Changed names of the pragmas to be identical to the corresponding command line

options. This should make use easier. The old names of the pragmas are still
available but will cause warnings.

git-svn-id: svn://svn.cc65.org/cc65/trunk@4364 b7a2c559-68d2-44c3-8de9-860c34a00d81

diff --git a/doc/cc65.sgml b/doc/cc65.sgml
index 2226cc26fcf9e450cc7bc9a2b475d94ddda5b000..4171a41d450e8d87f65c06aab31ac504435f9826 100644 (file)
--- a/doc/cc65.sgml
+++ b/doc/cc65.sgml
@@ -3,7 +3,7 @@
 <article>
 <title>cc65 Users Guide
 <author>Ullrich von Bassewitz, <htmlurl url="mailto:uz@cc65.org" name="uz@cc65.org">
-<date>03.09.2000, 02.10.2001, 2005-8-1
+<date>2000-09-03, 2001-10-02, 2005-08-01
 
 <abstract>
 cc65 is a C compiler for 6502 targets. It supports several 6502 based home
@@ -23,11 +23,7 @@ John R. Dunning. In prior releases I've described the compiler by listing
 up the changes made by me. I have made many more changes in the meantime
 (and rewritten major parts of the compiler), so I will no longer do that,
 since the list would be too large and of no use to anyone. Instead I will
-describe the compiler in respect to the ANSI/ISO C standard. In fact, I'm
-planning a complete rewrite (that is, a complete new compiler) for the
-next release, since there are too many limitations in the current code,
-and removing these limitations would mean a rewrite of many more parts of
-the compiler.
+describe the compiler in respect to the ANSI/ISO C standard.
 
 There are separate documents named <url url="library.html"> and <url
 url="funcref.html"> that cover the library that is available for the compiler.
@@ -108,21 +104,26 @@ Here is a description of all the command line options:
 
 <descrip>
 
+  <label id="option-bss-name">
   <tag><tt>--bss-name seg</tt></tag>
 
-  Set the name of the bss segment.
+  Set the name of the bss segment. See also <tt/<ref id="pragma-bss-name"
+  name="#pragma&nbsp;bss-name">/.
 
 
+  <label id="option-check-stack">
   <tag><tt>--check-stack</tt></tag>
 
   Tells the compiler to generate code that checks for stack overflows. See
-  <tt><ref id="pragma-checkstack" name="#pragma&nbsp;checkstack"></tt> for an
+  <tt/<ref id="pragma-check-stack" name="#pragma&nbsp;check-stack">/ for an
   explanation of this feature.
 
 
+  <label id="option-code-name">
   <tag><tt>--code-name seg</tt></tag>
 
-  Set the name of the code segment.
+  Set the name of the code segment. See also <tt/<ref id="pragma-code-name"
+  name="#pragma&nbsp;code-name">/
 
 
   <label id="option-codesize">
@@ -134,6 +135,7 @@ Here is a description of all the command line options:
   using <tt/-Oi/ (<tt/-Oi/ is the same as <tt/-O --codesize&nbsp;200/).
 
 
+  <label id="option-cpu">
   <tag><tt>--cpu CPU</tt></tag>
 
   A new, still experimental option. You may specify "6502" or "65C02" as
@@ -144,6 +146,7 @@ Here is a description of all the command line options:
   overwhelming.
 
 
+  <label id="option-create-dep">
   <tag><tt>--create-dep</tt></tag>
 
   Tells the compiler to generate a file containing the dependency list for
@@ -151,6 +154,13 @@ Here is a description of all the command line options:
   file with the extension replaced by <tt/.u/.
 
 
+  <label id="option-data-name">
+  <tag><tt>--data-name seg</tt></tag>
+
+  Set the name of the data segment. See also <tt/<ref id="pragma-data-name"
+  name="#pragma&nbsp;data-name">/
+
+
   <tag><tt>-d, --debug</tt></tag>
 
   Enables debug mode, something that should not be needed for mere
@@ -188,6 +198,7 @@ Here is a description of all the command line options:
   name of the C input file is used, with the extension replaced by ".s".
 
 
+  <label id="option-register-vars">
   <tag><tt>-r, --register-vars</tt></tag>
 
   <tt/-r/ will make the compiler honor the <tt/register/ keyword. Local
