/contrib/toolchain/binutils/bfd/plugin.h |
---|
0,0 → 1,36 |
/* Plugin support for BFD. |
Copyright 2009 Free Software Foundation, Inc. |
This file is part of BFD, the Binary File Descriptor library. |
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 3 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., 51 Franklin Street - Fifth Floor, Boston, |
MA 02110-1301, USA. */ |
#ifndef _PLUGIN_H_ |
#define _PLUGIN_H_ |
#include "bfd.h" |
void bfd_plugin_set_program_name (const char *); |
void bfd_plugin_set_plugin (const char *); |
typedef struct plugin_data_struct |
{ |
int nsyms; |
const struct ld_plugin_symbol *syms; |
} |
plugin_data_struct; |
#endif |
/contrib/toolchain/binutils/binutils/Makefile |
---|
1,4 → 1,3 |
NAME= objcopy-new |
LIB_DIR:= $(SDK_DIR)/lib |
20,23 → 19,38 |
SRCS = \ |
arparse.c arlex.c ar.c \ |
not-ranlib.c arsup.c \ |
binemul.c emul_vanilla.c \ |
objcopy.c not-strip.c rename.c \ |
rddbg.c debug.c stabs.c ieee.c \ |
rdcoff.c wrstabs.c bucomm.c \ |
version.c filemode.c |
OCOPY = \ |
objcopy.o not-strip.o rename.o \ |
rddbg.o debug.o stabs.o ieee.o \ |
rdcoff.o wrstabs.o bucomm.o \ |
version.o filemode.o |
OAR = \ |
arparse.o arlex.o ar.o \ |
not-ranlib.o arsup.o rename.o \ |
binemul.o emul_vanilla.o \ |
bucomm.o version.o filemode.o |
OBJS = $(patsubst %.cpp, %.o, $(patsubst %.c, %.o, $(SRCS))) |
# targets |
all: $(NAME) |
all: objcopy ar |
$(NAME): $(OBJS) Makefile |
$(LD) $(LDFLAGS) $(LIBPATH) -o $@ $(OBJS) $(LIBS) |
kos32-objcopy $@ kos32-objcopy -O binary |
objcopy: $(OCOPY) Makefile |
$(LD) $(LDFLAGS) $(LIBPATH) -o $@ $(OCOPY) $(LIBS) |
kos32-objcopy $@ -O binary |
ar: $(OAR) Makefile |
$(LD) $(LDFLAGS) $(LIBPATH) -o $@ $(OAR) $(LIBS) |
kos32-objcopy $@ -O binary |
%.o : %.c Makefile |
$(CC) $(CFLAGS) $(DEFINES) $(INCLUDES) -o $@ $< |
/contrib/toolchain/binutils/binutils/ar.c |
---|
0,0 → 1,1478 |
/* ar.c - Archive modify and extract. |
Copyright 1991-2013 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 3 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., 51 Franklin Street - Fifth Floor, Boston, |
MA 02110-1301, USA. */ |
/* |
Bugs: GNU ar used to check file against filesystem in quick_update and |
replace operations (would check mtime). Doesn't warn when name truncated. |
No way to specify pos_end. Error messages should be more consistent. */ |
#include "sysdep.h" |
#include "bfd.h" |
#include "libiberty.h" |
#include "progress.h" |
#include "getopt.h" |
#include "aout/ar.h" |
#include "libbfd.h" |
#include "bucomm.h" |
#include "arsup.h" |
#include "filenames.h" |
#include "binemul.h" |
#include "plugin.h" |
#ifdef __GO32___ |
#define EXT_NAME_LEN 3 /* Bufflen of addition to name if it's MS-DOS. */ |
#else |
#define EXT_NAME_LEN 6 /* Ditto for *NIX. */ |
#endif |
/* Static declarations. */ |
static void mri_emul (void); |
static const char *normalize (const char *, bfd *); |
static void remove_output (void); |
static void map_over_members (bfd *, void (*)(bfd *), char **, int); |
static void print_contents (bfd * member); |
static void delete_members (bfd *, char **files_to_delete); |
static void move_members (bfd *, char **files_to_move); |
static void replace_members |
(bfd *, char **files_to_replace, bfd_boolean quick); |
static void print_descr (bfd * abfd); |
static void write_archive (bfd *); |
static int ranlib_only (const char *archname); |
static int ranlib_touch (const char *archname); |
static void usage (int); |
/** Globals and flags. */ |
static int mri_mode; |
/* This flag distinguishes between ar and ranlib: |
1 means this is 'ranlib'; 0 means this is 'ar'. |
-1 means if we should use argv[0] to decide. */ |
extern int is_ranlib; |
/* Nonzero means don't warn about creating the archive file if necessary. */ |
int silent_create = 0; |
/* Nonzero means describe each action performed. */ |
int verbose = 0; |
/* Nonzero means preserve dates of members when extracting them. */ |
int preserve_dates = 0; |
/* Nonzero means don't replace existing members whose dates are more recent |
than the corresponding files. */ |
int newer_only = 0; |
/* Controls the writing of an archive symbol table (in BSD: a __.SYMDEF |
member). -1 means we've been explicitly asked to not write a symbol table; |
+1 means we've been explicitly asked to write it; |
0 is the default. |
Traditionally, the default in BSD has been to not write the table. |
However, for POSIX.2 compliance the default is now to write a symbol table |
if any of the members are object files. */ |
int write_armap = 0; |
/* Operate in deterministic mode: write zero for timestamps, uids, |
and gids for archive members and the archive symbol table, and write |
consistent file modes. */ |
int deterministic = -1; /* Determinism indeterminate. */ |
/* Nonzero means it's the name of an existing member; position new or moved |
files with respect to this one. */ |
char *posname = NULL; |
/* Sez how to use `posname': pos_before means position before that member. |
pos_after means position after that member. pos_end means always at end. |
pos_default means default appropriately. For the latter two, `posname' |
should also be zero. */ |
enum pos |
{ |
pos_default, pos_before, pos_after, pos_end |
} postype = pos_default; |
enum operations |
{ |
none = 0, del, replace, print_table, |
print_files, extract, move, quick_append |
} operation = none; |
static bfd ** |
get_pos_bfd (bfd **, enum pos, const char *); |
/* For extract/delete only. If COUNTED_NAME_MODE is TRUE, we only |
extract the COUNTED_NAME_COUNTER instance of that name. */ |
static bfd_boolean counted_name_mode = 0; |
static int counted_name_counter = 0; |
/* Whether to truncate names of files stored in the archive. */ |
static bfd_boolean ar_truncate = FALSE; |
/* Whether to use a full file name match when searching an archive. |
This is convenient for archives created by the Microsoft lib |
program. */ |
static bfd_boolean full_pathname = FALSE; |
/* Whether to create a "thin" archive (symbol index only -- no files). */ |
static bfd_boolean make_thin_archive = FALSE; |
static int show_version = 0; |
static int show_help = 0; |
static const char *plugin_target = NULL; |
static const char *target = NULL; |
#define OPTION_PLUGIN 201 |
#define OPTION_TARGET 202 |
static struct option long_options[] = |
{ |
{"help", no_argument, &show_help, 1}, |
{"plugin", required_argument, NULL, OPTION_PLUGIN}, |
{"target", required_argument, NULL, OPTION_TARGET}, |
{"version", no_argument, &show_version, 1}, |
{NULL, no_argument, NULL, 0} |
}; |
int interactive = 0; |
static void |
mri_emul (void) |
{ |
interactive = isatty (fileno (stdin)); |
yyparse (); |
} |
/* If COUNT is 0, then FUNCTION is called once on each entry. If nonzero, |
COUNT is the length of the FILES chain; FUNCTION is called on each entry |
whose name matches one in FILES. */ |
static void |
map_over_members (bfd *arch, void (*function)(bfd *), char **files, int count) |
{ |
bfd *head; |
int match_count; |
if (count == 0) |
{ |
for (head = arch->archive_next; head; head = head->archive_next) |
{ |
PROGRESS (1); |
function (head); |
} |
return; |
} |
/* This may appear to be a baroque way of accomplishing what we want. |
However we have to iterate over the filenames in order to notice where |
a filename is requested but does not exist in the archive. Ditto |
mapping over each file each time -- we want to hack multiple |
references. */ |
for (head = arch->archive_next; head; head = head->archive_next) |
head->archive_pass = 0; |
for (; count > 0; files++, count--) |
{ |
bfd_boolean found = FALSE; |
match_count = 0; |
for (head = arch->archive_next; head; head = head->archive_next) |
{ |
const char * filename; |
PROGRESS (1); |
/* PR binutils/15796: Once an archive element has been matched |
do not match it again. If the user provides multiple same-named |
parameters on the command line their intent is to match multiple |
same-named entries in the archive, not the same entry multiple |
times. */ |
if (head->archive_pass) |
continue; |
filename = head->filename; |
if (filename == NULL) |
{ |
/* Some archive formats don't get the filenames filled in |
until the elements are opened. */ |
struct stat buf; |
bfd_stat_arch_elt (head, &buf); |
} |
else if (bfd_is_thin_archive (arch)) |
{ |
/* Thin archives store full pathnames. Need to normalize. */ |
filename = normalize (filename, arch); |
} |
if (filename != NULL |
&& !FILENAME_CMP (normalize (*files, arch), filename)) |
{ |
++match_count; |
if (counted_name_mode |
&& match_count != counted_name_counter) |
{ |
/* Counting, and didn't match on count; go on to the |
next one. */ |
continue; |
} |
found = TRUE; |
function (head); |
head->archive_pass = 1; |
/* PR binutils/15796: Once a file has been matched, do not |
match any more same-named files in the archive. If the |
user does want to match multiple same-name files in an |
archive they should provide multiple same-name parameters |
to the ar command. */ |
break; |
} |
} |
if (!found) |
/* xgettext:c-format */ |
fprintf (stderr, _("no entry %s in archive\n"), *files); |
} |
} |
bfd_boolean operation_alters_arch = FALSE; |
static void |
usage (int help) |
{ |
FILE *s; |
#if BFD_SUPPORTS_PLUGINS |
/* xgettext:c-format */ |
const char *command_line |
= _("Usage: %s [emulation options] [-]{dmpqrstx}[abcDfilMNoPsSTuvV]" |
" [--plugin <name>] [member-name] [count] archive-file file...\n"); |
#else |
/* xgettext:c-format */ |
const char *command_line |
= _("Usage: %s [emulation options] [-]{dmpqrstx}[abcDfilMNoPsSTuvV]" |
" [member-name] [count] archive-file file...\n"); |
#endif |
s = help ? stdout : stderr; |
fprintf (s, command_line, program_name); |
/* xgettext:c-format */ |
fprintf (s, _(" %s -M [<mri-script]\n"), program_name); |
fprintf (s, _(" commands:\n")); |
fprintf (s, _(" d - delete file(s) from the archive\n")); |
fprintf (s, _(" m[ab] - move file(s) in the archive\n")); |
fprintf (s, _(" p - print file(s) found in the archive\n")); |
fprintf (s, _(" q[f] - quick append file(s) to the archive\n")); |
fprintf (s, _(" r[ab][f][u] - replace existing or insert new file(s) into the archive\n")); |
fprintf (s, _(" s - act as ranlib\n")); |
fprintf (s, _(" t - display contents of archive\n")); |
fprintf (s, _(" x[o] - extract file(s) from the archive\n")); |
fprintf (s, _(" command specific modifiers:\n")); |
fprintf (s, _(" [a] - put file(s) after [member-name]\n")); |
fprintf (s, _(" [b] - put file(s) before [member-name] (same as [i])\n")); |
if (DEFAULT_AR_DETERMINISTIC) |
{ |
fprintf (s, _("\ |
[D] - use zero for timestamps and uids/gids (default)\n")); |
fprintf (s, _("\ |
[U] - use actual timestamps and uids/gids\n")); |
} |
else |
{ |
fprintf (s, _("\ |
[D] - use zero for timestamps and uids/gids\n")); |
fprintf (s, _("\ |
[U] - use actual timestamps and uids/gids (default)\n")); |
} |
fprintf (s, _(" [N] - use instance [count] of name\n")); |
fprintf (s, _(" [f] - truncate inserted file names\n")); |
fprintf (s, _(" [P] - use full path names when matching\n")); |
fprintf (s, _(" [o] - preserve original dates\n")); |
fprintf (s, _(" [u] - only replace files that are newer than current archive contents\n")); |
fprintf (s, _(" generic modifiers:\n")); |
fprintf (s, _(" [c] - do not warn if the library had to be created\n")); |
fprintf (s, _(" [s] - create an archive index (cf. ranlib)\n")); |
fprintf (s, _(" [S] - do not build a symbol table\n")); |
fprintf (s, _(" [T] - make a thin archive\n")); |
fprintf (s, _(" [v] - be verbose\n")); |
fprintf (s, _(" [V] - display the version number\n")); |
fprintf (s, _(" @<file> - read options from <file>\n")); |
fprintf (s, _(" --target=BFDNAME - specify the target object format as BFDNAME\n")); |
#if BFD_SUPPORTS_PLUGINS |
fprintf (s, _(" optional:\n")); |
fprintf (s, _(" --plugin <p> - load the specified plugin\n")); |
#endif |
ar_emul_usage (s); |
list_supported_targets (program_name, s); |
if (REPORT_BUGS_TO[0] && help) |
fprintf (s, _("Report bugs to %s\n"), REPORT_BUGS_TO); |
xexit (help ? 0 : 1); |
} |
static void |
ranlib_usage (int help) |
{ |
FILE *s; |
s = help ? stdout : stderr; |
/* xgettext:c-format */ |
fprintf (s, _("Usage: %s [options] archive\n"), program_name); |
fprintf (s, _(" Generate an index to speed access to archives\n")); |
fprintf (s, _(" The options are:\n\ |
@<file> Read options from <file>\n")); |
#if BFD_SUPPORTS_PLUGINS |
fprintf (s, _("\ |
--plugin <name> Load the specified plugin\n")); |
#endif |
if (DEFAULT_AR_DETERMINISTIC) |
fprintf (s, _("\ |
-D Use zero for symbol map timestamp (default)\n\ |
-U Use an actual symbol map timestamp\n")); |
else |
fprintf (s, _("\ |
-D Use zero for symbol map timestamp\n\ |
-U Use actual symbol map timestamp (default)\n")); |
fprintf (s, _("\ |
-t Update the archive's symbol map timestamp\n\ |
-h --help Print this help message\n\ |
-v --version Print version information\n")); |
list_supported_targets (program_name, s); |
if (REPORT_BUGS_TO[0] && help) |
fprintf (s, _("Report bugs to %s\n"), REPORT_BUGS_TO); |
xexit (help ? 0 : 1); |
} |
/* Normalize a file name specified on the command line into a file |
name which we will use in an archive. */ |
static const char * |
normalize (const char *file, bfd *abfd) |
{ |
const char *filename; |
if (full_pathname) |
return file; |
filename = lbasename (file); |
if (ar_truncate |
&& abfd != NULL |
&& strlen (filename) > abfd->xvec->ar_max_namelen) |
{ |
char *s; |
/* Space leak. */ |
s = (char *) xmalloc (abfd->xvec->ar_max_namelen + 1); |
memcpy (s, filename, abfd->xvec->ar_max_namelen); |
s[abfd->xvec->ar_max_namelen] = '\0'; |
filename = s; |
} |
return filename; |
} |
/* Remove any output file. This is only called via xatexit. */ |
static const char *output_filename = NULL; |
static FILE *output_file = NULL; |
static bfd *output_bfd = NULL; |
static void |
remove_output (void) |
{ |
if (output_filename != NULL) |
{ |
if (output_bfd != NULL) |
bfd_cache_close (output_bfd); |
if (output_file != NULL) |
fclose (output_file); |
unlink_if_ordinary (output_filename); |
} |
} |
static char ** |
decode_options (int argc, char **argv) |
{ |
int c; |
/* Convert old-style tar call by exploding option element and rearranging |
options accordingly. */ |
if (argc > 1 && argv[1][0] != '-') |
{ |
int new_argc; /* argc value for rearranged arguments */ |
char **new_argv; /* argv value for rearranged arguments */ |
char *const *in; /* cursor into original argv */ |
char **out; /* cursor into rearranged argv */ |
const char *letter; /* cursor into old option letters */ |
char buffer[3]; /* constructed option buffer */ |
/* Initialize a constructed option. */ |
buffer[0] = '-'; |
buffer[2] = '\0'; |
/* Allocate a new argument array, and copy program name in it. */ |
new_argc = argc - 1 + strlen (argv[1]); |
new_argv = xmalloc ((new_argc + 1) * sizeof (*argv)); |
in = argv; |
out = new_argv; |
*out++ = *in++; |
/* Copy each old letter option as a separate option. */ |
for (letter = *in++; *letter; letter++) |
{ |
buffer[1] = *letter; |
*out++ = xstrdup (buffer); |
} |
/* Copy all remaining options. */ |
while (in < argv + argc) |
*out++ = *in++; |
*out = NULL; |
/* Replace the old option list by the new one. */ |
argc = new_argc; |
argv = new_argv; |
} |
while ((c = getopt_long (argc, argv, "hdmpqrtxlcoVsSuvabiMNfPTDU", |
long_options, NULL)) != EOF) |
{ |
switch (c) |
{ |
case 'd': |
case 'm': |
case 'p': |
case 'q': |
case 'r': |
case 't': |
case 'x': |
if (operation != none) |
fatal (_("two different operation options specified")); |
break; |
} |
switch (c) |
{ |
case 'h': |
show_help = 1; |
break; |
case 'd': |
operation = del; |
operation_alters_arch = TRUE; |
break; |
case 'm': |
operation = move; |
operation_alters_arch = TRUE; |
break; |
case 'p': |
operation = print_files; |
break; |
case 'q': |
operation = quick_append; |
operation_alters_arch = TRUE; |
break; |
case 'r': |
operation = replace; |
operation_alters_arch = TRUE; |
break; |
case 't': |
operation = print_table; |
break; |
case 'x': |
operation = extract; |
break; |
case 'l': |
break; |
case 'c': |
silent_create = 1; |
break; |
case 'o': |
preserve_dates = 1; |
break; |
case 'V': |
show_version = TRUE; |
break; |
case 's': |
write_armap = 1; |
break; |
case 'S': |
write_armap = -1; |
break; |
case 'u': |
newer_only = 1; |
break; |
case 'v': |
verbose = 1; |
break; |
case 'a': |
postype = pos_after; |
break; |
case 'b': |
postype = pos_before; |
break; |
case 'i': |
postype = pos_before; |
break; |
case 'M': |
mri_mode = 1; |
break; |
case 'N': |
counted_name_mode = TRUE; |
break; |
case 'f': |
ar_truncate = TRUE; |
break; |
case 'P': |
full_pathname = TRUE; |
break; |
case 'T': |
make_thin_archive = TRUE; |
break; |
case 'D': |
deterministic = TRUE; |
break; |
case 'U': |
deterministic = FALSE; |
break; |
case OPTION_PLUGIN: |
#if BFD_SUPPORTS_PLUGINS |
plugin_target = "plugin"; |
bfd_plugin_set_plugin (optarg); |
#else |
fprintf (stderr, _("sorry - this program has been built without plugin support\n")); |
xexit (1); |
#endif |
break; |
case OPTION_TARGET: |
target = optarg; |
break; |
case 0: /* A long option that just sets a flag. */ |
break; |
default: |
usage (0); |
} |
} |
return &argv[optind]; |
} |
/* If neither -D nor -U was specified explicitly, |
then use the configured default. */ |
static void |
default_deterministic (void) |
{ |
if (deterministic < 0) |
deterministic = DEFAULT_AR_DETERMINISTIC; |
} |
static void |
ranlib_main (int argc, char **argv) |
{ |
int arg_index, status = 0; |
bfd_boolean touch = FALSE; |
int c; |
while ((c = getopt_long (argc, argv, "DhHUvVt", long_options, NULL)) != EOF) |
{ |
switch (c) |
{ |
case 'D': |
deterministic = TRUE; |
break; |
case 'U': |
deterministic = FALSE; |
break; |
case 'h': |
case 'H': |
show_help = 1; |
break; |
case 't': |
touch = TRUE; |
break; |
case 'v': |
case 'V': |
show_version = 1; |
break; |
/* PR binutils/13493: Support plugins. */ |
case OPTION_PLUGIN: |
#if BFD_SUPPORTS_PLUGINS |
plugin_target = "plugin"; |
bfd_plugin_set_plugin (optarg); |
#else |
fprintf (stderr, _("sorry - this program has been built without plugin support\n")); |
xexit (1); |
#endif |
break; |
} |
} |
if (argc < 2) |
ranlib_usage (0); |
if (show_help) |
ranlib_usage (1); |
if (show_version) |
print_version ("ranlib"); |
default_deterministic (); |
arg_index = optind; |
while (arg_index < argc) |
{ |
if (! touch) |
status |= ranlib_only (argv[arg_index]); |
else |
status |= ranlib_touch (argv[arg_index]); |
++arg_index; |
} |
xexit (status); |
} |
int main (int, char **); |
int |
main (int argc, char **argv) |
{ |
int arg_index; |
char **files; |
int file_count; |
char *inarch_filename; |
int i; |
#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES) |
setlocale (LC_MESSAGES, ""); |
#endif |
#if defined (HAVE_SETLOCALE) |
setlocale (LC_CTYPE, ""); |
#endif |
bindtextdomain (PACKAGE, LOCALEDIR); |
textdomain (PACKAGE); |
program_name = argv[0]; |
xmalloc_set_program_name (program_name); |
#if BFD_SUPPORTS_PLUGINS |
bfd_plugin_set_program_name (program_name); |
#endif |
expandargv (&argc, &argv); |
if (is_ranlib < 0) |
{ |
const char *temp = lbasename (program_name); |
if (strlen (temp) >= 6 |
&& FILENAME_CMP (temp + strlen (temp) - 6, "ranlib") == 0) |
is_ranlib = 1; |
else |
is_ranlib = 0; |
} |
START_PROGRESS (program_name, 0); |
bfd_init (); |
set_default_bfd_target (); |
xatexit (remove_output); |
for (i = 1; i < argc; i++) |
if (! ar_emul_parse_arg (argv[i])) |
break; |
argv += (i - 1); |
argc -= (i - 1); |
if (is_ranlib) |
ranlib_main (argc, argv); |
if (argc < 2) |
usage (0); |
argv = decode_options (argc, argv); |
if (show_help) |
usage (1); |
if (show_version) |
print_version ("ar"); |
arg_index = 0; |
if (mri_mode) |
{ |
mri_emul (); |
} |
else |
{ |
bfd *arch; |
/* We don't use do_quick_append any more. Too many systems |
expect ar to always rebuild the symbol table even when q is |
used. */ |
/* We can't write an armap when using ar q, so just do ar r |
instead. */ |
if (operation == quick_append && write_armap) |
operation = replace; |
if ((operation == none || operation == print_table) |
&& write_armap == 1) |
xexit (ranlib_only (argv[arg_index])); |
if (operation == none) |
fatal (_("no operation specified")); |
if (newer_only && operation != replace) |
fatal (_("`u' is only meaningful with the `r' option.")); |
if (newer_only && deterministic > 0) |
fatal (_("`u' is not meaningful with the `D' option.")); |
if (newer_only && deterministic < 0 && DEFAULT_AR_DETERMINISTIC) |
non_fatal (_("\ |
`u' modifier ignored since `D' is the default (see `U')")); |
default_deterministic (); |
if (postype != pos_default) |
posname = argv[arg_index++]; |
if (counted_name_mode) |
{ |
if (operation != extract && operation != del) |
fatal (_("`N' is only meaningful with the `x' and `d' options.")); |
counted_name_counter = atoi (argv[arg_index++]); |
if (counted_name_counter <= 0) |
fatal (_("Value for `N' must be positive.")); |
} |
inarch_filename = argv[arg_index++]; |
for (file_count = 0; argv[arg_index + file_count] != NULL; file_count++) |
continue; |
files = (file_count > 0) ? argv + arg_index : NULL; |
arch = open_inarch (inarch_filename, |
files == NULL ? (char *) NULL : files[0]); |
if (operation == extract && bfd_is_thin_archive (arch)) |
fatal (_("`x' cannot be used on thin archives.")); |
switch (operation) |
{ |
case print_table: |
map_over_members (arch, print_descr, files, file_count); |
break; |
case print_files: |
map_over_members (arch, print_contents, files, file_count); |
break; |
case extract: |
map_over_members (arch, extract_file, files, file_count); |
break; |
case del: |
if (files != NULL) |
delete_members (arch, files); |
else |
output_filename = NULL; |
break; |
case move: |
/* PR 12558: Creating and moving at the same time does |
not make sense. Just create the archive instead. */ |
if (! silent_create) |
{ |
if (files != NULL) |
move_members (arch, files); |
else |
output_filename = NULL; |
break; |
} |
/* Fall through. */ |
case replace: |
case quick_append: |
if (files != NULL || write_armap > 0) |
replace_members (arch, files, operation == quick_append); |
else |
output_filename = NULL; |
break; |
/* Shouldn't happen! */ |
default: |
/* xgettext:c-format */ |
fatal (_("internal error -- this option not implemented")); |
} |
} |
END_PROGRESS (program_name); |
xexit (0); |
return 0; |
} |
bfd * |
open_inarch (const char *archive_filename, const char *file) |
{ |
bfd **last_one; |
bfd *next_one; |
struct stat sbuf; |
bfd *arch; |
char **matching; |
bfd_set_error (bfd_error_no_error); |
if (target == NULL) |
target = plugin_target; |
if (stat (archive_filename, &sbuf) != 0) |
{ |
#if !defined(__GO32__) || defined(__DJGPP__) |
/* FIXME: I don't understand why this fragment was ifndef'ed |
away for __GO32__; perhaps it was in the days of DJGPP v1.x. |
stat() works just fine in v2.x, so I think this should be |
removed. For now, I enable it for DJGPP v2. -- EZ. */ |
/* KLUDGE ALERT! Temporary fix until I figger why |
stat() is wrong ... think it's buried in GO32's IDT - Jax */ |
if (errno != ENOENT) |
bfd_fatal (archive_filename); |
#endif |
if (!operation_alters_arch) |
{ |
fprintf (stderr, "%s: ", program_name); |
// perror (archive_filename); |
maybequit (); |
return NULL; |
} |
/* If the target isn't set, try to figure out the target to use |
for the archive from the first object on the list. */ |
if (target == NULL && file != NULL) |
{ |
bfd *obj; |
obj = bfd_openr (file, target); |
if (obj != NULL) |
{ |
if (bfd_check_format (obj, bfd_object)) |
target = bfd_get_target (obj); |
(void) bfd_close (obj); |
} |
} |
/* Create an empty archive. */ |
arch = bfd_openw (archive_filename, target); |
if (arch == NULL |
|| ! bfd_set_format (arch, bfd_archive) |
|| ! bfd_close (arch)) |
bfd_fatal (archive_filename); |
else if (!silent_create) |
non_fatal (_("creating %s"), archive_filename); |
/* If we die creating a new archive, don't leave it around. */ |
output_filename = archive_filename; |
} |
arch = bfd_openr (archive_filename, target); |
if (arch == NULL) |
{ |
bloser: |
bfd_fatal (archive_filename); |
} |
if (! bfd_check_format_matches (arch, bfd_archive, &matching)) |
{ |
bfd_nonfatal (archive_filename); |
if (bfd_get_error () == bfd_error_file_ambiguously_recognized) |
{ |
list_matching_formats (matching); |
free (matching); |
} |
xexit (1); |
} |
if ((operation == replace || operation == quick_append) |
&& bfd_openr_next_archived_file (arch, NULL) != NULL) |
{ |
/* PR 15140: Catch attempts to convert a normal |
archive into a thin archive or vice versa. */ |
if (make_thin_archive && ! bfd_is_thin_archive (arch)) |
{ |
fatal (_("Cannot convert existing library %s to thin format"), |
bfd_get_filename (arch)); |
goto bloser; |
} |
else if (! make_thin_archive && bfd_is_thin_archive (arch)) |
{ |
fatal (_("Cannot convert existing thin library %s to normal format"), |
bfd_get_filename (arch)); |
goto bloser; |
} |
} |
last_one = &(arch->archive_next); |
/* Read all the contents right away, regardless. */ |
for (next_one = bfd_openr_next_archived_file (arch, NULL); |
next_one; |
next_one = bfd_openr_next_archived_file (arch, next_one)) |
{ |
PROGRESS (1); |
*last_one = next_one; |
last_one = &next_one->archive_next; |
} |
*last_one = (bfd *) NULL; |
if (bfd_get_error () != bfd_error_no_more_archived_files) |
goto bloser; |
return arch; |
} |
static void |
print_contents (bfd *abfd) |
{ |
bfd_size_type ncopied = 0; |
bfd_size_type size; |
char *cbuf = (char *) xmalloc (BUFSIZE); |
struct stat buf; |
if (bfd_stat_arch_elt (abfd, &buf) != 0) |
/* xgettext:c-format */ |
fatal (_("internal stat error on %s"), bfd_get_filename (abfd)); |
if (verbose) |
printf ("\n<%s>\n\n", bfd_get_filename (abfd)); |
bfd_seek (abfd, (file_ptr) 0, SEEK_SET); |
size = buf.st_size; |
while (ncopied < size) |
{ |
bfd_size_type nread; |
bfd_size_type tocopy = size - ncopied; |
if (tocopy > BUFSIZE) |
tocopy = BUFSIZE; |
nread = bfd_bread (cbuf, tocopy, abfd); |
if (nread != tocopy) |
/* xgettext:c-format */ |
fatal (_("%s is not a valid archive"), |
bfd_get_filename (bfd_my_archive (abfd))); |
/* fwrite in mingw32 may return int instead of bfd_size_type. Cast the |
return value to bfd_size_type to avoid comparison between signed and |
unsigned values. */ |
if ((bfd_size_type) fwrite (cbuf, 1, nread, stdout) != nread) |
fatal ("stdout: %s", strerror (errno)); |
ncopied += tocopy; |
} |
free (cbuf); |
} |
/* Extract a member of the archive into its own file. |
We defer opening the new file until after we have read a BUFSIZ chunk of the |
old one, since we know we have just read the archive header for the old |
one. Since most members are shorter than BUFSIZ, this means we will read |
the old header, read the old data, write a new inode for the new file, and |
write the new data, and be done. This 'optimization' is what comes from |
sitting next to a bare disk and hearing it every time it seeks. -- Gnu |
Gilmore */ |
void |
extract_file (bfd *abfd) |
{ |
FILE *ostream; |
char *cbuf = (char *) xmalloc (BUFSIZE); |
bfd_size_type nread, tocopy; |
bfd_size_type ncopied = 0; |
bfd_size_type size; |
struct stat buf; |
if (bfd_stat_arch_elt (abfd, &buf) != 0) |
/* xgettext:c-format */ |
fatal (_("internal stat error on %s"), bfd_get_filename (abfd)); |
size = buf.st_size; |
if (verbose) |
printf ("x - %s\n", bfd_get_filename (abfd)); |
bfd_seek (abfd, (file_ptr) 0, SEEK_SET); |
ostream = NULL; |
if (size == 0) |
{ |
/* Seems like an abstraction violation, eh? Well it's OK! */ |
output_filename = bfd_get_filename (abfd); |
ostream = fopen (bfd_get_filename (abfd), FOPEN_WB); |
if (ostream == NULL) |
{ |
// perror (bfd_get_filename (abfd)); |
xexit (1); |
} |
output_file = ostream; |
} |
else |
while (ncopied < size) |
{ |
tocopy = size - ncopied; |
if (tocopy > BUFSIZE) |
tocopy = BUFSIZE; |
nread = bfd_bread (cbuf, tocopy, abfd); |
if (nread != tocopy) |
/* xgettext:c-format */ |
fatal (_("%s is not a valid archive"), |
bfd_get_filename (bfd_my_archive (abfd))); |
/* See comment above; this saves disk arm motion */ |
if (ostream == NULL) |
{ |
/* Seems like an abstraction violation, eh? Well it's OK! */ |
output_filename = bfd_get_filename (abfd); |
ostream = fopen (bfd_get_filename (abfd), FOPEN_WB); |
if (ostream == NULL) |
{ |
// perror (bfd_get_filename (abfd)); |
xexit (1); |
} |
output_file = ostream; |
} |
/* fwrite in mingw32 may return int instead of bfd_size_type. Cast |
the return value to bfd_size_type to avoid comparison between |
signed and unsigned values. */ |
if ((bfd_size_type) fwrite (cbuf, 1, nread, ostream) != nread) |
fatal ("%s: %s", output_filename, strerror (errno)); |
ncopied += tocopy; |
} |
if (ostream != NULL) |
fclose (ostream); |
output_file = NULL; |
output_filename = NULL; |
// chmod (bfd_get_filename (abfd), buf.st_mode); |
if (preserve_dates) |
{ |
/* Set access time to modification time. Only st_mtime is |
initialized by bfd_stat_arch_elt. */ |
buf.st_atime = buf.st_mtime; |
set_times (bfd_get_filename (abfd), &buf); |
} |
free (cbuf); |
} |
static void |
write_archive (bfd *iarch) |
{ |
bfd *obfd; |
char *old_name, *new_name; |
bfd *contents_head = iarch->archive_next; |
old_name = (char *) xmalloc (strlen (bfd_get_filename (iarch)) + 1); |
strcpy (old_name, bfd_get_filename (iarch)); |
new_name = make_tempname (old_name); |
if (new_name == NULL) |
bfd_fatal (_("could not create temporary file whilst writing archive")); |
output_filename = new_name; |
obfd = bfd_openw (new_name, bfd_get_target (iarch)); |
if (obfd == NULL) |
bfd_fatal (old_name); |
output_bfd = obfd; |
bfd_set_format (obfd, bfd_archive); |
/* Request writing the archive symbol table unless we've |
been explicitly requested not to. */ |
obfd->has_armap = write_armap >= 0; |
if (ar_truncate) |
{ |
/* This should really use bfd_set_file_flags, but that rejects |
archives. */ |
obfd->flags |= BFD_TRADITIONAL_FORMAT; |
} |
if (deterministic) |
obfd->flags |= BFD_DETERMINISTIC_OUTPUT; |
if (make_thin_archive || bfd_is_thin_archive (iarch)) |
bfd_is_thin_archive (obfd) = 1; |
if (!bfd_set_archive_head (obfd, contents_head)) |
bfd_fatal (old_name); |
if (!bfd_close (obfd)) |
bfd_fatal (old_name); |
output_bfd = NULL; |
output_filename = NULL; |
/* We don't care if this fails; we might be creating the archive. */ |
bfd_close (iarch); |
if (smart_rename (new_name, old_name, 0) != 0) |
xexit (1); |
free (old_name); |
} |
/* Return a pointer to the pointer to the entry which should be rplacd'd |
into when altering. DEFAULT_POS should be how to interpret pos_default, |
and should be a pos value. */ |
static bfd ** |
get_pos_bfd (bfd **contents, enum pos default_pos, const char *default_posname) |
{ |
bfd **after_bfd = contents; |
enum pos realpos; |
const char *realposname; |
if (postype == pos_default) |
{ |
realpos = default_pos; |
realposname = default_posname; |
} |
else |
{ |
realpos = postype; |
realposname = posname; |
} |
if (realpos == pos_end) |
{ |
while (*after_bfd) |
after_bfd = &((*after_bfd)->archive_next); |
} |
else |
{ |
for (; *after_bfd; after_bfd = &(*after_bfd)->archive_next) |
if (FILENAME_CMP ((*after_bfd)->filename, realposname) == 0) |
{ |
if (realpos == pos_after) |
after_bfd = &(*after_bfd)->archive_next; |
break; |
} |
} |
return after_bfd; |
} |
static void |
delete_members (bfd *arch, char **files_to_delete) |
{ |
bfd **current_ptr_ptr; |
bfd_boolean found; |
bfd_boolean something_changed = FALSE; |
int match_count; |
for (; *files_to_delete != NULL; ++files_to_delete) |
{ |
/* In a.out systems, the armap is optional. It's also called |
__.SYMDEF. So if the user asked to delete it, we should remember |
that fact. This isn't quite right for COFF systems (where |
__.SYMDEF might be regular member), but it's very unlikely |
to be a problem. FIXME */ |
if (!strcmp (*files_to_delete, "__.SYMDEF")) |
{ |
arch->has_armap = FALSE; |
write_armap = -1; |
continue; |
} |
found = FALSE; |
match_count = 0; |
current_ptr_ptr = &(arch->archive_next); |
while (*current_ptr_ptr) |
{ |
if (FILENAME_CMP (normalize (*files_to_delete, arch), |
(*current_ptr_ptr)->filename) == 0) |
{ |
++match_count; |
if (counted_name_mode |
&& match_count != counted_name_counter) |
{ |
/* Counting, and didn't match on count; go on to the |
next one. */ |
} |
else |
{ |
found = TRUE; |
something_changed = TRUE; |
if (verbose) |
printf ("d - %s\n", |
*files_to_delete); |
*current_ptr_ptr = ((*current_ptr_ptr)->archive_next); |
goto next_file; |
} |
} |
current_ptr_ptr = &((*current_ptr_ptr)->archive_next); |
} |
if (verbose && !found) |
{ |
/* xgettext:c-format */ |
printf (_("No member named `%s'\n"), *files_to_delete); |
} |
next_file: |
; |
} |
if (something_changed) |
write_archive (arch); |
else |
output_filename = NULL; |
} |
/* Reposition existing members within an archive */ |
static void |
move_members (bfd *arch, char **files_to_move) |
{ |
bfd **after_bfd; /* New entries go after this one */ |
bfd **current_ptr_ptr; /* cdr pointer into contents */ |
for (; *files_to_move; ++files_to_move) |
{ |
current_ptr_ptr = &(arch->archive_next); |
while (*current_ptr_ptr) |
{ |
bfd *current_ptr = *current_ptr_ptr; |
if (FILENAME_CMP (normalize (*files_to_move, arch), |
current_ptr->filename) == 0) |
{ |
/* Move this file to the end of the list - first cut from |
where it is. */ |
bfd *link_bfd; |
*current_ptr_ptr = current_ptr->archive_next; |
/* Now glue to end */ |
after_bfd = get_pos_bfd (&arch->archive_next, pos_end, NULL); |
link_bfd = *after_bfd; |
*after_bfd = current_ptr; |
current_ptr->archive_next = link_bfd; |
if (verbose) |
printf ("m - %s\n", *files_to_move); |
goto next_file; |
} |
current_ptr_ptr = &((*current_ptr_ptr)->archive_next); |
} |
/* xgettext:c-format */ |
fatal (_("no entry %s in archive %s!"), *files_to_move, arch->filename); |
next_file:; |
} |
write_archive (arch); |
} |
/* Ought to default to replacing in place, but this is existing practice! */ |
static void |
replace_members (bfd *arch, char **files_to_move, bfd_boolean quick) |
{ |
bfd_boolean changed = FALSE; |
bfd **after_bfd; /* New entries go after this one. */ |
bfd *current; |
bfd **current_ptr; |
while (files_to_move && *files_to_move) |
{ |
if (! quick) |
{ |
current_ptr = &arch->archive_next; |
while (*current_ptr) |
{ |
current = *current_ptr; |
/* For compatibility with existing ar programs, we |
permit the same file to be added multiple times. */ |
if (FILENAME_CMP (normalize (*files_to_move, arch), |
normalize (current->filename, arch)) == 0 |
&& current->arelt_data != NULL) |
{ |
if (newer_only) |
{ |
struct stat fsbuf, asbuf; |
if (stat (*files_to_move, &fsbuf) != 0) |
{ |
if (errno != ENOENT) |
bfd_fatal (*files_to_move); |
goto next_file; |
} |
if (bfd_stat_arch_elt (current, &asbuf) != 0) |
/* xgettext:c-format */ |
fatal (_("internal stat error on %s"), |
current->filename); |
if (fsbuf.st_mtime <= asbuf.st_mtime) |
goto next_file; |
} |
after_bfd = get_pos_bfd (&arch->archive_next, pos_after, |
current->filename); |
if (ar_emul_replace (after_bfd, *files_to_move, |
target, verbose)) |
{ |
/* Snip out this entry from the chain. */ |
*current_ptr = (*current_ptr)->archive_next; |
changed = TRUE; |
} |
goto next_file; |
} |
current_ptr = &(current->archive_next); |
} |
} |
/* Add to the end of the archive. */ |
after_bfd = get_pos_bfd (&arch->archive_next, pos_end, NULL); |
if (ar_emul_append (after_bfd, *files_to_move, target, |
verbose, make_thin_archive)) |
changed = TRUE; |
next_file:; |
files_to_move++; |
} |
if (changed) |
write_archive (arch); |
else |
output_filename = NULL; |
} |
static int |
ranlib_only (const char *archname) |
{ |
bfd *arch; |
if (get_file_size (archname) < 1) |
return 1; |
write_armap = 1; |
arch = open_inarch (archname, (char *) NULL); |
if (arch == NULL) |
xexit (1); |
write_archive (arch); |
return 0; |
} |
/* Update the timestamp of the symbol map of an archive. */ |
static int |
ranlib_touch (const char *archname) |
{ |
#ifdef __GO32__ |
/* I don't think updating works on go32. */ |
ranlib_only (archname); |
#else |
int f; |
bfd *arch; |
char **matching; |
if (get_file_size (archname) < 1) |
return 1; |
f = open (archname, O_RDWR | O_BINARY, 0); |
if (f < 0) |
{ |
bfd_set_error (bfd_error_system_call); |
bfd_fatal (archname); |
} |
arch = bfd_fdopenr (archname, (const char *) NULL, f); |
if (arch == NULL) |
bfd_fatal (archname); |
if (! bfd_check_format_matches (arch, bfd_archive, &matching)) |
{ |
bfd_nonfatal (archname); |
if (bfd_get_error () == bfd_error_file_ambiguously_recognized) |
{ |
list_matching_formats (matching); |
free (matching); |
} |
xexit (1); |
} |
if (! bfd_has_map (arch)) |
/* xgettext:c-format */ |
fatal (_("%s: no archive map to update"), archname); |
if (deterministic) |
arch->flags |= BFD_DETERMINISTIC_OUTPUT; |
bfd_update_armap_timestamp (arch); |
if (! bfd_close (arch)) |
bfd_fatal (archname); |
#endif |
return 0; |
} |
/* Things which are interesting to map over all or some of the files: */ |
static void |
print_descr (bfd *abfd) |
{ |
print_arelt_descr (stdout, abfd, verbose); |
} |
/contrib/toolchain/binutils/binutils/arlex.c |
---|
0,0 → 1,2036 |
#line 3 "arlex.c" |
#define YY_INT_ALIGNED short int |
/* A lexical scanner generated by flex */ |
#define FLEX_SCANNER |
#define YY_FLEX_MAJOR_VERSION 2 |
#define YY_FLEX_MINOR_VERSION 5 |
#define YY_FLEX_SUBMINOR_VERSION 35 |
#if YY_FLEX_SUBMINOR_VERSION > 0 |
#define FLEX_BETA |
#endif |
/* First, we deal with platform-specific or compiler-specific issues. */ |
/* begin standard C headers. */ |
#include <stdio.h> |
#include <string.h> |
#include <errno.h> |
#include <stdlib.h> |
/* end standard C headers. */ |
/* flex integer type definitions */ |
#ifndef FLEXINT_H |
#define FLEXINT_H |
/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */ |
#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L |
/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, |
* if you want the limit (max/min) macros for int types. |
*/ |
#ifndef __STDC_LIMIT_MACROS |
#define __STDC_LIMIT_MACROS 1 |
#endif |
#include <inttypes.h> |
typedef int8_t flex_int8_t; |
typedef uint8_t flex_uint8_t; |
typedef int16_t flex_int16_t; |
typedef uint16_t flex_uint16_t; |
typedef int32_t flex_int32_t; |
typedef uint32_t flex_uint32_t; |
typedef uint64_t flex_uint64_t; |
#else |
typedef signed char flex_int8_t; |
typedef short int flex_int16_t; |
typedef int flex_int32_t; |
typedef unsigned char flex_uint8_t; |
typedef unsigned short int flex_uint16_t; |
typedef unsigned int flex_uint32_t; |
#endif /* ! C99 */ |
/* Limits of integral types. */ |
#ifndef INT8_MIN |
#define INT8_MIN (-128) |
#endif |
#ifndef INT16_MIN |
#define INT16_MIN (-32767-1) |
#endif |
#ifndef INT32_MIN |
#define INT32_MIN (-2147483647-1) |
#endif |
#ifndef INT8_MAX |
#define INT8_MAX (127) |
#endif |
#ifndef INT16_MAX |
#define INT16_MAX (32767) |
#endif |
#ifndef INT32_MAX |
#define INT32_MAX (2147483647) |
#endif |
#ifndef UINT8_MAX |
#define UINT8_MAX (255U) |
#endif |
#ifndef UINT16_MAX |
#define UINT16_MAX (65535U) |
#endif |
#ifndef UINT32_MAX |
#define UINT32_MAX (4294967295U) |
#endif |
#endif /* ! FLEXINT_H */ |
#ifdef __cplusplus |
/* The "const" storage-class-modifier is valid. */ |
#define YY_USE_CONST |
#else /* ! __cplusplus */ |
/* C99 requires __STDC__ to be defined as 1. */ |
#if defined (__STDC__) |
#define YY_USE_CONST |
#endif /* defined (__STDC__) */ |
#endif /* ! __cplusplus */ |
#ifdef YY_USE_CONST |
#define yyconst const |
#else |
#define yyconst |
#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. */ |
#ifndef YY_BUF_SIZE |
#define YY_BUF_SIZE 16384 |
#endif |
/* The state buf must be large enough to hold one state per character in the main buffer. |
*/ |
#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) |
#ifndef YY_TYPEDEF_YY_BUFFER_STATE |
#define YY_TYPEDEF_YY_BUFFER_STATE |
typedef struct yy_buffer_state *YY_BUFFER_STATE; |
#endif |
#ifndef YY_TYPEDEF_YY_SIZE_T |
#define YY_TYPEDEF_YY_SIZE_T |
typedef size_t yy_size_t; |
#endif |
extern yy_size_t yyleng; |
extern FILE *yyin, *yyout; |
#define EOB_ACT_CONTINUE_SCAN 0 |
#define EOB_ACT_END_OF_FILE 1 |
#define EOB_ACT_LAST_MATCH 2 |
#define YY_LESS_LINENO(n) |
/* Return all but the first "n" matched characters back to the input stream. */ |
#define yyless(n) \ |
do \ |
{ \ |
/* Undo effects of setting up yytext. */ \ |
int yyless_macro_arg = (n); \ |
YY_LESS_LINENO(yyless_macro_arg);\ |
*yy_cp = (yy_hold_char); \ |
YY_RESTORE_YY_MORE_OFFSET \ |
(yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ |
YY_DO_BEFORE_ACTION; /* set up yytext again */ \ |
} \ |
while ( 0 ) |
#define unput(c) yyunput( c, (yytext_ptr) ) |
#ifndef YY_STRUCT_YY_BUFFER_STATE |
#define YY_STRUCT_YY_BUFFER_STATE |
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. |
*/ |
yy_size_t 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; |
int yy_bs_lineno; /**< The line count. */ |
int yy_bs_column; /**< The column count. */ |
/* 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 |
}; |
#endif /* !YY_STRUCT_YY_BUFFER_STATE */ |
/* Stack of input buffers. */ |
static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */ |
static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */ |
static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */ |
/* 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". |
* |
* Returns the top of the stack, or NULL. |
*/ |
#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ |
? (yy_buffer_stack)[(yy_buffer_stack_top)] \ |
: NULL) |
/* Same as previous macro, but useful when we know that the buffer stack is not |
* NULL or when we need an lvalue. For internal use only. |
*/ |
#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] |
/* yy_hold_char holds the character lost when yytext is formed. */ |
static char yy_hold_char; |
static yy_size_t yy_n_chars; /* number of characters read into yy_ch_buf */ |
yy_size_t yyleng; |
/* Points to current character in buffer. */ |
static char *yy_c_buf_p = (char *) 0; |
static int yy_init = 0; /* 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 (FILE *input_file ); |
void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ); |
YY_BUFFER_STATE yy_create_buffer (FILE *file,int size ); |
void yy_delete_buffer (YY_BUFFER_STATE b ); |
void yy_flush_buffer (YY_BUFFER_STATE b ); |
void yypush_buffer_state (YY_BUFFER_STATE new_buffer ); |
void yypop_buffer_state (void ); |
static void yyensure_buffer_stack (void ); |
static void yy_load_buffer_state (void ); |
static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file ); |
#define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER ) |
YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size ); |
YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str ); |
YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,yy_size_t len ); |
void *yyalloc (yy_size_t ); |
void *yyrealloc (void *,yy_size_t ); |
void yyfree (void * ); |
#define yy_new_buffer yy_create_buffer |
#define yy_set_interactive(is_interactive) \ |
{ \ |
if ( ! YY_CURRENT_BUFFER ){ \ |
yyensure_buffer_stack (); \ |
YY_CURRENT_BUFFER_LVALUE = \ |
yy_create_buffer(yyin,YY_BUF_SIZE ); \ |
} \ |
YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ |
} |
#define yy_set_bol(at_bol) \ |
{ \ |
if ( ! YY_CURRENT_BUFFER ){\ |
yyensure_buffer_stack (); \ |
YY_CURRENT_BUFFER_LVALUE = \ |
yy_create_buffer(yyin,YY_BUF_SIZE ); \ |
} \ |
YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ |
} |
#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) |
/* Begin user sect3 */ |
typedef unsigned char YY_CHAR; |
FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; |
typedef int yy_state_type; |
extern int yylineno; |
int yylineno = 1; |
extern char *yytext; |
#define yytext_ptr yytext |
static yy_state_type yy_get_previous_state (void ); |
static yy_state_type yy_try_NUL_trans (yy_state_type current_state ); |
static int yy_get_next_buffer (void ); |
static void yy_fatal_error (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 = (yy_size_t) (yy_cp - yy_bp); \ |
(yy_hold_char) = *yy_cp; \ |
*yy_cp = '\0'; \ |
(yy_c_buf_p) = yy_cp; |
#define YY_NUM_RULES 40 |
#define YY_END_OF_BUFFER 41 |
/* This struct is not used in this scanner, |
but its presence is necessary. */ |
struct yy_trans_info |
{ |
flex_int32_t yy_verify; |
flex_int32_t yy_nxt; |
}; |
static yyconst flex_int16_t yy_accept[177] = |
{ 0, |
0, 0, 41, 40, 39, 38, 35, 32, 33, 36, |
40, 34, 37, 35, 35, 35, 35, 35, 35, 35, |
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, |
35, 35, 35, 35, 35, 35, 36, 31, 37, 35, |
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, |
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, |
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, |
35, 35, 7, 35, 35, 35, 35, 35, 35, 35, |
35, 35, 35, 35, 35, 35, 22, 35, 35, 35, |
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, |
35, 35, 35, 10, 11, 12, 35, 15, 35, 35, |
35, 35, 35, 35, 35, 35, 35, 25, 26, 27, |
35, 30, 35, 35, 35, 3, 35, 35, 35, 35, |
35, 35, 35, 35, 35, 18, 35, 35, 35, 35, |
35, 35, 35, 1, 2, 4, 5, 35, 35, 35, |
35, 35, 16, 17, 19, 20, 35, 35, 35, 35, |
35, 35, 8, 9, 13, 14, 35, 23, 24, 28, |
29, 35, 35, 6, 21, 0 |
} ; |
static yyconst flex_int32_t yy_ec[256] = |
{ 0, |
1, 1, 1, 1, 1, 1, 1, 1, 1, 2, |
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
1, 3, 1, 1, 1, 4, 1, 1, 1, 5, |
6, 7, 8, 9, 4, 4, 4, 4, 4, 4, |
4, 4, 4, 4, 4, 4, 4, 4, 10, 1, |
1, 1, 1, 1, 11, 12, 13, 14, 15, 16, |
4, 17, 18, 4, 4, 19, 20, 21, 22, 23, |
4, 24, 25, 26, 27, 28, 4, 29, 30, 4, |
1, 4, 1, 1, 4, 1, 31, 32, 33, 34, |
35, 36, 4, 37, 38, 4, 4, 39, 40, 41, |
42, 43, 4, 44, 45, 46, 47, 48, 4, 49, |
50, 4, 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 flex_int32_t yy_meta[51] = |
{ 0, |
1, 2, 1, 3, 1, 1, 1, 1, 1, 1, |
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, |
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, |
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, |
3, 3, 3, 3, 3, 3, 3, 3, 3, 3 |
} ; |
static yyconst flex_int16_t yy_base[180] = |
{ 0, |
0, 0, 193, 194, 194, 194, 0, 194, 194, 0, |
190, 194, 0, 177, 32, 37, 32, 163, 174, 170, |
164, 171, 174, 169, 149, 15, 22, 17, 135, 146, |
142, 136, 143, 146, 141, 0, 0, 194, 0, 161, |
159, 158, 153, 147, 156, 143, 149, 148, 141, 150, |
141, 135, 138, 127, 125, 124, 119, 113, 122, 109, |
115, 114, 107, 116, 107, 101, 104, 43, 136, 135, |
130, 129, 0, 119, 123, 118, 114, 118, 119, 122, |
124, 25, 104, 103, 98, 97, 0, 87, 91, 86, |
82, 86, 87, 90, 92, 105, 100, 97, 94, 93, |
105, 106, 102, 0, 0, 0, 104, 0, 92, 75, |
70, 67, 64, 63, 75, 76, 72, 0, 0, 0, |
74, 0, 62, 91, 88, 0, 86, 85, 73, 85, |
79, 83, 70, 62, 59, 0, 57, 56, 44, 56, |
50, 54, 41, 0, 0, 0, 0, 63, 58, 59, |
67, 66, 0, 0, 0, 0, 38, 33, 34, 42, |
41, 51, 0, 0, 0, 0, 30, 0, 0, 0, |
0, 43, 21, 0, 0, 194, 65, 66, 69 |
} ; |
static yyconst flex_int16_t yy_def[180] = |
{ 0, |
176, 1, 176, 176, 176, 176, 177, 176, 176, 178, |
176, 176, 179, 177, 177, 177, 177, 177, 177, 177, |
177, 177, 177, 177, 177, 177, 177, 177, 177, 177, |
177, 177, 177, 177, 177, 177, 178, 176, 179, 177, |
177, 177, 177, 177, 177, 177, 177, 177, 177, 177, |
177, 177, 177, 177, 177, 177, 177, 177, 177, 177, |
177, 177, 177, 177, 177, 177, 177, 177, 177, 177, |
177, 177, 177, 177, 177, 177, 177, 177, 177, 177, |
177, 177, 177, 177, 177, 177, 177, 177, 177, 177, |
177, 177, 177, 177, 177, 177, 177, 177, 177, 177, |
177, 177, 177, 177, 177, 177, 177, 177, 177, 177, |
177, 177, 177, 177, 177, 177, 177, 177, 177, 177, |
177, 177, 177, 177, 177, 177, 177, 177, 177, 177, |
177, 177, 177, 177, 177, 177, 177, 177, 177, 177, |
177, 177, 177, 177, 177, 177, 177, 177, 177, 177, |
177, 177, 177, 177, 177, 177, 177, 177, 177, 177, |
177, 177, 177, 177, 177, 177, 177, 177, 177, 177, |
177, 177, 177, 177, 177, 0, 176, 176, 176 |
} ; |
static yyconst flex_int16_t yy_nxt[245] = |
{ 0, |
4, 5, 6, 7, 8, 9, 10, 11, 12, 13, |
14, 7, 15, 16, 17, 18, 19, 7, 20, 7, |
7, 21, 7, 22, 23, 7, 7, 24, 7, 7, |
25, 7, 26, 27, 28, 29, 30, 7, 31, 7, |
7, 32, 7, 33, 34, 7, 7, 35, 7, 7, |
41, 43, 45, 55, 44, 42, 57, 59, 56, 58, |
46, 96, 97, 110, 111, 60, 37, 36, 37, 39, |
175, 39, 174, 173, 172, 171, 170, 169, 168, 167, |
166, 165, 164, 163, 162, 161, 160, 159, 158, 157, |
156, 155, 154, 153, 152, 151, 150, 149, 148, 147, |
146, 145, 144, 143, 142, 141, 140, 139, 138, 137, |
136, 135, 134, 133, 132, 131, 130, 129, 128, 127, |
126, 125, 124, 123, 122, 121, 120, 119, 118, 117, |
116, 115, 114, 113, 112, 109, 108, 107, 106, 105, |
104, 103, 102, 101, 100, 99, 98, 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, 54, 53, 52, 51, 50, 49, 48, 47, |
40, 38, 176, 3, 176, 176, 176, 176, 176, 176, |
176, 176, 176, 176, 176, 176, 176, 176, 176, 176, |
176, 176, 176, 176, 176, 176, 176, 176, 176, 176, |
176, 176, 176, 176, 176, 176, 176, 176, 176, 176, |
176, 176, 176, 176, 176, 176, 176, 176, 176, 176, |
176, 176, 176, 176 |
} ; |
static yyconst flex_int16_t yy_chk[245] = |
{ 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, 1, 1, |
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
15, 16, 17, 26, 16, 15, 27, 28, 26, 27, |
17, 68, 68, 82, 82, 28, 178, 177, 178, 179, |
173, 179, 172, 167, 162, 161, 160, 159, 158, 157, |
152, 151, 150, 149, 148, 143, 142, 141, 140, 139, |
138, 137, 135, 134, 133, 132, 131, 130, 129, 128, |
127, 125, 124, 123, 121, 117, 116, 115, 114, 113, |
112, 111, 110, 109, 107, 103, 102, 101, 100, 99, |
98, 97, 96, 95, 94, 93, 92, 91, 90, 89, |
88, 86, 85, 84, 83, 81, 80, 79, 78, 77, |
76, 75, 74, 72, 71, 70, 69, 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, 42, 41, 40, 35, 34, 33, 32, 31, |
30, 29, 25, 24, 23, 22, 21, 20, 19, 18, |
14, 11, 3, 176, 176, 176, 176, 176, 176, 176, |
176, 176, 176, 176, 176, 176, 176, 176, 176, 176, |
176, 176, 176, 176, 176, 176, 176, 176, 176, 176, |
176, 176, 176, 176, 176, 176, 176, 176, 176, 176, |
176, 176, 176, 176, 176, 176, 176, 176, 176, 176, |
176, 176, 176, 176 |
} ; |
static yy_state_type yy_last_accepting_state; |
static char *yy_last_accepting_cpos; |
extern int yy_flex_debug; |
int yy_flex_debug = 0; |
/* 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 |
#define YY_RESTORE_YY_MORE_OFFSET |
char *yytext; |
#line 1 "arlex.l" |
#define YY_NO_INPUT 1 |
#line 4 "arlex.l" |
/* arlex.l - Strange script language lexer */ |
/* Copyright 1992, 1997, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2011 |
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 3 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., 51 Franklin Street - Fifth Floor, Boston, |
MA 02110-1301, USA. */ |
/* Contributed by Steve Chamberlain <sac@cygnus.com>. */ |
#define DONTDECLARE_MALLOC |
#include "ansidecl.h" |
#include "libiberty.h" |
#include "arparse.h" |
#ifndef YY_NO_UNPUT |
#define YY_NO_UNPUT |
#endif |
extern int yylex (void); |
int linenumber; |
#line 599 "arlex.c" |
#define INITIAL 0 |
#ifndef YY_NO_UNISTD_H |
/* Special case for "unistd.h", since it is non-ANSI. We include it way |
* down here because we want the user's section 1 to have been scanned first. |
* The user has a chance to override it with an option. |
*/ |
#include <unistd.h> |
#endif |
#ifndef YY_EXTRA_TYPE |
#define YY_EXTRA_TYPE void * |
#endif |
static int yy_init_globals (void ); |
/* Accessor methods to globals. |
These are made visible to non-reentrant scanners for convenience. */ |
int yylex_destroy (void ); |
int yyget_debug (void ); |
void yyset_debug (int debug_flag ); |
YY_EXTRA_TYPE yyget_extra (void ); |
void yyset_extra (YY_EXTRA_TYPE user_defined ); |
FILE *yyget_in (void ); |
void yyset_in (FILE * in_str ); |
FILE *yyget_out (void ); |
void yyset_out (FILE * out_str ); |
yy_size_t yyget_leng (void ); |
char *yyget_text (void ); |
int yyget_lineno (void ); |
void yyset_lineno (int line_number ); |
/* Macros after this point can all be overridden by user definitions in |
* section 1. |
*/ |
#ifndef YY_SKIP_YYWRAP |
#ifdef __cplusplus |
extern "C" int yywrap (void ); |
#else |
extern int yywrap (void ); |
#endif |
#endif |
#ifndef yytext_ptr |
static void yy_flex_strncpy (char *,yyconst char *,int ); |
#endif |
#ifdef YY_NEED_STRLEN |
static int yy_flex_strlen (yyconst char * ); |
#endif |
#ifndef YY_NO_INPUT |
#ifdef __cplusplus |
static int yyinput (void ); |
#else |
static int input (void ); |
#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 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_LVALUE->yy_is_interactive ) \ |
{ \ |
int c = '*'; \ |
yy_size_t 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 \ |
{ \ |
errno=0; \ |
while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \ |
{ \ |
if( errno != EINTR) \ |
{ \ |
YY_FATAL_ERROR( "input in flex scanner failed" ); \ |
break; \ |
} \ |
errno=0; \ |
clearerr(yyin); \ |
} \ |
}\ |
\ |
#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 |
/* end tables serialization structures and prototypes */ |
/* Default declaration of generated scanner - a define so the user can |
* easily add parameters. |
*/ |
#ifndef YY_DECL |
#define YY_DECL_IS_OURS 1 |
extern int yylex (void); |
#define YY_DECL int yylex (void) |
#endif /* !YY_DECL */ |
/* 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 |
/** The main scanner function which does all the work. |
*/ |
YY_DECL |
{ |
register yy_state_type yy_current_state; |
register char *yy_cp, *yy_bp; |
register int yy_act; |
#line 46 "arlex.l" |
#line 782 "arlex.c" |
if ( !(yy_init) ) |
{ |
(yy_init) = 1; |
#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 ) { |
yyensure_buffer_stack (); |
YY_CURRENT_BUFFER_LVALUE = |
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 >= 177 ) |
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] != 194 ); |
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 48 "arlex.l" |
{ return ADDLIB; } |
YY_BREAK |
case 2: |
YY_RULE_SETUP |
#line 49 "arlex.l" |
{ return ADDMOD; } |
YY_BREAK |
case 3: |
YY_RULE_SETUP |
#line 50 "arlex.l" |
{ return CLEAR; } |
YY_BREAK |
case 4: |
YY_RULE_SETUP |
#line 51 "arlex.l" |
{ return CREATE; } |
YY_BREAK |
case 5: |
YY_RULE_SETUP |
#line 52 "arlex.l" |
{ return DELETE; } |
YY_BREAK |
case 6: |
YY_RULE_SETUP |
#line 53 "arlex.l" |
{ return DIRECTORY; } |
YY_BREAK |
case 7: |
YY_RULE_SETUP |
#line 54 "arlex.l" |
{ return END; } |
YY_BREAK |
case 8: |
YY_RULE_SETUP |
#line 55 "arlex.l" |
{ return EXTRACT; } |
YY_BREAK |
case 9: |
YY_RULE_SETUP |
#line 56 "arlex.l" |
{ return FULLDIR; } |
YY_BREAK |
case 10: |
YY_RULE_SETUP |
#line 57 "arlex.l" |
{ return HELP; } |
YY_BREAK |
case 11: |
YY_RULE_SETUP |
#line 58 "arlex.l" |
{ return LIST; } |
YY_BREAK |
case 12: |
YY_RULE_SETUP |
#line 59 "arlex.l" |
{ return OPEN; } |
YY_BREAK |
case 13: |
YY_RULE_SETUP |
#line 60 "arlex.l" |
{ return REPLACE; } |
YY_BREAK |
case 14: |
YY_RULE_SETUP |
#line 61 "arlex.l" |
{ return VERBOSE; } |
YY_BREAK |
case 15: |
YY_RULE_SETUP |
#line 62 "arlex.l" |
{ return SAVE; } |
YY_BREAK |
case 16: |
YY_RULE_SETUP |
#line 63 "arlex.l" |
{ return ADDLIB; } |
YY_BREAK |
case 17: |
YY_RULE_SETUP |
#line 64 "arlex.l" |
{ return ADDMOD; } |
YY_BREAK |
case 18: |
YY_RULE_SETUP |
#line 65 "arlex.l" |
{ return CLEAR; } |
YY_BREAK |
case 19: |
YY_RULE_SETUP |
#line 66 "arlex.l" |
{ return CREATE; } |
YY_BREAK |
case 20: |
YY_RULE_SETUP |
#line 67 "arlex.l" |
{ return DELETE; } |
YY_BREAK |
case 21: |
YY_RULE_SETUP |
#line 68 "arlex.l" |
{ return DIRECTORY; } |
YY_BREAK |
case 22: |
YY_RULE_SETUP |
#line 69 "arlex.l" |
{ return END; } |
YY_BREAK |
case 23: |
YY_RULE_SETUP |
#line 70 "arlex.l" |
{ return EXTRACT; } |
YY_BREAK |
case 24: |
YY_RULE_SETUP |
#line 71 "arlex.l" |
{ return FULLDIR; } |
YY_BREAK |
case 25: |
YY_RULE_SETUP |
#line 72 "arlex.l" |
{ return HELP; } |
YY_BREAK |
case 26: |
YY_RULE_SETUP |
#line 73 "arlex.l" |
{ return LIST; } |
YY_BREAK |
case 27: |
YY_RULE_SETUP |
#line 74 "arlex.l" |
{ return OPEN; } |
YY_BREAK |
case 28: |
YY_RULE_SETUP |
#line 75 "arlex.l" |
{ return REPLACE; } |
YY_BREAK |
case 29: |
YY_RULE_SETUP |
#line 76 "arlex.l" |
{ return VERBOSE; } |
YY_BREAK |
case 30: |
YY_RULE_SETUP |
#line 77 "arlex.l" |
{ return SAVE; } |
YY_BREAK |
case 31: |
/* rule 31 can match eol */ |
YY_RULE_SETUP |
#line 78 "arlex.l" |
{ linenumber ++; } |
YY_BREAK |
case 32: |
YY_RULE_SETUP |
#line 79 "arlex.l" |
{ return '('; } |
YY_BREAK |
case 33: |
YY_RULE_SETUP |
#line 80 "arlex.l" |
{ return ')'; } |
YY_BREAK |
case 34: |
YY_RULE_SETUP |
#line 81 "arlex.l" |
{ return ','; } |
YY_BREAK |
case 35: |
YY_RULE_SETUP |
#line 82 "arlex.l" |
{ |
yylval.name = xstrdup (yytext); |
return FILENAME; |
} |
YY_BREAK |
case 36: |
YY_RULE_SETUP |
#line 86 "arlex.l" |
{ } |
YY_BREAK |
case 37: |
YY_RULE_SETUP |
#line 87 "arlex.l" |
{ } |
YY_BREAK |
case 38: |
YY_RULE_SETUP |
#line 88 "arlex.l" |
{ } |
YY_BREAK |
case 39: |
/* rule 39 can match eol */ |
YY_RULE_SETUP |
#line 89 "arlex.l" |
{ linenumber ++; return NEWLINE; } |
YY_BREAK |
case 40: |
YY_RULE_SETUP |
#line 91 "arlex.l" |
ECHO; |
YY_BREAK |
#line 1070 "arlex.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); |
YY_RESTORE_YY_MORE_OFFSET |
if ( YY_CURRENT_BUFFER_LVALUE->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_LVALUE->yy_n_chars; |
YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; |
YY_CURRENT_BUFFER_LVALUE->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_LVALUE->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_LVALUE->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 (void) |
{ |
register char *dest = YY_CURRENT_BUFFER_LVALUE->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_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) |
YY_FATAL_ERROR( |
"fatal flex scanner internal error--end of buffer missed" ); |
if ( YY_CURRENT_BUFFER_LVALUE->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 single character, 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_LVALUE->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_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0; |
else |
{ |
yy_size_t num_to_read = |
YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; |
while ( num_to_read <= 0 ) |
{ /* Not enough room in the buffer - grow it. */ |
/* 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 ) |
{ |
yy_size_t 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. */ |
yyrealloc((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_LVALUE->yy_buf_size - |
number_to_move - 1; |
} |
if ( num_to_read > YY_READ_BUF_SIZE ) |
num_to_read = YY_READ_BUF_SIZE; |
/* Read in more data. */ |
YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), |
(yy_n_chars), num_to_read ); |
YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); |
} |
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_LVALUE->yy_buffer_status = |
YY_BUFFER_EOF_PENDING; |
} |
} |
else |
ret_val = EOB_ACT_CONTINUE_SCAN; |
if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { |
/* Extend the array by 50%, plus the number we really need. */ |
yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); |
YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ); |
if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) |
YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); |
} |
(yy_n_chars) += number_to_move; |
YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; |
YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; |
(yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->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 (void) |
{ |
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 >= 177 ) |
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 ); |
*/ |
static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state ) |
{ |
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 >= 177 ) |
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 == 176); |
return yy_is_jam ? 0 : yy_current_state; |
} |
#ifndef YY_NO_INPUT |
#ifdef __cplusplus |
static int yyinput (void) |
#else |
static int input (void) |
#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_LVALUE->yy_ch_buf[(yy_n_chars)] ) |
/* This was really a NUL. */ |
*(yy_c_buf_p) = '\0'; |
else |
{ /* need more input */ |
yy_size_t offset = (yy_c_buf_p) - (yytext_ptr); |
++(yy_c_buf_p); |
switch ( yy_get_next_buffer( ) ) |
{ |
case EOB_ACT_LAST_MATCH: |
/* This happens because yy_g_n_b() |
* sees that we've accumulated a |
* token and flags that we need to |
* try matching the token before |
* proceeding. But for input(), |
* there's no matching to consider. |
* So convert the EOB_ACT_LAST_MATCH |
* to EOB_ACT_END_OF_FILE. |
*/ |
/* Reset buffer status. */ |
yyrestart(yyin ); |
/*FALLTHROUGH*/ |
case EOB_ACT_END_OF_FILE: |
{ |
if ( yywrap( ) ) |
return 0; |
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) + offset; |
break; |
} |
} |
} |
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; |
} |
#endif /* ifndef YY_NO_INPUT */ |
/** Immediately switch to a different input stream. |
* @param input_file A readable stream. |
* |
* @note This function does not reset the start condition to @c INITIAL . |
*/ |
void yyrestart (FILE * input_file ) |
{ |
if ( ! YY_CURRENT_BUFFER ){ |
yyensure_buffer_stack (); |
YY_CURRENT_BUFFER_LVALUE = |
yy_create_buffer(yyin,YY_BUF_SIZE ); |
} |
yy_init_buffer(YY_CURRENT_BUFFER,input_file ); |
yy_load_buffer_state( ); |
} |
/** Switch to a different input buffer. |
* @param new_buffer The new input buffer. |
* |
*/ |
void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ) |
{ |
/* TODO. We should be able to replace this entire function body |
* with |
* yypop_buffer_state(); |
* yypush_buffer_state(new_buffer); |
*/ |
yyensure_buffer_stack (); |
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_LVALUE->yy_buf_pos = (yy_c_buf_p); |
YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); |
} |
YY_CURRENT_BUFFER_LVALUE = 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; |
} |
static void yy_load_buffer_state (void) |
{ |
(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; |
(yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; |
yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; |
(yy_hold_char) = *(yy_c_buf_p); |
} |
/** Allocate and initialize an input buffer state. |
* @param file A readable stream. |
* @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. |
* |
* @return the allocated buffer state. |
*/ |
YY_BUFFER_STATE yy_create_buffer (FILE * file, int size ) |
{ |
YY_BUFFER_STATE b; |
b = (YY_BUFFER_STATE) yyalloc(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 *) yyalloc(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; |
} |
/** Destroy the buffer. |
* @param b a buffer created with yy_create_buffer() |
* |
*/ |
void yy_delete_buffer (YY_BUFFER_STATE b ) |
{ |
if ( ! b ) |
return; |
if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ |
YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; |
if ( b->yy_is_our_buffer ) |
yyfree((void *) b->yy_ch_buf ); |
yyfree((void *) b ); |
} |
#ifndef __cplusplus |
extern int isatty (int ); |
#endif /* __cplusplus */ |
/* Initializes or reinitializes a buffer. |
* This function is sometimes called more than once on the same buffer, |
* such as during a yyrestart() or at EOF. |
*/ |
static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file ) |
{ |
int oerrno = errno; |
yy_flush_buffer(b ); |
b->yy_input_file = file; |
b->yy_fill_buffer = 1; |
/* If b is the current buffer, then yy_init_buffer was _probably_ |
* called from yyrestart() or through yy_get_next_buffer. |
* In that case, we don't want to reset the lineno or column. |
*/ |
if (b != YY_CURRENT_BUFFER){ |
b->yy_bs_lineno = 1; |
b->yy_bs_column = 0; |
} |
b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; |
errno = oerrno; |
} |
/** Discard all buffered characters. On the next scan, YY_INPUT will be called. |
* @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. |
* |
*/ |
void yy_flush_buffer (YY_BUFFER_STATE b ) |
{ |
if ( ! b ) |
return; |
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( ); |
} |
/** Pushes the new state onto the stack. The new state becomes |
* the current state. This function will allocate the stack |
* if necessary. |
* @param new_buffer The new state. |
* |
*/ |
void yypush_buffer_state (YY_BUFFER_STATE new_buffer ) |
{ |
if (new_buffer == NULL) |
return; |
yyensure_buffer_stack(); |
/* This block is copied from yy_switch_to_buffer. */ |
if ( YY_CURRENT_BUFFER ) |
{ |
/* Flush out information for old buffer. */ |
*(yy_c_buf_p) = (yy_hold_char); |
YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); |
YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); |
} |
/* Only push if top exists. Otherwise, replace top. */ |
if (YY_CURRENT_BUFFER) |
(yy_buffer_stack_top)++; |
YY_CURRENT_BUFFER_LVALUE = new_buffer; |
/* copied from yy_switch_to_buffer. */ |
yy_load_buffer_state( ); |
(yy_did_buffer_switch_on_eof) = 1; |
} |
/** Removes and deletes the top of the stack, if present. |
* The next element becomes the new top. |
* |
*/ |
void yypop_buffer_state (void) |
{ |
if (!YY_CURRENT_BUFFER) |
return; |
yy_delete_buffer(YY_CURRENT_BUFFER ); |
YY_CURRENT_BUFFER_LVALUE = NULL; |
if ((yy_buffer_stack_top) > 0) |
--(yy_buffer_stack_top); |
if (YY_CURRENT_BUFFER) { |
yy_load_buffer_state( ); |
(yy_did_buffer_switch_on_eof) = 1; |
} |
} |
/* Allocates the stack if it does not exist. |
* Guarantees space for at least one push. |
*/ |
static void yyensure_buffer_stack (void) |
{ |
yy_size_t num_to_alloc; |
if (!(yy_buffer_stack)) { |
/* First allocation is just for 2 elements, since we don't know if this |
* scanner will even need a stack. We use 2 instead of 1 to avoid an |
* immediate realloc on the next call. |
*/ |
num_to_alloc = 1; |
(yy_buffer_stack) = (struct yy_buffer_state**)yyalloc |
(num_to_alloc * sizeof(struct yy_buffer_state*) |
); |
if ( ! (yy_buffer_stack) ) |
YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); |
memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); |
(yy_buffer_stack_max) = num_to_alloc; |
(yy_buffer_stack_top) = 0; |
return; |
} |
if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){ |
/* Increase the buffer to prepare for a possible push. */ |
int grow_size = 8 /* arbitrary grow size */; |
num_to_alloc = (yy_buffer_stack_max) + grow_size; |
(yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc |
((yy_buffer_stack), |
num_to_alloc * sizeof(struct yy_buffer_state*) |
); |
if ( ! (yy_buffer_stack) ) |
YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); |
/* zero only the new slots.*/ |
memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); |
(yy_buffer_stack_max) = num_to_alloc; |
} |
} |
/** Setup the input buffer state to scan directly from a user-specified character buffer. |
* @param base the character buffer |
* @param size the size in bytes of the character buffer |
* |
* @return the newly allocated buffer state object. |
*/ |
YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ) |
{ |
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) yyalloc(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; |
} |
/** Setup the input buffer state to scan a string. The next call to yylex() will |
* scan from a @e copy of @a str. |
* @param yystr a NUL-terminated string to scan |
* |
* @return the newly allocated buffer state object. |
* @note If you want to scan bytes that may contain NUL values, then use |
* yy_scan_bytes() instead. |
*/ |
YY_BUFFER_STATE yy_scan_string (yyconst char * yystr ) |
{ |
return yy_scan_bytes(yystr,strlen(yystr) ); |
} |
/** Setup the input buffer state to scan the given bytes. The next call to yylex() will |
* scan from a @e copy of @a bytes. |
* @param bytes the byte buffer to scan |
* @param len the number of bytes in the buffer pointed to by @a bytes. |
* |
* @return the newly allocated buffer state object. |
*/ |
YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len ) |
{ |
YY_BUFFER_STATE b; |
char *buf; |
yy_size_t n, i; |
/* Get memory for full buffer, including space for trailing EOB's. */ |
n = _yybytes_len + 2; |
buf = (char *) yyalloc(n ); |
if ( ! buf ) |
YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); |
for ( i = 0; i < _yybytes_len; ++i ) |
buf[i] = yybytes[i]; |
buf[_yybytes_len] = buf[_yybytes_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; |
} |
#ifndef YY_EXIT_FAILURE |
#define YY_EXIT_FAILURE 2 |
#endif |
static void yy_fatal_error (yyconst char* msg ) |
{ |
(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. */ \ |
int yyless_macro_arg = (n); \ |
YY_LESS_LINENO(yyless_macro_arg);\ |
yytext[yyleng] = (yy_hold_char); \ |
(yy_c_buf_p) = yytext + yyless_macro_arg; \ |
(yy_hold_char) = *(yy_c_buf_p); \ |
*(yy_c_buf_p) = '\0'; \ |
yyleng = yyless_macro_arg; \ |
} \ |
while ( 0 ) |
/* Accessor methods (get/set functions) to struct members. */ |
/** Get the current line number. |
* |
*/ |
int yyget_lineno (void) |
{ |
return yylineno; |
} |
/** Get the input stream. |
* |
*/ |
FILE *yyget_in (void) |
{ |
return yyin; |
} |
/** Get the output stream. |
* |
*/ |
FILE *yyget_out (void) |
{ |
return yyout; |
} |
/** Get the length of the current token. |
* |
*/ |
yy_size_t yyget_leng (void) |
{ |
return yyleng; |
} |
/** Get the current token. |
* |
*/ |
char *yyget_text (void) |
{ |
return yytext; |
} |
/** Set the current line number. |
* @param line_number |
* |
*/ |
void yyset_lineno (int line_number ) |
{ |
yylineno = line_number; |
} |
/** Set the input stream. This does not discard the current |
* input buffer. |
* @param in_str A readable stream. |
* |
* @see yy_switch_to_buffer |
*/ |
void yyset_in (FILE * in_str ) |
{ |
yyin = in_str ; |
} |
void yyset_out (FILE * out_str ) |
{ |
yyout = out_str ; |
} |
int yyget_debug (void) |
{ |
return yy_flex_debug; |
} |
void yyset_debug (int bdebug ) |
{ |
yy_flex_debug = bdebug ; |
} |
static int yy_init_globals (void) |
{ |
/* Initialization is the same as for the non-reentrant scanner. |
* This function is called from yylex_destroy(), so don't allocate here. |
*/ |
(yy_buffer_stack) = 0; |
(yy_buffer_stack_top) = 0; |
(yy_buffer_stack_max) = 0; |
(yy_c_buf_p) = (char *) 0; |
(yy_init) = 0; |
(yy_start) = 0; |
/* Defined in main.c */ |
#ifdef YY_STDINIT |
yyin = stdin; |
yyout = stdout; |
#else |
yyin = (FILE *) 0; |
yyout = (FILE *) 0; |
#endif |
/* For future reference: Set errno on error, since we are called by |
* yylex_init() |
*/ |
return 0; |
} |
/* yylex_destroy is for both reentrant and non-reentrant scanners. */ |
int yylex_destroy (void) |
{ |
/* Pop the buffer stack, destroying each element. */ |
while(YY_CURRENT_BUFFER){ |
yy_delete_buffer(YY_CURRENT_BUFFER ); |
YY_CURRENT_BUFFER_LVALUE = NULL; |
yypop_buffer_state(); |
} |
/* Destroy the stack itself. */ |
yyfree((yy_buffer_stack) ); |
(yy_buffer_stack) = NULL; |
/* Reset the globals. This is important in a non-reentrant scanner so the next time |
* yylex() is called, initialization will occur. */ |
yy_init_globals( ); |
return 0; |
} |
/* |
* Internal utility routines. |
*/ |
#ifndef yytext_ptr |
static void yy_flex_strncpy (char* s1, yyconst char * s2, int n ) |
{ |
register int i; |
for ( i = 0; i < n; ++i ) |
s1[i] = s2[i]; |
} |
#endif |
#ifdef YY_NEED_STRLEN |
static int yy_flex_strlen (yyconst char * s ) |
{ |
register int n; |
for ( n = 0; s[n]; ++n ) |
; |
return n; |
} |
#endif |
void *yyalloc (yy_size_t size ) |
{ |
return (void *) malloc( size ); |
} |
void *yyrealloc (void * ptr, yy_size_t size ) |
{ |
/* 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 ); |
} |
void yyfree (void * ptr ) |
{ |
free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ |
} |
#define YYTABLES_NAME "yytables" |
#line 91 "arlex.l" |
#ifndef yywrap |
/* Needed for lex, though not flex. */ |
int yywrap(void) { return 1; } |
#endif |
/contrib/toolchain/binutils/binutils/arparse.c |
---|
0,0 → 1,1770 |
/* A Bison parser, made by GNU Bison 2.3. */ |
/* Skeleton implementation for Bison's Yacc-like parsers in C |
Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 |
Free Software Foundation, Inc. |
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, Inc., 51 Franklin Street, Fifth Floor, |
Boston, MA 02110-1301, USA. */ |
/* As a special exception, you may create a larger work that contains |
part or all of the Bison parser skeleton and distribute that work |
under terms of your choice, so long as that work isn't itself a |
parser generator using the skeleton or a modified version thereof |
as a parser skeleton. Alternatively, if you modify or redistribute |
the parser skeleton itself, you may (at your option) remove this |
special exception, which will cause the skeleton and the resulting |
Bison output files to be licensed under the GNU General Public |
License without this special exception. |
This special exception was added by the Free Software Foundation in |
version 2.2 of Bison. */ |
/* C LALR(1) parser skeleton written by Richard Stallman, by |
simplifying the original so-called "semantic" parser. */ |
/* All symbols defined below should begin with yy or YY, to avoid |
infringing on user name space. This should be done even for local |
variables, as they might otherwise be expanded by user macros. |
There are some unavoidable exceptions within include files to |
define necessary library symbols; they are noted "INFRINGES ON |
USER NAME SPACE" below. */ |
/* Identify Bison output. */ |
#define YYBISON 1 |
/* Bison version. */ |
#define YYBISON_VERSION "2.3" |
/* Skeleton name. */ |
#define YYSKELETON_NAME "yacc.c" |
/* Pure parsers. */ |
#define YYPURE 0 |
/* Using locations. */ |
#define YYLSP_NEEDED 0 |
/* Tokens. */ |
#ifndef YYTOKENTYPE |
# define YYTOKENTYPE |
/* Put the tokens into the symbol table, so that GDB and other debuggers |
know about them. */ |
enum yytokentype { |
NEWLINE = 258, |
VERBOSE = 259, |
FILENAME = 260, |
ADDLIB = 261, |
LIST = 262, |
ADDMOD = 263, |
CLEAR = 264, |
CREATE = 265, |
DELETE = 266, |
DIRECTORY = 267, |
END = 268, |
EXTRACT = 269, |
FULLDIR = 270, |
HELP = 271, |
QUIT = 272, |
REPLACE = 273, |
SAVE = 274, |
OPEN = 275 |
}; |
#endif |
/* Tokens. */ |
#define NEWLINE 258 |
#define VERBOSE 259 |
#define FILENAME 260 |
#define ADDLIB 261 |
#define LIST 262 |
#define ADDMOD 263 |
#define CLEAR 264 |
#define CREATE 265 |
#define DELETE 266 |
#define DIRECTORY 267 |
#define END 268 |
#define EXTRACT 269 |
#define FULLDIR 270 |
#define HELP 271 |
#define QUIT 272 |
#define REPLACE 273 |
#define SAVE 274 |
#define OPEN 275 |
/* Copy the first part of user declarations. */ |
#line 1 "arparse.y" |
/* arparse.y - Stange script language parser */ |
/* Copyright 1992, 1993, 1995, 1997, 1999, 2002, 2003, 2005, 2007 |
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 3 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., 51 Franklin Street - Fifth Floor, Boston, |
MA 02110-1301, USA. */ |
/* Contributed by Steve Chamberlain |
sac@cygnus.com |
*/ |
#define DONTDECLARE_MALLOC |
#include "sysdep.h" |
#include "bfd.h" |
#include "arsup.h" |
extern int verbose; |
extern int yylex (void); |
static int yyerror (const char *); |
/* Enabling traces. */ |
#ifndef YYDEBUG |
# define YYDEBUG 0 |
#endif |
/* Enabling verbose error messages. */ |
#ifdef YYERROR_VERBOSE |
# undef YYERROR_VERBOSE |
# define YYERROR_VERBOSE 1 |
#else |
# define YYERROR_VERBOSE 0 |
#endif |
/* Enabling the token table. */ |
#ifndef YYTOKEN_TABLE |
# define YYTOKEN_TABLE 0 |
#endif |
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED |
typedef union YYSTYPE |
#line 38 "arparse.y" |
{ |
char *name; |
struct list *list ; |
} |
/* Line 193 of yacc.c. */ |
#line 179 "arparse.c" |
YYSTYPE; |
# define yystype YYSTYPE /* obsolescent; will be withdrawn */ |
# define YYSTYPE_IS_DECLARED 1 |
# define YYSTYPE_IS_TRIVIAL 1 |
#endif |
/* Copy the second part of user declarations. */ |
/* Line 216 of yacc.c. */ |
#line 192 "arparse.c" |
#ifdef short |
# undef short |
#endif |
#ifdef YYTYPE_UINT8 |
typedef YYTYPE_UINT8 yytype_uint8; |
#else |
typedef unsigned char yytype_uint8; |
#endif |
#ifdef YYTYPE_INT8 |
typedef YYTYPE_INT8 yytype_int8; |
#elif (defined __STDC__ || defined __C99__FUNC__ \ |
|| defined __cplusplus || defined _MSC_VER) |
typedef signed char yytype_int8; |
#else |
typedef short int yytype_int8; |
#endif |
#ifdef YYTYPE_UINT16 |
typedef YYTYPE_UINT16 yytype_uint16; |
#else |
typedef unsigned short int yytype_uint16; |
#endif |
#ifdef YYTYPE_INT16 |
typedef YYTYPE_INT16 yytype_int16; |
#else |
typedef short int yytype_int16; |
#endif |
#ifndef YYSIZE_T |
# ifdef __SIZE_TYPE__ |
# define YYSIZE_T __SIZE_TYPE__ |
# elif defined size_t |
# define YYSIZE_T size_t |
# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ |
|| defined __cplusplus || defined _MSC_VER) |
# include <stddef.h> /* INFRINGES ON USER NAME SPACE */ |
# define YYSIZE_T size_t |
# else |
# define YYSIZE_T unsigned int |
# endif |
#endif |
#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) |
#ifndef YY_ |
# if defined YYENABLE_NLS && YYENABLE_NLS |
# if ENABLE_NLS |
# include <libintl.h> /* INFRINGES ON USER NAME SPACE */ |
# define YY_(msgid) dgettext ("bison-runtime", msgid) |
# endif |
# endif |
# ifndef YY_ |
# define YY_(msgid) msgid |
# endif |
#endif |
/* Suppress unused-variable warnings by "using" E. */ |
#if ! defined lint || defined __GNUC__ |
# define YYUSE(e) ((void) (e)) |
#else |
# define YYUSE(e) /* empty */ |
#endif |
/* Identity function, used to suppress warnings about constant conditions. */ |
#ifndef lint |
# define YYID(n) (n) |
#else |
#if (defined __STDC__ || defined __C99__FUNC__ \ |
|| defined __cplusplus || defined _MSC_VER) |
static int |
YYID (int i) |
#else |
static int |
YYID (i) |
int i; |
#endif |
{ |
return i; |
} |
#endif |
#if ! defined yyoverflow || YYERROR_VERBOSE |
/* The parser invokes alloca or malloc; define the necessary symbols. */ |
# ifdef YYSTACK_USE_ALLOCA |
# if YYSTACK_USE_ALLOCA |
# ifdef __GNUC__ |
# define YYSTACK_ALLOC __builtin_alloca |
# elif defined __BUILTIN_VA_ARG_INCR |
# include <alloca.h> /* INFRINGES ON USER NAME SPACE */ |
# elif defined _AIX |
# define YYSTACK_ALLOC __alloca |
# elif defined _MSC_VER |
# include <malloc.h> /* INFRINGES ON USER NAME SPACE */ |
# define alloca _alloca |
# else |
# define YYSTACK_ALLOC alloca |
# if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ |
|| defined __cplusplus || defined _MSC_VER) |
# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ |
# ifndef _STDLIB_H |
# define _STDLIB_H 1 |
# endif |
# endif |
# endif |
# endif |
# endif |
# ifdef YYSTACK_ALLOC |
/* Pacify GCC's `empty if-body' warning. */ |
# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) |
# ifndef YYSTACK_ALLOC_MAXIMUM |
/* The OS might guarantee only one guard page at the bottom of the stack, |
and a page size can be as small as 4096 bytes. So we cannot safely |
invoke alloca (N) if N exceeds 4096. Use a slightly smaller number |
to allow for a few compiler-allocated temporary stack slots. */ |
# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ |
# endif |
# else |
# define YYSTACK_ALLOC YYMALLOC |
# define YYSTACK_FREE YYFREE |
# ifndef YYSTACK_ALLOC_MAXIMUM |
# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM |
# endif |
# if (defined __cplusplus && ! defined _STDLIB_H \ |
&& ! ((defined YYMALLOC || defined malloc) \ |
&& (defined YYFREE || defined free))) |
# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ |
# ifndef _STDLIB_H |
# define _STDLIB_H 1 |
# endif |
# endif |
# ifndef YYMALLOC |
# define YYMALLOC malloc |
# if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ |
|| defined __cplusplus || defined _MSC_VER) |
void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ |
# endif |
# endif |
# ifndef YYFREE |
# define YYFREE free |
# if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ |
|| defined __cplusplus || defined _MSC_VER) |
void free (void *); /* INFRINGES ON USER NAME SPACE */ |
# endif |
# endif |
# endif |
#endif /* ! defined yyoverflow || YYERROR_VERBOSE */ |
#if (! defined yyoverflow \ |
&& (! defined __cplusplus \ |
|| (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) |
/* A type that is properly aligned for any stack member. */ |
union yyalloc |
{ |
yytype_int16 yyss; |
YYSTYPE yyvs; |
}; |
/* The size of the maximum gap between one aligned stack and the next. */ |
# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) |
/* The size of an array large to enough to hold all stacks, each with |
N elements. */ |
# define YYSTACK_BYTES(N) \ |
((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ |
+ YYSTACK_GAP_MAXIMUM) |
/* Copy COUNT objects from FROM to TO. The source and destination do |
not overlap. */ |
# ifndef YYCOPY |
# if defined __GNUC__ && 1 < __GNUC__ |
# define YYCOPY(To, From, Count) \ |
__builtin_memcpy (To, From, (Count) * sizeof (*(From))) |
# else |
# define YYCOPY(To, From, Count) \ |
do \ |
{ \ |
YYSIZE_T yyi; \ |
for (yyi = 0; yyi < (Count); yyi++) \ |
(To)[yyi] = (From)[yyi]; \ |
} \ |
while (YYID (0)) |
# endif |
# endif |
/* Relocate STACK from its old location to the new one. The |
local variables YYSIZE and YYSTACKSIZE give the old and new number of |
elements in the stack, and YYPTR gives the new location of the |
stack. Advance YYPTR to a properly aligned location for the next |
stack. */ |
# define YYSTACK_RELOCATE(Stack) \ |
do \ |
{ \ |
YYSIZE_T yynewbytes; \ |
YYCOPY (&yyptr->Stack, Stack, yysize); \ |
Stack = &yyptr->Stack; \ |
yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ |
yyptr += yynewbytes / sizeof (*yyptr); \ |
} \ |
while (YYID (0)) |
#endif |
/* YYFINAL -- State number of the termination state. */ |
#define YYFINAL 3 |
/* YYLAST -- Last index in YYTABLE. */ |
#define YYLAST 34 |
/* YYNTOKENS -- Number of terminals. */ |
#define YYNTOKENS 24 |
/* YYNNTS -- Number of nonterminals. */ |
#define YYNNTS 22 |
/* YYNRULES -- Number of rules. */ |
#define YYNRULES 42 |
/* YYNRULES -- Number of states. */ |
#define YYNSTATES 53 |
/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ |
#define YYUNDEFTOK 2 |
#define YYMAXUTOK 275 |
#define YYTRANSLATE(YYX) \ |
((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) |
/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ |
static const yytype_uint8 yytranslate[] = |
{ |
0, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
21, 22, 2, 2, 23, 2, 2, 2, 2, 2, |
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
2, 2, 2, 2, 2, 2, 1, 2, 3, 4, |
5, 6, 7, 8, 9, 10, 11, 12, 13, 14, |
15, 16, 17, 18, 19, 20 |
}; |
#if YYDEBUG |
/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in |
YYRHS. */ |
static const yytype_uint8 yyprhs[] = |
{ |
0, 0, 3, 4, 7, 10, 11, 14, 16, 18, |
20, 22, 24, 26, 28, 30, 32, 34, 36, 38, |
40, 42, 44, 45, 48, 51, 53, 56, 59, 61, |
63, 66, 69, 73, 78, 80, 81, 85, 86, 90, |
91, 93, 94 |
}; |
/* YYRHS -- A `-1'-separated list of the rules' RHS. */ |
static const yytype_int8 yyrhs[] = |
{ |
25, 0, -1, -1, 26, 27, -1, 27, 28, -1, |
-1, 29, 3, -1, 37, -1, 38, -1, 45, -1, |
40, -1, 39, -1, 32, -1, 34, -1, 36, -1, |
30, -1, 31, -1, 33, -1, 35, -1, 13, -1, |
1, -1, 5, -1, -1, 14, 43, -1, 18, 43, |
-1, 9, -1, 11, 43, -1, 8, 43, -1, 7, |
-1, 19, -1, 20, 5, -1, 10, 5, -1, 6, |
5, 42, -1, 12, 5, 42, 41, -1, 5, -1, |
-1, 21, 43, 22, -1, -1, 43, 44, 5, -1, |
-1, 23, -1, -1, 4, -1 |
}; |
/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ |
static const yytype_uint8 yyrline[] = |
{ |
0, 69, 69, 69, 73, 74, 78, 82, 83, 84, |
85, 86, 87, 88, 89, 90, 91, 92, 93, 94, |
95, 96, 97, 102, 107, 112, 117, 121, 126, 131, |
138, 143, 149, 153, 160, 162, 166, 169, 173, 179, |
184, 185, 190 |
}; |
#endif |
#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE |
/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. |
First, the terminals, then, starting at YYNTOKENS, nonterminals. */ |
static const char *const yytname[] = |
{ |
"$end", "error", "$undefined", "NEWLINE", "VERBOSE", "FILENAME", |
"ADDLIB", "LIST", "ADDMOD", "CLEAR", "CREATE", "DELETE", "DIRECTORY", |
"END", "EXTRACT", "FULLDIR", "HELP", "QUIT", "REPLACE", "SAVE", "OPEN", |
"'('", "')'", "','", "$accept", "start", "@1", "session", "command_line", |
"command", "extract_command", "replace_command", "clear_command", |
"delete_command", "addmod_command", "list_command", "save_command", |
"open_command", "create_command", "addlib_command", "directory_command", |
"optional_filename", "modulelist", "modulename", "optcomma", |
"verbose_command", 0 |
}; |
#endif |
# ifdef YYPRINT |
/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to |
token YYLEX-NUM. */ |
static const yytype_uint16 yytoknum[] = |
{ |
0, 256, 257, 258, 259, 260, 261, 262, 263, 264, |
265, 266, 267, 268, 269, 270, 271, 272, 273, 274, |
275, 40, 41, 44 |
}; |
# endif |
/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ |
static const yytype_uint8 yyr1[] = |
{ |
0, 24, 26, 25, 27, 27, 28, 29, 29, 29, |
29, 29, 29, 29, 29, 29, 29, 29, 29, 29, |
29, 29, 29, 30, 31, 32, 33, 34, 35, 36, |
37, 38, 39, 40, 41, 41, 42, 42, 43, 43, |
44, 44, 45 |
}; |
/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ |
static const yytype_uint8 yyr2[] = |
{ |
0, 2, 0, 2, 2, 0, 2, 1, 1, 1, |
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
1, 1, 0, 2, 2, 1, 2, 2, 1, 1, |
2, 2, 3, 4, 1, 0, 3, 0, 3, 0, |
1, 0, 1 |
}; |
/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state |
STATE-NUM when YYTABLE doesn't specify something else to do. Zero |
means the default is an error. */ |
static const yytype_uint8 yydefact[] = |
{ |
2, 0, 5, 1, 0, 20, 42, 21, 0, 28, |
39, 25, 0, 39, 0, 19, 39, 39, 29, 0, |
4, 0, 15, 16, 12, 17, 13, 18, 14, 7, |
8, 11, 10, 9, 37, 27, 31, 26, 37, 23, |
24, 30, 6, 39, 32, 40, 0, 35, 41, 38, |
34, 33, 36 |
}; |
/* YYDEFGOTO[NTERM-NUM]. */ |
static const yytype_int8 yydefgoto[] = |
{ |
-1, 1, 2, 4, 20, 21, 22, 23, 24, 25, |
26, 27, 28, 29, 30, 31, 32, 51, 44, 35, |
46, 33 |
}; |
/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing |
STATE-NUM. */ |
#define YYPACT_NINF -14 |
static const yytype_int8 yypact[] = |
{ |
-14, 1, -14, -14, 5, -14, -14, -14, 2, -14, |
-14, -14, 21, -14, 22, -14, -14, -14, -14, 23, |
-14, 26, -14, -14, -14, -14, -14, -14, -14, -14, |
-14, -14, -14, -14, 10, -3, -14, -3, 10, -3, |
-3, -14, -14, -14, -14, -14, 27, 28, -1, -14, |
-14, -14, -14 |
}; |
/* YYPGOTO[NTERM-NUM]. */ |
static const yytype_int8 yypgoto[] = |
{ |
-14, -14, -14, -14, -14, -14, -14, -14, -14, -14, |
-14, -14, -14, -14, -14, -14, -14, -14, -4, -13, |
-14, -14 |
}; |
/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If |
positive, shift that token. If negative, reduce the rule which |
number is the opposite. If zero, do what YYDEFACT says. |
If YYTABLE_NINF, syntax error. */ |
#define YYTABLE_NINF -42 |
static const yytype_int8 yytable[] = |
{ |
37, 3, -41, 39, 40, -3, 5, 34, -22, 6, |
7, 8, 9, 10, 11, 12, 13, 14, 15, 16, |
45, 52, 45, 17, 18, 19, 36, 38, 41, 42, |
48, 43, 49, 50, 47 |
}; |
static const yytype_uint8 yycheck[] = |
{ |
13, 0, 5, 16, 17, 0, 1, 5, 3, 4, |
5, 6, 7, 8, 9, 10, 11, 12, 13, 14, |
23, 22, 23, 18, 19, 20, 5, 5, 5, 3, |
43, 21, 5, 5, 38 |
}; |
/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing |
symbol of state STATE-NUM. */ |
static const yytype_uint8 yystos[] = |
{ |
0, 25, 26, 0, 27, 1, 4, 5, 6, 7, |
8, 9, 10, 11, 12, 13, 14, 18, 19, 20, |
28, 29, 30, 31, 32, 33, 34, 35, 36, 37, |
38, 39, 40, 45, 5, 43, 5, 43, 5, 43, |
43, 5, 3, 21, 42, 23, 44, 42, 43, 5, |
5, 41, 22 |
}; |
#define yyerrok (yyerrstatus = 0) |
#define yyclearin (yychar = YYEMPTY) |
#define YYEMPTY (-2) |
#define YYEOF 0 |
#define YYACCEPT goto yyacceptlab |
#define YYABORT goto yyabortlab |
#define YYERROR goto yyerrorlab |
/* Like YYERROR except do call yyerror. This remains here temporarily |
to ease the transition to the new meaning of YYERROR, for GCC. |
Once GCC version 2 has supplanted version 1, this can go. */ |
#define YYFAIL goto yyerrlab |
#define YYRECOVERING() (!!yyerrstatus) |
#define YYBACKUP(Token, Value) \ |
do \ |
if (yychar == YYEMPTY && yylen == 1) \ |
{ \ |
yychar = (Token); \ |
yylval = (Value); \ |
yytoken = YYTRANSLATE (yychar); \ |
YYPOPSTACK (1); \ |
goto yybackup; \ |
} \ |
else \ |
{ \ |
yyerror (YY_("syntax error: cannot back up")); \ |
YYERROR; \ |
} \ |
while (YYID (0)) |
#define YYTERROR 1 |
#define YYERRCODE 256 |
/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. |
If N is 0, then set CURRENT to the empty location which ends |
the previous symbol: RHS[0] (always defined). */ |
#define YYRHSLOC(Rhs, K) ((Rhs)[K]) |
#ifndef YYLLOC_DEFAULT |
# define YYLLOC_DEFAULT(Current, Rhs, N) \ |
do \ |
if (YYID (N)) \ |
{ \ |
(Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ |
(Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ |
(Current).last_line = YYRHSLOC (Rhs, N).last_line; \ |
(Current).last_column = YYRHSLOC (Rhs, N).last_column; \ |
} \ |
else \ |
{ \ |
(Current).first_line = (Current).last_line = \ |
YYRHSLOC (Rhs, 0).last_line; \ |
(Current).first_column = (Current).last_column = \ |
YYRHSLOC (Rhs, 0).last_column; \ |
} \ |
while (YYID (0)) |
#endif |
/* YY_LOCATION_PRINT -- Print the location on the stream. |
This macro was not mandated originally: define only if we know |
we won't break user code: when these are the locations we know. */ |
#ifndef YY_LOCATION_PRINT |
# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL |
# define YY_LOCATION_PRINT(File, Loc) \ |
fprintf (File, "%d.%d-%d.%d", \ |
(Loc).first_line, (Loc).first_column, \ |
(Loc).last_line, (Loc).last_column) |
# else |
# define YY_LOCATION_PRINT(File, Loc) ((void) 0) |
# endif |
#endif |
/* YYLEX -- calling `yylex' with the right arguments. */ |
#ifdef YYLEX_PARAM |
# define YYLEX yylex (YYLEX_PARAM) |
#else |
# define YYLEX yylex () |
#endif |
/* Enable debugging if requested. */ |
#if YYDEBUG |
# ifndef YYFPRINTF |
# include <stdio.h> /* INFRINGES ON USER NAME SPACE */ |
# define YYFPRINTF fprintf |
# endif |
# define YYDPRINTF(Args) \ |
do { \ |
if (yydebug) \ |
YYFPRINTF Args; \ |
} while (YYID (0)) |
# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ |
do { \ |
if (yydebug) \ |
{ \ |
YYFPRINTF (stderr, "%s ", Title); \ |
yy_symbol_print (stderr, \ |
Type, Value); \ |
YYFPRINTF (stderr, "\n"); \ |
} \ |
} while (YYID (0)) |
/*--------------------------------. |
| Print this symbol on YYOUTPUT. | |
`--------------------------------*/ |
/*ARGSUSED*/ |
#if (defined __STDC__ || defined __C99__FUNC__ \ |
|| defined __cplusplus || defined _MSC_VER) |
static void |
yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) |
#else |
static void |
yy_symbol_value_print (yyoutput, yytype, yyvaluep) |
FILE *yyoutput; |
int yytype; |
YYSTYPE const * const yyvaluep; |
#endif |
{ |
if (!yyvaluep) |
return; |
# ifdef YYPRINT |
if (yytype < YYNTOKENS) |
YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); |
# else |
YYUSE (yyoutput); |
# endif |
switch (yytype) |
{ |
default: |
break; |
} |
} |
/*--------------------------------. |
| Print this symbol on YYOUTPUT. | |
`--------------------------------*/ |
#if (defined __STDC__ || defined __C99__FUNC__ \ |
|| defined __cplusplus || defined _MSC_VER) |
static void |
yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) |
#else |
static void |
yy_symbol_print (yyoutput, yytype, yyvaluep) |
FILE *yyoutput; |
int yytype; |
YYSTYPE const * const yyvaluep; |
#endif |
{ |
if (yytype < YYNTOKENS) |
YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); |
else |
YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); |
yy_symbol_value_print (yyoutput, yytype, yyvaluep); |
YYFPRINTF (yyoutput, ")"); |
} |
/*------------------------------------------------------------------. |
| yy_stack_print -- Print the state stack from its BOTTOM up to its | |
| TOP (included). | |
`------------------------------------------------------------------*/ |
#if (defined __STDC__ || defined __C99__FUNC__ \ |
|| defined __cplusplus || defined _MSC_VER) |
static void |
yy_stack_print (yytype_int16 *bottom, yytype_int16 *top) |
#else |
static void |
yy_stack_print (bottom, top) |
yytype_int16 *bottom; |
yytype_int16 *top; |
#endif |
{ |
YYFPRINTF (stderr, "Stack now"); |
for (; bottom <= top; ++bottom) |
YYFPRINTF (stderr, " %d", *bottom); |
YYFPRINTF (stderr, "\n"); |
} |
# define YY_STACK_PRINT(Bottom, Top) \ |
do { \ |
if (yydebug) \ |
yy_stack_print ((Bottom), (Top)); \ |
} while (YYID (0)) |
/*------------------------------------------------. |
| Report that the YYRULE is going to be reduced. | |
`------------------------------------------------*/ |
#if (defined __STDC__ || defined __C99__FUNC__ \ |
|| defined __cplusplus || defined _MSC_VER) |
static void |
yy_reduce_print (YYSTYPE *yyvsp, int yyrule) |
#else |
static void |
yy_reduce_print (yyvsp, yyrule) |
YYSTYPE *yyvsp; |
int yyrule; |
#endif |
{ |
int yynrhs = yyr2[yyrule]; |
int yyi; |
unsigned long int yylno = yyrline[yyrule]; |
YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", |
yyrule - 1, yylno); |
/* The symbols being reduced. */ |
for (yyi = 0; yyi < yynrhs; yyi++) |
{ |
fprintf (stderr, " $%d = ", yyi + 1); |
yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], |
&(yyvsp[(yyi + 1) - (yynrhs)]) |
); |
fprintf (stderr, "\n"); |
} |
} |
# define YY_REDUCE_PRINT(Rule) \ |
do { \ |
if (yydebug) \ |
yy_reduce_print (yyvsp, Rule); \ |
} while (YYID (0)) |
/* Nonzero means print parse trace. It is left uninitialized so that |
multiple parsers can coexist. */ |
int yydebug; |
#else /* !YYDEBUG */ |
# define YYDPRINTF(Args) |
# define YY_SYMBOL_PRINT(Title, Type, Value, Location) |
# define YY_STACK_PRINT(Bottom, Top) |
# define YY_REDUCE_PRINT(Rule) |
#endif /* !YYDEBUG */ |
/* YYINITDEPTH -- initial size of the parser's stacks. */ |
#ifndef YYINITDEPTH |
# define YYINITDEPTH 200 |
#endif |
/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only |
if the built-in stack extension method is used). |
Do not make this value too large; the results are undefined if |
YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) |
evaluated with infinite-precision integer arithmetic. */ |
#ifndef YYMAXDEPTH |
# define YYMAXDEPTH 10000 |
#endif |
#if YYERROR_VERBOSE |
# ifndef yystrlen |
# if defined __GLIBC__ && defined _STRING_H |
# define yystrlen strlen |
# else |
/* Return the length of YYSTR. */ |
#if (defined __STDC__ || defined __C99__FUNC__ \ |
|| defined __cplusplus || defined _MSC_VER) |
static YYSIZE_T |
yystrlen (const char *yystr) |
#else |
static YYSIZE_T |
yystrlen (yystr) |
const char *yystr; |
#endif |
{ |
YYSIZE_T yylen; |
for (yylen = 0; yystr[yylen]; yylen++) |
continue; |
return yylen; |
} |
# endif |
# endif |
# ifndef yystpcpy |
# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE |
# define yystpcpy stpcpy |
# else |
/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in |
YYDEST. */ |
#if (defined __STDC__ || defined __C99__FUNC__ \ |
|| defined __cplusplus || defined _MSC_VER) |
static char * |
yystpcpy (char *yydest, const char *yysrc) |
#else |
static char * |
yystpcpy (yydest, yysrc) |
char *yydest; |
const char *yysrc; |
#endif |
{ |
char *yyd = yydest; |
const char *yys = yysrc; |
while ((*yyd++ = *yys++) != '\0') |
continue; |
return yyd - 1; |
} |
# endif |
# endif |
# ifndef yytnamerr |
/* Copy to YYRES the contents of YYSTR after stripping away unnecessary |
quotes and backslashes, so that it's suitable for yyerror. The |
heuristic is that double-quoting is unnecessary unless the string |
contains an apostrophe, a comma, or backslash (other than |
backslash-backslash). YYSTR is taken from yytname. If YYRES is |
null, do not copy; instead, return the length of what the result |
would have been. */ |
static YYSIZE_T |
yytnamerr (char *yyres, const char *yystr) |
{ |
if (*yystr == '"') |
{ |
YYSIZE_T yyn = 0; |
char const *yyp = yystr; |
for (;;) |
switch (*++yyp) |
{ |
case '\'': |
case ',': |
goto do_not_strip_quotes; |
case '\\': |
if (*++yyp != '\\') |
goto do_not_strip_quotes; |
/* Fall through. */ |
default: |
if (yyres) |
yyres[yyn] = *yyp; |
yyn++; |
break; |
case '"': |
if (yyres) |
yyres[yyn] = '\0'; |
return yyn; |
} |
do_not_strip_quotes: ; |
} |
if (! yyres) |
return yystrlen (yystr); |
return yystpcpy (yyres, yystr) - yyres; |
} |
# endif |
/* Copy into YYRESULT an error message about the unexpected token |
YYCHAR while in state YYSTATE. Return the number of bytes copied, |
including the terminating null byte. If YYRESULT is null, do not |
copy anything; just return the number of bytes that would be |
copied. As a special case, return 0 if an ordinary "syntax error" |
message will do. Return YYSIZE_MAXIMUM if overflow occurs during |
size calculation. */ |
static YYSIZE_T |
yysyntax_error (char *yyresult, int yystate, int yychar) |
{ |
int yyn = yypact[yystate]; |
if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) |
return 0; |
else |
{ |
int yytype = YYTRANSLATE (yychar); |
YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); |
YYSIZE_T yysize = yysize0; |
YYSIZE_T yysize1; |
int yysize_overflow = 0; |
enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; |
char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; |
int yyx; |
# if 0 |
/* This is so xgettext sees the translatable formats that are |
constructed on the fly. */ |
YY_("syntax error, unexpected %s"); |
YY_("syntax error, unexpected %s, expecting %s"); |
YY_("syntax error, unexpected %s, expecting %s or %s"); |
YY_("syntax error, unexpected %s, expecting %s or %s or %s"); |
YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); |
# endif |
char *yyfmt; |
char const *yyf; |
static char const yyunexpected[] = "syntax error, unexpected %s"; |
static char const yyexpecting[] = ", expecting %s"; |
static char const yyor[] = " or %s"; |
char yyformat[sizeof yyunexpected |
+ sizeof yyexpecting - 1 |
+ ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) |
* (sizeof yyor - 1))]; |
char const *yyprefix = yyexpecting; |
/* Start YYX at -YYN if negative to avoid negative indexes in |
YYCHECK. */ |
int yyxbegin = yyn < 0 ? -yyn : 0; |
/* Stay within bounds of both yycheck and yytname. */ |
int yychecklim = YYLAST - yyn + 1; |
int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; |
int yycount = 1; |
yyarg[0] = yytname[yytype]; |
yyfmt = yystpcpy (yyformat, yyunexpected); |
for (yyx = yyxbegin; yyx < yyxend; ++yyx) |
if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) |
{ |
if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) |
{ |
yycount = 1; |
yysize = yysize0; |
yyformat[sizeof yyunexpected - 1] = '\0'; |
break; |
} |
yyarg[yycount++] = yytname[yyx]; |
yysize1 = yysize + yytnamerr (0, yytname[yyx]); |
yysize_overflow |= (yysize1 < yysize); |
yysize = yysize1; |
yyfmt = yystpcpy (yyfmt, yyprefix); |
yyprefix = yyor; |
} |
yyf = YY_(yyformat); |
yysize1 = yysize + yystrlen (yyf); |
yysize_overflow |= (yysize1 < yysize); |
yysize = yysize1; |
if (yysize_overflow) |
return YYSIZE_MAXIMUM; |
if (yyresult) |
{ |
/* Avoid sprintf, as that infringes on the user's name space. |
Don't have undefined behavior even if the translation |
produced a string with the wrong number of "%s"s. */ |
char *yyp = yyresult; |
int yyi = 0; |
while ((*yyp = *yyf) != '\0') |
{ |
if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) |
{ |
yyp += yytnamerr (yyp, yyarg[yyi++]); |
yyf += 2; |
} |
else |
{ |
yyp++; |
yyf++; |
} |
} |
} |
return yysize; |
} |
} |
#endif /* YYERROR_VERBOSE */ |
/*-----------------------------------------------. |
| Release the memory associated to this symbol. | |
`-----------------------------------------------*/ |
/*ARGSUSED*/ |
#if (defined __STDC__ || defined __C99__FUNC__ \ |
|| defined __cplusplus || defined _MSC_VER) |
static void |
yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) |
#else |
static void |
yydestruct (yymsg, yytype, yyvaluep) |
const char *yymsg; |
int yytype; |
YYSTYPE *yyvaluep; |
#endif |
{ |
YYUSE (yyvaluep); |
if (!yymsg) |
yymsg = "Deleting"; |
YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); |
switch (yytype) |
{ |
default: |
break; |
} |
} |
/* Prevent warnings from -Wmissing-prototypes. */ |
#ifdef YYPARSE_PARAM |
#if defined __STDC__ || defined __cplusplus |
int yyparse (void *YYPARSE_PARAM); |
#else |
int yyparse (); |
#endif |
#else /* ! YYPARSE_PARAM */ |
#if defined __STDC__ || defined __cplusplus |
int yyparse (void); |
#else |
int yyparse (); |
#endif |
#endif /* ! YYPARSE_PARAM */ |
/* The look-ahead symbol. */ |
int yychar; |
/* The semantic value of the look-ahead symbol. */ |
YYSTYPE yylval; |
/* Number of syntax errors so far. */ |
int yynerrs; |
/*----------. |
| yyparse. | |
`----------*/ |
#ifdef YYPARSE_PARAM |
#if (defined __STDC__ || defined __C99__FUNC__ \ |
|| defined __cplusplus || defined _MSC_VER) |
int |
yyparse (void *YYPARSE_PARAM) |
#else |
int |
yyparse (YYPARSE_PARAM) |
void *YYPARSE_PARAM; |
#endif |
#else /* ! YYPARSE_PARAM */ |
#if (defined __STDC__ || defined __C99__FUNC__ \ |
|| defined __cplusplus || defined _MSC_VER) |
int |
yyparse (void) |
#else |
int |
yyparse () |
#endif |
#endif |
{ |
int yystate; |
int yyn; |
int yyresult; |
/* Number of tokens to shift before error messages enabled. */ |
int yyerrstatus; |
/* Look-ahead token as an internal (translated) token number. */ |
int yytoken = 0; |
#if YYERROR_VERBOSE |
/* Buffer for error messages, and its allocated size. */ |
char yymsgbuf[128]; |
char *yymsg = yymsgbuf; |
YYSIZE_T yymsg_alloc = sizeof yymsgbuf; |
#endif |
/* Three stacks and their tools: |
`yyss': related to states, |
`yyvs': related to semantic values, |
`yyls': related to locations. |
Refer to the stacks thru separate pointers, to allow yyoverflow |
to reallocate them elsewhere. */ |
/* The state stack. */ |
yytype_int16 yyssa[YYINITDEPTH]; |
yytype_int16 *yyss = yyssa; |
yytype_int16 *yyssp; |
/* The semantic value stack. */ |
YYSTYPE yyvsa[YYINITDEPTH]; |
YYSTYPE *yyvs = yyvsa; |
YYSTYPE *yyvsp; |
#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) |
YYSIZE_T yystacksize = YYINITDEPTH; |
/* The variables used to return semantic value and location from the |
action routines. */ |
YYSTYPE yyval; |
/* The number of symbols on the RHS of the reduced rule. |
Keep to zero when no symbol should be popped. */ |
int yylen = 0; |
YYDPRINTF ((stderr, "Starting parse\n")); |
yystate = 0; |
yyerrstatus = 0; |
yynerrs = 0; |
yychar = YYEMPTY; /* Cause a token to be read. */ |
/* Initialize stack pointers. |
Waste one element of value and location stack |
so that they stay on the same level as the state stack. |
The wasted elements are never initialized. */ |
yyssp = yyss; |
yyvsp = yyvs; |
goto yysetstate; |
/*------------------------------------------------------------. |
| yynewstate -- Push a new state, which is found in yystate. | |
`------------------------------------------------------------*/ |
yynewstate: |
/* In all cases, when you get here, the value and location stacks |
have just been pushed. So pushing a state here evens the stacks. */ |
yyssp++; |
yysetstate: |
*yyssp = yystate; |
if (yyss + yystacksize - 1 <= yyssp) |
{ |
/* Get the current used size of the three stacks, in elements. */ |
YYSIZE_T yysize = yyssp - yyss + 1; |
#ifdef yyoverflow |
{ |
/* Give user a chance to reallocate the stack. Use copies of |
these so that the &'s don't force the real ones into |
memory. */ |
YYSTYPE *yyvs1 = yyvs; |
yytype_int16 *yyss1 = yyss; |
/* Each stack pointer address is followed by the size of the |
data in use in that stack, in bytes. This used to be a |
conditional around just the two extra args, but that might |
be undefined if yyoverflow is a macro. */ |
yyoverflow (YY_("memory exhausted"), |
&yyss1, yysize * sizeof (*yyssp), |
&yyvs1, yysize * sizeof (*yyvsp), |
&yystacksize); |
yyss = yyss1; |
yyvs = yyvs1; |
} |
#else /* no yyoverflow */ |
# ifndef YYSTACK_RELOCATE |
goto yyexhaustedlab; |
# else |
/* Extend the stack our own way. */ |
if (YYMAXDEPTH <= yystacksize) |
goto yyexhaustedlab; |
yystacksize *= 2; |
if (YYMAXDEPTH < yystacksize) |
yystacksize = YYMAXDEPTH; |
{ |
yytype_int16 *yyss1 = yyss; |
union yyalloc *yyptr = |
(union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); |
if (! yyptr) |
goto yyexhaustedlab; |
YYSTACK_RELOCATE (yyss); |
YYSTACK_RELOCATE (yyvs); |
# undef YYSTACK_RELOCATE |
if (yyss1 != yyssa) |
YYSTACK_FREE (yyss1); |
} |
# endif |
#endif /* no yyoverflow */ |
yyssp = yyss + yysize - 1; |
yyvsp = yyvs + yysize - 1; |
YYDPRINTF ((stderr, "Stack size increased to %lu\n", |
(unsigned long int) yystacksize)); |
if (yyss + yystacksize - 1 <= yyssp) |
YYABORT; |
} |
YYDPRINTF ((stderr, "Entering state %d\n", yystate)); |
goto yybackup; |
/*-----------. |
| yybackup. | |
`-----------*/ |
yybackup: |
/* Do appropriate processing given the current state. Read a |
look-ahead token if we need one and don't already have one. */ |
/* First try to decide what to do without reference to look-ahead token. */ |
yyn = yypact[yystate]; |
if (yyn == YYPACT_NINF) |
goto yydefault; |
/* Not known => get a look-ahead token if don't already have one. */ |
/* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */ |
if (yychar == YYEMPTY) |
{ |
YYDPRINTF ((stderr, "Reading a token: ")); |
yychar = YYLEX; |
} |
if (yychar <= YYEOF) |
{ |
yychar = yytoken = YYEOF; |
YYDPRINTF ((stderr, "Now at end of input.\n")); |
} |
else |
{ |
yytoken = YYTRANSLATE (yychar); |
YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); |
} |
/* If the proper action on seeing token YYTOKEN is to reduce or to |
detect an error, take that action. */ |
yyn += yytoken; |
if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) |
goto yydefault; |
yyn = yytable[yyn]; |
if (yyn <= 0) |
{ |
if (yyn == 0 || yyn == YYTABLE_NINF) |
goto yyerrlab; |
yyn = -yyn; |
goto yyreduce; |
} |
if (yyn == YYFINAL) |
YYACCEPT; |
/* Count tokens shifted since error; after three, turn off error |
status. */ |
if (yyerrstatus) |
yyerrstatus--; |
/* Shift the look-ahead token. */ |
YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); |
/* Discard the shifted token unless it is eof. */ |
if (yychar != YYEOF) |
yychar = YYEMPTY; |
yystate = yyn; |
*++yyvsp = yylval; |
goto yynewstate; |
/*-----------------------------------------------------------. |
| yydefault -- do the default action for the current state. | |
`-----------------------------------------------------------*/ |
yydefault: |
yyn = yydefact[yystate]; |
if (yyn == 0) |
goto yyerrlab; |
goto yyreduce; |
/*-----------------------------. |
| yyreduce -- Do a reduction. | |
`-----------------------------*/ |
yyreduce: |
/* yyn is the number of a rule to reduce with. */ |
yylen = yyr2[yyn]; |
/* If YYLEN is nonzero, implement the default value of the action: |
`$$ = $1'. |
Otherwise, the following line sets YYVAL to garbage. |
This behavior is undocumented and Bison |
users should not rely upon it. Assigning to YYVAL |
unconditionally makes the parser a bit smaller, and it avoids a |
GCC warning that YYVAL may be used uninitialized. */ |
yyval = yyvsp[1-yylen]; |
YY_REDUCE_PRINT (yyn); |
switch (yyn) |
{ |
case 2: |
#line 69 "arparse.y" |
{ prompt(); } |
break; |
case 6: |
#line 78 "arparse.y" |
{ prompt(); } |
break; |
case 19: |
#line 94 "arparse.y" |
{ ar_end(); return 0; } |
break; |
case 21: |
#line 96 "arparse.y" |
{ yyerror("foo"); } |
break; |
case 23: |
#line 103 "arparse.y" |
{ ar_extract((yyvsp[(2) - (2)].list)); } |
break; |
case 24: |
#line 108 "arparse.y" |
{ ar_replace((yyvsp[(2) - (2)].list)); } |
break; |
case 25: |
#line 113 "arparse.y" |
{ ar_clear(); } |
break; |
case 26: |
#line 118 "arparse.y" |
{ ar_delete((yyvsp[(2) - (2)].list)); } |
break; |
case 27: |
#line 122 "arparse.y" |
{ ar_addmod((yyvsp[(2) - (2)].list)); } |
break; |
case 28: |
#line 127 "arparse.y" |
{ ar_list(); } |
break; |
case 29: |
#line 132 "arparse.y" |
{ ar_save(); } |
break; |
case 30: |
#line 139 "arparse.y" |
{ ar_open((yyvsp[(2) - (2)].name),0); } |
break; |
case 31: |
#line 144 "arparse.y" |
{ ar_open((yyvsp[(2) - (2)].name),1); } |
break; |
case 32: |
#line 150 "arparse.y" |
{ ar_addlib((yyvsp[(2) - (3)].name),(yyvsp[(3) - (3)].list)); } |
break; |
case 33: |
#line 154 "arparse.y" |
{ ar_directory((yyvsp[(2) - (4)].name), (yyvsp[(3) - (4)].list), (yyvsp[(4) - (4)].name)); } |
break; |
case 34: |
#line 161 "arparse.y" |
{ (yyval.name) = (yyvsp[(1) - (1)].name); } |
break; |
case 35: |
#line 162 "arparse.y" |
{ (yyval.name) = 0; } |
break; |
case 36: |
#line 167 "arparse.y" |
{ (yyval.list) = (yyvsp[(2) - (3)].list); } |
break; |
case 37: |
#line 169 "arparse.y" |
{ (yyval.list) = 0; } |
break; |
case 38: |
#line 174 "arparse.y" |
{ struct list *n = (struct list *) malloc(sizeof(struct list)); |
n->next = (yyvsp[(1) - (3)].list); |
n->name = (yyvsp[(3) - (3)].name); |
(yyval.list) = n; |
} |
break; |
case 39: |
#line 179 "arparse.y" |
{ (yyval.list) = 0; } |
break; |
case 42: |
#line 191 "arparse.y" |
{ verbose = !verbose; } |
break; |
/* Line 1267 of yacc.c. */ |
#line 1546 "arparse.c" |
default: break; |
} |
YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); |
YYPOPSTACK (yylen); |
yylen = 0; |
YY_STACK_PRINT (yyss, yyssp); |
*++yyvsp = yyval; |
/* Now `shift' the result of the reduction. Determine what state |
that goes to, based on the state we popped back to and the rule |
number reduced by. */ |
yyn = yyr1[yyn]; |
yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; |
if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) |
yystate = yytable[yystate]; |
else |
yystate = yydefgoto[yyn - YYNTOKENS]; |
goto yynewstate; |
/*------------------------------------. |
| yyerrlab -- here on detecting error | |
`------------------------------------*/ |
yyerrlab: |
/* If not already recovering from an error, report this error. */ |
if (!yyerrstatus) |
{ |
++yynerrs; |
#if ! YYERROR_VERBOSE |
yyerror (YY_("syntax error")); |
#else |
{ |
YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); |
if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) |
{ |
YYSIZE_T yyalloc = 2 * yysize; |
if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) |
yyalloc = YYSTACK_ALLOC_MAXIMUM; |
if (yymsg != yymsgbuf) |
YYSTACK_FREE (yymsg); |
yymsg = (char *) YYSTACK_ALLOC (yyalloc); |
if (yymsg) |
yymsg_alloc = yyalloc; |
else |
{ |
yymsg = yymsgbuf; |
yymsg_alloc = sizeof yymsgbuf; |
} |
} |
if (0 < yysize && yysize <= yymsg_alloc) |
{ |
(void) yysyntax_error (yymsg, yystate, yychar); |
yyerror (yymsg); |
} |
else |
{ |
yyerror (YY_("syntax error")); |
if (yysize != 0) |
goto yyexhaustedlab; |
} |
} |
#endif |
} |
if (yyerrstatus == 3) |
{ |
/* If just tried and failed to reuse look-ahead token after an |
error, discard it. */ |
if (yychar <= YYEOF) |
{ |
/* Return failure if at end of input. */ |
if (yychar == YYEOF) |
YYABORT; |
} |
else |
{ |
yydestruct ("Error: discarding", |
yytoken, &yylval); |
yychar = YYEMPTY; |
} |
} |
/* Else will try to reuse look-ahead token after shifting the error |
token. */ |
goto yyerrlab1; |
/*---------------------------------------------------. |
| yyerrorlab -- error raised explicitly by YYERROR. | |
`---------------------------------------------------*/ |
yyerrorlab: |
/* Pacify compilers like GCC when the user code never invokes |
YYERROR and the label yyerrorlab therefore never appears in user |
code. */ |
if (/*CONSTCOND*/ 0) |
goto yyerrorlab; |
/* Do not reclaim the symbols of the rule which action triggered |
this YYERROR. */ |
YYPOPSTACK (yylen); |
yylen = 0; |
YY_STACK_PRINT (yyss, yyssp); |
yystate = *yyssp; |
goto yyerrlab1; |
/*-------------------------------------------------------------. |
| yyerrlab1 -- common code for both syntax error and YYERROR. | |
`-------------------------------------------------------------*/ |
yyerrlab1: |
yyerrstatus = 3; /* Each real token shifted decrements this. */ |
for (;;) |
{ |
yyn = yypact[yystate]; |
if (yyn != YYPACT_NINF) |
{ |
yyn += YYTERROR; |
if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) |
{ |
yyn = yytable[yyn]; |
if (0 < yyn) |
break; |
} |
} |
/* Pop the current state because it cannot handle the error token. */ |
if (yyssp == yyss) |
YYABORT; |
yydestruct ("Error: popping", |
yystos[yystate], yyvsp); |
YYPOPSTACK (1); |
yystate = *yyssp; |
YY_STACK_PRINT (yyss, yyssp); |
} |
if (yyn == YYFINAL) |
YYACCEPT; |
*++yyvsp = yylval; |
/* Shift the error token. */ |
YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); |
yystate = yyn; |
goto yynewstate; |
/*-------------------------------------. |
| yyacceptlab -- YYACCEPT comes here. | |
`-------------------------------------*/ |
yyacceptlab: |
yyresult = 0; |
goto yyreturn; |
/*-----------------------------------. |
| yyabortlab -- YYABORT comes here. | |
`-----------------------------------*/ |
yyabortlab: |
yyresult = 1; |
goto yyreturn; |
#ifndef yyoverflow |
/*-------------------------------------------------. |
| yyexhaustedlab -- memory exhaustion comes here. | |
`-------------------------------------------------*/ |
yyexhaustedlab: |
yyerror (YY_("memory exhausted")); |
yyresult = 2; |
/* Fall through. */ |
#endif |
yyreturn: |
if (yychar != YYEOF && yychar != YYEMPTY) |
yydestruct ("Cleanup: discarding lookahead", |
yytoken, &yylval); |
/* Do not reclaim the symbols of the rule which action triggered |
this YYABORT or YYACCEPT. */ |
YYPOPSTACK (yylen); |
YY_STACK_PRINT (yyss, yyssp); |
while (yyssp != yyss) |
{ |
yydestruct ("Cleanup: popping", |
yystos[*yyssp], yyvsp); |
YYPOPSTACK (1); |
} |
#ifndef yyoverflow |
if (yyss != yyssa) |
YYSTACK_FREE (yyss); |
#endif |
#if YYERROR_VERBOSE |
if (yymsg != yymsgbuf) |
YYSTACK_FREE (yymsg); |
#endif |
/* Make sure YYID is used. */ |
return YYID (yyresult); |
} |
#line 195 "arparse.y" |
static int |
yyerror (const char *x ATTRIBUTE_UNUSED) |
{ |
extern int linenumber; |
printf (_("Syntax error in archive script, line %d\n"), linenumber + 1); |
return 0; |
} |
/contrib/toolchain/binutils/binutils/arparse.h |
---|
0,0 → 1,102 |
/* A Bison parser, made by GNU Bison 2.3. */ |
/* Skeleton interface for Bison's Yacc-like parsers in C |
Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 |
Free Software Foundation, Inc. |
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, Inc., 51 Franklin Street, Fifth Floor, |
Boston, MA 02110-1301, USA. */ |
/* As a special exception, you may create a larger work that contains |
part or all of the Bison parser skeleton and distribute that work |
under terms of your choice, so long as that work isn't itself a |
parser generator using the skeleton or a modified version thereof |
as a parser skeleton. Alternatively, if you modify or redistribute |
the parser skeleton itself, you may (at your option) remove this |
special exception, which will cause the skeleton and the resulting |
Bison output files to be licensed under the GNU General Public |
License without this special exception. |
This special exception was added by the Free Software Foundation in |
version 2.2 of Bison. */ |
/* Tokens. */ |
#ifndef YYTOKENTYPE |
# define YYTOKENTYPE |
/* Put the tokens into the symbol table, so that GDB and other debuggers |
know about them. */ |
enum yytokentype { |
NEWLINE = 258, |
VERBOSE = 259, |
FILENAME = 260, |
ADDLIB = 261, |
LIST = 262, |
ADDMOD = 263, |
CLEAR = 264, |
CREATE = 265, |
DELETE = 266, |
DIRECTORY = 267, |
END = 268, |
EXTRACT = 269, |
FULLDIR = 270, |
HELP = 271, |
QUIT = 272, |
REPLACE = 273, |
SAVE = 274, |
OPEN = 275 |
}; |
#endif |
/* Tokens. */ |
#define NEWLINE 258 |
#define VERBOSE 259 |
#define FILENAME 260 |
#define ADDLIB 261 |
#define LIST 262 |
#define ADDMOD 263 |
#define CLEAR 264 |
#define CREATE 265 |
#define DELETE 266 |
#define DIRECTORY 267 |
#define END 268 |
#define EXTRACT 269 |
#define FULLDIR 270 |
#define HELP 271 |
#define QUIT 272 |
#define REPLACE 273 |
#define SAVE 274 |
#define OPEN 275 |
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED |
typedef union YYSTYPE |
#line 38 "arparse.y" |
{ |
char *name; |
struct list *list ; |
} |
/* Line 1529 of yacc.c. */ |
#line 95 "arparse.h" |
YYSTYPE; |
# define yystype YYSTYPE /* obsolescent; will be withdrawn */ |
# define YYSTYPE_IS_DECLARED 1 |
# define YYSTYPE_IS_TRIVIAL 1 |
#endif |
extern YYSTYPE yylval; |
/contrib/toolchain/binutils/binutils/arsup.c |
---|
0,0 → 1,481 |
/* arsup.c - Archive support for MRI compatibility |
Copyright 1992, 1994, 1995, 1996, 1997, 1999, 2000, 2001, 2002, 2003, |
2004, 2005, 2007, 2008 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 3 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., 51 Franklin Street - Fifth Floor, Boston, |
MA 02110-1301, USA. */ |
/* Contributed by Steve Chamberlain |
sac@cygnus.com |
This file looks after requests from arparse.y, to provide the MRI |
style librarian command syntax + 1 word LIST. */ |
#include "sysdep.h" |
#include "bfd.h" |
#include "libiberty.h" |
#include "filenames.h" |
#include "bucomm.h" |
#include "arsup.h" |
static void map_over_list |
(bfd *, void (*function) (bfd *, bfd *), struct list *); |
static void ar_directory_doer (bfd *, bfd *); |
static void ar_addlib_doer (bfd *, bfd *); |
extern int verbose; |
static bfd *obfd; |
static char *real_name; |
static FILE *outfile; |
static void |
map_over_list (bfd *arch, void (*function) (bfd *, bfd *), struct list *list) |
{ |
bfd *head; |
if (list == NULL) |
{ |
bfd *next; |
head = arch->archive_next; |
while (head != NULL) |
{ |
next = head->archive_next; |
function (head, (bfd *) NULL); |
head = next; |
} |
} |
else |
{ |
struct list *ptr; |
/* This may appear to be a baroque way of accomplishing what we |
want. however we have to iterate over the filenames in order |
to notice where a filename is requested but does not exist in |
the archive. Ditto mapping over each file each time -- we |
want to hack multiple references. */ |
for (ptr = list; ptr; ptr = ptr->next) |
{ |
bfd_boolean found = FALSE; |
bfd *prev = arch; |
for (head = arch->archive_next; head; head = head->archive_next) |
{ |
if (head->filename != NULL |
&& FILENAME_CMP (ptr->name, head->filename) == 0) |
{ |
found = TRUE; |
function (head, prev); |
} |
prev = head; |
} |
if (! found) |
fprintf (stderr, _("No entry %s in archive.\n"), ptr->name); |
} |
} |
} |
static void |
ar_directory_doer (bfd *abfd, bfd *ignore ATTRIBUTE_UNUSED) |
{ |
print_arelt_descr(outfile, abfd, verbose); |
} |
void |
ar_directory (char *ar_name, struct list *list, char *output) |
{ |
bfd *arch; |
arch = open_inarch (ar_name, (char *) NULL); |
if (output) |
{ |
outfile = fopen(output,"w"); |
if (outfile == 0) |
{ |
outfile = stdout; |
fprintf (stderr,_("Can't open file %s\n"), output); |
output = 0; |
} |
} |
else |
outfile = stdout; |
map_over_list (arch, ar_directory_doer, list); |
bfd_close (arch); |
if (output) |
fclose (outfile); |
} |
void |
prompt (void) |
{ |
extern int interactive; |
if (interactive) |
{ |
printf ("AR >"); |
fflush (stdout); |
} |
} |
void |
maybequit (void) |
{ |
if (! interactive) |
xexit (9); |
} |
void |
ar_open (char *name, int t) |
{ |
char *tname = (char *) xmalloc (strlen (name) + 10); |
const char *bname = lbasename (name); |
real_name = name; |
/* Prepend tmp- to the beginning, to avoid file-name clashes after |
truncation on filesystems with limited namespaces (DOS). */ |
sprintf (tname, "%.*stmp-%s", (int) (bname - name), name, bname); |
obfd = bfd_openw (tname, NULL); |
if (!obfd) |
{ |
fprintf (stderr, |
_("%s: Can't open output archive %s\n"), |
program_name, tname); |
maybequit (); |
} |
else |
{ |
if (!t) |
{ |
bfd **ptr; |
bfd *element; |
bfd *ibfd; |
ibfd = bfd_openr (name, NULL); |
if (!ibfd) |
{ |
fprintf (stderr,_("%s: Can't open input archive %s\n"), |
program_name, name); |
maybequit (); |
return; |
} |
if (!bfd_check_format(ibfd, bfd_archive)) |
{ |
fprintf (stderr, |
_("%s: file %s is not an archive\n"), |
program_name, name); |
maybequit (); |
return; |
} |
ptr = &(obfd->archive_head); |
element = bfd_openr_next_archived_file (ibfd, NULL); |
while (element) |
{ |
*ptr = element; |
ptr = &element->archive_next; |
element = bfd_openr_next_archived_file (ibfd, element); |
} |
} |
bfd_set_format (obfd, bfd_archive); |
obfd->has_armap = 1; |
obfd->is_thin_archive = 0; |
} |
} |
static void |
ar_addlib_doer (bfd *abfd, bfd *prev) |
{ |
/* Add this module to the output bfd. */ |
if (prev != NULL) |
prev->archive_next = abfd->archive_next; |
abfd->archive_next = obfd->archive_head; |
obfd->archive_head = abfd; |
} |
void |
ar_addlib (char *name, struct list *list) |
{ |
if (obfd == NULL) |
{ |
fprintf (stderr, _("%s: no output archive specified yet\n"), program_name); |
maybequit (); |
} |
else |
{ |
bfd *arch; |
arch = open_inarch (name, (char *) NULL); |
if (arch != NULL) |
map_over_list (arch, ar_addlib_doer, list); |
/* Don't close the bfd, since it will make the elements disappear. */ |
} |
} |
void |
ar_addmod (struct list *list) |
{ |
if (!obfd) |
{ |
fprintf (stderr, _("%s: no open output archive\n"), program_name); |
maybequit (); |
} |
else |
{ |
while (list) |
{ |
bfd *abfd = bfd_openr (list->name, NULL); |
if (!abfd) |
{ |
fprintf (stderr, _("%s: can't open file %s\n"), |
program_name, list->name); |
maybequit (); |
} |
else |
{ |
abfd->archive_next = obfd->archive_head; |
obfd->archive_head = abfd; |
} |
list = list->next; |
} |
} |
} |
void |
ar_clear (void) |
{ |
if (obfd) |
obfd->archive_head = 0; |
} |
void |
ar_delete (struct list *list) |
{ |
if (!obfd) |
{ |
fprintf (stderr, _("%s: no open output archive\n"), program_name); |
maybequit (); |
} |
else |
{ |
while (list) |
{ |
/* Find this name in the archive. */ |
bfd *member = obfd->archive_head; |
bfd **prev = &(obfd->archive_head); |
int found = 0; |
while (member) |
{ |
if (FILENAME_CMP(member->filename, list->name) == 0) |
{ |
*prev = member->archive_next; |
found = 1; |
} |
else |
prev = &(member->archive_next); |
member = member->archive_next; |
} |
if (!found) |
{ |
fprintf (stderr, _("%s: can't find module file %s\n"), |
program_name, list->name); |
maybequit (); |
} |
list = list->next; |
} |
} |
} |
void |
ar_save (void) |
{ |
if (!obfd) |
{ |
fprintf (stderr, _("%s: no open output archive\n"), program_name); |
maybequit (); |
} |
else |
{ |
char *ofilename = xstrdup (bfd_get_filename (obfd)); |
bfd_close (obfd); |
smart_rename (ofilename, real_name, 0); |
obfd = 0; |
free (ofilename); |
} |
} |
void |
ar_replace (struct list *list) |
{ |
if (!obfd) |
{ |
fprintf (stderr, _("%s: no open output archive\n"), program_name); |
maybequit (); |
} |
else |
{ |
while (list) |
{ |
/* Find this name in the archive. */ |
bfd *member = obfd->archive_head; |
bfd **prev = &(obfd->archive_head); |
int found = 0; |
while (member) |
{ |
if (FILENAME_CMP (member->filename, list->name) == 0) |
{ |
/* Found the one to replace. */ |
bfd *abfd = bfd_openr (list->name, 0); |
if (!abfd) |
{ |
fprintf (stderr, _("%s: can't open file %s\n"), |
program_name, list->name); |
maybequit (); |
} |
else |
{ |
*prev = abfd; |
abfd->archive_next = member->archive_next; |
found = 1; |
} |
} |
else |
{ |
prev = &(member->archive_next); |
} |
member = member->archive_next; |
} |
if (!found) |
{ |
bfd *abfd = bfd_openr (list->name, 0); |
fprintf (stderr,_("%s: can't find module file %s\n"), |
program_name, list->name); |
if (!abfd) |
{ |
fprintf (stderr, _("%s: can't open file %s\n"), |
program_name, list->name); |
maybequit (); |
} |
else |
*prev = abfd; |
} |
list = list->next; |
} |
} |
} |
/* And I added this one. */ |
void |
ar_list (void) |
{ |
if (!obfd) |
{ |
fprintf (stderr, _("%s: no open output archive\n"), program_name); |
maybequit (); |
} |
else |
{ |
bfd *abfd; |
outfile = stdout; |
verbose =1 ; |
printf (_("Current open archive is %s\n"), bfd_get_filename (obfd)); |
for (abfd = obfd->archive_head; |
abfd != (bfd *)NULL; |
abfd = abfd->archive_next) |
ar_directory_doer (abfd, (bfd *) NULL); |
} |
} |
void |
ar_end (void) |
{ |
if (obfd) |
{ |
bfd_cache_close (obfd); |
unlink (bfd_get_filename (obfd)); |
} |
} |
void |
ar_extract (struct list *list) |
{ |
if (!obfd) |
{ |
fprintf (stderr, _("%s: no open archive\n"), program_name); |
maybequit (); |
} |
else |
{ |
while (list) |
{ |
/* Find this name in the archive. */ |
bfd *member = obfd->archive_head; |
int found = 0; |
while (member && !found) |
{ |
if (FILENAME_CMP (member->filename, list->name) == 0) |
{ |
extract_file (member); |
found = 1; |
} |
member = member->archive_next; |
} |
if (!found) |
{ |
bfd_openr (list->name, 0); |
fprintf (stderr, _("%s: can't find module file %s\n"), |
program_name, list->name); |
} |
list = list->next; |
} |
} |
} |
/contrib/toolchain/binutils/binutils/arsup.h |
---|
0,0 → 1,63 |
/* arsup.h - archive support header file |
Copyright 1992, 1993, 1994, 1996, 2001, 2002, 2003, 2005, 2007 |
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 3 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., 51 Franklin Street - Fifth Floor, Boston, |
MA 02110-1301, USA. */ |
struct list { |
char *name; |
struct list *next; |
}; |
void maybequit (void); |
void prompt (void); |
void ar_clear (void); |
void ar_replace (struct list *); |
void ar_delete (struct list *); |
void ar_save (void); |
void ar_list (void); |
void ar_open (char *, int); |
void ar_directory (char *, struct list *, char *); |
void ar_addmod (struct list *); |
void ar_addlib (char *, struct list *); |
void ar_end (void); |
void ar_extract (struct list *); |
bfd *open_inarch (const char *archive_filename, const char *); |
extern int yylex (void); |
int yyparse (void); |
/* Functions from ar.c */ |
void extract_file (bfd * abfd); |
extern int interactive; |
/contrib/toolchain/binutils/binutils/binemul.c |
---|
0,0 → 1,149 |
/* Binutils emulation layer. |
Copyright 2002, 2003, 2005, 2007, 2008, 2010 |
Free Software Foundation, Inc. |
Written by Tom Rix, Red Hat 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 3 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., 51 Franklin Street - Fifth Floor, Boston, |
MA 02110-1301, USA. */ |
#include "binemul.h" |
extern bin_emulation_xfer_type bin_dummy_emulation; |
void |
ar_emul_usage (FILE *fp) |
{ |
if (bin_dummy_emulation.ar_usage) |
bin_dummy_emulation.ar_usage (fp); |
} |
void |
ar_emul_default_usage (FILE *fp) |
{ |
AR_EMUL_USAGE_PRINT_OPTION_HEADER (fp); |
/* xgettext:c-format */ |
fprintf (fp, _(" No emulation specific options\n")); |
} |
bfd_boolean |
ar_emul_append (bfd **after_bfd, char *file_name, const char *target, |
bfd_boolean verbose, bfd_boolean flatten) |
{ |
if (bin_dummy_emulation.ar_append) |
return bin_dummy_emulation.ar_append (after_bfd, file_name, target, |
verbose, flatten); |
return FALSE; |
} |
static bfd_boolean |
any_ok (bfd *new_bfd ATTRIBUTE_UNUSED) |
{ |
return TRUE; |
} |
bfd_boolean |
do_ar_emul_append (bfd **after_bfd, bfd *new_bfd, |
bfd_boolean verbose, bfd_boolean flatten, |
bfd_boolean (*check) (bfd *)) |
{ |
/* When flattening, add the members of an archive instead of the |
archive itself. */ |
if (flatten && bfd_check_format (new_bfd, bfd_archive)) |
{ |
bfd *elt; |
bfd_boolean added = FALSE; |
for (elt = bfd_openr_next_archived_file (new_bfd, NULL); |
elt; |
elt = bfd_openr_next_archived_file (new_bfd, elt)) |
{ |
if (do_ar_emul_append (after_bfd, elt, verbose, TRUE, check)) |
{ |
added = TRUE; |
after_bfd = &((*after_bfd)->archive_next); |
} |
} |
return added; |
} |
if (!check (new_bfd)) |
return FALSE; |
AR_EMUL_APPEND_PRINT_VERBOSE (verbose, new_bfd->filename); |
new_bfd->archive_next = *after_bfd; |
*after_bfd = new_bfd; |
return TRUE; |
} |
bfd_boolean |
ar_emul_default_append (bfd **after_bfd, char *file_name, |
const char *target, bfd_boolean verbose, |
bfd_boolean flatten) |
{ |
bfd *new_bfd; |
new_bfd = bfd_openr (file_name, target); |
AR_EMUL_ELEMENT_CHECK (new_bfd, file_name); |
return do_ar_emul_append (after_bfd, new_bfd, verbose, flatten, any_ok); |
} |
bfd_boolean |
ar_emul_replace (bfd **after_bfd, char *file_name, const char *target, |
bfd_boolean verbose) |
{ |
if (bin_dummy_emulation.ar_replace) |
return bin_dummy_emulation.ar_replace (after_bfd, file_name, |
target, verbose); |
return FALSE; |
} |
bfd_boolean |
ar_emul_default_replace (bfd **after_bfd, char *file_name, |
const char *target, bfd_boolean verbose) |
{ |
bfd *new_bfd; |
new_bfd = bfd_openr (file_name, target); |
AR_EMUL_ELEMENT_CHECK (new_bfd, file_name); |
AR_EMUL_REPLACE_PRINT_VERBOSE (verbose, file_name); |
new_bfd->archive_next = *after_bfd; |
*after_bfd = new_bfd; |
return TRUE; |
} |
bfd_boolean |
ar_emul_parse_arg (char *arg) |
{ |
if (bin_dummy_emulation.ar_parse_arg) |
return bin_dummy_emulation.ar_parse_arg (arg); |
return FALSE; |
} |
bfd_boolean |
ar_emul_default_parse_arg (char *arg ATTRIBUTE_UNUSED) |
{ |
return FALSE; |
} |
/contrib/toolchain/binutils/binutils/binemul.h |
---|
0,0 → 1,71 |
/* Binutils emulation layer. |
Copyright 2002, 2003, 2005, 2007, 2008 Free Software Foundation, Inc. |
Written by Tom Rix, Red Hat 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 3 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., 51 Franklin Street - Fifth Floor, Boston, |
MA 02110-1301, USA. */ |
#ifndef BINEMUL_H |
#define BINEMUL_H |
#include "sysdep.h" |
#include "bfd.h" |
#include "bucomm.h" |
extern void ar_emul_usage (FILE *); |
extern void ar_emul_default_usage (FILE *); |
extern bfd_boolean ar_emul_append (bfd **, char *, const char *, |
bfd_boolean, bfd_boolean); |
extern bfd_boolean ar_emul_default_append (bfd **, char *, const char *, |
bfd_boolean, bfd_boolean); |
extern bfd_boolean do_ar_emul_append (bfd **, bfd *, |
bfd_boolean, bfd_boolean, |
bfd_boolean (*)(bfd *)); |
extern bfd_boolean ar_emul_replace (bfd **, char *, const char *, |
bfd_boolean); |
extern bfd_boolean ar_emul_default_replace (bfd **, char *, |
const char *, bfd_boolean); |
extern bfd_boolean ar_emul_parse_arg (char *); |
extern bfd_boolean ar_emul_default_parse_arg (char *); |
/* Macros for common output. */ |
#define AR_EMUL_USAGE_PRINT_OPTION_HEADER(fp) \ |
/* xgettext:c-format */ \ |
fprintf (fp, _(" emulation options: \n")) |
#define AR_EMUL_ELEMENT_CHECK(abfd, file_name) \ |
do { if ((abfd) == NULL) bfd_fatal (file_name); } while (0) |
#define AR_EMUL_APPEND_PRINT_VERBOSE(verbose, file_name) \ |
do { if (verbose) printf ("a - %s\n", file_name); } while (0) |
#define AR_EMUL_REPLACE_PRINT_VERBOSE(verbose, file_name) \ |
do { if (verbose) printf ("r - %s\n", file_name); } while (0) |
typedef struct bin_emulation_xfer_struct |
{ |
/* Print out the extra options. */ |
void (* ar_usage) (FILE *fp); |
bfd_boolean (* ar_append) (bfd **, char *, const char *, bfd_boolean, |
bfd_boolean); |
bfd_boolean (* ar_replace) (bfd **, char *, const char *, bfd_boolean); |
bfd_boolean (* ar_parse_arg) (char *); |
} |
bin_emulation_xfer_type; |
#endif |
/contrib/toolchain/binutils/binutils/emul_vanilla.c |
---|
0,0 → 1,30 |
/* Binutils emulation layer. |
Copyright (C) 2002, 2005, 2007 Free Software Foundation, Inc. |
Written by Tom Rix, Red Hat 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 3 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., 51 Franklin Street - Fifth Floor, Boston, |
MA 02110-1301, USA. */ |
#include "binemul.h" |
struct bin_emulation_xfer_struct bin_vanilla_emulation = |
{ |
ar_emul_default_usage, |
ar_emul_default_append, |
ar_emul_default_replace, |
ar_emul_default_parse_arg, |
}; |
/contrib/toolchain/binutils/binutils/not-ranlib.c |
---|
0,0 → 1,22 |
/* Copyright 2007 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 3 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., 51 Franklin Street - Fifth Floor, Boston, MA |
02110-1301, USA. */ |
/* Linked with ar.o to flag that this program is 'ar' (not 'ranlib'). */ |
int is_ranlib = 0; |