InputParser.cpp

Go to the documentation of this file.

// Parser.cpp: implementation of the CParser class.
/*
 * Copyright (c) 1996-2000 Erwin Coumans <coockie@acm.org>
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  Erwin Coumans makes no
 * representations about the suitability of this software for any
 * purpose.  It is provided "as is" without express or implied warranty.
 *
 */

#include <stdlib.h>

#include "MT_assert.h"

#include "Value.h"
#include "InputParser.h"
#include "ErrorValue.h"
#include "IntValue.h"
#include "StringValue.h"
#include "FloatValue.h"
#include "BoolValue.h"
#include "EmptyValue.h"
#include "ConstExpr.h"
#include "Operator2Expr.h"
#include "Operator1Expr.h"
#include "IdentifierExpr.h"

// this is disable at the moment, I expected a memleak from it, but the error-cleanup was the reason
// well, looks we don't need it anyway, until maybe the Curved Surfaces are integrated into CSG 
// cool things like (IF(LOD==1,CCurvedValue,IF(LOD==2,CCurvedValue2)) etc...
#include "IfExpr.h" 

#if (defined(WIN32) || defined(WIN64)) && !defined(FREE_WINDOWS)
#define strcasecmp      _stricmp

#ifndef strtoll
#define strtoll         _strtoi64
#endif

#endif /* Def WIN32 or Def WIN64 */

#define NUM_PRIORITY 6

// Construction/Destruction

CParser::CParser() : m_identifierContext(NULL)
{
}



CParser::~CParser()
{
        if (m_identifierContext)
                m_identifierContext->Release();
}



void CParser::ScanError(const char *str)
{
        // sets the global variable errmsg to an errormessage with
        // contents str, appending if it already exists
        //      AfxMessageBox("Parse Error:"+str,MB_ICONERROR);
        if (errmsg)
                errmsg = new COperator2Expr(VALUE_ADD_OPERATOR, errmsg, Error(str));
        else
                errmsg = Error(str);

        sym = errorsym;
}



CExpression* CParser::Error(const char *str)
{
        // makes and returns a new CConstExpr filled with an CErrorValue
        // with string str
        //      AfxMessageBox("Error:"+str,MB_ICONERROR);
        return new CConstExpr(new CErrorValue(str));
}



void CParser::NextCh()
{
        // sets the global variable ch to the next character, if it exists
        // and increases the global variable chcount
        chcount++;

        if (chcount < text.Length())
                ch = text[chcount];
        else
                ch = 0x00;
}



void CParser::TermChar(char c)
{
        // generates an error if the next char isn't the specified char c,
        // otherwise, skip the char
        if(ch == c)
        {
                NextCh();
        }
        else
        {
                STR_String str;
                str.Format("Warning: %c expected\ncontinuing without it", c);
                trace(str);
        }
}



void CParser::DigRep()
{
        // changes the current character to the first character that
        // isn't a decimal
        while ((ch >= '0') && (ch <= '9'))
                NextCh();
}



void CParser::CharRep()
{
        // changes the current character to the first character that
        // isn't an alphanumeric character
        while (((ch >= '0') && (ch <= '9'))
                || ((ch >= 'a') && (ch <= 'z'))
                || ((ch >= 'A') && (ch <= 'Z'))
                || (ch == '.') || (ch == '_'))
                NextCh();
}



void CParser::GrabString(int start)
{
        // puts part of the input string into the global variable
        // const_as_string, from position start, to position chchount
        const_as_string = text.Mid(start, chcount-start);
}



void CParser::GrabRealString(int start)
{
        // works like GrabString but converting \\n to \n
        // puts part of the input string into the global variable
        // const_as_string, from position start, to position chchount

        int i;
        char tmpch;

        const_as_string = STR_String();
        for (i=start;i<chcount;i++) {
                tmpch= text[i];
                if ((tmpch =='\\') && (text[i+1] == 'n')){
                        tmpch = '\n';
                        i++;
                }
                const_as_string += tmpch;
        }
}



