/*
 * Original source:
 *    https://simh.trailing-edge.com/sources/simtools/crossassemblers/macro1.c
 *   (https://www.masswerk.at/spacewar/sources/macro1.c -- similar to above)
 * Created: 2018-06-01 13:58
 * Assembler Manual: https://www.bitsavers.org/pdf/dec/pdp1/PDP-1_Macro.pdf
 * Fixes/enhancements applied to V3.0 (2003) -- see (MSH) below.
 */

/*
 * $Id: macro1.c,v 1.74 2003/10/23 23:29:17 phil Exp $
 *
 * TODO:
 * have flex() use nextfiodec()?? (what if legal in repeat???)
 * "flex<SP><SP><SP>x" should give right justified result???
 * squawk if nextfiodec called in a repeat w/ a delim?
 *
 * forbid variables/constants in macros
 * forbid text in repeat??
 * forbid start in repeat or macro
 * use same error TLA's as MACRO???
 * IPA error for overbar on LHS of =
 * variables returns value??
 *
 * macro addressing: labels defined during macro are local use only????
 *	spacewar expects this??? (is it wrong?)
 *
 * self-feeding lines: \n legal anywhere \t is (except in 'repeat')
 *	read next token into "token" buffer -- avoid saving "line"?
 *	remove crocks from "define"
 * list title (first line of file) should not be parsed as source!    // DONE
 * incorrect listing for bare "start"       // Also see below
 * list only 4 digits for address column    // MSH2
 *
 * other:
 * note variables in symbol dump, xref?
 * no "permenant" symbols; flush -p? rename .ini?
 * keep seperate macro/pseudo table?
 * verify bad input(?) detected
 * implement dimension pseudo?
 * remove crocks for '/' and ','?
 *
 * (MSH)
 *
 * Add further symbols (e.g. for PDP-1D ... sni, cmi, lai, lia, swp, etc.)?
 * Add further IOT symbols for extended hardware?
 * Enter variables into symbol table as SYMTYP LABEL?
 * Replace exit( x ); with exit( EXIT_FAILURE ); + see return() in main()
 * Should parse first 4 characters of (e)pseudo not 3 ... see lookup() ...
 * ... PROBLEM: jmp dec ... dec, switches to decimal (etc.)
 * Improve listing of '-m' (it's a bit messy)
 * Fix define name // repeat 2, 123<tab>456 // term ...
 * ... \t in a macro is read as \n
 * If the same label is defined twice at the same address: xref should count it
 * ... fred, // fred, only XREFs the first 'fred' not the second
 * Should "start" with no parameter punch the 'jmp' instruction? (start_addr)
 * DIFFERENCE TO MANUAL: Undefined symbols default to -0 (not 0)
 * ALSO: Expressions including a 0 must never result in -0 ... X=0-0 : X is -0
 * NOT CAUGHT: repeat X, 1234 // X=3 (X not defined on pass 1 but IS on pass2)
 * Macros treat TAB like CR (also in commments) ... also after 'repeat' WRONG!
 * Macro invocation: if the macro is not the last thing on the line, boom! ...
 * ... define ABCD // . // terminate // abcd <TAB> abcd / Generates wrong code
 * 123/456 does not store 456 at location 123 (parameter is ignored) ...
 * ... same for 123/ 456 (requires CR or TAB after '/')
 */

/*
 * Program:  MACRO1
 * File:     macro1.c
 * Author:   Gary A. Messenbrink <gary@netcom.com> (macro8)
 *    MACRO7 modifications: Bob Supnik <bob.supnik@ljo.dec.com>
 *    MACRO1 modifications: Bob Supnik <bob.supnik@ljo.dec.com>
 *    slashed to be more like real MACRO like by Phil Budne <phil@ultimate.com>
 *
 * Purpose:  A 2 pass PDP-1 assembler
 *
 * NAME
 *    macro1 - a PDP-1 assembler.
 *
 * SYNOPSIS:
 *    macro1 [ -d -p -m -r -t -q -c -s -x ] inputfile inputfile...  // MSH4,e,h
 *
 * DESCRIPTION
 *    This is a cross-assembler for PDP-1 assembly language programs.
 *    It will produce an output file in rim or bin format.
 *    A listing file is always produced 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
 *    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:
 *	 .mac	 source code (input)
 *	 .lst	 assembly listing (output)
 *	 .rim	 assembly output in DEC's rim/bin format (output)
 *	 .prm	 permanent symbol table in form suitable for reading after
 *		 the 'expunge' pseudo-op.
 *	 .sym	 "symbol punch" tape (for DDT, or reloading into macro)
 *
 * OPTIONS
 *    -d   Dump the symbol table at end of assembly
 *    -p   Generate a file with the permanent symbols in it.
 *	   (To get the current symbol table, assemble a file than has only
 *	    START in it.)
 *    -x   Generate a cross-reference (concordance) of user symbols.
 *    -r   Output a tape using only RIM format (else output block loader)
 *    -t   Suppress page throws in the listing                 // MSH4
 *    -q   Suppress non-generative listing lines               // MSHh
 *    -c   Convert all upper-case symbols to lower-case        // MSHe
 *    -s   Output a symbol dump tape (loader + loader blocks)
 *    -S file
 *	   Read a symbol tape back in
 *
 * DIAGNOSTICS
 *    Assembler error diagnostics are output to stderr and inserted
 *    in the listing file.  Each error line output to stderr has the form
 *
 *	 <filename>:<line>:<col> : error:  <message> at Loc = <loc>
 *
 *    An example error message is:
 *
 *	 bintst.7: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	   DAC	   UNDEF
 *	 UD undefined			   ^
 *	    18 07617 1777	   TAD	I  DUMMY
 *
 *    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.
 *
 * REFERENCES:
 *    This assembler is based on the pal assember by:
 *	 Douglas Jones <jones@cs.uiowa.edu> and
 *	 Rich Coon <coon@convexw.convex.com>
 *
 * 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.
 *    v3.0  14Feb97  RMS  MACRO8X features.
 *    	     8Mar97  RMS  MACRO7 released w/ sim8swre
 *    	    13Mar97  RMS  MACRO1 released w/ lispswre
 *    	    28Nov01  RMS  MACRO1 released w/ simtools
 *    	     5Mar03  DP   MACRO1 released w/ ddt1
 *    	    2003     PLB  major reworking, assembles MACRO, DDT
 *          22Jan25  MSH  Fix VC++ /W4 warnings        (marked with ... (MSH1)
 *          02May25  MSH  Change location from 5 to 4 digits (see TODO) (MSH2)
 *          02May25  MSH  Fix infinite loop with illegal char in 'text' (MSH3)
 *          02May25  MSH  Add -t qualifier to suppress page throws      (MSH4)
 *          04May25  MSH  Fix symbol table losing attributes            (MSH5)
 *          04May25  MSH  Add '=' to symbol table types (like '#')      (MSH6)
 *          04May25  MSH  Add 'sorted numerically' to the symbol table  (MSH7)
 *          05May25  MSH  Xref: catch calloc()==NULL & add '*'=not-ref  (MSH8)
 *          05May25  MSH  Flag source lines which are too long          (MSH9)
 *          05May25  MSH  Fix missing '.' in command-line filename      (MSHa)
 *          05May25  MSH  Throw page after opening further input files  (MSHb)
 *          05May25  MSH  Show location for lines with labels only      (MSHc)
 *          15May25  MSH  Catch repeat with negative (or massive) count (MSHd)
 *          16May25  MSH  Add -c qualifier for case-blind symbols       (MSHe)
 *          16May25  MSH  Wrap location counter changes (x/) to 12 bits (MSHf)
 *          20May25  MSH  List location change on same line             (MSHg)
 *          26May25  MSH  Add -q for suppressing non-generative lines   (MSHh)
 *          18Jun25  MSH  Replace '\0' with '\n' when storing macros    (MSHi)
 *          30Sep25  MSH  Throw a page for each new title (after start) (MSHj)
 *          10Oct25  MSH  Add error messages for fopen() failures       (MSHk)
 */


/* Ignore security warnings in Microsoft VC++ */
#ifdef _MSC_VER                       /* MSH1 */
#define _CRT_SECURE_NO_WARNINGS 1     /* MSH1 */
#endif                                /* MSH1 */


#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>


#define LINELEN              96
#define LIST_LINES_PER_PAGE  60		/* Includes 3 line page header. */
#define NAMELEN             128
#define SYMBOL_COLUMNS        5
#define SYMLEN                7
/*#define SYMSIG	      4		/* EXP: significant chars in a symbol */
#define SYMBOL_TABLE_SIZE  8192
#define MAC_MAX_ARGS         20
#define MAC_MAX_LENGTH     8192
#define MAC_TABLE_LENGTH   1024		/* Must be <= 4096. */

#define MAX_LITERALS	   1000
#define MAX_CONSTANTS	     10		/* max number of "constants" blocks  */

#define XREF_COLUMNS          8

#define ADDRESS_FIELD  0007777
#define INDIRECT_BIT   0010000
#define OP_CODE        0760000

#define CONCISE_LC 072
#define CONCISE_UC 074

/* Macro to get the number of elements in an array. */
#define DIM(a) (sizeof(a)/sizeof(a[0]))

#define ISBLANK(c) ((c==' ') || (c=='\f'))
#define ISEND(c)   ((c=='\0')|| (c=='\n') || (c == '\t'))
#define ISDONE(c)  ((c=='/') || ISEND(c))

#define ISOVERBAR(c) (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_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_PSEUDO(s)	(((s) & PSEUDO) == PSEUDO)
#define M_EPSEUDO(s)	(((s) & EPSEUDO) == EPSEUDO)
#define M_MACRO(s)	(((s) & MACRO) == MACRO)
#define M_NOTRDEF(s)	(((s) & NOTRDEF) != 0)

typedef unsigned char BOOL;
typedef unsigned char BYTE;
typedef          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, LINE_LOC
};
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. */
enum symtyp
{
  UNDEFINED = 0000,
  DEFINED   = 0001,
  FIXED     = 0002,
  LABEL     = 0010    | DEFINED,
  REDEFINED = 0020    | DEFINED,
  DUPLICATE = 0040    | DEFINED,
  PSEUDO    = 0100    | FIXED | DEFINED,
  EPSEUDO   = 0200    | FIXED | DEFINED,
  MACRO     = 0400    | DEFINED,
  DEFFIX    = DEFINED | FIXED,
  NOTRDEF   = (MACRO | PSEUDO | LABEL | FIXED) & ~DEFINED
};
typedef enum symtyp SYMTYP;

enum pseudo_t {
    DECIMAL,
    DEFINE,
    FLEX,
    CONSTANTS,
    OCTAL,
    REPEAT,
    START,
    CHAR,
    VARIABLES,
    TEXT,
    NOINPUT,
    EXPUNGE
};
typedef enum pseudo_t PSEUDO_T;

struct sym_t
{
  SYMTYP  type;
  char    name[SYMLEN];
  WORD32  val;
  WORD32  xref_index;
  WORD32  xref_count;
};
typedef struct sym_t SYM_T;

struct emsg_t
{
  char  *list;
  char  *file;
};
typedef struct emsg_t EMSG_T;

struct errsave_t
{
  char   *mesg;
  WORD32  col;
};
typedef struct errsave_t ERRSAVE_T;

/*----------------------------------------------------------------------------*/

/* Function Prototypes */

