SDCC.lex - lexical analyser for use with sdcc ( a freeware compiler for
8/16 bit microcontrollers)
Written by : Sandeep Dutta . sandeep.dutta@usa.net (1997)
-
+
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, 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, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
+
In other words, you are welcome to use, share and improve this program.
You are forbidden to forbid anyone else to use, share and improve
- what you give them. Help stamp out software-hoarding!
+ what you give them. Help stamp out software-hoarding!
-------------------------------------------------------------------------*/
D [0-9]
#include <ctype.h>
#include "common.h"
#include "newalloc.h"
-#include "dbuf.h"
+#include "dbuf_string.h"
#define TKEYWORD(token) return (isTargetKeyword(yytext) ? token :\
check_type())
+#define TKEYWORDSDCC(token) return (options.std_sdcc && isTargetKeyword(yytext)\
+ ? token : check_type())
+
+#define TKEYWORD99(token) return (options.std_c99 ? token : check_type())
+
extern int lineno, column;
extern char *filename;
/* forward declarations */
static char *stringLiteral(void);
static void count(void);
-static int process_pragma(char *);
+static int process_pragma(const char *);
static int check_type(void);
-static int isTargetKeyword(char *s);
-static int checkCurrFile(char *s);
+static int isTargetKeyword(const char *s);
+static int checkCurrFile(const char *s);
%}
%x asm
%%
-"_asm" {
+_?"_asm" {
count();
+ if (!options.std_sdcc && yytext[1] != '_')
+ return check_type();
assert(asmbuff.alloc == 0 && asmbuff.len == 0 && asmbuff.buf == NULL);
dbuf_init(&asmbuff, INITIAL_INLINEASM);
BEGIN(asm);
}
-<asm>"_endasm" {
+<asm>_?"_endasm" {
count();
- yylval.yyinline = dbuf_c_str(&asmbuff);
- dbuf_detach(&asmbuff);
- BEGIN(INITIAL);
- return (INLINEASM);
+ if (!options.std_sdcc && yytext[1] != '_')
+ {
+ dbuf_append_str(&asmbuff, yytext);
+ }
+ else
+ {
+ yylval.yyinline = dbuf_c_str(&asmbuff);
+ dbuf_detach(&asmbuff);
+ BEGIN(INITIAL);
+ return (INLINEASM);
+ }
}
<asm>\n {
count();
- dbuf_append(&asmbuff, yytext, 1);
+ dbuf_append_char(&asmbuff, *yytext);
}
<asm>. {
- dbuf_append(&asmbuff, yytext, 1);
+ dbuf_append_char(&asmbuff, *yytext);
}
-"at" { count(); TKEYWORD(AT); }
+"at" { count(); TKEYWORDSDCC(AT); }
+"__at" { count(); TKEYWORD(AT); }
"auto" { count(); return(AUTO); }
-"bit" { count(); TKEYWORD(BIT); }
+"bit" { count(); TKEYWORDSDCC(BIT); }
+"__bit" { count(); TKEYWORD(BIT); }
"break" { count(); return(BREAK); }
"case" { count(); return(CASE); }
"char" { count(); return(CHAR); }
-"code" { count(); TKEYWORD(CODE); }
+"code" { count(); TKEYWORDSDCC(CODE); }
+"__code" { count(); TKEYWORD(CODE); }
"const" { count(); return(CONST); }
"continue" { count(); return(CONTINUE); }
-"critical" { count(); TKEYWORD(CRITICAL); }
-"data" { count(); TKEYWORD(DATA); }
+"critical" { count(); TKEYWORDSDCC(CRITICAL); }
+"__critical" { count(); TKEYWORD(CRITICAL); }
+"data" { count(); TKEYWORDSDCC(DATA); }
+"__data" { count(); TKEYWORD(DATA); }
"default" { count(); return(DEFAULT); }
"do" { count(); return(DO); }
"double" { count(); werror(W_DOUBLE_UNSUPPORTED);return(FLOAT); }
"else" { count(); return(ELSE); }
"enum" { count(); return(ENUM); }
"extern" { count(); return(EXTERN); }
-"far" { count(); TKEYWORD(XDATA); }
-"eeprom" { count(); TKEYWORD(EEPROM); }
+"far" { count(); TKEYWORDSDCC(XDATA); }
+"__far" { count(); TKEYWORD(XDATA); }
+"eeprom" { count(); TKEYWORDSDCC(EEPROM); }
+"__eeprom" { count(); TKEYWORD(EEPROM); }
"float" { count(); return(FLOAT); }
-"flash" { count(); TKEYWORD(CODE); }
+"fixed16x16" { count(); TKEYWORDSDCC(FIXED16X16); }
+"__fixed16x16" { count(); TKEYWORD(FIXED16X16); }
+"flash" { count(); TKEYWORDSDCC(CODE); }
+"__flash" { count(); TKEYWORD(CODE); }
"for" { count(); return(FOR); }
"goto" { count(); return(GOTO); }
-"idata" { count(); TKEYWORD(IDATA); }
+"idata" { count(); TKEYWORDSDCC(IDATA); }
+"__idata" { count(); TKEYWORD(IDATA); }
"if" { count(); return(IF); }
"int" { count(); return(INT); }
-"interrupt" { count(); return(INTERRUPT); }
-"nonbanked" { count(); TKEYWORD(NONBANKED); }
-"banked" { count(); TKEYWORD(BANKED); }
+"interrupt" { count(); TKEYWORDSDCC(INTERRUPT); }
+"__interrupt" { count(); TKEYWORD(INTERRUPT); }
+"nonbanked" { count(); TKEYWORDSDCC(NONBANKED); }
+"__nonbanked" { count(); TKEYWORD(NONBANKED); }
+"banked" { count(); TKEYWORDSDCC(BANKED); }
+"__banked" { count(); TKEYWORD(BANKED); }
"long" { count(); return(LONG); }
-"near" { count(); TKEYWORD(DATA); }
-"pdata" { count(); TKEYWORD(PDATA); }
-"reentrant" { count(); TKEYWORD(REENTRANT); }
-"shadowregs" { count(); TKEYWORD(SHADOWREGS); }
-"wparam" { count(); TKEYWORD(WPARAM); }
+"near" { count(); TKEYWORDSDCC(DATA); }
+"__near" { count(); TKEYWORD(DATA); }
+"pdata" { count(); TKEYWORDSDCC(PDATA); }
+"__pdata" { count(); TKEYWORD(PDATA); }
+"reentrant" { count(); TKEYWORDSDCC(REENTRANT); }
+"__reentrant" { count(); TKEYWORD(REENTRANT); }
+"shadowregs" { count(); TKEYWORDSDCC(SHADOWREGS); }
+"__shadowregs" { count(); TKEYWORD(SHADOWREGS); }
+"wparam" { count(); TKEYWORDSDCC(WPARAM); }
+"__wparam" { count(); TKEYWORD(WPARAM); }
"register" { count(); return(REGISTER); }
"return" { count(); return(RETURN); }
-"sfr" { count(); TKEYWORD(SFR); }
-"sbit" { count(); TKEYWORD(SBIT); }
+"sfr" { count(); TKEYWORDSDCC(SFR); }
+"__sfr" { count(); TKEYWORD(SFR); }
+"sfr16" { count(); TKEYWORDSDCC(SFR16); }
+"__sfr16" { count(); TKEYWORD(SFR16); }
+"sfr32" { count(); TKEYWORDSDCC(SFR32); }
+"__sfr32" { count(); TKEYWORD(SFR32); }
+"sbit" { count(); TKEYWORDSDCC(SBIT); }
+"__sbit" { count(); TKEYWORD(SBIT); }
"short" { count(); return(SHORT); }
"signed" { count(); return(SIGNED); }
"sizeof" { count(); return(SIZEOF); }
-"sram" { count(); TKEYWORD(XDATA); }
+"sram" { count(); TKEYWORDSDCC(XDATA); }
+"__sram" { count(); TKEYWORD(XDATA); }
"static" { count(); return(STATIC); }
"struct" { count(); return(STRUCT); }
"switch" { count(); return(SWITCH); }
"unsigned" { count(); return(UNSIGNED); }
"void" { count(); return(VOID); }
"volatile" { count(); return(VOLATILE); }
-"using" { count(); TKEYWORD(USING); }
-"_naked" { count(); TKEYWORD(NAKED); }
+"using" { count(); TKEYWORDSDCC(USING); }
+"__using" { count(); TKEYWORD(USING); }
+"_naked" { count(); TKEYWORDSDCC(NAKED); }
+"__naked" { count(); TKEYWORD(NAKED); }
"while" { count(); return(WHILE); }
-"xdata" { count(); TKEYWORD(XDATA); }
+"xdata" { count(); TKEYWORDSDCC(XDATA); }
+"__xdata" { count(); TKEYWORD(XDATA); }
"..." { count(); return(VAR_ARGS); }
"__typeof" { count(); return TYPEOF; }
"_JavaNative" { count(); TKEYWORD(JAVANATIVE); }
-"_overlay" { count(); TKEYWORD(OVERLAY); }
+"_overlay" { count(); TKEYWORDSDCC(OVERLAY); }
+"__overlay" { count(); TKEYWORD(OVERLAY); }
+"inline" { count(); TKEYWORD99(INLINE); }
+"restrict" { count(); TKEYWORD99(RESTRICT); }
{L}({L}|{D})* { count(); return(check_type()); }
0[xX]{H}+{IS}? { count(); yylval.val = constVal(yytext); return(CONSTANT); }
0[0-7]*{IS}? { count(); yylval.val = constVal(yytext); return(CONSTANT); }
"^" { count(); return('^'); }
"|" { count(); return('|'); }
"?" { count(); return('?'); }
-^#pragma.*"\n" { count(); process_pragma(yytext); }
+^#pragma.*$ { count(); process_pragma(yytext); }
^(#line.*"\n")|(#.*"\n") { count(); checkCurrFile(yytext); }
^[^(]+"("[0-9]+") : error"[^\n]+ { werror(E_PRE_PROC_FAILED, yytext); count(); }
#endif
-static int checkCurrFile (char *s)
+static int checkCurrFile (const char *s)
{
int lNum;
char *tptr;
/* get the line number */
lNum = strtol(s, &tptr, 10);
- if (tptr == s || !isspace(*tptr))
+ if (tptr == s || !isspace((unsigned char)*tptr))
return 0;
s = tptr;
/* now see if we have a file name */
- while (*s != '\"' && *s)
- s++;
+ while (*s != '"' && *s)
+ ++s;
/* if we don't have a filename then */
/* set the current line number to */
/* if we have a filename then check */
/* if it is "standard in" if yes then */
/* get the currentfile name info */
- s++ ;
+ ++s;
/* in c1mode fullSrcFileName is NULL */
if (fullSrcFileName &&
strncmp(s, fullSrcFileName, strlen(fullSrcFileName)) == 0) {
lineno = mylineno = lNum;
currFname = fullSrcFileName;
- } else {
- char *sb = s;
- /* mark the end of the filename */
- while (*s != '"') s++;
- *s = '\0';
- currFname = strdup (sb);
- lineno = mylineno = lNum;
+ }
+ else {
+ const char *sb = s;
+
+ /* find the end of the filename */
+ while (*s && *s != '"')
+ ++s;
+ currFname = Safe_malloc(s - sb + 1);
+ memcpy(currFname, sb, s - sb);
+ currFname[s - sb] = '\0';
+ lineno = mylineno = lNum;
}
filename = currFname ;
return 0;
if (dbuf.alloc == 0)
dbuf_init(&dbuf, STR_BUF_CHUNCK_LEN);
else
- dbuf_set_size(&dbuf, 0);
+ dbuf_set_length(&dbuf, 0);
- dbuf_append(&dbuf, "\"", 1);
+ dbuf_append_char(&dbuf, '"');
/* put into the buffer till we hit the first \" */
while ((ch = input()) != 0) {
case '\n':
/* if new line we have a new line break, which is illegal */
werror(W_NEWLINE_IN_STRING);
- dbuf_append(&dbuf, "\n", 1);
+ dbuf_append_char(&dbuf, '\n');
lineno = ++mylineno;
column = 0;
break;
/* if this is a quote then we have work to do */
/* find the next non whitespace character */
/* if that is a double quote then carry on */
- dbuf_append(&dbuf, "\"", 1); /* Pass end of this string or substring to evaluator */
- while ((ch = input()) && (isspace(ch) || ch == '\\')) {
+ dbuf_append_char(&dbuf, '"'); /* Pass end of this string or substring to evaluator */
+ while ((ch = input()) && (isspace(ch) || ch == '\\' || ch == '#')) {
switch (ch) {
case '\\':
if ((ch = input()) != '\n') {
break;
case '\n':
- mylineno++;
+ lineno = ++mylineno;
+ column = 0;
break;
+
+ case '#':
+ if (0 == column) {
+ /* # at the beginning of the line: collect the entire line */
+ struct dbuf_s linebuf;
+ const char *line;
+
+ dbuf_init(&linebuf, STR_BUF_CHUNCK_LEN);
+ dbuf_append_char(&linebuf, '#');
+
+ while ((ch = input()) && ch != '\n') {
+ dbuf_append_char(&linebuf, (char)ch);
+ }
+
+ if (ch == '\n') {
+ lineno = ++mylineno;
+ column = 0;
+ }
+
+ line = dbuf_c_str(&linebuf);
+
+ /* process the line */
+ if (startsWith(line, "#pragma"))
+ process_pragma(line);
+ else
+ checkCurrFile(line);
+
+ dbuf_destroy(&linebuf);
+ }
}
}
if (!ch)
goto out;
- if (ch != '\"') {
+ if (ch != '"') {
unput(ch);
goto out;
}
break;
default:
- buf[0] = ch;
- dbuf_append(&dbuf, buf, 1); /* Put next substring introducer into output string */
+ dbuf_append_char(&dbuf, (char)ch); /* Put next substring introducer into output string */
}
}
}
-enum pragma_id {
+enum {
P_SAVE = 1,
P_RESTORE,
P_NOINDUCTION,
P_DISABLEWARN,
P_OPTCODESPEED,
P_OPTCODESIZE,
- P_OPTCODEBALANCED
+ P_OPTCODEBALANCED,
+ P_STD_C89,
+ P_STD_C99,
+ P_STD_SDCC89,
+ P_STD_SDCC99,
+ P_CODESEG,
+ P_CONSTSEG
};
STACK_DCL(options_stack, struct options *, SAVE_RESTORE_SIZE)
STACK_DCL(optimize_stack, struct optimize *, SAVE_RESTORE_SIZE)
+STACK_DCL(SDCCERRG_stack, struct SDCCERRG *, SAVE_RESTORE_SIZE)
/*
* cloneXxx functions should be updated every time a new set is
{
struct optimize *new_opt;
- new_opt = Safe_malloc(sizeof (struct options));
+ new_opt = Safe_malloc(sizeof (struct optimize));
/* clone scalar values */
*new_opt = *opt;
return new_opt;
}
+static struct SDCCERRG *cloneSDCCERRG (struct SDCCERRG *val)
+{
+ struct SDCCERRG *new_val;
+
+ new_val = Safe_malloc(sizeof (struct SDCCERRG));
+
+ /* clone scalar values */
+ *new_val = *val;
+
+ return new_val;
+}
+
static void copyAndFreeOptions(struct options *dest, struct options *src)
{
/* delete dest sets */
/* not implemented yet: */
/* deleteSet(&dest->olaysSet); */
- /* dopy src to dest */
+ /* copy src to dest */
*dest = *src;
Safe_free(src);
static void copyAndFreeOptimize(struct optimize *dest, struct optimize *src)
{
- /* dopy src to dest */
+ /* copy src to dest */
*dest = *src;
Safe_free(src);
}
-static void doPragma(int op, char *cp)
+static void copyAndFreeSDCCERRG(struct SDCCERRG *dest, struct SDCCERRG *src)
{
- int i;
+ /* copy src to dest */
+ *dest = *src;
- switch (op) {
- case P_SAVE:
- {
- STACK_PUSH(options_stack, cloneOptions(&options));
- STACK_PUSH(optimize_stack, cloneOptimize(&optimize));
- }
- break;
+ Safe_free(src);
+}
- case P_RESTORE:
+/*
+ * returns 1 if the pragma was processed, 0 if not
+ */
+static int doPragma(int id, const char *name, const char *cp)
+{
+ struct pragma_token_s token;
+ int err = 0;
+ int processed = 1;
+
+ init_pragma_token(&token);
+
+ switch (id)
{
- struct options *optionsp;
- struct optimize *optimizep;
+ case P_SAVE:
+ {
+ cp = get_pragma_token(cp, &token);
+ if (TOKEN_EOL != token.type)
+ {
+ err = 1;
+ break;
+ }
- optionsp = STACK_POP(options_stack);
- copyAndFreeOptions(&options, optionsp);
+ STACK_PUSH(options_stack, cloneOptions(&options));
+ STACK_PUSH(optimize_stack, cloneOptimize(&optimize));
+ STACK_PUSH(SDCCERRG_stack, cloneSDCCERRG(&_SDCCERRG));
+ }
+ break;
- optimizep = STACK_POP(optimize_stack);
- copyAndFreeOptimize(&optimize, optimizep);
- }
- break;
+ case P_RESTORE:
+ {
+ struct options *optionsp;
+ struct optimize *optimizep;
+ struct SDCCERRG *sdccerrgp;
+
+ cp = get_pragma_token(cp, &token);
+ if (TOKEN_EOL != token.type)
+ {
+ err = 1;
+ break;
+ }
- case P_NOINDUCTION:
- optimize.loopInduction = 0;
- break;
+ optionsp = STACK_POP(options_stack);
+ copyAndFreeOptions(&options, optionsp);
- case P_NOINVARIANT:
- optimize.loopInvariant = 0;
- break;
+ optimizep = STACK_POP(optimize_stack);
+ copyAndFreeOptimize(&optimize, optimizep);
- case P_INDUCTION:
- optimize.loopInduction = 1;
- break;
+ sdccerrgp = STACK_POP(SDCCERRG_stack);
+ copyAndFreeSDCCERRG(&_SDCCERRG, sdccerrgp);
+ }
+ break;
- case P_STACKAUTO:
- options.stackAuto = 1;
- break;
+ case P_NOINDUCTION:
+ cp = get_pragma_token(cp, &token);
+ if (TOKEN_EOL != token.type)
+ {
+ err = 1;
+ break;
+ }
- case P_NOJTBOUND:
- optimize.noJTabBoundary = 1;
- break;
+ optimize.loopInduction = 0;
+ break;
- case P_NOGCSE:
- optimize.global_cse = 0;
- break;
+ case P_NOINVARIANT:
+ cp = get_pragma_token(cp, &token);
+ if (TOKEN_EOL != token.type)
+ {
+ err = 1;
+ break;
+ }
- case P_NOOVERLAY:
- options.noOverlay = 1;
- break;
+ optimize.loopInvariant = 0;
+ break;
- case P_LESSPEDANTIC:
- options.lessPedantic = 1;
- break;
+ case P_INDUCTION:
+ cp = get_pragma_token(cp, &token);
+ if (TOKEN_EOL != token.type)
+ {
+ err = 1;
+ break;
+ }
- case P_CALLEE_SAVES:
- /* append to the functions already listed
- in callee-saves */
- setParseWithComma(&options.calleeSavesSet, cp);
- break;
+ optimize.loopInduction = 1;
+ break;
- case P_EXCLUDE:
- {
- deleteSet(&options.excludeRegsSet);
- setParseWithComma(&options.excludeRegsSet, cp);
- }
- break;
+ case P_STACKAUTO:
+ cp = get_pragma_token(cp, &token);
+ if (TOKEN_EOL != token.type)
+ {
+ err = 1;
+ break;
+ }
- case P_NOIV:
- options.noiv = 1;
- break;
+ options.stackAuto = 1;
+ break;
- case P_LOOPREV:
- optimize.noLoopReverse = 1;
- break;
+ case P_NOJTBOUND:
+ cp = get_pragma_token(cp, &token);
+ if (TOKEN_EOL != token.type)
+ {
+ err = 1;
+ break;
+ }
- case P_OVERLAY_:
- break; /* notyet */
+ optimize.noJTabBoundary = 1;
+ break;
- case P_DISABLEWARN:
- if (sscanf(cp, "%d", &i) && (i<MAX_ERROR_WARNING))
+ case P_NOGCSE:
+ cp = get_pragma_token(cp, &token);
+ if (TOKEN_EOL != token.type)
+ {
+ err = 1;
+ break;
+ }
+
+ optimize.global_cse = 0;
+ break;
+
+ case P_NOOVERLAY:
+ cp = get_pragma_token(cp, &token);
+ if (TOKEN_EOL != token.type)
+ {
+ err = 1;
+ break;
+ }
+
+ options.noOverlay = 1;
+ break;
+
+ case P_LESSPEDANTIC:
+ cp = get_pragma_token(cp, &token);
+ if (TOKEN_EOL != token.type)
+ {
+ err = 1;
+ break;
+ }
+
+ options.lessPedantic = 1;
+ setErrorLogLevel(ERROR_LEVEL_WARNING);
+ break;
+
+ case P_CALLEE_SAVES:
+ /* append to the functions already listed
+ in callee-saves */
+ setParseWithComma(&options.calleeSavesSet, cp);
+ err = -1;
+ break;
+
+ case P_EXCLUDE:
{
- setWarningDisabled(i);
+ deleteSet(&options.excludeRegsSet);
+ setParseWithComma(&options.excludeRegsSet, cp);
+ err = -1;
}
- break;
-
- case P_OPTCODESPEED:
- optimize.codeSpeed = 1;
- optimize.codeSize = 0;
- break;
-
- case P_OPTCODESIZE:
- optimize.codeSpeed = 0;
- optimize.codeSize = 1;
- break;
-
- case P_OPTCODEBALANCED:
- optimize.codeSpeed = 0;
- optimize.codeSize = 0;
- break;
+ break;
- }
+ case P_NOIV:
+ cp = get_pragma_token(cp, &token);
+ if (TOKEN_EOL != token.type)
+ {
+ err = 1;
+ break;
+ }
+
+ options.noiv = 1;
+ break;
+
+ case P_LOOPREV:
+ cp = get_pragma_token(cp, &token);
+ if (TOKEN_EOL != token.type)
+ {
+ err = 1;
+ break;
+ }
+
+ optimize.noLoopReverse = 1;
+ break;
+
+ case P_OVERLAY_:
+ cp = get_pragma_token(cp, &token);
+ if (TOKEN_EOL != token.type)
+ {
+ err = 1;
+ break;
+ }
+
+ break; /* notyet */
+
+ case P_DISABLEWARN:
+ {
+ int warn;
+
+ cp = get_pragma_token(cp, &token);
+ if (TOKEN_INT != token.type)
+ {
+ err = 1;
+ break;
+ }
+ warn = token.val.int_val;
+
+ cp = get_pragma_token(cp, &token);
+ if (TOKEN_EOL != token.type)
+ {
+ err = 1;
+ break;
+ }
+
+ if (warn < MAX_ERROR_WARNING)
+ setWarningDisabled(warn);
+ }
+ break;
+
+ case P_OPTCODESPEED:
+ cp = get_pragma_token(cp, &token);
+ if (TOKEN_EOL != token.type)
+ {
+ err = 1;
+ break;
+ }
+
+ optimize.codeSpeed = 1;
+ optimize.codeSize = 0;
+ break;
+
+ case P_OPTCODESIZE:
+ cp = get_pragma_token(cp, &token);
+ if (TOKEN_EOL != token.type)
+ {
+ err = 1;
+ break;
+ }
+
+ optimize.codeSpeed = 0;
+ optimize.codeSize = 1;
+ break;
+
+ case P_OPTCODEBALANCED:
+ cp = get_pragma_token(cp, &token);
+ if (TOKEN_EOL != token.type)
+ {
+ err = 1;
+ break;
+ }
+
+ optimize.codeSpeed = 0;
+ optimize.codeSize = 0;
+ break;
+
+ case P_STD_C89:
+ cp = get_pragma_token(cp, &token);
+ if (TOKEN_EOL != token.type)
+ {
+ err = 1;
+ break;
+ }
+
+ options.std_c99 = 0;
+ options.std_sdcc = 0;
+ break;
+
+ case P_STD_C99:
+ cp = get_pragma_token(cp, &token);
+ if (TOKEN_EOL != token.type)
+ {
+ err = 1;
+ break;
+ }
+
+ options.std_c99 = 1;
+ options.std_sdcc = 0;
+ break;
+
+ case P_STD_SDCC89:
+ cp = get_pragma_token(cp, &token);
+ if (TOKEN_EOL != token.type)
+ {
+ err = 1;
+ break;
+ }
+
+ options.std_c99 = 0;
+ options.std_sdcc = 1;
+ break;
+
+ case P_STD_SDCC99:
+ cp = get_pragma_token(cp, &token);
+ if (TOKEN_EOL != token.type)
+ {
+ err = 1;
+ break;
+ }
+
+ options.std_c99 = 1;
+ options.std_sdcc = 1;
+ break;
+
+ case P_CODESEG:
+ {
+ const char *segname;
+
+ cp = get_pragma_token(cp, &token);
+ if (token.type == TOKEN_EOL)
+ {
+ err = 1;
+ break;
+ }
+ segname = get_pragma_string(&token);
+
+ cp = get_pragma_token(cp, &token);
+ if (token.type != TOKEN_EOL)
+ {
+ err = 1;
+ break;
+ }
+
+ if (strlen(segname) > 8)
+ {
+ err = 1;
+ break;
+ }
+ else
+ {
+ dbuf_append(&token.dbuf, "(CODE)", (sizeof "(CODE)") - 1);
+ options.code_seg = Safe_strdup(get_pragma_string(&token));
+ }
+ }
+ break;
+
+ case P_CONSTSEG:
+ {
+ const char *segname;
+
+ cp = get_pragma_token(cp, &token);
+ if (token.type == TOKEN_EOL)
+ {
+ err = 1;
+ break;
+ }
+ segname = get_pragma_string(&token);
+
+ cp = get_pragma_token(cp, &token);
+ if (token.type != TOKEN_EOL)
+ {
+ err = 1;
+ break;
+ }
+
+ if (strlen(segname) > 8)
+ {
+ err = 1;
+ break;
+ }
+ else
+ {
+ dbuf_append(&token.dbuf, "(CODE)", (sizeof "(CODE)") - 1);
+ options.code_seg = Safe_strdup(get_pragma_string(&token));
+ }
+ }
+ break;
+
+ default:
+ processed = 0;
+ break;
+ }
+
+ get_pragma_token(cp, &token);
+
+ if (1 == err || (0 == err && token.type != TOKEN_EOL))
+ werror(W_BAD_PRAGMA_ARGUMENTS, name);
+
+ free_pragma_token(&token);
+ return processed;
}
-static int process_pragma(char *s)
-{
-#define NELEM(x) (sizeof (x) / sizeof (x)[0])
-#define PRAGMA_STR "#pragma"
-#define PRAGMA_LEN ((sizeof PRAGMA_STR) - 1)
+static struct pragma_s pragma_tbl[] = {
+ { "save", P_SAVE, 0, doPragma },
+ { "restore", P_RESTORE, 0, doPragma },
+ { "noinduction", P_NOINDUCTION, 0, doPragma },
+ { "noinvariant", P_NOINVARIANT, 0, doPragma },
+ { "noloopreverse", P_LOOPREV, 0, doPragma },
+ { "induction", P_INDUCTION, 0, doPragma },
+ { "stackauto", P_STACKAUTO, 0, doPragma },
+ { "nojtbound", P_NOJTBOUND, 0, doPragma },
+ { "nogcse", P_NOGCSE, 0, doPragma },
+ { "nooverlay", P_NOOVERLAY, 0, doPragma },
+ { "callee_saves", P_CALLEE_SAVES, 0, doPragma },
+ { "exclude", P_EXCLUDE, 0, doPragma },
+ { "noiv", P_NOIV, 0, doPragma },
+ { "overlay", P_OVERLAY_, 0, doPragma },
+ { "less_pedantic", P_LESSPEDANTIC, 0, doPragma },
+ { "disable_warning",P_DISABLEWARN, 0, doPragma },
+ { "opt_code_speed", P_OPTCODESPEED, 0, doPragma },
+ { "opt_code_size", P_OPTCODESIZE, 0, doPragma },
+ { "opt_code_balanced", P_OPTCODEBALANCED, 0, doPragma },
+ { "std_c89", P_STD_C89, 0, doPragma },
+ { "std_c99", P_STD_C99, 0, doPragma },
+ { "std_sdcc89", P_STD_SDCC89, 0, doPragma },
+ { "std_sdcc99", P_STD_SDCC99, 0, doPragma },
+ { "codeseg", P_CODESEG, 0, doPragma },
+ { "constseg", P_CONSTSEG, 0, doPragma },
+ { NULL, 0, 0, NULL },
+};
- static struct pragma_s
- {
- const char *name;
- enum pragma_id id;
- char deprecated;
- } pragma_tbl[] = {
- { "save", P_SAVE, 0 },
- { "restore", P_RESTORE, 0 },
- { "noinduction", P_NOINDUCTION, 0 },
- { "noinvariant", P_NOINVARIANT, 0 },
- { "noloopreverse", P_LOOPREV, 0 },
- { "induction", P_INDUCTION, 0 },
- { "stackauto", P_STACKAUTO, 0 },
- { "nojtbound", P_NOJTBOUND, 0 },
- { "nogcse", P_NOGCSE, 0 },
- { "nooverlay", P_NOOVERLAY, 0 },
- { "callee_saves", P_CALLEE_SAVES, 0 },
- { "exclude", P_EXCLUDE, 0 },
- { "noiv", P_NOIV, 0 },
- { "overlay", P_OVERLAY_, 0 },
- { "less_pedantic", P_LESSPEDANTIC, 0 },
- { "disable_warning",P_DISABLEWARN, 0 },
- { "opt_code_speed", P_OPTCODESPEED, 0 },
- { "opt_code_size", P_OPTCODESIZE, 0 },
- { "opt_code_balanced", P_OPTCODEBALANCED, 0 },
-
- /*
- * The following lines are deprecated pragmas,
- * only for bacward compatibility.
- * They should be removed in next major release after 1.4.0
- */
-
- { "SAVE", P_SAVE, 1 },
- { "RESTORE", P_RESTORE, 1 },
- { "NOINDUCTION", P_NOINDUCTION, 1 },
- { "NOINVARIANT", P_NOINVARIANT, 1 },
- { "NOLOOPREVERSE", P_LOOPREV, 1 },
- { "INDUCTION", P_INDUCTION, 1 },
- { "STACKAUTO", P_STACKAUTO, 1 },
- { "NOJTBOUND", P_NOJTBOUND, 1 },
- { "NOGCSE", P_NOGCSE, 1 },
- { "NOOVERLAY", P_NOOVERLAY, 1 },
- { "CALLEE-SAVES", P_CALLEE_SAVES, 1 },
- { "EXCLUDE", P_EXCLUDE, 1 },
- { "NOIV", P_NOIV, 1 },
- { "OVERLAY", P_OVERLAY_, 1 },
- { "LESS_PEDANTIC", P_LESSPEDANTIC, 1 },
- };
- char *cp;
+/*
+ * returns 1 if the pragma was processed, 0 if not
+ */
+int
+process_pragma_tbl(const struct pragma_s *pragma_tbl, const char *s)
+{
+ struct pragma_token_s token;
int i;
+ int ret = 0;
- /* find the pragma */
- while (strncmp(s, PRAGMA_STR, PRAGMA_LEN))
- s++;
- s += PRAGMA_LEN;
+ init_pragma_token(&token);
- /* look for the directive */
- while(isspace(*s))
- s++;
+ s = get_pragma_token(s, &token);
- cp = s;
- /* look for the end of the directive */
- while ((!isspace(*s)) && (*s != '\n'))
- s++ ;
-
- /* First give the port a chance */
- if (port->process_pragma && !port->process_pragma(cp))
- return 0;
+ /* skip separating whitespace */
+ while ('\n' != *s && isspace((unsigned char)*s))
+ s++;
- for (i = 0; i < NELEM(pragma_tbl); i++)
+ for (i = 0; NULL != pragma_tbl[i].name; ++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)
+ if (strcmp(get_pragma_string(&token), pragma_tbl[i].name) == 0)
{
if (pragma_tbl[i].deprecated != 0)
werror(W_DEPRECATED_PRAGMA, pragma_tbl[i].name);
- doPragma(pragma_tbl[i].id, cp + len);
- return 0;
+ ret = (*pragma_tbl[i].func)(pragma_tbl[i].id, pragma_tbl[i].name, s);
+ break;
}
}
- werror(W_UNKNOWN_PRAGMA, cp);
- return 0;
+ free_pragma_token(&token);
+ return ret;
+}
+
+static int process_pragma(const char *s)
+{
+ struct pragma_token_s token;
+
+ init_pragma_token(&token);
+
+ s = get_pragma_token(s, &token);
+ if (0 != strcmp("#pragma", get_pragma_string(&token)))
+ {
+ /* Oops, womething went totally wrong - internal error */
+ wassertl(0, "pragma parser internal error");
+ }
+
+ /* skip spaces */
+ while ('\n' != *s && isspace((unsigned char)*s))
+ ++s;
+
+ /* First give the port a chance */
+ if (port->process_pragma && port->process_pragma(s))
+ return 1;
+
+ if (process_pragma_tbl(pragma_tbl, s))
+ {
+ return 1;
+ }
+ else
+ {
+ werror(W_UNKNOWN_PRAGMA, s);
+ return 0;
+ }
}
/* will return 1 if the string is a part
of a target specific keyword */
-static int isTargetKeyword(char *s)
+static int isTargetKeyword(const char *s)
{
int i;
if (port->keywords == NULL)
return 0;
- for (i = 0 ; port->keywords[i] ; i++ ) {
- if (strcmp(port->keywords[i],s) == 0)
- return 1;
- }
- return 0;
+ if (s[0] == '_' && s[1] == '_')
+ {
+ /* Keywords in the port's array have either 0 or 1 underscore, */
+ /* so skip over the appropriate number of chars when comparing */
+ for (i = 0 ; port->keywords[i] ; i++ )
+ {
+ if (port->keywords[i][0] == '_' &&
+ strcmp(port->keywords[i],s+1) == 0)
+ return 1;
+ else if (strcmp(port->keywords[i],s+2) == 0)
+ return 1;
+ }
+ }
+ else
+ {
+ for (i = 0 ; port->keywords[i] ; i++ )
+ {
+ if (strcmp(port->keywords[i],s) == 0)
+ return 1;
+ }
+ }
+
+ return 0;
}
int yywrap(void)
{
fflush(stdout);
- 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 */
- }
+ 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++;
+
return 0;
}