void CParser::NextSym()
{
        // sets the global variable sym to the next symbol, and
        // if it is an operator
        //   sets the global variable opkind to the kind of operator
        // if it is a constant
        //   sets the global variable constkind to the kind of operator
        // if it is a reference to a cell
        //   sets the global variable cellcoord to the kind of operator
        
        errmsg = NULL;
        while(ch == ' ' || ch == 0x9)
                NextCh();

        switch(ch)
        {
    case '(':
                sym = lbracksym; NextCh();
                break;
    case ')':
                sym = rbracksym; NextCh();
                break;
    case ',':
                sym = commasym; NextCh();
                break;
        case '%' :
                sym = opsym; opkind = OPmodulus; NextCh();
                break;
    case '+' :
                sym = opsym; opkind = OPplus; NextCh();
                break;
    case '-' :
                sym = opsym; opkind = OPminus; NextCh();
                break;
    case '*' :
                sym = opsym; opkind = OPtimes; NextCh();
                break;
    case '/' :
                sym = opsym; opkind = OPdivide; NextCh();
                break;
        case '&' :
                sym = opsym; opkind = OPand; NextCh(); TermChar('&');
                break;
        case '|' :
                sym = opsym; opkind = OPor; NextCh(); TermChar('|');
                break;
        case '=' :
                sym = opsym; opkind = OPequal; NextCh(); TermChar('=');
                break;
        case '!' :
                sym = opsym;
                NextCh();
                if (ch == '=')
                {
                        opkind = OPunequal;
                        NextCh();
                }
                else
                {
                        opkind = OPnot;
                }
                break;
        case '>':
                sym = opsym;
                NextCh();
                if (ch == '=')
                {
                        opkind = OPgreaterequal;
                        NextCh();
                }
                else
                {
                        opkind = OPgreater;
                }
                break;
        case '<':
                sym = opsym;
                NextCh();
                if (ch == '=') {
                        opkind = OPlessequal;
                        NextCh();
                } else {
                        opkind = OPless;
                }
                break;
    case '\"' : {
                int start;
                sym = constsym;
                constkind = stringtype;
                NextCh();
                start = chcount;
                while ((ch != '\"') && (ch != 0x0))
                        NextCh();
                GrabRealString(start);
                TermChar('\"'); // check for eol before '\"'
                break;
                                }
    case 0x0: sym = eolsym; break;
    default: 
                {
                        int start;
                        start = chcount;
                        DigRep();
                        if ((start != chcount) || (ch == '.')) { // number
                                sym = constsym;
                                if (ch == '.') {
                                        constkind = floattype;
                                        NextCh();
                                        DigRep();
                                }
                                else constkind = inttype;
                                if ((ch == 'e') || (ch == 'E')) {
                                        int mark;
                                        constkind = floattype;
                                        NextCh();
                                        if ((ch == '+') || (ch == '-')) NextCh();
                                        mark = chcount;
                                        DigRep();
                                        if (mark == chcount) {
                                                ScanError("Number expected after 'E'");
                                                return;
                                        }
                                }
                                GrabString(start);
                        } else if (((ch >= 'a') && (ch <= 'z'))
                                || ((ch >= 'A') && (ch <= 'Z')))
                        { // reserved word?
                                
                                start = chcount;
                                CharRep();
                                GrabString(start);
                                if (!strcasecmp(const_as_string, "SUM")) {
                                        sym = sumsym;
                                }
                                else if (!strcasecmp(const_as_string, "NOT")) {
                                        sym = opsym;
                                        opkind = OPnot;
                                }
                                else if (!strcasecmp(const_as_string, "AND")) {
                                        sym = opsym; opkind = OPand;
                                }
                                else if (!strcasecmp(const_as_string, "OR")) {
                                        sym = opsym; opkind = OPor;
                                }
                                else if (!strcasecmp(const_as_string, "IF"))
                                        sym = ifsym;
                                else if (!strcasecmp(const_as_string, "WHOMADE"))
                                        sym = whocodedsym;
                                else if (!strcasecmp(const_as_string, "FALSE")) {
                                        sym = constsym; constkind = booltype; boolvalue = false;
                                } else if (!strcasecmp(const_as_string, "TRUE")) {
                                        sym = constsym; constkind = booltype; boolvalue = true;
                                } else {
                                        sym = idsym;
                                        //STR_String str;
                                        //str.Format("'%s' makes no sense here", (const char*)funstr);
                                        //ScanError(str);
                                }
                        } else { // unknown symbol
                                STR_String str;
                                str.Format("Unexpected character '%c'", ch);
                                NextCh();
                                ScanError(str);
                                return;
                        }
                }
        }
}

#if 0
int CParser::MakeInt() {
        // returns the integer representation of the value in the global
        // variable const_as_string
        // pre: const_as_string contains only numercal chars
        return atoi(const_as_string);
}
#endif