int     binarySearch( char *name, int start, int symbol_count );
int     compareSymbols( const void *a, const void *b );
SYM_T  *defineLexeme( WORD32 start, WORD32 term, WORD32 val, SYMTYP type );
SYM_T  *defineSymbol( char *name, WORD32 val, SYMTYP type, WORD32 start);
void    errorLexeme( EMSG_T *mesg, WORD32 col );
void    errorMessage( EMSG_T *mesg, WORD32 col );
void    errorSymbol( EMSG_T *mesg, char *name, WORD32 col );
SYM_T   eval( void );
SYM_T  *evalSymbol( void );
void    getArgs( int argc, char *argv[] );
SYM_T   getExpr( void );
WORD32  getExprs( void );
WORD32  incrementClc( void );
WORD32  literal( WORD32 value );
BOOL    isLexSymbol();
char   *lexemeToName( char *name, WORD32 from, WORD32 term );
void    listLine( void );
SYM_T  *lookup( char *name, int type );
void    moveToEndOfLine( void );
void    next(int);
void    onePass( void );
void    printCrossReference( void );
void    printErrorMessages( void );
void    printLine(char *line, WORD32 loc, WORD32 val, LINESTYLE_T linestyle);
void    printPageBreak( void );
void    printPermanentSymbolTable( void );
void    printSymbolTable( void );
BOOL    pseudo( PSEUDO_T val );
void    punchLocObject( WORD32 loc, WORD32 val );
void    punchOutObject( WORD32 loc, WORD32 val );
void    punchLeader( WORD32 count );
void    punchLoader( void );
void    flushLoader( void );
void    readLine( void );
void    saveError( char *mesg, WORD32 cc );
void    topOfForm( char *title, char *sub_title );
void	constants(void);
void	variables(void);
void	eob(void);
void	dump_symbols(void);

/*----------------------------------------------------------------------------*/

/* Table of pseudo-ops (directives) which are used to setup the symbol */
/* table on startup */
SYM_T pseudos[] =
{
  { PSEUDO,  "consta",	CONSTANTS },
  { PSEUDO,  "define",	DEFINE  },	/* Define macro. */
  { PSEUDO,  "repeat",	REPEAT  },
  { PSEUDO,  "start",	START   },	/* Set starting address. */
  { PSEUDO,  "variab",	VARIABLES },
  { PSEUDO,  "text",	TEXT	},
  { PSEUDO,  "noinpu",	NOINPUT	},
  { PSEUDO,  "expung",	EXPUNGE	},
/* the following can appear in expressions: */
  { EPSEUDO, "charac",	CHAR    },
  { EPSEUDO, "decima",	DECIMAL },	/* base 10. */
  { EPSEUDO, "flexo",	FLEX    },
  { EPSEUDO, "octal",	OCTAL   },	/* Read literal constants in base 8. */
};

/* Symbol Table */
/* The table is put in lexical order on startup, so symbols can be */
/* inserted as desired into the initial table. */
#define DIO 0320000
#define JMP 0600000
SYM_T permanent_symbols[] =
{
  /* Memory Reference Instructions */
  { DEFFIX, "i",      0010000 },
  { DEFFIX, "and",    0020000 },
  { DEFFIX, "ior",    0040000 },
  { DEFFIX, "xor",    0060000 },
  { DEFFIX, "xct",    0100000 },
/*{ DEFFIX, "jfd",    0120000 },*/
  { DEFFIX, "cal",    0160000 },
  { DEFFIX, "jda",    0170000 },
  { DEFFIX, "lac",    0200000 },
  { DEFFIX, "lio",    0220000 },
  { DEFFIX, "dac",    0240000 },
  { DEFFIX, "dap",    0260000 },
  { DEFFIX, "dip",    0300000 },
  { DEFFIX, "dio",    0320000 },
  { DEFFIX, "dzm",    0340000 },
  { DEFFIX, "add",    0400000 },
  { DEFFIX, "sub",    0420000 },
  { DEFFIX, "idx",    0440000 },
  { DEFFIX, "isp",    0460000 },
  { DEFFIX, "sad",    0500000 },
  { DEFFIX, "sas",    0520000 },
  { DEFFIX, "mul",    0540000 },
  { DEFFIX, "mus",    0540000 },	/* for spacewar */
  { DEFFIX, "div",    0560000 },
  { DEFFIX, "dis",    0560000 },	/* for spacewar */
  { DEFFIX, "jmp",    0600000 },
  { DEFFIX, "jsp",    0620000 },
  { DEFFIX, "skip",   0640000 },	/* for spacewar */
  { DEFFIX, "skp",    0640000 },
  { DEFFIX, "law",    0700000 },
  { DEFFIX, "iot",    0720000 },
  { DEFFIX, "opr",    0760000 },
  { DEFFIX, "nop",    0760000 },
  /* Shift Instructions */
  { DEFFIX, "ral",    0661000 },
  { DEFFIX, "ril",    0662000 },
  { DEFFIX, "rcl",    0663000 },
  { DEFFIX, "sal",    0665000 },
  { DEFFIX, "sil",    0666000 },
  { DEFFIX, "scl",    0667000 },
  { DEFFIX, "rar",    0671000 },
  { DEFFIX, "rir",    0672000 },
  { DEFFIX, "rcr",    0673000 },
  { DEFFIX, "sar",    0675000 },
  { DEFFIX, "sir",    0676000 },
  { DEFFIX, "scr",    0677000 },
  { DEFFIX, "1s",     0000001 },
  { DEFFIX, "2s",     0000003 },
  { DEFFIX, "3s",     0000007 },
  { DEFFIX, "4s",     0000017 },
  { DEFFIX, "5s",     0000037 },
  { DEFFIX, "6s",     0000077 },
  { DEFFIX, "7s",     0000177 },
  { DEFFIX, "8s",     0000377 },
  { DEFFIX, "9s",     0000777 },
  /* Skip Microinstructions */
  { DEFFIX, "sza",    0640100 },
  { DEFFIX, "spa",    0640200 },
  { DEFFIX, "sma",    0640400 },
/*{ DEFFIX, "szm",    0640500 },*/
  { DEFFIX, "szo",    0641000 },
  { DEFFIX, "spi",    0642000 },
  { DEFFIX, "szs",    0640000 },
  { DEFFIX, "szf",    0640000 },
/*{ DEFFIX, "spq",    0650500 },*/
/*{ DEFFIX, "clo",    0651600 },*/

  /* Operate Microinstructions */
  { DEFFIX, "clf",    0760000 },
  { DEFFIX, "stf",    0760010 },
  { DEFFIX, "cla",    0760200 },
/*{ DEFFIX, "lap",    0760300 },*/
  { DEFFIX, "hlt",    0760400 },
  { DEFFIX, "xx",     0760400 },
  { DEFFIX, "cma",    0761000 },
  { DEFFIX, "clc",    0761200 },
  { DEFFIX, "lat",    0762200 },
  { DEFFIX, "cli",    0764000 },
  /* IOT's */
/*{ DEFFIX, "ioh",    0730000 },*/
  { DEFFIX, "rpa",    0730001 },
  { DEFFIX, "rpb",    0730002 },
  { DEFFIX, "rrb",    0720030 },
  { DEFFIX, "ppa",    0730005 },
  { DEFFIX, "ppb",    0730006 },
  { DEFFIX, "tyo",    0730003 },
  { DEFFIX, "tyi",    0720004 },
  { DEFFIX, "dpy",    0730007 },	/* for spacewar, munching squares! */
  { DEFFIX, "lsm",    0720054 },
  { DEFFIX, "esm",    0720055 },
  { DEFFIX, "cbs",    0720056 },
  { DEFFIX, "lem",    0720074 },
/*{ DEFFIX, "cfd",    0720074 },*/
/*{ DEFFIX, "cdf",    0720075 },*/
  { DEFFIX, "eem",    0724074 },
  { DEFFIX, "cks",    0720033 },
};					/* End-of-Symbols for Permanent Symbol Table */

/* Global variables */
SYM_T *symtab;				/* Symbol Table */
int    symbol_top;			/* Number of entries in symbol table. */

#define LOADERBASE 07751

/* make it relocatable (DDT expects it at 7751) */
#define LOADER_IN LOADERBASE
#define LOADER_B (LOADERBASE+06)
#define LOADER_A (LOADERBASE+07)
#define LOADER_CK (LOADERBASE+025)
#define LOADER_EN1 (LOADERBASE+026)

WORD32 loader[] = {
    0730002,				/* in,	rpb */
    0320000+LOADER_A,			/* 	dio a */
    0100000+LOADER_A,			/* 	xct a */
    0320000+LOADER_CK,			/* 	dio ck */
    0730002,				/* 	rpb */
    0320000+LOADER_EN1,			/* 	dio en1 */
    0730002,				/* b,	rpb */
    0000000,				/* a,	xx */
    0210000+LOADER_A,			/* 	lac i a */
    0400000+LOADER_CK,			/* 	add ck */
    0240000+LOADER_CK,			/* 	dac ck */
    0440000+LOADER_A,			/* 	idx a */
    0520000+LOADER_EN1,			/* 	sas en1 */
    0600000+LOADER_B,			/* 	jmp b */
    0200000+LOADER_CK,			/* 	lac ck */
    0400000+LOADER_EN1,			/* 	add en1 */
    0730002,				/* 	rpb */
    0320000+LOADER_CK,			/* 	dio ck */
    0520000+LOADER_CK,			/* 	sas ck */
    0760400,				/*	hlt */
    0600000+LOADER_IN			/* 	jmp in */
					/* ck,  0 */
					/* en1, 0 */
};

#define LOADERBUFSIZE 0100		/* <=0100, power of 2*/
#define LOADERBUFMASK (LOADERBUFSIZE-1)	/* for block alignment */

WORD32 loaderbuf[LOADERBUFSIZE];
WORD32 loaderbufcount;
WORD32 loaderbufstart;

/*----------------------------------------------------------------------------*/

WORD32 *xreftab;			/* Start of the concordance table. */

ERRSAVE_T error_list[20];
int     save_error_count;

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) */
/*      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) */
/*	VR  Value Required */
/*      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  misplaced_symbol    = { "misplaced symbol", "misplaced symbol" };
EMSG_T  redefined_symbol    = { "RD redefined",  "redefined symbol" };
EMSG_T  value_required      = { "VR value required",  "value required" };
EMSG_T  literal_gen_off     = { "lit generation off",
                                   "literal generation disabled" };
EMSG_T  literal_overflow    = { "PE page exceeded",
                                   "current page literal capacity exceeded" };
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  no_pseudo_op        = { "not implemented", "Unimplemented pseudo-op" };
EMSG_T  illegal_vfd_value   = { "width out of range",
                                   "VFD field width not in range" };
EMSG_T  no_literal_value    = { "no value",  "No literal value" };
EMSG_T  text_string         = { "no delimiter",
                                    "Text string delimiters not matched" };
EMSG_T  lt_expected         = { "'<' expected",  "'<' expected" };
EMSG_T  symbol_table_full   = { "ST Symbol Tbl full", "Symbol table full" };
EMSG_T  no_macro_name       = { "no macro name", "No name following DEFINE" };
EMSG_T  bad_dummy_arg       = { "bad dummy arg",
                                    "Bad dummy argument following DEFINE" };
EMSG_T  macro_too_long      = { "macro too long", "Macro too long" };
EMSG_T  no_virtual_memory   = { "out of memory",
                                    "Insufficient memory for macro" };
EMSG_T  macro_table_full    = { "Macro Table full", "Macro table full" };
EMSG_T  define_in_repeat    = { "define in a repeat", "Define in a repeat" };
EMSG_T  line_too_long       = { "LL line length",
                                    "Source line too long" };    /* MSH9 */
EMSG_T  repeat_negative     = { "bad repeat count",
                                    "Repeat count invalid" };    /* MSHd */

/*----------------------------------------------------------------------------*/

FILE   *errorfile;
FILE   *infile;
FILE   *listfile;
FILE   *listsave;
FILE   *objectfile;
FILE   *objectsave;

