From d908f13420218445b40bacd577a80c46ca5ca7a5 Mon Sep 17 00:00:00 2001 From: ocoursiere Date: Sat, 21 Sep 2002 14:12:12 +0000 Subject: [PATCH] Shared object version of the stubgen parser --- bepascal/bepascal/stubgen.so/COPYING | 340 ++ .../stubgen.so/Example Usage for OpenBeOS.txt | 3 + bepascal/bepascal/stubgen.so/Makefile | 90 + bepascal/bepascal/stubgen.so/README | 147 + bepascal/bepascal/stubgen.so/README.fpc | 3 + bepascal/bepascal/stubgen.so/getopt.c | 826 ++++ bepascal/bepascal/stubgen.so/getopt.h | 130 + bepascal/bepascal/stubgen.so/lex.yy.c | 2652 +++++++++++++ bepascal/bepascal/stubgen.so/lexer.l | 522 +++ bepascal/bepascal/stubgen.so/lib.c | 2 + bepascal/bepascal/stubgen.so/main.c | 726 ++++ bepascal/bepascal/stubgen.so/parser.y | 1784 +++++++++ bepascal/bepascal/stubgen.so/pathname.c | 86 + bepascal/bepascal/stubgen.so/pathname.h | 70 + bepascal/bepascal/stubgen.so/stubgen.pp | 49 + bepascal/bepascal/stubgen.so/table.c | 441 +++ bepascal/bepascal/stubgen.so/table.h | 119 + bepascal/bepascal/stubgen.so/util.c | 147 + bepascal/bepascal/stubgen.so/util.h | 63 + bepascal/bepascal/stubgen.so/y.tab.c | 3309 +++++++++++++++++ bepascal/bepascal/stubgen.so/y.tab.h | 60 + 21 files changed, 11569 insertions(+) create mode 100644 bepascal/bepascal/stubgen.so/COPYING create mode 100644 bepascal/bepascal/stubgen.so/Example Usage for OpenBeOS.txt create mode 100644 bepascal/bepascal/stubgen.so/Makefile create mode 100644 bepascal/bepascal/stubgen.so/README create mode 100644 bepascal/bepascal/stubgen.so/README.fpc create mode 100644 bepascal/bepascal/stubgen.so/getopt.c create mode 100644 bepascal/bepascal/stubgen.so/getopt.h create mode 100644 bepascal/bepascal/stubgen.so/lex.yy.c create mode 100644 bepascal/bepascal/stubgen.so/lexer.l create mode 100644 bepascal/bepascal/stubgen.so/lib.c create mode 100644 bepascal/bepascal/stubgen.so/main.c create mode 100644 bepascal/bepascal/stubgen.so/parser.y create mode 100644 bepascal/bepascal/stubgen.so/pathname.c create mode 100644 bepascal/bepascal/stubgen.so/pathname.h create mode 100644 bepascal/bepascal/stubgen.so/stubgen.pp create mode 100644 bepascal/bepascal/stubgen.so/table.c create mode 100644 bepascal/bepascal/stubgen.so/table.h create mode 100644 bepascal/bepascal/stubgen.so/util.c create mode 100644 bepascal/bepascal/stubgen.so/util.h create mode 100644 bepascal/bepascal/stubgen.so/y.tab.c create mode 100644 bepascal/bepascal/stubgen.so/y.tab.h diff --git a/bepascal/bepascal/stubgen.so/COPYING b/bepascal/bepascal/stubgen.so/COPYING new file mode 100644 index 0000000..60549be --- /dev/null +++ b/bepascal/bepascal/stubgen.so/COPYING @@ -0,0 +1,340 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc. + 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Library General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) 19yy + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) 19yy name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + , 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Library General +Public License instead of this License. diff --git a/bepascal/bepascal/stubgen.so/Example Usage for OpenBeOS.txt b/bepascal/bepascal/stubgen.so/Example Usage for OpenBeOS.txt new file mode 100644 index 0000000..402cfb8 --- /dev/null +++ b/bepascal/bepascal/stubgen.so/Example Usage for OpenBeOS.txt @@ -0,0 +1,3 @@ +Example usage for OpenBeOS project: + +stubgen -s -g -a *.h diff --git a/bepascal/bepascal/stubgen.so/Makefile b/bepascal/bepascal/stubgen.so/Makefile new file mode 100644 index 0000000..6194d9d --- /dev/null +++ b/bepascal/bepascal/stubgen.so/Makefile @@ -0,0 +1,90 @@ +# +# FILE: Makefile +# AUTH: Michael John Radwin +# +# DESC: stubgen makefile +# modified from O'Reilly's lex & yacc, Second Edition +# +# DATE: Wed Aug 14 18:11:18 US/Eastern 1996 +# $Id: Makefile,v 1.1 2002-09-21 14:12:12 ocoursiere Exp $ +# +# Copyright (c) 1996-1998 Michael John Radwin +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# + +# --- User-definable stuff. Edit if you know what you're doing. --- # + +# Choose your compiler. I like Sun's cc compiler because I use dbx for +# debugging, but you might want gcc. +CC = gcc -Wall +#CC = cc + +# You'll need to use a lexer that supports the exclusive start state +# mechanism (the '%x' directive). GNU Flex does this just fine. +LEX = flex +#LEX = lex + +# You should be able to use any of the 3 common flavors of yacc: +# AT&T Yacc, Berkeley Yacc, or GNU Bison. We've tested with bison. +#YACC = yacc -d +YACC = bison -y -d +#YACC = byacc -d + +# etags is used purely for development purposes. +ETAGS = etags + +# for Sun cc, we don't like incremental linking. +#LFLAGS = -xildoff + +# for a lex other than GNU Flex, we must link with the -ll library. +#LFLAGS = -ll + +# Debug settings are on. Having the SGDEBUG macro defined will make +# generate 'stubgen.log' files on each execution of stubgen, which are +# useful for debugging, but probably annoying. +CFLAGS = -g -DSGDEBUG +#CFLAGS = -O + +# --- You probably shouldn't edit anything below this line. --- # +OFILES = y.tab.o lex.yy.o table.o util.o pathname.o main.o getopt.o +SRCFILES = lexer.l parser.y table.[ch] util.[ch] pathname.[ch] main.c + +all: stubgen + +stubgen: $(OFILES) + $(CC) $(CFLAGS) -o $@ $(OFILES) $(LFLAGS) $(LIBS) + chmod 0755 $@ + +y.output: parser.y + $(YACC) -v parser.y + +lex.yy.c: lexer.l y.tab.h + $(LEX) lexer.l + +y.tab.h y.tab.c: parser.y + $(YACC) parser.y + +tags: TAGS +TAGS: $(SRCFILES) + $(ETAGS) $(SRCFILES) + +clean: + rm -f $(OFILES) TAGS + rm -f y.tab.h y.tab.c lex.yy.c y.output stubgen.log + rm -f win32/stubgen.plg win32/stubgen.ncb win32/stubgen.opt + rm -f win32/stubgen.pdb win32/stubgen.ilk + rm -f win32/stubgen.mak win32/stubgen.bsc win32/stubgen.log + rm -rf win32/Debug win32/debug diff --git a/bepascal/bepascal/stubgen.so/README b/bepascal/bepascal/stubgen.so/README new file mode 100644 index 0000000..435a1ce --- /dev/null +++ b/bepascal/bepascal/stubgen.so/README @@ -0,0 +1,147 @@ +stubgen README file +Michael John Radwin +$Id: README,v 1.1 2002-09-21 14:12:12 ocoursiere Exp $ + + +Description +----------- +Welcome to stubgen version 2.05 (build 1086). + +stubgen is a C++ development tool that keeps code files in sync with +their associated headers. When it finds a member function declaration +in a header file that doesn't have a corresponding implementation, it +creates an empty skeleton with descriptive comment headers. stubgen has +several options, but see the "Brief Example" section below for an idea +of what it can do. + +This program is free software; you can redistribute it and/or modify it +under the terms of the GNU General Public License as published by the +Free Software Foundation; either version 2 of the License, or (at your +option) any later version. + +This program is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + + +Brief Example +------------- +Suppose you have the following header file Point.h: + + class Point { + public: + Point(int x, int y); + void addTo(const Point& other); + + int xValue, yValue; + }; + +Running "stubgen -s Point.h" would produce the following file: + + /*********************************************** + * AUTHOR: Michael John Radwin + * FILE: Point.cpp + * DATE: Mon Apr 20 17:39:05 1998 + * DESCR: + ***********************************************/ + #include "Point.h" + + /* + * Method: Point::Point() + * Descr: + */ + Point::Point(int x, int y) + { + } + + /* + * Method: Point::addTo() + * Descr: + */ + void + Point::addTo(const Point& other) + { + } + + +Supported Platforms +------------------- +I've successfully built stubgen on the following platforms, using the +GNU tools make, gcc, bison, and flex: + + SPARC Solaris (2.5 and 2.6) + SunOS 4.1.3 + SGI IRIX 5.3 + RS6000 AIX 3.2 + MS Windows NT 4.0 (using GNU bison/flex and MSVC++ 5.0) + + +Home Page +--------- +Check out the stubgen home page and download the current source code at: + + http://www.radwin.org/michael/projects/stubgen/ + + +Files +----- +The following files are included in this distribution: + + COPYING - the GNU general public license + ChangeLog - a listing of changes made on various versions. + Makefile - a makefile for building stubgen on unix + README - this file + etc/ - debugging routines for use with the -d option + getopt.[ch] - GNU getopts (for Win32) + lexer.l - flex source, generates tokens + main.c - code generation routines + parser.y - yacc source, parses header and code files + pathname.[ch] - dirname() and basename() routines + stubgen.1 - nroff-able man page + table.[ch] - data structures used in parsing + util.[ch] - utilities, logging routines, used in parsing + test/ - test header files for stubgen + win32/ - MS Visual C++ 5.0 project (Win32 console app) + + +Building +-------- +1. ensure that your system has 'flex' installed. +2. ensure that your system has 'yacc', 'byacc', or 'bison' installed. +3. edit 'Makefile' and pick your favorite CC, LEX, YACC, LFLAGS and CFLAGS +4. run 'make' + +We assume that flex, bison, and cc/gcc are in your path. + +For win32, there's no need to build. You'll find stubgen.exe in the +directory .\win32. + + +Installing +---------- +There is no fancy installation procedure. Since the binary doesn't +depend on any other files, copy it to /usr/local/bin or wherever you +choose. You may wish to copy stubgen.1 to /usr/local/man/man1 or some +similar directory. + + +Acknowledgments +---------------- +stubgen borrows code from: + +Jutta Degener's 1995 ANSI C grammar (based on Jeff Lee's 1985 +implementation): +ftp://ftp.uu.net/usenet/net.sources/ansi.c.grammar.Z +http://www.lysator.liu.se/c/ANSI-C-grammar-l.html +http://www.lysator.liu.se/c/ANSI-C-grammar-y.html + +Graham D. Parrington's Stub Generator for the Arjuna project at the +University of Newcastle upon Tyne: +http://arjuna.ncl.ac.uk/ + + +Copyright +--------- +stubgen is Copyright (c) 1996-1998 Michael John Radwin, under the terms +of the GNU General Public License. See COPYING for more. diff --git a/bepascal/bepascal/stubgen.so/README.fpc b/bepascal/bepascal/stubgen.so/README.fpc new file mode 100644 index 0000000..e6d0d27 --- /dev/null +++ b/bepascal/bepascal/stubgen.so/README.fpc @@ -0,0 +1,3 @@ +libstubgen is a shared object that export the stubgen's parser. + +stubgen.pp is the pascal unit to use this library. diff --git a/bepascal/bepascal/stubgen.so/getopt.c b/bepascal/bepascal/stubgen.so/getopt.c new file mode 100644 index 0000000..d87c250 --- /dev/null +++ b/bepascal/bepascal/stubgen.so/getopt.c @@ -0,0 +1,826 @@ +/* Getopt for GNU. + NOTE: getopt is now part of the C library, so if you don't know what + "Keep this file name-space clean" means, talk to roland@gnu.ai.mit.edu + before changing it! + + Copyright (C) 1987, 88, 89, 90, 91, 92, 93, 94, 95, 1996 + Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by the + Free Software Foundation; either version 2, or (at your option) any + later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, + USA. */ + +/* This tells Alpha OSF/1 not to define a getopt prototype in . + Ditto for AIX 3.2 and . */ +#ifndef _NO_PROTO +#define _NO_PROTO +#endif + +#ifdef HAVE_CONFIG_H +#include +#endif + +#if !defined (__STDC__) || !__STDC__ +/* This is a separate conditional since some stdc systems + reject `defined (const)'. */ +#ifndef const +#define const +#endif +#endif + +#include + +/* Comment out all this code if we are using the GNU C Library, and are not + actually compiling the library itself. This code is part of the GNU C + Library, but also included in many other GNU distributions. Compiling + and linking in this code is a waste when using the GNU C library + (especially if it is a shared library). Rather than having every GNU + program understand `configure --with-gnu-libc' and omit the object files, + it is simpler to just do this in the source for each such file. */ + +#if defined (_LIBC) || !defined (__GNU_LIBRARY__) + + +/* This needs to come after some library #include + to get __GNU_LIBRARY__ defined. */ +#ifdef __GNU_LIBRARY__ +/* Don't include stdlib.h for non-GNU C libraries because some of them + contain conflicting prototypes for getopt. */ +#include +#include +#endif /* GNU C library. */ + +#ifdef VMS +#include +#if HAVE_STRING_H - 0 +#include +#endif +#endif + +#if defined (WIN32) && !defined (__CYGWIN32__) +/* It's not Unix, really. See? Capital letters. */ +#include +#define getpid() GetCurrentProcessId() +#endif + +#ifndef _ +/* This is for other GNU distributions with internationalized messages. + When compiling libc, the _ macro is predefined. */ +#ifdef HAVE_LIBINTL_H +# include +# define _(msgid) gettext (msgid) +#else +# define _(msgid) (msgid) +#endif +#endif + +/* This version of `getopt' appears to the caller like standard Unix `getopt' + but it behaves differently for the user, since it allows the user + to intersperse the options with the other arguments. + + As `getopt' works, it permutes the elements of ARGV so that, + when it is done, all the options precede everything else. Thus + all application programs are extended to handle flexible argument order. + + Setting the environment variable POSIXLY_CORRECT disables permutation. + Then the behavior is completely standard. + + GNU application programs can use a third alternative mode in which + they can distinguish the relative order of options and other arguments. */ + +#include "getopt.h" + +/* For communication from `getopt' to the caller. + When `getopt' finds an option that takes an argument, + the argument value is returned here. + Also, when `ordering' is RETURN_IN_ORDER, + each non-option ARGV-element is returned here. */ + +char *optarg = NULL; + +/* Index in ARGV of the next element to be scanned. + This is used for communication to and from the caller + and for communication between successive calls to `getopt'. + + On entry to `getopt', zero means this is the first call; initialize. + + When `getopt' returns EOF, this is the index of the first of the + non-option elements that the caller should itself scan. + + Otherwise, `optind' communicates from one call to the next + how much of ARGV has been scanned so far. */ + +/* XXX 1003.2 says this must be 1 before any call. */ +int optind = 0; + +/* The next char to be scanned in the option-element + in which the last option character we returned was found. + This allows us to pick up the scan where we left off. + + If this is zero, or a null string, it means resume the scan + by advancing to the next ARGV-element. */ + +static char *nextchar; + +/* Callers store zero here to inhibit the error message + for unrecognized options. */ + +int opterr = 1; + +/* Set to an option character which was unrecognized. + This must be initialized on some systems to avoid linking in the + system's own getopt implementation. */ + +int optopt = '?'; + +/* Describe how to deal with options that follow non-option ARGV-elements. + + If the caller did not specify anything, + the default is REQUIRE_ORDER if the environment variable + POSIXLY_CORRECT is defined, PERMUTE otherwise. + + REQUIRE_ORDER means don't recognize them as options; + stop option processing when the first non-option is seen. + This is what Unix does. + This mode of operation is selected by either setting the environment + variable POSIXLY_CORRECT, or using `+' as the first character + of the list of option characters. + + PERMUTE is the default. We permute the contents of ARGV as we scan, + so that eventually all the non-options are at the end. This allows options + to be given in any order, even with programs that were not written to + expect this. + + RETURN_IN_ORDER is an option available to programs that were written + to expect options and other ARGV-elements in any order and that care about + the ordering of the two. We describe each non-option ARGV-element + as if it were the argument of an option with character code 1. + Using `-' as the first character of the list of option characters + selects this mode of operation. + + The special argument `--' forces an end of option-scanning regardless + of the value of `ordering'. In the case of RETURN_IN_ORDER, only + `--' can cause `getopt' to return EOF with `optind' != ARGC. */ + +static enum +{ + REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER +} ordering; + +/* Value of POSIXLY_CORRECT environment variable. */ +static char *posixly_correct; + +#ifdef __GNU_LIBRARY__ +/* We want to avoid inclusion of string.h with non-GNU libraries + because there are many ways it can cause trouble. + On some systems, it contains special magic macros that don't work + in GCC. */ +#include +#define my_index strchr +#else + +/* Avoid depending on library functions or files + whose names are inconsistent. */ + +char *getenv (); + +static char * +my_index (str, chr) + const char *str; + int chr; +{ + while (*str) + { + if (*str == chr) + return (char *) str; + str++; + } + return 0; +} + +/* If using GCC, we can safely declare strlen this way. + If not using GCC, it is ok not to declare it. */ +#ifdef __GNUC__ +/* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h. + That was relevant to code that was here before. */ +#if !defined (__STDC__) || !__STDC__ +/* gcc with -traditional declares the built-in strlen to return int, + and has done so at least since version 2.4.5. -- rms. */ +extern int strlen (const char *); +#endif /* not __STDC__ */ +#endif /* __GNUC__ */ + +#endif /* not __GNU_LIBRARY__ */ + +/* Handle permutation of arguments. */ + +/* Describe the part of ARGV that contains non-options that have + been skipped. `first_nonopt' is the index in ARGV of the first of them; + `last_nonopt' is the index after the last of them. */ + +static int first_nonopt; +static int last_nonopt; + +/* Bash 2.0 gives us an environment variable containing flags + indicating ARGV elements that should not be considered arguments. */ + +static const char *nonoption_flags; +static int nonoption_flags_len; + +/* Exchange two adjacent subsequences of ARGV. + One subsequence is elements [first_nonopt,last_nonopt) + which contains all the non-options that have been skipped so far. + The other is elements [last_nonopt,optind), which contains all + the options processed since those non-options were skipped. + + `first_nonopt' and `last_nonopt' are relocated so that they describe + the new indices of the non-options in ARGV after they are moved. */ + +#if defined (__STDC__) && __STDC__ +static void exchange (char **); +#endif + +static void +exchange (argv) + char **argv; +{ + int bottom = first_nonopt; + int middle = last_nonopt; + int top = optind; + char *tem; + + /* Exchange the shorter segment with the far end of the longer segment. + That puts the shorter segment into the right place. + It leaves the longer segment in the right place overall, + but it consists of two parts that need to be swapped next. */ + + while (top > middle && middle > bottom) + { + if (top - middle > middle - bottom) + { + /* Bottom segment is the short one. */ + int len = middle - bottom; + register int i; + + /* Swap it with the top part of the top segment. */ + for (i = 0; i < len; i++) + { + tem = argv[bottom + i]; + argv[bottom + i] = argv[top - (middle - bottom) + i]; + argv[top - (middle - bottom) + i] = tem; + } + /* Exclude the moved bottom segment from further swapping. */ + top -= len; + } + else + { + /* Top segment is the short one. */ + int len = top - middle; + register int i; + + /* Swap it with the bottom part of the bottom segment. */ + for (i = 0; i < len; i++) + { + tem = argv[bottom + i]; + argv[bottom + i] = argv[middle + i]; + argv[middle + i] = tem; + } + /* Exclude the moved top segment from further swapping. */ + bottom += len; + } + } + + /* Update records for the slots the non-options now occupy. */ + + first_nonopt += (optind - last_nonopt); + last_nonopt = optind; +} + +/* Initialize the internal data when the first call is made. */ + +#if defined (__STDC__) && __STDC__ +static const char *_getopt_initialize (const char *); +#endif +static const char * +_getopt_initialize (optstring) + const char *optstring; +{ + /* Start processing options with ARGV-element 1 (since ARGV-element 0 + is the program name); the sequence of previously skipped + non-option ARGV-elements is empty. */ + + first_nonopt = last_nonopt = optind = 1; + + nextchar = NULL; + + posixly_correct = getenv ("POSIXLY_CORRECT"); + + /* Determine how to handle the ordering of options and nonoptions. */ + + if (optstring[0] == '-') + { + ordering = RETURN_IN_ORDER; + ++optstring; + } + else if (optstring[0] == '+') + { + ordering = REQUIRE_ORDER; + ++optstring; + } + else if (posixly_correct != NULL) + ordering = REQUIRE_ORDER; + else + ordering = PERMUTE; + + if (posixly_correct == NULL) + { + /* Bash 2.0 puts a special variable in the environment for each + command it runs, specifying which ARGV elements are the results of + file name wildcard expansion and therefore should not be + considered as options. */ + char var[100]; + sprintf (var, "_%d_GNU_nonoption_argv_flags_", getpid ()); + nonoption_flags = getenv (var); + if (nonoption_flags == NULL) + nonoption_flags_len = 0; + else + nonoption_flags_len = strlen (nonoption_flags); + } + + return optstring; +} + +/* Scan elements of ARGV (whose length is ARGC) for option characters + given in OPTSTRING. + + If an element of ARGV starts with '-', and is not exactly "-" or "--", + then it is an option element. The characters of this element + (aside from the initial '-') are option characters. If `getopt' + is called repeatedly, it returns successively each of the option characters + from each of the option elements. + + If `getopt' finds another option character, it returns that character, + updating `optind' and `nextchar' so that the next call to `getopt' can + resume the scan with the following option character or ARGV-element. + + If there are no more option characters, `getopt' returns `EOF'. + Then `optind' is the index in ARGV of the first ARGV-element + that is not an option. (The ARGV-elements have been permuted + so that those that are not options now come last.) + + OPTSTRING is a string containing the legitimate option characters. + If an option character is seen that is not listed in OPTSTRING, + return '?' after printing an error message. If you set `opterr' to + zero, the error message is suppressed but we still return '?'. + + If a char in OPTSTRING is followed by a colon, that means it wants an arg, + so the following text in the same ARGV-element, or the text of the following + ARGV-element, is returned in `optarg'. Two colons mean an option that + wants an optional arg; if there is text in the current ARGV-element, + it is returned in `optarg', otherwise `optarg' is set to zero. + + If OPTSTRING starts with `-' or `+', it requests different methods of + handling the non-option ARGV-elements. + See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above. + + Long-named options begin with `--' instead of `-'. + Their names may be abbreviated as long as the abbreviation is unique + or is an exact match for some defined option. If they have an + argument, it follows the option name in the same ARGV-element, separated + from the option name by a `=', or else the in next ARGV-element. + When `getopt' finds a long-named option, it returns 0 if that option's + `flag' field is nonzero, the value of the option's `val' field + if the `flag' field is zero. + + The elements of ARGV aren't really const, because we permute them. + But we pretend they're const in the prototype to be compatible + with other systems. + + LONGOPTS is a vector of `struct option' terminated by an + element containing a name which is zero. + + LONGIND returns the index in LONGOPT of the long-named option found. + It is only valid when a long-named option has been found by the most + recent call. + + If LONG_ONLY is nonzero, '-' as well as '--' can introduce + long-named options. */ + +int +_getopt_internal (argc, argv, optstring, longopts, longind, long_only) + int argc; + char *const *argv; + const char *optstring; + const struct option *longopts; + int *longind; + int long_only; +{ + optarg = NULL; + + if (optind == 0) + { + optstring = _getopt_initialize (optstring); + optind = 1; /* Don't scan ARGV[0], the program name. */ + } + + /* Test whether ARGV[optind] points to a non-option argument. + Either it does not have option syntax, or there is an environment flag + from the shell indicating it is not an option. */ +#define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0' \ + || (optind < nonoption_flags_len \ + && nonoption_flags[optind] == '1')) + + if (nextchar == NULL || *nextchar == '\0') + { + /* Advance to the next ARGV-element. */ + + /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been + moved back by the user (who may also have changed the arguments). */ + if (last_nonopt > optind) + last_nonopt = optind; + if (first_nonopt > optind) + first_nonopt = optind; + + if (ordering == PERMUTE) + { + /* If we have just processed some options following some non-options, + exchange them so that the options come first. */ + + if (first_nonopt != last_nonopt && last_nonopt != optind) + exchange ((char **) argv); + else if (last_nonopt != optind) + first_nonopt = optind; + + /* Skip any additional non-options + and extend the range of non-options previously skipped. */ + + while (optind < argc && NONOPTION_P) + optind++; + last_nonopt = optind; + } + + /* The special ARGV-element `--' means premature end of options. + Skip it like a null option, + then exchange with previous non-options as if it were an option, + then skip everything else like a non-option. */ + + if (optind != argc && !strcmp (argv[optind], "--")) + { + optind++; + + if (first_nonopt != last_nonopt && last_nonopt != optind) + exchange ((char **) argv); + else if (first_nonopt == last_nonopt) + first_nonopt = optind; + last_nonopt = argc; + + optind = argc; + } + + /* If we have done all the ARGV-elements, stop the scan + and back over any non-options that we skipped and permuted. */ + + if (optind == argc) + { + /* Set the next-arg-index to point at the non-options + that we previously skipped, so the caller will digest them. */ + if (first_nonopt != last_nonopt) + optind = first_nonopt; + return EOF; + } + + /* If we have come to a non-option and did not permute it, + either stop the scan or describe it to the caller and pass it by. */ + + if (NONOPTION_P) + { + if (ordering == REQUIRE_ORDER) + return EOF; + optarg = argv[optind++]; + return 1; + } + + /* We have found another option-ARGV-element. + Skip the initial punctuation. */ + + nextchar = (argv[optind] + 1 + + (longopts != NULL && argv[optind][1] == '-')); + } + + /* Decode the current option-ARGV-element. */ + + /* Check whether the ARGV-element is a long option. + + If long_only and the ARGV-element has the form "-f", where f is + a valid short option, don't consider it an abbreviated form of + a long option that starts with f. Otherwise there would be no + way to give the -f short option. + + On the other hand, if there's a long option "fubar" and + the ARGV-element is "-fu", do consider that an abbreviation of + the long option, just like "--fu", and not "-f" with arg "u". + + This distinction seems to be the most useful approach. */ + + if (longopts != NULL + && (argv[optind][1] == '-' + || (long_only && (argv[optind][2] || !my_index (optstring, argv[optind][1]))))) + { + char *nameend; + const struct option *p; + const struct option *pfound = NULL; + int exact = 0; + int ambig = 0; + int indfound; + int option_index; + + for (nameend = nextchar; *nameend && *nameend != '='; nameend++) + /* Do nothing. */ ; + + /* Test all long options for either exact match + or abbreviated matches. */ + for (p = longopts, option_index = 0; p->name; p++, option_index++) + if (!strncmp (p->name, nextchar, nameend - nextchar)) + { + if (nameend - nextchar == strlen (p->name)) + { + /* Exact match found. */ + pfound = p; + indfound = option_index; + exact = 1; + break; + } + else if (pfound == NULL) + { + /* First nonexact match found. */ + pfound = p; + indfound = option_index; + } + else + /* Second or later nonexact match found. */ + ambig = 1; + } + + if (ambig && !exact) + { + if (opterr) + fprintf (stderr, _("%s: option `%s' is ambiguous\n"), + argv[0], argv[optind]); + nextchar += strlen (nextchar); + optind++; + optopt = 0; + return '?'; + } + + if (pfound != NULL) + { + option_index = indfound; + optind++; + if (*nameend) + { + /* Don't test has_arg with >, because some C compilers don't + allow it to be used on enums. */ + if (pfound->has_arg) + optarg = nameend + 1; + else + { + if (opterr) + if (argv[optind - 1][1] == '-') + /* --option */ + fprintf (stderr, + _("%s: option `--%s' doesn't allow an argument\n"), + argv[0], pfound->name); + else + /* +option or -option */ + fprintf (stderr, + _("%s: option `%c%s' doesn't allow an argument\n"), + argv[0], argv[optind - 1][0], pfound->name); + + nextchar += strlen (nextchar); + + optopt = pfound->val; + return '?'; + } + } + else if (pfound->has_arg == 1) + { + if (optind < argc) + optarg = argv[optind++]; + else + { + if (opterr) + fprintf (stderr, + _("%s: option `%s' requires an argument\n"), + argv[0], argv[optind - 1]); + nextchar += strlen (nextchar); + optopt = pfound->val; + return optstring[0] == ':' ? ':' : '?'; + } + } + nextchar += strlen (nextchar); + if (longind != NULL) + *longind = option_index; + if (pfound->flag) + { + *(pfound->flag) = pfound->val; + return 0; + } + return pfound->val; + } + + /* Can't find it as a long option. If this is not getopt_long_only, + or the option starts with '--' or is not a valid short + option, then it's an error. + Otherwise interpret it as a short option. */ + if (!long_only || argv[optind][1] == '-' + || my_index (optstring, *nextchar) == NULL) + { + if (opterr) + { + if (argv[optind][1] == '-') + /* --option */ + fprintf (stderr, _("%s: unrecognized option `--%s'\n"), + argv[0], nextchar); + else + /* +option or -option */ + fprintf (stderr, _("%s: unrecognized option `%c%s'\n"), + argv[0], argv[optind][0], nextchar); + } + nextchar = (char *) ""; + optind++; + optopt = 0; + return '?'; + } + } + + /* Look at and handle the next short option-character. */ + + { + char c = *nextchar++; + char *temp = my_index (optstring, c); + + /* Increment `optind' when we start to process its last character. */ + if (*nextchar == '\0') + ++optind; + + if (temp == NULL || c == ':') + { + if (opterr) + { + if (posixly_correct) + /* 1003.2 specifies the format of this message. */ + fprintf (stderr, _("%s: illegal option -- %c\n"), + argv[0], c); + else + fprintf (stderr, _("%s: invalid option -- %c\n"), + argv[0], c); + } + optopt = c; + return '?'; + } + if (temp[1] == ':') + { + if (temp[2] == ':') + { + /* This is an option that accepts an argument optionally. */ + if (*nextchar != '\0') + { + optarg = nextchar; + optind++; + } + else + optarg = NULL; + nextchar = NULL; + } + else + { + /* This is an option that requires an argument. */ + if (*nextchar != '\0') + { + optarg = nextchar; + /* If we end this ARGV-element by taking the rest as an arg, + we must advance to the next element now. */ + optind++; + } + else if (optind == argc) + { + if (opterr) + { + /* 1003.2 specifies the format of this message. */ + fprintf (stderr, + _("%s: option requires an argument -- %c\n"), + argv[0], c); + } + optopt = c; + if (optstring[0] == ':') + c = ':'; + else + c = '?'; + } + else + /* We already incremented `optind' once; + increment it again when taking next ARGV-elt as argument. */ + optarg = argv[optind++]; + nextchar = NULL; + } + } + return c; + } +} + +int +getopt (argc, argv, optstring) + int argc; + char *const *argv; + const char *optstring; +{ + return _getopt_internal (argc, argv, optstring, + (const struct option *) 0, + (int *) 0, + 0); +} + +#endif /* _LIBC or not __GNU_LIBRARY__. */ + +#ifdef TEST + +/* Compile with -DTEST to make an executable for use in testing + the above definition of `getopt'. */ + +int +main (argc, argv) + int argc; + char **argv; +{ + int c; + int digit_optind = 0; + + while (1) + { + int this_option_optind = optind ? optind : 1; + + c = getopt (argc, argv, "abc:d:0123456789"); + if (c == EOF) + break; + + switch (c) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + if (digit_optind != 0 && digit_optind != this_option_optind) + printf ("digits occur in two different argv-elements.\n"); + digit_optind = this_option_optind; + printf ("option %c\n", c); + break; + + case 'a': + printf ("option a\n"); + break; + + case 'b': + printf ("option b\n"); + break; + + case 'c': + printf ("option c with value `%s'\n", optarg); + break; + + case '?': + break; + + default: + printf ("?? getopt returned character code 0%o ??\n", c); + } + } + + if (optind < argc) + { + printf ("non-option ARGV-elements: "); + while (optind < argc) + printf ("%s ", argv[optind++]); + printf ("\n"); + } + + exit (0); +} + +#endif /* TEST */ diff --git a/bepascal/bepascal/stubgen.so/getopt.h b/bepascal/bepascal/stubgen.so/getopt.h new file mode 100644 index 0000000..0de1881 --- /dev/null +++ b/bepascal/bepascal/stubgen.so/getopt.h @@ -0,0 +1,130 @@ +/* Declarations for getopt. + Copyright (C) 1989, 90, 91, 92, 93, 94 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by the + Free Software Foundation; either version 2, or (at your option) any + later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, + USA. */ + +#ifndef _GETOPT_H +#define _GETOPT_H 1 + +#ifdef __cplusplus +extern "C" { +#endif + +/* For communication from `getopt' to the caller. + When `getopt' finds an option that takes an argument, + the argument value is returned here. + Also, when `ordering' is RETURN_IN_ORDER, + each non-option ARGV-element is returned here. */ + +extern char *optarg; + +/* Index in ARGV of the next element to be scanned. + This is used for communication to and from the caller + and for communication between successive calls to `getopt'. + + On entry to `getopt', zero means this is the first call; initialize. + + When `getopt' returns EOF, this is the index of the first of the + non-option elements that the caller should itself scan. + + Otherwise, `optind' communicates from one call to the next + how much of ARGV has been scanned so far. */ + +extern int optind; + +/* Callers store zero here to inhibit the error message `getopt' prints + for unrecognized options. */ + +extern int opterr; + +/* Set to an option character which was unrecognized. */ + +extern int optopt; + +/* Describe the long-named options requested by the application. + The LONG_OPTIONS argument to getopt_long or getopt_long_only is a vector + of `struct option' terminated by an element containing a name which is + zero. + + The field `has_arg' is: + no_argument (or 0) if the option does not take an argument, + required_argument (or 1) if the option requires an argument, + optional_argument (or 2) if the option takes an optional argument. + + If the field `flag' is not NULL, it points to a variable that is set + to the value given in the field `val' when the option is found, but + left unchanged if the option is not found. + + To have a long-named option do something other than set an `int' to + a compiled-in constant, such as set a value from `optarg', set the + option's `flag' field to zero and its `val' field to a nonzero + value (the equivalent single-letter option character, if there is + one). For long options that have a zero `flag' field, `getopt' + returns the contents of the `val' field. */ + +struct option +{ +#if defined (__STDC__) && __STDC__ + const char *name; +#else + char *name; +#endif + /* has_arg can't be an enum because some compilers complain about + type mismatches in all the code that assumes it is an int. */ + int has_arg; + int *flag; + int val; +}; + +/* Names for the values of the `has_arg' field of `struct option'. */ + +#define no_argument 0 +#define required_argument 1 +#define optional_argument 2 + +#if defined (__STDC__) && __STDC__ +#ifdef __GNU_LIBRARY__ +/* Many other libraries have conflicting prototypes for getopt, with + differences in the consts, in stdlib.h. To avoid compilation + errors, only prototype getopt for the GNU C library. */ +extern int getopt (int argc, char *const *argv, const char *shortopts); +#else /* not __GNU_LIBRARY__ */ +extern int getopt (); +#endif /* __GNU_LIBRARY__ */ +extern int getopt_long (int argc, char *const *argv, const char *shortopts, + const struct option *longopts, int *longind); +extern int getopt_long_only (int argc, char *const *argv, + const char *shortopts, + const struct option *longopts, int *longind); + +/* Internal only. Users should not call this directly. */ +extern int _getopt_internal (int argc, char *const *argv, + const char *shortopts, + const struct option *longopts, int *longind, + int long_only); +#else /* not __STDC__ */ +extern int getopt (); +extern int getopt_long (); +extern int getopt_long_only (); + +extern int _getopt_internal (); +#endif /* __STDC__ */ + +#ifdef __cplusplus +} +#endif + +#endif /* _GETOPT_H */ diff --git a/bepascal/bepascal/stubgen.so/lex.yy.c b/bepascal/bepascal/stubgen.so/lex.yy.c new file mode 100644 index 0000000..b998e53 --- /dev/null +++ b/bepascal/bepascal/stubgen.so/lex.yy.c @@ -0,0 +1,2652 @@ +/* A lexical scanner generated by flex */ + +/* Scanner skeleton version: + * $Header: /home/haiku/befpc/bepascal/bepascal/stubgen.so/lex.yy.c,v 1.1 2002-09-21 14:12:12 ocoursiere Exp $ + */ + +#define FLEX_SCANNER +#define YY_FLEX_MAJOR_VERSION 2 +#define YY_FLEX_MINOR_VERSION 5 + +#include + + +/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ +#ifdef c_plusplus +#ifndef __cplusplus +#define __cplusplus +#endif +#endif + + +#ifdef __cplusplus + +#include +#include + +/* Use prototypes in function declarations. */ +#define YY_USE_PROTOS + +/* The "const" storage-class-modifier is valid. */ +#define YY_USE_CONST + +#else /* ! __cplusplus */ + +#if __STDC__ + +#define YY_USE_PROTOS +#define YY_USE_CONST + +#endif /* __STDC__ */ +#endif /* ! __cplusplus */ + +#ifdef __TURBOC__ + #pragma warn -rch + #pragma warn -use +#include +#include +#define YY_USE_CONST +#define YY_USE_PROTOS +#endif + +#ifdef YY_USE_CONST +#define yyconst const +#else +#define yyconst +#endif + + +#ifdef YY_USE_PROTOS +#define YY_PROTO(proto) proto +#else +#define YY_PROTO(proto) () +#endif + +/* Returned upon end-of-file. */ +#define YY_NULL 0 + +/* Promotes a possibly negative, possibly signed char to an unsigned + * integer for use as an array index. If the signed char is negative, + * we want to instead treat it as an 8-bit unsigned char, hence the + * double cast. + */ +#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) + +/* Enter a start condition. This macro really ought to take a parameter, + * but we do it the disgusting crufty way forced on us by the ()-less + * definition of BEGIN. + */ +#define BEGIN yy_start = 1 + 2 * + +/* Translate the current start state into a value that can be later handed + * to BEGIN to return to the state. The YYSTATE alias is for lex + * compatibility. + */ +#define YY_START ((yy_start - 1) / 2) +#define YYSTATE YY_START + +/* Action number for EOF rule of a given start state. */ +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) + +/* Special action meaning "start processing a new file". */ +#define YY_NEW_FILE yyrestart( yyin ) + +#define YY_END_OF_BUFFER_CHAR 0 + +/* Size of default input buffer. */ +#define YY_BUF_SIZE 16384 + +typedef struct yy_buffer_state *YY_BUFFER_STATE; + +extern int yyleng; +extern FILE *yyin, *yyout; + +#define EOB_ACT_CONTINUE_SCAN 0 +#define EOB_ACT_END_OF_FILE 1 +#define EOB_ACT_LAST_MATCH 2 + +/* The funky do-while in the following #define is used to turn the definition + * int a single C statement (which needs a semi-colon terminator). This + * avoids problems with code like: + * + * if ( condition_holds ) + * yyless( 5 ); + * else + * do_something_else(); + * + * Prior to using the do-while the compiler would get upset at the + * "else" because it interpreted the "if" statement as being all + * done when it reached the ';' after the yyless() call. + */ + +/* Return all but the first 'n' matched characters back to the input stream. */ + +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + *yy_cp = yy_hold_char; \ + YY_RESTORE_YY_MORE_OFFSET \ + yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \ + YY_DO_BEFORE_ACTION; /* set up yytext again */ \ + } \ + while ( 0 ) + +#define unput(c) yyunput( c, yytext_ptr ) + +/* The following is because we cannot portably get our hands on size_t + * (without autoconf's help, which isn't available because we want + * flex-generated scanners to compile on their own). + */ +typedef unsigned int yy_size_t; + + +struct yy_buffer_state + { + FILE *yy_input_file; + + char *yy_ch_buf; /* input buffer */ + char *yy_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + yy_size_t yy_buf_size; + + /* Number of characters read into yy_ch_buf, not including EOB + * characters. + */ + int yy_n_chars; + + /* Whether we "own" the buffer - i.e., we know we created it, + * and can realloc() it to grow it, and should free() it to + * delete it. + */ + int yy_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int yy_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int yy_at_bol; + + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int yy_fill_buffer; + + int yy_buffer_status; +#define YY_BUFFER_NEW 0 +#define YY_BUFFER_NORMAL 1 + /* When an EOF's been seen but there's still some text to process + * then we mark the buffer as YY_EOF_PENDING, to indicate that we + * shouldn't try reading from the input source any more. We might + * still have a bunch of tokens to match, though, because of + * possible backing-up. + * + * When we actually see the EOF, we change the status to "new" + * (via yyrestart()), so that the user can continue scanning by + * just pointing yyin at a new input file. + */ +#define YY_BUFFER_EOF_PENDING 2 + }; + +static YY_BUFFER_STATE yy_current_buffer = 0; + +/* We provide macros for accessing buffer states in case in the + * future we want to put the buffer states in a more general + * "scanner state". + */ +#define YY_CURRENT_BUFFER yy_current_buffer + + +/* yy_hold_char holds the character lost when yytext is formed. */ +static char yy_hold_char; + +static int yy_n_chars; /* number of characters read into yy_ch_buf */ + + +int yyleng; + +/* Points to current character in buffer. */ +static char *yy_c_buf_p = (char *) 0; +static int yy_init = 1; /* whether we need to initialize */ +static int yy_start = 0; /* start state number */ + +/* Flag which is used to allow yywrap()'s to do buffer switches + * instead of setting up a fresh yyin. A bit of a hack ... + */ +static int yy_did_buffer_switch_on_eof; + +void yyrestart YY_PROTO(( FILE *input_file )); + +void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer )); +void yy_load_buffer_state YY_PROTO(( void )); +YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size )); +void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b )); +void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file )); +void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b )); +#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer ) + +YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size )); +YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str )); +YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len )); + +static void *yy_flex_alloc YY_PROTO(( yy_size_t )); +static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )); +static void yy_flex_free YY_PROTO(( void * )); + +#define yy_new_buffer yy_create_buffer + +#define yy_set_interactive(is_interactive) \ + { \ + if ( ! yy_current_buffer ) \ + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ + yy_current_buffer->yy_is_interactive = is_interactive; \ + } + +#define yy_set_bol(at_bol) \ + { \ + if ( ! yy_current_buffer ) \ + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ + yy_current_buffer->yy_at_bol = at_bol; \ + } + +#define YY_AT_BOL() (yy_current_buffer->yy_at_bol) + +typedef unsigned char YY_CHAR; +FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; +typedef int yy_state_type; +extern char *yytext; +#define yytext_ptr yytext + +static yy_state_type yy_get_previous_state YY_PROTO(( void )); +static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state )); +static int yy_get_next_buffer YY_PROTO(( void )); +static void yy_fatal_error YY_PROTO(( yyconst char msg[] )); + +/* Done after the current pattern has been matched and before the + * corresponding action - sets up yytext. + */ +#define YY_DO_BEFORE_ACTION \ + yytext_ptr = yy_bp; \ + yyleng = (int) (yy_cp - yy_bp); \ + yy_hold_char = *yy_cp; \ + *yy_cp = '\0'; \ + yy_c_buf_p = yy_cp; + +#define YY_NUM_RULES 112 +#define YY_END_OF_BUFFER 113 +static yyconst short int yy_accept[320] = + { 0, + 0, 0, 0, 0, 0, 0, 113, 111, 110, 1, + 86, 111, 4, 92, 85, 111, 80, 81, 90, 89, + 77, 88, 84, 91, 46, 46, 78, 74, 93, 79, + 94, 97, 43, 82, 83, 95, 43, 43, 43, 43, + 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, + 43, 43, 75, 96, 76, 87, 103, 104, 102, 103, + 108, 109, 107, 108, 1, 73, 0, 51, 0, 58, + 68, 59, 0, 0, 56, 64, 54, 65, 55, 66, + 0, 49, 2, 3, 57, 50, 45, 0, 46, 0, + 46, 98, 63, 70, 72, 71, 62, 43, 60, 43, + + 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, + 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, + 43, 43, 43, 43, 43, 43, 43, 43, 43, 61, + 69, 100, 101, 105, 106, 47, 67, 99, 0, 49, + 3, 49, 0, 50, 45, 0, 48, 44, 53, 52, + 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, + 43, 43, 43, 36, 43, 43, 43, 27, 43, 43, + 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, + 43, 43, 43, 43, 43, 43, 101, 106, 0, 49, + 0, 49, 0, 50, 48, 44, 7, 34, 43, 43, + + 43, 43, 43, 43, 13, 43, 43, 43, 43, 43, + 37, 43, 43, 43, 43, 43, 43, 43, 43, 43, + 43, 43, 43, 43, 43, 43, 43, 43, 43, 42, + 43, 0, 49, 25, 14, 43, 43, 43, 43, 43, + 43, 40, 43, 43, 43, 43, 43, 43, 43, 43, + 43, 35, 43, 43, 43, 43, 33, 43, 43, 12, + 43, 17, 43, 43, 26, 43, 43, 41, 43, 8, + 28, 23, 43, 43, 43, 43, 43, 32, 43, 38, + 5, 11, 43, 43, 43, 43, 43, 43, 43, 43, + 43, 22, 43, 43, 31, 43, 43, 43, 10, 43, + + 43, 24, 43, 43, 43, 21, 43, 29, 43, 9, + 15, 16, 39, 6, 19, 20, 18, 30, 0 + } ; + +static yyconst int yy_ec[256] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, + 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 2, 4, 5, 6, 1, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 19, + 19, 19, 19, 19, 19, 19, 19, 20, 21, 22, + 23, 24, 25, 1, 26, 26, 26, 26, 27, 28, + 29, 29, 29, 29, 29, 30, 29, 29, 29, 29, + 29, 29, 29, 29, 31, 29, 29, 32, 29, 29, + 33, 34, 35, 36, 29, 1, 37, 38, 39, 40, + + 41, 42, 43, 44, 45, 29, 29, 46, 47, 48, + 49, 50, 29, 51, 52, 53, 54, 55, 56, 57, + 58, 29, 59, 60, 61, 62, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1 + } ; + +static yyconst int yy_meta[63] = + { 0, + 1, 1, 2, 1, 1, 1, 1, 1, 3, 1, + 1, 1, 1, 1, 1, 1, 1, 4, 4, 1, + 1, 1, 1, 1, 1, 4, 4, 4, 5, 5, + 5, 5, 1, 1, 1, 1, 4, 4, 4, 4, + 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 1, 1, + 1, 1 + } ; + +static yyconst short int yy_base[330] = + { 0, + 0, 0, 60, 61, 62, 66, 468, 469, 469, 0, + 444, 65, 469, 443, 63, 431, 469, 469, 441, 61, + 469, 58, 69, 77, 85, 79, 443, 469, 53, 439, + 67, 469, 0, 469, 469, 438, 406, 75, 81, 45, + 62, 411, 409, 403, 55, 406, 60, 414, 84, 91, + 86, 91, 469, 84, 469, 469, 469, 469, 469, 106, + 469, 469, 469, 129, 0, 469, 138, 469, 451, 469, + 469, 469, 71, 142, 469, 469, 469, 469, 469, 441, + 436, 129, 469, 0, 469, 135, 164, 171, 157, 0, + 182, 469, 428, 469, 469, 469, 427, 0, 469, 396, + + 411, 410, 398, 399, 398, 389, 388, 102, 392, 395, + 114, 391, 385, 390, 380, 394, 119, 396, 390, 383, + 388, 141, 383, 378, 378, 121, 382, 375, 151, 469, + 469, 469, 0, 469, 0, 469, 469, 469, 189, 469, + 0, 197, 216, 469, 191, 201, 214, 216, 469, 469, + 376, 373, 371, 370, 380, 185, 382, 372, 372, 376, + 379, 374, 369, 0, 370, 375, 370, 0, 359, 354, + 355, 361, 361, 354, 356, 350, 348, 351, 351, 358, + 349, 352, 348, 342, 354, 356, 0, 0, 222, 231, + 239, 469, 245, 248, 469, 238, 0, 0, 340, 338, + + 337, 332, 341, 341, 0, 341, 334, 331, 335, 334, + 0, 343, 328, 342, 341, 336, 331, 323, 321, 332, + 327, 332, 324, 313, 110, 320, 324, 323, 311, 0, + 311, 253, 261, 0, 0, 322, 312, 311, 319, 320, + 310, 0, 317, 315, 309, 304, 300, 299, 312, 311, + 293, 0, 301, 297, 277, 282, 0, 265, 268, 0, + 256, 0, 265, 256, 0, 251, 250, 0, 253, 0, + 0, 0, 256, 259, 246, 252, 235, 0, 246, 0, + 0, 0, 233, 243, 236, 241, 235, 229, 223, 214, + 202, 0, 214, 200, 0, 207, 166, 173, 0, 165, + + 159, 0, 152, 132, 126, 0, 133, 0, 129, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 469, 307, + 312, 317, 322, 327, 329, 334, 157, 339, 344 + } ; + +static yyconst short int yy_def[330] = + { 0, + 319, 1, 320, 320, 321, 321, 319, 319, 319, 322, + 319, 323, 319, 319, 319, 324, 319, 319, 319, 319, + 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, + 319, 319, 325, 319, 319, 319, 325, 325, 325, 325, + 325, 325, 325, 325, 325, 325, 325, 325, 325, 325, + 325, 325, 319, 319, 319, 319, 319, 319, 319, 319, + 319, 319, 319, 319, 322, 319, 323, 319, 323, 319, + 319, 319, 324, 324, 319, 319, 319, 319, 319, 319, + 319, 319, 319, 326, 319, 319, 319, 319, 319, 327, + 319, 319, 319, 319, 319, 319, 319, 325, 319, 325, + + 325, 325, 325, 325, 325, 325, 325, 325, 325, 325, + 325, 325, 325, 325, 325, 325, 325, 325, 325, 325, + 325, 325, 325, 325, 325, 325, 325, 325, 325, 319, + 319, 319, 328, 319, 329, 319, 319, 319, 319, 319, + 326, 319, 319, 319, 319, 319, 319, 327, 319, 319, + 325, 325, 325, 325, 325, 325, 325, 325, 325, 325, + 325, 325, 325, 325, 325, 325, 325, 325, 325, 325, + 325, 325, 325, 325, 325, 325, 325, 325, 325, 325, + 325, 325, 325, 325, 325, 325, 328, 329, 319, 319, + 319, 319, 319, 319, 319, 319, 325, 325, 325, 325, + + 325, 325, 325, 325, 325, 325, 325, 325, 325, 325, + 325, 325, 325, 325, 325, 325, 325, 325, 325, 325, + 325, 325, 325, 325, 325, 325, 325, 325, 325, 325, + 325, 319, 319, 325, 325, 325, 325, 325, 325, 325, + 325, 325, 325, 325, 325, 325, 325, 325, 325, 325, + 325, 325, 325, 325, 325, 325, 325, 325, 325, 325, + 325, 325, 325, 325, 325, 325, 325, 325, 325, 325, + 325, 325, 325, 325, 325, 325, 325, 325, 325, 325, + 325, 325, 325, 325, 325, 325, 325, 325, 325, 325, + 325, 325, 325, 325, 325, 325, 325, 325, 325, 325, + + 325, 325, 325, 325, 325, 325, 325, 325, 325, 325, + 325, 325, 325, 325, 325, 325, 325, 325, 0, 319, + 319, 319, 319, 319, 319, 319, 319, 319, 319 + } ; + +static yyconst short int yy_nxt[532] = + { 0, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + 28, 29, 30, 31, 32, 33, 33, 33, 33, 33, + 33, 33, 34, 8, 35, 36, 37, 33, 38, 39, + 40, 41, 33, 33, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 33, 33, 33, 53, 54, + 55, 56, 58, 58, 62, 59, 59, 63, 62, 68, + 71, 63, 78, 76, 93, 94, 60, 60, 64, 136, + 79, 80, 64, 77, 81, 72, 82, 82, 83, 96, + 97, 114, 107, 84, 86, 115, 91, 91, 69, 85, + + 86, 108, 87, 87, 74, 88, 130, 109, 89, 89, + 117, 88, 110, 118, 89, 89, 90, 132, 101, 88, + 102, 104, 133, 103, 89, 88, 105, 120, 121, 106, + 89, 123, 89, 126, 124, 128, 122, 127, 89, 129, + 134, 90, 68, 131, 319, 135, 82, 82, 125, 258, + 73, 159, 142, 142, 160, 139, 140, 259, 140, 163, + 148, 143, 144, 170, 144, 181, 164, 171, 318, 139, + 140, 69, 182, 317, 140, 143, 144, 176, 316, 86, + 144, 87, 87, 146, 315, 146, 89, 89, 147, 147, + 88, 177, 314, 145, 145, 185, 186, 86, 313, 91, + + 91, 189, 89, 189, 88, 312, 190, 190, 88, 145, + 89, 89, 89, 311, 142, 142, 310, 145, 147, 147, + 145, 145, 88, 191, 192, 202, 192, 89, 193, 203, + 193, 147, 147, 194, 194, 89, 145, 191, 192, 190, + 190, 195, 192, 195, 145, 196, 196, 309, 190, 190, + 308, 232, 307, 232, 306, 195, 233, 233, 140, 195, + 140, 196, 194, 194, 305, 194, 194, 196, 196, 196, + 233, 233, 140, 304, 303, 144, 140, 144, 233, 233, + 302, 301, 300, 196, 299, 298, 297, 296, 192, 144, + 192, 196, 295, 144, 294, 293, 292, 291, 290, 289, + + 288, 287, 192, 286, 285, 284, 192, 57, 57, 57, + 57, 57, 61, 61, 61, 61, 61, 65, 283, 65, + 65, 65, 67, 67, 67, 67, 67, 73, 73, 282, + 73, 73, 98, 98, 141, 281, 141, 141, 141, 187, + 280, 187, 187, 187, 188, 279, 188, 188, 188, 278, + 277, 276, 275, 274, 273, 272, 271, 270, 269, 268, + 267, 266, 265, 264, 263, 262, 261, 260, 257, 256, + 255, 254, 253, 252, 251, 250, 249, 248, 247, 246, + 245, 244, 243, 242, 241, 240, 239, 238, 237, 236, + 235, 234, 231, 230, 229, 228, 227, 226, 225, 224, + + 223, 222, 221, 220, 219, 218, 217, 216, 215, 214, + 213, 212, 211, 210, 209, 208, 207, 206, 205, 204, + 201, 200, 199, 198, 197, 184, 183, 180, 179, 178, + 175, 174, 173, 172, 169, 168, 167, 166, 165, 162, + 161, 158, 157, 156, 155, 154, 153, 152, 151, 150, + 149, 138, 137, 319, 119, 116, 113, 112, 111, 100, + 99, 95, 92, 75, 74, 70, 66, 319, 7, 319, + 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, + 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, + 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, + + 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, + 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, + 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, + 319 + } ; + +static yyconst short int yy_chk[532] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 3, 4, 5, 3, 4, 5, 6, 12, + 15, 6, 22, 20, 29, 29, 3, 4, 5, 73, + 22, 22, 6, 20, 23, 15, 23, 23, 24, 31, + 31, 45, 40, 24, 26, 45, 26, 26, 12, 24, + + 25, 40, 25, 25, 73, 26, 54, 41, 26, 26, + 47, 25, 41, 47, 25, 25, 25, 60, 38, 26, + 38, 39, 60, 38, 26, 25, 39, 49, 49, 39, + 25, 50, 26, 51, 50, 52, 49, 51, 25, 52, + 64, 25, 67, 54, 74, 64, 82, 82, 50, 225, + 74, 108, 86, 86, 108, 82, 82, 225, 82, 111, + 327, 86, 86, 117, 86, 126, 111, 117, 309, 82, + 82, 67, 126, 307, 82, 86, 86, 122, 305, 87, + 86, 87, 87, 88, 304, 88, 89, 89, 88, 88, + 87, 122, 303, 87, 87, 129, 129, 91, 301, 91, + + 91, 139, 89, 139, 87, 300, 139, 139, 91, 87, + 89, 91, 91, 298, 142, 142, 297, 87, 146, 146, + 145, 145, 91, 142, 142, 156, 142, 91, 143, 156, + 143, 147, 147, 143, 143, 91, 145, 142, 142, 189, + 189, 147, 142, 147, 145, 148, 148, 296, 190, 190, + 294, 191, 293, 191, 291, 147, 191, 191, 190, 147, + 190, 148, 193, 193, 290, 194, 194, 196, 196, 148, + 232, 232, 190, 289, 288, 194, 190, 194, 233, 233, + 287, 286, 285, 196, 284, 283, 279, 277, 233, 194, + 233, 196, 276, 194, 275, 274, 273, 269, 267, 266, + + 264, 263, 233, 261, 259, 258, 233, 320, 320, 320, + 320, 320, 321, 321, 321, 321, 321, 322, 256, 322, + 322, 322, 323, 323, 323, 323, 323, 324, 324, 255, + 324, 324, 325, 325, 326, 254, 326, 326, 326, 328, + 253, 328, 328, 328, 329, 251, 329, 329, 329, 250, + 249, 248, 247, 246, 245, 244, 243, 241, 240, 239, + 238, 237, 236, 231, 229, 228, 227, 226, 224, 223, + 222, 221, 220, 219, 218, 217, 216, 215, 214, 213, + 212, 210, 209, 208, 207, 206, 204, 203, 202, 201, + 200, 199, 186, 185, 184, 183, 182, 181, 180, 179, + + 178, 177, 176, 175, 174, 173, 172, 171, 170, 169, + 167, 166, 165, 163, 162, 161, 160, 159, 158, 157, + 155, 154, 153, 152, 151, 128, 127, 125, 124, 123, + 121, 120, 119, 118, 116, 115, 114, 113, 112, 110, + 109, 107, 106, 105, 104, 103, 102, 101, 100, 97, + 93, 81, 80, 69, 48, 46, 44, 43, 42, 37, + 36, 30, 27, 19, 16, 14, 11, 7, 319, 319, + 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, + 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, + 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, + + 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, + 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, + 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, + 319 + } ; + +static yy_state_type yy_last_accepting_state; +static char *yy_last_accepting_cpos; + +/* The intent behind this definition is that it'll catch + * any uses of REJECT which flex missed. + */ +#define REJECT reject_used_but_not_detected +#define yymore() yymore_used_but_not_detected +#define YY_MORE_ADJ 0 +#define YY_RESTORE_YY_MORE_OFFSET +char *yytext; +#line 1 "lexer.l" +#define INITIAL 0 +#line 2 "lexer.l" +/* + * FILE: lexer.l + * AUTH: Michael John Radwin + * + * DESC: stubgen lexer. Portions borrowed from Newcastle + * University's Arjuna project (http://arjuna.ncl.ac.uk/), and + * Jeff Lee's ANSI Grammar + * (ftp://ftp.uu.net/usenet/net.sources/ansi.c.grammar.Z) + * + * DATE: Thu Aug 15 13:10:06 EDT 1996 + * $Id: lex.yy.c,v 1.1 2002-09-21 14:12:12 ocoursiere Exp $ + * + * Copyright (c) 1996-1998 Michael John Radwin + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Modification history: + * $Log: not supported by cvs2svn $ + * Revision 1.1 2001/11/07 10:06:07 ithamar + * Added stubgen to CVS + * + * Revision 1.33 1998/07/27 19:16:57 mradwin + * added some c++ keywords + * need to handle typename, using, and namespace + * + * Revision 1.32 1998/05/11 19:49:11 mradwin + * Version 2.03 (updated copyright information). + * + * Revision 1.31 1998/04/07 23:39:55 mradwin + * changed error-handling code significantly. functions + * like count() are now contributing to linebuf so we get correct + * parse error messages during lineno == 1 and other situations. + * also, instead of calling fatal() for collect*() functions, + * we return -1 and let the parser recover more gracefully. + * + * Revision 1.30 1998/01/12 19:39:11 mradwin + * modified rcsid + * + * Revision 1.29 1997/11/13 22:37:31 mradwin + * changed char[] to char * to make non-gcc compilers + * a little happier. We need to #define const to nothing + * for other compilers as well. + * + * Revision 1.28 1997/11/13 21:29:30 mradwin + * moved code from parser.y to main.c + * + * Revision 1.27 1997/11/13 21:10:17 mradwin + * renamed stubgen.[ly] to parser.y lexer.l + * + * Revision 1.26 1997/11/11 03:52:06 mradwin + * changed fatal() + * + * Revision 1.25 1997/11/05 03:02:02 mradwin + * Modified logging routines. + * + * Revision 1.24 1997/11/01 23:12:43 mradwin + * greatly improved error-recovery. errors no longer spill over + * into other files because the yyerror state is properly reset. + * + * Revision 1.23 1997/10/26 23:16:32 mradwin + * changed inform_user and fatal functions to use varargs + * + * Revision 1.22 1997/10/26 22:46:48 mradwin + * support macros within comments, etc. + * + * Revision 1.21 1997/10/16 19:42:48 mradwin + * added support for elipses, static member/array initializers, + * and bitfields. + * + * Revision 1.20 1997/10/16 17:36:06 mradwin + * Fixed compiler warning on win32 from and isspace() + * + * Revision 1.19 1997/10/16 17:12:59 mradwin + * handle extern "C" blocks better now, and support multi-line + * macros. still need error-checking. + * + * Revision 1.18 1997/10/15 22:09:06 mradwin + * changed tons of names. stubelem -> sytaxelem, + * stubin -> infile, stubout -> outfile, stublog -> logfile. + * + * Revision 1.17 1997/10/15 21:45:13 mradwin + * rearranged table.[ch] and util.[ch] so that util pkg + * knows nothing about syntaxelems. + * + * Revision 1.16 1997/10/15 17:42:37 mradwin + * added support for 'extern "C" { ... }' blocks. + * + * Revision 1.15 1997/09/05 19:17:06 mradwin + * works for scanning old versions, except for parameter + * names that differ between .H and .C files. + * + * Revision 1.14 1997/09/05 16:37:41 mradwin + * rcsid + * + * Revision 1.13 1997/09/05 16:34:36 mradwin + * GPL-ized code. + * + * Revision 1.12 1997/09/05 16:13:18 mradwin + * changed email address to acm.org + * + * Revision 1.11 1996/09/12 14:44:49 mjr + * Added throw decl recognition (great, another 4 bytes in syntaxelem) + * and cleaned up the grammar so that const_opt appears in far fewer + * places. const_opt is by default 0 as well, so we don't need to + * pass it as an arg to new_elem(). + * + * I also added a fix to a potential bug with the MINIT and INLIN + * exclusive start states. I think they could have been confused + * by braces within comments, so now I'm grabbing comments in those + * states as well. + * + * Revision 1.10 1996/09/12 03:46:10 mjr + * No concrete changes in code. Just added some sanity by + * factoring out code into util.[ch] and putting some prototypes + * that were in table.h into stubgen.y where they belong. + * + * Revision 1.9 1996/09/01 20:59:48 mjr + * Added collectMemberInitList() function, which is similar + * to collectInlineDef() and also the exclusive state MINIT + * + * Revision 1.8 1996/08/23 05:09:19 mjr + * fixed up some more portability things + * + * Revision 1.7 1996/08/22 02:43:47 mjr + * added parse error message (using O'Reilly p. 274) + * + * Revision 1.6 1996/08/21 18:33:50 mjr + * removed the buffer for inlines. we don't care anyway. + * now we can't overflow on inlines! + * + * Revision 1.5 1996/08/21 17:40:56 mjr + * added some cpp directives for porting to WIN32 + * + * Revision 1.4 1996/08/19 17:01:33 mjr + * no echo now + * + * Revision 1.3 1996/08/15 21:24:58 mjr + * *** empty log message *** + */ +#line 163 "lexer.l" +#include +#include +#include +#include "table.h" +#include "util.h" + +#ifdef WIN32 +/* definitions of exit, malloc, realloc, and free */ +#include +#endif + +#if 0 /* #ifdef WIN32 */ +#include "y_tab.h" +#else +#include "y.tab.h" +#endif + +#ifdef __cplusplus +#define STUB_INPUT() yyinput() +#else +#define STUB_INPUT() input() +#endif + +/* when we return a string, duplicate it so we can free it later. + we always allocate memory so we can uniformly free() it. */ +#define RETURN_STR(x) tokens_seen++; yylval.string = strdup(yytext); return(x) + +/* make that nasty union a value that will bus error if we misinterpret + the value as a pointer */ +#define RETURN_VAL(x) tokens_seen++; yylval.flag = 37; return(x) + +static const char rcsid[] = "$Id: lex.yy.c,v 1.1 2002-09-21 14:12:12 ocoursiere Exp $"; + +static void count(); +static void comment(); +static void macro(); + +char linebuf[1024]; /* null-terminated at beginning of each file */ +int lineno; /* set to 1 at beginning of each file */ +int column; /* set to 0 at beginning of each file */ +int tokens_seen; /* set to 0 at beginning of each file */ + +#define INLIN 1 +#define MINIT 2 + +#line 787 "lex.yy.c" + +/* Macros after this point can all be overridden by user definitions in + * section 1. + */ + +#ifndef YY_SKIP_YYWRAP +#ifdef __cplusplus +extern "C" int yywrap YY_PROTO(( void )); +#else +extern int yywrap YY_PROTO(( void )); +#endif +#endif + +#ifndef YY_NO_UNPUT +static void yyunput YY_PROTO(( int c, char *buf_ptr )); +#endif + +#ifndef yytext_ptr +static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int )); +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen YY_PROTO(( yyconst char * )); +#endif + +#ifndef YY_NO_INPUT +#ifdef __cplusplus +static int yyinput YY_PROTO(( void )); +#else +static int input YY_PROTO(( void )); +#endif +#endif + +#if YY_STACK_USED +static int yy_start_stack_ptr = 0; +static int yy_start_stack_depth = 0; +static int *yy_start_stack = 0; +#ifndef YY_NO_PUSH_STATE +static void yy_push_state YY_PROTO(( int new_state )); +#endif +#ifndef YY_NO_POP_STATE +static void yy_pop_state YY_PROTO(( void )); +#endif +#ifndef YY_NO_TOP_STATE +static int yy_top_state YY_PROTO(( void )); +#endif + +#else +#define YY_NO_PUSH_STATE 1 +#define YY_NO_POP_STATE 1 +#define YY_NO_TOP_STATE 1 +#endif + +#ifdef YY_MALLOC_DECL +YY_MALLOC_DECL +#else +#if __STDC__ +#ifndef __cplusplus +#include +#endif +#else +/* Just try to get by without declaring the routines. This will fail + * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int) + * or sizeof(void*) != sizeof(int). + */ +#endif +#endif + +/* Amount of stuff to slurp up with each read. */ +#ifndef YY_READ_BUF_SIZE +#define YY_READ_BUF_SIZE 8192 +#endif + +/* Copy whatever the last rule matched to the standard output. */ + +#ifndef ECHO +/* This used to be an fputs(), but since the string might contain NUL's, + * we now use fwrite(). + */ +#define ECHO (void) fwrite( yytext, yyleng, 1, yyout ) +#endif + +/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, + * is returned in "result". + */ +#ifndef YY_INPUT +#define YY_INPUT(buf,result,max_size) \ + if ( yy_current_buffer->yy_is_interactive ) \ + { \ + int c = '*', n; \ + for ( n = 0; n < max_size && \ + (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ + buf[n] = (char) c; \ + if ( c == '\n' ) \ + buf[n++] = (char) c; \ + if ( c == EOF && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + result = n; \ + } \ + else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \ + && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); +#endif + +/* No semi-colon after return; correct usage is to write "yyterminate();" - + * we don't want an extra ';' after the "return" because that will cause + * some compilers to complain about unreachable statements. + */ +#ifndef yyterminate +#define yyterminate() return YY_NULL +#endif + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* Report a fatal error. */ +#ifndef YY_FATAL_ERROR +#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) +#endif + +/* Default declaration of generated scanner - a define so the user can + * easily add parameters. + */ +#ifndef YY_DECL +#define YY_DECL int yylex YY_PROTO(( void )) +#endif + +/* Code executed at the beginning of each rule, after yytext and yyleng + * have been set up. + */ +#ifndef YY_USER_ACTION +#define YY_USER_ACTION +#endif + +/* Code executed at the end of each rule. */ +#ifndef YY_BREAK +#define YY_BREAK break; +#endif + +#define YY_RULE_SETUP \ + YY_USER_ACTION + +YY_DECL + { + register yy_state_type yy_current_state; + register char *yy_cp, *yy_bp; + register int yy_act; + +#line 208 "lexer.l" + +#line 940 "lex.yy.c" + + if ( yy_init ) + { + yy_init = 0; + +#ifdef YY_USER_INIT + YY_USER_INIT; +#endif + + if ( ! yy_start ) + yy_start = 1; /* first start state */ + + if ( ! yyin ) + yyin = stdin; + + if ( ! yyout ) + yyout = stdout; + + if ( ! yy_current_buffer ) + yy_current_buffer = + yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_load_buffer_state(); + } + + while ( 1 ) /* loops until end-of-file is reached */ + { + yy_cp = yy_c_buf_p; + + /* Support of yytext. */ + *yy_cp = yy_hold_char; + + /* yy_bp points to the position in yy_ch_buf of the start of + * the current run. + */ + yy_bp = yy_cp; + + yy_current_state = yy_start; +yy_match: + do + { + register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 320 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + ++yy_cp; + } + while ( yy_base[yy_current_state] != 469 ); + +yy_find_action: + yy_act = yy_accept[yy_current_state]; + if ( yy_act == 0 ) + { /* have to back up */ + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + yy_act = yy_accept[yy_current_state]; + } + + YY_DO_BEFORE_ACTION; + + +do_action: /* This label is used only to access EOF actions. */ + + + switch ( yy_act ) + { /* beginning of action switch */ + case 0: /* must back up */ + /* undo the effects of YY_DO_BEFORE_ACTION */ + *yy_cp = yy_hold_char; + yy_cp = yy_last_accepting_cpos; + yy_current_state = yy_last_accepting_state; + goto yy_find_action; + +case 1: +YY_RULE_SETUP +#line 209 "lexer.l" +{ /* + * for debugging purposes, we grab an entire + * line and buffer it, then grab tokens out of + * it. This lets us have more informative + * error messages. See yyerror() in parser.y + */ + strncpy(linebuf, yytext+1, 1024); + lineno++; + column = 0; + yyless(1); /* give back everything but \n */ + } + YY_BREAK +case 2: +YY_RULE_SETUP +#line 220 "lexer.l" +{ comment(); } + YY_BREAK +case 3: +YY_RULE_SETUP +#line 222 "lexer.l" +{ count(); } + YY_BREAK +case 4: +YY_RULE_SETUP +#line 223 "lexer.l" +{ macro(); /* was #.* { count(); } */ } + YY_BREAK +case 5: +YY_RULE_SETUP +#line 225 "lexer.l" +{ count(); tokens_seen++; } + YY_BREAK +case 6: +YY_RULE_SETUP +#line 226 "lexer.l" +{ count(); tokens_seen++; } + YY_BREAK +case 7: +YY_RULE_SETUP +#line 227 "lexer.l" +{ count(); tokens_seen++; } + YY_BREAK +case 8: +YY_RULE_SETUP +#line 228 "lexer.l" +{ count(); RETURN_VAL(EXTERN); } + YY_BREAK +case 9: +YY_RULE_SETUP +#line 229 "lexer.l" +{ count(); tokens_seen++; } + YY_BREAK +case 10: +YY_RULE_SETUP +#line 230 "lexer.l" +{ count(); tokens_seen++; } + YY_BREAK +case 11: +YY_RULE_SETUP +#line 231 "lexer.l" +{ count(); RETURN_VAL(STRUCT); } + YY_BREAK +case 12: +YY_RULE_SETUP +#line 232 "lexer.l" +{ count(); RETURN_VAL(UNION); } + YY_BREAK +case 13: +YY_RULE_SETUP +#line 233 "lexer.l" +{ count(); RETURN_VAL(ENUM); } + YY_BREAK +case 14: +YY_RULE_SETUP +#line 234 "lexer.l" +{ count(); RETURN_VAL(CONST); } + YY_BREAK +case 15: +YY_RULE_SETUP +#line 235 "lexer.l" +{ count(); RETURN_VAL(TEMPLATE); } + YY_BREAK +case 16: +YY_RULE_SETUP +#line 237 "lexer.l" +{ count(); tokens_seen++; /* FIXME */ } + YY_BREAK +case 17: +YY_RULE_SETUP +#line 238 "lexer.l" +{ count(); tokens_seen++; /* FIXME */ } + YY_BREAK +case 18: +YY_RULE_SETUP +#line 239 "lexer.l" +{ count(); RETURN_VAL(CLASS); /* FIXME */ } + YY_BREAK +case 19: +YY_RULE_SETUP +#line 241 "lexer.l" +{ count(); tokens_seen++; } + YY_BREAK +case 20: +YY_RULE_SETUP +#line 242 "lexer.l" +{ count(); tokens_seen++; } + YY_BREAK +case 21: +YY_RULE_SETUP +#line 244 "lexer.l" +{ count(); tokens_seen++; } + YY_BREAK +case 22: +YY_RULE_SETUP +#line 245 "lexer.l" +{ count(); tokens_seen++; } + YY_BREAK +case 23: +YY_RULE_SETUP +#line 246 "lexer.l" +{ count(); tokens_seen++; } + YY_BREAK +case 24: +YY_RULE_SETUP +#line 247 "lexer.l" +{ count(); tokens_seen++; } + YY_BREAK +case 25: +YY_RULE_SETUP +#line 248 "lexer.l" +{ count(); RETURN_VAL(CLASS); } + YY_BREAK +case 26: +YY_RULE_SETUP +#line 249 "lexer.l" +{ count(); RETURN_VAL(DELETE); } + YY_BREAK +case 27: +YY_RULE_SETUP +#line 250 "lexer.l" +{ count(); RETURN_VAL(NEW); } + YY_BREAK +case 28: +YY_RULE_SETUP +#line 251 "lexer.l" +{ count(); RETURN_VAL(FRIEND); } + YY_BREAK +case 29: +YY_RULE_SETUP +#line 252 "lexer.l" +{ count(); RETURN_VAL(OPERATOR); } + YY_BREAK +case 30: +YY_RULE_SETUP +#line 253 "lexer.l" +{ count(); RETURN_VAL(PROTECTED); } + YY_BREAK +case 31: +YY_RULE_SETUP +#line 254 "lexer.l" +{ count(); RETURN_VAL(PRIVATE); } + YY_BREAK +case 32: +YY_RULE_SETUP +#line 255 "lexer.l" +{ count(); RETURN_VAL(PUBLIC); } + YY_BREAK +case 33: +YY_RULE_SETUP +#line 256 "lexer.l" +{ count(); RETURN_VAL(THROW); } + YY_BREAK +case 34: +YY_RULE_SETUP +#line 258 "lexer.l" +{ count(); RETURN_STR(CHAR); } + YY_BREAK +case 35: +YY_RULE_SETUP +#line 259 "lexer.l" +{ count(); RETURN_STR(SHORT); } + YY_BREAK +case 36: +YY_RULE_SETUP +#line 260 "lexer.l" +{ count(); RETURN_STR(INT); } + YY_BREAK +case 37: +YY_RULE_SETUP +#line 261 "lexer.l" +{ count(); RETURN_STR(LONG); } + YY_BREAK +case 38: +YY_RULE_SETUP +#line 262 "lexer.l" +{ count(); RETURN_STR(SIGNED); } + YY_BREAK +case 39: +YY_RULE_SETUP +#line 263 "lexer.l" +{ count(); RETURN_STR(UNSIGNED); } + YY_BREAK +case 40: +YY_RULE_SETUP +#line 264 "lexer.l" +{ count(); RETURN_STR(FLOAT); } + YY_BREAK +case 41: +YY_RULE_SETUP +#line 265 "lexer.l" +{ count(); RETURN_STR(DOUBLE); } + YY_BREAK +case 42: +YY_RULE_SETUP +#line 266 "lexer.l" +{ count(); RETURN_STR(VOID); } + YY_BREAK +case 43: +YY_RULE_SETUP +#line 268 "lexer.l" +{ count(); RETURN_STR(IDENTIFIER); } + YY_BREAK +case 44: +YY_RULE_SETUP +#line 270 "lexer.l" +{ count(); RETURN_STR(CONSTANT); } + YY_BREAK +case 45: +YY_RULE_SETUP +#line 271 "lexer.l" +{ count(); RETURN_STR(CONSTANT); } + YY_BREAK +case 46: +YY_RULE_SETUP +#line 272 "lexer.l" +{ count(); RETURN_STR(CONSTANT); } + YY_BREAK +case 47: +YY_RULE_SETUP +#line 273 "lexer.l" +{ count(); RETURN_STR(CONSTANT); /* 'fontlck */ } + YY_BREAK +case 48: +YY_RULE_SETUP +#line 275 "lexer.l" +{ count(); RETURN_STR(CONSTANT); } + YY_BREAK +case 49: +YY_RULE_SETUP +#line 276 "lexer.l" +{ count(); RETURN_STR(CONSTANT); } + YY_BREAK +case 50: +YY_RULE_SETUP +#line 277 "lexer.l" +{ count(); RETURN_STR(CONSTANT); } + YY_BREAK +case 51: +YY_RULE_SETUP +#line 279 "lexer.l" +{ count(); RETURN_STR(STRING_LITERAL); /* "fontlck */ } + YY_BREAK +case 52: +YY_RULE_SETUP +#line 281 "lexer.l" +{ count(); RETURN_VAL(RIGHT_ASSIGN); } + YY_BREAK +case 53: +YY_RULE_SETUP +#line 282 "lexer.l" +{ count(); RETURN_VAL(LEFT_ASSIGN); } + YY_BREAK +case 54: +YY_RULE_SETUP +#line 283 "lexer.l" +{ count(); RETURN_VAL(ADD_ASSIGN); } + YY_BREAK +case 55: +YY_RULE_SETUP +#line 284 "lexer.l" +{ count(); RETURN_VAL(SUB_ASSIGN); } + YY_BREAK +case 56: +YY_RULE_SETUP +#line 285 "lexer.l" +{ count(); RETURN_VAL(MUL_ASSIGN); } + YY_BREAK +case 57: +YY_RULE_SETUP +#line 286 "lexer.l" +{ count(); RETURN_VAL(DIV_ASSIGN); } + YY_BREAK +case 58: +YY_RULE_SETUP +#line 287 "lexer.l" +{ count(); RETURN_VAL(MOD_ASSIGN); } + YY_BREAK +case 59: +YY_RULE_SETUP +#line 288 "lexer.l" +{ count(); RETURN_VAL(AND_ASSIGN); } + YY_BREAK +case 60: +YY_RULE_SETUP +#line 289 "lexer.l" +{ count(); RETURN_VAL(XOR_ASSIGN); } + YY_BREAK +case 61: +YY_RULE_SETUP +#line 290 "lexer.l" +{ count(); RETURN_VAL(OR_ASSIGN); } + YY_BREAK +case 62: +YY_RULE_SETUP +#line 291 "lexer.l" +{ count(); RETURN_VAL(RIGHT_OP); } + YY_BREAK +case 63: +YY_RULE_SETUP +#line 292 "lexer.l" +{ count(); RETURN_VAL(LEFT_OP); } + YY_BREAK +case 64: +YY_RULE_SETUP +#line 293 "lexer.l" +{ count(); RETURN_VAL(INC_OP); } + YY_BREAK +case 65: +YY_RULE_SETUP +#line 294 "lexer.l" +{ count(); RETURN_VAL(DEC_OP); } + YY_BREAK +case 66: +YY_RULE_SETUP +#line 295 "lexer.l" +{ count(); RETURN_VAL(PTR_OP); } + YY_BREAK +case 67: +YY_RULE_SETUP +#line 296 "lexer.l" +{ count(); RETURN_VAL(MEM_PTR_OP); } + YY_BREAK +case 68: +YY_RULE_SETUP +#line 297 "lexer.l" +{ count(); RETURN_VAL(AND_OP); } + YY_BREAK +case 69: +YY_RULE_SETUP +#line 298 "lexer.l" +{ count(); RETURN_VAL(OR_OP); } + YY_BREAK +case 70: +YY_RULE_SETUP +#line 299 "lexer.l" +{ count(); RETURN_VAL(LE_OP); } + YY_BREAK +case 71: +YY_RULE_SETUP +#line 300 "lexer.l" +{ count(); RETURN_VAL(GE_OP); } + YY_BREAK +case 72: +YY_RULE_SETUP +#line 301 "lexer.l" +{ count(); RETURN_VAL(EQ_OP); } + YY_BREAK +case 73: +YY_RULE_SETUP +#line 302 "lexer.l" +{ count(); RETURN_VAL(NE_OP); } + YY_BREAK +case 74: +YY_RULE_SETUP +#line 303 "lexer.l" +{ count(); RETURN_VAL(';'); } + YY_BREAK +case 75: +YY_RULE_SETUP +#line 304 "lexer.l" +{ count(); RETURN_VAL('{'); } + YY_BREAK +case 76: +YY_RULE_SETUP +#line 305 "lexer.l" +{ count(); RETURN_VAL('}'); } + YY_BREAK +case 77: +YY_RULE_SETUP +#line 306 "lexer.l" +{ count(); RETURN_VAL(','); } + YY_BREAK +case 78: +YY_RULE_SETUP +#line 307 "lexer.l" +{ count(); RETURN_VAL(':'); } + YY_BREAK +case 79: +YY_RULE_SETUP +#line 308 "lexer.l" +{ count(); RETURN_VAL('='); } + YY_BREAK +case 80: +YY_RULE_SETUP +#line 309 "lexer.l" +{ count(); RETURN_VAL('('); } + YY_BREAK +case 81: +YY_RULE_SETUP +#line 310 "lexer.l" +{ count(); RETURN_VAL(')'); } + YY_BREAK +case 82: +YY_RULE_SETUP +#line 311 "lexer.l" +{ count(); RETURN_VAL('['); } + YY_BREAK +case 83: +YY_RULE_SETUP +#line 312 "lexer.l" +{ count(); RETURN_VAL(']'); } + YY_BREAK +case 84: +YY_RULE_SETUP +#line 313 "lexer.l" +{ count(); RETURN_VAL('.'); } + YY_BREAK +case 85: +YY_RULE_SETUP +#line 314 "lexer.l" +{ count(); RETURN_VAL('&'); } + YY_BREAK +case 86: +YY_RULE_SETUP +#line 315 "lexer.l" +{ count(); RETURN_VAL('!'); } + YY_BREAK +case 87: +YY_RULE_SETUP +#line 316 "lexer.l" +{ count(); RETURN_VAL('~'); } + YY_BREAK +case 88: +YY_RULE_SETUP +#line 317 "lexer.l" +{ count(); RETURN_VAL('-'); } + YY_BREAK +case 89: +YY_RULE_SETUP +#line 318 "lexer.l" +{ count(); RETURN_VAL('+'); } + YY_BREAK +case 90: +YY_RULE_SETUP +#line 319 "lexer.l" +{ count(); RETURN_VAL('*'); } + YY_BREAK +case 91: +YY_RULE_SETUP +#line 320 "lexer.l" +{ count(); RETURN_VAL('/'); } + YY_BREAK +case 92: +YY_RULE_SETUP +#line 321 "lexer.l" +{ count(); RETURN_VAL('%'); } + YY_BREAK +case 93: +YY_RULE_SETUP +#line 322 "lexer.l" +{ count(); RETURN_VAL('<'); } + YY_BREAK +case 94: +YY_RULE_SETUP +#line 323 "lexer.l" +{ count(); RETURN_VAL('>'); } + YY_BREAK +case 95: +YY_RULE_SETUP +#line 324 "lexer.l" +{ count(); RETURN_VAL('^'); } + YY_BREAK +case 96: +YY_RULE_SETUP +#line 325 "lexer.l" +{ count(); RETURN_VAL('|'); } + YY_BREAK +case 97: +YY_RULE_SETUP +#line 326 "lexer.l" +{ count(); RETURN_VAL('?'); } + YY_BREAK +case 98: +YY_RULE_SETUP +#line 327 "lexer.l" +{ count(); RETURN_VAL(CLCL); } + YY_BREAK +case 99: +YY_RULE_SETUP +#line 328 "lexer.l" +{ count(); RETURN_VAL(ELIPSIS); } + YY_BREAK +case 100: +YY_RULE_SETUP +#line 330 "lexer.l" +{ comment(); } + YY_BREAK +case 101: +YY_RULE_SETUP +#line 331 "lexer.l" +{ count(); } + YY_BREAK +case 102: +YY_RULE_SETUP +#line 332 "lexer.l" +{ macro(); /* was #.* { count(); } */ } + YY_BREAK +case 103: +#line 334 "lexer.l" +case 104: +YY_RULE_SETUP +#line 334 "lexer.l" +{ RETURN_VAL((int) yytext[0]); } + YY_BREAK +case 105: +YY_RULE_SETUP +#line 336 "lexer.l" +{ comment(); } + YY_BREAK +case 106: +YY_RULE_SETUP +#line 337 "lexer.l" +{ count(); } + YY_BREAK +case 107: +YY_RULE_SETUP +#line 338 "lexer.l" +{ macro(); /* was #.* { count(); } */ } + YY_BREAK +case 108: +#line 340 "lexer.l" +case 109: +YY_RULE_SETUP +#line 340 "lexer.l" +{ RETURN_VAL((int) yytext[0]); } + YY_BREAK +case 110: +YY_RULE_SETUP +#line 342 "lexer.l" +{ count(); } + YY_BREAK +case 111: +YY_RULE_SETUP +#line 343 "lexer.l" +{ count(); /* ignore bad characters */ } + YY_BREAK +case 112: +YY_RULE_SETUP +#line 345 "lexer.l" +ECHO; + YY_BREAK +#line 1587 "lex.yy.c" +case YY_STATE_EOF(INITIAL): +case YY_STATE_EOF(INLIN): +case YY_STATE_EOF(MINIT): + yyterminate(); + + case YY_END_OF_BUFFER: + { + /* Amount of text matched not including the EOB char. */ + int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1; + + /* Undo the effects of YY_DO_BEFORE_ACTION. */ + *yy_cp = yy_hold_char; + YY_RESTORE_YY_MORE_OFFSET + + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW ) + { + /* We're scanning a new file or input source. It's + * possible that this happened because the user + * just pointed yyin at a new source and called + * yylex(). If so, then we have to assure + * consistency between yy_current_buffer and our + * globals. Here is the right place to do so, because + * this is the first action (other than possibly a + * back-up) that will match for the new input source. + */ + yy_n_chars = yy_current_buffer->yy_n_chars; + yy_current_buffer->yy_input_file = yyin; + yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL; + } + + /* Note that here we test for yy_c_buf_p "<=" to the position + * of the first EOB in the buffer, since yy_c_buf_p will + * already have been incremented past the NUL character + * (since all states make transitions on EOB to the + * end-of-buffer state). Contrast this with the test + * in input(). + */ + if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + { /* This was really a NUL. */ + yy_state_type yy_next_state; + + yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + /* Okay, we're now positioned to make the NUL + * transition. We couldn't have + * yy_get_previous_state() go ahead and do it + * for us because it doesn't know how to deal + * with the possibility of jamming (and we don't + * want to build jamming into it because then it + * will run more slowly). + */ + + yy_next_state = yy_try_NUL_trans( yy_current_state ); + + yy_bp = yytext_ptr + YY_MORE_ADJ; + + if ( yy_next_state ) + { + /* Consume the NUL. */ + yy_cp = ++yy_c_buf_p; + yy_current_state = yy_next_state; + goto yy_match; + } + + else + { + yy_cp = yy_c_buf_p; + goto yy_find_action; + } + } + + else switch ( yy_get_next_buffer() ) + { + case EOB_ACT_END_OF_FILE: + { + yy_did_buffer_switch_on_eof = 0; + + if ( yywrap() ) + { + /* Note: because we've taken care in + * yy_get_next_buffer() to have set up + * yytext, we can now set up + * yy_c_buf_p so that if some total + * hoser (like flex itself) wants to + * call the scanner after we return the + * YY_NULL, it'll still work - another + * YY_NULL will get returned. + */ + yy_c_buf_p = yytext_ptr + YY_MORE_ADJ; + + yy_act = YY_STATE_EOF(YY_START); + goto do_action; + } + + else + { + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; + } + break; + } + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = + yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext_ptr + YY_MORE_ADJ; + goto yy_match; + + case EOB_ACT_LAST_MATCH: + yy_c_buf_p = + &yy_current_buffer->yy_ch_buf[yy_n_chars]; + + yy_current_state = yy_get_previous_state(); + + yy_cp = yy_c_buf_p; + yy_bp = yytext_ptr + YY_MORE_ADJ; + goto yy_find_action; + } + break; + } + + default: + YY_FATAL_ERROR( + "fatal flex scanner internal error--no action found" ); + } /* end of action switch */ + } /* end of scanning one token */ + } /* end of yylex */ + + +/* yy_get_next_buffer - try to read in a new buffer + * + * Returns a code representing an action: + * EOB_ACT_LAST_MATCH - + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position + * EOB_ACT_END_OF_FILE - end of file + */ + +static int yy_get_next_buffer() + { + register char *dest = yy_current_buffer->yy_ch_buf; + register char *source = yytext_ptr; + register int number_to_move, i; + int ret_val; + + if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) + YY_FATAL_ERROR( + "fatal flex scanner internal error--end of buffer missed" ); + + if ( yy_current_buffer->yy_fill_buffer == 0 ) + { /* Don't try to fill the buffer, so this is an EOF. */ + if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 ) + { + /* We matched a single character, the EOB, so + * treat this as a final EOF. + */ + return EOB_ACT_END_OF_FILE; + } + + else + { + /* We matched some text prior to the EOB, first + * process it. + */ + return EOB_ACT_LAST_MATCH; + } + } + + /* Try to read more data. */ + + /* First move last chars to start of buffer. */ + number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1; + + for ( i = 0; i < number_to_move; ++i ) + *(dest++) = *(source++); + + if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING ) + /* don't do the read, it's not guaranteed to return an EOF, + * just force an EOF + */ + yy_current_buffer->yy_n_chars = yy_n_chars = 0; + + else + { + int num_to_read = + yy_current_buffer->yy_buf_size - number_to_move - 1; + + while ( num_to_read <= 0 ) + { /* Not enough room in the buffer - grow it. */ +#ifdef YY_USES_REJECT + YY_FATAL_ERROR( +"input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); +#else + + /* just a shorter name for the current buffer */ + YY_BUFFER_STATE b = yy_current_buffer; + + int yy_c_buf_p_offset = + (int) (yy_c_buf_p - b->yy_ch_buf); + + if ( b->yy_is_our_buffer ) + { + int new_size = b->yy_buf_size * 2; + + if ( new_size <= 0 ) + b->yy_buf_size += b->yy_buf_size / 8; + else + b->yy_buf_size *= 2; + + b->yy_ch_buf = (char *) + /* Include room in for 2 EOB chars. */ + yy_flex_realloc( (void *) b->yy_ch_buf, + b->yy_buf_size + 2 ); + } + else + /* Can't grow it, we don't own it. */ + b->yy_ch_buf = 0; + + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( + "fatal error - scanner input buffer overflow" ); + + yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; + + num_to_read = yy_current_buffer->yy_buf_size - + number_to_move - 1; +#endif + } + + if ( num_to_read > YY_READ_BUF_SIZE ) + num_to_read = YY_READ_BUF_SIZE; + + /* Read in more data. */ + YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]), + yy_n_chars, num_to_read ); + + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + if ( yy_n_chars == 0 ) + { + if ( number_to_move == YY_MORE_ADJ ) + { + ret_val = EOB_ACT_END_OF_FILE; + yyrestart( yyin ); + } + + else + { + ret_val = EOB_ACT_LAST_MATCH; + yy_current_buffer->yy_buffer_status = + YY_BUFFER_EOF_PENDING; + } + } + + else + ret_val = EOB_ACT_CONTINUE_SCAN; + + yy_n_chars += number_to_move; + yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; + yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; + + yytext_ptr = &yy_current_buffer->yy_ch_buf[0]; + + return ret_val; + } + + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + +static yy_state_type yy_get_previous_state() + { + register yy_state_type yy_current_state; + register char *yy_cp; + + yy_current_state = yy_start; + + for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) + { + register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 320 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + } + + return yy_current_state; + } + + +/* yy_try_NUL_trans - try to make a transition on the NUL character + * + * synopsis + * next_state = yy_try_NUL_trans( current_state ); + */ + +#ifdef YY_USE_PROTOS +static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state ) +#else +static yy_state_type yy_try_NUL_trans( yy_current_state ) +yy_state_type yy_current_state; +#endif + { + register int yy_is_jam; + register char *yy_cp = yy_c_buf_p; + + register YY_CHAR yy_c = 1; + if ( yy_accept[yy_current_state] ) + { + yy_last_accepting_state = yy_current_state; + yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 320 ) + yy_c = yy_meta[(unsigned int) yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; + yy_is_jam = (yy_current_state == 319); + + return yy_is_jam ? 0 : yy_current_state; + } + + +#ifndef YY_NO_UNPUT +#ifdef YY_USE_PROTOS +static void yyunput( int c, register char *yy_bp ) +#else +static void yyunput( c, yy_bp ) +int c; +register char *yy_bp; +#endif + { + register char *yy_cp = yy_c_buf_p; + + /* undo effects of setting up yytext */ + *yy_cp = yy_hold_char; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + { /* need to shift things up to make room */ + /* +2 for EOB chars. */ + register int number_to_move = yy_n_chars + 2; + register char *dest = &yy_current_buffer->yy_ch_buf[ + yy_current_buffer->yy_buf_size + 2]; + register char *source = + &yy_current_buffer->yy_ch_buf[number_to_move]; + + while ( source > yy_current_buffer->yy_ch_buf ) + *--dest = *--source; + + yy_cp += (int) (dest - source); + yy_bp += (int) (dest - source); + yy_current_buffer->yy_n_chars = + yy_n_chars = yy_current_buffer->yy_buf_size; + + if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) + YY_FATAL_ERROR( "flex scanner push-back overflow" ); + } + + *--yy_cp = (char) c; + + + yytext_ptr = yy_bp; + yy_hold_char = *yy_cp; + yy_c_buf_p = yy_cp; + } +#endif /* ifndef YY_NO_UNPUT */ + + +#ifdef __cplusplus +static int yyinput() +#else +static int input() +#endif + { + int c; + + *yy_c_buf_p = yy_hold_char; + + if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) + { + /* yy_c_buf_p now points to the character we want to return. + * If this occurs *before* the EOB characters, then it's a + * valid NUL; if not, then we've hit the end of the buffer. + */ + if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + /* This was really a NUL. */ + *yy_c_buf_p = '\0'; + + else + { /* need more input */ + int offset = yy_c_buf_p - yytext_ptr; + ++yy_c_buf_p; + + switch ( yy_get_next_buffer() ) + { + case EOB_ACT_LAST_MATCH: + /* This happens because yy_g_n_b() + * sees that we've accumulated a + * token and flags that we need to + * try matching the token before + * proceeding. But for input(), + * there's no matching to consider. + * So convert the EOB_ACT_LAST_MATCH + * to EOB_ACT_END_OF_FILE. + */ + + /* Reset buffer status. */ + yyrestart( yyin ); + + /* fall through */ + + case EOB_ACT_END_OF_FILE: + { + if ( yywrap() ) + return EOF; + + if ( ! yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; +#ifdef __cplusplus + return yyinput(); +#else + return input(); +#endif + } + + case EOB_ACT_CONTINUE_SCAN: + yy_c_buf_p = yytext_ptr + offset; + break; + } + } + } + + c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */ + *yy_c_buf_p = '\0'; /* preserve yytext */ + yy_hold_char = *++yy_c_buf_p; + + + return c; + } + + +#ifdef YY_USE_PROTOS +void yyrestart( FILE *input_file ) +#else +void yyrestart( input_file ) +FILE *input_file; +#endif + { + if ( ! yy_current_buffer ) + yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); + + yy_init_buffer( yy_current_buffer, input_file ); + yy_load_buffer_state(); + } + + +#ifdef YY_USE_PROTOS +void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) +#else +void yy_switch_to_buffer( new_buffer ) +YY_BUFFER_STATE new_buffer; +#endif + { + if ( yy_current_buffer == new_buffer ) + return; + + if ( yy_current_buffer ) + { + /* Flush out information for old buffer. */ + *yy_c_buf_p = yy_hold_char; + yy_current_buffer->yy_buf_pos = yy_c_buf_p; + yy_current_buffer->yy_n_chars = yy_n_chars; + } + + yy_current_buffer = new_buffer; + yy_load_buffer_state(); + + /* We don't actually know whether we did this switch during + * EOF (yywrap()) processing, but the only time this flag + * is looked at is after yywrap() is called, so it's safe + * to go ahead and always set it. + */ + yy_did_buffer_switch_on_eof = 1; + } + + +#ifdef YY_USE_PROTOS +void yy_load_buffer_state( void ) +#else +void yy_load_buffer_state() +#endif + { + yy_n_chars = yy_current_buffer->yy_n_chars; + yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos; + yyin = yy_current_buffer->yy_input_file; + yy_hold_char = *yy_c_buf_p; + } + + +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_create_buffer( FILE *file, int size ) +#else +YY_BUFFER_STATE yy_create_buffer( file, size ) +FILE *file; +int size; +#endif + { + YY_BUFFER_STATE b; + + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_buf_size = size; + + /* yy_ch_buf has to be 2 characters longer than the size given because + * we need to put in 2 end-of-buffer characters. + */ + b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 ); + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_is_our_buffer = 1; + + yy_init_buffer( b, file ); + + return b; + } + + +#ifdef YY_USE_PROTOS +void yy_delete_buffer( YY_BUFFER_STATE b ) +#else +void yy_delete_buffer( b ) +YY_BUFFER_STATE b; +#endif + { + if ( ! b ) + return; + + if ( b == yy_current_buffer ) + yy_current_buffer = (YY_BUFFER_STATE) 0; + + if ( b->yy_is_our_buffer ) + yy_flex_free( (void *) b->yy_ch_buf ); + + yy_flex_free( (void *) b ); + } + + +#ifndef YY_ALWAYS_INTERACTIVE +#ifndef YY_NEVER_INTERACTIVE +extern int isatty YY_PROTO(( int )); +#endif +#endif + +#ifdef YY_USE_PROTOS +void yy_init_buffer( YY_BUFFER_STATE b, FILE *file ) +#else +void yy_init_buffer( b, file ) +YY_BUFFER_STATE b; +FILE *file; +#endif + + + { + yy_flush_buffer( b ); + + b->yy_input_file = file; + b->yy_fill_buffer = 1; + +#if YY_ALWAYS_INTERACTIVE + b->yy_is_interactive = 1; +#else +#if YY_NEVER_INTERACTIVE + b->yy_is_interactive = 0; +#else + b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; +#endif +#endif + } + + +#ifdef YY_USE_PROTOS +void yy_flush_buffer( YY_BUFFER_STATE b ) +#else +void yy_flush_buffer( b ) +YY_BUFFER_STATE b; +#endif + + { + if ( ! b ) + return; + + b->yy_n_chars = 0; + + /* We always need two end-of-buffer characters. The first causes + * a transition to the end-of-buffer state. The second causes + * a jam in that state. + */ + b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; + b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; + + b->yy_buf_pos = &b->yy_ch_buf[0]; + + b->yy_at_bol = 1; + b->yy_buffer_status = YY_BUFFER_NEW; + + if ( b == yy_current_buffer ) + yy_load_buffer_state(); + } + + +#ifndef YY_NO_SCAN_BUFFER +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size ) +#else +YY_BUFFER_STATE yy_scan_buffer( base, size ) +char *base; +yy_size_t size; +#endif + { + YY_BUFFER_STATE b; + + if ( size < 2 || + base[size-2] != YY_END_OF_BUFFER_CHAR || + base[size-1] != YY_END_OF_BUFFER_CHAR ) + /* They forgot to leave room for the EOB's. */ + return 0; + + b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); + + b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ + b->yy_buf_pos = b->yy_ch_buf = base; + b->yy_is_our_buffer = 0; + b->yy_input_file = 0; + b->yy_n_chars = b->yy_buf_size; + b->yy_is_interactive = 0; + b->yy_at_bol = 1; + b->yy_fill_buffer = 0; + b->yy_buffer_status = YY_BUFFER_NEW; + + yy_switch_to_buffer( b ); + + return b; + } +#endif + + +#ifndef YY_NO_SCAN_STRING +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str ) +#else +YY_BUFFER_STATE yy_scan_string( yy_str ) +yyconst char *yy_str; +#endif + { + int len; + for ( len = 0; yy_str[len]; ++len ) + ; + + return yy_scan_bytes( yy_str, len ); + } +#endif + + +#ifndef YY_NO_SCAN_BYTES +#ifdef YY_USE_PROTOS +YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len ) +#else +YY_BUFFER_STATE yy_scan_bytes( bytes, len ) +yyconst char *bytes; +int len; +#endif + { + YY_BUFFER_STATE b; + char *buf; + yy_size_t n; + int i; + + /* Get memory for full buffer, including space for trailing EOB's. */ + n = len + 2; + buf = (char *) yy_flex_alloc( n ); + if ( ! buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); + + for ( i = 0; i < len; ++i ) + buf[i] = bytes[i]; + + buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR; + + b = yy_scan_buffer( buf, n ); + if ( ! b ) + YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); + + /* It's okay to grow etc. this buffer, and we should throw it + * away when we're done. + */ + b->yy_is_our_buffer = 1; + + return b; + } +#endif + + +#ifndef YY_NO_PUSH_STATE +#ifdef YY_USE_PROTOS +static void yy_push_state( int new_state ) +#else +static void yy_push_state( new_state ) +int new_state; +#endif + { + if ( yy_start_stack_ptr >= yy_start_stack_depth ) + { + yy_size_t new_size; + + yy_start_stack_depth += YY_START_STACK_INCR; + new_size = yy_start_stack_depth * sizeof( int ); + + if ( ! yy_start_stack ) + yy_start_stack = (int *) yy_flex_alloc( new_size ); + + else + yy_start_stack = (int *) yy_flex_realloc( + (void *) yy_start_stack, new_size ); + + if ( ! yy_start_stack ) + YY_FATAL_ERROR( + "out of memory expanding start-condition stack" ); + } + + yy_start_stack[yy_start_stack_ptr++] = YY_START; + + BEGIN(new_state); + } +#endif + + +#ifndef YY_NO_POP_STATE +static void yy_pop_state() + { + if ( --yy_start_stack_ptr < 0 ) + YY_FATAL_ERROR( "start-condition stack underflow" ); + + BEGIN(yy_start_stack[yy_start_stack_ptr]); + } +#endif + + +#ifndef YY_NO_TOP_STATE +static int yy_top_state() + { + return yy_start_stack[yy_start_stack_ptr - 1]; + } +#endif + +#ifndef YY_EXIT_FAILURE +#define YY_EXIT_FAILURE 2 +#endif + +#ifdef YY_USE_PROTOS +static void yy_fatal_error( yyconst char msg[] ) +#else +static void yy_fatal_error( msg ) +char msg[]; +#endif + { + (void) fprintf( stderr, "%s\n", msg ); + exit( YY_EXIT_FAILURE ); + } + + + +/* Redefine yyless() so it works in section 3 code. */ + +#undef yyless +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + yytext[yyleng] = yy_hold_char; \ + yy_c_buf_p = yytext + n; \ + yy_hold_char = *yy_c_buf_p; \ + *yy_c_buf_p = '\0'; \ + yyleng = n; \ + } \ + while ( 0 ) + + +/* Internal utility routines. */ + +#ifndef yytext_ptr +#ifdef YY_USE_PROTOS +static void yy_flex_strncpy( char *s1, yyconst char *s2, int n ) +#else +static void yy_flex_strncpy( s1, s2, n ) +char *s1; +yyconst char *s2; +int n; +#endif + { + register int i; + for ( i = 0; i < n; ++i ) + s1[i] = s2[i]; + } +#endif + +#ifdef YY_NEED_STRLEN +#ifdef YY_USE_PROTOS +static int yy_flex_strlen( yyconst char *s ) +#else +static int yy_flex_strlen( s ) +yyconst char *s; +#endif + { + register int n; + for ( n = 0; s[n]; ++n ) + ; + + return n; + } +#endif + + +#ifdef YY_USE_PROTOS +static void *yy_flex_alloc( yy_size_t size ) +#else +static void *yy_flex_alloc( size ) +yy_size_t size; +#endif + { + return (void *) malloc( size ); + } + +#ifdef YY_USE_PROTOS +static void *yy_flex_realloc( void *ptr, yy_size_t size ) +#else +static void *yy_flex_realloc( ptr, size ) +void *ptr; +yy_size_t size; +#endif + { + /* The cast to (char *) in the following accommodates both + * implementations that use char* generic pointers, and those + * that use void* generic pointers. It works with the latter + * because both ANSI C and C++ allow castless assignment from + * any pointer type to void*, and deal with argument conversions + * as though doing an assignment. + */ + return (void *) realloc( (char *) ptr, size ); + } + +#ifdef YY_USE_PROTOS +static void yy_flex_free( void *ptr ) +#else +static void yy_flex_free( ptr ) +void *ptr; +#endif + { + free( ptr ); + } + +#if YY_MAIN +int main() + { + yylex(); + return 0; + } +#endif +#line 345 "lexer.l" + + +/* + * called when EOF is encountered. Return 1 so the scanner will return + * the zero token to report end-of-file. + */ +int yywrap() +{ + return(1); +} + +static void comment() +{ + int c1 = 0, c2 = STUB_INPUT(); + + linebuf[column] = c2; + column++; + for(;;) { + if (c2 == EOF) + break; + if (c1 == '*' && c2 == '/') + break; + if (c2 == '\n') { + linebuf[0] = '\0'; + column = 0; + lineno++; + } + + c1 = c2; + c2 = STUB_INPUT(); + linebuf[column] = c2; + column++; + } +} + + +static void macro() +{ + int c1 = 0, c2 = STUB_INPUT(), nonws = 0; + + log_printf("MACRO reading begining...\n#"); + log_printf("%c", c2); + + linebuf[column] = c2; + column++; + for(;;) { + if (c2 == EOF) + break; + if (!isspace(c1)) + nonws = c1; + if (nonws == '\\' && c2 == '\n') { + linebuf[0] = '\0'; + column = 0; + lineno++; + } else if (c2 == '\n') { + linebuf[0] = '\0'; + column = 0; + lineno++; + break; + } + + c1 = c2; + c2 = STUB_INPUT(); + linebuf[column] = c2; + log_printf("%c", c2); + column++; + } + log_printf("MACRO reading done.\n"); +} + + +static void count() +{ + int i; + + if (lineno == 1) + strcat(linebuf, yytext); + + for (i = 0; yytext[i] != '\0'; i++) + if (yytext[i] == '\n') + column = 0; + else if (yytext[i] == '\t') + column += 8 - (column % 8); + else + column++; + + /* equiv to fprintf(yyout, "%s", yytext); */ + /* ECHO; */ +} + +/* + * Collect the contents of inline functions, reading them char by char. + * thanks to the arjuna stubgen project for this one + */ +int collectInlineDef() +{ + int bracelevel = 1; + int token; + + /* the magic of exclusive start states makes it all possible */ + BEGIN INLIN; + + while (bracelevel > 0) { + token = yylex(); + column++; +/* fprintf(stderr, "INLIN: read token %c\n", token); */ + if (token > 0) { + /* Assume single char */ + switch (token) { + case '{': + bracelevel++; + break; + case '}': + bracelevel--; + if (bracelevel == 0) + { + column--; + unput(token); + break; + } + break; + case '\n': + column = 0; + lineno++; + break; + } + } else { + /* fatal error: Unexpected EOF reading inline function */ + return -1; + } + } + + /* we now return you to your regularly scheduled start state */ + BEGIN 0; + + return 0; +} + + +/* + * hmmm... looks familiar. more control-y programming. + */ +int collectMemberInitList() +{ + int token; + int insideList = 1; + + /* the magic of exclusive start states makes it all possible */ + BEGIN MINIT; + + while(insideList) { + token = yylex(); + column++; +/* fprintf(stderr, "MINIT: read token %c\n", token); */ + if (token > 0) { + /* Assume single char */ + switch (token) + { + case '{': + insideList = 0; + unput(token); + break; + case '\n': + column = 0; + lineno++; + break; + } + } else { + /* fatal error: Unexpected EOF reading member initialization */ + return -1; + } + } + + /* we now return you to your regularly scheduled start state */ + BEGIN 0; + + return 0; +} diff --git a/bepascal/bepascal/stubgen.so/lexer.l b/bepascal/bepascal/stubgen.so/lexer.l new file mode 100644 index 0000000..d311389 --- /dev/null +++ b/bepascal/bepascal/stubgen.so/lexer.l @@ -0,0 +1,522 @@ +%{ +/* + * FILE: lexer.l + * AUTH: Michael John Radwin + * + * DESC: stubgen lexer. Portions borrowed from Newcastle + * University's Arjuna project (http://arjuna.ncl.ac.uk/), and + * Jeff Lee's ANSI Grammar + * (ftp://ftp.uu.net/usenet/net.sources/ansi.c.grammar.Z) + * + * DATE: Thu Aug 15 13:10:06 EDT 1996 + * $Id: lexer.l,v 1.1 2002-09-21 14:12:12 ocoursiere Exp $ + * + * Copyright (c) 1996-1998 Michael John Radwin + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Modification history: + * $Log: not supported by cvs2svn $ + * Revision 1.1 2001/11/07 10:06:07 ithamar + * Added stubgen to CVS + * + * Revision 1.33 1998/07/27 19:16:57 mradwin + * added some c++ keywords + * need to handle typename, using, and namespace + * + * Revision 1.32 1998/05/11 19:49:11 mradwin + * Version 2.03 (updated copyright information). + * + * Revision 1.31 1998/04/07 23:39:55 mradwin + * changed error-handling code significantly. functions + * like count() are now contributing to linebuf so we get correct + * parse error messages during lineno == 1 and other situations. + * also, instead of calling fatal() for collect*() functions, + * we return -1 and let the parser recover more gracefully. + * + * Revision 1.30 1998/01/12 19:39:11 mradwin + * modified rcsid + * + * Revision 1.29 1997/11/13 22:37:31 mradwin + * changed char[] to char * to make non-gcc compilers + * a little happier. We need to #define const to nothing + * for other compilers as well. + * + * Revision 1.28 1997/11/13 21:29:30 mradwin + * moved code from parser.y to main.c + * + * Revision 1.27 1997/11/13 21:10:17 mradwin + * renamed stubgen.[ly] to parser.y lexer.l + * + * Revision 1.26 1997/11/11 03:52:06 mradwin + * changed fatal() + * + * Revision 1.25 1997/11/05 03:02:02 mradwin + * Modified logging routines. + * + * Revision 1.24 1997/11/01 23:12:43 mradwin + * greatly improved error-recovery. errors no longer spill over + * into other files because the yyerror state is properly reset. + * + * Revision 1.23 1997/10/26 23:16:32 mradwin + * changed inform_user and fatal functions to use varargs + * + * Revision 1.22 1997/10/26 22:46:48 mradwin + * support macros within comments, etc. + * + * Revision 1.21 1997/10/16 19:42:48 mradwin + * added support for elipses, static member/array initializers, + * and bitfields. + * + * Revision 1.20 1997/10/16 17:36:06 mradwin + * Fixed compiler warning on win32 from and isspace() + * + * Revision 1.19 1997/10/16 17:12:59 mradwin + * handle extern "C" blocks better now, and support multi-line + * macros. still need error-checking. + * + * Revision 1.18 1997/10/15 22:09:06 mradwin + * changed tons of names. stubelem -> sytaxelem, + * stubin -> infile, stubout -> outfile, stublog -> logfile. + * + * Revision 1.17 1997/10/15 21:45:13 mradwin + * rearranged table.[ch] and util.[ch] so that util pkg + * knows nothing about syntaxelems. + * + * Revision 1.16 1997/10/15 17:42:37 mradwin + * added support for 'extern "C" { ... }' blocks. + * + * Revision 1.15 1997/09/05 19:17:06 mradwin + * works for scanning old versions, except for parameter + * names that differ between .H and .C files. + * + * Revision 1.14 1997/09/05 16:37:41 mradwin + * rcsid + * + * Revision 1.13 1997/09/05 16:34:36 mradwin + * GPL-ized code. + * + * Revision 1.12 1997/09/05 16:13:18 mradwin + * changed email address to acm.org + * + * Revision 1.11 1996/09/12 14:44:49 mjr + * Added throw decl recognition (great, another 4 bytes in syntaxelem) + * and cleaned up the grammar so that const_opt appears in far fewer + * places. const_opt is by default 0 as well, so we don't need to + * pass it as an arg to new_elem(). + * + * I also added a fix to a potential bug with the MINIT and INLIN + * exclusive start states. I think they could have been confused + * by braces within comments, so now I'm grabbing comments in those + * states as well. + * + * Revision 1.10 1996/09/12 03:46:10 mjr + * No concrete changes in code. Just added some sanity by + * factoring out code into util.[ch] and putting some prototypes + * that were in table.h into stubgen.y where they belong. + * + * Revision 1.9 1996/09/01 20:59:48 mjr + * Added collectMemberInitList() function, which is similar + * to collectInlineDef() and also the exclusive state MINIT + * + * Revision 1.8 1996/08/23 05:09:19 mjr + * fixed up some more portability things + * + * Revision 1.7 1996/08/22 02:43:47 mjr + * added parse error message (using O'Reilly p. 274) + * + * Revision 1.6 1996/08/21 18:33:50 mjr + * removed the buffer for inlines. we don't care anyway. + * now we can't overflow on inlines! + * + * Revision 1.5 1996/08/21 17:40:56 mjr + * added some cpp directives for porting to WIN32 + * + * Revision 1.4 1996/08/19 17:01:33 mjr + * no echo now + * + * Revision 1.3 1996/08/15 21:24:58 mjr + * *** empty log message *** + */ +%} + +D [0-9] +L [a-zA-Z_] +H [a-fA-F0-9] +E [Ee][+-]?{D}+ +FS (f|F|l|L) +IS (u|U|l|L)* + +%{ +#include +#include +#include +#include "table.h" +#include "util.h" + +#ifdef WIN32 +/* definitions of exit, malloc, realloc, and free */ +#include +#endif + +#if 0 /* #ifdef WIN32 */ +#include "y_tab.h" +#else +#include "y.tab.h" +#endif + +#ifdef __cplusplus +#define STUB_INPUT() yyinput() +#else +#define STUB_INPUT() input() +#endif + +/* when we return a string, duplicate it so we can free it later. + we always allocate memory so we can uniformly free() it. */ +#define RETURN_STR(x) tokens_seen++; yylval.string = strdup(yytext); return(x) + +/* make that nasty union a value that will bus error if we misinterpret + the value as a pointer */ +#define RETURN_VAL(x) tokens_seen++; yylval.flag = 37; return(x) + +static const char rcsid[] = "$Id: lexer.l,v 1.1 2002-09-21 14:12:12 ocoursiere Exp $"; + +static void count(); +static void comment(); +static void macro(); + +char linebuf[1024]; /* null-terminated at beginning of each file */ +int lineno; /* set to 1 at beginning of each file */ +int column; /* set to 0 at beginning of each file */ +int tokens_seen; /* set to 0 at beginning of each file */ + +%} + +%x INLIN MINIT +%% +\n.* { /* + * for debugging purposes, we grab an entire + * line and buffer it, then grab tokens out of + * it. This lets us have more informative + * error messages. See yyerror() in parser.y + */ + strncpy(linebuf, yytext+1, 1024); + lineno++; + column = 0; + yyless(1); /* give back everything but \n */ + } +"/*" { comment(); } + +"//".* { count(); } +"#" { macro(); /* was #.* { count(); } */ } + +"static" { count(); tokens_seen++; } +"volatile" { count(); tokens_seen++; } +"auto" { count(); tokens_seen++; } +"extern" { count(); RETURN_VAL(EXTERN); } +"register" { count(); tokens_seen++; } +"typedef" { count(); tokens_seen++; } +"struct" { count(); RETURN_VAL(STRUCT); } +"union" { count(); RETURN_VAL(UNION); } +"enum" { count(); RETURN_VAL(ENUM); } +"const" { count(); RETURN_VAL(CONST); } +"template" { count(); RETURN_VAL(TEMPLATE); } + +"typename" { count(); tokens_seen++; /* FIXME */ } +"using" { count(); tokens_seen++; /* FIXME */ } +"namespace" { count(); RETURN_VAL(CLASS); /* FIXME */ } + +"dllexport" { count(); tokens_seen++; } +"dllimport" { count(); tokens_seen++; } + +"explicit" { count(); tokens_seen++; } +"mutable" { count(); tokens_seen++; } +"inline" { count(); tokens_seen++; } +"virtual" { count(); tokens_seen++; } +"class" { count(); RETURN_VAL(CLASS); } +"delete" { count(); RETURN_VAL(DELETE); } +"new" { count(); RETURN_VAL(NEW); } +"friend" { count(); RETURN_VAL(FRIEND); } +"operator" { count(); RETURN_VAL(OPERATOR); } +"protected" { count(); RETURN_VAL(PROTECTED); } +"private" { count(); RETURN_VAL(PRIVATE); } +"public" { count(); RETURN_VAL(PUBLIC); } +"throw" { count(); RETURN_VAL(THROW); } + +"char" { count(); RETURN_STR(CHAR); } +"short" { count(); RETURN_STR(SHORT); } +"int" { count(); RETURN_STR(INT); } +"long" { count(); RETURN_STR(LONG); } +"signed" { count(); RETURN_STR(SIGNED); } +"unsigned" { count(); RETURN_STR(UNSIGNED); } +"float" { count(); RETURN_STR(FLOAT); } +"double" { count(); RETURN_STR(DOUBLE); } +"void" { count(); RETURN_STR(VOID); } + +{L}({L}|{D})* { count(); RETURN_STR(IDENTIFIER); } + +0[xX]{H}+{IS}? { count(); RETURN_STR(CONSTANT); } +0{D}+{IS}? { count(); RETURN_STR(CONSTANT); } +{D}+{IS}? { count(); RETURN_STR(CONSTANT); } +'(\\.|[^\\'])+' { count(); RETURN_STR(CONSTANT); /* 'fontlck */ } + +{D}+{E}{FS}? { count(); RETURN_STR(CONSTANT); } +{D}*"."{D}+({E})?{FS}? { count(); RETURN_STR(CONSTANT); } +{D}+"."{D}*({E})?{FS}? { count(); RETURN_STR(CONSTANT); } + +\"(\\.|[^\\"])*\" { count(); RETURN_STR(STRING_LITERAL); /* "fontlck */ } + +">>=" { count(); RETURN_VAL(RIGHT_ASSIGN); } +"<<=" { count(); RETURN_VAL(LEFT_ASSIGN); } +"+=" { count(); RETURN_VAL(ADD_ASSIGN); } +"-=" { count(); RETURN_VAL(SUB_ASSIGN); } +"*=" { count(); RETURN_VAL(MUL_ASSIGN); } +"/=" { count(); RETURN_VAL(DIV_ASSIGN); } +"%=" { count(); RETURN_VAL(MOD_ASSIGN); } +"&=" { count(); RETURN_VAL(AND_ASSIGN); } +"^=" { count(); RETURN_VAL(XOR_ASSIGN); } +"|=" { count(); RETURN_VAL(OR_ASSIGN); } +">>" { count(); RETURN_VAL(RIGHT_OP); } +"<<" { count(); RETURN_VAL(LEFT_OP); } +"++" { count(); RETURN_VAL(INC_OP); } +"--" { count(); RETURN_VAL(DEC_OP); } +"->" { count(); RETURN_VAL(PTR_OP); } +"->*" { count(); RETURN_VAL(MEM_PTR_OP); } +"&&" { count(); RETURN_VAL(AND_OP); } +"||" { count(); RETURN_VAL(OR_OP); } +"<=" { count(); RETURN_VAL(LE_OP); } +">=" { count(); RETURN_VAL(GE_OP); } +"==" { count(); RETURN_VAL(EQ_OP); } +"!=" { count(); RETURN_VAL(NE_OP); } +";" { count(); RETURN_VAL(';'); } +"{" { count(); RETURN_VAL('{'); } +"}" { count(); RETURN_VAL('}'); } +"," { count(); RETURN_VAL(','); } +":" { count(); RETURN_VAL(':'); } +"=" { count(); RETURN_VAL('='); } +"(" { count(); RETURN_VAL('('); } +")" { count(); RETURN_VAL(')'); } +"[" { count(); RETURN_VAL('['); } +"]" { count(); RETURN_VAL(']'); } +"." { count(); RETURN_VAL('.'); } +"&" { count(); RETURN_VAL('&'); } +"!" { count(); RETURN_VAL('!'); } +"~" { count(); RETURN_VAL('~'); } +"-" { count(); RETURN_VAL('-'); } +"+" { count(); RETURN_VAL('+'); } +"*" { count(); RETURN_VAL('*'); } +"/" { count(); RETURN_VAL('/'); } +"%" { count(); RETURN_VAL('%'); } +"<" { count(); RETURN_VAL('<'); } +">" { count(); RETURN_VAL('>'); } +"^" { count(); RETURN_VAL('^'); } +"|" { count(); RETURN_VAL('|'); } +"?" { count(); RETURN_VAL('?'); } +"::" { count(); RETURN_VAL(CLCL); } +"..." { count(); RETURN_VAL(ELIPSIS); } + +"/*" { comment(); } +"//".* { count(); } +"#" { macro(); /* was #.* { count(); } */ } +. | +\n { RETURN_VAL((int) yytext[0]); } + +"/*" { comment(); } +"//".* { count(); } +"#" { macro(); /* was #.* { count(); } */ } +. | +\n { RETURN_VAL((int) yytext[0]); } + +[ \t\v\f] { count(); } +. { count(); /* ignore bad characters */ } + +%% + +/* + * called when EOF is encountered. Return 1 so the scanner will return + * the zero token to report end-of-file. + */ +int yywrap() +{ + return(1); +} + +static void comment() +{ + int c1 = 0, c2 = STUB_INPUT(); + + linebuf[column] = c2; + column++; + for(;;) { + if (c2 == EOF) + break; + if (c1 == '*' && c2 == '/') + break; + if (c2 == '\n') { + linebuf[0] = '\0'; + column = 0; + lineno++; + } + + c1 = c2; + c2 = STUB_INPUT(); + linebuf[column] = c2; + column++; + } +} + + +static void macro() +{ + int c1 = 0, c2 = STUB_INPUT(), nonws = 0; + + log_printf("MACRO reading begining...\n#"); + log_printf("%c", c2); + + linebuf[column] = c2; + column++; + for(;;) { + if (c2 == EOF) + break; + if (!isspace(c1)) + nonws = c1; + if (nonws == '\\' && c2 == '\n') { + linebuf[0] = '\0'; + column = 0; + lineno++; + } else if (c2 == '\n') { + linebuf[0] = '\0'; + column = 0; + lineno++; + break; + } + + c1 = c2; + c2 = STUB_INPUT(); + linebuf[column] = c2; + log_printf("%c", c2); + column++; + } + log_printf("MACRO reading done.\n"); +} + + +static void count() +{ + int i; + + if (lineno == 1) + strcat(linebuf, yytext); + + for (i = 0; yytext[i] != '\0'; i++) + if (yytext[i] == '\n') + column = 0; + else if (yytext[i] == '\t') + column += 8 - (column % 8); + else + column++; + + /* equiv to fprintf(yyout, "%s", yytext); */ + /* ECHO; */ +} + +/* + * Collect the contents of inline functions, reading them char by char. + * thanks to the arjuna stubgen project for this one + */ +int collectInlineDef() +{ + int bracelevel = 1; + int token; + + /* the magic of exclusive start states makes it all possible */ + BEGIN INLIN; + + while (bracelevel > 0) { + token = yylex(); + column++; +/* fprintf(stderr, "INLIN: read token %c\n", token); */ + if (token > 0) { + /* Assume single char */ + switch (token) { + case '{': + bracelevel++; + break; + case '}': + bracelevel--; + if (bracelevel == 0) + { + column--; + unput(token); + break; + } + break; + case '\n': + column = 0; + lineno++; + break; + } + } else { + /* fatal error: Unexpected EOF reading inline function */ + return -1; + } + } + + /* we now return you to your regularly scheduled start state */ + BEGIN 0; + + return 0; +} + + +/* + * hmmm... looks familiar. more control-y programming. + */ +int collectMemberInitList() +{ + int token; + int insideList = 1; + + /* the magic of exclusive start states makes it all possible */ + BEGIN MINIT; + + while(insideList) { + token = yylex(); + column++; +/* fprintf(stderr, "MINIT: read token %c\n", token); */ + if (token > 0) { + /* Assume single char */ + switch (token) + { + case '{': + insideList = 0; + unput(token); + break; + case '\n': + column = 0; + lineno++; + break; + } + } else { + /* fatal error: Unexpected EOF reading member initialization */ + return -1; + } + } + + /* we now return you to your regularly scheduled start state */ + BEGIN 0; + + return 0; +} diff --git a/bepascal/bepascal/stubgen.so/lib.c b/bepascal/bepascal/stubgen.so/lib.c new file mode 100644 index 0000000..328a7ff --- /dev/null +++ b/bepascal/bepascal/stubgen.so/lib.c @@ -0,0 +1,2 @@ +#include "main.c" + diff --git a/bepascal/bepascal/stubgen.so/main.c b/bepascal/bepascal/stubgen.so/main.c new file mode 100644 index 0000000..dbfc300 --- /dev/null +++ b/bepascal/bepascal/stubgen.so/main.c @@ -0,0 +1,726 @@ +/* + * FILE: main.c + * AUTH: Michael John Radwin + * + * DESC: stubgen code generation routines + * + * DATE: Thu Nov 13 13:28:23 PST 1997 + * $Id: main.c,v 1.1 2002-09-21 14:12:12 ocoursiere Exp $ + * + * Copyright (c) 1996-1998 Michael John Radwin + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "table.h" +#include "util.h" +#include "pathname.h" +#include +#include +#include +#include +#include + +#ifdef WIN32 +#include /* defintion of GetUserName(), BOOL, etc. */ +#include +#include /* defintion of alloca() */ +#include "getopt.h" /* use GNU getopt */ +#else /* !WIN32 */ +#include +#endif /* WIN32 */ + +/* protos */ +static void debug_printf(syntaxelem_t *); +static void generate_skel(syntaxelem_t *); +static void print_function(syntaxelem_t *); +static void function_hdr(syntaxelem_t *); +static void file_hdr(); +static void scan_and_generate(FILE *); +static void scan_existing_skeleton(); + +/* duplicating variable names from stubgen.pl */ +static const char *OPTS = "hqrivgae:cdbfsn"; +int opt_h = 0, opt_q = 0, opt_r = 0, opt_i = 0; +int opt_v = 0, opt_g = 0, opt_a = 0; +int opt_c = 0, opt_d = 0; +int opt_b = 0, opt_f = 0, opt_s = 0, opt_n = 0; +char *opt_e = "cpp"; + +int using_stdio = 0; +static int new_functions = 0, fileOpened = 0, fileExisted = 0; +static int inform_indent = 0; + +#ifdef SGDEBUG +static const char *logfilename = "stubgen.log"; +#endif /* SGDEBUG */ + +FILE *outfile = NULL; +static char *inPath = NULL, *outPath = NULL; +char *currentFile = ""; +static const char *lots_of_stars = + "***********************************************************************"; +static const char *progname = "stubgen"; +static const char rcsid[] = "$Id: main.c,v 1.1 2002-09-21 14:12:12 ocoursiere Exp $"; +static const char *progver = "2.05"; + +static const char *copyright = + "Copyright (c) 1996-1998 Michael John Radwin"; + +static const char *version_info = +"Distributed under the GNU General Public License.\n\ +See http://www.radwin.org/michael/projects/stubgen/ for more information.\n"; + +static const char *usage = +"usage: %s [-hqrivgacd] [-e ext] [-{bfsn}] [infiles]\n\ + OPTIONS\n\ + -h Display usage information.\n\ + -q Quiet mode, no status information while generating code.\n\ + -r Make RCS-style file headers.\n\ + -i Don't put the #include \"my_file.H\" directive in my_file.cpp\n\ + -v Display version information.\n\ + -g Generate dummy return statements for functions.\n\ + -a Split function arguments over multiple lines.\n\ + -c Print debugging output with cerrs (#include ).\n\ + -d Print debugging output with dprintfs (#include ).\n\ + -e ext Generate source files with extension '.ext' (default '.cpp').\n\ +\n\ + METHOD HEADER STYLES\n\ + -b Block method headers (default).\n\ + -f Full method headers: like block, but less asterisks.\n\ + -s Simple method headers: only \"Method\" and \"Descr\" fields.\n\ + -n No method headers.\n"; + + +static void generate_skel(syntaxelem_t *elt) +{ + syntaxelem_t *e; + + log_printf("generate_skel called: %s\n", elt->name); + if (elt->kind != CLASS_KIND && elt->kind != STRUCT_KIND) + return; + + inform_user("%*s==> %s %s", inform_indent, "", + (elt->kind == CLASS_KIND ? "class " : "struct"), + elt->name); + if (inform_indent == 0) + inform_user(" (file %s)", inPath); + else + inform_user(" (nested class)"); + inform_user("\n"); + inform_indent += 4; + + for (e = elt->children; e != NULL; e = e->next) { + if (e->kind == FUNC_KIND) { + char *arg_str = args_to_string(e->args, 0); + log_printf(">>>>>>> generating %s: %s %s::%s(%s) %s\n", + string_kind(e->kind), + e->ret_type, elt->name, e->name, arg_str, + (e->const_flag) ? "const" : ""); + free(arg_str); + print_se(e); + print_function(e); + e->kind = DONE_FUNC_KIND; + } else if (e->kind == CLASS_KIND || e->kind == STRUCT_KIND) { + /* nested class */ + char *tmp_str = (char *) malloc(strlen(elt->name) + strlen(e->name) + 3); + sprintf(tmp_str, "%s::%s", elt->name, e->name); + free(e->name); + e->name = tmp_str; + + log_printf(">>>>>>> generating NESTED %s: %s\n", + string_kind(e->kind), e->name); + print_se(e); + generate_skel(e); + } else { + log_printf("------> ignoring %s: %s\n", + string_kind(e->kind), e->name); + } + } + + inform_indent -= 4; + inform_user("%*s==> %s %s", inform_indent, "", + (elt->kind == CLASS_KIND ? "class " : "struct"), + elt->name); + if (inform_indent == 0) + inform_user(" (%d functions appended to %s)", new_functions, outPath); + else + inform_user(" (end nested class)"); + inform_user("\n"); + + elt->kind = DONE_CLASS_KIND; +} + + + +static void print_function(syntaxelem_t *elt) +{ + syntaxelem_t *e; + + if (find_skeleton(elt)) { + log_printf("find_skeleton() returned true for this elt:\n"); + print_se(elt); + return; + } + + new_functions++; + if (!fileOpened) { + fileOpened = 1; + + if (using_stdio) { + fileExisted = 0; + } else { + /* test for existence */ + outfile = fopen(outPath, "r"); + if (outfile != NULL) { + fileExisted = 1; + fclose(outfile); + } + + /* do the fopen */ + log_printf("writing to %s\n", outPath); + outfile = fopen(outPath, "a"); + if (outfile == NULL) { + /* open failed */ + fatal(1, "%s: cannot open %s\n", progname, outPath); + } + } + + if (!fileExisted) file_hdr(); + } + + inform_user("%*s%s\n", inform_indent, "", elt->name); + function_hdr(elt); + for (e = elt->parent; e != NULL; e = e->parent) { + if (e->templ) { + fprintf(outfile, "%s\n", e->templ); + break; + } + } + + { /* scope for local vars */ + char *arg_str; + + fprintf(outfile, "%s%s%s::%s(", + elt->ret_type, (strcmp(elt->ret_type, "") ? "\n" : ""), + elt->parent->name, elt->name); + + arg_str = args_to_string( + elt->args, + opt_a ? strlen(elt->parent->name) + strlen(elt->name) + 3 : 0); + + fprintf(outfile, "%s)", arg_str); + free(arg_str); + + if (elt->throw_decl) + fprintf(outfile, " %s", elt->throw_decl); + + if (elt->const_flag) + fprintf(outfile, " const"); + + fprintf(outfile, "\n{\n"); + } + + debug_printf(elt); + fprintf(outfile, "}\n\n\n"); +} + +static void function_hdr(syntaxelem_t *elt) +{ + if (opt_n) + return; + + fprintf(outfile, "/%s\n", (opt_b ? lots_of_stars : "*")); + fprintf(outfile, " * Method: %s::%s%s\n", elt->parent->name, elt->name, + (opt_s ? "()" : "")); + + if (opt_s) { + fprintf(outfile, " * Descr: \n"); + + } else { + char *arg_str = args_to_string(elt->args, 0); + fprintf(outfile, " * Params: %s\n", arg_str); + if (strcmp(elt->ret_type, "")) + fprintf(outfile, " * Returns: %s\n", elt->ret_type); + fprintf(outfile, " * Effects: \n"); + free(arg_str); + } + + fprintf(outfile, " %s/\n", (opt_b ? lots_of_stars : "*")); +} + +#ifdef WIN32 +static BOOL win32_fullname(const char *login, char *dest) +{ + WCHAR wszLogin[256]; /* Unicode user name */ + struct _USER_INFO_10 *ui; /* User structure */ + + /* Convert ASCII user name to Unicode. */ + MultiByteToWideChar(CP_ACP, 0, login, + strlen(login)+1, wszLogin, sizeof(wszLogin)); + + /* Look up the user on the DC. This function only works for + * Windows NT, and not Windows 95. */ + if (NetUserGetInfo(NULL, (LPWSTR) &wszLogin, 10, (LPBYTE *) &ui)) + return FALSE; + + /* Convert the Unicode full name to ASCII. */ + WideCharToMultiByte(CP_ACP, 0, ui->usri10_full_name, + -1, dest, 256, NULL, NULL); + + return TRUE; +} +#endif /* WIN32 */ + +static char *sg_getlogin() +{ + static char *login; +#ifdef WIN32 + static char login_buffer[256]; + DWORD size; +#endif /* WIN32 */ + static int sg_getlogin_called = 0; + + if (sg_getlogin_called) + return login; + else + sg_getlogin_called = 1; + +#ifdef WIN32 + if ((login = getenv("USERNAME")) == NULL) { + if ((login = getenv("USER")) == NULL) { + size = 255; + login = login_buffer; + if (GetUserName(login_buffer, &size) == FALSE) + login = "nobody"; + } + } +#else /* !WIN32 */ + if ((login = getenv("USER")) == NULL) + if ((login = getlogin()) == NULL) + login = "nobody"; +#endif /* WIN32 */ + + return login; +} + +static char *sg_getfullname(const char *login) +{ + char *fullname; + static char fullname_buffer[256]; +#ifndef WIN32 + char *comma; + struct passwd *pw; +#endif /* WIN32 */ + +#ifdef WIN32 + fullname = fullname_buffer; + + if (win32_fullname(login, fullname_buffer) == FALSE) + fullname = "nobody"; +#else /* !WIN32 */ + if ((fullname = getenv("NAME")) == NULL) { + setpwent(); + pw = getpwnam(login); + if (pw == NULL) { + fullname = "nobody"; + } else { + strncpy(fullname_buffer, pw->pw_gecos, 256); + comma = strchr(fullname_buffer, ','); + if (comma) *comma = '\0'; + fullname = fullname_buffer; + } + endpwent(); + } +#endif /* WIN32 */ + + return fullname; +} + + +static void file_hdr() { + char domain[256], *tmp; + time_t now = time(0); + char *today = ctime(&now); + char *login = sg_getlogin(); + char *fullname = sg_getfullname(login); + + log_printf("login: %s, full name: %s\n", login, fullname); + + domain[0] = '\0'; + if ((tmp = getenv("STUBGEN_DOM")) != NULL) + sprintf(domain, "@%s", tmp); + + if (opt_r) { + fprintf(outfile, "/*\n * FILE: %s\n * AUTH: %s <%s%s>\n", outPath, fullname, login, domain); + /* no '\n' needed with ctime() */ + fprintf(outfile, " *\n * DESC: \n *\n * DATE: %s * %sId$ \n *\n", today, "$"); + fprintf(outfile, " * %sLog$\n", "$"); + fprintf(outfile, " *\n */\n"); + + } else { + fprintf(outfile, "/%s\n", lots_of_stars); + fprintf(outfile, " * AUTHOR: %s <%s%s>\n", fullname, login, domain); + fprintf(outfile, " * FILE: %s\n", outPath); + fprintf(outfile, " * DATE: %s", today); /* no '\n' needed with ctime() */ + fprintf(outfile, " * DESCR: \n"); + fprintf(outfile, " %s/\n", lots_of_stars); + } + + if (!opt_i && !using_stdio) + fprintf(outfile, "#include \"%s\"\n", inPath); + if (opt_c) + fprintf(outfile, "#include \n"); + else if (opt_d) + fprintf(outfile, "#include \n"); + + fprintf(outfile, "\n"); +} + + +static void debug_printf(syntaxelem_t *elt) +{ + /* + * Make a dummy return value if this function is not a + * procedure (returning void) or a ctor (returning ""). + * Don't bother for references because they require an lvalue. + */ + int dummy_ret_val = (opt_g && + strcmp(elt->ret_type, "") != 0 && + strcmp(elt->ret_type, "void") != 0 && + strchr(elt->ret_type, '&') == 0); + /* + * If it's not a pointer type, create a temporary on the stack. + * They'll get warnings "dummy has not yet been assigned a value" + * from the compiler, but that's the best we can do. + * If it's a pointer type, return NULL (we assume it's defined). + */ + if (dummy_ret_val != 0 && strchr(elt->ret_type, '*') == NULL) + fprintf(outfile, " %s dummy;\n\n", elt->ret_type); + + if (opt_c) + fprintf(outfile, " cerr << \"%s::%s()\" << endl;\n", + elt->parent->name, elt->name); + else if (opt_d) + fprintf(outfile, " dprintf((\"%s::%s()\\n\"));\n", + elt->parent->name, elt->name); + + if (dummy_ret_val != 0) + fprintf(outfile, " return %s;\n", + (strchr(elt->ret_type, '*') == NULL) ? "dummy" : "NULL"); +} + +extern char linebuf[]; +extern int lineno; +extern int column; +extern int tokens_seen; +extern int yyparse(); + +static void scan_existing_skeleton() +{ + extern FILE *yyin; + FILE *existing; + + log_printf("checking for existence of %s ...\n", outPath); + if ((existing = fopen(outPath, "r")) == NULL) + return; + + log_printf("%s exists, scanning skeleton...\n", outPath); + inform_user("scanning %s ...\n", outPath); + + lineno = 1; + column = 0; + tokens_seen = 0; + + yyin = existing; + currentFile = outPath; + linebuf[0] = '\0'; + yyparse(); + log_printf("finished yyparse()\n"); + currentFile = ""; + + fclose(existing); + log_printf("done scanning skeleton...\n"); +} + +__declspec(dllexport) syntaxelem_t * scan(char *infile) +{ + extern FILE *yyin; + + fileOpened = 0; + lineno = 1; + column = 0; + tokens_seen = 0; + + /* normal interaction on yyin and outfile from now on */ + inform_user("parsing %s ...\n", inPath); + log_printf("parsing %s ...\n", inPath); + yyin = fopen(/*infile*/"View.h", "r"); + if (yyin == NULL) { + /* open failed */ + fatal(1, "%s: cannot open %s\n", progname, infile); + }; + currentFile = inPath; + linebuf[0] = '\0'; + yyparse(); + log_printf("finished yyparse()\n"); + currentFile = ""; + log_printf("expanding classes...\n"); + if (!class_queue_empty()) + { + return dequeue_class(); + } +// while (!class_queue_empty()) { +// syntaxelem_t *elt = dequeue_class(); +// generate_skel(elt); +// } + + log_printf("closing %s\n", outPath); + free(outPath); + outPath = NULL; +// if (fileOpened) { +// fflush(outfile); +// fclose(outfile); +// outfile = NULL; +// } + fclose(yyin); + log_printf("done with %s\n", inPath); +} + +__declspec(dllexport) void scan_and_generate(FILE *infile) +{ + extern FILE *yyin; + + fileOpened = 0; + lineno = 1; + column = 0; + tokens_seen = 0; + + /* normal interaction on yyin and outfile from now on */ + inform_user("parsing %s ...\n", inPath); + log_printf("parsing %s ...\n", inPath); + yyin = infile; + currentFile = inPath; + linebuf[0] = '\0'; + yyparse(); + log_printf("finished yyparse()\n"); + currentFile = ""; + log_printf("expanding classes...\n"); + while (!class_queue_empty()) { + syntaxelem_t *elt = dequeue_class(); + generate_skel(elt); + } + + log_printf("closing %s\n", outPath); + free(outPath); + outPath = NULL; + if (fileOpened) { + fflush(outfile); + fclose(outfile); + outfile = NULL; + } + log_printf("done with %s\n", inPath); +} + +/* + * return a value representing numeric part of the RCS Revision string + * where value == (major * 1000) + minor. + */ +int revision() +{ + static char rcsrev[] = "$Revision: 1.1 $"; + static int value = -1; + char *major_str, *dot; + + if (value != -1) + return value; + + rcsrev[strlen(rcsrev)-2] = '\0'; + + major_str = &rcsrev[11]; + dot = strchr(major_str, '.'); + *dot++ = '\0'; /* tie off major_str and move to minor */ + + value = (atoi(major_str) * 1000) + atoi(dot); + + return value; +} + +#ifndef _MAX_PATH +#define _MAX_PATH 256 +#endif /* !def _MAX_PATH */ + +//int main(int argc, char **argv) +//{ +// extern int optind; +// extern char *optarg; +// int c, err_flag = 0; +// char *ext; +// +//#ifdef SGDEBUG +// char logfilename_buffer[_MAX_PATH]; +//#ifdef WIN32 +// DWORD tmpPathLen; +//#endif /* WIN32 */ +//#endif /* SGDEBUG */ +// +//#ifdef SGDEBUG +//#ifdef WIN32 +// tmpPathLen = GetTempPath(_MAX_PATH, logfilename_buffer); +// if (logfilename_buffer[tmpPathLen - 1] != '\\') +// strcat(logfilename_buffer, "\\"); +//#else /* !WIN32 */ +// strcpy(logfilename_buffer, "/tmp/"); +//#endif /* WIN32 */ +// +// strcat(logfilename_buffer, sg_getlogin()); +// strcat(logfilename_buffer, "-"); +// strcat(logfilename_buffer, logfilename); +// +// if (!log_open(logfilename_buffer)) { +// /* open failed */ +// fatal(1, "%s: cannot write to %s\n", progname, logfilename_buffer); +// } +//#endif /* SGDEBUG */ +// +// while ((c = getopt(argc, argv, OPTS)) != EOF) { +// switch (c) { +// case 'h': +// opt_h = 1; break; +// case 'q': +// opt_q = 1; break; +// case 'v': +// opt_v = 1; break; +// case 'g': +// opt_g = 1; break; +// case 'a': +// opt_a = 1; break; +// case 'e': +// opt_e = optarg; +// if (opt_e[0] == '.') +// opt_e++; +// break; +// case 'r': +// opt_r = 1; break; +// case 'i': +// opt_i = 1; break; +// case 'c': +// if (opt_d) err_flag = 1; +// opt_c = 1; break; +// case 'd': +// if (opt_c) err_flag = 1; +// opt_d = 1; break; +// case 'b': +// if (opt_f || opt_s || opt_n) err_flag = 1; +// opt_b = 1; break; +// case 'f': +// if (opt_b || opt_s || opt_n) err_flag = 1; +// opt_f = 1; break; +// case 's': +// if (opt_f || opt_b || opt_n) err_flag = 1; +// opt_s = 1; break; +// case 'n': +// if (opt_f || opt_s || opt_b) err_flag = 1; +// opt_n = 1; break; +// default: +// err_flag = 1; +// } +// } +// +// if (opt_h || opt_v || err_flag) { +// inform_user("%s version %s (build %d).\n", +// progname, progver, revision()); +// if (opt_h || err_flag) +// fatal(err_flag, usage, progname); +// else +// fatal(0, "%s\n%s", copyright, version_info); +// } +// +// if (!(opt_b || opt_f || opt_s || opt_n)) +// opt_b = 1; +// +// /* done setting options */ +// if (argc == optind) { +// /* read from stdin and stdout */ +// outfile = stdout; +// fprintf(outfile, "/* %s: reading from stdin */\n", progname); +// using_stdio = 1; +// inPath = "stdin"; +// outPath = strdup("stdout"); +// +// opt_q = 1; /* force quiet mode */ +// log_printf("initting...\n"); +// init_tables(); +// scan_and_generate(stdin); +// log_printf("freeing memory...\n"); +// free_tables(); +// +// } else { +// inform_user("%s version %s (build %d).\n", +// progname, progver, revision()); +// +// /* each bloody file from the command line */ +// while (optind < argc) { +// FILE *infile; +// log_printf("working on %s\n", argv[optind]); +// /* open for read */ +// infile = fopen(argv[optind], "r"); +// if (infile == NULL) { +// /* open failed */ +// fatal(1, "%s: cannot open %s\n", progname, argv[optind]); +// } +// +// inPath = basename(argv[optind]); +// outPath = (char *)malloc(strlen(inPath) + strlen(opt_e) + 2); +// strcpy(outPath, inPath); +// +// /* tie off .h, .hh, .hpp, or .hxx extension */ +// if (((ext = strrchr(outPath, '.')) != NULL) && +// (((strlen(ext) == 2) && +// ((ext[1] == 'H') || (ext[1] == 'h'))) || +// (((strlen(ext) == 3) && +// ((ext[1] == 'H') || (ext[1] == 'h')) && +// ((ext[2] == 'H') || (ext[2] == 'h')))) || +// ((strlen(ext) == 4) && +// ((ext[1] == 'H') || (ext[1] == 'h')) && +// ((((ext[2] == 'P') || (ext[2] == 'p')) && +// ((ext[3] == 'P') || (ext[3] == 'p'))) || +// (((ext[2] == 'X') || (ext[2] == 'x')) && +// ((ext[3] == 'X') || (ext[3] == 'x'))))))) +// *ext = '\0'; +// +// assert(opt_e[0] != '.'); +// strcat(outPath, "."); +// strcat(outPath, opt_e); +// +// log_printf("initting...\n"); +// init_tables(); +// scan_existing_skeleton(); +// scan_and_generate(infile); +// log_printf("freeing memory...\n"); +// free_tables(); +// clear_skeleton_queue(); +// fclose(infile); +// optind++; +// } +// } +// +//#ifdef SGDEBUG +// log_flush(); +// log_close(); +//#endif /* SGDEBUG */ +// +// return 0; +//} diff --git a/bepascal/bepascal/stubgen.so/parser.y b/bepascal/bepascal/stubgen.so/parser.y new file mode 100644 index 0000000..bb02b18 --- /dev/null +++ b/bepascal/bepascal/stubgen.so/parser.y @@ -0,0 +1,1784 @@ +%{ +/* + * FILE: parser.y + * AUTH: Michael John Radwin + * + * DESC: stubgen grammar description. Portions borrowed from + * Newcastle University's Arjuna project (http://arjuna.ncl.ac.uk/), + * and Jeff Lee's ANSI Grammar + * (ftp://ftp.uu.net/usenet/net.sources/ansi.c.grammar.Z) + * This grammar is only a subset of the real C++ language. + * + * DATE: Thu Aug 15 13:10:06 EDT 1996 + * $Id: parser.y,v 1.1 2002-09-21 14:12:12 ocoursiere Exp $ + * + * Copyright (c) 1996-1998 Michael John Radwin + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * -------------------------------------------------------------------- + * + * $Log: not supported by cvs2svn $ + * Revision 1.1 2001/11/07 10:06:07 ithamar + * Added stubgen to CVS + * + * Revision 1.72 1998/07/07 00:14:06 mradwin + * removed extra space from throw_decl, cleaned up memory leak + * in ctor skeleton + * + * Revision 1.71 1998/06/11 14:52:09 mradwin + * allow for empty class declarations, such as + * class Element {}; + * also, differentiate structs from classes with + * new STRUCT_KIND tag. + * New version: 2.04 + * + * Revision 1.70 1998/05/11 19:49:11 mradwin + * Version 2.03 (updated copyright information). + * + * Revision 1.69 1998/04/07 23:43:34 mradwin + * changed error-handling code significantly. + * several functions now return a value, and instead of + * calling fatal(), we do a YYABORT or YYERROR to get out + * of the parsing state. + * New version: 2.02. + * + * Revision 1.68 1998/03/28 02:59:41 mradwin + * working on slightly better error recovery; not done yet. + * + * Revision 1.67 1998/03/28 02:34:56 mradwin + * added multi-line function parameters + * also changed pointer and reference (* and &) types so there + * is no trailing space before the parameter name. + * + * Revision 1.66 1998/01/12 19:39:11 mradwin + * modified rcsid + * + * Revision 1.65 1997/11/13 22:50:55 mradwin + * moved copyright from parser.y to main.c + * + * Revision 1.64 1997/11/13 22:40:15 mradwin + * fixed a silly comment bug + * + * Revision 1.63 1997/11/13 22:37:31 mradwin + * changed char[] to char * to make non-gcc compilers + * a little happier. We need to #define const to nothing + * for other compilers as well. + * + * Revision 1.62 97/11/13 21:29:30 21:29:30 mradwin (Michael Radwin) + * moved code from parser.y to main.c + * + * Revision 1.61 1997/11/13 21:10:17 mradwin + * renamed stubgen.[ly] to parser.y lexer.l + * + * Revision 1.60 1997/11/11 04:11:29 mradwin + * fixed command-line flags: invalid options now force usgage. + * + * Revision 1.59 1997/11/11 04:03:56 mradwin + * changed version info + * + * Revision 1.58 1997/11/11 03:54:05 mradwin + * fixed a long-standing bug with -b option. a typo was causing + * the -b flag to be ignored. + * + * Revision 1.57 1997/11/11 03:52:06 mradwin + * changed fatal() + * + * Revision 1.56 1997/11/05 03:02:02 mradwin + * Modified logging routines. + * + * Revision 1.55 1997/11/05 02:14:38 mradwin + * Made some compiler warnings disappear. + * + * Revision 1.54 1997/11/01 23:26:13 mradwin + * new Revision string and usage info + * + * Revision 1.53 1997/11/01 23:12:43 mradwin + * greatly improved error-recovery. errors no longer spill over + * into other files because the yyerror state is properly reset. + * + * Revision 1.52 1997/10/27 01:14:23 mradwin + * fixed constant_value so it supports simple arithmetic. it's + * not as robust as full expressions, but this will handle the + * char buffer[BUFSIZE + 1] problem. + * + * Also removed expansion rules that simply did { $$ = $1; } because + * that action is implicit anyway. + * + * Revision 1.51 1997/10/26 23:16:32 mradwin + * changed inform_user and fatal functions to use varargs + * + * Revision 1.50 1997/10/26 22:27:07 mradwin + * Fixed this bug: + * stubgen dies on the following because the protected section is empty: + * + * class WidgetCsg : public WidgetLens { + * protected: + * + * public: + * virtual ~WidgetCsg() {} + * WidgetCsg(); + * }; + * + * Error: + * stubgen version 2.0-beta $Revision: 1.1 $. + * parse error at line 4, file test.H: + * public: + * ^ + * + * Revision 1.49 1997/10/16 19:42:48 mradwin + * added support for elipses, static member/array initializers, + * and bitfields. + * + * Revision 1.48 1997/10/16 17:35:39 mradwin + * cleaned up usage info + * + * Revision 1.47 1997/10/16 17:12:59 mradwin + * handle extern "C" blocks better now, and support multi-line + * macros. still need error-checking. + * + * Revision 1.46 1997/10/15 22:09:06 mradwin + * changed tons of names. stubelem -> sytaxelem, + * stubin -> infile, stubout -> outfile, stublog -> logfile. + * + * Revision 1.45 1997/10/15 21:33:36 mradwin + * fixed up function_hdr + * + * Revision 1.44 1997/10/15 21:33:02 mradwin + * *** empty log message *** + * + * Revision 1.43 1997/10/15 17:42:37 mradwin + * added support for 'extern "C" { ... }' blocks. + * + * Revision 1.42 1997/09/26 20:59:18 mradwin + * now allow "struct foobar *f" to appear in a parameter + * list or as a variable decl. Had to remove the + * class_or_struct rule and blow up the class_specifier + * description. + * + * Revision 1.41 1997/09/26 19:02:18 mradwin + * fixed memory leak involving template decls in skeleton code. + * Leads me to believe that skel_elemcmp() is flawed, because + * it may rely in parent->templ info. + * + * Revision 1.40 1997/09/26 18:44:22 mradwin + * changed parameter handing from char *'s to an argument type + * to facilitate comparisons between skeleton code + * and header code. Now we can correctly recognize different + * parameter names while still maintaining the same signature. + * + * Revision 1.39 1997/09/26 00:47:29 mradwin + * added better base type support -- recognize things like + * "long long" and "short int" now. + * + * Revision 1.38 1997/09/19 18:16:37 mradwin + * allowed an instance name to come after a class, struct, + * union, or enum. This improves parseability of typedefs + * commonly found in c header files, although true typedefs are + * not understood. + * + * Revision 1.37 1997/09/15 22:38:28 mradwin + * did more revision on the SGDEBUG stuff + * + * Revision 1.36 1997/09/15 19:05:26 mradwin + * allow logging to be compiled out by turning off SGDEBUG + * + * Revision 1.35 1997/09/12 00:58:43 mradwin + * duh, silly me. messed up compilation. + * + * Revision 1.34 1997/09/12 00:57:49 mradwin + * Revision string inserted in usage + * + * Revision 1.33 1997/09/12 00:51:19 mradwin + * string copyright added to code for binary copyright. + * + * Revision 1.32 1997/09/12 00:47:21 mradwin + * some more compactness of grammar with parameter_list_opt + * and also ampersand_opt + * + * Revision 1.31 1997/09/12 00:26:19 mradwin + * better template support, but still poor + * + * Revision 1.30 1997/09/08 23:24:51 mradwin + * changes to error-handling code. + * also got rid of the %type for the top-level rules + * + * Revision 1.30 1997/09/08 23:20:02 mradwin + * some error reporting changes and default values for top-level + * grammar stuff. + * + * Revision 1.29 1997/09/08 17:54:24 mradwin + * cleaned up options and usage info. + * + * Revision 1.28 1997/09/05 19:38:04 mradwin + * changed options for .ext instead of -l or -x + * + * Revision 1.27 1997/09/05 19:17:06 mradwin + * works for scanning old versions, except for parameter + * names that differ between .H and .C files. + * + * Revision 1.26 1997/09/05 16:34:36 mradwin + * GPL-ized code. + * + * Revision 1.25 1997/09/05 16:11:44 mradwin + * some simple cleanup before GPL-izing the code + * + * Revision 1.24 1997/09/04 19:50:34 mradwin + * whoo-hoo! by blowing up the description + * exponentially, it works! + * + * Revision 1.23 1997/03/20 16:05:41 mjr + * renamed syntaxelem to syntaxelem_t, cleaned up throw_decl + * + * Revision 1.22 1996/10/02 15:16:57 mjr + * using pathname.h instead of libgen.h + * + * Revision 1.21 1996/09/12 14:44:49 mjr + * Added throw decl recognition (great, another 4 bytes in syntaxelem) + * and cleaned up the grammar so that const_opt appears in far fewer + * places. const_opt is by default 0 as well, so we don't need to + * pass it as an arg to new_elem(). + * + * I also added a fix to a potential bug with the MINIT and INLIN + * exclusive start states. I think they could have been confused + * by braces within comments, so now I'm grabbing comments in those + * states as well. + * + * Revision 1.20 1996/09/12 04:55:22 mjr + * changed expand strategy. Don't expand while parsing now; + * enqueue as we go along and expand at the end. Eventually + * we'll need to provide similar behavior for when we parse + * .C files + * + * Revision 1.19 1996/09/12 03:46:10 mjr + * No concrete changes in code. Just added some sanity by + * factoring out code into util.[ch] and putting some prototypes + * that were in table.h into stubgen.y where they belong. + * + * Revision 1.18 1996/09/06 14:32:48 mjr + * defined the some_KIND constants for clarity, and made + * expandClass return immediately if it was give something other + * than a CLASS_KIND element. + * + * Revision 1.17 1996/09/06 14:05:44 mjr + * Almost there with expanded operator goodies. Still need + * to get OPERATOR type_name to work. + * + * Revision 1.16 1996/09/04 22:28:09 mjr + * nested classes work and default arguments are now removed + * from the parameter lists. + * + * Revision 1.15 1996/09/04 20:01:57 mjr + * non-functional expanded code. needs work. + * + * Revision 1.14 1996/09/01 21:29:34 mjr + * put the expanded_operator code back in as a useless rule. + * oughta think about fixing it up if possible + * + * Revision 1.13 1996/09/01 20:59:48 mjr + * Added collectMemberInitList() function, which is similar + * to collectInlineDef() and also the exclusive state MINIT + * + * Revision 1.12 1996/08/23 05:09:19 mjr + * fixed up some more portability things + * + * Revision 1.11 1996/08/22 02:43:47 mjr + * added parse error message (using O'Reilly p. 274) + * + * Revision 1.10 1996/08/21 18:33:50 mjr + * added support for template instantiation in the type_name + * rule. surprisingly it didn't cause any shift/reduce conflicts. + * + * Revision 1.9 1996/08/21 17:40:56 mjr + * added some cpp directives for porting to WIN32 + * + * Revision 1.8 1996/08/21 00:00:19 mjr + * approaching stability and usability. command line arguments + * are handled now and the fopens and fcloses appear to work. + * + * Revision 1.7 1996/08/20 20:44:23 mjr + * added initial support for optind but it is incomplete. + * + * Revision 1.6 1996/08/19 17:14:59 mjr + * misordered args, fixed bug + * + * Revision 1.5 1996/08/19 17:11:41 mjr + * RCS got confused with the RCS-style header goodies. + * got it cleaned up now. + * + * Revision 1.4 1996/08/19 17:01:33 mjr + * Removed the expanded code checking and added + * lots of code that duplicates what stubgen.pl did. + * still need options pretty badly + * + * Revision 1.3 1996/08/17 23:21:10 mjr + * added the expanded operator code, cleaned up tabs. + * consider putting all of the expanded code in another + * grammar - this one is getting cluttered. + * + */ +%} + +%{ +#include "table.h" +#include "util.h" +#include +#include +#include + +#ifdef WIN32 +#include /* defintion of alloca */ +#include "getopt.h" /* use GNU getopt */ +#endif /* WIN32 */ + +#ifndef WIN32 +#include +#endif /* WIN32 */ + +/* defined in lexer.l */ +extern int collectInlineDef(); +extern int collectMemberInitList(); + +/* defined here in parser.y */ +static int error_recovery(); +static int yyerror(char *); +static const char rcsid[] = "$Id: parser.y,v 1.1 2002-09-21 14:12:12 ocoursiere Exp $"; + +/* defined in main.c */ +extern FILE *outfile; +extern char *currentFile; +extern int lineno; + +%} + +%union { + char *string; + syntaxelem_t *elt; + arg_t *arg; + int flag; +} + +%token IDENTIFIER CONSTANT STRING_LITERAL +%token CHAR SHORT INT LONG SIGNED UNSIGNED FLOAT DOUBLE VOID +%token NEW DELETE TEMPLATE THROW + +%token PTR_OP INC_OP DEC_OP LEFT_OP RIGHT_OP LE_OP GE_OP EQ_OP NE_OP +%token AND_OP OR_OP MUL_ASSIGN DIV_ASSIGN MOD_ASSIGN ADD_ASSIGN +%token SUB_ASSIGN LEFT_ASSIGN RIGHT_ASSIGN AND_ASSIGN +%token XOR_ASSIGN OR_ASSIGN CLCL MEM_PTR_OP + +%token FRIEND OPERATOR CONST CLASS STRUCT UNION ENUM +%token PROTECTED PRIVATE PUBLIC EXTERN ELIPSIS + +%type simple_type_name simple_signed_type non_reference_type +%type scoped_identifier pointer asterisk +%type type_name binary_operator +%type assignment_operator unary_operator any_operator +%type variable_specifier_list union_specifier +%type constant_value multiple_variable_specifier +%type enum_specifier enumerator_list enumerator +%type template_specifier template_arg template_arg_list +%type template_instance_arg template_instance_arg_list +%type throw_decl throw_list variable_name bitfield_savvy_identifier +%type primary_expression expression +%type multiplicative_expression additive_expression +%type const_opt ampersand_opt +%type class_specifier +%type member_func_specifier function_specifier constructor +%type destructor member_specifier member member_with_access +%type mem_type_specifier member_or_error +%type member_list member_list_opt +%type member_func_inlined type_specifier overloaded_op_specifier +%type member_func_skel member_func_skel_spec +%type constructor_skeleton destructor_skeleton +%type overloaded_op_skeleton function_skeleton +%type variable_or_parameter variable_specifier +%type parameter_list parameter_list_opt unnamed_parameter + + +%start translation_unit +%% + +translation_unit + : declaration + | translation_unit declaration + ; + +declaration + : declaration_specifiers ';' + | EXTERN STRING_LITERAL compound_statement +{ + log_printf("IGNORING extern \"C\" { ... } block.\n"); + free($2); +} + | member_func_inlined +{ + $1->kind = INLINED_KIND; + log_printf("\nBEGIN matched dec : m_f_i rule --"); + print_se($1); + log_printf("END matched dec : m_f_i rule\n"); +} + | function_skeleton +{ + $1->kind = SKEL_KIND; + log_printf("\nBEGIN matched dec : function_skeleton rule --"); + print_se($1); + enqueue_skeleton($1); + log_printf("END matched dec : function_skeleton rule\n"); +} + | ';' + | error +{ + log_printf("declaration : error. Attempting to recover...\n"); + yyerrok; + yyclearin; + if (error_recovery() != 0) { + log_printf("ERROR recovery could not complete -- YYABORT.\n"); + YYABORT; + } + log_printf("ERROR recovery complete.\n"); +} + ; + +declaration_specifiers + : member_specifier +{ + /* the name of the rule "member_specifier" might be misleading, but + * this is either a class, struct, union, enum, global var, global + * prototype, etc.. */ + if ($1->kind == CLASS_KIND || $1->kind == STRUCT_KIND) { + enqueue_class($1); + } else { + log_printf("\nIGNORING dec_spec : mem_spec (%s) --", + string_kind($1->kind)); + print_se($1); + log_printf("END IGNORING dec_spec : mem_spec (%s)\n", + string_kind($1->kind)); + } +} + | forward_decl + ; + +type_specifier + : union_specifier +{ + /* ret_type, name, args, kind */ + syntaxelem_t *elem = new_elem(strdup(""), $1, NULL, IGNORE_KIND); +/* print_se(elem); */ + $$ = elem; +} + | enum_specifier +{ + /* ret_type, name, args, kind */ + syntaxelem_t *elem = new_elem(strdup(""), $1, NULL, IGNORE_KIND); +/* print_se(elem); */ + $$ = elem; +} + | class_specifier + ; + +ampersand_opt + : /* nothing */ { $$ = 0; } + | '&' { $$ = 1; } + ; + +type_name + : non_reference_type ampersand_opt +{ + char *tmp_str = (char *) malloc(strlen($1) + ($2 ? 2 : 0) + 1); + strcpy(tmp_str, $1); + if ($2) + strcat(tmp_str, " &"); + free($1); + $$ = tmp_str; +} + | CONST non_reference_type ampersand_opt +{ + char *tmp_str = (char *) malloc(strlen($2) + ($3 ? 2 : 0) + 7); + sprintf(tmp_str, "const %s%s", $2, ($3 ? " &" : "")); + free($2); + $$ = tmp_str; +} + ; + +forward_decl + : CLASS IDENTIFIER { free($2); } + | CLASS scoped_identifier { free($2); } + | STRUCT IDENTIFIER { free($2); } + | STRUCT scoped_identifier { free($2); } + ; + +non_reference_type + : scoped_identifier + | IDENTIFIER + | STRUCT IDENTIFIER +{ + char *tmp_str = (char *) malloc(strlen($2) + 8); + strcpy(tmp_str, "struct "); + strcat(tmp_str, $2); + free($2); + $$ = tmp_str; +} + | scoped_identifier '<' template_instance_arg_list '>' +{ + char *tmp_str = (char *) malloc(strlen($1) + strlen($3) + 3); + sprintf(tmp_str, "%s<%s>", $1, $3); + free($1); + free($3); + $$ = tmp_str; +} + | IDENTIFIER '<' template_instance_arg_list '>' +{ + char *tmp_str = (char *) malloc(strlen($1) + strlen($3) + 3); + sprintf(tmp_str, "%s<%s>", $1, $3); + free($1); + free($3); + $$ = tmp_str; +} + | scoped_identifier '<' template_instance_arg_list '>' pointer +{ + char *tmp_str = (char *) malloc(strlen($1) + strlen($3) + strlen($5) + 4); + sprintf(tmp_str, "%s<%s> %s", $1, $3, $5); + free($1); + free($3); + free($5); + $$ = tmp_str; +} + | IDENTIFIER '<' template_instance_arg_list '>' pointer +{ + char *tmp_str = (char *) malloc(strlen($1) + strlen($3) + strlen($5) + 4); + sprintf(tmp_str, "%s<%s> %s", $1, $3, $5); + free($1); + free($3); + free($5); + $$ = tmp_str; +} + | scoped_identifier pointer +{ + char *tmp_str = (char *) malloc(strlen($1) + strlen($2) + 2); + sprintf(tmp_str, "%s %s", $1, $2); + free($1); + free($2); + $$ = tmp_str; +} + | IDENTIFIER pointer +{ + char *tmp_str = (char *) malloc(strlen($1) + strlen($2) + 2); + sprintf(tmp_str, "%s %s", $1, $2); + free($1); + free($2); + $$ = tmp_str; +} + | STRUCT IDENTIFIER pointer +{ + char *tmp_str = (char *) malloc(strlen($2) + strlen($3) + 9); + sprintf(tmp_str, "struct %s %s", $2, $3); + free($2); + free($3); + $$ = tmp_str; +} + | simple_signed_type + | simple_signed_type pointer +{ + char *tmp_str = (char *) malloc(strlen($1) + strlen($2) + 2); + sprintf(tmp_str, "%s %s", $1, $2); + free($1); + free($2); + $$ = tmp_str; +} + ; + +simple_signed_type + : simple_type_name + | SIGNED simple_type_name +{ + char *tmp_str = (char *) malloc(strlen($2) + 8); + strcpy(tmp_str,"signed "); + strcat(tmp_str, $2); + free($1); + free($2); + $$ = tmp_str; +} + | UNSIGNED simple_type_name +{ + char *tmp_str = (char *) malloc(strlen($2) + 10); + strcpy(tmp_str,"unsigned "); + strcat(tmp_str, $2); + free($1); + free($2); + $$ = tmp_str; +} + ; + +simple_type_name + : CHAR + | SHORT + | SHORT INT +{ + $$ = strdup("short int"); + free($1); + free($2); +} + | INT + | LONG + | LONG INT +{ + $$ = strdup("long int"); + free($1); + free($2); +} + | LONG LONG +{ + $$ = strdup("long long"); + free($1); + free($2); +} + | LONG LONG INT +{ + $$ = strdup("long long int"); + free($1); + free($2); + free($3); +} + | UNSIGNED + | FLOAT + | DOUBLE + | VOID + ; + +scoped_identifier + : IDENTIFIER CLCL IDENTIFIER +{ + char *tmp_str = (char *) malloc(strlen($1) + strlen($3) + 3); + sprintf(tmp_str, "%s::%s", $1, $3); + free($1); + free($3); + $$ = tmp_str; +} + | scoped_identifier CLCL IDENTIFIER +{ + /* control-Y programming! */ + char *tmp_str = (char *) malloc(strlen($1) + strlen($3) + 3); + sprintf(tmp_str, "%s::%s", $1, $3); + free($1); + free($3); + $$ = tmp_str; +} + ; + +pointer + : asterisk + | pointer asterisk +{ + char *tmp_str = (char *) malloc(strlen($1) + strlen($2) + 1); + strcpy(tmp_str,$1); + strcat(tmp_str,$2); + free($1); + free($2); + $$ = tmp_str; +} + ; + +asterisk + : '*' { $$ = strdup("*"); } + | '*' CONST { $$ = strdup("*const "); } + ; + +variable_or_parameter + : type_name bitfield_savvy_identifier +{ + arg_t *new_arg = (arg_t *) malloc(sizeof(arg_t)); + new_arg->type = $1; + new_arg->name = $2; + new_arg->array = NULL; + new_arg->next = NULL; + $$ = new_arg; +} + | type_name scoped_identifier +{ + arg_t *new_arg = (arg_t *) malloc(sizeof(arg_t)); + new_arg->type = $1; + new_arg->name = $2; + new_arg->array = NULL; + new_arg->next = NULL; + $$ = new_arg; +} + | variable_or_parameter '[' constant_value ']' +{ + char *old_array = $1->array; + int old_len = old_array ? strlen(old_array) : 0; + $1->array = (char *) malloc(strlen($3) + old_len + 3); + sprintf($1->array, "%s[%s]", old_array ? old_array : "", $3); + free($3); + if (old_array) + free(old_array); + $$ = $1; +} + | variable_or_parameter '[' ']' +{ + char *old_array = $1->array; + int old_len = old_array ? strlen(old_array) : 0; + $1->array = (char *) malloc(old_len + 3); + sprintf($1->array, "%s[]", old_array ? old_array : ""); + if (old_array) + free(old_array); + $$ = $1; +} + ; + +bitfield_savvy_identifier + : IDENTIFIER + | IDENTIFIER ':' CONSTANT { free($3); $$ = $1;} + ; + +variable_name + : bitfield_savvy_identifier + | pointer IDENTIFIER +{ + char *tmp_str = (char *) malloc(strlen($1) + strlen($2) + 2); + sprintf(tmp_str, "%s %s", $1, $2); + free($1); + free($2); + $$ = tmp_str; +} + | variable_name '[' constant_value ']' +{ + char *tmp_str = (char *) malloc(strlen($1) + strlen($3) + 3); + sprintf(tmp_str, "%s[%s]", $1, $3); + free($1); + free($3); + $$ = tmp_str; +} + | variable_name '[' ']' +{ + char *tmp_str = (char *) malloc(strlen($1) + 3); + strcpy(tmp_str, $1); + strcat(tmp_str, "[]"); + free($1); + $$ = tmp_str; +} + ; + +variable_specifier + : variable_or_parameter + | EXTERN variable_or_parameter { $$ = $2; } + | variable_or_parameter '=' constant_value +{ + free($3); + $$ = $1; +} + ; + +multiple_variable_specifier + : variable_specifier +{ + $$ = args_to_string($1, 0); + free_args($1); +} + | multiple_variable_specifier ',' variable_name +{ + char *tmp_str = (char *) malloc(strlen($1) + strlen($3) + 3); + sprintf(tmp_str, "%s, %s", $1, $3); + free($1); + free($3); + $$ = tmp_str; +} + ; + +variable_specifier_list + : multiple_variable_specifier ';' +{ + char *tmp_str = (char *) malloc(strlen($1) + 2); + sprintf(tmp_str, "%s;", $1); + free($1); + $$ = tmp_str; +} + | variable_specifier_list multiple_variable_specifier ';' +{ + char *tmp_str = (char *) malloc(strlen($1) + strlen($2) + 3); + sprintf(tmp_str, "%s\n%s;", $1, $2); + free($1); + free($2); + $$ = tmp_str; +} + ; + +parameter_list_opt + : /* nothing */ +{ + $$ = NULL; +} + | parameter_list +{ + $$ = reverse_arg_list($1); +} + | parameter_list ',' ELIPSIS +{ + arg_t *new_arg = (arg_t *) malloc(sizeof(arg_t)); + new_arg->type = strdup("..."); + new_arg->name = NULL; + new_arg->array = NULL; + new_arg->next = $1; + $$ = reverse_arg_list(new_arg); +} + | ELIPSIS +{ + arg_t *new_arg = (arg_t *) malloc(sizeof(arg_t)); + new_arg->type = strdup("..."); + new_arg->name = NULL; + new_arg->array = NULL; + new_arg->next = NULL; + $$ = new_arg; +} + ; + +parameter_list + : variable_specifier + | unnamed_parameter + | parameter_list ',' variable_specifier +{ + $3->next = $1; + $$ = $3; +} + | parameter_list ',' unnamed_parameter +{ + $3->next = $1; + $$ = $3; +} + ; + +unnamed_parameter + : type_name +{ + arg_t *new_arg = (arg_t *) malloc(sizeof(arg_t)); + new_arg->type = $1; + new_arg->name = NULL; + new_arg->array = NULL; + new_arg->next = NULL; + $$ = new_arg; +} + | type_name '=' constant_value +{ + arg_t *new_arg = (arg_t *) malloc(sizeof(arg_t)); + new_arg->type = $1; + new_arg->name = NULL; + new_arg->array = NULL; + new_arg->next = NULL; + free($3); + $$ = new_arg; +} + | unnamed_parameter '[' constant_value ']' +{ + char *old_array = $1->array; + int old_len = old_array ? strlen(old_array) : 0; + $1->array = (char *) malloc(strlen($3) + old_len + 3); + sprintf($1->array, "%s[%s]", old_array ? old_array : "", $3); + free($3); + if (old_array) + free(old_array); + $$ = $1; +} + | unnamed_parameter '[' ']' +{ + char *old_array = $1->array; + int old_len = old_array ? strlen(old_array) : 0; + $1->array = (char *) malloc(old_len + 3); + sprintf($1->array, "%s[]", old_array ? old_array : ""); + if (old_array) + free(old_array); + $$ = $1; +} + ; + +function_skeleton + : member_func_skel compound_statement + | constructor_skeleton ':' + { if (collectMemberInitList() != 0) YYERROR; } compound_statement + | template_specifier member_func_skel compound_statement +{ + /* I think this is the correct behavior, but skel_elemcmp is wrong */ + /* $2->templ = $1; */ + free($1); + $$ = $2; +} + | template_specifier constructor_skeleton ':' + { if (collectMemberInitList() != 0) YYERROR; } compound_statement +{ + /* I think this is the correct behavior, but skel_elemcmp is wrong */ + /* $2->templ = $1; */ + free($1); + $$ = $2; +} + ; + +member_func_inlined + : member_func_specifier compound_statement + | constructor ':' + { if (collectMemberInitList() != 0) YYERROR; } compound_statement + ; + +member_func_skel + : member_func_skel_spec const_opt throw_decl +{ + $1->const_flag = $2; + $1->throw_decl = $3; + $$ = $1; +} + | constructor_skeleton + | destructor_skeleton + ; + +member_func_specifier + : function_specifier const_opt throw_decl +{ + $1->const_flag = $2; + $1->throw_decl = $3; + $$ = $1; +} + | constructor + | destructor + ; + + +member_func_skel_spec + : type_name scoped_identifier '(' parameter_list_opt ')' +{ + /* ret_type, name, args, kind */ + syntaxelem_t *elem = new_elem($1, $2, $4, FUNC_KIND); +/* print_se(elem); */ + $$ = elem; +} + | type_name IDENTIFIER '<' template_instance_arg_list '>' CLCL IDENTIFIER '(' parameter_list_opt ')' +{ + /* ret_type, name, args, kind */ + syntaxelem_t *elem = new_elem($1, + (char *) malloc(strlen($2) + strlen($4) + strlen($7) + 5), + $9, FUNC_KIND); + sprintf(elem->name,"%s<%s>::%s", $2, $4, $7); + free($2); + free($4); + free($7); + $$ = elem; +} + | overloaded_op_skeleton + ; + + + +function_specifier + : type_name IDENTIFIER '(' parameter_list_opt ')' +{ + /* ret_type, name, args, kind */ + syntaxelem_t *elem = new_elem($1, $2, $4, FUNC_KIND); + print_se(elem); + $$ = elem; +} + | overloaded_op_specifier + ; + +overloaded_op_skeleton + : type_name scoped_identifier CLCL OPERATOR any_operator '(' parameter_list_opt ')' +{ + /* ret_type, name, args, kind */ + syntaxelem_t *elem = new_elem($1, (char *)malloc(strlen($2) + strlen($5) + 12), + $7, FUNC_KIND); + sprintf(elem->name, "%s::operator%s", $2, $5); + free($2); + free($5); +/* print_se(elem); */ + $$ = elem; +} + | scoped_identifier CLCL OPERATOR type_name '(' ')' +{ + /* ret_type, name, args, kind */ + syntaxelem_t *elem = new_elem(strdup(""), + (char *)malloc(strlen($1) + strlen($4) + 13), + NULL, FUNC_KIND); + sprintf(elem->name, "%s::operator %s", $1, $4); + free($1); + free($4); +/* print_se(elem); */ + $$ = elem; +} + | type_name IDENTIFIER CLCL OPERATOR any_operator '(' parameter_list_opt ')' +{ + /* ret_type, name, args, kind */ + syntaxelem_t *elem = new_elem($1, (char *)malloc(strlen($2) + strlen($5) + 12), + $7, FUNC_KIND); + sprintf(elem->name, "%s::operator%s", $2, $5); + free($2); + free($5); +/* print_se(elem); */ + $$ = elem; +} + | IDENTIFIER CLCL OPERATOR type_name '(' ')' +{ + /* ret_type, name, args, kind */ + syntaxelem_t *elem = new_elem(strdup(""), + (char *)malloc(strlen($1) + strlen($4) + 13), + NULL, FUNC_KIND); + sprintf(elem->name, "%s::operator %s", $1, $4); + free($1); + free($4); +/* print_se(elem); */ + $$ = elem; +} + ; + +overloaded_op_specifier + : type_name OPERATOR any_operator '(' parameter_list_opt ')' +{ + /* ret_type, name, args, kind */ + syntaxelem_t *elem = new_elem($1, (char *)malloc(strlen($3) + 9), + $5, FUNC_KIND); + sprintf(elem->name, "operator%s", $3); + free($3); + print_se(elem); + $$ = elem; +} + | OPERATOR type_name '(' ')' +{ + /* ret_type, name, args, kind */ + syntaxelem_t *elem = new_elem(strdup(""), (char *)malloc(strlen($2) + 10), + NULL, FUNC_KIND); + sprintf(elem->name, "operator %s", $2); + free($2); + print_se(elem); + $$ = elem; +} + ; + +const_opt + : /* nothing */ { $$ = 0; } + | CONST { $$ = 1; } + ; + +throw_decl + : /* nothing */ { $$ = NULL; } + | THROW '(' throw_list ')' +{ + char *tmp_str = (char *) malloc(strlen($3) + 8); + sprintf(tmp_str, "throw(%s)", $3); + free($3); + $$ = tmp_str; +} + ; + +throw_list + : type_name + | throw_list ',' type_name +{ + char *tmp_str = (char *) malloc(strlen($1) + strlen($3) + 3); + sprintf(tmp_str, "%s, %s", $1, $3); + free($1); + free($3); + $$ = tmp_str; +} + ; + +destructor + : '~' IDENTIFIER '(' ')' +{ + /* ret_type, name, args, kind */ + syntaxelem_t *elem = new_elem(strdup(""), (char *) malloc(strlen($2) + 2), + NULL, FUNC_KIND); + sprintf(elem->name,"~%s", $2); + free($2); +/* print_se(elem); */ + $$ = elem; +} + ; + +destructor_skeleton + : scoped_identifier CLCL '~' IDENTIFIER '(' ')' +{ + /* ret_type, name, args, kind */ + syntaxelem_t *elem = new_elem(strdup(""), + (char *) malloc(strlen($1) + strlen($4) + 4), + NULL, FUNC_KIND); + sprintf(elem->name,"%s::~%s", $1, $4); + free($1); + free($4); +/* print_se(elem); */ + $$ = elem; +} + | IDENTIFIER CLCL '~' IDENTIFIER '(' ')' +{ + /* ret_type, name, args, kind */ + syntaxelem_t *elem = new_elem(strdup(""), + (char *) malloc(strlen($1) + strlen($4) + 4), + NULL, FUNC_KIND); + sprintf(elem->name,"%s::~%s", $1, $4); + free($1); + free($4); +/* print_se(elem); */ + $$ = elem; +} + | IDENTIFIER '<' template_instance_arg_list '>' CLCL '~' IDENTIFIER '(' ')' +{ + /* ret_type, name, args, kind */ + syntaxelem_t *elem = new_elem(strdup(""), + (char *) malloc(strlen($1) + strlen($3) + strlen($7) + 6), + NULL, FUNC_KIND); + sprintf(elem->name,"%s<%s>::~%s", $1, $3, $7); + free($1); + free($3); + free($7); + $$ = elem; +} + | scoped_identifier '<' template_instance_arg_list '>' CLCL '~' IDENTIFIER '(' ')' +{ + /* ret_type, name, args, kind */ + syntaxelem_t *elem = new_elem(strdup(""), + (char *) malloc(strlen($1) + strlen($3) + strlen($7) + 6), + NULL, FUNC_KIND); + sprintf(elem->name,"%s<%s>::~%s", $1, $3, $7); + free($1); + free($3); + free($7); + $$ = elem; +} + ; + +constructor + : IDENTIFIER '(' parameter_list_opt ')' throw_decl +{ + /* ret_type, name, args, kind */ + syntaxelem_t *elem = new_elem(strdup(""), $1, $3, FUNC_KIND); + elem->throw_decl = $5; +/* print_se(elem); */ + $$ = elem; +} + ; + +constructor_skeleton + : scoped_identifier '(' parameter_list_opt ')' throw_decl +{ + /* ret_type, name, args, kind */ + syntaxelem_t *elem = new_elem(strdup(""), $1, $3, FUNC_KIND); + elem->throw_decl = $5; +/* print_se(elem); */ + $$ = elem; +} + | IDENTIFIER '<' template_instance_arg_list '>' CLCL IDENTIFIER '(' parameter_list_opt ')' throw_decl +{ + /* ret_type, name, args, kind */ + syntaxelem_t *elem = new_elem(strdup(""), + (char *) malloc(strlen($1) + strlen($3) + strlen($6) + 5), + $8, FUNC_KIND); + sprintf(elem->name,"%s<%s>::%s", $1, $3, $6); + free($1); + free($3); + free($6); + elem->throw_decl = $10; + $$ = elem; +} + | scoped_identifier '<' template_instance_arg_list '>' CLCL IDENTIFIER '(' parameter_list_opt ')' throw_decl +{ + /* ret_type, name, args, kind */ + syntaxelem_t *elem = new_elem(strdup(""), + (char *) malloc(strlen($1) + strlen($3) + strlen($6) + 5), + $8, FUNC_KIND); + sprintf(elem->name,"%s<%s>::%s", $1, $3, $6); + free($1); + free($3); + free($6); + elem->throw_decl = $10; + $$ = elem; +} + ; + +compound_statement + : '{' { if (collectInlineDef() != 0) YYERROR; } '}' + ; + +enum_specifier + : ENUM '{' enumerator_list '}' +{ + char *tmp_str = (char *) malloc(strlen($3) + 10); + sprintf(tmp_str, "enum { %s }", $3); + free($3); + $$ = tmp_str; +} + | ENUM IDENTIFIER '{' enumerator_list '}' +{ + char *tmp_str = (char *) malloc(strlen($2) + strlen($4) + 11); + sprintf(tmp_str, "enum %s { %s }", $2, $4); + free($2); + free($4); + $$ = tmp_str; +} + | ENUM IDENTIFIER +{ + char *tmp_str = (char *) malloc(strlen($2) + 6); + sprintf(tmp_str, "enum %s", $2); + free($2); + $$ = tmp_str; +} + ; + +enumerator_list + : enumerator + | enumerator_list ',' enumerator +{ + char *tmp_str = (char *) malloc(strlen($1) + strlen($3) + 3); + sprintf(tmp_str, "%s, %s", $1, $3); + free($1); + free($3); + $$ = tmp_str; +} + ; + +enumerator + : IDENTIFIER + | IDENTIFIER '=' constant_value +{ + char *tmp_str = (char *) malloc(strlen($1) + strlen($3) + 2); + sprintf(tmp_str, "%s=%s", $1, $3); + free($1); + free($3); + $$ = tmp_str; +} + ; + +access_specifier_opt + : /* nothing */ + | access_specifier + ; + +access_specifier_list + : access_specifier ':' + | access_specifier_list access_specifier ':' + ; + +access_specifier + : PUBLIC + | PRIVATE + | PROTECTED + ; + +unary_operator + : '&' { $$ = strdup("&"); } + | '*' { $$ = strdup("*"); } + | '+' { $$ = strdup("+"); } + | '-' { $$ = strdup("-"); } + | '~' { $$ = strdup("~"); } + | '!' { $$ = strdup("!"); } + ; + +binary_operator + : '/' { $$ = strdup("/"); } + | '%' { $$ = strdup("%"); } + | '^' { $$ = strdup("^"); } + | '|' { $$ = strdup("|"); } + | '<' { $$ = strdup("<"); } + | '>' { $$ = strdup(">"); } + | ',' { $$ = strdup(","); } + ; + +assignment_operator + : '=' { $$ = strdup("="); } + | MUL_ASSIGN { $$ = strdup("*="); } + | DIV_ASSIGN { $$ = strdup("/="); } + | MOD_ASSIGN { $$ = strdup("%="); } + | ADD_ASSIGN { $$ = strdup("+="); } + | SUB_ASSIGN { $$ = strdup("-="); } + | LEFT_ASSIGN { $$ = strdup("<<="); } + | RIGHT_ASSIGN { $$ = strdup(">>="); } + | AND_ASSIGN { $$ = strdup("&="); } + | XOR_ASSIGN { $$ = strdup("^="); } + | OR_ASSIGN { $$ = strdup("|="); } + ; + +any_operator + : assignment_operator + | unary_operator + | binary_operator + | NEW { $$ = strdup(" new"); } + | DELETE { $$ = strdup(" delete"); } + | PTR_OP { $$ = strdup("->"); } + | MEM_PTR_OP { $$ = strdup("->*"); } + | INC_OP { $$ = strdup("++"); } + | DEC_OP { $$ = strdup("--"); } + | LEFT_OP { $$ = strdup("<<"); } + | RIGHT_OP { $$ = strdup(">>"); } + | LE_OP { $$ = strdup("<="); } + | GE_OP { $$ = strdup(">="); } + | EQ_OP { $$ = strdup("=="); } + | NE_OP { $$ = strdup("!="); } + | AND_OP { $$ = strdup("&&"); } + | OR_OP { $$ = strdup("||"); } + | '[' ']' { $$ = strdup("[]"); } + | '(' ')' { $$ = strdup("()"); } + ; + +constant_value + : expression + | compound_statement { $$ = strdup("{ ... }"); } + ; + +expression + : additive_expression + ; + +primary_expression + : CONSTANT + | '-' CONSTANT +{ + char *tmp_str = (char *) malloc(strlen($2) + 2); + sprintf(tmp_str, "-%s", $2); + free($2); + $$ = tmp_str; +} + | STRING_LITERAL + | IDENTIFIER + | scoped_identifier + | '(' expression ')' +{ + char *tmp_str = (char *) malloc(strlen($2) + 3); + sprintf(tmp_str, "(%s)", $2); + free($2); + $$ = tmp_str; +} + ; + +multiplicative_expression + : primary_expression + | multiplicative_expression '*' primary_expression +{ + char *tmp_str = (char *) malloc(strlen($1) + strlen($3) + 4); + sprintf(tmp_str, "%s * %s", $1, $3); + free($1); + free($3); + $$ = tmp_str; +} + | multiplicative_expression '/' primary_expression +{ + char *tmp_str = (char *) malloc(strlen($1) + strlen($3) + 4); + sprintf(tmp_str, "%s / %s", $1, $3); + free($1); + free($3); + $$ = tmp_str; +} + | multiplicative_expression '%' primary_expression +{ + char *tmp_str = (char *) malloc(strlen($1) + strlen($3) + 4); + sprintf(tmp_str, "%s %% %s", $1, $3); + free($1); + free($3); + $$ = tmp_str; +} + ; + +additive_expression + : multiplicative_expression + | additive_expression '+' multiplicative_expression +{ + char *tmp_str = (char *) malloc(strlen($1) + strlen($3) + 4); + sprintf(tmp_str, "%s + %s", $1, $3); + free($1); + free($3); + $$ = tmp_str; +} + | additive_expression '-' multiplicative_expression +{ + char *tmp_str = (char *) malloc(strlen($1) + strlen($3) + 4); + sprintf(tmp_str, "%s - %s", $1, $3); + free($1); + free($3); + $$ = tmp_str; +} + ; + + +union_specifier + : UNION IDENTIFIER '{' variable_specifier_list '}' +{ + char *tmp_str = (char *) malloc(strlen($2) + strlen($4) + 12); + sprintf(tmp_str, "union %s { %s }", $2, $4); + free($2); + free($4); + $$ = tmp_str; +} + | UNION '{' variable_specifier_list '}' +{ + char *tmp_str = (char *) malloc(strlen($3) + 11); + sprintf(tmp_str, "union { %s }", $3); + free($3); + $$ = tmp_str; +} + | UNION IDENTIFIER +{ + char *tmp_str = (char *) malloc(strlen($2) + 7); + sprintf(tmp_str, "union %s", $2); + free($2); + $$ = tmp_str; +} + ; + +class_specifier + : CLASS IDENTIFIER '{' member_list_opt '}' +{ + syntaxelem_t *child; + /* ret_type, name, args, kind */ + syntaxelem_t *tmp_elem = new_elem(strdup(""), $2, NULL, CLASS_KIND); + tmp_elem->children = reverse_list($4); + + for (child = tmp_elem->children; child != NULL; child = child->next) + child->parent = tmp_elem; + +/* print_se(tmp_elem); */ + $$ = tmp_elem; +} + | CLASS IDENTIFIER ':' superclass_list '{' member_list_opt '}' +{ + syntaxelem_t *child; + /* ret_type, name, args, kind */ + syntaxelem_t *tmp_elem = new_elem(strdup(""), $2, NULL, CLASS_KIND); + tmp_elem->children = reverse_list($6); + + for (child = tmp_elem->children; child != NULL; child = child->next) + child->parent = tmp_elem; + +/* print_se(tmp_elem); */ + $$ = tmp_elem; +} + | template_specifier CLASS IDENTIFIER '{' member_list_opt '}' +{ + syntaxelem_t *child; + /* ret_type, name, args, kind */ + syntaxelem_t *tmp_elem = new_elem(strdup(""), $3, NULL, CLASS_KIND); + tmp_elem->children = reverse_list($5); + tmp_elem->templ = $1; + + for (child = tmp_elem->children; child != NULL; child = child->next) + child->parent = tmp_elem; + +/* print_se(tmp_elem); */ + $$ = tmp_elem; +} + | template_specifier CLASS IDENTIFIER ':' superclass_list '{' member_list_opt '}' +{ + syntaxelem_t *child; + /* ret_type, name, args, kind */ + syntaxelem_t *tmp_elem = new_elem(strdup(""), $3, NULL, CLASS_KIND); + tmp_elem->children = reverse_list($7); + tmp_elem->templ = $1; + + for (child = tmp_elem->children; child != NULL; child = child->next) + child->parent = tmp_elem; + +/* print_se(tmp_elem); */ + $$ = tmp_elem; +} + | STRUCT '{' member_list_opt '}' +{ + syntaxelem_t *child; + /* ret_type, name, args, kind */ + syntaxelem_t *tmp_elem = new_elem(strdup(""), "unnamed_struct", + NULL, IGNORE_KIND); + tmp_elem->children = reverse_list($3); + + for (child = tmp_elem->children; child != NULL; child = child->next) + child->parent = tmp_elem; + +/* print_se(tmp_elem); */ + $$ = tmp_elem; +} + | STRUCT IDENTIFIER '{' member_list_opt '}' +{ + syntaxelem_t *child; + /* ret_type, name, args, kind */ + syntaxelem_t *tmp_elem = new_elem(strdup(""), $2, NULL, STRUCT_KIND); + tmp_elem->children = reverse_list($4); + + for (child = tmp_elem->children; child != NULL; child = child->next) + child->parent = tmp_elem; + +/* print_se(tmp_elem); */ + $$ = tmp_elem; +} + | STRUCT IDENTIFIER ':' superclass_list '{' member_list_opt '}' +{ + syntaxelem_t *child; + /* ret_type, name, args, kind */ + syntaxelem_t *tmp_elem = new_elem(strdup(""), $2, NULL, STRUCT_KIND); + tmp_elem->children = reverse_list($6); + + for (child = tmp_elem->children; child != NULL; child = child->next) + child->parent = tmp_elem; + +/* print_se(tmp_elem); */ + $$ = tmp_elem; +} + | template_specifier STRUCT IDENTIFIER '{' member_list_opt '}' +{ + syntaxelem_t *child; + /* ret_type, name, args, kind */ + syntaxelem_t *tmp_elem = new_elem(strdup(""), $3, NULL, STRUCT_KIND); + tmp_elem->children = reverse_list($5); + tmp_elem->templ = $1; + + for (child = tmp_elem->children; child != NULL; child = child->next) + child->parent = tmp_elem; + +/* print_se(tmp_elem); */ + $$ = tmp_elem; +} + | template_specifier STRUCT IDENTIFIER ':' superclass_list '{' member_list_opt '}' +{ + syntaxelem_t *child; + /* ret_type, name, args, kind */ + syntaxelem_t *tmp_elem = new_elem(strdup(""), $3, NULL, STRUCT_KIND); + tmp_elem->children = reverse_list($7); + tmp_elem->templ = $1; + + for (child = tmp_elem->children; child != NULL; child = child->next) + child->parent = tmp_elem; + +/* print_se(tmp_elem); */ + $$ = tmp_elem; +} + ; + +superclass_list + : superclass + | superclass_list ',' superclass + ; + +superclass + : access_specifier_opt type_name { free($2); } + ; + +friend_specifier + : FRIEND member_func_specifier { $2->kind = IGNORE_KIND; } + | FRIEND forward_decl + ; + +member_list_opt + : /* nothing */ { $$ = NULL; } + | member_list + ; + +member_list + : member_with_access +{ + if ($1 != NULL) + $1->next = NULL; + + $$ = $1; +} + | member_list member_with_access +{ + if ($2 != NULL) { + $2->next = $1; + $$ = $2; + } else { + $$ = $1; + } +} + ; + +member_or_error + : member + | error +{ + log_printf("member_with_access : error. Attempting to recover...\n"); + yyerrok; + yyclearin; + if (error_recovery() != 0) { + log_printf("ERROR recovery could not complete -- YYABORT.\n"); + YYABORT; + } + log_printf("ERROR recovery complete.\n"); + $$ = NULL; +} + ; + +member_with_access + : member_or_error + | access_specifier_list member_or_error { $$ = $2; } + ; + +member + : member_specifier ';' + | friend_specifier ';' { $$ = NULL; } + | member_func_inlined { $1->kind = INLINED_KIND; $$ = $1; } + | ';' { $$ = NULL; } + ; + +member_specifier + : multiple_variable_specifier +{ + /* ret_type, name, args, kind */ + syntaxelem_t *elem = new_elem(strdup(""), $1, NULL, IGNORE_KIND); +/* print_se(elem); */ + $$ = elem; +} + | member_func_specifier + | EXTERN member_func_specifier { $$ = $2; } + | member_func_specifier '=' CONSTANT { $1->kind = IGNORE_KIND; free($3); $$ = $1; } + | mem_type_specifier + ; + +mem_type_specifier + : type_specifier + | type_specifier IDENTIFIER { free($2); $$ = $1; } + | mem_type_specifier '[' ']' + | mem_type_specifier '[' constant_value ']' +{ + free($3); + $$ = $1; +} + ; + +template_arg + : CLASS IDENTIFIER +{ + char *tmp_str = (char *) malloc(strlen($2) + 7); + sprintf(tmp_str, "class %s", $2); + free($2); + $$ = tmp_str; +} + | type_name IDENTIFIER +{ + char *tmp_str = (char *) malloc(strlen($1) + strlen($2) + 2); + sprintf(tmp_str, "%s %s", $1, $2); + free($1); + free($2); + $$ = tmp_str; +} + ; + +template_arg_list + : template_arg + | template_arg_list ',' template_arg +{ + char *tmp_str = (char *) malloc(strlen($1) + strlen($3) + 3); + sprintf(tmp_str, "%s, %s", $1, $3); + free($1); + free($3); + $$ = tmp_str; +} + ; + +template_instance_arg + : CONSTANT + | type_name + ; + +template_instance_arg_list + : template_instance_arg + | template_instance_arg_list ',' template_instance_arg +{ + char *tmp_str = (char *) malloc(strlen($1) + strlen($3) + 3); + sprintf(tmp_str, "%s, %s", $1, $3); + free($1); + free($3); + $$ = tmp_str; +} + ; + +template_specifier + : TEMPLATE '<' template_arg_list '>' +{ + char *tmp_str = (char *) malloc(strlen($3) + 12); + sprintf(tmp_str, "template <%s>", $3); + free($3); + $$ = tmp_str; +} + ; + +%% + +static int yyerror(char *s /*UNUSED*/) +{ + if (outfile != NULL) + fflush(outfile); + + return 0; +} + +static int error_recovery() +{ + extern char linebuf[]; + extern int lineno; + extern int column; + extern int tokens_seen; + +#ifdef SGDEBUG + log_printf("parse error at line %d, file %s:\n%s\n%*s\n", + lineno, currentFile, linebuf, column, "^"); + log_flush(); +#endif /* SGDEBUG */ + + if (tokens_seen == 0) { + /* + * if we've seen no tokens but we're in an error, we must have + * hit an EOF, either by stdin, or on a file. Just give up + * now instead of complaining. + */ + return -1; + + } else { + fprintf(stderr, "parse error at line %d, file %s:\n%s\n%*s\n", + lineno, currentFile, linebuf, column, "^"); + } + + linebuf[0] = '\0'; + + for (;;) { + int result = yylex(); + + if (result <= 0) { + /* fatal error: Unexpected EOF during parse error recovery */ + +#ifdef SGDEBUG + log_printf("EOF in error recovery, line %d, file %s\n", + lineno, currentFile); + log_flush(); +#endif /* SGDEBUG */ + + fprintf(stderr, "EOF in error recovery, line %d, file %s\n", + lineno, currentFile); + + return -1; + } + + switch(result) { + case IDENTIFIER: + case CONSTANT: + case STRING_LITERAL: + case CHAR: + case SHORT: + case INT: + case LONG: + case SIGNED: + case UNSIGNED: + case FLOAT: + case DOUBLE: + case VOID: + free(yylval.string); + break; + case (int) '{': + if (collectInlineDef() != 0) + return -1; + result = yylex(); + return 0; + case (int) ';': + return 0; + } + } +} diff --git a/bepascal/bepascal/stubgen.so/pathname.c b/bepascal/bepascal/stubgen.so/pathname.c new file mode 100644 index 0000000..581299a --- /dev/null +++ b/bepascal/bepascal/stubgen.so/pathname.c @@ -0,0 +1,86 @@ +/* + * FILE: pathname.c + * AUTH: Michael John Radwin + * + * DESC: two important functions from libgen. Largely influenced + * by the gnu dirutils. + * + * DATE: Tue Oct 1 20:48:28 EDT 1996 + * $Id: pathname.c,v 1.1 2002-09-21 14:12:12 ocoursiere Exp $ + * + * Copyright (c) 1996-1998 Michael John Radwin + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include + +#ifdef WIN32 +#define PATH_SEPARATOR_STR "\\" +#define PATH_SEPARATOR_CHAR '\\' +#else +#define PATH_SEPARATOR_STR "/" +#define PATH_SEPARATOR_CHAR '/' +#endif + +static const char rcsid[] = "$Id: pathname.c,v 1.1 2002-09-21 14:12:12 ocoursiere Exp $"; + +static void +strip_trailing_slashes(char *path) +{ + int last = strlen (path) - 1; + while ((last > 0) && (path[last] == PATH_SEPARATOR_CHAR)) + path[last--] = '\0'; +} + +char * +basename(char *path) +{ + char *slash; + + if ((path == NULL) || (path[0] == '\0')) + return "."; + + strip_trailing_slashes(path); + if (path[0] == '\0') + return PATH_SEPARATOR_STR; + + slash = strrchr(path, PATH_SEPARATOR_CHAR); + return (slash) ? slash + 1 : path; +} + +char * +dirname(char *path) +{ + char *slash; + + if ((path == NULL) || (path[0] == '\0')) + return "."; + + strip_trailing_slashes(path); + if (path[0] == '\0') + return PATH_SEPARATOR_STR; + + slash = strrchr(path, PATH_SEPARATOR_CHAR); + if (slash == NULL) + return "."; + + /* Remove any trailing slashes and final element. */ + while (slash > path && *slash == PATH_SEPARATOR_CHAR) + --slash; + slash[1] = 0; + + return path; +} diff --git a/bepascal/bepascal/stubgen.so/pathname.h b/bepascal/bepascal/stubgen.so/pathname.h new file mode 100644 index 0000000..57fa1cd --- /dev/null +++ b/bepascal/bepascal/stubgen.so/pathname.h @@ -0,0 +1,70 @@ +/* + * FILE: pathname.h + * AUTH: Michael John Radwin + * + * DESC: two important functions from libgen + * + * DATE: Tue Oct 1 20:47:55 EDT 1996 + * $Id: pathname.h,v 1.1 2002-09-21 14:12:12 ocoursiere Exp $ + * + * Copyright (c) 1996-1998 Michael John Radwin + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef __pathname_H__ +#define __pathname_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * Given a pointer to a null-terminated character string that contains a + * path name, basename() returns a pointer to the last element of path. + * Trailing ``/'' characters are deleted. In doing this, it may place a + * null byte in the path name after the next to last element, so the + * content of path must be disposable. + * + * If path or *path is zero, pointer to a static constant ``.'' is + * returned. + * + * If path consists entirely of ``/'' characters, the empty string is + * returned. + */ +char * basename(char *path); + +/* + * Given a pointer to a null-terminated character string that contains a + * file system path name, dirname() returns a string that is the parent + * directory of that file. In doing this, it may place a null byte in + * the path name after the next to last element, so the content of path + * must be disposable. The returned string should not be deallocated by + * the caller. Trailing ``/'' characters in the path are not counted as + * part of the path. + * + * If path or *path is zero, a pointer to a static constant ``.'' is + * returned. + * + * dirname() and basename() together yield a complete path name. + * dirname (path) is the directory where basename (path) is found. + */ +char * dirname(char *path); + +#ifdef __cplusplus +} +#endif + +#endif /* __pathname_H__ */ diff --git a/bepascal/bepascal/stubgen.so/stubgen.pp b/bepascal/bepascal/stubgen.so/stubgen.pp new file mode 100644 index 0000000..4778169 --- /dev/null +++ b/bepascal/bepascal/stubgen.so/stubgen.pp @@ -0,0 +1,49 @@ +unit stubgen; + +interface + +uses + Classes, SysUtils; + +{$PACKRECORDS C} + +const + IGNORE_KIND = 0; // a variable or forward declaration */ + FUNC_KIND = 1; // a method declaration */ + CLASS_KIND = 2; // a class declaration */ + INLINED_KIND = 3; // a method w/body in a class decl. */ + SKEL_KIND = 4; // a method found in a code file */ + STRUCT_KIND = 5; // a struct declaration that's a class */ + DONE_FUNC_KIND = 11; // a fn that we've finished expanded */ + DONE_CLASS_KIND = 12; // a class that we've finished expanded */ + +type + PArgument = ^TArgument; + TArgument = record + aType : PChar; + aName : PChar; + aArray : PChar; + Next : PArgument; + end; + + PSyntaxelem = ^TSyntaxelem; + TSyntaxelem = record + aName : PChar; + ret_type : PChar; + args : PArgument; + templ : PChar; + parent : PSyntaxelem; + next : PSyntaxelem; + children : PSyntaxelem; + throw_decl : PChar; + const_flag : Longint; + kind : Longint; + end; + +procedure init_tables; cdecl; external 'stubgen' name 'init_tables'; +procedure free_tables; cdecl; external 'stubgen' name 'free_tables'; +function scan(FileName : PChar) : PSyntaxelem; cdecl; external 'stubgen' name 'scan'; + +implementation + +end. \ No newline at end of file diff --git a/bepascal/bepascal/stubgen.so/table.c b/bepascal/bepascal/stubgen.so/table.c new file mode 100644 index 0000000..58feb5c --- /dev/null +++ b/bepascal/bepascal/stubgen.so/table.c @@ -0,0 +1,441 @@ +/* + * FILE: table.c + * AUTH: Michael John Radwin + * + * DESC: stubgen symbol table goodies + * + * DATE: 1996/08/14 22:04:47 + * $Id: table.c,v 1.1 2002-09-21 14:12:12 ocoursiere Exp $ + * + * Copyright (c) 1996-1998 Michael John Radwin + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "table.h" +#include "util.h" +#include +#include +#include +#include + +static const char rcsid[] = "$Id: table.c,v 1.1 2002-09-21 14:12:12 ocoursiere Exp $"; + +/* global table */ +static syntaxelem_t etable[NELEMS]; +static int eindex; + +/* initializes all of the tables to default values. */ +void init_tables() +{ + memset(etable, 0, sizeof(syntaxelem_t) * NELEMS); + eindex = 0; + +#if 0 + syntaxelem_t *elt; + + for(elt = etable; elt < &etable[NELEMS]; elt++) { + elt->name = NULL; + elt->ret_type = NULL; + elt->args = NULL; + elt->templ = NULL; + elt->parent = NULL; + elt->children = NULL; + elt->throw_decl = NULL; + elt->const_flag = 0; + elt->kind = 73; + } +#endif +} + +/* recursively frees all syntaxelem_t's. */ +void free_tables() +{ + syntaxelem_t *elt; + + for (elt = etable; elt < &etable[NELEMS]; elt++) { + if (elt->name) { + free(elt->name); + free(elt->ret_type); + free_args(elt->args); + + if (elt->throw_decl) free(elt->throw_decl); + if (elt->templ) free(elt->templ); + } + } +} + +/* recursively frees the argument list and assoicated fields */ +void free_args(arg_t *args) +{ + arg_t *a; + + for (a = args; a != NULL; ) { + arg_t *next_arg = a->next; + free(a->type); + if (a->name) + free(a->name); + if (a->array) + free(a->array); + free(a); + a = next_arg; + } +} + +/* compares two arguments for equality. Returns 0 for equal, + non-zero if they differ. */ +int arg_cmp(arg_t *a1, arg_t *a2) +{ + if (strcmp(a1->type, a2->type) != 0) + return 1; + + if (a1->array) { + if (a2->array) { + if (strcmp(a1->array, a2->array) != 0) + return 1; + } else { + return 1; + } + } else if (a2->array) { + return 1; + } + + return 0; +} + +/* recursively compares two argument lists for equality. + Returns 0 for equal, non-zero if they differ. */ +int args_cmp(arg_t *a1, arg_t *a2) +{ + while (a1 != NULL) { + if (a2 == NULL) + return 1; + + if (arg_cmp(a1, a2) != 0) + return 1; + + a1 = a1->next; + a2 = a2->next; + } + + if (a2 != NULL) + return 1; + + return 0; +} + + +/* provides a string rep of this arglist. conses up new + memory, so client is responsible for freeing it. */ +char * args_to_string(arg_t *args, int indent_length) +{ + arg_t *a; + int len = 0; + char *str; + char *indent_str; + + if (indent_length <= 0) { + indent_str = strdup(", "); + indent_length = 2; + + } else { + indent_length += 2; /* room for ",\n" as well */ + indent_str = (char *) malloc(indent_length + 1); + memset(indent_str, ' ', indent_length); + indent_str[0] = ','; + indent_str[1] = '\n'; + indent_str[indent_length] = '\0'; + } + + for (a = args; a != NULL; a = a->next) { + len += strlen(a->type); /* we always have a type */ + if (a->name) + len += (1 + strlen(a->name)); /* room for ' ' and name */ + if (a->array) + len += strlen(a->array); + if (a != args) + len += indent_length; /* room for ", " */ + } + + str = (char *) malloc(len + 1); + str[0] = '\0'; + + for (a = args; a != NULL; a = a->next) { + if (a != args) + strcat(str, indent_str); + + strcat(str, a->type); + if (a->name) { + if (((a->type)[strlen(a->type)-1] != '*') && + ((a->type)[strlen(a->type)-1] != '&')) + strcat(str, " "); + strcat(str, a->name); + if (a->array) + strcat(str, a->array); /* array hugs variable name */ + } else { + if (a->array) + strcat(str, a->array); /* array hugs type name */ + } + } + + free(indent_str); + return str; +} + +/* compares a skeleton element to a header element for equality of + signatures. this isn't a strict comparison, because the kind and + parent fields ought to be different. returns 0 if equal, non-zero if + different */ +int skel_elemcmp(syntaxelem_t *skel_elem, syntaxelem_t *hdr_elem) +{ + char *tmp_str; + int result; + + assert(hdr_elem->kind == FUNC_KIND); + assert(skel_elem->kind == SKEL_KIND); + assert(hdr_elem->parent != NULL); + + if (skel_elem->const_flag != hdr_elem->const_flag) + return 1; + + /* + * templ and throw_decl are allowed to be NULL, + * so we must not pass them onto strcmp without + * a check first. + */ + if (skel_elem->templ != NULL) { + if (hdr_elem->templ == NULL) + return 1; + else if (strcmp(skel_elem->templ, hdr_elem->templ) != 0) + return 1; + } else if (hdr_elem->templ != NULL) { + return 1; + } + + if (skel_elem->throw_decl != NULL) { + if (hdr_elem->throw_decl == NULL) + return 1; + else if (strcmp(skel_elem->throw_decl, hdr_elem->throw_decl) != 0) + return 1; + } else if (hdr_elem->throw_decl != NULL) { + return 1; + } + + /* + * these two won't differ across files, and they're + * guaranteed not to be NULL. + */ + if (strcmp(skel_elem->ret_type, hdr_elem->ret_type) != 0) + return 1; + + /* now make sure the argument signatures match */ + if (args_cmp(skel_elem->args, hdr_elem->args) != 0) + return 1; + + /* + * the name, of course, is the hard part. we gotta + * look at the parent to make a scoped name. + */ + tmp_str = (char *) malloc(strlen(hdr_elem->parent->name) + + strlen(hdr_elem->name) + 3); + sprintf(tmp_str, "%s::%s", hdr_elem->parent->name, hdr_elem->name); + + result = strcmp(skel_elem->name, tmp_str); + free(tmp_str); + + return result; +} + +/* allocates a new element from the table, filling in the apropriate fields */ +syntaxelem_t * new_elem(char *ret_type, char *name, arg_t *args, int kind) +{ + syntaxelem_t *se; + + if (eindex == NELEMS - 1) { + fatal(2, "Too many symbols. Please mail mjr@acm.org."); + return NULL; + } + + se = &etable[eindex++]; + se->ret_type = ret_type; + se->name = name; + se->args = args; + se->kind = kind; + + return se; +} + + +/* given the head of the list, reverses it and returns the new head */ +syntaxelem_t * reverse_list(syntaxelem_t *head) +{ + syntaxelem_t *elt = head; + syntaxelem_t *prev = NULL; + syntaxelem_t *next; + + while (elt != NULL) { + next = elt->next; + elt->next = prev; + prev = elt; + elt = next; + } + + return prev; +} + +arg_t * reverse_arg_list(arg_t *head) +{ + arg_t *a = head; + arg_t *prev = NULL; + arg_t *next; + + while (a != NULL) { + next = a->next; + a->next = prev; + prev = a; + a = next; + } + + return prev; +} + +const char * string_kind(int some_KIND) +{ + switch(some_KIND) { + case IGNORE_KIND: + return "IGNORE_KIND"; + case FUNC_KIND: + return "FUNC_KIND"; + case CLASS_KIND: + return "CLASS_KIND"; + case STRUCT_KIND: + return "STRUCT_KIND"; + case INLINED_KIND: + return "INLINED_KIND"; + case SKEL_KIND: + return "SKEL_KIND"; + case DONE_FUNC_KIND: + return "DONE_FUNC_KIND"; + case DONE_CLASS_KIND: + return "DONE_CLASS_KIND"; + default: + return "BAD KIND!"; + } +} + + +#ifdef SGDEBUG +void print_se(syntaxelem_t *elt) +{ + char *arg_str = args_to_string(elt->args, 0); + + log_printf("\nSTUBELEM name: %s\n", elt->name); + log_printf(" ret_typ: %s\n", elt->ret_type); + log_printf(" args: %s\n", arg_str); + log_printf(" parent: %s\n", (elt->parent) ? elt->parent->name : "NULL"); + log_printf(" next: %s\n", (elt->next) ? elt->next->name : "NULL"); + log_printf(" const: %d\n", elt->const_flag); + log_printf(" kind: %s\n", string_kind(elt->kind)); + log_printf(" throw: %s\n", (elt->throw_decl)? elt->throw_decl : "NULL"); + log_printf(" templ: %s\n\n", (elt->templ)? elt->templ : "NULL"); + free(arg_str); +} +#endif /* SGDEBUG */ + +/* + * we can't use the 'next' field of syntaxelem_t because it is used to + * chain together methods. Make a slightly bigger struct so we can + * queue these up. + */ +typedef struct _skelnode { + syntaxelem_t *elt; + struct _skelnode *next; +} skelnode_t; + +/* the queue of elements found in the .H file, possibly to be expanded */ +static skelnode_t *exp_head = NULL; +static skelnode_t *exp_tail = NULL; + +void enqueue_class(syntaxelem_t *elt) +{ + skelnode_t *new_class; + + new_class = (skelnode_t *)malloc(sizeof(skelnode_t)); + new_class->elt = elt; + new_class->next = NULL; + + if (exp_head == NULL) + exp_tail = exp_head = new_class; + else { + exp_tail->next = new_class; + exp_tail = new_class; + } +} + +syntaxelem_t * dequeue_class() +{ + skelnode_t *old_head = exp_head; + syntaxelem_t *to_return = exp_head->elt; + + assert(exp_head != NULL); + exp_head = exp_head->next; + free(old_head); + + return to_return; +} + +int class_queue_empty() +{ + return exp_head == NULL; +} + +/* the list of skeletons found in the .C file, already expanded */ +static skelnode_t *skel_head = NULL; + +void enqueue_skeleton(syntaxelem_t *elt) +{ + skelnode_t *new_class; + + new_class = (skelnode_t *)malloc(sizeof(skelnode_t)); + new_class->elt = elt; + new_class->next = skel_head; + + skel_head = new_class; +} + +syntaxelem_t * find_skeleton(syntaxelem_t *elt) +{ + skelnode_t *node; + + /* the order of skel_elemcmp(node->elt, elt) is important. */ + for (node = skel_head; node != NULL; node = node->next) + if (skel_elemcmp(node->elt, elt) == 0) + return node->elt; + + return NULL; +} + +void clear_skeleton_queue() +{ + skelnode_t *node = skel_head; + + while (node != NULL) { + skelnode_t *next_node = node->next; + free(node); + node = next_node; + } + + skel_head = NULL; +} diff --git a/bepascal/bepascal/stubgen.so/table.h b/bepascal/bepascal/stubgen.so/table.h new file mode 100644 index 0000000..7d0c70f --- /dev/null +++ b/bepascal/bepascal/stubgen.so/table.h @@ -0,0 +1,119 @@ +/* + * FILE: table.h + * AUTH: Michael John Radwin + * + * DESC: stubgen symbol table goodies + * + * DATE: 1996/08/14 22:04:47 + * $Id: table.h,v 1.1 2002-09-21 14:12:12 ocoursiere Exp $ + * + * Copyright (c) 1996-1998 Michael John Radwin + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef TABLE_HEADER +#define TABLE_HEADER + +#ifdef __cplusplus +extern "C" { +#endif + +#define NELEMS 500 /* maximum number of symbols */ + +#define IGNORE_KIND 0 /* a variable or forward declaration */ +#define FUNC_KIND 1 /* a method declaration */ +#define CLASS_KIND 2 /* a class declaration */ +#define INLINED_KIND 3 /* a method w/body in a class decl. */ +#define SKEL_KIND 4 /* a method found in a code file */ +#define STRUCT_KIND 5 /* a struct declaration that's a class */ +#define DONE_FUNC_KIND 11 /* a fn that we've finished expanded */ +#define DONE_CLASS_KIND 12 /* a class that we've finished expanded */ + +/* returns a pointer to a static string */ +const char * string_kind(int some_KIND); + +/* + * Represents a single argument, often used in a list. + */ +typedef struct arg { + char *type; /* type of this arg. may NOT be NULL */ + char *name; /* formal parameter name. may be NULL */ + char *array; /* any array dimensions may be NULL + appended to name. */ + struct arg *next; /* next argument. may be NULL */ +} arg_t; + +/* + * This structure is central to the program. It might have been more + * elegant with an object-oriented approach consisting of the following + * objects: ignore, method, class, inlined, skeleton. + * + * Instead, however, we have a "throw-it-all-in-one" structure that has + * unused pieces of data, depending on the kind field. + * + * A syntaxelem_t is "valid" if the name field is non-NULL. + */ +typedef struct syntaxelem { + char *name; /* name of class or func. may NOT be NULL */ + char *ret_type; /* return type. may NOT be NULL */ + arg_t *args; /* argument list. may be NULL */ + char *templ; /* template declaration. may be NULL */ + struct syntaxelem *parent; /* parent class */ + struct syntaxelem *next; /* next class or member */ + struct syntaxelem *children; /* children of this class */ + char *throw_decl; /* throw() clause. may be NULL */ + int const_flag; /* 1 if the func is const, 0 if not. */ + int kind; /* some_KIND */ +} syntaxelem_t; + +/* defined in table.c */ +__declspec(dllexport) void init_tables(); +__declspec(dllexport) void free_tables(); + +#ifdef SGDEBUG +void print_se(syntaxelem_t *); +#else +#define print_se(arg) +#endif /* SGDEBUG */ + +/* used in scanning */ +arg_t * reverse_arg_list(arg_t *); +void free_args(arg_t *); +syntaxelem_t *new_elem(char *, char *, arg_t *, int); +syntaxelem_t *reverse_list(syntaxelem_t *); + +/* used in generating output. + allocates memory; someone's gotta clean it up! */ +char *args_to_string(arg_t *, int); + +/* used in comparison with existing skeletons*/ +int skel_elemcmp(syntaxelem_t *skel_elem, syntaxelem_t *hdr_elem); +int strict_elemcmp(syntaxelem_t *e1, syntaxelem_t *e2); + +/* list management primitives */ +void enqueue_class(syntaxelem_t *); +syntaxelem_t * dequeue_class(); +int class_queue_empty(); + +void enqueue_skeleton(syntaxelem_t *); +syntaxelem_t * find_skeleton(syntaxelem_t *); +void clear_skeleton_queue(); + +#ifdef __cplusplus +} +#endif + +#endif /* TABLE_HEADER */ diff --git a/bepascal/bepascal/stubgen.so/util.c b/bepascal/bepascal/stubgen.so/util.c new file mode 100644 index 0000000..8d21322 --- /dev/null +++ b/bepascal/bepascal/stubgen.so/util.c @@ -0,0 +1,147 @@ +/* + * FILE: util.c + * AUTH: Michael John Radwin + * + * DESC: stubgen utility macros and funcs + * + * DATE: Wed Sep 11 23:31:55 EDT 1996 + * $Id: util.c,v 1.1 2002-09-21 14:12:12 ocoursiere Exp $ + * + * Copyright (c) 1996-1998 Michael John Radwin + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include +#include +#include +#include +#include "util.h" + +static const char rcsid[] = "$Id: util.c,v 1.1 2002-09-21 14:12:12 ocoursiere Exp $"; + +#ifdef SGDEBUG +static FILE *logfile; + +int log_open(const char *logfilename) +{ + logfile = fopen(logfilename, "w"); + return (logfile != NULL); +} + +void log_flush() +{ + fflush(logfile); +} + +void log_close() +{ + fclose(logfile); + logfile = NULL; +} + +int log_printf(const char *format, ...) +{ + int retval; + va_list ap; + + va_start(ap, format); + retval = vfprintf(logfile, format, ap); + va_end(ap); + + return retval; +} + +int log_vprintf(const char *format, va_list ap) +{ + return vfprintf(logfile, format, ap); +} + +#else +int log_printf(const char *format /*UNUSED*/, ...) +{ + return 0; +} +#endif /* SGDEBUG */ + + +int inform_user(const char *format, ...) +{ + extern int opt_q; + int retval = 0; + va_list ap; + + if (!opt_q) { + va_start(ap, format); + retval = vfprintf(stderr, format, ap); + va_end(ap); + } + + return retval; +} + +void fatal(int status, const char *format, ...) +{ + va_list ap; + + va_start(ap, format); + log_vprintf(format, ap); + log_flush(); + log_close(); + (void) vfprintf(stderr, format, ap); + va_end(ap); + + fprintf(stderr, "\n"); + exit(status); +} + +#if 0 /* removeDefaultValues() not needed */ +/* + * modifies s by putting a null char in place of the first trailing space + */ +static void removeTrailingSpaces(char *s) +{ + char *end = s + strlen(s) - 1; + char *orig_end = end; + + while(*end == ' ') end--; + if (end != orig_end) *++end = '\0'; +} + +/* + * this both destructively modifies args and conses up a new string. + * be sure to free it up. + */ +char * removeDefaultValues(char *args) +{ + char *token; + char *new_arglist = (char *) malloc(strlen(args) + 1); + int once = 0; + + strcpy(new_arglist, ""); + token = strtok(args, "="); + + while(token != NULL) { + /* only append a comma if strtok got the comma off the arglist */ + if (once++) strcat(new_arglist, ","); + removeTrailingSpaces(token); + strcat(new_arglist, token); + token = strtok(NULL, ","); /* throw away the constant value */ + token = strtok(NULL, "="); /* grab args up til the next = sign */ + } + + return new_arglist; +} +#endif /* removeDefaultValues() not needed */ diff --git a/bepascal/bepascal/stubgen.so/util.h b/bepascal/bepascal/stubgen.so/util.h new file mode 100644 index 0000000..a7e640e --- /dev/null +++ b/bepascal/bepascal/stubgen.so/util.h @@ -0,0 +1,63 @@ +/* + * FILE: util.h + * AUTH: Michael John Radwin + * + * DESC: stubgen utility macros and funcs + * + * DATE: Wed Sep 11 23:31:55 EDT 1996 + * $Id: util.h,v 1.1 2002-09-21 14:12:12 ocoursiere Exp $ + * + * Copyright (c) 1996-1998 Michael John Radwin + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef UTIL_HEADER +#define UTIL_HEADER + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +extern int yylex(); + +/* prints a message to the logfile if debugging is enabled */ +int log_printf(const char *format, ...); + +#ifdef SGDEBUG +int log_vprintf(const char *format, va_list ap); +int log_open(const char *filename); +void log_flush(); +void log_close(); +#else +#define log_vprintf(a,b) +#define log_open(arg) +#define log_flush() +#define log_close() +#endif /* SGDEBUG */ + +/* prints a message to stderr if the -q option is not set */ +int inform_user(const char *format, ...); + +/* prints a message to stderr and exits with return value 1 */ +void fatal(int status, const char *format, ...); + +#ifdef __cplusplus +} +#endif + +#endif /* UTIL_HEADER */ diff --git a/bepascal/bepascal/stubgen.so/y.tab.c b/bepascal/bepascal/stubgen.so/y.tab.c new file mode 100644 index 0000000..6681ab5 --- /dev/null +++ b/bepascal/bepascal/stubgen.so/y.tab.c @@ -0,0 +1,3309 @@ + +/* A Bison parser, made from parser.y + by GNU Bison version 1.28 */ + +#define YYBISON 1 /* Identify Bison output. */ + +#define IDENTIFIER 257 +#define CONSTANT 258 +#define STRING_LITERAL 259 +#define CHAR 260 +#define SHORT 261 +#define INT 262 +#define LONG 263 +#define SIGNED 264 +#define UNSIGNED 265 +#define FLOAT 266 +#define DOUBLE 267 +#define VOID 268 +#define NEW 269 +#define DELETE 270 +#define TEMPLATE 271 +#define THROW 272 +#define PTR_OP 273 +#define INC_OP 274 +#define DEC_OP 275 +#define LEFT_OP 276 +#define RIGHT_OP 277 +#define LE_OP 278 +#define GE_OP 279 +#define EQ_OP 280 +#define NE_OP 281 +#define AND_OP 282 +#define OR_OP 283 +#define MUL_ASSIGN 284 +#define DIV_ASSIGN 285 +#define MOD_ASSIGN 286 +#define ADD_ASSIGN 287 +#define SUB_ASSIGN 288 +#define LEFT_ASSIGN 289 +#define RIGHT_ASSIGN 290 +#define AND_ASSIGN 291 +#define XOR_ASSIGN 292 +#define OR_ASSIGN 293 +#define CLCL 294 +#define MEM_PTR_OP 295 +#define FRIEND 296 +#define OPERATOR 297 +#define CONST 298 +#define CLASS 299 +#define STRUCT 300 +#define UNION 301 +#define ENUM 302 +#define PROTECTED 303 +#define PRIVATE 304 +#define PUBLIC 305 +#define EXTERN 306 +#define ELIPSIS 307 + +#line 1 "parser.y" + +/* + * FILE: parser.y + * AUTH: Michael John Radwin + * + * DESC: stubgen grammar description. Portions borrowed from + * Newcastle University's Arjuna project (http://arjuna.ncl.ac.uk/), + * and Jeff Lee's ANSI Grammar + * (ftp://ftp.uu.net/usenet/net.sources/ansi.c.grammar.Z) + * This grammar is only a subset of the real C++ language. + * + * DATE: Thu Aug 15 13:10:06 EDT 1996 + * $Id: y.tab.c,v 1.1 2002-09-21 14:12:12 ocoursiere Exp $ + * + * Copyright (c) 1996-1998 Michael John Radwin + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * -------------------------------------------------------------------- + * + * $Log: not supported by cvs2svn $ + * Revision 1.1 2001/11/07 10:06:07 ithamar + * Added stubgen to CVS + * + * Revision 1.72 1998/07/07 00:14:06 mradwin + * removed extra space from throw_decl, cleaned up memory leak + * in ctor skeleton + * + * Revision 1.71 1998/06/11 14:52:09 mradwin + * allow for empty class declarations, such as + * class Element {}; + * also, differentiate structs from classes with + * new STRUCT_KIND tag. + * New version: 2.04 + * + * Revision 1.70 1998/05/11 19:49:11 mradwin + * Version 2.03 (updated copyright information). + * + * Revision 1.69 1998/04/07 23:43:34 mradwin + * changed error-handling code significantly. + * several functions now return a value, and instead of + * calling fatal(), we do a YYABORT or YYERROR to get out + * of the parsing state. + * New version: 2.02. + * + * Revision 1.68 1998/03/28 02:59:41 mradwin + * working on slightly better error recovery; not done yet. + * + * Revision 1.67 1998/03/28 02:34:56 mradwin + * added multi-line function parameters + * also changed pointer and reference (* and &) types so there + * is no trailing space before the parameter name. + * + * Revision 1.66 1998/01/12 19:39:11 mradwin + * modified rcsid + * + * Revision 1.65 1997/11/13 22:50:55 mradwin + * moved copyright from parser.y to main.c + * + * Revision 1.64 1997/11/13 22:40:15 mradwin + * fixed a silly comment bug + * + * Revision 1.63 1997/11/13 22:37:31 mradwin + * changed char[] to char * to make non-gcc compilers + * a little happier. We need to #define const to nothing + * for other compilers as well. + * + * Revision 1.62 97/11/13 21:29:30 21:29:30 mradwin (Michael Radwin) + * moved code from parser.y to main.c + * + * Revision 1.61 1997/11/13 21:10:17 mradwin + * renamed stubgen.[ly] to parser.y lexer.l + * + * Revision 1.60 1997/11/11 04:11:29 mradwin + * fixed command-line flags: invalid options now force usgage. + * + * Revision 1.59 1997/11/11 04:03:56 mradwin + * changed version info + * + * Revision 1.58 1997/11/11 03:54:05 mradwin + * fixed a long-standing bug with -b option. a typo was causing + * the -b flag to be ignored. + * + * Revision 1.57 1997/11/11 03:52:06 mradwin + * changed fatal() + * + * Revision 1.56 1997/11/05 03:02:02 mradwin + * Modified logging routines. + * + * Revision 1.55 1997/11/05 02:14:38 mradwin + * Made some compiler warnings disappear. + * + * Revision 1.54 1997/11/01 23:26:13 mradwin + * new Revision string and usage info + * + * Revision 1.53 1997/11/01 23:12:43 mradwin + * greatly improved error-recovery. errors no longer spill over + * into other files because the yyerror state is properly reset. + * + * Revision 1.52 1997/10/27 01:14:23 mradwin + * fixed constant_value so it supports simple arithmetic. it's + * not as robust as full expressions, but this will handle the + * char buffer[BUFSIZE + 1] problem. + * + * Also removed expansion rules that simply did { $$ = $1; } because + * that action is implicit anyway. + * + * Revision 1.51 1997/10/26 23:16:32 mradwin + * changed inform_user and fatal functions to use varargs + * + * Revision 1.50 1997/10/26 22:27:07 mradwin + * Fixed this bug: + * stubgen dies on the following because the protected section is empty: + * + * class WidgetCsg : public WidgetLens { + * protected: + * + * public: + * virtual ~WidgetCsg() {} + * WidgetCsg(); + * }; + * + * Error: + * stubgen version 2.0-beta $Revision: 1.1 $. + * parse error at line 4, file test.H: + * public: + * ^ + * + * Revision 1.49 1997/10/16 19:42:48 mradwin + * added support for elipses, static member/array initializers, + * and bitfields. + * + * Revision 1.48 1997/10/16 17:35:39 mradwin + * cleaned up usage info + * + * Revision 1.47 1997/10/16 17:12:59 mradwin + * handle extern "C" blocks better now, and support multi-line + * macros. still need error-checking. + * + * Revision 1.46 1997/10/15 22:09:06 mradwin + * changed tons of names. stubelem -> sytaxelem, + * stubin -> infile, stubout -> outfile, stublog -> logfile. + * + * Revision 1.45 1997/10/15 21:33:36 mradwin + * fixed up function_hdr + * + * Revision 1.44 1997/10/15 21:33:02 mradwin + * *** empty log message *** + * + * Revision 1.43 1997/10/15 17:42:37 mradwin + * added support for 'extern "C" { ... }' blocks. + * + * Revision 1.42 1997/09/26 20:59:18 mradwin + * now allow "struct foobar *f" to appear in a parameter + * list or as a variable decl. Had to remove the + * class_or_struct rule and blow up the class_specifier + * description. + * + * Revision 1.41 1997/09/26 19:02:18 mradwin + * fixed memory leak involving template decls in skeleton code. + * Leads me to believe that skel_elemcmp() is flawed, because + * it may rely in parent->templ info. + * + * Revision 1.40 1997/09/26 18:44:22 mradwin + * changed parameter handing from char *'s to an argument type + * to facilitate comparisons between skeleton code + * and header code. Now we can correctly recognize different + * parameter names while still maintaining the same signature. + * + * Revision 1.39 1997/09/26 00:47:29 mradwin + * added better base type support -- recognize things like + * "long long" and "short int" now. + * + * Revision 1.38 1997/09/19 18:16:37 mradwin + * allowed an instance name to come after a class, struct, + * union, or enum. This improves parseability of typedefs + * commonly found in c header files, although true typedefs are + * not understood. + * + * Revision 1.37 1997/09/15 22:38:28 mradwin + * did more revision on the SGDEBUG stuff + * + * Revision 1.36 1997/09/15 19:05:26 mradwin + * allow logging to be compiled out by turning off SGDEBUG + * + * Revision 1.35 1997/09/12 00:58:43 mradwin + * duh, silly me. messed up compilation. + * + * Revision 1.34 1997/09/12 00:57:49 mradwin + * Revision string inserted in usage + * + * Revision 1.33 1997/09/12 00:51:19 mradwin + * string copyright added to code for binary copyright. + * + * Revision 1.32 1997/09/12 00:47:21 mradwin + * some more compactness of grammar with parameter_list_opt + * and also ampersand_opt + * + * Revision 1.31 1997/09/12 00:26:19 mradwin + * better template support, but still poor + * + * Revision 1.30 1997/09/08 23:24:51 mradwin + * changes to error-handling code. + * also got rid of the %type for the top-level rules + * + * Revision 1.30 1997/09/08 23:20:02 mradwin + * some error reporting changes and default values for top-level + * grammar stuff. + * + * Revision 1.29 1997/09/08 17:54:24 mradwin + * cleaned up options and usage info. + * + * Revision 1.28 1997/09/05 19:38:04 mradwin + * changed options for .ext instead of -l or -x + * + * Revision 1.27 1997/09/05 19:17:06 mradwin + * works for scanning old versions, except for parameter + * names that differ between .H and .C files. + * + * Revision 1.26 1997/09/05 16:34:36 mradwin + * GPL-ized code. + * + * Revision 1.25 1997/09/05 16:11:44 mradwin + * some simple cleanup before GPL-izing the code + * + * Revision 1.24 1997/09/04 19:50:34 mradwin + * whoo-hoo! by blowing up the description + * exponentially, it works! + * + * Revision 1.23 1997/03/20 16:05:41 mjr + * renamed syntaxelem to syntaxelem_t, cleaned up throw_decl + * + * Revision 1.22 1996/10/02 15:16:57 mjr + * using pathname.h instead of libgen.h + * + * Revision 1.21 1996/09/12 14:44:49 mjr + * Added throw decl recognition (great, another 4 bytes in syntaxelem) + * and cleaned up the grammar so that const_opt appears in far fewer + * places. const_opt is by default 0 as well, so we don't need to + * pass it as an arg to new_elem(). + * + * I also added a fix to a potential bug with the MINIT and INLIN + * exclusive start states. I think they could have been confused + * by braces within comments, so now I'm grabbing comments in those + * states as well. + * + * Revision 1.20 1996/09/12 04:55:22 mjr + * changed expand strategy. Don't expand while parsing now; + * enqueue as we go along and expand at the end. Eventually + * we'll need to provide similar behavior for when we parse + * .C files + * + * Revision 1.19 1996/09/12 03:46:10 mjr + * No concrete changes in code. Just added some sanity by + * factoring out code into util.[ch] and putting some prototypes + * that were in table.h into stubgen.y where they belong. + * + * Revision 1.18 1996/09/06 14:32:48 mjr + * defined the some_KIND constants for clarity, and made + * expandClass return immediately if it was give something other + * than a CLASS_KIND element. + * + * Revision 1.17 1996/09/06 14:05:44 mjr + * Almost there with expanded operator goodies. Still need + * to get OPERATOR type_name to work. + * + * Revision 1.16 1996/09/04 22:28:09 mjr + * nested classes work and default arguments are now removed + * from the parameter lists. + * + * Revision 1.15 1996/09/04 20:01:57 mjr + * non-functional expanded code. needs work. + * + * Revision 1.14 1996/09/01 21:29:34 mjr + * put the expanded_operator code back in as a useless rule. + * oughta think about fixing it up if possible + * + * Revision 1.13 1996/09/01 20:59:48 mjr + * Added collectMemberInitList() function, which is similar + * to collectInlineDef() and also the exclusive state MINIT + * + * Revision 1.12 1996/08/23 05:09:19 mjr + * fixed up some more portability things + * + * Revision 1.11 1996/08/22 02:43:47 mjr + * added parse error message (using O'Reilly p. 274) + * + * Revision 1.10 1996/08/21 18:33:50 mjr + * added support for template instantiation in the type_name + * rule. surprisingly it didn't cause any shift/reduce conflicts. + * + * Revision 1.9 1996/08/21 17:40:56 mjr + * added some cpp directives for porting to WIN32 + * + * Revision 1.8 1996/08/21 00:00:19 mjr + * approaching stability and usability. command line arguments + * are handled now and the fopens and fcloses appear to work. + * + * Revision 1.7 1996/08/20 20:44:23 mjr + * added initial support for optind but it is incomplete. + * + * Revision 1.6 1996/08/19 17:14:59 mjr + * misordered args, fixed bug + * + * Revision 1.5 1996/08/19 17:11:41 mjr + * RCS got confused with the RCS-style header goodies. + * got it cleaned up now. + * + * Revision 1.4 1996/08/19 17:01:33 mjr + * Removed the expanded code checking and added + * lots of code that duplicates what stubgen.pl did. + * still need options pretty badly + * + * Revision 1.3 1996/08/17 23:21:10 mjr + * added the expanded operator code, cleaned up tabs. + * consider putting all of the expanded code in another + * grammar - this one is getting cluttered. + * + */ +#line 334 "parser.y" + +#include "table.h" +#include "util.h" +#include +#include +#include + +#ifdef WIN32 +#include /* defintion of alloca */ +#include "getopt.h" /* use GNU getopt */ +#endif /* WIN32 */ + +#ifndef WIN32 +#include +#endif /* WIN32 */ + +/* defined in lexer.l */ +extern int collectInlineDef(); +extern int collectMemberInitList(); + +/* defined here in parser.y */ +static int error_recovery(); +static int yyerror(char *); +static const char rcsid[] = "$Id: y.tab.c,v 1.1 2002-09-21 14:12:12 ocoursiere Exp $"; + +/* defined in main.c */ +extern FILE *outfile; +extern char *currentFile; +extern int lineno; + + +#line 366 "parser.y" +typedef union { + char *string; + syntaxelem_t *elt; + arg_t *arg; + int flag; +} YYSTYPE; +#include + +#ifndef __cplusplus +#ifndef __STDC__ +#ifndef const +#define const +#endif +#endif +#endif + + + +#define YYFINAL 463 +#define YYFLAG -32768 +#define YYNTBASE 76 + +#define YYTRANSLATE(x) ((unsigned)(x) <= 307 ? yytranslate[x] : 150) + +static const char yytranslate[] = { 0, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 71, 2, 2, 2, 73, 55, 2, 64, + 65, 58, 69, 63, 70, 2, 72, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 61, 54, 56, + 62, 57, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 59, 2, 60, 74, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 67, 75, 68, 66, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 1, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, + 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, + 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, + 47, 48, 49, 50, 51, 52, 53 +}; + +#if YYDEBUG != 0 +static const short yyprhs[] = { 0, + 0, 2, 5, 8, 12, 14, 16, 18, 20, 22, + 24, 26, 28, 30, 31, 33, 36, 40, 43, 46, + 49, 52, 54, 56, 59, 64, 69, 75, 81, 84, + 87, 91, 93, 96, 98, 101, 104, 106, 108, 111, + 113, 115, 118, 121, 125, 127, 129, 131, 133, 137, + 141, 143, 146, 148, 151, 154, 157, 162, 166, 168, + 172, 174, 177, 182, 186, 188, 191, 195, 197, 201, + 204, 208, 209, 211, 215, 217, 219, 221, 225, 229, + 231, 235, 240, 244, 247, 248, 253, 257, 258, 264, + 267, 268, 273, 277, 279, 281, 285, 287, 289, 295, + 306, 308, 314, 316, 325, 332, 341, 348, 355, 360, + 361, 363, 364, 369, 371, 375, 380, 387, 394, 404, + 414, 420, 426, 437, 448, 449, 453, 458, 464, 467, + 469, 473, 475, 479, 480, 482, 485, 489, 491, 493, + 495, 497, 499, 501, 503, 505, 507, 509, 511, 513, + 515, 517, 519, 521, 523, 525, 527, 529, 531, 533, + 535, 537, 539, 541, 543, 545, 547, 549, 551, 553, + 555, 557, 559, 561, 563, 565, 567, 569, 571, 573, + 575, 577, 580, 583, 585, 587, 589, 591, 594, 596, + 598, 600, 604, 606, 610, 614, 618, 620, 624, 628, + 634, 639, 642, 648, 656, 663, 672, 677, 683, 691, + 698, 707, 709, 713, 716, 719, 722, 723, 725, 727, + 730, 732, 734, 736, 739, 742, 745, 747, 749, 751, + 753, 756, 760, 762, 764, 767, 771, 776, 779, 782, + 784, 788, 790, 792, 794, 798 +}; + +static const short yyrhs[] = { 77, + 0, 76, 77, 0, 78, 54, 0, 52, 5, 116, + 0, 101, 0, 98, 0, 54, 0, 1, 0, 143, + 0, 82, 0, 133, 0, 118, 0, 134, 0, 0, + 55, 0, 83, 80, 0, 44, 83, 80, 0, 45, + 3, 0, 45, 86, 0, 46, 3, 0, 46, 86, + 0, 86, 0, 3, 0, 46, 3, 0, 86, 56, + 148, 57, 0, 3, 56, 148, 57, 0, 86, 56, + 148, 57, 87, 0, 3, 56, 148, 57, 87, 0, + 86, 87, 0, 3, 87, 0, 46, 3, 87, 0, + 84, 0, 84, 87, 0, 85, 0, 10, 85, 0, + 11, 85, 0, 6, 0, 7, 0, 7, 8, 0, + 8, 0, 9, 0, 9, 8, 0, 9, 9, 0, + 9, 9, 8, 0, 11, 0, 12, 0, 13, 0, + 14, 0, 3, 40, 3, 0, 86, 40, 3, 0, + 88, 0, 87, 88, 0, 58, 0, 58, 44, 0, + 81, 90, 0, 81, 86, 0, 89, 59, 128, 60, + 0, 89, 59, 60, 0, 3, 0, 3, 61, 4, + 0, 90, 0, 87, 3, 0, 91, 59, 128, 60, + 0, 91, 59, 60, 0, 89, 0, 52, 89, 0, + 89, 62, 128, 0, 92, 0, 93, 63, 91, 0, + 93, 54, 0, 94, 93, 54, 0, 0, 96, 0, + 96, 63, 53, 0, 53, 0, 92, 0, 97, 0, + 96, 63, 92, 0, 96, 63, 97, 0, 81, 0, + 81, 62, 128, 0, 97, 59, 128, 60, 0, 97, + 59, 60, 0, 103, 116, 0, 0, 115, 61, 99, + 116, 0, 149, 103, 116, 0, 0, 149, 115, 61, + 100, 116, 0, 104, 116, 0, 0, 114, 61, 102, + 116, 0, 105, 109, 110, 0, 115, 0, 113, 0, + 106, 109, 110, 0, 114, 0, 112, 0, 81, 86, + 64, 95, 65, 0, 81, 3, 56, 148, 57, 40, + 3, 64, 95, 65, 0, 107, 0, 81, 3, 64, + 95, 65, 0, 108, 0, 81, 86, 40, 43, 127, + 64, 95, 65, 0, 86, 40, 43, 81, 64, 65, + 0, 81, 3, 40, 43, 127, 64, 95, 65, 0, + 3, 40, 43, 81, 64, 65, 0, 81, 43, 127, + 64, 95, 65, 0, 43, 81, 64, 65, 0, 0, + 44, 0, 0, 18, 64, 111, 65, 0, 81, 0, + 111, 63, 81, 0, 66, 3, 64, 65, 0, 86, + 40, 66, 3, 64, 65, 0, 3, 40, 66, 3, + 64, 65, 0, 3, 56, 148, 57, 40, 66, 3, + 64, 65, 0, 86, 56, 148, 57, 40, 66, 3, + 64, 65, 0, 3, 64, 95, 65, 110, 0, 86, + 64, 95, 65, 110, 0, 3, 56, 148, 57, 40, + 3, 64, 95, 65, 110, 0, 86, 56, 148, 57, + 40, 3, 64, 95, 65, 110, 0, 0, 67, 117, + 68, 0, 48, 67, 119, 68, 0, 48, 3, 67, + 119, 68, 0, 48, 3, 0, 120, 0, 119, 63, + 120, 0, 3, 0, 3, 62, 128, 0, 0, 123, + 0, 123, 61, 0, 122, 123, 61, 0, 51, 0, + 50, 0, 49, 0, 55, 0, 58, 0, 69, 0, + 70, 0, 66, 0, 71, 0, 72, 0, 73, 0, + 74, 0, 75, 0, 56, 0, 57, 0, 63, 0, + 62, 0, 30, 0, 31, 0, 32, 0, 33, 0, + 34, 0, 35, 0, 36, 0, 37, 0, 38, 0, + 39, 0, 126, 0, 124, 0, 125, 0, 15, 0, + 16, 0, 19, 0, 41, 0, 20, 0, 21, 0, + 22, 0, 23, 0, 24, 0, 25, 0, 26, 0, + 27, 0, 28, 0, 29, 0, 59, 60, 0, 64, + 65, 0, 129, 0, 116, 0, 132, 0, 4, 0, + 70, 4, 0, 5, 0, 3, 0, 86, 0, 64, + 129, 65, 0, 130, 0, 131, 58, 130, 0, 131, + 72, 130, 0, 131, 73, 130, 0, 131, 0, 132, + 69, 131, 0, 132, 70, 131, 0, 47, 3, 67, + 94, 68, 0, 47, 67, 94, 68, 0, 47, 3, + 0, 45, 3, 67, 138, 68, 0, 45, 3, 61, + 135, 67, 138, 68, 0, 149, 45, 3, 67, 138, + 68, 0, 149, 45, 3, 61, 135, 67, 138, 68, + 0, 46, 67, 138, 68, 0, 46, 3, 67, 138, + 68, 0, 46, 3, 61, 135, 67, 138, 68, 0, + 149, 46, 3, 67, 138, 68, 0, 149, 46, 3, + 61, 135, 67, 138, 68, 0, 136, 0, 135, 63, + 136, 0, 121, 81, 0, 42, 104, 0, 42, 82, + 0, 0, 139, 0, 141, 0, 139, 141, 0, 142, + 0, 1, 0, 140, 0, 122, 140, 0, 143, 54, + 0, 137, 54, 0, 101, 0, 54, 0, 93, 0, + 104, 0, 52, 104, 0, 104, 62, 4, 0, 144, + 0, 79, 0, 79, 3, 0, 144, 59, 60, 0, + 144, 59, 128, 60, 0, 45, 3, 0, 81, 3, + 0, 145, 0, 146, 63, 145, 0, 4, 0, 81, + 0, 147, 0, 148, 63, 147, 0, 17, 56, 146, + 57, 0 +}; + +#endif + +#if YYDEBUG != 0 +static const short yyrline[] = { 0, + 415, 416, 420, 421, 426, 433, 441, 442, 456, 471, + 475, 482, 489, 493, 494, 498, 507, 517, 518, 519, + 520, 524, 525, 526, 534, 542, 550, 559, 568, 576, + 584, 592, 593, 604, 605, 614, 626, 627, 628, 634, + 635, 636, 642, 648, 655, 656, 657, 658, 662, 670, + 682, 683, 695, 696, 700, 709, 718, 729, 742, 743, + 747, 748, 756, 764, 775, 776, 777, 785, 790, 801, + 808, 819, 823, 827, 836, 848, 849, 850, 855, 863, + 872, 882, 893, 906, 907, 909, 909, 916, 918, 927, + 928, 930, 933, 939, 940, 944, 950, 951, 956, 963, + 975, 981, 988, 992, 1003, 1015, 1026, 1041, 1051, 1064, + 1065, 1069, 1070, 1080, 1081, 1092, 1105, 1117, 1129, 1141, + 1156, 1167, 1175, 1188, 1204, 1205, 1208, 1215, 1223, 1233, + 1234, 1245, 1246, 1257, 1258, 1262, 1263, 1267, 1268, 1269, + 1273, 1274, 1275, 1276, 1277, 1278, 1282, 1283, 1284, 1285, + 1286, 1287, 1288, 1292, 1293, 1294, 1295, 1296, 1297, 1298, + 1299, 1300, 1301, 1302, 1306, 1307, 1308, 1309, 1310, 1311, + 1312, 1313, 1314, 1315, 1316, 1317, 1318, 1319, 1320, 1321, + 1322, 1323, 1324, 1328, 1329, 1333, 1337, 1338, 1345, 1346, + 1347, 1348, 1358, 1359, 1367, 1375, 1386, 1387, 1395, 1407, + 1415, 1422, 1432, 1445, 1458, 1472, 1486, 1500, 1513, 1526, + 1540, 1557, 1558, 1562, 1566, 1567, 1571, 1572, 1576, 1583, + 1595, 1596, 1611, 1612, 1616, 1617, 1618, 1619, 1623, 1630, + 1631, 1632, 1633, 1637, 1638, 1639, 1640, 1648, 1655, 1666, + 1667, 1678, 1679, 1683, 1684, 1695 +}; +#endif + + +#if YYDEBUG != 0 || defined (YYERROR_VERBOSE) + +static const char * const yytname[] = { "$","error","$undefined.","IDENTIFIER", +"CONSTANT","STRING_LITERAL","CHAR","SHORT","INT","LONG","SIGNED","UNSIGNED", +"FLOAT","DOUBLE","VOID","NEW","DELETE","TEMPLATE","THROW","PTR_OP","INC_OP", +"DEC_OP","LEFT_OP","RIGHT_OP","LE_OP","GE_OP","EQ_OP","NE_OP","AND_OP","OR_OP", +"MUL_ASSIGN","DIV_ASSIGN","MOD_ASSIGN","ADD_ASSIGN","SUB_ASSIGN","LEFT_ASSIGN", +"RIGHT_ASSIGN","AND_ASSIGN","XOR_ASSIGN","OR_ASSIGN","CLCL","MEM_PTR_OP","FRIEND", +"OPERATOR","CONST","CLASS","STRUCT","UNION","ENUM","PROTECTED","PRIVATE","PUBLIC", +"EXTERN","ELIPSIS","';'","'&'","'<'","'>'","'*'","'['","']'","':'","'='","','", +"'('","')'","'~'","'{'","'}'","'+'","'-'","'!'","'/'","'%'","'^'","'|'","translation_unit", +"declaration","declaration_specifiers","type_specifier","ampersand_opt","type_name", +"forward_decl","non_reference_type","simple_signed_type","simple_type_name", +"scoped_identifier","pointer","asterisk","variable_or_parameter","bitfield_savvy_identifier", +"variable_name","variable_specifier","multiple_variable_specifier","variable_specifier_list", +"parameter_list_opt","parameter_list","unnamed_parameter","function_skeleton", +"@1","@2","member_func_inlined","@3","member_func_skel","member_func_specifier", +"member_func_skel_spec","function_specifier","overloaded_op_skeleton","overloaded_op_specifier", +"const_opt","throw_decl","throw_list","destructor","destructor_skeleton","constructor", +"constructor_skeleton","compound_statement","@4","enum_specifier","enumerator_list", +"enumerator","access_specifier_opt","access_specifier_list","access_specifier", +"unary_operator","binary_operator","assignment_operator","any_operator","constant_value", +"expression","primary_expression","multiplicative_expression","additive_expression", +"union_specifier","class_specifier","superclass_list","superclass","friend_specifier", +"member_list_opt","member_list","member_or_error","member_with_access","member", +"member_specifier","mem_type_specifier","template_arg","template_arg_list","template_instance_arg", +"template_instance_arg_list","template_specifier", NULL +}; +#endif + +static const short yyr1[] = { 0, + 76, 76, 77, 77, 77, 77, 77, 77, 78, 78, + 79, 79, 79, 80, 80, 81, 81, 82, 82, 82, + 82, 83, 83, 83, 83, 83, 83, 83, 83, 83, + 83, 83, 83, 84, 84, 84, 85, 85, 85, 85, + 85, 85, 85, 85, 85, 85, 85, 85, 86, 86, + 87, 87, 88, 88, 89, 89, 89, 89, 90, 90, + 91, 91, 91, 91, 92, 92, 92, 93, 93, 94, + 94, 95, 95, 95, 95, 96, 96, 96, 96, 97, + 97, 97, 97, 98, 99, 98, 98, 100, 98, 101, + 102, 101, 103, 103, 103, 104, 104, 104, 105, 105, + 105, 106, 106, 107, 107, 107, 107, 108, 108, 109, + 109, 110, 110, 111, 111, 112, 113, 113, 113, 113, + 114, 115, 115, 115, 117, 116, 118, 118, 118, 119, + 119, 120, 120, 121, 121, 122, 122, 123, 123, 123, + 124, 124, 124, 124, 124, 124, 125, 125, 125, 125, + 125, 125, 125, 126, 126, 126, 126, 126, 126, 126, + 126, 126, 126, 126, 127, 127, 127, 127, 127, 127, + 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, + 127, 127, 127, 128, 128, 129, 130, 130, 130, 130, + 130, 130, 131, 131, 131, 131, 132, 132, 132, 133, + 133, 133, 134, 134, 134, 134, 134, 134, 134, 134, + 134, 135, 135, 136, 137, 137, 138, 138, 139, 139, + 140, 140, 141, 141, 142, 142, 142, 142, 143, 143, + 143, 143, 143, 144, 144, 144, 144, 145, 145, 146, + 146, 147, 147, 148, 148, 149 +}; + +static const short yyr2[] = { 0, + 1, 2, 2, 3, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 0, 1, 2, 3, 2, 2, 2, + 2, 1, 1, 2, 4, 4, 5, 5, 2, 2, + 3, 1, 2, 1, 2, 2, 1, 1, 2, 1, + 1, 2, 2, 3, 1, 1, 1, 1, 3, 3, + 1, 2, 1, 2, 2, 2, 4, 3, 1, 3, + 1, 2, 4, 3, 1, 2, 3, 1, 3, 2, + 3, 0, 1, 3, 1, 1, 1, 3, 3, 1, + 3, 4, 3, 2, 0, 4, 3, 0, 5, 2, + 0, 4, 3, 1, 1, 3, 1, 1, 5, 10, + 1, 5, 1, 8, 6, 8, 6, 6, 4, 0, + 1, 0, 4, 1, 3, 4, 6, 6, 9, 9, + 5, 5, 10, 10, 0, 3, 4, 5, 2, 1, + 3, 1, 3, 0, 1, 2, 3, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 2, 2, 1, 1, 1, 1, 2, 1, 1, + 1, 3, 1, 3, 3, 3, 1, 3, 3, 5, + 4, 2, 5, 7, 6, 8, 4, 5, 7, 6, + 8, 1, 3, 2, 2, 2, 0, 1, 1, 2, + 1, 1, 1, 2, 2, 2, 1, 1, 1, 1, + 2, 3, 1, 1, 2, 3, 4, 2, 2, 1, + 3, 1, 1, 1, 3, 4 +}; + +static const short yydefact[] = { 0, + 8, 23, 37, 38, 40, 41, 0, 45, 46, 47, + 48, 0, 0, 0, 0, 0, 0, 0, 0, 7, + 0, 0, 1, 0, 234, 0, 10, 14, 32, 34, + 22, 65, 68, 229, 6, 5, 0, 230, 110, 110, + 101, 103, 98, 95, 97, 94, 12, 11, 13, 9, + 233, 0, 0, 0, 53, 72, 30, 51, 39, 42, + 43, 45, 35, 36, 0, 23, 0, 0, 22, 14, + 18, 19, 24, 0, 21, 202, 0, 129, 0, 23, + 0, 0, 66, 231, 97, 0, 2, 3, 235, 59, + 0, 56, 55, 15, 16, 33, 0, 0, 72, 29, + 0, 0, 0, 125, 84, 0, 90, 111, 112, 112, + 91, 85, 0, 23, 0, 0, 0, 0, 94, 49, + 0, 0, 242, 243, 244, 0, 54, 0, 75, 80, + 76, 0, 73, 77, 52, 44, 0, 0, 240, 0, + 0, 0, 24, 0, 0, 0, 17, 134, 0, 134, + 0, 31, 222, 0, 0, 0, 140, 139, 138, 0, + 228, 227, 0, 0, 0, 0, 0, 223, 219, 221, + 0, 0, 0, 0, 0, 0, 0, 132, 0, 130, + 4, 59, 56, 0, 0, 0, 0, 72, 168, 169, + 170, 172, 173, 174, 175, 176, 177, 178, 179, 180, + 181, 155, 156, 157, 158, 159, 160, 161, 162, 163, + 164, 171, 141, 151, 152, 142, 0, 154, 153, 0, + 145, 143, 144, 146, 147, 148, 149, 150, 166, 167, + 165, 0, 0, 72, 50, 0, 0, 0, 0, 190, + 187, 189, 58, 0, 0, 191, 185, 0, 184, 193, + 197, 186, 67, 59, 0, 61, 69, 0, 232, 0, + 93, 96, 0, 0, 236, 0, 0, 24, 0, 0, + 87, 88, 0, 0, 26, 0, 59, 0, 112, 0, + 0, 238, 239, 246, 0, 0, 109, 0, 0, 135, + 0, 212, 0, 0, 0, 0, 0, 0, 216, 215, + 0, 24, 0, 224, 136, 226, 207, 220, 225, 0, + 0, 70, 201, 0, 0, 0, 0, 127, 116, 0, + 0, 60, 0, 182, 183, 72, 0, 0, 0, 0, + 25, 112, 0, 188, 57, 0, 0, 0, 0, 0, + 62, 0, 126, 0, 92, 86, 237, 134, 0, 134, + 0, 0, 0, 0, 0, 28, 245, 81, 121, 74, + 78, 79, 83, 0, 241, 26, 25, 214, 134, 0, + 203, 0, 208, 18, 24, 0, 137, 0, 200, 71, + 128, 133, 131, 0, 0, 102, 0, 0, 99, 0, + 0, 0, 27, 122, 192, 194, 195, 196, 198, 199, + 64, 0, 114, 0, 0, 0, 0, 0, 89, 107, + 118, 0, 0, 82, 213, 0, 0, 72, 0, 108, + 72, 105, 117, 0, 0, 63, 0, 113, 0, 205, + 0, 210, 72, 0, 204, 209, 0, 0, 0, 72, + 0, 115, 0, 0, 0, 0, 106, 72, 104, 0, + 0, 206, 211, 112, 119, 0, 112, 120, 123, 100, + 124, 0, 0 +}; + +static const short yydefgoto[] = { 22, + 23, 24, 25, 95, 82, 27, 28, 29, 30, 69, + 152, 58, 32, 93, 257, 33, 34, 176, 132, 133, + 134, 35, 264, 352, 162, 263, 37, 38, 39, 40, + 41, 42, 109, 261, 404, 43, 44, 45, 46, 247, + 258, 47, 179, 180, 289, 163, 164, 229, 230, 231, + 232, 248, 249, 250, 251, 252, 48, 49, 291, 292, + 165, 166, 167, 168, 169, 170, 171, 51, 139, 140, + 125, 126, 172 +}; + +static const short yypact[] = { 598, +-32768, 138,-32768, 26,-32768, 162, 301, 301,-32768,-32768, +-32768, -3, 874, 886, 75, 17, 18, 20, 154,-32768, + 114, 522,-32768, 85, 180, 37,-32768, 140, 161,-32768, + 159, 123,-32768, 172,-32768,-32768, 208, 166, 250, 250, +-32768,-32768,-32768,-32768, 222, 243,-32768,-32768,-32768,-32768, + 268, 534, 4, 818, 286, 758, 161,-32768,-32768,-32768, + 340,-32768,-32768,-32768, 830, 212, 347, 294, 223, 140, + 108, 319, 82, 443, 319, 295, 686, 297, 362, 209, + 208, 40, 308,-32768,-32768, 306,-32768,-32768,-32768, 116, + 721, 15,-32768,-32768,-32768, 161, 38, 818, 758, 161, + 33, 56, 8,-32768,-32768, 367,-32768,-32768, 354, 354, +-32768,-32768, 71, 234, 371, 372, 373, 208, 316,-32768, + 874, 376,-32768,-32768,-32768, 62,-32768, 874,-32768, 27, +-32768, 315, 318, 323,-32768,-32768, 380, 381,-32768, 198, + 383, 818, 161, 322, 385, 818,-32768, 296, 443, 296, + 443, 161,-32768, 660, 386, 29,-32768,-32768,-32768, 673, +-32768,-32768, 583, 329, 337, 324, 507,-32768,-32768,-32768, + 341, 163, 686, 393, 61, 391, 362, 344, 175,-32768, +-32768, 149, 319, 343, 43, 818, 405, 758,-32768,-32768, +-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, +-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, +-32768,-32768,-32768,-32768,-32768,-32768, 351,-32768,-32768, 348, +-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, +-32768, 350, 59, 758,-32768, 874, 409, 259, 352, 375, +-32768,-32768,-32768, 24, 412, 319,-32768, 359,-32768,-32768, + 228, 284,-32768, 361, 32,-32768, 364, 356,-32768, 365, +-32768,-32768, 208, 208,-32768, 360, -4, 226, 52, 15, +-32768,-32768, 366, 368, 72, 818, 153, 56, 354, 806, + 187,-32768,-32768,-32768, 830, 260,-32768, 262, 874,-32768, + 193,-32768, 363, 232, 370, 425, 431, 64,-32768,-32768, + 267, 230, 378,-32768,-32768,-32768,-32768,-32768,-32768, 433, + 610,-32768,-32768, 158, 190, 56, 362,-32768,-32768, 721, + 274,-32768, 377,-32768,-32768, 758, 721, 382, 394, 397, + 192, 354, 398,-32768,-32768, 24, 24, 24, 24, 24, +-32768, 202,-32768, 874,-32768,-32768,-32768, 296, 443, 296, + 443, 208, 399, 407, 45, 161,-32768,-32768,-32768,-32768, +-32768, 323,-32768, 402,-32768, 161, 161,-32768, 296, 443, +-32768, 443,-32768, 375, 224, 406,-32768, 271,-32768,-32768, +-32768,-32768,-32768, 410, 401,-32768, 408, 411,-32768, 413, + 414, 48, 161,-32768,-32768,-32768,-32768,-32768, 228, 228, +-32768, 416,-32768, 255, 239, 415, 272, 428,-32768,-32768, +-32768, 417, 474,-32768,-32768, 430, 432, 758, 477,-32768, + 758,-32768,-32768, 418, 481,-32768, 874,-32768, 443,-32768, + 443,-32768, 758, 435,-32768,-32768, 436, 438, 439, 758, + 441,-32768, 444, 458, 442, 462,-32768, 758,-32768, 473, + 495,-32768,-32768, 354,-32768, 497, 354,-32768,-32768,-32768, +-32768, 503,-32768 +}; + +static const short yypgoto[] = {-32768, + 484,-32768,-32768, 493, 0, 423, 550,-32768, 333, 129, + 2, -51, -10, 468,-32768, -55, -67, 429, -97,-32768, + 292,-32768,-32768,-32768, 42,-32768, 529, -7,-32768,-32768, +-32768,-32768, 542, -105,-32768,-32768,-32768, -2, 531, -23, +-32768,-32768, 421, 270,-32768,-32768, -124,-32768,-32768,-32768, + -193, -94, 392, 19, 21,-32768,-32768,-32768, -147, 216, +-32768, -133,-32768, 440, 447,-32768, 50,-32768, 353,-32768, + 379, -73, 110 +}; + + +#define YYLAST 932 + + +static const short yytable[] = { 26, + 131, 239, 294, 57, 262, 135, 120, 253, 83, 175, + 254, 84, 68, 105, 107, 293, 85, 295, 266, 73, + 76, 26, 78, 290, 238, 290, 240, 241, 242, 277, + 96, 302, 100, 59, 341, 240, 241, 242, 303, 90, + 235, 36, 182, 131, 135, 120, 121, 412, 135, 50, + 424, 117, 65, 124, 233, 130, 348, 181, 240, 241, + 242, 235, 349, 36, 138, 55, 376, 57, 286, 122, + 100, 50, 288, 240, 241, 242, 174, 71, 234, 91, + 236, 57, 91, 74, 77, 320, 79, 244, 278, 55, + 323, 185, 243, 245, 271, 74, 244, 124, 130, 104, + 135, 327, 245, 237, 255, 175, 91, 186, 314, 52, + 413, 355, 321, 425, 312, 57, 86, 83, 275, 244, + 273, 141, 104, 103, 276, 245, 384, 174, 31, 55, + 265, 52, 131, 388, 244, -20, 328, 104, 88, 55, + 245, 124, 150, 72, 75, 124, 300, 141, 151, 83, + 31, 85, 84, 298, 92, 185, 80, 85, 81, 3, + 4, 5, 6, 7, 8, 9, 10, 11, 148, 60, + 61, 186, 174, 359, 149, 174, 187, 53, 131, 188, + 31, 101, 89, 358, 102, 124, 364, 130, 141, 240, + 241, 242, 141, 54, 94, 55, 13, 14, 97, 67, + 405, 56, 407, 135, 240, 241, 242, 115, 310, 187, + 183, 380, 188, 187, 98, 406, 55, 408, 55, 21, + 103, 382, 99, 290, 361, 290, 394, 106, 387, 246, + 246, 392, 104, 130, 103, 329, 416, 317, 417, 345, + 346, 246, 318, 314, 290, 270, 363, 402, 141, 55, + 244, 141, 317, 104, 284, 369, 245, 381, 183, 370, + 285, 401, 145, 141, 142, 244, 55, 142, 104, 55, + 131, 245, 56, 53, 104, 124, 356, -20, 146, 130, + 55, 55, 111, 55, 138, 336, 350, 55, 368, 54, + 150, 55, 351, 108, 369, 443, 151, 444, 372, 337, + 338, 369, 183, 112, 135, 429, 3, 4, 5, 6, + 174, 62, 9, 10, 11, 331, 366, 427, 367, 428, + 437, 276, 276, 439, 276, 130, 113, 148, 409, 127, + 385, 350, 393, 149, 369, 445, 276, 351, 431, 63, + 64, 135, 450, 403, 157, 158, 159, 136, 459, 143, + 456, 461, 339, 340, 396, 397, 398, 144, 145, 399, + 400, 173, 131, 177, 178, 131, 101, 356, 393, 184, + 259, 260, 246, 267, 268, 269, 272, 131, 274, 279, + 280, 281, 282, 283, 131, 120, 287, 235, 301, 305, + 306, 307, 131, 66, 309, 277, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 316, 246, 319, 322, 246, + 324, 330, 325, 326, 141, 334, 332, 130, 335, 347, + 130, 187, 342, 343, 72, 75, 442, 374, 344, 353, + 371, 354, 130, 375, 14, 378, 67, 373, 377, 130, + 419, 386, 128, 153, 246, 80, 389, 130, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 390, 313, 12, + 391, 414, 395, 410, 246, 246, 246, 246, 246, 188, + 246, 411, 420, 418, 421, 426, 434, 422, 423, 438, + 433, 440, 430, 441, 154, 13, 14, 155, 156, 17, + 18, 157, 158, 159, 160, 432, 161, 435, 446, 436, + 447, 448, 463, 449, 451, 87, 454, 153, 21, 80, + -217, 452, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 462, 1, 12, 2, 453, 455, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 114, 457, 12, 3, + 4, 5, 6, 7, 8, 9, 10, 11, 154, 13, + 14, 155, 156, 17, 18, 157, 158, 159, 160, 458, + 161, 460, 147, 70, 13, 14, 15, 16, 17, 18, + 256, 362, 21, 19, -218, 20, 299, 14, 115, 116, + 118, 110, 119, 153, 415, 80, 383, 21, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 315, 1, 12, + 2, 311, 304, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 66, 308, 12, 3, 4, 5, 6, 7, + 8, 9, 10, 11, 154, 13, 14, 155, 156, 17, + 18, 157, 158, 159, 160, 333, 161, 365, 0, 0, + 13, 14, 15, 16, 17, 18, 0, 0, 21, 19, + 0, 20, 0, 14, 357, 67, 0, 0, 0, 0, + 0, 128, 80, 21, 0, 3, 4, 5, 6, 7, + 8, 9, 10, 11, 0, 80, 0, 379, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 0, 66, 0, + 0, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 0, 0, 13, 14, 296, 297, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 13, 14, 0, 67, 0, + 0, 0, 0, 0, 0, 21, 0, 0, 0, 14, + 0, 67, 0, 0, 0, 189, 190, 128, 21, 191, + 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, + 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, + 66, 212, 0, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 0, 0, 0, 213, 214, 215, 216, 217, + 0, 0, 218, 219, 220, 0, 221, 0, 0, 222, + 223, 224, 225, 226, 227, 228, 0, 0, 0, 0, + 0, 14, 0, 67, 0, 0, 0, 0, 66, 128, + 129, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 66, 123, 0, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 66, 0, 0, 3, 4, 5, 6, 7, + 8, 9, 10, 11, 0, 0, 0, 0, 0, 14, + 0, 67, 0, 0, 0, 0, 0, 128, 360, 0, + 0, 14, 0, 67, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 14, 137, 67, 66, 0, 0, 3, + 4, 5, 6, 7, 8, 9, 10, 11, 66, 0, + 0, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 14, 0, 67, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 67 +}; + +static const short yycheck[] = { 0, + 56, 99, 150, 2, 110, 57, 3, 102, 19, 77, + 3, 19, 13, 37, 38, 149, 19, 151, 113, 3, + 3, 22, 3, 148, 98, 150, 3, 4, 5, 3, + 29, 3, 31, 8, 3, 3, 4, 5, 163, 3, + 3, 0, 3, 99, 96, 3, 43, 3, 100, 0, + 3, 52, 56, 54, 40, 56, 61, 81, 3, 4, + 5, 3, 67, 22, 65, 58, 3, 66, 142, 66, + 69, 22, 146, 3, 4, 5, 77, 3, 64, 43, + 43, 80, 43, 67, 67, 43, 67, 64, 62, 58, + 188, 40, 60, 70, 118, 67, 64, 98, 99, 67, + 152, 43, 70, 66, 103, 173, 43, 56, 176, 0, + 66, 40, 186, 66, 54, 114, 3, 128, 57, 64, + 121, 40, 67, 63, 63, 70, 320, 128, 0, 58, + 60, 22, 188, 327, 64, 54, 234, 67, 54, 58, + 70, 142, 61, 15, 16, 146, 154, 40, 67, 160, + 22, 154, 160, 154, 26, 40, 3, 160, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 61, 8, + 9, 56, 173, 279, 67, 176, 61, 40, 234, 64, + 52, 59, 3, 278, 62, 186, 281, 188, 40, 3, + 4, 5, 40, 56, 55, 58, 43, 44, 40, 46, + 348, 64, 350, 255, 3, 4, 5, 45, 46, 61, + 82, 54, 64, 61, 56, 349, 58, 351, 58, 66, + 63, 316, 64, 348, 280, 350, 332, 62, 326, 101, + 102, 40, 67, 234, 63, 236, 370, 63, 372, 263, + 264, 113, 68, 311, 369, 117, 60, 342, 40, 58, + 64, 40, 63, 67, 57, 63, 70, 68, 130, 67, + 63, 60, 40, 40, 56, 64, 58, 56, 67, 58, + 326, 70, 64, 40, 67, 276, 275, 54, 56, 280, + 58, 58, 61, 58, 285, 58, 61, 58, 289, 56, + 61, 58, 67, 44, 63, 429, 67, 431, 67, 72, + 73, 63, 174, 61, 356, 67, 6, 7, 8, 9, + 311, 11, 12, 13, 14, 57, 57, 63, 57, 65, + 418, 63, 63, 421, 63, 326, 59, 61, 352, 44, + 57, 61, 331, 67, 63, 433, 63, 67, 67, 7, + 8, 393, 440, 344, 49, 50, 51, 8, 454, 3, + 448, 457, 69, 70, 336, 337, 338, 64, 40, 339, + 340, 67, 418, 67, 3, 421, 59, 366, 367, 64, + 4, 18, 244, 3, 3, 3, 61, 433, 3, 65, + 63, 59, 3, 3, 440, 3, 65, 3, 3, 61, + 54, 68, 448, 3, 54, 3, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 62, 278, 65, 4, 281, + 60, 3, 65, 64, 40, 4, 65, 418, 60, 60, + 421, 61, 59, 68, 296, 297, 427, 3, 64, 64, + 68, 64, 433, 3, 44, 3, 46, 68, 61, 440, + 40, 65, 52, 1, 316, 3, 65, 448, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 64, 68, 17, + 64, 60, 65, 65, 336, 337, 338, 339, 340, 64, + 342, 65, 65, 64, 64, 60, 3, 65, 65, 3, + 64, 64, 68, 3, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 68, 54, 68, 64, 68, + 65, 64, 0, 65, 64, 22, 65, 1, 66, 3, + 68, 68, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 0, 1, 17, 3, 68, 65, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 3, 65, 17, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 42, 43, + 44, 45, 46, 47, 48, 49, 50, 51, 52, 65, + 54, 65, 70, 14, 43, 44, 45, 46, 47, 48, + 103, 280, 66, 52, 68, 54, 154, 44, 45, 46, + 52, 40, 52, 1, 369, 3, 317, 66, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 177, 1, 17, + 3, 173, 163, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 3, 167, 17, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 244, 54, 285, -1, -1, + 43, 44, 45, 46, 47, 48, -1, -1, 66, 52, + -1, 54, -1, 44, 276, 46, -1, -1, -1, -1, + -1, 52, 3, 66, -1, 6, 7, 8, 9, 10, + 11, 12, 13, 14, -1, 3, -1, 68, 6, 7, + 8, 9, 10, 11, 12, 13, 14, -1, 3, -1, + -1, 6, 7, 8, 9, 10, 11, 12, 13, 14, + -1, -1, 43, 44, 45, 46, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 43, 44, -1, 46, -1, + -1, -1, -1, -1, -1, 66, -1, -1, -1, 44, + -1, 46, -1, -1, -1, 15, 16, 52, 66, 19, + 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, + 3, 41, -1, 6, 7, 8, 9, 10, 11, 12, + 13, 14, -1, -1, -1, 55, 56, 57, 58, 59, + -1, -1, 62, 63, 64, -1, 66, -1, -1, 69, + 70, 71, 72, 73, 74, 75, -1, -1, -1, -1, + -1, 44, -1, 46, -1, -1, -1, -1, 3, 52, + 53, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 3, 4, -1, 6, 7, 8, 9, 10, 11, 12, + 13, 14, 3, -1, -1, 6, 7, 8, 9, 10, + 11, 12, 13, 14, -1, -1, -1, -1, -1, 44, + -1, 46, -1, -1, -1, -1, -1, 52, 53, -1, + -1, 44, -1, 46, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 44, 45, 46, 3, -1, -1, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 3, -1, + -1, 6, 7, 8, 9, 10, 11, 12, 13, 14, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 44, -1, 46, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 46 +}; +/* -*-C-*- Note some compilers choke on comments on `#line' lines. */ +#line 3 "/etc/bison.simple" +/* This file comes from bison-1.28. */ + +/* Skeleton output parser for bison, + Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* 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. */ + +/* This is the parser code that is written into each bison parser + when the %semantic_parser declaration is not specified in the grammar. + It was written by Richard Stallman by simplifying the hairy parser + used when %semantic_parser is specified. */ + +#ifndef YYSTACK_USE_ALLOCA +#ifdef alloca +#define YYSTACK_USE_ALLOCA +#else /* alloca not defined */ +#ifdef __GNUC__ +#define YYSTACK_USE_ALLOCA +#define alloca __builtin_alloca +#else /* not GNU C. */ +#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386)) || (defined (__BEOS__) && defined (__MWERKS__)) +#define YYSTACK_USE_ALLOCA +#include +#else /* not sparc */ +/* We think this test detects Watcom and Microsoft C. */ +/* This used to test MSDOS, but that is a bad idea + since that symbol is in the user namespace. */ +#if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__) +#if 0 /* No need for malloc.h, which pollutes the namespace; + instead, just don't use alloca. */ +#include +#endif +#else /* not MSDOS, or __TURBOC__ */ +#if defined(_AIX) +/* I don't know what this was needed for, but it pollutes the namespace. + So I turned it off. rms, 2 May 1997. */ +/* #include */ + #pragma alloca +#define YYSTACK_USE_ALLOCA +#else /* not MSDOS, or __TURBOC__, or _AIX */ +#if 0 +#ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up, + and on HPUX 10. Eventually we can turn this on. */ +#define YYSTACK_USE_ALLOCA +#define alloca __builtin_alloca +#endif /* __hpux */ +#endif +#endif /* not _AIX */ +#endif /* not MSDOS, or __TURBOC__ */ +#endif /* not sparc */ +#endif /* not GNU C */ +#endif /* alloca not defined */ +#endif /* YYSTACK_USE_ALLOCA not defined */ + +#ifdef YYSTACK_USE_ALLOCA +#define YYSTACK_ALLOC alloca +#else +#define YYSTACK_ALLOC malloc +#endif + +/* Note: there must be only one dollar sign in this file. + It is replaced by the list of actions, each action + as one case of the switch. */ + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY -2 +#define YYEOF 0 +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrlab1 +/* Like YYERROR except do call yyerror. + This remains here temporarily to ease the + transition to the new meaning of YYERROR, for GCC. + Once GCC version 2 has supplanted version 1, this can go. */ +#define YYFAIL goto yyerrlab +#define YYRECOVERING() (!!yyerrstatus) +#define YYBACKUP(token, value) \ +do \ + if (yychar == YYEMPTY && yylen == 1) \ + { yychar = (token), yylval = (value); \ + yychar1 = YYTRANSLATE (yychar); \ + YYPOPSTACK; \ + goto yybackup; \ + } \ + else \ + { yyerror ("syntax error: cannot back up"); YYERROR; } \ +while (0) + +#define YYTERROR 1 +#define YYERRCODE 256 + +#ifndef YYPURE +#define YYLEX yylex() +#endif + +#ifdef YYPURE +#ifdef YYLSP_NEEDED +#ifdef YYLEX_PARAM +#define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM) +#else +#define YYLEX yylex(&yylval, &yylloc) +#endif +#else /* not YYLSP_NEEDED */ +#ifdef YYLEX_PARAM +#define YYLEX yylex(&yylval, YYLEX_PARAM) +#else +#define YYLEX yylex(&yylval) +#endif +#endif /* not YYLSP_NEEDED */ +#endif + +/* If nonreentrant, generate the variables here */ + +#ifndef YYPURE + +int yychar; /* the lookahead symbol */ +YYSTYPE yylval; /* the semantic value of the */ + /* lookahead symbol */ + +#ifdef YYLSP_NEEDED +YYLTYPE yylloc; /* location data for the lookahead */ + /* symbol */ +#endif + +int yynerrs; /* number of parse errors so far */ +#endif /* not YYPURE */ + +#if YYDEBUG != 0 +int yydebug; /* nonzero means print parse trace */ +/* Since this is uninitialized, it does not stop multiple parsers + from coexisting. */ +#endif + +/* YYINITDEPTH indicates the initial size of the parser's stacks */ + +#ifndef YYINITDEPTH +#define YYINITDEPTH 200 +#endif + +/* YYMAXDEPTH is the maximum size the stacks can grow to + (effective only if the built-in stack extension method is used). */ + +#if YYMAXDEPTH == 0 +#undef YYMAXDEPTH +#endif + +#ifndef YYMAXDEPTH +#define YYMAXDEPTH 10000 +#endif + +/* Define __yy_memcpy. Note that the size argument + should be passed with type unsigned int, because that is what the non-GCC + definitions require. With GCC, __builtin_memcpy takes an arg + of type size_t, but it can handle unsigned int. */ + +#if __GNUC__ > 1 /* GNU C and GNU C++ define this. */ +#define __yy_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT) +#else /* not GNU C or C++ */ +#ifndef __cplusplus + +/* This is the most reliable way to avoid incompatibilities + in available built-in functions on various systems. */ +static void +__yy_memcpy (to, from, count) + char *to; + char *from; + unsigned int count; +{ + register char *f = from; + register char *t = to; + register int i = count; + + while (i-- > 0) + *t++ = *f++; +} + +#else /* __cplusplus */ + +/* This is the most reliable way to avoid incompatibilities + in available built-in functions on various systems. */ +static void +__yy_memcpy (char *to, char *from, unsigned int count) +{ + register char *t = to; + register char *f = from; + register int i = count; + + while (i-- > 0) + *t++ = *f++; +} + +#endif +#endif + +#line 217 "/etc/bison.simple" + +/* The user can define YYPARSE_PARAM as the name of an argument to be passed + into yyparse. The argument should have type void *. + It should actually point to an object. + Grammar actions can access the variable by casting it + to the proper pointer type. */ + +#ifdef YYPARSE_PARAM +#ifdef __cplusplus +#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM +#define YYPARSE_PARAM_DECL +#else /* not __cplusplus */ +#define YYPARSE_PARAM_ARG YYPARSE_PARAM +#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM; +#endif /* not __cplusplus */ +#else /* not YYPARSE_PARAM */ +#define YYPARSE_PARAM_ARG +#define YYPARSE_PARAM_DECL +#endif /* not YYPARSE_PARAM */ + +/* Prevent warning if -Wstrict-prototypes. */ +#ifdef __GNUC__ +#ifdef YYPARSE_PARAM +int yyparse (void *); +#else +int yyparse (void); +#endif +#endif + +int +yyparse(YYPARSE_PARAM_ARG) + YYPARSE_PARAM_DECL +{ + register int yystate; + register int yyn; + register short *yyssp; + register YYSTYPE *yyvsp; + int yyerrstatus; /* number of tokens to shift before error messages enabled */ + int yychar1 = 0; /* lookahead token as an internal (translated) token number */ + + short yyssa[YYINITDEPTH]; /* the state stack */ + YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */ + + short *yyss = yyssa; /* refer to the stacks thru separate pointers */ + YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */ + +#ifdef YYLSP_NEEDED + YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */ + YYLTYPE *yyls = yylsa; + YYLTYPE *yylsp; + +#define YYPOPSTACK (yyvsp--, yyssp--, yylsp--) +#else +#define YYPOPSTACK (yyvsp--, yyssp--) +#endif + + int yystacksize = YYINITDEPTH; + int yyfree_stacks = 0; + +#ifdef YYPURE + int yychar; + YYSTYPE yylval; + int yynerrs; +#ifdef YYLSP_NEEDED + YYLTYPE yylloc; +#endif +#endif + + YYSTYPE yyval; /* the variable used to return */ + /* semantic values from the action */ + /* routines */ + + int yylen; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Starting parse\n"); +#endif + + yystate = 0; + yyerrstatus = 0; + yynerrs = 0; + yychar = YYEMPTY; /* Cause a token to be read. */ + + /* Initialize stack pointers. + Waste one element of value and location stack + so that they stay on the same level as the state stack. + The wasted elements are never initialized. */ + + yyssp = yyss - 1; + yyvsp = yyvs; +#ifdef YYLSP_NEEDED + yylsp = yyls; +#endif + +/* Push a new state, which is found in yystate . */ +/* In all cases, when you get here, the value and location stacks + have just been pushed. so pushing a state here evens the stacks. */ +yynewstate: + + *++yyssp = yystate; + + if (yyssp >= yyss + yystacksize - 1) + { + /* Give user a chance to reallocate the stack */ + /* Use copies of these so that the &'s don't force the real ones into memory. */ + YYSTYPE *yyvs1 = yyvs; + short *yyss1 = yyss; +#ifdef YYLSP_NEEDED + YYLTYPE *yyls1 = yyls; +#endif + + /* Get the current used size of the three stacks, in elements. */ + int size = yyssp - yyss + 1; + +#ifdef yyoverflow + /* Each stack pointer address is followed by the size of + the data in use in that stack, in bytes. */ +#ifdef YYLSP_NEEDED + /* 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", + &yyss1, size * sizeof (*yyssp), + &yyvs1, size * sizeof (*yyvsp), + &yyls1, size * sizeof (*yylsp), + &yystacksize); +#else + yyoverflow("parser stack overflow", + &yyss1, size * sizeof (*yyssp), + &yyvs1, size * sizeof (*yyvsp), + &yystacksize); +#endif + + yyss = yyss1; yyvs = yyvs1; +#ifdef YYLSP_NEEDED + yyls = yyls1; +#endif +#else /* no yyoverflow */ + /* Extend the stack our own way. */ + if (yystacksize >= YYMAXDEPTH) + { + yyerror("parser stack overflow"); + if (yyfree_stacks) + { +#ifndef YYSTACK_USE_ALLOCA + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); +#endif +#endif + } + return 2; + } + yystacksize *= 2; + if (yystacksize > YYMAXDEPTH) + yystacksize = YYMAXDEPTH; +#ifndef YYSTACK_USE_ALLOCA + yyfree_stacks = 1; +#endif + yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp)); + __yy_memcpy ((char *)yyss, (char *)yyss1, + size * (unsigned int) sizeof (*yyssp)); + yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp)); + __yy_memcpy ((char *)yyvs, (char *)yyvs1, + size * (unsigned int) sizeof (*yyvsp)); +#ifdef YYLSP_NEEDED + yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp)); + __yy_memcpy ((char *)yyls, (char *)yyls1, + size * (unsigned int) sizeof (*yylsp)); +#endif +#endif /* no yyoverflow */ + + yyssp = yyss + size - 1; + yyvsp = yyvs + size - 1; +#ifdef YYLSP_NEEDED + yylsp = yyls + size - 1; +#endif + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Stack size increased to %d\n", yystacksize); +#endif + + if (yyssp >= yyss + yystacksize - 1) + YYABORT; + } + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Entering state %d\n", yystate); +#endif + + goto yybackup; + yybackup: + +/* Do appropriate processing given the current state. */ +/* Read a lookahead token if we need one and don't already have one. */ +/* yyresume: */ + + /* First try to decide what to do without reference to lookahead token. */ + + yyn = yypact[yystate]; + if (yyn == YYFLAG) + goto yydefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* yychar is either YYEMPTY or YYEOF + or a valid token in external form. */ + + if (yychar == YYEMPTY) + { +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Reading a token: "); +#endif + yychar = YYLEX; + } + + /* Convert token to internal form (in yychar1) for indexing tables with */ + + if (yychar <= 0) /* This means end of input. */ + { + yychar1 = 0; + yychar = YYEOF; /* Don't call YYLEX any more */ + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Now at end of input.\n"); +#endif + } + else + { + yychar1 = YYTRANSLATE(yychar); + +#if YYDEBUG != 0 + if (yydebug) + { + fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]); + /* Give the individual parser a way to print the precise meaning + of a token, for further debugging info. */ +#ifdef YYPRINT + YYPRINT (stderr, yychar, yylval); +#endif + fprintf (stderr, ")\n"); + } +#endif + } + + yyn += yychar1; + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1) + goto yydefault; + + yyn = yytable[yyn]; + + /* yyn is what to do for this token type in this state. + Negative => reduce, -yyn is rule number. + Positive => shift, yyn is new state. + New state is final state => don't bother to shift, + just return success. + 0, or most negative number => error. */ + + if (yyn < 0) + { + if (yyn == YYFLAG) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + else if (yyn == 0) + goto yyerrlab; + + if (yyn == YYFINAL) + YYACCEPT; + + /* Shift the lookahead token. */ + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]); +#endif + + /* Discard the token being shifted unless it is eof. */ + if (yychar != YYEOF) + yychar = YYEMPTY; + + *++yyvsp = yylval; +#ifdef YYLSP_NEEDED + *++yylsp = yylloc; +#endif + + /* count tokens shifted since error; after three, turn off error status. */ + if (yyerrstatus) yyerrstatus--; + + yystate = yyn; + goto yynewstate; + +/* Do the default action for the current state. */ +yydefault: + + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + +/* Do a reduction. yyn is the number of a rule to reduce with. */ +yyreduce: + yylen = yyr2[yyn]; + if (yylen > 0) + yyval = yyvsp[1-yylen]; /* implement default value of the action */ + +#if YYDEBUG != 0 + if (yydebug) + { + int i; + + fprintf (stderr, "Reducing via rule %d (line %d), ", + yyn, yyrline[yyn]); + + /* Print the symbols being reduced, and their result. */ + for (i = yyprhs[yyn]; yyrhs[i] > 0; i++) + fprintf (stderr, "%s ", yytname[yyrhs[i]]); + fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]); + } +#endif + + + switch (yyn) { + +case 4: +#line 422 "parser.y" +{ + log_printf("IGNORING extern \"C\" { ... } block.\n"); + free(yyvsp[-1].string); +; + break;} +case 5: +#line 427 "parser.y" +{ + yyvsp[0].elt->kind = INLINED_KIND; + log_printf("\nBEGIN matched dec : m_f_i rule --"); + print_se(yyvsp[0].elt); + log_printf("END matched dec : m_f_i rule\n"); +; + break;} +case 6: +#line 434 "parser.y" +{ + yyvsp[0].elt->kind = SKEL_KIND; + log_printf("\nBEGIN matched dec : function_skeleton rule --"); + print_se(yyvsp[0].elt); + enqueue_skeleton(yyvsp[0].elt); + log_printf("END matched dec : function_skeleton rule\n"); +; + break;} +case 8: +#line 443 "parser.y" +{ + log_printf("declaration : error. Attempting to recover...\n"); + yyerrok; + yyclearin; + if (error_recovery() != 0) { + log_printf("ERROR recovery could not complete -- YYABORT.\n"); + YYABORT; + } + log_printf("ERROR recovery complete.\n"); +; + break;} +case 9: +#line 457 "parser.y" +{ + /* the name of the rule "member_specifier" might be misleading, but + * this is either a class, struct, union, enum, global var, global + * prototype, etc.. */ + if (yyvsp[0].elt->kind == CLASS_KIND || yyvsp[0].elt->kind == STRUCT_KIND) { + enqueue_class(yyvsp[0].elt); + } else { + log_printf("\nIGNORING dec_spec : mem_spec (%s) --", + string_kind(yyvsp[0].elt->kind)); + print_se(yyvsp[0].elt); + log_printf("END IGNORING dec_spec : mem_spec (%s)\n", + string_kind(yyvsp[0].elt->kind)); + } +; + break;} +case 11: +#line 476 "parser.y" +{ + /* ret_type, name, args, kind */ + syntaxelem_t *elem = new_elem(strdup(""), yyvsp[0].string, NULL, IGNORE_KIND); +/* print_se(elem); */ + yyval.elt = elem; +; + break;} +case 12: +#line 483 "parser.y" +{ + /* ret_type, name, args, kind */ + syntaxelem_t *elem = new_elem(strdup(""), yyvsp[0].string, NULL, IGNORE_KIND); +/* print_se(elem); */ + yyval.elt = elem; +; + break;} +case 14: +#line 493 "parser.y" +{ yyval.flag = 0; ; + break;} +case 15: +#line 494 "parser.y" +{ yyval.flag = 1; ; + break;} +case 16: +#line 499 "parser.y" +{ + char *tmp_str = (char *) malloc(strlen(yyvsp[-1].string) + (yyvsp[0].flag ? 2 : 0) + 1); + strcpy(tmp_str, yyvsp[-1].string); + if (yyvsp[0].flag) + strcat(tmp_str, " &"); + free(yyvsp[-1].string); + yyval.string = tmp_str; +; + break;} +case 17: +#line 508 "parser.y" +{ + char *tmp_str = (char *) malloc(strlen(yyvsp[-1].string) + (yyvsp[0].flag ? 2 : 0) + 7); + sprintf(tmp_str, "const %s%s", yyvsp[-1].string, (yyvsp[0].flag ? " &" : "")); + free(yyvsp[-1].string); + yyval.string = tmp_str; +; + break;} +case 18: +#line 517 "parser.y" +{ free(yyvsp[0].string); ; + break;} +case 19: +#line 518 "parser.y" +{ free(yyvsp[0].string); ; + break;} +case 20: +#line 519 "parser.y" +{ free(yyvsp[0].string); ; + break;} +case 21: +#line 520 "parser.y" +{ free(yyvsp[0].string); ; + break;} +case 24: +#line 527 "parser.y" +{ + char *tmp_str = (char *) malloc(strlen(yyvsp[0].string) + 8); + strcpy(tmp_str, "struct "); + strcat(tmp_str, yyvsp[0].string); + free(yyvsp[0].string); + yyval.string = tmp_str; +; + break;} +case 25: +#line 535 "parser.y" +{ + char *tmp_str = (char *) malloc(strlen(yyvsp[-3].string) + strlen(yyvsp[-1].string) + 3); + sprintf(tmp_str, "%s<%s>", yyvsp[-3].string, yyvsp[-1].string); + free(yyvsp[-3].string); + free(yyvsp[-1].string); + yyval.string = tmp_str; +; + break;} +case 26: +#line 543 "parser.y" +{ + char *tmp_str = (char *) malloc(strlen(yyvsp[-3].string) + strlen(yyvsp[-1].string) + 3); + sprintf(tmp_str, "%s<%s>", yyvsp[-3].string, yyvsp[-1].string); + free(yyvsp[-3].string); + free(yyvsp[-1].string); + yyval.string = tmp_str; +; + break;} +case 27: +#line 551 "parser.y" +{ + char *tmp_str = (char *) malloc(strlen(yyvsp[-4].string) + strlen(yyvsp[-2].string) + strlen(yyvsp[0].string) + 4); + sprintf(tmp_str, "%s<%s> %s", yyvsp[-4].string, yyvsp[-2].string, yyvsp[0].string); + free(yyvsp[-4].string); + free(yyvsp[-2].string); + free(yyvsp[0].string); + yyval.string = tmp_str; +; + break;} +case 28: +#line 560 "parser.y" +{ + char *tmp_str = (char *) malloc(strlen(yyvsp[-4].string) + strlen(yyvsp[-2].string) + strlen(yyvsp[0].string) + 4); + sprintf(tmp_str, "%s<%s> %s", yyvsp[-4].string, yyvsp[-2].string, yyvsp[0].string); + free(yyvsp[-4].string); + free(yyvsp[-2].string); + free(yyvsp[0].string); + yyval.string = tmp_str; +; + break;} +case 29: +#line 569 "parser.y" +{ + char *tmp_str = (char *) malloc(strlen(yyvsp[-1].string) + strlen(yyvsp[0].string) + 2); + sprintf(tmp_str, "%s %s", yyvsp[-1].string, yyvsp[0].string); + free(yyvsp[-1].string); + free(yyvsp[0].string); + yyval.string = tmp_str; +; + break;} +case 30: +#line 577 "parser.y" +{ + char *tmp_str = (char *) malloc(strlen(yyvsp[-1].string) + strlen(yyvsp[0].string) + 2); + sprintf(tmp_str, "%s %s", yyvsp[-1].string, yyvsp[0].string); + free(yyvsp[-1].string); + free(yyvsp[0].string); + yyval.string = tmp_str; +; + break;} +case 31: +#line 585 "parser.y" +{ + char *tmp_str = (char *) malloc(strlen(yyvsp[-1].string) + strlen(yyvsp[0].string) + 9); + sprintf(tmp_str, "struct %s %s", yyvsp[-1].string, yyvsp[0].string); + free(yyvsp[-1].string); + free(yyvsp[0].string); + yyval.string = tmp_str; +; + break;} +case 33: +#line 594 "parser.y" +{ + char *tmp_str = (char *) malloc(strlen(yyvsp[-1].string) + strlen(yyvsp[0].string) + 2); + sprintf(tmp_str, "%s %s", yyvsp[-1].string, yyvsp[0].string); + free(yyvsp[-1].string); + free(yyvsp[0].string); + yyval.string = tmp_str; +; + break;} +case 35: +#line 606 "parser.y" +{ + char *tmp_str = (char *) malloc(strlen(yyvsp[0].string) + 8); + strcpy(tmp_str,"signed "); + strcat(tmp_str, yyvsp[0].string); + free(yyvsp[-1].string); + free(yyvsp[0].string); + yyval.string = tmp_str; +; + break;} +case 36: +#line 615 "parser.y" +{ + char *tmp_str = (char *) malloc(strlen(yyvsp[0].string) + 10); + strcpy(tmp_str,"unsigned "); + strcat(tmp_str, yyvsp[0].string); + free(yyvsp[-1].string); + free(yyvsp[0].string); + yyval.string = tmp_str; +; + break;} +case 39: +#line 629 "parser.y" +{ + yyval.string = strdup("short int"); + free(yyvsp[-1].string); + free(yyvsp[0].string); +; + break;} +case 42: +#line 637 "parser.y" +{ + yyval.string = strdup("long int"); + free(yyvsp[-1].string); + free(yyvsp[0].string); +; + break;} +case 43: +#line 643 "parser.y" +{ + yyval.string = strdup("long long"); + free(yyvsp[-1].string); + free(yyvsp[0].string); +; + break;} +case 44: +#line 649 "parser.y" +{ + yyval.string = strdup("long long int"); + free(yyvsp[-2].string); + free(yyvsp[-1].string); + free(yyvsp[0].string); +; + break;} +case 49: +#line 663 "parser.y" +{ + char *tmp_str = (char *) malloc(strlen(yyvsp[-2].string) + strlen(yyvsp[0].string) + 3); + sprintf(tmp_str, "%s::%s", yyvsp[-2].string, yyvsp[0].string); + free(yyvsp[-2].string); + free(yyvsp[0].string); + yyval.string = tmp_str; +; + break;} +case 50: +#line 671 "parser.y" +{ + /* control-Y programming! */ + char *tmp_str = (char *) malloc(strlen(yyvsp[-2].string) + strlen(yyvsp[0].string) + 3); + sprintf(tmp_str, "%s::%s", yyvsp[-2].string, yyvsp[0].string); + free(yyvsp[-2].string); + free(yyvsp[0].string); + yyval.string = tmp_str; +; + break;} +case 52: +#line 684 "parser.y" +{ + char *tmp_str = (char *) malloc(strlen(yyvsp[-1].string) + strlen(yyvsp[0].string) + 1); + strcpy(tmp_str,yyvsp[-1].string); + strcat(tmp_str,yyvsp[0].string); + free(yyvsp[-1].string); + free(yyvsp[0].string); + yyval.string = tmp_str; +; + break;} +case 53: +#line 695 "parser.y" +{ yyval.string = strdup("*"); ; + break;} +case 54: +#line 696 "parser.y" +{ yyval.string = strdup("*const "); ; + break;} +case 55: +#line 701 "parser.y" +{ + arg_t *new_arg = (arg_t *) malloc(sizeof(arg_t)); + new_arg->type = yyvsp[-1].string; + new_arg->name = yyvsp[0].string; + new_arg->array = NULL; + new_arg->next = NULL; + yyval.arg = new_arg; +; + break;} +case 56: +#line 710 "parser.y" +{ + arg_t *new_arg = (arg_t *) malloc(sizeof(arg_t)); + new_arg->type = yyvsp[-1].string; + new_arg->name = yyvsp[0].string; + new_arg->array = NULL; + new_arg->next = NULL; + yyval.arg = new_arg; +; + break;} +case 57: +#line 719 "parser.y" +{ + char *old_array = yyvsp[-3].arg->array; + int old_len = old_array ? strlen(old_array) : 0; + yyvsp[-3].arg->array = (char *) malloc(strlen(yyvsp[-1].string) + old_len + 3); + sprintf(yyvsp[-3].arg->array, "%s[%s]", old_array ? old_array : "", yyvsp[-1].string); + free(yyvsp[-1].string); + if (old_array) + free(old_array); + yyval.arg = yyvsp[-3].arg; +; + break;} +case 58: +#line 730 "parser.y" +{ + char *old_array = yyvsp[-2].arg->array; + int old_len = old_array ? strlen(old_array) : 0; + yyvsp[-2].arg->array = (char *) malloc(old_len + 3); + sprintf(yyvsp[-2].arg->array, "%s[]", old_array ? old_array : ""); + if (old_array) + free(old_array); + yyval.arg = yyvsp[-2].arg; +; + break;} +case 60: +#line 743 "parser.y" +{ free(yyvsp[0].string); yyval.string = yyvsp[-2].string;; + break;} +case 62: +#line 749 "parser.y" +{ + char *tmp_str = (char *) malloc(strlen(yyvsp[-1].string) + strlen(yyvsp[0].string) + 2); + sprintf(tmp_str, "%s %s", yyvsp[-1].string, yyvsp[0].string); + free(yyvsp[-1].string); + free(yyvsp[0].string); + yyval.string = tmp_str; +; + break;} +case 63: +#line 757 "parser.y" +{ + char *tmp_str = (char *) malloc(strlen(yyvsp[-3].string) + strlen(yyvsp[-1].string) + 3); + sprintf(tmp_str, "%s[%s]", yyvsp[-3].string, yyvsp[-1].string); + free(yyvsp[-3].string); + free(yyvsp[-1].string); + yyval.string = tmp_str; +; + break;} +case 64: +#line 765 "parser.y" +{ + char *tmp_str = (char *) malloc(strlen(yyvsp[-2].string) + 3); + strcpy(tmp_str, yyvsp[-2].string); + strcat(tmp_str, "[]"); + free(yyvsp[-2].string); + yyval.string = tmp_str; +; + break;} +case 66: +#line 776 "parser.y" +{ yyval.arg = yyvsp[0].arg; ; + break;} +case 67: +#line 778 "parser.y" +{ + free(yyvsp[0].string); + yyval.arg = yyvsp[-2].arg; +; + break;} +case 68: +#line 786 "parser.y" +{ + yyval.string = args_to_string(yyvsp[0].arg, 0); + free_args(yyvsp[0].arg); +; + break;} +case 69: +#line 791 "parser.y" +{ + char *tmp_str = (char *) malloc(strlen(yyvsp[-2].string) + strlen(yyvsp[0].string) + 3); + sprintf(tmp_str, "%s, %s", yyvsp[-2].string, yyvsp[0].string); + free(yyvsp[-2].string); + free(yyvsp[0].string); + yyval.string = tmp_str; +; + break;} +case 70: +#line 802 "parser.y" +{ + char *tmp_str = (char *) malloc(strlen(yyvsp[-1].string) + 2); + sprintf(tmp_str, "%s;", yyvsp[-1].string); + free(yyvsp[-1].string); + yyval.string = tmp_str; +; + break;} +case 71: +#line 809 "parser.y" +{ + char *tmp_str = (char *) malloc(strlen(yyvsp[-2].string) + strlen(yyvsp[-1].string) + 3); + sprintf(tmp_str, "%s\n%s;", yyvsp[-2].string, yyvsp[-1].string); + free(yyvsp[-2].string); + free(yyvsp[-1].string); + yyval.string = tmp_str; +; + break;} +case 72: +#line 820 "parser.y" +{ + yyval.arg = NULL; +; + break;} +case 73: +#line 824 "parser.y" +{ + yyval.arg = reverse_arg_list(yyvsp[0].arg); +; + break;} +case 74: +#line 828 "parser.y" +{ + arg_t *new_arg = (arg_t *) malloc(sizeof(arg_t)); + new_arg->type = strdup("..."); + new_arg->name = NULL; + new_arg->array = NULL; + new_arg->next = yyvsp[-2].arg; + yyval.arg = reverse_arg_list(new_arg); +; + break;} +case 75: +#line 837 "parser.y" +{ + arg_t *new_arg = (arg_t *) malloc(sizeof(arg_t)); + new_arg->type = strdup("..."); + new_arg->name = NULL; + new_arg->array = NULL; + new_arg->next = NULL; + yyval.arg = new_arg; +; + break;} +case 78: +#line 851 "parser.y" +{ + yyvsp[0].arg->next = yyvsp[-2].arg; + yyval.arg = yyvsp[0].arg; +; + break;} +case 79: +#line 856 "parser.y" +{ + yyvsp[0].arg->next = yyvsp[-2].arg; + yyval.arg = yyvsp[0].arg; +; + break;} +case 80: +#line 864 "parser.y" +{ + arg_t *new_arg = (arg_t *) malloc(sizeof(arg_t)); + new_arg->type = yyvsp[0].string; + new_arg->name = NULL; + new_arg->array = NULL; + new_arg->next = NULL; + yyval.arg = new_arg; +; + break;} +case 81: +#line 873 "parser.y" +{ + arg_t *new_arg = (arg_t *) malloc(sizeof(arg_t)); + new_arg->type = yyvsp[-2].string; + new_arg->name = NULL; + new_arg->array = NULL; + new_arg->next = NULL; + free(yyvsp[0].string); + yyval.arg = new_arg; +; + break;} +case 82: +#line 883 "parser.y" +{ + char *old_array = yyvsp[-3].arg->array; + int old_len = old_array ? strlen(old_array) : 0; + yyvsp[-3].arg->array = (char *) malloc(strlen(yyvsp[-1].string) + old_len + 3); + sprintf(yyvsp[-3].arg->array, "%s[%s]", old_array ? old_array : "", yyvsp[-1].string); + free(yyvsp[-1].string); + if (old_array) + free(old_array); + yyval.arg = yyvsp[-3].arg; +; + break;} +case 83: +#line 894 "parser.y" +{ + char *old_array = yyvsp[-2].arg->array; + int old_len = old_array ? strlen(old_array) : 0; + yyvsp[-2].arg->array = (char *) malloc(old_len + 3); + sprintf(yyvsp[-2].arg->array, "%s[]", old_array ? old_array : ""); + if (old_array) + free(old_array); + yyval.arg = yyvsp[-2].arg; +; + break;} +case 85: +#line 908 "parser.y" +{ if (collectMemberInitList() != 0) YYERROR; ; + break;} +case 87: +#line 910 "parser.y" +{ + /* I think this is the correct behavior, but skel_elemcmp is wrong */ + /* $2->templ = $1; */ + free(yyvsp[-2].string); + yyval.elt = yyvsp[-1].elt; +; + break;} +case 88: +#line 917 "parser.y" +{ if (collectMemberInitList() != 0) YYERROR; ; + break;} +case 89: +#line 918 "parser.y" +{ + /* I think this is the correct behavior, but skel_elemcmp is wrong */ + /* $2->templ = $1; */ + free(yyvsp[-4].string); + yyval.elt = yyvsp[-3].elt; +; + break;} +case 91: +#line 929 "parser.y" +{ if (collectMemberInitList() != 0) YYERROR; ; + break;} +case 93: +#line 934 "parser.y" +{ + yyvsp[-2].elt->const_flag = yyvsp[-1].flag; + yyvsp[-2].elt->throw_decl = yyvsp[0].string; + yyval.elt = yyvsp[-2].elt; +; + break;} +case 96: +#line 945 "parser.y" +{ + yyvsp[-2].elt->const_flag = yyvsp[-1].flag; + yyvsp[-2].elt->throw_decl = yyvsp[0].string; + yyval.elt = yyvsp[-2].elt; +; + break;} +case 99: +#line 957 "parser.y" +{ + /* ret_type, name, args, kind */ + syntaxelem_t *elem = new_elem(yyvsp[-4].string, yyvsp[-3].string, yyvsp[-1].arg, FUNC_KIND); +/* print_se(elem); */ + yyval.elt = elem; +; + break;} +case 100: +#line 964 "parser.y" +{ + /* ret_type, name, args, kind */ + syntaxelem_t *elem = new_elem(yyvsp[-9].string, + (char *) malloc(strlen(yyvsp[-8].string) + strlen(yyvsp[-6].string) + strlen(yyvsp[-3].string) + 5), + yyvsp[-1].arg, FUNC_KIND); + sprintf(elem->name,"%s<%s>::%s", yyvsp[-8].string, yyvsp[-6].string, yyvsp[-3].string); + free(yyvsp[-8].string); + free(yyvsp[-6].string); + free(yyvsp[-3].string); + yyval.elt = elem; +; + break;} +case 102: +#line 982 "parser.y" +{ + /* ret_type, name, args, kind */ + syntaxelem_t *elem = new_elem(yyvsp[-4].string, yyvsp[-3].string, yyvsp[-1].arg, FUNC_KIND); + print_se(elem); + yyval.elt = elem; +; + break;} +case 104: +#line 993 "parser.y" +{ + /* ret_type, name, args, kind */ + syntaxelem_t *elem = new_elem(yyvsp[-7].string, (char *)malloc(strlen(yyvsp[-6].string) + strlen(yyvsp[-3].string) + 12), + yyvsp[-1].arg, FUNC_KIND); + sprintf(elem->name, "%s::operator%s", yyvsp[-6].string, yyvsp[-3].string); + free(yyvsp[-6].string); + free(yyvsp[-3].string); +/* print_se(elem); */ + yyval.elt = elem; +; + break;} +case 105: +#line 1004 "parser.y" +{ + /* ret_type, name, args, kind */ + syntaxelem_t *elem = new_elem(strdup(""), + (char *)malloc(strlen(yyvsp[-5].string) + strlen(yyvsp[-2].string) + 13), + NULL, FUNC_KIND); + sprintf(elem->name, "%s::operator %s", yyvsp[-5].string, yyvsp[-2].string); + free(yyvsp[-5].string); + free(yyvsp[-2].string); +/* print_se(elem); */ + yyval.elt = elem; +; + break;} +case 106: +#line 1016 "parser.y" +{ + /* ret_type, name, args, kind */ + syntaxelem_t *elem = new_elem(yyvsp[-7].string, (char *)malloc(strlen(yyvsp[-6].string) + strlen(yyvsp[-3].string) + 12), + yyvsp[-1].arg, FUNC_KIND); + sprintf(elem->name, "%s::operator%s", yyvsp[-6].string, yyvsp[-3].string); + free(yyvsp[-6].string); + free(yyvsp[-3].string); +/* print_se(elem); */ + yyval.elt = elem; +; + break;} +case 107: +#line 1027 "parser.y" +{ + /* ret_type, name, args, kind */ + syntaxelem_t *elem = new_elem(strdup(""), + (char *)malloc(strlen(yyvsp[-5].string) + strlen(yyvsp[-2].string) + 13), + NULL, FUNC_KIND); + sprintf(elem->name, "%s::operator %s", yyvsp[-5].string, yyvsp[-2].string); + free(yyvsp[-5].string); + free(yyvsp[-2].string); +/* print_se(elem); */ + yyval.elt = elem; +; + break;} +case 108: +#line 1042 "parser.y" +{ + /* ret_type, name, args, kind */ + syntaxelem_t *elem = new_elem(yyvsp[-5].string, (char *)malloc(strlen(yyvsp[-3].string) + 9), + yyvsp[-1].arg, FUNC_KIND); + sprintf(elem->name, "operator%s", yyvsp[-3].string); + free(yyvsp[-3].string); + print_se(elem); + yyval.elt = elem; +; + break;} +case 109: +#line 1052 "parser.y" +{ + /* ret_type, name, args, kind */ + syntaxelem_t *elem = new_elem(strdup(""), (char *)malloc(strlen(yyvsp[-2].string) + 10), + NULL, FUNC_KIND); + sprintf(elem->name, "operator %s", yyvsp[-2].string); + free(yyvsp[-2].string); + print_se(elem); + yyval.elt = elem; +; + break;} +case 110: +#line 1064 "parser.y" +{ yyval.flag = 0; ; + break;} +case 111: +#line 1065 "parser.y" +{ yyval.flag = 1; ; + break;} +case 112: +#line 1069 "parser.y" +{ yyval.string = NULL; ; + break;} +case 113: +#line 1071 "parser.y" +{ + char *tmp_str = (char *) malloc(strlen(yyvsp[-1].string) + 8); + sprintf(tmp_str, "throw(%s)", yyvsp[-1].string); + free(yyvsp[-1].string); + yyval.string = tmp_str; +; + break;} +case 115: +#line 1082 "parser.y" +{ + char *tmp_str = (char *) malloc(strlen(yyvsp[-2].string) + strlen(yyvsp[0].string) + 3); + sprintf(tmp_str, "%s, %s", yyvsp[-2].string, yyvsp[0].string); + free(yyvsp[-2].string); + free(yyvsp[0].string); + yyval.string = tmp_str; +; + break;} +case 116: +#line 1093 "parser.y" +{ + /* ret_type, name, args, kind */ + syntaxelem_t *elem = new_elem(strdup(""), (char *) malloc(strlen(yyvsp[-2].string) + 2), + NULL, FUNC_KIND); + sprintf(elem->name,"~%s", yyvsp[-2].string); + free(yyvsp[-2].string); +/* print_se(elem); */ + yyval.elt = elem; +; + break;} +case 117: +#line 1106 "parser.y" +{ + /* ret_type, name, args, kind */ + syntaxelem_t *elem = new_elem(strdup(""), + (char *) malloc(strlen(yyvsp[-5].string) + strlen(yyvsp[-2].string) + 4), + NULL, FUNC_KIND); + sprintf(elem->name,"%s::~%s", yyvsp[-5].string, yyvsp[-2].string); + free(yyvsp[-5].string); + free(yyvsp[-2].string); +/* print_se(elem); */ + yyval.elt = elem; +; + break;} +case 118: +#line 1118 "parser.y" +{ + /* ret_type, name, args, kind */ + syntaxelem_t *elem = new_elem(strdup(""), + (char *) malloc(strlen(yyvsp[-5].string) + strlen(yyvsp[-2].string) + 4), + NULL, FUNC_KIND); + sprintf(elem->name,"%s::~%s", yyvsp[-5].string, yyvsp[-2].string); + free(yyvsp[-5].string); + free(yyvsp[-2].string); +/* print_se(elem); */ + yyval.elt = elem; +; + break;} +case 119: +#line 1130 "parser.y" +{ + /* ret_type, name, args, kind */ + syntaxelem_t *elem = new_elem(strdup(""), + (char *) malloc(strlen(yyvsp[-8].string) + strlen(yyvsp[-6].string) + strlen(yyvsp[-2].string) + 6), + NULL, FUNC_KIND); + sprintf(elem->name,"%s<%s>::~%s", yyvsp[-8].string, yyvsp[-6].string, yyvsp[-2].string); + free(yyvsp[-8].string); + free(yyvsp[-6].string); + free(yyvsp[-2].string); + yyval.elt = elem; +; + break;} +case 120: +#line 1142 "parser.y" +{ + /* ret_type, name, args, kind */ + syntaxelem_t *elem = new_elem(strdup(""), + (char *) malloc(strlen(yyvsp[-8].string) + strlen(yyvsp[-6].string) + strlen(yyvsp[-2].string) + 6), + NULL, FUNC_KIND); + sprintf(elem->name,"%s<%s>::~%s", yyvsp[-8].string, yyvsp[-6].string, yyvsp[-2].string); + free(yyvsp[-8].string); + free(yyvsp[-6].string); + free(yyvsp[-2].string); + yyval.elt = elem; +; + break;} +case 121: +#line 1157 "parser.y" +{ + /* ret_type, name, args, kind */ + syntaxelem_t *elem = new_elem(strdup(""), yyvsp[-4].string, yyvsp[-2].arg, FUNC_KIND); + elem->throw_decl = yyvsp[0].string; +/* print_se(elem); */ + yyval.elt = elem; +; + break;} +case 122: +#line 1168 "parser.y" +{ + /* ret_type, name, args, kind */ + syntaxelem_t *elem = new_elem(strdup(""), yyvsp[-4].string, yyvsp[-2].arg, FUNC_KIND); + elem->throw_decl = yyvsp[0].string; +/* print_se(elem); */ + yyval.elt = elem; +; + break;} +case 123: +#line 1176 "parser.y" +{ + /* ret_type, name, args, kind */ + syntaxelem_t *elem = new_elem(strdup(""), + (char *) malloc(strlen(yyvsp[-9].string) + strlen(yyvsp[-7].string) + strlen(yyvsp[-4].string) + 5), + yyvsp[-2].arg, FUNC_KIND); + sprintf(elem->name,"%s<%s>::%s", yyvsp[-9].string, yyvsp[-7].string, yyvsp[-4].string); + free(yyvsp[-9].string); + free(yyvsp[-7].string); + free(yyvsp[-4].string); + elem->throw_decl = yyvsp[0].string; + yyval.elt = elem; +; + break;} +case 124: +#line 1189 "parser.y" +{ + /* ret_type, name, args, kind */ + syntaxelem_t *elem = new_elem(strdup(""), + (char *) malloc(strlen(yyvsp[-9].string) + strlen(yyvsp[-7].string) + strlen(yyvsp[-4].string) + 5), + yyvsp[-2].arg, FUNC_KIND); + sprintf(elem->name,"%s<%s>::%s", yyvsp[-9].string, yyvsp[-7].string, yyvsp[-4].string); + free(yyvsp[-9].string); + free(yyvsp[-7].string); + free(yyvsp[-4].string); + elem->throw_decl = yyvsp[0].string; + yyval.elt = elem; +; + break;} +case 125: +#line 1204 "parser.y" +{ if (collectInlineDef() != 0) YYERROR; ; + break;} +case 127: +#line 1209 "parser.y" +{ + char *tmp_str = (char *) malloc(strlen(yyvsp[-1].string) + 10); + sprintf(tmp_str, "enum { %s }", yyvsp[-1].string); + free(yyvsp[-1].string); + yyval.string = tmp_str; +; + break;} +case 128: +#line 1216 "parser.y" +{ + char *tmp_str = (char *) malloc(strlen(yyvsp[-3].string) + strlen(yyvsp[-1].string) + 11); + sprintf(tmp_str, "enum %s { %s }", yyvsp[-3].string, yyvsp[-1].string); + free(yyvsp[-3].string); + free(yyvsp[-1].string); + yyval.string = tmp_str; +; + break;} +case 129: +#line 1224 "parser.y" +{ + char *tmp_str = (char *) malloc(strlen(yyvsp[0].string) + 6); + sprintf(tmp_str, "enum %s", yyvsp[0].string); + free(yyvsp[0].string); + yyval.string = tmp_str; +; + break;} +case 131: +#line 1235 "parser.y" +{ + char *tmp_str = (char *) malloc(strlen(yyvsp[-2].string) + strlen(yyvsp[0].string) + 3); + sprintf(tmp_str, "%s, %s", yyvsp[-2].string, yyvsp[0].string); + free(yyvsp[-2].string); + free(yyvsp[0].string); + yyval.string = tmp_str; +; + break;} +case 133: +#line 1247 "parser.y" +{ + char *tmp_str = (char *) malloc(strlen(yyvsp[-2].string) + strlen(yyvsp[0].string) + 2); + sprintf(tmp_str, "%s=%s", yyvsp[-2].string, yyvsp[0].string); + free(yyvsp[-2].string); + free(yyvsp[0].string); + yyval.string = tmp_str; +; + break;} +case 141: +#line 1273 "parser.y" +{ yyval.string = strdup("&"); ; + break;} +case 142: +#line 1274 "parser.y" +{ yyval.string = strdup("*"); ; + break;} +case 143: +#line 1275 "parser.y" +{ yyval.string = strdup("+"); ; + break;} +case 144: +#line 1276 "parser.y" +{ yyval.string = strdup("-"); ; + break;} +case 145: +#line 1277 "parser.y" +{ yyval.string = strdup("~"); ; + break;} +case 146: +#line 1278 "parser.y" +{ yyval.string = strdup("!"); ; + break;} +case 147: +#line 1282 "parser.y" +{ yyval.string = strdup("/"); ; + break;} +case 148: +#line 1283 "parser.y" +{ yyval.string = strdup("%"); ; + break;} +case 149: +#line 1284 "parser.y" +{ yyval.string = strdup("^"); ; + break;} +case 150: +#line 1285 "parser.y" +{ yyval.string = strdup("|"); ; + break;} +case 151: +#line 1286 "parser.y" +{ yyval.string = strdup("<"); ; + break;} +case 152: +#line 1287 "parser.y" +{ yyval.string = strdup(">"); ; + break;} +case 153: +#line 1288 "parser.y" +{ yyval.string = strdup(","); ; + break;} +case 154: +#line 1292 "parser.y" +{ yyval.string = strdup("="); ; + break;} +case 155: +#line 1293 "parser.y" +{ yyval.string = strdup("*="); ; + break;} +case 156: +#line 1294 "parser.y" +{ yyval.string = strdup("/="); ; + break;} +case 157: +#line 1295 "parser.y" +{ yyval.string = strdup("%="); ; + break;} +case 158: +#line 1296 "parser.y" +{ yyval.string = strdup("+="); ; + break;} +case 159: +#line 1297 "parser.y" +{ yyval.string = strdup("-="); ; + break;} +case 160: +#line 1298 "parser.y" +{ yyval.string = strdup("<<="); ; + break;} +case 161: +#line 1299 "parser.y" +{ yyval.string = strdup(">>="); ; + break;} +case 162: +#line 1300 "parser.y" +{ yyval.string = strdup("&="); ; + break;} +case 163: +#line 1301 "parser.y" +{ yyval.string = strdup("^="); ; + break;} +case 164: +#line 1302 "parser.y" +{ yyval.string = strdup("|="); ; + break;} +case 168: +#line 1309 "parser.y" +{ yyval.string = strdup(" new"); ; + break;} +case 169: +#line 1310 "parser.y" +{ yyval.string = strdup(" delete"); ; + break;} +case 170: +#line 1311 "parser.y" +{ yyval.string = strdup("->"); ; + break;} +case 171: +#line 1312 "parser.y" +{ yyval.string = strdup("->*"); ; + break;} +case 172: +#line 1313 "parser.y" +{ yyval.string = strdup("++"); ; + break;} +case 173: +#line 1314 "parser.y" +{ yyval.string = strdup("--"); ; + break;} +case 174: +#line 1315 "parser.y" +{ yyval.string = strdup("<<"); ; + break;} +case 175: +#line 1316 "parser.y" +{ yyval.string = strdup(">>"); ; + break;} +case 176: +#line 1317 "parser.y" +{ yyval.string = strdup("<="); ; + break;} +case 177: +#line 1318 "parser.y" +{ yyval.string = strdup(">="); ; + break;} +case 178: +#line 1319 "parser.y" +{ yyval.string = strdup("=="); ; + break;} +case 179: +#line 1320 "parser.y" +{ yyval.string = strdup("!="); ; + break;} +case 180: +#line 1321 "parser.y" +{ yyval.string = strdup("&&"); ; + break;} +case 181: +#line 1322 "parser.y" +{ yyval.string = strdup("||"); ; + break;} +case 182: +#line 1323 "parser.y" +{ yyval.string = strdup("[]"); ; + break;} +case 183: +#line 1324 "parser.y" +{ yyval.string = strdup("()"); ; + break;} +case 185: +#line 1329 "parser.y" +{ yyval.string = strdup("{ ... }"); ; + break;} +case 188: +#line 1339 "parser.y" +{ + char *tmp_str = (char *) malloc(strlen(yyvsp[0].string) + 2); + sprintf(tmp_str, "-%s", yyvsp[0].string); + free(yyvsp[0].string); + yyval.string = tmp_str; +; + break;} +case 192: +#line 1349 "parser.y" +{ + char *tmp_str = (char *) malloc(strlen(yyvsp[-1].string) + 3); + sprintf(tmp_str, "(%s)", yyvsp[-1].string); + free(yyvsp[-1].string); + yyval.string = tmp_str; +; + break;} +case 194: +#line 1360 "parser.y" +{ + char *tmp_str = (char *) malloc(strlen(yyvsp[-2].string) + strlen(yyvsp[0].string) + 4); + sprintf(tmp_str, "%s * %s", yyvsp[-2].string, yyvsp[0].string); + free(yyvsp[-2].string); + free(yyvsp[0].string); + yyval.string = tmp_str; +; + break;} +case 195: +#line 1368 "parser.y" +{ + char *tmp_str = (char *) malloc(strlen(yyvsp[-2].string) + strlen(yyvsp[0].string) + 4); + sprintf(tmp_str, "%s / %s", yyvsp[-2].string, yyvsp[0].string); + free(yyvsp[-2].string); + free(yyvsp[0].string); + yyval.string = tmp_str; +; + break;} +case 196: +#line 1376 "parser.y" +{ + char *tmp_str = (char *) malloc(strlen(yyvsp[-2].string) + strlen(yyvsp[0].string) + 4); + sprintf(tmp_str, "%s %% %s", yyvsp[-2].string, yyvsp[0].string); + free(yyvsp[-2].string); + free(yyvsp[0].string); + yyval.string = tmp_str; +; + break;} +case 198: +#line 1388 "parser.y" +{ + char *tmp_str = (char *) malloc(strlen(yyvsp[-2].string) + strlen(yyvsp[0].string) + 4); + sprintf(tmp_str, "%s + %s", yyvsp[-2].string, yyvsp[0].string); + free(yyvsp[-2].string); + free(yyvsp[0].string); + yyval.string = tmp_str; +; + break;} +case 199: +#line 1396 "parser.y" +{ + char *tmp_str = (char *) malloc(strlen(yyvsp[-2].string) + strlen(yyvsp[0].string) + 4); + sprintf(tmp_str, "%s - %s", yyvsp[-2].string, yyvsp[0].string); + free(yyvsp[-2].string); + free(yyvsp[0].string); + yyval.string = tmp_str; +; + break;} +case 200: +#line 1408 "parser.y" +{ + char *tmp_str = (char *) malloc(strlen(yyvsp[-3].string) + strlen(yyvsp[-1].string) + 12); + sprintf(tmp_str, "union %s { %s }", yyvsp[-3].string, yyvsp[-1].string); + free(yyvsp[-3].string); + free(yyvsp[-1].string); + yyval.string = tmp_str; +; + break;} +case 201: +#line 1416 "parser.y" +{ + char *tmp_str = (char *) malloc(strlen(yyvsp[-1].string) + 11); + sprintf(tmp_str, "union { %s }", yyvsp[-1].string); + free(yyvsp[-1].string); + yyval.string = tmp_str; +; + break;} +case 202: +#line 1423 "parser.y" +{ + char *tmp_str = (char *) malloc(strlen(yyvsp[0].string) + 7); + sprintf(tmp_str, "union %s", yyvsp[0].string); + free(yyvsp[0].string); + yyval.string = tmp_str; +; + break;} +case 203: +#line 1433 "parser.y" +{ + syntaxelem_t *child; + /* ret_type, name, args, kind */ + syntaxelem_t *tmp_elem = new_elem(strdup(""), yyvsp[-3].string, NULL, CLASS_KIND); + tmp_elem->children = reverse_list(yyvsp[-1].elt); + + for (child = tmp_elem->children; child != NULL; child = child->next) + child->parent = tmp_elem; + +/* print_se(tmp_elem); */ + yyval.elt = tmp_elem; +; + break;} +case 204: +#line 1446 "parser.y" +{ + syntaxelem_t *child; + /* ret_type, name, args, kind */ + syntaxelem_t *tmp_elem = new_elem(strdup(""), yyvsp[-5].string, NULL, CLASS_KIND); + tmp_elem->children = reverse_list(yyvsp[-1].elt); + + for (child = tmp_elem->children; child != NULL; child = child->next) + child->parent = tmp_elem; + +/* print_se(tmp_elem); */ + yyval.elt = tmp_elem; +; + break;} +case 205: +#line 1459 "parser.y" +{ + syntaxelem_t *child; + /* ret_type, name, args, kind */ + syntaxelem_t *tmp_elem = new_elem(strdup(""), yyvsp[-3].string, NULL, CLASS_KIND); + tmp_elem->children = reverse_list(yyvsp[-1].elt); + tmp_elem->templ = yyvsp[-5].string; + + for (child = tmp_elem->children; child != NULL; child = child->next) + child->parent = tmp_elem; + +/* print_se(tmp_elem); */ + yyval.elt = tmp_elem; +; + break;} +case 206: +#line 1473 "parser.y" +{ + syntaxelem_t *child; + /* ret_type, name, args, kind */ + syntaxelem_t *tmp_elem = new_elem(strdup(""), yyvsp[-5].string, NULL, CLASS_KIND); + tmp_elem->children = reverse_list(yyvsp[-1].elt); + tmp_elem->templ = yyvsp[-7].string; + + for (child = tmp_elem->children; child != NULL; child = child->next) + child->parent = tmp_elem; + +/* print_se(tmp_elem); */ + yyval.elt = tmp_elem; +; + break;} +case 207: +#line 1487 "parser.y" +{ + syntaxelem_t *child; + /* ret_type, name, args, kind */ + syntaxelem_t *tmp_elem = new_elem(strdup(""), "unnamed_struct", + NULL, IGNORE_KIND); + tmp_elem->children = reverse_list(yyvsp[-1].elt); + + for (child = tmp_elem->children; child != NULL; child = child->next) + child->parent = tmp_elem; + +/* print_se(tmp_elem); */ + yyval.elt = tmp_elem; +; + break;} +case 208: +#line 1501 "parser.y" +{ + syntaxelem_t *child; + /* ret_type, name, args, kind */ + syntaxelem_t *tmp_elem = new_elem(strdup(""), yyvsp[-3].string, NULL, STRUCT_KIND); + tmp_elem->children = reverse_list(yyvsp[-1].elt); + + for (child = tmp_elem->children; child != NULL; child = child->next) + child->parent = tmp_elem; + +/* print_se(tmp_elem); */ + yyval.elt = tmp_elem; +; + break;} +case 209: +#line 1514 "parser.y" +{ + syntaxelem_t *child; + /* ret_type, name, args, kind */ + syntaxelem_t *tmp_elem = new_elem(strdup(""), yyvsp[-5].string, NULL, STRUCT_KIND); + tmp_elem->children = reverse_list(yyvsp[-1].elt); + + for (child = tmp_elem->children; child != NULL; child = child->next) + child->parent = tmp_elem; + +/* print_se(tmp_elem); */ + yyval.elt = tmp_elem; +; + break;} +case 210: +#line 1527 "parser.y" +{ + syntaxelem_t *child; + /* ret_type, name, args, kind */ + syntaxelem_t *tmp_elem = new_elem(strdup(""), yyvsp[-3].string, NULL, STRUCT_KIND); + tmp_elem->children = reverse_list(yyvsp[-1].elt); + tmp_elem->templ = yyvsp[-5].string; + + for (child = tmp_elem->children; child != NULL; child = child->next) + child->parent = tmp_elem; + +/* print_se(tmp_elem); */ + yyval.elt = tmp_elem; +; + break;} +case 211: +#line 1541 "parser.y" +{ + syntaxelem_t *child; + /* ret_type, name, args, kind */ + syntaxelem_t *tmp_elem = new_elem(strdup(""), yyvsp[-5].string, NULL, STRUCT_KIND); + tmp_elem->children = reverse_list(yyvsp[-1].elt); + tmp_elem->templ = yyvsp[-7].string; + + for (child = tmp_elem->children; child != NULL; child = child->next) + child->parent = tmp_elem; + +/* print_se(tmp_elem); */ + yyval.elt = tmp_elem; +; + break;} +case 214: +#line 1562 "parser.y" +{ free(yyvsp[0].string); ; + break;} +case 215: +#line 1566 "parser.y" +{ yyvsp[0].elt->kind = IGNORE_KIND; ; + break;} +case 217: +#line 1571 "parser.y" +{ yyval.elt = NULL; ; + break;} +case 219: +#line 1577 "parser.y" +{ + if (yyvsp[0].elt != NULL) + yyvsp[0].elt->next = NULL; + + yyval.elt = yyvsp[0].elt; +; + break;} +case 220: +#line 1584 "parser.y" +{ + if (yyvsp[0].elt != NULL) { + yyvsp[0].elt->next = yyvsp[-1].elt; + yyval.elt = yyvsp[0].elt; + } else { + yyval.elt = yyvsp[-1].elt; + } +; + break;} +case 222: +#line 1597 "parser.y" +{ + log_printf("member_with_access : error. Attempting to recover...\n"); + yyerrok; + yyclearin; + if (error_recovery() != 0) { + log_printf("ERROR recovery could not complete -- YYABORT.\n"); + YYABORT; + } + log_printf("ERROR recovery complete.\n"); + yyval.elt = NULL; +; + break;} +case 224: +#line 1612 "parser.y" +{ yyval.elt = yyvsp[0].elt; ; + break;} +case 226: +#line 1617 "parser.y" +{ yyval.elt = NULL; ; + break;} +case 227: +#line 1618 "parser.y" +{ yyvsp[0].elt->kind = INLINED_KIND; yyval.elt = yyvsp[0].elt; ; + break;} +case 228: +#line 1619 "parser.y" +{ yyval.elt = NULL; ; + break;} +case 229: +#line 1624 "parser.y" +{ + /* ret_type, name, args, kind */ + syntaxelem_t *elem = new_elem(strdup(""), yyvsp[0].string, NULL, IGNORE_KIND); +/* print_se(elem); */ + yyval.elt = elem; +; + break;} +case 231: +#line 1631 "parser.y" +{ yyval.elt = yyvsp[0].elt; ; + break;} +case 232: +#line 1632 "parser.y" +{ yyvsp[-2].elt->kind = IGNORE_KIND; free(yyvsp[0].string); yyval.elt = yyvsp[-2].elt; ; + break;} +case 235: +#line 1638 "parser.y" +{ free(yyvsp[0].string); yyval.elt = yyvsp[-1].elt; ; + break;} +case 237: +#line 1641 "parser.y" +{ + free(yyvsp[-1].string); + yyval.elt = yyvsp[-3].elt; +; + break;} +case 238: +#line 1649 "parser.y" +{ + char *tmp_str = (char *) malloc(strlen(yyvsp[0].string) + 7); + sprintf(tmp_str, "class %s", yyvsp[0].string); + free(yyvsp[0].string); + yyval.string = tmp_str; +; + break;} +case 239: +#line 1656 "parser.y" +{ + char *tmp_str = (char *) malloc(strlen(yyvsp[-1].string) + strlen(yyvsp[0].string) + 2); + sprintf(tmp_str, "%s %s", yyvsp[-1].string, yyvsp[0].string); + free(yyvsp[-1].string); + free(yyvsp[0].string); + yyval.string = tmp_str; +; + break;} +case 241: +#line 1668 "parser.y" +{ + char *tmp_str = (char *) malloc(strlen(yyvsp[-2].string) + strlen(yyvsp[0].string) + 3); + sprintf(tmp_str, "%s, %s", yyvsp[-2].string, yyvsp[0].string); + free(yyvsp[-2].string); + free(yyvsp[0].string); + yyval.string = tmp_str; +; + break;} +case 245: +#line 1685 "parser.y" +{ + char *tmp_str = (char *) malloc(strlen(yyvsp[-2].string) + strlen(yyvsp[0].string) + 3); + sprintf(tmp_str, "%s, %s", yyvsp[-2].string, yyvsp[0].string); + free(yyvsp[-2].string); + free(yyvsp[0].string); + yyval.string = tmp_str; +; + break;} +case 246: +#line 1696 "parser.y" +{ + char *tmp_str = (char *) malloc(strlen(yyvsp[-1].string) + 12); + sprintf(tmp_str, "template <%s>", yyvsp[-1].string); + free(yyvsp[-1].string); + yyval.string = tmp_str; +; + break;} +} + /* the action file gets copied in in place of this dollarsign */ +#line 543 "/etc/bison.simple" + + yyvsp -= yylen; + yyssp -= yylen; +#ifdef YYLSP_NEEDED + yylsp -= yylen; +#endif + +#if YYDEBUG != 0 + if (yydebug) + { + short *ssp1 = yyss - 1; + fprintf (stderr, "state stack now"); + while (ssp1 != yyssp) + fprintf (stderr, " %d", *++ssp1); + fprintf (stderr, "\n"); + } +#endif + + *++yyvsp = yyval; + +#ifdef YYLSP_NEEDED + yylsp++; + if (yylen == 0) + { + yylsp->first_line = yylloc.first_line; + yylsp->first_column = yylloc.first_column; + yylsp->last_line = (yylsp-1)->last_line; + yylsp->last_column = (yylsp-1)->last_column; + yylsp->text = 0; + } + else + { + yylsp->last_line = (yylsp+yylen-1)->last_line; + yylsp->last_column = (yylsp+yylen-1)->last_column; + } +#endif + + /* Now "shift" the result of the reduction. + Determine what state that goes to, + based on the state we popped back to + and the rule number reduced by. */ + + yyn = yyr1[yyn]; + + yystate = yypgoto[yyn - YYNTBASE] + *yyssp; + if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yytable[yystate]; + else + yystate = yydefgoto[yyn - YYNTBASE]; + + goto yynewstate; + +yyerrlab: /* here on detecting error */ + + if (! yyerrstatus) + /* If not already recovering from an error, report this error. */ + { + ++yynerrs; + +#ifdef YYERROR_VERBOSE + yyn = yypact[yystate]; + + if (yyn > YYFLAG && yyn < YYLAST) + { + int size = 0; + char *msg; + int x, count; + + count = 0; + /* Start X at -yyn if nec to avoid negative indexes in yycheck. */ + for (x = (yyn < 0 ? -yyn : 0); + x < (sizeof(yytname) / sizeof(char *)); x++) + if (yycheck[x + yyn] == x) + size += strlen(yytname[x]) + 15, count++; + msg = (char *) malloc(size + 15); + if (msg != 0) + { + strcpy(msg, "parse error"); + + if (count < 5) + { + count = 0; + for (x = (yyn < 0 ? -yyn : 0); + x < (sizeof(yytname) / sizeof(char *)); x++) + if (yycheck[x + yyn] == x) + { + strcat(msg, count == 0 ? ", expecting `" : " or `"); + strcat(msg, yytname[x]); + strcat(msg, "'"); + count++; + } + } + yyerror(msg); + free(msg); + } + else + yyerror ("parse error; also virtual memory exceeded"); + } + else +#endif /* YYERROR_VERBOSE */ + yyerror("parse error"); + } + + goto yyerrlab1; +yyerrlab1: /* here on error raised explicitly by an action */ + + if (yyerrstatus == 3) + { + /* if just tried and failed to reuse lookahead token after an error, discard it. */ + + /* return failure if at end of input */ + if (yychar == YYEOF) + YYABORT; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]); +#endif + + yychar = YYEMPTY; + } + + /* Else will try to reuse lookahead token + after shifting the error token. */ + + yyerrstatus = 3; /* Each real token shifted decrements this */ + + goto yyerrhandle; + +yyerrdefault: /* current state does not do anything special for the error token. */ + +#if 0 + /* This is wrong; only states that explicitly want error tokens + should shift them. */ + yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/ + if (yyn) goto yydefault; +#endif + +yyerrpop: /* pop the current state because it cannot handle the error token */ + + if (yyssp == yyss) YYABORT; + yyvsp--; + yystate = *--yyssp; +#ifdef YYLSP_NEEDED + yylsp--; +#endif + +#if YYDEBUG != 0 + if (yydebug) + { + short *ssp1 = yyss - 1; + fprintf (stderr, "Error: state stack now"); + while (ssp1 != yyssp) + fprintf (stderr, " %d", *++ssp1); + fprintf (stderr, "\n"); + } +#endif + +yyerrhandle: + + yyn = yypact[yystate]; + if (yyn == YYFLAG) + goto yyerrdefault; + + yyn += YYTERROR; + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR) + goto yyerrdefault; + + yyn = yytable[yyn]; + if (yyn < 0) + { + if (yyn == YYFLAG) + goto yyerrpop; + yyn = -yyn; + goto yyreduce; + } + else if (yyn == 0) + goto yyerrpop; + + if (yyn == YYFINAL) + YYACCEPT; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Shifting error token, "); +#endif + + *++yyvsp = yylval; +#ifdef YYLSP_NEEDED + *++yylsp = yylloc; +#endif + + yystate = yyn; + goto yynewstate; + + yyacceptlab: + /* YYACCEPT comes here. */ + if (yyfree_stacks) + { +#ifndef YYSTACK_USE_ALLOCA + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); +#endif +#endif + } + return 0; + + yyabortlab: + /* YYABORT comes here. */ + if (yyfree_stacks) + { +#ifndef YYSTACK_USE_ALLOCA + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); +#endif +#endif + } + return 1; +} +#line 1704 "parser.y" + + +static int yyerror(char *s /*UNUSED*/) +{ + if (outfile != NULL) + fflush(outfile); + + return 0; +} + +static int error_recovery() +{ + extern char linebuf[]; + extern int lineno; + extern int column; + extern int tokens_seen; + +#ifdef SGDEBUG + log_printf("parse error at line %d, file %s:\n%s\n%*s\n", + lineno, currentFile, linebuf, column, "^"); + log_flush(); +#endif /* SGDEBUG */ + + if (tokens_seen == 0) { + /* + * if we've seen no tokens but we're in an error, we must have + * hit an EOF, either by stdin, or on a file. Just give up + * now instead of complaining. + */ + return -1; + + } else { + fprintf(stderr, "parse error at line %d, file %s:\n%s\n%*s\n", + lineno, currentFile, linebuf, column, "^"); + } + + linebuf[0] = '\0'; + + for (;;) { + int result = yylex(); + + if (result <= 0) { + /* fatal error: Unexpected EOF during parse error recovery */ + +#ifdef SGDEBUG + log_printf("EOF in error recovery, line %d, file %s\n", + lineno, currentFile); + log_flush(); +#endif /* SGDEBUG */ + + fprintf(stderr, "EOF in error recovery, line %d, file %s\n", + lineno, currentFile); + + return -1; + } + + switch(result) { + case IDENTIFIER: + case CONSTANT: + case STRING_LITERAL: + case CHAR: + case SHORT: + case INT: + case LONG: + case SIGNED: + case UNSIGNED: + case FLOAT: + case DOUBLE: + case VOID: + free(yylval.string); + break; + case (int) '{': + if (collectInlineDef() != 0) + return -1; + result = yylex(); + return 0; + case (int) ';': + return 0; + } + } +} diff --git a/bepascal/bepascal/stubgen.so/y.tab.h b/bepascal/bepascal/stubgen.so/y.tab.h new file mode 100644 index 0000000..90828eb --- /dev/null +++ b/bepascal/bepascal/stubgen.so/y.tab.h @@ -0,0 +1,60 @@ +typedef union { + char *string; + syntaxelem_t *elt; + arg_t *arg; + int flag; +} YYSTYPE; +#define IDENTIFIER 257 +#define CONSTANT 258 +#define STRING_LITERAL 259 +#define CHAR 260 +#define SHORT 261 +#define INT 262 +#define LONG 263 +#define SIGNED 264 +#define UNSIGNED 265 +#define FLOAT 266 +#define DOUBLE 267 +#define VOID 268 +#define NEW 269 +#define DELETE 270 +#define TEMPLATE 271 +#define THROW 272 +#define PTR_OP 273 +#define INC_OP 274 +#define DEC_OP 275 +#define LEFT_OP 276 +#define RIGHT_OP 277 +#define LE_OP 278 +#define GE_OP 279 +#define EQ_OP 280 +#define NE_OP 281 +#define AND_OP 282 +#define OR_OP 283 +#define MUL_ASSIGN 284 +#define DIV_ASSIGN 285 +#define MOD_ASSIGN 286 +#define ADD_ASSIGN 287 +#define SUB_ASSIGN 288 +#define LEFT_ASSIGN 289 +#define RIGHT_ASSIGN 290 +#define AND_ASSIGN 291 +#define XOR_ASSIGN 292 +#define OR_ASSIGN 293 +#define CLCL 294 +#define MEM_PTR_OP 295 +#define FRIEND 296 +#define OPERATOR 297 +#define CONST 298 +#define CLASS 299 +#define STRUCT 300 +#define UNION 301 +#define ENUM 302 +#define PROTECTED 303 +#define PRIVATE 304 +#define PUBLIC 305 +#define EXTERN 306 +#define ELIPSIS 307 + + +extern YYSTYPE yylval;