PStack.cpp

Go to the documentation of this file.

#include "MercuryUtil.h"
#include "PStack.h"
#include "MercuryLog.h"

static PSElement NILElement;

MString PSElement::GetValueS( ) const
{
    if ( type == STRING )
        return *data.dataS;
    else if ( type == INTEGER )
        return ssprintf( "%li",data.l );
    else if ( type == FLOAT )
        return ssprintf( "%f",data.f );
    else if ( type == BOOL )
        return ssprintf( "%d",data.b );
    else if ( type == NIL )
        return "NIL";
    else
        return "";
}

bool PSElement::GetValueS( MString & ret )
{
    if ( type == STRING )
        ret = *data.dataS;
    else if ( type == INTEGER )
        ret = ssprintf( "%li",data.l );
    else if ( type == FLOAT )
        ret = ssprintf( "%f",data.f );
    else if ( type == BOOL )
        ret = ssprintf( "%d",data.b );
    else if ( type == NIL )
        ret = "NIL";
    else
        return false;
    return true;
}

int PSElement::GetValueI( ) const
{
    if ( type == INTEGER || type == PARAMETER )
        return data.l;
    else if ( type == FLOAT )
        return int(data.f);
    else if ( type == BOOL )
        return data.b;
    else if ( type == STRING )
        return atoi( data.dataS->c_str() );
    else
        return 0;
}

bool PSElement::GetValueI( long &ret )
{
    if ( type == INTEGER || type == PARAMETER )
    {
        ret = data.l;
        return true;
    }
    else if ( type == FLOAT )
    {
        ret = type;
        return true;
    }
    else if ( type == BOOL )
    {
        ret = data.b;
        return true;
    }
        return false;
}

float PSElement::GetValueF( ) const
{
    if ( type == INTEGER )
        return float(data.l);
    else if ( type == FLOAT )
        return data.f;
    else if ( type == STRING )
        return float(atof(data.dataS->c_str()));
    else
        return 0;
}

bool PSElement::GetValueF( float & ret )
{
    if ( type == INTEGER )
    {
        ret = float(data.l);
        return true;
    }
    else if ( type == FLOAT )
    {
        ret = data.f;
        return true;
    }
    else if ( type == STRING )
    {
        ret = float(atof(data.dataS->c_str()));
        return true;
    }
    else
        return false;
}

bool PSElement::GetValueB( ) const
{
    if ( type == BOOL )
        return data.b;
    if ( type == INTEGER )
        return data.l!=0;
    else if ( type == FLOAT )
        return data.f!=0;
    else
        return 0;
}

bool PSElement::GetValueB( bool & ret )
{
    if ( type == BOOL )
    {
        ret = data.b;
        return true;
    } 
    else if ( type == INTEGER )
    {
        ret = data.l!=0;
        return true;
    }
    else if ( type == FLOAT )
    {
        ret = data.f!=0;
        return true;
    }
    else
        return false;
}

void * PSElement::GetValueV( ) const
{
    if ( type == USERDATA )
        return data.v;
    else
        return NULL;
}

bool PSElement::GetValueV( void * & ret )
{
    if ( type == USERDATA )
    {
        ret = data.v;
        return true;
    } else
        return false;
}

PSElement::ParmType PSElement::GetType() const
{
    return type;
}

PStack::PStack( const char * sIn, int iMaxLength )
{
    if ( iMaxLength <= 0 )
        return;

    int iCtr = 0;
    int iParenDepth = 0;
    char cCurrent = sIn[iCtr];
    
    MString sCurrent;
    PSElement::ParmType pt = PSElement::FLOAT;
    bool bInString = false;

    while ( ( cCurrent != '\0' ) && ( iCtr < iMaxLength ) )
    {
        if ( cCurrent == '\"' )
        {
            pt = PSElement::STRING;
            bInString = !bInString;
            iCtr++;
            cCurrent = sIn[iCtr];
        }

        if ( bInString )
            sCurrent += cCurrent;
        else
            switch ( cCurrent )
            {
            case ',':
                if ( iParenDepth > 0 )
                {
                    sCurrent += cCurrent;
                    break;
                }
                if ( pt == PSElement::STRING )
                    PushItemBack( PSElement( sCurrent ) );
                else if ( pt == PSElement::FLOAT )
                    PushItemBack( PSElement( float( atof( sCurrent.c_str() ) ) ) );
                else
                {
                    PSElement PM = PSElement( atoi( sCurrent.c_str() ) );
                    PM.ForceType( pt );
                    PushItemBack( PM );
                }
                pt = PSElement::FLOAT;
                sCurrent = "";
                break;
            case '(':
                iParenDepth++;
                break;
            case ')':
                iParenDepth--;
                break;
            case '%':
                if ( iParenDepth > 0 )
                {
                    sCurrent += cCurrent;
                    break;
                }
                if ( sCurrent.empty() )
                    pt = PSElement::PARAMETER;
                break;
            default:
                sCurrent += cCurrent;
            }
        iCtr++;
        cCurrent = sIn[iCtr];
    }
    if ( pt == PSElement::STRING )
        PushItemBack( PSElement( sCurrent ) );
    else if ( pt == PSElement::FLOAT )
        PushItemBack( PSElement( float( atof( sCurrent.c_str() ) ) ) );
    else
    {
        PSElement PM = PSElement( atoi( sCurrent.c_str() ) );
        PM.ForceType( pt );
        PushItemBack( PM );
    }
}