char    filename[NAMELEN];
char    listpathname[NAMELEN];
char    sympathname[NAMELEN];
char    objectpathname[NAMELEN];
char   *pathname;
char    permpathname[NAMELEN];

WORD32  mac_count;			/* Total macros defined. */

/*
 * malloced macro bodies, indexed by sym->val dummies are evaluated at
 * invocation time, and value saved in "args"; if recursive macros are
 * desired (without conditionals, how would you escape?), keep a name
 * list here and move symbols to "macinv"
 */
struct macdef {
    int nargs;				/* number of args */
    SYM_T args[MAC_MAX_ARGS+1];		/* symbol for each and one for "r" */
    char body[1];			/* malloc'ed accordingly */
} *mac_defs[MAC_TABLE_LENGTH];

struct macinv {				/* current macro invocation */
    char    mac_line[LINELEN];		/* Saved macro invocation line. */
    WORD32  mac_cc;			/* Saved cc after macro invocation. */
    char   *mac_ptr;			/* Pointer to macro body, NULL if no macro. */
    struct macdef *defn;		/* pointer to definition for dummies */
    struct macinv *prev;		/* previous invocation in stack */
} *curmacro;				/* macro stack */

int	nrepeats;			/* count of nested repeats */

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. */
int     list_lines_per_page =		
        LIST_LINES_PER_PAGE; /* MSH4 */ /* Number of page lines before throw */
BOOL    list_loc_show;       /* MSHc */ /* Show location on line */
BOOL    case_blind = FALSE;  /* MSHe */ /* Convert all symbols to lower-case */
BOOL    quiet_list = FALSE;  /* MSHh */ /* Suppress non-generative lst lines */
WORD32  listed;				/* Listed flag. */
/* WORD32  listedsave; */		/* UNUSED */

WORD32  cc;				/* Column Counter (char position in line). */
WORD32  clc;				/* Location counter */
BOOL    end_of_input;			/* End of all input files. */
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. */
int     filix_curr;			/* Index in argv to current input file. */
int     filix_start;			/* Start of input files in argv. */
int	lexstartprev;			/* Where previous lexeme started. */
int	lextermprev;			/* Where previous lexeme ended. */
int	lexstart;			/* Index of current lexeme on line. */
int	lexterm;			/* Index of character after current lexeme. */
int	overbar;			/* next saw an overbar in last token */

int	nconst;				/* number of "constants" blocks */
int	lit_count[MAX_CONSTANTS];	/* # of lits in each block in pass 1 */
WORD32  lit_loc[MAX_CONSTANTS];		/* Base of literal blocks */

int	noinput;			/* don't punch loader */

int	nvars;				/* number of variables */
WORD32	vars_addr;			/* address of "variables" */
WORD32	vars_end;			/* end of "variables" */

/* pass 2 only; */
int	nlit;				/* number of literals in litter[] */
WORD32	litter[MAX_LITERALS];		/* literals */

WORD32  maxcc;				/* Current line length. */
BOOL    nomac_exp;			/* No macro expansion */
WORD32  pass;				/* Number of current pass. */
BOOL    print_permanent_symbols;
WORD32  radix;				/* Default number radix. */
BOOL    rim_mode;			/* RIM mode output. */
BOOL    sym_dump;			/* punch symbol tape */
int     save_argc;			/* Saved argc. */
char   **save_argv;			/* Saved *argv[]. */
WORD32  start_addr;			/* Saved start address. */
BOOL    symtab_print;			/* Print symbol table flag */
BOOL    xref;                           /* Print cross-reference flag */

SYM_T   sym_undefined = { UNDEFINED, "", 0 };/* Symbol Table Terminator */

/* initial data from SIMH v3.0 pdp1_stddev.c (different encoding of UC/LC) */
#define UC 0100				/* Upper case */
#define LC 0200
#define CHARBITS 077
#define BC LC|UC			/* both case bits */
#define BAD 014				/* unused concise code */

unsigned char ascii_to_fiodec[128] = {
	BAD,	BAD,	BAD,	BAD,	BAD,	BAD,	BAD,	BAD,
	BC|075,	BC|036,	BAD,	BAD,	BAD,	BC|077,	BAD,	BAD,
	BAD,	BAD,	BAD,	BAD,	BAD,	BAD,	BAD,	BAD,
	BAD,	BAD,	BAD,	BAD,	BAD,	BAD,	BAD,	BAD,
	BC|000,	UC|005,	UC|001,	UC|004,	BAD,	BAD,	UC|006,	UC|002,
	LC|057,	LC|055,	UC|073,	UC|054,	LC|033,	LC|054,	LC|073,	LC|021,
	LC|020,	LC|001,	LC|002,	LC|003,	LC|004,	LC|005,	LC|006,	LC|007,
	LC|010,	LC|011,	BAD,	BAD,	UC|007,	UC|033,	UC|010,	UC|021,
	LC|040,	UC|061,	UC|062,	UC|063,	UC|064,	UC|065,	UC|066,	UC|067,
	UC|070,	UC|071,	UC|041,	UC|042,	UC|043,	UC|044,	UC|045,	UC|046,
	UC|047,	UC|050,	UC|051,	UC|022,	UC|023,	UC|024,	UC|025,	UC|026,
	UC|027,	UC|030,	UC|031,	UC|057,	LC|056,	UC|055,	UC|011,	UC|040,
	UC|020,	LC|061,	LC|062,	LC|063,	LC|064,	LC|065,	LC|066,	LC|067,
	LC|070,	LC|071,	LC|041,	LC|042,	LC|043,	LC|044,	LC|045,	LC|046,
	LC|047,	LC|050,	LC|051,	LC|022,	LC|023,	LC|024,	LC|025,	LC|026,
	LC|027,	LC|030,	LC|031,	BAD,	UC|056,	BAD,	UC|003,	BC|075
};

/* for symbol punch tape conversion only!! */
char fiodec_to_ascii[64] = {
	0, '1', '2', '3', '4', '5', '6', '7',
	'8', '9', 0, 0, 0, 0, 0, 0,
	'0', 0, 's', 't', 'u', 'v', 'w', 'x',
	'y', 'z', 0, 0, 0, 0, 0, 0,
	0, 'j', 'k', 'l', 'm', 'n', 'o', 'p',
	'q', 'r', 0, 0, 0, 0, 0, 0,
	0, 'a', 'b', 'c', 'd', 'e', 'f', 'g',
	'h', 'i', 0, 0, 0, 0, 0, 0 };

/* used at startup & for expunge */
void
init_symtab(void) {
    /* Place end marker in symbol table. */
    symtab[0] = sym_undefined;
    symbol_top = 0;
}

/*  Function:  main */
/*  Synopsis:  Starting point.  Controls order of assembly. */
int
main( int argc, char *argv[] )
{
    int     ix;
    int     space;

    save_argc = argc;
    save_argv = argv;

    /* Set the default values for global symbols. */
    print_permanent_symbols = FALSE;
    nomac_exp = TRUE;
    rim_mode = FALSE;			/* default to loader tapes */
    sym_dump = FALSE;
    noinput = FALSE;

    symtab_print = FALSE;
    xref = FALSE;
    pathname = NULL;

    /* init symbol table before processing arguments, so we can
     * load symbol punch tapes on the fly
     */

    /*
     * Setup the error file in case symbol table overflows while
     * installing the permanent symbols.
     */
    errorfile = stderr;
    pass = 0;				/* required for symbol table init */
    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 );
    }

    init_symtab();

    /* Enter the pseudo-ops into the symbol table */
    for( ix = 0; ix < DIM( pseudos ); ix++ )
	defineSymbol( pseudos[ix].name, pseudos[ix].val, pseudos[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, 0 );

    /* Get the options and pathnames */
    getArgs( argc, argv );

    /* Do pass one of the assembly */
    pass = 1;
    onePass();
    errors_pass_1 = errors;

    /* Set up for pass two */
    objectfile = fopen( objectpathname, "wb" );
    objectsave = objectfile;

    if (!objectfile) {               /* MSHk */
        perror( objectpathname );    /* MSHk */
        exit ( -1 );                 /* MSHk */
    }                                /* MSHk */

    listfile = fopen( listpathname, "w" );
    listsave = listfile;

    if (!listfile) {                 /* MSHk */
        perror( listpathname );      /* MSHk */
        exit ( -1 );                 /* MSHk */
    }                                /* MSHk */

    /* XXX punch title into tape! */
    punchLeader( 0 );
    if (!rim_mode) {
	punchLoader();
	punchLeader(5);
    }

    if (nlit > 0)
	constants();			/* implied "constants"? */

    /* 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 & clear the necessary space. */
	xreftab = (WORD32 *) calloc( space, sizeof( WORD32 ));
        if (xreftab == NULL) xref = FALSE;    /* MSH8 */
    }
    pass = 2;
    onePass();

    objectfile = objectsave;

    /* Works great for trailer. */
    punchLeader( 1 );

    /* undo effects of NOLIST for any following output to listing file. */
    listfile = listsave;

    /* Display value of error counter. */
    if( errors == 0 ) {
	fprintf( listfile, "\n      %s %s %s\n", s_no, s_errors, s_detected );
    }
    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 ));
    }

    if( symtab_print )
	printSymbolTable();

    if( print_permanent_symbols )
	printPermanentSymbolTable();

    if( xref )
	printCrossReference();

    fclose( objectfile );
    fclose( listfile );
    if( errors == 0 && errors_pass_1 == 0 ) {
	/* after closing objectfile -- we reuse the FILE *!! */
	if (sym_dump)
	    dump_symbols();
    }
    else
	remove( objectpathname );

    return( errors != 0 );
} /* main() */

/* read a word from a binary punch file */
WORD32
getW(FILE *f)  /* MSH1 */
{
    int i, c;
    WORD32 w;

    w = 0;
    for (i = 0; i < 3;) {
	c = getc(f);
	if (c == -1)
	    return -1;
	if (c & 0200) {			/* ignore if ch8 not punched */
	    w <<= 6;
	    w |= c & 077;
	    i++;
	}
    }
    return w;
}

/*
 * "permute zone bits" like MACRO does for proper sorting
 * (see routine "per" in MACRO) -- it's what DDT expects
 *
 * it's it's own inverse!
 */

WORD32
permute(WORD32 name)
{
    WORD32 temp;

    temp = name & 0202020;		/* get zone bits */
    temp = ((temp << 1) & 0777777) | ((temp >> 17) & 1); /* rotate left */
    name ^= temp;			/* flip zone bits */
    name ^= 0400000;			/* toggle sign */
    return name;
}

/* add a symbol from a "symbol punch" tape */
void
addsym(WORD32 sym, WORD32 val)
{
    char name[4];

    sym = permute(sym);
    name[0] = fiodec_to_ascii[(sym >>12) & 077];
    name[1] = fiodec_to_ascii[(sym >> 6) & 077];
    name[2] = fiodec_to_ascii[sym & 077];
    name[3] = '\0';
    defineSymbol( name, val, LABEL, 0);
}

