zeroc-ice 3.6b1 → 3.6.0

data/ext/ice/mcpp/mcpp.gyp

@@ -0,0 +1,62 @@
+{
+  'targets': [
+    {
+      'target_name': 'mcpp',
+      'product_prefix' : 'lib',
+      'type': 'static_library',
+      'sources':  [
+        'directive.c',
+        'eval.c',
+        'expand.c',
+        'main.c',
+        'mbchar.c',
+        'support.c',
+        'system.c',
+      ],
+      'include_dirs' : ['.'],
+      'defines' : [
+        'HAVE_CONFIG_H',
+        'MCPP_LIB=1'
+      ],
+      'configurations': {
+        'Release': {
+          'msvs_settings': {
+            'VCCLCompilerTool': {
+                'RuntimeLibrary': '2',
+                'ExceptionHandling': '1',
+                'RuntimeTypeInfo' : 'true'
+              },
+          },
+          'msvs_disabled_warnings': [
+            4018,
+            4090,
+            4101,
+            4102,
+            4133,
+            4146,
+            4244,
+            4267
+          ]
+        }
+      },
+      'conditions': [
+        ['OS=="mac"', {
+          'xcode_settings': {
+            "MACOSX_DEPLOYMENT_TARGET":"10.9",
+            'OTHER_CFLAGS': [
+              '-fno-common',
+              '-stdlib=libstdc++',
+              '-w'
+            ]
+          }
+        }],
+        ['OS=="linux"', {
+          'cflags' : [
+            '-fPIC',
+            '-w'
+          ]
+        }]
+      ]
+    }
+  ]
+}

data/ext/ice/mcpp/support.c

@@ -50,9 +50,6 @@
  *              returns the advanced output pointer.
  * get_ch()     Reads the next byte from the current input stream, handling
  *              end of (macro/file) input and embedded comments appropriately.
- * cnv_trigraph()   Maps trigraph sequence to C character.
- * cnv_digraph()    Maps digraph sequence to C character.
- * id_operator()    See whether the identifier is an operator in C++.
  * unget_ch()   Pushs last gotten character back on the input stream.
  * unget_string()   Pushs sequence on the input stream.
  * save_string() Saves a string in malloc() memory.
@@ -70,23 +67,13 @@
  *              buffer.
  */
 
-#if PREPROCESSED
-#include    "mcpp.H"
-#else
 #include    "system.H"
 #include    "internal.H"
-#endif
 
 static void     scan_id( int c);
                 /* Scan an identifier           */
 static char *   scan_number( int c, char * out, char * out_end);
                 /* Scan a preprocessing number  */
-static char *   scan_number_prestd( int c, char * out, char * out_end);
-                /* scan_number() for pre-Standard mode  */
-#if OK_UCN
-static char *   scan_ucn( int cnt, char * out);
-                /* Scan an UCN sequence         */
-#endif
 static char *   scan_op( int c, char * out);
                 /* Scan an operator or a punctuator     */
 static char *   parse_line( void);
@@ -100,10 +87,6 @@ static char *   at_eof( int in_comment);
 static void     do_msg( const char * severity, const char * format
         , const char * arg1, long arg2, const char * arg3);
                 /* Putout diagnostic message    */
-static char *   cat_line( int del_bsl);
-                /* Splice the line              */
-static void     put_line( char * out, FILE * fp);
-                /* Put out a logical line       */
 static void     dump_token( int token_type, const char * cp);
                 /* Dump a token and its type    */
 
@@ -133,7 +116,6 @@ static CAT_LINE bsl_cat_line;
 static CAT_LINE com_cat_line;
         /* Datum on the last catenated line by a line-crossing comment  */
 
-#if MCPP_LIB
 static int  use_mem_buffers = FALSE;
 
 void    init_support( void)
@@ -174,11 +156,6 @@ void    mcpp_use_mem_buffers(
     }
 }
 
-int    using_mem_buffers( void)
-{
-    return use_mem_buffers;
-}
-
 #define BUF_INCR_SIZE   (NWORK * 2)
 #define MAX( a, b)      (((a) > (b)) ? (a) : (b))
 
@@ -247,7 +224,6 @@ char *  mcpp_get_mem_buffer(
     return mem_buffers[ od].buffer;
 }
 
-#endif  /* MCPP_LIB */
 
 #define DEST2FP(od) \
     (od == OUT) ? fp_out : \
@@ -268,17 +244,13 @@ int    mcpp_lib_fputc(
     OUTDEST od
 )
 {
-#if MCPP_LIB
     if (use_mem_buffers) {
         return mem_putc( c, od);
     } else {
-#endif
         FILE *  stream = DEST2FP( od);
 
         return (stream != NULL) ? fputc( c, stream) : EOF;
-#if MCPP_LIB
     }
-#endif
 }
 
 int (* mcpp_fputc)( int c, OUTDEST od) = mcpp_lib_fputc;
@@ -288,17 +260,13 @@ int    mcpp_lib_fputs(
     OUTDEST od
 )
 {
-#if MCPP_LIB
     if (use_mem_buffers) {
         return mem_puts( s, od);
     } else {
-#endif
         FILE *  stream = DEST2FP( od);
 
         return (stream != NULL) ? fputs( s, stream) : EOF;
-#if MCPP_LIB
     }
-#endif
 }
 
 int (* mcpp_fputs)( const char * s, OUTDEST od) = mcpp_lib_fputs;
