zeroc-ice 3.6b1 → 3.6.0

data/ext/ice/mcpp/expand.c

@@ -34,12 +34,8 @@
  * The macro expansion routines are placed here.
  */
 
-#if PREPROCESSED
-#include    "mcpp.H"
-#else
 #include    "system.H"
 #include    "internal.H"
-#endif
 
 #define ARG_ERROR   (-255)
 #define CERROR      1
@@ -58,17 +54,10 @@ typedef struct magic_seq {  /* Data of a sequence inserted between tokens   */
 } MAGIC_SEQ;
 
 static int      compat_mode;
-/* Expand recursive macro more than Standard (for compatibility with GNUC)  */
-#if COMPILER == GNUC
-static int      ansi;                   /* __STRICT_ANSI__ flag     */
-#endif
 
 static char *   expand_std( DEFBUF * defp, char * out, char * out_end
         , LINE_COL line_col, int * pragma_op);
                 /* Expand a macro completely (for Standard modes)   */
-static char *   expand_prestd( DEFBUF * defp, char * out, char * out_end
-        , LINE_COL line_col, int * pragma_op);
-                /* Expand a macro completely (for pre-Standard modes)       */
 static DEFBUF * is_macro_call( DEFBUF * defp, char ** cp, char ** endf
         , MAGIC_SEQ * mgc_seq);         /* Is this really a macro call ?    */
 static int      collect_args( const DEFBUF * defp, char ** arglist, int m_num);
@@ -97,20 +86,14 @@ static const char * const   unterm_macro
         = "Unterminated macro call \"%s\"";                 /* _E_  */
 static const char * const   narg_error
     = "%s than necessary %ld argument(s) in macro call \"%s\""; /* _E_ _W1_ */
