/*******************************************************************************
|
/*******************************************************************************
|
**
|
**
|
** 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;
|
}
|
}
|
|
|
|
|
