Web alhem.net

MyParser.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 "Token.h"
#include "Statement.h"
#include "Scope.h"
#include "MyParser.h"
#include "dp.h"

#define DEB(x)



MyParser::MyParser(const std::string &path)
:BaseParser()
,m_path(path)
,m_stfilename("")
,m_stline(0)
,m_stpos(0)
,m_plevelm(0)
,m_extern(false)
{
}


MyParser::~MyParser()
{
}


// new parser
// create Token
// add to token_vec
// if ';' - statement end
// if '{' - scope begin
// if '}' - scope end
// that's it (well...)
// # <line> <file> <?>
// (use in sequence constructor or something like that)

Scope *MyParser::Parser(FILE *fil,const std::string &name)
{
        int c;
        std::string val;
        std::string strClass;
        bool append_next_statement = false;
        Scope *s = new Scope;
        Scope *current = s;

        for (;;)
        {
                val = "";
                c = GetToken(fil,val);
                if (!c) // eof
                {
                        break;
                }
                if (c == CPP)
                {
                        preprocessor( val );
                }
                switch (c)
                {
                case COMMENT:
                        if (!m_tokens.size())
                        {
                                AddToken(c,val);
                                //
                                Statement *s = new Statement(m_tokens);
                                // set file, line
                                s -> SetParent(current);
                                s -> SetFile(m_stfilename);
                                s -> SetLine(m_stline);
                                s -> SetPos(m_stpos);
                                s -> SetExtern(m_extern);
                                current -> Add(s);
                                //
                                while (m_tokens.size())
                                        m_tokens.erase(m_tokens.begin());
                                m_plevelm = m_plevel;
                        }
                        else
                        {
                                AddToken(c,val);
                        }
                        break;
                case ':': // public, protected, private, case
                        AddToken(c,val);
                        {
                                token_v::iterator it = m_tokens.begin();
                                Token *t = *it;
                                if (t &&
                                    t -> GetCode() != Class &&
                                    t -> GetCode() != Template)
                                {
                                        Statement *s = new Statement(m_tokens);
                                        // set file, line
                                        s -> SetParent(current);
                                        s -> SetFile(m_stfilename);
                                        s -> SetLine(m_stline);
                                        s -> SetPos(m_stpos);
                                        s -> SetExtern(m_extern);
                                        current -> Add(s);
                                        //
                                        while (m_tokens.size())
                                                m_tokens.erase(m_tokens.begin());
                                        m_plevelm = m_plevel;
                                }
                        }
                        break;
                case ';':
                        AddToken(c,val);
                        if (m_plevel == m_plevelm)
                        {
                                if (append_next_statement)
                                {
                                        current -> AddTrail(m_tokens);
                                        current = current -> GetParent();
                                        append_next_statement = false;
                                }
                                else
                                {
                                        Statement *s = new Statement(m_tokens);
                                        // set file, line
                                        s -> SetParent(current);
                                        s -> SetFile(m_stfilename);
                                        s -> SetLine(m_stline);
                                        s -> SetPos(m_stpos);
                                        s -> SetExtern(m_extern);
                                        current -> Add(s);
                                }
                                //
                                while (m_tokens.size())
                                        m_tokens.erase(m_tokens.begin());
                                m_plevelm = m_plevel;
                        }
                        break;
                case '{':
                        {
                                Scope *s = new Scope(m_tokens);
                                // set file, line
                                s -> SetParent(current);
                                s -> SetFile(m_stfilename);
                                s -> SetLine(m_stline);
                                s -> SetPos(m_stpos);
                                s -> SetExtern(m_extern);
                                current -> Add(s);
                                //
                                current = s;
                                //
                                while (m_tokens.size())
                                        m_tokens.erase(m_tokens.begin());
                                m_plevelm = m_plevel;
                        }
                        break;
                case '}':
                        // enum fix
                        if (m_tokens.size())
                        {
                                Statement *s = new Statement(m_tokens);
                                // set file, line
                                s -> SetParent(current);
                                s -> SetFile(m_stfilename);
                                s -> SetLine(m_stline);
                                s -> SetPos(m_stpos);
                                s -> SetExtern(m_extern);
                                current -> Add(s);
                                //
                                while (m_tokens.size())
                                        m_tokens.erase(m_tokens.begin());
                                m_plevelm = m_plevel;
                        }
                        if (current -> Trail())
                        {
                                append_next_statement = true;
                        }
                        else
                        {
                                current = current -> GetParent();
                        }
                        break;
                default:
                        if (c != CPP)
                        {
                                AddToken(c,val);
                        }
                        break;
                }
                //
                EndToken(c);
        }

        return s;
}


Token *MyParser::AddToken(int c,const std::string &val)
{
        if (!m_tokens.size() && c == WHITESPACE)
                return NULL;
        Token *t = new Token(c,val);
        if (!m_tokens.size())
        {
                m_stfilename = GetFilename();
                m_stline = GetLine();
                m_stpos = GetPos();
                if (m_stfilename[0] == '/')
                        m_extern = true;
                else
                        m_extern = false;
        }
        m_tokens.push_back(t);
        return t;
}

---