STR_String CParser::Symbol2Str(int s) {
        // returns a string representation of of symbol s,
        // for use in Term when generating an error
        switch(s) {
    case errorsym: return "error";
    case lbracksym: return "(";
    case rbracksym: return ")";
    case commasym: return ",";
    case opsym: return "operator";
    case constsym: return "constant";
        case sumsym: return "SUM";
        case ifsym: return "IF";
        case whocodedsym: return "WHOMADE";
    case eolsym: return "end of line";
        case idsym: return "identifier";
    default: return "unknown";  // should not happen
        }
}

void CParser::Term(int s) {
        // generates an error if the next symbol isn't the specified symbol s
        // otherwise, skip the symbol
        if(s == sym) NextSym();
        else {
                STR_String msg;
                msg.Format("Warning: " + Symbol2Str(s) + " expected\ncontinuing without it");

//              AfxMessageBox(msg,MB_ICONERROR);

                trace(msg);
        }
}

int CParser::Priority(int optorkind) {
        // returns the priority of an operator
        // higher number means higher priority
        switch(optorkind) {
        case OPor: return 1;
        case OPand: return 2;
        case OPgreater:
        case OPless:
        case OPgreaterequal:
        case OPlessequal:
        case OPequal:
        case OPunequal: return 3;
    case OPplus:
    case OPminus: return 4;
        case OPmodulus:
    case OPtimes:
    case OPdivide: return 5;
        }
        MT_assert(false);
        return 0;      // should not happen
}

CExpression *CParser::Ex(int i) {
        // parses an expression in the imput, starting at priority i, and
        // returns an CExpression, containing the parsed input
        CExpression *e1 = NULL, *e2 = NULL;
        int opkind2;
        
        if (i < NUM_PRIORITY) {
                e1 = Ex(i + 1);
                while ((sym == opsym) && (Priority(opkind) == i)) {
                        opkind2 = opkind;
                        NextSym();
                        e2 = Ex(i + 1);
                        switch(opkind2) {
                        case OPmodulus: e1 = new COperator2Expr(VALUE_MOD_OPERATOR,e1, e2); break;
                        case OPplus: e1 = new COperator2Expr(VALUE_ADD_OPERATOR,e1, e2); break;
                        case OPminus: e1 = new COperator2Expr(VALUE_SUB_OPERATOR,e1, e2); break;
                        case OPtimes:   e1 = new COperator2Expr(VALUE_MUL_OPERATOR,e1, e2); break;
                        case OPdivide: e1 = new COperator2Expr(VALUE_DIV_OPERATOR,e1, e2); break;
                        case OPand: e1 = new COperator2Expr(VALUE_AND_OPERATOR,e1, e2); break;
                        case OPor: e1 = new COperator2Expr(VALUE_OR_OPERATOR,e1, e2); break;
                        case OPequal: e1 = new COperator2Expr(VALUE_EQL_OPERATOR,e1, e2); break;
                        case OPunequal: e1 = new COperator2Expr(VALUE_NEQ_OPERATOR,e1, e2); break;
                        case OPgreater: e1 = new COperator2Expr(VALUE_GRE_OPERATOR,e1, e2); break;
                        case OPless: e1 = new COperator2Expr(VALUE_LES_OPERATOR,e1, e2); break;
                        case OPgreaterequal: e1 = new COperator2Expr(VALUE_GEQ_OPERATOR,e1, e2); break;
                        case OPlessequal: e1 = new COperator2Expr(VALUE_LEQ_OPERATOR,e1, e2); break;
                        default: MT_assert(false);      break; // should not happen
                        }
                }
        } else if (i == NUM_PRIORITY) {
                if ((sym == opsym) 
                        && ( (opkind == OPminus) || (opkind == OPnot) || (opkind == OPplus) ) 
                        )
                {
                        NextSym();
                        switch(opkind) {
                        /* +1 is also a valid number! */
                        case OPplus: e1 = new COperator1Expr(VALUE_POS_OPERATOR, Ex(NUM_PRIORITY)); break;
                        case OPminus: e1 = new COperator1Expr(VALUE_NEG_OPERATOR, Ex(NUM_PRIORITY)); break;
                        case OPnot: e1 = new COperator1Expr(VALUE_NOT_OPERATOR, Ex(NUM_PRIORITY)); break;
                        default: {
                                                // should not happen
                                                e1 = Error("operator +, - or ! expected");
                                         }
                        }
                }
                else {
                        switch(sym) {
                        case constsym: {
                                switch(constkind) {
                                case booltype:
                                        e1 = new CConstExpr(new CBoolValue(boolvalue));
                                        break;
                                case inttype:
                                        {
                                                cInt temp;
                                                temp = strtoll(const_as_string, NULL, 10); /* atoi is for int only */
                                                e1 = new CConstExpr(new CIntValue(temp));
                                                break;
                                        }
                                case floattype:
                                        {
                                                double temp;
                                                temp = atof(const_as_string);
                                                e1 = new CConstExpr(new CFloatValue(temp));
                                                break;
                                        }
                                case stringtype:
                                        e1 = new CConstExpr(new CStringValue(const_as_string,""));
                                        break;
                                default :
                                        MT_assert(false);
                                        break;
                                }
                                NextSym();
                                break;
                                                   }
                        case lbracksym:
                                NextSym();
                                e1 = Ex(1);
                                Term(rbracksym);
                                break;
                        case ifsym:
                        {
                                CExpression *e3;
                                NextSym();
                                Term(lbracksym);
                                e1 = Ex(1);
                                Term(commasym);
                                e2 = Ex(1);
                                if (sym == commasym) {
                                        NextSym();
                                        e3 = Ex(1);
                                } else {
                                        e3 = new CConstExpr(new CEmptyValue());
                                }
                                Term(rbracksym);
                                e1 = new CIfExpr(e1, e2, e3);
                                break;
                        }
                        case idsym:
                                {
                                        e1 = new CIdentifierExpr(const_as_string,m_identifierContext);
                                        NextSym();
                                        
                                        break;
                                }
                        case errorsym:
                                {
                                        MT_assert(!e1);
                                        STR_String errtext="[no info]";
                                        if (errmsg)
                                        {
                                                CValue* errmsgval = errmsg->Calculate();
                                                errtext=errmsgval->GetText();
                                                errmsgval->Release();
                                        
                                                //e1 = Error(errmsg->Calculate()->GetText());//new CConstExpr(errmsg->Calculate());
                                                
                                                if ( !(errmsg->Release()) )
                                                {
                                                        errmsg=NULL;
                                                } else {
                                                        // does this happen ?
                                                        MT_assert ("does this happen");
                                                }
                                        }
                                        e1 = Error(errtext);

                                        break;                          
                                }
                        default:
                                NextSym();
                                //return Error("Expression expected");
                                MT_assert(!e1);
                                e1 = Error("Expression expected");
                        }
                }
        }
        return e1;
}

