PStack.h

Go to the documentation of this file.

#ifndef _PSTACK
#define _PSTACK

#include "global.h"
#include "MercuryVector.h"
#include "MercuryString.h"


class PSElement
{
public:
    PSElement( const MString & sI ) { data.dataS = new MString(sI); type = STRING; }
    PSElement( const char * sI ) { data.dataS = new MString(sI); type = STRING; }
    PSElement( const char * sI, int Length ) { data.dataS = new MString; data.dataS->append( sI, Length ); type = STRING; }
    PSElement( float fI ) { data.f = fI; type = FLOAT; }
    PSElement( int iI ) { data.l = iI; type = INTEGER; }
    PSElement( unsigned iI ) { data.l = iI; type = INTEGER; }
    PSElement( bool bI ) { data.b = bI; type = BOOL; }
    PSElement( void * vI ) { data.v = vI; type = USERDATA; }
    PSElement( void ) { type = NIL; }

    PSElement( const PSElement & RHS ) { data = RHS.data; type = RHS.type; if ( type == STRING ) data.dataS = new MString( *RHS.data.dataS ); }
    PSElement & operator = ( const PSElement & RHS ) { data = RHS.data; type = RHS.type; if ( type == STRING ) data.dataS = new MString( *RHS.data.dataS ); return *this; }

    ~PSElement() { if ( type == STRING ) delete data.dataS; }

    MString GetValueS() const;
    int     GetValueI() const;
    float   GetValueF() const;
    bool    GetValueB() const;
    void *  GetValueV() const;

    inline operator MString() const { return GetValueS(); }
    inline operator int() const { return GetValueI(); }
    inline operator float() const { return GetValueF(); }
    inline operator bool() const { return GetValueB(); }
    inline operator void*() const { return GetValueV(); }

    bool    GetValueS( MString & ret );
    bool    GetValueI( long & ret );
    bool    GetValueF( float & ret );
    bool    GetValueB( bool & ret );
    bool    GetValueV( void * & ret );

    enum ParmType
    {
        NIL = 0,
        BOOL,
        FLOAT,  //In LUA, float == NUMBER
        INTEGER,
        STRING,
        PARAMETER,
        USERDATA,
    };

    ParmType    GetType() const;
    void        ForceType( ParmType tI ) { type = tI; } 
    PSElement( ParmType tI ) { type = tI; }

    PSElement Operate( const MString & sOperator, const PSElement & pRHS );

    void    SetValueF( const float fToSet ) { data.f = fToSet; }
private:
    ParmType type;
    union ParmData
    {
        float   f;
        long    l;
        bool    b;
        void *  v;
        MString * dataS;
    } data;
};

class PStack
{
public:
    PStack( ) { };
    PStack( const char * sIn, int iMaxLength = 32767 );
    PStack( PSElement p1 );
    PStack( PSElement p1, PSElement p2 );
    PStack( PSElement p1, PSElement p2, PSElement p3 );
    PStack( PSElement p1, PSElement p2, PSElement p3, PSElement p4 );
    ~PStack();

    void PushItem( const PSElement & in );
    void PushItemBack( const PSElement & in );
    bool PopItem( PSElement & out );
    PSElement PopItem();
    bool PeekItem( PSElement & out );
    const PSElement& PeekItem( unsigned int iAhead = 0 ) const;
    inline const PSElement& operator[] ( unsigned int iAhead ) const { return PeekItem(iAhead); }
    void Clear() { m_stack.clear(); }

    inline unsigned int GetSize() const { return m_stack.size(); }
private:
    MVector< PSElement > m_stack;
};

//Managed PStacks, in general this should only be used by applications that cannot use C++ classes.
int HGEXPORT CreateMPStack();
int HGEXPORT GetMPStackSize( unsigned int iMPS );
const char * HGEXPORT GetMPStackAtS(  unsigned int iMPS, unsigned int iPL );    //Returns reference (DO NOT DELETE)
int HGEXPORT GetMPStackAtI(  unsigned int iMPS, unsigned int iPL );
float HGEXPORT GetMPStackAtF(  unsigned int iMPS, unsigned int iPL );
void HGEXPORT PushMPStackBackS(  unsigned int iMPS, const char * s );
void HGEXPORT PushMPStackBackI(  unsigned int iMPS, int i );
void HGEXPORT PushMPStackBackF(  unsigned int iMPS, float f );
void HGEXPORT DeleteMPStack(  unsigned int iMPS );
void HGEXPORT FlushMPStacks();
//Utility
PStack * GetMPStack(  unsigned int iMPS );

#endif
/* 
 * Copyright (c) 2006 Charles Lohr
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met:
 *  -   Redistributions of source code must retain the above
 *      copyright notice, this list of conditions and the following disclaimer.
 *  -   Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in
 *      the documentation and/or other materials provided with the distribution.
 *  -   Neither the name of the Mercury Engine nor the names of its
 *      contributors may be used to endorse or promote products derived from
 *      this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

---

Hosted by