Web alhem.net

BaseParser.cpp

Go to the documentation of this file.

/*
Copyright (C) 2004  Anders Hedstrom

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/
#include <stdio.h>
#include <string>
#include <vector>
#include <map>
#include "Parse.h"
#include <assert.h>
#include <ctype.h>
#include "BaseParser.h"

#define DEB(x)



BaseParser::BaseParser()
:m_level(0)
,m_plevel(0)
,m_glevel(0)
,m_filename("")
,m_line(0)
,m_pos(0)
,the_ptr(0)
{
        *the_str = 0;

        m_word["class"] = Class;
        m_word["namespace"] = Namespace;
        m_word["using"] = Using;
        m_word["template"] = Template;
        m_word["friend"] = Friend;
        m_word["typedef"] = Typedef;
        m_word["virtual"] = Virtual;
        m_word["public"] = Public;
        m_word["protected"] = Protected;
        m_word["private"] = Private;
        m_word["const"] = Const;
        m_word["struct"] = Struct;
        m_word["enum"] = Enum;
}


BaseParser::~BaseParser()
{
}


int BaseParser::GetWord(const std::string &str)
{
        stringint_m::iterator it = m_word.begin();
        while (it != m_word.end())
        {
                std::string strm = (*it).first;
                if (!strcmp(str.c_str(),strm.c_str()))
                {
                        return (*it).second;
                }
                //
                it++;
        }
        return 0;
}


void BaseParser::preprocessor(std::string &val)
{
        Parse pa( (char *)val.c_str() );
        int line;
        char slask[200];

        strcpy(slask,pa.getword().c_str()); // '#'
        assert(*slask == '#');
        if (!strcmp(slask,"#"))
        {
                strcpy(slask,pa.getword().c_str()); // line
                if (isdigit(*slask))
                {
                        line = atoi(slask);
                        strcpy(slask,pa.getword().c_str()); // "filename"
                        if (*slask == 34)
                        {
                                slask[strlen(slask) - 1] = 0;
                                m_filename = (char *)(slask + 1);
                                m_line = line;
                        }
                }
        }
}


int BaseParser::ReadLine(FILE *fil)
{
        fgets(the_str,500,fil);
        m_line++;
        if (feof(fil))
                return 0;
        while (strlen(the_str) && (Cx == 13 || Cx == 10))
                Cx = 0;
        while (Cx == '\\') // continue
        {
                fgets(the_str + strlen(the_str) - 1,500,fil);
                m_line++;
                if (feof(fil))
                        return 0;
                while (strlen(the_str) && (Cx == 13 || Cx == 10))
                        Cx = 0;
        }
        the_ptr = 0;
        return 1;
}


int BaseParser::GetToken(FILE *fil,std::string &val)
{
        bool bWhitespace = false;
        while (C == ' ' || C == '\t')
        {
                bWhitespace = true;
                the_ptr++;
        }
        while (!C)
        {
                if (!ReadLine(fil))
                        return 0;
                if (C == '#')
                {
                        val = the_str;
                        C = 0;
                        return CPP;
                }
                while (C == ' ' || C == '\t')
                {
                        the_ptr++;
                }
                bWhitespace = true; // new line automatically adds a whitespace token
        }
        if (bWhitespace)
        {
                val = " ";
                return WHITESPACE;
        }
        m_pos = the_ptr; // where this token begins
        if (isdigit(C))
        {
                while (isdigit(C) || C == '.')
                {
                        val += C;
                        the_ptr++;
                }
                return NUMBER;
        }
        if (isalpha(C) || C == '_' || C == '~' || (C == ':' && C1 == ':' && (isalpha(C2) || C2 == '_')) )
        {
                if (C == '~')
                {
                        val += C;
                        the_ptr++;
                }
                while (isalnum(C) || C == '_' || (C == ':' && C1 == ':'))
                {
                        if (C == ':' && C1 == ':')
                        {
                                val += C;
                                the_ptr++;
                        }
                        val += C;
                        the_ptr++;
                }
                {
                        int id = GetWord(val);
                        if (id >= 256)
                        {
                                return id;
                        }
                }
                return IDENTIFIER;
        }
        if (C == '/' && C1 == '*')
        {
                while (C != '*' || C1 != '/')
                {
                        val += C;
                        the_ptr++;
                        while (!C)
                        {
                                if (!ReadLine(fil))
                                        return 0;
                                val += '\n';
                        }
                }
                val += C;
                the_ptr++;
                val += C;
                the_ptr++;
                val += '\n';
                return COMMENT;
        }
        if (C == '/' && C1 == '/')
        {
                val = (char *)(the_str + the_ptr);
                C = 0;
                val += '\n';
                return COMMENT;
        }
        if (C == 34)
        {
                val += C;
                the_ptr++;
                while (C != 34 && C)
                {
                        if (C == '\\') // escaping
                        {
                                val += C;
                                the_ptr++;
                        }
                        val += C;
                        the_ptr++;
                }
                if (C == 34)
                {
                        val += C;
                        the_ptr++;
                }
                else
                {
                        error("Unterminated string constant");
                }
                return STRING;
        }
        if (C == '\'')
        {
                val += C;
                the_ptr++;
                while (C != '\'' && C)
                {
                        if (C == '\\') // escaping
                        {
                                val += C;
                                the_ptr++;
                        }
                        val += C;
                        the_ptr++;
                }
                if (C == '\'')
                {
                        val += C;
                        the_ptr++;
                }
                else
                {
                        error("Unterminated char constant");
                }
                return CHAR;
        }
        // dbl chars
#define dblcheck(x1,x2,y) { \
        if (C == x1 && C1 == x2) \
        { \
                val = x1; \
                val += x2; \
                the_ptr += 2; \
                return y; \
        } \
}
        //
        dblcheck(':',':',CC);
        dblcheck('<','<',LTLT);
        dblcheck('>','>',GTGT);
        dblcheck('*','*',DPTR);
        dblcheck('<','=',LTEQ);
        dblcheck('!','=',NEQ);
        dblcheck('>','=',GTEQ);
        dblcheck('=','=',EQ);
        dblcheck('|','|',OR);
        dblcheck('&','&',AND);
        dblcheck('+','+',PP);
        dblcheck('-','-',MM);
        dblcheck('-','>',POINTER);
        // single char:
        val += C;
        if (C == '{')
        {
                m_level++;
        }
        if (C == '(')
                m_plevel++;
        if (C == '<')
                m_glevel++;
        return the_str[the_ptr++];
}


void BaseParser::error(const std::string &str)
{
DEB(    fprintf(stderr,"%s line %d: %s\n",m_currentfile.c_str(),m_line,str.c_str());)
}


void BaseParser::EndToken(char c)
{
        if (c == '}')
        {
                m_level--;
        }
        if (c == ')')
                m_plevel--;
        if (c == '>')
                m_glevel--;
}

---