@@ -197,13 +208,14 @@ Here is a description of all the command line options:
   variables are of limited use without the optimizer, there is also a combined
   switch: <tt/-Or/ will enable both, the optimizer and register variables.
 
-  For more information about register variables see <ref id="regvars"
+  For more information about register variables see <ref id="register-vars"
   name="register variables">.
 
   The compiler setting can also be changed within the source file by using
-  <tt><ref id="pragma-regvars" name="#pragma&nbsp;regvars"></tt>.
+  <tt/<ref id="pragma-register-vars" name="#pragma&nbsp;register-vars">/.
 
 
+  <label id="option-register-space">
   <tag><tt>--register-space</tt></tag>
 
   This option takes a numeric parameter and is used to specify, how much
@@ -217,19 +229,21 @@ Here is a description of all the command line options:
   If you don't know what all this means, please don't use this option.
 
 
+  <label id="option-rodata-name">
   <tag><tt>--rodata-name seg</tt></tag>
 
   Set the name of the rodata segment (the segment used for readonly data).
+  See also <tt/<ref id="pragma-rodata-name" name="#pragma&nbsp;rodata-name">/
 
-
+  <label id="option-signed-chars">
   <tag><tt>-j, --signed-chars</tt></tag>
 
   Using this option, you can make the default characters signed. Since the
   6502 has no provisions for sign extending characters (which is needed on
   almost any load operation), this will make the code larger and slower. A
   better way is to declare characters explicitly as "signed" if needed. You
-  can also use <tt><ref id="pragma-signedchars"
-  name="#pragma&nbsp;signedchars"></tt> for better control of this option.
+  can also use <tt><ref id="pragma-signed-chars"
+  name="#pragma&nbsp;signed-chars"></tt> for better control of this option.
 
 
   <label id="option--standard">
@@ -248,6 +262,7 @@ Here is a description of all the command line options:
   (// comments for example).
 
 
+  <label id="option-standard">
   <tag><tt>-t target, --target target</tt></tag>
 
   This option is used to set the target system. The target system
@@ -281,12 +296,14 @@ Here is a description of all the command line options:
   or warnings are encountered.
 
 
+  <label id="option-writable-strings">
   <tag><tt>--writable-strings</tt></tag>
 
   Make string literals writable by placing them into the data segment instead
   of the rodata segment.
 
 
+  <label id="option-static-locals">
   <tag><tt>-Cl, --static-locals</tt></tag>
 
   Use static storage for local variables instead of storage on the stack.
@@ -319,11 +336,12 @@ Here is a description of all the command line options:
   function is entered, and will keep the old value from one call of the
   function to the next.
 
-  You may also use <tt><ref id="pragma-staticlocals"
-  name="#pragma&nbsp;staticlocals"></tt> to change this setting in your
+  You may also use <tt><ref id="pragma-static-locals"
+  name="#pragma&nbsp;static-locals"></tt> to change this setting in your
   sources.
 
 
+  <label id="option-include-dir">
   <tag><tt>-I dir, --include-dir dir</tt></tag>
 
   Set a directory where the compiler searches for include files. You may
@@ -344,10 +362,9 @@ Here is a description of all the command line options:
 
   <tt/-Or/ will make the compiler honor the <tt/register/ keyword. Local
   variables may be placed in registers (which are actually zero page
-  locations). There is some overhead involved with register variables, since
-  the old contents of the registers must be saved and restored. In addition,
-  the current implementation does not make good use of register variables, so
-  using <tt/-Or/ may make your program even slower and larger. Use with care!
+  locations). See also the <tt/<ref id="option-register-vars"
+  name="--register-vars">/ command line option, and the <ref
+  id="register-vars" name="discussion of register variables"> below.
 
   Using <tt/-Os/ will force the compiler to inline some known functions from
   the C library like strlen. Note: This has two consequences:
@@ -405,6 +422,9 @@ Here is a description of all the command line options:
         Warn about unused variables.
   </descrip>
 
+  You may also use <tt><ref id="pragma-warn" name="#pragma&nbsp;warn"></tt> to
+  control this setting for smaller pieces of code from within your code.
+
 </descrip><p>
 
 
@@ -731,7 +751,7 @@ If the first parameter is <tt/push/, the old value is saved onto a stack
 before changing it. The value may later be restored by using the <tt/pop/
 parameter with the <tt/#pragma/.
 