void
read_symbols(char *fname)
{
    FILE *f;

    f = fopen(fname, "rb");
    if (!f) {
	perror(fname);
	exit(1);
    }

    /* skip loader */
    for (;;) {
	WORD32 w;

	w = getW(f);  /* MSH1 */
	if (w == -1)
	    goto err;			/* XXX complain? */
	if ((w & OP_CODE) == JMP)
	    break;
	if ((w & OP_CODE) != DIO)
	    goto err;			/* XXX complain? */
	w = getW(f);  /* MSH1 */
	if (w == -1)
	    goto err;			/* XXX complain? */
    }


    /* XXX should push block reader down into a co-routine */
    for (;;) {
	WORD32 start, end, sum;

	start = getW(f);  /* MSH1 */
	if ((start & OP_CODE) == JMP) {
	    fclose(f);
	    return;
	}

	if (start == -1 || (start & OP_CODE) != DIO)
	    goto err;

	end = getW(f);  /* MSH1 */
	if (end == -1 || (end & OP_CODE) != DIO)
	    goto err;			/* XXX complain? */

	sum = start + end;
	while (start < end) {
	    WORD32 sym, val;
	    sym = getW(f);  /* MSH1 */
	    if (sym == -1)
		goto err;
	    sum += sym;
	    start++;
	    /* XXX handle block boundaries? */
	    if (start >= end)
		goto err;
	    val = getW(f);  /* MSH1 */
	    if (val == -1)
		goto err;
	    /*printf("%06o %06o\n", sym, val);*/
	    addsym(sym, val);
	    sum += val;
	    start++;
	}
	start = getW(f);	/* eat checksum XXX verify? */    /* MSH1 */
	if (start == -1)
	    goto err;
	/* roll over all the overflows at once */
	if (sum & ~0777777) {
	    sum = (sum & 0777777) + (sum >> 18);
	    if (sum & 01000000)			/* one more time */
		sum++;
	}
	if (start != sum)
	    goto err;
    }
err:
    fprintf(stderr, "error reading symbol file %s\n", fname);
    exit(1);
}