CExpression *CParser::Expr() {
        // parses an expression in the imput, and
        // returns an CExpression, containing the parsed input
        return Ex(1);
}

CExpression* CParser::ProcessText
(const char *intext) {
        
        // and parses the string in intext and returns it.
        
        
        CExpression* expr;
        text = intext;
        
        
        chcount = 0;    
        if (text.Length() == 0) {
                return NULL;
        }
        
        ch = text[0];
        /*if (ch != '=') {
        expr = new CConstExpr(new CStringValue(text));
        *dependant = deplist;
        return expr;
        } else 
        */
        //      NextCh();
        NextSym();
        expr = Expr();
        if (sym != eolsym) {
                CExpression* oldexpr = expr;
                expr = new COperator2Expr(VALUE_ADD_OPERATOR,
                        oldexpr, Error(STR_String("Extra characters after expression")));//new CConstExpr(new CErrorValue("Extra characters after expression")));
        }
        if (errmsg)
                errmsg->Release();
        
        return expr;
}



float CParser::GetFloat(STR_String& txt)
{
        // returns parsed text into a float
        // empty string returns -1
        
//      AfxMessageBox("parsed string="+txt);
        CValue* val=NULL;
        float result=-1;
//      String tmpstr;

        CExpression* expr = ProcessText(txt);
        if (expr) {
                val = expr->Calculate();
                result=(float)val->GetNumber();
                
                
        
                val->Release();
                expr->Release();
        }
//      tmpstr.Format("parseresult=%g",result);
//              AfxMessageBox(tmpstr);
        return result;
}

CValue* CParser::GetValue(STR_String& txt, bool bFallbackToText)
{
        // returns parsed text into a value, 
        // empty string returns NULL value !
        // if bFallbackToText then unparsed stuff is put into text
        
        CValue* result=NULL;
        CExpression* expr = ProcessText(txt);
        if (expr) {
                result = expr->Calculate();
                expr->Release();
        }
        if (result)
        {
                // if the parsed stuff lead to an errorvalue, don't return errors, just NULL
                if (result->IsError()) {
                        result->Release();
                        result=NULL;
                        if (bFallbackToText) {
                                if (txt.Length()>0)
                                {
                                        result = new CStringValue(txt,"");
                                }
                        }
                }
        }
        return result;
}

void CParser::SetContext(CValue* context)
{
        if (m_identifierContext)
        {
                m_identifierContext->Release();
        }
        m_identifierContext = context;
}