what you give them. Help stamp out software-hoarding!
-------------------------------------------------------------------------*/
+%option noyywrap
+
D [0-9]
L [a-zA-Z_]
H [a-fA-F0-9]
#include "newalloc.h"
#include "dbuf.h"
-char *stringLiteral();
+static char *stringLiteral(void);
char *currFname;
extern int lineno, column;
-extern char *filename ;
-int yylineno = 1 ;
-void count() ;
-int process_pragma(char *);
+extern char *filename;
+int mylineno = 1;
+static void count(void);
+static int process_pragma(char *);
#undef yywrap
+#ifndef YYPROTO
+
+#ifdef YY_USE_PROTOS
+#define YY_PROTO(proto) proto
+#else
+#define YY_PROTO(proto) ()
+#endif
+
+#endif
+
int yywrap YY_PROTO((void))
{
return(1);
}
+
+static void yyunput (int, char *);
+
+static void my_unput(char c)
+{
+ yyunput(c, (yytext_ptr));
+}
+
#define TKEYWORD(token) return (isTargetKeyword(yytext) ? token :\
- check_type(yytext))
+ check_type())
char *asmbuff=NULL;
int asmbuffSize=0;
char *asmp ;
-extern int check_type ();
- extern int isTargetKeyword ();
-extern int checkCurrFile (char *);
-extern int processPragma (char *);
-extern int printListing (int );
-struct optimize save_optimize ;
-struct options save_options ;
-
- enum {
- P_SAVE = 1,
- P_RESTORE ,
- P_NOINDUCTION,
- P_NOINVARIANT,
- P_INDUCTION ,
- P_STACKAUTO ,
- P_NOJTBOUND ,
- P_NOOVERLAY ,
- P_NOGCSE ,
- P_CALLEE_SAVES,
- P_EXCLUDE ,
- P_NOIV ,
- P_LOOPREV ,
- P_OVERLAY_ /* I had a strange conflict with P_OVERLAY while */
- /* cross-compiling for MINGW32 with gcc 3.2 */
- };
-
+static int check_type(void);
+static int isTargetKeyword(char *s);
+static int checkCurrFile (char *s);
+struct optimize save_optimize;
+struct options save_options;
%}
+
%x asm
%%
"_asm" {
}
<asm>. {
if (asmp-asmbuff >= asmbuffSize-2) {
- // increase the buffersize with 50%
+ /* increase the buffersize with 50% */
int size=asmp-asmbuff;
asmbuffSize=asmbuffSize*3/2;
asmbuff = realloc (asmbuff, asmbuffSize);
<asm>\n {
count();
if (asmp-asmbuff >= asmbuffSize-3) {
- // increase the buffersize with 50%
+ /* increase the buffersize with 50% */
int size=asmp-asmbuff;
asmbuffSize=asmbuffSize*3/2;
asmbuff = realloc (asmbuff, asmbuffSize);
\\ {
char ch=input();
if (ch!='\n') {
- // that could have been removed by the preprocessor anyway
+ /* that could have been removed by the preprocessor anyway */
werror (W_STRAY_BACKSLASH, column);
- unput(ch);
+ my_unput(ch);
}
}
. { count() ; }
%%
-int checkCurrFile ( char *s)
+static int checkCurrFile (char *s)
{
char lineNum[10] ;
int lNum ;
/* set the current line number to */
/* line number if printFlag is on */
if (!*s) {
- lineno = yylineno = lNum ;
+ lineno = mylineno = lNum ;
return 0;
}
/* in c1mode fullSrcFileName is NULL */
if ( fullSrcFileName &&
strncmp(s,fullSrcFileName,strlen(fullSrcFileName)) == 0) {
- lineno = yylineno = lNum;
+ lineno = mylineno = lNum;
currFname = fullSrcFileName ;
} else {
char *sb = s;
while (*s != '"') s++;
*s = '\0';
currFname = strdup (sb);
- lineno = yylineno = lNum;
+ lineno = mylineno = lNum;
}
filename = currFname ;
return 0;
}
int column = 0;
-int plineIdx=0;
+int plineIdx =0;
-void count()
+static void count(void)
{
int i;
for (i = 0; yytext[i] != '\0'; i++) {
if (yytext[i] == '\n') {
column = 0;
- lineno = ++yylineno ;
+ lineno = ++mylineno ;
}
else
if (yytext[i] == '\t')
/* ECHO; */
}
-int check_type()
+static int check_type(void)
{
/* check if it is in the typedef table */
if (findSym(TypedefTab,NULL,yytext)) {
* to support ANSI hex and octal escape sequences in string liteals
*/
-char *stringLiteral()
+static char *stringLiteral(void)
{
#define STR_BUF_CHUNCK_LEN 1024
int ch;
ch = input();
if (ch == '\n') {
/* \<newline> is a continuator */
- lineno = ++yylineno;
+ lineno = ++mylineno;
column = 0;
}
else {
/* if new line we have a new line break, which is illegal */
werror(W_NEWLINE_IN_STRING);
dbuf_append(&dbuf, "\n", 1);
- lineno = ++yylineno;
+ lineno = ++mylineno;
column = 0;
break;
case '\\':
if ((ch = input()) != '\n') {
werror(W_STRAY_BACKSLASH, column);
- unput(ch);
+ my_unput(ch);
}
else {
- lineno = ++yylineno;
+ lineno = ++mylineno;
column = 0;
}
break;
case '\n':
- yylineno++;
+ mylineno++;
break;
}
}
goto out;
if (ch != '\"') {
- unput(ch) ;
+ my_unput(ch) ;
goto out;
}
break;
return (char *)dbuf_c_str(&dbuf);
}
-void doPragma (int op, char *cp)
+
+enum pragma_id {
+ P_SAVE = 1,
+ P_RESTORE ,
+ P_NOINDUCTION,
+ P_NOINVARIANT,
+ P_INDUCTION ,
+ P_STACKAUTO ,
+ P_NOJTBOUND ,
+ P_NOOVERLAY ,
+ P_LESSPEDANTIC,
+ P_NOGCSE ,
+ P_CALLEE_SAVES,
+ P_EXCLUDE ,
+ P_NOIV ,
+ P_LOOPREV ,
+ P_OVERLAY_ /* I had a strange conflict with P_OVERLAY while */
+ /* cross-compiling for MINGW32 with gcc 3.2 */
+};
+
+
+/* SAVE/RESTORE stack */
+#define SAVE_RESTORE_SIZE 128
+
+STACK_DCL(options_stack, struct options *, SAVE_RESTORE_SIZE)
+STACK_DCL(optimize_stack, struct optimize *, SAVE_RESTORE_SIZE)
+
+/*
+ * cloneXxx functions should be updated every time a new set is
+ * added to the options or optimize structure!
+ */
+
+static struct options *cloneOptions(struct options *opt)
{
- switch (op) {
- case P_SAVE:
- memcpy(&save_options,&options,sizeof(options));
- memcpy(&save_optimize,&optimize,sizeof(optimize));
- break;
- case P_RESTORE:
- memcpy(&options,&save_options,sizeof(options));
- memcpy(&optimize,&save_optimize,sizeof(optimize));
- break;
- case P_NOINDUCTION:
- optimize.loopInduction = 0 ;
- break;
- case P_NOINVARIANT:
- optimize.loopInvariant = 0 ;
- break;
- case P_INDUCTION:
- optimize.loopInduction = 1 ;
- break;
- case P_STACKAUTO:
- options.stackAuto = 1;
- break;
- case P_NOJTBOUND:
- optimize.noJTabBoundary = 1;
- break;
- case P_NOGCSE:
- optimize.global_cse = 0;
- break;
- case P_NOOVERLAY:
- options.noOverlay = 1;
- break;
- case P_CALLEE_SAVES:
- {
- int i=0;
- /* append to the functions already listed
- in callee-saves */
- for (; options.calleeSaves[i] ;i++);
- parseWithComma(&options.calleeSaves[i], Safe_strdup(cp));
- }
- break;
- case P_EXCLUDE:
- parseWithComma(options.excludeRegs, Safe_strdup(cp));
- break;
- case P_NOIV:
- options.noiv = 1;
- break;
- case P_LOOPREV:
- optimize.noLoopReverse = 1;
- break;
- case P_OVERLAY_:
- break; /* notyet */
- }
+ struct options *new_opt;
+
+ new_opt = Safe_malloc(sizeof (struct options));
+
+ /* clone scalar values */
+ *new_opt = *opt;
+
+ /* clone sets */
+ new_opt->calleeSavesSet = setFromSetNonRev(opt->calleeSavesSet);
+ new_opt->excludeRegsSet = setFromSetNonRev(opt->excludeRegsSet);
+ /* not implemented yet: */
+ /* new_opt->olaysSet = setFromSetNonRev(opt->olaysSet); */
+
+ return new_opt;
}
-int process_pragma(char *s)
+static struct optimize *cloneOptimize(struct optimize *opt)
{
- char *cp ;
- /* find the pragma */
- while (strncmp(s,"#pragma",7))
- s++;
- s += 7;
-
- /* look for the directive */
- while(isspace(*s)) s++;
+ struct optimize *new_opt;
- cp = s;
- /* look for the end of the directive */
- while ((! isspace(*s)) &&
- (*s != '\n'))
- s++ ;
+ new_opt = Safe_malloc(sizeof (struct options));
- /* First give the port a chance */
- if (port->process_pragma && !port->process_pragma(cp))
- return 0;
+ /* clone scalar values */
+ *new_opt = *opt;
- /* now compare and do what needs to be done */
- if (strncmp(cp,PRAGMA_SAVE,strlen(PRAGMA_SAVE)) == 0) {
- doPragma(P_SAVE,cp+strlen(PRAGMA_SAVE));
- return 0;
- }
+ return new_opt;
+}
- if (strncmp(cp,PRAGMA_RESTORE,strlen(PRAGMA_RESTORE)) == 0) {
- doPragma (P_RESTORE,cp+strlen(PRAGMA_RESTORE));
- return 0;
- }
+static void copyAndFreeOptions(struct options *dest, struct options *src)
+{
+ /* delete dest sets */
+ deleteSet(&dest->calleeSavesSet);
+ deleteSet(&dest->excludeRegsSet);
+ /* not implemented yet: */
+ /* deleteSet(&dest->olaysSet); */
- if (strncmp(cp,PRAGMA_NOINDUCTION,strlen(PRAGMA_NOINDUCTION)) == 0) {
- doPragma (P_NOINDUCTION,cp+strlen(PRAGMA_NOINDUCTION)) ;
- return 0;
- }
+ /* dopy src to dest */
+ *dest = *src;
- if (strncmp(cp,PRAGMA_NOINVARIANT,strlen(PRAGMA_NOINVARIANT)) == 0) {
- doPragma (P_NOINVARIANT,NULL) ;
- return 0;
- }
+ Safe_free(src);
+}
- if (strncmp(cp,PRAGMA_INDUCTION,strlen(PRAGMA_INDUCTION)) == 0) {
- doPragma (P_INDUCTION,NULL) ;
- return 0;
- }
+static void copyAndFreeOptimize(struct optimize *dest, struct optimize *src)
+{
+ /* dopy src to dest */
+ *dest = *src;
- if (strncmp(cp,PRAGMA_STACKAUTO,strlen(PRAGMA_STACKAUTO)) == 0) {
- doPragma (P_STACKAUTO,NULL);
- return 0;
- }
+ Safe_free(src);
+}
- if (strncmp(cp,PRAGMA_NOJTBOUND,strlen(PRAGMA_NOJTBOUND)) == 0) {
- doPragma (P_NOJTBOUND,NULL);
- return 0;
+static void doPragma(int op, char *cp)
+{
+ switch (op) {
+ case P_SAVE:
+ {
+ STACK_PUSH(options_stack, cloneOptions(&options));
+ STACK_PUSH(optimize_stack, cloneOptimize(&optimize));
}
+ break;
- if (strncmp(cp,PRAGMA_NOGCSE,strlen(PRAGMA_NOGCSE)) == 0) {
- doPragma (P_NOGCSE,NULL);
- return 0;
- }
+ case P_RESTORE:
+ {
+ struct options *optionsp;
+ struct optimize *optimizep;
- if (strncmp(cp,PRAGMA_NOOVERLAY,strlen(PRAGMA_NOOVERLAY)) == 0) {
- doPragma (P_NOOVERLAY,NULL);
- return 0;
+ optionsp = STACK_POP(options_stack);
+ copyAndFreeOptions(&options, optionsp);
+
+ optimizep = STACK_POP(optimize_stack);
+ copyAndFreeOptimize(&optimize, optimizep);
}
-
- if (strncmp(cp,PRAGMA_CALLEESAVES,strlen(PRAGMA_CALLEESAVES)) == 0) {
- doPragma(P_CALLEE_SAVES,cp+strlen(PRAGMA_CALLEESAVES));
- return 0;
+ break;
+
+ case P_NOINDUCTION:
+ optimize.loopInduction = 0 ;
+ break;
+
+ case P_NOINVARIANT:
+ optimize.loopInvariant = 0 ;
+ break;
+
+ case P_INDUCTION:
+ optimize.loopInduction = 1 ;
+ break;
+
+ case P_STACKAUTO:
+ options.stackAuto = 1;
+ break;
+
+ case P_NOJTBOUND:
+ optimize.noJTabBoundary = 1;
+ break;
+
+ case P_NOGCSE:
+ optimize.global_cse = 0;
+ break;
+
+ case P_NOOVERLAY:
+ options.noOverlay = 1;
+ break;
+
+ case P_LESSPEDANTIC:
+ options.lessPedantic = 1;
+ break;
+
+ case P_CALLEE_SAVES:
+ /* append to the functions already listed
+ in callee-saves */
+ setParseWithComma(&options.calleeSavesSet, cp);
+ break;
+
+ case P_EXCLUDE:
+ {
+ deleteSet(&options.excludeRegsSet);
+ setParseWithComma(&options.excludeRegsSet, cp);
}
+ break;
+
+ case P_NOIV:
+ options.noiv = 1;
+ break;
+
+ case P_LOOPREV:
+ optimize.noLoopReverse = 1;
+ break;
+
+ case P_OVERLAY_:
+ break; /* notyet */
+ }
+}
+
+static int process_pragma(char *s)
+{
+#define NELEM(x) (sizeof (x) / sizeof (x)[0])
+#define PRAGMA "#pragma"
+
+ static struct pragma_s {
+ const char *name;
+ enum pragma_id id;
+ } pragma_tbl[] = {
+ { "SAVE", P_SAVE },
+ { "RESTORE", P_RESTORE },
+ { "NOINDUCTION", P_NOINDUCTION },
+ { "NOINVARIANT", P_NOINVARIANT },
+ { "NOLOOPREVERSE", P_LOOPREV },
+ { "INDUCTION", P_INDUCTION },
+ { "STACKAUTO", P_STACKAUTO },
+ { "NOJTBOUND", P_NOJTBOUND },
+ { "NOGCSE", P_NOGCSE },
+ { "NOOVERLAY", P_NOOVERLAY },
+ { "CALLEE-SAVES", P_CALLEE_SAVES },
+ { "EXCLUDE", P_EXCLUDE },
+ { "NOIV", P_NOIV },
+ { "OVERLAY", P_OVERLAY_ },
+ { "LESS_PEDANTIC", P_LESSPEDANTIC },
+ };
+ char *cp ;
+ int i;
+
+ /* find the pragma */
+ while (strncmp(s, PRAGMA, (sizeof PRAGMA) - 1))
+ s++;
+ s += (sizeof PRAGMA) - 1;
- if (strncmp(cp,PRAGMA_EXCLUDE,strlen(PRAGMA_EXCLUDE)) == 0) {
- doPragma(P_EXCLUDE,cp+strlen(PRAGMA_EXCLUDE));
- return 0;
- }
+ /* look for the directive */
+ while(isspace(*s))
+ s++;
- if (strncmp(cp,PRAGMA_NOIV,strlen(PRAGMA_NOIV)) == 0) {
- doPragma(P_NOIV,cp+strlen(PRAGMA_NOIV));
- return 0;
- }
+ cp = s;
+ /* look for the end of the directive */
+ while ((!isspace(*s)) && (*s != '\n'))
+ s++ ;
- if (strncmp(cp,PRAGMA_NOLOOPREV,strlen(PRAGMA_NOLOOPREV)) == 0) {
- doPragma(P_LOOPREV,NULL);
- return 0;
+ /* First give the port a chance */
+ if (port->process_pragma && !port->process_pragma(cp))
+ return 0;
+
+ for (i = 0; i < NELEM(pragma_tbl); i++) {
+ /* now compare and do what needs to be done */
+ size_t len = strlen(pragma_tbl[i].name);
+
+ if (strncmp(cp, pragma_tbl[i].name, len) == 0) {
+ doPragma(pragma_tbl[i].id, cp + len);
+ return 0;
}
+ }
- werror(W_UNKNOWN_PRAGMA,cp);
- return 0;
+ werror(W_UNKNOWN_PRAGMA,cp);
+ return 0;
}
/* will return 1 if the string is a part
of a target specific keyword */
-int isTargetKeyword(char *s)
+static int isTargetKeyword(char *s)
{
int i;
return 0;
}
-extern int fatalError;
-
int yyerror(char *s)
{
fflush(stdout);
- if (yylineno && filename) {
- fprintf(stdout,"\n%s:%d: %s: token -> '%s' ; column %d\n",
- filename,yylineno,
- s,yytext,column);
+ if (mylineno && filename) {
+ if(options.vc_err_style)
+ fprintf(stderr,"\n%s(%d) : %s: token -> '%s' ; column %d\n",
+ filename,mylineno,
+ s,yytext,column);
+ else
+ fprintf(stderr,"\n%s:%d: %s: token -> '%s' ; column %d\n",
+ filename,mylineno,
+ s,yytext,column);
fatalError++;
} else {
- // this comes from an empy file, no problem
+ /* this comes from an empy file, no problem */
}
return 0;
}
projects / fw / sdcc / blobdiff