@@ -318,7 +286,6 @@ int    mcpp_lib_fprintf(
         int rc;
 
         va_start( ap, format);
-#if MCPP_LIB
         if (use_mem_buffers) {
             static char     mem_buffer[ NWORK];
 
@@ -328,11 +295,8 @@ int    mcpp_lib_fprintf(
                 rc = mem_puts( mem_buffer, od);
             }
         } else {
-#endif
             rc = vfprintf( stream, format, ap);
-#if MCPP_LIB
         }
-#endif
         va_end( ap);
 
         return rc;
@@ -344,7 +308,6 @@ int    mcpp_lib_fprintf(
 
 int (* mcpp_fprintf)( OUTDEST od, const char * format, ...) = mcpp_lib_fprintf;
 
-#if MCPP_LIB
 void    mcpp_reset_def_out_func( void)
 {
     mcpp_fputc = mcpp_lib_fputc;
@@ -362,7 +325,6 @@ void    mcpp_set_out_func(
     mcpp_fputs = func_fputs;
     mcpp_fprintf = func_fprintf;
 }
-#endif
 
 int     get_unexpandable(
     int     c,                              /* First char of token  */
@@ -401,8 +363,7 @@ int     get_unexpandable(
             /* This diagnostic is issued even if "diag" is FALSE.   */
             cwarn( "Macro \"%s\" is expanded to 0 token"    /* _W1_ */
                     , defp->name, 0L, NULL);
-            if (! option_flags.no_source_line)
-                dump_a_def( "    macro", defp, FALSE, TRUE, fp_err);
+            dump_a_def( "    macro", defp, FALSE, TRUE, fp_err);
         }
     }
 
@@ -422,16 +383,11 @@ int     get_unexpandable(
                 c = get_ch();
                 continue;
             }
-            if (standard && str_eq( identifier, "defined")) {
+            if (str_eq( identifier, "defined")) {
                 cwarn( "Macro \"%s\" is expanded to \"defined\""    /* _W1_ */
                         , defp->name, 0L, NULL);
                 break;
             }
-            if (! standard && str_eq( identifier, "sizeof")) {
-                cwarn( "Macro \"%s\" is expanded to \"sizeof\""     /* _W1_ */
-                        , defp->name, 0L, NULL);
-                break;
-            }
             c = get_ch();
         }
         if (file == infile) {
@@ -501,8 +457,7 @@ int     scan_token(
     int     token_type = 0;             /* Type of token            */
     int     ch;
 
-    if (standard)
-        in_token = TRUE;                /* While a token is scanned */
+    in_token = TRUE;                /* While a token is scanned */
     c = c & UCHARMAX;
     ch_type = char_type[ c] & MBMASK;
 
@@ -510,8 +465,6 @@ int     scan_token(
     case LET:                           /* Probably an identifier   */
         switch (c) {
         case 'L':
-            if (! standard)
-                goto  ident;
             ch = get_ch();
             if (char_type[ ch] & QUO) { /* char_type[ ch] == QUO    */
                 if (ch == '"')
@@ -525,7 +478,6 @@ int     scan_token(
                 unget_ch();
             }                           /* Fall through             */
         default:                        /* An identifier            */
-ident:
             scan_id( c);
             out = stpcpy( out, identifier);
             token_type = NAM;
@@ -550,8 +502,7 @@ ident:
             goto  operat;
         /* Else fall through    */
     case DIG:                           /* Preprocessing number     */
-        out = (standard ? scan_number( c, out, out_end)
-                : scan_number_prestd( c, out, out_end));
+        out = scan_number( c, out, out_end);
         token_type = NUM;
         break;
     case PUNC:
@@ -559,25 +510,7 @@ operat: out = scan_op( c, out);         /* Operator or punctuator   */
         token_type = OPE;       /* Number is set in global "openum" */
         break;
     default:                /* Special tokens or special characters */
-#if OK_UCN
-        if (mcpp_mode == STD && c == '\\' && stdc2) {
-            ch = get_ch();
-            unget_ch();
-            if (ch == 'U' || ch == 'u')
-                goto  ident;            /* Universal-Characte-Name  */
-        }
-#endif
-#if OK_MBIDENT
-        if (mcpp_mode == STD && (char_type[ c] & mbchk) && stdc3) {
-            char *  bptr = infile->bptr;
-            mb_read( c, &infile->bptr, &out);
-            infile->bptr = bptr;
-            out = *out_pp;
-            goto  ident;        /* An identifier with multi-byte characters */
-            /* Mbchar cheking has been done in scan_quote() and others. */
-        }
-#endif
-        if ((standard && (c == CAT || c == ST_QUOTE)) || (char_type[ c] & SPA))
+        if (((c == CAT || c == ST_QUOTE)) || (char_type[ c] & SPA))
             token_type = SEP;       /* Token separator or magic char*/
         else
             token_type = SPE;
@@ -592,9 +525,6 @@ operat: out = scan_op( c, out);         /* Operator or punctuator   */
                 , *out_pp, 0L, NULL);
     if (mcpp_debug & TOKEN)
         dump_token( token_type, *out_pp);
-    if (mcpp_mode == POST_STD && token_type != SEP && infile->fp != NULL
-            && (char_type[ *infile->bptr & UCHARMAX] & SPA) == 0)
-        insert_sep = INSERT_SEP;    /* Insert token separator       */
     *out_pp = out;
 
     in_token = FALSE;               /* Token scanning has been done */
@@ -610,13 +540,6 @@ static void scan_id(
  */
 {
     static char * const     limit = &identifier[ IDMAX];
-    static int      dollar_diagnosed = FALSE;   /* Flag of diagnosing '$'   */
-#if OK_UCN
-    int     uc2 = 0, uc4 = 0;           /* Count of UCN16, UCN32    */
-#endif
-#if OK_MBIDENT
-    int     mb = 0;                     /* Count of MBCHAR  */
-#endif
     size_t  len;                        /* Length of identifier     */
     char *  bp = identifier;
 
@@ -632,56 +555,9 @@ static void scan_id(
     do {
         if (bp < limit)
             *bp++ = c;
-#if OK_UCN
-        if (mcpp_mode == STD && c == '\\' && stdc2) {
-            int     cnt;
-            char *  tp = bp;
-            
-            if ((c = get_ch()) == 'u') {
-                cnt = 4;
-            } else if (c == 'U') {
-                cnt = 8;
-            } else {
-                unget_ch();
-                bp--;
-                break;
-            }
-            *bp++ = c;
-            if ((bp = scan_ucn( cnt, bp)) == NULL)      /* Error    */
-                return;
-            if (cnt == 4)
-                uc2++;
-            else if (cnt == 8)
-                uc4++;
-            if (limit <= tp)            /* Too long identifier      */
-                bp = tp;                /* Back the pointer         */
-            goto  next_c;
-        }
-#endif  /* OK_UCN   */
-#if OK_MBIDENT
-        if (mcpp_mode == STD && (char_type[ c] & mbchk) && stdc3) {
-            len = mb_read( c, &infile->bptr, &bp);
-            if (len & MB_ERROR) {
-                if (infile->fp)
-                    cerror(
-                    "Illegal multi-byte character sequence."    /* _E_  */
-                            , NULL, 0L, NULL);
-            } else {
-                mb += len;
-            }
-        }
-#endif  /* OK_MBIDENT   */
-#if OK_UCN
-next_c:
-#endif
+
         c = get_ch();
     } while ((char_type[ c] & (LET | DIG))      /* Letter or digit  */
-#if OK_UCN
-            || (mcpp_mode == STD && c == '\\' && stdc2)
-#endif
-#if OK_MBIDENT
-            || (mcpp_mode == STD && (char_type[ c] & mbchk) && stdc3)
-#endif
         );
 
     unget_ch();
@@ -694,24 +570,10 @@ next_c:
     len = bp - identifier;
 #if IDMAX > IDLEN90MIN
     /* UCN16, UCN32, MBCHAR are counted as one character for each.  */
-#if OK_UCN
-    if (mcpp_mode == STD)
-        len -= (uc2 * 5) - (uc4 * 9);
-#endif
-#if OK_MBIDENT
-    if (mcpp_mode == STD)
-        len -= mb;
-#endif
-    if (standard && infile->fp && len > std_limits.id_len && (warn_level & 4))
+    if (infile->fp && len > std_limits.id_len && (warn_level & 4))
         cwarn( "Identifier longer than %.0s%ld characters \"%s\""   /* _W4_ */
                 , NULL, (long) std_limits.id_len, identifier);
 #endif  /* IDMAX > IDLEN90MIN   */
-
-    if (option_flags.dollar_in_name && dollar_diagnosed == FALSE
-            && (warn_level & 2) && strchr( identifier, '$') != NULL) {
-        cwarn( "'$' in identifier \"%s\"", identifier, 0L, NULL); /* _W2_ */
-        dollar_diagnosed = TRUE;            /* Diagnose only once   */
-    }
 }
 
 char *  scan_quote(
@@ -735,18 +597,15 @@ char *  scan_quote(
     const char * const      empty_const
                         = "Empty character constant %s%.0ld%s";
     const char *    skip;
-    size_t      len;
     int         c;
     char *      out_p = out;
 
     /* Set again in case of called from routines other than scan_token().   */
-    if (standard)
-        in_token = TRUE;
+    in_token = TRUE;
     *out_p++ = delim;
     if (delim == '<')
         delim = '>';
 
-scan:
     while ((c = get_ch()) != EOS) {
 
 #if MBCHAR
@@ -777,29 +636,8 @@ scan:
         if (c == delim) {
             break;
         } else if (c == '\\' && delim != '>') { /* In string literal    */
-#if OK_UCN
-            if (mcpp_mode == STD && stdc2) {
-                int         cnt;
-                char *      tp;
-
-                *out_p++ = c;
-                if ((c = get_ch()) == 'u') {
-                    cnt = 4;
-                } else if (c == 'U') {
-                    cnt = 8;
-                } else {
-                    goto  escape;
-                }
-                *out_p++ = c;
-                if ((tp = scan_ucn( cnt, out_p)) != NULL)
-                    out_p = tp;
-                /* Else error   */
-                continue;       /* Error or not, anyway continue    */
-            }
-#endif  /* OK_UCN   */
             *out_p++ = c;                   /* Escape sequence      */
             c = get_ch();
-escape:
 #if MBCHAR
             if (char_type[ c] & mbchk) {
                                 /* '\\' followed by multi-byte char */
@@ -807,15 +645,6 @@ escape:
                 continue;
             }
 #endif
-            if (! standard && c == '\n') {  /* <backslash><newline> */
-                out_p--;                    /* Splice the lines     */
-                if (cat_line( TRUE) == NULL)        /* End of file  */
-                    break;
-                c = get_ch();
-            }
-        } else if (mcpp_mode == POST_STD && c == ' ' && delim == '>'
-                && infile->fp == NULL) {
-            continue;   /* Skip space possibly inserted by macro expansion  */
         } else if (c == '\n') {
             break;
         }
@@ -825,7 +654,6 @@ escape:
             "Illegal control character %.0s0lx%02x in quotation"    /* _W1_ */
                     , NULL, (long) c, NULL);
         *out_p++ = c;
-chk_limit:
         if (out_end < out_p) {
             *out_end = EOS;
             cfatal( "Too long quotation", NULL, 0L, NULL);  /* _F_  */
@@ -840,54 +668,22 @@ chk_limit:
     if (diag) {                         /* At translation phase 3   */
         skip = (infile->fp == NULL) ? NULL : skip_line;
         if (c != delim) {
-            if (mcpp_mode == OLD_PREP   /* Implicit closing of quote*/
-                    && (delim == '"' || delim == '\''))
-                goto  done;
             if (delim == '"') {
-                if (mcpp_mode != POST_STD && option_flags.lang_asm) {
-                    /* STD, KR      */
-                    /* Concatenate the unterminated string to the next line */
-                    if (warn_level & 1)
-                        cwarn( unterm_string
-                                , ", catenated to the next line"    /* _W1_ */
-                                , 0L, NULL);
-                    if (cat_line( FALSE) != NULL)
-                        goto  scan;         /* Splice the lines     */
-                    /* Else end of file     */
-                } else {
-                    cerror( unterm_string, skip, 0L, NULL); /* _E_  */
-                }
+                cerror( unterm_string, skip, 0L, NULL); /* _E_  */
             } else if (delim == '\'') {
-                if (mcpp_mode != POST_STD && option_flags.lang_asm) {
-                    /* STD, KR      */
-                    if (warn_level & 1)
-                        cwarn( unterm_char, out, 0L, NULL); /* _W1_ */
-                    goto  done;
-                } else {
-                    cerror( unterm_char, out, 0L, skip);    /* _E_  */
-                }
+                cerror( unterm_char, out, 0L, skip);    /* _E_  */
             } else {
                 cerror( "Unterminated header name %s%.0ld%s"        /* _E_  */
                         , out, 0L, skip);
             }
             out_p = NULL;
         } else if (delim == '\'' && out_p - out <= 2) {
-            if (mcpp_mode != POST_STD && option_flags.lang_asm) {
-                /* STD, KR      */
-                if (warn_level & 1)
-                    cwarn( empty_const, out, 0L, skip);     /* _W1_ */
-            } else {
-                cerror( empty_const, out, 0L, skip);        /* _E_  */
-                out_p = NULL;
-                goto  done;
-            }
-        } else if (mcpp_mode == POST_STD && delim == '>' && (warn_level & 2)) {
-            cwarn(
-        "Header-name enclosed by <, > is an obsolescent feature %s" /* _W2_ */
-                    , out, 0L, skip);
+            cerror( empty_const, out, 0L, skip);        /* _E_  */
+            out_p = NULL;
+            goto  done;
         }
 #if NWORK-2 > SLEN90MIN
-        if (standard && out_p - out > std_limits.str_len && (warn_level & 4))
+        if (out_p - out > std_limits.str_len && (warn_level & 4))
             cwarn( "Quotation longer than %.0s%ld bytes"    /* _W4_ */
                     , NULL, std_limits.str_len, NULL);
 #endif
@@ -898,44 +694,6 @@ done:
     return  out_p;
 }
 
-static char *   cat_line(
-    int     del_bsl         /* Delete the <backslash><newline> ?    */
-)
-/*
- * If del_bsl == TRUE:
- *     Delete <backslash><newline> sequence in string literal.
- * FALSE: Overwrite the <newline> with <backslash>'n'.
- * Return NULL on end of file.  Called only from scan_quote().
- * This routine is never called in POST_STD mode.
- */
-{
-    size_t  len;
-    char *  save1, * save2;
-
-    if (del_bsl) {          /* Delete the <backslash><newline>      */
-        infile->bptr -= 2;
-        len = infile->bptr - infile->buffer;
-    } else {        /* Overwrite the <newline> with <backslash>'n'  */
-        strcpy( infile->bptr, "\\n");
-        len = strlen( infile->buffer);
-    }
-    save1 = save_string( infile->buffer);
-    save2 = get_line( FALSE);   /* infile->buffer is overwritten    */
-    if (save2 == NULL) {
-        free( save1);
-        return  NULL;
-    }
-    save2 = save_string( infile->buffer);
-    memcpy( infile->buffer, save1, len);
-    strcpy( infile->buffer + len, save2);               /* Catenate */
-    free( save1);
-    free( save2);
-    if (! del_bsl)
-        len -= 2;
-    infile->bptr = infile->buffer + len;
-    return  infile->bptr;
-}
-
 static char *   scan_number(
     int     c,                              /* First char of number */
     char *  out,                            /* Output buffer        */
@@ -955,55 +713,16 @@ static char *   scan_number(
     do {
         *out_p++ = c;
         if (c == 'E' || c == 'e'    /* Sign should follow 'E', 'e', */
-                || (stdc3 && (c == 'P' || c == 'p'))
-                                            /* 'P' or 'p'.          */
                 ) {
             c = get_ch();
             if (c == '+' || c == '-') {
                 *out_p++ = c;
                 c = get_ch();
             }
-#if OK_UCN
-        } else if (mcpp_mode == STD && c == '\\' && stdc3) {
-            int     cnt;
-            char *  tp;
-
-            if ((c = get_ch()) == 'u') {
-                cnt = 4;
-            } else if (c == 'U') {
-                cnt = 8;
-            } else {
-                unget_ch();
-                out_p--;
-                break;
-            }
-            *out_p++ = c;
-            if ((tp = scan_ucn( cnt, out_p)) == NULL)      /* Error    */
-                break;
-            else
-                out_p = tp;
-            c = get_ch();
-#endif  /* OK_UCN   */
-#if OK_MBIDENT
-        } else if (mcpp_mode == STD && (char_type[ c] & mbchk) && stdc3) {
-            len = mb_read( c, &infile->bptr, &out_p);
-            if (len & MB_ERROR) {
-                if (infile->fp)
-                    cerror(
-                    "Illegal multi-byte character sequence."    /* _E_  */
-                            , NULL, 0L, NULL);
-            }
-#endif  /* OK_MBIDENT   */
         } else {
             c = get_ch();
         }
     } while ((char_type[ c] & (DIG | DOT | LET))    /* Digit, dot or letter */
-#if OK_UCN
-            || (mcpp_mode == STD && c == '\\' && stdc3)
-#endif
-#if OK_MBIDENT
-            || (mcpp_mode == STD && (char_type[ c] & mbchk) && stdc3)
-#endif
         );
 
     *out_p = EOS;
@@ -1014,172 +733,6 @@ static char *   scan_number(
     return  out_p;
 }
 
-/* Original version of DECUS CPP with slight modifications, */
-/* too exact for Standard preprocessing.                    */
-static char *   scan_number_prestd(
-    int         c,                          /* First char of number */
-    char *      out,                        /* Output buffer        */
-    char *      out_end             /* Limit of output buffer       */
-)
-/*
- * Process a number.  We know that c is from 0 to 9 or dot.
- * Algorithm from Dave Conroy's Decus C.
- * Returns the advanced output pointer.
- */
-{
-    char * const    out_s = out;            /* For diagnostics      */
-    int             radix;                  /* 8, 10, or 16         */
-    int             expseen;                /* 'e' seen in floater  */
-    int             octal89;                /* For bad octal test   */
-    int             dotflag;                /* TRUE if '.' was seen */
-
-    expseen = FALSE;                        /* No exponent seen yet */
-    octal89 = FALSE;                        /* No bad octal yet     */
-    radix = 10;                             /* Assume decimal       */
-    if ((dotflag = (c == '.')) != FALSE) {  /* . something?         */
-        *out++ = '.';                       /* Always out the dot   */
-        if ((char_type[(c = get_ch())] & DIG) == 0) {
-                                            /* If not a float numb, */
-            goto  nomore;                   /* All done for now     */
-        }
-    }                                       /* End of float test    */
-    else if (c == '0') {                    /* Octal or hex?        */
-        *out++ = c;                         /* Stuff initial zero   */
-        radix = 8;                          /* Assume it's octal    */
-        c = get_ch();                       /* Look for an 'x'      */
-        if (c == 'x' || c == 'X') {         /* Did we get one?      */
-            radix = 16;                     /* Remember new radix   */
-            *out++ = c;                     /* Stuff the 'x'        */
-            c = get_ch();                   /* Get next character   */
-        }
-    }
-    while (1) {                             /* Process curr. char.  */
-        /*
-         * Note that this algorithm accepts "012e4" and "03.4"
-         * as legitimate floating-point numbers.
-         */
-        if (radix != 16 && (c == 'e' || c == 'E')) {
-            if (expseen)                    /* Already saw 'E'?     */
-                break;                      /* Exit loop, bad nbr.  */
-            expseen = TRUE;                 /* Set exponent seen    */
-            radix = 10;                     /* Decimal exponent     */
-            *out++ = c;                     /* Output the 'e'       */
-            if ((c = get_ch()) != '+' && c != '-')
-                continue;
-        }
-        else if (radix != 16 && c == '.') {
-            if (dotflag)                    /* Saw dot already?     */
-                break;                      /* Exit loop, two dots  */
-            dotflag = TRUE;                 /* Remember the dot     */
-            radix = 10;                     /* Decimal fraction     */
-        }
-        else {                              /* Check the digit      */
-            switch (c) {
-            case '8': case '9':             /* Sometimes wrong      */
-                octal89 = TRUE;             /* Do check later       */
-            case '0': case '1': case '2': case '3':
-            case '4': case '5': case '6': case '7':
-                break;                      /* Always ok            */
-
-            case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
-            case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
-                if (radix == 16)            /* Alpha's are ok only  */
-                    break;                  /* if reading hex.      */
-            default:                        /* At number end        */
-                goto done;                  /* Break from for loop  */
-            }                               /* End of switch        */
-        }                                   /* End general case     */
-        *out++ = c;                         /* Accept the character */
-        c = get_ch();                       /* Read another char    */
-    }                                       /* End of scan loop     */
-
-    if (out_end < out)                      /* Buffer overflow      */
-        goto  nomore;
-    /*
-     * When we break out of the scan loop, c contains the first
-     * character (maybe) not in the number.  If the number is an
-     * integer, allow a trailing 'L' for long.  If not those, push
-     * the trailing character back on the input stream.
-     * Floating point numbers accept a trailing 'L' for "long double".
-     */
-done:
-    if (! (dotflag || expseen)) {           /* Not floating point   */
-        /*
-         * We know that dotflag and expseen are both zero, now:
-         *   dotflag signals "saw 'L'".
-         */
-        for (;;) {
-            switch (c) {
-            case 'l':
-            case 'L':
-                if (dotflag)
-                    goto nomore;
-                dotflag = TRUE;
-                break;
-            default:
-                goto nomore;
-            }
-            *out++ = c;                     /* Got 'L' .            */
-            c = get_ch();                   /* Look at next, too.   */
-        }
-    }
-
-nomore: *out = EOS;
-    if (out_end < out)
-        goto  overflow;
-    unget_ch();                             /* Not part of a number */
-    if (octal89 && radix == 8 && (warn_level & 1))
-        cwarn( "Illegal digit in octal number \"%s\""       /* _W1_ */
-                , out_s, 0L, NULL);
-    return  out;
-
-overflow:
-    cfatal( "Too long number token \"%s\"", out_s, 0L, NULL);       /* _F_  */
-    return  out;
-}
-
-#if OK_UCN
-static char *   scan_ucn(
-    int     cnt,                            /* Bytes of sequence    */
-    char *  out                             /* Output buffer        */
-)
-/*
- * Scan an UCN sequence and put the sequence to 'out'.
- * Return the advanced pointer or NULL on failure.
- * This routine is never called in POST_STD mode.
- */
-{
-    uexpr_t value;                              /* Value of UCN     */
-    int     i, c;
-
-    value = 0L;
-    for (i = 0; i < cnt; i++) {
-        c = get_ch();
-        if (! isxdigit( c)) {
-            if (infile->fp)
-                cerror( "Illegal UCN sequence"              /* _E_  */
-                        , NULL, 0L, NULL);
-                *out = EOS;
-                unget_ch();
-                return  NULL;
-        }
-        c = tolower( c);
-        *out++ = c;
-        c = (isdigit( c) ? (c - '0') : (c - 'a' + 10));
-        value = (value << 4) | c;
-    }
-    if (infile->fp                              /* In source        */
-            && ((value >= 0L && value <= 0x9FL
-                && value != 0x24L && value != 0x40L && value != 0x60L)
-                                    /* Basic source character       */
-            || (stdc3 && (value >= 0xD800L && value <= 0xDFFFL))))
-                                    /* Reserved for special chars   */
-        cerror( "UCN cannot specify the value %.0s\"%08lx\""    /* _E_    */
-                    , NULL, (long) value, NULL);
-    return  out;
-}
-#endif  /* OK_UCN   */
-
 static char *   scan_op(
     int     c,                          /* First char of the token  */
     char *  out                         /* Output buffer            */
@@ -1192,7 +745,7 @@ static char *   scan_op(
  *   nevertheless is handled as a punctuator in this cpp for convenience.
  */
 {
-    int     c2, c3, c4;
+    int     c2, c3;
 
     *out++ = c;
 
@@ -1251,16 +804,10 @@ static char *   scan_op(
             break;
         case '=':   openum = OP_LE;         break;      /* <=       */
         case ':':                                   /* <: i.e. [    */
-            if (mcpp_mode == STD && option_flags.dig)
-                openum = OP_LBRCK_D;
-            else
-                openum = OP_LT;
+            openum = OP_LT;
             break;
         case '%':                                   /* <% i.e. {    */
-            if (mcpp_mode == STD && option_flags.dig)
-                openum = OP_LBRACE_D;
-            else
-                openum = OP_LT;
+            openum = OP_LT;
             break;
         default :   openum = OP_LT;         break;      /* <        */
         }
@@ -1281,7 +828,7 @@ static char *   scan_op(
         }
         break;
     case '#':
-        if (standard && (in_define || macro_line))  /* in #define or macro  */
+        if ((in_define || macro_line))  /* in #define or macro  */
             openum = ((c2 == '#') ? OP_CAT : OP_STR);   /* ##, #    */
         else
             openum = OP_1;                              /* #        */
@@ -1300,15 +847,7 @@ static char *   scan_op(
             /* openum = OP_2;   */
             break;
         case '>':
-            if (cplus_val) {
-                if ((c3 = get_ch()) == '*') {           /* ->*      */
-                    openum = OP_3;
-                    *out++ = c3;
-                } else {
-                    /* openum = OP_2;   */
-                    unget_ch();
-                }
-            }   /* else openum = OP_2;  */              /* ->       */
+           /* else openum = OP_2;  */              /* ->       */
             /* else openum = OP_2;      */
             break;
         default :   openum = OP_SUB;        break;      /* -        */
@@ -1318,36 +857,10 @@ static char *   scan_op(
         switch (c2) {
         case '=':                           break;      /* %=       */
         case '>':                                   /* %> i.e. }    */
-            if (mcpp_mode == STD && option_flags.dig)
-                openum = OP_RBRACE_D;
-            else
-                openum = OP_MOD;
+            openum = OP_MOD;
             break;
         case ':':
-            if (mcpp_mode == STD && option_flags.dig) {
-                if ((c3 = get_ch()) == '%') {
-                    if ((c4 = get_ch()) == ':') {   /* %:%: i.e. ## */
-                        openum = OP_DSHARP_D;
-                        *out++ = c3;
-                        *out++ = c4;
-                    } else {
-                        unget_ch();
-                        unget_ch();
-                        openum = OP_SHARP_D;        /* %: i.e. #    */
-                    }
-                } else {
-                    unget_ch();
-                    openum = OP_SHARP_D;            /* %: i.e. #    */
-                }
-                if (in_define) {                    /* in #define   */
-                    if (openum == OP_DSHARP_D)
-                        openum = OP_CAT;
-                    else
-                        openum = OP_STR;
-                }
-            } else {
-                openum = OP_MOD;
-            }
+            openum = OP_MOD;
             break;
         default :   openum = OP_MOD;        break;      /* %        */
         }
@@ -1368,33 +881,22 @@ static char *   scan_op(
         /* else openum = OP_2;  */                      /* ^=       */
         break;
     case '.':
-        if (standard) {
-            if (c2 == '.') {
-                c3 = get_ch();
-                if (c3 == '.') {
-                    openum = OP_ELL;                    /* ...      */
-                    *out++ = c3;
-                    break;
-                } else {
-                    unget_ch();
-                    openum = OP_1;
-                }
-            } else if (cplus_val && c2 == '*') {        /* .*       */
-                /* openum = OP_2    */  ;
-            } else {                                    /* .        */
+        if (c2 == '.') {
+            c3 = get_ch();
+            if (c3 == '.') {
+                openum = OP_ELL;                    /* ...      */
+                *out++ = c3;
+                break;
+            } else {
+                unget_ch();
                 openum = OP_1;
             }
-        } else {    
+        } else {                                    /* .        */
             openum = OP_1;
         }
         break;
     case ':':
-        if (cplus_val && c2 == ':')                     /* ::       */
-            /* openum = OP_2    */  ;
-        else if (mcpp_mode == STD && c2 == '>' && option_flags.dig)
-            openum = OP_RBRCK_D;                    /* :> i.e. ]    */
-        else                                            /* :        */
-            openum = OP_COL;
+        openum = OP_COL;
         break;
     default:                                    /* Never reach here */
         cfatal( "Bug: Punctuator is mis-implemented %.0s0lx%x"      /* _F_  */
@@ -1405,7 +907,7 @@ static char *   scan_op(
 
     switch (openum) {
     case OP_STR:
-        if (mcpp_mode == STD && c == '%')    break;              /* %:   */
+        if (c == '%')    break;              /* %:   */
     case OP_1:
     case OP_NOT:    case OP_AND:    case OP_OR:     case OP_LT:
     case OP_GT:     case OP_ADD:    case OP_SUB:    case OP_MOD:
@@ -1422,46 +924,6 @@ static char *   scan_op(
     return  out;
 }
 
-int     id_operator(
-    const char *    name
-)
-/*
- * Check whether the name is identifier-like operator in C++.
- * Return the operator number if matched, return 0 if not matched.
- * Note: these identifiers are defined as macros in <iso646.h> in C95.
- * This routine is never called in POST_STD mode.
- */
-{
-    typedef struct  id_op {
-        const char *    name;
-        int             op_num;
-    } ID_OP;
-
-    ID_OP   id_ops[] = {
-        { "and",    OP_ANA},
-        { "and_eq", OP_2},
-        { "bitand", OP_AND},
-        { "bitor",  OP_OR},
-        { "compl",  OP_COM},
-        { "not",    OP_NOT},
-        { "not_eq", OP_NE},
-        { "or",     OP_ORO},
-        { "or_eq",  OP_2},
-        { "xor",    OP_XOR},
-        { "xor_eq", OP_2},
-        { NULL,     0},
-    };
-
-    ID_OP *     id_p = id_ops;
-
-    while (id_p->name != NULL) {
-        if (str_eq( name, id_p->name))
-            return  id_p->op_num;
-        id_p++;
-    }
-    return  0;
-}
-
 void    expanding(
     const char *    name,       /* The name of (nested) macro just expanded. */
     int             to_be_freed /* The name should be freed later.  */
@@ -1519,24 +981,6 @@ int     get_ch( void)
     if ((file = infile) == NULL)
         return  CHAR_EOF;                   /* End of all input     */
 
-    if (mcpp_mode == POST_STD && file->fp) {        /* In a source file     */
-        switch (insert_sep) {
-        case NO_SEP:
-            break;
-        case INSERT_SEP:                /* Insert a token separator */
-            insert_sep = INSERTED_SEP;      /* Remember this fact   */
-            return  ' ';                    /*   for unget_ch().    */
-        case INSERTED_SEP:                  /* Has just inserted    */
-            insert_sep = NO_SEP;            /* Clear the flag       */
-            break;
-        }
-    }
-    if (! standard && squeezews) {
-        if (*file->bptr == ' ')
-            file->bptr++;                   /* Squeeze white spaces */
-        squeezews = FALSE;
-    }
-
     if (mcpp_debug & GETC) {
         mcpp_fprintf( DBG, "get_ch(%s) '%c' line %ld, bptr = %d, buffer"
             , file->fp ? cur_fullname : file->real_fname ? file->real_fname
@@ -1556,19 +1000,7 @@ int     get_ch( void)
      * The character is converted to int with no sign-extension.
      */
     if ((c = (*file->bptr++ & UCHARMAX)) != EOS) {
-        if (standard)
-            return  c;                      /* Just a character     */
-        if (! in_string && c == '\\' && *file->bptr == '\n'
-                && in_define        /* '\\''\n' is deleted in #define line, */
-                    /*   provided the '\\' is not the 2nd byte of mbchar.   */
-                && ! last_is_mbchar( file->buffer, strlen( file->buffer) - 2
-                && ! keep_spaces)
-            ) {
-            if (*(file->bptr - 2) == ' ')
-                squeezews = TRUE;
-        } else {
-            return  c;
-        }
+        return  c;                      /* Just a character     */
     }
 
     /*
@@ -1608,10 +1040,8 @@ int     get_ch( void)
         infile->bptr = infile->buffer + len;
         src_line = infile->line;            /* Reset line number    */
         inc_dirp = infile->dirp;            /* Includer's directory */
-#if MCPP_LIB
         mcpp_set_out_func( infile->last_fputc, infile->last_fputs,
                            infile->last_fprintf);
-#endif
         include_nest--;
         src_line++;                         /* Next line to #include*/
         sharp( NULL, infile->include_opt ? 1 : (file->include_opt ? 0 : 2));
@@ -1656,22 +1086,13 @@ static char *   parse_line( void)
 
     if ((sp = get_line( FALSE)) == NULL)    /* Next logical line    */
         return  NULL;                       /* End of a file        */
-    if (in_asm) {                           /* In #asm block        */
-        while (char_type[ *sp++ & UCHARMAX] & SPA)
-            ;
-        if (*--sp == '#')                   /* Directive line       */
-            infile->bptr = sp;
-        return  infile->bptr;               /* Don't tokenize       */
-    }
     tp = temp = xmalloc( (size_t) NBUFF);
     limit = temp + NBUFF - 2;
 
     while (char_type[ c = *sp++ & UCHARMAX] & HSP) {
-        if (mcpp_mode != POST_STD)
-            /* Preserve line top horizontal white spaces    */
-            /*      as they are for human-readability       */
-            *tp++ = c;
-        /* Else skip the line top spaces    */
+        /* Preserve line top horizontal white spaces    */
+        /*      as they are for human-readability       */
+        *tp++ = c;
     }
     sp--;
 
@@ -1681,41 +1102,18 @@ static char *   parse_line( void)
         case '/':
             switch (*sp++) {
             case '*':                       /* Start of a comment   */
-com_start:
                 if ((sp = read_a_comment( sp, &com_size)) == NULL) {
                     free( temp);            /* End of file with un- */
                     return  NULL;           /*   terminated comment */
                 }
-                if (keep_spaces && mcpp_mode != OLD_PREP) {
-                    if (tp + com_size >= limit - 1)     /* Too long comment */
-                        com_size = limit - tp - 1;      /* Truncate */
-                    while (com_size--)
-                        *tp++ = ' ';        /* Spaces of the comment length */
-                    break;
-                }
-                switch (mcpp_mode) {
-                case POST_STD:
-                    if (temp < tp && *(tp - 1) != ' ')
-                        *tp++ = ' ';        /* Squeeze white spaces */
-                    break;
-                case OLD_PREP:
-                    if (temp == tp
-                            || ! (char_type[ *(tp - 1) & UCHARMAX] & HSP))
-                        *tp++ = COM_SEP;    /* Convert to magic character   */
-                    break;
-                default:
-                    if (temp == tp ||
-                            ! (char_type[ *(tp - 1) & UCHARMAX] & HSP))
-                        *tp++ = ' ';        /* Squeeze white spaces */
-                    break;
-                }
+                if (temp == tp ||
+                        ! (char_type[ *(tp - 1) & UCHARMAX] & HSP))
+                    *tp++ = ' ';        /* Squeeze white spaces */
                 break;
             case '/':                                       /* //   */
-                if (! standard)
-                    goto  not_comment;
                 /* Comment when C++ or __STDC_VERSION__ >= 199901L      */
                 /* Need not to convert to a space because '\n' follows  */
-                if (! stdc2 && (warn_level & 2))
+                if ((warn_level & 2))
                     cwarn( "Parsed \"//\" as comment"       /* _W2_ */
                             , NULL, 0L, NULL);
                 if (keep_comments) {
@@ -1727,7 +1125,6 @@ com_start:
                 }
                 goto  end_line;
             default:                        /* Not a comment        */
-not_comment:
                 *tp++ = '/';
                 sp--;                       /* To re-read           */
                 break;
@@ -1742,27 +1139,14 @@ not_comment:
                     , NULL, (long) c, NULL);
         case '\t':                          /* Horizontal space     */
         case ' ':
-            if (keep_spaces) {
-                if (c == '\t')
-                    *tp++ = '\t';
-                else
-                    *tp++ = ' ';            /* Convert to ' '       */
-            } else if (! (char_type[ *(tp - 1) & UCHARMAX] & HSP)) {
+            if (! (char_type[ *(tp - 1) & UCHARMAX] & HSP)) {
                 *tp++ = ' ';                /* Squeeze white spaces */
-            } else if (mcpp_mode == OLD_PREP && *(tp - 1) == COM_SEP) {
-                *(tp - 1) = ' ';    /* Replace COM_SEP with ' '     */
             }
             break;
         case '"':                           /* String literal       */
         case '\'':                          /* Character constant   */
             infile->bptr = sp;
-            if (standard) {
-                tp = scan_quote( c, tp, limit, TRUE);
-            } else {
-                in_string = TRUE;   /* Enable line splicing by scan_quote() */
-                tp = scan_quote( c, tp, limit, TRUE);   /* (not by get_ch())*/
-                in_string = FALSE;
-            }
+            tp = scan_quote( c, tp, limit, TRUE);
             if (tp == NULL) {
                 free( temp);                /* Unbalanced quotation */
                 return  parse_line();       /* Skip the line        */
@@ -1799,7 +1183,7 @@ end_line:
         while (char_type[ *temp & UCHARMAX] & HSP)
             temp++;
         if (*temp == '#'        /* This line starts with # token    */
-                || (mcpp_mode == STD && *temp == '%' && *(temp + 1) == ':'))
+                || (*temp == '%' && *(temp + 1) == ':'))
             if (warn_level & 1)
                 cwarn(
     "Macro started at line %.0s%ld swallowed directive-like line"   /* _W1_ */
@@ -1820,10 +1204,6 @@ static char *   read_a_comment(
     char *      saved_sp;
     int         cat_line = 0;       /* Number of catenated lines    */
 
-    if (keep_spaces) {
-        saved_sp = sp - 2;          /* '-2' for beginning / and *   */
-        *sizp = 0;
-    }        
     if (keep_comments)                      /* If writing comments  */
         mcpp_fputs( "/*", OUT);             /* Write the initializer*/
     c = *sp++;
@@ -1850,8 +1230,6 @@ static char *   read_a_comment(
                     /*  trouble on some other tools such as rpcgen. */
                 wrong_line = TRUE;
             }
-            if (keep_spaces)                /* Save the length      */
-                *sizp = *sizp + (sp - saved_sp);
             if ((mcpp_debug & MACRO_CALL) && compiling) {
                 if (cat_line) {
                     cat_line++;
@@ -1864,8 +1242,6 @@ static char *   read_a_comment(
             }
             return  sp;                     /* End of comment       */
         case '\n':                          /* Line-crossing comment*/
-            if (keep_spaces)                /* Save the length      */
-                *sizp = *sizp + (sp - saved_sp) - 1;    /* '-1' for '\n'    */
             if ((mcpp_debug & MACRO_CALL) && compiling) {
                                     /* Save location informations   */
                 if (cat_line == 0)  /* First line of catenation     */
@@ -1916,11 +1292,7 @@ static char *   get_line(
  * Convert [CR+LF] to [LF]. 
  */
 {
-#if COMPILER == INDEPENDENT
 #define cr_warn_level 1
-#else
-#define cr_warn_level 2
-#endif
     static int  cr_converted;
     int     converted = FALSE;
     int     len;                            /* Line length - alpha  */
@@ -1937,7 +1309,7 @@ static char *   get_line(
             != NULL) {
         /* Translation phase 1  */
         src_line++;                 /* Gotten next physical line    */
-        if (standard && src_line == std_limits.line_num + 1
+        if (src_line == std_limits.line_num + 1
                 && (warn_level & 1))
             cwarn( "Line number %.0s\"%ld\" got beyond range"       /* _W1_ */
                     , NULL, src_line, NULL);
@@ -1967,40 +1339,34 @@ static char *   get_line(
                 cr_converted = TRUE;
             }
         }
-        if (standard) {
-            if (option_flags.trig)
-                converted = cnv_trigraph( ptr);
-            if (mcpp_mode == POST_STD && option_flags.dig)
-                converted += cnv_digraph( ptr);
-            if (converted)
-                len = strlen( ptr);
-            /* Translation phase 2  */
-            len -= 2;
-            if (len >= 0) {
-                if ((*(ptr + len) == '\\') && ! last_is_mbchar( ptr, len)) {
-                            /* <backslash><newline> (not MBCHAR)    */
-                    ptr = infile->bptr += len;  /* Splice the lines */
-                    wrong_line = TRUE;
-                    if ((mcpp_debug & MACRO_CALL) && compiling) {
-                                    /* Save location informations   */
-                        if (cat_line == 0)      /* First line of catenation */
-                            bsl_cat_line.start_line = src_line;
-                        if (cat_line < MAX_CAT_LINE)
-                                    /* Record the catenated length  */
-                            bsl_cat_line.len[ ++cat_line]
-                                    = strlen( infile->buffer) - 2;
-                        /* Else ignore  */
-                    }
-                    continue;
+        if (converted)
+            len = strlen( ptr);
+        /* Translation phase 2  */
+        len -= 2;
+        if (len >= 0) {
+            if (*(ptr + len) == '\\') {
+                        /* <backslash><newline> (not MBCHAR)    */
+                ptr = infile->bptr += len;  /* Splice the lines */
+                wrong_line = TRUE;
+                if ((mcpp_debug & MACRO_CALL) && compiling) {
+                                /* Save location informations   */
+                    if (cat_line == 0)      /* First line of catenation */
+                        bsl_cat_line.start_line = src_line;
+                    if (cat_line < MAX_CAT_LINE)
+                                /* Record the catenated length  */
+                        bsl_cat_line.len[ ++cat_line]
+                                = strlen( infile->buffer) - 2;
+                    /* Else ignore  */
                 }
+                continue;
             }
+        }
 #if NBUFF-2 > SLEN90MIN
-            if (ptr - infile->buffer + len + 2 > std_limits.str_len + 1
-                    && (warn_level & 4))    /* +1 for '\n'          */
-            cwarn( "Logical source line longer than %.0s%ld bytes"  /* _W4_ */
-                        , NULL, std_limits.str_len, NULL);
+        if (ptr - infile->buffer + len + 2 > std_limits.str_len + 1
+                && (warn_level & 4))    /* +1 for '\n'          */
+        cwarn( "Logical source line longer than %.0s%ld bytes"  /* _W4_ */
+                    , NULL, std_limits.str_len, NULL);
 #endif
-        }
         if ((mcpp_debug & MACRO_CALL) && compiling) {
             if (cat_line && cat_line < MAX_CAT_LINE) {
                 bsl_cat_line.len[ ++cat_line] = strlen( infile->buffer) - 1;
@@ -2016,98 +1382,9 @@ static char *   get_line(
         cfatal( "File read error", NULL, 0L, NULL);         /* _F_  */
     if ((ptr = at_eof( in_comment)) != NULL)        /* Check at end of file */
         return  ptr;                        /* Partial line supplemented    */
-    if (option_flags.z) {
-        no_output--;                        /* End of included file */
-        keep_comments = option_flags.c && compiling && !no_output;
-    }
     return  NULL;
 }
 
-#define TRIOFFSET       10
-
-int     cnv_trigraph(
-    char *      in
-)
-/*
- * Perform in-place trigraph replacement on a physical line.  This was added
- * to the C90.  In an input text line, the sequence ??[something] is
- * transformed to a character (which might not appear on the input keyboard).
- */
-{
-    const char * const  tritext = "=(/)'<!>-\0#[\\]^{|}~";
-    /*                             ^          ^
-     *                             +----------+
-     *                             this becomes this
-     */
-    int     count = 0;
-    const char *    tp;
-
-    while ((in = strchr( in, '?')) != NULL) {
-        if (*++in != '?')
-            continue;
-        while (*++in == '?')
-            ;
-        if ((tp = strchr( tritext, *in)) == NULL)
-            continue;
-        *(in - 2) = *(tp + TRIOFFSET);
-        in--;
-        memmove( in, in + 2, strlen( in + 1));
-        count++;
-    }
-
-    if (count && (warn_level & 16))
-        cwarn( "%.0s%ld trigraph(s) converted"          /* _W16_    */
-                , NULL, (long) count, NULL);
-    return  count;
-}
-
-int     cnv_digraph(
-    char *      in
-)
-/*
- * Perform in-place digraph replacement on a physical line.
- * Called only in POST_STD mode.
- */
-{
-    int     count = 0;
-    int     i;
-    int     c1, c2;
-
-    while ((i = strcspn( in, "%:<")), (c1 = *(in + i)) != '\0') {
-        in += i + 1;
-        c2 = *in;
-        switch (c1) {
-        case '%'    :
-            switch (c2) {
-            case ':'    :   *(in - 1) = '#';    break;
-            case '>'    :   *(in - 1) = '}';    break;
-            default     :   continue;
-            }
-            break;
-        case ':'    :
-            switch (c2) {
-            case '>'    :   *(in - 1) = ']';    break;
-            default     :   continue;
-            }
-            break;
-        case '<'    :
-            switch (c2) {
-            case '%'    :   *(in - 1) = '{';    break;
-            case ':'    :   *(in - 1) = '[';    break;
-            default     :   continue;
-            }
-            break;
-        }
-        memmove( in, in + 1, strlen( in));
-        count++;
-    }
-
-    if (count && (warn_level & 16))
-        cwarn( "%.0s%ld digraph(s) converted"           /* _W16_    */
-                , NULL, (long) count, NULL);
-    return  count;
-}
-
 static char *   at_eof(
     int     in_comment
 )
@@ -2131,8 +1408,6 @@ static char *   at_eof(
     const char * const  unterm_com
             = "unterminated comment, terminated the comment";   /* _W1_     */
     const char * const  backsl = "\\, deleted the \\";  /* _W1_     */
-    const char * const  unterm_asm_format
-= "End of %s with unterminated #asm block started at line %ld"; /* _E_ _W1_ */
     size_t  len;
     char *  cp;
 
@@ -2141,11 +1416,11 @@ static char *   at_eof(
     if (len && *(cp += (len - 1)) != '\n') {
         *++cp = '\n';                       /* Supplement <newline> */
         *++cp = EOS;
-        if (mcpp_mode != OLD_PREP && (warn_level & 1))
+        if ((warn_level & 1))
             cwarn( format, input, 0L, no_newline);
         return  infile->bptr = infile->buffer;
     }
-    if (standard && infile->buffer < infile->bptr) {
+    if (infile->buffer < infile->bptr) {
                             /* No line after <backslash><newline>   */
         cp = infile->bptr;
         *cp++ = '\n';                       /* Delete the \\        */
@@ -2155,7 +1430,7 @@ static char *   at_eof(
         return  infile->bptr = infile->buffer;
     }
     if (in_comment) {               /* End of file within a comment */
-        if (mcpp_mode != OLD_PREP && (warn_level & 1))
+        if ((warn_level & 1))
             cwarn( format, input, 0L, unterm_com);
         /* The partial comment line has been already read by        */
         /* read_a_comment(), so supplement the  next line.          */
@@ -2165,28 +1440,17 @@ static char *   at_eof(
 
     if (infile->initif < ifptr) {
         IFINFO *    ifp = infile->initif + 1;
-        if (standard) {
-            cerror( unterm_if_format, input, ifp->ifline, NULL);
-            ifptr = infile->initif;         /* Clear information of */
-            compiling = ifptr->stat;        /*   erroneous grouping */
-        } else if (mcpp_mode == KR && (warn_level & 1)) {
-            cwarn( unterm_if_format, input, ifp->ifline, NULL);
-        }
+        cerror( unterm_if_format, input, ifp->ifline, NULL);
+        ifptr = infile->initif;         /* Clear information of */
+        compiling = ifptr->stat;        /*   erroneous grouping */
     }
 
     if (macro_line != 0 && macro_line != MACRO_ERROR
-            && ((mcpp_mode == STD && in_getarg) || ! standard)) {
-        if (standard) {
-            cerror( unterm_macro_format, input, macro_line, NULL);
-            macro_line = MACRO_ERROR;
-        } else if (warn_level & 1) {
-            cwarn( unterm_macro_format, input, macro_line, NULL);
-        }
+            && in_getarg) {
+        cerror( unterm_macro_format, input, macro_line, NULL);
+        macro_line = MACRO_ERROR;
     }
 
-    if (in_asm && mcpp_mode == KR && (warn_level & 1))
-        cwarn( unterm_asm_format, input, in_asm, NULL);
-
     return  NULL;
 }
 
@@ -2204,19 +1468,6 @@ void    unget_ch( void)
     }
 
     if (infile != NULL) {
-        if (mcpp_mode == POST_STD && infile->fp) {
-            switch (insert_sep) {
-            case INSERTED_SEP:  /* Have just read an inserted separator */
-                insert_sep = INSERT_SEP;
-                return;
-            case INSERT_SEP:
-                cfatal( "Bug: unget_ch() just after scan_token()"   /* _F_  */
-                        , NULL, 0L, NULL);
-                break;
-            default:
-                break;
-            }
-        }
         --infile->bptr;
         if (infile->bptr < infile->buffer)      /* Shouldn't happen */
             cfatal( "Bug: Too much pushback", NULL, 0L, NULL);      /* _F_  */
@@ -2304,18 +1555,14 @@ FILEINFO *  get_file(
     } else {
         file->src_dir = NULL;
     }
-#if MCPP_LIB
     file->last_fputc = mcpp_lib_fputc;
     file->last_fputs = mcpp_lib_fputs;
     file->last_fprintf = mcpp_lib_fprintf;
-#endif
     if (infile != NULL) {                   /* If #include file     */
         infile->line = src_line;            /* Save current line    */
-#if MCPP_LIB
         infile->last_fputc = mcpp_fputc;
         infile->last_fputs = mcpp_fputs;
         infile->last_fprintf = mcpp_fprintf;
-#endif
     }
     infile = file;                          /* New current file     */
 
@@ -2409,23 +1656,6 @@ LINE_COL *  get_src_location(
     return  p_line_col;
 }
 
-static void put_line(
-    char *  out,
-    FILE *  fp
-)
-/*
- * Put out a logical source line.
- * This routine is called only in OLD_PREP mode.
- */
-{
-    int     c;
-
-    while ((c = *out++) != EOS) {
-        if (c != COM_SEP)           /* Skip 0-length comment        */
-            mcpp_fputc( c, FP2DEST( fp));
-    }
-}
-
 static void do_msg(
     const char *    severity,       /* "fatal", "error", "warning"  */
     const char *    format,         /* Format for the error message */
@@ -2468,45 +1698,27 @@ static void do_msg(
         while ((c = *sp++) != EOS) {
             switch (c) {
             case TOK_SEP:
-                if (mcpp_mode == OLD_PREP)      /* COM_SEP          */
-                    break;              /* Skip magic characters    */
-                /* Else fall through    */
             case RT_END:
             case CAT:
             case ST_QUOTE:
             case DEF_MAGIC:
-                if (! standard)
-                    *tp++ = ' ';
                 break;                  /* Skip the magic characters*/
             case IN_SRC:
-                if (! standard)
-                    *tp++ = ' ';
                 if ((mcpp_debug & MACRO_CALL) && ! in_directive)
                     sp += 2;            /* Skip two more bytes      */
                 break;
             case MAC_INF:
-                if (mcpp_mode != STD) {
-                    *tp++ = ' ';
-                    /* Illegal control character, convert to a space*/
-                } else {
-                    switch (*sp++) {    /* Skip the magic characters*/
-                    case MAC_ARG_START  :
-                        sp++;
-                        /* Fall through */
-                    case MAC_CALL_START :
-                        sp += 2;
-                        break;
-                    case MAC_ARG_END    :
-                        if (! option_flags.v)
-                            break;
-                        else
-                            sp++;
-                            /* Fall through */
-                    case MAC_CALL_END   :
-                        if (option_flags.v)
-                            sp += 2;
-                        break;
-                    }
+                switch (*sp++) {    /* Skip the magic characters*/
+                case MAC_ARG_START  :
+                    sp++;
+                    /* Fall through */
+                case MAC_CALL_START :
+                    sp += 2;
+                    break;
+                case MAC_ARG_END    :
+                    break;
+                case MAC_CALL_END   :
+                    break;
                 }
                 break;
             case '\n':
@@ -2533,19 +1745,12 @@ static void do_msg(
     }
     mcpp_fprintf( ERR, format, arg_t[ 0], arg2, arg_t[ 1]);
     mcpp_fputc( '\n', ERR);
-    if (option_flags.no_source_line)
-        goto  free_arg;
 
     /* Print source line, includers and expanding macros    */
     file = infile;
     if (file != NULL && file->fp != NULL) {
-        if (mcpp_mode == OLD_PREP) {
-            mcpp_fputs( "    ", ERR);
-            put_line( file->buffer, fp_err);
-        } else {
-            mcpp_fprintf( ERR, "    %s", file->buffer);
-                                            /* Current source line  */
-        }
+        mcpp_fprintf( ERR, "    %s", file->buffer);
+                                        /* Current source line  */
         file = file->parent;
     }
     while (file != NULL) {                  /* Print #includes, too */
@@ -2561,17 +1766,11 @@ static void do_msg(
         } else {                            /* Source file          */
             if (file->buffer[ 0] == '\0')
                 strcpy( file->buffer, "\n");
-            if (mcpp_mode != OLD_PREP) {
-                mcpp_fprintf( ERR, "    from %s: %ld:    %s",
-                    file->line ? file->full_fname       /* Full-path-list   */
-                        : "<stdin>",        /* Included by -include */
-                    file->line,             /* Current line number  */
-                    file->buffer);          /* The source line      */
-            } else {
-                mcpp_fprintf( ERR, "    from %s: %ld:    ", file->full_fname
-                        , file->line);
-                put_line( file->buffer, fp_err);
-            }
+            mcpp_fprintf( ERR, "    from %s: %ld:    %s",
+                file->line ? file->full_fname       /* Full-path-list   */
+                    : "<stdin>",        /* Included by -include */
+                file->line,             /* Current line number  */
+                file->buffer);          /* The source line      */
         }
         file = file->parent;
     }
@@ -2681,12 +1880,11 @@ void    dump_string(
             mcpp_fprintf( DBG, "<%d>", c);
             break;
         case MAC_INF:
-            if (! (mcpp_mode == STD && (mcpp_debug & MACRO_CALL)))
+            if (! ((mcpp_debug & MACRO_CALL)))
                 goto  no_magic;
             /* Macro informations inserted by -K option */
             c2 = *cp++ & UCHARMAX;
-            if (option_flags.v || c2 == MAC_CALL_START
-                    || c2 == MAC_ARG_START) {
+            if (c2 == MAC_CALL_START || c2 == MAC_ARG_START) {
                 c = ((*cp++ & UCHARMAX) - 1) * UCHARMAX;
                 c += (*cp++ & UCHARMAX) - 1;
             }
@@ -2695,67 +1893,42 @@ void    dump_string(
                 mcpp_fprintf( DBG, "<MAC%d>", c);
                 break;
             case MAC_CALL_END:
-                if (option_flags.v)
-                    mcpp_fprintf( DBG, "<MAC_END%d>", c);
-                else
-                    chr = "<MAC_END>";
+                chr = "<MAC_END>";
                 break;
             case MAC_ARG_START:
                 c1 = *cp++ & UCHARMAX;
                 mcpp_fprintf( DBG, "<MAC%d:ARG%d>", c, c1 - 1);
                 break;
             case MAC_ARG_END:
-                if (option_flags.v) {
-                    c1 = *cp++ & UCHARMAX;
-                    mcpp_fprintf( DBG, "<ARG_END%d-%d>", c, c1 - 1);
-                } else {
-                    chr = "<ARG_END>";
-                }
+                chr = "<ARG_END>";
                 break;
             }
             break;
         case DEF_MAGIC:
-            if (standard) {
-                chr = "<MAGIC>";
-                break;
-            }       /* Else fall through    */
+            chr = "<MAGIC>";
+            break;
         case CAT:
-            if (standard) {
-                chr = "##";
-                break;
-            }       /* Else fall through    */
+            chr = "##";
+            break;
         case ST_QUOTE:
-            if (standard) {
-                chr = "#";
-                break;
-            }       /* Else fall through    */
+            chr = "#";
+            break;
         case RT_END:
-            if (standard) {
-                chr = "<RT_END>";
-                break;
-            }       /* Else fall through    */
+            chr = "<RT_END>";
+            break;
         case IN_SRC:
-            if (standard) {
-                if ((mcpp_debug & MACRO_CALL) && ! in_directive) {
-                    int     num;
-                    num = ((*cp++ & UCHARMAX) - 1) * UCHARMAX;
-                    num += (*cp++ & UCHARMAX) - 1;
-                    mcpp_fprintf( DBG, "<SRC%d>", num);
-                } else {
-                    chr = "<SRC>";
-                }
-            } else {                        /* Control character    */
-                mcpp_fprintf( DBG, "<^%c>", c + '@');
+            if ((mcpp_debug & MACRO_CALL) && ! in_directive) {
+                int     num;
+                num = ((*cp++ & UCHARMAX) - 1) * UCHARMAX;
+                num += (*cp++ & UCHARMAX) - 1;
+                mcpp_fprintf( DBG, "<SRC%d>", num);
+            } else {
+                chr = "<SRC>";
             }
             break;
         case TOK_SEP:
-            if (mcpp_mode == STD) {
-                chr = "<TSEP>";
-                break;
-            } else if (mcpp_mode == OLD_PREP) {     /* COM_SEP      */
-                chr = "<CSEP>";
-                break;
-            }       /* Else fall through    */
+            chr = "<TSEP>";
+            break;
         default:
 no_magic:
             if (c < ' ')