[binutils] Bump binutils to 2.20.1

binutils/ld/ldlex.c

 
-#line 3 "ldlex.c"
+#line 3 "/Users/gingold/Repositories/fsf/binutils-2_20/ld/ldlex.c"
 
 #define  YY_INT_ALIGNED short int
 
 /* A lexical scanner generated by flex */
 
 #define FLEX_SCANNER
 #define YY_FLEX_MAJOR_VERSION 2
 #define YY_FLEX_MINOR_VERSION 5
 #define YY_FLEX_SUBMINOR_VERSION 35
 #if YY_FLEX_SUBMINOR_VERSION > 0
@@ skipping 1562 matching lines @@
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
    MA 02110-1301, USA.  */
 
-#include "sysdep.h"
 #include "bfd.h"
 #include "safe-ctype.h"
 #include "bfdlink.h"
 #include "ld.h"
 #include "ldmisc.h"
 #include "ldexp.h"
 #include "ldlang.h"
 #include <ldgram.h>
 #include "ldfile.h"
 #include "ldlex.h"
@@ skipping 53 matching lines @@
 int yywrap (void) { return 1; }
 #endif
 
 
 
 
 
 
 
 
-#line 1660 "ldlex.c"
+#line 1659 "/Users/gingold/Repositories/fsf/binutils-2_20/ld/ldlex.c"
 
 #define INITIAL 0
 #define SCRIPT 1
 #define EXPRESSION 2
 #define BOTH 3
 #define DEFSYMEXP 4
 #define MRI 5
 #define VERS_START 6
 #define VERS_SCRIPT 7
 #define VERS_NODE 8
