summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
author/dev/humancontroller <devhc@example.com>2017-04-13 11:30:00 +0000
committer/dev/humancontroller <devhc@example.com>2017-04-15 12:11:01 +0200
commit60d92bbdcfc22c7248989ad7efb856989d299daa (patch)
tree74de9d4cb1f1a938705e13257ba136b9872b6600
parent1a5afab2fcd1d43e5d43160ee601fa3bfa375a76 (diff)
update the tools to the latest revision
URL: https://github.com/darklegion/tremulous revision: c862a5340c8de44dcc7abaff170c20c04f9340e8, equivalently f45fbef604e05144057dec8d1dbfc5d4f5a2a822
Diffstat
-rw-r--r--src/qcommon/q_platform.h2
-rw-r--r--src/tools/asm/Makefile43
-rw-r--r--src/tools/asm/cmdlib.c113
-rw-r--r--src/tools/asm/cmdlib.h10
-rw-r--r--src/tools/asm/mathlib.h2
-rw-r--r--src/tools/asm/opstrings.h2
-rw-r--r--src/tools/asm/q3asm.c129
-rw-r--r--src/tools/lcc/Makefile163
-rw-r--r--src/tools/lcc/cpp/cpp.c12
-rw-r--r--src/tools/lcc/cpp/cpp.h4
-rw-r--r--src/tools/lcc/cpp/include.c7
-rw-r--r--src/tools/lcc/cpp/macro.c11
-rw-r--r--src/tools/lcc/cpp/nlist.c1
-rw-r--r--src/tools/lcc/cpp/tokens.c2
-rw-r--r--src/tools/lcc/cpp/unix.c15
-rw-r--r--src/tools/lcc/doc/4.html6
-rw-r--r--src/tools/lcc/doc/install.html4
-rw-r--r--src/tools/lcc/etc/bytecode.c4
-rw-r--r--src/tools/lcc/etc/lcc.c90
-rw-r--r--src/tools/lcc/lburg/gram.c2010
-rw-r--r--src/tools/lcc/lburg/gram.y1
-rw-r--r--src/tools/lcc/src/bytecode.c11
-rw-r--r--src/tools/lcc/src/c.h7
-rw-r--r--src/tools/lcc/src/enode.c3
-rw-r--r--src/tools/lcc/src/expr.c2
-rw-r--r--src/tools/lcc/src/list.c2
26 files changed, 1728 insertions, 928 deletions
diff --git a/src/qcommon/q_platform.h b/src/qcommon/q_platform.h
index ad9a938..9f037c6 100644
--- a/src/qcommon/q_platform.h
+++ b/src/qcommon/q_platform.h
@@ -123,6 +123,8 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#ifdef __linux__
+#include <endian.h>
+
#define OS_STRING "linux"
#define ID_INLINE inline
#define PATH_SEP '/'
diff --git a/src/tools/asm/Makefile b/src/tools/asm/Makefile
deleted file mode 100644
index a788386..0000000
--- a/src/tools/asm/Makefile
+++ /dev/null
@@ -1,43 +0,0 @@
-# yeah, couldn't do more simple really
-
-ifeq ($(PLATFORM),mingw32)
- BINEXT=.exe
-else
- BINEXT=
-endif
-
-ifeq ($(PLATFORM),sunos)
- INSTALL=ginstall
-else
- INSTALL=install
-endif
-
-CC=gcc
-Q3ASM_CFLAGS=-O2 -Wall -fno-strict-aliasing
-
-ifeq ($(PLATFORM),darwin)
- LCC_CFLAGS += -DMACOS_X=1
-endif
-
-ifndef USE_CCACHE
- USE_CCACHE=0
-endif
-
-ifeq ($(USE_CCACHE),1)
- CC := ccache $(CC)
- CXX := ccache $(CXX)
-endif
-
-default: q3asm
-
-q3asm: q3asm.c cmdlib.c
- $(CC) $(Q3ASM_CFLAGS) -o $@ $^
-
-clean:
- rm -f q3asm *~ *.o
-
-install: default
- $(INSTALL) -s -m 0755 q3asm$(BINEXT) ../
-
-uninstall:
- rm -f ../q3asm$(BINEXT)
diff --git a/src/tools/asm/cmdlib.c b/src/tools/asm/cmdlib.c
index 69ce3ff..63ba79e 100644
--- a/src/tools/asm/cmdlib.c
+++ b/src/tools/asm/cmdlib.c
@@ -1,7 +1,7 @@
/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.
-Copyright (C) 2000-2006 Tim Angus
+Copyright (C) 2000-2013 Darklegion Development
This file is part of Tremulous.
@@ -64,7 +64,7 @@ char *ex_argv[MAX_EX_ARGC];
void ExpandWildcards( int *argc, char ***argv )
{
struct _finddata_t fileinfo;
- int handle;
+ intptr_t handle;
int i;
char filename[1024];
char filebase[1024];
@@ -186,7 +186,7 @@ void _printf( const char *format, ... ) {
vsprintf (text, format, argptr);
va_end (argptr);
- printf(text);
+ printf("%s", text);
#ifdef WIN32
if (!lookedForServer) {
@@ -397,10 +397,12 @@ void Q_getwd (char *out)
int i = 0;
#ifdef WIN32
- _getcwd (out, 256);
+ if (_getcwd (out, 256) == NULL)
+ strcpy(out, "."); /* shrug */
strcat (out, "\\");
#else
- getcwd (out, 256);
+ if (getcwd (out, 256) == NULL)
+ strcpy(out, "."); /* shrug */
strcat (out, "/");
#endif
@@ -976,13 +978,7 @@ int ParseNum (const char *str)
============================================================================
*/
-#ifdef _SGI_SOURCE
-#define __BIG_ENDIAN__
-#endif
-
-#ifdef __BIG_ENDIAN__
-
-short LittleShort (short l)
+short ShortSwap (short l)
{
byte b1,b2;
@@ -992,13 +988,7 @@ short LittleShort (short l)
return (b1<<8) + b2;
}
-short BigShort (short l)
-{
- return l;
-}
-
-
-int LittleLong (int l)
+int LongSwap (int l)
{
byte b1,b2,b3,b4;
@@ -1010,89 +1000,20 @@ int LittleLong (int l)
return ((int)b1<<24) + ((int)b2<<16) + ((int)b3<<8) + b4;
}
-int BigLong (int l)
-{
- return l;
-}
-
-
-float LittleFloat (float l)
-{
- union {byte b[4]; float f;} in, out;
-
- in.f = l;
- out.b[0] = in.b[3];
- out.b[1] = in.b[2];
- out.b[2] = in.b[1];
- out.b[3] = in.b[0];
-
- return out.f;
-}
-
-float BigFloat (float l)
-{
- return l;
-}
-
-
-#else
-
-
-short BigShort (short l)
-{
- byte b1,b2;
-
- b1 = l&255;
- b2 = (l>>8)&255;
-
- return (b1<<8) + b2;
-}
-
-short LittleShort (short l)
-{
- return l;
-}
+typedef union {
+ float f;
+ unsigned int i;
+} _FloatByteUnion;
+float FloatSwap (const float *f) {
+ _FloatByteUnion out;
-int BigLong (int l)
-{
- byte b1,b2,b3,b4;
+ out.f = *f;
+ out.i = LongSwap(out.i);
- b1 = l&255;
- b2 = (l>>8)&255;
- b3 = (l>>16)&255;
- b4 = (l>>24)&255;
-
- return ((int)b1<<24) + ((int)b2<<16) + ((int)b3<<8) + b4;
-}
-
-int LittleLong (int l)
-{
- return l;
-}
-
-float BigFloat (float l)
-{
- union {byte b[4]; float f;} in, out;
-
- in.f = l;
- out.b[0] = in.b[3];
- out.b[1] = in.b[2];
- out.b[2] = in.b[1];
- out.b[3] = in.b[0];
-
return out.f;
}
-float LittleFloat (float l)
-{
- return l;
-}
-
-
-#endif
-
-
//=======================================================
diff --git a/src/tools/asm/cmdlib.h b/src/tools/asm/cmdlib.h
index 36a5dfc..4bf998e 100644
--- a/src/tools/asm/cmdlib.h
+++ b/src/tools/asm/cmdlib.h
@@ -1,7 +1,7 @@
/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.
-Copyright (C) 2000-2006 Tim Angus
+Copyright (C) 2000-2013 Darklegion Development
This file is part of Tremulous.
@@ -116,14 +116,6 @@ void ExtractFileExtension( const char *path, char *dest );
int ParseNum (const char *str);
-short BigShort (short l);
-short LittleShort (short l);
-int BigLong (int l);
-int LittleLong (int l);
-float BigFloat (float l);
-float LittleFloat (float l);
-
-
char *COM_Parse (char *data);
extern char com_token[1024];
diff --git a/src/tools/asm/mathlib.h b/src/tools/asm/mathlib.h
index 71bbabb..9818bf3 100644
--- a/src/tools/asm/mathlib.h
+++ b/src/tools/asm/mathlib.h
@@ -1,7 +1,7 @@
/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.
-Copyright (C) 2000-2006 Tim Angus
+Copyright (C) 2000-2013 Darklegion Development
This file is part of Tremulous.
diff --git a/src/tools/asm/opstrings.h b/src/tools/asm/opstrings.h
index 0bf81ab..c0af871 100644
--- a/src/tools/asm/opstrings.h
+++ b/src/tools/asm/opstrings.h
@@ -1,7 +1,7 @@
/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.
-Copyright (C) 2000-2006 Tim Angus
+Copyright (C) 2000-2013 Darklegion Development
This file is part of Tremulous.
diff --git a/src/tools/asm/q3asm.c b/src/tools/asm/q3asm.c
index 4f4c9a3..44a4219 100644
--- a/src/tools/asm/q3asm.c
+++ b/src/tools/asm/q3asm.c
@@ -1,7 +1,7 @@
/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.
-Copyright (C) 2000-2006 Tim Angus
+Copyright (C) 2000-2013 Darklegion Development
This file is part of Tremulous.
@@ -21,6 +21,7 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
===========================================================================
*/
+#include "../../qcommon/q_platform.h"
#include "cmdlib.h"
#include "mathlib.h"
#include "../../qcommon/qfiles.h"
@@ -131,7 +132,7 @@ typedef enum {
DATASEG, // initialized 32 bit data, will be byte swapped
LITSEG, // strings
BSSSEG, // 0 filled
- JTRGSEG, // psuedo-segment that contains only jump table targets
+ JTRGSEG, // pseudo-segment that contains only jump table targets
NUM_SEGMENTS
} segmentName_t;
@@ -226,16 +227,14 @@ int opcodesHash[ NUM_SOURCE_OPS ];
-int
-vreport (const char* fmt, va_list vp)
+static int vreport (const char* fmt, va_list vp)
{
if (options.verbose != qtrue)
return 0;
return vprintf(fmt, vp);
}
-int
-report (const char *fmt, ...)
+static int report (const char *fmt, ...)
{
va_list va;
int retval;
@@ -248,16 +247,13 @@ report (const char *fmt, ...)
/* The chain-and-bucket hash table. -PH */
-void
-hashtable_init (hashtable_t *H, int buckets)
+static void hashtable_init (hashtable_t *H, int buckets)
{
H->buckets = buckets;
H->table = calloc(H->buckets, sizeof(*(H->table)));
- return;
}
-hashtable_t *
-hashtable_new (int buckets)
+static hashtable_t *hashtable_new (int buckets)
{
hashtable_t *H;
@@ -268,8 +264,7 @@ hashtable_new (int buckets)
/* No destroy/destructor. No need. */
-void
-hashtable_add (hashtable_t *H, int hashvalue, void *datum)
+static void hashtable_add (hashtable_t *H, int hashvalue, void *datum)
{
hashchain_t *hc, **hb;
@@ -290,18 +285,15 @@ hashtable_add (hashtable_t *H, int hashvalue, void *datum)
}
hc->data = datum;
hc->next = 0;
- return;
}
-hashchain_t *
-hashtable_get (hashtable_t *H, int hashvalue)
+static hashchain_t *hashtable_get (hashtable_t *H, int hashvalue)
{
hashvalue = (abs(hashvalue) % H->buckets);
return (H->table[hashvalue]);
}
-void
-hashtable_stats (hashtable_t *H)
+static void hashtable_stats (hashtable_t *H)
{
int len, empties, longest, nodes;
int i;
@@ -341,8 +333,7 @@ hashtable_stats (hashtable_t *H)
/* Kludge. */
/* Check if symbol already exists. */
/* Returns 0 if symbol does NOT already exist, non-zero otherwise. */
-int
-hashtable_symbol_exists (hashtable_t *H, int hash, char *sym)
+static int hashtable_symbol_exists (hashtable_t *H, int hash, char *sym)
{
hashchain_t *hc;
symbol_t *s;
@@ -372,8 +363,7 @@ hashtable_symbol_exists (hashtable_t *H, int hash, char *sym)
/* Comparator function for quicksorting. */
-int
-symlist_cmp (const void *e1, const void *e2)
+static int symlist_cmp (const void *e1, const void *e2)
{
const symbol_t *a, *b;
@@ -389,15 +379,18 @@ symlist_cmp (const void *e1, const void *e2)
However, qsort(3) already exists, and I'm really lazy.
-PH
*/
-void
-sort_symbols ()
+static void sort_symbols ()
{
int i, elems;
symbol_t *s;
symbol_t **symlist;
+ if(!symbols)
+ return;
+
//crumb("sort_symbols: Constructing symlist array\n");
for (elems = 0, s = symbols; s; s = s->next, elems++) /* nop */ ;
+
symlist = malloc(elems * sizeof(symbol_t*));
for (i = 0, s = symbols; s; s = s->next, i++)
{
@@ -439,7 +432,7 @@ sort_symbols ()
This function is one big evil hack to work around this problem.
*/
-int atoiNoCap (const char *s)
+static int atoiNoCap (const char *s)
{
INT64 l;
union {
@@ -465,7 +458,7 @@ HashString
=============
*/
/* Default hash function of Kazlib 1.19, slightly modified. */
-unsigned int HashString (const char *key)
+static unsigned int HashString (const char *key)
{
static unsigned long randbox[] = {
0x49848f1bU, 0xe6255dbaU, 0x36da5bdcU, 0x47bf94e9U,
@@ -494,15 +487,15 @@ unsigned int HashString (const char *key)
CodeError
============
*/
-void CodeError( char *fmt, ... ) {
+static void CodeError( char *fmt, ... ) {
va_list argptr;
errorCount++;
- report( "%s:%i ", currentFileName, currentFileLine );
+ fprintf( stderr, "%s:%i ", currentFileName, currentFileLine );
va_start( argptr,fmt );
- vprintf( fmt,argptr );
+ vfprintf( stderr, fmt, argptr );
va_end( argptr );
}
@@ -511,7 +504,7 @@ void CodeError( char *fmt, ... ) {
EmitByte
============
*/
-void EmitByte( segment_t *seg, int v ) {
+static void EmitByte( segment_t *seg, int v ) {
if ( seg->imageUsed >= MAX_IMAGE ) {
Error( "MAX_IMAGE" );
}
@@ -524,7 +517,7 @@ void EmitByte( segment_t *seg, int v ) {
EmitInt
============
*/
-void EmitInt( segment_t *seg, int v ) {
+static void EmitInt( segment_t *seg, int v ) {
if ( seg->imageUsed >= MAX_IMAGE - 4) {
Error( "MAX_IMAGE" );
}
@@ -542,7 +535,7 @@ DefineSymbol
Symbols can only be defined on pass 0
============
*/
-void DefineSymbol( char *sym, int value ) {
+static void DefineSymbol( char *sym, int value ) {
/* Hand optimization by PhaethonH */
symbol_t *s;
char expanded[MAX_LINE_LENGTH];
@@ -598,7 +591,7 @@ LookupSymbol
Symbols can only be evaluated on pass 1
============
*/
-int LookupSymbol( char *sym ) {
+static int LookupSymbol( char *sym ) {
symbol_t *s;
char expanded[MAX_LINE_LENGTH];
int hash;
@@ -646,7 +639,7 @@ If a full line isn't parsed, returns NULL
Otherwise returns the updated parse pointer
===============
*/
-char *ExtractLine( char *data ) {
+static char *ExtractLine( char *data ) {
/* Goal:
Given a string `data', extract one text line into buffer `lineBuffer' that
is no longer than MAX_LINE_LENGTH characters long. Return value is
@@ -688,7 +681,7 @@ Parse
Parse a token out of linebuffer
==============
*/
-qboolean Parse( void ) {
+static qboolean Parse( void ) {
/* Hand-optimized by PhaethonH */
const char *p, *q;
@@ -724,7 +717,7 @@ qboolean Parse( void ) {
ParseValue
==============
*/
-int ParseValue( void ) {
+static int ParseValue( void ) {
Parse();
return atoiNoCap( token );
}
@@ -735,7 +728,7 @@ int ParseValue( void ) {
ParseExpression
==============
*/
-int ParseExpression(void) {
+static int ParseExpression(void) {
/* Hand optimization, PhaethonH */
int i, j;
char sym[MAX_LINE_LENGTH];
@@ -806,7 +799,7 @@ Note that the lit segment is read-write in the VM, so strings
aren't read only as in some architectures.
==============
*/
-void HackToSegment( segmentName_t seg ) {
+static void HackToSegment( segmentName_t seg ) {
if ( currentSegment == &segment[seg] ) {
return;
}
@@ -956,12 +949,11 @@ STAT("PROC");
ASM(ENDPROC)
{
- int v, v2;
if ( !strcmp( token, "endproc" ) ) {
STAT("ENDPROC");
Parse(); // skip the function name
- v = ParseValue(); // locals
- v2 = ParseValue(); // arg marshalling
+ ParseValue(); // locals
+ ParseValue(); // arg marshalling
// all functions must leave something on the opstack
instructionCount++;
@@ -1165,7 +1157,7 @@ AssembleLine
==============
*/
-void AssembleLine( void ) {
+static void AssembleLine( void ) {
hashchain_t *hc;
sourceOps_t *op;
int i;
@@ -1320,7 +1312,7 @@ void InitTables( void ) {
WriteMapFile
==============
*/
-void WriteMapFile( void ) {
+static void WriteMapFile( void ) {
FILE *f;
symbol_t *s;
char imageName[MAX_OS_PATH];
@@ -1352,7 +1344,7 @@ void WriteMapFile( void ) {
WriteVmFile
===============
*/
-void WriteVmFile( void ) {
+static void WriteVmFile( void ) {
char imageName[MAX_OS_PATH];
vmHeader_t header;
FILE *f;
@@ -1401,6 +1393,17 @@ void WriteVmFile( void ) {
report( "Writing to %s\n", imageName );
+#ifdef Q3_BIG_ENDIAN
+ {
+ int i;
+
+ // byte swap the header
+ for ( i = 0 ; i < sizeof( vmHeader_t ) / 4 ; i++ ) {
+ ((int *)&header)[i] = LittleLong( ((int *)&header)[i] );
+ }
+ }
+#endif
+
CreatePath( imageName );
f = SafeOpenWrite( imageName );
SafeWrite( f, &header, headerSize );
@@ -1420,7 +1423,7 @@ void WriteVmFile( void ) {
Assemble
===============
*/
-void Assemble( void ) {
+static void Assemble( void ) {
int i;
char filename[MAX_OS_PATH];
char *ptr;
@@ -1487,7 +1490,7 @@ ParseOptionFile
=============
*/
-void ParseOptionFile( const char *filename ) {
+static void ParseOptionFile( const char *filename ) {
char expanded[MAX_OS_PATH];
char *text, *text_p;
@@ -1515,6 +1518,20 @@ void ParseOptionFile( const char *filename ) {
}
}
+static void ShowHelp( char *argv0 ) {
+ Error("Usage: %s [OPTION]... [FILES]...\n\
+Assemble LCC bytecode assembly to Q3VM bytecode.\n\
+\n\
+ -o OUTPUT Write assembled output to file OUTPUT.qvm\n\
+ -f LISTFILE Read options and list of files to assemble from LISTFILE.q3asm\n\
+ -b BUCKETS Set symbol hash table to BUCKETS buckets\n\
+ -m Generate a mapfile for each OUTPUT.qvm\n\
+ -v Verbose compilation report\n\
+ -vq3 Produce a qvm file compatible with Q3 1.32b\n\
+ -h --help -? Show this help\n\
+", argv0);
+}
+
/*
==============
main
@@ -1527,15 +1544,7 @@ int main( int argc, char **argv ) {
// _chdir( "/quake3/jccode/cgame/lccout" ); // hack for vc profiler
if ( argc < 2 ) {
- Error("Usage: %s [OPTION]... [FILES]...\n\
-Assemble LCC bytecode assembly to Q3VM bytecode.\n\
-\n\
- -o OUTPUT Write assembled output to file OUTPUT.qvm\n\
- -f LISTFILE Read options and list of files to assemble from LISTFILE\n\
- -b BUCKETS Set symbol hash table to BUCKETS buckets\n\
- -v Verbose compilation report\n\
- -vq3 Produce a qvm file compatible with Q3 1.32b\n\
-", argv[0]);
+ ShowHelp( argv[0] );
}
start = I_FloatTime ();
@@ -1548,6 +1557,12 @@ Assemble LCC bytecode assembly to Q3VM bytecode.\n\
if ( argv[i][0] != '-' ) {
break;
}
+ if( !strcmp( argv[ i ], "-h" ) ||
+ !strcmp( argv[ i ], "--help" ) ||
+ !strcmp( argv[ i ], "-?") ) {
+ ShowHelp( argv[0] );
+ }
+
if ( !strcmp( argv[i], "-o" ) ) {
if ( i == argc - 1 ) {
Error( "-o must preceed a filename" );
@@ -1604,6 +1619,10 @@ Motivation: not wanting to scrollback for pages to find asm error.
asmFileNames[ numAsmFiles ] = copystring( argv[ i ] );
numAsmFiles++;
}
+ // In some case it Segfault without this check
+ if ( numAsmFiles == 0 ) {
+ Error( "No file to assemble" );
+ }
InitTables();
Assemble();
diff --git a/src/tools/lcc/Makefile b/src/tools/lcc/Makefile
deleted file mode 100644
index 8dd5fb2..0000000
--- a/src/tools/lcc/Makefile
+++ /dev/null
@@ -1,163 +0,0 @@
-TEMPDIR=/tmp
-A=.a
-O=.o
-
-ifeq ($(PLATFORM),mingw32)
- E=.exe
-else
- E=
-endif
-
-CC=gcc
-LCC_CFLAGS=-O2 -Wall -fno-strict-aliasing -MMD
-LDFLAGS=
-LD=gcc
-AR=ar
-ARFLAGS=cru
-RANLIB=ranlib
-DIFF=diff
-RM=rm -f
-RMDIR=rmdir
-BUILDDIR=build-$(PLATFORM)-$(ARCH)
-BD=$(BUILDDIR)/
-
-ifeq ($(USE_CCACHE),1)
- CC := ccache $(CC)
-endif
-
-# Need MACOS_X defined or this won't build.
-ifeq ($(PLATFORM),darwin)
- LCC_CFLAGS += -DMACOS_X
-endif
-
-ifeq ($(PLATFORM),sunos)
- INSTALL=ginstall
-else
- INSTALL=install
-endif
-
-all: q3rcc lburg q3cpp q3lcc
-
-q3rcc: makedirs $(BD)q3rcc$(E)
-lburg: makedirs $(BD)lburg$(E)
-q3cpp: makedirs $(BD)q3cpp$(E)
-q3lcc: makedirs $(BD)q3lcc$(E)
-
-makedirs:
- @if [ ! -d $(BD) ];then mkdir $(BD);fi
- @if [ ! -d $(BD)/etc ];then mkdir $(BD)/etc;fi
- @if [ ! -d $(BD)/rcc ];then mkdir $(BD)/rcc;fi
- @if [ ! -d $(BD)/cpp ];then mkdir $(BD)/cpp;fi
- @if [ ! -d $(BD)/lburg ];then mkdir $(BD)/lburg;fi
-
-# ===== RCC =====
-RCCOBJS= \
- $(BD)rcc/alloc$(O) \
- $(BD)rcc/bind$(O) \
- $(BD)rcc/bytecode$(O) \
- $(BD)rcc/dag$(O) \
- $(BD)rcc/dagcheck$(O) \
- $(BD)rcc/decl$(O) \
- $(BD)rcc/enode$(O) \
- $(BD)rcc/error$(O) \
- $(BD)rcc/event$(O) \
- $(BD)rcc/expr$(O) \
- $(BD)rcc/gen$(O) \
- $(BD)rcc/init$(O) \
- $(BD)rcc/inits$(O) \
- $(BD)rcc/input$(O) \
- $(BD)rcc/lex$(O) \
- $(BD)rcc/list$(O) \
- $(BD)rcc/main$(O) \
- $(BD)rcc/null$(O) \
- $(BD)rcc/output$(O) \
- $(BD)rcc/prof$(O) \
- $(BD)rcc/profio$(O) \
- $(BD)rcc/simp$(O) \
- $(BD)rcc/stmt$(O) \
- $(BD)rcc/string$(O) \
- $(BD)rcc/sym$(O) \
- $(BD)rcc/symbolic$(O) \
- $(BD)rcc/trace$(O) \
- $(BD)rcc/tree$(O) \
- $(BD)rcc/types$(O)
-
-$(BD)q3rcc$(E): $(RCCOBJS)
- $(LD) $(LDFLAGS) -o $@ $(RCCOBJS)
-
-$(BD)rcc/%$(O): src/%.c
- $(CC) $(LCC_CFLAGS) -c -Isrc -o $@ $<
-
-$(BD)rcc/dagcheck$(O): $(BD)rcc/dagcheck.c
- $(CC) $(LCC_CFLAGS) -Wno-unused -c -Isrc -o $@ $<
-
-$(BD)rcc/dagcheck.c: $(BD)lburg/lburg$(E) src/dagcheck.md
- $(BD)lburg/lburg$(E) src/dagcheck.md $@
-
-
-# ===== LBURG =====
-LBURGOBJS= \
- $(BD)lburg/lburg$(O) \
- $(BD)lburg/gram$(O)
-
-$(BD)lburg/lburg$(E): $(LBURGOBJS)
- $(LD) $(LDFLAGS) -o $@ $(LBURGOBJS)
-
-$(BD)lburg/%$(O): lburg/%.c
- $(CC) $(LCC_CFLAGS) -c -Ilburg -o $@ $<
-
-
-# ===== CPP =====
-CPPOBJS= \
- $(BD)cpp/cpp$(O) \
- $(BD)cpp/lex$(O) \
- $(BD)cpp/nlist$(O) \
- $(BD)cpp/tokens$(O) \
- $(BD)cpp/macro$(O) \
- $(BD)cpp/eval$(O) \
- $(BD)cpp/include$(O) \
- $(BD)cpp/hideset$(O) \
- $(BD)cpp/getopt$(O) \
- $(BD)cpp/unix$(O)
-
-$(BD)q3cpp$(E): $(CPPOBJS)
- $(LD) $(LDFLAGS) -o $@ $(CPPOBJS)
-
-$(BD)cpp/%$(O): cpp/%.c
- $(CC) $(LCC_CFLAGS) -c -Icpp -o $@ $<
-
-
-# ===== LCC =====
-LCCOBJS= \
- $(BD)etc/lcc$(O) \
- $(BD)etc/bytecode$(O)
-
-$(BD)q3lcc$(E): $(LCCOBJS)
- $(LD) $(LDFLAGS) -o $@ $(LCCOBJS)
-
-$(BD)etc/%$(O): etc/%.c
- $(CC) $(LCC_CFLAGS) -DTEMPDIR=\"$(TEMPDIR)\" -DSYSTEM=\"\" -c -Isrc -o $@ $<
-
-
-install: q3lcc q3cpp q3rcc
- $(INSTALL) -s -m 0755 $(BD)q3lcc$(E) ../
- $(INSTALL) -s -m 0755 $(BD)q3cpp$(E) ../
- $(INSTALL) -s -m 0755 $(BD)q3rcc$(E) ../
-
-uninstall:
- -$(RM) ../q3lcc$(E)
- -$(RM) ../q3cpp$(E)
- -$(RM) ../q3rcc$(E)
-
-clean:
- if [ -d $(BD) ];then (find $(BD) -name '*.d' -exec rm {} \;)fi
- $(RM) $(RCCOBJS) $(LBURGOBJS) $(CPPOBJS) $(LCCOBJS)
- $(RM) $(BD)rcc/dagcheck.c $(BD)lburg/lburg$(E)
- $(RM) $(BD)q3lcc$(E) $(BD)q3cpp$(E) $(BD)q3rcc$(E)
- $(RM) -r $(BD)
-
-D_FILES=$(shell find . -name '*.d')
-
-ifneq ($(strip $(D_FILES)),)
- include $(D_FILES)
-endif
diff --git a/src/tools/lcc/cpp/cpp.c b/src/tools/lcc/cpp/cpp.c
index 6739e4d..5c0cfd7 100644
--- a/src/tools/lcc/cpp/cpp.c
+++ b/src/tools/lcc/cpp/cpp.c
@@ -9,7 +9,7 @@ char rcsid[] = "cpp.c - faked rcsid";
#define OUTS 16384
char outbuf[OUTS];
-char *outp = outbuf;
+char *outbufp = outbuf;
Source *cursource;
int nerrs;
struct token nltoken = { NL, 0, 0, 0, 1, (uchar*)"\n" };
@@ -51,7 +51,7 @@ process(Tokenrow *trp)
for (;;) {
if (trp->tp >= trp->lp) {
trp->tp = trp->lp = trp->bp;
- outp = outbuf;
+ outbufp = outbuf;
anymacros |= gettokens(trp, 1);
trp->tp = trp->bp;
}
@@ -204,9 +204,14 @@ control(Tokenrow *trp)
error(WARNING, "Syntax error in #endif");
break;
+ case KWARNING:
+ trp->tp = tp+1;
+ error(WARNING, "#warning directive: %r", trp);
+ break;
+
case KERROR:
trp->tp = tp+1;
- error(WARNING, "#error directive: %r", trp);
+ error(ERROR, "#error directive: %r", trp);
break;
case KLINE:
@@ -245,7 +250,6 @@ control(Tokenrow *trp)
break;
}
setempty(trp);
- return;
}
void *
diff --git a/src/tools/lcc/cpp/cpp.h b/src/tools/lcc/cpp/cpp.h
index ae855c9..ddd7502 100644
--- a/src/tools/lcc/cpp/cpp.h
+++ b/src/tools/lcc/cpp/cpp.h
@@ -24,7 +24,7 @@ enum toktype { END, UNCLASS, NAME, NUMBER, STRING, CCON, NL, WS, DSHARP,
DSHARP1, NAME1, DEFINED, UMINUS };
enum kwtype { KIF, KIFDEF, KIFNDEF, KELIF, KELSE, KENDIF, KINCLUDE, KDEFINE,
- KUNDEF, KLINE, KERROR, KPRAGMA, KDEFINED,
+ KUNDEF, KLINE, KWARNING, KERROR, KPRAGMA, KDEFINED,
KLINENO, KFILE, KDATE, KTIME, KSTDC, KEVAL };
#define ISDEFINED 01 /* has #defined value */
@@ -143,7 +143,7 @@ void setobjname(char *);
char *basepath( char *fname );
-extern char *outp;
+extern char *outbufp;
extern Token nltoken;
extern Source *cursource;
extern char *curtime;
diff --git a/src/tools/lcc/cpp/include.c b/src/tools/lcc/cpp/include.c
index 1bb8847..5ecd8b3 100644
--- a/src/tools/lcc/cpp/include.c
+++ b/src/tools/lcc/cpp/include.c
@@ -108,7 +108,6 @@ doinclude(Tokenrow *trp)
return;
syntax:
error(ERROR, "Syntax error in #include");
- return;
}
/*
@@ -121,7 +120,7 @@ genline(void)
static Tokenrow tr = { &ta, &ta, &ta+1, 1 };
uchar *p;
- ta.t = p = (uchar*)outp;
+ ta.t = p = (uchar*)outbufp;
strcpy((char*)p, "#line ");
p += sizeof("#line ")-1;
p = (uchar*)outnum((char*)p, cursource->line);
@@ -134,8 +133,8 @@ genline(void)
strcpy((char*)p, cursource->filename);
p += strlen((char*)p);
*p++ = '"'; *p++ = '\n';
- ta.len = (char*)p-outp;
- outp = (char*)p;
+ ta.len = (char*)p-outbufp;
+ outbufp = (char*)p;
tr.tp = tr.bp;
puttokens(&tr);
}
diff --git a/src/tools/lcc/cpp/macro.c b/src/tools/lcc/cpp/macro.c
index 49d1129..2972083 100644
--- a/src/tools/lcc/cpp/macro.c
+++ b/src/tools/lcc/cpp/macro.c
@@ -218,7 +218,6 @@ expand(Tokenrow *trp, Nlist *np)
insertrow(trp, ntokc, &ntr);
trp->tp -= rowlen(&ntr);
dofree(ntr.bp);
- return;
}
/*
@@ -471,10 +470,10 @@ builtin(Tokenrow *trp, int biname)
/* most are strings */
tp->type = STRING;
if (tp->wslen) {
- *outp++ = ' ';
+ *outbufp++ = ' ';
tp->wslen = 1;
}
- op = outp;
+ op = outbufp;
*op++ = '"';
switch (biname) {
@@ -509,7 +508,7 @@ builtin(Tokenrow *trp, int biname)
}
if (tp->type==STRING)
*op++ = '"';
- tp->t = (uchar*)outp;
- tp->len = op - outp;
- outp = op;
+ tp->t = (uchar*)outbufp;
+ tp->len = op - outbufp;
+ outbufp = op;
}
diff --git a/src/tools/lcc/cpp/nlist.c b/src/tools/lcc/cpp/nlist.c
index d76df86..d3a8357 100644
--- a/src/tools/lcc/cpp/nlist.c
+++ b/src/tools/lcc/cpp/nlist.c
@@ -29,6 +29,7 @@ struct kwtab {
{"define", KDEFINE, ISKW},
{"undef", KUNDEF, ISKW},
{"line", KLINE, ISKW},
+ {"warning", KWARNING, ISKW},
{"error", KERROR, ISKW},
{"pragma", KPRAGMA, ISKW},
{"eval", KEVAL, ISKW},
diff --git a/src/tools/lcc/cpp/tokens.c b/src/tools/lcc/cpp/tokens.c
index 147569b..3570896 100644
--- a/src/tools/lcc/cpp/tokens.c
+++ b/src/tools/lcc/cpp/tokens.c
@@ -267,7 +267,7 @@ peektokens(Tokenrow *trp, char *str)
if (str)
fprintf(stderr, "%s ", str);
if (tp<trp->bp || tp>trp->lp)
- fprintf(stderr, "(tp offset %d) ", tp-trp->bp);
+ fprintf(stderr, "(tp offset %ld) ", (long int) (tp - trp->bp));
for (tp=trp->bp; tp<trp->lp && tp<trp->bp+32; tp++) {
if (tp->type!=NL) {
int c = tp->t[tp->len];
diff --git a/src/tools/lcc/cpp/unix.c b/src/tools/lcc/cpp/unix.c
index 17986d8..75e5b6d 100644
--- a/src/tools/lcc/cpp/unix.c
+++ b/src/tools/lcc/cpp/unix.c
@@ -2,6 +2,7 @@
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
+#include <sys/stat.h>
#include "cpp.h"
extern int lcc_getopt(int, char *const *, const char *);
@@ -66,7 +67,12 @@ setup(int argc, char **argv)
error(FATAL, "Can't open input file %s", fp);
}
if (optind+1<argc) {
- int fdo = creat(argv[optind+1], 0666);
+ int fdo;
+#ifdef WIN32
+ fdo = creat(argv[optind+1], _S_IREAD | _S_IWRITE);
+#else
+ fdo = creat(argv[optind+1], 0666);
+#endif
if (fdo<0)
error(FATAL, "Can't open output file %s", argv[optind+1]);
dup2(fdo, 1);
@@ -99,7 +105,8 @@ char *basepath( char *fname )
/* memmove is defined here because some vendors don't provide it at
all and others do a terrible job (like calling malloc) */
// -- ouch, that hurts -- ln
-#ifndef MACOS_X /* always use the system memmove() on Mac OS X. --ryan. */
+/* always use the system memmove() on Mac OS X. --ryan. */
+#if !defined(MACOS_X) && !defined(_MSC_VER)
#ifdef memmove
#undef memmove
#endif
@@ -109,7 +116,7 @@ memmove(void *dp, const void *sp, size_t n)
unsigned char *cdp, *csp;
if (n<=0)
- return 0;
+ return dp;
cdp = dp;
csp = (unsigned char *)sp;
if (cdp < csp) {
@@ -123,6 +130,6 @@ memmove(void *dp, const void *sp, size_t n)
*--cdp = *--csp;
} while (--n);
}
- return 0;
+ return dp;
}
#endif
diff --git a/src/tools/lcc/doc/4.html b/src/tools/lcc/doc/4.html
index a2e1213..0b4b36d 100644
--- a/src/tools/lcc/doc/4.html
+++ b/src/tools/lcc/doc/4.html
@@ -99,7 +99,7 @@ the symbol's <code>type</code> field.</p>
<h2><a NAME="operators">5.5 Dag Operators</a></h2>
-<p>The <code>op</code> field a of <code>node</code> structure holds a dag operator, which
+<p>The <code>op</code> field of a <code>node</code> structure holds a dag operator, which
consists of a generic operator, a type suffix, and a size indicator. The type suffixes
are:</p>
@@ -516,14 +516,14 @@ e.g.,</p>
<p>The type suffix for a conversion operator denotes the type of the result and the size
indicator gives the size of the result. For example, <code>CVUI4</code> converts an
unsigned (<code>U</code>) to a 4-byte signed integer (<code>I4</code>). The <code>syms[0]</code>
-field points to a symbol-table entry for a integer constant that gives the size of the
+field points to a symbol-table entry for an integer constant that gives the size of the
source operand. For example, if <code>syms[0]</code> in a <code>CVUI4</code> points to a
symbol-table entry for 2, the conversion widens a 2-byte unsigned integer to a 4-byte
signed integer. Conversions that widen unsigned integers zero-extend; those that widen
signed integers sign-extend.</p>
<p>The front end composes conversions between types <em>T</em><sub>1</sub> and <em>T</em><sub>2</sub>
-by widening <em>T</em><sub>1</sub> to it's &quot;supertype&quot;, if necessary, converting
+by widening <em>T</em><sub>1</sub> to its &quot;supertype&quot;, if necessary, converting
that result to <em>T</em><sub>2</sub>'s supertype, then narrowing the result to <em>T</em><sub>2</sub>,
if necessary. The following table lists the supertypes; omitted entries are their own
supertypes.</p>
diff --git a/src/tools/lcc/doc/install.html b/src/tools/lcc/doc/install.html
index 3cc59a8..3410e8f 100644
--- a/src/tools/lcc/doc/install.html
+++ b/src/tools/lcc/doc/install.html
@@ -722,7 +722,7 @@ C:\dist\lcc\4.1&gt;copy %BUILDDIR%\bprint.exe \bin
<h2><a NAME="bugs">Reporting Bugs</a></h2>
<p>lcc is a large, complex program. We find and repair errors routinely. If you think that
-you've found a error, follow the steps below, which are adapted from the instructions in
+you've found an error, follow the steps below, which are adapted from the instructions in
Chapter 1 of <cite>A Retargetable C Compiler: Design and Implementation</cite>.
<ol>
@@ -751,7 +751,7 @@ Chapter 1 of <cite>A Retargetable C Compiler: Design and Implementation</cite>.
HREF="ftp://ftp.cs.princeton.edu/pub/lcc"><code>pub/lcc</code></a>. A <a
HREF="ftp://ftp.cs.princeton.edu/pub/lcc/README"><code>README</code></a> file there gives
acquistion details, and the <a HREF="../LOG"><code>LOG</code></a> file reports what errors
- were fixed and when they were fixed. If you report a error that's been fixed, you might
+ were fixed and when they were fixed. If you report an error that's been fixed, you might
get a canned reply.</li>
<li>Send your program by electronic mail to <code>lcc-bugs@cs.princeton.edu</code>. Please
send only valid C programs; put all remarks in C comments so that we can process reports
diff --git a/src/tools/lcc/etc/bytecode.c b/src/tools/lcc/etc/bytecode.c
index fe4178f..a5855de 100644
--- a/src/tools/lcc/etc/bytecode.c
+++ b/src/tools/lcc/etc/bytecode.c
@@ -52,6 +52,10 @@ int option(char *arg) {
cpp[0] = concat(&arg[8], "/q3cpp" BINEXT);
include[0] = concat("-I", concat(&arg[8], "/include"));
com[0] = concat(&arg[8], "/q3rcc" BINEXT);
+ } else if (strncmp(arg, "-lcppdir=", 9) == 0) {
+ cpp[0] = concat(&arg[9], "/q3cpp" BINEXT);
+ } else if (strncmp(arg, "-lrccdir=", 9) == 0) {
+ com[0] = concat(&arg[9], "/q3rcc" BINEXT);
} else if (strcmp(arg, "-p") == 0 || strcmp(arg, "-pg") == 0) {
fprintf( stderr, "no profiling supported, %s ignored.\n", arg);
} else if (strcmp(arg, "-b") == 0)
diff --git a/src/tools/lcc/etc/lcc.c b/src/tools/lcc/etc/lcc.c
index cac01b9..aa3e789 100644
--- a/src/tools/lcc/etc/lcc.c
+++ b/src/tools/lcc/etc/lcc.c
@@ -11,7 +11,12 @@ static char rcsid[] = "Id: dummy rcsid";
#include <assert.h>
#include <ctype.h>
#include <signal.h>
+#ifdef WIN32
+#include <process.h> /* getpid() */
+#include <io.h> /* access() */
+#else
#include <unistd.h>
+#endif
#ifndef TEMPDIR
#define TEMPDIR "/tmp"
@@ -217,14 +222,74 @@ char *basename(char *name) {
#ifdef WIN32
#include <process.h>
+
+static char *escapeDoubleQuotes(const char *string) {
+ int stringLength = strlen(string);
+ int bufferSize = stringLength + 1;
+ int i, j;
+ char *newString;
+
+ if (string == NULL)
+ return NULL;
+
+ for (i = 0; i < stringLength; i++) {
+ if (string[i] == '"')
+ bufferSize++;
+ }
+
+ newString = (char*)malloc(bufferSize);
+
+ if (newString == NULL)
+ return NULL;
+
+ for (i = 0, j = 0; i < stringLength; i++) {
+ if (string[i] == '"')
+ newString[j++] = '\\';
+
+ newString[j++] = string[i];
+ }
+
+ newString[j] = '\0';
+
+ return newString;
+}
+
+static int spawn(const char *cmdname, char **argv) {
+ int argc = 0;
+ char **newArgv = argv;
+ int i;
+ intptr_t exitStatus;
+
+ // _spawnvp removes double quotes from arguments, so we
+ // have to escape them manually
+ while (*newArgv++ != NULL)
+ argc++;
+
+ newArgv = (char **)malloc(sizeof(char*) * (argc + 1));
+
+ for (i = 0; i < argc; i++)
+ newArgv[i] = escapeDoubleQuotes(argv[i]);
+
+ newArgv[argc] = NULL;
+
+ exitStatus = _spawnvp(_P_WAIT, cmdname, (const char *const *)newArgv);
+
+ for (i = 0; i < argc; i++)
+ free(newArgv[i]);
+
+ free(newArgv);
+ return exitStatus;
+}
+
#else
+
#define _P_WAIT 0
#ifndef __sun
extern int fork(void);
#endif
extern int wait(int *);
-static int _spawnvp(int mode, const char *cmdname, char *argv[]) {
+static int spawn(const char *cmdname, char **argv) {
int pid, n, status;
switch (pid = fork()) {
@@ -292,11 +357,7 @@ static int callsys(char **av) {
fprintf(stderr, "\n");
}
if (verbose < 2)
-#ifndef WIN32
- status = _spawnvp(_P_WAIT, executable, argv);
-#else
- status = _spawnvp(_P_WAIT, executable, (const char* const*)argv);
-#endif
+ status = spawn(executable, argv);
if (status == -1) {
fprintf(stderr, "%s: ", progname);
perror(argv[0]);
@@ -526,10 +587,6 @@ static void help(void) {
#define xx(v) if ((s = getenv(#v))) fprintf(stderr, #v "=%s\n", s)
xx(LCCINPUTS);
xx(LCCDIR);
-#ifdef WIN32
- xx(include);
- xx(lib);
-#endif
#undef xx
}
@@ -537,9 +594,6 @@ static void help(void) {
static void initinputs(void) {
char *s = getenv("LCCINPUTS");
List b;
-#ifdef WIN32
- List list;
-#endif
if (s == 0 || (s = inputs)[0] == 0)
s = ".";
@@ -556,13 +610,6 @@ static void initinputs(void) {
b->str = "";
} while (b != lccinputs);
}
-#ifdef WIN32
- if ((list = b = path2list(getenv("include"))))
- do {
- b = b->link;
- ilist = append(stringf("-I\"%s\"", b->str), ilist);
- } while (b != list);
-#endif
}
/* interrupt - catch interrupt signals */
@@ -771,10 +818,9 @@ char *strsave(const char *str) {
char *stringf(const char *fmt, ...) {
char buf[1024];
va_list ap;
- int n;
va_start(ap, fmt);
- n = vsprintf(buf, fmt, ap);
+ vsprintf(buf, fmt, ap);
va_end(ap);
return strsave(buf);
}
diff --git a/src/tools/lcc/lburg/gram.c b/src/tools/lcc/lburg/gram.c
index a1cc890..94fd3b3 100644
--- a/src/tools/lcc/lburg/gram.c
+++ b/src/tools/lcc/lburg/gram.c
@@ -1,262 +1,1545 @@
-#if defined(__STDC__) || defined(__cplusplus)
-#define YYCONST const
-#define YYPARAMS(x) x
-#define YYDEFUN(name, arglist, args) name(args)
-#define YYAND ,
-#define YYPTR void *
-#else
-#define YYCONST
-#define YYPARAMS(x) ()
-#define YYDEFUN(name, arglist, args) name arglist args;
-#define YYAND ;
-#define YYPTR char *
-#endif
-#ifndef lint
-YYCONST static char yysccsid[] = "@(#)yaccpar 1.8 (Berkeley +Cygnus.28) 01/20/91";
-#endif
-#define YYBYACC 1
-#ifndef YYDONT_INCLUDE_STDIO
-#include <stdio.h>
-#endif
-//#ifdef __cplusplus TA <tim@ngus.net> stdlib.h applies to C too
-#include <stdlib.h> /* for malloc/realloc/free */
-//#endif
-#line 2 "lburg/gram.y"
+/* A Bison parser, made by GNU Bison 3.0.2. */
+
+/* Bison implementation for Yacc-like parsers in C
+
+ Copyright (C) 1984, 1989-1990, 2000-2013 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 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
+
+/* As a special exception, you may create a larger work that contains
+ part or all of the Bison parser skeleton and distribute that work
+ under terms of your choice, so long as that work isn't itself a
+ parser generator using the skeleton or a modified version thereof
+ as a parser skeleton. Alternatively, if you modify or redistribute
+ the parser skeleton itself, you may (at your option) remove this
+ special exception, which will cause the skeleton and the resulting
+ Bison output files to be licensed under the GNU General Public
+ License without this special exception.
+
+ This special exception was added by the Free Software Foundation in
+ version 2.2 of Bison. */
+
+/* C LALR(1) parser skeleton written by Richard Stallman, by
+ simplifying the original so-called "semantic" parser. */
+
+/* All symbols defined below should begin with yy or YY, to avoid
+ infringing on user name space. This should be done even for local
+ variables, as they might otherwise be expanded by user macros.
+ There are some unavoidable exceptions within include files to
+ define necessary library symbols; they are noted "INFRINGES ON
+ USER NAME SPACE" below. */
+
+/* Identify Bison output. */
+#define YYBISON 1
+
+/* Bison version. */
+#define YYBISON_VERSION "3.0.2"
+
+/* Skeleton name. */
+#define YYSKELETON_NAME "yacc.c"
+
+/* Pure parsers. */
+#define YYPURE 0
+
+/* Push parsers. */
+#define YYPUSH 0
+
+/* Pull parsers. */
+#define YYPULL 1
+
+
+
+
+/* Copy the first part of user declarations. */
+#line 1 "code/tools/lcc/lburg/gram.y" /* yacc.c:339 */
+
#include <stdio.h>
#include "lburg.h"
+//static char rcsid[] = "$Id: gram.y 145 2001-10-17 21:53:10Z timo $";
/*lint -e616 -e527 -e652 -esym(552,yynerrs) -esym(563,yynewstate,yyerrlab) */
static int yylineno = 0;
-#line 8 "lburg/gram.y"
-typedef union {
+
+#line 74 "y.tab.c" /* yacc.c:339 */
+
+# ifndef YY_NULLPTR
+# if defined __cplusplus && 201103L <= __cplusplus
+# define YY_NULLPTR nullptr
+# else
+# define YY_NULLPTR 0
+# endif
+# endif
+
+/* Enabling verbose error messages. */
+#ifdef YYERROR_VERBOSE
+# undef YYERROR_VERBOSE
+# define YYERROR_VERBOSE 1
+#else
+# define YYERROR_VERBOSE 0
+#endif
+
+
+/* Debug traces. */
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
+#if YYDEBUG
+extern int yydebug;
+#endif
+
+/* Token type. */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+ enum yytokentype
+ {
+ TERMINAL = 258,
+ START = 259,
+ PPERCENT = 260,
+ ID = 261,
+ TEMPLATE = 262,
+ CODE = 263,
+ INT = 264
+ };
+#endif
+/* Tokens. */
+#define TERMINAL 258
+#define START 259
+#define PPERCENT 260
+#define ID 261
+#define TEMPLATE 262
+#define CODE 263
+#define INT 264
+
+/* Value type. */
+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+typedef union YYSTYPE YYSTYPE;
+union YYSTYPE
+{
+#line 8 "code/tools/lcc/lburg/gram.y" /* yacc.c:355 */
+
int n;
char *string;
Tree tree;
-} YYSTYPE;
-#line 37 "y.tab.c"
-#define TERMINAL 257
-#define START 258
-#define PPERCENT 259
-#define ID 260
-#define TEMPLATE 261
-#define CODE 262
-#define INT 263
-#define YYERRCODE 256
-static YYCONST short yylhs[] = { -1,
- 0, 0, 4, 4, 6, 6, 6, 6, 7, 7,
- 5, 5, 5, 5, 1, 3, 3, 3, 2,
+
+#line 135 "y.tab.c" /* yacc.c:355 */
};
-static YYCONST short yylen[] = { 2,
- 3, 1, 0, 2, 3, 3, 1, 2, 0, 4,
- 0, 7, 2, 3, 1, 1, 4, 6, 1,
+# define YYSTYPE_IS_TRIVIAL 1
+# define YYSTYPE_IS_DECLARED 1
+#endif
+
+
+extern YYSTYPE yylval;
+
+int yyparse (void);
+int yylex(void);
+
+
+
+/* Copy the second part of user declarations. */
+
+#line 150 "y.tab.c" /* yacc.c:358 */
+
+#ifdef short
+# undef short
+#endif
+
+#ifdef YYTYPE_UINT8
+typedef YYTYPE_UINT8 yytype_uint8;
+#else
+typedef unsigned char yytype_uint8;
+#endif
+
+#ifdef YYTYPE_INT8
+typedef YYTYPE_INT8 yytype_int8;
+#else
+typedef signed char yytype_int8;
+#endif
+
+#ifdef YYTYPE_UINT16
+typedef YYTYPE_UINT16 yytype_uint16;
+#else
+typedef unsigned short int yytype_uint16;
+#endif
+
+#ifdef YYTYPE_INT16
+typedef YYTYPE_INT16 yytype_int16;
+#else
+typedef short int yytype_int16;
+#endif
+
+#ifndef YYSIZE_T
+# ifdef __SIZE_TYPE__
+# define YYSIZE_T __SIZE_TYPE__
+# elif defined size_t
+# define YYSIZE_T size_t
+# elif ! defined YYSIZE_T
+# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+# define YYSIZE_T size_t
+# else
+# define YYSIZE_T unsigned int
+# endif
+#endif
+
+#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
+
+#ifndef YY_
+# if defined YYENABLE_NLS && YYENABLE_NLS
+# if ENABLE_NLS
+# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
+# define YY_(Msgid) dgettext ("bison-runtime", Msgid)
+# endif
+# endif
+# ifndef YY_
+# define YY_(Msgid) Msgid
+# endif
+#endif
+
+#ifndef YY_ATTRIBUTE
+# if (defined __GNUC__ \
+ && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \
+ || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
+# define YY_ATTRIBUTE(Spec) __attribute__(Spec)
+# else
+# define YY_ATTRIBUTE(Spec) /* empty */
+# endif
+#endif
+
+#ifndef YY_ATTRIBUTE_PURE
+# define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__))
+#endif
+
+#ifndef YY_ATTRIBUTE_UNUSED
+# define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
+#endif
+
+#if !defined _Noreturn \
+ && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
+# if defined _MSC_VER && 1200 <= _MSC_VER
+# define _Noreturn __declspec (noreturn)
+# else
+# define _Noreturn YY_ATTRIBUTE ((__noreturn__))
+# endif
+#endif
+
+/* Suppress unused-variable warnings by "using" E. */
+#if ! defined lint || defined __GNUC__
+# define YYUSE(E) ((void) (E))
+#else
+# define YYUSE(E) /* empty */
+#endif
+
+#if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
+/* Suppress an incorrect diagnostic about yylval being uninitialized. */
+# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
+ _Pragma ("GCC diagnostic push") \
+ _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
+ _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
+# define YY_IGNORE_MAYBE_UNINITIALIZED_END \
+ _Pragma ("GCC diagnostic pop")
+#else
+# define YY_INITIAL_VALUE(Value) Value
+#endif
+#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+# define YY_IGNORE_MAYBE_UNINITIALIZED_END
+#endif
+#ifndef YY_INITIAL_VALUE
+# define YY_INITIAL_VALUE(Value) /* Nothing. */
+#endif
+
+
+#if ! defined yyoverflow || YYERROR_VERBOSE
+
+/* The parser invokes alloca or malloc; define the necessary symbols. */
+
+# ifdef YYSTACK_USE_ALLOCA
+# if YYSTACK_USE_ALLOCA
+# ifdef __GNUC__
+# define YYSTACK_ALLOC __builtin_alloca
+# elif defined __BUILTIN_VA_ARG_INCR
+# include <alloca.h> /* INFRINGES ON USER NAME SPACE */
+# elif defined _AIX
+# define YYSTACK_ALLOC __alloca
+# elif defined _MSC_VER
+# include <malloc.h> /* INFRINGES ON USER NAME SPACE */
+# define alloca _alloca
+# else
+# define YYSTACK_ALLOC alloca
+# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
+# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+ /* Use EXIT_SUCCESS as a witness for stdlib.h. */
+# ifndef EXIT_SUCCESS
+# define EXIT_SUCCESS 0
+# endif
+# endif
+# endif
+# endif
+# endif
+
+# ifdef YYSTACK_ALLOC
+ /* Pacify GCC's 'empty if-body' warning. */
+# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
+# ifndef YYSTACK_ALLOC_MAXIMUM
+ /* The OS might guarantee only one guard page at the bottom of the stack,
+ and a page size can be as small as 4096 bytes. So we cannot safely
+ invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
+ to allow for a few compiler-allocated temporary stack slots. */
+# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
+# endif
+# else
+# define YYSTACK_ALLOC YYMALLOC
+# define YYSTACK_FREE YYFREE
+# ifndef YYSTACK_ALLOC_MAXIMUM
+# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
+# endif
+# if (defined __cplusplus && ! defined EXIT_SUCCESS \
+ && ! ((defined YYMALLOC || defined malloc) \
+ && (defined YYFREE || defined free)))
+# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+# ifndef EXIT_SUCCESS
+# define EXIT_SUCCESS 0
+# endif
+# endif
+# ifndef YYMALLOC
+# define YYMALLOC malloc
+# if ! defined malloc && ! defined EXIT_SUCCESS
+void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
+# endif
+# endif
+# ifndef YYFREE
+# define YYFREE free
+# if ! defined free && ! defined EXIT_SUCCESS
+void free (void *); /* INFRINGES ON USER NAME SPACE */
+# endif
+# endif
+# endif
+#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
+
+
+#if (! defined yyoverflow \
+ && (! defined __cplusplus \
+ || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
+
+/* A type that is properly aligned for any stack member. */
+union yyalloc
+{
+ yytype_int16 yyss_alloc;
+ YYSTYPE yyvs_alloc;
};
-static YYCONST short yydefred[] = { 3,
- 0, 0, 0, 9, 0, 11, 7, 4, 8, 0,
- 15, 0, 0, 0, 5, 6, 0, 13, 0, 0,
- 14, 0, 10, 0, 0, 0, 0, 0, 19, 0,
- 17, 0, 12, 0, 18,
+
+/* The size of the maximum gap between one aligned stack and the next. */
+# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
+
+/* The size of an array large to enough to hold all stacks, each with
+ N elements. */
+# define YYSTACK_BYTES(N) \
+ ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
+ + YYSTACK_GAP_MAXIMUM)
+
+# define YYCOPY_NEEDED 1
+
+/* Relocate STACK from its old location to the new one. The
+ local variables YYSIZE and YYSTACKSIZE give the old and new number of
+ elements in the stack, and YYPTR gives the new location of the
+ stack. Advance YYPTR to a properly aligned location for the next
+ stack. */
+# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
+ do \
+ { \
+ YYSIZE_T yynewbytes; \
+ YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
+ Stack = &yyptr->Stack_alloc; \
+ yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
+ yyptr += yynewbytes / sizeof (*yyptr); \
+ } \
+ while (0)
+
+#endif
+
+#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
+/* Copy COUNT objects from SRC to DST. The source and destination do
+ not overlap. */
+# ifndef YYCOPY
+# if defined __GNUC__ && 1 < __GNUC__
+# define YYCOPY(Dst, Src, Count) \
+ __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
+# else
+# define YYCOPY(Dst, Src, Count) \
+ do \
+ { \
+ YYSIZE_T yyi; \
+ for (yyi = 0; yyi < (Count); yyi++) \
+ (Dst)[yyi] = (Src)[yyi]; \
+ } \
+ while (0)
+# endif
+# endif
+#endif /* !YYCOPY_NEEDED */
+
+/* YYFINAL -- State number of the termination state. */
+#define YYFINAL 3
+/* YYLAST -- Last index in YYTABLE. */
+#define YYLAST 35
+
+/* YYNTOKENS -- Number of terminals. */
+#define YYNTOKENS 16
+/* YYNNTS -- Number of nonterminals. */
+#define YYNNTS 9
+/* YYNRULES -- Number of rules. */
+#define YYNRULES 20
+/* YYNSTATES -- Number of states. */
+#define YYNSTATES 37
+
+/* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
+ by yylex, with out-of-bounds checking. */
+#define YYUNDEFTOK 2
+#define YYMAXUTOK 264
+
+#define YYTRANSLATE(YYX) \
+ ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
+
+/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
+ as returned by yylex, without out-of-bounds checking. */
+static const yytype_uint8 yytranslate[] =
+{
+ 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 10, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 13, 14, 2, 2, 15, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 12, 2,
+ 2, 11, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
+ 5, 6, 7, 8, 9
};
-static YYCONST short yydgoto[] = { 1,
- 12, 30, 25, 2, 13, 8, 10,
+
+#if YYDEBUG
+ /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
+static const yytype_uint8 yyrline[] =
+{
+ 0, 22, 22, 23, 26, 27, 30, 31, 35, 36,
+ 39, 40, 43, 44, 45, 46, 49, 52, 53, 54,
+ 57
};
-static YYCONST short yysindex[] = { 0,
- 0, -4, -2, 0, -250, 0, 0, 0, 0, -9,
- 0, 1, -10, -49, 0, 0, 3, 0, -44, -248,
- 0, -244, 0, -22, -242, -244, -245, -37, 0, 10,
- 0, -244, 0, -20, 0,
+#endif
+
+#if YYDEBUG || YYERROR_VERBOSE || 0
+/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
+ First, the terminals, then, starting at YYNTOKENS, nonterminals. */
+static const char *const yytname[] =
+{
+ "$end", "error", "$undefined", "TERMINAL", "START", "PPERCENT", "ID",
+ "TEMPLATE", "CODE", "INT", "'\\n'", "'='", "':'", "'('", "')'", "','",
+ "$accept", "spec", "decls", "decl", "blist", "rules", "nonterm", "tree",
+ "cost", YY_NULLPTR
};
-static YYCONST short yyrindex[] = { 0,
- 0, 22, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 23, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, -39, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0,
+#endif
+
+# ifdef YYPRINT
+/* YYTOKNUM[NUM] -- (External) token number corresponding to the
+ (internal) symbol number NUM (which must be that of a token). */
+static const yytype_uint16 yytoknum[] =
+{
+ 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
+ 10, 61, 58, 40, 41, 44
};
-static YYCONST short yygindex[] = { 0,
- 11, 0, -23, 0, 0, 0, 0,
+# endif
+
+#define YYPACT_NINF -26
+
+#define yypact_value_is_default(Yystate) \
+ (!!((Yystate) == (-26)))
+
+#define YYTABLE_NINF -4
+
+#define yytable_value_is_error(Yytable_value) \
+ 0
+
+ /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
+ STATE-NUM. */
+static const yytype_int8 yypact[] =
+{
+ -26, 11, 0, -26, 5, -26, 8, -26, -26, -26,
+ -26, 3, -26, 7, 6, 9, -26, -26, 12, -26,
+ 13, 14, -26, 15, -26, 16, 17, 15, 18, 4,
+ -26, 20, -26, 15, -26, 19, -26
};
-#define YYTABLESIZE 255
-static YYCONST short yytable[] = { 18,
- 15, 16, 28, 31, 16, 7, 32, 9, 34, 11,
- 16, 20, 21, 22, 23, 24, 29, 26, 27, 33,
- 35, 2, 1, 19, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 16, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 17, 0, 0, 0, 11,
- 14, 3, 4, 5, 6,
+
+ /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
+ Performed when YYTABLE does not specify something else to do. Zero
+ means the default is an error. */
+static const yytype_uint8 yydefact[] =
+{
+ 4, 0, 0, 1, 0, 10, 0, 12, 8, 5,
+ 9, 0, 16, 0, 0, 0, 6, 7, 0, 14,
+ 0, 0, 15, 0, 11, 17, 0, 0, 0, 0,
+ 20, 0, 18, 0, 13, 0, 19
};
-static YYCONST short yycheck[] = { 10,
- 10, 41, 26, 41, 44, 10, 44, 10, 32, 260,
- 10, 61, 10, 58, 263, 260, 262, 40, 261, 10,
- 41, 0, 0, 13, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, 261, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, 256, -1, -1, -1, 260,
- 260, 256, 257, 258, 259,
+
+ /* YYPGOTO[NTERM-NUM]. */
+static const yytype_int8 yypgoto[] =
+{
+ -26, -26, -26, -26, -26, -26, 21, -25, -26
};
-#define YYFINAL 1
-#ifndef YYDEBUG
-#define YYDEBUG 0
-#endif
-#define YYMAXTOKEN 263
-#if YYDEBUG
-static YYCONST char *YYCONST yyname[] = {
-"end-of-file",0,0,0,0,0,0,0,0,0,"'\\n'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,"'('","')'",0,0,"','",0,0,0,0,0,0,0,0,0,0,0,0,0,"':'",0,0,
-"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-"TERMINAL","START","PPERCENT","ID","TEMPLATE","CODE","INT",
+
+ /* YYDEFGOTO[NTERM-NUM]. */
+static const yytype_int8 yydefgoto[] =
+{
+ -1, 1, 2, 9, 11, 14, 13, 26, 31
+};
+
+ /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
+ positive, shift that token. If negative, reduce the rule whose
+ number is the opposite. If YYTABLE_NINF, syntax error. */
+static const yytype_int8 yytable[] =
+{
+ -3, 4, 29, 5, 6, 7, -2, 18, 35, 15,
+ 8, 3, 12, 16, 12, 10, 19, 17, 32, 33,
+ 21, 25, 22, 24, 28, 23, 30, 0, 0, 27,
+ 34, 0, 0, 36, 0, 20
+};
+
+static const yytype_int8 yycheck[] =
+{
+ 0, 1, 27, 3, 4, 5, 0, 1, 33, 6,
+ 10, 0, 6, 10, 6, 10, 10, 10, 14, 15,
+ 11, 6, 10, 9, 7, 12, 8, -1, -1, 13,
+ 10, -1, -1, 14, -1, 14
};
-static YYCONST char *YYCONST yyrule[] = {
-"$accept : spec",
-"spec : decls PPERCENT rules",
-"spec : decls",
-"decls :",
-"decls : decls decl",
-"decl : TERMINAL blist '\\n'",
-"decl : START nonterm '\\n'",
-"decl : '\\n'",
-"decl : error '\\n'",
-"blist :",
-"blist : blist ID '=' INT",
-"rules :",
-"rules : rules nonterm ':' tree TEMPLATE cost '\\n'",
-"rules : rules '\\n'",
-"rules : rules error '\\n'",
-"nonterm : ID",
-"tree : ID",
-"tree : ID '(' tree ')'",
-"tree : ID '(' tree ',' tree ')'",
-"cost : CODE",
+
+ /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
+ symbol of state STATE-NUM. */
+static const yytype_uint8 yystos[] =
+{
+ 0, 17, 18, 0, 1, 3, 4, 5, 10, 19,
+ 10, 20, 6, 22, 21, 6, 10, 10, 1, 10,
+ 22, 11, 10, 12, 9, 6, 23, 13, 7, 23,
+ 8, 24, 14, 15, 10, 23, 14
};
+
+ /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
+static const yytype_uint8 yyr1[] =
+{
+ 0, 16, 17, 17, 18, 18, 19, 19, 19, 19,
+ 20, 20, 21, 21, 21, 21, 22, 23, 23, 23,
+ 24
+};
+
+ /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
+static const yytype_uint8 yyr2[] =
+{
+ 0, 2, 3, 1, 0, 2, 3, 3, 1, 2,
+ 0, 4, 0, 7, 2, 3, 1, 1, 4, 6,
+ 1
+};
+
+
+#define yyerrok (yyerrstatus = 0)
+#define yyclearin (yychar = YYEMPTY)
+#define YYEMPTY (-2)
+#define YYEOF 0
+
+#define YYACCEPT goto yyacceptlab
+#define YYABORT goto yyabortlab
+#define YYERROR goto yyerrorlab
+
+
+#define YYRECOVERING() (!!yyerrstatus)
+
+#define YYBACKUP(Token, Value) \
+do \
+ if (yychar == YYEMPTY) \
+ { \
+ yychar = (Token); \
+ yylval = (Value); \
+ YYPOPSTACK (yylen); \
+ yystate = *yyssp; \
+ goto yybackup; \
+ } \
+ else \
+ { \
+ yyerror (YY_("syntax error: cannot back up")); \
+ YYERROR; \
+ } \
+while (0)
+
+/* Error token number */
+#define YYTERROR 1
+#define YYERRCODE 256
+
+
+
+/* Enable debugging if requested. */
+#if YYDEBUG
+
+# ifndef YYFPRINTF
+# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
+# define YYFPRINTF fprintf
+# endif
+
+# define YYDPRINTF(Args) \
+do { \
+ if (yydebug) \
+ YYFPRINTF Args; \
+} while (0)
+
+/* This macro is provided for backward compatibility. */
+#ifndef YY_LOCATION_PRINT
+# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
#endif
-#define YYLEX yylex()
-#define YYEMPTY -1
-#define yyclearin (yychar=(YYEMPTY))
-#define yyerrok (yyerrflag=0)
+
+
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
+do { \
+ if (yydebug) \
+ { \
+ YYFPRINTF (stderr, "%s ", Title); \
+ yy_symbol_print (stderr, \
+ Type, Value); \
+ YYFPRINTF (stderr, "\n"); \
+ } \
+} while (0)
+
+
+/*----------------------------------------.
+| Print this symbol's value on YYOUTPUT. |
+`----------------------------------------*/
+
+static void
+yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
+{
+ FILE *yyo = yyoutput;
+ YYUSE (yyo);
+ if (!yyvaluep)
+ return;
+# ifdef YYPRINT
+ if (yytype < YYNTOKENS)
+ YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
+# endif
+ YYUSE (yytype);
+}
+
+
+/*--------------------------------.
+| Print this symbol on YYOUTPUT. |
+`--------------------------------*/
+
+static void
+yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
+{
+ YYFPRINTF (yyoutput, "%s %s (",
+ yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
+
+ yy_symbol_value_print (yyoutput, yytype, yyvaluep);
+ YYFPRINTF (yyoutput, ")");
+}
+
+/*------------------------------------------------------------------.
+| yy_stack_print -- Print the state stack from its BOTTOM up to its |
+| TOP (included). |
+`------------------------------------------------------------------*/
+
+static void
+yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
+{
+ YYFPRINTF (stderr, "Stack now");
+ for (; yybottom <= yytop; yybottom++)
+ {
+ int yybot = *yybottom;
+ YYFPRINTF (stderr, " %d", yybot);
+ }
+ YYFPRINTF (stderr, "\n");
+}
+
+# define YY_STACK_PRINT(Bottom, Top) \
+do { \
+ if (yydebug) \
+ yy_stack_print ((Bottom), (Top)); \
+} while (0)
+
+
+/*------------------------------------------------.
+| Report that the YYRULE is going to be reduced. |
+`------------------------------------------------*/
+
+static void
+yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule)
+{
+ unsigned long int yylno = yyrline[yyrule];
+ int yynrhs = yyr2[yyrule];
+ int yyi;
+ YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
+ yyrule - 1, yylno);
+ /* The symbols being reduced. */
+ for (yyi = 0; yyi < yynrhs; yyi++)
+ {
+ YYFPRINTF (stderr, " $%d = ", yyi + 1);
+ yy_symbol_print (stderr,
+ yystos[yyssp[yyi + 1 - yynrhs]],
+ &(yyvsp[(yyi + 1) - (yynrhs)])
+ );
+ YYFPRINTF (stderr, "\n");
+ }
+}
+
+# define YY_REDUCE_PRINT(Rule) \
+do { \
+ if (yydebug) \
+ yy_reduce_print (yyssp, yyvsp, Rule); \
+} while (0)
+
+/* Nonzero means print parse trace. It is left uninitialized so that
+ multiple parsers can coexist. */
+int yydebug;
+#else /* !YYDEBUG */
+# define YYDPRINTF(Args)
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
+# define YY_STACK_PRINT(Bottom, Top)
+# define YY_REDUCE_PRINT(Rule)
+#endif /* !YYDEBUG */
+
+
+/* YYINITDEPTH -- initial size of the parser's stacks. */
#ifndef YYINITDEPTH
-#define YYINITDEPTH 200
+# define YYINITDEPTH 200
#endif
-#ifdef YYSTACKSIZE
+
+/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
+ if the built-in stack extension method is used).
+
+ Do not make this value too large; the results are undefined if
+ YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
+ evaluated with infinite-precision integer arithmetic. */
+
#ifndef YYMAXDEPTH
-#define YYMAXDEPTH YYSTACKSIZE
-#endif
-#else
-#ifdef YYMAXDEPTH
-#define YYSTACKSIZE YYMAXDEPTH
-#else
-#define YYSTACKSIZE 500
-#define YYMAXDEPTH 500
-#endif
-#endif
-#ifndef YYMAXSTACKSIZE
-#define YYMAXSTACKSIZE 10000
+# define YYMAXDEPTH 10000
#endif
-int yydebug;
-int yynerrs;
-int yyerrflag;
-int yychar;
-YYSTYPE yyval;
-YYSTYPE yylval;
-static short *yyss;
-static YYSTYPE *yyvs;
-static int yystacksize;
-#define yyfree(x) free(x)
-extern int yylex();
-
-static YYPTR
-YYDEFUN (yymalloc, (bytes), unsigned bytes)
+
+
+#if YYERROR_VERBOSE
+
+# ifndef yystrlen
+# if defined __GLIBC__ && defined _STRING_H
+# define yystrlen strlen
+# else
+/* Return the length of YYSTR. */
+static YYSIZE_T
+yystrlen (const char *yystr)
{
- YYPTR ptr = (YYPTR) malloc (bytes);
- if (ptr != 0) return (ptr);
- yyerror ("yyparse: memory exhausted");
- return (0);
+ YYSIZE_T yylen;
+ for (yylen = 0; yystr[yylen]; yylen++)
+ continue;
+ return yylen;
}
+# endif
+# endif
-static YYPTR
-YYDEFUN (yyrealloc, (old, bytes), YYPTR old YYAND unsigned bytes)
+# ifndef yystpcpy
+# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
+# define yystpcpy stpcpy
+# else
+/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
+ YYDEST. */
+static char *
+yystpcpy (char *yydest, const char *yysrc)
{
- YYPTR ptr = (YYPTR) realloc (old, bytes);
- if (ptr != 0) return (ptr);
- yyerror ("yyparse: memory exhausted");
- return (0);
+ char *yyd = yydest;
+ const char *yys = yysrc;
+
+ while ((*yyd++ = *yys++) != '\0')
+ continue;
+
+ return yyd - 1;
}
+# endif
+# endif
+
+# ifndef yytnamerr
+/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
+ quotes and backslashes, so that it's suitable for yyerror. The
+ heuristic is that double-quoting is unnecessary unless the string
+ contains an apostrophe, a comma, or backslash (other than
+ backslash-backslash). YYSTR is taken from yytname. If YYRES is
+ null, do not copy; instead, return the length of what the result
+ would have been. */
+static YYSIZE_T
+yytnamerr (char *yyres, const char *yystr)
+{
+ if (*yystr == '"')
+ {
+ YYSIZE_T yyn = 0;
+ char const *yyp = yystr;
+
+ for (;;)
+ switch (*++yyp)
+ {
+ case '\'':
+ case ',':
+ goto do_not_strip_quotes;
+ case '\\':
+ if (*++yyp != '\\')
+ goto do_not_strip_quotes;
+ /* Fall through. */
+ default:
+ if (yyres)
+ yyres[yyn] = *yyp;
+ yyn++;
+ break;
+
+ case '"':
+ if (yyres)
+ yyres[yyn] = '\0';
+ return yyn;
+ }
+ do_not_strip_quotes: ;
+ }
+
+ if (! yyres)
+ return yystrlen (yystr);
+
+ return yystpcpy (yyres, yystr) - yyres;
+}
+# endif
+
+/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
+ about the unexpected token YYTOKEN for the state stack whose top is
+ YYSSP.
+
+ Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
+ not large enough to hold the message. In that case, also set
+ *YYMSG_ALLOC to the required number of bytes. Return 2 if the
+ required number of bytes is too large to store. */
static int
-#ifdef __GNUC__
-inline
-#endif
-yygrow ()
+yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
+ yytype_int16 *yyssp, int yytoken)
{
-#if YYDEBUG
- int old_stacksize = yystacksize;
+ YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
+ YYSIZE_T yysize = yysize0;
+ enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
+ /* Internationalized format string. */
+ const char *yyformat = YY_NULLPTR;
+ /* Arguments of yyformat. */
+ char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
+ /* Number of reported tokens (one for the "unexpected", one per
+ "expected"). */
+ int yycount = 0;
+
+ /* There are many possibilities here to consider:
+ - If this state is a consistent state with a default action, then
+ the only way this function was invoked is if the default action
+ is an error action. In that case, don't check for expected
+ tokens because there are none.
+ - The only way there can be no lookahead present (in yychar) is if
+ this state is a consistent state with a default action. Thus,
+ detecting the absence of a lookahead is sufficient to determine
+ that there is no unexpected or expected token to report. In that
+ case, just report a simple "syntax error".
+ - Don't assume there isn't a lookahead just because this state is a
+ consistent state with a default action. There might have been a
+ previous inconsistent state, consistent state with a non-default
+ action, or user semantic action that manipulated yychar.
+ - Of course, the expected token list depends on states to have
+ correct lookahead information, and it depends on the parser not
+ to perform extra reductions after fetching a lookahead from the
+ scanner and before detecting a syntax error. Thus, state merging
+ (from LALR or IELR) and default reductions corrupt the expected
+ token list. However, the list is correct for canonical LR with
+ one exception: it will still contain any token that will not be
+ accepted due to an error action in a later state.
+ */
+ if (yytoken != YYEMPTY)
+ {
+ int yyn = yypact[*yyssp];
+ yyarg[yycount++] = yytname[yytoken];
+ if (!yypact_value_is_default (yyn))
+ {
+ /* Start YYX at -YYN if negative to avoid negative indexes in
+ YYCHECK. In other words, skip the first -YYN actions for
+ this state because they are default actions. */
+ int yyxbegin = yyn < 0 ? -yyn : 0;
+ /* Stay within bounds of both yycheck and yytname. */
+ int yychecklim = YYLAST - yyn + 1;
+ int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
+ int yyx;
+
+ for (yyx = yyxbegin; yyx < yyxend; ++yyx)
+ if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
+ && !yytable_value_is_error (yytable[yyx + yyn]))
+ {
+ if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
+ {
+ yycount = 1;
+ yysize = yysize0;
+ break;
+ }
+ yyarg[yycount++] = yytname[yyx];
+ {
+ YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
+ if (! (yysize <= yysize1
+ && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
+ return 2;
+ yysize = yysize1;
+ }
+ }
+ }
+ }
+
+ switch (yycount)
+ {
+# define YYCASE_(N, S) \
+ case N: \
+ yyformat = S; \
+ break
+ YYCASE_(0, YY_("syntax error"));
+ YYCASE_(1, YY_("syntax error, unexpected %s"));
+ YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
+ YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
+ YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
+ YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
+# undef YYCASE_
+ }
+
+ {
+ YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
+ if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
+ return 2;
+ yysize = yysize1;
+ }
+
+ if (*yymsg_alloc < yysize)
+ {
+ *yymsg_alloc = 2 * yysize;
+ if (! (yysize <= *yymsg_alloc
+ && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
+ *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
+ return 1;
+ }
+
+ /* Avoid sprintf, as that infringes on the user's name space.
+ Don't have undefined behavior even if the translation
+ produced a string with the wrong number of "%s"s. */
+ {
+ char *yyp = *yymsg;
+ int yyi = 0;
+ while ((*yyp = *yyformat) != '\0')
+ if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
+ {
+ yyp += yytnamerr (yyp, yyarg[yyi++]);
+ yyformat += 2;
+ }
+ else
+ {
+ yyp++;
+ yyformat++;
+ }
+ }
+ return 0;
+}
+#endif /* YYERROR_VERBOSE */
+
+/*-----------------------------------------------.
+| Release the memory associated to this symbol. |
+`-----------------------------------------------*/
+
+static void
+yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
+{
+ YYUSE (yyvaluep);
+ if (!yymsg)
+ yymsg = "Deleting";
+ YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
+
+ YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+ YYUSE (yytype);
+ YY_IGNORE_MAYBE_UNINITIALIZED_END
+}
+
+
+
+
+/* The lookahead symbol. */
+int yychar;
+
+/* The semantic value of the lookahead symbol. */
+YYSTYPE yylval;
+/* Number of syntax errors so far. */
+int yynerrs;
+
+
+/*----------.
+| yyparse. |
+`----------*/
+
+int
+yyparse (void)
+{
+ int yystate;
+ /* Number of tokens to shift before error messages enabled. */
+ int yyerrstatus;
+
+ /* The stacks and their tools:
+ 'yyss': related to states.
+ 'yyvs': related to semantic values.
+
+ Refer to the stacks through separate pointers, to allow yyoverflow
+ to reallocate them elsewhere. */
+
+ /* The state stack. */
+ yytype_int16 yyssa[YYINITDEPTH];
+ yytype_int16 *yyss;
+ yytype_int16 *yyssp;
+
+ /* The semantic value stack. */
+ YYSTYPE yyvsa[YYINITDEPTH];
+ YYSTYPE *yyvs;
+ YYSTYPE *yyvsp;
+
+ YYSIZE_T yystacksize;
+
+ int yyn;
+ int yyresult;
+ /* Lookahead token as an internal (translated) token number. */
+ int yytoken = 0;
+ /* The variables used to return semantic value and location from the
+ action routines. */
+ YYSTYPE yyval;
+
+#if YYERROR_VERBOSE
+ /* Buffer for error messages, and its allocated size. */
+ char yymsgbuf[128];
+ char *yymsg = yymsgbuf;
+ YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
#endif
- short *new_yyss;
- YYSTYPE *new_yyvs;
-
- if (yystacksize == YYMAXSTACKSIZE)
- return (1);
- yystacksize += (yystacksize + 1 ) / 2;
- if (yystacksize > YYMAXSTACKSIZE)
- yystacksize = YYMAXSTACKSIZE;
-#if YYDEBUG
- if (yydebug)
- printf("yydebug: growing stack size from %d to %d\n",
- old_stacksize, yystacksize);
+
+#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
+
+ /* The number of symbols on the RHS of the reduced rule.
+ Keep to zero when no symbol should be popped. */
+ int yylen = 0;
+
+ yyssp = yyss = yyssa;
+ yyvsp = yyvs = yyvsa;
+ yystacksize = YYINITDEPTH;
+
+ YYDPRINTF ((stderr, "Starting parse\n"));
+
+ yystate = 0;
+ yyerrstatus = 0;
+ yynerrs = 0;
+ yychar = YYEMPTY; /* Cause a token to be read. */
+ goto yysetstate;
+
+/*------------------------------------------------------------.
+| yynewstate -- Push a new state, which is found in yystate. |
+`------------------------------------------------------------*/
+ yynewstate:
+ /* In all cases, when you get here, the value and location stacks
+ have just been pushed. So pushing a state here evens the stacks. */
+ yyssp++;
+
+ yysetstate:
+ *yyssp = yystate;
+
+ if (yyss + yystacksize - 1 <= yyssp)
+ {
+ /* Get the current used size of the three stacks, in elements. */
+ YYSIZE_T yysize = yyssp - yyss + 1;
+
+#ifdef yyoverflow
+ {
+ /* Give user a chance to reallocate the stack. Use copies of
+ these so that the &'s don't force the real ones into
+ memory. */
+ YYSTYPE *yyvs1 = yyvs;
+ yytype_int16 *yyss1 = yyss;
+
+ /* Each stack pointer address is followed by the size of the
+ data in use in that stack, in bytes. This used to be a
+ conditional around just the two extra args, but that might
+ be undefined if yyoverflow is a macro. */
+ yyoverflow (YY_("memory exhausted"),
+ &yyss1, yysize * sizeof (*yyssp),
+ &yyvs1, yysize * sizeof (*yyvsp),
+ &yystacksize);
+
+ yyss = yyss1;
+ yyvs = yyvs1;
+ }
+#else /* no yyoverflow */
+# ifndef YYSTACK_RELOCATE
+ goto yyexhaustedlab;
+# else
+ /* Extend the stack our own way. */
+ if (YYMAXDEPTH <= yystacksize)
+ goto yyexhaustedlab;
+ yystacksize *= 2;
+ if (YYMAXDEPTH < yystacksize)
+ yystacksize = YYMAXDEPTH;
+
+ {
+ yytype_int16 *yyss1 = yyss;
+ union yyalloc *yyptr =
+ (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
+ if (! yyptr)
+ goto yyexhaustedlab;
+ YYSTACK_RELOCATE (yyss_alloc, yyss);
+ YYSTACK_RELOCATE (yyvs_alloc, yyvs);
+# undef YYSTACK_RELOCATE
+ if (yyss1 != yyssa)
+ YYSTACK_FREE (yyss1);
+ }
+# endif
+#endif /* no yyoverflow */
+
+ yyssp = yyss + yysize - 1;
+ yyvsp = yyvs + yysize - 1;
+
+ YYDPRINTF ((stderr, "Stack size increased to %lu\n",
+ (unsigned long int) yystacksize));
+
+ if (yyss + yystacksize - 1 <= yyssp)
+ YYABORT;
+ }
+
+ YYDPRINTF ((stderr, "Entering state %d\n", yystate));
+
+ if (yystate == YYFINAL)
+ YYACCEPT;
+
+ goto yybackup;
+
+/*-----------.
+| yybackup. |
+`-----------*/
+yybackup:
+
+ /* Do appropriate processing given the current state. Read a
+ lookahead token if we need one and don't already have one. */
+
+ /* First try to decide what to do without reference to lookahead token. */
+ yyn = yypact[yystate];
+ if (yypact_value_is_default (yyn))
+ goto yydefault;
+
+ /* Not known => get a lookahead token if don't already have one. */
+
+ /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
+ if (yychar == YYEMPTY)
+ {
+ YYDPRINTF ((stderr, "Reading a token: "));
+ yychar = yylex ();
+ }
+
+ if (yychar <= YYEOF)
+ {
+ yychar = yytoken = YYEOF;
+ YYDPRINTF ((stderr, "Now at end of input.\n"));
+ }
+ else
+ {
+ yytoken = YYTRANSLATE (yychar);
+ YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
+ }
+
+ /* If the proper action on seeing token YYTOKEN is to reduce or to
+ detect an error, take that action. */
+ yyn += yytoken;
+ if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
+ goto yydefault;
+ yyn = yytable[yyn];
+ if (yyn <= 0)
+ {
+ if (yytable_value_is_error (yyn))
+ goto yyerrlab;
+ yyn = -yyn;
+ goto yyreduce;
+ }
+
+ /* Count tokens shifted since error; after three, turn off error
+ status. */
+ if (yyerrstatus)
+ yyerrstatus--;
+
+ /* Shift the lookahead token. */
+ YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
+
+ /* Discard the shifted token. */
+ yychar = YYEMPTY;
+
+ yystate = yyn;
+ YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+ *++yyvsp = yylval;
+ YY_IGNORE_MAYBE_UNINITIALIZED_END
+
+ goto yynewstate;
+
+
+/*-----------------------------------------------------------.
+| yydefault -- do the default action for the current state. |
+`-----------------------------------------------------------*/
+yydefault:
+ yyn = yydefact[yystate];
+ if (yyn == 0)
+ goto yyerrlab;
+ goto yyreduce;
+
+
+/*-----------------------------.
+| yyreduce -- Do a reduction. |
+`-----------------------------*/
+yyreduce:
+ /* yyn is the number of a rule to reduce with. */
+ yylen = yyr2[yyn];
+
+ /* If YYLEN is nonzero, implement the default value of the action:
+ '$$ = $1'.
+
+ Otherwise, the following line sets YYVAL to garbage.
+ This behavior is undocumented and Bison
+ users should not rely upon it. Assigning to YYVAL
+ unconditionally makes the parser a bit smaller, and it avoids a
+ GCC warning that YYVAL may be used uninitialized. */
+ yyval = yyvsp[1-yylen];
+
+
+ YY_REDUCE_PRINT (yyn);
+ switch (yyn)
+ {
+ case 2:
+#line 22 "code/tools/lcc/lburg/gram.y" /* yacc.c:1646 */
+ { yylineno = 0; }
+#line 1240 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 3:
+#line 23 "code/tools/lcc/lburg/gram.y" /* yacc.c:1646 */
+ { yylineno = 0; }
+#line 1246 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 7:
+#line 31 "code/tools/lcc/lburg/gram.y" /* yacc.c:1646 */
+ {
+ if (nonterm((yyvsp[-1].string))->number != 1)
+ yyerror("redeclaration of the start symbol\n");
+ }
+#line 1255 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 9:
+#line 36 "code/tools/lcc/lburg/gram.y" /* yacc.c:1646 */
+ { yyerrok; }
+#line 1261 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 11:
+#line 40 "code/tools/lcc/lburg/gram.y" /* yacc.c:1646 */
+ { term((yyvsp[-2].string), (yyvsp[0].n)); }
+#line 1267 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 13:
+#line 44 "code/tools/lcc/lburg/gram.y" /* yacc.c:1646 */
+ { rule((yyvsp[-5].string), (yyvsp[-3].tree), (yyvsp[-2].string), (yyvsp[-1].string)); }
+#line 1273 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 15:
+#line 46 "code/tools/lcc/lburg/gram.y" /* yacc.c:1646 */
+ { yyerrok; }
+#line 1279 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 16:
+#line 49 "code/tools/lcc/lburg/gram.y" /* yacc.c:1646 */
+ { nonterm((yyval.string) = (yyvsp[0].string)); }
+#line 1285 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 17:
+#line 52 "code/tools/lcc/lburg/gram.y" /* yacc.c:1646 */
+ { (yyval.tree) = tree((yyvsp[0].string), 0, 0); }
+#line 1291 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 18:
+#line 53 "code/tools/lcc/lburg/gram.y" /* yacc.c:1646 */
+ { (yyval.tree) = tree((yyvsp[-3].string), (yyvsp[-1].tree), 0); }
+#line 1297 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 19:
+#line 54 "code/tools/lcc/lburg/gram.y" /* yacc.c:1646 */
+ { (yyval.tree) = tree((yyvsp[-5].string), (yyvsp[-3].tree), (yyvsp[-1].tree)); }
+#line 1303 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+ case 20:
+#line 57 "code/tools/lcc/lburg/gram.y" /* yacc.c:1646 */
+ { if (*(yyvsp[0].string) == 0) (yyval.string) = "0"; }
+#line 1309 "y.tab.c" /* yacc.c:1646 */
+ break;
+
+
+#line 1313 "y.tab.c" /* yacc.c:1646 */
+ default: break;
+ }
+ /* User semantic actions sometimes alter yychar, and that requires
+ that yytoken be updated with the new translation. We take the
+ approach of translating immediately before every use of yytoken.
+ One alternative is translating here after every semantic action,
+ but that translation would be missed if the semantic action invokes
+ YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
+ if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
+ incorrect destructor might then be invoked immediately. In the
+ case of YYERROR or YYBACKUP, subsequent parser actions might lead
+ to an incorrect destructor call or verbose syntax error message
+ before the lookahead is translated. */
+ YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
+
+ YYPOPSTACK (yylen);
+ yylen = 0;
+ YY_STACK_PRINT (yyss, yyssp);
+
+ *++yyvsp = yyval;
+
+ /* Now 'shift' the result of the reduction. Determine what state
+ that goes to, based on the state we popped back to and the rule
+ number reduced by. */
+
+ yyn = yyr1[yyn];
+
+ yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
+ if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
+ yystate = yytable[yystate];
+ else
+ yystate = yydefgoto[yyn - YYNTOKENS];
+
+ goto yynewstate;
+
+
+/*--------------------------------------.
+| yyerrlab -- here on detecting error. |
+`--------------------------------------*/
+yyerrlab:
+ /* Make sure we have latest lookahead translation. See comments at
+ user semantic actions for why this is necessary. */
+ yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
+
+ /* If not already recovering from an error, report this error. */
+ if (!yyerrstatus)
+ {
+ ++yynerrs;
+#if ! YYERROR_VERBOSE
+ yyerror (YY_("syntax error"));
+#else
+# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
+ yyssp, yytoken)
+ {
+ char const *yymsgp = YY_("syntax error");
+ int yysyntax_error_status;
+ yysyntax_error_status = YYSYNTAX_ERROR;
+ if (yysyntax_error_status == 0)
+ yymsgp = yymsg;
+ else if (yysyntax_error_status == 1)
+ {
+ if (yymsg != yymsgbuf)
+ YYSTACK_FREE (yymsg);
+ yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
+ if (!yymsg)
+ {
+ yymsg = yymsgbuf;
+ yymsg_alloc = sizeof yymsgbuf;
+ yysyntax_error_status = 2;
+ }
+ else
+ {
+ yysyntax_error_status = YYSYNTAX_ERROR;
+ yymsgp = yymsg;
+ }
+ }
+ yyerror (yymsgp);
+ if (yysyntax_error_status == 2)
+ goto yyexhaustedlab;
+ }
+# undef YYSYNTAX_ERROR
+#endif
+ }
+
+
+
+ if (yyerrstatus == 3)
+ {
+ /* If just tried and failed to reuse lookahead token after an
+ error, discard it. */
+
+ if (yychar <= YYEOF)
+ {
+ /* Return failure if at end of input. */
+ if (yychar == YYEOF)
+ YYABORT;
+ }
+ else
+ {
+ yydestruct ("Error: discarding",
+ yytoken, &yylval);
+ yychar = YYEMPTY;
+ }
+ }
+
+ /* Else will try to reuse lookahead token after shifting the error
+ token. */
+ goto yyerrlab1;
+
+
+/*---------------------------------------------------.
+| yyerrorlab -- error raised explicitly by YYERROR. |
+`---------------------------------------------------*/
+yyerrorlab:
+
+ /* Pacify compilers like GCC when the user code never invokes
+ YYERROR and the label yyerrorlab therefore never appears in user
+ code. */
+ if (/*CONSTCOND*/ 0)
+ goto yyerrorlab;
+
+ /* Do not reclaim the symbols of the rule whose action triggered
+ this YYERROR. */
+ YYPOPSTACK (yylen);
+ yylen = 0;
+ YY_STACK_PRINT (yyss, yyssp);
+ yystate = *yyssp;
+ goto yyerrlab1;
+
+
+/*-------------------------------------------------------------.
+| yyerrlab1 -- common code for both syntax error and YYERROR. |
+`-------------------------------------------------------------*/
+yyerrlab1:
+ yyerrstatus = 3; /* Each real token shifted decrements this. */
+
+ for (;;)
+ {
+ yyn = yypact[yystate];
+ if (!yypact_value_is_default (yyn))
+ {
+ yyn += YYTERROR;
+ if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
+ {
+ yyn = yytable[yyn];
+ if (0 < yyn)
+ break;
+ }
+ }
+
+ /* Pop the current state because it cannot handle the error token. */
+ if (yyssp == yyss)
+ YYABORT;
+
+
+ yydestruct ("Error: popping",
+ yystos[yystate], yyvsp);
+ YYPOPSTACK (1);
+ yystate = *yyssp;
+ YY_STACK_PRINT (yyss, yyssp);
+ }
+
+ YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+ *++yyvsp = yylval;
+ YY_IGNORE_MAYBE_UNINITIALIZED_END
+
+
+ /* Shift the error token. */
+ YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
+
+ yystate = yyn;
+ goto yynewstate;
+
+
+/*-------------------------------------.
+| yyacceptlab -- YYACCEPT comes here. |
+`-------------------------------------*/
+yyacceptlab:
+ yyresult = 0;
+ goto yyreturn;
+
+/*-----------------------------------.
+| yyabortlab -- YYABORT comes here. |
+`-----------------------------------*/
+yyabortlab:
+ yyresult = 1;
+ goto yyreturn;
+
+#if !defined yyoverflow || YYERROR_VERBOSE
+/*-------------------------------------------------.
+| yyexhaustedlab -- memory exhaustion comes here. |
+`-------------------------------------------------*/
+yyexhaustedlab:
+ yyerror (YY_("memory exhausted"));
+ yyresult = 2;
+ /* Fall through. */
#endif
- new_yyss = (short *) yyrealloc ((char *)yyss, yystacksize * sizeof (short));
- if (new_yyss == 0)
- return (1);
- new_yyvs = (YYSTYPE *) yyrealloc ((char *)yyvs, yystacksize * sizeof (YYSTYPE));
- if (new_yyvs == 0)
+
+yyreturn:
+ if (yychar != YYEMPTY)
+ {
+ /* Make sure we have latest lookahead translation. See comments at
+ user semantic actions for why this is necessary. */
+ yytoken = YYTRANSLATE (yychar);
+ yydestruct ("Cleanup: discarding lookahead",
+ yytoken, &yylval);
+ }
+ /* Do not reclaim the symbols of the rule whose action triggered
+ this YYABORT or YYACCEPT. */
+ YYPOPSTACK (yylen);
+ YY_STACK_PRINT (yyss, yyssp);
+ while (yyssp != yyss)
{
- yyfree (new_yyss);
- return (1);
+ yydestruct ("Cleanup: popping",
+ yystos[*yyssp], yyvsp);
+ YYPOPSTACK (1);
}
- yyss = new_yyss;
- yyvs = new_yyvs;
- return (0);
+#ifndef yyoverflow
+ if (yyss != yyssa)
+ YYSTACK_FREE (yyss);
+#endif
+#if YYERROR_VERBOSE
+ if (yymsg != yymsgbuf)
+ YYSTACK_FREE (yymsg);
+#endif
+ return yyresult;
}
-#line 60 "lburg/gram.y"
+#line 59 "code/tools/lcc/lburg/gram.y" /* yacc.c:1906 */
+
#include <assert.h>
#include <stdarg.h>
#include <ctype.h>
@@ -399,284 +1682,5 @@ void yywarn(char *fmt, ...) {
fprintf(stderr, "line %d: ", yylineno);
fprintf(stderr, "warning: ");
vfprintf(stderr, fmt, ap);
-}
-#line 403 "y.tab.c"
-#define YYABORT goto yyabort
-#define YYACCEPT goto yyaccept
-#define YYERROR goto yyerrlab
-
-#if YYDEBUG
-#ifdef __cplusplus
-extern "C" char *getenv();
-#else
-extern char *getenv();
-#endif
-#endif
-
-int
-yyparse()
-{
- register int yym, yyn, yystate;
- register YYSTYPE *yyvsp;
- register short *yyssp;
- short *yysse;
-#if YYDEBUG
- register YYCONST char *yys;
-
- if (yys = getenv("YYDEBUG"))
- {
- yyn = *yys;
- if (yyn >= '0' && yyn <= '9')
- yydebug = yyn - '0';
- }
-#endif
-
- yynerrs = 0;
- yyerrflag = 0;
- yychar = (-1);
-
- if (yyss == 0)
- {
- yyss = (short *) yymalloc (YYSTACKSIZE * sizeof (short));
- if (yyss == 0)
- goto yyabort;
- yyvs = (YYSTYPE *) yymalloc (YYSTACKSIZE * sizeof (YYSTYPE));
- if (yyvs == 0)
- {
- yyfree (yyss);
- goto yyabort;
- }
- yystacksize = YYSTACKSIZE;
- }
- yysse = yyss + yystacksize - 1;
- yyssp = yyss;
- yyvsp = yyvs;
- *yyssp = yystate = 0;
- goto yyloop;
-
-yypush_lex:
- yyval = yylval;
- yystate = yytable[yyn];
-yypush:
- if (yyssp >= yysse)
- {
- int depth = yyssp - yyss;
- if (yygrow() != 0)
- goto yyoverflow;
- yysse = yyss + yystacksize -1;
- yyssp = depth + yyss;
- yyvsp = depth + yyvs;
- }
- *++yyssp = yystate;
- *++yyvsp = yyval;
-
-yyloop:
- if ((yyn = yydefred[yystate])) goto yyreduce;
- yyn = yysindex[yystate];
- if (yychar < 0)
- {
- if ((yychar = yylex()) < 0) yychar = 0;
-#if YYDEBUG
- if (yydebug)
- {
- yys = 0;
- if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
- if (!yys) yys = "illegal-symbol";
- printf("yydebug: state %d, reading %d (%s)\n", yystate,
- yychar, yys);
- }
-#endif
- }
- if (yyn != 0
- && ((yyn += yychar), ((unsigned)yyn <= (unsigned)YYTABLESIZE))
- && yycheck[yyn] == yychar)
- {
-#if YYDEBUG
- if (yydebug)
- printf("yydebug: state %d, shifting to state %d\n",
- yystate, yytable[yyn]);
-#endif
- if (yyerrflag > 0) --yyerrflag;
- yychar = (-1);
- goto yypush_lex;
- }
- yyn = yyrindex[yystate];
- if (yyn != 0
- && ((yyn += yychar), ((unsigned)yyn <= (unsigned)YYTABLESIZE))
- && yycheck[yyn] == yychar)
- {
- yyn = yytable[yyn];
- goto yyreduce;
- }
- if (yyerrflag) goto yyinrecovery;
-#ifdef lint
- goto yynewerror;
-yynewerror:
-#endif
- yyerror("syntax error");
-#ifdef lint
- goto yyerrlab;
-yyerrlab:
-#endif
- ++yynerrs;
-yyinrecovery:
- if (yyerrflag < 3)
- {
- yyerrflag = 3;
- for (;;)
- {
- yyn = yysindex[*yyssp];
- if (yyn != 0
- && ((yyn += YYERRCODE), ((unsigned)yyn <= (unsigned)YYTABLESIZE))
- && yycheck[yyn] == YYERRCODE)
- {
-#if YYDEBUG
- if (yydebug)
- printf("yydebug: state %d, error recovery shifting\
- to state %d\n", *yyssp, yytable[yyn]);
-#endif
- goto yypush_lex;
- }
- else
- {
-#if YYDEBUG
- if (yydebug)
- printf("yydebug: error recovery discarding state %d\n",
- *yyssp);
-#endif
- if (yyssp <= yyss) goto yyabort;
- --yyssp;
- --yyvsp;
- }
- }
- }
- else
- {
- if (yychar == 0) goto yyabort;
-#if YYDEBUG
- if (yydebug)
- {
- yys = 0;
- if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
- if (!yys) yys = "illegal-symbol";
- printf("yydebug: state %d, error recovery discards token %d (%s)\n",
- yystate, yychar, yys);
- }
-#endif
- yychar = (-1);
- goto yyloop;
- }
-yyreduce:
-#if YYDEBUG
- if (yydebug)
- printf("yydebug: state %d, reducing by rule %d (%s)\n",
- yystate, yyn, yyrule[yyn]);
-#endif
- yym = yylen[yyn];
- yyval = yyvsp[1-yym];
- switch (yyn)
- {
-case 1:
-#line 22 "lburg/gram.y"
-{ yylineno = 0; }
-break;
-case 2:
-#line 23 "lburg/gram.y"
-{ yylineno = 0; }
-break;
-case 6:
-#line 31 "lburg/gram.y"
-{
- if (nonterm(yyvsp[-1].string)->number != 1)
- yyerror("redeclaration of the start symbol\n");
- }
-break;
-case 8:
-#line 36 "lburg/gram.y"
-{ yyerrok; }
-break;
-case 10:
-#line 40 "lburg/gram.y"
-{ term(yyvsp[-2].string, yyvsp[0].n); }
-break;
-case 12:
-#line 44 "lburg/gram.y"
-{ rule(yyvsp[-5].string, yyvsp[-3].tree, yyvsp[-2].string, yyvsp[-1].string); }
-break;
-case 14:
-#line 46 "lburg/gram.y"
-{ yyerrok; }
-break;
-case 15:
-#line 49 "lburg/gram.y"
-{ nonterm(yyval.string = yyvsp[0].string); }
-break;
-case 16:
-#line 52 "lburg/gram.y"
-{ yyval.tree = tree(yyvsp[0].string, 0, 0); }
-break;
-case 17:
-#line 53 "lburg/gram.y"
-{ yyval.tree = tree(yyvsp[-3].string, yyvsp[-1].tree, 0); }
-break;
-case 18:
-#line 54 "lburg/gram.y"
-{ yyval.tree = tree(yyvsp[-5].string, yyvsp[-3].tree, yyvsp[-1].tree); }
-break;
-case 19:
-#line 57 "lburg/gram.y"
-{ if (*yyvsp[0].string == 0) yyval.string = "0"; }
-break;
-#line 630 "y.tab.c"
- }
- yyssp -= yym;
- yyvsp -= yym;
- yym = yylhs[yyn];
- yystate = *yyssp;
- if (yystate == 0 && yym == 0)
- {
-#if YYDEBUG
- if (yydebug)
- printf("yydebug: after reduction, shifting from state 0 to\
- state %d\n", YYFINAL);
-#endif
- yystate = YYFINAL;
- *++yyssp = YYFINAL;
- *++yyvsp = yyval;
- if (yychar < 0)
- {
- if ((yychar = yylex()) < 0) yychar = 0;
-#if YYDEBUG
- if (yydebug)
- {
- yys = 0;
- if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
- if (!yys) yys = "illegal-symbol";
- printf("yydebug: state %d, reading %d (%s)\n",
- YYFINAL, yychar, yys);
- }
-#endif
- }
- if (yychar == 0) goto yyaccept;
- goto yyloop;
- }
- yyn = yygindex[yym];
- if (yyn != 0
- && ((yyn += yystate), ((unsigned)yyn <= (unsigned)YYTABLESIZE))
- && yycheck[yyn] == yystate)
- yystate = yytable[yyn];
- else
- yystate = yydgoto[yym];
-#if YYDEBUG
- if (yydebug)
- printf("yydebug: after reduction, shifting from state %d \
-to state %d\n", *yyssp, yystate);
-#endif
- goto yypush;
-yyoverflow:
- yyerror("yacc stack overflow");
-yyabort:
- return (1);
-yyaccept:
- return (0);
+ va_end(ap);
}
diff --git a/src/tools/lcc/lburg/gram.y b/src/tools/lcc/lburg/gram.y
index 1ecd8a9..c0a9c94 100644
--- a/src/tools/lcc/lburg/gram.y
+++ b/src/tools/lcc/lburg/gram.y
@@ -199,4 +199,5 @@ void yywarn(char *fmt, ...) {
fprintf(stderr, "line %d: ", yylineno);
fprintf(stderr, "warning: ");
vfprintf(stderr, fmt, ap);
+ va_end(ap);
}
diff --git a/src/tools/lcc/src/bytecode.c b/src/tools/lcc/src/bytecode.c
index b267d6f..871056a 100644
--- a/src/tools/lcc/src/bytecode.c
+++ b/src/tools/lcc/src/bytecode.c
@@ -40,8 +40,9 @@ static void I(defconst)(int suffix, int size, Value v) {
case P: print("byte %d %U\n", size, (unsigned long)v.p); return;
case F:
if (size == 4) {
- float f = v.d;
- print("byte 4 %u\n", *(unsigned *)&f);
+ floatint_t fi;
+ fi.f = v.d;
+ print("byte 4 %u\n", fi.ui);
} else {
unsigned *p = (unsigned *)&v.d;
print("byte 4 %u\n", p[swap]);
@@ -67,10 +68,10 @@ static void I(defsymbol)(Symbol p) {
case P: p->x.name = stringf("%U", p->u.c.v.p); break;
case F:
{ // JDC: added this to get inline floats
- unsigned temp;
+ floatint_t temp;
- *(float *)&temp = p->u.c.v.d;
- p->x.name = stringf("%U", temp );
+ temp.f = p->u.c.v.d;
+ p->x.name = stringf("%U", temp.ui );
}
break;// JDC: added this
default: assert(0);
diff --git a/src/tools/lcc/src/c.h b/src/tools/lcc/src/c.h
index e36380e..43bec08 100644
--- a/src/tools/lcc/src/c.h
+++ b/src/tools/lcc/src/c.h
@@ -98,6 +98,12 @@ typedef struct {
void *xt;
} Xtype;
+typedef union {
+ float f;
+ int i;
+ unsigned int ui;
+} floatint_t;
+
#include "config.h"
typedef struct metrics {
unsigned char size, align, outofline;
@@ -571,6 +577,7 @@ extern Tree cnsttree(Type, ...);
extern Tree consttree(unsigned int, Type);
extern Tree eqtree(int, Tree, Tree);
extern int iscallb(Tree);
+extern int isnullptr(Tree);
extern Tree shtree(int, Tree, Tree);
extern void typeerror(int, Tree, Tree);
diff --git a/src/tools/lcc/src/enode.c b/src/tools/lcc/src/enode.c
index 760096d..4a37618 100644
--- a/src/tools/lcc/src/enode.c
+++ b/src/tools/lcc/src/enode.c
@@ -5,7 +5,6 @@ static Tree addtree(int, Tree, Tree);
static Tree andtree(int, Tree, Tree);
static Tree cmptree(int, Tree, Tree);
static int compatible(Type, Type);
-static int isnullptr(Tree e);
static Tree multree(int, Tree, Tree);
static Tree subtree(int, Tree, Tree);
#define isvoidptr(ty) \
@@ -220,7 +219,7 @@ static int compatible(Type ty1, Type ty2) {
&& isptr(ty2) && !isfunc(ty2->type)
&& eqtype(unqual(ty1->type), unqual(ty2->type), 0);
}
-static int isnullptr(Tree e) {
+int isnullptr(Tree e) {
Type ty = unqual(e->type);
return generic(e->op) == CNST
diff --git a/src/tools/lcc/src/expr.c b/src/tools/lcc/src/expr.c
index b8cb08b..96eec21 100644
--- a/src/tools/lcc/src/expr.c
+++ b/src/tools/lcc/src/expr.c
@@ -621,7 +621,7 @@ Tree cast(Tree p, Type type) {
p = simplify(CVP, dst, p, NULL);
else {
if ((isfunc(src->type) && !isfunc(dst->type))
- || (!isfunc(src->type) && isfunc(dst->type)))
+ || (!isnullptr(p) && !isfunc(src->type) && isfunc(dst->type)))
warning("conversion from `%t' to `%t' is compiler dependent\n", p->type, type);
if (src->size != dst->size)
diff --git a/src/tools/lcc/src/list.c b/src/tools/lcc/src/list.c
index 29e660a..9c3ec9f 100644
--- a/src/tools/lcc/src/list.c
+++ b/src/tools/lcc/src/list.c
@@ -33,7 +33,7 @@ int length(List list) {
return n;
}
-/* ltov - convert list to an NULL-terminated vector allocated in arena */
+/* ltov - convert list to a NULL-terminated vector allocated in arena */
void *ltov(List *list, unsigned arena) {
int i = 0;
void **array = newarray(length(*list) + 1, sizeof array[0], arena);
generated by cgit (git 2.34.1) at 2024-12-24 18:16:09 +0000