OpenCores
URL https://opencores.org/ocsvn/zipcpu/zipcpu/trunk

Subversion Repositories zipcpu

[/] [zipcpu/] [trunk/] [sw/] [zasm/] [zpp.l] - Diff between revs 16 and 26

Go to most recent revision | Only display areas with differences | Details | Blame | View Log

Rev 16 Rev 26
/*******************************************************************************
/*******************************************************************************
**
**
** Filename:    zpp.l
** Filename:    zpp.l
**
**
** Project:     Zip CPU -- a small, lightweight, RISC CPU core
** Project:     Zip CPU -- a small, lightweight, RISC CPU core
**
**
** Purpose:     The preprocessor for the Zip Assembler.
** Purpose:     The preprocessor for the Zip Assembler.
**
**
**      This routine strips comments, handles #define's, #ifdef's, and
**      This routine strips comments, handles #define's, #ifdef's, and
**      #include statements in a C fashion.
**      #include statements in a C fashion.
**
**
**      #define macro's are also defined in the language and therefore
**      #define macro's are also defined in the language and therefore
**      supposed to be supported, but the support isn't there yet.
**      supposed to be supported, but the support isn't there yet.
**
**
** Creator:     Dan Gisselquist, Ph.D.
** Creator:     Dan Gisselquist, Ph.D.
**              Gisselquist Tecnology, LLC
**              Gisselquist Tecnology, LLC
**
**
********************************************************************************
********************************************************************************
**
**
** Copyright (C) 2015, Gisselquist Technology, LLC
** Copyright (C) 2015, Gisselquist Technology, LLC
**
**
** This program is free software (firmware): you can redistribute it and/or
** This program is free software (firmware): you can redistribute it and/or
** modify it under the terms of  the GNU General Public License as published
** modify it under the terms of  the GNU General Public License as published
** by the Free Software Foundation, either version 3 of the License, or (at
** by the Free Software Foundation, either version 3 of the License, or (at
** your option) any later version.
** your option) any later version.
**
**
** This program is distributed in the hope that it will be useful, but WITHOUT
** This program is distributed in the hope that it will be useful, but WITHOUT
** ANY WARRANTY; without even the implied warranty of MERCHANTIBILITY or
** ANY WARRANTY; without even the implied warranty of MERCHANTIBILITY or
** FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
** FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
** for more details.
** for more details.
**
**
** You should have received a copy of the GNU General Public License along
** You should have received a copy of the GNU General Public License along
** with this program.  (It's in the $(ROOT)/doc directory, run make with no
** with this program.  (It's in the $(ROOT)/doc directory, run make with no
** target there if the PDF file isn't present.)  If not, see
** target there if the PDF file isn't present.)  If not, see
**  for a copy.
**  for a copy.
**
**
** License:     GPL, v3, as defined and found on www.gnu.org,
** License:     GPL, v3, as defined and found on www.gnu.org,
**              http://www.gnu.org/licenses/gpl.html
**              http://www.gnu.org/licenses/gpl.html
**
**
**
**
*******************************************************************************/
*******************************************************************************/
%{
%{
// #include 
// #include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
using namespace std;
int yylex();
int yylex();
void    mark_line(void);
void    mark_line(void);
int     end_of_file(void);
int     end_of_file(void);
void    pushf(const char *fname);
void    pushf(const char *fname);
// #include "zprepr.tab.h"
// #include "zprepr.tab.h"
int     ndef = 0, structno = 0;
int     ndef = 0, structno = 0;
char    *structid = NULL;
char    *structid = NULL;
void    stb_define(const char *str);
void    stb_define(const char *str);
void    stb_args(const char *str);
void    stb_args(const char *str);
void    stb_macro(const char *value);
void    stb_macro(const char *value);
void    stb_addmacro(const char *value);
void    stb_addmacro(const char *value);
bool    stb_isdefined(const char *str);
bool    stb_isdefined(const char *str);
const char      *stb_getdefn(const char *str);
const char      *stb_getdefn(const char *str);
%}
%}
%x DEF DFA DFV DFV_EOL INDEF IFDEFV INNOTDEF NODEF NVRDEF COMMENT INSTRUCT
%x DEF DFA DFV DFV_EOL INDEF IFDEFV INNOTDEF NODEF NVRDEF COMMENT INSTRUCT
%x INDEF_EOL INNOTDEF_EOL GETSTRUCTID
%x INDEF_EOL INNOTDEF_EOL GETSTRUCTID
%option noyywrap
%option noyywrap
%option stack
%option stack
ID [_:A-Za-z][_:A-Za-z0-9]*
ID [_:A-Za-z][_:A-Za-z0-9]*
IDDOT {ID}("."{ID})*
IDDOT {ID}("."{ID})*
%%
%%
"*/"            { yy_pop_state(); }
"*/"            { yy_pop_state(); }
[^*]+           { /* Ignore comments */ }
[^*]+           { /* Ignore comments */ }
"*"+[^/]        { /* Ignore comments */ }
"*"+[^/]        { /* Ignore comments */ }
^"#include"[ \t]+\"[^\"]+\"     {
^"#include"[ \t]+\"[^\"]+\"     {
                char *ptr = &yytext[9], *start, *end, *str;
                char *ptr = &yytext[9], *start, *end, *str;
                while(isspace(*ptr))
                while(isspace(*ptr))
                        ptr++;
                        ptr++;
                start = ++ptr;
                start = ++ptr;
                ptr++;
                ptr++;
                while((*ptr)&&(*ptr != '\"'))
                while((*ptr)&&(*ptr != '\"'))
                        ptr++;
                        ptr++;
                *ptr = '\0';
                *ptr = '\0';
                pushf(start);
                pushf(start);
                // push_file_state(yylineno); // and filename ...
                // push_file_state(yylineno); // and filename ...
                mark_line();
                mark_line();
        }
        }