@@ skipping 169 matching lines @@
         YY_USER_ACTION
 
 /** The main scanner function which does all the work.
  */
 YY_DECL
 {
         register yy_state_type yy_current_state;
         register char *yy_cp, *yy_bp;
         register int yy_act;
     
-#line 117 "ldlex.l"
+#line 116 "ldlex.l"
 
 
   if (parser_input != input_selected)
     {
       /* The first token of the input determines the initial parser state.  */
       input_type t = parser_input;
       parser_input = input_selected;
       switch (t)
         {
         case input_script: return INPUT_SCRIPT; break;
         case input_mri_script: return INPUT_MRI_SCRIPT; break;
         case input_version_script: return INPUT_VERSION_SCRIPT; break;
         case input_dynamic_list: return INPUT_DYNAMIC_LIST; break;
         case input_defsym: return INPUT_DEFSYM; break;
         default: abort ();
         }
     }
 
-#line 1869 "ldlex.c"
+#line 1868 "/Users/gingold/Repositories/fsf/binutils-2_20/ld/ldlex.c"
 
         if ( !(yy_init) )
                 {
                 (yy_init) = 1;
 
 #ifdef YY_USER_INIT
                 YY_USER_INIT;
 #endif
 
                 if ( ! (yy_start) )
@@ skipping 64 matching lines @@
         { /* beginning of action switch */
                         case 0: /* must back up */
                         /* undo the effects of YY_DO_BEFORE_ACTION */
                         *yy_cp = (yy_hold_char);
                         yy_cp = (yy_last_accepting_cpos);
                         yy_current_state = (yy_last_accepting_state);
                         goto yy_find_action;
 
 case 1:
 YY_RULE_SETUP
-#line 135 "ldlex.l"
+#line 134 "ldlex.l"
 { comment (); }
         YY_BREAK
 case 2:
 YY_RULE_SETUP
-#line 138 "ldlex.l"
+#line 137 "ldlex.l"
 { RTOKEN('-');}
         YY_BREAK
 case 3:
 YY_RULE_SETUP
-#line 139 "ldlex.l"
+#line 138 "ldlex.l"
 { RTOKEN('+');}
         YY_BREAK
 case 4:
 YY_RULE_SETUP
-#line 140 "ldlex.l"
+#line 139 "ldlex.l"
 { yylval.name = xstrdup (yytext); return NAME; }
         YY_BREAK
 case 5:
 YY_RULE_SETUP
-#line 141 "ldlex.l"
+#line 140 "ldlex.l"
 { RTOKEN('='); }
         YY_BREAK
 case 6:
 YY_RULE_SETUP
-#line 143 "ldlex.l"
+#line 142 "ldlex.l"
 {
                                 yylval.integer = bfd_scan_vma (yytext + 1, 0, 16);
                                 yylval.bigint.str = NULL;
                                 return INT;
                         }
         YY_BREAK
 case 7:
 YY_RULE_SETUP
-#line 149 "ldlex.l"
+#line 148 "ldlex.l"
 {
                                    int ibase ;
                                    switch (yytext[yyleng - 1]) {
                                     case 'X':
                                     case 'x':
                                     case 'H':
                                     case 'h':
                                      ibase = 16;
                                      break;
                                     case 'O':
                                     case 'o':
                                      ibase = 8;
                                      break;
                                     case 'B':
                                     case 'b':
                                      ibase = 2;
                                      break;
                                     default:
                                      ibase = 10;
                                    }
                                    yylval.integer = bfd_scan_vma (yytext, 0,
                                                                   ibase);
                                    yylval.bigint.str = NULL;
                                    return INT;
                                  }
         YY_BREAK
 case 8:
 YY_RULE_SETUP
-#line 174 "ldlex.l"
+#line 173 "ldlex.l"
 {
                                   char *s = yytext;
                                   int ibase = 0;
 
                                   if (*s == '$')
                                     {
                                       ++s;
                                       ibase = 16;
                                     }
                                   yylval.integer = bfd_scan_vma (s, 0, ibase);
@@ skipping 12 matching lines @@
                                            && (yytext[1] == 'x'
                                                || yytext[1] == 'X'))
                                     {
                                       yylval.bigint.str = xstrdup (yytext + 2);
                                     }
                                   return INT;
                                 }
         YY_BREAK
 case 9:
 YY_RULE_SETUP
+#line 202 "ldlex.l"
+{ RTOKEN(']');}
+        YY_BREAK
+case 10:
+YY_RULE_SETUP
 #line 203 "ldlex.l"
-{ RTOKEN(']');}
-        YY_BREAK
-case 10:
+{ RTOKEN('[');}
+        YY_BREAK
+case 11:
 YY_RULE_SETUP
 #line 204 "ldlex.l"
-{ RTOKEN('[');}
-        YY_BREAK
-case 11:
+{ RTOKEN(LSHIFTEQ);}
+        YY_BREAK
+case 12:
 YY_RULE_SETUP
 #line 205 "ldlex.l"
-{ RTOKEN(LSHIFTEQ);}
-        YY_BREAK
-case 12:
+{ RTOKEN(RSHIFTEQ);}
+        YY_BREAK
+case 13:
 YY_RULE_SETUP
 #line 206 "ldlex.l"
-{ RTOKEN(RSHIFTEQ);}
-        YY_BREAK
-case 13:
+{ RTOKEN(OROR);}
+        YY_BREAK
+case 14:
 YY_RULE_SETUP
 #line 207 "ldlex.l"
-{ RTOKEN(OROR);}
-        YY_BREAK
-case 14:
+{ RTOKEN(EQ);}
+        YY_BREAK
+case 15:
 YY_RULE_SETUP
 #line 208 "ldlex.l"
-{ RTOKEN(EQ);}
-        YY_BREAK
-case 15:
+{ RTOKEN(NE);}
+        YY_BREAK
+case 16:
 YY_RULE_SETUP
 #line 209 "ldlex.l"
-{ RTOKEN(NE);}
-        YY_BREAK
-case 16:
+{ RTOKEN(GE);}
+        YY_BREAK
+case 17:
 YY_RULE_SETUP
 #line 210 "ldlex.l"
-{ RTOKEN(GE);}
-        YY_BREAK
-case 17:
+{ RTOKEN(LE);}
+        YY_BREAK
+case 18:
 YY_RULE_SETUP
 #line 211 "ldlex.l"
-{ RTOKEN(LE);}
-        YY_BREAK
-case 18:
+{ RTOKEN(LSHIFT);}
+        YY_BREAK
+case 19:
 YY_RULE_SETUP
 #line 212 "ldlex.l"
-{ RTOKEN(LSHIFT);}
-        YY_BREAK
-case 19:
+{ RTOKEN(RSHIFT);}
+        YY_BREAK
+case 20:
 YY_RULE_SETUP
 #line 213 "ldlex.l"
-{ RTOKEN(RSHIFT);}
-        YY_BREAK
-case 20:
+{ RTOKEN(PLUSEQ);}
+        YY_BREAK
+case 21:
 YY_RULE_SETUP
 #line 214 "ldlex.l"
-{ RTOKEN(PLUSEQ);}
-        YY_BREAK
-case 21:
+{ RTOKEN(MINUSEQ);}
+        YY_BREAK
+case 22:
 YY_RULE_SETUP
 #line 215 "ldlex.l"
-{ RTOKEN(MINUSEQ);}
-        YY_BREAK
-case 22:
+{ RTOKEN(MULTEQ);}
+        YY_BREAK
+case 23:
 YY_RULE_SETUP
 #line 216 "ldlex.l"
-{ RTOKEN(MULTEQ);}
-        YY_BREAK
-case 23:
+{ RTOKEN(DIVEQ);}
+        YY_BREAK
+case 24:
 YY_RULE_SETUP
 #line 217 "ldlex.l"
-{ RTOKEN(DIVEQ);}
-        YY_BREAK
-case 24:
+{ RTOKEN(ANDEQ);}
+        YY_BREAK
+case 25:
 YY_RULE_SETUP
 #line 218 "ldlex.l"
-{ RTOKEN(ANDEQ);}
-        YY_BREAK
-case 25:
+{ RTOKEN(OREQ);}
+        YY_BREAK
+case 26:
 YY_RULE_SETUP
 #line 219 "ldlex.l"
-{ RTOKEN(OREQ);}
-        YY_BREAK
-case 26:
+{ RTOKEN(ANDAND);}
+        YY_BREAK
+case 27:
 YY_RULE_SETUP
 #line 220 "ldlex.l"
-{ RTOKEN(ANDAND);}
-        YY_BREAK
-case 27:
+{ RTOKEN('>');}
+        YY_BREAK
+case 28:
 YY_RULE_SETUP
 #line 221 "ldlex.l"
-{ RTOKEN('>');}
-        YY_BREAK
-case 28:
+{ RTOKEN(',');}
+        YY_BREAK
+case 29:
 YY_RULE_SETUP
 #line 222 "ldlex.l"
-{ RTOKEN(',');}
-        YY_BREAK
-case 29:
+{ RTOKEN('&');}
+        YY_BREAK
+case 30:
 YY_RULE_SETUP
 #line 223 "ldlex.l"
-{ RTOKEN('&');}
-        YY_BREAK
-case 30:
+{ RTOKEN('|');}
+        YY_BREAK
+case 31:
 YY_RULE_SETUP
 #line 224 "ldlex.l"
-{ RTOKEN('|');}
-        YY_BREAK
-case 31:
+{ RTOKEN('~');}
+        YY_BREAK
+case 32:
 YY_RULE_SETUP
 #line 225 "ldlex.l"
-{ RTOKEN('~');}
-        YY_BREAK
-case 32:
+{ RTOKEN('!');}
+        YY_BREAK
+case 33:
 YY_RULE_SETUP
 #line 226 "ldlex.l"
-{ RTOKEN('!');}
-        YY_BREAK
-case 33:
+{ RTOKEN('?');}
+        YY_BREAK
+case 34:
 YY_RULE_SETUP
 #line 227 "ldlex.l"
-{ RTOKEN('?');}
-        YY_BREAK
-case 34:
+{ RTOKEN('*');}
+        YY_BREAK
+case 35:
 YY_RULE_SETUP
 #line 228 "ldlex.l"
-{ RTOKEN('*');}
-        YY_BREAK
-case 35:
+{ RTOKEN('+');}
+        YY_BREAK
+case 36:
 YY_RULE_SETUP
 #line 229 "ldlex.l"
-{ RTOKEN('+');}
-        YY_BREAK
-case 36:
+{ RTOKEN('-');}
+        YY_BREAK
+case 37:
 YY_RULE_SETUP
 #line 230 "ldlex.l"
-{ RTOKEN('-');}
-        YY_BREAK
-case 37:
+{ RTOKEN('/');}
+        YY_BREAK
+case 38:
 YY_RULE_SETUP
 #line 231 "ldlex.l"
-{ RTOKEN('/');}
-        YY_BREAK
-case 38:
+{ RTOKEN('%');}
+        YY_BREAK
+case 39:
 YY_RULE_SETUP
 #line 232 "ldlex.l"
-{ RTOKEN('%');}
-        YY_BREAK
-case 39:
+{ RTOKEN('<');}
+        YY_BREAK
+case 40:
 YY_RULE_SETUP
 #line 233 "ldlex.l"
-{ RTOKEN('<');}
-        YY_BREAK
-case 40:
+{ RTOKEN('=');}
+        YY_BREAK
+case 41:
 YY_RULE_SETUP
 #line 234 "ldlex.l"
-{ RTOKEN('=');}
-        YY_BREAK
-case 41:
+{ RTOKEN('}') ; }
+        YY_BREAK
+case 42:
 YY_RULE_SETUP
 #line 235 "ldlex.l"
-{ RTOKEN('}') ; }
-        YY_BREAK
-case 42:
+{ RTOKEN('{'); }
+        YY_BREAK
+case 43:
 YY_RULE_SETUP
 #line 236 "ldlex.l"
-{ RTOKEN('{'); }
-        YY_BREAK
-case 43:
+{ RTOKEN(')');}
+        YY_BREAK
+case 44:
 YY_RULE_SETUP
 #line 237 "ldlex.l"
-{ RTOKEN(')');}
-        YY_BREAK
-case 44:
+{ RTOKEN('(');}
+        YY_BREAK
+case 45:
 YY_RULE_SETUP
 #line 238 "ldlex.l"
-{ RTOKEN('(');}
-        YY_BREAK
-case 45:
+{ RTOKEN(':'); }
+        YY_BREAK
+case 46:
 YY_RULE_SETUP
 #line 239 "ldlex.l"
-{ RTOKEN(':'); }
-        YY_BREAK
-case 46:
+{ RTOKEN(';');}
+        YY_BREAK
+case 47:
 YY_RULE_SETUP
 #line 240 "ldlex.l"
-{ RTOKEN(';');}
-        YY_BREAK
-case 47:
+{ RTOKEN(MEMORY);}
+        YY_BREAK
+case 48:
 YY_RULE_SETUP
 #line 241 "ldlex.l"
-{ RTOKEN(MEMORY);}
-        YY_BREAK
-case 48:
+{ RTOKEN(REGION_ALIAS);}
+        YY_BREAK
+case 49:
 YY_RULE_SETUP
 #line 242 "ldlex.l"
-{ RTOKEN(REGION_ALIAS);}
-        YY_BREAK
-case 49:
+{ RTOKEN(ORIGIN);}
+        YY_BREAK
+case 50:
 YY_RULE_SETUP
 #line 243 "ldlex.l"
-{ RTOKEN(ORIGIN);}
-        YY_BREAK
-case 50:
+{ RTOKEN(VERSIONK);}
+        YY_BREAK
+case 51:
 YY_RULE_SETUP
 #line 244 "ldlex.l"
-{ RTOKEN(VERSIONK);}
-        YY_BREAK
-case 51:
+{ RTOKEN(BLOCK);}
+        YY_BREAK
+case 52:
 YY_RULE_SETUP
 #line 245 "ldlex.l"
-{ RTOKEN(BLOCK);}
-        YY_BREAK
-case 52:
+{ RTOKEN(BIND);}
+        YY_BREAK
+case 53:
 YY_RULE_SETUP
 #line 246 "ldlex.l"
-{ RTOKEN(BIND);}
-        YY_BREAK
-case 53:
+{ RTOKEN(LENGTH);}
+        YY_BREAK
+case 54:
 YY_RULE_SETUP
 #line 247 "ldlex.l"
-{ RTOKEN(LENGTH);}
-        YY_BREAK
-case 54:
+{ RTOKEN(ALIGN_K);}
+        YY_BREAK
+case 55:
 YY_RULE_SETUP
 #line 248 "ldlex.l"
-{ RTOKEN(ALIGN_K);}
-        YY_BREAK
-case 55:
+{ RTOKEN(DATA_SEGMENT_ALIGN);}
+        YY_BREAK
+case 56:
 YY_RULE_SETUP
 #line 249 "ldlex.l"
-{ RTOKEN(DATA_SEGMENT_ALIGN);}
-        YY_BREAK
-case 56:
+{ RTOKEN(DATA_SEGMENT_RELRO_END);}
+        YY_BREAK
+case 57:
 YY_RULE_SETUP
 #line 250 "ldlex.l"
-{ RTOKEN(DATA_SEGMENT_RELRO_END);}
-        YY_BREAK
-case 57:
+{ RTOKEN(DATA_SEGMENT_END);}
+        YY_BREAK
+case 58:
 YY_RULE_SETUP
 #line 251 "ldlex.l"
-{ RTOKEN(DATA_SEGMENT_END);}
-        YY_BREAK
-case 58:
+{ RTOKEN(ADDR);}
+        YY_BREAK
+case 59:
 YY_RULE_SETUP
 #line 252 "ldlex.l"
-{ RTOKEN(ADDR);}
-        YY_BREAK
-case 59:
+{ RTOKEN(LOADADDR);}
+        YY_BREAK
+case 60:
 YY_RULE_SETUP
 #line 253 "ldlex.l"
-{ RTOKEN(LOADADDR);}
-        YY_BREAK
-case 60:
+{ RTOKEN(ALIGNOF); }
+        YY_BREAK
+case 61:
 YY_RULE_SETUP
 #line 254 "ldlex.l"
-{ RTOKEN(ALIGNOF); }
-        YY_BREAK
-case 61:
+{ RTOKEN(MAX_K); }
+        YY_BREAK
+case 62:
 YY_RULE_SETUP
 #line 255 "ldlex.l"
-{ RTOKEN(MAX_K); }
-        YY_BREAK
-case 62:
+{ RTOKEN(MIN_K); }
+        YY_BREAK
+case 63:
 YY_RULE_SETUP
 #line 256 "ldlex.l"
-{ RTOKEN(MIN_K); }
-        YY_BREAK
-case 63:
+{ RTOKEN(ASSERT_K); }
+        YY_BREAK
+case 64:
 YY_RULE_SETUP
 #line 257 "ldlex.l"
-{ RTOKEN(ASSERT_K); }
-        YY_BREAK
-case 64:
+{ RTOKEN(ENTRY);}
+        YY_BREAK
+case 65:
 YY_RULE_SETUP
 #line 258 "ldlex.l"
-{ RTOKEN(ENTRY);}
-        YY_BREAK
-case 65:
+{ RTOKEN(EXTERN);}
+        YY_BREAK
+case 66:
 YY_RULE_SETUP
 #line 259 "ldlex.l"
-{ RTOKEN(EXTERN);}
-        YY_BREAK
-case 66:
+{ RTOKEN(NEXT);}
+        YY_BREAK
+case 67:
 YY_RULE_SETUP
 #line 260 "ldlex.l"
-{ RTOKEN(NEXT);}
-        YY_BREAK
-case 67:
+{ RTOKEN(SIZEOF_HEADERS);}
+        YY_BREAK
+case 68:
 YY_RULE_SETUP
 #line 261 "ldlex.l"
 { RTOKEN(SIZEOF_HEADERS);}
         YY_BREAK
-case 68:
+case 69:
 YY_RULE_SETUP
 #line 262 "ldlex.l"
-{ RTOKEN(SIZEOF_HEADERS);}
-        YY_BREAK
-case 69:
+{ RTOKEN(SEGMENT_START);}
+        YY_BREAK
+case 70:
 YY_RULE_SETUP
 #line 263 "ldlex.l"
-{ RTOKEN(SEGMENT_START);}
-        YY_BREAK
-case 70:
+{ RTOKEN(MAP);}
+        YY_BREAK
+case 71:
 YY_RULE_SETUP
 #line 264 "ldlex.l"
-{ RTOKEN(MAP);}
-        YY_BREAK
-case 71:
+{ RTOKEN(SIZEOF);}
+        YY_BREAK
+case 72:
 YY_RULE_SETUP
 #line 265 "ldlex.l"
-{ RTOKEN(SIZEOF);}
-        YY_BREAK
-case 72:
+{ RTOKEN(TARGET_K);}
+        YY_BREAK
+case 73:
 YY_RULE_SETUP
 #line 266 "ldlex.l"
-{ RTOKEN(TARGET_K);}
-        YY_BREAK
-case 73:
+{ RTOKEN(SEARCH_DIR);}
+        YY_BREAK
+case 74:
 YY_RULE_SETUP
 #line 267 "ldlex.l"
-{ RTOKEN(SEARCH_DIR);}
-        YY_BREAK
-case 74:
+{ RTOKEN(OUTPUT);}
+        YY_BREAK
+case 75:
 YY_RULE_SETUP
 #line 268 "ldlex.l"
-{ RTOKEN(OUTPUT);}
-        YY_BREAK
-case 75:
+{ RTOKEN(INPUT);}
+        YY_BREAK
+case 76:
 YY_RULE_SETUP
 #line 269 "ldlex.l"
-{ RTOKEN(INPUT);}
-        YY_BREAK
-case 76:
+{ RTOKEN(GROUP);}
+        YY_BREAK
+case 77:
 YY_RULE_SETUP
 #line 270 "ldlex.l"
-{ RTOKEN(GROUP);}
-        YY_BREAK
-case 77:
+{ RTOKEN(AS_NEEDED);}
+        YY_BREAK
+case 78:
 YY_RULE_SETUP
 #line 271 "ldlex.l"
-{ RTOKEN(AS_NEEDED);}
-        YY_BREAK
-case 78:
+{ RTOKEN(DEFINED);}
+        YY_BREAK
+case 79:
 YY_RULE_SETUP
 #line 272 "ldlex.l"
-{ RTOKEN(DEFINED);}
-        YY_BREAK
-case 79:
+{ RTOKEN(CREATE_OBJECT_SYMBOLS);}
+        YY_BREAK
+case 80:
 YY_RULE_SETUP
 #line 273 "ldlex.l"
-{ RTOKEN(CREATE_OBJECT_SYMBOLS);}
-        YY_BREAK
-case 80:
+{ RTOKEN( CONSTRUCTORS);}
+        YY_BREAK
+case 81:
 YY_RULE_SETUP
 #line 274 "ldlex.l"
-{ RTOKEN( CONSTRUCTORS);}
-        YY_BREAK
-case 81:
+{ RTOKEN(FORCE_COMMON_ALLOCATION);}
+        YY_BREAK
+case 82:
 YY_RULE_SETUP
 #line 275 "ldlex.l"
-{ RTOKEN(FORCE_COMMON_ALLOCATION);}
-        YY_BREAK
-case 82:
+{ RTOKEN(INHIBIT_COMMON_ALLOCATION);}
+        YY_BREAK
+case 83:
 YY_RULE_SETUP
 #line 276 "ldlex.l"
-{ RTOKEN(INHIBIT_COMMON_ALLOCATION);}
-        YY_BREAK
-case 83:
+{ RTOKEN(SECTIONS);}
+        YY_BREAK
+case 84:
 YY_RULE_SETUP
 #line 277 "ldlex.l"
-{ RTOKEN(SECTIONS);}
-        YY_BREAK
-case 84:
+{ RTOKEN(INSERT_K);}
+        YY_BREAK
+case 85:
 YY_RULE_SETUP
 #line 278 "ldlex.l"
-{ RTOKEN(INSERT_K);}
-        YY_BREAK
-case 85:
+{ RTOKEN(AFTER);}
+        YY_BREAK
+case 86:
 YY_RULE_SETUP
 #line 279 "ldlex.l"
-{ RTOKEN(AFTER);}
-        YY_BREAK
-case 86:
+{ RTOKEN(BEFORE);}
+        YY_BREAK
+case 87:
 YY_RULE_SETUP
 #line 280 "ldlex.l"
-{ RTOKEN(BEFORE);}
-        YY_BREAK
-case 87:
+{ RTOKEN(FILL);}
+        YY_BREAK
+case 88:
 YY_RULE_SETUP
 #line 281 "ldlex.l"
-{ RTOKEN(FILL);}
-        YY_BREAK
-case 88:
+{ RTOKEN(STARTUP);}
+        YY_BREAK
+case 89:
 YY_RULE_SETUP
 #line 282 "ldlex.l"
-{ RTOKEN(STARTUP);}
-        YY_BREAK
-case 89:
+{ RTOKEN(OUTPUT_FORMAT);}
+        YY_BREAK
+case 90:
 YY_RULE_SETUP
 #line 283 "ldlex.l"
-{ RTOKEN(OUTPUT_FORMAT);}
-        YY_BREAK
-case 90:
+{ RTOKEN( OUTPUT_ARCH);}
+        YY_BREAK
+case 91:
 YY_RULE_SETUP
 #line 284 "ldlex.l"
-{ RTOKEN( OUTPUT_ARCH);}
-        YY_BREAK
-case 91:
+{ RTOKEN(HLL);}
+        YY_BREAK
+case 92:
 YY_RULE_SETUP
 #line 285 "ldlex.l"
-{ RTOKEN(HLL);}
-        YY_BREAK
-case 92:
+{ RTOKEN(SYSLIB);}
+        YY_BREAK
+case 93:
 YY_RULE_SETUP
 #line 286 "ldlex.l"
-{ RTOKEN(SYSLIB);}
-        YY_BREAK
-case 93:
+{ RTOKEN(FLOAT);}
+        YY_BREAK
+case 94:
 YY_RULE_SETUP
 #line 287 "ldlex.l"
-{ RTOKEN(FLOAT);}
-        YY_BREAK
-case 94:
+{ RTOKEN( QUAD);}
+        YY_BREAK
+case 95:
 YY_RULE_SETUP
 #line 288 "ldlex.l"
-{ RTOKEN( QUAD);}
-        YY_BREAK
-case 95:
+{ RTOKEN( SQUAD);}
+        YY_BREAK
+case 96:
 YY_RULE_SETUP
 #line 289 "ldlex.l"
-{ RTOKEN( SQUAD);}
-        YY_BREAK
-case 96:
+{ RTOKEN( LONG);}
+        YY_BREAK
+case 97:
 YY_RULE_SETUP
 #line 290 "ldlex.l"
-{ RTOKEN( LONG);}
-        YY_BREAK
-case 97:
+{ RTOKEN( SHORT);}
+        YY_BREAK
+case 98:
 YY_RULE_SETUP
 #line 291 "ldlex.l"
-{ RTOKEN( SHORT);}
-        YY_BREAK
-case 98:
+{ RTOKEN( BYTE);}
+        YY_BREAK
+case 99:
 YY_RULE_SETUP
 #line 292 "ldlex.l"
-{ RTOKEN( BYTE);}
-        YY_BREAK
-case 99:
+{ RTOKEN(NOFLOAT);}
+        YY_BREAK
+case 100:
 YY_RULE_SETUP
 #line 293 "ldlex.l"
-{ RTOKEN(NOFLOAT);}
-        YY_BREAK
-case 100:
+{ RTOKEN(NOCROSSREFS);}
+        YY_BREAK
+case 101:
 YY_RULE_SETUP
 #line 294 "ldlex.l"
-{ RTOKEN(NOCROSSREFS);}
-        YY_BREAK
-case 101:
+{ RTOKEN(OVERLAY); }
+        YY_BREAK
+case 102:
 YY_RULE_SETUP
 #line 295 "ldlex.l"
-{ RTOKEN(OVERLAY); }
-        YY_BREAK
-case 102:
+{ RTOKEN(SORT_BY_NAME); }
+        YY_BREAK
+case 103:
 YY_RULE_SETUP
 #line 296 "ldlex.l"
+{ RTOKEN(SORT_BY_ALIGNMENT); }
+        YY_BREAK
+case 104:
+YY_RULE_SETUP
+#line 297 "ldlex.l"
 { RTOKEN(SORT_BY_NAME); }
         YY_BREAK
-case 103:
-YY_RULE_SETUP
-#line 297 "ldlex.l"
-{ RTOKEN(SORT_BY_ALIGNMENT); }
-        YY_BREAK
-case 104:
+case 105:
 YY_RULE_SETUP
 #line 298 "ldlex.l"
-{ RTOKEN(SORT_BY_NAME); }
-        YY_BREAK
-case 105:
+{ RTOKEN(NOLOAD);}
+        YY_BREAK
+case 106:
 YY_RULE_SETUP
 #line 299 "ldlex.l"
-{ RTOKEN(NOLOAD);}
-        YY_BREAK
-case 106:
+{ RTOKEN(DSECT);}
+        YY_BREAK
+case 107:
 YY_RULE_SETUP
 #line 300 "ldlex.l"
-{ RTOKEN(DSECT);}
-        YY_BREAK
-case 107:
+{ RTOKEN(COPY);}
+        YY_BREAK
+case 108:
 YY_RULE_SETUP
 #line 301 "ldlex.l"
-{ RTOKEN(COPY);}
-        YY_BREAK
-case 108:
+{ RTOKEN(INFO);}
+        YY_BREAK
+case 109:
 YY_RULE_SETUP
 #line 302 "ldlex.l"
-{ RTOKEN(INFO);}
-        YY_BREAK
-case 109:
+{ RTOKEN(OVERLAY);}
+        YY_BREAK
+case 110:
 YY_RULE_SETUP
 #line 303 "ldlex.l"
-{ RTOKEN(OVERLAY);}
-        YY_BREAK
-case 110:
+{ RTOKEN(ONLY_IF_RO); }
+        YY_BREAK
+case 111:
 YY_RULE_SETUP
 #line 304 "ldlex.l"
-{ RTOKEN(ONLY_IF_RO); }
-        YY_BREAK
-case 111:
+{ RTOKEN(ONLY_IF_RW); }
+        YY_BREAK
+case 112:
 YY_RULE_SETUP
 #line 305 "ldlex.l"
-{ RTOKEN(ONLY_IF_RW); }
-        YY_BREAK
-case 112:
+{ RTOKEN(SPECIAL); }
+        YY_BREAK
+case 113:
 YY_RULE_SETUP
 #line 306 "ldlex.l"
-{ RTOKEN(SPECIAL); }
-        YY_BREAK
-case 113:
+{ RTOKEN(ORIGIN);}
+        YY_BREAK
+case 114:
 YY_RULE_SETUP
 #line 307 "ldlex.l"
 { RTOKEN(ORIGIN);}
         YY_BREAK
-case 114:
+case 115:
 YY_RULE_SETUP
 #line 308 "ldlex.l"
-{ RTOKEN(ORIGIN);}
-        YY_BREAK
-case 115:
+{ RTOKEN( LENGTH);}
+        YY_BREAK
+case 116:
 YY_RULE_SETUP
 #line 309 "ldlex.l"
 { RTOKEN( LENGTH);}
         YY_BREAK
-case 116:
+case 117:
 YY_RULE_SETUP
 #line 310 "ldlex.l"
-{ RTOKEN( LENGTH);}
-        YY_BREAK
-case 117:
+{ RTOKEN(INCLUDE);}
+        YY_BREAK
+case 118:
 YY_RULE_SETUP
 #line 311 "ldlex.l"
-{ RTOKEN(INCLUDE);}
-        YY_BREAK
-case 118:
+{ RTOKEN (PHDRS); }
+        YY_BREAK
+case 119:
 YY_RULE_SETUP
 #line 312 "ldlex.l"
-{ RTOKEN (PHDRS); }
-        YY_BREAK
-case 119:
+{ RTOKEN(AT);}
+        YY_BREAK
+case 120:
 YY_RULE_SETUP
 #line 313 "ldlex.l"
-{ RTOKEN(AT);}
-        YY_BREAK
-case 120:
+{ RTOKEN(SUBALIGN);}
+        YY_BREAK
+case 121:
 YY_RULE_SETUP
 #line 314 "ldlex.l"
-{ RTOKEN(SUBALIGN);}
-        YY_BREAK
-case 121:
+{ RTOKEN(PROVIDE); }
+        YY_BREAK
+case 122:
 YY_RULE_SETUP
 #line 315 "ldlex.l"
-{ RTOKEN(PROVIDE); }
-        YY_BREAK
-case 122:
+{ RTOKEN(PROVIDE_HIDDEN); }
+        YY_BREAK
+case 123:
 YY_RULE_SETUP
 #line 316 "ldlex.l"
-{ RTOKEN(PROVIDE_HIDDEN); }
-        YY_BREAK
-case 123:
+{ RTOKEN(KEEP); }
+        YY_BREAK
+case 124:
 YY_RULE_SETUP
 #line 317 "ldlex.l"
-{ RTOKEN(KEEP); }
-        YY_BREAK
-case 124:
+{ RTOKEN(EXCLUDE_FILE); }
+        YY_BREAK
+case 125:
 YY_RULE_SETUP
 #line 318 "ldlex.l"
-{ RTOKEN(EXCLUDE_FILE); }
-        YY_BREAK
-case 125:
-YY_RULE_SETUP
-#line 319 "ldlex.l"
 { RTOKEN(CONSTANT);}
         YY_BREAK
 case 126:
 /* rule 126 can match eol */
 YY_RULE_SETUP
-#line 320 "ldlex.l"
+#line 319 "ldlex.l"
 { ++ lineno; }
         YY_BREAK
 case 127:
 /* rule 127 can match eol */
 YY_RULE_SETUP
+#line 320 "ldlex.l"
+{ ++ lineno;  RTOKEN(NEWLINE); }
+        YY_BREAK
+case 128:
+YY_RULE_SETUP
 #line 321 "ldlex.l"
-{ ++ lineno;  RTOKEN(NEWLINE); }
-        YY_BREAK
-case 128:
+{ /* Mri comment line */ }
+        YY_BREAK
+case 129:
 YY_RULE_SETUP
 #line 322 "ldlex.l"
 { /* Mri comment line */ }
         YY_BREAK
-case 129:
+case 130:
 YY_RULE_SETUP
 #line 323 "ldlex.l"
-{ /* Mri comment line */ }
-        YY_BREAK
-case 130:
+{ RTOKEN(ENDWORD); }
+        YY_BREAK
+case 131:
 YY_RULE_SETUP
 #line 324 "ldlex.l"
+{ RTOKEN(ALIGNMOD);}
+        YY_BREAK
+case 132:
+YY_RULE_SETUP
+#line 325 "ldlex.l"
+{ RTOKEN(ALIGN_K);}
+        YY_BREAK
+case 133:
+YY_RULE_SETUP
+#line 326 "ldlex.l"
+{ RTOKEN(CHIP); }
+        YY_BREAK
+case 134:
+YY_RULE_SETUP
+#line 327 "ldlex.l"
+{ RTOKEN(BASE); }
+        YY_BREAK
+case 135:
+YY_RULE_SETUP
+#line 328 "ldlex.l"
+{ RTOKEN(ALIAS); }
+        YY_BREAK
+case 136:
+YY_RULE_SETUP
+#line 329 "ldlex.l"
+{ RTOKEN(TRUNCATE); }
+        YY_BREAK
+case 137:
+YY_RULE_SETUP
+#line 330 "ldlex.l"
+{ RTOKEN(LOAD); }
+        YY_BREAK
+case 138:
+YY_RULE_SETUP
+#line 331 "ldlex.l"
+{ RTOKEN(PUBLIC); }
+        YY_BREAK
+case 139:
+YY_RULE_SETUP
+#line 332 "ldlex.l"
+{ RTOKEN(ORDER); }
+        YY_BREAK
+case 140:
+YY_RULE_SETUP
+#line 333 "ldlex.l"
+{ RTOKEN(NAMEWORD); }
+        YY_BREAK
+case 141:
+YY_RULE_SETUP
+#line 334 "ldlex.l"
+{ RTOKEN(FORMAT); }
+        YY_BREAK
+case 142:
+YY_RULE_SETUP
+#line 335 "ldlex.l"
+{ RTOKEN(CASE); }
+        YY_BREAK
+case 143:
+YY_RULE_SETUP
+#line 336 "ldlex.l"
+{ RTOKEN(START); }
+        YY_BREAK
+case 144:
+YY_RULE_SETUP
+#line 337 "ldlex.l"
+{ RTOKEN(LIST); /* LIST and ignore to end of line */ }
+        YY_BREAK
+case 145:
+YY_RULE_SETUP
+#line 338 "ldlex.l"
+{ RTOKEN(SECT); }
+        YY_BREAK
+case 146:
+YY_RULE_SETUP
+#line 339 "ldlex.l"
+{ RTOKEN(ABSOLUTE); }
+        YY_BREAK
+case 147:
+YY_RULE_SETUP
+#line 340 "ldlex.l"
 { RTOKEN(ENDWORD); }
         YY_BREAK
-case 131:
-YY_RULE_SETUP
-#line 325 "ldlex.l"
+case 148:
+YY_RULE_SETUP
+#line 341 "ldlex.l"
 { RTOKEN(ALIGNMOD);}
         YY_BREAK
-case 132:
-YY_RULE_SETUP
-#line 326 "ldlex.l"
+case 149:
+YY_RULE_SETUP
+#line 342 "ldlex.l"
 { RTOKEN(ALIGN_K);}
         YY_BREAK
-case 133:
-YY_RULE_SETUP
-#line 327 "ldlex.l"
+case 150:
+YY_RULE_SETUP
+#line 343 "ldlex.l"
 { RTOKEN(CHIP); }
         YY_BREAK
-case 134:
-YY_RULE_SETUP
-#line 328 "ldlex.l"
+case 151:
+YY_RULE_SETUP
+#line 344 "ldlex.l"
 { RTOKEN(BASE); }
         YY_BREAK
-case 135:
-YY_RULE_SETUP
-#line 329 "ldlex.l"
+case 152:
+YY_RULE_SETUP
+#line 345 "ldlex.l"
 { RTOKEN(ALIAS); }
         YY_BREAK
-case 136:
-YY_RULE_SETUP
-#line 330 "ldlex.l"
+case 153:
+YY_RULE_SETUP
+#line 346 "ldlex.l"
 { RTOKEN(TRUNCATE); }
         YY_BREAK
-case 137:
-YY_RULE_SETUP
-#line 331 "ldlex.l"
+case 154:
+YY_RULE_SETUP
+#line 347 "ldlex.l"
 { RTOKEN(LOAD); }
         YY_BREAK
-case 138:
-YY_RULE_SETUP
-#line 332 "ldlex.l"
+case 155:
+YY_RULE_SETUP
+#line 348 "ldlex.l"
 { RTOKEN(PUBLIC); }
         YY_BREAK
-case 139:
-YY_RULE_SETUP
-#line 333 "ldlex.l"
+case 156:
+YY_RULE_SETUP
+#line 349 "ldlex.l"
 { RTOKEN(ORDER); }
         YY_BREAK
-case 140:
-YY_RULE_SETUP
-#line 334 "ldlex.l"
+case 157:
+YY_RULE_SETUP
+#line 350 "ldlex.l"
 { RTOKEN(NAMEWORD); }
         YY_BREAK
-case 141:
-YY_RULE_SETUP
-#line 335 "ldlex.l"
+case 158:
+YY_RULE_SETUP
+#line 351 "ldlex.l"
 { RTOKEN(FORMAT); }
         YY_BREAK
-case 142:
-YY_RULE_SETUP
-#line 336 "ldlex.l"
+case 159:
+YY_RULE_SETUP
+#line 352 "ldlex.l"
 { RTOKEN(CASE); }
         YY_BREAK
-case 143:
-YY_RULE_SETUP
-#line 337 "ldlex.l"
+case 160:
+YY_RULE_SETUP
+#line 353 "ldlex.l"
+{ RTOKEN(EXTERN); }
+        YY_BREAK
+case 161:
+YY_RULE_SETUP
+#line 354 "ldlex.l"
 { RTOKEN(START); }
         YY_BREAK
-case 144:
-YY_RULE_SETUP
-#line 338 "ldlex.l"
+case 162:
+YY_RULE_SETUP
+#line 355 "ldlex.l"
 { RTOKEN(LIST); /* LIST and ignore to end of line */ }
         YY_BREAK
-case 145:
-YY_RULE_SETUP
-#line 339 "ldlex.l"
+case 163:
+YY_RULE_SETUP
+#line 356 "ldlex.l"
 { RTOKEN(SECT); }
         YY_BREAK
-case 146:
-YY_RULE_SETUP
-#line 340 "ldlex.l"
+case 164:
+YY_RULE_SETUP
+#line 357 "ldlex.l"
 { RTOKEN(ABSOLUTE); }
         YY_BREAK
-case 147:
-YY_RULE_SETUP
-#line 341 "ldlex.l"
-{ RTOKEN(ENDWORD); }
-        YY_BREAK
-case 148:
-YY_RULE_SETUP
-#line 342 "ldlex.l"
-{ RTOKEN(ALIGNMOD);}
-        YY_BREAK
-case 149:
-YY_RULE_SETUP
-#line 343 "ldlex.l"
-{ RTOKEN(ALIGN_K);}
-        YY_BREAK
-case 150:
-YY_RULE_SETUP
-#line 344 "ldlex.l"
-{ RTOKEN(CHIP); }
-        YY_BREAK
-case 151:
-YY_RULE_SETUP
-#line 345 "ldlex.l"
-{ RTOKEN(BASE); }
-        YY_BREAK
-case 152:
-YY_RULE_SETUP
-#line 346 "ldlex.l"
-{ RTOKEN(ALIAS); }
-        YY_BREAK
-case 153:
-YY_RULE_SETUP
-#line 347 "ldlex.l"
-{ RTOKEN(TRUNCATE); }
-        YY_BREAK
-case 154:
-YY_RULE_SETUP
-#line 348 "ldlex.l"
-{ RTOKEN(LOAD); }
-        YY_BREAK
-case 155:
-YY_RULE_SETUP
-#line 349 "ldlex.l"
-{ RTOKEN(PUBLIC); }
-        YY_BREAK
-case 156:
-YY_RULE_SETUP
-#line 350 "ldlex.l"
-{ RTOKEN(ORDER); }
-        YY_BREAK
-case 157:
-YY_RULE_SETUP
-#line 351 "ldlex.l"
-{ RTOKEN(NAMEWORD); }
-        YY_BREAK
-case 158:
-YY_RULE_SETUP
-#line 352 "ldlex.l"
-{ RTOKEN(FORMAT); }
-        YY_BREAK
-case 159:
-YY_RULE_SETUP
-#line 353 "ldlex.l"
-{ RTOKEN(CASE); }
-        YY_BREAK
-case 160:
-YY_RULE_SETUP
-#line 354 "ldlex.l"
-{ RTOKEN(EXTERN); }
-        YY_BREAK
-case 161:
-YY_RULE_SETUP
-#line 355 "ldlex.l"
-{ RTOKEN(START); }
-        YY_BREAK
-case 162:
-YY_RULE_SETUP
-#line 356 "ldlex.l"
-{ RTOKEN(LIST); /* LIST and ignore to end of line */ }
-        YY_BREAK
-case 163:
-YY_RULE_SETUP
-#line 357 "ldlex.l"
-{ RTOKEN(SECT); }
-        YY_BREAK
-case 164:
-YY_RULE_SETUP
-#line 358 "ldlex.l"
-{ RTOKEN(ABSOLUTE); }
-        YY_BREAK
 case 165:
 YY_RULE_SETUP
-#line 360 "ldlex.l"
+#line 359 "ldlex.l"
 {
 /* Filename without commas, needed to parse mri stuff */
                                  yylval.name = xstrdup (yytext);
                                   return NAME;
                                 }
         YY_BREAK
 case 166:
 YY_RULE_SETUP
-#line 367 "ldlex.l"
+#line 366 "ldlex.l"
 {
                                  yylval.name = xstrdup (yytext);
                                   return NAME;
                                 }
         YY_BREAK
 case 167:
 YY_RULE_SETUP
-#line 371 "ldlex.l"
+#line 370 "ldlex.l"
 {
                                   yylval.name = xstrdup (yytext + 2);
                                   return LNAME;
                                 }
         YY_BREAK
 case 168:
 YY_RULE_SETUP
-#line 375 "ldlex.l"
+#line 374 "ldlex.l"
 {
                                  yylval.name = xstrdup (yytext);
                                   return NAME;
                                 }
         YY_BREAK
 case 169:
 YY_RULE_SETUP
-#line 379 "ldlex.l"
+#line 378 "ldlex.l"
 {
                                   yylval.name = xstrdup (yytext + 2);
                                   return LNAME;
                                 }
         YY_BREAK
 case 170:
 YY_RULE_SETUP
-#line 383 "ldlex.l"
+#line 382 "ldlex.l"
 {
                 /* Annoyingly, this pattern can match comments, and we have
                    longest match issues to consider.  So if the first two
                    characters are a comment opening, put the input back and
                    try again.  */
                 if (yytext[0] == '/' && yytext[1] == '*')
                   {
                     yyless (2);
                     comment ();
                   }
                 else
                   {
                     yylval.name = xstrdup (yytext);
                     return NAME;
                   }
         }
         YY_BREAK
 case 171:
 /* rule 171 can match eol */
 YY_RULE_SETUP
-#line 400 "ldlex.l"
+#line 399 "ldlex.l"
 {
                                         /* No matter the state, quotes
                                            give what's inside */
                                         yylval.name = xstrdup (yytext + 1);
                                         yylval.name[yyleng - 2] = 0;
                                         return NAME;
                                 }
         YY_BREAK
 case 172:
 /* rule 172 can match eol */
 YY_RULE_SETUP
-#line 407 "ldlex.l"
+#line 406 "ldlex.l"
 { lineno++;}
         YY_BREAK
 case 173:
 YY_RULE_SETUP
-#line 408 "ldlex.l"
+#line 407 "ldlex.l"
 { }
         YY_BREAK
 case 174:
 YY_RULE_SETUP
-#line 410 "ldlex.l"
+#line 409 "ldlex.l"
 { return *yytext; }
         YY_BREAK
 case 175:
 YY_RULE_SETUP
-#line 412 "ldlex.l"
+#line 411 "ldlex.l"
 { RTOKEN(GLOBAL); }
         YY_BREAK
 case 176:
 YY_RULE_SETUP
-#line 414 "ldlex.l"
+#line 413 "ldlex.l"
 { RTOKEN(LOCAL); }
         YY_BREAK
 case 177:
 YY_RULE_SETUP
-#line 416 "ldlex.l"
+#line 415 "ldlex.l"
 { RTOKEN(EXTERN); }
         YY_BREAK
 case 178:
 YY_RULE_SETUP
-#line 418 "ldlex.l"
+#line 417 "ldlex.l"
 { yylval.name = xstrdup (yytext);
                                   return VERS_IDENTIFIER; }
         YY_BREAK
 case 179:
 YY_RULE_SETUP
-#line 421 "ldlex.l"
+#line 420 "ldlex.l"
 { yylval.name = xstrdup (yytext);
                                   return VERS_TAG; }
         YY_BREAK
 case 180:
 YY_RULE_SETUP
-#line 424 "ldlex.l"
+#line 423 "ldlex.l"
 { BEGIN(VERS_SCRIPT); return *yytext; }
         YY_BREAK
 case 181:
 YY_RULE_SETUP
-#line 426 "ldlex.l"
+#line 425 "ldlex.l"
 { BEGIN(VERS_NODE);
                                   vers_node_nesting = 0;
                                   return *yytext;
                                 }
         YY_BREAK
 case 182:
 YY_RULE_SETUP
-#line 430 "ldlex.l"
+#line 429 "ldlex.l"
 { return *yytext; }
         YY_BREAK
 case 183:
 YY_RULE_SETUP
-#line 431 "ldlex.l"
+#line 430 "ldlex.l"
 { vers_node_nesting++; return *yytext; }
         YY_BREAK
 case 184:
 YY_RULE_SETUP
-#line 432 "ldlex.l"
+#line 431 "ldlex.l"
 { if (--vers_node_nesting < 0)
                                     BEGIN(VERS_SCRIPT);
                                   return *yytext;
                                 }
         YY_BREAK
 case 185:
 /* rule 185 can match eol */
 YY_RULE_SETUP
-#line 437 "ldlex.l"
+#line 436 "ldlex.l"
 { lineno++; }
         YY_BREAK
 case 186:
 YY_RULE_SETUP
-#line 439 "ldlex.l"
+#line 438 "ldlex.l"
 { /* Eat up comments */ }
         YY_BREAK
 case 187:
 YY_RULE_SETUP
-#line 441 "ldlex.l"
+#line 440 "ldlex.l"
 { /* Eat up whitespace */ }
         YY_BREAK
 case YY_STATE_EOF(INITIAL):
 case YY_STATE_EOF(SCRIPT):
 case YY_STATE_EOF(EXPRESSION):
 case YY_STATE_EOF(BOTH):
 case YY_STATE_EOF(DEFSYMEXP):
 case YY_STATE_EOF(MRI):
 case YY_STATE_EOF(VERS_START):
 case YY_STATE_EOF(VERS_SCRIPT):
 case YY_STATE_EOF(VERS_NODE):
-#line 443 "ldlex.l"
+#line 442 "ldlex.l"
 {
   include_stack_ptr--;
 
   if (include_stack_ptr == 0)
   {
     yyterminate ();
   }
   else
   {
     yy_switch_to_buffer (include_stack[include_stack_ptr]);
   }
 
   ldfile_input_filename = file_name_stack[include_stack_ptr - 1];
   lineno = lineno_stack[include_stack_ptr];
 
   return END;
 }
         YY_BREAK
 case 188:
 YY_RULE_SETUP
-#line 461 "ldlex.l"
+#line 460 "ldlex.l"
 lex_warn_invalid (" in script", yytext);
         YY_BREAK
 case 189:
 YY_RULE_SETUP
-#line 462 "ldlex.l"
+#line 461 "ldlex.l"
 lex_warn_invalid (" in expression", yytext);
         YY_BREAK
 case 190:
 YY_RULE_SETUP
-#line 464 "ldlex.l"
+#line 463 "ldlex.l"
 ECHO;
         YY_BREAK
-#line 3036 "ldlex.c"
+#line 3035 "/Users/gingold/Repositories/fsf/binutils-2_20/ld/ldlex.c"
 
         case YY_END_OF_BUFFER:
                 {
                 /* Amount of text matched not including the EOB char. */
                 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
 
                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
                 *yy_cp = (yy_hold_char);
                 YY_RESTORE_YY_MORE_OFFSET
 
@@ skipping 971 matching lines @@
          * any pointer type to void*, and deal with argument conversions
          * as though doing an assignment.
          */
         return (void *) realloc( (char *) ptr, size );
 }
 
 void yyfree (void * ptr )
 {
         free( (char *) ptr );   /* see yyrealloc() for (char *) cast */
 }