PStack::PStack( PSElement p1 )
{
    PushItem( p1 );
}

PStack::PStack( PSElement p1, PSElement p2 )
{
    PushItem( p2 );
    PushItem( p1 );
}

PStack::PStack( PSElement p1, PSElement p2, PSElement p3 )
{
    PushItem( p3 );
    PushItem( p2 );
    PushItem( p1 );
}

PStack::PStack( PSElement p1, PSElement p2, PSElement p3, PSElement p4 )
{
    PushItem( p4 );
    PushItem( p3 );
    PushItem( p2 );
    PushItem( p1 );
}

PStack::~PStack()
{
}

void PStack::PushItem(const PSElement & in )
{
    m_stack.insert( 0, in );//push_front( in );
}

void PStack::PushItemBack(const PSElement & in )
{
    m_stack.push_back( in );
}

bool PStack::PopItem( PSElement & out )
{
    if ( m_stack.empty() )
        return false;

    out = m_stack[0];
    //m_stack.pop_front();
    m_stack.remove( 0 );
    return true;
}

bool PStack::PeekItem( PSElement & out )
{
    if ( m_stack.empty() )
        return false;
    out = m_stack[0];
    return true;
}

PSElement PStack::PopItem()
{
    if ( m_stack.empty() )
        return NILElement;
    PSElement ret = m_stack[0];
    m_stack.remove( 0 );
    return ret;
}

const PSElement& PStack::PeekItem( unsigned int iAhead ) const
{
    if (iAhead < m_stack.size())
        return m_stack[iAhead];
    return NILElement;
}


MVector< PStack * > g_vMPStacks;

int HGEXPORT CreateMPStack()
{
    unsigned i;
    for( i = 0; i < g_vMPStacks.size(); i++ )
        if ( !g_vMPStacks[i] )
            break;

    if ( i == g_vMPStacks.size() )
        g_vMPStacks.push_back( new PStack );
    else
        g_vMPStacks[i] = new PStack;

    g_vMPStacks[i]->Clear();

    return i;
}

int HGEXPORT GetMPStackSize(  unsigned int iMPS )
{
    if ( iMPS >= g_vMPStacks.size() )
        return -1;
    else if ( g_vMPStacks[iMPS] )
        return g_vMPStacks[iMPS]->GetSize();
    else
        return -1;
}

const char * HGEXPORT GetMPStackAtS(  unsigned int iMPS,  unsigned int iPL )
{
    if ( iMPS >= g_vMPStacks.size() )
        return NULL;
    else if ( !g_vMPStacks[ iMPS ] )
        return NULL;
    else if ( iPL >= g_vMPStacks[ iMPS ]->GetSize() )
        return NULL;
    return g_vMPStacks[ iMPS ]->PeekItem( iPL ).GetValueS().c_str();
}

int HGEXPORT GetMPStackAtI(  unsigned int iMPS,  unsigned int iPL )
{
    if ( iMPS >= g_vMPStacks.size() )
        return 0;
    else if ( !g_vMPStacks[ iMPS ] )
        return 0;
    else if ( iPL >= g_vMPStacks[ iMPS ]->GetSize() )
        return 0;
    return g_vMPStacks[ iMPS ]->PeekItem( iPL ).GetValueI();
}

float HGEXPORT GetMPStackAtF(  unsigned int iMPS,  unsigned int iPL )
{
    if ( iMPS >= g_vMPStacks.size() )
        return (float)NULL;
    else if ( !g_vMPStacks[ iMPS ] )
        return (float)NULL;
    else if ( iPL >= g_vMPStacks[ iMPS ]->GetSize() )
        return (float)NULL;
    return g_vMPStacks[ iMPS ]->PeekItem( iPL ).GetValueF();
}

void HGEXPORT PushMPStackBackS( unsigned int iMPS, const char * s )
{
    if ( iMPS >= g_vMPStacks.size() )
        return;
    else if ( !g_vMPStacks[ iMPS ] )
        return;
    g_vMPStacks[iMPS]->PushItem( PSElement( MString( s ) ) );
}