-<sect1><tt>#pragma bssseg (&lsqb;push,&rsqb; &lt;name&gt;)</tt><p>
+<sect1><tt>#pragma bss-name (&lsqb;push,&rsqb; &lt;name&gt;)</tt><label id="pragma-bss-name"><p>
 
   This pragma changes the name used for the BSS segment (the BSS segment
   is used to store uninitialized data). The argument is a string enclosed
@@ -749,11 +769,11 @@ parameter with the <tt/#pragma/.
 
   Example:
   <tscreen><verb>
-               #pragma bssseg ("MyBSS")
+               #pragma bss-name ("MyBSS")
   </verb></tscreen>
 
 
-<sect1><tt>#pragma charmap (&lt;index&gt;, &lt;code&gt;)</tt><p>
+<sect1><tt>#pragma charmap (&lt;index&gt;, &lt;code&gt;)</tt><label id="pragma-charmap"><p>
 
   Each literal string and each literal character in the source is translated
   by use of a translation table. This translation table is preset when the
@@ -787,7 +807,7 @@ parameter with the <tt/#pragma/.
   </verb></tscreen>
 
 
-<sect1><tt>#pragma checkstack ([push,] on|off)</tt><label id="pragma-checkstack"><p>
+<sect1><tt>#pragma check-stack ([push,] on|off)</tt><label id="pragma-check-stack"><p>
 
   Tells the compiler to insert calls to a stack checking subroutine to detect
   stack overflows. The stack checking code will lead to somewhat larger and
@@ -800,7 +820,7 @@ parameter with the <tt/#pragma/.
 
   The <tt/#pragma/ understands the push and pop parameters as explained above.
 
-<sect1><tt>#pragma codeseg ([push,] &lt;name&gt;)</tt><p>
+<sect1><tt>#pragma code-name ([push,] &lt;name&gt;)</tt><label id="pragma-code-name"><p>
 
   This pragma changes the name used for the CODE segment (the CODE segment
   is used to store executable code). The argument is a string enclosed in
@@ -814,7 +834,7 @@ parameter with the <tt/#pragma/.
 
   Example:
   <tscreen><verb>
-       #pragma codeseg ("MyCODE")
+               #pragma code-name ("MyCODE")
   </verb></tscreen>
 
 
@@ -828,7 +848,7 @@ parameter with the <tt/#pragma/.
   The <tt/#pragma/ understands the push and pop parameters as explained above.
 
 
-<sect1><tt>#pragma dataseg ([push,] &lt;name&gt;)</tt><p>
+<sect1><tt>#pragma data-name ([push,] &lt;name&gt;)</tt><label id="pragma-data-name"><p>
 
   This pragma changes the name used for the DATA segment (the DATA segment
   is used to store initialized data). The argument is a string enclosed in
@@ -842,7 +862,7 @@ parameter with the <tt/#pragma/.
 
   Example:
   <tscreen><verb>
-       #pragma dataseg ("MyDATA")
+               #pragma data-name ("MyDATA")
   </verb></tscreen>
 
 
@@ -862,7 +882,7 @@ parameter with the <tt/#pragma/.
   The <tt/#pragma/ understands the push and pop parameters as explained above.
 
 
-<sect1><tt>#pragma rodataseg ([push,] &lt;name&gt;)</tt><p>
+<sect1><tt>#pragma rodata-name ([push,] &lt;name&gt;)</tt><label id="pragma-rodata-name"><p>
 
   This pragma changes the name used for the RODATA segment (the RODATA
   segment is used to store readonly data). The argument is a string
@@ -876,11 +896,11 @@ parameter with the <tt/#pragma/.
 
   Example:
   <tscreen><verb>
-       #pragma rodataseg ("MyRODATA")
+               #pragma rodata-name ("MyRODATA")
   </verb></tscreen>
 
 
-<sect1><tt>#pragma regvaraddr ([push,] on|off)</tt><p>
+<sect1><tt>#pragma regvaraddr ([push,] on|off)</tt><label id="pragma-regvaraddr"><p>
 
   The compiler does not allow to take the address of register variables.
   The regvaraddr pragma changes this. Taking the address of a register
@@ -904,33 +924,34 @@ parameter with the <tt/#pragma/.
   </verb></tscreen>
 
 
