doxygen/html/_parser_8cpp_source.html

 /*  Project STARS

-     John DiCamillo Software Consulting

-     Copyright � 1997-2004. All Rights Reserved.

-

-     SUBSYSTEM:    parser

-     FILE:         parser.cpp

-     AUTHOR:       John DiCamillo

-

-

-     OVERVIEW

-     ========

-     Implementation of the generic Parser class

- */

-

- #include "MemDebug.h"

- #include "reader.h"

- #include "token.h"

- #include "parser.h"

- #include <stdio.h>

- #include <stdlib.h>

-

- enum KEYS { KEY_TRUE, KEY_FALSE, KEY_DEF, KEY_MINUS };

-

- void Print(const char* fmt, ...);

-

- static int dump_tokens = 0;

-

- // +-------------------------------------------------------------------+

-

- Term* error(char* msg, const Token& token)

- {

-    static char buf[1024];

-    sprintf_s(buf, " near '%s' in line %d.", (const char*) token.symbol(), token.line());

-

-    return error(msg, buf);

- }

-

- // +-------------------------------------------------------------------+

-

- Parser::Parser(Reader* r)

- {

-    reader = r ? r : new(__FILE__, __LINE__) ConsoleReader;

-    lexer  = new(__FILE__, __LINE__) Scanner(reader);

-

-    Token::addKey("true",   KEY_TRUE);

-    Token::addKey("false",  KEY_FALSE);

-    Token::addKey(":",      KEY_DEF);

-    Token::addKey("-",      KEY_MINUS);

- }

-

- Parser::~Parser()

- {

-    delete lexer;

-    delete reader;

-    //Token::close();

- }

-

- Term*

- Parser::ParseTerm()

- {

-    Term* t = ParseTermBase();

-    if (t == 0) return t;

-

-    Term* t2 = ParseTermRest(t);

-

-    return t2;

- }

-

- Term*

- Parser::ParseTermRest(Term* base)

- {

-    Token    t = lexer->Get();

-

-    switch (t.type()) {

-    default:

-       lexer->PutBack();

-       return base;

-

-    case Token::StringLiteral: {

-          // concatenate adjacent string literal tokens:

-          TermText* text  = base->isText();

-          if (text) {

-             TermText* base2 = new(__FILE__, __LINE__) TermText(text->value() + t.symbol()(1, t.symbol().length()-2));

-             delete base;

-             return ParseTermRest(base2);

-          }

-          else {

-             lexer->PutBack();

-          }

-       }

-       break;

-

-    case Token::Keyword:

-       switch (t.key()) {

-       case KEY_DEF:

-          if (base->isText())

-             return new(__FILE__, __LINE__) TermDef(base->isText(), ParseTerm());

-          else

-             return error("(Parse) illegal lhs in def", t);

-

-       default:

-          lexer->PutBack();

-          return base;

-       }

-       break;

-    }

-

-    return base;

- }

-

- static int xtol(const char* p)

- {

-    int n = 0;

-

-    while (*p) {

-       char digit = *p++;

-       n *= 16;

-

-       if (digit >= '0' && digit <= '9')

-          n += digit - '0';

-

-       else if (digit >= 'a' && digit <= 'f')

-          n += digit - 'a' + 10;

-

-       else if (digit >= 'A' && digit <= 'F')

-          n += digit - 'A' + 10;

-    }

-

-    return n;

- }

-

- Term*

- Parser::ParseTermBase()