void HGEXPORT PushMPStackBackI( unsigned int iMPS, int i )
{
    if ( iMPS >= g_vMPStacks.size() )
        return;
    else if ( !g_vMPStacks[ iMPS ] )
        return;
    g_vMPStacks[iMPS]->PushItem( PSElement( i ) );
}

void HGEXPORT PushMPStackBackF( unsigned int iMPS, float f )
{
    if ( iMPS >= g_vMPStacks.size() )
        return;
    else if ( !g_vMPStacks[ iMPS ] )
        return;
    g_vMPStacks[iMPS]->PushItem( PSElement( f ) );
}

void HGEXPORT DeleteMPStack( unsigned int iMPS )
{
    SAFE_DELETE( g_vMPStacks[iMPS] );
    g_vMPStacks[iMPS] = NULL;   //For good measure, if it is not set to null, we WILL crash.
}

void HGEXPORT FlushMPStacks()
{
    for( unsigned i = 0; i < g_vMPStacks.size(); i++ )
        if( g_vMPStacks[i] )
            SAFE_DELETE( g_vMPStacks[i] );
}

PStack * GetMPStack( unsigned int iMPS )
{
    if ( iMPS >= g_vMPStacks.size() )
        return NULL;
    else if ( !g_vMPStacks[ iMPS ] )
        return NULL;
    return g_vMPStacks[iMPS];
}