-static const char * const   only_name
-        = "Macro \"%s\" needs arguments";                   /* _W8_ */
 
 void     expand_init(
-    int     compat,     /* "Compatible" to GNUC expansion of recursive macro*/
-    int     strict_ansi         /* __STRICT_ANSI__ flag for GNUC    */
+    int     compat     /* "Compatible" to GNUC expansion of recursive macro*/
 )
 /* Set expand_macro() function  */
 {
-    expand_macro = standard ? expand_std : expand_prestd;
+    expand_macro = expand_std;
     compat_mode = compat;
-#if COMPILER == GNUC
-    ansi = strict_ansi;
-#endif
 }
 
 DEFBUF *    is_macro(
@@ -146,12 +129,10 @@ static DEFBUF * is_macro_call(
         c = squeeze_ws( cp, endf, mgc_seq); /* See the next char.   */
         if (c == CHAR_EOF)                  /* End of file          */
             unget_string( "\n", NULL);      /* Restore skipped '\n' */
-        else if (! standard || c != RT_END)
+        else if (c != RT_END)
                         /* Still in the file and rescan boundary ?  */
             unget_ch();                     /* To see it again      */
         if (c != '(') {     /* Only the name of function-like macro */
-            if (! standard && warn_level & 8)
-                cwarn( only_name, defp->name, 0L, NULL);
             return  NULL;
         }
     }
@@ -235,8 +216,6 @@ static int      print_macro_inf( int c, char ** cpp, char ** opp);
 static char *   print_macro_arg( char *out, MACRO_INF * m_inf, int argn
         , int real_arg, int start);
                 /* Embed macro arg inf into comments*/
-static char *   chk_magic_balance( char * buf, char * buf_end, int move
-        , int diag);    /* Check imbalance of magics        */
 static char *   replace( DEFBUF * defp, char * out, char * out_end
         , const DEFBUF * outer, FILEINFO * rt_file, LINE_COL line_col
         , int in_src_n);
@@ -251,7 +230,7 @@ static int      prescan( const DEFBUF * defp, const char ** arglist
 static char *   catenate( const DEFBUF * defp, const char ** arglist
         , char * out, char * out_end, char ** token_p);
                 /* Catenate tokens                  */
-static const char * remove_magics( const char * argp, int from_last);
+static char * remove_magics( const char * argp, int from_last);
                 /* Remove pair of magic characters  */
 #if DEBUG_MACRO_ANN
 static void     chk_symmetry( char *  start_id, char *  end_id, size_t  len);
@@ -296,7 +275,7 @@ static char *   expand_std(
     macro_line = src_line;                  /* Line number for diag */
     macro_name = defp->name;
     rescan_level = 0;
-    trace_macro = (mcpp_mode == STD) && (mcpp_debug & MACRO_CALL)
+    trace_macro = (mcpp_debug & MACRO_CALL)
             && ! in_directive;
     if (trace_macro) {
         max_mac_num = INIT_MAC_INF;
@@ -330,40 +309,36 @@ static char *   expand_std(
     while ((c = *cp++) != EOS) {
         if (c == DEF_MAGIC)
             continue;                       /* Skip DEF_MAGIC       */
-        if (mcpp_mode == STD) {
-            if (c == IN_SRC) {              /* Skip IN_SRC          */
-                if (trace_macro)
-                    cp += 2;    /* Skip also the number (coded in 2 bytes)  */
-                continue;
-            } else if (c == TOK_SEP) {
-                /* Remove redundant token separator */
-                if ((char_type[ c1 & UCHARMAX] & HSP)
-                        || (char_type[ *cp & UCHARMAX] & HSP)
-                        || in_include || option_flags.lang_asm
-                        || (*cp == MAC_INF && *(cp + 1) == MAC_CALL_END)
-                        || (!option_flags.v && c1 == MAC_CALL_END)
-                        || (option_flags.v
-                            && *(cp - MAC_E_LEN_V - 1) == MAC_INF
-                            && *(cp - MAC_E_LEN_V) == MAC_CALL_END))
-                    continue;
-                    /* Skip separator just after ' ', '\t'          */
-                    /* and just after MAC_CALL_END.                 */
-                    /* Also skip this in lang_asm mode, #include    */
-                    /* Skip just before another TOK_SEP, ' ', '\t'  */
-                    /* Skip just before MAC_INF,MAC_CALL_END seq too*/
-                else
-                    c = ' ';                /* Else convert to ' '  */
-            } else if (trace_macro && (c == MAC_INF)) {
-                /* Embed macro expansion informations into comments */
-                c = *cp++;
-                c1 = print_macro_inf( c, &cp, &out_p);
-                if (out_end <= out_p) {
-                    cerror( macbuf_overflow, macro_name, 0, out);
-                    macro_line = MACRO_ERROR;
-                    goto  exp_end;
-                }
+
+        if (c == IN_SRC) {              /* Skip IN_SRC          */
+            if (trace_macro)
+                cp += 2;    /* Skip also the number (coded in 2 bytes)  */
+            continue;
+        } else if (c == TOK_SEP) {
+            /* Remove redundant token separator */
+            if ((char_type[ c1 & UCHARMAX] & HSP)
+                    || (char_type[ *cp & UCHARMAX] & HSP)
+                    || in_include
+                    || (*cp == MAC_INF && *(cp + 1) == MAC_CALL_END)
+                    || (c1 == MAC_CALL_END))
                 continue;
+                /* Skip separator just after ' ', '\t'          */
+                /* and just after MAC_CALL_END.                 */
+                /* Also skip this in lang_asm mode, #include    */
+                /* Skip just before another TOK_SEP, ' ', '\t'  */
+                /* Skip just before MAC_INF,MAC_CALL_END seq too*/
+            else
+                c = ' ';                /* Else convert to ' '  */
+        } else if (trace_macro && (c == MAC_INF)) {
+            /* Embed macro expansion informations into comments */
+            c = *cp++;
+            c1 = print_macro_inf( c, &cp, &out_p);
+            if (out_end <= out_p) {
+                cerror( macbuf_overflow, macro_name, 0, out);
+                macro_line = MACRO_ERROR;
+                goto  exp_end;
             }
+            continue;
         }
         *out_p++ = c1 = c;
     }
@@ -409,8 +384,7 @@ static int  print_macro_inf(
     if (*((*opp) - 1) == '/' && *((*opp) - 2) != '*')
                     /* Immediately preceding token is '/' (not '*' and '/') */
         *((*opp)++) = ' ';
-                /* Insert a space to separate with following '/' and '*'    */
-    if (option_flags.v || c == MAC_CALL_START || c == MAC_ARG_START) {
+    if (c == MAC_CALL_START || c == MAC_ARG_START) {
         num = ((*(*cpp)++ & UCHARMAX) - 1) * UCHARMAX;
         num += (*(*cpp)++ & UCHARMAX) - 1;
         m_inf = & mac_inf[ num];            /* Saved information    */
@@ -436,19 +410,9 @@ static int  print_macro_inf(
         *opp = print_macro_arg( *opp, m_inf, i, FALSE, TRUE);
         break;
     case MAC_CALL_END   :               /* End of a macro expansion */
-        if (option_flags.v) {               /* Verbose mode         */
-            *opp += sprintf( *opp, "/*%s>*/", m_inf->defp->name);
-            break;
-        }
         /* Else fall through    */
     case MAC_ARG_END    :               /* End of an argument       */
-        if (option_flags.v) {
-            i = (*(*cpp)++ & UCHARMAX) - 1;
-           /* Output verbose infs symmetrical to start of the arg infs  */
-            *opp = print_macro_arg( *opp, m_inf, i, FALSE, FALSE);
-        } else {
-            *opp = stpcpy( *opp, "/*>*/");
-        }
+        *opp = stpcpy( *opp, "/*>*/");
         break;
     }
 
@@ -483,163 +447,7 @@ static char *   print_macro_arg(
 
     return out;
 }
-
-static char *   chk_magic_balance(
-    char *  buf,                            /* Sequence to check    */
-    char *  buf_end,                        /* End of the sequence  */
-    int     move,                   /* Move a straying magic ?      */
-    int     diag                            /* Output a diagnostic? */
-)
-/*
- * Check imbalance of macro information magics and warn it.
- * get_an_arg() calls this routine setting 'move' argument on, hence a stray
- * magic is moved to an edge if found.
- * This routine does not do token parsing.  Yet it will do fine practically.
- */
-{
-#define MAX_NEST_MAGICS 255
-    char    mac_id[ MAX_NEST_MAGICS][ MAC_E_LEN_V - 2];
-    char    arg_id[ MAX_NEST_MAGICS][ ARG_E_LEN_V - 2];
-    char *  mac_loc[ MAX_NEST_MAGICS];
-    char *  arg_loc[ MAX_NEST_MAGICS];
-    char *  mesg = "%s %ld %s-closing-comment(s) in tracing macro";
-    int     mac, arg;
-    int     mac_s_n, mac_e_n, arg_s_n, arg_e_n;
-    char *  buf_p = buf;        /* Save 'buf' for debugging purpose */
-
-    mac = arg = 0;
-
-    while (buf_p < buf_end) {
-        if (*buf_p++ != MAC_INF)
-            continue;
-        switch (*buf_p++) {
-        case MAC_CALL_START :
-            if (option_flags.v) {
-                mac_loc[ mac] = buf_p - 2;
-                memcpy( mac_id[ mac], buf_p, MAC_S_LEN - 2);
-            }
-            mac++;
-            buf_p += MAC_S_LEN - 2;
-            break;
-        case MAC_ARG_START  :
-            if (option_flags.v) {
-                arg_loc[ arg] = buf_p - 2;
-                memcpy( arg_id[ arg], buf_p, ARG_S_LEN - 2);
-            }
-            arg++;
-            buf_p += ARG_S_LEN - 2;
-            break;
-        case MAC_ARG_END    :
-            arg--;
-            if (option_flags.v) {
-                if (arg < 0) {          /* Perhaps moved magic  */
-                    if (diag)
-                        cwarn( mesg, "Redundant", (long) -arg, "argument");
-                } else if (memcmp( arg_id[ arg], buf_p, ARG_E_LEN_V - 2) != 0)
-                {
-                    char *      to_be_edge = NULL;
-                    char *      cur_edge;
-
-                    if (arg >= 1 && memcmp( arg_id[ 0], buf_p, ARG_E_LEN_V - 2)
-                            == 0) {
-                        to_be_edge = arg_loc[ arg];
-                                            /* To be moved to top   */
-                        cur_edge = arg_loc[ 0];     /* Current top  */
-                    } else if (arg == 0) {
-                        char    arg_end_magic[ 2] = { MAC_INF, MAC_ARG_END};
-                        cur_edge = buf_end - ARG_E_LEN_V;
-                        /* Search the last magic    */
-                        /* Sequence from get_an_arg() is always     */
-                        /* surrounded by starting of an arg magic   */
-                        /* and its corresponding closing magic.     */
-                        while (buf_p + (ARG_E_LEN_V - 2) <= cur_edge 
-                                && memcmp( cur_edge, arg_end_magic, 2) != 0)
-                            cur_edge--;
-                        if (buf_p + (ARG_E_LEN_V - 2) <= cur_edge
-                                && memcmp( arg_id[ 0], cur_edge + 2
-                                        , ARG_E_LEN_V - 2) == 0) {
-                            to_be_edge = buf_p - 2; /* To be moved to end   */
-                        }
-                    }
-                    if (to_be_edge) {   /* Appropriate place found  */
-                        if (diag) {
-                            mac_s_n = ((to_be_edge[ 2] & UCHARMAX) - 1)
-                                    * UCHARMAX;
-                            mac_s_n += (to_be_edge[ 3] & UCHARMAX) - 1;
-                            arg_s_n = (to_be_edge[ 4] & UCHARMAX) - 1;
-                            mcpp_fprintf( ERR,
-                                "Stray arg inf of macro: %d:%d at line:%d\n"
-                                            , mac_s_n, arg_s_n, src_line);
-                        }
-                        if (move) {
-                            /* Move a stray magic to outside of sequences   */
-                            char    magic[ ARG_E_LEN_V];
-                            size_t  len = ARG_E_LEN_V;
-                            memcpy( magic, cur_edge, len);
-                                /* Save current edge    */
-                            if (to_be_edge == arg_loc[ arg])
-                                /* Shift followings to cur_edge */
-                                memmove( cur_edge, cur_edge + len
-                                        , to_be_edge - cur_edge);
-                            else        /* Shift precedents to cur_edge */
-                                memmove( to_be_edge + len, to_be_edge
-                                        , cur_edge - to_be_edge);
-                            memcpy( to_be_edge, magic, len);
-                            /* Restore old 'cur_edge' into old 'to_be_edge' */
-                        }
-                    } else {        /* Serious imbalance, just warn */
-                        char *      arg_p = arg_id[ arg];
-                        arg_s_n = ((arg_p[ 0] & UCHARMAX) - 1) * UCHARMAX;
-                        arg_s_n += (arg_p[ 1] & UCHARMAX) - 1;
-                        arg_e_n = ((buf_p[ 0] & UCHARMAX) - 1) * UCHARMAX;
-                        arg_e_n += (buf_p[ 1] & UCHARMAX) - 1;
-                        mcpp_fprintf( ERR,
-                "Asymmetry of arg inf found: start %d, end %d at line:%d\n"
-                                , arg_s_n, arg_e_n, src_line);
-                    }
-                }
-                buf_p += ARG_E_LEN_V - 2;
-            }
-            break;
-        case MAC_CALL_END   :
-            mac--;
-            if (option_flags.v) {
-                if (mac < 0) {
-                    if (diag)
-                        cwarn( mesg, "Redundant", (long) -mac, "macro");
-                } else if (memcmp( mac_id[ mac], buf_p, MAC_E_LEN_V - 2) != 0)
-                {
-                    char *      mac_p = mac_id[ mac];
-                    mac_s_n = ((mac_p[ 0] & UCHARMAX) - 1) * UCHARMAX;
-                    mac_s_n += (mac_p[ 1] & UCHARMAX) - 1;
-                    mac_e_n = ((buf_p[ 0] & UCHARMAX) - 1) * UCHARMAX;
-                    mac_e_n += (buf_p[ 1] & UCHARMAX) - 1;
-                    mcpp_fprintf( ERR,
-                "Asymmetry of macro inf found: start %d, end %d at line:%d\n"
-                            , mac_s_n, mac_e_n, src_line);
-                }
-                buf_p += MAC_E_LEN_V - 2;
-            }
-            break;
-        default :                       /* Not a MAC_INF sequence   */
-            break;                                  /* Continue     */
-        }
-    }
-
-    if (diag && (warn_level & 1)) {
-        if (mac > 0)
-            cwarn( mesg, "Lacking", (long) mac, "macro");
-        if (arg > 0)
-            cwarn( mesg, "Lacking", (long) arg, "argument");
-        if ((mac || arg) && (mcpp_debug & EXPAND))
-            mcpp_fputs(
-"Imbalance of magics occurred (perhaps a moved magic), see <expand_std exit> and diagnostics.\n"
-                    , DBG);
-    }
-
-    return  buf;
-}
-
+    
 static char *   replace(
     DEFBUF *    defp,                       /* Macro to be replaced */
     char *      out,                        /* Output Buffer        */
@@ -710,7 +518,8 @@ static char *   replace(
         } else {
             m_inf->locs.start_col = m_inf->locs.start_line = 0L;
         }
-        m_inf->args = m_inf->loc_args = NULL;       /* Default args */
+        m_inf->args = NULL;
+        m_inf->loc_args = NULL;       /* Default args */
         for (num = 1, recurs = 0; num < m_num; num++)
             if (mac_inf[ num].defp == defp)
                 recurs++;           /* Recursively nested macro     */
@@ -721,21 +530,17 @@ static char *   replace(
 
     if (nargs < DEF_NOARGS_DYNAMIC) {       /* __FILE__, __LINE__   */
         defp = def_special( defp);      /* These are redefined dynamically  */
-        if (mcpp_mode == STD) {
         /* Wrap repl-text with token separators to prevent token merging    */
-            *cur_out++ = TOK_SEP;     
-            cur_out = stpcpy( cur_out, defp->repl);
-            *cur_out++ = TOK_SEP;     
-            *cur_out = EOS;
-        } else {
-            cur_out = stpcpy( cur_out, defp->repl);
-        }
+        *cur_out++ = TOK_SEP;     
+        cur_out = stpcpy( cur_out, defp->repl);
+        *cur_out++ = TOK_SEP;     
+        *cur_out = EOS;
         if (enable_trace_macro) {
             m_inf->defp = defp;             /* Redefined dynamically*/
             cur_out = close_macro_inf( cur_out, m_num, in_src_n);
         }
         return  cur_out;
-    } else if (nargs == DEF_NOARGS_PREDEF_OLD && standard
+    } else if (nargs == DEF_NOARGS_PREDEF_OLD 
             && (warn_level & 1)) {          /* Some macros on GCC   */
         cwarn( "Old style predefined macro \"%s\" is used", /* _W2_ */
                 defp->name, 0L, NULL);
@@ -756,7 +561,7 @@ static char *   replace(
             m_inf->args = arglist[ 0];
             m_inf->num_args = num_args;     /* Number of actual args*/
         }
-        if (mcpp_mode == STD && outer && rt_file != infile) {
+        if (outer && rt_file != infile) {
                                  /* Has read over replacement-text  */
             if (compat_mode) {
                 enable_repl( outer, FALSE); /* Enable re-expansion  */
@@ -838,29 +643,17 @@ static char *   replace(
         cur_out = out_p = out;
         while ((c = *cur_out++) != EOS) {
             if (c == MAC_INF) {
-                if (! option_flags.v) {
-                    switch (*cur_out) {
-                    case MAC_ARG_START  :
-                        cur_out++;
-                        /* Fall through */
-                    case MAC_CALL_START :
-                        cur_out++;
-                        cur_out++;
-                        /* Fall through */
-                    default:
-                        cur_out++;
-                        break;
-                    }
-                } else {
-                    switch (*cur_out) {
-                    case MAC_ARG_START  :
-                    case MAC_ARG_END    :
-                        cur_out++;
-                        /* Fall through */
-                    default:
-                        cur_out += 3;
-                        break;
-                    }
+                switch (*cur_out) {
+                case MAC_ARG_START  :
+                    cur_out++;
+                    /* Fall through */
+                case MAC_CALL_START :
+                    cur_out++;
+                    cur_out++;
+                    /* Fall through */
+                default:
+                    cur_out++;
+                    break;
                 }
             } else {
                 *out_p++ = c;
@@ -889,10 +682,6 @@ static char *   close_macro_inf(
     m_inf = & mac_inf[ m_num];
     *out_p++ = MAC_INF;         /* Magic for end of macro expansion */
     *out_p++ = MAC_CALL_END;
-    if (option_flags.v) {
-        *out_p++ = (m_num / UCHARMAX) + 1;
-        *out_p++ = (m_num % UCHARMAX) + 1;
-    }
     *out_p = EOS;
     get_ch();                               /* Clear the garbage    */
     unget_ch();
@@ -988,16 +777,12 @@ static int  prescan(
      * inserted here and there.
      */
 
-    if (mcpp_mode == POST_STD) {
-        file = unget_string( defp->repl, defp->name);
-    } else {
-        *out++ = TOK_SEP;                   /* Wrap replacement     */
-        workp = work_buf;                   /*  text with token     */
-        workp = stpcpy( workp, defp->repl); /*   separators to      */
-        *workp++ = TOK_SEP;                 /*    prevent unintended*/
-        *workp = EOS;                       /*     token merging.   */
-        file = unget_string( work_buf, defp->name);
-    }
+    *out++ = TOK_SEP;                   /* Wrap replacement     */
+    workp = work_buf;                   /*  text with token     */
+    workp = stpcpy( workp, defp->repl); /*   separators to      */
+    *workp++ = TOK_SEP;                 /*    prevent unintended*/
+    *workp = EOS;                       /*     token merging.   */
+    file = unget_string( work_buf, defp->name);
 
     while (c = get_ch(), file == infile) {  /* To the end of repl   */
 
@@ -1026,10 +811,6 @@ static int  prescan(
                 out -= len;
                 *out = EOS;             /* Remove DEF_MAGIC, IN_SRC */
             }
-#if COMPILER == GNUC
-            if (*prev_token == ',')
-                break;      /* ', ##' sequence (peculiar to GCC)    */
-#endif
             if (horiz_space == out - 1) {
                 *--out = EOS;       /* Remove trailing white space  */
                 horiz_space = NULL;
@@ -1080,7 +861,6 @@ static char *   catenate(
  * other characters.
  */
 {
-    FILEINFO *      file;
     char *  prev_prev_token = NULL;
     const char *    invalid_token
     = "Not a valid preprocessing token \"%s\"";     /* _E_ _W2_     */
@@ -1096,34 +876,25 @@ static char *   catenate(
         out = prev_token;                   /* To overwrite         */
         if (trace_macro)
             argp = remove_magics( argp, TRUE);  /* Remove pair of magics    */
-        if ((mcpp_mode == POST_STD && *argp == EOS)
-                || (mcpp_mode == STD && *argp == RT_END)) {
+        if (argp == (char*)RT_END) {
             *out = EOS;                     /* An empty argument    */
         } else {
-            if (mcpp_mode == POST_STD) {
-                file = unget_string( argp, NULL);
-                while (c = get_ch(), file == infile) {
-                    prev_token = out;   /* Remember the last token  */
-                    scan_token( c, &out, out_end);
-                }       /* Copy actual argument without expansion   */
-                unget_ch();
-            } else {
-                unget_string( argp, NULL);
-                if (trace_macro)
-                    free( (char *) argp);
-                    /* malloc()ed in remove_magics()    */
-                while ((c = get_ch()) != RT_END) {
-                    prev_prev_token = prev_token;
-                    prev_token = out;   /* Remember the last token  */
-                    scan_token( c, &out, out_end);
-                }       /* Copy actual argument without expansion   */
-                if (*prev_token == TOK_SEP) {
-                    out = prev_token;
-                    prev_token = prev_prev_token;       /* Skip separator   */
-                }
+
+            unget_string( argp, NULL);
+            if (trace_macro)
+                free( (char *) argp);
+                /* malloc()ed in remove_magics()    */
+            while ((c = get_ch()) != RT_END) {
+                prev_prev_token = prev_token;
+                prev_token = out;   /* Remember the last token  */
+                scan_token( c, &out, out_end);
+            }       /* Copy actual argument without expansion   */
+            if (*prev_token == TOK_SEP) {
+                out = prev_token;
+                prev_token = prev_prev_token;       /* Skip separator   */
             }
             if (*prev_token == DEF_MAGIC 
-                    || (mcpp_mode == STD && *prev_token == IN_SRC)) {
+                    || (*prev_token == IN_SRC)) {
                 size_t  len = 1;
                 if (trace_macro && *prev_token == IN_SRC)
                     len = IN_SRC_LEN;
@@ -1148,8 +919,7 @@ static char *   catenate(
         argp = arglist[ c];                 /* Actual argument      */
         if (trace_macro)
             argp = remove_magics( argp, FALSE); /* Remove pair of magics    */
-        if ((mcpp_mode == POST_STD && *argp == EOS)
-                || (mcpp_mode == STD && *argp == RT_END)) {
+        if (*argp == RT_END) {
             *out = EOS;                     /* An empty argument    */
         } else {
             unget_string( argp, NULL);
@@ -1193,47 +963,30 @@ static char *   catenate(
         scan_token( c, (workp = work_buf, &workp), work_end);
         infile->fp = NULL;
         if (*infile->bptr != EOS) {         /* More than a token    */
-            if (option_flags.lang_asm) {    /* Assembler source     */
-                if (warn_level & 2)
-                    diag_macro( CWARN, invalid_token, prev_token, 0L, NULL
-                            , defp, NULL);
-            } else {
-                diag_macro( CERROR, invalid_token, prev_token, 0L, NULL, defp
-                       , NULL);
-            }
+            diag_macro( CERROR, invalid_token, prev_token, 0L, NULL, defp
+                   , NULL);
             infile->bptr += strlen( infile->bptr);
         }
         get_ch();                           /* To the parent "file" */
         unget_ch();
     }
 
-    if (mcpp_mode == STD && ! option_flags.lang_asm) {
-        *out++ = TOK_SEP;                   /* Prevent token merging*/
-        *out = EOS;
-    }
+    *out++ = TOK_SEP;                   /* Prevent token merging*/
+    *out = EOS;
     if (in_arg) {       /* There are more tokens after the generated one    */
-        if (mcpp_mode == POST_STD) {
-            file = infile;
-            while (c = get_ch(), file == infile) {
-                prev_token = out;       /* Remember the last token  */
-                scan_token( c, &out, out_end);
-            }           /* Copy rest of argument without expansion  */
-            unget_ch();
-        } else {
-            while ((c = get_ch()) != RT_END) {
-                if (c == TOK_SEP)
-                    continue;           /* Skip separator           */
-                prev_token = out;       /* Remember the last token  */
-                scan_token( c, &out, out_end);
-            }           /* Copy rest of argument without expansion  */
-        }
+        while ((c = get_ch()) != RT_END) {
+            if (c == TOK_SEP)
+                continue;           /* Skip separator           */
+            prev_token = out;       /* Remember the last token  */
+            scan_token( c, &out, out_end);
+        }           /* Copy rest of argument without expansion  */
     }
     *token_p = prev_token;          /* Report back the last token   */
 
     return  out;
 }
 
-static const char *     remove_magics(
+static char *     remove_magics(
     const char *    argp,       /* The argument list    */
     int     from_last           /* token is the last or first?  */
 )
@@ -1330,19 +1083,6 @@ static const char *     remove_magics(
                 arg_id[ arg_n++][ ARG_E_LEN_V - 1] = FALSE;
                 break;
             }
-            if (option_flags.v) {
-                switch (c) {
-                case MAC_CALL_END   :
-                    mac_id[ mac_n - 1][ 1] = *ap++ = get_ch();
-                    mac_id[ mac_n - 1][ 2] = *ap++ = get_ch();
-                    break;
-                case MAC_ARG_END    :
-                    arg_id[ arg_n - 1][ 1] = *ap++ = get_ch();
-                    arg_id[ arg_n - 1][ 2] = *ap++ = get_ch();
-                    arg_id[ arg_n - 1][ 3] = *ap++ = get_ch();
-                    break;
-                }
-            }
             mgc_index[ ind++] = c;      /* Index to mac_id[] and arg_id[]   */
             continue;
         } else if (char_type[ c & UCHARMAX] & HSP) {
@@ -1393,11 +1133,6 @@ static const char *     remove_magics(
                         nest_e--;
                         /* Search after the token   */
                         if (token < mac_loc[ mac_e] && nest_e == nest_s - 1) {
-#if DEBUG_MACRO_ANN
-                            if (option_flags.v)
-                                chk_symmetry( mac_id[ mac_s], mac_id[ mac_e]
-                                        , MAC_E_LEN - 2);
-#endif
                             mac_id[ mac_e][ MAC_S_LEN - 1] = TRUE;
                                                 /* To be removed    */
                             break;          /* Done for this mac_s  */
@@ -1430,11 +1165,6 @@ static const char *     remove_magics(
                     } else {
                         nest_e--;
                         if (token < arg_loc[ arg_e] && nest_e == nest_s - 1) {
-#if DEBUG_MACRO_ANN
-                            if (option_flags.v)
-                                chk_symmetry( arg_id[ arg_s], arg_id[ arg_e]
-                                        , ARG_E_LEN_V - 2);
-#endif
                             arg_id[ arg_e][ ARG_S_LEN - 1] = TRUE;
                             break;
                         }
@@ -1474,7 +1204,7 @@ static const char *     remove_magics(
             mark = MAC_S_LEN - 1;
             break;
         case MAC_CALL_END   :
-            len = option_flags.v ? MAC_E_LEN_V : MAC_E_LEN;
+            len = MAC_E_LEN;
             mark = MAC_E_LEN_V - 1;
             break;
         case MAC_ARG_START  :
@@ -1482,7 +1212,7 @@ static const char *     remove_magics(
             mark = ARG_S_LEN - 1;
             break;
         case MAC_ARG_END    :
-            len = option_flags.v ? ARG_E_LEN_V : ARG_E_LEN;
+            len = ARG_E_LEN;
             mark = ARG_E_LEN_V - 1;
             break;
         }
@@ -1559,15 +1289,13 @@ static char *   stringize(
  * Make a string literal from an argument.
  */
 {
-    char        arg_end_inf[ 8][ ARG_E_LEN_V - 1];
-                        /* Verbose information of macro arguments   */
-    FILEINFO *  file;
+
     int         stray_bsl = FALSE;          /* '\\' not in literal  */
     char *      out_p = out;
     int         token_type;
     int         num_arg_magic = 0;
     size_t      len;
-    size_t      arg_e_len = option_flags.v ? ARG_E_LEN_V : ARG_E_LEN;
+    size_t      arg_e_len = ARG_E_LEN;
     int         c;
 
     if (trace_macro) {
@@ -1585,7 +1313,6 @@ static char *   stringize(
         }
     }
 
-    file = unget_string( argp, NULL);
     len = strlen( infile->buffer);  /* Sequence ends with RT_END    */
     if (trace_macro) {          /* Remove suffixed argument closing magics  */
         /* There are 0 or more argument closing magic sequences and */
@@ -1598,12 +1325,6 @@ static char *   stringize(
                 || *(infile->buffer + len - 2) == TOK_SEP))) {
             if (*(infile->buffer + len - arg_e_len - 1) == MAC_INF
                     && *(infile->buffer + len - arg_e_len) == MAC_ARG_END) {
-                if (option_flags.v) {
-                    memcpy( arg_end_inf[ nmagic]
-                            , infile->buffer + len - arg_e_len + 1
-                            , arg_e_len - 2);
-                    arg_end_inf[ nmagic][ arg_e_len - 2] = EOS;
-                }
                 nmagic++;
                 len -= arg_e_len;
                 *(infile->buffer + len - 1) = RT_END;
@@ -1625,8 +1346,7 @@ static char *   stringize(
     }
     *out_p++ = '"';                         /* Starting quote       */
 
-    while ((c = get_ch()), ((mcpp_mode == POST_STD && file == infile)
-            || (mcpp_mode == STD && c != RT_END))) {
+    while ((c = get_ch()), (c != RT_END)) {
         if (c == ' ' || c == '\t') {
             *out_p++ = c;
             continue;
@@ -1650,17 +1370,6 @@ static char *   stringize(
                 get_ch();
                 break;
             }
-            if (option_flags.v) {
-                switch (c) {
-                case MAC_ARG_END    :
-                    get_ch();
-                    /* Fall through */
-                case MAC_CALL_END   :
-                    get_ch();
-                    get_ch();
-                    break;
-                }
-            }
             continue;
         }
         token_type = scan_token( c, (workp = work_buf, &workp), work_end);
@@ -1679,11 +1388,6 @@ static char *   stringize(
                 } else if (c == '"') {
                     *out_p++ = '\\';        /* Insert '\\'          */
                 } else if (c == '\\') {
-#if OK_UCN
-                    if (mcpp_mode == POST_STD || ! stdc3
-                            || (*workp != 'u' && *workp != 'U'))
-                                            /* Not UCN              */
-#endif
                         *out_p++ = '\\';
                 }
                 *out_p++ = c;
@@ -1696,15 +1400,11 @@ static char *   stringize(
         }
     }
 
-    if (mcpp_mode == POST_STD)
-        unget_ch();
     *out_p++ = '"';                         /* Closing quote        */
     if (trace_macro) {
         while (num_arg_magic--) {
             *out_p++ = MAC_INF;             /* Restore removed magic*/
             *out_p++ = MAC_ARG_END;
-            if (option_flags.v)
-                out_p = stpcpy( out_p, arg_end_inf[ num_arg_magic]);
         }
     }
     *out_p = EOS;
@@ -1747,12 +1447,7 @@ static char *   substitute(
  * the formal parameters in the replacement list.
  */
 {
-    char *  out_start = out;
-    const char *    arg;
     int     c;
-    int     gvar_arg;   /* gvar_arg'th argument is GCC variable argument    */
-
-    gvar_arg = (defp->nargs & GVA_ARGS) ? (defp->nargs & ~AVA_ARGS) : 0;
     *out = EOS;                             /* Ensure to termanate  */
 
     while ((c = *in++) != EOS) {
@@ -1762,45 +1457,6 @@ static char *   substitute(
                 mcpp_fprintf( DBG, " (expanding arg[%d])", c);
                 dump_string( NULL, arglist[ c - 1]);
             }
-#if COMPILER == GNUC || COMPILER == MSC
-            arg = arglist[ c - 1];
-            if (trace_macro) {
-                if (*arg == MAC_INF) {
-                    if (*++arg == MAC_ARG_START)
-                        arg += ARG_S_LEN - 1;       /* Next to magic chars  */
-                }
-            }
-#if COMPILER == GNUC
-            if (c == gvar_arg && *arg == RT_END && ! ansi) {
-                /*
-                 * GCC variadic macro and its variable argument is absent.
-                 * Note that in its "strict-ansi" mode GCC does not remove 
-                 * ',', nevertheless it ignores '##' (inconsistent
-                 * behavior).  Though GCC2 changes behavior depending the
-                 * ',' is preceded by space or not, we only count on the
-                 * "strict-ansi" flag.
-                 */
-#else
-            if ((defp->nargs & VA_ARGS) && c == (defp->nargs & ~VA_ARGS)
-                    && *arg == RT_END && mcpp_mode == STD) {
-                /* Visual C 2005 also removes ',' immediately preceding     */
-                /* absent variable arguments.  It does not use '##' though. */
-#endif
-                char *  tmp;
-                tmp = out - 1;
-                while (char_type[ *tmp & UCHARMAX] & HSP)
-                    tmp--;
-                if (*tmp == ',') {
-                    out = tmp;      /* Remove the immediately preceding ',' */
-                    if (warn_level & 1) {
-                        *out = EOS;
-                        diag_macro( CWARN,
-        "Removed ',' preceding the absent variable argument: %s"    /* _W1_ */
-                                , out_start, 0L, NULL, defp, NULL);
-                    }
-                }
-            } else
-#endif
             if ((out = rescan( NULL, arglist[ c - 1], out, out_end))
                     == NULL) {              /* Replace completely   */
                 return  NULL;               /* Error                */
@@ -1841,10 +1497,6 @@ static char *   rescan(
     int     c;                      /* First character of token     */
     int     token_type;
     char *  mac_arg_start = NULL;
-#if COMPILER == GNUC
-    int     within_defined = FALSE;
-    int     within_defined_arg_depth = 0;
-#endif
 
     if (mcpp_debug & EXPAND) {
         mcpp_fprintf( DBG, "rescan_level--%d (%s) "
@@ -1853,11 +1505,9 @@ static char *   rescan(
     }
     if (! disable_repl( outer)) /* Don't re-replace replacing macro */
         return  NULL;               /* Too deeply nested macro call */
-    if (mcpp_mode == STD) {
-        get_ch();                   /* Clear empty "file"s          */
-        unget_ch();                 /*      for diagnostic          */
-        cur_cp = infile->bptr;      /* Remember current location    */
-    }
+    get_ch();                   /* Clear empty "file"s          */
+    unget_ch();                 /*      for diagnostic          */
+    cur_cp = infile->bptr;      /* Remember current location    */
     file = unget_string( in, outer ? outer->name : NULL);
                                     /* Stack input on a "file"      */
 
@@ -1887,41 +1537,14 @@ static char *   rescan(
                 *out_p++ = get_ch();
                 break;
             case MAC_ARG_END    :
-                if (! option_flags.v)
-                    break;
-                else
-                    *out_p++ = get_ch();
-                    /* Fall through */
+                break;
             case MAC_CALL_END   :
-                if (option_flags.v) {
-                    *out_p++ = get_ch();
-                    *out_p++ = get_ch();
-                }
                 break;
             }               /* Pass these characters as they are    */
             continue;
         }
         token_type = scan_token( c, (tp = out_p, &out_p), out_end);
-#if COMPILER == GNUC
-        if (mcpp_mode == STD) {
-            /* Pass stuff within defined() as they are, if in_directive */
-            if ((within_defined || within_defined_arg_depth)) {
-                if (c == '(') {
-                    within_defined_arg_depth++;
-                    within_defined = FALSE;
-                } else if (within_defined_arg_depth && c == ')') {
-                    within_defined_arg_depth--;
-                }       /* Else should be a name (possibly macro)   */
-                continue;
-            } else if (token_type == NAM && in_directive
-                        && str_eq(identifier, "defined")) {
-                within_defined = TRUE;
-                            /* 'defined' token in directive line    */
-                continue;
-            }
-        } 
-#endif
-        if (mcpp_mode == STD && c == IN_SRC)
+        if (c == IN_SRC)
             len = trace_macro ? IN_SRC_LEN : 1;
         if (token_type == NAM && c != DEF_MAGIC 
                 && (inner = look_id( tp + len)) != NULL) {  /* A macro name */
@@ -1933,11 +1556,9 @@ static char *   rescan(
                 memset( &mgc_seq, 0, sizeof (MAGIC_SEQ));
             if (is_macro_call( inner, &out_p, &endf
                         , trace_macro ? &mgc_seq : NULL)
-                    && ((mcpp_mode == POST_STD && is_able_repl( inner))
-                        || (mcpp_mode == STD
-                            && (((is_able = is_able_repl( inner)) == YES)
+                    && ((((is_able = is_able_repl( inner)) == YES)
                                 || (is_able == READ_OVER 
-                                    && (c == IN_SRC || compat_mode)))))) {
+                                    && (c == IN_SRC || compat_mode))))) {
                                             /* Really a macro call  */
                 LINE_COL    in_src_line_col = { 0L, 0};
                 int     in_src_n = 0;
@@ -1955,8 +1576,7 @@ static char *   rescan(
                         /* name and '('.  This is a nuisance.    */
                         char *      mgc_cleared;
                         size_t      seq_len;
-                        size_t      arg_elen = option_flags.v ? ARG_E_LEN_V
-                                            : ARG_E_LEN;
+                        size_t      arg_elen = ARG_E_LEN;
                         if ((tp - ARG_S_LEN) == mac_arg_start
                                 && *mgc_seq.magic_start == MAC_INF
                                 && *(mgc_seq.magic_start + 1) == MAC_ARG_END) {
@@ -1993,9 +1613,9 @@ static char *   rescan(
                     *out_p = EOS;
                 }
                 if ((is_able = is_able_repl( inner)) == NO
-                        || (mcpp_mode == STD && is_able == READ_OVER
+                        || (is_able == READ_OVER
                                 && c != IN_SRC && ! compat_mode)) {
-                    if (mcpp_mode == POST_STD || c != IN_SRC)
+                    if (c != IN_SRC)
                         memmove( tp + 1, tp, (size_t) (out_p++ - tp));
                     *tp = DEF_MAGIC;        /* Mark not to replace  */
                 }                           /* Else not a macro call*/
@@ -2012,25 +1632,21 @@ static char *   rescan(
 
     if (out_p) {
         *out_p = EOS;
-        if (mcpp_mode == STD) {
             if  (c != RT_END) {
-                unget_ch();
-                if (outer != NULL) {    /* outer isn't a macro in argument  */
-                    if (infile && infile->bptr != cur_cp
-                                    /* Have overrun replacement list*/
-                            && !(tp && *tp == DEF_MAGIC)
-                                                /* Macro is enabled */
-                            && ((!compat_mode && (warn_level & 1))
-                                || (compat_mode && (warn_level & 8)))) {
-                        diag_macro( CWARN,
+            unget_ch();
+            if (outer != NULL) {    /* outer isn't a macro in argument  */
+                if (infile && infile->bptr != cur_cp
+                                /* Have overrun replacement list*/
+                        && !(tp && *tp == DEF_MAGIC)
+                                            /* Macro is enabled */
+                        && ((!compat_mode && (warn_level & 1))
+                            || (compat_mode && (warn_level & 8)))) {
+                    diag_macro( CWARN,
 "Replacement text \"%s\" of macro %.0ld\"%s\" involved subsequent text" /* _W1_ */
-                            , in, 0L, outer->name, outer, inner);
-                    }
+                        , in, 0L, outer->name, outer, inner);
                 }
-            }                       /* Else remove RT_END           */
-        } else {
-            unget_ch();
-        }
+            }
+        }                       /* Else remove RT_END           */
     }
     enable_repl( outer, TRUE);      /* Enable macro for later text  */
     if (mcpp_debug & EXPAND) {
@@ -2119,271 +1735,6 @@ static char *   insert_to_bptr(
     return  infile->buffer;
 }
 
-/*
- *  M a c r o   E x p a n s i o n   i n   P R E - S T A N D A R D   M o d e
- */
-
-#include    "setjmp.h"
-
-static jmp_buf  jump;
-
-static char *   arglist_pre[ NMACPARS];     /* Pointers to args     */
-
-static int      rescan_pre( int c, char * mp, char * mac_end);
-                /* Replace a macro repeatedly   */
-static int      replace_pre( DEFBUF * defp);
-                /* Replace a macro once         */
-static void     substitute_pre( DEFBUF * defp);
-                /* Substitute parms with args   */
-
-static char *   expand_prestd(
-    DEFBUF *    defp,                       /* Macro definition     */
-    char *  out,                            /* Output buffer        */
-    char *  out_end,                        /* End of output buffer */
-    LINE_COL    line_col,       /* Location of macro (not used in prestd)   */
-    int *   pragma_op           /* Flag of _Pragma (not used in prestd)     */
-)
-/*
- * Expand a macro call completely, write the results to the specified buffer
- * and return the advanced pointer.
- */
-{
-    char    macrobuf[ NMACWORK + IDMAX];    /* Buffer for rescan_pre()      */
-    char *  mac_end = &macrobuf[ NMACWORK]; /* End of macrobuf[]    */
-    char *  out_p;                          /* Pointer into out[]   */
-    char *  mp = macrobuf;                  /* Pointer into macrobuf*/
-    int     len;                            /* Length of a token    */
-    int     token_type;                     /* Type of token        */
-    int     c;
-
-    macro_line = src_line;                  /* Line number for diag.*/
-    unget_string( identifier, identifier);  /* To re-read           */
-    macro_name = defp->name;
-    rescan_level = 0;
-    if (setjmp( jump) == 1) {
-        skip_macro();
-        mp = macrobuf;
-        *mp = EOS;
-        macro_line = MACRO_ERROR;
-        goto  err_end;
-    }
-
-    while ((c = get_ch()) != CHAR_EOF && infile->fp == NULL) {
-                            /* While the input stream is a macro    */
-        while (c == ' ' || c == '\t') {     /* Output the spaces    */
-            *mp++ = c;
-            c = get_ch();
-            if (infile == NULL || infile->fp != NULL)
-                goto  exp_end;
-        }
-        token_type = rescan_pre( c, mp, mac_end);   /* Scan token   */
-            /*  and expand.  Result of expansion is written at mp.  */
-
-        switch (token_type) {
-        case STR:                           /* String literal       */
-        case CHR:                           /* Character constant   */
-        case NUM:                           /* Number token         */
-        case OPE:                           /* Operator or punct.   */
-        case NAM:                           /* Identifier           */
-            len = strlen( mp);
-            mp += len;
-            break;
-        case SEP:                           /* Special character    */
-            switch( *mp) {
-            case COM_SEP:
-                if (mcpp_mode == OLD_PREP)
-                    break;  /* Zero-length comment is removed now   */
-                /* Else fall through    */
-            default:                        /* Who knows ?          */
-                mp++;                       /* Copy the character   */
-                break;
-            }
-            break;
-        case NO_TOKEN:  break;              /* End of file          */
-        default:                            /* Unkown token char.   */
-            mp++;                           /* Copy the character   */
-            break;
-        }
-
-        if (mac_end <= mp) {
-            *mp = EOS;
-            cerror( macbuf_overflow, macro_name, 0L, macrobuf);
-            longjmp( jump, 1);
-        }
-        if (mcpp_debug & GETC) {
-            *mp = EOS;
-            dump_string( "macrobuf", macrobuf);
-        }
-    }
-
-exp_end:
-    unget_ch();
-    while (macrobuf < mp && (*(mp - 1) == ' ' || *(mp - 1) == '\t'))
-        mp--;                           /* Remove trailing blank    */
-    macro_line = 0;
-    *mp = EOS;
-    if (mp - macrobuf > out_end - out) {
-        cerror( macbuf_overflow, macro_name, 0L, macrobuf);
-        macro_line = MACRO_ERROR;
-    }
-err_end:
-    out_p = stpcpy( out, macrobuf);
-    if (mcpp_debug & EXPAND) {
-        dump_string( "expand_prestd exit", out);
-    }
-    macro_name = NULL;
-    clear_exp_mac();
-    *pragma_op = FALSE;
-    return  out_p;
-}
-
-static int  rescan_pre(
-    int     c,                      /* First character of token     */
-    char *  mp,                     /* Output buffer                */
-    char *  mac_end                 /* End of output buffer         */
-)
-/*
- * If the token is a macro name, replace the macro repeatedly until the first
- * token becomes a non-macro and return the type of token after expansion.
- */
-{
-    int     token_type;             /* Type of token                */
-    char *  cp = mp;        /* Value of mp should not be changed    */
-    DEFBUF *    defp;
-    FILEINFO *  file;
-
-    while ((token_type = scan_token( c, &cp, mac_end)) == NAM
-            && (defp = look_id( identifier)) != NULL) { /* Macro    */
-        if (replace_pre( defp) == FALSE)
-            break;                  /* Macro name with no argument  */
-        file = infile;
-        c = get_ch();
-        if (file != infile) {       /* Replaced to 0 token          */
-            unget_ch();
-            token_type = NO_TOKEN;
-            break;
-        }
-        cp = mp;                    /* Overwrite on the macro call  */
-    }                               /* The macro call is replaced   */
-    return  token_type;
-}
-
-static int  replace_pre(
-    DEFBUF *    defp                /* Definition of the macro      */
-)
-/*
- * Replace a macro one level.  Called from expand_prestd() (via rescan_pre())
- * when an identifier is found in the macro table.  It calls collect_args()
- * to parse actual arguments, checking for the correct number.  It then
- * creates a "file" containing single line containing the replacement text
- * with the actual arguments inserted appropriately.  This is "pushed back"
- * onto the input stream.  (When get_ch() routine runs off the end of the macro
- * line, it will dismiss the macro itself.)
- */
-{
-    int         arg_len;
-    int         c;
-
-    if (mcpp_debug & EXPAND) {
-        dump_a_def( "replace_pre entry", defp, FALSE, TRUE, fp_debug);
-        dump_unget( "replace_pre entry");
-    }
-    if (++rescan_level >= PRESTD_RESCAN_LIMIT) {
-        diag_macro( CERROR
-                , "Recursive macro definition of \"%s\""    /* _E_  */
-                , defp->name, 0L, NULL, defp, NULL);
-        longjmp( jump, 1);
-    }
-
-    /*
-     * Here's a macro to replace.
-     */
-    switch (defp->nargs) {
-    case DEF_NOARGS:                /* No argument just stuffs      */
-    case DEF_NOARGS_PREDEF_OLD:     /* Compiler-specific predef without '_' */
-    case DEF_NOARGS_PREDEF:         /* Compiler-specific predef     */
-        break;
-    default:                                /* defp->nargs >= 0     */
-        c = squeeze_ws( NULL, NULL, NULL);  /* Look for and skip '('*/
-        if (c != '(') {         /* Macro name without following '(' */
-            unget_ch();
-            if (warn_level & 8)
-                diag_macro( CWARN, only_name, defp->name, 0L, NULL, defp, NULL);
-            return  FALSE;
-        } else {
-            arglist_pre[ 0] = xmalloc( (size_t) (NMACWORK + IDMAX * 2));
-            arg_len = collect_args( defp, arglist_pre, 0);
-                                            /* Collect arguments    */
-            if (arg_len == ARG_ERROR) {     /* End of input         */
-                free( arglist_pre[ 0]);
-                longjmp( jump, 1);
-            }
-        }
-        break;
-    }
-
-    if (defp->nargs > 0)
-        substitute_pre( defp);              /* Do actual arguments  */
-    else
-        unget_string( defp->repl, defp->name);
-
-    if (mcpp_debug & EXPAND)
-        dump_unget( "replace_pre exit");
-    if (defp->nargs >= 0)
-        free( arglist_pre[ 0]);
-    return  TRUE;
-}
-
-static void substitute_pre(
-    DEFBUF *        defp            /* Current macro being replaced */
-)
-/*
- * Stuff the macro body, substituting formal parameters with actual arguments.
- */
-{
-    int         c;                          /* Current character    */
-    FILEINFO *  file;                       /* Funny #include       */
-    char *      out_end;                    /* -> output buffer end */
-    char *      in_p;                       /* -> replacement text  */
-    char *      out_p;                      /* -> macro output buff */
-
-    file = get_file( defp->name, NULL, NULL, (size_t) (NMACWORK + 1), FALSE);
-                                            /* file == infile       */
-    in_p = defp->repl;                      /* -> macro replacement */
-    out_p = file->buffer;                   /* -> output buffer     */
-    out_end = file->buffer + NMACWORK;      /* -> buffer end        */
-
-    while ((c = *in_p++) != EOS) {
-        if (c == MAC_PARM) {
-            c = (*in_p++ & UCHARMAX) - 1;   /* Parm number          */
-            /*
-             * Substitute formal parameter with actual argument.
-             */
-            if (out_end <= (out_p + strlen( arglist_pre[ c])))
-                goto nospace;
-            out_p = stpcpy( out_p, arglist_pre[ c]);
-        } else {
-            *out_p++ = c;
-        }
-        if (out_end <= out_p)
-            goto  nospace;
-    }
-
-    *out_p = EOS;
-    file->buffer = xrealloc( file->buffer, strlen( file->buffer) + 1);
-    file->bptr = file->buffer;              /* Truncate buffer      */
-    if (mcpp_debug & EXPAND)
-        dump_string( "substitute_pre macroline", file->buffer);
-    return;
-
-nospace:
-    *out_p = EOS;
-    diag_macro( CERROR, macbuf_overflow, defp->name, 0L, file->buffer, defp
-            , NULL);
-    longjmp( jump, 1);
-}
-
-
 /*
  *                  C O M M O N   R O U T I N E S
  *  f o r   S T A N D A R D   a n d   p r e - S T A N D A R D   M o d e s
@@ -2436,19 +1787,17 @@ static int  collect_args(
     seq_end = seq + NMACWORK/2;
     seq = stpcpy( seq, name);
     *seq++ = '(';
-    if (mcpp_mode == STD) {
-        /*
-         * in_getarg is set TRUE while getting macro arguments, for the sake
-         * of diagnostic's convenience.  in_getarg is used only in STD mode.
-         */
-        in_getarg = TRUE;
-        if (trace_macro && m_num) {
-            /* #pragma MCPP debug macro_call, and the macro is on source    */
-            mac_inf[ m_num].loc_args = loc = locs
-                    = (LOCATION *) xmalloc( (sizeof (LOCATION)) * UCHARMAX);
-            memset( loc, 0, (sizeof (LOCATION)) * UCHARMAX);
-                    /* 0-clear for default values, including empty argument */
-        }
+    /*
+     * in_getarg is set TRUE while getting macro arguments, for the sake
+     * of diagnostic's convenience.  in_getarg is used only in STD mode.
+     */
+    in_getarg = TRUE;
+    if (trace_macro && m_num) {
+        /* #pragma MCPP debug macro_call, and the macro is on source    */
+        mac_inf[ m_num].loc_args = loc = locs
+                = (LOCATION *) xmalloc( (sizeof (LOCATION)) * UCHARMAX);
+        memset( loc, 0, (sizeof (LOCATION)) * UCHARMAX);
+                /* 0-clear for default values, including empty argument */
     }
 
     while (1) {
@@ -2474,13 +1823,12 @@ static int  collect_args(
                 loc++;                  /* Advance pointer to infs  */
             if (warn_level & 2)
                 diag_macro( CWARN, empty_arg, sequence, 0L, NULL, defp, NULL);
-            if (standard && var_arg && nargs == args - 1) {
+            if (var_arg && nargs == args - 1) {
                 /* Variable arguments begin with an empty argument  */
                 c = get_an_arg( c, &argp, arg_end, &seq, 1, nargs, &loc
                         , m_num, (trace_macro && m_num) ? &mgc_prefix : NULL);
             } else {
-                if (mcpp_mode == STD)
-                    *argp++ = RT_END;
+                *argp++ = RT_END;
                 *argp++ = EOS;
             }
             if (++nargs == args)
@@ -2530,25 +1878,22 @@ static int  collect_args(
         if (warn_level & 2)
             diag_macro( CWARN, empty_arg, sequence, 0L, NULL, defp, NULL);
     } else if (nargs != args) {         /* Wrong number of arguments*/
-        if (mcpp_mode != OLD_PREP || (warn_level & 1)) {
-            if ((standard && var_arg && (nargs == args - 1))
-                                /* Absence of variable arguments    */
-                        || (mcpp_mode == OLD_PREP)) {
-                if (warn_level & 1)
-                    diag_macro( CWARN, narg_error, nargs < args ? "Less"
-                            : "More", (long) args, sequence, defp, NULL);
-            } else {
-                diag_macro( CERROR, narg_error, nargs < args ? "Less" : "More"
-                        , (long) args, sequence, defp, NULL);
-            }
+        if ((var_arg && (nargs == args - 1))
+                            /* Absence of variable arguments    */
+                    ) {
+            if (warn_level & 1)
+                diag_macro( CWARN, narg_error, nargs < args ? "Less"
+                        : "More", (long) args, sequence, defp, NULL);
+        } else {
+            diag_macro( CERROR, narg_error, nargs < args ? "Less" : "More"
+                    , (long) args, sequence, defp, NULL);
         }
     }
     if (args < nargs) {
         argp = valid_argp;              /* Truncate excess arguments*/
     } else {
         for (c = nargs; c < args; c++) {
-            if (mcpp_mode == STD)
-                *argp++ = RT_END;       /* For rescan()             */
+            *argp++ = RT_END;       /* For rescan()             */
             *argp++ = EOS;              /* Missing arguments        */
         }
         if (c == 0)
@@ -2573,8 +1918,7 @@ static int  collect_args(
         dump_unget( "collect_args exit");
     }
 arg_ret:
-    if (mcpp_mode == STD)
-        in_getarg = FALSE;
+    in_getarg = FALSE;
     /* Return number of found arguments for function-like macro at most */
     /* defp->nargs, or return defp->nargs for object-like macro.        */
     return  defp->nargs <= DEF_NOARGS ? defp->nargs : nargs;
@@ -2689,23 +2033,15 @@ static int  get_an_arg(
                 *argp++ = get_ch();
                 break;
             case MAC_ARG_END    :
-                if (! option_flags.v)
-                    break;
-                else
-                    *argp++ = get_ch();
-                    /* Fall through */
+                break;
             case MAC_CALL_END   :
-                if (option_flags.v) {
-                    *argp++ = get_ch();
-                    *argp++ = get_ch();
-                }
                 break;
             }
             break;
         case CHAR_EOF   :                   /* Unexpected EOF       */
             return  0;
         default :                           /* Any token            */
-            if (mcpp_mode == STD && token_type == NAM
+            if (token_type == NAM
                     && c != IN_SRC && c != DEF_MAGIC && infile->fp) {
                 len = trace_arg ? IN_SRC_LEN : 1;
                 memmove( prevp + len, prevp, (size_t) (argp - prevp));
@@ -2771,28 +2107,18 @@ static int  get_an_arg(
     argp--;                                 /* Remove the punctuator*/
     if (mgc_seq.space)
         --argp;                     /* Remove trailing space        */
-    if (mcpp_mode == STD) {
-        if (trace_macro && m_num) {
-            if (trace_arg) {        /* Location of end of an arg    */
-                get_src_location( & e_line_col);
-                (*locp)->end_line = e_line_col.line;
-                (*locp)->end_col = e_line_col.col;
-            }
-            (*locp)++;      /* Advance pointer even if !trace_arg   */
-            *argp++ = MAC_INF;
-            *argp++ = MAC_ARG_END;
-            if (option_flags.v) {
-                *argp++ = (m_num / UCHARMAX) + 1;
-                *argp++ = (m_num % UCHARMAX) + 1;
-                *argp++ = nargs + 1;
-                *argp = EOS;
-                *argpp = chk_magic_balance( *argpp, argp, TRUE, FALSE);
-                    /* Check a stray magic caused by abnormal macro */
-                    /* and move it to an edge if found.             */
-            }
+
+    if (trace_macro && m_num) {
+        if (trace_arg) {        /* Location of end of an arg    */
+            get_src_location( & e_line_col);
+            (*locp)->end_line = e_line_col.line;
+            (*locp)->end_col = e_line_col.col;
         }
-        *argp++ = RT_END;                   /* For rescan()         */
+        (*locp)++;      /* Advance pointer even if !trace_arg   */
+        *argp++ = MAC_INF;
+        *argp++ = MAC_ARG_END;
     }
+    *argp++ = RT_END;                   /* For rescan()         */
     *argp++ = EOS;                          /* Terminate an argument*/
     *argpp = argp;
     return  c;
@@ -2822,13 +2148,9 @@ static int  squeeze_ws(
     int     space = 0;
     int     tsep = 0;
     FILEINFO *      file = infile;
-    FILE *  fp = infile->fp;
     int     end_of_file = (out && endf) ? FALSE : TRUE;
 
-    while (((char_type[ c = get_ch()] & SPA) && (! standard 
-                || (mcpp_mode == POST_STD && file == infile)
-                || (mcpp_mode == STD
-                    && ((macro_line != 0 && macro_line != MACRO_ERROR)
+    while (((char_type[ c = get_ch()] & SPA) && ((((macro_line != 0 && macro_line != MACRO_ERROR)
                         || file == infile))))
             || c == MAC_INF) {
         if (! end_of_file && file != infile) {  /* Infile has been read over*/
@@ -2843,8 +2165,7 @@ static int  squeeze_ws(
             wrong_line = TRUE;
             break;
         case TOK_SEP:
-            if (mcpp_mode == STD)
-                tsep++;
+            tsep++;
             continue;           /* Skip COM_SEP in OLD_PREP mode    */
         case MAC_INF    :       /* Copy magics as they are, or skip */
             if (mgc_seq && ! mgc_seq->magic_start)
@@ -2870,23 +2191,8 @@ static int  squeeze_ws(
                     *(*out)++ = c;
                 break;
             case MAC_ARG_END    :
-                if (! option_flags.v) {
-                    break;
-                } else {
-                    c = get_ch();
-                    if (out)
-                        *(*out)++ = c;
-                    /* Fall through */
-                }
+                break;
             case MAC_CALL_END   :
-                if (option_flags.v) {
-                    c = get_ch();
-                    if (out)
-                        *(*out)++ = c;
-                    c = get_ch();
-                    if (out)
-                        *(*out)++ = c;
-                }
                 break;
             }
             if (mgc_seq)        /* Remember end of last magic seq   */
@@ -2908,10 +2214,7 @@ static int  squeeze_ws(
             *(*out)++ = TOK_SEP;
         **out = EOS;
     }
-    if (mcpp_mode == POST_STD && file != infile) {
-        unget_ch();             /* Arguments cannot cross "file"s   */
-        c = fp ? CHAR_EOF : RT_END; /* EOF is diagnosed by at_eof() */
-    } else if (mcpp_mode == STD && macro_line == MACRO_ERROR
+    if (macro_line == MACRO_ERROR
             && file != infile) {            /* EOF                  */
         unget_ch();             /*   diagnosed by at_eof() or only  */
         c = CHAR_EOF;           /*   name of a function-like macro. */