Fixed timing of #pragma charmap.

Now it is immediately applied and affects almost all characters and string literals after it.
Exceptions:
- String literals as the message of a static assertion or inline assembler code (only the required one, not any optional formatted arguments) in an asm() expression are not translated with either #pragma charmap or target presets.
- String literals used for preprocessor directives or as the result of stringized macro arguments are never translated.

src/cc65/asmstmt.c

@@ -417,6 +417,9 @@ void AsmStatement (void)
 ** a string literal in parenthesis.
 */
 {
+    /* Prevent from translating the inline code string literal in asm */
+    NoCharMap = 1;
+
     /* Skip the ASM */
     NextToken ();
 
@@ -431,9 +434,15 @@ void AsmStatement (void)
 
     /* Need left parenthesis */
     if (!ConsumeLParen ()) {
+        NoCharMap = 0;
         return;
     }
 
+    /* We have got the inline code string untranslated, now reenable string
+    ** literal translation for string arguments (if any).
+    */
+    NoCharMap = 0;
+
     /* String literal */
     if (CurTok.Tok != TOK_SCONST) {
 

src/cc65/expr.c

@@ -1336,8 +1336,6 @@ static void Primary (ExprDesc* E)
             /* String literal */
             if ((Flags & E_EVAL_UNEVAL) != E_EVAL_UNEVAL) {
                 E->V.LVal = UseLiteral (CurTok.SVal);
-                /* Translate into target charset */
-                TranslateLiteral (E->V.LVal);
             } else {
                 E->V.LVal = CurTok.SVal;
             }

src/cc65/initdata.c

@@ -245,9 +245,6 @@ static void DefineBitFieldData (StructInitData* SI)
 
 static void DefineStrData (Literal* Lit, unsigned Count)
 {
-    /* Translate into target charset */
-    TranslateLiteral (Lit);
-
     /* Output the data */
     g_defbytes (GetLiteralStr (Lit), Count);
 }

src/cc65/pragma.c

@@ -1096,8 +1096,12 @@ void ConsumePragma (void)
     /* Skip the _Pragma token */
     NextToken ();
 
+    /* Prevent from translating string literals in _Pragma */
+    ++InPragmaParser;
+
     /* We expect an opening paren */
     if (!ConsumeLParen ()) {
+        --InPragmaParser;
         return;
     }
 
@@ -1115,6 +1119,8 @@ void ConsumePragma (void)
         ParsePragmaString ();
     }
 
+    --InPragmaParser;
+
     /* Closing paren needed */
     ConsumeRParen ();
 }

src/cc65/scanner.c

@@ -70,10 +70,12 @@
 
 
 
-static Token SavedTok;  /* Saved token */
-Token CurTok;           /* The current token */
-Token NextTok;          /* The next token */
-int   PPParserRunning;  /* Is tokenizer used by the preprocessor */
+static Token SavedTok;          /* Saved token */
+Token       CurTok;             /* The current token */
+Token       NextTok;            /* The next token */
+int         PPParserRunning;    /* Is tokenizer used by the preprocessor */
+int         NoCharMap;          /* Disable literal translation */
+unsigned    InPragmaParser;     /* Depth of pragma parser calling */
 
 
 
@@ -455,7 +457,7 @@ static void CharConst (void)
     }
 
     /* Translate into target charset */
-    NextTok.IVal = SignExtendChar (TgtTranslateChar (C));
+    NextTok.IVal = SignExtendChar (C);
 
     /* Character constants have type int */
     NextTok.Type = type_int;
@@ -798,6 +800,15 @@ static void GetNextInputToken (void)
 {
     ident token;
 
+    if (!NoCharMap && !InPragmaParser) {
+        /* Translate string and character literals into target charset */
+        if (NextTok.Tok == TOK_SCONST || NextTok.Tok == TOK_WCSCONST) {
+            TranslateLiteral (NextTok.SVal);
+        } else if (NextTok.Tok == TOK_CCONST || NextTok.Tok == TOK_WCCONST) {
+            NextTok.IVal = SignExtendChar (TgtTranslateChar (NextTok.IVal));
+        }
+    }
+
     /* Current token is the lookahead token */
     if (CurTok.LI) {
         ReleaseLineInfo (CurTok.LI);

src/cc65/scanner.h

@@ -219,9 +219,11 @@ struct Token {
     const Type*     Type;       /* Type if integer or float constant */
 };
 
-extern Token CurTok;            /* The current token */
-extern Token NextTok;           /* The next token */
-extern int   PPParserRunning;   /* Is tokenizer used by the preprocessor */
+extern Token    CurTok;             /* The current token */
+extern Token    NextTok;            /* The next token */
+extern int      PPParserRunning;    /* Is tokenizer used by the preprocessor */
+extern int      NoCharMap;          /* Disable literal translation */
+extern unsigned InPragmaParser;     /* Depth of pragma parser calling */
 
 
 

src/cc65/staticassert.c

@@ -72,9 +72,15 @@ void ParseStaticAssert ()
     ** support the C2X syntax with only an expression.
     */
     if (CurTok.Tok == TOK_COMMA) {
-        /* Skip the comma. */
+        /* Prevent from translating the message string literal */
+        NoCharMap = 1;
+
+        /* Skip the comma and get the next token */
         NextToken ();
 
+        /* Reenable string literal translation */
+        NoCharMap = 0;
+
         /* String literal */
         if (CurTok.Tok != TOK_SCONST) {
             Error ("String literal expected for static_assert message");