PSElement PSElement::Operate( const MString & sOperator, const PSElement & pRHS )
{
    PSElement ret;
    if( sOperator.length() == 0 )
    {
        LOG.Warn( "NULL Operator used!" );
        return NILElement;
    }

    char sFirstChar = sOperator.c_str()[0];
    char sSecondChar = sOperator.c_str()[1];
    long lLength = sOperator.length();

    if( sFirstChar <= '.' )
    {
        if( sFirstChar == '!' )
        {
            if( sSecondChar == '=' && lLength == 2 )
            {
                ret.type = BOOL;
                ret.data.b = ( GetValueS().compare( pRHS.GetValueS() ) != 0 );
                return ret;
            }
            if( lLength == 1 )
            {
                ret.type = BOOL;
                ret.data.b = !GetValueB();
                return ret;
            }
        }
        if( sFirstChar == '*' )
        {
            if( sSecondChar == '=' && lLength == 2 )
            {
                if( ( GetType() != INTEGER && GetType() != FLOAT ) || 
                    ( pRHS.GetType() != INTEGER && pRHS.GetType() != FLOAT ) )
                {
                    LOG.Warn( "Incompatible types for operator *" );
                    return NILElement;
                }
                if( GetType() == FLOAT || pRHS.GetType() == FLOAT )
                {
                    data.f = GetValueF() * pRHS.GetValueF();
                    type = FLOAT;
                } else {
                    data.l = GetValueI() * pRHS.GetValueI();
                    type = INTEGER;
                }
                return (*this);
            } else if( lLength == 1 )
            {
                if( ( GetType() != INTEGER && GetType() != FLOAT ) || 
                    ( pRHS.GetType() != INTEGER && pRHS.GetType() != FLOAT ) )
                {
                    LOG.Warn( "Incompatible types for operator *" );
                    return NILElement;
                }
                if( GetType() == FLOAT || pRHS.GetType() == FLOAT )
                {
                    ret.data.f = GetValueF() * pRHS.GetValueF();
                    ret.type = FLOAT;
                } else {
                    ret.data.l = GetValueI() * pRHS.GetValueI();
                    ret.type = INTEGER;
                }
                return ret;
            }
        }
        if( sFirstChar == '+' )
        {
            if( sSecondChar == '=' && lLength == 2 )
            {
                if( ( GetType() != INTEGER && GetType() != FLOAT ) || 
                    ( pRHS.GetType() != INTEGER && pRHS.GetType() != FLOAT ) )
                {
                    LOG.Warn( "Incompatible types for operator +" );
                    return NILElement;
                }
                if( GetType() == FLOAT || pRHS.GetType() == FLOAT )
                {
                    data.f = GetValueF() + pRHS.GetValueF();
                    type = FLOAT;
                } else {
                    data.l = GetValueI() + pRHS.GetValueI();
                    type = INTEGER;
                }
                return (*this);
            } else if( lLength == 1 )
            {
                if( ( GetType() != INTEGER && GetType() != FLOAT ) || 
                    ( pRHS.GetType() != INTEGER && pRHS.GetType() != FLOAT ) )
                {
                    LOG.Warn( "Incompatible types for operator +" );
                    return NILElement;
                }
                if( GetType() == FLOAT || pRHS.GetType() == FLOAT )
                {
                    ret.data.f = GetValueF() + pRHS.GetValueF();
                    ret.type = FLOAT;
                } else {
                    ret.data.l = GetValueI() + pRHS.GetValueI();
                    ret.type = INTEGER;
                }
                return ret;
            }       
        }
        if( sFirstChar == '-' )
        {
            if( sSecondChar == '=' && lLength == 2 )
            {
                if( ( GetType() != INTEGER && GetType() != FLOAT ) || 
                    ( pRHS.GetType() != INTEGER && pRHS.GetType() != FLOAT ) )
                {
                    LOG.Warn( "Incompatible types for operator -" );
                    return NILElement;
                }
                if( GetType() == FLOAT || pRHS.GetType() == FLOAT )
                {
                    data.f = GetValueF() - pRHS.GetValueF();
                    type = FLOAT;
                } else {
                    data.l = GetValueI() - pRHS.GetValueI();
                    type = INTEGER;
                }
                return (*this);
            } else if( lLength == 1 )
            {
                if( ( GetType() != INTEGER && GetType() != FLOAT ) || 
                    ( pRHS.GetType() != INTEGER && pRHS.GetType() != FLOAT ) )
                {
                    LOG.Warn( "Incompatible types for operator -" );
                    return NILElement;
                }
                if( GetType() == FLOAT || pRHS.GetType() == FLOAT )
                {
                    ret.data.f = GetValueF() - pRHS.GetValueF();
                    ret.type = FLOAT;
                } else {
                    ret.data.l = GetValueI() - pRHS.GetValueI();
                    ret.type = INTEGER;
                }
                return ret;
            }       
        }
        if( sFirstChar == '.' )
        {
            if( sSecondChar == '=' && lLength == 2 )
            {
                if( type == STRING )
                    delete data.dataS;
                type = STRING;
                data.dataS = new MString( GetValueS() + pRHS.GetValueS() );
                return (*this);

            } else if( lLength == 1 )
            {
                if( ret.type == STRING )
                    delete data.dataS;
                ret.type = STRING;
                ret.data.dataS = new MString( GetValueS() + pRHS.GetValueS() );
                return ret;
            }   
        }
    } else {
        if( sFirstChar == '=' )
        {
            if( sSecondChar == '=' && lLength == 2 )
            {
                ret.type = BOOL;
                ret.data.b = ( GetValueS().compare( pRHS.GetValueS() ) == 0 );
                return ret;
            }
            if( lLength == 1 )
            {
                type = pRHS.type;
                if( pRHS.type == STRING )
                {
                    if( type == STRING )
                        *data.dataS = *pRHS.data.dataS;
                    else
                        data.dataS = new MString( *pRHS.data.dataS );
                }
                else
                    data = pRHS.data;
                return (*this);
            }
        }
        if( sFirstChar == '>' )
        {
            if( sSecondChar == '=' && lLength == 2 )
            {
                ret.type = BOOL;
                ret.data.b = GetValueF() >= pRHS.GetValueF();
                return ret;
            }
            if( lLength == 1 )
            {
                ret.type = BOOL;
                ret.data.b = GetValueF() > pRHS.GetValueF();
                return ret;
            }
        }
        if( sFirstChar == '<' )
        {
            if( sSecondChar == '=' && lLength == 2 )
            {
                ret.type = BOOL;
                ret.data.b = GetValueF() <= pRHS.GetValueF();
                return ret; 
            }
            if( lLength == 1 )
            {
                ret.type = BOOL;
                ret.data.b = GetValueF() < pRHS.GetValueF();
                return ret;
            }
        }
        if( sFirstChar == '/' )
        {
            if( sSecondChar == '=' && lLength == 2 )
            {
                if( ( GetType() != INTEGER && GetType() != FLOAT ) || 
                    ( pRHS.GetType() != INTEGER && pRHS.GetType() != FLOAT ) )
                {
                    LOG.Warn( "Incompatible types for operator /" );
                    return NILElement;
                }
                if( GetType() == FLOAT || pRHS.GetType() == FLOAT )
                {
                    data.f = GetValueF() / pRHS.GetValueF();
                    type = FLOAT;
                } else {
                    data.l = GetValueI() / pRHS.GetValueI();
                    type = INTEGER;
                }
                return (*this);
            } else if( lLength == 1 )
            {
                if( ( GetType() != INTEGER && GetType() != FLOAT ) || 
                    ( pRHS.GetType() != INTEGER && pRHS.GetType() != FLOAT ) )
                {
                    LOG.Warn( "Incompatible types for operator /" );
                    return NILElement;
                }
                if( GetType() == FLOAT || pRHS.GetType() == FLOAT )
                {
                    ret.data.f = GetValueF() / pRHS.GetValueF();
                    ret.type = FLOAT;
                } else {
                    ret.data.l = GetValueI() / pRHS.GetValueI();
                    ret.type = INTEGER;
                }
                return ret;
            }
        }
    }

    LOG.Warn( "Operator '" + sOperator + "' unknown." );
    return NILElement;
}






/* 
 * 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 <ORGANIZATION> 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