^"#define"[ \t]+        { yy_push_state(DEF); }
^"#define"[ \t]+        { yy_push_state(DEF); }
 /* <*>^"#line"[ \t]+(0-9)+[ \t]+["][^"]*["][ \t]*\n       { } */
 /* <*>^"#line"[ \t]+(0-9)+[ \t]+["][^"]*["][ \t]*\n       { } */
{IDDOT}/[^(]    {
{IDDOT}/[^(]    {
                stb_define(yytext);
                stb_define(yytext);
                BEGIN DFV;
                BEGIN DFV;
        }
        }
{IDDOT}/[(]     { stb_define(yytext); BEGIN DFA; }
{IDDOT}/[(]     { stb_define(yytext); BEGIN DFA; }
"("[^)]+")"                             {
"("[^)]+")"                             {
                /* Process macro arguments */
                /* Process macro arguments */
                stb_args(yytext);
                stb_args(yytext);
                BEGIN DFV;
                BEGIN DFV;
        }
        }
[ \t]+  { /* Ignore initial spaces */ }
[ \t]+  { /* Ignore initial spaces */ }
[^ \t\n]*       {/* Parse to end of line, get value for our define */
[^ \t\n]*       {/* Parse to end of line, get value for our define */
                stb_macro(yytext);
                stb_macro(yytext);
        }
        }
[ \t]*((;|"//").*)?$    {/* Parse to end of line, get value for our define */
[ \t]*((;|"//").*)?$    {/* Parse to end of line, get value for our define */
                yy_pop_state();
                yy_pop_state();
        }
        }
[ \t]*"\\"[ \t]*((;|"//").*)?\n {/* Continue onto next line */
[ \t]*"\\"[ \t]*((;|"//").*)?\n {/* Continue onto next line */
                fprintf(yyout, "\n"); mark_line(); yylineno++;
                fprintf(yyout, "\n"); mark_line(); yylineno++;
                stb_macro("\n");
                stb_macro("\n");
        }
        }
^[ \t]+.[dD][aA][tT][aA]?       { fprintf(yyout, "\tWORD"); }
^[ \t]+.[dD][aA][tT][aA]?       { fprintf(yyout, "\tWORD"); }
^"#defcont"[ \t]+       { yy_push_state(DFV); }
^"#defcont"[ \t]+       { yy_push_state(DFV); }
^"#ifdef"[ \t]* { ndef = 0; yy_push_state(IFDEFV); }
^"#ifdef"[ \t]* { ndef = 0; yy_push_state(IFDEFV); }
^"#ifndef"[ \t]*        { ndef = 1; yy_push_state(IFDEFV); }
^"#ifndef"[ \t]*        { ndef = 1; yy_push_state(IFDEFV); }
{IDDOT} {
{IDDOT} {
                bool    known = stb_isdefined(yytext);
                bool    known = stb_isdefined(yytext);
                if ( ((known)&&(ndef==0)) || ((!known)&&(ndef!=0)) ) {
                if ( ((known)&&(ndef==0)) || ((!known)&&(ndef!=0)) ) {
                        BEGIN INDEF_EOL;
                        BEGIN INDEF_EOL;
                } else {
                } else {
                        BEGIN INNOTDEF_EOL;
                        BEGIN INNOTDEF_EOL;
                }
                }
        }
        }
        /* Not yet: ^"#if"[ \t]*                { yy_push_state(IFDEFE); }
        /* Not yet: ^"#if"[ \t]*                { yy_push_state(IFDEFE); }
        /* Not yet: ^"#if"[ \t]*                { yy_push_state(IFDEFE); }
        /* Not yet: ^"#if"[ \t]*                { yy_push_state(IFDEFE); }
        /* Not yet:  { yy_push_state(IFDEFE); } */
        /* Not yet:  { yy_push_state(IFDEFE); } */
        /* ^"#elsif"[ \t]*      { yy_pop_state(); yy_push_state(IFDEFE); } */
        /* ^"#elsif"[ \t]*      { yy_pop_state(); yy_push_state(IFDEFE); } */
[ \t]*$         { BEGIN INDEF; }
[ \t]*$         { BEGIN INDEF; }
(;|"//").*$             { BEGIN INDEF; }
(;|"//").*$             { BEGIN INDEF; }
[ \t]*$         { BEGIN INNOTDEF; }
[ \t]*$         { BEGIN INNOTDEF; }
(;|"//").*$     { BEGIN INNOTDEF; }
(;|"//").*$     { BEGIN INNOTDEF; }
[^ \t\n].*$             { BEGIN INDEF; fprintf(stderr, "WARNING! Unexpected characters on IFDEF line, \'%s\'\n", yytext); mark_line(); }
[^ \t\n].*$             { BEGIN INDEF; fprintf(stderr, "WARNING! Unexpected characters on IFDEF line, \'%s\'\n", yytext); mark_line(); }
[^ \t\n].*$     { BEGIN INNOTDEF; fprintf(stderr, "WARNING! Unexpected characters on IFNDEF line, %s\n", yytext); mark_line(); }
[^ \t\n].*$     { BEGIN INNOTDEF; fprintf(stderr, "WARNING! Unexpected characters on IFNDEF line, %s\n", yytext); mark_line(); }
^"#else"[ \t]*((;|"//").*)?$    { BEGIN NODEF; }
^"#else"[ \t]*((;|"//").*)?$    { BEGIN NODEF; }
^"#else"[ \t]*((;|"//").*)?$            { BEGIN INDEF; }
^"#else"[ \t]*((;|"//").*)?$            { BEGIN INDEF; }
(.*)                    { }
(.*)                    { }
^"#elsif"[ \t]*         { BEGIN NVRDEF; }
^"#elsif"[ \t]*         { BEGIN NVRDEF; }
^"#endif"[ \t]*((;|"//").*)?$   { yy_pop_state(); }
^"#endif"[ \t]*((;|"//").*)?$   { yy_pop_state(); }
^"#endif"[ \t]*"/*"     { BEGIN COMMENT; }
^"#endif"[ \t]*"/*"     { BEGIN COMMENT; }
<*>^"#endif"[ \t]*         { fprintf(stderr, "ERR: Unknown endif!!\n");}
<*>^"#endif"[ \t]*         { fprintf(stderr, "ERR: Unknown endif!!\n");}
^"#struct"[ \t]*        {
^"#struct"[ \t]*        {
                yy_push_state(GETSTRUCTID); structno  = 0; }
                yy_push_state(GETSTRUCTID); structno  = 0; }
 
<*>^"#"{ID}[ \t]*          { fprintf(stderr, "ERR: Unrecognized preprocessor instruction, %s\n", yytext);}
{ID}/[ \t\n;/]  { BEGIN INSTRUCT;
{ID}/[ \t\n;/]  { BEGIN INSTRUCT;
                structid = strdup(yytext);
                structid = strdup(yytext);
                }
                }
{ID}("."{ID})*  {
{ID}("."{ID})*  {
                fprintf(yyout, "\t%s.%s\tequ\t%d", structid, yytext, structno++); }
                fprintf(yyout, "\t%s.%s\tequ\t%d", structid, yytext, structno++); }
^"#endstruct".*$        { yy_pop_state(); }
^"#endstruct".*$        { yy_pop_state(); }
        /* Not yet: ^"#struct"[ \t]*    {}      */
        /* Not yet: ^"#struct"[ \t]*    {}      */
        /* Not yet: ^"#endstruct"[ \t]* {}      */
        /* Not yet: ^"#endstruct"[ \t]* {}      */
        /* Not yet: ^"#seg"[ \t]*       {}      */
        /* Not yet: ^"#seg"[ \t]*       {}      */
.*              { /* Ignore everything in these states*/ }
.*              { /* Ignore everything in these states*/ }
{ID}/[^(]       {
{ID}/[^(]       {
                if (stb_isdefined(yytext))
                if (stb_isdefined(yytext))
                        fprintf(yyout, "%s", stb_getdefn(yytext));
                        fprintf(yyout, "%s", stb_getdefn(yytext));
                else
                else
                        fprintf(yyout, "%s", yytext);
                        fprintf(yyout, "%s", yytext);
        }
        }
<*>[ \t]*"//".*$   { /* Ignore (trailing) comment only lines */ }
<*>[ \t]*"//".*$   { /* Ignore (trailing) comment only lines */ }
<*>[ \t]*";".*$            { /* Ignore (trailing) comment only lines */ }
<*>[ \t]*";".*$            { /* Ignore (trailing) comment only lines */ }
 
<*>"#warning".*$   { fprintf(stderr, "WARNING: %s\n", &yytext[8]); }
 
<*>"#error".*$             { fprintf(stderr, "ERROR: %s\n", &yytext[8]); exit(-1); }
<*>"/*"                    { yy_push_state(COMMENT); }
<*>"/*"                    { yy_push_state(COMMENT); }
<*>[ \t]+          { ECHO; }
<*>[ \t]+          { ECHO; }
<*>\n                      { ECHO; yylineno++; mark_line(); }
<*>\n                      { ECHO; yylineno++; mark_line(); }
        /* <*>.                    { printf("Unmatched \'%c\'\n", yytext[0]); } */
        /* <*>.                    { printf("Unmatched \'%c\'\n", yytext[0]); } */
<>                       { if (end_of_file()) yyterminate(); }
<>       { fprintf(stderr, "Unexpected EOF!  Expecting #endif\n"); }
 
<>               { fprintf(stderr, "Unexpected EOF!  Expecting #endif\n"); }
 
<>       { fprintf(stderr, "Unexpected EOF!  Expecting */\n"); }
 
<>       { fprintf(stderr, "Unexpected EOF!  Expecting #endstruct\n"); }
 
<>       { fprintf(stderr, "Unexpected EOF!  Expecting #struct ID, then #endstruct\n"); }
 
<> { fprintf(stderr, "Unexpected EOF!  Expecting end of line\n"); }
 
 
 
<>       { if (end_of_file()) yyterminate(); }
 
 
%%
%%
class   SYMTABLE_ENTRY {
class   SYMTABLE_ENTRY {
private:
private:
        std::string     &trim(std::string &s) {
        std::string     &trim(std::string &s) {
                std::string::iterator   ptr = s.end();
                std::string::iterator   ptr = s.end();
                while((ptr >= s.begin())&&(isspace(*ptr)))
                while((ptr >= s.begin())&&(isspace(*ptr)))
                        *ptr-- = '\0';
                        *ptr-- = '\0';
                return s;
                return s;
        }
        }
public:
public:
        std::string     m_name, m_value, m_args;
        std::string     m_name, m_value, m_args;
        SYMTABLE_ENTRY(const char *str) : m_name(str) {
        SYMTABLE_ENTRY(const char *str) : m_name(str) {
                trim(m_name);
                trim(m_name);
        }
        }
        SYMTABLE_ENTRY &operator+=(const char *str) {
        SYMTABLE_ENTRY &operator+=(const char *str) {
                const char      *start = str;
                const char      *start = str;
                while(isspace(*start))
                while(isspace(*start))
                        start++;
                        start++;
                if (m_value.length()!=0)
                if (m_value.length()!=0)
                        m_value += " ";
                        m_value += " ";
                std::string     trimd(start);
                std::string     trimd(start);
                trim(trimd);
                trim(trimd);
                m_value += trimd;
                m_value += trimd;
                /*
                /*
                printf("ENTRY::SYMBOL \'%s\' NOW = \'%s\'\n",
                printf("ENTRY::SYMBOL \'%s\' NOW = \'%s\'\n",
                        m_name.c_str(), m_value.c_str());
                        m_name.c_str(), m_value.c_str());
                */
                */
                return *this;
                return *this;
        }
        }
        SYMTABLE_ENTRY &setargs(const char *str) {
        SYMTABLE_ENTRY &setargs(const char *str) {
                m_args += str;
                m_args += str;
                return *this;
                return *this;
        }
        }
        const std::string &getdefn(void) {
        const std::string &getdefn(void) {
                return m_value;
                return m_value;
        }
        }
};
};
class   SYMBOL_TABLE {
class   SYMBOL_TABLE {
private:
private:
        typedef SYMTABLE_ENTRY  *TBLV;
        typedef SYMTABLE_ENTRY  *TBLV;
        typedef std::list       TBLT;
        typedef std::list       TBLT;
        TBLT    m_tbl;
        TBLT    m_tbl;
        TBLT::iterator  lookup(const char *str) {
        TBLT::iterator  lookup(const char *str) {
                TBLT::iterator  i = m_tbl.begin();
                TBLT::iterator  i = m_tbl.begin();
                for(; (i!= m_tbl.end())&&(strcmp(str, (*i)->m_name.c_str())>0); i++)
                for(; (i!= m_tbl.end())&&(strcmp(str, (*i)->m_name.c_str())>0); i++)
                        ;
                        ;
                if ((i != m_tbl.end())&&(strcmp(str, (*i)->m_name.c_str())==0))
                if ((i != m_tbl.end())&&(strcmp(str, (*i)->m_name.c_str())==0))
                        return i;
                        return i;
                return m_tbl.end();
                return m_tbl.end();
        }
        }
public:
public:
        SYMBOL_TABLE(void) {}
        SYMBOL_TABLE(void) {}
        void define(const char *str) {
        void define(const char *str) {
                SYMTABLE_ENTRY  *v = new SYMTABLE_ENTRY(str);
                SYMTABLE_ENTRY  *v = new SYMTABLE_ENTRY(str);
                TBLT::iterator  i = m_tbl.begin();
                TBLT::iterator  i = m_tbl.begin();
                for(; (i!= m_tbl.end())&&(strcmp(str, (*i)->m_name.c_str())>0); i++)
                for(; (i!= m_tbl.end())&&(strcmp(str, (*i)->m_name.c_str())>0); i++)
                        ;
                        ;
                m_tbl.insert(i, v);
                m_tbl.insert(i, v);
                // printf("SYMS::Defining SYMBOL: \'%s\'\n", str);
                // printf("SYMS::Defining SYMBOL: \'%s\'\n", str);
        }
        }
        bool defined(const char *str) {
        bool defined(const char *str) {
                TBLT::iterator  i = lookup(str);
                TBLT::iterator  i = lookup(str);
                if (i==m_tbl.end())
                if (i==m_tbl.end())
                        return false;
                        return false;
                else
                else
                        return true;
                        return true;
        }
        }
        void    undefine(const char *str) {
        void    undefine(const char *str) {
                TBLT::iterator  i = lookup(str);
                TBLT::iterator  i = lookup(str);
                if (i == m_tbl.end())
                if (i == m_tbl.end())
                        return;
                        return;
                TBLV    v = (*i);
                TBLV    v = (*i);
                m_tbl.erase(i);
                m_tbl.erase(i);
                delete  v;
                delete  v;
        }
        }
        void    addmacro(const char *name, const char *str) {
        void    addmacro(const char *name, const char *str) {
                TBLT::iterator i = lookup(name);
                TBLT::iterator i = lookup(name);
                if (i == m_tbl.end()) {
                if (i == m_tbl.end()) {
                        fprintf(stderr, "INTERNAL ERR, %s NOT DEFINED!\n", name);
                        fprintf(stderr, "INTERNAL ERR, %s NOT DEFINED!\n", name);
                } *(*i) += str;
                } *(*i) += str;
        }
        }
        void    addargs(const char *name, const char *str) {
        void    addargs(const char *name, const char *str) {
                TBLT::iterator i = lookup(name);
                TBLT::iterator i = lookup(name);
                if (i == m_tbl.end()) {
                if (i == m_tbl.end()) {
                        fprintf(stderr, "INTERNAL ERR, %s NOT DEFINED!\n", name);
                        fprintf(stderr, "INTERNAL ERR, %s NOT DEFINED!\n", name);
                } (*i)->setargs(str);
                } (*i)->setargs(str);
        }
        }
        const   char *getdefn(const char *name) {
        const   char *getdefn(const char *name) {
                TBLT::iterator i = lookup(name);
                TBLT::iterator i = lookup(name);
                if (i == m_tbl.end()) {
                if (i == m_tbl.end()) {
                        fprintf(stderr, "INTERNAL ERR, %s NOT DEFINED!\n", name);
                        fprintf(stderr, "INTERNAL ERR, %s NOT DEFINED!\n", name);
                        return NULL;
                        return NULL;
                } (*i)->getdefn().c_str();
                } (*i)->getdefn().c_str();
        }
        }
};
};
SYMTABLE_ENTRY  *last = NULL;
SYMTABLE_ENTRY  *last = NULL;
SYMBOL_TABLE    syms;
SYMBOL_TABLE    syms;
std::string     last_define;
std::string     last_define;
void    stb_define(const char *str) {
void    stb_define(const char *str) {
        if (syms.defined(str)) {
        if (syms.defined(str)) {
                fprintf(stderr, "WARNING!  Symbol \'%s\' is already defined!\n", str);
                fprintf(stderr, "WARNING!  Symbol \'%s\' is already defined!\n", str);
                syms.undefine(str);
                syms.undefine(str);
        }
        }
        syms.define(str);
        syms.define(str);
        last_define = str;
        last_define = str;
}
}
void    stb_args(const char *args) {
void    stb_args(const char *args) {
        syms.addargs(last_define.c_str(), args);
        syms.addargs(last_define.c_str(), args);
}
}
void    stb_macro(const char *value) {
void    stb_macro(const char *value) {
        syms.addmacro(last_define.c_str(), value);
        syms.addmacro(last_define.c_str(), value);
}
}
void    stb_addmacro(const char *value) {
void    stb_addmacro(const char *value) {
        syms.addmacro(last_define.c_str(),value);
        syms.addmacro(last_define.c_str(),value);
}
}
bool    stb_isdefined(const char *str) {
bool    stb_isdefined(const char *str) {
        return syms.defined(str);
        return syms.defined(str);
}
}
const char *stb_getdefn(const char *str) {
const char *stb_getdefn(const char *str) {
        return syms.getdefn(str);
        return syms.getdefn(str);
}
}
class   BUFSTACK {
class   BUFSTACK {
public:
public:
        FILE            *m_fp;
        FILE            *m_fp;
        char            *m_fname;
        char            *m_fname;
        int             m_lineno;
        int             m_lineno;
        BUFSTACK        *m_prev;
        BUFSTACK        *m_prev;
        YY_BUFFER_STATE m_bs;
        YY_BUFFER_STATE m_bs;
        static  BUFSTACK        *curbs;
        static  BUFSTACK        *curbs;
        static  const char      *curfilename;
        static  const char      *curfilename;
        BUFSTACK(void) {
        BUFSTACK(void) {
                m_fp = stdin;
                m_fp = stdin;
                if (curbs)
                if (curbs)
                        curbs->m_lineno = yylineno;
                        curbs->m_lineno = yylineno;
                m_prev = curbs;
                m_prev = curbs;
                // m_bs = yy_create_buffer(fp, YY_BUF_SIZE);
                // m_bs = yy_create_buffer(fp, YY_BUF_SIZE);
                m_fname = strdup("(stdin)");
                m_fname = strdup("(stdin)");
                // yy_switch_to_buffer(m_bs);
                // yy_switch_to_buffer(m_bs);
                m_bs = NULL;
                m_bs = NULL;
                curbs = this;
                curbs = this;
                m_lineno = 1;
                m_lineno = 1;
                curfilename = m_fname;
                curfilename = m_fname;
                yyrestart(m_fp);
                yyrestart(m_fp);
                yylineno = 1;
                yylineno = 1;
        }
        }
        BUFSTACK(const char *fname) {
        BUFSTACK(const char *fname) {
                m_fp = fopen(fname, "r");
                m_fp = fopen(fname, "r");
                if (!m_fp) {
                if (!m_fp) {
                        fprintf(stderr, "Cannot open %s\n", fname);
                        fprintf(stderr, "Cannot open %s\n", fname);
                        perror("O/S Err:");
                        perror("O/S Err:");
                        exit(-1);
                        exit(-1);
                }
                }
                if (curbs)
                if (curbs)
                        curbs->m_lineno = yylineno;
                        curbs->m_lineno = yylineno;
                m_prev = curbs;
                m_prev = curbs;
                m_bs = yy_create_buffer(m_fp, YY_BUF_SIZE);
                m_bs = yy_create_buffer(m_fp, YY_BUF_SIZE);
                m_fname = strdup(fname);
                m_fname = strdup(fname);
                yy_switch_to_buffer(m_bs);
                yy_switch_to_buffer(m_bs);
                curbs = this;
                curbs = this;
                m_lineno = 1;
                m_lineno = 1;
                curfilename = m_fname;
                curfilename = m_fname;
                yyrestart(m_fp);
                yyrestart(m_fp);
                yylineno = 1;
                yylineno = 1;
        }
        }
        ~BUFSTACK(void) {
        ~BUFSTACK(void) {
                // fprintf(stderr, "DELETING(%s)\n", m_fname);
                // fprintf(stderr, "DELETING(%s)\n", m_fname);
                fclose(m_fp);
                fclose(m_fp);
                free(m_fname);
                free(m_fname);
                if (m_bs)
                if (m_bs)
                        yy_delete_buffer(m_bs);
                        yy_delete_buffer(m_bs);
                curbs = m_prev;
                curbs = m_prev;
                if (curbs) {
                if (curbs) {
                        yy_switch_to_buffer(curbs->m_bs);
                        yy_switch_to_buffer(curbs->m_bs);
                        yylineno = curbs->m_lineno;
                        yylineno = curbs->m_lineno;
                        curfilename = curbs->m_fname;
                        curfilename = curbs->m_fname;
                }
                }
        }
        }
        void    mark(void) {
        void    mark(void) {
                FILE    *fp = yyout;
                FILE    *fp = yyout;
                if (!fp) fp = stdout;
                if (!fp) fp = stdout;
                fprintf(fp, "#line %d \"%s\"\n", yylineno, m_fname);
                fprintf(fp, "#line %d \"%s\"\n", yylineno, m_fname);
        }
        }
 
 
 
        void    markline(void) {
 
                FILE    *fp = yyout;
 
                if (!fp) fp = stdout;
 
                fprintf(fp, "#line %d\n", yylineno);
 
        }
 
 
        static  void pop(void) {
        static  void pop(void) {
                // fprintf(stderr, "POP! (%s)\n", curbs->m_fname);
                // fprintf(stderr, "POP! (%s)\n", curbs->m_fname);
                if (curbs)
                if (curbs)
                        delete curbs;
                        delete curbs;
        }
        }
};
};
BUFSTACK *BUFSTACK::curbs = NULL;
BUFSTACK *BUFSTACK::curbs = NULL;
const char *BUFSTACK::curfilename = NULL;
const char *BUFSTACK::curfilename = NULL;
int             last_marked_line = -1;
int             last_marked_line = -1;
const char      *last_marked_file = NULL;
const char      *last_marked_file = NULL;
void    mark_line(void) {
void    mark_line(void) {
        if ((yylineno != last_marked_line+1)||(BUFSTACK::curfilename != last_marked_file))
        if ((yylineno != last_marked_line+1)||(BUFSTACK::curfilename != last_marked_file))
                BUFSTACK::curbs->mark();
                if (BUFSTACK::curfilename == last_marked_file)
 
                        BUFSTACK::curbs->markline();
 
                else BUFSTACK::curbs->mark();
        last_marked_line = yylineno;
        last_marked_line = yylineno;
        last_marked_file = BUFSTACK::curfilename;
        last_marked_file = BUFSTACK::curfilename;
}
}
int     end_of_file(void) {
int     end_of_file(void) {
        BUFSTACK::pop();
        BUFSTACK::pop();
        return (BUFSTACK::curbs == NULL);
        return (BUFSTACK::curbs == NULL);
}
}
void    pushf(const char *fname) {
void    pushf(const char *fname) {
        BUFSTACK        *bs = new BUFSTACK(fname);
        BUFSTACK        *bs = new BUFSTACK(fname);
}
}
int main(int argc, char **argv) {
int main(int argc, char **argv) {
        yylineno = 1;
        yylineno = 1;
        if (argc < 2) { // Stdin only
        if (argc < 2) { // Stdin only
                BUFSTACK::curbs = new BUFSTACK();
                BUFSTACK::curbs = new BUFSTACK();
                yylex();
                yylex();
        } else {
        } else {
                for(int argn=1; argn
                for(int argn=1; argn
                        BUFSTACK        *bs = new BUFSTACK(argv[argn]);
                        BUFSTACK        *bs = new BUFSTACK(argv[argn]);
                        mark_line();
                        mark_line();
                        yylex();
                        yylex();
                        // delete       bs;
                        // delete       bs;
                }
                }
        }
        }
 
 
 
        return 0;
}
}
 
 

powered by: WebSVN 2.1.0

© copyright 1999-2022 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.