-<sect1><tt>#pragma regvars ([push,] on|off)</tt><label id="pragma-regvars"><p>
+<sect1><tt>#pragma register-vars ([push,] on|off)</tt><label id="pragma-register-vars"><p>
 
   Enables or disables use of register variables. If register variables are
   disabled (the default), the <tt/register/ keyword is ignored. Register
-  variables are explained in more detail in <ref id="regvars" name="a separate
+  variables are explained in more detail in <ref id="register-vars" name="a separate
   chapter">.
 
   The <tt/#pragma/ understands the push and pop parameters as explained above.
 
 
-<sect1><tt>#pragma signedchars ([push,] on|off)</tt><label id="pragma-signedchars"><p>
+<sect1><tt>#pragma signed-chars ([push,] on|off)</tt><label id="pragma-signed-chars"><p>
 
   Changes the signedness of the default character type. If the argument is
-  "on", default characters are signed, otherwise characters are unsigned.
-  The compiler default is to make characters unsigned since this creates a
-  lot better code. This default may be overridden by the <tt/--signed-chars/
-  command line option.
+  "on", default characters are signed, otherwise characters are unsigned. The
+  compiler default is to make characters unsigned since this creates a lot
+  better code. This default may be overridden by the <tt/<ref
+  name="--signed-chars" id="option-signed-chars">/ command line option.
 
   The <tt/#pragma/ understands the push and pop parameters as explained above.
 
 
-<sect1><tt>#pragma staticlocals ([push,] on|off)</tt><label id="pragma-staticlocals"<p>
+<sect1><tt>#pragma static-locals ([push,] on|off)</tt><label id="pragma-static-locals"<p>
 
   Use variables in the bss segment instead of variables on the stack. This
-  pragma changes the default set by the compiler option <tt/-Cl/. If the
-  argument is "on", local variables are allocated in the BSS segment,
-  leading to shorter and in most cases faster, but non-reentrant code.
+  pragma changes the default set by the compiler option <tt/<ref
+  name="--static-locals" id="option-static-locals">/. If the argument is "on",
+  local variables are allocated in the BSS segment, leading to shorter and in
+  most cases faster, but non-reentrant code.
 
   The <tt/#pragma/ understands the push and pop parameters as explained above.
 
@@ -943,6 +964,16 @@ parameter with the <tt/#pragma/.
   "off", optionally preceeded by "push" to push the current state before
   changing it.
 
+  Example:
+  <tscreen><verb>
+        /* Don't warn about the unused parameter in function func */
+       #pragma warn (unused-param, push, off)
+        static int func (int unused)
+        {
+            return 0;
+        }
+        #pragma warn (unused-param, pop)
+  </verb></tscreen>
 
 <sect1><tt>#pragma zpsym (&lt;name&gt;)</tt><p>
 
@@ -959,7 +990,7 @@ parameter with the <tt/#pragma/.
 
 
 