/*  Function:  getArgs */
/*  Synopsis:  Parse command line, set flags accordingly and setup input and */
/*             output files. */
void getArgs( int argc, char *argv[] )
{
  WORD32  len;
  WORD32  ix, jx;

  /* Set the defaults */
  infile = NULL;
  listfile = NULL;
  listsave = NULL;
  objectfile = NULL;
  objectsave = NULL;

  for( ix = 1; ix < argc; )
  {
    if( argv[ix][0] == '-' )
    {
      char *switches = argv[ix++];
      for( jx = 1; switches[jx] != 0; jx++ )
      {
        switch( switches[jx] )
        {
        case 'd':
          symtab_print = TRUE;
          break;

        case 'r':
          rim_mode = TRUE;		/* punch pure rim-mode tapes */
          break;

        case 't':                         /* MSH4 */
          list_lines_per_page = 99999;    /* MSH4 */
          break;                          /* MSH4 */

        case 'q':                         /* MSHh */
          quiet_list = TRUE;              /* MSHh */
          break;                          /* MSHh */

        case 'c':                         /* MSHe */
          case_blind = TRUE;              /* MSHe */
          break;                          /* MSHe */

	case 's':
	  sym_dump = TRUE;
	  break;

        case 'm':
          nomac_exp = FALSE;
          break;

        case 'p':
          print_permanent_symbols = TRUE;
          break;

        case 'x':
          xref = TRUE;
          break;

	case 'S':
	  if (ix <= argc)
	      read_symbols(argv[ix++]);
	  break;

        default:
          fprintf( stderr, "%s: unknown flag: -%c\n", argv[0],
                                                   switches[jx] );   /* MSHe */
          fprintf( stderr, " -d -- dump symbol table\n" );
          fprintf( stderr, " -m -- output macro expansions\n" );
          fprintf( stderr, " -p -- output permanent symbols to file\n" );
          fprintf( stderr, " -r -- output RIM format file\n" );
          fprintf( stderr,
              " -t -- suppress page throws in the listing\n" );      /* MSH4 */
          fprintf( stderr,
              " -q -- suppress non-generative listing lines\n" );    /* MSHh */
          fprintf( stderr, " -c -- convert syms to lower-case\n" );  /* MSHe */
          fprintf( stderr, " -s -- output symbol punch tape to file\n" );
          fprintf( stderr, " -S file -- read symbol punch tape\n" );
	  fprintf( stderr, " -x -- output cross reference to file\n" );
          fflush( stderr );
          exit( -1 );
        } /* end switch */
      } /* end for */
    }
    else
    {
      filix_start = ix;
      pathname = argv[ix];
      break;
    }
  } /* 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 make the pathnames */
  /* Find last '.', if it exists. */
  jx = len - 1;
  while( pathname[jx] != '.'  && pathname[jx] != '/'
      && pathname[jx] != '\\' && jx > 0 )    /* MSHa */
  {
    jx--;
  }

#if 0    /* MSHa */
  switch( pathname[jx] )
  {
  case '.':
    break;

  case '/':
  case '\\':
    jx = len;
    break;

  default:
    break;
  }
#endif     /* MSHa */

  if (pathname[jx] != '.') jx = len;     /* MSHa */

  /* Add the pathname extensions. */
  strncpy( objectpathname, pathname, jx );
  objectpathname[jx] = '\0';
  strcat( objectpathname, ".rim");

  strncpy( listpathname, pathname, jx );
  listpathname[jx] = '\0';
  strcat( listpathname, ".lst" );

  strncpy( permpathname, pathname, jx );
  permpathname[jx] = '\0';
  strcat( permpathname, ".prm" );

  strncpy( sympathname, pathname, jx );
  sympathname[jx] = '\0';
  strcat( sympathname, ".sym" );

  /* 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() */


int
invokeMacro(int index)
{
    struct macinv *mip;
    struct macdef *mdp;
    int jx;

    mdp = mac_defs[index];
    if (mdp == NULL || mdp->body[0] == '\0')
	return 0;

    /* Find arguments. */
    while (ISBLANK(line[lexstart]))
	next(0);

    mip = calloc(1, sizeof(struct macinv));
    if (!mip) {
	fprintf(stderr, "could not allocate memory for macro invocation\n");
	exit(1);
    }
    mip->defn = mdp;

    /* evaluate args, saving values in SYM_T entries in defn.
     * (cannot have recursive macros)
     */
    mdp->args[0].val = clc;		/* r is location at start */
    for( jx = 1; !ISDONE(line[lexstart]) && jx <= MAC_MAX_ARGS; ) {
	WORD32 val;

	next(0);
	if (ISDONE(line[lexstart]))
	    break;

	if (line[lexstart] == ',')
	    next(0);

	while( ISBLANK( line[lexstart] ))
	    next(0);

	if (ISDONE(line[lexstart]))
	    break;

	val = getExprs();

	/* ignore excess values silently? */
	if (jx <= mdp->nargs)
	    mdp->args[jx].val = val;
	jx++;
    } /* end for */

    /* XXX complain if too few actuals? -- nah */
    while (jx <= mdp->nargs)
	mdp->args[jx++].val = 0;

    strcpy(mip->mac_line, line);	/* save line */
    mip->mac_cc = cc;			/* save position in line */
    mip->mac_ptr = mdp->body;
    mip->prev = curmacro;		/* push the old entry */
    curmacro = mip;			/* step up to the plate! */
    return 1;
}

/* process input; used by onePass and repeat */
void
processLine() {
    if (!list_title_set) {
	char *cp;

	/* assert(sizeof(title) >= sizeof(line)); */
	strcpy(list_title, line);

	cp = strchr(list_title, '\n');  /* MSH1 */
	if (cp)                         /* MSH1 */
	    *cp = '\0';

	if (list_title[0]) {
	    list_title_set = TRUE;
	    fprintf(stderr, "%s - pass %d\n", list_title, pass );
	    /* XXX punch title into tape  banner (until an '@' seen) */
            page_lineno = list_lines_per_page;    /* Force a page throw */ /* MSHj */
	}
	return;
    }

    for (;;) {
	int jx;
	SYM_T evalue;

	next(0);
	if( end_of_input )
	    return;

	if( ISEND( line[lexstart] )) {
	    if (line[lexstart] != '\t')
		return;
	    continue;
	}
	if (line[lexstart] == '/')	/* comment? */
	    return;			/* done */

	/* look ahead for 'exp/' */
	/* skip until whitespace or terminator */
	for( jx = lexstart; jx < maxcc; jx++ )
	    if( ISBLANK(line[jx]) || ISDONE(line[jx]))
		break;
	if( line[jx] == '/') {		/* EXP/ set location */
	    WORD32  newclc;

	    newclc = getExprs();
            newclc &= ADDRESS_FIELD;    /* Silenty wrap */    /* MSHf */

	    /* Do not change Current Location Counter if an error occurred. */
	    if( !error_in_line )
		clc = newclc;

	/* printLine( line, newclc, 0, LINE_LOC ); */                 /* MSHg */
            /* We only list the last empty location change/line  */   /* MSHg */
            /* If the line has data and ends with a location ... */   /* MSHg */
            /* ... change, the new location lists on the ...     */   /* MSHg */
            /* ... following line                                */   /* MSHg */
            list_loc_show = TRUE;         /* List location */         /* MSHg */

	    cc = jx + 1;
	    next(0);			/* discard slash */
	    continue;
	}

	switch( line[lexterm] ) {
	case ',':
	    if( isLexSymbol()) {
		WORD32 val;
		SYM_T *sym;
		char name[SYMLEN];

		/* Use lookup so symbol will not be counted as reference. */
		sym = lookup(lexemeToName(name, lexstart, lexterm), UNDEFINED);

		if (curmacro) {
		    /* relative during macro expansion!! */
		    val = clc - curmacro->defn->args[0].val;
		}
		else
		    val = clc;

		if( M_DEFINED( sym->type )) {
		    if( sym->val != val && pass == 2 )
			errorSymbol( &duplicate_label, sym->name, lexstart );
		    sym->type |= DUPLICATE;	/* XXX never used! */
		}
		/* Must call define on pass 2 to generate concordance. */
		defineLexeme( lexstart, lexterm, val, LABEL );
	    }
	    else if (isdigit(line[lexstart])) {	/* constant, */
		int i;
		WORD32 val = 0;

		for( i = lexstart; i < lexterm; i++ ) {
		    if( isdigit( line[i] )) {
			int digit;
			digit = line[i] - '0';
			if( digit >= radix ) {
			    errorLexeme( &number_not_radix, i );
			    val = 0;
			    break;
			}
			val = val * radix + digit;
		    }
		    else {
			errorLexeme( &not_a_number, lexstart );
			val = 0;
			break;
		    }
		}
		if (i == lexterm) {
		    if( clc != val && pass == 2 )
			errorLexeme( &duplicate_label, lexstart); /* XXX */
		}
	    }
	    else
		errorLexeme( &label_syntax, lexstart );
	    next(0);			/* skip comma */
            list_loc_show = TRUE;       /* List location */    /* MSHc */
	    continue;

	case '=':
	    if( isLexSymbol()) {
		WORD32 start, term, val;

		start = lexstart;
		term = lexterm;
		next(0);		/* skip symbol */
		next(0);		/* skip trailing = */
		val = getExprs();
		defineLexeme( start, term, val, DEFINED );
		printLine( line, 0, val, LINE_VAL );
	    }
	    else {
		errorLexeme( &symbol_syntax, lexstartprev );
		next(0);		/* skip symbol */
		next(0);		/* skip trailing = */
		getExprs();		/* skip expression */
	    }
	    continue;
	} /* switch on terminator */

	if( isLexSymbol()) {
	    SYM_T  *sym;
	    WORD32  val;

	    sym = evalSymbol();
	    val = sym->val;
	    if( M_MACRO(sym->type)) {
		if (!invokeMacro(val))
		    next(0);		/* bad defn? or body is empty! */
		continue;
	    } /* macro invocation */
	    else if( M_PSEUDO(sym->type)) {	/* NO EPSEUDOs */
		pseudo( (PSEUDO_T)val & 0777777 );
		continue;
	    } /* pseudo */
	} /* macro, or non-char pseudo */

	evalue = getExpr();
	if (evalue.type != PSEUDO) {	/* not a  bare pseudo-op? */
	    if (line[lexstart] == ',') {	/* EXP, */
		if(evalue.val != clc && pass == 2 )
		    errorLexeme( &duplicate_label, lexstart); /* XXX */
	    }
	    else if (line[lexstart] == '/') {	/* EXP/ */
		clc = evalue.val;
		printLine( line, clc, 0, LINE_LOC );
		next(0);
	    }
	    else {
		punchOutObject( clc, evalue.val & 0777777); /* punch it! */
		incrementClc();
	    }
	}
    } /* forever */
}

/*  Function:  onePass */
/*  Synopsis:  Do one assembly pass. */
void onePass() {
    int     ix;

    clc = 4;				/* Default location is 4 */
    start_addr = 0;			/* No starting address. */
    nconst = 0;				/* No constant blocks seen */
    nvars = 0;				/* No variables seen */
    list_loc_show = FALSE;  /* MSHc */  /* No label seen yet */

    while (curmacro) {			/* pop macro stack */
	struct macinv *mp;

	mp = curmacro->prev;
	free(curmacro);
	curmacro = mp;
    }

    for( ix = 0; ix < mac_count; ix++) {
	if (mac_defs[ix])
	    free( mac_defs[ix] );
	mac_defs[ix] = NULL;
    }
    mac_count = 0;			/* No macros defined. */

    listed = TRUE;
    lineno = 0;
    list_pageno = 0;
    list_lineno = 0;
    list_title_set = FALSE;
    page_lineno =
#if 0                                                                             /* MSHj */
        list_lines_per_page;    /*-Force top of page at start of pass */          /*-MSH4 */
#endif                                                                            /* MSHj */
        -99999;                 /* Suppress a page throw until we see a title */  /* MSHj */
    radix = 8;                  /* Initial radix is octal (base 8). */

    /* Now open the first input file. */
    end_of_input = FALSE;
    filix_curr = filix_start;		/* Initialize pointer to input files. */
    if(( infile = fopen( save_argv[filix_curr], "r" )) == NULL ) {
	fprintf( stderr, "%s: cannot open \"%s\"\n", save_argv[0],
		save_argv[filix_curr] );
	exit( -1 );
    }

    for (;;) {
	readLine();
	if (end_of_input) {
	    eob();
	    fclose( infile );
	    return;
	}
	processLine();
    } /* forever */
} /* onePass */


/*  Function:  getExprs */
/*  Synopsys:  gutted like a fish */
WORD32 getExprs()
{
    SYM_T sym;

    sym = getExpr();
    if (sym.type == PSEUDO)
	errorMessage( &value_required, lexstart ); /* XXX wrong pointer? */

    return sym.val & 0777777;
} /* getExprs */


SYM_T getExpr()
{
    SYM_T sym;

    sym = eval();

    /* Here we assume the current lexeme is the operator separating the */
    /* previous operator from the next, if any. */

    for (;;) {
	int space;
	/*
	 * falling out of switch breaks loop and returns from routine
	 * so if you want to keep going, you must "continue"!!
	 */
	space = FALSE;
	switch( line[lexstart] ) {
	case ' ':
	    space = TRUE;
	    /* fall */
	case '+':			/* add */
	    next(1);			/* skip operator */
	    if (space && ISEND(line[lexstart]))	/* tollerate a trailing space */
		return sym;
	    sym.val += eval().val;	/* XXX look at type? */
	    sym.type = DEFINED;
	    if( sym.val >= 01000000 )
		sym.val = ( sym.val + 1 ) & 0777777;
	    continue;

	case '-':			/* subtract */
	    next(1);			/* skip over the operator */
	    sym.val += eval().val ^ 0777777; /* XXX look at type? */
	    sym.type = DEFINED;
	    if( sym.val >= 01000000 )
		sym.val = ( sym.val + 1 ) & 0777777;
	    continue;

	case '*':			/* multiply */
	    next(1);			/* skip over the operator */
	    sym.val *= eval().val;
	    sym.type = DEFINED;
	    if( sym.val >= 01000000 )
		sym.val = ( sym.val + 1 ) & 0777777;
	    continue;

#if 0
	case '%':			/* divide !??? */
	    /*
	     * neither '%' nor the divide symbol appear in FIO-DEC,
	     * does any known program use such an operator?
	     * Easily confused for "MOD", which is how C uses '%'!
	     */
	    next(1);
	    sym.val /= eval().val;
	    sym.type = DEFINED;
	    continue;
#endif

	case '&':			/* and */
	    next(1);			/* skip over the operator */
	    sym.val &= eval().val;
	    sym.type = DEFINED;
	    continue;

	case '!':			/* or */
	    next(1);			/* skip over the operator */
	    sym.val |= eval().val;
	    sym.type = DEFINED;
	    continue;

	case '/':
	case ')':
	case ']':
	case ':':
	case ',':
	    break;

	case '=':
	    errorMessage( &illegal_equals, lexstart );
	    moveToEndOfLine();
	    sym.val = 0;
	    break;

	default:
	    if (!ISEND(line[lexstart])) {
		errorMessage( &illegal_expression, lexstart );
		moveToEndOfLine();
		sym.val = 0;
		break;
	    }
	} /* switch */
	break;				/* break loop!! */
    } /* "forever" */
    return( sym );
} /* getExpr */

/*
 * return fio-dec code for next char
 * embeds shifts as needed
 */
int
nextfiodec(int *ccase, int delim)
{
    unsigned char c;

    for (;;) {
	if (cc >= maxcc) {
	    if (delim == -1)
		return -1;

	    /* XXX MUST NOT BE IN A REPEAT!! */
	    readLine();			/* danger Will Robinson! */
	    if (end_of_input)
		return -1;
	}
	c = line[cc];
	switch (c) {
	case '\n':
	    c = '\r';
	    break;
	case '\r':
	    continue;
	}
	break;
    }

    if (delim != -1 && c == delim) {
	if (*ccase == LC) {
	    cc++;			/* eat delim */
	    return -1;
	}
	*ccase = LC;
	return CONCISE_LC;		/* shift down first */
    }

    if (c > 0177) {			/* non-ascii */
    /*  errorMessage( &illegal_character, cc );  */    /* MSH3 */
        c = '\0';    /* BAD character! */              /* MSH3 */
    }

    c = ascii_to_fiodec[c&0177];
    if (c == BAD) {
	errorMessage( &illegal_character, cc );
	cc++; return 0;    /* MSH3 */	/* space?! */
    }

    if (!(c & *ccase)) {		/* char not in current case? */
	*ccase ^= BC;			/* switch case */
	if (*ccase == LC)
	    return CONCISE_LC;		/* shift down */
	else
	    return CONCISE_UC;		/* shift up */
    }
    cc++;
    return c & CHARBITS;
}

/*
 * Function: flex
 * Synopsis: Handle data for "flexo" pseudo
 * handle upper case by doing shifts
 */

WORD32 flex()
{
    WORD32 w;
    int shift;
    int ccase;

    if (line[lexstart] == ' ')		/* always? */
	next(0);

    /* original version appears to take next 3 characters,
     * REGARDLESS of what they are (tab, newline, space?)!
     */
    w = 0;
    ccase = LC;				/* current case */
    for (shift = 12; shift >= 0; shift -= 6) {
	unsigned char c;
	if( lexstart >= maxcc )
	    break;

	c = line[lexstart];
	if (c == '\t' || c == '\n') {
	    if (ccase == LC)
		break;
	    c = CONCISE_LC;			/* shift down first */
	}
	else {
	    if (c > 0177) {		/* non-ascii */
		errorMessage( &illegal_character, lexstart );
		c = 0;
	    }

	    c = ascii_to_fiodec[c&0177];
	    if (c == BAD) {
		errorMessage( &illegal_character, lexstart );
		c = 0;
	    }

	    if (!(c & ccase)) {		/* char not in current case? */
		ccase ^= BC;		/* switch case */
		if (ccase == LC)
		    c = CONCISE_LC;	/* shift down */
		else
		    c = CONCISE_UC;	/* shift up */
	    }
	    else
		lexstart++;
	}
	w |= (c & CHARBITS) << shift;
    }
    /* error to get here w/ case == UC? nah. shift down could be next */
    return w;
} /* flex */

/*
 * Function: getChar
 * Synopsis: Handle data for "char" pseudo
 */

WORD32 getChar()
{
    unsigned char c, pos;

    if( cc >= maxcc )
	return 0;			/* XXX error? */
    pos = line[cc++];
    if (pos != 'l' && pos != 'm' && pos != 'r') {
	errorMessage( &illegal_character, lexstart );
	return 0;
    }

    if( cc >= maxcc )
	return 0;			/* XXX error? */

    c = line[cc++];
    if (c > 0177) {
	errorMessage( &illegal_character, lexstart );
	c = 0;
    }

    c = ascii_to_fiodec[c];
    if (c == BAD) {
	errorMessage( &illegal_character, lexstart );
	c = 0;
    }

    if (!(c & LC)) {			/* upper case only char? */
	c = CONCISE_UC;			/* take a shift up */
	cc--;				/* and leave char for next luser */
    }

    c &= CHARBITS;
    switch (pos) {
    case 'l': return c << 12;
    case 'm': return c << 6;
    case 'r': return c;
    }
    /* should not happen */
    return 0;
} /* flex */

/*  Function:  eval */
/*  Synopsis:  Get the value of the current lexeme, and advance.*/
SYM_T eval2()
{
  WORD32  digit;
  WORD32  from;
  SYM_T  *sym;
  WORD32  val;
  SYM_T   sym_eval;

  sym_eval.type = DEFINED;
  sym_eval.name[0] = '\0';
  sym_eval.val = sym_eval.xref_index = sym_eval.xref_count = 0;

  val = 0;

  if( isLexSymbol()) {
    sym = evalSymbol();
    if(!M_DEFINED( sym->type )) {
      if( pass == 2 )
        errorSymbol( &undefined_symbol, sym->name, lexstart );
      next(1);
      return( *sym );
    }
    else if( M_PSEUDO(sym->type) || M_EPSEUDO(sym->type)) {
      switch (sym->val) {
      case DECIMAL:
        radix = 10;
	sym_eval.type = PSEUDO;
	sym_eval.val = 0;		/* has zero as a value! */
	break;
      case OCTAL:
        radix = 8;
	sym_eval.type = PSEUDO;
	sym_eval.val = 0;		/* has zero as a value */
	break;
      case FLEX:
	next(1);			/* skip keyword */
	sym_eval.val = flex();
	break;
      case CHAR:
	next(1);			/* skip keyword */
	sym_eval.val = getChar();
	break;
      default:
        errorSymbol( &value_required, sym->name, lexstart );
        sym_eval.type = sym->type;
	sym_eval.val = 0;
	break;
      }
      next(1);
      return( sym_eval );
    }
    else if( M_MACRO( sym->type ))
    {
      if( pass == 2 )
      {
        errorSymbol( &misplaced_symbol, sym->name, lexstart );
      }
      sym_eval.type = sym->type;
      sym_eval.val = 0;
      next(1);
      return( sym_eval );
    }
    else
    {
      next(1);
      return( *sym );
    }
  } /* symbol */
  else if( isdigit( line[lexstart] )) {
    from = lexstart;
    val = 0;
    while( from < lexterm ) {
	if( isdigit( line[from] )) {
	    digit = line[from++] - '0';
	    if( digit >= radix ) {
		errorLexeme( &number_not_radix, from - 1 );
		val = 0;
		break;
	    }
	    val = val * radix + digit;
	}
	else {
	    errorLexeme( &not_a_number, lexstart );
	    val = 0;
	    break;
	}
    }
    next(1);
    sym_eval.val = val;
    return( sym_eval );
  } /* digit */
  else {
    switch( line[lexstart] ) {
    case '.':				/* Value of Current Location Counter */
	val = clc;
	next(1);
	break;
    case '(':				/* Generate literal */
	next(1);			/* Skip paren */
	val = getExprs();		/* recurse */
	if( line[lexstart] == ')' )
	    next(1);			/* Skip end paren */
	sym_eval.val = literal(val);
	return sym_eval;
    case '[':				/* parens!! */
	next(1);
	sym_eval.val = getExprs();	/* mutual recursion */
	if( line[lexstart] == ']' )
	    next(1);			/* Skip close bracket */
	else
	    errorMessage( &illegal_character, lexstart );
	return sym_eval;
    default:
	switch( line[lexstart] ) {
	case '=':
	    errorMessage( &illegal_equals, lexstart );
	    moveToEndOfLine();
	    break;
	default:
	    errorMessage( &illegal_character, lexstart );
	    break;
	} /* error switch */
	val = 0;				/* On error, set value to zero. */
	next(1);				/* Go past illegal character. */
    } /* switch on first char */
  } /* not symbol or number */
  sym_eval.val = val;
  return( sym_eval );
} /* eval2 */


SYM_T eval() {
    SYM_T sym;

    switch (line[lexstart]) {
    case '-':				/* unary - */
	next(1);
	sym = eval2();			/* skip op */
	sym.val ^= 0777777;
	break;
    case '+':				/* unary + */
	next(1);			/* skip op */
	/* fall */
    default:
	sym = eval2();
    }
    return sym;
}

/*  Function:  incrementClc */
/*  Synopsis:  Set the next assembly location.  Test for collision with */
/*             the literal tables. */
WORD32 incrementClc()
{
  clc = (( clc + 1 ) & ADDRESS_FIELD );
  return( clc );
} /* incrementClc */


/*  Function:  readLine */
/*  Synopsis:  Get next line of input.  Print previous line if needed. */
void readLine()
{
    BOOL    ffseen;
    WORD32  ix;
    WORD32  iy;
    char    inpline[LINELEN];

    /* XXX panic if nrepeats > 0 (if self-feeding, do the backup here?) */

    listLine();				/* List previous line if needed. */
    error_in_line = FALSE;		/* No error in line. */

    if(curmacro && *curmacro->mac_ptr == '\0') { /* end of macro? */
	struct macinv *mp;

	listed = TRUE;			/* Already listed. */

	/* Restore invoking line. */
	strcpy(line, curmacro->mac_line);
	cc = lexstartprev = curmacro->mac_cc; /* Restore cc. */
	maxcc = strlen( line );		/* Restore maxcc. */

	mp = curmacro->prev;		/* pop stack */
	free(curmacro);
	curmacro = mp;

	return;
    } /* end of macro */

    cc = 0;				/* Initialize column counter. */
    lexstartprev = 0;
    if( curmacro ) {			/* Inside macro? */
	char mc;

	maxcc = 0;
	do {

	    mc = *curmacro->mac_ptr++;	/* Next character. */
	    /* watch for overflow? how could it?? */
	    line[maxcc++] = mc;
	} while( !ISEND( mc ));		/* note: terminates on tab?! */
	line[maxcc] = '\0';
	listed = nomac_exp;
	return;
    } /* inside macro */

    lineno++;				/* Count lines read. */
    listed = FALSE;			/* Mark as not listed. */
 READ_LINE:
    inpline[LINELEN - 3] = '\n';    /* MSH9 */
    if(( fgets( inpline, LINELEN - 1, infile )) == NULL ) {
	filix_curr++;			/* Advance to next file. */
	if( filix_curr < save_argc ) {	/* More files? */
	    fclose( infile );
	    if(( infile = fopen( save_argv[filix_curr], "r" )) == NULL ) {
		fprintf( stderr, "%s: cannot open \"%s\"\n", save_argv[0],
			save_argv[filix_curr] );
		exit( -1 );
	    }
            page_lineno =
                list_lines_per_page; /* Throw page for new titles */ /* MSHb */
	    list_title_set = FALSE;
	    goto READ_LINE;
	}
	else
	    end_of_input = TRUE;
    } /* fgets failed */

    if (inpline[LINELEN - 3] != '\n') {                 /* MSH9 */
        errorMessage( &line_too_long, LINELEN - 3 );    /* MSH9 */
        --errors;    /* Don't count as an error */      /* MSH9 */
        inpline[LINELEN - 2] = '\n';                    /* MSH9 */
    }                                                   /* MSH9 */

    ffseen = FALSE;
    for( ix = 0, iy = 0; inpline[ix] != '\0'; ix++ ) {
	if( inpline[ix] == '\f' ) {
	    if( !ffseen && list_title_set ) topOfForm( list_title, NULL );
	    ffseen = TRUE;
	}
	else
	    line[iy++] = inpline[ix];
    }
    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 )
  {
    if (!list_loc_show)                         /* MSHc */
        printLine( line, 0, 0, LINE );
    else                                        /* MSHc */
        printLine( line, clc, 0, LINE_LOC );    /* MSHc */
  }
} /* 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 )    /* MSH4 */
         /*  ( list_lineno % LIST_LINES_PER_PAGE ) == 0 ) */
  {
    topOfForm( list_title, NULL );
  }
} /* printPageBreak */


