Import of binutils-2.8.1 from Cygnus/FSF

9 files changed, 4561 insertions, 0 deletions

diff --git a/gnu/usr.bin/binutils/binutils/addr2line.1 b/gnu/usr.bin/binutils/binutils/addr2line.1
new file mode 100644
index 00000000000..87ce103f8e3
--- /dev/null
+++ b/gnu/usr.bin/binutils/binutils/addr2line.1
@@ -0,0 +1,127 @@
+.\" Copyright (c) 1997 Free Software Foundation
+.\" See COPYING for conditions for redistribution
+.TH addr2line 1 "27 March 1997" "Cygnus Solutions" "GNU Development Tools"
+.de BP
+.sp
+.ti \-.2i
+\(**
+..
+
+.SH NAME
+addr2line \- convert addresses into file names and line numbers
+
+.SH SYNOPSIS
+.hy 0
+.na
+.TP
+.B addr2line
+.RB "[\|" "\-b\ "\c
+.I bfdname\c
+.RB " | " "\-\-target="\c
+.I bfdname\c
+\&\|]
+.RB "[\|" \-C | \-\-demangle "\|]"
+.RB "[\|" "\-e\ "\c
+.I filename\c
+.RB " | " "\-\-exe="\c
+.I filename\c
+\&\|]
+.RB "[\|" \-f | \-\-functions "\|]"
+.RB "[\|" \-s | \-\-basenames "\|]"
+.RB "[\|" \-H | \-\-help "\|]"
+.RB "[\|" \-V | \-\-version "\|]"
+.RB "[\|" addr addr ...  "\|]"
+.ad b
+.hy 1
+.SH DESCRIPTION
+\c
+.B addr2line
+translates program addresses into file names and line numbers.  Given
+an address and an executable, it uses the debugging information in the
+executable to figure out which file name and line number are
+associated with a given address.
+
+The executable to use is specified with the
+.B \-e
+option.  The default is
+.B a.out\c
+\&.
+
+.B addr2line
+has two modes of operation.
+
+In the first, hexadecimal addresses are specified on the command line,
+and
+.B addr2line
+displays the file name and line number for each address.
+
+In the second,
+.B addr2line
+reads hexadecimal addresses from standard input, and prints the file
+name and line number for each address on standard output.  In this
+mode,
+.B addr2line
+may be used in a pipe to convert dynamically chosen addresses.
+
+The format of the output is FILENAME:LINENO.  The file name and line
+number for each address is printed on a separate line.  If the
+.B \-f
+option is used, then each FILENAME:LINENO line is preceded by a
+FUNCTIONNAME line which is the name of the function containing the
+address.
+
+If the file name or function name can not be determined,
+.B addr2line
+will print two question marks in their place.  If the line number can
+not be determined,
+.B addr2line
+will print 0.
+
+.SH OPTIONS
+.TP
+.BI "\-b " "bfdname"\c
+.TP
+.BI "\-\-target=" "bfdname"
+Specify the object-code format for the object files to be
+\c
+.I bfdname\c
+\&.
+
+.TP
+.B \-C
+.TP
+.B \-\-demangle
+Decode (\fIdemangle\fP) low-level symbol names into user-level names.
+Besides removing any initial underscore prepended by the system, this
+makes C++ function names readable.
+
+.TP
+.BI "\-e " "filename"\c
+.TP
+.BI "\-\-exe=" "filename"
+Specify the name of the executable for which addresses should be
+translated.  The default file is
+.B a.out\c
+\&.
+
+.TP
+.B \-f
+.TP
+.B \-\-functions
+Display function names as well as file and line number information.
+
+.TP
+.B \-s
+.TP
+.B \-\-basenames
+Display only the base of each file name.
+
+.SH "SEE ALSO"
+.RB "`\|" binutils "\|'"
+entry in 
+.B
+info\c
+\&; 
+.I
+The GNU Binary Utilities\c
+\&, Roland H. Pesch (October 1991).
diff --git a/gnu/usr.bin/binutils/binutils/addr2line.c b/gnu/usr.bin/binutils/binutils/addr2line.c
new file mode 100644
index 00000000000..7fbbdd855df
--- /dev/null
+++ b/gnu/usr.bin/binutils/binutils/addr2line.c
@@ -0,0 +1,324 @@
+/* addr2line.c -- convert addresses to line number and function name
+   Copyright 1997 Free Software Foundation, Inc.
+   Contributed by Ulrich Lauther <Ulrich.Lauther@zfe.siemens.de>
+
+   This file is part of GNU Binutils.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   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, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+/* Derived from objdump.c and nm.c by Ulrich.Lauther@zfe.siemens.de
+
+   Usage: 
+   addr2line [options] addr addr ...
+   or
+   addr2line [options] 
+
+   both forms write results to stdout, the second form reads addresses
+   to be converted from stdin.  */
+
+#include <ctype.h>
+#include <string.h>
+
+#include "bfd.h"
+#include "getopt.h"
+#include "libiberty.h"
+#include "demangle.h"
+#include "bucomm.h"
+
+extern char *program_version;
+
+static boolean with_functions;	/* -f, show function names.  */
+static boolean do_demangle;	/* -C, demangle names.  */
+static boolean base_names;	/* -s, strip directory names.  */
+
+static int naddr;		/* Number of addresses to process.  */
+static char **addr;		/* Hex addresses to process.  */
+
+static asymbol **syms;		/* Symbol table.  */
+
+static struct option long_options[] =
+{
+  {"basenames", no_argument, NULL, 's'},
+  {"demangle", no_argument, NULL, 'C'},
+  {"exe", required_argument, NULL, 'e'},
+  {"functions", no_argument, NULL, 'f'},
+  {"target", required_argument, NULL, 'b'},
+  {"help", no_argument, NULL, 'H'},
+  {"version", no_argument, NULL, 'V'},
+  {0, no_argument, 0, 0}
+};
+
+static void usage PARAMS ((FILE *, int));
+static void slurp_symtab PARAMS ((bfd *));
+static void find_address_in_section PARAMS ((bfd *, asection *, PTR));
+static void translate_addresses PARAMS ((bfd *));
+static void process_file PARAMS ((const char *, const char *));
+
+/* Print a usage message to STREAM and exit with STATUS.  */
+
+static void
+usage (stream, status)
+     FILE *stream;
+     int status;
+{
+  fprintf (stream, "\
+Usage: %s [-CfsHV] [-b bfdname] [--target=bfdname]\n\
+       [-e executable] [--exe=executable] [--demangle]\n\
+       [--basenames] [--functions] [addr addr ...]\n",
+	   program_name);
+  list_supported_targets (program_name, stream);
+  if (status == 0)
+    fprintf (stream, "Report bugs to bug-gnu-utils@prep.ai.mit.edu\n");
+  exit (status);
+}
+
+/* Read in the symbol table.  */
+
+static void
+slurp_symtab (abfd)
+     bfd *abfd;
+{
+  long storage;
+  long symcount;
+
+  if ((bfd_get_file_flags (abfd) & HAS_SYMS) == 0)
+    return;
+
+  storage = bfd_get_symtab_upper_bound (abfd);
+  if (storage < 0)
+    bfd_fatal (bfd_get_filename (abfd));
+
+  syms = (asymbol **) xmalloc (storage);
+
+  symcount = bfd_canonicalize_symtab (abfd, syms);
+  if (symcount < 0)
+    bfd_fatal (bfd_get_filename (abfd));
+}
+
+/* These global variables are used to pass information between
+   translate_addresses and find_address_in_section.  */
+
+static bfd_vma pc;
+static const char *filename;
+static const char *functionname;
+static unsigned int line;
+static boolean found;
+
+/* Look for an address in a section.  This is called via
+   bfd_map_over_sections.  */
+
+static void
+find_address_in_section (abfd, section, data)
+     bfd *abfd;
+     asection *section;
+     PTR data;
+{
+  bfd_vma vma;
+
+  if (found)
+    return;
+
+  if ((bfd_get_section_flags (abfd, section) & SEC_ALLOC) == 0)
+    return;
+
+  vma = bfd_get_section_vma (abfd, section);
+  if (pc < vma)
+    return;
+
+  found = bfd_find_nearest_line (abfd, section, syms, pc - vma,
+				 &filename, &functionname, &line);
+}
+
+/* Read hexadecimal addresses from stdin, translate into
+   file_name:line_number and optionally function name.  */
+
+static void
+translate_addresses (abfd)
+     bfd *abfd;
+{
+  int read_stdin = (naddr == 0);
+
+  for (;;)
+    {
+      if (read_stdin)
+	{
+	  char addr_hex[100];
+
+	  if (fgets (addr_hex, sizeof addr_hex, stdin) == NULL)
+	    break;
+	  pc = strtol (addr_hex, NULL, 16);
+	}
+      else
+	{
+	  if (naddr <= 0)
+	    break;
+	  --naddr;
+	  pc = strtol (*addr++, NULL, 16);
+	}
+
+      found = false;
+      bfd_map_over_sections (abfd, find_address_in_section, (PTR) NULL);
+
+      if (! found)
+	{
+	  if (with_functions)
+	    printf ("??\n");
+	  printf ("??:0\n");
+	}
+      else
+	{
+	  if (with_functions)
+	    {
+	      if (*functionname == '\0')
+		printf ("??\n");
+	      else if (! do_demangle)
+		printf ("%s\n", functionname);
+	      else
+		{
+		  char *res;
+
+		  res = cplus_demangle (functionname, DMGL_ANSI | DMGL_PARAMS);
+		  if (res == NULL)
+		    printf ("%s\n", functionname);
+		  else
+		    {
+		      printf ("%s\n", res);
+		      free (res);
+		    }
+		}
+	    }
+
+	  if (base_names)
+	    {
+	      char *h;
+
+	      h = strrchr (filename, '/');
+	      if (h != NULL)
+		filename = h + 1;
+	    }
+
+	  printf ("%s:%u\n", filename, line);
+	}
+
+      /* fflush() is essential for using this command as a server
+         child process that reads addresses from a pipe and responds
+         with line number information, processing one address at a
+         time.  */
+      fflush (stdout);
+    }
+}
+
+/* Process a file.  */
+
+static void
+process_file (filename, target)
+     const char *filename;
+     const char *target;
+{
+  bfd *abfd;
+  char **matching;
+
+  abfd = bfd_openr (filename, target);
+  if (abfd == NULL)
+    bfd_fatal (filename);
+
+  if (bfd_check_format (abfd, bfd_archive))
+    fatal ("%s: can not get addresses from archive", filename);
+
+  if (! bfd_check_format_matches (abfd, bfd_object, &matching))
+    {
+      bfd_nonfatal (bfd_get_filename (abfd));
+      if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
+	{
+	  list_matching_formats (matching);
+	  free (matching);
+	}
+      xexit (1);
+    }
+
+  slurp_symtab (abfd);
+
+  translate_addresses (abfd);
+
+  if (syms != NULL)
+    {
+      free (syms);
+      syms = NULL;
+    }
+
+  bfd_close (abfd);
+}
+
+int
+main (argc, argv)
+     int argc;
+     char **argv;
+{
+  char *filename;
+  char *target;
+  int c;
+
+  program_name = *argv;
+  xmalloc_set_program_name (program_name);
+
+  bfd_init ();
+  set_default_bfd_target ();
+
+  filename = NULL;
+  target = NULL;
+  while ((c = getopt_long (argc, argv, "b:Ce:sfHV", long_options, (int *) 0))
+	 != EOF)
+    {
+      switch (c)
+	{
+	case 0:
+	  break;		/* we've been given a long option */
+	case 'b':
+	  target = optarg;
+	  break;
+	case 'C':
+	  do_demangle = true;
+	  break;
+	case 'e':
+	  filename = optarg;
+	  break;
+	case 's':
+	  base_names = true;
+	  break;
+	case 'f':
+	  with_functions = true;
+	  break;
+	case 'V':
+	  print_version ("addr2line");
+	  break;
+	case 'H':
+	  usage (stdout, 0);
+	  break;
+	default:
+	  usage (stderr, 1);
+	  break;
+	}
+    }
+
+  if (filename == NULL)
+    filename = "a.out";
+
+  addr = argv + optind;
+  naddr = argc - optind;
+
+  process_file (filename, target);
+
+  return 0;
+}
diff --git a/gnu/usr.bin/binutils/binutils/binutils.info-1 b/gnu/usr.bin/binutils/binutils/binutils.info-1
new file mode 100644
index 00000000000..a8a10d025cb
--- /dev/null
+++ b/gnu/usr.bin/binutils/binutils/binutils.info-1
@@ -0,0 +1,1347 @@
+This is Info file binutils.info, produced by Makeinfo-1.64 from the
+input file ./binutils.texi.
+
+START-INFO-DIR-ENTRY
+* Binutils: (binutils).         The GNU binary utilities "ar", "objcopy",
+				"objdump", "nm", "nlmconv", "size",
+                                "strings", "strip", and "ranlib".
+END-INFO-DIR-ENTRY
+
+   Copyright (C) 1991, 92, 93, 94, 95, 96, 1997 Free Software
+Foundation, Inc.
+
+   Permission is granted to make and distribute verbatim copies of this
+manual provided the copyright notice and this permission notice are
+preserved on all copies.
+
+   Permission is granted to copy and distribute modified versions of
+this manual under the conditions for verbatim copying, provided also
+that the entire resulting derived work is distributed under the terms
+of a permission notice identical to this one.
+
+   Permission is granted to copy and distribute translations of this
+manual into another language, under the above conditions for modified
+versions.
+
+
+File: binutils.info,  Node: Top,  Next: ar,  Up: (dir)
+
+Introduction
+************
+
+   This brief manual contains preliminary documentation for the GNU
+binary utilities (collectively version 2.8.1):
+
+* Menu:
+
+* ar::                          Create, modify, and extract from archives
+* nm::                          List symbols from object files
+* objcopy::			Copy and translate object files
+* objdump::                     Display information from object files
+* ranlib::                      Generate index to archive contents
+* size::                        List section sizes and total size
+* strings::                     List printable strings from files
+* strip::                       Discard symbols
+* c++filt::			Filter to demangle encoded C++ symbols
+* addr2line::			Convert addresses to file and line
+* nlmconv::                     Converts object code into an NLM
+* Selecting The Target System:: How these utilities determine the target.
+* Reporting Bugs::              Reporting Bugs
+* Index::                       Index
+
+
+File: binutils.info,  Node: ar,  Next: nm,  Prev: Top,  Up: Top
+
+ar
+**
+
+     ar [-]P[MOD [RELPOS]] ARCHIVE [MEMBER...]
+     ar -M [ <mri-script ]
+
+   The GNU `ar' program creates, modifies, and extracts from archives.
+An "archive" is a single file holding a collection of other files in a
+structure that makes it possible to retrieve the original individual
+files (called "members" of the archive).
+
+   The original files' contents, mode (permissions), timestamp, owner,
+and group are preserved in the archive, and can be restored on
+extraction.
+
+   GNU `ar' can maintain archives whose members have names of any
+length; however, depending on how `ar' is configured on your system, a
+limit on member-name length may be imposed for compatibility with
+archive formats maintained with other tools.  If it exists, the limit
+is often 15 characters (typical of formats related to a.out) or 16
+characters (typical of formats related to coff).
+
+   `ar' is considered a binary utility because archives of this sort
+are most often used as "libraries" holding commonly needed subroutines.
+
+   `ar' creates an index to the symbols defined in relocatable object
+modules in the archive when you specify the modifier `s'.  Once
+created, this index is updated in the archive whenever `ar' makes a
+change to its contents (save for the `q' update operation).  An archive
+with such an index speeds up linking to the library, and allows
+routines in the library to call each other without regard to their
+placement in the archive.
+
+   You may use `nm -s' or `nm --print-armap' to list this index table.
+If an archive lacks the table, another form of `ar' called `ranlib' can
+be used to add just the table.
+
+   GNU `ar' is designed to be compatible with two different facilities.
+You can control its activity using command-line options, like the
+different varieties of `ar' on Unix systems; or, if you specify the
+single command-line option `-M', you can control it with a script
+supplied via standard input, like the MRI "librarian" program.
+
+* Menu:
+
+* ar cmdline::                  Controlling `ar' on the command line
+* ar scripts::                  Controlling `ar' with a script
+
+
+File: binutils.info,  Node: ar cmdline,  Next: ar scripts,  Up: ar
+
+Controlling `ar' on the command line
+====================================
+
+     ar [-]P[MOD [RELPOS]] ARCHIVE [MEMBER...]
+
+   When you use `ar' in the Unix style, `ar' insists on at least two
+arguments to execute: one keyletter specifying the *operation*
+(optionally accompanied by other keyletters specifying *modifiers*),
+and the archive name to act on.
+
+   Most operations can also accept further MEMBER arguments, specifying
+particular files to operate on.
+
+   GNU `ar' allows you to mix the operation code P and modifier flags
+MOD in any order, within the first command-line argument.
+
+   If you wish, you may begin the first command-line argument with a
+dash.
+
+   The P keyletter specifies what operation to execute; it may be any
+of the following, but you must specify only one of them:
+
+`d'
+     *Delete* modules from the archive.  Specify the names of modules to
+     be deleted as MEMBER...; the archive is untouched if you specify
+     no files to delete.
+
+     If you specify the `v' modifier, `ar' lists each module as it is
+     deleted.
+
+`m'
+     Use this operation to *move* members in an archive.
+
+     The ordering of members in an archive can make a difference in how
+     programs are linked using the library, if a symbol is defined in
+     more than one member.
+
+     If no modifiers are used with `m', any members you name in the
+     MEMBER arguments are moved to the *end* of the archive; you can
+     use the `a', `b', or `i' modifiers to move them to a specified
+     place instead.
+
+`p'
+     *Print* the specified members of the archive, to the standard
+     output file.  If the `v' modifier is specified, show the member
+     name before copying its contents to standard output.
+
+     If you specify no MEMBER arguments, all the files in the archive
+     are printed.
+
+`q'
+     *Quick append*; add the files MEMBER... to the end of ARCHIVE,
+     without checking for replacement.
+
+     The modifiers `a', `b', and `i' do *not* affect this operation;
+     new members are always placed at the end of the archive.
+
+     The modifier `v' makes `ar' list each file as it is appended.
+
+     Since the point of this operation is speed, the archive's symbol
+     table index is not updated, even if it already existed; you can
+     use `ar s' or `ranlib' explicitly to update the symbol table index.
+
+`r'
+     Insert the files MEMBER... into ARCHIVE (with *replacement*). This
+     operation differs from `q' in that any previously existing members
+     are deleted if their names match those being added.
+
+     If one of the files named in MEMBER... does not exist, `ar'
+     displays an error message, and leaves undisturbed any existing
+     members of the archive matching that name.
+
+     By default, new members are added at the end of the file; but you
+     may use one of the modifiers `a', `b', or `i' to request placement
+     relative to some existing member.
+
+     The modifier `v' used with this operation elicits a line of output
+     for each file inserted, along with one of the letters `a' or `r'
+     to indicate whether the file was appended (no old member deleted)
+     or replaced.
+
+`t'
+     Display a *table* listing the contents of ARCHIVE, or those of the
+     files listed in MEMBER... that are present in the archive.
+     Normally only the member name is shown; if you also want to see
+     the modes (permissions), timestamp, owner, group, and size, you can
+     request that by also specifying the `v' modifier.
+
+     If you do not specify a MEMBER, all files in the archive are
+     listed.
+
+     If there is more than one file with the same name (say, `fie') in
+     an archive (say `b.a'), `ar t b.a fie' lists only the first
+     instance; to see them all, you must ask for a complete listing--in
+     our example, `ar t b.a'.
+
+`x'
+     *Extract* members (named MEMBER) from the archive.  You can use
+     the `v' modifier with this operation, to request that `ar' list
+     each name as it extracts it.
+
+     If you do not specify a MEMBER, all files in the archive are
+     extracted.
+
+   A number of modifiers (MOD) may immediately follow the P keyletter,
+to specify variations on an operation's behavior:
+
+`a'
+     Add new files *after* an existing member of the archive.  If you
+     use the modifier `a', the name of an existing archive member must
+     be present as the RELPOS argument, before the ARCHIVE
+     specification.
+
+`b'
+     Add new files *before* an existing member of the archive.  If you
+     use the modifier `b', the name of an existing archive member must
+     be present as the RELPOS argument, before the ARCHIVE
+     specification.  (same as `i').
+
+`c'
+     *Create* the archive.  The specified ARCHIVE is always created if
+     it did not exist, when you request an update.  But a warning is
+     issued unless you specify in advance that you expect to create it,
+     by using this modifier.
+
+`f'
+     Truncate names in the archive.  GNU `ar' will normally permit file
+     names of any length.  This will cause it to create archives which
+     are not compatible with the native `ar' program on some systems.
+     If this is a concern, the `f' modifier may be used to truncate file
+     names when putting them in the archive.
+
+`i'
+     Insert new files *before* an existing member of the archive.  If
+     you use the modifier `i', the name of an existing archive member
+     must be present as the RELPOS argument, before the ARCHIVE
+     specification.  (same as `b').
+
+`l'
+     This modifier is accepted but not used.
+
+`o'
+     Preserve the *original* dates of members when extracting them.  If
+     you do not specify this modifier, files extracted from the archive
+     are stamped with the time of extraction.
+
+`s'
+     Write an object-file index into the archive, or update an existing
+     one, even if no other change is made to the archive.  You may use
+     this modifier flag either with any operation, or alone.  Running
+     `ar s' on an archive is equivalent to running `ranlib' on it.
+
+`u'
+     Normally, `ar r'... inserts all files listed into the archive.  If
+     you would like to insert *only* those of the files you list that
+     are newer than existing members of the same names, use this
+     modifier.  The `u' modifier is allowed only for the operation `r'
+     (replace).  In particular, the combination `qu' is not allowed,
+     since checking the timestamps would lose any speed advantage from
+     the operation `q'.
+
+`v'
+     This modifier requests the *verbose* version of an operation.  Many
+     operations display additional information, such as filenames
+     processed, when the modifier `v' is appended.
+
+`V'
+     This modifier shows the version number of `ar'.
+
+
+File: binutils.info,  Node: ar scripts,  Prev: ar cmdline,  Up: ar
+
+Controlling `ar' with a script
+==============================
+
+     ar -M [ <SCRIPT ]
+
+   If you use the single command-line option `-M' with `ar', you can
+control its operation with a rudimentary command language.  This form
+of `ar' operates interactively if standard input is coming directly
+from a terminal.  During interactive use, `ar' prompts for input (the
+prompt is `AR >'), and continues executing even after errors.  If you
+redirect standard input to a script file, no prompts are issued, and
+`ar' abandons execution (with a nonzero exit code) on any error.
+
+   The `ar' command language is *not* designed to be equivalent to the
+command-line options; in fact, it provides somewhat less control over
+archives.  The only purpose of the command language is to ease the
+transition to GNU `ar' for developers who already have scripts written
+for the MRI "librarian" program.
+
+   The syntax for the `ar' command language is straightforward:
+   * commands are recognized in upper or lower case; for example, `LIST'
+     is the same as `list'.  In the following descriptions, commands are
+     shown in upper case for clarity.
+
+   * a single command may appear on each line; it is the first word on
+     the line.
+
+   * empty lines are allowed, and have no effect.
+
+   * comments are allowed; text after either of the characters `*' or
+     `;' is ignored.
+
+   * Whenever you use a list of names as part of the argument to an `ar'
+     command, you can separate the individual names with either commas
+     or blanks.  Commas are shown in the explanations below, for
+     clarity.
+
+   * `+' is used as a line continuation character; if `+' appears at
+     the end of a line, the text on the following line is considered
+     part of the current command.
+
+   Here are the commands you can use in `ar' scripts, or when using
+`ar' interactively.  Three of them have special significance:
+
+   `OPEN' or `CREATE' specify a "current archive", which is a temporary
+file required for most of the other commands.
+
+   `SAVE' commits the changes so far specified by the script.  Prior to
+`SAVE', commands affect only the temporary copy of the current archive.
+
+`ADDLIB ARCHIVE'
+`ADDLIB ARCHIVE (MODULE, MODULE, ... MODULE)'
+     Add all the contents of ARCHIVE (or, if specified, each named
+     MODULE from ARCHIVE) to the current archive.
+
+     Requires prior use of `OPEN' or `CREATE'.
+
+`ADDMOD MEMBER, MEMBER, ... MEMBER'
+     Add each named MEMBER as a module in the current archive.
+
+     Requires prior use of `OPEN' or `CREATE'.
+
+`CLEAR'
+     Discard the contents of the current archive, cancelling the effect
+     of any operations since the last `SAVE'.  May be executed (with no
+     effect) even if  no current archive is specified.
+
+`CREATE ARCHIVE'
+     Creates an archive, and makes it the current archive (required for
+     many other commands).  The new archive is created with a temporary
+     name; it is not actually saved as ARCHIVE until you use `SAVE'.
+     You can overwrite existing archives; similarly, the contents of any
+     existing file named ARCHIVE will not be destroyed until `SAVE'.
+
+`DELETE MODULE, MODULE, ... MODULE'
+     Delete each listed MODULE from the current archive; equivalent to
+     `ar -d ARCHIVE MODULE ... MODULE'.
+
+     Requires prior use of `OPEN' or `CREATE'.
+
+`DIRECTORY ARCHIVE (MODULE, ... MODULE)'
+`DIRECTORY ARCHIVE (MODULE, ... MODULE) OUTPUTFILE'
+     List each named MODULE present in ARCHIVE.  The separate command
+     `VERBOSE' specifies the form of the output: when verbose output is
+     off, output is like that of `ar -t ARCHIVE MODULE...'.  When
+     verbose output is on, the listing is like `ar -tv ARCHIVE
+     MODULE...'.
+
+     Output normally goes to the standard output stream; however, if you
+     specify OUTPUTFILE as a final argument, `ar' directs the output to
+     that file.
+
+`END'
+     Exit from `ar', with a `0' exit code to indicate successful
+     completion.  This command does not save the output file; if you
+     have changed the current archive since the last `SAVE' command,
+     those changes are lost.
+
+`EXTRACT MODULE, MODULE, ... MODULE'
+     Extract each named MODULE from the current archive, writing them
+     into the current directory as separate files.  Equivalent to `ar -x
+     ARCHIVE MODULE...'.
+
+     Requires prior use of `OPEN' or `CREATE'.
+
+`LIST'
+     Display full contents of the current archive, in "verbose" style
+     regardless of the state of `VERBOSE'.  The effect is like `ar tv
+     ARCHIVE').  (This single command is a GNU `ld' enhancement, rather
+     than present for MRI compatibility.)
+
+     Requires prior use of `OPEN' or `CREATE'.
+
+`OPEN ARCHIVE'
+     Opens an existing archive for use as the current archive (required
+     for many other commands).  Any changes as the result of subsequent
+     commands will not actually affect ARCHIVE until you next use
+     `SAVE'.
+
+`REPLACE MODULE, MODULE, ... MODULE'
+     In the current archive, replace each existing MODULE (named in the
+     `REPLACE' arguments) from files in the current working directory.
+     To execute this command without errors, both the file, and the
+     module in the current archive, must exist.
+
+     Requires prior use of `OPEN' or `CREATE'.
+
+`VERBOSE'
+     Toggle an internal flag governing the output from `DIRECTORY'.
+     When the flag is on, `DIRECTORY' output matches output from `ar
+     -tv '....
+
+`SAVE'
+     Commit your changes to the current archive, and actually save it
+     as a file with the name specified in the last `CREATE' or `OPEN'
+     command.
+
+     Requires prior use of `OPEN' or `CREATE'.
+
+
+File: binutils.info,  Node: nm,  Next: objcopy,  Prev: ar,  Up: Top
+
+nm
+**
+
+     nm [ -a | --debug-syms ]  [ -g | --extern-only ]
+        [ -B ]  [ -C | --demangle ] [ -D | --dynamic ]
+        [ -s | --print-armap ]  [ -A | -o | --print-file-name ]
+        [ -n | -v | --numeric-sort ]  [ -p | --no-sort ]
+        [ -r | --reverse-sort ]  [ --size-sort ] [ -u | --undefined-only ]
+        [ -t RADIX | --radix=RADIX ] [ -P | --portability ]
+        [ --target=BFDNAME ] [ -f FORMAT | --format=FORMAT ]
+        [ --defined-only ] [-l | --line-numbers ]
+        [ --no-demangle ] [ -V | --version ]  [ --help ]  [ OBJFILE... ]
+
+   GNU `nm' lists the symbols from object files OBJFILE....  If no
+object files are listed as arguments, `nm' assumes `a.out'.
+
+   For each symbol, `nm' shows:
+
+   * The symbol value, in the radix selected by options (see below), or
+     hexadecimal by default.
+
+   * The symbol type.  At least the following types are used; others
+     are, as well, depending on the object file format.  If lowercase,
+     the symbol is local; if uppercase, the symbol is global (external).
+
+    `A'
+          The symbol's value is absolute, and will not be changed by
+          further linking.
+
+    `B'
+          The symbol is in the uninitialized data section (known as
+          BSS).
+
+    `C'
+          The symbol is common.  Common symbols are uninitialized data.
+          When linking, multiple common symbols may appear with the
+          same name.  If the symbol is defined anywhere, the common
+          symbols are treated as undefined references.  For more
+          details on common symbols, see the discussion of -warn-common
+          in *Note Linker options: (ld.info)Options.
+
+    `D'
+          The symbol is in the initialized data section.
+
+    `G'
+          The symbol is in an initialized data section for small
+          objects.  Some object file formats permit more efficient
+          access to small data objects, such as a global int variable
+          as opposed to a large global array.
+
+    `I'
+          The symbol is an indirect reference to another symbol.  This
+          is a GNU extension to the a.out object file format which is
+          rarely used.
+
+    `N'
+          The symbol is a debugging symbol.
+
+    `R'
+          The symbol is in a read only data section.
+
+    `S'
+          The symbol is in an uninitialized data section for small
+          objects.
+
+    `T'
+          The symbol is in the text (code) section.
+
+    `U'
+          The symbol is undefined.
+
+    `W'
+          The symbol is weak.  When a weak defined symbol is linked
+          with a normal defined symbol, the normal defined symbol is
+          used with no error.  When a weak undefined symbol is linked
+          and the symbol is not defined, the value of the weak symbol
+          becomes zero with no error.
+
+    `-'
+          The symbol is a stabs symbol in an a.out object file.  In
+          this case, the next values printed are the stabs other field,
+          the stabs desc field, and the stab type.  Stabs symbols are
+          used to hold debugging information; for more information, see
+          *Note Stabs: (stabs.info)Top.
+
+    `?'
+          The symbol type is unknown, or object file format specific.
+
+   * The symbol name.
+
+   The long and short forms of options, shown here as alternatives, are
+equivalent.
+
+`-A'
+`-o'
+`--print-file-name'
+     Precede each symbol by the name of the input file (or archive
+     element) in which it was found, rather than identifying the input
+     file once only, before all of its symbols.
+
+`-a'
+`--debug-syms'
+     Display all symbols, even debugger-only symbols; normally these
+     are not listed.
+
+`-B'
+     The same as `--format=bsd' (for compatibility with the MIPS `nm').
+
+`-C'
+`--demangle'
+     Decode ("demangle") low-level symbol names into user-level names.
+     Besides removing any initial underscore prepended by the system,
+     this makes C++ function names readable.  *Note c++filt::, for more
+     information on demangling.
+
+`--no-demangle'
+     Do not demangle low-level symbol names.  This is the default.
+
+`-D'
+`--dynamic'
+     Display the dynamic symbols rather than the normal symbols.  This
+     is only meaningful for dynamic objects, such as certain types of
+     shared libraries.
+
+`-f FORMAT'
+`--format=FORMAT'
+     Use the output format FORMAT, which can be `bsd', `sysv', or
+     `posix'.  The default is `bsd'.  Only the first character of
+     FORMAT is significant; it can be either upper or lower case.
+
+`-g'
+`--extern-only'
+     Display only external symbols.
+
+`-l'
+`--line-numbers'
+     For each symbol, use debugging information to try to find a
+     filename and line number.  For a defined symbol, look for the line
+     number of the address of the symbol.  For an undefined symbol,
+     look for the line number of a relocation entry which refers to the
+     symbol.  If line number information can be found, print it after
+     the other symbol information.
+
+`-n'
+`-v'
+`--numeric-sort'
+     Sort symbols numerically by their addresses, rather than
+     alphabetically by their names.
+
+`-p'
+`--no-sort'
+     Do not bother to sort the symbols in any order; print them in the
+     order encountered.
+
+`-P'
+`--portability'
+     Use the POSIX.2 standard output format instead of the default
+     format.  Equivalent to `-f posix'.
+
+`-s'
+`--print-armap'
+     When listing symbols from archive members, include the index: a
+     mapping (stored in the archive by `ar' or `ranlib') of which
+     modules contain definitions for which names.
+
+`-r'
+`--reverse-sort'
+     Reverse the order of the sort (whether numeric or alphabetic); let
+     the last come first.
+
+`--size-sort'
+     Sort symbols by size.  The size is computed as the difference
+     between the value of the symbol and the value of the symbol with
+     the next higher value.  The size of the symbol is printed, rather
+     than the value.
+
+`-t RADIX'
+`--radix=RADIX'
+     Use RADIX as the radix for printing the symbol values.  It must be
+     `d' for decimal, `o' for octal, or `x' for hexadecimal.
+
+`--target=BFDNAME'
+     Specify an object code format other than your system's default
+     format.  *Note Target Selection::, for more information.
+
+`-u'
+`--undefined-only'
+     Display only undefined symbols (those external to each object
+     file).
+
+`--defined-only'
+     Display only defined symbols for each object file.
+
+`-V'
+`--version'
+     Show the version number of `nm' and exit.
+
+`--help'
+     Show a summary of the options to `nm' and exit.
+
+
+File: binutils.info,  Node: objcopy,  Next: objdump,  Prev: nm,  Up: Top
+
+objcopy
+*******
+
+     objcopy [ -F BFDNAME | --target=BFDNAME ]
+             [ -I BFDNAME | --input-target=BFDNAME ]
+             [ -O BFDNAME | --output-target=BFDNAME ]
+             [ -S | --strip-all ]  [ -g | --strip-debug ]
+             [ -K SYMBOLNAME | --keep-symbol=SYMBOLNAME ]
+             [ -N SYMBOLNAME | --strip-symbol=SYMBOLNAME ]
+             [ -x | --discard-all ]  [ -X | --discard-locals ]
+             [ -b BYTE | --byte=BYTE ]
+             [ -i INTERLEAVE | --interleave=INTERLEAVE ]
+             [ -R SECTIONNAME | --remove-section=SECTIONNAME ]
+             [ -p | --preserve-dates ] [ --debugging ]
+             [ --gap-fill=VAL ] [ --pad-to=ADDRESS ]
+             [ --set-start=VAL ] [ --adjust-start=INCR ]
+             [ --adjust-vma=INCR ]
+             [ --adjust-section-vma=SECTION{=,+,-}VAL ]
+             [ --adjust-warnings ] [ --no-adjust-warnings ]
+             [ --set-section-flags=SECTION=FLAGS ]
+             [ --add-section=SECTIONNAME=FILENAME ]
+             [ --change-leading-char ] [ --remove-leading-char ]
+             [ --weaken ]
+             [ -v | --verbose ] [ -V | --version ]  [ --help ]
+             INFILE [OUTFILE]
+
+   The GNU `objcopy' utility copies the contents of an object file to
+another.  `objcopy' uses the GNU BFD Library to read and write the
+object files.  It can write the destination object file in a format
+different from that of the source object file.  The exact behavior of
+`objcopy' is controlled by command-line options.
+
+   `objcopy' creates temporary files to do its translations and deletes
+them afterward.  `objcopy' uses BFD to do all its translation work; it
+has access to all the formats described in BFD and thus is able to
+recognize most formats without being told explicitly.  *Note BFD:
+(ld.info)BFD.
+
+   `objcopy' can be used to generate S-records by using an output
+target of `srec' (e.g., use `-O srec').
+
+   `objcopy' can be used to generate a raw binary file by using an
+output target of `binary' (e.g., use `-O binary').  When `objcopy'
+generates a raw binary file, it will essentially produce a memory dump
+of the contents of the input object file.  All symbols and relocation
+information will be discarded.  The memory dump will start at the load
+address of the lowest section copied into the output file.
+
+   When generating an S-record or a raw binary file, it may be helpful
+to use `-S' to remove sections containing debugging information.  In
+some cases `-R' will be useful to remove sections which contain
+information which is not needed by the binary file.
+
+`INFILE'
+`OUTFILE'
+     The source and output files, respectively.  If you do not specify
+     OUTFILE, `objcopy' creates a temporary file and destructively
+     renames the result with the name of INFILE.
+
+`-I BFDNAME'
+`--input-target=BFDNAME'
+     Consider the source file's object format to be BFDNAME, rather than
+     attempting to deduce it.  *Note Target Selection::, for more
+     information.
+
+`-O BFDNAME'
+`--output-target=BFDNAME'
+     Write the output file using the object format BFDNAME.  *Note
+     Target Selection::, for more information.
+
+`-F BFDNAME'
+`--target=BFDNAME'
+     Use BFDNAME as the object format for both the input and the output
+     file; i.e., simply transfer data from source to destination with no
+     translation.  *Note Target Selection::, for more information.
+
+`-R SECTIONNAME'
+`--remove-section=SECTIONNAME'
+     Remove any section named SECTIONNAME from the output file.  This
+     option may be given more than once.  Note that using this option
+     inappropriately may make the output file unusable.
+
+`-S'
+`--strip-all'
+     Do not copy relocation and symbol information from the source file.
+
+`-g'
+`--strip-debug'
+     Do not copy debugging symbols from the source file.
+
+`--strip-unneeded'
+     Strip all symbols that are not needed for relocation processing.
+
+`-K SYMBOLNAME'
+`--keep-symbol=SYMBOLNAME'
+     Copy only symbol SYMBOLNAME from the source file.  This option may
+     be given more than once.
+
+`-N SYMBOLNAME'
+`--strip-symbol=SYMBOLNAME'
+     Do not copy symbol SYMBOLNAME from the source file.  This option
+     may be given more than once, and may be combined with strip options
+     other than `-K'.
+
+`-x'
+`--discard-all'
+     Do not copy non-global symbols from the source file.
+
+`-X'
+`--discard-locals'
+     Do not copy compiler-generated local symbols.  (These usually
+     start with `L' or `.'.)
+
+`-b BYTE'
+`--byte=BYTE'
+     Keep only every BYTEth byte of the input file (header data is not
+     affected).  BYTE can be in the range from 0 to INTERLEAVE-1, where
+     INTERLEAVE is given by the `-i' or `--interleave' option, or the
+     default of 4.  This option is useful for creating files to program
+     ROM.  It is typically used with an `srec' output target.
+
+`-i INTERLEAVE'
+`--interleave=INTERLEAVE'
+     Only copy one out of every INTERLEAVE bytes.  Select which byte to
+     copy with the -B or `--byte' option.  The default is 4.  `objcopy'
+     ignores this option if you do not specify either `-b' or `--byte'.
+
+`-p'
+`--preserve-dates'
+     Set the access and modification dates of the output file to be the
+     same as those of the input file.
+
+`--debugging'
+     Convert debugging information, if possible.  This is not the
+     default because only certain debugging formats are supported, and
+     the conversion process can be time consuming.
+
+`--gap-fill VAL'
+     Fill gaps between sections with VAL.  This is done by increasing
+     the size of the section with the lower address, and filling in the
+     extra space created with VAL.
+
+`--pad-to ADDRESS'
+     Pad the output file up to the virtual address ADDRESS.  This is
+     done by increasing the size of the last section.  The extra space
+     is filled in with the value specified by `--gap-fill' (default
+     zero).
+
+`--set-start VAL'
+     Set the address of the new file to VAL.  Not all object file
+     formats support setting the start address.
+
+`--adjust-start INCR'
+     Adjust the start address by adding INCR.  Not all object file
+     formats support setting the start address.
+
+`--adjust-vma INCR'
+     Adjust the address of all sections, as well as the start address,
+     by adding INCR.  Some object file formats do not permit section
+     addresses to be changed arbitrarily.  Note that this does not
+     relocate the sections; if the program expects sections to be
+     loaded at a certain address, and this option is used to change the
+     sections such that they are loaded at a different address, the
+     program may fail.
+
+`--adjust-section-vma SECTION{=,+,-}VAL'
+     Set or adjust the address of the named SECTION.  If `=' is used,
+     the section address is set to VAL.  Otherwise, VAL is added to or
+     subtracted from the section address.  See the comments under
+     `--adjust-vma', above.  If SECTION does not exist in the input
+     file, a warning will be issued, unless `--no-adjust-warnings' is
+     used.
+
+`--adjust-warnings'
+     If `--adjust-section-vma' is used, and the named section does not
+     exist, issue a warning.  This is the default.
+
+`--no-adjust-warnings'
+     Do not issue a warning if `--adjust-section-vma' is used, even if
+     the named section does not exist.
+
+`--set-section-flags SECTION=FLAGS'
+     Set the flags for the named section.  The FLAGS argument is a
+     comma separated string of flag names.  The recognized names are
+     `alloc', `load', `readonly', `code', `data', and `rom'.  Not all
+     flags are meaningful for all object file formats.
+
+`--add-section SECTIONNAME=FILENAME'
+     Add a new section named SECTIONNAME while copying the file.  The
+     contents of the new section are taken from the file FILENAME.  The
+     size of the section will be the size of the file.  This option only
+     works on file formats which can support sections with arbitrary
+     names.
+
+`--change-leading-char'
+     Some object file formats use special characters at the start of
+     symbols.  The most common such character is underscore, which
+     compilers often add before every symbol.  This option tells
+     `objcopy' to change the leading character of every symbol when it
+     converts between object file formats.  If the object file formats
+     use the same leading character, this option has no effect.
+     Otherwise, it will add a character, or remove a character, or
+     change a character, as appropriate.
+
+`--remove-leading-char'
+     If the first character of a global symbol is a special symbol
+     leading character used by the object file format, remove the
+     character.  The most common symbol leading character is
+     underscore.  This option will remove a leading underscore from all
+     global symbols.  This can be useful if you want to link together
+     objects of different file formats with different conventions for
+     symbol names.  This is different from `--change-leading-char'
+     because it always changes the symbol name when appropriate,
+     regardless of the object file format of the output file.
+
+`--weaken'
+     Change all global symbols in the file to be weak.  This can be
+     useful when building an object which will be linked against other
+     objects using the `-R' option to the linker.  This option is only
+     effective when using an object file format which supports weak
+     symbols.
+
+`-V'
+`--version'
+     Show the version number of `objcopy'.
+
+`-v'
+`--verbose'
+     Verbose output: list all object files modified.  In the case of
+     archives, `objcopy -V' lists all members of the archive.
+
+`--help'
+     Show a summary of the options to `objcopy'.
+
+
+File: binutils.info,  Node: objdump,  Next: ranlib,  Prev: objcopy,  Up: Top
+
+objdump
+*******
+
+     objdump [ -a | --archive-headers ]
+             [ -b BFDNAME | --target=BFDNAME ] [ --debugging ]
+             [ -C | --demangle ] [ -d | --disassemble ]
+             [ -D | --disassemble-all ] [ --disassemble-zeroes ]
+             [ -EB | -EL | --endian={big | little } ]
+             [ -f | --file-headers ]
+             [ -h | --section-headers | --headers ]  [ -i | --info ]
+             [ -j SECTION | --section=SECTION ]
+             [ -l | --line-numbers ] [ -S | --source ]
+             [ -m MACHINE | --architecture=MACHINE ]
+             [ -r | --reloc ] [ -R | --dynamic-reloc ]
+             [ -s | --full-contents ]  [ --stabs ]
+             [ -t | --syms ] [ -T | --dynamic-syms ] [ -x | --all-headers ]
+             [ -w | --wide ] [ --start-address=ADDRESS ]
+             [ --stop-address=ADDRESS ]
+             [ --prefix-addresses] [ --[no-]show-raw-insn ]
+             [ --adjust-vma=OFFSET ]
+             [ --version ]  [ --help ]
+             OBJFILE...
+
+   `objdump' displays information about one or more object files.  The
+options control what particular information to display.  This
+information is mostly useful to programmers who are working on the
+compilation tools, as opposed to programmers who just want their
+program to compile and work.
+
+   OBJFILE... are the object files to be examined.  When you specify
+archives, `objdump' shows information on each of the member object
+files.
+
+   The long and short forms of options, shown here as alternatives, are
+equivalent.  At least one option besides `-l' must be given.
+
+`-a'
+`--archive-header'
+     If any of the OBJFILE files are archives, display the archive
+     header information (in a format similar to `ls -l').  Besides the
+     information you could list with `ar tv', `objdump -a' shows the
+     object file format of each archive member.
+
+`--adjust-vma=OFFSET'
+     When dumping information, first add OFFSET to all the section
+     addresses.  This is useful if the section addresses do not
+     correspond to the symbol table, which can happen when putting
+     sections at particular addresses when using a format which can not
+     represent section addresses, such as a.out.
+
+`-b BFDNAME'
+`--target=BFDNAME'
+     Specify that the object-code format for the object files is
+     BFDNAME.  This option may not be necessary; OBJDUMP can
+     automatically recognize many formats.
+
+     For example,
+          objdump -b oasys -m vax -h fu.o
+
+     displays summary information from the section headers (`-h') of
+     `fu.o', which is explicitly identified (`-m') as a VAX object file
+     in the format produced by Oasys compilers.  You can list the
+     formats available with the `-i' option.  *Note Target Selection::,
+     for more information.
+
+`-C'
+`--demangle'
+     Decode ("demangle") low-level symbol names into user-level names.
+     Besides removing any initial underscore prepended by the system,
+     this makes C++ function names readable.  *Note c++filt::, for more
+     information on demangling.
+
+`--debugging'
+     Display debugging information.  This attempts to parse debugging
+     information stored in the file and print it out using a C like
+     syntax.  Only certain types of debugging information have been
+     implemented.
+
+`-d'
+`--disassemble'
+     Display the assembler mnemonics for the machine instructions from
+     OBJFILE.  This option only disassembles those sections which are
+     expected to contain instructions.
+
+`-D'
+`--disassemble-all'
+     Like `-d', but disassemble the contents of all sections, not just
+     those expected to contain instructions.
+
+`--prefix-addresses'
+     When disassembling, print the complete address on each line.  This
+     is the older disassembly format.
+
+`--disassemble-zeroes'
+     Normally the disassembly output will skip blocks of zeroes.  This
+     option directs the disassembler to disassemble those blocks, just
+     like any other data.
+
+`-EB'
+`-EL'
+`--endian={big|little}'
+     Specify the endianness of the object files.  This only affects
+     disassembly.  This can be useful when disassembling a file format
+     which does not describe endianness information, such as S-records.
+
+`-f'
+`--file-header'
+     Display summary information from the overall header of each of the
+     OBJFILE files.
+
+`-h'
+`--section-header'
+`--header'
+     Display summary information from the section headers of the object
+     file.
+
+     File segments may be relocated to nonstandard addresses, for
+     example by using the `-Ttext', `-Tdata', or `-Tbss' options to
+     `ld'.  However, some object file formats, such as a.out, do not
+     store the starting address of the file segments.  In those
+     situations, although `ld' relocates the sections correctly, using
+     `objdump -h' to list the file section headers cannot show the
+     correct addresses.  Instead, it shows the usual addresses, which
+     are implicit for the target.
+
+`--help'
+     Print a summary of the options to `objdump' and exit.
+
+`-i'
+`--info'
+     Display a list showing all architectures and object formats
+     available for specification with `-b' or `-m'.
+
+`-j NAME'
+`--section=NAME'
+     Display information only for section NAME.
+
+`-l'
+`--line-numbers'
+     Label the display (using debugging information) with the filename
+     and source line numbers corresponding to the object code or relocs
+     shown.  Only useful with `-d', `-D', or `-r'.
+
+`-m MACHINE'
+`--architecture=MACHINE'
+     Specify the architecture to use when disassembling object files.
+     This can be useful when disasembling object files which do not
+     describe architecture information, such as S-records.  You can
+     list the available architectures with the `-i' option.
+
+`-r'
+`--reloc'
+     Print the relocation entries of the file.  If used with `-d' or
+     `-D', the relocations are printed interspersed with the
+     disassembly.
+
+`-R'
+`--dynamic-reloc'
+     Print the dynamic relocation entries of the file.  This is only
+     meaningful for dynamic objects, such as certain types of shared
+     libraries.
+
+`-s'
+`--full-contents'
+     Display the full contents of any sections requested.
+
+`-S'
+`--source'
+     Display source code intermixed with disassembly, if possible.
+     Implies `-d'.
+
+`--show-raw-insn'
+     When disassembling instructions, print the instruction in hex as
+     well as in symbolic form.  This is the default except when
+     `--prefix-addresses' is used.
+
+`--no-show-raw-insn'
+     When disassembling instructions, do not print the instruction
+     bytes.  This is the default when `--prefix-addresses' is used.
+
+`--stabs'
+     Display the full contents of any sections requested.  Display the
+     contents of the .stab and .stab.index and .stab.excl sections from
+     an ELF file.  This is only useful on systems (such as Solaris 2.0)
+     in which `.stab' debugging symbol-table entries are carried in an
+     ELF section.  In most other file formats, debugging symbol-table
+     entries are interleaved with linkage symbols, and are visible in
+     the `--syms' output.  For more information on stabs symbols, see
+     *Note Stabs: (stabs.info)Top.
+
+`--start-address=ADDRESS'
+     Start displaying data at the specified address.  This affects the
+     output of the `-d', `-r' and `-s' options.
+
+`--stop-address=ADDRESS'
+     Stop displaying data at the specified address.  This affects the
+     output of the `-d', `-r' and `-s' options.
+
+`-t'
+`--syms'
+     Print the symbol table entries of the file.  This is similar to
+     the information provided by the `nm' program.
+
+`-T'
+`--dynamic-syms'
+     Print the dynamic symbol table entries of the file.  This is only
+     meaningful for dynamic objects, such as certain types of shared
+     libraries.  This is similar to the information provided by the `nm'
+     program when given the `-D' (`--dynamic') option.
+
+`--version'
+     Print the version number of `objdump' and exit.
+
+`-x'
+`--all-header'
+     Display all available header information, including the symbol
+     table and relocation entries.  Using `-x' is equivalent to
+     specifying all of `-a -f -h -r -t'.
+
+`-w'
+`--wide'
+     Format some lines for output devices that have more than 80
+     columns.
+
+
+File: binutils.info,  Node: ranlib,  Next: size,  Prev: objdump,  Up: Top
+
+ranlib
+******
+
+     ranlib [-vV] ARCHIVE
+
+   `ranlib' generates an index to the contents of an archive and stores
+it in the archive.  The index lists each symbol defined by a member of
+an archive that is a relocatable object file.
+
+   You may use `nm -s' or `nm --print-armap' to list this index.
+
+   An archive with such an index speeds up linking to the library and
+allows routines in the library to call each other without regard to
+their placement in the archive.
+
+   The GNU `ranlib' program is another form of GNU `ar'; running
+`ranlib' is completely equivalent to executing `ar -s'.  *Note ar::.
+
+`-v'
+`-V'
+     Show the version number of `ranlib'.
+
+
+File: binutils.info,  Node: size,  Next: strings,  Prev: ranlib,  Up: Top
+
+size
+****
+
+     size [ -A | -B | --format=COMPATIBILITY ]
+          [ --help ]  [ -d | -o | -x | --radix=NUMBER ]
+          [ --target=BFDNAME ]  [ -V | --version ]
+          OBJFILE...
+
+   The GNU `size' utility lists the section sizes--and the total
+size--for each of the object or archive files OBJFILE in its argument
+list.  By default, one line of output is generated for each object file
+or each module in an archive.
+
+   OBJFILE... are the object files to be examined.
+
+   The command line options have the following meanings:
+
+`-A'
+`-B'
+`--format=COMPATIBILITY'
+     Using one of these options, you can choose whether the output from
+     GNU `size' resembles output from System V `size' (using `-A', or
+     `--format=sysv'), or Berkeley `size' (using `-B', or
+     `--format=berkeley').  The default is the one-line format similar
+     to Berkeley's.
+
+     Here is an example of the Berkeley (default) format of output from
+     `size':
+          size --format=Berkeley ranlib size
+          text    data    bss     dec     hex     filename
+          294880  81920   11592   388392  5ed28   ranlib
+          294880  81920   11888   388688  5ee50   size
+
+     This is the same data, but displayed closer to System V
+     conventions:
+
+          size --format=SysV ranlib size
+          ranlib  :
+          section         size         addr
+          .text         294880         8192
+          .data          81920       303104
+          .bss           11592       385024
+          Total         388392
+          
+          
+          size  :
+          section         size         addr
+          .text         294880         8192
+          .data          81920       303104
+          .bss           11888       385024
+          Total         388688
+
+`--help'
+     Show a summary of acceptable arguments and options.
+
+`-d'
+`-o'
+`-x'
+`--radix=NUMBER'
+     Using one of these options, you can control whether the size of
+     each section is given in decimal (`-d', or `--radix=10'); octal
+     (`-o', or `--radix=8'); or hexadecimal (`-x', or `--radix=16').
+     In `--radix=NUMBER', only the three values (8, 10, 16) are
+     supported.  The total size is always given in two radices; decimal
+     and hexadecimal for `-d' or `-x' output, or octal and hexadecimal
+     if you're using `-o'.
+
+`--target=BFDNAME'
+     Specify that the object-code format for OBJFILE is BFDNAME.  This
+     option may not be necessary; `size' can automatically recognize
+     many formats.  *Note Target Selection::, for more information.
+
+`-V'
+`--version'
+     Display the version number of `size'.
+
+
+File: binutils.info,  Node: strings,  Next: strip,  Prev: size,  Up: Top
+
+strings
+*******
+
+     strings [-afov] [-MIN-LEN] [-n MIN-LEN] [-t RADIX] [-]
+             [--all] [--print-file-name] [--bytes=MIN-LEN]
+             [--radix=RADIX] [--target=BFDNAME]
+             [--help] [--version] FILE...
+
+   For each FILE given, GNU `strings' prints the printable character
+sequences that are at least 4 characters long (or the number given with
+the options below) and are followed by an unprintable character.  By
+default, it only prints the strings from the initialized and loaded
+sections of object files; for other types of files, it prints the
+strings from the whole file.
+
+   `strings' is mainly useful for determining the contents of non-text
+files.
+
+`-a'
+`--all'
+`-'
+     Do not scan only the initialized and loaded sections of object
+     files; scan the whole files.
+
+`-f'
+`--print-file-name'
+     Print the name of the file before each string.
+
+`--help'
+     Print a summary of the program usage on the standard output and
+     exit.
+
+`-MIN-LEN'
+`-n MIN-LEN'
+`--bytes=MIN-LEN'
+     Print sequences of characters that are at least MIN-LEN characters
+     long, instead of the default 4.
+
+`-o'
+     Like `-t o'.  Some other versions of `strings' have `-o' act like
+     `-t d' instead.  Since we can not be compatible with both ways, we
+     simply chose one.
+
+`-t RADIX'
+`--radix=RADIX'
+     Print the offset within the file before each string.  The single
+     character argument specifies the radix of the offset--`o' for
+     octal, `x' for hexadecimal, or `d' for decimal.
+
+`--target=BFDNAME'
+     Specify an object code format other than your system's default
+     format.  *Note Target Selection::, for more information.
+
+`-v'
+`--version'
+     Print the program version number on the standard output and exit.
+
+
+File: binutils.info,  Node: strip,  Next: c++filt,  Prev: strings,  Up: Top
+
+strip
+*****
+
+     strip [ -F BFDNAME | --target=BFDNAME | --target=BFDNAME ]
+           [ -I BFDNAME | --input-target=BFDNAME ]
+           [ -O BFDNAME | --output-target=BFDNAME ]
+           [ -s | --strip-all ] [ -S | -g | --strip-debug ]
+           [ -K SYMBOLNAME | --keep-symbol=SYMBOLNAME ]
+           [ -N SYMBOLNAME | --strip-symbol=SYMBOLNAME ]
+           [ -x | --discard-all ] [ -X | --discard-locals ]
+           [ -R SECTIONNAME | --remove-section=SECTIONNAME ]
+           [ -o FILE ] [ -p | --preserve-dates ]
+           [ -v | --verbose ]  [ -V | --version ]  [ --help ]
+           OBJFILE...
+
+   GNU `strip' discards all symbols from object files OBJFILE.  The
+list of object files may include archives.  At least one object file
+must be given.
+
+   `strip' modifies the files named in its argument, rather than
+writing modified copies under different names.
+
+`-F BFDNAME'
+`--target=BFDNAME'
+     Treat the original OBJFILE as a file with the object code format
+     BFDNAME, and rewrite it in the same format.  *Note Target
+     Selection::, for more information.
+
+`--help'
+     Show a summary of the options to `strip' and exit.
+
+`-I BFDNAME'
+`--input-target=BFDNAME'
+     Treat the original OBJFILE as a file with the object code format
+     BFDNAME.  *Note Target Selection::, for more information.
+
+`-O BFDNAME'
+`--output-target=BFDNAME'
+     Replace OBJFILE with a file in the output format BFDNAME.  *Note
+     Target Selection::, for more information.
+
+`-R SECTIONNAME'
+`--remove-section=SECTIONNAME'
+     Remove any section named SECTIONNAME from the output file.  This
+     option may be given more than once.  Note that using this option
+     inappropriately may make the output file unusable.
+
+`-s'
+`--strip-all'
+     Remove all symbols.
+
+`-g'
+`-S'
+`--strip-debug'
+     Remove debugging symbols only.
+
+`--strip-unneeded'
+     Remove all symbols that are not needed for relocation processing.
+
+`-K SYMBOLNAME'
+`--keep-symbol=SYMBOLNAME'
+     Keep only symbol SYMBOLNAME from the source file.  This option may
+     be given more than once.
+
+`-N SYMBOLNAME'
+`--strip-symbol=SYMBOLNAME'
+     Remove symbol SYMBOLNAME from the source file. This option may be
+     given more than once, and may be combined with strip options other
+     than `-K'.
+
+`-o FILE'
+     Put the stripped output in FILE, rather than replacing the
+     existing file.  When this argument is used, only one OBJFILE
+     argument may be specified.
+
+`-p'
+`--preserve-dates'
+     Preserve the access and modification dates of the file.
+
+`-x'
+`--discard-all'
+     Remove non-global symbols.
+
+`-X'
+`--discard-locals'
+     Remove compiler-generated local symbols.  (These usually start
+     with `L' or `.'.)
+
+`-V'
+`--version'
+     Show the version number for `strip'.
+
+`-v'
+`--verbose'
+     Verbose output: list all object files modified.  In the case of
+     archives, `strip -v' lists all members of the archive.
+
diff --git a/gnu/usr.bin/binutils/binutils/binutils.info-2 b/gnu/usr.bin/binutils/binutils/binutils.info-2
new file mode 100644
index 00000000000..4adbdd5944c
--- /dev/null
+++ b/gnu/usr.bin/binutils/binutils/binutils.info-2
@@ -0,0 +1,771 @@
+This is Info file binutils.info, produced by Makeinfo-1.64 from the
+input file ./binutils.texi.
+
+START-INFO-DIR-ENTRY
+* Binutils: (binutils).         The GNU binary utilities "ar", "objcopy",
+				"objdump", "nm", "nlmconv", "size",
+                                "strings", "strip", and "ranlib".
+END-INFO-DIR-ENTRY
+
+   Copyright (C) 1991, 92, 93, 94, 95, 96, 1997 Free Software
+Foundation, Inc.
+
+   Permission is granted to make and distribute verbatim copies of this
+manual provided the copyright notice and this permission notice are
+preserved on all copies.
+
+   Permission is granted to copy and distribute modified versions of
+this manual under the conditions for verbatim copying, provided also
+that the entire resulting derived work is distributed under the terms
+of a permission notice identical to this one.
+
+   Permission is granted to copy and distribute translations of this
+manual into another language, under the above conditions for modified
+versions.
+
+
+File: binutils.info,  Node: c++filt,  Next: addr2line,  Prev: strip,  Up: Top
+
+c++filt
+*******
+
+     c++filt [ -_ | --strip-underscores ]
+     	[ -n | --no-strip-underscores ]
+             [ -s FORMAT | --format=FORMAT ]
+             [ --help ]  [ --version ]  [ SYMBOL... ]
+
+   The C++ language provides function overloading, which means that you
+can write many functions with the same name (providing each takes
+parameters of different types).  All C++ function names are encoded
+into a low-level assembly label (this process is known as "mangling").
+The `c++filt' program does the inverse mapping: it decodes
+("demangles") low-level names into user-level names so that the linker
+can keep these overloaded functions from clashing.
+
+   Every alphanumeric word (consisting of letters, digits, underscores,
+dollars, or periods) seen in the input is a potential label.  If the
+label decodes into a C++ name, the C++ name replaces the low-level name
+in the output.
+
+   You can use `c++filt' to decipher individual symbols:
+
+     c++filt SYMBOL
+
+   If no SYMBOL arguments are given, `c++filt' reads symbol names from
+the standard input and writes the demangled names to the standard
+output.  All results are printed on the standard output.
+
+`-_'
+`--strip-underscores'
+     On some systems, both the C and C++ compilers put an underscore in
+     front of every name.  For example, the C name `foo' gets the
+     low-level name `_foo'.  This option removes the initial
+     underscore.  Whether `c++filt' removes the underscore by default
+     is target dependent.
+
+`-n'
+`--no-strip-underscores'
+     Do not remove the initial underscore.
+
+`-s FORMAT'
+`--format=FORMAT'
+     GNU `nm' can decode three different methods of mangling, used by
+     different C++ compilers.  The argument to this option selects which
+     method it uses:
+
+    `gnu'
+          the one used by the GNU compiler (the default method)
+
+    `lucid'
+          the one used by the Lucid compiler
+
+    `arm'
+          the one specified by the C++ Annotated Reference Manual
+
+`--help'
+     Print a summary of the options to `c++filt' and exit.
+
+`--version'
+     Print the version number of `c++filt' and exit.
+
+     *Warning:* `c++filt' is a new utility, and the details of its user
+     interface are subject to change in future releases.  In particular,
+     a command-line option may be required in the the future to decode
+     a name passed as an argument on the command line; in other words,
+
+          c++filt SYMBOL
+
+     may in a future release become
+
+          c++filt OPTION SYMBOL
+
+
+File: binutils.info,  Node: addr2line,  Next: nlmconv,  Prev: c++filt,  Up: Top
+
+addr2line
+*********
+
+     addr2line [ -b BFDNAME | --target=BFDNAME ]
+               [ -C | --demangle ]
+               [ -e FILENAME | --exe=FILENAME ]
+               [ -f | --functions ] [ -s | --basename ]
+               [ -H | --help ] [ -V | --version ]
+               [ addr addr ... ]
+
+   `addr2line' translates program addresses into file names and line
+numbers.  Given an address and an executable, it uses the debugging
+information in the executable to figure out which file name and line
+number are associated with a given address.
+
+   The executable to use is specified with the `-e' option.  The
+default is `a.out'.
+
+   `addr2line' has two modes of operation.
+
+   In the first, hexadecimal addresses are specified on the command
+line, and `addr2line' displays the file name and line number for each
+address.
+
+   In the second, `addr2line' reads hexadecimal addresses from standard
+input, and prints the file name and line number for each address on
+standard output.  In this mode, `addr2line' may be used in a pipe to
+convert dynamically chosen addresses.
+
+   The format of the output is `FILENAME:LINENO'.  The file name and
+line number for each address is printed on a separate line.  If the
+`-f' option is used, then each `FILENAME:LINENO' line is preceded by a
+`FUNCTIONNAME' line which is the name of the function containing the
+address.
+
+   If the file name or function name can not be determined, `addr2line'
+will print two question marks in their place.  If the line number can
+not be determined, `addr2line' will print 0.
+
+   The long and short forms of options, shown here as alternatives, are
+equivalent.
+
+`-b BFDNAME'
+`--target=BFDNAME'
+     Specify that the object-code format for the object files is
+     BFDNAME.
+
+`-C'
+`--demangle'
+     Decode ("demangle") low-level symbol names into user-level names.
+     Besides removing any initial underscore prepended by the system,
+     this makes C++ function names readable.  *Note c++filt::, for more
+     information on demangling.
+
+`-e FILENAME'
+`--exe=FILENAME'
+     Specify the name of the executable for which addresses should be
+     translated.  The default file is `a.out'.
+
+`-f'
+`--functions'
+     Display function names as well as file and line number information.
+
+`-s'
+`--basenames'
+     Display only the base of each file name.
+
+
+File: binutils.info,  Node: nlmconv,  Next: Selecting The Target System,  Prev: addr2line,  Up: Top
+
+nlmconv
+*******
+
+   `nlmconv' converts a relocatable object file into a NetWare Loadable
+Module.
+
+     *Warning:* `nlmconv' is not always built as part of the binary
+     utilities, since it is only useful for NLM targets.
+
+     nlmconv [ -I BFDNAME | --input-target=BFDNAME ]
+             [ -O BFDNAME | --output-target=BFDNAME ]
+             [ -T HEADERFILE | --header-file=HEADERFILE ]
+             [ -d | --debug]  [ -l LINKER | --linker=LINKER ]
+             [ -h | --help ]  [ -V | --version ]
+             INFILE OUTFILE
+
+   `nlmconv' converts the relocatable `i386' object file INFILE into
+the NetWare Loadable Module OUTFILE, optionally reading HEADERFILE for
+NLM header information.  For instructions on writing the NLM command
+file language used in header files, see the `linkers' section,
+`NLMLINK' in particular, of the `NLM Development and Tools Overview',
+which is part of the NLM Software Developer's Kit ("NLM SDK"),
+available from Novell, Inc.  `nlmconv' uses the GNU Binary File
+Descriptor library to read INFILE; see *Note BFD: (ld.info)BFD, for
+more information.
+
+   `nlmconv' can perform a link step.  In other words, you can list
+more than one object file for input if you list them in the definitions
+file (rather than simply specifying one input file on the command line).
+In this case, `nlmconv' calls the linker for you.
+
+`-I BFDNAME'
+`--input-target=BFDNAME'
+     Object format of the input file.  `nlmconv' can usually determine
+     the format of a given file (so no default is necessary).  *Note
+     Target Selection::, for more information.
+
+`-O BFDNAME'
+`--output-target=BFDNAME'
+     Object format of the output file.  `nlmconv' infers the output
+     format based on the input format, e.g. for a `i386' input file the
+     output format is `nlm32-i386'.  *Note Target Selection::, for more
+     information.
+
+`-T HEADERFILE'
+`--header-file=HEADERFILE'
+     Reads HEADERFILE for NLM header information.  For instructions on
+     writing the NLM command file language used in header files, see
+     see the `linkers' section, of the `NLM Development and Tools
+     Overview', which is part of the NLM Software Developer's Kit,
+     available from Novell, Inc.
+
+`-d'
+`--debug'
+     Displays (on standard error) the linker command line used by
+     `nlmconv'.
+
+`-l LINKER'
+`--linker=LINKER'
+     Use LINKER for any linking.  LINKER can be an abosolute or a
+     relative pathname.
+
+`-h'
+`--help'
+     Prints a usage summary.
+
+`-V'
+`--version'
+     Prints the version number for `nlmconv'.
+
+
+File: binutils.info,  Node: Selecting The Target System,  Next: Reporting Bugs,  Prev: nlmconv,  Up: Top
+
+Selecting the target system
+***************************
+
+   You can specify three aspects of the target system to the GNU binary
+file utilities, each in several ways:
+
+   * the target
+
+   * the architecture
+
+   * the linker emulation (which applies to the linker only)
+
+   In the following summaries, the lists of ways to specify values are
+in order of decreasing precedence.  The ways listed first override those
+listed later.
+
+   The commands to list valid values only list the values for which the
+programs you are running were configured.  If they were configured with
+`--enable-targets=all', the commands list most of the available values,
+but a few are left out; not all targets can be configured in at once
+because some of them can only be configured "native" (on hosts with the
+same type as the target system).
+
+* Menu:
+
+* Target Selection::
+* Architecture Selection::
+* Linker Emulation Selection::
+
+
+File: binutils.info,  Node: Target Selection,  Next: Architecture Selection,  Up: Selecting The Target System
+
+Target Selection
+================
+
+   A "target" is an object file format.  A given target may be
+supported for multiple architectures (*note Architecture Selection::.).
+A target selection may also have variations for different operating
+systems or architectures.
+
+   The command to list valid target values is `objdump -i' (the first
+column of output contains the relevant information).
+
+   Some sample values are: `a.out-hp300bsd', `ecoff-littlemips',
+`a.out-sunos-big'.
+
+   You can also specify a target using a configuration triplet.  This is
+the same sort of name that is passed to configure to specify a target.
+When you use a configuration triplet as an argument, it must be fully
+canonicalized.  You can see the canonical version of a triplet by
+running the shell script `config.sub' which is included with the
+sources.
+
+   Some sample configuration triplets are: `m68k-hp-bsd',
+`mips-dec-ultrix', `sparc-sun-sunos'.
+
+`objdump' Target
+----------------
+
+   Ways to specify:
+
+  1. command line option: `-b' or `--target'
+
+  2. environment variable `GNUTARGET'
+
+  3. deduced from the input file
+
+`objcopy' and `strip' Input Target
+----------------------------------
+
+   Ways to specify:
+
+  1. command line options: `-I' or `--input-target', or `-F' or
+     `--target'
+
+  2. environment variable `GNUTARGET'
+
+  3. deduced from the input file
+
+`objcopy' and `strip' Output Target
+-----------------------------------
+
+   Ways to specify:
+
+  1. command line options: `-O' or `--output-target', or `-F' or
+     `--target'
+
+  2. the input target (see "`objcopy' and `strip' Input Target" above)
+
+  3. environment variable `GNUTARGET'
+
+  4. deduced from the input file
+
+`nm', `size', and `strings' Target
+----------------------------------
+
+   Ways to specify:
+
+  1. command line option: `--target'
+
+  2. environment variable `GNUTARGET'
+
+  3. deduced from the input file
+
+Linker Input Target
+-------------------
+
+   Ways to specify:
+
+  1. command line option: `-b' or `--format' (*note Options:
+     (ld.info)Options.)
+
+  2. script command `TARGET' (*note Option Commands: (ld.info)Option
+     Commands.)
+
+  3. environment variable `GNUTARGET' (*note Environment:
+     (ld.info)Environment.)
+
+  4. the default target of the selected linker emulation (*note Linker
+     Emulation Selection::.)
+
+Linker Output Target
+--------------------
+
+   Ways to specify:
+
+  1. command line option: `-oformat' (*note Options: (ld.info)Options.)
+
+  2. script command `OUTPUT_FORMAT' (*note Option Commands:
+     (ld.info)Option Commands.)
+
+  3. the linker input target (see "Linker Input Target" above)
+
+
+File: binutils.info,  Node: Architecture Selection,  Next: Linker Emulation Selection,  Prev: Target Selection,  Up: Selecting The Target System
+
+Architecture selection
+======================
+
+   An "architecture" is a type of CPU on which an object file is to
+run.  Its name may contain a colon, separating the name of the
+processor family from the name of the particular CPU.
+
+   The command to list valid architecture values is `objdump -i' (the
+second column contains the relevant information).
+
+   Sample values: `m68k:68020', `mips:3000', `sparc'.
+
+`objdump' Architecture
+----------------------
+
+   Ways to specify:
+
+  1. command line option: `-m' or `--architecture'
+
+  2. deduced from the input file
+
+`objcopy', `nm', `size', `strings' Architecture
+-----------------------------------------------
+
+   Ways to specify:
+
+  1. deduced from the input file
+
+Linker Input Architecture
+-------------------------
+
+   Ways to specify:
+
+  1. deduced from the input file
+
+Linker Output Architecture
+--------------------------
+
+   Ways to specify:
+
+  1. script command `OUTPUT_ARCH' (*note Option Commands:
+     (ld.info)Option Commands.)
+
+  2. the default architecture from the linker output target (*note
+     Target Selection::.)
+
+
+File: binutils.info,  Node: Linker Emulation Selection,  Prev: Architecture Selection,  Up: Selecting The Target System
+
+Linker emulation selection
+==========================
+
+   A linker "emulation" is a "personality" of the linker, which gives
+the linker default values for the other aspects of the target system.
+In particular, it consists of
+
+   * the linker script
+
+   * the target
+
+   * several "hook" functions that are run at certain stages of the
+     linking process to do special things that some targets require
+
+   The command to list valid linker emulation values is `ld -V'.
+
+   Sample values: `hp300bsd', `mipslit', `sun4'.
+
+   Ways to specify:
+
+  1. command line option: `-m' (*note Options: (ld.info)Options.)
+
+  2. environment variable `LDEMULATION'
+
+  3. compiled-in `DEFAULT_EMULATION' from `Makefile', which comes from
+     `EMUL' in `config/TARGET.mt'
+
+
+File: binutils.info,  Node: Reporting Bugs,  Next: Index,  Prev: Selecting The Target System,  Up: Top
+
+Reporting Bugs
+**************
+
+   Your bug reports play an essential role in making the binary
+utilities reliable.
+
+   Reporting a bug may help you by bringing a solution to your problem,
+or it may not.  But in any case the principal function of a bug report
+is to help the entire community by making the next version of the binary
+utilities work better.  Bug reports are your contribution to their
+maintenance.
+
+   In order for a bug report to serve its purpose, you must include the
+information that enables us to fix the bug.
+
+* Menu:
+
+* Bug Criteria::                Have you found a bug?
+* Bug Reporting::               How to report bugs
+
+
+File: binutils.info,  Node: Bug Criteria,  Next: Bug Reporting,  Up: Reporting Bugs
+
+Have you found a bug?
+=====================
+
+   If you are not sure whether you have found a bug, here are some
+guidelines:
+
+   * If a binary utility gets a fatal signal, for any input whatever,
+     that is a bug.  Reliable utilities never crash.
+
+   * If a binary utility produces an error message for valid input,
+     that is a bug.
+
+   * If you are an experienced user of binary utilities, your
+     suggestions for improvement are welcome in any case.
+
+
+File: binutils.info,  Node: Bug Reporting,  Prev: Bug Criteria,  Up: Reporting Bugs
+
+How to report bugs
+==================
+
+   A number of companies and individuals offer support for GNU
+products.  If you obtained the binary utilities from a support
+organization, we recommend you contact that organization first.
+
+   You can find contact information for many support companies and
+individuals in the file `etc/SERVICE' in the GNU Emacs distribution.
+
+   In any event, we also recommend that you send bug reports for the
+binary utilities to `bug-gnu-utils@prep.ai.mit.edu'.
+
+   The fundamental principle of reporting bugs usefully is this:
+*report all the facts*.  If you are not sure whether to state a fact or
+leave it out, state it!
+
+   Often people omit facts because they think they know what causes the
+problem and assume that some details do not matter.  Thus, you might
+assume that the name of a file you use in an example does not matter.
+Well, probably it does not, but one cannot be sure.  Perhaps the bug is
+a stray memory reference which happens to fetch from the location where
+that pathname is stored in memory; perhaps, if the pathname were
+different, the contents of that location would fool the utility into
+doing the right thing despite the bug.  Play it safe and give a
+specific, complete example.  That is the easiest thing for you to do,
+and the most helpful.
+
+   Keep in mind that the purpose of a bug report is to enable us to fix
+the bug if it is new to us.  Therefore, always write your bug reports
+on the assumption that the bug has not been reported previously.
+
+   Sometimes people give a few sketchy facts and ask, "Does this ring a
+bell?"  Those bug reports are useless, and we urge everyone to *refuse
+to respond to them* except to chide the sender to report bugs properly.
+
+   To enable us to fix the bug, you should include all these things:
+
+   * The version of the utility.  Each utility announces it if you
+     start it with the `--version' argument.
+
+     Without this, we will not know whether there is any point in
+     looking for the bug in the current version of the binary utilities.
+
+   * Any patches you may have applied to the source, including any
+     patches made to the `BFD' library.
+
+   * The type of machine you are using, and the operating system name
+     and version number.
+
+   * What compiler (and its version) was used to compile the
+     utilities--e.g.  "`gcc-2.7'".
+
+   * The command arguments you gave the utility to observe the bug.  To
+     guarantee you will not omit something important, list them all.  A
+     copy of the Makefile (or the output from make) is sufficient.
+
+     If we were to try to guess the arguments, we would probably guess
+     wrong and then we might not encounter the bug.
+
+   * A complete input file, or set of input files, that will reproduce
+     the bug.  If the utility is reading an object file or files, then
+     it is generally most helpful to send the actual object files,
+     uuencoded if necessary to get them through the mail system.
+     Making them available for anonymous FTP is not as good, but may be
+     the only reasonable choice for large object files.
+
+     If the source files were produced exclusively using GNU programs
+     (e.g., `gcc', `gas', and/or the GNU `ld'), then it may be OK to
+     send the source files rather than the object files.  In this case,
+     be sure to say exactly what version of `gcc', or whatever, was
+     used to produce the object files.  Also say how `gcc', or
+     whatever, was configured.
+
+   * A description of what behavior you observe that you believe is
+     incorrect.  For example, "It gets a fatal signal."
+
+     Of course, if the bug is that the utility gets a fatal signal,
+     then we will certainly notice it.  But if the bug is incorrect
+     output, we might not notice unless it is glaringly wrong.  You
+     might as well not give us a chance to make a mistake.
+
+     Even if the problem you experience is a fatal signal, you should
+     still say so explicitly.  Suppose something strange is going on,
+     such as, your copy of the utility is out of synch, or you have
+     encountered a bug in the C library on your system.  (This has
+     happened!)  Your copy might crash and ours would not.  If you told
+     us to expect a crash, then when ours fails to crash, we would know
+     that the bug was not happening for us.  If you had not told us to
+     expect a crash, then we would not be able to draw any conclusion
+     from our observations.
+
+   * If you wish to suggest changes to the source, send us context
+     diffs, as generated by `diff' with the `-u', `-c', or `-p' option.
+     Always send diffs from the old file to the new file.  If you even
+     discuss something in the `ld' source, refer to it by context, not
+     by line number.
+
+     The line numbers in our development sources will not match those
+     in your sources.  Your line numbers would convey no useful
+     information to us.
+
+   Here are some things that are not necessary:
+
+   * A description of the envelope of the bug.
+
+     Often people who encounter a bug spend a lot of time investigating
+     which changes to the input file will make the bug go away and which
+     changes will not affect it.
+
+     This is often time consuming and not very useful, because the way
+     we will find the bug is by running a single example under the
+     debugger with breakpoints, not by pure deduction from a series of
+     examples.  We recommend that you save your time for something else.
+
+     Of course, if you can find a simpler example to report *instead*
+     of the original one, that is a convenience for us.  Errors in the
+     output will be easier to spot, running under the debugger will take
+     less time, and so on.
+
+     However, simplification is not vital; if you do not want to do
+     this, report the bug anyway and send us the entire test case you
+     used.
+
+   * A patch for the bug.
+
+     A patch for the bug does help us if it is a good one.  But do not
+     omit the necessary information, such as the test case, on the
+     assumption that a patch is all we need.  We might see problems
+     with your patch and decide to fix the problem another way, or we
+     might not understand it at all.
+
+     Sometimes with programs as complicated as the binary utilities it
+     is very hard to construct an example that will make the program
+     follow a certain path through the code.  If you do not send us the
+     example, we will not be able to construct one, so we will not be
+     able to verify that the bug is fixed.
+
+     And if we cannot understand what bug you are trying to fix, or why
+     your patch should be an improvement, we will not install it.  A
+     test case will help us to understand.
+
+   * A guess about what the bug is or what it depends on.
+
+     Such guesses are usually wrong.  Even we cannot guess right about
+     such things without first using the debugger to find the facts.
+
+
+File: binutils.info,  Node: Index,  Prev: Reporting Bugs,  Up: Top
+
+Index
+*****
+
+* Menu:
+
+* .stab:                                objdump.
+* ar compatibility:                     ar.
+* nm compatibility:                     nm.
+* nm format:                            nm.
+* size display format:                  size.
+* size number format:                   size.
+* addr2line:                            addr2line.
+* address to file name and line number: addr2line.
+* all header information, object file:  objdump.
+* ar:                                   ar.
+* architecture:                         objdump.
+* architectures available:              objdump.
+* archive contents:                     ranlib.
+* archive headers:                      objdump.
+* archives:                             ar.
+* bug criteria:                         Bug Criteria.
+* bug reports:                          Bug Reporting.
+* bugs:                                 Reporting Bugs.
+* bugs, reporting:                      Bug Reporting.
+* c++filt:                              c++filt.
+* collections of files:                 ar.
+* compatibility, ar:                    ar.
+* contents of archive:                  ar cmdline.
+* crash:                                Bug Criteria.
+* creating archives:                    ar cmdline.
+* dates in archive:                     ar cmdline.
+* debug symbols:                        objdump.
+* debugging symbols:                    nm.
+* deleting from archive:                ar cmdline.
+* demangling C++ symbols:               c++filt.
+* demangling in nm:                     nm.
+* demangling in objdump <1>:            objdump.
+* demangling in objdump:                addr2line.
+* disassembling object code:            objdump.
+* disassembly architecture:             objdump.
+* disassembly endianness:               objdump.
+* disassembly, with source:             objdump.
+* discarding symbols:                   strip.
+* dynamic relocation entries, in object file: objdump.
+* dynamic symbol table entries, printing: objdump.
+* dynamic symbols:                      nm.
+* ELF object file format:               objdump.
+* endianness:                           objdump.
+* error on valid input:                 Bug Criteria.
+* external symbols:                     nm.
+* extract from archive:                 ar cmdline.
+* fatal signal:                         Bug Criteria.
+* file name:                            nm.
+* header information, all:              objdump.
+* input file name:                      nm.
+* libraries:                            ar.
+* listings strings:                     strings.
+* machine instructions:                 objdump.
+* moving in archive:                    ar cmdline.
+* MRI compatibility, ar:                ar scripts.
+* name duplication in archive:          ar cmdline.
+* name length:                          ar.
+* nm:                                   nm.
+* objdump:                              objdump.
+* object code format <1>:               objdump.
+* object code format <2>:               strings.
+* object code format <3>:               nm.
+* object code format <4>:               size.
+* object code format:                   addr2line.
+* object file header:                   objdump.
+* object file information:              objdump.
+* object file sections:                 objdump.
+* object formats available:             objdump.
+* operations on archive:                ar cmdline.
+* printing from archive:                ar cmdline.
+* printing strings:                     strings.
+* quick append to archive:              ar cmdline.
+* radix for section sizes:              size.
+* ranlib:                               ranlib.
+* relative placement in archive:        ar cmdline.
+* relocation entries, in object file:   objdump.
+* removing symbols:                     strip.
+* repeated names in archive:            ar cmdline.
+* replacement in archive:               ar cmdline.
+* reporting bugs:                       Reporting Bugs.
+* scripts, ar:                          ar scripts.
+* section addresses in objdump:         objdump.
+* section headers:                      objdump.
+* section information:                  objdump.
+* section sizes:                        size.
+* sections, full contents:              objdump.
+* size:                                 size.
+* sorting symbols:                      nm.
+* source disassembly:                   objdump.
+* source file name:                     nm.
+* source filenames for object files:    objdump.
+* stab:                                 objdump.
+* start-address:                        objdump.
+* stop-address:                         objdump.
+* strings:                              strings.
+* strings, printing:                    strings.
+* strip:                                strip.
+* symbol index <1>:                     ranlib.
+* symbol index:                         ar.
+* symbol index, listing:                nm.
+* symbol line numbers:                  nm.
+* symbol table entries, printing:       objdump.
+* symbols:                              nm.
+* symbols, discarding:                  strip.
+* undefined symbols:                    nm.
+* Unix compatibility, ar:               ar cmdline.
+* updating an archive:                  ar cmdline.
+* version:                              Top.
+* VMA in objdump:                       objdump.
+* wide output, printing:                objdump.
+* writing archive index:                ar cmdline.
+
+
diff --git a/gnu/usr.bin/binutils/binutils/configure.com b/gnu/usr.bin/binutils/binutils/configure.com
new file mode 100644
index 00000000000..9e35c766297
--- /dev/null
+++ b/gnu/usr.bin/binutils/binutils/configure.com
@@ -0,0 +1,78 @@
+$!
+$! This file configures binutils for use with openVMS/Alpha
+$! We do not use the configure script, since we do not have /bin/sh
+$! to execute it.
+$!
+$! Written by Klaus K"ampf (kkaempf@progis.de)
+$!
+$arch_indx = 1 + ((f$getsyi("CPU").ge.128).and.1)      ! vax==1, alpha==2
+$arch = f$element(arch_indx,"|","|VAX|Alpha|")
+$if arch .eqs. "VAX"
+$then
+$ write sys$output "Target VAX not supported."
+$ exit 2
+$endif
+$!
+$!
+$! Generate config.h
+$!
+$ create []config.h
+/* config.h.  Generated automatically by configure.  */
+/* config.in.  Generated automatically from configure.in by autoheader.  */
+/* Is the type time_t defined in <time.h>?  */
+#define HAVE_TIME_T_IN_TIME_H 1
+/* Is the type time_t defined in <sys/types.h>?  */
+#define HAVE_TIME_T_IN_TYPES_H 1
+/* Does <utime.h> define struct utimbuf?  */
+#define HAVE_GOOD_UTIME_H 1
+/* Whether fprintf must be declared even if <stdio.h> is included.  */
+#define NEED_DECLARATION_FPRINTF 1
+/* Whether sbrk must be declared even if <unistd.h> is included.  */
+#undef NEED_DECLARATION_SBRK
+/* Do we need to use the b modifier when opening binary files?  */
+/* #undef USE_BINARY_FOPEN */
+/* Define if you have the sbrk function.  */
+#define HAVE_SBRK 1
+/* Define if you have the utimes function.  */
+#define HAVE_UTIMES 1
+/* Define if you have the <fcntl.h> header file.  */
+#define HAVE_FCNTL_H 1
+/* Define if you have the <stdlib.h> header file.  */
+#define HAVE_STDLIB_H 1
+/* Define if you have the <string.h> header file.  */
+#define HAVE_STRING_H 1
+/* Define if you have the <strings.h> header file.  */
+#define HAVE_STRINGS_H 1
+/* Define if you have the <sys/file.h> header file.  */
+#define HAVE_SYS_FILE_H 1
+/* Define if you have the <unistd.h> header file.  */
+#define HAVE_UNISTD_H 1
+$ write sys$output "Generated `config.h'"
+$!
+$!
+$! Edit VERSION in makefile.vms
+$!
+$ edit/tpu/nojournal/nosection/nodisplay/command=sys$input -
+        []makefile.vms /output=[]makefile.vms
+$DECK
+!
+! Get VERSION from Makefile.in
+!
+   mfile := CREATE_BUFFER("mfile", "Makefile.in");
+   rang := CREATE_RANGE(BEGINNING_OF(mfile), END_OF(mfile));
+   v_pos := SEARCH_QUIETLY('VERSION=', FORWARD, EXACT, rang);
+   POSITION(BEGINNING_OF(v_pos));
+   vers := CURRENT_LINE;
+   IF match_pos <> 0 THEN;
+      file := CREATE_BUFFER("file", GET_INFO(COMMAND_LINE, "file_name"));
+      rang := CREATE_RANGE(BEGINNING_OF(file), END_OF(file));
+      match_pos := SEARCH_QUIETLY('VERSION=', FORWARD, EXACT, rang);
+      POSITION(BEGINNING_OF(match_pos));
+      ERASE_LINE;
+      COPY_TEXT(vers);
+      SPLIT_LINE;
+   ENDIF;
+   WRITE_FILE(file, GET_INFO(COMMAND_LINE, "output_file"));
+   QUIT
+$  EOD
+$ write sys$output "Patched `makefile.vms'"
diff --git a/gnu/usr.bin/binutils/binutils/deflex.c b/gnu/usr.bin/binutils/binutils/deflex.c
new file mode 100644
index 00000000000..7629e9a90d7
--- /dev/null
+++ b/gnu/usr.bin/binutils/binutils/deflex.c
@@ -0,0 +1,1747 @@
+/* A lexical scanner generated by flex */
+
+/* Scanner skeleton version:
+ * $Header: /cvs/OpenBSD/src/gnu/usr.bin/binutils/binutils/deflex.c,v 1.1 1997/05/29 09:15:57 niklas Exp $
+ */
+
+#define FLEX_SCANNER
+#define YY_FLEX_MAJOR_VERSION 2
+#define YY_FLEX_MINOR_VERSION 5
+
+#include <stdio.h>
+
+
+/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
+#ifdef c_plusplus
+#ifndef __cplusplus
+#define __cplusplus
+#endif
+#endif
+
+
+#ifdef __cplusplus
+
+#include <stdlib.h>
+#include <unistd.h>
+
+/* Use prototypes in function declarations. */
+#define YY_USE_PROTOS
+
+/* The "const" storage-class-modifier is valid. */
+#define YY_USE_CONST
+
+#else	/* ! __cplusplus */
+
+#if __STDC__
+
+#define YY_USE_PROTOS
+#define YY_USE_CONST
+
+#endif	/* __STDC__ */
+#endif	/* ! __cplusplus */
+
+#ifdef __TURBOC__
+ #pragma warn -rch
+ #pragma warn -use
+#include <io.h>
+#include <stdlib.h>
+#define YY_USE_CONST
+#define YY_USE_PROTOS
+#endif
+
+#ifdef YY_USE_CONST
+#define yyconst const
+#else
+#define yyconst
+#endif
+
+
+#ifdef YY_USE_PROTOS
+#define YY_PROTO(proto) proto
+#else
+#define YY_PROTO(proto) ()
+#endif
+
+/* Returned upon end-of-file. */
+#define YY_NULL 0
+
+/* Promotes a possibly negative, possibly signed char to an unsigned
+ * integer for use as an array index.  If the signed char is negative,
+ * we want to instead treat it as an 8-bit unsigned char, hence the
+ * double cast.
+ */
+#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
+
+/* Enter a start condition.  This macro really ought to take a parameter,
+ * but we do it the disgusting crufty way forced on us by the ()-less
+ * definition of BEGIN.
+ */
+#define BEGIN yy_start = 1 + 2 *
+
+/* Translate the current start state into a value that can be later handed
+ * to BEGIN to return to the state.  The YYSTATE alias is for lex
+ * compatibility.
+ */
+#define YY_START ((yy_start - 1) / 2)
+#define YYSTATE YY_START
+
+/* Action number for EOF rule of a given start state. */
+#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
+
+/* Special action meaning "start processing a new file". */
+#define YY_NEW_FILE yyrestart( yyin )
+
+#define YY_END_OF_BUFFER_CHAR 0
+
+/* Size of default input buffer. */
+#define YY_BUF_SIZE 16384
+
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+
+extern int yyleng;
+extern FILE *yyin, *yyout;
+
+#define EOB_ACT_CONTINUE_SCAN 0
+#define EOB_ACT_END_OF_FILE 1
+#define EOB_ACT_LAST_MATCH 2
+
+/* The funky do-while in the following #define is used to turn the definition
+ * int a single C statement (which needs a semi-colon terminator).  This
+ * avoids problems with code like:
+ *
+ * 	if ( condition_holds )
+ *		yyless( 5 );
+ *	else
+ *		do_something_else();
+ *
+ * Prior to using the do-while the compiler would get upset at the
+ * "else" because it interpreted the "if" statement as being all
+ * done when it reached the ';' after the yyless() call.
+ */
+
+/* Return all but the first 'n' matched characters back to the input stream. */
+
+#define yyless(n) \
+	do \
+		{ \
+		/* Undo effects of setting up yytext. */ \
+		*yy_cp = yy_hold_char; \
+		yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
+		YY_DO_BEFORE_ACTION; /* set up yytext again */ \
+		} \
+	while ( 0 )
+
+#define unput(c) yyunput( c, yytext_ptr )
+
+/* The following is because we cannot portably get our hands on size_t
+ * (without autoconf's help, which isn't available because we want
+ * flex-generated scanners to compile on their own).
+ */
+typedef unsigned int yy_size_t;
+
+
+struct yy_buffer_state
+	{
+	FILE *yy_input_file;
+
+	char *yy_ch_buf;		/* input buffer */
+	char *yy_buf_pos;		/* current position in input buffer */
+
+	/* Size of input buffer in bytes, not including room for EOB
+	 * characters.
+	 */
+	yy_size_t yy_buf_size;
+
+	/* Number of characters read into yy_ch_buf, not including EOB
+	 * characters.
+	 */
+	int yy_n_chars;
+
+	/* Whether we "own" the buffer - i.e., we know we created it,
+	 * and can realloc() it to grow it, and should free() it to
+	 * delete it.
+	 */
+	int yy_is_our_buffer;
+
+	/* Whether this is an "interactive" input source; if so, and
+	 * if we're using stdio for input, then we want to use getc()
+	 * instead of fread(), to make sure we stop fetching input after
+	 * each newline.
+	 */
+	int yy_is_interactive;
+
+	/* Whether we're considered to be at the beginning of a line.
+	 * If so, '^' rules will be active on the next match, otherwise
+	 * not.
+	 */
+	int yy_at_bol;
+
+	/* Whether to try to fill the input buffer when we reach the
+	 * end of it.
+	 */
+	int yy_fill_buffer;
+
+	int yy_buffer_status;
+#define YY_BUFFER_NEW 0
+#define YY_BUFFER_NORMAL 1
+	/* When an EOF's been seen but there's still some text to process
+	 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
+	 * shouldn't try reading from the input source any more.  We might
+	 * still have a bunch of tokens to match, though, because of
+	 * possible backing-up.
+	 *
+	 * When we actually see the EOF, we change the status to "new"
+	 * (via yyrestart()), so that the user can continue scanning by
+	 * just pointing yyin at a new input file.
+	 */
+#define YY_BUFFER_EOF_PENDING 2
+	};
+
+static YY_BUFFER_STATE yy_current_buffer = 0;
+
+/* We provide macros for accessing buffer states in case in the
+ * future we want to put the buffer states in a more general
+ * "scanner state".
+ */
+#define YY_CURRENT_BUFFER yy_current_buffer
+
+
+/* yy_hold_char holds the character lost when yytext is formed. */
+static char yy_hold_char;
+
+static int yy_n_chars;		/* number of characters read into yy_ch_buf */
+
+
+int yyleng;
+
+/* Points to current character in buffer. */
+static char *yy_c_buf_p = (char *) 0;
+static int yy_init = 1;		/* whether we need to initialize */
+static int yy_start = 0;	/* start state number */
+
+/* Flag which is used to allow yywrap()'s to do buffer switches
+ * instead of setting up a fresh yyin.  A bit of a hack ...
+ */
+static int yy_did_buffer_switch_on_eof;
+
+void yyrestart YY_PROTO(( FILE *input_file ));
+
+void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
+void yy_load_buffer_state YY_PROTO(( void ));
+YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
+void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
+void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
+void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
+#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
+
+YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
+YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *str ));
+YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
+
+static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
+static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
+static void yy_flex_free YY_PROTO(( void * ));
+
+#define yy_new_buffer yy_create_buffer
+
+#define yy_set_interactive(is_interactive) \
+	{ \
+	if ( ! yy_current_buffer ) \
+		yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
+	yy_current_buffer->yy_is_interactive = is_interactive; \
+	}
+
+#define yy_set_bol(at_bol) \
+	{ \
+	if ( ! yy_current_buffer ) \
+		yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
+	yy_current_buffer->yy_at_bol = at_bol; \
+	}
+
+#define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
+
+typedef unsigned char YY_CHAR;
+FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
+typedef int yy_state_type;
+extern char *yytext;
+#define yytext_ptr yytext
+
+static yy_state_type yy_get_previous_state YY_PROTO(( void ));
+static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
+static int yy_get_next_buffer YY_PROTO(( void ));
+static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
+
+/* Done after the current pattern has been matched and before the
+ * corresponding action - sets up yytext.
+ */
+#define YY_DO_BEFORE_ACTION \
+	yytext_ptr = yy_bp; \
+	yyleng = (int) (yy_cp - yy_bp); \
+	yy_hold_char = *yy_cp; \
+	*yy_cp = '\0'; \
+	yy_c_buf_p = yy_cp;
+
+#define YY_NUM_RULES 32
+#define YY_END_OF_BUFFER 33
+static yyconst short int yy_accept[135] =
+    {   0,
+        0,    0,   33,   32,   26,   27,   25,   32,   32,   32,
+       23,   31,   29,   19,   24,   28,   30,   32,   32,   32,
+       32,   32,   32,   32,   32,   32,   32,   32,   32,    0,
+       21,   20,    0,   22,   23,   19,   24,   20,   20,   20,
+       20,   20,   20,   20,   20,   20,   20,   20,   20,   20,
+       20,   20,   20,   20,   20,   20,   20,   20,   20,   20,
+       20,   20,   20,   20,   20,   20,   20,   20,   20,   20,
+       20,   12,    6,   20,    7,   20,   20,   20,   20,   20,
+       20,    1,   20,   15,   20,   20,   20,   20,   20,   20,
+       20,   20,   20,   20,   20,   20,   20,   20,   20,   20,
+
+       20,   16,   20,   20,   20,   20,   20,   20,   20,   14,
+       20,   18,   20,   20,   20,   20,   17,    9,   20,   10,
+        2,   20,   20,   11,   13,   20,    5,    8,   20,   20,
+        4,   20,    3,    0
+    } ;
+
+static yyconst int yy_ec[256] =
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    4,    1,    5,    1,    6,    1,    1,    7,    1,
+        1,    8,    1,    9,    6,   10,   11,   12,   12,   12,
+       12,   12,   12,   12,   12,   12,   12,    6,   13,    1,
+       14,    1,    1,   15,   16,   17,   18,   19,   20,   21,
+        6,   22,   23,    6,   24,   25,   26,   27,   28,   29,
+        6,   30,   31,   32,   33,   34,   35,   36,   37,   38,
+        1,    1,    1,    1,    6,    1,   21,   21,   21,   21,
+
+       21,   21,    6,    6,    6,    6,    6,    6,    6,    6,
+        6,    6,    6,    6,    6,    6,    6,    6,    6,   21,
+        6,    6,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1
+    } ;
+
+static yyconst int yy_meta[39] =
+    {   0,
+        1,    1,    2,    1,    1,    3,    1,    1,    1,    1,
+        3,    4,    1,    1,    3,    4,    4,    4,    4,    4,
+        4,    3,    3,    3,    3,    3,    3,    3,    3,    3,
+        3,    3,    3,    3,    3,    3,    3,    3
+    } ;
+
+static yyconst short int yy_base[141] =
+    {   0,
+        0,    0,  156,  157,  157,  157,  157,  150,    0,  147,
+        0,  157,  157,    0,    0,  157,  157,  137,  124,   23,
+      115,  130,  123,  125,   24,  127,   22,  126,  115,  139,
+      157,    0,  136,  157,    0,    0,    0,  111,   22,  109,
+      109,   26,  123,  109,  120,  110,  108,  118,  115,  116,
+      115,  100,  106,  108,  107,   95,  109,  106,  105,   94,
+       92,   92,   89,   98,  101,   97,   83,   84,   95,   81,
+       79,    0,    0,   78,    0,   79,   75,   77,   75,   75,
+       88,    0,   77,    0,   79,   81,   76,   76,   78,   81,
+       73,   63,   62,   70,   60,   61,   70,   61,   69,   56,
+
+       58,    0,   58,   55,   63,   51,   43,   49,   42,    0,
+       51,    0,   54,   49,   43,   42,    0,    0,   51,    0,
+        0,   36,   15,    0,    0,   28,    0,    0,   30,   20,
+        0,   20,    0,  157,   55,   57,   61,   65,   41,   69
+    } ;
+
+static yyconst short int yy_def[141] =
+    {   0,
+      134,    1,  134,  134,  134,  134,  134,  135,  136,  137,
+      138,  134,  134,  139,  140,  134,  134,  136,  136,  136,
+      136,  136,  136,  136,  136,  136,  136,  136,  136,  135,
+      134,  136,  137,  134,  138,  139,  140,  136,  136,  136,
+      136,  136,  136,  136,  136,  136,  136,  136,  136,  136,
+      136,  136,  136,  136,  136,  136,  136,  136,  136,  136,
+      136,  136,  136,  136,  136,  136,  136,  136,  136,  136,
+      136,  136,  136,  136,  136,  136,  136,  136,  136,  136,
+      136,  136,  136,  136,  136,  136,  136,  136,  136,  136,
+      136,  136,  136,  136,  136,  136,  136,  136,  136,  136,
+
+      136,  136,  136,  136,  136,  136,  136,  136,  136,  136,
+      136,  136,  136,  136,  136,  136,  136,  136,  136,  136,
+      136,  136,  136,  136,  136,  136,  136,  136,  136,  136,
+      136,  136,  136,    0,  134,  134,  134,  134,  134,  134
+    } ;
+
+static yyconst short int yy_nxt[196] =
+    {   0,
+        4,    5,    6,    7,    8,    9,   10,   11,   12,   13,
+        4,   14,   15,   16,   17,    9,   18,   19,   20,   21,
+        9,   22,   23,    9,   24,    9,   25,    9,    9,   26,
+       27,    9,    9,   28,   29,    9,    9,    9,   40,   46,
+       55,   49,   41,   50,   36,   59,  133,  132,   56,  131,
+      130,   47,  129,   51,   60,   30,   30,   30,   30,   32,
+       32,   33,   33,   33,   33,   35,  128,   35,   35,   37,
+      127,   37,   37,  126,  125,  124,  123,  122,  121,  120,
+      119,  118,  117,  116,  115,  114,  113,  112,  111,  110,
+      109,  108,  107,  106,  105,  104,  103,  102,  101,  100,
+
+       99,   98,   97,   96,   95,   94,   93,   92,   91,   90,
+       89,   88,   87,   86,   85,   84,   83,   82,   81,   80,
+       79,   78,   77,   76,   75,   74,   73,   72,   71,   70,
+       69,   68,   67,   66,   65,   64,   63,   62,   61,   58,
+       57,   54,   34,   31,   53,   52,   48,   45,   44,   43,
+       42,   39,   38,   34,   31,  134,    3,  134,  134,  134,
+      134,  134,  134,  134,  134,  134,  134,  134,  134,  134,
+      134,  134,  134,  134,  134,  134,  134,  134,  134,  134,
+      134,  134,  134,  134,  134,  134,  134,  134,  134,  134,
+      134,  134,  134,  134,  134
+
+    } ;
+
+static yyconst short int yy_chk[196] =
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,   20,   25,
+       39,   27,   20,   27,  139,   42,  132,  130,   39,  129,
+      126,   25,  123,   27,   42,  135,  135,  135,  135,  136,
+      136,  137,  137,  137,  137,  138,  122,  138,  138,  140,
+      119,  140,  140,  116,  115,  114,  113,  111,  109,  108,
+      107,  106,  105,  104,  103,  101,  100,   99,   98,   97,
+       96,   95,   94,   93,   92,   91,   90,   89,   88,   87,
+
+       86,   85,   83,   81,   80,   79,   78,   77,   76,   74,
+       71,   70,   69,   68,   67,   66,   65,   64,   63,   62,
+       61,   60,   59,   58,   57,   56,   55,   54,   53,   52,
+       51,   50,   49,   48,   47,   46,   45,   44,   43,   41,
+       40,   38,   33,   30,   29,   28,   26,   24,   23,   22,
+       21,   19,   18,   10,    8,    3,  134,  134,  134,  134,
+      134,  134,  134,  134,  134,  134,  134,  134,  134,  134,
+      134,  134,  134,  134,  134,  134,  134,  134,  134,  134,
+      134,  134,  134,  134,  134,  134,  134,  134,  134,  134,
+      134,  134,  134,  134,  134
+
+    } ;
+
+static yy_state_type yy_last_accepting_state;
+static char *yy_last_accepting_cpos;
+
+/* The intent behind this definition is that it'll catch
+ * any uses of REJECT which flex missed.
+ */
+#define REJECT reject_used_but_not_detected
+#define yymore() yymore_used_but_not_detected
+#define YY_MORE_ADJ 0
+char *yytext;
+#line 1 "./deflex.l"
+#define INITIAL 0
+#line 2 "./deflex.l"
+/* deflex.l - Lexer for .def files */
+
+/*   Copyright (C) 1995 Free Software Foundation, Inc.
+
+This file is part of GNU Binutils.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+
+/* Contributed by Steve Chamberlain
+   		  sac@cygnus.com
+
+*/
+#define DONTDECLARE_MALLOC
+#include "defparse.h"
+extern char *strdup();
+int linenumber;
+
+#line 479 "lex.yy.c"
+
+/* Macros after this point can all be overridden by user definitions in
+ * section 1.
+ */
+
+#ifndef YY_SKIP_YYWRAP
+#ifdef __cplusplus
+extern "C" int yywrap YY_PROTO(( void ));
+#else
+extern int yywrap YY_PROTO(( void ));
+#endif
+#endif
+
+#ifndef YY_NO_UNPUT
+static void yyunput YY_PROTO(( int c, char *buf_ptr ));
+#endif
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
+#endif
+
+#ifndef YY_NO_INPUT
+#ifdef __cplusplus
+static int yyinput YY_PROTO(( void ));
+#else
+static int input YY_PROTO(( void ));
+#endif
+#endif
+
+#if YY_STACK_USED
+static int yy_start_stack_ptr = 0;
+static int yy_start_stack_depth = 0;
+static int *yy_start_stack = 0;
+#ifndef YY_NO_PUSH_STATE
+static void yy_push_state YY_PROTO(( int new_state ));
+#endif
+#ifndef YY_NO_POP_STATE
+static void yy_pop_state YY_PROTO(( void ));
+#endif
+#ifndef YY_NO_TOP_STATE
+static int yy_top_state YY_PROTO(( void ));
+#endif
+
+#else
+#define YY_NO_PUSH_STATE 1
+#define YY_NO_POP_STATE 1
+#define YY_NO_TOP_STATE 1
+#endif
+
+#ifdef YY_MALLOC_DECL
+YY_MALLOC_DECL
+#else
+#if __STDC__
+#ifndef __cplusplus
+#include <stdlib.h>
+#endif
+#else
+/* Just try to get by without declaring the routines.  This will fail
+ * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
+ * or sizeof(void*) != sizeof(int).
+ */
+#endif
+#endif
+
+/* Amount of stuff to slurp up with each read. */
+#ifndef YY_READ_BUF_SIZE
+#define YY_READ_BUF_SIZE 8192
+#endif
+
+/* Copy whatever the last rule matched to the standard output. */
+
+#ifndef ECHO
+/* This used to be an fputs(), but since the string might contain NUL's,
+ * we now use fwrite().
+ */
+#define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
+#endif
+
+/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
+ * is returned in "result".
+ */
+#ifndef YY_INPUT
+#define YY_INPUT(buf,result,max_size) \
+	if ( yy_current_buffer->yy_is_interactive ) \
+		{ \
+		int c = '*', n; \
+		for ( n = 0; n < max_size && \
+			     (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
+			buf[n] = (char) c; \
+		if ( c == '\n' ) \
+			buf[n++] = (char) c; \
+		if ( c == EOF && ferror( yyin ) ) \
+			YY_FATAL_ERROR( "input in flex scanner failed" ); \
+		result = n; \
+		} \
+	else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
+		  && ferror( yyin ) ) \
+		YY_FATAL_ERROR( "input in flex scanner failed" );
+#endif
+
+/* No semi-colon after return; correct usage is to write "yyterminate();" -
+ * we don't want an extra ';' after the "return" because that will cause
+ * some compilers to complain about unreachable statements.
+ */
+#ifndef yyterminate
+#define yyterminate() return YY_NULL
+#endif
+
+/* Number of entries by which start-condition stack grows. */
+#ifndef YY_START_STACK_INCR
+#define YY_START_STACK_INCR 25
+#endif
+
+/* Report a fatal error. */
+#ifndef YY_FATAL_ERROR
+#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
+#endif
+
+/* Default declaration of generated scanner - a define so the user can
+ * easily add parameters.
+ */
+#ifndef YY_DECL
+#define YY_DECL int yylex YY_PROTO(( void ))
+#endif
+
+/* Code executed at the beginning of each rule, after yytext and yyleng
+ * have been set up.
+ */
+#ifndef YY_USER_ACTION
+#define YY_USER_ACTION
+#endif
+
+/* Code executed at the end of each rule. */
+#ifndef YY_BREAK
+#define YY_BREAK break;
+#endif
+
+#define YY_RULE_SETUP \
+	YY_USER_ACTION
+
+YY_DECL
+	{
+	register yy_state_type yy_current_state;
+	register char *yy_cp, *yy_bp;
+	register int yy_act;
+
+#line 33 "./deflex.l"
+
+#line 628 "lex.yy.c"
+
+	if ( yy_init )
+		{
+		yy_init = 0;
+
+#ifdef YY_USER_INIT
+		YY_USER_INIT;
+#endif
+
+		if ( ! yy_start )
+			yy_start = 1;	/* first start state */
+
+		if ( ! yyin )
+			yyin = stdin;
+
+		if ( ! yyout )
+			yyout = stdout;
+
+		if ( ! yy_current_buffer )
+			yy_current_buffer =
+				yy_create_buffer( yyin, YY_BUF_SIZE );
+
+		yy_load_buffer_state();
+		}
+
+	while ( 1 )		/* loops until end-of-file is reached */
+		{
+		yy_cp = yy_c_buf_p;
+
+		/* Support of yytext. */
+		*yy_cp = yy_hold_char;
+
+		/* yy_bp points to the position in yy_ch_buf of the start of
+		 * the current run.
+		 */
+		yy_bp = yy_cp;
+
+		yy_current_state = yy_start;
+yy_match:
+		do
+			{
+			register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
+			if ( yy_accept[yy_current_state] )
+				{
+				yy_last_accepting_state = yy_current_state;
+				yy_last_accepting_cpos = yy_cp;
+				}
+			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+				{
+				yy_current_state = (int) yy_def[yy_current_state];
+				if ( yy_current_state >= 135 )
+					yy_c = yy_meta[(unsigned int) yy_c];
+				}
+			yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+			++yy_cp;
+			}
+		while ( yy_base[yy_current_state] != 157 );
+
+yy_find_action:
+		yy_act = yy_accept[yy_current_state];
+		if ( yy_act == 0 )
+			{ /* have to back up */
+			yy_cp = yy_last_accepting_cpos;
+			yy_current_state = yy_last_accepting_state;
+			yy_act = yy_accept[yy_current_state];
+			}
+
+		YY_DO_BEFORE_ACTION;
+
+
+do_action:	/* This label is used only to access EOF actions. */
+
+
+		switch ( yy_act )
+	{ /* 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 34 "./deflex.l"
+{ return NAME;}
+	YY_BREAK
+case 2:
+YY_RULE_SETUP
+#line 35 "./deflex.l"
+{ return LIBRARY;}
+	YY_BREAK
+case 3:
+YY_RULE_SETUP
+#line 36 "./deflex.l"
+{ return DESCRIPTION;}
+	YY_BREAK
+case 4:
+YY_RULE_SETUP
+#line 37 "./deflex.l"
+{ return STACKSIZE;}
+	YY_BREAK
+case 5:
+YY_RULE_SETUP
+#line 38 "./deflex.l"
+{ return HEAPSIZE;}
+	YY_BREAK
+case 6:
+YY_RULE_SETUP
+#line 39 "./deflex.l"
+{ return CODE;}
+	YY_BREAK
+case 7:
+YY_RULE_SETUP
+#line 40 "./deflex.l"
+{ return DATA;}
+	YY_BREAK
+case 8:
+YY_RULE_SETUP
+#line 41 "./deflex.l"
+{ return SECTIONS;}
+	YY_BREAK
+case 9:
+YY_RULE_SETUP
+#line 42 "./deflex.l"
+{ return EXPORTS;}
+	YY_BREAK
+case 10:
+YY_RULE_SETUP
+#line 43 "./deflex.l"
+{ return IMPORTS;}
+	YY_BREAK
+case 11:
+YY_RULE_SETUP
+#line 44 "./deflex.l"
+{ return VERSION;}
+	YY_BREAK
+case 12:
+YY_RULE_SETUP
+#line 45 "./deflex.l"
+{ return BASE;}
+	YY_BREAK
+case 13:
+YY_RULE_SETUP
+#line 46 "./deflex.l"
+{ return CONSTANT; }
+	YY_BREAK
+case 14:
+YY_RULE_SETUP
+#line 47 "./deflex.l"
+{ return NONAME; }
+	YY_BREAK
+case 15:
+YY_RULE_SETUP
+#line 48 "./deflex.l"
+{ return READ;}
+	YY_BREAK
+case 16:
+YY_RULE_SETUP
+#line 49 "./deflex.l"
+{ return WRITE;}
+	YY_BREAK
+case 17:
+YY_RULE_SETUP
+#line 50 "./deflex.l"
+{ return EXECUTE;}
+	YY_BREAK
+case 18:
+YY_RULE_SETUP
+#line 51 "./deflex.l"
+{ return SHARED;}
+	YY_BREAK
+case 19:
+YY_RULE_SETUP
+#line 53 "./deflex.l"
+{ yylval.number = strtol (yytext,0,0); 
+		return NUMBER; }
+	YY_BREAK
+case 20:
+YY_RULE_SETUP
+#line 56 "./deflex.l"
+{ 	
+		yylval.id =  strdup(yytext);
+		return ID;
+		}
+	YY_BREAK
+case 21:
+YY_RULE_SETUP
+#line 61 "./deflex.l"
+{
+		yylval.id = strdup (yytext+1);
+		yylval.id[yyleng-2] = 0;
+		return ID;
+		}
+	YY_BREAK
+case 22:
+YY_RULE_SETUP
+#line 67 "./deflex.l"
+{
+		yylval.id = strdup (yytext+1);
+		yylval.id[yyleng-2] = 0;
+		return ID;
+		}
+	YY_BREAK
+case 23:
+YY_RULE_SETUP
+#line 72 "./deflex.l"
+{ }
+	YY_BREAK
+case 24:
+YY_RULE_SETUP
+#line 73 "./deflex.l"
+{ }
+	YY_BREAK
+case 25:
+YY_RULE_SETUP
+#line 74 "./deflex.l"
+{ }
+	YY_BREAK
+case 26:
+YY_RULE_SETUP
+#line 75 "./deflex.l"
+{ }
+	YY_BREAK
+case 27:
+YY_RULE_SETUP
+#line 76 "./deflex.l"
+{ linenumber ++ ;}
+	YY_BREAK
+case 28:
+YY_RULE_SETUP
+#line 77 "./deflex.l"
+{ return '=';}
+	YY_BREAK
+case 29:
+YY_RULE_SETUP
+#line 78 "./deflex.l"
+{ return '.';}
+	YY_BREAK
+case 30:
+YY_RULE_SETUP
+#line 79 "./deflex.l"
+{ return '@';}
+	YY_BREAK
+case 31:
+YY_RULE_SETUP
+#line 80 "./deflex.l"
+{ return ',';}
+	YY_BREAK
+case 32:
+YY_RULE_SETUP
+#line 81 "./deflex.l"
+ECHO;
+	YY_BREAK
+#line 883 "lex.yy.c"
+case YY_STATE_EOF(INITIAL):
+	yyterminate();
+
+	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;
+
+		if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
+			{
+			/* We're scanning a new file or input source.  It's
+			 * possible that this happened because the user
+			 * just pointed yyin at a new source and called
+			 * yylex().  If so, then we have to assure
+			 * consistency between yy_current_buffer and our
+			 * globals.  Here is the right place to do so, because
+			 * this is the first action (other than possibly a
+			 * back-up) that will match for the new input source.
+			 */
+			yy_n_chars = yy_current_buffer->yy_n_chars;
+			yy_current_buffer->yy_input_file = yyin;
+			yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
+			}
+
+		/* Note that here we test for yy_c_buf_p "<=" to the position
+		 * of the first EOB in the buffer, since yy_c_buf_p will
+		 * already have been incremented past the NUL character
+		 * (since all states make transitions on EOB to the
+		 * end-of-buffer state).  Contrast this with the test
+		 * in input().
+		 */
+		if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
+			{ /* This was really a NUL. */
+			yy_state_type yy_next_state;
+
+			yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
+
+			yy_current_state = yy_get_previous_state();
+
+			/* Okay, we're now positioned to make the NUL
+			 * transition.  We couldn't have
+			 * yy_get_previous_state() go ahead and do it
+			 * for us because it doesn't know how to deal
+			 * with the possibility of jamming (and we don't
+			 * want to build jamming into it because then it
+			 * will run more slowly).
+			 */
+
+			yy_next_state = yy_try_NUL_trans( yy_current_state );
+
+			yy_bp = yytext_ptr + YY_MORE_ADJ;
+
+			if ( yy_next_state )
+				{
+				/* Consume the NUL. */
+				yy_cp = ++yy_c_buf_p;
+				yy_current_state = yy_next_state;
+				goto yy_match;
+				}
+
+			else
+				{
+				yy_cp = yy_c_buf_p;
+				goto yy_find_action;
+				}
+			}
+
+		else switch ( yy_get_next_buffer() )
+			{
+			case EOB_ACT_END_OF_FILE:
+				{
+				yy_did_buffer_switch_on_eof = 0;
+
+				if ( yywrap() )
+					{
+					/* Note: because we've taken care in
+					 * yy_get_next_buffer() to have set up
+					 * yytext, we can now set up
+					 * yy_c_buf_p so that if some total
+					 * hoser (like flex itself) wants to
+					 * call the scanner after we return the
+					 * YY_NULL, it'll still work - another
+					 * YY_NULL will get returned.
+					 */
+					yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
+
+					yy_act = YY_STATE_EOF(YY_START);
+					goto do_action;
+					}
+
+				else
+					{
+					if ( ! yy_did_buffer_switch_on_eof )
+						YY_NEW_FILE;
+					}
+				break;
+				}
+
+			case EOB_ACT_CONTINUE_SCAN:
+				yy_c_buf_p =
+					yytext_ptr + yy_amount_of_matched_text;
+
+				yy_current_state = yy_get_previous_state();
+
+				yy_cp = yy_c_buf_p;
+				yy_bp = yytext_ptr + YY_MORE_ADJ;
+				goto yy_match;
+
+			case EOB_ACT_LAST_MATCH:
+				yy_c_buf_p =
+				&yy_current_buffer->yy_ch_buf[yy_n_chars];
+
+				yy_current_state = yy_get_previous_state();
+
+				yy_cp = yy_c_buf_p;
+				yy_bp = yytext_ptr + YY_MORE_ADJ;
+				goto yy_find_action;
+			}
+		break;
+		}
+
+	default:
+		YY_FATAL_ERROR(
+			"fatal flex scanner internal error--no action found" );
+	} /* end of action switch */
+		} /* end of scanning one token */
+	} /* end of yylex */
+
+
+/* yy_get_next_buffer - try to read in a new buffer
+ *
+ * Returns a code representing an action:
+ *	EOB_ACT_LAST_MATCH -
+ *	EOB_ACT_CONTINUE_SCAN - continue scanning from current position
+ *	EOB_ACT_END_OF_FILE - end of file
+ */
+
+static int yy_get_next_buffer()
+	{
+	register char *dest = yy_current_buffer->yy_ch_buf;
+	register char *source = yytext_ptr;
+	register int number_to_move, i;
+	int ret_val;
+
+	if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
+		YY_FATAL_ERROR(
+		"fatal flex scanner internal error--end of buffer missed" );
+
+	if ( yy_current_buffer->yy_fill_buffer == 0 )
+		{ /* Don't try to fill the buffer, so this is an EOF. */
+		if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
+			{
+			/* We matched a singled characater, the EOB, so
+			 * treat this as a final EOF.
+			 */
+			return EOB_ACT_END_OF_FILE;
+			}
+
+		else
+			{
+			/* We matched some text prior to the EOB, first
+			 * process it.
+			 */
+			return EOB_ACT_LAST_MATCH;
+			}
+		}
+
+	/* Try to read more data. */
+
+	/* First move last chars to start of buffer. */
+	number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
+
+	for ( i = 0; i < number_to_move; ++i )
+		*(dest++) = *(source++);
+
+	if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
+		/* don't do the read, it's not guaranteed to return an EOF,
+		 * just force an EOF
+		 */
+		yy_n_chars = 0;
+
+	else
+		{
+		int num_to_read =
+			yy_current_buffer->yy_buf_size - number_to_move - 1;
+
+		while ( num_to_read <= 0 )
+			{ /* Not enough room in the buffer - grow it. */
+#ifdef YY_USES_REJECT
+			YY_FATAL_ERROR(
+"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
+#else
+
+			/* just a shorter name for the current buffer */
+			YY_BUFFER_STATE b = yy_current_buffer;
+
+			int yy_c_buf_p_offset =
+				(int) (yy_c_buf_p - b->yy_ch_buf);
+
+			if ( b->yy_is_our_buffer )
+				{
+				int new_size = b->yy_buf_size * 2;
+
+				if ( new_size <= 0 )
+					b->yy_buf_size += b->yy_buf_size / 8;
+				else
+					b->yy_buf_size *= 2;
+
+				b->yy_ch_buf = (char *)
+					/* Include room in for 2 EOB chars. */
+					yy_flex_realloc( (void *) b->yy_ch_buf,
+							 b->yy_buf_size + 2 );
+				}
+			else
+				/* Can't grow it, we don't own it. */
+				b->yy_ch_buf = 0;
+
+			if ( ! b->yy_ch_buf )
+				YY_FATAL_ERROR(
+				"fatal error - scanner input buffer overflow" );
+
+			yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
+
+			num_to_read = yy_current_buffer->yy_buf_size -
+						number_to_move - 1;
+#endif
+			}
+
+		if ( num_to_read > YY_READ_BUF_SIZE )
+			num_to_read = YY_READ_BUF_SIZE;
+
+		/* Read in more data. */
+		YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
+			yy_n_chars, num_to_read );
+		}
+
+	if ( yy_n_chars == 0 )
+		{
+		if ( number_to_move == YY_MORE_ADJ )
+			{
+			ret_val = EOB_ACT_END_OF_FILE;
+			yyrestart( yyin );
+			}
+
+		else
+			{
+			ret_val = EOB_ACT_LAST_MATCH;
+			yy_current_buffer->yy_buffer_status =
+				YY_BUFFER_EOF_PENDING;
+			}
+		}
+
+	else
+		ret_val = EOB_ACT_CONTINUE_SCAN;
+
+	yy_n_chars += number_to_move;
+	yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
+	yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
+
+	yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
+
+	return ret_val;
+	}
+
+
+/* yy_get_previous_state - get the state just before the EOB char was reached */
+
+static yy_state_type yy_get_previous_state()
+	{
+	register yy_state_type yy_current_state;
+	register char *yy_cp;
+
+	yy_current_state = yy_start;
+
+	for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
+		{
+		register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
+		if ( yy_accept[yy_current_state] )
+			{
+			yy_last_accepting_state = yy_current_state;
+			yy_last_accepting_cpos = yy_cp;
+			}
+		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+			{
+			yy_current_state = (int) yy_def[yy_current_state];
+			if ( yy_current_state >= 135 )
+				yy_c = yy_meta[(unsigned int) yy_c];
+			}
+		yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+		}
+
+	return yy_current_state;
+	}
+
+
+/* yy_try_NUL_trans - try to make a transition on the NUL character
+ *
+ * synopsis
+ *	next_state = yy_try_NUL_trans( current_state );
+ */
+
+#ifdef YY_USE_PROTOS
+static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
+#else
+static yy_state_type yy_try_NUL_trans( yy_current_state )
+yy_state_type yy_current_state;
+#endif
+	{
+	register int yy_is_jam;
+	register char *yy_cp = yy_c_buf_p;
+
+	register YY_CHAR yy_c = 1;
+	if ( yy_accept[yy_current_state] )
+		{
+		yy_last_accepting_state = yy_current_state;
+		yy_last_accepting_cpos = yy_cp;
+		}
+	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+		{
+		yy_current_state = (int) yy_def[yy_current_state];
+		if ( yy_current_state >= 135 )
+			yy_c = yy_meta[(unsigned int) yy_c];
+		}
+	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+	yy_is_jam = (yy_current_state == 134);
+
+	return yy_is_jam ? 0 : yy_current_state;
+	}
+
+
+#ifndef YY_NO_UNPUT
+#ifdef YY_USE_PROTOS
+static void yyunput( int c, register char *yy_bp )
+#else
+static void yyunput( c, yy_bp )
+int c;
+register char *yy_bp;
+#endif
+	{
+	register char *yy_cp = yy_c_buf_p;
+
+	/* undo effects of setting up yytext */
+	*yy_cp = yy_hold_char;
+
+	if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
+		{ /* need to shift things up to make room */
+		/* +2 for EOB chars. */
+		register int number_to_move = yy_n_chars + 2;
+		register char *dest = &yy_current_buffer->yy_ch_buf[
+					yy_current_buffer->yy_buf_size + 2];
+		register char *source =
+				&yy_current_buffer->yy_ch_buf[number_to_move];
+
+		while ( source > yy_current_buffer->yy_ch_buf )
+			*--dest = *--source;
+
+		yy_cp += (int) (dest - source);
+		yy_bp += (int) (dest - source);
+		yy_n_chars = yy_current_buffer->yy_buf_size;
+
+		if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
+			YY_FATAL_ERROR( "flex scanner push-back overflow" );
+		}
+
+	*--yy_cp = (char) c;
+
+
+	yytext_ptr = yy_bp;
+	yy_hold_char = *yy_cp;
+	yy_c_buf_p = yy_cp;
+	}
+#endif	/* ifndef YY_NO_UNPUT */
+
+
+#ifdef __cplusplus
+static int yyinput()
+#else
+static int input()
+#endif
+	{
+	int c;
+
+	*yy_c_buf_p = yy_hold_char;
+
+	if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
+		{
+		/* yy_c_buf_p now points to the character we want to return.
+		 * If this occurs *before* the EOB characters, then it's a
+		 * valid NUL; if not, then we've hit the end of the buffer.
+		 */
+		if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
+			/* This was really a NUL. */
+			*yy_c_buf_p = '\0';
+
+		else
+			{ /* need more input */
+			yytext_ptr = yy_c_buf_p;
+			++yy_c_buf_p;
+
+			switch ( yy_get_next_buffer() )
+				{
+				case EOB_ACT_END_OF_FILE:
+					{
+					if ( yywrap() )
+						{
+						yy_c_buf_p =
+						yytext_ptr + YY_MORE_ADJ;
+						return EOF;
+						}
+
+					if ( ! yy_did_buffer_switch_on_eof )
+						YY_NEW_FILE;
+#ifdef __cplusplus
+					return yyinput();
+#else
+					return input();
+#endif
+					}
+
+				case EOB_ACT_CONTINUE_SCAN:
+					yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
+					break;
+
+				case EOB_ACT_LAST_MATCH:
+#ifdef __cplusplus
+					YY_FATAL_ERROR(
+					"unexpected last match in yyinput()" );
+#else
+					YY_FATAL_ERROR(
+					"unexpected last match in input()" );
+#endif
+				}
+			}
+		}
+
+	c = *(unsigned char *) yy_c_buf_p;	/* cast for 8-bit char's */
+	*yy_c_buf_p = '\0';	/* preserve yytext */
+	yy_hold_char = *++yy_c_buf_p;
+
+
+	return c;
+	}
+
+
+#ifdef YY_USE_PROTOS
+void yyrestart( FILE *input_file )
+#else
+void yyrestart( input_file )
+FILE *input_file;
+#endif
+	{
+	if ( ! yy_current_buffer )
+		yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
+
+	yy_init_buffer( yy_current_buffer, input_file );
+	yy_load_buffer_state();
+	}
+
+
+#ifdef YY_USE_PROTOS
+void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
+#else
+void yy_switch_to_buffer( new_buffer )
+YY_BUFFER_STATE new_buffer;
+#endif
+	{
+	if ( yy_current_buffer == new_buffer )
+		return;
+
+	if ( yy_current_buffer )
+		{
+		/* Flush out information for old buffer. */
+		*yy_c_buf_p = yy_hold_char;
+		yy_current_buffer->yy_buf_pos = yy_c_buf_p;
+		yy_current_buffer->yy_n_chars = yy_n_chars;
+		}
+
+	yy_current_buffer = new_buffer;
+	yy_load_buffer_state();
+
+	/* We don't actually know whether we did this switch during
+	 * EOF (yywrap()) processing, but the only time this flag
+	 * is looked at is after yywrap() is called, so it's safe
+	 * to go ahead and always set it.
+	 */
+	yy_did_buffer_switch_on_eof = 1;
+	}
+
+
+#ifdef YY_USE_PROTOS
+void yy_load_buffer_state( void )
+#else
+void yy_load_buffer_state()
+#endif
+	{
+	yy_n_chars = yy_current_buffer->yy_n_chars;
+	yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
+	yyin = yy_current_buffer->yy_input_file;
+	yy_hold_char = *yy_c_buf_p;
+	}
+
+
+#ifdef YY_USE_PROTOS
+YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
+#else
+YY_BUFFER_STATE yy_create_buffer( file, size )
+FILE *file;
+int size;
+#endif
+	{
+	YY_BUFFER_STATE b;
+
+	b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
+	if ( ! b )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+
+	b->yy_buf_size = size;
+
+	/* yy_ch_buf has to be 2 characters longer than the size given because
+	 * we need to put in 2 end-of-buffer characters.
+	 */
+	b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
+	if ( ! b->yy_ch_buf )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+
+	b->yy_is_our_buffer = 1;
+
+	yy_init_buffer( b, file );
+
+	return b;
+	}
+
+
+#ifdef YY_USE_PROTOS
+void yy_delete_buffer( YY_BUFFER_STATE b )
+#else
+void yy_delete_buffer( b )
+YY_BUFFER_STATE b;
+#endif
+	{
+	if ( ! b )
+		return;
+
+	if ( b == yy_current_buffer )
+		yy_current_buffer = (YY_BUFFER_STATE) 0;
+
+	if ( b->yy_is_our_buffer )
+		yy_flex_free( (void *) b->yy_ch_buf );
+
+	yy_flex_free( (void *) b );
+	}
+
+
+#ifndef YY_ALWAYS_INTERACTIVE
+#ifndef YY_NEVER_INTERACTIVE
+extern int isatty YY_PROTO(( int ));
+#endif
+#endif
+
+#ifdef YY_USE_PROTOS
+void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
+#else
+void yy_init_buffer( b, file )
+YY_BUFFER_STATE b;
+FILE *file;
+#endif
+
+
+	{
+	yy_flush_buffer( b );
+
+	b->yy_input_file = file;
+	b->yy_fill_buffer = 1;
+
+#if YY_ALWAYS_INTERACTIVE
+	b->yy_is_interactive = 1;
+#else
+#if YY_NEVER_INTERACTIVE
+	b->yy_is_interactive = 0;
+#else
+	b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
+#endif
+#endif
+	}
+
+
+#ifdef YY_USE_PROTOS
+void yy_flush_buffer( YY_BUFFER_STATE b )
+#else
+void yy_flush_buffer( b )
+YY_BUFFER_STATE b;
+#endif
+
+	{
+	b->yy_n_chars = 0;
+
+	/* We always need two end-of-buffer characters.  The first causes
+	 * a transition to the end-of-buffer state.  The second causes
+	 * a jam in that state.
+	 */
+	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
+	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
+
+	b->yy_buf_pos = &b->yy_ch_buf[0];
+
+	b->yy_at_bol = 1;
+	b->yy_buffer_status = YY_BUFFER_NEW;
+
+	if ( b == yy_current_buffer )
+		yy_load_buffer_state();
+	}
+
+
+#ifndef YY_NO_SCAN_BUFFER
+#ifdef YY_USE_PROTOS
+YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
+#else
+YY_BUFFER_STATE yy_scan_buffer( base, size )
+char *base;
+yy_size_t size;
+#endif
+	{
+	YY_BUFFER_STATE b;
+
+	if ( size < 2 ||
+	     base[size-2] != YY_END_OF_BUFFER_CHAR ||
+	     base[size-1] != YY_END_OF_BUFFER_CHAR )
+		/* They forgot to leave room for the EOB's. */
+		return 0;
+
+	b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
+	if ( ! b )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
+
+	b->yy_buf_size = size - 2;	/* "- 2" to take care of EOB's */
+	b->yy_buf_pos = b->yy_ch_buf = base;
+	b->yy_is_our_buffer = 0;
+	b->yy_input_file = 0;
+	b->yy_n_chars = b->yy_buf_size;
+	b->yy_is_interactive = 0;
+	b->yy_at_bol = 1;
+	b->yy_fill_buffer = 0;
+	b->yy_buffer_status = YY_BUFFER_NEW;
+
+	yy_switch_to_buffer( b );
+
+	return b;
+	}
+#endif
+
+
+#ifndef YY_NO_SCAN_STRING
+#ifdef YY_USE_PROTOS
+YY_BUFFER_STATE yy_scan_string( yyconst char *str )
+#else
+YY_BUFFER_STATE yy_scan_string( str )
+yyconst char *str;
+#endif
+	{
+	int len;
+	for ( len = 0; str[len]; ++len )
+		;
+
+	return yy_scan_bytes( str, len );
+	}
+#endif
+
+
+#ifndef YY_NO_SCAN_BYTES
+#ifdef YY_USE_PROTOS
+YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
+#else
+YY_BUFFER_STATE yy_scan_bytes( bytes, len )
+yyconst char *bytes;
+int len;
+#endif
+	{
+	YY_BUFFER_STATE b;
+	char *buf;
+	yy_size_t n;
+	int i;
+
+	/* Get memory for full buffer, including space for trailing EOB's. */
+	n = len + 2;
+	buf = (char *) yy_flex_alloc( n );
+	if ( ! buf )
+		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
+
+	for ( i = 0; i < len; ++i )
+		buf[i] = bytes[i];
+
+	buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
+
+	b = yy_scan_buffer( buf, n );
+	if ( ! b )
+		YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
+
+	/* It's okay to grow etc. this buffer, and we should throw it
+	 * away when we're done.
+	 */
+	b->yy_is_our_buffer = 1;
+
+	return b;
+	}
+#endif
+
+
+#ifndef YY_NO_PUSH_STATE
+#ifdef YY_USE_PROTOS
+static void yy_push_state( int new_state )
+#else
+static void yy_push_state( new_state )
+int new_state;
+#endif
+	{
+	if ( yy_start_stack_ptr >= yy_start_stack_depth )
+		{
+		yy_size_t new_size;
+
+		yy_start_stack_depth += YY_START_STACK_INCR;
+		new_size = yy_start_stack_depth * sizeof( int );
+
+		if ( ! yy_start_stack )
+			yy_start_stack = (int *) yy_flex_alloc( new_size );
+
+		else
+			yy_start_stack = (int *) yy_flex_realloc(
+					(void *) yy_start_stack, new_size );
+
+		if ( ! yy_start_stack )
+			YY_FATAL_ERROR(
+			"out of memory expanding start-condition stack" );
+		}
+
+	yy_start_stack[yy_start_stack_ptr++] = YY_START;
+
+	BEGIN(new_state);
+	}
+#endif
+
+
+#ifndef YY_NO_POP_STATE
+static void yy_pop_state()
+	{
+	if ( --yy_start_stack_ptr < 0 )
+		YY_FATAL_ERROR( "start-condition stack underflow" );
+
+	BEGIN(yy_start_stack[yy_start_stack_ptr]);
+	}
+#endif
+
+
+#ifndef YY_NO_TOP_STATE
+static int yy_top_state()
+	{
+	return yy_start_stack[yy_start_stack_ptr - 1];
+	}
+#endif
+
+#ifndef YY_EXIT_FAILURE
+#define YY_EXIT_FAILURE 2
+#endif
+
+#ifdef YY_USE_PROTOS
+static void yy_fatal_error( yyconst char msg[] )
+#else
+static void yy_fatal_error( msg )
+char msg[];
+#endif
+	{
+	(void) fprintf( stderr, "%s\n", msg );
+	exit( YY_EXIT_FAILURE );
+	}
+
+
+
+/* Redefine yyless() so it works in section 3 code. */
+
+#undef yyless
+#define yyless(n) \
+	do \
+		{ \
+		/* Undo effects of setting up yytext. */ \
+		yytext[yyleng] = yy_hold_char; \
+		yy_c_buf_p = yytext + n - YY_MORE_ADJ; \
+		yy_hold_char = *yy_c_buf_p; \
+		*yy_c_buf_p = '\0'; \
+		yyleng = n; \
+		} \
+	while ( 0 )
+
+
+/* Internal utility routines. */
+
+#ifndef yytext_ptr
+#ifdef YY_USE_PROTOS
+static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
+#else
+static void yy_flex_strncpy( s1, s2, n )
+char *s1;
+yyconst char *s2;
+int n;
+#endif
+	{
+	register int i;
+	for ( i = 0; i < n; ++i )
+		s1[i] = s2[i];
+	}
+#endif
+
+
+#ifdef YY_USE_PROTOS
+static void *yy_flex_alloc( yy_size_t size )
+#else
+static void *yy_flex_alloc( size )
+yy_size_t size;
+#endif
+	{
+	return (void *) malloc( size );
+	}
+
+#ifdef YY_USE_PROTOS
+static void *yy_flex_realloc( void *ptr, yy_size_t size )
+#else
+static void *yy_flex_realloc( ptr, size )
+void *ptr;
+yy_size_t size;
+#endif
+	{
+	/* The cast to (char *) in the following accommodates both
+	 * implementations that use char* generic pointers, and those
+	 * that use void* generic pointers.  It works with the latter
+	 * because both ANSI C and C++ allow castless assignment from
+	 * any pointer type to void*, and deal with argument conversions
+	 * as though doing an assignment.
+	 */
+	return (void *) realloc( (char *) ptr, size );
+	}
+
+#ifdef YY_USE_PROTOS
+static void yy_flex_free( void *ptr )
+#else
+static void yy_flex_free( ptr )
+void *ptr;
+#endif
+	{
+	free( ptr );
+	}
+
+#if YY_MAIN
+int main()
+	{
+	yylex();
+	return 0;
+	}
+#endif
+#line 81 "./deflex.l"
+
+#ifndef yywrap
+/* Needed for lex, though not flex. */
+int yywrap() { return 1; }
+#endif
diff --git a/gnu/usr.bin/binutils/makefile.vms b/gnu/usr.bin/binutils/makefile.vms
new file mode 100644
index 00000000000..164b57a0725
--- /dev/null
+++ b/gnu/usr.bin/binutils/makefile.vms
@@ -0,0 +1,37 @@
+#
+# makefile for bfd, binutils and gas
+#
+# Created by Klaus K"ampf (kkaempf@progis.de)
+#
+# You must use Version 3.75p (proGIS enhanced) of GNU Make
+#
+#
+CC = gcc
+
+all:
+	$$ @setup
+	$(CD) [.bfd]
+	gmake "CC=$(CC)"
+	$(CD) [-.opcodes]
+	gmake "CC=$(CC)"
+	$(CD) [-.libiberty]
+	gmake "CC=$(CC)"
+	$(CD) [-.binutils]
+	gmake "CC=$(CC)"
+	$(CD) [-.gas]
+	gmake "CC=$(CC)"
+	$(CD) [-]
+
+clean:
+	$(CD) [.bfd]
+	gmake clean
+	$(CD) [-.opcodes]
+	gmake clean
+	$(CD) [-.libiberty]
+	gmake clean
+	$(CD) [-.binutils]
+	gmake clean
+	$(CD) [-.gas]
+	gmake clean
+	$(CD) [-]
+
diff --git a/gnu/usr.bin/binutils/mpw-install b/gnu/usr.bin/binutils/mpw-install
new file mode 100644
index 00000000000..04c5aac2a4f
--- /dev/null
+++ b/gnu/usr.bin/binutils/mpw-install
@@ -0,0 +1,122 @@
+# GNU Install script for MPW.
+
+Set OldExit "{Exit}"
+Set Exit 0
+
+Set TempUserStartup "{TempFolder}"__temp__UserStartup
+
+Echo '# UserStartup generated by GNU Install script' > "{TempUserStartup}"
+Echo ''						>> "{TempUserStartup}"
+
+# (should) Check that disk space is sufficient for installation.
+
+# Assume that the install script is where everything else is.
+
+Set thisdir "`Directory`"
+
+# Copy the binaries to the desired place.
+
+Confirm -t "Copy the binaries to somewhere else?"
+Set TmpStatus {Status}
+If {TmpStatus} == 0
+	Set bindest "`GetFileName -d -m "Where to install the binaries?"`"
+	If {Status} == 0
+		If "`Exists "{thisdir}bin"`" != ""
+			For afile In "{thisdir}"bin:\Option-x
+				Duplicate -y "{afile}" "{bindest}"
+			End For
+		Else
+			Echo "bin directory not found, exiting"
+			Exit 1
+		End If
+	Else
+		Echo "No destination supplied, exiting"
+		Exit 1
+	End If
+Else If {TmpStatus} == 4
+	# Use the existing directory.
+	Set bindest "{thisdir}bin:"
+Else
+	# Cancelled from confirmation, escape altogether.
+	Exit 1
+End If
+
+# Copy the libraries to the desired place.
+
+Confirm -t "Copy the libraries to somewhere else?"
+Set TmpStatus {Status}
+If {TmpStatus} == 0
+	Set libdest "`GetFileName -d -m "Where to install the libraries?"`"
+	If {Status} == 0
+		If "`Exists "{thisdir}lib:"`" != ""
+			For afile In "{thisdir}"lib:\Option-x
+				Duplicate -y "{afile}" "{libdest}"
+			End For
+		Else
+			Echo "lib directory not found, exiting"
+			Exit 1
+		End If
+	Else
+		Echo "No destination supplied, exiting"
+		Exit 1
+	End If
+Else If {TmpStatus} == 4
+	# Use the existing directory.
+	Set libdest "{thisdir}lib:"
+Else
+	# Cancelled from confirmation, escape altogether.
+	Exit 1
+End If
+
+
+# Add the location of the binaries to the command path.
+
+Echo -n 'Set Commands "'			>> "{TempUserStartup}"
+Echo -n "{bindest}"				>> "{TempUserStartup}"
+Echo    ',{Commands}"'				>> "{TempUserStartup}"
+Echo ''						>> "{TempUserStartup}"
+
+# Set up GCC exec prefix.
+
+Set gcclibdir "{libdest}"gcc-lib:
+
+Echo -n 'Set GCC_EXEC_PREFIX "'			>> "{TempUserStartup}"
+Echo -n "{gcclibdir}"				>> "{TempUserStartup}"
+Echo    '"'					>> "{TempUserStartup}"
+Echo "Export GCC_EXEC_PREFIX"			>> "{TempUserStartup}"
+Echo ''						>> "{TempUserStartup}"
+
+# Set up path to libgcc.xcoff etc.
+
+Echo -n 'Set GCCPPCLibraries "'			>> "{TempUserStartup}"
+Echo -n "{libdest}"				>> "{TempUserStartup}"
+Echo    '"'					>> "{TempUserStartup}"
+Echo "Export GCCPPCLibraries"			>> "{TempUserStartup}"
+Echo ''						>> "{TempUserStartup}"
+
+# Display contents of UserStartup, confirm installation.
+
+Set UserStartupName "UserStartup\Option-8GNU"
+
+Echo "Contents of" {UserStartupName} "will be:"
+Catenate "{TempUserStartup}"
+
+Confirm "Install {UserStartupName} into the MPW folder {MPW} ?"
+If {Status} == 0
+	Duplicate "{TempUserStartup}" "{MPW}{UserStartupName}"
+	Delete -y "{TempUserStartup}"
+Else
+	Echo "{UserStartupName} file not installed"
+End If
+
+# (should) Check HEXA resource, warn if low.
+
+# (should) Check for spaces in pathnames, warn if found.
+
+Echo "Installation was successful."
+Echo ""
+Echo "Be sure to review the usage notes in 'Read Me for MPW' before proceeding!"
+
+# Restore previous settings.
+
+Set Exit "{OldExit}"
diff --git a/gnu/usr.bin/binutils/setup.com b/gnu/usr.bin/binutils/setup.com
new file mode 100644
index 00000000000..553afd55ae1
--- /dev/null
+++ b/gnu/usr.bin/binutils/setup.com
@@ -0,0 +1,8 @@
+$! setup files for openVMS/Alpha
+$!
+$ define aout [-.INCLUDE.AOUT]
+$ define coff [-.INCLUDE.COFF]
+$ define elf [-.INCLUDE.ELF]
+$ define mpw [-.INCLUDE.MPW]
+$ define nlm [-.INCLUDE.NLM]
+$ define opcode [-.INCLUDE.OPCODE]