-<sect>Register variables<label id="regvars"><p>
+<sect>Register variables<label id="register-vars"><p>
 
 The runtime for all supported platforms has 6 bytes of zero page space
 available for register variables (this could be increased, but I think it's a
@@ -989,11 +1020,13 @@ much difference in the code generated for counters, so you will need at least
 trouble. The only savings you get here are by the use of a zero page variable
 instead of one on the stack or in the data segment.
 
-Register variables must be explicitly enabled by using <tt/-Or/ or <tt/-r/ on
-the command line. Register variables are only accepted on function top level,
-register variables declared in interior blocks are silently converted to
-<tt/auto/. With register variables disabled, all variables declared as
-<tt/register/ are actually auto variables.
+Register variables must be explicitly enabled, either by using <tt/<ref
+name="-Or" id="option-O">/ or <tt/<ref name="--register-vars"
+id="option-register-vars">/ on the command line or by use of <tt/<ref
+name="#pragma register-vars" id="pragma-register-vars">/. Register variables
+are only accepted on function top level, register variables declared in
+interior blocks are silently converted to <tt/auto/. With register variables
+disabled, all variables declared as <tt/register/ are actually auto variables.
 
 Please take care when using register variables: While they are helpful and can
 lead to a tremendous speedup when used correctly, improper usage will cause

diff --git a/libsrc/common/_scanf.c b/libsrc/common/_scanf.c
index ba2b15eab05c8022ffa25f9d1e162a2f1ae71706..8526b893351317fcebc4afeb4a3fe6f9bcf9d23f 100644 (file)
--- a/libsrc/common/_scanf.c
+++ b/libsrc/common/_scanf.c
@@ -31,7 +31,7 @@
 
 extern void __fastcall__ _seterrno (unsigned char code);
 
-#pragma staticlocals(on)
+#pragma static-locals(on)
 
 
 

diff --git a/libsrc/common/strftime.c b/libsrc/common/strftime.c
index 803c3d8cd0d8803dde4e9b5b29672274d0912f68..baaa6fbe81106c3a055ec3205c92693592f30d0c 100644 (file)
--- a/libsrc/common/strftime.c
+++ b/libsrc/common/strftime.c
@@ -40,7 +40,7 @@
 
 
 /* Use static local variables for speed */
-#pragma staticlocals (on);
+#pragma static-locals (on);
 
 
 
@@ -135,7 +135,7 @@ size_t __fastcall__ strftime (char* buf, size_t bufsize, const char* format,
                     break;
 
                 case 'W':
-                    sprintf (arg, "%02d", 
+                    sprintf (arg, "%02d",
                              (tm->tm_yday + 7 - (tm->tm_wday? tm->tm_wday - 1 : 6)) / 7);
                     break;
 

diff --git a/samples/fire.c b/samples/fire.c
index 860067438ef1df28bac898e62f2b9f8f254d6bce..bbea872cf1c92adb17a44345f4451d67d2b9a3d6 100644 (file)
--- a/samples/fire.c
+++ b/samples/fire.c
@@ -55,7 +55,7 @@
 
 
 /* Use static local variables for speed */
-#pragma staticlocals (1);
+#pragma static-locals (1);
 
 
 

diff --git a/samples/mandelbrot.c b/samples/mandelbrot.c
index 461001d58be6228579a6c80628667193f5519ed0..23eda0cf12acb495936e6b9c1573f87826a21cfa 100644 (file)
--- a/samples/mandelbrot.c
+++ b/samples/mandelbrot.c
@@ -34,7 +34,7 @@
 #endif
 
 /* Use static local variables for speed */
-#pragma staticlocals (1);
+#pragma static-locals (1);
 
 
 
@@ -90,7 +90,7 @@ int main (void)
 
     clrscr ();
 
-    /* Load the graphics driver */                       
+    /* Load the graphics driver */
     cprintf ("initializing... mompls\r\n");
     tgi_load_driver (tgi_stddrv);
     err = tgi_geterror ();

diff --git a/samples/plasma.c b/samples/plasma.c
index 37514ecd40996feb6bc03d2015d4966c39033e6a..cf0d911f54a96bdb6136675f8ea089d4d8026c7f 100644 (file)
--- a/samples/plasma.c
+++ b/samples/plasma.c
@@ -50,7 +50,7 @@
 
 
 /* Use static local variables for speed */
-#pragma staticlocals (1); 
+#pragma static-locals (1);
 
 
 

diff --git a/samples/sieve.c b/samples/sieve.c
index ada8a37b1cec80515c89253f6981f8afdf016fa0..a82e972c9d1620a6578ea91b8b380784e3bb2968 100644 (file)
--- a/samples/sieve.c
+++ b/samples/sieve.c
@@ -38,7 +38,7 @@ static unsigned char Sieve[COUNT];
 
 
 
-#pragma staticlocals(1);
+#pragma static-locals(1);
 
 
 

diff --git a/src/cc65/pragma.c b/src/cc65/pragma.c
index 47f4da0afda46fe22ff422e57ccd79c9a2cbc9bd..684d6a416371a5fd344cd73f974dbb021fef6b0f 100644 (file)
--- a/src/cc65/pragma.c
+++ b/src/cc65/pragma.c
@@ -62,43 +62,59 @@
 
 /* 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_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_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 */
+    { "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             },
+    { "zpsym",          PRAGMA_ZPSYM           },
 };
 
 /* Result of ParsePushPop */
@@ -137,13 +153,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;
 }
 
 
@@ -158,7 +174,7 @@ static int GetComma (StrBuf* B)
         Error ("Comma expected");
         return 0;
     }
-    SB_SkipWhite (B);
+    SB_SkipWhite (B);                                   
     return 1;
 }
 
@@ -657,7 +673,7 @@ 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...
@@ -679,59 +695,83 @@ 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_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_ZPSYM:
            StringPragma (&B, MakeZPSym);
            break;