- {

-    Token    t = lexer->Get();

-    int      n = 0;

-    double   d = 0.0;

-

-    switch (t.type()) {

-    case Token::IntLiteral: {

-       if (dump_tokens)

-          Print("%s", t.symbol().data());

-

-       char nstr[256], *p = nstr;

-       for (int i = 0; i < (int) t.symbol().length(); i++)

-          if (t.symbol()[i] != '_')

-             *p++ = t.symbol()[i];

-       *p++ = '\0';

-

-       // handle hex notation:

-       if (nstr[1] == 'x')

-          n = xtol(nstr+2);

-

-       else

-          n = atol(nstr);

-

-       return new(__FILE__, __LINE__) TermNumber(n);

-       }

-

-    case Token::FloatLiteral: {

-       if (dump_tokens)

-          Print("%s", t.symbol().data());

-

-       char nstr[256], *p = nstr;

-       for (int i = 0; i < (int) t.symbol().length(); i++)

-          if (t.symbol()[i] != '_')

-             *p++ = t.symbol()[i];

-       *p++ = '\0';

-

-       d = atof(nstr);

-       return new(__FILE__, __LINE__) TermNumber(d);

-       }

-

-    case Token::StringLiteral:

-       if (dump_tokens)

-          Print("%s", t.symbol().data());

-

-       return new(__FILE__, __LINE__) TermText(t.symbol()(1, t.symbol().length()-2));

-

-    case Token::AlphaIdent:

-       if (dump_tokens)

-          Print("%s", t.symbol().data());

-

-       return new(__FILE__, __LINE__) TermText(t.symbol());

-

-    case Token::Keyword:

-       if (dump_tokens)

-          Print("%s", t.symbol().data());

-

-       switch (t.key()) {

-       case KEY_FALSE:   return new(__FILE__, __LINE__) TermBool(0);

-       case KEY_TRUE:    return new(__FILE__, __LINE__) TermBool(1);

-

-       case KEY_MINUS: {

-             Token next = lexer->Get();

-             if (next.type() == Token::IntLiteral) {

-                if (dump_tokens)

-                   Print("%s", next.symbol().data());

-

-                char nstr[256], *p = nstr;

-                for (int i = 0; i < (int) next.symbol().length(); i++)

-                   if (next.symbol()[i] != '_')

-                      *p++ = next.symbol()[i];

-                *p++ = '\0';

-

-                n = -1 * atol(nstr);

-                return new(__FILE__, __LINE__) TermNumber(n);

-             }

-             else if (next.type() == Token::FloatLiteral) {

-                if (dump_tokens)

-                   Print("%s", next.symbol().data());

-

-                char nstr[256], *p = nstr;

-                for (int i = 0; i < (int) next.symbol().length(); i++)

-                   if (next.symbol()[i] != '_')

-                      *p++ = next.symbol()[i];

-                *p++ = '\0';

-

-                d = -1.0 * atof(nstr);

-                return new(__FILE__, __LINE__) TermNumber(d);

-             }

-             else {

-                lexer->PutBack();

-                return error("(Parse) illegal token '-': number expected", next);

-             }

-          }

-          break;

-

-       default:

-          lexer->PutBack();

-          return 0;

-       }

-

-    case Token::LParen:  return ParseArray();

-

-    case Token::LBrace:  return ParseStruct();

-

-    case Token::CharLiteral:

-       return error("(Parse) illegal token ", t);

-

-    default:

-       lexer->PutBack();

-       return 0;

-    }

- }

-

- TermArray*

- Parser::ParseArray()

- {

-    TermList*   elems = ParseTermList(0);

-    Token       end = lexer->Get();

-

-    if (end.type() != Token::RParen)

-       return (TermArray*) error("(Parse) ')' missing in array-decl", end);

-

-    return new(__FILE__, __LINE__) TermArray(elems);

- }

-

- TermStruct*

- Parser::ParseStruct()

- {

-    TermList*   elems = ParseTermList(1);

-    Token       end = lexer->Get();

-

-    if (end.type() != Token::RBrace)

-       return (TermStruct*) error("(Parse) '}' missing in struct", end);

-

-    return new(__FILE__, __LINE__) TermStruct(elems);

- }

-

- TermList*

- Parser::ParseTermList(int for_struct)

- {

-    TermList*   tlist = new(__FILE__, __LINE__) TermList;

-

-    Term* term = ParseTerm();

-    while (term) {

-       if (for_struct && !term->isDef()) {

-          return (TermList*) error("(Parse) non-definition term in struct");

-       }

-       else if (!for_struct && term->isDef()) {

-          return (TermList*) error("(Parse) illegal definition in array");

-       }

-

-       tlist->append(term);

-       Token t = lexer->Get();

-

-       /*** OLD WAY: COMMA SEPARATORS REQUIRED ***

-       if (t.type() != Token::Comma) {

-          lexer->PutBack();

-          term = 0;

-       }

-       else

-          term = ParseTerm();

-       /*******************************************/

-

-       // NEW WAY: COMMA SEPARATORS OPTIONAL:

-       if (t.type() != Token::Comma) {

-          lexer->PutBack();

-       }

-

-       term = ParseTerm();

-    }

-

-    return tlist;

- }

-

-

-

-