/*  Function:  printLine */
/*  Synopsis:  Output a line to the listing file with new page if necessary. */
void printLine( char *line, WORD32 loc, WORD32 val, LINESTYLE_T linestyle )
{
  if( listfile == NULL )
  {
    save_error_count = 0;
    return;
  }

  printPageBreak();

  list_lineno++;
  page_lineno++;
  switch( linestyle )
  {
  default:
  case LINE:
    if (quiet_list && !error_in_line) break;    /* MSHh */
    fprintf( listfile, "%5d                   ", lineno );
    fputs( line, listfile );
    listed = TRUE;
    break;

  case LINE_VAL:
    if (curmacro && quiet_list && !error_in_line) break;    /* MSHh */
    if( !listed )
    {
      fprintf( listfile, "%5d       %6.6o      ", lineno, val );
      fputs( line, listfile );
      listed = TRUE;
    }
    else
    {
      fprintf( listfile, "            %6.6o\n", val );
    }
    break;

  case LINE_LOC:
    if( !listed )
    {
      fprintf( listfile, "%5d %5.4o             ", lineno, loc );    /* MSH2 */
      fputs( line, listfile );
      listed = TRUE;
    }
    else
    {
      fprintf( listfile, "      %5.4o\n", loc );    /* MSH2 */
    }
    break;

  case LINE_LOC_VAL:
    if( !listed )
    {
      fprintf( listfile, "%5d %5.4o %6.6o      ",    /* MSH2 */
              lineno, loc, val );
      fputs( line, listfile );
      listed = TRUE;
    }
    else
    {
      fprintf( listfile, "      %5.4o %6.6o\n", loc, val );    /* MSH2 */
    }
    break;

  case LOC_VAL:    /* UNUSED */
    fprintf( listfile, "      %5.4o %6.6o\n", loc, val );    /* MSH2 */
    break;
  }
  printErrorMessages();
  list_loc_show = FALSE;    /* Reset label flag */    /* MSHc */
} /* printLine */


/*  Function:  printErrorMessages */
/*  Synopsis:  Output any error messages from the current list of errors. */
void printErrorMessages()
{
  WORD32  ix;
  WORD32  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:  punchObject */
/*  Synopsis:  Put one character to object file */
void punchObject( WORD32 val )
{
  val &= 0377;
  if( objectfile != NULL )
      fputc( val, objectfile );
} /* punchObject */

/*  Function:  punchTriplet */
/*  Synopsis:  Output 18b word as three 6b characters with ho bit set. */
void punchTriplet( WORD32 val )
{
  punchObject((( val >> 12) & 077) | 0200 );
  punchObject((( val >> 6 ) & 077) | 0200 );
  punchObject(( val & 077) | 0200 );
} /* punchTriplet */

void
eob() {
    /* in case no "start" in file (an error?) */
}

/*  Function:  punchLeader */
/*  Synopsis:  Generate 2 feet of leader on object file, as per DEC */
/*             documentation.  Paper tape has 10 punches per inch. */
void punchLeader( WORD32 count )
{
  WORD32  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( 0, objectfile );
    }
  }
} /* punchLeader */

/*  Function:  punchOutObject */
/*  Synopsis:  Output the current line and then then punch value to the */
/*             object file. */
void punchOutObject( WORD32 loc, WORD32 val )
{
  printLine( line, loc, val, LINE_LOC_VAL );
  punchLocObject( loc, val );
} /* punchOutObject */


/*  Function:  punchLocObjectRIM */
/*  Synopsis:  Output the word in RIM mode */
void punchLocObjectRIM( WORD32 loc, WORD32 val )
{
    punchTriplet( DIO | loc );
    punchTriplet( val );
} /* punchLocObject */

/* punch loader in RIM mode */
void
punchLoader() {
    int i;

    if (noinput)
	return;

    for (i = 0; i < DIM(loader); i++)
	punchLocObjectRIM(LOADERBASE+i, loader[i]);
    punchTriplet( JMP | LOADERBASE );
}

/*
 * flush out loader buffer; output a block:
 * DIO start
 * DIO end+1
 * .... data ....
 * sum
 */
#define PW(X) { WORD32 x = X; sum += x; punchTriplet(x); }
void
flushLoader() {
    WORD32 sum;
    int i;

    if (loaderbufcount == 0)
	return;

    sum = 0;
    PW( DIO | loaderbufstart );
    PW( DIO | loaderbufstart + loaderbufcount );
    for (i = 0; i < loaderbufcount; i++)
	PW( loaderbuf[i] );

    /* roll over all the overflows at once */
    if (sum & ~0777777)
	sum = (sum & 0777777) + (sum >> 18);
    if (sum & 01000000)			/* one more time */
	sum++;
    PW( sum );

    punchLeader(5);
    loaderbufcount = 0;
}

void punchLocObject( WORD32 loc, WORD32 val )
{
    if (!rim_mode) {
	if ((loc & LOADERBUFMASK) == 0 || /* full/force alignment */
	    loaderbufcount > 0 &&
	    loc != loaderbufstart + loaderbufcount) /* disjoint */
	    flushLoader();
	if (loaderbufcount == 0)
	    loaderbufstart = loc;
	loaderbuf[loaderbufcount++] = val;
    }
    else
	punchLocObjectRIM( loc, val );
}

/*  Function:  literal */
/*  Synopsis:  Add a value to the literal pool */
WORD32
literal( WORD32 value )
{
    int i;

    if (nconst >= MAX_CONSTANTS) {
	fprintf(stderr, "too many 'constants'; increase MAX_CONSTANTS\n");
	exit(1);
    }

    if (pass == 1) {
	if (++lit_count[nconst] == MAX_LITERALS) {
	    fprintf(stderr, "too many literals; increase MAX_LITERALS\n");
	    exit(1);
	}
	return lit_count[nconst];
    }

#if 1
    /*
     * pool constants; makes for a shorter tape
     * (but "middle" constants blocks can't shrink)
     */
    for (i = 0; i < nlit; i++)
	if (litter[i] == value)
	    return lit_loc[nconst] + i;
#endif

    /* paranoia */
    if (nlit == MAX_LITERALS) {
	fprintf(stderr, "too many literals; increase MAX_LITERALS\n");
	exit(1);
    }

    /* not found, save it */
    litter[nlit] = value;

    /* use base for this block, determined on pass1 */
    return lit_loc[nconst] + nlit++;
} /* literal */


