From 98a36557e48d61ba8f9a895420b9c67b1df20d98 Mon Sep 17 00:00:00 2001 From: Michael Steil Date: Sat, 3 May 2014 22:20:34 -0700 Subject: [PATCH] Initial commit from macross.tar.gz MD5 (macross.tar.gz) = 4ecb4a6e015b11fef043fe78d1eedb61 --- .mark | 1 + DOC | 34 + Makefile | 164 +++ Makefile_6502 | 162 +++ Makefile_68000 | 162 +++ actions.o | Bin 0 -> 47534 bytes actions_6502.c | 511 ++++++++ actions_68000.c | 1089 +++++++++++++++++ buildStuff1.c | 547 +++++++++ buildStuff1.o | Bin 0 -> 48250 bytes buildStuff2.c | 358 ++++++ buildStuff2.o | Bin 0 -> 41152 bytes buildStuff3.c | 232 ++++ buildStuff3.o | Bin 0 -> 38158 bytes builtInFunctions.c | 1033 ++++++++++++++++ builtInFunctions.o | Bin 0 -> 59433 bytes builtInFunsSD.o | Bin 0 -> 38015 bytes builtInFunsSD_6502.c | 237 ++++ builtInFunsSD_68000.c | 505 ++++++++ conditionDefs_6502.h | 19 + conditionDefs_68000.h | 20 + debugPrint.c | 1200 +++++++++++++++++++ debugPrint.o | Bin 0 -> 72623 bytes debugPrintSD.o | Bin 0 -> 39082 bytes debugPrintSD_6502.c | 249 ++++ debugPrintSD_68000.c | 309 +++++ doc/genmacros.itr | 463 ++++++++ doc/handyHelpfulHints.t | 85 ++ doc/linkerReleaseNotes | 224 ++++ doc/macros.itr | 315 +++++ doc/macross.1 | 108 ++ doc/slinky.1 | 66 ++ doc/writeup_6502.itr | 2124 +++++++++++++++++++++++++++++++++ doc/writeup_68000.itr | 2262 ++++++++++++++++++++++++++++++++++++ driver.c | 47 + emitBranch.o | Bin 0 -> 37547 bytes emitBranch_6502.c | 157 +++ emitBranch_68000.c | 116 ++ emitStuff.c | 560 +++++++++ emitStuff.o | Bin 0 -> 47786 bytes encode.c | 674 +++++++++++ encode.o | Bin 0 -> 49930 bytes errorStuff.c | 360 ++++++ errorStuff.o | Bin 0 -> 47417 bytes errorfyle | 39 + expressionSemantics.c | 1219 +++++++++++++++++++ expressionSemantics.o | Bin 0 -> 73640 bytes fixups.c | 346 ++++++ fixups.o | Bin 0 -> 44133 bytes garbage.c | 829 +++++++++++++ garbage.o | Bin 0 -> 53605 bytes initialize.c | 557 +++++++++ initialize.o | Bin 0 -> 51325 bytes lexer.c | 542 +++++++++ lexer.o | Bin 0 -> 57423 bytes lexerTables.h | 85 ++ listing.c | 649 +++++++++++ listing.o | Bin 0 -> 56138 bytes lookups.c | 521 +++++++++ lookups.o | Bin 0 -> 46074 bytes macross | Bin 0 -> 491520 bytes macrossGlobals.h | 151 +++ macrossTables.o | Bin 0 -> 37062 bytes macrossTables_6502.c | 405 +++++++ macrossTables_68000.c | 608 ++++++++++ macrossTypes.h | 1070 +++++++++++++++++ macross_6502.y | 1202 +++++++++++++++++++ macross_68000.y | 1362 ++++++++++++++++++++++ main.c | 37 + main.o | Bin 0 -> 34054 bytes malloc.c | 331 ++++++ malloc.o | Bin 0 -> 5616 bytes notes68/1.am | 51 + notes68/2.amg | 45 + notes68/3.os | 60 + notes68/4.ic | 115 ++ object.c | 612 ++++++++++ object.o | Bin 0 -> 54217 bytes operandBody_6502.h | 59 + operandBody_68000.h | 81 ++ operandDefs_6502.h | 80 ++ operandDefs_68000.h | 279 +++++ operandStuffSD.o | Bin 0 -> 41461 bytes operandStuffSD_6502.c | 389 +++++++ operandStuffSD_68000.c | 559 +++++++++ opt/.mark | 1 + opt/Makefile | 165 +++ opt/Makefile_6502 | 162 +++ opt/Makefile_68000 | 162 +++ parserMisc.c | 128 ++ parserMisc.o | Bin 0 -> 37000 bytes semanticMisc.c | 1337 +++++++++++++++++++++ semanticMisc.o | Bin 0 -> 62907 bytes slinky/.mark | 1 + slinky/DOC | 8 + slinky/Makefile | 77 ++ slinky/builtins.c | 431 +++++++ slinky/builtins.o | Bin 0 -> 18402 bytes slinky/debugPrint.c | 124 ++ slinky/debugPrint.o | Bin 0 -> 10632 bytes slinky/errorStuff.c | 65 ++ slinky/errorStuff.o | Bin 0 -> 8982 bytes slinky/errorfyle | 15 + slinky/expr.c | 885 ++++++++++++++ slinky/expr.o | Bin 0 -> 29138 bytes slinky/initialize.c | 198 ++++ slinky/initialize.o | Bin 0 -> 12599 bytes slinky/instantiate.c | 317 +++++ slinky/instantiate.o | Bin 0 -> 14342 bytes slinky/link.c | 442 +++++++ slinky/link.o | Bin 0 -> 17169 bytes slinky/main.c | 28 + slinky/main.o | Bin 0 -> 7052 bytes slinky/map.c | 82 ++ slinky/map.o | Bin 0 -> 8770 bytes slinky/opt/.mark | 1 + slinky/opt/Makefile | 77 ++ slinky/poke.c | 193 +++ slinky/poke.o | Bin 0 -> 11536 bytes slinky/read.c | 529 +++++++++ slinky/read.o | Bin 0 -> 23468 bytes slinky/relocate.c | 348 ++++++ slinky/relocate.o | Bin 0 -> 16417 bytes slinky/slinky | Bin 0 -> 122880 bytes slinky/slinkyExpressions.h | 147 +++ slinky/slinkyGlobals.h | 49 + slinky/slinkyTables.c | 49 + slinky/slinkyTables.o | Bin 0 -> 5544 bytes slinky/slinkyTypes.h | 168 +++ slinky/write.c | 60 + slinky/write.o | Bin 0 -> 14686 bytes slinky/y.tab.h | 80 ++ slinkyExpressions.h | 147 +++ statementSemantics.c | 1532 ++++++++++++++++++++++++ statementSemantics.o | Bin 0 -> 95142 bytes structSemantics.c | 156 +++ structSemantics.o | Bin 0 -> 39212 bytes tokenStrings.o | Bin 0 -> 35534 bytes tokenStrings_6502.c | 138 +++ tokenStrings_68000.c | 160 +++ y.tab.c | 1698 +++++++++++++++++++++++++++ y.tab.h | 80 ++ y.tab.o | Bin 0 -> 71368 bytes 143 files changed, 36916 insertions(+) create mode 100644 .mark create mode 100644 DOC create mode 100644 Makefile create mode 100644 Makefile_6502 create mode 100644 Makefile_68000 create mode 100644 actions.o create mode 100644 actions_6502.c create mode 100644 actions_68000.c create mode 100644 buildStuff1.c create mode 100644 buildStuff1.o create mode 100644 buildStuff2.c create mode 100644 buildStuff2.o create mode 100644 buildStuff3.c create mode 100644 buildStuff3.o create mode 100644 builtInFunctions.c create mode 100644 builtInFunctions.o create mode 100644 builtInFunsSD.o create mode 100644 builtInFunsSD_6502.c create mode 100644 builtInFunsSD_68000.c create mode 100644 conditionDefs_6502.h create mode 100644 conditionDefs_68000.h create mode 100644 debugPrint.c create mode 100644 debugPrint.o create mode 100644 debugPrintSD.o create mode 100644 debugPrintSD_6502.c create mode 100644 debugPrintSD_68000.c create mode 100644 doc/genmacros.itr create mode 100644 doc/handyHelpfulHints.t create mode 100644 doc/linkerReleaseNotes create mode 100644 doc/macros.itr create mode 100644 doc/macross.1 create mode 100644 doc/slinky.1 create mode 100644 doc/writeup_6502.itr create mode 100644 doc/writeup_68000.itr create mode 100644 driver.c create mode 100644 emitBranch.o create mode 100644 emitBranch_6502.c create mode 100644 emitBranch_68000.c create mode 100644 emitStuff.c create mode 100644 emitStuff.o create mode 100644 encode.c create mode 100644 encode.o create mode 100644 errorStuff.c create mode 100644 errorStuff.o create mode 100644 errorfyle create mode 100644 expressionSemantics.c create mode 100644 expressionSemantics.o create mode 100644 fixups.c create mode 100644 fixups.o create mode 100644 garbage.c create mode 100644 garbage.o create mode 100644 initialize.c create mode 100644 initialize.o create mode 100644 lexer.c create mode 100644 lexer.o create mode 100644 lexerTables.h create mode 100644 listing.c create mode 100644 listing.o create mode 100644 lookups.c create mode 100644 lookups.o create mode 100755 macross create mode 100644 macrossGlobals.h create mode 100644 macrossTables.o create mode 100644 macrossTables_6502.c create mode 100644 macrossTables_68000.c create mode 100644 macrossTypes.h create mode 100644 macross_6502.y create mode 100644 macross_68000.y create mode 100644 main.c create mode 100644 main.o create mode 100644 malloc.c create mode 100644 malloc.o create mode 100644 notes68/1.am create mode 100644 notes68/2.amg create mode 100644 notes68/3.os create mode 100644 notes68/4.ic create mode 100644 object.c create mode 100644 object.o create mode 100644 operandBody_6502.h create mode 100644 operandBody_68000.h create mode 100644 operandDefs_6502.h create mode 100644 operandDefs_68000.h create mode 100644 operandStuffSD.o create mode 100644 operandStuffSD_6502.c create mode 100644 operandStuffSD_68000.c create mode 100644 opt/.mark create mode 100644 opt/Makefile create mode 100644 opt/Makefile_6502 create mode 100644 opt/Makefile_68000 create mode 100644 parserMisc.c create mode 100644 parserMisc.o create mode 100644 semanticMisc.c create mode 100644 semanticMisc.o create mode 100644 slinky/.mark create mode 100644 slinky/DOC create mode 100644 slinky/Makefile create mode 100644 slinky/builtins.c create mode 100644 slinky/builtins.o create mode 100644 slinky/debugPrint.c create mode 100644 slinky/debugPrint.o create mode 100644 slinky/errorStuff.c create mode 100644 slinky/errorStuff.o create mode 100644 slinky/errorfyle create mode 100644 slinky/expr.c create mode 100644 slinky/expr.o create mode 100644 slinky/initialize.c create mode 100644 slinky/initialize.o create mode 100644 slinky/instantiate.c create mode 100644 slinky/instantiate.o create mode 100644 slinky/link.c create mode 100644 slinky/link.o create mode 100644 slinky/main.c create mode 100644 slinky/main.o create mode 100644 slinky/map.c create mode 100644 slinky/map.o create mode 100644 slinky/opt/.mark create mode 100644 slinky/opt/Makefile create mode 100644 slinky/poke.c create mode 100644 slinky/poke.o create mode 100644 slinky/read.c create mode 100644 slinky/read.o create mode 100644 slinky/relocate.c create mode 100644 slinky/relocate.o create mode 100755 slinky/slinky create mode 100644 slinky/slinkyExpressions.h create mode 100644 slinky/slinkyGlobals.h create mode 100644 slinky/slinkyTables.c create mode 100644 slinky/slinkyTables.o create mode 100644 slinky/slinkyTypes.h create mode 100644 slinky/write.c create mode 100644 slinky/write.o create mode 100644 slinky/y.tab.h create mode 100644 slinkyExpressions.h create mode 100644 statementSemantics.c create mode 100644 statementSemantics.o create mode 100644 structSemantics.c create mode 100644 structSemantics.o create mode 100644 tokenStrings.o create mode 100644 tokenStrings_6502.c create mode 100644 tokenStrings_68000.c create mode 100644 y.tab.c create mode 100644 y.tab.h create mode 100644 y.tab.o diff --git a/.mark b/.mark new file mode 100644 index 0000000..3fc6e21 --- /dev/null +++ b/.mark @@ -0,0 +1 @@ +Mon Feb 2 23:18:33 PST 1987 diff --git a/DOC b/DOC new file mode 100644 index 0000000..9bdf982 --- /dev/null +++ b/DOC @@ -0,0 +1,34 @@ +/u0/chip/macross: + This directory contains the source to Macross. Here's what's here: + +DOC - this file + +Makefile - current makefile +Makefile_6502 - makefile for 6502 version +Makefile_68000 - makefile for 68000 + + There are both 6502 and 68000 versions of Macross, though the 68000 +version has not been very well tested. Source for both is here. Source files +which come in different flavors for the different versions are marked 6502 or +68000 in their names as appropriate. There are two different Makefiles also. +At any given time, either the 6502 version or the 68000 version is the +'working' version. The 'working' version is what the default makefile +'Makefile' will produce. Typing 'make foobar' will change the working version +by swapping the makefiles. + +*.c, *.h, *.y - source for the program + +doc/ - the manual and other user documentation are here +notes68/ - notes on 68000 syntax and operand structure +opt/ - working directory for 'optimized' version. When I + was developing the program, I needed to keep two separate copies of + the source and object code. This is because the C compiler can + compile with debugging or with optimization, but not both. The + version that folks use needs to be compiled with optimization, but I + need a version with debugging to fix any problems that crop up. Since + the time to recompile the whole thing is so enormous, it was easiest + to keep two copies. In the interest of saving file space, all that is + in this directory now, however, are the Makefiles for compiling with + optimization. + +slinky/ - Slinky lives here diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..84fcd09 --- /dev/null +++ b/Makefile @@ -0,0 +1,164 @@ +.SUFFIXES: .o .c .h .run + +# to make for another target CPU, redefine PROC to the name of the target +# processor, e.g., 68000 +PROC =6502 + +OBJECTS = y.tab.o actions.o buildStuff1.o buildStuff2.o\ +buildStuff3.o builtInFunctions.o builtInFunsSD.o debugPrint.o debugPrintSD.o\ +emitBranch.o emitStuff.o encode.o errorStuff.o expressionSemantics.o fixups.o\ +garbage.o initialize.o lexer.o listing.o lookups.o macrossTables.o main.o\ +malloc.o object.o operandStuffSD.o parserMisc.o semanticMisc.o\ +statementSemantics.o structSemantics.o tokenStrings.o + +SOURCES = macross_$(PROC).y actions_$(PROC).c buildStuff1.c buildStuff2.c\ +buildStuff3.c builtInFunctions.c builtInFunsSD_$(PROC).c debugPrint.c\ +debugPrintSD_$(PROC).c emitBranch_$(PROC).c emitStuff.c encode.c errorStuff.c\ +expressionSemantics.c fixups.c garbage.c initialize.c lexer.c listing.c\ +lookups.c macrossTables_$(PROC).c main.c malloc.c object.c\ +operandStuffSD_$(PROC).c parserMisc.c semanticMisc.c statementSemantics.c\ +structSemantics.c tokenStrings_$(PROC).c lexerTables.h macrossGlobals.h\ +macrossTypes.h operandDefs_$(PROC).h operandBody_$(PROC).h\ +conditionDefs_$(PROC).h driver.c slinkyExpressions.h + +HEADERS = macrossTypes.h macrossGlobals.h + +.c.o: + cc -c -g -DTARGET_CPU=CPU_$(PROC) $*.c + +.c.run: + cc -o $* $*.c + +macross: $(OBJECTS) + cc -g -o macross $(OBJECTS) + +driver: driver.c + cc -o driver driver.c + +update: .mark + kessel "(cd /u0/chip/macross; make macross >&errorfyle)" & + +install: macross + cp macross /u1/gg/bin/macross_tmp + strip /u1/gg/bin/macross_tmp + mv /u1/gg/bin/macross_$(PROC) /u1/gg/bin/macross_$(PROC).old + mv /u1/gg/bin/macross_tmp /u1/gg/bin/macross_$(PROC) + cp /u1/gg/bin/macross_$(PROC) /net/mycroft/u1/gg/bin + cp /u1/gg/bin/macross_$(PROC) /net/shem/u1/gg/bin + cp /u1/gg/bin/macross_$(PROC) /net/weyr/u1/gg/bin + +dinstall: driver + cp driver /u1/gg/bin/driver_tmp + strip /u1/gg/bin/driver_tmp + mv /u1/gg/bin/driver_tmp /u1/gg/bin/driver/macross + cp /u1/gg/bin/driver /net/mycroft/u1/gg/bin/macross + cp /u1/gg/bin/driver /net/shem/u1/gg/bin/macross + cp /u1/gg/bin/driver /net/weyr/u1/gg/bin/macross + +change: + rm *.o + rm *.tab.* + cp Makefile_68000 Makefile + +move: .mark + +.mark: $(SOURCES) + cp $? /net/kessel/u0/chip/macross + cp $? /net/kessel/u0/chip/macross/prof + cp $? opt + date >.mark + date >/net/kessel/u0/chip/macross/.mark + date >/net/kessel/u0/chip/macross/prof/.mark + date >opt/.mark + +macrossTypes.h: macrossTypes.h operandDefs_$(PROC).h operandBody_$(PROC).h\ +conditionDefs_$(PROC).h + +actions.o: actions_$(PROC).c $(HEADERS) + cc -c -g -DTARGET_CPU=CPU_$(PROC) actions_$(PROC).c + mv actions_$(PROC).o actions.o + +buildStuff1.o: buildStuff1.c $(HEADERS) + +buildStuff2.o: buildStuff2.c $(HEADERS) + +buildStuff3.o: buildStuff3.c $(HEADERS) + +builtInFunctions.o: builtInFunctions.c $(HEADERS) + +builtInFunsSD.o: builtInFunsSD_$(PROC).c $(HEADERS) + cc -c -g -DTARGET_CPU=CPU_$(PROC) builtInFunsSD_$(PROC).c + mv builtInFunsSD_$(PROC).o builtInFunsSD.o + +debugPrint.o: debugPrint.c y.tab.h $(HEADERS) + +debugPrintSD.o: debugPrintSD_$(PROC).c y.tab.h $(HEADERS) + cc -c -g -DTARGET_CPU=CPU_$(PROC) debugPrintSD_$(PROC).c + mv debugPrintSD_$(PROC).o debugPrintSD.o + +emitBranch.o: emitBranch_$(PROC).c $(HEADERS) + cc -c -g -DTARGET_CPU=CPU_$(PROC) emitBranch_$(PROC).c + mv emitBranch_$(PROC).o emitBranch.o + +emitStuff.o: emitStuff.c $(HEADERS) + cc -c -g -DBYTESWAPPED -DTARGET_CPU=CPU_$(PROC) emitStuff.c + +encode.o: encode.c $(HEADERS) + +errorStuff.o: errorStuff.c $(HEADERS) + +expressionSemantics.o: expressionSemantics.c y.tab.h $(HEADERS) + +fixups.o: fixups.c $(HEADERS) + +garbage.o: garbage.c y.tab.h $(HEADERS) + +initialize.o: initialize.c $(HEADERS) + +lexer.o: lexer.c lexerTables.h y.tab.h $(HEADERS) + +listing.o: listing.c $(HEADERS) + +lookups.o: lookups.c $(HEADERS) + +macrossTables.o: macrossTables_$(PROC).c y.tab.h macrossTypes.h + cc -c -g -DTARGET_CPU=CPU_$(PROC) macrossTables_$(PROC).c + mv macrossTables_$(PROC).o macrossTables.o + +malloc.o: malloc.c + +main.o: main.c $(HEADERS) + +object.o: object.c $(HEADERS) + +operandStuffSD.o: operandStuffSD_$(PROC).c $(HEADERS) + cc -c -g -DTARGET_CPU=CPU_$(PROC) operandStuffSD_$(PROC).c + mv operandStuffSD_$(PROC).o operandStuffSD.o + +parserMisc.o: parserMisc.c y.tab.h $(HEADERS) + +semanticMisc.o: semanticMisc.c $(HEADERS) + +statementSemantics.o: statementSemantics.c $(HEADERS) + +structSemantics.o: structSemantics.c $(HEADERS) + +tokenStrings.o: tokenStrings_$(PROC).c $(HEADERS) + cc -c -g -DTARGET_CPU=CPU_$(PROC) tokenStrings_$(PROC).c + mv tokenStrings_$(PROC).o tokenStrings.o + +y.tab.o: y.tab.c $(HEADERS) + cc -c -g -DYYDEBUG -DTARGET_CPU=CPU_$(PROC) y.tab.c + +y.tab.c y.tab.h: macross_$(PROC).y + yacc -d macross_$(PROC).y + +y.output: macross_$(PROC).y + yacc -vd macross_$(PROC).y + +cleanup: + /bin/rm -f *.o y.output y.tab.c y.tab.h macross + +love: + @echo "Not war?" + diff --git a/Makefile_6502 b/Makefile_6502 new file mode 100644 index 0000000..5891e6f --- /dev/null +++ b/Makefile_6502 @@ -0,0 +1,162 @@ +.SUFFIXES: .o .c .h .run + +# to make for another target CPU, redefine PROC to the name of the target +# processor, e.g., 68000 +PROC =6502 + +OBJECTS = y.tab.o actions.o buildStuff1.o buildStuff2.o\ +buildStuff3.o builtInFunctions.o builtInFunsSD.o debugPrint.o debugPrintSD.o\ +emitBranch.o emitStuff.o errorStuff.o expressionSemantics.o fixups.o\ +garbage.o initialize.o lexer.o listing.o lookups.o macrossTables.o main.o\ +malloc.o object.o operandStuffSD.o parserMisc.o semanticMisc.o\ +statementSemantics.o structSemantics.o tokenStrings.o + +SOURCES = macross_$(PROC).y actions_$(PROC).c buildStuff1.c buildStuff2.c\ +buildStuff3.c builtInFunctions.c builtInFunsSD_$(PROC).c debugPrint.c\ +debugPrintSD_$(PROC).c emitBranch_$(PROC).c emitStuff.c errorStuff.c\ +expressionSemantics.c fixups.c garbage.c initialize.c lexer.c listing.c\ +lookups.c macrossTables_$(PROC).c main.c malloc.c object.c\ +operandStuffSD_$(PROC).c parserMisc.c semanticMisc.c statementSemantics.c\ +structSemantics.c tokenStrings_$(PROC).c lexerTables.h macrossGlobals.h\ +macrossTypes.h operandDefs_$(PROC).h operandBody_$(PROC).h\ +conditionDefs_$(PROC).h driver.c + +HEADERS = macrossTypes.h macrossGlobals.h + +.c.o: + cc -c -g -DTARGET_CPU=CPU_$(PROC) $*.c + +.c.run: + cc -o $* $*.c + +macross: $(OBJECTS) + cc -g -o macross $(OBJECTS) + +driver: driver.c + cc -o driver driver.c + +update: .mark + kessel "(cd /u0/chip/macross; make macross >&errorfyle)" & + +install: macross + cp macross /u1/gg/bin/macross_tmp + strip /u1/gg/bin/macross_tmp + mv /u1/gg/bin/macross_$(PROC) /u1/gg/bin/macross_$(PROC).old + mv /u1/gg/bin/macross_tmp /u1/gg/bin/macross_$(PROC) + cp /u1/gg/bin/macross_$(PROC) /net/mycroft/u1/gg/bin + cp /u1/gg/bin/macross_$(PROC) /net/shem/u1/gg/bin + cp /u1/gg/bin/macross_$(PROC) /net/weyr/u1/gg/bin + +dinstall: driver + cp driver /u1/gg/bin/driver_tmp + strip /u1/gg/bin/driver_tmp + mv /u1/gg/bin/driver_tmp /u1/gg/bin/driver/macross + cp /u1/gg/bin/driver /net/mycroft/u1/gg/bin/macross + cp /u1/gg/bin/driver /net/shem/u1/gg/bin/macross + cp /u1/gg/bin/driver /net/weyr/u1/gg/bin/macross + +change: + rm *.o + rm *.tab.* + cp Makefile_68000 Makefile + +move: .mark + +.mark: $(SOURCES) + cp $? /net/kessel/u0/chip/macross + cp $? /net/kessel/u0/chip/macross/prof + cp $? opt + date >.mark + date >/net/kessel/u0/chip/macross/.mark + date >/net/kessel/u0/chip/macross/prof/.mark + date >opt/.mark + +macrossTypes.h: macrossTypes.h operandDefs_$(PROC).h operandBody_$(PROC).h\ +conditionDefs_$(PROC).h + +actions.o: actions_$(PROC).c $(HEADERS) + cc -c -g -DTARGET_CPU=CPU_$(PROC) actions_$(PROC).c + mv actions_$(PROC).o actions.o + +buildStuff1.o: buildStuff1.c $(HEADERS) + +buildStuff2.o: buildStuff2.c $(HEADERS) + +buildStuff3.o: buildStuff3.c $(HEADERS) + +builtInFunctions.o: builtInFunctions.c $(HEADERS) + +builtInFunsSD.o: builtInFunsSD_$(PROC).c $(HEADERS) + cc -c -g -DTARGET_CPU=CPU_$(PROC) builtInFunsSD_$(PROC).c + mv builtInFunsSD_$(PROC).o builtInFunsSD.o + +debugPrint.o: debugPrint.c y.tab.h $(HEADERS) + +debugPrintSD.o: debugPrintSD_$(PROC).c y.tab.h $(HEADERS) + cc -c -g -DTARGET_CPU=CPU_$(PROC) debugPrintSD_$(PROC).c + mv debugPrintSD_$(PROC).o debugPrintSD.o + +emitBranch.o: emitBranch_$(PROC).c $(HEADERS) + cc -c -g -DTARGET_CPU=CPU_$(PROC) emitBranch_$(PROC).c + mv emitBranch_$(PROC).o emitBranch.o + +emitStuff.o: emitStuff.c $(HEADERS) + cc -c -g -DBYTESWAPPED -DTARGET_CPU=CPU_$(PROC) emitStuff.c + +errorStuff.o: errorStuff.c $(HEADERS) + +expressionSemantics.o: expressionSemantics.c y.tab.h $(HEADERS) + +fixups.o: fixups.c $(HEADERS) + +garbage.o: garbage.c y.tab.h $(HEADERS) + +initialize.o: initialize.c $(HEADERS) + +lexer.o: lexer.c lexerTables.h y.tab.h $(HEADERS) + +listing.o: listing.c $(HEADERS) + +lookups.o: lookups.c $(HEADERS) + +macrossTables.o: macrossTables_$(PROC).c y.tab.h macrossTypes.h + cc -c -g -DTARGET_CPU=CPU_$(PROC) macrossTables_$(PROC).c + mv macrossTables_$(PROC).o macrossTables.o + +malloc.o: malloc.c + +main.o: main.c $(HEADERS) + +object.o: object.c $(HEADERS) + +operandStuffSD.o: operandStuffSD_$(PROC).c $(HEADERS) + cc -c -g -DTARGET_CPU=CPU_$(PROC) operandStuffSD_$(PROC).c + mv operandStuffSD_$(PROC).o operandStuffSD.o + +parserMisc.o: parserMisc.c y.tab.h $(HEADERS) + +semanticMisc.o: semanticMisc.c $(HEADERS) + +statementSemantics.o: statementSemantics.c $(HEADERS) + +structSemantics.o: structSemantics.c $(HEADERS) + +tokenStrings.o: tokenStrings_$(PROC).c $(HEADERS) + cc -c -g -DTARGET_CPU=CPU_$(PROC) tokenStrings_$(PROC).c + mv tokenStrings_$(PROC).o tokenStrings.o + +y.tab.o: y.tab.c $(HEADERS) + cc -c -g -DYYDEBUG -DTARGET_CPU=CPU_$(PROC) y.tab.c + +y.tab.c y.tab.h: macross_$(PROC).y + yacc -d macross_$(PROC).y + +y.output: macross_$(PROC).y + yacc -vd macross_$(PROC).y + +cleanup: + /bin/rm -f *.o y.output y.tab.c y.tab.h macross + +love: + @echo "Not war?" + diff --git a/Makefile_68000 b/Makefile_68000 new file mode 100644 index 0000000..70e8b63 --- /dev/null +++ b/Makefile_68000 @@ -0,0 +1,162 @@ +.SUFFIXES: .o .c .h .run + +# to make for another target CPU, redefine PROC to the name of the target +# processor, e.g., 68000 +PROC =68000 + +OBJECTS = y.tab.o actions.o buildStuff1.o buildStuff2.o\ +buildStuff3.o builtInFunctions.o builtInFunsSD.o debugPrint.o debugPrintSD.o\ +emitBranch.o emitStuff.o errorStuff.o expressionSemantics.o fixups.o\ +garbage.o initialize.o lexer.o listing.o lookups.o macrossTables.o main.o\ +malloc.o object.o operandStuffSD.o parserMisc.o semanticMisc.o\ +statementSemantics.o structSemantics.o tokenStrings.o + +SOURCES = macross_$(PROC).y actions_$(PROC).c buildStuff1.c buildStuff2.c\ +buildStuff3.c builtInFunctions.c builtInFunsSD_$(PROC).c debugPrint.c\ +debugPrintSD_$(PROC).c emitBranch_$(PROC).c emitStuff.c errorStuff.c\ +expressionSemantics.c fixups.c garbage.c initialize.c lexer.c listing.c\ +lookups.c macrossTables_$(PROC).c main.c malloc.c object.c\ +operandStuffSD_$(PROC).c parserMisc.c semanticMisc.c statementSemantics.c\ +structSemantics.c tokenStrings_$(PROC).c lexerTables.h macrossGlobals.h\ +macrossTypes.h operandDefs_$(PROC).h operandBody_$(PROC).h\ +conditionDefs_$(PROC).h driver.c + +HEADERS = macrossTypes.h macrossGlobals.h + +.c.o: + cc -c -g -DTARGET_CPU=CPU_$(PROC) $*.c + +.c.run: + cc -o $* $*.c + +macross: $(OBJECTS) + cc -g -o macross $(OBJECTS) + +driver: driver.c + cc -o driver driver.c + +update: .mark + kessel "(cd /u0/chip/macross; make macross >&errorfyle)" & + +install: macross + cp macross /u1/gg/bin/macross_tmp + strip /u1/gg/bin/macross_tmp + mv /u1/gg/bin/macross_$(PROC) /u1/gg/bin/macross_$(PROC).old + mv /u1/gg/bin/macross_tmp /u1/gg/bin/macross_$(PROC) + cp /u1/gg/bin/macross_$(PROC) /net/mycroft/u1/gg/bin + cp /u1/gg/bin/macross_$(PROC) /net/shem/u1/gg/bin + cp /u1/gg/bin/macross_$(PROC) /net/weyr/u1/gg/bin + +dinstall: driver + cp driver /u1/gg/bin/driver_tmp + strip /u1/gg/bin/driver_tmp + mv /u1/gg/bin/driver_tmp /u1/gg/bin/driver/macross + cp /u1/gg/bin/driver /net/mycroft/u1/gg/bin/macross + cp /u1/gg/bin/driver /net/shem/u1/gg/bin/macross + cp /u1/gg/bin/driver /net/weyr/u1/gg/bin/macross + +change: + rm *.o + rm *.tab.* + cp Makefile_6502 Makefile + +move: .mark + +.mark: $(SOURCES) + cp $? /net/kessel/u0/chip/macross + cp $? /net/kessel/u0/chip/macross/prof + cp $? opt + date >.mark + date >/net/kessel/u0/chip/macross/.mark + date >/net/kessel/u0/chip/macross/prof/.mark + date >opt/.mark + +macrossTypes.h: macrossTypes.h operandDefs_$(PROC).h operandBody_$(PROC).h\ +conditionDefs_$(PROC).h + +actions.o: actions_$(PROC).c $(HEADERS) + cc -c -g -DTARGET_CPU=CPU_$(PROC) actions_$(PROC).c + mv actions_$(PROC).o actions.o + +buildStuff1.o: buildStuff1.c $(HEADERS) + +buildStuff2.o: buildStuff2.c $(HEADERS) + +buildStuff3.o: buildStuff3.c $(HEADERS) + +builtInFunctions.o: builtInFunctions.c $(HEADERS) + +builtInFunsSD.o: builtInFunsSD_$(PROC).c $(HEADERS) + cc -c -g -DTARGET_CPU=CPU_$(PROC) builtInFunsSD_$(PROC).c + mv builtInFunsSD_$(PROC).o builtInFunsSD.o + +debugPrint.o: debugPrint.c y.tab.h $(HEADERS) + +debugPrintSD.o: debugPrintSD_$(PROC).c y.tab.h $(HEADERS) + cc -c -g -DTARGET_CPU=CPU_$(PROC) debugPrintSD_$(PROC).c + mv debugPrintSD_$(PROC).o debugPrintSD.o + +emitBranch.o: emitBranch_$(PROC).c $(HEADERS) + cc -c -g -DTARGET_CPU=CPU_$(PROC) emitBranch_$(PROC).c + mv emitBranch_$(PROC).o emitBranch.o + +emitStuff.o: emitStuff.c $(HEADERS) + cc -c -g -DBYTESWAPPED -DTARGET_CPU=CPU_$(PROC) emitStuff.c + +errorStuff.o: errorStuff.c $(HEADERS) + +expressionSemantics.o: expressionSemantics.c y.tab.h $(HEADERS) + +fixups.o: fixups.c $(HEADERS) + +garbage.o: garbage.c y.tab.h $(HEADERS) + +initialize.o: initialize.c $(HEADERS) + +lexer.o: lexer.c lexerTables.h y.tab.h $(HEADERS) + +listing.o: listing.c $(HEADERS) + +lookups.o: lookups.c $(HEADERS) + +macrossTables.o: macrossTables_$(PROC).c y.tab.h macrossTypes.h + cc -c -g -DTARGET_CPU=CPU_$(PROC) macrossTables_$(PROC).c + mv macrossTables_$(PROC).o macrossTables.o + +malloc.o: malloc.c + +main.o: main.c $(HEADERS) + +object.o: object.c $(HEADERS) + +operandStuffSD.o: operandStuffSD_$(PROC).c $(HEADERS) + cc -c -g -DTARGET_CPU=CPU_$(PROC) operandStuffSD_$(PROC).c + mv operandStuffSD_$(PROC).o operandStuffSD.o + +parserMisc.o: parserMisc.c y.tab.h $(HEADERS) + +semanticMisc.o: semanticMisc.c $(HEADERS) + +statementSemantics.o: statementSemantics.c $(HEADERS) + +structSemantics.o: structSemantics.c $(HEADERS) + +tokenStrings.o: tokenStrings_$(PROC).c $(HEADERS) + cc -c -g -DTARGET_CPU=CPU_$(PROC) tokenStrings_$(PROC).c + mv tokenStrings_$(PROC).o tokenStrings.o + +y.tab.o: y.tab.c $(HEADERS) + cc -c -g -DYYDEBUG -DTARGET_CPU=CPU_$(PROC) y.tab.c + +y.tab.c y.tab.h: macross_$(PROC).y + yacc -d macross_$(PROC).y + +y.output: macross_$(PROC).y + yacc -vd macross_$(PROC).y + +cleanup: + /bin/rm -f *.o y.output y.tab.c y.tab.h macross + +love: + @echo "Not war?" + diff --git a/actions.o b/actions.o new file mode 100644 index 0000000000000000000000000000000000000000..2f3d20126621cd706fb58c65e065891b721b4c02 GIT binary patch literal 47534 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 UP-Ro;HcaJI_v>)cyjvalue +#define class (evaluatedOperands[0])->addressMode +#define binary opcode->opcode + +/* + These routines are vectored off of the opcode lookup table. Each + instruction is of a particular category that defines which address modes + it accepts its operands in and what size (one byte or two) the operands + are. There is one "actionsXXXX" routine for each of these categories that + grabs the operand, checks the address mode, and emits the binary opcode + and operand. + */ + + void +actionsDir1(opcode, numberOfOperands, evaluatedOperands) + opcodeTableEntryType *opcode; + int numberOfOperands; + valueType *evaluatedOperands[]; +{ +#define ZERO_PAGE_ADDRESS_BIT 0x00 +#define NON_ZERO_PAGE_ADDRESS_BIT 0x08 + + if(class==EXPRESSION_OPND && isByteAddress(operand) && + isDefined(operand)){ + emitByte(binary | ZERO_PAGE_ADDRESS_BIT); + emitByte(address); + } else if (wordCheck(address)) { + emitByte(binary | NON_ZERO_PAGE_ADDRESS_BIT); + putFixupsHere(WORD_FIXUP, 0); + emitWord(address); + } +} + + void +actionsDir2(opcode, numberOfOperands, evaluatedOperands) + opcodeTableEntryType *opcode; + int numberOfOperands; + valueType *evaluatedOperands[]; +{ + if (wordCheck(address)) { + emitByte(binary); + putFixupsHere(WORD_FIXUP, 0); + emitWord(address); + } +} + + void +actionsDirIndir(opcode, numberOfOperands, evaluatedOperands) + opcodeTableEntryType *opcode; + int numberOfOperands; + valueType *evaluatedOperands[]; +{ +#define DIRECT_ADDRESS_BIT 0x00 +#define INDIRECT_ADDRESS_BIT 0x20 + + if (wordCheck(address)) { + if (class == INDIRECT_OPND) + emitByte(binary | INDIRECT_ADDRESS_BIT); + else + emitByte(binary | DIRECT_ADDRESS_BIT); + putFixupsHere(WORD_FIXUP, 0); + emitWord(address); + } +} + + void +actionsDirX1(opcode, numberOfOperands, evaluatedOperands) + opcodeTableEntryType *opcode; + int numberOfOperands; + valueType *evaluatedOperands[]; +{ +#define DIRECT_ADDRESS_ZERO_PAGE_BITS_X1 0x04 +#define A_REGISTER_BITS_X1 0x08 +#define DIRECT_ADDRESS_NON_ZERO_PAGE_BITS_X1 0x0C +#define X_INDEXED_ZERO_PAGE_BITS_X1 0x14 +#define X_INDEXED_NON_ZERO_PAGE_BITS_X1 0x1C + + if (class == EXPRESSION_OPND) { + if (isByteAddress(operand) && isDefined(operand)) { + emitByte(binary | DIRECT_ADDRESS_ZERO_PAGE_BITS_X1); + emitByte(address); + } else if (wordCheck(address)) { + emitByte(binary|DIRECT_ADDRESS_NON_ZERO_PAGE_BITS_X1); + putFixupsHere(WORD_FIXUP, 0); + emitWord(address); + } + } else if (class==X_INDEXED_OPND || class==X_SELECTED_OPND) { + if (isByteAddress(operand) && isDefined(operand)) { + emitByte(binary | X_INDEXED_ZERO_PAGE_BITS_X1); + emitByte(address); + } else if (wordCheck(address)) { + emitByte(binary | X_INDEXED_NON_ZERO_PAGE_BITS_X1); + putFixupsHere(WORD_FIXUP, 0); + emitWord(address); + } + } else { + emitByte(binary | A_REGISTER_BITS_X1); + } +} + + void +actionsDirX2(opcode, numberOfOperands, evaluatedOperands) + opcodeTableEntryType *opcode; + int numberOfOperands; + valueType *evaluatedOperands[]; +{ +#define DIRECT_ADDRESS_ZERO_PAGE_BITS_X2 0x00 +#define DIRECT_ADDRESS_NON_ZERO_PAGE_BITS_X2 0x08 +#define X_INDEXED_ZERO_PAGE_BITS_X2 0x10 +#define X_INDEXED_NON_ZERO_PAGE_BITS_X2 0x18 + + if (class == EXPRESSION_OPND) { + if (isByteAddress(operand) && isDefined(operand)) { + emitByte(binary | DIRECT_ADDRESS_ZERO_PAGE_BITS_X2); + emitByte(address); + } else if (wordCheck(address)) { + emitByte(binary|DIRECT_ADDRESS_NON_ZERO_PAGE_BITS_X2); + putFixupsHere(WORD_FIXUP, 0); + emitWord(address); + } + } else { + if (isByteAddress(operand) && isDefined(operand)) { + emitByte(binary | X_INDEXED_ZERO_PAGE_BITS_X2); + emitByte(address); + } else if (wordCheck(address)) { + emitByte(binary | X_INDEXED_NON_ZERO_PAGE_BITS_X2); + putFixupsHere(WORD_FIXUP, 0); + emitWord(address); + } + } +} + + void +actionsDirX3(opcode, numberOfOperands, evaluatedOperands) + opcodeTableEntryType *opcode; + int numberOfOperands; + valueType *evaluatedOperands[]; +{ + if (class == EXPRESSION_OPND) { + if (isByteAddress(operand) && isDefined(operand)) { + emitByte(binary | DIRECT_ADDRESS_ZERO_PAGE_BITS_X2); + emitByte(address); + } else if (wordCheck(address)) { + emitByte(binary|DIRECT_ADDRESS_NON_ZERO_PAGE_BITS_X2); + putFixupsHere(WORD_FIXUP, 0); + emitWord(address); + } + } else { + if (byteCheck(address)) { + emitByte(binary | X_INDEXED_ZERO_PAGE_BITS_X2); + putFixupsHere(BYTE_FIXUP, 0); + emitByte(address); + } + } +} + + void +actionsDirY(opcode, numberOfOperands, evaluatedOperands) + opcodeTableEntryType *opcode; + int numberOfOperands; + valueType *evaluatedOperands[]; +{ +#define DIRECT_ADDRESS_ZERO_PAGE_BITS_Y 0x00 +#define DIRECT_ADDRESS_NON_ZERO_PAGE_BITS_Y 0x08 +#define Y_INDEXED_ZERO_PAGE_BITS_Y 0x10 + + if (class == EXPRESSION_OPND) { + if (isByteAddress(operand) && isDefined(operand)) { + emitByte(binary | DIRECT_ADDRESS_ZERO_PAGE_BITS_Y); + emitByte(address); + } else if (wordCheck(address)) { + emitByte(binary|DIRECT_ADDRESS_NON_ZERO_PAGE_BITS_Y); + putFixupsHere(WORD_FIXUP, 0); + emitWord(address); + } + } else { + if (byteCheck(address)) { + emitByte(binary | Y_INDEXED_ZERO_PAGE_BITS_Y); + putFixupsHere(BYTE_FIXUP, 0); + emitByte(address); + } + } +} + + void +actionsImmDir(opcode, numberOfOperands, evaluatedOperands) + opcodeTableEntryType *opcode; + int numberOfOperands; + valueType *evaluatedOperands[]; +{ +#define IMMEDIATE_DATA_BITS_ID 0x00 +#define DIRECT_ADDRESS_ZERO_PAGE_BITS_ID 0x04 +#define DIRECT_ADDRESS_NON_ZERO_PAGE_BITS_ID 0x0C + + if (class == IMMEDIATE_OPND) { + if (byteCheck(address)) { + emitByte(binary | IMMEDIATE_DATA_BITS_ID); + putFixupsHere(BYTE_FIXUP, 0); + emitByte(address); + } + } else { + if (isByteAddress(operand) && isDefined(operand)) { + emitByte(binary | DIRECT_ADDRESS_ZERO_PAGE_BITS_ID); + emitByte(address); + } else if (wordCheck(address)) { + emitByte(binary|DIRECT_ADDRESS_NON_ZERO_PAGE_BITS_ID); + putFixupsHere(WORD_FIXUP, 0); + emitWord(address); + } + } +} + + void +actionsImmDirX(opcode, numberOfOperands, evaluatedOperands) + opcodeTableEntryType *opcode; + int numberOfOperands; + valueType *evaluatedOperands[]; +{ +#define IMMEDIATE_DATA_BITS_IX 0x00 +#define DIRECT_ADDRESS_ZERO_PAGE_BITS_IX 0x04 +#define DIRECT_ADDRESS_NON_ZERO_PAGE_BITS_IX 0x0C +#define X_INDEXED_ZERO_PAGE_BITS_IX 0x14 +#define X_INDEXED_NON_ZERO_PAGE_BITS_IX 0x1C + + if (class == IMMEDIATE_OPND) { + if (byteCheck(address)) { + emitByte(binary | IMMEDIATE_DATA_BITS_IX); + putFixupsHere(BYTE_FIXUP, 0); + emitByte(address); + } + } else if (class == EXPRESSION_OPND) { + if (isByteAddress(operand) && isDefined(operand)) { + emitByte(binary | DIRECT_ADDRESS_ZERO_PAGE_BITS_IX); + emitByte(address); + } else if (wordCheck(address)) { + emitByte(binary|DIRECT_ADDRESS_NON_ZERO_PAGE_BITS_IX); + putFixupsHere(WORD_FIXUP, 0); + emitWord(address); + } + } else { + if (isByteAddress(operand) && isDefined(operand)) { + emitByte(binary | X_INDEXED_ZERO_PAGE_BITS_IX); + emitByte(address); + } else if (wordCheck(address)) { + emitByte(binary | X_INDEXED_NON_ZERO_PAGE_BITS_IX); + putFixupsHere(WORD_FIXUP, 0); + emitWord(address); + } + } +} + + void +actionsImmDirY(opcode, numberOfOperands, evaluatedOperands) + opcodeTableEntryType *opcode; + int numberOfOperands; + valueType *evaluatedOperands[]; +{ +#define IMMEDIATE_DATA_BITS_IY 0x00 +#define DIRECT_ADDRESS_ZERO_PAGE_BITS_IY 0x04 +#define DIRECT_ADDRESS_NON_ZERO_PAGE_BITS_IY 0x0C +#define Y_INDEXED_ZERO_PAGE_BITS_IY 0x14 +#define Y_INDEXED_NON_ZERO_PAGE_BITS_IY 0x1C + + if (class == IMMEDIATE_OPND) { + if (byteCheck(address)) { + emitByte(binary | IMMEDIATE_DATA_BITS_IY); + putFixupsHere(BYTE_FIXUP, 0); + emitByte(address); + } + } else if (class == EXPRESSION_OPND) { + if (isByteAddress(operand) && isDefined(operand)) { + emitByte(binary | DIRECT_ADDRESS_ZERO_PAGE_BITS_IY); + emitByte(address); + } else if (wordCheck(address)) { + emitByte(binary|DIRECT_ADDRESS_NON_ZERO_PAGE_BITS_IY); + putFixupsHere(WORD_FIXUP, 0); + emitWord(address); + } + } else { + if (isByteAddress(operand) && isDefined(operand)) { + emitByte(binary | Y_INDEXED_ZERO_PAGE_BITS_IY); + emitByte(address); + } else if (wordCheck(address)) { + emitByte(binary | Y_INDEXED_NON_ZERO_PAGE_BITS_IY); + putFixupsHere(WORD_FIXUP, 0); + emitWord(address); + } + } +} + + void +actionsImmIndex(opcode, numberOfOperands, evaluatedOperands) + opcodeTableEntryType *opcode; + int numberOfOperands; + valueType *evaluatedOperands[]; +{ +#define PRE_INDEXED_BITS_A 0x00 +#define DIRECT_ADDRESS_ZERO_PAGE_BITS_A 0x04 +#define IMMEDIATE_DATA_BITS_A 0x08 +#define DIRECT_ADDRESS_NON_ZERO_PAGE_BITS_A 0x0C +#define POST_INDEXED_BITS_A 0x10 +#define X_INDEXED_ZERO_PAGE_BITS_A 0x14 +#define Y_INDEXED_NON_ZERO_PAGE_BITS_A 0x18 +#define X_INDEXED_NON_ZERO_PAGE_BITS_A 0x1C + + if (class == EXPRESSION_OPND) { + if (isByteAddress(operand) && isDefined(operand)) { + emitByte(binary | DIRECT_ADDRESS_ZERO_PAGE_BITS_A); + emitByte(address); + } else if (wordCheck(address)) { + emitByte(binary |DIRECT_ADDRESS_NON_ZERO_PAGE_BITS_A); + putFixupsHere(WORD_FIXUP, 0); + emitWord(address); + } + } else if (class==X_INDEXED_OPND || class==X_SELECTED_OPND) { + if (isByteAddress(operand) && isDefined(operand)) { + emitByte(binary | X_INDEXED_ZERO_PAGE_BITS_A); + emitByte(address); + } else if (wordCheck(address)) { + emitByte(binary | X_INDEXED_NON_ZERO_PAGE_BITS_A); + putFixupsHere(WORD_FIXUP, 0); + emitWord(address); + } + } else if (class==Y_INDEXED_OPND || class==Y_SELECTED_OPND) { + if (wordCheck(address)) { + emitByte(binary | Y_INDEXED_NON_ZERO_PAGE_BITS_A); + putFixupsHere(WORD_FIXUP, 0); + emitWord(address); + } + } else if (class == IMMEDIATE_OPND) { + if (byteCheck(address)) { + emitByte(binary | IMMEDIATE_DATA_BITS_A); + putFixupsHere(BYTE_FIXUP, 0); + emitByte(address); + } + } else if (class == POST_INDEXED_Y_OPND) { + if (byteCheck(address)) { + emitByte(binary | POST_INDEXED_BITS_A); + putFixupsHere(BYTE_FIXUP, 0); + emitByte(address); + } + } else { + if (byteCheck(address)) { + emitByte(binary | PRE_INDEXED_BITS_A); + putFixupsHere(BYTE_FIXUP, 0); + emitByte(address); + } + } +} + + void +actionsIndex(opcode, numberOfOperands, evaluatedOperands) + opcodeTableEntryType *opcode; + int numberOfOperands; + valueType *evaluatedOperands[]; +{ + if (class == EXPRESSION_OPND) { + if (isByteAddress(operand) && isDefined(operand)) { + emitByte(binary | DIRECT_ADDRESS_ZERO_PAGE_BITS_A); + emitByte(address); + } else if (wordCheck(address)) { + emitByte(binary |DIRECT_ADDRESS_NON_ZERO_PAGE_BITS_A); + putFixupsHere(WORD_FIXUP, 0); + emitWord(address); + } + } else if (class==X_INDEXED_OPND || class==X_SELECTED_OPND) { + if (isByteAddress(operand) && isDefined(operand)) { + emitByte(binary | X_INDEXED_ZERO_PAGE_BITS_A); + emitByte(address); + } else if (wordCheck(address)) { + emitByte(binary | X_INDEXED_NON_ZERO_PAGE_BITS_A); + putFixupsHere(WORD_FIXUP, 0); + emitWord(address); + } + } else if (class==Y_INDEXED_OPND || class==Y_SELECTED_OPND) { + if (wordCheck(address)) { + emitByte(binary | Y_INDEXED_NON_ZERO_PAGE_BITS_A); + putFixupsHere(WORD_FIXUP, 0); + emitWord(address); + } + } else if (class == POST_INDEXED_Y_OPND) { + if (byteCheck(address)) { + emitByte(binary | POST_INDEXED_BITS_A); + putFixupsHere(BYTE_FIXUP, 0); + emitByte(address); + } + } else { + if (byteCheck(address)) { + emitByte(binary | PRE_INDEXED_BITS_A); + putFixupsHere(BYTE_FIXUP, 0); + emitByte(address); + } + } +} + + void +actionsNone(opcode, numberOfOperands, evaluatedOperands) + opcodeTableEntryType *opcode; + int numberOfOperands; + valueType *evaluatedOperands[]; +{ + emitByte(binary); +} + + void +actionsRelative(opcode, numberOfOperands, evaluatedOperands) + opcodeTableEntryType *opcode; + int numberOfOperands; + valueType *evaluatedOperands[]; +{ + int offset; + + if (operand->kindOfValue == UNDEFINED_VALUE || (currentCodeMode == + RELOCATABLE_BUFFER && targetOffset == 0)) + offset = 0; + else + offset = address - (currentLocationCounter.value - targetOffset) - 1; + if (offset < 0) + offset--; + if (isByteOffset(offset)) { + emitByte(binary); + putFixupsHere(BYTE_RELATIVE_FIXUP, 0); + emitByte(offset); + } else { + error(RELATIVE_OFFSET_TOO_LARGE_ERROR); + } +} + +/* + Miscellaneous helper predicates. + */ + + bool +isByte(value) + int value; +{ + return (-129kindOfValue==ABSOLUTE_VALUE && isByte(value->value)); +} + + bool +isWord(value) + int value; +{ + return (-32769kindOfValue!=UNDEFINED_VALUE); +} diff --git a/actions_68000.c b/actions_68000.c new file mode 100644 index 0000000..bdbea9c --- /dev/null +++ b/actions_68000.c @@ -0,0 +1,1089 @@ +/* + actions.c -- Actions associated with various machine instruction + classes (68000 version). + + Chip Morningstar -- Lucasfilm Ltd. + + 26-April-1985 + +*/ + +#include "macrossTypes.h" +#include "macrossGlobals.h" + +#define binary opcode->opcode +#define altBinary opcode->subClass +#define sub opcode->subClass + +#define mode(n) ((evaluatedOperands[n])->addressMode) +#define trueMode(n) (operandKindField(mode(n))) +#define address(n) (evaluatedOperands[n]->value) +#define forward(n) (!isDefined(evaluatedOperands[n])) +#define register(n) (getRegister(mode(n))) +#define controlRegister(n) (trueMode(n)==USP_REGISTER_OPND ? \ + 0x800 : (register(n) == SFC_REGISTER ? \ + 0x000 : (register(n) == DFC_REGISTER ? \ + 0x001 : 0x801))) +#define eaPC(n) (effectiveAddressBits(mode(n), address(n), \ + forward(n), TRUE)) +#define eaNoPC(n) (effectiveAddressBits(mode(n), address(n), \ + forward(n), FALSE)) +#define eaFlop(n) (eaNoPC(n)>>3 | (eaNoPC(n)&7)<<3) +#define extendPC(n) emitPossibleExtension(address(n), mode(n), binary, n,\ + forward(n), TRUE) +#define extendNoPC(n) emitPossibleExtension(address(n), mode(n), binary, n,\ + forward(n), FALSE) +#define check(g, n) ((operandClassTable[(int)trueMode(n)] &\ + g) != 0) +#define defcheck(n) isDefined(evaluatedOperands[n]) +#define check1(g) (numberOfOperands==1 && check(g, 0)) +#define check2(g1, g2) (numberOfOperands==2 && check(g1, 0) && check(g2, 1)) +/*#define check1(g) (numberOfOperands==1 && check(g, 0) && defcheck(0)) +#define check2(g1, g2) (numberOfOperands==2 && check(g1, 0) && check(g2, 1)\ + && defcheck(0) && defcheck(1))*/ + +#define iifCheck0() if (numberOfOperands==0) { +#define iifCheck1(g) if (check1(g)) { +#define eifCheck1(g) } else if (check1(g)) { +#define iifCheck2(g1, g2) if (check2(g1, g2)) { +#define eifCheck2(g1, g2) } else if (check2(g1, g2)) { +#define done } else {\ + error(INAPPROPRIATE_ADDRESS_MODES_ERROR);\ + } + +#define D_TO_EA_BIT 0x0100 +#define EA_TO_D_BIT 0x0000 +#define R_SHIFT 9 +#define Q_DATA_SHIFT 9 + +#define OP_SIZE_BITS 0x00C0 +#define BYTE_OP_SIZE_BITS 0x0000 +#define WORD_OP_SIZE_BITS 0x0040 +#define LONG_OP_SIZE_BITS 0x0080 + +#define byteOp(op) (((op) & OP_SIZE_BITS) == BYTE_OP_SIZE_BITS) +#define wordOp(op) (((op) & OP_SIZE_BITS) == WORD_OP_SIZE_BITS) +#define longOp(op) (((op) & OP_SIZE_BITS) == LONG_OP_SIZE_BITS) + +#define MOVE_OP_SIZE_BITS 0x3000 +#define MOVE_BYTE_OP_SIZE_BITS 0x1000 +#define MOVE_WORD_OP_SIZE_BITS 0x3000 +#define MOVE_LONG_OP_SIZE_BITS 0x2000 + +#define moveByteOp(op) (((op) & MOVE_OP_SIZE_BITS) == \ + MOVE_BYTE_OP_SIZE_BITS) +#define moveWordOp(op) (((op) & MOVE_OP_SIZE_BITS) == \ + MOVE_WORD_OP_SIZE_BITS) +#define moveLongOp(op) (((op) & MOVE_OP_SIZE_BITS) == \ + MOVE_LONG_OP_SIZE_BITS) + +#define isMoveOp(op) ((op)==0x1000 || (op)==0x2000 || (op)==0x3000) +#define byteOpGeneral(op) (isMoveOp(op) ? moveByteOp(op) : byteOp(op)) +#define wordOpGeneral(op) (isMoveOp(op) ? moveWordOp(op) : wordOp(op)) + +void emitPossibleExtension(); + +#define emitImmediate(n) \ + if (byteOp(binary)) {\ + if (byteCheck(address(n))) {\ + emitByte(0);\ + putFixupsHere(BYTE_FIXUP, n);\ + emitByte(address(n));\ + }\ + } else if (wordOp(binary)) {\ + if (wordCheck(address(n))) {\ + putFixupsHere(WORD_FIXUP, n);\ + emitWord(address(n));\ + }\ + } else {\ + putFixupsHere(LONG_FIXUP, n);\ + emitLong(address(n));\ + } + +/* + These routines are vectored off of the opcode lookup table. Each + instruction is of a particular category that defines which address modes + it accepts its operands in and what size the operands are. There is one + "actionsXXXX" routine for each of these categories that grabs the operands, + checks their address modes, and emits the binary instruction and operands. + */ + +/* Class I: abcd, addxb, addxw, addxl, sbcd, subxb, subxw, subxl */ + void +actionsClassI(opcode, numberOfOperands, evaluatedOperands) + opcodeTableEntryType *opcode; + int numberOfOperands; + valueType *evaluatedOperands[]; +{ +#define D_REGISTER_BIT_I 0x0000 +#define PREDECREMENT_BIT_I 0x0008 + +iifCheck2(GROUP_A, GROUP_A) + emitWord(binary | register(1)<data */ + emitWord(binary | register(0)<addr */ + emitWord(binary | register(0)<data */ + emitWord(binary | register(1)<addr */ + emitWord(binary | register(0)<kindOfValue==ABSOLUTE_VALUE && isByte(value->value)); +} + + bool +isWord(value) + int value; +{ + return (-32769kindOfValue!=UNDEFINED_VALUE); +} + +#define D_REGISTER_EA 0x0000 +#define A_REGISTER_EA 0x0008 +#define A_REGISTER_INDIRECT_EA 0x0010 +#define POSTINCREMENT_EA 0x0018 +#define PREDECREMENT_EA 0x0020 +#define DISPLACEMENT_EA 0x0028 +#define SELECTED_EA 0x0028 +#define INDEXED_EA 0x0030 +#define INDEX_SELECTED_EA 0x0030 +#define PC_DISPLACEMENT_EA 0x003A +#define PC_INDEXED_EA 0x003B +#define IMMEDIATE_EA 0x003C +#define ABSOLUTE_SHORT_EA 0x0038 +#define ABSOLUTE_LONG_EA 0x0039 + + int +effectiveAddressBits(operandKind, value, isForwardRef, pcRelativeOK) + operandKindType operandKind; + int value; + bool isForwardRef; + bool pcRelativeOK; +{ + switch(operandKindField(operandKind)) { + case D_REGISTER_OPND: + return(D_REGISTER_EA | getRegister(operandKind)); + break; + case A_REGISTER_OPND: + return(A_REGISTER_EA | getRegister(operandKind)); + break; + case A_REGISTER_INDIRECT_OPND: + return(A_REGISTER_INDIRECT_EA | getRegister(operandKind)); + break; + case POSTINCREMENT_OPND: + return(POSTINCREMENT_EA | getRegister(operandKind)); + break; + case PREDECREMENT_OPND: + return(PREDECREMENT_EA | getRegister(operandKind)); + break; + case DISPLACEMENT_OPND: + return(DISPLACEMENT_EA | getRegister(operandKind)); + break; + case SELECTED_OPND: + return(SELECTED_EA | getRegister(operandKind)); + break; + case INDEXED_OPND: + return(INDEXED_EA | getRegister(operandKind)); + break; + case INDEX_SELECTED_OPND: + return(INDEX_SELECTED_EA | getRegister(operandKind)); + break; + case PC_DISPLACEMENT_OPND: + return(PC_DISPLACEMENT_EA); + break; + case PC_INDEXED_OPND: + return(PC_INDEXED_EA); + break; + case IMMEDIATE_OPND: + return(IMMEDIATE_EA); + break; + case ABSOLUTE_SHORT_OPND: + return(ABSOLUTE_SHORT_EA); + break; + case ABSOLUTE_LONG_OPND: + return(ABSOLUTE_LONG_EA); + break; + case EXPRESSION_OPND: + if (pcRelativeOK && isWordOffset(value - + (currentLocationCounter.value - targetOffset + + 2)) && !isForwardRef) + return(PC_DISPLACEMENT_EA); + else if (isWord(value) && !isForwardRef) + return(ABSOLUTE_SHORT_EA); + else + return(ABSOLUTE_LONG_EA); + break; + case STRING_OPND: + botch("string opnd to get ea\n"); + break; + case BLOCK_OPND: + botch("block opnd to get ea\n"); + break; + case CC_REGISTER_OPND: + case STATUS_REGISTER_OPND: + case USP_REGISTER_OPND: + case CONTROL_REGISTER_OPND: + botch("funny opnd to get ea\n"); + break; + default: + botch("non-existant operand kind to get ea: %x\n", + operandKind); + break; + } +} + + void +emitPossibleExtension(value, addressMode, opcode, operandNumber, isForwardRef, + pcRelativeOK) + int value; + operandKindType addressMode; + int opcode; + int operandNumber; + bool isForwardRef; + bool pcRelativeOK; +{ + switch (operandKindField(addressMode)) { + + case DISPLACEMENT_OPND: + case SELECTED_OPND: + case ABSOLUTE_SHORT_OPND: + case PC_DISPLACEMENT_OPND: + putFixupsHere(WORD_FIXUP, operandNumber); + wordCheck(value); + emitWord(value); + break; + case INDEXED_OPND: + case INDEX_SELECTED_OPND: + case PC_INDEXED_OPND: + emitByte(indexByte(addressMode)); + putFixupsHere(BYTE_FIXUP,operandNumber); + byteCheck(value); + emitByte(value); + break; + case ABSOLUTE_LONG_OPND: + putFixupsHere(LONG_FIXUP, operandNumber); + emitLong(value); + break; + case IMMEDIATE_OPND: + if (byteOpGeneral(opcode)) { + emitByte(0); + putFixupsHere(BYTE_FIXUP, operandNumber); + byteCheck(value); + emitByte(value); + } else if (wordOpGeneral(opcode)) { + putFixupsHere(WORD_FIXUP, operandNumber); + wordCheck(value); + emitWord(value); + } else { + putFixupsHere(LONG_FIXUP, operandNumber); + emitLong(value); + } + break; + case EXPRESSION_OPND: + if (pcRelativeOK && isWordOffset(value - + (currentLocationCounter.value - + targetOffset)) && !isForwardRef) { + putFixupsHere(WORD_RELATIVE_FIXUP, + operandNumber); + emitWord(value - (currentLocationCounter.value - + targetOffset)); + } else if (isWord(value) && !isForwardRef) { + putFixupsHere(WORD_FIXUP, operandNumber); + emitWord(value); + } else { + putFixupsHere(LONG_FIXUP, operandNumber); + emitLong(value); + } + break; + default: + break; + } +} + + int +indexByte(operandKind) + operandKindType operandKind; +{ + return((getIndexRegister(operandKind)<<4) | (getWL(operandKind)<<3)); +} diff --git a/buildStuff1.c b/buildStuff1.c new file mode 100644 index 0000000..18319e9 --- /dev/null +++ b/buildStuff1.c @@ -0,0 +1,547 @@ +/* + buildStuff1.c -- Routines to build parse-tree structures for the + Macross assembler. This module is target processor + independent. + + Chip Morningstar -- Lucasfilm Ltd. + + 1-November-1984 + +*/ + +#include "macrossTypes.h" +#include "macrossGlobals.h" + +symbolTableEntryType *lookupOrEnterSymbol(); +char *saveString(); + +/* Generic routine to create statement nodes */ + statementType * +newStatement(kind, body) + statementKindType kind; + statementBodyType body; +{ + statementType *result; + + result = typeAlloc(statementType); + result->kindOfStatement = kind; + result->labels = NULL; + result->statementBody = body; + result->nextStatement = NULL; + result->fileName = currentFileName; + result->lineNumber = currentLineNumber; + result->cumulativeLineNumber = cumulativeLineNumber; + return(result); +} + +/* + These routines specifically build top-level parse-tree nodes corresponding + to the different types of Macross statements. There is one such routine of + the form "buildXxxxStatement" for each kind of Macross statement. + */ + + statementType * +buildAlignStatement(expression) + expressionType *expression; +{ + return(newStatement(ALIGN_STATEMENT, + (alignStatementBodyType *) expression)); +} + + statementType * +buildAssertStatement(condition, message) + expressionType *condition; + expressionType *message; +{ + assertStatementBodyType *result; + + result = typeAlloc(assertStatementBodyType); + + result->condition = condition; + result->message = message; + return(newStatement(ASSERT_STATEMENT, result)); +} + + statementType * +buildBlockStatement(expressionList) + expressionListType *expressionList; +{ + return(newStatement(BLOCK_STATEMENT, + (blockStatementBodyType *) expressionList)); +} + + statementType * +buildByteStatement(expressionList) + expressionListType *expressionList; +{ + return(newStatement(BYTE_STATEMENT, + (byteStatementBodyType *) expressionList)); +} + + statementType * +buildConstrainStatement(expression, block) + expressionType *expression; + blockType *block; +{ + constrainStatementBodyType *result; + + result = typeAlloc(constrainStatementBodyType); + + result->constraint = expression; + result->constrainedBlock = block; + return(newStatement(CONSTRAIN_STATEMENT, result)); +} + + statementType * +buildDbyteStatement(expressionList) + expressionListType *expressionList; +{ + return(newStatement(DBYTE_STATEMENT, + (dbyteStatementBodyType *) expressionList)); +} + + statementType * +buildDefineStatement(name, value) + stringType *name; + expressionType *value; +{ + defineStatementBodyType *result; + + result = typeAlloc(defineStatementBodyType); + result->theSymbol = lookupOrEnterSymbol(name, UNKNOWN_SYMBOL); + result->theValue = value; + return(newStatement(DEFINE_STATEMENT, result)); +} + + statementType * +buildDoUntilStatement(body, condition) + blockType *body; + conditionType condition; +{ + doUntilStatementBodyType *result; + + result = typeAlloc(doUntilStatementBodyType); + result->doUntilCondition = condition; + result->doUntilLoop = body; + return(newStatement(DO_UNTIL_STATEMENT,result)); +} + + statementType * +buildDoWhileStatement(body, condition) + blockType *body; + conditionType condition; +{ + doWhileStatementBodyType *result; + + result = typeAlloc(doWhileStatementBodyType); + result->doWhileCondition = condition; + result->doWhileLoop = body; + return(newStatement(DO_WHILE_STATEMENT, result)); +} + + statementType * +buildDoStatement(body, end) + blockType *body; + doEndType *end; +{ + statementType *result; + + if (end->doEndKind == UNTIL_END) + result = buildDoUntilStatement(body, end->doEndCondition); + else if (end->doEndKind == WHILE_END) + result = buildDoWhileStatement(body, end->doEndCondition); + else + botch("bad do-end kind: %d\n", end->doEndCondition); + qfree(end); + return(result); +} + + statementType * +buildExternStatement(identifierList) + identifierListType *identifierList; +{ + return(newStatement(EXTERN_STATEMENT, + (externStatementBodyType *) identifierList)); +} + + statementType * +buildFreturnStatement(expression) + expressionType *expression; +{ + return(newStatement(FRETURN_STATEMENT, + (freturnStatementBodyType *) expression)); +} + + statementType * +buildFunctionStatement(name, arguments, body) + stringType *name; + argumentDefinitionListType *arguments; + blockType *body; +{ + functionStatementBodyType *result; + symbolTableEntryType *testSymbol; + + testSymbol = lookupOrEnterSymbol(name, FUNCTION_SYMBOL); + if (testSymbol->context->usage != FUNCTION_SYMBOL && testSymbol-> + context->usage != UNKNOWN_FUNCTION_SYMBOL) { + error(SYMBOL_ALREADY_THERE_ERROR, symbName(testSymbol)); + return(NULL); + } + result = typeAlloc(functionStatementBodyType); + result->functionName = saveString(name); + result->theArguments = arguments; + result->theBlock = body; + return(newStatement(FUNCTION_STATEMENT, result)); +} + + statementType * +buildGroupStatement(block) + blockType *block; +{ + return(newStatement(GROUP_STATEMENT, + (groupStatementBodyType *) block)); +} + + statementType * +buildIfStatement(head, continuation, continuationKind) + ifHeadType *head; + ifContinuationType continuation; + ifContinuationKindType continuationKind; +{ + ifStatementBodyType *result; + + result = typeAlloc(ifStatementBodyType); + + result->ifCondition = head->headCondition; + result->consequence = head->headBody; + if (continuationKind == NO_CONTINUATION) + result->continuation.blockUnion = NULL; + else if (continuationKind == ELSE_CONTINUATION) { + result->continuation.continuationBodyUnion = + typeAlloc(ifContinuationBodyType); + result->continuation.continuationBodyUnion->ifCondition = + ALWAYS_COND; + result->continuation.continuationBodyUnion->consequence = + continuation.blockUnion; + result->continuation.continuationBodyUnion-> + continuation.continuationBodyUnion = NULL; + } else if (continuationKind == ELSEIF_CONTINUATION) + result->continuation = continuation; + else + botch("bad continuation kind: %d\n", continuationKind); + qfree(head); + return(newStatement(IF_STATEMENT, result)); +} + + statementType * +buildIncludeStatement(filename) + expressionType *filename; +{ + return(newStatement(INCLUDE_STATEMENT, + (includeStatementBodyType *) filename)); +} + + statementType * +buildInstructionStatement(opcode, operands) + opcodeTableEntryType *opcode; + operandListType *operands; +{ + instructionStatementBodyType *result; + + result = typeAlloc(instructionStatementBodyType); + result->kindOfInstruction = OPCODE_INSTRUCTION; + result->theInstruction.opcodeUnion = opcode; + result->theOperands = operands; + return(newStatement(INSTRUCTION_STATEMENT, result)); +} + + statementType * +buildLongStatement(expressionList) + expressionListType *expressionList; +{ + return(newStatement(LONG_STATEMENT, + (longStatementBodyType *) expressionList)); +} + + statementType * +buildMacroStatement(macro, arguments, body) + macroTableEntryType *macro; + argumentDefinitionListType *arguments; + blockType *body; +{ + macroStatementBodyType *result; + + result = typeAlloc(macroStatementBodyType); + result->theMacro = macro; + result->theArguments = arguments; + result->theBlock = body; + return(newStatement(MACRO_STATEMENT, result)); +} + + statementType * +buildMacroInstructionStatement(macro, operands) + macroTableEntryType *macro; + operandListType *operands; +{ + instructionStatementBodyType *result; + + result = typeAlloc(instructionStatementBodyType); + result->kindOfInstruction = MACRO_INSTRUCTION; + result->theInstruction.macroUnion = macro; + result->theOperands = operands; + return(newStatement(INSTRUCTION_STATEMENT, result)); +} + + statementType * +buildMdefineStatement(name, value) + stringType *name; + expressionType *value; +{ + mdefineStatementBodyType *result; + + result = typeAlloc(mdefineStatementBodyType); + result->theSymbol = lookupOrEnterSymbol(name, DEAD_SYMBOL); + result->theValue = value; + return(newStatement(MDEFINE_STATEMENT, result)); +} + + statementType * +buildMdoUntilStatement(body, condition) + blockType *body; + ExpressionType *condition; +{ + mdoUntilStatementBodyType *result; + + result = typeAlloc(mdoUntilStatementBodyType); + result->mdoUntilCondition = condition; + result->mdoUntilLoop = body; + return(newStatement(MDO_UNTIL_STATEMENT,result)); +} + + statementType * +buildMdoWhileStatement(body, condition) + blockType *body; + expressionType *condition; +{ + mdoWhileStatementBodyType *result; + + result = typeAlloc(mdoWhileStatementBodyType); + result->mdoWhileCondition = condition; + result->mdoWhileLoop = body; + return(newStatement(MDO_WHILE_STATEMENT, result)); +} + + statementType * +buildMdoStatement(body, end) + blockType *body; + doEndType *end; +{ + statementType *result; + + if (end->doEndKind == UNTIL_END) + result = buildMdoUntilStatement(body, end->doEndCondition); + else if (end->doEndKind == WHILE_END) + result = buildMdoWhileStatement(body, end->doEndCondition); + else + botch("bad mdo-end kind: %d\n", end->doEndCondition); + qfree(end); + return(result); +} + + statementType * +buildMforStatement(forExpressions, body) + forExpressionsType *forExpressions; + blockType *body; +{ + mforStatementBodyType *result; + + result = typeAlloc(mforStatementBodyType); + result->initExpression = forExpressions->initExpression; + result->testExpression = forExpressions->testExpression; + result->incrExpression = forExpressions->incrExpression; + result->forLoop = body; + qfree(forExpressions); + return(newStatement(MFOR_STATEMENT, result)); +} + + statementType * +buildMifStatement(head, continuation, continuationKind) + mifHeadType *head; + mifContinuationType continuation; + ifContinuationKindType continuationKind; +{ + mifStatementBodyType *result; + + result = typeAlloc(mifStatementBodyType); + + result->mifCondition = head->headCondition; + result->mifConsequence = head->headBody; + if (continuationKind == NO_CONTINUATION) + result->mifContinuation.mifContinuationBodyUnion = NULL; + else if (continuationKind == ELSE_CONTINUATION) { + result->mifContinuation.mifContinuationBodyUnion = + typeAlloc(mifContinuationBodyType); + result->mifContinuation.mifContinuationBodyUnion-> + mifCondition = NULL; + result->mifContinuation.mifContinuationBodyUnion-> + mifConsequence = continuation.mifBlockUnion; + result->mifContinuation.mifContinuationBodyUnion-> + mifContinuation.mifContinuationBodyUnion = NULL; + } else if (continuationKind == ELSEIF_CONTINUATION) + result->mifContinuation = continuation; + else + botch("bad mif continuation kind: %d\n", continuationKind); + qfree(head); + return(newStatement(MIF_STATEMENT, result)); +} + + statementType * +buildMswitchStatement(switchExpression, cases) + expressionType *switchExpression; + caseListType *cases; +{ + mswitchStatementBodyType *result; + + result = typeAlloc(mswitchStatementBodyType); + result->switchExpression = switchExpression; + result->cases = cases; + return(newStatement(MSWITCH_STATEMENT, result)); +} + + statementType * +buildMvariableStatement(name, value, dimension) + stringType *name; + expressionListType *value; + expressionType *dimension; +{ + mvariableStatementBodyType *result; + + result = typeAlloc(mvariableStatementBodyType); + result->theSymbol = lookupOrEnterSymbol(name, DEAD_SYMBOL); + result->theValue = value; + result->theDimension = dimension; + return(newStatement(MVARIABLE_STATEMENT, result)); +} + + statementType * +buildMwhileStatement(condition, body) + expressionType *condition; + blockType *body; +{ + mwhileStatementBodyType *result; + + result = typeAlloc(mwhileStatementBodyType); + result->mwhileCondition = condition; + result->mwhileLoop = body; + return(newStatement(MWHILE_STATEMENT, result)); +} + + statementType * +buildNullStatement() +{ + return(newStatement(NULL_STATEMENT, NULL)); +} + + statementType * +buildOrgStatement(expression) + expressionType *expression; +{ + return(newStatement(ORG_STATEMENT, + (orgStatementBodyType *) expression)); +} + + statementType * +buildPerformStatement(expression) + expressionType *expression; +{ + return(newStatement(PERFORM_STATEMENT, + (performStatementBodyType *) expression)); +} + + statementType * +buildRelStatement() +{ + return(newStatement(REL_STATEMENT, NULL)); +} + + statementType * +buildStartStatement(expression) + expressionType *expression; +{ + return(newStatement(START_STATEMENT, + (startStatementBodyType *) expression)); +} + + statementType * +buildStringStatement(expressionList) + expressionListType *expressionList; +{ + return(newStatement(STRING_STATEMENT, + (stringStatementBodyType *) expressionList)); +} + + statementType * +buildStructStatement(name, body) + symbolTableEntryType *name; + blockType *body; +{ + structStatementBodyType *result; + + result = typeAlloc(structStatementBodyType); + result->structBody = body; + result->structName = name; + return(newStatement(STRUCT_STATEMENT, result)); +} + + statementType * +buildTargetStatement(expression) + expressionType *expression; +{ + return(newStatement(TARGET_STATEMENT, + (targetStatementBodyType *) expression)); +} + + statementType * +buildUndefineStatement(identifierList) + identifierListType *identifierList; +{ + return(newStatement(UNDEFINE_STATEMENT, + (undefineStatementBodyType *) identifierList)); +} + + statementType * +buildVariableStatement(name, value, dimension) + stringType *name; + expressionListType *value; + expressionType *dimension; +{ + variableStatementBodyType *result; + + result = typeAlloc(variableStatementBodyType); + result->theSymbol = lookupOrEnterSymbol(name, VARIABLE_SYMBOL); + result->theValue = value; + result->theDimension = dimension; + return(newStatement(VARIABLE_STATEMENT, result)); +} + + statementType * +buildWhileStatement(condition, body) + conditionType condition; + blockType *body; +{ + whileStatementBodyType *result; + + result = typeAlloc(whileStatementBodyType); + result->whileCondition = condition; + result->whileLoop = body; + return(newStatement(WHILE_STATEMENT, result)); +} + + statementType * +buildWordStatement(expressionList) + expressionListType *expressionList; +{ + return(newStatement(WORD_STATEMENT, + (wordStatementBodyType *) expressionList)); +} + diff --git a/buildStuff1.o b/buildStuff1.o new file mode 100644 index 0000000000000000000000000000000000000000..63fa732b279c7064c3f9dd867b46370f47ec5ee0 GIT binary patch literal 48250 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 o*7YShjl)6f4BX024Ht_#+N*dcaseTags = caseTags; + result->caseBody = caseBody; + return(result); +} + + doEndType * +buildDoEnd(condition, kindOfDoEnd) + conditionType condition; + doEndKindType kindOfDoEnd; +{ + doEndType *result; + + result = typeAlloc(doEndType); + result->doEndKind = kindOfDoEnd; + result->doEndCondition = condition; + return(result); +} + + forExpressionsType * +buildForExpressions(initExpression, testExpression, incrExpression) + expressionType *initExpression; + expressionType *testExpression; + expressionType *incrExpression; +{ + forExpressionsType *result; + + result = typeAlloc(forExpressionsType); + result->initExpression = initExpression; + result->testExpression = testExpression; + result->incrExpression = incrExpression; + return(result); +} + + ifHeadType * +buildIfHead(condition, block) + conditionType condition; + blockType *block; +{ + ifHeadType *result; + + result = typeAlloc(ifHeadType); + result->headCondition = condition; + result->headBody = block; + return(result); +} + + mdoEndType * +buildMdoEnd(condition, kindOfMdoEnd) + expressionType *condition; + doEndKindType kindOfMdoEnd; +{ + mdoEndType *result; + + result = typeAlloc(mdoEndType); + result->mdoEndKind = kindOfMdoEnd; + result->mdoEndCondition = condition; + return(result); +} + + + mifHeadType * +buildMifHead(condition, block) + expressionType *condition; + blockType *block; +{ + mifHeadType *result; + + result = typeAlloc(mifHeadType); + result->headCondition = condition; + result->headBody = block; + return(result); +} + + +/* Fragments of expression structures */ + + arrayTermType * +buildArrayTerm(array, index) + expressionType *array; + expressionType *index; +{ + arrayTermType *result; + + result = typeAlloc(arrayTermType); + result->arrayName = array; + result->arrayIndex = index; + return(result); +} + + binopTermType * +buildBinopTerm(binop, leftArgument, rightArgument) + binopKindType binop; + expressionType *leftArgument; + expressionType *rightArgument; +{ + binopTermType *result; + + result = typeAlloc(binopTermType); + result->binop = binop; + result->leftArgument = leftArgument; + result->rightArgument = rightArgument; + return(result); +} + + functionCallTermType * +buildFunctionCall(functionName, arguments) + stringType *functionName; + operandListType *arguments; +{ + functionCallTermType *result; + symbolTableEntryType *lookupOrEnterSymbol(); + + result = typeAlloc(functionCallTermType); + result->functionName = lookupOrEnterSymbol(functionName, + UNKNOWN_FUNCTION_SYMBOL); + result->parameters = arguments; + return(result); +} + + postOpTermType * +buildPostOpTerm(postOp, postOpArgument) + postOpKindType postOp; + expressionType *postOpArgument; +{ + postOpTermType *result; + + result = typeAlloc(postOpTermType); + result->postOp = postOp; + result->postOpArgument = postOpArgument; + return(result); +} + + preOpTermType * +buildPreOpTerm(preOp, preOpArgument) + preOpKindType preOp; + expressionType *preOpArgument; +{ + preOpTermType *result; + + result = typeAlloc(preOpTermType); + result->preOp = preOp; + result->preOpArgument = preOpArgument; + return(result); +} + + unopTermType * +buildUnopTerm(unop, unopArgument) + unopKindType unop; + expressionType *unopArgument; +{ + unopTermType *result; + + result = typeAlloc(unopTermType); + result->unop = unop; + result->unopArgument = unopArgument; + return(result); +} + + expressionTermType * +buildExpressionTerm(kindOfExpressionTerm, arg1, arg2, arg3) + expressionTermKindType kindOfExpressionTerm; + anyOldThing *arg1; + anyOldThing *arg2; + anyOldThing *arg3; +{ + expressionType *result; + + symbolTableEntryType *lookupOrEnterSymbol(); + + result = typeAlloc(expressionType); + result->kindOfTerm = kindOfExpressionTerm; + switch (kindOfExpressionTerm) { + + case IDENTIFIER_EXPR: + result->expressionTerm.identifierUnion = + (identifierTermType *) arg1; + break; + + case ARRAY_EXPR: + result->expressionTerm.arrayUnion = + buildArrayTerm((expressionType *) arg1, + (expressionType *) arg2); + break; + + case FUNCTION_CALL_EXPR: + result->expressionTerm.functionCallUnion = + (functionCallTermType *) arg1; + break; + + case NUMBER_EXPR: + result->expressionTerm.numberUnion = (numberTermType) arg1; + break; + + case STRING_EXPR: + result->expressionTerm.stringUnion = (stringTermType *) arg1; + break; + + case SUBEXPRESSION_EXPR: + result->expressionTerm.subexpressionUnion = + (subexpressionTermType *) arg1; + break; + + case UNOP_EXPR: + result->expressionTerm.unopUnion = + buildUnopTerm((unopKindType) arg1, + (expressionType *) arg2); + break; + + case ASSIGN_EXPR: + case BINOP_EXPR: + result->expressionTerm.binopUnion = + buildBinopTerm((binopKindType) arg1, + (expressionType *) arg2, + (expressionType *) arg3); + break; + + case PREOP_EXPR: + result->expressionTerm.preOpUnion = + buildPreOpTerm((preOpKindType) arg1, + (expressionType *) arg2); + break; + + case POSTOP_EXPR: + result->expressionTerm.postOpUnion = + buildPostOpTerm((postOpKindType) arg1, + (expressionType *) arg2); + break; + + case HERE_EXPR: + result->expressionTerm.hereUnion = (hereTermType *) NULL; + break; + + case CONDITION_CODE_EXPR: + result->expressionTerm.conditionCodeUnion = + (conditionCodeTermType) arg1; + break; + + default: + botch("invalid expression term kind: %d\n", + kindOfExpressionTerm); + break; + } + return(result); +} + + +/* Other stuff */ + + macroTableEntryType * +buildMacroTableEntry(name) + stringType *name; +{ + macroTableEntryType *result; + char *saveString(); + + result = typeAlloc(macroTableEntryType); + result->macroName = saveString(name); + result->nextMacro = NULL; + result->arguments = NULL; + result->body = NULL; + return(result); +} + + symbolTableEntryType * +buildSymbolTableEntry(name, usage) + stringType *name; + symbolUsageKindType usage; +{ + symbolTableEntryType *result; + char *saveString(); + + result = typeAlloc(symbolTableEntryType); + result->symbolName = saveString(name); + result->nextSymbol = NULL; + result->context = typeAlloc(symbolInContextType); + result->referenceCount = 0; + dupValue(result->context->value, UndefinedValue); + result->context->attributes = 0; + result->context->referenceCount = 0; + result->context->usage = usage; + result->context->pushedContexts = NULL; + result->context->environmentNumber = GLOBAL_ENVIRONMENT_NUMBER; + return(result); +} + + codeBreakType * +buildCodeBreak(kind, address, data) + codeBreakKindType kind; + addressType address; + int data; +{ + codeBreakType *result; + + result = typeAlloc(codeBreakType); + result->kindOfBreak = kind; + result->breakAddress = address; + result->breakData = data; + result->nextBreak = NULL; + return(result); +} + + reservationListType * +buildReservation(startAddress, blockSize, nextReservation) + addressType startAddress; + int blockSize; + reservationListType *nextReservation; +{ + reservationListType *result; + + result = typeAlloc(reservationListType); + result->startAddress = startAddress; + result->blockSize = blockSize; + result->nextReservation = nextReservation; + return(result); +} + + simpleFixupListType * +buildSimpleFixupList(locationToFixup, previousList) + valueType locationToFixup; + simpleFixupListType *previousList; +{ + simpleFixupListType *result; + + result = typeAlloc(simpleFixupListType); + result->locationToFixup = locationToFixup; + result->nextFixup = previousList; + return(result); +} diff --git a/buildStuff2.o b/buildStuff2.o new file mode 100644 index 0000000000000000000000000000000000000000..a2168c82fc78031cbd6f862416c44cb8132c847d GIT binary patch literal 41152 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 IYDG-{8{qNw3IG5A literal 0 HcmV?d00001 diff --git a/buildStuff3.c b/buildStuff3.c new file mode 100644 index 0000000..cf2bb56 --- /dev/null +++ b/buildStuff3.c @@ -0,0 +1,232 @@ +/* + buildStuff3.c -- Still more routines to build parse-tree structures + for the Macross assembler. + + Chip Morningstar -- Lucasfilm Ltd. + + 2-November-1984 + +*/ + +#include "macrossTypes.h" +#include "macrossGlobals.h" + +/* + These routines all build list-type structures. Since yacc likes to build + things left-recursively but we don't want lists to be backwards (which + would then necessitate reversing them at some point -- yuck), we employ + the ruse of substituting for the first element of a list a different + struct which is identical to a normal one but contains an additional field + for a pointer to the tail element of the list. We can then add things + directly onto the tail as we like. + */ + + argumentListHeadType * +buildArgumentList(new, rest, arrayTag) + stringType *new; + argumentListHeadType *rest; + bool arrayTag; +{ + argumentListHeadType *newListHead; + argumentDefinitionListType *newArgument; + symbolTableEntryType *lookupOrEnterSymbol(); + + if (rest == NULL) { + newListHead = typeAlloc(argumentListHeadType); + newListHead->theArgument = lookupOrEnterSymbol(new, + DEAD_SYMBOL); + newListHead->nextArgument = NULL; + newListHead->tail = NULL; + newListHead->arrayTag = arrayTag; + return(newListHead); + } else { + newArgument = typeAlloc(argumentDefinitionListType); + newArgument->theArgument = lookupOrEnterSymbol(new, + DEAD_SYMBOL); + newArgument->nextArgument = NULL; + if (rest->tail != NULL) + rest->tail->nextArgument = newArgument; + else + rest->nextArgument = newArgument; + rest->tail = newArgument; + rest->arrayTag = arrayTag; + return(rest); + } +} + + caseListHeadType * +buildCaseList(new, rest) + caseType *new; + caseListHeadType *rest; +{ + caseListHeadType *newListHead; + caseListType *newCase; + + if (rest == NULL) { + newListHead = typeAlloc(caseListHeadType); + newListHead->theCase = new; + newListHead->nextCase = NULL; + newListHead->tail = NULL; + return(newListHead); + } else { + newCase = typeAlloc(caseListType); + newCase->theCase = new; + newCase->nextCase = NULL; + if (rest->tail != NULL) + rest->tail->nextCase = newCase; + else + rest->nextCase = newCase; + rest->tail = newCase; + return(rest); + } +} + + expressionListHeadType * +buildExpressionList(new, rest) + expressionType *new; + expressionListHeadType *rest; +{ + expressionListHeadType *newListHead; + expressionListType *newListEntry; + + if (rest == NULL) { + newListHead = typeAlloc(expressionListHeadType); + newListHead->theExpression = new; + newListHead->nextExpression = NULL; + newListHead->tail = NULL; + return(newListHead); + } else { + newListEntry = typeAlloc(expressionListType); + newListEntry->theExpression = new; + newListEntry->nextExpression = NULL; + if (rest->tail != NULL) + rest->tail->nextExpression = newListEntry; + else + rest->nextExpression = newListEntry; + rest->tail = newListEntry; + return(rest); + } +} + + identifierListHeadType * +buildIdentifierList(new, rest, usage) + stringType *new; + identifierListHeadType *rest; + symbolUsageKindType usage; +{ + identifierListType *newListEntry; + identifierListHeadType *newListHead; + + symbolTableEntryType *lookupOrEnterSymbol(); + + if (rest == NULL) { + newListHead = typeAlloc(identifierListHeadType); + newListHead->theSymbol = lookupOrEnterSymbol(new, usage); + newListHead->nextIdentifier = NULL; + newListHead->tail = NULL; + return(newListHead); + } else { + newListEntry = typeAlloc(identifierListType); + newListEntry->theSymbol = lookupOrEnterSymbol(new, usage); + newListEntry->nextIdentifier = NULL; + if (rest->tail != NULL) + rest->tail->nextIdentifier = newListEntry; + else + rest->nextIdentifier = newListEntry; + rest->tail = newListEntry; + return(rest); + } +} + + labelListHeadType * +buildLabelList(new, rest) + symbolTableEntryType *new; + labelListHeadType *rest; +{ + labelListHeadType *newLabelHead; + labelListType *newLabel; + + if (rest == NULL) { + newLabelHead = typeAlloc(labelListHeadType); + newLabelHead->theLabel = new; + newLabelHead->nextLabel = NULL; + newLabelHead->tail = NULL; + return(newLabelHead); + } else { + newLabel = typeAlloc(labelListType); + newLabel->theLabel = new; + newLabel->nextLabel = NULL; + if (rest->tail != NULL) + rest->tail->nextLabel = newLabel; + else + rest->nextLabel = newLabel; + rest->tail = newLabel; + return(rest); + } +} + + operandListHeadType * +buildOperandList(new, rest) + operandType *new; + operandListHeadType *rest; +{ + operandListHeadType *newListHead; + + if (rest == NULL) { + newListHead = typeAlloc(operandListHeadType); + newListHead->kindOfOperand = new->kindOfOperand; + newListHead->theOperand = new->theOperand; + newListHead->nextOperand = NULL; + newListHead->tail = NULL; + qfree(new); + return(newListHead); + } else { + new->nextOperand = NULL; + if (rest->tail != NULL) + rest->tail->nextOperand = new; + else + rest->nextOperand = new; + rest->tail = new; + return(rest); + } +} + + selectionListHeadType * +buildSelectionList(new, rest) + selectionListType *new; + selectionListHeadType *rest; +{ + return((selectionListHeadType *) buildIdentifierList(new, rest)); +} + + statementListHeadType * +buildStatementList(new, rest) + statementType *new; + statementListHeadType *rest; +{ + statementListHeadType *newListHead; + + if (new == NULL) + return(rest); + if (rest == NULL) { + newListHead = typeAlloc(statementListHeadType); + newListHead->kindOfStatement = new->kindOfStatement; + newListHead->labels = new->labels; + newListHead->statementBody = new->statementBody; + newListHead->lineNumber = new->lineNumber; + newListHead->fileName = new->fileName; + newListHead->cumulativeLineNumber = new->cumulativeLineNumber; + newListHead->nextStatement = NULL; + newListHead->tail = NULL; + qfree(new); + return(newListHead); + } else { + new->nextStatement = NULL; + if (rest->tail != NULL) + rest->tail->nextStatement = new; + else + rest->nextStatement = new; + rest->tail = new; + return(rest); + } +} diff --git a/buildStuff3.o b/buildStuff3.o new file mode 100644 index 0000000000000000000000000000000000000000..ed45f7d9c3782010d88fcc4f2c723a0c4c72e947 GIT binary patch literal 38158 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 Qbf80NDmMm + +/* + Helper routines to return values into the Macross expression evaluation + environment + */ + + valueType * +makeBooleanValue(test) + int test; +{ + valueType *newValue(); + + return(newValue(ABSOLUTE_VALUE, test!=0, EXPRESSION_OPND)); +} + + valueType * +makeFailureValue() +{ + valueType *newValue(); + + return(newValue(FAIL, 0, EXPRESSION_OPND)); +} + + valueType * +makeIntegerValue(integer) + int integer; +{ + valueType *newValue(); + + return(newValue(ABSOLUTE_VALUE, integer, EXPRESSION_OPND)); +} + + valueType * +makeOperandValue(operand) + operandType *operand; +{ + valueType *newValue(); + + return(newValue(OPERAND_VALUE, operand, EXPRESSION_OPND)); +} + + valueType * +makeStringValue(string) + stringType *string; +{ + valueType *newValue(); + + return(newValue(STRING_VALUE, string, STRING_OPND)); +} + + valueType * +makeUndefinedValue() +{ + valueType *newValue(); + + return(newValue(UNDEFINED_VALUE, 0, EXPRESSION_OPND)); +} + + +/* + The built-in-functions themselves: pointers to these are loaded into the + values of the predefined Macross symbols denoting them at assembly + initialization time from the built-in-function table. Each symbol of the + form "xxx" is assigned a pointer to "xxxBIF" (BIF == Built-In-Function). + */ + +/* Return internal address mode of an operand */ + valueType * +addressModeBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeIntegerValue(evaluatedParameter->addressMode)); + } else { + return(makeIntegerValue(-1)); + } +} + +/* Call a macro where the macro name is obtained dynamically from a string */ + valueType * +applyBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *stringValue; + stringType *macroToLookup; + macroTableEntryType *macroToCall; + + macroTableEntryType *lookupMacroName(); + valueType *evaluateOperand(); + + if (parameterList == NULL) { + error(NO_ARGUMENTS_TO_BIF_ERROR, "apply"); + return(makeFailureValue()); + } + stringValue = evaluateOperand(parameterList, NO_FIXUP); + if (stringValue->kindOfValue != STRING_VALUE) { + error(BIF_ARGUMENT_IS_NOT_A_STRING_ERROR, "apply"); + return(makeFailureValue()); + } + macroToLookup = (stringType *)stringValue->value; + if ((macroToCall = lookupMacroName(macroToLookup, + hashString(macroToLookup))) == 0) { + error(APPLY_ARGUMENT_IS_NOT_MACRO_ERROR, macroToLookup); + return(makeFailureValue()); + } + assembleMacro(macroToCall, parameterList->nextOperand); + return(makeBooleanValue(TRUE)); +} + +/* return the length of an array */ + valueType * +arrayLengthBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *testObjectValue; + valueType *evaluateOperand(); + + if (parameterList == NULL) + return(makeIntegerValue(0)); + testObjectValue = evaluateOperand(parameterList, NO_FIXUP_OK); + if (testObjectValue->kindOfValue == STRING_VALUE) { + return(makeIntegerValue(strlen(testObjectValue->value))); + } else if (testObjectValue->kindOfValue == ARRAY_VALUE) { + return(makeIntegerValue(((arrayType *)(testObjectValue-> + value))->arraySize)); + } else { + return(makeIntegerValue(0)); + } +} + +/* The two ATASCII related BIF's refer to this table -- This really only + makes sense for the 6502 version, but is harmless in other versions. */ +static char atasciiTable[] = { /* 0xFFs will become 0x00s on output */ + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, + 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, + 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, + 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, + 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, + 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, + 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, + 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, + 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, + 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0xFF, +}; + +/* Convert a string to ATASCII */ + valueType * +atasciiBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + int i; + valueType *stringValue; + stringType *string; + stringType *newString; + + valueType *evaluateOperand(); + + if (parameterList == NULL) + return(makeStringValue("")); + stringValue = evaluateOperand(parameterList, NO_FIXUP); + if (stringValue->kindOfValue != STRING_VALUE) { + error(BIF_ARGUMENT_IS_NOT_A_STRING_ERROR, "atascii"); + return(makeFailureValue()); + } + string = (stringType *)stringValue->value; + newString = (stringType *)malloc(strlen(string)+1); + for (i=0; string[i]!='\0'; i++) + newString[i] = atasciiTable[string[i]]; + newString[i] = '\0'; + return(makeStringValue(newString)); +} + +/* Convert a string to ATASCII while setting high-order color bits */ + valueType * +atasciiColorBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + int i; + valueType *stringValue; + stringType *string; + valueType *colorValue; + int color; + stringType *newString; + byte testChar; + + valueType *evaluateOperand(); + + if (parameterList == NULL) + return(makeStringValue("")); + stringValue = evaluateOperand(parameterList, NO_FIXUP); + parameterList = parameterList->nextOperand; + if (parameterList == NULL) { + color = 0; + } else { + colorValue = evaluateOperand(parameterList, NO_FIXUP); + if (colorValue->kindOfValue != ABSOLUTE_VALUE) { + error(BAD_COLOR_ARGUMENT_TO_ATASCII_COLOR_ERROR); + return(makeFailureValue()); + } + color = colorValue->value; + } + color = (color & 0x03) << 6; + if (stringValue->kindOfValue != STRING_VALUE) { + error(BIF_ARGUMENT_IS_NOT_A_STRING_ERROR, "atasciiColor"); + return(makeFailureValue()); + } + string = (stringType *)stringValue->value; + newString = (stringType *)malloc(strlen(string)+1); + for (i=0; string[i]!='\0'; i++) { + testChar = atasciiTable[string[i]]; + if (testChar == 0xFF) + testChar = 0; + testChar = (testChar & 0x3F) | color; + if (testChar == 0) + testChar = 0xFF; + newString[i] = testChar; + } + newString[i] = '\0'; + return(makeStringValue(newString)); +} + +/* Turn debug mode off and on */ + valueType * +debugModeOffBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + debug = FALSE; + return(makeBooleanValue(FALSE)); +} + + valueType * +debugModeOnBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + debug = TRUE; + return(makeBooleanValue(TRUE)); +} + +/* Turn display of code emission off and on */ + valueType * +emitModeOffBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + emitPrint = FALSE; + return(makeBooleanValue(FALSE)); +} + + valueType * +emitModeOnBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + emitPrint = TRUE; + return(makeBooleanValue(TRUE)); +} + +/* Check if an operand is absolute (as opposed to relocatable) */ + valueType * +isAbsoluteValueBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeBooleanValue(evaluatedParameter->kindOfValue == + ABSOLUTE_VALUE)); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Check if operand is code block */ + valueType * +isBlockBIF(parameterList, kindOfFixup) /* questionable */ + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeBooleanValue(evaluatedParameter->kindOfValue == + BLOCK_VALUE)); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Check if operand is a BIF */ + valueType * +isBuiltInFunctionBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeBooleanValue(evaluatedParameter->kindOfValue == + BUILT_IN_FUNCTION_VALUE)); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Check if operand is a condition code */ + valueType * +isConditionCodeBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeBooleanValue(evaluatedParameter->kindOfValue == + CONDITION_VALUE)); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Check if a symbol is defined */ + valueType * +isDefinedBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + expressionType *expression; + symbolInContextType *context; + + symbolInContextType *getWorkingContext(); + symbolTableEntryType *effectiveSymbol(); + + if (parameterList != NULL) { + if (parameterList->kindOfOperand == EXPRESSION_OPND && + (expression = parameterList->theOperand. + expressionUnion) != NULL && expression-> + kindOfTerm == IDENTIFIER_EXPR && + effectiveSymbol(expression->expressionTerm. + identifierUnion, &context) != NULL && + context != NULL && (context->value-> + kindOfValue == UNDEFINED_VALUE || context-> + value->kindOfValue == FAIL)) { + if ((context->usage == UNKNOWN_SYMBOL || context-> + usage == NESTED_UNKNOWN_SYMBOL) && + context->referenceCount == 0) + context->usage = DEAD_SYMBOL; + return(makeBooleanValue(FALSE)); + } else { + return(makeBooleanValue(TRUE)); + } + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Check if a symbol is externally visible */ + valueType * +isExternalBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + expressionType *expression; + symbolInContextType *context; + + symbolInContextType *getWorkingContext(); + + if (parameterList != NULL && parameterList->kindOfOperand == + EXPRESSION_OPND) { + expression = parameterList->theOperand.expressionUnion; + return(makeBooleanValue(expression->kindOfTerm == + IDENTIFIER_EXPR && (context = getWorkingContext( + expression->expressionTerm.identifierUnion))!=NULL && + (context->attributes & GLOBAL_ATT)!=0)); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Check if an operand is a struct field */ + valueType * +isFieldBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeBooleanValue(evaluatedParameter->kindOfValue == + FIELD_VALUE)); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Check if an operand is a user-defined function */ + valueType * +isFunctionBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeBooleanValue(evaluatedParameter->kindOfValue == + FUNCTION_VALUE)); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Check if an operand value is relocatable */ + valueType * +isRelocatableValueBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeBooleanValue(evaluatedParameter->kindOfValue == + RELOCATABLE_VALUE || evaluatedParameter-> + kindOfValue == DATA_VALUE)); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Check if an operand is a string */ + valueType * +isStringBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeBooleanValue(evaluatedParameter->kindOfValue == + STRING_VALUE)); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Check if an operand is a struct */ + valueType * +isStructBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeBooleanValue(evaluatedParameter->kindOfValue == + STRUCT_VALUE)); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Check if an operand is a symbol */ + valueType * +isSymbolBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + expressionType *expression; + + if (parameterList != NULL && parameterList->kindOfOperand == + EXPRESSION_OPND) { + expression = parameterList->theOperand.expressionUnion; + return(makeBooleanValue(expression->kindOfTerm == + IDENTIFIER_EXPR)); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Turn listing off and on */ + valueType * +listingOffBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + if (listingOn) { + if (!listingControlCounter) + saveListingOff(); + listingControlCounter++; + } + return(makeBooleanValue(FALSE)); +} + + valueType * +listingOnBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + if (listingOn) { + if (--listingControlCounter < 0) { + listingControlCounter = 0; + return(makeBooleanValue(TRUE)); + } else if (listingControlCounter) { + return(makeBooleanValue(FALSE)); + } else { + saveListingOn(); + return(makeBooleanValue(TRUE)); + } + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Generate an array on the fly */ + valueType * +makeArrayBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *lengthValue; + int length; + valueType *result; + valueType **arrayContents; + int i; + + if (parameterList == NULL) { + error(NO_ARGUMENTS_TO_BIF_ERROR, "makeArray"); + return(makeFailureValue()); + } + lengthValue = evaluateOperand(parameterList, NO_FIXUP); + if (lengthValue->kindOfValue != ABSOLUTE_VALUE) { + error(BIF_NTH_ARGUMENT_IS_NOT_ABSOLUTE_VALUE_ERROR, + "makeArray", 1); + return(makeFailureValue()); + } else if (lengthValue->value < 0) { + error(NEGATIVE_ARRAY_SIZE_TO_MAKEARRAY_ERROR); + return(makeFailureValue()); + } + length = lengthValue->value; + result = newValue(ARRAY_VALUE, allocArray(length, &arrayContents), + EXPRESSION_OPND); + parameterList = parameterList->nextOperand; + for (i=0; inextOperand; + } else { + arrayContents[i] = NULL; + } + } + if (parameterList != NULL) { + error(TOO_MANY_INITIALIZATION_ARGS_TO_MAKEARRAY_ERROR); + return(makeFailureValue()); + } + return(result); +} + +/* Return the Nth character of a string (as an integer) */ + valueType * +nthCharBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *positionValue; + int position; + valueType *stringValue; + stringType *string; + + valueType *evaluateOperand(); + + if (parameterList == NULL) + return(makeFailureValue()); + stringValue = evaluateOperand(parameterList, NO_FIXUP); + if (stringValue->kindOfValue != STRING_VALUE) { + error(BIF_ARGUMENT_IS_NOT_A_STRING_ERROR, "nthChar"); + return(makeFailureValue()); + } + parameterList = parameterList->nextOperand; + if (parameterList == NULL) { + position = 0; + } else { + positionValue = evaluateOperand(parameterList, NO_FIXUP); + if (positionValue->kindOfValue != ABSOLUTE_VALUE) { + error(BAD_POSITION_ARGUMENT_TO_NTH_CHAR_ERROR); + return(makeFailureValue()); + } + position = positionValue->value; + } + + string = (stringType *)stringValue->value; + if (position >= strlen(string)) { + error(BAD_POSITION_ARGUMENT_TO_NTH_CHAR_ERROR); + return(makeFailureValue()); + } + return(makeIntegerValue(string[position])); +} + +/* Pass stuff through to stdio's 'printf' function */ + valueType * +printfBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + stringType *formatString; + valueType *stringValue; + int argumentCount; + int argument[20]; + valueType *result; + + valueType *evaluateOperand(); + + result = makeFailureValue(); + if (parameterList != NULL) { + stringValue = evaluateOperand(parameterList, NO_FIXUP); + if (stringValue->kindOfValue != STRING_VALUE) { + error(PRINTF_FORMAT_IS_NOT_A_STRING_ERROR); + return(result); + } + formatString = (stringType *)stringValue->value; + parameterList = parameterList->nextOperand; + argumentCount = 0; + while (parameterList != NULL && argumentCount < 20) { + argument[argumentCount++] = evaluateOperand( + parameterList)->value; + parameterList = parameterList->nextOperand; + } + /* cretinous hack */ + printf(formatString, argument[0], argument[1], argument[2], + argument[3], argument[4], argument[5], argument[6], + argument[7], argument[8], argument[9], argument[10], + argument[11], argument[12], argument[13], + argument[14], argument[15], argument[16], + argument[17], argument[18], argument[19]); + } + return(result); +} + +/* Concatenate two strings */ + valueType * +strcatBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *stringValue; + stringType *string1; + stringType *string2; + stringType *newString; + + if (parameterList == NULL) + return(makeStringValue("")); + stringValue = evaluateOperand(parameterList, NO_FIXUP); + if (stringValue->kindOfValue != STRING_VALUE) { + error(BIF_NTH_ARGUMENT_IS_NOT_A_STRING_ERROR, "strcat", 1); + return(makeFailureValue()); + } + string1 = (stringType *)stringValue->value; + parameterList = parameterList->nextOperand; + if (parameterList == NULL) + return(makeStringValue(string1)); + stringValue = evaluateOperand(parameterList, NO_FIXUP); + if (stringValue->kindOfValue != STRING_VALUE) { + error(BIF_NTH_ARGUMENT_IS_NOT_A_STRING_ERROR, "strcat", 2); + return(makeFailureValue()); + } + string2 = (stringType *)stringValue->value; + newString = (stringType *)malloc(strlen(string1)+strlen(string2)+1); + strcpy(newString, string1); + strcat(newString, string2); + return(makeStringValue(newString)); +} + +/* Compare two strings */ + valueType * +strcmpBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *stringValue; + stringType *string1; + stringType *string2; + stringType *newString; + + if (parameterList == NULL) { + error(NO_ARGUMENTS_TO_BIF_ERROR, "strcmp"); + return(makeFailureValue()); + } + stringValue = evaluateOperand(parameterList, NO_FIXUP); + if (stringValue->kindOfValue != STRING_VALUE) { + error(BIF_NTH_ARGUMENT_IS_NOT_A_STRING_ERROR, "strcmp", 1); + return(makeFailureValue()); + } + string1 = (stringType *)stringValue->value; + parameterList = parameterList->nextOperand; + if (parameterList == NULL) + return(makeStringValue(string1)); + stringValue = evaluateOperand(parameterList, NO_FIXUP); + if (stringValue->kindOfValue != STRING_VALUE) { + error(BIF_NTH_ARGUMENT_IS_NOT_A_STRING_ERROR, "strcmp", 2); + return(makeFailureValue()); + } + string2 = (stringType *)stringValue->value; + return(makeIntegerValue(strcmp(string1, string2))); +} + +/* Compare two strings in a case-independent fashion */ + valueType * +strcmplcBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *stringValue; + stringType *string1; + stringType *string2; + stringType *newString; + + if (parameterList == NULL) { + error(NO_ARGUMENTS_TO_BIF_ERROR, "strcmplc"); + return(makeFailureValue()); + } + stringValue = evaluateOperand(parameterList, NO_FIXUP); + if (stringValue->kindOfValue != STRING_VALUE) { + error(BIF_NTH_ARGUMENT_IS_NOT_A_STRING_ERROR, "strcmplc", 1); + return(makeFailureValue()); + } + string1 = (stringType *)stringValue->value; + parameterList = parameterList->nextOperand; + if (parameterList == NULL) + return(makeStringValue(string1)); + stringValue = evaluateOperand(parameterList, NO_FIXUP); + if (stringValue->kindOfValue != STRING_VALUE) { + error(BIF_NTH_ARGUMENT_IS_NOT_A_STRING_ERROR, "strcmplc", 2); + return(makeFailureValue()); + } + string2 = (stringType *)stringValue->value; + return(makeIntegerValue(strcmplc(string1, string2))); +} + +/* Return the length of a string */ + valueType * +strlenBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *stringValue; + + if (parameterList == NULL) + return(makeIntegerValue(-1)); + stringValue = evaluateOperand(parameterList, NO_FIXUP); + if (stringValue->kindOfValue != STRING_VALUE) { + error(BIF_ARGUMENT_IS_NOT_A_STRING_ERROR, "strlen"); + return(makeFailureValue()); + } else + return(makeIntegerValue(strlen(stringValue->value))); +} + +/* Return a substring of a string */ + valueType * +substrBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *stringValue; + stringType *string; + valueType *startValue; + int start; + valueType *lengthValue; + int length; + stringType *newString; + int originalLength; + bool backwards; + + if (parameterList == NULL) { + error(NO_ARGUMENTS_TO_BIF_ERROR, "substr"); + return(makeFailureValue()); + } + stringValue = evaluateOperand(parameterList, NO_FIXUP); + if (stringValue->kindOfValue != STRING_VALUE) { + error(BIF_ARGUMENT_IS_NOT_A_STRING_ERROR, "substr"); + return(makeFailureValue()); + } + string = (stringType *)stringValue->value; + originalLength = strlen(string); + + parameterList = parameterList->nextOperand; + if (parameterList == NULL) { + error(TOO_FEW_ARGUMENTS_TO_BIF_ERROR, "substr"); + return(makeFailureValue()); + } + startValue = evaluateOperand(parameterList, NO_FIXUP); + if (startValue->kindOfValue != ABSOLUTE_VALUE) { + error(BIF_NTH_ARGUMENT_IS_NOT_ABSOLUTE_VALUE_ERROR, "substr", + 2); + return(makeFailureValue()); + } + start = startValue->value; + if (start < 0) { + start = -start - 1; + backwards = TRUE; + } else + backwards = FALSE; + + parameterList = parameterList->nextOperand; + if (parameterList == NULL) { + length = originalLength - start; + if (backwards) + length = -length; + } else { + lengthValue = evaluateOperand(parameterList, NO_FIXUP); + if (lengthValue->kindOfValue != ABSOLUTE_VALUE) { + error(BIF_NTH_ARGUMENT_IS_NOT_ABSOLUTE_VALUE_ERROR, + "substr", 3); + return(makeFailureValue()); + } + length = lengthValue->value; + } + if (length < 0) { + length = -length; + if (backwards) + start = start + length - 1; + else + start = start - length + 1; + } + if (backwards) + start = originalLength - start - 1; + if (originalLength <= start || originalLength < length + start || + start < 0 ){ + error(BAD_SUBSTRING_INDICES_ERROR); + return(makeFailureValue()); + } + newString = (stringType *)malloc(length+1); + strncpy(newString, string+start, length); + newString[length] = '\0'; + return(makeStringValue(newString)); +} + +/* Turn a string into a symbol */ + valueType * +symbolLookupBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *stringValue; + stringType *identifierToLookup; + + expressionTermType *buildExpressionTerm(); + operandType *buildOperand(); + valueType *evaluateIdentifier(); + + if (parameterList == NULL) { + error(NO_ARGUMENTS_TO_BIF_ERROR, "symbolLookup"); + return(makeFailureValue()); + } + stringValue = evaluateOperand(parameterList, NO_FIXUP); + if (stringValue->kindOfValue != STRING_VALUE) { + error(BIF_ARGUMENT_IS_NOT_A_STRING_ERROR, "symbolLookup"); + return(makeFailureValue()); + } + identifierToLookup = (stringType *)stringValue->value; + return(evaluateIdentifier(lookupOrEnterSymbol(identifierToLookup, + UNKNOWN_SYMBOL), FALSE, kindOfFixup)); +} + +/* Define a string as a symbol */ + valueType * +symbolDefineBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *stringValue; + statementType *syntheticDefineStatement; + statementType *buildDefineStatement(); + + if (parameterList == NULL) { + error(NO_ARGUMENTS_TO_BIF_ERROR, "symbolDefine"); + return(makeFailureValue()); + } + stringValue = evaluateOperand(parameterList, NO_FIXUP); + if (stringValue->kindOfValue != STRING_VALUE) { + error(BIF_ARGUMENT_IS_NOT_A_STRING_ERROR, "symbolDefine"); + return(makeFailureValue()); + } + parameterList = parameterList->nextOperand; + if (parameterList == NULL) { + syntheticDefineStatement = buildDefineStatement(stringValue-> + value, NULL); + } else if (parameterList->kindOfOperand != EXPRESSION_OPND) { + error(SYMBOL_DEFINE_VALUE_NOT_EXPRESSION_OPND_ERROR); + return(makeFailureValue()); + } else { + syntheticDefineStatement = buildDefineStatement(stringValue-> + value, parameterList->theOperand); + } + assembleDefineStatement(syntheticDefineStatement->statementBody); + freeStatement(syntheticDefineStatement); + return(makeBooleanValue(TRUE)); +} + +/* Turn a symbol into a string */ + valueType * +symbolNameBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + expressionType *expression; + symbolInContextType *context; + environmentType *saveEnvironment; + + symbolInContextType *getWorkingContext(); + + saveEnvironment = currentEnvironment; + while (parameterList != NULL && parameterList->kindOfOperand == + EXPRESSION_OPND) { + expression = parameterList->theOperand.expressionUnion; + if (expression->kindOfTerm == IDENTIFIER_EXPR && (context = + getWorkingContext(expression->expressionTerm. + identifierUnion)) != NULL) { + if (context->value->kindOfValue != OPERAND_VALUE || + context->usage != ARGUMENT_SYMBOL) { + currentEnvironment = saveEnvironment; + return(makeStringValue(symbName(expression-> + expressionTerm.identifierUnion))); + } else { + currentEnvironment = currentEnvironment-> + previousEnvironment; + parameterList = (operandListType *)context-> + value->value; + } + } else { + break; + } + } + currentEnvironment = saveEnvironment; + error(CANT_FIND_SYMBOL_ERROR); + return(makeStringValue("")); +} + +/* Return internal form of what sort of symbol a symbol is */ + valueType * +symbolUsageBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + expressionType *expression; + symbolInContextType *context; + + symbolInContextType *getWorkingContext(); + + if (parameterList != NULL && parameterList->kindOfOperand == + EXPRESSION_OPND) { + expression = parameterList->theOperand.expressionUnion; + if (expression->kindOfTerm == IDENTIFIER_EXPR && (context = + getWorkingContext(expression->expressionTerm. + identifierUnion))!=NULL) + return(makeIntegerValue(context->usage)); + } + return(makeIntegerValue(-1)); +} + +/* Return internal form of what sort of value a value is */ + valueType * +valueTypeBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeIntegerValue(evaluatedParameter->kindOfValue)); + } else { + return(makeIntegerValue(-1)); + } +} + diff --git a/builtInFunctions.o b/builtInFunctions.o new file mode 100644 index 0000000000000000000000000000000000000000..b81a0a499c76586261be9255b08b5b8ef773dd22 GIT binary patch literal 59433 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 LbNA|utG@pSPQ(@a literal 0 HcmV?d00001 diff --git a/builtInFunsSD.o b/builtInFunsSD.o new file mode 100644 index 0000000000000000000000000000000000000000..191a3c97663b312d4f73b7b83a5e9a25adc42a01 GIT binary patch literal 38015 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 APXGV_ literal 0 HcmV?d00001 diff --git a/builtInFunsSD_6502.c b/builtInFunsSD_6502.c new file mode 100644 index 0000000..db515b3 --- /dev/null +++ b/builtInFunsSD_6502.c @@ -0,0 +1,237 @@ +/* + builtInFunsSD_6502.c -- Code for target-processor dependent + intrinsic user callable functions in the Macross assembler. + (6502 version). + + Chip Morningstar -- Lucasfilm Ltd. + + 23-April-1985 + +*/ + +#include "macrossTypes.h" +#include "macrossGlobals.h" + +/* Helper functions, defined in builtInFunctions.c */ +valueType *makeBooleanValue(); +valueType *makeFailureValue(); +valueType *makeIntegerValue(); +valueType *makeOperandValue(); +valueType *makeStringValue(); +valueType *makeUndefinedValue(); + + +/* Check if operand is the accumulator */ + valueType * +isARegisterBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeBooleanValue(evaluatedParameter->addressMode == + A_REGISTER_OPND)); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Check if an operand's address mode is DIRECT */ + valueType * +isDirectModeBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeBooleanValue(evaluatedParameter->addressMode == + EXPRESSION_OPND)); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Check if an operand's address mode is IMMEDIATE */ + valueType * +isImmediateModeBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeBooleanValue(evaluatedParameter->addressMode == + IMMEDIATE_OPND)); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Check if an operand's address mode is INDEXED (either X or Y) */ + valueType * +isIndexedModeBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeBooleanValue(evaluatedParameter->addressMode == + X_INDEXED_OPND || evaluatedParameter->addressMode == + Y_INDEXED_OPND || evaluatedParameter->addressMode == + X_SELECTED_OPND || evaluatedParameter->addressMode == + Y_SELECTED_OPND)); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Check if an operand's address mode is INDIRECT */ + valueType * +isIndirectModeBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeBooleanValue(evaluatedParameter->addressMode == + INDIRECT_OPND)); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Check if an operand's address mode is POST-INDEXED */ + valueType * +isPostIndexedModeBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeBooleanValue(evaluatedParameter->addressMode == + POST_INDEXED_Y_OPND)); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Check if an operand's address mode is PRE-INDEXED */ + valueType * +isPreIndexedModeBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeBooleanValue(evaluatedParameter->addressMode == + PRE_INDEXED_X_OPND || evaluatedParameter-> + addressMode == PRE_SELECTED_X_OPND)); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Check if an operand's address mode is X-INDEXED */ + valueType * +isXIndexedModeBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeBooleanValue(evaluatedParameter->addressMode == + X_INDEXED_OPND || evaluatedParameter->addressMode == + X_SELECTED_OPND)); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Check if an operand is the X index register */ + valueType * +isXRegisterBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeBooleanValue(evaluatedParameter->addressMode == + X_REGISTER_OPND)); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Check if an operand's address mode is Y-INDEXED */ + valueType * +isYIndexedModeBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeBooleanValue(evaluatedParameter->addressMode == + Y_INDEXED_OPND || evaluatedParameter->addressMode == + Y_SELECTED_OPND)); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Check if an operand is the Y index register */ + valueType * +isYRegisterBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeBooleanValue(evaluatedParameter->addressMode == + Y_REGISTER_OPND)); + } else { + return(makeBooleanValue(FALSE)); + } +} diff --git a/builtInFunsSD_68000.c b/builtInFunsSD_68000.c new file mode 100644 index 0000000..3f67a39 --- /dev/null +++ b/builtInFunsSD_68000.c @@ -0,0 +1,505 @@ +/* + builtInFunsSD_68000.c -- Code for target-processor dependent + intrinsic user callable functions in the Macross assembler. + (68000 version). + + Chip Morningstar -- Lucasfilm Ltd. + + 26-April-1985 + +*/ + +#include "macrossTypes.h" +#include "macrossGlobals.h" + +/* Helper functions, defined in builtInFunctions.c */ +valueType *makeBooleanValue(); +valueType *makeFailureValue(); +valueType *makeIntegerValue(); +valueType *makeOperandValue(); +valueType *makeStringValue(); +valueType *makeUndefinedValue(); + + +/* Get address register component of operand */ + valueType * +getAddressRegisterBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeIntegerValue(getAddressRegister( + evaluatedParameter->addressMode))); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Get data register component of operand */ + valueType * +getDataRegisterBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeIntegerValue(getDataRegister(evaluatedParameter-> + addressMode))); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Get index register component of operand */ + valueType * +getIndexRegisterBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeIntegerValue(getIndexRegister(evaluatedParameter-> + addressMode))); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Get register component of operand */ + valueType * +getRegisterBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeIntegerValue(getRegister(evaluatedParameter-> + addressMode))); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Get word/long component of operand */ + valueType * +getWLBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeIntegerValue(getWL(evaluatedParameter-> + addressMode))); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Check if an operand's address mode is absolute */ + valueType * +isAbsoluteModeBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeBooleanValue(operandKindField(evaluatedParameter-> + addressMode) == ABSOLUTE_SHORT_OPND || + operandKindField(evaluatedParameter->addressMode) == + ABSOLUTE_LONG_OPND)); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Check if an operand's address mode is absolute long */ + valueType * +isAbsoluteLongModeBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeBooleanValue(operandKindField(evaluatedParameter-> + addressMode) == ABSOLUTE_LONG_OPND)); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Check if an operand's address mode is absolute short */ + valueType * +isAbsoluteShortModeBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeBooleanValue(operandKindField(evaluatedParameter-> + addressMode) == ABSOLUTE_SHORT_OPND)); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Check if operand is an address register */ + valueType * +isARegisterBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeBooleanValue(operandKindField(evaluatedParameter-> + addressMode) == A_REGISTER_OPND)); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Check if operand is the condition code register */ + valueType * +isCCRegisterBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeBooleanValue(operandKindField(evaluatedParameter-> + addressMode) == CC_REGISTER_OPND)); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Check if operand is a control register */ + valueType * +isControlRegisterBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeBooleanValue(operandKindField(evaluatedParameter-> + addressMode) == CONTROL_REGISTER_OPND)); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Check if operand is a data register */ + valueType * +isDRegisterBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeBooleanValue(operandKindField(evaluatedParameter-> + addressMode) == D_REGISTER_OPND)); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Check if operand is DFC register */ + valueType * +isDFCRegisterBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeBooleanValue(operandKindField(evaluatedParameter-> + addressMode) == CONTROL_REGISTER_OPND && + getRegister(evaluatedParameter->addressMode) == + DFC_REGISTER)); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Check if an operand's address mode is displacement */ + valueType * +isDisplacementModeBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeBooleanValue(operandKindField(evaluatedParameter-> + addressMode) == DISPLACEMENT_OPND)); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Check if an operand's address mode is IMMEDIATE */ + valueType * +isImmediateModeBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeBooleanValue(operandKindField(evaluatedParameter-> + addressMode) == IMMEDIATE_OPND)); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Check if an operand's address mode is indexed */ + valueType * +isIndexedModeBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeBooleanValue(operandKindField(evaluatedParameter-> + addressMode) == INDEXED_OPND)); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Check if an operand's address mode is indirect */ + valueType * +isIndirectModeBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeBooleanValue(operandKindField(evaluatedParameter-> + addressMode) == A_REGISTER_INDIRECT_OPND)); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Check if an operand's address mode is pc displacement */ + valueType * +isPCDisplacementModeBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeBooleanValue(operandKindField(evaluatedParameter-> + addressMode) == PC_DISPLACEMENT_OPND)); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Check if an operand's address mode is pc indexed */ + valueType * +isPCIndexedModeBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeBooleanValue(operandKindField(evaluatedParameter-> + addressMode) == PC_INDEXED_OPND)); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Check if an operand's address mode is postincrement */ + valueType * +isPostincrementModeBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeBooleanValue(operandKindField(evaluatedParameter-> + addressMode) == POSTINCREMENT_OPND)); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Check if an operand's address mode is predecrement */ + valueType * +isPredecrementModeBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeBooleanValue(operandKindField(evaluatedParameter-> + addressMode) == PREDECREMENT_OPND)); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Check if operand is SFC register */ + valueType * +isSFCRegisterBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeBooleanValue(operandKindField(evaluatedParameter-> + addressMode) == CONTROL_REGISTER_OPND && + getRegister(evaluatedParameter->addressMode) == + SFC_REGISTER)); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Check if operand is the status register */ + valueType * +isStatusRegisterBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeBooleanValue(operandKindField(evaluatedParameter-> + addressMode) == STATUS_REGISTER_OPND)); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Check if operand is user stack pointer */ + valueType * +isUSPBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeBooleanValue(operandKindField(evaluatedParameter-> + addressMode) == USP_REGISTER_OPND)); + } else { + return(makeBooleanValue(FALSE)); + } +} + +/* Check if operand is VB register */ + valueType * +isVBRegisterBIF(parameterList, kindOfFixup) + operandListType *parameterList; + fixupKindType kindOfFixup; +{ + valueType *evaluatedParameter; + + valueType *evaluateOperand(); + + if (parameterList != NULL) { + evaluatedParameter = evaluateOperand(parameterList, NO_FIXUP); + return(makeBooleanValue(operandKindField(evaluatedParameter-> + addressMode) == CONTROL_REGISTER_OPND && + getRegister(evaluatedParameter->addressMode) == + VBR_REGISTER)); + } else { + return(makeBooleanValue(FALSE)); + } +} diff --git a/conditionDefs_6502.h b/conditionDefs_6502.h new file mode 100644 index 0000000..602abd1 --- /dev/null +++ b/conditionDefs_6502.h @@ -0,0 +1,19 @@ +/* + conditionDefs_6502.h -- Define types for 6502 branch condition codes. + + Chip Morningstar -- Lucasfilm Ltd. + + 18-April-1985 +*/ + +typedef enum { + CARRY_COND, ZERO_COND, NEGATIVE_COND, OVERFLOW_COND, LT_COND, + LEQ_COND, SLT_COND, SLEQ_COND, + ALWAYS_COND, + NOT_CARRY_COND, NOT_ZERO_COND, NOT_NEGATIVE_COND, + NOT_OVERFLOW_COND, GEQ_COND, GT_COND, SGEQ_COND, SGT_COND, + NEVER_COND, + NOT_FOUND_COND, + } conditionType; + +#define COMPOUND_BRANCH_MAX 3 diff --git a/conditionDefs_68000.h b/conditionDefs_68000.h new file mode 100644 index 0000000..e83b7a2 --- /dev/null +++ b/conditionDefs_68000.h @@ -0,0 +1,20 @@ +/* + conditionDefs_68000.h -- Define types for 68000 condition codes. + + Chip Morningstar -- Lucasfilm Ltd. + + 25-April-1985 +*/ + +typedef enum { + CARRY_COND, EQUAL_COND, OVERFLOW_COND, MINUS_COND, LT_COND, + LEQ_COND, LOW_OR_SAME_COND, + ALWAYS_COND, + NOT_CARRY_COND, NOT_EQUAL_COND, NOT_OVERFLOW_COND, PLUS_COND, + GEQ_COND, GT_COND, HIGH_COND, + NEVER_COND, + NOT_FOUND_COND, + } conditionType; + +#define COMPOUND_BRANCH_MAX 1 + diff --git a/debugPrint.c b/debugPrint.c new file mode 100644 index 0000000..630252a --- /dev/null +++ b/debugPrint.c @@ -0,0 +1,1200 @@ +/* + debugPrint.c -- Routines to print out things for debugging purposes. + + Chip Morningstar -- Lucasfilm Ltd. + + 5-November-1984 + +*/ + +#include "macrossTypes.h" +#include "macrossGlobals.h" +#include "y.tab.h" + +/* + Print out the parse-tree. + */ + +int tablevel = 0; + +/* Fundamental nop print operation */ +#define nullPrint(thing) if (thing==NULL) { tab(); printf("()\n"); return; } + +/* For keeping nested structures looking pretty */ + void +tab() +{ + int n; + + n = tablevel; + while (n-- > 0) + printf(" "); +} + +/* + The following routines print readable strings for the values of various + enumerated types and pre-defined constants. Each contains a static table + of strings that must be kept consistent with the type or set of + definitions that it represents. + */ + + void +printAssignmentKind(assignmentKind) + assignmentKindType assignmentKind; +{ +/* This table MUST be maintained congruently with the definition of the + enumerated type 'assignmentKindType'. */ + static char *assignmentTable[] = { + "ASSIGN_ASSIGN", + "ADD_ASSIGN", + "SUB_ASSIGN", + "MUL_ASSIGN", + "DIV_ASSIGN", + "MOD_ASSIGN", + "AND_ASSIGN", + "OR_ASSIGN", + "XOR_ASSIGN", + "LEFT_SHIFT_ASSIGN", + "RIGHT_SHIFT_ASSIGN", + "NO_ASSIGN", + }; + + printf("%s", assignmentTable[(int)assignmentKind]); +} + + void +printExpressionKind(kind) + expressionTermKindType kind; +{ +/* This table MUST be maintained congruently with the definition of the + enumerated type 'expressionTermKindType'. */ + static char *expressionKindTable[] = { + "identifier expr", + "function call expr", + "number expr", + "subexpression", + "unop expr", + "binop expr", + "preop expr", + "postop expr", + "here", + "assignment expr", + "condition code expr", + "string expr", + "value", + "array expr", + }; + + printf("%s", expressionKindTable[(int)kind]); +} + + stringType * +statementKindString(kind) + statementKindType kind; +{ +/* This table MUST be maintained congruently with the definition of + the enumerated type 'statementKindType'. */ +static char *statementKindTable[] = { + "if", + "while", + "do_while", + "do_until", + "word", + "dbyte", + "byte", + "string", + "struct", + "instruction", + "define", + "undefine", + "mif", + "freturn", + "mfor", + "mdo_while", + "mdo_until", + "include", + "extern", + "start", + "align", + "org", + "rel", + "perform", + "block", + "mwhile", + "mdefine", + "null", + "group", + "macro", + "function", + "variable", + "mvariable", + "constrain", + "assert", + "mswitch", + "long", + "target", + }; + return(statementKindTable[(int)kind]); +} + + void +printStatementKind(kind) + statementKindType kind; +{ + printf("%s", statementKindString(kind)); +} + + +/* + These routines collectively print expressions and values. + */ + + void +printValue(value) + valueType *value; +{ +/* This table MUST be maintained congruently with the definition of the + enumerated type 'valueKindType'. */ + static char *valueKindTable[NUM_OF_VALUE_KINDS] = { + "ABSOLUTE_VALUE", + "DATA_VALUE", + "RELOCATABLE_VALUE", + "BSS_VALUE", + "STRUCT_VALUE", + "FIELD_VALUE", + "MACRO_VALUE", + "OPERAND_VALUE", + "STRING_VALUE", + "CONDITION_VALUE", + "UNDEFINED_VALUE", + "FUNCTION_VALUE", + "BLOCK_VALUE", + "BUILT_IN_FUNCTION_VALUE", + "ARRAY_VALUE", + "FAIL", + }; + + if (value != NULL) { + printf("(%s: %d==0x%x ", valueKindTable[(int)value-> + kindOfValue], value->value, value->value); + printOperandKind(value->addressMode); + printf(")"); + } else + printf("(no value)"); +} + + void +printSymbol(symbol) + symbolTableEntryType *symbol; +{ +/* This table MUST be maintained congruent with the definition of the + enumerated type 'symbolUsageKindType'. */ + static char *symbolUsageTable[] = { + "STRUCT_NAME_SYMBOL", + "STRUCT_FIELD_SYMBOL", + "MACRO_SYMBOL", + "ARGUMENT_SYMBOL", + "LABEL_SYMBOL", + "EXTERNAL_SYMBOL", + "VARIABLE_SYMBOL", + "MVARIABLE_SYMBOL", + "UNKNOWN_SYMBOL", + "DEAD_SYMBOL", + "FUNCTION_SYMBOL", + "BUILT_IN_FUNCTION_SYMBOL", + "NESTED_UNKNOWN_SYMBOL", + "DEFINE_SYMBOL", + "MDEFINE_SYMBOL", + "UNKNOWN_FUNCTION_SYMBOL", + "UNKNOWN_MACRO_SYMBOL", + }; + + nullPrint(symbol); + tab(); printf("(symbol: %s ", symbol->symbolName); + printValue(symbol->context->value); + printf(" %d %s", symbol->context->attributes, + symbolUsageTable[(int)symbol->context->usage]); + if (symbol->context->pushedContexts != NULL) + printf(" ..."); + printf(")\n"); +} + + void +printArgumentDefinitionList(list) + argumentDefinitionListType *list; +{ + nullPrint(list); + tab(); printf("(arguments:\n"); + tablevel++; + while (list != NULL) { + printSymbol(list->theArgument); + list = list->nextArgument; + } + tablevel--; + tab(); printf(")\n"); +} + + void +printBlock(block) + blockType *block; +{ + void printStatement(); + + nullPrint(block); + tab(); printf("(block:\n"); + tablevel++; + printStatement(block); + tablevel--; + tab(); printf(")\n"); +} + + void +printArrayTerm(arrayTerm) + arrayTermType *arrayTerm; +{ + void printIdentifier(); + void printExpression(); + + nullPrint(arrayTerm); + tab(); printf("(array\n"); + tablevel++; + printExpression(arrayTerm->arrayName); + printExpression(arrayTerm->arrayIndex); + tablevel--; + tab(); printf(")\n"); +} + + void +printAssignmentTerm(assignmentTerm) + binopTermType *assignmentTerm; +{ + void printExpression(); + + nullPrint(assignmentTerm); + tab(); printf("(assignment ["); + printAssignmentKind(assignmentTerm->binop); + printf("]\n"); + tablevel++; + printExpression(assignmentTerm->leftArgument); + printExpression(assignmentTerm->rightArgument); + tablevel--; + tab(); printf(")\n"); +} + + void +printBinopTerm(binopTerm) + binopTermType *binopTerm; +{ + void printIdentifier(); + void printExpression(); + + nullPrint(binopTerm); + tab(); printf("(binop ["); + printToken(binopTerm->binop); + printf("]\n"); + tablevel++; + printExpression(binopTerm->leftArgument); + if (binopTerm->binop == SELECT) + printIdentifier(binopTerm->rightArgument); + else + printExpression(binopTerm->rightArgument); + tablevel--; + tab(); printf(")\n"); +} + + void +printFunctionCall(functionCall) + functionCallTermType *functionCall; +{ + void printOperandList(); + + nullPrint(functionCall); + tab(); printf("(function call %s\n", functionCall->functionName-> + symbolName); + tablevel++; + printOperandList(functionCall->parameters); + tablevel--; + tab(); printf(")\n"); +} + + void +printHere() +{ + tab(); printf("(here)\n"); +} + + void +printIdentifier(identifier) + symbolTableEntryType *identifier; +{ + nullPrint(identifier); + printSymbol(identifier); +} + + void +printNumber(number) + numberTermType number; +{ + tab(); printf("(number: %d)\n", number); +} + + void +printPostopTerm(postopTerm) + postOpTermType *postopTerm; +{ + nullPrint(postopTerm); + tab(); printf("(postop ["); + printToken(postopTerm->postOp); + printf("]\n"); + tablevel++; + printExpression(postopTerm->postOpArgument); + tablevel--; + tab(); printf(")\n"); +} + + void +printPreopTerm(preopTerm) + preOpTermType *preopTerm; +{ + nullPrint(preopTerm); + tab(); printf("(preop ["); + printToken(preopTerm->preOp); + printf("]\n"); + tablevel++; + printExpression(preopTerm->preOpArgument); + tablevel--; + tab(); printf(")\n"); +} + + void +printUnopTerm(unopTerm) + unopTermType *unopTerm; +{ + void printExpression(); + + nullPrint(unopTerm); + tab(); printf("(unop ["); + printToken(unopTerm->unop); + printf("]\n"); + tablevel++; + printExpression(unopTerm->unopArgument); + tablevel--; + tab(); printf(")\n"); +} + + void +printExpression(expression) + expressionType *expression; +{ + nullPrint(expression); + tab(); printf("(expression: ["); + printExpressionKind(expression->kindOfTerm); + printf("]\n"); + tablevel++; + switch (expression->kindOfTerm) { + + case ARRAY_EXPR: + printArrayTerm(expression->expressionTerm); + break; + + case ASSIGN_EXPR: + printAssignmentTerm(expression->expressionTerm); + break; + + case BINOP_EXPR: + printBinopTerm(expression->expressionTerm); + break; + + case CONDITION_CODE_EXPR: + printCondition(expression->expressionTerm); + break; + + case FUNCTION_CALL_EXPR: + printFunctionCall(expression->expressionTerm); + break; + + case HERE_EXPR: + printHere(); + break; + + case IDENTIFIER_EXPR: + printIdentifier(expression->expressionTerm); + break; + + case NUMBER_EXPR: + printNumber(expression->expressionTerm); + break; + + case POSTOP_EXPR: + printPostopTerm(expression->expressionTerm); + break; + + case PREOP_EXPR: + printPreopTerm(expression->expressionTerm); + break; + + case STRING_EXPR: + tab(); printf("%s\n", expression->expressionTerm); + break; + + case SUBEXPRESSION_EXPR: + printExpression(expression->expressionTerm); + break; + + case UNOP_EXPR: + printUnopTerm(expression->expressionTerm); + break; + + case VALUE_EXPR: + printValue(expression->expressionTerm); + break; + + default: + printf("eh? funny expression kind %d\n", + expression->kindOfTerm); + break; + } + tablevel--; + tab(); printf(")\n"); +} + + void +printExpressionList(expressionList) + expressionListType *expressionList; +{ + while (expressionList != NULL) { + printExpression(expressionList->theExpression); + expressionList = expressionList->nextExpression; + } +} + + void +printIdentifierList(identifierList) + identifierListType *identifierList; +{ + nullPrint(identifierList); + printSymbol(identifierList->theSymbol); + if (identifierList->nextIdentifier != NULL) + printIdentifierList(identifierList->nextIdentifier); +} + + +/* + These routines collectively print statements and statement fragments. + */ + + void +printCase(aCase) + caseType *aCase; +{ + tab(); printf("(case:\n"); tablevel++; + if (aCase->caseTags == NULL) { + tab(); printf("(default case)\n"); + } else { + printExpressionList(aCase->caseTags); + } + tablevel--; + tab(); printf(")\n"); + tab(); printf("(body:\n"); tablevel++; + printBlock(aCase->caseBody); + tablevel--; + tab(); printf(")\n"); +} + + void +printCaseList(caseList) + caseListType *caseList; +{ + tab(); printf("(cases:\n"); + tablevel++; + while (caseList != NULL) { + printCase(caseList->theCase); + caseList = caseList->nextCase; + } + tablevel--; + tab(); printf(")\n"); +} + + void +printMacro(macroInstruction) + macroTableEntryType *macroInstruction; +{ + nullPrint(macroInstruction); + tab(); printf("(macro: %s)\n", macroInstruction->macroName); +} + + void +printOpcode(opcode) + opcodeTableEntryType *opcode; +{ + nullPrint(opcode); + tab(); printf("(opcode: %s)\n", opcode->mnemonic); +} + + void +printOperandList(operandList) + operandListType *operandList; +{ + nullPrint(operandList); + printOperand(operandList); + if (operandList->nextOperand != NULL) + printOperandList(operandList->nextOperand); +} + + void +printAlignStatement(alignStatement) + alignStatementBodyType *alignStatement; +{ + nullPrint(alignStatement); + printExpression(alignStatement); +} + + void +printAssertStatement(assertStatement) + assertStatementBodyType *assertStatement; +{ + nullPrint(assertStatement); + printExpression(assertStatement->condition); + printExpression(assertStatement->message); +} + + void +printBlockStatement(blockStatement) + blockStatementBodyType *blockStatement; +{ + nullPrint(blockStatement); + printExpressionList(blockStatement); +} + + void +printByteStatement(byteStatement) + byteStatementBodyType *byteStatement; +{ + nullPrint(byteStatement); + printExpressionList(byteStatement); +} + + void +printConstrainStatement(constrainStatement) + constrainStatementBodyType *constrainStatement; +{ + nullPrint(constrainStatement); + printExpression(constrainStatement->constraint); + printBlock(constrainStatement->constrainedBlock); +} + + void +printDbyteStatement(dbyteStatement) + dbyteStatementBodyType *dbyteStatement; +{ + nullPrint(dbyteStatement); + printExpressionList(dbyteStatement); +} + + void +printDefineStatement(defineStatement) + defineStatementBodyType *defineStatement; +{ + nullPrint(defineStatement); + printSymbol(defineStatement->theSymbol); + printExpression(defineStatement->theValue); +} + + void +printDoUntilStatement(doUntilStatement) + doUntilStatementBodyType *doUntilStatement; +{ + nullPrint(doUntilStatement); + printBlock(doUntilStatement->doUntilLoop); + tab(); printf("(condition: "); + printCondition(doUntilStatement->doUntilCondition); + printf(")\n"); +} + + void +printDoWhileStatement(doWhileStatement) + doWhileStatementBodyType *doWhileStatement; +{ + nullPrint(doWhileStatement); + printBlock(doWhileStatement->doWhileLoop); + tab(); printf("(condition: "); + printCondition(doWhileStatement->doWhileCondition); + printf(")\n"); +} + + void +printExternStatement(externStatement) + externStatementBodyType *externStatement; +{ + nullPrint(externStatement); + printIdentifierList(externStatement); +} + + void +printFreturnStatement(freturnStatement) + freturnStatementBodyType *freturnStatement; +{ + nullPrint(freturnStatement); + printExpression(freturnStatement); +} + + void +printFunctionStatement(functionStatement) + functionStatementBodyType *functionStatement; +{ + nullPrint(functionStatement); + tab();printf("(function name: %s)\n",functionStatement->functionName); + printArgumentDefinitionList(functionStatement->theArguments); + printBlock(functionStatement->theBlock); +} + + void +printIfStatement(ifStatement) + ifStatementBodyType *ifStatement; +{ + nullPrint(ifStatement); + tab(); printf("(condition: "); + printCondition(ifStatement->ifCondition); + printf(")\n"); + printBlock(ifStatement->consequence); + tab(); printf("(else:\n"); + tablevel++; + printIfStatement(ifStatement->continuation); + tablevel--; + tab(); printf(")\n"); +} + + void +printIncludeStatement(includeStatement) + includeStatementBodyType *includeStatement; +{ + nullPrint(includeStatement); + printExpression(includeStatement); +} + + void +printInstructionStatement(instructionStatement) + instructionStatementBodyType *instructionStatement; +{ + nullPrint(instructionStatement); + switch(instructionStatement->kindOfInstruction) { + case OPCODE_INSTRUCTION: + printOpcode(instructionStatement->theInstruction); + break; + + case MACRO_INSTRUCTION: + printMacro(instructionStatement->theInstruction); + break; + + default: + printf("huh? instruction type=%d\n", instructionStatement-> + kindOfInstruction); + break; + } + printOperandList(instructionStatement->theOperands); +} + + void +printLongStatement(longStatement) + longStatementBodyType *longStatement; +{ + nullPrint(longStatement); + printExpressionList(longStatement); +} + + void +printMacroStatement(macroStatement) + macroStatementBodyType *macroStatement; +{ + nullPrint(macroStatement); + tab(); printf("(macro name: %s)\n", macroStatement->theMacro); + printArgumentDefinitionList(macroStatement->theArguments); + printBlock(macroStatement->theBlock); +} + + void +printMdefineStatement(mdefineStatement) + defineStatementBodyType *mdefineStatement; +{ + nullPrint(mdefineStatement); + printSymbol(mdefineStatement->theSymbol); + printExpression(mdefineStatement->theValue); +} + + void +printMdoUntilStatement(mdoUntilStatement) + mdoUntilStatementBodyType *mdoUntilStatement; +{ + nullPrint(mdoUntilStatement); + printBlock(mdoUntilStatement->mdoUntilLoop); + printExpression(mdoUntilStatement->mdoUntilCondition); +} + + void +printMdoWhileStatement(mdoWhileStatement) + mdoWhileStatementBodyType *mdoWhileStatement; +{ + nullPrint(mdoWhileStatement); + printBlock(mdoWhileStatement->mdoWhileLoop); + printExpression(mdoWhileStatement->mdoWhileCondition); +} + + void +printMforStatement(mforStatement) + mforStatementBodyType *mforStatement; +{ + nullPrint(mforStatement); + printExpression(mforStatement->initExpression); + printExpression(mforStatement->testExpression); + printExpression(mforStatement->incrExpression); + printBlock(mforStatement->forLoop); +} + + void +printMifStatement(mifStatement) + mifStatementBodyType *mifStatement; +{ + nullPrint(mifStatement); + printExpression(mifStatement->mifCondition); + printBlock(mifStatement->mifConsequence); + tab(); printf("(melse:\n"); + tablevel++; + printMifStatement(mifStatement->mifContinuation); + tablevel--; + tab(); printf(")\n"); +} + + void +printMswitchStatement(mswitchStatement) + mswitchStatementBodyType *mswitchStatement; +{ + nullPrint(mswitchStatement); + printExpression(mswitchStatement->switchExpression); + printCaseList(mswitchStatement->cases); +} + + void +printMvariableStatement(mvariableStatement) + mvariableStatementBodyType *mvariableStatement; +{ + nullPrint(mvariableStatement); + printSymbol(mvariableStatement->theSymbol); + printExpression(mvariableStatement->theValue); +} + + void +printMwhileStatement(mwhileStatement) + mwhileStatementBodyType *mwhileStatement; +{ + nullPrint(mwhileStatement); + printExpression(mwhileStatement->mwhileCondition); + printBlock(mwhileStatement->mwhileLoop); +} + + void +printOrgStatement(orgStatement) + orgStatementBodyType *orgStatement; +{ + nullPrint(orgStatement); + printExpression(orgStatement); +} + + void +printPerformStatement(performStatement) + performStatementBodyType *performStatement; +{ + nullPrint(performStatement); + printExpression(performStatement); +} + + void +printRelStatement(relStatement) + relStatementBodyType *relStatement; +{ + /* there's nothing here... */ +} + + void +printStartStatement(startStatement) + startStatementBodyType *startStatement; +{ + nullPrint(startStatement); + printExpression(startStatement); +} + + void +printStringStatement(stringStatement) + stringStatementBodyType *stringStatement; +{ + nullPrint(stringStatement); + printExpressionList(stringStatement); +} + + void +printStructStatement(structStatement) + structStatementBodyType *structStatement; +{ + nullPrint(structStatement); + printSymbol(structStatement->structName); + printBlock(structStatement->structBody); +} + + void +printTargetStatement(targetStatement) + targetStatementBodyType *targetStatement; +{ + nullPrint(targetStatement); + printExpression(targetStatement); +} + + void +printUndefineStatement(undefineStatement) + undefineStatementBodyType *undefineStatement; +{ + nullPrint(undefineStatement); + printIdentifierList(undefineStatement); +} + + void +printVariableStatement(variableStatement) + variableStatementBodyType *variableStatement; +{ + nullPrint(variableStatement); + printSymbol(variableStatement->theSymbol); + printExpression(variableStatement->theValue); +} + + void +printWhileStatement(whileStatement) + whileStatementBodyType *whileStatement; +{ + nullPrint(whileStatement); + tab(); printf("(condition: "); + printCondition(whileStatement->whileCondition); + printf(")\n"); + printBlock(whileStatement->whileLoop); +} + + void +printWordStatement(wordStatement) + wordStatementBodyType *wordStatement; +{ + nullPrint(wordStatement); + printExpressionList(wordStatement); +} + + void +printLabelList(labelList) + labelListType *labelList; +{ + nullPrint(labelList); + tab(); printf("(\n"); + tablevel++; + while (labelList != NULL) { + printSymbol(labelList->theLabel); + labelList = labelList->nextLabel; + } + tablevel--; + tab(); printf(")\n"); +} + + void +printStatementBody(kind, body) + statementKindType kind; + statementBodyType body; +{ + switch (kind) { + + case ALIGN_STATEMENT: + printAlignStatement(body); + break; + + case ASSERT_STATEMENT: + printAssertStatement(body); + break; + + case BLOCK_STATEMENT: + printBlockStatement(body); + break; + + case BYTE_STATEMENT: + printByteStatement(body); + break; + + case CONSTRAIN_STATEMENT: + printConstrainStatement(body); + break; + + case DBYTE_STATEMENT: + printDbyteStatement(body); + break; + + case DEFINE_STATEMENT: + printDefineStatement(body); + break; + + case DO_UNTIL_STATEMENT: + printDoUntilStatement(body); + break; + + case DO_WHILE_STATEMENT: + printDoWhileStatement(body); + break; + + case EXTERN_STATEMENT: + printExternStatement(body); + break; + + case FRETURN_STATEMENT: + printFreturnStatement(body); + break; + + case FUNCTION_STATEMENT: + printFunctionStatement(body); + break; + + case GROUP_STATEMENT: + printBlock(body); + break; + + case IF_STATEMENT: + printIfStatement(body); + break; + + case INCLUDE_STATEMENT: + printIncludeStatement(body); + break; + + case INSTRUCTION_STATEMENT: + printInstructionStatement(body); + break; + + case LONG_STATEMENT: + printLongStatement(body); + break; + + case MACRO_STATEMENT: + printMacroStatement(body); + break; + + case MDEFINE_STATEMENT: + printMdefineStatement(body); + break; + + case MDO_UNTIL_STATEMENT: + printMdoUntilStatement(body); + break; + + case MDO_WHILE_STATEMENT: + printMdoWhileStatement(body); + break; + + case MFOR_STATEMENT: + printMforStatement(body); + break; + + case MIF_STATEMENT: + printMifStatement(body); + break; + + case MSWITCH_STATEMENT: + printMswitchStatement(body); + break; + + case MVARIABLE_STATEMENT: + printMvariableStatement(body); + break; + + case MWHILE_STATEMENT: + printMwhileStatement(body); + break; + + case NULL_STATEMENT: + /* do nothing */ + break; + + case ORG_STATEMENT: + printOrgStatement(body); + break; + + case PERFORM_STATEMENT: + printPerformStatement(body); + break; + + case REL_STATEMENT: + printRelStatement(body); + break; + + case START_STATEMENT: + printStartStatement(body); + break; + + case STRING_STATEMENT: + printStringStatement(body); + break; + + case STRUCT_STATEMENT: + printStructStatement(body); + break; + + case TARGET_STATEMENT: + printTargetStatement(body); + break; + + case UNDEFINE_STATEMENT: + printUndefineStatement(body); + break; + + case VARIABLE_STATEMENT: + printVariableStatement(body); + break; + + case WHILE_STATEMENT: + printWhileStatement(body); + break; + + case WORD_STATEMENT: + printWordStatement(body); + break; + + default: + printf("Say what? statement kind=%d\n", kind); + break; + } +} + + void +printStatement(statement) + statementType *statement; +{ + nullPrint(statement); + tab(); printf("(statement["); + printStatementKind(statement->kindOfStatement); + printf("]: \n"); + tablevel++; + printLabelList(statement->labels); + printStatementBody(statement->kindOfStatement, + statement->statementBody); + tablevel--; + tab(); printf(")\n"); + if (statement->nextStatement != NULL) + printStatement(statement->nextStatement); +} + +/* + Other debug print routines. + */ + + void +printPendingFixupList(fixupList) + fixupListType *fixupList; +{ + printf("fixup list: ("); + tablevel++; + while (fixupList != NULL) { + printExpression(fixupList->theFixupExpression); + fixupList = fixupList->nextFixup; + } + tablevel--; + printf(")\n"); +} + + void +printCreateFixup(expression, location, kindOfFixup) + expressionType *expression; + addressType location; + fixupKindType kindOfFixup; +{ + static char *fixupStringTable[] = { + "BYTE FIXUP", + "WORD FIXUP", + "NO FIXUP", + "OPERAND FIXUP", + "BYTE RELATIVE FIXUP", + "DBYTE FIXUP", + "NO FIXUP (OK)", + "LONG FIXUP", + "WORD RELATIVE FIXUP", + }; + + printf("created fixup: expr=0x%x at 0x%x (%s)\n", expression, + location, fixupStringTable[(int)kindOfFixup]); +} + + +/* + Print internal code buffers. + */ + + void +printExpressionBuffer() +{ + int line; + int i; + + printf("expression length = %d:\n", expressionBufferSize); + for (line=0; linecodeStartAddress); + end = bufferPosition(codeSegment->codeEndAddress); + + printf("buffer 0x%x:\n", bufferNum*CODE_BUFFER_SIZE); + for (line=0; lineend){ + /* skip it -- no code here */ + } else { + printf(" %4x:", bufferNum*CODE_BUFFER_SIZE + line); + for (i=line; iend) + printf(" "); + else + printf(" %2x", (*(codeSegment->codeBuffer))[i]); + } + printf("\n"); + } + } +} + + void +printCodeBufferSection(codeBufferSection) + codeRegionType *codeBufferSection; +{ + bool anyCodeThereFlag; + int i; + + anyCodeThereFlag = FALSE; + for (i=0; icodeSegments[i] != NULL) { + printOneCodeBuffer(codeBufferSection->codeSegments[i], + i); + anyCodeThereFlag = TRUE; + } + if (!anyCodeThereFlag) + printf("no code in section\n"); + printf("\n"); +} + + void +printCodeBuffers() +{ + printf("absolute code:\n"); + printCodeBufferSection(&absoluteCodeRegion); + printf("relocatable code:\n"); + printCodeBufferSection(&relocatableCodeRegion); +} diff --git a/debugPrint.o b/debugPrint.o new file mode 100644 index 0000000000000000000000000000000000000000..12aa40cd4626cfac3dcdc923f28755c3326f6e4b GIT binary patch literal 72623 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 literal 0 HcmV?d00001 diff --git a/debugPrintSD.o b/debugPrintSD.o new file mode 100644 index 0000000000000000000000000000000000000000..3b4d4535759759eaa1bf6b6c99cc68c7d042b43f GIT binary patch literal 39082 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 literal 0 HcmV?d00001 diff --git a/debugPrintSD_6502.c b/debugPrintSD_6502.c new file mode 100644 index 0000000..5b3f5b0 --- /dev/null +++ b/debugPrintSD_6502.c @@ -0,0 +1,249 @@ +/* + debugPrintSD_6502.c -- Routines to print out things for debugging + purposes (system dependent routines, 6502 version). + + Chip Morningstar -- Lucasfilm Ltd. + + 23-April-1985 + +*/ + +#include "macrossTypes.h" +#include "macrossGlobals.h" +#include "y.tab.h" + + +int tablevel; + +/* Fundamental nop print operation */ +#define nullPrint(thing) if (thing==NULL) { tab(); printf("()\n"); return; } + + void +printCondition(condition) + conditionType condition; +{ +/* This table MUST be maintained congruently with the definition of the + enumerated type 'conditionType'. */ + static char *conditionTable[] = { + "carry", + "zero", + "negative", + "overflow", + "lt", + "leq", + "slt", + "sleq", + "always", + "!carry", + "!zero", + "!negative", + "!overflow", + "geq", + "gt", + "sgeq", + "sgt", + "never", + }; + + printf("%s", conditionTable[(int)condition]); +} + + void +printOperandKind(kind) + operandKindType kind; +{ +/* This table MUST be maintained congruently with the definition of the + enumerated type 'operandKindType'. */ + static char *operandKindTable[] = { + "expression opnd", + "immediate opnd", + "indirect opnd", + "a register opnd", + "x register opnd", + "y register opnd", + "post indexed y opnd", + "pre indexed x opnd", + "x indexed opnd", + "y indexed opnd", + "x selected opnd", + "y selected opnd", + "pre selected x opnd", + "string opnd", + "block opnd", + }; + + printf("%s", operandKindTable[(int)kind]); +} + + void +printToken(token) + int token; +{ +/* This table MUST be maintained congruently with the set of '#define's in + the file 'y.tab.h' as produced by yacc. */ + static char *tokenTable[] = { + "A", + "ALIGN", + "ASSERT", + "BLOCK", + "BYTE", + "CONSTRAIN", + "DBYTE", + "DEFINE", + "DO", + "ELSE", + "ELSEIF", + "ENDFILE", + "EOL", + "EXTERN", + "FRETURN", + "FUNCTION", + "HERE", + "IF", + "INCLUDE", + "LONG", + "MACRO", + "MCASE", + "MDEFAULT", + "MDEFINE", + "MDO", + "MELSE", + "MELSEIF", + "MFOR", + "MIF", + "MSWITCH", + "MUNTIL", + "MVARIABLE", + "MWHILE", + "ORG", + "REL", + "START", + "STRING", + "STRUCT", + "TARGET", + "UNDEFINE", + "UNTIL", + "VARIABLE", + "WHILE", + "WORD", + "X", + "Y", + "ConditionCode", + "Identifier", + "MacroName", + "Number", + "Opcode", + "TextString", + "ASSIGN", + "LOGICAL_OR", + "LOGICAL_XOR", + "LOGICAL_AND", + "BITWISE_OR", + "BITWISE_XOR", + "BITWISE_AND", + "EQUAL_TO", + "NOT_EQUAL_TO", + "LESS_THAN", + "LESS_THAN_OR_EQUAL_TO", + "GREATER_THAN", + "GREATER_THAN_OR_EQUAL_TO", + "LEFT_SHIFT", + "RIGHT_SHIFT", + "ADD", + "SUB", + "MUL", + "DIV", + "MOD", + "UNARY_MINUS", + "LOGICAL_NOT", + "BITWISE_NOT", + "HI_BYTE", + "LO_BYTE", + "SELECT", + "INCREMENT", + "DECREMENT", + }; + + if (token >= A) { + printf("%s", tokenTable[token - A]); + } else { + printf("'%c'", token); + } +} + + void +printOperand(operand) + operandType *operand; +{ + nullPrint(operand); + tab(); printf("(operand: ["); + printOperandKind(operand->kindOfOperand); + printf("]\n"); + tablevel++; + switch (operand->kindOfOperand) { + + case EXPRESSION_OPND: + printExpression(operand->theOperand); + break; + + case IMMEDIATE_OPND: + printExpression(operand->theOperand); + break; + + case INDIRECT_OPND: + printExpression(operand->theOperand); + break; + + case A_REGISTER_OPND: + break; + + case X_REGISTER_OPND: + break; + + case Y_REGISTER_OPND: + break; + + case POST_INDEXED_Y_OPND: + printExpression(operand->theOperand); + break; + + case PRE_INDEXED_X_OPND: + printExpression(operand->theOperand); + break; + + case X_INDEXED_OPND: + printExpression(operand->theOperand); + break; + + case Y_INDEXED_OPND: + printExpression(operand->theOperand); + break; + + case X_SELECTED_OPND: + printIdentifierList(operand->theOperand); + break; + + case Y_SELECTED_OPND: + printIdentifierList(operand->theOperand); + break; + + case PRE_SELECTED_X_OPND: + printIdentifierList(operand->theOperand); + break; + + case STRING_OPND: + tab(); printf("(string: \"%s\")\n", operand->theOperand); + break; + + case BLOCK_OPND: + printBlock(operand->theOperand); + break; + + default: + printf("fooey: bad operand kind %d\n", operand-> + kindOfOperand); + break; + } + tablevel--; + tab(); printf(")\n"); +} diff --git a/debugPrintSD_68000.c b/debugPrintSD_68000.c new file mode 100644 index 0000000..0196caf --- /dev/null +++ b/debugPrintSD_68000.c @@ -0,0 +1,309 @@ +/* + debugPrintSD_68000.c -- Routines to print out things for debugging + purposes (system dependent routines, 68000 version). + + Chip Morningstar -- Lucasfilm Ltd. + + 26-April-1985 + +*/ + +#include "macrossTypes.h" +#include "macrossGlobals.h" +#include "y.tab.h" + + +int tablevel; + +/* Fundamental nop print operation */ +#define nullPrint(thing) if (thing==NULL) { tab(); printf("()\n"); return; } + + void +printCondition(condition) + conditionType condition; +{ +/* This table MUST be maintained congruently with the definition of the + enumerated type 'conditionType'. */ + static char *conditionTable[] = { + "carry", + "equal", + "overflow", + "minus", + "lt", + "leq", + "ls", + "always", + "!carry", + "!equal", + "!overflow", + "plus", + "geq", + "gt", + "high", + "never", + }; + + printf("%s", conditionTable[(int)condition]); +} + + void +printRegister(reg) + int reg; +{ + if (reg < 8) + printf(" a%d", reg); + else + printf(" d%d", reg - 8); +} + + void +printControlRegister(reg) + int reg; +{ + switch (reg) { + case SFC_REGISTER: printf("sfc"); break; + case DFC_REGISTER: printf("dfc"); break; + case VBR_REGISTER: printf("vbr"); break; + default: botch("Bad control register %d\n", reg); break; + } +} + + void +printOperandKind(kind) + operandKindType kind; +{ +/* This table MUST be maintained congruently with the definition of the + enumerated type 'operandKindType'. */ + static char *operandKindTable[] = { + "expression opnd", + "string opnd", + "block opnd", + "data register opnd", + "address register opnd", + "address register indirect opnd", + "postincrement opnd", + "predecrement opnd", + "displacement opnd", + "indexed opnd", + "program counter displacement opnd", + "program counter indexed opnd", + "immediate opnd", + "absolute short opnd", + "absolute long opnd", + "condition code register opnd", + "status register opnd", + "user stack pointer opnd", + "control register opnd", + }; + + printf("%s", operandKindTable[(int)operandKindField(kind)]); + if (isRegisterOperand(kind)) + printRegister(getRegister(kind)); + if (isControlRegisterOperand(kind)) + printControlRegister(getRegister(kind)); + if (isIndexedOperand(kind)) + printRegister(getIndexRegister(kind)); +} + + bool +isRegisterOperand(kind) + operandKindType kind; +{ + kind = operandKindField(kind); + return(kind==D_REGISTER_OPND || kind==A_REGISTER_OPND || + kind==A_REGISTER_INDIRECT_OPND || kind==POSTINCREMENT_OPND || + kind==PREDECREMENT_OPND || kind==DISPLACEMENT_OPND || + kind==INDEXED_OPND || kind==SELECTED_OPND || + kind==INDEX_SELECTED_OPND); +} + + bool +isIndexedOperand(kind) + operandKindType kind; +{ + kind = operandKindField(kind); + return(kind==INDEXED_OPND || kind==PC_INDEXED_OPND || kind== + INDEX_SELECTED_OPND); +} + + bool +isControlRegisterOperand(kind) + operandKindType kind; +{ + return(operandKindField(kind) == CONTROL_REGISTER_OPND); +} + + void +printToken(token) + int token; +{ +/* This table MUST be maintained congruently with the set of '#define's in + the file 'y.tab.h' as produced by yacc. */ + static char *tokenTable[] = { + "A0", + "A1", + "A2", + "A3", + "A4", + "A5", + "A6", + "A7", + "ALIGN", + "ASSERT", + "BLOCK", + "BYTE", + "CCR", + "CONSTRAIN", + "D0", + "D1", + "D2", + "D3", + "D4", + "D5", + "D6", + "D7", + "DBYTE", + "DEFINE", + "DFC", + "DO", + "ELSE", + "ELSEIF", + "ENDFILE", + "EOL", + "EXTERN", + "FRETURN", + "FUNCTION", + "HERE", + "IF", + "INCLUDE", + "L", + "LONG", + "MACRO", + "MCASE", + "MDEFAULT", + "MDEFINE", + "MDO", + "MELSE", + "MELSEIF", + "MFOR", + "MIF", + "MSWITCH", + "MUNTIL", + "MVARIABLE", + "MWHILE", + "ORG", + "PC", + "REL", + "SFC", + "SR", + "START", + "STRING", + "STRUCT", + "TARGET", + "UNDEFINE", + "UNTIL", + "USP", + "VARIABLE", + "VBR", + "W", + "WHILE", + "WORD", + "X", + "Y", + "ConditionCode", + "Identifier", + "MacroName", + "Number", + "Opcode", + "TextString", + "ASSIGN", + "LOGICAL_OR", + "LOGICAL_XOR", + "LOGICAL_AND", + "BITWISE_OR", + "BITWISE_XOR", + "BITWISE_AND", + "EQUAL_TO", + "NOT_EQUAL_TO", + "LESS_THAN", + "LESS_THAN_OR_EQUAL_TO", + "GREATER_THAN", + "GREATER_THAN_OR_EQUAL_TO", + "LEFT_SHIFT", + "RIGHT_SHIFT", + "ADD", + "SUB", + "MUL", + "DIV", + "MOD", + "UNARY_MINUS", + "LOGICAL_NOT", + "BITWISE_NOT", + "HI_BYTE", + "LO_BYTE", + "SELECT", + "INCREMENT", + "DECREMENT", + }; + + if (token >= A0) { + printf("%s", tokenTable[token - A0]); + } else { + printf("'%c'", token); + } +} + + void +printOperand(operand) + operandType *operand; +{ + nullPrint(operand); + tab(); printf("(operand: ["); + printOperandKind(operand->kindOfOperand); + printf("]\n"); + tablevel++; + switch (operand->kindOfOperand) { + + case EXPRESSION_OPND: + case DISPLACEMENT_OPND: + case INDEXED_OPND: + case PC_DISPLACEMENT_OPND: + case PC_INDEXED_OPND: + case IMMEDIATE_OPND: + case ABSOLUTE_SHORT_OPND: + case ABSOLUTE_LONG_OPND: + printExpression(operand->theOperand); + break; + + case D_REGISTER_OPND: + case A_REGISTER_OPND: + case A_REGISTER_INDIRECT_OPND: + case POSTINCREMENT_OPND: + case PREDECREMENT_OPND: + case CC_REGISTER_OPND: + case STATUS_REGISTER_OPND: + case USP_REGISTER_OPND: + case CONTROL_REGISTER_OPND: + break; + + case SELECTED_OPND: + case INDEX_SELECTED_OPND: + printIdentifierList(operand->theOperand); + break; + + case STRING_OPND: + tab(); printf("(string: \"%s\")\n", operand->theOperand); + break; + + case BLOCK_OPND: + printBlock(operand->theOperand); + break; + + default: + printf("fooey: bad operand kind %d\n", operand-> + kindOfOperand); + break; + } + tablevel--; + tab(); printf(")\n"); +} diff --git a/doc/genmacros.itr b/doc/genmacros.itr new file mode 100644 index 0000000..2e3efc7 --- /dev/null +++ b/doc/genmacros.itr @@ -0,0 +1,463 @@ +.TL +\s+9genmacros.m\s-9 +.AU +a macro library for use with the 6502 version of Macross +.AI +Lucasfilm Ltd. Games Division +\\*(DY +.ds LH genmacros.m +.ds CH \\*(DY +.ds RH Reference Manual +.ds LF Lucasfilm Ltd. Proprietary Information +.ds CF - % - +.ds RF CONFIDENTIAL +.PP +These macros have been concocted by various people for the convenience and +amusement of those programming the 6502 using \fIMacross\fR. The will be +found in the file \fB/u1/gg/lib/6502/genmacros.m\fR. To use them, insert the +following statement somewhere near the beginning of your \fIMacross\fR +program: +.nf + + \fBinclude "/u1/gg/lib/6502/genmacros.m"\fR + +.fi +Easy, no? What follows is a summary of the macros, grouped roughly by +category. +.sp 1 +.SH +\s+2Macros to save and restore registers\s-2 +.nf + +\fBphr\fR +.fi +.IP +Push all registers (i.e., the accumulator and the X and Y index registers) +onto the stack. +.LP +.nf + +\fBplr\fR +.fi +.IP +Pull the registers (the accumulator and the X and Y index registers) off the +stack. +.LP +.nf + +\fBphx\fR +.fi +.IP +Push the X register onto the stack. +.LP +.nf + +\fBplx\fR +.fi +.IP +Pull the X register off of the stack. +.LP +.nf + +\fBphy\fR +.fi +.IP +Push the Y register onto the stack. +.LP +.nf + +\fBply\fR +.fi +.IP +Pull the Y register off of the stack. +.LP +.nf + +\fBpushaddr \fIaddress\fR +.fi +.IP +Push \fIaddress\fR onto the stack to \fBrts\fR to. +.sp 1 +.SH +\s+2Macros to move data around with\s-2 +.PP +These macros provide an address mode independent method of moving bytes from +one place to another. The source and destination arguments of these macros +may, generally speaking, be in any address mode you desire (except, of course, +that the destination can't be immediate mode!). +.nf + +\fBmovm \fIn\fB, \fIdest\fB, \fIsrc\fR +.fi +.IP +Move multiple \(em move \fIn\fR bytes from \fIsrc\fR to \fIdest\fR. The bytes +are moved using the accumulator as an intermediary. +.LP +.nf + +\fBmovmx \fIn\fB, \fIdest\fB, \fIsrc\fR +.fi +.IP +Move multiple \(em move \fIn\fR bytes from \fIsrc\fR to \fIdest\fR. The bytes +are moved using the X register as an intermediary. +.LP +.nf + +\fBmovmy \fIn\fB, \fIdest\fB, \fIsrc\fR +.fi +.IP +Move multiple \(em move \fIn\fR bytes from \fIsrc\fR to \fIdest\fR. The bytes +are moved using the Y register as an intermediary. +.LP +.nf + +\fBmv2m \fIn\fB, \fIdest1\fB, \fIdest2\fB, \fIsrc\fR +.fi +.IP +Move multiple to two destinations \(em move \fIn\fR bytes from \fIsrc\fR to +both \fIdest1\fR and \fIdest2\fR. The bytes are moved using the acuumulator +as an intermediary. +.LP +.nf + +\fBmoveb \fIsrc\fB, \fIdest\fR +.fi +.IP +Move byte \(em move one byte from \fIsrc\fR to \fIdest\fR via the accumulator. +.LP +.nf + +\fBmovew \fIsrc\fB, \fIdest\fR +.fi +.IP +Move word \(em move one word from \fIsrc\fR to \fIdest\fR via the accumulator. +.LP +.nf + +\fBmovexb \fIsrc\fB, \fIdest\fR +.fi +.IP +Move byte \(em move one byte from \fIsrc\fR to \fIdest\fR via the X register. +.LP +.nf + +\fBmovexw \fIsrc\fB, \fIdest\fR +.fi +.IP +Move word \(em move one word from \fIsrc\fR to \fIdest\fR via the X register. +.LP +.nf + +\fBmoveyb \fIsrc\fB, \fIdest\fR +.fi +.IP +Move byte \(em move one byte from \fIsrc\fR to \fIdest\fR via the Y register. +.LP +.nf + +\fBmoveyw \fIsrc\fB, \fIdest\fR +.fi +.IP +Move word \(em move one word from \fIsrc\fR to \fIdest\fR via the Y register. +.LP +.nf + +\fBmovb \fIdest\fB, \fIsrc\fR +.fi +.IP +Move byte \(em move one byte from \fIsrc\fR to \fIdest\fR via the accumulator. +This is distinguished from \fBmoveb\fR in that it has the order of the +operands reversed. This confusing feature is provided for compatibility with +\fBa65\fR. +.LP +.nf + +\fBmovw \fIdest\fB, \fIsrc\fR +.fi +.IP +Move word \(em move one word from \fIsrc\fR to \fIdest\fR via the accumulator. +This is distinguished from \fBmovew\fR in that it has the order of the +operands reversed. This confusing feature is provided for compatibility with +\fBa65\fR. +.LP +.nf + +\fBclrm \fIn\fB, \fIdest\fR +.fi +.IP +Clear multiple \(em clears (zeros) \fIn\fR bytes starting at \fIdest\fR. +Leaves a zero in the accumulator. +.LP +.nf + +\fBclrb \fIdest\fR +\fBclearb \fIdest\fR +.fi +.IP +Clear byte \(em clears (zeros) one byte at \fIdest\fR. Leaves a zero in the +accumulator. +.LP +.nf + +\fBclrw \fIdest\fR +\fBclearw \fIdest\fR +.fi +.IP +Clear word \(em clears (zeros) one word at \fIdest\fR. Leaves a zero in the +accumulator. +.sp 1 +.SH +\s+2Arithmetic macros\s-2 +.nf + +\fBaddm \fIn\fB, \fIdest\fB, \fIsrc1\fB, \fIsrc2\fR +.fi +.IP +Add multiple \(em adds the \fIn\fR byte numbers found at \fIsrc1\fR and +\fIsrc2\fR and puts the result at \fIdest\fR. Clobbers the accumulator. +.LP +.nf + +\fBaddb \fIdest\fB, \fIsrc1\fB, \fIsrc2\fR +.fi +.IP +Add byte \(em adds the one byte numbers \fIsrc1\fR and \fIsrc2\fR and puts the +one byte result in \fIdest\fR. Clobbers the accumulator. +.LP +.nf + +\fBaddw \fIdest\fB, \fIsrc1\fB, \fIsrc2\fR +.fi +.IP +Add word \(em adds the two byte numbers \fIsrc1\fR and \fIsrc2\fR and puts the +two byte result in \fIdest\fR. Clobbers the accumulator. +.LP +.nf + +\fBsubm \fIn\fB, \fIdest\fB, \fIsrc1\fB, \fIsrc2\fR +.fi +.IP +Subtract multiple \(em subtracts the \fIn\fR byte number found at \fIsrc2\fR +from the same sized number found at \fIsrc1\fR and puts the \fIn\fR byte +result in \fIdest\fR. Clobbers the accumulator. +.LP +.nf + +\fBsubb \fIdest\fB, \fIsrc1\fB, \fIsrc2\fR +.fi +.IP +Subtract byte \(em subtracts the one byte number \fIsrc2\fR from \fIsrc1\fR +and puts the one byte result in \fIdest\fR. Clobbers the accumulator. +.LP +.nf + +\fBsubw \fIdest\fB, \fIsrc1\fB, \fIsrc2\fR +.fi +.IP +Subtract word \(em subtracts the two byte numbers \fIsrc2\fR from \fIsrc1\fR +and puts the two byte result in \fIdest\fR. Clobbers the accumulator. +.LP +.nf + +\fBcmpm \fIn\fB, \fIsrc1\fB, \fIsrc2\fR +.fi +.IP +Compare multiple \(em compares the two \fIn\fR byte numbers found at +\fIsrc1\fR and \fIsrc2\fR. Clobbers the accumulator. +.LP +.nf + +\fBcmpb \fIsrc1\fB, \fIsrc2\fR +.fi +.IP +Compare byte \(em compares the one byte numbers \fIsrc1\fR and \fIsrc2\fR. +Clobbers the accumulator. +.LP +.nf + +\fBcmpw \fIsrc1\fB, \fIsrc2\fR +.fi +.IP +Compare word \(em compares the two byte numbers \fIsrc1\fR and \fIsrc2\fR. +Clobbers the accumulator. +.LP +.nf + +\fBnegm \fIn\fB, \fIdest\fR +.fi +.IP +Negate multiple \(em negates the \fIn\fR byte number at \fIdest\fR. Clobbers +the accumulator. +.LP +.nf + +\fBnegb \fIdest\fR +.fi +.IP +Negate byte \(em negates the one byte number at \fIdest\fR. Clobbers the +accumulator. +.LP +.nf + +\fBnegw \fIdest\fR +.fi +.IP +Negate word \(em negates the two byte number at \fIdest\fR. Clobbers the +accumulator. +.LP +.nf + +\fBasrm \fIn\fB, \fIdest\fR +.fi +.IP +Arithmetic shift right multiple \(em performs a rightward one-bit arithmetic +shift of the \fIn\fR byte number at \fIdest\fR. Clobbers the accumulator. +.LP +.nf + +\fBasrb \fIdest\fR +.fi +.IP +Arithmetic shift right byte \(em performs a rightward one-bit arithmetic +shift of the byte at \fIdest\fR. Clobbers the accumulator. +.LP +.nf + +\fBasrw \fIdest\fR +.fi +.IP +Arithmetic shift right word \(em performs a rightward one-bit arithmetic +shift of the word at \fIdest\fR. Clobbers the accumulator. +.LP +.nf + +\fBaslm \fIn\fB, \fIdest\fR +.fi +.IP +Arithmetic shift left multiple \(em performs a leftward one-bit arithmetic +shift of the \fIn\fR byte number at \fIdest\fR. Clobbers the accumulator. +.LP +.nf + +\fBaslb \fIdest\fR +.fi +.IP +Arithmetic shift left byte \(em performs a leftward one-bit arithmetic +shift of the byte at \fIdest\fR. Clobbers the accumulator. +.LP +.nf + +\fBaslw \fIdest\fR +.fi +.IP +Arithmetic shift left word \(em performs a leftward one-bit arithmetic +shift of the word at \fIdest\fR. Clobbers the accumulator. +.LP +.nf + +\fBlsrm \fIn\fB, \fIdest\fR +.fi +.IP +Logical shift right multiple \(em performs a rightward one-bit logical shift +of the \fIn\fR byte number at \fIdest\fR. Clobbers the accumulator. +.LP +.nf + +\fBlsrb \fIdest\fR +.fi +.IP +Logical shift right byte \(em performs a rightward one-bit logical shift of +the byte at \fIdest\fR. Clobbers the accumulator. +.LP +.nf + +\fBlsrw \fIdest\fR +.fi +.IP +Logical shift right word \(em performs a rightward one-bit logical shift of +the word at \fIdest\fR. Clobbers the accumulator. +.SH +.sp 1 +\s+2Flow-of-control macros\s-2 +.nf + +\fBrepeat \fIn\fB { \fIcode\fB }\fR +.fi +.IP +Replicates the block of \fIMacross\fR statements \fIcode\fR \fIn\fR times. +.LP +.nf + +\fBloop \fIcounter\fB, \fIstart\fB, \fIend\fB { \fIcode\fB }\fR +.fi +.IP +Generic ``do-loop'' \(em generates 6502 code for a loop that initializes +\fIcounter\fR to \fIstart\fR, and then repeatedly executes \fIcode\fR, +incrementing \fIcounter\fR until it reaches the value \fIend\fR. +\fICounter\fR may be ``\fBx\fR'' to denote the X index register, ``\fBy\fR'' +to denote the Y index register, or a memory location. \fIStart\fR and +\fIend\fR may be referenced in any 6502 address mode. +.SH +.sp 1 +\s+2Miscellaneous macros\s-2 +.nf + +\fBmbyte \fIn\fR +.fi +.IP +Generates \fIn\fR zero data bytes. +.bp +.CD +\s+5\fBAppendix \*- Summary of the macros\fR\s-5 +.DE +.LP +.nf + \fBaddb \fIdest\fB, \fIsrc1\fB, \fIsrc2\fR + \fBaddm \fIn\fB, \fIdest\fB, \fIsrc1\fB, \fIsrc2\fR + \fBaddw \fIdest\fB, \fIsrc1\fB, \fIsrc2\fR + \fBaslb \fIdest\fR + \fBaslm \fIn\fB, \fIdest\fR + \fBaslw \fIdest\fR + \fBasrb \fIdest\fR + \fBasrm \fIn\fB, \fIdest\fR + \fBasrw \fIdest\fR + \fBclearb \fIdest\fR + \fBclearw \fIdest\fR + \fBclrb \fIdest\fR + \fBclrm \fIn\fB, \fIdest\fR + \fBclrw \fIdest\fR + \fBcmpb \fIsrc1\fB, \fIsrc2\fR + \fBcmpm \fIn\fB, \fIsrc1\fB, \fIsrc2\fR + \fBcmpw \fIsrc1\fB, \fIsrc2\fR + \fBloop \fIcounter\fB, \fIstart\fB, \fIend\fB, \fIcode\fR + \fBlsrb \fIdest\fR + \fBlsrm \fIn\fB, \fIdest\fR + \fBlsrw \fIdest\fR + \fBmbyte \fIn\fR + \fBmovb \fIdest\fB, \fIsrc\fR + \fBmoveb \fIsrc\fB, \fIdest\fR + \fBmovew \fIdest\fB, \fIsrc\fR + \fBmovexb \fIsrc\fB, \fIdest\fR + \fBmovexw \fIsrc\fB, \fIdest\fR + \fBmoveyb \fIsrc\fB, \fIdest\fR + \fBmoveyw \fIsrc\fB, \fIdest\fR + \fBmovm \fIn\fB, \fIdest\fB, \fIsrc\fR + \fBmovmx \fIn\fB, \fIdest\fB, \fIsrc\fR + \fBmovmy \fIn\fB, \fIdest\fB, \fIsrc\fR + \fBmovw \fIsrc\fB, \fIdest\fR + \fBmv2m \fIn\fB, \fIdest1\fB, \fIdest2\fB, \fIsrc\fR + \fBnegb \fIdest\fR + \fBnegm \fIn\fB, \fIdest\fR + \fBnegw \fIdest\fR + \fBphr\fR + \fBphx\fR + \fBphy\fR + \fBplr\fR + \fBplx\fR + \fBply\fR + \fBpushaddr \fIaddress\fR + \fBrepeat \fIn\fB, \fIcode\fR + \fBsubb \fIdest\fB, \fIsrc1\fB, \fIsrc2\fR + \fBsubm \fIn\fB, \fIdest\fB, \fIsrc1\fB, \fIsrc2\fR + \fBsubw \fIdest\fB, \fIsrc1\fB, \fIsrc2\fR +.fi diff --git a/doc/handyHelpfulHints.t b/doc/handyHelpfulHints.t new file mode 100644 index 0000000..c0d95dd --- /dev/null +++ b/doc/handyHelpfulHints.t @@ -0,0 +1,85 @@ +Handy Helpful Hints for using make/macross/slinky + +1. You need two header files: a header and a sub-header. The sub-header +declares 'define' symbols, zero page labels (as local labels), macros, +functions, and so on. The header includes the sub-header and then +additionally contains 'extern' declarations for all program-space labels and +non-zero page variable-space labels plus 'define' declarations which refer to +externals. + +Non-zero page variable-space should be laid out in one file that includes just +the sub-header. The rest of the program should be spread among files each of +which includes the header. + +2. In any given Macross assembly (usually one source file plus all of the +other files that it 'include's), you can classify each symbol in two different +orthogonal ways: whether it is global or local on the one hand and whether it +is defined in this assembly or defined in some other assembly. + +Being defined means that the symbol has a value which is known and can +therefore be used to generate code. If a symbol has a value when it is +encountered during assembly, then that value can be used immediately. +If not, then we must wait until linking when (presumably) the value will be +known. + +Being global means that the symbol's value is known outside of the assembly in +which the symbol is defined (i.e., that the value is "published" in the object +file for use by the linker). Conversely, being local means that the value is +known only in the one assembly. + +Let's look at the four possible cases when a symbol is encountered during +assembly: + +LOCAL, DEFINED: this is the usual case. The value is used at assembly time. +Multiple independent assemblies can define local symbols with the same names +without conflicting with each other when they are linked. + +LOCAL, UNDEFINED: this shouldn't happen. You will get a complaint from the +assembler. + +GLOBAL, DEFINED: during assembly, the symbol is treated just like a defined +local symbol. However, the value is "published" in the object file for use by +the linker. The symbol value can be made global either or both of two +different ways: with an 'extern' declaration + extern foo ; makes the symbol 'foo' global +or, if the symbol is a label, by using two colons instead of one + foo:: word 123 ; 'foo' is global + bar: word 456 ; 'bar' is local +If a global symbol is defined in more than one object file, the linker will +complain. + +GLOBAL, UNDEFINED: this means that the assembler assumes that the value of the +symbol will be defined at link time. You still have to tell the assembler +that the symbol is global with an 'extern' statement. + +Note that all macro, function and variable (Macross variables, not 6502 +storage locations used as variables) names MUST be local, as must be struct +names and struct fields. The assembler will complain if you try to declare +one of these 'extern'. + +A 'define' symbol must be local if it refers to any global symbols in its +definition. + +3. The fewer global symbols there are, the faster the link will run. + +4. When juggling a program that consists of multiple source and object files, +only a very foolish person would not use 'make'. + +5. Emacs has a very nice feature whereby you can run 'make' under emacs and +then get taken automagically to the errors: + +The emacs function 'compile' (or 'new-compile' on some systems), which is +usually bound to ^X^C (also to the shift-F5 key on my Concept terminal; I +don't know about others), will run make and put the output from make (error +messages and so on) in a buffer with a new window. + +After compiling with make, the emacs function 'next-error', which is usually +bound to ^X^N (also to the the F5 key on my Concept) will search in the error +message buffer for the first C-compiler-style error message (which is what +Macross outputs), read the file name and line number from the error message +and then (in another window) position the cursor at that line of that file. +Entering this command again takes you to the next error message, and then the +next, and so on. The wonderful thing about this is that if you edit your +source file, emacs keeps track of how you have shifted things around so that +it will always take you to the location of the next error, even if your +editing has invalidated the line numbers in the error messages! diff --git a/doc/linkerReleaseNotes b/doc/linkerReleaseNotes new file mode 100644 index 0000000..32396f0 --- /dev/null +++ b/doc/linkerReleaseNotes @@ -0,0 +1,224 @@ + An informal introduction to + code relocation + and + multi-file linking + using + Macross and Slinky + +To use: + +First, let me explain that if you don't want to use the linker and assemble +your programs in pieces, you need do nothing. Macross will continue to +operate for you just as it always has (except that it will be somewhat faster +since it no longer will be keeping track of some stuff internally that only +matters to the linker). If you're not interested stop reading this right now. + +There is a new command line option for Macross, '-c'. This signals to the +assembler that, rather than generating a plain old ordinary object file, you +want it to produce a special linkable object file that contains all kinds of +information that the linker will need later. (I know it's obscure, but I'm +running out of letters and the C compiler uses this flag to signal the same +thing (maybe it should be '-m' or would that be even more obscure?)). E.g.: + + macross -c -o foo foo.m + +To link object files together, you use Slinky. The command is + + slinky file1 file2 file3 ... + +where file1, file2, etc. were generated by Macross using the '-c' option +described in the previous paragraph. By default the output will go in the +file 's.out' but the aesthetically enlightened will use the '-o' option to +slinky that will name the output file whatever you want. E.g.: + + slinky -o foobar file1 file2 file3 ... + +will name the output 'foobar' (just like the '-o' option to Macross). The +output file from Slinky will be a standard a65-style object file suitable for +downloading to your Atari or whatever. *Don't* try to directly download an +unlinked object that was produced by Macross using '-c'. Doing so will make +the downloader choke, puke and die (actually, I haven't tried this, but in any +case it will be wrong and the result will most likely be ugly). + +Simple, no? Actually no, because... + +You need to write your Macross programs in a way that can allow the various +files to be assembled separately. This requires an understanding of two +important concepts: 1. relocation and 2. external symbols. + +A Macross relocatable object file consists of a bunch of little pieces of +object code (called 'segments') plus some other bookkeeping info. Each of +these little pieces of object code is either 'absolute' or 'relocatable'. +Being absolute means that a segment is given a fixed, pre-specified location +in memory. Being relocatable means that the segment can go wherever the +linker finds room to put it. + +All right, you ask, how do my pieces of code get to be absolute or +relocatable? Well, at any given time, Macross is assembling in either +absolute-mode or relocatable-mode (it starts out in relocatable-mode (always +did, bet you didn't even notice!)). It gets into absolute-mode using the +'org' statement with an absolute-value as the address to org to, i.e., + + org 0x1000 + +This starts an absolute segment at location 0x1000. The segment continues +until the next 'org' or 'rel' statement. Macross gets into relocatable-mode +via the 'rel' statement: + + rel + +or by an 'org' statement with a relocatable value as the address to org to +(actually, using an org in this way is, as of the current implementation, +somewhat questionable). The relocatable segment continues until the next +'org' kicks Macross out of relocatable-mode or you use a 'constrain' or +'align' statement. Each of the latter two (in relocatable-mode but not in +absolute-mode) starts a new relocatable segment which is aligned or +constrained appropriately at link-time. Also, a new relocatable segment +starts at the end of the block that is the argument of a 'constrain' +statement (again, in relocatable mode only). + +It is important for you to know where (in your source code) relocatable +segments begin and end, because each segment is relocated by the linker +independently of all the others. Thus, even though two segments might be +adjacent in your Macross source, in the eventual linked object they might not +be. Thus relative branches across segment boundaries may go out of range and +you cannot expect the flow of program execution to be continuous from one +segment to another, i.e., that the last instruction in a segment will be +followed immediately by the first instruction of the segment that follows it +in the source. For example, in the following: + + ...stuff... + and 123 + constrain (0x100) { + sta foobar + ...more stuff... + +you can't assume that the 'sta' will follow the 'and'. So + +RULE #1 -- Don't allow program flow of control to fall through from one +segment to the next. + +RULE #2 -- Don't do relative branches across segment boundaries ('jmp's and +'jsr's are OK). + +COROLLARY -- You can't put an 'align' or 'constrain' statement inside an 'if', +'while', 'do while' or 'do until' statement, and putting one inside a macro is +very likely to result in a weird program bug unless you really understand what +you are doing. + +As with segments, a symbol in your Macross program is either absolute or +relocatable. The value of an absolute symbol (called an 'absolute value') is +a location in an absolute segment (or simply a fixed number like 42 or 137). +A relocatable symbol has a value (called a 'relocatable value') which is a +location in a relocatable segment. The important point to note is that the +value of a relocatable symbol is not known until the program is linked and the +relocatable segment to which it refers is given an actual location in memory. + +This in turn means that Macross can't do any assembly-time arithmetic with the +symbol since it doesn't know what value to compute with. Since storing away +whole expressions in the object file would be both costly and messy we don't +even try. The only arithmetic operation that the linker knows how to do is +simple addition. Thus, the only operation you can perform with a relocatable +symbol or value is simple addition, and then only in contexts where the result +of the computation will get stored in the resultant object somewhere, such as +the argument to an instruction or a 'byte' or 'word' statement. Thus the +following are OK, for example (let's say 'foo' and 'bar' are relocatable +symbols): + + and foo+3 + ora bar-10 ; OK since this is just adding -10 + word foo+bar + +but these are not + + and foo*3 ; not addition + ora 10-bar ; can't subtract 'bar' + lda (bar+10)/7 ; even though 'bar' gets added, the result of + ; the addition is needed for the division + +So, + +RULE #3 -- No arithmetic more complicated than simple addition is allowed with +relocatable symbols or values. + +Now to explain external symbols... + +First of all, you need to understand about symbols being *defined*. When we +say that a symbol is 'defined' we mean that it has a value that the assembler +or linker can use. A symbol gets defined by the Macross 'define' statement or +by being used as a label. In order to actually use a symbol, e.g. as part of +the operand of an instruction, the symbol must be defined *somewhere*. + +Now let's say you have a subroutine that is defined in one file (actually, the +label which is associated with the entry point to the subroutine is defined in +that file, but let's not quibble), but which is called (using a 'jsr') from a +second file. Two pieces of information need to be given to Macross when it +assembles these files. In the first file, where the subroutine label is +defined, you need to tell Macross, "Hey, this label is going to be used +outside of this file, so put something in the object file that will tell the +linker that it's here." In the second file, where the label is used (but not +defined), you need to tell Macross, "Yes, I know this symbol isn't defined +here. Don't worry about it. It's defined elsewhere and the linker will worry +about it." Both of these pieces of information are conveyed by declaring the +symbol to be external using the Macross 'extern' statement. E.g., in the +first file: + + extern foo + ...stuff... + foo: ...more stuff... + rts + +and in the second file: + + extern foo + ...stuff... + jsr foo + ...more stuff... + +In addition to this, a shorthand form of declaring a label to be external when +it is defined is supported: you simply use two colons instead of one. In our +example above, then, the first file could be: + + ...stuff... + foo:: ...more stuff... + rts + +and the result would be exactly the same. So, + +RULE #4 -- If you want a symbol's value to be carried across multiple files, +that symbol MUST be declared external in the file where it is defined and in +all files in which it is used. + +Note that, as with relocatable symbols, symbols which are defined externally +do not have a value which is known to Macross at assembly-time (though symbols +which are external but which are defined in a given file do have such a value +presuming that they are not also relocatable). This means that the same +restrictions about arithmetic on relocatable symbols apply to externally +defined symbols: + +RULE #3a -- No arithmetic more complicated than simple addition is allowed +with externally defined symbols. + +Not to belabor the obvious, but it is of course an error to define an external +symbol in more than one file. The linker will catch this and complain if you +try. + +In summary then: + +RULE #1 -- Don't allow program flow of control to fall through from one +segment to the next. + +RULE #2 -- Don't do relative branches across segment boundaries ('jmp's and +'jsr's are OK). + +COROLLARY -- You can't put an 'align' or 'constrain' statement inside an 'if', +'while', 'do while' or 'do until' statement, and putting one inside a macro is +very likely to result in a weird program bug unless you really understand what +you are doing. + +RULE #3 -- No arithmetic more complicated than simple addition is allowed with +relocatable symbols or values or symbols which are defined externally. + +RULE #4 -- If you want a symbol's value to be carried across multiple files, +that symbol MUST be declared external in the file in which it is defined and +in all files in which it is used. diff --git a/doc/macros.itr b/doc/macros.itr new file mode 100644 index 0000000..da11387 --- /dev/null +++ b/doc/macros.itr @@ -0,0 +1,315 @@ +; +; potentially popular macros for the macross assembler +; +; 11-Jan-85 cbm converted for Macross from original a65 +; + +mif (!isDefined(_macros_)) { + define _macros_ = 1 +; +; push and pop X and Y registers +; +macro phx { + txa + pha +} +macro plx { + pla + tax +} +macro phy { + tya + pha +} +macro ply { + pla + tay +} + +macro call arg { + jsr arg +} + +macro return { + rts +} + +macro callret arg { + jmp arg ; same as jsr arg; rts +} + +macro save arg { + lda arg + pha +} + +macro restore arg { + pla + sta arg +} + +; ================================================================ +; some auxiliary functions for the macros that follow +; + +; MAKE-FIRST-BYTE - access low byte for any addressing mode +function makeFirstByte(operand) { + mif (isImmediateMode(operand)) { + freturn(/operand) + } melse { + freturn(operand) + } +} + +; MAKE-SECOND-BYTE - access high byte for any addr mode except (post y zzz) +function makeSecondByte(operand) { + mif (isImmediateMode(operand)) { + freturn(?operand) + } melse { + freturn(operand + 1) + } +} + +; MAKE-NTH-BYTE - similarly access arbitrary byte +function makeNthByte(operand, n) { + mif (isImmediateMode(operand)) { + freturn((operand >> (8 * (n - 1))) & 0xFF) + } melse { + freturn(operand + n - 1) + } +} + +; ================================================================ +; MOVM, MOVEB, MOVB, MOVEW, MOVW, CLEARB, and CLEARW +; Note that the args on MOVEx are src,dst as opposed to +; MOVx, which uses dst,src. +; + +; MOVM - move multiple +macro movm n, dst, src { + mvariable i + mfor (i=1, i<=n, i++) { + lda makeNthByte(src, i) + sta makeNthByte(dst, i) + } +} + +; MOVEB - move byte from src to dst +macro moveb src, dst { + lda src + sta dst +} + +; MOVB - for those who like their destination before their source +macro movb dst, src { + lda src + sta dst +} + +; MOVEW - move word from src to dst +; works for all addressing moves EXCEPT (post y zzz) +macro movew src, dst { + lda makeFirstByte(src) + sta makeFirstByte(dst) + lda makeSecondByte(src) + sta makeSecondByte(dst) +} + +; MOVW - and another with destination before source +; works for all addressing moves EXCEPT (post y zzz) +macro movw dst, src { + lda makeFirstByte(src) + sta makeFirstByte(dst) + lda makeSecondByte(src) + sta makeSecondByte(dst) +} + +; CLEARB - zero byte dst +macro clearb dst { + lda #0 + sta dst +} + +; CLEARW - zero word dst +; works for all addressing modes EXCEPT (post y dst) +macro clearw dst { + lda #0 + sta makeFirstByte(dst) + sta makeSecondByte(dst) +} + +; ================================================================ +; the general macros +; + +; MOVWB - move byte SRC to word DST +; works for all addressing modes EXCEPT (post y zzz) +macro movwb dst, src { + lda src + sta makeFirstByte(dst) + lda #0 + sta makeSecondByte(dst) +} + +; ADDM - add multiple +macro addm n, dst, src, src1 { + mvariable i + clc + mfor (i=1, i<=n, i++) { + lda makeNthByte(src, i) + adc makeNthByte(src1, i) + sta makeNthByte(dst, i) + } +} + +; ADDB - byte dst = byte src0 + byte src1 +macro addb dst, src0, src1 { + clc + lda src0 + adc src1 + sta dst +} + +; ADDW - word dst = word src0 + word src1 +; works for all addressing modes EXCEPT (post y zzz) +macro addw dst, src0, src1 { + clc + lda makeFirstByte(src0) + adc makeFirstByte(src1) + sta makeFirstByte(dst) + lda makeSecondByte(src0) + adc makeSecondByte(src1) + sta makeSecondByte(dst) +} + +; ADDWWB - word dst = word src0 + byte src1 +; works for all addressing modes EXCEPT (post y zzz) +macro addwwb dst, src0, src1 { + clc + lda makeFirstByte(src0) + adc src1 + sta makeFirstByte(dst) + lda makeSecondByte(src0) + adc #0 + sta makeSecondByte(dst) +} + +; SUBB - byte dst = byte src0 - byte src1 +macro subb dst, src0, src1 { + sec + lda src0 + sbc src1 + sta dst +} + +; SUBW - word dst = word src0 - word src1 +; works for all addressing modes EXCEPT (post y zzz) +macro subw dst, src0, src1 { + sec + lda makeFirstByte(src0) + sbc makeFirstByte(src1) + sta makeFirstByte(dst) + lda makeSecondByte(src0) + sbc makeSecondByte(src1) + sta makeSecondByte(dst) +} + +; SUBWWB - word dst = word src0 - byte src1 +; works for all addressing modes EXCEPT (post y zzz) +macro subwwb dst, src0, src1 { + sec + lda makeFirstByte(src0) + sbc src1 + sta makeFirstByte(dst) + lda makeSecondByte(src0) + sbc #0 + sta makeSecondByte(dst) +} + +; ================================================================ +; cmpm, cmpb, cmpw +; compare two quantities (arbitrary length, byte, and word) +; set the condition flags following s0-s1 +; +macro cmpm n, s0, s1 { + mvariable i + mfor (i=1, i<=n, i++) { + lda makeNthByte(s0, i) + sbc makeNthByte(s1, i) + } +} + +macro cmpb s0, s1 { + sec + lda s0 + sbc s1 +} + +macro cmpw s0, s1 { + sec + lda makeFirstByte(s0) + sbc makeFirstByte(s1) + lda makeSecondByte(s0) + sbc makeSecondByte(s1) +} + +; +; ASLM - multiply all by 2 +macro aslm n, s0 { + mvariable i + asl s0 + mfor (i = 2, i <= n, i++) { + rol makeNthByte(s0, i) + } +} + +; ================================================================ +; asrm, asrb, asrw +; Arithmetic Shift Right (with sign extend). +; +macro asrm n, s0 { + mvariable i = n + lda makeNthByte(s0, i) + cmp #0x80 + mwhile (i > 0) { + ror makeNthByte(s0, i--) + } +} + +macro asrb s0 { + lda s0 + cmp #0x80 + ror s0 +} + +macro asrw s0 { + lda makeSecondByte(s0) + cmp #0x80 + ror makeSecondByte(s0) + ror makeFirstByte(s0) +} + +; ================================================================ +; repeat n {code. . .} +; repeat n instances of code. e.g., +; repeat 6 { +; lda x[foo] +; sta x[bar] +; inx +; } +; will generate inline code to move 6 bytes +; +macro repeat count, blockToRepeat { + mvariable i = count + mwhile (i-- > 0) { + blockToRepeat + } +} + +macro includef fname { + printf("Including %s\n", fname) + include fname +} + + +} ; *** end -- mif (!isDefined(_macros_)) *** diff --git a/doc/macross.1 b/doc/macross.1 new file mode 100644 index 0000000..acd1e17 --- /dev/null +++ b/doc/macross.1 @@ -0,0 +1,108 @@ +.TH MACROSS 1 "27 November 1985" +.UC 4 +.SH NAME +macross \- Macross assembler +.SH SYNOPSIS +.B macross +[ option ] ... file ... +.SH DESCRIPTION +.I Macross +is a fancy macro cross assembler for the 6502. +.I Macross +assembles the given files in the order specified on the command line. Macross +source file names must end with ``\fB.m\fR''. +.PP +The following options are interpreted by +.IR macross . +.TP +.BI \-l " listfile" +Produce an assembler listing in the file +.IR listfile +showing the object code generated. If +.IR listfile +is ``\fB-\fR'' the listing will be printed on the standard output. +.TP +.B \-m +When listing is enabled, causes the assembler to include in the listing +synthesized lines showing the code generated by macros. +.TP +.B \-g +Suppress assembly-time garbage collection of unused dynamic storage space +(may speed up small assemblies). +.TP +.B \-d +Print esoteric debug information showing parse trees generated by the parser. +(Generally not of interest to the casual user). +.TP +.B \-D +Print even more esoteric debug information showing parser states. (Almost +certainly not of interest to the casual user). +.TP +.B \-e +Print esoteric debug information showing emitted binary as it is generated. +(Even duller than parser states). +.TP +.BI \-s " dumpfile" +Place a symbol table dump in the file +.IR dumpfile +at the end of assembly. If +.IR dumpfile +is ``\fB-\fR'', the symbol table dump will go to the standard output. +.TP +.BI \-S " dumpfile" +As \fB-s\fR, except also dump internal symbols normally not of interest. +.TP +.BI \-h " dumpfile" +As \fB-s\fR, except that the symbols are dumped in the form of Macross +\fBdefine\fR statements. +.TP +.BI \-H " dumpfile" +As \fB-h\fR, except that it only dumps defined external symbols. +.TP +.B \-a +If a symbol dump has been specified, have it include unreferenced \fBdefine\fR +symbols (these are not normally displayed in a symbol table dump listing). +.TP +.BI \-o " output" +Name the final output file +.IR output . +If this option is not used the output will be placed in the file `m.out'. +.TP +.BI \-P " processor" +Assemble for the target processor +.IR processor . +The allowed values are \fB6502\fR and \fB68000\fR. If this option is not +used \fB6502\fR will be assumed. +.TP +.B \-c +Make the object file produced be a linkable object suitable for use with the +\fIslinky\fR linker. +.TP +.B \-p +Produce position independent code for the \fBelse\fP clause of +\fBif-then-else\fP statements. This is accomplished by emitting a +\fBbcc/bcs\fP branch pair instead of a \fBjmp\fP instruction. +.TP +.B \-t +Be terse about error messages. Output no more than one error message for a +given line. +.TP +.B \-u +Don't discard the temporary intermediate files generated during the listing +process when the assemble exits (used for debugging the listing facility). +.TP +.B \-v +Print the \fImacross\fP version number on the standard output before beginning +assembly. +.TP +.B \-B +When generating branches for nested \fBif-then-else\fR constructs, generate +code like that generated by \fBa65\fR. This code will be slightly less +efficient but will be completely backwards compatible. +.SH "SEE ALSO" +slinky(1), the Macross manual +.SH DIAGNOSTICS +The diagnostics produced by Macross are \fIintended\fR to be self-explanatory. +.SH BUGS +Errors in the input may sometimes produce bizarre and unexpected results. +There are probably lots of bugs that are as yet undetected. diff --git a/doc/slinky.1 b/doc/slinky.1 new file mode 100644 index 0000000..102c6f9 --- /dev/null +++ b/doc/slinky.1 @@ -0,0 +1,66 @@ +.TH SLINKY 1 "28 February 1986" +.UC 4 +.SH NAME +slinky \- slinky linker +.SH SYNOPSIS +.B slinky +[ option ] ... file ... +.SH DESCRIPTION +.I Slinky +is a multi-file relocating object linker designed to be used in conjunction +with the +.I Macross +assembler. +.I Slinky +links the given +.I Macross +object files in the order specified on the command line together into one +executable object file. +.PP +The following options are interpreted by +.IR slinky . +.TP +.B \-d +Print esoteric debug information (you don't want to use this). +.TP +.B \-e +Print different esoteric debug information (you don't want to use this +either). +.TP +.B \-v +Print the \fIslinky\fP version number on the standard output before linking. +.TP +.BI \-l " hexaddress" +By default, \fIslinky\fP starts putting relocatable modules at location 0x100. +The \fB-l\fR option lets you tell it to put things anywhere. This option can +be used more than once in a single link command and can be interspersed with +the names of the object files being linked. Thus +.br + \fBslinky foo.obj -l 0x3800 bar.obj baz.obj -l 0x5000 snood.obj\fP +.br +loads `foo.obj' starting at location 0x100, `bar.obj' and `baz.obj' +consecutively starting at location 0x3800 and `snood.obj' starting at location +0x5000. +.TP +.BI \-o " output" +Name the final output file +.IR output . +If this option is not used the output will be placed in the file `s.out'. +.TP +.BI \-m " mapfile" +Generate a load map listing, showing the values of all symbols after linking +and put it in the file +.IR mapfile . +If +.IR mapfile +is ``\fB-\fR'', the load map will go to the standard output. +.TP +.B \-n +If generating a load map, suppress the printing of the names of the files that +reference each symbol. +.SH "SEE ALSO" +macross(1), the Macross manual +.SH DIAGNOSTICS +The diagnostics produced by Slinky are \fIintended\fR to be self-explanatory. +.SH BUGS +Who knows what bugs lurk there? Nobody's used it yet! diff --git a/doc/writeup_6502.itr b/doc/writeup_6502.itr new file mode 100644 index 0000000..e76fc2d --- /dev/null +++ b/doc/writeup_6502.itr @@ -0,0 +1,2124 @@ +.ds [ \s+1\z[\h'1p'\z[\h'-1p'\s-1\0 +.ds ] \s+1\z]\h'-1p'\z]\s-1\0 +.ds Z \s+1\z]\h'-1p'\z]\h'3p'\z*\s-1\0 +.ds Da July 7, 1986 +.TL +\s+6Macross 6502\s-6 +\"Macross +.AU +an assembler for people who hate assembly language +by +Chip Morningstar +.AI +Lucasfilm Ltd. Games Division +\\*(Da +.ds LH Macross +.ds CH \\*(Da +.ds RH 6502 Version +.ds LF Lucasfilm Ltd. Proprietary Information +.ds CF - % - +.ds RF CONFIDENTIAL +.AB +This document describes the 6502 version of \fIMacross\fR, a super-duper +cross-assembler that has actually been used! +.AE +.SH +\s+3Introduction\s-3 +\"Introduction +.PP +\fIMacross\fR is a generic cross assembler for a variety of different +microprocessors. This document describes the 6502 version of \fIMacross\fR. +\fIMacross\fR differs from many macro assemblers in that it provides a number +of ``higher level'' constructs not traditionally found in assembly language. +These include block-structured flow-of-control statements (\fCif\fR, +\fCwhile\fR, etc.) and the ability to define record-oriented data structures +(\fCstruct\fR). In addition, it contains a powerful macro capability that is +based on syntactic structural manipulations rather than simple text +substitution. \fIMacross\fR is, in fact, a complete block-structured +programming language in its own right which is interpreted at assembly time. +.SH +\s+3General Form of \fIMacross\fP Statements\s-3 +\"General Form of \fIMacross\fP Statements +.PP +Stylistically, much of \fIMacross\fR is patterned after \fBC\fR. In +particular, the form of many keywords and of block structured entities is +derived from \fBC\fR. Unlike \fBC\fR however, \fIMacross\fR follows the +convention of more traditional assemblers that statements are delimited by +line boundaries (i.e., one statement per line, with the end of a line ending a +statement). +.PP +In general, spaces and tabs are treated as whitespace characters and are +ignored. Therefore, such characters may be used as the assembly language +programmer desires to format his or her program according to personal taste. +For the convenience of the programmer, \fIMacross\fR relaxes the syntax rule +that newlines always end a statement: newlines may also be treated as +whitespace characters (again, for purposes of formatting) in places where it +would be syntactically unambiguous to do so (i.e., where a statement obviously +cannot terminate, such as after a comma). For example: +.nf + + \fCbyte 1, 2, 3, 4, + 5, 6, 7, 8\fR + +.fi +is allowed and is equivalent to +.nf + + \fCbyte 1, 2, 3, 4, 5, 6, 7, 8 + +.fi +.PP +Comments begin with a semicolon (``\fC;\fR'') and continue to the end of the +line, as is common in many assemblers. In addition, \fIMacross\fR supports +\fBC\fR style comments bracketed by ``\fC/*\fR'' and ``\fC*/\fR''. +.PP +As with most assemblers, \fIMacross\fR statements are allowed to begin with a +label (or several labels, if you like). A label is denoted by an identifier +followed by a colon (``\fC:\fR''). There is no requirement that the label +start in column 1, or anything like that. Labels, if present, merely must +precede anything else in a statement. +.PP +An identifier is just what you'd expect from all your years of programming +experience: a string of letters and digits that must begin with a letter. As +is traditional in Unix* +.FS * +Unix is a footnote of Bell Laboratories. +.FE +land, the underscore character (``\fC_\fR'') is considered to be a letter +(smacks of hubris that, but tradition is tradition). Departing from Unix +tradition, upper- and lower-case characters are not distinct from each other +for purposes of distinguishing identifiers. If you use mixed case for +stylistic reasons, \fIMacross\fR will remember the case of the letters in an +identifier when it was first defined, so that symbol table dumps and +cross-reference listings will retain whatever case usage style you've adopted. +There is, in principle, no restriction imposed upon the length of identifiers. +.SH +\s+3The Language\s-3 +.PP +In what follows, things in \fCthis typewriter like typeface\fR are keywords +and characters that are used literally. Things in \fIitalics\fR are other +kinds of syntactic entities. Double brackets (``\*['' and ``\*]'') enclose +things that are optional, while brackets followed by an asterisk (``*'') +enclose things that may be optionally repeated zero or more times. +.NH 1 +The Instruction Statement +.PP +The most elementary \fIMacross\fR statement is the instruction statement, +wherein the programmer specifies a machine instruction to be assembled. The +instruction statement is +.nf + +\*[ \fIlabel\fR \*Z \fIopcode\fR \*[ \fIoperand\fR \*[ \fC,\fR \fIoperand\fR \*Z \*] + +.fi +just like every assembler ever made (except \fBa65\fR, of course). +\fIOpcode\fR is an identifier which is either a machine instruction mnemonic +(a list of which mnemonics are accepted by \fIMacross\fR is given in +\fBAppendix F\fR at the end of this document) or a macro name. For example: +.nf + + \fCand foobar\fR + \fCsomeMacro foo, bar, baz, bletch\fR + +.fi +.PP +The operands of an instruction may be any of the various types of operands +allowed by the various addressing modes of the target processor. In the case +of the 6502, these are: +.NH 2 +\fRDirect addressing +.PP +Direct addresses take the form +.nf + + \fIexpression\fR + +.fi +and are used both for instructions that use direct addressing and ones that +use relative addressing (the offset is computed automatically by +\fIMacross\fR). +.NH 2 +\fRIndirect addressing +.PP +Indirect addresses take the form +.nf + + \fC@\fR \fIexpression\fR + +.fi +Of course, the only 6502 instruction which accepts an indirectly addressed +operand is \fCjmp\fR. +.NH 2 +\fRImmediate operands +.PP +Immediate operands take the form +.nf + + \fC#\fR \fIexpression\fR + +.fi +In the 6502, immediate mode operands are restricted to eight bit quantities. +\fIMacross\fR will give an error message if the operand value is larger than +this. +.NH 2 +\fRIndexed addressing +.PP +Indexed addressing operands take the forms +.nf + + \fCx\fR \fC\s-1[\s+1\fR \fIexpression\fR \fC\s-1]\s+1\fR + \fCy\fR \fC\s-1[\s+1\fR \fIexpression\fR \fC\s-1]\s+1\fR + +.fi +An alternate form of indexed addressing which is supported by \fIMacross\fR +allows the symbolic selection of a field of a \fCstruct\fR pointed to by an +index register +.nf + + \fCx\fR \fC.\fR \fIidentifier\fR \*[ \fC.\fR \fIidentifier\fR \*Z + \fCy\fR \fC.\fR \fIidentifier\fR \*[ \fC.\fR \fIidentifier\fR \*Z + +.fi +This is explained in greater detail in the sections on \fCstruct\fRs and +expressions below. +.NH 2 +\fRPre-indexed indirect addressing +.PP +Pre-indexed indirect addressing is specified by operands of the form +.nf + + \fC@\fR \fCx\fR \fC\s-1[\s+1\fR \fIexpression\fR \fC\s-1]\s+1\fR + +.fi +As with ordinary indexed addressing, there is a form of pre-indexed indirect +addressing which uses \fCstruct\fR fields +.nf + + \fC@\fR \fCx\fR \fC.\fR \fIidentifier\fR \*[ \fC.\fR \fIidentifier\fR \*Z +.fi +.NH 2 +\fRPost-indexed indirect addressing +.PP +Post-indexed indirect addressing is specified by operands of the form +.nf + + \fCy\fR \fC\s-1[\s+1\fR \fC@\fR \fIexpression\fR \fC\s-1]\s+1\fR + +.fi +There is no \fCstruct\fR-oriented form of post-indexed indirect addressing +since there doesn't seem to be any consistent interpretation of such a thing +that makes sense. +.NH 2 +\fRRegister addressing +.PP +The only register in the 6502 which is used as an operand in its own right is +the accumulator +.nf + + \fCa\fR + +.fi +For the sake of completeness, so that macros may have them as operands, +\fIMacross\fR also allows either of the index registers to be used as operands +.nf + + \fCx\fR + \fCy\fR + +.fi +These are equivalent to +.nf + + \fCx[0]\fR + \fCy[0]\fR + +.fi +Note that \fCa\fR, \fCx\fR and \fCy\fR are reserved words in the \fIMacross\fR +language and so cannot be used as labels, variable names, etc. It might seem +natural to call a variable \fCx\fR but you can't. Sorry. +.NH 2 +\fRText operands +.PP +For the sake of macros, text strings may also be used as operands +.nf + + \fC"\fIany string you like\fC"\fR + +.fi +The same conventions regarding escaped characters (using ``\fC\\\fR'') that +are followed by \fBC\fR are followed by \fIMacross\fR. These are documented +in \fBAppendix E\fR. Note that on many target machines the codes that these +escape sequences stand for are meaningless. They are provided primarily as a +convenience for writing calls to \fCprintf()\fR. +.NH 1 +The Flow of Control Statements +.PP +\fIMacross\fR provides a number of statements which allow program flow of +control to be specified in a \fBC\fR-like block structured fashion. This +include a conditional execution statement (\fCif\fR) and three conditional +loop statements (\fCwhile\fR, \fCdo-while\fR and \fCdo-until\fR). These +statements assemble into the appropriate conditional branches and jumps to +realize the desired construct. +.NH 2 +If\fR statement +.PP +The \fCif\fR statement has the following form +.nf + +\*[ \fIlabel\fR \*Z \fCif\fR \fC(\fR \fIcondition\fR \fC)\fR \fC{\fR + \*[ \fIstatement\fR \*Z + \fC}\fR \*[ \fCelseif\fR \fC(\fR \fIcondition\fR \fC)\fR \fC{\fR + \*[ \fIstatement\fR \*Z + \fC}\fR \*Z \*[ \fCelse\fR \fC{\fR + \*[ \fIstatement\fR \*Z + \fC}\fR \*] + +.fi +\fIcondition\fR is either the name of one of the target processor's hardware +condition codes such as can be tested for in a conditional branch instruction +(e.g., \fCcarry\fR, \fCoverflow\fR, etc.\(em the complete list is in +\fBAppendix B\fR) or one either of these negated using the ``logical not'' +operator (``\fC!\fR'') or the name of one of the more complex conditions +which \fIMacross\fR understands (\fCgeq\fR, \fClt\fR, etc., discussed +shortly). The condition is used to determine the appropriate type of branch +instruction(s) to use. For example, +.nf + + \fCif (plus) {\fR + \fIstatements-1\fR + \fC} elseif (carry) {\fR + \fIstatements-2\fR + \fC} else {\fR + \fIstatements-3\fR + \fC}\fR + +.fi +expands into this (the labels are made up for illustrative purposes only): +.nf + + \fCbmi temp1 + \fIstatements-1 + \fCjmp temp3 +temp1: bcc temp2 + \fIstatements-3 + \fCjmp temp3 +temp2: \fIstatements-3 +\fCtemp3: \fIwhatever follows\fR + +.fi +The keyword \fCelseif\fR may be used as shown, or specified as two separate +keywords, \fCelse if\fR, depending on the programmer's whim. +.PP +\fIMacross\fR knows about certain conditions which are more complex than those +than can be realized with single conditional branch instructions. These +conditions correspond to the results of comparison operations (such as +\fCgeq\fR \(em ``greater than or equal to'') that may require rather +complicated sequences of conditional branches to implement. These may be used +in any location where an ordinary condition may be used. One simply should +keep in mind that they can result in a non-trivial amount of code being +generated, if one is concerned about speed of execution. The complete list of +these complex conditions along with the object code that they produce is given +in \fBAppendix B\fR. +.NH 2 +While\fR statement +.PP +The \fCwhile\fR statement has the following form +.nf + +\*[ \fIlabel\fR \*Z \fCwhile\fR \fC(\fR \fIcondition\fR \fC)\fR \fC{\fR + \*[ \fIstatement\fR \*Z + \fC}\fR + +.fi +\fIcondition\fR is as described above for the \fCif\fR statement. An example +of the \fCwhile\fR statement would be +.nf + + \fCwhile (!carry) {\fR + \fIstatements\fR + \fC}\fR + +.fi +which would turn into +.nf + + bcs temp1 +\fCtemp2: \fIstatements + \fCbcc temp2 +temp1: \fIwhatever follows\fR + +.fi +.NH 2 +Do-while\fR statement +.PP +The \fCdo-while\fR statement is similar to the \fCwhile\fR statement except +that the condition is tested at the bottom of the loop. It has the form +.nf + +\*[ \fIlabel\fR \*Z \fCdo\fR \fC{\fR + \*[ \fIstatement\fR \*Z + \fC}\fR \fCwhile\fR \fC(\fR \fIcondition\fR \fC)\fR + +.fi +For example +.nf + + \fCdo {\fR + \fIstatements\fR + \fC} while (equal)\fR + +.fi +which is equivalent to +.nf + +\fCtemp: \fIstatements + \fCbeq temp\fR + +.fi +.NH 2 +Do-until\fR statement +.PP +The \fCdo-until\fR statement is the same as the \fCdo-while\fR statement +except that the sense of the condition is negated. It has the form +.nf + +\*[ \fIlabel\fR \*Z \fCdo\fR \fC{\fR + \*[ \fIstatement\fR \*Z + \fC}\fR \fCuntil\fR \fC(\fR \fIcondition\fR \fC)\fR + +.fi +For example +.nf + + \fCdo {\fR + \fIstatements\fR + \fC} until (equal)\fR + +.fi +which is equivalent to +.nf + +\fCtemp: \fIstatements + \fCbne temp\fR + +.fi +.NH 1 +The Data Statements +.PP +The data statements allow the allocation of memory space and the storage of +constant data. These statements are like the ones found in most assemblers. +There are several different forms, each for a different type of data. +.NH 2 +Block\fR statement +.PP +The \fCblock\fR statement allocates blocks of memory without initializing the +bytes to any particular value (actually, the loader will in all likelihood +initialize these to 0, but it is probably not really wise to rely on this). +It has the form +.nf + +\*[ \fIlabel\fR \*Z \fCblock\fR \fIexpression\fR \*[ \fC,\fR \fIexpression\fR \*Z + +.fi +The \fIexpression\fRs are the sizes of the blocks to reserve, expressed in +bytes. +.NH 2 +Align\fR statement +.PP +The \fCalign\fR statement aligns the current location counter to an integer +multiple of some value (e.g., to align with a word boundary). It has the form +.nf + +\*[ \fIlabel\fR \*Z \fCalign\fR \fIexpression\fR + +.fi +The \fIexpression\fR is the multiple to which the current location counter is +to be aligned. For example, +.nf + + \fCalign 2\fR + +.fi +would align the current location to a word boundary, while +.nf + + \fCalign 0x100\fR + +.fi +would align to a page boundary. +.NH 2 +Constrain\fR statement +.PP +The \fCconstrain\fR statement provides a means of constraining a portion of +code or data to be located within a region of memory bounded by addresses of +integer multiples of some value (e.g., within a page). Its form is +.nf + + \fCconstrain\fR \fC(\fR \fIboundary\fR \fC)\fR \fC{\fR + \*[ \fIstatement\fR \*Z + \fC}\fR + +.fi +\fIBoundary\fR may be any expression which evaluates to a number. The +\fIstatement\fRs are assembled normally. If assembling in absolute mode, an +error message is issued if the current location counter crosses an integer +multiple of \fIboundary\fR. If assembling in relocatable mode, information +about the constraint will be output in the object file and the contents of the +constrained block will be relocated as needed to satisfy the constraint (note +that this means that it is unsafe to assume that the things in the assembly +source immediately before the \fCconstrain\fR statement, the contents of the +constrain block itself, and the things in the assembly source immediately +after the \fCconstrain\fR statement will be located in contiguous locations in +the eventual target machine address space). For example, +.nf + + \fCconstrain (0x100) {\fR + \fIstatements\fR + \fC}\fR + +.fi +constrains the given statements to all fit within a page. +.NH 2 +Word\fR statement +.PP +The \fCword\fR statement allocates words, i.e., two byte chunks, of memory. +It takes the form +.nf + +\*[ \fIlabel\fR \*Z \fCword\fR \fIexpression\fR \*[ \fC,\fR \fIexpression\fR \*Z + +.fi +The \fIexpression\fRs must evaluate to quantities that can be contained in 16 +bits, of course. For example, +.nf + + \fCword 0x1234, foobar\fR + +.fi +would allocate two words, the first of which would be initialized to the +hexadecimal value \fC0x1234\fR and the second to whatever the value of +\fCfoobar\fR is. +.NH 2 +Dbyte\fR statement +.PP +The \fCdbyte\fR statement is just like the \fCword\fR statement, except that +the word is byte-swapped in memory. Its form is +.nf + +\*[ \fIlabel\fR \*Z \fCdbyte\fR \fIexpression\fR \*[ \fC,\fR \fIexpression\fR \*Z +.fi +.NH 2 +Long\fR statement +.PP +The \fClong\fR statement allocates longwords, i.e., four byte chunks, of +memory. It takes the form +.nf + +\*[ \fIlabel\fR \*Z \fClong\fR \fIexpression\fR \*[ \fC,\fR \fIexpression\fR \*Z + +.fi +The \fIexpression\fRs must evaluate to quantities that can be contained in 32 +bits, of course. For example, +.nf + + \fClong 0x12345678, foobar\fR + +.fi +would allocate two longwords, the first of which would be initialized to the +hexadecimal value \fC0x12345678\fR and the second to whatever the value of +\fCfoobar\fR is. +.NH 2 +Byte\fR statement +.PP +The \fCbyte\fR statement is similar to the \fCword\fR and \fCdbyte\fR +statements, except that it allocates single byte chunks. Its form is +.nf + +\*[ \fIlabel\fR \*Z \fCbyte\fR \fIexpression\fR \*[ \fC,\fR \fIexpression\fR \*Z + +.fi +An \fIexpression\fR, in this case, is either an ordinary expression (see +\fBExpressions\fR, below) which must evaluate to an 8-bit quantity, indicating +the value for a single byte to be reserved, or a string (see above, under the +discussion of text operands), indicating that the characters in the string +should be placed in memory at the current location. +.NH 2 +String\fR statement +.PP +The \fCstring\fR statement is much like the \fCbyte\fR statement, except that +the values indicated are followed in memory by a zero byte. This enables the +convenient declaration and allocation of NULL terminated character strings. +This feature is of little use in the 6502 version of \fIMacross\fR but is +provided for compatability with future versions targeted at more sophisticated +processors. The form of the \fCstring\fR statement is +.nf + +\*[ \fIlabel\fR \*Z \fCstring\fR \fIexpression\fR \*[ \fC,\fR \fIexpression\fR \*Z +.fi +.NH 2 +Struct\fR statement +.PP +The \fCstruct\fR statement enables the declaration and allocation of +record-oriented data structures. There are two forms of the \fCstruct\fR +statement, the first of which declares a \fCstruct\fR record type, and the +second of which causes space to be set aside in memory for a \fCstruct\fR that +has already been declared. The form of the first type of \fCstruct\fR +statement is +.nf + +\*[ \fIlabel\fR \*Z \fCstruct\fR \fC{\fR + \*[ \fIdataStatement\fR \*Z + \fC}\fR \fIname\fR + +.fi +\fIdataStatement\fRs are any of the data statements described in this section +(section 3). \fIName\fR becomes the name of the \fCstruct\fR. Any labels +inside the \fCstruct\fR become \fIfields\fR of the data structure which may be +referred to later in expressions using the ``\fC.\fR'' operator, as in +\fBC\fR. A more complete description of the semantics of \fCstruct\fRs is +given in the section below on expressions. +.PP +The first form of the \fCstruct\fR statement, called a ``\fCstruct\fR +definition'', lays out the constituent parts of a data structure and gives +those names to those parts. The second form of the \fCstruct\fR statement, +called a ``\fCstruct\fR instantiation'', +.nf + +\*[ \fIlabel\fR \*Z \fCstruct\fR \fIname\fR + +.fi +causes storage for the \fCstruct\fR named by \fIname\fR to be allocated. A +\fCstruct\fR definition \fImay not\fR contain another \fCstruct\fR definition, +but it \fImay\fR contain a \fCstruct\fR instantiation. For example, +.nf + + \fCstruct { + pointer: block 2 + class: block 1 + } fooThing\fR + +.fi +would create a \fCstruct\fR called \fCfooThing\fR. Then, +.nf + +\fCfooLabel: struct fooThing\fR + +.fi +would allocate one at the current location at the address labeled +\fCfooLabel\fR. This could then be used as follows: +.nf + + \fCand fooLabel.class + jmp @fooLabel.pointer\fR + +.fi +which would AND the accumulator with the \fCclass\fR field of the \fCstruct\fR +and then jump to wherever the \fCpointer\fR field pointed to. If the \fCx\fR +index register already contained the address of this \fCstruct\fR, then one +could say +.nf + + \fCand x.class\fR + +.fi +.NH 1 +The Symbol Definition Statements +.PP +The various symbol definition statements allow the declaration of symbolic +variables and values and the definition of macros and functions. +.NH 2 +Define\fR statement +.PP +The \fCdefine\fR statement enables the programmer to create symbolic names for +values. It has two forms. The first +.nf + + \fCdefine\fR \fIsymbolname\fR + +.fi +creates a new symbol, \fIsymbolname\fR (an identifier), and gives it the +special value \fCunassigned\fR. Any attempt to take the value of an +unassigned symbol will cause an error message from the assembler. The symbol +will, however, cause the \fCisDefined()\fR built-in function (see +\fBExpressions\fR, below) to return \fCTRUE\fR if passed as an argument. It +is also an error to \fCdefine\fR a symbol that has already been \fCdefine\fRd. +.PP +The second form of the \fCdefine\fR statement +.nf + + \fCdefine\fR \fIsymbolname\fR \fC=\fR \fIexpression\fR + +.fi +creates the symbol and gives it the value obtained by evaluating +\fIexpression\fR (see \fBExpressions\fR, below). Actually, what \fCdefine\fR +does is create a symbolic name for \fIexpression\fR and the save this +expression away in a secret place. This means that symbols in +\fIexpression\fR may be forward references, e.g., labels that haven't been +encountered yet. It is also possible to forward reference to symbols that are +defined by future \fCdefine\fR statements, for example: +.nf + + \fCdefine foo = bar + 2 + define bar = 47\fR + +.fi +effectively defines \fCfoo\fR to be \fC49\fR. Beware, however, as there is no +way for the assembler to detect mutually recursive references of this sort, so +that +.nf + + \fCdefine foo = bar + 2 + define bar = foo + 2\fR + +.fi +will be happily swallowed without complaint, until you actually try to use +\fCfoo\fR or \fCbar\fR in an instruction, whereupon \fIMacross\fR's expression +evaluator will go into infinite recursion until it runs out of stack space and +crashes the assembler (it looks to see what \fCfoo\fR is and sees that it's +\fCbar + 2\fR, so it looks to see what \fCbar\fR and see that it's \fCfoo + +2\fR, so it looks to see what \fCfoo\fR is... To have the assembler detect +and signal this error would, in the general case, add much complication and +inefficiency (read: make your programs assemble a lot more slowly) for little +return). +.PP +The scope of symbols defined in either of these two ways extends in time from +the definition itself to the end of the assembly. +.NH 2 +Variable\fR statement +.PP +The \fCvariable\fR statement enables the programmer to declare symbolic +variables for future use. Similar to the \fCdefine\fR statement, it has two +forms. The first +.nf + + \fCvariable\fR \fIsymbolname\fR + +.fi +creates a variable named \fIsymbolname\fR and gives it the special value +\fCunassigned\fR, just like the analogous \fCdefine\fR statement. +.PP +The second form of the \fCvariable\fR statement +.nf + + \fCvariable \fIsymbolname\fR \fC=\fR \fIexpression\fR + +.fi +creates the variable and gives it the value obtained by evaluating +\fIexpression\fR. The scope of variables defined in either of these two ways +extends from the \fCvariable\fR statement itself to the end of the assembly +(i.e., the variable is global). +.PP +The difference between the \fCdefine\fR statement and the \fCvariable\fR +statement is that the \fCdefine\fR statement creates what is in essence a +constant whereas the \fCvariable\fR statement creates a true variable. The +value of a variable may change (e.g., it may be assigned to) during the course +of assembly. In addition, the expression which establishes a symbol's value +in a \fCdefine\fR statement may contain forward references (i.e., labels whose +values are unknown because they haven't been encountered yet) whereas the +expression assigning an initial value to a variable must be made up of terms +all of whose values are known at the time the \fCvariable\fR statement is +encountered in the assembly. +.PP +A variable may also be declared as an array, using the form +.nf + + \fCvariable \fIsymbolname \fC[ \fIlength \fC]\fR + +.fi +where \fIlength\fP is an expression that indicates the number of elements the +array is to have. \fIMacross\fR arrays are zero-based, so the elements are +indexed from 0 to \fIlength\fP-1. As with ordinary variables, the elements of +the array may be initialized in the \fCvariable\fR statement using a statement +of the form +.nf + + \fCvariable \fIsymbolname \fC[ \fIlength \fC] = \fIexpression +\fR\*[ \fC, \fIexpression \fR\*Z + +.fi +The \fIexpression\fPs are assigned sequentially into the elements of the +array. If the array length is greater than the number of \fIexpression\fPs +given, the remaining elements are filled with zeroes. Of course, you should +not specify more than \fIlength\fP expressions or the assembler will complain +at you. +.NH 2 +Macro\fR statement +.PP +The \fCmacro\fR statement is used to define macros (surprise!). Its syntax is +.nf + + \fCmacro\fR \fImacroname\fR \*[ \fIargumentname\fR \*[ \fC,\fR \fIargumentname\fR \*Z \*] \fC{\fR + \*[ \fIstatement\fR \*Z + \fC}\fR + +.fi +where \fImacroname\fR is just that and the \fIargumentname\fRs are identifiers +corresponding to the formal parameters of the macro (in the classical +fashion). When the macro is called, the call arguments are bound to these +symbols and then \fIMacross\fR assembles the \fIstatement\fRs which form the +macro body. The scope of these symbols is limited to the inside of the macro +body and their values go away when the macro expansion is completed. The +\fIstatement\fRs may be any valid \fIMacross\fR statements except for +\fCmacro\fR statements and \fCfunction\fR statements (i.e., macro and function +definitions may not be nested). +.PP +Statement labels used inside macros can be made local to the macro by +preceding the label identifier with a dollar sign (``\fC$\fR''). For +example, +.nf + + \fCmacro fooMac arg { + jmp $foo + word arg + $foo: nop + }\fR + +.fi +defines a macro named \fCfooMac\fR that emits a word of data that gets jumped +over. The label \fC$foo\fR is local to the macro: both the reference to it +in the first line of the macro and its definition on the third will only be +seen inside the macro. Each time the macro is called, the \fCjmp\fR will +refer to the location two instructions ahead, and any other macros that might +contain \fC$foo\fR will not affect this nor will they be affected by this. +.PP +It is possible to define macros which take a variable number of arguments. +This is accomplished by following the last argument in the \fCmacro\fP +statement by \fC[ ]\fR. This declares the argument to be an array, which gets +assigned a list of all of the parameters not accounted for by the other +declared arguments. This array may be interrogated with the +\fCarrayLength()\fR built-in function (to find out how many extra parameters +there were) and accessed just like a regular array. For example, +.nf + + \fCmacro enfoon precision, args[] { + mvariable len = arrayLength(args) + mvariable i + word precision + mfor (i=0, i\fR'' \(em not relevant here. +.LP +All of the assignment operators (``\fC+=\fR'', ``\fC-=\fR'', etc.) +\fIare\fR supported by \fIMacross\fR. +.LP +\fIMacross\fR reinterprets the \fC.\fR operator in that ``\fIexpression\fC . +\fIstructfieldname\fR'' is interpreted as adding the offset value implied by +\fIstructfieldname\fR (i.e., the distance in bytes into a \fCstruct\fR to +reach the named field) to the address that is the value of \fIexpression\fR. +.LP +\fIMacross\fR adds to the operator set the following: +.IP +[1] ``\fC?\fR'' \(em as a unary operator, takes the high order byte of the +word value that is its argument. +.IP +[2] ``\fC/\fR'' \(em as a unary operator, takes the low order byte of the +word value that is its argument. +.IP +[3] ``\fC^^\fR'' \(em a binary operator, denotes logical exclusive-OR. This +is simply an orthogonal extension for the sake of completeness. +.LP +Of course, parenthesis can be used at any point to override the normal +precedence of the various operators. A full list of all the operators that +\fIMacross\fR understands is given in \fBAppendix D\fR. +.NH 1 +\fRExpression evaluation +.PP +In order to make the most effective use of expressions in the \fIMacross\fR +environment, it is helpful (and at times necessary) to understand how and when +\fIMacross\fR evaluates them. +.PP +When \fIMacross\fR evaluates an expression, it may have one of three sorts of +results. These are \fIsuccess\fR, \fIundefined\fR, and \fIfailure\fR. A +\fIsuccess\fR result means that \fIMacross\fR encountered no problems +evaluating the expression, and whatever value it evaluated to is just used as +needed. A \fIfailure\fR result indicates that there was a problem of some +sort. Usually this is a result of some user error. In any case, an +appropriate diagnostic message will be issued by the assembler and the +statement in which the expression was found will not be assembled. +.PP +An \fIundefined\fR result is where the complications, if any, arise. An +expression will evaluate to an \fIundefined\fR result if one or more of the +terms of the expression are undefined symbols. Usually these are labels which +simply haven't been encountered yet (i.e., they are forward references). In +certain contexts, such as the operand of a machine instruction, this is a +legitimate thing to do, and in certain others, such as the condition of a +\fCmif\fR statement, this is not allowed at all. In the latter case, an +\fIundefined\fR result is just like a \fIfailure\fR result. In the former +case, the assembler is forced to get fancy in order to make it all work right. +.PP +What \fIMacross\fR does is squirrel away a copy of the expression along with a +pointer as to where in the object code the value of the expression is supposed +to go. At the end of assembly, the undefined label will presumably now be +defined, and \fIMacross\fR evaluates the saved expression and pokes the result +into the appropriate location. (If, at this point, the undefined label is +still undefined, an error message to that effect is issued). Clearly, if an +expression has side effects (such as changing the value of some global +variable), this can result in some confusing behavior. The \fIMacross\fR +assembler is smart enough to not let you do anything that has overt side +effects in an expression that is being saved away for future evaluation. The +things which are disallowed in such a case are assignments and uses of the +post- and pre-increment and decrement operators (``\fC++\fR'' and +``\fC--\fR''). Functions, however, may have side effects and \fIMacross\fR +does not try to prevent you from using function calls in expressions that get +saved for later evaluation. It can, and will, detect some, but not all, side +effects during the later evaluation and give a suitable error message. This +is because it is perfectly legitimate to use a function call to a function +that doesn't have side effects in an expression containing forward references. +.PP +If you are now totally confused, the only thing you need remember is: \fBDon't +ever use a call to a function that has side effects in an expression +containing a forward reference.\fR +.bp +.CD +\s+5\fBAppendix A \(em Macross 6502 Grammar\fR\s-5 +\"\s+4\fBAppendix A \(em Macross 6502 Grammar\fR\s-4 +.fi +.LP +.nf +\fR\fIprogram\fR: + \*[ \fIstatement\fR Newline \*Z Endfile + +\fIstatement\fR: +\*[ \fIlabel\fR \*Z \fIopcode\fR \*[ \fIoperand\fR \*[ \fC,\fR \fIoperand\fR \*Z \*] +\*[ \fIlabel\fR \*Z \fCif\fR \fC(\fR \fIcondition\fR \fC)\fR \fIblock\fR + \*[ \fCelseif\fR \fC(\fR \fIcondition\fR \fC)\fR \fIblock\fR \*Z + \*[ \fCelse\fR \fIblock\fR \*] +\*[ \fIlabel\fR \*Z \fCwhile\fR \fC(\fR \fIcondition\fR \fC)\fR \fIblock\fR +\*[ \fIlabel\fR \*Z \fCdo\fR \fIblock\fR \fCwhile\fR \fC(\fR \fIcondition\fR \fC)\fR +\*[ \fIlabel\fR \*Z \fCdo\fR \fIblock\fR \fCuntil\fR \fC(\fR \fIcondition\fR \fC)\fR + \fIdataStatement\fR + \fCdefine\fR \fIidentifier\fR \*[ \fC=\fR \fIexpression\fR \*] + \fCvariable\fR \fIidentifier\fR \*[ \fC=\fR \fIexpression\fR \*] + \fCmacro\fR \fIidentifier\fR \*[ \fIidentifier\fR \*[ \fC,\fR \fIidentifier\fR \*Z \*] \fIblock\fR + \fCfunction\fR \fIidentifier\fR \fC(\fR \*[ \fIidentifier\fR \*[ \fC,\fR \fIidentifier\fR \*Z \*] \fC)\fR \fIblock\fR + \fCundefine\fR \fIidentifier\fR \*[ \fC,\fR \fIidentifier\fR \*Z +\*[ \fIlabel\fR \*Z \fIblock\fR + \fCmdefine\fR \fIidentifier\fR \*[ \fC=\fR \fIexpression\fR \*] + \fCmif\fR \fC(\fR \fIexpression\fR \fC)\fR \fIblock\fR + \*[ \fCmelseif\fR \fC(\fR \fIexpression\fR \fC)\fR \fIblock\fR \*Z + \*[ \fCmelse\fR \fIblock\fR \*] + \fCmwhile\fR \fC(\fR \fIexpression\fR \fC)\fR \fIblock\fR + \fCmdo\fR \fIblock\fR \fCwhile\fR \fC(\fR \fIexpression\fR \fC)\fR + \fCmdo\fR \fIblock\fR \fCuntil\fR \fC(\fR \fIexpression\fR \fC)\fR + \fCfreturn\fR \*[ \fIexpression\fR \*] + \fCmfor\fR \fC(\fR \fIexpression\fR \fC,\fR \fIexpression\fR \fC,\fR \fIexpression\fR \fC)\fR \fIblock\fR + \fCmswitch ( \fIselectionExpression \fC) {\fR + \*[ \fCmcase ( \fIexpression\fR \*[ \fC,\fI expression\fR \*Z \fC)\fI block\fR \*Z + \*[ \fCmdefault\fI block\fR \*] + \fC}\fR + \fCconstrain\fR \fC(\fR \fIexpression\fR \fC)\fR \fIblock\fR + \fCassert\fR \fC(\fR \fIexpression\fR \fC)\fR \*[ \fIexpression\fR \*] + \fCinclude\fR \fItextString\fR + \fCextern\fR \fIidentifier\fR \*[ \fC,\fR \fIidentifier\fR \*Z + \fCstart\fR \fIexpression\fR + \fCorg\fR \fIexpression\fR + \fCtarget\fR \fIexpression\fR + \fIexpression\fR + +\fIdataStatement\fR: +\*[ \fIlabel\fR \*Z \fCblock\fR \fIexpression\fR \*[ \fC,\fR \fIexpression\fR \*Z +\*[ \fIlabel\fR \*Z \fCalign\fR \fIexpression\fR +\*[ \fIlabel\fR \*Z \fCword\fR \fIexpression\fR \*[ \fC,\fR \fIexpression\fR \*Z +\*[ \fIlabel\fR \*Z \fClong\fR \fIexpression\fR \*[ \fC,\fR \fIexpression\fR \*Z +\*[ \fIlabel\fR \*Z \fCdbyte\fR \fIexpression\fR \*[ \fC,\fR \fIexpression\fR \*Z +\*[ \fIlabel\fR \*Z \fCbyte\fR \fIexpression\fR \*[ \fC,\fR \fIexpression\fR \*Z +\*[ \fIlabel\fR \*Z \fCstring\fR \fIexpression\fR \*[ \fC,\fR \fIexpression\fR \*Z +\*[ \fIlabel\fR \*Z \fCstruct\fR \fC{\fR \*[ \fIdataStatement\fR \*Z \fC}\fR \fIidentifier\fR +\*[ \fIlabel\fR \*Z \fCstruct\fR \fIidentifier\fR + +\fIlabel\fR: \fIidentifier\fR \fC:\fR + +\fIoperand\fR: + \fIexpression\fR + \fC@\fR \fIexpression\fR + \fC#\fR \fIexpression\fR + \fCa\fR + \fCx\fR + \fCy\fR + \fCx\fR \fC\s-1[\s+1\fR \fIexpression\fR \fC\s-1]\s+1\fR + \fCx\fR \fC.\fR \fIidentifier\fR \*[ \fC.\fR \fIidentifier\fR \*Z + \fCy\fR \fC\s-1[\s+1\fR \fIexpression\fR \fC\s-1]\s+1\fR + \fCy\fR \fC.\fR \fIidentifier\fR \*[ \fC.\fR \fIidentifier\fR \*Z + \fC@\fR \fCx\fR \fC\s-1[\s+1\fR \fIexpression\fR \fC\s-1]\s+1\fR + \fC@\fR \fCx\fR \fC.\fR \fIidentifier\fR \*[ \fC.\fR \fIidentifier\fR \*Z + \fCy\fR \fC\s-1[\s+1\fR \fC@\fR \fIexpression\fR \fC\s-1]\s+1\fR + \fItextString\fR + +\fIblock\fR: \fC{\fR \*[ \fIstatement\fR Newline \*Z \fC}\fR + +\fItextString\fR: + \fC" \fIany string you like \fC"\fR + +\fIcondition\fR: + \fIconditionCode\fR + \fC!\fR \fIconditionCode\fR + +\fIexpression\fR: + \fIidentifier\fR + \fIidentifier\fR \fC(\fR \*[ \fIoperand\fR \*[ \fC,\fR \fIoperand\fR \*Z \*] \fC)\fR + \fInumber\fR + \fChere\fR + \fItextString\fR + \fC(\fR \fIexpression\fR \fC)\fR + \fC-\fR \fIexpression\fR + \fC!\fR \fIexpression\fR + \fC~\fR \fIexpression\fR + \fC?\fR \fIexpression\fR + \fC/\fR \fIexpression\fR + \fIexpression\fR \fC*\fR \fIexpression\fR + \fIexpression\fR \fC/\fR \fIexpression\fR + \fIexpression\fR \fC%\fR \fIexpression\fR + \fIexpression\fR \fC-\fR \fIexpression\fR + \fIexpression\fR \fC+\fR \fIexpression\fR + \fIexpression\fR \fC<<\fR \fIexpression\fR + \fIexpression\fR \fC>>\fR \fIexpression\fR + \fIexpression\fR \fC<\fR \fIexpression\fR + \fIexpression\fR \fC>\fR \fIexpression\fR + \fIexpression\fR \fC<=\fR \fIexpression\fR + \fIexpression\fR \fC>=\fR \fIexpression\fR + \fIexpression\fR \fC==\fR \fIexpression\fR + \fIexpression\fR \fC!=\fR \fIexpression\fR + \fIexpression\fR \fC&\fR \fIexpression\fR + \fIexpression\fR \fC|\fR \fIexpression\fR + \fIexpression\fR \fC^\fR \fIexpression\fR + \fIexpression\fR \fC&&\fR \fIexpression\fR + \fIexpression\fR \fC||\fR \fIexpression\fR + \fIexpression\fR \fC^^\fR \fIexpression\fR + \fIexpression\fR \fC.\fR \fIidentifier\fR + \fIidentifier\fR \fC=\fR \fIexpression\fR + \fIidentifier\fR \fC+=\fR \fIexpression\fR + \fIidentifier\fR \fC-=\fR \fIexpression\fR + \fIidentifier\fR \fC*=\fR \fIexpression\fR + \fIidentifier\fR \fC/=\fR \fIexpression\fR + \fIidentifier\fR \fC%=\fR \fIexpression\fR + \fIidentifier\fR \fC&=\fR \fIexpression\fR + \fIidentifier\fR \fC|=\fR \fIexpression\fR + \fIidentifier\fR \fC^=\fR \fIexpression\fR + \fIidentifier\fR \fC<<=\fR \fIexpression\fR + \fIidentifier\fR \fC>>=\fR \fIexpression\fR + \fIidentifier\fR \fC++\fR + \fIidentifier\fR \fC--\fR + \fC++\fR \fIidentifier\fR + \fC--\fR \fIidentifier\fR + +\fIidentifier\fR: + \*[\fCa\fR-\fCzA\fR-\fCZ_\fR\*]\*[\fCa\fR-\fCzA\fR-\fCZ_0\fR-\fC9\fR\*Z + +\fInumber\fR: + \fIdecimalNumber\fR + \fIoctalNumber\fR + \fIbinaryNumber\fR + \fIhexadecimalNumber\fR + \fIquarter\fR + +\fIdecimalNumber\fR: + \*[\fC1\fR-\fC9\fR\*]\*[\fC0\fR-\fC9\fR\*Z + +\fIoctalNumber\fR: + \fC0\fR\*[\fC0\fR-\fC7\fR\*Z + +\fIbinaryNumber\fR: + \fC0b\fR\*[\fC01\fR\*]\*[\fC01\fR\*Z + +\fIhexadecimalNumber\fR: + \fC0x\fR\*[\fC0\fR-\fC9a\fR-\fCf\fR\*]\*[\fC0\fR-\fC9a\fR-\fCf\fR\*Z + +\fIquarter\fR: + \fC0q\fR\*[\fC0\fR-\fC3\fR\*]\*[\fC0\fR-\fC3\fR\*Z + +.fi +.bp +.CD +\s+5\fBAppendix B \(em Condition Codes\fR\s-5 +\"\s+4\fBAppendix B \(em Condition Codes\fR\s-4 +.sp 1 +\s+3\fB(6502 version)\fR\s-3 +.fi +.PP +The \fIMacross\fR \fCif\fR, \fCwhile\fR, \fCdo-while\fR and \fCdo-until\fR +statements make use of symbols denoting the hardware condition codes of the +target processor which may be used as the conditions upon which conditional +branches are base. In the 6502 version of \fIMacross\fR, these are the +recognized condition code symbols: +.SH +\s+2\fBConditions which generate simple branches\fR\s-2 +.nf + \fCcarry\fR tests carry bit + + \fCequal\fR tests zero bit + \fCzero\fR + + \fCneq\fR (equivalent to, e.g., \fC!equal\fR) + + \fCminus\fR tests negative bit + \fCnegative\fR + + \fCplus\fR (equivalent to, e.g., \fC!minus\fR) + \fCpositive\fR + + \fCoverflow\fR tests overflow bit + +.fi +.SH +\s+2\fBConditions which generate complex branches\fR\s-2 +.NH 0 +lt\fR \(em less than (valid after \fCcmp\fR or \fCsbc\fR) +.PP +For example, +.nf + + \fCif (lt) {\fR + \fI...stuff...\fR + \fC}\fR + + generates + + \fCbcs temp\fR + \fI...stuff...\fR + \fCtemp:\fR +.fi +.NH 1 +leq\fR \(em less than or equal to (valid after \fCcmp\fR or \fCsbc\fR) +.PP +For example, +.nf + + \fCif (leq) {\fR + \fI...stuff...\fR + \fC}\fR + + generates + + \fCbeq temp1\fR + \fCbcs temp2\fR + \fCtemp1:\fR + \fI...stuff...\fR + \fCtemp2:\fR +.fi +.NH 1 +geq\fR \(em greater than or equal to (valid after \fCcmp\fR or \fCsbc\fR) +.PP +For example, +.nf + + \fCif (geq) {\fR + \fI...stuff...\fR + \fC}\fR + + generates + + \fCbcc temp\fR + \fI...stuff...\fR + \fCtemp:\fR +.fi +.NH 1 +gt\fR \(em greater than (valid after \fCcmp\fR or \fCsbc\fR) +.PP +For example, +.nf + + \fCif (gt) {\fR + \fI...stuff...\fR + \fC}\fR + + generates + + \fCbcc temp\fR + \fCbeq temp\fR + \fI...stuff...\fR + \fCtemp:\fR +.fi +.NH 1 +slt\fR \(em signed less than (valid after \fCsbc\fR only) +.PP +For example, +.nf + + \fCif (slt) {\fR + \fI...stuff...\fR + \fC}\fR + + generates + + \fCbvs temp1\fR + \fCbpl temp3\fR + \fCbmi temp2\fR + \fCtemp1: bmi temp3\fR + \fCtemp2:\fR + \fI...stuff...\fR + \fCtemp3:\fR +.fi +.NH 1 +sleq\fR \(em signed less than or equal to (valid after \fCsbc\fR only) +.PP +For example, +.nf + + \fCif (sleq) {\fR + \fI...stuff...\fR + \fC}\fR + + generates + + \fCbeq temp2\fR + \fCbvs temp1\fR + \fCbpl temp3\fR + \fCbmi temp2\fR + \fCtemp1: bmi temp3\fR + \fCtemp2:\fR + \fI...stuff...\fR + \fCtemp3:\fR +.fi +.NH 1 +sgt\fR \(em signed greater than (valid after \fCsbc\fR only) +.PP +For example, +.nf + + \fCif (sgt) {\fR + \fI...stuff...\fR + \fC}\fR + + generates + + \fCbeq temp3\fR + \fCbvs temp1\fR + \fCbmi temp3\fR + \fCbpl temp2\fR + \fCtemp1: bpl temp3\fR + \fCtemp2:\fR + \fI...stuff...\fR + \fCtemp3:\fR +.fi +.NH 1 +sgeq\fR \(em signed greater than or equal to (valid after \fCsbc\fR only) +.PP +For example, +.nf + + \fCif (sgeq) {\fR + \fI...stuff...\fR + \fC}\fR + + generates + + \fCbvs temp1\fR + \fCbmi temp3\fR + \fCbpl temp2\fR + \fCtemp1: bpl temp3\fR + \fCtemp2:\fR + \fI...stuff...\fR + \fCtemp3:\fR +.fi +.bp +.CD +\s+5\fBAppendix C \(em Built-In Functions\fR\s-5 +\"\s+4\fBAppendix C \(em Built-In Functions\fR\s-4 +.fi +.PP +Certain predefined built-in functions are supported by \fIMacross\fR for +reasons of convenience or syntactic or semantic irregularity. They are: +.LP +\fCaddressMode(\fIoperand\fC)\fR +.IP +Returns a number whose value indicates which addressing mode \fIoperand\fR +represents \fI((define these values))\fR. +.LP +\fCapply(\fImacname\fR \*[ \fC, \fIarg\fR \*Z \fC)\fR +.IP +Assembles the macro whose name is specified by the \fCstring\fR \fImacname\fR +with the macro arguments (if any) given by the \fIarg\fRs. +.LP +\fCarrayLength(\fIarray\fC)\fR +.IP +Returns the number of elements in the array \fIarray\fP. +.LP +\fCatascii(\fIstring\fC)\fR +.IP +Returns a string which is \fIstring\fR with each character mapped through an +ASCII to ATASCII (Atari's ASCII deviant character code) conversion table. +.LP +\fCatasciiColor(\fIstring\fC, \fIcolor\fC)\fR +.IP +Returns a string which is \fIstring\fR with each character mapped through the +ASCII to ATASCII conversion table, and then the two-bit value specified by +\fIcolor\fR OR'ed into the high order two bits of each character. +.LP +\fCisAbsoluteValue(\fIoperand\fC)\fR +.IP +Returns \fCTRUE\fR if and only if \fIoperand\fR is an absolute (i.e., +non-relocatable) value, otherwise \fCFALSE\fR. +.LP +\fCisARegister(\fIoperand\fC)\fR +.IP +Returns \fCTRUE\fR if and only if \fIoperand\fR is \fCa\fR (i.e., the +accumulator), otherwise \fCFALSE\fR. +.LP +\fCisBlock(\fIoperand\fC)\fR +.IP +Returns \fCTRUE\fR if and only if \fIoperand\fR is a block, otherwise +\fCFALSE\fR. +.LP +\fCisBuiltInFunction(\fIsymbol\fC)\fR +.IP +Returns \fCTRUE\fR if and only if \fIsymbol\fR is a built-in function, +otherwise \fCFALSE\fR. +.LP +\fCisConditionCode(\fIoperand\fC)\fR +.IP +Returns \fCTRUE\fR if and only if \fIoperand\fR is a condition code, +otherwise \fCFALSE\fR. +.LP +\fCisDefined(\fIsymbol\fC)\fR +.IP +Returns \fCTRUE\fR if and only if \fIsymbol\fR has been defined, otherwise +\fCFALSE\fR. +.LP +\fCisDirectMode(\fIoperand\fC)\fR +.IP +Returns \fCTRUE\fR if and only if the address mode of \fIoperand\fR is +\fIdirect\fR, otherwise \fCFALSE\fR. +.LP +\fCisExternal(\fIsymbol\fC)\fR +.IP +Returns \fCTRUE\fR if and only if \fIsymbol\fR is external (i.e., visible +outside the file in which it is defined), otherwise \fCFALSE\fR. +.LP +\fCisField(\fIsymbol\fC)\fR +.IP +Returns \fCTRUE\fR if and only if \fIsymbol\fR is a field of a struct, +otherwise \fCFALSE\fR. +.LP +\fCisFunction(\fIsymbol\fC)\fR +.IP +Returns \fCTRUE\fR if and only if \fIsymbol\fR is a user defined function, +otherwise \fCFALSE\fR. +.LP +\fCisImmediateMode(\fIoperand\fC)\fR +.IP +Returns \fCTRUE\fR if and only if the address mode of \fIoperand\fR is +\fIimmediate\fR, otherwise \fCFALSE\fR. +.LP +\fCisIndexedMode(\fIoperand\fC)\fR +.IP +Returns \fCTRUE\fR if and only if the address mode of \fIoperand\fR is an +indexed mode, otherwise \fCFALSE\fR. +.LP +\fCisIndirectMode(\fIoperand\fC)\fR +.IP +Returns \fCTRUE\fR if and only if the address mode of \fIoperand\fR is +\fIindirect\fR, otherwise \fCFALSE\fR. +.LP +\fCisPostIndexedMode(\fIoperand\fC)\fR +.IP +Returns \fCTRUE\fR if and only if the address mode of \fIoperand\fR is +\fIpost-indexed\fR, otherwise \fCFALSE\fR. +.LP +\fCisPreIndexedMode(\fIoperand\fC)\fR +.IP +Returns \fCTRUE\fR if and only if the address mode of \fIoperand\fR is +\fIpre-indexed\fR, otherwise \fCFALSE\fR. +.LP +\fCisRelocatableValue(\fIoperand\fC)\fR +.IP +Returns \fCTRUE\fR if and only if \fIoperand\fR is a relocatable value, +otherwise \fCFALSE\fR. +.LP +\fCisString(\fIoperand\fC)\fR +.IP +Returns \fCTRUE\fR if and only if \fIoperand\fR is a string, otherwise +\fCFALSE\fR. +.LP +\fCisStruct(\fIsymbol\fC)\fR +.IP +Returns \fCTRUE\fR if and only if \fIsymbol\fR is the name of a struct, +otherwise \fCFALSE\fR. +.LP +\fCisSymbol(\fIoperand\fC)\fR +.IP +Returns \fCTRUE\fR if and only if \fIoperand\fR is a symbol (as opposed to an +expression or a number, for example), otherwise \fCFALSE\fR. +.LP +\fCisXIndexedMode(\fIoperand\fC)\fR +.IP +Returns \fCTRUE\fR if and only if the address mode of \fIoperand\fR is +\fIx-indexed\fR, otherwise \fCFALSE\fR. +.LP +\fCisXRegister(\fIoperand\fC)\fR +.IP +Returns \fCTRUE\fR if and only if \fIoperand\fR is \fCx\fR, otherwise +\fCFALSE\fR. +.LP +\fCisYIndexedMode(\fIoperand\fC)\fR +.IP +Returns \fCTRUE\fR if and only if the address mode of \fIoperand\fR is +\fIy-indexed\fR, otherwise \fCFALSE\fR. +.LP +\fCisYRegister(\fIoperand\fC)\fR +.IP +Returns \fCTRUE\fR if and only if \fIoperand\fR is \fCy\fR, otherwise +\fCFALSE\fR. +.LP +\fClistingOff()\fR +.IP +If assembly listing has been enabled using the \fC-l\fR command line flag, +turn listing off temporarily. Otherwise, no effect. +.LP +\fClistingOn()\fR +.IP +If assembly listing was turned off using the \fClistingOff()\fR function, turn +it back on again. If listings have been globally disabled by not specifying +the \fC-l\fR command line flag, this function has no effect. The +\fClistingOff()\fR and \fClistingOn()\fR functions are intended to be used to +together to control assembly listings of large programs. They can be used to +suppress listing of large and uninteresting sections such as header files full +of definitions of global values. These functions may nest: in effect +\fClistingOff()\fR increments a counter and \fClistingOn()\fR decrements it. +Only when the counter is zero (i.e., the number of \fClistingOn()\fRs matches +the number of \fClistingOff()\fRs) does listing actually occur. +.LP +\fCmakeArray(\fIlength\fR \*[ \fC, \fIelement\fR \*Z \fC)\fR +.IP +Creates an array of length \fIlength\fP and returns it. Optionally fills the +array with the values specified by the \fIelement\fP expressions. If the +number of \fIelement\fPs given is greater than \fIlength\fP, an error results. +.LP +\fCnthChar(\fIstring\fR \*[ \fC, \fIposition\fR \*] \fC)\fR +.IP +Returns the \fIposition\fPth character of the string \fIstring\fP (position +zero being the first character in the string). If \fIposition\fP is omitted +it defaults to zero. If \fIposition\fP is greater than the length of +\fIstring\fP, an error results. +.LP +\fCprintf(\fIformat\fR \*[ \fC, \fIarg\fR \*Z \fC)\fR +.IP +A formatted print routine just like the Unix system subroutine of the same +name. +.LP +\fCstrcat(\fIstring1\fC, \fIstring2\fC)\fR +.IP +Returns a string which is the concatenation of the two operands, which must +themselves be strings. +.LP +\fCstrcmp(\fIstring1\fC, \fIstring2\fC)\fR +.IP +Returns a number which is less than, equal to, or greater than 0 depending +upon whether \fIstring1\fR is lexically less than, equal to, or greater than +\fIstring2\fR. The ASCII character set is used. The two operands, of course, +must be strings. +.LP +\fCstrcmplc(\fIstring1\fC, \fIstring2\fC)\fR +.IP +Essentially the same as \fCstrcmp()\fR except that alphabetic characters are +converted to lower case before being compared. The result is a +case-independent string comparison. This is useful for comparing two +identifier name strings to see if they represent the same symbols. +.LP +\fCstrlen(\fIstring\fC)\fR +.IP +Returns a number which is the length, in characters, of \fIstring\fR. +.LP +\fCsubstr(\fIstring\fC, \fIstartPos\fR \*[\fC , \fIlength\fR \*] \fC)\fR +.IP +Returns a substring of the string \fIstring\fR starting from the character at +start position \fIstartPos\fR (counting the first character from 0) and +continuing for \fIlength\fR characters. If \fIstartPos\fR is negative, the +start position is counted from right to left (with the rightmost character +position being indicated by -1) instead of the more usual left to right. If +\fIlength\fR is negative, \fIstartPos\fR in essence denotes the end of the +desired substring and \fIlength\fR characters up to that position are +returned. If \fIlength\fR is omitted, the substring from \fIstartPos\fR to +the end of the string is returned, if \fIstartPos\fR is positive, or to the +beginning of the string, if \fIstartPos\fR is negative. If any of the indices +cause the substring bounds to go off the end of \fIstring\fR an error results. +For example, +.nf + \fCsubstr("hello there", 6, 3)\fR yields \fC"the"\fR + \fCsubstr("hello there", -8, 2)\fR yields \fC"lo"\fR + \fCsubstr("hello there", 6, -3)\fR yields \fC"o t"\fR + \fCsubstr("hello there", -8, -4)\fR yields \fC"hell"\fR + \fCsubstr("hello there", 6)\fR yields \fC"there"\fR + \fCsubstr("hello there", -7)\fR yields \fC"hello"\fR +.fi +.LP +\fCsymbolDefine(\fIstring\fR \*[ \fC, \fIvalue\fR \*] \fC)\fR +.IP +Defines the symbol named by \fIstring\fP (with optional value \fIvalue\fP) as +if it had been defined with a \fCdefine\fR statement. For example: +.nf + \fCsymbolDefine(strcat("foon", "farm"), 47)\fR +.fi +is equivalent to +.nf + \fCdefine foonfarm = 47\fR +.fi +.LP +\fCsymbolLookup(\fIstring\fC)\fR +.IP +A call to this function with a string operand is equivalent to a reference to +the symbol that the string represents. For example, +.nf + \fCand symbolLookup("foo")\fR +.fi +is equivalent to +.nf + \fCand foo\fR +.fi +.LP +\fCsymbolName(\fIsymbol\fC)\fR +.IP +Returns a string which is the name of the symbol \fIsymbol\fR. For example, +\fCsymbolName(foo)\fR would return \fC"foo"\fR. This can be used in +conjunction with the \fCsymbolLookup\fR function so that the following: +.nf + \fCand symbolLookup(strcat(symbolName(foo), "bar"))\fR +.fi +is equivalent to +.nf + \fCand foobar\fR +.fi +.LP +\fCsymbolUsage(\fIsymbol\fC)\fR +.IP +Returns a number whose value indicates what sort of symbol \fIsymbol\fR is +(i.e., label, function, struct field, etc.). \fI((define these values))\fR +.LP +\fCvalueType(\fIthing\fC)\fR +.IP +Returns a number whose value indicates the type of \fIthing\fR (i.e., symbol, +condition code, number, block, etc.). \fI((define these values))\fR +.bp +.CD +\s+5\fBAppendix D \(em Operator Set\fR\s-5 +\"\s+4\fBAppendix D \(em Operator Set\fR\s-4 +.fi +.PP +This appendix describes the (\fBC\fR derived) operators supported by +\fIMacross\fR. +.nf + + \fC-\fR \fIexpression\fR integer negation + \fC!\fR \fIexpression\fR logical negation (0 goes to 1, all other values go to 0) + \fC~\fR \fIexpression\fR bitwise negation (ones complement) + \fC?\fR \fIexpression\fR high byte + \fC/\fR \fIexpression\fR low byte + \fIexpression\fR \fC*\fR \fIexpression\fR integer multiplication + \fIexpression\fR \fC/\fR \fIexpression\fR integer division + \fIexpression\fR \fC%\fR \fIexpression\fR integer modulus (remainder) + \fIexpression\fR \fC-\fR \fIexpression\fR integer subtraction + \fIexpression\fR \fC+\fR \fIexpression\fR integer addition + \fIexpression\fR \fC<<\fR \fIexpression\fR left shift + \fIexpression\fR \fC>>\fR \fIexpression\fR right shift + \fIexpression\fR \fC<\fR \fIexpression\fR less than + \fIexpression\fR \fC>\fR \fIexpression\fR greater than + \fIexpression\fR \fC<=\fR \fIexpression\fR less than or equal to + \fIexpression\fR \fC>=\fR \fIexpression\fR greater than or equal to + \fIexpression\fR \fC==\fR \fIexpression\fR equal to + \fIexpression\fR \fC!=\fR \fIexpression\fR not equal to + \fIexpression\fR \fC&\fR \fIexpression\fR bitwise AND + \fIexpression\fR \fC|\fR \fIexpression\fR bitwise OR + \fIexpression\fR \fC^\fR \fIexpression\fR bitwise XOR + \fIexpression\fR \fC&&\fR \fIexpression\fR logical AND + \fIexpression\fR \fC||\fR \fIexpression\fR logical OR + \fIexpression\fR \fC^^\fR \fIexpression\fR logical XOR + \fIexpression\fR \fC.\fR \fIidentifier\fR struct field selection + \fIidentifier\fR \fC=\fR \fIexpression\fR assignment + \fIidentifier\fR \fC+=\fR \fIexpression\fR assignment with addition + \fIidentifier\fR \fC-=\fR \fIexpression\fR assignment with subtraction + \fIidentifier\fR \fC*=\fR \fIexpression\fR assignment with multiplication + \fIidentifier\fR \fC/=\fR \fIexpression\fR assignment with division + \fIidentifier\fR \fC%=\fR \fIexpression\fR assignment with modulus + \fIidentifier\fR \fC&=\fR \fIexpression\fR assignment with AND + \fIidentifier\fR \fC|=\fR \fIexpression\fR assignment with OR + \fIidentifier\fR \fC^=\fR \fIexpression\fR assignment with XOR + \fIidentifier\fR \fC<<=\fR \fIexpression\fR assignment with left shift + \fIidentifier\fR \fC>>=\fR \fIexpression\fR assignment with right shift + \fIidentifier\fR \fC++\fR post-increment + \fIidentifier\fR \fC--\fR post-decrement + \fC++\fR \fIidentifier\fR pre-increment + \fC--\fR \fIidentifier\fR pre-decrement + +.fi +.bp +.CD +\s+5\fB Appendix E \(em Character Escape Codes\fR\s-5 +\"\s+4\fB Appendix E \(em Character Escape Codes\fR\s-4 +.fi +.PP +Like \fBC\fR, \fIMacross\fR enables you to use the ``\fC\\\fR'' character as +an escape to embed quotation marks, formatting characters (such as newline) +and other non-printing characters in character strings and character +constants. The recognized codes are: +.nf + + \fC\\n\fR newline + \fC\\t\fR horizontal tab + \fC\\b\fR backspace + \fC\\r\fR carriage return + \fC\\f\fR form feed + \fC\\e\fR escape + \fC\\\\\fR backslash + \fC\\'\fR apostrophe + \fC\\"\fR quote + \fC\\^\fIc\fR CONTROL-\fIc\fR (where \fIc\fR is any character). + \fC\\\fIddd\fR arbitrary byte (where \fIddd\fR is one, two or three octal digits). +.fi +.bp +.CD +\s+5\fBAppendix F \(em Recognized Opcode Mnemonics\fR\s-5 +\"\s+4\fBAppendix F \(em Recognized Opcode Mnemonics\fR\s-4 +.sp 1 +\s+3\fB(6502 version)\fR\s-3 +.fi +.PP +These are the 6502 opcode mnemonics recognized by \fIMacross\fR: +.2C +.nf +\fCadc +and +asl +bcc +bcs +beq +bit +bmi +bne +bpl +brk +bvc +bvs +clc +cld +cli +clv +cmp +cpx +cpy +dec +dex +dey +eor +inc +inx +iny +jmp +jsr +lda +ldx +ldy +lsr +nop +ora +pha +php +pla +plp +rol +ror +rti +rts +sbc +sec +sei +sta +stx +sty +tax +tay +tsx +txa +txs +tya +.fi +.1C diff --git a/doc/writeup_68000.itr b/doc/writeup_68000.itr new file mode 100644 index 0000000..0736e97 --- /dev/null +++ b/doc/writeup_68000.itr @@ -0,0 +1,2262 @@ +.ds [ \s+1\z[\h'1p'\z[\h'-1p'\s-1\0 +.ds ] \s+1\z]\h'-1p'\z]\s-1\0 +.ds Z \s+1\z]\h'-1p'\z]\h'3p'\z*\s-1\0 +.TL +\s+6Macross 68000\s-6 +\"Macross +.AU +an assembler for people who hate assembly language +by +Chip Morningstar +.AI +Lucasfilm Ltd. Games Division +\\*(DY +.ds LH Macross +.ds CH \\*(DY +.ds RH 68000 Version +.ds LF Lucasfilm Ltd. Proprietary Information +.ds CF - % - +.ds RF CONFIDENTIAL +.AB +This document describes the 68000 version of \fIMacross\fR, a super-duper +cross-assembler that has but to be used! +.AE +.SH +\s+3Introduction\s-3 +\"Introduction +.PP +\fIMacross\fR is a generic cross assembler for a variety of different +microprocessors. This document describes the 68000 version of \fIMacross\fR. +\fIMacross\fR differs from many macro assemblers in that it provides a number +of ``higher level'' constructs not traditionally found in assembly language. +These include block-structured flow-of-control statements (\fBif\fR, +\fBwhile\fR, etc.) and the ability to define record-oriented data structures +(\fBstruct\fR). In addition, it contains a powerful macro capability that is +based on syntactic structural manipulations rather than simple text +substitution. \fIMacross\fR is, in fact, a complete block-structured +programming language in its own right which is interpreted at assembly time. +.SH +\s+3General Form of \fIMacross\fP Statements\s-3 +\"General Form of \fIMacross\fP Statements +.PP +Stylistically, much of \fIMacross\fR is patterned after \fBC\fR. In +particular, the form of many keywords and of block structured entities is +derived from \fBC\fR. Unlike \fBC\fR however, \fIMacross\fR follows the +convention of more traditional assemblers that statements are delimited by +line boundaries (i.e., one statement per line, with the end of a line ending a +statement). +.PP +In general, spaces and tabs are treated as whitespace characters and are +ignored. Therefore, such characters may be used as the assembly language +programmer desires to format his or her program according to personal taste. +For the convenience of the programmer, \fIMacross\fR relaxes the syntax rule +that newlines always end a statement: newlines may also be treated as +whitespace characters (again, for purposes of formatting) in places where it +would be syntactically unambiguous to do so (i.e., where a statement obviously +cannot terminate, such as after a comma). For example: +.nf + + \fBbyte 1, 2, 3, 4, + 5, 6, 7, 8\fR + +.fi +is allowed and is equivalent to +.nf + + \fBbyte 1, 2, 3, 4, 5, 6, 7, 8 + +.fi +.PP +Comments begin with a semicolon (``\fB;\fR'') and continue to the end of the +line, as is common in many assemblers. In addition, \fIMacross\fR supports +\fBC\fR style comments bracketed by ``\fB/*\fR'' and ``\fB*/\fR''. +.PP +As with most assemblers, \fIMacross\fR statements are allowed to begin with a +label (or several labels, if you like). A label is denoted by an identifier +followed by a colon (``\fB:\fR''). There is no requirement that the label +start in column 1, or anything like that. Labels, if present, merely must +precede anything else in a statement. +.PP +An identifier is just what you'd expect from all your years of programming +experience: a string of letters and digits that must begin with a letter. As +is traditional in Unix* +.FS * +Unix is a footnote of Bell Laboratories. +.FE +land, the underscore character (``\fB_\fR'') is considered to be a letter +(smacks of hubris that, but tradition is tradition). Departing from Unix +tradition, upper- and lower-case characters are not distinct from each other +for purposes of distinguishing identifiers. If you use mixed case for +stylistic reasons, \fIMacross\fR will remember the case of the letters in an +identifier when it was first defined, so that symbol table dumps and +cross-reference listings will retain whatever case usage style you've adopted. +There is, in principle, no restriction imposed upon the length of identifiers. +.SH +\s+3The Language\s-3 +.PP +In what follows, things in \fBboldface\fR are keywords and characters that are +used literally. Things in \fIitalics\fR are other kinds of syntactic +entities. Double brackets (``\*['' and ``\*]'') enclose things that are +optional, while brackets followed by an asterisk (``*'') enclose things that +may be optionally repeated zero or more times. +.NH 1 +The Instruction Statement +.PP +The most elementary \fIMacross\fR statement is the instruction statement, +wherein the programmer specifies a machine instruction to be assembled. The +instruction statement is +.nf + +\*[ \fIlabel\fR \*Z \fIopcode\fR \*[ \fIoperand\fR \*[ \fB,\fR \fIoperand\fR \*Z \*] + +.fi +just like every assembler ever made (except \fBa65\fR, of course). +\fIOpcode\fR is an identifier which is either a machine instruction mnemonic +(a list of which mnemonics are accepted by \fIMacross\fR is given in +\fBAppendix B\fR at the end of this document) or a macro name. For example: +.nf + + \fBandb foobar, d3\fR + \fBsomeMacro foo, bar, baz, bletch\fR + +.fi +.PP +The operands of an instruction may be any of the various types of operands +allowed by the various address modes of the target processor. In the case +of the 68000, these are: +.NH 2 +\fRRegister mode +.PP +Register operands take one of the forms +.nf + + \fBd\fIn\fR + \fBa\fIn\fR + \fBsp\fR + +.fi +where \fIn\fR is a digit from \fB0\fR to \fB7\fR. \fBd\fIn\fR of course +represents a data register and \fBa\fIn\fR represents an address register. +\fBsp\fR is equivalent to \fBa7\fR. +.NH 2 +\fRRegister indirect mode +.PP +Register indirect mode operands take the form +.nf + + \fB\s-1[\s+1\fBa\fIn\fB\s-1]\s+1\fR + +.fi +where \fBa\fIn\fR is some address register. +.NH 2 +\fRPostincrement mode +.PP +Postincrement mode operands take the form +.nf + + \fB\s-1[\s+1\fBa\fIn\fB\s-1]\s+1+\fR + +.fi +where \fBa\fIn\fR is some address register. +.NH 2 +\fRPredecrement mode +.PP +Predecrement mode operands take the form +.nf + + \fB-\s-1[\s+1\fBa\fIn\fB\s-1]\s+1\fR + +.fi +where \fBa\fIn\fR is some address register. +.NH 2 +\fRNormal mode +.PP +Normal mode addresses take the form +.nf + + \fIexpression\fR + +.fi +and are used in a couple of different ways. First, normal mode addresses are +used by instructions that require relative addresses (such as branch +instructions; the offset is computed automatically by \fIMacross\fR). Second, +the normal mode form of addresses is a shorthand way of refering to locations +for which \fIMacross\fR selects an appropriate address mode to use (PC +relative if it can, otherwise absolute). +.NH 2 +\fRAbsolute mode +.PP +Absolute addresses take one of these two forms +.nf + + \fIexpression\fB . w\fR + \fIexpression\fB . l\fR + +.fi +with the \fBw\fR or \fBl\fR indicating whether to generate a short (16 bit) or +a long (32 bit) address. +.NH 2 +\fRImmediate mode +.PP +Immediate mode operands take the form +.nf + + \fB#\fR \fIexpression\fR + +.fi +Generally speaking, in the 68000 immediate mode operands are restricted to +sixteen bit quantities. Depending upon the particular instruction involved, +the size may be even more restricted. \fIMacross\fR will give an error +message if the operand value is larger than allowed. +.NH 2 +\fRDisplacement mode +.PP +Displacement mode operands take the form +.nf + + \fIexpression\fR \fB\s-1[\s+1\fR \fBa\fIn\fR \fB\s-1]\s+1\fR + +.fi +where \fIexpression\fR is an offset off of the address register \fBa\fIn\fR. +These displacement values are limited to 16 bit quantities in the 68000. +.PP +An alternate form of displacment mode addressing which is supported by +\fIMacross\fR allows the symbolic selection of a field of a \fBstruct\fR +pointed to by an address register +.nf + + \fBa\fIn\fR \fB.\fR \fIidentifier\fR \*[ \fB.\fR \fIidentifier\fR \*Z + +.fi +This is explained in greater detail in the sections on \fBstruct\fRs and +expressions below. +.NH 2 +\fRIndexed mode +.PP +Indexed mode addressing is specified by operands of the form +.nf + + \fIexpression\fR \fB\s-1[\s+1\fR \fBa\fIn\fR \fB,\fR \fIrn\fR \fB. w \s-1]\s+1\fR + \fIexpression\fR \fB\s-1[\s+1\fR \fBa\fIn\fR \fB,\fR \fIrn\fR \fB. l \s-1]\s+1\fR + \fIexpression\fR \fB\s-1[\s+1\fR \fBa\fIn\fR \fB,\fR \fIrn\fR \fB\s-1]\s+1\fR + +.fi +where \fIexpression\fR is an offset off of address register \fBa\fIn\fR and +another register \fIrn\fR which may be any data or address register. The +Offset is restricted to an 8-bit quantity. The \fBw\fR or \fBl\fR indicates +whether the offset value in \fIrn\fR is to be taken as a word (16 bit) value +or as a long (32 bit) value (if omitted it defaults to long). +.PP +As with ordinary displacment addressing, there is a form of indexed addressing +which uses \fBstruct\fR fields +.nf + + \fBa\fIn\fR \fB\s-1[\s+1\fR \fIrn\fR \fB. w \fB\s-1]\s+1\fR \fB.\fR \fIidentifier\fR \*[ \fB.\fR \fIidentifier\fR \*Z + \fBa\fIn\fR \fB\s-1[\s+1\fR \fIrn\fR \fB. l \fB\s-1]\s+1\fR \fB.\fR \fIidentifier\fR \*[ \fB.\fR \fIidentifier\fR \*Z + \fBa\fIn\fR \fB\s-1[\s+1\fR \fIrn\fR \fB\s-1]\s+1\fR \fB.\fR \fIidentifier\fR \*[ \fB.\fR \fIidentifier\fR \*Z + +.fi +.NH 2 +\fRProgram counter displacement mode +.PP +Program counter displacement mode operands take the form +.nf + + \fIexpression\fR \fB\s-1[\s+1\fR \fBpc\fR \fB\s-1]\s+1\fR + +.fi +where \fIexpression\fR is an offset off of the program counter. These +displacement values are limited to 16 bit quantities in the 68000. +.NH 2 +\fRProgram counter indexed mode +.PP +Program counter indexed mode addressing is specified by operands of the form +.nf + + \fIexpression\fR \fB\s-1[\s+1\fR \fBpc\fR \fB,\fR \fIrn\fR \fB. w \s-1]\s+1\fR + \fIexpression\fR \fB\s-1[\s+1\fR \fBpc\fR \fB,\fR \fIrn\fR \fB. l \s-1]\s+1\fR + \fIexpression\fR \fB\s-1[\s+1\fR \fBpc\fR \fB,\fR \fIrn\fR \fB\s-1]\s+1\fR + +.fi +where \fIexpression\fR is an offset off of the program counter and another +register \fIrn\fR which may be any data or address register. The Offset is +restricted to an 8-bit quantity. The \fBw\fR or \fBl\fR indicates whether the +offset value in \fIrn\fR is to be taken as a word (16 bit) value or as a long +(32 bit) value (if omitted it defaults to long). +.NH 2 +\fRControl register mode +.PP +The various control register of the 68000 are sometimes used as operands +.nf + + \fBccr\fR + \fBsr\fR + \fBusp\fR + \fBsfc\fR + \fBdfc\fR + \fBvbr\fR + +.fi +where \fBccr\fR represents the condition code register, \fBsr\fR represents +the status register, \fBusp\fR represents the user stack pointer, \fBsfc\fR +represents the source function code register, \fBdfc\fR represents the +destination function code register, and \fBvbr\fR represents the vector base +register. +.NH 2 +\fRText operands +.PP +For the sake of macros, text strings may also be used as operands +.nf + + \fB"\fIany string you like\fB"\fR + +.fi +The same conventions regarding escaped characters (using ``\fB\\\fR'') that +are followed by \fBC\fR are followed by \fIMacross\fR. These are documented +in \fBAppendix F\fR. Note that on many target machines the codes that these +escape sequences stand for are meaningless. They are provided primarily as a +convenience for writing calls to \fBprintf()\fR. +.NH 1 +The Flow of Control Statements +.PP +\fIMacross\fR provides a number of statements which allow program flow of +control to be specified in a \fBC\fR-like block structured fashion. This +include a conditional execution statement (\fBif\fR) and three conditional +loop statements (\fBwhile\fR, \fBdo-while\fR and \fBdo-until\fR). These +statements assemble into the appropriate conditional branches and jumps to +realize the desired construct. +.NH 2 +If\fR statement +.PP +The \fBif\fR statement has the following form +.nf + +\*[ \fIlabel\fR \*Z \fBif\fR \fB(\fR \fIcondition\fR \fB)\fR \fB{\fR + \*[ \fIstatement\fR \*Z + \fB}\fR \*[ \fBelseif\fR \fB(\fR \fIcondition\fR \fB)\fR \fB{\fR + \*[ \fIstatement\fR \*Z + \fB}\fR \*Z \*[ \fBelse\fR \fB{\fR + \*[ \fIstatement\fR \*Z + \fB}\fR \*] + +.fi +\fIcondition\fR is either the name of one of the target processor's hardware +condition codes such as can be tested for in a conditional branch instruction +(e.g., \fBcarry\fR, \fBoverflow\fR, etc.\*- the complete list is in +\fBAppendix C\fR) or one either of these negated using the ``logical not'' +operator (``\fB!\fR''). The condition is used to determine the appropriate +type of branch instruction to use. For example, +.nf + + \fBif (overflow) {\fR + \fIstatements-1\fR + \fB} elseif (carry) {\fR + \fIstatements-2\fR + \fB} else {\fR + \fIstatements-3\fR + \fB}\fR + +.fi +expands into this (the labels are made up for illustrative purposes only): +.nf + + \fBbvc temp1 + \fIstatements-1 + \fBjmp temp3 +temp1: bcc temp2 + \fIstatements-3 + \fBjmp temp3 +temp2: \fIstatements-3 +\fBtemp3: \fIwhatever follows\fR + +.fi +The keyword \fBelseif\fR may be used as shown, or specified as two separate +keywords, \fBelse if\fR, depending on the programmer's whim. +.NH 2 +While\fR statement +.PP +The \fBwhile\fR statement has the following form +.nf + +\*[ \fIlabel\fR \*Z \fBwhile\fR \fB(\fR \fIcondition\fR \fB)\fR \fB{\fR + \*[ \fIstatement\fR \*Z + \fB}\fR + +.fi +\fIcondition\fR is as described above for the \fBif\fR statement. An example +of the \fBwhile\fR statement would be +.nf + + \fBwhile (!carry) {\fR + \fIstatements\fR + \fB}\fR + +.fi +which would turn into +.nf + +\fBtemp2: bcs temp1 + \fIstatements + \fBjmp temp2 +temp1: \fIwhatever follows\fR + +.fi +.NH 2 +Do-while\fR statement +.PP +The \fBdo-while\fR statement is similar to the \fBwhile\fR statement except +that the condition is tested at the bottom of the loop. It has the form +.nf + +\*[ \fIlabel\fR \*Z \fBdo\fR \fB{\fR + \*[ \fIstatement\fR \*Z + \fB}\fR \fBwhile\fR \fB(\fR \fIcondition\fR \fB)\fR + +.fi +For example +.nf + + \fBdo {\fR + \fIstatements\fR + \fB} while (equal)\fR + +.fi +which is equivalent to +.nf + +\fBtemp: \fIstatements + \fBbeq temp\fR + +.fi +.NH 2 +Do-until\fR statement +.PP +The \fBdo-until\fR statement is the same as the \fBdo-while\fR statement +except that the sense of the condition is negated. It has the form +.nf + +\*[ \fIlabel\fR \*Z \fBdo\fR \fB{\fR + \*[ \fIstatement\fR \*Z + \fB}\fR \fBuntil\fR \fB(\fR \fIcondition\fR \fB)\fR + +.fi +For example +.nf + + \fBdo {\fR + \fIstatements\fR + \fB} until (equal)\fR + +.fi +which is equivalent to +.nf + +\fBtemp: \fIstatements + \fBbne temp\fR + +.fi +.NH 1 +The Data Statements +.PP +The data statements allow the allocation of memory space and the storage of +constant data. These statements are like the ones found in most assemblers. +There are several different forms, each for a different type of data. +.NH 2 +Block\fR statement +.PP +The \fBblock\fR statement allocates blocks of memory without initializing the +bytes to any particular value (actually, the loader will in all likelihood +initialize these to 0, but it is probably not really wise to rely on this). +It has the form +.nf + +\*[ \fIlabel\fR \*Z \fBblock\fR \fIexpression\fR \*[ \fB,\fR \fIexpression\fR \*Z + +.fi +The \fIexpression\fRs are the sizes of the blocks to reserve, expressed in +bytes. +.NH 2 +Align\fR statement +.PP +The \fBalign\fR statement aligns the current location counter to an integer +multiple of some value (e.g., to align with a word boundary). It has the form +.nf + +\*[ \fIlabel\fR \*Z \fBalign\fR \fIexpression\fR + +.fi +The \fIexpression\fR is the multiple to which the current location counter is +to be aligned. For example, +.nf + + \fBalign 2\fR + +.fi +would align the current location to a word boundary, while +.nf + + \fBalign 0x100\fR + +.fi +would align to a page boundary. +.NH 2 +Constrain\fR statement +.PP +The \fBconstrain\fR statement provides a means of constraining a portion of +code or data to be located within a region of memory bounded by addresses of +integer multiples of some value (e.g., within a page). Its form is +.nf + + \fBconstrain\fR \fB(\fR \fIboundary\fR \fB)\fR \fB{\fR + \*[ \fIstatement\fR \*Z + \fB}\fR + +.fi +\fIBoundary\fR may be any expression which evaluates to a number. The +\fIstatement\fRs are assembled normally. If assembling in absolute mode, an +error message is issued if the current location counter crosses an integer +multiple of \fIboundary\fR. If assembling in relocatable mode, information +about the constraint will be output in the object file and the contents of the +constrained block will be relocated as needed to satisfy the constraint (note +that this means that it is unsafe to assume that the things in the assembly +source immediately before the \fBconstrain\fR statement, the contents of the +constrain block itself, and the things in the assembly source immediately +after the \fBconstrain\fR statement will be located in contiguous locations in +the eventual target machine address space). For example, +.nf + + \fBconstrain (0x100) {\fR + \fIstatements\fR + \fB}\fR + +.fi +constrains the given statements to all fit within a page. +.NH 2 +Word\fR statement +.PP +The \fBword\fR statement allocates words, i.e., two byte chunks, of memory. +It takes the form +.nf + +\*[ \fIlabel\fR \*Z \fBword\fR \fIexpression\fR \*[ \fB,\fR \fIexpression\fR \*Z + +.fi +The \fIexpression\fRs must evaluate to quantities that can be contained in 16 +bits, of course. For example, +.nf + + \fBword 0x1234, foobar\fR + +.fi +would allocate two words, the first of which would be initialized to the +hexadecimal value 0x1234 and the second to whatever the value of \fBfoobar\fR +is. +.NH 2 +Dbyte\fR statement +.PP +The \fBdbyte\fR statement is just like the \fBword\fR statement, except that +the word is byte-swapped in memory. Its form is +.nf + +\*[ \fIlabel\fR \*Z \fBdbyte\fR \fIexpression\fR \*[ \fB,\fR \fIexpression\fR \*Z +.fi +.NH 2 +Long\fR statement +.PP +The \fBlong\fR statement allocates longwords, i.e., four byte chunks, of +memory. It takes the form +.nf + +\*[ \fIlabel\fR \*Z \fBlong\fR \fIexpression\fR \*[ \fB,\fR \fIexpression\fR \*Z + +.fi +The \fIexpression\fRs must evaluate to quantities that can be contained in 32 +bits, of course. For example, +.nf + + \fBword 0x12345678, foobar\fR + +.fi +would allocate two longwords, the first of which would be initialized to the +hexadecimal value 0x12345678 and the second to whatever the value of +\fBfoobar\fR is. +.NH 2 +Byte\fR statement +.PP +The \fBbyte\fR statement is similar to the \fBword\fR and \fBdbyte\fR +statements, except that it allocates single byte chunks. Its form is +.nf + +\*[ \fIlabel\fR \*Z \fBbyte\fR \fIexpression\fR \*[ \fB,\fR \fIexpression\fR \*Z + +.fi +An \fIexpression\fR, in this case, is either an ordinary expression (see +\fBExpressions\fR, below) which must evaluate to an 8-bit quantity, indicating +the value for a single byte to be reserved, or a string (see above, under the +discussion of text operands), indicating that the characters in the string +should be placed in memory at the current location. +.NH 2 +String\fR statement +.PP +The \fBstring\fR statement is much like the \fBbyte\fR statement, except that +the values indicated are followed in memory by a zero byte. This enables the +convenient declaration and allocation of NULL terminated character strings. +This feature is of little use in the 68000 version of \fIMacross\fR but is +provided for compatability with future versions targeted at more sophisticated +processors. The form of the \fBstring\fR statement is +.nf + +\*[ \fIlabel\fR \*Z \fBstring\fR \fIexpression\fR \*[ \fB,\fR \fIexpression\fR \*Z +.fi +.NH 2 +Struct\fR statement +.PP +The \fBstruct\fR statement enables the declaration and allocation of +record-oriented data structures. There are two forms of the \fBstruct\fR +statement, the first of which declares a \fBstruct\fR record type, and the +second of which causes space to be set aside in memory for a \fBstruct\fR that +has already been declared. The form of the first type of \fBstruct\fR +statement is +.nf + +\*[ \fIlabel\fR \*Z \fBstruct\fR \fB{\fR + \*[ \fIdataStatement\fR \*Z + \fB}\fR \fIname\fR + +.fi +\fIdataStatement\fRs are any of the data statements described in this section +(section 3). \fIName\fR becomes the name of the \fBstruct\fR. Any labels +inside the \fBstruct\fR become \fIfields\fR of the data structure which may be +referred to later in expressions using the ``\fB.\fR'' operator, as in +\fBC\fR. A more complete description of the semantics of \fBstruct\fRs is +given in the section below on expressions. +.PP +The first form of the \fBstruct\fR statement, called a ``\fBstruct\fR +definition'', lays out the constituent parts of a data structure and gives +those names to those parts. The second form of the \fBstruct\fR statement, +called a ``\fBstruct\fR instantiation'', +.nf + +\*[ \fIlabel\fR \*Z \fBstruct\fR \fIname\fR + +.fi +causes storage for the \fBstruct\fR named by \fIname\fR to be allocated. A +\fBstruct\fR definition \fImay not\fR contain another \fBstruct\fR definition, +but it \fImay\fR contain a \fBstruct\fR instantiation. For example, +.nf + + \fBstruct { + pointer: block 2 + class: block 1 + } fooThing\fR + +.fi +would create a \fBstruct\fR called \fBfooThing\fR. Then, +.nf + +\fBfooLabel: struct fooThing\fR + +.fi +would allocate one at the current location at the address labeled +\fBfooLabel\fR. This could then be used as follows: +.nf + + \fBandb fooLabel.class, d0 + jmp fooLabel.pointer\fR + +.fi +which would AND \fBd0\fR with the \fBclass\fR field of the \fBstruct\fR and +then jump to wherever the \fBpointer\fR field pointed to. If the \fBx\fR +address register \fBa4\fR already contained the address of this \fBstruct\fR, +then one could say +.nf + + \fBandb a4.class, d0\fR + +.fi +.NH 1 +The Symbol Definition Statements +.PP +The various symbol definition statements allow the declaration of symbolic +variables and values and the definition of macros and functions. +.NH 2 +Define\fR statement +.PP +The \fBdefine\fR statement enables the programmer to create symbolic names for +values. It has two forms. The first +.nf + + \fBdefine\fR \fIsymbolname\fR + +.fi +creates a new symbol, \fIsymbolname\fR (an identifier), and gives it the +special value \fBunassigned\fR. Any attempt to take the value of an +unassigned symbol will cause an error message from the assembler. The symbol +will, however, cause the \fBisDefined()\fR built-in function (see +\fBExpressions\fR, below) to return \fBTRUE\fR if passed as an argument. It +is also an error to \fBdefine\fR a symbol that has already been \fBdefine\fRd. +.PP +The second form of the \fBdefine\fR statement +.nf + + \fBdefine\fR \fIsymbolname\fR \fB=\fR \fIexpression\fR + +.fi +creates the symbol and gives it the value obtained by evaluating +\fIexpression\fR (see \fBExpressions\fR, below). Actually, what \fBdefine\fR +does is create a symbolic name for \fIexpression\fR and the save this +expression away in a secret place. This means that symbols in +\fIexpression\fR may be forward references, e.g., labels that haven't been +encountered yet. It is also possible to forward reference to symbols that are +defined by future \fBdefine\fR statements, for example: +.nf + + \fBdefine foo = bar + 2 + define bar = 47\fR + +.fi +effectively defines \fBfoo\fR to be \fB49\fR. Beware, however, as there is no +way for the assembler to detect mutually recursive references of this sort, so +that +.nf + + \fBdefine foo = bar + 2 + define bar = foo + 2\fR + +.fi +will be happily swallowed without complaint, until you actually try to use +\fBfoo\fR or \fBbar\fR in an instruction, whereupon \fIMacross\fR's expression +evaluator will go into infinite recursion until it runs out of stack space and +crashes the assembler (it looks to see what \fBfoo\fR is and sees that it's +\fBbar + 2\fR, so it looks to see what \fBbar\fR and see that it's \fBfoo + +2\fR, so it looks to see what \fBfoo\fR is... To have the assembler detect +and signal this error would, in the general case, add much complication and +inefficiency (read: make your programs assemble a lot more slowly) for little +return). +.PP +The scope of symbols defined in either of these two ways extends in time from +the definition itself to the end of the assembly. +.NH 2 +Variable\fR statement +.PP +The \fBvariable\fR statement enables the programmer to declare symbolic +variables for future use. Similar to the \fBdefine\fR statement, it has two +forms. The first +.nf + + \fBvariable\fR \fIsymbolname\fR + +.fi +creates a variable named \fIsymbolname\fR and gives it the special value +\fBunassigned\fR, just like the analogous \fBdefine\fR statement. +.PP +The second form of the \fBvariable\fR statement +.nf + + \fBvariable\fR \fIsymbolname\fR \fB=\fR \fIexpression\fR + +.fi +creates the variable and gives it the value obtained by evaluating +\fIexpression\fR. The scope of variables defined in either of these two ways +extends from the \fBvariable\fR statement itself to the end of the assembly +(i.e., the variable is global). +.PP +The difference between the \fBdefine\fR statement and the \fBvariable\fR +statement is that the \fBdefine\fR statement creates what is in essence a +constant whereas the \fBvariable\fR statement creates a true variable. The +value of a variable may change (e.g., it may be assigned to) during the course +of assembly. In addition, the expression which establishes a symbol's value +in a \fBdefine\fR statement may contain forward references (i.e., labels whose +values are unknown because they haven't been encountered yet) whereas the +expression assigning an initial value to a variable must be made up of terms +all of whose values are known at the time the \fBvariable\fR statement is +encountered in the assembly. +.NH 2 +Macro\fR statement +.PP +The \fBmacro\fR statement is used to define macros (surprise!). Its syntax is +.nf + + \fBmacro\fR \fImacroname\fR \*[ \fIargumentname\fR \*[ \fB,\fR \fIargumentname\fR \*Z \*] \fB{\fR + \*[ \fIstatement\fR \*Z + \fB}\fR + +.fi +where \fImacroname\fR is just that and the \fIargumentname\fRs are identifiers +corresponding to the formal parameters of the macro (in the classical +fashion). When the macro is called, the call arguments are bound to these +symbols and then \fIMacross\fR assembles the \fIstatement\fRs which form the +macro body. The scope of these symbols is limited to the inside of the macro +body and their values go away when the macro expansion is completed. The +\fIstatement\fRs may be any valid \fIMacross\fR statements except for +\fBmacro\fR statements and \fBfunction\fR statements (i.e., macro and function +definitions may not be nested). +.PP +Statement labels used inside macros can be made local to the macro by +preceding the label identifier with a dollar sign (``\fB$\fR''). For +example, +.nf + + \fBmacro fooMac arg { + jmp $foo + word arg + $foo: nop + }\fR + +.fi +defines a macro named \fBfooMac\fR that emits a word of data that gets jumped +over. The label \fB$foo\fR is local to the macro: both the reference to it +in the first line of the macro and its definition on the third will only be +seen inside the macro. Each time the macro is called, the \fBjmp\fR will +refer to the location two instructions ahead, and any other macros that might +contain \fB$foo\fR will not affect this nor will they be affected by this. +.NH 2 +Function\fR statement +.PP +The \fBfunction\fR statement is used to define functions. Its syntax is +.nf + + \fBfunction\fR \fIfuncname\fR \fB(\fR \*[ \fIargumentname\fR \*[ \fB,\fR \fIargumentname\fR \*Z \*] \fB)\fR \fB{\fR + \*[ \fIstatement\fR \*Z + \fB}\fR + +.fi +where \fIfuncname\fR is the name of the function and the \fIargumentname\fRs +are identifiers corresponding to the formal parameters of the function. When +the function is called, the call arguments are evaluated and then bound to +these symbols and then \fIMacross\fR assembles the \fIstatement\fRs which form +the function body. The scope of these symbols is limited to the inside of the +function body and their values go away when the function evaluation is +completed. As with macro definitions, the \fIstatement\fRs may be any valid +\fIMacross\fR statements except for the \fBmacro\fR and \fBfunction\fR +statements. A function may return a value using the \fBfreturn\fR statement, +which is described below. +.NH 2 +Undefine\fR statement +.PP +The \fBundefine\fR statement allows symbol and macro definitions to be removed +from \fIMacross\fR' symbol table. It takes the form +.nf + + \fBundefine\fR \fIsymbolname\fR \*[ \fB,\fR \fIsymbolname\fR \*Z + +.fi +The named symbols go away as if they never were \*- they are free to be +defined again and the \fBisDefined()\fR built-in function will return +\fBFALSE\fR if passed one of them as an argument. +.NH 1 +Macro Body Statements +.PP +\fIMacross\fR provides several statements which are primarily intended to +manage the flow of control (or, rather, the ``flow of assembly'') within a +macro or function definition. Some of these statements are analogs to the +flow of control statements described above in section 2. However, one should +keep in mind that these statements are executed interpretively at assembly +time, whereas the previously described statements result in machine code in +the target-processor-executable output of the assembly process. +.PP +Although these statements are intended primarily for use within macros and +functions, their use is not restricted and they may be used at any point in a +program. In particular, the \fBmif\fR statement (to be described shortly) is +the means by which conditional assembly may be realized. +.NH 2 +\fRBlocks +.PP +The construct +.nf + + \fB{\fR + \*[ \fIstatement\fR \*Z + \fB}\fR + +.fi +is called a \fIblock\fR and is in fact a valid \fIMacross\fR statement type in +its own right. Blocks are used extensively in \fIMacross\fR to form the +bodies of flow-of-control statements, flow-of-assembly statements and macros. +.NH 2 +Mdefine\fR statement +.PP +The \fBmdefine\fR statement +.nf + + \fBmdefine\fR \fIsymbolname\fR +or + \fBmdefine\fR \fIsymbolname\fR \fB=\fR \fIexpression\fR + +.fi +operates like (and is syntactically congruent with) the \fBdefine\fR +statement, except that the scope of the symbol definition is restricted to the +body block of the macro or function in which the \fBmdefine\fR appears. The +symbol definition is invisible outside that block, though it \fIis\fR visible +inside any blocks that may themselves be contained within the macro or +function. +.NH 2 +Mvariable\fR statement +.PP +The \fBmvariable\fR statement +.nf + + \fBmvariable\fR \fIsymbolname\fR +or + \fBmvariable\fR \fIsymbolname\fR \fB=\fR \fIexpression\fR + +.fi +bears exactly the same relationship to the \fBvariable\fR statement that the +\fBmdefine\fR statement does to the \fBdefine\fR statement. It declares a +variable whose scope is limited to the function or macro in whose definition +it appears. +.NH 2 +Mif\fR statement +.PP +The \fBmif\fR statement conditionally assembles the statements contained in +the block following it: +.nf + + \fBmif\fR \fB(\fR \fIcondition\fR \fB)\fR \fB{\fR + \*[ \fIstatement\fR \*Z + \fB}\fR \*[ \fBmelseif\fR \fB(\fR \fIcondition\fR \fB)\fR \fB{\fR + \*[ \fIstatement\fR \*Z + \fB}\fR \*Z \*[ \fBmelse\fR \fB{\fR + \*[ \fIstatement\fR \*Z + \fB}\fR \*] + +.fi +unlike the \fBif\fR statement, the \fIcondition\fR may be any expression +whatsoever. \fIMacross\fR follows the \fBC\fR convention that the value 0 +represents \fBFALSE\fR and any other value represents \fBTRUE\fR (in fact, the +symbols \fBTRUE\fR and \fBFALSE\fR are ``predefined'' by the assembler to +have the values 1 and 0 respectively). The meaning of the \fBmif\fR construct +is the obvious one, but keep in mind that it is interpreted at assembly time +and has no direct bearing on the execution of the resulting assembled program. +.NH 2 +Mwhile\fR statement +.PP +The \fBmwhile\fR statement repetitively assembles a block of statements so +long as a given condition remains true. Its form is +.nf + + \fBmwhile\fR \fB(\fR \fIcondition\fR \fB)\fR \fB{\fR + \*[ \fIstatement\fR \*Z + \fB}\fR + +.fi +As with \fBmif\fR, the \fIcondition\fR may be any valid \fIMacross\fR +expression and the interpretation is what it seems. +.NH 2 +Mdo-while\fR statement +.PP +The \fBmdo-while\fR statement provides an alternative to the \fBmwhile\fR +statement by testing at the bottom of the loop instead of at the top. Its +form is +.nf + + \fBmdo\fR \fB{\fR + \*[ \fIstatement\fR \*Z + \fB}\fR \fBwhile\fR \fB(\fR \fIcondition\fR \fB)\fR +.fi +.NH 2 +Mdo-until\fR statement +.PP +The \fBmdo-until\fR statement is the same as the \fBmdo-while\fR statement +except that the sense of the condition is negated. It has the form +.nf + + \fBmdo\fR \fB{\fR + \*[ \fIstatement\fR \*Z + \fB}\fR \fBuntil\fR \fB(\fR \fIcondition\fR \fB)\fR +.fi +.NH 2 +Mfor\fR statement +.PP +The \fBmfor\fR statement provides a more general looping construct analogous +to the \fBC\fR \fBfor\fR loop. Its form is +.nf + + \fBmfor\fR \fB(\fR \fIexpression-1\fR \fB,\fR \fIexpression-2\fR \fB,\fR \fIexpression-3\fR \fB)\fR \fB{\fR + \*[ \fIstatement\fR \*Z + \fB}\fR + +.fi +where \fIexpression-1\fR is an initialization expression, \fIexpression-2\fR +is a test to see if looping should continue, and \fIexpression-3\fR is +executed at the bottom of the loop to set up for the next time around, just as +in \fBC\fR. Note that, unlike \fBC\fR, the \fIexpression\fRs are separated by +commas, not semicolons. This is because semicolons are used to delimit line +comments. +.PP +The \fBmfor\fR statement is equivalent to +.nf + + \fIexpression-1\fR + \fBmwhile (\fIexpression-2\fB ) {\fR + \fIstatements\fR + \fIexpression-3\fR + \fB}\fR +.fi +.NH 2 +Mswitch\fR statement +.PP +The \fBmswitch\fR statement provides a means of selecting one of a number of +blocks of code for assembly depending upon the value of some expression. Its +form is: +.nf + + \fBmswitch ( \fIselectionExpression \fB) {\fR + \*[ \fBmcase ( \fIexpression\fR \*[ \fB,\fI expression\fR \*Z \fB) {\fR + \*[ \fIstatement\fR \*Z + \fB}\fR \*Z + \*[ \fBmdefault {\fR + \*[ \fIstatement\fR \*Z + \fB}\fR \*] + \fB}\fR + +.fi +The way this works is as follows (it's actually easier to use than to +explain): \fIselectionExpression\fR is evaluated. Each of the +\fIexpression\fRs associated with the various \fBmcase\fR clauses (if any) is +then evaluated in turn and the resulting value compared to that of +\fIselectionExpression\fR. When and if one of these values ``matches'' the +value of \fIselectionExpression\fR the block of \fIstatement\fRs associated +with the corresponding \fBmcase\fR clause is immediately assembled and +execution of the \fBmswitch\fR statement is complete. If no such value +matches and there is an \fBmdefault\fR clause, the block of \fIstatement\fRs +associated with the \fBmdefault\fR clause is assembled. If no value matches +and there is no \fBmdefault\fR clause then nothing is assembled as a result of +the \fBmswitch\fR. When we say the values ``match'', we mean that either +the expressions evaluate to the same number or to strings which are identical +except for the case of alphabetic characters. For example: +.nf + + \fBmswitch (foo) { + mcase ("hello", "fnord") { + \fIstatements-1\fB + } + mcase ("ZAP!") { + \fIstatements-2\fB + } + mdefault { + \fIstatements-3\fR + } + }\fR + +.fi +would switch on the value of the symbol \fBfoo\fR. If the value of \fBfoo\fR +was \fB"hello"\fR, \fIstatements-1\fR would be assembled. If the value of +\fBfoo\fR was \fB"zap!"\fR, \fIstatements-2\fR would be assembled (since the +string comparison is done independent of case). If the value of \fBfoo\fR was +\fB"cromfelter"\fR or \fB47\fR, then \fIstatements-3\fR would be assembled by +default. +.NH 2 +Freturn\fR statement +.PP +A \fIMacross\fR function may (and probably will) be called from an expression +in the traditional manner of functions throughout the annals of computer +science. In such a situation, the programmer may wish to have a function +return a value. The \fBfreturn\fR statement enables this. Its form is +.nf + + \fBfreturn\fR \*[ \fIexpression\fR \*] + +.fi +where \fIexpression\fR is any permissible \fIMacross\fR expression as +described below under \fBExpressions\fR. If no \fIexpression\fR is given, the +macro simply returns without having a value as its result. Any attempt to use +the (non-existent) value returned by a call to function which doesn't return a +value will result in an error message from the assembler. Function calls will +automatically return without a value upon reaching the end of the block that +forms the body of the function. +.NH 1 +Miscellaneous Statements +.PP +Various useful statements don't fall into any of the above categories. +.NH 2 +Include\fR statement +.PP +The \fBinclude\fR statement allows the text in other files to be included in +the source program being assembled, in the time-honored fashion. Its form is +.nf + + \fBinclude\fR \fIfilename\fR + +.fi +where \fIfilename\fR is a string value giving the name of the file to be +included. \fBInclude\fRd files may themselves contain \fBinclude\fR +statements to any number of levels of recursion (within reason). +.NH 2 +Extern\fR statement +.PP +The \fBextern\fR statement allows you to declare symbols to be visible to the +linker outside of the file in which they are found. Its use: +.nf + + \fBextern\fR \fIsymbol\fR \*[ \fB,\fR \fIsymbol\fR \*Z +.fi +.NH 2 +Start\fR statement +.PP +The \fBstart\fR statement declares the starting address of a program. +.nf + + \fBstart\fR \fIexpression\fR + +.fi +where the \fIexpression\fR indicates the start address. There should be no +more than one \fBstart\fR statement in a program. If no start address is +specified, the object file will be produced without a start address entry. +.NH 2 +Assert\fR statement +.PP +The \fBassert\fR statement provides a means of testing assembly time +conditions and generating programmer specified error messages if those +conditions are not satisfied. Its syntax is: +.nf + + \fBassert (\fIcondition\fB)\fR \*[ \fItextString\fR \*] + +.fi +where \fIcondition\fR is an expression such as those used in the \fBmif\fR +statement. This condition is evaluated and if \fBFALSE\fR then the message +\fItextString\fR, if given, is written to the standard output. The message is +written in the form of a conventional \fIMacross\fR error message, giving the +file and line number on which the failed assertion occured. If +\fItextString\fR is omitted then a simple error message to the effect that the +assert failed will be output. For example, +.nf + + \fBassert (foo == 1) "Hey! You blew it."\fR + +.fi +would check to see that the value of the symbol \fBfoo\fR is \fB1\fR, and if +it isn't would issue an error message containing the string \fB"Hey! You blew +it."\fR. +.NH 2 +Org\fR statement +.PP +The \fBorg\fR statement adjusts the current location counter and tells the +assembler to start locating instructions and data in absolute memory +locations. +.nf + + \fBorg\fR \fIexpression\fR + +.fi +The \fIexpression\fR indicates the new current location. If this is an +absolute address, \fIMacross\fR starts assembling at the specified +absolute memory location. If, on the other hand, it is relative to a +relocatable address or to the current location counter, the current location +counter is simply adjusting accordingly. +.NH 2 +Rel\fR statement +.PP +The \fBrel\fR statement restores \fIMacross\fR to assembling code in a +relocatable fashion, if it was not already doing so. The relocatable location +resumes from wherever it was left the last time an absolute \fBorg\fR stopped +relocatable code assembly. \fI((explain this better))\fR +.NH 2 +Target\fR statement +.PP +The \fBtarget\fR statement +.nf + + \fBtarget\fR \fIexpression\fR + +.fi +tells the assembler to assemble as if it had been \fBorg\fRed to a particular +address without actually performing the \fBorg\fR. The \fIexpression\fR +indicates the location to start assembling from. This must be an absolute +address (and the \fBtarget\fR statement may only be used when assembling in +absolute mode). +.PP +The result of the \fBtarget\fR statement is that assembly proceeds from the +current location but labels will be defined as if it was proceeding from the +location specified by \fIexpression\fR and references to the current location +counter will be offset by the difference between the actual current location +counter value and the value of \fIexpression\fR. This effect will persist until the next \fBorg\fR or \fBtarget\fR statement. For example +.nf + + \fBorg 0x1000 + target 0x0800 +foo: rts +bar: word 0x1234 + word here + org someplaceElse\fR + +.fi +would first set the current location counter to \fB0x1000\fR. At location +\fB0x1000\fR it would assemble an \fBrts\fR instruction while giving the label +\fBfoo\fR the value \fB0x800\fR. Then, at location \fB0x1002\fR it would +deposit the word value \fB0x1234\fR while giving the label \fBbar\fR the +value \fB0x802\fR. At location \fB0x1004\fR it would deposit the word value +\fB0x804\fR. Finally, the second \fBorg\fR would set the current location +counter to \fBsomeplaceElse\fR and the effects of the \fBtarget\fR statement +would cease. +.SH +\s+3Expressions\s-3 +.PP +The expression syntax of \fIMacross\fR was chosen to be as close to that of +\fBC\fR as possible. \fIMacross\fR recognizes the same set of operators as +\fBC\fR with few exceptions, and the operators have the same precedence with +respect to each other that everyone is used to. +.PP +Another important feature of expressions in \fIMacross\fR is that expressions +by themselves on a line are valid statements. Assignment expressions, uses of +the post- and pre-increment and decrement operators (``\fB++\fR'' and +``\fB--\fR''), and calls to functions used like procedures are the most +useful applications of this. For example +.nf + + \fBfoo = 5\fR + \fBbar++\fR + \fBprintf("Hello world\\n")\fR + +.fi +are all valid statements. +.NH 0 +\fRPrimitive expressions +.PP +The most primitive expressions are identifiers, numbers, characters, character +strings, and function calls. +.PP +Identifiers have already been described, in the section \fBGeneral Form of +\fIMacross\fB Statements\fR above. The only thing to add here is that the +special identifier \fBhere\fR denotes the value of the current location +counter. +.PP +Numbers may be decimal, octal, hexadecimal, binary or quarters. The form of +the first three of these is as in \fBC\fR: decimal numbers are denoted by a +sequence of decimal digits that does not begin with a ``\fB0\fR''; octal +numbers by a sequence of octal digits that \fIdoes\fR begin with a +``\fB0\fR''; and hexadecimal numbers by a sequence of hexadecimal digits +(the decimal digits plus the letters ``\fBa\fR'' through ``\fBf\fR'', in +either upper or lower case), preceded by ``\fB0x\fR'' or ``\fB0X\fR''. +Binary numbers and quarters are represented analogously. Binary numbers are +represented by a sequence of ``\fB0\fR''s and ``\fB1\fR''s preceded by +``\fB0b\fR'' or ``\fB0B\fR''. Quarters are base-four numbers (for two-bit +entities like Atari pixels) and are represented by the sequences of the digits +\fB0\fR through \fB3\fR preceded by ``\fB0q\fR'' or ``\fB0Q\fR'' (the +credit for this idea goes to Charlie Kellner). +.PP +Character constants are denoted the same as in \fBC\fR: by a single character +enclosed in apostrophes (``\fB'\fR''). The same conventions about +characters escaped with a backslash (``\fB\\\fR'') also apply. Strings may +be of varying lengths and are enclosed in quotation marks (``\fB"\fR''), +as discussed above in the explanation of instruction operands. +.PP +A function call, in \fIMacross\fR, is syntactically the same as in \fBC\fR: +the name of the function being called followed by a comma-separated argument +list in parenthesis. The argument list, as in \fBC\fR, may be empty. The +arguments themselves may be arbitrary instruction operands (described above in +section 1). A number of built-in functions are provided by \fIMacross\fR to +perform a variety of useful operations. These are discussed in \fBAppendix +D\fR. +.NH 1 +\fROperators +.PP +Expressions may be constructed from the primitive elements described above and +from other expressions using a variety of unary and binary operators. The +operator set is patterned after \fBC\fR's. The only \fBC\fR operators not +supported are: +.IP +[1] ``\fB?:\fR'' (arithmetic if) \*- not supported for reasons of syntactic +confusion on both the part of the parser attempting to parse it and the +programmer attempting to use it. +.IP +[2] ``\fB,\fR'' (comma) \*- used in \fIMacross\fR as an important separator +and thus not available. +.IP +[3] unary ``\fB*\fR'' and ``\fB&\fR'', \fBsizeof\fR, casts and +``\fB->\fR'' \*- not relevant here. +.LP +All of the assignment operators (``\fB+=\fR'', ``\fB-=\fR'', etc.) +\fIare\fR supported by \fIMacross\fR. +.LP +\fIMacross\fR reinterprets the \fB.\fR operator in that ``\fIexpression\fB . +\fIstructfieldname\fR'' is interpreted as adding the offset value implied by +\fIstructfieldname\fR (i.e., the distance in bytes into a \fBstruct\fR to +reach the named field) to the address that is the value of \fIexpression\fR. +.LP +\fIMacross\fR adds to the operator set the following: +.IP +[1] ``\fB?\fR'' \*- as a unary operator, takes the high order byte of the +word value that is its argument. +.IP +[2] ``\fB/\fR'' \*- as a unary operator, takes the low order byte of the +word value that is its argument. +.IP +[3] ``\fB^^\fR'' \*- a binary operator, denotes logical exclusive-OR. This +is simply an orthogonal extension for the sake of completeness. +.LP +Of course, parenthesis can be used at any point to override the normal +precedence of the various operators. A full list of all the operators that +\fIMacross\fR understands is given in \fBAppendix E\fR. +.NH 1 +\fRExpression evaluation +.PP +In order to make the most effective use of expressions in the \fIMacross\fR +environment, it is helpful (and at times necessary) to understand how and when +\fIMacross\fR evaluates them. +.PP +When \fIMacross\fR evaluates an expression, it may have one of three sorts of +results. These are \fIsuccess\fR, \fIundefined\fR, and \fIfailure\fR. A +\fIsuccess\fR result means that \fIMacross\fR encountered no problems +evaluating the expression, and whatever value it evaluated to is just used as +needed. A \fIfailure\fR result indicates that there was a problem of some +sort. Usually this is a result of some user error. In any case, an +appropriate diagnostic message will be issued by the assembler and the +statement in which the expression was found will not be assembled. +.PP +An \fIundefined\fR result is where the complications, if any, arise. An +expression will evaluate to an \fIundefined\fR result if one or more of the +terms of the expression are undefined symbols. Usually these are labels which +simply haven't been encountered yet (i.e., they are forward references). In +certain contexts, such as the operand of a machine instruction, this is a +legitimate thing to do, and in certain others, such as the condition of a +\fBmif\fR statement, this is not allowed at all. In the latter case, an +\fIundefined\fR result is just like a \fIfailure\fR result. In the former +case, the assembler is forced to get fancy in order to make it all work right. +.PP +What \fIMacross\fR does is squirrel away a copy of the expression along with a +pointer as to where in the object code the value of the expression is supposed +to go. At the end of assembly, the undefined label will presumably now be +defined, and \fIMacross\fR evaluates the saved expression and pokes the result +into the appropriate location. (If, at this point, the undefined label is +still undefined, an error message to that effect is issued). Clearly, if an +expression has side effects (such as changing the value of some global +variable), this can result in some confusing behavior. The \fIMacross\fR +assembler is smart enough to not let you do anything that has overt side +effects in an expression that is being saved away for future evaluation. The +things which are disallowed in such a case are assignments and uses of the +post- and pre-increment and decrement operators (``\fB++\fR'' and +``\fB--\fR''). Functions, however, may have side effects and \fIMacross\fR +does not try to prevent you from using function calls in expressions that get +saved for later evaluation. It can, and will, detect some, but not all, side +effects during the later evaluation and give a suitable error message. This +is because it is perfectly legitimate to use a function call to a function +that doesn't have side effects in an expression containing forward references. +.PP +If you are now totally confused, the only thing you need remember is: \fBDon't +ever use a call to a function that has side effects in an expression +containing a forward reference.\fR +.bp +.CD + \s+5\fBAppendix A \*- Macross 68000 Grammar\fR\s-5 +\"\s+4\fBAppendix A \*- Macross 68000 Grammar\fR\s-4 +.DE +.LP +.nf +\fR\fIprogram\fR: + \*[ \fIstatement\fR Newline \*Z Endfile + +\fIstatement\fR: +\*[ \fIlabel\fR \*Z \fIopcode\fR \*[ \fIoperand\fR \*[ \fB,\fR \fIoperand\fR \*Z \*] +\*[ \fIlabel\fR \*Z \fBif\fR \fB(\fR \fIcondition\fR \fB)\fR \fIblock\fR + \*[ \fBelseif\fR \fB(\fR \fIcondition\fR \fB)\fR \fIblock\fR \*Z + \*[ \fBelse\fR \fIblock\fR \*] +\*[ \fIlabel\fR \*Z \fBwhile\fR \fB(\fR \fIcondition\fR \fB)\fR \fIblock\fR +\*[ \fIlabel\fR \*Z \fBdo\fR \fIblock\fR \fBwhile\fR \fB(\fR \fIcondition\fR \fB)\fR +\*[ \fIlabel\fR \*Z \fBdo\fR \fIblock\fR \fBuntil\fR \fB(\fR \fIcondition\fR \fB)\fR + \fIdataStatement\fR + \fBdefine\fR \fIidentifier\fR \*[ \fB=\fR \fIexpression\fR \*] + \fBvariable\fR \fIidentifier\fR \*[ \fB=\fR \fIexpression\fR \*] + \fBmacro\fR \fIidentifier\fR \*[ \fIidentifier\fR \*[ \fB,\fR \fIidentifier\fR \*Z \*] \fIblock\fR + \fBfunction\fR \fIidentifier\fR \fB(\fR \*[ \fIidentifier\fR \*[ \fB,\fR \fIidentifier\fR \*Z \*] \fB)\fR \fIblock\fR + \fBundefine\fR \fIidentifier\fR \*[ \fB,\fR \fIidentifier\fR \*Z +\*[ \fIlabel\fR \*Z \fIblock\fR + \fBmdefine\fR \fIidentifier\fR \*[ \fB=\fR \fIexpression\fR \*] + \fBmif\fR \fB(\fR \fIexpression\fR \fB)\fR \fIblock\fR + \*[ \fBmelseif\fR \fB(\fR \fIexpression\fR \fB)\fR \fIblock\fR \*Z + \*[ \fBmelse\fR \fIblock\fR \*] + \fBmwhile\fR \fB(\fR \fIexpression\fR \fB)\fR \fIblock\fR + \fBmdo\fR \fIblock\fR \fBwhile\fR \fB(\fR \fIexpression\fR \fB)\fR + \fBmdo\fR \fIblock\fR \fBuntil\fR \fB(\fR \fIexpression\fR \fB)\fR + \fBfreturn\fR \*[ \fIexpression\fR \*] + \fBmfor\fR \fB(\fR \fIexpression\fR \fB,\fR \fIexpression\fR \fB,\fR \fIexpression\fR \fB)\fR \fIblock\fR + \fBmswitch ( \fIselectionExpression \fB) {\fR + \*[ \fBmcase ( \fIexpression\fR \*[ \fB,\fI expression\fR \*Z \fB)\fI block\fR \*Z + \*[ \fBmdefault\fI block\fR \*] + \fB}\fR + \fBconstrain\fR \fB(\fR \fIexpression\fR \fB)\fR \fIblock\fR + \fBassert\fR \fB(\fR \fIexpression\fR \fB)\fR \*[ \fIexpression\fR \*] + \fBinclude\fR \fItextString\fR + \fBextern\fR \fIidentifier\fR \*[ \fB,\fR \fIidentifier\fR \*Z + \fBstart\fR \fIexpression\fR + \fBorg\fR \fIexpression\fR + \fBtarget\fR \fIexpression\fR + \fIexpression\fR + +\fIdataStatement\fR: +\*[ \fIlabel\fR \*Z \fBblock\fR \fIexpression\fR \*[ \fB,\fR \fIexpression\fR \*Z +\*[ \fIlabel\fR \*Z \fBalign\fR \fIexpression\fR +\*[ \fIlabel\fR \*Z \fBword\fR \fIexpression\fR \*[ \fB,\fR \fIexpression\fR \*Z +\*[ \fIlabel\fR \*Z \fBlong\fR \fIexpression\fR \*[ \fB,\fR \fIexpression\fR \*Z +\*[ \fIlabel\fR \*Z \fBdbyte\fR \fIexpression\fR \*[ \fB,\fR \fIexpression\fR \*Z +\*[ \fIlabel\fR \*Z \fBbyte\fR \fIexpression\fR \*[ \fB,\fR \fIexpression\fR \*Z +\*[ \fIlabel\fR \*Z \fBstring\fR \fIexpression\fR \*[ \fB,\fR \fIexpression\fR \*Z +\*[ \fIlabel\fR \*Z \fBstruct\fR \fB{\fR \*[ \fIdataStatement\fR \*Z \fB}\fR \fIidentifier\fR +\*[ \fIlabel\fR \*Z \fBstruct\fR \fIidentifier\fR + +\fIlabel\fR: \fIidentifier\fR \fB:\fR + +\fIoperand\fR: + \fBd\fIn\fR + \fBa\fIn\fR + \fBsp\fR + \fB\s-1[\s+1\fR \fBa\fIn\fR \fB\s-1]\s+1\fR + \fB\s-1[\s+1\fR \fBa\fIn\fR \fB\s-1]\s+1+\fR + \fB-\s-1[\s+1\fR \fBa\fIn\fR \fB\s-1]\s+1\fR + \fIexpression\fR + \fIexpression\fB . w\fR + \fIexpression\fB . l\fR + \fB#\fR \fIexpression\fR + \fIexpression\fR \fB\s-1[\s+1\fR \fBa\fIn\fR \fB\s-1]\s+1\fR + \fBa\fIn\fR \fB.\fR \fIidentifier\fR \*[ \fB.\fR \fIidentifier\fR \*Z + \fIexpression\fR \fB\s-1[\s+1\fR \fBa\fIn\fR \fB,\fR \fIrn\fR \fB. w \s-1]\s+1\fR + \fIexpression\fR \fB\s-1[\s+1\fR \fBa\fIn\fR \fB,\fR \fIrn\fR \fB. l \s-1]\s+1\fR + \fIexpression\fR \fB\s-1[\s+1\fR \fBa\fIn\fR \fB,\fR \fIrn\fR \fB\s-1]\s+1\fR + \fBa\fIn\fR \fB\s-1[\s+1\fR \fIrn\fR \fB. w \fB\s-1]\s+1\fR \fB.\fR \fIidentifier\fR \*[ \fB.\fR \fIidentifier\fR \*Z + \fBa\fIn\fR \fB\s-1[\s+1\fR \fIrn\fR \fB. l \fB\s-1]\s+1\fR \fB.\fR \fIidentifier\fR \*[ \fB.\fR \fIidentifier\fR \*Z + \fBa\fIn\fR \fB\s-1[\s+1\fR \fIrn\fR \fB\s-1]\s+1\fR \fB.\fR \fIidentifier\fR \*[ \fB.\fR \fIidentifier\fR \*Z + \fIexpression\fR \fB\s-1[\s+1\fR \fBpc\fR \fB\s-1]\s+1\fR + \fIexpression\fR \fB\s-1[\s+1\fR \fBpc\fR \fB,\fR \fIrn\fR \fB. w \s-1]\s+1\fR + \fIexpression\fR \fB\s-1[\s+1\fR \fBpc\fR \fB,\fR \fIrn\fR \fB. l \s-1]\s+1\fR + \fIexpression\fR \fB\s-1[\s+1\fR \fBpc\fR \fB,\fR \fIrn\fR \fB\s-1]\s+1\fR + \fBccr\fR + \fBsr\fR + \fBusp\fR + \fBsfc\fR + \fBdfc\fR + \fBvbr\fR + \fItextString\fR + +\fIblock\fR: \fB{\fR \*[ \fIstatement\fR Newline \*Z \fB}\fR + +\fItextString\fR: + \fB" \fIany string you like \fB"\fR + +\fIcondition\fR: + \fIconditionCode\fR + \fB!\fR \fIconditionCode\fR + +\fIexpression\fR: + \fIidentifier\fR + \fIidentifier\fR \fB(\fR \*[ \fIoperand\fR \*[ \fB,\fR \fIoperand\fR \*Z \*] \fB)\fR + \fInumber\fR + \fBhere\fR + \fItextString\fR + \fB(\fR \fIexpression\fR \fB)\fR + \fB-\fR \fIexpression\fR + \fB!\fR \fIexpression\fR + \fB~\fR \fIexpression\fR + \fB?\fR \fIexpression\fR + \fB/\fR \fIexpression\fR + \fIexpression\fR \fB*\fR \fIexpression\fR + \fIexpression\fR \fB/\fR \fIexpression\fR + \fIexpression\fR \fB%\fR \fIexpression\fR + \fIexpression\fR \fB-\fR \fIexpression\fR + \fIexpression\fR \fB+\fR \fIexpression\fR + \fIexpression\fR \fB<<\fR \fIexpression\fR + \fIexpression\fR \fB>>\fR \fIexpression\fR + \fIexpression\fR \fB<\fR \fIexpression\fR + \fIexpression\fR \fB>\fR \fIexpression\fR + \fIexpression\fR \fB<=\fR \fIexpression\fR + \fIexpression\fR \fB>=\fR \fIexpression\fR + \fIexpression\fR \fB==\fR \fIexpression\fR + \fIexpression\fR \fB!=\fR \fIexpression\fR + \fIexpression\fR \fB&\fR \fIexpression\fR + \fIexpression\fR \fB|\fR \fIexpression\fR + \fIexpression\fR \fB^\fR \fIexpression\fR + \fIexpression\fR \fB&&\fR \fIexpression\fR + \fIexpression\fR \fB||\fR \fIexpression\fR + \fIexpression\fR \fB^^\fR \fIexpression\fR + \fIexpression\fR \fB.\fR \fIidentifier\fR + \fIidentifier\fR \fB=\fR \fIexpression\fR + \fIidentifier\fR \fB+=\fR \fIexpression\fR + \fIidentifier\fR \fB-=\fR \fIexpression\fR + \fIidentifier\fR \fB*=\fR \fIexpression\fR + \fIidentifier\fR \fB/=\fR \fIexpression\fR + \fIidentifier\fR \fB%=\fR \fIexpression\fR + \fIidentifier\fR \fB&=\fR \fIexpression\fR + \fIidentifier\fR \fB|=\fR \fIexpression\fR + \fIidentifier\fR \fB^=\fR \fIexpression\fR + \fIidentifier\fR \fB<<=\fR \fIexpression\fR + \fIidentifier\fR \fB>>=\fR \fIexpression\fR + \fIidentifier\fR \fB++\fR + \fIidentifier\fR \fB--\fR + \fB++\fR \fIidentifier\fR + \fB--\fR \fIidentifier\fR + +\fIidentifier\fR: + \*[\fBa\fR-\fBzA\fR-\fBZ_\fR\*]\*[\fBa\fR-\fBzA\fR-\fBZ_0\fR-\fB9\fR\*Z + +\fInumber\fR: + \fIdecimalNumber\fR + \fIoctalNumber\fR + \fIbinaryNumber\fR + \fIhexadecimalNumber\fR + \fIquarter\fR + +\fIdecimalNumber\fR: + \*[\fB1\fR-\fB9\fR\*]\*[\fB0\fR-\fB9\fR\*Z + +\fIoctalNumber\fR: + \fB0\fR\*[\fB0\fR-\fB7\fR\*Z + +\fIbinaryNumber\fR: + \fB0b\fR\*[\fB01\fR\*]\*[\fB01\fR\*Z + +\fIhexadecimalNumber\fR: + \fB0x\fR\*[\fB0\fR-\fB9a\fR-\fBf\fR\*]\*[\fB0\fR-\fB9a\fR-\fBf\fR\*Z + +\fIquarter\fR: + \fB0q\fR\*[\fB0\fR-\fB3\fR\*]\*[\fB0\fR-\fB3\fR\*Z + +.fi +.bp +.CD +\s+5\fBAppendix B \*- Recognized Opcode Mnemonics\fR\s-5 +\"\s+4\fBAppendix B \*- Recognized Opcode Mnemonics\fR\s-4 +.sp 1 +\s+3\fB(68000 version)\fR\s-3 +.DE +.PP +These are the 68000 opcode mnemonics recognized by \fIMacross\fR: +.2C +.nf +\fBabcd +addb +addl +addqb +addql +addqw +addw +addxb +addxl +addxw +andb +andl +andw +aslb +asll +aslw +asrb +asrl +asrw +bcc +bchg +bclr +bcs +beq +bge +bgt +bhi +ble +bls +blt +bmi +bne +bpl +bra +bset +bsr +btst +bvc +bvs +chk +clrb +clrl +clrw +cmpb +cmpl +cmpmb +cmpml +cmpmw +cmpw +dbcc +dbcs +dbeq +dbf +dbge +dbgt +dbhi +dble +dbls +dblt +dbmi +dbne +dbpl +dbra +dbt +dbvc +dbvs +divs +divu +eorb +eorl +eorw +exg +extl +extw +illegal +jmp +jsr +lea +link +lslb +lsll +lslw +lsrb +lsrl +lsrw +movb +moveb +movel +moveml +movemw +movepl +movepw +moveq +movesb +movesl +movesw +movew +movl +movml +movmw +movpl +movpw +movq +movsb +movsl +movsw +movw +muls +mulu +nbcd +negb +negl +negw +negxb +negxl +negxw +nop +notb +notl +notw +orb +orl +orw +pea +reset +rolb +roll +rolw +rorb +rorl +rorw +roxlb +roxll +roxlw +roxrb +roxrl +roxrw +rtd +rte +rtr +rts +sbcd +scc +scs +seq +sf +sge +sgt +shi +sle +sls +slt +smi +sne +spl +st +stop +subb +subl +subqb +subql +subqw +subw +subxb +subxl +subxw +svc +svs +swap +tas +trap +trapv +tstb +tstl +tstw +unlk +.fi +.1C +.CD +\s+5\fBAppendix C \*- Condition Codes\fR\s-5 +\"\s+4\fBAppendix C \*- Condition Codes\fR\s-4 +.sp 1 +\s+3\fB(68000 version)\fR\s-3 +.DE +.PP +The \fIMacross\fR \fBif\fR, \fBwhile\fR, \fBdo-while\fR and \fBdo-until\fR +statements make use of symbols denoting the hardware condition codes of the +target processor which may be used as the conditions upon which conditional +branches are base. In the 68000 version of \fIMacross\fR, these are the +recognized condition code symbols: +.LP +.nf + \fBcarry\fR + \fBequal\fR + \fBgeq\fR + \fBgreater\fR + \fBgt\fR + \fBhigh\fR + \fBhigh_same\fR + \fBhs\fR + \fBless\fR + \fBleq\fR + \fBlow\fR + \fBlow_same\fR + \fBls\fR + \fBlt\fR + \fBminus\fR + \fBnegative\fR + \fBneq\fR + \fBoverflow\fR + \fBplus\fR + \fBpositive\fR + \fBzero\fR + +.fi +.bp +.CD +\s+5\fBAppendix D \*- Built-In Functions\fR\s-5 +\"\s+4\fBAppendix D \*- Built-In Functions\fR\s-4 +.DE +.PP +Certain predefined built-in functions are supported by \fIMacross\fR for +reasons of convenience or syntactic or semantic irregularity. They are: +.nf + +\fBaddressMode(\fIoperand\fB)\fR +.fi +.RS +Returns a number whose value indicates which addressing mode \fIoperand\fR +represents \fI((define these values))\fR. +.RE +.nf + +\fBapply(\fImacname\fR \*[ \fB, \fIarg\fR \*Z \fB)\fR +.fi +.RS +Assembles the macro whose name is specified by the \fBstring\fR \fImacname\fR +with the macro arguments (if any) given by the \fIarg\fRs. +.RE +.nf + +\fBgetAddressRegister(\fIoperand\fB)\fR +.fi +.RS +Returns a number from 0 to 7 indicating which address register is used in +\fIoperand\fR (assuming that the address mode of \fIoperand\fR is address +register, register indirect, postincrement, predecrement, displacement or +indexed). +.RE +.nf + +\fBgetDataRegister(\fIoperand\fB)\fR +.fi +.RS +Returns a number from 0 to 7 indicating which data register is used in +\fIoperand\fR (assuming that the address mode of \fIoperand\fR is data +register). +.RE +.nf + +\fBgetIndexRegister(\fIoperand\fB)\fR +.fi +.RS +Returns a number from 0 to 15 indicating which register is used as the index +register in \fIoperand\fR (assuming that the address mode of operand is +indexed or program counter indexed). The values 0 through 7 indicate the +address registers \fBa0\fR through \fBa7\fR and the values 8 through 15 +indicate the data registers \fBd0\fR through \fBd7\fR. +.RE +.nf + +\fBgetRegister(\fIoperand\fB)\fR +.fi +.RS +Returns a number from 0 to 15 indicating which register is used in +\fIoperand\fR. The values 0 through 7 indicate the address registers \fBa0\fR +through \fBa7\fR and the values 8 through 15 indicate the data registers +\fBd0\fR through \fBd7\fR. +.RE +.nf + +\fBgetWL(\fIoperand\fB)\fR +.fi +.RS +Returns a number 0 or 1 indicatng whether \fIoperand\fR is a word operand or a +long operand (assuming that the address mode of \fIoperand\fR is absolute, +indexed or program counter indexed). +.RE +.nf + +\fBisAbsoluteLongMode(\fIoperand\fB)\fR +.fi +.RS +Returns \fBTRUE\fR if and only if the address mode of \fIoperand\fR is +absolute long, otherwise \fBFALSE\fR. +.RE +.nf + +\fBisAbsoluteMode(\fIoperand\fB)\fR +.fi +.RS +Returns \fBTRUE\fR if and only if the address mode of \fIoperand\fR is +absolute (short or long), otherwise \fBFALSE\fR. +.RE +.nf + +\fBisAbsoluteShortMode(\fIoperand\fB)\fR +.fi +.RS +Returns \fBTRUE\fR if and only if the address mode of \fIoperand\fR is +absolute short, otherwise \fBFALSE\fR. +.RE +.nf + +\fBisAbsoluteValue(\fIoperand\fB)\fR +.fi +.RS +Returns \fBTRUE\fR if and only if \fIoperand\fR is an absolute (i.e., +non-relocatable) value, otherwise \fBFALSE\fR. +.RE +.bp +.nf +\fBisARegister(\fIoperand\fB)\fR +.fi +.RS +Returns \fBTRUE\fR if and only if \fIoperand\fR is an address register, +otherwise \fBFALSE\fR. +.RE +.nf + +\fBisBlock(\fIoperand\fB)\fR +.fi +.RS +Returns \fBTRUE\fR if and only if \fIoperand\fR is a block, otherwise +\fBFALSE\fR. +.RE +.nf + +\fBisBuiltInFunction(\fIsymbol\fB)\fR +.fi +.RS +Returns \fBTRUE\fR if and only if \fIsymbol\fR is a built-in function, +otherwise \fBFALSE\fR. +.RE +.nf + +\fBisCCRegister(\fIoperand\fB)\fR +.fi +.RS +Returns \fBTRUE\fR if and only if \fIoperand\fR is the condition code +register, otherwise \fBFALSE\fR. +.RE +.nf + +\fBisConditionCode(\fIoperand\fB)\fR +.fi +.RS +Returns \fBTRUE\fR if and only if \fIoperand\fR is a condition code, +otherwise \fBFALSE\fR. +.RE +.nf + +\fBisControlRegister(\fIoperand\fB)\fR +.fi +.RS +Returns \fBTRUE\fR if and only if \fIoperand\fR is a control register +(\fBusp\fR, \fBdfc\fR, \fBsfc\fR, or \fBvbr\fR), otherwise \fBFALSE\fR. +.RE +.nf + +\fBisDefined(\fIsymbol\fB)\fR +.fi +.RS +Returns \fBTRUE\fR if and only if \fIsymbol\fR has been defined, otherwise +\fBFALSE\fR. +.RE +.nf + +\fBisDFCRegister(\fIoperand\fB)\fR +.fi +.RS +Returns \fBTRUE\fR if and only if \fIoperand\fR is the destination function +code register, otherwise \fBFALSE\fR. +.RE +.nf + +\fBisDRegister(\fIoperand\fB)\fR +.fi +.RS +Returns \fBTRUE\fR if and only if \fIoperand\fR is a data register, otherwise +\fBFALSE\fR. +.RE +.nf + +\fBisDisplacementMode(\fIoperand\fB)\fR +.fi +.RS +Returns \fBTRUE\fR if and only if the address mode of \fIoperand\fR +displacment, otherwise \fBFALSE\fR. +.RE +.nf + +\fBisExternal(\fIsymbol\fB)\fR +.fi +.RS +Returns \fBTRUE\fR if and only if \fIsymbol\fR is external (i.e., visible +outside the file in which it is defined), otherwise \fBFALSE\fR. +.RE +.nf + +\fBisField(\fIsymbol\fB)\fR +.fi +.RS +Returns \fBTRUE\fR if and only if \fIsymbol\fR is a field of a struct, +otherwise \fBFALSE\fR. +.RE +.nf + +\fBisFunction(\fIsymbol\fB)\fR +.fi +.RS +Returns \fBTRUE\fR if and only if \fIsymbol\fR is a user defined function, +otherwise \fBFALSE\fR. +.RE +.nf + +\fBisImmediateMode(\fIoperand\fB)\fR +.fi +.RS +Returns \fBTRUE\fR if and only if the address mode of \fIoperand\fR is +\fIimmediate\fR, otherwise \fBFALSE\fR. +.RE +.nf + +\fBisIndexedMode(\fIoperand\fB)\fR +.fi +.RS +Returns \fBTRUE\fR if and only if the address mode of \fIoperand\fR is an +indexed mode, otherwise \fBFALSE\fR. +.RE +.nf + +\fBisPostincrementMode(\fIoperand\fB)\fR +.fi +.RS +Returns \fBTRUE\fR if and only if the address mode of \fIoperand\fR is +postincrement, otherwise \fBFALSE\fR. +.RE +.nf + +\fBisPredecrementMode(\fIoperand\fB)\fR +.fi +.RS +Returns \fBTRUE\fR if and only if the address mode of \fIoperand\fR is +predecrement, otherwise \fBFALSE\fR. +.RE +.nf + +\fBisRelocatableValue(\fIoperand\fB)\fR +.fi +.RS +Returns \fBTRUE\fR if and only if \fIoperand\fR is a relocatable value, +otherwise \fBFALSE\fR. +.RE +.nf + +\fBisSFCRegister(\fIoperand\fB)\fR +.fi +.RS +Returns \fBTRUE\fR if and only if \fIoperand\fR is the source function code +register, otherwise \fBFALSE\fR. +.RE +.nf + +\fBisStatusRegister(\fIoperand\fB)\fR +.fi +.RS +Returns \fBTRUE\fR if and only if \fIoperand\fR is the status register, +otherwise \fBFALSE\fR. +.RE +.nf + +\fBisString(\fIoperand\fB)\fR +.fi +.RS +Returns \fBTRUE\fR if and only if \fIoperand\fR is a string, otherwise +\fBFALSE\fR. +.RE +.nf + +\fBisStruct(\fIsymbol\fB)\fR +.fi +.RS +Returns \fBTRUE\fR if and only if \fIsymbol\fR is the name of a struct, +otherwise \fBFALSE\fR. +.RE +.nf + +\fBisSymbol(\fIoperand\fB)\fR +.fi +.RS +Returns \fBTRUE\fR if and only if \fIoperand\fR is a symbol (as opposed to an +expression or a number, for example), otherwise \fBFALSE\fR. +.RE +.nf + +\fBisUSP(\fIoperand\fB)\fR +.fi +.RS +Returns \fBTRUE\fR if and only if \fIoperand\fR is the user stack pointer, +otherwise \fBFALSE\fR. +.RE +.nf + +\fBisVBRegister(\fIoperand\fB)\fR +.fi +.RS +Returns \fBTRUE\fR if and only if \fIoperand\fR is the vector base register, +otherwise \fBFALSE\fR. +.RE +.nf + +\fBlistingOff()\fR +.fi +.RS +If assembly listing has been enabled using the \fB-l\fR command line flag, +turn listing off temporarily. Otherwise, no effect. +.RE +.nf + +\fBlistingOn()\fR +.fi +.RS +If assembly listing was turned off using the \fBlistingOff()\fR function, turn +it back on again. If listings have been globally disabled by not specifying +the \fB-l\fR command line flag, this function has no effect. The +\fBlistingOff()\fR and \fBlistingOn()\fR functions are intended to be used to +together to control assembly listings of large programs. They can be used to +suppress listing of large and uninteresting sections such as header files full +of definitions of global values. These functions may nest: in effect +\fBlistingOff()\fR increments a counter and \fBlistingOn()\fR decrements it. +Only when the counter is zero (i.e., the number of \fBlistingOn()\fRs matches +the number of \fBlistingOff()\fRs) does listing actually occur. +.RE +.nf + +\fBprintf(\fIformat\fR \*[ \fB, \fIarg\fR \*Z \fB)\fR +.fi +.RS +A formatted print routine just like the Unix system subroutine of the same +name. +.RE +.nf + +\fBstrcat(\fIstring1\fB, \fIstring2\fB)\fR +.fi +.RS +Returns a string which is the concatenation of the two operands, which must +themselves be strings. +.RE +.nf + +\fBstrcmp(\fIstring1\fB, \fIstring2\fB)\fR +.fi +.RS +Returns a number which is less than, equal to, or greater than 0 depending +upon whether \fIstring1\fR is lexically less than, equal to, or greater than +\fIstring2\fR. The ASCII character set is used. The two operands, of course, +must be strings. +.RE +.nf + +\fBstrcmplc(\fIstring1\fB, \fIstring2\fB)\fR +.fi +.RS +Essentially the same as \fBstrcmp()\fR except that alphabetic characters are +converted to lower case before being compared. The result is a +case-independent string comparison. This is useful for comparing two +identifier name strings to see if they represent the same symbols. +.RE +.nf + +\fBstrlen(\fIstring\fB)\fR +.fi +.RS +Returns a number which is the length, in characters, of \fIstring\fR. +.RE +.nf + +\fBsubstr(\fIstring\fB, \fIstartPos\fR \*[\fB , \fIlength\fR \*] \fB)\fR +.fi +.RS +Returns a substring of the string \fIstring\fR starting from the character at +start position \fIstartPos\fR (counting the first character from 0) and +continuing for \fIlength\fR characters. If \fIstartPos\fR is negative, the +start position is counted from right to left (with the rightmost character +position being indicated by -1) instead of the more usual left to right. If +\fIlength\fR is negative, \fIstartPos\fR in essence denotes the end of the +desired substring and \fIlength\fR characters up to that position are +returned. If \fIlength\fR is omitted, the substring from \fIstartPos\fR to +the end of the string is returned, if \fIstartPos\fR is positive, or to the +beginning of the string, if \fIstartPos\fR is negative. If any of the indices +cause the substring bounds to go off the end of \fIstring\fR an error results. +For example, +.nf + \fBsubstr("hello there", 6, 3)\fR yields \fB"the"\fR + \fBsubstr("hello there", -8, 2)\fR yields \fB"lo"\fR + \fBsubstr("hello there", 6, -3)\fR yields \fB"o t"\fR + \fBsubstr("hello there", -8, -4)\fR yields \fB"hell"\fR + \fBsubstr("hello there", 6)\fR yields \fB"there"\fR + \fBsubstr("hello there", -7)\fR yields \fB"hello"\fR +.fi +.RE +.nf + +\fBsymbolLookup(\fIstring\fB)\fR +.fi +.RS +A call to this function with a string operand is equivalent to a reference to +the symbol that the string represents. For example, +.nf + \fBand symbolLookup("foo")\fR +.fi +is equivalent to +.nf + \fBand foo\fR +.fi +.RE +.nf + +\fBsymbolName(\fIsymbol\fB)\fR +.fi +.RS +Returns a string which is the name of the symbol \fIsymbol\fR. For example, +\fBsymbolName(foo)\fR would return \fB"foo"\fR. This can be used in +conjunction with the \fBsymbolLookup\fR function so that the following: +.nf + \fBand symbolLookup(strcat(symbolName(foo), "bar"))\fR +.fi +is equivalent to +.nf + \fBand foobar\fR +.fi +.RE +.nf + +\fBsymbolUsage(\fIsymbol\fB)\fR +.fi +.RS +Returns a number whose value indicates what sort of symbol \fIsymbol\fR is +(i.e., label, function, struct field, etc.). \fI((define these values))\fR +.RE +.nf + +\fBvalueType(\fIthing\fB)\fR +.fi +.RS +Returns a number whose value indicates the type of \fIthing\fR (i.e., symbol, +condition code, number, block, etc.). \fI((define these values))\fR +.RE + +.fi +.bp +.CD +\s+5\fBAppendix E \*- Operator Set\fR\s-5 +\"\s+4\fBAppendix E \*- Operator Set\fR\s-4 +.DE +.PP +This appendix describes the (\fBC\fR derived) operators supported by +\fIMacross\fR. +.nf + + \fB-\fR \fIexpression\fR integer negation + \fB!\fR \fIexpression\fR logical negation (0 goes to 1, all other values go to 0) + \fB~\fR \fIexpression\fR bitwise negation (ones complement) + \fB?\fR \fIexpression\fR high byte + \fB/\fR \fIexpression\fR low byte + \fIexpression\fR \fB*\fR \fIexpression\fR integer multiplication + \fIexpression\fR \fB/\fR \fIexpression\fR integer division + \fIexpression\fR \fB%\fR \fIexpression\fR integer modulus (remainder) + \fIexpression\fR \fB-\fR \fIexpression\fR integer subtraction + \fIexpression\fR \fB+\fR \fIexpression\fR integer addition + \fIexpression\fR \fB<<\fR \fIexpression\fR left shift + \fIexpression\fR \fB>>\fR \fIexpression\fR right shift + \fIexpression\fR \fB<\fR \fIexpression\fR less than + \fIexpression\fR \fB>\fR \fIexpression\fR greater than + \fIexpression\fR \fB<=\fR \fIexpression\fR less than or equal to + \fIexpression\fR \fB>=\fR \fIexpression\fR greater than or equal to + \fIexpression\fR \fB==\fR \fIexpression\fR equal to + \fIexpression\fR \fB!=\fR \fIexpression\fR not equal to + \fIexpression\fR \fB&\fR \fIexpression\fR bitwise AND + \fIexpression\fR \fB|\fR \fIexpression\fR bitwise OR + \fIexpression\fR \fB^\fR \fIexpression\fR bitwise XOR + \fIexpression\fR \fB&&\fR \fIexpression\fR logical AND + \fIexpression\fR \fB||\fR \fIexpression\fR logical OR + \fIexpression\fR \fB^^\fR \fIexpression\fR logical XOR + \fIexpression\fR \fB.\fR \fIidentifier\fR struct field selection + \fIidentifier\fR \fB=\fR \fIexpression\fR assignment + \fIidentifier\fR \fB+=\fR \fIexpression\fR assignment with addition + \fIidentifier\fR \fB-=\fR \fIexpression\fR assignment with subtraction + \fIidentifier\fR \fB*=\fR \fIexpression\fR assignment with multiplication + \fIidentifier\fR \fB/=\fR \fIexpression\fR assignment with division + \fIidentifier\fR \fB%=\fR \fIexpression\fR assignment with modulus + \fIidentifier\fR \fB&=\fR \fIexpression\fR assignment with AND + \fIidentifier\fR \fB|=\fR \fIexpression\fR assignment with OR + \fIidentifier\fR \fB^=\fR \fIexpression\fR assignment with XOR + \fIidentifier\fR \fB<<=\fR \fIexpression\fR assignment with left shift + \fIidentifier\fR \fB>>=\fR \fIexpression\fR assignment with right shift + \fIidentifier\fR \fB++\fR post-increment + \fIidentifier\fR \fB--\fR post-decrement + \fB++\fR \fIidentifier\fR pre-increment + \fB--\fR \fIidentifier\fR pre-decrement + +.fi +.bp +.CD +\s+5\fB Appendix F \*- Character Escape Codes\fR\s-5 +\"\s+4\fB Appendix F \*- Character Escape Codes\fR\s-4 +.DE +.PP +Like \fBC\fR, \fIMacross\fR enables you to use the ``\fB\\\fR'' character as +an escape to embed quotation marks, formatting characters (such as newline) +and other non-printing characters in character strings and character +constants. The recognized codes are: +.nf + + \fB\\n\fR newline + \fB\\t\fR horizontal tab + \fB\\b\fR backspace + \fB\\r\fR carriage return + \fB\\f\fR form feed + \fB\\e\fR escape + \fB\\\\\fR backslash + \fB\\'\fR apostrophe + \fB\\"\fR quote + \fB\\^\fIc\fR CONTROL-\fIc\fR (where \fIc\fR is any character). + \fB\\\fIddd\fR arbitrary byte (where \fIddd\fR is one, two or three octal digits). +.fi diff --git a/driver.c b/driver.c new file mode 100644 index 0000000..e3404fd --- /dev/null +++ b/driver.c @@ -0,0 +1,47 @@ +/* + driver.c -- Top level driver program for all versions of Macross + + Chip Morningstar -- Lucasfilm Ltd. + + 3-May-1985 + +*/ + +#include + +#define MACROSS_6502 "/u1/gg/bin/macross_6502" +#define MACROSS_68000 "/u1/gg/bin/macross_68000" + +char *m6502 = "6502"; +char *m68000 = "68000"; + +char **mlist; + +main(argc, argv) + char **argv; +{ + char *processor = m6502; + int i; + int j; + + mlist = (char **)calloc(argc + 1, sizeof (char **)); + for (i=1, j=1; iAngb|u>jEN1-&V~nu9-d!{HYDS~cNHX<~q|xqpM;f6&-d(dW8c8E* zyd#a6k?h@sCW`}v5@;7xMJLS5pzl;gN= z;uvH1ckjFJz5C6dwS7*a*x#nx3Z6RZe`D%54zgV1y{6z@525^UVg0e zk(bXsG`Hi*bHN^>J&y06yLqeq^Lv6zzi{(*+x_k5E_(v`zPKZ}^mq2${_0aV%yn#o zXRD*TZ5#RbJo4&ul<&u#Tci8%`Q^P^!B2J{zWghDg14cpy(sG%N=MnFZ^P$jFP{q@ zy)?MwFt90)b-EOMm(lkhpscs!^MSW@2T$$@f~R(LcRYFhHgI>>Q`c`3?t-kNHvgV; zZBvvFpM&&yeoyyvHVwF4;fF0&cHlA}Lz!0uL2&=&Tfq;Y$P?{b9Y45!4tT5UiR7`2KFl+}hh6{J0|sp6=-G`0)+fz};O>->^+MBvb4C6C>+w zkhPo2c?REqZ)f-JTY$fI#a8gMo#%q*c5Ze2Y~LL4R@Za;<_L%6!5*9!a@Vbnz#R(j zvG{pY-rKG2FW`GW%KG``qrUf*|<(<=e3Nh2Y8d?T#m|-vZw5dh+@$!l82ZoD2R!?Eai8qf6m+g`3uu z+68|37F*YCe7^xYJhXQXZFD&JNyl8r(>Hbl&vpIe#%{tP9bQjeslCMaxvtOR``32P z?LLHZ{>>HJXuAu+^E+4GG0=d^%-TwyP2O#qguj&q7 zLPU79v%BM^o3??W^G(}?Lo%UzEBo{uh8!x7+684?f-+e5$MOC1?OVIwNS{PGd#t=V ze{giNJIdK(%R&6eez{}r>iy8+U+&!wp6R#{JlnC|@yv}|z}sEV-nd0LR3F%AT5R;1 z_4=tP?@DXCpW%BHWj%alckukKAb4R{cgOSlwt>65Uf8!yI8@f_sS~va>hume1U)~)&){gkv-re!o{yE_8uE+P!5e}7uI$cL~vUv^z(|6FXrcd;v(eu}L z?>zTV_hnZ<^6KAy=H~8p7gyVZOFr_)h99hN=sE*)mLBnAkoh6*qZw+=#RG_MogXSc>MZq z*kP{g2iJEK?xHd1F!)#=%26^dfsAo0;{nLy^#5#qNd5+G1&=R9WjT7YnD0 zi`^S5)y;QbYB+;4L9nY!<`N$UzD)1~ivFOYe;N4WufF;!%{MLt!O|y0&bNVoL-5nk zfOxJoEz0~zYTIq{zVZU_)q>%1ZE-KBE$QX7oiK7<`3iW-!hb(7%CzOSeM<3vP55WP z^M}HJ6!;0n|0Bi!vha5VLHi!V|BL5)xBDsp@oa52dxA3A^m@j`gI%-`~)!cWcv4jp{JG8aYD&~Zsb=#hi)Ao75)zcpBKCi z3_V%SA~5uHaxN%2+ajkMJTD0U?jYD12*&45d?z_CA$=$Gv~qSvyquj`Bj=^Bg9myt z|5t!fHe=|r6FM=5jyv(s$+=(2L4K;&OOUto+u-jC0{j>3{4Oy1BjfL31R$O`=+8lK z5O;L|zW@v#!t}2LQKfAK80myNz`JX=!8;&h*B*npoV^NPt?;!9lZ_yU`EOMCfWg7b zkQp(!9p&um5xflyn~Z(}6~W)GQ@|1*cA>uAsLS7FL4Q#&^zA&1@1VbU0T}$&R-JR+ zR-NYz|BLwSJP*Bye;pVyFDDF{oyZ?0d^mtI6g%-Zihoxb+=jA(TZK+(JSGspAFn0w z30npWif2{fdj%8Er^sud_igy!=N0|;6#j<7-xf@no>27vtMD%jCNb;s7;V?~6@$6let|E$&TAC?pu$Oo z?@;&y3U3%pzOnP8imv+9PHEq^2zab+@Y|hF8h+~6JAWp5LEm+ym$NIPuxis?cPaXs z!uKg`b%1WWzG~>C=Puhv&=$M?RPn2J-1T=t2Y+Xmi4}lB=e0tIpiX70&cj|#r_!x+ zS?H)&=dTJr2W)kN4xRs6<^7hzk1DL%vD4a$^1dQG(5=hbjqoi#Z`VIkIH$0UEzqay zzD49Re_anL{PlB|9CSUUFa>h?yW|Fi(+aOB{7)5rSm8fc_*suH-Kp@~6@Jfsf&IJm zHih2@p1qi3a8o^GS%ORd0`v|;zx1zw+XTPl>6h*D^vkdu3fc|NW!Ed7n8GQ=^EpNT zU%(>&vY&hU?l&v^yB@#kfY<*`?^X2w?eUvS3X`p*F4*@7?B84Vg1+16{Fc+eU4p*_ zEH>GbSNM$Q-?OdoE5IWEt=B00Up&72lfd0Z{@XsT@I$~-?q0H|#n%Cg4txKT!awvp zSKOrV^T2zI{44*t!m2J;KIZwa>QnfH=fCRv9$#Hi_&0z>pSM$+T1@^U^}1$S;dNlK z?KPyc#eWAZb$rJi3X{)^4d3xAivAr%|B7S zz|z+HsGkbH>8-%xdpE5qOg=C2Z~9jXe^=pWJl@}_@VvtR7+CDHpKK`jfa)&?s4oPj z?GC&bSjs(c9$550@JF70aJRyDE39<8xf^sT>*n7CmO8$N`lgii9_l+H|2^anQf`Fm zB6%Z9|Hu~=&o@2KE&CK!ZFI~3^!&GypNq^}|HR`%QO|RT{9kwumAp?LqCO@5bLh7e z|9@2YhYG*qagXY2J;R_&eS4^lEWS_ili!LRdPq-;sV-u-XuGFJZ%}wt;bmZvAEP)d zSofXYt3a3f_Wqi}UjUYJd!P0=PJLYXH8a6k1Oi+dEFP`IqHl9_yqrze#UCskY;P`)~F9Q;zpfp7S{ zgKfZ4$3Ydh2S2TNp7nTWP~i_NOmRu-GW1hmk$Kx4o_^cE02Uo?`<9|pY!~0Sjbe-N zyqEk?@a>m)e3;r%=!dCa3r@Y?UFJ&Ib$~~d|2VT6sC6UHvC7(pC#{+8nF1`5t<)LKRvn+Sadu3>z*e=^CIET5Rd4S zdGK7&CVJjMz9jTJ$ZswFGhmT%kWUIdNBvarSEBsd;7j^(kS%q$e2Na$F7Wst=u;@_u zwBq@y!hfdl_Z5Cx;TJugzeM48E3E21Kd0!w42=KiZ(ivz|J&WJF7pp7{2gG?fBr8O z{jWV1}rvT`BFDxTEKrRk0|_<$0gED@|MW2ByVX5SoA4P zDNOBa=?^OWU0^Hc=fI-d-Q+VC4|<-vj{{3tcYjLZf2;6+Rrvn^i~Q4KYbJH+4&6dT);XV zA6y^s-ww?Afe!;8z(10c!pCib594!A@Gw3%1drhJe!<8Rd`)l~pDzf8zO-k~GBZ%a zmU{>AoY2RCR|HQ0e_e16s&)vT0;c+tZqvXw3Z4O87d#963Bh*)KOy)e@V4N)fL|2+ ze(XoGA3)|QVEkkG9{}DE{6XMv3oZbEPw+gyw_xP!w0eF9*y{hAz_#4` zfsvof`aJNK;4c7wT`=0G^P7Ty3;4T)x4B-OR)+^c2QKf=-%}`;7N^gy&R5EJ7RsB& zT9B_6%aw(~Mq$2O9H}f8r;5vX^c>_jR*Jdx1rWeeTB~hTHy7xcbc+8!L)<}rxwuxW z7B)(2%VVW8o9jWoxLVpcUa2k`G<@6`}P4RIRO4?oE};#%MJo&6p!x)?#sf6S|hx7RsB8#cz`3W_Ch`H(@Z?Zi!kVwYW&K z$I*O2etxr5-pH)k1`xrsFyc~at+>d3V7L~iORMYUA~&Yd<+LeV@|4!rH=$sWDq;+Q zQi|1k-~yF3lYts`vRYaLn>2iG9X_(QXxnySb9J+f4EGeXDBV)miuZDMvd{mXmsB(TmWjswL_hqDc`aIb7!`7tf5AYU>5~o)o=O zxTiP^15R%gsvA;uYQeQqZAHumci^r!y?~Ckuwq-;mZ?lwhV!7X9QrPLgp#*P4xX!8 zBZWP)GJiL9GuSD&xxuZAyvxOn+|p95h`OTjmMYa%TMOzZ#e1h&B`#-eu~4q871Pv} z$d`>u7s~0idrH;H8ueC+JkrT(GnEPSK9p9e@yQqJ;p;FS*eE6$KjwDj z-s($p?JEXxT}c9fwNqVyDHm!R+#SgWgS`7nb}(P5SoR9k60JlDW0mS8g&*qU5`a9Z z-WA1F+*uxJ@y)f zI2m)4g9_Y4EI(E%mXXgmlh8s=P%+_Q1Z_|gBXQw^IpmNc@TP^+q0#DSX?f*1LVtC< zQ00``W*L5)McZ0mA1Rc}Jd};tGgTBt(S2bUjzPl+O*9lx5HKSj7^Ej5&qlRU_Lj2a zO!^)Sooq$%vf}Fc##!4;*5&FAjpi#>8^aHcf65>>Ad(KcLDZl?ZAHBtqvFP9buE3S zguXP7p}4TIVk;ix*@#qsr=zMh24>qP7=&aXuujQCyVSz>KG&W$qOMmfi<=7+#ZObj z%W)tH@*HSUizanFw1jr7ng2%*Ev%H*50#h7hgj2E?NC4sV;Ur%= zmdcfa(RRS4#8K;Dv9gH& ztlhd29NMf^56R5tP;FzeQ~@zxs?2XL4bB{hQTxUM`k!WHFLnG=1QVgVcJdzw5 z3f4BuWm3~r;b2f$JDV#n&a7a>Vp8m2Fkh*ZZSp)^pK;&8fM!)LYvLe#iu;~KzS1&H zW|^J7BI`_rD8dw_dT+)^%p?X}QY>*0Rfnd;YiLobenGq!E;(c@!CXTkGYc1WGU2A1 zaq1Fmhncx}PTlaepd$W%I;8v$WBYZ+pZ;pu5f?~P2)OwEqW$k%veER)WT%D2AA zcxq%SC*Km0++=zxHDOcxBc}pn&P*H;hGb+UH!+%-$>b)4G7y=a7)_65Cek)jv?nq) zJ29eoqS44OG(09*qR?(Olby+DCi3;1y^++^RO+PVgtDnjb}-r(8G`f6kc6SEW&+Vl zAS7k5UTXYe`o!c^dU~4l%uP;=!eW{6@$_gW1sgIU8p)s{Q)$?RzsDk}{8ai#W_l() zWhlLo6Lpk$sZ7RRvAOvchXKXg%!qD!W-oPuBK#*clev@qDl?Uj4n`v| zO+Gdl<4-o!U@zknNR11M4fYA@9ZWDfIY_mHrSr%?m?WDM%AXh15t`v-20eS0+b13Qcs$k4jv$PkYEN2 zRI7!vPAmd@Ey*NWwTK9o$wZoFV4ho}!Vuzb#s}g#eIS^al7<2be6-r7b%mLIBkm&p zAiN{+t|5i8BbsxhMR;WS$c6Pgr*I6WKrJHS&^%Wcbxas8yXAzCO(do%%9tp?!VscJ zKa|dqnWK)@&{Z8ALBr%w>yJ1FlPmpO8Jl!4b4%6$!HPA&*kDx044{4z>a~a;49xr~ zwSm|;kC}2!5@~87X|uF0R~;PngF_T0s7<8C)A{L>N1r+} zJD#4HvDtbf+0<}4Yrn=L=@SS76DddOi`F8= zZU|J0%chQLRt{Vw#~Bpu0?mSHWX^+`jOneIF_o}y6KbBOEk_eSGpX^LVyvH29wh~4 z6T@iX6A-0pNuxE7MN}F`^W>1BN{pu%;O*l!n%pwmOQdL(bb88$4Tryv<#1Kbo(S&RPV_SgR z5J43)+4vAOt+N8BpnH--A)7R$-+y$Br~x>nXT=ag&(u8EOtHEut`#wZ%TVA`oeWab zn;lbi>`7rsxu%F{c1z@Of%lE-tH)gjTc|0?&Z^nbk*cQ?dZoL>RCj4!gjWqc$Ffk_ zM~ekNq3)%A6HUB<;>8O$u(?Z`LLo7;nNXPJ5E|H8&To{|_t{?bLzK-7O}p$kZ3=QB zaB6B(GXE}q6y}jsPXKL7LG@I}Bty-s>Ga1SWmgHH0Z#WfhdTAOK z>#;mm`RNHN zvQ}E45->OO0nLoC#bZ@XG!o61Q&*fl~acitX%%BjgKBINVz)JYAE0euHF+fdP&n#C2rOns zu>#Lvp+1$Ty*f0#TdIzvvROlf!Dq*ZEekfdW{1_r9_Q=DdNwy{*yEAmjQfJExv8{G z!HyjE>FhUhhofn1(XoVNL_#Bf8&Er(Be_xGL2#1IHD-b*@J6g?Nm~lEX=&1E|0>*< zhcQE&U87k%?G5!I8gIsZk1{C~4{QguJ(oJROYM`H5IVQaS2!q0IuE-%N;%J=wvtqC zY)%cu87G?}5hqhDb<{ptE5xx1=Tr`wK3Qf+ahsV3HJ6-_S$o`W)SZ&C)^pf71g~ol z9x0UgRE|r&US=-flHIh8W2z%3?6kn{Q1F(8OSaTzE#y5O5jWg`5)P^LXyH^#p60zs z@@(#7wu<3goaFXJ>Wg&6QGiz&&BiPjgxy7)842~B1iEu^_#}3*$1*2oC(&(==cY#G z3&kgah?cUGZ}_kqOquLXuW(@}SIO#g+4H$$*wM}Aucy??oO?_NHsSqNK^zJ~3GIW9r-5cXGQ0O`{l`%4g9urf^} z%t&xMky!6BHLaHANViL8G?baU>vI-ToJ`p5Rw^|t`Je1PHSEqt&Fq}kG+qzsOsJNh zr!P^JLThRy2et5FA8iwwTSOBLHsLMl9_Y_o1Fp<|>4FKkyT>HuW4G4nSdmt-r`Sri4~TV}1^qmmLFx(VkF?V4*MM z7TI_m<1>ubG^k%dTlY(nfs|T&tka7u*|cx<3}@i)JT|m?<(i;wc!Y9 zh$Mzv#TIMGp&1H#plc~4&tjrkZc!ng|6860Av{Le)NF-T38uofW=K1}g6AbIq|?eE zX?a>oX9-QE-+K|+yeL>@juw(Rt(jaL^YS6fJ|Dp&DYI0^nKW#i_>D%6Xr^=EX-bnM zV+@=bP*TZI)C_i2vx+jC8!1VhF`D=XC>2HO+S_=wT3Uj^aDdJn>MW98aP6_ zN(T<=aytJ^qE~Om>r(v`4W>xSoEh?sCBZz5pnKZQBV0Fv_m`GJyNgL);IAN(G;e51 zq0$T76ov2nCco7YiVtyspwa?+04(+zD7F2vT&SeC4#mYh38}|p0jiU zvWEFVBLi=@oOzA(!fT|LR#%IQB}~j3<(qnzu$fbZ&0D2=ziGuWPvNs!B28k>Omn+6 zw==ct+1Fx#pnI+5lv}9^iVt-;L$blx-_|{Eo3HOS1hoOTPmuzi@X6a(r(7h z^Cj16y>?rLrvsjB_jQJFUKs6fUR0tbfft9Nw3wUZjke5$IlY53d)O&3r&BbImKsV< zb6XDZ3R%vIWqheLVhz}hDmY4gl3Rm#C*qj`*~5-zY8vR5gX?JyhGD zFS<;P_RxF>VtFZBFM>mrr0E5Z7tJfo=5>hn@S0xMu`NV%{$`?iiP=gpM>ghYDwb24 z2@S8$LcKfMgD6$Ro+KXV%w#5J@id3~b~-zq4%4C$qGiUy)EM>n*2}+W4}#H|THOjp z28_ClF5*Oc5OOx-3w3Ks7qp^1h#-783(}1zgoh}#^s8I>MfuccvTo_;_ugBr{F+yQ z;s)0c3mZ0qUHEx{s6_KcpROG_HC5X6-MZqGWpLDuL~c|Ir561!ig6pR?YMBZUTruy za&d8(=6jS#=CZDh$J51DTY%9h_eF@X^;Cja5g6s5q24W8!0QTL{V4Z3rWKYscyq|& z{zlYhi*BOV#p-C3yBLD?2)_+MTfOKT>=G!#xC8}kpA0WI$rvnbU9DuLA5ObkYG^Ev z;+Uf>mAysofTc5eyqBDUz^QC_whmKFm6sb?%lVr^A$3ayz)UV3of zXqL(&SFl{IY_2y?HoKS2c7vl)bU{2JTk@UKotSi;lH-wLfM1$kYYitcQnAQVmtv?5 z@f@KQ3tY%Zu?U$*uyXkt7fM|aljeL2H2D^9CmH5Sl~&-f?Wm?(u7CC=zz6kcy1WA zhx)KhWMrIjr_X#rbW)FXv7y-RNI4d_F2O#RBSz_z9p|&F7MXuL4!6LgolZxM($P82 z=PFj`X1%r*ta0piv63N8(C;m5CIX5@8lm4->l7xo{C2wIaSEE}0*>zLTcf8bj_lZZ z?$k)egPTU8d0^8>M}PN3Ye9K7S+(^pTx;glJEt;&<=P=dU^;E8yJ#;=N0nFH<}09OSZ zQLt}fDMp-B7!TDH=T*k0(lfJDcuT?O#VZ73IJ2cFIPBHL0C*AWR6q&!Mu;Y$=}2}K z2PTw|etDHb(~_uqY6^$HeCY#`RF=-Bc~YzgC(4d!0>9;^39$$sa6{>FP3(nw=2bH# z3sq@oNWAxE-Mao*E?s`gccs zLW~ZczyVTtE6!`six=Xir_&*O^`b)4$1^h{M>S)gd0wxwCL%EOk+e2-Z$GBgWqRpe zrpY|Zq{E!NJmvd7Xx8SAqR{liQKNJ!lj36(Io$Ms#rbItl1vGqH7e!sP|C{FfI8V(DXHzpbn3z)OM&92|Drw`0=0u|1jwL_DrkijX1=N7Gb>so;pfW5MF zQdhaZUqk&v8OZKo;SFSU#saUyFXOypof&9yMSDQFWk4+<=%6f~ZkoAQ{Y!y{I$pqI zWqNg59MMqu$OU^)!mYGSihFf}Q)3u4?UPM9zG6ByQZVVY;2<~7DR##$KUH1_Or zOMLBy={a`fou~U*)cZCrEO5doZZ8raHeHnZjh8|vPE9mH#|l}6q$;D}XbNdJU0e>m zY7*shuF)8$(R3)Rh*|g{AC5DGQ_RAKE6gXCxK8#QEVY4)D8yr~pYZDN;mcSeUgZm! z&{LWgY*H^$wA99goj!yQ|K4~4t&Si|=Oo!abmR{PjP>Adg`uGCY9HNPbhHqW6mH#A zC$m`d@46a0P@_!w>w=6i>_iO`oiXYPRu-WXY;^Y!kxt;Xd{Uk~Q-)Y`zLHvXy(Nhkz;j0?GIyb%>D+jF<|w`Ej+szy1_wl? zAbMreDwD%o!!}4phVh0d z&2?}dpWav(Iu0b;)6X)WfsT^KGd*Kd^-gMj=H#T~pf{_b%_Mf*=u!aH0CFtQmP4;z zYff{3ww{R&+0p@8uuk!Wnai~&3{6dN;@L2brZ2)o^GC2vr7tRq3=5u%O6m_Q&ZmIu zG)l@T-OO~J4sNIL_Cv_X(SZhrjB8v>K{Ml%QzSCaF_jx$j{S1m#iHhr<&1mVfmv|n z08b-j@+Hn1i;(k;rzYr?e>2ZFmlN=P3${68G=a@zvuOJ)xeVXMpc)qMEb@U(qXtRL z(iBe|11~M|Y0ws_3HG%nrQ7WN^tJ~MX6J`b=J_nV=$=G#n67MJX0|!-CWqV|fF3+H zjk#vMPM8Lpx2scG3{#^g^Hz|N-AnV~5$dz3E$(UFv<|eaLnCEI^TWAZHVtL9U-b^aCQ?yrH3~kUfkUjQWq!fl_6G{a1+My z(uI+wiiMYvBQ++77Kyr^2V2vnB$7&@(>wsQMW#>SW)9m+;&u(zSfI%zVg`Jlv+w** z8`q&LPYhF^dhwu9oO>rhn4|tJg{GSIscs%BvR+WHv_d@{rnYydjKV!AY{_a}u6wa+ zQy?Wrwh;}lW?BE}!|epK*_q5FMScl*lx)q{$Dxzg>c+zd#gqi5s1#l)Op*)f7EMri45d12 ziP$)uVb8)>8ai)+d$x3|(b@6IMh@656g|8gk=|d&&>&6ta7~U2X$?Z~hKWmTA)p^l z>0*xndVb zj8a7{XT79>)(V9#u9A`maPJ9>g15OO=pYDWMqGRvpxLV#9x-vHy)QJTTsmb`$A(B9 z$2g|WDK`-saJy#MCOew1ON`qsH4#Rk)QXdRH8UL3q+<{ZQ=2%F!gFh#)Gt9SH+4LP zw{WJ?c*`X{f!=B6>>}TeR(L%ug_s7XBCTlEL%orLt}x<~q>0od%{g(~4BpnUZm)wk zo)DQru?fpQX_@HdHlCK^yhr4Hvl(2s#g~M+)zySE5B3!zBO`Rp6*W0aQMoC`PTNH8 z7Ag_1HS(LhCTo2vx;Wyh)rbbKdg18s)06peyhBMv^BYD=I_wFxY-+u9j7F^!5mkL+ zom?!KtWGSuiDK9%KNVo}b&wv$3h%I0jdDvzRmy7E9>j zbxy-;lq_CwMJ!a)Jv@GP>Z37vP_)&Vo=my1Ac{SBcu)4E>!!9t>md{mn~i?5Ji%_W zekn^$Bcf5WI2A@)q^$u3S-&g@6@jG_^>3^g%^cK*4VrsV)S?Bsbyh5*>`246$VvYq zThQy2>JB%T1Fu`o;JM8tEjG-hVVEZ&Qk!=$O&`EQif9O?=_6Rcp(Cf=-U1d;hSyM= zbr7tis9|}z<|f#g2~-Co50*xDDix(?26myYg^HD86l3);!k%e7$Fj&|f!5dNja3PX zHl5y0o=}?@lC0MB!il9;oi5X~X&`H*ka@7|a`ki7;^R5wJTgf>mJa8MnK^rwb}1w! z%ew)#W$>_qr#7<)lcp*hej7dADjZk*=Kb8)$Uvdm6`?Hf8rkq9#I`0E?V1nILzI^h z6KxN{Vq@5sLf4S>sMR+~vvaKARmr?CRh-^uZ6>Tj;H-9bqgainVl{_XL+$RFY@T7; zwP?l=y9uE3H59>XK6iDY*)+H)Ki;I~TL#q*gsyF40eHsA8+UdYZany+W!O%JojbbP z&zZ7OcwfZscwn|?9>}T;JQ1#&=11cQb==+kqcmSc12d+Q4fjoQu)PzPOY(Z&XO>pO z5|cVEMg!~w(EGLFoq%W@Qy!kzsci(aEVi8i3rqWe(hm2H%OGrFqxIdju1EMTZo1gD zQ&wlMCKmHggHJzNd_`;n)qbnV$*p_eIxba#yNx zLHw9cF7c)mQ#`0vj{3QQ`ZRw0=YDRWt{8Q*o0!1e4o*q+-1V2fb6Ge&VfDy{uYu-d zY-5X-a$a0+bd&NV%{|fK3!H7a{3`?Yi@R*!5!5dlIGVk!-x1tveCAgKEIoAZyeEc# zP5|@-z0csEBJ>RL<(EN|EBwJs_hS0@u0g7evjjffoRpiwe^DvA`!$b3sBPDRzv!cWX2Iy*I zWThVifR)TE=aduAtU@{Y6sLW&+;UP-Vmso^mR7$j;8>bnXKoYaf;_q-C3Ne&PY?YJ z2FMf(an2RbvYK8>&m8dC*LO=lbE84(e~G}91M@WgMhTL*=HZ`Gaa25zZt}woD%n5S zqq>l$_KZ{A?e{8A^Iu`{4D>L(S;sQBF@}GF0J)6Qm_)w3%UpbK+> zLUCG#ZcGmUfRNE4)NOJ9xi}v`;t&0FiD3`*-dJDUTwoqF{*DFMsV5nJ%*@o<51Jk@n`d#8{%Y;B~g602bF`%J@6X@?x!3?I4VuT`8)v~eGxLIEHp77 z0p_TI(KPgqj2prwA9R3Y_y&kk>*K5jDi{7G6jOzeuV9!pyylXw#-9P<<*q8xRJ=4xFDFs*)A$EXwXP3|Hb&RhRTgw2M__?!L?k4uLc z8h>KKrTSNx%+VJZr#5I*ZG>Oz#MeNH;yGd z#jw*qODvglD!y+P%H|g@a^||! foDm`|h{=pVblQTxt(O+e7)r&2IxYJmBHjN774RIn literal 0 HcmV?d00001 diff --git a/emitBranch_6502.c b/emitBranch_6502.c new file mode 100644 index 0000000..04c656b --- /dev/null +++ b/emitBranch_6502.c @@ -0,0 +1,157 @@ +/* + emitBranch_6502.c -- Routines to deal with code generation for + branches and jumps in the Macross assembler (6502 + version). + + Chip Morningstar -- Lucasfilm Ltd. + + 23-April-1985 + +*/ + +#include "macrossTypes.h" +#include "macrossGlobals.h" + +/* emitRelativeBranch emits a relative branch instruction for the 6502, + branching from the current location given a condition to branch upon and a + target address. */ + + void +emitRelativeBranch(condition, target, fixupLocation) + conditionType condition; + valueType *target; + valueType fixupLocation[COMPOUND_BRANCH_MAX]; +{ + int i; + +#define COMPOUND 0x00 +#define BPL_OPCODE 0x10 +#define BMI_OPCODE 0x30 +#define BVC_OPCODE 0x50 +#define BVS_OPCODE 0x70 +#define BCC_OPCODE 0x90 +#define BCS_OPCODE 0xB0 +#define BNE_OPCODE 0xD0 +#define NOP_OPCODE 0xEA +#define BEQ_OPCODE 0xF0 + + static byte conditionalBranchOpcodes[] = { + /* CARRY_COND */ BCS_OPCODE, + /* ZERO_COND */ BEQ_OPCODE, + /* NEGATIVE_COND */ BMI_OPCODE, + /* OVERFLOW_COND */ BVS_OPCODE, + /* LT_COND */ BCC_OPCODE, + /* LEQ_COND */ COMPOUND, + /* SLT_COND */ COMPOUND, + /* SLEQ_COND */ COMPOUND, + /* ALWAYS_COND */ NOP_OPCODE, + /* NOT_CARRY_COND */ BCC_OPCODE, + /* NOT_ZERO_COND */ BNE_OPCODE, + /* NOT_NEGATIVE_COND */ BPL_OPCODE, + /* NOT_OVERFLOW_COND */ BVC_OPCODE, + /* GEQ_COND */ BCS_OPCODE, + /* GT_COND */ COMPOUND, + /* SGEQ_COND */ COMPOUND, + /* SGT_COND */ COMPOUND, + /* NEVER_COND */ NOP_OPCODE + }; + +#define conditionalFixup(n) if (fixupLocation != NULL) \ + fixupLocation[n] = currentLocationCounter; \ + emitRelativeByteOffset(target); + + if (fixupLocation != NULL) + for (i=0; ikindOfValue != ABSOLUTE_VALUE) + noteAnonymousReference(); + emitWordValue(target); + } + } + return(result); +} + diff --git a/emitBranch_68000.c b/emitBranch_68000.c new file mode 100644 index 0000000..21e11c6 --- /dev/null +++ b/emitBranch_68000.c @@ -0,0 +1,116 @@ +/* + emitBranch_68000.c -- Routines to deal with code generation for + branches and jumps in the Macross assembler (68000 + version). + + Chip Morningstar -- Lucasfilm Ltd. + + 29-April-1985 + +*/ + +#include "macrossTypes.h" +#include "macrossGlobals.h" + +/* emitRelativeBranch emits a relative branch instruction for the 68000, + branching from the current location given a condition to branch upon and a + target address. */ + + void +emitRelativeBranch(condition, target, fixupLocation) + conditionType condition; + valueType *target; + valueType *fixupLocation; +{ + int i; + +#define BCS_OPCODE 0x65 +#define BCC_OPCODE 0x64 +#define BEQ_OPCODE 0x67 +#define BGE_OPCODE 0x6C +#define BGT_OPCODE 0x6E +#define BHI_OPCODE 0x62 +#define BLE_OPCODE 0x6F +#define BLS_OPCODE 0x63 +#define BLT_OPCODE 0x6D +#define BMI_OPCODE 0x6B +#define BNE_OPCODE 0x66 +#define BPL_OPCODE 0x6A +#define BVC_OPCODE 0x68 +#define BVS_OPCODE 0x69 +#define BRA_OPCODE 0x60 + + static byte conditionalBranchOpcodes[] = { + /* CARRY_COND */ BCS_OPCODE, + /* EQUAL_COND */ BEQ_OPCODE, + /* OVERFLOW_COND */ BVS_OPCODE, + /* MINUS_COND */ BMI_OPCODE, + /* LT_COND */ BLT_OPCODE, + /* LEQ_COND */ BLE_OPCODE, + /* LOW_OR_SAME */ BLS_OPCODE, + /* ALWAYS_COND */ BRA_OPCODE, + /* NOT_CARRY_COND */ BCC_OPCODE, + /* NOT_EQUAL_COND */ BNE_OPCODE, + /* NOT_OVERFLOW_COND */ BVC_OPCODE, + /* PLUS_COND */ BPL_OPCODE, + /* GEQ_COND */ BGE_OPCODE, + /* GT_COND */ BGT_OPCODE, + /* HIGH_COND */ BHI_OPCODE, + /* NEVER_COND */ 0, + }; + + if (fixupLocation != NULL) + fixupLocation->value = -1; + if (condition == NEVER_COND) + return; + emitByte(conditionalBranchOpcodes[(int)condition]); + if (isByteOffset(target - (currentLocationCounter.value + 1))) { + if (fixupLocation != NULL) + *fixupLocation = currentLocationCounter; + emitRelativeByteOffset(target); + } else { + emitByte(0); + if (fixupLocation != NULL) + *fixupLocation = currentLocationCounter; + emitRelativeWordOffset(target); + } +} + + +/* emitJump emits a 68000 jump instruction given the target address */ + + simpleFixupListType * +emitJump(target, previousFixups) + valueType *target; + simpleFixupListType *previousFixups; +{ + simpleFixupListType *result; + + simpleFixupListType *buildSimpleFixupList(); + +#define JUMP_OPCODE_WORD 0x4EF8 +#define JUMP_OPCODE_LONG 0x4EF9 +#define JUMP_OPCODE_PC_REL 0x4EFA + + result = previousFixups; + if (target == NULL) { + emitWord(JUMP_OPCODE_LONG); + result = buildSimpleFixupList(currentLocationCounter, result); + emitWord(0); + } else if (target->kindOfValue != ABSOLUTE_VALUE) { + emitWord(JUMP_OPCODE_LONG); + noteAnonymousReference(); + emitLongValue(target); + } else if (isWordOffset(target->value-currentLocationCounter.value)) { + emitWord(JUMP_OPCODE_PC_REL); + emitWord(target->value - currentLocationCounter.value); + } else if (isWord(target)) { + emitWord(JUMP_OPCODE_WORD); + emitWord(target); + } else { + emitWord(JUMP_OPCODE_LONG); + emitLong(target); + } + return(result); +} + diff --git a/emitStuff.c b/emitStuff.c new file mode 100644 index 0000000..c97ed27 --- /dev/null +++ b/emitStuff.c @@ -0,0 +1,560 @@ +/* + emitStuff.c -- Routines to actually generate binary stuff for the + Macross assembler. + + Chip Morningstar -- Lucasfilm Ltd. + + 14-November-1984 +*/ + +#include "macrossTypes.h" +#include "macrossGlobals.h" + +/* + Emitted code is stored in places that are allocated dynamically as they + are needed. This saves us from having to keep umpteenK of code buffer + around ALL the time and also lets us keep track of where code has actually + been put for purposes of generating the final object module. + + The structure of the code storage is: there are two code region structs + (type 'codeRegionType'), one each for absolute and relocatable code. These + are stored in the global array 'codeRegions' which is indexed by + 'currentCodeMode' which in turn indicates whether we are emitting aboslute + or relocatable code. Each of these region structs contains a vector of + [currently 64] pointers to code segment structs (type 'codeSegmentType'). + Each code segment represents a [currently 1Kbyte] piece of the target + processor address space; it contains the high and low addresses within + that space that have been occupied up until now and a pointer to a + [1Kbyte] buffer that actually contains the code. + + Initially, the code regions are filled with vectors of null pointers and + there are no code segments allocated. As code is emitted, the space for + the code segments and their associated buffers is allocated using 'malloc'. + Only the actual buffers needed are allocated, resulting in substantial + storage savings. + + A complication that can arise from Macross 'struct's. Structs are + assembled in a small scratch buffer and then transferred to the main code + buffers as needed. + */ + + +/* incarnateCodeBuffer causes code buffer space to actually be allocated */ + + void +incarnateCodeBuffer(bufferNum, bufferKind) + int bufferNum; + codeBufferKindType bufferKind; +{ + codeSegmentType *newCodeSegment; + codeBufferType *newCodeBuffer; + int i; + + newCodeSegment = typeAlloc(codeSegmentType); + newCodeBuffer = typeAlloc(codeBufferType); + for (i=0; icodeStartAddress = 0xFFFF + 1; + newCodeSegment->codeEndAddress = -1; + newCodeSegment->codeBuffer = newCodeBuffer; + codeRegions[(int)bufferKind]->codeSegments[bufferNum] = + newCodeSegment; +} + + +/* putByte actually puts a byte in code storage somewhere, given the address + and the byte itself. It tracks down the appropriate code buffer, taking + care to make sure said buffer actually exists before using it. */ + + void +putByte(address, byteValue) + addressType address; + byte byteValue; +{ + int bufferNum; + int bufferPos; + codeBufferType *theBuffer; + codeSegmentType *theSegment; + + bufferNum = bufferNumber(address); + bufferPos = bufferPosition(address); + if (bufferNum >= CODE_BUFFERS_IN_ADDRESS_SPACE) { + fatalError(ADDRESS_OUTSIDE_ADDRESS_SPACE_ERROR, address); + return; + } + theSegment = codeRegions[(int)currentCodeMode]->codeSegments[ + bufferNum]; + if (theSegment == NULL) { + incarnateCodeBuffer(bufferNum, currentCodeMode); + theSegment = codeRegions[(int)currentCodeMode]->codeSegments[ + bufferNum]; + } + theBuffer = theSegment->codeBuffer; + if (currentCodeMode == RELOCATABLE_BUFFER && address > + relocatableHighWaterMark) + relocatableHighWaterMark = address; + if (address > theSegment->codeEndAddress) + theSegment->codeEndAddress = address; + if (address < theSegment->codeStartAddress) + theSegment->codeStartAddress = address; + if (address > codeRegions[(int)currentCodeMode]->regionEndAddress) + codeRegions[(int)currentCodeMode]->regionEndAddress = address; + if (address < codeRegions[(int)currentCodeMode]->regionStartAddress) + codeRegions[(int)currentCodeMode]->regionStartAddress = + address; + (*theBuffer)[bufferPos] = byteValue; +} + + +/* mapByte is like 'putByte', but places its values in the struct assembly + buffer */ + + void +mapByte(address, byteValue) + int address; + byte byteValue; +{ + if (address < MAXIMUM_ALLOWED_STRUCT_SIZE) + structScratchBuffer[address] = byteValue; +} + + +/* emitByte outputs one byte at the current location in either the current + code buffer or the current struct assembly buffer */ + + void +emitByte(byteValue) + byte byteValue; +{ + if (debug || emitPrint) + if (structNestingDepth == 0) + printf("emitByte(%x: %x)\n", currentLocationCounter. + value, byteValue); + else + printf("emitByte in struct (%x: %x)\n", + currentFieldOffset, byteValue); + if (structNestingDepth == 0) { + putByte(currentLocationCounter.value++, byteValue); + } else { + mapByte(currentFieldOffset++, byteValue); + } +} + + +/* emitWord similarly emits a word */ + + void +emitWord(wordValue) + wordType wordValue; +{ + byteToWordType convert; + int loByte, hiByte; + +/* We hack around with this, even though it's less portable, so that we can + avoid doing a division and a modulo on every word we emit (since code + emission is in the inner loop). */ + +#ifdef BYTESWAPPED + loByte = 1; + hiByte = 0; +#else + loByte = 0; + hiByte = 1; +#endif + convert.wordPart = wordValue; + if (debug || emitPrint) + if (structNestingDepth == 0) + printf("emitWord(%x: %x)\n", currentLocationCounter. + value, wordValue); + else + printf("emitWord in struct (%x: %x)\n", + currentFieldOffset, wordValue); + if (structNestingDepth == 0) { +#if TARGET_CPU == CPU_6502 + putByte(currentLocationCounter.value++, + convert.bytePart[loByte]); + putByte(currentLocationCounter.value++, + convert.bytePart[hiByte]); +#else if TARGET_CPU == CPU_68000 + putByte(currentLocationCounter.value++, + convert.bytePart[hiByte]); + putByte(currentLocationCounter.value++, + convert.bytePart[loByte]); +#endif + } else { +#if TARGET_CPU == CPU_6502 + mapByte(currentFieldOffset++, convert.bytePart[loByte]); + mapByte(currentFieldOffset++, convert.bytePart[hiByte]); +#else if TARGET_CPU == CPU_68000 + mapByte(currentFieldOffset++, convert.bytePart[hiByte]); + mapByte(currentFieldOffset++, convert.bytePart[loByte]); +#endif + } +} + +/* emitLong similarly emits a long */ + + void +emitLong(longValue) + longType longValue; +{ + byteToLongType convert; + int loByte, secondByte, thirdByte, hiByte; + +/* We hack around with this, even though it's less portable, so that we can + avoid doing a division and a modulo on every long we emit (since code + emission is in the inner loop). */ + +#ifdef BYTESWAPPED + /* Sun workstation... */ + loByte = 3; + secondByte = 2; + thirdByte = 1; + hiByte = 0; +#else + /* Vax... */ + loByte = 0; + secondByte = 1; + thirdByte = 2; + hiByte = 3; +#endif + convert.longPart = longValue; + if (debug || emitPrint) + if (structNestingDepth == 0) + printf("emitLong(%x: %x)\n", currentLocationCounter. + value, longValue); + else + printf("emitLong in struct (%x: %x)\n", + currentFieldOffset, longValue); + if (structNestingDepth == 0) { +#if TARGET_CPU == CPU_6502 + putByte(currentLocationCounter.value++, + convert.bytePart[loByte]); + putByte(currentLocationCounter.value++, + convert.bytePart[secondByte]); + putByte(currentLocationCounter.value++, + convert.bytePart[thirdByte]); + putByte(currentLocationCounter.value++, + convert.bytePart[hiByte]); +#else if TARGET_CPU == CPU_68000 + putByte(currentLocationCounter.value++, + convert.bytePart[hiByte]); + putByte(currentLocationCounter.value++, + convert.bytePart[thirdByte]); + putByte(currentLocationCounter.value++, + convert.bytePart[secondByte]); + putByte(currentLocationCounter.value++, + convert.bytePart[loByte]); +#endif + } else { +#if TARGET_CPU == CPU_6502 + mapByte(currentFieldOffset++, convert.bytePart[loByte]); + mapByte(currentFieldOffset++, convert.bytePart[secondByte]); + mapByte(currentFieldOffset++, convert.bytePart[thirdByte]); + mapByte(currentFieldOffset++, convert.bytePart[hiByte]); +#else if TARGET_CPU == CPU_68000 + mapByte(currentFieldOffset++, convert.bytePart[hiByte]); + mapByte(currentFieldOffset++, convert.bytePart[thirdByte]); + mapByte(currentFieldOffset++, convert.bytePart[secondByte]); + mapByte(currentFieldOffset++, convert.bytePart[loByte]); +#endif + } +} + + +/* emitByteValue takes the byte to be emitted out of a 'valueType' */ + + void +emitByteValue(byteValue) + valueType *byteValue; +{ + if (byteValue->kindOfValue == ABSOLUTE_VALUE || byteValue->kindOfValue == + RELOCATABLE_VALUE || byteValue->kindOfValue == UNDEFINED_VALUE) { + if (byteCheck(byteValue->value) && byteValue->kindOfValue!=FAIL) { + if (debug || emitPrint) { + if (structNestingDepth == 0) + printf("emitByteValue(%x: ",currentLocationCounter.value); + else + printf("emitByteValue in struct (%x:",currentFieldOffset); + printValue(byteValue); + printf(")\n"); + } + emitByte(byteValue->value); + } + } else { + if (byteValue->kindOfValue != FAIL) + error(NON_ADDRESS_BYTE_VALUE_ERROR, valueKindString(byteValue-> + kindOfValue)); + } +} + + +/* emitString similarly spits out a string of bytes */ + + void +emitString(string) + stringType *string; +{ + if (debug || emitPrint) + if (structNestingDepth == 0) + printf("emitString(%x: \"%s\")\n", + currentLocationCounter.value, string); + else + printf("emitString in struct(%x: \"%s\")\n", + currentFieldOffset, string); +/* Horrible terrible no good very bad cretinous ugly hack, but no graceful + way to avoid it: a 0xFF byte in the string means output a 0x00 byte in + the object. This is so we can embed nuls in strings without embedding + nuls in strings, so to speak. We assume that the character 0xFF is not + likely to be needed since ASCII (and ATASCII) is a seven bit character + code. */ + while (*string != NULL) + if ((*string & 0xFF) == 0xFF) { + emitByte('\0'); + string++; + } else { + emitByte(*string++); + } +} + + +/* emitWordValue emits a word out of a 'valueType' */ + + void +emitWordValue(wordValue) + valueType *wordValue; +{ + if (wordValue->kindOfValue == ABSOLUTE_VALUE || wordValue->kindOfValue == + RELOCATABLE_VALUE || wordValue->kindOfValue == UNDEFINED_VALUE) { + if (wordCheck(wordValue->value) && wordValue->kindOfValue!=FAIL) { + if (debug || emitPrint) { + if (structNestingDepth == 0) + printf("emitWordValue(%x: ",currentLocationCounter.value); + else + printf("emitWordValue in struct (%x:",currentFieldOffset); + printValue(wordValue); + printf(")\n"); + } + emitWord(wordValue->value); + } + } else { + if (wordValue->kindOfValue != FAIL) + error(NON_ADDRESS_WORD_VALUE_ERROR, valueKindString(wordValue-> + kindOfValue)); + } +} + + +/* emitLongValue emits a long out of a 'valueType' */ + + void +emitLongValue(longValue) + valueType *longValue; +{ + if (longValue->kindOfValue == ABSOLUTE_VALUE || longValue->kindOfValue == + RELOCATABLE_VALUE || longValue->kindOfValue == UNDEFINED_VALUE) { + if (longValue->kindOfValue != FAIL) { + if (debug || emitPrint) { + if (structNestingDepth == 0) + printf("emitLongValue(%x: ",currentLocationCounter.value); + else + printf("emitLongValue in struct (%x:",currentFieldOffset); + printValue(longValue); + printf(")\n"); + } + emitLong(longValue->value); + } + } else { + if (longValue->kindOfValue != FAIL) + error(NON_ADDRESS_LONG_VALUE_ERROR, valueKindString(longValue-> + kindOfValue)); + } +} + + +/* pokeByteValue is like 'emitByte' but it's random access */ + + void +pokeByteValue(location, value) + addressType location; + valueType *value; +{ + currentLocationCounter.value = location; + emitByteValue(value); +} + + +/* ditto pokeWordValue */ + + void +pokeWordValue(location, value) + addressType location; + valueType *value; +{ + currentLocationCounter.value = location; + emitWordValue(value); +} + + +/* ditto pokeLongValue */ + + void +pokeLongValue(location, value) + addressType location; + valueType *value; +{ + currentLocationCounter.value = location; + emitLongValue(value); +} + + +/* ditto pokeRelativeByteValue. This is a special case used in fixing up + relative branches */ + + void +pokeRelativeByteValue(location, value) + addressType location; + valueType *value; +{ + int offset; + + currentLocationCounter.value = location; + offset = value->value - (location - targetOffset) - 1; + if (offset < 0) + offset--; +/* if (currentCodeMode == RELOCATABLE_BUFFER) + offset = 0;*/ + if (isByteOffset(offset)) { + emitByte(offset); + } else { + error(RELATIVE_OFFSET_TOO_LARGE_ERROR); + } +} + +/* ditto pokeRelativeWordValue. This is a special case used in fixing up + relative branches */ + + void +pokeRelativeWordValue(location, value) + addressType location; + valueType *value; +{ + int offset; + + currentLocationCounter.value = location; + offset = value->value - (location - targetOffset); + if (isWordOffset(offset)) { + emitWord(offset); + } else { + error(RELATIVE_OFFSET_TOO_LARGE_ERROR); + } +} + + +/* getByte fetches a byte back out of the labyrinth of code buffers */ + + byte +getByte(address) + addressType address; +{ + int bufferNum; + int bufferPos; + codeBufferType *theBuffer; + codeSegmentType *theSegment; + + bufferNum = bufferNumber(address); + bufferPos = bufferPosition(address); + theSegment = codeRegions[(int)currentCodeMode]->codeSegments[ + bufferNum]; + if (theSegment == NULL) + return(0); + else + return((*(theSegment->codeBuffer))[bufferPos]); +} + + void +emitRelativeByteOffset(target) + valueType *target; +{ + int saveTargetOffset; + + if (target == NULL) { + emitByte(0); + } else { + (target->value)++; + saveTargetOffset = targetOffset; + targetOffset = 0; + pokeRelativeByteValue(currentLocationCounter.value, target); + targetOffset = saveTargetOffset; + (target->value)--; + } +} + + void +emitRelativeWordOffset(target) + valueType *target; +{ + int saveTargetOffset; + + if (target == NULL) { + emitWord(0); + } else { + saveTargetOffset = targetOffset; + targetOffset = 0; + pokeRelativeWordValue(currentLocationCounter.value, target); + targetOffset = saveTargetOffset; + } +} + +/* fixupBranch repairs a previously undefined branch once the branch address + has become known. */ + + void +fixupBranch(location, target) + valueType location[COMPOUND_BRANCH_MAX]; + valueType target; +{ + valueType saveCurrentLocation; + int saveTargetOffset; + int i; + + saveCurrentLocation = currentLocationCounter; + saveTargetOffset = targetOffset; + targetOffset = 0; + for (i=0; i= 0) + pokeRelativeByteValue(location[i].value, &target); + } + targetOffset = saveTargetOffset; + currentLocationCounter = saveCurrentLocation; +} + + +/* fixupJump similarly repairs a jump */ + + void +fixupJump(locations, target) + simpleFixupListType *locations; + valueType target; +{ + valueType saveCurrentLocation; + simpleFixupListType *oldLocation; + + saveCurrentLocation = currentLocationCounter; + while (locations != NULL) { + currentLocationCounter = locations->locationToFixup; + noteAnonymousReference(); + target.value -= targetOffset; + if (positionIndependentCodeMode) + pokeRelativeByteValue(locations->locationToFixup. + value, &target); + else + pokeWordValue(locations->locationToFixup.value, + &target); + target.value += targetOffset; + oldLocation = locations; + locations = locations->nextFixup; + free(oldLocation); + } + currentLocationCounter = saveCurrentLocation; +} diff --git a/emitStuff.o b/emitStuff.o new file mode 100644 index 0000000000000000000000000000000000000000..12dad7116416d96c08dc8309a98c9c98fcd4dd95 GIT binary patch literal 47786 zcmd^o4RqXBb?0C5$d+w6mQB6@LzKjc?PP*AqtSOlBugVpu`CIF#5Q%S&yh8;q){|d zV(&r`ltQ|M;?h7<2%v^Q1Eg#y*)HW{ZQArSZ8@!RO`6T7R0NX-YO_E5Y>^ZBGcz$!=efQmW-+lLe{NMXe(Tbu~L9p@BASfCN`0vK!=5yUi`do4Q zg$wTpMvr{t+Y3c!wk)>(>z2j#BjpukO-L)k|Hro+J%6NpbD+MTJGSNM+2gB@o?Uo& zb8zKCu!i_ftU7w`BxuKOYFhI&K0jEzRP;3X%8y=nnbMzGb@cpegP`fz>x1B%z>DR# zUs$?+De^qB%POy!I{_I@$VcD7KTV$-@c;4R zir{x|swln!_<@a!!PCV}YaT3KDt#6*K6dj^@zRQ5{nD1BXHefWD1XDogP^2mVz_T>0eh?M9zY?@X3W&Tb`FeKL^^m8KbnEm%#VZ z4U3T&@}F5*5m38V13z))V({|Hrq`TXc`Wz|$@;^lP1g68v;Q;Td*-@h0ovd!eD2)R z`o&#KH#e;h`Oh)u`__LRuDD?RgX-(r6#1Wqe~0ofa{ld$JFOn%f3QFMmu*|nRu?Y> zSCQ>W-pS&{fc((5)5-OVJ1sBCIkK@LXu>D)!_QXJ=f!xgLi*FiX!|3d3axI$B#;pMl2?{_uA$4{)aH{MfCm} z@rHcH#HTHbtu!{CC=RGiC>E6wFSYB___FZuQZYW*M<{MSy8?V4AENkFM|_kQV_c*O zn7%_sDfqV&rWkp$xCt^A*MoKw(QG^+KFBB(3pW+uCWYoO^)M>&HMiHpcMVB*M48lzOSIp%f^4J?=Rcm zsLwxh$Fbl;yRyMOb2dlW5N3thjtVkokB{jsu#H&+xrkMSO3-Ffu=jdpJS0=|E8^HR|ZNTYRzwTHxRj>$xS z+l8NXiH&(qkGSx9%Ny$7zm$Gh_gt#{$yZqZkHM$|rK8`VDIa}Jg z*m2Ut<@4VaoA8)HJSQ;zzQ1^==)`pu5j(%eobNpO#j)#_+?Y#a9p?9JQ(1Qh&s;x* zbvMR>6-$vt_zSJQe=&W2#&toRIF{M5j@H%Ge~w)@6fS>`^vC*;^*aguLgo3n?3Tqc zlJWkHLs%CzVI4CRIeA?L@KEW~s4H-(ZKG$<1~i8~cKuL5b6v~@PcM9YX$Ab?byObw z`SkB#9ZqBR@7^?2bfh>~O?~Hs#S5j+6fZ^4c4aGNeS~%4=?`OV{?YPa-N$ZTD*6!C zs!QN~I1;Qo9vO;2#;ajR9!KE^ryq$d7Ga%z8haYwrn1n#&TOO48!CcNqYk$KKX%1p z@KQ-raHeD^f^{tLQ0W=0XMw}*@Ah1dyn_1EoQ!nGxE`mn$^NuPv~#aQHfsV8@mkwG zyK*SqUZdO$@6)t`*Ez*O}&5q9OXrObDVgd)2vN?{v}Gg0so(hECw$? z?k6M1HogG4wBKO*$ztp2lA*HGTObp5Y636IJ9^=7>GQLwa}1x4Us(~HEjbpvT(T57 zdn4hc(wA?(Qd8-<9f#*qTW>hjP;tYdZEGB*B0XJ^otvE>ovX-A+>@Cd z%cm^M-kF&`kjqY#W!XuYJBKIdjYduzCWSHuqHW*YY+A~=?uP7jIaHs8bx`S4jZi_3 z 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 Y7ed*hI1ajRmn=9lIc8VPqzVc8KYvtJx&QzG literal 0 HcmV?d00001 diff --git a/encode.c b/encode.c new file mode 100644 index 0000000..1e0dffb --- /dev/null +++ b/encode.c @@ -0,0 +1,674 @@ +/* WARNING: this file has not yet been separated into 6502 and non-6052 parts */ +/* + encode.c -- Routines to encode expressions for Macross object files. + + Chip Morningstar -- Lucasfilm Ltd. + + 8-November-1985 +*/ + +#include "macrossTypes.h" +#include "macrossGlobals.h" +#include "y.tab.h" +#include "slinkyExpressions.h" + +#define nullEncode(thing) if (thing==NULL) return(TRUE); +#define byteOp(op) ((op)-256) + +bool encodingFunction; + + bool +encodeByte(aByte) + byte aByte; +{ + if (expressionBufferSize < EXPRESSION_BUFFER_LIMIT) { + expressionBuffer[expressionBufferSize++] = aByte; + return(TRUE); + } else { + error(EXPRESSION_TOO_BIG_TO_FIT_IN_OBJECT_ERROR); + return(FALSE); + } +} + + bool +encodeBigword(bigword) + int bigword; +{ + int i; + for (i=0; i>= 8; + } + return(TRUE); +} + + bool +encodeAssignmentTerm(assignmentTerm, kindOfFixup) + binopTermType *assignmentTerm; + fixupKindType kindOfFixup; +{ + nullEncode(assignmentTerm); + if ((assignmentKindType)assignmentTerm->binop != ASSIGN_ASSIGN) { + error(FUNNY_ASSIGNMENT_KIND_IN_OBJECT_EXPRESSION_ERROR); + return(FALSE); + } + return( + encodeByte(BINOP_TAG) && + encodeByte(byteOp(ASSIGN)) && + encodeIdentifier(assignmentTerm->leftArgument) && + encodeExpression(assignmentTerm->rightArgument) + ); +} + + bool +encodeBinopTerm(binopTerm, isTopLevel, kindOfFixup) + binopTermType *binopTerm; + bool isTopLevel; + fixupKindType kindOfFixup; +{ + bool encodeExpression(); + + nullEncode(binopTerm); + return ( + encodeByte(BINOP_TAG) && + encodeByte(byteOp(binopTerm->binop)) && + encodeExpression(binopTerm->leftArgument) && + encodeExpression(binopTerm->rightArgument) + ); +} + + bool +encodeCondition(condition) + conditionType condition; +{ + return( + encodeByte(CONDITION_CODE_TAG) && + encodeByte(condition) + ); +} + + int +functionNumber(function) + functionDefinitionType *function; +{ + if (function->ordinal == -1) { + function->ordinal = externalFunctionCount++; + if (externalFunctionList == NULL) { + externalFunctionList = endOfExternalFunctionList = + function; + } else { + endOfExternalFunctionList->nextExternalFunction = + function; + endOfExternalFunctionList = function; + } + } + return(function->ordinal); +} + + bool +encodeFunctionCall(functionCall) + functionCallTermType *functionCall; +{ + functionDefinitionType *theFunction; + int functionOrdinal; + symbolInContextType *workingContext; + operandListType *parameterList; + + symbolInContextType *getWorkingContext(); + + nullEncode(functionCall); + workingContext = getWorkingContext(functionCall->functionName); + if (isFunction(workingContext)) { + if (!encodeByte(FUNCTION_CALL_TAG)) + return(FALSE); + theFunction = (functionDefinitionType *)workingContext-> + value->value; + if (!encodeBigword(functionNumber(theFunction))) + return(FALSE); + } else if (isBuiltInFunction(workingContext)) { + functionOrdinal = workingContext->value->value; + if (builtInFunctionTable[functionOrdinal].isSpecialFunction) + return(encodeValue((*builtInFunctionTable[ + functionOrdinal].functionEntry)(functionCall-> + parameters, NO_FIXUP))); + if (!encodeByte(BUILTIN_FUNCTION_CALL_TAG)) + return(FALSE); + if (builtInFunctionTable[functionOrdinal].ordinal < 0) { + error(BUILT_IN_FUNCTION_NOT_AVAILABLE_IN_OBJECT_ERROR, + builtInFunctionTable[functionOrdinal]. + functionName); + return(FALSE); + } else if (!encodeBigword(builtInFunctionTable[ + functionOrdinal].ordinal)) { + return(FALSE); + } + } else { + error(NOT_A_FUNCTION_ERROR, symbName(functionCall-> + functionName)); + return(FALSE); + } + parameterList = functionCall->parameters; + if (!encodeByte(countParameters(parameterList))) + return(FALSE); + while (parameterList != NULL) + if (!encodeOperand(parameterList)) + return(FALSE); + else + parameterList = parameterList->nextOperand; + return(TRUE); +} + + bool +encodeHere() +{ + return(encodeByte(HERE_TAG)); +} + + bool +encodeIdentifier(identifier) + symbolTableEntryType *identifier; +{ + symbolInContextType *workingContext; + environmentType *saveEnvironment; + bool result; + + nullEncode(identifier); + + if (symbName(identifier)[0] == '$') { + error(TEMP_SYMBOL_IN_OBJECT_ERROR, symbName(identifier)); + return(FALSE); + } + if (encodingFunction) { + return(encodeByte(IDENTIFIER_TAG) && + encodeBigword(identifier->ordinal)); + } + if ((workingContext = getWorkingContext(identifier)) == NULL) { + error(UNDEFINED_SYMBOL_ERROR, symbName(identifier)); + return(FALSE); + } + if (workingContext->usage == FUNCTION_SYMBOL || workingContext->usage + == BUILT_IN_FUNCTION_SYMBOL) { + error(FUNCTION_IS_NOT_A_VALUE_ERROR, symbName(identifier)); + return(FALSE); + } + if (workingContext->value == NULL) { + error(UNDEFINED_SYMBOL_ERROR, symbName(identifier)); + return(FALSE); + } + if (workingContext->value->kindOfValue == UNDEFINED_VALUE) { + if (workingContext->attributes & GLOBAL_ATT) { + return(encodeByte(IDENTIFIER_TAG) && + encodeBigword(identifier->ordinal)); + } else { + error(UNDEFINED_SYMBOL_ERROR, symbName(identifier)); + return(FALSE); + } + } + if (workingContext->value->kindOfValue == RELOCATABLE_VALUE) { + return(encodeByte(IDENTIFIER_TAG) && + encodeBigword(identifier->ordinal)); + } + if (workingContext->value->kindOfValue == FAIL) { + error(UNASSIGNED_SYMBOL_ERROR, symbName(identifier)); + return(FALSE); + } + if (workingContext->value->kindOfValue == OPERAND_VALUE) { + saveEnvironment = currentEnvironment; + if (workingContext->usage == ARGUMENT_SYMBOL) { + currentEnvironment = currentEnvironment-> + previousEnvironment; + } + result = encodeOperand(workingContext->value->value); + currentEnvironment = saveEnvironment; + return(result); + } + if (workingContext->value->kindOfValue == BLOCK_VALUE) { + error(BLOCK_OPERAND_IN_OBJECT_EXPRESSION_ERROR); + return(FALSE); + } + return(encodeValue(workingContext->value)); +} + + bool +encodeNumber(number) + numberTermType number; +{ + return( + encodeByte(NUMBER_TAG) && + encodeBigword(number) + ); +} + + bool +encodeRelocatableNumber(number) + numberTermType number; +{ + return( + encodeByte(RELOCATABLE_TAG) && + encodeBigword(number) + ); +} + + bool +encodeOperand(operand) + operandType *operand; +{ + switch (operand->kindOfOperand) { + case EXPRESSION_OPND: + case IMMEDIATE_OPND: + case INDIRECT_OPND: + case POST_INDEXED_Y_OPND: + case PRE_INDEXED_X_OPND: + case X_INDEXED_OPND: + case Y_INDEXED_OPND: + return(encodeExpression(operand->theOperand)); + + case A_REGISTER_OPND: + case X_REGISTER_OPND: + case Y_REGISTER_OPND: + error(REGISTER_OPERAND_IN_OBJECT_EXPRESSION_ERROR); + return(FALSE); + + case X_SELECTED_OPND: + case Y_SELECTED_OPND: + case PRE_SELECTED_X_OPND: + error(SELECTION_OPERAND_IN_OBJECT_EXPRESSION_ERROR); + return(FALSE); + + case STRING_OPND: + return(encodeString(operand->theOperand)); + + case BLOCK_OPND: + error(BLOCK_OPERAND_IN_OBJECT_EXPRESSION_ERROR); + return(FALSE); + } +} + + bool +encodePostopTerm(postopTerm) + postOpTermType *postopTerm; +{ + nullEncode(postopTerm); + return( + encodeByte(POSTOP_TAG) && + encodeByte(byteOp(postopTerm->postOp)) && + encodeExpression(postopTerm->postOpArgument) + ); +} + + bool +encodePreopTerm(preopTerm) + preOpTermType *preopTerm; +{ + nullEncode(preopTerm); + return( + encodeByte(PREOP_TAG) && + encodeByte(byteOp(preopTerm->preOp)) && + encodeExpression(preopTerm->preOpArgument) + ); +} + + bool +encodeString(string) + stringType *string; +{ + if (!encodeByte(STRING_TAG)) + return(FALSE); + while (*string != '\0') { + if (!encodeByte(*string++)) + return(FALSE); + } + return(encodeByte('\0')); +} + + bool +encodeUnopTerm(unopTerm) + unopTermType *unopTerm; +{ + nullEncode(unopTerm); + return( + encodeByte(UNOP_TAG) && + encodeByte(byteOp(unopTerm->unop)) && + encodeExpression(unopTerm->unopArgument) + ); +} + + bool +encodeValue(value) + valueType *value; +{ + switch (value->kindOfValue) { + case ABSOLUTE_VALUE: + return(encodeNumber(value->value)); + + case RELOCATABLE_VALUE: + return(encodeRelocatableNumber(value->value)); + + case OPERAND_VALUE: + return(encodeOperand(value->value)); + + case STRING_VALUE: + return(encodeString(value->value)); + + case CONDITION_VALUE: + return(encodeCondition(value->value)); + + case DATA_VALUE: + case BSS_VALUE: + case STRUCT_VALUE: + case FIELD_VALUE: + case MACRO_VALUE: + case UNDEFINED_VALUE: + case FUNCTION_VALUE: + case BLOCK_VALUE: + case BUILT_IN_FUNCTION_VALUE: + case ARRAY_VALUE: + case FAIL: + error(WRONG_KIND_OF_VALUE_IN_OBJECT_EXPRESSION_ERROR, + valueKindString(value->kindOfValue)); + return(FALSE); + } +} + + bool +encodeExpression(expression) + expressionType *expression; +{ + nullEncode(expression); + switch (expression->kindOfTerm) { + + case ARRAY_EXPR: + error(ARRAY_TERM_IN_OBJECT_EXPRESSION_ERROR); + return(FALSE); + break; + + case ASSIGN_EXPR: + return(encodeAssignmentTerm(expression->expressionTerm)); + break; + + case BINOP_EXPR: + return(encodeBinopTerm(expression->expressionTerm)); + break; + + case CONDITION_CODE_EXPR: + return(encodeCondition(expression->expressionTerm)); + break; + + case FUNCTION_CALL_EXPR: + return(encodeFunctionCall(expression->expressionTerm)); + break; + + case HERE_EXPR: + return(encodeHere()); + break; + + case IDENTIFIER_EXPR: + return(encodeIdentifier(expression->expressionTerm)); + break; + + case NUMBER_EXPR: + return(encodeNumber(expression->expressionTerm)); + break; + + case POSTOP_EXPR: + return(encodePostopTerm(expression->expressionTerm)); + break; + + case PREOP_EXPR: + return(encodePreopTerm(expression->expressionTerm)); + break; + + case SUBEXPRESSION_EXPR: + encodeExpression(expression->expressionTerm); + break; + + case STRING_EXPR: + return(encodeString(expression->expressionTerm)); + break; + + case UNOP_EXPR: + return(encodeUnopTerm(expression->expressionTerm)); + break; + + case VALUE_EXPR: + return(encodeValue(expression->expressionTerm)); + break; + + default: + botch("encodeExpression: funny expression kind %d\n", + expression->kindOfTerm); + break; + } +} + + bool +encodeAssertStatement(assertStatement) + assertStatementBodyType *assertStatement; +{ + return( + encodeByte(ASSERT_TAG) && + encodeExpression(assertStatement->condition) && + encodeExpression(assertStatement->message) + ); +} + + bool +encodeFreturnStatement(freturnStatement) + freturnStatementBodyType *freturnStatement; +{ + return( + encodeByte(FRETURN_TAG) && + encodeExpression(freturnStatement) + ); +} + + bool +encodeMdefineStatement(mdefineStatement) + defineStatementBodyType *mdefineStatement; +{ + return( + encodeByte(MDEFINE_TAG) && + encodeIdentifier(mdefineStatement->theSymbol) && + encodeExpression(mdefineStatement->theValue) + ); +} + + bool +encodeMdoUntilStatement(mdoUntilStatement) + mdoUntilStatementBodyType *mdoUntilStatement; +{ + return( + encodeByte(MDOUNTIL_TAG) && + encodeExpression(mdoUntilStatement->mdoUntilCondition) && + encodeBlock(mdoUntilStatement->mdoUntilLoop) + ); +} + + bool +encodeMdoWhileStatement(mdoWhileStatement) + mdoWhileStatementBodyType *mdoWhileStatement; +{ + return( + encodeByte(MDOWHILE_TAG) && + encodeExpression(mdoWhileStatement->mdoWhileCondition) && + encodeBlock(mdoWhileStatement->mdoWhileLoop) + ); +} + + bool +encodeMforStatement(mforStatement) + mforStatementBodyType *mforStatement; +{ + return( + encodeByte(MFOR_TAG) && + encodeExpression(mforStatement->initExpression) && + encodeExpression(mforStatement->testExpression) && + encodeExpression(mforStatement->incrExpression) && + encodeBlock(mforStatement->forLoop) + ); +} + + bool +encodeMifStatement(mifStatement) + mifStatementBodyType *mifStatement; +{ + return( + encodeByte(MIF_TAG) && + encodeExpression(mifStatement->mifCondition) && + encodeBlock(mifStatement->mifConsequence) && + encodeBlock(mifStatement->mifContinuation) + ); +} + + bool +encodeMswitchStatement(mswitchStatement) + mswitchStatementBodyType *mswitchStatement; +{ + caseListType *caseList; + caseType *theCase; + expressionListType *tagExpressionList; + + if (!(encodeByte(MSWITCH_TAG) && encodeExpression(mswitchStatement-> + switchExpression))) + return(FALSE); + for (caseList=mswitchStatement->cases; caseList!=NULL; caseList=caseList-> + nextCase) { + theCase = caseList->theCase; + for (tagExpressionList=theCase->caseTags; tagExpressionList!=NULL; + tagExpressionList=tagExpressionList->nextExpression) { + if (!encodeExpression(tagExpressionList->theExpression)) + return(FALSE); + } + if (!encodeBlock(theCase->caseBody)) + return(FALSE); + } + return(encodeByte(END_TAG)); +} + + bool +encodeMvariableStatement(mvariableStatement) + mvariableStatementBodyType *mvariableStatement; +{ + int length; + + if ((length=expressionListLength(mvariableStatement->theValue) > 1) || + mvariableStatement->theDimension!=NULL) { + error(ARRAY_MVARIABLE_IN_OBJECT_FUNCTION_ERROR); + return(FALSE); + } + if (!(encodeByte(MVARIABLE_TAG) && encodeIdentifier(mvariableStatement-> + theSymbol))) + return(FALSE); + if (length == 1) + return(encodeExpression(mvariableStatement->theValue-> + theExpression)); + else + return(encodeExpression(NULL)); +} + + bool +encodeMwhileStatement(mwhileStatement) + mwhileStatementBodyType *mwhileStatement; +{ + return( + encodeByte(MWHILE_TAG) && + encodeExpression(mwhileStatement->mwhileCondition) && + encodeBlock(mwhileStatement->mwhileLoop) + ); +} + + bool +encodeStatement(statement) + statementType *statement; +{ + switch(statement->kindOfStatement) { + + case ALIGN_STATEMENT: + case BLOCK_STATEMENT: + case BYTE_STATEMENT: + case CONSTRAIN_STATEMENT: + case DBYTE_STATEMENT: + case DEFINE_STATEMENT: + case DO_UNTIL_STATEMENT: + case DO_WHILE_STATEMENT: + case EXTERN_STATEMENT: + case FUNCTION_STATEMENT: + case IF_STATEMENT: + case INCLUDE_STATEMENT: + case INSTRUCTION_STATEMENT: + case LONG_STATEMENT: + case MACRO_STATEMENT: + case ORG_STATEMENT: + case REL_STATEMENT: + case START_STATEMENT: + case STRING_STATEMENT: + case STRUCT_STATEMENT: + case TARGET_STATEMENT: + case UNDEFINE_STATEMENT: + case VARIABLE_STATEMENT: + case WHILE_STATEMENT: + case WORD_STATEMENT: + error(ILLEGAL_STATEMENT_IN_OBJECT_FILE_FUNCTION_ERROR, + statementKindString(statement->kindOfStatement)); + return(FALSE); + + case ASSERT_STATEMENT: + return(encodeAssertStatement(statement->statementBody)); + + case FRETURN_STATEMENT: + return(encodeFreturnStatement(statement->statementBody)); + + case GROUP_STATEMENT: + return(encodeBlock(statement->statementBody)); + + case MDEFINE_STATEMENT: + return(encodeMdefineStatement(statement->statementBody)); + + case MDO_UNTIL_STATEMENT: + return(encodeMdoUntilStatement(statement->statementBody)); + + case MDO_WHILE_STATEMENT: + return(encodeMdoWhileStatement(statement->statementBody)); + + case MFOR_STATEMENT: + return(encodeMforStatement(statement->statementBody)); + + case MIF_STATEMENT: + return(encodeMifStatement(statement->statementBody)); + + case MSWITCH_STATEMENT: + return(encodeMswitchStatement(statement->statementBody)); + + case MVARIABLE_STATEMENT: + return(encodeMvariableStatement(statement->statementBody)); + + case MWHILE_STATEMENT: + return(encodeMwhileStatement(statement->statementBody)); + + case NULL_STATEMENT: + return(TRUE); + + case PERFORM_STATEMENT: + return(encodeExpression(statement->statementBody)); + + default: + botch("encodeStatementBody doesn't know kind %d\n", + statement->kindOfStatement); + return(FALSE); + } +} + + bool +encodeBlock(block) + blockType *block; +{ + if (!encodeByte(BLOCK_TAG)) + return(FALSE); + while (block != NULL) { + if (!encodeStatement(block)) + return(FALSE); + block = block->nextStatement; + } + return(encodeByte(END_TAG)); +} diff --git a/encode.o b/encode.o new file mode 100644 index 0000000000000000000000000000000000000000..7310f715dfefae8648a8e09b36d03ca0e430298e GIT binary patch literal 49930 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 literal 0 HcmV?d00001 diff --git a/errorStuff.c b/errorStuff.c new file mode 100644 index 0000000..99bbf68 --- /dev/null +++ b/errorStuff.c @@ -0,0 +1,360 @@ +/* + errorStuff.c -- Error handling for the Macross assembler + + Chip Morningstar -- Lucasfilm Ltd. + + 5-November-1984 +*/ + +#include "macrossTypes.h" +#include "macrossGlobals.h" + +bool nullStatementFlag; + +/* puntOnError handles syntax errors and the like encountered during parsing + or lexical analysis: it issues the relevent error message and scans the + input up to the end of the line, in a (probably futile) effort to recover + from the booboo. */ + + void +puntOnError(theError, arg1, arg2, arg3) + errorType theError; + anyOldThing *arg1; + anyOldThing *arg2; + anyOldThing *arg3; +{ + char c; + void error(); + + while ((c = getc(input))!='\n' && c!=EOF) + ; + ungetc(c, input); + error(theError, arg1, arg2, arg3); +} + + +/* printErrorMessage is the general error message handler */ + + void +printErrorMessage(theError, arg1, arg2, arg3) + errorType theError; + anyOldThing *arg1; + anyOldThing *arg2; + anyOldThing *arg3; +{ +/* This table MUST be maintained congruently with the definition of the + enumerated type 'errorType'. */ + void fatalError(); + static bool dying = FALSE; + + static char *errorMessageStrings[] = { + "assignment in 'define' statement is not '='", + "digit '%c' is not valid in base %d", + "closing \"'\" missing in character constant", + "closing '\"' missing in string constant", + "octal value '0%o' too large to fit in a character", + "character '%c' not allowed here", + "comment not closed at end of file", + "line comment not closed at end of file", + "fatal: unable to open temporary scratch file '%s'", + "%s cannot be a valid address for an 'org'", + "negative block size in 'block' statement", + "'%s' is %s and hence unassignable", + "left and right hand sides of assignment are incompatible for '%s' operator", + "operands of '%s' are incompatible with each other", + "postincrement operand is %s and hence un-postincrementable", + "postdecrement operand is %s and hence un-postdecrementable", + "preincrement operand is %s and hence un-preincrementable", + "predecrement operand is %s and hence un-predecrementable", + "operand of '%s' is incompatible with operator", + "value is not an address", + "value is not an integer", + "can't 'align' to zero or negative value", + "left hand operand of '%s' has no value", + "too many operands for '%s' instruction (should have %d)", + "illegal address mode for '%s' instruction", + "value %d is too large to fit in a byte", + "value %d is too large to fit in a word", + "illegal address mode for '%s' instruction", + "divide by zero", + "symbol '%s' undefined", + "relative branch offset too large", + "label '%s' previously defined", + "fatal: can't open object file '%s'", + "%s can't be made external", + "warning: more than one output file name given on command line", + "warning: '-%c' is not a recognized command line flag", + "fatal: no output file name given on command line after '-o'", + "fatal: unable to open input file '%s'", + "fatal: unable to open include file '%s'", + "%s cannot be a valid boolean value", + "symbol '%s' was previously defined", + "assignment to undeclared variable '%s'", + "redefinition of variable '%s'", + "'%s' is not a struct", + "struct is too large for all components to be addressed", + "struct field '%s' previously defined", + "struct definition inside a struct definition", + "'%s' is not a struct field", + "macro '%s' previously defined", + "macro definition inside a macro or function", + "too many arguments given to macro '%s' (expects no more than %d)", + "function definition inside a macro or function", + "function '%s' previously defined", + "too many arguments given to function '%s' (expects no more than %d)", + "'%s' is not a function", + "function '%s' did not return a value", + "operand already has an address mode", + "multiple address modes in expression", + "include file name given is not a string", + "start address previously given", + "attempt to use function name '%s' as a value", + "statement with side-effects not allowed inside a function", + "symbolName can't find symbol", + "error inside macro '%s'", + "error inside function '%s'", + "fatal: no listing file name given on command line after '-l'", + "fatal: no symbol dump file name given on command line after '-%c'", + "warning: more than one listing file name given on command line", + "warning: more than one symbol dump file name given on command line", + "fatal: can't open listing file '%s'", + "fatal: can't open symbol dump file '%s'", + "fatal: source file '%s' does not have a Macross source file name", + "fatal: output file '%s' has a Macross source file name", + "fatal: list file '%s' has a Macross source file name", + "fatal: symbol dump file '%s' has a Macross source file name", + "constraint value is not an integer", + "constrained block crosses 0x%x boundary", + "symbol '%s' has no value", + "bad start address", + "align inside constraint block -- alignment ignored", + "constrain inside constraint block -- constraint ignored", + "can't emit %s as a word", + "can't emit %s as a byte", + "too few operands for '%s' instruction (should have %d)", + "bad color argument to 'atasciiColor'", + "'printf' format argument is not a string", + "'%s' argument #%d is not a string", + "no arguments given to '%s'", + "'%s' argument is not a string", + "too few arguments to '%s'", + "'%s' argument #%d is not an absolute value", + "bad substring indices", + "invalid 'assert' condition", + "invalid 'assert' message", + "'assert' failed: %s", + "'assert' failed", + "can't use %s as a switch value", + "can't use %s as a case value", + "can't forward reference a block", + "warning: turning macro expansion listing off because listing in general is off", + + "inappropriate address modes", + "can't do byte address op", + "quick data out of range", + "ccr op is byte op", + "sr op is word op", + "shift op is word op", + "cmp address is not byte op", + "usp move is long op", + "ccr move is word op", + "sr move is word op", + "cr move is long op", + "address move not byte op", + "trap data too large", + "relative offset value too large", + "can't do op from A register", + "forward reference not allowed here", + "fatal: address 0x%x is outside the available address space", + "argument '%s' to 'apply' is not a macro name", + "can't 'target' in relocatable mode", + "%s cannot be a valid address for a 'target'", + "macro '%s' is undefined", + "bad position argument to 'nthChar'", + "value argument to 'symbolDefine' is not an expression operand", + "attempt to use %s as an array", + "attempt to index an array with %s", + "array index of %d exceeds maximum of %d", + "too many initialization values for variable", + "negative array index", + "can't emit %s as a long", + "can't use ++ or -- on an element of a string", + "can't assign a non-character value into a string element", + "negative array size given to 'makeArray'", + "too many initialization values given to 'makeArray'", + "array element has no value", + "can't use prefix '%s' in an expression containing a forward reference", + "can't use postfix '%s' in an expression containing a forward reference", + "can't use assignment in an expression containing a forward reference", + "fatal: too many errors (choke, gasp, wheeze, die...)", + "expression too large for object file encoding", + "operator assignment not allowed in object file expression", + "temporary symbol '%s' in object file expression", + "block operand in object file expression", + "register operand in object file expression", + "selection operand in object file expression (not yet)", + "%s not allowed in object file expression", + "array term not allowed in object file expression", + "%s not allowed in object file function", + "array mvariable declaration in object file function", + "built-in function '%s' is not available in the linker", + "fatal: no name definition given on command line after '-D'", + "bad name definition: '%s'", + "warning: perform statement has no side effects", + }; + + static int errorCount = 0; + + if (!terseErrorMessages || currentFileName != lastErrorFile || + currentLineNumber != lastErrorLine) { + lastErrorFile = currentFileName; + lastErrorLine = currentLineNumber; + printf("\"%s\", line %d: ", currentFileName, currentLineNumber + -1); + printf(errorMessageStrings[(int)theError], arg1, arg2, arg3); + printf("\n"); + fflush(stdout); + } + if (++errorCount > ERROR_LIMIT && !dying) { + dying = TRUE; + fatalError(TOO_MANY_ERRORS_ERROR); + } +} + + void +error(theError, arg1, arg2, arg3) + errorType theError; + anyOldThing *arg1; + anyOldThing *arg2; + anyOldThing *arg3; +{ + printErrorMessage(theError, arg1, arg2, arg3); + errorFlag = TRUE; +} + + void +warning(theError, arg1, arg2, arg3) + errorType theError; + anyOldThing *arg1; + anyOldThing *arg2; + anyOldThing *arg3; +{ + printErrorMessage(theError, arg1, arg2, arg3); +} + + void +fatalError(theError, arg1, arg2, arg3) + errorType theError; + anyOldThing *arg1; + anyOldThing *arg2; + anyOldThing *arg3; +{ + printErrorMessage(theError, arg1, arg2, arg3); + chokePukeAndDie(); +} + + void +fatalSystemError(theError, arg1, arg2, arg3) + errorType theError; + anyOldThing *arg1; + anyOldThing *arg2; + anyOldThing *arg3; +{ + printErrorMessage(theError, arg1, arg2, arg3); + perror("Unix says"); + chokePukeAndDie(); +} + +/* yyerror is what yacc expects to call when it hits an error. Yacc passes + the error message as a string (this is almost always 'syntax error'). */ + + void +yyerror(s) + char *s; +{ + printf("\"%s\", line %d: %s\n", currentFileName, currentLineNumber,s); + fflush(stdout); + errorFlag = TRUE; +} + + +/* usageString is used in reporting errors having to do with symbol usage. + It provides a translation between the internal representation and + something printable (with the printable something designed to be embedded + in a sentence). */ + + char * +usageString(usageKind) + symbolUsageKindType usageKind; +{ +/* This table MUST be maintained congruently with the definition of the + enumerated type 'symbolUsageKindType'. */ + + static char *usageStrings[NUM_OF_SYM_USAGES] = { + "a struct name", + "a struct field name", + "a macro name", + "an argument variable name", + "a label", + "an external symbol", + "a variable", + "a macro variable", + "a symbol of unknown type", + "a dead symbol", + "a function name", + "a built-in-function name", + "a nested symbol of unknown type", + "a define symbol", + "a macro define symbol", + "an unknown function", + "an unknown macro", + }; + return(usageStrings[(int)usageKind]); +} + + +/* valueKindString similarly deals with the different kinds of values. */ + + char * +valueKindString(valueKind) + valueKindType valueKind; +{ +/* This table MUST be maintained congruently with the definition of the + enumerated type 'valueKindType'. */ + + static char *valueKindStrings[] = { + "an absolute value", + "a data value", + "a relocatable value", + "a bss value", + "a struct name", + "a field name", + "a macro name", + "an operand value", + "a string value", + "a condition code", + "an undefined value", + "a function name", + "a block of statements", + "a built in function", + "an array", + "a failed expression" + }; + return (valueKindStrings[(int)valueKind]); +} + +/* assignmentString similarly handles assignments */ + + char * +assignmentString(assignment) + assignmentKindType assignment; +{ +/* This table MUST be maintained congruently with the definition of the + enumerated type 'assignmentKindType'. */ + + static char *assignmentStringTable[] = { + "=", "+=", "-=", "*=", "/=", "%=", "&=", "|=", "^=", + "<<=", ">>=", "macross botch! no assigment" + }; + return(assignmentStringTable[(int)assignment]); +} diff --git a/errorStuff.o b/errorStuff.o new file mode 100644 index 0000000000000000000000000000000000000000..0f161c604ea8b787dca54a6a9a0b963d529df9a2 GIT binary patch literal 47417 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 Gx&9vkf7{sr literal 0 HcmV?d00001 diff --git a/errorfyle b/errorfyle new file mode 100644 index 0000000..7136330 --- /dev/null +++ b/errorfyle @@ -0,0 +1,39 @@ +make: Warning: Infinite loop: Target `macrossTypes.h' depends on itself +cc -c -g -DYYDEBUG -DTARGET_CPU=CPU_6502 y.tab.c +cc -c -g -DTARGET_CPU=CPU_6502 actions_6502.c +mv actions_6502.o actions.o +cc -c -g -DTARGET_CPU=CPU_6502 buildStuff1.c +cc -c -g -DTARGET_CPU=CPU_6502 buildStuff2.c +cc -c -g -DTARGET_CPU=CPU_6502 buildStuff3.c +cc -c -g -DTARGET_CPU=CPU_6502 builtInFunctions.c +cc -c -g -DTARGET_CPU=CPU_6502 builtInFunsSD_6502.c +mv builtInFunsSD_6502.o builtInFunsSD.o +cc -c -g -DTARGET_CPU=CPU_6502 debugPrint.c +cc -c -g -DTARGET_CPU=CPU_6502 debugPrintSD_6502.c +mv debugPrintSD_6502.o debugPrintSD.o +cc -c -g -DTARGET_CPU=CPU_6502 emitBranch_6502.c +mv emitBranch_6502.o emitBranch.o +cc -c -g -DBYTESWAPPED -DTARGET_CPU=CPU_6502 emitStuff.c +cc -c -g -DTARGET_CPU=CPU_6502 encode.c +cc -c -g -DTARGET_CPU=CPU_6502 errorStuff.c +cc -c -g -DTARGET_CPU=CPU_6502 expressionSemantics.c +cc -c -g -DTARGET_CPU=CPU_6502 fixups.c +cc -c -g -DTARGET_CPU=CPU_6502 garbage.c +cc -c -g -DTARGET_CPU=CPU_6502 initialize.c +cc -c -g -DTARGET_CPU=CPU_6502 lexer.c +cc -c -g -DTARGET_CPU=CPU_6502 listing.c +cc -c -g -DTARGET_CPU=CPU_6502 lookups.c +cc -c -g -DTARGET_CPU=CPU_6502 macrossTables_6502.c +mv macrossTables_6502.o macrossTables.o +cc -c -g -DTARGET_CPU=CPU_6502 main.c +cc -c -g -DTARGET_CPU=CPU_6502 malloc.c +cc -c -g -DTARGET_CPU=CPU_6502 object.c +cc -c -g -DTARGET_CPU=CPU_6502 operandStuffSD_6502.c +mv operandStuffSD_6502.o operandStuffSD.o +cc -c -g -DTARGET_CPU=CPU_6502 parserMisc.c +cc -c -g -DTARGET_CPU=CPU_6502 semanticMisc.c +cc -c -g -DTARGET_CPU=CPU_6502 statementSemantics.c +cc -c -g -DTARGET_CPU=CPU_6502 structSemantics.c +cc -c -g -DTARGET_CPU=CPU_6502 tokenStrings_6502.c +mv tokenStrings_6502.o tokenStrings.o +cc -g -o macross y.tab.o actions.o buildStuff1.o buildStuff2.o buildStuff3.o builtInFunctions.o builtInFunsSD.o debugPrint.o debugPrintSD.o emitBranch.o emitStuff.o encode.o errorStuff.o expressionSemantics.o fixups.o garbage.o initialize.o lexer.o listing.o lookups.o macrossTables.o main.o malloc.o object.o operandStuffSD.o parserMisc.o semanticMisc.o statementSemantics.o structSemantics.o tokenStrings.o diff --git a/expressionSemantics.c b/expressionSemantics.c new file mode 100644 index 0000000..a91d6a8 --- /dev/null +++ b/expressionSemantics.c @@ -0,0 +1,1219 @@ +/* + expressionSemantics.c -- Routines to eat up a parse tree and spit out + code. + + Chip Morningstar -- Lucasfilm Ltd. + + 12-November-1984 +*/ + +#include "macrossTypes.h" +#include "macrossGlobals.h" +#include "y.tab.h" + +operandType *dbOperand; /* safe temps for dbx hacking */ +expressionType *dbExpression; +symbolTableEntryType *dbSymbol; +stringType *dbString; + +#define nullEvaluate(thing) if (thing==NULL) return(NULL); +#define fail(err) if (!expressionFailed) {\ + error(err);\ + expressionFailed = TRUE;\ + } +#define fail1(err,arg) if (!expressionFailed) {\ + error(err,arg);\ + expressionFailed = TRUE;\ + } +#define fail2(err,arg1,arg2) if (!expressionFailed) {\ + error(err,arg1,arg2);\ + expressionFailed = TRUE;\ + } + +#define qfree2(a,b) if (freeFlag) { free(a); free(b); } + +#define expansionOff() {saveExpansion=expandMacros; expandMacros=FALSE;} +#define forceExpansion() {saveExpansion=expandMacros; expandMacros=TRUE;} +#define expansionOn() expandMacros=saveExpansion; + +#define moreStuff(f) (generatingFixup ? moreExpression(f) : moreText(f)) +#define moreStuff1(f,x) (generatingFixup? moreExpression(f,x) : moreText(f,x)) + + anyOldThing * +arrayLookup(arrayTerm, kindOfThing) + arrayTermType *arrayTerm; + valueKindType *kindOfThing; +{ + valueType *arrayValue; + valueType *indexValue; + arrayType *array; + int index; + stringType *string; + + valueType *evaluateExpression(); + + *kindOfThing = FAIL; + arrayValue = evaluateExpression(arrayTerm->arrayName, NO_FIXUP); + if (arrayValue->kindOfValue == FAIL) + return(NULL); + indexValue = evaluateExpression(arrayTerm->arrayIndex, NO_FIXUP); + if (indexValue->kindOfValue == FAIL) + return(NULL); + if (arrayValue->kindOfValue != ARRAY_VALUE && arrayValue->kindOfValue + != STRING_VALUE) { + error(ATTEMPT_TO_INDEX_NON_ARRAY_ERROR, valueKindString( + arrayValue->kindOfValue)); + return(NULL); + } else if (indexValue->kindOfValue != ABSOLUTE_VALUE) { + error(NON_INTEGER_INDEX_ERROR, valueKindString(indexValue-> + kindOfValue)); + return(NULL); + } + + index = indexValue->value; + if (arrayValue->kindOfValue == ARRAY_VALUE) { + array = (arrayType *)arrayValue->value; + if (index >= array->arraySize) { + error(ARRAY_INDEX_OUT_OF_RANGE_ERROR, index, + array->arraySize-1); + return(NULL); + } else if (index < 0) { + error(NEGATIVE_ARRAY_INDEX_ERROR); + return(NULL); + } else { + *kindOfThing = ARRAY_VALUE; + return((anyOldThing *)&((array->arrayContents)[index])); + } + } else { + string = (stringType *)arrayValue->value; + if (index >= strlen(string)) { + error(ARRAY_INDEX_OUT_OF_RANGE_ERROR, index, + strlen(string) - 1); + return(NULL); + } else if (index < 0) { + error(NEGATIVE_ARRAY_INDEX_ERROR); + return(NULL); + } else { + *kindOfThing = STRING_VALUE; + return((anyOldThing *) &(string[index])); + } + } +} + + valueType * +evaluateArrayTerm(arrayTerm) + arrayTermType *arrayTerm; +{ + anyOldThing *resultThing; + valueKindType kindOfResult; + stringType *charPtr; + valueType **valuePtr; + valueType *result; + environmentType *saveEnvironment; + bool saveExpansion; + + valueType *newValue(); + valueType *evaluateOperand(); + + expansionOff(); + resultThing = arrayLookup(arrayTerm, &kindOfResult); + expansionOn(); + if (kindOfResult == STRING_VALUE) { + charPtr = (stringType *) resultThing; + expand(moreExpression("'%c'", *charPtr)); + return(newValue(ABSOLUTE_VALUE, *charPtr, EXPRESSION_OPND)); + } else if (kindOfResult == FAIL) { + return(newValue(FAIL, 0, EXPRESSION_OPND)); + } else if (*(valueType **)resultThing == NULL) { + error(VALUELESS_ARRAY_ELEMENT_ERROR); + return(newValue(FAIL, 0, EXPRESSION_OPND)); + } else { + valuePtr = (valueType **) resultThing; + if ((*valuePtr)->kindOfValue == OPERAND_VALUE) { + saveEnvironment = currentEnvironment; + currentEnvironment = currentEnvironment-> + previousEnvironment; + expansionOff(); + result = evaluateOperand((*valuePtr)->value); + expansionOn(); + currentEnvironment = saveEnvironment; + } else { + dupValue(result, *valuePtr); + } + expand(result->kindOfValue==ABSOLUTE_VALUE ? + moreExpression("0x%x", result->value) : (result-> + kindOfValue==STRING_VALUE ? moreExpression("\"%s\"", + result->value) : 0)); + return(result); + } +} + + valueType * +evaluateAssignmentTerm(assignmentTerm, kindOfFixup) + binopTermType *assignmentTerm; + fixupKindType kindOfFixup; +{ + symbolTableEntryType *targetSymbol; + valueType *target; + valueType **targetPtr; + anyOldThing *targetThing; + valueType *object; + valueType *result; + valueKindType kindOfTarget; + valueKindType newKindOfValue; + symbolInContextType *targetContext; + bool stringAssign; + char *charPtr; + char objectChar; + + symbolTableEntryType *effectiveSymbol(); + valueType *evaluateExpressionInternally(); + valueKindType addValueKind(); + valueKindType selectValueKind(); + valueKindType subValueKind(); + valueKindType opValueKind(); + valueType *makeUndefinedValue(); + valueType *newValue(); + + nullEvaluate(assignmentTerm); + sideEffectFlag = TRUE; + stringAssign = FALSE; + if (assignmentTerm->leftArgument->kindOfTerm == IDENTIFIER_EXPR) { + targetSymbol = effectiveSymbol(assignmentTerm->leftArgument-> + expressionTerm.identifierUnion, &targetContext); + if (isAssignable(targetContext)) { + if ((target = targetContext->value) == NULL && + (assignmentKindType)assignmentTerm->binop != + ASSIGN_ASSIGN) { + error(OPERATOR_ASSIGNMENT_ON_NULL_TARGET_ERROR, tokenString( + assignmentTerm->binop)); + return(object); /* wrong --needs evaluation */ + } + targetPtr = &(targetContext->value); + expand(moreExpression("%s %s ", symbName(targetSymbol), + assignmentString(assignmentTerm->binop))); + } else { + if (targetContext->usage == DEAD_SYMBOL || targetContext->usage == + UNKNOWN_SYMBOL || targetContext->usage == + NESTED_UNKNOWN_SYMBOL) { + fail1(UNDECLARED_VARIABLE_ERROR, symbName(targetSymbol)); + } else { + fail2(UNASSIGNABLE_SYMBOL_TYPE_ERROR, symbName(targetSymbol), + usageString(targetContext->usage)); + } + return(newValue(FAIL, 0, EXPRESSION_OPND)); + } + } else { + targetThing = arrayLookup(assignmentTerm->leftArgument-> + expressionTerm.arrayUnion, &kindOfTarget); + if (kindOfTarget == FAIL) { + return(newValue(FAIL, 0, EXPRESSION_OPND)); + } else if (kindOfTarget == ARRAY_VALUE) { + targetPtr = (valueType **) targetThing; + target = *targetPtr; + } else if (kindOfTarget == STRING_VALUE) { + charPtr = (char *) targetThing; + stringAssign = TRUE; + } + } + + if (isUndefined(object = evaluateExpressionInternally(assignmentTerm-> + rightArgument, FALSE, kindOfFixup, FALSE))) { + result = makeUndefinedValue(); + result->addressMode = object->addressMode; + return(result); + } else if (object->kindOfValue == FAIL) { + return(object); /* we can use it as it's a failure */ + } + if (stringAssign) { + if (object->kindOfValue == ABSOLUTE_VALUE) { + objectChar = object->value & 0xFF; + } else { + fail(NON_CHARACTER_STRING_ASSIGNMENT_ERROR); + return(newValue(FAIL, 0, EXPRESSION_OPND)); + } + } + + switch (assignmentTerm->binop) { + + case ASSIGN_ASSIGN: + if (stringAssign) { + *charPtr = objectChar; + } else if (target == NULL) { + *targetPtr = object; + dupValue(result, object); + return(result); + } else { + newKindOfValue = object->kindOfValue; + target->value = object->value; + } + break; + + case ADD_ASSIGN: + if (stringAssign) + *charPtr += objectChar; + else if ((newKindOfValue = addValueKind(target, object)) != + FAIL) + target->value += object->value; + break; + + case AND_ASSIGN: + if (stringAssign) + *charPtr &= objectChar; + else if ((newKindOfValue = opValueKind(target, object)) != + FAIL) + target->value &= object->value; + break; + + case DIV_ASSIGN: + if (stringAssign) + *charPtr /= objectChar; + else if ((newKindOfValue = opValueKind(target, object)) != + FAIL) + target->value /= object->value; + break; + + case LEFT_SHIFT_ASSIGN: + if (stringAssign) + *charPtr <<= objectChar; + else if ((newKindOfValue = opValueKind(target, object)) != + FAIL) + target->value <<= object->value; + break; + + case MOD_ASSIGN: + if (stringAssign) + *charPtr %= objectChar; + else if ((newKindOfValue = opValueKind(target, object)) != + FAIL) + target->value %= object->value; + break; + + case MUL_ASSIGN: + if (stringAssign) + *charPtr *= objectChar; + else if ((newKindOfValue = opValueKind(target, object)) != + FAIL) + target->value *= object->value; + break; + + case OR_ASSIGN: + if (stringAssign) + *charPtr |= objectChar; + else if ((newKindOfValue = opValueKind(target, object)) != + FAIL) + target->value |= object->value; + break; + + case RIGHT_SHIFT_ASSIGN: + if (stringAssign) + *charPtr >>= objectChar; + else if ((newKindOfValue = opValueKind(target, object)) != + FAIL) + target->value >>= object->value; + break; + + case SUB_ASSIGN: + if (stringAssign) + *charPtr -= objectChar; + else if ((newKindOfValue = subValueKind(target, object)) != + FAIL) + target->value -= object->value; + break; + + case XOR_ASSIGN: + if (stringAssign) + *charPtr ^= objectChar; + else if ((newKindOfValue = opValueKind(target, object)) != + FAIL) + target->value ^= object->value; + break; + + case NO_ASSIGN: + botch("try to assign with NO_ASSIGN\n"); + break; + + default: + botch("bad assignment kind\n"); + break; + } + if (newKindOfValue == FAIL) { + fail1(INCOMPATIBLE_ASSIGNMENT_OPERANDS_ERROR, + assignmentString(assignmentTerm->binop)); + target->value = 0; + } + if (stringAssign) { + result = newValue(ABSOLUTE_VALUE, *charPtr, EXPRESSION_OPND); + } else { + target->kindOfValue = newKindOfValue; + dupValue(result, target); + } + return(result); +} + + valueType * +evaluateBinopTerm(binopTerm, isTopLevel, kindOfFixup) + binopTermType *binopTerm; + bool isTopLevel; + fixupKindType kindOfFixup; +{ + valueType *leftOperand; + valueType *rightOperand; + symbolTableEntryType *rightSelection; + valueKindType resultKindOfValue; + int resultValue; + operandKindType resultAddressMode; + valueType *result; + + symbolInContextType *getWorkingContext(); + valueType *evaluateExpressionInternally(); + valueType *newValue(); + valueType *makeUndefinedValue(); + + nullEvaluate(binopTerm); + if (binopTerm->binop != SUB && binopTerm->binop != ADD) + isTopLevel = FALSE; + leftOperand = evaluateExpressionInternally(binopTerm->leftArgument, + isTopLevel, kindOfFixup, FALSE); + expand(moreExpression("%s", tokenString(binopTerm->binop))); + if (binopTerm->binop != ADD) + isTopLevel = FALSE; + if (binopTerm->binop == SELECT) { + expand(moreExpression("%s", symbName((symbolTableEntryType *) + binopTerm->rightArgument))); + dupValue(rightOperand, getWorkingContext( + (symbolTableEntryType *)(binopTerm->rightArgument))-> + value); + } else { + rightOperand = evaluateExpressionInternally(binopTerm-> + rightArgument, FALSE, kindOfFixup, FALSE); + } + if (isLogicalOp(binopTerm->binop)) { + resultAddressMode = EXPRESSION_OPND; + } else { + resultAddressMode = leftOperand->addressMode; + if (leftOperand->addressMode!=EXPRESSION_OPND && + rightOperand->addressMode!=EXPRESSION_OPND) { + error(MULTIPLE_ADDRESS_MODES_ERROR); + qfree2(leftOperand, rightOperand); + return(newValue(FAIL, 0, EXPRESSION_OPND)); + } else if (rightOperand->addressMode != EXPRESSION_OPND) { + resultAddressMode = rightOperand->addressMode; + } + } + if ((isUndefined(leftOperand) && !isFailure(rightOperand)) || + (isUndefined(rightOperand) && !isFailure(leftOperand))) { + qfree2(leftOperand, rightOperand); + result = makeUndefinedValue(); + result->addressMode = resultAddressMode; + return(result); + } + + switch (binopTerm->binop) { + + case ADD: + if ((resultKindOfValue = addValueKind(leftOperand, + rightOperand)) != FAIL) + resultValue = leftOperand->value + + rightOperand->value; + break; + + case ASSIGN: + botch("assignment leaked thru to binop\n"); + break; + + case BITWISE_AND: + if ((resultKindOfValue = opValueKind(leftOperand, + rightOperand)) != FAIL) + resultValue = leftOperand->value & + rightOperand->value; + break; + + case BITWISE_OR: + if ((resultKindOfValue = opValueKind(leftOperand, + rightOperand)) != FAIL) + resultValue = leftOperand->value | + rightOperand->value; + break; + + case BITWISE_XOR: + if ((resultKindOfValue = opValueKind(leftOperand, + rightOperand)) != FAIL) + resultValue = leftOperand->value ^ + rightOperand->value; + break; + + case DIV: + if ((resultKindOfValue = opValueKind(leftOperand, + rightOperand)) != FAIL) + if (rightOperand->value == 0) { + fail(DIVIDE_BY_ZERO_ERROR); + resultKindOfValue = FAIL; + } else { + resultValue = leftOperand->value / + rightOperand->value; + } + break; + + case EQUAL_TO: + if ((resultKindOfValue = opValueKind(leftOperand, + rightOperand)) != FAIL) + resultValue = leftOperand->value == + rightOperand->value; + break; + + case GREATER_THAN: + if ((resultKindOfValue = opValueKind(leftOperand, + rightOperand)) != FAIL) + resultValue = leftOperand->value > + rightOperand->value; + break; + + case GREATER_THAN_OR_EQUAL_TO: + if ((resultKindOfValue = opValueKind(leftOperand, + rightOperand)) != FAIL) + resultValue = leftOperand->value >= + rightOperand->value; + break; + + case LEFT_SHIFT: + if ((resultKindOfValue = opValueKind(leftOperand, + rightOperand)) != FAIL) + resultValue = leftOperand->value << + rightOperand->value; + break; + + case LESS_THAN: + if ((resultKindOfValue = opValueKind(leftOperand, + rightOperand)) != FAIL) + resultValue = leftOperand->value < + rightOperand->value; + break; + + case LESS_THAN_OR_EQUAL_TO: + if ((resultKindOfValue = opValueKind(leftOperand, + rightOperand)) != FAIL) + resultValue = leftOperand->value <= + rightOperand->value; + break; + + case LOGICAL_AND: + if ((resultKindOfValue = opValueKind(leftOperand, + rightOperand)) != FAIL) + resultValue = leftOperand->value && + rightOperand->value; + break; + + case LOGICAL_OR: + if ((resultKindOfValue = opValueKind(leftOperand, + rightOperand)) != FAIL) + resultValue = leftOperand->value || + rightOperand->value; + break; + + case LOGICAL_XOR: + if ((resultKindOfValue = opValueKind(leftOperand, + rightOperand)) != FAIL) + resultValue = logicalXOR(leftOperand->value, + rightOperand->value); + break; + + case MOD: + if ((resultKindOfValue = opValueKind(leftOperand, + rightOperand)) != FAIL) + resultValue = leftOperand->value % + rightOperand->value; + break; + + case MUL: + if ((resultKindOfValue = opValueKind(leftOperand, + rightOperand)) != FAIL) + resultValue = leftOperand->value * + rightOperand->value; + break; + + case NOT_EQUAL_TO: + if ((resultKindOfValue = opValueKind(leftOperand, + rightOperand)) != FAIL) + resultValue = leftOperand->value != + rightOperand->value; + break; + + case RIGHT_SHIFT: + if ((resultKindOfValue = opValueKind(leftOperand, + rightOperand)) != FAIL) + resultValue = leftOperand->value >> + rightOperand->value; + break; + + case SELECT: + if ((resultKindOfValue = selectValueKind(leftOperand, + rightOperand)) != FAIL) + resultValue = leftOperand->value + + rightOperand->value; + break; + + case SUB: + if ((resultKindOfValue = subValueKind(leftOperand, + rightOperand)) != FAIL) + resultValue = leftOperand->value - + rightOperand->value; + break; + + default: + botch("bad binop kind\n"); + break; + } + if (resultKindOfValue == FAIL) { + resultValue = 0; + fail1(INCOMPATIBLE_BINOP_OPERANDS_ERROR, + tokenString(binopTerm->binop)); + } + qfree2(leftOperand, rightOperand); + return(newValue(resultKindOfValue, resultValue, resultAddressMode)); +} + + valueType * +evaluateCondition(condition) + conditionType condition; +{ + valueType *newValue(); + + expand(moreExpression("%s", conditionString(condition))); + return(newValue(CONDITION_VALUE, condition, EXPRESSION_OPND)); +} + + valueType * +evaluateBuiltInFunctionCall(workingContext, parameters, kindOfFixup) + symbolInContextType *workingContext; + operandListType *parameters; + fixupKindType kindOfFixup; +{ + sideEffectFlag = TRUE; + return((*builtInFunctionTable[workingContext->value->value]. + functionEntry)(parameters, kindOfFixup)); +} + + valueType * +evaluateFunctionCall(functionCall, kindOfFixup, isStandalone) + functionCallTermType *functionCall; + fixupKindType kindOfFixup; + bool isStandalone; +{ + functionDefinitionType *theFunction; + int numberBound; + identifierListType *savedLocalVariableList; + int savedLabelTagNumber; + stringType *savedFunctionName; + bool savedErrorFlag; + bool savedBeneathFunction; + symbolInContextType *workingContext; + environmentType newEnvironment; + valueType *result; + bool saveExpansion; + + symbolInContextType *getWorkingContext(); + valueType *evaluateBuiltInFunctionCall(); + valueType *newValue(); + + nullEvaluate(functionCall); + sideEffectFlag = TRUE; + pushEnvironment(newEnvironment); + resultOfLastFunctionCall = NULL; + freturnExit = FALSE; + workingContext = getWorkingContext(functionCall->functionName); + expand(moreExpression("%s(", symbName(functionCall->functionName))); + if (isBuiltInFunction(workingContext)) { + popEnvironment(); + result = evaluateBuiltInFunctionCall(workingContext, + functionCall->parameters, kindOfFixup); + expand(moreExpression(")")); + return(result); + } if (isFunction(workingContext)) { + theFunction = (functionDefinitionType *)workingContext-> + value->value; + } else { + error(NOT_A_FUNCTION_ERROR, symbName(functionCall-> + functionName)); + popEnvironment(); + return(newValue(FAIL, 0, EXPRESSION_OPND)); + } + savedLocalVariableList = currentLocalVariableList; + currentLocalVariableList = NULL; + savedLabelTagNumber = currentLabelTagNumber; + savedFunctionName = currentFunctionName; + currentFunctionName = symbName(theFunction->functionName); + currentLabelTagNumber = nextLabelTagNumber++; + savedErrorFlag = errorFlag; + savedBeneathFunction = beneathFunction; + errorFlag = FALSE; + if ((numberBound = bindFunctionArguments(theFunction->arguments, + functionCall->parameters, symbName( + theFunction->functionName))) > 0) { + expansionOff(); + beneathFunction = TRUE; + assembleBlock(theFunction->body); + freturnExit = FALSE; + expansionOn(); + } else + numberBound = -numberBound; + if (numberBound > 1) + unbindArguments(theFunction->arguments, numberBound-1); + unbindLocalVariables(currentLocalVariableList); + beneathFunction = savedBeneathFunction; + expand(moreExpression(")")); + currentLabelTagNumber = savedLabelTagNumber; + currentLocalVariableList = savedLocalVariableList; + currentFunctionName = savedFunctionName; + if (errorFlag) + error(ERROR_INSIDE_FUNCTION_ERROR, symbName(theFunction-> + functionName)); + else + errorFlag = savedErrorFlag; + popEnvironment(); + if (resultOfLastFunctionCall != NULL) { + return(resultOfLastFunctionCall); + } else { + if (!isStandalone) + error(FUNCTION_DID_NOT_RETURN_A_VALUE_ERROR, symbName( + theFunction->functionName)); + return(newValue(FAIL, 0, EXPRESSION_OPND)); + } +} + + valueType * +evaluateHere() +{ + valueType *newValue(); + valueType *result; + + expand(moreExpression("here")); + result = newValue(currentLocationCounter.kindOfValue, + currentLocationCounter.value, EXPRESSION_OPND); + result->value -= targetOffset; + return(result); +} + + valueType * +evaluateIdentifier(identifier, isTopLevel, kindOfFixup) + symbolTableEntryType *identifier; + bool isTopLevel; + fixupKindType kindOfFixup; +{ + symbolInContextType *workingContext; + valueType *resultValue; + valueType *result; + environmentType *saveEnvironment; + bool saveExpansion; + + valueType *newValue(); + valueType *evaluateOperand(); + symbolInContextType *getWorkingContext(); + symbolTableEntryType *generateLocalLabel(); + + nullEvaluate(identifier); + identifier->referenceCount++; + if (symbName(identifier)[0] == '$') + identifier = generateLocalLabel(identifier); + if ((workingContext = getWorkingContext(identifier)) == NULL) { + fail1(UNDEFINED_SYMBOL_ERROR, symbName(identifier)); + expand(moreExpression("%s", symbName(identifier))); + return(newValue(FAIL, 0, EXPRESSION_OPND)); + } + if (workingContext->usage == DEAD_SYMBOL) { + reincarnateSymbol(workingContext, UNKNOWN_SYMBOL); + } + if (workingContext->usage == FUNCTION_SYMBOL || workingContext->usage + == BUILT_IN_FUNCTION_SYMBOL) { + fail1(FUNCTION_IS_NOT_A_VALUE_ERROR, symbName(identifier)); + expand(moreExpression("%s", symbName(identifier))); + return(newValue(FAIL, 0, EXPRESSION_OPND)); + } + if (workingContext->value == NULL) { + if (kindOfFixup == NO_FIXUP) { + fail1(UNDEFINED_SYMBOL_ERROR, symbName(identifier)); + expand(moreExpression("%s", symbName(identifier))); + return(newValue(FAIL, 0, EXPRESSION_OPND)); + } else if (kindOfFixup != NO_FIXUP_OK) { + expand(moreExpression("%s", symbName(identifier))); + return(newValue(FAIL, 0, EXPRESSION_OPND)); + } + } else { + resultValue = workingContext->value; + if (workingContext->value->kindOfValue == UNDEFINED_VALUE){ + if (kindOfFixup==NO_FIXUP || + (workingContext->usage!=LABEL_SYMBOL && + workingContext->usage!=EXTERNAL_SYMBOL && + workingContext->usage!=UNKNOWN_SYMBOL && + workingContext->usage!=NESTED_UNKNOWN_SYMBOL)) { + expand(moreExpression("%s", symbName( + identifier))); + if ((workingContext->attributes & GLOBAL_ATT) + !=0 && performingFixups) { + return(newValue(UNDEFINED_VALUE, 0, + resultValue->addressMode)); + } else { + fail1(UNDEFINED_SYMBOL_ERROR, + symbName(identifier)); + return(newValue(FAIL, 0, + EXPRESSION_OPND)); + } + } else if (kindOfFixup == NO_FIXUP_OK) { + expand(moreExpression("%s", symbName( + identifier))); + return(newValue(UNDEFINED_VALUE, 0, + EXPRESSION_OPND)); + } + } else if (workingContext->value->kindOfValue == FAIL) { + fail1(UNASSIGNED_SYMBOL_ERROR, symbName(identifier)); + expand(moreExpression("%s", symbName(identifier))); + return(newValue(FAIL, 0, EXPRESSION_OPND)); + } + if (workingContext->value->kindOfValue == OPERAND_VALUE) { + saveEnvironment = currentEnvironment; + if (workingContext->usage == ARGUMENT_SYMBOL) { + currentEnvironment = currentEnvironment-> + previousEnvironment; + expand(shouldParenthesize(workingContext-> + value->value) ? moreExpression("(") : + 0); + } else { + expand(moreExpression("%s", + symbName(identifier))); + expansionOff(); + } + resultValue = evaluateOperand(workingContext-> + value->value); + if (workingContext->usage == ARGUMENT_SYMBOL) { + expand(shouldParenthesize(workingContext-> + value->value) ? moreExpression(")") : + 0); + } else { + expansionOn(); + } + currentEnvironment = saveEnvironment; + } else if (workingContext->value->kindOfValue == BLOCK_VALUE){ + sideEffectFlag = TRUE; + saveEnvironment = currentEnvironment; + currentEnvironment = currentEnvironment-> + previousEnvironment; + expand((moreText("{"), endLine(), tabCount++)); + assembleBlock(workingContext->value->value); + expand((tabCount--, tabIndent(), moreText("}"), + endLine())); + currentEnvironment = saveEnvironment; + return(newValue(UNDEFINED_VALUE, 0, EXPRESSION_OPND)); + } else if (workingContext->usage==MVARIABLE_SYMBOL || + workingContext->usage==VARIABLE_SYMBOL || + workingContext->usage==MDEFINE_SYMBOL) { + expand(workingContext->value->kindOfValue== + ABSOLUTE_VALUE ? moreExpression("0x%x", + workingContext->value->value) : ( + workingContext->value->kindOfValue== + STRING_VALUE ? moreExpression("\"%s\"", + workingContext->value->value) : 0)); + } else { + expand(moreExpression("%s", symbName(identifier))); + } + + dupValue(result, resultValue); + if (result->kindOfValue != UNDEFINED_VALUE) + workingContext->referenceCount += 1; + if (result->kindOfValue==RELOCATABLE_VALUE && (kindOfFixup!= + NO_FIXUP || performingFixups)) + result->value = 0; /* it'll be relocated */ + return(result); + } +} + + valueType * +evaluateNumber(number) + numberTermType number; +{ + valueType *newValue(); + + expand(moreExpression("0x%x", number)); + return(newValue(ABSOLUTE_VALUE, number, EXPRESSION_OPND)); +} + + valueType * +evaluatePostopTerm(postopTerm) + postOpTermType *postopTerm; +{ + valueType *theOperand; + valueType **theOperandPtr; + valueKindType kindOfOperand; + valueType *result; + symbolInContextType *workingContext; + symbolTableEntryType *targetSymbol; + + symbolTableEntryType *effectiveSymbol(); + symbolInContextType *getWorkingContext(); + + nullEvaluate(postopTerm); + sideEffectFlag = TRUE; + if (postopTerm->postOpArgument->kindOfTerm == IDENTIFIER_EXPR) { + targetSymbol = effectiveSymbol(postopTerm->postOpArgument-> + expressionTerm.identifierUnion, &workingContext); + if (workingContext != NULL) + theOperand = workingContext->value; + else + theOperand = NULL; + } else { + theOperandPtr = (valueType **) arrayLookup(postopTerm-> + postOpArgument->expressionTerm.arrayUnion, + &kindOfOperand); + if (kindOfOperand == FAIL) + theOperand = NULL; + else if (kindOfOperand == ARRAY_VALUE) + theOperand = *theOperandPtr; + else { + fail(CANT_POSTPREOP_STRING_ERROR); + return(newValue(FAIL, 0, EXPRESSION_OPND)); + } + } + + switch (postopTerm->postOp) { + + case INCREMENT: + if (incrementable(theOperand)) { + expand(moreExpression("%s++",symbName(targetSymbol))); + dupValue(result, theOperand); + theOperand->value += 1; + return(result); + } else { + fail1(UNPOSTINCREMENTABLE_OPERAND_ERROR, + valueKindString(theOperand->kindOfValue)); + return(newValue(FAIL, 0, EXPRESSION_OPND)); + } + break; + + case DECREMENT: + if (decrementable(theOperand)) { + expand(moreExpression("%s--",symbName(targetSymbol))); + dupValue(result, theOperand); + theOperand->value -= 1; + return(result); + } else { + fail1(UNPOSTDECREMENTABLE_OPERAND_ERROR, + valueKindString(theOperand->kindOfValue)); + return(newValue(FAIL, 0, EXPRESSION_OPND)); + } + break; + + default: + botch("bad postop type\n"); + break; + } +} + + valueType * +evaluatePreopTerm(preopTerm) + preOpTermType *preopTerm; +{ + valueType *theOperand; + valueType *result; + valueType **theOperandPtr; + valueKindType kindOfOperand; + symbolInContextType *workingContext; + symbolTableEntryType *targetSymbol; + + symbolTableEntryType *effectiveSymbol(); + symbolInContextType *getWorkingContext(); + + nullEvaluate(preopTerm); + sideEffectFlag = TRUE; + if (preopTerm->preOpArgument->kindOfTerm == IDENTIFIER_EXPR) { + targetSymbol = effectiveSymbol(preopTerm->preOpArgument-> + expressionTerm.identifierUnion, &workingContext); + if (workingContext != NULL) + theOperand = workingContext->value; + else + theOperand = NULL; + } else { + theOperandPtr = (valueType **) arrayLookup(preopTerm-> + preOpArgument->expressionTerm.arrayUnion, + &kindOfOperand); + if (kindOfOperand == FAIL) + theOperand = NULL; + else if (kindOfOperand == ARRAY_VALUE) + theOperand = *theOperandPtr; + else { + fail(CANT_POSTPREOP_STRING_ERROR); + return(newValue(FAIL, 0, EXPRESSION_OPND)); + } + } + + switch (preopTerm->preOp) { + + case INCREMENT: + if (incrementable(theOperand)) { + expand(moreExpression("%++s",symbName(targetSymbol))); + theOperand->value += 1; + dupValue(result, theOperand); + return(result); + } else { + fail1(UNPREINCREMENTABLE_OPERAND_ERROR, + valueKindString(theOperand->kindOfValue)); + return(newValue(FAIL, 0, EXPRESSION_OPND)); + } + break; + + case DECREMENT: + if (decrementable(theOperand)) { + expand(moreExpression("%--s",symbName(targetSymbol))); + theOperand->value -= 1; + dupValue(result, theOperand); + return(result); + } else { + fail1(UNPREDECREMENTABLE_OPERAND_ERROR, + valueKindString(theOperand->kindOfValue)); + return(newValue(FAIL, 0, EXPRESSION_OPND)); + } + break; + + default: + botch("bad preop type\n"); + break; + } +} + + valueType * +evaluateString(string) + stringType *string; +{ + valueType *newValue(); + stringType *newString; + + expand(moreExpression("\"%s\"", string)); + newString = (stringType *)malloc(strlen(string)+1); + strcpy(newString, string); + return(newValue(STRING_VALUE, newString, EXPRESSION_OPND)); +} + + valueType * +evaluateUnopTerm(unopTerm, kindOfFixup) + unopTermType *unopTerm; + fixupKindType kindOfFixup; +{ + valueType *theOperand; + valueKindType resultKindOfValue; + int resultValue; + operandKindType resultAddressMode; + valueType *result; + + valueKindType unopValueKind(); + valueType *newValue(); + valueType *evaluateExpressionInternally(); + valueType *makeUndefinedValue(); + + nullEvaluate(unopTerm); + expand(moreExpression("%s", tokenString(unopTerm->unop))); + theOperand = evaluateExpressionInternally(unopTerm->unopArgument, + FALSE, kindOfFixup, FALSE); + resultAddressMode = theOperand->addressMode; + if (isUndefined(theOperand)) { + qfree(theOperand); + result = makeUndefinedValue(); + result->addressMode = resultAddressMode; + return(result); + } + if ((resultKindOfValue = unopValueKind(theOperand)) != FAIL) { + switch (unopTerm->unop) { + + case BITWISE_NOT: + resultValue = ~theOperand->value; + break; + + case HI_BYTE: + resultValue = (theOperand->value>>8) & 0xFF; + break; + + case LO_BYTE: + resultValue = theOperand->value & 0xFF; + break; + + case LOGICAL_NOT: + resultValue = !theOperand->value; + break; + + case UNARY_MINUS: + resultValue = -theOperand->value; + break; + } + } else { + fail1(INCOMPATIBLE_UNOP_OPERAND_ERROR, tokenString(unopTerm-> + unop)); + resultValue = 0; + } + qfree(theOperand); + return(newValue(resultKindOfValue, resultValue, resultAddressMode)); +} + + valueType * +evaluateExpressionInternally(expression, isTopLevel, kindOfFixup,isStandalone) + expressionType *expression; + bool isTopLevel; + fixupKindType kindOfFixup; + bool isStandalone; +{ + valueType *result; + + nullEvaluate(expression); + switch (expression->kindOfTerm) { + + case ARRAY_EXPR: + return(evaluateArrayTerm(expression->expressionTerm)); + break; + + case ASSIGN_EXPR: + return(evaluateAssignmentTerm(expression->expressionTerm, + kindOfFixup)); + break; + + case BINOP_EXPR: + return(evaluateBinopTerm(expression->expressionTerm, + isTopLevel, kindOfFixup)); + break; + + case CONDITION_CODE_EXPR: + return(evaluateCondition(expression->expressionTerm)); + break; + + case FUNCTION_CALL_EXPR: + return(evaluateFunctionCall(expression->expressionTerm, + kindOfFixup, isStandalone)); + break; + + case HERE_EXPR: + return(evaluateHere()); + break; + + case IDENTIFIER_EXPR: + result = evaluateIdentifier(expression->expressionTerm, + isTopLevel, kindOfFixup); + return(result); + break; + + case NUMBER_EXPR: + return(evaluateNumber(expression->expressionTerm)); + break; + + case POSTOP_EXPR: + return(evaluatePostopTerm(expression->expressionTerm)); + break; + + case PREOP_EXPR: + return(evaluatePreopTerm(expression->expressionTerm)); + break; + + case SUBEXPRESSION_EXPR: + expand(moreExpression("(")); + result = evaluateExpressionInternally(expression-> + expressionTerm, isTopLevel, kindOfFixup, FALSE); + expand(moreExpression(")")); + return(result); + break; + + case STRING_EXPR: + return(evaluateString(expression->expressionTerm)); + break; + + case UNOP_EXPR: + return(evaluateUnopTerm(expression->expressionTerm, + kindOfFixup)); + break; + + case VALUE_EXPR: + if (expression->expressionTerm.valueUnion->kindOfValue == + OPERAND_VALUE) { + return(evaluateOperand(expression->expressionTerm. + valueUnion->value)); + } else { + dupValue(result, expression->expressionTerm. + valueUnion); + expand(moreExpression("0x%x", result->value)); + return(result); + } + break; + + default: + botch("evaluateExpression: funny expression kind %d\n", + expression->kindOfTerm); + break; + } +} + + valueType * +evaluateExpression(expression, kindOfFixup) + expressionType *expression; + fixupKindType kindOfFixup; +{ + valueType *result; + + expressionFailed = FALSE; + referencesToNote[currentOperandNumber] = NULL; + result = evaluateExpressionInternally(expression, TRUE, kindOfFixup, + FALSE); + if (result->kindOfValue == RELOCATABLE_VALUE) { + result->kindOfValue = UNDEFINED_VALUE; + result->value = 0; /* fix linker bug */ + } + if (isUndefined(result)) { + flushExpressionString(); + pendingFixup[currentOperandNumber] = expression; + } else + pendingFixup[currentOperandNumber] = NULL; + return(result); +} + + void +evaluateExpressionStandalone(expression) + expressionType *expression; +{ + bool saveExpansion; + valueType *expressionResult; + + expressionFailed = FALSE; + referencesToNote[currentOperandNumber] = NULL; + + standaloneExpansionFlag = amExpanding(); + expansionOff(); + expressionResult = evaluateExpressionInternally(expression, TRUE, + NO_FIXUP, TRUE); + expansionOn(); + standaloneExpansionFlag = FALSE; + if (expressionResult != NULL) + qfree(expressionResult); + pendingFixup[0] = NULL; +} + + valueType * +evaluateDefineExpression(expression) + expressionType *expression; +{ + valueType *newValue(); + expressionType *generateFixupExpression(); + operandType *buildOperand(); + + nullEvaluate(expression); + return(newValue(OPERAND_VALUE, buildOperand(EXPRESSION_OPND, + generateFixupExpression(expression)), EXPRESSION_OPND)); +} + + valueType * +evaluateSelectionList(selectionList) + selectionListType *selectionList; +{ + int offset; + valueType *newValue(); + + offset = 0; + while (selectionList != NULL) { + expand(moreExpression(".%s", symbName(selectionList-> + theSymbol))); + offset += fieldValue(selectionList->theSymbol); + selectionList = selectionList->nextIdentifier; + } + return(newValue(ABSOLUTE_VALUE, offset, EXPRESSION_OPND)); +} diff --git a/expressionSemantics.o b/expressionSemantics.o new file mode 100644 index 0000000000000000000000000000000000000000..3ba29c08d97762296b156971b2e584d92bd7a1d2 GIT binary patch literal 73640 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 Q04~OmM%4*Z=?k literal 0 HcmV?d00001 diff --git a/fixups.c b/fixups.c new file mode 100644 index 0000000..c977d3c --- /dev/null +++ b/fixups.c @@ -0,0 +1,346 @@ +/* + fixups.c -- Routines to handle expressions being saved away for fixups + in the Macross assembler. + + Chip Morningstar -- Lucasfilm Ltd. + + 20-December-1984 +*/ + +#include "macrossTypes.h" +#include "macrossGlobals.h" + +operandType *dbOperand; /* safe temps for dbx hacking */ +expressionType *dbExpression; +symbolTableEntryType *dbSymbol; + +stringType *dbString = "graphics2.m"; + +#define nullDup(thing) if (thing==NULL) { return (NULL); } + +#define expansionOff() {saveExpansion=expandMacros; expandMacros=FALSE;} +#define expansionOn() expandMacros=saveExpansion; + +/* + Whenever a value is needed as the operand of an instruction or data + statement, but one or more of the terms of the expression which define the + value are themselves undefined symbols, we have to get fancy. What we do + is use a zero value and save away a copy of the expression for later + evaluation at a time (the end of assembly) when (hopefully) the undefined + symbols will have been defined. It is necessary to save a copy of the + expression, rather that the expression itself, since some of the terms of + the expression may be variables whose value may change between now and + when the saved expression gets reevaluated. When we are making the copy + we replace any variables with their present values. + + The routines below collectively duplicate expressions for later evaluation. + */ + + expressionType * +generateFixupExpression(expression) + expressionType *expression; +{ + expressionType *result; + expressionType *duplicateExpressionForFixup(); + + generatingFixup = TRUE; + result = duplicateExpressionForFixup(expression, TRUE, FALSE); + generatingFixup = FALSE; + return(result); +} + + expressionType * +duplicateExpressionForFixup(expression, isTopLevel, isSpecialFunctionOperand) + expressionType *expression; + bool isTopLevel; + bool isSpecialFunctionOperand; +{ + expressionType *result; + expressionType *originalResult; + valueType *value; + symbolTableEntryType *identifier; + symbolInContextType *context; + operandType *newOperand; + environmentType *saveEnvironment; + bool saveExpansion; + + operandType *duplicateOperandForFixup(); + symbolInContextType *getWorkingContext(); + functionCallTermType *duplicateFunctionCall(); + expressionType *duplicateArrayReference(); + valueType *evaluateIdentifier(); + valueType *evaluateHere(); + valueType *newValue(); + symbolTableEntryType *generateLocalLabel(); + stringType *saveString(); + + nullDup(expression); + result = originalResult = typeAlloc(expressionType); + *result = *expression; + switch (expression->kindOfTerm) { + + case STRING_EXPR: + expand(moreExpression("%s", expression->expressionTerm.stringUnion)); + result->expressionTerm.stringUnion = saveString(originalResult-> + expressionTerm.stringUnion); + break; + + case IDENTIFIER_EXPR: + identifier = expression->expressionTerm.identifierUnion; + if (symbName(identifier)[0] == '$') + identifier = result->expressionTerm.identifierUnion = + generateLocalLabel(identifier); + context = getWorkingContext(identifier); + if (context->usage == ARGUMENT_SYMBOL && context->value-> + kindOfValue == OPERAND_VALUE) { + if (isSpecialFunctionOperand) { + while (context->usage == ARGUMENT_SYMBOL && context->value-> + kindOfValue == OPERAND_VALUE) { + newOperand = (operandType *)context->value->value; + if (newOperand->kindOfOperand == EXPRESSION_OPND && + (expression = newOperand->theOperand. + expressionUnion) != NULL && expression-> + kindOfTerm == IDENTIFIER_EXPR) { + identifier = expression->expressionTerm. + identifierUnion; + context = getWorkingContext(identifier); + } else { + expand(moreExpression("*fail*")); + return(NULL); + } + } + expand(moreExpression("%s", symbName(identifier))); + result->expressionTerm.identifierUnion = identifier; + } else { + saveEnvironment = currentEnvironment; + currentEnvironment = currentEnvironment->previousEnvironment; + if ((newOperand = duplicateOperandForFixup( + context->value->value, + FALSE)) == NULL) { + result = NULL; + } else { + result->kindOfTerm = VALUE_EXPR; + result->expressionTerm.valueUnion = + newValue(OPERAND_VALUE, + newOperand, newOperand-> + kindOfOperand); + } + currentEnvironment = saveEnvironment; + } + } else { + expansionOff(); + if(!isUndefined(value = evaluateIdentifier(identifier, + isTopLevel, NO_FIXUP_OK)) && value->kindOfValue != + RELOCATABLE_VALUE) { + expansionOn(); + result->kindOfTerm = VALUE_EXPR; + result->expressionTerm.valueUnion = value; + expand((context->usage==MVARIABLE_SYMBOL || + context->usage==VARIABLE_SYMBOL || + context->usage==MDEFINE_SYMBOL) ? + moreExpression("0x%x", value->value) : + moreExpression("%s", symbName(identifier))); + } else { + expansionOn(); + expand(moreExpression("%s", symbName(identifier))); + } + } + break; + + case FUNCTION_CALL_EXPR: + if ((result->expressionTerm.functionCallUnion = + duplicateFunctionCall(expression-> + expressionTerm.functionCallUnion)) == NULL) + result = NULL; + break; + + case NUMBER_EXPR: + expand(moreExpression("0x%x", result->expressionTerm.numberUnion)); + /* keep unchanged */ + break; + + case SUBEXPRESSION_EXPR: + expand(moreExpression("(")); + if ((result->expressionTerm.subexpressionUnion = + duplicateExpressionForFixup(expression-> + expressionTerm.subexpressionUnion, + isTopLevel, FALSE)) == NULL) + result = NULL; + expand(moreExpression(")")); + break; + + case UNOP_EXPR: + expand(moreExpression("%s", tokenString(expression->expressionTerm. + unopUnion->unop))); + result->expressionTerm.unopUnion = typeAlloc(unopTermType); + result->expressionTerm.unopUnion->unop = expression->expressionTerm. + unopUnion->unop; + if ((result->expressionTerm.unopUnion->unopArgument = + duplicateExpressionForFixup(expression-> + expressionTerm.unopUnion->unopArgument, + FALSE, FALSE)) == NULL) + result = NULL; + break; + + case BINOP_EXPR: + result->expressionTerm.binopUnion = typeAlloc(binopTermType); + result->expressionTerm.binopUnion->binop = expression->expressionTerm. + binopUnion->binop; + if ((result->expressionTerm.binopUnion->leftArgument = + duplicateExpressionForFixup(expression-> + expressionTerm.binopUnion->leftArgument, + FALSE, FALSE)) == NULL) { + expand(moreExpression("*fail*")); + result = NULL; + } else { + expand(moreExpression("%s", tokenString(expression-> + expressionTerm.binopUnion->binop))); + if ((result->expressionTerm.binopUnion->rightArgument = + duplicateExpressionForFixup(expression-> + expressionTerm.binopUnion->rightArgument, + FALSE, FALSE)) == NULL) { + result = NULL; + expand(moreExpression("*fail*")); + } + } + break; + + + case PREOP_EXPR: + expand(moreExpression("*fail*")); + error(CANT_USE_PREOP_WITH_FORWARD_REFERENCE_ERROR, tokenString( + expression->expressionTerm.preOpUnion->preOp)); + result = NULL; + break; + + case POSTOP_EXPR: + expand(moreExpression("*fail*")); + error(CANT_USE_POSTOP_WITH_FORWARD_REFERENCE_ERROR, tokenString( + expression->expressionTerm.postOpUnion->postOp)); + result = NULL; + break; + + case HERE_EXPR: + result->kindOfTerm = VALUE_EXPR; + result->expressionTerm.valueUnion = evaluateHere(); + expand(moreExpression("0x%x", result->expressionTerm.valueUnion-> + value)); + break; + + case ASSIGN_EXPR: + expand(moreExpression("*fail*")); + error(CANT_USE_ASSIGNMENT_WITH_FORWARD_REFERENCE_ERROR); + result = NULL; + break; + + case CONDITION_CODE_EXPR: + /* keep unchanged */ + expand(moreExpression("%s", conditionString(expression-> + expressionTerm.conditionCodeUnion))); + break; + + case VALUE_EXPR: + /* keep unchanged */ + expand(moreExpression("0x%x", expression->expressionTerm.valueUnion-> + value)); + break; + + case ARRAY_EXPR: + result = duplicateArrayReference(expression->expressionTerm. + arrayUnion); + break; + + default: + botch("duplicateExpression: funny expression kind %d\n", + expression->kindOfTerm); + break; + } + return(result); +} + + functionCallTermType * +duplicateFunctionCall(functionCall) + functionCallTermType *functionCall; +{ + functionCallTermType *result; + operandListType **argument; + operandListType *parameterList; + + operandListType *duplicateOperandForFixup(); + + result = typeAlloc(functionCallTermType); + result->functionName = functionCall->functionName; + expand(moreExpression("%s(", symbName(functionCall->functionName))); + result->parameters = NULL; + parameterList = functionCall->parameters; + argument = &(result->parameters); + while (parameterList != NULL) { + *argument = duplicateOperandForFixup(parameterList, + (functionCall->functionName->context->attributes & + SPECIAL_FUNCTION_ATT) != 0); + (*argument)->nextOperand = NULL; + argument = &((*argument)->nextOperand); + parameterList = parameterList->nextOperand; + expand(parameterList != NULL ? moreExpression(", ") : 0); + } + expand(moreExpression(")")); + return(result); +} + + + expressionType * +duplicateArrayReference(arrayTerm) + arrayTermType *arrayTerm; +{ + anyOldThing *resultThing; + valueKindType kindOfResult; + expressionType *result; + stringType *charPtr; + valueType **valuePtr; + environmentType *saveEnvironment; + bool saveExpansion; + operandType *newOperand; + + valueType *newValue(); + operandType *duplicateOperandForFixup(); + anyOldThing *arrayLookup(); + + expansionOff(); + resultThing = arrayLookup(arrayTerm, &kindOfResult); + expansionOn(); + if (*(valueType **)resultThing == NULL) { + error(VALUELESS_ARRAY_ELEMENT_ERROR); + result = NULL; + } else if (kindOfResult == FAIL) { + result = NULL; + } else if (kindOfResult == STRING_VALUE) { + charPtr = (stringType *)resultThing; + result = typeAlloc(expressionType); + result->kindOfTerm = VALUE_EXPR; + result->expressionTerm.valueUnion = newValue(ABSOLUTE_VALUE, + *charPtr, EXPRESSION_OPND); + } else { + valuePtr = (valueType **) resultThing; + if ((*valuePtr)->kindOfValue == OPERAND_VALUE) { + saveEnvironment = currentEnvironment; + currentEnvironment = currentEnvironment-> + previousEnvironment; + if ((newOperand = duplicateOperandForFixup((* + valuePtr)->value, FALSE)) == NULL) { + result = NULL; + } else { + result = typeAlloc(expressionType); + result->kindOfTerm = VALUE_EXPR; + result->expressionTerm.valueUnion = newValue( + OPERAND_VALUE, newOperand, + newOperand->kindOfOperand); + } + currentEnvironment = saveEnvironment; + } else { + result = typeAlloc(expressionType); + result->kindOfTerm = VALUE_EXPR; + dupValue(result->expressionTerm.valueUnion,*valuePtr); + } + } + return(result); +} diff --git a/fixups.o b/fixups.o new file mode 100644 index 0000000000000000000000000000000000000000..e82446353cc16980b2707de579a538ceec6ed88b GIT binary patch literal 44133 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 literal 0 HcmV?d00001 diff --git a/garbage.c b/garbage.c new file mode 100644 index 0000000..9166a25 --- /dev/null +++ b/garbage.c @@ -0,0 +1,829 @@ +/* + garbage.c -- Routines to eat up a parse tree and throw it away + + Chip Morningstar -- Lucasfilm Ltd. + + 4-February-1985 +*/ + +#include "macrossTypes.h" +#include "macrossGlobals.h" +#include "y.tab.h" + +#define nullFree(thing) if (thing == NULL) return; + + void +freeArrayTerm(arrayTerm) + arrayTermType *arrayTerm; +{ + void freeExpression(); + + nullFree(arrayTerm); + freeExpression(arrayTerm->arrayName); + freeExpression(arrayTerm->arrayIndex); + free(arrayTerm); +} + + void +freeAssignmentTerm(assignmentTerm) + binopTermType *assignmentTerm; +{ + void freeExpression(); + + nullFree(assignmentTerm); + freeExpression(assignmentTerm->rightArgument); + free(assignmentTerm); +} + + void +freeBinopTerm(binopTerm) + binopTermType *binopTerm; +{ + void freeExpression(); + + nullFree(binopTerm); + freeExpression(binopTerm->leftArgument); + if (binopTerm->binop != SELECT) + freeExpression(binopTerm->rightArgument); + free(binopTerm); +} + + void +freeFunctionCall(functionCall) + functionCallTermType *functionCall; +{ + void freeOperandList(); + + nullFree(functionCall); + freeOperandList(functionCall->parameters); + free(functionCall); +} + + void +freePostopTerm(postopTerm) + postOpTermType *postopTerm; +{ + nullFree(postopTerm); + free(postopTerm); +} + + void +freePreopTerm(preopTerm) + preOpTermType *preopTerm; +{ + nullFree(preopTerm); + free(preopTerm); +} + + void +freeString(string) + stringType *string; +{ + nullFree(string); + free(string); +} + + void +freeUnopTerm(unopTerm) + unopTermType *unopTerm; +{ + void freeExpression(); + + nullFree(unopTerm); + freeExpression(unopTerm->unopArgument); + free(unopTerm); +} + + void +freeExpression(expression) + expressionType *expression; +{ + nullFree(expression); + switch (expression->kindOfTerm) { + + case CONDITION_CODE_EXPR: + case HERE_EXPR: + case IDENTIFIER_EXPR: + case NUMBER_EXPR: + case VALUE_EXPR: + case STRING_EXPR: + break; + + case ARRAY_EXPR: + freeArrayTerm(expression->expressionTerm); + break; + + case ASSIGN_EXPR: + freeAssignmentTerm(expression->expressionTerm); + break; + + case BINOP_EXPR: + freeBinopTerm(expression->expressionTerm); + break; + + case FUNCTION_CALL_EXPR: + freeFunctionCall(expression->expressionTerm); + break; + + case POSTOP_EXPR: + freePostopTerm(expression->expressionTerm); + break; + + case PREOP_EXPR: + freePreopTerm(expression->expressionTerm); + break; + + case SUBEXPRESSION_EXPR: + freeExpression(expression->expressionTerm); + break; + + case UNOP_EXPR: + freeUnopTerm(expression->expressionTerm); + break; + + default: + botch("freeExpression: funny expression kind %d\n", + expression->kindOfTerm); + break; + } + free(expression); +} + + void +freeExpressionList(expressionList) + expressionListType *expressionList; +{ + expressionListType *newExpressionList; + + while (expressionList != NULL) { + freeExpression(expressionList->theExpression); + newExpressionList = expressionList->nextExpression; + free(expressionList); + expressionList = newExpressionList; + } +} + + void +freeIdentifierList(identifierList) + identifierListType *identifierList; +{ + identifierListType *newIdentifierList; + + while (identifierList != NULL) { + newIdentifierList = identifierList->nextIdentifier; + free(identifierList); + identifierList = newIdentifierList; + } +} + + void +freeSelectionList(selectionList) + selectionListType *selectionList; +{ + freeIdentifierList(selectionList); +} + + void +freeBlock(block) + blockType *block; +{ + void freeStatement(); + + nullFree(block); + freeStatement(block); +} + + void +freeCase(aCase) + caseType *aCase; +{ + freeExpressionList(aCase->caseTags); + freeBlock(aCase->caseBody); + free(aCase); +} + + void +freeCaseList(caseList) + caseListType *caseList; +{ + caseListType *newCaseList; + + while (caseList != NULL) { + freeCase(caseList->theCase); + newCaseList = caseList->nextCase; + free(caseList); + caseList = newCaseList; + } +} + + void +freeOperandList(operandList) + operandListType *operandList; +{ + freeOperand(operandList); +} + + void +freeMacro(operands) + operandListType *operands; +{ + freeOperandList(operands); +} + + void +freeMachineInstruction(operands) + operandListType *operands; +{ + freeOperandList(operands); +} + + void +freeAlignStatement(alignStatement) + alignStatementBodyType *alignStatement; +{ + nullFree(alignStatement); + freeExpression(alignStatement); +} + + void +freeAssertStatement(assertStatement) + assertStatementBodyType *assertStatement; +{ + nullFree(assertStatement); + freeExpression(assertStatement->condition); + freeExpression(assertStatement->message); + free(assertStatement); +} + + void +freeBlockStatement(blockStatement) + blockStatementBodyType *blockStatement; +{ + nullFree(blockStatement); + freeExpressionList(blockStatement); +} + + void +freeByteStatement(byteStatement) + byteStatementBodyType *byteStatement; +{ + byteStatementBodyType *newByteStatement; + + nullFree(byteStatement); + while (byteStatement != NULL) { + freeExpression(byteStatement->theExpression); + newByteStatement = byteStatement->nextExpression; + free(byteStatement); + byteStatement = newByteStatement; + } +} + + void +freeConstrainStatement(constrainStatement) + constrainStatementBodyType *constrainStatement; +{ + nullFree(constrainStatement); + freeExpression(constrainStatement->constraint); + freeBlock(constrainStatement->constrainedBlock); + free(constrainStatement); +} + + void +freeDbyteStatement(dbyteStatement) + dbyteStatementBodyType *dbyteStatement; +{ + dbyteStatementBodyType *newDbyteStatement; + + nullFree(dbyteStatement); + while (dbyteStatement != NULL) { + freeExpression(dbyteStatement->theExpression); + newDbyteStatement = dbyteStatement->nextExpression; + free(dbyteStatement); + dbyteStatement = newDbyteStatement; + } +} + + void +freeDefineStatement(defineStatement) + defineStatementBodyType *defineStatement; +{ + nullFree(defineStatement); + freeExpression(defineStatement->theValue); + free(defineStatement); +} + + void +freeDoUntilStatement(doUntilStatement) + doUntilStatementBodyType *doUntilStatement; +{ + nullFree(doUntilStatement); + freeBlock(doUntilStatement->doUntilLoop); + free(doUntilStatement); +} + + void +freeDoWhileStatement(doWhileStatement) + doWhileStatementBodyType *doWhileStatement; +{ + nullFree(doWhileStatement); + freeBlock(doWhileStatement->doWhileLoop); + free(doWhileStatement); +} + + void +freeExternStatement(externStatement) + externStatementBodyType *externStatement; +{ + freeIdentifierList(externStatement); +} + + void +freeFreturnStatement(freturnStatement) + freturnStatementBodyType *freturnStatement; +{ + nullFree(freturnStatement); + freeExpression(freturnStatement); +} + + void +freeFunctionStatement(functionStatement) + functionStatementBodyType *functionStatement; +{ + nullFree(functionStatement); + free(functionStatement->functionName); + free(functionStatement); +} + + void +freeIfStatement(ifStatement) + ifStatementBodyType *ifStatement; +{ + nullFree(ifStatement); + if (ifStatement->consequence != NULL) + freeBlock(ifStatement->consequence); + if (ifStatement->continuation.continuationBodyUnion != NULL) { + freeIfStatement(ifStatement->continuation); + } + free(ifStatement); +} + + void +freeIncludeStatement(includeStatement) + includeStatementBodyType *includeStatement; +{ + nullFree(includeStatement); + freeExpression(includeStatement); +} + + void +freeInstructionStatement(instructionStatement) + instructionStatementBodyType *instructionStatement; +{ + nullFree(instructionStatement); + switch(instructionStatement->kindOfInstruction) { + + case OPCODE_INSTRUCTION: + freeMachineInstruction(instructionStatement->theOperands); + break; + + case MACRO_INSTRUCTION: + freeMacro(instructionStatement->theOperands); + break; + + default: + botch("bad instruction type=%d\n", instructionStatement-> + kindOfInstruction); + break; + } +} + + void +freeLongStatement(longStatement) + longStatementBodyType *longStatement; +{ + longStatementBodyType *newLongStatement; + + nullFree(longStatement); + while (longStatement != NULL) { + freeExpression(longStatement->theExpression); + newLongStatement = longStatement->nextExpression; + free(longStatement); + longStatement = newLongStatement; + } +} + + void +freeMacroStatement(macroStatement) + macroStatementBodyType *macroStatement; +{ + nullFree(macroStatement); + free(macroStatement); +} + + void +freeMdefineStatement(mdefineStatement) + defineStatementBodyType *mdefineStatement; +{ + valueType *freeDefineExpression(); + + nullFree(mdefineStatement); + freeExpression(mdefineStatement->theValue); + free(mdefineStatement); +} + + void +freeMdoUntilStatement(mdoUntilStatement) + mdoUntilStatementBodyType *mdoUntilStatement; +{ + nullFree(mdoUntilStatement); + freeBlock(mdoUntilStatement->mdoUntilLoop); + freeExpression(mdoUntilStatement->mdoUntilCondition); +} + + void +freeMdoWhileStatement(mdoWhileStatement) + mdoWhileStatementBodyType *mdoWhileStatement; +{ + nullFree(mdoWhileStatement); + freeBlock(mdoWhileStatement->mdoWhileLoop); + freeExpression(mdoWhileStatement->mdoWhileCondition); + free(mdoWhileStatement); +} + + void +freeMifStatement(mifStatement) + mifStatementBodyType *mifStatement; +{ + nullFree(mifStatement); + freeExpression(mifStatement->mifCondition); + freeBlock(mifStatement->mifConsequence); + freeMifStatement(mifStatement->mifContinuation. + mifContinuationBodyUnion); + free(mifStatement); +} + + void +freeMswitchStatement(mswitchStatement) + mswitchStatementBodyType *mswitchStatement; +{ + freeExpression(mswitchStatement->switchExpression); + freeCaseList(mswitchStatement->cases); + free(mswitchStatement); +} + + void +freeMforStatement(mforStatement) + mforStatementBodyType *mforStatement; +{ + nullFree(mforStatement); + freeExpression(mforStatement->initExpression); + freeExpression(mforStatement->testExpression); + freeExpression(mforStatement->incrExpression); + freeBlock(mforStatement->forLoop); + free(mforStatement); +} + + void +freeMvariableStatement(mvariableStatement) + mvariableStatementBodyType *mvariableStatement; +{ + nullFree(mvariableStatement); + if ((int)mvariableStatement->theDimension != -1) + freeExpression(mvariableStatement->theDimension); + freeExpressionList(mvariableStatement->theValue); + free(mvariableStatement); +} + + void +freeMwhileStatement(mwhileStatement) + mwhileStatementBodyType *mwhileStatement; +{ + nullFree(mwhileStatement); + freeExpression(mwhileStatement->mwhileCondition); + freeBlock(mwhileStatement->mwhileLoop); + free(mwhileStatement); +} + + void +freeOrgStatement(orgStatement) + orgStatementBodyType *orgStatement; +{ + nullFree(orgStatement); + freeExpression(orgStatement); +} + + void +freePerformStatement(performStatement) + performStatementBodyType *performStatement; +{ + nullFree(performStatement); + freeExpression(performStatement); +} + + void +freeRelStatement(relStatement) + relStatementBodyType *relStatement; +{ +} + + void +freeStartStatement(startStatement) + startStatementBodyType *startStatement; +{ + nullFree(startStatement); + freeExpression(startStatement); +} + + void +freeStringStatement(stringStatement) + stringStatementBodyType *stringStatement; +{ + stringStatementBodyType *newStringStatement; + + nullFree(stringStatement); + while (stringStatement != NULL) { + freeExpression(stringStatement->theExpression); + newStringStatement = stringStatement->nextExpression; + free(stringStatement); + stringStatement = newStringStatement; + } +} + + void +freeStructStatement(structStatement) + structStatementBodyType *structStatement; +{ + nullFree(structStatement); + freeBlock(structStatement->structBody); + free(structStatement); +} + + void +freeTargetStatement(targetStatement) + targetStatementBodyType *targetStatement; +{ + nullFree(targetStatement); + freeExpression(targetStatement); +} + + void +freeUndefineStatement(undefineStatement) + undefineStatementBodyType *undefineStatement; +{ + freeIdentifierList(undefineStatement); +} + + void +freeVariableStatement(variableStatement) + variableStatementBodyType *variableStatement; +{ + nullFree(variableStatement); + if ((int)variableStatement->theDimension != -1) + freeExpression(variableStatement->theDimension); + freeExpressionList(variableStatement->theValue); + free(variableStatement); +} + + void +freeWhileStatement(whileStatement) + whileStatementBodyType *whileStatement; +{ + nullFree(whileStatement); + freeBlock(whileStatement->whileLoop); + free(whileStatement); +} + + void +freeWordStatement(wordStatement) + wordStatementBodyType *wordStatement; +{ + wordStatementBodyType *newWordStatement; + + nullFree(wordStatement); + while (wordStatement != NULL) { + freeExpression(wordStatement->theExpression); + newWordStatement = wordStatement->nextExpression; + free(wordStatement); + wordStatement = newWordStatement; + } +} + + void +freeStatementBody(kind, body) + statementKindType kind; + statementBodyType body; +{ + switch (kind) { + + case ALIGN_STATEMENT: + freeAlignStatement(body); + break; + + case ASSERT_STATEMENT: + freeAssertStatement(body); + break; + + case BLOCK_STATEMENT: + freeBlockStatement(body); + break; + + case BYTE_STATEMENT: + freeByteStatement(body); + break; + + case CONSTRAIN_STATEMENT: + freeConstrainStatement(body); + break; + + case DBYTE_STATEMENT: + freeDbyteStatement(body); + break; + + case DEFINE_STATEMENT: + freeDefineStatement(body); + break; + + case DO_UNTIL_STATEMENT: + freeDoUntilStatement(body); + break; + + case DO_WHILE_STATEMENT: + freeDoWhileStatement(body); + break; + + case EXTERN_STATEMENT: + freeExternStatement(body); + break; + + case FRETURN_STATEMENT: + freeFreturnStatement(body); + break; + + case FUNCTION_STATEMENT: + freeFunctionStatement(body); + break; + + case GROUP_STATEMENT: + freeBlock(body); + break; + + case IF_STATEMENT: + freeIfStatement(body); + break; + + case INCLUDE_STATEMENT: + freeIncludeStatement(body); + break; + + case INSTRUCTION_STATEMENT: + freeInstructionStatement(body); + break; + + case LONG_STATEMENT: + freeLongStatement(body); + break; + + case MACRO_STATEMENT: + freeMacroStatement(body); + break; + + case MDEFINE_STATEMENT: + freeMdefineStatement(body); + break; + + case MDO_UNTIL_STATEMENT: + freeMdoUntilStatement(body); + break; + + case MDO_WHILE_STATEMENT: + freeMdoWhileStatement(body); + break; + + case MIF_STATEMENT: + freeMifStatement(body); + break; + + case MSWITCH_STATEMENT: + freeMswitchStatement(body); + break; + + case MFOR_STATEMENT: + freeMforStatement(body); + break; + + case MVARIABLE_STATEMENT: + freeMvariableStatement(body); + break; + + case MWHILE_STATEMENT: + freeMwhileStatement(body); + break; + + case NULL_STATEMENT: + /* do nothing */ + break; + + case ORG_STATEMENT: + freeOrgStatement(body); + break; + + case PERFORM_STATEMENT: + freePerformStatement(body); + break; + + case REL_STATEMENT: + freeRelStatement(body); + break; + + case START_STATEMENT: + freeStartStatement(body); + break; + + case STRING_STATEMENT: + freeStringStatement(body); + break; + + case STRUCT_STATEMENT: + freeStructStatement(body); + break; + + case TARGET_STATEMENT: + freeTargetStatement(body); + break; + + case UNDEFINE_STATEMENT: + freeUndefineStatement(body); + break; + + case VARIABLE_STATEMENT: + freeVariableStatement(body); + break; + + case WHILE_STATEMENT: + freeWhileStatement(body); + break; + + case WORD_STATEMENT: + freeWordStatement(body); + break; + + default: + botch("freeStatementBody doesn't know kind %d\n", kind); + break; + } +} + + void +freeLabelList(labelList) + labelListType *labelList; +{ + labelListType *nextLabel; + + while (labelList != NULL) { + nextLabel = labelList->nextLabel; + free(labelList); + labelList = nextLabel; + } +} + + void +freeStatement(statement) + statementType *statement; +{ + statementType *newStatement; + + while (statement != NULL) { + freeLabelList(statement->labels); + freeStatementBody(statement->kindOfStatement, statement-> + statementBody); + newStatement = statement->nextStatement; + free(statement); + statement = newStatement; + } +} + + void +freeArray(array) + arrayType *array; +{ + int i; + void freeValue(); + + if (array->arraySize > 0) { + for (i=0; iarraySize; i++) + freeValue((array->arrayContents)[i]); + free(array->arrayContents); + } + free(array); +} + + void +freeValue(value) + valueType *value; +{ + if (value->kindOfValue == STRING_VALUE) + freeString(value->value); + else if (value->kindOfValue == ARRAY_VALUE) + freeArray(value->value); + free(value); +} diff --git a/garbage.o b/garbage.o new file mode 100644 index 0000000000000000000000000000000000000000..01dbce6843d9a767bac5872edc1b180d5fd70827 GIT binary patch literal 53605 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 literal 0 HcmV?d00001 diff --git a/initialize.c b/initialize.c new file mode 100644 index 0000000..1f9d8c8 --- /dev/null +++ b/initialize.c @@ -0,0 +1,557 @@ +/* + initialize.c -- Routines to get things going for the Macross assembler + + Chip Morningstar -- Lucasfilm Ltd. + + 6-November-1984 +*/ + +#include "macrossTypes.h" +#include "macrossGlobals.h" + +#define isAlphaNumeric(c) (alphaNumericCharacterTable[c]) + +extern int yydebug; + +static fileNameListType *bottomOfInputFileStack; +static char *outputFileName; + + void +chokePukeAndDie() +{ + unlink(outputFileName); + exit(1); +} + + void +initializeStuff(argc, argv) + int argc; + char *argv[]; +{ + int i; + int j; + char **args; + char *arg; + int outputFilesFound; + int listFilesFound; + int symbolDumpFilesFound; + char *listFileName; + char *symbolDumpFileName; + bool dontUnlinkTempFiles; + + void createHashTables(); + void installBuiltInFunctions(); + void installPredefinedSymbols(); + void installCommandLineDefineSymbols(); + void openFirstInputFile(); + void queueInputFile(); + void noteCommandLineDefine(); + + for (i=0; i<128; i++) { + lowerCaseCharacterTable[i] = i; + alphabeticCharacterTable[i] = FALSE; + numericCharacterTable[i] = FALSE; + alphaNumericCharacterTable[i] = FALSE; + } + for (i='A'; i<='Z'; i++) { + lowerCaseCharacterTable[i] = i - 'A' + 'a'; + alphabeticCharacterTable[i] = TRUE; + alphabeticCharacterTable[i - 'A' + 'a'] = TRUE; + alphaNumericCharacterTable[i] = TRUE; + alphaNumericCharacterTable[i - 'A' + 'a'] = TRUE; + } + alphabeticCharacterTable['_'] = TRUE; + alphaNumericCharacterTable['_'] = TRUE; + for (i='0'; i<='9'; i++) { + numericCharacterTable[i] = TRUE; + alphaNumericCharacterTable[i] = TRUE; + } + + outputFilesFound = 0; + listFilesFound = 0; + symbolDumpFilesFound = 0; + outputFileName = DEFAULT_OBJECT_FILE_NAME; + dontUnlinkTempFiles = FALSE; + produceLinkableObject = FALSE; + + currentFileName = ""; /* for error messages... */ + currentLineNumber = 1; /* ...during startup */ + cumulativeLineNumber = 1; + + nextEnvironmentNumber = GLOBAL_ENVIRONMENT_NUMBER; + currentEnvironment = NULL; + pushEnvironment(globalEnvironment); + beneathFunction = FALSE; + includeNestingDepth = 0; + macroOrFunctionNestingDepth = 0; + macroCallDepth = 0; + tabCount = 1; + statementEvaluationDepth = 0; + structNestingDepth = 0; + + performingFixups = FALSE; + generatingFixup = FALSE; + finishOperand = FALSE; + unknownSymbolTag = UNKNOWN_SYMBOL; + + haveUserStartAddress = FALSE; + fixupStartAddress = FALSE; + + currentLabelTagNumber = 0; + currentLocalVariableList = NULL; + inputFileStack = bottomOfInputFileStack = NULL; + listingControlCounter = 0; + nextLabelTagNumber = 1; + commandLineDefines = NULL; + + showAllSymbolsFlag = FALSE; + backwardsCompatibleIfFlag = FALSE; + debug = FALSE; + yydebug = FALSE; + emitPrint = FALSE; + freeFlag = TRUE; + freturnExit = FALSE; + listingOn = FALSE; + expandMacros = FALSE; + standaloneExpansionFlag = FALSE; + terseErrorMessages = FALSE; + lastErrorLine = -1; + lastErrorFile = NULL; + symbolTableDumpOn = 0; + positionIndependentCodeMode = FALSE; + hackFlag = 0; + + args = argv + 1; + for (i=1; i= argc) { + fatalError(NO_DASH_D_FILE_NAME_ERROR); + } else { + noteCommandLineDefine(*args++); + } + continue; + + case 'e': + emitPrint = TRUE; + continue; + + case 'g': + freeFlag = FALSE; + continue; + + case 'l': + if (++i >= argc) { + fatalError(NO_LIST_FILE_NAME_ERROR); + } else { + if (isDotMName(*args)) { + fatalError(LIST_FILE_NAME_IS_MACROSS_SOURCE_ERROR, + *args); + } + listFileName = *args++; + listFilesFound++; + } + listingOn = TRUE; + continue; + + case 'm': + expandMacros = TRUE; + continue; + + case 'o': + if (++i >= argc) { + fatalError(NO_DASH_O_FILE_NAME_ERROR); + } else { + if (isDotMName(*args)) { + fatalError(OUTPUT_FILE_NAME_IS_MACROSS_SOURCE_ERROR, + *args); + } + outputFileName = *args++; + outputFilesFound++; + } + continue; + + case 'p': + positionIndependentCodeMode = TRUE; + continue; + + case 's': + case 'S': + case 'h': + case 'H': + if (++i >= argc) { + fatalError(NO_SYMBOL_DUMP_FILE_NAME_ERROR, arg[j]); + } else { + if (isDotMName(*args)) { + fatalError(SYMBOL_DUMP_FILE_NAME_IS_MACROSS_SOURCE_ERROR, + *args); + } + symbolDumpFileName = *args++; + symbolDumpFilesFound++; + } + if (arg[j] == 'h') { + hackFlag = 1; + symbolTableDumpOn = 1; + } else if (arg[j] == 'H') { + hackFlag = 2; + symbolTableDumpOn = 1; + } else { + symbolTableDumpOn = arg[j]=='s' ? 1 : 2; + } + continue; + + case 't': + terseErrorMessages = TRUE; + continue; + + case 'u': + dontUnlinkTempFiles = TRUE; + continue; + + case 'v': + printVersion(); + continue; + + case 'Y': + yydebug = TRUE; + continue; + + default: + warning(BAD_COMMAND_LINE_FLAG_ERROR, arg[j]); + continue; + } + } + + openFirstInputFile(); + + if (outputFilesFound > 1) { + warning(MORE_THAN_ONE_OUTPUT_FILE_ERROR); + } else if ((objectFileOutput = fopen(outputFileName, "w"))==NULL) { + fatalSystemError(CANT_OPEN_OBJECT_FILE_ERROR, outputFileName); + } + + if (listFilesFound > 1) { + warning(MORE_THAN_ONE_LIST_FILE_ERROR); + } else if (listFilesFound == 1) { + if (strcmp(listFileName, "-") == 0) { + listFileOutput = stdout; + } else if ((listFileOutput = fopen(listFileName, "w"))==NULL){ + fatalSystemError(CANT_OPEN_LIST_FILE_ERROR, listFileName); + } + } + + if (symbolDumpFilesFound > 1) { + warning(MORE_THAN_ONE_SYMBOL_DUMP_FILE_ERROR); + } else if (symbolDumpFilesFound == 1) { + if (strcmp(symbolDumpFileName, "-") == 0) { + symbolDumpFileOutput = stdout; + } else if ((symbolDumpFileOutput = fopen(symbolDumpFileName, + "w"))==NULL) { + fatalSystemError(CANT_OPEN_SYMBOL_DUMP_FILE_ERROR, symbolDumpFileName); + } + } + + expressionReferenceList[0] = expressionReferenceList[1] = NULL; + numberOfReferencesInList[0] = numberOfReferencesInList[1] = 0; + externalFunctionList = endOfExternalFunctionList = NULL; + externalFunctionCount = 0; + + currentLocationCounter.kindOfValue = RELOCATABLE_VALUE; + currentLocationCounter.value = 0; + targetOffset = 0; + currentCodeMode = RELOCATABLE_BUFFER; + relocatableHighWaterMark = -1; + codeBreakList = NULL; + lastCodeBreak = NULL; + reservationList = NULL; + + for (i=0; icontext->value =newValue(BUILT_IN_FUNCTION_VALUE, + i, EXPRESSION_OPND); + if (builtInFunctionTable[i].isSpecialFunction) + newFunction->context->attributes |= + SPECIAL_FUNCTION_ATT; + } +} + + void +installPredefinedSymbols() +{ + int i; + symbolTableEntryType *newSymbol; + + symbolTableEntryType *lookupOrEnterSymbol(); + valueType *newValue(); + + for (i=0; predefinedSymbolTable[i].symbolName!=NULL; i++) { + newSymbol = lookupOrEnterSymbol(predefinedSymbolTable[i]. + symbolName, DEFINE_SYMBOL); + newSymbol->context->value = newValue(ABSOLUTE_VALUE, + predefinedSymbolTable[i].symbolValue, + EXPRESSION_OPND); + newSymbol->context->attributes |= DEFINED_VARIABLE_ATT; + } +} + + void +installCommandLineDefineSymbols() +{ + int i; + symbolTableEntryType *newSymbol; + + symbolTableEntryType *lookupOrEnterSymbol(); + valueType *newValue(); + + while (commandLineDefines != NULL) { + newSymbol = lookupOrEnterSymbol(commandLineDefines->name, + DEFINE_SYMBOL); + newSymbol->context->value = newValue(ABSOLUTE_VALUE, + commandLineDefines->value, EXPRESSION_OPND); + newSymbol->context->attributes |= DEFINED_VARIABLE_ATT; + commandLineDefines = commandLineDefines->nextDefine; + } +} + + void +createHashTables() +{ + opcodeTableEntryType *newOpcodeEntry; + keywordTableEntryType *newKeywordEntry; + conditionTableEntryType *newConditionEntry; + + newOpcodeEntry = theOpcodes; + while (newOpcodeEntry->mnemonic != NULL) + hashStringEnter(newOpcodeEntry++, opcodeTable); + + newKeywordEntry = theKeywords; + while (newKeywordEntry->string != NULL) + hashStringEnter(newKeywordEntry++, keywordTable); + + newConditionEntry = theConditions; + while (newConditionEntry->string != NULL) + hashStringEnter(newConditionEntry++, conditionTable); +} + + void +queueInputFile(name) + char *name; +{ + fileNameListType *newFileName; + + newFileName = typeAlloc(fileNameListType); + newFileName->name = name; + newFileName->fildes = NULL; + newFileName->openFlag = FALSE; + newFileName->nextFileName = NULL; + newFileName->lineNumber = 1; + if (inputFileStack == NULL) { + inputFileStack = bottomOfInputFileStack = newFileName; + } else { + bottomOfInputFileStack->nextFileName = newFileName; + bottomOfInputFileStack = newFileName; + } +} + + void +openFirstInputFile() +{ + if (inputFileStack == NULL) { + inputFileStack = typeAlloc(fileNameListType); + inputFileStack->name = ""; + inputFileStack->fildes = stdin; + inputFileStack->openFlag = TRUE; + inputFileStack->lineNumber = 1; + inputFileStack->nextFileName = NULL; + } else { + if ((inputFileStack->fildes = fopen(inputFileStack->name, + "r")) == NULL) { + fatalSystemError(UNABLE_TO_OPEN_INPUT_FILE_ERROR, + inputFileStack->name); + } else { + inputFileStack->openFlag = TRUE; + } + } + input = inputFileStack->fildes; + currentLineNumber = inputFileStack->lineNumber; + currentFileName = inputFileStack->name; + currentOperandNumber = 0; +} + + bool +isDotMName(fileName) + stringType *fileName; +{ + int length; + + length = strlen(fileName); + return(length >= 2 && fileName[length - 1] == 'm' && + fileName[length - 2] == '.'); +} + + bool +parseCommandLineDefine(arg, name, value) + char *arg; + char **name; + int *value; +{ + char *ptr; + char c; + int base; + int start; + + ptr = arg; + while ((c = *ptr++) && (ptr-arg)name = name; + newCommandLineDefine->value = value; + newCommandLineDefine->nextDefine = commandLineDefines; + commandLineDefines = newCommandLineDefine; + } +} diff --git a/initialize.o b/initialize.o new file mode 100644 index 0000000000000000000000000000000000000000..6160d5ac8cbe3ed8020bcb306ccb2316e030fb19 GIT binary patch literal 51325 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 literal 0 HcmV?d00001 diff --git a/lexer.c b/lexer.c new file mode 100644 index 0000000..fa03963 --- /dev/null +++ b/lexer.c @@ -0,0 +1,542 @@ +/* + lexer.c -- Lexical scanner for the Macross assembler + + Chip Morningstar -- Lucasfilm Ltd. + + 3-November-1984 +*/ + +#include "macrossTypes.h" +#include "macrossGlobals.h" +#include "y.tab.h" +#include "lexerTables.h" + +extern int yylval; +extern int yydebug; + +static char lineBuffer[LINE_BUFFER_SIZE] = { '\0' }; +static int lineBufferPtr = 0; + +#define getNextChar() (lineBuffer[lineBufferPtr] ? \ + lineBuffer[lineBufferPtr++] : \ + readAnotherLine()) +/*int getNextChar() {int c;c=xgetNextChar();printf("read '%c'\n",c);return(c);}*/ + +#define oopsThatWasTheWrongChar(c) { if(lineBufferPtr) \ + lineBuffer[--lineBufferPtr] = c; } +/*oopsThatWasTheWrongChar(c)char c;{printf("ungetting '%c'\n", c);xoopsThatWasTheWrongChar(c);}*/ + +#define isAlphabetic(c) (alphabeticCharacterTable[c]) +#define isNumeric(c) (numericCharacterTable[c]) +#define isAlphaNumeric(c) (alphaNumericCharacterTable[c]) + + int +yylex() +{ + int result; + + result = lexer(); + if (yydebug) { + printf("lexer returns "); + printToken(result); + printf(", value=%d (0x%x)\n", yylval, yylval); + } + return(result); +} + + int +lexer() +{ + char c; + + char skipWhitespaceAndComments(); + + if ((c = skipWhitespaceAndComments()) == EOF) + return(lexLiteral(c)); + else + return((*lexDispatchTable[c])(c)); +} + + void +initializeLexDispatchTable() +{ + int c; + int lexIdentifier(); + int lexNumber(); + int lexLiteral(); + int lexCharacterConstant(); + int lexStringConstant(); + int lexOperator(); + + for (c = 0; c < LEX_DISPATCH_TABLE_SIZE; c++) { + if (isAlphabetic(c) || c=='$') + lexDispatchTable[c] = lexIdentifier; + else if (isNumeric(c)) + lexDispatchTable[c] = lexNumber; + else if (isMacrossLiteralCharacter(c)) + lexDispatchTable[c] = lexLiteral; + else if (c == '\'') + lexDispatchTable[c] = lexCharacterConstant; + else if (c == '"') + lexDispatchTable[c] = lexStringConstant; + else + lexDispatchTable[c] = lexOperator; + } +} + + bool +isMacrossLiteralCharacter(c) + char c; +{ + return(c==':' || c==',' || c=='@' || c=='#' || + c=='(' || c==')' || c=='{' || c=='}' || c=='[' || c==']' || + c=='\n' || c==EOF); +} + + void +snarfAlphanumericString(c, buffer) + char c; + char *buffer; +{ + char *bufferPtr; + + bufferPtr = buffer; + do { + if (bufferPtr < &buffer[MAX_NAME_SIZE]) + *bufferPtr++ = c; + c = getNextChar(); + } while (c!=EOF && isAlphaNumeric(c)); + *bufferPtr = '\0'; + oopsThatWasTheWrongChar(c); +} + +char nameBuffer[MAX_NAME_SIZE+1]; + + int +lexIdentifier(c) + char c; +{ + char *saveString(); + int hashValue; + + snarfAlphanumericString(c, nameBuffer); + hashValue = hashString(nameBuffer); + if (yylval = lookupOpcode(nameBuffer, hashValue)) + return(Opcode); + else if (yylval = lookupKeyword(nameBuffer, hashValue)) + return(yylval); + else if ((yylval = lookupConditionCode(nameBuffer, hashValue)) != + (int)NOT_FOUND_COND) + return(ConditionCode); + else if (yylval = lookupMacroName(nameBuffer, hashValue)) + return(MacroName); + else { + yylval = (int) saveString(nameBuffer); + return(Identifier); + } +} + +char numberBuffer[MAX_NAME_SIZE+1]; + + int +lexNumber(c) + char c; +{ + int base; + int start; + + snarfAlphanumericString(c, numberBuffer); + if (numberBuffer[0] != '0') { + base = 10; + start = 0; + } else if (numberBuffer[1]=='b' || numberBuffer[1]=='B') { + base = 2; + start = 2; + } else if (numberBuffer[1]=='q' || numberBuffer[1]=='Q') { + base = 4; + start = 2; + } else if (numberBuffer[1]=='x' || numberBuffer[1]=='X') { + base = 16; + start = 2; + } else { + base = 8; + start = 1; + } + yylval = fancyAtoI(&numberBuffer[start], base); + return(Number); +} + + int +fancyAtoI(buffer, base) + char *buffer; + int base; +{ + int value; + int digit; + char c; + + value = 0; + while (*buffer != '\0') { + if ((digit = digitValue(c = *buffer++)) >= base) { + error(DIGIT_OUT_OF_RADIX_ERROR, c, base); + return(0); + } + value = value*base + digit; + } + return(value); +} + + int +digitValue(c) + char c; +{ + if (isNumeric(c)) + return(c - '0'); + else + return(toLowerCase(c) - 'a' + 10); +} + + int +lexLiteral(c) + char c; +{ + static bool passedEnd = FALSE; + + yylval = 0; + if (c == '\n') { + return(EOL); + } else if (c == EOF) { + if (passedEnd) { + return(0); + } else { + passedEnd = TRUE; + return(ENDFILE); + } + } else { + return(c); + } +} + + int +lexCharacterConstant() +{ + char c; + + yylval = getStringCharacter(input); + if (getNextChar() != '\'') { + error(UNCLOSED_CHARACTER_CONSTANT_ERROR); + while ((c = getNextChar())!='\'' && c!='\n' && c!=EOF) + ; + } + return(Number); +} + +bool escaped; /* true if last string character read was an escape + code. */ + int +getStringCharacter(input) + FILE *input; +{ + char c; + char *numberPtr; + int result; + char controlCharacter(); + + escaped = FALSE; + c = getNextChar(); + if (c == '\\') { + escaped = TRUE; + c = getNextChar(); + if (c == '^') + return(controlCharacter(getNextChar())); + else if ('0'<=c && c<='7') { + numberPtr = numberBuffer; + while ('0'<=c && c<='7') { + *numberPtr++ = c; + c = getNextChar(); + } + *numberPtr = '\0'; + oopsThatWasTheWrongChar(c); + result = fancyAtoI(numberBuffer, 8); + if (result > 0377) + error(OCTAL_CHARACTER_TOO_BIG_ERROR, result); + return (result % 0377); + } else + return(escapeCodes[c]); + } else + return(c); +} + +char stringBuffer[MAX_NAME_SIZE + 1]; + + int +lexStringConstant() +{ + char *stringPtr; + char c; + + stringPtr = stringBuffer; + while (((c = getStringCharacter(input))!='"' && c!='\n' && c!=EOF) + || escaped) + *stringPtr++ = c; + *stringPtr = '\0'; + if (c=='\n' || c==EOF) + error(UNCLOSED_STRING_CONSTANT_ERROR); + yylval = (int)saveString(stringBuffer); + return(TextString); +} + + int +lexOperator(firstC) + char firstC; +{ + char secondC; + char thirdC; + int op; + int oper; + + secondC = getNextChar(); + for (op=0; operatorTable[op].first!='\0'; op++) { + if (operatorTable[op].first==firstC && + operatorTable[op].second==secondC) + break; + else if (operatorTable[op].first==firstC && + operatorTable[op].second=='\0') { + oopsThatWasTheWrongChar(secondC); + break; + } + } + if (operatorTable[op].first == '\0') { + error(UNRECOGNIZED_SOMETHING_OR_OTHER_ERROR, firstC); + return(yylex()); + } + /* kludge to deal with the two three-character operators: */ + if ((oper=operatorTable[op].token)==RIGHT_SHIFT || oper==LEFT_SHIFT) { + thirdC = getNextChar(); + if (thirdC == '=') { + yylval = (int)((oper==RIGHT_SHIFT) ? + RIGHT_SHIFT_ASSIGN : LEFT_SHIFT_ASSIGN); + return(ASSIGN); + } else + oopsThatWasTheWrongChar(thirdC); + } + yylval = (int)operatorTable[op].value; + return(operatorTable[op].token); +} + + char +controlCharacter(c) + char c; +{ +#define CONTROL_CHARACTER_MASK (~0100) + + return(c & CONTROL_CHARACTER_MASK); +} + + char +skipWhitespaceAndComments() +{ + char c; + + while ((c=getNextChar())==' ' || c=='\t' || c=='/') { + if (c == '/') { + if ((c = getNextChar()) == '*') { + while (TRUE) { + while ((c = getNextChar()) != '*') { + if (c == EOF) { + error(UNCLOSED_COMMENT_ERROR); + return(c); + } + } + if ((c = getNextChar()) == '/') { + break; + } else if (c == '*') { + oopsThatWasTheWrongChar(c); + } + } + } else { + oopsThatWasTheWrongChar(c); + return('/'); + } + } + } + if (c == ';') { + while ((c = getNextChar()) != '\n') { + if (c == EOF) { + error(UNCLOSED_LINE_COMMENT_ERROR); + return(c); + } + } + } + return(c); +} + + int +popInputFileStack() +{ + fileNameListType *oldFile; + + if (inputFileStack->nextFileName == NULL) + return(EOF); + oldFile = inputFileStack; + inputFileStack = inputFileStack->nextFileName; + qfree(oldFile); + currentLineNumber = inputFileStack->lineNumber; + currentFileName = inputFileStack->name; + cumulativeLineNumber--; + fclose(input); + if (!inputFileStack->openFlag) { + if ((inputFileStack->fildes = fopen(inputFileStack->name, + "r")) == NULL) { + fatalSystemError(UNABLE_TO_OPEN_INPUT_FILE_ERROR, + inputFileStack->name); + } else { + inputFileStack->openFlag = TRUE; + } + } + input = inputFileStack->fildes; + if (includeNestingDepth > 0) { + includeNestingDepth--; + currentLineNumber--; + } + return(getNextChar()); +} + + void +pushInputFileStack(fileName) + stringType *fileName; +{ + fileNameListType *newFileName; + + inputFileStack->lineNumber = currentLineNumber; + newFileName = typeAlloc(fileNameListType); + if ((input = newFileName->fildes = fopen(fileName, "r")) == NULL) { + fatalSystemError(UNABLE_TO_OPEN_INCLUDE_FILE_ERROR, fileName); + } + newFileName->openFlag = TRUE; + newFileName->nextFileName = inputFileStack; + inputFileStack = newFileName; + currentFileName = newFileName->name = fileName; + currentLineNumber = newFileName->lineNumber = 1; + includeNestingDepth++; + if (statementEvaluationDepth == 1) + oopsThatWasTheWrongChar('\n'); /* hack for line #'s */ +} + + void +resynchronizeInput() +{ + char c; + while ((c = getNextChar())!='\n' && c!=EOF) + ; + oopsThatWasTheWrongChar(c); +} + + bool longLineFlag = FALSE; +static bool previousLongLineFlag = FALSE; + + void +saveLineForListing(line) + stringType *line; +{ + if (!previousLongLineFlag) { + putw(currentLocationCounter.value, saveFileForPass2); + putw(includeNestingDepth, saveFileForPass2); + } + previousLongLineFlag = longLineFlag; + fputs(line, saveFileForPass2); +} + + void +saveEOLForListing() +{ + putw(-1, saveFileForPass2); + putw(includeNestingDepth, saveFileForPass2); + fputs("\n", saveFileForPass2); +} + + void +saveIndexForListing(kindOfStatement, cumulativeLineNumber) + statementKindType kindOfStatement; + int cumulativeLineNumber; +{ + if (!amExpanding() || !notListable(kindOfStatement)) { + putw(kindOfStatement, indexFileForPass2); + putw(currentLocationCounter.value, indexFileForPass2); + if (amExpanding()) + putw(-cumulativeLineNumber, indexFileForPass2); + else + putw( cumulativeLineNumber, indexFileForPass2); + } +} + + void +saveEndMifForListing(cumulativeLineNumber) + int cumulativeLineNumber; +{ + putw(MIF_STATEMENT, indexFileForPass2); + putw(-1, indexFileForPass2); + if (amExpanding()) + putw(-cumulativeLineNumber, indexFileForPass2); + else + putw(cumulativeLineNumber, indexFileForPass2); +} + + void +saveListingOff() +{ + saveIndexForListing(-1, cumulativeLineNumber); +} + + void +saveListingOn() +{ + if (currentCodeMode == ABSOLUTE_BUFFER) + saveIndexForListing(-1, cumulativeLineNumber); + else + saveIndexForListing(-2, cumulativeLineNumber); +} + + char * +myfgets(buffer, length, stream) + char *buffer; + int length; + FILE *stream; +{ + char *result; + char c; + + result = buffer; + while (length-- > 1 && (c = getc(stream)) != EOF && c != '\n') + *buffer++ = c; + if (c == EOF) { + *result = '\0'; + return(NULL); + } + if (length > 0) + *buffer++ = c; + if (length == 0 && c != '\n') + longLineFlag = TRUE; + else + longLineFlag = FALSE; + *buffer = '\0'; + return(result); +} + + int +readAnotherLine() +{ + int result; + + if (myfgets(lineBuffer, LINE_BUFFER_SIZE, input)) { + if (amListing()) + saveLineForListing(lineBuffer); + lineBufferPtr = 1; + result = lineBuffer[0]; + } else { + result = popInputFileStack(); + } + currentLineNumber++; + cumulativeLineNumber++; + return(result); +} diff --git a/lexer.o b/lexer.o new file mode 100644 index 0000000000000000000000000000000000000000..67dbdfd98dcd19ba44489cc4321f3668bc5a6d89 GIT binary patch literal 57423 zcmeIbdtlX9l`sBH2oNBYlxKLA!>a{)3OOh5gxZ88Kp-SBj~0|M3CRhGBspmwEohw{ zwO6ZF#mZIGsz*v6<8-`LJKm0VY@FK}nYo=28LUjF(}@);R;HqtQB;)QXRW>VcdzpZ z)cbS(yHR>RXYIAuUVH7e*M5BW{+^5}8Ph#4kmq?>*&hD|kC@M;pn2Yu+pb)BkJokd zvpDkNI(`RPDiyii|Gh^QML?_zexdE>dpUgM?*~=E&w0TH7mD%Af zz~|}Acmi*3%$q{_4(A5ECv&~*cYk{#``zb~b;x=@%ii?tmDsV{uFQ>j)A@VjvsWs; z%&CMS=Q{d41=^8ZZ^kD##4{J;`_Xv;?{6~4b54T(`SD8D@r{%@j{2TNU1G-qv4t`3 zty~_yQ(YdM+u@zw;mv>@Waze>+5CM<2jc`tze)s2D7BG8{&823u>`L%@;-Y;*gT!Or-iT@IKVvhxGvikl8 z-#@mgBh%K8+Um&MxOaM$Hv@SVQXZ+}Dx2pTb(}$YsE&^WJ2GzqesunXw;rF5F9>+& z*2Lz$hO{qE?Z|lTre`nbK6~X6;!kS-aq__no8sF}HpaI-2>*y3>nMkf%82(gXrIXS zX2y<91VJk#+8NM3o$KYq9`2|FZ4=R61}&cJ&50cktOjiZ(Ov=Vc&>MS?09?~Xlse~ zDrk@Adh=qB1lEHVAlhr7J(24zh&>X2CumEF_Bv?r)kU#K1MdQjZSxDzp33zW#~zKp z6*TS}zXa{+TyH7t{3oF0P~P8wb~x8t4!@cS8vF4n(8y|R+dRA{ufDQ#JQsd-J@n+hMZS7AEAAc7if2%Jo?SEHJ-#NMaWn827j$^%cXMmlu2V-YbwflhQ7N_O)DZNg43divr$n8pfBQ%;j^R zz4Bd3Cm$c*VB(C5J?!V?s}xrrT-A|5{(5Rv+*^dtPt2WQKRC0Ya#oT*aZI!RWPSbK zD_8ypm32M-CB!n=#L`Ydk4mHyALTo_s>Ajl;>q$*+&j5CV9T<3Lde5DX!WZEpRUj0+?Dy@@qI3h zpG{`JcB{+D9RW}JX}7uPQxn1=SO}T{?}p5Ig40oF;t`W9F|Y z-Vhyp>=XD-emRHp!1qt7G}PhJkxXyKX|xC8_RE&%8g)pC<<>4Q?5LcHI?O^H*oGAA z53dT4FS4C%Ot)j{$(@yRkbcJ-Esy+td{qE*0~=@KG;Z5|F&lEYFS#-1UW&uHR4>~{ zrQb>(whi|svYU+uXvZAL^6PL7{kSh#`LKI4m1kwKKW3_Uwj(wRI^@7c9E+EN_r)n4 z9>s35%ZsZgy!h&ljMc!$=685!>%HqA&GqI&2iCdLo4SYOgO(jTK5-M|@Yo3bGb=&Y zb+vKP&T(v++&42Pyia6KWKjQl0Ws#&t0uU7n&V8MU5@2?xvEU=>!4+04v_cA=6K#& z%;88c(Shr74s)|F=6dsEk93e9^St3aXf&3@9=SqeMHcA?Upqsee@K6^ZBKQwb5QDw z%I8=Iju%q`-q9(646^N+)g9jFRtGXx0@J*W#=_&6FQ~e)T|vvHI=u>gW$v&SzVlh5 zr}K?JetTy9h{~Y$d==#@8@>(Y^E`#-j_0Skx#P)Qu|?v?vng)~|1M0!yn9+8qk!;@ z9o|zn1~N*3X})-}A+{9tW!qPJS$|J?D!q(P&?o4<^mz&O{(7#rEcRGOKH|x4qS0Ji z#(`@Os-;2m2%k+By1cCJlr<=QgqK`IZl>~ou*y<+_g z^V3V?w^Sy_fHyGrfTLpWVe5=BEBoFnzyAo=>858dV$O9j_Hf6QEQuB9gIS2F7b~HI z)cYdxU~OZ*Lr-q6mthN<$J#!A5`7$L5^tdQ8yLH-PBcalruhfvKLu3o$2SD>K3?9D zcWTqKzm;)$6>Q3J4(;<>X&-;y`XXqb%k^f*9=_tQ$yP$nL>A9Ia*>zkc(evM3*NKA zO7B(RN3$j}UNvLK1eHr`opCtpYv7T&wqM5UpqaTgulsELol=Q>l-JhBe#iVWy9o4O z+=%fucV*!9OCzJZbpWPD3crMaai{0a#yN`ZCs+uyx*7H+Ez^In7&4Hm9}bFB`liPt%&`u(u5Sb8Q>_ zVRLuWf6#WkKB9Wb8s!rDCePJh1`T!0r2g=QU?AgjQ^s>`zc{;doX0-sFb_Jg57O9= zem1oddXi4}Uis~}=@Vt}-1Vxq#=PwX^xN36A5^1lxW8fTi$1)P=BMSlj(<+Q6*Hn!aa+N)U;-np!CkH*JyYdbtU$9`gMJcIUV&##^E z=Zls2PP&BfkLKCGm=?%Jd5fVh&(Cc=PG*{Q--B~IJe!Bwi`FaHXUZbqKpq~)Y@Sod z10Psx`B85kmux!Xf5xd*foyAs7c%2ncFktjj*vS$OYI5K7>#wczn-;ukF1JkkPT0- zn(*v8iDZ0w9`xIZ`5*Ly4S9}g?K;`q`y}?cp{uMZGM*y);QKY(`~vnfY~8GFP`@15 zV16ZJkQ|!Rp2Yr#^>s_9{ZH(@Wl9re#OiU6<{cAju;vEsQP};}HSrvp*S)$nz<%=D)DG{9*yko+d2Ov(kG(z> zdwP#dWT0LDuj0v3jP+^uH=m|`B5fz~ssI1$_>3K7->dX_UbDM#koR{@41M;>zfoSR zllaOTj+gIFd>$0H`(RogY{+YPOSAq_iE?$>SEJK@uJs-2cQ$Xj@(<_UcI9fabbiu_ z*1gI6>Ex1+)Bc{VhuDhe&^AA46z{mN+5QRI%q-a_r8-#MDL;7ElMT|<&6Z4kLu9jbeA>2X8}2trdGDdT)?P^ay|n@4j-`>yb6@K_7jKH!Q(IFkq&?dQ z@oeN2eCkMMM+Wv=GP30P*9+6*^=C52y`$LUI4gOm)17G zYYn{!cq-Ws^zHc1tQ&7+T*}z-Ok=W_Q9<+#jy?rVi@%JmM8BCPSYAdWW5>hK8bPli z`Ykk|dKpcO9S=V<2fdc)8;QlsXdt}F@nq3l4fJh9-@KXe7RH9>HpWEuGTub^RzoMw zSq!}ls;~DZL$4zGn~2lPsAf#i%c#VEX1&eu5P$aD-iH5ryu~_;p_frkJoh-B>G#~j zJjF~W=w*}<{!@c@5+(&fuP4mV{AZSzkvS!6>a^+EGiJ`pnSI@y-0SDgo4;V;qP)dR zmM&Xo?pSyk+C2{7|@{u&B7Cw5+^h^Q~{Xt+HxMbxrNoZQJX1 z?5y9_(Af0m=9bpB+wa)D=PhsD`zLQ}@950#>Ry_&zqjx02l@wQMu+a4Ju+kLuDcH& zddEBOdDoxb8+-SA-h1DFd*A!-|G)=7^uUKd^3lT|d+_5&{`)6BdGu4C{>($4{oLo{ zUpV&g@kbtg?D0SQ;-5e97hn1xPk#9;Uw!H?zxF?${;RKl{2Km70K|M8!`bMm{V{`vIxUiki*e|hm=U;4L~|9#>Iul(@rk6!)pxu3lD)ARrF z`p+)>{1^Y{;(z|~SC@YMo8Mmk-S4j`Tl_!x2U?&%axgL+7>+%n-J-B|RH;n(yB&j$j6ue)=F9ZIN;GpMC%l5q0m+(Cw7{1B4(DUB=zAIO* zJP&%M=Y5LsI56S_@voT<3|}UG#^}@2t^8JCD}T45?^W~;kspVg6P{OR^P;>u$(sQ^ ztAw5r0Je0LYxyab`1~lB&PQdPMn6NjSwuNnh|Y&R6_}ioewG&qg_!n+-qX zR>hC{`to6Cvcq*}!H+UXKH({sq^-{ZLpN?~V5q}wy6PEVd?7mHJjb84O!2Q#^mU33 z{mC~tFZB22jC$T9_oEQ}WgP_mkl-Uq&QT@jaYcVZ(VtTErxhJ~`{j-sI_q%G^FC_J zJr8Wly`<={gQZV}T6e!!S@$JADpcel#htLXiTeo)E0N6Ea;^KK@YpiO;1IIeeqRTsNo#)lu4?g@&3j&M%ryIlijI2ubkvLG6A$$F=_eE&y7}}=jy^rd(WmDsdXvzh|8%sM)qgs4v$1Y^zpL-` z%kX{J5OqhXE_&)-F}%1`DhoeBk6G2<)tyq=A8-q+SoD^cDDR8mnr@= zioQY;75_oSA5--E6kWCTtiy)R zx}8w`u$5mg*vhucEV30U%KWIawcD)oieK4hmav{%j5z8xsHGKe8)d~jiRqp z^n67xRP<6qC;78C8#?3duD-MDU43UCG=1b3_k$n*rXjZc0<_s;hm|Bp?7$d0H-nG< zW={Zrh@m(8oQnyw&%2m#9dxk%e_f^Xx9cF2V%pF5Vh-_ylX=~fPUdw_K{oL~-|NO* zY`G40wqxRT7fpT1SFgKd>dW}Dp;O)GK#aBX9I|b;X_q;9j(<)-(aGl0UUPzm&T`1+ z(q41=4V});&lxgw#t$iaT+yEwI=0Q{oD@26ZkFTEg;Tp;H}m zTMeCYx1#qdI_U;E%rmO!2MwL-m3xn&Gk)68SqG%~`n+V?>u0dd^^nK9Ed$OG9>StC zm36)7%y_fmC;8V`8h*y4zvy=TZbN7O4n?PWNn2bmHs`!zbH*o}Z(I*MTi>|;B_(G< z$+@8D7Zv@oqtEpmeXg_-l{J^@EaLnqzlXB#@>Tt%O+ z=*tY9%9@Y1@#Uai6mx!xddw&NA&cc4QF)~V@zwb!44v~n zZ|H;iw{HGQF8O48I@n2Bfi1mM(Kjo4r5k@2)wuC@ z(RR;!Gju-pG<0rKI3=6!bIB&Ur66JLkck z)OJ6HZ5HF7ZTH2wPKU*i>(gNq+jfidou4l*bbh|L#_7BmcCfZx3_I91T@1Z#n=XbO zeEMER@9?~j-S6?=;%;E^fyJYyzSJ&@51RTi2Ct1{iyu(*BZ_`h(H}B&vj5_^p)(#= z{9;d*e?sv;ulOev|5-z4{_~1{LD4T6I+u0X&iQ)*Ic{+yLBUbYtAA z^6pl7_lj=E!5@R4-4Dg_xAZ<>vFFkwp7(i6KMHK=kK=T&r9S~|>EoDFQhh5S2X^ka zJTC!To(a)80G@NMeV4+{wtbhv&VJsDD(@x9o9%haJg4)rET{9b`A+9$c~0kL>zvNZ zU~{YUGT6|TwQRd9YZ>fGzVySVP*#WH=~g_w!UNkZdqD9VRy?pF%jpMCT=5)NJdX>{ zZty&*>V>jxTP%A{)$4?+*BMnW*x9ewMOD@%Rn}!GE6eki=Q^I{^BvFfJj3(KIq;Oa zIl%JGZVs?~FHYv%k4C`X@(y5W-{qr<|DfWBP3#BBOQD*2BaI>pizPZ&DmCl&uwivP45cUGXDcHCJpq3CB79dfO$R-AXXT5(a)FFCq7 zGXR6pAD`j$>2LuV1UjUf9}f7c*gK7IRg4gCI76#mlVF@a3-HsGBPvQ z2|WkTt*QhgDRaB%ISQ<7ivu!9#ojsb@Y#F*>Sd0qyzf-_e!sv51CV>E~L*CKI{x~h{@=j|M47O>?p3~l|c*JkP;!XQAMSoi1Z!7$Q!si52-k%%Y==u0` zZyJf?y@Kg{{tI8A|8(WU)60Yh{bjo7Nq#<^@8SsmolgGrce!$>A2t3-dzI54GxUrg z@YfVSpOJ!`9MI1Q4+@xm-snlsyQfQh1DBW0XRHi=_C~|A>>%hhuH0-JD^Qng8y^U( zIFS7@#s7%Hf2Ht03Z`f{*=N` zDSSfV7vJOAznq^sJlg}$e4IUC^BuD+-t6~*o@MB>KLMN}_|FvmFBSb;z?s7HUB&YQ zg)cas>uMbRx}(4%|GFRdr$OQGJN@UJcl6v(JA8ef!elF{3ue8Z{k#5ufu3V@ zp1TA%TW~+H*ks;y3g6`T=Y3S+zW^5b^Zwr9`R{OeK^bts$X{5b@SB09+=XOMi~kW= zbXYW?@CO~wqVGAJ_XXfwBY*LBg;iY^zuWOIKI`z3>5hNNdmLVRgTm#&qR&!lQ^Cu~ zf23Z^GZm%@y4ZF(>1^@iz*5KMzjpWr@_Di04Yw%zU5fr8MOQv{!;citZya7hbrG2> zs4qylfmy(!Pk`)W>D+gW4Fl9SC2!!I<5}4PEOlQw=y+DX$NA(+>W`9l)k1}-9|>Li z;i~6A7kyTT6>fI?tE0fuM^^tgM_;p6;rBYcR_Sn~;<>Q~JW}5qsoz=rRfYcnSoFM! ze9z*q083l1qkd}fII#HM`sE6f&x`!^Z&CPeg+HnA*Bst(y~06YvCjswp~b4dY@oj2 znYP<-9$3n~`8HtD|K=e@|AxcC#R@Ckg5LpM%DQC>u+;Gu>YGy5M(R5vev0r{=ip@8(XnCc>SEBLaapHle$I9#|8SmYN`92Ttm zPSM|iF7+)AE4&q0$}Rr5!qmqt|MS4orX>_JMScnKTl}w%zjQaS$Sggi@V_X0(eanj z96P-_`^yI^5Q;=oH(%wIc942)qk1hf zF=zX~DEu>r>t-lS?HDlpJIJ3U?~YZ#;)gqEeklEP$7x{EZD+CL*-7&v;onI-qEG$K z81{#Z{Ce^wq3Q5@ZK_q|Ab>O?MCLOy`#Ysz|e=DgAD%L8ecbl;IP`0zZx(A zqP)S^V&K7joXeCnj`co1SP$?(l#g!$#-1C?S%;6H;Pv?2EO-Mxw+p89UcwVb<|tvv zyagY?gTE5p?h|?lpBf+byl7So^@46!h-ci$0iER(u z%|W^JcZvQ}gDZTAI3o)@n_?+8Av*JKgGv@}2evk;1BN)}*#X=ucqj0Eg6n}F7rYC2 zTyO*MS;39K7X>$=%2xiHf!7JW1sJldKABwB1luR`9-+74D{!=A4f_D?*F|^7A>3r+ zyl(-I)s65G$@?b?zYTl;4P=srFRo}a})Osq>5=*;sDBw74UV5=wEf$jh?&%1yN1^+2< zrQmykxgBe8bsYGh&=Df0#s$9@_zA)H0Yhh&`99zY!S4s=azQ}dr)3HK0|rMa&Pd&d z=C6U0pwIWbp|$bEx}$Fqo#hh->(IuSU-zLh!Ccn3DGNNzf5h-J{_nu0LjMFXe46Q> z1l}$9C~&vnPXQx8^L!c@zQ_18z_#w7O?ye`p9MZE_;bJ)1%DoU{8pbha8T&SfHw<% z7`R68Bf#~79|ayFJi+yvevi-}108s%7J{>Y9{|2R?%QoB0t~tz1OLMCu>ORRJalKw z+3;P0VZ)&h08=0Nm50A^Q*N9v6#R3PXh-9e-F4+FyzgE2y3euO+tSWbl{;grYNzMo{qYfGz*;fjfi_TjtzvFom(4xZq6O zP01EK1vpo57O?0*k5FfK2z?sxkl^XSF~Ku{j|!dz%z936-Di&rJqL8)JNE>P4}*N? zps_hUTO>PV%mt6eFM;R%F=J=c^UkA!QGe^(v%$l87b364dBEp{z8LpinglNaw)!sx zJ}C5Mz;VILfu9h31MmsL6I_?;P78en=)iZzjsA32lztABk_psn1;NyaeflmuA0X{3Z9N6kpVeYc9KAVA$2+x~<9~XQZ@JYc{z_yL5 zao%pe&})E^-`aU@x6o@r2fp*d8n*4+QO_IBjwjlA2Y5hd9SGkic$dNrzz-qs^&-c% zZ!_o`KMkI6%x@!Wf4XfRr@+={?gc(8^cc>_&9v`HbOV4Bhjd5c+3k*@MXbYz*$VI^D*E&p+5}FDnjSu zz@Y;|}Xbl~AHnEKLLHP#cf1UwF&XJRS+Ycc4||0VES z{3OmMw-SAV%UbdPVd(i~(1C}a3$Py&b@Nwd8V7{_x1d}6cff^0 z|2A;F;1j^zkXbA;`+=L|roJ`62Lx{y{(k~Lc(`1`F~Q$a81-0sTIiV9Ewyzyh3$7D zlWqSQc(dT|0q+(3ec&OK`+lPjo%0zv9{2U(yf1+VbRXX@_}@Uc_+{XSg#PcqXk+G| z06s7H6`c9Z5&T2o0LmISu0d95Vj{GBbc52mT!hz%ZXTN)xLrV3a$$1b9AhJ^qnxe{J}EJPw}q zG1C_=1D6Q?E!e$r_W9-bVE*4Buf@LyJ|XlgICtD_a3(%(xKA+jx#6f_B-{`e4Bc*c zLhw}JX9Q0J7T?I64tz=InAg$yWzr#YCNR~9@GRhEgeO?f73&Ct4qn2ex2<72(0NOy z=Yp!;t~6{m`L)WftxN{VxZtXibHsrN;jSUY+21mD!4KiCp=K#0{BL_$8 zJNHHUTRZnRj1BCI414W(5mDn1<&EMCDPP|=LUI~=dhorkJ5t-z6X_b=+TSS^GH9rC zWF%ZS*c~~zwXZ*7#1D;)^wtdyjg1niWwf*F0E&!`l0c&+K1U-1P>VgWbD2yN06>)gO%>7#remMtM{9!N}I=uvh@q?~UGF z)!%QLY(&&!`zI>j9oaVq>+}tF^^bK&64OQ_!y}Q};o<1;uE@wp=YDE+r~(Z~(1^{E zo(S5hi>;0X;zQ#_2S=|K`i!ee$u4&5Cc z?oN=uwG&OztxMc8hW4a(X9HA62fJa$=pcC?xtUa@hrFn&yPMS9#YsKzQdnXH4al|e z+V_q1^^evKS{D%pV2T4KcYpNm$Z&P%NFgbpvIz^)=Ba zg4Xpz0(yE zOyH;}-Zo87SATQ_R)iF&XR{+ZC@lu4qc#p(11EN>=)Sj8OoDGWj*YTMAuoa~g4Rd` zeu9A36CEC~bw`(gHy|n_afT+B*I1~TqROV z5rlfJ_zO8nqUpN(_V7z1Z|V|0`M4q>>iwn=k;p zgc1-Ln<(mg?dTu<`^GRnpiS#Y=f0jkjw$F%rZt;J;i7%04-XG6XL7$07e+X|t1mh> zQlHQv5e7|glKwI_cwjJk_n-;K7{X}O80od`v=1Z5-JOVk7%wmu^r08j^_Z4Iq~rlk zfARH?H?OW7@|>iQ?hd*4APN<#$MgcYG5}* zG4)RqY0+!RT4dK+j7WVw31be&_?oeSA?@DW8xk7<-qP4pn>G$bM!GtODC~D(=!ExD zE7x#TMo$nA+1eNBhXB)GgqGl}LlkmN8`onr9;WF>zu&+{eF`(^B#r3aV$^E*(umlZ zl@{EWG%rvSpY477d+)%+V0c&OFlG#h|6~2=$@TD2+xx50L_Eg%;}t406dg*QZBRrt zb13TanDf{+mNDbh4B&?insALu^SePh zGB7lH$d+i@fVz>hd5Q~2sPW~BvDoyj(E~KT)0|DUiw&VvA?+aSOpW!ap2Q-_ov4v8 zA*B~i)*kFbG}?zbW9MkEwJ|2D6mrSb5=+o4Wh}Q{j^~=HzA@#M$CUho4R`YhBo#0^lxH~Mn*Py=va~Aja?pGvV3%1 zelWED)?xmrxFsAaEGaB4C@w6m@L@@X*M)Xr*05m>udm3j2!)YCqdun;TvG@pfWxN1 zLdRPWE-5app#MVH7zTv>nC%4o@``-U{EBcw}?iX)sh=K?4yo=0jpI zR9F}+t*Gz@$NKw8O;d&SUgzMU#{TZsUc@OTh1YxgqS1bvyzkJcVJ%wk(e&BRTD+b; z#s6N4e0}@x01IcOugKaOC5kYGsNQ2?64Qja3@KK;9#w~?#A|3Fs(z<5Nv5}ZmVvU zuZ6*_b+z?1@~tSitE#%WQN9%i8=GpIs~T)-NpP=+%ykXhgrPK8-Pll5*IL)uAe6FT zTLWI6T-Q)*GllYlTiY6{6;CJ>+yV`EN|q3`YpbhoZLe!+Pv$HLRy8+Q?XjFtwyLha zJX92{fb+}Ph9PvMy|^ep3||+LGFSmMex!DHQ*&)g3+dU|)KCM9)$Q6MQi#R-M3E1xN>iDP1!8matq=wjZ!=Q^ z(=!XG6GY%YRjqZmvtQLUw};9@L71jJTps36HdJ{5!xL%xF(J)e@F& zNB;6svN@sl-Q{II-ct?-X=rSyEr(lh?aQG$amtqhsLH*-?*RzYBcbpCbc)6vp4FGH z3sKbK-p8yGpiCH(deY>*d>y%i1T$D*c)0VBFBXA)q?Adtm=qB#lZiA*q5Tdj3?Y64 zJ`m681Hr_URN+zJqm2uifng$og$?2^;t#?*0xwN{C_AD#M_PnOmXBPRk8lddU<%YC z5)RGl8d1lDVVdum8HbQfB&IpZR#AY3Aw-dWD4ioSM;)!9Uv+SJDU(vIKjIinuJoVG z*rbD*)3OE#R;&TW2BSJ=0LhbIr$ym<&+MgCjUqPg!_GJyqdGY12ZxAA zP;02#RomXOXV;d-dUSFjng}PXgRb79eHmY*gN+O$xxp%%fY zraeh0I*W<7R&J;uxGRZLh@fmV@#Cu%TjVF1z;Efr=yj$o>aYm~&p(*p&(v26!qV5M zBN%@eqqgCO_xnVr-;@b1?60|bshQx$v|ky)_97Q*dWH12P>Juz5x0O(=n0`>?om8J z#?*qASc&OnJhidu3Ec&qE*$20PDsY1Ru|B*z&P?FX7JV{gub znT+YJm@)NXJ1wDk(zYB;{LG}r?S-;_zVax^Gy6kE3zvW>HBxG{=CO!M<7i%5VW<-0 zDF!(E`1^nUzJQZR(W=zfQ+CiuEKkwGg%y6985B4HEgy0T*eKwwOUV^3(uov(Yy#%M zE?2Fr`)y*G&V}6~*q#I=HEaH;TIs$UqX>CBF)I=1_;kQ`J*G`l78xWM~r z$<^bogKg(3$DN|U0ds|A*e>hV;H`QiQ;#|8!?19&FYMI~Tv<^ra9BEbdAT(1Bj z#8kwHm7Z?GrJhmKR1>B!E`W{Bfj&H0qFoo-^u+ce?LbK!kl=}ZaWiBz_6U>DU4v`xMf=H54AH0WZ#ChC%S?$ z&nWGaNd@iHFQq775#;muVQF7i+Oe&W`bp^|dawdA*9D^}P?0Lo6$j_W9{*_LkeW#H z9Me!K{5fVGPE3MS$c*MJph|}<-#IEg#QHSSiI^yyB6}$_C&(to$wZG0MpN|O*O!Kf zJzwmCQ9M@FL?h9BxeBY{Z4K?_15@Ryni~5h6l`hRV!wogyV~mQ7h3e)Zod=;cQyKX zih{IFAkwgJ&}=cUbKTd{V14aYOtrVy;lILO7HqEDwmpf+t3u0xr6Fy!MU!mDD>fo) z)6w_IEXP(#v_D0FP?!_6l>SIh!k~kJQv7Nd`{F4{*2B#Jkl;N$wlUogkvt8-bcv~T z^f-oG*cE~4=h!|s+$JcDks5nxbVxvv*>!CsrmbR?hNUqLaHTfc*TM$sAw13=h>YTa zIB8KNGs7Zu{evU2pJE3MJ3Gbs19`fXP!P@W@a#CEh^*PhO_*JpXGR!G{LLDlC|wN` zFgRv4c6|1<)4meC@-4O4jABgdpKZJ?VZMihjknh}Z>?{{!DUQPh0_*AYkQ&wa7rR3s)6O$Hd_o1}pG7EYzFZX|E1V z?=MxWtLp0w5e9GDwZ*bvgR5M%`W+fgOjPL-4u=;gLd#OXaxa z>Sg8vezHGpHTv)%FxAR=z=hg1n~3V)+nDM(nB@{GP9n?mMogU3|6LTgc%9` zP9)ZQOs!SRa-`d(GaAaw-SrU`DNZKrb}N+{mi$llo>F#aLuPhPYZ|AAbS6~G&C`4A z`6k~PknD~04GiI!hfUKqp}9qj1DwOv zh9jgQk{E6kTdW}`%uvt+{gy&<8z!3llT?W3|CT332#--VwLVI#1XE#KGo;}}E1!u? zJIOLaPa>yoL)WKT8) zo~EQpGRDA}0VUODv#Xi`l$pK>N~tr3ivJ5rMUlGpHeL<%^}t{_-DHjhC3JvN^!0-y z;7HI_IHYV1%^=A zGTEr+&k-Tj?hw4e@~&3#QVta9M+H#j>4oWtF7#Z*lBFCS{xE@e$qD211}WoiO2$t! zXlfnHWVkHj)xVpDsxjD(X}yt}K5Q+~!CUKnwsi)sq0QCC(Ijo&Kxre9ew;dn8l1#vOL!KO_7?U8X+~&^fRCChh}z+ zRC0wq*(IYnZ=9GJk6GY}FUbKPGvA@xTKur3d>yr|gc4eY`E(pzup46jLp;AMKbBxG z)RxcD+)pUu!Tk+sz=tGk_?H8}>4P<|tc>Cb5lv}9^n`d;#-nTT8`9*ewvd^CU9rGA z{!&q0a&rd2NIO<&o-g^WR$#YPcsk(7c3-Cg=Y`S!=Dr*)37j|#rIE%a-e{|9FsFBL zW)C|B=5>(NaUnNpH(CULng_u{u{OjaX%NqY6V#a+1FWL7F%V&lJcWc9fHIw&@E_ z+{IDDCwVT7t|O%oJ;_YnJpDxf8L^{lC?8qq@h`Iat0Nbw68r=#Y6B_7RYLjxWZ(}f z-j2lb(3>>!O<{U-dP|TxbR>52)b6V%<1*p?NmjySWjfY7xokS1J9%p2N;Q;E6YElc z!AnkpwXO+tOjT2O-b1zh`Krs*P(ICfAeNW1$s#yZNt#~pIMKYqOkamkKCkIz9Xp9= z&Yw;+FEJ+*%#n>b(u(DjbV3u?X9>MKl#eJC!JZ@@=(N@~wBczE_wCyHmfA#GC`h!r zt%=ky_4vt`f1!K?qk|(!D;OCtk}~=cCzOwnGgjD@w5IffRwy44gb!yyy77d>AxbU% zl2(2pKJ{6ewDfa(?~|?k(pP}u2GR~rsKInup_=6jS#=CZDh$J3F?wg5vR?u!s%>!}0}ATY{7 zL%mznh3g7V{Sfy$rgiS;;LRb6`x{ZyExL)G6stoa?qUem)qER*wtCSw*dh$mz{u2cFa zCjCyy@klYiFHNtthLaenSY)Y7G1P{5j?jt)E@Y(GhNi*BrPB~-;x~<8Y3P%X&2X89 zf3KGqT%5-u3+78MOIW6@C02Pg6;fQ{sh9?dqP*>(7{phxhhZ27%ua{mfHRT}uqk0U z?Al(jz>|mty9^>E4UdG;GHc1ixnam2>ccjXk+Ii5edY?HlX|R+4aIgx%4hM{CD_RF zi6J^=$NB84Mdsf=hrht1olc(`qN8)1&#zdLn-$nru*R|5#Y%=W0k)H^h0R1ju}CA7 z*lO*?#FpP#;Pdzjn&$#O-LLNmJx%e+K0D8yQptF5lS(uXY*Ojy?~Z6Ki1i6fHQ*AQ z?%c`!1b=+=M*}}8R3N@Z!-z4C84?tSxE2iuVm=eG6pJ085zq_^&G}rq-%07lmBg3C zX$hTji(sc%pWS+h{ z0uHCN^0g{QqC*LCeZdiNg~qLlRGDS|9RR-yIHF*0Vkt(PRM?eJQ=C`X+FaY(){I*U zE-$VSY{i)^MZsaOGzP#$ti2v3BpV@A3{9)++i+k)2`Q1Q6q;6ws#i7R@RuvSELc@f zXVV-hoR1S_+cbf1xoJW;hzHzIdY2{^Ks|HSOvyr3QW_HX-t3(TUym>j=CtAHiOO0M z+}7OK)}%?L_Bx5nr*C%n)Pj6nk90azeACrOq2;~MI}%0PAx3pbF}8H=Ie z=zg4cOfmyau4oSk@0w9d2s$W>r<-Q(m3%4CPXm7HSLp4I=*5~&iK0F3cbERjQt6@LX35pyayy{B*SnS+0tBFwX>c7i-F99Qu8gO zVv3=JgLrCBt89rhhDt}){1RH!HO4}WwJ^v5?AbN;@Owy1&#@!#K6-7Ax^Lr$1x~2J zyNbkzO&6tpAL?IsYA`7PuAHED17Y_4F!q8LF7Hm?lQnb{@gqRb_w;1nRIi}(LzL0xOG~c%wo;mbv1UNMrn33jWO&* z4HA80Bo(YILMPbhm03jEjcfU&Jb9)JvF3awU%9-anGTiJHa9oYaj=@YZFM+M+lGHz z+ncLu>UK*~2y>b0`ot&O$t4bdKy z7&%my!cgZoE~cP$yPBFwWIM-HZg@HN%WW49nM0PX{%r?l!7B%N8Yz=6an^8@w$yM4=^c0LO)x|gCkOjov-nQac-kU zuO*C*g|tv&8=JRuIGag&nC}}@Vd=mx1yR*2^xqVc6esN~L##51O<0Ia7eNQ%>zJNWbJOenZx#yLc0b_Ezsl=F=ejL**pI&#&zhGCx)p= zT|7t?=if;X=8(IkkXExI)y)%%Ocqoit&mKIsqMQ{YTzCewq&&~uY0j-Qy?Wrwh;|i zv#fs<;q3%%^{sVH6!|6KQL;5(5r$+?|mlJ$E?hw7EJbLIJ;1qdmz|lZr0%Lz=(1kT(uVibTN@8V5UT4!;%t?)0psK@5B0^B;m#m?-z-O_yyXMD1JKPBwVHZ78+l) z8aPcUrF5IZ%^1|ME9s`IZ>_!KY6E&HE?)3(Q%{ow`{EG{UwB%$%_TtxL7=YMk56SZdo{x&Ca$#ig~pVZP8rp)A(F(g z3sdJRe>}TeR=6Hkg_s7XBCTlEL%orLt}x;yNexv^H0Q+IW^h}_y1fqG zctT_f#U?EKq-CPZZ9FZ-d5_?m+v@PTEq+Ouzq)Gh&4Yb~V0AUU=8Bq}rKsE#V_R$@ zcMFw>YmI!9*JMpjMHfe0wHndjl`I?`zNM*s7w%9}(R{;5Nrye5mQ78Tj?rlHL_}4W zm?ReqCaV+6PNNw1$@hBLd~GsDOP}N&{bYH9 z-DZ6$OHCs}A+tCYMq8w<0R>sNEJ!EuYmk zRf3{Tr@P4wY7;|})tX*7vD8Y^rG+*PWUZ879xS{3`uWx3<2mF!GD+T9o0unT=Ir&f zOCc%syc=L!1`jKEYSV@=X{y5EH`UXv!i9?8+|Rv61`5@F5y}GB$c85&wl%qEzxnVy zM0pu8(e@B5wiWwQ=o+#fwfdIQ>>Mk2RWdJ36{quAn+dBBIIErAC|2XCSk2*TsNFr2 z%`lp=V|=fAqpY#LmZA2+G_ErV(YLf1C606gR5jXS#xHy(V|GHfTq z&KpI@xW})Jdjlxcp{uM%?}kK)NyxrkJ4NbDa@Ekro3;GgYE5jxg@XW zU1n)DEHSC$Vl==`0Nt-m+zAL3V#>qwI<<{pmc_O+U}0$=P}<=>bs2;$Y_z`rTGws- zu5x;@>!fedF5kxQlJb(?8f?iaFWVbI3T?+?3q8&2`TcC>-Prm)Wt0uaZjjCVf`xle zby6n(m1`&pykhKJ?} zj#P}7Ju6DMtc+f53=7kbCBRDN$~oo4GpmH0e2UZFEVrB#l-Q2A*)rMhF8D0zUSe(& zptc=b=s6PzkvX;Fd}TC+O7aF+?Rc4mAxOe>Ts#Ax;Ka622 ztl>2;=}P_G63#;hm=ol45J0F-`S~KQ1`bN%t+P0DQF~R6q(t*-T?sIg{oavLC&4$l zi*Puf{HGyoHoS~K?aw3m=`cg;4@>x|?h2DR`of27MC0T%lPRHR6qL;4 z0)5|6@H0LjN-os4e5?6lMlo~5#{4#iO~I=zxj`rYbvDCE;YjjN`YS6==8zFO$!|0% ziNd(g%qWInE}Z!F%vY+65C-ucI;k@oCBbe5`RH0)3Dj7<{O&1Cy2^#H^qS0|G5@SOQ9`(*2AxkF_rw}kaeompU1Ho%+#1$h61U$ zi?N+*p#%@ZOaU{vRLkNBl9?$dsARa6EL#Zb!RssZQL7Di#A@53rW;m^PNThj!`=3a zef1;va%*OpqT62pVxe3q>#vjjl%eA^)=T**BdcGuznd4c91WSbi2$MMEC+sq(9y t_^xA&U*G=7;QrBGb}TdwTr$!*U=raV*11hiYkIKgA4N1JIcDzV{~z>L*RTKp literal 0 HcmV?d00001 diff --git a/lexerTables.h b/lexerTables.h new file mode 100644 index 0000000..df12c43 --- /dev/null +++ b/lexerTables.h @@ -0,0 +1,85 @@ +/* + lexerTables.h -- Tables describing stuff the lexer needs to know. + + Chip Morningstar -- Lucasfilm Ltd. + + 3-November-1984 +*/ + +struct { + char first; + char second; + int token; + assignmentKindType value; + } operatorTable[] = { + '!', '=', NOT_EQUAL_TO, NO_ASSIGN, + '!', '\0', LOGICAL_NOT, NO_ASSIGN, + '%', '=', ASSIGN, MOD_ASSIGN, + '%', '\0', MOD, NO_ASSIGN, + '&', '&', LOGICAL_AND, NO_ASSIGN, + '&', '=', ASSIGN, AND_ASSIGN, + '&', '\0', BITWISE_AND, NO_ASSIGN, + '*', '=', ASSIGN, MUL_ASSIGN, + '*', '\0', MUL, NO_ASSIGN, + '+', '+', INCREMENT, NO_ASSIGN, + '+', '=', ASSIGN, ADD_ASSIGN, + '+', '\0', ADD, NO_ASSIGN, + '-', '-', DECREMENT, NO_ASSIGN, + '-', '=', ASSIGN, SUB_ASSIGN, + '-', '\0', SUB, NO_ASSIGN, + '.', '\0', SELECT, NO_ASSIGN, + '/', '=', ASSIGN, DIV_ASSIGN, + '/', '\0', DIV, NO_ASSIGN, + '<', '<', LEFT_SHIFT, NO_ASSIGN, + '<', '=', LESS_THAN_OR_EQUAL_TO, NO_ASSIGN, + '<', '\0', LESS_THAN, NO_ASSIGN, + '=', '=', EQUAL_TO, NO_ASSIGN, + '=', '\0', ASSIGN, ASSIGN_ASSIGN, + '>', '=', GREATER_THAN_OR_EQUAL_TO, NO_ASSIGN, + '>', '>', RIGHT_SHIFT, NO_ASSIGN, + '>', '\0', GREATER_THAN, NO_ASSIGN, + '^', '=', ASSIGN, XOR_ASSIGN, + '^', '^', LOGICAL_XOR, NO_ASSIGN, + '^', '\0', BITWISE_XOR, NO_ASSIGN, + '|', '=', ASSIGN, OR_ASSIGN, + '|', '|', LOGICAL_OR, NO_ASSIGN, + '|', '\0', BITWISE_OR, NO_ASSIGN, + '~', '\0', BITWISE_NOT, NO_ASSIGN, + '?', '\0', HI_BYTE, NO_ASSIGN, + '\0', '\0', 0, NO_ASSIGN, + }; + +char escapeCodes[256] = { + '\000', '\001', '\002', '\003', '\004', '\005', '\006', '\007', + '\010', '\011', '\012', '\013', '\014', '\015', '\016', '\017', + '\020', '\021', '\022', '\023', '\024', '\025', '\026', '\027', + '\030', '\031', '\032', '\033', '\034', '\035', '\036', '\037', + ' ', '!', '"', '#', '$', '%', '&', '\'', + '(', ')', '*', '+', ',', '-', '.', '/', + '0', '1', '2', '3', '4', '5', '6', '7', + '8', '9', ':', ';', '<', '=', '>', '?', + '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', + 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', + 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', + 'X', 'Y', 'Z', '[', '\\', ']', '^', '_', + '`', 'a', '\b', 'c', 'd', '\33', '\f', 'g', + 'h', 'i', 'j', 'k', 'l', 'm', '\n', 'o', + 'p', 'q', '\r', 's', '\t', 'u', 'v', 'w', + 'x', 'y', 'z', '{', '|', '}', '~', '\177', + '\200', '\201', '\202', '\203', '\204', '\205', '\206', '\207', + '\210', '\211', '\212', '\213', '\214', '\215', '\216', '\217', + '\220', '\221', '\222', '\223', '\224', '\225', '\226', '\227', + '\230', '\231', '\232', '\233', '\234', '\235', '\236', '\237', + '\240', '\241', '\242', '\243', '\244', '\245', '\246', '\247', + '\250', '\251', '\252', '\253', '\254', '\255', '\256', '\257', + '\260', '\261', '\262', '\263', '\264', '\265', '\266', '\267', + '\270', '\271', '\272', '\273', '\274', '\275', '\276', '\277', + '\300', '\301', '\302', '\303', '\304', '\305', '\306', '\307', + '\310', '\311', '\312', '\313', '\314', '\315', '\316', '\317', + '\320', '\321', '\322', '\323', '\324', '\325', '\326', '\327', + '\330', '\331', '\332', '\333', '\334', '\335', '\336', '\337', + '\340', '\341', '\342', '\343', '\344', '\345', '\346', '\347', + '\350', '\351', '\352', '\353', '\354', '\355', '\356', '\357', + '\360', '\361', '\362', '\363', '\364', '\365', '\366', '\367', + '\370', '\371', '\372', '\373', '\374', '\375', '\376', '\377', +}; diff --git a/listing.c b/listing.c new file mode 100644 index 0000000..667542c --- /dev/null +++ b/listing.c @@ -0,0 +1,649 @@ +/* + listing.c -- Routines to generate a Macross assembly listing. + + Chip Morningstar -- Lucasfilm Ltd. + + 10-February-1985 +*/ + +#include "macrossTypes.h" +#include "macrossGlobals.h" + +static char lineBuffer1[LINE_BUFFER_SIZE]; +static char lineBuffer2[LINE_BUFFER_SIZE]; +static int cumulativeLineNumber = 0; +static char macroLineBuffer[LINE_BUFFER_SIZE]; +static char nextMacroLineBuffer[LINE_BUFFER_SIZE]; +static int macroAddress; +static int nextMacroAddress; +static int macroDepth; +static int nextMacroDepth; + + void +outputListing() +{ + void generateListing(); + + rewind(saveFileForPass2); + rewind(indexFileForPass2); + rewind(macroFileForPass2); + generateListing(); +} + + void +terminateListingFiles() +{ + saveLineForListing("\n"); + saveIndexForListing(NULL_STATEMENT, cumulativeLineNumber); + saveLineForListing("\n"); + saveIndexForListing(NULL_STATEMENT, cumulativeLineNumber); +} + +#define advanceSourceFile() \ + if (nextSourceAddress == -1) {\ + readSourceFileLine(&sourceAddress, &sourceDepth,\ + sourceText = lineBuffer1, saveFileForPass2);\ + readSourceFileLine(&nextSourceAddress,\ + &nextSourceDepth, nextSourceText =\ + lineBuffer2, saveFileForPass2);\ + sourceLineNumber++;\ + } else {\ + sourceAddress = nextSourceAddress;\ + sourceDepth = nextSourceDepth;\ + tempText = sourceText;\ + sourceText = nextSourceText;\ + nextSourceText = tempText;\ + if (tempText == NULL)\ + nextSourceText = (sourceText==lineBuffer1) ?\ + lineBuffer2 : lineBuffer1;\ + readSourceFileLine(&nextSourceAddress,\ + &nextSourceDepth, nextSourceText,\ + saveFileForPass2);\ + sourceLineNumber++;\ + } + +#define advanceIndexFile() {\ + indexAddress = nextIndexAddress;\ + indexLineNumber = nextIndexLineNumber;\ + indexKind = nextIndexKind;\ + readIndexFileLine(&nextIndexKind, &nextIndexAddress,\ + &nextIndexLineNumber);\ + } + +/* This is the most horrible piece of code I have ever written in my entire + life -- cbm */ + void +generateListing() +{ + int sourceAddress; + int sourceDepth; + char *sourceText = lineBuffer1; + int nextSourceAddress; + int nextSourceDepth; + char *nextSourceText = lineBuffer2; + int sourceLineNumber; + + int indexAddress; + int indexLineNumber; + statementKindType indexKind; + int nextIndexAddress; + int nextIndexLineNumber; + statementKindType nextIndexKind; + + bool firstLine; + bool alreadyListingMacroExpansion; + bool finishingListingMacroExpansion; + bool nullMacroLine; + int callLineNumber; + int targetLineNumber; + bool mifEndFlag; + int numberOfBytesToList; + int numberOfBytesListed; + char *tempText; + + void readIndexFileLine(); + void readSourceFileLine(); + + sourceLineNumber = 1; + alreadyListingMacroExpansion = FALSE; + readSourceFileLine(&sourceAddress, &sourceDepth, sourceText, + saveFileForPass2); + readSourceFileLine(&nextSourceAddress, &nextSourceDepth, + nextSourceText, saveFileForPass2); + if (expandMacros) + readSourceFileLine(&nextMacroAddress, &nextMacroDepth, + nextMacroLineBuffer, macroFileForPass2); + readIndexFileLine(&indexKind, &indexAddress, &indexLineNumber); + readIndexFileLine(&nextIndexKind, &nextIndexAddress, + &nextIndexLineNumber); + currentCodeMode = RELOCATABLE_BUFFER; + if (indexKind == ORG_STATEMENT || indexKind == ALIGN_STATEMENT || + indexKind == REL_STATEMENT) { + if (indexKind == ORG_STATEMENT) { + currentCodeMode = ABSOLUTE_BUFFER; + } + advanceIndexFile(); + } + while (!feof(saveFileForPass2) && !feof(indexFileForPass2)) { + mifEndFlag = FALSE; + if ((int)indexKind == -1) { + advanceIndexFile(); + if ((int)indexKind == -1) + currentCodeMode = ABSOLUTE_BUFFER; + else + currentCodeMode = RELOCATABLE_BUFFER; + advanceIndexFile(); + sourceLineNumber = indexLineNumber; + if (nextIndexKind == ORG_STATEMENT || nextIndexKind == + ALIGN_STATEMENT || nextIndexKind == + REL_STATEMENT) { + if (nextIndexKind == ORG_STATEMENT) { + currentCodeMode = ABSOLUTE_BUFFER; + } else if (nextIndexKind == REL_STATEMENT) { + currentCodeMode = RELOCATABLE_BUFFER; + } + advanceIndexFile(); + } + } + if (indexKind == MACRO_STATEMENT || indexKind == + FUNCTION_STATEMENT || indexKind == + STRUCT_STATEMENT) { + while (sourceLineNumber < indexLineNumber) { + printListingLine(0, indexAddress, sourceText, + indexKind); + advanceSourceFile(); + } + } else if (!alreadyListingMacroExpansion && isBlockOpener( + indexKind)) { + while (sourceLineNumber < nextIndexLineNumber) { + printListingLine(0, indexAddress, sourceText, + indexKind); + advanceSourceFile(); + } + readIndexFileLine(&nextIndexKind, &nextIndexAddress, + &nextIndexLineNumber); + } + while ((indexLineNumber == nextIndexLineNumber && + !alreadyListingMacroExpansion && + (int)nextIndexKind != -1 && indexKind != + ORG_STATEMENT) || (indexKind == + NULL_STATEMENT && nextSourceAddress == -1)) { + while (nextSourceAddress == -1) { + printListingLine(0, indexAddress, sourceText, + indexKind); + advanceSourceFile(); + } + readIndexFileLine(&nextIndexKind, &nextIndexAddress, + &nextIndexLineNumber); + } + if (nextIndexLineNumber >= 0) { + targetLineNumber = alreadyListingMacroExpansion ? + callLineNumber : sourceLineNumber; + while (nextIndexLineNumber < targetLineNumber && + !isBlockOpener(indexKind)) { + readIndexFileLine(&nextIndexKind, + &nextIndexAddress, + &nextIndexLineNumber); + } + } + while (nextIndexAddress == -1 && !feof(indexFileForPass2)) { + readIndexFileLine(&nextIndexKind, &nextIndexAddress, + &nextIndexLineNumber); + mifEndFlag = TRUE; + } + numberOfBytesToList = nextIndexAddress - indexAddress; + firstLine = TRUE; + nullMacroLine = FALSE; + while (numberOfBytesToList > 0 || nextSourceAddress == -1 || + firstLine) { + firstLine = FALSE; + if (alreadyListingMacroExpansion) { + if (nullMacroLine) { + numberOfBytesListed = printListingLine( + numberOfBytesToList, indexAddress, + NULL, indexKind); + nullMacroLine = FALSE; + } else { + numberOfBytesListed = printMacroLine( + numberOfBytesToList, indexAddress, + indexKind); + } + } else if (!feof(indexFileForPass2)) { + numberOfBytesListed = printListingLine( + numberOfBytesToList, indexAddress, + sourceText, indexKind); + } + numberOfBytesToList -= numberOfBytesListed; + indexAddress += numberOfBytesListed; + if (nextSourceAddress == -1 || (sourceLineNumber < + indexLineNumber && indexKind == + INSTRUCTION_STATEMENT && + !alreadyListingMacroExpansion)) { + advanceSourceFile(); + firstLine = TRUE; + } else if (!alreadyListingMacroExpansion && + nextIndexLineNumber >= 0) { + sourceText = NULL; + } else if (alreadyListingMacroExpansion && + numberOfBytesToList > 0) { + nullMacroLine = TRUE; + } + } + while (mifEndFlag && sourceLineNumber+10; spaces--) { + putc(' ', listFileOutput); + column++; + } + } else { + putc(*text, listFileOutput); + column++; + } + text++; + } +} + + void +printNTimes(aChar, times) + char aChar; + int times; +{ + void moreText(); + + while (times-- > 0) + moreText("%c", aChar); +} + + void +tabIndent() +{ + printNTimes('\t', tabCount); +} + +static char expressionString[LINE_BUFFER_SIZE] = { '\0' }; +static char *expressionStringPtr = expressionString; +static char expansionString[LINE_BUFFER_SIZE] = { '\0' }; +static char *expansionStringPtr = expansionString; +static char labelString[LINE_BUFFER_SIZE] = { '\0' }; +static char *labelStringPtr = labelString; + + bool +labeledLine() +{ + return(labelStringPtr != labelString); +} + + void +addText(buffer, bufferPtr, format, arg1, arg2, arg3) + char *buffer; + char **bufferPtr; + char *format; + int arg1; + int arg2; + int arg3; +{ + sprintf(*bufferPtr, format, arg1, arg2, arg3); + *bufferPtr = buffer + strlen(buffer); +} + + void +moreTextOptional(buffer, bufferPtr, format, arg1, arg2, arg3) + char *buffer; + char **bufferPtr; + char *format; + int arg1; + int arg2; + int arg3; +{ + if (buffer == NULL) + addText(expansionString, &expansionStringPtr, format, arg1, + arg2, arg3); + else + addText(buffer, bufferPtr, format, arg1, arg2, arg3); +} + + void +moreText(format, arg1, arg2, arg3) + char *format; + int arg1; + int arg2; + int arg3; +{ + addText(expansionString, &expansionStringPtr, format, arg1,arg2,arg3); +} + + void +moreLabel(format, arg1, arg2, arg3) + char *format; + int arg1; + int arg2; + int arg3; +{ + sprintf(labelStringPtr, format, arg1, arg2, arg3); + labelStringPtr = labelString + strlen(labelString); +} + +static addressType savedCurrentLocationCounterValue; +static int savedIncludeNestingDepth; + + void +startLine() +{ + printNTimes('+', macroCallDepth); + savedCurrentLocationCounterValue = currentLocationCounter.value; + savedIncludeNestingDepth = includeNestingDepth; +} + + void +endLine() +{ + if (amListing()) { + putw(savedCurrentLocationCounterValue, macroFileForPass2); + putw(savedIncludeNestingDepth, macroFileForPass2); + fprintf(macroFileForPass2, "%s\n", expansionString); + } + expansionStringPtr = expansionString; + *expansionStringPtr = '\0'; +} + + void +flushExpressionString() +{ + expressionStringPtr = expressionString; + *expressionStringPtr = '\0'; +} + + void +expandExpression(toBuffer, toBufferPtr) + char *toBuffer; + char **toBufferPtr; +{ + if (toBuffer == NULL) + moreText("%s", expressionString); + else + addText(toBuffer, toBufferPtr, "%s", expressionString); + flushExpressionString(); +} + + void +expandNum(buffer, bufferPtr, n) + char *buffer; + char **bufferPtr; + int n; +{ + moreTextOptional(buffer, bufferPtr, "%d", n); +} + + void +flushOperand(n) + int n; +{ + moreText("%s", operandBuffer[n]); + operandBuffer[n][0] = '\0'; +} + + void +expandOperands(op) + int op; +{ + int i; + + if (op > 0) { + flushOperand(0); + for (i=1; i&j7Bdz5XsWWQapN~M{I*ZlBJQQc=U*7 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 OL^)rBRkRs{(*FZ|Y1kkD literal 0 HcmV?d00001 diff --git a/lookups.c b/lookups.c new file mode 100644 index 0000000..b761c8c --- /dev/null +++ b/lookups.c @@ -0,0 +1,521 @@ +/* + lookups.c -- Routines to lookup things in tables. + + Chip Morningstar -- Lucasfilm Ltd. + + 5-November-1984 +*/ + +#include "macrossTypes.h" +#include "macrossGlobals.h" + +/* + These routines all do basically the same thing. Various kinds of keywords + and so forth are stored in hash tables. The hash buckets contain linked + lists that are sorted alphabetically. + */ + + conditionType +lookupConditionCode(s, hashValue) + char *s; + int hashValue; +{ + conditionTableEntryType *result; + + genericTableEntryType *prehashedStringLookup(); + + result = (conditionTableEntryType *) prehashedStringLookup(s, + conditionTable, hashValue); + if (result != NULL) + return(result->code); + else + return(NOT_FOUND_COND); +} + + int +lookupKeyword(s, hashValue) + char *s; + int hashValue; +{ + keywordTableEntryType *result; + + genericTableEntryType *prehashedStringLookup(); + + result = (keywordTableEntryType *) prehashedStringLookup(s, + keywordTable, hashValue); + if (result != NULL) + return(result->token); + else + return(0); +} + + macroTableEntryType * +lookupMacroName(s, hashValue) + char *s; + int hashValue; +{ + genericTableEntryType *prehashedStringLookup(); + + return((macroTableEntryType *) prehashedStringLookup(s, macroTable, + hashValue)); +} + + opcodeTableEntryType * +lookupOpcode(s, hashValue) + char *s; + int hashValue; +{ + genericTableEntryType *prehashedStringLookup(); + + return((opcodeTableEntryType *) prehashedStringLookup(s, + opcodeTable, hashValue)); +} + +/* lookupOrEnterSymbol -- if there is an entry in the symbol table for the + given symbol, return that entry, otherwise create a new entry for it of + the given kind and return *that* */ + + symbolTableEntryType * +lookupOrEnterSymbol(s, kind) + stringType *s; + symbolUsageKindType kind; +{ + symbolTableEntryType *result; + genericTableEntryType *hashStringLookup(); + genericTableEntryType *hashStringEnter(); + symbolTableEntryType *buildSymbolTableEntry(); + + if (result = (symbolTableEntryType *)hashStringLookup(s,symbolTable)){ +/* result->referenceCount++;*/ + return(result); + } else + return((symbolTableEntryType *) + hashStringEnter(buildSymbolTableEntry(s, kind), + symbolTable)); +} + + void +pushSymbol(symbol) + symbolTableEntryType *symbol; +{ + symbolInContextType *newContext; + + newContext = typeAlloc(symbolInContextType); + newContext->pushedContexts = symbol->context; + symbol->context = newContext; +} + + void +popSymbol(symbol) + symbolTableEntryType *symbol; +{ + symbolInContextType *deadContext; + + deadContext = symbol->context; + if (deadContext == NULL) + botch("symbol pop underflow\n"); + else { + symbol->context = deadContext->pushedContexts; + if (freeFlag) { + if (deadContext->value != NULL) + freeValue(deadContext->value); + free(deadContext); + } + } +} + + macroTableEntryType * +createMacro(macroName) + stringType *macroName; +{ + macroTableEntryType *result; + symbolTableEntryType *testSymbol; + + genericTableEntryType *hashStringLookup(); + genericTableEntryType *hashStringEnter(); + macroTableEntryType *buildMacroTableEntry(); + symbolTableEntryType *lookupOrEnterSymbol(); + + testSymbol = lookupOrEnterSymbol(macroName, MACRO_SYMBOL); + if (testSymbol->context->usage != MACRO_SYMBOL) { + error(SYMBOL_ALREADY_THERE_ERROR, symbName(testSymbol)); + return(NULL); + } else if (hashStringLookup(macroName, macroTable) != NULL) { + error(SYMBOL_ALREADY_THERE_ERROR, symbName(testSymbol)); + return(NULL); + } else { + result = (macroTableEntryType *) + hashStringEnter(buildMacroTableEntry(macroName), + macroTable); + result->body = NULL; + return(result); + } +} + + +/* + Generic table lookup utility routines + */ + + genericTableEntryType * +prehashedStringLookup(s, table, hashValue) + char *s; + genericTableEntryType *table[]; + int hashValue; +{ + genericTableEntryType *result; + int test; + + result = table[hashValue]; + while (result != NULL) { + if ((test = strcmplc(s, result->string)) == 0) + break; + else if (test > 0) { + result = NULL; + break; + } else { + result = result->next; + } + } + return(result); +} + + genericTableEntryType * +hashStringLookup(s, table) + char *s; + genericTableEntryType *table[]; +{ + return(prehashedStringLookup(s, table, hashString(s))); +} + + genericTableEntryType * +hashStringEnter(entry, table) + genericTableEntryType *entry; + genericTableEntryType *table[]; +{ + genericTableEntryType *result; + genericTableEntryType *oldResult; + int test; + int hashValue; + + hashValue = hashString(entry->string); + result = table[hashValue]; + if (result == NULL) { + table[hashValue] = entry; + entry->next = NULL; + return(entry); + } + oldResult = NULL; + while (result != NULL) { + if ((test = strcmplc(entry->string, result->string)) == 0) { + botch("symbol table entry %s already there\n", + entry->string); + } else if (test > 0) { + entry->next = result; + if (oldResult == NULL) + table[hashValue] = entry; + else + oldResult->next = entry; + return(entry); + } else { + oldResult = result; + result = result->next; + } + } + if (oldResult == NULL) + table[hashValue] = entry; + else + oldResult->next = entry; + entry->next = NULL; + return(entry); +} + + int +hashString(s) + char *s; +{ + unsigned result; + + result = 0; + while (*s != '\0') + result = (result << 1) + toLowerCase(*s++); + return(result & HASH_TABLE_MASK); +} + + bool +strcmplc(s1, s2) /* string compare in lower case */ + char *s1; /* heavily optimized version */ + char *s2; +{ + char c1; + int result; + + do { + c1 = toLowerCase(*s1++); + + /* if result != 0, they differ */ + if (result = c1 - toLowerCase(*s2++)) { + return(result); /* c1c2==pos */ + } else if (!c1) { /* if they're null, we're done */ + return(0); + } + } while (TRUE); +} + + bool +strcmplct(s1, s2) /* For tables: s2 is already lower case */ + char *s1; /* heavily optimized version. */ + char *s2; +{ + char c1; + int result; + + while (TRUE) { + c1 = toLowerCase(*s1++); + if (result = c1 - (*s2++)) { /* if result != 0, they differ */ + return(result); /* c1c2==pos */ + } else if (!c1) { /* if they're null, we're done */ + return(0); + } + } +} + + void +purgeSymbol(symbol) + symbolTableEntryType *symbol; +{ + symbolInContextType *context; + + symbolInContextType *getWorkingContext(); + + if ((context = getWorkingContext(symbol)) != NULL) + context->usage = DEAD_SYMBOL; +} + + void +reincarnateSymbol(context, newUsage) + symbolInContextType *context; + symbolUsageKindType newUsage; +{ + context->attributes = 0; + dupValue(context->value, UndefinedValue); + context->usage = newUsage; +} + + +/* + Routines to handle assembly-time binding of symbols to contexts. + */ + + void +pushBinding(symbol, newBinding, newUsage) + symbolTableEntryType *symbol; + valueType *newBinding; + symbolUsageKindType newUsage; +{ + valueType *newValue(); + + pushSymbol(symbol); + if (newBinding == NULL) + newBinding = newValue(FAIL, 0, EXPRESSION_OPND); + symbol->context->value = newBinding; + symbol->context->usage = newUsage; + symbol->context->environmentNumber = currentEnvironment-> + environmentNumber; + symbol->context->attributes = DEFINED_VARIABLE_ATT; +} + + void +popBinding(symbol) + symbolTableEntryType *symbol; +{ + popSymbol(symbol); +} + + int /* returns number of bindings completed, negative this if failure */ +bindMacroArguments(argumentList, parameterList, macroName) + argumentDefinitionListType *argumentList; + operandListType *parameterList; + stringType *macroName; +{ + int numberBound; + bool arrayTag; + int arrayLength; + valueType **arrayContents; + int i; + + valueType *newValue(); + + if (argumentList == NULL) + arrayTag = FALSE; + else + arrayTag = ((argumentListHeadType *)argumentList)->arrayTag; + numberBound = 1; + while (argumentList!=NULL && (!arrayTag || argumentList-> + nextArgument!=NULL) && parameterList!=NULL) { + pushBinding(argumentList->theArgument, newValue(OPERAND_VALUE, + parameterList, EXPRESSION_OPND), ARGUMENT_SYMBOL); + argumentList = argumentList->nextArgument; + parameterList = parameterList->nextOperand; + numberBound++; + } + if (!arrayTag) { + if (parameterList != NULL) { + error(TOO_MANY_ARGUMENTS_TO_MACRO_ERROR, macroName, + numberBound-1); + return(-numberBound); + } + while (argumentList != NULL) { + pushBinding(argumentList->theArgument, newValue(FAIL, + 0, EXPRESSION_OPND), ARGUMENT_SYMBOL); + argumentList = argumentList->nextArgument; + numberBound++; + } + } else { + if (parameterList == NULL) { + while (argumentList->nextArgument != NULL) { + pushBinding(argumentList->theArgument, + newValue(FAIL, 0, EXPRESSION_OPND), + ARGUMENT_SYMBOL); + argumentList = argumentList->nextArgument; + numberBound++; + } + } + arrayLength = countParameters(parameterList); + pushBinding(argumentList->theArgument, newValue(ARRAY_VALUE, + allocArray(arrayLength, &arrayContents), + EXPRESSION_OPND), ARGUMENT_SYMBOL); + for (i=0; inextOperand; + } + numberBound++; + } + return(numberBound); +} + + int /* returns number of bindings completed, negative this if failure */ +bindFunctionArguments(argumentList, parameterList, functionName) + argumentDefinitionListType *argumentList; + operandListType *parameterList; + stringType *functionName; +{ + valueType *argument; + bool arrayTag; + int arrayLength; + valueType **arrayContents; + int i; + int numberBound; + valueType *firstArgument; + environmentType *saveEnvironment; + + valueType *evaluateOperand(); + valueType *newValue(); + + if (argumentList == NULL) + arrayTag = FALSE; + else + arrayTag = ((argumentListHeadType *)argumentList)->arrayTag; + numberBound = 1; + firstArgument = NULL; + while (argumentList!=NULL && (!arrayTag || argumentList-> + nextArgument!=NULL) && parameterList!=NULL) { + saveEnvironment = currentEnvironment; + currentEnvironment = currentEnvironment->previousEnvironment; + argument = evaluateOperand(parameterList, NO_FIXUP); + currentEnvironment = saveEnvironment; + if (firstArgument == NULL) + firstArgument = argument; + if (isUsable(argument)) { + pushBinding(argumentList->theArgument, argument, + ARGUMENT_SYMBOL); + argumentList = argumentList->nextArgument; + parameterList = parameterList->nextOperand; + expand((argumentList!=NULL && parameterList!=NULL) ? + moreExpression(", ") : 0); + numberBound++; + } else { + if (isUndefined(argument)) + resultOfLastFunctionCall = + newValue(UNDEFINED_VALUE, 0, + firstArgument->addressMode); + return(-numberBound); + } + } + if (!arrayTag) { + if (parameterList != NULL) { + error(TOO_MANY_ARGUMENTS_TO_FUNCTION_ERROR, + functionName, numberBound - 1); + return(-numberBound); + } + while (argumentList != NULL) { + pushBinding(argumentList->theArgument, newValue(FAIL, + 0, EXPRESSION_OPND), ARGUMENT_SYMBOL); + argumentList = argumentList->nextArgument; + numberBound++; + } + } else { + if (parameterList == NULL) { + while (argumentList->nextArgument != NULL) { + pushBinding(argumentList->theArgument, + newValue(FAIL, 0, EXPRESSION_OPND), + ARGUMENT_SYMBOL); + argumentList = argumentList->nextArgument; + numberBound++; + } + } + arrayLength = countParameters(parameterList); + pushBinding(argumentList->theArgument, newValue(ARRAY_VALUE, + allocArray(arrayLength, &arrayContents), + EXPRESSION_OPND), ARGUMENT_SYMBOL); + numberBound++; + for (i=0; i + previousEnvironment; + argument = evaluateOperand(parameterList, NO_FIXUP); + currentEnvironment = saveEnvironment; + if (firstArgument == NULL) + firstArgument = argument; + if (isUsable(argument)) { + arrayContents[i] = argument; + parameterList = parameterList->nextOperand; + } else { + if (isUndefined(argument)) + resultOfLastFunctionCall = + newValue(UNDEFINED_VALUE, 0, + firstArgument->addressMode); + return(-numberBound); + } + } + } + return(numberBound); +} + + void +unbindArguments(argumentList, numberToUnbind) + argumentDefinitionListType *argumentList; + int numberToUnbind; +{ + while (argumentList != NULL && numberToUnbind-- > 0) { + popBinding(argumentList->theArgument); + argumentList = argumentList->nextArgument; + } + if (numberToUnbind > 0) + botch("binding count larger than number of bindings\n"); +} + + void +unbindLocalVariables(identifierList) + identifierListType *identifierList; +{ + identifierListType *deadEntry; + + while (identifierList != NULL) { + popBinding(identifierList->theSymbol); + deadEntry = identifierList; + identifierList = identifierList->nextIdentifier; + qfree(deadEntry); + } +} diff --git a/lookups.o b/lookups.o new file mode 100644 index 0000000000000000000000000000000000000000..e46b287c2bc3592e65aec5024fa3f36f4aae3c9c GIT binary patch literal 46074 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 M3_Q)i7oLIt4?^W=YXATM literal 0 HcmV?d00001 diff --git a/macrossGlobals.h b/macrossGlobals.h new file mode 100644 index 0000000..b24eaef --- /dev/null +++ b/macrossGlobals.h @@ -0,0 +1,151 @@ +/* + macrossGlobals.h -- Global variable definitions for the Macross + assembler. + + Chip Morningstar -- Lucasfilm Ltd. + + 1-November-1984 + +*/ + +bool backwardsCompatibleIfFlag; +bool beneathFunction; +commandLineDefineType *commandLineDefines; +int cumulativeLineNumber; +environmentType *currentEnvironment; +int currentFieldOffset; +char *currentFileName; +char *lastErrorFile; +stringType *currentFunctionName; +int currentLabelTagNumber; +int currentLineNumber; +int lastErrorLine; +identifierListType *currentLocalVariableList; +valueType currentLocationCounter; +int currentOperandNumber; +int currentReferenceDepth; +bool debug; +bool emitPrint; +bool expandMacros; +bool errorFlag; +bool expressionFailed; +bool finishOperand; +operandKindType fixupAddressMode[MAX_NUMBER_OF_OPERANDS]; +operandKindType newFixupAddressMode; +fixupListType *fixupList; +bool freeFlag; +bool freturnExit; +bool generatingFixup; +environmentType globalEnvironment; +int hackFlag; +bool haveUserStartAddress; +bool fixupStartAddress; +int includeNestingDepth; +FILE *indexFileForPass2; +FILE *input; +fileNameListType *inputFileStack; +FILE *listFileOutput; +int listingControlCounter; +bool listingOn; +int macroCallDepth; +FILE *macroFileForPass2; +int macroOrFunctionNestingDepth; +structInstanceType *newStruct; +int nextEnvironmentNumber; +int nextLabelTagNumber; +FILE *objectFileOutput; +char operandBuffer[MAX_NUMBER_OF_OPERANDS][LINE_BUFFER_SIZE]; +char pass2IndexFileName[]; +char pass2SourceFileName[]; +char pass2MacroExpansionFileName[]; +expressionType *pendingFixup[MAX_NUMBER_OF_OPERANDS]; +bool performingFixups; +bool positionIndependentCodeMode; +bool produceLinkableObject; +addressType relocatableHighWaterMark; +reservationListType *reservationList; +valueType *resultOfLastFunctionCall; +valueType savedRelocatableCurrentLocationCounter; +FILE *saveFileForPass2; +bool showAllSymbolsFlag; +bool sideEffectFlag; +bool standaloneExpansionFlag; +valueType *startAddress; +int statementEvaluationDepth; +int statementListNestingDepth; +int structNestingDepth; +FILE *symbolDumpFileOutput; +bool symbolTableDumpOn; +int tabCount; +addressType targetOffset; +bool terseErrorMessages; +valueType *UndefinedValue; +symbolUsageKindType unknownSymbolTag; + +#define DEFAULT_OBJECT_FILE_NAME "m.out" + +#define LEX_DISPATCH_TABLE_SIZE 128 +int (*lexDispatchTable[128])(); + +#define HASH_TABLE_SIZE 512 +#define HASH_TABLE_MASK 0x1FF + +struct { + stringType *functionName; + valueType *(*functionEntry)(); + bool isSpecialFunction; + int ordinal; + } builtInFunctionTable[]; + +struct { + stringType *symbolName; + int symbolValue; + } predefinedSymbolTable[]; + +macroTableEntryType *macroTable[HASH_TABLE_SIZE]; + +opcodeTableEntryType *opcodeTable[HASH_TABLE_SIZE]; + +opcodeTableEntryType theOpcodes[]; + +keywordTableEntryType *keywordTable[HASH_TABLE_SIZE]; + +keywordTableEntryType theKeywords[]; + +conditionTableEntryType *conditionTable[HASH_TABLE_SIZE]; + +conditionTableEntryType theConditions[]; + +symbolTableEntryType *symbolTable[HASH_TABLE_SIZE]; + +int operandClassTable[]; + +void (*instructionActionTable[])(); + +int validSymbolValues[NUM_OF_SYM_USAGES]; + +byte structScratchBuffer[MAXIMUM_ALLOWED_STRUCT_SIZE]; + +codeRegionType absoluteCodeRegion; +codeRegionType relocatableCodeRegion; +codeRegionType *codeRegions[2]; +codeBufferKindType currentCodeMode; +codeBufferType *emptyBuffer; /* ??? */ +codeBreakType *codeBreakList; +codeBreakType *lastCodeBreak; + +expressionReferenceListType *expressionReferenceList[3]; +expressionReferenceListType *referencesToNote[MAX_NUMBER_OF_OPERANDS]; +int numberOfReferencesInList[3]; +functionDefinitionType *externalFunctionList; +functionDefinitionType *endOfExternalFunctionList; +int externalFunctionCount; + +char alphabeticCharacterTable[128]; +char alphaNumericCharacterTable[128]; +char lowerCaseCharacterTable[128]; +char numericCharacterTable[128]; + +int expressionBufferSize; +#define EXPRESSION_BUFFER_LIMIT 500 +byte expressionBuffer[EXPRESSION_BUFFER_LIMIT]; diff --git a/macrossTables.o b/macrossTables.o new file mode 100644 index 0000000000000000000000000000000000000000..522096581d38203498916f4971de483356e77334 GIT binary patch literal 37062 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 q=jnPpP0!lEX&9A4gyzN + +/* + Stuff for sorting out which target processor we are going to be an + assembler for, this time around. +*/ + +/* TARGET_CPU gets defined as one of these on the 'cc' commmand line using + the "-D" option */ +#define CPU_6502 1 +#define CPU_68000 2 + +#if TARGET_CPU == CPU_6502 +#define OPERAND_DEFS "operandDefs_6502.h" +#define OPERAND_BODY "operandBody_6502.h" +#define CONDITION_DEFS "conditionDefs_6502.h" +#define TARGET_CPU_STRING "6502" + +#else if TARGET_CPU == CPU_68000 +#define OPERAND_DEFS "operandDefs_68000.h" +#define OPERAND_BODY "operandBody_68000.h" +#define CONDITION_DEFS "conditionDefs_68000.h" +#define TARGET_CPU_STRING "MC68000" + +#endif + +/* + General types -- These data types are just useful for dealing with the + world at large. +*/ + +typedef int nullType; /* for nothingness */ + +typedef char anyOldThing; /* for storage allocators */ + +typedef int bool; /* for logical operations */ +#define FALSE 0 +#define TRUE 1 + +typedef unsigned char byte; + +typedef unsigned short wordType; + +typedef unsigned long longType; + +typedef unsigned long bigWord; + +typedef union { /* lets us build or take */ + wordType wordPart; /* apart a word while */ + byte bytePart[2]; /* keeping control over */ + } byteToWordType;/* byte order. */ +/* which element of bytePart is the low order byte and which is the high + order byte is host-system dependent! */ + +typedef union { /* lets us build or take */ + longType longPart; /* apart a long while */ + byte bytePart[4]; /* keeping control over */ + } byteToLongType;/* byte order. */ +/* which element of bytePart is the low order byte and which is the high + order byte is host-system dependent! */ + +typedef char stringType; /* sometimes...because + although a char is not a +string, a pointer to a char *is* a pointer to a string and pointers are what +we care about. We never declare anything to be 'stringType' but we'll declare +lots of things 'stringType *' */ + +typedef long addressType; /* address on the target + processor, not the host + processor */ + +/* + Values: the values of Macross expressions, instruction operands, and so on + are kept track of internally using objects of 'valueType'. This is a + struct consisting of the value itself together with something telling what + kind of value it is (string, relocatable address, etc.) and what address + mode is associated with it (direct, indirect, etc.). + */ + +typedef enum { + ABSOLUTE_VALUE, DATA_VALUE, RELOCATABLE_VALUE, BSS_VALUE, + STRUCT_VALUE, FIELD_VALUE, MACRO_VALUE, OPERAND_VALUE, STRING_VALUE, + CONDITION_VALUE, UNDEFINED_VALUE, FUNCTION_VALUE, BLOCK_VALUE, + BUILT_IN_FUNCTION_VALUE, ARRAY_VALUE, FAIL + } valueKindType; +#define NUM_OF_VALUE_KINDS 16 /* C really could benefit from a + 'cardinality-of-enumerated-type' operator */ + +#define ABSOLUTE_VALUE_BIT 0x0001 +#define DATA_VALUE_BIT 0x0002 +#define RELOCATABLE_VALUE_BIT 0x0004 +#define BSS_VALUE_BIT 0x0008 +#define STRUCT_VALUE_BIT 0x0010 +#define FIELD_VALUE_BIT 0x0020 +#define MACRO_VALUE_BIT 0x0040 +#define OPERAND_VALUE_BIT 0x0080 +#define STRING_VALUE_BIT 0x0100 +#define CONDITION_VALUE_BIT 0x0200 +#define UNDEFINED_VALUE_BIT 0x0400 +#define FUNCTION_VALUE_BIT 0x0800 +#define BLOCK_VALUE_BIT 0x1000 +#define BUILT_IN_FUNCTION_VALUE_BIT 0x2000 +#define ARRAY_VALUE_BIT 0x4000 +#define FAIL_BIT 0x8000 + +#include OPERAND_DEFS + +typedef struct { + valueKindType kindOfValue; + int value; + operandKindType addressMode; + } valueType; + +typedef struct { + int arraySize; + valueType **arrayContents; + } arrayType; + +/* + Input files are kept track of using 'fileNameListType'. A linked list of + these structs is built with one entry for each input file given on the + command line. Include files are pushed onto the head of this list. Thus, + the standard action upon reading an EOF is to pop the list. When the list + is empty, we're done! + */ + +typedef struct fileNameListStruct { + char *name; + FILE *fildes; + bool openFlag; + int lineNumber; + struct fileNameListStruct *nextFileName; + } fileNameListType; + +typedef struct commandLineDefineStruct { + char *name; + int value; + struct commandLineDefineStruct *nextDefine; + } commandLineDefineType; + +/* + Internal tables +*/ + +/* Symbol table: all user-defined symbols are kept in the symbol table. Each + symbol has but one entry. Associated with each such entry is a list of + 'symbolInContextType's that contain information pertaining to particular + uses of individual symbols. This is how we handle scoping in function and + macro calls. */ + +typedef int symbolAttributesType; /* Symbol attributes */ +#define GLOBAL_ATT 0x01 /* are orthogonal to symbol */ +#define ZERO_PAGE_ATT 0x02 /* type */ +#define DEFINED_VARIABLE_ATT 0x04 +#define SYMBOL_USED_ATT 0x08 +#define SPECIAL_FUNCTION_ATT 0x10 +#define TENTATIVE_GLOBAL_ATT 0x20 + +typedef enum { + STRUCT_NAME_SYMBOL, STRUCT_FIELD_SYMBOL, MACRO_SYMBOL, + ARGUMENT_SYMBOL, LABEL_SYMBOL, EXTERNAL_SYMBOL, + VARIABLE_SYMBOL, MVARIABLE_SYMBOL, UNKNOWN_SYMBOL, + DEAD_SYMBOL, FUNCTION_SYMBOL, BUILT_IN_FUNCTION_SYMBOL, + NESTED_UNKNOWN_SYMBOL, DEFINE_SYMBOL, MDEFINE_SYMBOL, + UNKNOWN_FUNCTION_SYMBOL, UNKNOWN_MACRO_SYMBOL, + } symbolUsageKindType; +#define NUM_OF_SYM_USAGES 17 + +typedef struct symbolInContextStruct { + valueType *value; + symbolUsageKindType usage; + symbolAttributesType attributes; + int referenceCount; + struct symbolInContextStruct *pushedContexts; + int environmentNumber; + int definingLineNumber; + char *definingFileName; + } symbolInContextType; +#define GLOBAL_ENVIRONMENT_NUMBER 0 + +typedef struct environmentStruct { + int environmentNumber; + struct environmentStruct *previousEnvironment; + } environmentType; + +#define pushEnvironment(newEnv) {\ + newEnv.environmentNumber = nextEnvironmentNumber++;\ + newEnv.previousEnvironment = currentEnvironment;\ + currentEnvironment = &newEnv;\ + } + +#define popEnvironment() currentEnvironment = currentEnvironment->\ + previousEnvironment; + +typedef struct symbolTableEntryStruct { + stringType *symbolName; + struct symbolTableEntryStruct *nextSymbol; + symbolInContextType *context; + int ordinal; + int referenceCount; + } symbolTableEntryType; + +#define symbName(sptr) ((sptr)->symbolName) + +/* symbolClass bits */ +#define SYMBOL_UNDEFINED 0x00 +#define SYMBOL_ABSOLUTE 0x02 +#define SYMBOL_RELOCATABLE 0x04 +#define SYMBOL_EXTERNAL 0x01 + +typedef struct { + byte symbolClass; /* see above */ + int symbolValue; + } objectSymbolType; + +/* These structs are used to allow us to put symbols in the object file */ + +#define MODE_ABSOLUTE 0 +#define MODE_RELOCATABLE 1 + +#define REF_BYTE 0 +#define REF_WORD 1 +#define REF_DBYTE 2 +#define REF_LONG 3 + +typedef struct { + bigWord referenceAddress : 24, /* target machine address */ + referenceMode : 1, /* see above MODE_xx defines*/ + referenceRelative : 1, /* TRUE==is relative */ + referenceKind : 3, /* see above REF_xx defines */ + referenceExternal : 1, /* TRUE==is ref to external */ + : 2; /* unused bits */ + int referenceExpression; /* local expression ordinal */ + } expressionReferenceType; + +#define ExpressionType struct expressionTermStruct + +typedef struct expressionReferenceListStruct { + expressionReferenceType relocation; + struct expressionReferenceListStruct *nextReference; + ExpressionType *expressionReferenced; + } expressionReferenceListType; + +/* These are sort of 'forward references' to types used in the construction of + parse trees, but they are refered to by various internal tables and so have + to go here, rather than with the other parse-tree types. */ + +#define BlockType struct statementStruct + +#define IdentifierListType struct identifierListStruct +#define IdentifierListHeadType struct identifierListHeadStruct + +typedef symbolTableEntryType argumentType; + +typedef struct argumentDefinitionListStruct { + argumentType *theArgument; + struct argumentDefinitionListStruct *nextArgument; + } argumentDefinitionListType; + +typedef struct { + argumentType *theArgument; + argumentDefinitionListType *nextArgument; + argumentDefinitionListType *tail; + bool arrayTag; + } argumentListHeadType; + +/* Macros: */ +typedef struct macroTableEntryStruct { + stringType *macroName; + struct macroTableEntryStruct *nextMacro; + argumentDefinitionListType *arguments; + BlockType *body; + } macroTableEntryType; + +/* Functions: */ +typedef struct functionDefinitionStruct { + symbolTableEntryType *functionName; + argumentDefinitionListType *arguments; + BlockType *body; + int ordinal; + struct functionDefinitionStruct *nextExternalFunction; + } functionDefinitionType; + +typedef struct opcodeTableEntryStruct { + stringType *mnemonic; + struct opcodeTableEntryStruct *nextOpcode; + unsigned int opcode; + addressClassType addressClass; + int permissibleOperandModes; + int minNumberOfOperands; + int maxNumberOfOperands; + int subClass; + } opcodeTableEntryType; + +/* Macross keywords: */ +typedef struct keywordTableEntryStruct { + stringType *string; + struct keywordTableEntryStruct *nextKeyword; + int token; + } keywordTableEntryType; + +/* All the various things that are stored in tables, like keywords, symbols + and macro names, are stored with a common format to the head of the struct + that defines them, so that a set of generic table handling routines may be + written. These routines look at the following type: */ + +typedef struct genericTableEntryStruct { + stringType *string; + struct genericTableEntryStruct *next; + } genericTableEntryType; +/* + Parser types -- These data types define the parse-tree data structure + which is constructed during the parse phase of assembly. This is the form + in which statements are stored internally prior to being turned into + object code, as well as the form in which macros and functions are + remembered. + + The exposition of the types is by necessity bottom-up. That's C. +*/ + +typedef int postOpKindType; + +typedef struct { + postOpKindType postOp; + ExpressionType *postOpArgument; + } postOpTermType; + +typedef int preOpKindType; + +typedef struct { + preOpKindType preOp; + ExpressionType *preOpArgument; + } preOpTermType; + +typedef int unopKindType; + +typedef int binopKindType; + +typedef enum { + ASSIGN_ASSIGN, ADD_ASSIGN, SUB_ASSIGN, MUL_ASSIGN, DIV_ASSIGN, + MOD_ASSIGN, AND_ASSIGN, OR_ASSIGN, XOR_ASSIGN, + LEFT_SHIFT_ASSIGN, RIGHT_SHIFT_ASSIGN, NO_ASSIGN + } assignmentKindType; + +typedef struct { + unopKindType unop; + ExpressionType *unopArgument; + } unopTermType; + +typedef struct { + binopKindType binop; + ExpressionType *leftArgument; + ExpressionType *rightArgument; + } binopTermType; + +#define ExpressionListType struct expressionListStruct + +typedef struct { + ExpressionType *arrayName; + ExpressionType *arrayIndex; + } arrayTermType; + +typedef ExpressionType subexpressionTermType; + +typedef int numberTermType; + +#define OperandListType struct operandStruct + +typedef struct { + symbolTableEntryType *functionName; + OperandListType *parameters; + } functionCallTermType; + +typedef symbolTableEntryType identifierTermType; + +typedef nullType hereTermType; + +#include CONDITION_DEFS + +typedef struct conditionTableEntryStruct { + stringType *string; + struct conditionTableEntryStruct *nextCondition; + conditionType code; + } conditionTableEntryType; + +typedef conditionType conditionCodeTermType; + +typedef stringType stringTermType; + +typedef enum { + IDENTIFIER_EXPR, FUNCTION_CALL_EXPR, NUMBER_EXPR, + SUBEXPRESSION_EXPR, UNOP_EXPR, BINOP_EXPR, PREOP_EXPR, + POSTOP_EXPR, HERE_EXPR, ASSIGN_EXPR, CONDITION_CODE_EXPR, + STRING_EXPR, VALUE_EXPR, ARRAY_EXPR, + } expressionTermKindType; + +typedef union expressionTermBodyUnion { + identifierTermType *identifierUnion; + functionCallTermType *functionCallUnion; + numberTermType numberUnion; + conditionCodeTermType conditionCodeUnion; + subexpressionTermType *subexpressionUnion; + unopTermType *unopUnion; + binopTermType *binopUnion; + preOpTermType *preOpUnion; + postOpTermType *postOpUnion; + hereTermType *hereUnion; + stringTermType *stringUnion; + arrayTermType *arrayUnion; + valueType *valueUnion; + } expressionTermBodyType; + +typedef struct expressionTermStruct { + expressionTermKindType kindOfTerm; + expressionTermBodyType expressionTerm; + } expressionTermType; + +typedef expressionTermType expressionType; + +typedef enum { + BYTE_FIXUP, WORD_FIXUP, NO_FIXUP, OPERAND_FIXUP, + BYTE_RELATIVE_FIXUP, DBYTE_FIXUP, NO_FIXUP_OK, LONG_FIXUP, + WORD_RELATIVE_FIXUP, + } fixupKindType; + +typedef enum { + ABSOLUTE_BUFFER, RELOCATABLE_BUFFER, + } codeBufferKindType; +#define LAST_BUFFER_KIND ((int)RELOCATABLE_BUFFER) +#define STRUCT_BUFFER (LAST_BUFFER_KIND + 1) + +typedef struct fixupListStruct { + addressType locationToFixup; + codeBufferKindType codeMode; + fixupKindType kindOfFixup; + expressionType *theFixupExpression; + int targetOffset; + stringType *fileName; + int lineNumber; + struct fixupListStruct *nextFixup; + } fixupListType; + +typedef struct simpleFixupListStruct { + valueType locationToFixup; + struct simpleFixupListStruct *nextFixup; + } simpleFixupListType; + +typedef expressionType performStatementBodyType; + +typedef expressionType orgStatementBodyType; + +typedef expressionType targetStatementBodyType; + +typedef expressionType startStatementBodyType; + +typedef struct identifierListStruct { + symbolTableEntryType *theSymbol; + struct identifierListStruct *nextIdentifier; + } identifierListType; + +typedef struct identifierListHeadStruct { + symbolTableEntryType *theSymbol; + struct identifierListStruct *nextIdentifier; + identifierListType *tail; + } identifierListHeadType; + +typedef identifierListType externStatementBodyType; + +#define StatementListType struct statementStruct + +typedef BlockType structBodyType; + +typedef struct { + structBodyType *structBody; + symbolTableEntryType *structName; + } structStatementBodyType; + +typedef enum { + UNTIL_END, WHILE_END + } doEndKindType; + +typedef struct { + doEndKindType mdoEndKind; + expressionType *mdoEndCondition; + } mdoEndType; + +typedef struct { + expressionType *mdoUntilCondition; + BlockType *mdoUntilLoop; + } mdoUntilStatementBodyType; + +typedef struct { + expressionType *mdoWhileCondition; + BlockType *mdoWhileLoop; + } mdoWhileStatementBodyType; + +typedef struct { + expressionType *mwhileCondition; + BlockType *mwhileLoop; + } mwhileStatementBodyType; + +typedef struct { + expressionType *initExpression; + expressionType *testExpression; + expressionType *incrExpression; + } forExpressionsType; + +typedef struct { + expressionType *initExpression; + expressionType *testExpression; + expressionType *incrExpression; + BlockType *forLoop; + } mforStatementBodyType; + +#define MifStatementBodyType struct mifStatementBodyStruct + +typedef MifStatementBodyType mifContinuationBodyType; + +typedef union { + mifContinuationBodyType *mifContinuationBodyUnion; + BlockType *mifBlockUnion; + } mifContinuationType; + +typedef struct { + expressionType *headCondition; + BlockType *headBody; + } mifHeadType; + +typedef struct mifStatementBodyStruct { + expressionType *mifCondition; + BlockType *mifConsequence; + mifContinuationType mifContinuation; + } mifStatementBodyType; + +typedef identifierListType undefineStatementBodyType; + +typedef struct { + macroTableEntryType *theMacro; + argumentDefinitionListType *theArguments; + BlockType *theBlock; + } macroStatementBodyType; + +typedef struct { + stringType *functionName; + argumentDefinitionListType *theArguments; + BlockType *theBlock; + } functionStatementBodyType; + +typedef struct { + symbolTableEntryType *theSymbol; + expressionType *theValue; + } defineStatementBodyType; + +typedef struct { + symbolTableEntryType *theSymbol; + expressionType *theValue; + } mdefineStatementBodyType; + +typedef struct { + symbolTableEntryType *theSymbol; + ExpressionListType *theValue; + expressionType *theDimension; + } variableStatementBodyType; + +typedef struct { + symbolTableEntryType *theSymbol; + ExpressionListType *theValue; + expressionType *theDimension; + } mvariableStatementBodyType; + +typedef identifierListType selectionListType; +typedef identifierListHeadType selectionListHeadType; + +#include OPERAND_BODY + +typedef struct operandStruct { + operandKindType kindOfOperand; + operandBodyType theOperand; + struct operandStruct *nextOperand; + } operandType; + +typedef struct { + operandKindType kindOfOperand; + valueType *theOperand; + } operandValueType; + +typedef expressionType freturnStatementBodyType; + +typedef operandType operandListType; + +typedef struct { + operandKindType kindOfOperand; + operandBodyType theOperand; + operandListType *nextOperand; + operandListType *tail; + } operandListHeadType; + +typedef union { + opcodeTableEntryType *opcodeUnion; + macroTableEntryType *macroUnion; + } instructionType; + +typedef enum { + OPCODE_INSTRUCTION, MACRO_INSTRUCTION + } instructionKindType; + +typedef struct { + instructionKindType kindOfInstruction; + instructionType theInstruction; + operandListType *theOperands; + } instructionStatementBodyType; + +typedef expressionType includeStatementBodyType; + +typedef struct expressionListStruct { + expressionType *theExpression; + struct expressionListStruct *nextExpression; + } expressionListType; + +typedef struct { + expressionType *theExpression; + expressionListType *nextExpression; + expressionListType *tail; + } expressionListHeadType; + +typedef expressionListType stringStatementBodyType; + +typedef expressionListType byteStatementBodyType; + +typedef expressionListType dbyteStatementBodyType; + +typedef expressionType alignStatementBodyType; + +typedef expressionListType wordStatementBodyType; + +typedef expressionListType longStatementBodyType; + +typedef struct { + doEndKindType doEndKind; + conditionType doEndCondition; + } doEndType; + +typedef struct { + conditionType doUntilCondition; + BlockType *doUntilLoop; + } doUntilStatementBodyType; + +typedef struct { + conditionType doWhileCondition; + BlockType *doWhileLoop; + } doWhileStatementBodyType; + +typedef struct { + conditionType whileCondition; + BlockType *whileLoop; + } whileStatementBodyType; + +#define IfStatementBodyType struct ifStatementBodyStruct + +typedef enum { + NO_CONTINUATION, ELSE_CONTINUATION, ELSEIF_CONTINUATION + } ifContinuationKindType; + +typedef IfStatementBodyType ifContinuationBodyType; + +typedef union { + ifContinuationBodyType *continuationBodyUnion; + BlockType *blockUnion; + } ifContinuationType; + +typedef struct { + conditionType headCondition; + BlockType *headBody; + } ifHeadType; + +typedef struct ifStatementBodyStruct { + conditionType ifCondition; + BlockType *consequence; + ifContinuationType continuation; + } ifStatementBodyType; + +typedef struct { + expressionType *constraint; + BlockType *constrainedBlock; + } constrainStatementBodyType; + +typedef struct { + expressionType *condition; + expressionType *message; + } assertStatementBodyType; + +typedef struct { + expressionListType *caseTags; + BlockType *caseBody; + } caseType; + +typedef struct caseListStruct { + caseType *theCase; + struct caseListStruct *nextCase; + } caseListType; + +typedef struct { + caseType *theCase; + caseListType *nextCase; + caseListType *tail; + } caseListHeadType; + +typedef struct { + expressionType *switchExpression; + caseListType *cases; + } mswitchStatementBodyType; + +typedef nullType relStatementBodyType; + +typedef expressionListType blockStatementBodyType; + +typedef BlockType groupStatementBodyType; + +typedef union { + ifStatementBodyType *ifUnion; + whileStatementBodyType *whileUnion; + doWhileStatementBodyType *doWhileUnion; + doUntilStatementBodyType *doUntilUnion; + wordStatementBodyType *wordUnion; + dbyteStatementBodyType *dbyteUnion; + byteStatementBodyType *byteUnion; + stringStatementBodyType *stringUnion; + blockStatementBodyType *blockUnion; + structStatementBodyType *structUnion; + instructionStatementBodyType *instructionUnion; + defineStatementBodyType *defineUnion; + mdefineStatementBodyType *mdefineUnion; + variableStatementBodyType *variableUnion; + mvariableStatementBodyType *mvariableUnion; + macroStatementBodyType *macroUnion; + functionStatementBodyType *functionUnion; + undefineStatementBodyType *undefineUnion; + mifStatementBodyType *mifUnion; + freturnStatementBodyType *freturnUnion; + mforStatementBodyType *mforUnion; + mwhileStatementBodyType *mwhileUnion; + mdoWhileStatementBodyType *mdoWhileUnion; + mdoUntilStatementBodyType *mdoUntilUnion; + includeStatementBodyType *includeUnion; + externStatementBodyType *externUnion; + startStatementBodyType *startUnion; + alignStatementBodyType *alignUnion; + orgStatementBodyType *orgUnion; + targetStatementBodyType *targetUnion; + relStatementBodyType *relUnion; + performStatementBodyType *performUnion; + groupStatementBodyType *groupUnion; + constrainStatementBodyType *constrainUnion; + assertStatementBodyType *assertUnion; + mswitchStatementBodyType *mswitchUnion; + longStatementBodyType *longUnion; + } statementBodyType; + +typedef enum { + IF_STATEMENT, WHILE_STATEMENT, DO_WHILE_STATEMENT, + DO_UNTIL_STATEMENT, WORD_STATEMENT, DBYTE_STATEMENT, + BYTE_STATEMENT, STRING_STATEMENT, STRUCT_STATEMENT, + INSTRUCTION_STATEMENT, DEFINE_STATEMENT, + UNDEFINE_STATEMENT, MIF_STATEMENT, + FRETURN_STATEMENT, MFOR_STATEMENT, MDO_WHILE_STATEMENT, + MDO_UNTIL_STATEMENT, INCLUDE_STATEMENT, EXTERN_STATEMENT, + START_STATEMENT, ALIGN_STATEMENT, ORG_STATEMENT, + REL_STATEMENT, PERFORM_STATEMENT, BLOCK_STATEMENT, + MWHILE_STATEMENT, MDEFINE_STATEMENT, NULL_STATEMENT, + GROUP_STATEMENT, MACRO_STATEMENT, FUNCTION_STATEMENT, + VARIABLE_STATEMENT, MVARIABLE_STATEMENT, CONSTRAIN_STATEMENT, + ASSERT_STATEMENT, MSWITCH_STATEMENT, LONG_STATEMENT, + TARGET_STATEMENT, + } statementKindType; + +typedef struct labelStruct { + symbolTableEntryType *theLabel; + struct labelStruct *nextLabel; + } labelType; + +typedef labelType labelListType; + +typedef struct { + symbolTableEntryType *theLabel; + labelListType *nextLabel; + labelListType *tail; + } labelListHeadType; + +typedef struct statementStruct { + statementKindType kindOfStatement; + labelListType *labels; + statementBodyType statementBody; + struct statementStruct *nextStatement; + stringType *fileName; + int lineNumber; + int cumulativeLineNumber; + } statementType; + +typedef statementType statementListType; + +typedef statementListType blockType; + +typedef struct { + statementKindType kindOfStatement; + labelListType *labels; + statementBodyType statementBody; + statementListType *nextStatement; + stringType *fileName; + int lineNumber; + int cumulativeLineNumber; + statementListType *tail; + } statementListHeadType; + +typedef statementListType programType; + +/* End of parse-tree types */ + + +#define UNASSIGNED NULL + +#define MAX_NAME_SIZE 300 + + +/* Struct instances */ + +#define MAXIMUM_ALLOWED_STRUCT_SIZE 255 + +typedef struct { + int structSize; + byte *structMap; + fixupListType *structFixups; + expressionReferenceListType *structReferences; + } structInstanceType; + + +/* Code output buffers */ + +#define CODE_BUFFER_SIZE 1024 +#if TARGET_CPU == CPU_6502 +#define CODE_BUFFERS_IN_ADDRESS_SPACE 64 + +#else if TARGET_CPU == CPU_68000 +#define CODE_BUFFERS_IN_ADDRESS_SPACE 256 + +#endif + +#define bufferNumber(addr) ((addr)/CODE_BUFFER_SIZE) +#define bufferPosition(addr) ((addr)%CODE_BUFFER_SIZE) + +typedef byte codeBufferType[CODE_BUFFER_SIZE]; + +typedef enum { + BREAK_BREAK, ALIGN_BREAK, CONSTRAIN_BREAK, + END_CONSTRAIN_BREAK, + } codeBreakKindType; + +typedef struct codeBreakStruct { + codeBreakKindType kindOfBreak; + addressType breakAddress; + int breakData; + struct codeBreakStruct *nextBreak; + } codeBreakType; + +typedef struct { + addressType codeStartAddress; + addressType codeEndAddress; + codeBufferType *codeBuffer; + } codeSegmentType; + +typedef struct { + addressType regionStartAddress; + addressType regionEndAddress; + codeSegmentType *codeSegments[ + CODE_BUFFERS_IN_ADDRESS_SPACE]; + } codeRegionType; + +typedef struct reservationListStruct { + addressType startAddress; + int blockSize; + struct reservationListStruct *nextReservation; + } reservationListType; + +#define LINE_BUFFER_SIZE 300 + +/* Error types */ + +typedef enum { + DEFINE_ASSIGNMENT_WRONG_ERROR, + DIGIT_OUT_OF_RADIX_ERROR, + UNCLOSED_CHARACTER_CONSTANT_ERROR, + UNCLOSED_STRING_CONSTANT_ERROR, + OCTAL_CHARACTER_TOO_BIG_ERROR, + UNRECOGNIZED_SOMETHING_OR_OTHER_ERROR, + UNCLOSED_COMMENT_ERROR, + UNCLOSED_LINE_COMMENT_ERROR, + UNABLE_TO_OPEN_PASS_2_FILE_ERROR, + BAD_ORG_ADDRESS_ERROR, + NEGATIVE_BLOCK_SIZE_ERROR, + UNASSIGNABLE_SYMBOL_TYPE_ERROR, + INCOMPATIBLE_ASSIGNMENT_OPERANDS_ERROR, + INCOMPATIBLE_BINOP_OPERANDS_ERROR, + UNPOSTINCREMENTABLE_OPERAND_ERROR, + UNPOSTDECREMENTABLE_OPERAND_ERROR, + UNPREINCREMENTABLE_OPERAND_ERROR, + UNPREDECREMENTABLE_OPERAND_ERROR, + INCOMPATIBLE_UNOP_OPERAND_ERROR, + VALUE_IS_NOT_AN_ADDRESS_ERROR, + VALUE_IS_NOT_AN_INT_ERROR, + IMPROPER_ALIGNMENT_VALUE_ERROR, + OPERATOR_ASSIGNMENT_ON_NULL_TARGET_ERROR, + TOO_MANY_INSTRUCTION_OPERANDS_ERROR, + ILLEGAL_OPERAND_TYPE_ERROR, + BYTE_VALUE_TOO_LARGE_ERROR, + WORD_VALUE_TOO_LARGE_ERROR, + BAD_INSTRUCTION_OPERAND_ERROR, + DIVIDE_BY_ZERO_ERROR, + UNDEFINED_SYMBOL_ERROR, + RELATIVE_OFFSET_TOO_LARGE_ERROR, + LABEL_ALREADY_DEFINED_ERROR, + CANT_OPEN_OBJECT_FILE_ERROR, + BAD_KIND_OF_SYMBOL_TO_MAKE_EXTERNAL_ERROR, + MORE_THAN_ONE_OUTPUT_FILE_ERROR, + BAD_COMMAND_LINE_FLAG_ERROR, + NO_DASH_O_FILE_NAME_ERROR, + UNABLE_TO_OPEN_INPUT_FILE_ERROR, + UNABLE_TO_OPEN_INCLUDE_FILE_ERROR, + INVALID_BOOLEAN_VALUE_ERROR, + SYMBOL_ALREADY_THERE_ERROR, + UNDECLARED_VARIABLE_ERROR, + REDEFINITION_OF_SYMBOL_ERROR, + NOT_A_STRUCT_NAME_ERROR, + STRUCT_TOO_BIG_ERROR, + FIELD_ALREADY_DEFINED_ERROR, + STRUCT_DEFINITION_INSIDE_STRUCT_DEFINITION_ERROR, + VALUE_IS_NOT_A_FIELD_ERROR, + MACRO_ALREADY_EXISTS_ERROR, + MACRO_DEFINITION_INSIDE_MACRO_ERROR, + TOO_MANY_ARGUMENTS_TO_MACRO_ERROR, + FUNCTION_DEFINITION_INSIDE_FUNCTION_ERROR, + FUNCTION_ALREADY_EXISTS_ERROR, + TOO_MANY_ARGUMENTS_TO_FUNCTION_ERROR, + NOT_A_FUNCTION_ERROR, + FUNCTION_DID_NOT_RETURN_A_VALUE_ERROR, + BAD_ADDRESS_MODE_ERROR, + MULTIPLE_ADDRESS_MODES_ERROR, + INCLUDE_FILE_NOT_A_STRING_VALUE_ERROR, + START_ADDRESS_ALREADY_GIVEN_ERROR, + FUNCTION_IS_NOT_A_VALUE_ERROR, + SIDE_EFFECT_ERROR, + CANT_FIND_SYMBOL_ERROR, + ERROR_INSIDE_MACRO_ERROR, + ERROR_INSIDE_FUNCTION_ERROR, + NO_LIST_FILE_NAME_ERROR, + NO_SYMBOL_DUMP_FILE_NAME_ERROR, + MORE_THAN_ONE_LIST_FILE_ERROR, + MORE_THAN_ONE_SYMBOL_DUMP_FILE_ERROR, + CANT_OPEN_LIST_FILE_ERROR, + CANT_OPEN_SYMBOL_DUMP_FILE_ERROR, + FILE_NAME_IS_NOT_MACROSS_SOURCE_ERROR, + OUTPUT_FILE_NAME_IS_MACROSS_SOURCE_ERROR, + LIST_FILE_NAME_IS_MACROSS_SOURCE_ERROR, + SYMBOL_DUMP_FILE_NAME_IS_MACROSS_SOURCE_ERROR, + INVALID_CONSTRAINT_VALUE_ERROR, + CONSTRAINT_ERROR, + UNASSIGNED_SYMBOL_ERROR, + BAD_START_ADDRESS_ERROR, + ALIGN_INSIDE_CONSTRAIN_ERROR, + CONSTRAIN_INSIDE_CONSTRAIN_ERROR, + NON_ADDRESS_WORD_VALUE_ERROR, + NON_ADDRESS_BYTE_VALUE_ERROR, + TOO_FEW_INSTRUCTION_OPERANDS_ERROR, + BAD_COLOR_ARGUMENT_TO_ATASCII_COLOR_ERROR, + PRINTF_FORMAT_IS_NOT_A_STRING_ERROR, + BIF_NTH_ARGUMENT_IS_NOT_A_STRING_ERROR, /* name, # */ + NO_ARGUMENTS_TO_BIF_ERROR, /* name */ + BIF_ARGUMENT_IS_NOT_A_STRING_ERROR, /* name */ + TOO_FEW_ARGUMENTS_TO_BIF_ERROR, /* name */ + BIF_NTH_ARGUMENT_IS_NOT_ABSOLUTE_VALUE_ERROR, /* name, # */ + BAD_SUBSTRING_INDICES_ERROR, + INVALID_ASSERT_CONDITION_ERROR, + INVALID_ASSERT_MESSAGE_ERROR, + ASSERT_WITH_MESSAGE_ERROR, + ASSERT_ERROR, + INVALID_SWITCH_VALUE_KIND, + INVALID_CASE_VALUE_KIND, + CANT_FORWARD_REFERENCE_BLOCK_ERROR, + MACRO_EXPANSION_WITHOUT_LISTING_ERROR, + INAPPROPRIATE_ADDRESS_MODES_ERROR, + CANT_DO_BYTE_ADDRESS_OP_ERROR, + QUICK_DATA_OUT_OF_RANGE_ERROR, + CCR_OP_IS_BYTE_OP_ERROR, + SR_OP_IS_WORD_OP_ERROR, + SHIFT_OP_IS_WORD_OP_ERROR, + CMP_ADDRESS_NOT_BYTE_OP_ERROR, + USP_MOVE_IS_LONG_OP_ERROR, + CCR_MOVE_IS_WORD_OP_ERROR, + SR_MOVE_IS_WORD_OP_ERROR, + CR_MOVE_IS_LONG_OP_ERROR, + ADDRESS_MOVE_NOT_BYTE_OP_ERROR, + TRAP_DATA_TOO_LARGE_ERROR, + RELATIVE_OFFSET_VALUE_TOO_LARGE_ERROR, + CANT_DO_OP_FROM_A_REGISTER_ERROR, + FORWARD_REFERENCE_NOT_ALLOWED_HERE_ERROR, + ADDRESS_OUTSIDE_ADDRESS_SPACE_ERROR, + APPLY_ARGUMENT_IS_NOT_MACRO_ERROR, + CANT_TARGET_IN_RELOCATABLE_MODE_ERROR, + BAD_TARGET_ADDRESS_ERROR, + UNDEFINED_MACRO_ERROR, + BAD_POSITION_ARGUMENT_TO_NTH_CHAR_ERROR, + SYMBOL_DEFINE_VALUE_NOT_EXPRESSION_OPND_ERROR, + ATTEMPT_TO_INDEX_NON_ARRAY_ERROR, + NON_INTEGER_INDEX_ERROR, + ARRAY_INDEX_OUT_OF_RANGE_ERROR, + TOO_MANY_VARIABLE_INITIALIZERS_ERROR, + NEGATIVE_ARRAY_INDEX_ERROR, + NON_ADDRESS_LONG_VALUE_ERROR, + CANT_POSTPREOP_STRING_ERROR, + NON_CHARACTER_STRING_ASSIGNMENT_ERROR, + NEGATIVE_ARRAY_SIZE_TO_MAKEARRAY_ERROR, + TOO_MANY_INITIALIZATION_ARGS_TO_MAKEARRAY_ERROR, + VALUELESS_ARRAY_ELEMENT_ERROR, + CANT_USE_PREOP_WITH_FORWARD_REFERENCE_ERROR, + CANT_USE_POSTOP_WITH_FORWARD_REFERENCE_ERROR, + CANT_USE_ASSIGNMENT_WITH_FORWARD_REFERENCE_ERROR, + TOO_MANY_ERRORS_ERROR, + EXPRESSION_TOO_BIG_TO_FIT_IN_OBJECT_ERROR, + FUNNY_ASSIGNMENT_KIND_IN_OBJECT_EXPRESSION_ERROR, + TEMP_SYMBOL_IN_OBJECT_ERROR, + } errorTypeX; +typedef enum {/* horrible kludge due to C compiler bug on Sun */ + BLOCK_OPERAND_IN_OBJECT_EXPRESSION_ERROR = + (int)TEMP_SYMBOL_IN_OBJECT_ERROR + 1, + REGISTER_OPERAND_IN_OBJECT_EXPRESSION_ERROR, + SELECTION_OPERAND_IN_OBJECT_EXPRESSION_ERROR, + WRONG_KIND_OF_VALUE_IN_OBJECT_EXPRESSION_ERROR, + ARRAY_TERM_IN_OBJECT_EXPRESSION_ERROR, + ILLEGAL_STATEMENT_IN_OBJECT_FILE_FUNCTION_ERROR, + ARRAY_MVARIABLE_IN_OBJECT_FUNCTION_ERROR, + BUILT_IN_FUNCTION_NOT_AVAILABLE_IN_OBJECT_ERROR, + NO_DASH_D_FILE_NAME_ERROR, + BAD_COMMAND_LINE_DEFINE_ERROR, + PERFORM_WITHOUT_SIDE_EFFECT_ERROR, + } errorType; + +#define ERROR_LIMIT 300 + +/* Misc. macros: */ + +#define qfree(thing) if (freeFlag) free(thing); +#define qsfree(thing) if (freeFlag&&statementEvaluationDepth<=1)free(thing); +#define toLowerCase(c) (lowerCaseCharacterTable[(c)]) +#define dupValue(new, v) {(new)=typeAlloc(valueType);*(new)= *(v);} +#define amListing() (listingOn && !listingControlCounter) +#define amExpanding() (expandMacros && !beneathFunction && \ + macroCallDepth > 0) +#define expand(x) if(amExpanding()){x;} + +#define EXPAND 1 +/* Boy, is this macro useful! */ + +#define typeAlloc(type) (type *)malloc(sizeof(type)) diff --git a/macross_6502.y b/macross_6502.y new file mode 100644 index 0000000..c149e4c --- /dev/null +++ b/macross_6502.y @@ -0,0 +1,1202 @@ +/* + macross.y -- Grammar and semantic rules for Macross parser + + Chip Morningstar -- Lucasfilm Ltd. + + 1-November-1984 + +*/ +%{ + +#include "macrossTypes.h" +#include "macrossGlobals.h" + +%} + +/* Token list is target system dependent */ +%token A ALIGN ASSERT BLOCK BYTE CONSTRAIN DBYTE DEFINE DO ELSE ELSEIF +%token ENDFILE EOL EXTERN FRETURN FUNCTION HERE IF INCLUDE LONG MACRO MCASE +%token MDEFAULT MDEFINE MDO MELSE MELSEIF MFOR MIF MSWITCH MUNTIL MVARIABLE +%token MWHILE ORG REL START STRING STRUCT TARGET UNDEFINE UNTIL VARIABLE +%token WHILE WORD X Y +%token ConditionCode Identifier MacroName Number Opcode TextString + +/* funny characters used literally: + + : , @ ( ) { } [ ] + +*/ + +%right ASSIGN /* = += *= -= /= %= <<= >>= &= |= + ^= */ +%left LOGICAL_OR /* || */ +%left LOGICAL_XOR /* ^^ */ +%left LOGICAL_AND /* && */ +%left BITWISE_OR /* | */ +%left BITWISE_XOR /* ^ */ +%left BITWISE_AND /* & */ +%nonassoc EQUAL_TO NOT_EQUAL_TO /* == != */ +%nonassoc LESS_THAN LESS_THAN_OR_EQUAL_TO GREATER_THAN GREATER_THAN_OR_EQUAL_TO + /* < <= > >= */ +%nonassoc '[' +%left LEFT_SHIFT RIGHT_SHIFT /* << >> */ +%left ADD SUB /* + - */ +%left MUL DIV MOD /* * / % */ +%right UNARY_MINUS LOGICAL_NOT BITWISE_NOT HI_BYTE LO_BYTE + /* - ! ~ ? / */ +%left SELECT /* . */ +%token INCREMENT DECREMENT /* ++ -- */ + +%% + +/* + In what follows, the comment "da" indicates that we are taking the default + action: + $$ = $1; + If this comment is not present, then then we intend there to be no action + even though yacc will give us the default. (The author's stylistic + tendencies being what they are, the default would have been entered + wherever it was intended, but this was found to clutter up the listing + excessively. +*/ + +program: beginProgram statementList EOL ENDFILE +{ + $$ = $2; +} + | ENDFILE +{ + $$ = 0; +} + ; + +beginProgram: /* null string */ +{ + statementListNestingDepth = 0; + errorFlag = FALSE; +} + ; + +/* "_" represents an optional newline (i.e., a whitespace newline as opposed + to an end-of-statement newline */ +_: eolList + | /* null string */ + ; + +eolList: EOL +{ + if (amListing()) + saveEOLForListing(); +} + | eolList EOL +{ + if (amListing()) + saveEOLForListing(); +} + ; + +statementList: statement +{ + if (statementListNestingDepth == 0) { + $$ = eatStatement($1); + } else { + $$ = buildStatementList($1, NULL); + } +} + | statementList EOL statement +{ + if (statementListNestingDepth == 0) { + $$ = eatStatement($3); + } else { + $$ = buildStatementList($3, $1); + } +} + ; + +statement: labeledStatement /* da */ + | unlabeledStatement /* da */ + | error ENDFILE +{ + $$ = NULL; + YYACCEPT; +} + | error +{ + yyerrok; + yyclearin; + resynchronizeInput(); + $$ = NULL; +} + ; + +labeledStatement: + labelList labelableStatement +{ + $$ = addLabelToStatement($1, $2); +} + ; + +unlabeledStatement: + labelableStatement /* da */ + ; + +labelList: label +{ + $$ = buildLabelList($1, NULL); +} + | labelList label +{ + $$ = buildLabelList($2, $1); +} + ; + +label: Identifier ':' +{ + $$ = lookupOrEnterSymbol($1, LABEL_SYMBOL); +} + | Identifier ':' ':' +{ + $$ = lookupOrEnterSymbol($1, LABEL_SYMBOL); + addAttributeToSymbol($$, TENTATIVE_GLOBAL_ATT); +} + ; + +labelableStatement: + ifStatement /* da */ + | whileStatement /* da */ + | doStatement /* da */ + | wordStatement /* da */ + | dbyteStatement /* da */ + | byteStatement /* da */ + | blockStatement /* da */ + | stringStatement /* da */ + | nullStatement /* da */ + | structStatement /* da */ + | performStatement /* da */ + | instructionStatement /* da */ + | groupStatement /* da */ + | defineStatement /* da */ + | macroDefineStatement /* da */ + | variableStatement /* da */ + | macroVariableStatement /* da */ + | macroStatement /* da */ + | functionStatement /* da */ + | functionReturnStatement /* da */ + | undefineStatement /* da */ + | macroIfStatement /* da */ + | macroWhileStatement /* da */ + | macroDoStatement /* da */ + | macroForStatement /* da */ + | macroSwitchStatement /* da */ + | includeStatement /* da */ + | externStatement /* da */ + | startStatement /* da */ + | alignStatement /* da */ + | orgStatement /* da */ + | relStatement /* da */ + | constrainStatement /* da */ + | assertStatement /* da */ + | longStatement /* da */ + | targetStatement /* da */ + ; + +ifStatement: IF _ ifHead +{ + $$ = buildIfStatement($3, NULL, NO_CONTINUATION); +} + | IF _ ifHead elsePart +{ + $$ = buildIfStatement($3, $4, ELSE_CONTINUATION); +} + | IF _ ifHead elseIf +{ + $$ = buildIfStatement($3, $4, ELSEIF_CONTINUATION); +} + ; + +ifHead: condition _ block +{ + $$ = buildIfHead($1, $3); +} + ; + +condition: '(' _ conditionExpression _ ')' +{ + $$ = $3; +} + ; + +conditionExpression: + ConditionCode /* da */ + | LOGICAL_NOT conditionExpression +{ + $$ = invertConditionCode($2); +} + | '(' _ conditionExpression _ ')' +{ + $$ = $3; +} + ; + +elsePart: ELSE _ block +{ + $$ = $3; +} + ; + +elseIf: ELSE _ ifStatement +{ + $$ = extractIfBody($3); +} + | ELSEIF _ ifHead +{ + $$ = extractIfBody(buildIfStatement($3, NULL, NO_CONTINUATION)); +} + | ELSEIF _ ifHead elsePart +{ + $$ = extractIfBody(buildIfStatement($3, $4, ELSE_CONTINUATION)); +} + | ELSEIF _ ifHead elseIf +{ + $$ = extractIfBody(buildIfStatement($3, $4, ELSEIF_CONTINUATION)); +} + ; + +whileStatement: WHILE _ condition _ block +{ + $$ = buildWhileStatement($3, $5); +} + ; + +doStatement: DO _ block _ doEnd +{ + $$ = buildDoStatement($3, $5); +} + ; + +doEnd: WHILE _ condition +{ + $$ = buildDoEnd($3, WHILE_END); +} + | UNTIL _ condition +{ + $$ = buildDoEnd($3, UNTIL_END); +} + ; + +wordStatement: WORD _ expressionList +{ + $$ = buildWordStatement($3); +} + ; + +longStatement: LONG _ expressionList +{ + $$ = buildLongStatement($3); +} + ; + +expressionList: expression +{ + $$ = buildExpressionList($1, NULL); +} + | expressionList ',' _ expression +{ + $$ = buildExpressionList($4, $1); +} + ; + +constrainStatement: + CONSTRAIN _ '(' _ expression _ ')' _ block +{ + $$ = buildConstrainStatement($5, $9); +} + ; + +assertStatement: + ASSERT _ '(' _ expression _ ')' expression +{ + $$ = buildAssertStatement($5, $8); +} + | ASSERT _ '(' _ expression _ ')' +{ + $$ = buildAssertStatement($5, NULL); +} + ; + +dbyteStatement: DBYTE _ expressionList +{ + $$ = buildDbyteStatement($3); +} + ; + +byteStatement: BYTE _ expressionList +{ + $$ = buildByteStatement($3); +} + ; + +blockStatement: BLOCK _ expressionList +{ + $$ = buildBlockStatement($3); +} + ; + +stringStatement: + STRING _ expressionList +{ + $$ = buildStringStatement($3); +} + ; + +structStatement: + STRUCT _ structName +{ + $$ = buildStructStatement($3, NULL); +} + | STRUCT _ structBody _ structName +{ + $$ = buildStructStatement($5, $3); +} + ; + +structName: Identifier +{ + $$ = lookupOrEnterSymbol($1, STRUCT_NAME_SYMBOL); +} + ; + +structBody: '{' structBodyStatementList '}' +{ + $$ = $2; +} + ; + +structBodyStatementList: + structBodyStatement +{ + $$ = buildStatementList($1, NULL); +} + | structBodyStatementList EOL structBodyStatement +{ + $$ = buildStatementList($3, $1); +} + ; + +structBodyStatement: + basicStructBodyStatement /* da */ + | labelList basicStructBodyStatement +{ + $$ = addLabelToStatement($1, $2); +} + ; + +basicStructBodyStatement: + wordStatement /* da */ + | dbyteStatement /* da */ + | byteStatement /* da */ + | blockStatement /* da */ + | stringStatement /* da */ + | alignStatement /* da */ + | nullStatement /* da */ + | structStatement /* da */ + | longStatement /* da */ + ; + +nullStatement: /* null string */ +{ + $$ = buildNullStatement(); +} + ; + +instructionStatement: + Opcode +{ + $$ = buildInstructionStatement($1, NULL); +} + | Opcode operandList +{ + $$ = buildInstructionStatement($1, $2); +} + | MacroName +{ + $$ = buildMacroInstructionStatement($1, NULL); +} + | MacroName operandList +{ + $$ = buildMacroInstructionStatement($1, $2); +} + ; + +groupStatement: block +{ + $$ = buildGroupStatement($1); +} + +defineStatement: + DEFINE _ defineTail +{ + $$ = $3; +} + ; + +defineTail: + Identifier +{ + $$ = buildDefineStatement($1, UNASSIGNED); +} + | Identifier ASSIGN /* must be '=' */ _ expression +{ + checkDefineAssignmentOperator($2); + $$ = buildDefineStatement($1, $4); +} + ; + +mdefineTail: + Identifier +{ + $$ = buildMdefineStatement($1, UNASSIGNED); +} + | Identifier ASSIGN /* must be '=' */ _ expression +{ + checkDefineAssignmentOperator($2); + $$ = buildMdefineStatement($1, $4); +} + ; + +macroStatement: + MACRO enter _ Identifier macroArguments _ block +{ + $$ = buildMacroStatement(createMacro($4), $5, $7); + popMacroOrFunctionNestingDepth(); +} + | MACRO enter _ Identifier _ block +{ + $$ = buildMacroStatement(createMacro($4), NULL, $6); + popMacroOrFunctionNestingDepth(); +} + | MACRO enter _ MacroName macroArguments _ block +{ + $$ = buildMacroStatement($4, $5, $7); + popMacroOrFunctionNestingDepth(); +} + | MACRO enter _ MacroName _ block +{ + $$ = buildMacroStatement($4, NULL, $6); + popMacroOrFunctionNestingDepth(); +} + ; + +enter: /* null string */ +{ + pushMacroOrFunctionNestingDepth(); +} + +macroArguments: argumentList; /* da */ + +functionStatement: + FUNCTION enter _ Identifier _ functionArguments _ block +{ + $$ = buildFunctionStatement($4, $6, $8); + popMacroOrFunctionNestingDepth(); +} + ; + +undefineStatement: + UNDEFINE _ identifierList +{ + $$ = buildUndefineStatement($3); +} + ; + +identifierList: Identifier +{ + $$ = buildIdentifierList($1, NULL, unknownSymbolTag); +} + | identifierList ',' _ Identifier +{ + $$ = buildIdentifierList($4, $1, unknownSymbolTag); +} + ; + +functionArguments: '(' ')' +{ + $$ = NULL; +} + | '(' argumentList ')' +{ + $$ = $2; +} + ; + +argumentList: basicArgumentList +{ + $$ = $1; +} + | basicArgumentList ',' _ variableArg +{ + $$ = buildArgumentList($4, $1, TRUE); +} + | variableArg +{ + $$ = buildArgumentList($1, NULL, TRUE); +} + ; + +basicArgumentList: + argument +{ + $$ = buildArgumentList($1, NULL, FALSE); +} + | basicArgumentList ',' _ argument +{ + $$ = buildArgumentList($4, $1, FALSE); +} + ; + +variableArg: Identifier '[' _ ']' /* da */ + ; + +argument: Identifier /* da */ + ; + +variableStatement: + VARIABLE _ variableTail +{ + $$ = $3; +} + ; + +variableTail: + Identifier +{ + $$ = buildVariableStatement($1, UNASSIGNED, NULL); +} + | Identifier ASSIGN /* must be '=' */ _ expressionList +{ + checkDefineAssignmentOperator($2); + $$ = buildVariableStatement($1, $4, NULL); +} + | Identifier '[' _ expression _ ']' +{ + $$ = buildVariableStatement($1, UNASSIGNED, $4); +} + | Identifier '[' _ expression _ ']' ASSIGN _ expressionList +{ + checkDefineAssignmentOperator($2); + $$ = buildVariableStatement($1, $9, $4); +} + | Identifier '[' ']' ASSIGN _ expressionList +{ + checkDefineAssignmentOperator($2); + $$ = buildVariableStatement($1, $6, -1); +} + ; + +macroVariableStatement: + MVARIABLE _ mvariableTail +{ + $$ = $3; +} + ; + +mvariableTail: + Identifier +{ + $$ = buildMvariableStatement($1, UNASSIGNED, NULL); +} + | Identifier ASSIGN /* must be '=' */ _ expressionList +{ + checkDefineAssignmentOperator($2); + $$ = buildMvariableStatement($1, $4, NULL); +} + | Identifier '[' _ expression _ ']' +{ + $$ = buildMvariableStatement($1, UNASSIGNED, $4); +} + | Identifier '[' _ expression _ ']' ASSIGN _ expressionList +{ + checkDefineAssignmentOperator($2); + $$ = buildMvariableStatement($1, $9, $4); +} + | Identifier '[' ']' ASSIGN _ expressionList +{ + checkDefineAssignmentOperator($2); + $$ = buildMvariableStatement($1, $6, -1); +} + ; + +macroDefineStatement: + MDEFINE _ mdefineTail +{ + $$ = $3; +} + ; + +macroIfStatement: + MIF _ mIfHead +{ + $$ = buildMifStatement($3, NULL, NO_CONTINUATION); +} + | MIF _ mIfHead mElsePart +{ + $$ = buildMifStatement($3, $4, ELSE_CONTINUATION); +} + | MIF _ mIfHead mElseIf +{ + $$ = buildMifStatement($3, $4, ELSEIF_CONTINUATION); +} + ; + +mIfHead: macroCondition _ block +{ + $$ = buildMifHead($1, $3); +} + ; + +macroCondition: '(' _ expression _ ')' +{ + $$ = $3; +} + ; + +mElsePart: MELSE _ block +{ + $$ = $3; +} + ; + +mElseIf: MELSE _ macroIfStatement +{ + $$ = extractMifBody($3); +} + | MELSEIF _ mIfHead +{ + $$ = extractMifBody(buildMifStatement($3, NULL, NO_CONTINUATION)); +} + | MELSEIF _ mIfHead mElsePart +{ + $$ = extractMifBody(buildMifStatement($3, $4, ELSE_CONTINUATION)); +} + | MELSEIF _ mIfHead mElseIf +{ + $$ = extractMifBody(buildMifStatement($3, $4, ELSEIF_CONTINUATION)); +} + ; + +macroSwitchStatement: + MSWITCH _ switch _ cases +{ + $$ = buildMswitchStatement($3, $5); +} + ; + +switch: '(' _ expression _ ')' +{ + $$ = $3; +} + ; + +cases: '{' _ caseList _ '}' +{ + $$ = $3; +} + | + '{' _ '}' +{ + $$ = NULL; +} + ; + +caseList: case +{ + $$ = buildCaseList($1, NULL); +} + | caseList _ case +{ + $$ = buildCaseList($3, $1); +} + ; + +case: caseTag _ block +{ + $$ = buildCase($1, $3); +} + ; + +caseTag: MCASE _ '(' _ expressionList _ ')' +{ + $$ = $5; +} + | MDEFAULT +{ + $$ = NULL; +} + ; + +macroWhileStatement: + MWHILE _ macroCondition _ block +{ + $$ = buildMwhileStatement($3, $5); +} + ; + +macroDoStatement: + MDO _ block _ macroDoEnd +{ + $$ = buildMdoStatement($3, $5); +} + ; + +macroDoEnd: WHILE _ macroCondition +{ + $$ = buildMdoEnd($3, WHILE_END); +} + | MWHILE _ macroCondition +{ + $$ = buildMdoEnd($3, WHILE_END); +} + | UNTIL _ macroCondition +{ + $$ = buildMdoEnd($3, UNTIL_END); +} + | MUNTIL _ macroCondition +{ + $$ = buildMdoEnd($3, UNTIL_END); +} + ; + +functionReturnStatement: + FRETURN +{ + $$ = buildFreturnStatement(NULL); +} + | FRETURN thingToReturn +{ + $$ = buildFreturnStatement($2); +} + ; + +thingToReturn: expression /* da */ + ; + +macroForStatement: + MFOR _ '(' _ forExpressions _ ')' _ block +{ + $$ = buildMforStatement($5, $9); +} + ; + +forExpressions: + expression ',' _ expression ',' _ expression +{ + $$ = buildForExpressions($1, $4, $7); +} + ; + +includeStatement: + INCLUDE _ expression +{ + $$ = buildIncludeStatement($3); +} + ; + +externStatement: + EXTERN _ identifierList +{ + $$ = buildExternStatement($3); +} + ; + +startStatement: START _ expression +{ + $$ = buildStartStatement($3); +} + ; + +alignStatement: ALIGN _ expression +{ + $$ = buildAlignStatement($3); +} + ; + +orgStatement: ORG _ expression +{ + $$ = buildOrgStatement($3); +} + ; + +targetStatement: + TARGET _ expression +{ + $$ = buildTargetStatement($3); +} + ; + +relStatement: REL +{ + $$ = buildRelStatement(); +} + ; + +performStatement: + expression +{ + $$ = buildPerformStatement($1); +} + ; + +operandList: blockEndingOperandList /* da */ + | nonBlockEndingOperandList /* da */ + ; + +blockEndingOperandList: + blockOperand +{ + $$ = buildOperandList($1, NULL); +} + | blockEndingOperandList blockOperand +{ + $$ = buildOperandList($2, $1); +} + | blockEndingOperandList ',' _ blockOperand +{ + $$ = buildOperandList($4, $1); +} + | nonBlockEndingOperandList blockOperand +{ + $$ = buildOperandList($2, $1); +} + | nonBlockEndingOperandList ',' _ blockOperand +{ + $$ = buildOperandList($4, $1); +} + ; + +nonBlockEndingOperandList: + nonBlockOperand +{ + $$ = buildOperandList($1, NULL); +} + | nonBlockEndingOperandList ',' _ nonBlockOperand +{ + $$ = buildOperandList($4, $1); +} + | blockEndingOperandList nonBlockOperand +{ + $$ = buildOperandList($2, $1); +} + | blockEndingOperandList ',' _ nonBlockOperand +{ + $$ = buildOperandList($4, $1); +} + ; + +blockOperand: block +{ + $$ = buildOperand(BLOCK_OPND, $1); +} + ; + +block: '{' nestDeeper statementList '}' +{ + $$ = $3; + statementListNestingDepth--; +} + ; + +nestDeeper: /* null string */ +{ + statementListNestingDepth++; +} + +selectionList: SELECT _ Identifier +{ + $$ = buildSelectionList($3, NULL); +} + | selectionList SELECT _ Identifier +{ + $$ = buildSelectionList($4, $1); +} + ; + +array: variable '[' _ expression _ ']' +{ + $$ = buildExpressionTerm(ARRAY_EXPR, $1, $4); +} + | array '[' _ expression _ ']' +{ + $$ = buildExpressionTerm(ARRAY_EXPR, $1, $4); +} + ; + +variable: Identifier +{ + $$ = buildExpressionTerm(IDENTIFIER_EXPR, lookupOrEnterSymbol($1, + unknownSymbolTag)); +} + ; + +lvalue: array /* da */ + | variable /* da */ + ; + +expression: lvalue +{ + $$ = $1; +} + | functionCall +{ + $$ = buildExpressionTerm(FUNCTION_CALL_EXPR, $1); +} + | Number +{ + $$ = buildExpressionTerm(NUMBER_EXPR, $1); +} + | ConditionCode +{ + $$ = buildExpressionTerm(CONDITION_CODE_EXPR, $1); +} + | HERE +{ + $$ = buildExpressionTerm(HERE_EXPR); +} + | TextString +{ + $$ = buildExpressionTerm(STRING_EXPR, $1); +} + | '(' _ expression _ ')' +{ + $$ = buildExpressionTerm(SUBEXPRESSION_EXPR, $3); +} + | SUB _ expression %prec UNARY_MINUS +{ + $$ = buildExpressionTerm(UNOP_EXPR, UNARY_MINUS, $3); +} + | LOGICAL_NOT _ expression +{ + $$ = buildExpressionTerm(UNOP_EXPR, LOGICAL_NOT, $3); +} + | BITWISE_NOT _ expression +{ + $$ = buildExpressionTerm(UNOP_EXPR, BITWISE_NOT, $3); +} + | DIV _ expression %prec LO_BYTE +{ + $$ = buildExpressionTerm(UNOP_EXPR, LO_BYTE, $3); +} + | HI_BYTE _ expression +{ + $$ = buildExpressionTerm(UNOP_EXPR, HI_BYTE, $3); +} + | expression MUL _ expression +{ + $$ = buildExpressionTerm(BINOP_EXPR, MUL, $1, $4); +} + | expression DIV _ expression +{ + $$ = buildExpressionTerm(BINOP_EXPR, DIV, $1, $4); +} + | expression MOD _ expression +{ + $$ = buildExpressionTerm(BINOP_EXPR, MOD, $1, $4); +} + | expression SUB _ expression +{ + $$ = buildExpressionTerm(BINOP_EXPR, SUB, $1, $4); +} + | expression ADD _ expression +{ + $$ = buildExpressionTerm(BINOP_EXPR, ADD, $1, $4); +} + | expression LEFT_SHIFT _ expression +{ + $$ = buildExpressionTerm(BINOP_EXPR, LEFT_SHIFT, $1, $4); +} + | expression RIGHT_SHIFT _ expression +{ + $$ = buildExpressionTerm(BINOP_EXPR, RIGHT_SHIFT, $1, $4); +} + | expression LESS_THAN _ expression +{ + $$ = buildExpressionTerm(BINOP_EXPR, LESS_THAN, $1, $4); +} + | expression GREATER_THAN _ expression +{ + $$ = buildExpressionTerm(BINOP_EXPR, GREATER_THAN, $1, $4); +} + | expression LESS_THAN_OR_EQUAL_TO _ expression +{ + $$ = buildExpressionTerm(BINOP_EXPR, LESS_THAN_OR_EQUAL_TO, $1, $4); +} + | expression GREATER_THAN_OR_EQUAL_TO _ expression +{ + $$ = buildExpressionTerm(BINOP_EXPR, GREATER_THAN_OR_EQUAL_TO, $1,$4); +} + | expression EQUAL_TO _ expression +{ + $$ = buildExpressionTerm(BINOP_EXPR, EQUAL_TO, $1, $4); +} + | expression NOT_EQUAL_TO _ expression +{ + $$ = buildExpressionTerm(BINOP_EXPR, NOT_EQUAL_TO, $1, $4); +} + | expression BITWISE_AND _ expression +{ + $$ = buildExpressionTerm(BINOP_EXPR, BITWISE_AND, $1, $4); +} + | expression BITWISE_OR _ expression +{ + $$ = buildExpressionTerm(BINOP_EXPR, BITWISE_OR, $1, $4); +} + | expression BITWISE_XOR _ expression +{ + $$ = buildExpressionTerm(BINOP_EXPR, BITWISE_XOR, $1, $4); +} + | expression LOGICAL_AND _ expression +{ + $$ = buildExpressionTerm(BINOP_EXPR, LOGICAL_AND, $1, $4); +} + | expression LOGICAL_OR _ expression +{ + $$ = buildExpressionTerm(BINOP_EXPR, LOGICAL_OR, $1, $4); +} + | expression LOGICAL_XOR _ expression +{ + $$ = buildExpressionTerm(BINOP_EXPR, LOGICAL_XOR, $1, $4); +} + | expression SELECT _ Identifier +{ + $$ = buildExpressionTerm(BINOP_EXPR, SELECT, $1, + lookupOrEnterSymbol($4, STRUCT_FIELD_SYMBOL)); +} + | lvalue ASSIGN _ expression +{ + $$ = buildExpressionTerm(ASSIGN_EXPR, $2, $1, $4); +} + | lvalue INCREMENT +{ + $$ = buildExpressionTerm(POSTOP_EXPR, INCREMENT, $1); +} + | lvalue DECREMENT +{ + $$ = buildExpressionTerm(POSTOP_EXPR, DECREMENT, $1); +} + | INCREMENT _ lvalue +{ + $$ = buildExpressionTerm(PREOP_EXPR, INCREMENT, $3); +} + | DECREMENT _ lvalue +{ + $$ = buildExpressionTerm(PREOP_EXPR, DECREMENT, $3); +} + ; + +functionCall: + functionName '(' _ ')' +{ + $$ = buildFunctionCall($1, NULL); +} + | functionName '(' _ functionArgumentList _ ')' +{ + $$ = buildFunctionCall($1, $4); +} + ; + +functionName: Identifier /* da */ + ; + +functionArgumentList: + operandList /* da */ + ; + +/* Stuff above this point is target independent (except for token list), stuff + below this points is target dependent (operand syntax) */ + +nonBlockOperand: + directExpression /* da */ + | indirectExpression /* da */ + | immediateExpression /* da */ + | registerExpression /* da */ + | indexedExpression /* da */ + | preIndexedXExpression /* da */ + | postIndexedYExpression /* da */ + ; + +directExpression: expression +{ + $$ = buildOperand(EXPRESSION_OPND, $1); +} + ; + +indirectExpression: '@' _ expression +{ + $$ = buildOperand(INDIRECT_OPND, $3); +} + ; + +immediateExpression: '#' _ expression +{ + $$ = buildOperand(IMMEDIATE_OPND, $3); +} + ; + +registerExpression: + A +{ + $$ = buildOperand(A_REGISTER_OPND, NULL); +} + | X +{ + $$ = buildOperand(X_REGISTER_OPND, NULL); +} + | Y +{ + $$ = buildOperand(Y_REGISTER_OPND, NULL); +} + ; + +indexedExpression: + X '[' _ expression _ ']' +{ + $$ = buildOperand(X_INDEXED_OPND, $4); +} + | Y '[' _ expression _ ']' +{ + $$ = buildOperand(Y_INDEXED_OPND, $4); +} + | X selectionList +{ + $$ = buildOperand(X_SELECTED_OPND, $2); +} + | Y selectionList +{ + $$ = buildOperand(Y_SELECTED_OPND, $2); +} + | '@' _ X +{ + $$ = buildOperand(X_INDEXED_OPND, NULL); +} + | '@' _ Y +{ + $$ = buildOperand(Y_INDEXED_OPND, NULL); +} + ; + +preIndexedXExpression: + '@' _ X '[' _ expression _ ']' +{ + $$ = buildOperand(PRE_INDEXED_X_OPND, $6); +} + | '@' _ X selectionList +{ + $$ = buildOperand(PRE_SELECTED_X_OPND, $4); +} + ; + +postIndexedYExpression: + Y '[' _ '@' _ expression _ ']' +{ + $$ = buildOperand(POST_INDEXED_Y_OPND, $6); +} + ; diff --git a/macross_68000.y b/macross_68000.y new file mode 100644 index 0000000..cc52c66 --- /dev/null +++ b/macross_68000.y @@ -0,0 +1,1362 @@ +/* + macross.y -- Grammar and semantic rules for Macross parser + + Chip Morningstar -- Lucasfilm Ltd. + + 1-November-1984 + +*/ +%{ + +#include "macrossTypes.h" +#include "macrossGlobals.h" + +%} + +/* Token list is target system dependent */ +%token A0 A1 A2 A3 A4 A5 A6 A7 ALIGN ASSERT BLOCK BYTE CCR CONSTRAIN D0 D1 D2 +%token D3 D4 D5 D6 D7 DBYTE DEFINE DFC DO ELSE ELSEIF ENDFILE EOL EXTERN +%token FRETURN FUNCTION HERE IF INCLUDE L LONG MACRO MCASE MDEFAULT MDEFINE +%token MDO MELSE MELSEIF MFOR MIF MSWITCH MUNTIL MVARIABLE MWHILE ORG PC REL +%token SFC SR START STRING STRUCT TARGET UNDEFINE UNTIL USP VARIABLE VBR W +%token WHILE WORD +%token ConditionCode Identifier MacroName Number Opcode TextString + +/* funny characters used literally: + + : , @ ( ) { } [ ] + +*/ + +%right ASSIGN /* = += *= -= /= %= <<= >>= &= |= + ^= */ +%left LOGICAL_OR /* || */ +%left LOGICAL_XOR /* ^^ */ +%left LOGICAL_AND /* && */ +%left BITWISE_OR /* | */ +%left BITWISE_XOR /* ^ */ +%left BITWISE_AND /* & */ +%nonassoc EQUAL_TO NOT_EQUAL_TO /* == != */ +%nonassoc LESS_THAN LESS_THAN_OR_EQUAL_TO GREATER_THAN GREATER_THAN_OR_EQUAL_TO + /* < <= > >= */ +/* %nonassoc '['*/ +%left LEFT_SHIFT RIGHT_SHIFT /* << >> */ +%left ADD SUB /* + - */ +%left MUL DIV MOD /* * / % */ +%right UNARY_MINUS LOGICAL_NOT BITWISE_NOT HI_BYTE LO_BYTE + /* - ! ~ ? / */ +%left SELECT /* . */ +%token INCREMENT DECREMENT /* ++ -- */ + +%% + +/* + In what follows, the comment "da" indicates that we are taking the default + action: + $$ = $1; + If this comment is not present, then then we intend there to be no action + even though yacc will give us the default. (The author's stylistic + tendencies being what they are, the default would have been entered + wherever it was intended, but this was found to clutter up the listing + excessively. +*/ + +program: beginProgram statementList EOL ENDFILE +{ + $$ = $2; +} + | ENDFILE +{ + $$ = 0; +} + ; + +beginProgram: /* null string */ +{ + statementListNestingDepth = 0; + errorFlag = FALSE; +} + ; + +/* "_" represents an optional newline (i.e., a whitespace newline as opposed + to an end-of-statement newline */ +_: eolList + | /* null string */ + ; + +eolList: EOL +{ + if (amListing()) + saveEOLForListing(); +} + | eolList EOL +{ + if (amListing()) + saveEOLForListing(); +} + ; + +statementList: statement +{ + if (statementListNestingDepth == 0) { + $$ = eatStatement($1); + } else { + $$ = buildStatementList($1, NULL); + } +} + | statementList EOL statement +{ + if (statementListNestingDepth == 0) { + $$ = eatStatement($3); + } else { + $$ = buildStatementList($3, $1); + } +} + ; + +statement: labeledStatement /* da */ + | unlabeledStatement /* da */ + | error ENDFILE +{ + $$ = NULL; + YYACCEPT; +} + | error +{ + yyerrok; + yyclearin; + resynchronizeInput(); + $$ = NULL; +} + ; + +labeledStatement: + labelList labelableStatement +{ + $$ = addLabelToStatement($1, $2); +} + ; + +unlabeledStatement: + labelableStatement /* da */ + ; + +labelList: label +{ + $$ = buildLabelList($1, NULL); +} + | labelList label +{ + $$ = buildLabelList($2, $1); +} + ; + +label: Identifier ':' +{ + $$ = lookupOrEnterSymbol($1, LABEL_SYMBOL); +} + | Identifier ':' ':' +{ + $$ = lookupOrEnterSymbol($1, LABEL_SYMBOL); + addAttributeToSymbol($$, TENTATIVE_GLOBAL_ATT); +} + ; + +labelableStatement: + ifStatement /* da */ + | whileStatement /* da */ + | doStatement /* da */ + | wordStatement /* da */ + | dbyteStatement /* da */ + | byteStatement /* da */ + | blockStatement /* da */ + | stringStatement /* da */ + | nullStatement /* da */ + | structStatement /* da */ + | performStatement /* da */ + | instructionStatement /* da */ + | groupStatement /* da */ + | defineStatement /* da */ + | macroDefineStatement /* da */ + | variableStatement /* da */ + | macroVariableStatement /* da */ + | macroStatement /* da */ + | functionStatement /* da */ + | functionReturnStatement /* da */ + | undefineStatement /* da */ + | macroIfStatement /* da */ + | macroWhileStatement /* da */ + | macroDoStatement /* da */ + | macroForStatement /* da */ + | macroSwitchStatement /* da */ + | includeStatement /* da */ + | externStatement /* da */ + | startStatement /* da */ + | alignStatement /* da */ + | orgStatement /* da */ + | relStatement /* da */ + | constrainStatement /* da */ + | assertStatement /* da */ + | longStatement /* da */ + | targetStatement /* da */ + ; + +ifStatement: IF _ ifHead +{ + $$ = buildIfStatement($3, NULL, NO_CONTINUATION); +} + | IF _ ifHead elsePart +{ + $$ = buildIfStatement($3, $4, ELSE_CONTINUATION); +} + | IF _ ifHead elseIf +{ + $$ = buildIfStatement($3, $4, ELSEIF_CONTINUATION); +} + ; + +ifHead: condition _ block +{ + $$ = buildIfHead($1, $3); +} + ; + +condition: '(' _ conditionExpression _ ')' +{ + $$ = $3; +} + ; + +conditionExpression: + ConditionCode /* da */ + | LOGICAL_NOT conditionExpression +{ + $$ = invertConditionCode($2); +} + | '(' _ conditionExpression _ ')' +{ + $$ = $3; +} + ; + +elsePart: ELSE _ block +{ + $$ = $3; +} + ; + +elseIf: ELSE _ ifStatement +{ + $$ = extractIfBody($3); +} + | ELSEIF _ ifHead +{ + $$ = extractIfBody(buildIfStatement($3, NULL, NO_CONTINUATION)); +} + | ELSEIF _ ifHead elsePart +{ + $$ = extractIfBody(buildIfStatement($3, $4, ELSE_CONTINUATION)); +} + | ELSEIF _ ifHead elseIf +{ + $$ = extractIfBody(buildIfStatement($3, $4, ELSEIF_CONTINUATION)); +} + ; + +whileStatement: WHILE _ condition _ block +{ + $$ = buildWhileStatement($3, $5); +} + ; + +doStatement: DO _ block _ doEnd +{ + $$ = buildDoStatement($3, $5); +} + ; + +doEnd: WHILE _ condition +{ + $$ = buildDoEnd($3, WHILE_END); +} + | UNTIL _ condition +{ + $$ = buildDoEnd($3, UNTIL_END); +} + ; + +wordStatement: WORD _ expressionList +{ + $$ = buildWordStatement($3); +} + ; + +longStatement: LONG _ expressionList +{ + $$ = buildLongStatement($3); +} + ; + +expressionList: expression +{ + $$ = buildExpressionList($1, NULL); +} + | expressionList ',' _ expression +{ + $$ = buildExpressionList($4, $1); +} + ; + +constrainStatement: + CONSTRAIN _ '(' _ expression _ ')' _ block +{ + $$ = buildConstrainStatement($5, $9); +} + ; + +assertStatement: + ASSERT _ '(' _ expression _ ')' expression +{ + $$ = buildAssertStatement($5, $8); +} + | ASSERT _ '(' _ expression _ ')' +{ + $$ = buildAssertStatement($5, NULL); +} + ; + +dbyteStatement: DBYTE _ expressionList +{ + $$ = buildDbyteStatement($3); +} + ; + +byteStatement: BYTE _ expressionList +{ + $$ = buildByteStatement($3); +} + ; + +blockStatement: BLOCK _ expressionList +{ + $$ = buildBlockStatement($3); +} + ; + +stringStatement: + STRING _ expressionList +{ + $$ = buildStringStatement($3); +} + ; + +structStatement: + STRUCT _ structName +{ + $$ = buildStructStatement($3, NULL); +} + | STRUCT _ structBody _ structName +{ + $$ = buildStructStatement($5, $3); +} + ; + +structName: Identifier +{ + $$ = lookupOrEnterSymbol($1, STRUCT_NAME_SYMBOL); +} + ; + +structBody: '{' structBodyStatementList '}' +{ + $$ = $2; +} + ; + +structBodyStatementList: + structBodyStatement +{ + $$ = buildStatementList($1, NULL); +} + | structBodyStatementList EOL structBodyStatement +{ + $$ = buildStatementList($3, $1); +} + ; + +structBodyStatement: + basicStructBodyStatement /* da */ + | labelList basicStructBodyStatement +{ + $$ = addLabelToStatement($1, $2); +} + ; + +basicStructBodyStatement: + wordStatement /* da */ + | dbyteStatement /* da */ + | byteStatement /* da */ + | blockStatement /* da */ + | stringStatement /* da */ + | alignStatement /* da */ + | nullStatement /* da */ + | structStatement /* da */ + | longStatement /* da */ + ; + +nullStatement: /* null string */ +{ + $$ = buildNullStatement(); +} + ; + +instructionStatement: + Opcode +{ + $$ = buildInstructionStatement($1, NULL); +} + | Opcode operandList +{ + $$ = buildInstructionStatement($1, $2); +} + | MacroName +{ + $$ = buildMacroInstructionStatement($1, NULL); +} + | MacroName operandList +{ + $$ = buildMacroInstructionStatement($1, $2); +} + ; + +groupStatement: block +{ + $$ = buildGroupStatement($1); +} + +defineStatement: + DEFINE _ defineTail +{ + $$ = $3; +} + ; + +defineTail: + Identifier +{ + $$ = buildDefineStatement($1, UNASSIGNED); +} + | Identifier ASSIGN /* must be '=' */ _ expression +{ + checkDefineAssignmentOperator($2); + $$ = buildDefineStatement($1, $4); +} + ; + +mdefineTail: + Identifier +{ + $$ = buildMdefineStatement($1, UNASSIGNED); +} + | Identifier ASSIGN /* must be '=' */ _ expression +{ + checkDefineAssignmentOperator($2); + $$ = buildMdefineStatement($1, $4); +} + ; + +macroStatement: + MACRO enter _ Identifier macroArguments _ block +{ + $$ = buildMacroStatement(createMacro($4), $5, $7); + popMacroOrFunctionNestingDepth(); +} + | MACRO enter _ Identifier _ block +{ + $$ = buildMacroStatement(createMacro($4), NULL, $6); + popMacroOrFunctionNestingDepth(); +} + | MACRO enter _ MacroName macroArguments _ block +{ + $$ = buildMacroStatement($4, $5, $7); + popMacroOrFunctionNestingDepth(); +} + | MACRO enter _ MacroName _ block +{ + $$ = buildMacroStatement($4, NULL, $6); + popMacroOrFunctionNestingDepth(); +} + ; + +enter: /* null string */ +{ + pushMacroOrFunctionNestingDepth(); +} + +macroArguments: argumentList; /* da */ + +functionStatement: + FUNCTION enter _ Identifier _ functionArguments _ block +{ + $$ = buildFunctionStatement($4, $6, $8); + popMacroOrFunctionNestingDepth(); +} + ; + +undefineStatement: + UNDEFINE _ identifierList +{ + $$ = buildUndefineStatement($3); +} + ; + +identifierList: Identifier +{ + $$ = buildIdentifierList($1, NULL, unknownSymbolTag); +} + | identifierList ',' _ Identifier +{ + $$ = buildIdentifierList($4, $1, unknownSymbolTag); +} + ; + +functionArguments: '(' ')' +{ + $$ = NULL; +} + | '(' argumentList ')' +{ + $$ = $2; +} + ; + +argumentList: basicArgumentList +{ + $$ = $1; +} + | basicArgumentList ',' _ variableArg +{ + $$ = buildArgumentList($4, $1, TRUE); +} + | variableArg +{ + $$ = buildArgumentList($1, NULL, TRUE); +} + ; + +basicArgumentList: + argument +{ + $$ = buildArgumentList($1, NULL, FALSE); +} + | basicArgumentList ',' _ argument +{ + $$ = buildArgumentList($4, $1, FALSE); +} + ; + +variableArg: Identifier '[' _ ']' /* da */ + ; + +argument: Identifier /* da */ + ; + +variableStatement: + VARIABLE _ variableTail +{ + $$ = $3; +} + ; + +variableTail: + Identifier +{ + $$ = buildVariableStatement($1, UNASSIGNED, NULL); +} + | Identifier ASSIGN /* must be '=' */ _ expressionList +{ + checkDefineAssignmentOperator($2); + $$ = buildVariableStatement($1, $4, NULL); +} + | Identifier '[' _ expression _ ']' +{ + $$ = buildVariableStatement($1, UNASSIGNED, $4); +} + | Identifier '[' _ expression _ ']' ASSIGN _ expressionList +{ + checkDefineAssignmentOperator($2); + $$ = buildVariableStatement($1, $9, $4); +} + | Identifier '[' ']' ASSIGN _ expressionList +{ + checkDefineAssignmentOperator($2); + $$ = buildVariableStatement($1, $6, -1); +} + ; + +macroVariableStatement: + MVARIABLE _ mvariableTail +{ + $$ = $3; +} + ; + +mvariableTail: + Identifier +{ + $$ = buildMvariableStatement($1, UNASSIGNED, NULL); +} + | Identifier ASSIGN /* must be '=' */ _ expressionList +{ + checkDefineAssignmentOperator($2); + $$ = buildMvariableStatement($1, $4, NULL); +} + | Identifier '[' _ expression _ ']' +{ + $$ = buildMvariableStatement($1, UNASSIGNED, $4); +} + | Identifier '[' _ expression _ ']' ASSIGN _ expressionList +{ + checkDefineAssignmentOperator($2); + $$ = buildMvariableStatement($1, $9, $4); +} + | Identifier '[' ']' ASSIGN _ expressionList +{ + checkDefineAssignmentOperator($2); + $$ = buildMvariableStatement($1, $6, -1); +} + ; + +macroDefineStatement: + MDEFINE _ mdefineTail +{ + $$ = $3; +} + ; + +macroIfStatement: + MIF _ mIfHead +{ + $$ = buildMifStatement($3, NULL, NO_CONTINUATION); +} + | MIF _ mIfHead mElsePart +{ + $$ = buildMifStatement($3, $4, ELSE_CONTINUATION); +} + | MIF _ mIfHead mElseIf +{ + $$ = buildMifStatement($3, $4, ELSEIF_CONTINUATION); +} + ; + +mIfHead: macroCondition _ block +{ + $$ = buildMifHead($1, $3); +} + ; + +macroCondition: '(' _ expression _ ')' +{ + $$ = $3; +} + ; + +mElsePart: MELSE _ block +{ + $$ = $3; +} + ; + +mElseIf: MELSE _ macroIfStatement +{ + $$ = extractMifBody($3); +} + | MELSEIF _ mIfHead +{ + $$ = extractMifBody(buildMifStatement($3, NULL, NO_CONTINUATION)); +} + | MELSEIF _ mIfHead mElsePart +{ + $$ = extractMifBody(buildMifStatement($3, $4, ELSE_CONTINUATION)); +} + | MELSEIF _ mIfHead mElseIf +{ + $$ = extractMifBody(buildMifStatement($3, $4, ELSEIF_CONTINUATION)); +} + ; + +macroSwitchStatement: + MSWITCH _ switch _ cases +{ + $$ = buildMswitchStatement($3, $5); +} + ; + +switch: '(' _ expression _ ')' +{ + $$ = $3; +} + ; + +cases: '{' _ caseList _ '}' +{ + $$ = $3; +} + | + '{' _ '}' +{ + $$ = NULL; +} + ; + +caseList: case +{ + $$ = buildCaseList($1, NULL); +} + | caseList _ case +{ + $$ = buildCaseList($3, $1); +} + ; + +case: caseTag _ block +{ + $$ = buildCase($1, $3); +} + ; + +caseTag: MCASE _ '(' _ expressionList _ ')' +{ + $$ = $5; +} + | MDEFAULT +{ + $$ = NULL; +} + ; + +macroWhileStatement: + MWHILE _ macroCondition _ block +{ + $$ = buildMwhileStatement($3, $5); +} + ; + +macroDoStatement: + MDO _ block _ macroDoEnd +{ + $$ = buildMdoStatement($3, $5); +} + ; + +macroDoEnd: WHILE _ macroCondition +{ + $$ = buildMdoEnd($3, WHILE_END); +} + | MWHILE _ macroCondition +{ + $$ = buildMdoEnd($3, WHILE_END); +} + | UNTIL _ macroCondition +{ + $$ = buildMdoEnd($3, UNTIL_END); +} + | MUNTIL _ macroCondition +{ + $$ = buildMdoEnd($3, UNTIL_END); +} + ; + +functionReturnStatement: + FRETURN +{ + $$ = buildFreturnStatement(NULL); +} + | FRETURN thingToReturn +{ + $$ = buildFreturnStatement($2); +} + ; + +thingToReturn: expression /* da */ + ; + +macroForStatement: + MFOR _ '(' _ forExpressions _ ')' _ block +{ + $$ = buildMforStatement($5, $9); +} + ; + +forExpressions: + expression ',' _ expression ',' _ expression +{ + $$ = buildForExpressions($1, $4, $7); +} + ; + +includeStatement: + INCLUDE _ expression +{ + $$ = buildIncludeStatement($3); +} + ; + +externStatement: + EXTERN _ identifierList +{ + $$ = buildExternStatement($3); +} + ; + +startStatement: START _ expression +{ + $$ = buildStartStatement($3); +} + ; + +alignStatement: ALIGN _ expression +{ + $$ = buildAlignStatement($3); +} + ; + +orgStatement: ORG _ expression +{ + $$ = buildOrgStatement($3); +} + ; + +targetStatement: + TARGET _ expression +{ + $$ = buildTargetStatement($3); +} + ; + +relStatement: REL +{ + $$ = buildRelStatement(); +} + ; + +performStatement: + expression +{ + $$ = buildPerformStatement($1); +} + ; + +operandList: blockEndingOperandList /* da */ + | nonBlockEndingOperandList /* da */ + ; + +blockEndingOperandList: + blockOperand +{ + $$ = buildOperandList($1, NULL); +} + | blockEndingOperandList blockOperand +{ + $$ = buildOperandList($2, $1); +} + | blockEndingOperandList ',' _ blockOperand +{ + $$ = buildOperandList($4, $1); +} + | nonBlockEndingOperandList blockOperand +{ + $$ = buildOperandList($2, $1); +} + | nonBlockEndingOperandList ',' _ blockOperand +{ + $$ = buildOperandList($4, $1); +} + ; + +nonBlockEndingOperandList: + nonBlockOperand +{ + $$ = buildOperandList($1, NULL); +} + | nonBlockEndingOperandList ',' _ nonBlockOperand +{ + $$ = buildOperandList($4, $1); +} + | blockEndingOperandList nonBlockOperand +{ + $$ = buildOperandList($2, $1); +} + | blockEndingOperandList ',' _ nonBlockOperand +{ + $$ = buildOperandList($4, $1); +} + ; + +blockOperand: block +{ + $$ = buildOperand(BLOCK_OPND, $1); +} + ; + +block: '{' nestDeeper statementList '}' +{ + $$ = $3; + statementListNestingDepth--; +} + ; + +nestDeeper: /* null string */ +{ + statementListNestingDepth++; +} + +selectionList: SELECT _ Identifier +{ + $$ = buildSelectionList($3, NULL); +} + | selectionList SELECT _ Identifier +{ + $$ = buildSelectionList($4, $1); +} + ; + +array: variable '[' _ expression _ ']' +{ + $$ = buildExpressionTerm(ARRAY_EXPR, $1, $4); +} + | array '[' _ expression _ ']' +{ + $$ = buildExpressionTerm(ARRAY_EXPR, $1, $4); +} + ; + +variable: Identifier +{ + $$ = buildExpressionTerm(IDENTIFIER_EXPR, lookupOrEnterSymbol($1, + unknownSymbolTag)); +} + ; + +lvalue: array /* da */ + | variable /* da */ + ; + +expression: lvalue +{ + $$ = $1; +} + | functionCall +{ + $$ = buildExpressionTerm(FUNCTION_CALL_EXPR, $1); +} + | Number +{ + $$ = buildExpressionTerm(NUMBER_EXPR, $1); +} + | ConditionCode +{ + $$ = buildExpressionTerm(CONDITION_CODE_EXPR, $1); +} + | HERE +{ + $$ = buildExpressionTerm(HERE_EXPR); +} + | TextString +{ + $$ = buildExpressionTerm(STRING_EXPR, $1); +} + | '(' _ expression _ ')' +{ + $$ = buildExpressionTerm(SUBEXPRESSION_EXPR, $3); +} + | SUB _ expression %prec UNARY_MINUS +{ + $$ = buildExpressionTerm(UNOP_EXPR, UNARY_MINUS, $3); +} + | LOGICAL_NOT _ expression +{ + $$ = buildExpressionTerm(UNOP_EXPR, LOGICAL_NOT, $3); +} + | BITWISE_NOT _ expression +{ + $$ = buildExpressionTerm(UNOP_EXPR, BITWISE_NOT, $3); +} + | DIV _ expression %prec LO_BYTE +{ + $$ = buildExpressionTerm(UNOP_EXPR, LO_BYTE, $3); +} + | HI_BYTE _ expression +{ + $$ = buildExpressionTerm(UNOP_EXPR, HI_BYTE, $3); +} + | expression MUL _ expression +{ + $$ = buildExpressionTerm(BINOP_EXPR, MUL, $1, $4); +} + | expression DIV _ expression +{ + $$ = buildExpressionTerm(BINOP_EXPR, DIV, $1, $4); +} + | expression MOD _ expression +{ + $$ = buildExpressionTerm(BINOP_EXPR, MOD, $1, $4); +} + | expression SUB _ expression +{ + $$ = buildExpressionTerm(BINOP_EXPR, SUB, $1, $4); +} + | expression ADD _ expression +{ + $$ = buildExpressionTerm(BINOP_EXPR, ADD, $1, $4); +} + | expression LEFT_SHIFT _ expression +{ + $$ = buildExpressionTerm(BINOP_EXPR, LEFT_SHIFT, $1, $4); +} + | expression RIGHT_SHIFT _ expression +{ + $$ = buildExpressionTerm(BINOP_EXPR, RIGHT_SHIFT, $1, $4); +} + | expression LESS_THAN _ expression +{ + $$ = buildExpressionTerm(BINOP_EXPR, LESS_THAN, $1, $4); +} + | expression GREATER_THAN _ expression +{ + $$ = buildExpressionTerm(BINOP_EXPR, GREATER_THAN, $1, $4); +} + | expression LESS_THAN_OR_EQUAL_TO _ expression +{ + $$ = buildExpressionTerm(BINOP_EXPR, LESS_THAN_OR_EQUAL_TO, $1, $4); +} + | expression GREATER_THAN_OR_EQUAL_TO _ expression +{ + $$ = buildExpressionTerm(BINOP_EXPR, GREATER_THAN_OR_EQUAL_TO, $1,$4); +} + | expression EQUAL_TO _ expression +{ + $$ = buildExpressionTerm(BINOP_EXPR, EQUAL_TO, $1, $4); +} + | expression NOT_EQUAL_TO _ expression +{ + $$ = buildExpressionTerm(BINOP_EXPR, NOT_EQUAL_TO, $1, $4); +} + | expression BITWISE_AND _ expression +{ + $$ = buildExpressionTerm(BINOP_EXPR, BITWISE_AND, $1, $4); +} + | expression BITWISE_OR _ expression +{ + $$ = buildExpressionTerm(BINOP_EXPR, BITWISE_OR, $1, $4); +} + | expression BITWISE_XOR _ expression +{ + $$ = buildExpressionTerm(BINOP_EXPR, BITWISE_XOR, $1, $4); +} + | expression LOGICAL_AND _ expression +{ + $$ = buildExpressionTerm(BINOP_EXPR, LOGICAL_AND, $1, $4); +} + | expression LOGICAL_OR _ expression +{ + $$ = buildExpressionTerm(BINOP_EXPR, LOGICAL_OR, $1, $4); +} + | expression LOGICAL_XOR _ expression +{ + $$ = buildExpressionTerm(BINOP_EXPR, LOGICAL_XOR, $1, $4); +} + | expression SELECT _ Identifier +{ + $$ = buildExpressionTerm(BINOP_EXPR, SELECT, $1, + lookupOrEnterSymbol($4, STRUCT_FIELD_SYMBOL)); +} + | lvalue ASSIGN _ expression +{ + $$ = buildExpressionTerm(ASSIGN_EXPR, $2, $1, $4); +} + | lvalue INCREMENT +{ + $$ = buildExpressionTerm(POSTOP_EXPR, INCREMENT, $1); +} + | lvalue DECREMENT +{ + $$ = buildExpressionTerm(POSTOP_EXPR, DECREMENT, $1); +} + | INCREMENT _ lvalue +{ + $$ = buildExpressionTerm(PREOP_EXPR, INCREMENT, $3); +} + | DECREMENT _ lvalue +{ + $$ = buildExpressionTerm(PREOP_EXPR, DECREMENT, $3); +} + ; + +functionCall: + functionName '(' _ ')' +{ + $$ = buildFunctionCall($1, NULL); +} + | functionName '(' _ functionArgumentList _ ')' +{ + $$ = buildFunctionCall($1, $4); +} + ; + +functionName: Identifier /* da */ + ; + +functionArgumentList: + operandList /* da */ + ; + +/* Stuff above this point is target independent (except for token list), stuff + below this points is target dependent (operand syntax) */ + +nonBlockOperand: + dataRegisterExpression /* da */ + | addressRegisterExpression /* da */ + | addressRegisterIndirectExpression /* da */ + | postincrementExpression /* da */ + | predecrementExpression /* da */ + | displacementExpression /* da */ + | indexedExpression /* da */ + | pcDisplacementExpression /* da */ + | pcIndexedExpression /* da */ + | immediateExpression /* da */ + | absoluteShortExpression /* da */ + | absoluteLongExpression /* da */ + | normalExpression /* da */ + | conditionCodeRegisterExpression /* da */ + | statusRegisterExpression /* da */ + | userStackPointerExpression /* da */ + | controlRegisterExpression /* da */ + ; + +dataRegister: D0 { $$ = 0; } + | D1 { $$ = 1; } + | D2 { $$ = 2; } + | D3 { $$ = 3; } + | D4 { $$ = 4; } + | D5 { $$ = 5; } + | D6 { $$ = 6; } + | D7 { $$ = 7; } + ; + +addressRegister:A0 { $$ = 0; } + | A1 { $$ = 1; } + | A2 { $$ = 2; } + | A3 { $$ = 3; } + | A4 { $$ = 4; } + | A5 { $$ = 5; } + | A6 { $$ = 6; } + | A7 { $$ = 7; } + ; + +register: dataRegister +{ + $$ = $1; +} + | addressRegister +{ + $$ = $1 + 8; +} + ; + +controlRegister:SFC { $$ = 0; } + | DFC { $$ = 1; } + | VBR { $$ = 2; } + ; + +dataRegisterExpression: dataRegister +{ + $$ = buildOperand(D_REGISTER_OPND, $1); +} + ; + +addressRegisterExpression: addressRegister +{ + $$ = buildOperand(A_REGISTER_OPND, $1); +} + ; + +addressRegisterIndirectExpression: + '[' _ addressRegister _ ']' +{ + $$ = buildOperand(A_REGISTER_INDIRECT_OPND, $3); +} + | addressRegister '@' +{ + $$ = buildOperand(A_REGISTER_INDIRECT_OPND, $1); +} + ; + +postincrementExpression: + '[' _ addressRegister _ ']' ADD +{ + $$ = buildOperand(POSTINCREMENT_OPND, $3); +} + | addressRegister '@' ADD +{ + $$ = buildOperand(POSTINCREMENT_OPND, $1); +} + ; + +predecrementExpression: + SUB '[' _ addressRegister _ ']' +{ + $$ = buildOperand(PREDECREMENT_OPND, $4); +} + | addressRegister '@' SUB +{ + $$ = buildOperand(PREDECREMENT_OPND, $1); +} + ; + +displacementExpression: + expression '[' _ addressRegister _ ']' +{ + $$ = buildOperand(DISPLACEMENT_OPND, $4, $1); +} + | addressRegister '@' '(' _ expression _ ')' +{ + $$ = buildOperand(DISPLACEMENT_OPND, $1, $5); +} + | addressRegister selectionList +{ + $$ = buildOperand(SELECTED_OPND, $1, $2); +} + ; + +indexedExpression: + expression '[' _ addressRegister ',' _ register _ SELECT _ W _ ']' +{ + $$ = buildOperand(INDEXED_OPND, $1, $4, $7, 0); +} + | expression '[' _ addressRegister ',' _ register _ SELECT _ L _ ']' +{ + $$ = buildOperand(INDEXED_OPND, $1, $4, $7, 1); +} + | expression '[' _ addressRegister ',' _ register _ ']' +{ + $$ = buildOperand(INDEXED_OPND, $1, $4, $7, 1); +} + | addressRegister '[' _ register _ SELECT _ W _ ']' selectionList +{ + $$ = buildOperand(INDEX_SELECTED_OPND, $11, $1, $4, 0); +} + | addressRegister '[' _ register _ SELECT _ L _ ']' selectionList +{ + $$ = buildOperand(INDEX_SELECTED_OPND, $11, $1, $4, 1); +} + | addressRegister '[' _ register _ ']' selectionList +{ + $$ = buildOperand(INDEX_SELECTED_OPND, $7, $1, $4, 1); +} + | addressRegister '(' _ expression ',' _ register _ ':' _ W _ ')' +{ + $$ = buildOperand(INDEXED_OPND, $4, $1, $7, 0); +} + | addressRegister '(' _ expression ',' _ register _ ':' _ L _ ')' +{ + $$ = buildOperand(INDEXED_OPND, $4, $1, $7, 1); +} + | addressRegister '(' _ expression ',' _ register _ ')' +{ + $$ = buildOperand(INDEXED_OPND, $4, $1, $7, 1); +} + ; + +pcDisplacementExpression: + expression '[' _ PC _ ']' +{ + $$ = buildOperand(PC_DISPLACEMENT_OPND, $1); +} + | PC '@' '(' _ expression _ ')' +{ + $$ = buildOperand(PC_DISPLACEMENT_OPND, $4); +} + ; + +pcIndexedExpression: + expression '[' _ PC ',' _ register _ SELECT _ W _ ']' +{ + $$ = buildOperand(PC_INDEXED_OPND, $1, $7, 0); +} + | expression '[' _ PC ',' _ register _ SELECT _ L _ ']' +{ + $$ = buildOperand(PC_INDEXED_OPND, $1, $7, 1); +} + | PC '@' '(' _ expression ',' _ register _ ':' _ W _ ')' +{ + $$ = buildOperand(PC_INDEXED_OPND, $5, $8, 0); +} + | PC '@' '(' _ expression ',' _ register _ ':' _ L _ ')' +{ + $$ = buildOperand(PC_INDEXED_OPND, $5, $8, 1); +} + ; + +immediateExpression: '#' _ expression +{ + $$ = buildOperand(IMMEDIATE_OPND, $3); +} + ; + +absoluteShortExpression: + expression SELECT _ W +{ + $$ = buildOperand(ABSOLUTE_SHORT_OPND, $1); +} + | expression ': ' _ W +{ + $$ = buildOperand(ABSOLUTE_SHORT_OPND, $1); +} + ; + +absoluteLongExpression: + expression SELECT _ L +{ + $$ = buildOperand(ABSOLUTE_LONG_OPND, $1); +} + | expression ':' _ L +{ + $$ = buildOperand(ABSOLUTE_LONG_OPND, $1); +} + ; + +normalExpression: + expression +{ + $$ = buildOperand(EXPRESSION_OPND, $1); +} + ; + +conditionCodeRegisterExpression: + CCR +{ + $$ = buildOperand(CC_REGISTER_OPND); +} + ; + +statusRegisterExpression: + SR +{ + $$ = buildOperand(STATUS_REGISTER_OPND); +} + ; + +userStackPointerExpression: + USP +{ + $$ = buildOperand(USP_REGISTER_OPND); +} + ; + +controlRegisterExpression: + controlRegister +{ + $$ = buildOperand(CONTROL_REGISTER_OPND, $1); +} + ; diff --git a/main.c b/main.c new file mode 100644 index 0000000..1afc86a --- /dev/null +++ b/main.c @@ -0,0 +1,37 @@ +/* + main.c -- Top level of the Macross assembler. + + Chip Morningstar -- Lucasfilm Ltd. + + 5-December-1984 +*/ + +#include "macrossTypes.h" +#include "macrossGlobals.h" + +main(argc, argv) + int argc; + char *argv[]; +{ + extern char end; + char *sbrk(); + + fflush(stdout); + initializeStuff(argc, argv); + yyparse(); + finishUp(); + if (emitPrint) + printf("storage high water mark 0x%x == %d\n", sbrk(0) - &end, + sbrk(0) - &end); + if (errorFlag) + chokePukeAndDie(); + else + exit(0); +} + + void +printVersion() +{ + printf("Macross %s version 4.20.\n", TARGET_CPU_STRING); +} + diff --git a/main.o b/main.o new file mode 100644 index 0000000000000000000000000000000000000000..565ac4316e452bdd62b064e804df2af0b9709a3a GIT binary patch literal 34054 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ΜellXUV3r+fjV>lq0A^}5GMt@dKaGG7YadqsBndZm zc)dt8#8qf(BLC@;6R7h13XLmT4VM6BtpZ(i^vPN2k!7OIkJ z+4oUSDTcf(eYNS6s>`z*rG{F{WJz;%pI+1;2#%N+t>ozF%BCkaga;vPE zMA?ysUy&30B3aONO7(`D%Yo~bo7lJ6pvi`LGz@VPJhi!lX>0%!DZ;^-7FRKWgCQ5) z+5#p~hSp%m83<-l)UiBWa{+c~9nHbWgQ<}Xr9#>>uoHD%s7NVIK2{GSteHl0EQtgQ zG`}`CR>djWbh?|ot`;#QSu@NFEv^;khxM!JeYR5_PJ*9@f=bf36h^K#`C02 z%wDEd3P~yRYJlw-Y*uh+vjsP4n!@gPRMRcPSw(N|=e|k?a@DR1C4pDThMf@Gn_RW) zKJ14mEh8dY9)iSHur3ADkolh1M=QV{CokODX}Hngo7Q2C z3@dl^w4W2@XyG#{yW)Xp&uqx53>*k2!h9^$iwXO!G+)ICF+$0a_a@odK7+?4c|Pwm zORr&yNrsEj04o7>zc#)S5M~kba9pRB5zMsM8UrSlc7xIm_oLGwEMcSf-LtN%{QNdO z>^kwS>G@TDVkJntC2Y|nkL~r5Ld&sOLLc+AyUS*toYwD@Q8paAK{oS?0RDC8L?-v7 z8dt>IeDZELrI_l0wdJT^7D%S?_MiKWfkZXxWj7Ildk~zGlGMr9-?=WFp0IqB<4-?x zGM2H0OF058FS<#6lIC`F_|axtFaNNB{o30ZsG1>fZfW^n2ocGB1 z4+j9Bqx%eg7h!sVAHNL7Jl+ptdKc5*y9NTs?eI8|{TT;Wjeoz|q7uIu;n2ya*Tl2v2hGvc)^4&EZz!u2ta~?!oUTF5vI^#V`hqmP>}#jP&m*N`Q&^s4RfI9iltOV@hF(mL z|1OZ>A!fFC|6G)hxA;^}X z2!^P5=TO(s@n^HojpAgGrK0$452^=`dj#s|8>DbFnz!)nkHZKWAqxctRDd~ZU^tE4 zk#R#f9hos~K{0#>q^b9DRs)TT|M-cajp+)8Swm|c=^Fjf56(jem}BL$6M(B8`Gp*A z1`bN%)mfamDBhGJk!YUQ6$dlvCv^-vG2LVnVRt_H_aSUHJjOrv7kFGc#4!5n5-!zW zVKPTw_>hfooJ=#BVwRCL0}u3peu!dz#i(HiP6kM%hK literal 0 HcmV?d00001 diff --git a/malloc.c b/malloc.c new file mode 100644 index 0000000..7f1488c --- /dev/null +++ b/malloc.c @@ -0,0 +1,331 @@ +#ifndef lint +static char sccsid[] = "@(#)malloc.c 1.2 (Lucasfilm) 84/10/17"; +/* from malloc.c 4.3 (Berkeley) 9/16/83 */ +#endif + +/* + * malloc.c (Caltech) 2/21/82 + * Chris Kingsley, kingsley@cit-20. + * + * This is a very fast storage allocator. It allocates blocks of a small + * number of different sizes, and keeps free lists of each size. Blocks that + * don't exactly fit are passed up to the next larger size. In this + * implementation, the available sizes are 2^n-4 (or 2^n-12) bytes long. + * This is designed for use in a program that uses vast quantities of memory, + * but bombs when it runs out. + */ + +#include + +#define NULL 0 + +/* + * The overhead on a block is at least 4 bytes. When free, this space + * contains a pointer to the next free block, and the bottom two bits must + * be zero. When in use, the first byte is set to MAGIC, and the second + * byte is the size index. The remaining bytes are for alignment. + * If range checking is enabled and the size of the block fits + * in two bytes, then the top two bytes hold the size of the requested block + * plus the range checking words, and the header word MINUS ONE. + */ +union overhead { + union overhead *ov_next; /* when free */ + struct { + u_char ovu_magic; /* magic number */ + u_char ovu_index; /* bucket # */ +#ifdef RCHECK + u_short ovu_size; /* actual block size */ + u_int ovu_rmagic; /* range magic number */ +#endif + } ovu; +#define ov_magic ovu.ovu_magic +#define ov_index ovu.ovu_index +#define ov_size ovu.ovu_size +#define ov_rmagic ovu.ovu_rmagic +}; + +#define MAGIC 0xff /* magic # on accounting info */ +#define RMAGIC 0x55555555 /* magic # on range info */ +#ifdef RCHECK +#define RSLOP sizeof (u_int) +#else +#define RSLOP 0 +#endif + +/* + * nextf[i] is the pointer to the next free block of size 2^(i+3). The + * smallest allocatable block is 8 bytes. The overhead information + * precedes the data area returned to the user. + */ +#define NBUCKETS 30 +static union overhead *nextf[NBUCKETS]; +extern char *sbrk(); + +#ifdef MSTATS +/* + * nmalloc[i] is the difference between the number of mallocs and frees + * for a given block size. + */ +static u_int nmalloc[NBUCKETS]; +#include +#endif + +#ifdef debug +#define ASSERT(p) if (!(p)) botch("p"); else +static +botch(s) + char *s; +{ + + printf("assertion botched: %s\n", s); + abort(); +} +#else +#define ASSERT(p) +#endif + +char * +malloc(nbytes) + register unsigned nbytes; +{ + register union overhead *p; + register int bucket = 0; + register unsigned shiftr; + + /* + * Convert amount of memory requested into + * closest block size stored in hash buckets + * which satisfies request. Account for + * space used per block for accounting. + */ + nbytes += sizeof (union overhead) + RSLOP; + nbytes = (nbytes + 3) &~ 3; + shiftr = (nbytes - 1) >> 2; + /* apart from this loop, this is O(1) */ + while (shiftr >>= 1) + bucket++; + /* + * If nothing in hash bucket right now, + * request more memory from the system. + */ + if (nextf[bucket] == NULL) + morecore(bucket); + if ((p = (union overhead *)nextf[bucket]) == NULL) + return (NULL); + /* remove from linked list */ + nextf[bucket] = nextf[bucket]->ov_next; + p->ov_magic = MAGIC; + p->ov_index= bucket; +#ifdef MSTATS + nmalloc[bucket]++; +#endif +#ifdef RCHECK + /* + * Record allocated size of block and + * bound space with magic numbers. + */ + if (nbytes <= 0x10000) + p->ov_size = nbytes - 1; + p->ov_rmagic = RMAGIC; + *((u_int *)((caddr_t)p + nbytes - RSLOP)) = RMAGIC; +#endif + return ((char *)(p + 1)); +} + +/* + * Allocate more memory to the indicated bucket. + */ +static +morecore(bucket) + register bucket; +{ + register union overhead *op; + register int rnu; /* 2^rnu bytes will be requested */ + register int nblks; /* become nblks blocks of the desired size */ + register int siz; + + if (nextf[bucket]) + return; + /* + * Insure memory is allocated + * on a page boundary. Should + * make getpageize call? + */ + op = (union overhead *)sbrk(0); + if ((int)op & 0x3ff) + sbrk(1024 - ((int)op & 0x3ff)); + /* take 2k unless the block is bigger than that */ + /* rnu = (bucket <= 8) ? 11 : bucket + 3; */ + rnu = (bucket <= 10) ? 13 : bucket + 3; /* now grab 8k 'cbm' */ + nblks = 1 << (rnu - (bucket + 3)); /* how many blocks to get */ + if (rnu < bucket) + rnu = bucket; + op = (union overhead *)sbrk(1 << rnu); + /* no more room! */ + if ((int)op == -1) + return; + /* + * Round up to minimum allocation size boundary + * and deduct from block count to reflect. + */ + if ((int)op & 7) { + op = (union overhead *)(((int)op + 8) &~ 7); + nblks--; + } + /* + * Add new memory allocated to that on + * free list for this hash bucket. + */ + nextf[bucket] = op; + siz = 1 << (bucket + 3); + while (--nblks > 0) { + op->ov_next = (union overhead *)((caddr_t)op + siz); + op = (union overhead *)((caddr_t)op + siz); + } +} + +free(cp) + char *cp; +{ + register int size; + register union overhead *op; + + if (cp == NULL) + return; + op = (union overhead *)((caddr_t)cp - sizeof (union overhead)); +#ifdef debug + ASSERT(op->ov_magic == MAGIC); /* make sure it was in use */ +#else + if (op->ov_magic != MAGIC) + return; /* sanity */ +#endif +#ifdef RCHECK + ASSERT(op->ov_rmagic == RMAGIC); + if (op->ov_index <= 13) + ASSERT(*(u_int *)((caddr_t)op + op->ov_size + 1 - RSLOP) == RMAGIC); +#endif + ASSERT(op->ov_index < NBUCKETS); + size = op->ov_index; + op->ov_next = nextf[size]; + nextf[size] = op; +#ifdef MSTATS + nmalloc[size]--; +#endif +} + +/* + * When a program attempts "storage compaction" as mentioned in the + * old malloc man page, it realloc's an already freed block. Usually + * this is the last block it freed; occasionally it might be farther + * back. We have to search all the free lists for the block in order + * to determine its bucket: 1st we make one pass thru the lists + * checking only the first block in each; if that fails we search + * ``realloc_srchlen'' blocks in each list for a match (the variable + * is extern so the caller can modify it). If that fails we just copy + * however many bytes was given to realloc() and hope it's not huge. + */ +int realloc_srchlen = 4; /* 4 should be plenty, -1 =>'s whole list */ + +char * +realloc(cp, nbytes) + char *cp; + unsigned nbytes; +{ + register u_int onb; + union overhead *op; + char *res; + register int i; + int was_alloced = 0; + + if (cp == NULL) + return (malloc(nbytes)); + op = (union overhead *)((caddr_t)cp - sizeof (union overhead)); + if (op->ov_magic == MAGIC) { + was_alloced++; + i = op->ov_index; + } else { + /* + * Already free, doing "compaction". + * + * Search for the old block of memory on the + * free list. First, check the most common + * case (last element free'd), then (this failing) + * the last ``realloc_srchlen'' items free'd. + * If all lookups fail, then assume the size of + * the memory block being realloc'd is the + * smallest possible. + */ + if ((i = findbucket(op, 1)) < 0 && + (i = findbucket(op, realloc_srchlen)) < 0) + i = 0; + } + onb = (1 << (i + 3)) - sizeof (*op) - RSLOP; + /* avoid the copy if same size block */ + if (was_alloced && + nbytes <= onb && nbytes > (onb >> 1) - sizeof(*op) - RSLOP) + return(cp); + if ((res = malloc(nbytes)) == NULL) + return (NULL); + if (cp != res) /* common optimization */ + bcopy(cp, res, (nbytes < onb) ? nbytes : onb); + if (was_alloced) + free(cp); + return (res); +} + +/* + * Search ``srchlen'' elements of each free list for a block whose + * header starts at ``freep''. If srchlen is -1 search the whole list. + * Return bucket number, or -1 if not found. + */ +static +findbucket(freep, srchlen) + union overhead *freep; + int srchlen; +{ + register union overhead *p; + register int i, j; + + for (i = 0; i < NBUCKETS; i++) { + j = 0; + for (p = nextf[i]; p && j != srchlen; p = p->ov_next) { + if (p == freep) + return (i); + j++; + } + } + return (-1); +} + +#ifdef MSTATS +/* + * mstats - print out statistics about malloc + * + * Prints two lines of numbers, one showing the length of the free list + * for each size category, the second showing the number of mallocs - + * frees for each size category. + */ +mstats(s) + char *s; +{ + register int i, j; + register union overhead *p; + int totfree = 0, + totused = 0; + + fprintf(stderr, "Memory allocation statistics %s\nfree:\t", s); + for (i = 0; i < NBUCKETS; i++) { + for (j = 0, p = nextf[i]; p; p = p->ov_next, j++) + ; + fprintf(stderr, " %d", j); + totfree += j * (1 << (i + 3)); + } + fprintf(stderr, "\nused:\t"); + for (i = 0; i < NBUCKETS; i++) { + fprintf(stderr, " %d", nmalloc[i]); + totused += nmalloc[i] * (1 << (i + 3)); + } + fprintf(stderr, "\n\tTotal in use: %d, total free: %d\n", + totused, totfree); +} +#endif diff --git a/malloc.o b/malloc.o new file mode 100644 index 0000000000000000000000000000000000000000..c7e1ecf3811a52609e02cbe53069a912852d7470 GIT binary patch literal 5616 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 Q`L?k7YE2tHAF`eQ2T{p|l>h($ literal 0 HcmV?d00001 diff --git a/notes68/1.am b/notes68/1.am new file mode 100644 index 0000000..09c4874 --- /dev/null +++ b/notes68/1.am @@ -0,0 +1,51 @@ +Address Modes +------------- + Notation +Number Motorola Name Motorola Sun Sun Name +------ ------------- -------- --- -------- +1 Data Register Direct Dn Dn Register + +2 Address Register Direct An An Register + +3 Address Register Indirect (An) An@ Register + Deferred + +4 Address Register Indirect w/ (An)+ An@+ Postincrement + Postincrement + +5 Address Register Indirect w/ -(An) An@- Predecrement + Predecrement + +6 Address Register Indirect w/ d(An) An@(d) Displacement + Displacement + +7 Address Register Indirect w/ d(An,Rx.W) An@(d,Rx:W) Word Index + Index d(An,Rx.L) An@(d,Rx:L) Long Index + +8 Program Counter w/ Displacement d(PC) PC@(d) PC Displacement + +9 Program Counter w/ Index d(PC,Rx.W) PC@(d,Rx:W) PC Word + Index + d(PC,Rx.L) PC@(d,Rx:L) PC Long + Index + +10 Immediate #xxx #xxx Immediate + +11 Absolute Short xxx.W xxx:W Absolute Short + +12 Absolute Long xxx.L xxx:L Absolute Long + +13 -- -- xxx Normal + +14 (condition code register) CCR CC -- + +15 (status register) SR SR -- + +16 Implied + +17 (user stack pointer) USP USP -- + +18 (control register) SFC SFC -- + DFC DFC + VBR VBR + diff --git a/notes68/2.amg b/notes68/2.amg new file mode 100644 index 0000000..c3fa2c2 --- /dev/null +++ b/notes68/2.amg @@ -0,0 +1,45 @@ +Address Mode Groups +------------------- +ID Mode set Mnemonic +-- -------- -------- +A 1 DATA_REGISTER + +B 2 ADDRESS_REGISTER + +C 4 POSTINCREMENT + +D 5 PREDECREMENT + +E 6 DISPLACEMENT + +F 10 IMMEDIATE + +G 13 NORMAL + +H 14 CONDITION_CODE_REGISTER + +I 15 STATUS_REGISTER + +J 16 (no operand at all!) + +K 17 USER_STACK_POINTER + +L { 17-18 } CONTROL_REGISTER + +M { 1-2 } REGISTER + +N { 1-7, 11-13 } STORABLE + +O { 1-13 } FULL_EA + +P { 1, 3-7, 11-13 } STORABLE_NO_A_REGISTER + +Q { 1, 3-13 } FULL_EA_NO_A_REG + +R { 3-4, 6-9, 11-13 } MISC_1 + +S { 3-7, 11-13 } STORABLE_NO_REGISTER + +T { 3, 5-7, 11-13 } MISC_2 + +U { 3, 6-9, 11-13 } MISC_3 diff --git a/notes68/3.os b/notes68/3.os new file mode 100644 index 0000000..11ce3f8 --- /dev/null +++ b/notes68/3.os @@ -0,0 +1,60 @@ +Operand Sets +------------ + 1 A + 2 AA + 3 AE + 4 AG + 5 AP + 6 AS + + 7 B + 8 BF + 9 BK + +10 CC + +11 DD + +12 EA + +13 F +14 FA +15 FH +16 FI +17 FN +18 FP + +19 G + +20 HP + +21 IP + +22 J + +23 KB + +24 LM + +25 ML +26 MM +27 MP +28 MS +29 M*T + +30 OA +31 OB + +32 P + +33 QA +34 QH +35 QI + +36 RM* + +37 S +38 SM + +39 U +40 UB diff --git a/notes68/4.ic b/notes68/4.ic new file mode 100644 index 0000000..e693f1e --- /dev/null +++ b/notes68/4.ic @@ -0,0 +1,115 @@ +Instruction Classes +------------------- +i ABCD - | AA + ADDX bwl | DD + SBCD - | + SUBX bwl | + +ii ADD bwl | AS + SUB bwl | FP __I + | OA + | OB __A + +iii ADDQ bwl | FN + SUBQ bwl | + +iv AND bwl | AS + OR bwl | FH __CCR + | FI __SR + | FN __I + | GA + +v ASL bwl | AA + ASR bwl | FA + LSL bwl | S + LSR bwl | + ROL bwl | + ROR bwl | + ROXL bwl | + ROXR bwl | + +vi Bcc - | G + BRA - | + BSR - | + +vii BCHG - | AP + BCLR - | FP + BSET - | + BTST - | + +viii CHK - | QA + DIVS - | + DIVU - | + MULS - | + MULU - | + +ix CLR bwl | P + NBCD - | + NEG bwl | + NEGX bwl | + NOT bwl | + Scc - | + TAS - | + TST bwl | + +x CMP bwl | FP __I + | OA + | OB __A + +xi CMPM bwl | CC + +xii DBcc - | AG + +xiii EOR bwl | AP + | FH __CCR + | FI __SR + | FP __I + +xiv EXG - | MM + +xv EXT bwl | A + SWAP - | + +xvi ILLEGAL - | J + NOP - | + RESET - | + RTE - | + RTR - | + RTS - | + TRAPV - | + +xvii JMP - | U + JSR - | + PEA - | + +xviii LEA - | UB + +xix LINK - | BF + +xx MOV bwl | BK __USP + | HP CCR__ + | IP SR__ + | KB __USP + | LM __C + | ML __C + | OB __I + | OP + | QH __CCR + | QI __SR + +xxi MOVEM wl | M*T + | RM* + +xxii MOVEP wl | AE + | EA + +xxiii MOVEQ - | FA + +xxiv MOVS bwl | MS + | SM + +xxv RTD - | F + STOP - | + TRAP - | + +xxvi UNLK - | B diff --git a/object.c b/object.c new file mode 100644 index 0000000..8a4b662 --- /dev/null +++ b/object.c @@ -0,0 +1,612 @@ +/* + object.c -- Routines to output object files for the Macross assembler. + + Chip Morningstar -- Lucasfilm Ltd. + + 20-November-1984 +*/ + +#include "macrossTypes.h" +#include "macrossGlobals.h" + +static int symbolTableSize; +static int symbolTableStringSize; +bool encodingFunction; + + void +outputObjectFile() +{ + void outputPartition(); + void outputReferenceInfo(); + void outputSymbolTableInfo(); + void outputAbsoluteCode(); + void outputRelocatableCode(); + void outputReservations(); + void outputExpressions(); + void outputFunctions(); + void dumpSymbolTable(); + void enumerateAndCountSymbols(); + + if (debug || emitPrint) + printCodeBuffers(); + outputPartition(); + outputAbsoluteCode(); + if (produceLinkableObject) { + outputPartition(); + outputRelocatableCode(); + outputPartition(); + outputReservations(); + outputPartition(); + enumerateAndCountSymbols(); + outputReferenceInfo(); + outputSymbolTableInfo(); + outputExpressions(); + outputFunctions(); + } + if (symbolTableDumpOn) + dumpSymbolTable(); + fclose(objectFileOutput); +} + + void +outputWord(aWord) + int aWord; +{ + putc(aWord & 0xFF, objectFileOutput); + putc((aWord >> 8) & 0xFF, objectFileOutput); +} + + void +outputPartition() +{ + outputWord(0xFFFF); +} + + void +outputBigword(bigword) + unsigned long bigword; +{ + int i; + + for (i=1; i<=4; i++) { + putc(bigword & 0xFF, objectFileOutput); + bigword >>= 8; + } +} + + void +outputByte(aByte) + byte aByte; +{ + putc(aByte, objectFileOutput); +} + + void +outputString(string) + stringType *string; +{ + do { + putc(*string, objectFileOutput); + } while (*string++ != '\0'); +} + + void +outputStartAddress(startAddress) + addressType startAddress; +{ + outputWord(startAddress); + if (produceLinkableObject) { + outputWord(startAddress - 3); + outputByte(0); + } else { + outputWord(startAddress); + outputByte(0); + } +} + + void +outputRelocatableCode() +{ + int i; + addressType codeStartAddress; + addressType codeEndAddress; + + void outputPseudoSegment(); + void outputBreak(); + + if (haveUserStartAddress && !fixupStartAddress && startAddress-> + kindOfValue == RELOCATABLE_VALUE) + outputStartAddress(startAddress->value); + else if (haveUserStartAddress && fixupStartAddress) + outputStartAddress(0xFFFE); + if (relocatableHighWaterMark < 0) + return; + codeEndAddress = -1; + do { + codeStartAddress = codeEndAddress + 1; + while (codeBreakList != NULL && codeBreakList->breakAddress + == codeStartAddress) { + outputBreak(codeBreakList); + codeBreakList = codeBreakList->nextBreak; + } + if (codeBreakList == NULL) + codeEndAddress = relocatableHighWaterMark; + else + codeEndAddress = codeBreakList->breakAddress - 1; + outputPseudoSegment(codeStartAddress, codeEndAddress); + } while (codeEndAddress < relocatableHighWaterMark); +} + + void +outputBreak(codeBreak) + codeBreakType *codeBreak; +{ + switch (codeBreak->kindOfBreak) { + case BREAK_BREAK: + case END_CONSTRAIN_BREAK: + /* do nothing */ + break; + + case ALIGN_BREAK: + outputWord(codeBreak->breakAddress); + outputWord(codeBreak->breakAddress - 2); + outputWord(codeBreak->breakData); + break; + + case CONSTRAIN_BREAK: + outputWord(codeBreak->breakAddress); + outputWord(codeBreak->breakAddress - 1); + outputWord(codeBreak->breakData); + break; + } +} + + void +outputAbsoluteCode() +{ + int i; + int startSegment; + int endSegment; + int nextSegment; + void outputOneCodeBuffer(); + + if (haveUserStartAddress && !fixupStartAddress && startAddress-> + kindOfValue==ABSOLUTE_VALUE) + outputStartAddress(startAddress->value); + for (startSegment=0; startSegmentcodeEndAddress+1 == + absoluteCodeRegion.codeSegments[nextSegment] + ->codeStartAddress) { + ++endSegment; + ++nextSegment; + } + if (absoluteCodeRegion.codeSegments[startSegment] != NULL) { + outputWord(absoluteCodeRegion.codeSegments[ + startSegment]->codeStartAddress); + outputWord(absoluteCodeRegion.codeSegments[ + endSegment]->codeEndAddress); + for (i=startSegment; i<=endSegment; ++i) + outputOneCodeBuffer(absoluteCodeRegion. + codeSegments[i]); + } + } +} + + void +outputOneCodeBuffer(segment) + codeSegmentType *segment; +{ + int i; + + if (segment != NULL) { +/* outputWord(segment->codeStartAddress); + outputWord(segment->codeEndAddress);*/ + for (i=bufferPosition(segment->codeStartAddress); i<= + bufferPosition(segment->codeEndAddress); i++) + outputByte((*segment->codeBuffer)[i]); + } +} + + void +outputPseudoSegment(codeStartAddress, codeEndAddress) + addressType codeStartAddress; + addressType codeEndAddress; +{ + int startSegment; + int endSegment; + int startPosition; + int endPosition; + int originalStartPosition; + int ultimateEndPosition; + int position; + int segment; + codeSegmentType *segmentPtr; + + void outputWord(); + void outputByte(); + + outputWord(codeStartAddress); + outputWord(codeEndAddress); + startSegment = bufferNumber(codeStartAddress); + endSegment = bufferNumber(codeEndAddress); + originalStartPosition = bufferPosition(codeStartAddress); + ultimateEndPosition = bufferPosition(codeEndAddress); + for (segment=startSegment; segment<=endSegment; segment++) { + segmentPtr = relocatableCodeRegion.codeSegments[segment]; + startPosition = (segment == startSegment) ? + originalStartPosition : 0; + endPosition = (segment == endSegment) ? ultimateEndPosition : + CODE_BUFFER_SIZE - 1; + for(position=startPosition; position<=endPosition; position++) + outputByte((*segmentPtr->codeBuffer)[position]); + } +} + + bool +isObjectSymbol(symbol) + symbolTableEntryType *symbol; +{ + return(symbol != NULL && symbol->context->value != NULL && + symbol->context->value->kindOfValue != FUNCTION_VALUE && + symbol->context->value->kindOfValue != BUILT_IN_FUNCTION_VALUE + && symbol->context->value->kindOfValue != MACRO_VALUE && + ((isExternal(symbol) && symbol->context->value->kindOfValue + != UNDEFINED_VALUE) || symbol->referenceCount > 0)); +/* return(symbol != NULL && symbol->context->value != NULL && + (symbol->context->value->kindOfValue == RELOCATABLE_VALUE || + symbol->context->value->kindOfValue == ABSOLUTE_VALUE || + isExternal(symbol)));*/ +} + + void +enumerateAndCountSymbols() +{ + int i; + symbolTableEntryType *symb; + + symbolTableSize = 0; + symbolTableStringSize = 0; + for (i=0; inextSymbol) + if (isObjectSymbol(symb)) { + symbolTableStringSize += strlen(symb->symbolName) + 1; + symb->ordinal = symbolTableSize++; + } +} + + int +enumerateAndCountReferences() +{ + int result; + int codeMode; + expressionReferenceListType *theReferences; + + result = 0; + for (codeMode=0; codeMode<=1; codeMode++) { + theReferences = expressionReferenceList[codeMode]; + while (theReferences != NULL) { + theReferences->relocation.referenceExpression = result++; + theReferences = theReferences->nextReference; + } + } + return(result); +} + + void +outputReference(reference) + expressionReferenceType *reference; +{ + byte funnyByte; + bigWord funnyWord; + + /* This nonsense is to maintain byte-order and bit-order independence + across host machines so that Macross object files will be + portable. */ + funnyByte = reference->referenceMode | + (reference->referenceRelative << 1) | + (reference->referenceExternal << 2) | + (reference->referenceKind << 3); + funnyWord = ((reference->referenceAddress) & 0xFFFFFF) | + (funnyByte << 24); + outputBigword(funnyWord); + outputBigword(reference->referenceExpression); + +} + +static int referenceCount; + + void +outputReferenceInfo() +{ + expressionReferenceListType *theReferences; + int codeMode; + + outputBigword(referenceCount = enumerateAndCountReferences()); + + for (codeMode=0; codeMode<=1; codeMode++) { + theReferences = expressionReferenceList[codeMode]; + while (theReferences != NULL) { + outputReference(&(theReferences->relocation)); + theReferences = theReferences->nextReference; + } + } +} + + void +outputOneSymbol(symbol) + symbolTableEntryType *symbol; +{ + byte symbolClass; + valueType *symbolValue; + valueType *evaluateIdentifier(); + + if (symbol->context->usage == DEFINE_SYMBOL) + symbolValue = evaluateIdentifier(symbol, FALSE, NO_FIXUP_OK); + else + symbolValue = symbol->context->value; + if (symbolValue->kindOfValue == ABSOLUTE_VALUE) + symbolClass = SYMBOL_ABSOLUTE; + else if (symbolValue->kindOfValue == RELOCATABLE_VALUE) + symbolClass = SYMBOL_RELOCATABLE; + else + symbolClass = SYMBOL_UNDEFINED; + if (isExternal(symbol)) + symbolClass |= SYMBOL_EXTERNAL; + else if (symbolClass == SYMBOL_UNDEFINED) + symbolClass = SYMBOL_ABSOLUTE; + outputByte(symbolClass); + outputBigword(symbolValue->value); + outputString(symbol->symbolName); +} + + void +outputSymbolTableInfo() +{ + int i; + symbolTableEntryType *symb; + + outputBigword(symbolTableSize); + outputBigword(symbolTableStringSize); + for (i=0; inextSymbol) + if (isObjectSymbol(symb)) + outputOneSymbol(symb); +} + + int +symbolCompare(symbol1, symbol2) + symbolTableEntryType **symbol1; + symbolTableEntryType **symbol2; +{ + return(strcmplc((*symbol1)->symbolName, (*symbol2)->symbolName)); +} + + bool +shouldDumpSymbol(symbol) + symbolTableEntryType *symbol; +{ + return(symbolTableDumpOn == 2 + || (symbol->context->usage != BUILT_IN_FUNCTION_SYMBOL + && (symbol->context->usage != DEFINE_SYMBOL + || symbol->context->referenceCount != 0 + || showAllSymbolsFlag + ) + && symbol->symbolName[0] != '$' + && symbol->symbolName[0] != '_' + ) + ); +} + + void +dumpSymbolTable() +{ + int i; + symbolTableEntryType *symb; + symbolTableEntryType **symbolVector; + int numberOfSymbols; + int symbolPtr; + valueType *value; + + valueType *evaluateIdentifier(); + void printValueTersely(); + + numberOfSymbols = 0; + for (i=0; inextSymbol) { + if (symb->context != NULL && symb->context->value != NULL && + (symb->context->value->kindOfValue != + UNDEFINED_VALUE || symb->context->usage == + LABEL_SYMBOL || symb->context->usage == + EXTERNAL_SYMBOL || symb->context->usage == + UNKNOWN_SYMBOL || symb->context->usage == + NESTED_UNKNOWN_SYMBOL)) { + if (shouldDumpSymbol(symb)) { + numberOfSymbols++; + } + } + } + symbolVector = (symbolTableEntryType **)malloc( + sizeof(symbolTableEntryType *) * numberOfSymbols); + symbolPtr = 0; + for (i=0; inextSymbol) { + if (symb->context != NULL && symb->context->value != NULL && + (symb->context->value->kindOfValue != + UNDEFINED_VALUE || symb->context->usage == + LABEL_SYMBOL || symb->context->usage == + EXTERNAL_SYMBOL || symb->context->usage == + UNKNOWN_SYMBOL || symb->context->usage == + NESTED_UNKNOWN_SYMBOL)) { + if (shouldDumpSymbol(symb)) { + symbolVector[symbolPtr++] = symb; + } + } + } + qsort(symbolVector, numberOfSymbols, sizeof(symbolTableEntryType *), + symbolCompare); + for (symbolPtr=0; symbolPtr + symbolName, value->value); + } + } else if (symb->context->usage == FUNCTION_SYMBOL) { + fprintf(symbolDumpFileOutput, "%-20s = FUNCTION\n", + symb->symbolName); + } else if (symbolTableDumpOn == 2 || symb->context->usage != + BUILT_IN_FUNCTION_SYMBOL) { + value = evaluateIdentifier(symb, TRUE, NO_FIXUP_OK); + fprintf(symbolDumpFileOutput, "%-20s = ", symb-> + symbolName); + printValueTersely(value); + fprintf(symbolDumpFileOutput, " [%d]", symb-> + context->referenceCount - 1); + if (isExternal(symb)) + fprintf(symbolDumpFileOutput, " ext"); + fprintf(symbolDumpFileOutput, "\n"); + } + } + free(symbolVector); +} + + bool +hackableSymbol(symbol) + symbolTableEntryType *symbol; +{ + return(symbol->context->usage == DEFINE_SYMBOL || symbol->context-> + usage == LABEL_SYMBOL); +} + + void +printValueTersely(value) + valueType *value; +{ + static char *valueKindTable[NUM_OF_VALUE_KINDS] = { + "ABS", + "DAT", + "REL", + "BSS", + "STT", + "FLD", + "MAC", + "OPN", + "STR", + "CND", + "UND", + "FUN", + "BLK", + "BIF", + "FAL", + }; + + if (value != NULL) + fprintf(symbolDumpFileOutput, "%s: %#6x %d", valueKindTable[ + (int)value->kindOfValue], value->value, value->value); + else + fprintf(symbolDumpFileOutput, "(no value)"); +} + + void +outputReservations() +{ + while (reservationList != NULL) { + outputWord(reservationList->startAddress); + outputWord(reservationList->blockSize); + reservationList = reservationList->nextReservation; + } +} + + void +outputExpressionBuffer() +{ + int i; + + outputBigword(expressionBufferSize); + if (debug || emitPrint) + printExpressionBuffer(); + for (i=0; iexpressionReferenced); + theReferences = theReferences->nextReference; + } + } + if (haveUserStartAddress && fixupStartAddress) + outputOneExpression(startAddress); +} + + void +outputOneFunction(function) + functionDefinitionType *function; +{ + argumentDefinitionListType *argumentList; + bool encodeBlock(); + int countArguments(); + + outputByte((byte)countArguments(function)); + argumentList = function->arguments; + while (argumentList != NULL) { + outputBigword(argumentList->theArgument->ordinal); + argumentList = argumentList->nextArgument; + } + expressionBufferSize = 0; + if (encodeBlock(function->body)) + outputExpressionBuffer(); +} + + void +outputFunctions() +{ + outputBigword(externalFunctionCount); + encodingFunction = TRUE; + while (externalFunctionCount-- > 0) { + outputOneFunction(externalFunctionList); + externalFunctionList = externalFunctionList-> + nextExternalFunction; + } +} diff --git a/object.o b/object.o new file mode 100644 index 0000000000000000000000000000000000000000..66ba718c5c14a5416ed0657bc2a5900131f6d47a GIT binary patch literal 54217 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 Swmcm|;dnVm3fFmU(f=pSz{Fwz literal 0 HcmV?d00001 diff --git a/operandBody_6502.h b/operandBody_6502.h new file mode 100644 index 0000000..bc1af12 --- /dev/null +++ b/operandBody_6502.h @@ -0,0 +1,59 @@ +/* + operandBody_6502.h -- Define parser tree types for 6502 operands. + + Chip Morningstar -- Lucasfilm Ltd. + + 18-April-1985 +*/ + +typedef stringType stringOperandBodyType; + +typedef expressionType xIndexedOperandBodyType; + +typedef expressionType yIndexedOperandBodyType; + +typedef expressionType preIndexedXOperandBodyType; + +typedef expressionType postIndexedYOperandBodyType; + +typedef nullType yRegisterOperandBodyType; + +typedef nullType xRegisterOperandBodyType; + +typedef nullType aRegisterOperandBodyType; + +typedef expressionType immediateOperandBodyType; + +typedef expressionType indirectOperandBodyType; + +typedef expressionType expressionOperandBodyType; + +typedef BlockType blockOperandBodyType; + +typedef selectionListType xSelectedOperandBodyType; + +typedef selectionListType ySelectedOperandBodyType; + +typedef selectionListType preSelectedOperandBodyType; + +#define BlockOperandBodyType anyOldThing /* kludge */ +/* doing above right confuses compiler as it is a forward reference inside + yon union: */ + +typedef union { + expressionOperandBodyType *expressionUnion; + immediateOperandBodyType *immediateUnion; + indirectOperandBodyType *indirectUnion; + aRegisterOperandBodyType *aRegisterUnion; + xRegisterOperandBodyType *xRegisterUnion; + yRegisterOperandBodyType *yRegisterUnion; + postIndexedYOperandBodyType *postIndexedYUnion; + preIndexedXOperandBodyType *preIndexedXUnion; + xIndexedOperandBodyType *xIndexedUnion; + yIndexedOperandBodyType *yIndexedUnion; + xSelectedOperandBodyType *xSelectedUnion; + ySelectedOperandBodyType *ySelectedUnion; + preSelectedOperandBodyType *preSelectedUnion; + stringOperandBodyType *stringUnion; + BlockOperandBodyType *blockUnion; + } operandBodyType; diff --git a/operandBody_68000.h b/operandBody_68000.h new file mode 100644 index 0000000..b8fda7f --- /dev/null +++ b/operandBody_68000.h @@ -0,0 +1,81 @@ +/* + operandBody_68000.h -- Define parser tree types for 68000 operands. + + Chip Morningstar -- Lucasfilm Ltd. + + 25-April-1985 +*/ + +typedef expressionType expressionOperandBodyType; + +typedef stringType stringOperandBodyType; + +typedef BlockType blockOperandBodyType; + +typedef nullType dRegisterOperandBodyType; + +typedef nullType aRegisterOperandBodyType; + +typedef nullType aRegisterIndirectOperandBodyType; + +typedef nullType postincrementOperandBodyType; + +typedef nullType predecrementOperandBodyType; + +typedef expressionType displacementOperandBodyType; + +typedef selectionListType selectedOperandBodyType; + +typedef expressionType indexedOperandBodyType; + +typedef selectionListType indexSelectedOperandBodyType; + +typedef expressionType pcDisplacementOperandBodyType; + +typedef expressionType pcIndexedOperandBodyType; + +typedef expressionType immediateOperandBodyType; + +typedef expressionType absoluteShortOperandBodyType; + +typedef expressionType absoluteLongOperandBodyType; + +typedef nullType ccRegisterOperandBodyType; + +typedef nullType statusRegisterOperandBodyType; + +typedef nullType uspRegisterOperandBodyType; + +typedef nullType controlRegisterOperandBodyType; + +#define BlockOperandBodyType anyOldThing /* kludge */ +/* doing above right confuses compiler as it is a forward reference inside + yon union: */ + +typedef union { + expressionOperandBodyType *expressionUnion; + stringOperandBodyType *stringUnion; + BlockOperandBodyType *blockUnion; + dRegisterOperandBodyType *dRegisterUnion; + aRegisterOperandBodyType *aRegisterUnion; + aRegisterIndirectOperandBodyType *aRegisterIndirectUnion; + postincrementOperandBodyType *postincrementUnion; + predecrementOperandBodyType *predecrementUnion; + displacementOperandBodyType *displacementUnion; + selectedOperandBodyType *selectionUnion; + indexedOperandBodyType *indexedUnion; + indexSelectedOperandBodyType *indexSelectedUnion; + pcDisplacementOperandBodyType *pcDisplacementUnion; + pcIndexedOperandBodyType *pcIndexedUnion; + immediateOperandBodyType *immediateUnion; + absoluteShortOperandBodyType *absoluteShortUnion; + absoluteLongOperandBodyType *absoluteLongUnion; + ccRegisterOperandBodyType *ccRegisterUnion; + statusRegisterOperandBodyType *statusRegisterUnion; + uspRegisterOperandBodyType *uspRegisterUnion; + controlRegisterOperandBodyType *controlRegisterUnion; + } operandBodyType; + +#define SFC_REGISTER 0 +#define DFC_REGISTER 1 +#define VBR_REGISTER 2 diff --git a/operandDefs_6502.h b/operandDefs_6502.h new file mode 100644 index 0000000..0466578 --- /dev/null +++ b/operandDefs_6502.h @@ -0,0 +1,80 @@ +/* + operandDefs_6502.h -- Define operand types and flag bits for 6502. + + Chip Morningstar -- Lucasfilm Ltd. + + 18-April-1985 +*/ + +typedef enum { + EXPRESSION_OPND, IMMEDIATE_OPND, INDIRECT_OPND, + A_REGISTER_OPND, X_REGISTER_OPND, Y_REGISTER_OPND, + POST_INDEXED_Y_OPND, PRE_INDEXED_X_OPND, X_INDEXED_OPND, + Y_INDEXED_OPND, X_SELECTED_OPND, Y_SELECTED_OPND, + PRE_SELECTED_X_OPND, STRING_OPND, BLOCK_OPND + } operandKindType; + +#define operandKindField(op) op + +/* Opcodes: */ +/* In the opcode table we want to have information that tells which possible + address modes the corresponding instruction can utilize. The + instruction set of the 6502 breaks up into classes of instructions, such + that all of the instructions in a class accept the same address modes. + We encode the instructions by class and the classes by permissible address + modes. This helps us reduce errors in construction of the opcode table, + since getting one instruction of a given class right means getting all the + others right too. */ +typedef enum { + RELATIVE, DIR_1, DIR_2, DIR_INDIR, DIR_X_1, DIR_X_2, DIR_X_3, + DIR_Y, IMM_DIR, IMM_DIR_X, IMM_DIR_Y, NONE, INDEX, IMM_INDEX + } addressClassType; + +#define NO_OPND_BIT 0x0000 +#define EXPRESSION_OPND_BIT 0x0001 +#define IMMEDIATE_OPND_BIT 0x0002 +#define INDIRECT_OPND_BIT 0x0004 +#define A_REGISTER_OPND_BIT 0x0008 +#define X_REGISTER_OPND_BIT 0x0010 +#define Y_REGISTER_OPND_BIT 0x0020 +#define POST_INDEXED_Y_OPND_BIT 0x0040 +#define PRE_INDEXED_X_OPND_BIT 0x0080 +#define X_INDEXED_OPND_BIT 0x0100 +#define Y_INDEXED_OPND_BIT 0x0200 +#define X_SELECTED_OPND_BIT 0x0400 +#define Y_SELECTED_OPND_BIT 0x0800 +#define PRE_SELECTED_X_OPND_BIT 0x1000 +#define STRING_OPND_BIT 0x2000 +#define BLOCK_OPND_BIT 0x4000 +#define ANY_OPND_BITS 0xFFFF + +#define REL_CLASS_BITS EXPRESSION_OPND_BIT +#define DIR_1_CLASS_BITS EXPRESSION_OPND_BIT +#define DIR_2_CLASS_BITS EXPRESSION_OPND_BIT +#define DIR_INDIR_CLASS_BITS EXPRESSION_OPND_BIT | INDIRECT_OPND_BIT +#define DIR_X_1_CLASS_BITS EXPRESSION_OPND_BIT | X_INDEXED_OPND_BIT | \ + X_SELECTED_OPND_BIT | A_REGISTER_OPND_BIT +#define DIR_X_2_CLASS_BITS EXPRESSION_OPND_BIT | X_INDEXED_OPND_BIT | \ + X_SELECTED_OPND_BIT +#define DIR_X_3_CLASS_BITS EXPRESSION_OPND_BIT | X_INDEXED_OPND_BIT | \ + X_SELECTED_OPND_BIT +#define DIR_Y_CLASS_BITS EXPRESSION_OPND_BIT | Y_INDEXED_OPND_BIT | \ + Y_SELECTED_OPND_BIT +#define IMM_DIR_CLASS_BITS EXPRESSION_OPND_BIT | IMMEDIATE_OPND_BIT +#define IMM_DIR_X_CLASS_BITS EXPRESSION_OPND_BIT | IMMEDIATE_OPND_BIT | \ + X_INDEXED_OPND_BIT | X_SELECTED_OPND_BIT +#define IMM_DIR_Y_CLASS_BITS EXPRESSION_OPND_BIT | IMMEDIATE_OPND_BIT | \ + Y_INDEXED_OPND_BIT | Y_SELECTED_OPND_BIT +#define NONE_CLASS_BITS NO_OPND_BIT +#define IMM_INDEX_CLASS_BITS X_INDEXED_OPND_BIT | Y_INDEXED_OPND_BIT | \ + X_SELECTED_OPND_BIT | Y_SELECTED_OPND_BIT | \ + IMMEDIATE_OPND_BIT | PRE_INDEXED_X_OPND_BIT |\ + POST_INDEXED_Y_OPND_BIT | \ + EXPRESSION_OPND_BIT | PRE_SELECTED_X_OPND_BIT +#define INDEX_CLASS_BITS X_INDEXED_OPND_BIT | Y_INDEXED_OPND_BIT | \ + X_SELECTED_OPND_BIT | Y_SELECTED_OPND_BIT | \ + PRE_INDEXED_X_OPND_BIT | \ + POST_INDEXED_Y_OPND_BIT | \ + EXPRESSION_OPND_BIT | PRE_SELECTED_X_OPND_BIT + +#define MAX_NUMBER_OF_OPERANDS 1 diff --git a/operandDefs_68000.h b/operandDefs_68000.h new file mode 100644 index 0000000..5a951d3 --- /dev/null +++ b/operandDefs_68000.h @@ -0,0 +1,279 @@ +/* + operandDefs_68000.h -- Define operand types and flag bits for 68000. + + Chip Morningstar -- Lucasfilm Ltd. + + 25-April-1985 +*/ + +typedef enum { + EXPRESSION_OPND, STRING_OPND, BLOCK_OPND, D_REGISTER_OPND, + A_REGISTER_OPND, A_REGISTER_INDIRECT_OPND, POSTINCREMENT_OPND, + PREDECREMENT_OPND, DISPLACEMENT_OPND, INDEXED_OPND, + PC_DISPLACEMENT_OPND, PC_INDEXED_OPND, IMMEDIATE_OPND, + ABSOLUTE_SHORT_OPND, ABSOLUTE_LONG_OPND, CC_REGISTER_OPND, + STATUS_REGISTER_OPND, USP_REGISTER_OPND, + CONTROL_REGISTER_OPND, SELECTED_OPND, INDEX_SELECTED_OPND, + } operandKindType; + +/*** Hack warning ***/ + +/* We know that enumerated types are actually just ints. Some of the address + modes require some additional information in the form of one or two + register numbers. We want to still encode this information in one int. + Therefor, we are going to OR some bits representing the register into the + higher-order bits of the type word, thus violating the principle of + enumerated types (it's just that the 'enum' syntax above is so much cleaner + than a bunch of '#define's) */ + +#define getRegisterField(op, n) ((((int)op)>>(8+(n-1)*4)) & 0xF) +#define setRegisterField(op, n, r) (op=((int)op | \ + (((r)&0xF)<<(8+((n)-1)*4)))) + +#define getAddressRegister(op) (getRegisterField(op, 1) - 8) +#define getDataRegister(op) getRegisterField(op, 1) +#define getRegister(op) getRegisterField(op, 1) +#define getIndexRegister(op) getRegisterField(op, 2) +#define getWL(op) (((int)op >> 16) & 1) + +#define setAddressRegister(op, r) setRegisterField(op, 1, (int)r + 8) +#define setDataRegister(op, r) setRegisterField(op, 1, (int)r) +#define setRegister(op, r) setRegisterField(op, 1, (int)r) +#define setIndexRegister(op, r) setRegisterField(op, 2, (int)r) +#define setWL(op, wl) (op = ((int)op | (((wl) & 1) << 16))) + +#define operandKindField(op) (operandKindType)((int)op & 0xFF) + +/* Opcodes: */ +/* In the opcode table we want to have information that tells which possible + address modes the corresponding instruction can utilize. The + instruction set of the 68000 breaks up into classes of instructions, such + that all of the instructions in a class accept the same address modes. + We encode the instructions by class and the classes by permissible address + modes. This helps us reduce errors in construction of the opcode table, + since getting one instruction of a given class right means getting all the + others right too. Ordinarily we'd give each class a nice mnemonic name, + but the 68000 has 26 idiosyncratic classes and a unique name for each + would confuse more than it would help. */ + +typedef enum { + CLASS_I, CLASS_II, CLASS_III, CLASS_IV, CLASS_V, CLASS_VI, + CLASS_VII, CLASS_VIII, CLASS_IX, CLASS_X, CLASS_XI, CLASS_XII, + CLASS_XIII, CLASS_XIV, CLASS_XV, CLASS_XVI, CLASS_XVII, + CLASS_XVIII, CLASS_XIX, CLASS_XX, CLASS_XXI, CLASS_XXII, + CLASS_XXIII, CLASS_XXIV, CLASS_XXV, CLASS_XXVI, CLASS_XXVII, + CLASS_XXVIII, + } addressClassType; + +/* The various address modes as required by the various instructions manage to + sort themselves into a number of independent groups. We will give these + groups names to facilitate operand address mode checking */ + +#define NO_OPND_BIT 0x000000 +#define EXPRESSION_OPND_BIT 0x000001 +#define STRING_OPND_BIT 0x000002 +#define BLOCK_OPND_BIT 0x000004 +#define D_REGISTER_OPND_BIT 0x000008 +#define A_REGISTER_OPND_BIT 0x000010 +#define A_REGISTER_INDIRECT_OPND_BIT 0x000020 +#define POSTINCREMENT_OPND_BIT 0x000040 +#define PREDECREMENT_OPND_BIT 0x000080 +#define DISPLACEMENT_OPND_BIT 0x000100 +#define INDEXED_OPND_BIT 0x000200 +#define PC_DISPLACEMENT_OPND_BIT 0x000400 +#define PC_INDEXED_OPND_BIT 0x000800 +#define IMMEDIATE_OPND_BIT 0x001000 +#define ABSOLUTE_SHORT_OPND_BIT 0x002000 +#define ABSOLUTE_LONG_OPND_BIT 0x004000 +#define CC_REGISTER_OPND_BIT 0x008000 +#define STATUS_REGISTER_OPND_BIT 0x010000 +#define USP_REGISTER_OPND_BIT 0x020000 +#define CONTROL_REGISTER_OPND_BIT 0x040000 +#define SELECTED_OPND_BIT 0x080000 +#define INDEX_SELECTED_OPND_BIT 0x100000 +#define ANY_OPND_BITS 0xFFFFFF + +#define D_REGISTER_GROUP_BITS D_REGISTER_OPND_BIT +#define GROUP_A D_REGISTER_GROUP_BITS + +#define A_REGISTER_GROUP_BITS A_REGISTER_OPND_BIT +#define GROUP_B A_REGISTER_GROUP_BITS + +#define POSTINCREMENT_GROUP_BITS POSTINCREMENT_OPND_BIT +#define GROUP_C POSTINCREMENT_GROUP_BITS + +#define PREDECREMENT_GROUP_BITS PREDECREMENT_OPND_BIT +#define GROUP_D PREDECREMENT_GROUP_BITS + +#define DISPLACEMENT_GROUP_BITS (DISPLACEMENT_OPND_BIT | \ + SELECTED_OPND_BIT) +#define GROUP_E DISPLACEMENT_GROUP_BITS + +#define IMMEDIATE_GROUP_BITS IMMEDIATE_OPND_BIT +#define GROUP_F IMMEDIATE_GROUP_BITS + +#define NORMAL_GROUP_BITS EXPRESSION_OPND_BIT +#define GROUP_G NORMAL_GROUP_BITS + +#define CC_REGISTER_GROUP_BITS CC_REGISTER_OPND_BIT +#define GROUP_H CC_REGISTER_GROUP_BITS + +#define STATUS_REGISTER_GROUP_BITS STATUS_REGISTER_OPND_BIT +#define GROUP_I STATUS_REGISTER_GROUP_BITS + +#define IMPLIED_GROUP_BITS NO_OPND_BIT +#define GROUP_J IMPLIED_GROUP_BITS + +#define USP_REGISTER_GROUP_BITS USP_REGISTER_OPND_BIT +#define GROUP_K USP_REGISTER_GROUP_BITS + +#define CONTROL_REGISTER_GROUP_BITS (USP_REGISTER_OPND_BIT | \ + CONTROL_REGISTER_OPND_BIT) +#define GROUP_L CONTROL_REGISTER_GROUP_BITS + +#define REGISTER_GROUP_BITS (D_REGISTER_OPND_BIT | \ + A_REGISTER_OPND_BIT) +#define GROUP_M REGISTER_GROUP_BITS + +#define STORABLE_GROUP_BITS (D_REGISTER_OPND_BIT | \ + A_REGISTER_OPND_BIT | \ + A_REGISTER_INDIRECT_OPND_BIT | \ + POSTINCREMENT_OPND_BIT | \ + PREDECREMENT_OPND_BIT | \ + DISPLACEMENT_OPND_BIT | \ + SELECTED_OPND_BIT | \ + INDEXED_OPND_BIT | \ + INDEX_SELECTED_OPND_BIT | \ + ABSOLUTE_SHORT_OPND_BIT | \ + ABSOLUTE_LONG_OPND_BIT | \ + EXPRESSION_OPND_BIT) +#define GROUP_N STORABLE_GROUP_BITS + +#define FULL_EA_GROUP_BITS (D_REGISTER_OPND_BIT | \ + A_REGISTER_OPND_BIT | \ + A_REGISTER_INDIRECT_OPND_BIT | \ + POSTINCREMENT_OPND_BIT | \ + PREDECREMENT_OPND_BIT | \ + DISPLACEMENT_OPND_BIT | \ + SELECTED_OPND_BIT | \ + INDEXED_OPND_BIT | \ + INDEX_SELECTED_OPND_BIT | \ + PC_DISPLACEMENT_OPND_BIT | \ + PC_INDEXED_OPND_BIT | \ + IMMEDIATE_OPND_BIT | \ + ABSOLUTE_SHORT_OPND_BIT | \ + ABSOLUTE_LONG_OPND_BIT | \ + EXPRESSION_OPND_BIT) +#define GROUP_O FULL_EA_GROUP_BITS + +#define STORABLE_NO_A_REGISTER_GROUP_BITS \ + (D_REGISTER_OPND_BIT | \ + A_REGISTER_INDIRECT_OPND_BIT | \ + POSTINCREMENT_OPND_BIT | \ + PREDECREMENT_OPND_BIT | \ + DISPLACEMENT_OPND_BIT | \ + SELECTED_OPND_BIT | \ + INDEXED_OPND_BIT | \ + INDEX_SELECTED_OPND_BIT | \ + ABSOLUTE_SHORT_OPND_BIT | \ + ABSOLUTE_LONG_OPND_BIT | \ + EXPRESSION_OPND_BIT) +#define GROUP_P STORABLE_NO_A_REGISTER_GROUP_BITS + +#define FULL_EA_NO_A_REGISTER_GROUP_BITS (D_REGISTER_OPND_BIT | \ + A_REGISTER_INDIRECT_OPND_BIT | \ + POSTINCREMENT_OPND_BIT | \ + PREDECREMENT_OPND_BIT | \ + DISPLACEMENT_OPND_BIT | \ + SELECTED_OPND_BIT | \ + INDEXED_OPND_BIT | \ + INDEX_SELECTED_OPND_BIT | \ + PC_DISPLACEMENT_OPND_BIT | \ + PC_INDEXED_OPND_BIT | \ + IMMEDIATE_OPND_BIT | \ + ABSOLUTE_SHORT_OPND_BIT | \ + ABSOLUTE_LONG_OPND_BIT | \ + EXPRESSION_OPND_BIT) +#define GROUP_Q FULL_EA_NO_A_REGISTER_GROUP_BITS + +#define MISC_1_GROUP_BITS (A_REGISTER_INDIRECT_OPND_BIT | \ + POSTINCREMENT_OPND_BIT | \ + DISPLACEMENT_OPND_BIT | \ + SELECTED_OPND_BIT | \ + INDEXED_OPND_BIT | \ + INDEX_SELECTED_OPND_BIT | \ + PC_DISPLACEMENT_OPND_BIT | \ + PC_INDEXED_OPND_BIT | \ + ABSOLUTE_SHORT_OPND_BIT | \ + ABSOLUTE_LONG_OPND_BIT | \ + EXPRESSION_OPND_BIT) +#define GROUP_R MISC_1_GROUP_BITS + +#define STORABLE_NO_REGISTER_GROUP_BITS (A_REGISTER_INDIRECT_OPND_BIT | \ + POSTINCREMENT_OPND_BIT | \ + PREDECREMENT_OPND_BIT | \ + DISPLACEMENT_OPND_BIT | \ + SELECTED_OPND_BIT | \ + INDEXED_OPND_BIT | \ + INDEX_SELECTED_OPND_BIT | \ + ABSOLUTE_SHORT_OPND_BIT | \ + ABSOLUTE_LONG_OPND_BIT | \ + EXPRESSION_OPND_BIT) +#define GROUP_S STORABLE_NO_REGISTER_GROUP_BITS + +#define MISC_2_GROUP_BITS (A_REGISTER_INDIRECT_OPND_BIT | \ + PREDECREMENT_OPND_BIT | \ + DISPLACEMENT_OPND_BIT | \ + SELECTED_OPND_BIT | \ + INDEXED_OPND_BIT | \ + INDEX_SELECTED_OPND_BIT | \ + ABSOLUTE_SHORT_OPND_BIT | \ + ABSOLUTE_LONG_OPND_BIT | \ + EXPRESSION_OPND_BIT) +#define GROUP_T MISC_2_GROUP_BITS + +#define MISC_3_GROUP_BITS (A_REGISTER_INDIRECT_OPND_BIT | \ + DISPLACEMENT_OPND_BIT | \ + SELECTED_OPND_BIT | \ + INDEXED_OPND_BIT | \ + INDEX_SELECTED_OPND_BIT | \ + PC_DISPLACEMENT_OPND_BIT | \ + PC_INDEXED_OPND_BIT | \ + ABSOLUTE_SHORT_OPND_BIT | \ + ABSOLUTE_LONG_OPND_BIT | \ + EXPRESSION_OPND_BIT) +#define GROUP_U MISC_3_GROUP_BITS + +#define CLASS_I_BITS (GROUP_A | GROUP_D) +#define CLASS_II_BITS (GROUP_A | GROUP_B | GROUP_F | GROUP_O | \ + GROUP_P | GROUP_S) +#define CLASS_III_BITS (GROUP_F | GROUP_N) +#define CLASS_IV_BITS (GROUP_A | GROUP_F | GROUP_H | GROUP_I | \ + GROUP_P | GROUP_Q | GROUP_S) +#define CLASS_V_BITS (GROUP_A | GROUP_F | GROUP_S) +#define CLASS_VI_BITS GROUP_G +#define CLASS_VII_BITS (GROUP_A | GROUP_F | GROUP_P) +#define CLASS_VIII_BITS (GROUP_A | GROUP_Q) +#define CLASS_IX_BITS GROUP_P +#define CLASS_X_BITS (GROUP_A | GROUP_B | GROUP_F | GROUP_O | GROUP_P) +#define CLASS_XI_BITS GROUP_C +#define CLASS_XII_BITS (GROUP_A | GROUP_G) +#define CLASS_XIII_BITS (GROUP_A | GROUP_F | GROUP_H | GROUP_I | GROUP_P) +#define CLASS_XIV_BITS GROUP_M +#define CLASS_XV_BITS GROUP_A +#define CLASS_XVI_BITS GROUP_J +#define CLASS_XVII_BITS GROUP_U +#define CLASS_XVIII_BITS (GROUP_B | GROUP_U) +#define CLASS_XIX_BITS (GROUP_B | GROUP_F) +#define CLASS_XX_BITS (GROUP_B | GROUP_H | GROUP_I | GROUP_K | \ + GROUP_L | GROUP_M | GROUP_O | GROUP_Q) +#define CLASS_XXI_BITS (GROUP_M | GROUP_R | GROUP_T) +#define CLASS_XXII_BITS (GROUP_A | GROUP_E) +#define CLASS_XXIII_BITS (GROUP_A | GROUP_F) +#define CLASS_XXIV_BITS (GROUP_M | GROUP_S) +#define CLASS_XXV_BITS GROUP_F +#define CLASS_XXVI_BITS GROUP_B +#define CLASS_XXVII_BITS GROUP_F +#define CLASS_XXVIII_BITS GROUP_F + +#define MAX_NUMBER_OF_OPERANDS 17 diff --git a/operandStuffSD.o b/operandStuffSD.o new file mode 100644 index 0000000000000000000000000000000000000000..010a02a578196abe96c618adc75159eb882a39bd GIT binary patch literal 41461 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 literal 0 HcmV?d00001 diff --git a/operandStuffSD_6502.c b/operandStuffSD_6502.c new file mode 100644 index 0000000..64828b7 --- /dev/null +++ b/operandStuffSD_6502.c @@ -0,0 +1,389 @@ +/* + operandStuff_6502.c -- Various target processor routines to handle + operands in the Macross assembler (6502 version). + + Chip Morningstar -- Lucasfilm Ltd. + + 23-April-1985 +*/ + +#include "macrossTypes.h" +#include "macrossGlobals.h" + +/* corresponds to routines in buildStuff2.c */ + + operandType * +buildOperand(kindOfOperand, arg) + operandKindType kindOfOperand; + anyOldThing *arg; +{ + operandType *result; + + result = typeAlloc(operandType); + result->kindOfOperand = kindOfOperand; + result->nextOperand = NULL; + switch (kindOfOperand) { + + case EXPRESSION_OPND: + result->theOperand.expressionUnion = + (expressionOperandBodyType *) arg; + break; + + case IMMEDIATE_OPND: + result->theOperand.immediateUnion = + (immediateOperandBodyType *) arg; + break; + + case INDIRECT_OPND: + result->theOperand.indirectUnion = + (indirectOperandBodyType *) arg; + break; + + case A_REGISTER_OPND: + result->theOperand.aRegisterUnion = + (aRegisterOperandBodyType *) NULL; + break; + + case X_REGISTER_OPND: + result->theOperand.xRegisterUnion = + (xRegisterOperandBodyType *) NULL; + break; + + case Y_REGISTER_OPND: + result->theOperand.yRegisterUnion = + (yRegisterOperandBodyType *) NULL; + break; + + case POST_INDEXED_Y_OPND: + result->theOperand.postIndexedYUnion = + (postIndexedYOperandBodyType *) arg; + break; + + case PRE_INDEXED_X_OPND: + result->theOperand.preIndexedXUnion = + (preIndexedXOperandBodyType *) arg; + break; + + case X_INDEXED_OPND: + result->theOperand.xIndexedUnion = + (xIndexedOperandBodyType *) arg; + break; + + case Y_INDEXED_OPND: + result->theOperand.yIndexedUnion = + (yIndexedOperandBodyType *) arg; + break; + + case X_SELECTED_OPND: + result->theOperand.xSelectedUnion = + (xSelectedOperandBodyType *) arg; + break; + + case Y_SELECTED_OPND: + result->theOperand.ySelectedUnion = + (ySelectedOperandBodyType *) arg; + break; + + case PRE_SELECTED_X_OPND: + result->theOperand.preSelectedUnion = + (preSelectedOperandBodyType *) arg; + break; + + case STRING_OPND: + result->theOperand.stringUnion = + (stringOperandBodyType *) arg; + break; + + case BLOCK_OPND: + result->theOperand.blockUnion = (BlockOperandBodyType *) arg; + break; + + default: + botch("unknown operand kind: %d\n", kindOfOperand); + break; + } + return(result); +} + +/* corresponds to routines in fixups.c */ + + operandListType * +duplicateOperandForFixup(operand, isSpecialFunctionOperand) + operandListType *operand; + bool isSpecialFunctionOperand; +{ + operandListType *result; + + expressionType *duplicateExpressionForFixup(); + + result = typeAlloc(operandListType); + result->kindOfOperand = operand->kindOfOperand; + result->nextOperand = NULL; + if (operand->kindOfOperand != EXPRESSION_OPND) + newFixupAddressMode = operand->kindOfOperand; + switch (operand->kindOfOperand) { + case EXPRESSION_OPND: + case IMMEDIATE_OPND: + case INDIRECT_OPND: + case POST_INDEXED_Y_OPND: + case PRE_INDEXED_X_OPND: + case X_INDEXED_OPND: + case Y_INDEXED_OPND: + result->theOperand.expressionUnion = + duplicateExpressionForFixup(operand->theOperand, + FALSE, isSpecialFunctionOperand); + break; + case X_SELECTED_OPND: + case Y_SELECTED_OPND: + case PRE_SELECTED_X_OPND: + result->theOperand.expressionUnion = + duplicateExpressionForFixup(operand->theOperand, + FALSE, isSpecialFunctionOperand); + break; + case A_REGISTER_OPND: + case X_REGISTER_OPND: + case Y_REGISTER_OPND: + result->theOperand = operand->theOperand; + break; + case STRING_OPND: + result->theOperand = operand->theOperand; + break; + case BLOCK_OPND: + error(CANT_FORWARD_REFERENCE_BLOCK_ERROR); + result = NULL; + break; + } + return(result); +} + +/* corresponds to routines in garbage.c */ + +#define nullFree(thing) if (thing == NULL) return; + + void +freeOperand(operand) + operandType *operand; +{ + nullFree(operand); + switch (operand->kindOfOperand) { + + case EXPRESSION_OPND: + case IMMEDIATE_OPND: + case INDIRECT_OPND: + case POST_INDEXED_Y_OPND: + case PRE_INDEXED_X_OPND: + case X_INDEXED_OPND: + case Y_INDEXED_OPND: + freeExpression(operand->theOperand); + break; + + case A_REGISTER_OPND: + case X_REGISTER_OPND: + case Y_REGISTER_OPND: + break; + + case X_SELECTED_OPND: + case Y_SELECTED_OPND: + case PRE_SELECTED_X_OPND: + freeSelectionList(operand->theOperand); + break; + + case STRING_OPND: + freeString(operand->theOperand); + break; + + case BLOCK_OPND: + freeBlock(operand->theOperand); + break; + + default: + botch("bad operand kind in freeOperand %d\n", + operand->kindOfOperand); + break; + } + freeOperand(operand->nextOperand); + free(operand); +} + +/* corresponds to routines in listing.c */ + + void +expandOperand(addressMode) + operandKindType addressMode; +{ + switch (addressMode) { + case IMMEDIATE_OPND: moreText("#"); break; + case INDIRECT_OPND: moreText("@"); break; + case POST_INDEXED_Y_OPND: moreText("y[@"); break; + case PRE_INDEXED_X_OPND: moreText("@x["); break; + case X_INDEXED_OPND: moreText("x["); break; + case Y_INDEXED_OPND: moreText("y["); break; + case A_REGISTER_OPND: moreText("a"); break; + case X_REGISTER_OPND: moreText("x"); break; + case Y_REGISTER_OPND: moreText("y"); break; + case X_SELECTED_OPND: moreText("x"); break; + case Y_SELECTED_OPND: moreText("y"); break; + case PRE_SELECTED_X_OPND: moreText("@x"); break; + default: break; + } + expandExpression(NULL); + if (addressMode == POST_INDEXED_Y_OPND || + addressMode == PRE_INDEXED_X_OPND || + addressMode == X_INDEXED_OPND || + addressMode == Y_INDEXED_OPND) + moreText("]"); +} + +/* corresponds to routines in expressionSemantics.c */ + +#define nullEvaluate(thing) if (thing==NULL) return(NULL); +#define fail(err) if (!expressionFailed) {\ + error(err);\ + expressionFailed = TRUE;\ + } +#define fail1(err,arg) if (!expressionFailed) {\ + error(err,arg);\ + expressionFailed = TRUE;\ + } +#define fail2(err,arg1,arg2) if (!expressionFailed) {\ + error(err,arg1,arg2);\ + expressionFailed = TRUE;\ + } + +#define qfree2(a,b) if (freeFlag) { free(a); free(b); } + +#define expansionOff() {saveExpansion=expandMacros; expandMacros=FALSE;} +#define forceExpansion() {saveExpansion=expandMacros; expandMacros=TRUE;} +#define expansionOn() expandMacros=saveExpansion; + + valueType * +evaluateOperand(operand) + operandType *operand; +{ + valueType *result; + bool saveExpansion; + expressionType *expression; + + valueType *evaluateExpression(); + valueType *evaluateSelectionList(); + valueType *newValue(); + + nullEvaluate(operand); + if (operand->kindOfOperand != EXPRESSION_OPND) + newFixupAddressMode = operand->kindOfOperand; + switch (operand->kindOfOperand) { + + case EXPRESSION_OPND: + case IMMEDIATE_OPND: + case INDIRECT_OPND: + case POST_INDEXED_Y_OPND: + case PRE_INDEXED_X_OPND: + case X_INDEXED_OPND: + case Y_INDEXED_OPND: + result = evaluateExpression(operand->theOperand, + performingFixups ? NO_FIXUP : OPERAND_FIXUP); + if (operand->kindOfOperand != EXPRESSION_OPND) { + if (result->addressMode != EXPRESSION_OPND) { + error(BAD_ADDRESS_MODE_ERROR); + result->kindOfValue = FAIL; + } else { + result->addressMode = operand->kindOfOperand; + } + } + break; + + case A_REGISTER_OPND: + case X_REGISTER_OPND: + case Y_REGISTER_OPND: + result = newValue(UNDEFINED_VALUE, 0, operand-> + kindOfOperand); + break; + + case X_SELECTED_OPND: + case Y_SELECTED_OPND: + case PRE_SELECTED_X_OPND: + result = evaluateSelectionList(operand->theOperand); + if (result->addressMode != EXPRESSION_OPND) { + error(BAD_ADDRESS_MODE_ERROR); + result->kindOfValue = FAIL; + } else { + result->addressMode = operand->kindOfOperand; + } + break; + + case STRING_OPND: + result = newValue(STRING_VALUE, operand->theOperand, + STRING_OPND); + break; + + case BLOCK_OPND: + if (standaloneExpansionFlag) + forceExpansion(); + sideEffectFlag = TRUE; + assembleBlock(operand->theOperand); + expansionOn(); + result = newValue(FAIL, 0, BLOCK_OPND); + break; + + default: + botch("bad operand kind in evaluateOperand %d\n", + operand->kindOfOperand); + break; + } + return(result); +} + +/* from parserMisc.c */ + + conditionType +invertConditionCode(conditionCode) + conditionType conditionCode; +{ +#define cc (int)conditionCode + + if ((int)CARRY_COND<=cc && cc<=(int)ALWAYS_COND) + return((conditionType) + (cc - (int)CARRY_COND + (int)NOT_CARRY_COND)); + else if ((int)NOT_CARRY_COND<=cc && cc<=(int)NEVER_COND) + return((conditionType) + (cc + (int)CARRY_COND - (int)NOT_CARRY_COND)); + else + botch("invertConditionCode given %d, not a condition code\n"); +} + +/* from semanticMisc.c */ + + bool +shouldParenthesize(operand) + operandType *operand; +{ + expressionTermKindType kind; + + switch(operand->kindOfOperand) { + case EXPRESSION_OPND: + case IMMEDIATE_OPND: + case INDIRECT_OPND: + case POST_INDEXED_Y_OPND: + case PRE_INDEXED_X_OPND: + case X_INDEXED_OPND: + case Y_INDEXED_OPND: + kind = operand->theOperand.expressionUnion->kindOfTerm; + return (kind==UNOP_EXPR || kind==BINOP_EXPR || kind== + ASSIGN_EXPR); + break; + + case X_SELECTED_OPND: + case Y_SELECTED_OPND: + case PRE_SELECTED_X_OPND: + return(TRUE); + break; + + case A_REGISTER_OPND: + case X_REGISTER_OPND: + case Y_REGISTER_OPND: + case STRING_OPND: + case BLOCK_OPND: + return(FALSE); + break; + } +} diff --git a/operandStuffSD_68000.c b/operandStuffSD_68000.c new file mode 100644 index 0000000..f6d1a81 --- /dev/null +++ b/operandStuffSD_68000.c @@ -0,0 +1,559 @@ +/* + operandStuff_68000.c -- Various target processor routines to handle + operands in the Macross assembler (68000 version). + + Chip Morningstar -- Lucasfilm Ltd. + + 26-April-1985 +*/ + +#include "macrossTypes.h" +#include "macrossGlobals.h" + +/* corresponds to routines in buildStuff2.c */ + + operandType * +buildOperand(kindOfOperand, arg1, arg2, arg3, arg4) + operandKindType kindOfOperand; + int arg1; + int arg2; + int arg3; + int arg4; +{ + operandType *result; + + result = typeAlloc(operandType); + result->kindOfOperand = kindOfOperand; + result->nextOperand = NULL; + switch (kindOfOperand) { + + case EXPRESSION_OPND: + result->theOperand.expressionUnion = + (expressionOperandBodyType *) arg1; + break; + + case STRING_OPND: + result->theOperand.stringUnion = + (stringOperandBodyType *) arg1; + break; + + case BLOCK_OPND: + result->theOperand.blockUnion = (BlockOperandBodyType *) arg1; + break; + + case D_REGISTER_OPND: + result->theOperand.dRegisterUnion = + (dRegisterOperandBodyType *) NULL; + setRegister(result->kindOfOperand, arg1); + break; + + case A_REGISTER_OPND: + result->theOperand.aRegisterUnion = + (aRegisterOperandBodyType *) NULL; + setRegister(result->kindOfOperand, arg1); + break; + + case A_REGISTER_INDIRECT_OPND: + result->theOperand.aRegisterIndirectUnion = + (aRegisterIndirectOperandBodyType *) NULL; + setRegister(result->kindOfOperand, arg1); + break; + + case POSTINCREMENT_OPND: + result->theOperand.postincrementUnion = + (postincrementOperandBodyType *) NULL; + setRegister(result->kindOfOperand, arg1); + break; + + case PREDECREMENT_OPND: + result->theOperand.predecrementUnion = + (predecrementOperandBodyType *) NULL; + setRegister(result->kindOfOperand, arg1); + break; + + case DISPLACEMENT_OPND: + result->theOperand.displacementUnion = + (displacementOperandBodyType *) arg2; + setRegister(result->kindOfOperand, arg1); + break; + + case SELECTED_OPND: + result->theOperand.selectionUnion = + (selectedOperandBodyType *) arg2; + setRegister(result->kindOfOperand, arg1); + break; + + case INDEXED_OPND: + result->theOperand.indexedUnion = + (indexedOperandBodyType *) arg1; + setRegister(result->kindOfOperand, arg2); + setIndexRegister(result->kindOfOperand, arg3); + setWL(result->kindOfOperand, (int)arg4); + break; + + case INDEX_SELECTED_OPND: + result->theOperand.indexSelectedUnion = + (indexSelectedOperandBodyType *) arg1; + setRegister(result->kindOfOperand, arg2); + setIndexRegister(result->kindOfOperand, arg3); + setWL(result->kindOfOperand, (int)arg4); + break; + + case PC_DISPLACEMENT_OPND: + result->theOperand.pcDisplacementUnion = + (pcDisplacementOperandBodyType *) arg1; + break; + + case PC_INDEXED_OPND: + result->theOperand.pcIndexedUnion = + (pcIndexedOperandBodyType *) arg1; + setIndexRegister(result->kindOfOperand, arg2); + setWL(result->kindOfOperand, (int)arg3); + break; + + case IMMEDIATE_OPND: + result->theOperand.immediateUnion = + (immediateOperandBodyType *) arg1; + break; + + case ABSOLUTE_SHORT_OPND: + result->theOperand.absoluteShortUnion = + (absoluteShortOperandBodyType *) arg1; + break; + + case ABSOLUTE_LONG_OPND: + result->theOperand.absoluteLongUnion = + (absoluteLongOperandBodyType *) arg1; + break; + + case CC_REGISTER_OPND: + result->theOperand.ccRegisterUnion = + (ccRegisterOperandBodyType *) NULL; + break; + + case STATUS_REGISTER_OPND: + result->theOperand.statusRegisterUnion = + (statusRegisterOperandBodyType *) NULL; + break; + + case USP_REGISTER_OPND: + result->theOperand.uspRegisterUnion = + (uspRegisterOperandBodyType *) NULL; + break; + + case CONTROL_REGISTER_OPND: + result->theOperand.controlRegisterUnion = + (controlRegisterOperandBodyType *) NULL; + setRegister(result->kindOfOperand, arg1); + break; + + default: + botch("unknown operand kind: %d\n", kindOfOperand); + break; + } + return(result); +} + +/* corresponds to routines in fixups.c */ + + operandListType * +duplicateOperandForFixup(operand, isSpecialFunctionOperand) + operandListType *operand; + bool isSpecialFunctionOperand; +{ + operandListType *result; + + expressionType *duplicateExpressionForFixup(); + + result = typeAlloc(operandListType); + result->kindOfOperand = operand->kindOfOperand; + result->nextOperand = NULL; + if (operand->kindOfOperand != EXPRESSION_OPND) + newFixupAddressMode = operand->kindOfOperand; + switch (operandKindField(operand->kindOfOperand)) { + + case EXPRESSION_OPND: + case DISPLACEMENT_OPND: + case SELECTED_OPND: + case INDEXED_OPND: + case INDEX_SELECTED_OPND: + case PC_DISPLACEMENT_OPND: + case PC_INDEXED_OPND: + case IMMEDIATE_OPND: + case ABSOLUTE_SHORT_OPND: + case ABSOLUTE_LONG_OPND: + result->theOperand.expressionUnion = + duplicateExpressionForFixup(operand->theOperand, + FALSE, isSpecialFunctionOperand); + break; + case D_REGISTER_OPND: + case A_REGISTER_OPND: + case A_REGISTER_INDIRECT_OPND: + case POSTINCREMENT_OPND: + case PREDECREMENT_OPND: + case CC_REGISTER_OPND: + case STATUS_REGISTER_OPND: + case USP_REGISTER_OPND: + case CONTROL_REGISTER_OPND: + result->theOperand = operand->theOperand; + break; + case STRING_OPND: + result->theOperand = operand->theOperand; + break; + case BLOCK_OPND: + error(CANT_FORWARD_REFERENCE_BLOCK_ERROR); + result = NULL; + break; + } + return(result); +} + +/* corresponds to routines in garbage.c */ + +#define nullFree(thing) if (thing == NULL) return; + + void +freeOperand(operand) + operandType *operand; +{ + nullFree(operand); + switch (operandKindField(operand->kindOfOperand)) { + + case EXPRESSION_OPND: + case DISPLACEMENT_OPND: + case INDEXED_OPND: + case PC_DISPLACEMENT_OPND: + case PC_INDEXED_OPND: + case IMMEDIATE_OPND: + case ABSOLUTE_SHORT_OPND: + case ABSOLUTE_LONG_OPND: + freeExpression(operand->theOperand); + break; + + case D_REGISTER_OPND: + case A_REGISTER_OPND: + case A_REGISTER_INDIRECT_OPND: + case POSTINCREMENT_OPND: + case PREDECREMENT_OPND: + case CC_REGISTER_OPND: + case STATUS_REGISTER_OPND: + case USP_REGISTER_OPND: + case CONTROL_REGISTER_OPND: + break; + + case SELECTED_OPND: + case INDEX_SELECTED_OPND: + freeSelectionList(operand->theOperand); + break; + + case STRING_OPND: + freeString(operand->theOperand); + break; + + case BLOCK_OPND: + freeBlock(operand->theOperand); + break; + + default: + botch("bad operand kind in freeOperand %d\n", + operand->kindOfOperand); + break; + } + freeOperand(operand->nextOperand); + free(operand); +} + +/* corresponds to routines in listing.c */ + + void +expandOperand(addressMode, buffer) + operandKindType addressMode; + char *buffer; +{ + char *bufferPtr; + + bufferPtr = buffer; + switch (operandKindField(addressMode)) { + case D_REGISTER_OPND: + moreTextOptional(buffer, &bufferPtr, "d"); + expandNum(buffer, &bufferPtr, getRegister(addressMode)); + break; + case A_REGISTER_OPND: + moreTextOptional(buffer, &bufferPtr, "a"); + expandNum(buffer, &bufferPtr, getRegister(addressMode)); + break; + case A_REGISTER_INDIRECT_OPND: + moreTextOptional(buffer, &bufferPtr, "[a"); + expandNum(buffer, &bufferPtr, getRegister(addressMode)); + moreTextOptional(buffer, &bufferPtr, "]"); + break; + case POSTINCREMENT_OPND: + moreTextOptional(buffer, &bufferPtr, "[a"); + expandNum(buffer, &bufferPtr, getRegister(addressMode)); + moreTextOptional(buffer, &bufferPtr, "]+"); + break; + case PREDECREMENT_OPND: + moreTextOptional(buffer, &bufferPtr, "-[a"); + expandNum(buffer, &bufferPtr, getRegister(addressMode)); + moreTextOptional(buffer, &bufferPtr, "]"); + break; + case IMMEDIATE_OPND: + moreTextOptional(buffer, &bufferPtr, "#"); + break; + case CC_REGISTER_OPND: + moreTextOptional(buffer, &bufferPtr, "ccr"); + break; + case STATUS_REGISTER_OPND: + moreTextOptional(buffer, &bufferPtr, "sr"); + break; + case USP_REGISTER_OPND: + moreTextOptional(buffer, &bufferPtr, "usp"); + break; + case CONTROL_REGISTER_OPND: + if (getRegister(addressMode) == 1) + moreTextOptional(buffer, &bufferPtr, "sfc"); + else if (getRegister(addressMode) == 2) + moreTextOptional(buffer, &bufferPtr, "dfc"); + else + moreTextOptional(buffer, &bufferPtr, "vbr"); + break; + case SELECTED_OPND: + moreTextOptional(buffer, &bufferPtr, "a"); + expandNum(buffer, &bufferPtr, getRegister(addressMode)); + break; + case INDEX_SELECTED_OPND: + moreTextOptional(buffer, &bufferPtr, "a"); + expandNum(buffer, &bufferPtr, getRegister(addressMode)); + if (getIndexRegister(addressMode)<8) { + moreTextOptional(buffer, &bufferPtr, "[a"); + expandNum(buffer, &bufferPtr, + getIndexRegister(addressMode)); + } else { + moreTextOptional(buffer, &bufferPtr, "[d"); + expandNum(buffer, &bufferPtr, + getIndexRegister(addressMode)-8); + } + moreTextOptional(buffer, &bufferPtr, "]"); + break; + + default: + break; + } + expandExpression(buffer, &bufferPtr); + switch(operandKindField(addressMode)) { + case DISPLACEMENT_OPND: + moreTextOptional(buffer, &bufferPtr, "[a"); + expandNum(buffer, &bufferPtr, getRegister(addressMode)); + moreTextOptional(buffer, &bufferPtr, "]"); + break; + case INDEXED_OPND: + moreTextOptional(buffer, &bufferPtr, "[a"); + expandNum(buffer, &bufferPtr, getRegister(addressMode)); + moreTextOptional(buffer, &bufferPtr, ","); + if (getIndexRegister(addressMode)<8) { + moreTextOptional(buffer, &bufferPtr, "a"); + expandNum(buffer, &bufferPtr, + getIndexRegister(addressMode)); + } else { + moreTextOptional(buffer, &bufferPtr, "d"); + expandNum(buffer, &bufferPtr, + getIndexRegister(addressMode)-8); + } + moreTextOptional(buffer, &bufferPtr, "."); + if (getWL(addressMode)) + moreTextOptional(buffer, &bufferPtr, "l]"); + else + moreTextOptional(buffer, &bufferPtr, "w]"); + break; + case PC_DISPLACEMENT_OPND: + moreTextOptional(buffer, &bufferPtr, "[pc]"); + break; + case PC_INDEXED_OPND: + moreTextOptional(buffer, &bufferPtr, "[pc,"); + if (getIndexRegister(addressMode)<8) { + moreTextOptional(buffer, &bufferPtr, "a"); + expandNum(buffer, &bufferPtr, + getIndexRegister(addressMode)); + } else { + moreTextOptional(buffer, &bufferPtr, "d"); + expandNum(buffer, &bufferPtr, + getIndexRegister(addressMode)-8); + } + moreTextOptional(buffer, &bufferPtr, "."); + if (getWL(addressMode)) + moreTextOptional(buffer, &bufferPtr, "l]"); + else + moreTextOptional(buffer, &bufferPtr, "w]"); + break; + case ABSOLUTE_SHORT_OPND: + moreTextOptional(buffer, &bufferPtr, ".w"); + break; + case ABSOLUTE_LONG_OPND: + moreTextOptional(buffer, &bufferPtr, ".l"); + break; + default: + break; + } +} + +/* corresponds to routines in expressionSemantics.c */ + +#define nullEvaluate(thing) if (thing==NULL) return(NULL); +#define fail(err) if (!expressionFailed) {\ + error(err);\ + expressionFailed = TRUE;\ + } +#define fail1(err,arg) if (!expressionFailed) {\ + error(err,arg);\ + expressionFailed = TRUE;\ + } +#define fail2(err,arg1,arg2) if (!expressionFailed) {\ + error(err,arg1,arg2);\ + expressionFailed = TRUE;\ + } + +#define qfree2(a,b) if (freeFlag) { free(a); free(b); } + +#define expansionOff() {saveExpansion=expandMacros; expandMacros=FALSE;} +#define forceExpansion() {saveExpansion=expandMacros; expandMacros=TRUE;} +#define expansionOn() expandMacros=saveExpansion; + + valueType * +evaluateOperand(operand) + operandType *operand; +{ + valueType *result; + bool saveExpansion; + expressionType *expression; + + valueType *evaluateExpression(); + valueType *evaluateSelectionList(); + valueType *newValue(); + + nullEvaluate(operand); + if (operand->kindOfOperand != EXPRESSION_OPND) + newFixupAddressMode = operand->kindOfOperand; + switch (operandKindField(operand->kindOfOperand)) { + + case EXPRESSION_OPND: + case DISPLACEMENT_OPND: + case INDEXED_OPND: + case PC_DISPLACEMENT_OPND: + case PC_INDEXED_OPND: + case IMMEDIATE_OPND: + case ABSOLUTE_SHORT_OPND: + case ABSOLUTE_LONG_OPND: + result = evaluateExpression(operand->theOperand, + performingFixups ? NO_FIXUP : OPERAND_FIXUP); + if (operand->kindOfOperand != EXPRESSION_OPND) { + if (result->addressMode != EXPRESSION_OPND) { + error(BAD_ADDRESS_MODE_ERROR); + result->kindOfValue = FAIL; + } else { + result->addressMode = operand->kindOfOperand; + } + } + break; + + case SELECTED_OPND: + case INDEX_SELECTED_OPND: + result = evaluateSelectionList(operand->theOperand); + if (result->addressMode != EXPRESSION_OPND) { + error(BAD_ADDRESS_MODE_ERROR); + result->kindOfValue = FAIL; + } else { + result->addressMode = operand->kindOfOperand; + } + break; + + case D_REGISTER_OPND: + case A_REGISTER_OPND: + case A_REGISTER_INDIRECT_OPND: + case POSTINCREMENT_OPND: + case PREDECREMENT_OPND: + case CC_REGISTER_OPND: + case STATUS_REGISTER_OPND: + case USP_REGISTER_OPND: + case CONTROL_REGISTER_OPND: + result = newValue(ABSOLUTE_VALUE, 0, operand-> + kindOfOperand); + break; + + case STRING_OPND: + result = newValue(STRING_VALUE, operand->theOperand, + STRING_OPND); + break; + + case BLOCK_OPND: + if (standaloneExpansionFlag) + forceExpansion(); + assembleBlock(operand->theOperand); + expansionOn(); + result = newValue(FAIL, 0, BLOCK_OPND); + break; + + default: + botch("bad operand kind in evaluateOperand %d\n", + operand->kindOfOperand); + break; + } + return(result); +} + +/* from parserMisc.c */ + + conditionType +invertConditionCode(conditionCode) + conditionType conditionCode; +{ +#define cc (int)conditionCode + + if ((int)CARRY_COND<=cc && cc<=(int)ALWAYS_COND) + return((conditionType) + (cc - (int)CARRY_COND + (int)NOT_CARRY_COND)); + else if ((int)NOT_CARRY_COND<=cc && cc<=(int)NEVER_COND) + return((conditionType) + (cc + (int)CARRY_COND - (int)NOT_CARRY_COND)); + else + botch("invertConditionCode given %d, not a condition code\n"); +} + +/* from semanticMisc.c */ + + bool +shouldParenthesize(operand) + operandType *operand; +{ + expressionTermKindType kind; + + switch(operandKindField(operand->kindOfOperand)) { + case EXPRESSION_OPND: + case DISPLACEMENT_OPND: + case INDEXED_OPND: + case PC_DISPLACEMENT_OPND: + case PC_INDEXED_OPND: + case IMMEDIATE_OPND: + case ABSOLUTE_SHORT_OPND: + case ABSOLUTE_LONG_OPND: + kind = operand->theOperand.expressionUnion->kindOfTerm; + return (kind==UNOP_EXPR || kind==BINOP_EXPR || kind== + ASSIGN_EXPR); + break; + + case STRING_OPND: + case BLOCK_OPND: + case D_REGISTER_OPND: + case A_REGISTER_OPND: + case A_REGISTER_INDIRECT_OPND: + case POSTINCREMENT_OPND: + case PREDECREMENT_OPND: + case CC_REGISTER_OPND: + case STATUS_REGISTER_OPND: + case USP_REGISTER_OPND: + case CONTROL_REGISTER_OPND: + case SELECTED_OPND: + case INDEX_SELECTED_OPND: + return(FALSE); + break; + } +} diff --git a/opt/.mark b/opt/.mark new file mode 100644 index 0000000..56fe325 --- /dev/null +++ b/opt/.mark @@ -0,0 +1 @@ +Mon Feb 2 23:18:37 PST 1987 diff --git a/opt/Makefile b/opt/Makefile new file mode 100644 index 0000000..9784005 --- /dev/null +++ b/opt/Makefile @@ -0,0 +1,165 @@ +.SUFFIXES: .o .c .h .run + +# to make for another target CPU, redefine PROC to the name of the target +# processor, e.g., 68000 +PROC =6502 + +OBJECTS = y.tab.o actions.o buildStuff1.o buildStuff2.o\ +buildStuff3.o builtInFunctions.o builtInFunsSD.o debugPrint.o debugPrintSD.o\ +emitBranch.o emitStuff.o encode.o errorStuff.o expressionSemantics.o fixups.o\ +garbage.o initialize.o lexer.o listing.o lookups.o macrossTables.o main.o\ +malloc.o object.o operandStuffSD.o parserMisc.o semanticMisc.o\ +statementSemantics.o structSemantics.o tokenStrings.o + +SOURCES = macross_$(PROC).y actions_$(PROC).c buildStuff1.c buildStuff2.c\ +buildStuff3.c builtInFunctions.c builtInFunsSD_$(PROC).c debugPrint.c\ +debugPrintSD_$(PROC).c emitBranch_$(PROC).c emitStuff.c encode.c errorStuff.c\ +expressionSemantics.c fixups.c garbage.c initialize.c lexer.c listing.c\ +lookups.c macrossTables_$(PROC).c main.c malloc.c object.c\ +operandStuffSD_$(PROC).c parserMisc.c semanticMisc.c statementSemantics.c\ +structSemantics.c tokenStrings_$(PROC).c lexerTables.h macrossGlobals.h\ +macrossTypes.h operandDefs_$(PROC).h operandBody_$(PROC).h\ +conditionDefs_$(PROC).h driver.c + +HEADERS = macrossTypes.h macrossGlobals.h + +.c.o: + cc -c -O -DTARGET_CPU=CPU_$(PROC) $*.c + +.c.run: + cc -o $* $*.c + +macross: $(OBJECTS) + cc -O -o macross $(OBJECTS) + +driver: driver.c + cc -o driver driver.c + +update: .mark + kessel "(cd /u0/chip/macross; make macross >&errorfyle)" & + +install: macross + cp macross macross_tmp + strip macross_tmp + cp /u1/gg/bin/macross_$(PROC) /u1/gg/bin/macross_$(PROC).old + cp macross_tmp /u1/gg/bin/macross_$(PROC) + rm macross_tmp + cp /u1/gg/bin/macross_$(PROC) /net/mycroft/u1/gg/bin + cp /u1/gg/bin/macross_$(PROC) /net/shem/u1/gg/bin + cp /u1/gg/bin/macross_$(PROC) /net/weyr/u1/gg/bin + +dinstall: driver + cp driver /u1/gg/bin/driver_tmp + strip /u1/gg/bin/driver_tmp + mv /u1/gg/bin/driver_tmp /u1/gg/bin/driver/macross + cp /u1/gg/bin/driver /net/mycroft/u1/gg/bin/macross + cp /u1/gg/bin/driver /net/shem/u1/gg/bin/macross + cp /u1/gg/bin/driver /net/weyr/u1/gg/bin/macross + +change: + rm *.o + rm *.tab.* + cp Makefile_68000 Makefile + +move: .mark + +.mark: $(SOURCES) + cp $? /net/kessel/u0/chip/macross + cp $? /net/kessel/u0/chip/macross/prof + cp $? .. + date >.mark + date >/net/kessel/u0/chip/macross/.mark + date >/net/kessel/u0/chip/macross/prof/.mark + date >../.mark + +macrossTypes.h: macrossTypes.h operandDefs_$(PROC).h operandBody_$(PROC).h\ +conditionDefs_$(PROC).h + +actions.o: actions_$(PROC).c $(HEADERS) + cc -c -O -DTARGET_CPU=CPU_$(PROC) actions_$(PROC).c + mv actions_$(PROC).o actions.o + +buildStuff1.o: buildStuff1.c $(HEADERS) + +buildStuff2.o: buildStuff2.c $(HEADERS) + +buildStuff3.o: buildStuff3.c $(HEADERS) + +builtInFunctions.o: builtInFunctions.c $(HEADERS) + +builtInFunsSD.o: builtInFunsSD_$(PROC).c $(HEADERS) + cc -c -O -DTARGET_CPU=CPU_$(PROC) builtInFunsSD_$(PROC).c + mv builtInFunsSD_$(PROC).o builtInFunsSD.o + +debugPrint.o: debugPrint.c y.tab.h $(HEADERS) + +debugPrintSD.o: debugPrintSD_$(PROC).c y.tab.h $(HEADERS) + cc -c -O -DTARGET_CPU=CPU_$(PROC) debugPrintSD_$(PROC).c + mv debugPrintSD_$(PROC).o debugPrintSD.o + +emitBranch.o: emitBranch_$(PROC).c $(HEADERS) + cc -c -O -DTARGET_CPU=CPU_$(PROC) emitBranch_$(PROC).c + mv emitBranch_$(PROC).o emitBranch.o + +emitStuff.o: emitStuff.c $(HEADERS) + cc -c -O -DBYTESWAPPED -DTARGET_CPU=CPU_$(PROC) emitStuff.c + +encode.o: encode.c $(HEADERS) + +errorStuff.o: errorStuff.c $(HEADERS) + +expressionSemantics.o: expressionSemantics.c y.tab.h $(HEADERS) + +fixups.o: fixups.c $(HEADERS) + +garbage.o: garbage.c y.tab.h $(HEADERS) + +initialize.o: initialize.c $(HEADERS) + +lexer.o: lexer.c lexerTables.h y.tab.h $(HEADERS) + +listing.o: listing.c $(HEADERS) + +lookups.o: lookups.c $(HEADERS) + +macrossTables.o: macrossTables_$(PROC).c y.tab.h macrossTypes.h + cc -c -O -DTARGET_CPU=CPU_$(PROC) macrossTables_$(PROC).c + mv macrossTables_$(PROC).o macrossTables.o + +malloc.o: malloc.c + +main.o: main.c $(HEADERS) + +object.o: object.c $(HEADERS) + +operandStuffSD.o: operandStuffSD_$(PROC).c $(HEADERS) + cc -c -O -DTARGET_CPU=CPU_$(PROC) operandStuffSD_$(PROC).c + mv operandStuffSD_$(PROC).o operandStuffSD.o + +parserMisc.o: parserMisc.c y.tab.h $(HEADERS) + +semanticMisc.o: semanticMisc.c $(HEADERS) + +statementSemantics.o: statementSemantics.c $(HEADERS) + +structSemantics.o: structSemantics.c $(HEADERS) + +tokenStrings.o: tokenStrings_$(PROC).c $(HEADERS) + cc -c -O -DTARGET_CPU=CPU_$(PROC) tokenStrings_$(PROC).c + mv tokenStrings_$(PROC).o tokenStrings.o + +y.tab.o: y.tab.c $(HEADERS) + cc -c -O -DYYDEBUG -DTARGET_CPU=CPU_$(PROC) y.tab.c + +y.tab.c y.tab.h: macross_$(PROC).y + yacc -d macross_$(PROC).y + +y.output: macross_$(PROC).y + yacc -vd macross_$(PROC).y + +cleanup: + /bin/rm -f *.o y.output y.tab.c y.tab.h macross + +love: + @echo "Not war?" + diff --git a/opt/Makefile_6502 b/opt/Makefile_6502 new file mode 100644 index 0000000..abe4bee --- /dev/null +++ b/opt/Makefile_6502 @@ -0,0 +1,162 @@ +.SUFFIXES: .o .c .h .run + +# to make for another target CPU, redefine PROC to the name of the target +# processor, e.g., 68000 +PROC =6502 + +OBJECTS = y.tab.o actions.o buildStuff1.o buildStuff2.o\ +buildStuff3.o builtInFunctions.o builtInFunsSD.o debugPrint.o debugPrintSD.o\ +emitBranch.o emitStuff.o errorStuff.o expressionSemantics.o fixups.o\ +garbage.o initialize.o lexer.o listing.o lookups.o macrossTables.o main.o\ +malloc.o object.o operandStuffSD.o parserMisc.o semanticMisc.o\ +statementSemantics.o structSemantics.o tokenStrings.o + +SOURCES = macross_$(PROC).y actions_$(PROC).c buildStuff1.c buildStuff2.c\ +buildStuff3.c builtInFunctions.c builtInFunsSD_$(PROC).c debugPrint.c\ +debugPrintSD_$(PROC).c emitBranch_$(PROC).c emitStuff.c errorStuff.c\ +expressionSemantics.c fixups.c garbage.c initialize.c lexer.c listing.c\ +lookups.c macrossTables_$(PROC).c main.c malloc.c object.c\ +operandStuffSD_$(PROC).c parserMisc.c semanticMisc.c statementSemantics.c\ +structSemantics.c tokenStrings_$(PROC).c lexerTables.h macrossGlobals.h\ +macrossTypes.h operandDefs_$(PROC).h operandBody_$(PROC).h\ +conditionDefs_$(PROC).h driver.c + +HEADERS = macrossTypes.h macrossGlobals.h + +.c.o: + cc -O -c -DTARGET_CPU=CPU_$(PROC) $*.c + +.c.run: + cc -O -o $* $*.c + +macross: $(OBJECTS) + cc -O -o macross $(OBJECTS) + +driver: driver.c + cc -O -o driver driver.c + +update: .mark + kessel "(cd /u0/chip/macross; make macross >&errorfyle)" & + +install: macross + cp macross /u1/gg/bin/macross_tmp + strip /u1/gg/bin/macross_tmp + mv /u1/gg/bin/macross_$(PROC) /u1/gg/bin/macross_$(PROC).old + mv /u1/gg/bin/macross_tmp /u1/gg/bin/macross_$(PROC) + cp /u1/gg/bin/macross_$(PROC) /net/mycroft/u1/gg/bin + cp /u1/gg/bin/macross_$(PROC) /net/shem/u1/gg/bin + cp /u1/gg/bin/macross_$(PROC) /net/weyr/u1/gg/bin + +dinstall: driver + cp driver /u1/gg/bin/driver_tmp + strip /u1/gg/bin/driver_tmp + mv /u1/gg/bin/driver_tmp /u1/gg/bin/macross + cp /u1/gg/bin/macross /net/mycroft/u1/gg/bin/macross + cp /u1/gg/bin/macross /net/shem/u1/gg/bin/macross + cp /u1/gg/bin/macross /net/weyr/u1/gg/bin/macross + +change: + rm *.o + rm *.tab.* + cp Makefile_68000 Makefile + +move: .mark + +.mark: $(SOURCES) + cp $? /net/kessel/u0/chip/macross + cp $? /net/kessel/u0/chip/macross/prof + cp $? .. + date >.mark + date >/net/kessel/u0/chip/macross/.mark + date >/net/kessel/u0/chip/macross/prof/.mark + date >../.mark + +macrossTypes.h: macrossTypes.h operandDefs_$(PROC).h operandBody_$(PROC).h\ +conditionDefs_$(PROC).h + +actions.o: actions_$(PROC).c $(HEADERS) + cc -O -c -DTARGET_CPU=CPU_$(PROC) actions_$(PROC).c + mv actions_$(PROC).o actions.o + +buildStuff1.o: buildStuff1.c $(HEADERS) + +buildStuff2.o: buildStuff2.c $(HEADERS) + +buildStuff3.o: buildStuff3.c $(HEADERS) + +builtInFunctions.o: builtInFunctions.c $(HEADERS) + +builtInFunsSD.o: builtInFunsSD_$(PROC).c $(HEADERS) + cc -O -c -DTARGET_CPU=CPU_$(PROC) builtInFunsSD_$(PROC).c + mv builtInFunsSD_$(PROC).o builtInFunsSD.o + +debugPrint.o: debugPrint.c y.tab.h $(HEADERS) + +debugPrintSD.o: debugPrintSD_$(PROC).c y.tab.h $(HEADERS) + cc -O -c -DTARGET_CPU=CPU_$(PROC) debugPrintSD_$(PROC).c + mv debugPrintSD_$(PROC).o debugPrintSD.o + +emitBranch.o: emitBranch_$(PROC).c $(HEADERS) + cc -O -c -DTARGET_CPU=CPU_$(PROC) emitBranch_$(PROC).c + mv emitBranch_$(PROC).o emitBranch.o + +emitStuff.o: emitStuff.c $(HEADERS) + cc -O -c -DBYTESWAPPED -DTARGET_CPU=CPU_$(PROC) emitStuff.c + +errorStuff.o: errorStuff.c $(HEADERS) + +expressionSemantics.o: expressionSemantics.c y.tab.h $(HEADERS) + +fixups.o: fixups.c $(HEADERS) + +garbage.o: garbage.c y.tab.h $(HEADERS) + +initialize.o: initialize.c $(HEADERS) + +lexer.o: lexer.c lexerTables.h y.tab.h $(HEADERS) + +listing.o: listing.c $(HEADERS) + +lookups.o: lookups.c $(HEADERS) + +macrossTables.o: macrossTables_$(PROC).c y.tab.h macrossTypes.h + cc -O -c -DTARGET_CPU=CPU_$(PROC) macrossTables_$(PROC).c + mv macrossTables_$(PROC).o macrossTables.o + +malloc.o: malloc.c + +main.o: main.c $(HEADERS) + +object.o: object.c $(HEADERS) + +operandStuffSD.o: operandStuffSD_$(PROC).c $(HEADERS) + cc -O -c -DTARGET_CPU=CPU_$(PROC) operandStuffSD_$(PROC).c + mv operandStuffSD_$(PROC).o operandStuffSD.o + +parserMisc.o: parserMisc.c y.tab.h $(HEADERS) + +semanticMisc.o: semanticMisc.c $(HEADERS) + +statementSemantics.o: statementSemantics.c $(HEADERS) + +structSemantics.o: structSemantics.c $(HEADERS) + +tokenStrings.o: tokenStrings_$(PROC).c $(HEADERS) + cc -O -c -DTARGET_CPU=CPU_$(PROC) tokenStrings_$(PROC).c + mv tokenStrings_$(PROC).o tokenStrings.o + +y.tab.o: y.tab.c $(HEADERS) + cc -O -c -DYYDEBUG -DTARGET_CPU=CPU_$(PROC) y.tab.c + +y.tab.c y.tab.h: macross_$(PROC).y + yacc -d macross_$(PROC).y + +y.output: macross_$(PROC).y + yacc -vd macross_$(PROC).y + +cleanup: + /bin/rm -f *.o y.output y.tab.c y.tab.h macross + +love: + @echo "Not war?" + diff --git a/opt/Makefile_68000 b/opt/Makefile_68000 new file mode 100644 index 0000000..5015fb6 --- /dev/null +++ b/opt/Makefile_68000 @@ -0,0 +1,162 @@ +.SUFFIXES: .o .c .h .run + +# to make for another target CPU, redefine PROC to the name of the target +# processor, e.g., 68000 +PROC =68000 + +OBJECTS = y.tab.o actions.o buildStuff1.o buildStuff2.o\ +buildStuff3.o builtInFunctions.o builtInFunsSD.o debugPrint.o debugPrintSD.o\ +emitBranch.o emitStuff.o errorStuff.o expressionSemantics.o fixups.o\ +garbage.o initialize.o lexer.o listing.o lookups.o macrossTables.o main.o\ +malloc.o object.o operandStuffSD.o parserMisc.o semanticMisc.o\ +statementSemantics.o structSemantics.o tokenStrings.o + +SOURCES = macross_$(PROC).y actions_$(PROC).c buildStuff1.c buildStuff2.c\ +buildStuff3.c builtInFunctions.c builtInFunsSD_$(PROC).c debugPrint.c\ +debugPrintSD_$(PROC).c emitBranch_$(PROC).c emitStuff.c errorStuff.c\ +expressionSemantics.c fixups.c garbage.c initialize.c lexer.c listing.c\ +lookups.c macrossTables_$(PROC).c main.c malloc.c object.c\ +operandStuffSD_$(PROC).c parserMisc.c semanticMisc.c statementSemantics.c\ +structSemantics.c tokenStrings_$(PROC).c lexerTables.h macrossGlobals.h\ +macrossTypes.h operandDefs_$(PROC).h operandBody_$(PROC).h\ +conditionDefs_$(PROC).h driver.c + +HEADERS = macrossTypes.h macrossGlobals.h + +.c.o: + cc -O -c -DTARGET_CPU=CPU_$(PROC) $*.c + +.c.run: + cc -O -o $* $*.c + +macross: $(OBJECTS) + cc -O -o macross $(OBJECTS) + +driver: driver.c + cc -O -o driver driver.c + +update: .mark + kessel "(cd /u0/chip/macross; make macross >&errorfyle)" & + +install: macross + cp macross /u1/gg/bin/macross_tmp + strip /u1/gg/bin/macross_tmp + mv /u1/gg/bin/macross_$(PROC) /u1/gg/bin/macross_$(PROC).old + mv /u1/gg/bin/macross_tmp /u1/gg/bin/macross_$(PROC) + cp /u1/gg/bin/macross_$(PROC) /net/mycroft/u1/gg/bin + cp /u1/gg/bin/macross_$(PROC) /net/shem/u1/gg/bin + cp /u1/gg/bin/macross_$(PROC) /net/weyr/u1/gg/bin + +dinstall: driver + cp driver /u1/gg/bin/driver_tmp + strip /u1/gg/bin/driver_tmp + mv /u1/gg/bin/driver_tmp /u1/gg/bin/macross + cp /u1/gg/bin/macross /net/mycroft/u1/gg/bin/macross + cp /u1/gg/bin/macross /net/shem/u1/gg/bin/macross + cp /u1/gg/bin/macross /net/weyr/u1/gg/bin/macross + +change: + rm *.o + rm *.tab.* + cp Makefile_6502 Makefile + +move: .mark + +.mark: $(SOURCES) + cp $? /net/kessel/u0/chip/macross + cp $? /net/kessel/u0/chip/macross/prof + cp $? .. + date >.mark + date >/net/kessel/u0/chip/macross/.mark + date >/net/kessel/u0/chip/macross/prof/.mark + date >../.mark + +macrossTypes.h: macrossTypes.h operandDefs_$(PROC).h operandBody_$(PROC).h\ +conditionDefs_$(PROC).h + +actions.o: actions_$(PROC).c $(HEADERS) + cc -O -c -DTARGET_CPU=CPU_$(PROC) actions_$(PROC).c + mv actions_$(PROC).o actions.o + +buildStuff1.o: buildStuff1.c $(HEADERS) + +buildStuff2.o: buildStuff2.c $(HEADERS) + +buildStuff3.o: buildStuff3.c $(HEADERS) + +builtInFunctions.o: builtInFunctions.c $(HEADERS) + +builtInFunsSD.o: builtInFunsSD_$(PROC).c $(HEADERS) + cc -O -c -DTARGET_CPU=CPU_$(PROC) builtInFunsSD_$(PROC).c + mv builtInFunsSD_$(PROC).o builtInFunsSD.o + +debugPrint.o: debugPrint.c y.tab.h $(HEADERS) + +debugPrintSD.o: debugPrintSD_$(PROC).c y.tab.h $(HEADERS) + cc -O -c -DTARGET_CPU=CPU_$(PROC) debugPrintSD_$(PROC).c + mv debugPrintSD_$(PROC).o debugPrintSD.o + +emitBranch.o: emitBranch_$(PROC).c $(HEADERS) + cc -O -c -DTARGET_CPU=CPU_$(PROC) emitBranch_$(PROC).c + mv emitBranch_$(PROC).o emitBranch.o + +emitStuff.o: emitStuff.c $(HEADERS) + cc -O -c -DBYTESWAPPED -DTARGET_CPU=CPU_$(PROC) emitStuff.c + +errorStuff.o: errorStuff.c $(HEADERS) + +expressionSemantics.o: expressionSemantics.c y.tab.h $(HEADERS) + +fixups.o: fixups.c $(HEADERS) + +garbage.o: garbage.c y.tab.h $(HEADERS) + +initialize.o: initialize.c $(HEADERS) + +lexer.o: lexer.c lexerTables.h y.tab.h $(HEADERS) + +listing.o: listing.c $(HEADERS) + +lookups.o: lookups.c $(HEADERS) + +macrossTables.o: macrossTables_$(PROC).c y.tab.h macrossTypes.h + cc -O -c -DTARGET_CPU=CPU_$(PROC) macrossTables_$(PROC).c + mv macrossTables_$(PROC).o macrossTables.o + +malloc.o: malloc.c + +main.o: main.c $(HEADERS) + +object.o: object.c $(HEADERS) + +operandStuffSD.o: operandStuffSD_$(PROC).c $(HEADERS) + cc -O -c -DTARGET_CPU=CPU_$(PROC) operandStuffSD_$(PROC).c + mv operandStuffSD_$(PROC).o operandStuffSD.o + +parserMisc.o: parserMisc.c y.tab.h $(HEADERS) + +semanticMisc.o: semanticMisc.c $(HEADERS) + +statementSemantics.o: statementSemantics.c $(HEADERS) + +structSemantics.o: structSemantics.c $(HEADERS) + +tokenStrings.o: tokenStrings_$(PROC).c $(HEADERS) + cc -O -c -DTARGET_CPU=CPU_$(PROC) tokenStrings_$(PROC).c + mv tokenStrings_$(PROC).o tokenStrings.o + +y.tab.o: y.tab.c $(HEADERS) + cc -O -c -DYYDEBUG -DTARGET_CPU=CPU_$(PROC) y.tab.c + +y.tab.c y.tab.h: macross_$(PROC).y + yacc -d macross_$(PROC).y + +y.output: macross_$(PROC).y + yacc -vd macross_$(PROC).y + +cleanup: + /bin/rm -f *.o y.output y.tab.c y.tab.h macross + +love: + @echo "Not war?" + diff --git a/parserMisc.c b/parserMisc.c new file mode 100644 index 0000000..0617fcb --- /dev/null +++ b/parserMisc.c @@ -0,0 +1,128 @@ +/* + parserMisc.c -- Miscellaneous parser support routines for the Macross + assembler. + + Chip Morningstar -- Lucasfilm Ltd. + + 3-November-1984 + +*/ + +#include "macrossTypes.h" +#include "macrossGlobals.h" +#include "y.tab.h" + + statementType * +addLabelToStatement(labelList, statement) + labelListType *labelList; + statementType *statement; +{ + statementType *newStatement(); + + if (statement == NULL) + statement = newStatement(NULL_STATEMENT, NULL); + statement->labels = labelList; + return(statement); +} + + void +botch(message, arg1, arg2, arg3) + char *message; + anyOldThing *arg1; + anyOldThing *arg2; + anyOldThing *arg3; +{ + printf("Macross horrible terrible internal botch: "); + printf(message, arg1, arg2, arg3); + chokePukeAndDie(); +} + + void +checkDefineAssignmentOperator(assignmentOperator) + assignmentKindType assignmentOperator; +{ + if (assignmentOperator != ASSIGN_ASSIGN) + puntOnError(DEFINE_ASSIGNMENT_WRONG_ERROR); +} + + statementType * +convertDefineToMdefine(defineStatement) + statementType *defineStatement; +{ + if (defineStatement->kindOfStatement != DEFINE_STATEMENT) + botch("convertDefineToMdefine got statement kind: %d\n", + defineStatement->kindOfStatement); + defineStatement->kindOfStatement = MDEFINE_STATEMENT; + return(defineStatement); +} + + ifStatementBodyType * +extractIfBody(ifStatement) + statementType *ifStatement; +{ + ifStatementBodyType *result; + + result = ifStatement->statementBody.ifUnion; + if (ifStatement->labels != NULL) + botch("extract if body with non-null labels\n"); + else if (ifStatement->nextStatement != NULL) + botch("extract if body with non-null next\n"); + else + qfree(ifStatement); + return(result); +} + + mifStatementBodyType * +extractMifBody(mifStatement) + statementType *mifStatement; +{ + mifStatementBodyType *result; + + result = mifStatement->statementBody.mifUnion; + if (mifStatement->labels != NULL) + botch("extract mif body with non-null labels\n"); + else if (mifStatement->nextStatement != NULL) + botch("extract mif body with non-null next\n"); + else + qfree(mifStatement); + return(result); +} + + stringType * +extractString(textExpression) + operandType *textExpression; +{ + stringType *result; + + if (textExpression->kindOfOperand != STRING_OPND) + botch("extract string got handed an opnd kind: %d\n", + textExpression->kindOfOperand); + result = textExpression->theOperand.stringUnion; + qfree(textExpression); + return(result); +} + + void +popMacroOrFunctionNestingDepth() +{ + if (--macroOrFunctionNestingDepth == 0) + unknownSymbolTag = UNKNOWN_SYMBOL; +} + + void +pushMacroOrFunctionNestingDepth() +{ + macroOrFunctionNestingDepth++; + unknownSymbolTag = NESTED_UNKNOWN_SYMBOL; +} + + char * +saveString(s) + char *s; +{ + char *result; + + result = (char *)malloc(strlen(s)+1); + strcpy(result, s); + return(result); +} diff --git a/parserMisc.o b/parserMisc.o new file mode 100644 index 0000000000000000000000000000000000000000..b5261f22adf4bbe51d71cc67f1cf82e686f5630d GIT binary patch literal 37000 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 Yrnt&i_c%HlfFojbjMykkRT-cDFTwt|rvLx| literal 0 HcmV?d00001 diff --git a/semanticMisc.c b/semanticMisc.c new file mode 100644 index 0000000..78ca693 --- /dev/null +++ b/semanticMisc.c @@ -0,0 +1,1337 @@ +/* + semanticMisc.c -- Miscellaneous helper routines for the semantic + portions of the Macross assembler. + + Chip Morningstar -- Lucasfilm Ltd. + + 12-November-1984 +*/ + +#include "macrossTypes.h" +#include "macrossGlobals.h" +#include "y.tab.h" + +#define expansionOff() {saveExpansion=expandMacros; expandMacros=FALSE;} +#define expansionOn() expandMacros=saveExpansion; + +/* + These are miscellaneous routines called by the primary semantics routines. + */ + + bool +absoluteValue(address) + valueType *address; +{ + return(address->kindOfValue == ABSOLUTE_VALUE); +} + + void +addAttributeToSymbol(symbol, attribute) + symbolTableEntryType *symbol; + symbolAttributesType attribute; +{ + symbolInContextType *context; + + symbolInContextType *getBaseContext(); + + context = getBaseContext(symbol); + if (context != NULL) + context->attributes |= attribute; +} + + addressType +addressValue(value) + valueType *value; +{ + if (value->kindOfValue==STRING_VALUE || + value->kindOfValue==CONDITION_VALUE || + value->kindOfValue==FAIL) + error(VALUE_IS_NOT_AN_ADDRESS_ERROR); + else + return(value->value); +} + + valueKindType +addValueKind(leftOperand, rightOperand) + valueType *leftOperand; + valueType *rightOperand; +{ +/* This table MUST be maintained congruently with the definition of the + enumerated type 'valueKindType'. */ + static valueKindType addValueKindTable[NUM_OF_VALUE_KINDS] + [NUM_OF_VALUE_KINDS] = { +/* ABSOLUTE_VALUE , DATA_VALUE , RELOCATABLE_VALUE , + BSS_VALUE , STRUCT_VALUE , FIELD_VALUE , + MACRO_VALUE , OPERAND_VALUE , STRING_VALUE , + CONDITION_VALUE, UNDEFINED_VALUE, FUNCTION_VALUE , + BLOCK_VALUE , BUILT_IN_FUNCTI, ARRAY_VALUE , + FAIL ,*/ + +/*ABSOLUTE_VALUE */ ABSOLUTE_VALUE , DATA_VALUE , RELOCATABLE_VALUE , + BSS_VALUE , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , UNDEFINED_VALUE, FAIL , + FAIL , FAIL , FAIL , + FAIL, + +/*DATA_VALUE */ DATA_VALUE , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , UNDEFINED_VALUE, FAIL , + FAIL , FAIL , FAIL , + FAIL, + +/*RELOCATABLE_VAL*/ RELOCATABLE_VALUE, FAIL , UNDEFINED_VALUE, + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , UNDEFINED_VALUE, FAIL , + FAIL , FAIL , FAIL , + FAIL, + +/*BSS_VALUE */ BSS_VALUE , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , UNDEFINED_VALUE, FAIL , + FAIL , FAIL , FAIL , + FAIL, + +/*STRUCT_VALUE */ FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL, + +/*FIELD_VALUE */ FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL, + +/*MACRO_VALUE */ FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL, + +/*OPERAND_VALUE */ FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL, + +/*STRING_VALUE */ FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , STRING_VALUE , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL, + +/*CONDITION_VALUE*/ FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL, + +/*UNDEFINED_VALUE*/ UNDEFINED_VALUE, UNDEFINED_VALUE, UNDEFINED_VALUE, + UNDEFINED_VALUE, FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , UNDEFINED_VALUE, FAIL , + FAIL , FAIL , FAIL , + FAIL, + +/*FUNCTION_VALUE */ FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL, + +/*BLOCK_VALUE */ FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL, + +/*BUILT_IN_FUNCT-*/ FAIL , FAIL , FAIL , +/*-ION_VALUE */ FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL, + +/*ARRAY_VALUE */ FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL, + +/*FAIL */ FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL, + }; + + return(addValueKindTable[(int)leftOperand->kindOfValue] + [(int)rightOperand->kindOfValue]); +} + + bool +alreadyDefined(context) + symbolInContextType *context; +{ + return((context->attributes & DEFINED_VARIABLE_ATT) != 0); +} + + bool +booleanTest(expression) + expressionType *expression; +{ + bool result; + valueType *expressionResult; + bool saveExpansion; + valueType *evaluateExpression(); + + expansionOff(); + expressionResult = evaluateExpression(expression, NO_FIXUP); + expansionOn(); + if (expressionResult == NULL) { + return(FALSE); + } else if (expressionResult->kindOfValue != ABSOLUTE_VALUE) { + error(INVALID_BOOLEAN_VALUE_ERROR, + valueKindString(expressionResult->kindOfValue)); + result = FALSE; + } else { + result = (expressionResult->value != 0); + } + qfree(expressionResult); + return(result); +} + + int +countArguments(function) + functionDefinitionType *function; +{ + int result; + argumentDefinitionListType *arguments; + + arguments = function->arguments; + result = 0; + while (arguments != NULL) { + result++; + arguments = arguments->nextArgument; + } + return(result); +} + + int +countParameters(parameterList) + operandListType *parameterList; +{ + int result; + + result = 0; + while (parameterList != NULL) { + result++; + parameterList = parameterList->nextOperand; + } + return(result); +} + + arrayType * +allocArray(size, contentsPtr) + int size; + valueType ***contentsPtr; +{ + arrayType *result; + int i; + + result = typeAlloc(arrayType); + result->arraySize = size; + result->arrayContents = *contentsPtr = (valueType **) malloc(size * + sizeof(valueType *)); + for (i=0; ikindOfValue != ABSOLUTE_VALUE) { + return(newValue(FAIL, 0, EXPRESSION_OPND)); + } else { + arraySize = arraySizeValue->value; + } + } + result = allocArray(arraySize, &arrayContents); + if (initCount > arraySize) { + error(TOO_MANY_VARIABLE_INITIALIZERS_ERROR); + initCount = arraySize; + } + for (i=0; i + theExpression, NO_FIXUP); + initializers = initializers->nextExpression; + } + return(newValue(ARRAY_VALUE, result, EXPRESSION_OPND)); +} + + bool +decrementable(value) + valueType *value; +{ +/* This table MUST be maintained congruently with the definition of the + enumerated type 'valueKindType'. */ + static bool decrementableTable[NUM_OF_VALUE_KINDS] = { + /* ABSOLUTE_VALUE */ TRUE, + /* DATA_VALUE */ TRUE, + /* RELOCATABLE_VALUE */ TRUE, + /* BSS_VALUE */ TRUE, + /* STRUCT_VALUE */ FALSE, + /* FIELD_VALUE */ FALSE, + /* MACRO_VALUE */ FALSE, + /* OPERAND_VALUE */ FALSE, + /* STRING_VALUE */ FALSE, + /* CONDITION_VALUE */ FALSE, + /* UNDEFINED_VALUE */ TRUE, + /* FUNCTION_VALUE */ FALSE, + /* BLOCK_VALUE */ FALSE, + /* BUILT_IN_FUNCTION_VALUE */ FALSE, + /* ARRAY_VALUE */ FALSE, + /* FAIL */ FALSE, + }; + + if (value == NULL) + return(FALSE); + else + return(decrementableTable[(int)value->kindOfValue]); +} + + int +expressionListLength(expressionList) + expressionListType *expressionList; +{ + int result; + + result = 0; + while (expressionList != NULL) { + result++; + expressionList = expressionList->nextExpression; + } + return(result); +} + + int +fieldValue(symbol) + symbolTableEntryType *symbol; +{ + valueType *value; + valueType *evaluateIdentifier(); + + value = evaluateIdentifier(symbol, FALSE, NO_FIXUP); + if (value->kindOfValue != FIELD_VALUE) { + error(VALUE_IS_NOT_A_FIELD_ERROR, symbName(symbol)); + return(0); + } else { + return(value->value); + } +} + + bool +incrementable(value) + valueType *value; +{ +/* This table MUST be maintained congruently with the definition of the + enumerated type 'valueKindType'. */ + static bool incrementableTable[NUM_OF_VALUE_KINDS] = { + /* ABSOLUTE_VALUE */ TRUE, + /* DATA_VALUE */ TRUE, + /* RELOCATABLE_VALUE */ TRUE, + /* BSS_VALUE */ TRUE, + /* STRUCT_VALUE */ FALSE, + /* FIELD_VALUE */ FALSE, + /* MACRO_VALUE */ FALSE, + /* OPERAND_VALUE */ FALSE, + /* STRING_VALUE */ FALSE, + /* CONDITION_VALUE */ FALSE, + /* UNDEFINED_VALUE */ TRUE, + /* FUNCTION_VALUE */ FALSE, + /* BLOCK_VALUE */ FALSE, + /* BUILT_IN_FUNCTION_VALUE */ FALSE, + /* ARRAY_VALUE */ FALSE, + /* FAIL */ FALSE, + }; + + if (value == NULL) + return(FALSE); + else + return(incrementableTable[(int)value->kindOfValue]); +} + + int +intValue(value) + valueType *value; +{ + if (value->kindOfValue != ABSOLUTE_VALUE) { + error(VALUE_IS_NOT_AN_INT_ERROR); + return(0); + } else { + return(value->value); + } +} + + bool +isAssignable(context) + symbolInContextType *context; +{ + return( context->usage==ARGUMENT_SYMBOL || + context->usage==VARIABLE_SYMBOL || + context->usage==MVARIABLE_SYMBOL ); +} + + bool +isBuiltInFunction(context) + symbolInContextType *context; +{ + return(context!=NULL && context->usage==BUILT_IN_FUNCTION_SYMBOL); +} + + bool +isDefinable(context) + symbolInContextType *context; +{ + return( context->usage==DEFINE_SYMBOL || + context->usage==DEAD_SYMBOL || + context->usage==UNKNOWN_SYMBOL || + context->usage==NESTED_UNKNOWN_SYMBOL ); +} + + bool +isExternal(symbol) + symbolTableEntryType *symbol; +{ + symbolInContextType *context; + + symbolInContextType *getBaseContext(); + + context = getBaseContext(symbol); + return (context!=NULL && (context->attributes & GLOBAL_ATT)!=0 && + context->usage != DEAD_SYMBOL); +} + + bool +isFailure(value) + valueType *value; +{ + if (value == NULL) + return(FALSE); + else + return(value->kindOfValue == FAIL); +} + + bool +isFunction(context) + symbolInContextType *context; +{ + return(context!=NULL && context->usage==FUNCTION_SYMBOL); +} + + bool +isLastStatementInBlock(statement) + statementType *statement; +{ + statement = statement->nextStatement; + while (statement != NULL) { + if (statement->kindOfStatement != BLOCK_STATEMENT && + statement->kindOfStatement != BYTE_STATEMENT && + statement->kindOfStatement != CONSTRAIN_STATEMENT && + statement->kindOfStatement != DBYTE_STATEMENT && + statement->kindOfStatement != DO_UNTIL_STATEMENT && + statement->kindOfStatement != DO_WHILE_STATEMENT && + statement->kindOfStatement != GROUP_STATEMENT && + statement->kindOfStatement != IF_STATEMENT && + statement->kindOfStatement != INCLUDE_STATEMENT && + statement->kindOfStatement != INSTRUCTION_STATEMENT && + statement->kindOfStatement != LONG_STATEMENT && + statement->kindOfStatement != STRING_STATEMENT && + statement->kindOfStatement != STRUCT_STATEMENT && + statement->kindOfStatement != WHILE_STATEMENT && + statement->kindOfStatement != MIF_STATEMENT && + statement->kindOfStatement != MWHILE_STATEMENT && + statement->kindOfStatement != MFOR_STATEMENT && + statement->kindOfStatement != MDO_WHILE_STATEMENT && + statement->kindOfStatement != MDO_UNTIL_STATEMENT && + statement->kindOfStatement != MSWITCH_STATEMENT && + statement->kindOfStatement != WORD_STATEMENT) + statement = statement->nextStatement; + else + return(FALSE); + } + return(TRUE); +} + + bool +isLogicalOp(op) + int op; +{ + return (op==EQUAL_TO || op==GREATER_THAN || op== + GREATER_THAN_OR_EQUAL_TO || op==LESS_THAN || op== + LESS_THAN_OR_EQUAL_TO || op==NOT_EQUAL_TO || op== + LOGICAL_AND || op==LOGICAL_OR || op==LOGICAL_XOR); +} + + bool +isPotentialVariable(context) + symbolInContextType *context; +{ + return( context->usage == VARIABLE_SYMBOL || + context->usage == DEAD_SYMBOL || + context->usage == NESTED_UNKNOWN_SYMBOL ); +} + + bool +isUndefined(value) + valueType *value; +{ + return(value==NULL || value->kindOfValue==UNDEFINED_VALUE); +} + + bool +isUsable(value) + valueType *value; +{ + return(value!=NULL && value->kindOfValue!=UNDEFINED_VALUE && + value->kindOfValue!=FAIL); +} + + bool +logicalXOR(int1, int2) + int int1; + int int2; +{ + return((int1 && !int2) || (int2 && !int1)); +} + + valueType * +newValue(kindOfValue, value, addressMode) + valueKindType kindOfValue; + int value; + operandKindType addressMode; +{ + valueType *result; + + result = typeAlloc(valueType); + result->kindOfValue = kindOfValue; + result->value = value; + result->addressMode = addressMode; + return(result); +} + + valueKindType +opValueKind(leftOperand, rightOperand) + valueType *leftOperand; + valueType *rightOperand; +{ + if (leftOperand->kindOfValue==ABSOLUTE_VALUE && rightOperand-> + kindOfValue==ABSOLUTE_VALUE) + return(ABSOLUTE_VALUE); + else if ((leftOperand->kindOfValue==ABSOLUTE_VALUE && rightOperand-> + kindOfValue==UNDEFINED_VALUE) || + (leftOperand->kindOfValue==UNDEFINED_VALUE && rightOperand-> + kindOfValue==ABSOLUTE_VALUE) || + (leftOperand->kindOfValue==RELOCATABLE_VALUE &&rightOperand-> + kindOfValue==UNDEFINED_VALUE) || + (leftOperand->kindOfValue==UNDEFINED_VALUE && rightOperand-> + kindOfValue==RELOCATABLE_VALUE) || + (leftOperand->kindOfValue==RELOCATABLE_VALUE &&rightOperand-> + kindOfValue==ABSOLUTE_VALUE) || + (leftOperand->kindOfValue==ABSOLUTE_VALUE && rightOperand-> + kindOfValue==RELOCATABLE_VALUE) || + (leftOperand->kindOfValue==RELOCATABLE_VALUE &&rightOperand-> + kindOfValue==RELOCATABLE_VALUE) || + (leftOperand->kindOfValue==UNDEFINED_VALUE && rightOperand-> + kindOfValue==UNDEFINED_VALUE)) + return(UNDEFINED_VALUE); + else + return(FAIL); +} + + bool +relocatableValue(address) + valueType *address; +{ + return( address->kindOfValue==DATA_VALUE || + address->kindOfValue==RELOCATABLE_VALUE ); +} + + valueKindType +selectValueKind(leftOperand, rightOperand) + valueType *leftOperand; + valueType *rightOperand; +{ + if (rightOperand->kindOfValue!=FIELD_VALUE || + (leftOperand->kindOfValue!=ABSOLUTE_VALUE && + leftOperand->kindOfValue!=RELOCATABLE_VALUE && + leftOperand->kindOfValue!=DATA_VALUE)) + return(FAIL); + else + return(leftOperand->kindOfValue); +} + + valueKindType +subValueKind(leftOperand, rightOperand) + valueType *leftOperand; + valueType *rightOperand; +{ +/* This table MUST be maintained congruently with the definition of the + enumerated type 'valueKindType'. */ + static valueKindType subValueKindTable[NUM_OF_VALUE_KINDS] + [NUM_OF_VALUE_KINDS] = { +/* ABSOLUTE_VALUE , DATA_VALUE , RELOCATABLE_VALUE , + BSS_VALUE , STRUCT_VALUE , FIELD_VALUE , + MACRO_VALUE , OPERAND_VALUE , STRING_VALUE , + CONDITION_VALUE, UNDEFINED_VALUE, FUNCTION_VALUE , + BLOCK_VALUE , BUILT_IN_FUNCTI, ARRAY_VALUE , + FAIL , */ + +/*ABSOLUTE_VALUE */ ABSOLUTE_VALUE , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL, + +/*DATA_VALUE */ DATA_VALUE , ABSOLUTE_VALUE , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL, + +/*RELOCATABLE_VAL*/ RELOCATABLE_VALUE, FAIL , UNDEFINED_VALUE, + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL, + +/*BSS_VALUE */ BSS_VALUE , FAIL , FAIL , + BSS_VALUE , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL, + +/*STRUCT_VALUE */ FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL, + +/*FIELD_VALUE */ FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL, + +/*MACRO_VALUE */ FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL, + +/*OPERAND_VALUE */ FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL, + +/*STRING_VALUE */ FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL, + +/*CONDITION_VALUE*/ FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL, + +/*UNDEFINED_VALUE*/ UNDEFINED_VALUE, FAIL , UNDEFINED_VALUE, + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , UNDEFINED_VALUE, FAIL , + FAIL , FAIL , FAIL , + FAIL, + +/*FUNCTION_VALUE */ FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL, + +/*BLOCK_VALUE */ FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL, + +/*BUILT_IN_FUNCT-*/ FAIL , FAIL , FAIL , +/*-ION_VALUE */ FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL, + +/*ARRAY_VALUE */ FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL, + +/*FAIL */ FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL , FAIL , FAIL , + FAIL, + }; + + return(subValueKindTable[(int)leftOperand->kindOfValue] + [(int)rightOperand->kindOfValue]); +} + + int +swab(i) + int i; +{ + return(((i & 0xFF) << 8) | ((i & 0xFF00) >> 8)); +} + + valueType * +swabValue(value) + valueType *value; +{ + valueType *newValue(); + + return(newValue(value->kindOfValue, swab(value->value), value-> + addressMode)); +} + + valueKindType +unopValueKind(operand) + valueType *operand; +{ + return(operand->kindOfValue==ABSOLUTE_VALUE || operand->kindOfValue== + UNDEFINED_VALUE || operand->kindOfValue==RELOCATABLE_VALUE ? + operand->kindOfValue : FAIL); +} + + void +valueField(symbol, value) + symbolTableEntryType *symbol; + valueType *value; +{ + symbolInContextType *workingContext; + + symbolInContextType *getWorkingContext(); + symbolTableEntryType *effectiveSymbol(); + + symbol = effectiveSymbol(symbol, &workingContext); + expand(moreLabel("%s:", symbol->symbolName)); + if (workingContext->usage == DEAD_SYMBOL) + reincarnateSymbol(workingContext, STRUCT_FIELD_SYMBOL); + if (workingContext->usage!=LABEL_SYMBOL && workingContext->usage!= + UNKNOWN_SYMBOL && workingContext->usage!= + NESTED_UNKNOWN_SYMBOL) + error(SYMBOL_ALREADY_THERE_ERROR, symbName(symbol)); + else if (workingContext->value==NULL || workingContext->value-> + kindOfValue==UNDEFINED_VALUE) { + workingContext->value = value; + workingContext->usage = STRUCT_FIELD_SYMBOL; + workingContext->environmentNumber = GLOBAL_ENVIRONMENT_NUMBER; + } else + error(FIELD_ALREADY_DEFINED_ERROR, symbName(symbol)); +} + + void +valueLabel(symbol, value) + symbolTableEntryType *symbol; + valueType *value; +{ + symbolInContextType *workingContext; + + symbolTableEntryType *generateLocalLabel(); + symbolInContextType *getBaseContext(); + symbolTableEntryType *effectiveSymbol(); + + symbol = effectiveSymbol(symbol, &workingContext); + expand(moreLabel("%s:", symbol->symbolName)); + if (workingContext->usage == DEAD_SYMBOL) + reincarnateSymbol(workingContext, LABEL_SYMBOL); + if (workingContext->usage!=LABEL_SYMBOL && workingContext->usage!= + UNKNOWN_SYMBOL && workingContext->usage!= + NESTED_UNKNOWN_SYMBOL) + error(SYMBOL_ALREADY_THERE_ERROR, symbName(symbol)); + else if (symbName(symbol)[0] == '$') { + symbol = generateLocalLabel(symbol); + workingContext = getBaseContext(symbol); + workingContext->value = value; + if (targetOffset != 0) { + workingContext->value->kindOfValue = ABSOLUTE_VALUE; + workingContext->value->value -= targetOffset; + } + workingContext->usage = LABEL_SYMBOL; + workingContext->environmentNumber = GLOBAL_ENVIRONMENT_NUMBER; + } else if (workingContext->value==NULL || workingContext->value-> + kindOfValue==UNDEFINED_VALUE) { + workingContext->value = value; + if (targetOffset != 0) { + workingContext->value->value -= targetOffset; + workingContext->value->kindOfValue = ABSOLUTE_VALUE; + } + workingContext->usage = LABEL_SYMBOL; + workingContext->environmentNumber = GLOBAL_ENVIRONMENT_NUMBER; + if (workingContext->attributes & TENTATIVE_GLOBAL_ATT) + workingContext->attributes |= GLOBAL_ATT; + } else + error(LABEL_ALREADY_DEFINED_ERROR, symbName(symbol)); + symbol->referenceCount++; +} + +/* + These routines deal with fixups and references. + */ + + void +createFixup(expression, location, kindOfFixup, codeMode, whichFixup) + expressionType *expression; + addressType location; + fixupKindType kindOfFixup; + codeBufferKindType codeMode; + int whichFixup; +{ + fixupListType *newFixup; + + expressionType *generateFixupExpression(); + + if (debug || emitPrint) + printCreateFixup(expression, location, kindOfFixup); + newFixup = typeAlloc(fixupListType); + newFixup->locationToFixup = location; + newFixup->targetOffset = targetOffset; + newFixup->codeMode = codeMode; + newFixup->kindOfFixup = kindOfFixup; + newFixup->fileName = currentFileName; + newFixup->lineNumber = currentLineNumber; + expand(flushExpressionString()); + newFixupAddressMode = EXPRESSION_OPND; + newFixup->theFixupExpression = generateFixupExpression(expression); + if (newFixupAddressMode != EXPRESSION_OPND) + fixupAddressMode[whichFixup] = newFixupAddressMode; + expand(finishOperand ? expandOperand(fixupAddressMode[whichFixup], + operandBuffer[whichFixup]) : /*expandExpression(NULL)*/0); + finishOperand = FALSE; + if (structNestingDepth == 0) { + newFixup->nextFixup = fixupList; + fixupList = newFixup; + } else { + newFixup->nextFixup = newStruct->structFixups; + newStruct->structFixups = newFixup; + } +} + + void +finishUp() +{ + void performFixups(); + void performStartAddressFixup(); + + if (listingOn) + terminateListingFiles(); + performFixups(fixupList); + if (haveUserStartAddress && fixupStartAddress) + performStartAddressFixup(); + outputObjectFile(); + if (listingOn) + outputListing(); +} +/* + bool +isReferenceToRemember(reference) + expressionReferenceListType *reference; +{ + symbolInContextType *context; + + symbolInContextType *getWorkingContext(); + + context = getWorkingContext(reference->expressionReferenced); + if (context != NULL) + return ((context->usage == LABEL_SYMBOL && context->value-> + kindOfValue != ABSOLUTE_VALUE) || context->usage == + EXTERNAL_SYMBOL || context->usage == UNKNOWN_SYMBOL + || context->usage == NESTED_UNKNOWN_SYMBOL); + else + return(FALSE); +} +*/ + void +noteAnonymousReference() +{ + expressionReferenceListType *newReference; + + if (!produceLinkableObject || targetOffset != 0) + return; + + newReference = typeAlloc(expressionReferenceListType); + newReference->nextReference = expressionReferenceList[(int) + currentCodeMode]; + expressionReferenceList[(int)currentCodeMode] = newReference; + newReference->expressionReferenced = NULL; + newReference->relocation.referenceAddress = currentLocationCounter. + value; + newReference->relocation.referenceExpression = -1; + newReference->relocation.referenceRelative = FALSE; + newReference->relocation.referenceKind = REF_WORD; + newReference->relocation.referenceExternal = FALSE; + newReference->relocation.referenceMode = (int)currentCodeMode; +} + + void +noteReference(expression, kindOfFixup, location, codeMode) + expressionType *expression; + fixupKindType kindOfFixup; + addressType location; + codeBufferKindType codeMode; +{ + expressionReferenceListType *newReference; + + if (!produceLinkableObject) + return; + + newReference = typeAlloc(expressionReferenceListType); + numberOfReferencesInList[(int)codeMode]++; + newReference->nextReference = expressionReferenceList[(int)codeMode]; + expressionReferenceList[(int)codeMode] = newReference; + newReference->expressionReferenced = expression; + newReference->relocation.referenceAddress = location; + newReference->relocation.referenceMode = (int)codeMode; + newReference->relocation.referenceExpression = 0; + switch (kindOfFixup) { + case BYTE_FIXUP: + newReference->relocation.referenceRelative = FALSE; + newReference->relocation.referenceKind = REF_BYTE; + break; + case WORD_FIXUP: + newReference->relocation.referenceRelative = FALSE; + newReference->relocation.referenceKind = REF_WORD; + break; + case LONG_FIXUP: + newReference->relocation.referenceRelative = FALSE; + newReference->relocation.referenceKind = REF_LONG; + break; + case DBYTE_FIXUP: + newReference->relocation.referenceRelative = FALSE; + newReference->relocation.referenceKind = REF_DBYTE; + break; + case BYTE_RELATIVE_FIXUP: + newReference->relocation.referenceRelative = TRUE; + newReference->relocation.referenceKind = REF_BYTE; + break; + case WORD_RELATIVE_FIXUP: + newReference->relocation.referenceRelative = TRUE; + newReference->relocation.referenceKind = REF_WORD; + break; + default: + botch("bad fixup kind in noteReference %d\n", + kindOfFixup); + } + newReference->relocation.referenceExternal = FALSE; /* irrelevent? */ +} + + void +performFixups(fixups) + fixupListType *fixups; +{ + valueType *evaluateExpression(); + valueType *valueToPoke; + + performingFixups = TRUE; + statementEvaluationDepth = 2; /* don't throw away functions! */ + while (fixups != NULL) { + if (fixups->theFixupExpression == NULL) + break; + currentFileName = fixups->fileName; + currentLineNumber = fixups->lineNumber; + currentCodeMode = fixups->codeMode; + targetOffset = fixups->targetOffset; + valueToPoke = evaluateExpression(fixups->theFixupExpression, + NO_FIXUP); + if (isUndefined(valueToPoke)) { + noteReference(fixups->theFixupExpression, fixups-> + kindOfFixup, fixups->locationToFixup, fixups-> + codeMode); + } else { + switch (fixups->kindOfFixup) { + + case BYTE_FIXUP: + pokeByteValue(fixups->locationToFixup, + valueToPoke); + break; + + case WORD_FIXUP: + pokeWordValue(fixups->locationToFixup, + valueToPoke); + break; + + case LONG_FIXUP: + pokeLongValue(fixups->locationToFixup, + valueToPoke); + break; + + case DBYTE_FIXUP: + pokeWordValue(fixups->locationToFixup, + swabValue(valueToPoke)); + break; + + case BYTE_RELATIVE_FIXUP: + pokeRelativeByteValue(fixups->locationToFixup, + valueToPoke); + break; + + case WORD_RELATIVE_FIXUP: + pokeRelativeWordValue(fixups->locationToFixup, + valueToPoke); + break; + + default: + botch("bad fixup at end\n"); + } + } + fixups = fixups->nextFixup; + } +} + + void +performStartAddressFixup() +{ + expressionType *startAddressExpression; + + expressionType *generateFixupExpression(); + + startAddressExpression = (expressionType *)startAddress; + startAddress = evaluateExpression(startAddressExpression,NO_FIXUP_OK); + if (startAddress->kindOfValue == UNDEFINED_VALUE && + produceLinkableObject) { + startAddress = (valueType *)generateFixupExpression( + startAddressExpression); + } else if (startAddress->kindOfValue != ABSOLUTE_VALUE && + startAddress->kindOfValue != RELOCATABLE_VALUE) { + error(BAD_START_ADDRESS_ERROR); + haveUserStartAddress = FALSE; + } else { + fixupStartAddress = FALSE; + } +} + + void +putFixupsHere(kindOfFixupsToPut, whichFixup) + fixupKindType kindOfFixupsToPut; + int whichFixup; +{ + int location; + + location = structNestingDepth==0 ? currentLocationCounter.value : + currentFieldOffset; + if (pendingFixup[whichFixup] != NULL) { + createFixup(pendingFixup[whichFixup], location, + kindOfFixupsToPut, currentCodeMode, whichFixup); + } +} +/* + void +putReferencesHere(kindOfReferencesToPut, whichReference) + fixupKindType kindOfReferencesToPut; +{ + expressionReferenceListType *worthyReference; + int currentLocation; + int currentMode; + + if (!produceLinkableObject) + return; + + currentLocation = structNestingDepth==0 ? + currentLocationCounter.value : currentFieldOffset; + currentMode = structNestingDepth==0 ? (int)currentCodeMode : + STRUCT_BUFFER; + while (referencesToNote[whichReference] != NULL) { + if (isReferenceToRemember(referencesToNote[whichReference])) { + switch (kindOfReferencesToPut) { + case BYTE_FIXUP: + referencesToNote[whichReference]-> + relocation.referenceKind = REF_BYTE; + break; + case WORD_FIXUP: + referencesToNote[whichReference]-> + relocation.referenceKind = REF_WORD; + break; + case LONG_FIXUP: + referencesToNote[whichReference]-> + relocation.referenceKind = REF_LONG; + break; + case BYTE_RELATIVE_FIXUP: + referencesToNote[whichReference]-> + relocation.referenceKind = REF_BYTE; + referencesToNote[whichReference]-> + relocation.referenceRelative = TRUE; + break; + case WORD_RELATIVE_FIXUP: + referencesToNote[whichReference]-> + relocation.referenceKind = REF_WORD; + referencesToNote[whichReference]-> + relocation.referenceRelative = TRUE; + break; + case DBYTE_FIXUP: + referencesToNote[whichReference]-> + relocation.referenceKind = REF_DBYTE; + break; + default: + botch("bad fixup kind in put references %d\n", + kindOfReferencesToPut); + break; + } + numberOfReferencesInList[currentMode]++; + referencesToNote[whichReference]-> + relocation.referenceAddress = currentLocation; + referencesToNote[whichReference]-> + relocation.referenceMode = currentMode; + worthyReference = referencesToNote[whichReference]; + referencesToNote[whichReference] = + referencesToNote[whichReference]-> + nextReference; + worthyReference->nextReference = + expressionReferenceList[currentMode]; + expressionReferenceList[currentMode]= worthyReference; + } else { + worthyReference = referencesToNote[whichReference]; + referencesToNote[whichReference] = + referencesToNote[whichReference]-> + nextReference; + qsfree(worthyReference); + } + } +} +*/ + +/* + These routines handle contexts and dynamic symbol creation. + */ + + void +addNewLocalVariable(symbol) + symbolTableEntryType *symbol; +{ + identifierListType *newLocalVariable; + + newLocalVariable = typeAlloc(identifierListType); + newLocalVariable->theSymbol = symbol; + newLocalVariable->nextIdentifier = currentLocalVariableList; + currentLocalVariableList = newLocalVariable; +} + + symbolTableEntryType * +effectiveSymbol(symbol, assignmentTargetContext) + symbolTableEntryType *symbol; + symbolInContextType **assignmentTargetContext; +{ + symbolInContextType *context; + operandType *operand; + expressionType *expression; + environmentType *saveEnvironment; + + symbolInContextType *getWorkingContext(); + + context = getWorkingContext(symbol); + saveEnvironment = currentEnvironment; + while (context != NULL && context->usage == ARGUMENT_SYMBOL && + context->value->kindOfValue == OPERAND_VALUE) { + operand = (operandType *)context->value->value; + if (operand->kindOfOperand == EXPRESSION_OPND) { + expression = operand->theOperand.expressionUnion; + if (expression->kindOfTerm == IDENTIFIER_EXPR) { + currentEnvironment = currentEnvironment-> + previousEnvironment; + context =getWorkingContext(symbol=expression-> + expressionTerm.identifierUnion); + } else { + break; + } + } else { + break; + } + } + currentEnvironment = saveEnvironment; + if (assignmentTargetContext != NULL) + *assignmentTargetContext = context; + return(symbol); +} + + symbolTableEntryType * +generateLocalLabel(symbol) + symbolTableEntryType *symbol; +{ + stringType *localLabelString(); + symbolTableEntryType *lookupOrEnterSymbol(); + + return(lookupOrEnterSymbol(localLabelString(symbol), LABEL_SYMBOL)); +} + + symbolInContextType * +getBaseContext(identifier) + symbolTableEntryType *identifier; +{ + symbolInContextType *result; + + result = identifier->context; + while (result != NULL && result->environmentNumber != + GLOBAL_ENVIRONMENT_NUMBER) + result = result->pushedContexts; + return(result); +} + + symbolInContextType * +getWorkingContext(identifier) + symbolTableEntryType *identifier; +{ + symbolInContextType *result; + + result = identifier->context; + while (result != NULL && result->environmentNumber != + GLOBAL_ENVIRONMENT_NUMBER && result-> + environmentNumber != currentEnvironment-> + environmentNumber) + result = result->pushedContexts; + return(result); +} + + stringType * +localLabelString(symbol) + symbolTableEntryType *symbol; +{ +#define TEMP_SYMBOL_SIZE_LIMIT 200 + char nameUnderConstruction[TEMP_SYMBOL_SIZE_LIMIT]; + + stringType *saveString(); + + sprintf(nameUnderConstruction, "_%d_", localLabelTagValue(symbol)); + strncat(nameUnderConstruction, &(symbName(symbol)[1]), + TEMP_SYMBOL_SIZE_LIMIT); + return(saveString(nameUnderConstruction)); +} + + int +localLabelTagValue(symbol) + symbolTableEntryType *symbol; +{ + symbolInContextType *context; + + symbolInContextType *getWorkingContext(); + void addNewLocalVariable(); + + context = getWorkingContext(symbol); + if (context == NULL) + botch("local label doesn't have symbol context\n"); + if(context->environmentNumber!=currentEnvironment->environmentNumber){ + pushBinding(symbol, newValue(ABSOLUTE_VALUE, + currentLabelTagNumber, EXPRESSION_OPND), + LABEL_SYMBOL); + addNewLocalVariable(symbol); + return(currentLabelTagNumber); + } + return(context->value->value); +} + + void +addBreak(kind, data) + codeBreakKindType kind; + int data; +{ + codeBreakType *newBreak; + codeBreakType *buildCodeBreak(); + + newBreak = buildCodeBreak(kind, currentLocationCounter.value, data); + if (codeBreakList == NULL) { + codeBreakList = lastCodeBreak = newBreak; + } else { + lastCodeBreak->nextBreak = newBreak; + lastCodeBreak = newBreak; + } +} + + void +reserveAbsolute(startAddress, blockSize) + addressType startAddress; + int blockSize; +{ + reservationListType *buildReservation(); + + if (reservationList != NULL && reservationList->startAddress + + reservationList->blockSize == startAddress) + reservationList->blockSize += blockSize; + else + reservationList = buildReservation(startAddress, blockSize, + reservationList); +} + + bool +listableStatement(kind) + statementKindType kind; +{ + return( kind == ALIGN_STATEMENT || kind == BLOCK_STATEMENT || + kind == BYTE_STATEMENT || kind == CONSTRAIN_STATEMENT || + kind == DBYTE_STATEMENT || kind == DO_UNTIL_STATEMENT || + kind == DO_WHILE_STATEMENT || kind == IF_STATEMENT || + /*kind == INSTRUCTION_STATEMENT ||*/ kind == ORG_STATEMENT || + kind == REL_STATEMENT || kind == START_STATEMENT || + kind == STRUCT_STATEMENT || kind == LONG_STATEMENT || + kind == STRING_STATEMENT || kind == WHILE_STATEMENT || + kind == WORD_STATEMENT || kind == DEFINE_STATEMENT || + kind == EXTERN_STATEMENT || kind == INCLUDE_STATEMENT || + kind == UNDEFINE_STATEMENT || kind == VARIABLE_STATEMENT || + kind == TARGET_STATEMENT); +} diff --git a/semanticMisc.o b/semanticMisc.o new file mode 100644 index 0000000000000000000000000000000000000000..00bb997360d52b10abdfa22db1caae5b80ad89f6 GIT binary patch literal 62907 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℞tGWO=9-7al56r zGqvmf%Q3*vmtz@L`|ws9;uar`1g`QXyqm~sER!ZlY?7K{%)Fj(S z+*CcxTTYgmxWmytoSLS+H#NmHh)JTEEKe#-Q=}$YjgXqC`kA4d(9DjJO5UJPcFAbY z8z*YUqZWALOLD+R&3EXjIX+2UxtiKmLJ2Ly3>`-o^oE$ZiD$|(gCF)nb@?34O+p0^ z?pLG%ACl1FUyco@57xZ0Qi^*bnxzHNJ@Kr9N7u3|(&Uo1kePs9vA{ZJsc1bv=o$bc z?Rbg0zhqjiSZ}NFbigI+eVq+BFO2qAk0R2Nz!is~G}7F{8*L3u>huoI>|v)soldc7 zwA8TVq_<@SuaM=eSc6+C%_l1KMiqvfc4;CT|-Tp;ZvpRAkmB&xOVr?L$xJt0lOa|Uj@p>edo8F|6 zF@@^Q=`BI((2>}wQ+qC*jAv$dO|cRtE7P&wsb$jv-KkT(E7f2jO{_y^!AnkpwXOMCe_wBmIwmL5@7$921CNH&!dc0>5 zXN}%;%n`w8Uo>e2BLhZKMiX&@g$Oz0CEZDDN)xn#g@_=0I1AF1CwPY_Yw4G?@(c2* z&rs6R&)s{UYUP){0u(p6hFI9J5%j{(6^KftU-a3vBd4ZHo4%V=oMjmtbt92uqh0+| z^uHj+ZMe4K!r6Lj9csvto{co$qeL>7c5U3Aj!d-$7z}b>ga}lA|)t!kU&HjPC8n1Flo_@E|W+70VO@ z0jZ}fM`CqVa0)G*NM3qy-$<9rBbT#lbeJDDO|xaJb}!RyCI^G)g1AH0>vl?WV$yU< zjz<;){8IH=Z8(XM7KUfeR@qx}j;XanorCRPmceur%~3$ZEJu!@tAv z1{c?3kp=T5H%pOBTg$cb)>O#i5>Lf6NEGF52a7>`6?+(pVNmUKSR8OhvH>O+0lCQ>qXnA2x&L3C1&b`Fh zvE?^87#^dbx-VeproK_Sn_|d@o##%eWZbw(C8`@XsdV&rm#8f$_lDdAS9k8@Cc%u4 zW;8HK!D8_(8b(yBt0BSS5Z9vNKzvI@EQ>`C&uPyC(Ype6vs~8n( z+uG1xQ*Sets{8d;*0KN$y}8adb#XbS)C2S~1(_!EERzm%^753Qwx&6fIf_El4?_*o zsZ5HGLF6#g0~Y5_bC9G;@T^fOhfDTOe@bZL#&-%#NmG}fJpZBdpL&6Ay1P|53hB`z zIj~_SDpbcHon7V8oNJ)wJ??Q*BTUa5X<8yhkyVmp$-sc(Wd9`Puz-4EBK5Ftw0OFV%a%Ks@(6^Q2$*9(tB8V0@*rafrsOF z;W76lGtlIU_JF!@!^|WF>7Xp`ZmPLg@`%xe#8{Wf>r0YGG7OiIjjeUnw|4UXF_5WHs;+`o zOi`4g0Pfn;DqA9rqSBEyQ$ichJk?{2B^YaAklom`YwqROr>LHzN8X)y@xyNGc^eZJ zIH49V>kuDSU6lHbD}_#+s%V0a<*^D$wTyzJDWqLnWEUN6b`$uVYp{sZXgcIoL@oS~ z562n2DQaQE73PymTqk`F7OyeT-CP+(y_Uo(l_N@7$tb_94Lv1o!7B9YYo8l}~h zsf?i~YLIBcYf{0MMd$<@y-18m+wfREDNmj$L##Sq$&XxaZKXqHb*-(?CJ?oB{P;)yDh)O~9$fQ=L8BdWL z4a(evMmzwIZe^#^gs!8BpBim%#?#z&O`R>UL}wAs)Y0h~wm~Sc5l@KHTnFdz>4|lr z<3O@L{Vekt=qPDC(^EFJo=NR&-`-+4=*enm(}Ep0dMSX_0CFr)mqU+U+nnkEZ88%b zvZVvGU~T0IGncDR7^<4!#Is_mt-Ayh%^$(mT6alNWLWTAQc}5BaXtl{q)|vt={B@= z(!uR&JpJG?aF^vJ)O=c|_!@cR~Ya}?18wxO{RZQn>P!|!6S8Wzti@_|jI21#tBDV{h6 z9$Mtnpi`ulv9F~mU1u++r#)~myL03APCg4Sx`)slsw?Ym{n>|&Y^*HE8DZSk&#jqjm1GFTl1F^YP~t#~;A1qt=IGD?9d zZ$-WJliDH;>zHPo>u#?{TjLc26k1vkU2J)z39h9~Gs<;9+k&0@oQ8?1g zT%uNbHE4Q-Ewh$TI+oBviEXUj(&5@n(u??cgK8`t_@y9L^-9c}LXzU7er1SO#@mD? zc<4gOvWkV5kt3xhh!$l@JrA~~my$>-g-&$?P#0OZ4R7Yqy`)61!BPuUxkOBb+voH% z|82^3=#?jmsnmM#AXS`sCPA2k?o$eBH7m8cxu?ivLB-Mv$#j@nzdNNC?m=NoR_pS* z7p*o0QgUP+(eP-N_K#A$ouH$!y`hC7zXUu=*5)ha(8+6c<>3??sj19+UUVUPt*)i$ zI&a3yLYg#_wffb8*5l4t->@&#;S4zXwz6ayrl!>E@#2`Im{Nu*Duq`HljK5niny1FXuRo2_N=8wEsyGp4j32BJmJYpe~8x zr%RlIE5vW1F`})3Qb72LKo8-;3m$G7X_BB{Jc8j1uWM?n zX=uPeL@6S&1kWsC2C}J>_O+_I$D{%@=>}a7VDVAd&svM3cU9OM#0lu5_Av*8fr{@s-W4c8XhrmrM)jS zro41Ysg4biB#teZI#-*CP=(nw!!}ucXHsH`-cl1`6iT%?*;iA;F-@vv&dG&mJ$MXMg_jTCf+5idzT!Le20V0*A`{8(>>gNHtM4>c~I2VX=|xAV?hvm@bI3-?WUXR z4s8#ixY?}qljR9^o9&0PtZ76rs1~QfsEgD!pdjlm3p_<&=|ue-D@HX3)nS9?UKF)x zL9U$@izq$P@LS}he~~TdaZ2kQZYBpFw`|9Kn-*GZsF#Leo`guPp21Xo01GLiA(+-} z#sUrR{x-(nwFGf^^S7FVt+ zo~b-Xv&dwD*4OHZRSAkZot{l@vNka!*;>;JCze`Cy0p=zfvlB0=E1Vd)X!9lkLQr{ z$RzpJI&YpLHD_<6T?$EQGPqg6Q=1NiNmUgNzp0+C6)v&()$_TR$v~mn6k%E5 zGTCq^M7JgvZJH1FLo6>NCfXi?#WrDI3SC3iqgvk(&Caocw@T)Psm1B~tj>g02%J^V zZY);isaVb7(NMj6CYxv2c8#bpL~jCE`BIADHJ^EPq1rUKBtM>{=C=%5I}mnlQwzX7 zPTsiF%W&nvmn=hfGVI*ZtNn~AQ-zlX^o|E+d+LU)m4PS1Nz;66)Jqq3Z>70Kq%dPD znex6#4z{=9<&wOfcQZ??VTnl{7o!1o0_gc#?@mCl1XCWK*IC;LYFVs10~VJ02BjYE zQ~p0qDZ0bSZtxE`A~t$rrxJ* zzo(3{;n)qbsjqs_E7H{qt&=jDSE_MAe49^R#!e}!cu=(*>+2xNX?*(+uRWI+sYy*G zqxEJtN$|Y%JxQrXdU^D1@{9~^lXF=(J)!j=2J6+~oQ!R3DNK$4r&Yw<(czao>vH+S z9r_}oKN?{O))zwzjru&jsNE3E(>LlH8k+9;n1M^gqr-ArgCBz4yt<5@XK?Q#6mH;` zUpi?%MFAo7UQGA7YY=eU4lf6y58Bu|S?{~nB`1CN#gLP~7{D@d&(zW1U(uZDKG~qt z_=#xGJr!weIUr+yO+n|u%_;92`c=tjYkpa}_lkTH@^Ltk-4%C92jCqN1xz1kQSrjI?1KZ$jRqm^w9TCQ*&nT$_d7?1n*OUDRN8GBFVeU2sMD7e1=DpO zb)PzIN}8`JKrBp%mRGN8KW6n6crPJZ(6sfo=Y+G3g_4G^;iqkUm#$@l8#uU4!+v5G_ zs_v@EJ>SDo?4I6RR9d25VD6-Tr338LlMp_wE?9$`?dop1n@o4v6^%MQhA402P}9)y zXLX+&;$#3OQ8KI{f?)PyeeOYoqtbi}pAHL3>6kp@#`?VRel>rKkTyVRTYD@V{c=$yDTub9@K9;;+l^hXuR zn3Z~xd4Vw~+)C)LV`wQp7=bC0i1rkR-iNo6yM=Kg9o0c0c;gersb2FCqOkFM<@AGz zX|k&5a2x61>GZ);?#14o4H}o@{V9whK!SS`U6wK%HI}opSPD5(GTadc=B&G1WTSS{Y@m2i?iYA+MW-TXf@5d z>$vB#)et4UqRdCUR3uALwP*X!(sWA_q3VvtK?@1)mP@USl3NV18@~Bo6)jDe@;thOX^}uIaP0Z6N&kt zoaXmv@8R%h56i0W=cUgVt;X||>N|#-LHA|d6H-3qH8msNWT-ytIW>!p)|w-!+PZL5 zoO+@8RGwz{*4liEODF5>uI}_{CoE>v{7$~(skzO(Q28OwM4~|R=~2yvm*hx?Nb`Y7 z&6HZOnWbr#B-QcGe)`glbbU{v`{65{j7AI^Er!O5G{yqxHjb;(-P9>WMIsxZb85-l zr6n-)v|&UoaJ5@ z#ZY_&LadLH8CBdM#rjfU#^Z>*-J?yQd`T@^Ie4Rc&}>qiN6k6$@K1N2=HUj{dnr@} z-Y((qOm>WzqSJr>)lH78~Q U02ZAz%%MZ55m@VMDS+1ee=;h|-~a#s literal 0 HcmV?d00001 diff --git a/slinky/.mark b/slinky/.mark new file mode 100644 index 0000000..e259cf5 --- /dev/null +++ b/slinky/.mark @@ -0,0 +1 @@ +Fri Jun 6 14:51:43 PDT 1986 diff --git a/slinky/DOC b/slinky/DOC new file mode 100644 index 0000000..72b16fe --- /dev/null +++ b/slinky/DOC @@ -0,0 +1,8 @@ +/u0/chip/macross/slinky: + This directory contains the source to Slinky. Here's what's here: + +DOC - This file +Makefile - Makefile to compile it +*.c, *.h - source files +opt/ - directory for optimized version, as mentioned in + documentation above for /u0/chip/macross/opt diff --git a/slinky/Makefile b/slinky/Makefile new file mode 100644 index 0000000..5e01400 --- /dev/null +++ b/slinky/Makefile @@ -0,0 +1,77 @@ +.SUFFIXES: .o .c .h .run + +OBJECTS = builtins.o debugPrint.o errorStuff.o expr.o initialize.o\ +instantiate.o link.o main.o map.o poke.o read.o relocate.o slinkyTables.o\ +write.o + +SOURCES = builtins.c debugPrint.c errorStuff.c expr.c initialize.c\ +instantiate.c link.c main.c map.c poke.c read.c relocate.c slinkyTables.c\ +write.c slinkyExpressions.h slinkyGlobals.h slinkyTypes.h y.tab.h + +.c.o: + cc -c -g $*.c + +.c.run: + cc -o $* $*.c + +slinky: $(OBJECTS) + cc -g -o slinky $(OBJECTS) + +update: .mark + kessel "(cd /u0/chip/macross/slinky; make slinky >&errorfyle)" & + +move: .mark + +.mark: $(SOURCES) +# cp $? /net/kessel/u0/chip/macross/slinky + cp $? /net/kessel/u0/chip/macross/slinky +# cp $? /net/kessel/u0/chip/macross/slinky/prof + cp $? /net/kessel/u0/chip/macross/slinky/prof + cp $? opt + date >.mark +# date >/net/kessel/u0/chip/macross/slinky/.mark + date >/net/kessel/u0/chip/macross/slinky/.mark +# date >/net/kessel/u0/chip/macross/slinky/prof/.mark + date >/net/kessel/u0/chip/macross/slinky/prof/.mark + date >opt/.mark + +install: slinky + cp slinky /u1/gg/bin/slinky_tmp + strip /u1/gg/bin/slinky_tmp + mv /u1/gg/bin/slinky /u1/gg/bin/sliny.old + mv /u1/gg/bin/slinky_tmp /u1/gg/bin/slinky + +builtins.o: builtins.c slinkyGlobals.h slinkyTypes.h slinkyExpressions.h + +debugPrint.o: debugPrint.c slinkyGlobals.h slinkyTypes.h + +errorStuff.o: errorStuff.c slinkyGlobals.h slinkyTypes.h + +expr.o: expr.c slinkyExpressions.h slinkyGlobals.h slinkyTypes.h y.tab.h + +initialize.o: initialize.c slinkyGlobals.h slinkyTypes.h + +instantiate.o: instantiate.c slinkyGlobals.h slinkyTypes.h slinkyExpressions.h + +link.o: link.c slinkyGlobals.h slinkyTypes.h + +main.o: main.c slinkyGlobals.h slinkyTypes.h + +map.o: map.c slinkyGlobals.h slinkyTypes.h + +poke.o: poke.c slinkyGlobals.h slinkyTypes.h + +read.o: read.c slinkyGlobals.h slinkyTypes.h + +relocate.o: relocate.c slinkyGlobals.h slinkyTypes.h + +slinkyTables.o: slinkyTables.c slinkyTypes.h + +write.o: write.c slinkyGlobals.h slinkyTypes.h + +cleanup: + /bin/rm -f *.o slinky + +love: + @echo "Not war?" + diff --git a/slinky/builtins.c b/slinky/builtins.c new file mode 100644 index 0000000..055c530 --- /dev/null +++ b/slinky/builtins.c @@ -0,0 +1,431 @@ +/* + builtins.c -- Built-in functions for the Slinky linker + + Chip Morningstar -- Lucasfilm Ltd. + + 14-November-1985 +*/ + +#include "slinkyTypes.h" +#include "slinkyGlobals.h" +#include "slinkyExpressions.h" +#include + +#define getSymbol() ((symbolType *)getNumber()) + + void +tooFewArgs(argCount, name) + int argCount; + stringType *name; +{ + error(TOO_FEW_ARGUMENTS_TO_BIF_ERROR, name); + while (argCount-- > 0) + skipExpression(); +} + + void +tooManyArgs(argCount, name) + int argCount; + stringType *name; +{ + error(TOO_MANY_ARGUMENTS_TO_BIF_ERROR, name); + while (argCount-- > 0) + skipExpression(); +} + +/* + The built-in-functions themselves: pointers to these are loaded into the + builtInFunctionTable at linker compile time. These are all known within + the Macross assembler: each symbol of the form "xxx" is assigned a pointer + to "xxxBIF" (BIF == Built-In-Function). + */ + +/* The two ATASCII related BIF's refer to this table -- This really only + makes sense for the 6502 version, but is harmless in other versions. */ +static char atasciiTable[] = { /* 0xFFs will become 0x00s on output */ + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, + 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, + 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, + 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, + 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, + 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, + 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, + 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, + 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, + 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0xFF, +}; + +/* Convert a string to ATASCII */ + stringType * +atasciiBIF(argCount) + int argCount; +{ + stringType *string; + stringType *newString; + int i; + + if (argCount == 0) { + return(""); + } else if (argCount > 1) { + tooManyArgs(argCount, "atascii"); + return(""); + } else { + string = (stringType *)evaluateExpression(); + newString = (stringType *)malloc(strlen(string)+1); + for (i=0; string[i]!='\0'; i++) + newString[i] = atasciiTable[string[i]]; + newString[i] = '\0'; + return(newString); + } +} + +/* Convert a string to ATASCII while setting high-order color bits */ + stringType * +atasciiColorBIF(argCount) + int argCount; +{ + stringType *string; + stringType *newString; + int color; + int i; + byte testChar; + + if (argCount == 0) { + return(""); + } else if (argCount == 1) { + return(atasciiBIF(argCount)); + } else if (argCount > 2) { + tooManyArgs(argCount, "atasciiColor"); + return(""); + } else { + string = (stringType *)evaluateExpression(); + color = (evaluateExpression() & 0x03) << 6; + newString = (stringType *)malloc(strlen(string)+1); + for (i=0; string[i]!='\0'; i++) { + testChar = atasciiTable[string[i]]; + if (testChar == 0xFF) + testChar = 0; + testChar = (testChar & 0x3F) | color; + if (testChar == 0) + testChar = 0xFF; + newString[i] = testChar; + } + newString[i] = '\0'; + return(newString); + } +} + +/* Check if an operand is absolute (as opposed to relocatable) */ + bool +isAbsoluteValueBIF(argCount) + int argCount; +{ + if (argCount > 1) + tooManyArgs(argCount, "isAbsoluteValue"); + return(TRUE); +} + +/* Check if operand is a condition code */ + bool +isConditionCodeBIF(argCount) + int argCount; +{ + bool result; + + if (argCount == 0) + return(FALSE); + else if (argCount > 1) { + tooManyArgs(argCount, "isConditionCode"); + return(FALSE); + } + result = (*pc == CONDITION_CODE_TAG); + skipExpression(); + return(result); +} + +/* Check if a symbol is defined */ + bool +isDefinedBIF(argCount) + int argCount; +{ + symbolType *symbol; + + if (argCount == 0) + return(FALSE); + else if (argCount > 1) { + tooManyArgs(argCount, "isDefined"); + return(FALSE); + } + if (*pc != IDENTIFIER_TAG) { + skipExpression(); + return(TRUE); + } + pc++; /* skip tag */ + symbol = getSymbol(); + return((symbol->symbolClass & ~SYMBOL_EXTERNAL) != 0); +} + +/* Check if a symbol is externally visible */ + bool +isExternalBIF(argCount) + int argCount; +{ + symbolType *symbol; + + if (argCount == 0) + return(FALSE); + else if (argCount > 1) { + tooManyArgs(argCount, "isExternal"); + return(FALSE); + } + if (*pc != IDENTIFIER_TAG) { + skipExpression(); + return(TRUE); + } + pc++; /* skip tag */ + symbol = getSymbol(); + return((symbol->symbolClass & SYMBOL_EXTERNAL) != 0); +} + +/* Return the Nth character of a string (as an integer) */ + int +nthCharBIF(argCount) + int argCount; +{ + stringType *string; + int position; + + if (argCount > 2) { + tooManyArgs(argCount, "nthChar"); + return(0); + } else if (argCount != 2) { + tooFewArgs(argCount, "nthChar"); + return(0); + } + string = (stringType *)evaluateExpression(); + position = evaluateExpression(); + if (position >= strlen(string)) { + error(BAD_POSITION_ARGUMENT_TO_NTH_CHAR_ERROR); + return(0); + } + return(string[position]); +} + +/* Pass stuff through to stdio's 'printf' function */ + int +printfBIF(argCount) + int argCount; +{ + stringType *formatString; + int argument[20]; + int i; + + if (argCount < 1) { + tooFewArgs(argCount, "printf"); + return(0); + } else if (argCount > 21) { + tooManyArgs(argCount, "printf"); + return(0); + } + formatString = (stringType *)evaluateExpression(); + argCount--; + for (i=0; i 2) { + tooManyArgs(argCount, "strcat"); + return(""); + } + string1 = (stringType *)evaluateExpression(); + string2 = (stringType *)evaluateExpression(); + newString = (stringType *)malloc(strlen(string1)+strlen(string2)+1); + strcpy(newString, string1); + strcat(newString, string2); + return(newString); +} + +/* Compare two strings */ + int +strcmpBIF(argCount) + int argCount; +{ + stringType *string1; + stringType *string2; + + if (argCount < 2) { + tooFewArgs(argCount, "strcmp"); + return(0); + } else if (argCount > 2) { + tooManyArgs(argCount, "strcmp"); + return(0); + } + string1 = (stringType *)evaluateExpression(); + string2 = (stringType *)evaluateExpression(); + return(strcmp(string1, string2)); +} + +/* Compare two strings in a case-independent fashion */ + int +strcmplcBIF(argCount) + int argCount; + +{ + stringType *string1; + stringType *string2; + + if (argCount < 2) { + tooFewArgs(argCount, "strcmplc"); + return(0); + } else if (argCount > 2) { + tooManyArgs(argCount, "strcmplc"); + return(0); + } + string1 = (stringType *)evaluateExpression(); + string2 = (stringType *)evaluateExpression(); + return(strcmplc(string1, string2)); +} + +/* Return the length of a string */ + int +strlenBIF(argCount) + int argCount; +{ + if (argCount < 1) + return(0); + else if (argCount > 1) { + tooManyArgs(argCount, "strlen"); + return(0); + } + return(strlen(evaluateExpression())); +} + +/* Return a substring of a string */ + char * +substrBIF(argCount) + int argCount; +{ + stringType *string; + int start; + int length; + stringType *newString; + int originalLength; + bool backwards; + + if (argCount < 1) + return(""); + else if (argCount == 1) + return((stringType *)evaluateExpression()); + else if (argCount > 3) { + tooManyArgs(argCount, "substr"); + return(""); + } + string = (stringType *)evaluateExpression(); + originalLength = strlen(string); + start = evaluateExpression(); + if (start < 0) { + start = -start - 1; + backwards = TRUE; + } else + backwards = FALSE; + if (argCount == 2) { + length = originalLength - start; + if (backwards) + length = -length; + } else { + length = evaluateExpression(); + } + if (length < 0) { + length = -length; + if (backwards) + start = start + length - 1; + else + start = start - length + 1; + } + if (backwards) + start = originalLength - start - 1; + if (originalLength <= start || originalLength < length + start || + start < 0 ){ + error(BAD_SUBSTRING_INDICES_ERROR); + return(""); + } + newString = (stringType *)malloc(length+1); + strncpy(newString, string+start, length); + newString[length] = '\0'; + return(newString); +} + +/* Turn a string into a symbol and return its value */ + addressType +symbolLookupBIF(argCount) + int argCount; +{ + symbolType *symbol; + stringType *symbolName; + symbolType *lookupGlobalSymbol(); + + if (argCount < 1) { + tooFewArgs(argCount, "symbolLookup"); + return(0); + } else if (argCount > 1) { + tooManyArgs(argCount, "symbolLookup"); + return(0); + } + symbol = lookupGlobalSymbol(symbolName = (stringType *) + evaluateExpression()); + if (symbol == NULL) { + error(SYMBOL_NOT_FOUND_IN_SYMBOL_LOOKUP_ERROR, symbolName); + return(0); + } else + return(symbol->symbolValue); +} + +/* Turn a symbol into a string */ + stringType * +symbolNameBIF(argCount) + int argCount; +{ + symbolType *symbol; + + if (argCount < 1) { + tooFewArgs(argCount, "symbolName"); + return(NULL); + } else if (argCount > 1) { + tooManyArgs(argCount, "symbolName"); + return(NULL); + } + if (*pc != IDENTIFIER_TAG) { + error(SYMBOL_NAME_ARG_IS_NOT_SYMBOL_ERROR); + skipExpression(); + return(""); + } + pc++; + symbol = getSymbol(); + return(symbol->symbolName); +} diff --git a/slinky/builtins.o b/slinky/builtins.o new file mode 100644 index 0000000000000000000000000000000000000000..83ddc1f3f2ae34527531ae6283b2b34a1393f303 GIT binary patch literal 18402 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 R9qawo_#?GHH(X|}{vVrUD~$jE literal 0 HcmV?d00001 diff --git a/slinky/debugPrint.c b/slinky/debugPrint.c new file mode 100644 index 0000000..2521861 --- /dev/null +++ b/slinky/debugPrint.c @@ -0,0 +1,124 @@ +/* + debugPrint.c -- Routines to dump stuff out in readable form for + debugging the Slinky linker. + + Chip Morningstar -- Lucasfilm Ltd. + + 18-March-1985 + +*/ + +#include "slinkyTypes.h" +#include "slinkyGlobals.h" + + +static char *modeStrings[2] = { + "abs", + "rel", + }; + +static char *kindStrings[3] = { + "byte", + "word", + "dbyt", + }; + +static char *pcrelStrings[2] = { + " ", + "pcrel", + }; + +static char *externalStrings[2] = { + " ", + "extern", + }; + +static char *symbolStrings[6] = { + "und ", /* 0x00 */ + "und ext", /* 0x01 */ + "abs ", /* 0x02 */ + "abs ext", /* 0x03 */ + "rel ", /* 0x04 */ + "rel ext", /* 0x05 */ + }; + + void +printCode(startAddress, endAddress, mode) + int startAddress; + int endAddress; + int mode; +{ + printf(" Code: 0x%04x:0x%04x %s\n", startAddress, endAddress, + modeStrings[mode]); +} + + void +printReference(reference) + expressionReferenceType *reference; +{ + printf(" Ref : 0x%04x (%s %s %s %s) expression #%d\n", reference-> + referenceAddress, modeStrings[reference->referenceMode], + pcrelStrings[reference->referenceRelative], externalStrings[ + reference->referenceExternal], kindStrings[reference-> + referenceKind], reference->referenceExpression.inFile); +} + + void +printReferenceFixup(reference) + expressionReferenceType *reference; +{ + printf(" Ref : 0x%04x (%s %s %s %s) expression=0x%x\n", + reference->referenceAddress, modeStrings[reference-> + referenceMode],pcrelStrings[reference->referenceRelative], + externalStrings[reference->referenceExternal], kindStrings[ + reference->referenceKind], reference->referenceExpression. + inCore); +} + + void +printSymbol(symbolTag, symbol) + int symbolTag; + symbolType *symbol; +{ + printf(" Symb: %3d %s 0x%04x \"%s\"\n", symbolTag, symbolStrings[ + symbol->symbolClass], symbol->symbolValue, + symbol->symbolName); +} + + void +printLoadMapSymbol(symbol) + symbolType *symbol; +{ + fprintf(mapFileOutput, "%-20s 0x%04x %s ", symbol->symbolName, + symbol->symbolValue, symbolStrings[symbol->symbolClass]); +} + + void +printGlobalSymbols() +{ + int symbolCount; + + printf("Globals:\n"); + printf(" %d global symbols\n", globalSymbolCount); + for (symbolCount=0; symbolCountsymbolName); + } +} + + void +printExpression(expression, length) + expressionPCType expression; + int length; +{ + int line; + int i; + + printf("expression length = %d:\n", length); + for (line=0; linesgdYS!yU!ASox_ygX6llf;=O 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 literal 0 HcmV?d00001 diff --git a/slinky/errorStuff.c b/slinky/errorStuff.c new file mode 100644 index 0000000..0e583cf --- /dev/null +++ b/slinky/errorStuff.c @@ -0,0 +1,65 @@ +/* + errorStuff.c -- Error handling for the Slinky linker. + + Chip Morningstar -- Lucasfilm Ltd. + + 9-March-1985 +*/ + +#include "slinkyTypes.h" +#include "slinkyGlobals.h" + + void +error(theError, arg1, arg2, arg3, arg4, arg5, arg6) + errorType theError; + anyOldThing *arg1; + anyOldThing *arg2; + anyOldThing *arg3; + anyOldThing *arg4; + anyOldThing *arg5; + anyOldThing *arg6; +{ +/* This table MUST be maintained congruently with the definition of the + enumerated type 'errorType'. */ + + static char *errorMessageStrings[] = { + "no file name on command line after '-o'", + "unknown command line flag '-%c'", + "more than one output file name given on command line", + "can't open load file '%s'", + "can't open object file '%s'", + "no input files given!", + "file '%s' is not a valid Macross object file", + "premature end of file on object file '%s'", + "error reading object file '%s'", + "absolute code in '%s' with addresses 0x%04x:0x%04x overlaps absolute code in '%s' with addresses 0x%04x:0x%04x", + "can't find a place to relocate relocatable code segment starting at 0x%04x in file '%s'", + "multiply defined symbol '%s'", + "'%s' undefined", + "relative offset %d too large to fit at byte (0x%04x) 0x%04x", + "value 0x%x too large to fit at byte (0x%04x) 0x%04x", + "value 0x%x too large to fit at word (0x%04x) 0x%04x", + "no file name on command line after '-m'", + "more than one load map file name given on command line", + "can't open load map file '%s'", + "bad load address ('%s') given on command line", + "no load address on command line after '-l'", + "array term found in expression in object file", + "ASSERT failed: %s", + "condition code term in expression in object file", + "'mswitch' clause at top level -- boo boo", + "too many arguments to function inside object", + "too few arguments to built in function '%s'", + "too many arguments to built in function '%s'", + "bad position argument to 'nthChar'", + "bad substring indices to 'substr'", + "argument to 'symbolName' is not a symbol", + "symbol '%s' undefined in 'symbolLookup()'", + }; + + printf("\"%s\": ", currentFileName); + printf(errorMessageStrings[(int)theError], arg1, arg2, arg3, arg4, + arg5, arg6); + printf("\n"); + errorFlag = TRUE; +} diff --git a/slinky/errorStuff.o b/slinky/errorStuff.o new file mode 100644 index 0000000000000000000000000000000000000000..22b5e6dc85730feccff24305f6d026852d5eb9b3 GIT binary patch literal 8982 zcmc&)Ym6gVb-vy6+()2idIC{EQ3ZD5@#5L;vfbUD_HJg~?dr$kwk_K|vlC6IDcj|4 zGwv!=RqmZe1cnLPpui6VA=#A@rGwaC{8))UEBFOk1W^F7tRNymiZ%(6k|3cKLJ*Ni zo$uU7)wO$vhZHH6-1XHt=bm%!Ip;pzQzxd*Fvgx^?9}Uc;&XaKJlS6|Hg)&J)uW?( ztaJER|9W@o_0(bc$Em}OpQH{eKTRFh|0{La`g!W`>2qlCiSq`V#q-taTkJ_Zr|^B{ z%;C*f-g$WQ)ia0XPd|EV`mLb-`T5t_E7Nx$0&U|vXAUcWf9A0My)%cce>`*ev}&jH zsrTn*jH$Pw?f2e!i+%WOubutyzvJcq`Q!OUuRm}N&)IVg-!nS?-k#%ijX~dY4W}2m zfswlGr`X85?fK74@OuMi2keWT6x;Iy*NAo<4@#hD6b(m_rg^8o?-FZFKkGPNDl+^b zSOeeb3i;HH|7R`9~gn_bo<`UakkSA{lO@5(XXxxw|FDtnSQiu zINfgGhM^l8^LH-J=kF|whvDzL!N3`Y#;@O2hNahs(~dD5I32{?hj#2r~oi+92h8q5mj6WIiol7I^0~}3;P%z!aFY9 zbDtTPZIAkch!>@5#AEr!iti&#fgk#z=%Vt397%c6?&_`+q!@{WqjnetG#W6D`W*~V z5)o7ivgm;z@?lWL+^9_}Vr(#Nh#2wcpdO?Ir{ep!N5f0$6nn?T@Eywrdr(gGk6>*& zi|+^UehJTqB+f8qd{oNJ1Ak27JY#Qr_UP#78+fmXwzST%x@gPsK+60X=#h{){l~y} zgbc^9$Mt*!bl7=7+4?xJvIW-ZX{>s`1#nX0CxOpOd<*zti9ZcIBk_yC7bN~VFxqoH z{|x+gfv4XDY)D)HrZ~XX^mX7%5`PsqBk+me0Y)51=0p(~ap3qVV6^A>S>VSd{vz;` z68{LeEbz&<0B=aV1zeH%HZa8y`cFO&+>-b!z)ws3W8j+tpF%v?Er}O^yAr<#cvoVI z<3QqHCa!2AcF!I9b4d9cs-=HVH7c~5ch9A{%QNwi&U)S)hQ(Ptg zvm@#B@<*D?M>YJshF{e17c~4W4gZIR|0lsyZ_#jC!;fpYs^LG>@Ib>K)bKqGe^SFQ zXju7)E>3+}qkmh&KNOh4Jav@Nr{An$0|}O&>2(da?kX~y{-B1R)9}k0{|YWQz8{7=A2&(9P3`56tTHGEaWwuV0hEPXityhf+KEBZHq z&ocfw|DOqcb{bgvIs4nd(x2H!H2OU74C9|!3s~yW<3AfcA_VYv_THh;SqA|WryO>syNVmJ@gdNqFJO4@ea_GpLMIJmU^5Uu#3h}nD_w&|_O9b1de z9g?|*lOeOQGj)S~oECgfXzz@I0K3D97DK0VTQmSKIH>!5FS6o&Ej0FeI053wv3A^B zC0`P!E%eLTcaz3etdQ9|1HbJIntV$qebq^;*is`-@(cx+Yy5n}Y&u*GR%oy2?S#z6 zW}hNc<40U(M}DM~N)5vfT#oH-;a~_IF5H4b3O}`m9vO=qWMm^bySOq!dbnnwC z*K-4${ko)ibI;i!W73FnQAHhgX)DX-dgOulYtD6c`@^|GZ!otf4$5;O&i=O#<`~a% zGaB`Jk98RQT8=KwXUy~y0e=)PXU+UlzK~nY7m6`lDzXkX+FUd%M6>DQe9_E;Gw{6~ z&dL2!CE>0g2!r`VHkVymEEMT4l#Otv*rB6pY;Pf!oG)e<7BrDW+oC43xUi7ZrDFG% zG@;9;rbh*#Fd@)G#D%w4Von~tW?g@TF(CpsAF~R?+V}fi!9YkUqGp<1y?RxU5IP=Y z_L$5@>tN`HkL|L#Q5ekiz0P3Nb?3sU+xJ1V`+j@WTW(#-QhLJdyxl>zxPr`lCYLSR z!zfq=7iu2`c_9rVr?;KZ6^zVcUQkB8u>XG9_{t)u(KQcI^68A3Eo98aqD>V9vL9VC$vtwQkY+e6)&||yF2TGCc1#xxYgdzEhuETs$P_NN#gzTyah@jITS%$YL zQ}Pyl6u~L7xG|4riVAP3_3={E!2a9bwsyDfBq!d;9C>~JCQ-jm{ ze%~L3x`*(kP*e=vN#Ta)-ihRNL<&*Tq!7sw=|UzFZ={pNj!(7|UZUE=f;#o;ehLT4 zT1lRX$sB5*%q^)JDvs%m?JcF5I{wEr434m%s4IT=K$ad4grX~3NEaECm8yrn;r6h0 zc^x-aY+`JMg+S5eT0ohF0wgeBjCnL2OGY-IF%w2ZUTZ1lg3f$5BB~e|6G`GT&*v#W zQiNOKMGI@Hz$Vu-X-L#NZiFzj9GcfeutbI7-gL*KYaB@xg(WW&n{<~r9%7mmFwIB- z%j-_C7kP#yTV()4(Y!*HF6pc2>k1YdS58%#ED{8*H*w=A6V4Y{*@5f=pPXdlxF&en zm>79fq^OHbw!nR(2`d@b(92!IYBd?*q^K~irS^#tV`2=4g=n`QHpSLS20j@uI$e%W zG>X%zsZGpb+SGPqeB+{Ln}#W-Ghy%za-fI!SO!G4sZ_Kr6!%&VXA|RDO>&c7Bral5 zk8dk=2WfQY3tl{TifD)#m2bDmUKS&jG7|?w@b$zBH)v%NlabC7g&5zq2?3sRDCUb3 z3MQGP^`@pMLN(2du~3F%?Sw|YSkd&JRHAAv1o(1lX0AX$6r)y5q7HL${b2!$sKWKi z09V!_WhU8l^FXO_4DGoE?q6{t_(@)_q%lUuw%S@^vV0lJ@}B_4$0aYBHnz97oBj8z z87L{0Mxv5?q*gAhG^$i4ti~R}rr16v6bu8mTC>Zg=7wFf*ETDbT`g@{w$*6V8q4#U zl~UPWt!-_Us%5*fS+(r7N@-nk&CFJLrd}znqPGC(q%Nhx zF`wDmuCzAml^b^1T0^kPcJs#8O0A*<%*=N6jXBv&!>W{8o7WJFsnM+!pCV2&(4xZUk zx!katDqtp$*c&h~!Iv71(ha+1HMWpol@VDlW=8xzVy~4@ie(wNEb6FMEpN6qYgG|> z>uKb>*`#-?x?0<=LR})BLw8pzrR}C=mnf2TyJB6lR2r~;QTR~OH|(|T>MGZYNN?*I z&n|GGHS4;au#o$eO;udk#YD~hM3#7b>b0hDU5QZPD%dx+p@~++Jz68dQ&) z=| z^CphXoQ@{i@<{svPBwA;xZf>BEO2ZmMxCdI@j+ir&&L>i&!l1%i);JKb$+_T@7nq$ z4=mHBk{!EzPz-)o5~~}d#@8==Bf_s_6#ssg5sI&0s)&W3M|(cabdFenrH9AwLZFQA z7MRL{e#s=5*q=?TKZ1^p)a0d%a&6cF;wLt`{^C?5VC;g2>%ft9=h(#xI63SFo^a#^ zh`42dnsymbolValue = right; + return(right); + + case LOGICAL_OR: + return(left || right); + + case LOGICAL_XOR: + return((left && !right) || (!left && right)); + + case LOGICAL_AND: + return(left && right); + + case BITWISE_OR: + return(left | right); + + case BITWISE_XOR: + return(left ^ right); + + case BITWISE_AND: + return(left & right); + + case EQUAL_TO: + return(left == right); + + case NOT_EQUAL_TO: + return(left != right); + + case LESS_THAN: + return(left < right); + + case LESS_THAN_OR_EQUAL_TO: + return(left <= right); + + case GREATER_THAN: + return(left > right); + + case GREATER_THAN_OR_EQUAL_TO: + return(left >= right); + + case LEFT_SHIFT: + return(left << right); + + case RIGHT_SHIFT: + return(left >> right); + + case ADD: + return(left + right); + + case SUB: + return(left - right); + + case MUL: + return(left * right); + + case DIV: + return(left / right); + + case MOD: + return(left % right); + } +} + + addressType +evaluateBlock() +{ + while (*pc != END_TAG) { + evaluateExpression(); + if (hitFreturn) + while (*pc != END_TAG) + skipExpression(); + } + overByte(); + return(0); +} + + addressType +evaluateConditionCode() +{ + overByte(); + error(CONDITION_CODE_EXPRESSION_ENCOUNTERED_ERROR); + return(0); +} + + void +pushSymbol(symbol, value) + symbolType *symbol; + addressType value; +{ + bindingListType *newBinding; + + newBinding = typeAlloc(bindingListType); + newBinding->boundSymbol = symbol; + newBinding->previousClass = symbol->symbolClass; + symbol->symbolClass = SYMBOL_LOCAL; + newBinding->previousValue = symbol->symbolValue; + symbol->symbolValue = value; + newBinding->nextBinding = localBindings; + localBindings = newBinding; +} + + void +bindFunctionArguments(theFunction, argCount) + functionType *theFunction; + int argCount; +{ + argumentListType *argList; + + argList = theFunction->functionArguments; + while (argCount > 0) { + if (argList == NULL) { + error(TOO_MANY_FUNCTION_ARGUMENTS_ERROR); + while (argCount-- > 0) + skipExpression(); + } else { + pushSymbol(argList->argumentSymbol, + evaluateExpression()); + argList = argList->nextArgument; + argCount--; + } + } + while (argList != NULL) { + pushSymbol(argList->argumentSymbol, 0); + argList = argList->nextArgument; + } +} + + void +undoBindings() +{ + bindingListType *deadBinding; + + while (localBindings != NULL) { + localBindings->boundSymbol->symbolClass = localBindings-> + previousClass; + localBindings->boundSymbol->symbolValue = localBindings-> + previousValue; + deadBinding = localBindings; + localBindings = localBindings->nextBinding; + free(deadBinding); + } +} + + addressType +evaluateFreturn() +{ + hitFreturn = TRUE; + functionResult = evaluateExpression(); + return(0); +} + + addressType +evaluateBuiltinFunctionCall() +{ + int theFunction; + int argCount; + + theFunction = getNumber(); + nextByte(argCount); + if (theFunction<0 || MAX_FUNCTIONS<=theFunction) { + printf("illegal built-in function #%d\n", theFunction); + chokePukeAndDie(); + } + return((*builtInFunctionTable[theFunction].functionEntry)(argCount)); +} + + addressType +evaluateFunctionCall() +{ + expressionPCType savePoint; + functionType *theFunction; + int argCount; + bindingListType *saveBindings; + + theFunction = getFunction(); + nextByte(argCount); + saveBindings = localBindings; + localBindings = NULL; + bindFunctionArguments(theFunction, argCount); + savePoint = pc; + pc = theFunction->functionBody; + evaluateExpression(); + undoBindings(); + localBindings = saveBindings; + pc = savePoint; + if (hitFreturn) { + hitFreturn = FALSE; + return(functionResult); + } else + return(0); +} + + addressType +evaluateHere() +{ + return(here); +} + + addressType +evaluateMdefine() +{ + symbolType *symbol; + + symbol = getSymbol(); + pushSymbol(symbol, evaluateExpression); +} + + addressType +evaluateMdoUntil() +{ + expressionPCType testPoint; + expressionPCType endPoint; + + testPoint = pc; + skipExpression(); + do { + evaluateExpression; + endPoint = pc; + pc = testPoint; + } while (!evaluateExpression()); + pc = endPoint; + return(0); +} + + addressType +evaluateMdoWhile() +{ + expressionPCType testPoint; + expressionPCType endPoint; + + testPoint = pc; + skipExpression(); + do { + evaluateExpression; + endPoint = pc; + pc = testPoint; + } while (evaluateExpression()); + pc = endPoint; + return(0); +} + + addressType +evaluateMfor() +{ + expressionPCType testPoint; + expressionPCType incrPoint; + expressionPCType endPoint; + expressionPCType bodyPoint; + + evaluateExpression(); + testPoint = pc; + if (evaluateExpression()) { + incrPoint = pc; + skipExpression(); + bodyPoint = pc; + do { + pc = bodyPoint; + evaluateExpression(); + endPoint = pc; + pc = incrPoint; + evaluateExpression(); + pc = testPoint; + } while (evaluateExpression()); + pc = endPoint; + } else { + skipExpression(); + skipExpression(); + } + return(0); +} + + addressType +evaluateMif() +{ + if (evaluateExpression()) { + evaluateExpression(); + skipExpression(); + } else { + skipExpression(); + evaluateExpression(); + } + return(0); +} + + bool +evaluateClause(pattern) + addressType pattern; +{ + bool match; + + match = FALSE; + while (*pc != BLOCK_TAG) + if (match) + skipExpression(); + else + match = (evaluateExpression() == pattern); + if (match) + evaluateExpression(); + else + skipExpression(); + return(match); +} + + addressType +evaluateMswitch() +{ + addressType pattern; + + pattern = evaluateExpression(); + while (*pc != END_TAG) + if (evaluateClause(pattern)) + break; + while (*pc != END_TAG) + skipClause(); + overByte(); + return(0); +} + + addressType +evaluateMwhile() +{ + expressionPCType testPoint; + expressionPCType endPoint; + + testPoint = pc; + if (evaluateExpression()) { + do { + evaluateExpression(); + endPoint = pc; + pc = testPoint; + } while (evaluateExpression()); + pc = endPoint; + } else { + skipExpression(); + } +} + + addressType +evaluateMvariable() +{ + symbolType *symbol; + + symbol = getSymbol(); + pushSymbol(symbol, evaluateExpression); +} + + addressType +evaluateNumber() +{ + addressType result; + int i; + int shift; + + result = 0; + for (i=0, shift=0; isymbolValue++); + + case DECREMENT: + return(target->symbolValue--); + } +} + + addressType +evaluatePreop() +{ + int op; + symbolType *target; + + nextByte(op); + target = getSymbol(); + switch (intOp(op)) { + case INCREMENT: + return(++target->symbolValue); + + case DECREMENT: + return(--target->symbolValue); + } +} + + addressType +evaluateString() +{ + addressType result; + + result = (addressType) pc; + while (*pc++ != '\0') + ; + return(result); +} + + addressType +evaluateSymbol() +{ + symbolType *target; + + target = getSymbol(); + return(target->symbolValue); +} + + addressType +evaluateUnop() +{ + int op; + addressType arg; + + nextByte(op); + arg = evaluateExpression(); + switch(intOp(op)) { + case UNARY_MINUS: + return(-arg); + + case LOGICAL_NOT: + return(!arg); + + case BITWISE_NOT: + return(~arg); + + case HI_BYTE: + return((arg & 0xFF00) >> 8); + + case LO_BYTE: + return(arg & 0xFF); + } +} + + addressType +evaluateExpression() +{ + if (pc == NULL) + return(0); + switch (*pc++) { + case IDENTIFIER_TAG: + return(evaluateSymbol()); + + case FUNCTION_CALL_TAG: + return(evaluateFunctionCall()); + + case BUILTIN_FUNCTION_CALL_TAG: + return(evaluateBuiltinFunctionCall()); + + case NUMBER_TAG: + return(evaluateNumber()); + + case RELOCATABLE_TAG: + return(evaluateRelocatableNumber()); + + case CONDITION_CODE_TAG: + return(evaluateConditionCode()); + + case SUBEXPRESSION_TAG: + return(evaluateExpression()); + + case UNOP_TAG: + return(evaluateUnop()); + + case BINOP_TAG: + return(evaluateBinop()); + + case PREOP_TAG: + return(evaluatePreop()); + + case POSTOP_TAG: + return(evaluatePostop()); + + case HERE_TAG: + return(evaluateHere()); + + case STRING_TAG: + return(evaluateString()); + + case ARRAY_TAG: + return(evaluateArray()); + + case VALUE_TAG: + return(evaluateNumber()); + + case NULL_TAG: + return(0); + + case BLOCK_TAG: + return(evaluateBlock()); + + case MDEFINE_TAG: + return(evaluateMdefine()); + + case MVARIABLE_TAG: + return(evaluateMvariable()); + + case MIF_TAG: + return(evaluateMif()); + + case MFOR_TAG: + return(evaluateMfor()); + + case MWHILE_TAG: + return(evaluateMwhile()); + + case MDOWHILE_TAG: + return(evaluateMdoWhile()); + + case MDOUNTIL_TAG: + return(evaluateMdoUntil()); + + case PERFORM_TAG: + return(evaluatePerform()); + + case GROUP_TAG: + return(evaluateBlock()); + + case ASSERT_TAG: + return(evaluateAssert()); + + case MSWITCH_TAG: + return(evaluateMswitch()); + + case CLAUSE_TAG: + error(CLAUSE_AT_TOP_LEVEL_ERROR); + chokePukeAndDie(); + + case FRETURN_TAG: + return(evaluateFreturn()); + + case END_TAG: + return(0); + } +} + + void +skipArray() +{ + overSymbol(); + skipExpression(); +} + + void +skipAssert() +{ + skipExpression(); + skipString(); +} + + void +skipBinop() +{ + overByte(); + skipExpression(); + skipExpression(); +} + + void +skipBlock() +{ + while (*pc != END_TAG) + skipExpression(); + overByte(); +} + + void +skipFunctionCall() +{ + int argCount; + + overFunction(); + nextByte(argCount); + while (argCount-- > 0) + skipExpression(); +} + + void +skipMdefine() +{ + overSymbol(); + skipExpression(); +} + + void +skipMdoUntil() +{ + skipExpression(); + skipExpression(); +} + + void +skipMdoWhile() +{ + skipExpression(); + skipExpression(); +} + + void +skipMfor() +{ + skipExpression(); + skipExpression(); + skipExpression(); + skipExpression(); +} + + void +skipMif() +{ + skipExpression(); + skipExpression(); + skipExpression(); +} + + void +skipClause() +{ + while (*pc != BLOCK_TAG) + skipExpression; + skipBlock(); +} + + void +skipMswitch() +{ + skipExpression(); + while (*pc != END_TAG) + skipClause(); + overByte(); +} + + void +skipMvariable() +{ + overSymbol(); + skipExpression(); +} + + void +skipMwhile() +{ + skipExpression(); + skipExpression(); +} + + void +skipPostop() +{ + overByte(); + skipExpression(); +} + + void +skipPreop() +{ + overByte(); + skipExpression(); +} + + void +skipString() +{ + while (*pc++ != '\0') + ; +} + + void +skipUnop() +{ + overByte(); + skipExpression(); +} + + void +skipExpression() +{ + if (pc == NULL) + return; + switch (*pc++) { + case IDENTIFIER_TAG: + overSymbol(); + break; + + case FUNCTION_CALL_TAG: + skipFunctionCall(); + break; + + case NUMBER_TAG: + case RELOCATABLE_TAG: + overNumber(); + break; + + case CONDITION_CODE_TAG: + overByte(); + break; + + case SUBEXPRESSION_TAG: + skipExpression(); + break; + + case UNOP_TAG: + skipUnop(); + break; + + case BINOP_TAG: + skipBinop(); + break; + + case PREOP_TAG: + skipPreop(); + break; + + case POSTOP_TAG: + skipPostop(); + break; + + case HERE_TAG: + break; + + case STRING_TAG: + skipString(); + break; + + case ARRAY_TAG: + skipArray(); + break; + + case VALUE_TAG: + overNumber(); + break; + + case NULL_TAG: + break; + + case BLOCK_TAG: + skipBlock(); + break; + + case MDEFINE_TAG: + skipMdefine(); + break; + + case MVARIABLE_TAG: + skipMvariable(); + break; + + case MIF_TAG: + skipMif(); + break; + + case MFOR_TAG: + skipMfor(); + break; + + case MWHILE_TAG: + skipMwhile(); + break; + + case MDOWHILE_TAG: + skipMdoWhile(); + break; + + case MDOUNTIL_TAG: + skipMdoUntil(); + break; + + case PERFORM_TAG: + skipExpression(); + break; + + case GROUP_TAG: + skipBlock(); + break; + + case ASSERT_TAG: + skipAssert(); + break; + + case MSWITCH_TAG: + skipMswitch(); + break; + + case CLAUSE_TAG: + skipClause(); + break; + + case END_TAG: + break; + } +} diff --git a/slinky/expr.o b/slinky/expr.o new file mode 100644 index 0000000000000000000000000000000000000000..9beb0664dd0afc575731b74947a55fdbf8a891ce GIT binary patch literal 29138 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 = FIRST_AVAILABLE_LOCATION; + freeSegmentList->segmentEndAddress = LAST_AVAILABLE_LOCATION; + freeSegmentList->nextFreeSegment = NULL; + + outputFilesFound = 0; + outputFileName = DEFAULT_LOAD_FILE_NAME; + mapFilesFound = 0; + mapFileName = NULL; + + args = argv + 1; + for (i=1; i= argc) { + error(NO_LOAD_ADDRESS_ERROR); + chokePukeAndDie(); + } else { + queueLoadAddress(*args++); + } + continue; + + case 'm': + if (++i >= argc) { + error(NO_MAP_FILE_NAME_ERROR); + chokePukeAndDie(); + } else { + mapFileName = *args++; + mapFilesFound++; + } + produceLoadMap = TRUE; + continue; + + case 'n': + leaveOffLoadFiles = TRUE; + continue; + + case 'o': + if (++i >= argc) { + error(NO_DASH_O_FILE_NAME_ERROR); + chokePukeAndDie(); + } else { + outputFileName = *args++; + outputFilesFound++; + } + continue; + + case 'p': + packFlag = TRUE; + continue; + + case 'v': + printVersion(); + continue; + + default: + error(BAD_COMMAND_LINE_FLAG_ERROR, arg[j]); + continue; + } + } + + if (outputFilesFound > 1) { + error(MORE_THAN_ONE_OUTPUT_FILE_ERROR); + chokePukeAndDie(); + } else if ((loadFileOutput = fopen(outputFileName, "w"))==NULL) { + error(CANT_OPEN_LOAD_FILE_ERROR, outputFileName); + perror("Unix says"); + chokePukeAndDie(); + } + + if (mapFilesFound > 1) { + error(MORE_THAN_ONE_MAP_FILE_ERROR); + chokePukeAndDie(); + } else if (mapFilesFound == 1) { + if (strcmp(mapFileName, "-") == 0) { + mapFileOutput = stdout; + } else if ((mapFileOutput = fopen(mapFileName, "w")) == NULL){ + error(CANT_OPEN_MAP_FILE_ERROR, mapFileName); + perror("Unix says"); + chokePukeAndDie(); + } + } + currentFileName = outputFileName; +} + + + void +queueInputFile(name) + char *name; +{ + objectFileListType *newObjectFile; + + newObjectFile = typeAlloc(objectFileListType); + newObjectFile->name = name; + newObjectFile->symbolTable = NULL; + newObjectFile->codeSegments = NULL; + newObjectFile->lastCodeSegment = NULL; + newObjectFile->nextObjectFile = NULL; + if (objectFileList == NULL) { + objectFileList = endOfObjectFileList = newObjectFile; + } else { + endOfObjectFileList->nextObjectFile = newObjectFile; + endOfObjectFileList = newObjectFile; + } +} + + void +queueLoadAddress(addressString) + char *addressString; +{ + int loadAddress; + objectFileListType *newObjectFile; + + if (sscanf(addressString, "0x%x", &loadAddress) != 1) { + if (sscanf(addressString, "0X%x", &loadAddress) != 1) { + if (sscanf(addressString, "%x", &loadAddress) != 1) { + error(BAD_LOAD_ADDRESS_ERROR, addressString); + chokePukeAndDie(); + }}} + newObjectFile = typeAlloc(objectFileListType); + newObjectFile->name = NULL;/* NULL name encodes load address change */ + newObjectFile->symbolCount = loadAddress; /* then address goes here */ + newObjectFile->nextObjectFile = NULL; + if (objectFileList == NULL) { + objectFileList = endOfObjectFileList = newObjectFile; + } else { + endOfObjectFileList->nextObjectFile = newObjectFile; + endOfObjectFileList = newObjectFile; + } +} diff --git a/slinky/initialize.o b/slinky/initialize.o new file mode 100644 index 0000000000000000000000000000000000000000..e3cd73efab7c189f951f96d9d498e7a6af800f84 GIT binary patch literal 12599 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 F{{YkeAjtp# literal 0 HcmV?d00001 diff --git a/slinky/instantiate.c b/slinky/instantiate.c new file mode 100644 index 0000000..eb41b49 --- /dev/null +++ b/slinky/instantiate.c @@ -0,0 +1,317 @@ +/* + instantiate.c -- Slinky linker routines to walk expression tree and + replace symbol ordinals with symbol pointers. + + Chip Morningstar -- Lucasfilm Ltd. + + 11-November-1985 +*/ + +#include "slinkyTypes.h" +#include "slinkyGlobals.h" +#include "slinkyExpressions.h" +#include "y.tab.h" + +#define overFunction() (pc+=sizeof(functionType *)) +#define overNumber() (pc+=sizeof(addressType)) +#define overByte() pc++ +#define nextByte(byt) (byt = *pc++) + +void putSymbolPointersIntoArray(); +void putSymbolPointersIntoClause(); +void putSymbolPointersIntoExpression(); + + void +putNumber(number) + int number; +{ + int i; + for (i=0; i>= 8; + } +} + + void +instantiateSymbol() +{ + int index; + + index = evaluateNumber(); + pc -= sizeof(symbolType *); + putNumber(currentSymbolTable[index]); +} + + void +instantiateFunction() +{ + int index; + + index = evaluateNumber(); + pc -= sizeof(functionType *); + putNumber(&(currentFunctionTable[index])); +} + + void +putSymbolPointersIntoArray() +{ + instantiateSymbol(); + putSymbolPointersIntoExpression(); +} + + void +putSymbolPointersIntoAssert() +{ + putSymbolPointersIntoExpression(); + skipString(); +} + + void +putSymbolPointersIntoBinop() +{ + overByte(); + putSymbolPointersIntoExpression(); + putSymbolPointersIntoExpression(); +} + + void +putSymbolPointersIntoBlock() +{ + while (*pc != END_TAG) + putSymbolPointersIntoExpression(); + overByte(); +} + + void +putSymbolPointersIntoBuiltinFunctionCall() +{ + int argCount; + + overNumber(); + nextByte(argCount); + while (argCount-- > 0) + putSymbolPointersIntoExpression(); +} + + void +putSymbolPointersIntoFunctionCall() +{ + int argCount; + + instantiateFunction(); + nextByte(argCount); + while (argCount-- > 0) + putSymbolPointersIntoExpression(); +} + + void +putSymbolPointersIntoMdefine() +{ + instantiateSymbol(); + putSymbolPointersIntoExpression(); +} + + void +putSymbolPointersIntoMdoUntil() +{ + putSymbolPointersIntoExpression(); + putSymbolPointersIntoExpression(); +} + + void +putSymbolPointersIntoMdoWhile() +{ + putSymbolPointersIntoExpression(); + putSymbolPointersIntoExpression(); +} + + void +putSymbolPointersIntoMfor() +{ + putSymbolPointersIntoExpression(); + putSymbolPointersIntoExpression(); + putSymbolPointersIntoExpression(); + putSymbolPointersIntoExpression(); +} + + void +putSymbolPointersIntoMif() +{ + putSymbolPointersIntoExpression(); + putSymbolPointersIntoExpression(); + putSymbolPointersIntoExpression(); +} + + void +putSymbolPointersIntoClause() +{ + while (*pc != BLOCK_TAG) + putSymbolPointersIntoExpression(); + putSymbolPointersIntoBlock(); +} + + void +putSymbolPointersIntoMswitch() +{ + putSymbolPointersIntoExpression(); + while (*pc != END_TAG) + putSymbolPointersIntoClause(); + overByte(); +} + + void +putSymbolPointersIntoMvariable() +{ + instantiateSymbol(); + putSymbolPointersIntoExpression(); +} + + void +putSymbolPointersIntoMwhile() +{ + putSymbolPointersIntoExpression(); + putSymbolPointersIntoExpression(); +} + + void +putSymbolPointersIntoPostop() +{ + overByte(); + putSymbolPointersIntoExpression(); +} + + void +putSymbolPointersIntoPreop() +{ + overByte(); + putSymbolPointersIntoExpression(); +} + + void +putSymbolPointersIntoUnop() +{ + overByte(); + putSymbolPointersIntoExpression(); +} + + void +putSymbolPointersIntoExpression() +{ + if (pc == NULL) + return; + switch (*pc++) { + case IDENTIFIER_TAG: + instantiateSymbol(); + break; + + case FUNCTION_CALL_TAG: + putSymbolPointersIntoFunctionCall(); + break; + + case BUILTIN_FUNCTION_CALL_TAG: + putSymbolPointersIntoBuiltinFunctionCall(); + break; + + case NUMBER_TAG: + case RELOCATABLE_TAG: + overNumber(); + break; + + case CONDITION_CODE_TAG: + overByte(); + break; + + case SUBEXPRESSION_TAG: + putSymbolPointersIntoExpression(); + break; + + case UNOP_TAG: + putSymbolPointersIntoUnop(); + break; + + case BINOP_TAG: + putSymbolPointersIntoBinop(); + break; + + case PREOP_TAG: + putSymbolPointersIntoPreop(); + break; + + case POSTOP_TAG: + putSymbolPointersIntoPostop(); + break; + + case HERE_TAG: + break; + + case STRING_TAG: + skipString(); + break; + + case ARRAY_TAG: + putSymbolPointersIntoArray(); + break; + + case VALUE_TAG: + overNumber(); + break; + + case NULL_TAG: + break; + + case BLOCK_TAG: + putSymbolPointersIntoBlock(); + break; + + case MDEFINE_TAG: + putSymbolPointersIntoMdefine(); + break; + + case MVARIABLE_TAG: + putSymbolPointersIntoMvariable(); + break; + + case MIF_TAG: + putSymbolPointersIntoMif(); + break; + + case MFOR_TAG: + putSymbolPointersIntoMfor(); + break; + + case MWHILE_TAG: + putSymbolPointersIntoMwhile(); + break; + + case MDOWHILE_TAG: + putSymbolPointersIntoMdoWhile(); + break; + + case MDOUNTIL_TAG: + putSymbolPointersIntoMdoUntil(); + break; + + case PERFORM_TAG: + putSymbolPointersIntoExpression(); + break; + + case GROUP_TAG: + putSymbolPointersIntoBlock(); + break; + + case ASSERT_TAG: + putSymbolPointersIntoAssert(); + break; + + case MSWITCH_TAG: + putSymbolPointersIntoMswitch(); + break; + + case CLAUSE_TAG: + putSymbolPointersIntoClause(); + break; + + case END_TAG: + break; + } +} diff --git a/slinky/instantiate.o b/slinky/instantiate.o new file mode 100644 index 0000000000000000000000000000000000000000..b4ff97b832ecfd7ddf6957c1e9e3c8a6d499ee5b GIT binary patch literal 14342 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 + if ((objectFildes = fopen(objectFile->name, "r")) == NULL) { + error(CANT_OPEN_OBJECT_FILE_ERROR, objectFile->name); + perror("Unix says"); + return(FALSE); + } + if (verbose) + printf("internalizing %s:\n", objectFile->name); + if ((magic = readWord(objectFildes, objectFile->name)) != 0xFFFF) { + error(BAD_OBJECT_FILE_ERROR, objectFile->name); + return(FALSE); + } + mode = MODE_ABSOLUTE; + for (;;) { + startAddress = readWord(objectFildes, objectFile->name); + if (startAddress == 0xFFFF) { + if (mode == MODE_ABSOLUTE) { + mode = MODE_RELOCATABLE; + continue; + } else { + break; + } + } + endAddress = readWord(objectFildes, objectFile->name); + readCode(startAddress, endAddress, mode, objectFile, + objectFildes); + } + readReservations(objectFile, objectFildes); + readReferences(objectFile, objectFildes); + readSymbols(objectFile, objectFildes); + readExpressions(objectFile, objectFildes); + readFunctions(objectFile, objectFildes); + instantiateExpressionAndSymbolPointers(objectFile); + if (readExpressionEntryPoint) { + pc = entryPointExpression; + putSymbolPointersIntoExpression(); + readExpressionEntryPoint = FALSE; + haveExpressionEntryPoint = TRUE; + } + qsort(objectFile->symbolTable, objectFile->symbolCount, + sizeof(symbolType *), compareSymbolValues); + fclose(objectFildes); + return(TRUE); +} + +#define toLowerCase(c) (('A'<=(c)&&(c)<='Z')?((c)-'A'+'a'):(c)); + + bool +strcmplc(s1, s2) + char *s1; + char *s2; +{ + register char c1; + register char c2; + int result; + + do { + c1 = *s1++; + c1 = toLowerCase(c1); + c2 = *s2++; + c2 = toLowerCase(c2); + + /* if result != 0, they differ */ + if (result = c1 - c2) { + return(result); /* c1c2==pos */ + } else if (!c1) { /* if they're null, we're done */ + return(0); + } + } while (TRUE); +} + + bool +compareSymbols(symbol1, symbol2) + symbolType **symbol1; + symbolType **symbol2; +{ + bool result; + + result = strcmplc((*symbol1)->symbolName, (*symbol2)->symbolName); + if (result == 0 && (((*symbol1)->symbolClass & ~SYMBOL_EXTERNAL) && + ((*symbol2)->symbolClass & ~SYMBOL_EXTERNAL))) { + error(MULTIPLY_DEFINED_SYMBOL_ERROR, (*symbol1)->symbolName); + (*symbol2)->symbolClass &= ~SYMBOL_ABSOLUTE; + (*symbol2)->symbolClass &= ~SYMBOL_RELOCATABLE; + } + return(result); +} + + void +buildGlobalSymbolTable(inputFileList) + objectFileListType *inputFileList; +{ + int symbolCount; + symbolType **symbol; + symbolType **globalSymbolPtr; + + globalSymbolTable = typeAllocBlock(symbolType *, globalSymbolCount); + globalSymbolPtr = globalSymbolTable; + for (; inputFileList != NULL; inputFileList = inputFileList-> + nextObjectFile) { + if (inputFileList->name != NULL) { + for (symbol = inputFileList->symbolTable, + symbolCount = inputFileList-> + symbolCount; symbolCount>0; symbol++, + symbolCount--) { + if (((*symbol)->symbolClass & + SYMBOL_EXTERNAL) && + ((*symbol)->symbolClass & + ~SYMBOL_EXTERNAL)) { + *globalSymbolPtr++ = (*symbol); + } + } + } + } + qsort(globalSymbolTable, globalSymbolCount, sizeof(symbolType *), + compareSymbols); + if (debug) { + printGlobalSymbols(); + } +} + + bool +readem() +{ + objectFileListType *inputFileList; + + if (objectFileList == NULL) { + error(NO_INPUT_FILES_ERROR); + return(FALSE); + } + inputFileList = objectFileList; + while (inputFileList != NULL) { + if (inputFileList->name != NULL) + if (!internalizeOneObjectFile(inputFileList)) + return(FALSE); + inputFileList = inputFileList->nextObjectFile; + } + buildGlobalSymbolTable(objectFileList); + return(TRUE); +} + + codeSegmentHeaderType * +locateConflictingSegment(codeSegment) + codeSegmentHeaderType *codeSegment; +{ + segmentListType *segmentPtr; + int segmentListOffset; + int segmentListOffsetStart; + int segmentListOffsetEnd; + addressType start; + addressType end; + + start = codeSegment->segmentStartAddress; + end = codeSegment->segmentEndAddress; +/* segmentListOffsetStart = (start / CODE_REGION_SIZE) - 1; + segmentListOffsetEnd = segmentListOffsetStart + 2; + if (segmentListOffsetStart < 0)*/ + segmentListOffsetStart = 0; +/* if (segmentListOffsetEnd >= CODE_REGIONS_IN_ADDRESS_SPACE)*/ + segmentListOffsetEnd = CODE_REGIONS_IN_ADDRESS_SPACE - 1; + for (segmentListOffset = segmentListOffsetStart; + segmentListOffset <= segmentListOffsetEnd; + segmentListOffset++) { + segmentPtr = generatedLoadImage[segmentListOffset]; + while (segmentPtr != NULL) { + if ((segmentPtr->thisSegment->segmentStartAddress<=start && + start<=segmentPtr->thisSegment->segmentEndAddress) || + (segmentPtr->thisSegment->segmentStartAddress<=end && + end<=segmentPtr->thisSegment->segmentEndAddress)) + return(segmentPtr->thisSegment); + else + segmentPtr = segmentPtr->nextSegment; + } + } + printf("Hey! segment list overrun in locateConflictingSegment\n"); + return(NULL); +} + + void +reserveSegment(start, end) + addressType start; + addressType end; +{ + freeSegmentEntryType *freeSegmentPtr; + freeSegmentEntryType *previousSegmentPtr; + freeSegmentEntryType *newSegmentPtr; + + previousSegmentPtr = NULL; + freeSegmentPtr = freeSegmentList; + while (freeSegmentPtr != NULL && start > freeSegmentPtr-> + segmentEndAddress) { + previousSegmentPtr = freeSegmentPtr; + freeSegmentPtr = freeSegmentPtr->nextFreeSegment; + } + if (end < freeSegmentPtr->segmentStartAddress) { + /* return; */ + } else if (start <= freeSegmentPtr->segmentStartAddress && end < + freeSegmentPtr->segmentEndAddress) { + freeSegmentPtr->segmentStartAddress = end + 1; + } else if (end >= freeSegmentPtr->segmentEndAddress) { + if (start > freeSegmentPtr->segmentStartAddress) + freeSegmentPtr->segmentEndAddress = start - 1; + if (previousSegmentPtr == NULL) { + while (end >= freeSegmentPtr->segmentEndAddress) { + freeSegmentList = freeSegmentPtr-> + nextFreeSegment; + free(freeSegmentPtr); + freeSegmentPtr = freeSegmentList; + } + } else { + while (end >= freeSegmentPtr->segmentEndAddress) { + previousSegmentPtr->nextFreeSegment = + freeSegmentPtr->nextFreeSegment; + free(freeSegmentPtr); + freeSegmentPtr = previousSegmentPtr-> + nextFreeSegment; + } + } + if (end >= freeSegmentPtr->segmentStartAddress) { + freeSegmentPtr->segmentStartAddress = end + 1; + } + } else { + newSegmentPtr = typeAlloc(freeSegmentEntryType); + newSegmentPtr->nextFreeSegment = freeSegmentPtr-> + nextFreeSegment; + freeSegmentPtr->nextFreeSegment = newSegmentPtr; + newSegmentPtr->segmentEndAddress = freeSegmentPtr-> + segmentEndAddress; + freeSegmentPtr->segmentEndAddress = start - 1; + newSegmentPtr->segmentStartAddress = end + 1; + } +} + + codeSegmentHeaderType * +allocateAbsolute(codeSegment) + codeSegmentHeaderType *codeSegment; +{ + freeSegmentEntryType *freeSegmentPtr; + freeSegmentEntryType *previousSegmentPtr; + freeSegmentEntryType *newSegmentPtr; + addressType start; + addressType end; + + previousSegmentPtr = NULL; + freeSegmentPtr = freeSegmentList; + start = codeSegment->segmentStartAddress; + end = codeSegment->segmentEndAddress; + while (freeSegmentPtr != NULL && start > freeSegmentPtr-> + segmentEndAddress) { + previousSegmentPtr = freeSegmentPtr; + freeSegmentPtr = freeSegmentPtr->nextFreeSegment; + } + if (freeSegmentPtr->segmentEndAddress < end || start + segmentStartAddress) + return(locateConflictingSegment(codeSegment)); + if (freeSegmentPtr->segmentStartAddress == start || freeSegmentPtr-> + segmentEndAddress == end) { + if (freeSegmentPtr->segmentStartAddress == start) + freeSegmentPtr->segmentStartAddress = end + 1; + if (freeSegmentPtr->segmentEndAddress == end) + freeSegmentPtr->segmentEndAddress = start - 1; + if (freeSegmentPtr->segmentEndAddress < freeSegmentPtr-> + segmentStartAddress) { + if (previousSegmentPtr == NULL) + freeSegmentList = freeSegmentPtr-> + nextFreeSegment; + else + previousSegmentPtr->nextFreeSegment = + freeSegmentPtr->nextFreeSegment; + free(freeSegmentPtr); + } + } else { + newSegmentPtr = typeAlloc(freeSegmentEntryType); + newSegmentPtr->nextFreeSegment = freeSegmentPtr-> + nextFreeSegment; + freeSegmentPtr->nextFreeSegment = newSegmentPtr; + newSegmentPtr->segmentEndAddress = freeSegmentPtr-> + segmentEndAddress; + freeSegmentPtr->segmentEndAddress = start - 1; + newSegmentPtr->segmentStartAddress = end + 1; + } + return(NULL); +} + + void +reserveReservations() +{ + while (reservationList != NULL) { + reserveSegment(reservationList->startAddress, + reservationList->startAddress + reservationList-> + blockSize - 1); + reservationList = reservationList->nextReservation; + } +} + + void +installSegment(codeSegment) + codeSegmentHeaderType *codeSegment; +{ + segmentListType *previousSegment; + segmentListType *installSegmentList; + segmentListType *newSegmentListEntry; + int regionNumber; + int endRegion; + + regionNumber = regionOf(codeSegment->segmentStartAddress); + previousSegment = NULL; + installSegmentList = generatedLoadImage[regionNumber]; + while (installSegmentList != NULL && installSegmentList->thisSegment-> + segmentStartAddress < codeSegment->segmentStartAddress) { + previousSegment = installSegmentList; + installSegmentList = installSegmentList->nextSegment; + } + newSegmentListEntry = typeAlloc(segmentListType); + newSegmentListEntry->thisSegment = codeSegment; + newSegmentListEntry->nextSegment = installSegmentList; + if (previousSegment == NULL) { + generatedLoadImage[regionNumber] = newSegmentListEntry; + } else { + previousSegment->nextSegment = newSegmentListEntry; + } + if (regionNumber < (endRegion=regionOf(codeSegment->segmentEndAddress))) { + for (regionNumber++; regionNumber <= endRegion; regionNumber++) { + newSegmentListEntry = typeAlloc(segmentListType); + newSegmentListEntry->thisSegment = codeSegment; + newSegmentListEntry->nextSegment=generatedLoadImage[regionNumber]; + generatedLoadImage[regionNumber] = newSegmentListEntry; + } + } +} + + void +installAbsoluteCodeSegment(codeSegment) + codeSegmentHeaderType *codeSegment; +{ + codeSegmentHeaderType *conflictingSegment; + + if ((conflictingSegment = allocateAbsolute(codeSegment)) != NULL) { + error(OVERLAPPING_ABSOLUTE_CODE_SEGMENTS_ERROR, conflictingSegment-> + fileName, conflictingSegment->segmentStartAddress, + conflictingSegment->segmentEndAddress, codeSegment->fileName, + codeSegment->segmentStartAddress, codeSegment->segmentEndAddress); + } else { + installSegment(codeSegment); + } +} + + void +linkem() +{ + if (!readem()) + return; + relocatem(); + valuem(); + pokem(); + writem(); +} diff --git a/slinky/link.o b/slinky/link.o new file mode 100644 index 0000000000000000000000000000000000000000..7c8a07e69f3615d7700a3d98172d74ee4d6a6b14 GIT binary patch literal 17169 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 literal 0 HcmV?d00001 diff --git a/slinky/main.c b/slinky/main.c new file mode 100644 index 0000000..479be17 --- /dev/null +++ b/slinky/main.c @@ -0,0 +1,28 @@ +/* + main.c -- Top level of the Slinky linker + + Chip Morningstar -- Lucasfilm Ltd. + + 9-March-1985 +*/ + +#include "slinkyTypes.h" +#include "slinkyGlobals.h" + +main(argc, argv) + int argc; + char *argv[]; +{ + initializeStuff(argc, argv); + linkem(); + if (errorFlag) + chokePukeAndDie(); + else + exit(0); +} + + void +printVersion() +{ + printf("Slinky version 1.16.\n"); +} diff --git a/slinky/main.o b/slinky/main.o new file mode 100644 index 0000000000000000000000000000000000000000..4302096d84fe273c16e91ba759a46a7381ddd11d GIT binary patch literal 7052 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, entry2-> + symbol->symbolName)) != 0) + return(result); + else if (entry1->symbol->symbolValue < entry2->symbol->symbolValue) + return(-1); + else if (entry1->symbol->symbolValue > entry2->symbol->symbolValue) + return(1); + else + return(strcmplc(entry1->fileName, entry2->fileName)); +} + + void +outputLoadMap() +{ + loadMapTableEntryType *loadMapTable; + loadMapTableEntryType *loadMapPtr; + objectFileListType *inputFileList; + int symbolCount; + int i; + + loadMapPtr = loadMapTable = typeAllocBlock(loadMapTableEntryType, + totalSymbolCount); + for (inputFileList = objectFileList; inputFileList != NULL; + inputFileList = inputFileList->nextObjectFile) { + if (inputFileList->name != NULL) { + for (symbolCount=0; symbolCount < inputFileList->symbolCount; + symbolCount++) { + loadMapPtr->symbol = inputFileList->symbolTable[ + symbolCount]; + loadMapPtr->fileName = inputFileList->name; + loadMapPtr++; + } + } + } + qsort(loadMapTable, totalSymbolCount, sizeof(loadMapTableEntryType), + compareLoadMapEntries); + loadMapPtr = loadMapTable; + for (i=0; isymbol->symbolName, + (loadMapPtr-1)->symbol->symbolName)==0 && + loadMapPtr->symbol->symbolValue==(loadMapPtr- + 1)->symbol->symbolValue && loadMapPtr-> + symbol->symbolClass==(loadMapPtr-1)->symbol-> + symbolClass) { + if (!leaveOffLoadFiles) + fprintf(mapFileOutput, ", %s", loadMapPtr-> + fileName); + } else { + fprintf(mapFileOutput, "\n"); + printLoadMapSymbol(loadMapPtr->symbol); + if (!leaveOffLoadFiles) + fprintf(mapFileOutput, " %s", loadMapPtr-> + fileName); + } + loadMapPtr++; + } + fprintf(mapFileOutput, "\n"); +} diff --git a/slinky/map.o b/slinky/map.o new file mode 100644 index 0000000000000000000000000000000000000000..57eea564d7af51113370475789ba2ac768b2269d GIT binary patch literal 8770 zcmai2du&@*89#ocNw;oG+iY}O**sR(rkEzzaS}JCG){c;V2+*HPDjzETgSdmy*hU0 zM_Cbw02-PYh=O2D2&6ETiGPqLG1!DA(m#0Y4?s~hO=W@-jjD_-n#xq9NOXkXcOLhi zI4f96?(crzcfR*|+~e_i+8OhGnlaXiKm0oOil=9lp1z|S8((JmXMgy&MbFj!OY!&i zFHNkpFU2o-8C&t5=y&S?HGo<2Y)O3m#;6LWgQ^5@%Q%S>z#}2e!>?a z|AvpTOTH8SRp@!s&)8-E3IF1`#oO+X@@G4bZb1G+B!30+Z~4!&x7z~#HORl)w#crw zt@;5!JGkV%=pDZKjrQgBi}w$+OL(qg9OdQB`&a#!@qW&~)NvU; zT!H-a{#DNv=c74lybInF>^q%-jt>Dpvul+N<4OEA z)ME|$;N#l6?aONhXjiud*y4}R?}3jGNgZplhKJ}KF|WVo9Y%hZI$j69=-pVq;0ri4 zC)r)H#uUpX-xt?ceXIUAfiI&9SNuz;@%c{3+(r7}_xjsyN7vVG8D{Wd{c78J_TH_? z;q$|HKxQY&sGLjPH@SYC@Kb!>-gUx}8OA&DQRh4Lu}V(yQIqu*)JnapJW=gnm)k&H z5bM$nZBYErpx+B{b{u2Qt#%}%U#>U2L zz~?0%23}+A&ZqFC-&NqJ1!U`t?IrmRM2 zZ9L!I>K~Ma3 zX?UN84{A87;c1C!d_kk1(r`nQ`I<)mu7;o2@GBbrt%mv#(I3(9e1VVSW51)}?=QOaUu*c1i+$TQ{4otDHQdnfGa7zL z!z&toN5dN~_V4^MQ$PQG8Xka5*T%-bc`Bb%BFz5^=pI4$zY6S?_#&`h;5psp8^E%?cb)^rdPl#V zuLNBD7hvhb&VRXh*R2}f2Q2mM8rJB?G+fp2lN$c9hJOPrec1I^jZU#k`tIGpSflB; zyEov{CxE4&yH5a1e|A5n(N6<+GXC5BG_cg8=YRJv7oFbg^6hhUb_JG%d>knrlz4*S z2f`inq@Tp7K^OHi>b`NE=;tw~@Zhz9%v~D38yF=1Z!aFx5`P%ahQ#;axhV0yc%GB^ zK0IF_yejms5Qegk-~rr~*+&G<=JW?z@ET-Fi#%TPv+D~IuLFM*7(Ksn4fq@|#c~z+ z7ZPKv6Boy@dk7?jdr$(NU(gL;?h0@S82cypryn>g@c{6G#Dl<#5|jMbB_^Fq5`O~t zMTw69zb5e~f&VNq%y|$Cw`C$lpO<(H_^ia^8lD7xS<*iRj2!Z@4+5`BoB&2nIDJaP zDeU=Ok`5ny0f`?14ijF5FfhjRv1x(3eq~i>AG7m~u~OMilH(LhPuGOlwv2qTQHM?%tPUnazOy!%k8tk@=Sjgp1i2>l%&P-Qf z+I(UGqw5&Sta_uCpI<2Fp}SZ_gr(E=SZffE*Q+&z>?(*A3Zwv0=T6(MHq)`dthsV^ zHdhwWN#}LaXth~^%9>rS=6MXMVzF+6lCRD$V3g%g=4xCtBt%2q z(cY*L0;gQ9%yCZN|5Z{yi9X=6VOO>id_ge_WB*k-e{=5UlVb) z4QMh0{r!Eql;hr@CiHPb)1#6QX%Q$Q)xz7u4kwJLS)tm*WD<$%byyK%ovxM&f`OD$ zMvZQE^ypDRLh5*u*&$hm?3o3-e&{6YY1V5!rAofsEZ9BuMxj&%(JEDEo5i8*fe@9a z9_qF7s1{cc><#vXqSivAHUuuz9t63+8$?c@&DCwe2o8h=rCF?(J|_ns9^kYhRso`f zyMsn35;O*)7PStMLLi01!ALa9X3sQ4r2XCOv(;LGT;|aXbThKwIAD-_eq{1wtzIw0t13}L)j7aS4^@%2qo3<|bxgamQ4oU7N# zUxW_xQ9(VHD>r!*hDwN_)9e_6w`f!H7BPzCM49a@XVat75M>qa^5ue7$4sNv%r{UB z1Nnjn1G89v3K{MjDMgna!~;rsX|Oz=E>)X#-9r>75>*V{N#RDtexf1QCsK%(CWR=D zC>JW>dgEjxjFi>pnrgeyyhOLxBZ{Z{DI6qgF*%aVq4&w$ph{VElU~Q(U^gqO4MjA9 z5ya%EM-+9WS~w$Hk0(OWl`WKujLA;bQ=hhr*a0hf+c9QfZq*|-MVEU9)f);>z;M*z z(LyX4p>WV}8ELzW-Ql#u?AMtOBBN>)=7c-Se4=63D!H;^9@a;>OEtxU34Wv*E>%XW zH5j3`5eY6;Xe%HEXhWWgs1tM^-pWmW0&Blr)9PkWgNMUZA1T7E@TP?|rM`9FlZM0s zkgrxSwQ{tsiDZcm%ayUTQmaU+Xso(8ZDbm`T4QsHX;r{7BL&P#p@lub!;)-O0Zc{X zFm<}5k0REQCQb%&sS1WrAZUGrImP2Ut_&d5&le{-*y#!0HU?%MH7WWc7>aP;Xu)#l zHS~&1vn?5Rn+o$2Ig=*(l}YFXGBV5;@t_O)8+icAg8RFTGt#_K)?Y zX_{g=yI~FV6mO}3s5Z5VcH-h*%js-jKC4Bp)eF}}OzO>tQ{6$D-Qh^ZSvy5G#EQy~ zWn?denM##$k|FqdVTBvCGl|7W=ZQwddTJL-*!zV5FF6$R%?S^VI1?HChPp?Ua_apln91nM5D*xMOTaxeA<#0FV$fh&8R+tdqhC=nN)0Vf)EKaJYGNsR{707Lsw5yVPq;@XsG^$lv ztU4aSCgUFvE(O!TPNuAQEHh!Htg*?2X(eM*re&tnsq|29a3mJDMpIK$v1HszOeRfh zED;-*Tq8J@N}E=8B9^pLV5MfV(=%D2M2rswM`OvXm6|q_Rw4ye+<@TqX}r|Pr_9k! zBf~*>HJMcUGSXx}cWA5lKyW&3PQ|h_@W)JzN$J7hBa9of(q=3^nH;yYkwcMS>X?~M z#HOc-6C25-5;Iv7(Z)?HV~$Um$*eMan7o-z#6}S<0D{z|R62TtQ!|O|?j4IIX2^>c zZaDaGDjmNOw;zc>1XHo;EhRPvTB_&>i82|3TAf;X5nc{n*;qWDHZv+=2G7_BFtEVK z(&^Z7D{H2wP+(ON*)K*gmdTiDv_cH67?+6)p^s9@_+)l6l@ysbKaF~4GW2dHM^iIN zsB^{p5bkIqHj^=}7-e$WN|?t?RR-)|ls>fdacgWQIm)#n(=&R-L;YN6%zW5#S*ZQU zq-w6vfUD+4B7;0X)2WPbU5QZ>C9@OO=tL~7LKLaY%#38RY3j#G#5-!Le1;AOWh?R7 z2}Raq#!9BLn>(zp*AWA240(xDj^)rqD)r#Zv^3af1f$M(%sBs6r!N_P3o$g#k3C|o zpt}P_ke3tcRb4Hp_syTSp!SJR3;F<}4^}!+iO*iiYgsx$#a`5hMQZD%iNkC8UgmTR z(Y8lA7jUwH&yO2jYB&O0PGS^14Rk*B)v;*{gP)mHt{idgd^ye!lx*`=5iHZ8l5M$m zP>jtN4V$RWhYml8@VgwvztJs(;_H_$V&mu8?(JqeM{K~-!>zX@&ZKMGQdp( z;?$A2o#XNHl*yeB1;9>TkBD;)?W6n?6vvG%CsI0t;QHi)Zl#9CHeF2#J=7AKyZk_n4O`Nt>8^n5$E6SMyl5`*Mwe4&%ZZJZ#F3o+ E7ePYHivR!s literal 0 HcmV?d00001 diff --git a/slinky/opt/.mark b/slinky/opt/.mark new file mode 100644 index 0000000..3ee320f --- /dev/null +++ b/slinky/opt/.mark @@ -0,0 +1 @@ +Fri Jun 6 14:51:46 PDT 1986 diff --git a/slinky/opt/Makefile b/slinky/opt/Makefile new file mode 100644 index 0000000..3ec6fb7 --- /dev/null +++ b/slinky/opt/Makefile @@ -0,0 +1,77 @@ +.SUFFIXES: .o .c .h .run + +OBJECTS = builtins.o debugPrint.o errorStuff.o expr.o initialize.o\ +instantiate.o link.o main.o map.o poke.o read.o relocate.o slinkyTables.o\ +write.o + +SOURCES = builtins.c debugPrint.c errorStuff.c expr.c initialize.c\ +instantiate.c link.c main.c map.c poke.c read.c relocate.c slinkyTables.c\ +write.c slinkyExpressions.h slinkyGlobals.h slinkyTypes.h y.tab.h + +.c.o: + cc -c -O $*.c + +.c.run: + cc -o $* $*.c + +slinky: $(OBJECTS) + cc -O -o slinky $(OBJECTS) + +update: .mark + kessel "(cd /u0/chip/macross/slinky; make slinky >&errorfyle)" & + +move: .mark + +.mark: $(SOURCES) + cp $? /net/kessel/u0/chip/macross/slinky + cp $? /net/kessel/u0/chip/macross/slinky/prof + cp $? .. + date >.mark + date >/net/kessel/u0/chip/macross/slinky/.mark + date >/net/kessel/u0/chip/macross/slinky/prof/.mark + date >../.mark + +install: slinky + cp slinky slinky_tmp + strip slinky_tmp + cp /u1/gg/bin/slinky /u1/gg/bin/slinky.old + cp slinky_tmp /u1/gg/bin/slinky + /bin/rm slinky_tmp + cp /u1/gg/bin/slinky /net/mycroft/u1/gg/bin + cp /u1/gg/bin/slinky /net/shem/u1/gg/bin + cp /u1/gg/bin/slinky /net/weyr/u1/gg/bin + +builtins.o: builtins.c slinkyGlobals.h slinkyTypes.h slinkyExpressions.h + +debugPrint.o: debugPrint.c slinkyGlobals.h slinkyTypes.h + +errorStuff.o: errorStuff.c slinkyGlobals.h slinkyTypes.h + +expr.o: expr.c slinkyExpressions.h slinkyGlobals.h slinkyTypes.h y.tab.h + +initialize.o: initialize.c slinkyGlobals.h slinkyTypes.h + +instantiate.o: instantiate.c slinkyGlobals.h slinkyTypes.h slinkyExpressions.h + +link.o: link.c slinkyGlobals.h slinkyTypes.h + +main.o: main.c slinkyGlobals.h slinkyTypes.h + +map.o: map.c slinkyGlobals.h slinkyTypes.h + +poke.o: poke.c slinkyGlobals.h slinkyTypes.h + +read.o: read.c slinkyGlobals.h slinkyTypes.h + +relocate.o: relocate.c slinkyGlobals.h slinkyTypes.h + +slinkyTables.o: slinkyTables.c slinkyTypes.h + +write.o: write.c slinkyGlobals.h slinkyTypes.h + +cleanup: + /bin/rm -f *.o slinky + +love: + @echo "Not war?" + diff --git a/slinky/poke.c b/slinky/poke.c new file mode 100644 index 0000000..328bac1 --- /dev/null +++ b/slinky/poke.c @@ -0,0 +1,193 @@ +/* + poke.c -- Routines to poke the values of symbolic references into the + generated code for the Slinky linker. + + Chip Morningstar -- Lucasfilm Ltd. + + 18-March-1985 + +*/ + +#include "slinkyTypes.h" +#include "slinkyGlobals.h" + + bool +isWordSized(value) + int value; +{ + return (-32768<=value && value<=65535); +} + + bool +isByteSized(value) + int value; +{ + return (-128<=value && value<=255); +} + + bool +isByteOffset(value) + int value; +{ + return (-128<=value && value<=127); +} + + int +computeRelativeValue(valueToPoke, codeSegment, offset) + int valueToPoke; + codeSegmentHeaderType *codeSegment; + int offset; +{ + int fromLocation; + int result; + + fromLocation = codeSegment->segmentStartAddress + offset; + result = valueToPoke - fromLocation; +/* if (result > 0)*/ if (result != 0) + result = result - 1; + else if (result < 0) + result = result + 1; + if (!isByteOffset(result)) { + error(RELATIVE_OFFSET_TOO_LARGE_ERROR, result, offset, + fromLocation); + result = 0; + } + return(result); +} + + int +getBaseValue(codeBuffer, offset, referenceKind) + byte codeBuffer[]; + int offset; + int referenceKind; +{ + int result; + + switch (referenceKind) { + case REF_BYTE: + result = codeBuffer[offset]; + break; + + case REF_DBYTE: + result = (codeBuffer[offset] << 8) | codeBuffer[offset+1]; + break; + + case REF_WORD: + result = codeBuffer[offset] | (codeBuffer[offset+1] << 8); + break; + } + return(result); +} + + void +pokeValue(value, codeBuffer, offset, referenceKind, trueAddress) + int value; + byte codeBuffer[]; + int offset; + int referenceKind; + int trueAddress; +{ + switch (referenceKind) { + case REF_BYTE: + if (!isByteSized(value)) { + error(BYTE_VALUE_TOO_LARGE_ERROR, value, offset, + trueAddress); + } else { + codeBuffer[offset] = value; + } + if (debug) + printf(" Byte: 0x%02x at (0x%04x) 0x%04x\n\n", + value&0xFF, offset, trueAddress); + break; + + case REF_WORD: + if (!isWordSized(value)) { + error(WORD_VALUE_TOO_LARGE_ERROR, value, offset, + trueAddress); + } else { + codeBuffer[offset] = value & 0xFF; + codeBuffer[offset+1] = (value >> 8) & 0xFF; + } + if (debug) + printf(" Word: 0x%04x at (0x%04x) 0x%04x\n\n", + value, offset, trueAddress); + break; + + case REF_DBYTE: + if (!isWordSized(value)) { + error(WORD_VALUE_TOO_LARGE_ERROR, value, offset, + trueAddress); + } else { + codeBuffer[offset] = (value >> 8) & 0xFF; + codeBuffer[offset+1] = 0xFF; + } + if (debug) + printf(" Dbyt: 0x%04x at (0x%04x) 0x%04x\n\n", + value, offset, trueAddress); + break; + } +} + + void +fixupReference(reference, codeSegment) + expressionReferenceType *reference; + codeSegmentHeaderType *codeSegment; +{ + int offset; + addressType baseValue; + int valueToPoke; + + /* at this point, we assume we are already pointing at the + correct codeSegment! */ + if (debug) + printReferenceFixup(reference); + offset = reference->referenceAddress - codeSegment-> + segmentStartAddress + codeSegment->relocationOffset; + relocationOffset = codeSegment->relocationOffset; + baseValue = getBaseValue(codeSegment->segmentCodeBuffer, offset, + reference->referenceKind); + + pc = reference->referenceExpression.inCore; + valueToPoke = evaluateExpression(); + if (reference->referenceRelative) + valueToPoke = computeRelativeValue(valueToPoke, codeSegment, + offset); + else + valueToPoke = (short)baseValue + (short)valueToPoke; + pokeValue(valueToPoke, codeSegment->segmentCodeBuffer, offset, + reference->referenceKind, codeSegment->segmentStartAddress + + offset); + +} + + void +pokem() +{ + objectFileListType *inputFileList; + codeSegmentHeaderType *codeSegment; + expressionReferenceType *reference; + int referenceCount; + + if (debug) + printf("\nFixups:\n"); + + if (haveExpressionEntryPoint) { + pc = entryPointExpression; + entryPointAddress = evaluateExpression(); + } + + for (inputFileList = objectFileList; inputFileList != NULL; + inputFileList = inputFileList->nextObjectFile) { + if (inputFileList->name != NULL) { + currentFileName = inputFileList->name; + for (codeSegment = inputFileList->codeSegments; codeSegment!= + NULL; codeSegment = codeSegment->nextSegment) { + for (reference=codeSegment->segmentReferences, + referenceCount=codeSegment->referenceCount; + referenceCount >0; reference++, referenceCount--){ + fixupReference(reference, codeSegment); + } + } + } + } +} diff --git a/slinky/poke.o b/slinky/poke.o new file mode 100644 index 0000000000000000000000000000000000000000..2b19063f06166af7f232be321415799443febf88 GIT binary patch literal 11536 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 & SYMBOL_ABSOLUTE) != 0) +#define isRelocatable(symbol) (((symbol)->symbolClass &SYMBOL_RELOCATABLE)!=0) + + void +fileCheck(fildes, fileName) + FILE *fildes; + char *fileName; +{ + if (feof(fildes)) { + error(PREMATURE_EOF_ERROR, fileName); + chokePukeAndDie(); + } else if (ferror(fildes)) { + error(ERROR_READING_OBJECT_FILE, fileName); + perror("Unix says"); + chokePukeAndDie(); + } +} + + wordType +readWord(file, fileName) + FILE *file; + char *fileName; +{ + wordType result; + register char loByte; + register char hiByte; + + loByte = getc(file); + hiByte = getc(file); + fileCheck(file, fileName); + result = ((hiByte & 0xFF) << 8) | (loByte & 0xFF); + return(result); +} + + byte +readByte(file, fileName) + FILE *file; + char *fileName; +{ + int result; + + if ((result = getc(file)) == EOF) { + fileCheck(file, fileName); + } + return(result); +} + + bigWord +readBigword(file, fileName) + FILE *file; + char *fileName; +{ + register bigWord result; + + result = getc(file) & 0xFF; + result |= (getc(file) & 0xFF) << 8; + result |= (getc(file) & 0xFF) << 16; + result |= (getc(file) & 0xFF) << 24; + fileCheck(file, fileName); + return(result); +} + + bigWord +read3ByteWord(file, fileName) + FILE *file; + char *fileName; +{ + register bigWord result; + + result = getc(file) & 0xFF; + result |= (getc(file) & 0xFF) << 8; + result |= (getc(file) & 0xFF) << 16; + fileCheck(file, fileName); + return(result); +} + + int +readString(buffer, fildes, fileName) + char *buffer; + FILE *fildes; + char *fileName; +{ + register char c; + register char *scratchBuffer; + + scratchBuffer = buffer; + while ((c = getc(fildes)) != EOF && c != '\0') + *scratchBuffer++ = c; + fileCheck(fildes, fileName); + *scratchBuffer++ = '\0'; + return(scratchBuffer - buffer); +} + + void +readChunk(buffer, numberOfBytes, fildes, fileName) + byte *buffer; + int numberOfBytes; + FILE *fildes; + char *fileName; +{ + do { + *buffer++ = getc(fildes); + } while (--numberOfBytes > 0); + fileCheck(fildes, fileName); +} + + void +readCode(startAddress, endAddress, mode, objectFile, objectFildes) + addressType startAddress; + addressType endAddress; + int mode; + objectFileListType *objectFile; + FILE *objectFildes; +{ + int size; + byte *codeBuffer; + codeSegmentHeaderType *newCodeSegment; + static int currentConstraint = 0; + static int currentAlignment = 0; + + size = (short)endAddress - (short)startAddress + 1; + if (size == -2) { + entryPointAddress = startAddress; + entryPointMode = mode; + haveEntryPoint = TRUE; + readByte(objectFildes, objectFile->name); + return; + } else if (size == 0) { + currentConstraint = readWord(objectFildes, objectFile->name); + return; + } else if (size == -1) { + currentAlignment = readWord(objectFildes, objectFile->name); + return; + } + size = (wordType)endAddress - (wordType)startAddress + 1; + codeBuffer = typeAllocBlock(byte, size); + readChunk(codeBuffer, size, objectFildes, objectFile->name); + newCodeSegment = typeAlloc(codeSegmentHeaderType); + newCodeSegment->fileName = objectFile->name; + newCodeSegment->segmentStartAddress = startAddress; + newCodeSegment->segmentEndAddress = endAddress; + newCodeSegment->segmentMode = mode; + newCodeSegment->segmentCodeBuffer = codeBuffer; + newCodeSegment->relocationOffset = 0; + newCodeSegment->constraint = currentConstraint; + newCodeSegment->alignment = currentAlignment; + currentConstraint = currentAlignment = 0; + if (objectFile->lastCodeSegment == NULL) { + objectFile->codeSegments = newCodeSegment; + } else { + objectFile->lastCodeSegment->nextSegment = newCodeSegment; + } + objectFile->lastCodeSegment = newCodeSegment; + newCodeSegment->nextSegment = NULL; + if (mode == MODE_ABSOLUTE) + installAbsoluteCodeSegment(newCodeSegment); + if (debug) + printCode(startAddress, endAddress, mode); +} + + bool +compareReferences(reference1, reference2) + expressionReferenceType *reference1; + expressionReferenceType *reference2; +{ + if (reference1->referenceMode == MODE_ABSOLUTE && reference2-> + referenceMode == MODE_RELOCATABLE) + return(-1); + else + return(reference1->referenceAddress - reference2-> + referenceAddress); +/* else if (reference1->referenceAddress < reference2->referenceAddress) + return(-1); + else if (reference1->referenceAddress > reference2->referenceAddress) + return(1); + else + return(0);*/ +} + + void +sortReferences(theReferences, numberOfReferences) + expressionReferenceType *theReferences; + int numberOfReferences; +{ + qsort(theReferences, numberOfReferences, + sizeof(expressionReferenceType), compareReferences); +} + + void +readReference(reference, fildes, fileName) + expressionReferenceType *reference; + FILE *fildes; + char *fileName; +{ + register byte funnyByte; + + reference->referenceAddress = read3ByteWord(fildes, fileName); + funnyByte = readByte(fildes, fileName); + reference->referenceMode = funnyByte & 1; + reference->referenceRelative = (funnyByte >> 1) & 1; + reference->referenceExternal = (funnyByte >> 2) & 1; + reference->referenceKind = (funnyByte >> 3) & 7; + reference->referenceExpression.inFile = readBigword(fildes, fileName); + if (debug) { + printReference(reference); + } +} + + void +readReferences(objectFile, objectFildes) + objectFileListType *objectFile; + FILE *objectFildes; +{ + int count; + int readCount; + expressionReferenceType *theReferences; + expressionReferenceType *readPtr; + expressionReferenceType *subPtr; + codeSegmentHeaderType *codeSegment; + + readCount = count = readBigword(objectFildes, objectFile->name); + if (readCount == 0) + readPtr = theReferences = NULL; + else + readPtr = theReferences = + typeAllocBlock(expressionReferenceType, count); + if (debug) + printf(" %d references\n", count); + while (readCount-- > 0) + readReference(readPtr++, objectFildes, objectFile->name); + sortReferences(theReferences, count); + if (debug) { + printf(" sorted references\n"); + for (readCount=0; readCountcodeSegments; codeSegment != NULL; + codeSegment = codeSegment->nextSegment) { + codeSegment->segmentReferences = readPtr; + while (codeSegment->nextSegment != NULL && readPtr != NULL && + readPtr->referenceAddress <= codeSegment-> + segmentEndAddress && readPtr-> + referenceMode == codeSegment->segmentMode && + readCount-- > 0) { + readPtr++; + } + if (codeSegment->nextSegment != NULL) { + codeSegment->referenceCount = readPtr - subPtr; + subPtr = readPtr; + } else { + codeSegment->referenceCount = count - (readPtr - + theReferences); + } + } +} + + bool +compareSymbolValues(symbol1, symbol2) + symbolType **symbol1; + symbolType **symbol2; +{ + if ((isAbsolute(*symbol1) && !isAbsolute(*symbol2)) || + (isRelocatable(*symbol1) && !isRelocatable(*symbol2) + && !isAbsolute(*symbol2))) + return(-1); + else if ((isAbsolute(*symbol2) && !isAbsolute(*symbol1)) || + (isRelocatable(*symbol2) && !isRelocatable(*symbol1) + && !isAbsolute(*symbol1))) + return(1); + else + return((*symbol1)->symbolValue - (*symbol2)->symbolValue); +/* else if ((*symbol1)->symbolValue < (*symbol2)->symbolValue) + return(-1); + else if ((*symbol1)->symbolValue == (*symbol2)->symbolValue) + return(0); + else + return(1);*/ +} + + void +readSymbols(objectFile, objectFildes) + objectFileListType *objectFile; + FILE *objectFildes; +{ + symbolType *symbolTable; + symbolType **symbolTableIndir; + int symbolCount; + int stringSize; + char *stringBuffer; + char *fileName; + int symbolTag; + + fileName = objectFile->name; + symbolCount = readBigword(objectFildes, fileName); + objectFile->symbolCount = symbolCount; + stringSize = readBigword(objectFildes, fileName); + if (debug) { + printf(" %d symbols with %d bytes of strings\n", + symbolCount, stringSize); + } + symbolTable = typeAllocBlock(symbolType, symbolCount); + symbolTableIndir = typeAllocBlock(symbolType *, symbolCount); + stringBuffer = typeAllocBlock(char, stringSize); + objectFile->symbolTable = symbolTableIndir; + symbolTag = 0; + while (symbolCount-- > 0) { + *symbolTableIndir++ = symbolTable; + symbolTable->symbolClass = readByte(objectFildes, fileName); + symbolTable->symbolValue = readBigword(objectFildes,fileName); + symbolTable->symbolName = stringBuffer; + stringBuffer += readString(stringBuffer, objectFildes, + fileName); + if (debug) { + printSymbol(symbolTag, symbolTable); + symbolTag++; + } + if ((symbolTable->symbolClass & SYMBOL_EXTERNAL) && + (symbolTable->symbolClass & ~SYMBOL_EXTERNAL)) + globalSymbolCount++; + symbolTable++; + } +} + + expressionPCType +readOneExpression(objectFile, objectFildes) + objectFileListType *objectFile; + FILE *objectFildes; +{ + char *fileName; + int expressionSize; + byte *expressionBuffer; + expressionPCType result; + int saveExpressionSize; + + fileName = objectFile->name; + expressionSize = readBigword(objectFildes, fileName); + if (expressionSize == 0) + return(NULL); + expressionBuffer = typeAllocBlock(byte, expressionSize); + result = expressionBuffer; + saveExpressionSize = expressionSize; + do { + *expressionBuffer++ = readByte(objectFildes, fileName); + } while (--expressionSize > 0); + if (debug) { + printExpression(result, saveExpressionSize); + } + return(result); +} + + void +readExpressions(objectFile, objectFildes) + objectFileListType *objectFile; + FILE *objectFildes; +{ + expressionPCType *expressions; + int expressionCount; + int expressionSize; + int saveExpressionSize; + char *fileName; + byte *expressionBuffer; + + fileName = objectFile->name; + expressionCount = readBigword(objectFildes, fileName); + objectFile->expressionCount = expressionCount; + if (debug) + printf(" %d expressions\n", expressionCount); + expressions = typeAllocBlock(expressionPCType, expressionCount); + objectFile->expressions = expressions; + while (expressionCount-- > 0) { + *expressions = readOneExpression(objectFile, objectFildes); + expressions++; + } + if (haveEntryPoint && entryPointAddress==0xFFFE && entryPointMode== + MODE_RELOCATABLE && !haveExpressionEntryPoint) { + if (debug) + printf("Start address expression:\n"); + entryPointAddress = 0; + entryPointExpression = readOneExpression(objectFile, + objectFildes); + readExpressionEntryPoint = TRUE; + } +} + + argumentListType * +readArgumentList(objectFile, objectFildes) + objectFileListType *objectFile; + FILE *objectFildes; +{ + int argumentCount; + char *fileName; + argumentListType *result; + int i; + int symbolNumber; + + fileName = objectFile->name; + argumentCount = readByte(objectFildes, fileName); + if (argumentCount == 0) + return(NULL); + result = typeAllocBlock(argumentListType, argumentCount); + for (i=0; i + symbolTable[symbolNumber]; + } + return(result); +} + + void +readFunctions(objectFile, objectFildes) + objectFileListType *objectFile; + FILE *objectFildes; +{ + functionType *functions; + int functionCount; + int functionSize; + int argumentCount; + int useFunctionSize; + char *fileName; + byte *functionBuffer; + + fileName = objectFile->name; + functionCount = readBigword(objectFildes, fileName); + objectFile->functionCount = functionCount; + if (debug) + printf(" %d functions\n", functionCount); + functions = typeAllocBlock(functionType, functionCount); + objectFile->functions = functions; + while (functionCount-- > 0) { + functions->functionArguments = readArgumentList(objectFile, + objectFildes); + functionSize = readBigword(objectFildes, fileName); + functionBuffer = typeAllocBlock(byte, functionSize); + functions->functionBody = functionBuffer; + useFunctionSize = functionSize; + while (useFunctionSize-- > 0) + *functionBuffer++ = readByte(objectFildes,fileName); + if (debug) { + printExpression(functions->functionBody,functionSize); + } + functions++; + } +} + + void +instantiateExpressionAndSymbolPointers(objectFile) + objectFileListType *objectFile; +{ + symbolType **symbolTable; + expressionPCType *expressions; + functionType *functions; + int i; + codeSegmentHeaderType *codeSegment; + expressionReferenceType *reference; + int referenceCount; + + currentSymbolTable = objectFile->symbolTable; + currentFunctionTable = objectFile->functions; + expressions = objectFile->expressions; + for (codeSegment = objectFile->codeSegments; codeSegment != NULL; + codeSegment = codeSegment->nextSegment) { + for (reference = codeSegment->segmentReferences, referenceCount = + codeSegment->referenceCount; referenceCount > 0; + reference++, referenceCount--) { + pc = reference->referenceExpression.inCore = expressions[ + reference->referenceExpression.inFile]; + putSymbolPointersIntoExpression(); + } + } + functions = objectFile->functions; + for (i=0; ifunctionCount; ++i) { + pc = functions[i].functionBody; + putSymbolPointersIntoExpression(); + } +} + + void +readReservations(objectFile, objectFildes) + objectFileListType *objectFile; + FILE *objectFildes; +{ + addressType startAddress; + reservationListType *buildReservation(); + + if (debug) + printf(" reservations\n"); + while ((startAddress = readWord(objectFildes, objectFile->name)) != + 0xFFFF) + reservationList = buildReservation(startAddress, + readWord(objectFildes, objectFile->name), + reservationList); +} + + reservationListType * +buildReservation(startAddress, blockSize, nextReservation) + addressType startAddress; + int blockSize; + reservationListType *nextReservation; +{ + reservationListType *result; + + result = typeAlloc(reservationListType); + result->startAddress = startAddress; + result->blockSize = blockSize; + result->nextReservation = nextReservation; + if (debug) + printf(" Res: 0x%x 0x%x @0x%x -> 0x%x\n", startAddress, + blockSize, result, nextReservation); + return(result); +} diff --git a/slinky/read.o b/slinky/read.o new file mode 100644 index 0000000000000000000000000000000000000000..e7bd774175162a6dd0b5b44a1a8f7af90c8bce7d GIT binary patch literal 23468 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 literal 0 HcmV?d00001 diff --git a/slinky/relocate.c b/slinky/relocate.c new file mode 100644 index 0000000..c4ba9df --- /dev/null +++ b/slinky/relocate.c @@ -0,0 +1,348 @@ +/* + relocate.c -- Routines to relocate relocatable code for the Slinky + linker. + + Chip Morningstar -- Lucasfilm Ltd. + + 15-March-1985 +*/ + +#include "slinkyTypes.h" +#include "slinkyGlobals.h" + +#define isUndefined(symbol) (((symbol)->symbolClass & ~SYMBOL_EXTERNAL) == 0) + + void +removeZeroPageFromFreeList() +{ + while (freeSegmentList->segmentEndAddress <= 0x100) + freeSegmentList = freeSegmentList->nextFreeSegment; + if (freeSegmentList->segmentStartAddress < 0x100) + freeSegmentList->segmentStartAddress = 0x100; +} + + addressType +align(address, alignment) + addressType address; + int alignment; +{ + if (alignment == 0) + return(address); + else + return(((address + alignment - 1) / alignment) * alignment); +} + + addressType +constrain(address, size, constraint) + addressType address; + int size; + addressType constraint; +{ + if (constraint == 0) + return(address); + else if (address/constraint != (address + size - 1)/constraint) + return(align(address, constraint)); + else + return(address); +} + void +moveRelocationBase(newBase) + addressType newBase; +{ + freeSegmentEntryType *freePtr; + freeSegmentEntryType *newFreePtr; + + freePtr = freeSegmentList; + while (freePtr != NULL && newBase > freePtr->segmentEndAddress) + freePtr = freePtr->nextFreeSegment; + if (freePtr == NULL || freePtr->segmentStartAddress == newBase) { + effectiveFreeSegmentList = freePtr; + } else { + newFreePtr = typeAlloc(freeSegmentEntryType); + newFreePtr->segmentEndAddress = freePtr->segmentEndAddress; + freePtr->segmentEndAddress = newBase - 1; + newFreePtr->segmentStartAddress = newBase; + newFreePtr->nextFreeSegment = freePtr->nextFreeSegment; + freePtr->nextFreeSegment = newFreePtr; + effectiveFreeSegmentList = newFreePtr; + } +} + + addressType +allocateRelocatable(codeSegment) + codeSegmentHeaderType *codeSegment; +{ + freeSegmentEntryType *freePtr; + freeSegmentEntryType *previousPtr; + freeSegmentEntryType *newFreePtr; + int size; + addressType effectiveStartAddress; + + freePtr = effectiveFreeSegmentList; + previousPtr = NULL; + size = codeSegment->segmentEndAddress - codeSegment-> + segmentStartAddress + 1; + while (freePtr != NULL) { + effectiveStartAddress = align(freePtr->segmentStartAddress, + codeSegment->alignment); + effectiveStartAddress = constrain(effectiveStartAddress, size, + codeSegment->constraint); + if (freePtr->segmentEndAddress - effectiveStartAddress + 1 < + size) { + previousPtr = freePtr; + freePtr = freePtr->nextFreeSegment; + continue; + } + /* if we made it to here, we got a winner! */ + if (effectiveStartAddress == freePtr->segmentStartAddress) { + if (effectiveStartAddress + size - 1 == freePtr-> + segmentEndAddress) { + if (previousPtr == NULL) + freeSegmentList = freePtr->nextFreeSegment; + else + previousPtr->nextFreeSegment = freePtr-> + nextFreeSegment; + } else { + freePtr->segmentStartAddress += size; + } + } else { + if (effectiveStartAddress + size - 1 == freePtr-> + segmentEndAddress) { + freePtr->segmentEndAddress -= size; + } else { + newFreePtr = typeAlloc(freeSegmentEntryType); + newFreePtr->nextFreeSegment = freePtr->nextFreeSegment; + freePtr->nextFreeSegment = newFreePtr; + newFreePtr->segmentEndAddress =freePtr->segmentEndAddress; + freePtr->segmentEndAddress = effectiveStartAddress - 1; + newFreePtr->segmentStartAddress = effectiveStartAddress + + size; + } + } + return(effectiveStartAddress); + } + return((addressType) -1); +} + + void +relocateOneCodeSegment(codeSegment, targetLocation) + codeSegmentHeaderType *codeSegment; + addressType targetLocation; +{ + int relocationOffset; + + relocationOffset = targetLocation - codeSegment->segmentStartAddress; + if (verbose) + printf(" 0x%04x:0x%04x --> 0x%04x", codeSegment-> + segmentStartAddress, codeSegment->segmentEndAddress, + targetLocation); + codeSegment->relocationOffset = relocationOffset; + codeSegment->segmentStartAddress += relocationOffset; + codeSegment->segmentEndAddress += relocationOffset; + if (!packFlag) { + moveRelocationBase(codeSegment->segmentEndAddress+1); + } + if (verbose) + printf(" (0x%04x:0x%04x)\n", codeSegment->segmentStartAddress, + codeSegment->segmentEndAddress); + installSegment(codeSegment); +} + + void +relocatem() +{ + objectFileListType *inputFileList; + addressType targetLocation; + codeSegmentHeaderType *codeSegment; + + reserveReservations(); + removeZeroPageFromFreeList(); + for (inputFileList = objectFileList; inputFileList != NULL; + inputFileList = inputFileList->nextObjectFile) { + if (inputFileList->name != NULL) { + currentFileName = inputFileList->name; + if (verbose) + printf("%s:\n", inputFileList->name); + for (codeSegment = inputFileList->codeSegments; codeSegment != + NULL; codeSegment = codeSegment->nextSegment) { + if (codeSegment->segmentMode == MODE_RELOCATABLE) { + if ((targetLocation=allocateRelocatable(codeSegment)) + == (addressType) -1) { + error(NO_PLACE_TO_PUT_CODE_SEGMENT_ERROR, + codeSegment->segmentStartAddress, + inputFileList->name); + } else { + relocateOneCodeSegment(codeSegment, + targetLocation); + } + } + } + } else { /* null name encodes new relocation base */ + moveRelocationBase(inputFileList->symbolCount); + } + } +} + + codeSegmentHeaderType * +matchModes(symbol, codeSegment) + symbolType *symbol; + codeSegmentHeaderType *codeSegment; +{ + while (codeSegment!=NULL && ((codeSegment->segmentMode==MODE_ABSOLUTE + && !(symbol->symbolClass & SYMBOL_ABSOLUTE)) || + (codeSegment->segmentMode==MODE_RELOCATABLE && + !(symbol->symbolClass & SYMBOL_RELOCATABLE) && + !(symbol->symbolClass & SYMBOL_ABSOLUTE)))) + codeSegment = codeSegment->nextSegment; + return(codeSegment); +} + + bool +matchedModes(symbol, codeSegment) + symbolType *symbol; + codeSegmentHeaderType *codeSegment; +{ + return(((symbol->symbolClass & SYMBOL_ABSOLUTE) && codeSegment-> + segmentMode == MODE_ABSOLUTE) || ((symbol->symbolClass & + SYMBOL_RELOCATABLE) && codeSegment->segmentMode == + MODE_RELOCATABLE)); +} + + codeSegmentHeaderType * +synchronizeCodeSegment(symbol, codeSegment) + symbolType *symbol; + codeSegmentHeaderType *codeSegment; +{ + codeSegment = matchModes(symbol, codeSegment); + while (codeSegment != NULL && codeSegment->nextSegment != NULL && + codeSegment->segmentEndAddress - codeSegment-> + relocationOffset < symbol->symbolValue && + matchedModes(symbol, codeSegment)) { + codeSegment = codeSegment->nextSegment; + } + return(codeSegment); +} + + void +handleGlobalSymbol(symbol) + symbolType *symbol; +{ +} + + void +valueSymbol(symbol, codeSegment) + symbolType *symbol; + codeSegmentHeaderType *codeSegment; +{ + if (symbol->symbolClass & SYMBOL_ABSOLUTE) { + return; + } else if (symbol->symbolClass & SYMBOL_RELOCATABLE) { + symbol->symbolValue += codeSegment->relocationOffset; + } else { + printf("Super botcho! Undefined symbol in ValueSymbol.\n"); + } +} + + symbolType * +lookupGlobalSymbol(symbolName) + char *symbolName; +{ + int guess; + int top; + int bottom; + int compare; + int oldTop; + int oldBottom; + + top = oldBottom = globalSymbolCount; + bottom = oldTop = 0; + while (top != bottom && top != oldTop && bottom != oldBottom) { + guess = (top + bottom) >> 1; + compare = strcmplc(globalSymbolTable[guess]->symbolName, + symbolName); + if (compare == 0) + return(globalSymbolTable[guess]); + else if (compare < 0) { + oldBottom = bottom; + bottom = guess; + } else { + oldTop = top; + top = guess; + } + } + return(NULL); +} + + void +valueUndefinedSymbol(symbol) + symbolType *symbol; +{ + symbolType *globalSymbol; + + if ((globalSymbol = lookupGlobalSymbol(symbol->symbolName)) == NULL) { + error(UNDEFINED_SYMBOL_ERROR, symbol->symbolName); + } else { + symbol->symbolClass = globalSymbol->symbolClass; + symbol->symbolValue = globalSymbol->symbolValue; + } +} + + void +valuem() +{ + objectFileListType *inputFileList; + codeSegmentHeaderType *codeSegmentPtr; + symbolType *symbolPtr; + int symbolCount; + + totalSymbolCount = 0; + for (inputFileList = objectFileList; inputFileList != NULL; + inputFileList = inputFileList->nextObjectFile) { + if (inputFileList->name != NULL) { + currentFileName = inputFileList->name; + if (debug) + printf("\nSymbols with values (%s):\n", inputFileList-> + name); + codeSegmentPtr = inputFileList->codeSegments; + for (symbolCount = 0; symbolCountsymbolCount; + symbolCount++) { + symbolPtr = inputFileList->symbolTable[symbolCount]; + if (isUndefined(symbolPtr)) { +/* inputFileList->undefinedSymbols = symbolPtr;*/ + inputFileList->undefinedSymbols = &(inputFileList->symbolTable[symbolCount]); + break; + } + codeSegmentPtr = synchronizeCodeSegment(symbolPtr, + codeSegmentPtr); + valueSymbol(symbolPtr, codeSegmentPtr); + if (debug) + printSymbol(symbolCount, symbolPtr); + } + inputFileList->baseSymbolCount = symbolCount; + inputFileList->symbolCount -= symbolCount; + } + } + + for (inputFileList = objectFileList; inputFileList != NULL; + inputFileList = inputFileList->nextObjectFile) { + if (inputFileList->name != NULL) { + currentFileName = inputFileList->name; + if (debug) + printf("\nGlobal symbols with values (%s):\n", + inputFileList->name); + for (symbolCount = 0; symbolCount symbolCount; + symbolCount++) { + symbolPtr = inputFileList->undefinedSymbols[symbolCount]; + valueUndefinedSymbol(symbolPtr); + if (debug) + printSymbol(symbolCount, symbolPtr); + } + inputFileList->symbolCount = inputFileList->baseSymbolCount; + totalSymbolCount += inputFileList->baseSymbolCount; + } + } + if (debug) + printf("\nTotal symbol count = %d\n", totalSymbolCount); + if (produceLoadMap) + outputLoadMap(); +} diff --git a/slinky/relocate.o b/slinky/relocate.o new file mode 100644 index 0000000000000000000000000000000000000000..f6d86e5a5ba13b693a252c602216845a8bfb8f0c GIT binary patch literal 16417 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 literal 0 HcmV?d00001 diff --git a/slinky/slinky b/slinky/slinky new file mode 100755 index 0000000000000000000000000000000000000000..f5da58b133d7d04a4d3a20357bc4faa43f017f45 GIT binary patch literal 122880 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 literal 0 HcmV?d00001 diff --git a/slinky/slinkyExpressions.h b/slinky/slinkyExpressions.h new file mode 100644 index 0000000..04ddca7 --- /dev/null +++ b/slinky/slinkyExpressions.h @@ -0,0 +1,147 @@ +/* + slinkyExpressions.h -- Expression definitions for the Slinky linker + + Chip Morningstar -- Lucasfilm Ltd. + + 6-November-1985 +*/ + +/* + Expressions are stored in the object file in a compact parse-tree + representation. We just read this directly and interpret it on-the-fly + without much sophistication. Function definitions include whole + statements, but the principle is the same. + + The basic form of a syntactic entity is: + +---------+-------------+ + | tagByte | bodyOfThing | + +---------+-------------+ + where 'tabByte' encodes how 'bodyOfThing' is to be interpreted. + + These are the possible 'thing's, as encoded by the 'tagByte's + +------+ + identifier: | sym# | 'sym#' is an index into the symbol entries + +------+ of the object file when the expression is + in the object file too, and then 'sym#' is converted + to a pointer to symbol structure when the symbol + itself is read in. + +-------+-------+------+------+-----+ + functionCall: | func# | argCt | expr | expr | ... | 'argCt' is a + +-------+-------+------+------+-----+ single byte + argument count (which means that a function may have + no more than 255 arguments if it is to be used + externally) and this is how many 'expr's there are. + +-----+ + number: | num | 'num' is just a 4-byte number. + +-----+ + +----+ + conditionCode: | cc | 'cc' is a single byte condition code. + +----+ + +------+ + subexpression: | expr | + +------+ + +----+------+ + unop: | op | expr | 'op' is a 1-byte operation number. + +----+------+ + +----+------+------+ + binop: | op | expr | expr | + +----+------+------+ + +----+------+ + preop: | op | expr | + +----+------+ + +----+------+ + postop: | op | expr | + +----+------+ + + here: empty body. + + +---+---+---+---+-----+----+ + string: | a | b | c | d | ... | \0 | Typical 'C' string. + +---+---+---+---+-----+----+ + +------+------+ + array: | sym# | expr | + +------+------+ + +-----+ + value: | num | + +-----+ + + null: empty body. Encodes null expression *or* statement. + + +-------+-------+-----+-----+ + block: | thing | thing | ... | end | 'end' acts as a + +-------+-------+-----+-----+ termination symbol. + +------+------+ + mdefine: | sym# | expr | 'expr' can be null. + +------+------+ + +------+------+ + mvar: | sym# | expr | 'expr' can be null. + +------+------+ + +------+-------+-------+ + mif: | expr | block | block | either 'block' can be null. + +------+-------+-------+ + +------+------+------+-------+ + mfor: | expr | expr | expr | block | + +------+------+------+-------+ + +------+-------+ + mwhile: | expr | block | + +------+-------+ + +------+-------+ + mdoWhile: | expr | block | + +------+-------+ + +------+-------+ + mdoUntil: | expr | block | + +------+-------+ + +------+ + freturn: | expr | + +------+ + +------+ + perform: | expr | + +------+ + +-------+ + group: | block | + +-------+ + +------+--------+ + assert: | expr | string | + +------+--------+ + +------+--------+--------+-----+-----+ + mswitch: | expr | clause | clause | ... | end | + +------+--------+--------+-----+-----+ + +------+------+-----+-------+ + clause: | expr | expr | ... | block | + +------+------+-----+-------+ + + end: empty body. + +*/ + +#define IDENTIFIER_TAG 0x00 +#define FUNCTION_CALL_TAG 0x01 +#define NUMBER_TAG 0x02 +#define CONDITION_CODE_TAG 0x03 +#define SUBEXPRESSION_TAG 0x04 +#define UNOP_TAG 0x05 +#define BINOP_TAG 0x06 +#define PREOP_TAG 0x07 +#define POSTOP_TAG 0x08 +#define HERE_TAG 0x09 +#define STRING_TAG 0x0A +#define ARRAY_TAG 0x0B +#define VALUE_TAG 0x0C +#define NULL_TAG 0x0D +#define BLOCK_TAG 0x0E +#define MDEFINE_TAG 0x0F +#define MVARIABLE_TAG 0x10 +#define MIF_TAG 0x11 +#define MFOR_TAG 0x12 +#define MWHILE_TAG 0x13 +#define MDOWHILE_TAG 0x14 +#define MDOUNTIL_TAG 0x15 +#define PERFORM_TAG 0x16 +#define GROUP_TAG 0x17 +#define ASSERT_TAG 0x18 +#define MSWITCH_TAG 0x19 +#define CLAUSE_TAG 0x1A +#define END_TAG 0x1B +#define FRETURN_TAG 0x1C +#define BUILTIN_FUNCTION_CALL_TAG 0x1D +#define RELOCATABLE_TAG 0x1E diff --git a/slinky/slinkyGlobals.h b/slinky/slinkyGlobals.h new file mode 100644 index 0000000..e62d610 --- /dev/null +++ b/slinky/slinkyGlobals.h @@ -0,0 +1,49 @@ +/* + slinkyGlobals.h -- Global variables for the Slinky linker. + + Chip Morningstar -- Lucasfilm Ltd. + + 9-March-1985 +*/ + +bool debug; /* TRUE iff we should print debug diagnostics */ +bool errorFlag; /* TRUE iff an error occured during linking */ +bool verbose; +bool packFlag; +#define DEFAULT_LOAD_FILE_NAME "s.out" +FILE *loadFileOutput; /* where to put the results */ +FILE *mapFileOutput; +objectFileListType *objectFileList; +objectFileListType *endOfObjectFileList; +char *currentFileName; +freeSegmentEntryType *freeSegmentList; +freeSegmentEntryType *effectiveFreeSegmentList; +addressType relocationOffset; +addressType entryPointAddress; +int entryPointMode; +expressionPCType entryPointExpression; +bool produceLoadMap; +bool leaveOffLoadFiles; +bool haveEntryPoint; +bool haveExpressionEntryPoint; +bool readExpressionEntryPoint; +symbolType **globalSymbolTable; +int globalSymbolCount; +symbolType **currentSymbolTable; +functionType *currentFunctionTable; +reservationListType *reservationList; +int totalSymbolCount; +expressionPCType pc; +addressType here; +bindingListType *localBindings; + +#define CODE_REGIONS_IN_ADDRESS_SPACE 256 +#define CODE_REGION_SIZE 0x100 +segmentListType *generatedLoadImage[CODE_REGIONS_IN_ADDRESS_SPACE]; +#define regionOf(addr) (addr / CODE_REGION_SIZE) + +struct { + stringType *functionName; + addressType (*functionEntry)(); + } builtInFunctionTable[]; +#define MAX_FUNCTIONS 15 diff --git a/slinky/slinkyTables.c b/slinky/slinkyTables.c new file mode 100644 index 0000000..7cefba9 --- /dev/null +++ b/slinky/slinkyTables.c @@ -0,0 +1,49 @@ +/* + slinkyTables.c -- Global tables for the Slinky linker. + + Chip Morningstar -- Lucasfilm Ltd. + + 14-November-1985 +*/ + +#include "slinkyTypes.h" + +addressType atasciiBIF(); +addressType atasciiColorBIF(); +addressType isAbsoluteValueBIF(); +addressType isConditionCodeBIF(); +addressType isDefinedBIF(); +addressType isExternalBIF(); +addressType nthCharBIF(); +addressType printfBIF(); +addressType strcatBIF(); +addressType strcmpBIF(); +addressType strcmplcBIF(); +addressType strlenBIF(); +addressType substrBIF(); +addressType symbolDefineBIF(); +addressType symbolLookupBIF(); +addressType symbolNameBIF(); + +/* Used to initialize symbols representing built-in functions */ +struct { + stringType *functionName; + addressType (*functionEntry)(); + } builtInFunctionTable[] = { + "atascii", atasciiBIF, /* 0 */ + "atasciiColor", atasciiColorBIF, /* 1 */ + "isAbsoluteValue", isAbsoluteValueBIF, /* 2 */ + "isConditionCode", isConditionCodeBIF, /* 3 */ + "isDefined", isDefinedBIF, /* 4 */ + "isExternal", isExternalBIF, /* 5 */ + "nthChar", nthCharBIF, /* 6 */ + "printf", printfBIF, /* 7 */ + "strcat", strcatBIF, /* 8 */ + "strcmp", strcmpBIF, /* 9 */ + "strcmplc", strcmplcBIF, /* 10 */ + "strlen", strlenBIF, /* 11 */ + "substr", substrBIF, /* 12 */ + "symbolLookup", symbolLookupBIF, /* 13 */ + "symbolName", symbolNameBIF, /* 14 */ + NULL, NULL, +}; diff --git a/slinky/slinkyTables.o b/slinky/slinkyTables.o new file mode 100644 index 0000000000000000000000000000000000000000..98dc881e1cf97c38c1f0f3d6115a0da674162c20 GIT binary patch literal 5544 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 Tf + +typedef unsigned char byte; + +typedef unsigned short wordType; + +typedef unsigned int *ptr; + +typedef byte anyOldThing; + +#define TRUE 1 +#define FALSE 0 +typedef int bool; + +typedef unsigned long bigWord; + +typedef char stringType; /* a char is not a string but a + pointer to char is a pointer to a + string, and pointers are what we + care about when handling strings */ + +typedef bigWord addressType; /* target machine address */ + +/* symbolClass bits */ +#define SYMBOL_UNDEFINED 0x00 +#define SYMBOL_ABSOLUTE 0x02 +#define SYMBOL_RELOCATABLE 0x04 +#define SYMBOL_LOCAL 0x08 +#define SYMBOL_EXTERNAL 0x01 + +typedef struct { + byte symbolClass; /* see above */ + int symbolValue; + stringType *symbolName; + } symbolType; /* as managed in core */ + +typedef byte *expressionPCType; + +typedef struct bindingListStruct { + symbolType *boundSymbol; + byte previousClass; + int previousValue; + struct bindingListStruct *nextBinding; + } bindingListType; + +typedef struct argumentListStruct { + symbolType *argumentSymbol; + struct argumentListStruct *nextArgument; + } argumentListType; + +typedef struct { + expressionPCType functionBody; + argumentListType *functionArguments; + } functionType; + +#define MODE_ABSOLUTE 0 +#define MODE_RELOCATABLE 1 + +#define REF_BYTE 0 +#define REF_WORD 1 +#define REF_DBYTE 2 + +typedef struct { + bigWord referenceAddress : 24, /* target machine address */ + referenceMode : 1, /* see above MODE_xx defines*/ + referenceRelative : 1, /* TRUE==is relative */ + referenceKind : 3, /* see above REF_xx defines */ + referenceExternal : 1, /* TRUE==is ref to external */ + : 2; /* unused bits */ + union { + expressionPCType inCore; + int inFile; + } referenceExpression; + } expressionReferenceType; + +typedef struct codeSegmentHeaderStruct { + struct codeSegmentHeaderStruct *nextSegment; + int relocationOffset; + addressType constraint; + addressType alignment; + addressType segmentStartAddress; + addressType segmentEndAddress; + byte segmentMode; + byte *segmentCodeBuffer; + int referenceCount; + expressionReferenceType *segmentReferences; + char *fileName; + } codeSegmentHeaderType; + +typedef struct segmentListStruct { + codeSegmentHeaderType *thisSegment; + struct segmentListStruct *nextSegment; + } segmentListType; + +#define FIRST_AVAILABLE_LOCATION 0x0000 +#define LAST_AVAILABLE_LOCATION 0xFFFF +typedef struct freeSegmentEntryStruct { + addressType segmentStartAddress; + addressType segmentEndAddress; + struct freeSegmentEntryStruct *nextFreeSegment; + } freeSegmentEntryType; + +typedef struct objectFileListStruct { + char *name; + symbolType **symbolTable; + int symbolCount; + int baseSymbolCount; + symbolType **undefinedSymbols; + int expressionCount; + int functionCount; + expressionPCType *expressions; + functionType *functions; + codeSegmentHeaderType *codeSegments; + codeSegmentHeaderType *lastCodeSegment; + struct objectFileListStruct *nextObjectFile; + } objectFileListType; + +typedef struct reservationListStruct { + addressType startAddress; + int blockSize; + struct reservationListStruct *nextReservation; + } reservationListType; + +typedef enum { + NO_DASH_O_FILE_NAME_ERROR, + BAD_COMMAND_LINE_FLAG_ERROR, + MORE_THAN_ONE_OUTPUT_FILE_ERROR, + CANT_OPEN_LOAD_FILE_ERROR, + CANT_OPEN_OBJECT_FILE_ERROR, + NO_INPUT_FILES_ERROR, + BAD_OBJECT_FILE_ERROR, + PREMATURE_EOF_ERROR, + ERROR_READING_OBJECT_FILE, + OVERLAPPING_ABSOLUTE_CODE_SEGMENTS_ERROR, + NO_PLACE_TO_PUT_CODE_SEGMENT_ERROR, + MULTIPLY_DEFINED_SYMBOL_ERROR, + UNDEFINED_SYMBOL_ERROR, + RELATIVE_OFFSET_TOO_LARGE_ERROR, + BYTE_VALUE_TOO_LARGE_ERROR, + WORD_VALUE_TOO_LARGE_ERROR, + NO_MAP_FILE_NAME_ERROR, + MORE_THAN_ONE_MAP_FILE_ERROR, + CANT_OPEN_MAP_FILE_ERROR, + BAD_LOAD_ADDRESS_ERROR, + NO_LOAD_ADDRESS_ERROR, + ARRAY_TERM_IN_OBJECT_ERROR, + ASSERT_FAILED_ERROR, + CONDITION_CODE_EXPRESSION_ENCOUNTERED_ERROR, + CLAUSE_AT_TOP_LEVEL_ERROR, + TOO_MANY_FUNCTION_ARGUMENTS_ERROR, + TOO_FEW_ARGUMENTS_TO_BIF_ERROR, + TOO_MANY_ARGUMENTS_TO_BIF_ERROR, + BAD_POSITION_ARGUMENT_TO_NTH_CHAR_ERROR, + BAD_SUBSTRING_INDICES_ERROR, + SYMBOL_NAME_ARG_IS_NOT_SYMBOL_ERROR, + SYMBOL_NOT_FOUND_IN_SYMBOL_LOOKUP_ERROR, + } errorType; + +#define typeAlloc(type) (type *)malloc(sizeof(type)) +#define typeAllocBlock(type, size) (type *)malloc(sizeof(type) * (size)) diff --git a/slinky/write.c b/slinky/write.c new file mode 100644 index 0000000..9b2893d --- /dev/null +++ b/slinky/write.c @@ -0,0 +1,60 @@ +/* + write.c -- Routines to write out the eventual object module for the + Slinky linker + + Chip Morningstar -- Lucasfilm Ltd. + + 19-March-1985 +*/ + +#include "slinkyTypes.h" +#include "slinkyGlobals.h" + +#define writeWord(aWord) putc(aWord & 0xFF, loadFileOutput);\ + putc((aWord >> 8) & 0xFF, loadFileOutput) +#define writeByte(aByte) putc(aByte & 0xFF, loadFileOutput) + + void +writeEntryPoint() +{ + writeWord(entryPointAddress); + writeWord(entryPointAddress); + writeByte(0); +} + + void +writeCodeSegment(codeSegment) + codeSegmentHeaderType *codeSegment; +{ + int length; + int i; + + writeWord(codeSegment->segmentStartAddress); + writeWord(codeSegment->segmentEndAddress); + length = codeSegment->segmentEndAddress - codeSegment-> + segmentStartAddress + 1; + for (i=0; isegmentCodeBuffer[i]); +} + + void +writem() +{ + int regionNumber; + codeSegmentHeaderType *lastSegment; + segmentListType *segment; + + writeWord(0xFFFF); + if (haveEntryPoint) + writeEntryPoint(); + lastSegment = NULL; + for (regionNumber = 0; regionNumber < CODE_REGIONS_IN_ADDRESS_SPACE; + regionNumber++) { + for (segment = generatedLoadImage[regionNumber]; segment != + NULL; segment = segment->nextSegment) { + if (segment->thisSegment != lastSegment) + writeCodeSegment(lastSegment = segment-> + thisSegment); + } + } +} diff --git a/slinky/write.o b/slinky/write.o new file mode 100644 index 0000000000000000000000000000000000000000..2204187c0ffea0cc02b74a8e4771831b046e1192 GIT binary patch literal 14686 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] & opcode-> + permissibleOperandModes) == 0) { + error(ILLEGAL_OPERAND_TYPE_ERROR, opcode->mnemonic); + return(FALSE); + } + } + return(TRUE); +} + + void +assembleMachineInstruction(opcode, operands) + opcodeTableEntryType *opcode; + operandListType *operands; +{ + int i; + int op; + valueType *evaluatedOperands[MAX_NUMBER_OF_OPERANDS]; + valueType *value; + + valueType *evaluateOperand(); + addressType addressValue(); + + nullAssemble(opcode); + expand(moreText("%s\t", opcode->mnemonic)); + for (op=1; operands!=NULL && op<=opcode->maxNumberOfOperands; + op++, operands=operands->nextOperand) { + newFixupAddressMode = EXPRESSION_OPND; + evaluatedOperands[op-1] = value = evaluateOperand(operands); + fixupAddressMode[op-1] = newFixupAddressMode; + currentOperandNumber++; + expand(isUndefined(value) ? (finishOperand = TRUE) : + expandOperand(value->addressMode, + operandBuffer[op-1])); + if (value==NULL || value->kindOfValue == FAIL){ + error(BAD_INSTRUCTION_OPERAND_ERROR, opcode-> + mnemonic); + if (freeFlag) + for (i=1; imnemonic, + opcode->maxNumberOfOperands); + } else if (op < opcode->minNumberOfOperands) { + error(TOO_FEW_INSTRUCTION_OPERANDS_ERROR, opcode->mnemonic, + opcode->minNumberOfOperands); + } else if (operandCheck(opcode, op, evaluatedOperands)) { + (*instructionActionTable[(int)opcode->addressClass])(opcode, + op, evaluatedOperands); + } + expand((expandOperands(op), endLine())); + if (freeFlag) + for (i=0; ibody == NULL) { + error(UNDEFINED_MACRO_ERROR, macroInstruction->macroName); + return; + } + pushEnvironment(newEnvironment); + savedLocalVariableList = currentLocalVariableList; + currentLocalVariableList = NULL; + savedLabelTagNumber = currentLabelTagNumber; + currentLabelTagNumber = nextLabelTagNumber++; + savedErrorFlag = errorFlag; + errorFlag = FALSE; + saveListingOn = listingOn; + if ((numberBound = bindMacroArguments(macroInstruction->arguments, + operands, macroInstruction->macroName)) > 0) { + macroCallDepth++; + listingOn = amExpanding(); + assembleBlock(macroInstruction->body); + macroCallDepth--; + } else + numberBound = -numberBound; + if (numberBound > 1) + unbindArguments(macroInstruction->arguments, numberBound-1); + unbindLocalVariables(currentLocalVariableList); + if (errorFlag) + error(ERROR_INSIDE_MACRO_ERROR, macroInstruction->macroName); + else + errorFlag = savedErrorFlag; + currentLabelTagNumber = savedLabelTagNumber; + currentLocalVariableList = savedLocalVariableList; + listingOn = saveListingOn; + popEnvironment(); +} + + void +assembleAlignStatement(alignStatement) + alignStatementBodyType *alignStatement; +{ + int alignment; + bool saveExpansion; + + int intValue(); + valueType *evaluateExpression(); + + nullAssemble(alignStatement); + expansionOff(); + alignment = intValue(evaluateExpression(alignStatement, NO_FIXUP)); + expansionOn(); + expand((moreText("align\t0x%x", alignment), endLine())); + if (alignment > 0) + if (currentCodeMode == ABSOLUTE_BUFFER) { + if (structNestingDepth == 0) + currentLocationCounter.value = alignment * + ((currentLocationCounter.value + + alignment - 1) / alignment); + else + currentFieldOffset = alignment * + ((currentFieldOffset + alignment - + 1) / alignment); + } else { + if (insideConstraintBlock) + error(ALIGN_INSIDE_CONSTRAIN_ERROR); + else + addBreak(ALIGN_BREAK, alignment); + } + else + error(IMPROPER_ALIGNMENT_VALUE_ERROR); +} + + void +assembleAssertStatement(assertStatement) + assertStatementBodyType *assertStatement; +{ + valueType *test; + valueType *message; + bool saveExpansion; + + valueType *evaluateExpression(); + + expansionOff(); + test = evaluateExpression(assertStatement->condition, NO_FIXUP); + expansionOn(); + if (test == NULL || test->kindOfValue != ABSOLUTE_VALUE) { + error(INVALID_ASSERT_CONDITION_ERROR); + } else if (!test->value) { + if (assertStatement->message == NULL) + error(ASSERT_ERROR); + else { + expansionOff(); + message = evaluateExpression(assertStatement->message, + NO_FIXUP); + expansionOn(); + if (message == NULL || message->kindOfValue != + STRING_VALUE) + error(INVALID_ASSERT_MESSAGE_ERROR); + else + error(ASSERT_WITH_MESSAGE_ERROR, message-> + value); + } + } +} + + void +assembleBlockStatement(blockStatement) + blockStatementBodyType *blockStatement; +{ + valueType *blockIncrement; + int blockSize; + + valueType *evaluateExpression(); + int intValue(); + + blockSize = 0; + nullAssemble(blockStatement); + expand(moreText("block\t")); + while (blockStatement != NULL) { + blockIncrement = evaluateExpression(blockStatement-> + theExpression, NO_FIXUP); + blockSize += intValue(blockIncrement); + blockStatement = blockStatement->nextExpression; + expand((expandExpression(NULL), blockStatement!=NULL ? + moreText(", ") : 0)); + qfree(blockIncrement); + } + expand(endLine()); + if (blockSize >= 0) { + if (structNestingDepth != 0) { + while (blockSize-- > 0) + emitByte(0); + } else if (currentCodeMode == RELOCATABLE_BUFFER) { + while (blockSize-- > 0) + emitByte(0); + } else { + if (produceLinkableObject) + reserveAbsolute(currentLocationCounter.value, + blockSize); + currentLocationCounter.value += blockSize; + } + } else + error(NEGATIVE_BLOCK_SIZE_ERROR); +} + + void +assembleByteStatement(byteStatement) + byteStatementBodyType *byteStatement; +{ + valueType *byteValue; + + valueType *evaluateExpression(); + + nullAssemble(byteStatement); + expand(moreText("byte\t")); + while (byteStatement != NULL) { + byteValue = evaluateExpression(byteStatement->theExpression, + BYTE_FIXUP); + if (byteValue->kindOfValue == STRING_VALUE) { + emitString(byteValue->value); + } else { + putFixupsHere(BYTE_FIXUP, 0); + emitByteValue(byteValue); + } + qfree(byteValue); + byteStatement = byteStatement->nextExpression; + expand((expandExpression(NULL), byteStatement != NULL ? + moreText(", ") : 0)); + } + expand(endLine()); +} + + void +assembleConstrainStatement(constrainStatement) + constrainStatementBodyType *constrainStatement; +{ + valueType *constraintValue; + int constraint; + addressType startAddress; + addressType endAddress; + bool saveExpansion; + + valueType *evaluateExpression(); + + expansionOff(); + constraintValue = evaluateExpression(constrainStatement->constraint, + NO_FIXUP); + expansionOn(); + if (constraintValue == NULL || constraintValue->kindOfValue != + ABSOLUTE_VALUE) { + error(INVALID_CONSTRAINT_VALUE_ERROR); + return; + } + constraint = constraintValue->value; + expand((moreText("constrain (0x%x) {", constraint), endLine(), + tabCount++)); + if (currentCodeMode == ABSOLUTE_BUFFER) { + startAddress = currentLocationCounter.value; + assembleBlock(constrainStatement->constrainedBlock); + endAddress = currentLocationCounter.value; + if ((startAddress / constraint) != (endAddress / constraint)) + error(CONSTRAINT_ERROR, constraint); + } else { + if (insideConstraintBlock) { + error(CONSTRAIN_INSIDE_CONSTRAIN_ERROR); + assembleBlock(constrainStatement->constrainedBlock); + } else { + insideConstraintBlock = TRUE; + addBreak(CONSTRAIN_BREAK, constraint); + assembleBlock(constrainStatement->constrainedBlock); + addBreak(END_CONSTRAIN_BREAK, 0); + insideConstraintBlock = FALSE; + } + } + expand((tabCount--, startLineMarked(), tabIndent(), moreText("}"), + endLine())); +} + + void +assembleDbyteStatement(dbyteStatement) + dbyteStatementBodyType *dbyteStatement; +{ + valueType *wordValue; + + valueType *evaluateExpression(); + valueType *swabValue(); + + nullAssemble(dbyteStatement); + expand(moreText("dbyte\t")); + while (dbyteStatement != NULL) { + wordValue = swabValue(evaluateExpression(dbyteStatement-> + theExpression, DBYTE_FIXUP)); + dbyteStatement = dbyteStatement->nextExpression; + expand((expandExpression(NULL), dbyteStatement != NULL ? + moreText(", ") : 0)); + putFixupsHere(DBYTE_FIXUP, 0); + emitWordValue(wordValue); + qfree(wordValue); + } + expand(endLine()); +} + + void +assembleDefineStatement(defineStatement) + defineStatementBodyType *defineStatement; +{ + symbolTableEntryType *symbolToDefine; + symbolInContextType *contextToDefine; + bool saveExpansion; + + valueType *evaluateDefineExpression(); + valueType *newValue(); + symbolTableEntryType *effectiveSymbol(); + + nullAssemble(defineStatement); + symbolToDefine = effectiveSymbol(defineStatement->theSymbol, + &contextToDefine); + if (isDefinable(contextToDefine)) { + expand(moreText("define %s = ", symbName(symbolToDefine))); + if (contextToDefine->usage == DEAD_SYMBOL) { + reincarnateSymbol(contextToDefine, DEFINE_SYMBOL); + } else if (contextToDefine->usage == NESTED_UNKNOWN_SYMBOL) { + contextToDefine->usage = DEFINE_SYMBOL; + } + if (alreadyDefined(contextToDefine)) + error(REDEFINITION_OF_SYMBOL_ERROR, symbName( + symbolToDefine)); + else { + if (defineStatement->theValue != NULL) { + contextToDefine->value = + evaluateDefineExpression( + defineStatement->theValue); + contextToDefine->usage = DEFINE_SYMBOL; + expand(expandExpression(NULL)); + } else + contextToDefine->value = newValue(FAIL, 0, + EXPRESSION_OPND); + contextToDefine->environmentNumber = + GLOBAL_ENVIRONMENT_NUMBER; + contextToDefine->attributes |= DEFINED_VARIABLE_ATT; + } + expand(endLine()); + } else { + error(SYMBOL_ALREADY_THERE_ERROR, symbName(symbolToDefine)); + } +} + + void +assembleDoUntilStatement(doUntilStatement) + doUntilStatementBodyType *doUntilStatement; +{ + valueType topOfLoop; + + simpleFixupListType *emitJump(); + + nullAssemble(doUntilStatement); + topOfLoop = currentLocationCounter; + if (doUntilStatement->doUntilCondition == NEVER_COND) + topOfLoop.value -= targetOffset; + expand((moreText("do {"), endLine(), tabCount++)); + assembleBlock(doUntilStatement->doUntilLoop); + expand((tabCount--, startLineMarked(), tabIndent(), + moreText("} until %s", conditionString(doUntilStatement-> + doUntilCondition)), endLine())); + if (doUntilStatement->doUntilCondition == ALWAYS_COND) { + return; + } else if (doUntilStatement->doUntilCondition != NEVER_COND) { + emitRelativeBranch(invertConditionCode(doUntilStatement-> + doUntilCondition), &topOfLoop, NULL); + } else { + emitJump(&topOfLoop, NULL); + } +} + + void +assembleDoWhileStatement(doWhileStatement) + doWhileStatementBodyType *doWhileStatement; +{ + valueType topOfLoop; + + simpleFixupListType *emitJump(); + + nullAssemble(doWhileStatement); + topOfLoop = currentLocationCounter; + if (doWhileStatement->doWhileCondition == ALWAYS_COND) + topOfLoop.value -= targetOffset; + expand((moreText("do {"), endLine(), tabCount++)); + assembleBlock(doWhileStatement->doWhileLoop); + expand((tabCount--, startLineMarked(), tabIndent(), + moreText("} while %s", conditionString(doWhileStatement-> + doWhileCondition)), endLine())); + if (doWhileStatement->doWhileCondition == NEVER_COND) { + return; + } else if (doWhileStatement->doWhileCondition != ALWAYS_COND) { + emitRelativeBranch(doWhileStatement->doWhileCondition, + &topOfLoop, NULL); + } else { + emitJump(&topOfLoop, NULL); + } +} + + void +assembleExternStatement(externStatement) + externStatementBodyType *externStatement; +{ + symbolInContextType *context; + symbolTableEntryType *theSymbol; + + symbolInContextType *getBaseContext(); + symbolTableEntryType *effectiveSymbol(); + + expand(moreText("extern\t")); + while (externStatement != NULL) { + theSymbol = effectiveSymbol(externStatement->theSymbol, + &context); + expand(moreText("%s", symbName(theSymbol))); + if (context != NULL) { + if (context->usage == LABEL_SYMBOL || context->usage + == EXTERNAL_SYMBOL || context->usage + == UNKNOWN_SYMBOL || context->usage + == NESTED_UNKNOWN_SYMBOL) { + context->attributes |= GLOBAL_ATT; + } else { + error(BAD_KIND_OF_SYMBOL_TO_MAKE_EXTERNAL_ERROR, + usageString(context->usage)); + } + } + externStatement = externStatement->nextIdentifier; + expand(externStatement != NULL ? moreText(", ") : 0); + } + expand(endLine()); +} + + void +assembleFreturnStatement(freturnStatement) + freturnStatementBodyType *freturnStatement; +{ + freturnExit = TRUE; + resultOfLastFunctionCall = evaluateExpression(freturnStatement, + NO_FIXUP_OK); +} + + void +assembleFunctionStatement(functionStatement) + functionStatementBodyType *functionStatement; +{ + symbolTableEntryType *newFunctionSymbol; + functionDefinitionType *newFunction; + symbolInContextType *context; + + symbolTableEntryType *lookupOrEnterSymbol(); + valueType *newValue(); + symbolInContextType *getBaseContext(); + + nullAssemble(functionStatement); + if (currentEnvironment != &globalEnvironment) { + error(FUNCTION_DEFINITION_INSIDE_FUNCTION_ERROR); + return; + } + newFunctionSymbol = lookupOrEnterSymbol(functionStatement-> + functionName, FUNCTION_SYMBOL); + context = getBaseContext(newFunctionSymbol); + if (context->usage != FUNCTION_SYMBOL) { + if (context->usage == UNKNOWN_FUNCTION_SYMBOL) { + context->usage = FUNCTION_SYMBOL; + } else { + error(SYMBOL_ALREADY_THERE_ERROR, symbName( + newFunctionSymbol)); + return; + } + } else if (isDefined(context->value)) { + error(FUNCTION_ALREADY_EXISTS_ERROR, symbName( + newFunctionSymbol)); + return; + } + newFunction = typeAlloc(functionDefinitionType); + newFunction->functionName = newFunctionSymbol; + newFunction->arguments = functionStatement->theArguments; + newFunction->body = functionStatement->theBlock; + newFunction->ordinal = -1; + newFunction->nextExternalFunction = NULL; + context->value = newValue(FUNCTION_VALUE, newFunction, + EXPRESSION_OPND); + context->environmentNumber = GLOBAL_ENVIRONMENT_NUMBER; +} + + void +assembleGroupStatement(groupStatement) + blockType *groupStatement; +{ + expand((startLineMarked(), tabIndent(), moreText("{"), endLine(), + tabCount++)); + assembleBlock(groupStatement); + expand((tabCount--, startLineMarked(), tabIndent(), moreText("}"), + endLine())); +} + + simpleFixupListType * +assembleIfStatement(ifStatement, terminalIf, ongoingFixupList) + ifStatementBodyType *ifStatement; + bool terminalIf; + simpleFixupListType *ongoingFixupList; +{ + valueType fixupLocation1[COMPOUND_BRANCH_MAX]; + simpleFixupListType *fixupLocation2; + + simpleFixupListType *emitJump(); + void assembleIfStatementOldStyle(); + + if (backwardsCompatibleIfFlag) { + assembleIfStatementOldStyle(ifStatement); + return(NULL); + } + + nullAssemble(ifStatement); + fixupLocation2 = ongoingFixupList; + if (ifStatement->ifCondition != ALWAYS_COND && ifStatement-> + ifCondition != NEVER_COND) { + emitRelativeBranch(invertConditionCode(ifStatement-> + ifCondition), NULL, fixupLocation1); + expand((moreText("if %s {", conditionString(ifStatement-> + ifCondition)), endLine(), tabCount++)); + } else if (ifStatement->ifCondition == ALWAYS_COND) { + expand((moreText("{"), endLine(), tabCount++)); + } + if (ifStatement->consequence != NULL && ifStatement->ifCondition != + NEVER_COND) + fixupLocation2 = assembleBlockInsideIf(ifStatement-> + consequence, fixupLocation2); + expand((tabCount--, startLineMarked())); + if (ifStatement->continuation.continuationBodyUnion != NULL && + ifStatement->ifCondition != NEVER_COND && + ifStatement->ifCondition != ALWAYS_COND) + fixupLocation2 = emitJump(NULL, fixupLocation2); + if (ifStatement->ifCondition != ALWAYS_COND && ifStatement-> + ifCondition != NEVER_COND) + fixupBranch(fixupLocation1, currentLocationCounter); + if (ifStatement->continuation.continuationBodyUnion != NULL && + ifStatement->ifCondition != ALWAYS_COND) { + expand((tabIndent(), moreText("} else "))); + fixupLocation2 = assembleIfStatement(ifStatement-> + continuation, terminalIf, fixupLocation2); + } else { + expand((tabIndent(), moreText("}"), endLine())); + } + if (terminalIf) { + return(fixupLocation2); + } else { + fixupJump(fixupLocation2, currentLocationCounter); + return(NULL); + } +} + + void +assembleIfStatementOldStyle(ifStatement) + ifStatementBodyType *ifStatement; +{ + valueType fixupLocation1[COMPOUND_BRANCH_MAX]; + simpleFixupListType *fixupLocation2; + + simpleFixupListType *emitJump(); + + nullAssemble(ifStatement); + if (ifStatement->ifCondition != ALWAYS_COND) { + emitRelativeBranch(invertConditionCode(ifStatement-> + ifCondition), NULL, fixupLocation1); + expand((moreText("if %s {", conditionString(ifStatement-> + ifCondition)), endLine(), tabCount++)); + } else { + expand((moreText("{"), endLine(), tabCount++)); + } + if (ifStatement->consequence != NULL) + assembleBlock(ifStatement->consequence); + expand((tabCount--, startLineMarked())); + if (ifStatement->continuation.continuationBodyUnion != NULL) + fixupLocation2 = emitJump(NULL, NULL); + if (ifStatement->ifCondition != ALWAYS_COND) + fixupBranch(fixupLocation1, currentLocationCounter); + if (ifStatement->continuation.continuationBodyUnion != NULL) { + expand((tabIndent(), moreText("} else "))); + assembleIfStatementOldStyle(ifStatement->continuation); + } else { + expand((tabIndent(), moreText("}"), endLine())); + } + if (ifStatement->continuation.continuationBodyUnion != NULL) + fixupJump(fixupLocation2, currentLocationCounter); +} + + void +assembleIncludeStatement(includeStatement) + includeStatementBodyType *includeStatement; +{ + stringType *fileName; + valueType *possibleFileName; + bool saveExpansion; + valueType *evaluateExpression(); + stringType *saveString(); + + expansionOff(); + possibleFileName = evaluateExpression(includeStatement, NO_FIXUP); + expansionOn(); + if (possibleFileName->kindOfValue == STRING_VALUE) { + fileName = (stringType *)possibleFileName->value; + newIncludeFile = TRUE; + expand((moreText("include \"%s\"", fileName), endLine())); + pushInputFileStack(saveString(fileName)); + } else { + error(INCLUDE_FILE_NOT_A_STRING_VALUE_ERROR); + } +} + + void +assembleInstructionStatement(instructionStatement, cumulativeLineNumber) + instructionStatementBodyType *instructionStatement; + int cumulativeLineNumber; +{ + nullAssemble(instructionStatement); + switch(instructionStatement->kindOfInstruction) { + + case OPCODE_INSTRUCTION: + if (amListing()) + saveIndexForListing(INSTRUCTION_STATEMENT, + cumulativeLineNumber); + expand((startLine(), expandLabel(), tabIndent())); + assembleMachineInstruction(instructionStatement-> + theInstruction, instructionStatement->theOperands); + break; + + case MACRO_INSTRUCTION: + if (amListing() && !amExpanding()) + saveIndexForListing(INSTRUCTION_STATEMENT, + cumulativeLineNumber); + assembleMacro(instructionStatement->theInstruction, + instructionStatement->theOperands); + break; + + default: + botch("bad instruction type=%d\n", instructionStatement-> + kindOfInstruction); + break; + } +} + + void +assembleLongStatement(longStatement) + longStatementBodyType *longStatement; +{ + valueType *longValue; + + valueType *evaluateExpression(); + + nullAssemble(longStatement); + expand(moreText("long\t")); + while (longStatement != NULL) { + longValue = evaluateExpression(longStatement->theExpression, + LONG_FIXUP); + longStatement = longStatement->nextExpression; + expand((expandExpression(NULL), longStatement != NULL ? + moreText(", ") : 0)); + putFixupsHere(LONG_FIXUP, 0); + emitLongValue(longValue); + qfree(longValue); + } + expand(endLine()); +} + + void +assembleMacroStatement(macroStatement) + macroStatementBodyType *macroStatement; +{ + macroTableEntryType *newMacro; + + macroTableEntryType *installMacro(); + + nullAssemble(macroStatement); + if (currentEnvironment != &globalEnvironment) { + error(MACRO_DEFINITION_INSIDE_MACRO_ERROR); + return; + } + newMacro = macroStatement->theMacro; + if (newMacro == NULL) + return; + if (newMacro->body != NULL) { + error(MACRO_ALREADY_EXISTS_ERROR, macroStatement->theMacro-> + macroName); + return; + } + newMacro->arguments = macroStatement->theArguments; + newMacro->body = macroStatement->theBlock; +} + + void +assembleMdefineStatement(mdefineStatement) + defineStatementBodyType *mdefineStatement; +{ + bool saveExpansion; + valueType *evaluateDefineExpression(); + + nullAssemble(mdefineStatement); + expansionOff(); + pushBinding(mdefineStatement->theSymbol, evaluateDefineExpression( + mdefineStatement->theValue), MDEFINE_SYMBOL); + expansionOn(); + addNewLocalVariable(mdefineStatement->theSymbol); +} + + void +assembleMdoUntilStatement(mdoUntilStatement) + mdoUntilStatementBodyType *mdoUntilStatement; +{ + bool saveListingOn; + + nullAssemble(mdoUntilStatement); + saveListingOn = listingOn; + do { + assembleBlock(mdoUntilStatement->mdoUntilLoop); + listingOn = amExpanding(); + } while (!booleanTest(mdoUntilStatement->mdoUntilCondition)); + listingOn = saveListingOn; +} + + void +assembleMdoWhileStatement(mdoWhileStatement) + mdoWhileStatementBodyType *mdoWhileStatement; +{ + bool saveListingOn; + + nullAssemble(mdoWhileStatement); + saveListingOn = listingOn; + do { + assembleBlock(mdoWhileStatement->mdoWhileLoop); + listingOn = amExpanding(); + } while (booleanTest(mdoWhileStatement->mdoWhileCondition)); + listingOn = saveListingOn; +} + + void +assembleMforStatement(mforStatement) + mforStatementBodyType *mforStatement; +{ + bool saveListingOn; + bool saveExpansion; + + nullAssemble(mforStatement); + saveListingOn = listingOn; + expansionOff(); + for (evaluateExpression(mforStatement->initExpression, NO_FIXUP); + booleanTest(mforStatement->testExpression); + evaluateExpression(mforStatement->incrExpression, NO_FIXUP)) { + expansionOn(); + assembleBlock(mforStatement->forLoop); + listingOn = amExpanding(); + expansionOff(); + } + expansionOn(); + listingOn = saveListingOn; +} + + void +assembleMifStatement(mifStatement, cumulativeLineNumber) + mifStatementBodyType *mifStatement; + int cumulativeLineNumber; +{ + while (mifStatement != NULL) { + if (mifStatement->mifCondition == NULL) { + assembleBlock(mifStatement->mifConsequence); + break; + } else if (booleanTest(mifStatement->mifCondition)) { + assembleBlock(mifStatement->mifConsequence); + break; + } else { + mifStatement = mifStatement->mifContinuation. + mifContinuationBodyUnion; + } + } + if (amListing()) + saveEndMifForListing(cumulativeLineNumber); +} + + void +assembleMswitchStatement(mswitchStatement) + mswitchStatementBodyType *mswitchStatement; +{ + valueType *switchValue; + caseListType *caseList; + caseType *theCase; + bool matched; + expressionListType *tagExpressionList; + valueType *tagValue; + bool saveExpansion; + valueType *evaluateExpression(); + + expansionOff(); + switchValue = evaluateExpression(mswitchStatement->switchExpression, + NO_FIXUP); + expansionOn(); + if (switchValue->kindOfValue != ABSOLUTE_VALUE && switchValue->kindOfValue + != STRING_VALUE) { + error(INVALID_SWITCH_VALUE_KIND, valueKindString(switchValue-> + kindOfValue)); + return; + } + for (caseList=mswitchStatement->cases; caseList!=NULL; caseList=caseList-> + nextCase) { + theCase = caseList->theCase; + if (theCase->caseTags == NULL) { + assembleBlock(theCase->caseBody); + break; + } else { + matched = FALSE; + for (tagExpressionList=theCase->caseTags; tagExpressionList!=NULL; + tagExpressionList=tagExpressionList->nextExpression) { + expansionOff(); + tagValue = evaluateExpression(tagExpressionList-> + theExpression, NO_FIXUP); + expansionOn(); + if (tagValue->kindOfValue != ABSOLUTE_VALUE && tagValue-> + kindOfValue != STRING_VALUE) { + error(INVALID_CASE_VALUE_KIND, valueKindString(tagValue-> + kindOfValue)); + continue; + } + if (tagValue->kindOfValue != switchValue->kindOfValue) + continue; + if (tagValue->kindOfValue == ABSOLUTE_VALUE) { + if (tagValue->value != switchValue->value) + continue; + } else { + if (strcmplc(tagValue->value, switchValue->value) != 0) + continue; + } + matched = TRUE; + break; + } + if (matched) { + assembleBlock(theCase->caseBody); + break; + } + } + } +} + + void +assembleMvariableStatement(mvariableStatement) + mvariableStatementBodyType *mvariableStatement; +{ + identifierListType *newLocalVariable; + int initCount; + bool saveExpansion; + + valueType *createArray(); + int expressionListLength(); + + nullAssemble(mvariableStatement); + expansionOff(); + if (mvariableStatement->theDimension == NULL) { + if ((initCount = expressionListLength(mvariableStatement-> + theValue)) == 1) { + pushBinding(mvariableStatement->theSymbol, + evaluateExpression(mvariableStatement-> + theValue->theExpression, NO_FIXUP), + MVARIABLE_SYMBOL); + } else if (initCount > 1) { + error(TOO_MANY_VARIABLE_INITIALIZERS_ERROR); + } else { + pushBinding(mvariableStatement->theSymbol, NULL, + MVARIABLE_SYMBOL); + } + } else { + pushBinding(mvariableStatement->theSymbol, createArray( + mvariableStatement->theDimension, mvariableStatement-> + theValue), MVARIABLE_SYMBOL); + } + expansionOn(); + newLocalVariable = typeAlloc(identifierListType); + newLocalVariable->theSymbol = mvariableStatement->theSymbol; + newLocalVariable->nextIdentifier = currentLocalVariableList; + currentLocalVariableList = newLocalVariable; +} + + void +assembleMwhileStatement(mwhileStatement) + mwhileStatementBodyType *mwhileStatement; +{ + bool saveListingOn; + + nullAssemble(mwhileStatement); + saveListingOn = listingOn; + while (booleanTest(mwhileStatement->mwhileCondition)) { + assembleBlock(mwhileStatement->mwhileLoop); + listingOn = amExpanding(); + } + listingOn = saveListingOn; +} + + void +assembleOrgStatement(orgStatement) + orgStatementBodyType *orgStatement; +{ + valueType *orgAddress; + bool saveExpansion; + valueType *evaluateExpression(); + + nullAssemble(orgStatement); + targetOffset = 0; + expansionOff(); + orgAddress = evaluateExpression(orgStatement, NO_FIXUP); + expansionOn(); + if (absoluteValue(orgAddress) || relocatableValue(orgAddress)) { + if (relocatableValue(¤tLocationCounter) && + absoluteValue(orgAddress)) { + savedRelocatableCurrentLocationCounter = + currentLocationCounter; + currentCodeMode = ABSOLUTE_BUFFER; + } + currentLocationCounter.kindOfValue = orgAddress->kindOfValue; + currentLocationCounter.value = orgAddress->value; + expand((moreText("org\t0x%x", orgAddress->value), endLine())); + } else { + error(BAD_ORG_ADDRESS_ERROR, valueKindString(orgAddress-> + kindOfValue)); + } + qfree(orgAddress); +} + + void +assemblePerformStatement(performStatement) + performStatementBodyType *performStatement; +{ + void evaluateExpressionStandalone(); + + nullAssemble(performStatement); + sideEffectFlag = FALSE; + evaluateExpressionStandalone(performStatement); + if (!sideEffectFlag) + warning(PERFORM_WITHOUT_SIDE_EFFECT_ERROR); +} + + void +assembleRelStatement(relStatement) + relStatementBodyType *relStatement; +{ + targetOffset = 0; + if (!relocatableValue(¤tLocationCounter)) { + currentLocationCounter = + savedRelocatableCurrentLocationCounter; + currentCodeMode = RELOCATABLE_BUFFER; + } + expand((moreText("rel"), endLine())); + addBreak(BREAK_BREAK, 0); +} + + void +assembleStartStatement(startStatement) + startStatementBodyType *startStatement; +{ + valueType *evaluateExpression(); + addressType addressValue(); + expressionType *generateFixupExpression(); + + nullAssemble(startStatement); + expand(moreText("start\t")); + if (haveUserStartAddress) { + expand((moreText("*fail*"), endLine())); + error(START_ADDRESS_ALREADY_GIVEN_ERROR); + } else { + startAddress = evaluateExpression(startStatement,NO_FIXUP_OK); + if (startAddress->kindOfValue == UNDEFINED_VALUE) { + startAddress = (valueType *)generateFixupExpression( + startStatement); + haveUserStartAddress = TRUE; + fixupStartAddress = TRUE; + } else if (startAddress->kindOfValue != ABSOLUTE_VALUE && + startAddress->kindOfValue!=RELOCATABLE_VALUE){ + expand((moreText("*fail*"), endLine())); + error(BAD_START_ADDRESS_ERROR); + } else { + expand((expandExpression(NULL), endLine())); + haveUserStartAddress = TRUE; + fixupStartAddress = FALSE; + } + } +} + + void +assembleStringStatement(stringStatement) + stringStatementBodyType *stringStatement; +{ + valueType *byteValue; + + valueType *evaluateExpression(); + + nullAssemble(stringStatement); + expand(moreText("string\t")); + while (stringStatement != NULL) { + byteValue = evaluateExpression(stringStatement->theExpression, + BYTE_FIXUP); + if (byteValue->kindOfValue == STRING_VALUE) { + emitString(byteValue->value); + emitByte('\0'); + } else { + putFixupsHere(BYTE_FIXUP, 0); + emitByteValue(byteValue); + } + qfree(byteValue); + stringStatement = stringStatement->nextExpression; + expand((expandExpression(NULL), stringStatement != NULL ? + moreText(", ") : 0)); + } + expand(endLine()); +} + + void +assembleStructStatement(structStatement) + structStatementBodyType *structStatement; +{ + nullAssemble(structStatement); + if (structStatement->structBody == NULL) + instantiateStruct(structStatement); + else + assembleStructDefinition(structStatement); +} + + void +assembleTargetStatement(targetStatement) + targetStatementBodyType *targetStatement; +{ + valueType *targetAddress; + bool saveExpansion; + valueType *evaluateExpression(); + + nullAssemble(targetStatement); + targetOffset = 0; + expansionOff(); + targetAddress = evaluateExpression(targetStatement, NO_FIXUP); + expansionOn(); + if (absoluteValue(targetAddress)) { + expand((moreText("target\t0x%x", targetAddress-> + value), endLine())); + targetOffset = currentLocationCounter.value - + targetAddress->value; + } else { + error(BAD_TARGET_ADDRESS_ERROR, valueKindString( + targetAddress->kindOfValue)); + } + qfree(targetAddress); +} + + void +assembleUndefineStatement(undefineStatement) + undefineStatementBodyType *undefineStatement; +{ + symbolTableEntryType *effectiveSymbol(); + + expand(moreText("undefine\t")); + while (undefineStatement != NULL) { + expand(moreText("%s", symbName(undefineStatement->theSymbol))); + purgeSymbol(effectiveSymbol(undefineStatement->theSymbol, + NULL)); + undefineStatement = undefineStatement->nextIdentifier; + expand(undefineStatement != NULL ? moreText(", ") : 0); + } + expand(endLine()); +} + + void +assembleVariableStatement(variableStatement) + variableStatementBodyType *variableStatement; +{ + symbolTableEntryType *newVariable; + symbolInContextType *contextForVariable; + int initCount; + + symbolTableEntryType *effectiveSymbol(); + valueType *createArray(); + int expressionListLength(); + + nullAssemble(variableStatement); + newVariable = effectiveSymbol(variableStatement->theSymbol, + &contextForVariable); + if (isPotentialVariable(contextForVariable)) { + expand(moreText("variable %s = ", symbName(newVariable))); + if (contextForVariable->usage == DEAD_SYMBOL) { + reincarnateSymbol(contextForVariable, VARIABLE_SYMBOL); + } else if (contextForVariable->usage == NESTED_UNKNOWN_SYMBOL) { + contextForVariable->usage = VARIABLE_SYMBOL; + } + if (alreadyDefined(contextForVariable)) { + error(REDEFINITION_OF_SYMBOL_ERROR, symbName(newVariable)); + } else { + if (variableStatement->theDimension == NULL) { + if ((initCount = expressionListLength(variableStatement-> + theValue)) == 1) { + contextForVariable->value = evaluateExpression( + variableStatement->theValue->theExpression, NO_FIXUP); + expand(expandExpression(NULL)); + } else { + if (initCount > 1) + error(TOO_MANY_VARIABLE_INITIALIZERS_ERROR); + expand(moreText("*fail*")); + contextForVariable->value = newValue(FAIL, 0, + EXPRESSION_OPND); + } + } else { + contextForVariable->value = createArray(variableStatement-> + theDimension, variableStatement->theValue); + } + contextForVariable->environmentNumber = GLOBAL_ENVIRONMENT_NUMBER; + contextForVariable->attributes |= DEFINED_VARIABLE_ATT; + } + expand(endLine()); + } else { + error(SYMBOL_ALREADY_THERE_ERROR, symbName(newVariable)); + } +} + + void +assembleWhileStatement(whileStatement) + whileStatementBodyType *whileStatement; +{ + valueType topOfLoop; + valueType fixupLocation[COMPOUND_BRANCH_MAX]; + + nullAssemble(whileStatement); + if (whileStatement->whileCondition == NEVER_COND) { + return; + } else if (whileStatement->whileCondition != ALWAYS_COND) { + emitRelativeBranch(invertConditionCode(whileStatement-> + whileCondition), NULL, fixupLocation); + topOfLoop = currentLocationCounter; + } else { + topOfLoop = currentLocationCounter; + topOfLoop.value -= targetOffset; + } + expand((moreText("while %s {", conditionString(whileStatement-> + whileCondition)), endLine(), tabCount++)); + assembleBlock(whileStatement->whileLoop); + expand((tabCount--, startLineMarked(), tabIndent(), moreText("}"), + endLine())); + if (whileStatement->whileCondition != ALWAYS_COND) { + emitRelativeBranch(whileStatement->whileCondition, &topOfLoop, + NULL); + fixupBranch(fixupLocation, currentLocationCounter); + } else { + emitJump(&topOfLoop, NULL); + } +} + + void +assembleWordStatement(wordStatement) + wordStatementBodyType *wordStatement; +{ + valueType *word; + + valueType *evaluateExpression(); + + nullAssemble(wordStatement); + expand(moreText("word\t")); + while (wordStatement != NULL) { + word = evaluateExpression(wordStatement->theExpression, + WORD_FIXUP); + wordStatement = wordStatement->nextExpression; + expand((expandExpression(NULL), wordStatement != NULL ? + moreText(", ") : 0)); + putFixupsHere(WORD_FIXUP, 0); + emitWordValue(word); + qfree(word); + } + expand(endLine()); +} + + bool +assembleStatementBody(kind, body, cumulativeLineNumber, worryAboutIf, + ifFixupList) + statementKindType kind; + statementBodyType body; + int cumulativeLineNumber; + bool worryAboutIf; + simpleFixupListType **ifFixupList; +{ + bool result; + + result = TRUE; + if (amListing() && kind != INSTRUCTION_STATEMENT && !beneathFunction) + saveIndexForListing(kind, cumulativeLineNumber); + switch (kind) { + + case ALIGN_STATEMENT: + sideEffectBomb(); + assembleAlignStatement(body); + if (amListing()) + saveIndexForListing(ALIGN_STATEMENT, + cumulativeLineNumber); + break; + + case ASSERT_STATEMENT: + assembleAssertStatement(body); + break; + + case BLOCK_STATEMENT: + sideEffectBomb(); + assembleBlockStatement(body); + break; + + case BYTE_STATEMENT: + sideEffectBomb(); + assembleByteStatement(body); + break; + + case CONSTRAIN_STATEMENT: + sideEffectBomb(); + assembleConstrainStatement(body); + break; + + case DBYTE_STATEMENT: + sideEffectBomb(); + assembleDbyteStatement(body); + break; + + case DEFINE_STATEMENT: + sideEffectBomb(); + assembleDefineStatement(body); + break; + + case DO_UNTIL_STATEMENT: + sideEffectBomb(); + assembleDoUntilStatement(body); + break; + + case DO_WHILE_STATEMENT: + sideEffectBomb(); + assembleDoWhileStatement(body); + break; + + case EXTERN_STATEMENT: + sideEffectBomb(); + assembleExternStatement(body); + break; + + case FRETURN_STATEMENT: + assembleFreturnStatement(body); +/* result = FALSE;*/ + break; + + case FUNCTION_STATEMENT: + assembleFunctionStatement(body); + break; + + case GROUP_STATEMENT: + assembleGroupStatement(body); + break; + + case IF_STATEMENT: + sideEffectBomb(); + if (worryAboutIf) { + *ifFixupList = assembleIfStatement(body, worryAboutIf, + *ifFixupList); + } else { + assembleIfStatement(body, worryAboutIf, NULL); + } + break; + + case INCLUDE_STATEMENT: + sideEffectBomb(); + assembleIncludeStatement(body); + break; + + case INSTRUCTION_STATEMENT: + sideEffectBomb(); + assembleInstructionStatement(body, cumulativeLineNumber); + break; + + case LONG_STATEMENT: + sideEffectBomb(); + assembleLongStatement(body); + break; + + case MACRO_STATEMENT: + assembleMacroStatement(body); + break; + + case MDEFINE_STATEMENT: + assembleMdefineStatement(body); + break; + + case MDO_UNTIL_STATEMENT: + assembleMdoUntilStatement(body); + break; + + case MDO_WHILE_STATEMENT: + assembleMdoWhileStatement(body); + break; + + case MFOR_STATEMENT: + assembleMforStatement(body); + break; + + case MIF_STATEMENT: + assembleMifStatement(body, cumulativeLineNumber); + break; + + case MSWITCH_STATEMENT: + assembleMswitchStatement(body); + break; + + case MVARIABLE_STATEMENT: + assembleMvariableStatement(body); + break; + + case MWHILE_STATEMENT: + assembleMwhileStatement(body); + break; + + case NULL_STATEMENT: + nullStatementFlag = TRUE; + expand(labeledLine() ? (startLineMarked(), expandLabel(), + endLine()) : 0); + break; + + case ORG_STATEMENT: + sideEffectBomb(); + assembleOrgStatement(body); + if (amListing()) + saveIndexForListing(ORG_STATEMENT, + cumulativeLineNumber); + break; + + case PERFORM_STATEMENT: + assemblePerformStatement(body); + break; + + case REL_STATEMENT: + sideEffectBomb(); + assembleRelStatement(body); + if (amListing()) + saveIndexForListing(REL_STATEMENT, + cumulativeLineNumber); + break; + + case START_STATEMENT: + assembleStartStatement(body); + break; + + case STRING_STATEMENT: + sideEffectBomb(); + assembleStringStatement(body); + break; + + case STRUCT_STATEMENT: + sideEffectBomb(); + assembleStructStatement(body); + break; + + case TARGET_STATEMENT: + sideEffectBomb(); + assembleTargetStatement(body); + break; + + case UNDEFINE_STATEMENT: + sideEffectBomb(); + assembleUndefineStatement(body); + break; + + case VARIABLE_STATEMENT: + sideEffectBomb(); + assembleVariableStatement(body); + break; + + case WHILE_STATEMENT: + sideEffectBomb(); + assembleWhileStatement(body); + break; + + case WORD_STATEMENT: + sideEffectBomb(); + assembleWordStatement(body); + break; + + default: + botch("assembleStatementBody doesn't know kind %d\n", kind); + break; + } +/* return(result);*/ + return(!freturnExit); +} + + void +assembleLabelList(labelList) + labelListType *labelList; +{ + valueType *newValue(); + + while (labelList != NULL) { + if (structNestingDepth == 0) + valueLabel(labelList->theLabel, + newValue(currentLocationCounter.kindOfValue, + currentLocationCounter.value, + EXPRESSION_OPND)); + else + valueField(labelList->theLabel, newValue(FIELD_VALUE, + currentFieldOffset, EXPRESSION_OPND)); + labelList = labelList->nextLabel; + } +} + + simpleFixupListType * +assembleStatement(statement, insideIf, ongoingFixupList) + statementType *statement; + bool insideIf; + simpleFixupListType *ongoingFixupList; +{ + char *saveFileName; + int saveLineNumber; + int saveCumulativeLineNumber; + simpleFixupListType *result; + + statementEvaluationDepth++; + expand(flushExpressionString()); + saveFileName = currentFileName; + saveLineNumber = currentLineNumber; + result = ongoingFixupList; + while (statement != NULL) { + currentFileName = statement->fileName; + currentLineNumber = statement->lineNumber; + expand(listableStatement(statement->kindOfStatement) ? + startLine() : 0); + assembleLabelList(statement->labels); + expand(listableStatement(statement->kindOfStatement) ? + (expandLabel(), tabIndent()) : 0); + if (assembleStatementBody(statement->kindOfStatement, + statement->statementBody, statement-> + cumulativeLineNumber, insideIf && + isLastStatementInBlock(statement), &result)) { + if (freeFlag && statementEvaluationDepth == 1) + freeStatement(statement); + statement = statement->nextStatement; + } else { + if (freeFlag && statementEvaluationDepth == 1) + freeStatement(statement); + freturnExit = TRUE; + break; + } + } + if (!newIncludeFile) { + currentFileName = saveFileName; + currentLineNumber = saveLineNumber; + } else { + newIncludeFile = FALSE; + } + statementEvaluationDepth--; + return(result); +} + + void +eatStatement(statement) + statementType *statement; +{ + if (debug) { + printf("assembling:\n"); + printStatement(statement); + } + assembleStatement(statement, FALSE, NULL); +} diff --git a/statementSemantics.o b/statementSemantics.o new file mode 100644 index 0000000000000000000000000000000000000000..f3a3bd3180fdad49ca232fff0a4b3485015019fc GIT binary patch literal 95142 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 = base + fixups->locationToFixup; + newFixup->kindOfFixup = fixups->kindOfFixup; + newFixup->theFixupExpression = fixups->theFixupExpression; + if (structNestingDepth == 0) { + newFixup->nextFixup = fixupList; + fixupList = newFixup; + } else { + newFixup->nextFixup = newStruct->structFixups; + newStruct->structFixups = newFixup; + } + fixups = fixups->nextFixup; + } +} + + void +putStructReferences(base, references) + int base; + expressionReferenceListType *references; +{ + expressionReferenceListType *newReference; + int currentMode; + + if (!produceLinkableObject) + return; + + currentMode = structNestingDepth==0 ? (int)currentCodeMode : + STRUCT_BUFFER; + while (references != NULL) { + newReference = typeAlloc(expressionReferenceListType); + newReference->relocation = references->relocation; + newReference->relocation.referenceAddress += base; + newReference->expressionReferenced = references-> + expressionReferenced; + newReference->nextReference = expressionReferenceList[ + currentMode]; + expressionReferenceList[currentMode] = newReference; + references = references->nextReference; + } +} + + void +instantiateStruct(structStatement) + structStatementBodyType *structStatement; +{ + int i; + int base; + symbolInContextType *context; + + symbolInContextType *getWorkingContext(); + +#define structInstance ((structInstanceType *) context->value->value) + + context = getWorkingContext(structStatement->structName); + if (context == NULL) + botch("struct doesn't have working context\n"); + if (context->usage != STRUCT_NAME_SYMBOL) { + error(NOT_A_STRUCT_NAME_ERROR, structStatement->structName-> + symbolName); + } else if (context->value->kindOfValue != STRUCT_VALUE) { + botch("struct name doesn't have struct value\n"); + } else { + expand((moreText("struct\t%s", structStatement->structName-> + symbolName), endLine())); + base = structNestingDepth==0 ? currentLocationCounter.value : + currentFieldOffset; + for (i=0; istructSize; i++) + emitByte(structInstance->structMap[i]); + putStructFixups(base, structInstance->structFixups); + putStructReferences(base, structInstance->structReferences); + } +} + + structInstanceType * +assembleStructDefinitionBody(structBody) + structBodyType *structBody; +{ + int i; + simpleFixupListType *dummy; + + newStruct = typeAlloc(structInstanceType); + newStruct->structFixups = NULL; + currentFieldOffset = 0; + while (structBody != NULL) { + expand(listableStatement(structBody->kindOfStatement) ? + startLine() : 0); + assembleLabelList(structBody->labels); + expand(listableStatement(structBody->kindOfStatement) ? + (expandLabel(), tabIndent()) : 0); + assembleStatementBody(structBody->kindOfStatement, + structBody->statementBody, FALSE, &dummy); + if (currentFieldOffset > MAXIMUM_ALLOWED_STRUCT_SIZE) { + error(STRUCT_TOO_BIG_ERROR); + return(NULL); + } + structBody = (blockType *)structBody->nextStatement; + } + newStruct->structSize = currentFieldOffset; + newStruct->structMap = (byte *)malloc(currentFieldOffset); + newStruct->structReferences = expressionReferenceList[STRUCT_BUFFER]; + for (i=0; istructMap[i] = structScratchBuffer[i]; + return(newStruct); +} + + void +assembleStructDefinition(structStatement) + structStatementBodyType *structStatement; +{ + symbolTableEntryType *name; + symbolInContextType *context; + + symbolTableEntryType *effectiveSymbol(); + + name = effectiveSymbol(structStatement->structName, &context); + if (context == NULL) + botch("struct definition doesn't have working context\n"); + if (context->usage != STRUCT_NAME_SYMBOL) + error(NOT_A_STRUCT_NAME_ERROR, structStatement->structName-> + symbolName); + else if (structNestingDepth > 0) + error(STRUCT_DEFINITION_INSIDE_STRUCT_DEFINITION_ERROR); + else { + structNestingDepth++; + expressionReferenceList[STRUCT_BUFFER] = NULL; + numberOfReferencesInList[STRUCT_BUFFER] = 0; + context->value->kindOfValue = STRUCT_VALUE; + expand((moreText("struct {"), endLine(), tabCount++)); + context->value->value = (int) + assembleStructDefinitionBody(structStatement->structBody); + expand((tabCount--, startLineMarked(), tabIndent(), + moreText("} %s", symbName(structStatement-> + structName)), endLine())); + context->environmentNumber = GLOBAL_ENVIRONMENT_NUMBER; + structNestingDepth--; + } +} diff --git a/structSemantics.o b/structSemantics.o new file mode 100644 index 0000000000000000000000000000000000000000..843e0d42f96d177453ffe18e7d5836621a681766 GIT binary patch literal 39212 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 O", + ">=", + "<<", + ">>", + "+", + "-", + "*", + "/", + "%", + "-", + "!", + "~", + "?", + "/", + ".", + "++", + "--", + }; + return(tokenTable[token-257]); +} diff --git a/tokenStrings_68000.c b/tokenStrings_68000.c new file mode 100644 index 0000000..6ac0be1 --- /dev/null +++ b/tokenStrings_68000.c @@ -0,0 +1,160 @@ +/* + tokenStrings_68000.c -- Target processor dependent string generators + for the Macross assembler (68000 version). + + Chip Morningstar -- Lucasfilm Ltd. + + 26-April-1985 + +*/ + +#include "macrossTypes.h" +#include "macrossGlobals.h" + +/* conditionString similarly deals with condition codes */ + char * +conditionString(condition) + conditionType condition; +{ +/* This table MUST be maintained congruently with the definition of the + enumerated type 'conditionType' */ + + static char *conditionStringTable[] = { + "(carry)", + "(equal)", + "(overflow)", + "(minus)", + "(lt)", + "(leq)", + "(ls)", + "(always)", + "(!carry)", + "(!equal)", + "(!overflow)", + "(plus)", + "(geq)", + "(gt)", + "(high)", + "(never)", + }; + return(conditionStringTable[(int)condition]); +} + + +/* tokenString similarly deals with parser tokens */ + + char * +tokenString(token) + int token; +{ +/* This table MUST be maintained congruently with the token definitions in + the file 'y.tab.h' as output by yacc. */ + + static char *tokenTable[] = { + "A0", + "A1", + "A2", + "A3", + "A4", + "A5", + "A6", + "A7", + "ALIGN", + "ASSERT", + "BLOCK", + "BYTE", + "CCR", + "CONSTRAIN", + "D0", + "D1", + "D2", + "D3", + "D4", + "D5", + "D6", + "D7", + "DBYTE", + "DEFINE", + "DFC", + "DO", + "ELSE", + "ELSEIF", + "ENDFILE", + "EOL", + "EXTERN", + "FRETURN", + "FUNCTION", + "HERE", + "IF", + "INCLUDE", + "L", + "LONG", + "MACRO", + "MCASE", + "MDEFAULT", + "MDEFINE", + "MDO", + "MELSE", + "MELSEIF", + "MFOR", + "MIF", + "MSWITCH", + "MUNTIL", + "MVARIABLE", + "MWHILE", + "ORG", + "PC", + "REL", + "SFC", + "SR", + "START", + "STRING", + "STRUCT", + "TARGET", + "UNDEFINE", + "UNTIL", + "USP", + "VARIABLE", + "VBR", + "W", + "WHILE", + "WORD", + "X", + "Y", + "ConditionCode", + "Identifier", + "MacroName", + "Number", + "Opcode", + "TextString", + "Assignment", + "||", + "^^", + "&&", + "|", + "^", + "&", + "==", + "!=", + "<", + "<=", + ">", + ">=", + "<<", + ">>", + "+", + "-", + "*", + "/", + "%", + "-", + "!", + "~", + "?", + "/", + ".", + "++", + "--", + }; + return(tokenTable[token-257]); +} diff --git a/y.tab.c b/y.tab.c new file mode 100644 index 0000000..4bc54f3 --- /dev/null +++ b/y.tab.c @@ -0,0 +1,1698 @@ + +# line 10 "macross_6502.y" + +#include "macrossTypes.h" +#include "macrossGlobals.h" + +# define A 257 +# define ALIGN 258 +# define ASSERT 259 +# define BLOCK 260 +# define BYTE 261 +# define CONSTRAIN 262 +# define DBYTE 263 +# define DEFINE 264 +# define DO 265 +# define ELSE 266 +# define ELSEIF 267 +# define ENDFILE 268 +# define EOL 269 +# define EXTERN 270 +# define FRETURN 271 +# define FUNCTION 272 +# define HERE 273 +# define IF 274 +# define INCLUDE 275 +# define LONG 276 +# define MACRO 277 +# define MCASE 278 +# define MDEFAULT 279 +# define MDEFINE 280 +# define MDO 281 +# define MELSE 282 +# define MELSEIF 283 +# define MFOR 284 +# define MIF 285 +# define MSWITCH 286 +# define MUNTIL 287 +# define MVARIABLE 288 +# define MWHILE 289 +# define ORG 290 +# define REL 291 +# define START 292 +# define STRING 293 +# define STRUCT 294 +# define TARGET 295 +# define UNDEFINE 296 +# define UNTIL 297 +# define VARIABLE 298 +# define WHILE 299 +# define WORD 300 +# define X 301 +# define Y 302 +# define ConditionCode 303 +# define Identifier 304 +# define MacroName 305 +# define Number 306 +# define Opcode 307 +# define TextString 308 +# define ASSIGN 309 +# define LOGICAL_OR 310 +# define LOGICAL_XOR 311 +# define LOGICAL_AND 312 +# define BITWISE_OR 313 +# define BITWISE_XOR 314 +# define BITWISE_AND 315 +# define EQUAL_TO 316 +# define NOT_EQUAL_TO 317 +# define LESS_THAN 318 +# define LESS_THAN_OR_EQUAL_TO 319 +# define GREATER_THAN 320 +# define GREATER_THAN_OR_EQUAL_TO 321 +# define LEFT_SHIFT 322 +# define RIGHT_SHIFT 323 +# define ADD 324 +# define SUB 325 +# define MUL 326 +# define DIV 327 +# define MOD 328 +# define UNARY_MINUS 329 +# define LOGICAL_NOT 330 +# define BITWISE_NOT 331 +# define HI_BYTE 332 +# define LO_BYTE 333 +# define SELECT 334 +# define INCREMENT 335 +# define DECREMENT 336 +#define yyclearin yychar = -1 +#define yyerrok yyerrflag = 0 +extern int yychar; +extern short yyerrflag; +#ifndef YYMAXDEPTH +#define YYMAXDEPTH 150 +#endif +#ifndef YYSTYPE +#define YYSTYPE int +#endif +YYSTYPE yylval, yyval; +# define YYERRCODE 256 +short yyexca[] ={ +-1, 1, + 0, -1, + -2, 0, +-1, 48, + 40, 242, + -2, 200, +-1, 158, + 40, 242, + -2, 200, +-1, 323, + 318, 0, + 319, 0, + 320, 0, + 321, 0, + -2, 222, +-1, 324, + 318, 0, + 319, 0, + 320, 0, + 321, 0, + -2, 223, +-1, 325, + 318, 0, + 319, 0, + 320, 0, + 321, 0, + -2, 224, +-1, 326, + 318, 0, + 319, 0, + 320, 0, + 321, 0, + -2, 225, +-1, 327, + 316, 0, + 317, 0, + -2, 226, +-1, 328, + 316, 0, + 317, 0, + -2, 227, + }; +# define YYNPROD 266 +# define YYLAST 1367 +short yyact[]={ + + 108, 207, 418, 526, 417, 357, 262, 415, 381, 293, + 292, 261, 356, 46, 41, 21, 201, 33, 12, 413, + 20, 183, 303, 19, 18, 343, 142, 245, 202, 17, + 398, 247, 16, 15, 143, 244, 9, 138, 5, 123, + 122, 119, 120, 121, 351, 556, 384, 184, 185, 138, + 555, 111, 112, 113, 114, 115, 116, 117, 118, 119, + 120, 121, 467, 160, 161, 162, 163, 138, 464, 347, + 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, + 178, 346, 179, 180, 181, 182, 349, 352, 353, 304, + 216, 419, 186, 187, 188, 189, 190, 191, 192, 193, + 124, 125, 123, 122, 119, 120, 121, 513, 476, 457, + 402, 215, 138, 354, 335, 286, 209, 210, 211, 212, + 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, + 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, + 205, 110, 199, 126, 128, 127, 129, 124, 125, 123, + 122, 119, 120, 121, 242, 243, 260, 256, 254, 138, + 11, 252, 250, 99, 99, 257, 258, 237, 240, 433, + 106, 431, 213, 358, 359, 239, 419, 264, 388, 432, + 387, 430, 110, 276, 278, 248, 412, 391, 372, 559, + 139, 204, 525, 409, 103, 104, 289, 290, 291, 300, + 294, 295, 259, 296, 297, 3, 298, 299, 99, 85, + 437, 554, 553, 542, 538, 301, 132, 130, 131, 126, + 128, 127, 129, 124, 125, 123, 122, 119, 120, 121, + 314, 311, 313, 241, 536, 138, 502, 312, 501, 336, + 310, 309, 337, 492, 491, 342, 308, 344, 345, 307, + 306, 159, 4, 305, 471, 196, 195, 107, 200, 164, + 300, 470, 350, 360, 361, 362, 363, 364, 365, 366, + 355, 215, 573, 246, 246, 367, 368, 552, 246, 544, + 370, 130, 131, 126, 128, 127, 129, 124, 125, 123, + 122, 119, 120, 121, 532, 378, 379, 531, 530, 138, + 522, 389, 517, 496, 348, 493, 441, 144, 562, 382, + 61, 263, 99, 203, 475, 49, 275, 61, 274, 314, + 311, 313, 268, 266, 197, 70, 312, 165, 151, 310, + 309, 392, 371, 150, 149, 308, 383, 148, 307, 306, + 147, 558, 528, 529, 401, 528, 529, 405, 406, 407, + 408, 410, 411, 414, 421, 422, 423, 146, 208, 424, + 425, 58, 110, 394, 396, 145, 10, 399, 58, 110, + 419, 395, 397, 420, 442, 443, 105, 444, 270, 376, + 102, 86, 448, 101, 100, 450, 194, 141, 451, 452, + 140, 434, 449, 91, 166, 393, 447, 446, 429, 455, + 527, 456, 285, 287, 458, 459, 314, 311, 313, 462, + 199, 61, 465, 312, 468, 454, 310, 309, 152, 152, + 206, 472, 308, 524, 110, 307, 306, 167, 480, 305, + 436, 481, 482, 483, 484, 485, 267, 479, 487, 488, + 489, 490, 478, 255, 253, 416, 474, 288, 91, 251, + 249, 302, 214, 386, 47, 45, 44, 495, 494, 497, + 43, 42, 58, 40, 504, 505, 106, 506, 507, 39, + 38, 509, 510, 37, 390, 512, 36, 35, 34, 265, + 498, 499, 377, 514, 32, 516, 31, 523, 518, 519, + 520, 521, 515, 30, 29, 28, 27, 26, 533, 152, + 25, 534, 61, 24, 535, 23, 22, 537, 14, 539, + 13, 7, 541, 6, 540, 154, 109, 2, 1, 0, + 91, 375, 0, 545, 0, 547, 0, 0, 548, 549, + 0, 0, 550, 269, 0, 271, 272, 273, 0, 0, + 0, 277, 0, 0, 153, 279, 280, 281, 282, 283, + 284, 560, 0, 58, 0, 0, 564, 565, 0, 566, + 0, 0, 0, 567, 0, 0, 568, 569, 0, 571, + 0, 0, 572, 0, 0, 0, 316, 317, 318, 319, + 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, + 330, 331, 332, 333, 334, 0, 0, 0, 0, 0, + 0, 338, 341, 99, 380, 0, 385, 136, 137, 135, + 133, 134, 132, 130, 131, 126, 128, 127, 129, 124, + 125, 123, 122, 119, 120, 121, 89, 78, 0, 55, + 54, 138, 53, 0, 0, 0, 0, 369, 0, 0, + 0, 0, 0, 0, 0, 83, 0, 0, 373, 374, + 152, 0, 0, 91, 339, 340, 88, 158, 0, 87, + 0, 90, 56, 57, 0, 0, 0, 0, 426, 52, + 428, 0, 0, 315, 0, 0, 0, 0, 92, 61, + 95, 89, 0, 93, 94, 96, 445, 0, 97, 98, + 0, 0, 0, 0, 0, 152, 152, 0, 0, 0, + 0, 400, 0, 0, 403, 0, 0, 0, 0, 0, + 0, 88, 158, 0, 87, 0, 90, 0, 0, 0, + 427, 0, 469, 435, 0, 438, 439, 440, 0, 473, + 58, 0, 477, 92, 91, 95, 99, 155, 93, 94, + 96, 0, 0, 97, 98, 0, 0, 0, 453, 0, + 0, 0, 0, 89, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 460, 461, 0, 463, 0, 0, + 466, 0, 0, 0, 0, 0, 508, 0, 0, 0, + 511, 156, 157, 88, 158, 110, 87, 0, 90, 134, + 132, 130, 131, 126, 128, 127, 129, 124, 125, 123, + 122, 119, 120, 121, 0, 92, 0, 95, 0, 138, + 93, 94, 96, 91, 500, 97, 98, 99, 503, 0, + 543, 0, 0, 0, 0, 0, 136, 137, 135, 133, + 134, 132, 130, 131, 126, 128, 127, 129, 124, 125, + 123, 122, 119, 120, 121, 486, 0, 0, 0, 0, + 138, 0, 0, 557, 0, 0, 561, 0, 563, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, + 0, 78, 82, 55, 54, 81, 53, 62, 51, 0, + 0, 198, 546, 76, 68, 67, 89, 49, 75, 83, + 66, 551, 0, 63, 72, 0, 99, 73, 70, 74, + 0, 65, 71, 79, 80, 77, 56, 57, 84, 69, + 0, 64, 50, 52, 0, 0, 88, 48, 60, 87, + 59, 90, 154, 0, 0, 570, 0, 91, 0, 0, + 0, 238, 0, 0, 154, 0, 0, 0, 92, 91, + 95, 0, 0, 93, 94, 96, 0, 0, 97, 98, + 8, 153, 78, 82, 55, 54, 81, 53, 62, 51, + 0, 0, 0, 153, 76, 68, 67, 89, 49, 75, + 83, 66, 0, 0, 63, 72, 0, 0, 73, 70, + 74, 0, 65, 71, 79, 80, 77, 56, 57, 84, + 69, 0, 64, 50, 52, 0, 0, 88, 48, 60, + 87, 59, 90, 0, 0, 0, 0, 0, 0, 0, + 99, 0, 0, 0, 0, 0, 0, 0, 0, 92, + 0, 95, 99, 0, 93, 94, 96, 0, 0, 97, + 98, 78, 82, 55, 54, 81, 53, 62, 51, 0, + 0, 0, 0, 76, 68, 67, 89, 49, 75, 83, + 66, 0, 0, 63, 72, 0, 0, 73, 70, 74, + 0, 65, 71, 79, 80, 77, 56, 57, 84, 69, + 91, 64, 50, 52, 0, 0, 88, 48, 60, 87, + 59, 90, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 404, 0, 0, 0, 92, 0, + 95, 0, 0, 93, 94, 96, 0, 0, 97, 98, + 0, 136, 137, 135, 133, 134, 132, 130, 131, 126, + 128, 127, 129, 124, 125, 123, 122, 119, 120, 121, + 0, 0, 0, 0, 0, 138, 0, 0, 0, 0, + 0, 0, 0, 0, 155, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 155, 0, 0, 0, + 89, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 89, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 156, 157, + 88, 158, 0, 87, 0, 90, 0, 0, 0, 0, + 156, 157, 88, 158, 0, 87, 0, 90, 0, 0, + 0, 0, 92, 0, 95, 0, 0, 93, 94, 96, + 0, 0, 97, 98, 92, 0, 95, 0, 0, 93, + 94, 96, 0, 0, 97, 98, 136, 137, 135, 133, + 134, 132, 130, 131, 126, 128, 127, 129, 124, 125, + 123, 122, 119, 120, 121, 0, 0, 0, 0, 0, + 138, 137, 135, 133, 134, 132, 130, 131, 126, 128, + 127, 129, 124, 125, 123, 122, 119, 120, 121, 0, + 0, 0, 0, 0, 138, 135, 133, 134, 132, 130, + 131, 126, 128, 127, 129, 124, 125, 123, 122, 119, + 120, 121, 0, 89, 0, 0, 0, 138, 133, 134, + 132, 130, 131, 126, 128, 127, 129, 124, 125, 123, + 122, 119, 120, 121, 0, 0, 0, 0, 0, 138, + 0, 0, 0, 88, 158, 0, 87, 0, 90, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 92, 0, 95, 0, 0, + 93, 94, 96, 0, 0, 97, 98 }; +short yypact[]={ + + -63,-1000, 694,-1000, -75,-1000,-1000,-1000, -73, 773, +-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000, +-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000, +-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000, +-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000, 199, -87, + -87, -87, -87, -87, -87, -87, -87, -87, 926, 899, + 899,-1000, -87, -87, -87, -87,-1000,-1000, 408, -87, + -87, -87, -87, -87, -87, -87, -87, -87, -87, -87, +-1000, -87, -87, -87, -87,-288,-1000,-1000,-1000,-1000, +-1000, -87, -87, -87, -87, -87, -87, -87, -87,-1000, + 165, 164, 284, 613,-1000,-1000,-1000, 200, 273, -78, +-1000, 273, 85, 408, 408, 408, 408, 408, -33, -87, + -87, -87, -87, -87, -87, -87, -87, -87, -87, -87, + -87, -87, -87, -87, -87, -87, -87, -87, -87,-1000, + 887, 189,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000, +-1000,-1000, 926, -87, -87,-1000, -56, -60,-1000,-1000, +-142,-143,-146,-147, -87, -87,-1000, 926,-148, 271, + 271, 85, 283, 282, 408,-148, 408, 408, 408, 278, + 276, 408, 408, -87,-1000,-1000, 408, 408, 408, 408, + 408, 408,-189,-189, 694, -87, -87, -87,-1000,-1000, +-1000, -66, -87, -87,-1000, -87, -87, 216, 926, 216, + 216, 216, 216,-1000, -87,-1000, 369, 408, 408, 408, + 408, 408, 408, 408, 408, 408, 408, 408, 408, 408, + 408, 408, 408, 408, 408, 408,-190,-1000, -87,-1000, +-1000, -87, 353, 408, -87,-309, -87, -87,-309,-1000, +-228,-1000,-240,-1000, -5,-1000, -47,-217,-191, 226, +-1000,-109, -87, -87, -87, -87, -87, -87, -87, 926, + 226, 926, 926, 926, -87, -87, 216, 926, 408, 516, +-297,-297,-297,-297,-297,-1000,-1000,-1000, 63, 408, + 408, 480,-1000,-1000, -87, -87, 85, 6, 85,-119, + -87,-193, 62,-1000,-1000, 369,-1000,-1000,-1000,-1000, +-1000,-1000,-1000,-1000,-1000, 199,-297,-297,-297,-267, +-267,-285,-285,-222,-222,-222,-222,-175,-175, -35, + 475, -99, 995, 950, 973,-1000, 899, 899, 926, -61, +-1000, 926, 408, -87,-194,1030, -87, -87, -87, 100, + -87, 93,-128,-128, -87, -87,-1000,-1000, -87, -87, + 85, 408, 85,-118, 408, 87, 408, 408, 408, 926, + 265, 694,-1000, 516, 516,-1000, -87,-1000, 41, 273, +-1000, -87,-1000, 6, -87,-1000,-1000, -87, -87, 408, +-1000,-1000, 369,-1000,-1000,-1000,-1000,-1000, -87,-309, + 516,-195,-1000, 516, -87, 408, 408, 408, 408,-241, + 408, 408,-247, -87, 85,-1000, 217,-1000,-1000, 163, + -87, 85, 274,-196, 40, 271,-1000, 516,-1000,-1000, + -87, -87, -87, -87, -87, 801,-1000, -87, 516, 516, + 516,-1000, 151, 150, 264,-1000,-1000, -66, 262,-1000, + 6, 273, 273, 926,-1000, 408, 145,-1000, 143, 408, + 926, 926, 216, 516, -87, 216, 516, -87, 85,-1000, + -87, -87, 85,-1000, -87, 66,-1000,-1000,-1000,-109, + 261, 271, 271, 271, 271, 259, -87, 67, 257, 256, + 253,-1000,-1000,-1000,-1000,-1000,-1000, -87,-1000,-1000, + 516,-1000,-1000, 516, 141, 408, 121, 408,-1000,-213, + 120,-1000, 85,-1000, 238,-1000,-1000,-1000,-1000,-1000, +-1000,-1000, -87, 408, -87,-1000,-1000, -87, -87,-1000, +-1000, -87, 408, 236, 119, 118,-259, 216,-264, 216, +-1000,-1000,-1000,-1000,-1000, 85, 297, 64, 85, 268, + 85, 926,-1000,-1000,-1000, -87, -87,-1000, -87,-1000, +-1000,-1000, -87,-1000, 408, 408, 408, 408, 216, 216, + 926, 155, 231,-1000 }; +short yypgo[]={ + + 0, 518, 517, 252, 0, 516, 38, 513, 511, 36, + 366, 160, 18, 510, 508, 33, 32, 29, 24, 23, + 20, 15, 506, 505, 503, 500, 497, 496, 495, 494, + 493, 486, 484, 17, 478, 477, 476, 473, 470, 469, + 463, 14, 461, 460, 456, 455, 13, 454, 16, 10, + 9, 28, 307, 8, 453, 1, 358, 172, 452, 451, + 22, 89, 190, 450, 449, 259, 19, 7, 446, 202, + 445, 4, 2, 444, 443, 11, 12, 5, 6, 436, + 430, 423, 3, 400, 398, 394, 391, 390, 387, 26, + 34, 386, 27, 384, 383, 209, 381, 380, 379, 365, + 357, 340, 337, 334, 333, 328 }; +short yyr1[]={ + + 0, 1, 1, 2, 4, 4, 5, 5, 3, 3, + 6, 6, 6, 6, 7, 8, 9, 9, 11, 11, + 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, + 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, + 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, + 10, 10, 10, 10, 10, 10, 12, 12, 12, 48, + 51, 53, 53, 53, 49, 50, 50, 50, 50, 13, + 14, 54, 54, 15, 46, 55, 55, 44, 45, 45, + 16, 17, 18, 19, 21, 21, 57, 58, 59, 59, + 60, 60, 61, 61, 61, 61, 61, 61, 61, 61, + 61, 20, 23, 23, 23, 23, 24, 25, 63, 63, + 64, 64, 29, 29, 29, 29, 65, 66, 30, 32, + 69, 69, 68, 68, 67, 67, 67, 70, 70, 71, + 72, 27, 73, 73, 73, 73, 73, 28, 74, 74, + 74, 74, 74, 26, 33, 33, 33, 75, 78, 76, + 77, 77, 77, 77, 37, 79, 80, 80, 81, 81, + 82, 83, 83, 34, 35, 84, 84, 84, 84, 31, + 31, 85, 36, 86, 38, 39, 40, 41, 42, 47, + 43, 22, 62, 62, 87, 87, 87, 87, 87, 88, + 88, 88, 88, 89, 52, 91, 92, 92, 93, 93, + 94, 95, 95, 56, 56, 56, 56, 56, 56, 56, + 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, + 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, + 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, + 96, 96, 97, 98, 90, 90, 90, 90, 90, 90, + 90, 99, 100, 101, 102, 102, 102, 103, 103, 103, + 103, 103, 103, 104, 104, 105 }; +short yyr2[]={ + + 0, 4, 1, 0, 1, 0, 1, 2, 1, 3, + 1, 1, 2, 1, 2, 1, 1, 2, 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, 3, 4, 4, 3, + 5, 1, 2, 5, 3, 3, 3, 4, 4, 5, + 5, 3, 3, 3, 3, 1, 4, 9, 8, 7, + 3, 3, 3, 3, 3, 5, 1, 3, 1, 3, + 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 0, 1, 2, 1, 2, 1, 3, 1, 4, + 1, 4, 7, 6, 7, 6, 0, 1, 8, 3, + 1, 4, 2, 3, 1, 4, 1, 1, 4, 4, + 1, 3, 1, 4, 6, 9, 6, 3, 1, 4, + 6, 9, 6, 3, 3, 4, 4, 3, 5, 3, + 3, 3, 4, 4, 5, 5, 5, 3, 1, 3, + 3, 7, 1, 5, 5, 3, 3, 3, 3, 1, + 2, 1, 9, 7, 3, 3, 3, 3, 3, 3, + 1, 1, 1, 1, 1, 2, 4, 2, 4, 1, + 4, 2, 4, 1, 4, 0, 3, 4, 6, 6, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, + 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 2, 2, 3, 3, + 4, 6, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 3, 3, 1, 1, 1, 6, 6, 2, + 2, 3, 3, 8, 4, 8 }; +short yychk[]={ + +-1000, -1, -2, 268, -3, -6, -7, -8, 256, -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, 304, 274, + 299, 265, 300, 263, 261, 260, 293, 294, -56, 307, + 305, -52, 264, 280, 298, 288, 277, 272, 271, 296, + 285, 289, 281, 284, 286, 275, 270, 292, 258, 290, + 291, 262, 259, 276, 295, -95, -96, 306, 303, 273, + 308, 40, 325, 330, 331, 327, 332, 335, 336, 123, + -93, -94, -97, 269, 268, -10, -11, 58, -4, -5, + 269, -4, -4, -4, -4, -4, -4, -4, -4, 326, + 327, 328, 325, 324, 322, 323, 318, 320, 319, 321, + 316, 317, 315, 313, 314, 312, 310, 311, 334, -62, + -87, -88, -89, -90, -52, -99,-100,-101,-102,-103, +-104,-105, -56, 64, 35, 257, 301, 302, 304, -62, + -4, -4, -4, -4, -65, -65, -85, -56, -4, -4, + -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, + -4, -4, -4, 309, 335, 336, -4, -4, -4, -4, + -4, -4, -4, -4, -91, 91, 91, 40, 268, -6, + 58, -48, -51, 40, 269, -51, -52, -55, -56, -55, + -55, -55, -55, -57, -58, 304, 123, -4, -4, -4, + -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, + -4, -4, -4, -4, -4, -4, -4, -89, 44, -90, + -89, 44, -4, -4, 91, -92, 334, 91, -92, -63, + 304, -64, 304, -73, 304, -74, 304, -4, -4, -69, + 304, -75, -78, 40, -78, -52, 40, -79, 40, -56, + -69, -56, -56, -56, 40, 40, -55, -56, -4, -56, + -56, -56, -56, -56, -56, -95, 304, -95, -3, -4, + -4, -4, -49, -50, 266, 267, -4, -4, -4, -4, + 44, -4, -59, -60, -61, -9, -15, -16, -17, -18, + -19, -41, -20, -21, -46, 304, -56, -56, -56, -56, + -56, -56, -56, -56, -56, -56, -56, -56, -56, -56, + -56, -56, -56, -56, -56, 304, -4, -4, -56, 301, + 302, -56, -4, 334, -4, -4, 309, 309, 309, 91, + 309, 91, 304, 305, 304, 44, -76, -77, 282, 283, + -4, -4, -4, -4, -4, -4, -4, -4, -4, -56, + -4, 269, 125, -56, -56, 41, -98, -62, -4, -4, + -52, -53, 303, 330, 40, -52, -54, 299, 297, -4, + -57, 125, 269, -61, -89, -90, -89, -90, 91, -92, + -56, -4, 304, -56, 64, -4, -4, -4, -4, 93, + -4, -4, 93, -66, -4, -67, -70, -71, -72, 304, + -66, -4, -4, -4, -4, -4, -52, -56, -52, -84, + 299, 289, 297, 287, -86, -56, -80, 123, -56, -56, + -56, 41, -4, -4, -4, -52, -12, -48, -4, -53, + -4, -4, -4, -56, -60, -4, -4, 304, -4, -4, + -56, -56, -55, -56, 309, -55, -56, 309, -4, -52, + 44, 91, -4, -52, -68, 40, 304, -52, -33, -75, + -4, -4, -4, -4, -4, -4, 44, -4, -4, -4, + -4, 93, 93, 41, -49, -50, 41, -53, -51, -51, + -56, 93, 93, -56, -4, -4, -4, -4, -52, -4, + -4, -52, -4, 41, -67, -76, -77, 41, -78, -78, + -78, -78, 41, -4, -81, 125, -82, -83, 278, 279, + 41, 41, 41, -4, -4, -4, 93, -55, 93, -55, + -71, -72, 93, -52, 41, -4, -56, -4, -4, -4, + -4, -56, 41, 93, 93, 309, 309, -52, 44, 125, + -82, -52, 40, -52, -4, -4, -4, -4, -55, -55, + -56, -55, -4, 41 }; +short yydef[]={ + + 3, -2, 101, 2, 0, 8, 10, 11, 13, 101, + 15, 16, 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, 54, 55, -2, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 181, 102, + 104, 106, 5, 5, 5, 5, 116, 116, 169, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 180, 5, 5, 5, 5, 203, 204, 205, 206, 207, + 208, 5, 5, 5, 5, 5, 5, 5, 5, 195, + 201, 202, 0, 101, 12, 14, 17, 18, 0, 4, + 6, 0, 0, 0, 0, 0, 0, 0, 0, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 103, + 182, 183, 184, 189, 193, 244, 245, 246, 247, 248, + 249, 250, 251, 5, 5, 254, 255, 256, -2, 105, + 0, 0, 0, 0, 5, 5, 170, 171, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 5, 236, 237, 0, 0, 0, 0, + 0, 0, 0, 0, 101, 5, 5, 5, 1, 9, + 19, 56, 5, 5, 7, 5, 5, 73, 75, 80, + 81, 82, 83, 84, 5, 86, 101, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 185, 5, 191, + 187, 5, 0, 0, 5, 259, 5, 5, 260, 107, + 108, 143, 110, 131, 132, 137, 138, 0, 0, 119, + 120, 144, 5, 5, 5, 5, 5, 5, 5, 174, + 175, 176, 177, 178, 5, 5, 74, 179, 0, 5, + 210, 211, 212, 213, 214, 238, 200, 239, 0, 0, + 0, 0, 57, 58, 5, 5, 0, 0, 0, 0, + 5, 0, 0, 88, 90, 101, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 0, 215, 216, 217, 218, + 219, 220, 221, -2, -2, -2, -2, -2, -2, 228, + 229, 230, 231, 232, 233, 234, 0, 0, 252, 261, + 262, 253, 0, 5, 0, 0, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 145, 146, 5, 5, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 235, + 0, 101, 194, 5, 5, 240, 5, 243, 0, 0, + 59, 5, 61, 0, 5, 69, 70, 5, 5, 0, + 85, 87, 101, 91, 186, 192, 188, 190, 5, 264, + 5, 0, 196, 5, 5, 0, 0, 0, 0, 0, + 0, 0, 0, 5, 0, 117, 124, 126, 127, 130, + 5, 0, 0, 0, 0, 0, 147, 5, 163, 164, + 5, 5, 5, 5, 5, 0, 154, 5, 5, 5, + 5, 209, 0, 0, 0, 64, 65, 66, 0, 62, + 0, 0, 0, 76, 89, 0, 0, 197, 0, 0, + 109, 111, 133, 5, 5, 139, 5, 5, 0, 113, + 5, 5, 0, 115, 5, 0, 121, 149, 150, 151, + 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, + 0, 199, 198, 241, 67, 68, 60, 5, 71, 72, + 5, 257, 258, 5, 0, 0, 0, 0, 112, 0, + 0, 114, 0, 122, 0, 152, 153, 148, 165, 166, + 167, 168, 5, 0, 5, 157, 158, 5, 5, 162, + 155, 5, 79, 0, 0, 0, 134, 136, 140, 142, + 125, 128, 129, 118, 123, 0, 0, 0, 0, 0, + 0, 78, 63, 263, 265, 5, 5, 172, 5, 156, + 159, 160, 5, 77, 0, 0, 0, 0, 135, 141, + 173, 5, 0, 161 }; +#ifndef lint +static char yaccpar_sccsid[] = "@(#)yaccpar 1.1 83/07/20 SMI"; /* from UCB 4.1 83/02/11 */ +#endif + +# +# define YYFLAG -1000 +# define YYERROR goto yyerrlab +# define YYACCEPT return(0) +# define YYABORT return(1) + +/* parser for yacc output */ + +#ifdef YYDEBUG +int yydebug = 0; /* 1 for debugging */ +#endif +YYSTYPE yyv[YYMAXDEPTH]; /* where the values are stored */ +int yychar = -1; /* current input token number */ +int yynerrs = 0; /* number of errors */ +short yyerrflag = 0; /* error recovery flag */ + +yyparse() { + + short yys[YYMAXDEPTH]; + short yyj, yym; + register YYSTYPE *yypvt; + register short yystate, *yyps, yyn; + register YYSTYPE *yypv; + register short *yyxi; + + yystate = 0; + yychar = -1; + yynerrs = 0; + yyerrflag = 0; + yyps= &yys[-1]; + yypv= &yyv[-1]; + + yystack: /* put a state and value onto the stack */ + +#ifdef YYDEBUG + if( yydebug ) printf( "state %d, char 0%o\n", yystate, yychar ); +#endif + if( ++yyps> &yys[YYMAXDEPTH] ) { yyerror( "yacc stack overflow" ); return(1); } + *yyps = yystate; + ++yypv; + *yypv = yyval; + + yynewstate: + + yyn = yypact[yystate]; + + if( yyn<= YYFLAG ) goto yydefault; /* simple state */ + + if( yychar<0 ) if( (yychar=yylex())<0 ) yychar=0; + if( (yyn += yychar)<0 || yyn >= YYLAST ) goto yydefault; + + if( yychk[ yyn=yyact[ yyn ] ] == yychar ){ /* valid shift */ + yychar = -1; + yyval = yylval; + yystate = yyn; + if( yyerrflag > 0 ) --yyerrflag; + goto yystack; + } + + yydefault: + /* default state action */ + + if( (yyn=yydef[yystate]) == -2 ) { + if( yychar<0 ) if( (yychar=yylex())<0 ) yychar = 0; + /* look through exception table */ + + for( yyxi=yyexca; (*yyxi!= (-1)) || (yyxi[1]!=yystate) ; yyxi += 2 ) ; /* VOID */ + + while( *(yyxi+=2) >= 0 ){ + if( *yyxi == yychar ) break; + } + if( (yyn = yyxi[1]) < 0 ) return(0); /* accept */ + } + + if( yyn == 0 ){ /* error */ + /* error ... attempt to resume parsing */ + + switch( yyerrflag ){ + + case 0: /* brand new error */ + + yyerror( "syntax error" ); + yyerrlab: + ++yynerrs; + + case 1: + case 2: /* incompletely recovered error ... try again */ + + yyerrflag = 3; + + /* find a state where "error" is a legal shift action */ + + while ( yyps >= yys ) { + yyn = yypact[*yyps] + YYERRCODE; + if( yyn>= 0 && yyn < YYLAST && yychk[yyact[yyn]] == YYERRCODE ){ + yystate = yyact[yyn]; /* simulate a shift of "error" */ + goto yystack; + } + yyn = yypact[*yyps]; + + /* the current yyps has no shift onn "error", pop stack */ + +#ifdef YYDEBUG + if( yydebug ) printf( "error recovery pops state %d, uncovers %d\n", *yyps, yyps[-1] ); +#endif + --yyps; + --yypv; + } + + /* there is no state on the stack with an error shift ... abort */ + + yyabort: + return(1); + + + case 3: /* no shift yet; clobber input char */ + +#ifdef YYDEBUG + if( yydebug ) printf( "error recovery discards char %d\n", yychar ); +#endif + + if( yychar == 0 ) goto yyabort; /* don't discard EOF, quit */ + yychar = -1; + goto yynewstate; /* try again in the same state */ + + } + + } + + /* reduction by production yyn */ + +#ifdef YYDEBUG + if( yydebug ) printf("reduce %d\n",yyn); +#endif + yyps -= yyr2[yyn]; + yypvt = yypv; + yypv -= yyr2[yyn]; + yyval = yypv[1]; + yym=yyn; + /* consult goto table to find next state */ + yyn = yyr1[yyn]; + yyj = yypgo[yyn] + *yyps + 1; + if( yyj>=YYLAST || yychk[ yystate = yyact[yyj] ] != -yyn ) yystate = yyact[yypgo[yyn]]; + switch(yym){ + +case 1: +# line 64 "macross_6502.y" +{ + yyval = yypvt[-2]; +} break; +case 2: +# line 68 "macross_6502.y" +{ + yyval = 0; +} break; +case 3: +# line 74 "macross_6502.y" +{ + statementListNestingDepth = 0; + errorFlag = FALSE; +} break; +case 6: +# line 87 "macross_6502.y" +{ + if (amListing()) + saveEOLForListing(); +} break; +case 7: +# line 92 "macross_6502.y" +{ + if (amListing()) + saveEOLForListing(); +} break; +case 8: +# line 99 "macross_6502.y" +{ + if (statementListNestingDepth == 0) { + yyval = eatStatement(yypvt[-0]); + } else { + yyval = buildStatementList(yypvt[-0], NULL); + } +} break; +case 9: +# line 107 "macross_6502.y" +{ + if (statementListNestingDepth == 0) { + yyval = eatStatement(yypvt[-0]); + } else { + yyval = buildStatementList(yypvt[-0], yypvt[-2]); + } +} break; +case 12: +# line 119 "macross_6502.y" +{ + yyval = NULL; + YYACCEPT; +} break; +case 13: +# line 124 "macross_6502.y" +{ + yyerrok; + yyclearin; + resynchronizeInput(); + yyval = NULL; +} break; +case 14: +# line 134 "macross_6502.y" +{ + yyval = addLabelToStatement(yypvt[-1], yypvt[-0]); +} break; +case 16: +# line 144 "macross_6502.y" +{ + yyval = buildLabelList(yypvt[-0], NULL); +} break; +case 17: +# line 148 "macross_6502.y" +{ + yyval = buildLabelList(yypvt[-0], yypvt[-1]); +} break; +case 18: +# line 154 "macross_6502.y" +{ + yyval = lookupOrEnterSymbol(yypvt[-1], LABEL_SYMBOL); +} break; +case 19: +# line 158 "macross_6502.y" +{ + yyval = lookupOrEnterSymbol(yypvt[-2], LABEL_SYMBOL); + addAttributeToSymbol(yyval, TENTATIVE_GLOBAL_ATT); +} break; +case 56: +# line 204 "macross_6502.y" +{ + yyval = buildIfStatement(yypvt[-0], NULL, NO_CONTINUATION); +} break; +case 57: +# line 208 "macross_6502.y" +{ + yyval = buildIfStatement(yypvt[-1], yypvt[-0], ELSE_CONTINUATION); +} break; +case 58: +# line 212 "macross_6502.y" +{ + yyval = buildIfStatement(yypvt[-1], yypvt[-0], ELSEIF_CONTINUATION); +} break; +case 59: +# line 218 "macross_6502.y" +{ + yyval = buildIfHead(yypvt[-2], yypvt[-0]); +} break; +case 60: +# line 224 "macross_6502.y" +{ + yyval = yypvt[-2]; +} break; +case 62: +# line 232 "macross_6502.y" +{ + yyval = invertConditionCode(yypvt[-0]); +} break; +case 63: +# line 236 "macross_6502.y" +{ + yyval = yypvt[-2]; +} break; +case 64: +# line 242 "macross_6502.y" +{ + yyval = yypvt[-0]; +} break; +case 65: +# line 248 "macross_6502.y" +{ + yyval = extractIfBody(yypvt[-0]); +} break; +case 66: +# line 252 "macross_6502.y" +{ + yyval = extractIfBody(buildIfStatement(yypvt[-0], NULL, NO_CONTINUATION)); +} break; +case 67: +# line 256 "macross_6502.y" +{ + yyval = extractIfBody(buildIfStatement(yypvt[-1], yypvt[-0], ELSE_CONTINUATION)); +} break; +case 68: +# line 260 "macross_6502.y" +{ + yyval = extractIfBody(buildIfStatement(yypvt[-1], yypvt[-0], ELSEIF_CONTINUATION)); +} break; +case 69: +# line 266 "macross_6502.y" +{ + yyval = buildWhileStatement(yypvt[-2], yypvt[-0]); +} break; +case 70: +# line 272 "macross_6502.y" +{ + yyval = buildDoStatement(yypvt[-2], yypvt[-0]); +} break; +case 71: +# line 278 "macross_6502.y" +{ + yyval = buildDoEnd(yypvt[-0], WHILE_END); +} break; +case 72: +# line 282 "macross_6502.y" +{ + yyval = buildDoEnd(yypvt[-0], UNTIL_END); +} break; +case 73: +# line 288 "macross_6502.y" +{ + yyval = buildWordStatement(yypvt[-0]); +} break; +case 74: +# line 294 "macross_6502.y" +{ + yyval = buildLongStatement(yypvt[-0]); +} break; +case 75: +# line 300 "macross_6502.y" +{ + yyval = buildExpressionList(yypvt[-0], NULL); +} break; +case 76: +# line 304 "macross_6502.y" +{ + yyval = buildExpressionList(yypvt[-0], yypvt[-3]); +} break; +case 77: +# line 311 "macross_6502.y" +{ + yyval = buildConstrainStatement(yypvt[-4], yypvt[-0]); +} break; +case 78: +# line 318 "macross_6502.y" +{ + yyval = buildAssertStatement(yypvt[-3], yypvt[-0]); +} break; +case 79: +# line 322 "macross_6502.y" +{ + yyval = buildAssertStatement(yypvt[-2], NULL); +} break; +case 80: +# line 328 "macross_6502.y" +{ + yyval = buildDbyteStatement(yypvt[-0]); +} break; +case 81: +# line 334 "macross_6502.y" +{ + yyval = buildByteStatement(yypvt[-0]); +} break; +case 82: +# line 340 "macross_6502.y" +{ + yyval = buildBlockStatement(yypvt[-0]); +} break; +case 83: +# line 347 "macross_6502.y" +{ + yyval = buildStringStatement(yypvt[-0]); +} break; +case 84: +# line 354 "macross_6502.y" +{ + yyval = buildStructStatement(yypvt[-0], NULL); +} break; +case 85: +# line 358 "macross_6502.y" +{ + yyval = buildStructStatement(yypvt[-0], yypvt[-2]); +} break; +case 86: +# line 364 "macross_6502.y" +{ + yyval = lookupOrEnterSymbol(yypvt[-0], STRUCT_NAME_SYMBOL); +} break; +case 87: +# line 370 "macross_6502.y" +{ + yyval = yypvt[-1]; +} break; +case 88: +# line 377 "macross_6502.y" +{ + yyval = buildStatementList(yypvt[-0], NULL); +} break; +case 89: +# line 381 "macross_6502.y" +{ + yyval = buildStatementList(yypvt[-0], yypvt[-2]); +} break; +case 91: +# line 389 "macross_6502.y" +{ + yyval = addLabelToStatement(yypvt[-1], yypvt[-0]); +} break; +case 101: +# line 407 "macross_6502.y" +{ + yyval = buildNullStatement(); +} break; +case 102: +# line 414 "macross_6502.y" +{ + yyval = buildInstructionStatement(yypvt[-0], NULL); +} break; +case 103: +# line 418 "macross_6502.y" +{ + yyval = buildInstructionStatement(yypvt[-1], yypvt[-0]); +} break; +case 104: +# line 422 "macross_6502.y" +{ + yyval = buildMacroInstructionStatement(yypvt[-0], NULL); +} break; +case 105: +# line 426 "macross_6502.y" +{ + yyval = buildMacroInstructionStatement(yypvt[-1], yypvt[-0]); +} break; +case 106: +# line 432 "macross_6502.y" +{ + yyval = buildGroupStatement(yypvt[-0]); +} break; +case 107: +# line 438 "macross_6502.y" +{ + yyval = yypvt[-0]; +} break; +case 108: +# line 445 "macross_6502.y" +{ + yyval = buildDefineStatement(yypvt[-0], UNASSIGNED); +} break; +case 109: +# line 449 "macross_6502.y" +{ + checkDefineAssignmentOperator(yypvt[-2]); + yyval = buildDefineStatement(yypvt[-3], yypvt[-0]); +} break; +case 110: +# line 457 "macross_6502.y" +{ + yyval = buildMdefineStatement(yypvt[-0], UNASSIGNED); +} break; +case 111: +# line 461 "macross_6502.y" +{ + checkDefineAssignmentOperator(yypvt[-2]); + yyval = buildMdefineStatement(yypvt[-3], yypvt[-0]); +} break; +case 112: +# line 469 "macross_6502.y" +{ + yyval = buildMacroStatement(createMacro(yypvt[-3]), yypvt[-2], yypvt[-0]); + popMacroOrFunctionNestingDepth(); +} break; +case 113: +# line 474 "macross_6502.y" +{ + yyval = buildMacroStatement(createMacro(yypvt[-2]), NULL, yypvt[-0]); + popMacroOrFunctionNestingDepth(); +} break; +case 114: +# line 479 "macross_6502.y" +{ + yyval = buildMacroStatement(yypvt[-3], yypvt[-2], yypvt[-0]); + popMacroOrFunctionNestingDepth(); +} break; +case 115: +# line 484 "macross_6502.y" +{ + yyval = buildMacroStatement(yypvt[-2], NULL, yypvt[-0]); + popMacroOrFunctionNestingDepth(); +} break; +case 116: +# line 491 "macross_6502.y" +{ + pushMacroOrFunctionNestingDepth(); +} break; +case 118: +# line 499 "macross_6502.y" +{ + yyval = buildFunctionStatement(yypvt[-4], yypvt[-2], yypvt[-0]); + popMacroOrFunctionNestingDepth(); +} break; +case 119: +# line 507 "macross_6502.y" +{ + yyval = buildUndefineStatement(yypvt[-0]); +} break; +case 120: +# line 513 "macross_6502.y" +{ + yyval = buildIdentifierList(yypvt[-0], NULL, unknownSymbolTag); +} break; +case 121: +# line 517 "macross_6502.y" +{ + yyval = buildIdentifierList(yypvt[-0], yypvt[-3], unknownSymbolTag); +} break; +case 122: +# line 523 "macross_6502.y" +{ + yyval = NULL; +} break; +case 123: +# line 527 "macross_6502.y" +{ + yyval = yypvt[-1]; +} break; +case 124: +# line 533 "macross_6502.y" +{ + yyval = yypvt[-0]; +} break; +case 125: +# line 537 "macross_6502.y" +{ + yyval = buildArgumentList(yypvt[-0], yypvt[-3], TRUE); +} break; +case 126: +# line 541 "macross_6502.y" +{ + yyval = buildArgumentList(yypvt[-0], NULL, TRUE); +} break; +case 127: +# line 548 "macross_6502.y" +{ + yyval = buildArgumentList(yypvt[-0], NULL, FALSE); +} break; +case 128: +# line 552 "macross_6502.y" +{ + yyval = buildArgumentList(yypvt[-0], yypvt[-3], FALSE); +} break; +case 131: +# line 565 "macross_6502.y" +{ + yyval = yypvt[-0]; +} break; +case 132: +# line 572 "macross_6502.y" +{ + yyval = buildVariableStatement(yypvt[-0], UNASSIGNED, NULL); +} break; +case 133: +# line 576 "macross_6502.y" +{ + checkDefineAssignmentOperator(yypvt[-2]); + yyval = buildVariableStatement(yypvt[-3], yypvt[-0], NULL); +} break; +case 134: +# line 581 "macross_6502.y" +{ + yyval = buildVariableStatement(yypvt[-5], UNASSIGNED, yypvt[-2]); +} break; +case 135: +# line 585 "macross_6502.y" +{ + checkDefineAssignmentOperator(yypvt[-7]); + yyval = buildVariableStatement(yypvt[-8], yypvt[-0], yypvt[-5]); +} break; +case 136: +# line 590 "macross_6502.y" +{ + checkDefineAssignmentOperator(yypvt[-4]); + yyval = buildVariableStatement(yypvt[-5], yypvt[-0], -1); +} break; +case 137: +# line 598 "macross_6502.y" +{ + yyval = yypvt[-0]; +} break; +case 138: +# line 605 "macross_6502.y" +{ + yyval = buildMvariableStatement(yypvt[-0], UNASSIGNED, NULL); +} break; +case 139: +# line 609 "macross_6502.y" +{ + checkDefineAssignmentOperator(yypvt[-2]); + yyval = buildMvariableStatement(yypvt[-3], yypvt[-0], NULL); +} break; +case 140: +# line 614 "macross_6502.y" +{ + yyval = buildMvariableStatement(yypvt[-5], UNASSIGNED, yypvt[-2]); +} break; +case 141: +# line 618 "macross_6502.y" +{ + checkDefineAssignmentOperator(yypvt[-7]); + yyval = buildMvariableStatement(yypvt[-8], yypvt[-0], yypvt[-5]); +} break; +case 142: +# line 623 "macross_6502.y" +{ + checkDefineAssignmentOperator(yypvt[-4]); + yyval = buildMvariableStatement(yypvt[-5], yypvt[-0], -1); +} break; +case 143: +# line 631 "macross_6502.y" +{ + yyval = yypvt[-0]; +} break; +case 144: +# line 638 "macross_6502.y" +{ + yyval = buildMifStatement(yypvt[-0], NULL, NO_CONTINUATION); +} break; +case 145: +# line 642 "macross_6502.y" +{ + yyval = buildMifStatement(yypvt[-1], yypvt[-0], ELSE_CONTINUATION); +} break; +case 146: +# line 646 "macross_6502.y" +{ + yyval = buildMifStatement(yypvt[-1], yypvt[-0], ELSEIF_CONTINUATION); +} break; +case 147: +# line 652 "macross_6502.y" +{ + yyval = buildMifHead(yypvt[-2], yypvt[-0]); +} break; +case 148: +# line 658 "macross_6502.y" +{ + yyval = yypvt[-2]; +} break; +case 149: +# line 664 "macross_6502.y" +{ + yyval = yypvt[-0]; +} break; +case 150: +# line 670 "macross_6502.y" +{ + yyval = extractMifBody(yypvt[-0]); +} break; +case 151: +# line 674 "macross_6502.y" +{ + yyval = extractMifBody(buildMifStatement(yypvt[-0], NULL, NO_CONTINUATION)); +} break; +case 152: +# line 678 "macross_6502.y" +{ + yyval = extractMifBody(buildMifStatement(yypvt[-1], yypvt[-0], ELSE_CONTINUATION)); +} break; +case 153: +# line 682 "macross_6502.y" +{ + yyval = extractMifBody(buildMifStatement(yypvt[-1], yypvt[-0], ELSEIF_CONTINUATION)); +} break; +case 154: +# line 689 "macross_6502.y" +{ + yyval = buildMswitchStatement(yypvt[-2], yypvt[-0]); +} break; +case 155: +# line 695 "macross_6502.y" +{ + yyval = yypvt[-2]; +} break; +case 156: +# line 701 "macross_6502.y" +{ + yyval = yypvt[-2]; +} break; +case 157: +# line 706 "macross_6502.y" +{ + yyval = NULL; +} break; +case 158: +# line 712 "macross_6502.y" +{ + yyval = buildCaseList(yypvt[-0], NULL); +} break; +case 159: +# line 716 "macross_6502.y" +{ + yyval = buildCaseList(yypvt[-0], yypvt[-2]); +} break; +case 160: +# line 722 "macross_6502.y" +{ + yyval = buildCase(yypvt[-2], yypvt[-0]); +} break; +case 161: +# line 728 "macross_6502.y" +{ + yyval = yypvt[-2]; +} break; +case 162: +# line 732 "macross_6502.y" +{ + yyval = NULL; +} break; +case 163: +# line 739 "macross_6502.y" +{ + yyval = buildMwhileStatement(yypvt[-2], yypvt[-0]); +} break; +case 164: +# line 746 "macross_6502.y" +{ + yyval = buildMdoStatement(yypvt[-2], yypvt[-0]); +} break; +case 165: +# line 752 "macross_6502.y" +{ + yyval = buildMdoEnd(yypvt[-0], WHILE_END); +} break; +case 166: +# line 756 "macross_6502.y" +{ + yyval = buildMdoEnd(yypvt[-0], WHILE_END); +} break; +case 167: +# line 760 "macross_6502.y" +{ + yyval = buildMdoEnd(yypvt[-0], UNTIL_END); +} break; +case 168: +# line 764 "macross_6502.y" +{ + yyval = buildMdoEnd(yypvt[-0], UNTIL_END); +} break; +case 169: +# line 771 "macross_6502.y" +{ + yyval = buildFreturnStatement(NULL); +} break; +case 170: +# line 775 "macross_6502.y" +{ + yyval = buildFreturnStatement(yypvt[-0]); +} break; +case 172: +# line 785 "macross_6502.y" +{ + yyval = buildMforStatement(yypvt[-4], yypvt[-0]); +} break; +case 173: +# line 792 "macross_6502.y" +{ + yyval = buildForExpressions(yypvt[-6], yypvt[-3], yypvt[-0]); +} break; +case 174: +# line 799 "macross_6502.y" +{ + yyval = buildIncludeStatement(yypvt[-0]); +} break; +case 175: +# line 806 "macross_6502.y" +{ + yyval = buildExternStatement(yypvt[-0]); +} break; +case 176: +# line 812 "macross_6502.y" +{ + yyval = buildStartStatement(yypvt[-0]); +} break; +case 177: +# line 818 "macross_6502.y" +{ + yyval = buildAlignStatement(yypvt[-0]); +} break; +case 178: +# line 824 "macross_6502.y" +{ + yyval = buildOrgStatement(yypvt[-0]); +} break; +case 179: +# line 831 "macross_6502.y" +{ + yyval = buildTargetStatement(yypvt[-0]); +} break; +case 180: +# line 837 "macross_6502.y" +{ + yyval = buildRelStatement(); +} break; +case 181: +# line 844 "macross_6502.y" +{ + yyval = buildPerformStatement(yypvt[-0]); +} break; +case 184: +# line 855 "macross_6502.y" +{ + yyval = buildOperandList(yypvt[-0], NULL); +} break; +case 185: +# line 859 "macross_6502.y" +{ + yyval = buildOperandList(yypvt[-0], yypvt[-1]); +} break; +case 186: +# line 863 "macross_6502.y" +{ + yyval = buildOperandList(yypvt[-0], yypvt[-3]); +} break; +case 187: +# line 867 "macross_6502.y" +{ + yyval = buildOperandList(yypvt[-0], yypvt[-1]); +} break; +case 188: +# line 871 "macross_6502.y" +{ + yyval = buildOperandList(yypvt[-0], yypvt[-3]); +} break; +case 189: +# line 878 "macross_6502.y" +{ + yyval = buildOperandList(yypvt[-0], NULL); +} break; +case 190: +# line 882 "macross_6502.y" +{ + yyval = buildOperandList(yypvt[-0], yypvt[-3]); +} break; +case 191: +# line 886 "macross_6502.y" +{ + yyval = buildOperandList(yypvt[-0], yypvt[-1]); +} break; +case 192: +# line 890 "macross_6502.y" +{ + yyval = buildOperandList(yypvt[-0], yypvt[-3]); +} break; +case 193: +# line 896 "macross_6502.y" +{ + yyval = buildOperand(BLOCK_OPND, yypvt[-0]); +} break; +case 194: +# line 902 "macross_6502.y" +{ + yyval = yypvt[-1]; + statementListNestingDepth--; +} break; +case 195: +# line 909 "macross_6502.y" +{ + statementListNestingDepth++; +} break; +case 196: +# line 914 "macross_6502.y" +{ + yyval = buildSelectionList(yypvt[-0], NULL); +} break; +case 197: +# line 918 "macross_6502.y" +{ + yyval = buildSelectionList(yypvt[-0], yypvt[-3]); +} break; +case 198: +# line 924 "macross_6502.y" +{ + yyval = buildExpressionTerm(ARRAY_EXPR, yypvt[-5], yypvt[-2]); +} break; +case 199: +# line 928 "macross_6502.y" +{ + yyval = buildExpressionTerm(ARRAY_EXPR, yypvt[-5], yypvt[-2]); +} break; +case 200: +# line 934 "macross_6502.y" +{ + yyval = buildExpressionTerm(IDENTIFIER_EXPR, lookupOrEnterSymbol(yypvt[-0], + unknownSymbolTag)); +} break; +case 203: +# line 945 "macross_6502.y" +{ + yyval = yypvt[-0]; +} break; +case 204: +# line 949 "macross_6502.y" +{ + yyval = buildExpressionTerm(FUNCTION_CALL_EXPR, yypvt[-0]); +} break; +case 205: +# line 953 "macross_6502.y" +{ + yyval = buildExpressionTerm(NUMBER_EXPR, yypvt[-0]); +} break; +case 206: +# line 957 "macross_6502.y" +{ + yyval = buildExpressionTerm(CONDITION_CODE_EXPR, yypvt[-0]); +} break; +case 207: +# line 961 "macross_6502.y" +{ + yyval = buildExpressionTerm(HERE_EXPR); +} break; +case 208: +# line 965 "macross_6502.y" +{ + yyval = buildExpressionTerm(STRING_EXPR, yypvt[-0]); +} break; +case 209: +# line 969 "macross_6502.y" +{ + yyval = buildExpressionTerm(SUBEXPRESSION_EXPR, yypvt[-2]); +} break; +case 210: +# line 973 "macross_6502.y" +{ + yyval = buildExpressionTerm(UNOP_EXPR, UNARY_MINUS, yypvt[-0]); +} break; +case 211: +# line 977 "macross_6502.y" +{ + yyval = buildExpressionTerm(UNOP_EXPR, LOGICAL_NOT, yypvt[-0]); +} break; +case 212: +# line 981 "macross_6502.y" +{ + yyval = buildExpressionTerm(UNOP_EXPR, BITWISE_NOT, yypvt[-0]); +} break; +case 213: +# line 985 "macross_6502.y" +{ + yyval = buildExpressionTerm(UNOP_EXPR, LO_BYTE, yypvt[-0]); +} break; +case 214: +# line 989 "macross_6502.y" +{ + yyval = buildExpressionTerm(UNOP_EXPR, HI_BYTE, yypvt[-0]); +} break; +case 215: +# line 993 "macross_6502.y" +{ + yyval = buildExpressionTerm(BINOP_EXPR, MUL, yypvt[-3], yypvt[-0]); +} break; +case 216: +# line 997 "macross_6502.y" +{ + yyval = buildExpressionTerm(BINOP_EXPR, DIV, yypvt[-3], yypvt[-0]); +} break; +case 217: +# line 1001 "macross_6502.y" +{ + yyval = buildExpressionTerm(BINOP_EXPR, MOD, yypvt[-3], yypvt[-0]); +} break; +case 218: +# line 1005 "macross_6502.y" +{ + yyval = buildExpressionTerm(BINOP_EXPR, SUB, yypvt[-3], yypvt[-0]); +} break; +case 219: +# line 1009 "macross_6502.y" +{ + yyval = buildExpressionTerm(BINOP_EXPR, ADD, yypvt[-3], yypvt[-0]); +} break; +case 220: +# line 1013 "macross_6502.y" +{ + yyval = buildExpressionTerm(BINOP_EXPR, LEFT_SHIFT, yypvt[-3], yypvt[-0]); +} break; +case 221: +# line 1017 "macross_6502.y" +{ + yyval = buildExpressionTerm(BINOP_EXPR, RIGHT_SHIFT, yypvt[-3], yypvt[-0]); +} break; +case 222: +# line 1021 "macross_6502.y" +{ + yyval = buildExpressionTerm(BINOP_EXPR, LESS_THAN, yypvt[-3], yypvt[-0]); +} break; +case 223: +# line 1025 "macross_6502.y" +{ + yyval = buildExpressionTerm(BINOP_EXPR, GREATER_THAN, yypvt[-3], yypvt[-0]); +} break; +case 224: +# line 1029 "macross_6502.y" +{ + yyval = buildExpressionTerm(BINOP_EXPR, LESS_THAN_OR_EQUAL_TO, yypvt[-3], yypvt[-0]); +} break; +case 225: +# line 1033 "macross_6502.y" +{ + yyval = buildExpressionTerm(BINOP_EXPR, GREATER_THAN_OR_EQUAL_TO, yypvt[-3],yypvt[-0]); +} break; +case 226: +# line 1037 "macross_6502.y" +{ + yyval = buildExpressionTerm(BINOP_EXPR, EQUAL_TO, yypvt[-3], yypvt[-0]); +} break; +case 227: +# line 1041 "macross_6502.y" +{ + yyval = buildExpressionTerm(BINOP_EXPR, NOT_EQUAL_TO, yypvt[-3], yypvt[-0]); +} break; +case 228: +# line 1045 "macross_6502.y" +{ + yyval = buildExpressionTerm(BINOP_EXPR, BITWISE_AND, yypvt[-3], yypvt[-0]); +} break; +case 229: +# line 1049 "macross_6502.y" +{ + yyval = buildExpressionTerm(BINOP_EXPR, BITWISE_OR, yypvt[-3], yypvt[-0]); +} break; +case 230: +# line 1053 "macross_6502.y" +{ + yyval = buildExpressionTerm(BINOP_EXPR, BITWISE_XOR, yypvt[-3], yypvt[-0]); +} break; +case 231: +# line 1057 "macross_6502.y" +{ + yyval = buildExpressionTerm(BINOP_EXPR, LOGICAL_AND, yypvt[-3], yypvt[-0]); +} break; +case 232: +# line 1061 "macross_6502.y" +{ + yyval = buildExpressionTerm(BINOP_EXPR, LOGICAL_OR, yypvt[-3], yypvt[-0]); +} break; +case 233: +# line 1065 "macross_6502.y" +{ + yyval = buildExpressionTerm(BINOP_EXPR, LOGICAL_XOR, yypvt[-3], yypvt[-0]); +} break; +case 234: +# line 1069 "macross_6502.y" +{ + yyval = buildExpressionTerm(BINOP_EXPR, SELECT, yypvt[-3], + lookupOrEnterSymbol(yypvt[-0], STRUCT_FIELD_SYMBOL)); +} break; +case 235: +# line 1074 "macross_6502.y" +{ + yyval = buildExpressionTerm(ASSIGN_EXPR, yypvt[-2], yypvt[-3], yypvt[-0]); +} break; +case 236: +# line 1078 "macross_6502.y" +{ + yyval = buildExpressionTerm(POSTOP_EXPR, INCREMENT, yypvt[-1]); +} break; +case 237: +# line 1082 "macross_6502.y" +{ + yyval = buildExpressionTerm(POSTOP_EXPR, DECREMENT, yypvt[-1]); +} break; +case 238: +# line 1086 "macross_6502.y" +{ + yyval = buildExpressionTerm(PREOP_EXPR, INCREMENT, yypvt[-0]); +} break; +case 239: +# line 1090 "macross_6502.y" +{ + yyval = buildExpressionTerm(PREOP_EXPR, DECREMENT, yypvt[-0]); +} break; +case 240: +# line 1097 "macross_6502.y" +{ + yyval = buildFunctionCall(yypvt[-3], NULL); +} break; +case 241: +# line 1101 "macross_6502.y" +{ + yyval = buildFunctionCall(yypvt[-5], yypvt[-2]); +} break; +case 251: +# line 1127 "macross_6502.y" +{ + yyval = buildOperand(EXPRESSION_OPND, yypvt[-0]); +} break; +case 252: +# line 1133 "macross_6502.y" +{ + yyval = buildOperand(INDIRECT_OPND, yypvt[-0]); +} break; +case 253: +# line 1139 "macross_6502.y" +{ + yyval = buildOperand(IMMEDIATE_OPND, yypvt[-0]); +} break; +case 254: +# line 1146 "macross_6502.y" +{ + yyval = buildOperand(A_REGISTER_OPND, NULL); +} break; +case 255: +# line 1150 "macross_6502.y" +{ + yyval = buildOperand(X_REGISTER_OPND, NULL); +} break; +case 256: +# line 1154 "macross_6502.y" +{ + yyval = buildOperand(Y_REGISTER_OPND, NULL); +} break; +case 257: +# line 1161 "macross_6502.y" +{ + yyval = buildOperand(X_INDEXED_OPND, yypvt[-2]); +} break; +case 258: +# line 1165 "macross_6502.y" +{ + yyval = buildOperand(Y_INDEXED_OPND, yypvt[-2]); +} break; +case 259: +# line 1169 "macross_6502.y" +{ + yyval = buildOperand(X_SELECTED_OPND, yypvt[-0]); +} break; +case 260: +# line 1173 "macross_6502.y" +{ + yyval = buildOperand(Y_SELECTED_OPND, yypvt[-0]); +} break; +case 261: +# line 1177 "macross_6502.y" +{ + yyval = buildOperand(X_INDEXED_OPND, NULL); +} break; +case 262: +# line 1181 "macross_6502.y" +{ + yyval = buildOperand(Y_INDEXED_OPND, NULL); +} break; +case 263: +# line 1188 "macross_6502.y" +{ + yyval = buildOperand(PRE_INDEXED_X_OPND, yypvt[-2]); +} break; +case 264: +# line 1192 "macross_6502.y" +{ + yyval = buildOperand(PRE_SELECTED_X_OPND, yypvt[-0]); +} break; +case 265: +# line 1199 "macross_6502.y" +{ + yyval = buildOperand(POST_INDEXED_Y_OPND, yypvt[-2]); +} break; + } + goto yystack; /* stack new state and value */ + + } diff --git a/y.tab.h b/y.tab.h new file mode 100644 index 0000000..00a12d8 --- /dev/null +++ b/y.tab.h @@ -0,0 +1,80 @@ +# define A 257 +# define ALIGN 258 +# define ASSERT 259 +# define BLOCK 260 +# define BYTE 261 +# define CONSTRAIN 262 +# define DBYTE 263 +# define DEFINE 264 +# define DO 265 +# define ELSE 266 +# define ELSEIF 267 +# define ENDFILE 268 +# define EOL 269 +# define EXTERN 270 +# define FRETURN 271 +# define FUNCTION 272 +# define HERE 273 +# define IF 274 +# define INCLUDE 275 +# define LONG 276 +# define MACRO 277 +# define MCASE 278 +# define MDEFAULT 279 +# define MDEFINE 280 +# define MDO 281 +# define MELSE 282 +# define MELSEIF 283 +# define MFOR 284 +# define MIF 285 +# define MSWITCH 286 +# define MUNTIL 287 +# define MVARIABLE 288 +# define MWHILE 289 +# define ORG 290 +# define REL 291 +# define START 292 +# define STRING 293 +# define STRUCT 294 +# define TARGET 295 +# define UNDEFINE 296 +# define UNTIL 297 +# define VARIABLE 298 +# define WHILE 299 +# define WORD 300 +# define X 301 +# define Y 302 +# define ConditionCode 303 +# define Identifier 304 +# define MacroName 305 +# define Number 306 +# define Opcode 307 +# define TextString 308 +# define ASSIGN 309 +# define LOGICAL_OR 310 +# define LOGICAL_XOR 311 +# define LOGICAL_AND 312 +# define BITWISE_OR 313 +# define BITWISE_XOR 314 +# define BITWISE_AND 315 +# define EQUAL_TO 316 +# define NOT_EQUAL_TO 317 +# define LESS_THAN 318 +# define LESS_THAN_OR_EQUAL_TO 319 +# define GREATER_THAN 320 +# define GREATER_THAN_OR_EQUAL_TO 321 +# define LEFT_SHIFT 322 +# define RIGHT_SHIFT 323 +# define ADD 324 +# define SUB 325 +# define MUL 326 +# define DIV 327 +# define MOD 328 +# define UNARY_MINUS 329 +# define LOGICAL_NOT 330 +# define BITWISE_NOT 331 +# define HI_BYTE 332 +# define LO_BYTE 333 +# define SELECT 334 +# define INCREMENT 335 +# define DECREMENT 336 diff --git a/y.tab.o b/y.tab.o new file mode 100644 index 0000000000000000000000000000000000000000..c034aad3112d3c61d2e61574575d5e01d7270fbd GIT binary patch literal 71368 zcmeFae_+*B{Xc$QcVioDz<_}Rh7OoI^eVgC7~_Ys!3InRo7<47)Hb#|HW}O84;@K4 zlZuRrl9H5kDjFIU85tFCT}eray~(Js$d-~(p;Dqz68HOfp7T7f*Yn=pO?!Xepa0&w zZ1-`W=W(9rd7kH-=Q*$QI9ig0oA)r zjrH}akq$n8K3S!W!~3@J=~~B8U!N+#XG(i2Zot?3SpS6y%(Xn5zAZW3N$ySfH*wGA z^{Xf2YGa9W#Fws)TvDKQf8nxPhiv-d_yKjSqBn6LY`QO5P3e7PQ))`Dilw~Cy{d%X zrG1lnRU*j>@JsL0@p~jAoor7)n$9;9vi^)(bur#g#P+GL`1_K-vTz`IUtI5mZ(rG$ z{Ozmzl6O;C+f+(iuZkl*PtfN_gRAk`mVFt?_dx!QEBYK;#}`-iC&1Q`+wptvWqrV#~WYQ7Y9^^}^`_UN#YCrUoj$@VS3iVHdO`~Jk zue#oq1L}d91I~k&4JbuI;dEM-8Qtm>Tr`%+M! zl-@`0I1d~0iD&)KehTxU?JLrUvfoe}?M+sR$F4`8AsZjLBLuzLZ!ce;?n7PE&~HXi zIeX*MV`1An77ri~Y)ppkaq#VEk{^K#{VRdWAYb%8Trdjytl!Q1Goil`_YCxZ(X>?} z+E{sn~zK}z3Y(vpz>cKVDyv!32SjQUYuqWYy#-d*&0*Q2XpZz_F$44)tO z4>*?tKQXaZom!*v)KKG@ht5+)f$)<4^<1_Vr*fkz)lR*3z!9RL^ z=zOGap1Nef_v9tD)NaoZkH@cWE9zIT#SW03309BIPkwySSE~x}PWfix_v8rleT*x& zJ)a4^PH9gdCS8H|zg*l$eb;M~3h*CJk4eS2{@i8hKGI44IO0}5-m-LVRUb32uF*^lq=}^pgIHgvds8Zw5 zUgObT@JT_+Ul6;j-Dl=LeFW_`C9>V%?@`o8zjWDvW8><}m1=ZfvKspee2)Gw?y*=k zes}DEb8_y}FaBlq(=Q^fOzeGB_YvKeq<34oy5L2mZI2RL(C(utzC^RNcUOM`{Gi*5 z;@VfQNO#EQJrn!X8>wlQ9F)|-?>++7o7r1@UtB2|Hl=k`L z^eE}^75`IxFT!88K3;k8S6hALHxr}c7rL_Sbl9;dL}U5I8GWuj6o2|>43J;0Bre+G z+>24`6Muxjtf_LY8!!u@Il*JnBQUD(&h+_OXYWygD@Z!_t-Uqx#hJ^qItM{&J2e-zs` z4wKel)5v#G^4@II(Vx#mNndNy?>Id~y>I07Gee~7@lUaDi1M$or$K!vf@g3)m|LE~2&K>_l)W;qFqVJ5e_6(87jjuzL$>V>hm^I>`q<^sgM!YqA zxg-8+(udUh>U-q>?R(_^h0Pzuw!=2f^V5jutSq{pM(A}D^(Cthc!+*CV&8k{+GEn+ zm#&AH>y8g?Y(ocE!Blhyw|^xi^TVcQ1Ii!uG4_2BUz zEw+!i$>=d-iRN5+{VLk^I?F?OXNKV|Bi=atnl;e~9{+co6T0;LPvc(5=1KiB<_k`i z<&eLI;9MHPaeXHAxZ|Jd0zJ_<6RjSRFWJht{Al^&4QFtlj9yOcyUagj`hb_uD>wG< z%sFA(A7f^KV)fDZJ5E`d;M@8Cv`qv56!EuXU1ep0{~KE`A^WA34PDn*9{--rb}SE3 z*Z%iW*YEs?b+z;V`>pGPwqByH_gUF6b^RRMHE2yD^zi&|VljN+i{k4$SkDk^kl5R7 zy3p&+|3b#&KiZg%Z5*mTQS9OI@7nCHYoc(=BYfc2FABHV)+73wBK9hqF6yNBU(kod zHCAj6@w|8vJKN+NYVMD9$3MlzD0W?B%N@e53v9ZuYkY(a?)rZS9dTAi^z@kXCVi-N zWQ^Vu;&r6k9-cihZ;1R+Vo(f^|Dk*o^D^b9>#o86iTSnF9VP9ENgHY%8N=)UJ5Ewu zjW$mv_r~!2AFbcU>>sA=Zw{08#4u@(43oBVn6xiYS`;6Ac9=ZxvHp*7*Z=TOl^funj6S^wPW!;Jcao+N(_n7sP8|yy3{s-TQ?lYfW|0CTuM7m!8BYo5m>3aQ-^n}6v z!FQC~D{+Xtdj3b=82BoRpL_>7f9&UzrG_{|ONQa;^*{5j9)`C}*jF$NPtX6XZ_zM3J^wSWa2Vb!QSQQFczXP^zN?1e>GePJ z77W8n6y?qvhNrLpS>ODjdCotCzWiZ$uM1w@Fg!c{sb9?-|6IiifT;@S@CL&VJTKobn+!-(XIh(GzWKI*$ns^hD)+nK*R4 z5`CU<^!#tGo1(=w$Buu@g;Di?jBOYqE;}FQ^daK9)6MBIL)fR+|L`YbYkHLUmyiGan5JdKNRlqtIw)4YNWbbjZn9% z52@Q!kJ{+e`20?<+ONK=?)F`-+Elx`MRll7)up=Ct<3p_>QfJ?ht(tMZs&+|liIBw zS5K&~sy*s!>g(zoYOngHdeXU3eM{|A-&RjKA8=}&IwwmVa~@IOQ{Pty)PJd`)ibJJ z{XlI}ANET3InHtCC(h^9uc3LZQ|4T#ey(0rzfecjOX@f3x9Yh1oqAdQUJa-}s8`gh z>V*2EdQJUFom78Te^Gx`r_>9oRXwLZqI%UG>dtWO>hJ0;hfe97N1YSZIrT49uj(Dg z@u}C1C-owuEGC(oJVT<4r}{_0%s^FgP{X?AXQ);lfE2B+1jSHJdMrQT8RIBib5FH^mP!$TcIm+wn)KIGi)o8TLd zHXr4D%s0Y0?W}QLcfN~bN7>Ft)KxggSFfITeyajF_;Zyr-dOA;Iiu8%)KVv3J*w{2 z7H@Gn)fd$lVDTMlySDfq-<7^(-#F)U`tKK=-#f1RJ9UtHz<9R5A({Ftm&JMj9M zbIi&0C82Ec?^m1w_;;W42j>;%Rp*5BM<>zwz4IsMr1NLzFV4#JsPQ&UtmQ^Kl=JL#ml- zhBMOnyYrT_(dSd?zF2jUFVPq0i}xk?M*3pZg=(5gQ&ZIx-$d9q**8gDrBZzt;ON~X z-()q$H&u;R@xEy)&X=a{QyY{|Q6Rg?xlJkGbo|bwDCW!XU98_PaYiGGjCGRrQ9y|F zu`H#&zNr zh0bEc!Xm`CrHEO}of797=US)KS>dcST=Unda8_ZoZ9?8V)fV+h^$GPc_3`1xg}OnJ zhPf&a;}ur1o?9&9_ey%l3jJ1ii+*l$DxE4-jaaSJYW&`)@)hhiKh6^>*V#kZ(e=^N zHSll^N>l0s>VvA*`7fY4wN|H@Kh#tB$Js`}xyOFi@3J&4aJ~x8FP(4U?^Diqoc(xz zi9GE5POU-Tslj-<-;}25ZfVYsT)kw^pdaV3^8&Q|HzhbPddbc?gPoAtslKdh-^#Tg z-p2~|DA=RmV_kdr?~JZ}z4H&WIvwV;Kkuv6oYyQJ8u8l)ipqcYMCligP8R!p|G}ua*OumLZYx1R-jf1ofq;7Ge}dT1Z*g zLiIneP-l1l)Vs(6(^e!8w=kOjC{Kj{v>M~T;jFu92>rSzIND7n>OM~jUW?UrVr z_l&txv%!O6n@1UhhVp_6{oq`x@2PXCp>Ll{rB~=XF(VB6-}$Sa3q2nBig_UBu9&+} z7N<~2&JO!2{M}=nAMh*+=Y$?Vmx`6nF3guf!%>HvaiJ%nbsScEJM1g;`^bDleLj~O zbDR1vuRIUMJV1G1)uGTql7>1$w}e_l8;lgGEtu2CqSUFF!FS-3DSZ-Fsz8*J>gv5h zOF~P0PZ>K*DWRvi1eBwW#XO*nnHPBid2jLZ4u?XE4WIsEjgOMgKTmqkKMzS7ev|S0 zE`EO=x-?X%UIDttSYiL7Cz? zy0*6%ru?g(V=Zr=fBXEa=U)xY;MaAb>q5VCejEC7%&Rd^#k_!aKu>`M&jO)*XuUc% zj>>^W4fy>)s24AMBJEm=_D1=4F$}DFbBj~a@ogIW6VJ&&f z7aO{Y^1_SUYN4@&LL*W7D(HHNa;Zn?lQTZF5G%~F#J5_FtufQ7JhFgN)V=D9PJ(7U z?Zn}8oHNcD7xMu14D~sD{;acu{H~5sx%?MpnflSYLhI`M_u$GB{Y}4OAYX#3CZ+yu zQkkP`Xe`2-_R}b1Bh@u@x#~e#REIYtpY+?F>UkEqPT?x^*7N^X$IhQs$GjY<_bkjy ztDGdYit0cwlh62;K6!nf`Z8*Ezxor(Rajk*!1bPjU6wm`i8?J$9MgO|p#Y|^e9|Mr#U$|yZs~OIE`wLbI^HKO~UN+wDUvf2TlyGz~h~#)laduj8#5d%X}YK zph>v$j>FZ)*KrjT<7{(2gX^D9I3IWJQd4k^@KH6@>2>ZU{4qiTJi-ndEDh97Oe#K+OG7_&uyhi;my^>&U64p{VSfSA?fEAW`jaFl@LeIl~ z!j)LV%~gI}4P61Bj8o%L>xp>H!^(F7UJLQMYS1eMo;R;lH5qHCMQG&$w1{~Xs>Qe> zO2?|M7;8aV4bp2VUdyl!oQgG;eWhVFXkSy%s`R=R>$Xy?49)9ey-qAw*Wp!x^<<@* zfvd49eqDqIwpQW#?0R(xuGuoNi*gyR>@G(uUX9mk_f?HGCB1II3iBqc8P{MfMys(J zyz>9oUbU)LuRU+Xy48Ets|H;AHtN?p>_6C7lWJ1U=o7K}S`b51_YDVq!t@gADF*pi zMxXxwzG8Imi$U)r{iY8ZneCC(D;=;#qDRI9+ZW}a6#6xmh1+87r!=F1w8W!-(=Vka zu-w##>P-xKH~cu185e;)dyO4-?2zS@F9zBjcQnywW8KIw+evC)H2&z9%C_$c`C|1* zv@Gx4`iOK>>F@95gKm=}&Mn!~X)HINDFRq_0<|t?6#94QU!i}7aHb*jkI*}z zw?k(_Z-xFI`djF9=*`d@q1QvFLVpeYCG_Xe$4WGBtJ(3ya}oD9dO_s-(5Zm7yPE=GYzjO6alB;n0^uJ45$}?hAb>v?FwH=n!JhOw4XqI9EDZ;9326 z#w_$ztj6r;sPEXbgSCS=k0MUoggPaK{sqgAgkAt19eM#}{{$L;!msB-KgJ&E?Spbh zEeWizC_n6{zhJ1FLc6fvg1@03!0vwheh0r#;g|A%AMf7|J*hH7PlgWT?>F&#DD-{& z;)Ph3sVzBYKJ(v)kmn)v8&m#&hkoXaauWH|IbG_HLI*?7qCa`P=-0X*y@;Gz^Lzbe z>kg5(!99nTL22+JUf74A-z@CMWudfvp>NS%l`UVqQ@+va!&H`<6?%Z%>~QFL^rdT1 zv%{gEqKD2xj_1^e;rC~CyQA&3wu_ifv`%+sITwYVz~{YaIpa+#iC%{>#*X0qdH#%*JRw_Wu+jR?9R3SFX3m>*z60nV zS;+r;w3#gv@1~_mqGz00A+!l<{5*Qn3#b8RA?URH!y4f)82?4y!~2uw1#~X-4S4M9 zp|3fUoC`41;bn3{$4}^&YK`~9TJC9uhp8NDA8jw`p#Ee^qq3t`E$Y^{TiYrWrW{k3f5K@a1|%aV6&BEWPT; z!Mr;M>y5e4PV-Fo>)V(co7By&v{Yd6s6O@E^;6ulIH8DfJz-ANN3hfcr0RW1s#X>a6-F?nb<;%Ra9{h|=fv zd~Ql0jdXuy_@5D2Iln%L66E?gm=7mlbwax0_1_Y#j%Y1JE1@b#u15{u@6UI^e+GAQ zM(7M9u)c*}Cl>c4T5wmX6?Zx|V;{rp;?RAiZImuv?p-1+y9RfP6p*>o^Go$B?8_Ze zZ@R|N`jK+mAA_o~E(+?^7p=X_YKhiI3U`l=dH0J#=e<|N{UXwL4zpIA`Zo~QMVBOP z9f3O%pARda@|mB%;w^~#5X3)?-?y}Q0TAxn;cqe4smAhESU(0a3w#fEy$;~+*9a#8 zDGGOTWX*JTom1g{+a}yEx&!xZyqYU@4?aDjcIjNkN<7@|e)>5pD8R1hVqn~%)IX)X z5B4MdX#?)-eN5;1l>V!5kIz`qiFc(osxRO!&b=lp|MhHmPW@Q@4Qucstma4PRrmy{o)3HdVLeJWnJ7hN|BCqB-F1@Z@V?v z(b&>rnb{dPlIHk~gNex3zZ?pA~htYI!HLj*6rP38wHyQanq&p~^#-KP;; zcV{m!*WKCY`GoElS)br;r_qBvxYud)5I!d4$Auie)8!K9v?uq)8u?WN*at~4a*Z>X z5Bq(Y%qN_0eEaW1zy*R+Bsf(8k* z&zw5}Z0+0(Z0#hR#d!(ma$dpQ^xhMy~O0Bd4~GK^qZYW3m%` zYU`MOBiDF9@K1RB*jOVcow3MAdNj6m+yuF;BVlX*kASWHg!9dqdiN0U8l!VD@yULw z3*mN_qn%^BSWdWy<-Ne*X+B~6(l~vW@D{<@Dmc4^oc%z3I~MJs+X(q$4=|tbVf-fG zcL2Xf@C(~Crq5XWQQOACKN_P>u_py4AAv*li-p}jxeI-6UT!4miokHBL5l z`4{qyNH?6h<-i$+qj8atFBkG!Z>)`I@W$E*@*&Eavk-d7hp3CjTa7%o3G!`5uJJJ= zr+zZxxRGlNn@A7!lM!4O!g25g$tiDKDt@6~<4hx`ym5Xb*BJKOI2pIxvoo$r$g71M zWlY)#5_Cc%M!Y)p{p>7E#&cwr4dfdT}@hDHr zp(B1T%L&7WGpH`5zz2lRexdUy#t?D*;2am60l_(=)JKVv1kO2+15;ev5>gE3AE$6R zmL@pqf|HBm7SQvL!{96woC3kAV$L3L)(B3m;4}z%laRM7l}GyFvxKcmT~4?Qc)Q^5 z5PbMbbIQR%AG1DBI3PGjnd1lNxZn&3&KWE@sH`M#&Uu`X%Hxbo7V;D!M}PAp?>o>v z5@lE$MrH{P`3LPxKO>8Tyh_N$I2{R}+(0@}*OBdl({|FGbnV161nrN4US z1t(W<@&%_mIMj>l2EaB)POHQ?+K zoV|i`5KpucXCXL;1?Pz1z*m|BUyV8?IHx^MVl0;8&~xUTQi(|(Cox%YGL$MN&T(-3 zf|DgUMa($>PO0FO3r?+4$)pGEpNPI>+aj?=a5mw13UM}rgI|{ezghnz?oethaiAj+ zx?IjK!P$pP1LDAzMA+nV`UU4G=4axdPKl_S%NY=yGt5Z>=bXpEN7tUD6cbzCI;B)n zn&6}h4*3dopr52%AzyCd_FMZQCtq1kmEfSBGyAI00Z(65rV3C?!G z>BD6$acaTYEjW7wr(da05T^i~LxOWya0Zx@4$euzLH%tTjaEucCOvo`o#1gsCkYPn z6X)*(;A9GpUvL&GHHJ6`!6_1)<$_Z!&KPFx9GnBfXILE=s=e#I?%yQ1VAGloPtrB^wIqz<8sLrGZJ{Yq}@OuS+ zGxL!?rjPlxz{qd?GiHzA?`1y9AJebYCrN(+Fl>F2Fl--lLgYOu@}kbVUhu(KrPMcx zkN2?&9)E0-#~+)n)W^1ffS<9@`!Qbcjm<>AMBdZKAkPwcb4A|eB5$e43%hk*)MG4s zW$QS0jmX<1V_<_dJo7=%b z-8CQY$y)?}tI)ZNIna>|KiGODqYT%ce%4t4&Qa$3fvN7$OFzj2f`6L%$(Z+I4gU@J zV_cHQABQxne_Xnd3qOooh;KnfUEVl|yhVbuT;zoxsJ?IP2B(GjsQb7s!S50LZOmy0 zXNTbI6dd?L>#PE&pZNvAhXnty;KL7^58KC`W_~j8S;0sBZGFcJKa2;@m1kl*7X+zec-@8>;Li9g452NZQ%3>&L+V@+EgkF-0?dENBChp{NU=}EAql8 zt{iRS+J6)W5J{&WI^h$SGaxu;*|r3Q8w$+F`viQp{0ZbAjv*7^Q}W3v=$in&r2iDk znUE{^`GQ~0eAqjon)$ndYX!eS@O!XTPCB=M(p2VYgDdQP zmEcqhPCKrDh_elx9>LipI9qY2fH+;?Y!{pzf`filKpg0vxL0scwp%ZZyF}tF1n02e z91$G&Y7}wO!8s{7rvwLnt0zvZQj_p&`^=;Sk25J%sYT%Y89F9Gm&?fzoGhi*5(ni^ z$`>5iXKkJYA9fH2^_Wy8IH;$~X~8$@5(mDS)Fn7Qg0q!5NS_3rYtIhB*~6SFaP|q# ze!)4+oLq2@3eGXXImMh5aLx$MS≀lHr_0`UT)wdoD;796xi8f|Dya`GQl*oPFR_ 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