X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=src%2Fcc65%2Fpragma.c;h=608ef7e6d03db81ab588ea64c6453f8c07faa9b4;hb=112ae0e3db511ddd92e769c11328646ebe2a6240;hp=47f4da0afda46fe22ff422e57ccd79c9a2cbc9bd;hpb=a1fb355a9ab6058b3b353eec4509608d431c7995;p=cc65 diff --git a/src/cc65/pragma.c b/src/cc65/pragma.c index 47f4da0af..608ef7e6d 100644 --- a/src/cc65/pragma.c +++ b/src/cc65/pragma.c @@ -62,43 +62,63 @@ /* Tokens for the #pragmas */ typedef enum { - PR_ILLEGAL = -1, - PR_BSSSEG, - PR_CHARMAP, - PR_CHECKSTACK, - PR_CODESEG, - PR_CODESIZE, - PR_DATASEG, - PR_OPTIMIZE, - PR_REGVARADDR, - PR_REGVARS, - PR_RODATASEG, - PR_SIGNEDCHARS, - PR_STATICLOCALS, - PR_WARN, - PR_ZPSYM, - PR_COUNT + PRAGMA_ILLEGAL = -1, + PRAGMA_BSS_NAME, + PRAGMA_BSSSEG, /* obsolete */ + PRAGMA_CHARMAP, + PRAGMA_CHECK_STACK, + PRAGMA_CHECKSTACK, /* obsolete */ + PRAGMA_CODE_NAME, + PRAGMA_CODESEG, /* obsolete */ + PRAGMA_CODESIZE, + PRAGMA_DATA_NAME, + PRAGMA_DATASEG, /* obsolete */ + PRAGMA_LOCAL_STRINGS, + PRAGMA_OPTIMIZE, + PRAGMA_REGVARADDR, + PRAGMA_REGISTER_VARS, + PRAGMA_REGVARS, /* obsolete */ + PRAGMA_RODATA_NAME, + PRAGMA_RODATASEG, /* obsolete */ + PRAGMA_SIGNED_CHARS, + PRAGMA_SIGNEDCHARS, /* obsolete */ + PRAGMA_STATIC_LOCALS, + PRAGMA_STATICLOCALS, /* obsolete */ + PRAGMA_WARN, + PRAGMA_WRITABLE_STRINGS, + PRAGMA_ZPSYM, + PRAGMA_COUNT } pragma_t; /* Pragma table */ static const struct Pragma { const char* Key; /* Keyword */ pragma_t Tok; /* Token */ -} Pragmas[PR_COUNT] = { - { "bssseg", PR_BSSSEG }, - { "charmap", PR_CHARMAP }, - { "checkstack", PR_CHECKSTACK }, - { "codeseg", PR_CODESEG }, - { "codesize", PR_CODESIZE }, - { "dataseg", PR_DATASEG }, - { "optimize", PR_OPTIMIZE }, - { "regvaraddr", PR_REGVARADDR }, - { "regvars", PR_REGVARS }, - { "rodataseg", PR_RODATASEG }, - { "signedchars", PR_SIGNEDCHARS }, - { "staticlocals", PR_STATICLOCALS }, - { "warn", PR_WARN }, - { "zpsym", PR_ZPSYM }, +} Pragmas[PRAGMA_COUNT] = { + { "bss-name", PRAGMA_BSS_NAME }, + { "bssseg", PRAGMA_BSSSEG }, /* obsolete */ + { "charmap", PRAGMA_CHARMAP }, + { "check-stack", PRAGMA_CHECK_STACK }, + { "checkstack", PRAGMA_CHECKSTACK }, /* obsolete */ + { "code-name", PRAGMA_CODE_NAME }, + { "codeseg", PRAGMA_CODESEG }, /* obsolete */ + { "codesize", PRAGMA_CODESIZE }, + { "data-name", PRAGMA_DATA_NAME }, + { "dataseg", PRAGMA_DATASEG }, /* obsolete */ + { "local-strings", PRAGMA_LOCAL_STRINGS }, + { "optimize", PRAGMA_OPTIMIZE }, + { "register-vars", PRAGMA_REGISTER_VARS }, + { "regvaraddr", PRAGMA_REGVARADDR }, + { "regvars", PRAGMA_REGVARS }, /* obsolete */ + { "rodata-name", PRAGMA_RODATA_NAME }, + { "rodataseg", PRAGMA_RODATASEG }, /* obsolete */ + { "signed-chars", PRAGMA_SIGNED_CHARS }, + { "signedchars", PRAGMA_SIGNEDCHARS }, /* obsolete */ + { "static-locals", PRAGMA_STATIC_LOCALS }, + { "staticlocals", PRAGMA_STATICLOCALS }, /* obsolete */ + { "warn", PRAGMA_WARN }, + { "writable-strings", PRAGMA_WRITABLE_STRINGS }, + { "zpsym", PRAGMA_ZPSYM }, }; /* Result of ParsePushPop */ @@ -137,13 +157,13 @@ static int CmpKey (const void* Key, const void* Elem) static pragma_t FindPragma (const StrBuf* Key) -/* Find a pragma and return the token. Return PR_ILLEGAL if the keyword is +/* Find a pragma and return the token. Return PRAGMA_ILLEGAL if the keyword is * not a valid pragma. */ { struct Pragma* P; - P = bsearch (SB_GetConstBuf (Key), Pragmas, PR_COUNT, sizeof (Pragmas[0]), CmpKey); - return P? P->Tok : PR_ILLEGAL; + P = bsearch (SB_GetConstBuf (Key), Pragmas, PRAGMA_COUNT, sizeof (Pragmas[0]), CmpKey); + return P? P->Tok : PRAGMA_ILLEGAL; } @@ -634,14 +654,7 @@ static void ParsePragma (void) /* Create a string buffer from the string literal */ StrBuf B = AUTO_STRBUF_INITIALIZER; - GetLiteralStrBuf (&B, CurTok.IVal); - - /* Reset the string pointer, effectivly clearing the string from the - * string table. Since we're working with one token lookahead, this - * will fail if the next token is also a string token, but that's a - * syntax error anyway, because we expect a right paren. - */ - ResetLiteralPoolOffs (CurTok.IVal); + SB_Append (&B, GetLiteralStrBuf (CurTok.SVal)); /* Skip the string token */ NextToken (); @@ -657,12 +670,13 @@ static void ParsePragma (void) Pragma = FindPragma (&Ident); /* Do we know this pragma? */ - if (Pragma == PR_ILLEGAL) { + if (Pragma == PRAGMA_ILLEGAL) { /* According to the ANSI standard, we're not allowed to generate errors - * for unknown pragmas, however, we're allowed to warn - and we will - * do so. Otherwise one typo may give you hours of bug hunting... + * for unknown pragmas, but warn about them if enabled (the default). */ - Warning ("Unknown pragma `%s'", SB_GetConstBuf (&Ident)); + if (IS_Get (&WarnUnknownPragma)) { + Warning ("Unknown pragma `%s'", SB_GetConstBuf (&Ident)); + } goto ExitPoint; } @@ -679,59 +693,91 @@ static void ParsePragma (void) /* Switch for the different pragmas */ switch (Pragma) { - case PR_BSSSEG: + case PRAGMA_BSSSEG: + Warning ("#pragma bssseg is obsolete, please use #pragma bss-name instead"); + /* FALLTHROUGH */ + case PRAGMA_BSS_NAME: SegNamePragma (&B, SEG_BSS); break; - case PR_CHARMAP: + case PRAGMA_CHARMAP: CharMapPragma (&B); break; - case PR_CHECKSTACK: + case PRAGMA_CHECKSTACK: + Warning ("#pragma checkstack is obsolete, please use #pragma check-stack instead"); + /* FALLTHROUGH */ + case PRAGMA_CHECK_STACK: FlagPragma (&B, &CheckStack); break; - case PR_CODESEG: + case PRAGMA_CODESEG: + Warning ("#pragma codeseg is obsolete, please use #pragma code-name instead"); + /* FALLTHROUGH */ + case PRAGMA_CODE_NAME: SegNamePragma (&B, SEG_CODE); break; - case PR_CODESIZE: + case PRAGMA_CODESIZE: IntPragma (&B, &CodeSizeFactor, 10, 1000); break; - case PR_DATASEG: + case PRAGMA_DATASEG: + Warning ("#pragma dataseg is obsolete, please use #pragma data-name instead"); + /* FALLTHROUGH */ + case PRAGMA_DATA_NAME: SegNamePragma (&B, SEG_DATA); break; - case PR_OPTIMIZE: + case PRAGMA_LOCAL_STRINGS: + FlagPragma (&B, &LocalStrings); + break; + + case PRAGMA_OPTIMIZE: FlagPragma (&B, &Optimize); break; - case PR_REGVARADDR: + case PRAGMA_REGVARADDR: FlagPragma (&B, &AllowRegVarAddr); break; - case PR_REGVARS: + case PRAGMA_REGVARS: + Warning ("#pragma regvars is obsolete, please use #pragma register-vars instead"); + /* FALLTHROUGH */ + case PRAGMA_REGISTER_VARS: FlagPragma (&B, &EnableRegVars); break; - case PR_RODATASEG: + case PRAGMA_RODATASEG: + Warning ("#pragma rodataseg is obsolete, please use #pragma rodata-name instead"); + /* FALLTHROUGH */ + case PRAGMA_RODATA_NAME: SegNamePragma (&B, SEG_RODATA); break; - case PR_SIGNEDCHARS: + case PRAGMA_SIGNEDCHARS: + Warning ("#pragma signedchars is obsolete, please use #pragma signed-chars instead"); + /* FALLTHROUGH */ + case PRAGMA_SIGNED_CHARS: FlagPragma (&B, &SignedChars); break; - case PR_STATICLOCALS: + case PRAGMA_STATICLOCALS: + Warning ("#pragma staticlocals is obsolete, please use #pragma static-locals instead"); + /* FALLTHROUGH */ + case PRAGMA_STATIC_LOCALS: FlagPragma (&B, &StaticLocals); break; - case PR_WARN: + case PRAGMA_WARN: WarnPragma (&B); break; - case PR_ZPSYM: + case PRAGMA_WRITABLE_STRINGS: + FlagPragma (&B, &WritableStrings); + break; + + case PRAGMA_ZPSYM: StringPragma (&B, MakeZPSym); break;