/*  Function:  pstComp */
/*  Synopsis:  Compare elements of the symbol table. */
int pstComp( const void *arg1, const void *arg2 )    /* MSH7 */
{
    SYM_T *sym1 = (SYM_T *) arg1;
    SYM_T *sym2 = (SYM_T *) arg2;

    if (sym1->val < sym2->val) return -1;
    if (sym1->val > sym2->val) return +1;
    return strcmp( sym1->name, sym2->name );
} /* pstComp */


/*  Function:  printSymbolTable */
/*  Synopsis:  Output the symbol table. */
/* XXX now prints FIXED symbols too */
/* MSH7 now also prints symbols in numerical order */
void printSymbolTable()
{
    int    ix;
    int    symbol_lines;
    SYM_T *sym;
    SYM_T *numtab = NULL, *num;    /* MSH7 - all through this routine */
    char mark;

    /* Count symbols */

    symbol_lines = 0;
    for (ix = 0, sym = symtab; ix < symbol_top; ix++, sym++) {
	if (M_FIXED(sym->type) || M_PSEUDO(sym->type) ||
	    M_MACRO(sym->type) || M_EPSEUDO(sym->type))
	    continue;
	symbol_lines++;
    }

    if (symbol_lines == 0)
       return;

    /* Fill numerical-order symbol table */

#if 1
    numtab = malloc( sizeof( SYM_T ) * symbol_lines );

    /* Sort numerical symbol table */

    if (numtab != NULL) {
        for (ix = 0, sym = symtab, num=numtab; ix < symbol_top; ix++, sym++) {
	    if (M_FIXED(sym->type) || M_PSEUDO(sym->type) ||
	        M_MACRO(sym->type) || M_EPSEUDO(sym->type))
	        continue;
	    memcpy( num, sym, sizeof( SYM_T ) );
            num++;
        }
        qsort( numtab, symbol_lines, sizeof( SYM_T ), pstComp);
    }
#endif

    /* Top of page */

    topOfForm( list_title, s_symtable );
    symbol_lines = list_lines_per_page;    /* MSH4 */

    /* Alphabetical & numerical symbol table */

    for (ix = 0, sym = symtab, num = numtab; ix < symbol_top; ix++, sym++) {
	if (M_FIXED(sym->type) || M_PSEUDO(sym->type) ||
	    M_MACRO(sym->type) || M_EPSEUDO(sym->type))
	    continue;

	switch( sym->type & ( DEFINED | REDEFINED )) {
	case UNDEFINED:
	    mark = '?';
	    break;

	case REDEFINED:
	    mark = '#';
	    break;

	default:
	    mark = ' ';
            if (!M_NOTRDEF(sym->type)) mark = '=';    /* MSH6 */
	    break;
	}

        if (numtab == NULL) {
            fprintf( listfile, "%c%-6.6s %6.6o\n", mark, sym->name, sym->val );
        } else {
            fprintf( listfile, "%c%-6.6s %6.6o          %6.6o %s\n", mark,
                    sym->name, sym->val, num->val, num->name );
            num++;
        }
    }
} /* 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;

    if(( permfile = fopen( permpathname, "w" )) == NULL )
    {
	exit( 2 );
    }

    fprintf( permfile, "/ PERMANENT SYMBOL TABLE\n/\n" );
    fprintf( permfile, "        expunge\n/\n" );

    for( ix = 0; ix < symbol_top; ix++ )
    {
	int type = symtab[ix].type;
	if( M_FIXED(type) && !M_PSEUDO(type) && !M_EPSEUDO(type) )
	    fprintf( permfile, "\t%s=%o\n",
		     symtab[ix].name, symtab[ix].val );
    }
    fclose( permfile );
} /* printPermanentSymbolTable */


/*  Function:  printCrossReference */
/*  Synopsis:  Output a cross reference (concordance) for the file being */
/*             assembled. */
void printCrossReference()
{
    int    ix;
    int    xc;
    int    xc_index;
    int    xc_refcount;
    int    xc_cols;
    SYM_T  *sym;

    /* Force top of form for first page. */
    page_lineno = list_lines_per_page;    /* MSH4 */

    list_lineno = 0;

    for( ix = 0, sym = symtab; ix < symbol_top; ix++, sym++ ) {
	if (M_FIXED(sym->type) && xreftab[sym->xref_index] == 0)
	    continue;
	list_lineno++;
	page_lineno++;
	if( page_lineno >= list_lines_per_page )    /* MSH4 */
	    topOfForm( list_title, s_xref );

	fprintf( listfile, "%5d", list_lineno );

	/* Get reference count & index into concordance table for this symbol */
	xc_refcount = sym->xref_count;
	xc_index = sym->xref_index;
	/* Determine how to label symbol on concordance. */
	/* XXX flag variables? */
	switch( sym->type & ( DEFINED | REDEFINED )) {
	case UNDEFINED:
	    fprintf( listfile, " U         ");
	    break;

	case REDEFINED:
	    fprintf( listfile, " M  %5d  ", xreftab[xc_index] );
	    break;

	default:
	    fprintf( listfile, " %c  %5d  ",          /* MSH8 */
                    (xc_refcount > 0) ? 'A' : '*',    /* MSH8 */
                    xreftab[xc_index]);               /* MSH8 */
	    break;
	}
	fprintf( listfile, "%-6.6s  ", sym->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 )    /* MSH4 */
		    topOfForm( list_title, s_xref);
		list_lineno++;
		fprintf( listfile, "\n%5d%-19s", list_lineno, " " );
	    }
	    fprintf( listfile, "  %5d", xreftab[xc_index + xc] );
	}
	fprintf( listfile, "\n" );
    } /* for */
} /* 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 );

    if (!listfile)
	return;

    /* Output a top of form if not the first page of the listing. */
    if( list_pageno > 1 || /* or title not on 1st line */ list_lineno > 0)    /* MSHj */
	fprintf( listfile, "\f" );

    fprintf( listfile, "\n      %-63s %10s\n", title, temp );

    /* Reset the current page line counter. */
    page_lineno = 1;
    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, WORD32 from, WORD32 term )
{
    int to;

    to = 0;
    while( from < term && to < SYMLEN-1) {
	char c = line[from++];
	if (ISOVERBAR(c))
	    continue;
	name[to++] = c;
    }
    name[to] = '\0';

    return( name );
} /* lexemeToName */

