58f6e7d2db
- ibm1130software.zip was contained within ibm1130.zip from ibm1130.org - Tabs converted to spaces
4701 lines
170 KiB
C
4701 lines
170 KiB
C
/*
|
|
* (C) Copyright 2002, Brian Knittel.
|
|
* You may freely use this program, but: it offered strictly on an AS-IS, AT YOUR OWN
|
|
* RISK basis, there is no warranty of fitness for any purpose, and the rest of the
|
|
* usual yada-yada. Please keep this notice and the copyright in any distributions
|
|
* or modifications.
|
|
*
|
|
* This is not a supported product, but I welcome bug reports and fixes.
|
|
* Mail to sim@ibm1130.org
|
|
*/
|
|
|
|
#define VERSION "ASM1130 CROSS ASSEMBLER V1.22"
|
|
|
|
/********************************************************************************************
|
|
* ASM1130 - IBM 1130 Cross Assembler
|
|
*
|
|
* Version
|
|
* 1.22 - 2012Nov26 - When the -d argument is specified on the command line, % and < in sources
|
|
* act like ( and ), since in the DMS sources these characters need to be interpreted
|
|
* this way.
|
|
* 1.21 - 2012Oct25 - Fixed bug in XFLC. With no argument, it should spit out a zero
|
|
* value, thus reserving core for a variable. It was not, so separate
|
|
* variables ended up sharing the same core address.
|
|
* 1.20 - 2011Mar25 - Made hex output in listings uppercase
|
|
* 1.19 - 2008Nov25 - Set binout[4] in SBRK cards (probably irrelevant)
|
|
* 1.18 - 2006Sep09 - Fixed opcode for BOD instruction, error found by Luiz Carlos Orsoni
|
|
* 1.17 - 2004Dec14 - Made DEC, DECS output 0 if no argument is given
|
|
* 1.16 - 2004Nov12 - Output WAIT instruction for LIBF if output mode is not binary
|
|
* 1.15 - 2004Nov03 - Added -f option to offset displayed assembly address in listing
|
|
* This is useful when viewing listings of code that is assembled to
|
|
* one address but actually loaded to another (e.g. some APL\1130 modules)
|
|
* 1.14 - 2004Oct22 - Fixed problem with BSS complaining about negative
|
|
* sizes. This may be a fundamental problem with my using
|
|
* 32-bit expressions, but for now, it appears that just
|
|
* truncating the BSS size to 16 bits is sufficient to build DMS.
|
|
* 1.13 - 2004Jun05 - Fixed sign extension of constants in expressions. Statements
|
|
* like LD /FFFF were being assembled incorrectly.
|
|
* 1.12 - 2004Jun04 - Made WAIT instruction take a displacement value.
|
|
* Doesn't affect operation, but these are used as indicators
|
|
* in the IBM one-card diagnostic programs.
|
|
* Also -- should mention that the .IPL directive was
|
|
* removed some time ago. To create bootable cards,
|
|
* use -b flag to create binary output, and post-process the
|
|
* binary output with program "mkboot"
|
|
* 1.11 - 2004May22 - Added CMP, DCM, and DECS instructions for 1800,
|
|
* thanks to Kevin Everets.
|
|
* 1.10 - 2003Dec08 - Fixed opcode value for XCH instruction, thanks to
|
|
* Roger Simpson.
|
|
* 1.09 - 2003Aug03 - Added fxwrite so asm will write little-endian files
|
|
* on all CPUs.
|
|
* 1.08 - 2003Mar18 - Fixed bug that complained about valid MDX displacement of +127
|
|
* 1.07 - 2003Jan05 - Filenames are now left in lower case. SYMBOLS.SYS stays all upper case
|
|
* 1.06 - 2002May02 - Fixed bug in ebdic constants (data goes into low byte)
|
|
* First stab at adding ISS level # info, this is iffy
|
|
* 1.05 - 2002Apr24 - Made negative BSS size a warning not an error, as it
|
|
* it's looking like it happens twice in PTMASMBL.
|
|
* This version still doesn't do fixed point numbers and
|
|
* negative floats may be wrong.
|
|
* 1.04 - 2002Apr18 - Added binary (card loader format) output, removed
|
|
* interim IPL output formats and moved that to MKBOOT.
|
|
* Enhanced relocatable code handling. Added floating
|
|
* point constants, but don't know how to make fixed point
|
|
* constants yet. Made amenable to syntax variations found
|
|
* in the DMS sources. Doesn't properly handle ILS
|
|
* modules yet and ISS is probably wrong.
|
|
* 1.03 - 2002Apr10 - numerous fixes, began to add relative/absolute support
|
|
* 1.02 - 2002Feb26 - replaced "strupr" with "upcase" for compatibility
|
|
* 1.01 - 2002Feb25 - minor compiler compatibility changes
|
|
* 1.00 - 2002Feb01 - first release. Tested only under Win32.
|
|
* ---------------------------------------------------------------------------------
|
|
*
|
|
* Usage:
|
|
* asm1130 [-bdvsx] [-o[file]] [-l[file] [-fXXXX]] [-rN.M] file...
|
|
*
|
|
* Description:
|
|
* -b binary output (.bin, relocatable absolute format)
|
|
* -d compile with DMS source character adjustments: % is interpreted as ( and < is intrepreted as ).
|
|
* -v verbose
|
|
* -s print symbol table
|
|
* -x print cross references
|
|
* -o output file (default is name of first source file + extension .out or .bin)
|
|
* -l listing file (default is name of first source file + extension .lst)
|
|
* -y preload system symbol table SYMBOLS.SYS (from the current directory)
|
|
* -w write the system symbol table SYMBOLS.SYS in the current directory
|
|
* -W same as -w but don't prompt to confirm overwriting existing file
|
|
* -r set DMS release to release N version M, for sbrk cards
|
|
* -f Apply offset XXXX (hex) to APPARENT assembly address in leftmost column of listing
|
|
*
|
|
* Listing and symbol table output can be turned on by *LIST directives in the source, too
|
|
* Listing file default extension is .LST
|
|
*
|
|
* Input files can use strict IBM 1130 Assembler column format, or loose formatting
|
|
* with tabs, or any mix on a line-by-line basis. Input files default extension is .ASM.
|
|
*
|
|
* Strict specification is:
|
|
*
|
|
* label columns 1 - 5
|
|
* opcode 7 - 10
|
|
* tag 12
|
|
* index 13
|
|
* arguments 15 - 51
|
|
*
|
|
* Loose, indicated by presence of ascii tab character(s):
|
|
*
|
|
* label<tab>opcode<tab>index and format indicators<tab>arguments
|
|
*
|
|
* In both cases, the IBM convention that the arguments section ends with the
|
|
* first nonblank applies. This means that ".DC 1, 2, 3" assembles only the 1!
|
|
*
|
|
* Output file format is that used by the LOAD command in my 1130
|
|
* simulator. Lines are any of the following. All values are in hex:
|
|
*
|
|
* @addr load address for subsequent words is addr
|
|
* Znwords Zero the next "nwords" and increment load address by nwords.
|
|
* =addr set IAR register to address addr (a convenience)
|
|
* value load value at load address and increment load address
|
|
*
|
|
* Output file default extension is .OUT or .BIN for binary assemblies
|
|
*
|
|
* Note: this version does not handle relative assembly, and so doesn't carry
|
|
* absolute/relative indication through expression calculation.
|
|
*
|
|
* Seems to work. Was able to assemble the resident monitor OK.
|
|
* >>> Look for "bug here" though, for things to check out.
|
|
*
|
|
* Notes:
|
|
* We assume that the computer on which the assembler runs uses ANSI floating point.
|
|
* Also, the assembly of floating point values may be incorrect on non-Intel
|
|
* architectures, this needs to be investigated.
|
|
*
|
|
* org_advanced tells whether * in an expression refers to the address AFTER the
|
|
* instruction (1 or 2 words, depending on length). This is the case for opcodes
|
|
* but not all directives.
|
|
*
|
|
* Revision History
|
|
* 16Apr02 1.03 Added sector break, relocation flag output
|
|
* 02Apr02 1.02 Fixed bug in BOSC: it CAN be a short instruction.
|
|
* Added directives for 1130 and 1800 IPL output formats
|
|
* Added conditional assembly directives
|
|
********************************************************************************************/
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <stdarg.h>
|
|
#include <setjmp.h>
|
|
#include <time.h>
|
|
#include <ctype.h>
|
|
#include "util_io.h"
|
|
|
|
/********************************************************************************************
|
|
* DEFINITIONS
|
|
********************************************************************************************/
|
|
|
|
/* I have found some IBM source code where @ and ' seem interchangable (likely due to the
|
|
* use of 026 keypunches).
|
|
* Comment out this define to make @ and ' different in symbol names, keep to make equivalent
|
|
*/
|
|
|
|
#if defined(VMS)
|
|
# include <unistd.h> /* to pick up 'unlink' */
|
|
#endif
|
|
|
|
#define BETWEEN(v,a,b) (((v) >= (a)) && ((v) <= (b)))
|
|
#define MIN(a,b) (((a) <= (b)) ? (a) : (b))
|
|
#define MAX(a,b) (((a) >= (b)) ? (a) : (b))
|
|
|
|
#ifndef _WIN32
|
|
int strnicmp (char *a, char *b, int n);
|
|
int strcmpi (char *a, char *b);
|
|
#endif
|
|
|
|
#define FIX_ATS
|
|
|
|
#define DMSVERSION "V2M12" /* required 5 characters on sector break card col 67-71 */
|
|
|
|
#define DOLLAREXIT "/38" /* hmmm, are these really fixed absolutely in all versions? */
|
|
#define DOLLARDUMP "/3F"
|
|
|
|
#define SYSTEM_TABLE "SYMBOLS.SYS"
|
|
|
|
#define BOOL int
|
|
#define TRUE 1
|
|
#define FALSE 0
|
|
|
|
#define ISTV 0x33 /* magic number from DMS R2V12 monitorm symbol @ISTV */
|
|
|
|
#define MAXLITERALS 300
|
|
#define MAXENTRIES 14
|
|
|
|
#define LINEFORMAT " %4ld | %s"
|
|
#define LEFT_MARGIN " |"
|
|
/* XXXX XXXX XXXX XXXX XXXX XXXX */
|
|
/* org w1 w2 w3 w4 w5 */
|
|
/* XXXX 1111 2222 3333 4444 LLLL | */
|
|
/* 12345678901234567890123456789012 */
|
|
|
|
typedef enum {ABSOLUTE = 0, RELATIVE = 1, LIBF = 2, CALL = 3} RELOC;
|
|
|
|
typedef struct tag_symbol { /* symbol table entry: */
|
|
char *name; /* name of symbol */
|
|
int value; /* value (absolute) */
|
|
int pass; /* defined during pass # */
|
|
int defined; /* definition state, see #defines below */
|
|
RELOC relative; /* ABSOLUTE = absolute, RELATIVE = relative */
|
|
struct tag_symbol *next; /* next symbol in list */
|
|
struct tag_xref *xrefs; /* cross references */
|
|
} SYMBOL, *PSYMBOL;
|
|
|
|
#define S_UNDEFINED 0 /* values of 'defined' */
|
|
#define S_PROVISIONAL 1 /* usually an expression with forward references */
|
|
#define S_DEFINED 2 /* ordering must be undef < prov < def */
|
|
|
|
typedef struct tag_xref { /* cross reference entry */
|
|
char *fname; /* filename */
|
|
int lno; /* line number */
|
|
BOOL definition; /* true = definition, false = reference */
|
|
struct tag_xref *next; /* next reference */
|
|
} XREF, *PXREF;
|
|
|
|
typedef struct tag_expr { /* expression result: absolute or relative */
|
|
int value;
|
|
RELOC relative;
|
|
} EXPR;
|
|
|
|
typedef enum {PROGTYPE_ABSOLUTE = 1, PROGTYPE_RELOCATABLE = 2, PROGTYPE_LIBF = 3, PROGTYPE_CALL = 4,
|
|
PROGTYPE_ISSLIBF = 5, PROGTYPE_ISSCALL = 6, PROGTYPE_ILS = 7} PROGTYPE;
|
|
|
|
typedef enum {SUBTYPE_INCORE = 0, SUBTYPE_FORDISK = 1, SUBTYPE_ARITH = 2,
|
|
SUBTYPE_FORNONDISK = 3, SUBTYPE_FUNCTION=8} SUBTYPE;
|
|
|
|
typedef enum {INTMODE_UNSPECIFIED = 0, INTMODE_MATCHREAL = 0x0080, INTMODE_ONEWORD = 0x0090} INTMODE;
|
|
typedef enum {REALMODE_UNSPECIFIED = 0, REALMODE_STANDARD = 0x0001, REALMODE_EXTENDED = 0x0002} REALMODE;
|
|
|
|
#define OP_INDEXED 0x0300 /* 1130 opcode modifier bits */
|
|
#define OP_LONG 0x0400
|
|
#define OP_INDIRECT 0x0080
|
|
|
|
typedef enum {OUTMODE_LOAD, OUTMODE_BINARY} OUTMODE;
|
|
|
|
#ifdef _WIN32
|
|
# define OUTWRITEMODE "wb" /* write outfile in binary mode */
|
|
# define ENDLINE "\r\n" /* explictly write CR/LF */
|
|
#else
|
|
# define OUTWRITEMODE "w" /* use native mode */
|
|
# define ENDLINE "\n"
|
|
#endif
|
|
|
|
/********************************************************************************************
|
|
* GLOBALS
|
|
********************************************************************************************/
|
|
|
|
/* command line syntax */
|
|
char *usestr =
|
|
"Usage: asm1130 [-bdpsvwxy8] [-o[file]] [-l[file] [-fXXXX]] [-rN.M] file...\n\n"
|
|
"-b binary (relocatable format) output; default is simulator LOAD format\n"
|
|
"-d interpret % and < as ( and ), for assembling DMS sources\n"
|
|
"-p count passes required; no assembly output is created with this flag"
|
|
"-s add symbol table to listing\n"
|
|
"-v verbose mode\n"
|
|
"-w write system symbol table as SYMBOLS.SYS\n"
|
|
"-W same as -w but do not confirm overwriting previous file\n"
|
|
"-x add cross reference table to listing\n"
|
|
"-y preload system symbol table SYMBOLS.SYS\n"
|
|
"-8 enable IBM 1800 instructions\n" /* (alternately, rename or link executable to asm1800.exe) */
|
|
"-o set output file; default is first input file + .out or .bin\n"
|
|
"-l create listing file; default is first input file + .lst\n"
|
|
"-r set dms version to VN RM for system SBRK cards\n"
|
|
"-f apply offset XXXX (hex) to APPARENT assembly address listing\n";
|
|
|
|
BOOL verbose = FALSE; /* verbose mode flag */
|
|
BOOL tabformat = FALSE; /* TRUE if tabs were seen in the file */
|
|
BOOL enable_1800 = FALSE; /* TRUE if 1800 mode is enabled by flag or executable name */
|
|
int listoffset = 0; /* offset to use for listing assembly address column */
|
|
int pass; /* current assembler pass (1 or 2) */
|
|
char curfn[256]; /* current input file name */
|
|
char progname[8]; /* base name of primary input file */
|
|
char *outfn = NULL; /* output file name */
|
|
int lno; /* current input file line number */
|
|
BOOL preload = FALSE; /* preload system symbol table */
|
|
BOOL savetable = FALSE; /* write system symbol table */
|
|
BOOL saveprompt = TRUE; /* prompt before overwriting */
|
|
int nerrors = 0; /* count of errors */
|
|
int nwarnings = 0; /* count of warnings */
|
|
FILE *fin = NULL; /* current input file */
|
|
FILE *fout = NULL; /* output file stream */
|
|
OUTMODE outmode = OUTMODE_LOAD; /* output file mode */
|
|
int outcols = 0; /* columns written in using card output */
|
|
int maxiplcols = 80;
|
|
char cardid[9]; /* characters used for IPL card ID */
|
|
FILE *flist = NULL; /* listing file stream */
|
|
char *listfn = NULL; /* listing filename */
|
|
BOOL do_list = FALSE; /* flag: create listing */
|
|
BOOL passcount = FALSE; /* flag: count passes only */
|
|
BOOL list_on = TRUE; /* listing is currently enabled */
|
|
BOOL do_xref = FALSE; /* cross reference listing */
|
|
BOOL do_syms = FALSE; /* symbol table listing */
|
|
BOOL ended = FALSE; /* end of current file */
|
|
BOOL hasforward = FALSE; /* true if there are any forward references */
|
|
char listline[350]; /* output listing line */
|
|
BOOL line_error; /* already saw an error on current line */
|
|
RELOC relocate = RELATIVE; /* relocatable assembly mode */
|
|
BOOL assembled = FALSE; /* true if any output has been generated */
|
|
int nwout; /* number of words written on current line */
|
|
int org = 0; /* output address (origin) */
|
|
int org_advanced; /* if nonzero, value of * is (instruction address + org_advanced) during evaluation */
|
|
int pta = -1; /* program transfer address */
|
|
BOOL cexpr = FALSE; /* "C" expression syntax (nonstandard, not enabled by default) */
|
|
PSYMBOL symbols = NULL; /* the symbol table (linear search) */
|
|
BOOL check_control = TRUE; /* check for control cards */
|
|
PROGTYPE progtype = PROGTYPE_RELOCATABLE; /* program type */
|
|
INTMODE intmode = INTMODE_UNSPECIFIED; /* integer mode */
|
|
REALMODE realmode = REALMODE_UNSPECIFIED; /* real mode */
|
|
int nintlevels = 0; /* # of interrupt levels for ISS */
|
|
int intlevel_primary = 0; /* primary level for ISS and level for ILS */
|
|
int intlevel_secondary = 0; /* secondary level for ISS */
|
|
int iss_number = 0; /* ISS number */
|
|
PSYMBOL entry[MAXENTRIES]; /* entries for subroutines */
|
|
int nentries = 0;
|
|
int ndefined_files = 0;
|
|
struct lit { /* accumulated literals waiting to be output */
|
|
int value; /* constant value */
|
|
int tagno; /* constant symbol tag number (e.g. _L001) */
|
|
BOOL hex; /* constant was expressed in hex */
|
|
BOOL even; /* constant was operand of a double-width instruction (e.g. AD) */
|
|
} literal[MAXLITERALS];
|
|
|
|
int n_literals = 0, lit_tag = 0;
|
|
BOOL requires_even_address; /* target of current instruction */
|
|
BOOL dmes_saved; /* odd character left over from dmes ending in ' */
|
|
int dmes_savew;
|
|
char opfield[256]; /* extracted operand field from source line */
|
|
char dmsversion[12] = DMSVERSION; /* version number for SBRK cards */
|
|
const char whitespace[] = " \t"; /* whitespace */
|
|
|
|
int ascii_to_ebcdic_table[128] =
|
|
{
|
|
/* */
|
|
0x00,0x01,0x02,0x03,0x37,0x2d,0x2e,0x2f, 0x16,0x05,0x25,0x0b,0x0c,0x0d,0x0e,0x0f,
|
|
/* */
|
|
0x10,0x11,0x12,0x13,0x3c,0x3d,0x32,0x26, 0x18,0x19,0x3f,0x27,0x1c,0x1d,0x1e,0x1f,
|
|
/* spac ! " # $ % & ' ( ) * + , - . / */
|
|
0x40,0x5a,0x7f,0x7b,0x5b,0x6c,0x50,0x7d, 0x4d,0x5d,0x5c,0x4e,0x6b,0x60,0x4b,0x61,
|
|
/* 0 1 2 3 4 5 6 7 8 9 : ; < = > ? */
|
|
0xf0,0xf1,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7, 0xf8,0xf9,0x7a,0x5e,0x4c,0x7e,0x6e,0x6f,
|
|
/* @ A B C D E F G H I J K L M N O */
|
|
0x7c,0xc1,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7, 0xc8,0xc9,0xd1,0xd2,0xd3,0xd4,0xd5,0xd6,
|
|
/* P Q R S T U V W X Y Z [ \ ] & _ */
|
|
0xd7,0xd8,0xd9,0xe2,0xe3,0xe4,0xe5,0xe6, 0xe7,0xe8,0xe9,0xba,0xe0,0xbb,0xb0,0x6d,
|
|
/* a b c d e f g h i j k l m n o */
|
|
0x79,0x81,0x82,0x83,0x84,0x85,0x86,0x87, 0x88,0x89,0x91,0x92,0x93,0x94,0x95,0x96,
|
|
/* p q r s t u v w x y z { | } ~ */
|
|
0x97,0x98,0x99,0xa2,0xa3,0xa4,0xa5,0xa6, 0xa7,0xa8,0xa9,0xc0,0x4f,0xd0,0xa1,0x07,
|
|
};
|
|
|
|
/* note that by default, ascii_to_ebcdic_table maps % and < to the EBCDIC codes for these characters.
|
|
* If the -d command line switch is used to enable DMS mode, these characters map to ( and )
|
|
* Another way to look at the -d switch is that it interprets % and < as if they had been typed
|
|
* on an 026 Commercial keypunch.
|
|
*/
|
|
|
|
int ascii_to_1403_table[128] =
|
|
{ /* 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f */
|
|
0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f, 0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,
|
|
0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f, 0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,
|
|
0x7f,0x7f,0x7f,0x7f,0x62,0x7f,0x15,0x0b, 0x57,0x2f,0x23,0x6d,0x16,0x61,0x6e,0x4c,
|
|
0x49,0x40,0x01,0x02,0x43,0x04,0x45,0x46, 0x07,0x08,0x7f,0x7f,0x7f,0x4a,0x7f,0x7f,
|
|
0x7f,0x64,0x25,0x26,0x67,0x68,0x29,0x2a, 0x6b,0x2c,0x58,0x19,0x1a,0x5b,0x1c,0x5d,
|
|
0x5e,0x1f,0x20,0x0d,0x0e,0x4f,0x10,0x51, 0x52,0x13,0x54,0x7f,0x7f,0x7f,0x7f,0x7f,
|
|
0x7f,0x64,0x25,0x26,0x67,0x68,0x29,0x2a, 0x6b,0x2c,0x58,0x19,0x1a,0x5b,0x1c,0x5d,
|
|
0x5e,0x1f,0x20,0x0d,0x0e,0x4f,0x10,0x51, 0x52,0x13,0x54,0x7f,0x7f,0x7f,0x7f,0x7f
|
|
};
|
|
|
|
#include "../ibm1130_conout.h" /* conout_to_ascii_table */
|
|
#include "../ibm1130_prtwheel.h" /* 1132 printer printwheel data */
|
|
|
|
/********************************************************************************************
|
|
* PROTOTYPES
|
|
********************************************************************************************/
|
|
|
|
void init (int argc, char **argv);
|
|
void bail (char *msg);
|
|
void flag (char *arg);
|
|
void proc (char *fname);
|
|
void startpass (int n);
|
|
void errprintf (char *fmt, ...);
|
|
void asm_error (char *fmt, ...);
|
|
void asm_warning (char *fmt, ...);
|
|
char *astring (char *str);
|
|
PSYMBOL lookup_symbol (char *name, BOOL define);
|
|
void add_xref (PSYMBOL s, BOOL definition);
|
|
int get_symbol (char *name);
|
|
void set_symbol (char *name, int value, int known, RELOC relative);
|
|
char * gtok (char **pc, char *tok);
|
|
char *skipbl (char *c);
|
|
void sym_list (void);
|
|
void xref_list (void);
|
|
void listhdr (void);
|
|
int getexpr (char *pc, BOOL undefined_ok, EXPR *expr);
|
|
void passreport (void);
|
|
void listout (BOOL reset);
|
|
void output_literals (BOOL eof);
|
|
char *upcase (char *str);
|
|
void prep_line (char *line);
|
|
int ascii_to_hollerith (int ch);
|
|
char *detab (char *str);
|
|
void preload_symbols (void);
|
|
void save_symbols (void);
|
|
void bincard_init (void);
|
|
void bincard_writecard (char *sbrk_text);
|
|
void bincard_writedata (void);
|
|
void bincard_flush (void);
|
|
void bincard_sbrk (char *line);
|
|
void bincard_setorg (int neworg);
|
|
void bincard_writew (int word, RELOC relative);
|
|
void bincard_endcard (void);
|
|
void handle_sbrk (char *line);
|
|
void bincard_typecard (void);
|
|
void namecode (unsigned short *words, char *tok);
|
|
int signextend (int v);
|
|
|
|
/********************************************************************************************
|
|
* main routine
|
|
********************************************************************************************/
|
|
|
|
int main (int argc, char **argv)
|
|
{
|
|
int i, sawfile = FALSE;
|
|
|
|
init(argc, argv); /* initialize, process flags */
|
|
|
|
startpass(1); /* first pass, process files */
|
|
|
|
for (i = 1; i < argc; i++)
|
|
if (*argv[i] != '-')
|
|
proc(argv[i]), sawfile = TRUE;
|
|
|
|
if (! sawfile) /* should have seen at least one file */
|
|
bail(usestr);
|
|
|
|
if (passcount) {
|
|
passreport();
|
|
return 0;
|
|
}
|
|
|
|
startpass(2); /* second pass, process files again */
|
|
|
|
for (i = 1; i < argc; i++)
|
|
if (*argv[i] != '-')
|
|
proc(argv[i]);
|
|
|
|
if (outmode == OUTMODE_LOAD) {
|
|
if (pta >= 0) /* write start address to the load file */
|
|
fprintf(fout, "=%04X" ENDLINE, pta & 0xFFFF);
|
|
}
|
|
else
|
|
bincard_endcard();
|
|
|
|
if (flist) {
|
|
if (nerrors || nwarnings) { /* summarize (or summarise) */
|
|
if (nerrors == 0)
|
|
fprintf(flist, "There %s ", (nwarnings == 1) ? "was" : "were");
|
|
else
|
|
fprintf(flist, "\nThere %s %d error%s %s",
|
|
(nerrors == 1) ? "was" : "were", nerrors, (nerrors == 1) ? "" : "s", nwarnings ? "and " : "");
|
|
|
|
if (nwarnings > 0)
|
|
fprintf(flist, "%d warning%s ", nwarnings, (nwarnings == 1) ? "" : "s");
|
|
|
|
fprintf(flist, "in this assembly\n");
|
|
}
|
|
else
|
|
fprintf(flist, "\nThere were no errors in this assembly\n");
|
|
}
|
|
|
|
if (flist) { /* finish the listing */
|
|
if (pta >= 0)
|
|
fprintf(flist, "\nProgram transfer address = %04X\n", pta);
|
|
|
|
if (do_xref)
|
|
xref_list();
|
|
else if (do_syms)
|
|
sym_list();
|
|
}
|
|
|
|
if (savetable)
|
|
save_symbols();
|
|
|
|
return 0; /* all done */
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* init - initialize assembler, process command line flags
|
|
********************************************************************************************/
|
|
|
|
void init (int argc, char **argv)
|
|
{
|
|
int i;
|
|
|
|
enable_1800 = strstr(argv[0], "1800") != NULL; /* if "1800" appears in the executable name, enable 1800 extensions */
|
|
|
|
for (i = 1; i < argc; i++) /* process command line switches */
|
|
if (*argv[i] == '-')
|
|
flag(argv[i]+1);
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* flag - process one command line switch
|
|
********************************************************************************************/
|
|
|
|
void flag (char *arg)
|
|
{
|
|
int major, minor;
|
|
|
|
while (*arg) {
|
|
switch (*arg++) {
|
|
case 'o': /* output (load) file name */
|
|
if (! *arg)
|
|
bail(usestr);
|
|
outfn = arg;
|
|
return;
|
|
|
|
case 'p':
|
|
passcount = TRUE;
|
|
break;
|
|
|
|
case 'v': /* mumble while running */
|
|
verbose = TRUE;
|
|
break;
|
|
|
|
case 'x': /* print cross reference table */
|
|
do_xref = TRUE;
|
|
break;
|
|
|
|
case 's': /* print symbol table */
|
|
do_syms = TRUE;
|
|
break;
|
|
|
|
case 'l': /* listing file name */
|
|
listfn = (* arg) ? arg : NULL;
|
|
do_list = TRUE;
|
|
return;
|
|
|
|
case 'W':
|
|
saveprompt = FALSE;
|
|
/* fall through */
|
|
case 'w':
|
|
savetable = TRUE;
|
|
break;
|
|
|
|
case 'y':
|
|
preload = TRUE;
|
|
break;
|
|
|
|
case 'b':
|
|
outmode = OUTMODE_BINARY;
|
|
break;
|
|
|
|
case '8':
|
|
enable_1800 = TRUE;
|
|
break;
|
|
|
|
case 'r':
|
|
if (sscanf(arg, "%d.%d", &major, &minor) != 2)
|
|
bail(usestr);
|
|
sprintf(dmsversion, "V%01.1dM%02.2d", major, minor);
|
|
return;
|
|
|
|
case 'f':
|
|
if (sscanf(arg, "%x", &listoffset) != 1)
|
|
bail(usestr);
|
|
|
|
if (listoffset & 0x8000) /* sign extend from 16 to (int) bits */
|
|
listoffset |= ~0x7FFF;
|
|
|
|
return;
|
|
|
|
case 'd': /* DMS source code mode: treat % and < as ( and ) */
|
|
ascii_to_ebcdic_table['%'] = ascii_to_ebcdic_table['(']; /* an alternate intpretation of -d is that it interprets */
|
|
ascii_to_ebcdic_table['<'] = ascii_to_ebcdic_table[')']; /* % and < as if from an 026 Commercial keypunch */
|
|
break;
|
|
|
|
default:
|
|
bail(usestr);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* bail - print error message on stderr (only) and exit
|
|
********************************************************************************************/
|
|
|
|
void bail (char *msg)
|
|
{
|
|
fprintf(stderr, "%s\n", msg);
|
|
exit(1);
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* errprintf - print error message to stderr
|
|
********************************************************************************************/
|
|
|
|
void errprintf (char *fmt, ...)
|
|
{
|
|
va_list args;
|
|
|
|
va_start(args, fmt); /* get pointer to argument list */
|
|
|
|
vfprintf(stderr, fmt, args); /* write errors to terminal (stderr) */
|
|
|
|
va_end(args);
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* asm_error - report an error to listing file and to user's console
|
|
********************************************************************************************/
|
|
|
|
void asm_error (char *fmt, ...)
|
|
{
|
|
va_list args;
|
|
|
|
if (pass == 1) /* only print on pass 2 */
|
|
return;
|
|
|
|
va_start(args, fmt); /* get pointer to argument list */
|
|
|
|
fprintf(stderr, "E: %s (%d): ", curfn, lno);
|
|
vfprintf(stderr, fmt, args); /* write errors to terminal (stderr) */
|
|
putc('\n', stderr);
|
|
|
|
if (flist != NULL && list_on) {
|
|
listout(FALSE);
|
|
line_error = TRUE;
|
|
|
|
fprintf(flist, "**** Error: ");
|
|
vfprintf(flist, fmt, args); /* write errors to listing file */
|
|
putc('\n', flist);
|
|
}
|
|
|
|
nerrors++;
|
|
va_end(args);
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* asm_warning - same but warnings are not counted
|
|
********************************************************************************************/
|
|
|
|
void asm_warning (char *fmt, ...)
|
|
{
|
|
va_list args;
|
|
|
|
if (pass == 1) /* only print on pass 2 */
|
|
return;
|
|
|
|
va_start(args, fmt); /* get pointer to argument list */
|
|
|
|
fprintf(stderr, "W: %s (%d): ", curfn, lno);
|
|
vfprintf(stderr, fmt, args); /* write errors to terminal (stderr) */
|
|
putc('\n', stderr);
|
|
|
|
if (flist != NULL && list_on) {
|
|
listout(FALSE);
|
|
line_error = TRUE;
|
|
|
|
fprintf(flist, "**** Warning: ");
|
|
vfprintf(flist, fmt, args); /* write errors to listing file */
|
|
putc('\n', flist);
|
|
}
|
|
|
|
nwarnings++;
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* sym_list - print the symbol table
|
|
********************************************************************************************/
|
|
|
|
void sym_list (void)
|
|
{
|
|
PSYMBOL s;
|
|
int n = 5;
|
|
|
|
if (symbols == NULL || flist == NULL)
|
|
return;
|
|
|
|
fprintf(flist, "\n=== SYMBOL TABLE ==============================================================\n");
|
|
|
|
for (s = symbols, n = 0; s != NULL; s = s->next) {
|
|
if (n >= 5) {
|
|
putc('\n', flist);
|
|
n = 0;
|
|
}
|
|
else if (n > 0)
|
|
fprintf(flist, " ");
|
|
|
|
fprintf(flist, "%-6s ", s->name);
|
|
if (s->defined == S_DEFINED)
|
|
fprintf(flist, "%04X%s", s->value & 0xFFFF, s->relative ? "R" : " ");
|
|
else
|
|
fprintf(flist, "UUUU ");
|
|
|
|
n++;
|
|
}
|
|
fprintf(flist, "\n");
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* passreport - report # of passes required for assembly on the 1130
|
|
********************************************************************************************/
|
|
|
|
void passreport (void)
|
|
{
|
|
PSYMBOL s;
|
|
|
|
for (s = symbols; s != NULL; s = s->next) {
|
|
if (s->defined == S_UNDEFINED || s->defined == S_PROVISIONAL) {
|
|
printf("There are undefined symbols. Cannot determine pass requirement.\n");
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (hasforward)
|
|
printf("There are forward references. Two passes are required.\n");
|
|
else
|
|
printf("There are no forward references. Only one pass is required.\n");
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* xref_list - print the cross-reference table
|
|
********************************************************************************************/
|
|
|
|
void xref_list (void)
|
|
{
|
|
int n = 0;
|
|
PXREF x;
|
|
PSYMBOL s;
|
|
|
|
if (flist == NULL || symbols == NULL)
|
|
return;
|
|
|
|
fprintf(flist, "\n=== CROSS REFERENCES ==========================================================\n");
|
|
|
|
if (symbols == NULL || flist == NULL)
|
|
return;
|
|
|
|
fprintf(flist, "Name Val Defd Referenced\n");
|
|
|
|
for (s = symbols; s != NULL; s = s->next) {
|
|
fprintf(flist, "%-5s %04X%s", s->name, s->value & 0xFFFF, s->relative ? "R" : " ");
|
|
|
|
for (x = s->xrefs; x != NULL; x = x->next)
|
|
if (x->definition)
|
|
break;
|
|
|
|
if (x == NULL)
|
|
fprintf(flist, "----");
|
|
else
|
|
fprintf(flist, " %4d", x->lno);
|
|
|
|
for (n = 0, x = s->xrefs; x != NULL; x = x->next) {
|
|
if (x->definition)
|
|
continue;
|
|
|
|
if (n >= 12) {
|
|
n = 0;
|
|
fprintf(flist, "\n ");
|
|
}
|
|
fprintf(flist, " %4d", x->lno);
|
|
n++;
|
|
}
|
|
putc('\n', flist);
|
|
}
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* listhdr - print a banner header in the listing file. Since it's not paginated
|
|
* at this time, this is not used often.
|
|
********************************************************************************************/
|
|
|
|
void listhdr (void)
|
|
{
|
|
time_t t;
|
|
|
|
time(&t);
|
|
fprintf(flist, "%s -- %s -- ", VERSION, dmsversion);
|
|
|
|
if (listoffset != 0) /* be sure to note difference in the listing */
|
|
fprintf(flist, "LIST OFFSET %04X -- ", listoffset & 0xFFFF);
|
|
|
|
fprintf(flist, "%s\n", ctime(&t));
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* astring - allocate a copy of a string
|
|
********************************************************************************************/
|
|
|
|
char *astring (char *str)
|
|
{
|
|
static char *s = NULL;
|
|
|
|
if (s != NULL)
|
|
if (strcmp(s, str) == 0) /* if same as immediately previous allocation */
|
|
return s; /* return same pointer (why did I do this?) */
|
|
|
|
if ((s = malloc(strlen(str)+1)) == NULL)
|
|
bail("out of memory");
|
|
|
|
strcpy(s, str);
|
|
return s;
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* lookup_symbol - get pointer to a symbol.
|
|
* If define is TRUE, creates and marks 'undefined' if not previously defined.
|
|
********************************************************************************************/
|
|
|
|
PSYMBOL lookup_symbol (char *name, BOOL define)
|
|
{
|
|
PSYMBOL s, n, prv = NULL;
|
|
int c;
|
|
char *at;
|
|
|
|
if (strlen(name) > 5) { /* (sigh) */
|
|
asm_error("Symbol '%s' is longer than 5 letters", name);
|
|
name[5] = '\0';
|
|
}
|
|
|
|
#ifdef FIX_ATS
|
|
while ((at = strchr(name, '@')) != NULL)
|
|
*at = '\'';
|
|
#endif
|
|
/* search sorted list of symbols */
|
|
for (s = symbols; s != NULL; prv = s, s = s->next) {
|
|
c = strcmpi(s->name, name);
|
|
if (c == 0)
|
|
return s;
|
|
if (c > 0)
|
|
break;
|
|
}
|
|
|
|
if (! define)
|
|
return NULL; /* not found */
|
|
|
|
if ((n = malloc(sizeof(SYMBOL))) == NULL)
|
|
bail("out of memory");
|
|
|
|
n->name = astring(name); /* symbol was undefined -- add it now */
|
|
n->value = 0;
|
|
n->defined = FALSE;
|
|
n->xrefs = NULL;
|
|
n->defined = FALSE;
|
|
|
|
n->next = s; /* link in alpha order */
|
|
|
|
if (prv == NULL) /* we stopped before first item in list */
|
|
symbols = n;
|
|
else
|
|
prv->next = n; /* insert after item before place we stopped */
|
|
|
|
return n;
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* add_xref - add a cross reference entry to a symbol
|
|
********************************************************************************************/
|
|
|
|
void add_xref (PSYMBOL s, BOOL definition)
|
|
{
|
|
PXREF x, prv = NULL, n;
|
|
|
|
if (pass == 1 || ! do_xref) /* define only during 2nd pass and only if listing was requested */
|
|
return;
|
|
|
|
for (x = s->xrefs; x != NULL; prv = x, x = x->next)
|
|
if (strcmpi(x->fname, curfn) == 0 && x->lno == lno)
|
|
return; /* ignore multiple refs on same line */
|
|
|
|
if ((n = malloc(sizeof(XREF))) == NULL)
|
|
bail("out of memory");
|
|
|
|
n->fname = astring(curfn);
|
|
n->lno = lno;
|
|
n->definition = definition;
|
|
|
|
n->next = x; /* link at end of existing list */
|
|
|
|
if (prv == NULL)
|
|
s->xrefs = n;
|
|
else
|
|
prv->next = n;
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* get_symbol - get a symbol value, defining if necessary
|
|
********************************************************************************************/
|
|
|
|
int get_symbol (char *name)
|
|
{
|
|
PSYMBOL s;
|
|
|
|
s = lookup_symbol(name, TRUE); /* lookup, define if necessary */
|
|
|
|
if (pass == 2) /* should be defined by now */
|
|
if (! s->defined)
|
|
asm_error("Symbol '%s' is undefined", name);
|
|
|
|
add_xref(s, FALSE); /* note the reference */
|
|
|
|
return s->value;
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* set_symbol - set a symbol value. Known = TRUE means we really know the value;
|
|
* FALSE means we're calculating it with forward referenced values or something like
|
|
* that.
|
|
********************************************************************************************/
|
|
|
|
void set_symbol (char *name, int value, int known, RELOC relative)
|
|
{
|
|
PSYMBOL s;
|
|
char *at;
|
|
|
|
if (strlen(name) > 5) {
|
|
asm_error("Symbol '%s' is longer than 5 letters", name);
|
|
name[5] = '\0';
|
|
}
|
|
|
|
#ifdef FIX_ATS
|
|
while ((at = strchr(name, '@')) != NULL)
|
|
*at = '\'';
|
|
#endif
|
|
|
|
s = lookup_symbol(name, TRUE);
|
|
|
|
if (s->defined == S_DEFINED) /* once defined, it should not change */
|
|
if (s->value != value)
|
|
asm_error("Symbol '%s' %s", name, (s->pass == pass) ? "is multiply defined" : "changed between passes");
|
|
|
|
s->value = value;
|
|
s->relative = relative;
|
|
s->defined = known ? S_DEFINED : S_PROVISIONAL;
|
|
s->pass = pass;
|
|
|
|
if (! known)
|
|
hasforward = TRUE;
|
|
|
|
add_xref(s, TRUE); /* record the place of definition */
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* skipbl - return pointer to first nonblank character in string s
|
|
********************************************************************************************/
|
|
|
|
char *skipbl (char *s)
|
|
{
|
|
while (*s && *s <= ' ')
|
|
s++;
|
|
|
|
return s;
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* gtok - extracts a whitespace-delimited token from the string pointed to by *pc;
|
|
* stores the token into the buffer tok and returns pointer to same. Returns NULL
|
|
* when there are no tokens. Best to call repeatedly with a pointer to the source
|
|
* buffer, e.g.
|
|
* char *pbuf = buf;
|
|
* while (gtok(&pbuf, token) != NULL) ...
|
|
********************************************************************************************/
|
|
|
|
char * gtok (char **pc, char *tok)
|
|
{
|
|
char *s = *pc, *otok = tok;
|
|
|
|
while (*s && *s <= ' ') /* skip blanks */
|
|
s++;
|
|
|
|
if (! *s) { /* no tokens to be found */
|
|
*tok = '\0';
|
|
*pc = s;
|
|
return NULL;
|
|
}
|
|
|
|
while (*s > ' ') /* save nonblanks into 'tok' */
|
|
*tok++ = *s++;
|
|
|
|
*tok = '\0'; /* terminate */
|
|
*pc = s; /* adjust caller's pointer */
|
|
|
|
return otok; /* return pointer to token */
|
|
}
|
|
|
|
/* listing format:
|
|
*
|
|
* ADDR CODE SOURCE
|
|
* 0000 0000 0000 0000 0000 | XXXXXXXXXXXXXXXXX
|
|
*/
|
|
|
|
/********************************************************************************************
|
|
* trim - remove trailing whitespace from string s
|
|
********************************************************************************************/
|
|
|
|
char *trim (char *s)
|
|
{
|
|
char *os = s, *nb;
|
|
|
|
for (nb = s-1; *s; s++)
|
|
if (*s > ' ')
|
|
nb = s;
|
|
|
|
nb[1] = '\0';
|
|
return os;
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* listout - emit current constructed output listing line held in "listline" and
|
|
* if "reset" is true, prepare listline for second and subsequent listing lines
|
|
* for a given input statement.
|
|
********************************************************************************************/
|
|
|
|
void listout (BOOL reset)
|
|
{
|
|
if (flist && list_on && ! line_error) {
|
|
trim(listline);
|
|
fputs(listline, flist);
|
|
putc('\n', flist);
|
|
if (reset)
|
|
sprintf(listline, LEFT_MARGIN, org);
|
|
}
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* storew - store a word in the output medium (hex or binary file). Most of the time
|
|
* writew is used. Advances the origin!
|
|
********************************************************************************************/
|
|
|
|
void storew (int word, RELOC relative)
|
|
{
|
|
if (pass == 2) { /* save in output (load) file. */
|
|
switch (outmode) {
|
|
case OUTMODE_BINARY:
|
|
bincard_writew(word, relative);
|
|
break;
|
|
|
|
case OUTMODE_LOAD:
|
|
fprintf(fout, " %04X%s" ENDLINE, word & 0xFFFF,
|
|
(relative == ABSOLUTE) ? "" : (relative == RELATIVE) ? "R" :
|
|
(relative == LIBF) ? "L" : (relative == CALL) ? "$" : "?");
|
|
break;
|
|
|
|
default:
|
|
bail("in storew, can't happen");
|
|
}
|
|
}
|
|
|
|
if (relative != LIBF)
|
|
org++;
|
|
|
|
assembled = TRUE; /* remember that we wrote something */
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* setw - store a word value in the current listing output line in position 'pos'.
|
|
********************************************************************************************/
|
|
|
|
void setw (int pos, int word, RELOC relative)
|
|
{
|
|
char tok[10], *p;
|
|
int i;
|
|
|
|
if (flist == NULL || ! list_on)
|
|
return;
|
|
|
|
sprintf(tok, "%04X", word & 0xFFFF);
|
|
|
|
for (i = 0, p = listline + 5*pos; i < 4; i++)
|
|
p[i] = tok[i];
|
|
|
|
if (relative == RELATIVE)
|
|
p[i] = 'R';
|
|
else if (relative != ABSOLUTE)
|
|
p[i] = '*';
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* writew - emit an assembled word value. Words are also displayed in the listing file.
|
|
* if relative is true, a relocation entry should be recorded.
|
|
********************************************************************************************/
|
|
|
|
void writew (int word, RELOC relative)
|
|
{ /* first, the listing stuff... */
|
|
if (nwout == 0) { /* on first output word, display address in column 0 */
|
|
setw(0, org+listoffset, FALSE);
|
|
}
|
|
else if (nwout >= 4) { /* if 4 words have already been written, start new line */
|
|
listout(TRUE);
|
|
nwout = 0;
|
|
}
|
|
|
|
nwout++;
|
|
setw(nwout, word, relative); /* display word in the listing line */
|
|
|
|
storew(word, relative); /* write it to the output medium */
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* setorg - take note of new load address
|
|
********************************************************************************************/
|
|
|
|
void setorg (int neworg)
|
|
{
|
|
if (pass == 2) {
|
|
setw(0, neworg+listoffset, FALSE); /* display in listing file in column 0 */
|
|
|
|
if (outmode == OUTMODE_LOAD) { /* write new load address to the output file */
|
|
fprintf(fout, "@%04X%s" ENDLINE, neworg & 0xFFFF, relocate ? "R" : "");
|
|
}
|
|
else {
|
|
bincard_setorg(neworg);
|
|
}
|
|
}
|
|
|
|
org = neworg;
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* org_even - force load address to an even address
|
|
********************************************************************************************/
|
|
|
|
void org_even (void)
|
|
{
|
|
if (org & 1)
|
|
setorg(org+1);
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* tabtok - get the token in tab-delimited column number i, from source string c,
|
|
* saving in string 'tok'. If save is nonnull, we copy the entire remainder of
|
|
* the input string in buffer 'save' (in contrast to 'tok' which gets only the
|
|
* first whitespace delimited token).
|
|
********************************************************************************************/
|
|
|
|
void tabtok (char *c, char *tok, int i, char *save)
|
|
{
|
|
*tok = '\0';
|
|
|
|
while (--i >= 0) { /* skip to i'th tab-delimited field */
|
|
if ((c = strchr(c, '\t')) == NULL) {
|
|
if (save) /* was none */
|
|
*save = '\0';
|
|
return;
|
|
}
|
|
c++;
|
|
}
|
|
|
|
while (*c == ' ') /* skip leading blanks */
|
|
c++;
|
|
|
|
if (save != NULL) /* save copy of entire remainder */
|
|
strcpy(save, c);
|
|
|
|
while (*c > ' ') { /* take up to any whitespace */
|
|
if (*c == '(') { /* if we start with a paren, take all up to closing paren including spaces */
|
|
while (*c && *c != ')')
|
|
*tok++ = *c++;
|
|
}
|
|
else if (*c == '.') { /* period means literal character following */
|
|
*tok++ = *c++;
|
|
if (*c)
|
|
*tok++ = *c++;
|
|
}
|
|
else
|
|
*tok++ = *c++;
|
|
}
|
|
|
|
*tok = '\0';
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* coltok - extract a token from string c, saving to buffer tok, by examining
|
|
* columns ifrom through ito only. If save is nonnull, the entire remainder
|
|
* of the input from ifrom to the end is saved there. In this routine
|
|
* if condense is true, we save all nonwhite characters in the column range;
|
|
* not the usual thing. This helps us coalesce the format, tag, & index things
|
|
* nto one string for the simple minded parser. If condense is FALSE, we terminate
|
|
* on the first nonblank, except that if we start with a (, we take up to ) and
|
|
* then terminate on a space.
|
|
*
|
|
* ifrom and ito on entry are column numbers, not indices; we change that right away
|
|
********************************************************************************************/
|
|
|
|
void coltok (char *c, char *tok, int ifrom, int ito, BOOL condense, char *save)
|
|
{
|
|
char *otok = tok;
|
|
int i;
|
|
|
|
ifrom--;
|
|
ito--;
|
|
|
|
for (i = 0; i < ifrom; i++) {
|
|
if (c[i] == '\0') { /* line ended before this column */
|
|
*tok = '\0';
|
|
if (save)
|
|
*save = '\0';
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (save) /* save from ifrom on */
|
|
strcpy(save, c+i);
|
|
|
|
if (condense) {
|
|
for (; i <= ito; i++) { /* save only nonwhite characters */
|
|
if (c[i] > ' ')
|
|
*tok++ = c[i];
|
|
}
|
|
}
|
|
else {
|
|
if (c[i] == ' ' && save != NULL)/* if it starts with a space, it's empty */
|
|
*save = '\0';
|
|
|
|
while (i <= ito) { /* take up to any whitespace */
|
|
if (c[i] <= ' ')
|
|
break;
|
|
else if (c[i] == '(') { /* starts with paren? take to close paren */
|
|
while (i <= ito && c[i]) {
|
|
if ((*tok++ = c[i++]) == ')')
|
|
break;
|
|
}
|
|
}
|
|
else if (c[i] == '.') { /* period means literal character following */
|
|
*tok++ = c[i++];
|
|
if (i <= ito && c[i])
|
|
*tok++ = c[i++];
|
|
}
|
|
else
|
|
*tok++ = c[i++];
|
|
}
|
|
}
|
|
|
|
*tok = '\0';
|
|
trim(otok);
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* opcode table
|
|
********************************************************************************************/
|
|
|
|
/* modifiers for the opcode definition table: */
|
|
|
|
#define L "L" /* long */
|
|
#define X "X" /* absolute displacement */
|
|
#define I "I" /* indirect */
|
|
#define IDX "0123" /* indexed (some LDX commands in the DMS source say LDX L0, so accept 0 */
|
|
#define E "E" /* even address */
|
|
#define NONE ""
|
|
#define ALL L X I IDX /* hope non-Microsoft C accepts and concatenates strings like this */
|
|
#define ANY "\xFF"
|
|
#define NUMS "0123456789"
|
|
|
|
#define IS_DBL 0x0001 /* double word operand implies even address */
|
|
#define IS_ABS 0x0002 /* always uses absolute addressing mode (implied X) */
|
|
#define NO_IDX 0x0004 /* even with 1 or 2 modifier, this is not really indexed (for STX/LDX) */
|
|
#define NO_ARGS 0x0008 /* statement takes no arguments */
|
|
#define IS_1800 0x0010 /* 1800-only directive or instruction, flagged if 1800 mode is not enabled */
|
|
#define TRAP 0x1000 /* debug this instruction */
|
|
|
|
struct tag_op { /* OPCODE TABLE */
|
|
char *mnem;
|
|
int opcode;
|
|
void (*handler)(struct tag_op *op, char *label, char *mods, char *arg);
|
|
char *mods_allowed;
|
|
char *mods_implied;
|
|
int flags;
|
|
};
|
|
/* special opcode handlers */
|
|
void std_op (struct tag_op *op, char *label, char *mods, char *arg);
|
|
void b_op (struct tag_op *op, char *label, char *mods, char *arg);
|
|
void bsc_op (struct tag_op *op, char *label, char *mods, char *arg);
|
|
void bsi_op (struct tag_op *op, char *label, char *mods, char *arg);
|
|
void mdx_op (struct tag_op *op, char *label, char *mods, char *arg);
|
|
void shf_op (struct tag_op *op, char *label, char *mods, char *arg);
|
|
|
|
void x_aif (struct tag_op *op, char *label, char *mods, char *arg);
|
|
void x_aifb (struct tag_op *op, char *label, char *mods, char *arg);
|
|
void x_ago (struct tag_op *op, char *label, char *mods, char *arg);
|
|
void x_agob (struct tag_op *op, char *label, char *mods, char *arg);
|
|
void x_anop (struct tag_op *op, char *label, char *mods, char *arg);
|
|
void x_abs (struct tag_op *op, char *label, char *mods, char *arg);
|
|
void x_call (struct tag_op *op, char *label, char *mods, char *arg);
|
|
void x_dsa (struct tag_op *op, char *label, char *mods, char *arg);
|
|
void x_file (struct tag_op *op, char *label, char *mods, char *arg);
|
|
void x_link (struct tag_op *op, char *label, char *mods, char *arg);
|
|
void x_libf (struct tag_op *op, char *label, char *mods, char *arg);
|
|
void x_org (struct tag_op *op, char *label, char *mods, char *arg);
|
|
void x_opt (struct tag_op *op, char *label, char *mods, char *arg);
|
|
void x_ces (struct tag_op *op, char *label, char *mods, char *arg);
|
|
void x_bes (struct tag_op *op, char *label, char *mods, char *arg);
|
|
void x_bss (struct tag_op *op, char *label, char *mods, char *arg);
|
|
void x_dc (struct tag_op *op, char *label, char *mods, char *arg);
|
|
void x_dec (struct tag_op *op, char *label, char *mods, char *arg);
|
|
void x_decs (struct tag_op *op, char *label, char *mods, char *arg);
|
|
void x_ebc (struct tag_op *op, char *label, char *mods, char *arg);
|
|
void x_end (struct tag_op *op, char *label, char *mods, char *arg);
|
|
void x_ent (struct tag_op *op, char *label, char *mods, char *arg);
|
|
void x_epr (struct tag_op *op, char *label, char *mods, char *arg);
|
|
void x_equ (struct tag_op *op, char *label, char *mods, char *arg);
|
|
void x_exit (struct tag_op *op, char *label, char *mods, char *arg);
|
|
void x_ils (struct tag_op *op, char *label, char *mods, char *arg);
|
|
void x_iss (struct tag_op *op, char *label, char *mods, char *arg);
|
|
void x_libr (struct tag_op *op, char *label, char *mods, char *arg);
|
|
void x_lorg (struct tag_op *op, char *label, char *mods, char *arg);
|
|
void x_dmes (struct tag_op *op, char *label, char *mods, char *arg);
|
|
void x_dn (struct tag_op *op, char *label, char *mods, char *arg);
|
|
void x_dump (struct tag_op *op, char *label, char *mods, char *arg);
|
|
void x_pdmp (struct tag_op *op, char *label, char *mods, char *arg);
|
|
void x_hdng (struct tag_op *op, char *label, char *mods, char *arg);
|
|
void x_list (struct tag_op *op, char *label, char *mods, char *arg);
|
|
void x_spac (struct tag_op *op, char *label, char *mods, char *arg);
|
|
void x_spr (struct tag_op *op, char *label, char *mods, char *arg);
|
|
void x_ejct (struct tag_op *op, char *label, char *mods, char *arg);
|
|
void x_trap (struct tag_op *op, char *label, char *mods, char *arg);
|
|
void x_xflc (struct tag_op *op, char *label, char *mods, char *arg);
|
|
|
|
struct tag_op ops[] = {
|
|
".OPT", 0, x_opt, NONE, NONE, 0, /* non-IBM extensions */
|
|
"TRAP", 0, x_trap, NONE, NONE, 0, /* assembler breakpoint trap */
|
|
".CES", 0, x_ces, NONE, NONE, 0, /* lets us specify simulated console entry switch values for startup */
|
|
|
|
"ABS", 0, x_abs, NONE, NONE, 0,
|
|
"BES", 0, x_bes, E, NONE, 0, /* standard pseudo-ops */
|
|
"BSS", 0, x_bss, E, NONE, 0,
|
|
"DC", 0, x_dc, NONE, NONE, 0,
|
|
"DEC", 0, x_dec, E, E, IS_DBL,
|
|
"DECS", 0, x_decs, E, E, IS_DBL, /* this is an IBM 1800 directive */
|
|
"DMES", 0, x_dmes, ANY, NONE, 0,
|
|
"DN", 0, x_dn, NONE, NONE, 0,
|
|
"DSA", 0, x_dsa, NONE, NONE, 0,
|
|
"DUMP", 0, x_dump, NONE, NONE, 0,
|
|
"EBC", 0, x_ebc, NONE, NONE, 0,
|
|
"EJCT", 0, x_ejct, NONE, NONE, 0,
|
|
"END", 0, x_end, NONE, NONE, 0,
|
|
"ENT", 0, x_ent, NONE, NONE, 0,
|
|
"EPR", 0, x_epr, NONE, NONE, 0,
|
|
"EQU", 0, x_equ, NONE, NONE, 0,
|
|
"EXIT", 0, x_exit, NONE, NONE, 0, /* alias for call $exit since we don't have macros yet */
|
|
"FILE", 0, x_file, NONE, NONE, 0,
|
|
"HDNG", 0, x_hdng, ANY, NONE, 0,
|
|
"ILS", 0, x_ils, NUMS, NONE, 0,
|
|
"ISS", 0, x_iss, NUMS, NONE, 0,
|
|
"LIBF", 0, x_libf, NONE, NONE, 0,
|
|
"LIBR", 0, x_libr, NONE, NONE, 0,
|
|
"LINK", 0, x_link, NONE, NONE, 0,
|
|
"LIST", 0, x_list, NONE, NONE, 0,
|
|
"LORG", 0, x_lorg, NONE, NONE, 0,
|
|
"ORG", 0, x_org, NONE, NONE, 0,
|
|
"PDMP", 0, x_pdmp, NONE, NONE, 0,
|
|
"SPAC", 0, x_spac, NONE, NONE, 0,
|
|
"SPR", 0, x_spr, NONE, NONE, 0,
|
|
"XFLC", 0, x_xflc, NONE, NONE, 0,
|
|
|
|
"A", 0x8000, std_op, ALL, NONE, 0, /* standard addressing ops */
|
|
"AD", 0x8800, std_op, ALL, NONE, IS_DBL,
|
|
"AND", 0xE000, std_op, ALL, NONE, 0,
|
|
"BSI", 0x4000, bsi_op, ALL, NONE, 0,
|
|
"CALL", 0x4000, x_call, ALL, L, 0, /* alias for BSI L, or external call */
|
|
"CMP", 0xB000, std_op, ALL, NONE, IS_1800, /* this is an IBM 1800-only instruction */
|
|
"DCM", 0xB800, std_op, ALL, NONE, IS_1800, /* this is an IBM 1800-only instruction */
|
|
"D" , 0xA800, std_op, ALL, NONE, 0,
|
|
"EOR", 0xF000, std_op, ALL, NONE, 0,
|
|
"LD", 0xC000, std_op, ALL, NONE, 0,
|
|
"LDD", 0xC800, std_op, ALL, NONE, IS_DBL,
|
|
"LDS", 0x2000, std_op, NONE, NONE, IS_ABS,
|
|
"LDX", 0x6000, std_op, ALL, NONE, IS_ABS|NO_IDX,
|
|
"M", 0xA000, std_op, ALL, NONE, 0,
|
|
"MDX", 0x7000, mdx_op, ALL, NONE, 0,
|
|
"MDM", 0x7000, mdx_op, L, L, 0, /* like MDX L */
|
|
"NOP", 0x1000, std_op, NONE, NONE, NO_ARGS,
|
|
"OR", 0xE800, std_op, ALL, NONE, 0,
|
|
"S", 0x9000, std_op, ALL, NONE, 0,
|
|
"SD", 0x9800, std_op, ALL, NONE, IS_DBL,
|
|
"STD", 0xD800, std_op, ALL, NONE, IS_DBL,
|
|
"STO", 0xD000, std_op, ALL, NONE, 0,
|
|
"STS", 0x2800, std_op, ALL, NONE, 0,
|
|
"STX", 0x6800, std_op, ALL, NONE, NO_IDX,
|
|
"WAIT", 0x3000, std_op, NONE, NONE, IS_ABS,
|
|
"XCH", 0x18D0, std_op, NONE, NONE, 0, /* same as RTE 16, 18C0 + 10 */
|
|
"XIO", 0x0800, std_op, ALL, NONE, IS_DBL,
|
|
|
|
"BSC", 0x4800, bsc_op, ALL, NONE, 0, /* branch family */
|
|
"BOSC", 0x4840, bsc_op, ALL, NONE, 0, /* is BOSC always long form? No. */
|
|
"SKP", 0x4800, bsc_op, NONE, NONE, 0, /* alias for BSC one word version */
|
|
|
|
"B", 0x4800, b_op, ALL, NONE, 0, /* alias for MDX or BSC L */
|
|
"BC", 0x4802, std_op, ALL, L, 0, /* alias for BSC L */
|
|
"BN", 0x4828, std_op, ALL, L, 0, /* alias for BSC L */
|
|
"BNN", 0x4810, std_op, ALL, L, 0, /* alias for BSC L */
|
|
"BNP", 0x4808, std_op, ALL, L, 0, /* alias for BSC L */
|
|
"BNZ", 0x4820, std_op, ALL, L, 0, /* alias for BSC L */
|
|
"BO", 0x4801, std_op, ALL, L, 0, /* alias for BSC L */
|
|
"BOD", 0x4804, std_op, ALL, L, 0, /* alias for BSC L */
|
|
"BP", 0x4830, std_op, ALL, L, 0, /* alias for BSC L */
|
|
"BZ", 0x4818, std_op, ALL, L, 0, /* alias for BSC L */
|
|
|
|
"RTE", 0x18C0, shf_op, IDX X, X, 0, /* shift family */
|
|
"SLA", 0x1000, shf_op, IDX X, X, 0,
|
|
"SLC", 0x10C0, shf_op, IDX X, X, 0,
|
|
"SLCA", 0x1040, shf_op, IDX X, X, 0,
|
|
"SLT", 0x1080, shf_op, IDX X, X, 0,
|
|
"SRA", 0x1800, shf_op, IDX X, X, 0,
|
|
"SRT", 0x1880, shf_op, IDX X, X, 0,
|
|
|
|
"AIF", 0, x_aif, NONE, NONE, 0, /* assemble if */
|
|
"AIFB", 0, x_aifb, NONE, NONE, 0, /* assemble if */
|
|
"AGO", 0, x_ago, NONE, NONE, 0, /* assemble goto */
|
|
"AGOB", 0, x_agob, NONE, NONE, 0, /* assemble goto */
|
|
"ANOP", 0, x_anop, NONE, NONE, 0, /* assemble target */
|
|
|
|
NULL /* end of table */
|
|
};
|
|
|
|
/********************************************************************************************
|
|
* addextn - apply file extension 'extn' to filename 'fname' and put result in 'outbuf'
|
|
* if outbuf is NULL, we allocate a buffer
|
|
********************************************************************************************/
|
|
|
|
char *addextn (char *fname, char *extn, char *outbuf)
|
|
{
|
|
char *buf, line[500], *c;
|
|
|
|
buf = (outbuf == NULL) ? line : outbuf;
|
|
|
|
strcpy(buf, fname); /* create listfn from first source filename (e.g. xxx.lst); */
|
|
if ((c = strrchr(buf, '\\')) == NULL)
|
|
if ((c = strrchr(buf, '/')) == NULL)
|
|
if ((c = strrchr(buf, ':')) == NULL)
|
|
c = buf;
|
|
|
|
if ((c = strrchr(c, '.')) == NULL)
|
|
strcat(buf, extn);
|
|
else
|
|
strcpy(c, extn);
|
|
|
|
return (outbuf == NULL) ? astring(line) : outbuf;
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* controlcard - examine an assembler control card (* in column 1)
|
|
********************************************************************************************/
|
|
|
|
BOOL controlcard (char *line)
|
|
{
|
|
if (strnicmp(line, "*LIST", 5) == 0) { /* turn on listing file even if not specified on command line */
|
|
do_list = list_on = TRUE;
|
|
return TRUE;
|
|
}
|
|
|
|
if (strnicmp(line, "*XREF", 5) == 0) {
|
|
do_xref = TRUE;
|
|
return TRUE;
|
|
}
|
|
|
|
if (strnicmp(line, "*PRINT SYMBOL TABLE", 19) == 0) {
|
|
do_syms = TRUE;
|
|
return TRUE;
|
|
}
|
|
|
|
if (strnicmp(line, "*SAVE SYMBOL TABLE", 18) == 0) {
|
|
savetable = TRUE;
|
|
return TRUE;
|
|
}
|
|
|
|
if (strnicmp(line, "*SYSTEM SYMBOL TABLE", 20) == 0) {
|
|
preload = TRUE;
|
|
preload_symbols();
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* stuff - insert characters into a line
|
|
********************************************************************************************/
|
|
|
|
void stuff (char *buf, char *tok, int maxchars)
|
|
{
|
|
while (*tok) {
|
|
*buf++ = *tok++;
|
|
|
|
if (maxchars)
|
|
if (--maxchars <= 0)
|
|
break;
|
|
}
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* format_line - construct a source code input line from components
|
|
********************************************************************************************/
|
|
|
|
void format_line (char *buf, char *label, char *op, char *mods, char *args, char *remarks)
|
|
{
|
|
int i;
|
|
|
|
if (tabformat) {
|
|
sprintf(buf, "%s\t%s\t%s\t%s\t%s", label, op, mods, args, remarks);
|
|
}
|
|
else {
|
|
for (i = 0; i < 72; i++)
|
|
buf[i] = ' ';
|
|
buf[i] = '\0';
|
|
|
|
stuff(buf+20, label, 5);
|
|
stuff(buf+26, op, 4);
|
|
stuff(buf+31, mods, 2);
|
|
stuff(buf+34, args, 72-34);
|
|
}
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* lookup_op - find an opcode
|
|
********************************************************************************************/
|
|
|
|
struct tag_op * lookup_op (char *mnem)
|
|
{
|
|
struct tag_op *op;
|
|
int i;
|
|
|
|
for (op = ops; op->mnem != NULL; op++) {
|
|
if ((i = strcmp(op->mnem, mnem)) == 0)
|
|
return op;
|
|
|
|
if (i > 0)
|
|
break;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* bincard - routines to write IBM 1130 Card object format
|
|
********************************************************************************************/
|
|
|
|
unsigned short bincard[54]; /* the 54 data words that can fit on a binary format card */
|
|
char binflag[45]; /* the relocation flags of the 45 buffered object words (0, 1, 2, 3) */
|
|
int bincard_n = 0; /* number of object words stored in bincard (0-45) */
|
|
int bincard_seq = 0; /* card output sequence number */
|
|
int bincard_org = 0; /* origin of current card-full */
|
|
int bincard_maxaddr = 0;
|
|
BOOL bincard_first = TRUE; /* TRUE when we're to write the program type card */
|
|
|
|
/********************************************************************************************
|
|
* bincard_init - prepare a new object data output card
|
|
********************************************************************************************/
|
|
|
|
void bincard_init (void)
|
|
{
|
|
memset(bincard, 0, sizeof(bincard)); /* clear card data */
|
|
memset(binflag, 0, sizeof(binflag)); /* clear relocation data */
|
|
bincard_n = 0; /* no data */
|
|
bincard[0] = bincard_org; /* store load address */
|
|
bincard_maxaddr = MAX(bincard_maxaddr, bincard_org-1); /* save highest address written-to (this may be a BSS) */
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* binard_writecard - emit a card. sbrk_text = NULL for normal data cards, points to comment text for sbrk card
|
|
* note: sbrk_text if not NULL MUST be a writeable buffer of at LEAST 71 characters
|
|
********************************************************************************************/
|
|
|
|
void bincard_writecard (char *sbrk_text)
|
|
{
|
|
unsigned short binout[80];
|
|
char ident[12];
|
|
int i, j;
|
|
/* this is an SBRK record */
|
|
if (sbrk_text != NULL) { /* sbrk card has 4 binary words followed by comment text */
|
|
for (j = 66; j < 71; j++) /* be sure input columns 67..71 are nonblank (have version number) */
|
|
if (sbrk_text[j] <= ' ')
|
|
break;
|
|
|
|
if (j < 71) /* sbrk card didn't have the info, stuff in current release */
|
|
for (j = 0; j < 5; j++)
|
|
sbrk_text[66+j] = dmsversion[j];
|
|
|
|
binout[0] = 0;
|
|
binout[1] = 0;
|
|
binout[2] = 0;
|
|
binout[3] = 0x1000;
|
|
// V1.19 - in previous versions of asm1130, binout[4] was left unset, random
|
|
binout[4] = 0;
|
|
|
|
sbrk_text += 5; /* start at the real column 6 (after *SBRK */
|
|
for (j = 5; j < 72; j++)
|
|
binout[j] = (*sbrk_text) ? ascii_to_hollerith(*sbrk_text++) : 0;
|
|
|
|
}
|
|
else { /* binary card format packs 54 words into 72 columns */
|
|
for (i = j = 0; i < 54; i += 3, j += 4) {
|
|
binout[j ] = ( bincard[i] & 0xFFF0);
|
|
binout[j+1] = ((bincard[i] << 12) & 0xF000) | ((bincard[i+1] >> 4) & 0x0FF0);
|
|
binout[j+2] = ((bincard[i+1] << 8) & 0xFF00) | ((bincard[i+2] >> 8) & 0x00F0);
|
|
binout[j+3] = ((bincard[i+2] << 4) & 0xFFF0);
|
|
}
|
|
}
|
|
|
|
sprintf(ident, "%08ld", ++bincard_seq); /* append sequence text */
|
|
memmove(ident, progname, MIN(strlen(progname), 4));
|
|
|
|
for (i = 0; i < 8; i++)
|
|
binout[j++] = ascii_to_hollerith(ident[i]);
|
|
|
|
fxwrite(binout, sizeof(binout[0]), 80, fout); /* write card image */
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* binard_writedata - emit an object data card
|
|
********************************************************************************************/
|
|
|
|
void bincard_writedata (void)
|
|
{
|
|
unsigned short rflag = 0;
|
|
int i, j, nflag = 0;
|
|
|
|
bincard[1] = 0; /* checksum */
|
|
bincard[2] = 0x0A00 | bincard_n; /* data card type + word count */
|
|
|
|
for (i = 0, j = 3; i < bincard_n; i++) { /* construct relocation indicator bitmap */
|
|
if (nflag == 8) {
|
|
bincard[j++] = rflag;
|
|
rflag = 0;
|
|
nflag = 0;
|
|
}
|
|
rflag = (rflag << 2) | (binflag[i] & 3);
|
|
nflag++;
|
|
}
|
|
|
|
if (nflag > 0)
|
|
bincard[j] = rflag << (16 - 2*nflag);
|
|
|
|
bincard_writecard(FALSE); /* emit the card */
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* bincard_flush - flush any pending binary data
|
|
********************************************************************************************/
|
|
|
|
void bincard_flush (void)
|
|
{
|
|
if (bincard_n > 0)
|
|
bincard_writedata();
|
|
|
|
bincard_init();
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* bincard_sbrk - emit an SBRK card
|
|
********************************************************************************************/
|
|
|
|
void bincard_sbrk (char *line)
|
|
{
|
|
if (bincard_first)
|
|
bincard_typecard();
|
|
else
|
|
bincard_flush();
|
|
|
|
bincard_writecard(line);
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* bincard_setorg - set the origin
|
|
********************************************************************************************/
|
|
|
|
void bincard_setorg (int neworg)
|
|
{
|
|
bincard_org = neworg; /* set origin for next card */
|
|
bincard_flush(); /* flush any current data & store origin */
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* bincard_endcard - write end of program card
|
|
********************************************************************************************/
|
|
|
|
void bincard_endcard (void)
|
|
{
|
|
bincard_flush();
|
|
|
|
bincard[0] = (bincard_maxaddr + 2) & ~1; /* effective length: add 1 to max origin, then 1 more to round up */
|
|
bincard[1] = 0;
|
|
bincard[2] = 0x0F00;
|
|
bincard[3] = pta & 0xFFFF;
|
|
|
|
bincard_writecard(NULL);
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* bincard_typecard - write the program type
|
|
********************************************************************************************/
|
|
|
|
void bincard_typecard (void)
|
|
{
|
|
int i;
|
|
|
|
if (! bincard_first)
|
|
return;
|
|
|
|
bincard_first = FALSE;
|
|
|
|
memset(bincard, 0, sizeof(bincard));
|
|
|
|
bincard[2] = (unsigned short) ((progtype << 8) | intmode | realmode);
|
|
|
|
/* all indices not listed are documented as 'reserved' */
|
|
|
|
switch (progtype) {
|
|
case PROGTYPE_ABSOLUTE:
|
|
case PROGTYPE_RELOCATABLE:
|
|
/* bincard[ 4] = 0; // length of common (fortran only) */
|
|
bincard[ 5] = 0x0003;
|
|
/* bincard[ 6] = 0; // length of work area (fortran only) */
|
|
bincard[ 8] = ndefined_files;
|
|
namecode(&bincard[9], progname);
|
|
bincard[11] = (pta < 0) ? 0 : pta;
|
|
break;
|
|
|
|
case PROGTYPE_LIBF:
|
|
case PROGTYPE_CALL:
|
|
bincard[ 5] = 3*nentries;
|
|
for (i = 0; i < nentries; i++) {
|
|
namecode(&bincard[9+3*i], entry[i]->name);
|
|
bincard[11+3*i] = entry[i]->value;
|
|
}
|
|
break;
|
|
|
|
case PROGTYPE_ISSLIBF:
|
|
case PROGTYPE_ISSCALL:
|
|
bincard[ 5] = 6+nintlevels;
|
|
namecode(&bincard[9], entry[0]->name);
|
|
bincard[11] = entry[0]->value;
|
|
bincard[12] = iss_number + ISTV; /* magic number ISTV is 0x33 in DMS R2V12 */
|
|
bincard[13] = iss_number;
|
|
bincard[14] = nintlevels;
|
|
bincard[15] = intlevel_primary;
|
|
bincard[16] = intlevel_secondary;
|
|
bincard[29] = 1;
|
|
break;
|
|
|
|
case PROGTYPE_ILS:
|
|
bincard[ 2] = (unsigned short) (progtype << 8);
|
|
bincard[ 5] = 4;
|
|
bincard[12] = intlevel_primary;
|
|
break;
|
|
|
|
default:
|
|
bail("in bincard_typecard, can't happen");
|
|
}
|
|
|
|
bincard[1] = 0; /* checksum */
|
|
|
|
bincard_writecard(NULL);
|
|
|
|
bincard_init();
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* bincard_writew - write a word to the current output card.
|
|
********************************************************************************************/
|
|
|
|
void bincard_writew (int word, RELOC relative)
|
|
{
|
|
if (pass != 2)
|
|
return;
|
|
|
|
if (bincard_first)
|
|
bincard_typecard();
|
|
else if (bincard_n >= 45) /* flush full card buffer */
|
|
bincard_flush();
|
|
|
|
binflag[bincard_n] = relative & 3; /* store relocation bits and data word */
|
|
bincard[9+bincard_n++] = word;
|
|
|
|
if (relative != LIBF) {
|
|
bincard_maxaddr = MAX(bincard_maxaddr, bincard_org);
|
|
bincard_org++;
|
|
}
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* writetwo - notification that we are about to write two words which must stay together
|
|
********************************************************************************************/
|
|
|
|
void writetwo (void)
|
|
{
|
|
if (pass == 2 && outmode == OUTMODE_BINARY && bincard_n >= 44)
|
|
bincard_flush();
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* handle_sbrk - handle an SBRK directive.
|
|
* This was not part of the 1130 assembler; they must have assembled DMS on a 360 using a cross assembler
|
|
********************************************************************************************/
|
|
|
|
void handle_sbrk (char *line)
|
|
{
|
|
char rline[90];
|
|
|
|
if (pass != 2)
|
|
return;
|
|
|
|
strncpy(rline, line, 81); /* get a copy and pad it if necessary to 80 characters */
|
|
rline[80] = '\0';
|
|
while (strlen(rline) < 80)
|
|
strcat(rline, " ");
|
|
|
|
switch (outmode) {
|
|
case OUTMODE_LOAD:
|
|
fprintf(fout, "#SBRK%s\n", trim(rline+5));
|
|
|
|
case OUTMODE_BINARY:
|
|
bincard_sbrk(rline);
|
|
break;
|
|
|
|
default:
|
|
bail("in handle_sbrk, can't happen");
|
|
}
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* namecode - turn a string into a two-word packed name
|
|
********************************************************************************************/
|
|
|
|
void namecode (unsigned short *words, char *tok)
|
|
{
|
|
long val = 0;
|
|
int i, ch;
|
|
|
|
for (i = 0; i < 5; i++) { /* pick up bits */
|
|
if (*tok)
|
|
ch = *tok++;
|
|
else
|
|
ch = ' ';
|
|
|
|
val = (val << 6) | (ascii_to_ebcdic_table[ch] & 0x3F);
|
|
}
|
|
|
|
words[0] = (unsigned short) (val >> 16);
|
|
words[1] = (unsigned short) val;
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* parse_line - parse one input line.
|
|
********************************************************************************************/
|
|
|
|
void parse_line (char *line)
|
|
{
|
|
char label[100], mnem[100], arg[200], mods[20], *c;
|
|
struct tag_op *op;
|
|
|
|
if (line[0] == '/' && line[1] == '/') /* job control card? probably best to ignore it */
|
|
return;
|
|
|
|
if (line[0] == '*') { /* control card comment or comment in tab-format file */
|
|
if (check_control) /* pay attention to control cards only at top of file */
|
|
if (! controlcard(line))
|
|
check_control = FALSE; /* first non-control card shuts off sensitivity to them */
|
|
|
|
if (strnicmp(line+1, "SBRK", 4) == 0)
|
|
handle_sbrk(line);
|
|
|
|
return;
|
|
}
|
|
|
|
check_control = FALSE; /* non-control card, consider them no more */
|
|
|
|
label[0] = '\0'; /* prepare to extract fields */
|
|
mods[0] = '\0';
|
|
mnem[0] = '\0';
|
|
arg[0] = '\0';
|
|
|
|
if (tabformat || strchr(line, '\t') != NULL) { /* if input line has tabs, parse loosely */
|
|
tabformat = TRUE; /* this is a tab-formatted file */
|
|
|
|
for (c = line; *c && *c <= ' '; c++) /* find first nonblank */
|
|
;
|
|
|
|
if (*c == '*' || ! *c) /* ignore as a comment */
|
|
return;
|
|
|
|
tabtok(line, label, 0, NULL);
|
|
tabtok(line, mnem, 1, NULL);
|
|
tabtok(line, mods, 2, NULL);
|
|
tabtok(line, arg, 3, opfield);
|
|
}
|
|
else { /* if no tabs, use strict card-column format */
|
|
if (line[20] == '*') /* comment */
|
|
return;
|
|
|
|
line[72] = '\0'; /* clip off sequence */
|
|
|
|
coltok(line, label, 21, 25, TRUE, NULL);
|
|
coltok(line, mnem, 27, 30, TRUE, NULL);
|
|
coltok(line, mods, 32, 33, TRUE, NULL);
|
|
coltok(line, arg, 35, 72, FALSE, opfield);
|
|
}
|
|
|
|
if (*label) /* display org in any line with a label */
|
|
setw(0, org+listoffset, FALSE);
|
|
|
|
if (! *mnem) { /* label w/o mnemonic, just define the symbol */
|
|
if (*label)
|
|
set_symbol(label, org, TRUE, relocate);
|
|
return;
|
|
}
|
|
|
|
if ((op = lookup_op(mnem)) == NULL) { /* look up mnemonic */
|
|
if (*label)
|
|
set_symbol(label, org, TRUE, relocate);/* at least define the label */
|
|
|
|
asm_error("Unknown opcode '%s'", mnem);
|
|
return;
|
|
}
|
|
|
|
if (op->flags & TRAP) /* assembler debugging breakpoint */
|
|
x_trap(op, label, mods, arg);
|
|
|
|
if (*op->mods_allowed != '\xFF') { /* validate modifiers against list of allowed characters */
|
|
for (c = mods; *c; ) {
|
|
if (strchr(op->mods_allowed, *c) == NULL) {
|
|
asm_warning("Modifier '%c' not permitted", *c);
|
|
strcpy(c, c+1); /* remove it and keep parsing */
|
|
}
|
|
else
|
|
c++;
|
|
}
|
|
}
|
|
|
|
strcat(mods, op->mods_implied); /* tack on implied modifiers */
|
|
|
|
if (strchr(mods, 'I')) /* indirect implies long */
|
|
strcat(mods, "L");
|
|
|
|
requires_even_address = op->flags & IS_DBL;
|
|
|
|
org_advanced = strchr(mods, 'L') ? 2 : 1; /* by default, * means address + 1 or 2. Sometimes it doesn't */
|
|
(op->handler)(op, label, mods, arg);
|
|
|
|
if ((op->flags & IS_1800) && ! enable_1800)
|
|
asm_warning("%s is IBM 1800-specific; use the -8 command line option", op->mnem);
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* get one input line from current file or macro
|
|
********************************************************************************************/
|
|
|
|
BOOL get_line (char *buf, int nbuf, BOOL onelevel)
|
|
{
|
|
char *retval;
|
|
|
|
if (ended) /* we hit the END command */
|
|
return FALSE;
|
|
|
|
/* if macro active, return line from macro buffer, otherwise read from file */
|
|
/* do not pop end-of-macro if onelevel is TRUE */
|
|
|
|
if ((retval = fgets(buf, nbuf, fin)) == NULL)
|
|
return FALSE;
|
|
|
|
lno++; /* count the line */
|
|
return TRUE;
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* proc - process one pass of one source file
|
|
********************************************************************************************/
|
|
|
|
void proc (char *fname)
|
|
{
|
|
char line[256], *c;
|
|
int i;
|
|
|
|
if (strchr(fname, '.') == NULL) /* if input file has no extension, */
|
|
addextn(fname, ".asm", curfn); /* set appropriate file extension */
|
|
else
|
|
strcpy(curfn, fname); /* otherwise use extension specified */
|
|
|
|
/* let's leave filename case alone even if it doesn't matter */
|
|
/*#if (defined(_WIN32) || defined(VMS)) */
|
|
/* upcase(curfn); // only force uppercase of name on Windows and VMS */
|
|
/*#endif */
|
|
|
|
if (progname[0] == '\0') { /* pick up primary filename */
|
|
if ((c = strrchr(curfn, '\\')) == NULL)
|
|
if ((c = strrchr(curfn, '/')) == NULL)
|
|
if ((c = strrchr(curfn, ':')) == NULL)
|
|
c = curfn;
|
|
|
|
strncpy(progname, c, sizeof(progname)); /* take name after path */
|
|
progname[sizeof(progname)-1] = '\0';
|
|
if ((c = strchr(progname, '.')) != NULL)/* remove extension */
|
|
*c = '\0';
|
|
}
|
|
|
|
lno = 0; /* reset global input line number */
|
|
ended = FALSE; /* have not seen END statement */
|
|
|
|
if (listfn == NULL) /* if list file name is undefined, */
|
|
listfn = addextn(fname, ".lst", NULL); /* create from first filename */
|
|
|
|
if (verbose)
|
|
fprintf(stderr, "--- Starting file %s pass %d\n", curfn, pass);
|
|
|
|
if ((fin = fopen(curfn, "r")) == NULL) {
|
|
perror(curfn); /* oops */
|
|
exit(1);
|
|
}
|
|
|
|
if (flist) { /* put banner in listing file */
|
|
strcpy(listline,"=== FILE ======================================================================");
|
|
for (i = 9, c = curfn; *c;)
|
|
listline[i++] = *c++;
|
|
listline[i] = ' ';
|
|
fputs(listline, flist);
|
|
putc('\n', flist);
|
|
list_on = TRUE;
|
|
}
|
|
/* read all lines till EOF or END statement */
|
|
while (get_line(line, sizeof(line), FALSE)) {
|
|
prep_line(line); /* preform standard line prep */
|
|
parse_line(line); /* parse */
|
|
listout(FALSE); /* complete the listing */
|
|
}
|
|
|
|
fclose(fin);
|
|
|
|
if (n_literals > 0) { /* force out any pending literal constants at end of file */
|
|
output_literals(TRUE);
|
|
listout(FALSE);
|
|
}
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* prep_line - prepare input line for parsing
|
|
********************************************************************************************/
|
|
|
|
void prep_line (char *line)
|
|
{
|
|
char *c;
|
|
|
|
upcase(line); /* uppercase it */
|
|
nwout = 0; /* number of words output so far */
|
|
line_error = FALSE; /* no errors on this line so far */
|
|
|
|
for (c = line; *c; c++) { /* truncate at newline */
|
|
if (*c == '\r' || *c == '\n') {
|
|
*c = '\0';
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (flist && list_on) { /* construct beginning of listing line */
|
|
if (tabformat)
|
|
sprintf(listline, LINEFORMAT, lno, detab(line));
|
|
else {
|
|
if (strlen(line) > 20) /* get the part where the commands start */
|
|
c = line+20;
|
|
else
|
|
c = "";
|
|
|
|
sprintf(listline, LINEFORMAT, lno, c);
|
|
stuff(listline, line, 20); /* stuff the left margin in to the left side */
|
|
}
|
|
}
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* opcmp - operand name comparison routine for qsort
|
|
********************************************************************************************/
|
|
|
|
int opcmp (const void *a, const void *b)
|
|
{
|
|
return strcmp(((struct tag_op *) a)->mnem, ((struct tag_op *) b)->mnem);
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* preload_symbols - load a saved symbol table
|
|
********************************************************************************************/
|
|
|
|
void preload_symbols (void)
|
|
{
|
|
FILE *fd;
|
|
char str[200], sym[20];
|
|
int v;
|
|
static BOOL preloaded_already = FALSE;
|
|
|
|
if (pass > 1 || preloaded_already)
|
|
return;
|
|
|
|
preloaded_already = TRUE;
|
|
|
|
if ((fd = fopen(SYSTEM_TABLE, "r")) == NULL) /* read the system symbol tabl */
|
|
perror(SYSTEM_TABLE);
|
|
else {
|
|
while (fgets(str, sizeof(str), fd) != NULL) {
|
|
if (sscanf(str, "%s %x", sym, &v) == 2)
|
|
set_symbol(sym, v, TRUE, FALSE);
|
|
}
|
|
fclose(fd);
|
|
}
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* save_symbols - save a symbol table
|
|
********************************************************************************************/
|
|
|
|
void save_symbols (void)
|
|
{
|
|
FILE *fd;
|
|
char str[20];
|
|
PSYMBOL s;
|
|
|
|
if (relocate) {
|
|
fprintf(stderr, "Can't save symbol table unless ABS assembly\n");
|
|
return;
|
|
}
|
|
|
|
if ((fd = fopen(SYSTEM_TABLE, "r")) != NULL) {
|
|
fclose(fd);
|
|
if (saveprompt) {
|
|
printf("Overwrite system symbol table %s? ", SYSTEM_TABLE);
|
|
fgets(str, sizeof(str), stdin);
|
|
if (str[0] != 'y' && str[0] != 'Y')
|
|
return;
|
|
}
|
|
unlink(SYSTEM_TABLE);
|
|
}
|
|
|
|
if ((fd = fopen(SYSTEM_TABLE, "w")) == NULL) {
|
|
perror(SYSTEM_TABLE);
|
|
return;
|
|
}
|
|
|
|
for (s = symbols; s != NULL; s = s->next)
|
|
fprintf(fd, "%-5s %04X\n", s->name, s->value);
|
|
|
|
fclose(fd);
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* startpass - initialize data structures, prepare to start a pass
|
|
********************************************************************************************/
|
|
|
|
void startpass (int n)
|
|
{
|
|
int nops;
|
|
struct tag_op *p;
|
|
|
|
pass = n; /* reset globals: pass number */
|
|
nerrors = 0; /* error count */
|
|
org = 0; /* load address (origin) */
|
|
lno = 0; /* input line number */
|
|
relocate = TRUE; /* relocatable assembly mode */
|
|
assembled = FALSE; /* true if any output has been generated */
|
|
list_on = do_list; /* listing enable */
|
|
dmes_saved = FALSE; /* partial character strings output */
|
|
|
|
n_literals = 0; /* literal values pending output */
|
|
lit_tag = 0;
|
|
|
|
if (pass == 1) { /* first pass only */
|
|
for (nops = 0, p = ops; p->mnem != NULL; p++, nops++) /* count opcodes */
|
|
;
|
|
|
|
qsort(ops, nops, sizeof(*p), opcmp); /* sort the opcode table */
|
|
|
|
if (preload)
|
|
preload_symbols();
|
|
}
|
|
else { /* second pass only */
|
|
if (outfn == NULL)
|
|
outfn = addextn(curfn, (outmode == OUTMODE_LOAD) ? ".out" : ".bin" , NULL);
|
|
|
|
if ((fout = fopen(outfn, OUTWRITEMODE)) == NULL) { /* open output file */
|
|
perror(outfn);
|
|
exit(1);
|
|
}
|
|
|
|
if (do_list) { /* open listing file */
|
|
if ((flist = fopen(listfn, "w")) == NULL) {
|
|
perror(listfn);
|
|
exit(1);
|
|
}
|
|
listhdr(); /* print banner */
|
|
}
|
|
}
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* x_dc - DC define constant directive
|
|
********************************************************************************************/
|
|
|
|
void x_dc (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
EXPR expr;
|
|
/* char *tok; */
|
|
|
|
org_advanced = 1; /* assume * means this address+1 */
|
|
/* doesn't make sense, but I think I found DMS listings to support it */
|
|
|
|
if (strchr(mods, 'E') != NULL) /* force even address */
|
|
org_even();
|
|
|
|
setw(0, org+listoffset, FALSE); /* display org in listing line */
|
|
|
|
if (*label) /* define label */
|
|
set_symbol(label, org, TRUE, relocate);
|
|
|
|
getexpr(arg, FALSE, &expr);
|
|
writew(expr.value, expr.relative); /* store value */
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* x_dec - DEC define double word constant directive.
|
|
********************************************************************************************/
|
|
|
|
/* wd[0]: 8 unused bits | characteristic (= exponent+128)
|
|
* wd[1]: sign + 15 msb of mantissa in 2's complement
|
|
* wd[2]: 16 lsb of mantissa
|
|
* NOTE: these are wrong with Fixed point numbers */
|
|
|
|
void convert_double_to_extended (double d, unsigned short *wd)
|
|
{
|
|
int neg, exp;
|
|
unsigned long mantissa;
|
|
unsigned char *byte = (unsigned char *) &d;
|
|
|
|
if (d == 0.) {
|
|
wd[0] = wd[1] = wd[2] = 0;
|
|
return;
|
|
}
|
|
/* 7 6 5 4 0 */
|
|
/* d = ansi real*8 SXXX XXXX XXXX MMMM MMMM MMMM MMMM MMMM ... MMMM MMMM */
|
|
|
|
neg = byte[7] & 0x80;
|
|
exp = ((byte[7] & 0x7F) << 4) | ((byte[6] & 0xF0) >> 4); /* extract exponent */
|
|
exp -= 1023; /* remove bias */
|
|
|
|
exp++; /* shift to account for implied 1 we added */
|
|
|
|
/* get 32 bits worth of mantissa. add the implied point */
|
|
mantissa = 0x80000000L | ((byte[6] & 0x0F) << 27) | (byte[5] << 19) | (byte[4] << 11) | (byte[3] << 3) | ((byte[2] & 0xE0) >> 5);
|
|
|
|
if (mantissa & (0x80000000L >> 31)) /* keep 31 bits, round if necessary */
|
|
mantissa += (0x80000000L >> 31);
|
|
|
|
mantissa >>= (32-31); /* get into low 31 bits */
|
|
|
|
/* now turn into IBM 1130 extended precision */
|
|
|
|
exp += 128;
|
|
|
|
if (neg)
|
|
mantissa = (unsigned long) (- (long) mantissa); /* two's complement */
|
|
|
|
wd[0] = (unsigned short) (exp & 0xFF);
|
|
wd[1] = (unsigned short) ((neg ? 0x8000 : 0) | ((mantissa >> (31-15)) & 0x7FFF));
|
|
wd[2] = (unsigned short) (mantissa & 0xFFFF);
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* convert_double_to_standard -
|
|
********************************************************************************************/
|
|
|
|
void convert_double_to_standard (double d, unsigned short *wd)
|
|
{
|
|
int neg, exp;
|
|
unsigned long mantissa;
|
|
unsigned char *byte = (unsigned char *) &d;
|
|
|
|
if (d == 0.) {
|
|
wd[0] = wd[1] = 0;
|
|
return;
|
|
}
|
|
/* 7 6 5 4 0 */
|
|
/* d = ansi real*8 SXXX XXXX XXXX MMMM MMMM MMMM MMMM MMMM ... MMMM MMMM */
|
|
|
|
neg = byte[7] & 0x80;
|
|
exp = ((byte[7] & 0x7F) << 4) | ((byte[6] & 0xF0) >> 4); /* extract exponent */
|
|
exp -= 1023; /* remove bias */
|
|
|
|
exp++; /* shift to account for implied 1 we added */
|
|
|
|
/* get 32 bits worth of mantissa. add the implied point */
|
|
mantissa = 0x80000000L | ((byte[6] & 0x0F) << 27) | (byte[5] << 19) | (byte[4] << 11) | (byte[3] << 3) | ((byte[2] & 0xE0) >> 5);
|
|
|
|
/* if (mantissa & (0x80000000L >> 23)) // keep 23 bits, round if necessary */
|
|
/* mantissa += (0x80000000L >> 23); */
|
|
|
|
/* DEBUG */
|
|
/* printf("%8.4lf: %08lX %d\n", d, mantissa, exp); */
|
|
|
|
mantissa >>= (32-23); /* get into low 23 bits */
|
|
|
|
/* now turn into IBM 1130 standard precision */
|
|
|
|
exp += 128;
|
|
|
|
if (neg)
|
|
mantissa = (unsigned long) (- (long) mantissa); /* two's complement */
|
|
|
|
wd[0] = (unsigned short) ((neg ? 0x8000 : 0) | ((mantissa >> (23-15)) & 0x7FFF));
|
|
wd[1] = (unsigned short) ((mantissa & 0x00FF) << 8) | (exp & 0xFF);
|
|
|
|
/* DEBUG */
|
|
/* printf(" D %04x%04X\n", wd[0], wd[1]); */
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* convert_double_to_fixed -
|
|
********************************************************************************************/
|
|
|
|
void convert_double_to_fixed (double d, unsigned short *wd, int bexp)
|
|
{
|
|
int neg, exp, rshift;
|
|
unsigned long mantissa;
|
|
unsigned char *byte = (unsigned char *) &d;
|
|
|
|
if (d == 0.) {
|
|
wd[0] = wd[1] = 0;
|
|
return;
|
|
}
|
|
|
|
/* note: we assume that this computer uses ANSI floating point */
|
|
|
|
/* 7 6 5 4 0 */
|
|
/* d = ansi real*8 SXXX XXXX XXXX MMMM MMMM MMMM MMMM MMMM ... MMMM MMMM */
|
|
|
|
neg = byte[7] & 0x80;
|
|
exp = ((byte[7] & 0x7F) << 4) | ((byte[6] & 0xF0) >> 4); /* extract exponent */
|
|
exp -= 1023; /* remove bias */
|
|
|
|
exp++; /* shift to account for implied 1 we added */
|
|
|
|
/* get 32 bits worth of mantissa. add the implied point */
|
|
mantissa = 0x80000000L | ((byte[6] & 0x0F) << 27) | (byte[5] << 19) | (byte[4] << 11) | (byte[3] << 3) | ((byte[2] & 0xE0) >> 5);
|
|
|
|
mantissa >>= 1; /* shift it out of the sign bit */
|
|
|
|
/* DEBUG */
|
|
/* printf("%8.4lf: %08lX %d\n", d, mantissa, exp); */
|
|
|
|
rshift = bexp - exp;
|
|
|
|
if (rshift > 0) {
|
|
mantissa >>= rshift;
|
|
}
|
|
else if (rshift < 0) {
|
|
mantissa >>= (-rshift);
|
|
asm_warning("Fixed point overflow");
|
|
}
|
|
|
|
if (neg)
|
|
mantissa = (unsigned long) (- (long) mantissa); /* two's complement */
|
|
|
|
/* DEBUG */
|
|
/* printf(" B %08lX\n", mantissa); */
|
|
|
|
wd[0] = (unsigned short) ((mantissa >> 16) & 0xFFFF); /* return all of the bits; no exponent here */
|
|
wd[1] = (unsigned short) (mantissa & 0xFFFF);
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* getDconstant -
|
|
********************************************************************************************/
|
|
|
|
void getDconstant (char *tok, unsigned short *wd)
|
|
{
|
|
unsigned long l;
|
|
char *b, *fmt;
|
|
double d;
|
|
int bexp;
|
|
BOOL fixed = FALSE;
|
|
|
|
wd[0] = 0;
|
|
wd[1] = 0;
|
|
|
|
tok = skipbl(tok);
|
|
if (! *tok)
|
|
return; /* no argument is the same as 0 */
|
|
|
|
if (strchr(tok, '.') == NULL && strchr(tok, 'B') == NULL && strchr(tok, 'E') == NULL) {
|
|
fmt = "%ld"; /* not a floating point number -- parse as a 32-bit integer */
|
|
if (*tok == '/') { /* I don't see that this is legal but can't hurt to allow it */
|
|
fmt = "%lx";
|
|
tok++;
|
|
}
|
|
|
|
if (sscanf(tok, fmt, &l) != 1)
|
|
asm_error("Syntax error in constant");
|
|
else {
|
|
wd[0] = (unsigned short) ((l >> 16) & 0xFFFF); /* high word */
|
|
wd[1] = (unsigned short) (l & 0xFFFF); /* low word */
|
|
}
|
|
}
|
|
else {
|
|
if ((b = strchr(tok, 'B')) != NULL) {
|
|
fixed = TRUE;
|
|
bexp = atoi(b+1); /* get binary exponent, after the B */
|
|
*b = '\0'; /* truncate at the B */
|
|
}
|
|
|
|
if (sscanf(tok, "%lg", &d) != 1)
|
|
asm_error("Syntax error in constant");
|
|
else if (fixed)
|
|
convert_double_to_fixed(d, wd, bexp);
|
|
else
|
|
convert_double_to_standard(d, wd);
|
|
}
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* x_dec - If the input value is an integer with no decimal point and no B or E,
|
|
* DEC generates a double INTEGER value.
|
|
* IBM documentation ranges from ambiguous to wrong on this point, but
|
|
* examination of the DMS microfiche supports this.
|
|
********************************************************************************************/
|
|
|
|
void x_dec (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
unsigned short wd[2];
|
|
|
|
org_advanced = 2; /* assume * means address after this location, since it's +1 for dc? */
|
|
|
|
org_even(); /* even address is implied */
|
|
setw(0, org+listoffset, FALSE); /* display the origin */
|
|
|
|
if (*label) /* define label */
|
|
set_symbol(label, org, TRUE, relocate);
|
|
|
|
getDconstant(arg, wd);
|
|
writew(wd[0], FALSE); /* write hiword, then loword */
|
|
writew(wd[1], FALSE);
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* DECS directive. Writes just the high word of a DEC value
|
|
********************************************************************************************/
|
|
|
|
void x_decs (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
unsigned short wd[2];
|
|
|
|
org_advanced = 1; /* assume * means address after this location */
|
|
|
|
setw(0, org+listoffset, FALSE); /* display the origin */
|
|
|
|
if (*label) /* define label */
|
|
set_symbol(label, org, TRUE, relocate);
|
|
|
|
getDconstant(arg, wd);
|
|
writew(wd[0], FALSE); /* write hiword ONLY */
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* x_xflc - extended precision constant. (Note: if there is no argument, we must write a zero value)
|
|
********************************************************************************************/
|
|
|
|
void x_xflc (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
char *tok, *b;
|
|
double d;
|
|
int bexp, fixed;
|
|
unsigned short wd[3];
|
|
|
|
org_advanced = 2; /* who knows? */
|
|
|
|
setw(0, org+listoffset, FALSE); /* display the origin */
|
|
|
|
if (*label) /* define label */
|
|
set_symbol(label, org, TRUE, relocate);
|
|
|
|
if ((tok = strtok(arg, ",")) == NULL) { /* pick up value */
|
|
tok = "0"; /* if there is no argument at all, spit out a zero */
|
|
/* fprintf(stderr, ">>> ENCOUNTERED XFLC WITH NO ARGUMENT IN %s -- THIS WAS BUGGY BEFORE\n", curfn); */
|
|
}
|
|
|
|
bexp = 0; /* parse the value */
|
|
if ((b = strchr(tok, 'B')) != NULL) {
|
|
bexp = atoi(b+1);
|
|
fixed = TRUE;
|
|
*b = '\0'; /* truncate at the b */
|
|
asm_warning("Fixed point extended floating constant?");
|
|
}
|
|
|
|
if (sscanf(tok, "%lg", &d) != 1) {
|
|
asm_error("Syntax error in constant");
|
|
d = 0.;
|
|
}
|
|
|
|
convert_double_to_extended(d, wd);
|
|
|
|
writew(wd[0], ABSOLUTE);
|
|
writew(wd[1], ABSOLUTE);
|
|
writew(wd[2], ABSOLUTE);
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* x_equ - EQU directive
|
|
********************************************************************************************/
|
|
|
|
void x_equ (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
EXPR expr;
|
|
|
|
org_advanced = 0; /* * means this address, not incremented */
|
|
|
|
getexpr(arg, FALSE, &expr);
|
|
|
|
setw(0, expr.value, expr.relative); /* show this as address */
|
|
|
|
if (*label) /* EQU is all about defining labels, better have one */
|
|
set_symbol(label, expr.value, TRUE, expr.relative);
|
|
/* else // IBM assembler doesn't complain about this */
|
|
/* asm_error("EQU without label?"); */
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* x_lorg - LORG directive -- output queued literal values
|
|
********************************************************************************************/
|
|
|
|
void x_lorg (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
org_advanced = 0; /* * means this address (not used, though) */
|
|
output_literals(FALSE); /* generate .DC's for queued literal values */
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* x_abs - ABS directive
|
|
********************************************************************************************/
|
|
|
|
void x_abs (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
if (assembled)
|
|
asm_error("ABS must be first statement");
|
|
|
|
relocate = ABSOLUTE;
|
|
|
|
switch (progtype) {
|
|
case PROGTYPE_ABSOLUTE:
|
|
case PROGTYPE_RELOCATABLE:
|
|
progtype = PROGTYPE_ABSOLUTE; /* change program type, still assumed to be mainline */
|
|
break;
|
|
|
|
case PROGTYPE_LIBF:
|
|
case PROGTYPE_CALL:
|
|
case PROGTYPE_ISSLIBF:
|
|
case PROGTYPE_ISSCALL:
|
|
case PROGTYPE_ILS:
|
|
asm_error("ABS not allowed with LIBF, ENT, ILS or ISS");
|
|
break;
|
|
|
|
default:
|
|
bail("in x_libr, can't happen");
|
|
}
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* x_call - ORG pseudo-op
|
|
********************************************************************************************/
|
|
|
|
void x_call (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
unsigned short words[2];
|
|
static struct tag_op *bsi = NULL;
|
|
|
|
if (*label) /* define label */
|
|
set_symbol(label, org, TRUE, relocate);
|
|
|
|
if (! *arg) {
|
|
asm_error("CALL missing argument");
|
|
return;
|
|
}
|
|
|
|
if (pass == 1) { /* it will take two words in any case */
|
|
org += 2;
|
|
return;
|
|
}
|
|
|
|
setw(0, org+listoffset, FALSE); /* display origin */
|
|
|
|
if (lookup_symbol(arg, FALSE) != NULL) {/* it's a defined symbol? */
|
|
if (bsi == NULL)
|
|
if ((bsi = lookup_op("BSI")) == NULL)
|
|
bail("Can't find BSI op");
|
|
|
|
(bsi->handler)(bsi, "", "L", arg);
|
|
}
|
|
else if (outmode == OUTMODE_BINARY) {
|
|
namecode(words, arg); /* emit namecode for loader */
|
|
|
|
writetwo();
|
|
writew(words[0], CALL);
|
|
writew(words[1], ABSOLUTE);
|
|
}
|
|
else {
|
|
writew(0x3000, 0); /* write two WAIT commands */
|
|
writew(0x3000, 0);
|
|
asm_warning("CALL <libroutine> is not valid for simulator load output format, emitting WAIT");
|
|
}
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* x_org - ORG directive
|
|
********************************************************************************************/
|
|
|
|
void x_org (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
EXPR expr;
|
|
|
|
org_advanced = 0; /* * means this address */
|
|
|
|
if (*label) /* label is defined BEFORE the new origin is set!!! */
|
|
set_symbol(label, org, TRUE, relocate);
|
|
|
|
if (getexpr(arg, FALSE, &expr) != S_DEFINED)
|
|
return;
|
|
|
|
setorg(expr.value); /* set origin to this value */
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* x_end - END directive
|
|
********************************************************************************************/
|
|
|
|
void x_end (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
EXPR expr;
|
|
|
|
org_advanced = 0; /* * means this address */
|
|
|
|
if (*arg) { /* they're specifing the program start address */
|
|
if (getexpr(arg, FALSE, &expr) == S_DEFINED)
|
|
pta = expr.value;
|
|
}
|
|
|
|
if (*label) /* define label */
|
|
set_symbol(label, org, TRUE, relocate);
|
|
|
|
setw(0, org+listoffset, FALSE); /* display origin */
|
|
|
|
ended = TRUE; /* assembly is done, stop reading file */
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* x_ent - ENT op
|
|
********************************************************************************************/
|
|
|
|
void x_ent (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
PSYMBOL s;
|
|
|
|
org_advanced = 0; /* * means this address */
|
|
|
|
if (pass < 2)
|
|
return;
|
|
|
|
/* if (*label) // define label */
|
|
/* set_symbol(label, org, TRUE, relocate); */
|
|
/* */
|
|
/* setw(0, org+listoffset, FALSE); // display origin */
|
|
|
|
if (! *arg)
|
|
asm_error("No entry label specified");
|
|
|
|
else if ((s = lookup_symbol(arg, FALSE)) == NULL)
|
|
asm_error("Entry symbol %s not defined", arg);
|
|
|
|
else if (nentries >= MAXENTRIES)
|
|
asm_error("Too many entries, limit is %d", MAXENTRIES);
|
|
|
|
else
|
|
entry[nentries++] = s; /* save symbol pointer */
|
|
|
|
switch (progtype) {
|
|
case PROGTYPE_ABSOLUTE:
|
|
asm_error("ENT not allowed with ABS");
|
|
break;
|
|
case PROGTYPE_RELOCATABLE:
|
|
progtype = PROGTYPE_CALL;
|
|
break;
|
|
case PROGTYPE_LIBF:
|
|
case PROGTYPE_CALL:
|
|
case PROGTYPE_ISSLIBF:
|
|
case PROGTYPE_ISSCALL:
|
|
break;
|
|
case PROGTYPE_ILS:
|
|
asm_error("Can't mix ENT and ILS, can you?");
|
|
break;
|
|
default:
|
|
bail("in x_libr, can't happen");
|
|
}
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* declare a libf-type subprogram
|
|
********************************************************************************************/
|
|
|
|
void x_libr (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
switch (progtype) {
|
|
case PROGTYPE_ABSOLUTE:
|
|
asm_error("LIBR not allowed with ABS");
|
|
break;
|
|
case PROGTYPE_RELOCATABLE:
|
|
case PROGTYPE_LIBF:
|
|
case PROGTYPE_CALL:
|
|
progtype = PROGTYPE_LIBF;
|
|
break;
|
|
case PROGTYPE_ISSLIBF:
|
|
case PROGTYPE_ISSCALL:
|
|
progtype = PROGTYPE_ISSLIBF;
|
|
break;
|
|
case PROGTYPE_ILS:
|
|
asm_error("Can't use LIBR in an ILS");
|
|
break;
|
|
default:
|
|
bail("in x_libr, can't happen");
|
|
}
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* x_ils - ILS directive
|
|
********************************************************************************************/
|
|
|
|
void x_ils (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
switch (progtype) {
|
|
case PROGTYPE_ABSOLUTE:
|
|
asm_error("ILS not allowed with ABS");
|
|
break;
|
|
case PROGTYPE_RELOCATABLE:
|
|
case PROGTYPE_ILS:
|
|
progtype = PROGTYPE_ILS;
|
|
break;
|
|
case PROGTYPE_LIBF:
|
|
case PROGTYPE_CALL:
|
|
asm_error("Invalid placement of ILS");
|
|
break;
|
|
case PROGTYPE_ISSLIBF:
|
|
case PROGTYPE_ISSCALL:
|
|
break;
|
|
default:
|
|
bail("in x_libr, can't happen");
|
|
}
|
|
|
|
intlevel_primary = atoi(mods);
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* x_iss - ISS directive
|
|
********************************************************************************************/
|
|
|
|
void x_iss (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
char *tok;
|
|
|
|
switch (progtype) {
|
|
case PROGTYPE_ABSOLUTE:
|
|
asm_error("ISS not allowed with ABS");
|
|
break;
|
|
case PROGTYPE_RELOCATABLE:
|
|
case PROGTYPE_CALL:
|
|
case PROGTYPE_ISSCALL:
|
|
progtype = PROGTYPE_ISSCALL;
|
|
break;
|
|
case PROGTYPE_LIBF:
|
|
case PROGTYPE_ISSLIBF:
|
|
progtype = PROGTYPE_ISSLIBF;
|
|
break;
|
|
case PROGTYPE_ILS:
|
|
asm_error("Can't mix ISS and ILS");
|
|
default:
|
|
bail("in x_libr, can't happen");
|
|
}
|
|
|
|
iss_number = atoi(mods); /* get ISS number */
|
|
|
|
opfield[16] = '\0'; /* be sure not to look too far into this */
|
|
|
|
nintlevels = 0; /* # of interrupt levels for ISS */
|
|
intlevel_primary = 0; /* primary level for ISS and level for ILS */
|
|
intlevel_secondary = 0; /* secondary level for ISS */
|
|
|
|
if ((tok = strtok(opfield, " ")) == NULL)
|
|
asm_error("ISS missing entry label");
|
|
else
|
|
x_ent(NULL, label, "", arg); /* process as an ENT */
|
|
|
|
if ((tok = strtok(NULL, " ")) != NULL) { /* get associated levels */
|
|
nintlevels++;
|
|
intlevel_primary = atoi(tok);
|
|
}
|
|
|
|
if ((tok = strtok(NULL, " ")) != NULL) {
|
|
nintlevels++;
|
|
intlevel_secondary = atoi(tok);
|
|
}
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* x_spr -
|
|
********************************************************************************************/
|
|
|
|
void x_spr (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
realmode = REALMODE_STANDARD;
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* x_epr -
|
|
********************************************************************************************/
|
|
|
|
void x_epr (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
realmode = REALMODE_EXTENDED;
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* x_dsa -
|
|
********************************************************************************************/
|
|
|
|
void x_dsa (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
unsigned short words[2];
|
|
|
|
setw(0, org+listoffset, FALSE); /* display origin */
|
|
|
|
if (*label) /* define label */
|
|
set_symbol(label, org, TRUE, relocate);
|
|
|
|
if (! *arg) {
|
|
asm_error("DSA missing filename");
|
|
}
|
|
else if (outmode == OUTMODE_BINARY) {
|
|
namecode(words, arg);
|
|
writetwo();
|
|
writew(words[0], CALL); /* special relocation bits here 3 and 1 */
|
|
writew(words[1], RELATIVE);
|
|
}
|
|
else {
|
|
writew(0, 0); /* write two zeroes */
|
|
writew(0, 0);
|
|
asm_warning("DSA is not valid for simulator load output format, emitting 0's");
|
|
}
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* x_link -
|
|
********************************************************************************************/
|
|
|
|
void x_link (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
unsigned short words[2];
|
|
char nline[128];
|
|
|
|
setw(0, org+listoffset, FALSE); /* display origin */
|
|
|
|
if (*label) /* define label */
|
|
set_symbol(label, org, TRUE, relocate);
|
|
|
|
if (! *arg) {
|
|
asm_error("LINK missing program name");
|
|
}
|
|
else {
|
|
format_line(nline, label, "CALL", "", "$LINK", "");
|
|
parse_line(nline);
|
|
|
|
if (outmode == OUTMODE_BINARY) {
|
|
namecode(words, arg);
|
|
writew(words[0], ABSOLUTE); /* special relocation bits here 3 and 1 */
|
|
writew(words[1], ABSOLUTE);
|
|
}
|
|
else {
|
|
writew(0x3000, 0); /* write two WAIT commands */
|
|
writew(0x3000, 0);
|
|
asm_warning("LINK is not valid for simulator load output format, emitting WAIT");
|
|
}
|
|
}
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* x_libf -
|
|
********************************************************************************************/
|
|
|
|
void x_libf (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
unsigned short words[2];
|
|
|
|
if (*label) /* define label */
|
|
set_symbol(label, org, TRUE, relocate);
|
|
|
|
if (! *arg) {
|
|
asm_error("LIBF missing argument");
|
|
return;
|
|
}
|
|
|
|
if (pass == 1) { /* it will take one word in any case */
|
|
org++;
|
|
return;
|
|
}
|
|
|
|
setw(0, org+listoffset, FALSE); /* display origin */
|
|
|
|
if (outmode == OUTMODE_BINARY) {
|
|
namecode(words, arg); /* emit namecode for loader */
|
|
|
|
writetwo();
|
|
writew(words[0], LIBF); /* this one does NOT advance org! */
|
|
writew(words[1], ABSOLUTE);
|
|
}
|
|
else {
|
|
writew(0x3000, 0); /* write a WAIT command */
|
|
asm_warning("LIBF is not valid for simulator load output format, emitting WAIT");
|
|
}
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* x_file -
|
|
********************************************************************************************/
|
|
|
|
void x_file (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
int i, n, r;
|
|
EXPR vals[5];
|
|
char *tok;
|
|
|
|
for (i = 0; i < 5; i++) {
|
|
if ((tok = strtok(arg, ",")) == NULL) {
|
|
asm_error("FILE has insufficient arguments");
|
|
return;
|
|
}
|
|
arg = NULL; /* for next strtok call */
|
|
|
|
if (i == 3) {
|
|
if (strcmpi(tok, "U") != 0)
|
|
asm_error("Argument 4 must be the letter U");
|
|
}
|
|
else if (getexpr(tok, FALSE, &vals[i]) == S_DEFINED) {
|
|
if (i <= 3 && vals[i].relative)
|
|
asm_error("Argument %d must be absolute", i+1);
|
|
else if (pass == 2 && vals[i].value == 0)
|
|
asm_error("Argument %d must be nonzero", i+1);
|
|
}
|
|
}
|
|
|
|
writew(vals[0].value, ABSOLUTE);
|
|
writew(vals[1].value, ABSOLUTE);
|
|
writew(vals[2].value, ABSOLUTE);
|
|
writew(vals[4].value, vals[i].relative);
|
|
writew(0, ABSOLUTE);
|
|
n = MAX(1, vals[2].value);
|
|
r = 320/n;
|
|
writew(r, ABSOLUTE);
|
|
r = MAX(1, r);
|
|
writew((16*vals[1].value)/r, ABSOLUTE);
|
|
|
|
if (pass == 2)
|
|
ndefined_files++;
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* x_trap - place to set a breakpoint
|
|
********************************************************************************************/
|
|
|
|
void x_trap (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
/* debugging breakpoint */
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* x_ces - .CES directive (nonstandard). Specify a value for the console entry
|
|
* switches. When this program is loaded into the simulator, the switches will
|
|
* be set accordingly. Handy for bootstraps and other programs that read
|
|
* the switches.
|
|
********************************************************************************************/
|
|
|
|
void x_ces (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
EXPR expr;
|
|
|
|
if (outmode != OUTMODE_LOAD) /* this works only in our loader format */
|
|
return;
|
|
|
|
if (getexpr(arg, FALSE, &expr) != S_DEFINED)
|
|
return;
|
|
|
|
if (pass == 2)
|
|
fprintf(fout, "S%04X" ENDLINE, expr.value & 0xFFFF);
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* x_bss - BSS directive - reserve space in core
|
|
********************************************************************************************/
|
|
|
|
void x_bss (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
EXPR expr;
|
|
|
|
org_advanced = 0; /* * means this address */
|
|
|
|
if (! *arg) {
|
|
expr.value = 0;
|
|
expr.relative = ABSOLUTE;
|
|
}
|
|
else if (getexpr(arg, FALSE, &expr) != S_DEFINED)
|
|
return;
|
|
|
|
if (strchr(mods, 'E') != NULL) /* force even address */
|
|
org_even();
|
|
|
|
if (expr.relative)
|
|
asm_error("BSS size must be an absolute value");
|
|
|
|
setw(0, org+listoffset, FALSE); /* display origin */
|
|
|
|
if (*label) /* define label */
|
|
set_symbol(label, org, TRUE, relocate);
|
|
|
|
expr.value &= 0xFFFF; /* truncate to 16 bits */
|
|
|
|
if (expr.value & 0x8000) {
|
|
asm_warning("Negative BSS size (%ld, /%04X)", (long)(short)expr.value, expr.value);
|
|
}
|
|
else if (expr.value > 0) {
|
|
if (outmode == OUTMODE_LOAD) {
|
|
org += expr.value; /* advance the origin by appropriate number of words */
|
|
if (pass == 2) /* emit new load address in output file */
|
|
fprintf(fout, "@%04X%s" ENDLINE, org & 0xFFFF, relocate ? "R" : "");
|
|
}
|
|
else {
|
|
org += expr.value; /* advance the origin by appropriate number of words */
|
|
if (pass == 2)
|
|
bincard_setorg(org);
|
|
}
|
|
}
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* x_bes - Block Ended by Symbol directive. Like BSS but label gets address AFTER the space, instead of first address
|
|
********************************************************************************************/
|
|
|
|
void x_bes (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
EXPR expr;
|
|
|
|
org_advanced = 0; /* * means this address */
|
|
|
|
if (! *arg) { /* arg field = space */
|
|
expr.value = 0;
|
|
expr.relative = ABSOLUTE;
|
|
}
|
|
else if (getexpr(arg, FALSE, &expr) != S_DEFINED)
|
|
return;
|
|
|
|
if (strchr(mods, 'E') != NULL && (org & 1) != 0)
|
|
org_even(); /* force even address */
|
|
|
|
if (expr.relative)
|
|
asm_error("BES size must be an absolute value");
|
|
|
|
if (expr.value < 0)
|
|
asm_warning("Negative BES size");
|
|
|
|
else if (expr.value > 0) {
|
|
setw(0, org+expr.value+listoffset, FALSE); /* display NEW origin */
|
|
|
|
if (outmode == OUTMODE_LOAD) {
|
|
org += expr.value; /* advance the origin */
|
|
if (pass == 2) /* emit new load address in output file */
|
|
fprintf(fout, "@%04X%s" ENDLINE, org & 0xFFFF, relocate ? "R" : "");
|
|
}
|
|
else {
|
|
org += expr.value; /* advance the origin */
|
|
bincard_setorg(org);
|
|
}
|
|
}
|
|
|
|
if (*label) /* NOW define the label */
|
|
set_symbol(label, org, TRUE, relocate);
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* x_dmes - DMES define message directive. Various encodings, none pretty.
|
|
********************************************************************************************/
|
|
|
|
int dmes_wd;
|
|
int dmes_nc;
|
|
enum {CODESET_CONSOLE, CODESET_1403, CODESET_1132, CODESET_EBCDIC} dmes_cs;
|
|
void stuff_dmes (int ch, int rpt);
|
|
|
|
void x_dmes (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
int rpt;
|
|
char *c = opfield;
|
|
BOOL cont = FALSE;
|
|
|
|
if (dmes_saved) { /* previous DMES had an odd character saved */
|
|
dmes_wd = dmes_savew;
|
|
dmes_nc = 1; /* stick it into the outbut buffer */
|
|
}
|
|
else
|
|
dmes_nc = dmes_wd = 0; /* clear output buffer */
|
|
|
|
trim(opfield); /* remove trailing blanks from rest of input line (use whole thing) */
|
|
setw(0, org+listoffset, FALSE); /* display origin */
|
|
|
|
if (*label) /* define label */
|
|
set_symbol(label, org, TRUE, relocate);
|
|
|
|
if (strchr(mods, '1') != NULL) /* determine the encoding scheme */
|
|
dmes_cs = CODESET_1403;
|
|
else if (strchr(mods, '2') != NULL)
|
|
dmes_cs = CODESET_1132;
|
|
else if (strchr(mods, '0') != NULL || ! *mods)
|
|
dmes_cs = CODESET_CONSOLE;
|
|
else {
|
|
asm_error("Invalid printer code in tag field");
|
|
dmes_cs = CODESET_EBCDIC;
|
|
}
|
|
|
|
while (*c) { /* pick up characters */
|
|
if (*c == '\'') { /* quote (') is the escape character */
|
|
c++;
|
|
|
|
rpt = 0; /* get repeat count */
|
|
while (BETWEEN(*c, '0', '9')) {
|
|
rpt = rpt*10 + *c++ - '0';
|
|
}
|
|
if (rpt <= 0) /* no count = insert one copy */
|
|
rpt = 1;
|
|
|
|
switch (*c) { /* handle escape codes */
|
|
case '\'':
|
|
stuff_dmes(*c, 1);
|
|
break;
|
|
|
|
case 'E':
|
|
*c = '\0'; /* end */
|
|
break;
|
|
|
|
case 'X':
|
|
case 'S':
|
|
stuff_dmes(' ', rpt);
|
|
break;
|
|
|
|
case 'F':
|
|
stuff_dmes(*++c, rpt); /* repeat character */
|
|
break;
|
|
|
|
case ' ':
|
|
case '\0':
|
|
cont = TRUE;
|
|
*c = '\0'; /* end */
|
|
break;
|
|
|
|
case 'T':
|
|
if (dmes_cs != CODESET_CONSOLE) {
|
|
badcode: asm_error("Invalid ' escape for selected printer");
|
|
break;
|
|
}
|
|
stuff_dmes(0x41, -rpt); /* tab */
|
|
break;
|
|
|
|
case 'D':
|
|
if (dmes_cs != CODESET_CONSOLE) goto badcode;
|
|
stuff_dmes(0x11, -rpt); /* backspace */
|
|
break;
|
|
|
|
case 'B':
|
|
if (dmes_cs != CODESET_CONSOLE) goto badcode;
|
|
stuff_dmes(0x05, -rpt); /* black */
|
|
break;
|
|
|
|
case 'A':
|
|
if (dmes_cs != CODESET_CONSOLE) goto badcode;
|
|
stuff_dmes(0x09, -rpt); /* red */
|
|
break;
|
|
|
|
case 'R':
|
|
if (dmes_cs != CODESET_CONSOLE) goto badcode;
|
|
stuff_dmes(0x81, -rpt); /* return */
|
|
break;
|
|
|
|
case 'L':
|
|
if (dmes_cs != CODESET_CONSOLE) goto badcode;
|
|
stuff_dmes(0x03, -rpt); /* line feed */
|
|
break;
|
|
|
|
default:
|
|
asm_error("Invalid ' escape in DMES");
|
|
*c = '\0';
|
|
break;
|
|
}
|
|
}
|
|
else /* just copy literal character */
|
|
stuff_dmes(*c, 1);
|
|
|
|
if (*c)
|
|
c++;
|
|
}
|
|
|
|
dmes_saved = FALSE;
|
|
|
|
if (dmes_nc) { /* odd number of characters */
|
|
if (cont) {
|
|
dmes_saved = TRUE;
|
|
dmes_savew = dmes_wd; /* save for next time */
|
|
}
|
|
else
|
|
stuff_dmes(' ', 1); /* pad with a space to force out even # of characters */
|
|
}
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* stuff_dmes - insert 'rpt' copies of character 'ch' into output words
|
|
********************************************************************************************/
|
|
|
|
void stuff_dmes (int ch, int rpt)
|
|
{
|
|
int nch, i; /* nch is translated output value */
|
|
|
|
if (rpt < 0) { /* negative repeat means no translation needed */
|
|
rpt = -rpt;
|
|
nch = ch;
|
|
}
|
|
else {
|
|
switch (dmes_cs) {
|
|
case CODESET_CONSOLE:
|
|
nch = 0x21;
|
|
for (i = 0; i < 256; i++) {
|
|
if (conout_to_ascii[i] == ch) {
|
|
nch = i;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case CODESET_EBCDIC:
|
|
nch = ascii_to_ebcdic_table[ch & 0x7F];
|
|
if (nch == 0)
|
|
nch = 0x7F;
|
|
break;
|
|
|
|
case CODESET_1403:
|
|
nch = ascii_to_1403_table[ch & 0x7F];
|
|
if (nch == 0)
|
|
nch = 0x7F;
|
|
break;
|
|
|
|
case CODESET_1132:
|
|
nch = 0x40;
|
|
for (i = 0; i < WHEELCHARS_1132; i++) {
|
|
if (codewheel1132[i].ascii == ch) {
|
|
nch = codewheel1132[i].ebcdic;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
bail("bad cs in x_dmes, can't happen");
|
|
break;
|
|
}
|
|
}
|
|
|
|
while (--rpt >= 0) { /* pack them into words, output when we have two */
|
|
if (dmes_nc == 0) {
|
|
dmes_wd = (nch & 0xFF) << 8;
|
|
dmes_nc = 1;
|
|
}
|
|
else {
|
|
dmes_wd |= (nch & 0xFF);
|
|
writew(dmes_wd, FALSE);
|
|
dmes_nc = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* x_ebc - handle EBCDIC string definition (delimited with periods)
|
|
********************************************************************************************/
|
|
|
|
void x_ebc (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
char *p;
|
|
|
|
/* setw(0, org+listoffset, FALSE); */
|
|
if (*label)
|
|
set_symbol(label, org, TRUE, relocate);
|
|
|
|
p = trim(opfield); /* remove trailing blanks from rest of input line (use whole thing) */
|
|
|
|
if (*p != '.') {
|
|
asm_error("EBC data must start with .");
|
|
return;
|
|
}
|
|
p++; /* skip leading period */
|
|
|
|
dmes_nc = dmes_wd = 0; /* clear output buffer (we're borrowing the DMES packer) */
|
|
dmes_cs = CODESET_EBCDIC;
|
|
|
|
while (*p && *p != '.') /* store packed ebcdic */
|
|
stuff_dmes(*p++, 1);
|
|
|
|
if (dmes_nc) /* odd number of characters */
|
|
stuff_dmes(' ', 1); /* pad with a space to force out even # of characters */
|
|
|
|
if (*p != '.')
|
|
asm_error("EBC missing closing .");
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* x_dn - define name DN directive. Pack 5 characters into two words. This by the
|
|
* way is the reason the language Forth is not Fourth.
|
|
********************************************************************************************/
|
|
|
|
void x_dn (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
unsigned short words[2];
|
|
|
|
setw(0, org+listoffset, FALSE); /* display origin */
|
|
|
|
if (*label) /* define label */
|
|
set_symbol(label, org, TRUE, relocate);
|
|
|
|
namecode(words, arg);
|
|
|
|
writew(words[0], ABSOLUTE);
|
|
writew(words[1], ABSOLUTE);
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* x_dump - DUMP directive - pretend we saw "call $dump, call $exit"
|
|
********************************************************************************************/
|
|
|
|
void x_dump (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
x_pdmp(op, label, mods, arg);
|
|
x_exit(NULL, "", "", ""); /* compile "call $exit" */
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* x_pdmp - PDMP directive - like DUMP but without the call $exit
|
|
********************************************************************************************/
|
|
|
|
void x_pdmp (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
char nline[200], *tok;
|
|
EXPR addr[3];
|
|
int i;
|
|
|
|
for (i = 0, tok = strtok(arg, ","); i < 3 && tok != NULL; i++, tok = strtok(NULL, ",")) {
|
|
if (getexpr(tok, FALSE, addr+i) != S_DEFINED) {
|
|
addr[i].value = (i == 1) ? 0x3FFF : 0;
|
|
addr[i].relative = ABSOLUTE;
|
|
}
|
|
}
|
|
|
|
org_advanced = 0; /* * means this address+1 */
|
|
|
|
format_line(nline, label, "BSI", "L", DOLLARDUMP, "");
|
|
parse_line(nline); /* compile "call $dump" */
|
|
|
|
writew(addr[2].value, ABSOLUTE); /* append arguments (0, start, end address) */
|
|
writew(addr[0].value, addr[0].relative);
|
|
writew(addr[1].value, addr[1].relative);
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* x_hdng - HDNG directive
|
|
********************************************************************************************/
|
|
|
|
void x_hdng (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
char *c;
|
|
|
|
/* label is not entered into the symbol table */
|
|
|
|
if (flist == NULL || ! list_on) {
|
|
line_error = TRUE; /* inhibit listing: don't print the HDNG statement */
|
|
return;
|
|
}
|
|
|
|
line_error = TRUE; /* don't print the statement */
|
|
|
|
c = skipbl(opfield);
|
|
trim(c);
|
|
fprintf(flist, "\f%s\n\n", c); /* print page header */
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* x_list - LIST directive. enable or disable listing
|
|
********************************************************************************************/
|
|
|
|
void x_list (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
BOOL on;
|
|
|
|
/* label is not entered into the symbol table */
|
|
|
|
line_error = TRUE; /* don't print the LIST statement */
|
|
|
|
if (flist == NULL || ! list_on) {
|
|
return;
|
|
}
|
|
|
|
if (strcmpi(arg, "ON") == 0)
|
|
on = TRUE;
|
|
else if (strcmpi(arg, "OFF") == 0)
|
|
on = FALSE;
|
|
else
|
|
on = do_list;
|
|
|
|
list_on = on;
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* x_spac - SPAC directive. Put blank lines in listing
|
|
********************************************************************************************/
|
|
|
|
void x_spac (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
EXPR expr;
|
|
|
|
/* label is not entered into the symbol table */
|
|
|
|
if (flist == NULL || ! list_on) {
|
|
line_error = TRUE; /* don't print the SPAC statement */
|
|
return;
|
|
}
|
|
|
|
if (getexpr(arg, FALSE, &expr) != S_DEFINED)
|
|
return;
|
|
|
|
line_error = TRUE; /* don't print the statement */
|
|
|
|
while (--expr.value >= 0)
|
|
putc('\n', flist);
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* x_ejct - EJCT directive - put formfeed in listing
|
|
********************************************************************************************/
|
|
|
|
void x_ejct (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
/* label is not entered into the symbol table */
|
|
|
|
if (flist == NULL || ! list_on) {
|
|
line_error = TRUE; /* don't print the EJCT statement */
|
|
return;
|
|
}
|
|
|
|
line_error = TRUE; /* don't print the statement */
|
|
|
|
putc('\f', flist);
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* basic_opcode - construct a standard opcode value from op table entry and modifier chars
|
|
********************************************************************************************/
|
|
|
|
int basic_opcode (struct tag_op *op, char *mods)
|
|
{
|
|
int opcode = op->opcode; /* basic code value */
|
|
|
|
if (strchr(mods, '1') != 0) /* indexing */
|
|
opcode |= 0x0100;
|
|
else if (strchr(mods, '2') != 0)
|
|
opcode |= 0x0200;
|
|
else if (strchr(mods, '3') != 0)
|
|
opcode |= 0x0300;
|
|
|
|
if (strchr(mods, 'L')) { /* two-word format */
|
|
opcode |= OP_LONG;
|
|
if (strchr(mods, 'I') != 0) /* and indirect to boot */
|
|
opcode |= OP_INDIRECT;
|
|
}
|
|
|
|
return opcode;
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* std_op - assemble a vanilla opcode
|
|
********************************************************************************************/
|
|
|
|
void std_op (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
EXPR expr;
|
|
int opcode = basic_opcode(op, mods);
|
|
BOOL val_ok = FALSE;
|
|
|
|
if (*label) /* define label */
|
|
set_symbol(label, org, TRUE, relocate);
|
|
|
|
if (*arg && ! (op->flags & NO_ARGS)) { /* get value argument */
|
|
if (getexpr(arg, FALSE, &expr) == S_DEFINED)
|
|
val_ok = TRUE;
|
|
}
|
|
else {
|
|
expr.value = 0;
|
|
expr.relative = FALSE;
|
|
}
|
|
|
|
if (opcode & OP_LONG) { /* two-word format, just write code and value */
|
|
writew(opcode, FALSE);
|
|
writew(expr.value, expr.relative);
|
|
}
|
|
else { /* one-word format */
|
|
if (strchr(mods, 'I') != 0)
|
|
asm_error("Indirect mode not permitted on one-word instructions");
|
|
|
|
if (val_ok && ! (strchr(mods, 'X') || (op->flags & IS_ABS) || ((opcode & OP_INDEXED) && ! (op->flags & NO_IDX))))
|
|
expr.value -= (org+1); /* compute displacement */
|
|
|
|
if (expr.value < -128 || expr.value > 127) {/* check range */
|
|
asm_error("Offset of %d is too large", expr.value);
|
|
expr.value = 0;
|
|
}
|
|
|
|
writew(opcode | (expr.value & 0x00FF), FALSE);/* that's the code */
|
|
}
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* mdx_op - assemble a MDX family instruction
|
|
********************************************************************************************/
|
|
|
|
void mdx_op (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
EXPR dest, incr = {0, FALSE};
|
|
int opcode = basic_opcode(op, mods);
|
|
char *tok;
|
|
|
|
if (*label) /* define label */
|
|
set_symbol(label, org, TRUE, relocate);
|
|
|
|
if ((tok = strtok(arg, ",")) == NULL) { /* argument format is dest[,increment] */
|
|
/* asm_error("Destination not specified"); // seems not to be an error, IBM omits it sometimes */
|
|
dest.value = 0;
|
|
dest.relative = ABSOLUTE;
|
|
}
|
|
else
|
|
getexpr(tok, FALSE, &dest); /* parse the address */
|
|
|
|
tok = strtok(NULL, ","); /* look for second argument */
|
|
|
|
if (opcode & OP_LONG) { /* two word format */
|
|
if (opcode & OP_INDEXED) { /* format: MDX 2 dest */
|
|
if (tok != NULL)
|
|
asm_error("This format takes only one argument");
|
|
}
|
|
else { /* format: MDX dest,increment */
|
|
if (opcode & OP_INDIRECT)
|
|
asm_error("Indirect can't be used without indexing");
|
|
|
|
if (tok == NULL) {
|
|
/* asm_error("This format takes two arguments"); */
|
|
incr.value = 0;
|
|
incr.relative = ABSOLUTE;
|
|
}
|
|
else
|
|
getexpr(tok, FALSE, &incr);
|
|
|
|
if (incr.value < -128 || incr.value > 127) /* displacement style (fixed in ver 1.08) */
|
|
asm_error("Invalid increment value (8 bits signed)");
|
|
|
|
opcode |= (incr.value & 0xFF);
|
|
}
|
|
|
|
writew(opcode, ABSOLUTE);
|
|
writew(dest.value, dest.relative);
|
|
}
|
|
else { /* one word format MDX val */
|
|
if (tok != NULL)
|
|
asm_error("This format takes only one argument");
|
|
|
|
if (! (strchr(mods, 'X') || (opcode & OP_INDEXED)))
|
|
dest.value -= (org+1); /* compute displacement */
|
|
|
|
if (dest.value < -128 || dest.value > 127)
|
|
asm_error("Offset/Increment of %d is too large", dest.value);
|
|
|
|
writew(opcode | (dest.value & 0xFF), FALSE);
|
|
}
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* bsi_op - BSI long instruction is like a BSC L, short is standard
|
|
********************************************************************************************/
|
|
|
|
void bsi_op (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
if (strchr(mods, 'L') || strchr(mods, 'I'))
|
|
bsc_op(op, label, mods, arg);
|
|
else
|
|
std_op(op, label, mods, arg);
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* b_op - branch; use short or long version
|
|
********************************************************************************************/
|
|
|
|
void b_op (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
static struct tag_op *mdx = NULL;
|
|
|
|
if (strchr(mods, 'L') || strchr(mods, 'I')) {
|
|
bsi_op(op, label, mods, arg);
|
|
return;
|
|
}
|
|
|
|
if (mdx == NULL)
|
|
if ((mdx = lookup_op("MDX")) == NULL)
|
|
bail("Can't find MDX op");
|
|
|
|
(mdx->handler)(mdx, label, mods, arg);
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* bsc_op - compute a BSC family instruction
|
|
********************************************************************************************/
|
|
|
|
void bsc_op (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
EXPR dest;
|
|
int opcode = basic_opcode(op, mods);
|
|
char *tok, *tests;
|
|
|
|
if (*label) /* define label */
|
|
set_symbol(label, org, TRUE, relocate);
|
|
|
|
if (opcode & OP_LONG) { /* two word format */
|
|
if ((tok = strtok(arg, ",")) == NULL) { /* format is BSC dest[,tests] */
|
|
asm_error("Destination not specified");
|
|
dest.value = 0;
|
|
dest.relative = ABSOLUTE;
|
|
}
|
|
else
|
|
getexpr(tok, FALSE, &dest);
|
|
|
|
tests = strtok(NULL, ","); /* get test characters */
|
|
}
|
|
else
|
|
tests = arg; /* short format is BSC tests */
|
|
|
|
if (tests != NULL) { /* stick in the testing bits */
|
|
for (; *tests; tests++) {
|
|
switch (*tests) {
|
|
/* bit 0x40 is the BOSC bit */
|
|
case 'Z': opcode |= 0x20; break;
|
|
case '-': opcode |= 0x10; break;
|
|
case '+':
|
|
case '&': opcode |= 0x08; break;
|
|
case 'E': opcode |= 0x04; break;
|
|
case 'C': opcode |= 0x02; break;
|
|
case 'O': opcode |= 0x01; break;
|
|
default:
|
|
asm_error("Invalid test flag: '%c'", *tests);
|
|
}
|
|
}
|
|
}
|
|
|
|
writew(opcode, ABSOLUTE); /* emit code */
|
|
if (opcode & OP_LONG)
|
|
writew(dest.value, dest.relative);
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* shf_op - assemble a shift instruction
|
|
********************************************************************************************/
|
|
|
|
void shf_op (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
EXPR expr;
|
|
int opcode = basic_opcode(op, mods);
|
|
|
|
if (*label) /* define label */
|
|
set_symbol(label, org, TRUE, relocate);
|
|
|
|
if (opcode & OP_INDEXED) { /* shift value comes from index register */
|
|
expr.value = 0;
|
|
expr.relative = ABSOLUTE;
|
|
}
|
|
else
|
|
getexpr(arg, FALSE, &expr);
|
|
|
|
if (expr.relative) {
|
|
asm_error("Shift value is a relative address");
|
|
expr.relative = ABSOLUTE;
|
|
}
|
|
|
|
if (expr.value < 0 || expr.value > 32) { /* check range */
|
|
asm_error("Shift count of %d is invalid", expr.value);
|
|
expr.value = 0;
|
|
}
|
|
|
|
writew(opcode | (expr.value & 0x3F), FALSE); /* put shift count into displacement field */
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* x_mdm - MDM instruction
|
|
********************************************************************************************/
|
|
|
|
void x_mdm (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
int opcode = basic_opcode(op, mods);
|
|
|
|
if (*label) /* define label */
|
|
set_symbol(label, org, TRUE, relocate);
|
|
/* oh dear: bug here */
|
|
asm_error("'%s' is not yet supported", op->mnem);
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* x_exit - EXIT directive. Assembler manual says it treats like CALL $EXIT, but
|
|
* object code reveals the truth: jump to $EXIT, which is a small value, so we can use LDX.
|
|
********************************************************************************************/
|
|
|
|
void x_exit (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
char nline[120];
|
|
|
|
format_line(nline, label, "LDX", "X", DOLLAREXIT, "");
|
|
parse_line(nline);
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* x_opt - .OPT directive. Nonstandard. Possible values:
|
|
*
|
|
* .OPT CEXPR - use C precedence in evaluating expressions rather than strict left-right. The real
|
|
* 1130 assembler was left-to-right. Enabling CEXPR enables precedence and makes the
|
|
* assembler NON STANDARD.
|
|
********************************************************************************************/
|
|
|
|
void x_opt (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
char *tok;
|
|
|
|
org_advanced = 0; /* * means this address */
|
|
|
|
if (*label) {
|
|
asm_error("Label not permitted on .OPT statement");
|
|
return;
|
|
}
|
|
/* look for OPT arguments */
|
|
for (tok = strtok(arg, ","); tok != NULL; tok = strtok(NULL, ",")) {
|
|
if (strcmp(tok, "CEXPR") == 0) {
|
|
cexpr = TRUE; /* use C expression precedence (untested) */
|
|
}
|
|
else
|
|
asm_error("Unknown .OPT: '%s'", tok);
|
|
}
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* askip - skip input lines until a line with the target label appears
|
|
********************************************************************************************/
|
|
|
|
void askip (char *target)
|
|
{
|
|
char nline[200], cur_label[20], *c;
|
|
|
|
while (get_line(nline, sizeof(nline), TRUE)) { /* read next line (but don't exit a macro) */
|
|
listout(FALSE); /* end listing of previous input line */
|
|
|
|
prep_line(nline); /* preform standard line prep */
|
|
|
|
strncpy(cur_label, nline, 6); /* get first 5 characters */
|
|
cur_label[5] = '\0';
|
|
|
|
for (c = cur_label; *c > ' '; c++) /* truncate at first whitespace */
|
|
;
|
|
*c = '\0';
|
|
/* stop if there's a match */
|
|
if ((target == NULL) ? (cur_label[0] == '\0') : strcmp(target, cur_label) == 0) {
|
|
parse_line(nline); /* process this line */
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (target != NULL)
|
|
asm_error("Label %s not found", target);
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* x_aif - process conditional assembly jump
|
|
********************************************************************************************/
|
|
|
|
void x_aif (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
char *target, *tok;
|
|
EXPR expr1, expr2;
|
|
BOOL istrue;
|
|
enum {OP_EQ, OP_LT, OP_GT, OP_NE, OP_LE, OP_GE} cmp_op;
|
|
|
|
/* label is not entered into the symbol table */
|
|
|
|
arg = skipbl(arg);
|
|
if (*arg != '(') {
|
|
asm_error("AIF operand must start with (");
|
|
return;
|
|
}
|
|
|
|
arg++; /* skip the paren */
|
|
|
|
/* normally whitespace is never found in the arg string (see tabtok and coltok). */
|
|
/* However, spaces inside parens are permitted. */
|
|
|
|
if ((tok = strtok(arg, whitespace)) == NULL) {
|
|
asm_error("AIF missing first expression");
|
|
return;
|
|
}
|
|
|
|
getexpr(tok, FALSE, &expr1);
|
|
|
|
if ((tok = strtok(NULL, whitespace)) == NULL) {
|
|
asm_error("AIF missing conditional operator");
|
|
return;
|
|
}
|
|
|
|
if (strcmp(tok, "EQ") == 0)
|
|
cmp_op = OP_EQ;
|
|
else if (strcmp(tok, "LT") == 0)
|
|
cmp_op = OP_LT;
|
|
else if (strcmp(tok, "GT") == 0)
|
|
cmp_op = OP_GT;
|
|
else if (strcmp(tok, "NE") == 0)
|
|
cmp_op = OP_NE;
|
|
else if (strcmp(tok, "LE") == 0)
|
|
cmp_op = OP_LE;
|
|
else if (strcmp(tok, "GE") == 0)
|
|
cmp_op = OP_GE;
|
|
else {
|
|
asm_error("AIF: %s is not a valid conditional operator", tok);
|
|
return;
|
|
}
|
|
|
|
if ((tok = strtok(NULL, ")")) == NULL) {
|
|
asm_error("AIF missing second expression");
|
|
return;
|
|
}
|
|
|
|
getexpr(tok, FALSE, &expr2);
|
|
|
|
switch (cmp_op) { /* test the condition */
|
|
case OP_EQ: istrue = expr1.value == expr2.value; break;
|
|
case OP_LT: istrue = expr1.value < expr2.value; break;
|
|
case OP_GT: istrue = expr1.value > expr2.value; break;
|
|
case OP_NE: istrue = expr1.value != expr2.value; break;
|
|
case OP_LE: istrue = expr1.value <= expr2.value; break;
|
|
case OP_GE: istrue = expr1.value >= expr2.value; break;
|
|
default: bail("in aif, can't happen");
|
|
}
|
|
|
|
/* After the closing paren coltok and tabtok guarantee we will have no whitespace */
|
|
|
|
if ((target = strtok(arg, ",")) == NULL) /* get target label */
|
|
asm_warning("Missing target label");
|
|
|
|
if (istrue)
|
|
askip(target); /* skip to the target */
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* x_aifb - conditional assembly jump back (macro only)
|
|
********************************************************************************************/
|
|
|
|
void x_aifb (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
asm_error("aifb valid in macros only and not implemented in any case");
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* x_ago
|
|
********************************************************************************************/
|
|
|
|
void x_ago (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
char *target;
|
|
|
|
/* label is not entered into the symbol table */
|
|
|
|
/* handle differently in a macro */
|
|
|
|
if ((target = strtok(arg, ",")) == NULL) /* get target label */
|
|
asm_warning("Missing target label");
|
|
|
|
askip(target); /* skip to the target */
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* x_agob -
|
|
********************************************************************************************/
|
|
|
|
void x_agob (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
asm_error("agob valid in macros only and not implemented in any case");
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* x_anop -
|
|
********************************************************************************************/
|
|
|
|
void x_anop (struct tag_op *op, char *label, char *mods, char *arg)
|
|
{
|
|
/* label is not entered into the symbol table */
|
|
/* do nothing else */
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* expression parser, borrowed from older code, no comments, sorry
|
|
********************************************************************************************/
|
|
|
|
char *exprptr, *oexprptr;
|
|
|
|
#define GETNEXT (*exprptr++)
|
|
#define UNGET --exprptr
|
|
|
|
#define LETTER 0 /* character types */
|
|
#define DIGIT 1
|
|
#define ETC 2
|
|
#define ILL 3
|
|
#define SPACE 4
|
|
#define MULOP 5
|
|
#define ADDOP 6
|
|
#define EXPOP 7
|
|
|
|
int getnb (void);
|
|
void c_expr (EXPR *ap);
|
|
void c_expr_m (EXPR *ap);
|
|
void c_expr_e (EXPR *ap);
|
|
void c_expr_u (EXPR *ap);
|
|
void c_term (EXPR *ap);
|
|
int c_number (int c, int r, int nchar);
|
|
int digit (int c, int r);
|
|
int c_esc (int c);
|
|
void exprerr (int n);
|
|
void a1130_expr (EXPR *ap);
|
|
void a1130_term (EXPR *ap);
|
|
|
|
char ctype[128] = { /* character types */
|
|
/*^0ABCDEFG */ ILL, ILL, ILL, ILL, ILL, ILL, ILL, ILL,
|
|
/*^HIJKLMNO */ ILL, SPACE, SPACE, ILL, SPACE, SPACE, ILL, ILL,
|
|
/*^PQRSTUVW */ ILL, ILL, ILL, ILL, ILL, ILL, ILL, ILL,
|
|
/*^XYZ */ ILL, ILL, ILL, ILL, ILL, ILL, ILL, ILL,
|
|
/* !"#$%&' */ SPACE, ETC, ETC, LETTER, LETTER, MULOP, MULOP, LETTER, /* $ # @ and ' are letters here */
|
|
/* ()*+,-./ */ ETC, ETC, MULOP, ADDOP, ETC, ADDOP, ETC, MULOP,
|
|
/* 01234567 */ DIGIT, DIGIT, DIGIT, DIGIT, DIGIT, DIGIT, DIGIT, DIGIT,
|
|
/* 89:;<=>? */ DIGIT, DIGIT, ETC, ETC, MULOP, ETC, MULOP, ETC,
|
|
/* @ABCDEFG */ LETTER, LETTER, LETTER, LETTER, LETTER, LETTER, LETTER, LETTER,
|
|
/* HIJKLMNO */ LETTER, LETTER, LETTER, LETTER, LETTER, LETTER, LETTER, LETTER,
|
|
/* PQRSTUVW */ LETTER, LETTER, LETTER, LETTER, LETTER, LETTER, LETTER, LETTER,
|
|
/* XYZ[\]^_ */ LETTER, LETTER, LETTER, ETC, ETC, ETC, EXPOP, LETTER,
|
|
/* `abcdefg */ ETC, LETTER, LETTER, LETTER, LETTER, LETTER, LETTER, LETTER,
|
|
/* hijklmno */ LETTER, LETTER, LETTER, LETTER, LETTER, LETTER, LETTER, LETTER,
|
|
/* pqrstuvw */ LETTER, LETTER, LETTER, LETTER, LETTER, LETTER, LETTER, LETTER,
|
|
/* xyz{|}~ */ LETTER, LETTER, LETTER, ETC, ADDOP, ETC, ETC, ETC
|
|
};
|
|
|
|
char *errstr[] = {
|
|
"Missing exponent", /* 0 */
|
|
"Undefined symbol", /* 1 */
|
|
"Division by zero", /* 2 */
|
|
"Illegal operator", /* 3 */
|
|
") expected", /* 4 */
|
|
"Char expected after '", /* 5 */
|
|
"Char expected after .", /* 6 */
|
|
"Number expected after =", /* 7 */
|
|
"Syntax error", /* 8 */
|
|
"Number syntax", /* 9 */
|
|
"Char expected after \\", /* 10 */
|
|
"Relocation error" /* 11 */
|
|
};
|
|
|
|
int getnb () {
|
|
int c;
|
|
|
|
if (cexpr) { /* in C mode, handle normally */
|
|
while (ctype[(c = GETNEXT)] == SPACE)
|
|
;
|
|
} /* in 1130 mode, a space terminates the expression. Here, eat the rest */
|
|
else if ((c = GETNEXT) == ' ') {
|
|
while ((c = GETNEXT) != '\0')
|
|
;
|
|
}
|
|
|
|
return c;
|
|
}
|
|
|
|
int symbest, exprerrno;
|
|
jmp_buf exprjmp;
|
|
|
|
/********************************************************************************************
|
|
* getexpr
|
|
********************************************************************************************/
|
|
|
|
int getexpr (char *pc, BOOL undefined_ok, EXPR *pval)
|
|
{
|
|
symbest = S_DEFINED; /* assume no questionable symbols */
|
|
|
|
pval->value = 0;
|
|
pval->relative = ABSOLUTE;
|
|
|
|
if (! *pc) /* blank expression is same as zero, ok? */
|
|
return S_DEFINED;
|
|
|
|
if (setjmp(exprjmp) != 0) { /* encountered a syntax error & bailed */
|
|
pval->value = 0;
|
|
pval->relative = ABSOLUTE;
|
|
return S_UNDEFINED;
|
|
}
|
|
|
|
exprptr = oexprptr = pc; /* make global the buffer pointer */
|
|
|
|
c_expr(pval);
|
|
|
|
if (GETNEXT) /* expression should have been entirely eaten */
|
|
exprerr(8); /* if characters are left, it's an error */
|
|
|
|
if (pval->relative < 0 || pval->relative > 1)
|
|
exprerr(11); /* has to work out to an absolute or a single relative term */
|
|
|
|
if (symbest == S_DEFINED) /* tell how it came out */
|
|
return S_DEFINED;
|
|
|
|
pval->value = 0;
|
|
pval->relative = ABSOLUTE;
|
|
return (pass == 1 && undefined_ok) ? S_PROVISIONAL : S_UNDEFINED;
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* output_literals - construct .DC assembler lines to assemble pending literal
|
|
* constant values that have accumulated.
|
|
********************************************************************************************/
|
|
|
|
void output_literals (BOOL eof)
|
|
{
|
|
char line[120], label[12], num[20];
|
|
int i;
|
|
|
|
for (i = 0; i < n_literals; i++) { /* generate DC statements for any pending literal constants */
|
|
if (literal[i].even && literal[i].hex) /* create the value string */
|
|
sprintf(num, "/%08lX", literal[i].value);
|
|
else if (literal[i].even)
|
|
sprintf(num, "%ld", literal[i].value);
|
|
else if (literal[i].hex)
|
|
sprintf(num, "/%04X", literal[i].value & 0xFFFF);
|
|
else
|
|
sprintf(num, "%d", literal[i].value);
|
|
|
|
sprintf(label, "_L%03d", literal[i].tagno);
|
|
format_line(line, label, literal[i].even ? "DEC" : "DC", "", num, "GENERATED LITERAL CONSTANT");
|
|
|
|
if (eof) {
|
|
eof = FALSE; /* at end of file, for first literal, only prepare blank line */
|
|
sprintf(listline, LEFT_MARGIN, org);
|
|
}
|
|
else
|
|
listout(TRUE); /* push out any pending line(s) */
|
|
|
|
if (flist && list_on) /* this makes stuff appear in the listing */
|
|
sprintf(listline, LEFT_MARGIN " %s", detab(line));
|
|
|
|
nwout = 0;
|
|
|
|
parse_line(line); /* assemble the constant definition */
|
|
}
|
|
|
|
n_literals = 0; /* clear list */
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* a1130_term - extract one term of an expression using 1130 assembler syntax (no precedence!)
|
|
********************************************************************************************/
|
|
|
|
void a1130_term (EXPR *ap)
|
|
{
|
|
PSYMBOL s;
|
|
char token[80], *t;
|
|
int c;
|
|
|
|
if (cexpr) { /* use C syntax and operator precedence */
|
|
c_term(ap);
|
|
return;
|
|
}
|
|
|
|
c = GETNEXT;
|
|
|
|
if (ctype[c] == DIGIT) { /* number */
|
|
ap->value = signextend(c_number(c,10,-1));
|
|
ap->relative = ABSOLUTE;
|
|
}
|
|
else if (c == '+') { /* unary + */
|
|
a1130_term(ap);
|
|
}
|
|
else if (c == '-') { /* unary - */
|
|
a1130_term(ap);
|
|
ap->value = - ap->value;
|
|
}
|
|
else if (c == '/') { /* / starts a hex constant */
|
|
ap->value = signextend(c_number(c,16,-1));
|
|
ap->relative = ABSOLUTE;
|
|
}
|
|
else if (c == '*') { /* asterisk alone = org */
|
|
ap->value = org + org_advanced; /* here is where that offset matters! */
|
|
ap->relative = relocate;
|
|
}
|
|
else if (c == '.') { /* EBCDIC constant */
|
|
c = GETNEXT;
|
|
if (c == '\0') {
|
|
UNGET;
|
|
c = ' ';
|
|
}
|
|
c = ascii_to_ebcdic_table[c];
|
|
ap->value = c; /* VALUE IS IN LOW BYTE!!! */
|
|
ap->relative = ABSOLUTE;
|
|
}
|
|
else if (ctype[c] == LETTER) { /* symbol */
|
|
t = token;
|
|
do {
|
|
*t++ = c;
|
|
c = GETNEXT;
|
|
} while (ctype[c] == LETTER || ctype[c] == DIGIT);
|
|
UNGET;
|
|
*t++ = '\0';
|
|
|
|
s = lookup_symbol(token, TRUE);
|
|
add_xref(s, FALSE);
|
|
ap->value = s->value;
|
|
ap->relative = s->relative;
|
|
|
|
symbest = MIN(symbest, s->defined); /* this goes to lowest value (undefined < provisional < defined) */
|
|
if (pass == 2 && s->defined != S_DEFINED)
|
|
exprerr(1);
|
|
}
|
|
else
|
|
exprerr(8);
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* signextend - sign-extend a 16-bit constant value to whatever "int" is.
|
|
********************************************************************************************/
|
|
|
|
int signextend (int v)
|
|
{
|
|
v &= 0xFFFF; /* clip to 16 bits (this may not be necessary, but best to be safe?) */
|
|
|
|
if (v & 0x8000) /* if sign bit is set */
|
|
v |= ~0xFFFF; /* sign extend */
|
|
|
|
return v;
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* c_expr - evalate an expression using C syntax
|
|
********************************************************************************************/
|
|
|
|
void c_expr (EXPR *ap)
|
|
{
|
|
int c;
|
|
EXPR rop;
|
|
|
|
c_expr_m(ap); /* get combined multiplicative terms */
|
|
for (;;) { /* handle +/- precedence operators */
|
|
if (ctype[c=getnb()] != ADDOP) {
|
|
UNGET;
|
|
break;
|
|
}
|
|
c_expr_m(&rop); /* right hand operand */
|
|
switch (c) {
|
|
case '+':
|
|
ap->value += rop.value;
|
|
ap->relative += rop.relative;
|
|
break;
|
|
|
|
case '-':
|
|
ap->value -= rop.value;
|
|
ap->relative -= rop.relative;
|
|
break;
|
|
|
|
case '|':
|
|
if (ap->relative || rop.relative)
|
|
exprerr(11);
|
|
ap->value = ((long) (ap->value)) | ((long) rop.value);
|
|
break;
|
|
|
|
default:
|
|
printf("In expr, can't happen\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* c_expr_m - get multiplicative precedence terms. Again, this is not usually used
|
|
********************************************************************************************/
|
|
|
|
void c_expr_m (EXPR *ap)
|
|
{
|
|
int c;
|
|
EXPR rop;
|
|
|
|
c_expr_e(ap); /* get exponential precedence term */
|
|
for (;;) { /* get operator */
|
|
c = getnb();
|
|
if ((c=='<') || (c=='>'))
|
|
if (c != getnb()) /* << or >> */
|
|
exprerr(3);
|
|
if (ctype[c] != MULOP) {
|
|
UNGET;
|
|
break;
|
|
}
|
|
c_expr_e(&rop); /* right hand operand */
|
|
|
|
switch(c) {
|
|
case '*':
|
|
if (ap->relative && rop.relative)
|
|
exprerr(11);
|
|
|
|
ap->value *= rop.value;
|
|
ap->relative = (ap->relative || rop.relative) ? RELATIVE : ABSOLUTE;
|
|
break;
|
|
|
|
case '/':
|
|
if (rop.value == 0)
|
|
exprerr(2);
|
|
if (ap->relative || rop.relative)
|
|
exprerr(11);
|
|
|
|
ap->value /= rop.value;
|
|
break;
|
|
|
|
case '%':
|
|
if (rop.value == 0)
|
|
exprerr(2);
|
|
if (ap->relative || rop.relative)
|
|
exprerr(11);
|
|
|
|
ap->value = ((long) (ap->value)) % ((long) rop.value);
|
|
break;
|
|
|
|
case '&':
|
|
if (ap->relative || rop.relative)
|
|
exprerr(11);
|
|
|
|
ap->value = ((long) (ap->value)) & ((long) rop.value);
|
|
break;
|
|
|
|
case '>':
|
|
if (ap->relative || rop.relative)
|
|
exprerr(11);
|
|
|
|
ap->value = ((long) (ap->value)) >> ((long) rop.value);
|
|
break;
|
|
|
|
case '<':
|
|
if (ap->relative || rop.relative)
|
|
exprerr(11);
|
|
|
|
ap->value = ((long) (ap->value)) << ((long) rop.value);
|
|
break;
|
|
|
|
default:
|
|
printf("In expr_m, can't happen\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* c_expr_e - get exponential precedence terms. Again, this is not usually used
|
|
********************************************************************************************/
|
|
|
|
void c_expr_e (EXPR *ap)
|
|
{
|
|
int c, i, v;
|
|
EXPR rop;
|
|
|
|
c_expr_u(ap);
|
|
for (;;) {
|
|
c = getnb();
|
|
if (ctype[c] != EXPOP) {
|
|
UNGET;
|
|
break;
|
|
}
|
|
c_expr_u(&rop);
|
|
|
|
switch(c) {
|
|
case '^':
|
|
if (ap->relative || rop.relative)
|
|
exprerr(11);
|
|
|
|
v = ap->value;
|
|
ap->value = 1;
|
|
for (i = 0; i < rop.value; i++)
|
|
ap->value *= v;
|
|
break;
|
|
|
|
default:
|
|
printf("In expr_e, can't happen\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* c_expr_u - get unary precedence terms. Again, this is not usually used
|
|
********************************************************************************************/
|
|
|
|
void c_expr_u (EXPR *ap)
|
|
{
|
|
int c;
|
|
|
|
if ((c = getnb()) == '!') {
|
|
a1130_term(ap);
|
|
ap->value = ~ ((long)(ap->value));
|
|
if (ap->relative)
|
|
exprerr(11);
|
|
}
|
|
else if (c == '-') {
|
|
a1130_term(ap);
|
|
ap->value = - ap->value;
|
|
if (ap->relative)
|
|
exprerr(11);
|
|
}
|
|
else {
|
|
UNGET;
|
|
a1130_term(ap);
|
|
}
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* c_term - get basic operand or parenthesized expression. Again, this is not usually used
|
|
********************************************************************************************/
|
|
|
|
void c_term (EXPR *ap)
|
|
{
|
|
int c, cc;
|
|
PSYMBOL s;
|
|
char token[80], *t;
|
|
|
|
ap->relative = ABSOLUTE; /* assume absolute */
|
|
|
|
if ((c = getnb()) == '(') { /* parenthesized expr */
|
|
c_expr(ap); /* start over at the top! */
|
|
if ((cc = getnb()) != ')')
|
|
exprerr(4);
|
|
}
|
|
else if (c == '\'') { /* single quote: char */
|
|
if ((c = GETNEXT) == '\0')
|
|
c = ' ';
|
|
ap->value = c_esc(c);
|
|
}
|
|
else if (ctype[c] == DIGIT) { /* number */
|
|
ap->value = signextend(c_number(c,10,-1));
|
|
}
|
|
else if (c == '0') { /* 0 starts a hex or octal constant */
|
|
if ((c = GETNEXT) == 'x') {
|
|
c = GETNEXT;
|
|
ap->value = signextend(c_number(c,16,-1));
|
|
}
|
|
else {
|
|
ap->value = signextend(c_number(c,8,-1));
|
|
}
|
|
}
|
|
else if (c == '*') { /* asterisk alone = org */
|
|
ap->value = org + org_advanced;
|
|
ap->relative = relocate;
|
|
}
|
|
else if (ctype[c] == LETTER) { /* symbol */
|
|
t = token;
|
|
do {
|
|
*t++ = c;
|
|
c = GETNEXT;
|
|
} while (ctype[c] == LETTER || ctype[c] == DIGIT);
|
|
UNGET;
|
|
*t++ = '\0';
|
|
|
|
s = lookup_symbol(token, TRUE);
|
|
ap->value = s->value;
|
|
ap->relative = s->relative;
|
|
add_xref(s, FALSE);
|
|
symbest = MIN(symbest, s->defined); /* this goes to lowest value (undefined < provisional < defined) */
|
|
|
|
if (pass == 2 && s->defined != S_DEFINED)
|
|
exprerr(1);
|
|
}
|
|
else
|
|
exprerr(8);
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* c_number - get a C format constant value. Again, this is not usually used
|
|
********************************************************************************************/
|
|
|
|
int c_number (int c, int r, int nchar)
|
|
{
|
|
int v, n;
|
|
|
|
nchar--;
|
|
|
|
if (c == '/' && ! cexpr) { /* special radix stuff */
|
|
r = 16;
|
|
c = GETNEXT;
|
|
}
|
|
else if (r == 10 && c == '0' && cexpr) { /* accept C style 0x## also */
|
|
c = GETNEXT;
|
|
if (c == 'x') {
|
|
r = 16;
|
|
c = GETNEXT;
|
|
}
|
|
else {
|
|
r = 8;
|
|
UNGET;
|
|
c = '0';
|
|
}
|
|
}
|
|
|
|
n = 0; /* decode number */
|
|
while ((nchar-- != 0) && (v = digit(c, r)) >= 0) {
|
|
if (v >= r) /* out of range! */
|
|
exprerr(9);
|
|
|
|
n = r*n + v;
|
|
|
|
c = GETNEXT;
|
|
if (c == '.') { /* maybe make it decimal? */
|
|
c = GETNEXT;
|
|
break;
|
|
}
|
|
}
|
|
|
|
UNGET;
|
|
return (n);
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* digit - get digit value of character c in radix r
|
|
********************************************************************************************/
|
|
|
|
int digit (int c, int r)
|
|
{
|
|
if (r == 16) {
|
|
if (c >= 'A' && c <= 'F')
|
|
return (c - 'A' + 10);
|
|
}
|
|
|
|
if (c >= '0' && c <= '9')
|
|
return (c - '0');
|
|
|
|
return (-1);
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* c_esc - handle C character escape
|
|
********************************************************************************************/
|
|
|
|
int c_esc (int c)
|
|
{
|
|
if (c != '\\') /* not escaped */
|
|
return(c);
|
|
|
|
if ((c = GETNEXT) == '\0') /* must be followed by something */
|
|
exprerr(10);
|
|
if ((c >= 'A') && (c <= 'Z')) /* handle upper case */
|
|
c += 'a'-'A';
|
|
if (ctype[c] == LETTER) /* control character abbrevs */
|
|
switch (c) {
|
|
case 'b': c = '\b'; break; /* backspace */
|
|
case 'e': c = 27 ; break; /* escape */
|
|
case 'f': c = '\f'; break; /* formfeed */
|
|
case 'n': c = '\n'; break; /* newline */
|
|
case 'r': c = '\r'; break; /* return */
|
|
case 't': c = '\t'; break; /* horiz. tab */
|
|
}
|
|
else if (ctype[c] == DIGIT) { /* get character by the numbers */
|
|
c = c_number(c,8,3); /* force octal */
|
|
}
|
|
|
|
return c;
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* exprerr - note an expression syntax error. Longjumps back to caller with failure code
|
|
********************************************************************************************/
|
|
|
|
void exprerr (int n)
|
|
{
|
|
char msg[256];
|
|
int nex = exprptr-oexprptr;
|
|
|
|
strncpy(msg, oexprptr, nex); /* show where the problem was */
|
|
msg[nex] = '\0';
|
|
strcat(msg, " << ");
|
|
strcat(msg, errstr[n]);
|
|
|
|
asm_error(msg);
|
|
|
|
exprerrno = n;
|
|
longjmp(exprjmp, 1);
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* upcase - force a string to uppercase (ASCII)
|
|
********************************************************************************************/
|
|
|
|
char *upcase (char *str)
|
|
{
|
|
char *s;
|
|
|
|
for (s = str; *s; s++) {
|
|
if (*s >= 'a' && *s <= 'z')
|
|
*s -= 32;
|
|
}
|
|
|
|
return str;
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* hollerith table for IPL card ident field
|
|
********************************************************************************************/
|
|
|
|
typedef struct {
|
|
int hollerith;
|
|
char ascii;
|
|
} CPCODE;
|
|
|
|
static CPCODE cardcode_029[] =
|
|
{
|
|
0x0000, ' ',
|
|
0x8000, '&', /* + in 026 Fortran */
|
|
0x4000, '-',
|
|
0x2000, '0',
|
|
0x1000, '1',
|
|
0x0800, '2',
|
|
0x0400, '3',
|
|
0x0200, '4',
|
|
0x0100, '5',
|
|
0x0080, '6',
|
|
0x0040, '7',
|
|
0x0020, '8',
|
|
0x0010, '9',
|
|
0x9000, 'A',
|
|
0x8800, 'B',
|
|
0x8400, 'C',
|
|
0x8200, 'D',
|
|
0x8100, 'E',
|
|
0x8080, 'F',
|
|
0x8040, 'G',
|
|
0x8020, 'H',
|
|
0x8010, 'I',
|
|
0x5000, 'J',
|
|
0x4800, 'K',
|
|
0x4400, 'L',
|
|
0x4200, 'M',
|
|
0x4100, 'N',
|
|
0x4080, 'O',
|
|
0x4040, 'P',
|
|
0x4020, 'Q',
|
|
0x4010, 'R',
|
|
0x3000, '/',
|
|
0x2800, 'S',
|
|
0x2400, 'T',
|
|
0x2200, 'U',
|
|
0x2100, 'V',
|
|
0x2080, 'W',
|
|
0x2040, 'X',
|
|
0x2020, 'Y',
|
|
0x2010, 'Z',
|
|
0x0820, ':',
|
|
0x0420, '#', /* = in 026 Fortran */
|
|
0x0220, '@', /* ' in 026 Fortran */
|
|
0x0120, '\'',
|
|
0x00A0, '=',
|
|
0x0060, '"',
|
|
0x8820, 'c', /* cent */
|
|
0x8420, '.',
|
|
0x8220, '<', /* ) in 026 Fortran */
|
|
0x8120, '(',
|
|
0x80A0, '+',
|
|
0x8060, '|',
|
|
0x4820, '!',
|
|
0x4420, '$',
|
|
0x4220, '*',
|
|
0x4120, ')',
|
|
0x40A0, ';',
|
|
0x4060, 'n', /* not */
|
|
0x2820, 'x', /* what? */
|
|
0x2420, ',',
|
|
0x2220, '%', /* ( in 026 Fortran */
|
|
0x2120, '_',
|
|
0x20A0, '>',
|
|
0x2060, '>',
|
|
};
|
|
|
|
/********************************************************************************************
|
|
* ascii_to_hollerith -
|
|
********************************************************************************************/
|
|
|
|
int ascii_to_hollerith (int ch)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < sizeof(cardcode_029) / sizeof(CPCODE); i++)
|
|
if (cardcode_029[i].ascii == ch)
|
|
return cardcode_029[i].hollerith;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/********************************************************************************************
|
|
* detab - replace tabs with spaces for listing files
|
|
********************************************************************************************/
|
|
|
|
char *detab (char *instr)
|
|
{
|
|
static char outstr[256];
|
|
char *out = outstr;
|
|
int col = 0;
|
|
|
|
while (*instr) {
|
|
if (*instr == '\t') {
|
|
do {
|
|
*out++ = ' ';
|
|
col++;
|
|
}
|
|
while (col & 7);
|
|
}
|
|
else {
|
|
*out++ = *instr;
|
|
col++;
|
|
}
|
|
|
|
instr++;
|
|
}
|
|
|
|
*out = '\0';
|
|
|
|
return outstr;
|
|
}
|
|
|
|
#ifndef _WIN32
|
|
|
|
/********************************************************************************************
|
|
* routines provided by Microsoft C but not others
|
|
********************************************************************************************/
|
|
|
|
int strnicmp (char *a, char *b, int n)
|
|
{
|
|
int ca, cb;
|
|
|
|
for (;;) {
|
|
if (--n < 0) /* still equal after n characters? quit now */
|
|
return 0;
|
|
|
|
if ((ca = *a) == 0) /* get character, stop on null terminator */
|
|
return *b ? -1 : 0;
|
|
|
|
if (ca >= 'a' && ca <= 'z') /* fold lowercase to uppercase */
|
|
ca -= 32;
|
|
|
|
cb = *b;
|
|
if (cb >= 'a' && cb <= 'z')
|
|
cb -= 32;
|
|
|
|
if ((ca -= cb) != 0) /* if different, return comparison */
|
|
return ca;
|
|
|
|
a++, b++;
|
|
}
|
|
}
|
|
|
|
int strcmpi (char *a, char *b)
|
|
{
|
|
int ca, cb;
|
|
|
|
for (;;) {
|
|
if ((ca = *a) == 0) /* get character, stop on null terminator */
|
|
return *b ? -1 : 0;
|
|
|
|
if (ca >= 'a' && ca <= 'z') /* fold lowercase to uppercase */
|
|
ca -= 32;
|
|
|
|
cb = *b;
|
|
if (cb >= 'a' && cb <= 'z')
|
|
cb -= 32;
|
|
|
|
if ((ca -= cb) != 0) /* if different, return comparison */
|
|
return ca;
|
|
|
|
a++, b++;
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|