--- /dev/null
+/******************************************************************************/
+/* */
+/* Program: PAL (BART version) */
+/* File: pal.c */
+/* Author: Gary A. Messenbrink <gary@netcom.com> */
+/* */
+/* Purpose: A 2 pass PDP-8 pal-like assembler. */
+/* */
+/* PAL(1) */
+/* */
+/* NAME */
+/* pal - a PDP/8 pal-like assembler. */
+/* */
+/* SYNOPSIS: */
+/* pal [ -d -l -p -r -x ] inputfile */
+/* */
+/* DESCRIPTION */
+/* This is a cross-assembler to for PDP/8 assembly language programs. */
+/* It will produce an output file in bin format, rim format, and using the */
+/* appropriate pseudo-ops, a combination of rim and bin formats. */
+/* A listing file is always produced and with an optional symbol table */
+/* and/or a symbol cross-reference (concordance). The permanent symbol */
+/* table can be output in a form that may be read back in so a customized */
+/* permanent symbol table can be produced. Any detected errors are output */
+/* to a separate file giving the filename in which they were detected */
+/* along with the line number, column number and error message as well as */
+/* marking the error in the listing file. */
+/* The following file name extensions are used: */
+/* .pal source code (input) */
+/* .lst assembly listing (output) */
+/* .bin assembly output in DEC's bin format (output) */
+/* .rim assembly output in DEC's rim format (output) */
+/* .err assembly errors detected (if any) (output) */
+/* .prm permanent symbol table in form suitable for reading after */
+/* the EXPUNGE pseudo-op. */
+/* */
+/* OPTIONS */
+/* -d Dump the symbol table at end of assembly */
+/* -l Allow generation of literals (default is no literal generation) */
+/* -p Generate a file with the permanent symbols in it. */
+/* (To get the current symbol table, assemble a file than has only */
+/* a $ in it.) */
+/* -r Produce output in rim format (default is bin format) */
+/* -x Generate a cross-reference (concordance) of user symbols. */
+/* */
+/* DIAGNOSTICS */
+/* Assembler error diagnostics are output to an error file and inserted */
+/* in the listing file. Each line in the error file has the form */
+/* */
+/* <filename>(<line>:<col>) : error: <message> at Loc = <loc> */
+/* */
+/* An example error message is: */
+/* */
+/* bintst.pal(17:9) : error: undefined symbol "UNDEF" at Loc = 07616 */
+/* */
+/* The error diagnostics put in the listing start with a two character */
+/* error code (if appropriate) and a short message. A carat '^' is */
+/* placed under the item in error if appropriate. */
+/* An example error message is: */
+/* */
+/* 17 07616 3000 DCA UNDEF */
+/* UD undefined ^ */
+/* 18 07617 1777 TAD I DUMMY */
+/* */
+/* When an indirect is generated, an at character '@' is placed after the */
+/* the instruction value in the listing as an indicator as follows: */
+/* */
+/* 14 03716 1777@ TAD OFFPAG */
+/* */
+/* Undefined symbols are marked in the symbol table listing by prepending */
+/* a '?' to the symbol. Redefined symbols are marked in the symbol table */
+/* listing by prepending a '#' to the symbol. Examples are: */
+/* */
+/* #REDEF 04567 */
+/* SWITCH 07612 */
+/* ?UNDEF 00000 */
+/* */
+/* Refer to the code for the diagnostic messages generated. */
+/* */
+/* BUGS */
+/* Only a minimal effort has been made to keep the listing format */
+/* anything like the PAL-8 listing format. */
+/* The operation of the conditional assembly pseudo-ops may not function */
+/* exactly as the DEC versions. I did not have any examples of these so */
+/* the implementation is my interpretation of how they should work. */
+/* */
+/* The RIMPUNch and BINPUNch pseudo-ops do not change the binary output */
+/* file type that was specified on startup. This was intentional and */
+/* and allows rim formatted data to be output prior to the actual binary */
+/* formatted data. On UN*X style systems, the same effect can be achieved */
+/* by using the "cat" command, but on DOS/Windows systems, doing this was */
+/* a major chore. */
+/* */
+/* The floating point input does not generate values exactly as the DEC */
+/* compiler does. I worked out several examples by hand and believe that */
+/* this implementation is slightly more accurate. If I am mistaken, */
+/* let me know and, if possible, a better method of generating the values. */
+/* */
+/* BUILD and INSTALLATION */
+/* This program has been built and successfully executed on: */
+/* a. Linux (80486 CPU)using gcc */
+/* b. RS/6000 (AIX 3.2.5) */
+/* c. Borland C++ version 3.1 (large memory model) */
+/* d. Borland C++ version 4.52 (large memory model) */
+/* with no modifications to the source code. */
+/* */
+/* On UNIX type systems, store the the program as the pal command */
+/* and on PC type systems, store it as pal.exe */
+/* */
+/* HISTORICAL NOTE: */
+/* This assembler was written to support the fleet of PDP-8 systems */
+/* used by the Bay Area Rapid Transit System. As of early 1997, */
+/* this includes about 40 PDP-8/E systems driving the train destination */
+/* signs in passenger stations. */
+/* */
+/* REFERENCES: */
+/* This assembler is based on the pal assember by: */
+/* Douglas Jones <jones@cs.uiowa.edu> and */
+/* Rich Coon <coon@convexw.convex.com> */
+/* */
+/* DISCLAIMER: */
+/* See the symbol table for the set of pseudo-ops supported. */
+/* See the code for pseudo-ops that are not standard for PDP/8 assembly. */
+/* Refer to DEC's "Programming Languages (for the PDP/8)" for complete */
+/* documentation of pseudo-ops. */
+/* Refer to DEC's "Introduction to Programming (for the PDP/8)" or a */
+/* lower level introduction to the assembly language. */
+/* */
+/* WARRANTY: */
+/* If you don't like it the way it works or if it doesn't work, that's */
+/* tough. You're welcome to fix it yourself. That's what you get for */
+/* using free software. */
+/* */
+/* COPYRIGHT NOTICE: */
+/* This is free software. There is no fee for using it. You may make */
+/* any changes that you wish and also give it away. If you can make */
+/* a commercial product out of it, fine, but do not put any limits on */
+/* the purchaser's right to do the same. If you improve it or fix any */
+/* bugs, it would be nice if you told me and offered me a copy of the */
+/* new version. */
+/* */
+/* */
+/* Amendments Record: */
+/* Version Date by Comments */
+/* ------- ------- --- --------------------------------------------------- */
+/* v1.0 12Apr96 GAM Original */
+/* v1.1 18Nov96 GAM Permanent symbol table initialization error. */
+/* v1.2 20Nov96 GAM Added BINPUNch and RIMPUNch pseudo-operators. */
+/* v1.3 24Nov96 GAM Added DUBL pseudo-op (24 bit integer constants). */
+/* v1.4 29Nov96 GAM Fixed bug in checksum generation. */
+/* v2.1 08Dec96 GAM Added concordance processing (cross reference). */
+/* v2.2 10Dec96 GAM Added FLTG psuedo-op (floating point constants). */
+/* v2.3 2Feb97 GAM Fixed paging problem in cross reference output. */
+/* */
+/******************************************************************************/
+
+#include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define LINELEN 96
+#define LIST_LINES_PER_PAGE 55 /* Includes 5 line page header. */
+#define NAMELEN 128
+#define SYMBOL_COLUMNS 5
+#define SYMLEN 7
+#define SYMBOL_TABLE_SIZE 1024
+#define TITLELEN 63
+#define XREF_COLUMNS 8
+
+#define ADDRESS_FIELD 00177
+#define FIELD_FIELD 070000
+#define INDIRECT_BIT 00400
+#define LAST_PAGE_LOC 00177
+#define OP_CODE 07000
+#define PAGE_BIT 00200
+
+#ifdef PAGE_SIZE
+#undef PAGE_SIZE
+#endif
+#define PAGE_SIZE 00200
+
+#define PAGE_FIELD 07600
+#define PAGE_ZERO_END 00200
+
+/* Macro to get the number of elements in an array. */
+#define DIM(a) (sizeof(a)/sizeof(a[0]))
+
+/* Macro to get the address plus one of the end of an array. */
+#define BEYOND(a) ((a) + DIM(A))
+
+#define is_blank(c) ((c==' ') || (c=='\t') || (c=='\f') || (c=='>'))
+#define isend(c) ((c=='\0')|| (c=='\n'))
+#define isdone(c) ((c=='/') || (isend(c)) || (c==';'))
+
+/* Macros for testing symbol attributes. Each macro evaluates to non-zero */
+/* (true) if the stated condtion is met. */
+/* Use these to test attributes. The proper bits are extracted and then */
+/* tested. */
+#define M_CONDITIONAL(s) ((s & CONDITION) == CONDITION)
+#define M_DEFINED(s) ((s & DEFINED) == DEFINED)
+#define M_DUPLICATE(s) ((s & DUPLICATE) == DUPLICATE)
+#define M_FIXED(s) ((s & FIXED) == FIXED)
+#define M_LABEL(s) ((s & LABEL) == LABEL)
+#define M_MRI(s) ((s & MRI) == MRI)
+#define M_MRIFIX(s) ((s & MRIFIX) == MRIFIX)
+#define M_PSEUDO(s) ((s & PSEUDO) == PSEUDO)
+#define M_REDEFINED(s) ((s & REDEFINED) == REDEFINED)
+#define M_UNDEFINED(s) (!M_DEFINED(s))
+
+/* This macro is used to test symbols by the conditional assembly pseudo-ops. */
+#define M_DEF(s) (M_DEFINED(s))
+#define M_COND(s) (M_DEFINED(s))
+#define M_DEFINED_CONDITIONALLY(t) ((M_DEF(t)&&pass==1)||(!M_COND(t)&&pass==2))
+
+typedef unsigned char BOOL;
+typedef unsigned char BYTE;
+typedef short int WORD16;
+typedef long int WORD32;
+
+#ifndef FALSE
+ #define FALSE 0
+ #define TRUE (!FALSE)
+#endif
+
+/* Line listing styles. Used to control listing of lines. */
+enum linestyle_t
+{
+ LINE, LINE_VAL, LINE_LOC_VAL, LOC_VAL
+};
+typedef enum linestyle_t LINESTYLE_T;
+
+/* Symbol Types. */
+/* Note that the names that have FIX as the suffix contain the FIXED bit */
+/* included in the value. */
+/* */
+/* The CONDITION bit is used when processing the conditional assembly PSEUDO- */
+/* OPs (e.g., IFDEF). During pass 1 of the assembly, the symbol is either */
+/* defined or undefined. The condition bit is set when the symbol is defined */
+/* during pass 1 and reset on pass 2 at the location the symbol was defined */
+/* during pass 1. When processing conditionals during pass 2, if the symbol */
+/* is defined and the condition bit is set, the symbol is treated as if it */
+/* were undefined. This gives consistent behavior of the conditional */
+/* pseudo-ops during both pass 1 and pass 2. */
+enum symtyp
+{
+ UNDEFINED = 0000,
+ DEFINED = 0001,
+ FIXED = 0002,
+ MRI = 0004 | DEFINED,
+ LABEL = 0010 | DEFINED,
+ REDEFINED = 0020 | DEFINED,
+ DUPLICATE = 0040 | DEFINED,
+ PSEUDO = 0100 | FIXED | DEFINED,
+ CONDITION = 0200 | DEFINED,
+ MRIFIX = MRI | FIXED | DEFINED,
+ DEFFIX = DEFINED | FIXED
+};
+typedef enum symtyp SYMTYP;
+
+enum pseudo_t
+{
+ BANK, BINPUNCH, DECIMAL, DUBL, EJECT, ENPUNCH, EXPUNGE, FIELD,
+ FIXMRI, FIXTAB, FLTG, IFDEF, IFNDEF, IFNZERO, IFZERO, NOPUNCH,
+ OCTAL, PAGE, PAUSE, RELOC, RIMPUNCH, SEGMNT, TEXT, TITLE,
+ XLIST, ZBLOCK
+};
+typedef enum pseudo_t PSEUDO_T;
+
+struct sym_t
+{
+ SYMTYP type;
+ char name[SYMLEN];
+ WORD16 val;
+ WORD16 xref_index;
+ WORD16 xref_count;
+};
+typedef struct sym_t SYM_T;
+
+struct lpool_t
+{
+ WORD16 error; /* True if error message has been printed. */
+ WORD16 loc;
+ WORD16 pool[PAGE_SIZE];
+};
+typedef struct lpool_t LPOOL_T;
+
+struct emsg_t
+{
+ char *list;
+ char *file;
+};
+typedef struct emsg_t EMSG_T;
+
+struct errsave_t
+{
+ char *mesg;
+ WORD16 col;
+};
+typedef struct errsave_t ERRSAVE_T;
+
+struct fltg_
+{
+ WORD16 exponent;
+ WORD32 mantissa;
+};
+typedef struct fltg_ FLTG_T;
+
+/*----------------------------------------------------------------------------*/
+
+/* Function Prototypes */
+
+int binarySearch( char *name, int start, int symbol_count );
+int compareSymbols( const void *a, const void *b );
+void conditionFalse( void );
+void conditionTrue( void );
+SYM_T *defineLexeme( WORD16 start, WORD16 term, WORD16 val, SYMTYP type );
+SYM_T *defineSymbol( char *name, WORD16 val, SYMTYP type, WORD16 start);
+void endOfBinary( void );
+void errorLexeme( EMSG_T *mesg, WORD16 col );
+void errorMessage( EMSG_T *mesg, WORD16 col );
+void errorSymbol( EMSG_T *mesg, char *name, WORD16 col );
+SYM_T *eval( void );
+WORD32 evalDubl( WORD32 initial_value );
+FLTG_T *evalFltg( void );
+SYM_T *evalSymbol( void );
+void getArgs( int argc, char *argv[] );
+WORD32 getDublExpr( void );
+WORD32 getDublExprs( void );
+FLTG_T *getFltgExpr( void );
+FLTG_T *getFltgExprs( void );
+SYM_T *getExpr( void );
+WORD16 getExprs( void );
+WORD16 incrementClc( void );
+void inputDubl( void );
+void inputFltg( void );
+WORD16 insertLiteral( LPOOL_T *pool, WORD16 value );
+char *lexemeToName( char *name, WORD16 from, WORD16 term );
+void listLine( void );
+SYM_T *lookup( char *name );
+void moveToEndOfLine( void );
+void nextLexBlank( void );
+void nextLexeme( void );
+void normalizeFltg( FLTG_T *fltg );
+void onePass( void );
+void printCrossReference( void );
+void printErrorMessages( void );
+void printLine(char *line, WORD16 loc, WORD16 val, LINESTYLE_T linestyle);
+void printPageBreak( void );
+void printPermanentSymbolTable( void );
+void printSymbolTable( void );
+BOOL pseudoOperators( PSEUDO_T val );
+void punchChecksum( void );
+void punchLocObject( WORD16 loc, WORD16 val );
+void punchLiteralPool( LPOOL_T *p, WORD16 lpool_page );
+void punchOutObject( WORD16 loc, WORD16 val );
+void punchLeader( WORD16 count );
+void punchObject( WORD16 val );
+void punchOrigin( WORD16 loc );
+void readLine( void );
+void saveError( char *mesg, WORD16 cc );
+BOOL testForLiteralCollision( WORD16 loc );
+void topOfForm( char *title, char *sub_title );
+
+/*----------------------------------------------------------------------------*/
+
+/* Table of pseudo-ops (directives) which are used to setup the symbol */
+/* table on startup and when the EXPUNGE pseudo-op is executed. */
+SYM_T pseudo[] =
+{
+ { PSEUDO, "BANK", BANK }, /* Like field, select some 32K out of 128K*/
+ { PSEUDO, "BINPUN", BINPUNCH }, /* Output in Binary Loader format. */
+ { PSEUDO, "DECIMA", DECIMAL }, /* Read literal constants in base 10. */
+ { PSEUDO, "DUBL", DUBL }, /* Ignored (unsupported). */
+ { PSEUDO, "EJECT", EJECT }, /* Eject a page in the listing. */
+ { PSEUDO, "ENPUNC", ENPUNCH }, /* Turn on object code generation. */
+ { PSEUDO, "EXPUNG", EXPUNGE }, /* Remove all symbols from symbol table. */
+ { PSEUDO, "FIELD", FIELD }, /* Set origin to memory field. */
+ { PSEUDO, "FIXMRI", FIXMRI }, /* Like =, but creates mem ref instruction*/
+ { PSEUDO, "FIXTAB", FIXTAB }, /* Mark current symbols as permanent. */
+ { PSEUDO, "FLTG", FLTG }, /* Ignored (unsupported). */
+ { PSEUDO, "IFDEF", IFDEF }, /* Assemble if symbol is defined. */
+ { PSEUDO, "IFNDEF", IFNDEF }, /* Assemble if symbol is not defined. */
+ { PSEUDO, "IFNZER", IFNZERO }, /* Assemble if symbol value is not 0. */
+ { PSEUDO, "IFZERO", IFZERO }, /* Assemble if symbol value is 0. */
+ { PSEUDO, "NOPUNC", NOPUNCH }, /* Turn off object code generation. */
+ { PSEUDO, "OCTAL", OCTAL }, /* Read literal constants in base 8. */
+ { PSEUDO, "PAGE", PAGE }, /* Set orign to page +1 or page n (0..37).*/
+ { PSEUDO, "PAUSE", PAUSE }, /* Ignored */
+ { PSEUDO, "RELOC", RELOC }, /* Assemble to run at a different address.*/
+ { PSEUDO, "RIMPUN", RIMPUNCH }, /* Output in Read In Mode format. */
+ { PSEUDO, "SEGMNT", SEGMNT }, /* Like page, but with page size=1K words.*/
+ { PSEUDO, "TEXT", TEXT }, /* Pack 6 bit trimmed ASCII into memory. */
+ { PSEUDO, "TITLE", TITLE }, /* Use the text string as a listing title.*/
+ { PSEUDO, "XLIST", XLIST }, /* Toggle listing generation. */
+ { PSEUDO, "ZBLOCK", ZBLOCK } /* Zero a block of memory. */
+};
+
+/* Symbol Table */
+/* The table is put in lexical order on startup, so symbols can be */
+/* inserted as desired into the initial table. */
+SYM_T permanent_symbols[] =
+{
+ /* Memory Reference Instructions */
+ { MRIFIX, "AND", 00000 }, /* LOGICAL AND */
+ { MRIFIX, "TAD", 01000 }, /* TWO'S COMPLEMENT ADD */
+ { MRIFIX, "ISZ", 02000 }, /* INCREMENT AND SKIP IF ZERO */
+ { MRIFIX, "DCA", 03000 }, /* DEPOSIT AND CLEAR ACC */
+ { MRIFIX, "I", 00400 }, /* INDIRECT ADDRESSING */
+ { MRIFIX, "JMP", 05000 }, /* JUMP */
+ { MRIFIX, "JMS", 04000 }, /* JUMP TO SUBROUTINE */
+ { MRIFIX, "Z", 00000 }, /* PAGE ZERO ADDRESS */
+ /* Floating Point Interpreter Instructions */
+ { MRIFIX, "FEXT", 00000 }, /* FLOATING EXIT */
+ { MRIFIX, "FADD", 01000 }, /* FLOATING ADD */
+ { MRIFIX, "FSUB", 02000 }, /* FLOATING SUBTRACT */
+ { MRIFIX, "FMPY", 03000 }, /* FLOATING MULTIPLY */
+ { MRIFIX, "FDIV", 04000 }, /* FLOATING DIVIDE */
+ { MRIFIX, "FGET", 05000 }, /* FLOATING GET */
+ { MRIFIX, "FPUT", 06000 }, /* FLOATING PUT */
+ { FIXED, "FNOR", 07000 }, /* FLOATING NORMALIZE */
+ { FIXED, "FEXT", 00000 }, /* EXIT FROM FLOATING POINT INTERPRETER */
+ { FIXED, "SQUARE", 00001 }, /* SQUARE C(FAC) */
+ { FIXED, "SQROOT", 00002 }, /* TAKE SQUARE ROOT OF C(FAC) */
+ /* Group 1 Operate Microinstrcutions */
+ { FIXED, "NOP", 07000 }, /* NO OPERATION */
+ { FIXED, "IAC", 07001 }, /* INCREMENT AC */
+ { FIXED, "RAL", 07004 }, /* ROTATE AC AND LINK LEFT ONE */
+ { FIXED, "RTL", 07006 }, /* ROTATE AC AND LINK LEFT TWO */
+ { FIXED, "RAR", 07010 }, /* ROTATE AC AND LINK RIGHT ONE */
+ { FIXED, "RTR", 07012 }, /* ROTATE AC AND LINK RIGHT TWO */
+ { FIXED, "CML", 07020 }, /* COMPLEMENT LINK */
+ { FIXED, "CMA", 07040 }, /* COMPLEMEMNT AC */
+ { FIXED, "CLL", 07100 }, /* CLEAR LINK */
+ { FIXED, "CLA", 07200 }, /* CLEAR AC */
+ /* Group 2 Operate Microinstructions */
+ { FIXED, "BSW", 07002 }, /* Swap bytes in AC (PDP/8e) */
+ { FIXED, "HLT", 07402 }, /* HALT THE COMPUTER */
+ { FIXED, "OSR", 07404 }, /* INCLUSIVE OR SR WITH AC */
+ { FIXED, "SKP", 07410 }, /* SKIP UNCONDITIONALLY */
+ { FIXED, "SNL", 07420 }, /* SKIP ON NON-ZERO LINK */
+ { FIXED, "SZL", 07430 }, /* SKIP ON ZERO LINK */
+ { FIXED, "SZA", 07440 }, /* SKIP ON ZERO AC */
+ { FIXED, "SNA", 07450 }, /* SKIP ON NON=ZERO AC */
+ { FIXED, "SMA", 07500 }, /* SKIP MINUS AC */
+ { FIXED, "SPA", 07510 }, /* SKIP ON POSITIVE AC (ZERO IS POSITIVE) */
+ /* Combined Operate Microinstructions */
+ { FIXED, "CIA", 07041 }, /* COMPLEMENT AND INCREMENT AC */
+ { FIXED, "STL", 07120 }, /* SET LINK TO 1 */
+ { FIXED, "GLK", 07204 }, /* GET LINK (PUT LINK IN AC BIT 11) */
+ { FIXED, "STA", 07240 }, /* SET AC TO -1 */
+ { FIXED, "LAS", 07604 }, /* LOAD ACC WITH SR */
+ /* MQ Instructions (PDP/8e) */
+ { FIXED, "MQL", 07421 }, /* Load MQ from AC, then clear AC. */
+ { FIXED, "MQA", 07501 }, /* Inclusive OR MQ with AC */
+ { FIXED, "SWP", 07521 }, /* Swap AC and MQ */
+ { FIXED, "ACL", 07701 }, /* Load MQ into AC */
+ /* Program Interrupt */
+ { FIXED, "IOT", 06000 },
+ { FIXED, "ION", 06001 }, /* TURN INTERRUPT PROCESSOR ON */
+ { FIXED, "IOF", 06002 }, /* TURN INTERRUPT PROCESSOR OFF */
+ /* Program Interrupt, PDP-8/e */
+ { FIXED, "SKON", 06000 }, /* Skip if interrupt on and turn int off. */
+ { FIXED, "SRQ", 06003 }, /* Skip on interrupt request. */
+ { FIXED, "GTF", 06004 }, /* Get interrupt flags. */
+ { FIXED, "RTF", 06005 }, /* Restore interrupt flags. */
+ { FIXED, "SGT", 06006 }, /* Skip on greater than flag. */
+ { FIXED, "CAF", 06007 }, /* Clear all flags. */
+ /* Keyboard/Reader */
+ { FIXED, "KSF", 06031 }, /* SKIP ON KEYBOARD FLAG */
+ { FIXED, "KCC", 06032 }, /* CLEAR KEYBOARD FLAG */
+ { FIXED, "KRS", 06034 }, /* READ KEYBOARD BUFFER (STATIC) */
+ { FIXED, "KRB", 06036 }, /* READ KEYBOARD BUFFER & CLEAR FLAG */
+ /* Teleprinter/Punch */
+ { FIXED, "TSF", 06041 }, /* SKIP ON TELEPRINTER FLAG */
+ { FIXED, "TCF", 06042 }, /* CLEAR TELEPRINTER FLAG */
+ { FIXED, "TPC", 06044 }, /* LOAD TELEPRINTER & PRINT */
+ { FIXED, "TLS", 06046 }, /* LOAD TELPRINTER & CLEAR FLAG */
+ /* High Speed Paper Tape Reader */
+ { FIXED, "RSF", 06011 }, /* SKIP ON READER FLAG */
+ { FIXED, "RRB", 06012 }, /* READ READER BUFFER AND CLEAR FLAG */
+ { FIXED, "RFC", 06014 }, /* READER FETCH CHARACTER */
+ /* PC8-E High Speed Paper Tape Reader & Punch */
+ { FIXED, "RPE", 06010 }, /* Set interrupt enable for reader/punch */
+ { FIXED, "PCE", 06020 }, /* Clear interrupt enable for rdr/punch */
+ { FIXED, "RCC", 06016 }, /* Read reader buffer, clear flags & buf, */
+ /* and fetch character. */
+ /* High Speed Paper Tape Punch */
+ { FIXED, "PSF", 06021 }, /* SKIP ON PUNCH FLAG */
+ { FIXED, "PCF", 06022 }, /* CLEAR ON PUNCH FLAG */
+ { FIXED, "PPC", 06024 }, /* LOAD PUNCH BUFFER AND PUNCH CHARACTER* */
+ { FIXED, "PLS", 06026 }, /* LOAD PUNCH BUFFER AND CLEAR FLAG */
+ /* DECtape Transport Type TU55 and DECtape Control Type TC01 */
+ { FIXED, "DTRA", 06761 }, /* Contents of status register is ORed */
+ /* into AC bits 0-9 */
+ { FIXED, "DTCA", 06762 }, /* Clear status register A, all flags */
+ /* undisturbed */
+ { FIXED, "DTXA", 06764 }, /* Status register A loaded by exclusive */
+ /* OR from AC. If AC bit 10=0, clear */
+ /* error flags; if AC bit 11=0, DECtape */
+ /* control flag is cleared. */
+ { FIXED, "DTLA", 06766 }, /* Combination of DTCA and DTXA */
+ { FIXED, "DTSF", 06771 }, /* Skip if error flag is 1 or if DECtape */
+ /* control flag is 1 */
+ { FIXED, "DTRB", 06772 }, /* Contents of status register B is */
+ /* ORed into AC */
+ { FIXED, "DTLB", 06774 }, /* Memory field portion of status */
+ /* register B loaded from AC bits 6-8 */
+ /* Disk File and Control, Type DF32 */
+ { FIXED, "DCMA", 06601 }, /* CLEAR DISK MEMORY REQUEST AND */
+ /* INTERRUPT FLAGS */
+ { FIXED, "DMAR", 06603 }, /* LOAD DISK FROM AC, CLEAR AC READ */
+ /* INTO CORE, CLEAR INTERRUPT FLAG */
+ { FIXED, "DMAW", 06605 }, /* LOAD DISK FROM AC, WRITE ONTO DISK */
+ /* FROM CORE, CLEAR INTERRUPT FLAG */
+ { FIXED, "DCEA", 06611 }, /* CLEAR DISK EXTENDED ADDRESS AND */
+ { FIXED, "DSAC", 06612 }, /* SKIP IF ADDRESS CONFIRMED FLAG = 1 */
+ /* MEMORY ADDRESS EXTENSION REGISTER */
+ { FIXED, "DEAL", 06615 }, /* CLEAR DISK EXTENDED ADDRESS AND */
+ /* MEMORY ADDRESS EXTENSION REGISTER */
+ /* AND LOAD SAME FROM AC */
+ { FIXED, "DEAC", 06616 }, /* CLEAR AC, LOAD AC FROM DISK EXTENDED */
+ /* ADDRESS REGISTER, SKIP IF ADDRESS */
+ /* CONFIRMED FLAG = 1 */
+ { FIXED, "DFSE", 06621 }, /* SKIP IF PARITY ERROR, DATA REQUEST */
+ /* LATE, OR WRITE LOCK SWITCH FLAG = 0 */
+ /* (NO ERROR) */
+ { FIXED, "DFSC", 06622 }, /* SKIP IF COMPLETION FLAG = 1 (DATA */
+ /* TRANSFER COMPLETE) */
+ { FIXED, "DMAC", 06626 }, /* CLEAR AC, LOAD AC FROM DISK MEMORY */
+ /* ADDRESS REGISTER */
+ /* Disk File and Control, Type RF08 */
+ { FIXED, "DCIM", 06611 },
+ { FIXED, "DIML", 06615 },
+ { FIXED, "DIMA", 06616 },
+ { FIXED, "DISK", 06623 },
+ { FIXED, "DCXA", 06641 },
+ { FIXED, "DXAL", 06643 },
+ { FIXED, "DXAC", 06645 },
+ { FIXED, "DMMT", 06646 },
+ /* Memory Extension Control, Type 183 */
+ { FIXED, "CDF", 06201 }, /* CHANGE DATA FIELD */
+ { FIXED, "CIF", 06202 }, /* CHANGE INSTRUCTION FIELD */
+ { FIXED, "CDI", 06203 }, /* Change data & instrution field. */
+ { FIXED, "RDF", 06214 }, /* READ DATA FIELD */
+ { FIXED, "RIF", 06224 }, /* READ INSTRUCTION FIELD */
+ { FIXED, "RIB", 06234 }, /* READ INTERRUPT BUFFER */
+ { FIXED, "RMF", 06224 }, /* RESTORE MEMORY FIELD */
+ /* Memory Parity, Type MP8/I (MP8/L) */
+ { FIXED, "SMP", 06101 }, /* SKIP IF MEMORY PARITY FLAG = 0 */
+ { FIXED, "CMP", 06104 }, /* CLEAR MEMORY PAIRTY FLAG */
+ /* Memory Parity, Type MP8-E (PDP8/e) */
+ { FIXED, "DPI", 06100 }, /* Disable parity interrupt. */
+ { FIXED, "SNP", 06101 }, /* Skip if no parity error. */
+ { FIXED, "EPI", 06103 }, /* Enable parity interrupt. */
+ { FIXED, "CNP", 06104 }, /* Clear parity error flag. */
+ { FIXED, "CEP", 06106 }, /* Check for even parity. */
+ { FIXED, "SPO", 06107 }, /* Skip on parity option. */
+ /* Data Communications Systems, Type 680I */
+ { FIXED, "TTINCR", 06401 }, /* The content of the line select */
+ /* register is incremented by one. */
+ { FIXED, "TTI", 06402 }, /* The line status word is read and */
+ /* sampled. If the line is active for */
+ /* the fourth time, the line bit is */
+ /* shifted into the character assembly */
+ /* word. If the line bit is active for */
+ /* a number of times less than four, */
+ /* the count is incremented. If the */
+ /* line is not active, the active/inac- */
+ /* tive status of the line is recorded */
+ { FIXED, "TTO", 06404 }, /* The character in the AC is shifted */
+ /* right one position, zeros are shifted */
+ /* into vacated positions, and the orig- */
+ /* inal content of AC11 is transferred */
+ /* out of the computer on the TTY line. */
+ { FIXED, "TTCL", 06411 }, /* The line select register is cleared. */
+ { FIXED, "TTSL", 06412 }, /* The line select register is loaded by */
+ /* an OR transfer from the content of */
+ /* of AC5-11, the the AC is cleared. */
+ { FIXED, "TTRL", 06414 }, /* The content of the line select regis- */
+ /* ter is read into AC5-11 by an OR */
+ /* transfer. */
+ { FIXED, "TTSKP", 06421 }, /* Skip if clock flag is a 1. */
+ { FIXED, "TTXON", 06424 }, /* Clock 1 is enabled to request a prog- */
+ /* ram interrupt and clock 1 flag is */
+ /* cleared. */
+ { FIXED, "TTXOF", 06422 }, /* Clock 1 is disabled from causing a */
+ /* program interrupt and clock 1 flag */
+ /* is cleared. */
+}; /* End-of-Symbols for Permanent Symbol Table */
+
+/* Global variables */
+SYM_T *symtab; /* Symbol Table */
+int symbol_top; /* Number of entries in symbol table. */
+
+SYM_T *fixed_symbols; /* Start of the fixed symbol table entries. */
+int number_of_fixed_symbols;
+
+/*----------------------------------------------------------------------------*/
+
+WORD16 *xreftab; /* Start of the concordance table. */
+
+ERRSAVE_T error_list[20];
+int save_error_count;
+
+LPOOL_T pz; /* Storage for page zero constants. */
+LPOOL_T cp; /* Storage for current page constants. */
+
+char s_detected[] = "detected";
+char s_error[] = "error";
+char s_errors[] = "errors";
+char s_no[] = "No";
+char s_page[] = "Page";
+char s_symtable[] = "Symbol Table";
+char s_xref[] = "Cross Reference";
+
+/* Assembler diagnostic messages. */
+/* Some attempt has been made to keep continuity with the PAL-III and */
+/* MACRO-8 diagnostic messages. If a diagnostic indicator, (e.g., IC) */
+/* exists, then the indicator is put in the listing as the first two */
+/* characters of the diagnostic message. The PAL-III indicators where used */
+/* when there was a choice between using MACRO-8 and PAL-III indicators. */
+/* The character pairs and their meanings are: */
+/* DT Duplicate Tag (symbol) */
+/* IC Illegal Character */
+/* ID Illegal Redefinition of a symbol. An attempt was made to give */
+/* a symbol a new value not via =. */
+/* IE Illegal Equals An equal sign was used in the wrong context, */
+/* (e.g., A+B=C, or TAD A+=B) */
+/* II Illegal Indirect An off page reference was made, but a literal */
+/* could not be generated because the indirect bit was already set. */
+/* IR Illegal Reference (address is not on current page or page zero) */
+/* ND No $ (the program terminator) at end of file. */
+/* PE Current, Non-Zero Page Exceeded (literal table flowed into code) */
+/* RD ReDefintion of a symbol */
+/* ST Symbol Table full */
+/* UA Undefined Address (undefined symbol) */
+/* ZE Zero Page Exceeded (see above, or out of space) */
+EMSG_T duplicate_label = { "DT duplicate", "duplicate label" };
+EMSG_T illegal_blank = { "IC illegal blank", "illegal blank" };
+EMSG_T illegal_character = { "IC illegal char", "illegal character" };
+EMSG_T illegal_expression = { "IC in expression", "illegal expression" };
+EMSG_T label_syntax = { "IC label syntax", "label syntax" };
+EMSG_T not_a_number = { "IC numeric syntax", "numeric syntax of" };
+EMSG_T number_not_radix = { "IC radix", "number not in current radix"};
+EMSG_T symbol_syntax = { "IC symbol syntax", "symbol syntax" };
+EMSG_T illegal_equals = { "IE illegal =", "illegal equals" };
+EMSG_T illegal_indirect = { "II off page", "illegal indirect" };
+EMSG_T illegal_reference = { "IR off page", "illegal reference" };
+EMSG_T undefined_symbol = { "UD undefined", "undefined symbol" };
+EMSG_T redefined_symbol = { "RD redefined", "redefined symbol" };
+EMSG_T literal_overflow = { "PE page exceeded",
+ "current page literal capacity exceeded" };
+EMSG_T pz_literal_overflow = { "ZE page exceeded",
+ "page zero capacity exceeded" };
+EMSG_T dubl_overflow = { "dubl overflow", "DUBL value overflow" };
+EMSG_T fltg_overflow = { "fltg overflow", "FLTG value overflow" };
+EMSG_T zblock_too_small = { "expr too small", "ZBLOCK value too small" };
+EMSG_T zblock_too_large = { "expr too large", "ZBLOCK value too large" };
+EMSG_T end_of_file = { "ND no $ at EOF", "No $ at End-of-File" };
+EMSG_T no_pseudo_op = { "not implemented",
+ "not implemented pseudo-op" };
+EMSG_T illegal_field_value = { "expr out of range",
+ "field value not in range of 0 through 7" };
+EMSG_T literal_gen_off = { "literals off",
+ "literal generation is off" };
+EMSG_T no_literal_value = { "no value", "no literal value" };
+EMSG_T text_string = { "no delimiter",
+ "text string delimiters not matched" };
+EMSG_T in_rim_mode = { "not OK in rim mode"
+ "FIELD pseudo-op not valid in RIM mode" };
+EMSG_T lt_expected = { "'<' expected", "'<' expected" };
+EMSG_T symbol_table_full = { "ST Symbol Tbl Full",
+ "Symbol Table Full" };
+
+/*----------------------------------------------------------------------------*/
+
+FILE *errorfile;
+FILE *infile;
+FILE *listfile;
+FILE *listsave;
+FILE *objectfile;
+FILE *objectsave;
+
+char errorpathname[NAMELEN];
+char filename[NAMELEN];
+char listpathname[NAMELEN];
+char objectpathname[NAMELEN];
+char *pathname;
+char permpathname[NAMELEN];
+
+int list_lineno;
+int list_pageno;
+char list_title[LINELEN];
+BOOL list_title_set; /* Set if TITLE pseudo-op used. */
+char line[LINELEN]; /* Input line. */
+int lineno; /* Current line number. */
+int page_lineno; /* print line number on current page. */
+WORD16 listed; /* Listed flag. */
+WORD16 listedsave;
+
+WORD16 cc; /* Column Counter (char position in line). */
+WORD16 checksum; /* Generated checksum */
+BOOL binary_data_output; /* Set true when data has been output. */
+WORD16 clc; /* Location counter */
+WORD16 cplc; /* Current page literal counter. */
+char delimiter; /* Character immediately after eval'd term. */
+int errors; /* Number of errors found so far. */
+BOOL error_in_line; /* TRUE if error on current line. */
+int errors_pass_1; /* Number of errors on pass 1. */
+WORD16 field; /* Current field */
+WORD16 fieldlc; /* location counter without field portion. */
+BOOL fltg_input; /* TRUE when doing floating point input. */
+BOOL indirect_generated; /* TRUE if an off page address generated. */
+WORD16 lexstartprev; /* Where previous lexeme started. */
+WORD16 lextermprev; /* Where previous lexeme ended. */
+WORD16 lexstart; /* Index of current lexeme on line. */
+WORD16 lexterm; /* Index of character after current lexeme. */
+BOOL literals_on; /* Generate literals, defaults to none */
+WORD16 maxcc; /* Current line length. */
+BOOL overflow; /* Overflow flag for math routines. */
+WORD16 pass; /* Number of current pass. */
+BOOL print_permanent_symbols;
+WORD16 pzlc; /* Page Zero literal counter. */
+WORD16 radix; /* Default number radix. */
+WORD16 reloc; /* The relocation distance. */
+BOOL rim_mode; /* Generate rim format, defaults to bin */
+BOOL symtab_print; /* Print symbol table flag */
+BOOL xref;
+
+FLTG_T fltg_ac; /* Value holder for evalFltg() */
+SYM_T sym_eval = { DEFINED, "", 0 }; /* Value holder for eval() */
+SYM_T sym_getexpr = { DEFINED, "", 0 }; /* Value holder for getexpr() */
+SYM_T sym_undefined = { UNDEFINED, "", 0 };/* Symbol Table Terminator */
+
+
+/******************************************************************************/
+/* */
+/* Function: main */
+/* */
+/* Synopsis: Starting point. Controls order of assembly. */
+/* */
+/******************************************************************************/
+int main( int argc, char *argv[] )
+{
+ int ix;
+ int space;
+
+ /* Set the default values for global symbols. */
+ binary_data_output = FALSE;
+ fltg_input = FALSE;
+ literals_on = FALSE;
+ print_permanent_symbols = FALSE;
+ rim_mode = FALSE;
+ symtab_print = FALSE;
+ xref = FALSE;
+ pathname = NULL;
+
+ /* Get the options and pathnames */
+ getArgs( argc, argv );
+
+ /* Setup the error file in case symbol table overflows while installing the */
+ /* permanent symbols. */
+ errorfile = fopen( errorpathname, "w" );
+ errors = 0;
+ save_error_count = 0;
+ pass = 0; /* This is required for symbol table initialization. */
+ symtab = (SYM_T *) malloc( sizeof( SYM_T ) * SYMBOL_TABLE_SIZE );
+
+ if( symtab == NULL )
+ {
+ fprintf( stderr, "Could not allocate memory for symbol table.\n");
+ exit( -1 );
+ }
+
+ /* Place end marker in symbol table. */
+ symtab[0] = sym_undefined;
+ symbol_top = 0;
+ number_of_fixed_symbols = symbol_top;
+ fixed_symbols = &symtab[symbol_top - 1];
+
+ /* Enter the pseudo-ops into the symbol table */
+ for( ix = 0; ix < DIM( pseudo ); ix++ )
+ {
+ defineSymbol( pseudo[ix].name, pseudo[ix].val, pseudo[ix].type, 0 );
+ }
+
+ /* Enter the predefined symbols into the table. */
+ /* Also make them part of the permanent symbol table. */
+ for( ix = 0; ix < DIM( permanent_symbols ); ix++ )
+ {
+ defineSymbol( permanent_symbols[ix].name,
+ permanent_symbols[ix].val,
+ permanent_symbols[ix].type | DEFFIX , 0 );
+ }
+
+ number_of_fixed_symbols = symbol_top;
+ fixed_symbols = &symtab[symbol_top - 1];
+
+ /* Do pass one of the assembly */
+ checksum = 0;
+ pass = 1;
+ onePass();
+ errors_pass_1 = errors;
+
+ /* Set up for pass two */
+ rewind( infile );
+ errorfile = fopen( errorpathname, "w" );
+ objectfile = fopen( objectpathname, "wb" );
+ objectsave = objectfile;
+
+ listfile = fopen( listpathname, "w" );
+ listsave = NULL;
+
+ punchLeader( 0 );
+ checksum = 0;
+
+ /* Do pass two of the assembly */
+ errors = 0;
+ save_error_count = 0;
+
+ if( xref )
+ {
+ /* Get the amount of space that will be required for the concordance. */
+ for( space = 0, ix = 0; ix < symbol_top; ix++ )
+ {
+ symtab[ix].xref_index = space; /* Index into concordance table. */
+ space += symtab[ix].xref_count + 1;
+ symtab[ix].xref_count = 0; /* Clear the count for pass 2. */
+
+ }
+ /* Allocate the necessary space. */
+ xreftab = (WORD16 *) malloc( sizeof( WORD16 ) * space );
+
+ /* Clear the cross reference space. */
+ for( ix = 0; ix < space; ix++ )
+ {
+ xreftab[ix] = 0;
+ }
+ }
+ pass = 2;
+ onePass();
+
+ /* Undo effects of NOPUNCH for any following checksum */
+ objectfile = objectsave;
+ punchChecksum();
+
+ /* Works great for trailer. */
+ punchLeader( 1 );
+
+ /* undo effects of XLIST for any following output to listing file. */
+ if( listfile == NULL )
+ {
+ listfile = listsave;
+ }
+
+ /* Display value of error counter. */
+ if( errors == 0 )
+ {
+ fprintf( listfile, "\n %s %s %s\n", s_no, s_detected, s_errors );
+ }
+ else
+ {
+ fprintf( errorfile, "\n %d %s %s\n", errors, s_detected,
+ ( errors == 1 ? s_error : s_errors ));
+ fprintf( listfile, "\n %d %s %s\n", errors, s_detected,
+ ( errors == 1 ? s_error : s_errors ));
+ fprintf( stderr, " %d %s %s\n", errors, s_detected,
+ ( errors == 1 ? s_error : s_errors ));
+ }
+
+ if( symtab_print )
+ {
+ printSymbolTable();
+ }
+
+ if( print_permanent_symbols )
+ {
+ printPermanentSymbolTable();
+ }
+
+ if( xref )
+ {
+ printCrossReference();
+ }
+
+ fclose( objectfile );
+ fclose( listfile );
+ fclose( errorfile );
+ if( errors == 0 && errors_pass_1 == 0 )
+ {
+ remove( errorpathname );
+ }
+
+ return( errors != 0 );
+} /* main() */
+
+/******************************************************************************/
+/* */
+/* Function: getArgs */
+/* */
+/* Synopsis: Parse command line, set flags accordingly and setup input and */
+/* output files. */
+/* */
+/******************************************************************************/
+void getArgs( int argc, char *argv[] )
+{
+ WORD16 len;
+ WORD16 ix, jx;
+
+ /* Set the defaults */
+ errorfile = NULL;
+ infile = NULL;
+ listfile = NULL;
+ listsave = NULL;
+ objectfile = NULL;
+ objectsave = NULL;
+
+ for( ix = 1; ix < argc; ix++ )
+ {
+ if( argv[ix][0] == '-' )
+ {
+ for( jx = 1; argv[ix][jx] != 0; jx++ )
+ {
+ switch( argv[ix][jx] )
+ {
+ case 'd':
+ symtab_print = TRUE;
+ break;
+
+ case 'r':
+ rim_mode = TRUE;
+ break;
+
+ case 'l':
+ literals_on = TRUE;
+ break;
+
+ case 'p':
+ print_permanent_symbols = TRUE;
+ break;
+
+ case 'x':
+ xref = TRUE;
+ break;
+
+ default:
+ fprintf( stderr, "%s: unknown flag: %s\n", argv[0], argv[ix] );
+ fprintf( stderr, " -d -- dump symbol table\n" );
+ fprintf( stderr, " -l -- generate literals\n" );
+ fprintf( stderr, " -r -- output rim format file\n" );
+ fprintf( stderr, " -p -- output permanent symbols to file\n" );
+ fprintf( stderr, " -x -- output cross reference to file\n" );
+ fflush( stderr );
+ exit( -1 );
+ } /* end switch */
+ } /* end for */
+ }
+ else
+ {
+ if( pathname != NULL )
+ {
+ fprintf( stderr, "%s: too many input files\n", argv[0] );
+ exit( -1 );
+ }
+ pathname = &argv[ix][0];
+ }
+ } /* end for */
+
+ if( pathname == NULL )
+ {
+ fprintf( stderr, "%s: no input file specified\n", argv[0] );
+ exit( -1 );
+ }
+
+ len = strlen( pathname );
+ if( len > NAMELEN - 5 )
+ {
+ fprintf( stderr, "%s: pathname \"%s\" too long\n", argv[0], pathname );
+ exit( -1 );
+ }
+
+ /* Now open the input file. */
+ if(( infile = fopen( pathname, "r" )) == NULL )
+ {
+ fprintf( stderr, "%s: cannot open \"%s\"\n", argv[0], pathname );
+ exit( -1 );
+ }
+
+ /* Now make the pathnames */
+ /* Find last '.', if it exists. */
+ jx = len - 1;
+ while( pathname[jx] != '.' && pathname[jx] != '/'
+ && pathname[jx] != '\\' && jx >= 0 )
+ {
+ jx--;
+ }
+
+ switch( pathname[jx] )
+ {
+ case '.':
+ break;
+
+ case '/':
+ case '\\':
+ jx = len;
+ break;
+
+ default:
+ break;
+ }
+
+ /* Add the pathname extensions. */
+ strncpy( objectpathname, pathname, jx );
+ objectpathname[jx] = '\0';
+ strcat( objectpathname, rim_mode ? ".rim" : ".bin" );
+
+ strncpy( listpathname, pathname, jx );
+ listpathname[jx] = '\0';
+ strcat( listpathname, ".lst" );
+
+ strncpy( errorpathname, pathname, jx );
+ errorpathname[jx] = '\0';
+ strcat( errorpathname, ".err" );
+
+ strncpy( permpathname, pathname, jx );
+ permpathname[jx] = '\0';
+ strcat( permpathname, ".prm" );
+
+ /* Extract the filename from the path. */
+ if( isalpha( pathname[0] ) && pathname[1] == ':' && pathname[2] != '\\' )
+ {
+ pathname[1] = '\\'; /* MS-DOS style pathname */
+ }
+
+ jx = len - 1;
+ while( pathname[jx] != '/' && pathname[jx] != '\\' && jx >= 0 )
+ {
+ jx--;
+ }
+ strcpy( filename, &pathname[jx + 1] );
+
+} /* getArgs() */
+
+
+/******************************************************************************/
+/* */
+/* Function: onePass */
+/* */
+/* Synopsis: Do one assembly pass. */
+/* */
+/******************************************************************************/
+void onePass()
+{
+ char name[SYMLEN];
+ WORD16 newclc;
+ BOOL scanning_line;
+ WORD16 start;
+ SYM_T *sym;
+ WORD16 term;
+ WORD16 val;
+
+ clc = 0200; /* Default starting address is 200 octal. */
+ field = 0;
+ fieldlc = 0;
+ reloc = 0;
+ cp.loc = 00200; /* Points to end of page for [] operands. */
+ pz.loc = 00200; /* Points to end of page for () operands. */
+ cp.error = FALSE;
+ pz.error = FALSE;
+ listed = TRUE;
+ lineno = 0;
+ list_pageno = 0;
+ list_lineno = 0;
+ list_title_set = FALSE;
+ radix = 8; /* Initial radix is octal (base 8). */
+
+ while( TRUE )
+ {
+ readLine();
+ nextLexeme();
+
+ scanning_line = TRUE;
+ while( scanning_line )
+ {
+ if( isend( line[lexstart] ))
+ {
+ scanning_line = FALSE;
+ }
+ else
+ {
+ switch( line[lexstart] )
+ {
+ case '/':
+ scanning_line = FALSE;
+ break;
+
+ case ';':
+ nextLexeme();
+ break;
+
+ case '$':
+ endOfBinary();
+ return;
+
+ case '*':
+ nextLexeme(); /* Skip '*', (set origin symbol) */
+ newclc = ((getExpr())->val & 07777 ) | field;
+ /* Do not change Current Location Counter if an error occurred. */
+ if( !error_in_line )
+ {
+ if(( newclc & 07600 ) != ( clc & 07600 ))
+ {
+ /* Current page has changed. */
+ punchLiteralPool( &cp, clc - 1 );
+ }
+ clc = newclc - reloc;
+ fieldlc = clc & 07777;
+
+ if( !rim_mode )
+ {
+ /* Not rim mode, put out origin. */
+ punchOrigin( clc );
+ }
+ printLine( line, 0, fieldlc, LINE_VAL );
+ }
+ break;
+
+ default:
+ switch( line[lexterm] )
+ {
+ case ',':
+ if( isalpha( line[lexstart] ))
+ {
+ /* Use lookup so symbol will not be counted as reference. */
+ sym = lookup( lexemeToName( name, lexstart, lexterm ));
+ if( M_DEFINED( sym->type ))
+ {
+ if( sym->val != clc && pass == 2 )
+ {
+ errorSymbol( &duplicate_label, sym->name, lexstart );
+ }
+ sym->type = sym->type | DUPLICATE;
+ }
+ /* Must call define on pass 2 to generate concordance. */
+ defineLexeme( lexstart, lexterm, ( clc+reloc ), LABEL );
+ }
+ else
+ {
+ errorLexeme( &label_syntax, lexstart );
+ }
+ nextLexeme(); /* skip label */
+ nextLexeme(); /* skip comma */
+ break;
+
+ case '=':
+ if( isalpha( line[lexstart] ))
+ {
+ start = lexstart;
+ term = lexterm;
+ delimiter = line[lexterm];
+ nextLexBlank(); /* skip symbol */
+ nextLexBlank(); /* skip trailing = */
+ val = getExprs();
+ defineLexeme( start, term, val, DEFINED );
+ printLine( line, 0, val, LINE_VAL );
+ }
+ else
+ {
+ errorLexeme( &symbol_syntax, lexstartprev );
+ nextLexeme(); /* skip symbol */
+ nextLexeme(); /* skip trailing = */
+ getExprs(); /* skip expression */
+ }
+ break;
+
+ default:
+ if( isalpha( line[lexstart] ))
+ {
+ sym = evalSymbol();
+ val = sym->val;
+ if( M_PSEUDO( sym->type ))
+ {
+ nextLexeme(); /* Skip symbol */
+ scanning_line = pseudoOperators( (PSEUDO_T)val & 07777 );
+ }
+ else
+ {
+ /* Identifier is not a pseudo-op, interpret as load value */
+ punchOutObject( clc, getExprs() & 07777 );
+ incrementClc();
+ }
+ }
+ else
+ {
+ /* Identifier is a value, interpret as load value */
+ punchOutObject( clc, getExprs() & 07777 );
+ incrementClc();
+ }
+ break;
+ } /* end switch */
+ break;
+ } /* end switch */
+ } /* end if */
+ } /* end while( scanning_line ) */
+ } /* end while( TRUE ) */
+} /* onePass() */
+
+
+/******************************************************************************/
+/* */
+/* Function: getExprs */
+/* */
+/* Synopsis: Or together a list of blank separated expressions, from the */
+/* current lexeme onward. Leave the current lexeme as */
+/* the last one in the list. */
+/* */
+/******************************************************************************/
+WORD16 getExprs()
+{
+ SYM_T *symv;
+ SYM_T *symt;
+ WORD16 temp;
+ SYMTYP temp_type;
+ WORD16 value;
+ SYMTYP value_type;
+
+ symv = getExpr();
+ value = symv->val;
+ value_type = symv->type;
+
+ while( TRUE )
+ {
+ if( isdone( line[lexstart] ))
+ {
+ return( value );
+ }
+ switch( line[lexstart] )
+ {
+ case ')':
+ case ']':
+ return( value );
+
+ default:
+ break;
+ }
+
+ /* Interpret space as logical or */
+ symt = getExpr();
+ temp = symt->val & 07777;
+ temp_type = symt->type;
+
+ switch( value_type )
+ {
+ case MRI:
+ case MRIFIX:
+ /* Previous symbol was a Memory Reference Instruction. */
+ switch( temp_type )
+ {
+ case MRI:
+ case MRIFIX:
+ /* Current symbol is also a Memory Reference Instruction. */
+ value |= temp; /* Just OR the MRI instructions. */
+ break;
+
+ default:
+ /* Now have the address part of the MRI instruction. */
+ if( temp < 00200 )
+ {
+ value |= temp; /* Page zero MRI. */
+ }
+ else if( (( fieldlc + reloc ) & 07600 ) <= temp
+ && temp <= (( fieldlc + reloc ) | 0177 ))
+ {
+ value |= ( PAGE_BIT | (temp & ADDRESS_FIELD )); /* Current page MRI */
+ }
+ else
+ {
+ if(( value & INDIRECT_BIT ) == INDIRECT_BIT )
+ {
+ /* Already indirect, can't generate */
+ errorSymbol( &illegal_indirect, symt->name, lexstartprev );
+ }
+ else
+ {
+ if( literals_on )
+ {
+ /* Now fix off page reference. */
+ /* Search current page literal pool for needed value. */
+ /* Set Indirect Current Page */
+ value |= ( 00600 | insertLiteral( &cp, temp ));
+ indirect_generated = TRUE;
+ }
+ else
+ {
+ errorSymbol( &illegal_reference, symt->name, lexstartprev );
+ value |= ( temp & 0177 );
+ }
+ }
+ }
+ break;
+ }
+ break;
+
+ default:
+ value |= temp; /* Normal 12 bit value. */
+ break;
+ }
+ } /* end while */
+} /* getExprs() */
+
+
+/******************************************************************************/
+/* */
+/* Function: getExpr */
+/* */
+/* Synopsis: Get an expression, from the current lexeme onward, leave the */
+/* current lexeme as the one after the expression. Expressions */
+/* contain terminal symbols (identifiers) separated by operators. */
+/* */
+/******************************************************************************/
+SYM_T *getExpr()
+{
+ delimiter = line[lexterm];
+
+ if( line[lexstart] == '-' )
+ {
+ nextLexBlank();
+ sym_getexpr = *(eval());
+ sym_getexpr.val = ( - sym_getexpr.val );
+ }
+ else
+ {
+ sym_getexpr = *(eval());
+ }
+
+
+ if( is_blank( delimiter ))
+ {
+ return( &sym_getexpr );
+ }
+
+ /* Here we assume the current lexeme is the operator separating the */
+ /* previous operator from the next, if any. */
+ while( TRUE )
+ {
+ /* assert line[lexstart] == delimiter */
+ if( is_blank( delimiter ))
+ {
+ return( &sym_getexpr );
+ }
+
+ switch( line[lexstart] )
+ {
+ case '+': /* add */
+ nextLexBlank(); /* skip over the operator */
+ sym_getexpr.val += (eval())->val;
+ break;
+
+ case '-': /* subtract */
+ nextLexBlank(); /* skip over the operator */
+ sym_getexpr.val -= (eval())->val;
+ break;
+
+ case '^': /* multiply */
+ nextLexBlank(); /* skip over the operator */
+ sym_getexpr.val *= (eval())->val;
+ break;
+
+ case '%': /* divide */
+ nextLexBlank(); /* skip over the operator */
+ sym_getexpr.val /= (eval())->val;
+ break;
+
+ case '&': /* and */
+ nextLexBlank(); /* skip over the operator */
+ sym_getexpr.val &= (eval())->val;
+ break;
+
+ case '!': /* or */
+ nextLexBlank(); /* skip over the operator */
+ sym_getexpr.val |= (eval())->val;
+ break;
+
+ default:
+ if( isend( line[lexstart] ))
+ {
+ return( &sym_getexpr );
+ }
+
+ switch( line[lexstart] )
+ {
+ case '/':
+ case ';':
+ case ')':
+ case ']':
+ case '<':
+ break;
+
+ case '=':
+ errorMessage( &illegal_equals, lexstart );
+ moveToEndOfLine();
+ sym_getexpr.val = 0;
+ break;
+
+ default:
+ errorMessage( &illegal_expression, lexstart );
+ moveToEndOfLine();
+ sym_getexpr.val = 0;
+ break;
+ }
+ return( &sym_getexpr );
+ }
+ } /* end while */
+} /* getExpr() */
+
+
+/******************************************************************************/
+/* */
+/* Function: eval */
+/* */
+/* Synopsis: Get the value of the current lexeme, set delimiter and advance.*/
+/* */
+/******************************************************************************/
+SYM_T *eval()
+{
+ WORD16 digit;
+ WORD16 from;
+ WORD16 loc;
+ SYM_T *sym;
+ WORD16 val;
+
+ val = 0;
+
+ delimiter = line[lexterm];
+ if( isalpha( line[lexstart] ))
+ {
+ sym = evalSymbol();
+ if( M_UNDEFINED( sym->type ) && pass == 2 )
+ {
+ errorSymbol( &undefined_symbol, sym->name, lexstart );
+ nextLexeme();
+ return( sym );
+ }
+ else
+ {
+ nextLexeme();
+ return( sym );
+ }
+ }
+ else if( isdigit( line[lexstart] ))
+ {
+ from = lexstart;
+ val = 0;
+ while( from < lexterm )
+ {
+ if( isdigit( line[from] ))
+ {
+ digit = (WORD16) line[from++] - (WORD16) '0';
+ if( digit < radix )
+ {
+ val = val * radix + digit;
+ }
+ else
+ {
+ errorLexeme( &number_not_radix, from - 1 );
+ val = 0;
+ from = lexterm;
+ }
+ }
+ else
+ {
+ errorLexeme( ¬_a_number, lexstart );
+ val = 0;
+ from = lexterm;
+ }
+ }
+ nextLexeme();
+ sym_eval.val = val;
+ return( &sym_eval );
+ }
+ else
+ {
+ switch( line[lexstart] )
+ {
+ case '"': /* Character literal */
+ if( cc + 2 < maxcc )
+ {
+ val = line[lexstart + 1] | 0200;
+ delimiter = line[lexstart + 2];
+ cc = lexstart + 2;
+ }
+ else
+ {
+ errorMessage( &no_literal_value, lexstart );
+ }
+ nextLexeme();
+ break;
+
+ case '.': /* Value of Current Location Counter */
+ val = clc + reloc;
+ nextLexeme();
+ break;
+
+ case '[': /* Generate literal on page zero. */
+ if( !literals_on )
+ {
+ errorMessage( &literal_gen_off, lexstart );
+ }
+ nextLexBlank(); /* Skip bracket */
+ val = (getExpr())->val & 07777;
+ if( line[lexstart] == ']' )
+ {
+ nextLexBlank(); /* Skip end bracket */
+ }
+ else
+ {
+ /* errorMessage( "parens", lexstart ); */
+ }
+ sym_eval.val = literals_on ? insertLiteral( &pz, val ) : 0;
+ return( &sym_eval );
+
+ case '(': /* Generate literal on current page. */
+ if( !literals_on )
+ {
+ errorMessage( &literal_gen_off, lexstart );
+ }
+
+ nextLexBlank(); /* Skip paren */
+ val = getExprs() & 07777;
+
+ if( line[lexstart] == ')' )
+ {
+ nextLexBlank(); /* Skip end paren */
+ }
+ else
+ {
+ /* errorMessage( "parens", NULL ); */
+ }
+
+ loc = literals_on ? insertLiteral( &cp, val ) : 0;
+ sym_eval.val = loc + (( clc + reloc ) & 077600 );
+ return( &sym_eval );
+
+ default:
+ switch( line[lexstart] )
+ {
+ case '=':
+ errorMessage( &illegal_equals, lexstart );
+ moveToEndOfLine();
+ break;
+
+ default:
+ errorMessage( &illegal_character, lexstart );
+ break;
+ }
+ val = 0; /* On error, set value to zero. */
+ nextLexBlank(); /* Go past illegal character. */
+ }
+ }
+ sym_eval.val = val;
+ return( &sym_eval );
+} /* eval() */
+
+
+/******************************************************************************/
+/* */
+/* Function: inputDubl */
+/* */
+/* Synopsis: Get the value of the current lexeme as a double word. */
+/* */
+/******************************************************************************/
+void inputDubl()
+{
+ WORD32 dublvalue;
+ BOOL scanning_line;
+
+ scanning_line = TRUE;
+ do
+ {
+ while( scanning_line )
+ {
+ if( isend( line[lexstart] ))
+ {
+ scanning_line = FALSE;
+ }
+ else
+ {
+ switch( line[lexstart] )
+ {
+ case '/':
+ scanning_line = FALSE;
+ break;
+
+ case ';':
+ nextLexeme();
+ break;
+
+ case '+':
+ delimiter = line[lexterm];
+ nextLexBlank();
+ case '-':
+ default:
+ if( isdigit( line[lexstart] ) || line[lexstart] == '-' )
+ {
+ dublvalue = getDublExprs();
+ punchOutObject( clc, (WORD16)(( dublvalue >> 12 ) & 07777 ));
+ incrementClc();
+ punchOutObject( clc, (WORD16)( dublvalue & 07777 ));
+ incrementClc();
+ }
+ else
+ {
+ return; /* Non-numeric input, back to assembly. */
+ }
+ break;
+ } /* end switch */
+ } /* end if */
+
+ if( error_in_line )
+ {
+ return; /* Error occurred, exit DUBL input mode. */
+ }
+ } /* end while( scanning_line ) */
+ readLine();
+ nextLexeme();
+ scanning_line = TRUE;
+ }
+ while( TRUE );
+} /* inputDubl() */
+
+
+/******************************************************************************/
+/* */
+/* Function: getDublExprs */
+/* */
+/* Synopsis: Get a DUBL expression. */
+/* */
+/******************************************************************************/
+WORD32 getDublExprs()
+{
+ WORD32 dublvalue;
+
+ dublvalue = getDublExpr();
+
+ while( TRUE )
+ {
+ if( isdone( line[lexstart] ))
+ {
+ return( dublvalue );
+ }
+ else
+ {
+ errorMessage( &illegal_expression, lexstart - 1 );
+ return( 0 );
+ }
+ } /* end while */
+} /* getDublExprs() */
+
+
+/******************************************************************************/
+/* */
+/* Function: getDublExpr */
+/* */
+/* Synopsis: Get the value of the current lexeme as a double word. The */
+/* number is always considered to have a decimal radix. */
+/* */
+/******************************************************************************/
+WORD32 getDublExpr()
+{
+ WORD32 dublvalue;
+
+ delimiter = line[lexterm];
+ if( line[lexstart] == '-' )
+ {
+ nextLexBlank();
+ dublvalue = evalDubl( 0 );
+ nextLexeme();
+ /* Test for any value greater than 23 bits in length. */
+ if( (unsigned long int)dublvalue > 040000000L )
+ {
+ errorMessage( &dubl_overflow, lexstart );
+ dublvalue = 0;
+ }
+ dublvalue = -dublvalue;
+ }
+ else
+ {
+ dublvalue = evalDubl( 0 );
+ nextLexeme();
+ /* Test for any value greater than 23 bits in length. */
+ if( (unsigned long int)dublvalue > 037777777L )
+ {
+ errorMessage( &dubl_overflow, lexstart );
+ dublvalue = 0;
+ }
+ }
+
+ if( is_blank( delimiter ))
+ {
+ return( dublvalue );
+ }
+
+ /* Here we assume the current lexeme is the operator separating the */
+ /* previous operator from the next, if any. */
+ while( TRUE )
+ {
+ /* assert line[lexstart] == delimiter */
+ if( is_blank( delimiter ))
+ {
+ errorMessage( &illegal_expression, lexstart );
+ moveToEndOfLine();
+ dublvalue = 0;
+ return( dublvalue );
+ }
+
+ switch( line[lexstart] )
+ {
+ case '+': /* add */
+ case '-': /* subtract */
+ case '^': /* multiply */
+ case '%': /* divide */
+ case '&': /* and */
+ case '!': /* or */
+ errorMessage( &illegal_expression, lexstart );
+ moveToEndOfLine();
+ dublvalue = 0;
+ break;
+
+ default:
+ if( isend( line[lexstart] ))
+ {
+ return( dublvalue );
+ }
+
+ switch( line[lexstart] )
+ {
+ case '/':
+ case ';':
+ break;
+
+ default:
+ errorMessage( &illegal_expression, lexstart );
+ moveToEndOfLine();
+ dublvalue = 0;
+ break;
+ }
+ return( dublvalue );
+ }
+ } /* end while */
+} /* getDublExpr() */
+
+
+/******************************************************************************/
+/* */
+/* Function: evalDubl */
+/* */
+/* Synopsis: Get the value of the current lexeme as a double word. The */
+/* number is always considered to have a decimal radix. */
+/* */
+/******************************************************************************/
+WORD32 evalDubl( WORD32 initial_value )
+{
+ WORD32 digit;
+ WORD16 from;
+ WORD32 dublvalue;
+ WORD32 olddublvalue;
+
+ overflow = FALSE;
+ delimiter = line[lexterm];
+ from = lexstart;
+ dublvalue = initial_value;
+
+ while( from < lexterm )
+ {
+ if( isdigit( line[from] ))
+ {
+ olddublvalue = dublvalue;
+ digit = (WORD32)( line[from++] - '0' );
+ dublvalue = dublvalue * 10 + digit;
+ if( dublvalue < olddublvalue )
+ {
+ overflow = TRUE;
+ }
+ }
+ else
+ {
+ errorLexeme( ¬_a_number, from );
+ dublvalue = 0;
+ from = lexterm;
+ }
+ }
+ return( dublvalue );
+} /* evalDubl() */
+
+
+/******************************************************************************/
+/* */
+/* Function: inputFltg */
+/* */
+/* Synopsis: Get the value of the current lexeme as a Floating Point const. */
+/* */
+/******************************************************************************/
+void inputFltg()
+{
+ FLTG_T *fltg;
+ BOOL scanning_line;
+
+ fltg_input = TRUE; /* Set lexeme scanner for floating point. */
+ scanning_line = TRUE;
+ while( TRUE )
+ {
+ while( scanning_line )
+ {
+ if( isend( line[lexstart] ))
+ {
+ scanning_line = FALSE;
+ }
+ else
+ {
+ switch( line[lexstart] )
+ {
+ case '/':
+ scanning_line = FALSE;
+ break;
+
+ case ';':
+ nextLexeme();
+ break;
+
+ case '+':
+ delimiter = line[lexterm];
+ nextLexBlank();
+ case '-':
+ default:
+ if( isdigit( line[lexstart] ) || line[lexstart] == '-' )
+ {
+ fltg = getFltgExprs();
+ punchOutObject( clc, ( fltg->exponent & 07777 ));
+ incrementClc();
+ punchOutObject( clc, (WORD16)(( fltg->mantissa >> 12 ) & 07777 ));
+ incrementClc();
+ punchOutObject( clc, (WORD16)( fltg->mantissa & 07777 ));
+ incrementClc();
+ }
+ else
+ {
+ fltg_input = FALSE; /* Reset lexeme scanner. */
+ return; /* Non-numeric input, back to assembly. */
+ }
+ break;
+ } /* end switch */
+ } /* end if */
+
+ if( error_in_line )
+ {
+ fltg_input = FALSE; /* Reset lexeme scanner. */
+ return; /* Error occurred, exit FLTG input mode. */
+ }
+ } /* end while( scanning_line ) */
+ readLine();
+ nextLexeme();
+ scanning_line = TRUE;
+ }
+} /* inputFltg() */
+
+
+/******************************************************************************/
+/* */
+/* Function: getFltgExprs */
+/* */
+/* Synopsis: Get a FLTG expression. */
+/* */
+/******************************************************************************/
+FLTG_T *getFltgExprs()
+{
+ FLTG_T *fltg;
+
+ fltg = getFltgExpr();
+
+ while( TRUE )
+ {
+ if( isdone( line[lexstart] ))
+ {
+ return( fltg );
+ }
+ else
+ {
+ errorMessage( &illegal_expression, lexstart - 1 );
+ return( 0 );
+ }
+ } /* end while */
+} /* getFltgExprs() */
+
+
+/******************************************************************************/
+/* */
+/* Function: getFltgExpr */
+/* */
+/* Synopsis: Get the value of the current lexeme as a double word. The */
+/* number is always considered to have a decimal radix. */
+/* */
+/******************************************************************************/
+FLTG_T *getFltgExpr()
+{
+ FLTG_T *fltg;
+
+ delimiter = line[lexterm];
+ fltg = evalFltg();
+ /* Test for any value greater than 23 bits in length. */
+ if( (unsigned long int)fltg->mantissa> 077777777L )
+ {
+ errorMessage( &fltg_overflow, lexstart );
+ }
+
+ if( is_blank( delimiter ))
+ {
+ return( fltg );
+ }
+
+ /* Here we assume the current lexeme is the operator separating the */
+ /* previous operator from the next, if any. */
+ while( TRUE )
+ {
+ /* assert line[lexstart] == delimiter */
+ if( is_blank( delimiter ))
+ {
+ errorMessage( &illegal_expression, lexstart );
+ moveToEndOfLine();
+ fltg = 0;
+ return( fltg );
+ }
+
+ switch( line[lexstart] )
+ {
+ case '+': /* add */
+ case '-': /* subtract */
+ case '^': /* multiply */
+ case '%': /* divide */
+ case '&': /* and */
+ case '!': /* or */
+ errorMessage( &illegal_expression, lexstart );
+ moveToEndOfLine();
+ fltg = NULL;
+ break;
+
+ default:
+ if( isend( line[lexstart] ))
+ {
+ return( fltg );
+ }
+
+ switch( line[lexstart] )
+ {
+ case '/':
+ case ';':
+ break;
+
+ default:
+ errorMessage( &illegal_expression, lexstart );
+ moveToEndOfLine();
+ fltg = NULL;
+ break;
+ }
+ return( fltg );
+ }
+ } /* end while */
+} /* getFltgExpr() */
+
+
+/******************************************************************************/
+/* */
+/* Function: evalFltg */
+/* */
+/* Synopsis: Get the value of the current lexeme as a floating point value. */
+/* Floating point input is alwasy considered decimal. */
+/* The general format of a floating point number is: */
+/* +-ddd.dddE+-dd where each d is a decimal digit. */
+/* */
+/******************************************************************************/
+FLTG_T *evalFltg()
+{
+ BYTE current_state;
+ BYTE current_col;
+ WORD16 exponent;
+ FLTG_T *fltg;
+ WORD32 input_value;
+ BOOL negate;
+ BOOL negate_exponent;
+ BYTE next_state;
+ int right_digits;
+
+ /* This uses a lexical analyzer to parse the floating point format. */
+ static BYTE state_table[][10] =
+ {
+ /* 0 1 2 3 4 5 6 Oolumn index */
+ /* + - d . E sp p State Comment */
+ { 2, 1, 3, 4, 10, 10, 10 }, /* 0 Initial state. */
+ { 11, 11, 3, 4, 11, 11, 11 }, /* 1 - */
+ { 11, 11, 3, 4, 11, 11, 11 }, /* 2 + */
+ { 10, 10, 10, 4, 6, 10, 10 }, /* 3 # (+-ddd) */
+ { 11, 11, 5, 11, 11, 10, 10 }, /* 4 . (+-ddd.) */
+ { 11, 11, 11, 11, 6, 10, 11 }, /* 5 # (+-ddd.ddd) */
+ { 8, 7, 9, 11, 11, 11, 11 }, /* 6 E (+-ddd.dddE) */
+ { 11, 11, 9, 11, 11, 11, 11 }, /* 7 - (+-ddd.dddE- */
+ { 11, 11, 9, 11, 11, 11, 11 }, /* 8 + (+-ddd.dddE+ */
+ { 11, 11, 11, 11, 11, 10, 11 } /* 9 # (+-ddd.dddE+-dd */
+ /* 10 Completion state */
+ /* 11 Error state. */
+ };
+
+ delimiter = line[lexterm];
+ fltg = &fltg_ac;
+ fltg->exponent = 0;
+ fltg->mantissa = 0;
+ input_value = 0;
+ negate = FALSE;
+ negate_exponent = FALSE;
+ exponent = 0;
+ right_digits = 0;
+ current_state = 0;
+
+ while( TRUE )
+ {
+ /* Classify character. This is the column index. */
+ switch( line[lexstart] )
+ {
+ case '+':
+ current_col = 0;
+ break;
+
+ case '-':
+ current_col = 1;
+ break;
+
+ case '.':
+ current_col = 3;
+ break;
+
+ case 'E': case 'e':
+ current_col = 4;
+ break;
+
+ default:
+ if( isdigit( line[lexstart] ))
+ {
+ current_col = 2;
+ }
+ else if( isdone( line[lexstart] ))
+ {
+ current_col = 5;
+ }
+ else
+ {
+ current_col = 6;
+ }
+ break;
+ }
+
+ next_state = state_table[current_state][current_col];
+
+ switch( next_state )
+ {
+ case 1: /* - */
+ negate = TRUE;
+ case 2: /* + */
+ delimiter = line[lexterm]; /* Move past the + or - character. */
+ nextLexBlank();
+ break;
+
+ case 3: /* Number (+-ddd) */
+ input_value = evalDubl( 0 ); /* Integer part of the number. */
+ nextLexeme(); /* Move past previous lexeme. */
+ break;
+
+ case 4:
+ delimiter = line[lexterm];
+ nextLexBlank(); /* Move past the . character. */
+ break;
+
+ case 5: /* . (+-ddd.ddd) */
+ /* Fractional part of the number. */
+ input_value = evalDubl( input_value );
+ right_digits = lexterm - lexstart;/* Digit count to right of decimal. */
+ nextLexeme(); /* Move past previous lexeme. */
+ break;
+
+ case 6: /* E (+-ddd.dddE) */
+ delimiter = line[lexterm]; /* Move past the E. */
+ nextLexBlank();
+ break;
+
+ case 7: /* - (+-ddd.dddE-) */
+ negate_exponent = TRUE;
+ case 8: /* + (+-ddd.dddE+) */
+ delimiter = line[lexterm]; /* Move past the + or - character. */
+ nextLexBlank();
+ break;
+
+ case 9: /* # (+-ddd.dddE+-dd) */
+ exponent = (int)evalDubl( 0 ); /* Exponent of floating point number. */
+ if( negate_exponent ) { exponent = - exponent; }
+ nextLexeme(); /* Move past previous lexeme. */
+ break;
+
+ case 10: /* Floating number parsed, convert */
+ /* the number. */
+ /* Get the exponent for the number as input. */
+ exponent -= right_digits;
+
+ /* Remove trailing zeros and adjust the exponent accordingly. */
+ while(( input_value % 10 ) == 0 )
+ {
+ input_value /= 10;
+ exponent++;
+ }
+
+ /* Convert the number to floating point. The number is calculated with */
+ /* a 27 bit mantissa to improve precision. The extra 3 bits are */
+ /* discarded after the result has been calculated. */
+ fltg->exponent = 26;
+ fltg->mantissa = input_value << 3;
+ normalizeFltg( fltg );
+
+
+ while( exponent != 0 )
+ {
+ if( exponent < 0 )
+ {
+ /* Decimal point is to the left. */
+ fltg->mantissa /= 10;
+ normalizeFltg( fltg );
+ exponent++;
+ }
+ else if( exponent > 0 )
+ {
+ /* Decimal point is to the right. */
+ fltg->mantissa *= 10;
+ normalizeFltg( fltg );
+ exponent--;
+ }
+ }
+
+ /* Discard the extra precsion used for calculating the number. */
+ fltg->mantissa >>= 3;
+ fltg->exponent -= 3;
+ if( negate )
+ {
+ fltg->mantissa = (- fltg->mantissa ) & 077777777L;
+ }
+ return( fltg );
+
+ case 11: /* Error in format. */
+ /* Not a properly constructued floating point number. */
+ return( fltg );
+ default:
+ break;
+ }
+ /* Set state for next pass through the loop. */
+ current_state = next_state;
+ }
+} /* evalFltg() */
+
+
+
+/******************************************************************************/
+/* */
+/* Function: normalizeFltg */
+/* */
+/* Synopsis: Normalize a PDP-8 double precision floating point number. */
+/* */
+/******************************************************************************/
+void normalizeFltg( FLTG_T *fltg )
+{
+ /* Normalize the floating point number. */
+ if( fltg->mantissa != 0 )
+ {
+ if(( fltg->mantissa & ~0x3FFFFFFL ) == 0 )
+ {
+ while(( fltg->mantissa & ~0x1FFFFFFL ) == 0 )
+
+ {
+ fltg->mantissa <<= 1;
+ fltg->exponent--;
+ }
+ }
+ else
+ {
+ while(( fltg->mantissa & ~0x3FFFFFFL ) != 0 )
+ {
+ fltg->mantissa >>= 1;
+ fltg->exponent++;
+ }
+ }
+ }
+ else
+ {
+ fltg->exponent = 0;
+ }
+ return;
+}
+
+
+/******************************************************************************/
+/* */
+/* Function: incrementClc */
+/* */
+/* Synopsis: Set the next assembly location. Test for collision with */
+/* the literal tables. */
+/* */
+/******************************************************************************/
+WORD16 incrementClc()
+{
+ testForLiteralCollision( clc );
+
+ /* Incrementing the location counter is not to change field setting. */
+ clc = ( clc & 070000 ) + (( clc + 1 ) & 07777 );
+ fieldlc = clc & 07777;
+ return( clc );
+} /* incrementClc() */
+
+
+/******************************************************************************/
+/* */
+/* Function: testForLiteralCollision */
+/* */
+/* Synopsis: Test the given location for collision with the literal tables. */
+/* */
+/******************************************************************************/
+BOOL testForLiteralCollision( WORD16 loc )
+{
+ WORD16 pagelc;
+ BOOL result = FALSE;
+ WORD16 tmppage;
+
+ tmppage = loc & 07600;
+ pagelc = loc & 00177;
+
+ if( tmppage == 0 )
+ {
+ if( pagelc >= pz.loc && !pz.error )
+ {
+ errorMessage( &pz_literal_overflow, -1 );
+ pz.error = TRUE;
+ result = TRUE;
+ }
+ }
+ else
+ {
+ if( pagelc >= cp.loc && !cp.error )
+ {
+ errorMessage( &literal_overflow, -1 );
+ cp.error = TRUE;
+ result = TRUE;
+ }
+ }
+ return( result );
+} /* testForLiteralCollision() */
+
+
+/******************************************************************************/
+/* */
+/* Function: readLine */
+/* */
+/* Synopsis: Get next line of input. Print previous line if needed. */
+/* */
+/******************************************************************************/
+void readLine()
+{
+ WORD16 ix;
+ WORD16 iy;
+ char inpline[LINELEN];
+
+ listLine(); /* List previous line if needed. */
+ lineno++; /* Count lines read. */
+ indirect_generated = FALSE; /* Mark no indirect address generated. */
+ listed = FALSE; /* Mark as not listed. */
+ cc = 0; /* Initialize column counter. */
+ lexstartprev = 0;
+
+ if(( fgets( inpline, LINELEN - 1, infile )) == NULL )
+ {
+ inpline[0] = '$';
+ inpline[1] = '\n';
+ inpline[2] = '\0';
+ error_in_line = TRUE;
+ }
+ else
+ {
+ error_in_line = FALSE;
+ }
+
+ /* Remove any tabs from the input line by inserting the required number */
+ /* of spaces to simulate 8 character tab stops. */
+ for( ix = 0, iy = 0; inpline[ix] != '\0'; ix++ )
+ {
+ switch( inpline[ix] )
+ {
+ case '\t':
+ do
+ {
+ line[iy] = ' ';
+ iy++;
+ }
+ while(( iy % 8 ) != 0 );
+ break;
+
+ default:
+ line[iy] = inpline[ix];
+ iy++;
+ break;
+ }
+ }
+ line[iy] = '\0';
+
+ /* If the line is terminated by CR-LF, remove, the CR. */
+ if( line[iy - 2] == '\r' )
+ {
+ iy--;
+ line[iy - 1] = line[iy - 0];
+ line[iy] = '\0';
+ }
+ maxcc = iy; /* Save the current line length. */
+} /* readLine() */
+
+
+/******************************************************************************/
+/* */
+/* Function: listLine */
+/* */
+/* Synopsis: Output a line to the listing file. */
+/* */
+/******************************************************************************/
+void listLine()
+/* generate a line of listing if not already done! */
+{
+ if( listfile != NULL && listed == FALSE )
+ {
+ printLine( line, 0, 0, LINE );
+ }
+} /* listLine() */
+
+
+/******************************************************************************/
+/* */
+/* Function: printPageBreak */
+/* */
+/* Synopsis: Output a Top of Form and listing header if new page necessary. */
+/* */
+/******************************************************************************/
+void printPageBreak()
+{
+ if( page_lineno >= LIST_LINES_PER_PAGE )
+ /* ( list_lineno % LIST_LINES_PER_PAGE ) == 0 ) */
+ {
+ if( !list_title_set )
+ {
+ strcpy( list_title, line );
+ if( list_title[strlen(list_title) - 1] == '\n' )
+ {
+ list_title[strlen(list_title) - 1] = '\0';
+ }
+ if( strlen( list_title ) > TITLELEN )
+ {
+ list_title[TITLELEN] = '\0';
+ }
+ list_title_set = TRUE;
+ }
+ topOfForm( list_title, NULL );
+
+ }
+} /* printPageBreak() */
+
+
+/******************************************************************************/
+/* */
+/* Function: printLine */
+/* */
+/* Synopsis: Output a line to the listing file with new page if necessary. */
+/* */
+/******************************************************************************/
+void printLine( char *line, WORD16 loc, WORD16 val, LINESTYLE_T linestyle )
+{
+ if( listfile == NULL )
+ {
+ save_error_count = 0;
+ return;
+ }
+
+ printPageBreak();
+
+ list_lineno++;
+ page_lineno++;
+ switch( linestyle )
+ {
+ default:
+ case LINE:
+ fprintf(listfile, "%5d ", lineno );
+ fputs( line, listfile );
+ listed = TRUE;
+ break;
+
+ case LINE_VAL:
+ fprintf(listfile, "%5d %4.4o ", lineno, val );
+ fputs( line, listfile );
+ listed = TRUE;
+ break;
+
+ case LINE_LOC_VAL:
+ if( !listed )
+ {
+ if( indirect_generated )
+ {
+ fprintf( listfile, "%5d %5.5o %4.4o@ ", lineno, loc, val );
+ }
+ else
+ {
+ fprintf( listfile, "%5d %5.5o %4.4o ", lineno, loc, val );
+ }
+ fputs( line, listfile );
+ listed = TRUE;
+ }
+ else
+ {
+ fprintf( listfile, " %5.5o %4.4o\n", loc, val );
+ }
+ break;
+
+ case LOC_VAL:
+ fprintf( listfile, " %5.5o %4.4o\n", loc, val );
+ break;
+ }
+ printErrorMessages();
+} /* printLine() */
+
+
+/******************************************************************************/
+/* */
+/* Function: printErrorMessages */
+/* */
+/* Synopsis: Output any error messages from the current list of errors. */
+/* */
+/******************************************************************************/
+void printErrorMessages()
+{
+ WORD16 ix;
+ WORD16 iy;
+
+ if( listfile != NULL )
+ {
+ /* If any errors, display them now. */
+ for( iy = 0; iy < save_error_count; iy++ )
+ {
+ printPageBreak();
+ fprintf( listfile, "%-18.18s", error_list[iy].mesg );
+ if( error_list[iy].col >= 0 )
+ {
+ for( ix = 0; ix < error_list[iy].col; ix++ )
+ {
+ if( line[ix] == '\t' )
+ {
+ putc( '\t', listfile );
+ }
+ else
+ {
+ putc( ' ', listfile );
+ }
+ }
+ fputs( "^", listfile );
+ list_lineno++;
+ page_lineno++;
+ }
+ fputs( "\n", listfile );
+ }
+ }
+ save_error_count = 0;
+} /* printErrorMessages() */
+
+
+/******************************************************************************/
+/* */
+/* Function: endOfBinary */
+/* */
+/* Synopsis: Outputs both literal tables at the end of a binary segment. */
+/* */
+/******************************************************************************/
+void endOfBinary()
+{
+ /* Points to end of page for () operands. */
+ punchLiteralPool( &cp, clc - 1 );
+ /* Points to end of page zero for [] operands. */
+ punchLiteralPool( &pz, 0 );
+ if( error_in_line )
+ {
+ listed = TRUE;
+ clc = ( clc & 070000 ) + (( clc - 1 ) & 07777 );
+ errorMessage( &end_of_file, -1 );
+ clc = ( clc & 070000 ) + (( clc + 1 ) & 07777 );
+ }
+ else
+ {
+ listLine(); /* List line if not done yet. */
+ }
+ return;
+} /* endOfBinary() */
+
+
+/******************************************************************************/
+/* */
+/* Function: punchChecksum */
+/* */
+/* Synopsis: Output a checksum if the current mode requires it and an */
+/* object file exists. */
+/* */
+/******************************************************************************/
+void punchChecksum()
+{
+ /* If the assembler has output any BIN data output the checksum. */
+ if( binary_data_output && !rim_mode )
+ {
+ punchLocObject( 0, checksum );
+ }
+ binary_data_output = FALSE;
+ checksum = 0;
+} /* punchChecksum() */
+
+
+/******************************************************************************/
+/* */
+/* Function: punchLeader */
+/* */
+/* Synopsis: Generate 2 feet of leader on object file, as per DEC */
+/* documentation. Paper tape has 10 punches per inch. */
+/* */
+/******************************************************************************/
+void punchLeader( WORD16 count )
+{
+ WORD16 ix;
+
+ /* If value is zero, set to the default of 2 feet of leader. */
+ count = ( count == 0 ) ? 240 : count;
+
+ if( objectfile != NULL )
+ {
+ for( ix = 0; ix < count; ix++ )
+ {
+ fputc( 0200, objectfile );
+ }
+ }
+} /* punchLeader() */
+
+
+/******************************************************************************/
+/* */
+/* Function: punchOrigin */
+/* */
+/* Synopsis: Output an origin to the object file. */
+/* */
+/******************************************************************************/
+void punchOrigin( WORD16 loc )
+{
+ punchObject((( loc >> 6 ) & 0077 ) | 0100 );
+ punchObject( loc & 0077 );
+} /* punchOrigin() */
+
+
+/******************************************************************************/
+/* */
+/* Function: punchObject */
+/* */
+/* Synopsis: Put one character to object file and include it in checksum. */
+/* */
+/******************************************************************************/
+void punchObject( WORD16 val )
+{
+ val &= 0377;
+ if( objectfile != NULL )
+ {
+ fputc( val, objectfile );
+ }
+ checksum += val;
+ binary_data_output = TRUE;
+} /* punchObject() */
+
+
+/******************************************************************************/
+/* */
+/* Function: punchOutObject */
+/* */
+/* Synopsis: Output the current line and then then punch value to the */
+/* object file. */
+/* */
+/******************************************************************************/
+void punchOutObject( WORD16 loc, WORD16 val )
+{
+ printLine( line, ( field | loc ), val, LINE_LOC_VAL );
+ punchLocObject( loc, val );
+} /* punchOutObject() */
+
+/******************************************************************************/
+/* */
+/* Function: punchLocObject */
+/* */
+/* Synopsis: Output the word (with origin if rim format) to the object file.*/
+/* */
+/******************************************************************************/
+void punchLocObject( WORD16 loc, WORD16 val )
+{
+ if( rim_mode )
+ {
+ punchOrigin( loc );
+ }
+ punchObject(( val >> 6 ) & 0077 );
+ punchObject( val & 0077 );
+} /* punchLocObject() */
+
+
+/******************************************************************************/
+/* */
+/* Function: punchLiteralPool */
+/* */
+/* Synopsis: Output the current page data. */
+/* */
+/******************************************************************************/
+void punchLiteralPool( LPOOL_T *p, WORD16 lpool_page )
+{
+ WORD16 loc;
+ WORD16 tmplc;
+
+ lpool_page &= 07600;
+
+ if( p->loc < 00200 )
+ {
+ if( !rim_mode )
+ {
+ /* Put out origin if not in rim mode. */
+ punchOrigin( p->loc | lpool_page );
+ }
+ /* Put the literals in the object file. */
+ for( loc = p->loc; loc < 00200; loc++ )
+ {
+ tmplc = loc + lpool_page;
+ printLine( line, (field | tmplc), p->pool[loc], LOC_VAL );
+ punchLocObject( tmplc, p->pool[loc] );
+ }
+ p->error = FALSE;
+ p->loc = 00200;
+ }
+} /* punchLiteralPool() */
+
+
+/******************************************************************************/
+/* */
+/* Function: insertLiteral */
+/* */
+/* Synopsis: Add a value to the given literal pool if not already in pool. */
+/* Return the location of the value in the pool. */
+/* */
+/******************************************************************************/
+WORD16 insertLiteral( LPOOL_T *pool, WORD16 value )
+{
+ WORD16 ix;
+ LPOOL_T *p;
+
+ p = pool;
+
+ /* If page zero is the current page, make sure that literals are inserted */
+ /* in the page zero literal table. */
+ if(( clc & 07600 ) == 0 )
+ {
+ p = &pz;
+ }
+
+ /* Search the literal pool for any occurence of the needed value. */
+ ix = PAGE_SIZE - 1;
+ while( ix >= p->loc && p->pool[ix] != value )
+ {
+ ix--;
+ }
+
+ /* Check if value found in literal pool. If not, then insert value. */
+ if( ix < p->loc )
+ {
+ (p->loc)--;
+ p->pool[p->loc] = value;
+ ix = p->loc;
+ }
+ return( ix );
+} /* insertLiteral() */
+
+
+/******************************************************************************/
+/* */
+/* Function: printSymbolTable */
+/* */
+/* Synopsis: Output the symbol table. */
+/* */
+/******************************************************************************/
+void printSymbolTable()
+{
+ int col;
+ int cx;
+ char *fmt;
+ int ix;
+ char mark;
+ int page;
+ int row;
+ int symbol_base;
+ int symbol_lines;
+
+ symbol_base = number_of_fixed_symbols;
+
+ for( page=0, list_lineno=0, col=0, ix=symbol_base; ix < symbol_top; page++ )
+ {
+ topOfForm( list_title, s_symtable );
+ symbol_lines = LIST_LINES_PER_PAGE - page_lineno;
+
+ for( row = 0; page_lineno < LIST_LINES_PER_PAGE && ix < symbol_top; row++)
+ {
+ list_lineno++;
+ page_lineno++;
+ fprintf( listfile, "%5d", list_lineno );
+
+ for( col = 0; col < SYMBOL_COLUMNS && ix < symbol_top; col++ )
+ {
+ /* Get index of symbol for the current line and column */
+ cx = symbol_lines * ( SYMBOL_COLUMNS * page + col ) + row;
+ cx += symbol_base;
+
+ /* Make sure that there is a symbol to be printed. */
+ if( number_of_fixed_symbols <= cx && cx < symbol_top )
+ {
+ switch( symtab[cx].type & LABEL )
+ {
+ case LABEL:
+ fmt = " %c%-6.6s %5.5o ";
+ break;
+
+ default:
+ fmt = " %c%-6.6s %4.4o ";
+ break;
+ }
+
+ switch( symtab[cx].type & ( DEFINED | REDEFINED ))
+ {
+ case UNDEFINED:
+ mark = '?';
+ break;
+
+ case REDEFINED:
+ mark = '#';
+ break;
+
+ default:
+ mark = ' ';
+ break;
+ }
+ fprintf( listfile, fmt, mark, symtab[cx].name, symtab[cx].val );
+ ix++;
+ }
+ }
+ fprintf( listfile, "\n" );
+ }
+ }
+} /* printSymbolTable() */
+
+
+/******************************************************************************/
+/* */
+/* Function: printPermanentSymbolTable */
+/* */
+/* Synopsis: Output the permanent symbol table to a file suitable for */
+/* being input after the EXPUNGE pseudo-op. */
+/* */
+/******************************************************************************/
+void printPermanentSymbolTable()
+{
+ int ix;
+ FILE *permfile;
+ char *s_type;
+
+ if(( permfile = fopen( permpathname, "w" )) == NULL )
+ {
+ exit( 2 );
+ }
+
+ fprintf( permfile, "/ PERMANENT SYMBOL TABLE\n/\n" );
+ fprintf( permfile, " EXPUNGE\n/\n" );
+ /* Print the memory reference instructions first. */
+ s_type = "FIXMRI";
+ for( ix = 0; ix < symbol_top; ix++ )
+ {
+ if( M_MRI( symtab[ix].type ))
+ {
+ fprintf( permfile, "%-7s %s=%4.4o\n",
+ s_type, symtab[ix].name, symtab[ix].val );
+ }
+ }
+
+ s_type = " ";
+ for( ix = 0; ix < symbol_top; ix++ )
+ {
+ if( M_FIXED( symtab[ix].type ))
+ {
+ if( !M_MRI( symtab[ix].type ) && !M_PSEUDO( symtab[ix].type ))
+ {
+ fprintf( permfile, "%-7s %s=%4.4o\n",
+ s_type, symtab[ix].name, symtab[ix].val );
+ }
+ }
+ }
+ fprintf( permfile, "/\n FIXTAB\n" );
+ fclose( permfile );
+} /* printPermanentSymbolTable() */
+
+
+/******************************************************************************/
+/* */
+/* Function: printCrossReference */
+/* */
+/* Synopsis: Output a cross reference (concordance) for the file being */
+/* assembled. */
+/* */
+/******************************************************************************/
+void printCrossReference()
+{
+ int ix;
+ int symbol_base;
+ int xc;
+ int xc_index;
+ int xc_refcount;
+ int xc_cols;
+
+ /* Force top of form for first page. */
+ page_lineno = LIST_LINES_PER_PAGE;
+
+ list_lineno = 0;
+ symbol_base = number_of_fixed_symbols;
+
+ for( ix = symbol_base; ix < symbol_top; ix++ )
+ {
+ list_lineno++;
+ page_lineno++;
+ if( page_lineno >= LIST_LINES_PER_PAGE )
+ {
+ topOfForm( list_title, s_xref );
+ }
+
+ fprintf( listfile, "%5d", list_lineno );
+
+ /* Get reference count & index into concordance table for this symbol. */
+ xc_refcount = symtab[ix].xref_count;
+ xc_index = symtab[ix].xref_index;
+ /* Determine how to label symbol on concordance. */
+ switch( symtab[ix].type & ( DEFINED | REDEFINED ))
+ {
+ case UNDEFINED:
+ fprintf( listfile, " U ");
+ break;
+
+ case REDEFINED:
+ fprintf( listfile, " M %5d ", xreftab[xc_index] );
+ break;
+
+ default:
+ fprintf( listfile, " A %5d ", xreftab[xc_index] );
+ break;
+ }
+ fprintf( listfile, "%-6.6s ", symtab[ix].name );
+
+ /* Output the references, 8 numbers per line after symbol name. */
+ for( xc_cols = 0, xc = 1; xc < xc_refcount + 1; xc++, xc_cols++ )
+ {
+ if( xc_cols >= XREF_COLUMNS )
+ {
+ xc_cols = 0;
+ page_lineno++;
+ if( page_lineno >= LIST_LINES_PER_PAGE )
+ {
+ topOfForm( list_title, s_xref);
+ }
+ list_lineno++;
+ fprintf( listfile, "\n%5d%-19s", list_lineno, " " );
+ }
+ fprintf( listfile, " %5d", xreftab[xc_index + xc] );
+ }
+ fprintf( listfile, "\n" );
+ }
+} /* printCrossReference() */
+
+
+/******************************************************************************/
+/* */
+/* Function: topOfForm */
+/* */
+/* Synopsis: Prints title and sub-title on top of next page of listing. */
+/* */
+/******************************************************************************/
+void topOfForm( char *title, char *sub_title )
+{
+ char temp[10];
+
+ list_pageno++;
+ strcpy( temp, s_page );
+ sprintf( temp, "%s %d", s_page, list_pageno );
+
+ /* Output a top of form if not the first page of the listing. */
+ if( list_pageno > 1 )
+ {
+ fprintf( listfile, "\f" );
+ }
+ fprintf( listfile, "\n\n\n %-63s %10s\n", title, temp );
+
+ /* Reset the current page line counter. */
+ page_lineno = 3;
+ if( sub_title != NULL )
+ {
+ fprintf( listfile, "%80s\n", sub_title );
+ page_lineno++;
+ }
+ else
+ {
+ fprintf( listfile, "\n" );
+ page_lineno++;
+ }
+ fprintf( listfile, "\n" );
+ page_lineno++;
+} /* topOfForm() */
+
+
+/******************************************************************************/
+/* */
+/* Function: lexemeToName */
+/* */
+/* Synopsis: Convert the current lexeme into a string. */
+/* */
+/******************************************************************************/
+char *lexemeToName( char *name, WORD16 from, WORD16 term )
+{
+ WORD16 to;
+
+ to = 0;
+
+ while( from < term && to < ( SYMLEN - 1 ))
+ {
+ name[to++] = toupper( line[from++] );
+ }
+
+ while( to < SYMLEN )
+ {
+ name[to++] = '\0';
+ }
+ return( name );
+} /* lexemeToName() */
+
+/******************************************************************************/
+/* */
+/* Function: defineLexeme */
+/* */
+/* Synopsis: Put lexeme into symbol table with a value. */
+/* */
+/******************************************************************************/
+SYM_T *defineLexeme( WORD16 start, /* start of lexeme being defined. */
+ WORD16 term, /* end+1 of lexeme being defined. */
+ WORD16 val, /* value of lexeme being defined. */
+ SYMTYP type ) /* how symbol is being defined. */
+{
+ char name[SYMLEN];
+
+ lexemeToName( name, start, term);
+ return( defineSymbol( name, val, type, start ));
+} /* defineLexeme() */
+
+
+/******************************************************************************/
+/* */
+/* Function: defineSymbol */
+/* */
+/* Synopsis: Define a symbol in the symbol table, enter symbol name if not */
+/* not already in table. */
+/* */
+/******************************************************************************/
+SYM_T *defineSymbol( char *name, WORD16 val, SYMTYP type, WORD16 start )
+{
+ SYM_T *sym;
+ WORD16 xref_count;
+
+ if( strlen( name ) < 1 )
+ {
+ return( &sym_undefined ); /* Protect against non-existent names. */
+ }
+ sym = lookup( name );
+ if( M_FIXED( sym->type ))
+ {
+ return( sym ); /* Can't modify permanent symbols. */
+ }
+
+ xref_count = 0; /* Set concordance for normal defintion. */
+
+ if( M_DEFINED( sym->type ))
+ {
+ if( pass == 2 && sym->val != val )
+ {
+ /* Generate diagnostic if redefining a symbol. */
+ if( M_REDEFINED( sym->type ))
+ {
+ errorSymbol( &redefined_symbol, sym->name, start );
+ }
+ type = type | REDEFINED;
+ sym->xref_count++; /* Referenced suymbol, count it. */
+ xref_count = sym->xref_count;
+ }
+ }
+
+ if( pass == 2 && xref )
+ {
+ /* Put the definition line number in the concordance table. */
+ /* Defined symbols are not counted as references. */
+ xreftab[sym->xref_index] = lineno;
+ /* Put the line number in the concordance table. */
+ xreftab[sym->xref_index + xref_count] = lineno;
+ }
+
+ /* Now set the value and the type. */
+ sym->val = ( type == LABEL) ? val : val & 07777;
+ sym->type = ( pass == 1 ) ? ( type | CONDITION ) : type;
+ return( sym );
+} /* defineSymbol() */
+
+
+/******************************************************************************/
+/* */
+/* Function: lookup */
+/* */
+/* Synopsis: Find a symbol in table. If not in table, enter symbol in */
+/* table as undefined. Return address of symbol in table. */
+/* */
+/******************************************************************************/
+SYM_T *lookup( char *name )
+{
+ int ix; /* Insertion index */
+ int lx; /* Left index */
+ int rx; /* Right index */
+
+ /* First search the permanent symbols. */
+ lx = 0;
+ ix = binarySearch( name, lx, number_of_fixed_symbols );
+
+ /* If symbol not in permanent symbol table. */
+ if( ix < 0 )
+ {
+ /* Now try the user symbol table. */
+ ix = binarySearch( name, number_of_fixed_symbols, symbol_top );
+
+ /* If symbol not in user symbol table. */
+ if( ix < 0 )
+ {
+ /* Must put symbol in table if index is negative. */
+ ix = ~ix;
+ if( symbol_top + 1 >= SYMBOL_TABLE_SIZE )
+ {
+ errorSymbol( &symbol_table_full, name, lexstart );
+ exit( 1 );
+ }
+
+ for( rx = symbol_top; rx >= ix; rx-- )
+ {
+ symtab[rx + 1] = symtab[rx];
+ }
+ symbol_top++;
+
+ /* Enter the symbol as UNDEFINED with a value of zero. */
+ strcpy( symtab[ix].name, name );
+ symtab[ix].type = UNDEFINED;
+ symtab[ix].val = 0;
+ symtab[ix].xref_count = 0;
+ if( xref && pass == 2 )
+ {
+ xreftab[symtab[ix].xref_index] = 0;
+ }
+ }
+ }
+
+ return( &symtab[ix] ); /* Return the location of the symbol. */
+} /* lookup() */
+
+
+/******************************************************************************/
+/* */
+/* Function: binarySearch */
+/* */
+/* Synopsis: Searches the symbol table within the limits given. If the */
+/* symbol is not in the table, it returns the insertion point. */
+/* */
+/******************************************************************************/
+int binarySearch( char *name, int start, int symbol_count )
+{
+ int lx; /* Left index */
+ int mx; /* Middle index */
+ int rx; /* Right index */
+ int compare; /* Results of comparison */
+
+ lx = start;
+ rx = symbol_count - 1;
+ while( lx <= rx )
+ {
+ mx = ( lx + rx ) / 2; /* Find center of search area. */
+
+ compare = strcmp( name, symtab[mx].name );
+
+ if( compare < 0 )
+ {
+ rx = mx - 1;
+ }
+ else if( compare > 0 )
+ {
+ lx = mx + 1;
+ }
+ else
+ {
+ return( mx ); /* Found a match in symbol table. */
+ }
+ } /* end while */
+ return( ~lx ); /* Return insertion point. */
+} /* binarySearch() */
+
+
+/******************************************************************************/
+/* */
+/* Function: compareSymbols */
+/* */
+/* Synopsis: Used to presort the symbol table when starting assembler. */
+/* */
+/******************************************************************************/
+int compareSymbols( const void *a, const void *b )
+{
+ return( strcmp( ((SYM_T *) a)->name, ((SYM_T *) b)->name ));
+} /* compareSymbols() */
+
+
+/******************************************************************************/
+/* */
+/* Function: evalSymbol */
+/* */
+/* Synopsis: Get the pointer for the symbol table entry if exists. */
+/* If symbol doesn't exist, return a pointer to the undefined sym */
+/* */
+/******************************************************************************/
+SYM_T *evalSymbol()
+{
+ char name[SYMLEN];
+ SYM_T *sym;
+
+ sym = lookup( lexemeToName( name, lexstart, lexterm ));
+
+ sym->xref_count++; /* Count the number of references to symbol. */
+
+ if( xref && pass == 2 )
+ {
+ /* Put the line number in the concordance table. */
+ xreftab[sym->xref_index + sym->xref_count] = lineno;
+ }
+
+ return( sym );
+} /* evalSymbol() */
+
+
+/******************************************************************************/
+/* */
+/* Function: moveToEndOfLine */
+/* */
+/* Synopsis: Move the parser input to the end of the current input line. */
+/* */
+/******************************************************************************/
+void moveToEndOfLine()
+{
+ while( !isend( line[cc] )) cc++;
+ lexstart = cc;
+ lexterm = cc;
+ lexstartprev = lexstart;
+} /* moveToEndOfLine() */
+
+/******************************************************************************/
+/* */
+/* Function: nextLexeme */
+/* */
+/* Synopsis: Get the next lexical element from input line. */
+/* */
+/******************************************************************************/
+void nextLexeme()
+{
+ /* Save start column of previous lexeme for diagnostic messages. */
+ lexstartprev = lexstart;
+ lextermprev = lexterm;
+
+ while( is_blank( line[cc] )) { cc++; }
+ lexstart = cc;
+
+ if( isalnum( line[cc] ))
+ {
+ while( isalnum( line[cc] )) { cc++; }
+ }
+ else if( isend( line[cc] ))
+ {
+ /* End-of-Line, don't advance cc! */
+ }
+ else
+ {
+ switch( line[cc] )
+ {
+ case '"': /* Quoted letter */
+ if( cc + 2 < maxcc )
+ {
+ cc++;
+ cc++;
+ }
+ else
+ {
+ errorMessage( &no_literal_value, lexstart );
+ cc++;
+ }
+ break;
+
+ case '/': /* Comment, don't advance cc! */
+ break;
+
+ default: /* All other punctuation. */
+ cc++;
+ break;
+ }
+ }
+ lexterm = cc;
+} /* nextLexeme() */
+
+
+/******************************************************************************/
+/* */
+/* Function: nextLexBlank */
+/* */
+/* Synopsis: Used to prevent illegal blanks in expressions. */
+/* */
+/******************************************************************************/
+void nextLexBlank()
+{
+ nextLexeme();
+ if( is_blank( delimiter ))
+ {
+ errorMessage( &illegal_blank, lexstart - 1 );
+ }
+ delimiter = line[lexterm];
+} /* nextLexBlank() */
+
+
+
+/******************************************************************************/
+/* */
+/* Function: pseudoOperators */
+/* */
+/* Synopsis: Process pseudo-ops (directives). */
+/* */
+/******************************************************************************/
+BOOL pseudoOperators( PSEUDO_T val )
+{
+ int count;
+ int delim;
+ int index;
+ int ix;
+ int lexstartsave;
+ WORD16 newfield;
+ WORD16 oldclc;
+ int pack;
+ BOOL status;
+ SYM_T *sym;
+ FILE *temp;
+ int term;
+ WORD16 value;
+
+ status = TRUE;
+ switch( (PSEUDO_T) val )
+ {
+ case BANK:
+ errorSymbol( &no_pseudo_op, "BANK", lexstartprev );
+ /* should select a different 32K out of 128K */
+ break;
+
+ case BINPUNCH:
+ /* If there has been data output and this is a mode switch, set up to */
+ /* output data in BIN mode. */
+ if( binary_data_output && rim_mode )
+ {
+ cp.loc = 00200; /* Clear the literal tables. */
+ cp.error = FALSE;
+ pz.loc = 00200;
+ pz.error = FALSE;
+ punchLeader( 8 ); /* Generate a short leader/trailer. */
+ checksum = 0;
+ binary_data_output = FALSE;
+ }
+ rim_mode = FALSE;
+ break;
+
+ case DECIMAL:
+ radix = 10;
+ break;
+
+ case DUBL:
+ inputDubl();
+ break;
+
+ case EJECT:
+ page_lineno = LIST_LINES_PER_PAGE; /* This will force a page break. */
+ status = FALSE; /* This will force reading of next line */
+ break;
+
+ case ENPUNCH:
+ if( pass == 2 )
+ {
+ objectfile = objectsave;
+ }
+ break;
+
+ case EXPUNGE: /* Erase symbol table */
+ if( pass == 1 )
+ {
+ symtab[0] = sym_undefined;
+ symbol_top = 0;
+ number_of_fixed_symbols = symbol_top;
+ fixed_symbols = &symtab[symbol_top - 1];
+
+ /* Enter the pseudo-ops into the symbol table. */
+ for( ix = 0; ix < DIM( pseudo ); ix++ )
+ {
+ defineSymbol( pseudo[ix].name, pseudo[ix].val, pseudo[ix].type, 0 );
+ }
+ number_of_fixed_symbols = symbol_top;
+ fixed_symbols = &symtab[symbol_top - 1];
+ }
+ break;
+
+ case FIELD:
+ punchLiteralPool( &cp, clc - 1 );
+ punchLiteralPool( &pz, 0 );
+ newfield = field >> 12;
+ lexstartsave = lexstartprev;
+ if( isdone( line[lexstart] ))
+ {
+ newfield += 1; /* Blank FIELD directive. */
+ }
+ else
+ {
+ newfield = (getExpr())->val; /* FIELD with argument. */
+ }
+
+ if( rim_mode )
+ {
+ errorMessage( &in_rim_mode, lexstartsave ); /* Can't change fields. */
+ }
+ else if( newfield > 7 || newfield < 0 )
+ {
+ errorMessage( &illegal_field_value, lexstartprev );
+ }
+ else
+ {
+ value = (( newfield & 0007 ) << 3 ) | 00300;
+ punchObject( value );
+ checksum -= value; /* Field punches are not added to checksum. */
+ field = newfield << 12;
+ }
+
+ clc = 0200 | field;
+ fieldlc = clc & 07777;
+
+ if( !rim_mode )
+ {
+ punchOrigin( clc );
+ }
+ break;
+
+ case FIXMRI:
+ if( line[lexterm] == '=' && isalpha( line[lexstart] ))
+ {
+ lexstartsave = lexstart;
+ term = lexterm;
+ nextLexeme(); /* Skip symbol. */
+ nextLexeme(); /* Skip trailing = */
+ defineLexeme( lexstartsave, term, getExprs(), MRI );
+ }
+ else
+ {
+ errorLexeme( &symbol_syntax, lexstart );
+ nextLexeme(); /* Skip symbol. */
+ nextLexeme(); /* Skip trailing = */
+ (void) getExprs(); /* Skip expression. */
+ }
+ break;
+
+ case FIXTAB:
+ /* Mark all current symbols as permanent symbols. */
+ for( ix = 0; ix < symbol_top; ix++ )
+ {
+ symtab[ix].type = symtab[ix].type | FIXED;
+ }
+ number_of_fixed_symbols = symbol_top;
+ fixed_symbols = &symtab[symbol_top - 1];
+
+ /* Re-sort the symbol table */
+ qsort( symtab, symbol_top, sizeof(symtab[0]), compareSymbols );
+ break;
+
+ case FLTG:
+ inputFltg();
+ /* errorSymbol( &no_pseudo_op, "FLTG", lexstartprev ); */
+ break;
+
+ case IFDEF:
+ if( isalpha( line[lexstart] ))
+ {
+ sym = evalSymbol();
+ nextLexeme();
+ if( M_DEFINED_CONDITIONALLY( sym->type ))
+ {
+ conditionTrue();
+ }
+ else
+ {
+ conditionFalse();
+ }
+ }
+ else
+ {
+ errorLexeme( &label_syntax, lexstart );
+ }
+ break;
+
+ case IFNDEF:
+ if( isalpha( line[lexstart] ))
+ {
+ sym = evalSymbol();
+ nextLexeme();
+ if( M_DEFINED_CONDITIONALLY( sym->type ))
+ {
+ conditionFalse();
+ }
+ else
+ {
+ conditionTrue();
+ }
+ }
+ else
+ {
+ errorLexeme( &label_syntax, lexstart );
+ }
+ break;
+
+ case IFNZERO:
+ if( (getExpr())->val == 0 )
+ {
+ conditionFalse();
+ }
+ else
+ {
+ conditionTrue();
+ }
+ break;
+
+ case IFZERO:
+ if( (getExpr())->val == 0 )
+ {
+ conditionTrue();
+ }
+ else
+ {
+ conditionFalse();
+ }
+ break;
+
+ case NOPUNCH:
+ if( pass == 2 )
+ {
+ objectfile = NULL;
+ }
+ break;
+
+ case OCTAL:
+ radix = 8;
+ break;
+
+ case PAGE:
+ punchLiteralPool( &cp, clc - 1 );
+ oldclc = clc;
+ if( isdone( line[lexstart] ))
+ {
+ clc = ( clc + 0177 ) & 077600; /* No argumnet. */
+ fieldlc = clc & 07777;
+ }
+ else
+ {
+ value = (getExpr())->val;
+ clc = ( field << 12 ) + (( value & 037 ) << 7 );
+ fieldlc = clc & 07777;
+ }
+ testForLiteralCollision( clc );
+
+ if( !rim_mode && clc != oldclc )
+ {
+ punchOrigin( clc );
+ }
+ break;
+
+ case PAUSE:
+ break;
+
+ case RELOC:
+ if( isdone( line[lexstart] ))
+ {
+ reloc = 0; /* Blank RELOC directive. */
+ }
+ else
+ {
+ value = (getExpr())->val; /* RELOC with argument. */
+ reloc = value - ( clc + reloc );
+ }
+ break;
+
+ case RIMPUNCH:
+ /* If the assembler has output any BIN data, output the literal tables */
+ /* and the checksum for what has been assembled and setup for RIM mode. */
+ if( binary_data_output && !rim_mode )
+ {
+ endOfBinary();
+ punchChecksum();
+ punchLeader( 8 ); /* Generate a short leader/trailer. */
+ }
+ rim_mode = TRUE;
+ break;
+
+ case SEGMNT:
+ punchLiteralPool( &cp, clc - 1 );
+ if( isdone( line[lexstart] ))
+ { /* No argument. */
+ clc = ( clc & 06000 ) + 02000;
+ fieldlc = clc & 07777;
+ }
+ else
+ {
+ getExpr();
+ clc = ( val & 003 ) << 10;
+ fieldlc = clc & 07777;
+ }
+ if( !rim_mode )
+ {
+ punchOrigin( clc );
+ }
+ testForLiteralCollision( clc );
+ break;
+
+ case TEXT:
+ delim = line[lexstart];
+ pack = 0;
+ count = 0;
+ index = lexstart + 1;
+ while( line[index] != delim && !isend( line[index] ))
+ {
+ pack = ( pack << 6 ) | ( line[index] & 077 );
+ count++;
+ if( count > 1 )
+ {
+ punchOutObject( clc, pack );
+ incrementClc();
+ count = 0;
+ pack = 0;
+ }
+ index++;
+ }
+
+ if( count != 0 )
+ {
+ punchOutObject( clc, pack << 6 );
+ incrementClc();
+ }
+ else
+ {
+ punchOutObject( clc, 0 );
+ incrementClc();
+ }
+
+ if( isend( line[index] ))
+ {
+ cc = index;
+ lexterm = cc;
+ errorMessage( &text_string, cc );
+ }
+ else
+ {
+ cc = index + 1;
+ lexterm = cc;
+ }
+ nextLexeme();
+ break;
+
+ case TITLE:
+ delim = line[lexstart];
+ ix = lexstart + 1;
+ /* Find string delimiter. */
+ do
+ {
+ if( list_title[ix] == delim && list_title[ix + 1] == delim )
+ {
+ ix++;
+ }
+ ix++;
+ } while( line[ix] != delim && !isend(line[ix]) );
+
+ if( !isend( line[ix] ) )
+ {
+ count = 0;
+ ix = lexstart + 1;
+ do
+ {
+ if( list_title[ix] == delim && list_title[ix + 1] == delim )
+ {
+ ix++;
+ }
+ list_title[count] = line[ix];
+ count++;
+ ix++;
+ } while( line[ix] != delim && !isend(line[ix]) );
+
+ if( strlen( list_title ) > TITLELEN )
+ {
+ list_title[TITLELEN] = '\0';
+ }
+
+ cc = ix + 1;
+ lexterm = cc;
+ page_lineno = LIST_LINES_PER_PAGE;/* Force top of page for new titles. */
+ list_title_set = TRUE;
+ }
+ else
+ {
+ cc = ix;
+ lexterm = cc;
+ errorMessage( &text_string, cc );
+ }
+
+ nextLexeme();
+ break;
+
+ case XLIST:
+ if( isdone( line[lexstart] ))
+ {
+ temp = listfile; /* Blank XLIST directive. */
+ listfile = listsave;
+ listsave = temp;
+ }
+ else
+ {
+ if( (getExpr())->val == 0 )
+ {
+ if( listfile == NULL )
+ {
+ listfile = listsave;
+ listsave = NULL;
+ }
+ }
+ else
+ {
+ if( listfile != NULL )
+ {
+ listsave = listfile;
+ listfile = NULL;
+ }
+ }
+ }
+ break;
+
+ case ZBLOCK:
+ value = (getExpr())->val;
+ if( value < 0 )
+ {
+ errorMessage( &zblock_too_small, lexstartprev );
+ }
+ else if( value + ( clc & 07777 ) - 1 > 07777 )
+ {
+ errorMessage( &zblock_too_large, lexstartprev );
+ }
+ else
+ {
+ for( ; value > 0; value-- )
+ {
+ punchOutObject( clc, 0 );
+ incrementClc();
+ }
+ }
+
+ break;
+
+ default:
+ break;
+ } /* end switch for pseudo-ops */
+ return( status );
+} /* pseudoOperators() */
+
+
+/******************************************************************************/
+/* */
+/* Function: conditionFalse */
+/* */
+/* Synopsis: Called when a false conditional has been evaluated. */
+/* Lex should be the opening <; ignore all text until */
+/* the closing >. */
+/* */
+/******************************************************************************/
+void conditionFalse()
+{
+ int level;
+
+ if( line[lexstart] == '<' )
+ {
+ /* Invariant: line[cc] is the next unexamined character. */
+ level = 1;
+ while( level > 0 )
+ {
+ if( isend( line[cc] ))
+ {
+ readLine();
+ }
+ else
+ {
+ switch( line[cc] )
+ {
+ case '>':
+ level--;
+ cc++;
+ break;
+
+ case '<':
+ level++;
+ cc++;
+ break;
+
+ case '$':
+ level = 0;
+ cc++;
+ break;
+
+ default:
+ cc++;
+ break;
+ } /* end switch */
+ } /* end if */
+ } /* end while */
+ nextLexeme();
+ }
+ else
+ {
+ errorMessage( <_expected, lexstart );
+ }
+} /* conditionFalse() */
+
+/******************************************************************************/
+/* */
+/* Function: conditionTrue */
+/* */
+/* Synopsis: Called when a true conditional has been evaluated. */
+/* Lex should be the opening <; skip it and setup for */
+/* normal assembly. */
+/* */
+/******************************************************************************/
+void conditionTrue()
+{
+ if( line[lexstart] == '<' )
+ {
+ nextLexeme(); /* Skip the opening '<' */
+ }
+ else
+ {
+ errorMessage( <_expected, lexstart );
+ }
+} /* conditionTrue() */
+
+
+/******************************************************************************/
+/* */
+/* Function: errorLexeme */
+/* */
+/* Synopsis: Display an error message using the current lexical element. */
+/* */
+/******************************************************************************/
+void errorLexeme( EMSG_T *mesg, WORD16 col )
+{
+ char name[SYMLEN];
+
+ errorSymbol( mesg, lexemeToName( name, lexstart, lexterm ), col );
+} /* errorLexeme() */
+
+
+/******************************************************************************/
+/* */
+/* Function: errorSymbol */
+/* */
+/* Synopsis: Display an error message with a given string. */
+/* */
+/******************************************************************************/
+void errorSymbol( EMSG_T *mesg, char *name, WORD16 col )
+{
+ char linecol[12];
+ char *s;
+
+ if( pass == 2 )
+ {
+ s = ( name == NULL ) ? "" : name ;
+ errors++;
+ sprintf( linecol, "(%d:%d)", lineno, col + 1 );
+ fprintf( errorfile, "%s%-9s : error: %s \"%s\" at Loc = %5.5o\n",
+ filename, linecol, mesg->file, s, clc );
+ saveError( mesg->list, col );
+ }
+ error_in_line = TRUE;
+} /* errorSymbol() */
+
+
+/******************************************************************************/
+/* */
+/* Function: errorMessage */
+/* */
+/* Synopsis: Display an error message without a name argument. */
+/* */
+/******************************************************************************/
+void errorMessage( EMSG_T *mesg, WORD16 col )
+{
+ char linecol[12];
+
+ if( pass == 2 )
+ {
+ errors++;
+ sprintf( linecol, "(%d:%d)", lineno, col + 1 );
+ fprintf( errorfile, "%s%-9s : error: %s at Loc = %5.5o\n",
+ filename, linecol, mesg->file, clc );
+ saveError( mesg->list, col );
+ }
+ error_in_line = TRUE;
+} /* errorMessage() */
+
+/******************************************************************************/
+/* */
+/* Function: saveError */
+/* */
+/* Synopsis: Save the current error in a list so it may displayed after the */
+/* the current line is printed. */
+/* */
+/******************************************************************************/
+void saveError( char *mesg, WORD16 col )
+{
+ if( save_error_count < DIM( error_list ))
+ {
+ error_list[save_error_count].mesg = mesg;
+ error_list[save_error_count].col = col;
+ save_error_count++;
+ }
+ error_in_line = TRUE;
+
+ if( listed )
+ {
+ printErrorMessages();
+ }
+} /* saveError() */
+/* End-of-File */
projects / pdp8.git / blobdiff