/*  Function:  defineLexeme */
/*  Synopsis:  Put lexeme into symbol table with a value. */
SYM_T *defineLexeme( WORD32  start,     /* start of lexeme being defined. */
		     WORD32  term,	/* end+1 of lexeme being defined. */
                     WORD32  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 already in table. */
SYM_T *defineSymbol( char *name, WORD32 val, SYMTYP type, WORD32 start )
{
    SYM_T  *sym;
    WORD32  xref_count;

    if( strlen( name ) < 1 )
    {
	return( &sym_undefined );		/* Protect against non-existent names. */
    }
    sym = lookup( name, type );
    xref_count = 0;			/* Set concordance for normal defintion. */

    if( M_DEFINED( sym->type ) && sym->val != val && M_NOTRDEF( sym -> type ))
    {
	if( pass == 2 )
	{
	    errorSymbol( &redefined_symbol, sym->name, start );
	    type = type | REDEFINED;
	    sym->xref_count++;		/* Referenced symbol, count it. */
	    xref_count = sym->xref_count;
	    /* moved inside "if pass2" -plb 10/2/03 allow redefinition
	     * of predefined symbols during pass1
	     */
            sym->type = type;    /* MSH5 */
	    return ( sym );
	}
    }

    if( pass == 2 && xref )
    {
	/* Put the definition line number in the concordance table. */
	/* Defined symbols are not counted as references. */
	if (sym->xref_index >= 0) {	/* beware macro dummies */
	    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 = val & 0777777;
    sym->type = type |
                (sym->type & ~DEFINED & (DUPLICATE | REDEFINED));    /* MSH5 */
    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 *find, int type )   /* MSHe */
{
    int ix;				/* Insertion index */
    int lx;				/* Left index */
    int rx;				/* Right index */
    SYM_T *best;			/* best match */
    SYM_T *sym;
    char *name = find;                  /* MSHe */
    char lcname[SYMLEN];                /* MSHe */

    if (case_blind) {    /* MSHe ... */
        int i;

        for (i=0; ; i++) {
            lcname[i] = (char) tolower((int) name[i]);
            if (lcname[i] == '\0') break;
        }
        name = lcname;
    }   /* ... MSHe */

    /* YIKES!  Search dummies (and "R") before anything else!! */
    if (curmacro && curmacro->defn) {
	struct macdef *mdp = curmacro->defn;
	int i;

	for (i = 0, sym = mdp->args; i <= mdp->nargs; i++, sym++)
	    if (strcmp(name, sym->name) == 0)
		return sym;
    }

    lx = 0;
    rx = symbol_top - 1;
    best = NULL;
    while (lx <= rx) {
	int mx = (lx + rx) / 2;		/* Find center of search area. */
	int compare;

	sym = symtab + mx;

	compare = strcmp(name, sym->name);
	if (compare < 0)
	    rx = mx - 1;
	else if (compare > 0)
	    lx = mx + 1;
	else {				/* match */
	    if (overbar && !M_DEFINED(sym->type) && pass == 2) {
		sym->type = DEFINED;
		sym->val = vars_addr++;
		nvars++;
	    }
	    return sym;			 /* return exact match */
	} /* match */

	/* save best non-exact match; MACRO returns last defined n-x match! */
	if ((M_PSEUDO(sym->type)||M_EPSEUDO(sym->type)||M_MACRO(sym->type)) &&
	    strncmp(name, sym->name, 3) == 0)    /* MSH: ought to be 4 not 3 */
	    best = sym;
    } /* while */

    /* return best match (pseudo or macro) if any for lookups (not defns) */
    if (best && type == UNDEFINED)
	return best;

    /* Must put symbol in table if index is negative. */
    ix = lx;				/* insertion point */
    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. */
    sym = symtab + ix;
    strcpy( sym->name, name );
    sym->type = UNDEFINED;
    sym->val  = 0;
    sym->xref_count = 0;
    if( xref && pass == 2 && sym->xref_index >= 0)
	xreftab[sym->xref_index] = 0;

    if (overbar)
	nvars++;

    return sym;
} /* lookup */

/*  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 ), UNDEFINED);

    sym->xref_count++;			/* Count the number of references to symbol. */

    if( xref && pass == 2 && sym->xref_index >= 0)
    {
	/* 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++;	/* XXX wrong! will stop on a tab! */
    lexstart = cc;
    lexterm = cc;
    lexstartprev = lexstart;
} /* moveToEndOfLine */

/* frame the next token in "line" with lexstart and lexterm indicies */
void
next(int op) {
    char c;

    /* Save start column of previous lexeme for diagnostic messages. */
    lexstartprev = lexstart;
    lextermprev = lexterm;

    c = line[cc];
    if (c == ' ') {
	/* eat spaces */
	do {
	    c = line[++cc];
	} while (c == ' ');
	if (op)				/* looking for operators? */
	    cc--;			/* return one */
    }

    overbar = 0;
    lexstart = cc;
    c = line[cc];
    if( isalnum(c) || ISOVERBAR(c)) {
	if (ISOVERBAR(c))
	    overbar = 1;
	do {
	    c = line[++cc];
	    if (ISOVERBAR(c))
		overbar = 1;
	} while (isalnum(c) || ISOVERBAR(c));
    }
    else if(!ISDONE(c) || c == '\t')	/* not end of line, or comment */
	cc++;				/* advance past all punctuation */
    lexterm = cc;
} /* next */

BOOL isLexSymbol()
{
    int ix;

    /* XXX alpha within first 4? 3?? */
    for( ix = lexstart; ix < lexterm; ix++ )
	if(isalpha(line[ix]))
	    return TRUE;			/* any position will do! */
    return FALSE;
} /* isLexSymbol */

/*
 * from macro manual (F-36BP), p.18;
 *
 * "A macro-instruction definition consists of four parts;
 * the pseudo-instruction _define_, the _macro instruction name_
 * amd _dummy symbol list,_ the _body_, and the pseudo-instruction
 * _terminate_.  Each part is followed by at least one tabulation or
 * carriage return."
 *
 * and in the next paragraph;
 *
 * "The name is terminated by a _space_ or by a _tab_ or _cr_
 * if there is no dummy symbol list."
 *
 * This accepts tabs and/or a newline after define
 * (but will accept a space), and only accepts spaces
 * between macro and dummy names.
 */

void
defineMacro() {
    int lexstartsave;			/* point to macro name */
    int index;				/* point to error char */
    int error;				/* error boolean */
    int i;
    int count;
    WORD32  length;
    WORD32  value = 0;  /* MSH1 */
    char    termin[SYMLEN];
    char    args[MAC_MAX_ARGS][SYMLEN];	/* macro & arg names */
    char    body[MAC_MAX_LENGTH + 1];
    struct macdef *mdp;
    SYM_T *sym;

    if (nrepeats) {
	/* we can call readLine, so throw up hands now */
	errorLexeme( &define_in_repeat, lexstartprev );
	return;
    }

    while (line[lexstart] == ' ' || line[lexstart] == '\t')
	next(0);

    /* not a tab or space */
    if (ISEND(line[lexstart])) {	/* newline or EOS? */
	/* crock; next token should invisibly skip over line boundaries? */
	readLine();
	next(0);
	while (line[lexstart] == ' ' || line[lexstart] == '\t')
	    next(0);
    }

    /* XXX pick up macro name out here */

    count = 0;
    index = 0;
    error = FALSE;
    lexstartsave = lexstart;
    while (!ISDONE(line[lexstart]) && count < MAC_MAX_ARGS) {
	if (!isalnum(line[lexstart]) && index == 0)
	    index = lexstart;		/* error pointer */
	lexemeToName( args[count++], lexstart, lexterm );
	/* XXX error if NOT a comma (& not first dummy) ? */
	if (line[lexterm] == ',')
	    next(0);			/* eat the comma */
	next(0);
	if (line[lexstart] == ' ')
	    next(0);
    }
    if( count == 0 ) {			/* No macro name. */
	errorMessage( &no_macro_name, lexstartsave );
	error = TRUE;
    }
    else if( index ) {			/* Bad argument name. */
	errorMessage( &bad_dummy_arg, index );
	error = TRUE;
    }
    else if( mac_count >= MAC_TABLE_LENGTH ) {
	errorMessage( &macro_table_full, lexstartsave );
	error = TRUE;
    }
    else {
	value = mac_count++;		/* sym value is index into mac */
	defineSymbol( args[0], value, MACRO, lexstartsave );
    }

    for( length = 0;; ) {
	readLine();
	if (end_of_input)
	    break;
	next(0);
	while (line[lexstart] == ' ' || line[lexstart] == '\t')
	    next(0);

	lexemeToName( termin, lexstart, lexterm ); /* just look at line? */
	if (strncmp( termin, "term", 4 ) == 0)
	    break;

	if (!error) {
	    int ll = strlen(line);
	    int allblank = FALSE;

	    /* don't save blank lines! */
	    for( i = 0; i < ll && allblank; i++ )
		if(!ISBLANK(line[i]))
		    allblank = FALSE;

	    if (allblank)			/* nothing but air? */
		continue;			/* skip it! */

	    if ((length + ll + 1) >= MAC_MAX_LENGTH ) {
		errorMessage (&macro_too_long, lexstart );
		error = TRUE;
		continue;
	    }

	    strcpy(body+length, line);
	    length += ll;
            body[length-1] = '\n';    /* MSHi */
	}
    } /* for */
    if( error )
	return;

    mdp = calloc(1, sizeof(struct macdef) + length);
    if (mdp == NULL) {
	fprintf(stderr, "error allocating memory for macro definition\n");
	exit(1);
    }
    mac_defs[value] = mdp;

    strncpy(mdp->body, body, length);
    mdp->body[length] = '\0';
    mdp->nargs = count - 1;

    /*
     * save dummy names
     * symbol slot 0 reserved for "R" symbol
     * move SYM_T entries to macinv to allow recursion
     */
    sym = mdp->args;
    sym->type = DEFINED;
    if (case_blind)               /* MSHe */
       strcpy(sym->name, "r");    /* MSHe */
    else                          /* MSHe */
       strcpy(sym->name, "R");
    sym->val = 0;
    sym->xref_index = -1;		/* ??? allow xref? */
    sym++;

    for (i = 1; i <= mdp->nargs; i++, sym++) {
	sym->type = DEFINED;
        if (case_blind) {                          /* MSHe ... */
            int j = 0;

            do
                sym->name[j] = (char) tolower((char) args[i][j]);
            while (sym->name[j++]);
        } else                                     /* ... MSHe */
	    strcpy(sym->name, args[i]);
	sym->val = 0;
	sym->xref_index = -1;		/* don't xref!! */
    }
} /* defineMacro */

/* VARIABLES pseudo-op */
void
variables() {
    /* XXX error if "variables" already seen (in this pass) */
    /* XXX error if different address on pass 2 */
    if (pass == 2)
	printLine( line, clc, 0, LINE_LOC );
    vars_addr = clc;
    vars_end = clc = (clc + nvars) & ADDRESS_FIELD;
    if (pass == 2)
	printLine( line, clc, 0, LINE_LOC);
}

/* TEXT pseudo-op */
void
text(void)
{
    char delim;
    WORD32 w;
    int count;
    int ccase;
    /* XXX error in repeat!! */
    do {
	if (cc == maxcc) {
	    /* XXX EOL before delim found!!! */
	    fprintf(stderr, "FIX ME!\n");
	    return;
	}
	delim = line[cc++];
    } while (delim == ' ');		/* others? NL */

    w = count = 0;
    ccase = LC;
    for (;;) {
	int c = nextfiodec(&ccase, delim);
	if (c == -1)
	    break;
	w |= c << ((2-count)*6);
	if (++count == 3) {
	    punchOutObject(clc, w);	/* punch it! */
	    incrementClc();
	    count = w = 0;
	}
    }
    if (count > 0) {
	punchOutObject(clc, w);		/* punch remainder */
	incrementClc();
    }
}

/* CONSTANTS pseudo-op */
void
constants(void) {
    int i;

    /* XXX illegal inside macro (curmacro != NULL) */

    if (pass == 1) {
	lit_loc[nconst] = clc;

	/* just use addition?! */
	for (i = 0; i < lit_count[nconst]; i++)
	    incrementClc();

	nconst++;
	return;
    }

    /* pass 2: */
    /* XXX complain if clc != lit_base[nconst]? */

    for (i = 0; i < lit_count[nconst]; i++) {
	if (i < nlit)
	    punchOutObject( clc, litter[i] & 0777777); /* punch it! */
	incrementClc();
    }

    nconst++;
    nlit = 0;				/* litter[] now empty */
} /* constants */


/* process pseudo-ops
 * return FALSE if line scan should end (no longer used)
 */
BOOL pseudo( PSEUDO_T val )
{
    int count;
    int repeatstart;

    switch( (PSEUDO_T) val ) {
    case CONSTANTS:
	next(0);			/* Skip symbol */
	constants();
	break;

    case VARIABLES:
	next(0);			/* Skip symbol */
	variables();
	break;

    case DEFINE:
	next(0);			/* Skip symbol */
	defineMacro();
	return FALSE;
	break;

    case REPEAT:
	next(0);			/* Skip symbol */

	/* NOTE!! constant followed by SPACE picked up as expression!! */
	count = getExprs() /* & ADDRESS_FIELD */ ;         /* MSHd */
        if (count & 0770000) {                             /* MSHd */
        /*  if (count != 0777777)  */    /* Allow -0 */    /* MSHd */
            errorMessage( &repeat_negative, lexstart );    /* MSHd */
            count = 0;                                     /* MSHd */
        }                                                  /* MSHd */
     /* count &= ADDRESS_FIELD; */                         /* MSHd */

	/* allow comma, but do not require */
	if( line[lexstart] == ',')
	    next(0);

	nrepeats++;
	repeatstart = lexstart;		/* save line start */
	while (count-- > 0) {
	    cc = repeatstart;		/* reset input pointer */
	    processLine();		/* recurse! */
	}
	cc = maxcc;
	nrepeats--;

	return FALSE;
	break;

    case START:
	next(0);			/* Skip symbol */
	/* XXX illegal in macro or repeat */
	flushLoader();
        /* MSH 'start' with no parameter will not punch 'jmp' */
	if (!ISDONE(line[lexstart])) {
	    if (line[lexstart] == ' ')
		next(0);
	    start_addr = getExprs() & ADDRESS_FIELD;
	    next(0);
	    printLine( line, 0, start_addr, LINE_VAL );
	    /* MACRO punches 4" of leader */
	    punchTriplet(JMP | start_addr);
	    /* MACRO punches 24" of leader? */
	}
	/*
	 * handle multiple tapes concatenated into one file!!
	 * have command line option?? treat "start" as EOF??
	 */
	list_title_set = FALSE;
	return FALSE;

    case TEXT:
	/* NOTE!! no next()! */
	text();
	break;

    case NOINPUT:
	next(0);			/* Skip symbol */
	noinput = TRUE;
	break;

    case EXPUNGE:
	next(0);			/* Skip symbol */
	if (pass == 1)
	    init_symtab();
	break;

    default:
	break;
    } /* end switch for pseudo-ops */
    return TRUE;			/* keep scanning */
} /* pseudo */


/*  Function:  errorLexeme */
/*  Synopsis:  Display an error message using the current lexical element. */
void errorLexeme( EMSG_T *mesg, WORD32 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, WORD32 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.4o\n",    /* MSH2 */
	    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, WORD32 col )
{
  char   linecol[12];

  if( pass == 2 )
  {
    errors++;
    sprintf( linecol, ":%d:%d", lineno, col + 1 );
    fprintf( errorfile, "%s%-9s : error:  %s at Loc =%5.4o\n",    /* MSH2 */
	    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 current line is printed. */
void saveError( char *mesg, WORD32 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 */

/* create a "symbol punch" for DDT */
/* MUST be called after object file closed; we reuse the FILE*! */

void
dump_symbols(void) {
    int ix;
    WORD32 addr;

    objectfile = fopen( sympathname, "wb" );
    if (!objectfile) {
	perror(sympathname);
	return;
    }

    punchLeader(0);
    punchLoader();
    punchLeader(5);

    /* XXX fudge addr -- get count, and subtract 2N from 07750? */
    addr = 05000;

    for( ix = 0; ix < symbol_top; ix++ ) {
	int i, type;
	WORD32 name;

	type = symtab[ix].type;
	if (M_FIXED(type) || M_PSEUDO(type) || M_MACRO(type))
	    continue;

	name = 0;
	for (i = 0; i < 3; i++) {
	    char c;

	    c = symtab[ix].name[i];
	    /* XXX leave on NUL? */

	    c = ascii_to_fiodec[tolower(c) & 0177];
	    /* XXX check for BAD entries? */

	    /* XXX OR in val<<(3-i)*6?? */
	    name <<= 6;
	    name |= c & CHARBITS;
	}
	punchLocObject(addr++, permute(name));
	punchLocObject(addr++, symtab[ix].val);
    }
    flushLoader();
    punchTriplet( JMP );		/* ??? */
    punchLeader(0);
    fclose(objectfile);
}
