OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

Compare Revisions

  • This comparison shows the changes necessary to convert path 
    /openrisc/trunk
    from Rev 339 to Rev 342
    ↔ Reverse comparison
  •

Rev 339 → Rev 342

/gnu-src/gdb-7.2/bfd/doc/bfd.info
1,4 → 1,4
This is bfd.info, produced by makeinfo version 4.8 from bfd.texinfo.
This is bfd.info, produced by makeinfo version 4.13 from bfd.texinfo.
 
START-INFO-DIR-ENTRY
* Bfd: (bfd). The Binary File Descriptor library.
7537,9 → 7537,9
each object file or archive which is to be linked (typically these are
the files named on the command line, but some may also come from the
linker script). The entry point is responsible for examining the file.
For an object file, BFD must add any relevant symbol information to
the hash table. For an archive, BFD must determine which elements of
the archive should be used and adding them to the link.
For an object file, BFD must add any relevant symbol information to the
hash table. For an archive, BFD must determine which elements of the
archive should be used and adding them to the link.
 
The a.out version of this entry point is
`NAME(aout,link_add_symbols)'.
11415,67 → 11415,67
 

Tag Table:
Node: Top1051
Node: Overview1390
Node: History2441
Node: How It Works3387
Node: What BFD Version 2 Can Do4930
Node: BFD information loss6245
Node: Canonical format8777
Node: BFD front end13149
Node: Memory Usage44685
Node: Initialization45913
Node: Sections46372
Node: Section Input46855
Node: Section Output48220
Node: typedef asection50706
Node: section prototypes75715
Node: Symbols85395
Node: Reading Symbols86990
Node: Writing Symbols88097
Node: Mini Symbols89806
Node: typedef asymbol90780
Node: symbol handling functions96839
Node: Archives102181
Node: Formats105907
Node: Relocations108855
Node: typedef arelent109582
Node: howto manager125218
Node: Core Files200290
Node: Targets202107
Node: bfd_target204077
Node: Architectures226393
Node: Opening and Closing249683
Node: Internal261021
Node: File Caching267354
Node: Linker Functions269268
Node: Creating a Linker Hash Table270941
Node: Adding Symbols to the Hash Table272679
Node: Differing file formats273579
Node: Adding symbols from an object file275304
Node: Adding symbols from an archive277455
Node: Performing the Final Link279869
Node: Information provided by the linker281111
Node: Relocating the section contents282265
Node: Writing the symbol table284016
Node: Hash Tables288031
Node: Creating and Freeing a Hash Table289229
Node: Looking Up or Entering a String290479
Node: Traversing a Hash Table291732
Node: Deriving a New Hash Table Type292521
Node: Define the Derived Structures293587
Node: Write the Derived Creation Routine294668
Node: Write Other Derived Routines297292
Node: BFD back ends298607
Node: What to Put Where298877
Node: aout299057
Node: coff305375
Node: elf333808
Node: mmo334209
Node: File layout335137
Node: Symbol-table340784
Node: mmo section mapping344553
Node: GNU Free Documentation License348205
Node: BFD Index373288
Node: Top1052
Node: Overview1391
Node: History2442
Node: How It Works3388
Node: What BFD Version 2 Can Do4931
Node: BFD information loss6246
Node: Canonical format8778
Node: BFD front end13150
Node: Memory Usage44686
Node: Initialization45914
Node: Sections46373
Node: Section Input46856
Node: Section Output48221
Node: typedef asection50707
Node: section prototypes75716
Node: Symbols85396
Node: Reading Symbols86991
Node: Writing Symbols88098
Node: Mini Symbols89807
Node: typedef asymbol90781
Node: symbol handling functions96840
Node: Archives102182
Node: Formats105908
Node: Relocations108856
Node: typedef arelent109583
Node: howto manager125219
Node: Core Files200291
Node: Targets202108
Node: bfd_target204078
Node: Architectures226394
Node: Opening and Closing249684
Node: Internal261022
Node: File Caching267355
Node: Linker Functions269269
Node: Creating a Linker Hash Table270942
Node: Adding Symbols to the Hash Table272680
Node: Differing file formats273580
Node: Adding symbols from an object file275305
Node: Adding symbols from an archive277456
Node: Performing the Final Link279870
Node: Information provided by the linker281112
Node: Relocating the section contents282266
Node: Writing the symbol table284017
Node: Hash Tables288032
Node: Creating and Freeing a Hash Table289230
Node: Looking Up or Entering a String290480
Node: Traversing a Hash Table291733
Node: Deriving a New Hash Table Type292522
Node: Define the Derived Structures293588
Node: Write the Derived Creation Routine294669
Node: Write Other Derived Routines297293
Node: BFD back ends298608
Node: What to Put Where298878
Node: aout299058
Node: coff305376
Node: elf333809
Node: mmo334210
Node: File layout335138
Node: Symbol-table340785
Node: mmo section mapping344554
Node: GNU Free Documentation License348206
Node: BFD Index373289

End Tag Table
/gnu-src/gdb-7.2/gdb/doc/gdb.info-1
1,4 → 1,4
This is gdb.info, produced by makeinfo version 4.8 from ./gdb.texinfo.
This is gdb.info, produced by makeinfo version 4.13 from ./gdb.texinfo.
 
INFO-DIR-SECTION Software development
START-INFO-DIR-ENTRY
23,7 → 23,7
This file documents the GNU debugger GDB.
 
This is the Ninth Edition, of `Debugging with GDB: the GNU
Source-Level Debugger' for GDB (GDB) Version 7.2.
Source-Level Debugger' for GDB (GDB) Version 7.2-or32-1.0rc1.
 
Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
48,7 → 48,7
 
This file describes GDB, the GNU symbolic debugger.
 
This is the Ninth Edition, for GDB (GDB) Version 7.2.
This is the Ninth Edition, for GDB (GDB) Version 7.2-or32-1.0rc1.
 
Copyright (C) 1988-2010 Free Software Foundation, Inc.
 
135,13 → 135,13
correcting the effects of one bug and go on to learn about another.
 
You can use GDB to debug programs written in C and C++. For more
information, see *Note Supported Languages: Supported Languages. For
more information, see *Note C and C++: C.
information, see *note Supported Languages: Supported Languages. For
more information, see *note C and C++: C.
 
Support for D is partial. For information on D, see *Note D: D.
Support for D is partial. For information on D, see *note D: D.
 
Support for Modula-2 is partial. For information on Modula-2, see
*Note Modula-2: Modula-2.
*note Modula-2: Modula-2.
 
Debugging Pascal programs which use sets, subranges, file variables,
or nested functions does not currently work. GDB does not support
437,6 → 437,10
Michael Eager and staff of Xilinx, Inc., contributed support for the
Xilinx MicroBlaze architecture.
 
The original port to the OpenRISC 1000 is believed to be due to
Alessandro Forin and Per Bothner. More recent ports have been the work
of Jeremy Bennett.
 

File: gdb.info, Node: Sample Session, Next: Invocation, Prev: Summary, Up: Top
 
483,7 → 487,7
There is absolutely no warranty for GDB; type "show warranty"
for details.
 
GDB 7.2, Copyright 1999 Free Software Foundation, Inc...
GDB 7.2-or32-1.0rc1, Copyright 1999 Free Software Foundation, Inc...
(gdb)
 
GDB reads only enough symbol data to know where to find the rest when
1160,7 → 1164,7
previous command. Certain commands (for example, `run') will not
repeat this way; these are commands whose unintentional repetition
might cause trouble and which you are unlikely to want to repeat.
User-defined commands can disable this feature; see *Note dont-repeat:
User-defined commands can disable this feature; see *note dont-repeat:
Define.
 
The `list' and `x' commands, when you repeat them with <RET>,
1273,9 → 1277,9
have not yet started typing the argument list when you ask for
completion on an overloaded symbol.
 
For more information about overloaded functions, see *Note C++
For more information about overloaded functions, see *note C++
Expressions: C Plus Plus Expressions. You can use the command `set
overload-resolution off' to disable overload resolution; see *Note GDB
overload-resolution off' to disable overload resolution; see *note GDB
Features for C++: Debugging C Plus Plus.
 
When completing in an expression which looks up a field in a
1511,7 → 1515,7
making it possible to debug optimized code. We recommend that you
_always_ use `-g' whenever you compile a program. You may think your
program is correct, but there is no sense in pushing your luck. For
more information, see *Note Optimized Code::.
more information, see *note Optimized Code::.
 
Older versions of the GNU C compiler permitted a variant option
`-gg' for debugging information. GDB no longer supports this format;
1633,11 → 1637,11
`start' or `run'.
 
It is sometimes necessary to debug the program during elaboration.
In these cases, using the `start' command would stop the
execution of your program too late, as the program would have
already completed the elaboration phase. Under these
circumstances, insert breakpoints in your elaboration code before
running your program.
In these cases, using the `start' command would stop the execution
of your program too late, as the program would have already
completed the elaboration phase. Under these circumstances,
insert breakpoints in your elaboration code before running your
program.
 
`set exec-wrapper WRAPPER'
`show exec-wrapper'
2694,7 → 2698,7
different command to set a catchpoint (*note Setting Catchpoints: Set
Catchpoints.), but aside from that, you can manage a catchpoint like any
other breakpoint. (To stop when your program receives a signal, use the
`handle' command; see *Note Signals: Signals.)
`handle' command; see *note Signals: Signals.)
 
GDB assigns a number to each breakpoint, watchpoint, or catchpoint
when you create it; these numbers are successive integers starting with
2730,7 → 2734,7
 
Breakpoints are set with the `break' command (abbreviated `b'). The
debugger convenience variable `$bpnum' records the number of the
breakpoint you've set most recently; see *Note Convenience Variables:
breakpoint you've set most recently; see *note Convenience Variables:
Convenience Vars, for a discussion of what you can do with convenience
variables.
 
2801,7 → 2805,7
unused hardware breakpoints before setting new ones (*note
Disabling Breakpoints: Disabling.). *Note Break Conditions:
Conditions. For remote targets, you can restrict the number of
hardware breakpoints GDB will use, see *Note set remote
hardware breakpoints GDB will use, see *note set remote
hardware-breakpoint-limit::.
 
`thbreak ARGS'
2812,7 → 2816,7
program stops there. Also, like the `hbreak' command, the
breakpoint requires hardware support and some target hardware may
not have this support. *Note Disabling Breakpoints: Disabling.
See also *Note Break Conditions: Conditions.
See also *note Break Conditions: Conditions.
 
`rbreak REGEX'
Set breakpoints on all functions matching the regular expression
2872,10 → 2876,10
 
_Address_
Where the breakpoint is in your program, as a memory address.
For a pending breakpoint whose address is not yet known,
this field will contain `<PENDING>'. Such breakpoint won't
fire until a shared library that has the symbol or line
referred by breakpoint is loaded. See below for details. A
For a pending breakpoint whose address is not yet known, this
field will contain `<PENDING>'. Such breakpoint won't fire
until a shared library that has the symbol or line referred
by breakpoint is loaded. See below for details. A
breakpoint with several locations will have `<MULTIPLE>' in
this field--see below for details.
 
3167,7 → 3171,7
Show the current mode of using hardware watchpoints.
 
For remote targets, you can restrict the number of hardware
watchpoints GDB will use, see *Note set remote
watchpoints GDB will use, see *note set remote
hardware-breakpoint-limit::.
 
When you issue the `watch' command, GDB reports
3575,7 → 3579,7
enabled; subsequently, they become disabled or enabled only when you
use one of the commands above. (The command `until' can set and delete
a breakpoint of its own, but it does not change the state of your other
breakpoints; see *Note Continuing and Stepping: Continuing and
breakpoints; see *note Continuing and Stepping: Continuing and
Stepping.)
 

4016,7 → 4020,7
`u LOCATION'
Continue running your program until either the specified location
is reached, or the current stack frame returns. LOCATION is any of
the forms described in *Note Specify Location::. This form of the
the forms described in *note Specify Location::. This form of the
command uses temporary breakpoints, and hence is quicker than
`until' without an argument. The specified location is actually
reached only if it is in the current frame. This implies that
4037,7 → 4041,7
`advance LOCATION'
Continue running the program up to the given LOCATION. An
argument is required, which should be of one of the forms
described in *Note Specify Location::. Execution will also stop
described in *note Specify Location::. Execution will also stop
upon exit from the current stack frame. This command is similar
to `until', but `advance' will not skip over recursive function
calls, and the target location doesn't have to be in the same
4303,8 → 4307,8
resumed when an execution command is issued. When `on', all
threads of all processes are allowed to run. When `off', only the
threads of the current process are resumed. The default is `off'.
The `scheduler-locking' mode takes precedence when set to `on',
or while you are stepping and set to `step'.
The `scheduler-locking' mode takes precedence when set to `on', or
while you are stepping and set to `step'.
 
`show schedule-multiple'
Display the current mode for resuming the execution of threads of
4453,7 → 4457,7
 
 
Background execution is especially useful in conjunction with
non-stop mode for debugging programs with multiple threads; see *Note
non-stop mode for debugging programs with multiple threads; see *note
Non-Stop Mode::. However, you can also use these commands in the
normal all-stop mode with the restriction that you cannot issue another
execution command until the previous one finishes. Examples of
5066,7 → 5070,7
The value of parameter `data' in frame 1 has been replaced by `...'.
By default, GDB prints the value of a parameter only if it is a scalar
(integer, pointer, enumeration, etc). See command `set print
frame-arguments' in *Note Print Settings:: for more details on how to
frame-arguments' in *note Print Settings:: for more details on how to
configure the way function parameter values are printed.
 
If your program was compiled with optimizations, some compilers will
5293,7 → 5297,7
source files by explicit command.
 
If you use GDB through its GNU Emacs interface, you may prefer to
use Emacs facilities to view source; see *Note Using GDB under GNU
use Emacs facilities to view source; see *note Using GDB under GNU
Emacs: Emacs.
 
* Menu:
5313,7 → 5317,7
 
To print lines from a source file, use the `list' command (abbreviated
`l'). By default, ten lines are printed. There are several ways to
specify what part of the file you want to print; see *Note Specify
specify what part of the file you want to print; see *note Specify
Location::, for the full list.
 
Here are the forms of the `list' command most commonly used:
5582,7 → 5586,7
debug information in case the sources were moved to a different
directory between compilation and debugging. A rule is made of two
strings, the first specifying what needs to be rewritten in the path,
and the second specifying how it should be rewritten. In *Note set
and the second specifying how it should be rewritten. In *note set
substitute-path::, we name these two parts FROM and TO respectively.
GDB does a simple string replacement of FROM with TO at the start of
the directory part of the source file name, and uses that result
5726,7 → 5730,7
`info line LINESPEC'
Print the starting and ending addresses of the compiled code for
source line LINESPEC. You can specify source lines in any of the
ways documented in *Note Specify Location::.
ways documented in *note Specify Location::.
 
For example, we can use `info line' to discover the location of the
object code for the first line of function `m4_changequote':
5883,7 → 5887,7
EXPR is an expression (in the source language). By default the
value of EXPR is printed in a format appropriate to its data type;
you can choose a different format by specifying `/F', where F is a
letter specifying the format; see *Note Output Formats: Output
letter specifying the format; see *note Output Formats: Output
Formats.
 
`print'
5937,7 → 5941,7
programming language you are using is valid in an expression in GDB.
This includes conditional expressions, function calls, casts, and
string constants. It also includes preprocessor macros, if you
compiled your program to include this information; see *Note
compiled your program to include this information; see *note
Compilation::.
 
GDB supports array constants in expressions input by the user. The
6314,7 → 6318,7
---------- Footnotes ----------
 
(1) `b' cannot be used because these format letters are also used
with the `x' command, where `b' stands for "byte"; see *Note Examining
with the `x' command, where `b' stands for "byte"; see *note Examining
Memory: Memory.
 

6405,7 → 6409,7
`i' format also prints branch delay slot instructions, if any, beyond
the count specified, which immediately follow the last instruction that
is within the count. The command `disassemble' gives an alternative
way of inspecting machine instructions; see *Note Source and Machine
way of inspecting machine instructions; see *note Source and Machine
Code: Machine Code.
 
All the defaults for the arguments to `x' are designed to make it
/gnu-src/gdb-7.2/gdb/doc/gdb.info-2
1,4 → 1,4
This is gdb.info, produced by makeinfo version 4.8 from ./gdb.texinfo.
This is gdb.info, produced by makeinfo version 4.13 from ./gdb.texinfo.
 
INFO-DIR-SECTION Software development
START-INFO-DIR-ENTRY
23,7 → 23,7
This file documents the GNU debugger GDB.
 
This is the Ninth Edition, of `Debugging with GDB: the GNU
Source-Level Debugger' for GDB (GDB) Version 7.2.
Source-Level Debugger' for GDB (GDB) Version 7.2-or32-1.0rc1.
 
Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
153,7 → 153,7
assumes that the innermost stack frame is selected; setting `$sp' is
not allowed when other stack frames are selected. To pop entire frames
off the stack, regardless of machine architecture, use `return'; see
*Note Returning from a Function: Returning.
*note Returning from a Function: Returning.
 

File: gdb.info, Node: Floating Point Hardware, Next: Vector Unit, Prev: Registers, Up: Data
213,7 → 213,7
system-specific. Depending on the configuration and operating system
facilities, GDB may be able to show you this information. For remote
targets, this functionality may further depend on the remote stub's
support of the `qXfer:auxv:read' packet, see *Note qXfer auxiliary
support of the `qXfer:auxv:read' packet, see *note qXfer auxiliary
vector read::.
 
`info auxv'
228,7 → 228,7
On some targets, GDB can access operating-system-specific information
and display it to user, without interpretation. For remote targets,
this functionality depends on the remote stub's support of the
`qXfer:osdata:read' packet, see *Note qXfer osdata read::.
`qXfer:osdata:read' packet, see *note qXfer osdata read::.
 
`info os'
List the types of OS information available for the target. If the
751,9 → 751,8
all finds.
 
You can use strings as search values. Quote them with double-quotes
(`"'). The string value is copied into the search pattern byte by
byte, regardless of the endianness of the target and the size
specification.
(`"'). The string value is copied into the search pattern byte by byte,
regardless of the endianness of the target and the size specification.
 
The address of each match found is printed as well as a count of the
number of matches found.
912,7 → 911,7
definitions, or have no definition at all. If there is a current stack
frame, GDB uses the macros in scope at that frame's source code line.
Otherwise, GDB uses the macros in scope at the current listing location;
see *Note List::.
see *note List::.
 
Whenever GDB evaluates an expression, it always expands any macro
invocations present in the expression. GDB also provides the following
1122,7 → 1121,7
how to collect trace data. This functionality is implemented in the
remote stub; however, none of the stubs distributed with GDB support
tracepoints as of this writing. The format of the remote packets used
to implement tracepoints are described in *Note Tracepoint Packets::.
to implement tracepoints are described in *note Tracepoint Packets::.
 
It is also possible to get trace data from a file, in a manner
reminiscent of corefiles; you specify the filename, and use `tfind' to
2224,7 → 2223,7
be relocated and its symbols defined as if the overlay were at its
mapped address. You can use GNU linker scripts to specify
different load and relocation addresses for pieces of your
program; see *Note Overlay Description: (ld.info)Overlay
program; see *note Overlay Description: (ld.info)Overlay
Description.
 
* The procedure for loading executable files onto your system must
2301,7 → 2300,7
`overlay auto'
Enable "automatic" overlay debugging. In this mode, GDB consults
a data structure the overlay manager maintains in the inferior to
see which overlays are mapped. For details, see *Note Automatic
see which overlays are mapped. For details, see *note Automatic
Overlay Debugging::.
 
`overlay load-target'
3117,7 → 3116,7
explicit function signature to call an overloaded function, as in
p 'foo(char,int)'('x', 13)
 
The GDB command-completion facility can simplify this; see *Note
The GDB command-completion facility can simplify this; see *note
Command Completion: Completion.
 
4. GDB understands variables declared as C++ references; you can use
3247,7 → 3246,7
Enable overload resolution for C++ expression evaluation. The
default is on. For overloaded functions, GDB evaluates the
arguments and searches for a function whose signature matches the
argument types, using the standard C++ conversion rules (see *Note
argument types, using the standard C++ conversion rules (see *note
C++ Expressions: C Plus Plus Expressions, for details). If it
cannot find a match, it emits a message.
 
3298,7 → 3297,7
 
In the PowerPC architecture, GDB provides a set of pseudo-registers
to inspect `_Decimal128' values stored in floating point registers.
See *Note PowerPC: PowerPC. for more details.
See *note PowerPC: PowerPC. for more details.
 

File: gdb.info, Node: D, Next: Objective-C, Prev: C, Up: Supported Languages
3317,8 → 3316,8
------------------
 
This section provides information about some commands and command
options that are useful for debugging Objective-C code. See also *Note
info classes: Symbols, and *Note info selectors: Symbols, for a few
options that are useful for debugging Objective-C code. See also *note
info classes: Symbols, and *note info selectors: Symbols, for a few
more commands specific to Objective-C support.
 
* Menu:
3451,7 → 3450,7
 
Fortran symbols are usually case-insensitive, so GDB by default uses
case-insensitive matches for Fortran symbols. You can change that with
the `set case-insensitive' command, see *Note Symbols::, for the
the `set case-insensitive' command, see *note Symbols::, for the
details.
 

4423,7 → 4422,7
`break LINESPEC task TASKNO if ...'
These commands are like the `break ... thread ...' command (*note
Thread Stops::). LINESPEC specifies source lines, as described in
*Note Specify Location::.
*note Specify Location::.
 
Use the qualifier `task TASKNO' with a breakpoint command to
specify that you only want GDB to stop the program when a
4718,7 → 4717,7
Symbol repeat is a local variable at frame offset -8, length 4.
 
This command is especially useful for determining what data to
collect during a "trace experiment", see *Note collect: Tracepoint
collect during a "trace experiment", see *note collect: Tracepoint
Actions.
 
`info source'
5009,8 → 5008,8
`jump LOCATION'
Resume execution at line LINESPEC or at address given by LOCATION.
Execution stops again immediately if there is a breakpoint there.
*Note Specify Location::, for a description of the different
forms of LINESPEC and LOCATION. It is common practice to use the
*Note Specify Location::, for a description of the different forms
of LINESPEC and LOCATION. It is common practice to use the
`tbreak' command in conjunction with `jump'. *Note Setting
Breakpoints: Set Breaks.
 
5789,7 → 5788,7
supported only on some operating systems, notably those which use
the ELF format for binary files and the GNU Binutils.) For more
details about this feature, see the description of the `--build-id'
command-line option in *Note Command Line Options:
command-line option in *note Command Line Options:
(ld.info)Options. The debug info file's name is not specified
explicitly by the build ID, but can be computed from the build ID,
see below.
6253,7 → 6252,7
device drivers, or even basic I/O is available, although some
simulators do provide these. For info about any
processor-specific simulator details, see the appropriate section
in *Note Embedded Processors: Embedded Processors.
in *note Embedded Processors: Embedded Processors.
 
 
Some configurations may include these targets as well:
6608,8 → 6607,8
running. The `run' and `attach' commands instruct `gdbserver' to run
or attach to a new program. The `run' command uses `set remote
exec-file' (*note set remote exec-file::) to select the program to run.
Command line arguments are supported, except for wildcard expansion
and I/O redirection (*note Arguments::).
Command line arguments are supported, except for wildcard expansion and
I/O redirection (*note Arguments::).
 
To start `gdbserver' without supplying an initial command to run or
process ID to attach, use the `--multi' command line option. Then you
6792,7 → 6791,7
 
This section documents the configuration options available when
debugging remote programs. For the options related to the File I/O
extensions of the remote protocol, see *Note system-call-allowed:
extensions of the remote protocol, see *note system-call-allowed:
system.
 
`set remoteaddresssize BITS'
6922,7 → 6921,7
can be set to `on' (the remote target supports this packet), `off' (the
remote target does not support this packet), or `auto' (detect remote
target support for this packet). They all default to `auto'. For more
information about each packet, see *Note Remote Protocol::.
information about each packet, see *note Remote Protocol::.
 
During normal use, you should not have to use any of these commands.
If you do, that may be a bug in your remote debugging stub, or a bug in
/gnu-src/gdb-7.2/gdb/doc/gdb.info-3
1,4 → 1,4
This is gdb.info, produced by makeinfo version 4.8 from ./gdb.texinfo.
This is gdb.info, produced by makeinfo version 4.13 from ./gdb.texinfo.
 
INFO-DIR-SECTION Software development
START-INFO-DIR-ENTRY
23,7 → 23,7
This file documents the GNU debugger GDB.
 
This is the Ninth Edition, of `Debugging with GDB: the GNU
Source-Level Debugger' for GDB (GDB) Version 7.2.
Source-Level Debugger' for GDB (GDB) Version 7.2-or32-1.0rc1.
 
Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
204,7 → 204,7
 
There are various additional Cygwin-specific commands, described in
this section. Working with DLLs that have no debugging symbols is
described in *Note Non-debug DLL Symbols::.
described in *note Non-debug DLL Symbols::.
 
`info w32'
This is a prefix of MS Windows-specific commands which print
307,8 → 307,8
start the program -- either by setting a breakpoint or letting the
program run once to completion. It is also possible to force GDB to
load a particular DLL before starting the executable -- see the shared
library information in *Note Files::, or the `dll-symbols' command in
*Note Cygwin Native::. Currently, explicitly loading symbols from a
library information in *note Files::, or the `dll-symbols' command in
*note Cygwin Native::. Currently, explicitly loading symbols from a
DLL with no debugging information will cause the symbol names to be
duplicated in GDB's lookup table, which may adversely affect symbol
lookup performance.
1167,33 → 1167,48
21.3.6 OpenRISC 1000
--------------------
 
See OR1k Architecture document (`www.opencores.org') for more
information about platform and commands.
Previous versions of GDB supported remote connection via a proprietary
JTAG protocol using the `target jtag' command. Support for this has now
been dropped.
 
`target jtag jtag://HOST:PORT'
Connects to remote JTAG server. JTAG remote server can be either
an or1ksim or JTAG server, connected via parallel port to the
board.
`target remote'
This is now the only way to connect to a remote OpenRISC 1000
target. This is supported by "Or1ksim", the OpenRISC 1000
architectural simulator, and Verilator and Icarus Verilog
simulations. "Remote serial protocol" servers are also available
to drive various hardware implementations via JTAG. Connects to
remote JTAG server.
 
Example: `target jtag jtag://localhost:9999'
Example: `target remote :51000'
 
`or1ksim COMMAND'
If connected to `or1ksim' OpenRISC 1000 Architectural Simulator,
proprietary commands can be executed.
`target sim'
"Or1ksim", the OpenRISC 1000 architectural simulator is now
incorporated within GDB as a simulator target. It is started in
quiet mode with 8M of memory starting at address 0. It is possible
to pass arguments to extend this configuration using the `-f'
option to `target sim'. However for more complex use, the user is
advised to run "Or1ksim" separately, with its own configuration
file, and connect using `target remote'
 
Example: `target sim'
 
`info or1k spr'
Displays spr groups.
Displays groups.
 
`info or1k spr GROUP'
`info or1k spr GROUPNO'
`info spr GROUP'
`info spr GROUPNO'
Displays register names in selected group.
 
`info or1k spr GROUP REGISTER'
`info or1k spr REGISTER'
`info or1k spr GROUPNO REGISTERNO'
`info or1k spr REGISTERNO'
`info spr GROUP REGISTER'
`info spr REGISTER'
`info spr GROUPNO REGISTERNO'
`info spr REGISTERNO'
Shows information about specified spr register.
 
Example: `info spr DRR'
 
`DEBUG.DRR = SPR6_21 = 0 (0x0)'
 
`spr GROUP REGISTER VALUE'
`spr REGISTER VALUE'
`spr GROUPNO REGISTERNO VALUE'
1200,72 → 1215,32
`spr REGISTERNO VALUE'
Writes VALUE to specified spr register.
 
Some implementations of OpenRISC 1000 Architecture also have
hardware trace. It is very similar to GDB trace, except it does not
interfere with normal program execution and is thus much faster.
Hardware breakpoints/watchpoint triggers can be set using:
`$LEA/$LDATA'
Load effective address/data
Example: spr PICMR 0x24
 
`$SEA/$SDATA'
Store effective address/data
The use of `info' and `spr' commands is anachronistic. At some time
in the future they will be replaced by `show spr' and `set spr'.
 
`$AEA/$ADATA'
Access effective address ($SEA or $LEA) or data ($SDATA/$LDATA)
There are some known problems with the current implementation
 
`$FETCH'
Fetch data
1. Some OpenRISC 1000 targets support hardware breakpoints and
watchpoints. Consult the target documentation for details. GDB
is not perfect in handling of watchpoints. It is possible to
allocate hardware watchpoints and not discover until running that
sufficient watchpoints are not available. It is also possible
that GDB will report watchpoints being hit spuriously. This can
be down to the assembly code having additional memory accesses
that are not obviously reflected in the source code.
 
When triggered, it can capture low level data, like: `PC', `LSEA',
`LDATA', `SDATA', `READSPR', `WRITESPR', `INSTR'.
2. The OpenRISC 1000 architecture has evolved since the first port of
GDB. In particular the structure of the Unit Present register has
changed and the CPU Configuration register has been added. The
port of GDB version 7.2-or32-1.0rc1 uses the _current_
specification of the OpenRISC 1000.
 
`htrace' commands:
`hwatch CONDITIONAL'
Set hardware watchpoint on combination of Load/Store Effective
Address(es) or Data. For example:
 
`hwatch ($LEA == my_var) && ($LDATA < 50) || ($SEA == my_var) &&
($SDATA >= 50)'
Reports of bugs are much welcomed. Please report problems through the
OpenRISC tracker at downloads (http://opencores.org/openrisc).
 
`hwatch ($LEA == my_var) && ($LDATA < 50) || ($SEA == my_var) &&
($SDATA >= 50)'
 
`htrace info'
Display information about current HW trace configuration.
 
`htrace trigger CONDITIONAL'
Set starting criteria for HW trace.
 
`htrace qualifier CONDITIONAL'
Set acquisition qualifier for HW trace.
 
`htrace stop CONDITIONAL'
Set HW trace stopping criteria.
 
`htrace record [DATA]*'
Selects the data to be recorded, when qualifier is met and HW
trace was triggered.
 
`htrace enable'
`htrace disable'
Enables/disables the HW trace.
 
`htrace rewind [FILENAME]'
Clears currently recorded trace data.
 
If filename is specified, new trace file is made and any newly
collected data will be written there.
 
`htrace print [START [LEN]]'
Prints trace buffer, using current record configuration.
 
`htrace mode continuous'
Set continuous trace mode.
 
`htrace mode suspend'
Set suspend trace mode.
 
 

File: gdb.info, Node: PowerPC Embedded, Next: Sparclet, Prev: PA, Up: Embedded Processors
 
1815,8 → 1790,8
Set whether to automatically flush the software-managed cache.
When set to `on', GDB will automatically cause the SPE
software-managed cache to be flushed whenever SPE execution stops.
This provides a consistent view of PowerPC memory that is
accessed via the cache. If an application does not use the
This provides a consistent view of PowerPC memory that is accessed
via the cache. If an application does not use the
software-managed cache, this option has no effect.
 
`show spu auto-flush-cache'
1849,7 → 1824,7
******************
 
You can alter the way GDB interacts with you by using the `set'
command. For commands controlling how GDB displays data, see *Note
command. For commands controlling how GDB displays data, see *note
Print Settings: Print Settings. Other settings are described here.
 
* Menu:
2184,7 → 2159,7
 
Currently, the messages controlled by `set verbose' are those which
announce that the symbol table for a source file is being read; see
`symbol-file' in *Note Commands to Specify Files: Files.
`symbol-file' in *note Commands to Specify Files: Files.
 
`set verbose on'
Enables GDB output of certain informational messages.
2591,7 → 2566,7
infinite recursion and aborts the command.
 
In addition to the above commands, user-defined commands frequently
use control flow commands, described in *Note Command Files::.
use control flow commands, described in *note Command Files::.
 
When user-defined commands are executed, the commands of the
definition are not printed. An error in any command stops execution of
3028,7 → 3003,7
-- Function: execute command [from_tty] [to_string]
Evaluate COMMAND, a string, as a GDB CLI command. If a GDB
exception happens while COMMAND runs, it is translated as
described in *Note Exception Handling: Exception Handling.
described in *note Exception Handling: Exception Handling.
 
FROM_TTY specifies whether GDB ought to consider this command as
having originated from the user invoking it interactively. It
3265,7 → 3240,7
ENCODING argument is not provided, or is an empty string, GDB
will automatically select the encoding most suitable for the
string type. For further information on encoding in GDB
please see *Note Character Sets::.
please see *note Character Sets::.
 
If the optional LENGTH argument is given, the string will be
fetched and encoded to the length of characters specified. If
3857,7 → 3832,7
By default, a GDB command is repeated when the user enters a blank
line at the command prompt. A command can suppress this behavior
by invoking the `dont_repeat' method. This is similar to the user
command `dont-repeat', see *Note dont-repeat: Define.
command `dont-repeat', see *note dont-repeat: Define.
 
-- Method on Command: invoke argument from_tty
This method is called by GDB when this command is invoked.
4357,9 → 4332,9
 
Within each frame, GDB maintains information on each block stored in
that frame. These blocks are organized hierarchically, and are
represented individually in Python as a `gdb.Block'. Please see *Note
represented individually in Python as a `gdb.Block'. Please see *note
Frames In Python::, for a more in-depth discussion on frames.
Furthermore, see *Note Examining the Stack: Stack, for more detailed
Furthermore, see *note Examining the Stack: Stack, for more detailed
technical information on GDB's book-keeping of the stack.
 
The following block-related functions are available in the `gdb'
4545,7 → 4520,7
`gdb.Symtab'. Symbol table and line data for a frame is returned from
the `find_sal' method in `gdb.Frame' object. *Note Frames In Python::.
 
For more information on GDB's symbol table management, see *Note
For more information on GDB's symbol table management, see *note
Examining the Symbol Table: Symbols, for more information.
 
A `gdb.Symtab_and_line' object has the following attributes:
4923,7 → 4898,7
`mi'
The newest GDB/MI interface (currently `mi2'). Used primarily by
programs wishing to use GDB as a backend for a debugger GUI or an
IDE. For more information, see *Note The GDB/MI Interface: GDB/MI.
IDE. For more information, see *note The GDB/MI Interface: GDB/MI.
 
`mi2'
The current GDB/MI interface.
7489,8 → 7464,8
 
Starts execution of the inferior from the beginning. The inferior
executes until either a breakpoint is encountered or the program exits.
In the latter case the output will include an exit code, if the
program has exited exceptionally.
In the latter case the output will include an exit code, if the program
has exited exceptionally.
 
When no option is specified, the current inferior is started. If the
`--thread-group' option is specified, it should refer to a thread group
8292,8 → 8267,7
........
 
-var-list-children [PRINT-VALUES] NAME [FROM TO]
 
Return a list of the children of the specified variable object and
Return a list of the children of the specified variable object and
create variable objects for them, if they do not already exist. With a
single argument or if PRINT-VALUES has a value of 0 or `--no-values',
print only the names of the variables; if PRINT-VALUES is 1 or
/gnu-src/gdb-7.2/gdb/doc/gdb.info
1,4 → 1,4
This is gdb.info, produced by makeinfo version 4.8 from ./gdb.texinfo.
This is gdb.info, produced by makeinfo version 4.13 from ./gdb.texinfo.
 
INFO-DIR-SECTION Software development
START-INFO-DIR-ENTRY
23,7 → 23,7
This file documents the GNU debugger GDB.
 
This is the Ninth Edition, of `Debugging with GDB: the GNU
Source-Level Debugger' for GDB (GDB) Version 7.2.
Source-Level Debugger' for GDB (GDB) Version 7.2-or32-1.0rc1.
 
Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
42,512 → 42,512
 

Indirect:
gdb.info-1: 1888
gdb.info-2: 297354
gdb.info-3: 596354
gdb.info-4: 902640
gdb.info-5: 1197690
gdb.info-6: 1307181
gdb.info-1: 1901
gdb.info-2: 297549
gdb.info-3: 596549
gdb.info-4: 902911
gdb.info-5: 1198305
gdb.info-6: 1307796

Tag Table:
(Indirect)
Node: Top1888
Node: Summary5015
Node: Free Software6720
Node: Contributors12288
Node: Sample Session20377
Node: Invocation27213
Node: Invoking GDB27757
Node: File Options30070
Node: Mode Options32807
Node: Startup39406
Ref: Startup-Footnote-141628
Node: Quitting GDB41737
Node: Shell Commands42634
Node: Logging Output43476
Node: Commands44322
Node: Command Syntax44960
Node: Completion47126
Ref: Completion-Footnote-152332
Node: Help52492
Node: Running57733
Node: Compilation58962
Node: Starting60939
Node: Arguments69829
Node: Environment71099
Node: Working Directory74367
Node: Input/Output75475
Node: Attach77446
Node: Kill Process79913
Node: Inferiors and Programs80894
Node: Threads88064
Node: Forks96442
Node: Checkpoint/Restart102750
Ref: Checkpoint/Restart-Footnote-1107279
Node: Stopping107314
Node: Breakpoints108473
Node: Set Breaks111909
Ref: Set Breaks-Footnote-1128201
Node: Set Watchpoints128449
Node: Set Catchpoints136458
Node: Delete Breaks145654
Node: Disabling147590
Node: Conditions150443
Node: Break Commands155392
Node: Save Breakpoints158616
Node: Error in Breakpoints159792
Node: Breakpoint-related Warnings160523
Node: Continuing and Stepping162850
Node: Signals172210
Ref: extra signal information176482
Node: Thread Stops177985
Node: All-Stop Mode179084
Node: Non-Stop Mode182982
Node: Background Execution186459
Node: Thread-Specific Breakpoints189028
Node: Interrupted System Calls190350
Node: Observer Mode191864
Node: Reverse Execution195303
Ref: Reverse Execution-Footnote-1199930
Ref: Reverse Execution-Footnote-2200557
Node: Process Record and Replay200607
Node: Stack207854
Node: Frames209347
Node: Backtrace212099
Ref: Backtrace-Footnote-1217330
Node: Selection217518
Node: Frame Info220382
Node: Source222713
Node: List223779
Node: Specify Location226392
Node: Edit229642
Ref: Edit-Footnote-1231117
Node: Search231352
Node: Source Path232160
Ref: set substitute-path238418
Node: Machine Code240639
Node: Data247313
Node: Expressions249983
Node: Ambiguous Expressions252075
Node: Variables255309
Node: Arrays259812
Node: Output Formats262343
Ref: Output Formats-Footnote-1265531
Node: Memory265688
Node: Auto Display271842
Node: Print Settings275557
Node: Pretty Printing289161
Node: Value History290198
Node: Convenience Vars292619
Node: Registers297354
Ref: Registers-Footnote-1302031
Node: Floating Point Hardware302426
Node: Vector Unit302958
Node: OS Information303345
Node: Memory Region Attributes305990
Node: Dump/Restore Files310660
Node: Core File Generation312965
Node: Character Sets314199
Node: Caching Remote Data320566
Ref: Caching Remote Data-Footnote-1322367
Node: Searching Memory322605
Node: Optimized Code325482
Node: Inline Functions327092
Node: Macros330062
Node: Tracepoints337165
Node: Set Tracepoints339226
Node: Create and Delete Tracepoints342165
Node: Enable and Disable Tracepoints347053
Node: Tracepoint Passcounts347837
Node: Tracepoint Conditions349264
Node: Trace State Variables350957
Node: Tracepoint Actions353147
Node: Listing Tracepoints358487
Node: Listing Static Tracepoint Markers359605
Node: Starting and Stopping Trace Experiments361451
Node: Tracepoint Restrictions365865
Node: Analyze Collected Data369618
Node: tfind370923
Node: tdump375345
Node: save tracepoints377860
Node: Tracepoint Variables378356
Node: Trace Files379484
Node: Overlays380942
Node: How Overlays Work381662
Ref: A code overlay384222
Node: Overlay Commands387660
Node: Automatic Overlay Debugging391850
Node: Overlay Sample Program393991
Node: Languages395751
Node: Setting396914
Node: Filenames398616
Node: Manually399427
Node: Automatically400636
Node: Show401697
Node: Checks403019
Node: Type Checking404409
Node: Range Checking407142
Node: Supported Languages409543
Node: C410753
Node: C Operators412044
Node: C Constants416363
Node: C Plus Plus Expressions418767
Node: C Defaults422310
Node: C Checks422993
Node: Debugging C423716
Node: Debugging C Plus Plus424200
Node: Decimal Floating Point427387
Node: D428646
Node: Objective-C428912
Node: Method Names in Commands429373
Node: The Print Command with Objective-C431068
Node: Fortran431719
Node: Fortran Operators432444
Node: Fortran Defaults433300
Node: Special Fortran Commands433685
Node: Pascal434191
Node: Modula-2434706
Node: M2 Operators435681
Node: Built-In Func/Proc438680
Node: M2 Constants441541
Node: M2 Types443142
Node: M2 Defaults446361
Node: Deviations446961
Node: M2 Checks448062
Node: M2 Scope448880
Node: GDB/M2449904
Node: Ada450816
Node: Ada Mode Intro451763
Node: Omissions from Ada453673
Node: Additions to Ada458027
Node: Stopping Before Main Program461957
Node: Ada Tasks462486
Node: Ada Tasks and Core Files468899
Node: Ada Glitches469812
Node: Unsupported Languages472879
Node: Symbols473569
Node: Altering487398
Node: Assignment488367
Node: Jumping491472
Node: Signaling493607
Node: Returning494738
Node: Calling498090
Node: Patching501117
Node: GDB Files502194
Node: Files502782
Ref: Shared Libraries515617
Ref: Files-Footnote-1525851
Node: Separate Debug Files526026
Node: Symbol Errors537598
Node: Data Files541220
Node: Targets542059
Node: Active Targets543539
Node: Target Commands545118
Ref: load549391
Node: Byte Order550372
Node: Remote Debugging551349
Node: Connecting552611
Node: File Transfer557551
Node: Server558491
Ref: Monitor Commands for gdbserver566141
Ref: Server-Footnote-1570690
Node: Remote Configuration570810
Ref: set remotebreak571834
Ref: set remote hardware-watchpoint-limit573298
Ref: set remote hardware-breakpoint-limit573298
Ref: set remote exec-file573580
Node: Remote Stub579783
Node: Stub Contents582680
Node: Bootstrapping584791
Node: Debug Session588600
Node: Configurations590160
Node: Native590929
Node: HP-UX591564
Node: BSD libkvm Interface591853
Node: SVR4 Process Information592924
Node: DJGPP Native596354
Node: Cygwin Native602934
Node: Non-debug DLL Symbols606883
Node: Hurd Native611431
Node: Neutrino616694
Node: Darwin617084
Node: Embedded OS618342
Node: VxWorks618818
Node: VxWorks Connection621035
Node: VxWorks Download621969
Node: VxWorks Attach623704
Node: Embedded Processors624102
Node: ARM625281
Node: M32R/D629402
Node: M68K631104
Node: MicroBlaze631397
Node: MIPS Embedded632847
Node: OpenRISC 1000637797
Node: PowerPC Embedded640652
Node: PA642544
Node: Sparclet642833
Node: Sparclet File644317
Node: Sparclet Connection645197
Node: Sparclet Download645675
Node: Sparclet Execution646724
Node: Sparclite647315
Node: Z8000647690
Node: AVR649074
Node: CRIS649437
Node: Super-H650415
Node: Architectures651530
Node: i386651952
Node: A29K652634
Node: Alpha653473
Node: MIPS653606
Node: HPPA656230
Node: SPU656749
Node: PowerPC658937
Node: Controlling GDB659655
Node: Prompt660481
Node: Editing661260
Node: Command History662203
Node: Screen Size665607
Node: Numbers667441
Node: ABI669418
Node: Messages/Warnings672347
Ref: confirmation requests673773
Node: Debugging Output674980
Node: Other Misc Settings680899
Node: Extending GDB681666
Node: Sequences683157
Node: Define683752
Node: Hooks687365
Node: Command Files689732
Node: Output694802
Node: Python699735
Node: Python Commands700590
Node: Python API702265
Node: Basic Python703924
Node: Exception Handling707856
Node: Values From Inferior709925
Node: Types In Python715522
Node: Pretty Printing API722996
Node: Selecting Pretty-Printers726895
Node: Disabling Pretty-Printers731007
Node: Inferiors In Python731881
Node: Threads In Python734441
Node: Commands In Python736167
Node: Parameters In Python744983
Node: Functions In Python749739
Node: Progspaces In Python751852
Node: Objfiles In Python753214
Node: Frames In Python754749
Node: Blocks In Python758143
Node: Symbols In Python759745
Node: Symbol Tables In Python764866
Node: Breakpoints In Python766525
Node: Lazy Strings In Python771496
Node: Auto-loading773770
Node: objfile-gdb.py file774845
Node: .debug_gdb_scripts section776100
Node: Which flavor to choose?777477
Node: Interpreters779294
Node: TUI781393
Node: TUI Overview782360
Node: TUI Keys784793
Node: TUI Single Key Mode787097
Node: TUI Commands787972
Node: TUI Configuration790356
Node: Emacs791652
Node: GDB/MI797129
Node: GDB/MI General Design798977
Node: Context management801500
Node: Asynchronous and non-stop modes804635
Node: Thread groups806627
Node: GDB/MI Command Syntax808905
Node: GDB/MI Input Syntax809148
Node: GDB/MI Output Syntax810702
Node: GDB/MI Compatibility with CLI814274
Node: GDB/MI Development and Front Ends815011
Node: GDB/MI Output Records816668
Node: GDB/MI Result Records817003
Node: GDB/MI Stream Records818009
Node: GDB/MI Async Records819274
Node: GDB/MI Frame Information825399
Node: GDB/MI Thread Information826477
Node: GDB/MI Simple Examples827415
Node: GDB/MI Command Description Format829592
Node: GDB/MI Breakpoint Commands830472
Node: GDB/MI Program Context848468
Node: GDB/MI Thread Commands852736
Node: GDB/MI Program Execution855614
Node: GDB/MI Stack Manipulation867395
Node: GDB/MI Variable Objects878089
Ref: -var-set-format887821
Ref: -var-list-children888939
Ref: -var-update897120
Ref: -var-set-frozen899817
Ref: -var-set-update-range900613
Ref: -var-set-visualizer901143
Node: GDB/MI Data Manipulation902640
Node: GDB/MI Tracepoint Commands917020
Node: GDB/MI Symbol Query924349
Node: GDB/MI File Commands925038
Node: GDB/MI Target Manipulation928375
Node: GDB/MI File Transfer Commands934597
Node: GDB/MI Miscellaneous Commands935919
Ref: -interpreter-exec945318
Node: Annotations947631
Node: Annotations Overview948550
Node: Server Prefix951013
Node: Prompting951747
Node: Errors953264
Node: Invalidation954160
Node: Annotations for Running954637
Node: Source Annotations956157
Node: JIT Interface957082
Node: Declarations958800
Node: Registering Code960187
Node: Unregistering Code961159
Node: GDB Bugs961760
Node: Bug Criteria962489
Node: Bug Reporting963366
Node: Command Line Editing970989
Node: Introduction and Notation971641
Node: Readline Interaction973261
Node: Readline Bare Essentials974450
Node: Readline Movement Commands976237
Node: Readline Killing Commands977200
Node: Readline Arguments979118
Node: Searching980160
Node: Readline Init File982309
Node: Readline Init File Syntax983372
Node: Conditional Init Constructs995304
Node: Sample Init File997835
Node: Bindable Readline Commands1000950
Node: Commands For Moving1002005
Node: Commands For History1002864
Node: Commands For Text1005986
Node: Commands For Killing1008710
Node: Numeric Arguments1010850
Node: Commands For Completion1011987
Node: Keyboard Macros1013529
Node: Miscellaneous Commands1014098
Node: Readline vi Mode1017457
Node: Using History Interactively1018374
Node: History Interaction1018889
Node: Event Designators1020311
Node: Word Designators1021244
Node: Modifiers1022881
Node: Formatting Documentation1024106
Ref: Formatting Documentation-Footnote-11027435
Node: Installing GDB1027499
Node: Requirements1028071
Ref: Expat1028640
Node: Running Configure1030775
Node: Separate Objdir1034314
Node: Config Names1037198
Node: Configure Options1038643
Node: System-wide configuration1041013
Node: Maintenance Commands1042308
Ref: maint info breakpoints1043492
Node: Remote Protocol1057527
Node: Overview1058089
Ref: Binary Data1060651
Node: Packets1062910
Ref: thread-id syntax1063810
Ref: extended mode1065255
Ref: bc1066976
Ref: bs1067186
Ref: read registers packet1068612
Ref: cycle step packet1069776
Ref: write register packet1071652
Ref: step with signal packet1072559
Ref: vStopped packet1078840
Ref: X packet1079183
Ref: insert breakpoint or watchpoint packet1079469
Node: Stop Reply Packets1082231
Node: General Query Packets1086971
Ref: QNonStop1095911
Ref: QPassSignals1096535
Ref: qSearch memory1098612
Ref: QStartNoAckMode1099110
Ref: qSupported1099640
Ref: multiprocess extensions1108362
Ref: qXfer read1112192
Ref: qXfer auxiliary vector read1112686
Ref: qXfer target description read1113035
Ref: qXfer library list read1113479
Ref: qXfer memory map read1114125
Ref: qXfer sdata read1114511
Ref: qXfer siginfo read1114975
Ref: qXfer spu read1115371
Ref: qXfer threads read1115894
Ref: qXfer osdata read1116287
Ref: qXfer write1117489
Ref: qXfer siginfo write1118046
Ref: qXfer spu write1118442
Ref: General Query Packets-Footnote-11120529
Node: Architecture-Specific Protocol Details1120856
Node: Tracepoint Packets1122369
Node: Host I/O Packets1138816
Node: Interrupts1142958
Node: Notification Packets1144861
Node: Remote Non-Stop1147132
Node: Packet Acknowledgment1151391
Node: Examples1153506
Node: File-I/O Remote Protocol Extension1154132
Node: File-I/O Overview1154594
Node: Protocol Basics1156791
Node: The F Request Packet1159023
Node: The F Reply Packet1159924
Node: The Ctrl-C Message1160842
Node: Console I/O1162471
Node: List of Supported Calls1163688
Node: open1164050
Node: close1166544
Node: read1166926
Node: write1167533
Node: lseek1168300
Node: rename1169178
Node: unlink1170574
Node: stat/fstat1171513
Node: gettimeofday1172400
Node: isatty1172835
Node: system1173431
Node: Protocol-specific Representation of Datatypes1174973
Node: Integral Datatypes1175350
Node: Pointer Values1176157
Node: Memory Transfer1176865
Node: struct stat1177485
Node: struct timeval1179687
Node: Constants1180204
Node: Open Flags1180653
Node: mode_t Values1180994
Node: Errno Values1181486
Node: Lseek Flags1182297
Node: Limits1182482
Node: File-I/O Examples1182842
Node: Library List Format1183958
Node: Memory Map Format1186722
Node: Thread List Format1189282
Node: Agent Expressions1190069
Node: General Bytecode Design1192890
Node: Bytecode Descriptions1197690
Node: Using Agent Expressions1209401
Node: Varying Target Capabilities1211379
Node: Rationale1212541
Node: Trace File Format1219927
Node: Target Descriptions1221908
Node: Retrieving Descriptions1223968
Node: Target Description Format1225053
Node: Predefined Target Types1234103
Node: Standard Target Features1235488
Node: ARM Features1237259
Node: i386 Features1238535
Node: MIPS Features1239644
Node: M68K Features1240589
Node: PowerPC Features1241252
Node: Operating System Information1242536
Node: Process list1243374
Node: Copying1244436
Node: GNU Free Documentation License1282023
Node: Index1307181
Node: Top1901
Node: Summary5040
Node: Free Software6745
Node: Contributors12313
Node: Sample Session20560
Node: Invocation27408
Node: Invoking GDB27952
Node: File Options30265
Node: Mode Options33002
Node: Startup39601
Ref: Startup-Footnote-141823
Node: Quitting GDB41932
Node: Shell Commands42829
Node: Logging Output43671
Node: Commands44517
Node: Command Syntax45155
Node: Completion47321
Ref: Completion-Footnote-152527
Node: Help52687
Node: Running57928
Node: Compilation59157
Node: Starting61134
Node: Arguments70024
Node: Environment71294
Node: Working Directory74562
Node: Input/Output75670
Node: Attach77641
Node: Kill Process80108
Node: Inferiors and Programs81089
Node: Threads88259
Node: Forks96637
Node: Checkpoint/Restart102945
Ref: Checkpoint/Restart-Footnote-1107474
Node: Stopping107509
Node: Breakpoints108668
Node: Set Breaks112104
Ref: Set Breaks-Footnote-1128396
Node: Set Watchpoints128644
Node: Set Catchpoints136653
Node: Delete Breaks145849
Node: Disabling147785
Node: Conditions150638
Node: Break Commands155587
Node: Save Breakpoints158811
Node: Error in Breakpoints159987
Node: Breakpoint-related Warnings160718
Node: Continuing and Stepping163045
Node: Signals172405
Ref: extra signal information176677
Node: Thread Stops178180
Node: All-Stop Mode179279
Node: Non-Stop Mode183177
Node: Background Execution186654
Node: Thread-Specific Breakpoints189223
Node: Interrupted System Calls190545
Node: Observer Mode192059
Node: Reverse Execution195498
Ref: Reverse Execution-Footnote-1200125
Ref: Reverse Execution-Footnote-2200752
Node: Process Record and Replay200802
Node: Stack208049
Node: Frames209542
Node: Backtrace212294
Ref: Backtrace-Footnote-1217525
Node: Selection217713
Node: Frame Info220577
Node: Source222908
Node: List223974
Node: Specify Location226587
Node: Edit229837
Ref: Edit-Footnote-1231312
Node: Search231547
Node: Source Path232355
Ref: set substitute-path238613
Node: Machine Code240834
Node: Data247508
Node: Expressions250178
Node: Ambiguous Expressions252270
Node: Variables255504
Node: Arrays260007
Node: Output Formats262538
Ref: Output Formats-Footnote-1265726
Node: Memory265883
Node: Auto Display272037
Node: Print Settings275752
Node: Pretty Printing289356
Node: Value History290393
Node: Convenience Vars292814
Node: Registers297549
Ref: Registers-Footnote-1302226
Node: Floating Point Hardware302621
Node: Vector Unit303153
Node: OS Information303540
Node: Memory Region Attributes306185
Node: Dump/Restore Files310855
Node: Core File Generation313160
Node: Character Sets314394
Node: Caching Remote Data320761
Ref: Caching Remote Data-Footnote-1322562
Node: Searching Memory322800
Node: Optimized Code325677
Node: Inline Functions327287
Node: Macros330257
Node: Tracepoints337360
Node: Set Tracepoints339421
Node: Create and Delete Tracepoints342360
Node: Enable and Disable Tracepoints347248
Node: Tracepoint Passcounts348032
Node: Tracepoint Conditions349459
Node: Trace State Variables351152
Node: Tracepoint Actions353342
Node: Listing Tracepoints358682
Node: Listing Static Tracepoint Markers359800
Node: Starting and Stopping Trace Experiments361646
Node: Tracepoint Restrictions366060
Node: Analyze Collected Data369813
Node: tfind371118
Node: tdump375540
Node: save tracepoints378055
Node: Tracepoint Variables378551
Node: Trace Files379679
Node: Overlays381137
Node: How Overlays Work381857
Ref: A code overlay384417
Node: Overlay Commands387855
Node: Automatic Overlay Debugging392045
Node: Overlay Sample Program394186
Node: Languages395946
Node: Setting397109
Node: Filenames398811
Node: Manually399622
Node: Automatically400831
Node: Show401892
Node: Checks403214
Node: Type Checking404604
Node: Range Checking407337
Node: Supported Languages409738
Node: C410948
Node: C Operators412239
Node: C Constants416558
Node: C Plus Plus Expressions418962
Node: C Defaults422505
Node: C Checks423188
Node: Debugging C423911
Node: Debugging C Plus Plus424395
Node: Decimal Floating Point427582
Node: D428841
Node: Objective-C429107
Node: Method Names in Commands429568
Node: The Print Command with Objective-C431263
Node: Fortran431914
Node: Fortran Operators432639
Node: Fortran Defaults433495
Node: Special Fortran Commands433880
Node: Pascal434386
Node: Modula-2434901
Node: M2 Operators435876
Node: Built-In Func/Proc438875
Node: M2 Constants441736
Node: M2 Types443337
Node: M2 Defaults446556
Node: Deviations447156
Node: M2 Checks448257
Node: M2 Scope449075
Node: GDB/M2450099
Node: Ada451011
Node: Ada Mode Intro451958
Node: Omissions from Ada453868
Node: Additions to Ada458222
Node: Stopping Before Main Program462152
Node: Ada Tasks462681
Node: Ada Tasks and Core Files469094
Node: Ada Glitches470007
Node: Unsupported Languages473074
Node: Symbols473764
Node: Altering487593
Node: Assignment488562
Node: Jumping491667
Node: Signaling493802
Node: Returning494933
Node: Calling498285
Node: Patching501312
Node: GDB Files502389
Node: Files502977
Ref: Shared Libraries515812
Ref: Files-Footnote-1526046
Node: Separate Debug Files526221
Node: Symbol Errors537793
Node: Data Files541415
Node: Targets542254
Node: Active Targets543734
Node: Target Commands545313
Ref: load549586
Node: Byte Order550567
Node: Remote Debugging551544
Node: Connecting552806
Node: File Transfer557746
Node: Server558686
Ref: Monitor Commands for gdbserver566336
Ref: Server-Footnote-1570885
Node: Remote Configuration571005
Ref: set remotebreak572029
Ref: set remote hardware-watchpoint-limit573493
Ref: set remote hardware-breakpoint-limit573493
Ref: set remote exec-file573775
Node: Remote Stub579978
Node: Stub Contents582875
Node: Bootstrapping584986
Node: Debug Session588795
Node: Configurations590355
Node: Native591124
Node: HP-UX591759
Node: BSD libkvm Interface592048
Node: SVR4 Process Information593119
Node: DJGPP Native596549
Node: Cygwin Native603129
Node: Non-debug DLL Symbols607078
Node: Hurd Native611626
Node: Neutrino616889
Node: Darwin617279
Node: Embedded OS618537
Node: VxWorks619013
Node: VxWorks Connection621230
Node: VxWorks Download622164
Node: VxWorks Attach623899
Node: Embedded Processors624297
Node: ARM625476
Node: M32R/D629597
Node: M68K631299
Node: MicroBlaze631592
Node: MIPS Embedded633042
Node: OpenRISC 1000637992
Node: PowerPC Embedded640927
Node: PA642819
Node: Sparclet643108
Node: Sparclet File644592
Node: Sparclet Connection645472
Node: Sparclet Download645950
Node: Sparclet Execution646999
Node: Sparclite647590
Node: Z8000647965
Node: AVR649349
Node: CRIS649712
Node: Super-H650690
Node: Architectures651805
Node: i386652227
Node: A29K652909
Node: Alpha653748
Node: MIPS653881
Node: HPPA656505
Node: SPU657024
Node: PowerPC659212
Node: Controlling GDB659930
Node: Prompt660756
Node: Editing661535
Node: Command History662478
Node: Screen Size665882
Node: Numbers667716
Node: ABI669693
Node: Messages/Warnings672622
Ref: confirmation requests674048
Node: Debugging Output675255
Node: Other Misc Settings681174
Node: Extending GDB681941
Node: Sequences683432
Node: Define684027
Node: Hooks687640
Node: Command Files690007
Node: Output695077
Node: Python700010
Node: Python Commands700865
Node: Python API702540
Node: Basic Python704199
Node: Exception Handling708131
Node: Values From Inferior710200
Node: Types In Python715797
Node: Pretty Printing API723271
Node: Selecting Pretty-Printers727170
Node: Disabling Pretty-Printers731282
Node: Inferiors In Python732156
Node: Threads In Python734716
Node: Commands In Python736442
Node: Parameters In Python745258
Node: Functions In Python750014
Node: Progspaces In Python752127
Node: Objfiles In Python753489
Node: Frames In Python755024
Node: Blocks In Python758418
Node: Symbols In Python760020
Node: Symbol Tables In Python765141
Node: Breakpoints In Python766800
Node: Lazy Strings In Python771771
Node: Auto-loading774045
Node: objfile-gdb.py file775120
Node: .debug_gdb_scripts section776375
Node: Which flavor to choose?777752
Node: Interpreters779569
Node: TUI781668
Node: TUI Overview782635
Node: TUI Keys785068
Node: TUI Single Key Mode787372
Node: TUI Commands788247
Node: TUI Configuration790631
Node: Emacs791927
Node: GDB/MI797404
Node: GDB/MI General Design799252
Node: Context management801775
Node: Asynchronous and non-stop modes804910
Node: Thread groups806902
Node: GDB/MI Command Syntax809180
Node: GDB/MI Input Syntax809423
Node: GDB/MI Output Syntax810977
Node: GDB/MI Compatibility with CLI814549
Node: GDB/MI Development and Front Ends815286
Node: GDB/MI Output Records816943
Node: GDB/MI Result Records817278
Node: GDB/MI Stream Records818284
Node: GDB/MI Async Records819549
Node: GDB/MI Frame Information825674
Node: GDB/MI Thread Information826752
Node: GDB/MI Simple Examples827690
Node: GDB/MI Command Description Format829867
Node: GDB/MI Breakpoint Commands830747
Node: GDB/MI Program Context848743
Node: GDB/MI Thread Commands853011
Node: GDB/MI Program Execution855889
Node: GDB/MI Stack Manipulation867670
Node: GDB/MI Variable Objects878364
Ref: -var-set-format888096
Ref: -var-list-children889214
Ref: -var-update897391
Ref: -var-set-frozen900088
Ref: -var-set-update-range900884
Ref: -var-set-visualizer901414
Node: GDB/MI Data Manipulation902911
Node: GDB/MI Tracepoint Commands917291
Node: GDB/MI Symbol Query924620
Node: GDB/MI File Commands925309
Node: GDB/MI Target Manipulation928646
Node: GDB/MI File Transfer Commands934868
Node: GDB/MI Miscellaneous Commands936190
Ref: -interpreter-exec945589
Node: Annotations947898
Node: Annotations Overview948817
Node: Server Prefix951280
Node: Prompting952014
Node: Errors953531
Node: Invalidation954427
Node: Annotations for Running954904
Node: Source Annotations956424
Node: JIT Interface957349
Node: Declarations959067
Node: Registering Code960454
Node: Unregistering Code961426
Node: GDB Bugs962027
Node: Bug Criteria962756
Node: Bug Reporting963633
Node: Command Line Editing971256
Node: Introduction and Notation971908
Node: Readline Interaction973528
Node: Readline Bare Essentials974717
Node: Readline Movement Commands976504
Node: Readline Killing Commands977467
Node: Readline Arguments979385
Node: Searching980427
Node: Readline Init File982576
Node: Readline Init File Syntax983639
Node: Conditional Init Constructs995571
Node: Sample Init File998102
Node: Bindable Readline Commands1001217
Node: Commands For Moving1002272
Node: Commands For History1003131
Node: Commands For Text1006253
Node: Commands For Killing1008977
Node: Numeric Arguments1011117
Node: Commands For Completion1012254
Node: Keyboard Macros1013796
Node: Miscellaneous Commands1014365
Node: Readline vi Mode1017724
Node: Using History Interactively1018641
Node: History Interaction1019156
Node: Event Designators1020578
Node: Word Designators1021511
Node: Modifiers1023148
Node: Formatting Documentation1024373
Ref: Formatting Documentation-Footnote-11027750
Node: Installing GDB1027838
Node: Requirements1028410
Ref: Expat1028979
Node: Running Configure1031114
Node: Separate Objdir1034833
Node: Config Names1037789
Node: Configure Options1039258
Node: System-wide configuration1041628
Node: Maintenance Commands1042923
Ref: maint info breakpoints1044107
Node: Remote Protocol1058142
Node: Overview1058704
Ref: Binary Data1061266
Node: Packets1063525
Ref: thread-id syntax1064425
Ref: extended mode1065870
Ref: bc1067591
Ref: bs1067801
Ref: read registers packet1069227
Ref: cycle step packet1070391
Ref: write register packet1072267
Ref: step with signal packet1073174
Ref: vStopped packet1079455
Ref: X packet1079798
Ref: insert breakpoint or watchpoint packet1080084
Node: Stop Reply Packets1082846
Node: General Query Packets1087586
Ref: QNonStop1096526
Ref: QPassSignals1097150
Ref: qSearch memory1099227
Ref: QStartNoAckMode1099725
Ref: qSupported1100255
Ref: multiprocess extensions1108977
Ref: qXfer read1112807
Ref: qXfer auxiliary vector read1113301
Ref: qXfer target description read1113650
Ref: qXfer library list read1114094
Ref: qXfer memory map read1114740
Ref: qXfer sdata read1115126
Ref: qXfer siginfo read1115590
Ref: qXfer spu read1115986
Ref: qXfer threads read1116509
Ref: qXfer osdata read1116902
Ref: qXfer write1118104
Ref: qXfer siginfo write1118661
Ref: qXfer spu write1119057
Ref: General Query Packets-Footnote-11121144
Node: Architecture-Specific Protocol Details1121471
Node: Tracepoint Packets1122984
Node: Host I/O Packets1139431
Node: Interrupts1143573
Node: Notification Packets1145476
Node: Remote Non-Stop1147747
Node: Packet Acknowledgment1152006
Node: Examples1154121
Node: File-I/O Remote Protocol Extension1154747
Node: File-I/O Overview1155209
Node: Protocol Basics1157406
Node: The F Request Packet1159638
Node: The F Reply Packet1160539
Node: The Ctrl-C Message1161457
Node: Console I/O1163086
Node: List of Supported Calls1164303
Node: open1164665
Node: close1167159
Node: read1167541
Node: write1168148
Node: lseek1168915
Node: rename1169793
Node: unlink1171189
Node: stat/fstat1172128
Node: gettimeofday1173015
Node: isatty1173450
Node: system1174046
Node: Protocol-specific Representation of Datatypes1175588
Node: Integral Datatypes1175965
Node: Pointer Values1176772
Node: Memory Transfer1177480
Node: struct stat1178100
Node: struct timeval1180302
Node: Constants1180819
Node: Open Flags1181268
Node: mode_t Values1181609
Node: Errno Values1182101
Node: Lseek Flags1182912
Node: Limits1183097
Node: File-I/O Examples1183457
Node: Library List Format1184573
Node: Memory Map Format1187337
Node: Thread List Format1189897
Node: Agent Expressions1190684
Node: General Bytecode Design1193505
Node: Bytecode Descriptions1198305
Node: Using Agent Expressions1210016
Node: Varying Target Capabilities1211994
Node: Rationale1213156
Node: Trace File Format1220542
Node: Target Descriptions1222523
Node: Retrieving Descriptions1224583
Node: Target Description Format1225668
Node: Predefined Target Types1234718
Node: Standard Target Features1236103
Node: ARM Features1237874
Node: i386 Features1239150
Node: MIPS Features1240259
Node: M68K Features1241204
Node: PowerPC Features1241867
Node: Operating System Information1243151
Node: Process list1243989
Node: Copying1245051
Node: GNU Free Documentation License1282638
Node: Index1307796

End Tag Table
/gnu-src/gdb-7.2/gdb/doc/gdb.info-4
1,4 → 1,4
This is gdb.info, produced by makeinfo version 4.8 from ./gdb.texinfo.
This is gdb.info, produced by makeinfo version 4.13 from ./gdb.texinfo.
 
INFO-DIR-SECTION Software development
START-INFO-DIR-ENTRY
23,7 → 23,7
This file documents the GNU debugger GDB.
 
This is the Ninth Edition, of `Debugging with GDB: the GNU
Source-Level Debugger' for GDB (GDB) Version 7.2.
Source-Level Debugger' for GDB (GDB) Version 7.2-or32-1.0rc1.
 
Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
199,7 → 199,7
.......
 
In the following example, the numbers that precede the commands are the
"tokens" described in *Note GDB/MI Command Syntax: GDB/MI Command
"tokens" described in *note GDB/MI Command Syntax: GDB/MI Command
Syntax. Notice how GDB/MI returns the same tokens in its output.
 
211-data-evaluate-expression A
493,7 → 493,7
================================
 
The commands defined in this section implement MI support for
tracepoints. For detailed introduction, see *Note Tracepoints::.
tracepoints. For detailed introduction, see *note Tracepoints::.
 
The `-trace-find' Command
-------------------------
505,7 → 505,7
 
Find a trace frame using criteria defined by MODE and PARAMETERS.
The following table lists permissible modes and their parameters. For
details of operation, see *Note tfind::.
details of operation, see *note tfind::.
 
`none'
No parameters are required. Stops examining trace frames.
1538,9 → 1538,8
--------
 
-interpreter-exec INTERPRETER COMMAND
Execute the specified COMMAND in the given INTERPRETER.
 
Execute the specified COMMAND in the given INTERPRETER.
 
GDB Command
-----------
 
3717,18 → 3716,19
 
GDB includes an already formatted copy of the on-line Info version
of this manual in the `gdb' subdirectory. The main Info file is
`gdb-7.2/gdb/gdb.info', and it refers to subordinate files matching
`gdb.info*' in the same directory. If necessary, you can print out
these files, or read them with any editor; but they are easier to read
using the `info' subsystem in GNU Emacs or the standalone `info'
program, available as part of the GNU Texinfo distribution.
`gdb-7.2-or32-1.0rc1/gdb/gdb.info', and it refers to subordinate files
matching `gdb.info*' in the same directory. If necessary, you can
print out these files, or read them with any editor; but they are
easier to read using the `info' subsystem in GNU Emacs or the
standalone `info' program, available as part of the GNU Texinfo
distribution.
 
If you want to format these Info files yourself, you need one of the
Info formatting programs, such as `texinfo-format-buffer' or `makeinfo'.
 
If you have `makeinfo' installed, and are in the top level GDB
source directory (`gdb-7.2', in the case of version 7.2), you can make
the Info file by typing:
source directory (`gdb-7.2-or32-1.0rc1', in the case of version
7.2-or32-1.0rc1), you can make the Info file by typing:
 
cd gdb
make gdb.info
3753,7 → 3753,8
 
If you have TeX and a DVI printer program installed, you can typeset
and print this manual. First switch to the `gdb' subdirectory of the
main source directory (for example, to `gdb-7.2/gdb') and type:
main source directory (for example, to `gdb-7.2-or32-1.0rc1/gdb') and
type:
 
make gdb.dvi
 
3761,7 → 3762,8
 
---------- Footnotes ----------
 
(1) In `gdb-7.2/gdb/refcard.ps' of the version 7.2 release.
(1) In `gdb-7.2-or32-1.0rc1/gdb/refcard.ps' of the version
7.2-or32-1.0rc1 release.
 

File: gdb.info, Node: Installing GDB, Next: Maintenance Commands, Prev: Formatting Documentation, Up: Top
3860,39 → 3862,39
in a single directory, whose name is usually composed by appending the
version number to `gdb'.
 
For example, the GDB version 7.2 distribution is in the `gdb-7.2'
directory. That directory contains:
For example, the GDB version 7.2-or32-1.0rc1 distribution is in the
`gdb-7.2-or32-1.0rc1' directory. That directory contains:
 
`gdb-7.2/configure (and supporting files)'
`gdb-7.2-or32-1.0rc1/configure (and supporting files)'
script for configuring GDB and all its supporting libraries
 
`gdb-7.2/gdb'
`gdb-7.2-or32-1.0rc1/gdb'
the source specific to GDB itself
 
`gdb-7.2/bfd'
`gdb-7.2-or32-1.0rc1/bfd'
source for the Binary File Descriptor library
 
`gdb-7.2/include'
`gdb-7.2-or32-1.0rc1/include'
GNU include files
 
`gdb-7.2/libiberty'
`gdb-7.2-or32-1.0rc1/libiberty'
source for the `-liberty' free software library
 
`gdb-7.2/opcodes'
`gdb-7.2-or32-1.0rc1/opcodes'
source for the library of opcode tables and disassemblers
 
`gdb-7.2/readline'
`gdb-7.2-or32-1.0rc1/readline'
source for the GNU command-line interface
 
`gdb-7.2/glob'
`gdb-7.2-or32-1.0rc1/glob'
source for the GNU filename pattern-matching subroutine
 
`gdb-7.2/mmalloc'
`gdb-7.2-or32-1.0rc1/mmalloc'
source for the GNU memory-mapped malloc package
 
The simplest way to configure and build GDB is to run `configure'
from the `gdb-VERSION-NUMBER' source directory, which in this example
is the `gdb-7.2' directory.
is the `gdb-7.2-or32-1.0rc1' directory.
 
First switch to the `gdb-VERSION-NUMBER' source directory if you are
not already in it; then run `configure'. Pass the identifier for the
3900,7 → 3902,7
 
For example:
 
cd gdb-7.2
cd gdb-7.2-or32-1.0rc1
./configure HOST
make
 
3921,10 → 3923,10
sh configure HOST
 
If you run `configure' from a directory that contains source
directories for multiple libraries or programs, such as the `gdb-7.2'
source directory for version 7.2, `configure' creates configuration
files for every directory level underneath (unless you tell it not to,
with the `--norecursion' option).
directories for multiple libraries or programs, such as the
`gdb-7.2-or32-1.0rc1' source directory for version 7.2-or32-1.0rc1,
`configure' creates configuration files for every directory level
underneath (unless you tell it not to, with the `--norecursion' option).
 
You should run the `configure' script from the top directory in the
source tree, the `gdb-VERSION-NUMBER' directory. If you run
3963,13 → 3965,13
argument to `--srcdir', you can leave out the `--srcdir' option; it is
assumed.)
 
For example, with version 7.2, you can build GDB in a separate
directory for a Sun 4 like this:
For example, with version 7.2-or32-1.0rc1, you can build GDB in a
separate directory for a Sun 4 like this:
 
cd gdb-7.2
cd gdb-7.2-or32-1.0rc1
mkdir ../gdb-sun4
cd ../gdb-sun4
../gdb-7.2/configure sun4
../gdb-7.2-or32-1.0rc1/configure sun4
make
 
When `configure' builds a configuration using a remote source
3980,9 → 3982,9
 
Make sure that your path to the `configure' script has just one
instance of `gdb' in it. If your path to `configure' looks like
`../gdb-7.2/gdb/configure', you are configuring only one subdirectory
of GDB, not the whole package. This leads to build errors about
missing include files such as `bfd/bfd.h'.
`../gdb-7.2-or32-1.0rc1/gdb/configure', you are configuring only one
subdirectory of GDB, not the whole package. This leads to build errors
about missing include files such as `bfd/bfd.h'.
 
One popular reason to build several GDB configurations in separate
directories is to configure GDB for cross-compiling (where GDB runs on
3996,9 → 3998,9
 
The `Makefile' that `configure' generates in each source directory
also runs recursively. If you type `make' in a source directory such
as `gdb-7.2' (or in a separate configured directory configured with
`--srcdir=DIRNAME/gdb-7.2'), you will build all the required libraries,
and then build GDB.
as `gdb-7.2-or32-1.0rc1' (or in a separate configured directory
configured with `--srcdir=DIRNAME/gdb-7.2-or32-1.0rc1'), you will build
all the required libraries, and then build GDB.
 
When you have multiple hosts or targets configured in separate
directories, you can run `make' on them in parallel (for example, if
4042,7 → 4044,7
Invalid configuration `i986v': machine `i986v' not recognized
 
`config.sub' is also distributed in the GDB source directory
(`gdb-7.2', for version 7.2).
(`gdb-7.2-or32-1.0rc1', for version 7.2-or32-1.0rc1).
 

File: gdb.info, Node: Configure Options, Next: System-wide configuration, Prev: Config Names, Up: Installing GDB
4150,7 → 4152,7
In addition to commands intended for GDB users, GDB includes a number
of commands intended for GDB developers, that are not documented
elsewhere in this manual. These commands are provided here for
reference. (For commands that turn on debugging messages, see *Note
reference. (For commands that turn on debugging messages, see *note
Debugging Output::.)
 
`maint agent EXPRESSION'
4545,7 → 4547,7
transmitted and received data, respectively.
 
All GDB commands and responses (other than acknowledgments and
notifications, see *Note Notification Packets::) are sent as a PACKET.
notifications, see *note Notification Packets::) are sent as a PACKET.
A PACKET is introduced with the character `$', the actual PACKET-DATA,
and the terminating character `#' followed by a two-digit CHECKSUM:
 
4577,7 → 4579,7
and continue COMMANDs, the response is only sent when the operation has
completed, and the target has again stopped all threads in all attached
processes. This is the default all-stop mode behavior, but the remote
protocol also supports GDB's non-stop execution mode; see *Note Remote
protocol also supports GDB's non-stop execution mode; see *note Remote
Non-Stop::, for details.
 
PACKET-DATA consists of a sequence of characters with the exception
4649,10 → 4651,10
syntax, followed by an explanation of the packet's meaning. We include
spaces in some of the templates for clarity; these are not part of the
packet's syntax. No GDB packet uses spaces to separate its components.
For example, a template like `foo BAR BAZ' describes a packet
beginning with the three ASCII bytes `foo', followed by a BAR, followed
directly by a BAZ. GDB does not transmit a space character between the
`foo' and the BAR, or between the BAR and the BAZ.
For example, a template like `foo BAR BAZ' describes a packet beginning
with the three ASCII bytes `foo', followed by a BAR, followed directly
by a BAZ. GDB does not transmit a space character between the `foo'
and the BAR, or between the BAR and the BAZ.
 
Several packets and replies include a THREAD-ID field to identify a
thread. Normally these are positive numbers with a target-specific
4694,7 → 4696,7
`?'
Indicate the reason the target halted. The reply is the same as
for step and continue. This packet has a special interpretation
when the target is in non-stop mode; see *Note Remote Non-Stop::.
when the target is in non-stop mode; see *note Remote Non-Stop::.
 
Reply: *Note Stop Reply Packets::, for the reply specifications.
 
4816,7 → 4818,7
C depends on the operation to be performed: it should be `c' for
step and continue operations, `g' for other operations. The
thread designator THREAD-ID has the format and interpretation
described in *Note thread-id syntax::.
described in *note thread-id syntax::.
 
Reply:
`OK'
4904,7 → 4906,7
`q NAME PARAMS...'
`Q NAME PARAMS...'
General query (`q') and set (`Q'). These packets are described
fully in *Note General Query Packets::.
fully in *note General Query Packets::.
 
`r'
Reset the entire system.
4979,7 → 4981,7
stopped in all-stop mode and in their current state in non-stop
mode. Specifying multiple default actions is an error; specifying
no actions is also an error. Thread IDs are specified using the
syntax described in *Note thread-id syntax::.
syntax described in *note thread-id syntax::.
 
Currently supported actions are:
 
5026,7 → 5028,7
 
`vFile:OPERATION:PARAMETER...'
Perform a file operation on the target system. For details, see
*Note Host I/O Packets::.
*note Host I/O Packets::.
 
`vFlashErase:ADDR,LENGTH'
Direct the stub to erase LENGTH bytes of flash starting at ADDR.
5084,7 → 5086,7
Kill the process with the specified process ID. PID is a
hexadecimal integer identifying the process. This packet is used
in preference to `k' when multiprocess protocol extensions are
supported; see *Note multiprocess extensions::.
supported; see *note multiprocess extensions::.
 
Reply:
`E NN'
5159,7 → 5161,7
target-specific and typically indicates the size of the breakpoint
in bytes that should be inserted. E.g., the ARM and MIPS can
insert either a 2 or 4 byte breakpoint. Some architectures have
additional meanings for KIND; see *Note Architecture-Specific
additional meanings for KIND; see *note Architecture-Specific
Protocol Details::.
 
_Implementation note: It is possible for a target to copy or move
5280,7 → 5282,7
two-digit hex number.
 
* If N is `thread', then R is the THREAD-ID of the stopped
thread, as specified in *Note thread-id syntax::.
thread, as specified in *note thread-id syntax::.
 
* If N is `core', then R is the hexadecimal number of the core
on which the stop event was detected.
5320,7 → 5322,7
 
The second form of the response, including the process ID of the
exited process, can be used only when GDB has reported support for
multiprocess protocol extensions; see *Note multiprocess
multiprocess protocol extensions; see *note multiprocess
extensions::. The PID is formatted as a big-endian hex string.
 
`X AA'
5329,7 → 5331,7
 
The second form of the response, including the process ID of the
terminated process, can be used only when GDB has reported support
for multiprocess protocol extensions; see *Note multiprocess
for multiprocess protocol extensions; see *note multiprocess
extensions::. The PID is formatted as a big-endian hex string.
 
`O XX...'
5412,7 → 5414,7
 
Reply:
`QC THREAD-ID'
Where THREAD-ID is a thread ID as documented in *Note
Where THREAD-ID is a thread ID as documented in *note
thread-id syntax::.
 
`(anything else)'
5464,7 → 5466,7
one or more thread IDs, separated by commas. GDB will respond to
each reply with a request for more thread ids (using the `qs' form
of the query), until the target responds with `l' (lower-case ell,
for "last"). Refer to *Note thread-id syntax::, for the format of
for "last"). Refer to *note thread-id syntax::, for the format of
the THREAD-ID fields.
 
`qGetTLSAddr:THREAD-ID,OFFSET,LM'
5964,7 → 5966,7
 
`qThreadExtraInfo,THREAD-ID'
Obtain a printable string description of a thread's attributes from
the target OS. THREAD-ID is a thread ID; see *Note thread-id
the target OS. THREAD-ID is a thread ID; see *note thread-id
syntax::. This string may contain anything that the target OS
thinks is interesting for GDB to tell the user about the thread.
The string is displayed in GDB's `info threads' display. Some
6214,7 → 6216,7
==========================================
 
This section describes how the remote protocol is applied to specific
target architectures. Also see *Note Standard Target Features::, for
target architectures. Also see *note Standard Target Features::, for
details of XML target descriptions for each architecture.
 
D.5.1 ARM
6328,7 → 6330,7
 
`X LEN,EXPR'
Evaluate EXPR, whose length is LEN, and collect memory as it
directs. EXPR is an agent expression, as described in *Note
directs. EXPR is an agent expression, as described in *note
Agent Expressions::. Each byte of the expression is encoded
as a two-digit hex number in the packet; LEN is the number of
bytes in the expression (and thus one-half the number of hex
6339,10 → 6341,10
packet, as long as the packet does not exceed the maximum packet
length (400 bytes, for many stubs). There may be only one `R'
action per tracepoint, and it must precede any `M' or `X' actions.
Any registers referred to by `M' and `X' actions must be
collected by a preceding `R' action. (The "while-stepping"
actions are treated as if they were attached to a separate
tracepoint, as far as these restrictions are concerned.)
Any registers referred to by `M' and `X' actions must be collected
by a preceding `R' action. (The "while-stepping" actions are
treated as if they were attached to a separate tracepoint, as far
as these restrictions are concerned.)
 
Replies:
`OK'
6738,11 → 6740,11
 
`vFile:pwrite: FD, OFFSET, DATA'
Write DATA (a binary buffer) to the open file corresponding to FD.
Start the write at OFFSET from the start of the file. Unlike
many `write' system calls, there is no separate COUNT argument;
the length of DATA in the packet is used. `vFile:write' returns
the number of bytes written, which may be shorter than the length
of DATA, or -1 if an error occurred.
Start the write at OFFSET from the start of the file. Unlike many
`write' system calls, there is no separate COUNT argument; the
length of DATA in the packet is used. `vFile:write' returns the
number of bytes written, which may be shorter than the length of
DATA, or -1 if an error occurred.
 
`vFile:unlink: PATHNAME'
Delete the file at PATHNAME on the target. Return 0, or -1 if an
6832,8 → 6834,8
 
`Stop: REPLY'
Report an asynchronous stop event in non-stop mode. The REPLY has
the form of a stop reply, as described in *Note Stop Reply
Packets::. Refer to *Note Remote Non-Stop::, for information on
the form of a stop reply, as described in *note Stop Reply
Packets::. Refer to *note Remote Non-Stop::, for information on
how these notifications are acknowledged by GDB.
 

6843,7 → 6845,7
==============================================
 
GDB's remote protocol supports non-stop debugging of multi-threaded
programs, as described in *Note Non-Stop Mode::. If the stub supports
programs, as described in *note Non-Stop Mode::. If the stub supports
non-stop mode, it should report that to GDB by including `QNonStop+' in
its `qSupported' response (*note qSupported::).
 
6933,7 → 6935,7
 
When in no-acknowledgment mode, neither the stub nor GDB shall send
or expect `+'/`-' protocol acknowledgments. The packet and response
format still includes the normal checksum, as described in *Note
format still includes the normal checksum, as described in *note
Overview::, but the checksum may be ignored by the receiver.
 
If the stub supports `QStartNoAckMode' and prefers to operate in
7827,7 → 7829,7
};
 
The integral datatypes conform to the definitions given in the
appropriate section (see *Note Integral Datatypes::, for details) so
appropriate section (see *note Integral Datatypes::, for details) so
this structure is of size 64 bytes.
 
The values of several fields have a restricted meaning and/or range
7840,7 → 7842,7
No valid meaning for the target. Transmitted unchanged.
 
`st_mode'
Valid mode bits are described in *Note Constants::. Any other
Valid mode bits are described in *note Constants::. Any other
bits have currently no meaning for the target.
 
`st_uid'
7878,7 → 7880,7
};
 
The integral datatypes conform to the definitions given in the
appropriate section (see *Note Integral Datatypes::, for details) so
appropriate section (see *note Integral Datatypes::, for details) so
this structure is of size 8 bytes.
 

/gnu-src/gdb-7.2/gdb/doc/gdb.info-5
1,4 → 1,4
This is gdb.info, produced by makeinfo version 4.8 from ./gdb.texinfo.
This is gdb.info, produced by makeinfo version 4.13 from ./gdb.texinfo.
 
INFO-DIR-SECTION Software development
START-INFO-DIR-ENTRY
23,7 → 23,7
This file documents the GNU debugger GDB.
 
This is the Ninth Edition, of `Debugging with GDB: the GNU
Source-Level Debugger' for GDB (GDB) Version 7.2.
Source-Level Debugger' for GDB (GDB) Version 7.2-or32-1.0rc1.
 
Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
652,7 → 652,7
description from the target. GDB retrieves it via the remote protocol
using `qXfer' requests (*note qXfer: General Query Packets.). The
ANNEX in the `qXfer' packet will be `target.xml'. The contents of the
`target.xml' annex are an XML document, of the form described in *Note
`target.xml' annex are an XML document, of the form described in *note
Target Description Format::.
 
Alternatively, you can specify a file to read for the target
/gnu-src/gdb-7.2/gdb/doc/gdb.info-6
1,4 → 1,4
This is gdb.info, produced by makeinfo version 4.8 from ./gdb.texinfo.
This is gdb.info, produced by makeinfo version 4.13 from ./gdb.texinfo.
 
INFO-DIR-SECTION Software development
START-INFO-DIR-ENTRY
23,7 → 23,7
This file documents the GNU debugger GDB.
 
This is the Ninth Edition, of `Debugging with GDB: the GNU
Source-Level Debugger' for GDB (GDB) Version 7.2.
Source-Level Debugger' for GDB (GDB) Version 7.2-or32-1.0rc1.
 
Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
156,7 → 156,7
* -enable-pretty-printing: GDB/MI Variable Objects.
(line 116)
* -enable-timings: GDB/MI Miscellaneous Commands.
(line 381)
(line 380)
* -environment-cd: GDB/MI Program Context.
(line 33)
* -environment-directory: GDB/MI Program Context.
210,9 → 210,9
* -gdb-version: GDB/MI Miscellaneous Commands.
(line 77)
* -inferior-tty-set: GDB/MI Miscellaneous Commands.
(line 332)
(line 331)
* -inferior-tty-show: GDB/MI Miscellaneous Commands.
(line 355)
(line 354)
* -interpreter-exec: GDB/MI Miscellaneous Commands.
(line 306)
* -l: Mode Options. (line 126)
281,37 → 281,37
* -trace-stop: GDB/MI Tracepoint Commands.
(line 244)
* -var-assign: GDB/MI Variable Objects.
(line 475)
(line 474)
* -var-create: GDB/MI Variable Objects.
(line 134)
* -var-delete: GDB/MI Variable Objects.
(line 220)
* -var-evaluate-expression: GDB/MI Variable Objects.
(line 454)
(line 453)
* -var-info-expression: GDB/MI Variable Objects.
(line 392)
(line 391)
* -var-info-num-children: GDB/MI Variable Objects.
(line 269)
* -var-info-path-expression: GDB/MI Variable Objects.
(line 416)
(line 415)
* -var-info-type: GDB/MI Variable Objects.
(line 379)
(line 378)
* -var-list-children: GDB/MI Variable Objects.
(line 285)
* -var-set-format: GDB/MI Variable Objects.
(line 233)
* -var-set-frozen: GDB/MI Variable Objects.
(line 613)
(line 612)
* -var-set-update-range: GDB/MI Variable Objects.
(line 639)
(line 638)
* -var-set-visualizer: GDB/MI Variable Objects.
(line 662)
(line 661)
* -var-show-attributes: GDB/MI Variable Objects.
(line 440)
(line 439)
* -var-show-format: GDB/MI Variable Objects.
(line 256)
* -var-update: GDB/MI Variable Objects.
(line 499)
(line 498)
* -w: Mode Options. (line 78)
* -x: File Options. (line 51)
* ., Modula-2 scope operator: M2 Scope. (line 6)
549,6 → 549,7
* bug criteria: Bug Criteria. (line 6)
* bug reports: Bug Reporting. (line 6)
* bugs in GDB: GDB Bugs. (line 6)
* Bugs, reporting: OpenRISC 1000. (line 77)
* build ID sections: Separate Debug Files.
(line 96)
* build ID, and separate debugging files: Separate Debug Files.
1360,8 → 1361,6
* Host I/O, remote protocol: Host I/O Packets. (line 6)
* how many arguments (user-defined commands): Define. (line 25)
* HPPA support: HPPA. (line 6)
* htrace: OpenRISC 1000. (line 69)
* hwatch: OpenRISC 1000. (line 59)
* i (info): Help. (line 99)
* I packet: Packets. (line 197)
* i packet: Packets. (line 192)
1429,7 → 1428,6
(line 45)
* info meminfo: SVR4 Process Information.
(line 78)
* info or1k spr: OpenRISC 1000. (line 20)
* info os: OS Information. (line 47)
* info os processes: OS Information. (line 52)
* info pidlist: SVR4 Process Information.
1450,6 → 1448,7
* info source: Symbols. (line 159)
* info source, show the source language: Show. (line 21)
* info sources: Symbols. (line 178)
* info spr: OpenRISC 1000. (line 31)
* info spu: SPU. (line 10)
* info stack: Backtrace. (line 34)
* info static-tracepoint-markers: Listing Static Tracepoint Markers.
1900,7 → 1899,11
* open flags, in file-i/o protocol: Open Flags. (line 6)
* open, file-i/o system call: open. (line 6)
* OpenRISC 1000: OpenRISC 1000. (line 6)
* OpenRISC 1000 htrace: OpenRISC 1000. (line 58)
* OpenRISC 1000 known problems: OpenRISC 1000. (line 59)
* OpenRISC 1000 known problems, architectural compatability: OpenRISC 1000.
(line 70)
* OpenRISC 1000 known problems, hardware breakpoints and watchpoints: OpenRISC 1000.
(line 61)
* operating system information: Operating System Information.
(line 6)
* operating system information, process list: Process list. (line 6)
1910,8 → 1913,6
(line 35)
* optional debugging messages: Debugging Output. (line 6)
* optional warnings: Messages/Warnings. (line 6)
* or1k boards: OpenRISC 1000. (line 6)
* or1ksim: OpenRISC 1000. (line 16)
* OS ABI: ABI. (line 11)
* OS information: OS Information. (line 6)
* out-of-line single-stepping: Maintenance Commands.
2289,6 → 2290,7
* replay log events, remote reply: Stop Reply Packets. (line 61)
* replay mode: Process Record and Replay.
(line 10)
* Reporting bugs: OpenRISC 1000. (line 77)
* reporting bugs in GDB: GDB Bugs. (line 6)
* reprint the last value: Data. (line 23)
* reset SDI connection, M32R: M32R/D. (line 44)
2814,7 → 2816,7
* Special Fortran commands: Special Fortran Commands.
(line 6)
* specifying location: Specify Location. (line 6)
* spr: OpenRISC 1000. (line 33)
* spr: OpenRISC 1000. (line 48)
* SPU: SPU. (line 6)
* SSE registers (x86): Registers. (line 71)
* stack frame: Frames. (line 6)
2962,7 → 2964,6
* target descriptions, XML format: Target Description Format.
(line 6)
* target dink32: PowerPC Embedded. (line 33)
* target jtag: OpenRISC 1000. (line 9)
* target lsi PORT: MIPS Embedded. (line 44)
* target m32r: M32R/D. (line 6)
* target m32rsdi: M32R/D. (line 9)
2979,8 → 2980,10
* target rdp: ARM. (line 11)
* target record: Process Record and Replay.
(line 38)
* target remote <1>: OpenRISC 1000. (line 10)
* target remote: Connecting. (line 11)
* target sds: PowerPC Embedded. (line 41)
* target sim: OpenRISC 1000. (line 20)
* target sim, with Z8000: Z8000. (line 15)
* target sparclite: Sparclite. (line 6)
* target stack description: Maintenance Commands.
/gnu-src/gdb-7.2/gdb/doc/gdbint.info-1
1,4 → 1,4
This is gdbint.info, produced by makeinfo version 4.8 from
This is gdbint.info, produced by makeinfo version 4.13 from
./gdbint.texinfo.
 
INFO-DIR-SECTION Software development
926,7 → 926,7
easy to extend, and versatile enough to be used as the standard
interface when adding new notifications.
 
See *Note GDB Observers:: for a brief description of the observers
See *note GDB Observers:: for a brief description of the observers
currently implemented in GDB. The rationale for the current
implementation is also briefly discussed.
 
2119,7 → 2119,7
The COFF sections, symbols, and line numbers are used, but debugging
symbols are `dbx'-style stabs whose strings are located in the `.debug'
section (rather than the string table). For more information, see
*Note Top: (stabs)Top.
*note Top: (stabs)Top.
 
The shared library scheme has a clean interface for figuring out what
shared libraries are in use, but the catch is that everything which
4259,7 → 4259,7
 
`I386_USE_GENERIC_WATCHPOINTS'
An x86-based target can define this to use the generic x86
watchpoint support; see *Note I386_USE_GENERIC_WATCHPOINTS:
watchpoint support; see *note I386_USE_GENERIC_WATCHPOINTS:
Algorithms.
 
`gdbarch_in_function_epilogue_p (GDBARCH, ADDR)'
4626,7 → 4626,7
supports, or for the target to tell GDB directly.
 
For details on writing, automatically supplying, and manually
selecting target descriptions, see *Note Target Descriptions:
selecting target descriptions, see *note Target Descriptions:
(gdb)Target Descriptions. This section will cover some related topics
about the GDB internals.
 
4659,7 → 4659,7
new architecture. Then the initialization routine is called, and has a
chance to adjust the constructed architecture based on the contents of
the target description. For instance, it can recognize any properties
set by a `to_read_description' routine. Also see *Note Adding Target
set by a `to_read_description' routine. Also see *note Adding Target
Described Register Support::.
 

4931,7 → 4931,7
 
`I386_USE_GENERIC_WATCHPOINTS'
An x86-based machine can define this to use the generic x86
watchpoint support; see *Note I386_USE_GENERIC_WATCHPOINTS:
watchpoint support; see *note I386_USE_GENERIC_WATCHPOINTS:
Algorithms.
 
`SOLIB_ADD (FILENAME, FROM_TTY, TARG, READSYMS)'
/gnu-src/gdb-7.2/gdb/doc/gdbint.info-2
1,4 → 1,4
This is gdbint.info, produced by makeinfo version 4.8 from
This is gdbint.info, produced by makeinfo version 4.13 from
./gdbint.texinfo.
 
INFO-DIR-SECTION Software development
/gnu-src/gdb-7.2/gdb/doc/gdbint.info
1,4 → 1,4
This is gdbint.info, produced by makeinfo version 4.8 from
This is gdbint.info, produced by makeinfo version 4.13 from
./gdbint.texinfo.
 
INFO-DIR-SECTION Software development
34,88 → 34,88
 

Indirect:
gdbint.info-1: 1537
gdbint.info-2: 299035
gdbint.info-1: 1538
gdbint.info-2: 299036

Tag Table:
(Indirect)
Node: Top1537
Node: Summary2418
Node: Requirements2568
Node: Contributors4047
Node: Overall Structure5640
Node: Algorithms10663
Node: User Interface42105
Ref: UI-Independent Output43960
Ref: User Interface-Footnote-165931
Ref: User Interface-Footnote-265980
Node: libgdb66215
Node: Values70166
Node: Stack Frames73010
Node: Symbol Handling77992
Node: Language Support94797
Node: Host Definition99523
Node: Target Architecture Definition103882
Node: OS ABI Variant Handling104702
Node: Initialize New Architecture109547
Node: How an Architecture is Represented109898
Node: Looking Up an Existing Architecture111855
Node: Creating a New Architecture114774
Node: Registers and Memory116812
Node: Pointers and Addresses117604
Ref: Pointers and Addresses-Footnote-1123605
Node: Address Classes123848
Node: Register Representation127093
Node: Raw and Cooked Registers127467
Node: Register Architecture Functions & Variables128651
Node: Register Information Functions132260
Ref: Register Information Functions-Footnote-1138166
Node: Register and Memory Data138585
Node: Register Caching141734
Node: Frame Interpretation143270
Node: All About Stack Frames143676
Ref: All About Stack Frames-Footnote-1149027
Node: Frame Handling Terminology149259
Node: Prologue Caches151786
Node: Functions and Variable to Analyze Frames153467
Ref: frame_align155565
Node: Functions to Access Frame Data157079
Node: Analyzing Stacks---Frame Sniffers159370
Ref: Analyzing Stacks---Frame Sniffers-Footnote-1164020
Node: Inferior Call Setup164517
Node: About Dummy Frames164800
Node: Functions Creating Dummy Frames165426
Node: Adding support for debugging core files169483
Node: Defining Other Architecture Features170027
Ref: gdbarch_breakpoint_from_pc174874
Ref: gdbarch_stabs_argument_has_addr187268
Ref: gdbarch_push_dummy_call187515
Ref: gdbarch_push_dummy_code188075
Ref: gdbarch_return_value189057
Ref: gdbarch_dummy_id194823
Node: Adding a New Target195511
Node: Target Descriptions197978
Node: Target Descriptions Implementation198917
Node: Adding Target Described Register Support200291
Node: Target Vector Definition203237
Node: Managing Execution State203769
Node: Existing Targets205582
Node: Native Debugging208097
Node: Support Libraries211925
Node: Coding223440
Node: Porting GDB248550
Node: Versions and Branches250419
Ref: Tags256375
Ref: experimental branch tags256706
Node: Start of New Year Procedure257438
Node: Releasing GDB259244
Node: Testsuite277476
Ref: Testsuite-Footnote-1289341
Node: Hints289459
Node: Getting Started289781
Node: Debugging GDB293946
Node: GDB Observers299035
Node: GNU Free Documentation License307343
Node: Index332510
Node: Top1538
Node: Summary2419
Node: Requirements2569
Node: Contributors4048
Node: Overall Structure5641
Node: Algorithms10664
Node: User Interface42106
Ref: UI-Independent Output43961
Ref: User Interface-Footnote-165932
Ref: User Interface-Footnote-265981
Node: libgdb66216
Node: Values70167
Node: Stack Frames73011
Node: Symbol Handling77993
Node: Language Support94798
Node: Host Definition99524
Node: Target Architecture Definition103883
Node: OS ABI Variant Handling104703
Node: Initialize New Architecture109548
Node: How an Architecture is Represented109899
Node: Looking Up an Existing Architecture111856
Node: Creating a New Architecture114775
Node: Registers and Memory116813
Node: Pointers and Addresses117605
Ref: Pointers and Addresses-Footnote-1123606
Node: Address Classes123849
Node: Register Representation127094
Node: Raw and Cooked Registers127468
Node: Register Architecture Functions & Variables128652
Node: Register Information Functions132261
Ref: Register Information Functions-Footnote-1138167
Node: Register and Memory Data138586
Node: Register Caching141735
Node: Frame Interpretation143271
Node: All About Stack Frames143677
Ref: All About Stack Frames-Footnote-1149028
Node: Frame Handling Terminology149260
Node: Prologue Caches151787
Node: Functions and Variable to Analyze Frames153468
Ref: frame_align155566
Node: Functions to Access Frame Data157080
Node: Analyzing Stacks---Frame Sniffers159371
Ref: Analyzing Stacks---Frame Sniffers-Footnote-1164021
Node: Inferior Call Setup164518
Node: About Dummy Frames164801
Node: Functions Creating Dummy Frames165427
Node: Adding support for debugging core files169484
Node: Defining Other Architecture Features170028
Ref: gdbarch_breakpoint_from_pc174875
Ref: gdbarch_stabs_argument_has_addr187269
Ref: gdbarch_push_dummy_call187516
Ref: gdbarch_push_dummy_code188076
Ref: gdbarch_return_value189058
Ref: gdbarch_dummy_id194824
Node: Adding a New Target195512
Node: Target Descriptions197979
Node: Target Descriptions Implementation198918
Node: Adding Target Described Register Support200292
Node: Target Vector Definition203238
Node: Managing Execution State203770
Node: Existing Targets205583
Node: Native Debugging208098
Node: Support Libraries211926
Node: Coding223441
Node: Porting GDB248551
Node: Versions and Branches250420
Ref: Tags256376
Ref: experimental branch tags256707
Node: Start of New Year Procedure257439
Node: Releasing GDB259245
Node: Testsuite277477
Ref: Testsuite-Footnote-1289342
Node: Hints289460
Node: Getting Started289782
Node: Debugging GDB293947
Node: GDB Observers299036
Node: GNU Free Documentation License307344
Node: Index332511

End Tag Table
/gnu-src/gdb-7.2/gdb/doc/annotate.info
1,4 → 1,4
This is annotate.info, produced by makeinfo version 4.8 from
This is annotate.info, produced by makeinfo version 4.13 from
./annotate.texinfo.
 
INFO-DIR-SECTION Software development
1172,21 → 1172,21
 

Tag Table:
Node: Top1282
Node: Annotations Overview2452
Node: Limitations4251
Node: Migrating to GDB/MI6836
Node: Server Prefix7219
Node: Value Annotations7865
Node: Frame Annotations11035
Node: Displays14934
Node: Prompting15965
Node: Errors17468
Node: Breakpoint Info18358
Node: Invalidation19583
Node: Annotations for Running20062
Node: Source Annotations21575
Node: Multi-threaded Apps22521
Node: GNU Free Documentation License23130
Node: Top1283
Node: Annotations Overview2453
Node: Limitations4252
Node: Migrating to GDB/MI6837
Node: Server Prefix7220
Node: Value Annotations7866
Node: Frame Annotations11036
Node: Displays14935
Node: Prompting15966
Node: Errors17469
Node: Breakpoint Info18359
Node: Invalidation19584
Node: Annotations for Running20063
Node: Source Annotations21576
Node: Multi-threaded Apps22522
Node: GNU Free Documentation License23131

End Tag Table
/gnu-src/gdb-7.2/gdb/doc/stabs.info
1,4 → 1,4
This is stabs.info, produced by makeinfo version 4.8 from
This is stabs.info, produced by makeinfo version 4.13 from
./stabs.texinfo.
 
INFO-DIR-SECTION Software development
146,7 → 146,7
.stabx "STRING",VALUE,TYPE,SDB-TYPE
 
For `.stabn' and `.stabd', there is no STRING (the `n_strx' field is
zero; see *Note Symbol Tables::). For `.stabd', the VALUE field is
zero; see *note Symbol Tables::). For `.stabd', the VALUE field is
implicit and has the value of the current file location. For `.stabx',
the SDB-TYPE field is unused for stabs and can always be set to zero.
The OTHER field is almost always unused and can be set to zero.
187,7 → 187,7
that tells more specifically what kind of symbol the stab represents.
If the SYMBOL-DESCRIPTOR is omitted, but type information follows, then
the stab represents a local variable. For a list of symbol
descriptors, see *Note Symbol Descriptors::. The `c' symbol descriptor
descriptors, see *note Symbol Descriptors::. The `c' symbol descriptor
is an exception in that it is not followed by type information. *Note
Constants::.
 
208,7 → 208,7
TYPE-DESCRIPTOR vary, depending on the TYPE-DESCRIPTOR. *Note Type
Descriptors::, for a list of TYPE-DESCRIPTOR values. If a number
follows the `=' then the number is a TYPE-REFERENCE. For a full
description of types, *Note Types::.
description of types, *note Types::.
 
A TYPE-NUMBER is often a single number. The GNU and Sun tools
additionally permit a TYPE-NUMBER to be a pair
218,7 → 218,7
on. The FILETYPE-NUMBER is a number starting with 1 which is
incremented for each new type defined in the file. (Separating the
file number and the type number permits the `N_BINCL' optimization to
succeed more often; see *Note Include Files::).
succeed more often; see *note Include Files::).
 
There is an AIX extension for type attributes. Following the `='
are any number of type attributes. Each one starts with `@' and ends
575,7 → 575,7
sure how to find which symbol of that name is the right one, and this
doesn't provide any way to deal with nested functions, it would
probably be better to make the value of the stab an address relative to
the start of the file, or just absolute. See *Note ELF Linker
the start of the file, or just absolute. See *note ELF Linker
Relocation:: for more information on linker relocation of stabs in ELF
files. For XCOFF, the stab uses the `C_FUN' storage class and the
value of the stab is meaningless; the address of the function can be
848,7 → 848,7
The value of the stab is the offset of the variable within the local
variables. On most machines this is an offset from the frame pointer
and is negative. The location of the stab specifies which block it is
defined in; see *Note Block Structure::.
defined in; see *note Block Structure::.
 
For example, the following C code:
 
865,8 → 865,8
.stabn 192,0,0,LBB2 # 192 is N_LBRAC
.stabn 224,0,0,LBE2 # 224 is N_RBRAC
 
See *Note Procedures:: for more information on the `N_FUN' stab, and
*Note Block Structure:: for more information on the `N_LBRAC' and
See *note Procedures:: for more information on the `N_FUN' stab, and
*note Block Structure:: for more information on the `N_LBRAC' and
`N_RBRAC' stabs.
 

1680,7 → 1680,7
represented by `M-2;3', where `-2' is a reference to a character
type (*note Negative Type Numbers::). I'm not sure how this
differs from an array. This appears to be a Fortran feature.
LENGTH is a bound, like those in range types; see *Note
LENGTH is a bound, like those in range types; see *note
Subranges::.
 
`S TYPE-INFORMATION'
1708,7 → 1708,7
`s' for a structure tag, `u' for a union tag, or `e' for a enumerator
tag, followed by the name of the tag, followed by `:'. If the name
contains `::' between a `<' and `>' pair (for C++ templates), such a
`::' does not end the name--only a single `:' ends the name; see *Note
`::' does not end the name--only a single `:' ends the name; see *note
Nested Symbols::.
 
For example, the following C declarations:
1770,7 → 1770,7
`J'
There is no bound.
 
Subranges are also used for builtin types; see *Note Traditional
Subranges are also used for builtin types; see *note Traditional
Builtin Types::.
 

1916,7 → 1916,7
There is no standard way to specify the size of an enumeration type;
it is determined by the architecture (normally all enumerations types
are 32 bits). Type attributes can be used to specify an enumeration
type of another size for debuggers which support them; see *Note String
type of another size for debuggers which support them; see *note String
Field::.
 
Enumeration types are unusual in that they define symbols for the
1990,7 → 1990,7
refers to.
 
If the structure has methods (a C++ feature), they follow the
non-method fields; see *Note Cplusplus::.
non-method fields; see *note Cplusplus::.
 

File: stabs.info, Node: Typedefs, Next: Unions, Prev: Structures, Up: Types
2501,8 → 2501,8
rather than one. This is followed by a new type definition for the
method. This is a number followed by an equal sign and the type of the
method. Normally this will be a type declared using the `#' type
descriptor; see *Note Method Type Descriptor::; static member functions
are declared using the `f' type descriptor instead; see *Note Function
descriptor; see *note Method Type Descriptor::; static member functions
are declared using the `f' type descriptor instead; see *note Function
Types::.
 
The format of an overloaded operator method name differs from that of
3118,10 → 3118,10
languages other than C.
 
`0x20 N_GSYM'
Global symbol; see *Note Global Variables::.
Global symbol; see *note Global Variables::.
 
`0x22 N_FNAME'
Function name (for BSD Fortran); see *Note Procedures::.
Function name (for BSD Fortran); see *note Procedures::.
 
`0x24 N_FUN'
Function name (*note Procedures::) or text segment variable (*note
3128,28 → 3128,28
Statics::).
 
`0x26 N_STSYM'
Data segment file-scope variable; see *Note Statics::.
Data segment file-scope variable; see *note Statics::.
 
`0x28 N_LCSYM'
BSS segment file-scope variable; see *Note Statics::.
BSS segment file-scope variable; see *note Statics::.
 
`0x2a N_MAIN'
Name of main routine; see *Note Main Program::.
Name of main routine; see *note Main Program::.
 
`0x2c N_ROSYM'
Variable in `.rodata' section; see *Note Statics::.
Variable in `.rodata' section; see *note Statics::.
 
`0x30 N_PC'
Global symbol (for Pascal); see *Note N_PC::.
Global symbol (for Pascal); see *note N_PC::.
 
`0x32 N_NSYMS'
Number of symbols (according to Ultrix V4.0); see *Note N_NSYMS::.
Number of symbols (according to Ultrix V4.0); see *note N_NSYMS::.
 
`0x34 N_NOMAP'
No DST map; see *Note N_NOMAP::.
No DST map; see *note N_NOMAP::.
 
`0x36 N_MAC_DEFINE'
Name and body of a `#define'd macro; see *Note Macro define and
Name and body of a `#define'd macro; see *note Macro define and
undefine::.
 
`0x38 N_OBJ'
3156,53 → 3156,53
Object file (Solaris2).
 
`0x3a N_MAC_UNDEF'
Name of an `#undef'ed macro; see *Note Macro define and undefine::.
Name of an `#undef'ed macro; see *note Macro define and undefine::.
 
`0x3c N_OPT'
Debugger options (Solaris2).
 
`0x40 N_RSYM'
Register variable; see *Note Register Variables::.
Register variable; see *note Register Variables::.
 
`0x42 N_M2C'
Modula-2 compilation unit; see *Note N_M2C::.
Modula-2 compilation unit; see *note N_M2C::.
 
`0x44 N_SLINE'
Line number in text segment; see *Note Line Numbers::.
Line number in text segment; see *note Line Numbers::.
 
`0x46 N_DSLINE'
Line number in data segment; see *Note Line Numbers::.
Line number in data segment; see *note Line Numbers::.
 
`0x48 N_BSLINE'
Line number in bss segment; see *Note Line Numbers::.
Line number in bss segment; see *note Line Numbers::.
 
`0x48 N_BROWS'
Sun source code browser, path to `.cb' file; see *Note N_BROWS::.
Sun source code browser, path to `.cb' file; see *note N_BROWS::.
 
`0x4a N_DEFD'
GNU Modula2 definition module dependency; see *Note N_DEFD::.
GNU Modula2 definition module dependency; see *note N_DEFD::.
 
`0x4c N_FLINE'
Function start/body/end line numbers (Solaris2).
 
`0x50 N_EHDECL'
GNU C++ exception variable; see *Note N_EHDECL::.
GNU C++ exception variable; see *note N_EHDECL::.
 
`0x50 N_MOD2'
Modula2 info "for imc" (according to Ultrix V4.0); see *Note
Modula2 info "for imc" (according to Ultrix V4.0); see *note
N_MOD2::.
 
`0x54 N_CATCH'
GNU C++ `catch' clause; see *Note N_CATCH::.
GNU C++ `catch' clause; see *note N_CATCH::.
 
`0x60 N_SSYM'
Structure of union element; see *Note N_SSYM::.
Structure of union element; see *note N_SSYM::.
 
`0x62 N_ENDM'
Last stab for module (Solaris2).
 
`0x64 N_SO'
Path and name of source file; see *Note Source Files::.
Path and name of source file; see *note Source Files::.
 
`0x80 N_LSYM'
Stack variable (*note Stack Variables::) or type (*note
3209,58 → 3209,58
Typedefs::).
 
`0x82 N_BINCL'
Beginning of an include file (Sun only); see *Note Include Files::.
Beginning of an include file (Sun only); see *note Include Files::.
 
`0x84 N_SOL'
Name of include file; see *Note Include Files::.
Name of include file; see *note Include Files::.
 
`0xa0 N_PSYM'
Parameter variable; see *Note Parameters::.
Parameter variable; see *note Parameters::.
 
`0xa2 N_EINCL'
End of an include file; see *Note Include Files::.
End of an include file; see *note Include Files::.
 
`0xa4 N_ENTRY'
Alternate entry point; see *Note Alternate Entry Points::.
Alternate entry point; see *note Alternate Entry Points::.
 
`0xc0 N_LBRAC'
Beginning of a lexical block; see *Note Block Structure::.
Beginning of a lexical block; see *note Block Structure::.
 
`0xc2 N_EXCL'
Place holder for a deleted include file; see *Note Include Files::.
Place holder for a deleted include file; see *note Include Files::.
 
`0xc4 N_SCOPE'
Modula2 scope information (Sun linker); see *Note N_SCOPE::.
Modula2 scope information (Sun linker); see *note N_SCOPE::.
 
`0xe0 N_RBRAC'
End of a lexical block; see *Note Block Structure::.
End of a lexical block; see *note Block Structure::.
 
`0xe2 N_BCOMM'
Begin named common block; see *Note Common Blocks::.
Begin named common block; see *note Common Blocks::.
 
`0xe4 N_ECOMM'
End named common block; see *Note Common Blocks::.
End named common block; see *note Common Blocks::.
 
`0xe8 N_ECOML'
Member of a common block; see *Note Common Blocks::.
Member of a common block; see *note Common Blocks::.
 
`0xea N_WITH'
Pascal `with' statement: type,,0,0,offset (Solaris2).
 
`0xf0 N_NBTEXT'
Gould non-base registers; see *Note Gould::.
Gould non-base registers; see *note Gould::.
 
`0xf2 N_NBDATA'
Gould non-base registers; see *Note Gould::.
Gould non-base registers; see *note Gould::.
 
`0xf4 N_NBBSS'
Gould non-base registers; see *Note Gould::.
Gould non-base registers; see *note Gould::.
 
`0xf6 N_NBSTS'
Gould non-base registers; see *Note Gould::.
Gould non-base registers; see *note Gould::.
 
`0xf8 N_NBLCS'
Gould non-base registers; see *Note Gould::.
Gould non-base registers; see *note Gould::.
 

File: stabs.info, Node: Symbol Descriptors, Next: Type Descriptors, Prev: Stab Types, Up: Top
3275,108 → 3275,108
`DIGIT'
`('
`-'
Variable on the stack; see *Note Stack Variables::.
Variable on the stack; see *note Stack Variables::.
 
`:'
C++ nested symbol; see *Note Nested Symbols::.
 
`a'
Parameter passed by reference in register; see *Note Reference
Parameter passed by reference in register; see *note Reference
Parameters::.
 
`b'
Based variable; see *Note Based Variables::.
Based variable; see *note Based Variables::.
 
`c'
Constant; see *Note Constants::.
Constant; see *note Constants::.
 
`C'
Conformant array bound (Pascal, maybe other languages); *Note
Conformant array bound (Pascal, maybe other languages); *note
Conformant Arrays::. Name of a caught exception (GNU C++). These
can be distinguished because the latter uses `N_CATCH' and the
former uses another symbol type.
 
`d'
Floating point register variable; see *Note Register Variables::.
Floating point register variable; see *note Register Variables::.
 
`D'
Parameter in floating point register; see *Note Register
Parameter in floating point register; see *note Register
Parameters::.
 
`f'
File scope function; see *Note Procedures::.
File scope function; see *note Procedures::.
 
`F'
Global function; see *Note Procedures::.
Global function; see *note Procedures::.
 
`G'
Global variable; see *Note Global Variables::.
Global variable; see *note Global Variables::.
 
`i'
*Note Register Parameters::.
 
`I'
Internal (nested) procedure; see *Note Nested Procedures::.
Internal (nested) procedure; see *note Nested Procedures::.
 
`J'
Internal (nested) function; see *Note Nested Procedures::.
Internal (nested) function; see *note Nested Procedures::.
 
`L'
Label name (documented by AIX, no further information known).
 
`m'
Module; see *Note Procedures::.
Module; see *note Procedures::.
 
`p'
Argument list parameter; see *Note Parameters::.
Argument list parameter; see *note Parameters::.
 
`pP'
*Note Parameters::.
 
`pF'
Fortran Function parameter; see *Note Parameters::.
Fortran Function parameter; see *note Parameters::.
 
`P'
Unfortunately, three separate meanings have been independently
invented for this symbol descriptor. At least the GNU and Sun
uses can be distinguished by the symbol type. Global Procedure
(AIX) (symbol type used unknown); see *Note Procedures::.
Register parameter (GNU) (symbol type `N_PSYM'); see *Note
(AIX) (symbol type used unknown); see *note Procedures::.
Register parameter (GNU) (symbol type `N_PSYM'); see *note
Parameters::. Prototype of function referenced by this file (Sun
`acc') (symbol type `N_FUN').
 
`Q'
Static Procedure; see *Note Procedures::.
Static Procedure; see *note Procedures::.
 
`R'
Register parameter; see *Note Register Parameters::.
Register parameter; see *note Register Parameters::.
 
`r'
Register variable; see *Note Register Variables::.
Register variable; see *note Register Variables::.
 
`S'
File scope variable; see *Note Statics::.
File scope variable; see *note Statics::.
 
`s'
Local variable (OS9000).
 
`t'
Type name; see *Note Typedefs::.
Type name; see *note Typedefs::.
 
`T'
Enumeration, structure, or union tag; see *Note Typedefs::.
Enumeration, structure, or union tag; see *note Typedefs::.
 
`v'
Parameter passed by reference; see *Note Reference Parameters::.
Parameter passed by reference; see *note Reference Parameters::.
 
`V'
Procedure scope static variable; see *Note Statics::.
Procedure scope static variable; see *note Statics::.
 
`x'
Conformant array; see *Note Conformant Arrays::.
Conformant array; see *note Conformant Arrays::.
 
`X'
Function return variable; see *Note Parameters::.
Function return variable; see *note Parameters::.
 

File: stabs.info, Node: Type Descriptors, Next: Expanded Reference, Prev: Symbol Descriptors, Up: Top
3390,40 → 3390,40
 
`DIGIT'
`('
Type reference; see *Note String Field::.
Type reference; see *note String Field::.
 
`-'
Reference to builtin type; see *Note Negative Type Numbers::.
Reference to builtin type; see *note Negative Type Numbers::.
 
`#'
Method (C++); see *Note Method Type Descriptor::.
Method (C++); see *note Method Type Descriptor::.
 
`*'
Pointer; see *Note Miscellaneous Types::.
Pointer; see *note Miscellaneous Types::.
 
`&'
Reference (C++).
 
`@'
Type Attributes (AIX); see *Note String Field::. Member (class
and variable) type (GNU C++); see *Note Member Type Descriptor::.
Type Attributes (AIX); see *note String Field::. Member (class
and variable) type (GNU C++); see *note Member Type Descriptor::.
 
`a'
Array; see *Note Arrays::.
Array; see *note Arrays::.
 
`A'
Open array; see *Note Arrays::.
Open array; see *note Arrays::.
 
`b'
Pascal space type (AIX); see *Note Miscellaneous Types::. Builtin
integer type (Sun); see *Note Builtin Type Descriptors::. Const
Pascal space type (AIX); see *note Miscellaneous Types::. Builtin
integer type (Sun); see *note Builtin Type Descriptors::. Const
and volatile qualified type (OS9000).
 
`B'
Volatile-qualified type; see *Note Miscellaneous Types::.
Volatile-qualified type; see *note Miscellaneous Types::.
 
`c'
Complex builtin type (AIX); see *Note Builtin Type Descriptors::.
Complex builtin type (AIX); see *note Builtin Type Descriptors::.
Const-qualified type (OS9000).
 
`C'
3430,75 → 3430,75
COBOL Picture type. See AIX documentation for details.
 
`d'
File type; see *Note Miscellaneous Types::.
File type; see *note Miscellaneous Types::.
 
`D'
N-dimensional dynamic array; see *Note Arrays::.
N-dimensional dynamic array; see *note Arrays::.
 
`e'
Enumeration type; see *Note Enumerations::.
Enumeration type; see *note Enumerations::.
 
`E'
N-dimensional subarray; see *Note Arrays::.
N-dimensional subarray; see *note Arrays::.
 
`f'
Function type; see *Note Function Types::.
Function type; see *note Function Types::.
 
`F'
Pascal function parameter; see *Note Function Types::
Pascal function parameter; see *note Function Types::
 
`g'
Builtin floating point type; see *Note Builtin Type Descriptors::.
Builtin floating point type; see *note Builtin Type Descriptors::.
 
`G'
COBOL Group. See AIX documentation for details.
 
`i'
Imported type (AIX); see *Note Cross-References::.
Imported type (AIX); see *note Cross-References::.
Volatile-qualified type (OS9000).
 
`k'
Const-qualified type; see *Note Miscellaneous Types::.
Const-qualified type; see *note Miscellaneous Types::.
 
`K'
COBOL File Descriptor. See AIX documentation for details.
 
`M'
Multiple instance type; see *Note Miscellaneous Types::.
Multiple instance type; see *note Miscellaneous Types::.
 
`n'
String type; see *Note Strings::.
String type; see *note Strings::.
 
`N'
Stringptr; see *Note Strings::.
Stringptr; see *note Strings::.
 
`o'
Opaque type; see *Note Typedefs::.
Opaque type; see *note Typedefs::.
 
`p'
Procedure; see *Note Function Types::.
Procedure; see *note Function Types::.
 
`P'
Packed array; see *Note Arrays::.
Packed array; see *note Arrays::.
 
`r'
Range type; see *Note Subranges::.
Range type; see *note Subranges::.
 
`R'
Builtin floating type; see *Note Builtin Type Descriptors:: (Sun).
Pascal subroutine parameter; see *Note Function Types:: (AIX).
Builtin floating type; see *note Builtin Type Descriptors:: (Sun).
Pascal subroutine parameter; see *note Function Types:: (AIX).
Detecting this conflict is possible with careful parsing (hint: a
Pascal subroutine parameter type will always contain a comma, and
a builtin type descriptor never will).
 
`s'
Structure type; see *Note Structures::.
Structure type; see *note Structures::.
 
`S'
Set type; see *Note Miscellaneous Types::.
Set type; see *note Miscellaneous Types::.
 
`u'
Union; see *Note Unions::.
Union; see *note Unions::.
 
`v'
Variant record. This is a Pascal and Modula-2 feature which is
3506,16 → 3506,16
details.
 
`w'
Wide character; see *Note Builtin Type Descriptors::.
Wide character; see *note Builtin Type Descriptors::.
 
`x'
Cross-reference; see *Note Cross-References::.
Cross-reference; see *note Cross-References::.
 
`Y'
Used by IBM's xlC C++ compiler (for structures, I think).
 
`z'
gstring; see *Note Strings::.
gstring; see *note Strings::.
 

File: stabs.info, Node: Expanded Reference, Next: Questions, Prev: Type Descriptors, Up: Top
3524,7 → 3524,7
******************************************
 
For a full list of stab types, and cross-references to where they are
described, see *Note Stab Types::. This appendix just covers certain
described, see *note Stab Types::. This appendix just covers certain
stabs which are not yet described in the main body of this document;
eventually the information will all be in one place.
 
4493,98 → 4493,98
 

Tag Table:
Node: Top1534
Node: Overview2581
Node: Flow3996
Node: Stabs Format5522
Node: String Field7084
Node: C Example12515
Node: Assembly Code13060
Node: Program Structure15031
Node: Main Program15757
Node: Source Files16318
Node: Include Files18770
Node: Line Numbers21435
Node: Procedures22969
Node: Nested Procedures28859
Node: Block Structure30035
Node: Alternate Entry Points31441
Node: Constants32174
Node: Variables35286
Node: Stack Variables35974
Node: Global Variables37675
Node: Register Variables38831
Node: Common Blocks39653
Node: Statics40907
Node: Based Variables43486
Node: Parameters44871
Node: Register Parameters46483
Node: Local Variable Parameters48744
Node: Reference Parameters51659
Node: Conformant Arrays52279
Node: Types52996
Node: Builtin Types53943
Node: Traditional Builtin Types55089
Node: Traditional Integer Types55490
Node: Traditional Other Types57798
Node: Builtin Type Descriptors58712
Node: Negative Type Numbers62212
Node: Miscellaneous Types68567
Node: Cross-References70453
Node: Subranges72128
Node: Arrays73367
Node: Strings76592
Node: Enumerations77654
Node: Structures80039
Node: Typedefs82746
Node: Unions84070
Node: Function Types85651
Node: Macro define and undefine87233
Node: Symbol Tables88810
Node: Symbol Table Format89262
Node: Transformations On Symbol Tables90710
Node: Transformations On Static Variables92064
Node: Transformations On Global Variables92800
Node: Stab Section Transformations94043
Node: Cplusplus95426
Node: Class Names96009
Node: Nested Symbols96754
Node: Basic Cplusplus Types97600
Node: Simple Classes99160
Node: Class Instance103454
Node: Methods104171
Node: Method Type Descriptor106390
Node: Member Type Descriptor107590
Node: Protections108382
Node: Method Modifiers111472
Node: Virtual Methods113100
Node: Inheritance116901
Node: Virtual Base Classes120597
Node: Static Members122841
Node: Stab Types123311
Node: Non-Stab Symbol Types123935
Node: Stab Symbol Types125366
Node: Symbol Descriptors129297
Node: Type Descriptors132076
Node: Expanded Reference135288
Node: N_PC136706
Node: N_NSYMS137074
Node: N_NOMAP137315
Node: N_M2C137621
Node: N_BROWS138055
Node: N_DEFD138338
Node: N_EHDECL138795
Node: N_MOD2139046
Node: N_CATCH139284
Node: N_SSYM139778
Node: N_SCOPE140063
Node: Gould140253
Node: N_LENG141245
Node: Questions141473
Node: Stab Sections143117
Node: Stab Section Basics143715
Node: ELF Linker Relocation147056
Node: GNU Free Documentation License150466
Node: Symbol Types Index175623
Node: Top1535
Node: Overview2582
Node: Flow3997
Node: Stabs Format5523
Node: String Field7085
Node: C Example12516
Node: Assembly Code13061
Node: Program Structure15032
Node: Main Program15758
Node: Source Files16319
Node: Include Files18771
Node: Line Numbers21436
Node: Procedures22970
Node: Nested Procedures28860
Node: Block Structure30036
Node: Alternate Entry Points31442
Node: Constants32175
Node: Variables35287
Node: Stack Variables35975
Node: Global Variables37676
Node: Register Variables38832
Node: Common Blocks39654
Node: Statics40908
Node: Based Variables43487
Node: Parameters44872
Node: Register Parameters46484
Node: Local Variable Parameters48745
Node: Reference Parameters51660
Node: Conformant Arrays52280
Node: Types52997
Node: Builtin Types53944
Node: Traditional Builtin Types55090
Node: Traditional Integer Types55491
Node: Traditional Other Types57799
Node: Builtin Type Descriptors58713
Node: Negative Type Numbers62213
Node: Miscellaneous Types68568
Node: Cross-References70454
Node: Subranges72129
Node: Arrays73368
Node: Strings76593
Node: Enumerations77655
Node: Structures80040
Node: Typedefs82747
Node: Unions84071
Node: Function Types85652
Node: Macro define and undefine87234
Node: Symbol Tables88811
Node: Symbol Table Format89263
Node: Transformations On Symbol Tables90711
Node: Transformations On Static Variables92065
Node: Transformations On Global Variables92801
Node: Stab Section Transformations94044
Node: Cplusplus95427
Node: Class Names96010
Node: Nested Symbols96755
Node: Basic Cplusplus Types97601
Node: Simple Classes99161
Node: Class Instance103455
Node: Methods104172
Node: Method Type Descriptor106391
Node: Member Type Descriptor107591
Node: Protections108383
Node: Method Modifiers111473
Node: Virtual Methods113101
Node: Inheritance116902
Node: Virtual Base Classes120598
Node: Static Members122842
Node: Stab Types123312
Node: Non-Stab Symbol Types123936
Node: Stab Symbol Types125367
Node: Symbol Descriptors129298
Node: Type Descriptors132077
Node: Expanded Reference135289
Node: N_PC136707
Node: N_NSYMS137075
Node: N_NOMAP137316
Node: N_M2C137622
Node: N_BROWS138056
Node: N_DEFD138339
Node: N_EHDECL138796
Node: N_MOD2139047
Node: N_CATCH139285
Node: N_SSYM139779
Node: N_SCOPE140064
Node: Gould140254
Node: N_LENG141246
Node: Questions141474
Node: Stab Sections143118
Node: Stab Section Basics143716
Node: ELF Linker Relocation147057
Node: GNU Free Documentation License150467
Node: Symbol Types Index175624

End Tag Table
/gnu-src/gdb-7.2/gdb/doc/GDBvn.texi
1,4 → 1,4
@set GDBVN 7.2
@set GDBVN 7.2-or32-1.0rc1
@set VERSION_PACKAGE (GDB)
@set BUGURL @uref{http://www.gnu.org/software/gdb/bugs/}
@set BUGURL_DEFAULT
/gnu-src/gdb-7.2/gdb/f-exp.c
1,30 → 1,39
/* A Bison parser, made by GNU Bison 1.875c. */
 
/* Skeleton parser for Yacc-like parsing with Bison,
Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
/* A Bison parser, made by GNU Bison 2.4.1. */
 
This program is free software; you can redistribute it and/or modify
/* 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.
 
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., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
along with this program. If not, see <http://www.gnu.org/licenses/>. */
 
/* As a special exception, when this file is copied by Bison into a
Bison output file, you may use that output file without restriction.
This special exception was added by the Free Software Foundation
in version 1.24 of Bison. */
/* 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. */
 
/* Written by Richard Stallman by simplifying the original so called
``semantic'' parser. */
/* 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
36,6 → 45,9
/* Identify Bison output. */
#define YYBISON 1
 
/* Bison version. */
#define YYBISON_VERSION "2.4.1"
 
/* Skeleton name. */
#define YYSKELETON_NAME "yacc.c"
 
42,100 → 54,20
/* Pure parsers. */
#define YYPURE 0
 
/* Push parsers. */
#define YYPUSH 0
 
/* Pull parsers. */
#define YYPULL 1
 
/* 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 {
INT = 258,
FLOAT = 259,
STRING_LITERAL = 260,
BOOLEAN_LITERAL = 261,
NAME = 262,
TYPENAME = 263,
NAME_OR_INT = 264,
SIZEOF = 265,
ERROR = 266,
INT_KEYWORD = 267,
INT_S2_KEYWORD = 268,
LOGICAL_S1_KEYWORD = 269,
LOGICAL_S2_KEYWORD = 270,
LOGICAL_S8_KEYWORD = 271,
LOGICAL_KEYWORD = 272,
REAL_KEYWORD = 273,
REAL_S8_KEYWORD = 274,
REAL_S16_KEYWORD = 275,
COMPLEX_S8_KEYWORD = 276,
COMPLEX_S16_KEYWORD = 277,
COMPLEX_S32_KEYWORD = 278,
BOOL_AND = 279,
BOOL_OR = 280,
BOOL_NOT = 281,
CHARACTER = 282,
VARIABLE = 283,
ASSIGN_MODIFY = 284,
ABOVE_COMMA = 285,
NOTEQUAL = 286,
EQUAL = 287,
GEQ = 288,
LEQ = 289,
GREATERTHAN = 290,
LESSTHAN = 291,
RSH = 292,
LSH = 293,
STARSTAR = 294,
UNARY = 295
};
#endif
#define INT 258
#define FLOAT 259
#define STRING_LITERAL 260
#define BOOLEAN_LITERAL 261
#define NAME 262
#define TYPENAME 263
#define NAME_OR_INT 264
#define SIZEOF 265
#define ERROR 266
#define INT_KEYWORD 267
#define INT_S2_KEYWORD 268
#define LOGICAL_S1_KEYWORD 269
#define LOGICAL_S2_KEYWORD 270
#define LOGICAL_S8_KEYWORD 271
#define LOGICAL_KEYWORD 272
#define REAL_KEYWORD 273
#define REAL_S8_KEYWORD 274
#define REAL_S16_KEYWORD 275
#define COMPLEX_S8_KEYWORD 276
#define COMPLEX_S16_KEYWORD 277
#define COMPLEX_S32_KEYWORD 278
#define BOOL_AND 279
#define BOOL_OR 280
#define BOOL_NOT 281
#define CHARACTER 282
#define VARIABLE 283
#define ASSIGN_MODIFY 284
#define ABOVE_COMMA 285
#define NOTEQUAL 286
#define EQUAL 287
#define GEQ 288
#define LEQ 289
#define GREATERTHAN 290
#define LESSTHAN 291
#define RSH 292
#define LSH 293
#define STARSTAR 294
#define UNARY 295
/* Copy the first part of user declarations. */
 
 
 
 
/* Copy the first part of user declarations. */
/* Line 189 of yacc.c */
#line 44 "f-exp.y"
 
 
221,6 → 153,9
 
 
 
/* Line 189 of yacc.c */
#line 158 "f-exp.c.tmp"
 
/* Enabling traces. */
#ifndef YYDEBUG
# define YYDEBUG 0
234,9 → 169,108
# define YYERROR_VERBOSE 0
#endif
 
#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
/* Enabling the token table. */
#ifndef YYTOKEN_TABLE
# define YYTOKEN_TABLE 0
#endif
 
 
/* Tokens. */
#ifndef YYTOKENTYPE
# define YYTOKENTYPE
/* Put the tokens into the symbol table, so that GDB and other debuggers
know about them. */
enum yytokentype {
INT = 258,
FLOAT = 259,
STRING_LITERAL = 260,
BOOLEAN_LITERAL = 261,
NAME = 262,
TYPENAME = 263,
NAME_OR_INT = 264,
SIZEOF = 265,
ERROR = 266,
INT_KEYWORD = 267,
INT_S2_KEYWORD = 268,
LOGICAL_S1_KEYWORD = 269,
LOGICAL_S2_KEYWORD = 270,
LOGICAL_S8_KEYWORD = 271,
LOGICAL_KEYWORD = 272,
REAL_KEYWORD = 273,
REAL_S8_KEYWORD = 274,
REAL_S16_KEYWORD = 275,
COMPLEX_S8_KEYWORD = 276,
COMPLEX_S16_KEYWORD = 277,
COMPLEX_S32_KEYWORD = 278,
BOOL_AND = 279,
BOOL_OR = 280,
BOOL_NOT = 281,
CHARACTER = 282,
VARIABLE = 283,
ASSIGN_MODIFY = 284,
ABOVE_COMMA = 285,
NOTEQUAL = 286,
EQUAL = 287,
GEQ = 288,
LEQ = 289,
GREATERTHAN = 290,
LESSTHAN = 291,
RSH = 292,
LSH = 293,
STARSTAR = 294,
UNARY = 295
};
#endif
/* Tokens. */
#define INT 258
#define FLOAT 259
#define STRING_LITERAL 260
#define BOOLEAN_LITERAL 261
#define NAME 262
#define TYPENAME 263
#define NAME_OR_INT 264
#define SIZEOF 265
#define ERROR 266
#define INT_KEYWORD 267
#define INT_S2_KEYWORD 268
#define LOGICAL_S1_KEYWORD 269
#define LOGICAL_S2_KEYWORD 270
#define LOGICAL_S8_KEYWORD 271
#define LOGICAL_KEYWORD 272
#define REAL_KEYWORD 273
#define REAL_S8_KEYWORD 274
#define REAL_S16_KEYWORD 275
#define COMPLEX_S8_KEYWORD 276
#define COMPLEX_S16_KEYWORD 277
#define COMPLEX_S32_KEYWORD 278
#define BOOL_AND 279
#define BOOL_OR 280
#define BOOL_NOT 281
#define CHARACTER 282
#define VARIABLE 283
#define ASSIGN_MODIFY 284
#define ABOVE_COMMA 285
#define NOTEQUAL 286
#define EQUAL 287
#define GEQ 288
#define LEQ 289
#define GREATERTHAN 290
#define LESSTHAN 291
#define RSH 292
#define LSH 293
#define STARSTAR 294
#define UNARY 295
 
 
 
 
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
typedef union YYSTYPE
{
 
/* Line 214 of yacc.c */
#line 133 "f-exp.y"
typedef union YYSTYPE {
 
LONGEST lval;
struct {
LONGEST val;
255,17 → 289,21
 
struct type **tvec;
int *ivec;
} YYSTYPE;
/* Line 191 of yacc.c. */
#line 261 "f-exp.c.tmp"
 
 
/* Line 214 of yacc.c */
#line 297 "f-exp.c.tmp"
} YYSTYPE;
# define YYSTYPE_IS_TRIVIAL 1
# 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. */
 
/* Copy the second part of user declarations. */
/* Line 264 of yacc.c */
#line 154 "f-exp.y"
 
/* YYSTYPE gets defined by %union */
272,58 → 310,172
static int parse_number (char *, int, int, YYSTYPE *);
 
 
/* Line 214 of yacc.c. */
#line 277 "f-exp.c.tmp"
/* Line 264 of yacc.c */
#line 315 "f-exp.c.tmp"
 
#if ! defined (yyoverflow) || YYERROR_VERBOSE
#ifdef short
# undef short
#endif
 
# ifndef YYFREE
# define YYFREE xfree
#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
# ifndef YYMALLOC
# define YYMALLOC xmalloc
#endif
 
#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
 
#ifndef YY_
# if 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 yyi)
#else
static int
YYID (yyi)
int yyi;
#endif
{
return yyi;
}
#endif
 
#if ! defined yyoverflow || YYERROR_VERBOSE
 
/* The parser invokes alloca or xmalloc; define the necessary symbols. */
 
# ifdef YYSTACK_USE_ALLOCA
# if YYSTACK_USE_ALLOCA
# define YYSTACK_ALLOC alloca
# endif
# else
# if defined (alloca) || defined (_ALLOCA_H)
# define YYSTACK_ALLOC alloca
# else
# 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
# 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 (0)
/* 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
# if defined (__STDC__) || defined (__cplusplus)
# 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 xmalloc) \
&& (defined YYFREE || defined xfree)))
# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
# define YYSIZE_T size_t
# ifndef _STDLIB_H
# define _STDLIB_H 1
# endif
# endif
# define YYSTACK_ALLOC YYMALLOC
# define YYSTACK_FREE YYFREE
# ifndef YYMALLOC
# define YYMALLOC xmalloc
# if ! defined xmalloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
void *xmalloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
# endif
# endif
# ifndef YYFREE
# define YYFREE xfree
# if ! defined xfree && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
void xfree (void *); /* INFRINGES ON USER NAME SPACE */
# endif
# endif
# endif
#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
 
 
#if (! defined (yyoverflow) \
&& (! defined (__cplusplus) \
|| (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
#if (! defined yyoverflow \
&& (! defined __cplusplus \
|| (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
 
/* A type that is properly aligned for any stack member. */
union yyalloc
{
short yyss;
YYSTYPE yyvs;
};
yytype_int16 yyss_alloc;
YYSTYPE yyvs_alloc;
};
 
/* The size of the maximum gap between one aligned stack and the next. */
# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
331,13 → 483,13
/* The size of an array large to enough to hold all stacks, each with
N elements. */
# define YYSTACK_BYTES(N) \
((N) * (sizeof (short) + sizeof (YYSTYPE)) \
((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__
# if defined __GNUC__ && 1 < __GNUC__
# define YYCOPY(To, From, Count) \
__builtin_memcpy (To, From, (Count) * sizeof (*(From)))
# else
344,11 → 496,11
# define YYCOPY(To, From, Count) \
do \
{ \
register YYSIZE_T yyi; \
YYSIZE_T yyi; \
for (yyi = 0; yyi < (Count); yyi++) \
(To)[yyi] = (From)[yyi]; \
} \
while (0)
while (YYID (0))
# endif
# endif
 
357,37 → 509,31
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) \
# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
do \
{ \
YYSIZE_T yynewbytes; \
YYCOPY (&yyptr->Stack, Stack, yysize); \
Stack = &yyptr->Stack; \
YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
Stack = &yyptr->Stack_alloc; \
yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
yyptr += yynewbytes / sizeof (*yyptr); \
} \
while (0)
while (YYID (0))
 
#endif
 
#if defined (__STDC__) || defined (__cplusplus)
typedef signed char yysigned_char;
#else
typedef short yysigned_char;
#endif
 
/* YYFINAL -- State number of the termination state. */
/* YYFINAL -- State number of the termination state. */
#define YYFINAL 47
/* YYLAST -- Last index in YYTABLE. */
#define YYLAST 529
 
/* YYNTOKENS -- Number of terminals. */
/* YYNTOKENS -- Number of terminals. */
#define YYNTOKENS 57
/* YYNNTS -- Number of nonterminals. */
/* YYNNTS -- Number of nonterminals. */
#define YYNNTS 18
/* YYNRULES -- Number of rules. */
/* YYNRULES -- Number of rules. */
#define YYNRULES 86
/* YYNRULES -- Number of states. */
/* YYNRULES -- Number of states. */
#define YYNSTATES 131
 
/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
394,11 → 540,11
#define YYUNDEFTOK 2
#define YYMAXUTOK 295
 
#define YYTRANSLATE(YYX) \
#define YYTRANSLATE(YYX) \
((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
 
/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
static const unsigned char yytranslate[] =
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,
435,7 → 581,7
#if YYDEBUG
/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
YYRHS. */
static const unsigned char yyprhs[] =
static const yytype_uint8 yyprhs[] =
{
0, 0, 3, 5, 7, 9, 13, 16, 19, 22,
25, 28, 31, 32, 38, 39, 41, 43, 47, 51,
448,8 → 594,8
238, 240, 242, 244, 246, 250, 252
};
 
/* YYRHS -- A `-1'-separated list of the rules' RHS. */
static const yysigned_char yyrhs[] =
/* YYRHS -- A `-1'-separated list of the rules' RHS. */
static const yytype_int8 yyrhs[] =
{
58, 0, -1, 60, -1, 59, -1, 66, -1, 53,
60, 54, -1, 48, 60, -1, 36, 60, -1, 47,
480,7 → 626,7
};
 
/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
static const unsigned short yyrline[] =
static const yytype_uint16 yyrline[] =
{
0, 233, 233, 234, 237, 243, 248, 252, 256, 260,
264, 268, 278, 277, 285, 288, 292, 296, 302, 308,
494,9 → 640,9
};
#endif
 
#if YYDEBUG || YYERROR_VERBOSE
/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
First, the terminals, then, starting at YYNTOKENS, nonterminals. */
#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", "INT", "FLOAT", "STRING_LITERAL",
509,7 → 655,7
"ASSIGN_MODIFY", "','", "ABOVE_COMMA", "'='", "'?'", "'|'", "'^'", "'&'",
"NOTEQUAL", "EQUAL", "GEQ", "LEQ", "GREATERTHAN", "LESSTHAN", "RSH",
"LSH", "'@'", "'+'", "'-'", "'*'", "'/'", "STARSTAR", "'%'", "UNARY",
"'('", "')'", "'~'", "':'", "$accept", "start", "type_exp", "exp", "@1",
"'('", "')'", "'~'", "':'", "$accept", "start", "type_exp", "exp", "$@1",
"arglist", "subrange", "complexnum", "variable", "type", "ptype",
"abs_decl", "direct_abs_decl", "func_mod", "typebase",
"nonempty_typelist", "name", "name_not_typename", 0
519,7 → 665,7
# ifdef YYPRINT
/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
token YYLEX-NUM. */
static const unsigned short yytoknum[] =
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,
531,7 → 677,7
# endif
 
/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
static const unsigned char yyr1[] =
static const yytype_uint8 yyr1[] =
{
0, 57, 58, 58, 59, 60, 60, 60, 60, 60,
60, 60, 61, 60, 62, 62, 62, 62, 63, 63,
545,7 → 691,7
};
 
/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
static const unsigned char yyr2[] =
static const yytype_uint8 yyr2[] =
{
0, 2, 1, 1, 1, 3, 2, 2, 2, 2,
2, 2, 0, 5, 0, 1, 1, 3, 3, 2,
561,7 → 707,7
/* 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 unsigned char yydefact[] =
static const yytype_uint8 yydefact[] =
{
0, 47, 49, 54, 53, 86, 69, 48, 0, 70,
71, 76, 75, 73, 74, 77, 78, 79, 80, 81,
579,8 → 725,8
17
};
 
/* YYDEFGOTO[NTERM-NUM]. */
static const yysigned_char yydefgoto[] =
/* YYDEFGOTO[NTERM-NUM]. */
static const yytype_int8 yydefgoto[] =
{
-1, 29, 30, 43, 105, 119, 120, 44, 32, 109,
34, 74, 75, 76, 35, 111, 104, 36
589,7 → 735,7
/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
STATE-NUM. */
#define YYPACT_NINF -57
static const short yypact[] =
static const yytype_int16 yypact[] =
{
134, -57, -57, -57, -57, -57, -57, -57, 162, -57,
-57, -57, -57, -57, -57, -57, -57, -57, -57, -57,
608,7 → 754,7
};
 
/* YYPGOTO[NTERM-NUM]. */
static const yysigned_char yypgoto[] =
static const yytype_int8 yypgoto[] =
{
-57, -57, -57, 0, -57, -57, -57, -57, -57, 2,
-57, -56, -57, -30, -57, -57, -57, -57
619,7 → 765,7
number is the opposite. If zero, do what YYDEFACT says.
If YYTABLE_NINF, syntax error. */
#define YYTABLE_NINF -1
static const unsigned char yytable[] =
static const yytype_uint8 yytable[] =
{
31, 71, 33, 122, 68, 69, 126, 70, 38, 66,
67, 68, 69, 72, 70, 106, 107, 110, 73, 47,
676,7 → 822,7
62, 63, 64, 65, 66, 67, 68, 69, 0, 70
};
 
static const yysigned_char yycheck[] =
static const yytype_int8 yycheck[] =
{
0, 36, 0, 30, 50, 51, 30, 53, 8, 48,
49, 50, 51, 48, 53, 71, 72, 73, 53, 0,
735,7 → 881,7
 
/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
symbol of state STATE-NUM. */
static const unsigned char yystos[] =
static const yytype_uint8 yystos[] =
{
0, 3, 4, 5, 6, 7, 8, 9, 10, 12,
13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
753,22 → 899,6
60
};
 
#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
# define YYSIZE_T __SIZE_TYPE__
#endif
#if ! defined (YYSIZE_T) && defined (size_t)
# define YYSIZE_T size_t
#endif
#if ! defined (YYSIZE_T)
# if defined (__STDC__) || defined (__cplusplus)
# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
# define YYSIZE_T size_t
# endif
#endif
#if ! defined (YYSIZE_T)
# define YYSIZE_T unsigned int
#endif
 
#define yyerrok (yyerrstatus = 0)
#define yyclearin (yychar = YYEMPTY)
#define YYEMPTY (-2)
794,30 → 924,63
yychar = (Token); \
yylval = (Value); \
yytoken = YYTRANSLATE (yychar); \
YYPOPSTACK; \
YYPOPSTACK (1); \
goto yybackup; \
} \
else \
{ \
yyerror ("syntax error: cannot back up");\
{ \
yyerror (YY_("syntax error: cannot back up")); \
YYERROR; \
} \
while (0)
while (YYID (0))
 
 
#define YYTERROR 1
#define YYERRCODE 256
 
/* YYLLOC_DEFAULT -- Compute the default location (before the actions
are run). */
 
/* 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) \
((Current).first_line = (Rhs)[1].first_line, \
(Current).first_column = (Rhs)[1].first_column, \
(Current).last_line = (Rhs)[N].last_line, \
(Current).last_column = (Rhs)[N].last_column)
# 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 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
838,43 → 1001,100
do { \
if (yydebug) \
YYFPRINTF Args; \
} while (0)
} while (YYID (0))
 
# define YYDSYMPRINT(Args) \
do { \
if (yydebug) \
yysymprint Args; \
} while (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))
 
# define YYDSYMPRINTF(Title, Token, Value, Location) \
do { \
if (yydebug) \
{ \
YYFPRINTF (stderr, "%s ", Title); \
yysymprint (stderr, \
Token, Value); \
YYFPRINTF (stderr, "\n"); \
} \
} while (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 (__cplusplus)
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
static void
yy_stack_print (short *bottom, short *top)
yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
#else
static void
yy_stack_print (bottom, top)
short *bottom;
short *top;
yy_stack_print (yybottom, yytop)
yytype_int16 *yybottom;
yytype_int16 *yytop;
#endif
{
YYFPRINTF (stderr, "Stack now");
for (/* Nothing. */; bottom <= top; ++bottom)
YYFPRINTF (stderr, " %d", *bottom);
for (; yybottom <= yytop; yybottom++)
{
int yybot = *yybottom;
YYFPRINTF (stderr, " %d", yybot);
}
YYFPRINTF (stderr, "\n");
}
 
882,7 → 1102,7
do { \
if (yydebug) \
yy_stack_print ((Bottom), (Top)); \
} while (0)
} while (YYID (0))
 
 
/*------------------------------------------------.
889,30 → 1109,38
| Report that the YYRULE is going to be reduced. |
`------------------------------------------------*/
 
#if defined (__STDC__) || defined (__cplusplus)
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
static void
yy_reduce_print (int yyrule)
yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
#else
static void
yy_reduce_print (yyrule)
yy_reduce_print (yyvsp, yyrule)
YYSTYPE *yyvsp;
int yyrule;
#endif
{
int yynrhs = yyr2[yyrule];
int yyi;
unsigned int yylno = yyrline[yyrule];
YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
yyrule - 1, yylno);
/* Print the symbols being reduced, and their result. */
for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);
YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);
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++)
{
YYFPRINTF (stderr, " $%d = ", yyi + 1);
yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
&(yyvsp[(yyi + 1) - (yynrhs)])
);
YYFPRINTF (stderr, "\n");
}
}
 
# define YY_REDUCE_PRINT(Rule) \
do { \
if (yydebug) \
yy_reduce_print (Rule); \
} while (0)
yy_reduce_print (yyvsp, Rule); \
} while (YYID (0))
 
/* Nonzero means print parse trace. It is left uninitialized so that
multiple parsers can coexist. */
919,8 → 1147,7
int yydebug;
#else /* !YYDEBUG */
# define YYDPRINTF(Args)
# define YYDSYMPRINT(Args)
# define YYDSYMPRINTF(Title, Token, Value, Location)
# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
# define YY_STACK_PRINT(Bottom, Top)
# define YY_REDUCE_PRINT(Rule)
#endif /* !YYDEBUG */
935,13 → 1162,9
if the built-in stack extension method is used).
 
Do not make this value too large; the results are undefined if
SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
evaluated with infinite-precision integer arithmetic. */
 
#if defined (YYMAXDEPTH) && YYMAXDEPTH == 0
# undef YYMAXDEPTH
#endif
 
#ifndef YYMAXDEPTH
# define YYMAXDEPTH 10000
#endif
951,45 → 1174,47
#if YYERROR_VERBOSE
 
# ifndef yystrlen
# if defined (__GLIBC__) && defined (_STRING_H)
# 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
# if defined (__STDC__) || defined (__cplusplus)
yystrlen (const char *yystr)
# else
#else
static YYSIZE_T
yystrlen (yystr)
const char *yystr;
# endif
const char *yystr;
#endif
{
register const char *yys = yystr;
 
while (*yys++ != '\0')
YYSIZE_T yylen;
for (yylen = 0; yystr[yylen]; yylen++)
continue;
 
return yys - yystr - 1;
return yylen;
}
# endif
# endif
 
# ifndef yystpcpy
# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
# 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 *
# if defined (__STDC__) || defined (__cplusplus)
yystpcpy (char *yydest, const char *yysrc)
# else
#else
static char *
yystpcpy (yydest, yysrc)
char *yydest;
const char *yysrc;
# endif
char *yydest;
const char *yysrc;
#endif
{
register char *yyd = yydest;
register const char *yys = yysrc;
char *yyd = yydest;
const char *yys = yysrc;
 
while ((*yyd++ = *yys++) != '\0')
continue;
999,84 → 1224,204
# endif
# endif
 
#endif /* !YYERROR_VERBOSE */
# 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;
 
#if YYDEBUG
/*--------------------------------.
| Print this symbol on YYOUTPUT. |
`--------------------------------*/
case '\\':
if (*++yyp != '\\')
goto do_not_strip_quotes;
/* Fall through. */
default:
if (yyres)
yyres[yyn] = *yyp;
yyn++;
break;
 
#if defined (__STDC__) || defined (__cplusplus)
static void
yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
#else
static void
yysymprint (yyoutput, yytype, yyvaluep)
FILE *yyoutput;
int yytype;
YYSTYPE *yyvaluep;
#endif
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)
{
/* Pacify ``unused variable'' warnings. */
(void) yyvaluep;
int yyn = yypact[yystate];
 
if (yytype < YYNTOKENS)
if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
return 0;
else
{
YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
# ifdef YYPRINT
YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
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
}
else
YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
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;
 
switch (yytype)
{
default:
break;
/* 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;
}
YYFPRINTF (yyoutput, ")");
}
#endif /* YYERROR_VERBOSE */
 
#endif /* ! YYDEBUG */
/*-----------------------------------------------.
| Release the memory associated to this symbol. |
`-----------------------------------------------*/
 
#if defined (__STDC__) || defined (__cplusplus)
/*ARGSUSED*/
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
static void
yydestruct (int yytype, YYSTYPE *yyvaluep)
yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
#else
static void
yydestruct (yytype, yyvaluep)
yydestruct (yymsg, yytype, yyvaluep)
const char *yymsg;
int yytype;
YYSTYPE *yyvaluep;
#endif
{
/* Pacify ``unused variable'' warnings. */
(void) yyvaluep;
YYUSE (yyvaluep);
 
if (!yymsg)
yymsg = "Deleting";
YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
 
switch (yytype)
{
 
default:
break;
break;
}
}
 
/* Prevent warnings from -Wmissing-prototypes. */
 
#ifdef YYPARSE_PARAM
# if defined (__STDC__) || defined (__cplusplus)
#if defined __STDC__ || defined __cplusplus
int yyparse (void *YYPARSE_PARAM);
# else
#else
int yyparse ();
# endif
#endif
#else /* ! YYPARSE_PARAM */
#if defined (__STDC__) || defined (__cplusplus)
#if defined __STDC__ || defined __cplusplus
int yyparse (void);
#else
int yyparse ();
1084,7 → 1429,6
#endif /* ! YYPARSE_PARAM */
 
 
 
/* The lookahead symbol. */
int yychar;
 
1096,19 → 1440,23
 
 
 
/*----------.
| yyparse. |
`----------*/
/*-------------------------.
| yyparse or yypush_parse. |
`-------------------------*/
 
#ifdef YYPARSE_PARAM
# if defined (__STDC__) || defined (__cplusplus)
int yyparse (void *YYPARSE_PARAM)
# else
int yyparse (YYPARSE_PARAM)
void *YYPARSE_PARAM;
# endif
#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 (__cplusplus)
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
int
yyparse (void)
#else
1118,60 → 1466,68
#endif
#endif
{
register int yystate;
register int yyn;
int yyresult;
/* Number of tokens to shift before error messages enabled. */
int yyerrstatus;
/* Lookahead token as an internal (translated) token number. */
int yytoken = 0;
 
/* 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 xreallocate them elsewhere. */
int yystate;
/* Number of tokens to shift before error messages enabled. */
int yyerrstatus;
 
/* The state stack. */
short yyssa[YYINITDEPTH];
short *yyss = yyssa;
register short *yyssp;
/* The stacks and their tools:
`yyss': related to states.
`yyvs': related to semantic values.
 
/* The semantic value stack. */
YYSTYPE yyvsa[YYINITDEPTH];
YYSTYPE *yyvs = yyvsa;
register YYSTYPE *yyvsp;
Refer to the stacks thru separate pointers, to allow yyoverflow
to xreallocate them elsewhere. */
 
/* The state stack. */
yytype_int16 yyssa[YYINITDEPTH];
yytype_int16 *yyss;
yytype_int16 *yyssp;
 
/* The semantic value stack. */
YYSTYPE yyvsa[YYINITDEPTH];
YYSTYPE *yyvs;
YYSTYPE *yyvsp;
 
#define YYPOPSTACK (yyvsp--, yyssp--)
YYSIZE_T yystacksize;
 
YYSIZE_T yystacksize = YYINITDEPTH;
 
int yyn;
int yyresult;
/* Lookahead token as an internal (translated) token number. */
int yytoken;
/* The variables used to return semantic value and location from the
action routines. */
YYSTYPE yyval;
 
#if YYERROR_VERBOSE
/* Buffer for error messages, and its allocated size. */
char yymsgbuf[128];
char *yymsg = yymsgbuf;
YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
#endif
 
/* When reducing, the number of symbols on the RHS of the reduced
rule. */
int yylen;
#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
 
/* The number of symbols on the RHS of the reduced rule.
Keep to zero when no symbol should be popped. */
int yylen = 0;
 
yytoken = 0;
yyss = yyssa;
yyvs = yyvsa;
yystacksize = YYINITDEPTH;
 
YYDPRINTF ((stderr, "Starting parse\n"));
 
yystate = 0;
yyerrstatus = 0;
yynerrs = 0;
yychar = YYEMPTY; /* Cause a token to be read. */
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;
 
1182,8 → 1538,7
`------------------------------------------------------------*/
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.
*/
have just been pushed. So pushing a state here evens the stacks. */
yyssp++;
 
yysetstate:
1196,21 → 1551,19
 
#ifdef yyoverflow
{
/* Give user a chance to xreallocate the stack. Use copies of
/* Give user a chance to xreallocate the stack. Use copies of
these so that the &'s don't force the real ones into
memory. */
YYSTYPE *yyvs1 = yyvs;
short *yyss1 = yyss;
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 ("parser stack overflow",
yyoverflow (YY_("memory exhausted"),
&yyss1, yysize * sizeof (*yyssp),
&yyvs1, yysize * sizeof (*yyvsp),
 
&yystacksize);
 
yyss = yyss1;
1218,24 → 1571,23
}
#else /* no yyoverflow */
# ifndef YYSTACK_RELOCATE
goto yyoverflowlab;
goto yyexhaustedlab;
# else
/* Extend the stack our own way. */
if (YYMAXDEPTH <= yystacksize)
goto yyoverflowlab;
goto yyexhaustedlab;
yystacksize *= 2;
if (YYMAXDEPTH < yystacksize)
yystacksize = YYMAXDEPTH;
 
{
short *yyss1 = yyss;
yytype_int16 *yyss1 = yyss;
union yyalloc *yyptr =
(union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
if (! yyptr)
goto yyoverflowlab;
YYSTACK_RELOCATE (yyss);
YYSTACK_RELOCATE (yyvs);
 
goto yyexhaustedlab;
YYSTACK_RELOCATE (yyss_alloc, yyss);
YYSTACK_RELOCATE (yyvs_alloc, yyvs);
# undef YYSTACK_RELOCATE
if (yyss1 != yyssa)
YYSTACK_FREE (yyss1);
1246,7 → 1598,6
yyssp = yyss + yysize - 1;
yyvsp = yyvs + yysize - 1;
 
 
YYDPRINTF ((stderr, "Stack size increased to %lu\n",
(unsigned long int) yystacksize));
 
1256,6 → 1607,9
 
YYDPRINTF ((stderr, "Entering state %d\n", yystate));
 
if (yystate == YYFINAL)
YYACCEPT;
 
goto yybackup;
 
/*-----------.
1263,12 → 1617,10
`-----------*/
yybackup:
 
/* Do appropriate processing given the current state. */
/* Read a lookahead token if we need one and don't already have one. */
/* yyresume: */
/* Do appropriate processing given the current state. Read a
lookahead token if we need one and don't already have one. */
 
/* First try to decide what to do without reference to lookahead token. */
 
yyn = yypact[yystate];
if (yyn == YYPACT_NINF)
goto yydefault;
1290,7 → 1642,7
else
{
yytoken = YYTRANSLATE (yychar);
YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc);
YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
}
 
/* If the proper action on seeing token YYTOKEN is to reduce or to
1307,25 → 1659,20
goto yyreduce;
}
 
if (yyn == YYFINAL)
YYACCEPT;
/* Count tokens shifted since error; after three, turn off error
status. */
if (yyerrstatus)
yyerrstatus--;
 
/* Shift the lookahead token. */
YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken]));
YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
 
/* Discard the token being shifted unless it is eof. */
if (yychar != YYEOF)
yychar = YYEMPTY;
/* Discard the shifted token. */
yychar = YYEMPTY;
 
yystate = yyn;
*++yyvsp = yylval;
 
 
/* Count tokens shifted since error; after three, turn off error
status. */
if (yyerrstatus)
yyerrstatus--;
 
yystate = yyn;
goto yynewstate;
 
 
1361,53 → 1708,73
switch (yyn)
{
case 4:
 
/* Line 1455 of yacc.c */
#line 238 "f-exp.y"
{ write_exp_elt_opcode(OP_TYPE);
write_exp_elt_type(yyvsp[0].tval);
write_exp_elt_type((yyvsp[(1) - (1)].tval));
write_exp_elt_opcode(OP_TYPE); }
break;
 
case 5:
 
/* Line 1455 of yacc.c */
#line 244 "f-exp.y"
{ }
break;
 
case 6:
 
/* Line 1455 of yacc.c */
#line 249 "f-exp.y"
{ write_exp_elt_opcode (UNOP_IND); }
break;
 
case 7:
 
/* Line 1455 of yacc.c */
#line 253 "f-exp.y"
{ write_exp_elt_opcode (UNOP_ADDR); }
break;
 
case 8:
 
/* Line 1455 of yacc.c */
#line 257 "f-exp.y"
{ write_exp_elt_opcode (UNOP_NEG); }
break;
 
case 9:
 
/* Line 1455 of yacc.c */
#line 261 "f-exp.y"
{ write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
break;
 
case 10:
 
/* Line 1455 of yacc.c */
#line 265 "f-exp.y"
{ write_exp_elt_opcode (UNOP_COMPLEMENT); }
break;
 
case 11:
 
/* Line 1455 of yacc.c */
#line 269 "f-exp.y"
{ write_exp_elt_opcode (UNOP_SIZEOF); }
break;
 
case 12:
 
/* Line 1455 of yacc.c */
#line 278 "f-exp.y"
{ start_arglist (); }
break;
 
case 13:
 
/* Line 1455 of yacc.c */
#line 280 "f-exp.y"
{ write_exp_elt_opcode (OP_F77_UNDETERMINED_ARGLIST);
write_exp_elt_longcst ((LONGEST) end_arglist ());
1415,21 → 1782,29
break;
 
case 15:
 
/* Line 1455 of yacc.c */
#line 289 "f-exp.y"
{ arglist_len = 1; }
break;
 
case 16:
 
/* Line 1455 of yacc.c */
#line 293 "f-exp.y"
{ arglist_len = 1; }
break;
 
case 17:
 
/* Line 1455 of yacc.c */
#line 297 "f-exp.y"
{ arglist_len++; }
break;
 
case 18:
 
/* Line 1455 of yacc.c */
#line 303 "f-exp.y"
{ write_exp_elt_opcode (OP_F90_RANGE);
write_exp_elt_longcst (NONE_BOUND_DEFAULT);
1437,6 → 1812,8
break;
 
case 19:
 
/* Line 1455 of yacc.c */
#line 309 "f-exp.y"
{ write_exp_elt_opcode (OP_F90_RANGE);
write_exp_elt_longcst (HIGH_BOUND_DEFAULT);
1444,6 → 1821,8
break;
 
case 20:
 
/* Line 1455 of yacc.c */
#line 315 "f-exp.y"
{ write_exp_elt_opcode (OP_F90_RANGE);
write_exp_elt_longcst (LOW_BOUND_DEFAULT);
1451,6 → 1830,8
break;
 
case 21:
 
/* Line 1455 of yacc.c */
#line 321 "f-exp.y"
{ write_exp_elt_opcode (OP_F90_RANGE);
write_exp_elt_longcst (BOTH_BOUND_DEFAULT);
1458,11 → 1839,15
break;
 
case 22:
 
/* Line 1455 of yacc.c */
#line 327 "f-exp.y"
{ }
break;
 
case 23:
 
/* Line 1455 of yacc.c */
#line 331 "f-exp.y"
{ write_exp_elt_opcode(OP_COMPLEX);
write_exp_elt_type (parse_f_type->builtin_complex_s16);
1470,138 → 1855,188
break;
 
case 24:
 
/* Line 1455 of yacc.c */
#line 337 "f-exp.y"
{ write_exp_elt_opcode (UNOP_CAST);
write_exp_elt_type (yyvsp[-2].tval);
write_exp_elt_type ((yyvsp[(2) - (4)].tval));
write_exp_elt_opcode (UNOP_CAST); }
break;
 
case 25:
 
/* Line 1455 of yacc.c */
#line 343 "f-exp.y"
{ write_exp_elt_opcode (STRUCTOP_STRUCT);
write_exp_string (yyvsp[0].sval);
write_exp_string ((yyvsp[(3) - (3)].sval));
write_exp_elt_opcode (STRUCTOP_STRUCT); }
break;
 
case 26:
 
/* Line 1455 of yacc.c */
#line 351 "f-exp.y"
{ write_exp_elt_opcode (BINOP_REPEAT); }
break;
 
case 27:
 
/* Line 1455 of yacc.c */
#line 355 "f-exp.y"
{ write_exp_elt_opcode (BINOP_EXP); }
break;
 
case 28:
 
/* Line 1455 of yacc.c */
#line 359 "f-exp.y"
{ write_exp_elt_opcode (BINOP_MUL); }
break;
 
case 29:
 
/* Line 1455 of yacc.c */
#line 363 "f-exp.y"
{ write_exp_elt_opcode (BINOP_DIV); }
break;
 
case 30:
 
/* Line 1455 of yacc.c */
#line 367 "f-exp.y"
{ write_exp_elt_opcode (BINOP_ADD); }
break;
 
case 31:
 
/* Line 1455 of yacc.c */
#line 371 "f-exp.y"
{ write_exp_elt_opcode (BINOP_SUB); }
break;
 
case 32:
 
/* Line 1455 of yacc.c */
#line 375 "f-exp.y"
{ write_exp_elt_opcode (BINOP_LSH); }
break;
 
case 33:
 
/* Line 1455 of yacc.c */
#line 379 "f-exp.y"
{ write_exp_elt_opcode (BINOP_RSH); }
break;
 
case 34:
 
/* Line 1455 of yacc.c */
#line 383 "f-exp.y"
{ write_exp_elt_opcode (BINOP_EQUAL); }
break;
 
case 35:
 
/* Line 1455 of yacc.c */
#line 387 "f-exp.y"
{ write_exp_elt_opcode (BINOP_NOTEQUAL); }
break;
 
case 36:
 
/* Line 1455 of yacc.c */
#line 391 "f-exp.y"
{ write_exp_elt_opcode (BINOP_LEQ); }
break;
 
case 37:
 
/* Line 1455 of yacc.c */
#line 395 "f-exp.y"
{ write_exp_elt_opcode (BINOP_GEQ); }
break;
 
case 38:
 
/* Line 1455 of yacc.c */
#line 399 "f-exp.y"
{ write_exp_elt_opcode (BINOP_LESS); }
break;
 
case 39:
 
/* Line 1455 of yacc.c */
#line 403 "f-exp.y"
{ write_exp_elt_opcode (BINOP_GTR); }
break;
 
case 40:
 
/* Line 1455 of yacc.c */
#line 407 "f-exp.y"
{ write_exp_elt_opcode (BINOP_BITWISE_AND); }
break;
 
case 41:
 
/* Line 1455 of yacc.c */
#line 411 "f-exp.y"
{ write_exp_elt_opcode (BINOP_BITWISE_XOR); }
break;
 
case 42:
 
/* Line 1455 of yacc.c */
#line 415 "f-exp.y"
{ write_exp_elt_opcode (BINOP_BITWISE_IOR); }
break;
 
case 43:
 
/* Line 1455 of yacc.c */
#line 419 "f-exp.y"
{ write_exp_elt_opcode (BINOP_LOGICAL_AND); }
break;
 
case 44:
 
/* Line 1455 of yacc.c */
#line 424 "f-exp.y"
{ write_exp_elt_opcode (BINOP_LOGICAL_OR); }
break;
 
case 45:
 
/* Line 1455 of yacc.c */
#line 428 "f-exp.y"
{ write_exp_elt_opcode (BINOP_ASSIGN); }
break;
 
case 46:
 
/* Line 1455 of yacc.c */
#line 432 "f-exp.y"
{ write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
write_exp_elt_opcode (yyvsp[-1].opcode);
write_exp_elt_opcode ((yyvsp[(2) - (3)].opcode));
write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); }
break;
 
case 47:
 
/* Line 1455 of yacc.c */
#line 438 "f-exp.y"
{ write_exp_elt_opcode (OP_LONG);
write_exp_elt_type (yyvsp[0].typed_val.type);
write_exp_elt_longcst ((LONGEST)(yyvsp[0].typed_val.val));
write_exp_elt_type ((yyvsp[(1) - (1)].typed_val).type);
write_exp_elt_longcst ((LONGEST)((yyvsp[(1) - (1)].typed_val).val));
write_exp_elt_opcode (OP_LONG); }
break;
 
case 48:
 
/* Line 1455 of yacc.c */
#line 445 "f-exp.y"
{ YYSTYPE val;
parse_number (yyvsp[0].ssym.stoken.ptr, yyvsp[0].ssym.stoken.length, 0, &val);
parse_number ((yyvsp[(1) - (1)].ssym).stoken.ptr, (yyvsp[(1) - (1)].ssym).stoken.length, 0, &val);
write_exp_elt_opcode (OP_LONG);
write_exp_elt_type (val.typed_val.type);
write_exp_elt_longcst ((LONGEST)val.typed_val.val);
1609,42 → 2044,52
break;
 
case 49:
 
/* Line 1455 of yacc.c */
#line 454 "f-exp.y"
{ write_exp_elt_opcode (OP_DOUBLE);
write_exp_elt_type (parse_f_type->builtin_real_s8);
write_exp_elt_dblcst (yyvsp[0].dval);
write_exp_elt_dblcst ((yyvsp[(1) - (1)].dval));
write_exp_elt_opcode (OP_DOUBLE); }
break;
 
case 52:
 
/* Line 1455 of yacc.c */
#line 467 "f-exp.y"
{ write_exp_elt_opcode (OP_LONG);
write_exp_elt_type (parse_f_type->builtin_integer);
CHECK_TYPEDEF (yyvsp[-1].tval);
write_exp_elt_longcst ((LONGEST) TYPE_LENGTH (yyvsp[-1].tval));
CHECK_TYPEDEF ((yyvsp[(3) - (4)].tval));
write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ((yyvsp[(3) - (4)].tval)));
write_exp_elt_opcode (OP_LONG); }
break;
 
case 53:
 
/* Line 1455 of yacc.c */
#line 475 "f-exp.y"
{ write_exp_elt_opcode (OP_BOOL);
write_exp_elt_longcst ((LONGEST) yyvsp[0].lval);
write_exp_elt_longcst ((LONGEST) (yyvsp[(1) - (1)].lval));
write_exp_elt_opcode (OP_BOOL);
}
break;
 
case 54:
 
/* Line 1455 of yacc.c */
#line 482 "f-exp.y"
{
write_exp_elt_opcode (OP_STRING);
write_exp_string (yyvsp[0].sval);
write_exp_string ((yyvsp[(1) - (1)].sval));
write_exp_elt_opcode (OP_STRING);
}
break;
 
case 55:
 
/* Line 1455 of yacc.c */
#line 490 "f-exp.y"
{ struct symbol *sym = yyvsp[0].ssym.sym;
{ struct symbol *sym = (yyvsp[(1) - (1)].ssym).sym;
 
if (sym)
{
1667,7 → 2112,7
else
{
struct minimal_symbol *msymbol;
char *arg = copy_name (yyvsp[0].ssym.stoken);
char *arg = copy_name ((yyvsp[(1) - (1)].ssym).stoken);
 
msymbol =
lookup_minimal_symbol (arg, NULL, NULL);
1677,18 → 2122,20
error ("No symbol table is loaded. Use the \"file\" command.");
else
error ("No symbol \"%s\" in current context.",
copy_name (yyvsp[0].ssym.stoken));
copy_name ((yyvsp[(1) - (1)].ssym).stoken));
}
}
break;
 
case 58:
 
/* Line 1455 of yacc.c */
#line 534 "f-exp.y"
{
/* This is where the interesting stuff happens. */
int done = 0;
int array_size;
struct type *follow_type = yyvsp[-1].tval;
struct type *follow_type = (yyvsp[(1) - (2)].tval);
struct type *range_type;
while (!done)
1722,161 → 2169,212
follow_type = lookup_function_type (follow_type);
break;
}
yyval.tval = follow_type;
(yyval.tval) = follow_type;
}
break;
 
case 59:
 
/* Line 1455 of yacc.c */
#line 577 "f-exp.y"
{ push_type (tp_pointer); yyval.voidval = 0; }
{ push_type (tp_pointer); (yyval.voidval) = 0; }
break;
 
case 60:
 
/* Line 1455 of yacc.c */
#line 579 "f-exp.y"
{ push_type (tp_pointer); yyval.voidval = yyvsp[0].voidval; }
{ push_type (tp_pointer); (yyval.voidval) = (yyvsp[(2) - (2)].voidval); }
break;
 
case 61:
 
/* Line 1455 of yacc.c */
#line 581 "f-exp.y"
{ push_type (tp_reference); yyval.voidval = 0; }
{ push_type (tp_reference); (yyval.voidval) = 0; }
break;
 
case 62:
 
/* Line 1455 of yacc.c */
#line 583 "f-exp.y"
{ push_type (tp_reference); yyval.voidval = yyvsp[0].voidval; }
{ push_type (tp_reference); (yyval.voidval) = (yyvsp[(2) - (2)].voidval); }
break;
 
case 64:
 
/* Line 1455 of yacc.c */
#line 588 "f-exp.y"
{ yyval.voidval = yyvsp[-1].voidval; }
{ (yyval.voidval) = (yyvsp[(2) - (3)].voidval); }
break;
 
case 65:
 
/* Line 1455 of yacc.c */
#line 590 "f-exp.y"
{ push_type (tp_function); }
break;
 
case 66:
 
/* Line 1455 of yacc.c */
#line 592 "f-exp.y"
{ push_type (tp_function); }
break;
 
case 67:
 
/* Line 1455 of yacc.c */
#line 596 "f-exp.y"
{ yyval.voidval = 0; }
{ (yyval.voidval) = 0; }
break;
 
case 68:
 
/* Line 1455 of yacc.c */
#line 598 "f-exp.y"
{ xfree (yyvsp[-1].tvec); yyval.voidval = 0; }
{ xfree ((yyvsp[(2) - (3)].tvec)); (yyval.voidval) = 0; }
break;
 
case 69:
 
/* Line 1455 of yacc.c */
#line 603 "f-exp.y"
{ yyval.tval = yyvsp[0].tsym.type; }
{ (yyval.tval) = (yyvsp[(1) - (1)].tsym).type; }
break;
 
case 70:
 
/* Line 1455 of yacc.c */
#line 605 "f-exp.y"
{ yyval.tval = parse_f_type->builtin_integer; }
{ (yyval.tval) = parse_f_type->builtin_integer; }
break;
 
case 71:
 
/* Line 1455 of yacc.c */
#line 607 "f-exp.y"
{ yyval.tval = parse_f_type->builtin_integer_s2; }
{ (yyval.tval) = parse_f_type->builtin_integer_s2; }
break;
 
case 72:
 
/* Line 1455 of yacc.c */
#line 609 "f-exp.y"
{ yyval.tval = parse_f_type->builtin_character; }
{ (yyval.tval) = parse_f_type->builtin_character; }
break;
 
case 73:
 
/* Line 1455 of yacc.c */
#line 611 "f-exp.y"
{ yyval.tval = parse_f_type->builtin_logical_s8; }
{ (yyval.tval) = parse_f_type->builtin_logical_s8; }
break;
 
case 74:
 
/* Line 1455 of yacc.c */
#line 613 "f-exp.y"
{ yyval.tval = parse_f_type->builtin_logical; }
{ (yyval.tval) = parse_f_type->builtin_logical; }
break;
 
case 75:
 
/* Line 1455 of yacc.c */
#line 615 "f-exp.y"
{ yyval.tval = parse_f_type->builtin_logical_s2; }
{ (yyval.tval) = parse_f_type->builtin_logical_s2; }
break;
 
case 76:
 
/* Line 1455 of yacc.c */
#line 617 "f-exp.y"
{ yyval.tval = parse_f_type->builtin_logical_s1; }
{ (yyval.tval) = parse_f_type->builtin_logical_s1; }
break;
 
case 77:
 
/* Line 1455 of yacc.c */
#line 619 "f-exp.y"
{ yyval.tval = parse_f_type->builtin_real; }
{ (yyval.tval) = parse_f_type->builtin_real; }
break;
 
case 78:
 
/* Line 1455 of yacc.c */
#line 621 "f-exp.y"
{ yyval.tval = parse_f_type->builtin_real_s8; }
{ (yyval.tval) = parse_f_type->builtin_real_s8; }
break;
 
case 79:
 
/* Line 1455 of yacc.c */
#line 623 "f-exp.y"
{ yyval.tval = parse_f_type->builtin_real_s16; }
{ (yyval.tval) = parse_f_type->builtin_real_s16; }
break;
 
case 80:
 
/* Line 1455 of yacc.c */
#line 625 "f-exp.y"
{ yyval.tval = parse_f_type->builtin_complex_s8; }
{ (yyval.tval) = parse_f_type->builtin_complex_s8; }
break;
 
case 81:
 
/* Line 1455 of yacc.c */
#line 627 "f-exp.y"
{ yyval.tval = parse_f_type->builtin_complex_s16; }
{ (yyval.tval) = parse_f_type->builtin_complex_s16; }
break;
 
case 82:
 
/* Line 1455 of yacc.c */
#line 629 "f-exp.y"
{ yyval.tval = parse_f_type->builtin_complex_s32; }
{ (yyval.tval) = parse_f_type->builtin_complex_s32; }
break;
 
case 83:
 
/* Line 1455 of yacc.c */
#line 634 "f-exp.y"
{ yyval.tvec = (struct type **) xmalloc (sizeof (struct type *) * 2);
yyval.ivec[0] = 1; /* Number of types in vector */
yyval.tvec[1] = yyvsp[0].tval;
{ (yyval.tvec) = (struct type **) xmalloc (sizeof (struct type *) * 2);
(yyval.ivec)[0] = 1; /* Number of types in vector */
(yyval.tvec)[1] = (yyvsp[(1) - (1)].tval);
}
break;
 
case 84:
 
/* Line 1455 of yacc.c */
#line 639 "f-exp.y"
{ int len = sizeof (struct type *) * (++(yyvsp[-2].ivec[0]) + 1);
yyval.tvec = (struct type **) xrealloc ((char *) yyvsp[-2].tvec, len);
yyval.tvec[yyval.ivec[0]] = yyvsp[0].tval;
{ int len = sizeof (struct type *) * (++((yyvsp[(1) - (3)].ivec)[0]) + 1);
(yyval.tvec) = (struct type **) xrealloc ((char *) (yyvsp[(1) - (3)].tvec), len);
(yyval.tvec)[(yyval.ivec)[0]] = (yyvsp[(3) - (3)].tval);
}
break;
 
case 85:
 
/* Line 1455 of yacc.c */
#line 646 "f-exp.y"
{ yyval.sval = yyvsp[0].ssym.stoken; }
{ (yyval.sval) = (yyvsp[(1) - (1)].ssym).stoken; }
break;
 
 
 
/* Line 1455 of yacc.c */
#line 2369 "f-exp.c.tmp"
default: break;
}
YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
 
/* Line 1000 of yacc.c. */
#line 1870 "f-exp.c.tmp"
yyvsp -= yylen;
yyssp -= yylen;
 
 
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. */
1900,66 → 2398,41
if (!yyerrstatus)
{
++yynerrs;
#if YYERROR_VERBOSE
yyn = yypact[yystate];
 
if (YYPACT_NINF < yyn && yyn < YYLAST)
{
YYSIZE_T yysize = 0;
int yytype = YYTRANSLATE (yychar);
const char* yyprefix;
char *yymsg;
int yyx;
 
/* 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;
int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
int yycount = 0;
 
yyprefix = ", expecting ";
for (yyx = yyxbegin; yyx < yyxend; ++yyx)
if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
#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
{
yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]);
yycount += 1;
if (yycount == 5)
{
yysize = 0;
break;
}
yymsg = yymsgbuf;
yymsg_alloc = sizeof yymsgbuf;
}
yysize += (sizeof ("syntax error, unexpected ")
+ yystrlen (yytname[yytype]));
yymsg = (char *) YYSTACK_ALLOC (yysize);
if (yymsg != 0)
{
char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
yyp = yystpcpy (yyp, yytname[yytype]);
}
 
if (yycount < 5)
{
yyprefix = ", expecting ";
for (yyx = yyxbegin; yyx < yyxend; ++yyx)
if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
{
yyp = yystpcpy (yyp, yyprefix);
yyp = yystpcpy (yyp, yytname[yyx]);
yyprefix = " or ";
}
}
yyerror (yymsg);
YYSTACK_FREE (yymsg);
}
else
yyerror ("syntax error; also virtual memory exhausted");
}
else
#endif /* YYERROR_VERBOSE */
yyerror ("syntax error");
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
}
 
 
1970,25 → 2443,16
error, discard it. */
 
if (yychar <= YYEOF)
{
/* If at end of input, pop the error token,
then the rest of the stack, then return failure. */
{
/* Return failure if at end of input. */
if (yychar == YYEOF)
for (;;)
{
YYPOPSTACK;
if (yyssp == yyss)
YYABORT;
YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
yydestruct (yystos[*yyssp], yyvsp);
}
}
YYABORT;
}
else
{
YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);
yydestruct (yytoken, &yylval);
yydestruct ("Error: discarding",
yytoken, &yylval);
yychar = YYEMPTY;
 
}
}
 
2002,15 → 2466,17
`---------------------------------------------------*/
yyerrorlab:
 
#ifdef __GNUC__
/* Pacify GCC when the user code never invokes YYERROR and the label
yyerrorlab therefore never appears in user code. */
if (0)
/* 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;
#endif
 
yyvsp -= yylen;
yyssp -= yylen;
/* 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;
 
2039,21 → 2505,20
if (yyssp == yyss)
YYABORT;
 
YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
yydestruct (yystos[yystate], yyvsp);
YYPOPSTACK;
 
yydestruct ("Error: popping",
yystos[yystate], yyvsp);
YYPOPSTACK (1);
yystate = *yyssp;
YY_STACK_PRINT (yyss, yyssp);
}
 
if (yyn == YYFINAL)
YYACCEPT;
*++yyvsp = yylval;
 
YYDPRINTF ((stderr, "Shifting error token, "));
 
*++yyvsp = yylval;
/* Shift the error token. */
YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
 
 
yystate = yyn;
goto yynewstate;
 
2072,25 → 2537,45
yyresult = 1;
goto yyreturn;
 
#ifndef yyoverflow
/*----------------------------------------------.
| yyoverflowlab -- parser overflow comes here. |
`----------------------------------------------*/
yyoverflowlab:
yyerror ("parser stack overflow");
#if !defined(yyoverflow) || YYERROR_VERBOSE
/*-------------------------------------------------.
| yyexhaustedlab -- memory exhaustion comes here. |
`-------------------------------------------------*/
yyexhaustedlab:
yyerror (YY_("memory exhausted"));
yyresult = 2;
/* Fall through. */
#endif
 
yyreturn:
if (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
return yyresult;
#if YYERROR_VERBOSE
if (yymsg != yymsgbuf)
YYSTACK_FREE (yymsg);
#endif
/* Make sure YYID is used. */
return YYID (yyresult);
}
 
 
 
/* Line 1675 of yacc.c */
#line 659 "f-exp.y"
 
 
2661,4 → 3146,3
error ("A %s in expression, near `%s'.", (msg ? msg : "error"), lexptr);
}
 
 
/gnu-src/gdb-7.2/gdb/cp-name-parser.c
1,30 → 1,39
/* A Bison parser, made by GNU Bison 1.875c. */
 
/* Skeleton parser for Yacc-like parsing with Bison,
Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
/* A Bison parser, made by GNU Bison 2.4.1. */
 
This program is free software; you can redistribute it and/or modify
/* 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.
 
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., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
along with this program. If not, see <http://www.gnu.org/licenses/>. */
 
/* As a special exception, when this file is copied by Bison into a
Bison output file, you may use that output file without restriction.
This special exception was added by the Free Software Foundation
in version 1.24 of Bison. */
/* 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. */
 
/* Written by Richard Stallman by simplifying the original so called
``semantic'' parser. */
/* 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
36,6 → 45,9
/* Identify Bison output. */
#define YYBISON 1
 
/* Bison version. */
#define YYBISON_VERSION "2.4.1"
 
/* Skeleton name. */
#define YYSKELETON_NAME "yacc.c"
 
42,124 → 54,20
/* Pure parsers. */
#define YYPURE 0
 
/* Push parsers. */
#define YYPUSH 0
 
/* Pull parsers. */
#define YYPULL 1
 
/* 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 {
INT = 258,
FLOAT = 259,
NAME = 260,
STRUCT = 261,
CLASS = 262,
UNION = 263,
ENUM = 264,
SIZEOF = 265,
UNSIGNED = 266,
COLONCOLON = 267,
TEMPLATE = 268,
ERROR = 269,
NEW = 270,
DELETE = 271,
OPERATOR = 272,
STATIC_CAST = 273,
REINTERPRET_CAST = 274,
DYNAMIC_CAST = 275,
SIGNED_KEYWORD = 276,
LONG = 277,
SHORT = 278,
INT_KEYWORD = 279,
CONST_KEYWORD = 280,
VOLATILE_KEYWORD = 281,
DOUBLE_KEYWORD = 282,
BOOL = 283,
ELLIPSIS = 284,
RESTRICT = 285,
VOID = 286,
FLOAT_KEYWORD = 287,
CHAR = 288,
WCHAR_T = 289,
ASSIGN_MODIFY = 290,
TRUEKEYWORD = 291,
FALSEKEYWORD = 292,
DEMANGLER_SPECIAL = 293,
CONSTRUCTION_VTABLE = 294,
CONSTRUCTION_IN = 295,
OROR = 296,
ANDAND = 297,
NOTEQUAL = 298,
EQUAL = 299,
GEQ = 300,
LEQ = 301,
RSH = 302,
LSH = 303,
DECREMENT = 304,
INCREMENT = 305,
UNARY = 306,
ARROW = 307
};
#endif
#define INT 258
#define FLOAT 259
#define NAME 260
#define STRUCT 261
#define CLASS 262
#define UNION 263
#define ENUM 264
#define SIZEOF 265
#define UNSIGNED 266
#define COLONCOLON 267
#define TEMPLATE 268
#define ERROR 269
#define NEW 270
#define DELETE 271
#define OPERATOR 272
#define STATIC_CAST 273
#define REINTERPRET_CAST 274
#define DYNAMIC_CAST 275
#define SIGNED_KEYWORD 276
#define LONG 277
#define SHORT 278
#define INT_KEYWORD 279
#define CONST_KEYWORD 280
#define VOLATILE_KEYWORD 281
#define DOUBLE_KEYWORD 282
#define BOOL 283
#define ELLIPSIS 284
#define RESTRICT 285
#define VOID 286
#define FLOAT_KEYWORD 287
#define CHAR 288
#define WCHAR_T 289
#define ASSIGN_MODIFY 290
#define TRUEKEYWORD 291
#define FALSEKEYWORD 292
#define DEMANGLER_SPECIAL 293
#define CONSTRUCTION_VTABLE 294
#define CONSTRUCTION_IN 295
#define OROR 296
#define ANDAND 297
#define NOTEQUAL 298
#define EQUAL 299
#define GEQ 300
#define LEQ 301
#define RSH 302
#define LSH 303
#define DECREMENT 304
#define INCREMENT 305
#define UNARY 306
#define ARROW 307
/* Copy the first part of user declarations. */
 
 
 
 
/* Copy the first part of user declarations. */
/* Line 189 of yacc.c */
#line 31 "cp-name-parser.y"
 
 
371,6 → 279,9
 
 
 
/* Line 189 of yacc.c */
#line 284 "cp-name-parser.c.tmp"
 
/* Enabling traces. */
#ifndef YYDEBUG
# define YYDEBUG 0
384,9 → 295,132
# define YYERROR_VERBOSE 0
#endif
 
#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
/* Enabling the token table. */
#ifndef YYTOKEN_TABLE
# define YYTOKEN_TABLE 0
#endif
 
 
/* Tokens. */
#ifndef YYTOKENTYPE
# define YYTOKENTYPE
/* Put the tokens into the symbol table, so that GDB and other debuggers
know about them. */
enum yytokentype {
INT = 258,
FLOAT = 259,
NAME = 260,
STRUCT = 261,
CLASS = 262,
UNION = 263,
ENUM = 264,
SIZEOF = 265,
UNSIGNED = 266,
COLONCOLON = 267,
TEMPLATE = 268,
ERROR = 269,
NEW = 270,
DELETE = 271,
OPERATOR = 272,
STATIC_CAST = 273,
REINTERPRET_CAST = 274,
DYNAMIC_CAST = 275,
SIGNED_KEYWORD = 276,
LONG = 277,
SHORT = 278,
INT_KEYWORD = 279,
CONST_KEYWORD = 280,
VOLATILE_KEYWORD = 281,
DOUBLE_KEYWORD = 282,
BOOL = 283,
ELLIPSIS = 284,
RESTRICT = 285,
VOID = 286,
FLOAT_KEYWORD = 287,
CHAR = 288,
WCHAR_T = 289,
ASSIGN_MODIFY = 290,
TRUEKEYWORD = 291,
FALSEKEYWORD = 292,
DEMANGLER_SPECIAL = 293,
CONSTRUCTION_VTABLE = 294,
CONSTRUCTION_IN = 295,
OROR = 296,
ANDAND = 297,
NOTEQUAL = 298,
EQUAL = 299,
GEQ = 300,
LEQ = 301,
RSH = 302,
LSH = 303,
DECREMENT = 304,
INCREMENT = 305,
UNARY = 306,
ARROW = 307
};
#endif
/* Tokens. */
#define INT 258
#define FLOAT 259
#define NAME 260
#define STRUCT 261
#define CLASS 262
#define UNION 263
#define ENUM 264
#define SIZEOF 265
#define UNSIGNED 266
#define COLONCOLON 267
#define TEMPLATE 268
#define ERROR 269
#define NEW 270
#define DELETE 271
#define OPERATOR 272
#define STATIC_CAST 273
#define REINTERPRET_CAST 274
#define DYNAMIC_CAST 275
#define SIGNED_KEYWORD 276
#define LONG 277
#define SHORT 278
#define INT_KEYWORD 279
#define CONST_KEYWORD 280
#define VOLATILE_KEYWORD 281
#define DOUBLE_KEYWORD 282
#define BOOL 283
#define ELLIPSIS 284
#define RESTRICT 285
#define VOID 286
#define FLOAT_KEYWORD 287
#define CHAR 288
#define WCHAR_T 289
#define ASSIGN_MODIFY 290
#define TRUEKEYWORD 291
#define FALSEKEYWORD 292
#define DEMANGLER_SPECIAL 293
#define CONSTRUCTION_VTABLE 294
#define CONSTRUCTION_IN 295
#define OROR 296
#define ANDAND 297
#define NOTEQUAL 298
#define EQUAL 299
#define GEQ 300
#define LEQ 301
#define RSH 302
#define LSH 303
#define DECREMENT 304
#define INCREMENT 305
#define UNARY 306
#define ARROW 307
 
 
 
 
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
typedef union YYSTYPE
{
 
/* Line 214 of yacc.c */
#line 242 "cp-name-parser.y"
typedef union YYSTYPE {
 
struct demangle_component *comp;
struct nested {
struct demangle_component *comp;
403,71 → 437,187
} abstract;
int lval;
const char *opname;
} YYSTYPE;
/* Line 191 of yacc.c. */
#line 409 "cp-name-parser.c.tmp"
 
 
/* Line 214 of yacc.c */
#line 445 "cp-name-parser.c.tmp"
} YYSTYPE;
# define YYSTYPE_IS_TRIVIAL 1
# 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 214 of yacc.c. */
#line 421 "cp-name-parser.c.tmp"
/* Line 264 of yacc.c */
#line 457 "cp-name-parser.c.tmp"
 
#if ! defined (yyoverflow) || YYERROR_VERBOSE
#ifdef short
# undef short
#endif
 
# ifndef YYFREE
# define YYFREE xfree
#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
# ifndef YYMALLOC
# define YYMALLOC xmalloc
#endif
 
#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
 
#ifndef YY_
# if 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 yyi)
#else
static int
YYID (yyi)
int yyi;
#endif
{
return yyi;
}
#endif
 
#if ! defined yyoverflow || YYERROR_VERBOSE
 
/* The parser invokes alloca or xmalloc; define the necessary symbols. */
 
# ifdef YYSTACK_USE_ALLOCA
# if YYSTACK_USE_ALLOCA
# define YYSTACK_ALLOC alloca
# endif
# else
# if defined (alloca) || defined (_ALLOCA_H)
# define YYSTACK_ALLOC alloca
# else
# 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
# 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 (0)
/* 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
# if defined (__STDC__) || defined (__cplusplus)
# 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 xmalloc) \
&& (defined YYFREE || defined xfree)))
# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
# define YYSIZE_T size_t
# ifndef _STDLIB_H
# define _STDLIB_H 1
# endif
# endif
# define YYSTACK_ALLOC YYMALLOC
# define YYSTACK_FREE YYFREE
# ifndef YYMALLOC
# define YYMALLOC xmalloc
# if ! defined xmalloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
void *xmalloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
# endif
# endif
# ifndef YYFREE
# define YYFREE xfree
# if ! defined xfree && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
void xfree (void *); /* INFRINGES ON USER NAME SPACE */
# endif
# endif
# endif
#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
 
 
#if (! defined (yyoverflow) \
&& (! defined (__cplusplus) \
|| (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
#if (! defined yyoverflow \
&& (! defined __cplusplus \
|| (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
 
/* A type that is properly aligned for any stack member. */
union yyalloc
{
short yyss;
YYSTYPE yyvs;
};
yytype_int16 yyss_alloc;
YYSTYPE yyvs_alloc;
};
 
/* The size of the maximum gap between one aligned stack and the next. */
# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
475,13 → 625,13
/* The size of an array large to enough to hold all stacks, each with
N elements. */
# define YYSTACK_BYTES(N) \
((N) * (sizeof (short) + sizeof (YYSTYPE)) \
((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__
# if defined __GNUC__ && 1 < __GNUC__
# define YYCOPY(To, From, Count) \
__builtin_memcpy (To, From, (Count) * sizeof (*(From)))
# else
488,11 → 638,11
# define YYCOPY(To, From, Count) \
do \
{ \
register YYSIZE_T yyi; \
YYSIZE_T yyi; \
for (yyi = 0; yyi < (Count); yyi++) \
(To)[yyi] = (From)[yyi]; \
} \
while (0)
while (YYID (0))
# endif
# endif
 
501,37 → 651,31
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) \
# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
do \
{ \
YYSIZE_T yynewbytes; \
YYCOPY (&yyptr->Stack, Stack, yysize); \
Stack = &yyptr->Stack; \
YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
Stack = &yyptr->Stack_alloc; \
yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
yyptr += yynewbytes / sizeof (*yyptr); \
} \
while (0)
while (YYID (0))
 
#endif
 
#if defined (__STDC__) || defined (__cplusplus)
typedef signed char yysigned_char;
#else
typedef short yysigned_char;
#endif
 
/* YYFINAL -- State number of the termination state. */
/* YYFINAL -- State number of the termination state. */
#define YYFINAL 84
/* YYLAST -- Last index in YYTABLE. */
#define YYLAST 1097
 
/* YYNTOKENS -- Number of terminals. */
/* YYNTOKENS -- Number of terminals. */
#define YYNTOKENS 75
/* YYNNTS -- Number of nonterminals. */
/* YYNNTS -- Number of nonterminals. */
#define YYNNTS 40
/* YYNRULES -- Number of rules. */
/* YYNRULES -- Number of rules. */
#define YYNRULES 194
/* YYNRULES -- Number of states. */
/* YYNRULES -- Number of states. */
#define YYNSTATES 324
 
/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
538,11 → 682,11
#define YYUNDEFTOK 2
#define YYMAXUTOK 307
 
#define YYTRANSLATE(YYX) \
#define YYTRANSLATE(YYX) \
((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
 
/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
static const unsigned char yytranslate[] =
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,
580,7 → 724,7
#if YYDEBUG
/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
YYRHS. */
static const unsigned short yyprhs[] =
static const yytype_uint16 yyprhs[] =
{
0, 0, 3, 5, 7, 9, 11, 12, 15, 18,
22, 26, 29, 32, 35, 40, 43, 46, 51, 56,
604,8 → 748,8
607, 609, 611, 616, 618
};
 
/* YYRHS -- A `-1'-separated list of the rules' RHS. */
static const yysigned_char yyrhs[] =
/* YYRHS -- A `-1'-separated list of the rules' RHS. */
static const yytype_int8 yyrhs[] =
{
76, 0, -1, 77, -1, 108, -1, 80, -1, 79,
-1, -1, 12, 77, -1, 104, 111, -1, 104, 95,
672,7 → 816,7
};
 
/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
static const unsigned short yyrline[] =
static const yytype_uint16 yyrline[] =
{
0, 356, 356, 360, 362, 364, 369, 370, 377, 386,
389, 393, 396, 415, 419, 423, 425, 427, 429, 431,
697,9 → 841,9
};
#endif
 
#if YYDEBUG || YYERROR_VERBOSE
/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
First, the terminals, then, starting at YYNTOKENS, nonterminals. */
#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", "INT", "FLOAT", "NAME", "STRUCT",
729,7 → 873,7
# ifdef YYPRINT
/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
token YYLEX-NUM. */
static const unsigned short yytoknum[] =
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,
743,7 → 887,7
# endif
 
/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
static const unsigned char yyr1[] =
static const yytype_uint8 yyr1[] =
{
0, 75, 76, 77, 77, 77, 78, 78, 79, 79,
79, 79, 79, 80, 80, 81, 81, 81, 81, 81,
768,7 → 912,7
};
 
/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
static const unsigned char yyr2[] =
static const yytype_uint8 yyr2[] =
{
0, 2, 1, 1, 1, 1, 0, 2, 2, 3,
3, 2, 2, 2, 4, 2, 2, 4, 4, 2,
795,7 → 939,7
/* 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 unsigned char yydefact[] =
static const yytype_uint8 yydefact[] =
{
0, 59, 97, 0, 0, 96, 99, 100, 95, 92,
91, 105, 107, 90, 109, 104, 98, 108, 0, 0,
832,8 → 976,8
0, 167, 169, 168
};
 
/* YYDEFGOTO[NTERM-NUM]. */
static const short yydefgoto[] =
/* YYDEFGOTO[NTERM-NUM]. */
static const yytype_int16 yydefgoto[] =
{
-1, 21, 155, 92, 23, 24, 25, 26, 27, 28,
118, 29, 252, 30, 31, 78, 33, 142, 143, 166,
844,7 → 988,7
/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
STATE-NUM. */
#define YYPACT_NINF -193
static const short yypact[] =
static const yytype_int16 yypact[] =
{
771, 28, -193, 45, 545, -193, -16, -193, -193, -193,
-193, -193, -193, -193, -193, -193, -193, -193, 771, 771,
882,7 → 1026,7
};
 
/* YYPGOTO[NTERM-NUM]. */
static const short yypgoto[] =
static const yytype_int16 yypgoto[] =
{
-193, -193, 25, 57, -193, -193, -193, 1, -193, 9,
-193, -1, -34, -24, 3, 0, 150, 157, 47, -193,
895,7 → 1039,7
number is the opposite. If zero, do what YYDEFACT says.
If YYTABLE_NINF, syntax error. */
#define YYTABLE_NINF -1
static const unsigned short yytable[] =
static const yytype_uint16 yytable[] =
{
32, 178, 44, 46, 43, 120, 45, 102, 98, 159,
86, 80, 96, 170, 242, 121, 123, 87, 32, 32,
1009,7 → 1153,7
230, 231, 0, 0, 0, 232, 0, 233
};
 
static const short yycheck[] =
static const yytype_int16 yycheck[] =
{
0, 98, 3, 3, 3, 39, 3, 30, 27, 3,
5, 27, 27, 5, 163, 39, 39, 12, 18, 19,
1125,7 → 1269,7
 
/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
symbol of state STATE-NUM. */
static const unsigned char yystos[] =
static const yytype_uint8 yystos[] =
{
0, 5, 11, 12, 17, 21, 22, 23, 24, 25,
26, 27, 28, 30, 31, 32, 33, 34, 38, 39,
1162,22 → 1306,6
114, 41, 41, 41
};
 
#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
# define YYSIZE_T __SIZE_TYPE__
#endif
#if ! defined (YYSIZE_T) && defined (size_t)
# define YYSIZE_T size_t
#endif
#if ! defined (YYSIZE_T)
# if defined (__STDC__) || defined (__cplusplus)
# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
# define YYSIZE_T size_t
# endif
#endif
#if ! defined (YYSIZE_T)
# define YYSIZE_T unsigned int
#endif
 
#define yyerrok (yyerrstatus = 0)
#define yyclearin (yychar = YYEMPTY)
#define YYEMPTY (-2)
1203,30 → 1331,63
yychar = (Token); \
yylval = (Value); \
yytoken = YYTRANSLATE (yychar); \
YYPOPSTACK; \
YYPOPSTACK (1); \
goto yybackup; \
} \
else \
{ \
yyerror ("syntax error: cannot back up");\
{ \
yyerror (YY_("syntax error: cannot back up")); \
YYERROR; \
} \
while (0)
while (YYID (0))
 
 
#define YYTERROR 1
#define YYERRCODE 256
 
/* YYLLOC_DEFAULT -- Compute the default location (before the actions
are run). */
 
/* 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) \
((Current).first_line = (Rhs)[1].first_line, \
(Current).first_column = (Rhs)[1].first_column, \
(Current).last_line = (Rhs)[N].last_line, \
(Current).last_column = (Rhs)[N].last_column)
# 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 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
1247,43 → 1408,100
do { \
if (yydebug) \
YYFPRINTF Args; \
} while (0)
} while (YYID (0))
 
# define YYDSYMPRINT(Args) \
do { \
if (yydebug) \
yysymprint Args; \
} while (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))
 
# define YYDSYMPRINTF(Title, Token, Value, Location) \
do { \
if (yydebug) \
{ \
YYFPRINTF (stderr, "%s ", Title); \
yysymprint (stderr, \
Token, Value); \
YYFPRINTF (stderr, "\n"); \
} \
} while (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 (__cplusplus)
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
static void
yy_stack_print (short *bottom, short *top)
yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
#else
static void
yy_stack_print (bottom, top)
short *bottom;
short *top;
yy_stack_print (yybottom, yytop)
yytype_int16 *yybottom;
yytype_int16 *yytop;
#endif
{
YYFPRINTF (stderr, "Stack now");
for (/* Nothing. */; bottom <= top; ++bottom)
YYFPRINTF (stderr, " %d", *bottom);
for (; yybottom <= yytop; yybottom++)
{
int yybot = *yybottom;
YYFPRINTF (stderr, " %d", yybot);
}
YYFPRINTF (stderr, "\n");
}
 
1291,7 → 1509,7
do { \
if (yydebug) \
yy_stack_print ((Bottom), (Top)); \
} while (0)
} while (YYID (0))
 
 
/*------------------------------------------------.
1298,30 → 1516,38
| Report that the YYRULE is going to be reduced. |
`------------------------------------------------*/
 
#if defined (__STDC__) || defined (__cplusplus)
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
static void
yy_reduce_print (int yyrule)
yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
#else
static void
yy_reduce_print (yyrule)
yy_reduce_print (yyvsp, yyrule)
YYSTYPE *yyvsp;
int yyrule;
#endif
{
int yynrhs = yyr2[yyrule];
int yyi;
unsigned int yylno = yyrline[yyrule];
YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
yyrule - 1, yylno);
/* Print the symbols being reduced, and their result. */
for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);
YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);
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++)
{
YYFPRINTF (stderr, " $%d = ", yyi + 1);
yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
&(yyvsp[(yyi + 1) - (yynrhs)])
);
YYFPRINTF (stderr, "\n");
}
}
 
# define YY_REDUCE_PRINT(Rule) \
do { \
if (yydebug) \
yy_reduce_print (Rule); \
} while (0)
yy_reduce_print (yyvsp, Rule); \
} while (YYID (0))
 
/* Nonzero means print parse trace. It is left uninitialized so that
multiple parsers can coexist. */
1328,8 → 1554,7
int yydebug;
#else /* !YYDEBUG */
# define YYDPRINTF(Args)
# define YYDSYMPRINT(Args)
# define YYDSYMPRINTF(Title, Token, Value, Location)
# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
# define YY_STACK_PRINT(Bottom, Top)
# define YY_REDUCE_PRINT(Rule)
#endif /* !YYDEBUG */
1344,13 → 1569,9
if the built-in stack extension method is used).
 
Do not make this value too large; the results are undefined if
SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
evaluated with infinite-precision integer arithmetic. */
 
#if defined (YYMAXDEPTH) && YYMAXDEPTH == 0
# undef YYMAXDEPTH
#endif
 
#ifndef YYMAXDEPTH
# define YYMAXDEPTH 10000
#endif
1360,45 → 1581,47
#if YYERROR_VERBOSE
 
# ifndef yystrlen
# if defined (__GLIBC__) && defined (_STRING_H)
# 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
# if defined (__STDC__) || defined (__cplusplus)
yystrlen (const char *yystr)
# else
#else
static YYSIZE_T
yystrlen (yystr)
const char *yystr;
# endif
const char *yystr;
#endif
{
register const char *yys = yystr;
 
while (*yys++ != '\0')
YYSIZE_T yylen;
for (yylen = 0; yystr[yylen]; yylen++)
continue;
 
return yys - yystr - 1;
return yylen;
}
# endif
# endif
 
# ifndef yystpcpy
# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
# 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 *
# if defined (__STDC__) || defined (__cplusplus)
yystpcpy (char *yydest, const char *yysrc)
# else
#else
static char *
yystpcpy (yydest, yysrc)
char *yydest;
const char *yysrc;
# endif
char *yydest;
const char *yysrc;
#endif
{
register char *yyd = yydest;
register const char *yys = yysrc;
char *yyd = yydest;
const char *yys = yysrc;
 
while ((*yyd++ = *yys++) != '\0')
continue;
1408,84 → 1631,204
# endif
# endif
 
#endif /* !YYERROR_VERBOSE */
# 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;
 
#if YYDEBUG
/*--------------------------------.
| Print this symbol on YYOUTPUT. |
`--------------------------------*/
case '\\':
if (*++yyp != '\\')
goto do_not_strip_quotes;
/* Fall through. */
default:
if (yyres)
yyres[yyn] = *yyp;
yyn++;
break;
 
#if defined (__STDC__) || defined (__cplusplus)
static void
yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
#else
static void
yysymprint (yyoutput, yytype, yyvaluep)
FILE *yyoutput;
int yytype;
YYSTYPE *yyvaluep;
#endif
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)
{
/* Pacify ``unused variable'' warnings. */
(void) yyvaluep;
int yyn = yypact[yystate];
 
if (yytype < YYNTOKENS)
if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
return 0;
else
{
YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
# ifdef YYPRINT
YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
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
}
else
YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
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;
 
switch (yytype)
{
default:
break;
/* 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;
}
YYFPRINTF (yyoutput, ")");
}
#endif /* YYERROR_VERBOSE */
 
#endif /* ! YYDEBUG */
/*-----------------------------------------------.
| Release the memory associated to this symbol. |
`-----------------------------------------------*/
 
#if defined (__STDC__) || defined (__cplusplus)
/*ARGSUSED*/
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
static void
yydestruct (int yytype, YYSTYPE *yyvaluep)
yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
#else
static void
yydestruct (yytype, yyvaluep)
yydestruct (yymsg, yytype, yyvaluep)
const char *yymsg;
int yytype;
YYSTYPE *yyvaluep;
#endif
{
/* Pacify ``unused variable'' warnings. */
(void) yyvaluep;
YYUSE (yyvaluep);
 
if (!yymsg)
yymsg = "Deleting";
YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
 
switch (yytype)
{
 
default:
break;
break;
}
}
 
/* Prevent warnings from -Wmissing-prototypes. */
 
#ifdef YYPARSE_PARAM
# if defined (__STDC__) || defined (__cplusplus)
#if defined __STDC__ || defined __cplusplus
int yyparse (void *YYPARSE_PARAM);
# else
#else
int yyparse ();
# endif
#endif
#else /* ! YYPARSE_PARAM */
#if defined (__STDC__) || defined (__cplusplus)
#if defined __STDC__ || defined __cplusplus
int yyparse (void);
#else
int yyparse ();
1493,7 → 1836,6
#endif /* ! YYPARSE_PARAM */
 
 
 
/* The lookahead symbol. */
int yychar;
 
1505,19 → 1847,23
 
 
 
/*----------.
| yyparse. |
`----------*/
/*-------------------------.
| yyparse or yypush_parse. |
`-------------------------*/
 
#ifdef YYPARSE_PARAM
# if defined (__STDC__) || defined (__cplusplus)
int yyparse (void *YYPARSE_PARAM)
# else
int yyparse (YYPARSE_PARAM)
void *YYPARSE_PARAM;
# endif
#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 (__cplusplus)
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
int
yyparse (void)
#else
1527,60 → 1873,68
#endif
#endif
{
register int yystate;
register int yyn;
int yyresult;
/* Number of tokens to shift before error messages enabled. */
int yyerrstatus;
/* Lookahead token as an internal (translated) token number. */
int yytoken = 0;
 
/* 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 xreallocate them elsewhere. */
int yystate;
/* Number of tokens to shift before error messages enabled. */
int yyerrstatus;
 
/* The state stack. */
short yyssa[YYINITDEPTH];
short *yyss = yyssa;
register short *yyssp;
/* The stacks and their tools:
`yyss': related to states.
`yyvs': related to semantic values.
 
/* The semantic value stack. */
YYSTYPE yyvsa[YYINITDEPTH];
YYSTYPE *yyvs = yyvsa;
register YYSTYPE *yyvsp;
Refer to the stacks thru separate pointers, to allow yyoverflow
to xreallocate them elsewhere. */
 
/* The state stack. */
yytype_int16 yyssa[YYINITDEPTH];
yytype_int16 *yyss;
yytype_int16 *yyssp;
 
/* The semantic value stack. */
YYSTYPE yyvsa[YYINITDEPTH];
YYSTYPE *yyvs;
YYSTYPE *yyvsp;
 
#define YYPOPSTACK (yyvsp--, yyssp--)
YYSIZE_T yystacksize;
 
YYSIZE_T yystacksize = YYINITDEPTH;
 
int yyn;
int yyresult;
/* Lookahead token as an internal (translated) token number. */
int yytoken;
/* The variables used to return semantic value and location from the
action routines. */
YYSTYPE yyval;
 
#if YYERROR_VERBOSE
/* Buffer for error messages, and its allocated size. */
char yymsgbuf[128];
char *yymsg = yymsgbuf;
YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
#endif
 
/* When reducing, the number of symbols on the RHS of the reduced
rule. */
int yylen;
#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
 
/* The number of symbols on the RHS of the reduced rule.
Keep to zero when no symbol should be popped. */
int yylen = 0;
 
yytoken = 0;
yyss = yyssa;
yyvs = yyvsa;
yystacksize = YYINITDEPTH;
 
YYDPRINTF ((stderr, "Starting parse\n"));
 
yystate = 0;
yyerrstatus = 0;
yynerrs = 0;
yychar = YYEMPTY; /* Cause a token to be read. */
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;
 
1591,8 → 1945,7
`------------------------------------------------------------*/
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.
*/
have just been pushed. So pushing a state here evens the stacks. */
yyssp++;
 
yysetstate:
1605,21 → 1958,19
 
#ifdef yyoverflow
{
/* Give user a chance to xreallocate the stack. Use copies of
/* Give user a chance to xreallocate the stack. Use copies of
these so that the &'s don't force the real ones into
memory. */
YYSTYPE *yyvs1 = yyvs;
short *yyss1 = yyss;
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 ("parser stack overflow",
yyoverflow (YY_("memory exhausted"),
&yyss1, yysize * sizeof (*yyssp),
&yyvs1, yysize * sizeof (*yyvsp),
 
&yystacksize);
 
yyss = yyss1;
1627,24 → 1978,23
}
#else /* no yyoverflow */
# ifndef YYSTACK_RELOCATE
goto yyoverflowlab;
goto yyexhaustedlab;
# else
/* Extend the stack our own way. */
if (YYMAXDEPTH <= yystacksize)
goto yyoverflowlab;
goto yyexhaustedlab;
yystacksize *= 2;
if (YYMAXDEPTH < yystacksize)
yystacksize = YYMAXDEPTH;
 
{
short *yyss1 = yyss;
yytype_int16 *yyss1 = yyss;
union yyalloc *yyptr =
(union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
if (! yyptr)
goto yyoverflowlab;
YYSTACK_RELOCATE (yyss);
YYSTACK_RELOCATE (yyvs);
 
goto yyexhaustedlab;
YYSTACK_RELOCATE (yyss_alloc, yyss);
YYSTACK_RELOCATE (yyvs_alloc, yyvs);
# undef YYSTACK_RELOCATE
if (yyss1 != yyssa)
YYSTACK_FREE (yyss1);
1655,7 → 2005,6
yyssp = yyss + yysize - 1;
yyvsp = yyvs + yysize - 1;
 
 
YYDPRINTF ((stderr, "Stack size increased to %lu\n",
(unsigned long int) yystacksize));
 
1665,6 → 2014,9
 
YYDPRINTF ((stderr, "Entering state %d\n", yystate));
 
if (yystate == YYFINAL)
YYACCEPT;
 
goto yybackup;
 
/*-----------.
1672,12 → 2024,10
`-----------*/
yybackup:
 
/* Do appropriate processing given the current state. */
/* Read a lookahead token if we need one and don't already have one. */
/* yyresume: */
/* Do appropriate processing given the current state. Read a
lookahead token if we need one and don't already have one. */
 
/* First try to decide what to do without reference to lookahead token. */
 
yyn = yypact[yystate];
if (yyn == YYPACT_NINF)
goto yydefault;
1699,7 → 2049,7
else
{
yytoken = YYTRANSLATE (yychar);
YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc);
YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
}
 
/* If the proper action on seeing token YYTOKEN is to reduce or to
1716,25 → 2066,20
goto yyreduce;
}
 
if (yyn == YYFINAL)
YYACCEPT;
/* Count tokens shifted since error; after three, turn off error
status. */
if (yyerrstatus)
yyerrstatus--;
 
/* Shift the lookahead token. */
YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken]));
YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
 
/* Discard the token being shifted unless it is eof. */
if (yychar != YYEOF)
yychar = YYEMPTY;
/* Discard the shifted token. */
yychar = YYEMPTY;
 
yystate = yyn;
*++yyvsp = yylval;
 
 
/* Count tokens shifted since error; after three, turn off error
status. */
if (yyerrstatus)
yyerrstatus--;
 
yystate = yyn;
goto yynewstate;
 
 
1770,1047 → 2115,1383
switch (yyn)
{
case 2:
 
/* Line 1455 of yacc.c */
#line 357 "cp-name-parser.y"
{ global_result = yyvsp[0].comp; }
{ global_result = (yyvsp[(1) - (1)].comp); }
break;
 
case 6:
 
/* Line 1455 of yacc.c */
#line 369 "cp-name-parser.y"
{ yyval.comp = NULL; }
{ (yyval.comp) = NULL; }
break;
 
case 7:
 
/* Line 1455 of yacc.c */
#line 371 "cp-name-parser.y"
{ yyval.comp = yyvsp[0].comp; }
{ (yyval.comp) = (yyvsp[(2) - (2)].comp); }
break;
 
case 8:
 
/* Line 1455 of yacc.c */
#line 378 "cp-name-parser.y"
{ yyval.comp = yyvsp[0].nested.comp;
*yyvsp[0].nested.last = yyvsp[-1].comp;
{ (yyval.comp) = (yyvsp[(2) - (2)].nested).comp;
*(yyvsp[(2) - (2)].nested).last = (yyvsp[(1) - (2)].comp);
}
break;
 
case 9:
 
/* Line 1455 of yacc.c */
#line 387 "cp-name-parser.y"
{ yyval.comp = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, yyvsp[-2].comp, yyvsp[-1].nested.comp);
if (yyvsp[0].comp) yyval.comp = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, yyval.comp, yyvsp[0].comp); }
{ (yyval.comp) = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, (yyvsp[(1) - (3)].comp), (yyvsp[(2) - (3)].nested).comp);
if ((yyvsp[(3) - (3)].comp)) (yyval.comp) = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, (yyval.comp), (yyvsp[(3) - (3)].comp)); }
break;
 
case 10:
 
/* Line 1455 of yacc.c */
#line 390 "cp-name-parser.y"
{ yyval.comp = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, yyvsp[-2].comp, yyvsp[-1].nested.comp);
if (yyvsp[0].comp) yyval.comp = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, yyval.comp, yyvsp[0].comp); }
{ (yyval.comp) = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, (yyvsp[(1) - (3)].comp), (yyvsp[(2) - (3)].nested).comp);
if ((yyvsp[(3) - (3)].comp)) (yyval.comp) = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, (yyval.comp), (yyvsp[(3) - (3)].comp)); }
break;
 
case 11:
 
/* Line 1455 of yacc.c */
#line 394 "cp-name-parser.y"
{ yyval.comp = yyvsp[-1].nested.comp;
if (yyvsp[0].comp) yyval.comp = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, yyval.comp, yyvsp[0].comp); }
{ (yyval.comp) = (yyvsp[(1) - (2)].nested).comp;
if ((yyvsp[(2) - (2)].comp)) (yyval.comp) = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, (yyval.comp), (yyvsp[(2) - (2)].comp)); }
break;
 
case 12:
 
/* Line 1455 of yacc.c */
#line 397 "cp-name-parser.y"
{ if (yyvsp[0].abstract.last)
{ if ((yyvsp[(2) - (2)].abstract).last)
{
/* First complete the abstract_declarator's type using
the typespec from the conversion_op_name. */
*yyvsp[0].abstract.last = *yyvsp[-1].nested.last;
*(yyvsp[(2) - (2)].abstract).last = *(yyvsp[(1) - (2)].nested).last;
/* Then complete the conversion_op_name with the type. */
*yyvsp[-1].nested.last = yyvsp[0].abstract.comp;
*(yyvsp[(1) - (2)].nested).last = (yyvsp[(2) - (2)].abstract).comp;
}
/* If we have an arglist, build a function type. */
if (yyvsp[0].abstract.fn.comp)
yyval.comp = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, yyvsp[-1].nested.comp, yyvsp[0].abstract.fn.comp);
if ((yyvsp[(2) - (2)].abstract).fn.comp)
(yyval.comp) = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, (yyvsp[(1) - (2)].nested).comp, (yyvsp[(2) - (2)].abstract).fn.comp);
else
yyval.comp = yyvsp[-1].nested.comp;
if (yyvsp[0].abstract.start) yyval.comp = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, yyval.comp, yyvsp[0].abstract.start);
(yyval.comp) = (yyvsp[(1) - (2)].nested).comp;
if ((yyvsp[(2) - (2)].abstract).start) (yyval.comp) = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, (yyval.comp), (yyvsp[(2) - (2)].abstract).start);
}
break;
 
case 13:
 
/* Line 1455 of yacc.c */
#line 416 "cp-name-parser.y"
{ yyval.comp = make_empty (yyvsp[-1].lval);
d_left (yyval.comp) = yyvsp[0].comp;
d_right (yyval.comp) = NULL; }
{ (yyval.comp) = make_empty ((yyvsp[(1) - (2)].lval));
d_left ((yyval.comp)) = (yyvsp[(2) - (2)].comp);
d_right ((yyval.comp)) = NULL; }
break;
 
case 14:
 
/* Line 1455 of yacc.c */
#line 420 "cp-name-parser.y"
{ yyval.comp = fill_comp (DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE, yyvsp[-2].comp, yyvsp[0].comp); }
{ (yyval.comp) = fill_comp (DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE, (yyvsp[(2) - (4)].comp), (yyvsp[(4) - (4)].comp)); }
break;
 
case 15:
 
/* Line 1455 of yacc.c */
#line 424 "cp-name-parser.y"
{ yyval.comp = make_operator ("new", 1); }
{ (yyval.comp) = make_operator ("new", 1); }
break;
 
case 16:
 
/* Line 1455 of yacc.c */
#line 426 "cp-name-parser.y"
{ yyval.comp = make_operator ("delete", 1); }
{ (yyval.comp) = make_operator ("delete", 1); }
break;
 
case 17:
 
/* Line 1455 of yacc.c */
#line 428 "cp-name-parser.y"
{ yyval.comp = make_operator ("new[]", 1); }
{ (yyval.comp) = make_operator ("new[]", 1); }
break;
 
case 18:
 
/* Line 1455 of yacc.c */
#line 430 "cp-name-parser.y"
{ yyval.comp = make_operator ("delete[]", 1); }
{ (yyval.comp) = make_operator ("delete[]", 1); }
break;
 
case 19:
 
/* Line 1455 of yacc.c */
#line 432 "cp-name-parser.y"
{ yyval.comp = make_operator ("+", 2); }
{ (yyval.comp) = make_operator ("+", 2); }
break;
 
case 20:
 
/* Line 1455 of yacc.c */
#line 434 "cp-name-parser.y"
{ yyval.comp = make_operator ("-", 2); }
{ (yyval.comp) = make_operator ("-", 2); }
break;
 
case 21:
 
/* Line 1455 of yacc.c */
#line 436 "cp-name-parser.y"
{ yyval.comp = make_operator ("*", 2); }
{ (yyval.comp) = make_operator ("*", 2); }
break;
 
case 22:
 
/* Line 1455 of yacc.c */
#line 438 "cp-name-parser.y"
{ yyval.comp = make_operator ("/", 2); }
{ (yyval.comp) = make_operator ("/", 2); }
break;
 
case 23:
 
/* Line 1455 of yacc.c */
#line 440 "cp-name-parser.y"
{ yyval.comp = make_operator ("%", 2); }
{ (yyval.comp) = make_operator ("%", 2); }
break;
 
case 24:
 
/* Line 1455 of yacc.c */
#line 442 "cp-name-parser.y"
{ yyval.comp = make_operator ("^", 2); }
{ (yyval.comp) = make_operator ("^", 2); }
break;
 
case 25:
 
/* Line 1455 of yacc.c */
#line 444 "cp-name-parser.y"
{ yyval.comp = make_operator ("&", 2); }
{ (yyval.comp) = make_operator ("&", 2); }
break;
 
case 26:
 
/* Line 1455 of yacc.c */
#line 446 "cp-name-parser.y"
{ yyval.comp = make_operator ("|", 2); }
{ (yyval.comp) = make_operator ("|", 2); }
break;
 
case 27:
 
/* Line 1455 of yacc.c */
#line 448 "cp-name-parser.y"
{ yyval.comp = make_operator ("~", 1); }
{ (yyval.comp) = make_operator ("~", 1); }
break;
 
case 28:
 
/* Line 1455 of yacc.c */
#line 450 "cp-name-parser.y"
{ yyval.comp = make_operator ("!", 1); }
{ (yyval.comp) = make_operator ("!", 1); }
break;
 
case 29:
 
/* Line 1455 of yacc.c */
#line 452 "cp-name-parser.y"
{ yyval.comp = make_operator ("=", 2); }
{ (yyval.comp) = make_operator ("=", 2); }
break;
 
case 30:
 
/* Line 1455 of yacc.c */
#line 454 "cp-name-parser.y"
{ yyval.comp = make_operator ("<", 2); }
{ (yyval.comp) = make_operator ("<", 2); }
break;
 
case 31:
 
/* Line 1455 of yacc.c */
#line 456 "cp-name-parser.y"
{ yyval.comp = make_operator (">", 2); }
{ (yyval.comp) = make_operator (">", 2); }
break;
 
case 32:
 
/* Line 1455 of yacc.c */
#line 458 "cp-name-parser.y"
{ yyval.comp = make_operator (yyvsp[0].opname, 2); }
{ (yyval.comp) = make_operator ((yyvsp[(2) - (2)].opname), 2); }
break;
 
case 33:
 
/* Line 1455 of yacc.c */
#line 460 "cp-name-parser.y"
{ yyval.comp = make_operator ("<<", 2); }
{ (yyval.comp) = make_operator ("<<", 2); }
break;
 
case 34:
 
/* Line 1455 of yacc.c */
#line 462 "cp-name-parser.y"
{ yyval.comp = make_operator (">>", 2); }
{ (yyval.comp) = make_operator (">>", 2); }
break;
 
case 35:
 
/* Line 1455 of yacc.c */
#line 464 "cp-name-parser.y"
{ yyval.comp = make_operator ("==", 2); }
{ (yyval.comp) = make_operator ("==", 2); }
break;
 
case 36:
 
/* Line 1455 of yacc.c */
#line 466 "cp-name-parser.y"
{ yyval.comp = make_operator ("!=", 2); }
{ (yyval.comp) = make_operator ("!=", 2); }
break;
 
case 37:
 
/* Line 1455 of yacc.c */
#line 468 "cp-name-parser.y"
{ yyval.comp = make_operator ("<=", 2); }
{ (yyval.comp) = make_operator ("<=", 2); }
break;
 
case 38:
 
/* Line 1455 of yacc.c */
#line 470 "cp-name-parser.y"
{ yyval.comp = make_operator (">=", 2); }
{ (yyval.comp) = make_operator (">=", 2); }
break;
 
case 39:
 
/* Line 1455 of yacc.c */
#line 472 "cp-name-parser.y"
{ yyval.comp = make_operator ("&&", 2); }
{ (yyval.comp) = make_operator ("&&", 2); }
break;
 
case 40:
 
/* Line 1455 of yacc.c */
#line 474 "cp-name-parser.y"
{ yyval.comp = make_operator ("||", 2); }
{ (yyval.comp) = make_operator ("||", 2); }
break;
 
case 41:
 
/* Line 1455 of yacc.c */
#line 476 "cp-name-parser.y"
{ yyval.comp = make_operator ("++", 1); }
{ (yyval.comp) = make_operator ("++", 1); }
break;
 
case 42:
 
/* Line 1455 of yacc.c */
#line 478 "cp-name-parser.y"
{ yyval.comp = make_operator ("--", 1); }
{ (yyval.comp) = make_operator ("--", 1); }
break;
 
case 43:
 
/* Line 1455 of yacc.c */
#line 480 "cp-name-parser.y"
{ yyval.comp = make_operator (",", 2); }
{ (yyval.comp) = make_operator (",", 2); }
break;
 
case 44:
 
/* Line 1455 of yacc.c */
#line 482 "cp-name-parser.y"
{ yyval.comp = make_operator ("->*", 2); }
{ (yyval.comp) = make_operator ("->*", 2); }
break;
 
case 45:
 
/* Line 1455 of yacc.c */
#line 484 "cp-name-parser.y"
{ yyval.comp = make_operator ("->", 2); }
{ (yyval.comp) = make_operator ("->", 2); }
break;
 
case 46:
 
/* Line 1455 of yacc.c */
#line 486 "cp-name-parser.y"
{ yyval.comp = make_operator ("()", 2); }
{ (yyval.comp) = make_operator ("()", 2); }
break;
 
case 47:
 
/* Line 1455 of yacc.c */
#line 488 "cp-name-parser.y"
{ yyval.comp = make_operator ("[]", 2); }
{ (yyval.comp) = make_operator ("[]", 2); }
break;
 
case 48:
 
/* Line 1455 of yacc.c */
#line 496 "cp-name-parser.y"
{ yyval.comp = fill_comp (DEMANGLE_COMPONENT_CAST, yyvsp[0].comp, NULL); }
{ (yyval.comp) = fill_comp (DEMANGLE_COMPONENT_CAST, (yyvsp[(2) - (2)].comp), NULL); }
break;
 
case 49:
 
/* Line 1455 of yacc.c */
#line 501 "cp-name-parser.y"
{ yyval.nested.comp = yyvsp[-1].nested1.comp;
d_right (yyvsp[-1].nested1.last) = yyvsp[0].comp;
yyval.nested.last = &d_left (yyvsp[0].comp);
{ (yyval.nested).comp = (yyvsp[(1) - (2)].nested1).comp;
d_right ((yyvsp[(1) - (2)].nested1).last) = (yyvsp[(2) - (2)].comp);
(yyval.nested).last = &d_left ((yyvsp[(2) - (2)].comp));
}
break;
 
case 50:
 
/* Line 1455 of yacc.c */
#line 506 "cp-name-parser.y"
{ yyval.nested.comp = yyvsp[0].comp;
yyval.nested.last = &d_left (yyvsp[0].comp);
{ (yyval.nested).comp = (yyvsp[(1) - (1)].comp);
(yyval.nested).last = &d_left ((yyvsp[(1) - (1)].comp));
}
break;
 
case 51:
 
/* Line 1455 of yacc.c */
#line 510 "cp-name-parser.y"
{ yyval.nested.comp = yyvsp[-1].nested1.comp;
d_right (yyvsp[-1].nested1.last) = yyvsp[0].comp;
yyval.nested.last = &d_left (yyvsp[0].comp);
{ (yyval.nested).comp = (yyvsp[(2) - (3)].nested1).comp;
d_right ((yyvsp[(2) - (3)].nested1).last) = (yyvsp[(3) - (3)].comp);
(yyval.nested).last = &d_left ((yyvsp[(3) - (3)].comp));
}
break;
 
case 52:
 
/* Line 1455 of yacc.c */
#line 515 "cp-name-parser.y"
{ yyval.nested.comp = yyvsp[0].comp;
yyval.nested.last = &d_left (yyvsp[0].comp);
{ (yyval.nested).comp = (yyvsp[(2) - (2)].comp);
(yyval.nested).last = &d_left ((yyvsp[(2) - (2)].comp));
}
break;
 
case 54:
 
/* Line 1455 of yacc.c */
#line 524 "cp-name-parser.y"
{ yyval.comp = fill_comp (DEMANGLE_COMPONENT_TEMPLATE, yyvsp[-3].comp, yyvsp[-1].nested.comp); }
{ (yyval.comp) = fill_comp (DEMANGLE_COMPONENT_TEMPLATE, (yyvsp[(1) - (4)].comp), (yyvsp[(3) - (4)].nested).comp); }
break;
 
case 55:
 
/* Line 1455 of yacc.c */
#line 526 "cp-name-parser.y"
{ yyval.comp = make_dtor (gnu_v3_complete_object_dtor, yyvsp[0].comp); }
{ (yyval.comp) = make_dtor (gnu_v3_complete_object_dtor, (yyvsp[(2) - (2)].comp)); }
break;
 
case 57:
 
/* Line 1455 of yacc.c */
#line 539 "cp-name-parser.y"
{ yyval.comp = yyvsp[0].comp; }
{ (yyval.comp) = (yyvsp[(2) - (2)].comp); }
break;
 
case 58:
 
/* Line 1455 of yacc.c */
#line 545 "cp-name-parser.y"
{ yyval.comp = yyvsp[-1].nested1.comp; d_right (yyvsp[-1].nested1.last) = yyvsp[0].comp; }
{ (yyval.comp) = (yyvsp[(1) - (2)].nested1).comp; d_right ((yyvsp[(1) - (2)].nested1).last) = (yyvsp[(2) - (2)].comp); }
break;
 
case 60:
 
/* Line 1455 of yacc.c */
#line 548 "cp-name-parser.y"
{ yyval.comp = yyvsp[-1].nested1.comp; d_right (yyvsp[-1].nested1.last) = yyvsp[0].comp; }
{ (yyval.comp) = (yyvsp[(1) - (2)].nested1).comp; d_right ((yyvsp[(1) - (2)].nested1).last) = (yyvsp[(2) - (2)].comp); }
break;
 
case 65:
 
/* Line 1455 of yacc.c */
#line 558 "cp-name-parser.y"
{ yyval.comp = yyvsp[0].comp; }
{ (yyval.comp) = (yyvsp[(2) - (2)].comp); }
break;
 
case 66:
 
/* Line 1455 of yacc.c */
#line 562 "cp-name-parser.y"
{ yyval.comp = yyvsp[-1].nested1.comp; d_right (yyvsp[-1].nested1.last) = yyvsp[0].comp; }
{ (yyval.comp) = (yyvsp[(1) - (2)].nested1).comp; d_right ((yyvsp[(1) - (2)].nested1).last) = (yyvsp[(2) - (2)].comp); }
break;
 
case 68:
 
/* Line 1455 of yacc.c */
#line 567 "cp-name-parser.y"
{ yyval.nested1.comp = make_empty (DEMANGLE_COMPONENT_QUAL_NAME);
d_left (yyval.nested1.comp) = yyvsp[-1].comp;
d_right (yyval.nested1.comp) = NULL;
yyval.nested1.last = yyval.nested1.comp;
{ (yyval.nested1).comp = make_empty (DEMANGLE_COMPONENT_QUAL_NAME);
d_left ((yyval.nested1).comp) = (yyvsp[(1) - (2)].comp);
d_right ((yyval.nested1).comp) = NULL;
(yyval.nested1).last = (yyval.nested1).comp;
}
break;
 
case 69:
 
/* Line 1455 of yacc.c */
#line 573 "cp-name-parser.y"
{ yyval.nested1.comp = yyvsp[-2].nested1.comp;
d_right (yyvsp[-2].nested1.last) = make_empty (DEMANGLE_COMPONENT_QUAL_NAME);
yyval.nested1.last = d_right (yyvsp[-2].nested1.last);
d_left (yyval.nested1.last) = yyvsp[-1].comp;
d_right (yyval.nested1.last) = NULL;
{ (yyval.nested1).comp = (yyvsp[(1) - (3)].nested1).comp;
d_right ((yyvsp[(1) - (3)].nested1).last) = make_empty (DEMANGLE_COMPONENT_QUAL_NAME);
(yyval.nested1).last = d_right ((yyvsp[(1) - (3)].nested1).last);
d_left ((yyval.nested1).last) = (yyvsp[(2) - (3)].comp);
d_right ((yyval.nested1).last) = NULL;
}
break;
 
case 70:
 
/* Line 1455 of yacc.c */
#line 580 "cp-name-parser.y"
{ yyval.nested1.comp = make_empty (DEMANGLE_COMPONENT_QUAL_NAME);
d_left (yyval.nested1.comp) = yyvsp[-1].comp;
d_right (yyval.nested1.comp) = NULL;
yyval.nested1.last = yyval.nested1.comp;
{ (yyval.nested1).comp = make_empty (DEMANGLE_COMPONENT_QUAL_NAME);
d_left ((yyval.nested1).comp) = (yyvsp[(1) - (2)].comp);
d_right ((yyval.nested1).comp) = NULL;
(yyval.nested1).last = (yyval.nested1).comp;
}
break;
 
case 71:
 
/* Line 1455 of yacc.c */
#line 586 "cp-name-parser.y"
{ yyval.nested1.comp = yyvsp[-2].nested1.comp;
d_right (yyvsp[-2].nested1.last) = make_empty (DEMANGLE_COMPONENT_QUAL_NAME);
yyval.nested1.last = d_right (yyvsp[-2].nested1.last);
d_left (yyval.nested1.last) = yyvsp[-1].comp;
d_right (yyval.nested1.last) = NULL;
{ (yyval.nested1).comp = (yyvsp[(1) - (3)].nested1).comp;
d_right ((yyvsp[(1) - (3)].nested1).last) = make_empty (DEMANGLE_COMPONENT_QUAL_NAME);
(yyval.nested1).last = d_right ((yyvsp[(1) - (3)].nested1).last);
d_left ((yyval.nested1).last) = (yyvsp[(2) - (3)].comp);
d_right ((yyval.nested1).last) = NULL;
}
break;
 
case 72:
 
/* Line 1455 of yacc.c */
#line 597 "cp-name-parser.y"
{ yyval.comp = fill_comp (DEMANGLE_COMPONENT_TEMPLATE, yyvsp[-3].comp, yyvsp[-1].nested.comp); }
{ (yyval.comp) = fill_comp (DEMANGLE_COMPONENT_TEMPLATE, (yyvsp[(1) - (4)].comp), (yyvsp[(3) - (4)].nested).comp); }
break;
 
case 73:
 
/* Line 1455 of yacc.c */
#line 601 "cp-name-parser.y"
{ yyval.nested.comp = fill_comp (DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, yyvsp[0].comp, NULL);
yyval.nested.last = &d_right (yyval.nested.comp); }
{ (yyval.nested).comp = fill_comp (DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, (yyvsp[(1) - (1)].comp), NULL);
(yyval.nested).last = &d_right ((yyval.nested).comp); }
break;
 
case 74:
 
/* Line 1455 of yacc.c */
#line 604 "cp-name-parser.y"
{ yyval.nested.comp = yyvsp[-2].nested.comp;
*yyvsp[-2].nested.last = fill_comp (DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, yyvsp[0].comp, NULL);
yyval.nested.last = &d_right (*yyvsp[-2].nested.last);
{ (yyval.nested).comp = (yyvsp[(1) - (3)].nested).comp;
*(yyvsp[(1) - (3)].nested).last = fill_comp (DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, (yyvsp[(3) - (3)].comp), NULL);
(yyval.nested).last = &d_right (*(yyvsp[(1) - (3)].nested).last);
}
break;
 
case 76:
 
/* Line 1455 of yacc.c */
#line 616 "cp-name-parser.y"
{ yyval.comp = yyvsp[0].abstract.comp;
*yyvsp[0].abstract.last = yyvsp[-1].comp;
{ (yyval.comp) = (yyvsp[(2) - (2)].abstract).comp;
*(yyvsp[(2) - (2)].abstract).last = (yyvsp[(1) - (2)].comp);
}
break;
 
case 77:
 
/* Line 1455 of yacc.c */
#line 620 "cp-name-parser.y"
{ yyval.comp = fill_comp (DEMANGLE_COMPONENT_UNARY, make_operator ("&", 1), yyvsp[0].comp); }
{ (yyval.comp) = fill_comp (DEMANGLE_COMPONENT_UNARY, make_operator ("&", 1), (yyvsp[(2) - (2)].comp)); }
break;
 
case 78:
 
/* Line 1455 of yacc.c */
#line 622 "cp-name-parser.y"
{ yyval.comp = fill_comp (DEMANGLE_COMPONENT_UNARY, make_operator ("&", 1), yyvsp[-1].comp); }
{ (yyval.comp) = fill_comp (DEMANGLE_COMPONENT_UNARY, make_operator ("&", 1), (yyvsp[(3) - (4)].comp)); }
break;
 
case 80:
 
/* Line 1455 of yacc.c */
#line 627 "cp-name-parser.y"
{ yyval.nested.comp = fill_comp (DEMANGLE_COMPONENT_ARGLIST, yyvsp[0].comp, NULL);
yyval.nested.last = &d_right (yyval.nested.comp);
{ (yyval.nested).comp = fill_comp (DEMANGLE_COMPONENT_ARGLIST, (yyvsp[(1) - (1)].comp), NULL);
(yyval.nested).last = &d_right ((yyval.nested).comp);
}
break;
 
case 81:
 
/* Line 1455 of yacc.c */
#line 631 "cp-name-parser.y"
{ *yyvsp[0].abstract.last = yyvsp[-1].comp;
yyval.nested.comp = fill_comp (DEMANGLE_COMPONENT_ARGLIST, yyvsp[0].abstract.comp, NULL);
yyval.nested.last = &d_right (yyval.nested.comp);
{ *(yyvsp[(2) - (2)].abstract).last = (yyvsp[(1) - (2)].comp);
(yyval.nested).comp = fill_comp (DEMANGLE_COMPONENT_ARGLIST, (yyvsp[(2) - (2)].abstract).comp, NULL);
(yyval.nested).last = &d_right ((yyval.nested).comp);
}
break;
 
case 82:
 
/* Line 1455 of yacc.c */
#line 636 "cp-name-parser.y"
{ *yyvsp[-2].nested.last = fill_comp (DEMANGLE_COMPONENT_ARGLIST, yyvsp[0].comp, NULL);
yyval.nested.comp = yyvsp[-2].nested.comp;
yyval.nested.last = &d_right (*yyvsp[-2].nested.last);
{ *(yyvsp[(1) - (3)].nested).last = fill_comp (DEMANGLE_COMPONENT_ARGLIST, (yyvsp[(3) - (3)].comp), NULL);
(yyval.nested).comp = (yyvsp[(1) - (3)].nested).comp;
(yyval.nested).last = &d_right (*(yyvsp[(1) - (3)].nested).last);
}
break;
 
case 83:
 
/* Line 1455 of yacc.c */
#line 641 "cp-name-parser.y"
{ *yyvsp[0].abstract.last = yyvsp[-1].comp;
*yyvsp[-3].nested.last = fill_comp (DEMANGLE_COMPONENT_ARGLIST, yyvsp[0].abstract.comp, NULL);
yyval.nested.comp = yyvsp[-3].nested.comp;
yyval.nested.last = &d_right (*yyvsp[-3].nested.last);
{ *(yyvsp[(4) - (4)].abstract).last = (yyvsp[(3) - (4)].comp);
*(yyvsp[(1) - (4)].nested).last = fill_comp (DEMANGLE_COMPONENT_ARGLIST, (yyvsp[(4) - (4)].abstract).comp, NULL);
(yyval.nested).comp = (yyvsp[(1) - (4)].nested).comp;
(yyval.nested).last = &d_right (*(yyvsp[(1) - (4)].nested).last);
}
break;
 
case 84:
 
/* Line 1455 of yacc.c */
#line 647 "cp-name-parser.y"
{ *yyvsp[-2].nested.last
{ *(yyvsp[(1) - (3)].nested).last
= fill_comp (DEMANGLE_COMPONENT_ARGLIST,
make_builtin_type ("..."),
NULL);
yyval.nested.comp = yyvsp[-2].nested.comp;
yyval.nested.last = &d_right (*yyvsp[-2].nested.last);
(yyval.nested).comp = (yyvsp[(1) - (3)].nested).comp;
(yyval.nested).last = &d_right (*(yyvsp[(1) - (3)].nested).last);
}
break;
 
case 85:
 
/* Line 1455 of yacc.c */
#line 657 "cp-name-parser.y"
{ yyval.nested.comp = fill_comp (DEMANGLE_COMPONENT_FUNCTION_TYPE, NULL, yyvsp[-2].nested.comp);
yyval.nested.last = &d_left (yyval.nested.comp);
yyval.nested.comp = d_qualify (yyval.nested.comp, yyvsp[0].lval, 1); }
{ (yyval.nested).comp = fill_comp (DEMANGLE_COMPONENT_FUNCTION_TYPE, NULL, (yyvsp[(2) - (4)].nested).comp);
(yyval.nested).last = &d_left ((yyval.nested).comp);
(yyval.nested).comp = d_qualify ((yyval.nested).comp, (yyvsp[(4) - (4)].lval), 1); }
break;
 
case 86:
 
/* Line 1455 of yacc.c */
#line 661 "cp-name-parser.y"
{ yyval.nested.comp = fill_comp (DEMANGLE_COMPONENT_FUNCTION_TYPE, NULL, NULL);
yyval.nested.last = &d_left (yyval.nested.comp);
yyval.nested.comp = d_qualify (yyval.nested.comp, yyvsp[0].lval, 1); }
{ (yyval.nested).comp = fill_comp (DEMANGLE_COMPONENT_FUNCTION_TYPE, NULL, NULL);
(yyval.nested).last = &d_left ((yyval.nested).comp);
(yyval.nested).comp = d_qualify ((yyval.nested).comp, (yyvsp[(4) - (4)].lval), 1); }
break;
 
case 87:
 
/* Line 1455 of yacc.c */
#line 665 "cp-name-parser.y"
{ yyval.nested.comp = fill_comp (DEMANGLE_COMPONENT_FUNCTION_TYPE, NULL, NULL);
yyval.nested.last = &d_left (yyval.nested.comp);
yyval.nested.comp = d_qualify (yyval.nested.comp, yyvsp[0].lval, 1); }
{ (yyval.nested).comp = fill_comp (DEMANGLE_COMPONENT_FUNCTION_TYPE, NULL, NULL);
(yyval.nested).last = &d_left ((yyval.nested).comp);
(yyval.nested).comp = d_qualify ((yyval.nested).comp, (yyvsp[(3) - (3)].lval), 1); }
break;
 
case 88:
 
/* Line 1455 of yacc.c */
#line 672 "cp-name-parser.y"
{ yyval.lval = 0; }
{ (yyval.lval) = 0; }
break;
 
case 90:
 
/* Line 1455 of yacc.c */
#line 677 "cp-name-parser.y"
{ yyval.lval = QUAL_RESTRICT; }
{ (yyval.lval) = QUAL_RESTRICT; }
break;
 
case 91:
 
/* Line 1455 of yacc.c */
#line 679 "cp-name-parser.y"
{ yyval.lval = QUAL_VOLATILE; }
{ (yyval.lval) = QUAL_VOLATILE; }
break;
 
case 92:
 
/* Line 1455 of yacc.c */
#line 681 "cp-name-parser.y"
{ yyval.lval = QUAL_CONST; }
{ (yyval.lval) = QUAL_CONST; }
break;
 
case 94:
 
/* Line 1455 of yacc.c */
#line 686 "cp-name-parser.y"
{ yyval.lval = yyvsp[-1].lval | yyvsp[0].lval; }
{ (yyval.lval) = (yyvsp[(1) - (2)].lval) | (yyvsp[(2) - (2)].lval); }
break;
 
case 95:
 
/* Line 1455 of yacc.c */
#line 693 "cp-name-parser.y"
{ yyval.lval = 0; }
{ (yyval.lval) = 0; }
break;
 
case 96:
 
/* Line 1455 of yacc.c */
#line 695 "cp-name-parser.y"
{ yyval.lval = INT_SIGNED; }
{ (yyval.lval) = INT_SIGNED; }
break;
 
case 97:
 
/* Line 1455 of yacc.c */
#line 697 "cp-name-parser.y"
{ yyval.lval = INT_UNSIGNED; }
{ (yyval.lval) = INT_UNSIGNED; }
break;
 
case 98:
 
/* Line 1455 of yacc.c */
#line 699 "cp-name-parser.y"
{ yyval.lval = INT_CHAR; }
{ (yyval.lval) = INT_CHAR; }
break;
 
case 99:
 
/* Line 1455 of yacc.c */
#line 701 "cp-name-parser.y"
{ yyval.lval = INT_LONG; }
{ (yyval.lval) = INT_LONG; }
break;
 
case 100:
 
/* Line 1455 of yacc.c */
#line 703 "cp-name-parser.y"
{ yyval.lval = INT_SHORT; }
{ (yyval.lval) = INT_SHORT; }
break;
 
case 102:
 
/* Line 1455 of yacc.c */
#line 708 "cp-name-parser.y"
{ yyval.lval = yyvsp[-1].lval | yyvsp[0].lval; if (yyvsp[-1].lval & yyvsp[0].lval & INT_LONG) yyval.lval = yyvsp[-1].lval | INT_LLONG; }
{ (yyval.lval) = (yyvsp[(1) - (2)].lval) | (yyvsp[(2) - (2)].lval); if ((yyvsp[(1) - (2)].lval) & (yyvsp[(2) - (2)].lval) & INT_LONG) (yyval.lval) = (yyvsp[(1) - (2)].lval) | INT_LLONG; }
break;
 
case 103:
 
/* Line 1455 of yacc.c */
#line 712 "cp-name-parser.y"
{ yyval.comp = d_int_type (yyvsp[0].lval); }
{ (yyval.comp) = d_int_type ((yyvsp[(1) - (1)].lval)); }
break;
 
case 104:
 
/* Line 1455 of yacc.c */
#line 714 "cp-name-parser.y"
{ yyval.comp = make_builtin_type ("float"); }
{ (yyval.comp) = make_builtin_type ("float"); }
break;
 
case 105:
 
/* Line 1455 of yacc.c */
#line 716 "cp-name-parser.y"
{ yyval.comp = make_builtin_type ("double"); }
{ (yyval.comp) = make_builtin_type ("double"); }
break;
 
case 106:
 
/* Line 1455 of yacc.c */
#line 718 "cp-name-parser.y"
{ yyval.comp = make_builtin_type ("long double"); }
{ (yyval.comp) = make_builtin_type ("long double"); }
break;
 
case 107:
 
/* Line 1455 of yacc.c */
#line 720 "cp-name-parser.y"
{ yyval.comp = make_builtin_type ("bool"); }
{ (yyval.comp) = make_builtin_type ("bool"); }
break;
 
case 108:
 
/* Line 1455 of yacc.c */
#line 722 "cp-name-parser.y"
{ yyval.comp = make_builtin_type ("wchar_t"); }
{ (yyval.comp) = make_builtin_type ("wchar_t"); }
break;
 
case 109:
 
/* Line 1455 of yacc.c */
#line 724 "cp-name-parser.y"
{ yyval.comp = make_builtin_type ("void"); }
{ (yyval.comp) = make_builtin_type ("void"); }
break;
 
case 110:
 
/* Line 1455 of yacc.c */
#line 728 "cp-name-parser.y"
{ yyval.nested.comp = make_empty (DEMANGLE_COMPONENT_POINTER);
yyval.nested.comp->u.s_binary.left = yyval.nested.comp->u.s_binary.right = NULL;
yyval.nested.last = &d_left (yyval.nested.comp);
yyval.nested.comp = d_qualify (yyval.nested.comp, yyvsp[0].lval, 0); }
{ (yyval.nested).comp = make_empty (DEMANGLE_COMPONENT_POINTER);
(yyval.nested).comp->u.s_binary.left = (yyval.nested).comp->u.s_binary.right = NULL;
(yyval.nested).last = &d_left ((yyval.nested).comp);
(yyval.nested).comp = d_qualify ((yyval.nested).comp, (yyvsp[(2) - (2)].lval), 0); }
break;
 
case 111:
 
/* Line 1455 of yacc.c */
#line 734 "cp-name-parser.y"
{ yyval.nested.comp = make_empty (DEMANGLE_COMPONENT_REFERENCE);
yyval.nested.comp->u.s_binary.left = yyval.nested.comp->u.s_binary.right = NULL;
yyval.nested.last = &d_left (yyval.nested.comp); }
{ (yyval.nested).comp = make_empty (DEMANGLE_COMPONENT_REFERENCE);
(yyval.nested).comp->u.s_binary.left = (yyval.nested).comp->u.s_binary.right = NULL;
(yyval.nested).last = &d_left ((yyval.nested).comp); }
break;
 
case 112:
 
/* Line 1455 of yacc.c */
#line 738 "cp-name-parser.y"
{ yyval.nested.comp = make_empty (DEMANGLE_COMPONENT_PTRMEM_TYPE);
yyval.nested.comp->u.s_binary.left = yyvsp[-2].nested1.comp;
{ (yyval.nested).comp = make_empty (DEMANGLE_COMPONENT_PTRMEM_TYPE);
(yyval.nested).comp->u.s_binary.left = (yyvsp[(1) - (3)].nested1).comp;
/* Convert the innermost DEMANGLE_COMPONENT_QUAL_NAME to a DEMANGLE_COMPONENT_NAME. */
*yyvsp[-2].nested1.last = *d_left (yyvsp[-2].nested1.last);
yyval.nested.comp->u.s_binary.right = NULL;
yyval.nested.last = &d_right (yyval.nested.comp);
yyval.nested.comp = d_qualify (yyval.nested.comp, yyvsp[0].lval, 0); }
*(yyvsp[(1) - (3)].nested1).last = *d_left ((yyvsp[(1) - (3)].nested1).last);
(yyval.nested).comp->u.s_binary.right = NULL;
(yyval.nested).last = &d_right ((yyval.nested).comp);
(yyval.nested).comp = d_qualify ((yyval.nested).comp, (yyvsp[(3) - (3)].lval), 0); }
break;
 
case 113:
 
/* Line 1455 of yacc.c */
#line 746 "cp-name-parser.y"
{ yyval.nested.comp = make_empty (DEMANGLE_COMPONENT_PTRMEM_TYPE);
yyval.nested.comp->u.s_binary.left = yyvsp[-2].nested1.comp;
{ (yyval.nested).comp = make_empty (DEMANGLE_COMPONENT_PTRMEM_TYPE);
(yyval.nested).comp->u.s_binary.left = (yyvsp[(2) - (4)].nested1).comp;
/* Convert the innermost DEMANGLE_COMPONENT_QUAL_NAME to a DEMANGLE_COMPONENT_NAME. */
*yyvsp[-2].nested1.last = *d_left (yyvsp[-2].nested1.last);
yyval.nested.comp->u.s_binary.right = NULL;
yyval.nested.last = &d_right (yyval.nested.comp);
yyval.nested.comp = d_qualify (yyval.nested.comp, yyvsp[0].lval, 0); }
*(yyvsp[(2) - (4)].nested1).last = *d_left ((yyvsp[(2) - (4)].nested1).last);
(yyval.nested).comp->u.s_binary.right = NULL;
(yyval.nested).last = &d_right ((yyval.nested).comp);
(yyval.nested).comp = d_qualify ((yyval.nested).comp, (yyvsp[(4) - (4)].lval), 0); }
break;
 
case 114:
 
/* Line 1455 of yacc.c */
#line 756 "cp-name-parser.y"
{ yyval.comp = make_empty (DEMANGLE_COMPONENT_ARRAY_TYPE);
d_left (yyval.comp) = NULL;
{ (yyval.comp) = make_empty (DEMANGLE_COMPONENT_ARRAY_TYPE);
d_left ((yyval.comp)) = NULL;
}
break;
 
case 115:
 
/* Line 1455 of yacc.c */
#line 760 "cp-name-parser.y"
{ yyval.comp = make_empty (DEMANGLE_COMPONENT_ARRAY_TYPE);
d_left (yyval.comp) = yyvsp[-1].comp;
{ (yyval.comp) = make_empty (DEMANGLE_COMPONENT_ARRAY_TYPE);
d_left ((yyval.comp)) = (yyvsp[(2) - (3)].comp);
}
break;
 
case 116:
 
/* Line 1455 of yacc.c */
#line 776 "cp-name-parser.y"
{ yyval.comp = d_qualify (yyvsp[-1].comp, yyvsp[0].lval, 0); }
{ (yyval.comp) = d_qualify ((yyvsp[(1) - (2)].comp), (yyvsp[(2) - (2)].lval), 0); }
break;
 
case 118:
 
/* Line 1455 of yacc.c */
#line 779 "cp-name-parser.y"
{ yyval.comp = d_qualify (yyvsp[-1].comp, yyvsp[-2].lval | yyvsp[0].lval, 0); }
{ (yyval.comp) = d_qualify ((yyvsp[(2) - (3)].comp), (yyvsp[(1) - (3)].lval) | (yyvsp[(3) - (3)].lval), 0); }
break;
 
case 119:
 
/* Line 1455 of yacc.c */
#line 781 "cp-name-parser.y"
{ yyval.comp = d_qualify (yyvsp[0].comp, yyvsp[-1].lval, 0); }
{ (yyval.comp) = d_qualify ((yyvsp[(2) - (2)].comp), (yyvsp[(1) - (2)].lval), 0); }
break;
 
case 120:
 
/* Line 1455 of yacc.c */
#line 784 "cp-name-parser.y"
{ yyval.comp = d_qualify (yyvsp[-1].comp, yyvsp[0].lval, 0); }
{ (yyval.comp) = d_qualify ((yyvsp[(1) - (2)].comp), (yyvsp[(2) - (2)].lval), 0); }
break;
 
case 122:
 
/* Line 1455 of yacc.c */
#line 787 "cp-name-parser.y"
{ yyval.comp = d_qualify (yyvsp[-1].comp, yyvsp[-2].lval | yyvsp[0].lval, 0); }
{ (yyval.comp) = d_qualify ((yyvsp[(2) - (3)].comp), (yyvsp[(1) - (3)].lval) | (yyvsp[(3) - (3)].lval), 0); }
break;
 
case 123:
 
/* Line 1455 of yacc.c */
#line 789 "cp-name-parser.y"
{ yyval.comp = d_qualify (yyvsp[0].comp, yyvsp[-1].lval, 0); }
{ (yyval.comp) = d_qualify ((yyvsp[(2) - (2)].comp), (yyvsp[(1) - (2)].lval), 0); }
break;
 
case 124:
 
/* Line 1455 of yacc.c */
#line 792 "cp-name-parser.y"
{ yyval.comp = d_qualify (yyvsp[-1].comp, yyvsp[0].lval, 0); }
{ (yyval.comp) = d_qualify ((yyvsp[(2) - (3)].comp), (yyvsp[(3) - (3)].lval), 0); }
break;
 
case 125:
 
/* Line 1455 of yacc.c */
#line 794 "cp-name-parser.y"
{ yyval.comp = yyvsp[0].comp; }
{ (yyval.comp) = (yyvsp[(2) - (2)].comp); }
break;
 
case 126:
 
/* Line 1455 of yacc.c */
#line 796 "cp-name-parser.y"
{ yyval.comp = d_qualify (yyvsp[-1].comp, yyvsp[-3].lval | yyvsp[0].lval, 0); }
{ (yyval.comp) = d_qualify ((yyvsp[(3) - (4)].comp), (yyvsp[(1) - (4)].lval) | (yyvsp[(4) - (4)].lval), 0); }
break;
 
case 127:
 
/* Line 1455 of yacc.c */
#line 798 "cp-name-parser.y"
{ yyval.comp = d_qualify (yyvsp[0].comp, yyvsp[-2].lval, 0); }
{ (yyval.comp) = d_qualify ((yyvsp[(3) - (3)].comp), (yyvsp[(1) - (3)].lval), 0); }
break;
 
case 128:
 
/* Line 1455 of yacc.c */
#line 803 "cp-name-parser.y"
{ yyval.abstract.comp = yyvsp[0].nested.comp; yyval.abstract.last = yyvsp[0].nested.last;
yyval.abstract.fn.comp = NULL; yyval.abstract.fn.last = NULL; }
{ (yyval.abstract).comp = (yyvsp[(1) - (1)].nested).comp; (yyval.abstract).last = (yyvsp[(1) - (1)].nested).last;
(yyval.abstract).fn.comp = NULL; (yyval.abstract).fn.last = NULL; }
break;
 
case 129:
 
/* Line 1455 of yacc.c */
#line 806 "cp-name-parser.y"
{ yyval.abstract = yyvsp[0].abstract; yyval.abstract.fn.comp = NULL; yyval.abstract.fn.last = NULL;
if (yyvsp[0].abstract.fn.comp) { yyval.abstract.last = yyvsp[0].abstract.fn.last; *yyvsp[0].abstract.last = yyvsp[0].abstract.fn.comp; }
*yyval.abstract.last = yyvsp[-1].nested.comp;
yyval.abstract.last = yyvsp[-1].nested.last; }
{ (yyval.abstract) = (yyvsp[(2) - (2)].abstract); (yyval.abstract).fn.comp = NULL; (yyval.abstract).fn.last = NULL;
if ((yyvsp[(2) - (2)].abstract).fn.comp) { (yyval.abstract).last = (yyvsp[(2) - (2)].abstract).fn.last; *(yyvsp[(2) - (2)].abstract).last = (yyvsp[(2) - (2)].abstract).fn.comp; }
*(yyval.abstract).last = (yyvsp[(1) - (2)].nested).comp;
(yyval.abstract).last = (yyvsp[(1) - (2)].nested).last; }
break;
 
case 130:
 
/* Line 1455 of yacc.c */
#line 811 "cp-name-parser.y"
{ yyval.abstract.fn.comp = NULL; yyval.abstract.fn.last = NULL;
if (yyvsp[0].abstract.fn.comp) { yyval.abstract.last = yyvsp[0].abstract.fn.last; *yyvsp[0].abstract.last = yyvsp[0].abstract.fn.comp; }
{ (yyval.abstract).fn.comp = NULL; (yyval.abstract).fn.last = NULL;
if ((yyvsp[(1) - (1)].abstract).fn.comp) { (yyval.abstract).last = (yyvsp[(1) - (1)].abstract).fn.last; *(yyvsp[(1) - (1)].abstract).last = (yyvsp[(1) - (1)].abstract).fn.comp; }
}
break;
 
case 131:
 
/* Line 1455 of yacc.c */
#line 818 "cp-name-parser.y"
{ yyval.abstract = yyvsp[-1].abstract; yyval.abstract.fn.comp = NULL; yyval.abstract.fn.last = NULL; yyval.abstract.fold_flag = 1;
if (yyvsp[-1].abstract.fn.comp) { yyval.abstract.last = yyvsp[-1].abstract.fn.last; *yyvsp[-1].abstract.last = yyvsp[-1].abstract.fn.comp; }
{ (yyval.abstract) = (yyvsp[(2) - (3)].abstract); (yyval.abstract).fn.comp = NULL; (yyval.abstract).fn.last = NULL; (yyval.abstract).fold_flag = 1;
if ((yyvsp[(2) - (3)].abstract).fn.comp) { (yyval.abstract).last = (yyvsp[(2) - (3)].abstract).fn.last; *(yyvsp[(2) - (3)].abstract).last = (yyvsp[(2) - (3)].abstract).fn.comp; }
}
break;
 
case 132:
 
/* Line 1455 of yacc.c */
#line 822 "cp-name-parser.y"
{ yyval.abstract.fold_flag = 0;
if (yyvsp[-1].abstract.fn.comp) { yyval.abstract.last = yyvsp[-1].abstract.fn.last; *yyvsp[-1].abstract.last = yyvsp[-1].abstract.fn.comp; }
if (yyvsp[-1].abstract.fold_flag)
{ (yyval.abstract).fold_flag = 0;
if ((yyvsp[(1) - (2)].abstract).fn.comp) { (yyval.abstract).last = (yyvsp[(1) - (2)].abstract).fn.last; *(yyvsp[(1) - (2)].abstract).last = (yyvsp[(1) - (2)].abstract).fn.comp; }
if ((yyvsp[(1) - (2)].abstract).fold_flag)
{
*yyval.abstract.last = yyvsp[0].nested.comp;
yyval.abstract.last = yyvsp[0].nested.last;
*(yyval.abstract).last = (yyvsp[(2) - (2)].nested).comp;
(yyval.abstract).last = (yyvsp[(2) - (2)].nested).last;
}
else
yyval.abstract.fn = yyvsp[0].nested;
(yyval.abstract).fn = (yyvsp[(2) - (2)].nested);
}
break;
 
case 133:
 
/* Line 1455 of yacc.c */
#line 833 "cp-name-parser.y"
{ yyval.abstract.fn.comp = NULL; yyval.abstract.fn.last = NULL; yyval.abstract.fold_flag = 0;
if (yyvsp[-1].abstract.fn.comp) { yyval.abstract.last = yyvsp[-1].abstract.fn.last; *yyvsp[-1].abstract.last = yyvsp[-1].abstract.fn.comp; }
*yyvsp[-1].abstract.last = yyvsp[0].comp;
yyval.abstract.last = &d_right (yyvsp[0].comp);
{ (yyval.abstract).fn.comp = NULL; (yyval.abstract).fn.last = NULL; (yyval.abstract).fold_flag = 0;
if ((yyvsp[(1) - (2)].abstract).fn.comp) { (yyval.abstract).last = (yyvsp[(1) - (2)].abstract).fn.last; *(yyvsp[(1) - (2)].abstract).last = (yyvsp[(1) - (2)].abstract).fn.comp; }
*(yyvsp[(1) - (2)].abstract).last = (yyvsp[(2) - (2)].comp);
(yyval.abstract).last = &d_right ((yyvsp[(2) - (2)].comp));
}
break;
 
case 134:
 
/* Line 1455 of yacc.c */
#line 839 "cp-name-parser.y"
{ yyval.abstract.fn.comp = NULL; yyval.abstract.fn.last = NULL; yyval.abstract.fold_flag = 0;
yyval.abstract.comp = yyvsp[0].comp;
yyval.abstract.last = &d_right (yyvsp[0].comp);
{ (yyval.abstract).fn.comp = NULL; (yyval.abstract).fn.last = NULL; (yyval.abstract).fold_flag = 0;
(yyval.abstract).comp = (yyvsp[(1) - (1)].comp);
(yyval.abstract).last = &d_right ((yyvsp[(1) - (1)].comp));
}
break;
 
case 135:
 
/* Line 1455 of yacc.c */
#line 857 "cp-name-parser.y"
{ yyval.abstract.comp = yyvsp[0].nested.comp; yyval.abstract.last = yyvsp[0].nested.last;
yyval.abstract.fn.comp = NULL; yyval.abstract.fn.last = NULL; yyval.abstract.start = NULL; }
{ (yyval.abstract).comp = (yyvsp[(1) - (1)].nested).comp; (yyval.abstract).last = (yyvsp[(1) - (1)].nested).last;
(yyval.abstract).fn.comp = NULL; (yyval.abstract).fn.last = NULL; (yyval.abstract).start = NULL; }
break;
 
case 136:
 
/* Line 1455 of yacc.c */
#line 860 "cp-name-parser.y"
{ yyval.abstract = yyvsp[0].abstract;
if (yyvsp[0].abstract.last)
*yyval.abstract.last = yyvsp[-1].nested.comp;
{ (yyval.abstract) = (yyvsp[(2) - (2)].abstract);
if ((yyvsp[(2) - (2)].abstract).last)
*(yyval.abstract).last = (yyvsp[(1) - (2)].nested).comp;
else
yyval.abstract.comp = yyvsp[-1].nested.comp;
yyval.abstract.last = yyvsp[-1].nested.last;
(yyval.abstract).comp = (yyvsp[(1) - (2)].nested).comp;
(yyval.abstract).last = (yyvsp[(1) - (2)].nested).last;
}
break;
 
case 137:
 
/* Line 1455 of yacc.c */
#line 868 "cp-name-parser.y"
{ yyval.abstract.comp = yyvsp[0].abstract.comp; yyval.abstract.last = yyvsp[0].abstract.last; yyval.abstract.fn = yyvsp[0].abstract.fn; yyval.abstract.start = NULL; }
{ (yyval.abstract).comp = (yyvsp[(1) - (1)].abstract).comp; (yyval.abstract).last = (yyvsp[(1) - (1)].abstract).last; (yyval.abstract).fn = (yyvsp[(1) - (1)].abstract).fn; (yyval.abstract).start = NULL; }
break;
 
case 138:
 
/* Line 1455 of yacc.c */
#line 870 "cp-name-parser.y"
{ yyval.abstract.start = yyvsp[0].comp;
if (yyvsp[-3].abstract.fn.comp) { yyval.abstract.last = yyvsp[-3].abstract.fn.last; *yyvsp[-3].abstract.last = yyvsp[-3].abstract.fn.comp; }
if (yyvsp[-3].abstract.fold_flag)
{ (yyval.abstract).start = (yyvsp[(4) - (4)].comp);
if ((yyvsp[(1) - (4)].abstract).fn.comp) { (yyval.abstract).last = (yyvsp[(1) - (4)].abstract).fn.last; *(yyvsp[(1) - (4)].abstract).last = (yyvsp[(1) - (4)].abstract).fn.comp; }
if ((yyvsp[(1) - (4)].abstract).fold_flag)
{
*yyval.abstract.last = yyvsp[-2].nested.comp;
yyval.abstract.last = yyvsp[-2].nested.last;
*(yyval.abstract).last = (yyvsp[(2) - (4)].nested).comp;
(yyval.abstract).last = (yyvsp[(2) - (4)].nested).last;
}
else
yyval.abstract.fn = yyvsp[-2].nested;
(yyval.abstract).fn = (yyvsp[(2) - (4)].nested);
}
break;
 
case 139:
 
/* Line 1455 of yacc.c */
#line 881 "cp-name-parser.y"
{ yyval.abstract.fn = yyvsp[-1].nested;
yyval.abstract.start = yyvsp[0].comp;
yyval.abstract.comp = NULL; yyval.abstract.last = NULL;
{ (yyval.abstract).fn = (yyvsp[(1) - (2)].nested);
(yyval.abstract).start = (yyvsp[(2) - (2)].comp);
(yyval.abstract).comp = NULL; (yyval.abstract).last = NULL;
}
break;
 
case 141:
 
/* Line 1455 of yacc.c */
#line 889 "cp-name-parser.y"
{ yyval.comp = yyvsp[0].abstract.comp;
*yyvsp[0].abstract.last = yyvsp[-1].comp;
{ (yyval.comp) = (yyvsp[(2) - (2)].abstract).comp;
*(yyvsp[(2) - (2)].abstract).last = (yyvsp[(1) - (2)].comp);
}
break;
 
case 142:
 
/* Line 1455 of yacc.c */
#line 895 "cp-name-parser.y"
{ yyval.nested.comp = yyvsp[0].nested.comp;
yyval.nested.last = yyvsp[-1].nested.last;
*yyvsp[0].nested.last = yyvsp[-1].nested.comp; }
{ (yyval.nested).comp = (yyvsp[(2) - (2)].nested).comp;
(yyval.nested).last = (yyvsp[(1) - (2)].nested).last;
*(yyvsp[(2) - (2)].nested).last = (yyvsp[(1) - (2)].nested).comp; }
break;
 
case 144:
 
/* Line 1455 of yacc.c */
#line 903 "cp-name-parser.y"
{ yyval.nested = yyvsp[-1].nested; }
{ (yyval.nested) = (yyvsp[(2) - (3)].nested); }
break;
 
case 145:
 
/* Line 1455 of yacc.c */
#line 905 "cp-name-parser.y"
{ yyval.nested.comp = yyvsp[-1].nested.comp;
*yyvsp[-1].nested.last = yyvsp[0].nested.comp;
yyval.nested.last = yyvsp[0].nested.last;
{ (yyval.nested).comp = (yyvsp[(1) - (2)].nested).comp;
*(yyvsp[(1) - (2)].nested).last = (yyvsp[(2) - (2)].nested).comp;
(yyval.nested).last = (yyvsp[(2) - (2)].nested).last;
}
break;
 
case 146:
 
/* Line 1455 of yacc.c */
#line 910 "cp-name-parser.y"
{ yyval.nested.comp = yyvsp[-1].nested.comp;
*yyvsp[-1].nested.last = yyvsp[0].comp;
yyval.nested.last = &d_right (yyvsp[0].comp);
{ (yyval.nested).comp = (yyvsp[(1) - (2)].nested).comp;
*(yyvsp[(1) - (2)].nested).last = (yyvsp[(2) - (2)].comp);
(yyval.nested).last = &d_right ((yyvsp[(2) - (2)].comp));
}
break;
 
case 147:
 
/* Line 1455 of yacc.c */
#line 915 "cp-name-parser.y"
{ yyval.nested.comp = make_empty (DEMANGLE_COMPONENT_TYPED_NAME);
d_left (yyval.nested.comp) = yyvsp[0].comp;
yyval.nested.last = &d_right (yyval.nested.comp);
{ (yyval.nested).comp = make_empty (DEMANGLE_COMPONENT_TYPED_NAME);
d_left ((yyval.nested).comp) = (yyvsp[(1) - (1)].comp);
(yyval.nested).last = &d_right ((yyval.nested).comp);
}
break;
 
case 148:
 
/* Line 1455 of yacc.c */
#line 928 "cp-name-parser.y"
{ yyval.nested.comp = yyvsp[0].nested.comp;
yyval.nested.last = yyvsp[-1].nested.last;
*yyvsp[0].nested.last = yyvsp[-1].nested.comp; }
{ (yyval.nested).comp = (yyvsp[(2) - (2)].nested).comp;
(yyval.nested).last = (yyvsp[(1) - (2)].nested).last;
*(yyvsp[(2) - (2)].nested).last = (yyvsp[(1) - (2)].nested).comp; }
break;
 
case 149:
 
/* Line 1455 of yacc.c */
#line 932 "cp-name-parser.y"
{ yyval.nested.comp = make_empty (DEMANGLE_COMPONENT_TYPED_NAME);
d_left (yyval.nested.comp) = yyvsp[0].comp;
yyval.nested.last = &d_right (yyval.nested.comp);
{ (yyval.nested).comp = make_empty (DEMANGLE_COMPONENT_TYPED_NAME);
d_left ((yyval.nested).comp) = (yyvsp[(1) - (1)].comp);
(yyval.nested).last = &d_right ((yyval.nested).comp);
}
break;
 
case 151:
 
/* Line 1455 of yacc.c */
#line 945 "cp-name-parser.y"
{ yyval.nested.comp = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, yyvsp[-3].comp, yyvsp[-2].nested.comp);
yyval.nested.last = yyvsp[-2].nested.last;
yyval.nested.comp = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, yyval.nested.comp, yyvsp[0].comp);
{ (yyval.nested).comp = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, (yyvsp[(1) - (4)].comp), (yyvsp[(2) - (4)].nested).comp);
(yyval.nested).last = (yyvsp[(2) - (4)].nested).last;
(yyval.nested).comp = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, (yyval.nested).comp, (yyvsp[(4) - (4)].comp));
}
break;
 
case 152:
 
/* Line 1455 of yacc.c */
#line 950 "cp-name-parser.y"
{ yyval.nested.comp = yyvsp[-3].nested.comp;
*yyvsp[-3].nested.last = yyvsp[-2].nested.comp;
yyval.nested.last = yyvsp[-2].nested.last;
yyval.nested.comp = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, yyval.nested.comp, yyvsp[0].comp);
{ (yyval.nested).comp = (yyvsp[(1) - (4)].nested).comp;
*(yyvsp[(1) - (4)].nested).last = (yyvsp[(2) - (4)].nested).comp;
(yyval.nested).last = (yyvsp[(2) - (4)].nested).last;
(yyval.nested).comp = fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, (yyval.nested).comp, (yyvsp[(4) - (4)].comp));
}
break;
 
case 153:
 
/* Line 1455 of yacc.c */
#line 959 "cp-name-parser.y"
{ yyval.nested.comp = yyvsp[-1].nested.comp;
yyval.nested.last = yyvsp[-2].nested.last;
*yyvsp[-1].nested.last = yyvsp[-2].nested.comp; }
{ (yyval.nested).comp = (yyvsp[(3) - (4)].nested).comp;
(yyval.nested).last = (yyvsp[(2) - (4)].nested).last;
*(yyvsp[(3) - (4)].nested).last = (yyvsp[(2) - (4)].nested).comp; }
break;
 
case 154:
 
/* Line 1455 of yacc.c */
#line 963 "cp-name-parser.y"
{ yyval.nested.comp = yyvsp[-1].nested.comp;
*yyvsp[-1].nested.last = yyvsp[0].nested.comp;
yyval.nested.last = yyvsp[0].nested.last;
{ (yyval.nested).comp = (yyvsp[(1) - (2)].nested).comp;
*(yyvsp[(1) - (2)].nested).last = (yyvsp[(2) - (2)].nested).comp;
(yyval.nested).last = (yyvsp[(2) - (2)].nested).last;
}
break;
 
case 155:
 
/* Line 1455 of yacc.c */
#line 968 "cp-name-parser.y"
{ yyval.nested.comp = yyvsp[-1].nested.comp;
*yyvsp[-1].nested.last = yyvsp[0].comp;
yyval.nested.last = &d_right (yyvsp[0].comp);
{ (yyval.nested).comp = (yyvsp[(1) - (2)].nested).comp;
*(yyvsp[(1) - (2)].nested).last = (yyvsp[(2) - (2)].comp);
(yyval.nested).last = &d_right ((yyvsp[(2) - (2)].comp));
}
break;
 
case 156:
 
/* Line 1455 of yacc.c */
#line 973 "cp-name-parser.y"
{ yyval.nested.comp = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, yyvsp[-1].comp, yyvsp[0].nested.comp);
yyval.nested.last = yyvsp[0].nested.last;
{ (yyval.nested).comp = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, (yyvsp[(1) - (2)].comp), (yyvsp[(2) - (2)].nested).comp);
(yyval.nested).last = (yyvsp[(2) - (2)].nested).last;
}
break;
 
case 157:
 
/* Line 1455 of yacc.c */
#line 977 "cp-name-parser.y"
{ yyval.nested.comp = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, yyvsp[-1].comp, yyvsp[0].comp);
yyval.nested.last = &d_right (yyvsp[0].comp);
{ (yyval.nested).comp = fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, (yyvsp[(1) - (2)].comp), (yyvsp[(2) - (2)].comp));
(yyval.nested).last = &d_right ((yyvsp[(2) - (2)].comp));
}
break;
 
case 158:
 
/* Line 1455 of yacc.c */
#line 983 "cp-name-parser.y"
{ yyval.comp = yyvsp[-1].comp; }
{ (yyval.comp) = (yyvsp[(2) - (3)].comp); }
break;
 
case 160:
 
/* Line 1455 of yacc.c */
#line 992 "cp-name-parser.y"
{ yyval.comp = d_binary (">", yyvsp[-2].comp, yyvsp[0].comp); }
{ (yyval.comp) = d_binary (">", (yyvsp[(1) - (3)].comp), (yyvsp[(3) - (3)].comp)); }
break;
 
case 161:
 
/* Line 1455 of yacc.c */
#line 999 "cp-name-parser.y"
{ yyval.comp = fill_comp (DEMANGLE_COMPONENT_UNARY, make_operator ("&", 1), yyvsp[0].comp); }
{ (yyval.comp) = fill_comp (DEMANGLE_COMPONENT_UNARY, make_operator ("&", 1), (yyvsp[(2) - (2)].comp)); }
break;
 
case 162:
 
/* Line 1455 of yacc.c */
#line 1001 "cp-name-parser.y"
{ yyval.comp = fill_comp (DEMANGLE_COMPONENT_UNARY, make_operator ("&", 1), yyvsp[-1].comp); }
{ (yyval.comp) = fill_comp (DEMANGLE_COMPONENT_UNARY, make_operator ("&", 1), (yyvsp[(3) - (4)].comp)); }
break;
 
case 163:
 
/* Line 1455 of yacc.c */
#line 1006 "cp-name-parser.y"
{ yyval.comp = d_unary ("-", yyvsp[0].comp); }
{ (yyval.comp) = d_unary ("-", (yyvsp[(2) - (2)].comp)); }
break;
 
case 164:
 
/* Line 1455 of yacc.c */
#line 1010 "cp-name-parser.y"
{ yyval.comp = d_unary ("!", yyvsp[0].comp); }
{ (yyval.comp) = d_unary ("!", (yyvsp[(2) - (2)].comp)); }
break;
 
case 165:
 
/* Line 1455 of yacc.c */
#line 1014 "cp-name-parser.y"
{ yyval.comp = d_unary ("~", yyvsp[0].comp); }
{ (yyval.comp) = d_unary ("~", (yyvsp[(2) - (2)].comp)); }
break;
 
case 166:
 
/* Line 1455 of yacc.c */
#line 1021 "cp-name-parser.y"
{ if (yyvsp[0].comp->type == DEMANGLE_COMPONENT_LITERAL
|| yyvsp[0].comp->type == DEMANGLE_COMPONENT_LITERAL_NEG)
{ if ((yyvsp[(4) - (4)].comp)->type == DEMANGLE_COMPONENT_LITERAL
|| (yyvsp[(4) - (4)].comp)->type == DEMANGLE_COMPONENT_LITERAL_NEG)
{
yyval.comp = yyvsp[0].comp;
d_left (yyvsp[0].comp) = yyvsp[-2].comp;
(yyval.comp) = (yyvsp[(4) - (4)].comp);
d_left ((yyvsp[(4) - (4)].comp)) = (yyvsp[(2) - (4)].comp);
}
else
yyval.comp = fill_comp (DEMANGLE_COMPONENT_UNARY,
fill_comp (DEMANGLE_COMPONENT_CAST, yyvsp[-2].comp, NULL),
yyvsp[0].comp);
(yyval.comp) = fill_comp (DEMANGLE_COMPONENT_UNARY,
fill_comp (DEMANGLE_COMPONENT_CAST, (yyvsp[(2) - (4)].comp), NULL),
(yyvsp[(4) - (4)].comp));
}
break;
 
case 167:
 
/* Line 1455 of yacc.c */
#line 1037 "cp-name-parser.y"
{ yyval.comp = fill_comp (DEMANGLE_COMPONENT_UNARY,
fill_comp (DEMANGLE_COMPONENT_CAST, yyvsp[-4].comp, NULL),
yyvsp[-1].comp);
{ (yyval.comp) = fill_comp (DEMANGLE_COMPONENT_UNARY,
fill_comp (DEMANGLE_COMPONENT_CAST, (yyvsp[(3) - (7)].comp), NULL),
(yyvsp[(6) - (7)].comp));
}
break;
 
case 168:
 
/* Line 1455 of yacc.c */
#line 1044 "cp-name-parser.y"
{ yyval.comp = fill_comp (DEMANGLE_COMPONENT_UNARY,
fill_comp (DEMANGLE_COMPONENT_CAST, yyvsp[-4].comp, NULL),
yyvsp[-1].comp);
{ (yyval.comp) = fill_comp (DEMANGLE_COMPONENT_UNARY,
fill_comp (DEMANGLE_COMPONENT_CAST, (yyvsp[(3) - (7)].comp), NULL),
(yyvsp[(6) - (7)].comp));
}
break;
 
case 169:
 
/* Line 1455 of yacc.c */
#line 1051 "cp-name-parser.y"
{ yyval.comp = fill_comp (DEMANGLE_COMPONENT_UNARY,
fill_comp (DEMANGLE_COMPONENT_CAST, yyvsp[-4].comp, NULL),
yyvsp[-1].comp);
{ (yyval.comp) = fill_comp (DEMANGLE_COMPONENT_UNARY,
fill_comp (DEMANGLE_COMPONENT_CAST, (yyvsp[(3) - (7)].comp), NULL),
(yyvsp[(6) - (7)].comp));
}
break;
 
case 170:
 
/* Line 1455 of yacc.c */
#line 1070 "cp-name-parser.y"
{ yyval.comp = d_binary ("*", yyvsp[-2].comp, yyvsp[0].comp); }
{ (yyval.comp) = d_binary ("*", (yyvsp[(1) - (3)].comp), (yyvsp[(3) - (3)].comp)); }
break;
 
case 171:
 
/* Line 1455 of yacc.c */
#line 1074 "cp-name-parser.y"
{ yyval.comp = d_binary ("/", yyvsp[-2].comp, yyvsp[0].comp); }
{ (yyval.comp) = d_binary ("/", (yyvsp[(1) - (3)].comp), (yyvsp[(3) - (3)].comp)); }
break;
 
case 172:
 
/* Line 1455 of yacc.c */
#line 1078 "cp-name-parser.y"
{ yyval.comp = d_binary ("%", yyvsp[-2].comp, yyvsp[0].comp); }
{ (yyval.comp) = d_binary ("%", (yyvsp[(1) - (3)].comp), (yyvsp[(3) - (3)].comp)); }
break;
 
case 173:
 
/* Line 1455 of yacc.c */
#line 1082 "cp-name-parser.y"
{ yyval.comp = d_binary ("+", yyvsp[-2].comp, yyvsp[0].comp); }
{ (yyval.comp) = d_binary ("+", (yyvsp[(1) - (3)].comp), (yyvsp[(3) - (3)].comp)); }
break;
 
case 174:
 
/* Line 1455 of yacc.c */
#line 1086 "cp-name-parser.y"
{ yyval.comp = d_binary ("-", yyvsp[-2].comp, yyvsp[0].comp); }
{ (yyval.comp) = d_binary ("-", (yyvsp[(1) - (3)].comp), (yyvsp[(3) - (3)].comp)); }
break;
 
case 175:
 
/* Line 1455 of yacc.c */
#line 1090 "cp-name-parser.y"
{ yyval.comp = d_binary ("<<", yyvsp[-2].comp, yyvsp[0].comp); }
{ (yyval.comp) = d_binary ("<<", (yyvsp[(1) - (3)].comp), (yyvsp[(3) - (3)].comp)); }
break;
 
case 176:
 
/* Line 1455 of yacc.c */
#line 1094 "cp-name-parser.y"
{ yyval.comp = d_binary (">>", yyvsp[-2].comp, yyvsp[0].comp); }
{ (yyval.comp) = d_binary (">>", (yyvsp[(1) - (3)].comp), (yyvsp[(3) - (3)].comp)); }
break;
 
case 177:
 
/* Line 1455 of yacc.c */
#line 1098 "cp-name-parser.y"
{ yyval.comp = d_binary ("==", yyvsp[-2].comp, yyvsp[0].comp); }
{ (yyval.comp) = d_binary ("==", (yyvsp[(1) - (3)].comp), (yyvsp[(3) - (3)].comp)); }
break;
 
case 178:
 
/* Line 1455 of yacc.c */
#line 1102 "cp-name-parser.y"
{ yyval.comp = d_binary ("!=", yyvsp[-2].comp, yyvsp[0].comp); }
{ (yyval.comp) = d_binary ("!=", (yyvsp[(1) - (3)].comp), (yyvsp[(3) - (3)].comp)); }
break;
 
case 179:
 
/* Line 1455 of yacc.c */
#line 1106 "cp-name-parser.y"
{ yyval.comp = d_binary ("<=", yyvsp[-2].comp, yyvsp[0].comp); }
{ (yyval.comp) = d_binary ("<=", (yyvsp[(1) - (3)].comp), (yyvsp[(3) - (3)].comp)); }
break;
 
case 180:
 
/* Line 1455 of yacc.c */
#line 1110 "cp-name-parser.y"
{ yyval.comp = d_binary (">=", yyvsp[-2].comp, yyvsp[0].comp); }
{ (yyval.comp) = d_binary (">=", (yyvsp[(1) - (3)].comp), (yyvsp[(3) - (3)].comp)); }
break;
 
case 181:
 
/* Line 1455 of yacc.c */
#line 1114 "cp-name-parser.y"
{ yyval.comp = d_binary ("<", yyvsp[-2].comp, yyvsp[0].comp); }
{ (yyval.comp) = d_binary ("<", (yyvsp[(1) - (3)].comp), (yyvsp[(3) - (3)].comp)); }
break;
 
case 182:
 
/* Line 1455 of yacc.c */
#line 1118 "cp-name-parser.y"
{ yyval.comp = d_binary ("&", yyvsp[-2].comp, yyvsp[0].comp); }
{ (yyval.comp) = d_binary ("&", (yyvsp[(1) - (3)].comp), (yyvsp[(3) - (3)].comp)); }
break;
 
case 183:
 
/* Line 1455 of yacc.c */
#line 1122 "cp-name-parser.y"
{ yyval.comp = d_binary ("^", yyvsp[-2].comp, yyvsp[0].comp); }
{ (yyval.comp) = d_binary ("^", (yyvsp[(1) - (3)].comp), (yyvsp[(3) - (3)].comp)); }
break;
 
case 184:
 
/* Line 1455 of yacc.c */
#line 1126 "cp-name-parser.y"
{ yyval.comp = d_binary ("|", yyvsp[-2].comp, yyvsp[0].comp); }
{ (yyval.comp) = d_binary ("|", (yyvsp[(1) - (3)].comp), (yyvsp[(3) - (3)].comp)); }
break;
 
case 185:
 
/* Line 1455 of yacc.c */
#line 1130 "cp-name-parser.y"
{ yyval.comp = d_binary ("&&", yyvsp[-2].comp, yyvsp[0].comp); }
{ (yyval.comp) = d_binary ("&&", (yyvsp[(1) - (3)].comp), (yyvsp[(3) - (3)].comp)); }
break;
 
case 186:
 
/* Line 1455 of yacc.c */
#line 1134 "cp-name-parser.y"
{ yyval.comp = d_binary ("||", yyvsp[-2].comp, yyvsp[0].comp); }
{ (yyval.comp) = d_binary ("||", (yyvsp[(1) - (3)].comp), (yyvsp[(3) - (3)].comp)); }
break;
 
case 187:
 
/* Line 1455 of yacc.c */
#line 1139 "cp-name-parser.y"
{ yyval.comp = d_binary ("->", yyvsp[-2].comp, yyvsp[0].comp); }
{ (yyval.comp) = d_binary ("->", (yyvsp[(1) - (3)].comp), (yyvsp[(3) - (3)].comp)); }
break;
 
case 188:
 
/* Line 1455 of yacc.c */
#line 1143 "cp-name-parser.y"
{ yyval.comp = d_binary (".", yyvsp[-2].comp, yyvsp[0].comp); }
{ (yyval.comp) = d_binary (".", (yyvsp[(1) - (3)].comp), (yyvsp[(3) - (3)].comp)); }
break;
 
case 189:
 
/* Line 1455 of yacc.c */
#line 1147 "cp-name-parser.y"
{ yyval.comp = fill_comp (DEMANGLE_COMPONENT_TRINARY, make_operator ("?", 3),
fill_comp (DEMANGLE_COMPONENT_TRINARY_ARG1, yyvsp[-4].comp,
fill_comp (DEMANGLE_COMPONENT_TRINARY_ARG2, yyvsp[-2].comp, yyvsp[0].comp)));
{ (yyval.comp) = fill_comp (DEMANGLE_COMPONENT_TRINARY, make_operator ("?", 3),
fill_comp (DEMANGLE_COMPONENT_TRINARY_ARG1, (yyvsp[(1) - (5)].comp),
fill_comp (DEMANGLE_COMPONENT_TRINARY_ARG2, (yyvsp[(3) - (5)].comp), (yyvsp[(5) - (5)].comp))));
}
break;
 
case 192:
 
/* Line 1455 of yacc.c */
#line 1161 "cp-name-parser.y"
{ yyval.comp = d_unary ("sizeof", yyvsp[-1].comp); }
{ (yyval.comp) = d_unary ("sizeof", (yyvsp[(3) - (4)].comp)); }
break;
 
case 193:
 
/* Line 1455 of yacc.c */
#line 1166 "cp-name-parser.y"
{ struct demangle_component *i;
i = make_name ("1", 1);
yyval.comp = fill_comp (DEMANGLE_COMPONENT_LITERAL,
(yyval.comp) = fill_comp (DEMANGLE_COMPONENT_LITERAL,
make_builtin_type ("bool"),
i);
}
2817,10 → 3498,12
break;
 
case 194:
 
/* Line 1455 of yacc.c */
#line 1175 "cp-name-parser.y"
{ struct demangle_component *i;
i = make_name ("0", 1);
yyval.comp = fill_comp (DEMANGLE_COMPONENT_LITERAL,
(yyval.comp) = fill_comp (DEMANGLE_COMPONENT_LITERAL,
make_builtin_type ("bool"),
i);
}
2827,20 → 3510,19
break;
 
 
 
/* Line 1455 of yacc.c */
#line 3517 "cp-name-parser.c.tmp"
default: break;
}
YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
 
/* Line 1000 of yacc.c. */
#line 2834 "cp-name-parser.c.tmp"
yyvsp -= yylen;
yyssp -= yylen;
 
 
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. */
2864,66 → 3546,41
if (!yyerrstatus)
{
++yynerrs;
#if YYERROR_VERBOSE
yyn = yypact[yystate];
 
if (YYPACT_NINF < yyn && yyn < YYLAST)
{
YYSIZE_T yysize = 0;
int yytype = YYTRANSLATE (yychar);
const char* yyprefix;
char *yymsg;
int yyx;
 
/* 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;
int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
int yycount = 0;
 
yyprefix = ", expecting ";
for (yyx = yyxbegin; yyx < yyxend; ++yyx)
if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
#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
{
yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]);
yycount += 1;
if (yycount == 5)
{
yysize = 0;
break;
}
yymsg = yymsgbuf;
yymsg_alloc = sizeof yymsgbuf;
}
yysize += (sizeof ("syntax error, unexpected ")
+ yystrlen (yytname[yytype]));
yymsg = (char *) YYSTACK_ALLOC (yysize);
if (yymsg != 0)
{
char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
yyp = yystpcpy (yyp, yytname[yytype]);
}
 
if (yycount < 5)
{
yyprefix = ", expecting ";
for (yyx = yyxbegin; yyx < yyxend; ++yyx)
if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
{
yyp = yystpcpy (yyp, yyprefix);
yyp = yystpcpy (yyp, yytname[yyx]);
yyprefix = " or ";
}
}
yyerror (yymsg);
YYSTACK_FREE (yymsg);
}
else
yyerror ("syntax error; also virtual memory exhausted");
}
else
#endif /* YYERROR_VERBOSE */
yyerror ("syntax error");
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
}
 
 
2934,25 → 3591,16
error, discard it. */
 
if (yychar <= YYEOF)
{
/* If at end of input, pop the error token,
then the rest of the stack, then return failure. */
{
/* Return failure if at end of input. */
if (yychar == YYEOF)
for (;;)
{
YYPOPSTACK;
if (yyssp == yyss)
YYABORT;
YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
yydestruct (yystos[*yyssp], yyvsp);
}
}
YYABORT;
}
else
{
YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);
yydestruct (yytoken, &yylval);
yydestruct ("Error: discarding",
yytoken, &yylval);
yychar = YYEMPTY;
 
}
}
 
2966,15 → 3614,17
`---------------------------------------------------*/
yyerrorlab:
 
#ifdef __GNUC__
/* Pacify GCC when the user code never invokes YYERROR and the label
yyerrorlab therefore never appears in user code. */
if (0)
/* 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;
#endif
 
yyvsp -= yylen;
yyssp -= yylen;
/* 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;
 
3003,21 → 3653,20
if (yyssp == yyss)
YYABORT;
 
YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
yydestruct (yystos[yystate], yyvsp);
YYPOPSTACK;
 
yydestruct ("Error: popping",
yystos[yystate], yyvsp);
YYPOPSTACK (1);
yystate = *yyssp;
YY_STACK_PRINT (yyss, yyssp);
}
 
if (yyn == YYFINAL)
YYACCEPT;
*++yyvsp = yylval;
 
YYDPRINTF ((stderr, "Shifting error token, "));
 
*++yyvsp = yylval;
/* Shift the error token. */
YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
 
 
yystate = yyn;
goto yynewstate;
 
3036,25 → 3685,45
yyresult = 1;
goto yyreturn;
 
#ifndef yyoverflow
/*----------------------------------------------.
| yyoverflowlab -- parser overflow comes here. |
`----------------------------------------------*/
yyoverflowlab:
yyerror ("parser stack overflow");
#if !defined(yyoverflow) || YYERROR_VERBOSE
/*-------------------------------------------------.
| yyexhaustedlab -- memory exhaustion comes here. |
`-------------------------------------------------*/
yyexhaustedlab:
yyerror (YY_("memory exhausted"));
yyresult = 2;
/* Fall through. */
#endif
 
yyreturn:
if (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
return yyresult;
#if YYERROR_VERBOSE
if (yymsg != yymsgbuf)
YYSTACK_FREE (yymsg);
#endif
/* Make sure YYID is used. */
return YYID (yyresult);
}
 
 
 
/* Line 1675 of yacc.c */
#line 1185 "cp-name-parser.y"
 
 
3987,4 → 4656,3
 
#endif
 
 
/gnu-src/gdb-7.2/gdb/po/gdb.pot
8,10 → 8,11
msgstr ""
"Project-Id-Version: PACKAGE VERSION\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2010-09-02 23:45+0000\n"
"POT-Creation-Date: 2010-09-06 11:53+0100\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
"Language: \n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=CHARSET\n"
"Content-Transfer-Encoding: 8bit\n"
519,8 → 520,8
#: ada-lang.c:9702
#, possible-c-format
msgid ""
"Undefined name, ambiguous name, or renaming used in component association: %"
"s."
"Undefined name, ambiguous name, or renaming used in component association: "
"%s."
msgstr ""
 
#: ada-lang.c:9705
689,39 → 690,39
"this option to \"off\" unless necessary."
msgstr ""
 
#: ada-lex.l:129 ada-lex.l:133
#: ../../gdb-7.2/gdb/ada-lex.l:129 ../../gdb-7.2/gdb/ada-lex.l:133
msgid "Based real literals not implemented yet."
msgstr ""
 
#: ada-lex.l:156
#: ../../gdb-7.2/gdb/ada-lex.l:156
msgid "ill-formed or non-terminated string literal"
msgstr ""
 
#: ada-lex.l:288
#: ../../gdb-7.2/gdb/ada-lex.l:288
#, possible-c-format
msgid "Invalid character '%s' in expression."
msgstr ""
 
#: ada-lex.l:342
#: ../../gdb-7.2/gdb/ada-lex.l:343
#, possible-c-format
msgid "Invalid base: %d."
msgstr ""
 
#: ada-lex.l:353 ada-lex.l:360
#: ../../gdb-7.2/gdb/ada-lex.l:354 ../../gdb-7.2/gdb/ada-lex.l:361
msgid "Integer literal out of range"
msgstr ""
 
#: ada-lex.l:355
#: ../../gdb-7.2/gdb/ada-lex.l:356
#, possible-c-format
msgid "Invalid digit `%c' in based literal"
msgstr ""
 
#: ada-lex.l:601
#: ../../gdb-7.2/gdb/ada-lex.l:602
#, possible-c-format
msgid "ambiguous attribute name: `%s'"
msgstr ""
 
#: ada-lex.l:604
#: ../../gdb-7.2/gdb/ada-lex.l:605
#, possible-c-format
msgid "unrecognized attribute: `%s'"
msgstr ""
3393,12 → 3394,6
"\n"
msgstr ""
 
#: breakpoint.c:11868 breakpoint.c:11880
msgid ""
"\n"
"Do \"help tracepoints\" for info on other tracepoint commands."
msgstr ""
 
#: breakpoint.c:11877
msgid ""
"Set a fast tracepoint at specified line or function.\n"
3790,6 → 3785,187
msgid "Could not convert character constant to target character set"
msgstr ""
 
#: cli/cli-decode.c:1291
#, possible-c-format
msgid "Undefined %scommand: \"%s\". Try \"help%s%.*s\"."
msgstr ""
 
#: cli/cli-decode.c:1324
#, possible-c-format
msgid "Lack of needed %scommand"
msgstr ""
 
#: cli/cli-decode.c:1388
#, possible-c-format
msgid "Ambiguous %scommand \"%s\": %s."
msgstr ""
 
#: cli/cli-decode.c:1773
msgid "Invalid command"
msgstr ""
 
#: cli/cli-setshow.c:60
msgid "\"on\", \"off\" or \"auto\" expected."
msgstr ""
 
#: cli/cli-setshow.c:89
msgid "\"on\" or \"off\" expected."
msgstr ""
 
#: cli/cli-setshow.c:193
msgid "filename to set it to."
msgstr ""
 
#: cli/cli-setshow.c:214 cli/cli-setshow.c:224 cli/cli-setshow.c:236
#: cli/cli-setshow.c:241
msgid "integer to set it to."
msgstr ""
 
#: cli/cli-setshow.c:229
#, possible-c-format
msgid "integer %u out of range"
msgstr ""
 
#: cli/cli-setshow.c:271
#, possible-c-format
msgid "Requires an argument. Valid arguments are %s."
msgstr ""
 
#: cli/cli-setshow.c:299
#, possible-c-format
msgid "Undefined item: \"%s\"."
msgstr ""
 
#: cli/cli-setshow.c:302
#, possible-c-format
msgid "Ambiguous item \"%s\"."
msgstr ""
 
#: cli/cli-setshow.c:308 cli/cli-setshow.c:378
msgid "gdb internal error: bad var_type in do_setshow_command"
msgstr ""
 
#: cli/cli-setshow.c:353
msgid "do_setshow_command: invalid var_auto_boolean"
msgstr ""
 
#: cli/cli-setshow.c:402
msgid "gdb internal error: bad cmd_type in do_setshow_command"
msgstr ""
 
#: cli/cli-logging.c:44
#, possible-c-format
msgid "The current logfile is \"%s\".\n"
msgstr ""
 
#: cli/cli-logging.c:53
#, possible-c-format
msgid "Whether logging overwrites or appends to the log file is %s.\n"
msgstr ""
 
#: cli/cli-logging.c:63
#, possible-c-format
msgid "The logging output mode is %s.\n"
msgstr ""
 
#: cli/cli-logging.c:101 cli/cli-logging.c:109
msgid "set logging"
msgstr ""
 
#: cli/cli-logging.c:134
msgid "Current output protocol does not support redirection"
msgstr ""
 
#: cli/cli-logging.c:166
msgid ""
"\"set logging\" lets you log output to a file.\n"
"Usage: set logging on [FILENAME]\n"
" set logging off\n"
" set logging file FILENAME\n"
" set logging overwrite [on|off]\n"
" set logging redirect [on|off]\n"
msgstr ""
 
#: cli/cli-logging.c:179
#, possible-c-format
msgid "Currently logging to \"%s\".\n"
msgstr ""
 
#: cli/cli-logging.c:182
#, possible-c-format
msgid "Future logs will be written to %s.\n"
msgstr ""
 
#: cli/cli-logging.c:186
msgid "Logs will overwrite the log file.\n"
msgstr ""
 
#: cli/cli-logging.c:188
msgid "Logs will be appended to the log file.\n"
msgstr ""
 
#: cli/cli-logging.c:191
msgid "Output will be sent only to the log file.\n"
msgstr ""
 
#: cli/cli-logging.c:193
msgid "Output will be logged and displayed.\n"
msgstr ""
 
#: cli/cli-logging.c:205
msgid "Set logging options"
msgstr ""
 
#: cli/cli-logging.c:208
msgid "Show logging options"
msgstr ""
 
#: cli/cli-logging.c:210
msgid "Set whether logging overwrites or appends to the log file."
msgstr ""
 
#: cli/cli-logging.c:211
msgid "Show whether logging overwrites or appends to the log file."
msgstr ""
 
#: cli/cli-logging.c:212
msgid "If set, logging overrides the log file."
msgstr ""
 
#: cli/cli-logging.c:217
msgid "Set the logging output mode."
msgstr ""
 
#: cli/cli-logging.c:218
msgid "Show the logging output mode."
msgstr ""
 
#: cli/cli-logging.c:219
msgid ""
"If redirect is off, output will go to both the screen and the log file.\n"
"If redirect is on, output will go only to the log file."
msgstr ""
 
#: cli/cli-logging.c:225
msgid "Set the current logfile."
msgstr ""
 
#: cli/cli-logging.c:226
msgid "Show the current logfile."
msgstr ""
 
#: cli/cli-logging.c:227
msgid "The logfile is used when directing GDB's output."
msgstr ""
 
#: cli/cli-logging.c:233
msgid "Enable logging."
msgstr ""
 
#: cli/cli-logging.c:235
msgid "Disable logging."
msgstr ""
 
#: cli/cli-cmds.c:214
#, possible-c-format
msgid "Argument required (%s)."
4301,25 → 4477,6
msgid "When 'on', each command is displayed as it is executed."
msgstr ""
 
#: cli/cli-decode.c:1291
#, possible-c-format
msgid "Undefined %scommand: \"%s\". Try \"help%s%.*s\"."
msgstr ""
 
#: cli/cli-decode.c:1324
#, possible-c-format
msgid "Lack of needed %scommand"
msgstr ""
 
#: cli/cli-decode.c:1388
#, possible-c-format
msgid "Ambiguous %scommand \"%s\": %s."
msgstr ""
 
#: cli/cli-decode.c:1773
msgid "Invalid command"
msgstr ""
 
#: cli/cli-dump.c:85
msgid "Missing filename."
msgstr ""
4519,119 → 4676,6
"(file relative) will be restored to target memory."
msgstr ""
 
#: cli/cli-logging.c:44
#, possible-c-format
msgid "The current logfile is \"%s\".\n"
msgstr ""
 
#: cli/cli-logging.c:53
#, possible-c-format
msgid "Whether logging overwrites or appends to the log file is %s.\n"
msgstr ""
 
#: cli/cli-logging.c:63
#, possible-c-format
msgid "The logging output mode is %s.\n"
msgstr ""
 
#: cli/cli-logging.c:101 cli/cli-logging.c:109
msgid "set logging"
msgstr ""
 
#: cli/cli-logging.c:134
msgid "Current output protocol does not support redirection"
msgstr ""
 
#: cli/cli-logging.c:166
msgid ""
"\"set logging\" lets you log output to a file.\n"
"Usage: set logging on [FILENAME]\n"
" set logging off\n"
" set logging file FILENAME\n"
" set logging overwrite [on|off]\n"
" set logging redirect [on|off]\n"
msgstr ""
 
#: cli/cli-logging.c:179
#, possible-c-format
msgid "Currently logging to \"%s\".\n"
msgstr ""
 
#: cli/cli-logging.c:182
#, possible-c-format
msgid "Future logs will be written to %s.\n"
msgstr ""
 
#: cli/cli-logging.c:186
msgid "Logs will overwrite the log file.\n"
msgstr ""
 
#: cli/cli-logging.c:188
msgid "Logs will be appended to the log file.\n"
msgstr ""
 
#: cli/cli-logging.c:191
msgid "Output will be sent only to the log file.\n"
msgstr ""
 
#: cli/cli-logging.c:193
msgid "Output will be logged and displayed.\n"
msgstr ""
 
#: cli/cli-logging.c:205
msgid "Set logging options"
msgstr ""
 
#: cli/cli-logging.c:208
msgid "Show logging options"
msgstr ""
 
#: cli/cli-logging.c:210
msgid "Set whether logging overwrites or appends to the log file."
msgstr ""
 
#: cli/cli-logging.c:211
msgid "Show whether logging overwrites or appends to the log file."
msgstr ""
 
#: cli/cli-logging.c:212
msgid "If set, logging overrides the log file."
msgstr ""
 
#: cli/cli-logging.c:217
msgid "Set the logging output mode."
msgstr ""
 
#: cli/cli-logging.c:218
msgid "Show the logging output mode."
msgstr ""
 
#: cli/cli-logging.c:219
msgid ""
"If redirect is off, output will go to both the screen and the log file.\n"
"If redirect is on, output will go only to the log file."
msgstr ""
 
#: cli/cli-logging.c:225
msgid "Set the current logfile."
msgstr ""
 
#: cli/cli-logging.c:226
msgid "Show the current logfile."
msgstr ""
 
#: cli/cli-logging.c:227
msgid "The logfile is used when directing GDB's output."
msgstr ""
 
#: cli/cli-logging.c:233
msgid "Enable logging."
msgstr ""
 
#: cli/cli-logging.c:235
msgid "Disable logging."
msgstr ""
 
#: cli/cli-script.c:90
msgid "if/while commands require arguments."
msgstr ""
4746,55 → 4790,6
msgid "bad reason"
msgstr ""
 
#: cli/cli-setshow.c:60
msgid "\"on\", \"off\" or \"auto\" expected."
msgstr ""
 
#: cli/cli-setshow.c:89
msgid "\"on\" or \"off\" expected."
msgstr ""
 
#: cli/cli-setshow.c:193
msgid "filename to set it to."
msgstr ""
 
#: cli/cli-setshow.c:214 cli/cli-setshow.c:224 cli/cli-setshow.c:236
#: cli/cli-setshow.c:241
msgid "integer to set it to."
msgstr ""
 
#: cli/cli-setshow.c:229
#, possible-c-format
msgid "integer %u out of range"
msgstr ""
 
#: cli/cli-setshow.c:271
#, possible-c-format
msgid "Requires an argument. Valid arguments are %s."
msgstr ""
 
#: cli/cli-setshow.c:299
#, possible-c-format
msgid "Undefined item: \"%s\"."
msgstr ""
 
#: cli/cli-setshow.c:302
#, possible-c-format
msgid "Ambiguous item \"%s\"."
msgstr ""
 
#: cli/cli-setshow.c:308 cli/cli-setshow.c:378
msgid "gdb internal error: bad var_type in do_setshow_command"
msgstr ""
 
#: cli/cli-setshow.c:353
msgid "do_setshow_command: invalid var_auto_boolean"
msgstr ""
 
#: cli/cli-setshow.c:402
msgid "gdb internal error: bad cmd_type in do_setshow_command"
msgstr ""
 
#: coffread.c:584
#, possible-c-format
msgid "\"%s\": error reading line numbers."
5585,8 → 5580,8
#: darwin-nat.c:1704
#, possible-c-format
msgid ""
"darwin_read_write_inferior: mach_vm_region_recurse addr=%s, start=%s, len=%"
"s\n"
"darwin_read_write_inferior: mach_vm_region_recurse addr=%s, start=%s, len="
"%s\n"
msgstr ""
 
#: darwin-nat.c:1713
7117,8 → 7112,8
#: dwarf2read.c:10940
#, possible-c-format
msgid ""
"Dwarf Error: Cannot find DIE at 0x%x referenced from DIE at 0x%x [in module %"
"s]"
"Dwarf Error: Cannot find DIE at 0x%x referenced from DIE at 0x%x [in module "
"%s]"
msgstr ""
 
#: dwarf2read.c:10961
7230,8 → 7225,8
#: dwarf2read.c:12145
#, possible-c-format
msgid ""
"Dwarf Error: could not find partial DIE containing offset 0x%lx [in module %"
"s]"
"Dwarf Error: could not find partial DIE containing offset 0x%lx [in module "
"%s]"
msgstr ""
 
#: dwarf2read.c:12157
13275,90 → 13270,11
msgid "mi_cmd_disassemble: No function contains specified address"
msgstr ""
 
#: mi/mi-cmd-env.c:73
msgid "mi_cmd_env_pwd: No arguments required"
msgstr ""
 
#: mi/mi-cmd-env.c:84
#: mi/mi-cmds.c:210
#, possible-c-format
msgid "mi_cmd_env_pwd: error finding name of working directory: %s"
msgid "command `%s' appears to be duplicated"
msgstr ""
 
#: mi/mi-cmd-env.c:95
msgid "mi_cmd_env_cd: Usage DIRECTORY"
msgstr ""
 
#: mi/mi-cmd-env.c:257
msgid "mi_cmd_inferior_tty_show: Usage: No args"
msgstr ""
 
#: mi/mi-cmd-file.c:39
msgid "mi_cmd_file_list_exec_source_file: Usage: No args"
msgstr ""
 
#: mi/mi-cmd-file.c:49
msgid "mi_cmd_file_list_exec_source_file: No symtab"
msgstr ""
 
#: mi/mi-cmd-file.c:87
msgid "mi_cmd_file_list_exec_source_files: Usage: No args"
msgstr ""
 
#: mi/mi-cmd-stack.c:56
msgid "mi_cmd_stack_list_frames: Usage: [FRAME_LOW FRAME_HIGH]"
msgstr ""
 
#: mi/mi-cmd-stack.c:79
msgid "mi_cmd_stack_list_frames: Not enough frames in stack."
msgstr ""
 
#: mi/mi-cmd-stack.c:106
msgid "mi_cmd_stack_info_depth: Usage: [MAX_DEPTH]"
msgstr ""
 
#: mi/mi-cmd-stack.c:136
#, possible-c-format
msgid ""
"Unknown value for PRINT_VALUES: must be: 0 or \"%s\", 1 or \"%s\", 2 or \"%s"
"\""
msgstr ""
 
#: mi/mi-cmd-stack.c:150
msgid "mi_cmd_stack_list_locals: Usage: PRINT_VALUES"
msgstr ""
 
#: mi/mi-cmd-stack.c:171
msgid "mi_cmd_stack_list_args: Usage: PRINT_VALUES [FRAME_LOW FRAME_HIGH]"
msgstr ""
 
#: mi/mi-cmd-stack.c:196
msgid "mi_cmd_stack_list_args: Not enough frames in stack."
msgstr ""
 
#: mi/mi-cmd-stack.c:228
msgid "Usage: PRINT_VALUES"
msgstr ""
 
#: mi/mi-cmd-stack.c:380
msgid "mi_cmd_stack_select_frame: Usage: FRAME_SPEC"
msgstr ""
 
#: mi/mi-cmd-stack.c:389
msgid "mi_cmd_stack_info_frame: No arguments required"
msgstr ""
 
#: mi/mi-cmd-target.c:40
msgid "mi_cmd_target_file_get: Usage: REMOTE_FILE LOCAL_FILE"
msgstr ""
 
#: mi/mi-cmd-target.c:64
msgid "mi_cmd_target_file_put: Usage: LOCAL_FILE REMOTE_FILE"
msgstr ""
 
#: mi/mi-cmd-target.c:88
msgid "mi_cmd_target_file_delete: Usage: REMOTE_FILE"
msgstr ""
 
#. mi_error_message = xstrprintf ("mi_cmd_var_create: Usage:
#. ...."); return MI_CMD_ERROR;
#: mi/mi-cmd-var.c:112
13479,15 → 13395,23
msgid "mi_cmd_var_set_update_range: Usage: VAROBJ FROM TO"
msgstr ""
 
#: mi/mi-cmds.c:210
#: mi/mi-cmd-env.c:73
msgid "mi_cmd_env_pwd: No arguments required"
msgstr ""
 
#: mi/mi-cmd-env.c:84
#, possible-c-format
msgid "command `%s' appears to be duplicated"
msgid "mi_cmd_env_pwd: error finding name of working directory: %s"
msgstr ""
 
#: mi/mi-common.c:53
msgid "async_reason_string_lookup is inconsistent"
#: mi/mi-cmd-env.c:95
msgid "mi_cmd_env_cd: Usage DIRECTORY"
msgstr ""
 
#: mi/mi-cmd-env.c:257
msgid "mi_cmd_inferior_tty_show: Usage: No args"
msgstr ""
 
#: mi/mi-console.c:69
msgid "mi_console_file_delete: bad magic number"
msgstr ""
13500,6 → 13424,63
msgid "mi_console_file_flush: bad magic number"
msgstr ""
 
#: mi/mi-common.c:53
msgid "async_reason_string_lookup is inconsistent"
msgstr ""
 
#: mi/mi-parse.c:315
msgid "Duplicate '--thread-group' option"
msgstr ""
 
#: mi/mi-parse.c:318
msgid "Invalid thread group id"
msgstr ""
 
#: mi/mi-parse.c:325
msgid "Duplicate '--thread' option"
msgstr ""
 
#: mi/mi-parse.c:332
msgid "Duplicate '--frame' option"
msgstr ""
 
#: mi/mi-parse.c:340
#, possible-c-format
msgid "Invalid value for the '%s' option"
msgstr ""
 
#: mi/mi-cmd-file.c:39
msgid "mi_cmd_file_list_exec_source_file: Usage: No args"
msgstr ""
 
#: mi/mi-cmd-file.c:49
msgid "mi_cmd_file_list_exec_source_file: No symtab"
msgstr ""
 
#: mi/mi-cmd-file.c:87
msgid "mi_cmd_file_list_exec_source_files: Usage: No args"
msgstr ""
 
#: mi/mi-symbol-cmds.c:41
msgid "mi_cmd_symbol_list_lines: Usage: SOURCE_FILENAME"
msgstr ""
 
#: mi/mi-symbol-cmds.c:47
msgid "mi_cmd_symbol_list_lines: Unknown source file name."
msgstr ""
 
#: mi/mi-cmd-target.c:40
msgid "mi_cmd_target_file_get: Usage: REMOTE_FILE LOCAL_FILE"
msgstr ""
 
#: mi/mi-cmd-target.c:64
msgid "mi_cmd_target_file_put: Usage: LOCAL_FILE REMOTE_FILE"
msgstr ""
 
#: mi/mi-cmd-target.c:88
msgid "mi_cmd_target_file_delete: Usage: REMOTE_FILE"
msgstr ""
 
#: mi/mi-getopt.c:37
msgid "mi_getopt_long: optind out of bounds"
msgstr ""
13629,35 → 13610,49
msgid "Invalid option: %s"
msgstr ""
 
#: mi/mi-parse.c:315
msgid "Duplicate '--thread-group' option"
#: mi/mi-cmd-stack.c:56
msgid "mi_cmd_stack_list_frames: Usage: [FRAME_LOW FRAME_HIGH]"
msgstr ""
 
#: mi/mi-parse.c:318
msgid "Invalid thread group id"
#: mi/mi-cmd-stack.c:79
msgid "mi_cmd_stack_list_frames: Not enough frames in stack."
msgstr ""
 
#: mi/mi-parse.c:325
msgid "Duplicate '--thread' option"
#: mi/mi-cmd-stack.c:106
msgid "mi_cmd_stack_info_depth: Usage: [MAX_DEPTH]"
msgstr ""
 
#: mi/mi-parse.c:332
msgid "Duplicate '--frame' option"
#: mi/mi-cmd-stack.c:136
#, possible-c-format
msgid ""
"Unknown value for PRINT_VALUES: must be: 0 or \"%s\", 1 or \"%s\", 2 or \"%s"
"\""
msgstr ""
 
#: mi/mi-parse.c:340
#, possible-c-format
msgid "Invalid value for the '%s' option"
#: mi/mi-cmd-stack.c:150
msgid "mi_cmd_stack_list_locals: Usage: PRINT_VALUES"
msgstr ""
 
#: mi/mi-symbol-cmds.c:41
msgid "mi_cmd_symbol_list_lines: Usage: SOURCE_FILENAME"
#: mi/mi-cmd-stack.c:171
msgid "mi_cmd_stack_list_args: Usage: PRINT_VALUES [FRAME_LOW FRAME_HIGH]"
msgstr ""
 
#: mi/mi-symbol-cmds.c:47
msgid "mi_cmd_symbol_list_lines: Unknown source file name."
#: mi/mi-cmd-stack.c:196
msgid "mi_cmd_stack_list_args: Not enough frames in stack."
msgstr ""
 
#: mi/mi-cmd-stack.c:228
msgid "Usage: PRINT_VALUES"
msgstr ""
 
#: mi/mi-cmd-stack.c:380
msgid "mi_cmd_stack_select_frame: Usage: FRAME_SPEC"
msgstr ""
 
#: mi/mi-cmd-stack.c:389
msgid "mi_cmd_stack_info_frame: No arguments required"
msgstr ""
 
#: microblaze-tdep.c:145
msgid "push_dummy_code not implemented"
msgstr ""
14256,6 → 14251,11
msgid "When non-zero, observer debugging is enabled."
msgstr ""
 
#: or32-tdep.c:644
#, possible-c-format
msgid "or32_register_type: illegal register number %d"
msgstr ""
 
#: osabi.c:140
#, possible-c-format
msgid ""
15210,340 → 15210,317
msgid "Show printing of pascal static members."
msgstr ""
 
#: python/py-auto-load.c:195
#, possible-c-format
msgid "Invalid entry in %s section"
#. Require a valid frame. This must be called inside a TRY_CATCH, or
#. another context in which a gdb exception is allowed.
#: python/py-frame.c:54
msgid "Frame is invalid."
msgstr ""
 
#: python/py-auto-load.c:210
#, possible-c-format
msgid "Non-null-terminated path in %s: %s"
#: python/py-frame.c:230 python/py-block.c:284
msgid "Cannot locate object file for block."
msgstr ""
 
#: python/py-auto-load.c:217
#, possible-c-format
msgid "Empty path in %s"
#: python/py-frame.c:277
msgid "Could not allocate frame object."
msgstr ""
 
#: python/py-auto-load.c:267
#, possible-c-format
msgid "%s (referenced in %s): %s"
#: python/py-frame.c:421 python/py-type.c:532
msgid "Second argument must be block."
msgstr ""
 
#: python/py-auto-load.c:301
#: python/py-frame.c:439
#, possible-c-format
msgid "Couldn't read %s section of %s"
msgid "Variable '%s' not found."
msgstr ""
 
#: python/py-auto-load.c:426
#, possible-c-format
msgid "Script name: %s\n"
#: python/py-frame.c:450
msgid "Argument must be a symbol or string."
msgstr ""
 
#: python/py-auto-load.c:427
#: python/py-frame.c:465
#, possible-c-format
msgid " Full name: %s\n"
msgid "Variable cannot be found for symbol '%s'."
msgstr ""
 
#: python/py-auto-load.c:448 solib.c:919 solib.c:1013 xcoffsolib.c:113
#, possible-c-format
msgid "Invalid regexp: %s"
#: python/py-frame.c:528
msgid "Invalid frame stop reason."
msgstr ""
 
#: python/py-auto-load.c:450
#, possible-c-format
msgid "Objfile scripts matching %s:\n"
#. Require that INFERIOR be a valid inferior ID.
#: python/py-infthread.c:34
msgid "Thread no longer exists."
msgstr ""
 
#: python/py-auto-load.c:455
msgid "Objfile scripts:\n"
#: python/py-lazy-string.c:103
msgid "Cannot create a value from NULL."
msgstr ""
 
#: python/py-auto-load.c:477
msgid "Enable or disable auto-loading of Python code when an object is opened."
#: python/py-lazy-string.c:128
msgid "Cannot create a lazy string with address 0x0, and a non-zero length."
msgstr ""
 
#: python/py-auto-load.c:478
msgid "Show whether Python code will be auto-loaded when an object is opened."
#: python/py-lazy-string.c:136
msgid "A lazy string's type cannot be NULL."
msgstr ""
 
#: python/py-auto-load.c:479
msgid ""
"Enables or disables auto-loading of Python code when an object is opened."
#: python/py-prettyprint.c:569 python/py-function.c:83 python/py-function.c:91
#: python/python.c:161 python/python.c:182
msgid "Error while executing Python code."
msgstr ""
 
#: python/py-auto-load.c:486
msgid "Print dump of auto-loaded section scripts matching REGEXP."
#: python/py-prettyprint.c:737
msgid "Argument must be a gdb.Value."
msgstr ""
 
#. Require a valid block. All access to block_object->block should be
#. gated by this call.
#: python/py-block.c:64
msgid "Block is invalid."
#: python/py-objfile.c:101
msgid "Cannot delete the pretty_printers attribute."
msgstr ""
 
#. Require a valid block. This macro is called during block iterator
#. creation, and at each next call.
#: python/py-block.c:76
msgid "Source block for iterator is invalid."
#: python/py-objfile.c:108
msgid "The pretty_printers attribute must be a list."
msgstr ""
 
#: python/py-block.c:251
msgid "Symbol is null."
#: python/py-function.c:48
msgid "Could not convert value to Python object."
msgstr ""
 
#: python/py-block.c:284 python/py-frame.c:230
msgid "Cannot locate object file for block."
#: python/py-function.c:73
msgid "No method named 'invoke' in object."
msgstr ""
 
#. Require that BREAKPOINT be a valid breakpoint ID; throw a Python
#. exception if it is invalid.
#. Require that BREAKPOINT be a valid breakpoint ID; throw a Python
#. exception if it is invalid. This macro is for use in setter functions.
#: python/py-breakpoint.c:72 python/py-breakpoint.c:82
#, possible-c-format
msgid "Breakpoint %d is invalid."
#: python/py-function.c:119
msgid "This function is not documented."
msgstr ""
 
#: python/py-breakpoint.c:179
msgid "Cannot delete `enabled' attribute."
#: python/py-type.c:298
msgid "This type does not have a range."
msgstr ""
 
#: python/py-breakpoint.c:186
msgid "The value of `enabled' must be a boolean."
#: python/py-type.c:371
msgid "Type does not have a target."
msgstr ""
 
#: python/py-breakpoint.c:212
msgid "Cannot delete `silent' attribute."
#: python/py-type.c:543
msgid "Null type name."
msgstr ""
 
#: python/py-breakpoint.c:218
msgid "The value of `silent' must be a boolean."
#: python/py-type.c:562
msgid "Type is not a template."
msgstr ""
 
#: python/py-breakpoint.c:243
msgid "Cannot delete `thread' attribute."
#: python/py-type.c:574
#, possible-c-format
msgid "No argument %d in template."
msgstr ""
 
#: python/py-breakpoint.c:252
msgid "Invalid thread ID."
#: python/py-type.c:737
msgid "'block' argument must be a Block."
msgstr ""
 
#: python/py-breakpoint.c:261
msgid "The value of `thread' must be an integer or None."
#: python/py-value.c:125
msgid "Value object creation takes only 1 argument"
msgstr ""
 
#: python/py-breakpoint.c:282
msgid "Cannot delete `task' attribute."
#: python/py-value.c:133
msgid "Could not allocate memory to create Value object."
msgstr ""
 
#: python/py-breakpoint.c:291
msgid "Invalid task ID."
#: python/py-value.c:313
msgid "Argument must be a type."
msgstr ""
 
#: python/py-breakpoint.c:300
msgid "The value of `task' must be an integer or None."
#: python/py-value.c:331 python/py-value.c:748 python/py-value.c:785
msgid "Invalid operation on gdb.Value."
msgstr ""
 
#: python/py-breakpoint.c:322
msgid "Cannot delete `ignore_count' attribute."
#: python/py-value.c:375
msgid "Cannot subscript requested type."
msgstr ""
 
#: python/py-breakpoint.c:328
msgid "The value of `ignore_count' must be an integer."
#: python/py-value.c:392
msgid "Setting of struct elements is not currently supported."
msgstr ""
 
#: python/py-breakpoint.c:351
msgid "Cannot delete `hit_count' attribute."
#: python/py-value.c:668
msgid "Attempted truth testing on invalid gdb.Value type."
msgstr ""
 
#: python/py-breakpoint.c:357
msgid "The value of `hit_count' must be zero."
#: python/py-value.c:827
msgid "Cannot convert value to int."
msgstr ""
 
#: python/py-breakpoint.c:435
msgid "Cannot delete `condition' attribute."
#: python/py-value.c:859
msgid "Cannot convert value to long."
msgstr ""
 
#: python/py-breakpoint.c:610
msgid "Cannot understand watchpoint access type."
#: python/py-value.c:889
msgid "Cannot convert value to float."
msgstr ""
 
#: python/py-breakpoint.c:614
msgid "Do not understand breakpoint type to set."
#: python/py-value.c:1028
#, possible-c-format
msgid "Could not convert Python object: %s."
msgstr ""
 
#: python/py-cmd.c:126 python/py-cmd.c:211
msgid "Invalid invocation of Python command object."
#. Require a valid block. All access to block_object->block should be
#. gated by this call.
#: python/py-block.c:64
msgid "Block is invalid."
msgstr ""
 
#: python/py-cmd.c:135
msgid "Python command object missing 'invoke' method."
#. Require a valid block. This macro is called during block iterator
#. creation, and at each next call.
#: python/py-block.c:76
msgid "Source block for iterator is invalid."
msgstr ""
 
#: python/py-cmd.c:142
msgid "Could not convert arguments to Python string."
#: python/py-block.c:251
msgid "Symbol is null."
msgstr ""
 
#. An error occurred computing the string representation of the
#. error message. This is rare, but we should inform the user.
#: python/py-cmd.c:169
msgid ""
"An error occurred in a Python command\n"
"and then another occurred computing the error message.\n"
#: python/py-auto-load.c:195
#, possible-c-format
msgid "Invalid entry in %s section"
msgstr ""
 
#: python/py-cmd.c:187
#: python/py-auto-load.c:210
#, possible-c-format
msgid "Error occurred in Python command: %s"
msgid "Non-null-terminated path in %s: %s"
msgstr ""
 
#: python/py-cmd.c:189
msgid "Error occurred in Python command."
#: python/py-auto-load.c:217
#, possible-c-format
msgid "Empty path in %s"
msgstr ""
 
#: python/py-cmd.c:221 python/py-cmd.c:224
msgid "Could not convert argument to Python string."
#: python/py-auto-load.c:267
#, possible-c-format
msgid "%s (referenced in %s): %s"
msgstr ""
 
#: python/py-cmd.c:310
msgid "No command name found."
#: python/py-auto-load.c:301
#, possible-c-format
msgid "Couldn't read %s section of %s"
msgstr ""
 
#: python/py-cmd.c:342
#: python/py-auto-load.c:426
#, possible-c-format
msgid "Could not find command prefix %s."
msgid "Script name: %s\n"
msgstr ""
 
#: python/py-cmd.c:356
#: python/py-auto-load.c:427
#, possible-c-format
msgid "'%s' is not a prefix command."
msgid " Full name: %s\n"
msgstr ""
 
#: python/py-cmd.c:405
msgid "Command object already initialized."
#: python/py-auto-load.c:448 solib.c:919 solib.c:1013 xcoffsolib.c:113
#, possible-c-format
msgid "Invalid regexp: %s"
msgstr ""
 
#: python/py-cmd.c:420 python/py-param.c:477
msgid "Invalid command class argument."
msgstr ""
 
#: python/py-cmd.c:426
msgid "Invalid completion type argument."
msgstr ""
 
#: python/py-cmd.c:472 python/py-param.c:428
msgid "This command is not documented."
msgstr ""
 
#. Require a valid frame. This must be called inside a TRY_CATCH, or
#. another context in which a gdb exception is allowed.
#: python/py-frame.c:54
msgid "Frame is invalid."
msgstr ""
 
#: python/py-frame.c:277
msgid "Could not allocate frame object."
msgstr ""
 
#: python/py-frame.c:421 python/py-type.c:532
msgid "Second argument must be block."
msgstr ""
 
#: python/py-frame.c:439
#: python/py-auto-load.c:450
#, possible-c-format
msgid "Variable '%s' not found."
msgid "Objfile scripts matching %s:\n"
msgstr ""
 
#: python/py-frame.c:450
msgid "Argument must be a symbol or string."
#: python/py-auto-load.c:455
msgid "Objfile scripts:\n"
msgstr ""
 
#: python/py-frame.c:465
#, possible-c-format
msgid "Variable cannot be found for symbol '%s'."
#: python/py-auto-load.c:477
msgid "Enable or disable auto-loading of Python code when an object is opened."
msgstr ""
 
#: python/py-frame.c:528
msgid "Invalid frame stop reason."
#: python/py-auto-load.c:478
msgid "Show whether Python code will be auto-loaded when an object is opened."
msgstr ""
 
#: python/py-function.c:48
msgid "Could not convert value to Python object."
#: python/py-auto-load.c:479
msgid ""
"Enables or disables auto-loading of Python code when an object is opened."
msgstr ""
 
#: python/py-function.c:73
msgid "No method named 'invoke' in object."
#: python/py-auto-load.c:486
msgid "Print dump of auto-loaded section scripts matching REGEXP."
msgstr ""
 
#: python/py-function.c:83 python/py-function.c:91 python/py-prettyprint.c:569
#: python/python.c:161 python/python.c:182
msgid "Error while executing Python code."
#. Require a valid symbol. All access to symbol_object->symbol should be
#. gated by this call.
#: python/py-symbol.c:48
msgid "Symbol is invalid."
msgstr ""
 
#: python/py-function.c:119
msgid "This function is not documented."
#: python/python.c:151
msgid "Invalid \"python\" block structure."
msgstr ""
 
#. Require that INFERIOR be a valid inferior ID.
#: python/py-inferior.c:71
msgid "Inferior no longer exists."
#: python/python.c:257
msgid "Programmer error: unhandled type."
msgstr ""
 
#: python/py-inferior.c:345
msgid "Could not allocate memory buffer object."
#: python/python.c:284
#, possible-c-format
msgid "Could not find parameter `%s'."
msgstr ""
 
#: python/py-inferior.c:420
#: python/python.c:288
#, possible-c-format
msgid "Memory buffer for address %s, which is %s bytes long."
msgid "`%s' is not a parameter."
msgstr ""
 
#: python/py-inferior.c:434
msgid "The memory buffer supports only one segment."
#: python/python.c:579 python/python.c:593 python/python.c:600
msgid "Python scripting is not supported in this copy of GDB."
msgstr ""
 
#: python/py-inferior.c:500
msgid "Search range is empty."
#: python/python.c:638
msgid ""
"Evaluate a Python command.\n"
"\n"
"The command can be given as an argument, for instance:\n"
"\n"
" python print 23\n"
"\n"
"If no argument is given, the following lines are read and used\n"
"as the Python commands. Type a line containing \"end\" to indicate\n"
"the end of the command."
msgstr ""
 
#: python/py-inferior.c:508
msgid "The search range is too large."
#: python/python.c:649
msgid ""
"Evaluate a Python command.\n"
"\n"
"Python scripting is not supported in this copy of GDB.\n"
"This command is only a placeholder."
msgstr ""
 
#: python/py-inferior.c:516
msgid "Cannot get search address/range from Python."
#: python/python.c:658 python/python.c:662
msgid "Prefix command for python maintenance settings."
msgstr ""
 
#: python/py-inferior.c:524
msgid "The pattern is not a Python buffer."
#: python/python.c:667
msgid "Enable or disable printing of Python stack dump on error."
msgstr ""
 
#. Require that INFERIOR be a valid inferior ID.
#: python/py-infthread.c:34
msgid "Thread no longer exists."
#: python/python.c:668
msgid "Show whether Python stack will be printed on error."
msgstr ""
 
#: python/py-lazy-string.c:103
msgid "Cannot create a value from NULL."
#: python/python.c:669
msgid "Enables or disables printing of Python stack traces."
msgstr ""
 
#: python/py-lazy-string.c:128
msgid "Cannot create a lazy string with address 0x0, and a non-zero length."
#: python/py-utils.c:79
msgid "Expected a string or unicode object."
msgstr ""
 
#: python/py-lazy-string.c:136
msgid "A lazy string's type cannot be NULL."
#: python/py-utils.c:311
msgid "Supplied address is negative."
msgstr ""
 
#: python/py-objfile.c:101
msgid "Cannot delete the pretty_printers attribute."
#: python/py-utils.c:318
msgid "Invalid type for address."
msgstr ""
 
#: python/py-objfile.c:108
msgid "The pretty_printers attribute must be a list."
msgstr ""
 
#: python/py-param.c:131
msgid "String required for filename."
msgstr ""
15596,6 → 15573,14
msgid "The enumeration item not a string."
msgstr ""
 
#: python/py-param.c:428 python/py-cmd.c:472
msgid "This command is not documented."
msgstr ""
 
#: python/py-param.c:477 python/py-cmd.c:420
msgid "Invalid command class argument."
msgstr ""
 
#: python/py-param.c:488
msgid "Invalid parameter class argument."
msgstr ""
15604,16 → 15589,6
msgid "Only PARAM_ENUM accepts a fourth argument."
msgstr ""
 
#: python/py-prettyprint.c:737
msgid "Argument must be a gdb.Value."
msgstr ""
 
#. Require a valid symbol. All access to symbol_object->symbol should be
#. gated by this call.
#: python/py-symbol.c:48
msgid "Symbol is invalid."
msgstr ""
 
#. Require a valid symbol table. All access to symtab_object->symtab
#. should be gated by this call.
#: python/py-symtab.c:50
15626,147 → 15601,172
msgid "Symbol Table and Line is invalid."
msgstr ""
 
#: python/py-type.c:298
msgid "This type does not have a range."
#. Require that BREAKPOINT be a valid breakpoint ID; throw a Python
#. exception if it is invalid.
#. Require that BREAKPOINT be a valid breakpoint ID; throw a Python
#. exception if it is invalid. This macro is for use in setter functions.
#: python/py-breakpoint.c:72 python/py-breakpoint.c:82
#, possible-c-format
msgid "Breakpoint %d is invalid."
msgstr ""
 
#: python/py-type.c:371
msgid "Type does not have a target."
#: python/py-breakpoint.c:179
msgid "Cannot delete `enabled' attribute."
msgstr ""
 
#: python/py-type.c:543
msgid "Null type name."
#: python/py-breakpoint.c:186
msgid "The value of `enabled' must be a boolean."
msgstr ""
 
#: python/py-type.c:562
msgid "Type is not a template."
#: python/py-breakpoint.c:212
msgid "Cannot delete `silent' attribute."
msgstr ""
 
#: python/py-type.c:574
#, possible-c-format
msgid "No argument %d in template."
#: python/py-breakpoint.c:218
msgid "The value of `silent' must be a boolean."
msgstr ""
 
#: python/py-type.c:737
msgid "'block' argument must be a Block."
#: python/py-breakpoint.c:243
msgid "Cannot delete `thread' attribute."
msgstr ""
 
#: python/py-utils.c:79
msgid "Expected a string or unicode object."
#: python/py-breakpoint.c:252
msgid "Invalid thread ID."
msgstr ""
 
#: python/py-utils.c:311
msgid "Supplied address is negative."
#: python/py-breakpoint.c:261
msgid "The value of `thread' must be an integer or None."
msgstr ""
 
#: python/py-utils.c:318
msgid "Invalid type for address."
#: python/py-breakpoint.c:282
msgid "Cannot delete `task' attribute."
msgstr ""
 
#: python/py-value.c:125
msgid "Value object creation takes only 1 argument"
#: python/py-breakpoint.c:291
msgid "Invalid task ID."
msgstr ""
 
#: python/py-value.c:133
msgid "Could not allocate memory to create Value object."
#: python/py-breakpoint.c:300
msgid "The value of `task' must be an integer or None."
msgstr ""
 
#: python/py-value.c:313
msgid "Argument must be a type."
#: python/py-breakpoint.c:322
msgid "Cannot delete `ignore_count' attribute."
msgstr ""
 
#: python/py-value.c:331 python/py-value.c:748 python/py-value.c:785
msgid "Invalid operation on gdb.Value."
#: python/py-breakpoint.c:328
msgid "The value of `ignore_count' must be an integer."
msgstr ""
 
#: python/py-value.c:375
msgid "Cannot subscript requested type."
#: python/py-breakpoint.c:351
msgid "Cannot delete `hit_count' attribute."
msgstr ""
 
#: python/py-value.c:392
msgid "Setting of struct elements is not currently supported."
#: python/py-breakpoint.c:357
msgid "The value of `hit_count' must be zero."
msgstr ""
 
#: python/py-value.c:668
msgid "Attempted truth testing on invalid gdb.Value type."
#: python/py-breakpoint.c:435
msgid "Cannot delete `condition' attribute."
msgstr ""
 
#: python/py-value.c:827
msgid "Cannot convert value to int."
#: python/py-breakpoint.c:610
msgid "Cannot understand watchpoint access type."
msgstr ""
 
#: python/py-value.c:859
msgid "Cannot convert value to long."
#: python/py-breakpoint.c:614
msgid "Do not understand breakpoint type to set."
msgstr ""
 
#: python/py-value.c:889
msgid "Cannot convert value to float."
#. Require that INFERIOR be a valid inferior ID.
#: python/py-inferior.c:71
msgid "Inferior no longer exists."
msgstr ""
 
#: python/py-value.c:1028
#: python/py-inferior.c:345
msgid "Could not allocate memory buffer object."
msgstr ""
 
#: python/py-inferior.c:420
#, possible-c-format
msgid "Could not convert Python object: %s."
msgid "Memory buffer for address %s, which is %s bytes long."
msgstr ""
 
#: python/python.c:151
msgid "Invalid \"python\" block structure."
#: python/py-inferior.c:434
msgid "The memory buffer supports only one segment."
msgstr ""
 
#: python/python.c:257
msgid "Programmer error: unhandled type."
#: python/py-inferior.c:500
msgid "Search range is empty."
msgstr ""
 
#: python/python.c:284
#, possible-c-format
msgid "Could not find parameter `%s'."
#: python/py-inferior.c:508
msgid "The search range is too large."
msgstr ""
 
#: python/python.c:288
#, possible-c-format
msgid "`%s' is not a parameter."
#: python/py-inferior.c:516
msgid "Cannot get search address/range from Python."
msgstr ""
 
#: python/python.c:579 python/python.c:593 python/python.c:600
msgid "Python scripting is not supported in this copy of GDB."
#: python/py-inferior.c:524
msgid "The pattern is not a Python buffer."
msgstr ""
 
#: python/python.c:638
msgid ""
"Evaluate a Python command.\n"
"\n"
"The command can be given as an argument, for instance:\n"
"\n"
" python print 23\n"
"\n"
"If no argument is given, the following lines are read and used\n"
"as the Python commands. Type a line containing \"end\" to indicate\n"
"the end of the command."
#: python/py-cmd.c:126 python/py-cmd.c:211
msgid "Invalid invocation of Python command object."
msgstr ""
 
#: python/python.c:649
#: python/py-cmd.c:135
msgid "Python command object missing 'invoke' method."
msgstr ""
 
#: python/py-cmd.c:142
msgid "Could not convert arguments to Python string."
msgstr ""
 
#. An error occurred computing the string representation of the
#. error message. This is rare, but we should inform the user.
#: python/py-cmd.c:169
msgid ""
"Evaluate a Python command.\n"
"\n"
"Python scripting is not supported in this copy of GDB.\n"
"This command is only a placeholder."
"An error occurred in a Python command\n"
"and then another occurred computing the error message.\n"
msgstr ""
 
#: python/python.c:658 python/python.c:662
msgid "Prefix command for python maintenance settings."
#: python/py-cmd.c:187
#, possible-c-format
msgid "Error occurred in Python command: %s"
msgstr ""
 
#: python/python.c:667
msgid "Enable or disable printing of Python stack dump on error."
#: python/py-cmd.c:189
msgid "Error occurred in Python command."
msgstr ""
 
#: python/python.c:668
msgid "Show whether Python stack will be printed on error."
#: python/py-cmd.c:221 python/py-cmd.c:224
msgid "Could not convert argument to Python string."
msgstr ""
 
#: python/python.c:669
msgid "Enables or disables printing of Python stack traces."
#: python/py-cmd.c:310
msgid "No command name found."
msgstr ""
 
#: python/py-cmd.c:342
#, possible-c-format
msgid "Could not find command prefix %s."
msgstr ""
 
#: python/py-cmd.c:356
#, possible-c-format
msgid "'%s' is not a prefix command."
msgstr ""
 
#: python/py-cmd.c:405
msgid "Command object already initialized."
msgstr ""
 
#: python/py-cmd.c:426
msgid "Invalid completion type argument."
msgstr ""
 
#: record.c:554
msgid ""
"Do you want to auto delete previous execution log entries when record/replay "
19547,13 → 19547,6
"directory as the binary, then in the `"
msgstr ""
 
#: symfile.c:3752
msgid ""
"' subdirectory,\n"
"and lastly at the path of the directory of the binary with\n"
"each global debug-file-directory component prepended."
msgstr ""
 
#: symfile-mem.c:77
msgid "add-symbol-file-from-memory not supported for this target"
msgstr ""
21132,127 → 21125,10
"up and stopping the trace run."
msgstr ""
 
#: tui/tui-file.c:81
msgid "tui_file_delete: bad magic number"
#: tui/tui.c:369
msgid "TUI mode not allowed"
msgstr ""
 
#: tui/tui-file.c:131
msgid "tui_file_isatty: bad magic number"
msgstr ""
 
#: tui/tui-file.c:145
msgid "tui_file_rewind: bad magic number"
msgstr ""
 
#: tui/tui-file.c:158
msgid "tui_file_put: bad magic number"
msgstr ""
 
#: tui/tui-file.c:195
msgid "tui_file_get_strbuf: bad magic number"
msgstr ""
 
#: tui/tui-file.c:210
msgid "tui_file_adjust_strbuf: bad magic number"
msgstr ""
 
#: tui/tui-file.c:238
msgid "tui_file_flush: bad magic number"
msgstr ""
 
#: tui/tui-hooks.c:81
msgid "(y or n) "
msgstr ""
 
#: tui/tui-hooks.c:114
msgid "Please answer y or n.\n"
msgstr ""
 
#: tui/tui-interp.c:131
msgid "tui_exec called"
msgstr ""
 
#: tui/tui-layout.c:389
msgid ""
"Change the layout of windows.\n"
"Usage: layout prev | next | <layout_name> \n"
"Layout names are:\n"
" src : Displays source and command windows.\n"
" asm : Displays disassembly and command windows.\n"
" split : Displays source, disassembly and command windows.\n"
" regs : Displays register window. If existing layout\n"
" is source/command or assembly/command, the \n"
" register window is displayed. If the\n"
" source/assembly/command (split) is displayed, \n"
" the register window is displayed with \n"
" the window that has current logical focus.\n"
msgstr ""
 
#: tui/tui-layout.c:404
msgid "Toggle between Source/Command and Disassembly/Command layouts.\n"
msgstr ""
 
#: tui/tui-layout.c:406
msgid ""
"Toggle between Source/Command or Disassembly/Command and \n"
"Source/Disassembly/Command layouts.\n"
msgstr ""
 
#: tui/tui-layout.c:441
msgid "Ambiguous command input."
msgstr ""
 
#: tui/tui-layout.c:612
#, possible-c-format
msgid ""
"Invalid layout specified.\n"
"%s"
msgstr ""
 
#: tui/tui-regs.c:611
msgid "\"tui reg\" must be followed by the name of a tui reg command.\n"
msgstr ""
 
#: tui/tui-regs.c:627
msgid "TUI commands to control the register window."
msgstr ""
 
#: tui/tui-regs.c:632
msgid "Display only floating point registers."
msgstr ""
 
#: tui/tui-regs.c:635
msgid "Display only general registers."
msgstr ""
 
#: tui/tui-regs.c:638
msgid "Display only system registers."
msgstr ""
 
#: tui/tui-regs.c:641
msgid "Display next register group."
msgstr ""
 
#: tui/tui-regs.c:647
msgid "Display only floating point registers\n"
msgstr ""
 
#: tui/tui-regs.c:649
msgid "Display only general registers\n"
msgstr ""
 
#: tui/tui-regs.c:651
msgid "Display only special registers\n"
msgstr ""
 
#: tui/tui-regs.c:653
msgid "Scroll the registers window forward\n"
msgstr ""
 
#: tui/tui-regs.c:655
msgid "Scroll the register window backward\n"
msgstr ""
 
#: tui/tui-stack.c:438
msgid ""
"Update the source window and locator to display the current execution "
21438,10 → 21314,127
"%s"
msgstr ""
 
#: tui/tui.c:369
msgid "TUI mode not allowed"
#: tui/tui-hooks.c:81
msgid "(y or n) "
msgstr ""
 
#: tui/tui-hooks.c:114
msgid "Please answer y or n.\n"
msgstr ""
 
#: tui/tui-file.c:81
msgid "tui_file_delete: bad magic number"
msgstr ""
 
#: tui/tui-file.c:131
msgid "tui_file_isatty: bad magic number"
msgstr ""
 
#: tui/tui-file.c:145
msgid "tui_file_rewind: bad magic number"
msgstr ""
 
#: tui/tui-file.c:158
msgid "tui_file_put: bad magic number"
msgstr ""
 
#: tui/tui-file.c:195
msgid "tui_file_get_strbuf: bad magic number"
msgstr ""
 
#: tui/tui-file.c:210
msgid "tui_file_adjust_strbuf: bad magic number"
msgstr ""
 
#: tui/tui-file.c:238
msgid "tui_file_flush: bad magic number"
msgstr ""
 
#: tui/tui-regs.c:611
msgid "\"tui reg\" must be followed by the name of a tui reg command.\n"
msgstr ""
 
#: tui/tui-regs.c:627
msgid "TUI commands to control the register window."
msgstr ""
 
#: tui/tui-regs.c:632
msgid "Display only floating point registers."
msgstr ""
 
#: tui/tui-regs.c:635
msgid "Display only general registers."
msgstr ""
 
#: tui/tui-regs.c:638
msgid "Display only system registers."
msgstr ""
 
#: tui/tui-regs.c:641
msgid "Display next register group."
msgstr ""
 
#: tui/tui-regs.c:647
msgid "Display only floating point registers\n"
msgstr ""
 
#: tui/tui-regs.c:649
msgid "Display only general registers\n"
msgstr ""
 
#: tui/tui-regs.c:651
msgid "Display only special registers\n"
msgstr ""
 
#: tui/tui-regs.c:653
msgid "Scroll the registers window forward\n"
msgstr ""
 
#: tui/tui-regs.c:655
msgid "Scroll the register window backward\n"
msgstr ""
 
#: tui/tui-layout.c:389
msgid ""
"Change the layout of windows.\n"
"Usage: layout prev | next | <layout_name> \n"
"Layout names are:\n"
" src : Displays source and command windows.\n"
" asm : Displays disassembly and command windows.\n"
" split : Displays source, disassembly and command windows.\n"
" regs : Displays register window. If existing layout\n"
" is source/command or assembly/command, the \n"
" register window is displayed. If the\n"
" source/assembly/command (split) is displayed, \n"
" the register window is displayed with \n"
" the window that has current logical focus.\n"
msgstr ""
 
#: tui/tui-layout.c:404
msgid "Toggle between Source/Command and Disassembly/Command layouts.\n"
msgstr ""
 
#: tui/tui-layout.c:406
msgid ""
"Toggle between Source/Command or Disassembly/Command and \n"
"Source/Disassembly/Command layouts.\n"
msgstr ""
 
#: tui/tui-layout.c:441
msgid "Ambiguous command input."
msgstr ""
 
#: tui/tui-layout.c:612
#, possible-c-format
msgid ""
"Invalid layout specified.\n"
"%s"
msgstr ""
 
#: tui/tui-interp.c:131
msgid "tui_exec called"
msgstr ""
 
#: typeprint.c:266
msgid "internal error: unhandled type in print_type_scalar"
msgstr ""
/gnu-src/gdb-7.2/gdb/objc-exp.c
1,30 → 1,39
/* A Bison parser, made by GNU Bison 1.875c. */
 
/* Skeleton parser for Yacc-like parsing with Bison,
Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
/* A Bison parser, made by GNU Bison 2.4.1. */
 
This program is free software; you can redistribute it and/or modify
/* 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.
 
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., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
along with this program. If not, see <http://www.gnu.org/licenses/>. */
 
/* As a special exception, when this file is copied by Bison into a
Bison output file, you may use that output file without restriction.
This special exception was added by the Free Software Foundation
in version 1.24 of Bison. */
/* 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. */
 
/* Written by Richard Stallman by simplifying the original so called
``semantic'' parser. */
/* 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
36,6 → 45,9
/* Identify Bison output. */
#define YYBISON 1
 
/* Bison version. */
#define YYBISON_VERSION "2.4.1"
 
/* Skeleton name. */
#define YYSKELETON_NAME "yacc.c"
 
42,106 → 54,20
/* Pure parsers. */
#define YYPURE 0
 
/* Push parsers. */
#define YYPUSH 0
 
/* Pull parsers. */
#define YYPULL 1
 
/* 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 {
INT = 258,
FLOAT = 259,
STRING = 260,
NSSTRING = 261,
SELECTOR = 262,
NAME = 263,
TYPENAME = 264,
CLASSNAME = 265,
NAME_OR_INT = 266,
STRUCT = 267,
CLASS = 268,
UNION = 269,
ENUM = 270,
SIZEOF = 271,
UNSIGNED = 272,
COLONCOLON = 273,
TEMPLATE = 274,
ERROR = 275,
SIGNED_KEYWORD = 276,
LONG = 277,
SHORT = 278,
INT_KEYWORD = 279,
CONST_KEYWORD = 280,
VOLATILE_KEYWORD = 281,
DOUBLE_KEYWORD = 282,
VARIABLE = 283,
ASSIGN_MODIFY = 284,
ABOVE_COMMA = 285,
OROR = 286,
ANDAND = 287,
NOTEQUAL = 288,
EQUAL = 289,
GEQ = 290,
LEQ = 291,
RSH = 292,
LSH = 293,
DECREMENT = 294,
INCREMENT = 295,
UNARY = 296,
ARROW = 297,
BLOCKNAME = 298
};
#endif
#define INT 258
#define FLOAT 259
#define STRING 260
#define NSSTRING 261
#define SELECTOR 262
#define NAME 263
#define TYPENAME 264
#define CLASSNAME 265
#define NAME_OR_INT 266
#define STRUCT 267
#define CLASS 268
#define UNION 269
#define ENUM 270
#define SIZEOF 271
#define UNSIGNED 272
#define COLONCOLON 273
#define TEMPLATE 274
#define ERROR 275
#define SIGNED_KEYWORD 276
#define LONG 277
#define SHORT 278
#define INT_KEYWORD 279
#define CONST_KEYWORD 280
#define VOLATILE_KEYWORD 281
#define DOUBLE_KEYWORD 282
#define VARIABLE 283
#define ASSIGN_MODIFY 284
#define ABOVE_COMMA 285
#define OROR 286
#define ANDAND 287
#define NOTEQUAL 288
#define EQUAL 289
#define GEQ 290
#define LEQ 291
#define RSH 292
#define LSH 293
#define DECREMENT 294
#define INCREMENT 295
#define UNARY 296
#define ARROW 297
#define BLOCKNAME 298
/* Copy the first part of user declarations. */
 
 
 
 
/* Copy the first part of user declarations. */
/* Line 189 of yacc.c */
#line 35 "objc-exp.y"
 
 
229,6 → 155,9
 
 
 
/* Line 189 of yacc.c */
#line 160 "objc-exp.c.tmp"
 
/* Enabling traces. */
#ifndef YYDEBUG
# define YYDEBUG 0
242,9 → 171,114
# define YYERROR_VERBOSE 0
#endif
 
#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
/* Enabling the token table. */
#ifndef YYTOKEN_TABLE
# define YYTOKEN_TABLE 0
#endif
 
 
/* Tokens. */
#ifndef YYTOKENTYPE
# define YYTOKENTYPE
/* Put the tokens into the symbol table, so that GDB and other debuggers
know about them. */
enum yytokentype {
INT = 258,
FLOAT = 259,
STRING = 260,
NSSTRING = 261,
SELECTOR = 262,
NAME = 263,
TYPENAME = 264,
CLASSNAME = 265,
NAME_OR_INT = 266,
STRUCT = 267,
CLASS = 268,
UNION = 269,
ENUM = 270,
SIZEOF = 271,
UNSIGNED = 272,
COLONCOLON = 273,
TEMPLATE = 274,
ERROR = 275,
SIGNED_KEYWORD = 276,
LONG = 277,
SHORT = 278,
INT_KEYWORD = 279,
CONST_KEYWORD = 280,
VOLATILE_KEYWORD = 281,
DOUBLE_KEYWORD = 282,
VARIABLE = 283,
ASSIGN_MODIFY = 284,
ABOVE_COMMA = 285,
OROR = 286,
ANDAND = 287,
NOTEQUAL = 288,
EQUAL = 289,
GEQ = 290,
LEQ = 291,
RSH = 292,
LSH = 293,
DECREMENT = 294,
INCREMENT = 295,
UNARY = 296,
ARROW = 297,
BLOCKNAME = 298
};
#endif
/* Tokens. */
#define INT 258
#define FLOAT 259
#define STRING 260
#define NSSTRING 261
#define SELECTOR 262
#define NAME 263
#define TYPENAME 264
#define CLASSNAME 265
#define NAME_OR_INT 266
#define STRUCT 267
#define CLASS 268
#define UNION 269
#define ENUM 270
#define SIZEOF 271
#define UNSIGNED 272
#define COLONCOLON 273
#define TEMPLATE 274
#define ERROR 275
#define SIGNED_KEYWORD 276
#define LONG 277
#define SHORT 278
#define INT_KEYWORD 279
#define CONST_KEYWORD 280
#define VOLATILE_KEYWORD 281
#define DOUBLE_KEYWORD 282
#define VARIABLE 283
#define ASSIGN_MODIFY 284
#define ABOVE_COMMA 285
#define OROR 286
#define ANDAND 287
#define NOTEQUAL 288
#define EQUAL 289
#define GEQ 290
#define LEQ 291
#define RSH 292
#define LSH 293
#define DECREMENT 294
#define INCREMENT 295
#define UNARY 296
#define ARROW 297
#define BLOCKNAME 298
 
 
 
 
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
typedef union YYSTYPE
{
 
/* Line 214 of yacc.c */
#line 126 "objc-exp.y"
typedef union YYSTYPE {
 
LONGEST lval;
struct {
LONGEST val;
267,17 → 301,21
 
struct type **tvec;
int *ivec;
} YYSTYPE;
/* Line 191 of yacc.c. */
#line 273 "objc-exp.c.tmp"
 
 
/* Line 214 of yacc.c */
#line 309 "objc-exp.c.tmp"
} YYSTYPE;
# define YYSTYPE_IS_TRIVIAL 1
# 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. */
 
/* Copy the second part of user declarations. */
/* Line 264 of yacc.c */
#line 151 "objc-exp.y"
 
/* YYSTYPE gets defined by %union. */
285,58 → 323,172
parse_number (char *, int, int, YYSTYPE *);
 
 
/* Line 214 of yacc.c. */
#line 290 "objc-exp.c.tmp"
/* Line 264 of yacc.c */
#line 328 "objc-exp.c.tmp"
 
#if ! defined (yyoverflow) || YYERROR_VERBOSE
#ifdef short
# undef short
#endif
 
# ifndef YYFREE
# define YYFREE xfree
#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
# ifndef YYMALLOC
# define YYMALLOC xmalloc
#endif
 
#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
 
#ifndef YY_
# if 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 yyi)
#else
static int
YYID (yyi)
int yyi;
#endif
{
return yyi;
}
#endif
 
#if ! defined yyoverflow || YYERROR_VERBOSE
 
/* The parser invokes alloca or xmalloc; define the necessary symbols. */
 
# ifdef YYSTACK_USE_ALLOCA
# if YYSTACK_USE_ALLOCA
# define YYSTACK_ALLOC alloca
# endif
# else
# if defined (alloca) || defined (_ALLOCA_H)
# define YYSTACK_ALLOC alloca
# else
# 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
# 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 (0)
/* 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
# if defined (__STDC__) || defined (__cplusplus)
# 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 xmalloc) \
&& (defined YYFREE || defined xfree)))
# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
# define YYSIZE_T size_t
# ifndef _STDLIB_H
# define _STDLIB_H 1
# endif
# endif
# define YYSTACK_ALLOC YYMALLOC
# define YYSTACK_FREE YYFREE
# ifndef YYMALLOC
# define YYMALLOC xmalloc
# if ! defined xmalloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
void *xmalloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
# endif
# endif
# ifndef YYFREE
# define YYFREE xfree
# if ! defined xfree && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
void xfree (void *); /* INFRINGES ON USER NAME SPACE */
# endif
# endif
# endif
#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
 
 
#if (! defined (yyoverflow) \
&& (! defined (__cplusplus) \
|| (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
#if (! defined yyoverflow \
&& (! defined __cplusplus \
|| (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
 
/* A type that is properly aligned for any stack member. */
union yyalloc
{
short yyss;
YYSTYPE yyvs;
};
yytype_int16 yyss_alloc;
YYSTYPE yyvs_alloc;
};
 
/* The size of the maximum gap between one aligned stack and the next. */
# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
344,13 → 496,13
/* The size of an array large to enough to hold all stacks, each with
N elements. */
# define YYSTACK_BYTES(N) \
((N) * (sizeof (short) + sizeof (YYSTYPE)) \
((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__
# if defined __GNUC__ && 1 < __GNUC__
# define YYCOPY(To, From, Count) \
__builtin_memcpy (To, From, (Count) * sizeof (*(From)))
# else
357,11 → 509,11
# define YYCOPY(To, From, Count) \
do \
{ \
register YYSIZE_T yyi; \
YYSIZE_T yyi; \
for (yyi = 0; yyi < (Count); yyi++) \
(To)[yyi] = (From)[yyi]; \
} \
while (0)
while (YYID (0))
# endif
# endif
 
370,37 → 522,31
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) \
# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
do \
{ \
YYSIZE_T yynewbytes; \
YYCOPY (&yyptr->Stack, Stack, yysize); \
Stack = &yyptr->Stack; \
YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
Stack = &yyptr->Stack_alloc; \
yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
yyptr += yynewbytes / sizeof (*yyptr); \
} \
while (0)
while (YYID (0))
 
#endif
 
#if defined (__STDC__) || defined (__cplusplus)
typedef signed char yysigned_char;
#else
typedef short yysigned_char;
#endif
 
/* YYFINAL -- State number of the termination state. */
/* YYFINAL -- State number of the termination state. */
#define YYFINAL 89
/* YYLAST -- Last index in YYTABLE. */
#define YYLAST 793
 
/* YYNTOKENS -- Number of terminals. */
/* YYNTOKENS -- Number of terminals. */
#define YYNTOKENS 68
/* YYNNTS -- Number of nonterminals. */
/* YYNNTS -- Number of nonterminals. */
#define YYNNTS 29
/* YYNRULES -- Number of rules. */
/* YYNRULES -- Number of rules. */
#define YYNRULES 146
/* YYNRULES -- Number of states. */
/* YYNRULES -- Number of states. */
#define YYNSTATES 236
 
/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
407,11 → 553,11
#define YYUNDEFTOK 2
#define YYMAXUTOK 298
 
#define YYTRANSLATE(YYX) \
#define YYTRANSLATE(YYX) \
((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
 
/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
static const unsigned char yytranslate[] =
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,
448,7 → 594,7
#if YYDEBUG
/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
YYRHS. */
static const unsigned short yyprhs[] =
static const yytype_uint16 yyprhs[] =
{
0, 0, 3, 5, 7, 9, 11, 15, 18, 21,
24, 27, 30, 33, 36, 39, 42, 45, 49, 53,
467,8 → 613,8
443, 445, 447, 449, 451, 453, 455
};
 
/* YYRHS -- A `-1'-separated list of the rules' RHS. */
static const yysigned_char yyrhs[] =
/* YYRHS -- A `-1'-separated list of the rules' RHS. */
static const yytype_int8 yyrhs[] =
{
69, 0, -1, 71, -1, 70, -1, 91, -1, 72,
-1, 71, 30, 72, -1, 50, 72, -1, 38, 72,
519,7 → 665,7
};
 
/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
static const unsigned short yyrline[] =
static const yytype_uint16 yyrline[] =
{
0, 231, 231, 232, 235, 242, 243, 248, 252, 256,
260, 264, 268, 272, 276, 280, 284, 288, 294, 301,
539,9 → 685,9
};
#endif
 
#if YYDEBUG || YYERROR_VERBOSE
/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
First, the terminals, then, starting at YYNTOKENS, nonterminals. */
#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", "INT", "FLOAT", "STRING", "NSSTRING",
554,10 → 700,11
"RSH", "LSH", "'@'", "'+'", "'-'", "'*'", "'/'", "'%'", "DECREMENT",
"INCREMENT", "UNARY", "'.'", "'['", "'('", "ARROW", "BLOCKNAME", "'!'",
"'~'", "']'", "':'", "')'", "'{'", "'}'", "$accept", "start", "type_exp",
"exp1", "exp", "@1", "@2", "@3", "msglist", "msgarglist", "msgarg", "@4",
"lcurly", "arglist", "rcurly", "block", "variable", "qualified_name",
"ptype", "abs_decl", "direct_abs_decl", "array_mod", "func_mod", "type",
"typebase", "typename", "nonempty_typelist", "name", "name_not_typename", 0
"exp1", "exp", "$@1", "$@2", "$@3", "msglist", "msgarglist", "msgarg",
"$@4", "lcurly", "arglist", "rcurly", "block", "variable",
"qualified_name", "ptype", "abs_decl", "direct_abs_decl", "array_mod",
"func_mod", "type", "typebase", "typename", "nonempty_typelist", "name",
"name_not_typename", 0
};
#endif
 
564,7 → 711,7
# ifdef YYPRINT
/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
token YYLEX-NUM. */
static const unsigned short yytoknum[] =
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,
577,7 → 724,7
# endif
 
/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
static const unsigned char yyr1[] =
static const yytype_uint8 yyr1[] =
{
0, 68, 69, 69, 70, 71, 71, 72, 72, 72,
72, 72, 72, 72, 72, 72, 72, 72, 72, 72,
597,7 → 744,7
};
 
/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
static const unsigned char yyr2[] =
static const yytype_uint8 yyr2[] =
{
0, 2, 1, 1, 1, 1, 3, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 3, 3, 4,
619,7 → 766,7
/* 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 unsigned char yydefact[] =
static const yytype_uint8 yydefact[] =
{
0, 70, 72, 77, 78, 75, 145, 108, 109, 71,
0, 0, 0, 0, 0, 128, 0, 0, 130, 111,
647,8 → 794,8
27, 29, 67, 38, 139, 34
};
 
/* YYDEFGOTO[NTERM-NUM]. */
static const short yydefgoto[] =
/* YYDEFGOTO[NTERM-NUM]. */
static const yytype_int16 yydefgoto[] =
{
-1, 37, 38, 85, 40, 140, 141, 142, 204, 205,
206, 174, 41, 120, 180, 42, 43, 44, 45, 130,
658,7 → 805,7
/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
STATE-NUM. */
#define YYPACT_NINF -86
static const short yypact[] =
static const yytype_int16 yypact[] =
{
220, -86, -86, -86, -86, -86, -86, -86, -86, -86,
19, 19, 19, 19, 284, 28, 19, 19, 118, 16,
687,7 → 834,7
};
 
/* YYPGOTO[NTERM-NUM]. */
static const short yypgoto[] =
static const yytype_int16 yypgoto[] =
{
-86, -86, -86, 3, -10, -86, -86, -86, -85, -86,
-51, -86, -86, -11, 37, -86, -86, -79, -86, 6,
699,7 → 846,7
number is the opposite. If zero, do what YYDEFACT says.
If YYTABLE_NINF, syntax error. */
#define YYTABLE_NINF -110
static const short yytable[] =
static const yytype_int16 yytable[] =
{
47, 46, 189, 39, 59, 54, 55, 56, 57, 178,
90, 66, 67, 221, 178, 74, 77, 78, 79, 80,
783,7 → 930,7
115, 116, 117, 118
};
 
static const short yycheck[] =
static const yytype_int16 yycheck[] =
{
0, 0, 3, 0, 14, 10, 11, 12, 13, 30,
30, 16, 17, 30, 30, 24, 26, 27, 28, 29,
869,7 → 1016,7
 
/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
symbol of state STATE-NUM. */
static const unsigned char yystos[] =
static const yytype_uint8 yystos[] =
{
0, 3, 4, 5, 6, 7, 8, 9, 10, 11,
12, 13, 14, 15, 16, 17, 18, 19, 21, 22,
897,22 → 1044,6
63, 63, 72, 65, 91, 72
};
 
#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
# define YYSIZE_T __SIZE_TYPE__
#endif
#if ! defined (YYSIZE_T) && defined (size_t)
# define YYSIZE_T size_t
#endif
#if ! defined (YYSIZE_T)
# if defined (__STDC__) || defined (__cplusplus)
# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
# define YYSIZE_T size_t
# endif
#endif
#if ! defined (YYSIZE_T)
# define YYSIZE_T unsigned int
#endif
 
#define yyerrok (yyerrstatus = 0)
#define yyclearin (yychar = YYEMPTY)
#define YYEMPTY (-2)
938,30 → 1069,63
yychar = (Token); \
yylval = (Value); \
yytoken = YYTRANSLATE (yychar); \
YYPOPSTACK; \
YYPOPSTACK (1); \
goto yybackup; \
} \
else \
{ \
yyerror ("syntax error: cannot back up");\
{ \
yyerror (YY_("syntax error: cannot back up")); \
YYERROR; \
} \
while (0)
while (YYID (0))
 
 
#define YYTERROR 1
#define YYERRCODE 256
 
/* YYLLOC_DEFAULT -- Compute the default location (before the actions
are run). */
 
/* 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) \
((Current).first_line = (Rhs)[1].first_line, \
(Current).first_column = (Rhs)[1].first_column, \
(Current).last_line = (Rhs)[N].last_line, \
(Current).last_column = (Rhs)[N].last_column)
# 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 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
982,43 → 1146,100
do { \
if (yydebug) \
YYFPRINTF Args; \
} while (0)
} while (YYID (0))
 
# define YYDSYMPRINT(Args) \
do { \
if (yydebug) \
yysymprint Args; \
} while (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))
 
# define YYDSYMPRINTF(Title, Token, Value, Location) \
do { \
if (yydebug) \
{ \
YYFPRINTF (stderr, "%s ", Title); \
yysymprint (stderr, \
Token, Value); \
YYFPRINTF (stderr, "\n"); \
} \
} while (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 (__cplusplus)
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
static void
yy_stack_print (short *bottom, short *top)
yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
#else
static void
yy_stack_print (bottom, top)
short *bottom;
short *top;
yy_stack_print (yybottom, yytop)
yytype_int16 *yybottom;
yytype_int16 *yytop;
#endif
{
YYFPRINTF (stderr, "Stack now");
for (/* Nothing. */; bottom <= top; ++bottom)
YYFPRINTF (stderr, " %d", *bottom);
for (; yybottom <= yytop; yybottom++)
{
int yybot = *yybottom;
YYFPRINTF (stderr, " %d", yybot);
}
YYFPRINTF (stderr, "\n");
}
 
1026,7 → 1247,7
do { \
if (yydebug) \
yy_stack_print ((Bottom), (Top)); \
} while (0)
} while (YYID (0))
 
 
/*------------------------------------------------.
1033,30 → 1254,38
| Report that the YYRULE is going to be reduced. |
`------------------------------------------------*/
 
#if defined (__STDC__) || defined (__cplusplus)
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
static void
yy_reduce_print (int yyrule)
yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
#else
static void
yy_reduce_print (yyrule)
yy_reduce_print (yyvsp, yyrule)
YYSTYPE *yyvsp;
int yyrule;
#endif
{
int yynrhs = yyr2[yyrule];
int yyi;
unsigned int yylno = yyrline[yyrule];
YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
yyrule - 1, yylno);
/* Print the symbols being reduced, and their result. */
for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);
YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);
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++)
{
YYFPRINTF (stderr, " $%d = ", yyi + 1);
yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
&(yyvsp[(yyi + 1) - (yynrhs)])
);
YYFPRINTF (stderr, "\n");
}
}
 
# define YY_REDUCE_PRINT(Rule) \
do { \
if (yydebug) \
yy_reduce_print (Rule); \
} while (0)
yy_reduce_print (yyvsp, Rule); \
} while (YYID (0))
 
/* Nonzero means print parse trace. It is left uninitialized so that
multiple parsers can coexist. */
1063,8 → 1292,7
int yydebug;
#else /* !YYDEBUG */
# define YYDPRINTF(Args)
# define YYDSYMPRINT(Args)
# define YYDSYMPRINTF(Title, Token, Value, Location)
# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
# define YY_STACK_PRINT(Bottom, Top)
# define YY_REDUCE_PRINT(Rule)
#endif /* !YYDEBUG */
1079,13 → 1307,9
if the built-in stack extension method is used).
 
Do not make this value too large; the results are undefined if
SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
evaluated with infinite-precision integer arithmetic. */
 
#if defined (YYMAXDEPTH) && YYMAXDEPTH == 0
# undef YYMAXDEPTH
#endif
 
#ifndef YYMAXDEPTH
# define YYMAXDEPTH 10000
#endif
1095,45 → 1319,47
#if YYERROR_VERBOSE
 
# ifndef yystrlen
# if defined (__GLIBC__) && defined (_STRING_H)
# 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
# if defined (__STDC__) || defined (__cplusplus)
yystrlen (const char *yystr)
# else
#else
static YYSIZE_T
yystrlen (yystr)
const char *yystr;
# endif
const char *yystr;
#endif
{
register const char *yys = yystr;
 
while (*yys++ != '\0')
YYSIZE_T yylen;
for (yylen = 0; yystr[yylen]; yylen++)
continue;
 
return yys - yystr - 1;
return yylen;
}
# endif
# endif
 
# ifndef yystpcpy
# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
# 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 *
# if defined (__STDC__) || defined (__cplusplus)
yystpcpy (char *yydest, const char *yysrc)
# else
#else
static char *
yystpcpy (yydest, yysrc)
char *yydest;
const char *yysrc;
# endif
char *yydest;
const char *yysrc;
#endif
{
register char *yyd = yydest;
register const char *yys = yysrc;
char *yyd = yydest;
const char *yys = yysrc;
 
while ((*yyd++ = *yys++) != '\0')
continue;
1143,84 → 1369,204
# endif
# endif
 
#endif /* !YYERROR_VERBOSE */
# 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;
 
#if YYDEBUG
/*--------------------------------.
| Print this symbol on YYOUTPUT. |
`--------------------------------*/
case '\\':
if (*++yyp != '\\')
goto do_not_strip_quotes;
/* Fall through. */
default:
if (yyres)
yyres[yyn] = *yyp;
yyn++;
break;
 
#if defined (__STDC__) || defined (__cplusplus)
static void
yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
#else
static void
yysymprint (yyoutput, yytype, yyvaluep)
FILE *yyoutput;
int yytype;
YYSTYPE *yyvaluep;
#endif
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)
{
/* Pacify ``unused variable'' warnings. */
(void) yyvaluep;
int yyn = yypact[yystate];
 
if (yytype < YYNTOKENS)
if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
return 0;
else
{
YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
# ifdef YYPRINT
YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
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
}
else
YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
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;
 
switch (yytype)
{
default:
break;
/* 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;
}
YYFPRINTF (yyoutput, ")");
}
#endif /* YYERROR_VERBOSE */
 
#endif /* ! YYDEBUG */
/*-----------------------------------------------.
| Release the memory associated to this symbol. |
`-----------------------------------------------*/
 
#if defined (__STDC__) || defined (__cplusplus)
/*ARGSUSED*/
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
static void
yydestruct (int yytype, YYSTYPE *yyvaluep)
yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
#else
static void
yydestruct (yytype, yyvaluep)
yydestruct (yymsg, yytype, yyvaluep)
const char *yymsg;
int yytype;
YYSTYPE *yyvaluep;
#endif
{
/* Pacify ``unused variable'' warnings. */
(void) yyvaluep;
YYUSE (yyvaluep);
 
if (!yymsg)
yymsg = "Deleting";
YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
 
switch (yytype)
{
 
default:
break;
break;
}
}
 
/* Prevent warnings from -Wmissing-prototypes. */
 
#ifdef YYPARSE_PARAM
# if defined (__STDC__) || defined (__cplusplus)
#if defined __STDC__ || defined __cplusplus
int yyparse (void *YYPARSE_PARAM);
# else
#else
int yyparse ();
# endif
#endif
#else /* ! YYPARSE_PARAM */
#if defined (__STDC__) || defined (__cplusplus)
#if defined __STDC__ || defined __cplusplus
int yyparse (void);
#else
int yyparse ();
1228,7 → 1574,6
#endif /* ! YYPARSE_PARAM */
 
 
 
/* The lookahead symbol. */
int yychar;
 
1240,19 → 1585,23
 
 
 
/*----------.
| yyparse. |
`----------*/
/*-------------------------.
| yyparse or yypush_parse. |
`-------------------------*/
 
#ifdef YYPARSE_PARAM
# if defined (__STDC__) || defined (__cplusplus)
int yyparse (void *YYPARSE_PARAM)
# else
int yyparse (YYPARSE_PARAM)
void *YYPARSE_PARAM;
# endif
#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 (__cplusplus)
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
int
yyparse (void)
#else
1262,60 → 1611,68
#endif
#endif
{
register int yystate;
register int yyn;
int yyresult;
/* Number of tokens to shift before error messages enabled. */
int yyerrstatus;
/* Lookahead token as an internal (translated) token number. */
int yytoken = 0;
 
/* 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 xreallocate them elsewhere. */
int yystate;
/* Number of tokens to shift before error messages enabled. */
int yyerrstatus;
 
/* The state stack. */
short yyssa[YYINITDEPTH];
short *yyss = yyssa;
register short *yyssp;
/* The stacks and their tools:
`yyss': related to states.
`yyvs': related to semantic values.
 
/* The semantic value stack. */
YYSTYPE yyvsa[YYINITDEPTH];
YYSTYPE *yyvs = yyvsa;
register YYSTYPE *yyvsp;
Refer to the stacks thru separate pointers, to allow yyoverflow
to xreallocate them elsewhere. */
 
/* The state stack. */
yytype_int16 yyssa[YYINITDEPTH];
yytype_int16 *yyss;
yytype_int16 *yyssp;
 
/* The semantic value stack. */
YYSTYPE yyvsa[YYINITDEPTH];
YYSTYPE *yyvs;
YYSTYPE *yyvsp;
 
#define YYPOPSTACK (yyvsp--, yyssp--)
YYSIZE_T yystacksize;
 
YYSIZE_T yystacksize = YYINITDEPTH;
 
int yyn;
int yyresult;
/* Lookahead token as an internal (translated) token number. */
int yytoken;
/* The variables used to return semantic value and location from the
action routines. */
YYSTYPE yyval;
 
#if YYERROR_VERBOSE
/* Buffer for error messages, and its allocated size. */
char yymsgbuf[128];
char *yymsg = yymsgbuf;
YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
#endif
 
/* When reducing, the number of symbols on the RHS of the reduced
rule. */
int yylen;
#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
 
/* The number of symbols on the RHS of the reduced rule.
Keep to zero when no symbol should be popped. */
int yylen = 0;
 
yytoken = 0;
yyss = yyssa;
yyvs = yyvsa;
yystacksize = YYINITDEPTH;
 
YYDPRINTF ((stderr, "Starting parse\n"));
 
yystate = 0;
yyerrstatus = 0;
yynerrs = 0;
yychar = YYEMPTY; /* Cause a token to be read. */
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;
 
1326,8 → 1683,7
`------------------------------------------------------------*/
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.
*/
have just been pushed. So pushing a state here evens the stacks. */
yyssp++;
 
yysetstate:
1340,21 → 1696,19
 
#ifdef yyoverflow
{
/* Give user a chance to xreallocate the stack. Use copies of
/* Give user a chance to xreallocate the stack. Use copies of
these so that the &'s don't force the real ones into
memory. */
YYSTYPE *yyvs1 = yyvs;
short *yyss1 = yyss;
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 ("parser stack overflow",
yyoverflow (YY_("memory exhausted"),
&yyss1, yysize * sizeof (*yyssp),
&yyvs1, yysize * sizeof (*yyvsp),
 
&yystacksize);
 
yyss = yyss1;
1362,24 → 1716,23
}
#else /* no yyoverflow */
# ifndef YYSTACK_RELOCATE
goto yyoverflowlab;
goto yyexhaustedlab;
# else
/* Extend the stack our own way. */
if (YYMAXDEPTH <= yystacksize)
goto yyoverflowlab;
goto yyexhaustedlab;
yystacksize *= 2;
if (YYMAXDEPTH < yystacksize)
yystacksize = YYMAXDEPTH;
 
{
short *yyss1 = yyss;
yytype_int16 *yyss1 = yyss;
union yyalloc *yyptr =
(union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
if (! yyptr)
goto yyoverflowlab;
YYSTACK_RELOCATE (yyss);
YYSTACK_RELOCATE (yyvs);
 
goto yyexhaustedlab;
YYSTACK_RELOCATE (yyss_alloc, yyss);
YYSTACK_RELOCATE (yyvs_alloc, yyvs);
# undef YYSTACK_RELOCATE
if (yyss1 != yyssa)
YYSTACK_FREE (yyss1);
1390,7 → 1743,6
yyssp = yyss + yysize - 1;
yyvsp = yyvs + yysize - 1;
 
 
YYDPRINTF ((stderr, "Stack size increased to %lu\n",
(unsigned long int) yystacksize));
 
1400,6 → 1752,9
 
YYDPRINTF ((stderr, "Entering state %d\n", yystate));
 
if (yystate == YYFINAL)
YYACCEPT;
 
goto yybackup;
 
/*-----------.
1407,12 → 1762,10
`-----------*/
yybackup:
 
/* Do appropriate processing given the current state. */
/* Read a lookahead token if we need one and don't already have one. */
/* yyresume: */
/* Do appropriate processing given the current state. Read a
lookahead token if we need one and don't already have one. */
 
/* First try to decide what to do without reference to lookahead token. */
 
yyn = yypact[yystate];
if (yyn == YYPACT_NINF)
goto yydefault;
1434,7 → 1787,7
else
{
yytoken = YYTRANSLATE (yychar);
YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc);
YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
}
 
/* If the proper action on seeing token YYTOKEN is to reduce or to
1451,25 → 1804,20
goto yyreduce;
}
 
if (yyn == YYFINAL)
YYACCEPT;
/* Count tokens shifted since error; after three, turn off error
status. */
if (yyerrstatus)
yyerrstatus--;
 
/* Shift the lookahead token. */
YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken]));
YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
 
/* Discard the token being shifted unless it is eof. */
if (yychar != YYEOF)
yychar = YYEMPTY;
/* Discard the shifted token. */
yychar = YYEMPTY;
 
yystate = yyn;
*++yyvsp = yylval;
 
 
/* Count tokens shifted since error; after three, turn off error
status. */
if (yyerrstatus)
yyerrstatus--;
 
yystate = yyn;
goto yynewstate;
 
 
1505,75 → 1853,103
switch (yyn)
{
case 4:
 
/* Line 1455 of yacc.c */
#line 236 "objc-exp.y"
{ write_exp_elt_opcode(OP_TYPE);
write_exp_elt_type(yyvsp[0].tval);
write_exp_elt_type((yyvsp[(1) - (1)].tval));
write_exp_elt_opcode(OP_TYPE);}
break;
 
case 6:
 
/* Line 1455 of yacc.c */
#line 244 "objc-exp.y"
{ write_exp_elt_opcode (BINOP_COMMA); }
break;
 
case 7:
 
/* Line 1455 of yacc.c */
#line 249 "objc-exp.y"
{ write_exp_elt_opcode (UNOP_IND); }
break;
 
case 8:
 
/* Line 1455 of yacc.c */
#line 253 "objc-exp.y"
{ write_exp_elt_opcode (UNOP_ADDR); }
break;
 
case 9:
 
/* Line 1455 of yacc.c */
#line 257 "objc-exp.y"
{ write_exp_elt_opcode (UNOP_NEG); }
break;
 
case 10:
 
/* Line 1455 of yacc.c */
#line 261 "objc-exp.y"
{ write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
break;
 
case 11:
 
/* Line 1455 of yacc.c */
#line 265 "objc-exp.y"
{ write_exp_elt_opcode (UNOP_COMPLEMENT); }
break;
 
case 12:
 
/* Line 1455 of yacc.c */
#line 269 "objc-exp.y"
{ write_exp_elt_opcode (UNOP_PREINCREMENT); }
break;
 
case 13:
 
/* Line 1455 of yacc.c */
#line 273 "objc-exp.y"
{ write_exp_elt_opcode (UNOP_PREDECREMENT); }
break;
 
case 14:
 
/* Line 1455 of yacc.c */
#line 277 "objc-exp.y"
{ write_exp_elt_opcode (UNOP_POSTINCREMENT); }
break;
 
case 15:
 
/* Line 1455 of yacc.c */
#line 281 "objc-exp.y"
{ write_exp_elt_opcode (UNOP_POSTDECREMENT); }
break;
 
case 16:
 
/* Line 1455 of yacc.c */
#line 285 "objc-exp.y"
{ write_exp_elt_opcode (UNOP_SIZEOF); }
break;
 
case 17:
 
/* Line 1455 of yacc.c */
#line 289 "objc-exp.y"
{ write_exp_elt_opcode (STRUCTOP_PTR);
write_exp_string (yyvsp[0].sval);
write_exp_string ((yyvsp[(3) - (3)].sval));
write_exp_elt_opcode (STRUCTOP_PTR); }
break;
 
case 18:
 
/* Line 1455 of yacc.c */
#line 295 "objc-exp.y"
{ /* exp->type::name becomes exp->*(&type::name) */
/* Note: this doesn't work if name is a
1583,18 → 1959,24
break;
 
case 19:
 
/* Line 1455 of yacc.c */
#line 302 "objc-exp.y"
{ write_exp_elt_opcode (STRUCTOP_MPTR); }
break;
 
case 20:
 
/* Line 1455 of yacc.c */
#line 306 "objc-exp.y"
{ write_exp_elt_opcode (STRUCTOP_STRUCT);
write_exp_string (yyvsp[0].sval);
write_exp_string ((yyvsp[(3) - (3)].sval));
write_exp_elt_opcode (STRUCTOP_STRUCT); }
break;
 
case 21:
 
/* Line 1455 of yacc.c */
#line 313 "objc-exp.y"
{ /* exp.type::name becomes exp.*(&type::name) */
/* Note: this doesn't work if name is a
1604,25 → 1986,31
break;
 
case 22:
 
/* Line 1455 of yacc.c */
#line 321 "objc-exp.y"
{ write_exp_elt_opcode (STRUCTOP_MEMBER); }
break;
 
case 23:
 
/* Line 1455 of yacc.c */
#line 325 "objc-exp.y"
{ write_exp_elt_opcode (BINOP_SUBSCRIPT); }
break;
 
case 24:
 
/* Line 1455 of yacc.c */
#line 333 "objc-exp.y"
{
CORE_ADDR class;
 
class = lookup_objc_class (parse_gdbarch,
copy_name (yyvsp[0].tsym.stoken));
copy_name ((yyvsp[(2) - (2)].tsym).stoken));
if (class == 0)
error ("%s is not an ObjC Class",
copy_name (yyvsp[0].tsym.stoken));
copy_name ((yyvsp[(2) - (2)].tsym).stoken));
write_exp_elt_opcode (OP_LONG);
write_exp_elt_type (parse_type->builtin_int);
write_exp_elt_longcst ((LONGEST) class);
1632,6 → 2020,8
break;
 
case 25:
 
/* Line 1455 of yacc.c */
#line 348 "objc-exp.y"
{ write_exp_elt_opcode (OP_OBJC_MSGCALL);
end_msglist();
1640,11 → 2030,13
break;
 
case 26:
 
/* Line 1455 of yacc.c */
#line 355 "objc-exp.y"
{
write_exp_elt_opcode (OP_LONG);
write_exp_elt_type (parse_type->builtin_int);
write_exp_elt_longcst ((LONGEST) yyvsp[0].class.class);
write_exp_elt_longcst ((LONGEST) (yyvsp[(2) - (2)].class).class);
write_exp_elt_opcode (OP_LONG);
start_msglist();
}
1651,6 → 2043,8
break;
 
case 27:
 
/* Line 1455 of yacc.c */
#line 363 "objc-exp.y"
{ write_exp_elt_opcode (OP_OBJC_MSGCALL);
end_msglist();
1659,11 → 2053,15
break;
 
case 28:
 
/* Line 1455 of yacc.c */
#line 370 "objc-exp.y"
{ start_msglist(); }
break;
 
case 29:
 
/* Line 1455 of yacc.c */
#line 372 "objc-exp.y"
{ write_exp_elt_opcode (OP_OBJC_MSGCALL);
end_msglist();
1672,31 → 2070,43
break;
 
case 30:
 
/* Line 1455 of yacc.c */
#line 379 "objc-exp.y"
{ add_msglist(&yyvsp[0].sval, 0); }
{ add_msglist(&(yyvsp[(1) - (1)].sval), 0); }
break;
 
case 34:
 
/* Line 1455 of yacc.c */
#line 388 "objc-exp.y"
{ add_msglist(&yyvsp[-2].sval, 1); }
{ add_msglist(&(yyvsp[(1) - (3)].sval), 1); }
break;
 
case 35:
 
/* Line 1455 of yacc.c */
#line 390 "objc-exp.y"
{ add_msglist(0, 1); }
break;
 
case 36:
 
/* Line 1455 of yacc.c */
#line 392 "objc-exp.y"
{ add_msglist(0, 0); }
break;
 
case 37:
 
/* Line 1455 of yacc.c */
#line 398 "objc-exp.y"
{ start_arglist (); }
break;
 
case 38:
 
/* Line 1455 of yacc.c */
#line 400 "objc-exp.y"
{ write_exp_elt_opcode (OP_FUNCALL);
write_exp_elt_longcst ((LONGEST) end_arglist ());
1704,176 → 2114,240
break;
 
case 39:
 
/* Line 1455 of yacc.c */
#line 406 "objc-exp.y"
{ start_arglist (); }
break;
 
case 41:
 
/* Line 1455 of yacc.c */
#line 413 "objc-exp.y"
{ arglist_len = 1; }
break;
 
case 42:
 
/* Line 1455 of yacc.c */
#line 417 "objc-exp.y"
{ arglist_len++; }
break;
 
case 43:
 
/* Line 1455 of yacc.c */
#line 421 "objc-exp.y"
{ yyval.lval = end_arglist () - 1; }
{ (yyval.lval) = end_arglist () - 1; }
break;
 
case 44:
 
/* Line 1455 of yacc.c */
#line 424 "objc-exp.y"
{ write_exp_elt_opcode (OP_ARRAY);
write_exp_elt_longcst ((LONGEST) 0);
write_exp_elt_longcst ((LONGEST) yyvsp[0].lval);
write_exp_elt_longcst ((LONGEST) (yyvsp[(3) - (3)].lval));
write_exp_elt_opcode (OP_ARRAY); }
break;
 
case 45:
 
/* Line 1455 of yacc.c */
#line 431 "objc-exp.y"
{ write_exp_elt_opcode (UNOP_MEMVAL);
write_exp_elt_type (yyvsp[-2].tval);
write_exp_elt_type ((yyvsp[(2) - (4)].tval));
write_exp_elt_opcode (UNOP_MEMVAL); }
break;
 
case 46:
 
/* Line 1455 of yacc.c */
#line 437 "objc-exp.y"
{ write_exp_elt_opcode (UNOP_CAST);
write_exp_elt_type (yyvsp[-2].tval);
write_exp_elt_type ((yyvsp[(2) - (4)].tval));
write_exp_elt_opcode (UNOP_CAST); }
break;
 
case 47:
 
/* Line 1455 of yacc.c */
#line 443 "objc-exp.y"
{ }
break;
 
case 48:
 
/* Line 1455 of yacc.c */
#line 449 "objc-exp.y"
{ write_exp_elt_opcode (BINOP_REPEAT); }
break;
 
case 49:
 
/* Line 1455 of yacc.c */
#line 453 "objc-exp.y"
{ write_exp_elt_opcode (BINOP_MUL); }
break;
 
case 50:
 
/* Line 1455 of yacc.c */
#line 457 "objc-exp.y"
{ write_exp_elt_opcode (BINOP_DIV); }
break;
 
case 51:
 
/* Line 1455 of yacc.c */
#line 461 "objc-exp.y"
{ write_exp_elt_opcode (BINOP_REM); }
break;
 
case 52:
 
/* Line 1455 of yacc.c */
#line 465 "objc-exp.y"
{ write_exp_elt_opcode (BINOP_ADD); }
break;
 
case 53:
 
/* Line 1455 of yacc.c */
#line 469 "objc-exp.y"
{ write_exp_elt_opcode (BINOP_SUB); }
break;
 
case 54:
 
/* Line 1455 of yacc.c */
#line 473 "objc-exp.y"
{ write_exp_elt_opcode (BINOP_LSH); }
break;
 
case 55:
 
/* Line 1455 of yacc.c */
#line 477 "objc-exp.y"
{ write_exp_elt_opcode (BINOP_RSH); }
break;
 
case 56:
 
/* Line 1455 of yacc.c */
#line 481 "objc-exp.y"
{ write_exp_elt_opcode (BINOP_EQUAL); }
break;
 
case 57:
 
/* Line 1455 of yacc.c */
#line 485 "objc-exp.y"
{ write_exp_elt_opcode (BINOP_NOTEQUAL); }
break;
 
case 58:
 
/* Line 1455 of yacc.c */
#line 489 "objc-exp.y"
{ write_exp_elt_opcode (BINOP_LEQ); }
break;
 
case 59:
 
/* Line 1455 of yacc.c */
#line 493 "objc-exp.y"
{ write_exp_elt_opcode (BINOP_GEQ); }
break;
 
case 60:
 
/* Line 1455 of yacc.c */
#line 497 "objc-exp.y"
{ write_exp_elt_opcode (BINOP_LESS); }
break;
 
case 61:
 
/* Line 1455 of yacc.c */
#line 501 "objc-exp.y"
{ write_exp_elt_opcode (BINOP_GTR); }
break;
 
case 62:
 
/* Line 1455 of yacc.c */
#line 505 "objc-exp.y"
{ write_exp_elt_opcode (BINOP_BITWISE_AND); }
break;
 
case 63:
 
/* Line 1455 of yacc.c */
#line 509 "objc-exp.y"
{ write_exp_elt_opcode (BINOP_BITWISE_XOR); }
break;
 
case 64:
 
/* Line 1455 of yacc.c */
#line 513 "objc-exp.y"
{ write_exp_elt_opcode (BINOP_BITWISE_IOR); }
break;
 
case 65:
 
/* Line 1455 of yacc.c */
#line 517 "objc-exp.y"
{ write_exp_elt_opcode (BINOP_LOGICAL_AND); }
break;
 
case 66:
 
/* Line 1455 of yacc.c */
#line 521 "objc-exp.y"
{ write_exp_elt_opcode (BINOP_LOGICAL_OR); }
break;
 
case 67:
 
/* Line 1455 of yacc.c */
#line 525 "objc-exp.y"
{ write_exp_elt_opcode (TERNOP_COND); }
break;
 
case 68:
 
/* Line 1455 of yacc.c */
#line 529 "objc-exp.y"
{ write_exp_elt_opcode (BINOP_ASSIGN); }
break;
 
case 69:
 
/* Line 1455 of yacc.c */
#line 533 "objc-exp.y"
{ write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
write_exp_elt_opcode (yyvsp[-1].opcode);
write_exp_elt_opcode ((yyvsp[(2) - (3)].opcode));
write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); }
break;
 
case 70:
 
/* Line 1455 of yacc.c */
#line 539 "objc-exp.y"
{ write_exp_elt_opcode (OP_LONG);
write_exp_elt_type (yyvsp[0].typed_val_int.type);
write_exp_elt_longcst ((LONGEST)(yyvsp[0].typed_val_int.val));
write_exp_elt_type ((yyvsp[(1) - (1)].typed_val_int).type);
write_exp_elt_longcst ((LONGEST)((yyvsp[(1) - (1)].typed_val_int).val));
write_exp_elt_opcode (OP_LONG); }
break;
 
case 71:
 
/* Line 1455 of yacc.c */
#line 546 "objc-exp.y"
{ YYSTYPE val;
parse_number (yyvsp[0].ssym.stoken.ptr, yyvsp[0].ssym.stoken.length, 0, &val);
parse_number ((yyvsp[(1) - (1)].ssym).stoken.ptr, (yyvsp[(1) - (1)].ssym).stoken.length, 0, &val);
write_exp_elt_opcode (OP_LONG);
write_exp_elt_type (val.typed_val_int.type);
write_exp_elt_longcst ((LONGEST)val.typed_val_int.val);
1882,31 → 2356,39
break;
 
case 72:
 
/* Line 1455 of yacc.c */
#line 557 "objc-exp.y"
{ write_exp_elt_opcode (OP_DOUBLE);
write_exp_elt_type (yyvsp[0].typed_val_float.type);
write_exp_elt_dblcst (yyvsp[0].typed_val_float.dval);
write_exp_elt_type ((yyvsp[(1) - (1)].typed_val_float).type);
write_exp_elt_dblcst ((yyvsp[(1) - (1)].typed_val_float).dval);
write_exp_elt_opcode (OP_DOUBLE); }
break;
 
case 75:
 
/* Line 1455 of yacc.c */
#line 571 "objc-exp.y"
{
write_exp_elt_opcode (OP_OBJC_SELECTOR);
write_exp_string (yyvsp[0].sval);
write_exp_string ((yyvsp[(1) - (1)].sval));
write_exp_elt_opcode (OP_OBJC_SELECTOR); }
break;
 
case 76:
 
/* Line 1455 of yacc.c */
#line 578 "objc-exp.y"
{ write_exp_elt_opcode (OP_LONG);
write_exp_elt_type (parse_type->builtin_int);
CHECK_TYPEDEF (yyvsp[-1].tval);
write_exp_elt_longcst ((LONGEST) TYPE_LENGTH (yyvsp[-1].tval));
CHECK_TYPEDEF ((yyvsp[(3) - (4)].tval));
write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ((yyvsp[(3) - (4)].tval)));
write_exp_elt_opcode (OP_LONG); }
break;
 
case 77:
 
/* Line 1455 of yacc.c */
#line 586 "objc-exp.y"
{ /* C strings are converted into array
constants with an explicit null byte
1914,7 → 2396,7
bound is the string length. There is no
such thing in C as a completely empty
string. */
char *sp = yyvsp[0].sval.ptr; int count = yyvsp[0].sval.length;
char *sp = (yyvsp[(1) - (1)].sval).ptr; int count = (yyvsp[(1) - (1)].sval).length;
while (count-- > 0)
{
write_exp_elt_opcode (OP_LONG);
1928,54 → 2410,62
write_exp_elt_opcode (OP_LONG);
write_exp_elt_opcode (OP_ARRAY);
write_exp_elt_longcst ((LONGEST) 0);
write_exp_elt_longcst ((LONGEST) (yyvsp[0].sval.length));
write_exp_elt_longcst ((LONGEST) ((yyvsp[(1) - (1)].sval).length));
write_exp_elt_opcode (OP_ARRAY); }
break;
 
case 78:
 
/* Line 1455 of yacc.c */
#line 613 "objc-exp.y"
{ write_exp_elt_opcode (OP_OBJC_NSSTRING);
write_exp_string (yyvsp[0].sval);
write_exp_string ((yyvsp[(1) - (1)].sval));
write_exp_elt_opcode (OP_OBJC_NSSTRING); }
break;
 
case 79:
 
/* Line 1455 of yacc.c */
#line 619 "objc-exp.y"
{
if (yyvsp[0].ssym.sym != 0)
yyval.bval = SYMBOL_BLOCK_VALUE (yyvsp[0].ssym.sym);
if ((yyvsp[(1) - (1)].ssym).sym != 0)
(yyval.bval) = SYMBOL_BLOCK_VALUE ((yyvsp[(1) - (1)].ssym).sym);
else
{
struct symtab *tem =
lookup_symtab (copy_name (yyvsp[0].ssym.stoken));
lookup_symtab (copy_name ((yyvsp[(1) - (1)].ssym).stoken));
if (tem)
yyval.bval = BLOCKVECTOR_BLOCK (BLOCKVECTOR (tem), STATIC_BLOCK);
(yyval.bval) = BLOCKVECTOR_BLOCK (BLOCKVECTOR (tem), STATIC_BLOCK);
else
error ("No file or function \"%s\".",
copy_name (yyvsp[0].ssym.stoken));
copy_name ((yyvsp[(1) - (1)].ssym).stoken));
}
}
break;
 
case 80:
 
/* Line 1455 of yacc.c */
#line 636 "objc-exp.y"
{ struct symbol *tem
= lookup_symbol (copy_name (yyvsp[0].sval), yyvsp[-2].bval,
= lookup_symbol (copy_name ((yyvsp[(3) - (3)].sval)), (yyvsp[(1) - (3)].bval),
VAR_DOMAIN, (int *) NULL);
if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
error ("No function \"%s\" in specified context.",
copy_name (yyvsp[0].sval));
yyval.bval = SYMBOL_BLOCK_VALUE (tem); }
copy_name ((yyvsp[(3) - (3)].sval)));
(yyval.bval) = SYMBOL_BLOCK_VALUE (tem); }
break;
 
case 81:
 
/* Line 1455 of yacc.c */
#line 646 "objc-exp.y"
{ struct symbol *sym;
sym = lookup_symbol (copy_name (yyvsp[0].sval), yyvsp[-2].bval,
sym = lookup_symbol (copy_name ((yyvsp[(3) - (3)].sval)), (yyvsp[(1) - (3)].bval),
VAR_DOMAIN, (int *) NULL);
if (sym == 0)
error ("No symbol \"%s\" in specified context.",
copy_name (yyvsp[0].sval));
copy_name ((yyvsp[(3) - (3)].sval)));
 
write_exp_elt_opcode (OP_VAR_VALUE);
/* block_found is set by lookup_symbol. */
1985,9 → 2475,11
break;
 
case 82:
 
/* Line 1455 of yacc.c */
#line 661 "objc-exp.y"
{
struct type *type = yyvsp[-2].tval;
struct type *type = (yyvsp[(1) - (3)].tval);
if (TYPE_CODE (type) != TYPE_CODE_STRUCT
&& TYPE_CODE (type) != TYPE_CODE_UNION)
error ("`%s' is not defined as an aggregate type.",
1995,15 → 2487,17
 
write_exp_elt_opcode (OP_SCOPE);
write_exp_elt_type (type);
write_exp_string (yyvsp[0].sval);
write_exp_string ((yyvsp[(3) - (3)].sval));
write_exp_elt_opcode (OP_SCOPE);
}
break;
 
case 83:
 
/* Line 1455 of yacc.c */
#line 674 "objc-exp.y"
{
struct type *type = yyvsp[-3].tval;
struct type *type = (yyvsp[(1) - (4)].tval);
struct stoken tmp_token;
if (TYPE_CODE (type) != TYPE_CODE_STRUCT
&& TYPE_CODE (type) != TYPE_CODE_UNION)
2010,14 → 2504,14
error ("`%s' is not defined as an aggregate type.",
TYPE_NAME (type));
 
if (strcmp (type_name_no_tag (type), yyvsp[0].sval.ptr) != 0)
if (strcmp (type_name_no_tag (type), (yyvsp[(4) - (4)].sval).ptr) != 0)
error ("invalid destructor `%s::~%s'",
type_name_no_tag (type), yyvsp[0].sval.ptr);
type_name_no_tag (type), (yyvsp[(4) - (4)].sval).ptr);
 
tmp_token.ptr = (char*) alloca (yyvsp[0].sval.length + 2);
tmp_token.length = yyvsp[0].sval.length + 1;
tmp_token.ptr = (char*) alloca ((yyvsp[(4) - (4)].sval).length + 2);
tmp_token.length = (yyvsp[(4) - (4)].sval).length + 1;
tmp_token.ptr[0] = '~';
memcpy (tmp_token.ptr+1, yyvsp[0].sval.ptr, yyvsp[0].sval.length);
memcpy (tmp_token.ptr+1, (yyvsp[(4) - (4)].sval).ptr, (yyvsp[(4) - (4)].sval).length);
tmp_token.ptr[tmp_token.length] = 0;
write_exp_elt_opcode (OP_SCOPE);
write_exp_elt_type (type);
2027,9 → 2521,11
break;
 
case 85:
 
/* Line 1455 of yacc.c */
#line 700 "objc-exp.y"
{
char *name = copy_name (yyvsp[0].sval);
char *name = copy_name ((yyvsp[(2) - (2)].sval));
struct symbol *sym;
struct minimal_symbol *msymbol;
 
2056,8 → 2552,10
break;
 
case 86:
 
/* Line 1455 of yacc.c */
#line 728 "objc-exp.y"
{ struct symbol *sym = yyvsp[0].ssym.sym;
{ struct symbol *sym = (yyvsp[(1) - (1)].ssym).sym;
 
if (sym)
{
2077,7 → 2575,7
write_exp_elt_sym (sym);
write_exp_elt_opcode (OP_VAR_VALUE);
}
else if (yyvsp[0].ssym.is_a_field_of_this)
else if ((yyvsp[(1) - (1)].ssym).is_a_field_of_this)
{
/* C++/ObjC: it hangs off of `this'/'self'.
Must not inadvertently convert from a
2088,13 → 2586,13
write_exp_elt_opcode (OP_OBJC_SELF);
write_exp_elt_opcode (OP_OBJC_SELF);
write_exp_elt_opcode (STRUCTOP_PTR);
write_exp_string (yyvsp[0].ssym.stoken);
write_exp_string ((yyvsp[(1) - (1)].ssym).stoken);
write_exp_elt_opcode (STRUCTOP_PTR);
}
else
{
struct minimal_symbol *msymbol;
char *arg = copy_name (yyvsp[0].ssym.stoken);
char *arg = copy_name ((yyvsp[(1) - (1)].ssym).stoken);
 
msymbol =
lookup_minimal_symbol (arg, NULL, NULL);
2105,327 → 2603,430
error ("No symbol table is loaded. Use the \"file\" command.");
else
error ("No symbol \"%s\" in current context.",
copy_name (yyvsp[0].ssym.stoken));
copy_name ((yyvsp[(1) - (1)].ssym).stoken));
}
}
break;
 
case 90:
 
/* Line 1455 of yacc.c */
#line 791 "objc-exp.y"
{ yyval.tval = follow_types (yyvsp[-1].tval); }
{ (yyval.tval) = follow_types ((yyvsp[(1) - (2)].tval)); }
break;
 
case 91:
 
/* Line 1455 of yacc.c */
#line 793 "objc-exp.y"
{ yyval.tval = follow_types (yyvsp[-2].tval); }
{ (yyval.tval) = follow_types ((yyvsp[(1) - (3)].tval)); }
break;
 
case 92:
 
/* Line 1455 of yacc.c */
#line 795 "objc-exp.y"
{ yyval.tval = follow_types (yyvsp[-2].tval); }
{ (yyval.tval) = follow_types ((yyvsp[(1) - (3)].tval)); }
break;
 
case 93:
 
/* Line 1455 of yacc.c */
#line 799 "objc-exp.y"
{ push_type (tp_pointer); yyval.voidval = 0; }
{ push_type (tp_pointer); (yyval.voidval) = 0; }
break;
 
case 94:
 
/* Line 1455 of yacc.c */
#line 801 "objc-exp.y"
{ push_type (tp_pointer); yyval.voidval = yyvsp[0].voidval; }
{ push_type (tp_pointer); (yyval.voidval) = (yyvsp[(2) - (2)].voidval); }
break;
 
case 95:
 
/* Line 1455 of yacc.c */
#line 803 "objc-exp.y"
{ push_type (tp_reference); yyval.voidval = 0; }
{ push_type (tp_reference); (yyval.voidval) = 0; }
break;
 
case 96:
 
/* Line 1455 of yacc.c */
#line 805 "objc-exp.y"
{ push_type (tp_reference); yyval.voidval = yyvsp[0].voidval; }
{ push_type (tp_reference); (yyval.voidval) = (yyvsp[(2) - (2)].voidval); }
break;
 
case 98:
 
/* Line 1455 of yacc.c */
#line 810 "objc-exp.y"
{ yyval.voidval = yyvsp[-1].voidval; }
{ (yyval.voidval) = (yyvsp[(2) - (3)].voidval); }
break;
 
case 99:
 
/* Line 1455 of yacc.c */
#line 812 "objc-exp.y"
{
push_type_int (yyvsp[0].lval);
push_type_int ((yyvsp[(2) - (2)].lval));
push_type (tp_array);
}
break;
 
case 100:
 
/* Line 1455 of yacc.c */
#line 817 "objc-exp.y"
{
push_type_int (yyvsp[0].lval);
push_type_int ((yyvsp[(1) - (1)].lval));
push_type (tp_array);
yyval.voidval = 0;
(yyval.voidval) = 0;
}
break;
 
case 101:
 
/* Line 1455 of yacc.c */
#line 824 "objc-exp.y"
{ push_type (tp_function); }
break;
 
case 102:
 
/* Line 1455 of yacc.c */
#line 826 "objc-exp.y"
{ push_type (tp_function); }
break;
 
case 103:
 
/* Line 1455 of yacc.c */
#line 830 "objc-exp.y"
{ yyval.lval = -1; }
{ (yyval.lval) = -1; }
break;
 
case 104:
 
/* Line 1455 of yacc.c */
#line 832 "objc-exp.y"
{ yyval.lval = yyvsp[-1].typed_val_int.val; }
{ (yyval.lval) = (yyvsp[(2) - (3)].typed_val_int).val; }
break;
 
case 105:
 
/* Line 1455 of yacc.c */
#line 836 "objc-exp.y"
{ yyval.voidval = 0; }
{ (yyval.voidval) = 0; }
break;
 
case 106:
 
/* Line 1455 of yacc.c */
#line 838 "objc-exp.y"
{ xfree (yyvsp[-1].tvec); yyval.voidval = 0; }
{ xfree ((yyvsp[(2) - (3)].tvec)); (yyval.voidval) = 0; }
break;
 
case 108:
 
/* Line 1455 of yacc.c */
#line 854 "objc-exp.y"
{ yyval.tval = yyvsp[0].tsym.type; }
{ (yyval.tval) = (yyvsp[(1) - (1)].tsym).type; }
break;
 
case 109:
 
/* Line 1455 of yacc.c */
#line 856 "objc-exp.y"
{
if (yyvsp[0].class.type == NULL)
if ((yyvsp[(1) - (1)].class).type == NULL)
error ("No symbol \"%s\" in current context.",
copy_name(yyvsp[0].class.stoken));
copy_name((yyvsp[(1) - (1)].class).stoken));
else
yyval.tval = yyvsp[0].class.type;
(yyval.tval) = (yyvsp[(1) - (1)].class).type;
}
break;
 
case 110:
 
/* Line 1455 of yacc.c */
#line 864 "objc-exp.y"
{ yyval.tval = parse_type->builtin_int; }
{ (yyval.tval) = parse_type->builtin_int; }
break;
 
case 111:
 
/* Line 1455 of yacc.c */
#line 866 "objc-exp.y"
{ yyval.tval = parse_type->builtin_long; }
{ (yyval.tval) = parse_type->builtin_long; }
break;
 
case 112:
 
/* Line 1455 of yacc.c */
#line 868 "objc-exp.y"
{ yyval.tval = parse_type->builtin_short; }
{ (yyval.tval) = parse_type->builtin_short; }
break;
 
case 113:
 
/* Line 1455 of yacc.c */
#line 870 "objc-exp.y"
{ yyval.tval = parse_type->builtin_long; }
{ (yyval.tval) = parse_type->builtin_long; }
break;
 
case 114:
 
/* Line 1455 of yacc.c */
#line 872 "objc-exp.y"
{ yyval.tval = parse_type->builtin_unsigned_long; }
{ (yyval.tval) = parse_type->builtin_unsigned_long; }
break;
 
case 115:
 
/* Line 1455 of yacc.c */
#line 874 "objc-exp.y"
{ yyval.tval = parse_type->builtin_long_long; }
{ (yyval.tval) = parse_type->builtin_long_long; }
break;
 
case 116:
 
/* Line 1455 of yacc.c */
#line 876 "objc-exp.y"
{ yyval.tval = parse_type->builtin_long_long; }
{ (yyval.tval) = parse_type->builtin_long_long; }
break;
 
case 117:
 
/* Line 1455 of yacc.c */
#line 878 "objc-exp.y"
{ yyval.tval = parse_type->builtin_unsigned_long_long; }
{ (yyval.tval) = parse_type->builtin_unsigned_long_long; }
break;
 
case 118:
 
/* Line 1455 of yacc.c */
#line 880 "objc-exp.y"
{ yyval.tval = parse_type->builtin_unsigned_long_long; }
{ (yyval.tval) = parse_type->builtin_unsigned_long_long; }
break;
 
case 119:
 
/* Line 1455 of yacc.c */
#line 882 "objc-exp.y"
{ yyval.tval = parse_type->builtin_short; }
{ (yyval.tval) = parse_type->builtin_short; }
break;
 
case 120:
 
/* Line 1455 of yacc.c */
#line 884 "objc-exp.y"
{ yyval.tval = parse_type->builtin_unsigned_short; }
{ (yyval.tval) = parse_type->builtin_unsigned_short; }
break;
 
case 121:
 
/* Line 1455 of yacc.c */
#line 886 "objc-exp.y"
{ yyval.tval = parse_type->builtin_double; }
{ (yyval.tval) = parse_type->builtin_double; }
break;
 
case 122:
 
/* Line 1455 of yacc.c */
#line 888 "objc-exp.y"
{ yyval.tval = parse_type->builtin_long_double; }
{ (yyval.tval) = parse_type->builtin_long_double; }
break;
 
case 123:
 
/* Line 1455 of yacc.c */
#line 890 "objc-exp.y"
{ yyval.tval = lookup_struct (copy_name (yyvsp[0].sval),
{ (yyval.tval) = lookup_struct (copy_name ((yyvsp[(2) - (2)].sval)),
expression_context_block); }
break;
 
case 124:
 
/* Line 1455 of yacc.c */
#line 893 "objc-exp.y"
{ yyval.tval = lookup_struct (copy_name (yyvsp[0].sval),
{ (yyval.tval) = lookup_struct (copy_name ((yyvsp[(2) - (2)].sval)),
expression_context_block); }
break;
 
case 125:
 
/* Line 1455 of yacc.c */
#line 896 "objc-exp.y"
{ yyval.tval = lookup_union (copy_name (yyvsp[0].sval),
{ (yyval.tval) = lookup_union (copy_name ((yyvsp[(2) - (2)].sval)),
expression_context_block); }
break;
 
case 126:
 
/* Line 1455 of yacc.c */
#line 899 "objc-exp.y"
{ yyval.tval = lookup_enum (copy_name (yyvsp[0].sval),
{ (yyval.tval) = lookup_enum (copy_name ((yyvsp[(2) - (2)].sval)),
expression_context_block); }
break;
 
case 127:
 
/* Line 1455 of yacc.c */
#line 902 "objc-exp.y"
{ yyval.tval = lookup_unsigned_typename (parse_language,
{ (yyval.tval) = lookup_unsigned_typename (parse_language,
parse_gdbarch,
TYPE_NAME(yyvsp[0].tsym.type)); }
TYPE_NAME((yyvsp[(2) - (2)].tsym).type)); }
break;
 
case 128:
 
/* Line 1455 of yacc.c */
#line 906 "objc-exp.y"
{ yyval.tval = parse_type->builtin_unsigned_int; }
{ (yyval.tval) = parse_type->builtin_unsigned_int; }
break;
 
case 129:
 
/* Line 1455 of yacc.c */
#line 908 "objc-exp.y"
{ yyval.tval = lookup_signed_typename (parse_language,
{ (yyval.tval) = lookup_signed_typename (parse_language,
parse_gdbarch,
TYPE_NAME(yyvsp[0].tsym.type)); }
TYPE_NAME((yyvsp[(2) - (2)].tsym).type)); }
break;
 
case 130:
 
/* Line 1455 of yacc.c */
#line 912 "objc-exp.y"
{ yyval.tval = parse_type->builtin_int; }
{ (yyval.tval) = parse_type->builtin_int; }
break;
 
case 131:
 
/* Line 1455 of yacc.c */
#line 914 "objc-exp.y"
{ yyval.tval = lookup_template_type(copy_name(yyvsp[-3].sval), yyvsp[-1].tval,
{ (yyval.tval) = lookup_template_type(copy_name((yyvsp[(2) - (5)].sval)), (yyvsp[(4) - (5)].tval),
expression_context_block);
}
break;
 
case 132:
 
/* Line 1455 of yacc.c */
#line 920 "objc-exp.y"
{ yyval.tval = yyvsp[0].tval; }
{ (yyval.tval) = (yyvsp[(2) - (2)].tval); }
break;
 
case 133:
 
/* Line 1455 of yacc.c */
#line 921 "objc-exp.y"
{ yyval.tval = yyvsp[0].tval; }
{ (yyval.tval) = (yyvsp[(2) - (2)].tval); }
break;
 
case 135:
 
/* Line 1455 of yacc.c */
#line 926 "objc-exp.y"
{
yyval.tsym.stoken.ptr = "int";
yyval.tsym.stoken.length = 3;
yyval.tsym.type = parse_type->builtin_int;
(yyval.tsym).stoken.ptr = "int";
(yyval.tsym).stoken.length = 3;
(yyval.tsym).type = parse_type->builtin_int;
}
break;
 
case 136:
 
/* Line 1455 of yacc.c */
#line 932 "objc-exp.y"
{
yyval.tsym.stoken.ptr = "long";
yyval.tsym.stoken.length = 4;
yyval.tsym.type = parse_type->builtin_long;
(yyval.tsym).stoken.ptr = "long";
(yyval.tsym).stoken.length = 4;
(yyval.tsym).type = parse_type->builtin_long;
}
break;
 
case 137:
 
/* Line 1455 of yacc.c */
#line 938 "objc-exp.y"
{
yyval.tsym.stoken.ptr = "short";
yyval.tsym.stoken.length = 5;
yyval.tsym.type = parse_type->builtin_short;
(yyval.tsym).stoken.ptr = "short";
(yyval.tsym).stoken.length = 5;
(yyval.tsym).type = parse_type->builtin_short;
}
break;
 
case 138:
 
/* Line 1455 of yacc.c */
#line 947 "objc-exp.y"
{ yyval.tvec = (struct type **) xmalloc (sizeof (struct type *) * 2);
yyval.ivec[0] = 1; /* Number of types in vector. */
yyval.tvec[1] = yyvsp[0].tval;
{ (yyval.tvec) = (struct type **) xmalloc (sizeof (struct type *) * 2);
(yyval.ivec)[0] = 1; /* Number of types in vector. */
(yyval.tvec)[1] = (yyvsp[(1) - (1)].tval);
}
break;
 
case 139:
 
/* Line 1455 of yacc.c */
#line 952 "objc-exp.y"
{ int len = sizeof (struct type *) * (++(yyvsp[-2].ivec[0]) + 1);
yyval.tvec = (struct type **) xrealloc ((char *) yyvsp[-2].tvec, len);
yyval.tvec[yyval.ivec[0]] = yyvsp[0].tval;
{ int len = sizeof (struct type *) * (++((yyvsp[(1) - (3)].ivec)[0]) + 1);
(yyval.tvec) = (struct type **) xrealloc ((char *) (yyvsp[(1) - (3)].tvec), len);
(yyval.tvec)[(yyval.ivec)[0]] = (yyvsp[(3) - (3)].tval);
}
break;
 
case 140:
 
/* Line 1455 of yacc.c */
#line 958 "objc-exp.y"
{ yyval.sval = yyvsp[0].ssym.stoken; }
{ (yyval.sval) = (yyvsp[(1) - (1)].ssym).stoken; }
break;
 
case 141:
 
/* Line 1455 of yacc.c */
#line 959 "objc-exp.y"
{ yyval.sval = yyvsp[0].ssym.stoken; }
{ (yyval.sval) = (yyvsp[(1) - (1)].ssym).stoken; }
break;
 
case 142:
 
/* Line 1455 of yacc.c */
#line 960 "objc-exp.y"
{ yyval.sval = yyvsp[0].tsym.stoken; }
{ (yyval.sval) = (yyvsp[(1) - (1)].tsym).stoken; }
break;
 
case 143:
 
/* Line 1455 of yacc.c */
#line 961 "objc-exp.y"
{ yyval.sval = yyvsp[0].class.stoken; }
{ (yyval.sval) = (yyvsp[(1) - (1)].class).stoken; }
break;
 
case 144:
 
/* Line 1455 of yacc.c */
#line 962 "objc-exp.y"
{ yyval.sval = yyvsp[0].ssym.stoken; }
{ (yyval.sval) = (yyvsp[(1) - (1)].ssym).stoken; }
break;
 
 
 
/* Line 1455 of yacc.c */
#line 3021 "objc-exp.c.tmp"
default: break;
}
YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
 
/* Line 1000 of yacc.c. */
#line 2419 "objc-exp.c.tmp"
yyvsp -= yylen;
yyssp -= yylen;
 
 
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. */
2449,66 → 3050,41
if (!yyerrstatus)
{
++yynerrs;
#if YYERROR_VERBOSE
yyn = yypact[yystate];
 
if (YYPACT_NINF < yyn && yyn < YYLAST)
{
YYSIZE_T yysize = 0;
int yytype = YYTRANSLATE (yychar);
const char* yyprefix;
char *yymsg;
int yyx;
 
/* 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;
int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
int yycount = 0;
 
yyprefix = ", expecting ";
for (yyx = yyxbegin; yyx < yyxend; ++yyx)
if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
#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
{
yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]);
yycount += 1;
if (yycount == 5)
{
yysize = 0;
break;
}
yymsg = yymsgbuf;
yymsg_alloc = sizeof yymsgbuf;
}
yysize += (sizeof ("syntax error, unexpected ")
+ yystrlen (yytname[yytype]));
yymsg = (char *) YYSTACK_ALLOC (yysize);
if (yymsg != 0)
{
char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
yyp = yystpcpy (yyp, yytname[yytype]);
}
 
if (yycount < 5)
{
yyprefix = ", expecting ";
for (yyx = yyxbegin; yyx < yyxend; ++yyx)
if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
{
yyp = yystpcpy (yyp, yyprefix);
yyp = yystpcpy (yyp, yytname[yyx]);
yyprefix = " or ";
}
}
yyerror (yymsg);
YYSTACK_FREE (yymsg);
}
else
yyerror ("syntax error; also virtual memory exhausted");
}
else
#endif /* YYERROR_VERBOSE */
yyerror ("syntax error");
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
}
 
 
2519,25 → 3095,16
error, discard it. */
 
if (yychar <= YYEOF)
{
/* If at end of input, pop the error token,
then the rest of the stack, then return failure. */
{
/* Return failure if at end of input. */
if (yychar == YYEOF)
for (;;)
{
YYPOPSTACK;
if (yyssp == yyss)
YYABORT;
YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
yydestruct (yystos[*yyssp], yyvsp);
}
}
YYABORT;
}
else
{
YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);
yydestruct (yytoken, &yylval);
yydestruct ("Error: discarding",
yytoken, &yylval);
yychar = YYEMPTY;
 
}
}
 
2551,15 → 3118,17
`---------------------------------------------------*/
yyerrorlab:
 
#ifdef __GNUC__
/* Pacify GCC when the user code never invokes YYERROR and the label
yyerrorlab therefore never appears in user code. */
if (0)
/* 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;
#endif
 
yyvsp -= yylen;
yyssp -= yylen;
/* 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;
 
2588,21 → 3157,20
if (yyssp == yyss)
YYABORT;
 
YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
yydestruct (yystos[yystate], yyvsp);
YYPOPSTACK;
 
yydestruct ("Error: popping",
yystos[yystate], yyvsp);
YYPOPSTACK (1);
yystate = *yyssp;
YY_STACK_PRINT (yyss, yyssp);
}
 
if (yyn == YYFINAL)
YYACCEPT;
*++yyvsp = yylval;
 
YYDPRINTF ((stderr, "Shifting error token, "));
 
*++yyvsp = yylval;
/* Shift the error token. */
YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
 
 
yystate = yyn;
goto yynewstate;
 
2621,25 → 3189,45
yyresult = 1;
goto yyreturn;
 
#ifndef yyoverflow
/*----------------------------------------------.
| yyoverflowlab -- parser overflow comes here. |
`----------------------------------------------*/
yyoverflowlab:
yyerror ("parser stack overflow");
#if !defined(yyoverflow) || YYERROR_VERBOSE
/*-------------------------------------------------.
| yyexhaustedlab -- memory exhaustion comes here. |
`-------------------------------------------------*/
yyexhaustedlab:
yyerror (YY_("memory exhausted"));
yyresult = 2;
/* Fall through. */
#endif
 
yyreturn:
if (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
return yyresult;
#if YYERROR_VERBOSE
if (yymsg != yymsgbuf)
YYSTACK_FREE (yymsg);
#endif
/* Make sure YYID is used. */
return YYID (yyresult);
}
 
 
 
/* Line 1675 of yacc.c */
#line 976 "objc-exp.y"
 
 
3464,4 → 4052,3
lexptr);
}
 
 
/gnu-src/gdb-7.2/gdb/p-exp.c
1,30 → 1,39
/* A Bison parser, made by GNU Bison 1.875c. */
 
/* Skeleton parser for Yacc-like parsing with Bison,
Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
/* A Bison parser, made by GNU Bison 2.4.1. */
 
This program is free software; you can redistribute it and/or modify
/* 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.
 
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., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
along with this program. If not, see <http://www.gnu.org/licenses/>. */
 
/* As a special exception, when this file is copied by Bison into a
Bison output file, you may use that output file without restriction.
This special exception was added by the Free Software Foundation
in version 1.24 of Bison. */
/* 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. */
 
/* Written by Richard Stallman by simplifying the original so called
``semantic'' parser. */
/* 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
36,6 → 45,9
/* Identify Bison output. */
#define YYBISON 1
 
/* Bison version. */
#define YYBISON_VERSION "2.4.1"
 
/* Skeleton name. */
#define YYSKELETON_NAME "yacc.c"
 
42,92 → 54,20
/* Pure parsers. */
#define YYPURE 0
 
/* Push parsers. */
#define YYPUSH 0
 
/* Pull parsers. */
#define YYPULL 1
 
/* 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 {
INT = 258,
FLOAT = 259,
STRING = 260,
FIELDNAME = 261,
NAME = 262,
TYPENAME = 263,
NAME_OR_INT = 264,
STRUCT = 265,
CLASS = 266,
SIZEOF = 267,
COLONCOLON = 268,
ERROR = 269,
VARIABLE = 270,
THIS = 271,
TRUEKEYWORD = 272,
FALSEKEYWORD = 273,
ABOVE_COMMA = 274,
ASSIGN = 275,
NOT = 276,
OR = 277,
XOR = 278,
ANDAND = 279,
NOTEQUAL = 280,
GEQ = 281,
LEQ = 282,
MOD = 283,
DIV = 284,
RSH = 285,
LSH = 286,
DECREMENT = 287,
INCREMENT = 288,
UNARY = 289,
ARROW = 290,
BLOCKNAME = 291
};
#endif
#define INT 258
#define FLOAT 259
#define STRING 260
#define FIELDNAME 261
#define NAME 262
#define TYPENAME 263
#define NAME_OR_INT 264
#define STRUCT 265
#define CLASS 266
#define SIZEOF 267
#define COLONCOLON 268
#define ERROR 269
#define VARIABLE 270
#define THIS 271
#define TRUEKEYWORD 272
#define FALSEKEYWORD 273
#define ABOVE_COMMA 274
#define ASSIGN 275
#define NOT 276
#define OR 277
#define XOR 278
#define ANDAND 279
#define NOTEQUAL 280
#define GEQ 281
#define LEQ 282
#define MOD 283
#define DIV 284
#define RSH 285
#define LSH 286
#define DECREMENT 287
#define INCREMENT 288
#define UNARY 289
#define ARROW 290
#define BLOCKNAME 291
/* Copy the first part of user declarations. */
 
 
 
 
/* Copy the first part of user declarations. */
/* Line 189 of yacc.c */
#line 45 "p-exp.y"
 
 
210,6 → 150,9
static char * uptok (char *, int);
 
 
/* Line 189 of yacc.c */
#line 155 "p-exp.c.tmp"
 
/* Enabling traces. */
#ifndef YYDEBUG
# define YYDEBUG 0
223,9 → 166,100
# define YYERROR_VERBOSE 0
#endif
 
#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
/* Enabling the token table. */
#ifndef YYTOKEN_TABLE
# define YYTOKEN_TABLE 0
#endif
 
 
/* Tokens. */
#ifndef YYTOKENTYPE
# define YYTOKENTYPE
/* Put the tokens into the symbol table, so that GDB and other debuggers
know about them. */
enum yytokentype {
INT = 258,
FLOAT = 259,
STRING = 260,
FIELDNAME = 261,
NAME = 262,
TYPENAME = 263,
NAME_OR_INT = 264,
STRUCT = 265,
CLASS = 266,
SIZEOF = 267,
COLONCOLON = 268,
ERROR = 269,
VARIABLE = 270,
THIS = 271,
TRUEKEYWORD = 272,
FALSEKEYWORD = 273,
ABOVE_COMMA = 274,
ASSIGN = 275,
NOT = 276,
OR = 277,
XOR = 278,
ANDAND = 279,
NOTEQUAL = 280,
GEQ = 281,
LEQ = 282,
MOD = 283,
DIV = 284,
RSH = 285,
LSH = 286,
DECREMENT = 287,
INCREMENT = 288,
UNARY = 289,
ARROW = 290,
BLOCKNAME = 291
};
#endif
/* Tokens. */
#define INT 258
#define FLOAT 259
#define STRING 260
#define FIELDNAME 261
#define NAME 262
#define TYPENAME 263
#define NAME_OR_INT 264
#define STRUCT 265
#define CLASS 266
#define SIZEOF 267
#define COLONCOLON 268
#define ERROR 269
#define VARIABLE 270
#define THIS 271
#define TRUEKEYWORD 272
#define FALSEKEYWORD 273
#define ABOVE_COMMA 274
#define ASSIGN 275
#define NOT 276
#define OR 277
#define XOR 278
#define ANDAND 279
#define NOTEQUAL 280
#define GEQ 281
#define LEQ 282
#define MOD 283
#define DIV 284
#define RSH 285
#define LSH 286
#define DECREMENT 287
#define INCREMENT 288
#define UNARY 289
#define ARROW 290
#define BLOCKNAME 291
 
 
 
 
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
typedef union YYSTYPE
{
 
/* Line 214 of yacc.c */
#line 131 "p-exp.y"
typedef union YYSTYPE {
 
LONGEST lval;
struct {
LONGEST val;
247,17 → 281,21
 
struct type **tvec;
int *ivec;
} YYSTYPE;
/* Line 191 of yacc.c. */
#line 253 "p-exp.c.tmp"
 
 
/* Line 214 of yacc.c */
#line 289 "p-exp.c.tmp"
} YYSTYPE;
# define YYSTYPE_IS_TRIVIAL 1
# 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. */
 
/* Copy the second part of user declarations. */
/* Line 264 of yacc.c */
#line 155 "p-exp.y"
 
/* YYSTYPE gets defined by %union */
271,58 → 309,172
static int search_field;
 
 
/* Line 214 of yacc.c. */
#line 276 "p-exp.c.tmp"
/* Line 264 of yacc.c */
#line 314 "p-exp.c.tmp"
 
#if ! defined (yyoverflow) || YYERROR_VERBOSE
#ifdef short
# undef short
#endif
 
# ifndef YYFREE
# define YYFREE xfree
#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
# ifndef YYMALLOC
# define YYMALLOC xmalloc
#endif
 
#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
 
#ifndef YY_
# if 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 yyi)
#else
static int
YYID (yyi)
int yyi;
#endif
{
return yyi;
}
#endif
 
#if ! defined yyoverflow || YYERROR_VERBOSE
 
/* The parser invokes alloca or xmalloc; define the necessary symbols. */
 
# ifdef YYSTACK_USE_ALLOCA
# if YYSTACK_USE_ALLOCA
# define YYSTACK_ALLOC alloca
# endif
# else
# if defined (alloca) || defined (_ALLOCA_H)
# define YYSTACK_ALLOC alloca
# else
# 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
# 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 (0)
/* 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
# if defined (__STDC__) || defined (__cplusplus)
# 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 xmalloc) \
&& (defined YYFREE || defined xfree)))
# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
# define YYSIZE_T size_t
# ifndef _STDLIB_H
# define _STDLIB_H 1
# endif
# endif
# define YYSTACK_ALLOC YYMALLOC
# define YYSTACK_FREE YYFREE
# ifndef YYMALLOC
# define YYMALLOC xmalloc
# if ! defined xmalloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
void *xmalloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
# endif
# endif
# ifndef YYFREE
# define YYFREE xfree
# if ! defined xfree && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
void xfree (void *); /* INFRINGES ON USER NAME SPACE */
# endif
# endif
# endif
#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
 
 
#if (! defined (yyoverflow) \
&& (! defined (__cplusplus) \
|| (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
#if (! defined yyoverflow \
&& (! defined __cplusplus \
|| (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
 
/* A type that is properly aligned for any stack member. */
union yyalloc
{
short yyss;
YYSTYPE yyvs;
};
yytype_int16 yyss_alloc;
YYSTYPE yyvs_alloc;
};
 
/* The size of the maximum gap between one aligned stack and the next. */
# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
330,13 → 482,13
/* The size of an array large to enough to hold all stacks, each with
N elements. */
# define YYSTACK_BYTES(N) \
((N) * (sizeof (short) + sizeof (YYSTYPE)) \
((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__
# if defined __GNUC__ && 1 < __GNUC__
# define YYCOPY(To, From, Count) \
__builtin_memcpy (To, From, (Count) * sizeof (*(From)))
# else
343,11 → 495,11
# define YYCOPY(To, From, Count) \
do \
{ \
register YYSIZE_T yyi; \
YYSIZE_T yyi; \
for (yyi = 0; yyi < (Count); yyi++) \
(To)[yyi] = (From)[yyi]; \
} \
while (0)
while (YYID (0))
# endif
# endif
 
356,37 → 508,31
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) \
# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
do \
{ \
YYSIZE_T yynewbytes; \
YYCOPY (&yyptr->Stack, Stack, yysize); \
Stack = &yyptr->Stack; \
YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
Stack = &yyptr->Stack_alloc; \
yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
yyptr += yynewbytes / sizeof (*yyptr); \
} \
while (0)
while (YYID (0))
 
#endif
 
#if defined (__STDC__) || defined (__cplusplus)
typedef signed char yysigned_char;
#else
typedef short yysigned_char;
#endif
 
/* YYFINAL -- State number of the termination state. */
/* YYFINAL -- State number of the termination state. */
#define YYFINAL 3
/* YYLAST -- Last index in YYTABLE. */
#define YYLAST 387
 
/* YYNTOKENS -- Number of terminals. */
/* YYNTOKENS -- Number of terminals. */
#define YYNTOKENS 52
/* YYNNTS -- Number of nonterminals. */
/* YYNNTS -- Number of nonterminals. */
#define YYNNTS 20
/* YYNRULES -- Number of rules. */
/* YYNRULES -- Number of rules. */
#define YYNRULES 74
/* YYNRULES -- Number of states. */
/* YYNRULES -- Number of states. */
#define YYNSTATES 123
 
/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
393,11 → 539,11
#define YYUNDEFTOK 2
#define YYMAXUTOK 291
 
#define YYTRANSLATE(YYX) \
#define YYTRANSLATE(YYX) \
((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
 
/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
static const unsigned char yytranslate[] =
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,
434,7 → 580,7
#if YYDEBUG
/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
YYRHS. */
static const unsigned char yyprhs[] =
static const yytype_uint8 yyprhs[] =
{
0, 0, 3, 4, 7, 9, 11, 13, 15, 19,
22, 25, 28, 31, 36, 41, 42, 47, 48, 54,
446,8 → 592,8
217, 219, 221, 223, 225
};
 
/* YYRHS -- A `-1'-separated list of the rules' RHS. */
static const yysigned_char yyrhs[] =
/* YYRHS -- A `-1'-separated list of the rules' RHS. */
static const yytype_int8 yyrhs[] =
{
53, 0, -1, -1, 54, 55, -1, 57, -1, 56,
-1, 68, -1, 58, -1, 57, 19, 58, -1, 58,
475,7 → 621,7
};
 
/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
static const unsigned short yyrline[] =
static const yytype_uint16 yyrline[] =
{
0, 235, 235, 235, 243, 244, 247, 254, 255, 260,
266, 272, 276, 280, 284, 288, 288, 303, 301, 331,
488,9 → 634,9
};
#endif
 
#if YYDEBUG || YYERROR_VERBOSE
/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
First, the terminals, then, starting at YYNTOKENS, nonterminals. */
#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", "INT", "FLOAT", "STRING", "FIELDNAME",
500,9 → 646,10
"NOTEQUAL", "'<'", "'>'", "GEQ", "LEQ", "MOD", "DIV", "RSH", "LSH",
"'@'", "'+'", "'-'", "'*'", "'/'", "DECREMENT", "INCREMENT", "UNARY",
"'.'", "'['", "'('", "ARROW", "'^'", "BLOCKNAME", "')'", "']'",
"$accept", "start", "@1", "normal_start", "type_exp", "exp1", "exp",
"@2", "@3", "@4", "arglist", "@5", "block", "variable", "qualified_name",
"ptype", "type", "typebase", "name", "name_not_typename", 0
"$accept", "start", "$@1", "normal_start", "type_exp", "exp1", "exp",
"$@2", "$@3", "$@4", "arglist", "$@5", "block", "variable",
"qualified_name", "ptype", "type", "typebase", "name",
"name_not_typename", 0
};
#endif
 
509,7 → 656,7
# ifdef YYPRINT
/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
token YYLEX-NUM. */
static const unsigned short yytoknum[] =
static const yytype_uint16 yytoknum[] =
{
0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
265, 266, 267, 268, 269, 270, 271, 272, 273, 44,
521,7 → 668,7
# endif
 
/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
static const unsigned char yyr1[] =
static const yytype_uint8 yyr1[] =
{
0, 52, 54, 53, 55, 55, 56, 57, 57, 58,
58, 58, 58, 58, 58, 59, 58, 60, 58, 61,
534,7 → 681,7
};
 
/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
static const unsigned char yyr2[] =
static const yytype_uint8 yyr2[] =
{
0, 2, 0, 2, 1, 1, 1, 1, 3, 2,
2, 2, 2, 4, 4, 0, 4, 0, 5, 0,
549,7 → 696,7
/* 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 unsigned char yydefact[] =
static const yytype_uint8 yydefact[] =
{
2, 0, 0, 1, 47, 49, 54, 73, 66, 48,
0, 0, 0, 0, 51, 55, 45, 46, 0, 0,
566,8 → 713,8
0, 20, 23
};
 
/* YYDEFGOTO[NTERM-NUM]. */
static const yysigned_char yydefgoto[] =
/* YYDEFGOTO[NTERM-NUM]. */
static const yytype_int8 yydefgoto[] =
{
-1, 1, 2, 26, 27, 28, 29, 103, 104, 105,
117, 102, 30, 31, 32, 33, 46, 35, 41, 36
576,7 → 723,7
/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
STATE-NUM. */
#define YYPACT_NINF -39
static const short yypact[] =
static const yytype_int16 yypact[] =
{
-39, 9, 88, -39, -39, -39, -39, -39, -39, -39,
4, 4, -31, 4, -39, -39, -39, -39, 88, 88,
594,7 → 741,7
};
 
/* YYPGOTO[NTERM-NUM]. */
static const yysigned_char yypgoto[] =
static const yytype_int8 yypgoto[] =
{
-39, -39, -39, -39, -39, -19, -18, -39, -39, -39,
-39, -39, -39, -39, -39, -39, 12, 38, -8, -39
605,7 → 752,7
number is the opposite. If zero, do what YYDEFACT says.
If YYTABLE_NINF, syntax error. */
#define YYTABLE_NINF -58
static const yysigned_char yytable[] =
static const yytype_int8 yytable[] =
{
45, 47, 48, 42, 51, 44, 72, 73, 74, 3,
75, 37, 38, 39, 34, 43, 8, 77, 10, 11,
648,7 → 795,7
0, 0, 0, 72, 73, 74, 0, 75
};
 
static const yysigned_char yycheck[] =
static const yytype_int8 yycheck[] =
{
18, 19, 20, 11, 23, 13, 44, 45, 46, 0,
48, 7, 8, 9, 2, 46, 8, 46, 10, 11,
693,7 → 840,7
 
/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
symbol of state STATE-NUM. */
static const unsigned char yystos[] =
static const yytype_uint8 yystos[] =
{
0, 53, 54, 0, 3, 4, 5, 7, 8, 9,
10, 11, 12, 13, 15, 16, 17, 18, 22, 36,
710,22 → 857,6
19, 50, 58
};
 
#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
# define YYSIZE_T __SIZE_TYPE__
#endif
#if ! defined (YYSIZE_T) && defined (size_t)
# define YYSIZE_T size_t
#endif
#if ! defined (YYSIZE_T)
# if defined (__STDC__) || defined (__cplusplus)
# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
# define YYSIZE_T size_t
# endif
#endif
#if ! defined (YYSIZE_T)
# define YYSIZE_T unsigned int
#endif
 
#define yyerrok (yyerrstatus = 0)
#define yyclearin (yychar = YYEMPTY)
#define YYEMPTY (-2)
751,30 → 882,63
yychar = (Token); \
yylval = (Value); \
yytoken = YYTRANSLATE (yychar); \
YYPOPSTACK; \
YYPOPSTACK (1); \
goto yybackup; \
} \
else \
{ \
yyerror ("syntax error: cannot back up");\
{ \
yyerror (YY_("syntax error: cannot back up")); \
YYERROR; \
} \
while (0)
while (YYID (0))
 
 
#define YYTERROR 1
#define YYERRCODE 256
 
/* YYLLOC_DEFAULT -- Compute the default location (before the actions
are run). */
 
/* 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) \
((Current).first_line = (Rhs)[1].first_line, \
(Current).first_column = (Rhs)[1].first_column, \
(Current).last_line = (Rhs)[N].last_line, \
(Current).last_column = (Rhs)[N].last_column)
# 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 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
795,43 → 959,100
do { \
if (yydebug) \
YYFPRINTF Args; \
} while (0)
} while (YYID (0))
 
# define YYDSYMPRINT(Args) \
do { \
if (yydebug) \
yysymprint Args; \
} while (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))
 
# define YYDSYMPRINTF(Title, Token, Value, Location) \
do { \
if (yydebug) \
{ \
YYFPRINTF (stderr, "%s ", Title); \
yysymprint (stderr, \
Token, Value); \
YYFPRINTF (stderr, "\n"); \
} \
} while (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 (__cplusplus)
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
static void
yy_stack_print (short *bottom, short *top)
yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
#else
static void
yy_stack_print (bottom, top)
short *bottom;
short *top;
yy_stack_print (yybottom, yytop)
yytype_int16 *yybottom;
yytype_int16 *yytop;
#endif
{
YYFPRINTF (stderr, "Stack now");
for (/* Nothing. */; bottom <= top; ++bottom)
YYFPRINTF (stderr, " %d", *bottom);
for (; yybottom <= yytop; yybottom++)
{
int yybot = *yybottom;
YYFPRINTF (stderr, " %d", yybot);
}
YYFPRINTF (stderr, "\n");
}
 
839,7 → 1060,7
do { \
if (yydebug) \
yy_stack_print ((Bottom), (Top)); \
} while (0)
} while (YYID (0))
 
 
/*------------------------------------------------.
846,30 → 1067,38
| Report that the YYRULE is going to be reduced. |
`------------------------------------------------*/
 
#if defined (__STDC__) || defined (__cplusplus)
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
static void
yy_reduce_print (int yyrule)
yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
#else
static void
yy_reduce_print (yyrule)
yy_reduce_print (yyvsp, yyrule)
YYSTYPE *yyvsp;
int yyrule;
#endif
{
int yynrhs = yyr2[yyrule];
int yyi;
unsigned int yylno = yyrline[yyrule];
YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
yyrule - 1, yylno);
/* Print the symbols being reduced, and their result. */
for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);
YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);
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++)
{
YYFPRINTF (stderr, " $%d = ", yyi + 1);
yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
&(yyvsp[(yyi + 1) - (yynrhs)])
);
YYFPRINTF (stderr, "\n");
}
}
 
# define YY_REDUCE_PRINT(Rule) \
do { \
if (yydebug) \
yy_reduce_print (Rule); \
} while (0)
yy_reduce_print (yyvsp, Rule); \
} while (YYID (0))
 
/* Nonzero means print parse trace. It is left uninitialized so that
multiple parsers can coexist. */
876,8 → 1105,7
int yydebug;
#else /* !YYDEBUG */
# define YYDPRINTF(Args)
# define YYDSYMPRINT(Args)
# define YYDSYMPRINTF(Title, Token, Value, Location)
# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
# define YY_STACK_PRINT(Bottom, Top)
# define YY_REDUCE_PRINT(Rule)
#endif /* !YYDEBUG */
892,13 → 1120,9
if the built-in stack extension method is used).
 
Do not make this value too large; the results are undefined if
SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
evaluated with infinite-precision integer arithmetic. */
 
#if defined (YYMAXDEPTH) && YYMAXDEPTH == 0
# undef YYMAXDEPTH
#endif
 
#ifndef YYMAXDEPTH
# define YYMAXDEPTH 10000
#endif
908,45 → 1132,47
#if YYERROR_VERBOSE
 
# ifndef yystrlen
# if defined (__GLIBC__) && defined (_STRING_H)
# 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
# if defined (__STDC__) || defined (__cplusplus)
yystrlen (const char *yystr)
# else
#else
static YYSIZE_T
yystrlen (yystr)
const char *yystr;
# endif
const char *yystr;
#endif
{
register const char *yys = yystr;
 
while (*yys++ != '\0')
YYSIZE_T yylen;
for (yylen = 0; yystr[yylen]; yylen++)
continue;
 
return yys - yystr - 1;
return yylen;
}
# endif
# endif
 
# ifndef yystpcpy
# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
# 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 *
# if defined (__STDC__) || defined (__cplusplus)
yystpcpy (char *yydest, const char *yysrc)
# else
#else
static char *
yystpcpy (yydest, yysrc)
char *yydest;
const char *yysrc;
# endif
char *yydest;
const char *yysrc;
#endif
{
register char *yyd = yydest;
register const char *yys = yysrc;
char *yyd = yydest;
const char *yys = yysrc;
 
while ((*yyd++ = *yys++) != '\0')
continue;
956,84 → 1182,204
# endif
# endif
 
#endif /* !YYERROR_VERBOSE */
# 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;
 
#if YYDEBUG
/*--------------------------------.
| Print this symbol on YYOUTPUT. |
`--------------------------------*/
case '\\':
if (*++yyp != '\\')
goto do_not_strip_quotes;
/* Fall through. */
default:
if (yyres)
yyres[yyn] = *yyp;
yyn++;
break;
 
#if defined (__STDC__) || defined (__cplusplus)
static void
yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
#else
static void
yysymprint (yyoutput, yytype, yyvaluep)
FILE *yyoutput;
int yytype;
YYSTYPE *yyvaluep;
#endif
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)
{
/* Pacify ``unused variable'' warnings. */
(void) yyvaluep;
int yyn = yypact[yystate];
 
if (yytype < YYNTOKENS)
if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
return 0;
else
{
YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
# ifdef YYPRINT
YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
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
}
else
YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
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;
 
switch (yytype)
{
default:
break;
/* 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;
}
YYFPRINTF (yyoutput, ")");
}
#endif /* YYERROR_VERBOSE */
 
#endif /* ! YYDEBUG */
/*-----------------------------------------------.
| Release the memory associated to this symbol. |
`-----------------------------------------------*/
 
#if defined (__STDC__) || defined (__cplusplus)
/*ARGSUSED*/
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
static void
yydestruct (int yytype, YYSTYPE *yyvaluep)
yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
#else
static void
yydestruct (yytype, yyvaluep)
yydestruct (yymsg, yytype, yyvaluep)
const char *yymsg;
int yytype;
YYSTYPE *yyvaluep;
#endif
{
/* Pacify ``unused variable'' warnings. */
(void) yyvaluep;
YYUSE (yyvaluep);
 
if (!yymsg)
yymsg = "Deleting";
YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
 
switch (yytype)
{
 
default:
break;
break;
}
}
 
/* Prevent warnings from -Wmissing-prototypes. */
 
#ifdef YYPARSE_PARAM
# if defined (__STDC__) || defined (__cplusplus)
#if defined __STDC__ || defined __cplusplus
int yyparse (void *YYPARSE_PARAM);
# else
#else
int yyparse ();
# endif
#endif
#else /* ! YYPARSE_PARAM */
#if defined (__STDC__) || defined (__cplusplus)
#if defined __STDC__ || defined __cplusplus
int yyparse (void);
#else
int yyparse ();
1041,7 → 1387,6
#endif /* ! YYPARSE_PARAM */
 
 
 
/* The lookahead symbol. */
int yychar;
 
1053,19 → 1398,23
 
 
 
/*----------.
| yyparse. |
`----------*/
/*-------------------------.
| yyparse or yypush_parse. |
`-------------------------*/
 
#ifdef YYPARSE_PARAM
# if defined (__STDC__) || defined (__cplusplus)
int yyparse (void *YYPARSE_PARAM)
# else
int yyparse (YYPARSE_PARAM)
void *YYPARSE_PARAM;
# endif
#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 (__cplusplus)
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
int
yyparse (void)
#else
1075,60 → 1424,68
#endif
#endif
{
register int yystate;
register int yyn;
int yyresult;
/* Number of tokens to shift before error messages enabled. */
int yyerrstatus;
/* Lookahead token as an internal (translated) token number. */
int yytoken = 0;
 
/* 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 xreallocate them elsewhere. */
int yystate;
/* Number of tokens to shift before error messages enabled. */
int yyerrstatus;
 
/* The state stack. */
short yyssa[YYINITDEPTH];
short *yyss = yyssa;
register short *yyssp;
/* The stacks and their tools:
`yyss': related to states.
`yyvs': related to semantic values.
 
/* The semantic value stack. */
YYSTYPE yyvsa[YYINITDEPTH];
YYSTYPE *yyvs = yyvsa;
register YYSTYPE *yyvsp;
Refer to the stacks thru separate pointers, to allow yyoverflow
to xreallocate them elsewhere. */
 
/* The state stack. */
yytype_int16 yyssa[YYINITDEPTH];
yytype_int16 *yyss;
yytype_int16 *yyssp;
 
/* The semantic value stack. */
YYSTYPE yyvsa[YYINITDEPTH];
YYSTYPE *yyvs;
YYSTYPE *yyvsp;
 
#define YYPOPSTACK (yyvsp--, yyssp--)
YYSIZE_T yystacksize;
 
YYSIZE_T yystacksize = YYINITDEPTH;
 
int yyn;
int yyresult;
/* Lookahead token as an internal (translated) token number. */
int yytoken;
/* The variables used to return semantic value and location from the
action routines. */
YYSTYPE yyval;
 
#if YYERROR_VERBOSE
/* Buffer for error messages, and its allocated size. */
char yymsgbuf[128];
char *yymsg = yymsgbuf;
YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
#endif
 
/* When reducing, the number of symbols on the RHS of the reduced
rule. */
int yylen;
#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
 
/* The number of symbols on the RHS of the reduced rule.
Keep to zero when no symbol should be popped. */
int yylen = 0;
 
yytoken = 0;
yyss = yyssa;
yyvs = yyvsa;
yystacksize = YYINITDEPTH;
 
YYDPRINTF ((stderr, "Starting parse\n"));
 
yystate = 0;
yyerrstatus = 0;
yynerrs = 0;
yychar = YYEMPTY; /* Cause a token to be read. */
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;
 
1139,8 → 1496,7
`------------------------------------------------------------*/
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.
*/
have just been pushed. So pushing a state here evens the stacks. */
yyssp++;
 
yysetstate:
1153,21 → 1509,19
 
#ifdef yyoverflow
{
/* Give user a chance to xreallocate the stack. Use copies of
/* Give user a chance to xreallocate the stack. Use copies of
these so that the &'s don't force the real ones into
memory. */
YYSTYPE *yyvs1 = yyvs;
short *yyss1 = yyss;
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 ("parser stack overflow",
yyoverflow (YY_("memory exhausted"),
&yyss1, yysize * sizeof (*yyssp),
&yyvs1, yysize * sizeof (*yyvsp),
 
&yystacksize);
 
yyss = yyss1;
1175,24 → 1529,23
}
#else /* no yyoverflow */
# ifndef YYSTACK_RELOCATE
goto yyoverflowlab;
goto yyexhaustedlab;
# else
/* Extend the stack our own way. */
if (YYMAXDEPTH <= yystacksize)
goto yyoverflowlab;
goto yyexhaustedlab;
yystacksize *= 2;
if (YYMAXDEPTH < yystacksize)
yystacksize = YYMAXDEPTH;
 
{
short *yyss1 = yyss;
yytype_int16 *yyss1 = yyss;
union yyalloc *yyptr =
(union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
if (! yyptr)
goto yyoverflowlab;
YYSTACK_RELOCATE (yyss);
YYSTACK_RELOCATE (yyvs);
 
goto yyexhaustedlab;
YYSTACK_RELOCATE (yyss_alloc, yyss);
YYSTACK_RELOCATE (yyvs_alloc, yyvs);
# undef YYSTACK_RELOCATE
if (yyss1 != yyssa)
YYSTACK_FREE (yyss1);
1203,7 → 1556,6
yyssp = yyss + yysize - 1;
yyvsp = yyvs + yysize - 1;
 
 
YYDPRINTF ((stderr, "Stack size increased to %lu\n",
(unsigned long int) yystacksize));
 
1213,6 → 1565,9
 
YYDPRINTF ((stderr, "Entering state %d\n", yystate));
 
if (yystate == YYFINAL)
YYACCEPT;
 
goto yybackup;
 
/*-----------.
1220,12 → 1575,10
`-----------*/
yybackup:
 
/* Do appropriate processing given the current state. */
/* Read a lookahead token if we need one and don't already have one. */
/* yyresume: */
/* Do appropriate processing given the current state. Read a
lookahead token if we need one and don't already have one. */
 
/* First try to decide what to do without reference to lookahead token. */
 
yyn = yypact[yystate];
if (yyn == YYPACT_NINF)
goto yydefault;
1247,7 → 1600,7
else
{
yytoken = YYTRANSLATE (yychar);
YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc);
YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
}
 
/* If the proper action on seeing token YYTOKEN is to reduce or to
1264,25 → 1617,20
goto yyreduce;
}
 
if (yyn == YYFINAL)
YYACCEPT;
/* Count tokens shifted since error; after three, turn off error
status. */
if (yyerrstatus)
yyerrstatus--;
 
/* Shift the lookahead token. */
YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken]));
YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
 
/* Discard the token being shifted unless it is eof. */
if (yychar != YYEOF)
yychar = YYEMPTY;
/* Discard the shifted token. */
yychar = YYEMPTY;
 
yystate = yyn;
*++yyvsp = yylval;
 
 
/* Count tokens shifted since error; after three, turn off error
status. */
if (yyerrstatus)
yyerrstatus--;
 
yystate = yyn;
goto yynewstate;
 
 
1318,6 → 1666,8
switch (yyn)
{
case 2:
 
/* Line 1455 of yacc.c */
#line 235 "p-exp.y"
{ current_type = NULL;
search_field = 0;
1326,24 → 1676,32
break;
 
case 3:
 
/* Line 1455 of yacc.c */
#line 239 "p-exp.y"
{}
break;
 
case 6:
 
/* Line 1455 of yacc.c */
#line 248 "p-exp.y"
{ write_exp_elt_opcode(OP_TYPE);
write_exp_elt_type(yyvsp[0].tval);
write_exp_elt_type((yyvsp[(1) - (1)].tval));
write_exp_elt_opcode(OP_TYPE);
current_type = yyvsp[0].tval; }
current_type = (yyvsp[(1) - (1)].tval); }
break;
 
case 8:
 
/* Line 1455 of yacc.c */
#line 256 "p-exp.y"
{ write_exp_elt_opcode (BINOP_COMMA); }
break;
 
case 9:
 
/* Line 1455 of yacc.c */
#line 261 "p-exp.y"
{ write_exp_elt_opcode (UNOP_IND);
if (current_type)
1351,6 → 1709,8
break;
 
case 10:
 
/* Line 1455 of yacc.c */
#line 267 "p-exp.y"
{ write_exp_elt_opcode (UNOP_ADDR);
if (current_type)
1358,34 → 1718,46
break;
 
case 11:
 
/* Line 1455 of yacc.c */
#line 273 "p-exp.y"
{ write_exp_elt_opcode (UNOP_NEG); }
break;
 
case 12:
 
/* Line 1455 of yacc.c */
#line 277 "p-exp.y"
{ write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
break;
 
case 13:
 
/* Line 1455 of yacc.c */
#line 281 "p-exp.y"
{ write_exp_elt_opcode (UNOP_PREINCREMENT); }
break;
 
case 14:
 
/* Line 1455 of yacc.c */
#line 285 "p-exp.y"
{ write_exp_elt_opcode (UNOP_PREDECREMENT); }
break;
 
case 15:
 
/* Line 1455 of yacc.c */
#line 288 "p-exp.y"
{ search_field = 1; }
break;
 
case 16:
 
/* Line 1455 of yacc.c */
#line 291 "p-exp.y"
{ write_exp_elt_opcode (STRUCTOP_STRUCT);
write_exp_string (yyvsp[0].sval);
write_exp_string ((yyvsp[(4) - (4)].sval));
write_exp_elt_opcode (STRUCTOP_STRUCT);
search_field = 0;
if (current_type)
1392,11 → 1764,13
{ while (TYPE_CODE (current_type) == TYPE_CODE_PTR)
current_type = TYPE_TARGET_TYPE (current_type);
current_type = lookup_struct_elt_type (
current_type, yyvsp[0].sval.ptr, 0); };
current_type, (yyvsp[(4) - (4)].sval).ptr, 0); };
}
break;
 
case 17:
 
/* Line 1455 of yacc.c */
#line 303 "p-exp.y"
{ char *arrayname;
int arrayfieldindex;
1419,6 → 1793,8
break;
 
case 18:
 
/* Line 1455 of yacc.c */
#line 322 "p-exp.y"
{ pop_current_type ();
write_exp_elt_opcode (BINOP_SUBSCRIPT);
1427,6 → 1803,8
break;
 
case 19:
 
/* Line 1455 of yacc.c */
#line 331 "p-exp.y"
{ push_current_type ();
start_arglist (); }
1433,6 → 1811,8
break;
 
case 20:
 
/* Line 1455 of yacc.c */
#line 334 "p-exp.y"
{ write_exp_elt_opcode (OP_FUNCALL);
write_exp_elt_longcst ((LONGEST) end_arglist ());
1444,16 → 1824,22
break;
 
case 22:
 
/* Line 1455 of yacc.c */
#line 345 "p-exp.y"
{ arglist_len = 1; }
break;
 
case 23:
 
/* Line 1455 of yacc.c */
#line 347 "p-exp.y"
{ arglist_len++; }
break;
 
case 24:
 
/* Line 1455 of yacc.c */
#line 351 "p-exp.y"
{ if (current_type)
{
1460,26 → 1846,32
/* Allow automatic dereference of classes. */
if ((TYPE_CODE (current_type) == TYPE_CODE_PTR)
&& (TYPE_CODE (TYPE_TARGET_TYPE (current_type)) == TYPE_CODE_CLASS)
&& (TYPE_CODE (yyvsp[-3].tval) == TYPE_CODE_CLASS))
&& (TYPE_CODE ((yyvsp[(1) - (4)].tval)) == TYPE_CODE_CLASS))
write_exp_elt_opcode (UNOP_IND);
}
write_exp_elt_opcode (UNOP_CAST);
write_exp_elt_type (yyvsp[-3].tval);
write_exp_elt_type ((yyvsp[(1) - (4)].tval));
write_exp_elt_opcode (UNOP_CAST);
current_type = yyvsp[-3].tval; }
current_type = (yyvsp[(1) - (4)].tval); }
break;
 
case 25:
 
/* Line 1455 of yacc.c */
#line 366 "p-exp.y"
{ }
break;
 
case 26:
 
/* Line 1455 of yacc.c */
#line 372 "p-exp.y"
{ write_exp_elt_opcode (BINOP_MUL); }
break;
 
case 27:
 
/* Line 1455 of yacc.c */
#line 375 "p-exp.y"
{
if (current_type && is_integral_type (current_type))
1488,6 → 1880,8
break;
 
case 28:
 
/* Line 1455 of yacc.c */
#line 380 "p-exp.y"
{
if (leftdiv_is_integer && current_type
1505,36 → 1899,50
break;
 
case 29:
 
/* Line 1455 of yacc.c */
#line 396 "p-exp.y"
{ write_exp_elt_opcode (BINOP_INTDIV); }
break;
 
case 30:
 
/* Line 1455 of yacc.c */
#line 400 "p-exp.y"
{ write_exp_elt_opcode (BINOP_REM); }
break;
 
case 31:
 
/* Line 1455 of yacc.c */
#line 404 "p-exp.y"
{ write_exp_elt_opcode (BINOP_ADD); }
break;
 
case 32:
 
/* Line 1455 of yacc.c */
#line 408 "p-exp.y"
{ write_exp_elt_opcode (BINOP_SUB); }
break;
 
case 33:
 
/* Line 1455 of yacc.c */
#line 412 "p-exp.y"
{ write_exp_elt_opcode (BINOP_LSH); }
break;
 
case 34:
 
/* Line 1455 of yacc.c */
#line 416 "p-exp.y"
{ write_exp_elt_opcode (BINOP_RSH); }
break;
 
case 35:
 
/* Line 1455 of yacc.c */
#line 420 "p-exp.y"
{ write_exp_elt_opcode (BINOP_EQUAL);
current_type = parse_type->builtin_bool;
1542,6 → 1950,8
break;
 
case 36:
 
/* Line 1455 of yacc.c */
#line 426 "p-exp.y"
{ write_exp_elt_opcode (BINOP_NOTEQUAL);
current_type = parse_type->builtin_bool;
1549,6 → 1959,8
break;
 
case 37:
 
/* Line 1455 of yacc.c */
#line 432 "p-exp.y"
{ write_exp_elt_opcode (BINOP_LEQ);
current_type = parse_type->builtin_bool;
1556,6 → 1968,8
break;
 
case 38:
 
/* Line 1455 of yacc.c */
#line 438 "p-exp.y"
{ write_exp_elt_opcode (BINOP_GEQ);
current_type = parse_type->builtin_bool;
1563,6 → 1977,8
break;
 
case 39:
 
/* Line 1455 of yacc.c */
#line 444 "p-exp.y"
{ write_exp_elt_opcode (BINOP_LESS);
current_type = parse_type->builtin_bool;
1570,6 → 1986,8
break;
 
case 40:
 
/* Line 1455 of yacc.c */
#line 450 "p-exp.y"
{ write_exp_elt_opcode (BINOP_GTR);
current_type = parse_type->builtin_bool;
1577,54 → 1995,70
break;
 
case 41:
 
/* Line 1455 of yacc.c */
#line 456 "p-exp.y"
{ write_exp_elt_opcode (BINOP_BITWISE_AND); }
break;
 
case 42:
 
/* Line 1455 of yacc.c */
#line 460 "p-exp.y"
{ write_exp_elt_opcode (BINOP_BITWISE_XOR); }
break;
 
case 43:
 
/* Line 1455 of yacc.c */
#line 464 "p-exp.y"
{ write_exp_elt_opcode (BINOP_BITWISE_IOR); }
break;
 
case 44:
 
/* Line 1455 of yacc.c */
#line 468 "p-exp.y"
{ write_exp_elt_opcode (BINOP_ASSIGN); }
break;
 
case 45:
 
/* Line 1455 of yacc.c */
#line 472 "p-exp.y"
{ write_exp_elt_opcode (OP_BOOL);
write_exp_elt_longcst ((LONGEST) yyvsp[0].lval);
write_exp_elt_longcst ((LONGEST) (yyvsp[(1) - (1)].lval));
current_type = parse_type->builtin_bool;
write_exp_elt_opcode (OP_BOOL); }
break;
 
case 46:
 
/* Line 1455 of yacc.c */
#line 479 "p-exp.y"
{ write_exp_elt_opcode (OP_BOOL);
write_exp_elt_longcst ((LONGEST) yyvsp[0].lval);
write_exp_elt_longcst ((LONGEST) (yyvsp[(1) - (1)].lval));
current_type = parse_type->builtin_bool;
write_exp_elt_opcode (OP_BOOL); }
break;
 
case 47:
 
/* Line 1455 of yacc.c */
#line 486 "p-exp.y"
{ write_exp_elt_opcode (OP_LONG);
write_exp_elt_type (yyvsp[0].typed_val_int.type);
current_type = yyvsp[0].typed_val_int.type;
write_exp_elt_longcst ((LONGEST)(yyvsp[0].typed_val_int.val));
write_exp_elt_type ((yyvsp[(1) - (1)].typed_val_int).type);
current_type = (yyvsp[(1) - (1)].typed_val_int).type;
write_exp_elt_longcst ((LONGEST)((yyvsp[(1) - (1)].typed_val_int).val));
write_exp_elt_opcode (OP_LONG); }
break;
 
case 48:
 
/* Line 1455 of yacc.c */
#line 494 "p-exp.y"
{ YYSTYPE val;
parse_number (yyvsp[0].ssym.stoken.ptr, yyvsp[0].ssym.stoken.length, 0, &val);
parse_number ((yyvsp[(1) - (1)].ssym).stoken.ptr, (yyvsp[(1) - (1)].ssym).stoken.length, 0, &val);
write_exp_elt_opcode (OP_LONG);
write_exp_elt_type (val.typed_val_int.type);
current_type = val.typed_val_int.type;
1634,29 → 2068,37
break;
 
case 49:
 
/* Line 1455 of yacc.c */
#line 506 "p-exp.y"
{ write_exp_elt_opcode (OP_DOUBLE);
write_exp_elt_type (yyvsp[0].typed_val_float.type);
current_type = yyvsp[0].typed_val_float.type;
write_exp_elt_dblcst (yyvsp[0].typed_val_float.dval);
write_exp_elt_type ((yyvsp[(1) - (1)].typed_val_float).type);
current_type = (yyvsp[(1) - (1)].typed_val_float).type;
write_exp_elt_dblcst ((yyvsp[(1) - (1)].typed_val_float).dval);
write_exp_elt_opcode (OP_DOUBLE); }
break;
 
case 52:
 
/* Line 1455 of yacc.c */
#line 521 "p-exp.y"
{ write_exp_elt_opcode (OP_LONG);
write_exp_elt_type (parse_type->builtin_int);
CHECK_TYPEDEF (yyvsp[-1].tval);
write_exp_elt_longcst ((LONGEST) TYPE_LENGTH (yyvsp[-1].tval));
CHECK_TYPEDEF ((yyvsp[(3) - (4)].tval));
write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ((yyvsp[(3) - (4)].tval)));
write_exp_elt_opcode (OP_LONG); }
break;
 
case 53:
 
/* Line 1455 of yacc.c */
#line 529 "p-exp.y"
{ write_exp_elt_opcode (UNOP_SIZEOF); }
break;
 
case 54:
 
/* Line 1455 of yacc.c */
#line 532 "p-exp.y"
{ /* C strings are converted into array constants with
an explicit null byte added at the end. Thus
1663,7 → 2105,7
the array upper bound is the string length.
There is no such thing in C as a completely empty
string. */
char *sp = yyvsp[0].sval.ptr; int count = yyvsp[0].sval.length;
char *sp = (yyvsp[(1) - (1)].sval).ptr; int count = (yyvsp[(1) - (1)].sval).length;
while (count-- > 0)
{
write_exp_elt_opcode (OP_LONG);
1677,11 → 2119,13
write_exp_elt_opcode (OP_LONG);
write_exp_elt_opcode (OP_ARRAY);
write_exp_elt_longcst ((LONGEST) 0);
write_exp_elt_longcst ((LONGEST) (yyvsp[0].sval.length));
write_exp_elt_longcst ((LONGEST) ((yyvsp[(1) - (1)].sval).length));
write_exp_elt_opcode (OP_ARRAY); }
break;
 
case 55:
 
/* Line 1455 of yacc.c */
#line 557 "p-exp.y"
{
struct value * this_val;
1708,42 → 2152,48
break;
 
case 56:
 
/* Line 1455 of yacc.c */
#line 584 "p-exp.y"
{
if (yyvsp[0].ssym.sym != 0)
yyval.bval = SYMBOL_BLOCK_VALUE (yyvsp[0].ssym.sym);
if ((yyvsp[(1) - (1)].ssym).sym != 0)
(yyval.bval) = SYMBOL_BLOCK_VALUE ((yyvsp[(1) - (1)].ssym).sym);
else
{
struct symtab *tem =
lookup_symtab (copy_name (yyvsp[0].ssym.stoken));
lookup_symtab (copy_name ((yyvsp[(1) - (1)].ssym).stoken));
if (tem)
yyval.bval = BLOCKVECTOR_BLOCK (BLOCKVECTOR (tem), STATIC_BLOCK);
(yyval.bval) = BLOCKVECTOR_BLOCK (BLOCKVECTOR (tem), STATIC_BLOCK);
else
error ("No file or function \"%s\".",
copy_name (yyvsp[0].ssym.stoken));
copy_name ((yyvsp[(1) - (1)].ssym).stoken));
}
}
break;
 
case 57:
 
/* Line 1455 of yacc.c */
#line 601 "p-exp.y"
{ struct symbol *tem
= lookup_symbol (copy_name (yyvsp[0].sval), yyvsp[-2].bval,
= lookup_symbol (copy_name ((yyvsp[(3) - (3)].sval)), (yyvsp[(1) - (3)].bval),
VAR_DOMAIN, (int *) NULL);
if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
error ("No function \"%s\" in specified context.",
copy_name (yyvsp[0].sval));
yyval.bval = SYMBOL_BLOCK_VALUE (tem); }
copy_name ((yyvsp[(3) - (3)].sval)));
(yyval.bval) = SYMBOL_BLOCK_VALUE (tem); }
break;
 
case 58:
 
/* Line 1455 of yacc.c */
#line 611 "p-exp.y"
{ struct symbol *sym;
sym = lookup_symbol (copy_name (yyvsp[0].sval), yyvsp[-2].bval,
sym = lookup_symbol (copy_name ((yyvsp[(3) - (3)].sval)), (yyvsp[(1) - (3)].bval),
VAR_DOMAIN, (int *) NULL);
if (sym == 0)
error ("No symbol \"%s\" in specified context.",
copy_name (yyvsp[0].sval));
copy_name ((yyvsp[(3) - (3)].sval)));
 
write_exp_elt_opcode (OP_VAR_VALUE);
/* block_found is set by lookup_symbol. */
1753,9 → 2203,11
break;
 
case 59:
 
/* Line 1455 of yacc.c */
#line 626 "p-exp.y"
{
struct type *type = yyvsp[-2].tval;
struct type *type = (yyvsp[(1) - (3)].tval);
if (TYPE_CODE (type) != TYPE_CODE_STRUCT
&& TYPE_CODE (type) != TYPE_CODE_UNION)
error ("`%s' is not defined as an aggregate type.",
1763,15 → 2215,17
 
write_exp_elt_opcode (OP_SCOPE);
write_exp_elt_type (type);
write_exp_string (yyvsp[0].sval);
write_exp_string ((yyvsp[(3) - (3)].sval));
write_exp_elt_opcode (OP_SCOPE);
}
break;
 
case 61:
 
/* Line 1455 of yacc.c */
#line 642 "p-exp.y"
{
char *name = copy_name (yyvsp[0].sval);
char *name = copy_name ((yyvsp[(2) - (2)].sval));
struct symbol *sym;
struct minimal_symbol *msymbol;
 
1798,8 → 2252,10
break;
 
case 62:
 
/* Line 1455 of yacc.c */
#line 670 "p-exp.y"
{ struct symbol *sym = yyvsp[0].ssym.sym;
{ struct symbol *sym = (yyvsp[(1) - (1)].ssym).sym;
 
if (sym)
{
1819,7 → 2275,7
write_exp_elt_sym (sym);
write_exp_elt_opcode (OP_VAR_VALUE);
current_type = sym->type; }
else if (yyvsp[0].ssym.is_a_field_of_this)
else if ((yyvsp[(1) - (1)].ssym).is_a_field_of_this)
{
struct value * this_val;
struct type * this_type;
1833,7 → 2289,7
write_exp_elt_opcode (OP_THIS);
write_exp_elt_opcode (OP_THIS);
write_exp_elt_opcode (STRUCTOP_PTR);
write_exp_string (yyvsp[0].ssym.stoken);
write_exp_string ((yyvsp[(1) - (1)].ssym).stoken);
write_exp_elt_opcode (STRUCTOP_PTR);
/* we need type of this */
this_val = value_of_this (0);
1844,7 → 2300,7
if (this_type)
current_type = lookup_struct_elt_type (
this_type,
copy_name (yyvsp[0].ssym.stoken), 0);
copy_name ((yyvsp[(1) - (1)].ssym).stoken), 0);
else
current_type = NULL;
}
1851,7 → 2307,7
else
{
struct minimal_symbol *msymbol;
char *arg = copy_name (yyvsp[0].ssym.stoken);
char *arg = copy_name ((yyvsp[(1) - (1)].ssym).stoken);
 
msymbol =
lookup_minimal_symbol (arg, NULL, NULL);
1861,68 → 2317,83
error ("No symbol table is loaded. Use the \"file\" command.");
else
error ("No symbol \"%s\" in current context.",
copy_name (yyvsp[0].ssym.stoken));
copy_name ((yyvsp[(1) - (1)].ssym).stoken));
}
}
break;
 
case 65:
 
/* Line 1455 of yacc.c */
#line 754 "p-exp.y"
{ yyval.tval = lookup_pointer_type (yyvsp[0].tval); }
{ (yyval.tval) = lookup_pointer_type ((yyvsp[(2) - (2)].tval)); }
break;
 
case 66:
 
/* Line 1455 of yacc.c */
#line 756 "p-exp.y"
{ yyval.tval = yyvsp[0].tsym.type; }
{ (yyval.tval) = (yyvsp[(1) - (1)].tsym).type; }
break;
 
case 67:
 
/* Line 1455 of yacc.c */
#line 758 "p-exp.y"
{ yyval.tval = lookup_struct (copy_name (yyvsp[0].sval),
{ (yyval.tval) = lookup_struct (copy_name ((yyvsp[(2) - (2)].sval)),
expression_context_block); }
break;
 
case 68:
 
/* Line 1455 of yacc.c */
#line 761 "p-exp.y"
{ yyval.tval = lookup_struct (copy_name (yyvsp[0].sval),
{ (yyval.tval) = lookup_struct (copy_name ((yyvsp[(2) - (2)].sval)),
expression_context_block); }
break;
 
case 69:
 
/* Line 1455 of yacc.c */
#line 768 "p-exp.y"
{ yyval.sval = yyvsp[0].ssym.stoken; }
{ (yyval.sval) = (yyvsp[(1) - (1)].ssym).stoken; }
break;
 
case 70:
 
/* Line 1455 of yacc.c */
#line 769 "p-exp.y"
{ yyval.sval = yyvsp[0].ssym.stoken; }
{ (yyval.sval) = (yyvsp[(1) - (1)].ssym).stoken; }
break;
 
case 71:
 
/* Line 1455 of yacc.c */
#line 770 "p-exp.y"
{ yyval.sval = yyvsp[0].tsym.stoken; }
{ (yyval.sval) = (yyvsp[(1) - (1)].tsym).stoken; }
break;
 
case 72:
 
/* Line 1455 of yacc.c */
#line 771 "p-exp.y"
{ yyval.sval = yyvsp[0].ssym.stoken; }
{ (yyval.sval) = (yyvsp[(1) - (1)].ssym).stoken; }
break;
 
 
 
/* Line 1455 of yacc.c */
#line 2388 "p-exp.c.tmp"
default: break;
}
YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
 
/* Line 1000 of yacc.c. */
#line 1916 "p-exp.c.tmp"
yyvsp -= yylen;
yyssp -= yylen;
 
 
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. */
1946,66 → 2417,41
if (!yyerrstatus)
{
++yynerrs;
#if YYERROR_VERBOSE
yyn = yypact[yystate];
 
if (YYPACT_NINF < yyn && yyn < YYLAST)
{
YYSIZE_T yysize = 0;
int yytype = YYTRANSLATE (yychar);
const char* yyprefix;
char *yymsg;
int yyx;
 
/* 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;
int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
int yycount = 0;
 
yyprefix = ", expecting ";
for (yyx = yyxbegin; yyx < yyxend; ++yyx)
if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
#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
{
yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]);
yycount += 1;
if (yycount == 5)
{
yysize = 0;
break;
}
yymsg = yymsgbuf;
yymsg_alloc = sizeof yymsgbuf;
}
yysize += (sizeof ("syntax error, unexpected ")
+ yystrlen (yytname[yytype]));
yymsg = (char *) YYSTACK_ALLOC (yysize);
if (yymsg != 0)
{
char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
yyp = yystpcpy (yyp, yytname[yytype]);
}
 
if (yycount < 5)
{
yyprefix = ", expecting ";
for (yyx = yyxbegin; yyx < yyxend; ++yyx)
if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
{
yyp = yystpcpy (yyp, yyprefix);
yyp = yystpcpy (yyp, yytname[yyx]);
yyprefix = " or ";
}
}
yyerror (yymsg);
YYSTACK_FREE (yymsg);
}
else
yyerror ("syntax error; also virtual memory exhausted");
}
else
#endif /* YYERROR_VERBOSE */
yyerror ("syntax error");
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
}
 
 
2016,25 → 2462,16
error, discard it. */
 
if (yychar <= YYEOF)
{
/* If at end of input, pop the error token,
then the rest of the stack, then return failure. */
{
/* Return failure if at end of input. */
if (yychar == YYEOF)
for (;;)
{
YYPOPSTACK;
if (yyssp == yyss)
YYABORT;
YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
yydestruct (yystos[*yyssp], yyvsp);
}
}
YYABORT;
}
else
{
YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);
yydestruct (yytoken, &yylval);
yydestruct ("Error: discarding",
yytoken, &yylval);
yychar = YYEMPTY;
 
}
}
 
2048,15 → 2485,17
`---------------------------------------------------*/
yyerrorlab:
 
#ifdef __GNUC__
/* Pacify GCC when the user code never invokes YYERROR and the label
yyerrorlab therefore never appears in user code. */
if (0)
/* 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;
#endif
 
yyvsp -= yylen;
yyssp -= yylen;
/* 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;
 
2085,21 → 2524,20
if (yyssp == yyss)
YYABORT;
 
YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
yydestruct (yystos[yystate], yyvsp);
YYPOPSTACK;
 
yydestruct ("Error: popping",
yystos[yystate], yyvsp);
YYPOPSTACK (1);
yystate = *yyssp;
YY_STACK_PRINT (yyss, yyssp);
}
 
if (yyn == YYFINAL)
YYACCEPT;
*++yyvsp = yylval;
 
YYDPRINTF ((stderr, "Shifting error token, "));
 
*++yyvsp = yylval;
/* Shift the error token. */
YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
 
 
yystate = yyn;
goto yynewstate;
 
2118,25 → 2556,45
yyresult = 1;
goto yyreturn;
 
#ifndef yyoverflow
/*----------------------------------------------.
| yyoverflowlab -- parser overflow comes here. |
`----------------------------------------------*/
yyoverflowlab:
yyerror ("parser stack overflow");
#if !defined(yyoverflow) || YYERROR_VERBOSE
/*-------------------------------------------------.
| yyexhaustedlab -- memory exhaustion comes here. |
`-------------------------------------------------*/
yyexhaustedlab:
yyerror (YY_("memory exhausted"));
yyresult = 2;
/* Fall through. */
#endif
 
yyreturn:
if (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
return yyresult;
#if YYERROR_VERBOSE
if (yymsg != yymsgbuf)
YYSTACK_FREE (yymsg);
#endif
/* Make sure YYID is used. */
return YYID (yyresult);
}
 
 
 
/* Line 1675 of yacc.c */
#line 785 "p-exp.y"
 
 
3039,4 → 3497,3
error ("A %s in expression, near `%s'.", (msg ? msg : "error"), lexptr);
}
 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.