seppdroid/Digital-Research-Source-Code
1
0
Fork 0
mirror of https://github.com/SEPPDROID/Digital-Research-Source-Code.git synced 2025-10-25 17:34:06 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Upload

Browse Source 
Digital Research
This commit is contained in:
Sepp J Morris
2020-11-06 18:50:37 +01:00
parent 621ed8ccaf
commit 31738079c4
8481 changed files with 1888323 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

408
CPM OPERATING SYSTEMS/CPM 68K/1.0X SOURCES/v102/as68/as68.h Normal file
View File

@@ -0,0 +1,408 @@
/*
Copyright 1981
Alcyon Corporation
8716 Production Ave.
San Diego, Ca. 92121
*/
#include <stdio.h>
#include <klib.h>
#include "machine.h"
#include "ctype.h"
#ifdef PDP11
struct {
char lobyte;
char hibyte;
};
struct {
char *ptrw1;
char *ptrw2;
};
struct {
int wd1;
int wd2;
};
struct {
int swd1;
};
#endif
#ifdef MC68000
struct {
char hibyte;
char lobyte;
};
struct {
char *ptrw2;
};
struct {
int wd1;
int wd2;
};
struct {
int swd1;
};
#endif
#ifdef VAX
struct {
short wd2;
short wd1;
};
struct {
short swd1;
};
struct {
char lobyte;
char hibyte;
};
struct {
char *ptrw2;
};
#endif
/* format of a symbol entry in the main table*/
# define NAMELEN 8 /*length of name in symbol table*/
struct symtab {
char name[NAMELEN]; /*symbol name*/
short flags; /*bit flags*/
char *tlnk; /*table link*/
long vl1; /*symbol value*/
};
struct symtab *symtptr;
# define STESIZE (sizeof *symtptr) /*byte length of symbol table entry*/
/* flags for symbols*/
# define SYDF 0100000 /*defined*/
# define SYEQ 0040000 /*equated*/
# define SYGL 0020000 /*global - entry or external*/
# define SYER 0010000 /*equated register*/
# define SYXR 0004000 /*external reference*/
# define SYRA 0002000 /*DATA based relocatable*/
# define SYRO 0001000 /*TEXT based relocatable*/
# define SYBS 0000400 /*BSS based relocatable*/
# define SYIN 0000200 /*internal symbol -- opcode, directive or equ*/
# define SYPC 0000100 /*[vlh]equated using star '*' expression*/
# define SYRM 0000040 /*[vlh]register mask equate*/
/*flags for opcodes and directives*/
# define OPDR 0100000 /*0=>opcode, 1=>directive*/
# define OPFF 037 /*type of instruction (used as mask)*/
struct irts {
char *irle; /*ptr to last entry in chain*/
char *irfe; /*ptr to first entry in chain*/
};
long stlen; /*length of symbol table*/
/*
* intermediate text file
* format of the intermediate text for one statement:
*
* ******************************************************
* * it type = ITBS * # it entries * 0
* ******************************************************
* * absolute line number (long) *
* ******************************************************
* * it type = ITSY * instr length * 1
* ******************************************************
* * symbol table pointer for stmt label (long) *
* ******************************************************
* * it type = ITSY * instr mode length * 2
* ******************************************************
* * opcode ptr (long) *
* ******************************************************
* * it type = ITCN * relocation base * 3
* ******************************************************
* * location counter (pass 1) *
* ******************************************************
* * it type * relocation flag * 4 - oprnds
* ******************************************************
* * value (long) *
* ******************************************************
* .
*
* .
* ******************************************************
* * it type * relocation flag * n - oprnds
* ******************************************************
* * value (long) *
* ******************************************************
*/
#define ITOP1 4 /*first it entry for operands*/
/*
* it type meaning
* 0 beginning of statement
* 1 value is pointer to symbol table
* 2 value is a constant
* 3 value is a specal char
*
* relocation flag for opcode it entry is operand length:
* 'b' => byte
* 'w' => word
* 'l' => long
*/
struct it {
char itty; /*it type*/
char itrl; /*relocation flag or # it entries*/
long itop;
};
int mode; /*operand mode (byte, word, long)*/
int modelen; /*operand length per mode*/
#define BYTE 'b'
#define WORD 'w'
#define LONG 'l'
/* parameters that define the main table*/
#define SZMT 300 /*initial size of the main table */
/*must be large enough to initialize*/
#ifdef PDP11
#define ICRSZMT 10 /*add to main table when run out*/
#else
#define ICRSZMT 50 /*add to main table when run out*/
#endif
int cszmt; /*current size of main table*/
char *bmte; /*beginning of main table*/
char *emte; /*end of main table*/
/* intermediate text types*/
#define ITBS 0 /*beginning of statement*/
#define ITSY 1 /*pointer to symbol table*/
#define ITCN 2 /*constant*/
#define ITSP 3 /*special*/
#define ITRM 4 /*[vlh]register mask!*/
#define ITPC 5 /*[vlh]pc relative argument*/
# define ITBSZ 256 /*size of the it buffer*/
short itbuf[ITBSZ]; /*it buffer*/
#define STMAX 200 /*size of intermediate text buffer*/
struct it stbuf[STMAX]; /*holds it for one statement*/
char sbuf[512]; /*holds one block of source*/
/*initial reference table for symbols*/
# define SZIRT 128
char *sirt[SZIRT];
/*initial reference table to opcodes*/
char *oirt[SZIRT];
/*external symbol table*/
#define EXTSZ 512
char *extbl[EXTSZ];
int extindx; /*index to external symbol table*/
char **pexti; /*ptr to external symbol table*/
int absln; /*absolute line number*/
int p2absln; /*pass 2 line number*/
int fcflg; /*0=>passed an item. 1=>first char*/
int fchr; /*first char in term*/
int ifn; /*source file descriptor*/
short *pitix; /*ptr to it buffer*/
int itwc; /*number of words in it buffer*/
struct it *pitw; /*ptr to it buffer next entry*/
int itype; /*type of item*/
long ival; /*value of item*/
char *lblpt; /*label pointer*/
char lbt[NAMELEN]; /*holds label name*/
char *lmte; /*last entry in main table*/
long loctr; /*location counter*/
long savelc[4]; /*save relocation counters for 3 bases*/
int nite; /*number of entries in stbuf*/
struct it *pnite;
int lfn; /*loader output file descriptor*/
char *opcpt; /*pointer to opcode entry in main table*/
int p2flg; /*0=>pass 1 1=>pass 2*/
char **pirt; /*entry in initial reference table*/
int reloc; /*relocation value returned by expression evaluator (expr)*/
int rlflg; /*relocation value of current location counter*/
/*relocation values*/
# define ABS 0 /*absolute*/
# define DATA 1
# define TEXT 2
# define BSS 3
# define EXTRN 4 /*externally defined*/
#define EOLC '\n' /*end of line character*/
#define EOF 0 /*end of file indicator*/
#define NULL 0 /* [vlh] character null '\0' */
#define TRUE 1 /* [vlh] boolean values */
#define FALSE 0 /* [vlh] boolean values */
int format;
int sbuflen; /*number of chars in sbuf*/
char *psbuf; /*ptr into sbuf*/
int itfn; /*it file number*/
char itfnc; /*last char of it file name*/
int trbfn; /*temp for text relocation bits*/
char trbfnc; /*last char of text rb file*/
int dafn; /*file for data stuff*/
char dafnc; /*last char of data file*/
int drbfn; /*file for data relocation bits*/
char drbfnc; /*last char*/
int prtflg; /*print output flag*/
int undflg; /*make undefined symbols external flag*/
int starmul; /* * is multiply operator*/
char *endptr, *addptr;
char *orgptr;
char *subptr, *addiptr, *addqptr, *subiptr, *subqptr;
char *cmpptr, *addaptr, *cmpaptr, *subaptr, *cmpmptr;
char *equptr;
char *andptr, *andiptr, *eorptr, *eoriptr, *orptr, *oriptr;
char *cmpiptr;
char *moveptr, *moveqptr;
char *exgptr;
char *evenptr;
char *jsrptr, *bsrptr, *nopptr;
char peekc;
int numcon[2], numsym[2], indir[2], immed[2], numreg[2];
int plevel; /*parenthesis level counter*/
int opdix; /*operand index counter*/
int p1inlen; /*pass 1 instr length*/
int instrlen; /*pass 2 bytes in current instruction*/
/* effective address mode bits*/
#define DDIR 000
#define ADIR 010
#define INDIRECT 020
#define INDINC 030
#define DECIND 040
#define INDDISP 050
#define INDINX 060
#define SADDR 070
#define LADDR 071
#define IMM 074
#define AREGLO 8
#define AREGHI 15
/* relocation bit definitions:*/
#define RBMASK 07 /*tells type of relocation*/
#define INSABS 7 /*first word of instr -- absolute*/
#define DABS 0 /*data word absolute*/
#define TRELOC 2 /* TEXT relocatable*/
#define DRELOC 1 /* DATA relocatable*/
#define BRELOC 3 /* BSS relocatable*/
#define EXTVAR 4 /* ref to external variable*/
#define LUPPER 5 /* upper word of long*/
#define EXTREL 6 /* external relative mode*/
/* ptrs to ins[] and rlbits[]*/
int *pins;
int *prlb;
int ins[5]; /*holds instruction words*/
#define PRTCHLEN 128
char prtchars[PRTCHLEN]; /*line buffer for putchar*/
char *prtchidx; /*index for putchar*/
int extflg, extref; /*external in expr*/
#define CCR 16
#define SR 17
#define USP 18
#define MOVECCR 042300
#define MOVESR 043300
#define SRMOVE 040300
#define MOVEUSP 047140
struct op {
int ea; /* effective address bits*/
int len; /* effective address length in bytes*/
long con; /*constant or reloc part of operand*/
int drlc; /*reloc of con*/
int ext; /*external variable #*/
int idx; /*index register if any*/
int xmod; /*mode of index reg*/
} opnd[2];
#define OPSTLEN 10
#define TREELEN 20
struct buf{
int fildes;
int nunused;
char *xfree;
char buff[512];
};
struct buf lbuf;
struct buf tbuf;
struct buf dabuf;
struct buf drbuf;
int nerror; /*# of assembler errors*/
int in_err; /*[vlh] don't generate instrlen err if already err state*/
int shortadr; /*short addresses if set*/
#define CLRFOR 24
#define CLRVAL 041000
long itoffset;
#define LASTCHTFN *tfilptr
char *tfilptr; /* -> Changed filename character */
#define PC 22
int equflg; /*doing an equate stmt*/
#define ANDI 01000
#define AND 0140000
#define ORI 0
#define OR 0100000
#define EORI 05000
#define EOR 0130000
#define MOVE 0
long lseek();
char *sbrk();
char *lemt();
int refpc; /* * referenced in expr*/
#define SOH 1
/* Conditional Assembly variables and constants [vlh] */
#define LOW_CA 21 /* [vlh] */
#define HI_CA 30 /* [vlh] */
int ca_true; /* true unless in a false CA*/
int ca; /* depth of conditional assembly, none = 0*/
int ca_level; /* at what CA depth did CA go false?*/
/* pass 1 global variables */
int numops; /*number of operands*/
int inoffset; /*[vlh]offset directive*/
int didorg;
int initflg; /*initialize flag*/
/* defines */
#define igblk() while(fchr==' ') fchr=gchr()
#define ckein() ((pitw >= pnite))
/* is it an alterable operand */
#define memalt(ap) (memea(ap) && altea(ap))
#define dataalt(ap) (dataea(ap) && altea(ap))
#define altea(ap) ((((ap)->ea&070)!=SADDR || ((ap)->ea&6)==0))
/* is it the specific type of operand */
#define memea(ap) (((ap)->ea&070) >= INDIRECT)
#define dataea(ap) (((ap)->ea&070) != ADIR)
#define pcea(ap) ((ap)->ea==072 || (ap)->ea==073)
#define ckdreg(ap) ((ap)->ea>=0 && (ap)->ea<AREGLO)
#define ckareg(ap) ((ap)->ea>=AREGLO && (ap)->ea<=AREGHI)
/*
* DRI Listing Hacks:
*/
char *sfname; /* -> Source file name */
#define LPP 58 /* # lines / page */
int xline; /* Present line # */
int xpage; /* Present Page # */

415
CPM OPERATING SYSTEMS/CPM 68K/1.0X SOURCES/v102/as68/as68.lst Normal file
View File

@@ -0,0 +1,415 @@
1File: AS68.H Page 1
1 /*
2 Copyright 1981
3 Alcyon Corporation
4 8716 Production Ave.
5 San Diego, Ca. 92121
6 */
7 #include <stdio.h>
8 #include <klib.h>
9 #include "machine.h"
10 #include "ctype.h"
11
12 #ifdef PDP11
13 struct {
14 char lobyte;
15 char hibyte;
16 };
17 struct {
18 char *ptrw1;
19 char *ptrw2;
20 };
21 struct {
22 int wd1;
23 int wd2;
24 };
25 struct {
26 int swd1;
27 };
28 #endif
29
30 #ifdef MC68000
31 struct {
32 char hibyte;
33 char lobyte;
34 };
35 struct {
36 char *ptrw2;
37 };
38 struct {
39 int wd1;
40 int wd2;
41 };
42 struct {
43 int swd1;
44 };
45 #endif
46
47 #ifdef VAX
48 struct {
49 short wd2;
50 short wd1;
51 };
52 struct {
53 short swd1;
54 };
55
56 struct {
57 char lobyte;
58 char hibyte;
59 };
1File: AS68.H Page 2
60 struct {
61 char *ptrw2;
62 };
63 #endif
64
65 /* format of a symbol entry in the main table*/
66
67 # define NAMELEN 8 /*length of name in symbol table*/
68 struct symtab {
69 char name[NAMELEN]; /*symbol name*/
70 short flags; /*bit flags*/
71 char *tlnk; /*table link*/
72 long vl1; /*symbol value*/
73 };
74
75 struct symtab *symtptr;
76 # define STESIZE (sizeof *symtptr) /*byte length of symbol table entry*/
77
78 /* flags for symbols*/
79 # define SYDF 0100000 /*defined*/
80 # define SYEQ 0040000 /*equated*/
81 # define SYGL 0020000 /*global - entry or external*/
82 # define SYER 0010000 /*equated register*/
83 # define SYXR 0004000 /*external reference*/
84 # define SYRA 0002000 /*DATA based relocatable*/
85 # define SYRO 0001000 /*TEXT based relocatable*/
86 # define SYBS 0000400 /*BSS based relocatable*/
87 # define SYIN 0000200 /*internal symbol -- opcode, directive or equ*/
88 # define SYPC 0000100 /*[vlh]equated using star '*' expression*/
89 # define SYRM 0000040 /*[vlh]register mask equate*/
90
91 /*flags for opcodes and directives*/
92 # define OPDR 0100000 /*0=>opcode, 1=>directive*/
93 # define OPFF 037 /*type of instruction (used as mask)*/
94
95 struct irts {
96 char *irle; /*ptr to last entry in chain*/
97 char *irfe; /*ptr to first entry in chain*/
98 };
99
100 long stlen; /*length of symbol table*/
101
102 /*
103 * intermediate text file
104 * format of the intermediate text for one statement:
105 *
106 * ******************************************************
107 * * it type = ITBS * # it entries * 0
108 * ******************************************************
109 * * absolute line number (long) *
110 * ******************************************************
111 * * it type = ITSY * instr length * 1
112 * ******************************************************
113 * * symbol table pointer for stmt label (long) *
114 * ******************************************************
115 * * it type = ITSY * instr mode length * 2
116 * ******************************************************
117 * * opcode ptr (long) *
118 * ******************************************************
1File: AS68.H Page 3
119 * * it type = ITCN * relocation base * 3
120 * ******************************************************
121 * * location counter (pass 1) *
122 * ******************************************************
123 * * it type * relocation flag * 4 - oprnds
124 * ******************************************************
125 * * value (long) *
126 * ******************************************************
127 * .
128 *
129 * .
130 * ******************************************************
131 * * it type * relocation flag * n - oprnds
132 * ******************************************************
133 * * value (long) *
134 * ******************************************************
135 */
136
137 #define ITOP1 4 /*first it entry for operands*/
138
139 /*
140 * it type meaning
141 * 0 beginning of statement
142 * 1 value is pointer to symbol table
143 * 2 value is a constant
144 * 3 value is a specal char
145 *
146 * relocation flag for opcode it entry is operand length:
147 * 'b' => byte
148 * 'w' => word
149 * 'l' => long
150 */
151
152 struct it {
153 char itty; /*it type*/
154 char itrl; /*relocation flag or # it entries*/
155 long itop;
156 };
157
158 int mode; /*operand mode (byte, word, long)*/
159 int modelen; /*operand length per mode*/
160 #define BYTE 'b'
161 #define WORD 'w'
162 #define LONG 'l'
163
164 /* parameters that define the main table*/
165 #define SZMT 300 /*initial size of the main table */
166 /*must be large enough to initialize*/
167 #ifdef PDP11
168 #define ICRSZMT 10 /*add to main table when run out*/
169 #else
170 #define ICRSZMT 50 /*add to main table when run out*/
171 #endif
172 int cszmt; /*current size of main table*/
173 char *bmte; /*beginning of main table*/
174 char *emte; /*end of main table*/
175
176 /* intermediate text types*/
177 #define ITBS 0 /*beginning of statement*/
1File: AS68.H Page 4
178 #define ITSY 1 /*pointer to symbol table*/
179 #define ITCN 2 /*constant*/
180 #define ITSP 3 /*special*/
181 #define ITRM 4 /*[vlh]register mask!*/
182 #define ITPC 5 /*[vlh]pc relative argument*/
183
184 # define ITBSZ 256 /*size of the it buffer*/
185 short itbuf[ITBSZ]; /*it buffer*/
186
187 #define STMAX 200 /*size of intermediate text buffer*/
188 struct it stbuf[STMAX]; /*holds it for one statement*/
189
190 char sbuf[512]; /*holds one block of source*/
191
192 /*initial reference table for symbols*/
193 # define SZIRT 128
194 char *sirt[SZIRT];
195
196 /*initial reference table to opcodes*/
197 char *oirt[SZIRT];
198
199 /*external symbol table*/
200 #define EXTSZ 512
201 char *extbl[EXTSZ];
202 int extindx; /*index to external symbol table*/
203 char **pexti; /*ptr to external symbol table*/
204
205 int absln; /*absolute line number*/
206 int p2absln; /*pass 2 line number*/
207 int fcflg; /*0=>passed an item. 1=>first char*/
208 int fchr; /*first char in term*/
209 int ifn; /*source file descriptor*/
210 short *pitix; /*ptr to it buffer*/
211 int itwc; /*number of words in it buffer*/
212 struct it *pitw; /*ptr to it buffer next entry*/
213 int itype; /*type of item*/
214 long ival; /*value of item*/
215 char *lblpt; /*label pointer*/
216 char lbt[NAMELEN]; /*holds label name*/
217 char *lmte; /*last entry in main table*/
218 long loctr; /*location counter*/
219 long savelc[4]; /*save relocation counters for 3 bases*/
220 int nite; /*number of entries in stbuf*/
221 struct it *pnite;
222 int lfn; /*loader output file descriptor*/
223 char *opcpt; /*pointer to opcode entry in main table*/
224 int p2flg; /*0=>pass 1 1=>pass 2*/
225 char **pirt; /*entry in initial reference table*/
226 int reloc; /*relocation value returned by expression evaluator (expr)*/
227 int rlflg; /*relocation value of current location counter*/
228 /*relocation values*/
229 # define ABS 0 /*absolute*/
230 # define DATA 1
231 # define TEXT 2
232 # define BSS 3
233 # define EXTRN 4 /*externally defined*/
234
235 #define EOLC '\n' /*end of line character*/
236 #define EOF 0 /*end of file indicator*/
1File: AS68.H Page 5
237 #define NULL 0 /* [vlh] character null '\0' */
238 #define TRUE 1 /* [vlh] boolean values */
239 #define FALSE 0 /* [vlh] boolean values */
240
241 int format;
242 int sbuflen; /*number of chars in sbuf*/
243 char *psbuf; /*ptr into sbuf*/
244 int itfn; /*it file number*/
245 char itfnc; /*last char of it file name*/
246 int trbfn; /*temp for text relocation bits*/
247 char trbfnc; /*last char of text rb file*/
248 int dafn; /*file for data stuff*/
249 char dafnc; /*last char of data file*/
250 int drbfn; /*file for data relocation bits*/
251 char drbfnc; /*last char*/
252 int prtflg; /*print output flag*/
253 int undflg; /*make undefined symbols external flag*/
254
255 int starmul; /* * is multiply operator*/
256
257 char *endptr, *addptr;
258 char *orgptr;
259 char *subptr, *addiptr, *addqptr, *subiptr, *subqptr;
260 char *cmpptr, *addaptr, *cmpaptr, *subaptr, *cmpmptr;
261 char *equptr;
262 char *andptr, *andiptr, *eorptr, *eoriptr, *orptr, *oriptr;
263 char *cmpiptr;
264 char *moveptr, *moveqptr;
265 char *exgptr;
266 char *evenptr;
267 char *jsrptr, *bsrptr, *nopptr;
268 char peekc;
269 int numcon[2], numsym[2], indir[2], immed[2], numreg[2];
270 int plevel; /*parenthesis level counter*/
271 int opdix; /*operand index counter*/
272 int p1inlen; /*pass 1 instr length*/
273 int instrlen; /*pass 2 bytes in current instruction*/
274
275 /* effective address mode bits*/
276 #define DDIR 000
277 #define ADIR 010
278 #define INDIRECT 020
279 #define INDINC 030
280 #define DECIND 040
281 #define INDDISP 050
282 #define INDINX 060
283 #define SADDR 070
284 #define LADDR 071
285 #define IMM 074
286
287 #define AREGLO 8
288 #define AREGHI 15
289
290 /* relocation bit definitions:*/
291 #define RBMASK 07 /*tells type of relocation*/
292 #define INSABS 7 /*first word of instr -- absolute*/
293 #define DABS 0 /*data word absolute*/
294 #define TRELOC 2 /* TEXT relocatable*/
295 #define DRELOC 1 /* DATA relocatable*/
1File: AS68.H Page 6
296 #define BRELOC 3 /* BSS relocatable*/
297 #define EXTVAR 4 /* ref to external variable*/
298 #define LUPPER 5 /* upper word of long*/
299 #define EXTREL 6 /* external relative mode*/
300
301 /* ptrs to ins[] and rlbits[]*/
302 int *pins;
303 int *prlb;
304 int ins[5]; /*holds instruction words*/
305
306 #define PRTCHLEN 128
307 char prtchars[PRTCHLEN]; /*line buffer for putchar*/
308 char *prtchidx; /*index for putchar*/
309
310 int extflg, extref; /*external in expr*/
311
312 #define CCR 16
313 #define SR 17
314 #define USP 18
315 #define MOVECCR 042300
316 #define MOVESR 043300
317 #define SRMOVE 040300
318 #define MOVEUSP 047140
319
320 struct op {
321 int ea; /* effective address bits*/
322 int len; /* effective address length in bytes*/
323 long con; /*constant or reloc part of operand*/
324 int drlc; /*reloc of con*/
325 int ext; /*external variable #*/
326 int idx; /*index register if any*/
327 int xmod; /*mode of index reg*/
328 } opnd[2];
329 #define OPSTLEN 10
330 #define TREELEN 20
331 struct buf{
332 int fildes;
333 int nunused;
334 char *xfree;
335 char buff[512];
336 };
337
338 struct buf lbuf;
339 struct buf tbuf;
340 struct buf dabuf;
341 struct buf drbuf;
342
343 int nerror; /*# of assembler errors*/
344 int in_err; /*[vlh] don't generate instrlen err if already err state*/
345 int shortadr; /*short addresses if set*/
346
347 #define CLRFOR 24
348 #define CLRVAL 041000
349
350 long itoffset;
351
352 #define LASTCHTFN *tfilptr
353 char *tfilptr; /* -> Changed filename character */
354 #define PC 22
1File: AS68.H Page 7
355
356 int equflg; /*doing an equate stmt*/
357
358 #define ANDI 01000
359 #define AND 0140000
360 #define ORI 0
361 #define OR 0100000
362 #define EORI 05000
363 #define EOR 0130000
364 #define MOVE 0
365
366 long lseek();
367 char *sbrk();
368 char *lemt();
369
370 int refpc; /* * referenced in expr*/
371 #define SOH 1
372
373 /* Conditional Assembly variables and constants [vlh] */
374 #define LOW_CA 21 /* [vlh] */
375 #define HI_CA 30 /* [vlh] */
376
377 int ca_true; /* true unless in a false CA*/
378 int ca; /* depth of conditional assembly, none = 0*/
379 int ca_level; /* at what CA depth did CA go false?*/
380
381 /* pass 1 global variables */
382 int numops; /*number of operands*/
383 int inoffset; /*[vlh]offset directive*/
384 int didorg;
385 int initflg; /*initialize flag*/
386
387 /* defines */
388 #define igblk() while(fchr==' ') fchr=gchr()
389 #define ckein() ((pitw >= pnite))
390
391 /* is it an alterable operand */
392 #define memalt(ap) (memea(ap) && altea(ap))
393 #define dataalt(ap) (dataea(ap) && altea(ap))
394 #define altea(ap) ((((ap)->ea&070)!=SADDR || ((ap)->ea&6)==0))
395
396 /* is it the specific type of operand */
397 #define memea(ap) (((ap)->ea&070) >= INDIRECT)
398 #define dataea(ap) (((ap)->ea&070) != ADIR)
399 #define pcea(ap) ((ap)->ea==072 || (ap)->ea==073)
400 #define ckdreg(ap) ((ap)->ea>=0 && (ap)->ea<AREGLO)
401 #define ckareg(ap) ((ap)->ea>=AREGLO && (ap)->ea<=AREGHI)
402 /*
403 * DRI Listing Hacks:
404 */
405 char *sfname; /* -> Source file name */
406 #define LPP 58 /* # lines / page */
407 int xline; /* Present line # */
408 int xpage; /* Present Page # */

222
CPM OPERATING SYSTEMS/CPM 68K/1.0X SOURCES/v102/as68/as68init Normal file
View File

@@ -0,0 +1,222 @@
*/*
* Copyright 1981
* Alcyon Corporation
* 8716 Production Ave.
* San Diego, Ca. 92121
**/
R0: .equ 0,r
R1: .equ 1,r
R2: .equ 2,r
R3: .equ 3,r
R4: .equ 4,r
R5: .equ 5,r
R6: .equ 6,r
R7: .equ 7,r
R8: .equ 8,r
R9: .equ 9,r
R10: .equ 10,r
R11: .equ 11,r
R12: .equ 12,r
R13: .equ 13,r
R14: .equ 14,r
R15: .equ 15,r
D0: .equ 0,r
D1: .equ 1,r
D2: .equ 2,r
D3: .equ 3,r
D4: .equ 4,r
D5: .equ 5,r
D6: .equ 6,r
D7: .equ 7,r
A0: .equ @10,r
A1: .equ @11,r
A2: .equ @12,r
A3: .equ @13,r
A4: .equ @14,r
A5: .equ @15,r
A6: .equ @16,r
A7: .equ @17,r
USP: .equ 18,r
SP: .equ 15,r
CCR: .equ 16,r
SR: .equ 17,r
r0: .equ 0,r
r1: .equ 1,r
r2: .equ 2,r
r3: .equ 3,r
r4: .equ 4,r
r5: .equ 5,r
r6: .equ 6,r
r7: .equ 7,r
r8: .equ 8,r
r9: .equ 9,r
r10: .equ 10,r
r11: .equ 11,r
r12: .equ 12,r
r13: .equ 13,r
r14: .equ 14,r
r15: .equ 15,r
d0: .equ 0,r
d1: .equ 1,r
d2: .equ 2,r
d3: .equ 3,r
d4: .equ 4,r
d5: .equ 5,r
d6: .equ 6,r
d7: .equ 7,r
a0: .equ @10,r
a1: .equ @11,r
a2: .equ @12,r
a3: .equ @13,r
a4: .equ @14,r
a5: .equ @15,r
a6: .equ @16,r
a7: .equ @17,r
usp: .equ 18,r
sp: .equ 15,r
ccr: .equ 16,r
sr: .equ 17,r
.b: .equ 19,r
.B: .equ 19,r
.w: .equ 20,r
.W: .equ 20,r
.l: .equ 21,r
.L: .equ 21,r
pc: .equ 22,r
PC: .equ 22,r
abcd: .opd 4,@140400
add: .opd 1,@150000
adda: .opd 15,@150000
addi: .opd 2,@003000
addq: .opd 17,@050000
inc: .opd 16,@050000
addx: .opd 27,@150400
and: .opd 1,@140000
andi: .opd 2,@001000
asl: .opd 8,@160400
asr: .opd 8,@160000
bcc: .opd 6,@062000
bcs: .opd 6,@062400
beq: .opd 6,@063400
bze: .opd 6,@063400
bge: .opd 6,@066000
bgt: .opd 6,@067000
bhi: .opd 6,@061000
bhis: .opd 6,@062000
bhs: .opd 6,@062000
ble: .opd 6,@067400
blo: .opd 6,@062400
bls: .opd 6,@061400
blos: .opd 6,@061400
blt: .opd 6,@066400
bmi: .opd 6,@065400
bne: .opd 6,@063000
bnz: .opd 6,@063000
bpl: .opd 6,@065000
bvc: .opd 6,@064000
bvs: .opd 6,@064400
bchg: .opd 7,@000100
bclr: .opd 7,@000200
bra: .opd 6,@060000
bt: .opd 6,@060000
bset: .opd 7,@000300
bsr: .opd 6,@060400
btst: .opd 7,@000000
chk: .opd 26,@040600
clr: .opd 24,@041000
cmp: .opd 26,@130000
cmpa: .opd 15,@130000
cmpi: .opd 2,@006000
cmpm: .opd 10,@130410
dbcc: .opd 11,@052310
dbcs: .opd 11,@052710
dblo: .opd 11,@052710
dbeq: .opd 11,@053710
dbze: .opd 11,@053710
dbra: .opd 11,@050710
dbf: .opd 11,@050710
dbge: .opd 11,@056310
dbgt: .opd 11,@057310
dbhi: .opd 11,@051310
dbhs: .opd 11,@051310
dble: .opd 11,@057710
dbls: .opd 11,@051710
dblt: .opd 11,@056710
dbmi: .opd 11,@055710
dbne: .opd 11,@053310
dbnz: .opd 11,@053310
dbpl: .opd 11,@055310
dbt: .opd 11,@050310
dbvc: .opd 11,@054310
dbvs: .opd 11,@054710
divs: .opd 5,@100700
divu: .opd 5,@100300
eor: .opd 23,@130000
eori: .opd 2,@005000
exg: .opd 12,@140400
ext: .opd 13,@044000
jmp: .opd 9,@047300
jsr: .opd 9,@047200
illegal:.opd 0,@045374
lea: .opd 30,@040700
link: .opd 19,@047120
lsr: .opd 8,@160010
lsl: .opd 8,@160410
move: .opd 3,@000000
movea: .opd 3,@000100
movem: .opd 20,@044200
movep: .opd 21,@000010
moveq: .opd 22,@070000
muls: .opd 5,@140700
mulu: .opd 5,@140300
nbcd: .opd 25,@044000
neg: .opd 24,@042000
negx: .opd 24,@040000
nop: .opd 0,@047161
not: .opd 24,@043000
or: .opd 1,@100000
ori: .opd 2,@000000
pea: .opd 29,@044100
reset: .opd 0,@047160
rol: .opd 8,@160430
ror: .opd 8,@160030
roxl: .opd 8,@160420
roxr: .opd 8,@160020
rte: .opd 0,@047163
rtr: .opd 0,@047167
rts: .opd 0,@047165
sbcd: .opd 4,@100400
scc: .opd 25,@052300
shs: .opd 25,@052300
scs: .opd 25,@052700
slo: .opd 25,@052700
seq: .opd 25,@053700
sze: .opd 25,@053700
sf: .opd 25,@050700
sge: .opd 25,@056300
sgt: .opd 25,@057300
shi: .opd 25,@051300
sle: .opd 25,@057700
sls: .opd 25,@051700
slt: .opd 25,@056700
smi: .opd 25,@055700
sne: .opd 25,@053300
snz: .opd 25,@053300
spl: .opd 25,@055300
st: .opd 25,@050300
svc: .opd 25,@054300
svs: .opd 25,@054700
stop: .opd 14,@047162
sub: .opd 1,@110000
suba: .opd 15,@110000
subi: .opd 2,@002000
subq: .opd 17,@050400
dec: .opd 16,@050400
subx: .opd 27,@110400
swap: .opd 28,@044100
tas: .opd 25,@045300
trap: .opd 18,@047100
trapv: .opd 0,@047166
tst: .opd 24,@045000
unlk: .opd 13,@047130
.end

454
CPM OPERATING SYSTEMS/CPM 68K/1.0X SOURCES/v102/as68/as68init.c Normal file
View File

@@ -0,0 +1,454 @@
/*
Copyright 1981
Alcyon Corporation
8716 Production Ave.
San Diego, Ca. 92121
*/
#include "machine.h"
#include "ctype.h"
#ifdef PDP11
struct {
char lobyte;
char hibyte;
};
struct {
char *ptrw1;
char *ptrw2;
};
struct {
int wd1;
int wd2;
};
struct {
int swd1;
};
#endif
#ifdef MC68000
struct {
char hibyte;
char lobyte;
};
struct {
char *ptrw2;
};
struct {
int wd1;
int wd2;
};
struct {
int swd1;
};
#endif
#ifdef VAX
struct {
short wd2;
short wd1;
};
struct {
short swd1;
};
struct {
char lobyte;
char hibyte;
};
struct {
char *ptrw2;
};
#endif
/* format of a symbol entry in the main table*/
# define NAMELEN 8 /*length of name in symbol table*/
struct symtab {
char name[NAMELEN]; /*symbol name*/
int flags; /*bit flags*/
char *tlnk; /*table link*/
long vl1; /*symbol value*/
};
struct symtab *symtptr;
# define STESIZE (sizeof *symtptr) /*byte length of symbol table entry*/
/* flags for symbols*/
# define SYDF 0100000 /*defined*/
# define SYEQ 0040000 /*equated*/
# define SYGL 0020000 /*global - entry or external*/
# define SYER 0010000 /*equated register*/
# define SYXR 0004000 /*external reference*/
# define SYRA 0002000 /*DATA based relocatable*/
# define SYRO 0001000 /*TEXT based relocatable*/
# define SYBS 0000400 /*BSS based relocatable*/
# define SYIN 0000200 /*internal symbol -- opcode, directive or equ*/
# define SYPC 0000100 /*[vlh]equated using star '*' expression*/
# define SYRM 0000040 /*[vlh]register mask equate*/
/*flags for opcodes and directives*/
# define OPDR 0100000 /*0=>opcode, 1=>directive*/
# define OPFF 037 /*type of instruction (used as mask)*/
struct irts {
char *irle; /*ptr to last entry in chain*/
char *irfe; /*ptr to first entry in chain*/
};
long stlen; /*length of symbol table*/
/*
* intermediate text file
* format of the intermediate text for one statement:
*
* ******************************************************
* * it type = ITBS * # it entries * 0
* ******************************************************
* * absolute line number (long) *
* ******************************************************
* * it type = ITSY * instr length * 1
* ******************************************************
* * symbol table pointer for stmt label (long) *
* ******************************************************
* * it type = ITSY * instr mode length * 2
* ******************************************************
* * opcode ptr (long) *
* ******************************************************
* * it type = ITCN * relocation base * 3
* ******************************************************
* * location counter (pass 1) *
* ******************************************************
* * it type * relocation flag * 4 - oprnds
* ******************************************************
* * value (long) *
* ******************************************************
* .
* .
* .
* ******************************************************
* * it type * relocation flag * n - oprnds
* ******************************************************
* * value (long) *
* ******************************************************
*/
#define ITOP1 4 /*first it entry for operands*/
/*
* it type meaning
* 0 beginning of statement
* 1 value is pointer to symbol table
* 2 value is a constant
* 3 value is a specal char
*
* relocation flag for opcode it entry is operand length:
* 'b' => byte
* 'w' => word
* 'l' => long
*/
struct it {
char itty; /*it type*/
char itrl; /*relocation flag or # it entries*/
long itop;
};
int mode=0; /*operand mode (byte, word, long)*/
int modelen=0; /*operand length per mode*/
#define BYTE 'b'
#define WORD 'w'
#define LONG 'l'
/* parameters that define the main table*/
#define SZMT 300 /*initial size of the main table */
/*must be large enough to initialize*/
#ifdef PDP11
#define ICRSZMT 10 /*add to main table when run out*/
#else
#define ICRSZMT 50 /*add to main table when run out*/
#endif
int cszmt=0; /*current size of main table*/
char *bmte=0; /*beginning of main table*/
char *emte=0; /*end of main table*/
/* intermediate text types*/
#define ITBS 0 /*beginning of statement*/
#define ITSY 1 /*pointer to symbol table*/
#define ITCN 2 /*constant*/
#define ITSP 3 /*special*/
#define ITRM 4 /*[vlh]register mask!*/
#define ITPC 5 /*[vlh]pc relative argument*/
# define ITBSZ 256 /*size of the it buffer*/
int itbuf[ITBSZ]={0}; /*it buffer*/
#define STMAX 200 /*size of intermediate text buffer*/
struct it stbuf[STMAX]={0}; /*holds it for one statement*/
char sbuf[512]={0}; /*holds one block of source*/
/*initial reference table for symbols*/
# define SZIRT 128
char *sirt[SZIRT]={0};
/*initial reference table to opcodes*/
char *oirt[SZIRT]={0};
/*external symbol table*/
#define EXTSZ 512
char *extbl[EXTSZ]={0};
int extindx=0; /*index to external symbol table*/
char **pexti=0; /*ptr to external symbol table*/
int absln=0; /*absolute line number*/
int p2absln=0; /*pass 2 line number*/
int fcflg=0; /*0=>passed an item. 1=>first char*/
int fchr=0; /*first char in term*/
int ifn=0; /*source file descriptor*/
int *pitix=0; /*ptr to it buffer*/
int itwc=0; /*number of words in it buffer*/
struct it *pitw=0; /*ptr to it buffer next entry*/
int itype=0; /*type of item*/
long ival=0; /*value of item*/
char *lblpt=0; /*label pointer*/
char lbt[NAMELEN]={0}; /*holds label name*/
char *lmte=0; /*last entry in main table*/
long loctr=0; /*location counter*/
long savelc[4]={0}; /*save relocation counters for 3 bases*/
int nite=0; /*number of entries in stbuf*/
struct it *pnite=0;
int lfn=0; /*loader output file descriptor*/
char *opcpt=0; /*pointer to opcode entry in main table*/
int p2flg=0; /*0=>pass 1 1=>pass 2*/
char **pirt=0; /*entry in initial reference table*/
int reloc=0; /*relocation value returned by expression evaluator (expr)*/
int rlflg=0; /*relocation value of current location counter*/
/*relocation values*/
# define ABS 0 /*absolute*/
# define DATA 1
# define TEXT 2
# define BSS 3
# define EXTRN 4 /*externally defined*/
#define EOLC '\n' /*end of line character*/
#define EOF 0 /*end of file indicator*/
#define NULL 0 /* [vlh] character null '\0' */
#define TRUE 1 /* [vlh] boolean values */
#define FALSE 0 /* [vlh] boolean values */
int format=0;
int sbuflen=0; /*number of chars in sbuf*/
char *psbuf=0; /*ptr into sbuf*/
int itfn=0; /*it file number*/
char itfnc=0; /*last char of it file name*/
int trbfn=0; /*temp for text relocation bits*/
char trbfnc=0; /*last char of text rb file*/
int dafn=0; /*file for data stuff*/
char dafnc=0; /*last char of data file*/
int drbfn=0; /*file for data relocation bits*/
char drbfnc=0; /*last char*/
int prtflg=0; /*print output flag*/
int undflg=0; /*make undefined symbols external flag*/
int starmul=0; /* * is multiply operator*/
char *endptr=0, *addptr=0;
char *orgptr=0;
char *subptr=0, *addiptr=0, *addqptr=0, *subiptr=0, *subqptr=0;
char *cmpptr=0, *addaptr=0, *cmpaptr=0, *subaptr=0, *cmpmptr=0;
char *equptr=0;
char *andptr=0, *andiptr=0, *eorptr=0, *eoriptr=0, *orptr=0, *oriptr=0;
char *cmpiptr=0;
char *moveptr=0, *moveqptr=0;
char *exgptr=0;
char *evenptr=0;
char *jsrptr=0, *bsrptr=0, *nopptr=0;
char peekc=0;
int numcon[2]=0, numsym[2]=0, indir[2]=0, immed[2]=0, numreg[2]=0;
int plevel=0; /*parenthesis level counter*/
int opdix=0; /*operand index counter*/
int p1inlen=0; /*pass 1 instr length*/
int instrlen=0; /*pass 2 bytes in current instruction*/
/* effective address mode bits*/
#define DDIR 000
#define ADIR 010
#define INDIRECT 020
#define INDINC 030
#define DECIND 040
#define INDDISP 050
#define INDINX 060
#define SADDR 070
#define LADDR 071
#define IMM 074
#define AREGLO 8
#define AREGHI 15
/* relocation bit definitions:*/
#define RBMASK 07 /*tells type of relocation*/
#define INSABS 7 /*first word of instr -- absolute*/
#define DABS 0 /*data word absolute*/
#define TRELOC 2 /* TEXT relocatable*/
#define DRELOC 1 /* DATA relocatable*/
#define BRELOC 3 /* BSS relocatable*/
#define EXTVAR 4 /* ref to external variable*/
#define LUPPER 5 /* upper word of long*/
#define EXTREL 6 /* external relative mode*/
/* ptrs to ins[] and rlbits[]*/
int *pins=0;
int *prlb=0;
int ins[5]={0}; /*holds instruction words*/
#define PRTCHLEN 128
char prtchars[PRTCHLEN]={0}; /*line buffer for putchar*/
char *prtchidx=0; /*index for putchar*/
int extflg=0, extref=0; /*external in expr*/
#define CCR 16
#define SR 17
#define USP 18
#define MOVECCR 042300
#define MOVESR 043300
#define SRMOVE 040300
#define MOVEUSP 047140
struct op {
int ea; /* effective address bits*/
int len; /* effective address length in bytes*/
long con; /*constant or reloc part of operand*/
int drlc; /*reloc of con*/
int ext; /*external variable #*/
int idx; /*index register if any*/
int xmod; /*mode of index reg*/
} opnd[2]={0};
#define OPSTLEN 10
#define TREELEN 20
struct buf{
int fildes;
int nunused;
char *xfree;
char buff[512];
};
struct buf lbuf={0};
struct buf tbuf={0};
struct buf dabuf={0};
struct buf drbuf={0};
int nerror=0; /*# of assembler errors*/
int in_err=0; /*[vlh] don't generate instrlen err if already err state*/
int shortadr=0; /*short addresses if set*/
#define CLRFOR 24
#define CLRVAL 041000
long itoffset=0;
#define LASTCHTFN tfilname[11]
#define PC 22
int equflg=0; /*doing an equate stmt*/
#define ANDI 01000
#define AND 0140000
#define ORI 0
#define OR 0100000
#define EORI 05000
#define EOR 0130000
#define MOVE 0
long lseek();
char *sbrk();
char *lemt();
int refpc=0; /* * referenced in expr*/
#define SOH 1
/* Conditional Assembly variables and constants [vlh] */
#define LOW_CA 21 /* [vlh] */
#define HI_CA 30 /* [vlh] */
int ca_true=0; /* true unless in a false CA*/
int ca=0; /* depth of conditional assembly, none = 0*/
int ca_level=0; /* at what CA depth did CA go false?*/
/* pass 1 global variables */
int numops=0; /*number of operands*/
int inoffset=0; /*[vlh]offset directive*/
int didorg=0;
int initflg=0; /*initialize flag*/
/* defines */
#define igblk() while(fchr==' ') fchr=gchr()
#define ckein() ((pitw >= pnite))
/* is it an alterable operand */
#define memalt(ap) (memea(ap) && altea(ap))
#define dataalt(ap) (dataea(ap) && altea(ap))
#define altea(ap) ((((ap)->ea&070)!=SADDR || ((ap)->ea&6)==0))
/* is it the specific type of operand */
#define memea(ap) (((ap)->ea&070) >= INDIRECT)
#define dataea(ap) (((ap)->ea&070) != ADIR)
#define pcea(ap) ((ap)->ea==072 || (ap)->ea==073)
#define ckdreg(ap) ((ap)->ea>=0 && (ap)->ea<AREGLO)
#define ckareg(ap) ((ap)->ea>=AREGLO && (ap)->ea<=AREGHI)
/*
* DRI Listing Hacks:
*/
char *sfname=0; /* -> Source filename */
int xline=0; /* Current line number */
int xpage=0; /* Current page number */
/*
* More Initializations:
*/
char *tfilname[80] = {0}; /* Temp filename area */
char *initfnam[80] = {0}; /* Init filename area */
struct it exitm={0};
int prcnt=0;
int rval=0;
int lpflg=0;
int lastopr=0;
int rlbits[5]={0};
int pline=0;
int prsp=0;
int amode=0;
long stlen=0;
int udfct=0;
int errno=0;
int nitleft=0;
int hibytflg[4]={0};
int hibytw[4]={0};
struct it *piop=0;
struct it *pitr=0;
struct it opstk[OPSTLEN]={0};
struct it tree[TREELEN]={0};
int chmvq=0;
int explmod=0;
int ftudp=0;
int iop=0;
int itr=0;
char ldfn[40]={0};
int opcval=0;
int poslab=0;
int symcon=0;
char *tfilptr=0;
int tlab1=0;
#define HDSIZE (sizeof couthd) /**.o file header size*/
struct hdr {
short ch_magic; /*c.out magic number 060016 = $600E*/
long ch_tsize; /*text size*/
long ch_dsize; /*data size*/
long ch_bsize; /*bss size*/
long ch_ssize; /*symbol table size*/
long ch_stksize; /*stack size*/
long ch_entry; /*entry point*/
short ch_rlbflg; /*relocation bits suppressed flag*/
} couthd={0};
#define MAGIC 0x601a /* bra .+26 instruction*/

462
CPM OPERATING SYSTEMS/CPM 68K/1.0X SOURCES/v102/as68/as68init.lis Normal file
View File

@@ -0,0 +1,462 @@
1File: AS68INIT.C Page 1
1 /*
2 Copyright 1981
3 Alcyon Corporation
4 8716 Production Ave.
5 San Diego, Ca. 92121
6 */
7
8 #include "machine.h"
9 #include "ctype.h"
10
11 #ifdef PDP11
12 struct {
13 char lobyte;
14 char hibyte;
15 };
16 struct {
17 char *ptrw1;
18 char *ptrw2;
19 };
20 struct {
21 int wd1;
22 int wd2;
23 };
24 struct {
25 int swd1;
26 };
27 #endif
28
29 #ifdef MC68000
30 struct {
31 char hibyte;
32 char lobyte;
33 };
34 struct {
35 char *ptrw2;
36 };
37 struct {
38 int wd1;
39 int wd2;
40 };
41 struct {
42 int swd1;
43 };
44 #endif
45
46 #ifdef VAX
47 struct {
48 short wd2;
49 short wd1;
50 };
51 struct {
52 short swd1;
53 };
54
55 struct {
56 char lobyte;
57 char hibyte;
58 };
59 struct {
1File: AS68INIT.C Page 2
60 char *ptrw2;
61 };
62 #endif
63
64 /* format of a symbol entry in the main table*/
65
66 # define NAMELEN 8 /*length of name in symbol table*/
67 struct symtab {
68 char name[NAMELEN]; /*symbol name*/
69 int flags; /*bit flags*/
70 char *tlnk; /*table link*/
71 long vl1; /*symbol value*/
72 };
73
74 struct symtab *symtptr;
75 # define STESIZE (sizeof *symtptr) /*byte length of symbol table entry*/
76
77 /* flags for symbols*/
78 # define SYDF 0100000 /*defined*/
79 # define SYEQ 0040000 /*equated*/
80 # define SYGL 0020000 /*global - entry or external*/
81 # define SYER 0010000 /*equated register*/
82 # define SYXR 0004000 /*external reference*/
83 # define SYRA 0002000 /*DATA based relocatable*/
84 # define SYRO 0001000 /*TEXT based relocatable*/
85 # define SYBS 0000400 /*BSS based relocatable*/
86 # define SYIN 0000200 /*internal symbol -- opcode, directive or equ*/
87 # define SYPC 0000100 /*[vlh]equated using star '*' expression*/
88 # define SYRM 0000040 /*[vlh]register mask equate*/
89
90 /*flags for opcodes and directives*/
91 # define OPDR 0100000 /*0=>opcode, 1=>directive*/
92 # define OPFF 037 /*type of instruction (used as mask)*/
93
94 struct irts {
95 char *irle; /*ptr to last entry in chain*/
96 char *irfe; /*ptr to first entry in chain*/
97 };
98
99 long stlen; /*length of symbol table*/
100
101 /*
102 * intermediate text file
103 * format of the intermediate text for one statement:
104 *
105 * ******************************************************
106 * * it type = ITBS * # it entries * 0
107 * ******************************************************
108 * * absolute line number (long) *
109 * ******************************************************
110 * * it type = ITSY * instr length * 1
111 * ******************************************************
112 * * symbol table pointer for stmt label (long) *
113 * ******************************************************
114 * * it type = ITSY * instr mode length * 2
115 * ******************************************************
116 * * opcode ptr (long) *
117 * ******************************************************
118 * * it type = ITCN * relocation base * 3
1File: AS68INIT.C Page 3
119 * ******************************************************
120 * * location counter (pass 1) *
121 * ******************************************************
122 * * it type * relocation flag * 4 - oprnds
123 * ******************************************************
124 * * value (long) *
125 * ******************************************************
126 * .
127 * .
128 * .
129 * ******************************************************
130 * * it type * relocation flag * n - oprnds
131 * ******************************************************
132 * * value (long) *
133 * ******************************************************
134 */
135
136 #define ITOP1 4 /*first it entry for operands*/
137
138 /*
139 * it type meaning
140 * 0 beginning of statement
141 * 1 value is pointer to symbol table
142 * 2 value is a constant
143 * 3 value is a specal char
144 *
145 * relocation flag for opcode it entry is operand length:
146 * 'b' => byte
147 * 'w' => word
148 * 'l' => long
149 */
150
151 struct it {
152 char itty; /*it type*/
153 char itrl; /*relocation flag or # it entries*/
154 long itop;
155 };
156
157 int mode=0; /*operand mode (byte, word, long)*/
158 int modelen=0; /*operand length per mode*/
159 #define BYTE 'b'
160 #define WORD 'w'
161 #define LONG 'l'
162
163 /* parameters that define the main table*/
164 #define SZMT 300 /*initial size of the main table */
165 /*must be large enough to initialize*/
166 #ifdef PDP11
167 #define ICRSZMT 10 /*add to main table when run out*/
168 #else
169 #define ICRSZMT 50 /*add to main table when run out*/
170 #endif
171 int cszmt=0; /*current size of main table*/
172 char *bmte=0; /*beginning of main table*/
173 char *emte=0; /*end of main table*/
174
175 /* intermediate text types*/
176 #define ITBS 0 /*beginning of statement*/
177 #define ITSY 1 /*pointer to symbol table*/
1File: AS68INIT.C Page 4
178 #define ITCN 2 /*constant*/
179 #define ITSP 3 /*special*/
180 #define ITRM 4 /*[vlh]register mask!*/
181 #define ITPC 5 /*[vlh]pc relative argument*/
182
183 # define ITBSZ 256 /*size of the it buffer*/
184 int itbuf[ITBSZ]={0}; /*it buffer*/
185
186 #define STMAX 200 /*size of intermediate text buffer*/
187 struct it stbuf[STMAX]={0}; /*holds it for one statement*/
188
189 char sbuf[512]={0}; /*holds one block of source*/
190
191 /*initial reference table for symbols*/
192 # define SZIRT 128
193 char *sirt[SZIRT]={0};
194
195 /*initial reference table to opcodes*/
196 char *oirt[SZIRT]={0};
197
198 /*external symbol table*/
199 #define EXTSZ 512
200 char *extbl[EXTSZ]={0};
201 int extindx=0; /*index to external symbol table*/
202 char **pexti=0; /*ptr to external symbol table*/
203
204 int absln=0; /*absolute line number*/
205 int p2absln=0; /*pass 2 line number*/
206 int fcflg=0; /*0=>passed an item. 1=>first char*/
207 int fchr=0; /*first char in term*/
208 int ifn=0; /*source file descriptor*/
209 int *pitix=0; /*ptr to it buffer*/
210 int itwc=0; /*number of words in it buffer*/
211 struct it *pitw=0; /*ptr to it buffer next entry*/
212 int itype=0; /*type of item*/
213 long ival=0; /*value of item*/
214 char *lblpt=0; /*label pointer*/
215 char lbt[NAMELEN]={0}; /*holds label name*/
216 char *lmte=0; /*last entry in main table*/
217 long loctr=0; /*location counter*/
218 long savelc[4]={0}; /*save relocation counters for 3 bases*/
219 int nite=0; /*number of entries in stbuf*/
220 struct it *pnite=0;
221 int lfn=0; /*loader output file descriptor*/
222 char *opcpt=0; /*pointer to opcode entry in main table*/
223 int p2flg=0; /*0=>pass 1 1=>pass 2*/
224 char **pirt=0; /*entry in initial reference table*/
225 int reloc=0; /*relocation value returned by expression evaluator (expr)*/
226 int rlflg=0; /*relocation value of current location counter*/
227 /*relocation values*/
228 # define ABS 0 /*absolute*/
229 # define DATA 1
230 # define TEXT 2
231 # define BSS 3
232 # define EXTRN 4 /*externally defined*/
233
234 #define EOLC '\n' /*end of line character*/
235 #define EOF 0 /*end of file indicator*/
236 #define NULL 0 /* [vlh] character null '\0' */
1File: AS68INIT.C Page 5
237 #define TRUE 1 /* [vlh] boolean values */
238 #define FALSE 0 /* [vlh] boolean values */
239
240 int format=0;
241 int sbuflen=0; /*number of chars in sbuf*/
242 char *psbuf=0; /*ptr into sbuf*/
243 int itfn=0; /*it file number*/
244 char itfnc=0; /*last char of it file name*/
245 int trbfn=0; /*temp for text relocation bits*/
246 char trbfnc=0; /*last char of text rb file*/
247 int dafn=0; /*file for data stuff*/
248 char dafnc=0; /*last char of data file*/
249 int drbfn=0; /*file for data relocation bits*/
250 char drbfnc=0; /*last char*/
251 int prtflg=0; /*print output flag*/
252 int undflg=0; /*make undefined symbols external flag*/
253
254 int starmul=0; /* * is multiply operator*/
255
256 char *endptr=0, *addptr=0;
257 char *orgptr=0;
258 char *subptr=0, *addiptr=0, *addqptr=0, *subiptr=0, *subqptr=0;
259 char *cmpptr=0, *addaptr=0, *cmpaptr=0, *subaptr=0, *cmpmptr=0;
260 char *equptr=0;
261 char *andptr=0, *andiptr=0, *eorptr=0, *eoriptr=0, *orptr=0, *oriptr=0;
262 char *cmpiptr=0;
263 char *moveptr=0, *moveqptr=0;
264 char *exgptr=0;
265 char *evenptr=0;
266 char *jsrptr=0, *bsrptr=0, *nopptr=0;
267
268 char peekc=0;
269 int numcon[2]=0, numsym[2]=0, indir[2]=0, immed[2]=0, numreg[2]=0;
270 int plevel=0; /*parenthesis level counter*/
271 int opdix=0; /*operand index counter*/
272 int p1inlen=0; /*pass 1 instr length*/
273 int instrlen=0; /*pass 2 bytes in current instruction*/
274
275 /* effective address mode bits*/
276 #define DDIR 000
277 #define ADIR 010
278 #define INDIRECT 020
279 #define INDINC 030
280 #define DECIND 040
281 #define INDDISP 050
282 #define INDINX 060
283 #define SADDR 070
284 #define LADDR 071
285 #define IMM 074
286
287 #define AREGLO 8
288 #define AREGHI 15
289
290 /* relocation bit definitions:*/
291 #define RBMASK 07 /*tells type of relocation*/
292 #define INSABS 7 /*first word of instr -- absolute*/
293 #define DABS 0 /*data word absolute*/
294 #define TRELOC 2 /* TEXT relocatable*/
295 #define DRELOC 1 /* DATA relocatable*/
1File: AS68INIT.C Page 6
296 #define BRELOC 3 /* BSS relocatable*/
297 #define EXTVAR 4 /* ref to external variable*/
298 #define LUPPER 5 /* upper word of long*/
299 #define EXTREL 6 /* external relative mode*/
300
301 /* ptrs to ins[] and rlbits[]*/
302 int *pins=0;
303 int *prlb=0;
304 int ins[5]={0}; /*holds instruction words*/
305
306 #define PRTCHLEN 128
307 char prtchars[PRTCHLEN]={0}; /*line buffer for putchar*/
308 char *prtchidx=0; /*index for putchar*/
309
310 int extflg=0, extref=0; /*external in expr*/
311
312 #define CCR 16
313 #define SR 17
314 #define USP 18
315 #define MOVECCR 042300
316 #define MOVESR 043300
317 #define SRMOVE 040300
318 #define MOVEUSP 047140
319
320 struct op {
321 int ea; /* effective address bits*/
322 int len; /* effective address length in bytes*/
323 long con; /*constant or reloc part of operand*/
324 int drlc; /*reloc of con*/
325 int ext; /*external variable #*/
326 int idx; /*index register if any*/
327 int xmod; /*mode of index reg*/
328 } opnd[2]={0};
329 #define OPSTLEN 10
330 #define TREELEN 20
331 struct buf{
332 int fildes;
333 int nunused;
334 char *xfree;
335 char buff[512];
336 };
337
338 struct buf lbuf={0};
339 struct buf tbuf={0};
340 struct buf dabuf={0};
341 struct buf drbuf={0};
342
343 int nerror=0; /*# of assembler errors*/
344 int in_err=0; /*[vlh] don't generate instrlen err if already err state*/
345 int shortadr=0; /*short addresses if set*/
346
347 #define CLRFOR 24
348 #define CLRVAL 041000
349
350 long itoffset=0;
351
352 #define LASTCHTFN tfilname[11]
353 #define PC 22
354
1File: AS68INIT.C Page 7
355 int equflg=0; /*doing an equate stmt*/
356
357 #define ANDI 01000
358 #define AND 0140000
359 #define ORI 0
360 #define OR 0100000
361 #define EORI 05000
362 #define EOR 0130000
363 #define MOVE 0
364
365 long lseek();
366 char *sbrk();
367 char *lemt();
368
369 int refpc=0; /* * referenced in expr*/
370 #define SOH 1
371
372 /* Conditional Assembly variables and constants [vlh] */
373 #define LOW_CA 21 /* [vlh] */
374 #define HI_CA 30 /* [vlh] */
375
376 int ca_true=0; /* true unless in a false CA*/
377 int ca=0; /* depth of conditional assembly, none = 0*/
378 int ca_level=0; /* at what CA depth did CA go false?*/
379
380 /* pass 1 global variables */
381 int numops=0; /*number of operands*/
382 int inoffset=0; /*[vlh]offset directive*/
383 int didorg=0;
384 int initflg=0; /*initialize flag*/
385
386 /* defines */
387 #define igblk() while(fchr==' ') fchr=gchr()
388 #define ckein() ((pitw >= pnite))
389
390 /* is it an alterable operand */
391 #define memalt(ap) (memea(ap) && altea(ap))
392 #define dataalt(ap) (dataea(ap) && altea(ap))
393 #define altea(ap) ((((ap)->ea&070)!=SADDR || ((ap)->ea&6)==0))
394
395 /* is it the specific type of operand */
396 #define memea(ap) (((ap)->ea&070) >= INDIRECT)
397 #define dataea(ap) (((ap)->ea&070) != ADIR)
398 #define pcea(ap) ((ap)->ea==072 || (ap)->ea==073)
399 #define ckdreg(ap) ((ap)->ea>=0 && (ap)->ea<AREGLO)
400 #define ckareg(ap) ((ap)->ea>=AREGLO && (ap)->ea<=AREGHI)
401 /*
402 * DRI Listing Hacks:
403 */
404 char *sfname=0; /* -> Source filename */
405 int xline=0; /* Current line number */
406 int xpage=0; /* Current page number */
407 /*
408 * More Initializations:
409 */
410 char *tfilname[80] = {0}; /* Temp filename area */
411 char *initfnam[80] = {0}; /* Init filename area */
412 struct it exitm={0};
413 int prcnt=0;
1File: AS68INIT.C Page 8
414 int rval=0;
415 int lpflg=0;
416 int lastopr=0;
417 int rlbits[5]={0};
418 int pline=0;
419 int prsp=0;
420 int amode=0;
421 long stlen=0;
422 int udfct=0;
423 int errno=0;
424 int nitleft=0;
425 int hibytflg[4]={0};
426 int hibytw[4]={0};
427 struct it *piop=0;
428 struct it *pitr=0;
429 struct it opstk[OPSTLEN]={0};
430 struct it tree[TREELEN]={0};
431 int chmvq=0;
432 int explmod=0;
433 int ftudp=0;
434 int iop=0;
435 int itr=0;
436 char ldfn[40]={0};
437 int opcval=0;
438 int poslab=0;
439 int symcon=0;
440 char *tfilptr=0;
441 int tlab1=0;
442 #define HDSIZE (sizeof couthd) /**.o file header size*/
443 struct hdr {
444 short ch_magic; /*c.out magic number 060016 = $600E*/
445 long ch_tsize; /*text size*/
446 long ch_dsize; /*data size*/
447 long ch_bsize; /*bss size*/
448 long ch_ssize; /*symbol table size*/
449 long ch_stksize; /*stack size*/
450 long ch_entry; /*entry point*/
451 short ch_rlbflg; /*relocation bits suppressed flag*/
452 } couthd={0};
453
454 #define MAGIC 0x601a /* bra .+26 instruction*/

13
CPM OPERATING SYSTEMS/CPM 68K/1.0X SOURCES/v102/as68/cout.h Normal file
View File

@@ -0,0 +1,13 @@
#define HDSIZE (sizeof couthd) /**.o file header size*/
struct hdr {
short ch_magic; /*c.out magic number 060016 = $600E*/
long ch_tsize; /*text size*/
long ch_dsize; /*data size*/
long ch_bsize; /*bss size*/
long ch_ssize; /*symbol table size*/
long ch_stksize; /*stack size*/
long ch_entry; /*entry point*/
short ch_rlbflg; /*relocation bits suppressed flag*/
} couthd;
#define MAGIC 0x601a /* bra .+26 instruction*/

14
CPM OPERATING SYSTEMS/CPM 68K/1.0X SOURCES/v102/as68/cout.lst Normal file
View File

@@ -0,0 +1,14 @@
1File: COUT.H Page 1
1 #define HDSIZE (sizeof couthd) /**.o file header size*/
2 struct hdr {
3 short ch_magic; /*c.out magic number 060016 = $600E*/
4 long ch_tsize; /*text size*/
5 long ch_dsize; /*data size*/
6 long ch_bsize; /*bss size*/
7 long ch_ssize; /*symbol table size*/
8 long ch_stksize; /*stack size*/
9 long ch_entry; /*entry point*/
10 short ch_rlbflg; /*relocation bits suppressed flag*/
11 } couthd;
12
13 #define MAGIC 0x601a /* bra .+26 instruction*/

36
CPM OPERATING SYSTEMS/CPM 68K/1.0X SOURCES/v102/as68/ctype.h Normal file
View File

@@ -0,0 +1,36 @@
/*
Copyright 1982
Alcyon Corporation
8716 Production Ave.
San Diego, Ca. 92121
*/
/*char *version "@(#)ctype - Aug 13, 1982";
Standard routines... */
#define isspace(c) ((c)==32 || (c)==9 || (c)==13 || (c)==10 ||(c)==12)
#define isupper(c) ((c)<='Z' && (c)>='A')
#define islower(c) ((c)<='z' && (c)>='a')
#define isalpha(c) (isupper((c)) || islower((c)))
#define isdigit(c) ((c)<='9' && (c)>='0')
#define isascii(c) ((c) < 0200 && (c) >= 0)
#define isalnum(c) (isalpha((c)) || isdigit((c)))
#define iscntrl(c) (((c) < 040 || (c) == 0177) && isascii((c)))
#define isprint(c) ((c) >= 040 && (c) < 0177)
#define ispunct(c) (!isalnum((c)) && isprint(c))
#define toupper(c) (islower((c)) ? (c) & ~32 : (c))
#define tolower(c) (isupper((c)) ? (c) | 32 : (c))
#define toascii(c) ((c) & 0177)

37
CPM OPERATING SYSTEMS/CPM 68K/1.0X SOURCES/v102/as68/ctype.lst Normal file
View File

@@ -0,0 +1,37 @@
1File: CTYPE.H Page 1
1 /*
2 Copyright 1982
3 Alcyon Corporation
4 8716 Production Ave.
5 San Diego, Ca. 92121
6 */
7
8 /*char *version "@(#)ctype - Aug 13, 1982";
9
10 Standard routines... */
11
12 #define isspace(c) ((c)==32 || (c)==9 || (c)==13 || (c)==10 ||(c)==12)
13
14 #define isupper(c) ((c)<='Z' && (c)>='A')
15
16 #define islower(c) ((c)<='z' && (c)>='a')
17
18 #define isalpha(c) (isupper((c)) || islower((c)))
19
20 #define isdigit(c) ((c)<='9' && (c)>='0')
21
22 #define isascii(c) ((c) < 0200 && (c) >= 0)
23
24 #define isalnum(c) (isalpha((c)) || isdigit((c)))
25
26 #define iscntrl(c) (((c) < 040 || (c) == 0177) && isascii((c)))
27
28 #define isprint(c) ((c) >= 040 && (c) < 0177)
29
30 #define ispunct(c) (!isalnum((c)) && isprint(c))
31
32 #define toupper(c) (islower((c)) ? (c) & ~32 : (c))
33
34 #define tolower(c) (isupper((c)) ? (c) | 32 : (c))
35
36 #define toascii(c) ((c) & 0177)

934
CPM OPERATING SYSTEMS/CPM 68K/1.0X SOURCES/v102/as68/dir.c Normal file
View File

@@ -0,0 +1,934 @@
/*
Copyright 1981
Alcyon Corporation
8716 Production Ave.
San Diego, Ca. 92121
*/
/* Pass 1 and pass 2 directive handling routines */
/* code to handle conditional assembly directives */
#include "as68.h"
#include "cout.h"
long lseek();
int p1gi();
int p2gi();
int igrst();
/*directive to define an opcode*/
hopd()
{
if(!lbt[0]) {
xerr(4); /*no label*/
return;
}
setname(); /*move label into main table*/
if((lblpt=lemt(oirt,TRUE))!=lmte) {
xerr(5); /*opcode redefined*/
return;
}
mmte(); /*make main table entry*/
expr(&p1gi); /*get instruction format*/
if(itype!=ITCN || ival<0 || ival>OPFF) {
xerr(18); /*illegal format specifier*/
return;
}
lblpt->flags =| ival|SYIN; /*remember format*/
if(fchr != ',') { /*field separator*/
xerr(10);
return;
}
expr(&p1gi); /*get opcode value*/
if(itype != ITCN) {
xerr(17); /*not a constant*/
return;
}
lblpt->vl1 = ival; /*put value in main table*/
igrst(); /*ignore rest of statement-comment*/
}
/* equate directive*/
hequ()
{
if(lbt[0] == 0) {
xerr(4); /*no label*/
return;
}
setname();
if((lblpt=lemt(sirt,FALSE))!=lmte) { /*aready there*/
if(lbt[0] == '~') { /*local symbol*/
lblpt = lmte;
mmte();
}
}
else
mmte();
if(lblpt->flags&SYXR) {
xerr(29);
return;
}
lblpt->flags =| SYDF|SYEQ; /*defined & equate*/
equflg = 1;
modelen = 4;
expr(&p1gi);
equflg = 0;
if(itype == ITSY && ival.ptrw2->flags&SYER) {
lblpt->flags =| SYER; /*equated register*/
ival = ival.ptrw2->vl1;
}
else if(itype != ITCN) {
xerr(7); /*not a constant*/
return;
}
if (inoffset && reloc != ABS) { /* [vlh] */
xerr(11);
return;
}
if(initflg) /*doing symbol table initialization*/
lblpt->flags =| SYIN; /*internal symbol*/
lblpt->vl1 = ival;
if(reloc == DATA) /*check relocation*/
{
lblpt->flags =| SYRA; /*DATA relocatable*/
}
else if(reloc == TEXT)
lblpt->flags =| SYRO; /*TEXT relocatable*/
else if(reloc == BSS)
lblpt->flags =| SYBS; /*BSS relocatable*/
else if(fchr==',' && (fchr=gchr())=='r')
lblpt->flags =| SYER; /*equated register*/
if (refpc) /*[vlh] flag directive is pc relative */
lblpt->flags =| SYPC;
igrst();
}
/* process dsect directive*/
hdsect()
{
dorlst(DATA);
}
dorlst(xrtyp)
{
inoffset = 0; /* [vlh] offset mode terminated my sect directive */
chkeven(); /* May need to make pc even */
dlabl(); /*define label on old base if there is one*/
savelc[rlflg] = loctr; /*save old base relocation*/
rlflg = xrtyp;
loctr = savelc[xrtyp]; /*set new base relocation ctr*/
opitb();
stbuf[0].itrl = itwc;
wostb();
igrst();
}
/*process psect directive*/
hpsect()
{
dorlst(TEXT);
}
hbss()
{
dorlst(BSS);
}
/*make pc even*/
heven()
{
modelen = 2; /*Try to figure this one out...*/
if(loctr&1) { /*have to make it even*/
dorlst(rlflg);
}
else {
igrst();
}
}
/*process globl directive*/
hent()
{
while(1) {
gterm(TRUE); /*get entry symbol*/
if(itype!=ITSY) { /*error if not symbol*/
xerr(28);
return;
}
if((lblpt=lemt(sirt,FALSE)) == lmte) /*look up in main table*/
mmte(); /*not there, make new entry*/
else
if(lblpt->flags&SYER) /*already there*/
uerr(29);
lblpt->flags =| SYGL; /*symbol is an entry*/
if(lblpt->flags&SYXR) { /*been thru hext code*/
lblpt->flags =& ~(SYXR|SYDF); /*reset for init of .comm*/
}
if (inoffset && reloc != ABS) { /* [vlh] */
xerr(11);
return;
}
if(fchr == ',') /*skip ',' between entries*/
fchr = gchr();
else {
igrst(); /*statement finished*/
return;
}
}
}
/*process comm directive*/
hext()
{
gterm(TRUE); /*get external symbol*/
if(itype!=ITSY) { /*error if not symbol*/
xerr(28);
return;
}
if((lblpt=lemt(sirt,FALSE)) == lmte) /*look up in main table*/
mmte(); /*not there, make new entry*/
else
if(lblpt->flags&SYDF && (lblpt->flags&SYXR)==0) /*already there*/
uerr(29);
lblpt->flags =| SYXR | SYDF; /*symbol is an external*/
mkextidx(lblpt); /*put into external table*/
if(fchr == ',') { /*skip ',' between operands*/
fchr = gchr();
gterm(TRUE);
if(itype != ITCN) {
xerr(17);
return;
}
lblpt->vl1.wd1 = ival; /* # bytes of storage required*/
}
else
lblpt->vl1.wd1 = 1; /* default # bytes*/
igrst();
}
mkextidx(p)
struct symtab *p;
{
if(extindx >= EXTSZ) { /*check for overflow of external symbol tbl*/
rpterr("overflow of external table\n");
endit();
}
p->vl1.wd2 = pexti - extbl; /* external symbol index #*/
*pexti++ = p; /*save external in external table*/
extindx++;
}
/* end statement*/
hend()
{
register short i;
register int j;
inoffset = 0; /*[vlh] turn off inoffset mode*/
lblpt = 0; /*no label*/
opitb(); /*output beginning of statement*/
igrst(); /* [vlh] ignore operands */
stbuf[0].itrl = itwc; /*number of it entries*/
wostb(); /*write out statement buffer*/
for(i=0; i<ITBSZ; i++)
doitwr(0);
if(initflg) {
putsymtab();
printf("68000 assembler initialized\n");
endit();
}
if((fchr=gchr())!=EOF) {
rpterr("end statement not at end of source\n");
}
savelc[rlflg] = loctr; /*last location on current reloc base*/
fixunds(); /*make golbals and maybe undefineds external*/
if(!didorg) /*did not assign to location counter*/
pass1a(); /*resolve short branches*/
pass2(); /*assembler pass 2*/
}
/* define storage given number of bytes*/
hds()
{
dlabl(); /*define label maybe*/
if (!inoffset) /* [vlh] */
opitb(); /*output it for beginning of statement*/
refpc = 0;
expr(&p1gi);
if(itype!=ITCN) {
xerr(17); /*must be constant*/
return;
}
if(reloc != ABS) {
xerr(9); /*must be absolute*/
return;
}
if (!inoffset) { /* [vlh] don't generate it if in offset */
opitoo(); /*output one operand*/
stbuf[0].itrl = itwc;
wostb(); /*write out statement buffer*/
loctr =+ (ival*modelen);
}
igrst();
}
/* make pc even if necessary for .dc and .ds */
chkeven()
{
register char *pi;
if(modelen>1 && loctr&1) {
pi = opcpt;
opcpt = evenptr;
opitb();
stbuf[0].itrl = itwc;
wostb();
opcpt = pi;
loctr++;
}
}
/* define byte directive*/
hdc()
{
chkeven();
hdata(modelen);
}
/*
* define bytes or words of data
* call with:
* 1 => defining bytes
* 2 => defining words
* 4 => defining long words
*/
hdata(mul)
{
dlabl(); /*define label*/
opitb(); /*beginning of statement*/
numops = 0; /*initialize count for number of operands*/
opito(); /*output it for operands*/
stbuf[0].itrl = itwc; /* # of it entries*/
wostb(); /*write out statement buffer*/
loctr =+ numops*mul; /* count by bytes or words*/
}
/* handle org statement*/
horg()
{
register i;
if(rlflg==TEXT && loctr!=0)
didorg++; /*can't do branch optimization as separate pass now*/
expr(&p1gi); /*value of new relocation counter*/
if(reloc != rlflg && reloc != ABS) {
xerr(27);
return;
}
if(ival < loctr) {
xerr(40); /*trying to go backwards*/
return;
}
opcpt = orgptr; /*org directive for pass 2*/
opitb();
opitoo();
stbuf[0].itrl = itwc;
wostb();
loctr = ival;
dlabl(); /*define label*/
}
/* Assemble for mask2 (R9M), ignore... */
hmask2() /* [vlh] */
{
igrst();
}
/* Define register list */
hreg() /* [vlh] */
{
int mask;
if(lbt[0]==0) {
xerr(4); /*no label*/
return;
}
setname(); /*move label into main table*/
if((lblpt=lemt(sirt,FALSE))!=lmte) {
xerr(5); /*opcode redefined*/
return;
}
if (inoffset)
if (reloc != ABS) {
xerr(11);
return;
}
mmte(); /*make main table entry*/
if ((mask = mkmask()) == -1) {
xerr(6);
return;
}
lblpt->flags =| SYDF|SYEQ|SYRM; /* register mask, defined & equated */
lblpt->vl1 = mask;
igrst();
}
int regmsk[] {0100000,040000,020000,010000,04000,02000,01000,0400,0200,
0100,040,020,010,4,2,1};
/* make a register mask for the reg routine */
mkmask() /* [vlh] */
{
register int *p, i, j, mask;
p = &regmsk; mask = 0;
while ((i = chkreg()) != -1) {
if (fchr == '-') {
fchr = gchr();
if ((j = chkreg()) == -1) {
xerr(40);
return(-1);
}
while (i <= j)
mask =| p[i++];
}
else mask =| p[i];
if (fchr != '/' && fchr != ',') break; /*[vlh] Signetics fix*/
fchr = gchr();
}
return(mask);
}
/* get a register # from file, return -1 if none or illegal */
chkreg() /* [vlh] */
{
register int i, j;
i = j = 0;
if (fchr == 'a' || fchr == 'A')
i = 8;
else if (fchr != 'd' && fchr != 'r' && fchr != 'D' && fchr != 'R')
return(-1);
fchr = gchr();
do {
j = (j*10) + (fchr - '0');
fchr = gchr();
} while (isdigit(fchr));
if (j < 0 || j > AREGHI) return(-1);
i =+ j;
if (i >= 0 && i <= AREGHI) return(i);
else return(-1);
}
/* Define constant block */
hdcb() /* [vlh] */
{
chkeven(); /* on even boundary if not byte block. */
dlabl(); /* define label... */
opitb();
opito();
stbuf[0].itrl = itwc;
numops = stbuf[ITOP1].itop;
loctr =+ numops * modelen;
wostb(); /* write out statement buffer */
}
/* Command line, similar to ds.b */
hcomline() /* [vlh] */
{
dlabl(); /*define label maybe*/
modelen = 1; /* byte store... */
opitb(); /*output it for beginning of statement*/
refpc = 0;
expr(&p1gi);
if(itype!=ITCN) {
xerr(17); /*must be constant*/
return;
}
if(reloc != ABS) {
xerr(9); /*must be absolute*/
return;
}
opitoo(); /*output one operand*/
stbuf[0].itrl = itwc;
wostb(); /*write out statement buffer*/
loctr =+ ival;
igrst();
}
/* Relocateable id record, ignore */
hidnt() /* [vlh] */
{
igrst();
}
/* Define offsets */
hoffset() /* [vlh] */
{
inoffset = 1;
expr(&p1gi); /* get new location counter */
if (itype != ITCN) {
xerr(17); /* constant required */
return;
}
if (reloc != ABS) {
xerr(9); /* must be absolute */
return;
}
loctr = ival;
igrst();
}
/* define sections: map to bss, text and data */
hsection() /* [vlh] */
{
inoffset = 0; /* reseting section turns off offset mode */
dlabl(); /* define label on old base if there is one */
savelc[rlflg] = loctr; /* save old base relocation */
opitb(); /* intermediate table... */
expr(&p1gi); /* get section # */
if (itype != ITCN) {
xerr(17); /* must be a constant */
return;
}
if (ival > 15 || ival < 0) {
xerr(9); /* proper range 0..15 */
return;
}
if (ival==14) rlflg = DATA;
else if (ival==15) rlflg = BSS;
else rlflg = TEXT;
loctr = savelc[rlflg];
stbuf[3].itop = loctr; /* pass 1 location counter */
stbuf[3].itrl = rlflg; /* relocation base */
stbuf[0].itrl = itwc;
wostb();
igrst();
}
/* hopt -- ignore, set up assembler options */
hopt() /* vlh */
{
igrst();
}
/**** Second pass directive handling routines ****/
/* second pass end statement*/
send()
{
register int i;
savelc[rlflg] = loctr;
if(savelc[TEXT]&1) {
rlflg = TEXT;
outbyte(0,DABS);
savelc[TEXT]++;
}
if(savelc[DATA]&1) {
rlflg = DATA;
outbyte(0,DABS);
savelc[DATA]++;
}
if(savelc[BSS]&1) {
savelc[BSS]++;
}
ival = 0;
reloc = ABS;
ckeop(9);
print(0);
cpdata(); /*copy data to loader file*/
osymt(); /*output symbol table*/
myfflush(&tbuf); /*flush text relocation bits*/
cprlbits(); /*copy relocation bits*/
myfflush(&lbuf);
i = (sizeof couthd.ch_magic) + 3*(sizeof couthd.ch_tsize);
if((lseek(lfn,(long)i,0) == -1) || write(lfn,&stlen,4) != 4)
rpterr("I/O error on loader output file\n");
endit(); /*end*/
}
/*second pass define storage - ds*/
sds()
{
print(0);
if(rlflg == TEXT || rlflg==DATA) {
expr(&p2gi);
if(itype != ITCN) {
uerr(13);
return;
}
ival =* modelen;
while(ival) {
outbyte(0,DABS);
loctr++;
ival--;
}
}
else
loctr =+ stbuf[ITOP1].itop*modelen; /*reserve storage*/
}
/* second pass - define block storage, initialized */
sdcb() /* [vlh] */
{
register int pfg, i, hflg, len;
expr(&p2gi);
if (itype != ITCN || reloc != ABS) {
uerr(13); /* must be absolute constant */
return;
}
len = ival;
expr(&p2gi);
if (modelen==1 && (ival<-128 || ival>=256 || reloc != ABS)) {
uerr(20);
ival = 0;
reloc = ABS;
}
while (len--) {
if (modelen==1) {
if (!hflg) {
ins[i].hibyte = ival;
outbyte(ival.wd2,DABS);
hflg++;
}
else {
ins[i++].lobyte = ival;
outbyte(ival.wd2,DABS);
hflg=0;
}
goto sdbl2;
}
else if (modelen==2) {
sdbl1:
ins[i++] = ival.wd2;
outword(ival.wd2, reloc);
sdbl2:
if (i>3) {
instrlen = i*2;
print ((pfg++) ? 2 : 1);
loctr =+ instrlen;
i=0;
}
}
else { /* long word... */
ins[i++] = ival.wd1;
outword(ival.wd1,LUPPER);
goto sdbl1;
}
}
if (i) { /* more printing */
instrlen = i*2 - hflg;
print ((pfg) ? 2 : 1);
loctr =+ instrlen;
}
}
/*second pass data*/
sdsect()
{
savelc[rlflg] = loctr;
rlflg = DATA;
loctr = savelc[DATA];
print(0); /*print the new location counter*/
}
/*second pass text*/
spsect()
{
savelc[rlflg] = loctr;
rlflg = TEXT;
loctr = savelc[TEXT];
print(0); /*print the new location counter*/
}
sbss()
{
savelc[rlflg] = loctr;
rlflg = BSS;
loctr = savelc[BSS];
print(0); /*print the new location counter*/
}
/* make loctr even*/
seven()
{
if(loctr&1) {
if(rlflg==TEXT || rlflg==DATA)
outbyte(0,DABS);
loctr++;
}
print(0);
}
/* second pass org*/
sorg()
{
long l;
if(rlflg==TEXT || rlflg==DATA) { /*must put out zeros*/
l = stbuf[ITOP1].itop - loctr; /*# zeroes to output*/
ins[0] = 0;
print(1);
while(l > 0) {
outbyte(0,DABS);
loctr++;
l--;
}
}
else { /*BSS*/
loctr = stbuf[ITOP1].itop; /*new location counter*/
print(0);
}
}
/*
*second pass define data (words or bytes)
* call with
* 2 => defining words
* 1 => defining bytes
* 4 => defining long words
*/
sdata(dtyp)
{
register pfg,i;
register hflg;
hflg = i = pfg = 0;
while(1) {
expr(&p2gi); /*evaluate expression*/
if(pitw < pnite)
pitw--; /*expr passed a token*/
if(itype!=ITCN && reloc != EXTRN) { /*must be constant*/
uerr(13);
ival=0;
reloc = ABS;
}
if(reloc == EXTRN)
reloc = (extref<<3)|EXTVAR; /*gen extern reference*/
if(dtyp==1) { /*defining a byte*/
if(ival<-128 || ival>=256 || reloc!=ABS) { /*not a byte*/
uerr(20);
ival=0;
reloc = ABS;
}
if(!hflg) {
ins[i].hibyte = ival;
outbyte(ival.wd2,DABS);
hflg++;
}
else {
ins[i++].lobyte = ival;
hflg = 0;
outbyte(ival.wd2,DABS);
}
goto sdal2;
}
else if(dtyp == 2) { /*defining a word*/
sdal1:
ins[i++] = ival.wd2;
outword(ival.wd2, reloc);
sdal2:
if(i>3) {
instrlen = i*2;
print ((pfg++) ? 2 : 1);
loctr =+ instrlen;
i=0;
}
}
else { /*long words*/
ins[i++] = ival.wd1;
outword(ival.wd1,LUPPER);
goto sdal1;
}
if(!ckeop(15)) /*should be end of operand*/
return;
pitw++;
if(ckein()) {
if(hflg) {
ins[i++].lobyte = 0;
}
if(i) { /*more printing*/
instrlen = i*2 - hflg;
print ((pfg) ? 2 : 1);
loctr =+ instrlen;
}
return;
}
}
}
sdc()
{
sdata(modelen);
}
ssection() /* [vlh] */
{
int sect;
sect = stbuf[3].itrl;
if (sect==DATA) sdsect();
else if (sect==BSS) sbss();
else spsect();
}
/*define word statement*/
sdw()
{
sdata(0); /*defining words*/
}
/**** Conditional assembly directives ****/
hifeq() /* [vlh] */
{
if (!acok()) return;
if (ival) {
if (ca_true) ca_level = ca;
ca_true = 0;
}
ca++;
}
hifne() /* [vlh] */
{
if (!acok()) return;
if (!ival) {
if (ca_true) ca_level = ca;
ca_true = 0;
}
ca++;
}
hiflt() /* [vlh] */
{
if (!acok()) return;
if (ival >= 0) {
if (ca_true) ca_level = ca;
ca_true = 0;
}
ca++;
}
hifle() /* [vlh] */
{
if (!acok()) return;
if (ival > 0) {
if (ca_true) ca_level = ca;
ca_true = 0;
}
ca++;
}
hifgt() /* [vlh] */
{
if (!acok()) return;
if (ival <= 0) {
if (ca_true) ca_level = ca;
ca_true = 0;
}
ca++;
}
hifge() /* [vlh] */
{
if (!acok()) return;
if (ival < 0) {
if (ca_true) ca_level = ca;
ca_true = 0;
}
ca++;
}
hifc() /* [vlh] */
{
if (!cmp_ops()) {
if (ca_true) ca_level = ca;
ca_true = 0;
}
ca++;
}
hifnc() /* [vlh] */
{
if (cmp_ops()) {
if (ca_true) ca_level = ca;
ca_true = 0;
}
ca++;
}
hendc() /* [vlh] */
{
if (!ca) {
xerr(25); /* unexpected endc */
return;
}
ca--;
if (!ca_true)
if (ca_level == ca) ca_true = 1;
igrst();
}
hpage()
{
opitb(); /* Output beginning */
wostb(); /* Write out buffer */
igrst(); /* Ignore rest of line */
}
spage()
{
print(0); /* Print the directive */
xline = LPP; /* Force page on next print */
page();
}
acok()
{
expr(&p1gi);
if (itype != ITCN) {
xerr(7); /* must be a constant */
return(0);
}
if (reloc != ABS) {
xerr(11); /* must be absolute, no forward references */
return(0);
}
igrst();
return(1);
}
cmp_ops()
{
char str1[25], str2[25];
register int len1, len2;
if (fchr != '\'') { xerr(9); return(0); }
len1 = len2 = 0;
while (fchr = gchr()) {
if (fchr == '\'') break;
if (fchr == EOLC) return(0);
str1[len1++] = fchr;
}
if ((fchr=gchr()) != ',') { xerr(9); return; }
if ((fchr=gchr()) != '\'') { xerr(10); return;}
while (fchr = gchr()) {
if (fchr == '\'') break;
if (fchr == EOLC) return(0);
str2[len2++] = fchr;
}
igrst();
if (len1 != len2) return(0);
str1[len1] = str2[len2] = NULL;
if (strcmp(str1,str2) == 0) return(1);
return(0);
}
strcmp(s,t)
register char *s, *t;
{
for( ; *s == *t; s++, t++ )
if( *s == '\0' )
return(0);
return( *s - *t );
}

950
CPM OPERATING SYSTEMS/CPM 68K/1.0X SOURCES/v102/as68/dir.lis Normal file
View File

@@ -0,0 +1,950 @@
1File: DIR.C Page 1
1 /*
2 Copyright 1981
3 Alcyon Corporation
4 8716 Production Ave.
5 San Diego, Ca. 92121
6 */
7
8 /* Pass 1 and pass 2 directive handling routines */
9 /* code to handle conditional assembly directives */
10
11 #include "as68.h"
12 #include "cout.h"
13
14 long lseek();
15 int p1gi();
16 int p2gi();
17 int igrst();
18
19 /*directive to define an opcode*/
20 hopd()
21 {
22
23 if(!lbt[0]) {
24 xerr(4); /*no label*/
25 return;
26 }
27 setname(); /*move label into main table*/
28 if((lblpt=lemt(oirt,TRUE))!=lmte) {
29 xerr(5); /*opcode redefined*/
30 return;
31 }
32 mmte(); /*make main table entry*/
33 expr(&p1gi); /*get instruction format*/
34 if(itype!=ITCN || ival<0 || ival>OPFF) {
35 xerr(18); /*illegal format specifier*/
36 return;
37 }
38 lblpt->flags =| ival|SYIN; /*remember format*/
39 if(fchr != ',') { /*field separator*/
40 xerr(10);
41 return;
42 }
43 expr(&p1gi); /*get opcode value*/
44 if(itype != ITCN) {
45 xerr(17); /*not a constant*/
46 return;
47 }
48 lblpt->vl1 = ival; /*put value in main table*/
49 igrst(); /*ignore rest of statement-comment*/
50 }
51
52 /* equate directive*/
53 hequ()
54 {
55 if(lbt[0] == 0) {
56 xerr(4); /*no label*/
57 return;
58 }
59 setname();
1File: DIR.C Page 2
60 if((lblpt=lemt(sirt,FALSE))!=lmte) { /*aready there*/
61 if(lbt[0] == '~') { /*local symbol*/
62 lblpt = lmte;
63 mmte();
64 }
65 }
66 else
67 mmte();
68 if(lblpt->flags&SYXR) {
69 xerr(29);
70 return;
71 }
72 lblpt->flags =| SYDF|SYEQ; /*defined & equate*/
73 equflg = 1;
74 modelen = 4;
75 expr(&p1gi);
76 equflg = 0;
77 if(itype == ITSY && ival.ptrw2->flags&SYER) {
78 lblpt->flags =| SYER; /*equated register*/
79 ival = ival.ptrw2->vl1;
80 }
81 else if(itype != ITCN) {
82 xerr(7); /*not a constant*/
83 return;
84 }
85 if (inoffset && reloc != ABS) { /* [vlh] */
86 xerr(11);
87 return;
88 }
89 if(initflg) /*doing symbol table initialization*/
90 lblpt->flags =| SYIN; /*internal symbol*/
91 lblpt->vl1 = ival;
92 if(reloc == DATA) /*check relocation*/
93 {
94 lblpt->flags =| SYRA; /*DATA relocatable*/
95 }
96 else if(reloc == TEXT)
97 lblpt->flags =| SYRO; /*TEXT relocatable*/
98 else if(reloc == BSS)
99 lblpt->flags =| SYBS; /*BSS relocatable*/
100 else if(fchr==',' && (fchr=gchr())=='r')
101 lblpt->flags =| SYER; /*equated register*/
102 if (refpc) /*[vlh] flag directive is pc relative */
103 lblpt->flags =| SYPC;
104 igrst();
105 }
106
107 /* process dsect directive*/
108 hdsect()
109 {
110 dorlst(DATA);
111 }
112
113 dorlst(xrtyp)
114 {
115 inoffset = 0; /* [vlh] offset mode terminated my sect directive */
116 chkeven(); /* May need to make pc even */
117 dlabl(); /*define label on old base if there is one*/
118 savelc[rlflg] = loctr; /*save old base relocation*/
1File: DIR.C Page 3
119 rlflg = xrtyp;
120 loctr = savelc[xrtyp]; /*set new base relocation ctr*/
121 opitb();
122 stbuf[0].itrl = itwc;
123 wostb();
124 igrst();
125 }
126
127 /*process psect directive*/
128 hpsect()
129 {
130 dorlst(TEXT);
131 }
132
133 hbss()
134 {
135 dorlst(BSS);
136 }
137
138 /*make pc even*/
139 heven()
140 {
141 modelen = 2; /*Try to figure this one out...*/
142 if(loctr&1) { /*have to make it even*/
143 dorlst(rlflg);
144 }
145 else {
146 igrst();
147 }
148 }
149
150 /*process globl directive*/
151 hent()
152 {
153 while(1) {
154 gterm(TRUE); /*get entry symbol*/
155 if(itype!=ITSY) { /*error if not symbol*/
156 xerr(28);
157 return;
158 }
159 if((lblpt=lemt(sirt,FALSE)) == lmte) /*look up in main table*/
160 mmte(); /*not there, make new entry*/
161 else
162 if(lblpt->flags&SYER) /*already there*/
163 uerr(29);
164 lblpt->flags =| SYGL; /*symbol is an entry*/
165 if(lblpt->flags&SYXR) { /*been thru hext code*/
166 lblpt->flags =& ~(SYXR|SYDF); /*reset for init of .comm*/
167 }
168 if (inoffset && reloc != ABS) { /* [vlh] */
169 xerr(11);
170 return;
171 }
172 if(fchr == ',') /*skip ',' between entries*/
173 fchr = gchr();
174 else {
175 igrst(); /*statement finished*/
176 return;
177 }
1File: DIR.C Page 4
178 }
179 }
180
181 /*process comm directive*/
182 hext()
183 {
184 gterm(TRUE); /*get external symbol*/
185 if(itype!=ITSY) { /*error if not symbol*/
186 xerr(28);
187 return;
188 }
189 if((lblpt=lemt(sirt,FALSE)) == lmte) /*look up in main table*/
190 mmte(); /*not there, make new entry*/
191 else
192 if(lblpt->flags&SYDF && (lblpt->flags&SYXR)==0) /*already there*/
193 uerr(29);
194 lblpt->flags =| SYXR | SYDF; /*symbol is an external*/
195 mkextidx(lblpt); /*put into external table*/
196 if(fchr == ',') { /*skip ',' between operands*/
197 fchr = gchr();
198 gterm(TRUE);
199 if(itype != ITCN) {
200 xerr(17);
201 return;
202 }
203 lblpt->vl1.wd1 = ival; /* # bytes of storage required*/
204 }
205 else
206 lblpt->vl1.wd1 = 1; /* default # bytes*/
207 igrst();
208 }
209
210 mkextidx(p)
211 struct symtab *p;
212 {
213
214 if(extindx >= EXTSZ) { /*check for overflow of external symbol tbl*/
215 rpterr("overflow of external table\n");
216 endit();
217 }
218 p->vl1.wd2 = pexti - extbl; /* external symbol index #*/
219 *pexti++ = p; /*save external in external table*/
220 extindx++;
221 }
222
223 /* end statement*/
224 hend()
225 {
226 register short i;
227 register int j;
228
229 inoffset = 0; /*[vlh] turn off inoffset mode*/
230 lblpt = 0; /*no label*/
231 opitb(); /*output beginning of statement*/
232 igrst(); /* [vlh] ignore operands */
233 stbuf[0].itrl = itwc; /*number of it entries*/
234 wostb(); /*write out statement buffer*/
235 for(i=0; i<ITBSZ; i++)
236 doitwr(0);
1File: DIR.C Page 5
237 if(initflg) {
238 putsymtab();
239 printf("68000 assembler initialized\n");
240 endit();
241 }
242 if((fchr=gchr())!=EOF) {
243 rpterr("end statement not at end of source\n");
244 }
245 savelc[rlflg] = loctr; /*last location on current reloc base*/
246 fixunds(); /*make golbals and maybe undefineds external*/
247 if(!didorg) /*did not assign to location counter*/
248 pass1a(); /*resolve short branches*/
249 pass2(); /*assembler pass 2*/
250 }
251
252 /* define storage given number of bytes*/
253 hds()
254 {
255 dlabl(); /*define label maybe*/
256 if (!inoffset) /* [vlh] */
257 opitb(); /*output it for beginning of statement*/
258 refpc = 0;
259 expr(&p1gi);
260 if(itype!=ITCN) {
261 xerr(17); /*must be constant*/
262 return;
263 }
264 if(reloc != ABS) {
265 xerr(9); /*must be absolute*/
266 return;
267 }
268 if (!inoffset) { /* [vlh] don't generate it if in offset */
269 opitoo(); /*output one operand*/
270 stbuf[0].itrl = itwc;
271 wostb(); /*write out statement buffer*/
272 loctr =+ (ival*modelen);
273 }
274 igrst();
275 }
276
277 /* make pc even if necessary for .dc and .ds */
278 chkeven()
279 {
280 register char *pi;
281
282 if(modelen>1 && loctr&1) {
283 pi = opcpt;
284 opcpt = evenptr;
285 opitb();
286 stbuf[0].itrl = itwc;
287 wostb();
288 opcpt = pi;
289 loctr++;
290 }
291 }
292
293 /* define byte directive*/
294 hdc()
295 {
1File: DIR.C Page 6
296 chkeven();
297 hdata(modelen);
298 }
299
300 /*
301 * define bytes or words of data
302 * call with:
303 * 1 => defining bytes
304 * 2 => defining words
305 * 4 => defining long words
306 */
307 hdata(mul)
308 {
309 dlabl(); /*define label*/
310 opitb(); /*beginning of statement*/
311 numops = 0; /*initialize count for number of operands*/
312 opito(); /*output it for operands*/
313 stbuf[0].itrl = itwc; /* # of it entries*/
314 wostb(); /*write out statement buffer*/
315 loctr =+ numops*mul; /* count by bytes or words*/
316 }
317
318 /* handle org statement*/
319 horg()
320 {
321 register i;
322
323 if(rlflg==TEXT && loctr!=0)
324 didorg++; /*can't do branch optimization as separate pass now*/
325 expr(&p1gi); /*value of new relocation counter*/
326 if(reloc != rlflg && reloc != ABS) {
327 xerr(27);
328 return;
329 }
330 if(ival < loctr) {
331 xerr(40); /*trying to go backwards*/
332 return;
333 }
334 opcpt = orgptr; /*org directive for pass 2*/
335 opitb();
336 opitoo();
337 stbuf[0].itrl = itwc;
338 wostb();
339 loctr = ival;
340 dlabl(); /*define label*/
341 }
342
343 /* Assemble for mask2 (R9M), ignore... */
344 hmask2() /* [vlh] */
345 {
346 igrst();
347 }
348
349 /* Define register list */
350 hreg() /* [vlh] */
351 {
352 int mask;
353 if(lbt[0]==0) {
354 xerr(4); /*no label*/
1File: DIR.C Page 7
355 return;
356 }
357 setname(); /*move label into main table*/
358 if((lblpt=lemt(sirt,FALSE))!=lmte) {
359 xerr(5); /*opcode redefined*/
360 return;
361 }
362 if (inoffset)
363 if (reloc != ABS) {
364 xerr(11);
365 return;
366 }
367 mmte(); /*make main table entry*/
368 if ((mask = mkmask()) == -1) {
369 xerr(6);
370 return;
371 }
372 lblpt->flags =| SYDF|SYEQ|SYRM; /* register mask, defined & equated */
373 lblpt->vl1 = mask;
374 igrst();
375 }
376
377 int regmsk[] {0100000,040000,020000,010000,04000,02000,01000,0400,0200,
378 0100,040,020,010,4,2,1};
379 /* make a register mask for the reg routine */
380 mkmask() /* [vlh] */
381 {
382 register int *p, i, j, mask;
383
384 p = &regmsk; mask = 0;
385 while ((i = chkreg()) != -1) {
386 if (fchr == '-') {
387 fchr = gchr();
388 if ((j = chkreg()) == -1) {
389 xerr(40);
390 return(-1);
391 }
392 while (i <= j)
393 mask =| p[i++];
394 }
395 else mask =| p[i];
396 if (fchr != '/' && fchr != ',') break; /*[vlh] Signetics fix*/
397 fchr = gchr();
398 }
399 return(mask);
400 }
401
402 /* get a register # from file, return -1 if none or illegal */
403 chkreg() /* [vlh] */
404 {
405 register int i, j;
406
407 i = j = 0;
408 if (fchr == 'a' || fchr == 'A')
409 i = 8;
410 else if (fchr != 'd' && fchr != 'r' && fchr != 'D' && fchr != 'R')
411 return(-1);
412 fchr = gchr();
413 do {
1File: DIR.C Page 8
414 j = (j*10) + (fchr - '0');
415 fchr = gchr();
416 } while (isdigit(fchr));
417 if (j < 0 || j > AREGHI) return(-1);
418 i =+ j;
419 if (i >= 0 && i <= AREGHI) return(i);
420 else return(-1);
421 }
422
423 /* Define constant block */
424 hdcb() /* [vlh] */
425 {
426 chkeven(); /* on even boundary if not byte block. */
427 dlabl(); /* define label... */
428 opitb();
429 opito();
430 stbuf[0].itrl = itwc;
431 numops = stbuf[ITOP1].itop;
432 loctr =+ numops * modelen;
433 wostb(); /* write out statement buffer */
434 }
435
436 /* Command line, similar to ds.b */
437 hcomline() /* [vlh] */
438 {
439 dlabl(); /*define label maybe*/
440 modelen = 1; /* byte store... */
441 opitb(); /*output it for beginning of statement*/
442 refpc = 0;
443 expr(&p1gi);
444 if(itype!=ITCN) {
445 xerr(17); /*must be constant*/
446 return;
447 }
448 if(reloc != ABS) {
449 xerr(9); /*must be absolute*/
450 return;
451 }
452 opitoo(); /*output one operand*/
453 stbuf[0].itrl = itwc;
454 wostb(); /*write out statement buffer*/
455 loctr =+ ival;
456 igrst();
457 }
458
459 /* Relocateable id record, ignore */
460 hidnt() /* [vlh] */
461 {
462 igrst();
463 }
464
465 /* Define offsets */
466 hoffset() /* [vlh] */
467 {
468 inoffset = 1;
469 expr(&p1gi); /* get new location counter */
470 if (itype != ITCN) {
471 xerr(17); /* constant required */
472 return;
1File: DIR.C Page 9
473 }
474 if (reloc != ABS) {
475 xerr(9); /* must be absolute */
476 return;
477 }
478 loctr = ival;
479 igrst();
480 }
481
482 /* define sections: map to bss, text and data */
483 hsection() /* [vlh] */
484 {
485 inoffset = 0; /* reseting section turns off offset mode */
486 dlabl(); /* define label on old base if there is one */
487 savelc[rlflg] = loctr; /* save old base relocation */
488 opitb(); /* intermediate table... */
489 expr(&p1gi); /* get section # */
490 if (itype != ITCN) {
491 xerr(17); /* must be a constant */
492 return;
493 }
494 if (ival > 15 || ival < 0) {
495 xerr(9); /* proper range 0..15 */
496 return;
497 }
498 if (ival==14) rlflg = DATA;
499 else if (ival==15) rlflg = BSS;
500 else rlflg = TEXT;
501 loctr = savelc[rlflg];
502 stbuf[3].itop = loctr; /* pass 1 location counter */
503 stbuf[3].itrl = rlflg; /* relocation base */
504 stbuf[0].itrl = itwc;
505 wostb();
506 igrst();
507 }
508
509 /* hopt -- ignore, set up assembler options */
510 hopt() /* vlh */
511 {
512 igrst();
513 }
514
515 /**** Second pass directive handling routines ****/
516
517 /* second pass end statement*/
518 send()
519 {
520 register int i;
521
522 savelc[rlflg] = loctr;
523 if(savelc[TEXT]&1) {
524 rlflg = TEXT;
525 outbyte(0,DABS);
526 savelc[TEXT]++;
527 }
528 if(savelc[DATA]&1) {
529 rlflg = DATA;
530 outbyte(0,DABS);
531 savelc[DATA]++;
1File: DIR.C Page 10
532 }
533 if(savelc[BSS]&1) {
534 savelc[BSS]++;
535 }
536
537 ival = 0;
538 reloc = ABS;
539 ckeop(9);
540 print(0);
541 cpdata(); /*copy data to loader file*/
542 osymt(); /*output symbol table*/
543 myfflush(&tbuf); /*flush text relocation bits*/
544 cprlbits(); /*copy relocation bits*/
545 myfflush(&lbuf);
546 i = (sizeof couthd.ch_magic) + 3*(sizeof couthd.ch_tsize);
547 if((lseek(lfn,(long)i,0) == -1) || write(lfn,&stlen,4) != 4)
548 rpterr("I/O error on loader output file\n");
549 endit(); /*end*/
550 }
551
552 /*second pass define storage - ds*/
553 sds()
554 {
555 print(0);
556 if(rlflg == TEXT || rlflg==DATA) {
557 expr(&p2gi);
558 if(itype != ITCN) {
559 uerr(13);
560 return;
561 }
562 ival =* modelen;
563 while(ival) {
564 outbyte(0,DABS);
565 loctr++;
566 ival--;
567 }
568 }
569 else
570 loctr =+ stbuf[ITOP1].itop*modelen; /*reserve storage*/
571 }
572
573 /* second pass - define block storage, initialized */
574 sdcb() /* [vlh] */
575 {
576 register int pfg, i, hflg, len;
577
578 expr(&p2gi);
579 if (itype != ITCN || reloc != ABS) {
580 uerr(13); /* must be absolute constant */
581 return;
582 }
583 len = ival;
584 expr(&p2gi);
585 if (modelen==1 && (ival<-128 || ival>=256 || reloc != ABS)) {
586 uerr(20);
587 ival = 0;
588 reloc = ABS;
589 }
590 while (len--) {
1File: DIR.C Page 11
591 if (modelen==1) {
592 if (!hflg) {
593 ins[i].hibyte = ival;
594 outbyte(ival.wd2,DABS);
595 hflg++;
596 }
597 else {
598 ins[i++].lobyte = ival;
599 outbyte(ival.wd2,DABS);
600 hflg=0;
601 }
602 goto sdbl2;
603 }
604 else if (modelen==2) {
605 sdbl1:
606 ins[i++] = ival.wd2;
607 outword(ival.wd2, reloc);
608 sdbl2:
609 if (i>3) {
610 instrlen = i*2;
611 print ((pfg++) ? 2 : 1);
612 loctr =+ instrlen;
613 i=0;
614 }
615 }
616 else { /* long word... */
617 ins[i++] = ival.wd1;
618 outword(ival.wd1,LUPPER);
619 goto sdbl1;
620 }
621 }
622 if (i) { /* more printing */
623 instrlen = i*2 - hflg;
624 print ((pfg) ? 2 : 1);
625 loctr =+ instrlen;
626 }
627 }
628
629 /*second pass data*/
630 sdsect()
631 {
632 savelc[rlflg] = loctr;
633 rlflg = DATA;
634 loctr = savelc[DATA];
635 print(0); /*print the new location counter*/
636 }
637
638 /*second pass text*/
639 spsect()
640 {
641 savelc[rlflg] = loctr;
642 rlflg = TEXT;
643 loctr = savelc[TEXT];
644 print(0); /*print the new location counter*/
645 }
646
647 sbss()
648 {
649 savelc[rlflg] = loctr;
1File: DIR.C Page 12
650 rlflg = BSS;
651 loctr = savelc[BSS];
652 print(0); /*print the new location counter*/
653 }
654
655 /* make loctr even*/
656 seven()
657 {
658 if(loctr&1) {
659 if(rlflg==TEXT || rlflg==DATA)
660 outbyte(0,DABS);
661 loctr++;
662 }
663 print(0);
664 }
665
666 /* second pass org*/
667 sorg()
668 {
669 long l;
670
671 if(rlflg==TEXT || rlflg==DATA) { /*must put out zeros*/
672 l = stbuf[ITOP1].itop - loctr; /*# zeroes to output*/
673 ins[0] = 0;
674 print(1);
675 while(l > 0) {
676 outbyte(0,DABS);
677 loctr++;
678 l--;
679 }
680 }
681 else { /*BSS*/
682 loctr = stbuf[ITOP1].itop; /*new location counter*/
683 print(0);
684 }
685 }
686
687 /*
688 *second pass define data (words or bytes)
689 * call with
690 * 2 => defining words
691 * 1 => defining bytes
692 * 4 => defining long words
693 */
694 sdata(dtyp)
695 {
696 register pfg,i;
697 register hflg;
698
699 hflg = i = pfg = 0;
700 while(1) {
701 expr(&p2gi); /*evaluate expression*/
702 if(pitw < pnite)
703 pitw--; /*expr passed a token*/
704 if(itype!=ITCN && reloc != EXTRN) { /*must be constant*/
705 uerr(13);
706 ival=0;
707 reloc = ABS;
708 }
1File: DIR.C Page 13
709 if(reloc == EXTRN)
710 reloc = (extref<<3)|EXTVAR; /*gen extern reference*/
711 if(dtyp==1) { /*defining a byte*/
712 if(ival<-128 || ival>=256 || reloc!=ABS) { /*not a byte*/
713 uerr(20);
714 ival=0;
715 reloc = ABS;
716 }
717 if(!hflg) {
718 ins[i].hibyte = ival;
719 outbyte(ival.wd2,DABS);
720 hflg++;
721 }
722 else {
723 ins[i++].lobyte = ival;
724 hflg = 0;
725 outbyte(ival.wd2,DABS);
726 }
727 goto sdal2;
728 }
729 else if(dtyp == 2) { /*defining a word*/
730 sdal1:
731 ins[i++] = ival.wd2;
732 outword(ival.wd2, reloc);
733 sdal2:
734 if(i>3) {
735 instrlen = i*2;
736 print ((pfg++) ? 2 : 1);
737 loctr =+ instrlen;
738 i=0;
739 }
740 }
741 else { /*long words*/
742 ins[i++] = ival.wd1;
743 outword(ival.wd1,LUPPER);
744 goto sdal1;
745 }
746 if(!ckeop(15)) /*should be end of operand*/
747 return;
748 pitw++;
749 if(ckein()) {
750 if(hflg) {
751 ins[i++].lobyte = 0;
752 }
753 if(i) { /*more printing*/
754 instrlen = i*2 - hflg;
755 print ((pfg) ? 2 : 1);
756 loctr =+ instrlen;
757 }
758 return;
759 }
760 }
761 }
762
763 sdc()
764 {
765 sdata(modelen);
766 }
767
1File: DIR.C Page 14
768 ssection() /* [vlh] */
769 {
770 int sect;
771
772 sect = stbuf[3].itrl;
773 if (sect==DATA) sdsect();
774 else if (sect==BSS) sbss();
775 else spsect();
776 }
777
778 /*define word statement*/
779 sdw()
780 {
781 sdata(0); /*defining words*/
782 }
783 /**** Conditional assembly directives ****/
784
785 hifeq() /* [vlh] */
786 {
787 if (!acok()) return;
788 if (ival) {
789 if (ca_true) ca_level = ca;
790 ca_true = 0;
791 }
792 ca++;
793 }
794
795 hifne() /* [vlh] */
796 {
797 if (!acok()) return;
798 if (!ival) {
799 if (ca_true) ca_level = ca;
800 ca_true = 0;
801 }
802 ca++;
803 }
804
805 hiflt() /* [vlh] */
806 {
807 if (!acok()) return;
808 if (ival >= 0) {
809 if (ca_true) ca_level = ca;
810 ca_true = 0;
811 }
812 ca++;
813 }
814
815 hifle() /* [vlh] */
816 {
817 if (!acok()) return;
818 if (ival > 0) {
819 if (ca_true) ca_level = ca;
820 ca_true = 0;
821 }
822 ca++;
823 }
824
825 hifgt() /* [vlh] */
826 {
1File: DIR.C Page 15
827 if (!acok()) return;
828 if (ival <= 0) {
829 if (ca_true) ca_level = ca;
830 ca_true = 0;
831 }
832 ca++;
833 }
834
835 hifge() /* [vlh] */
836 {
837 if (!acok()) return;
838 if (ival < 0) {
839 if (ca_true) ca_level = ca;
840 ca_true = 0;
841 }
842 ca++;
843 }
844
845 hifc() /* [vlh] */
846 {
847 if (!cmp_ops()) {
848 if (ca_true) ca_level = ca;
849 ca_true = 0;
850 }
851 ca++;
852 }
853
854 hifnc() /* [vlh] */
855 {
856 if (cmp_ops()) {
857 if (ca_true) ca_level = ca;
858 ca_true = 0;
859 }
860 ca++;
861 }
862
863 hendc() /* [vlh] */
864 {
865 if (!ca) {
866 xerr(25); /* unexpected endc */
867 return;
868 }
869 ca--;
870 if (!ca_true)
871 if (ca_level == ca) ca_true = 1;
872 igrst();
873 }
874 hpage()
875 {
876 opitb(); /* Output beginning */
877 wostb(); /* Write out buffer */
878 igrst(); /* Ignore rest of line */
879 }
880 spage()
881 {
882 print(0); /* Print the directive */
883 xline = LPP; /* Force page on next print */
884 page();
885 }
1File: DIR.C Page 16
886 acok()
887 {
888 expr(&p1gi);
889 if (itype != ITCN) {
890 xerr(7); /* must be a constant */
891 return(0);
892 }
893 if (reloc != ABS) {
894 xerr(11); /* must be absolute, no forward references */
895 return(0);
896 }
897 igrst();
898 return(1);
899 }
900
901 cmp_ops()
902 {
903 char str1[25], str2[25];
904 register int len1, len2;
905
906 if (fchr != '\'') { xerr(9); return(0); }
907 len1 = len2 = 0;
908 while (fchr = gchr()) {
909 if (fchr == '\'') break;
910 if (fchr == EOLC) return(0);
911 str1[len1++] = fchr;
912 }
913 if ((fchr=gchr()) != ',') { xerr(9); return; }
914 if ((fchr=gchr()) != '\'') { xerr(10); return;}
915 while (fchr = gchr()) {
916 if (fchr == '\'') break;
917 if (fchr == EOLC) return(0);
918 str2[len2++] = fchr;
919 }
920 igrst();
921 if (len1 != len2) return(0);
922 str1[len1] = str2[len2] = NULL;
923 if (strcmp(str1,str2) == 0) return(1);
924 return(0);
925 }
926
927 strcmp(s,t)
928 register char *s, *t;
929 {
930 for( ; *s == *t; s++, t++ )
931 if( *s == '\0' )
932 return(0);
933 return( *s - *t );
934 }

505
CPM OPERATING SYSTEMS/CPM 68K/1.0X SOURCES/v102/as68/expr.c Normal file
View File

@@ -0,0 +1,505 @@
/*
Copyright 1981
Alcyon Corporation
8716 Production Ave.
San Diego, Ca. 92121
*/
/* Expression evaluator */
# include "as68.h"
/*precedence of operators*/
# define PAO 2 /*AND, OR*/
# define PPM 2 /*+ -*/
# define PMD 3 /** /*/
# define PLP 1 /* (*/
# define PRP 4 /* )*/
# define PEE 0 /* all other special chars*/
/*global integers for this package*/
struct it exitm; /*expression item*/
int prcnt; /*paren count*/
int rval; /*relocation value*/
int lpflg;
int lastopr; /*last token was operator when set*/
long gval(); /*get operand value*/
/*
* expression evaluator
* call with:
* address of function to get input
* returns:
* item type in itype
* item value in ival
* relocation flag in reloc:
* 0 => absolute
* 1 => data
* 2 => text
* 3 => bss
* 4 => external
*
* The only expressions involving externals which are legal are
* external+constant or external-constant
*/
struct it *piop, *pitr;
int iop, itr;
struct it opstk[OPSTLEN]; /*operator stack*/
struct it tree[TREELEN]; /*operand stack*/
expr(iploc)
int (*iploc)();
{
register int i, ipr;
extflg = starmul = iop = lpflg = 0;
piop = &opstk[0];
itr = -1; /*tree stack pointer*/
pitr = &tree[0];
pitr--;
/* form end of expression operator*/
opstk[0].itty = ITSP; /*special character*/
opstk[0].itop.wd2 = '?';
lastopr = 1;
/* get an input item*/
while(1) {
if(itr >= TREELEN-2) {
rpterr("expr tree overflow\n");
abort();
}
if(iop >= OPSTLEN-1) {
rpterr("expr opstk overflow\n");
abort();
}
(*iploc)(); /*get an input term*/
if (itype==ITPC) return;
starmul=0; /* * is location counter*/
/* special character*/
if(itype==ITSP) {
ipr = gprc(i=ival.wd2); /*get precedence of character*/
if(ipr==PEE) /*end of expression*/
break;
lastopr = 1;
if(ipr==PLP) { /*left paren*/
lpflg++;
prcnt++;
iop++; /*up stack pointer*/
piop++;
piop->swd1=exitm.swd1; /*put operator on stack*/
piop->itop=exitm.itop;
continue;
}
if(ipr==PRP) { /*right paren*/
if(lpflg) { exerr(1); return; }
starmul = 1; /* * is multiply*/
prcnt--; /*down one level*/
while (piop->itop != '(') { /* top stk is '(' */
itr++; /*up tree pointer*/
pitr++;
pitr->swd1 = piop->swd1; /*move operator*/
pitr->itop = piop->itop;
iop--; /*reduce operand stack*/
piop--;
}
iop--; /*remove stack*/
piop--;
continue;
}
while(ipr<=gprc(i=piop->itop.wd2)) { /* >= precedence */
itr++;
pitr++;
pitr->swd1 = piop->swd1; /*move operator*/
pitr->itop = piop->itop;
iop--; /*reduce operand stack*/
piop--;
}
iop++; /*up operator stack*/
piop++;
piop->swd1 = exitm.swd1; /*put in operator stack*/
piop->itop = exitm.itop;
continue;
}
/* symbol or constant*/
else {
lastopr = lpflg = 0; /*clear flag*/
itr++; /*up tree pointer*/
pitr++;
pitr->swd1 = exitm.swd1; /*put in tree*/
pitr->itop = exitm.itop;
starmul = 1; /* * is multiply*/
continue;
}
} /* end while(1)... */
/*output the rest of the operator stack to the tree*/
for(i=iop; i>=0; i--) {
itr++;
pitr++;
pitr->swd1 = piop->swd1; /*move operator*/
pitr->itop = piop->itop;
piop--;
}
collapse();
}
/* collapse the tree into one entry*/
collapse()
{
register int rv1, rv2, topr, i, bos;
register long tv1, tv2;
bos = 0;
exct1:
if(itr>=3) {
piop = &tree[bos];
iop = bos;
while (iop<=(itr-3+bos) && (piop->itty==ITSP ||
(piop+1)->itty==ITSP || (piop+2)->itty!=ITSP)) {
iop++;
piop++;
}
if (iop<=(itr-3+bos)) {
tv1 = gval(piop); /*get value of first operand*/
rv1 = rval; /*relocation value*/
tv2 = gval(piop+1);
rv2 = rval;
topr = (piop+2)->itop; /*operator*/
/* handle operators */
if (topr == '+') {
tv1=+ tv2;
rv1 = ckrl1(rv1,rv2); /*relocation*/
}
else if (topr == '-') {
tv1 =- tv2;
rv1 = ckrl2(rv1,rv2); /*relocation*/
}
else {
switch(topr) { /*operator*/
case '/': /* division */
tv1 =/ tv2; break;
case '*': /* multiplication */
tv1 =* tv2; break;
case '&': /* logical and */
tv1 =& tv2; break;
case '!': /* logical or */
tv1 =| tv2; break;
case '<': /* left shift */
tv1 =<< tv2.wd2; break;
case '>': /* right shift */
tv1 =>> tv2.wd2; break;
default: /*invalid operator*/
exerr(2); return;
}
rv1 = ckrl3(rv1,rv2); /* relocation */
}
/*put new value in tree*/
if (iop==bos) {
bos =+ 2;
iop = bos;
}
piop = &tree[iop];
piop->itty = ITCN; /*must be constant*/
piop->itop = tv1; /*value*/
piop->itrl = rv1; /*relocation value*/
if (iop != bos) { /* push up the rest of the tree... */
i = iop + 2 - bos;
pitr = piop+2;
for(; i<itr; i++) {
piop++;
pitr++;
piop->swd1 = pitr->swd1;
piop->itop = pitr->itop;
}
}
itr =- 2;
goto exct1;
}
}
/* check for unary minus and unary plus*/
if (tree[bos+1].itty!=ITSP && tree[bos].itop.wd2=='?')
{ exerr(3); return; }
if (tree[bos+1].itty!=ITSP || tree[bos].itty==ITSP) {
reloc = ABS;
ival = 0;
itype = ITCN;
return;
}
if(tree[bos+1].itop.wd2!='?') { /*end of statement*/
if(tree[bos+1].itop.wd2!='+') { /*ignore unary plus*/
if(tree[bos+1].itop.wd2!='-') { /* invalid operator */
exerr(4);
return;
}
tree[bos+1].itop = -gval(&tree[bos]);
tree[bos+1].itty = ITCN;
tree[bos+1].itrl = tree[bos].itrl;
bos++;
itr--;
goto exct1;
}
}
/* send results back to caller*/
if ((itype = tree[bos].itty)==ITCN)
ival = gval(&tree[bos]);
else {
ival = tree[bos].itop;
if(itype==ITSY && !(ival.ptrw2->flags&SYDF)) { /*undef symbol*/
reloc = ABS;
ival = 0;
itype = ITCN;
return;
}
}
get_val(tree[bos].itrl);
}
/*
*if defined symbol get value and say constant
* except for externals and equated registers
*/
get_val(reloc_val)
int reloc_val;
{
if(itype==ITSY && (ival.ptrw2->flags&(SYXR|SYER))==0) {
if(ival.ptrw2->flags&SYRA) /*get symbol relocation factor*/
reloc = DATA;
else if(ival.ptrw2->flags&SYRO)
reloc = TEXT;
else if(ival.ptrw2->flags&SYBS)
reloc = BSS;
else reloc = ABS;
ival = ival.ptrw2->vl1; /*symbol vaue*/
itype = ITCN; /*constant*/
}
else
if(itype == ITSY && ival.ptrw2->flags&SYXR) { /*external symbol*/
fixext(ival.ptrw2);
reloc = EXTRN;
}
else
reloc = reloc_val; /*relocation value of item*/
}
exerr(n) /* [vlh] */
int n;
{
uerr(6);
ival = 0;
itype = ITCN;
reloc = ABS;
}
/*
* get precedence of a operator
* call with
* operator
* returns
* precedence
*/
gprc(dprc)
{
switch(dprc) {
case '+':
case '-':
case '&': /* and*/
case '!': /* or*/
case '^': /*exclusive or*/
return(PPM);
case '/':
case '*':
case '<': /*left shift*/
case '>': /*right shift*/
return(PMD);
case '(':
if(lastopr)
return(PLP);
break;
case ')':
if(!prcnt) /*no left parens*/
break;
return(PRP);
}
return(PEE); /*end of expression*/
}
/*
* get value from an it format item
* call with
* address of it format item
* returns
* the value
* relocation value in rval
* calls uerr if it cant get a value
*/
long gval(avwrd)
struct it *avwrd;
{
register struct it *vwrd;
register struct symtab *p;
vwrd = avwrd;
if(vwrd->itty == ITCN) { /*constant*/
rval = vwrd->itrl;
return(vwrd->itop); /*value*/
}
if(vwrd->itty != ITSY) {
uerr(6);
rval = ABS;
return(0);
}
p = vwrd->itop.ptrw2;
if(p->flags&SYXR) { /*external reference*/
fixext(p);
return(0);
}
if((p->flags&SYDF) != SYDF || (p->flags&SYER)) {
uerr(6);
rval = ABS;
return(0);
}
rval = (p->flags&SYRA) ? DATA : (p->flags&SYRO) /* reloc of item */
? TEXT : (p->flags&SYBS) ? BSS : ABS;
return(p->vl1);
}
/*
* get items for expression evaluator (pass one)
* returns:
* item type in itype
* item value in ival
* item in it format in exitm
*/
p1gi()
{
if(fcflg) /*used item so must pass it*/
gterm(TRUE);
if(!fcflg && ckspc(fchr)==1) {
fcflg=1; /*just pass first character*/
itype=ITSP; /*special char*/
ival=fchr; /*value is the char*/
}
else { /*get a whole term*/
fcflg = 0;
gterm(TRUE); /*get a term*/
if(itype==ITSY) { /* got a symbol*/
ival.ptrw2=lemt(sirt,FALSE); /*look it up in main table*/
if(ival.ptrw2==lmte) /*not there before*/
mmte(); /*put it in table*/
}
else
if(itype == ITCN)
exitm.itrl = reloc;
}
exitm.itty = itype;
exitm.itop = ival;
}
/*
* get items for expression evaluator (pass 2)
* returns:
* item type in itype
* item value in ival
* item in it format in exitm
*/
p2gi()
{
if(pitw==pnite) { /*end of statement*/
itype = ITSP;
ival = ' '; /*blank*/
exitm.itty = itype;
exitm.itop = ival;
return;
}
if((itype = pitw->itty) == ITPC) { /*vlh*/
pitw->itop = loctr;
if (p2flg || format==6) itype = pitw->itty = ITCN;
}
ival = pitw->itop; /*value*/
exitm.swd1 = pitw->swd1;
exitm.itop = ival;
pitw++;
}
/*
*check for a special character
* call with
* character to check
* returns:
* 0 => character is number or letter
*/
ckspc(acksc)
{
register cksc;
cksc = acksc;
if (isalnum(cksc)) return(0);
return((index("_~*.@$%\'",cksc) != -1) ? 0 : 1); /*[vlh] compacted*/
}
/* generate new relocation for op + op*/
ckrl1(rv1,rv2)
{
if(rv1==rv2)
return(rv1);
if(rv1==ABS || rv2==ABS)
return(rv1+rv2); /*the one that is not ABS*/
uerr(27);
return(ABS);
}
/*generate new relocation for op - op*/
ckrl2(rv1,rv2)
{
if(rv2==EXTRN)
uerr(26);
if(rv1==rv2)
return(ABS);
if(rv2==ABS)
return(rv1+rv2);
uerr(27);
return(ABS);
}
/*generate new relocation for op /*&|<>^! op*/
ckrl3(rv1,rv2)
{
if(rv1!=ABS || rv2!=ABS)
uerr(27);
return(ABS);
}
fixext(p)
struct symtab *p;
{
if(extflg)
uerr(36); /*two externals in expr*/
extflg++;
extref = p->vl1.wd2; /*get external #*/
rval = EXTRN;
itype = ITCN;
ival = 0;
}

514
CPM OPERATING SYSTEMS/CPM 68K/1.0X SOURCES/v102/as68/expr.lis Normal file
View File

@@ -0,0 +1,514 @@
1File: EXPR.C Page 1
1 /*
2 Copyright 1981
3 Alcyon Corporation
4 8716 Production Ave.
5 San Diego, Ca. 92121
6 */
7
8 /* Expression evaluator */
9
10 # include "as68.h"
11
12 /*precedence of operators*/
13 # define PAO 2 /*AND, OR*/
14 # define PPM 2 /*+ -*/
15 # define PMD 3 /** /*/
16 # define PLP 1 /* (*/
17 # define PRP 4 /* )*/
18 # define PEE 0 /* all other special chars*/
19
20
21 /*global integers for this package*/
22 struct it exitm; /*expression item*/
23 int prcnt; /*paren count*/
24 int rval; /*relocation value*/
25 int lpflg;
26 int lastopr; /*last token was operator when set*/
27
28 long gval(); /*get operand value*/
29
30 /*
31 * expression evaluator
32 * call with:
33 * address of function to get input
34 * returns:
35 * item type in itype
36 * item value in ival
37 * relocation flag in reloc:
38 * 0 => absolute
39 * 1 => data
40 * 2 => text
41 * 3 => bss
42 * 4 => external
43 *
44 * The only expressions involving externals which are legal are
45 * external+constant or external-constant
46 */
47
48 struct it *piop, *pitr;
49 int iop, itr;
50
51 struct it opstk[OPSTLEN]; /*operator stack*/
52 struct it tree[TREELEN]; /*operand stack*/
53
54 expr(iploc)
55 int (*iploc)();
56 {
57 register int i, ipr;
58
59 extflg = starmul = iop = lpflg = 0;
1File: EXPR.C Page 2
60 piop = &opstk[0];
61 itr = -1; /*tree stack pointer*/
62 pitr = &tree[0];
63 pitr--;
64 /* form end of expression operator*/
65 opstk[0].itty = ITSP; /*special character*/
66 opstk[0].itop.wd2 = '?';
67 lastopr = 1;
68
69 /* get an input item*/
70 while(1) {
71 if(itr >= TREELEN-2) {
72 rpterr("expr tree overflow\n");
73 abort();
74 }
75 if(iop >= OPSTLEN-1) {
76 rpterr("expr opstk overflow\n");
77 abort();
78 }
79 (*iploc)(); /*get an input term*/
80 if (itype==ITPC) return;
81 starmul=0; /* * is location counter*/
82
83 /* special character*/
84 if(itype==ITSP) {
85 ipr = gprc(i=ival.wd2); /*get precedence of character*/
86 if(ipr==PEE) /*end of expression*/
87 break;
88 lastopr = 1;
89 if(ipr==PLP) { /*left paren*/
90 lpflg++;
91 prcnt++;
92 iop++; /*up stack pointer*/
93 piop++;
94 piop->swd1=exitm.swd1; /*put operator on stack*/
95 piop->itop=exitm.itop;
96 continue;
97 }
98 if(ipr==PRP) { /*right paren*/
99 if(lpflg) { exerr(1); return; }
100 starmul = 1; /* * is multiply*/
101 prcnt--; /*down one level*/
102
103 while (piop->itop != '(') { /* top stk is '(' */
104 itr++; /*up tree pointer*/
105 pitr++;
106 pitr->swd1 = piop->swd1; /*move operator*/
107 pitr->itop = piop->itop;
108 iop--; /*reduce operand stack*/
109 piop--;
110 }
111 iop--; /*remove stack*/
112 piop--;
113 continue;
114 }
115
116 while(ipr<=gprc(i=piop->itop.wd2)) { /* >= precedence */
117 itr++;
118 pitr++;
1File: EXPR.C Page 3
119 pitr->swd1 = piop->swd1; /*move operator*/
120 pitr->itop = piop->itop;
121 iop--; /*reduce operand stack*/
122 piop--;
123 }
124 iop++; /*up operator stack*/
125 piop++;
126 piop->swd1 = exitm.swd1; /*put in operator stack*/
127 piop->itop = exitm.itop;
128 continue;
129 }
130
131 /* symbol or constant*/
132 else {
133 lastopr = lpflg = 0; /*clear flag*/
134 itr++; /*up tree pointer*/
135 pitr++;
136 pitr->swd1 = exitm.swd1; /*put in tree*/
137 pitr->itop = exitm.itop;
138 starmul = 1; /* * is multiply*/
139 continue;
140 }
141 } /* end while(1)... */
142
143 /*output the rest of the operator stack to the tree*/
144 for(i=iop; i>=0; i--) {
145 itr++;
146 pitr++;
147 pitr->swd1 = piop->swd1; /*move operator*/
148 pitr->itop = piop->itop;
149 piop--;
150 }
151
152 collapse();
153 }
154
155 /* collapse the tree into one entry*/
156 collapse()
157 {
158 register int rv1, rv2, topr, i, bos;
159 register long tv1, tv2;
160
161 bos = 0;
162 exct1:
163 if(itr>=3) {
164 piop = &tree[bos];
165 iop = bos;
166 while (iop<=(itr-3+bos) && (piop->itty==ITSP ||
167 (piop+1)->itty==ITSP || (piop+2)->itty!=ITSP)) {
168 iop++;
169 piop++;
170 }
171 if (iop<=(itr-3+bos)) {
172 tv1 = gval(piop); /*get value of first operand*/
173 rv1 = rval; /*relocation value*/
174 tv2 = gval(piop+1);
175 rv2 = rval;
176 topr = (piop+2)->itop; /*operator*/
177
1File: EXPR.C Page 4
178 /* handle operators */
179 if (topr == '+') {
180 tv1=+ tv2;
181 rv1 = ckrl1(rv1,rv2); /*relocation*/
182 }
183 else if (topr == '-') {
184 tv1 =- tv2;
185 rv1 = ckrl2(rv1,rv2); /*relocation*/
186 }
187 else {
188 switch(topr) { /*operator*/
189 case '/': /* division */
190 tv1 =/ tv2; break;
191 case '*': /* multiplication */
192 tv1 =* tv2; break;
193 case '&': /* logical and */
194 tv1 =& tv2; break;
195 case '!': /* logical or */
196 tv1 =| tv2; break;
197 case '<': /* left shift */
198 tv1 =<< tv2.wd2; break;
199 case '>': /* right shift */
200 tv1 =>> tv2.wd2; break;
201 default: /*invalid operator*/
202 exerr(2); return;
203 }
204 rv1 = ckrl3(rv1,rv2); /* relocation */
205 }
206
207 /*put new value in tree*/
208 if (iop==bos) {
209 bos =+ 2;
210 iop = bos;
211 }
212 piop = &tree[iop];
213 piop->itty = ITCN; /*must be constant*/
214 piop->itop = tv1; /*value*/
215 piop->itrl = rv1; /*relocation value*/
216
217 if (iop != bos) { /* push up the rest of the tree... */
218 i = iop + 2 - bos;
219 pitr = piop+2;
220 for(; i<itr; i++) {
221 piop++;
222 pitr++;
223 piop->swd1 = pitr->swd1;
224 piop->itop = pitr->itop;
225 }
226 }
227 itr =- 2;
228 goto exct1;
229 }
230 }
231
232 /* check for unary minus and unary plus*/
233 if (tree[bos+1].itty!=ITSP && tree[bos].itop.wd2=='?')
234 { exerr(3); return; }
235 if (tree[bos+1].itty!=ITSP || tree[bos].itty==ITSP) {
236 reloc = ABS;
1File: EXPR.C Page 5
237 ival = 0;
238 itype = ITCN;
239 return;
240 }
241
242 if(tree[bos+1].itop.wd2!='?') { /*end of statement*/
243 if(tree[bos+1].itop.wd2!='+') { /*ignore unary plus*/
244 if(tree[bos+1].itop.wd2!='-') { /* invalid operator */
245 exerr(4);
246 return;
247 }
248 tree[bos+1].itop = -gval(&tree[bos]);
249 tree[bos+1].itty = ITCN;
250 tree[bos+1].itrl = tree[bos].itrl;
251 bos++;
252 itr--;
253 goto exct1;
254 }
255 }
256 /* send results back to caller*/
257 if ((itype = tree[bos].itty)==ITCN)
258 ival = gval(&tree[bos]);
259 else {
260 ival = tree[bos].itop;
261 if(itype==ITSY && !(ival.ptrw2->flags&SYDF)) { /*undef symbol*/
262 reloc = ABS;
263 ival = 0;
264 itype = ITCN;
265 return;
266 }
267 }
268 get_val(tree[bos].itrl);
269 }
270
271 /*
272 *if defined symbol get value and say constant
273 * except for externals and equated registers
274 */
275 get_val(reloc_val)
276 int reloc_val;
277 {
278 if(itype==ITSY && (ival.ptrw2->flags&(SYXR|SYER))==0) {
279 if(ival.ptrw2->flags&SYRA) /*get symbol relocation factor*/
280 reloc = DATA;
281 else if(ival.ptrw2->flags&SYRO)
282 reloc = TEXT;
283 else if(ival.ptrw2->flags&SYBS)
284 reloc = BSS;
285 else reloc = ABS;
286 ival = ival.ptrw2->vl1; /*symbol vaue*/
287 itype = ITCN; /*constant*/
288 }
289 else
290 if(itype == ITSY && ival.ptrw2->flags&SYXR) { /*external symbol*/
291 fixext(ival.ptrw2);
292 reloc = EXTRN;
293 }
294 else
295 reloc = reloc_val; /*relocation value of item*/
1File: EXPR.C Page 6
296 }
297
298 exerr(n) /* [vlh] */
299 int n;
300 {
301 uerr(6);
302 ival = 0;
303 itype = ITCN;
304 reloc = ABS;
305 }
306
307 /*
308 * get precedence of a operator
309 * call with
310 * operator
311 * returns
312 * precedence
313 */
314 gprc(dprc)
315 {
316
317 switch(dprc) {
318
319 case '+':
320 case '-':
321 case '&': /* and*/
322 case '!': /* or*/
323 case '^': /*exclusive or*/
324 return(PPM);
325
326 case '/':
327 case '*':
328 case '<': /*left shift*/
329 case '>': /*right shift*/
330 return(PMD);
331
332 case '(':
333 if(lastopr)
334 return(PLP);
335 break;
336
337 case ')':
338 if(!prcnt) /*no left parens*/
339 break;
340 return(PRP);
341
342 }
343 return(PEE); /*end of expression*/
344 }
345
346 /*
347 * get value from an it format item
348 * call with
349 * address of it format item
350 * returns
351 * the value
352 * relocation value in rval
353 * calls uerr if it cant get a value
354 */
1File: EXPR.C Page 7
355 long gval(avwrd)
356 struct it *avwrd;
357 {
358 register struct it *vwrd;
359 register struct symtab *p;
360
361 vwrd = avwrd;
362 if(vwrd->itty == ITCN) { /*constant*/
363 rval = vwrd->itrl;
364 return(vwrd->itop); /*value*/
365 }
366 if(vwrd->itty != ITSY) {
367 uerr(6);
368 rval = ABS;
369 return(0);
370 }
371 p = vwrd->itop.ptrw2;
372 if(p->flags&SYXR) { /*external reference*/
373 fixext(p);
374 return(0);
375 }
376 if((p->flags&SYDF) != SYDF || (p->flags&SYER)) {
377 uerr(6);
378 rval = ABS;
379 return(0);
380 }
381 rval = (p->flags&SYRA) ? DATA : (p->flags&SYRO) /* reloc of item */
382 ? TEXT : (p->flags&SYBS) ? BSS : ABS;
383 return(p->vl1);
384 }
385
386 /*
387 * get items for expression evaluator (pass one)
388 * returns:
389 * item type in itype
390 * item value in ival
391 * item in it format in exitm
392 */
393 p1gi()
394 {
395 if(fcflg) /*used item so must pass it*/
396 gterm(TRUE);
397 if(!fcflg && ckspc(fchr)==1) {
398 fcflg=1; /*just pass first character*/
399 itype=ITSP; /*special char*/
400 ival=fchr; /*value is the char*/
401 }
402 else { /*get a whole term*/
403 fcflg = 0;
404 gterm(TRUE); /*get a term*/
405 if(itype==ITSY) { /* got a symbol*/
406 ival.ptrw2=lemt(sirt,FALSE); /*look it up in main table*/
407 if(ival.ptrw2==lmte) /*not there before*/
408 mmte(); /*put it in table*/
409 }
410 else
411 if(itype == ITCN)
412 exitm.itrl = reloc;
413 }
1File: EXPR.C Page 8
414 exitm.itty = itype;
415 exitm.itop = ival;
416 }
417
418 /*
419 * get items for expression evaluator (pass 2)
420 * returns:
421 * item type in itype
422 * item value in ival
423 * item in it format in exitm
424 */
425 p2gi()
426 {
427 if(pitw==pnite) { /*end of statement*/
428 itype = ITSP;
429 ival = ' '; /*blank*/
430 exitm.itty = itype;
431 exitm.itop = ival;
432 return;
433 }
434
435 if((itype = pitw->itty) == ITPC) { /*vlh*/
436 pitw->itop = loctr;
437 if (p2flg || format==6) itype = pitw->itty = ITCN;
438 }
439 ival = pitw->itop; /*value*/
440 exitm.swd1 = pitw->swd1;
441 exitm.itop = ival;
442 pitw++;
443 }
444
445 /*
446 *check for a special character
447 * call with
448 * character to check
449 * returns:
450 * 0 => character is number or letter
451 */
452 ckspc(acksc)
453 {
454 register cksc;
455
456 cksc = acksc;
457 if (isalnum(cksc)) return(0);
458 return((index("_~*.@$%\'",cksc) != -1) ? 0 : 1); /*[vlh] compacted*/
459 }
460
461 /* generate new relocation for op + op*/
462 ckrl1(rv1,rv2)
463 {
464 if(rv1==rv2)
465 return(rv1);
466 if(rv1==ABS || rv2==ABS)
467 return(rv1+rv2); /*the one that is not ABS*/
468 uerr(27);
469 return(ABS);
470 }
471
472 /*generate new relocation for op - op*/
1File: EXPR.C Page 9
473 ckrl2(rv1,rv2)
474 {
475 if(rv2==EXTRN)
476 uerr(26);
477 if(rv1==rv2)
478 return(ABS);
479 if(rv2==ABS)
480 return(rv1+rv2);
481 uerr(27);
482 return(ABS);
483 }
484
485 /*generate new relocation for op /*&|<>^! op*/
486 ckrl3(rv1,rv2)
487 {
488 if(rv1!=ABS || rv2!=ABS)
489 uerr(27);
490 return(ABS);
491 }
492
493 fixext(p)
494 struct symtab *p;
495 {
496 if(extflg)
497 uerr(36); /*two externals in expr*/
498 extflg++;
499 extref = p->vl1.wd2; /*get external #*/
500 rval = EXTRN;
501 itype = ITCN;
502 ival = 0;
503 }
504
505

39
CPM OPERATING SYSTEMS/CPM 68K/1.0X SOURCES/v102/as68/list.com Normal file
View File

@@ -0,0 +1,39 @@
$ num
AS68INIT.C
AS68INIT.lis
$ num
DIR.C
DIR.lis
$ num
EXPR.C
EXPR.lis
$ num
MAIN.C
MAIN.lis
$ num
MISC.C
MISC.lis
$ num
PASS1A.C
PASS1A.lis
$ num
PASS2.C
PASS2.lis
$ num
SYMT.C
SYMT.lis
$ num
VERSION.C
VERSION.lis
$ num
AS68.H
AS68.lst
$ num
COUT.H
COUT.lst
$ num
CTYPE.H
CTYPE.lst
$ num
MACHINE.H
MACHINE.lst

10
CPM OPERATING SYSTEMS/CPM 68K/1.0X SOURCES/v102/as68/machine.11 Normal file
View File

@@ -0,0 +1,10 @@
/*
* Use this file to determine what kind of machine you want the
* Alcyon stuff to run on ....
*/
/*#define MC68000 1*/ /* 68000 version */
/*#define VAX 1*/ /* VAX Version */
#define PDP11 1 /* PDP-11 Version*/
/*#define CPM 1*/ /* CP/M Operating System*/
#define UNIX 1 /* UNIX Operating System*/
/*#define VMS 1*/ /* VMS Operating System*/

10
CPM OPERATING SYSTEMS/CPM 68K/1.0X SOURCES/v102/as68/machine.68k Normal file
View File

@@ -0,0 +1,10 @@
/*
* Use this file to determine what kind of machine you want the
* Alcyon stuff to run on ....
*/
#define MC68000 1 /* 68000 version */
/*#define VAX 1*/ /* VAX Version */
/*#define PDP11 1*/ /* PDP-11 Version*/
#define CPM 1 /* CP/M Operating System*/
/*#define UNIX 1*/ /* UNIX Operating System*/
/*#define VMS 1*/ /* VMS Operating System*/

10
CPM OPERATING SYSTEMS/CPM 68K/1.0X SOURCES/v102/as68/machine.h Normal file
View File

@@ -0,0 +1,10 @@
/*
* Use this file to determine what kind of machine you want the
* Alcyon stuff to run on ....
*/
/*#define MC68000 1*/ /* 68000 version */
#define VAX 1 /* VAX Version */
/*#define PDP11 1*/ /* PDP-11 Version*/
/*#define CPM 1*/ /* CP/M Operating System*/
/*#define UNIX 1*/ /* UNIX Operating System*/
#define VMS 1 /* VMS Operating System*/

11
CPM OPERATING SYSTEMS/CPM 68K/1.0X SOURCES/v102/as68/machine.lst Normal file
View File

@@ -0,0 +1,11 @@
1File: MACHINE.H Page 1
1 /*
2 * Use this file to determine what kind of machine you want the
3 * Alcyon stuff to run on ....
4 */
5 /*#define MC68000 1*/ /* 68000 version */
6 #define VAX 1 /* VAX Version */
7 /*#define PDP11 1*/ /* PDP-11 Version*/
8 /*#define CPM 1*/ /* CP/M Operating System*/
9 /*#define UNIX 1*/ /* UNIX Operating System*/
10 #define VMS 1 /* VMS Operating System*/

10
CPM OPERATING SYSTEMS/CPM 68K/1.0X SOURCES/v102/as68/machine.vax Normal file
View File

@@ -0,0 +1,10 @@
/*
* Use this file to determine what kind of machine you want the
* Alcyon stuff to run on ....
*/
/*#define MC68000 1*/ /* 68000 version */
#define VAX 1 /* VAX Version */
/*#define PDP11 1*/ /* PDP-11 Version*/
/*#define CPM 1*/ /* CP/M Operating System*/
/*#define UNIX 1*/ /* UNIX Operating System*/
#define VMS 1 /* VMS Operating System*/

1100
CPM OPERATING SYSTEMS/CPM 68K/1.0X SOURCES/v102/as68/main.c Normal file
View File

File diff suppressed because it is too large Load Diff

1119
CPM OPERATING SYSTEMS/CPM 68K/1.0X SOURCES/v102/as68/main.lis Normal file
View File

File diff suppressed because it is too large Load Diff

68
CPM OPERATING SYSTEMS/CPM 68K/1.0X SOURCES/v102/as68/make.sub Normal file
View File

@@ -0,0 +1,68 @@
$1stat machine.h=rw
$1pip machine.h=machine.68k
$1cp68 -i 0$1 DIR.c $1x.i
$1c068 $1x.i $1x.ic $1x.st
era $1x.i
era $1x.st
$1c168 $1x.ic DIR.s -L
$1as68 -f $1 -s 0$1 -l -u DIR.s
era dir.s
$1cp68 -i 0$1 EXPR.c $1x.i
$1c068 $1x.i $1x.ic $1x.st
era $1x.i
era $1x.st
$1c168 $1x.ic EXPR.s -L
$1as68 -f $1 -s 0$1 -l -u EXPR.s
era expr.s
$1cp68 -i 0$1 MAIN.c $1x.i
$1c068 $1x.i $1x.ic $1x.st
era $1x.i
era $1x.st
$1c168 $1x.ic MAIN.s -L
$1as68 -f $1 -s 0$1 -l -u MAIN.s
era main.s
$1cp68 -i 0$1 misc.c $1x.i
$1c068 $1x.i $1x.ic $1x.st
era $1x.i
era $1x.st
$1c168 $1x.ic MISC.s -L
$1as68 -f $1 -s 0$1 -l -u MISC.s
era misc.s
$1cp68 -i 0$1 PASS1A.c $1x.i
$1c068 $1x.i $1x.ic $1x.st
era $1x.i
era $1x.st
$1c168 $1x.ic PASS1A.s -L
$1as68 -f $1 -s 0$1 -l -u PASS1A.s
era pass1a.s
$1cp68 -i 0$1 PASS2.c $1x.i
$1c068 $1x.i $1x.ic $1x.st
era $1x.i
era $1x.st
$1c168 $1x.ic PASS2.s -L
$1as68 -f $1 -s 0$1 -l -u PASS2.s
era pass2.s
$1cp68 -i 0$1 STRNCMP.c $1x.i
$1c068 $1x.i $1x.ic $1x.st
era $1x.i
era $1x.st
$1c168 $1x.ic STRNCMP.s -L
$1as68 -f $1 -s 0$1 -l -u STRNCMP.s
era strncmp.s
$1cp68 -i 0$1 SYMT.c $1x.i
$1c068 $1x.i $1x.ic $1x.st
era $1x.i
era $1x.st
$1c168 $1x.ic SYMT.s -L
$1as68 -f $1 -s 0$1 -l -u SYMT.s
era symt.s
relink $1

1078
CPM OPERATING SYSTEMS/CPM 68K/1.0X SOURCES/v102/as68/misc.c Normal file
View File

File diff suppressed because it is too large Load Diff

1097
CPM OPERATING SYSTEMS/CPM 68K/1.0X SOURCES/v102/as68/misc.lis Normal file
View File

File diff suppressed because it is too large Load Diff

109
CPM OPERATING SYSTEMS/CPM 68K/1.0X SOURCES/v102/as68/pass1a.c Normal file
View File

@@ -0,0 +1,109 @@
/*
Copyright 1981
Alcyon Corporation
8716 Production Ave.
San Diego, Ca. 92121
*/
/* reduce long relative branches to short if possible*/
#include "as68.h"
int nitleft;
char tfilname[];
int p2gi();
long lseek();
pass1a()
{
register long reduced;
register int i, wsize;
register long oldpos,newpos; /* Old and new file seek pointers */
register j; /* temp */
pitix = itbuf;
nitleft = 0;
reduced = 0; itoffset = 0; stbuf[0].itrl = 0;
wsize = 3*sizeof stbuf[0]; /* [vlh] don't calculate many times */
close(itfn);
LASTCHTFN = itfnc;
itfn = openfi(tfilname,2,1); /*open it for update*/
while(ristb()) {
opcpt = stbuf[2].itop.ptrw2; /*ptr to opcode entry in main tab*/
if(!(opcpt->flags&OPDR)) { /*not a directive*/
format = (opcpt->flags)&OPFF;
p1inlen = stbuf[1].itrl; /*pass 1 instr length guess*/
if(((format==6 && p1inlen==4) || opcpt==jsrptr) &&
(rlflg=stbuf[3].itrl)==TEXT) {
nite = stbuf[0].itrl & 0377;/* # of it entries */
pnite = &stbuf[nite].itty; /*ptr to end of stmt*/
modelen = stbuf[2].itrl; /*instr mode length*/
opdix = ITOP1; /*first operand*/
pitw = &stbuf[ITOP1].itty; /*ptr to first operand*/
loctr = stbuf[3].itop - reduced;
expr(&p2gi);
ival =- loctr+2L;
if(itype==ITCN && !extflg && reloc!=ABS) {
if(format==9) { /*jsr*/
i = (ival>= -128 && ival<=127) ? p1inlen-2 :
(ival>= -32768 && ival<=32767) ? p1inlen-4 : 0;
if (!i)
continue;
stbuf[2].itop.ptrw2 = bsrptr; /*chng to bsr*/
}
else if(ival>= -128 && ival<=127) {
i = 2; /*[vlh]was 4 for ival=2*/
if (!ival) stbuf[2].itop.ptrw2 = nopptr;
}
else
continue;
fixsyadr(i);
reduced =+ i;
stbuf[1].itrl =- i; /*reduced somewhat*/
if(!stbuf[1].itrl)
stbuf[1].itrl = -1; /*ignore flag*/
oldpos=lseek(itfn,0L,1); /* Remember current position */
newpos= itoffset -
(stbuf[0].itrl*sizeof stbuf[0]);
if(lseek(itfn,newpos,0) < 0) {
rpterr("seek error on it file\n");
abort();
}
if(write(itfn,&stbuf[0],wsize) != wsize) {
rpterr("write error on it file\n");
abort();
}
lseek(itfn,oldpos,0);
}
}
}
else if(opcpt == endptr) {
savelc[TEXT] =- reduced;
return;
}
}
}
/* fix all symbol addresses that are text based and greater than loctr*/
/* fix means subtract 2 from them*/
fixsyadr(al)
{
register char **sx1, **sx2;
register l;
l = al;
/* loop thru symbol initial reference table*/
for(sx1= sirt; sx1<&sirt[SZIRT-1]; sx1 =+ 2) {
if(*(sx2 = sx1+1)==0) /* this chain is empty*/
continue;
/* symbols on one chain*/
sx2 = *sx2; /*first entry on this chain*/
while(1) {
if((sx2->flags&SYDF || sx2->flags&SYPC) && sx2->flags&SYRO &&
sx2->vl1 > loctr) /* [vlh] */
sx2->vl1 =- l;
if(sx2 == *sx1) /*end of chain*/
break;
sx2 = sx2->tlnk; /*next entry in chain*/
}
}
}

111
CPM OPERATING SYSTEMS/CPM 68K/1.0X SOURCES/v102/as68/pass1a.lis Normal file
View File

@@ -0,0 +1,111 @@
1File: PASS1A.C Page 1
1 /*
2 Copyright 1981
3 Alcyon Corporation
4 8716 Production Ave.
5 San Diego, Ca. 92121
6 */
7
8 /* reduce long relative branches to short if possible*/
9
10 #include "as68.h"
11 int nitleft;
12 char tfilname[];
13 int p2gi();
14 long lseek();
15 pass1a()
16 {
17 register long reduced;
18 register int i, wsize;
19 register long oldpos,newpos; /* Old and new file seek pointers */
20 register j; /* temp */
21
22 pitix = itbuf;
23 nitleft = 0;
24 reduced = 0; itoffset = 0; stbuf[0].itrl = 0;
25 wsize = 3*sizeof stbuf[0]; /* [vlh] don't calculate many times */
26 close(itfn);
27 LASTCHTFN = itfnc;
28 itfn = openfi(tfilname,2,1); /*open it for update*/
29 while(ristb()) {
30 opcpt = stbuf[2].itop.ptrw2; /*ptr to opcode entry in main tab*/
31 if(!(opcpt->flags&OPDR)) { /*not a directive*/
32 format = (opcpt->flags)&OPFF;
33 p1inlen = stbuf[1].itrl; /*pass 1 instr length guess*/
34 if(((format==6 && p1inlen==4) || opcpt==jsrptr) &&
35 (rlflg=stbuf[3].itrl)==TEXT) {
36 nite = stbuf[0].itrl & 0377;/* # of it entries */
37 pnite = &stbuf[nite].itty; /*ptr to end of stmt*/
38 modelen = stbuf[2].itrl; /*instr mode length*/
39 opdix = ITOP1; /*first operand*/
40 pitw = &stbuf[ITOP1].itty; /*ptr to first operand*/
41 loctr = stbuf[3].itop - reduced;
42 expr(&p2gi);
43 ival =- loctr+2L;
44 if(itype==ITCN && !extflg && reloc!=ABS) {
45 if(format==9) { /*jsr*/
46 i = (ival>= -128 && ival<=127) ? p1inlen-2 :
47 (ival>= -32768 && ival<=32767) ? p1inlen-4 : 0;
48 if (!i)
49 continue;
50 stbuf[2].itop.ptrw2 = bsrptr; /*chng to bsr*/
51 }
52 else if(ival>= -128 && ival<=127) {
53 i = 2; /*[vlh]was 4 for ival=2*/
54 if (!ival) stbuf[2].itop.ptrw2 = nopptr;
55 }
56 else
57 continue;
58 fixsyadr(i);
59 reduced =+ i;
1File: PASS1A.C Page 2
60 stbuf[1].itrl =- i; /*reduced somewhat*/
61 if(!stbuf[1].itrl)
62 stbuf[1].itrl = -1; /*ignore flag*/
63 oldpos=lseek(itfn,0L,1); /* Remember current position */
64 newpos= itoffset -
65 (stbuf[0].itrl*sizeof stbuf[0]);
66 if(lseek(itfn,newpos,0) < 0) {
67 rpterr("seek error on it file\n");
68 abort();
69 }
70 if(write(itfn,&stbuf[0],wsize) != wsize) {
71 rpterr("write error on it file\n");
72 abort();
73 }
74 lseek(itfn,oldpos,0);
75 }
76 }
77 }
78 else if(opcpt == endptr) {
79 savelc[TEXT] =- reduced;
80 return;
81 }
82 }
83 }
84
85 /* fix all symbol addresses that are text based and greater than loctr*/
86 /* fix means subtract 2 from them*/
87 fixsyadr(al)
88 {
89 register char **sx1, **sx2;
90 register l;
91
92 l = al;
93 /* loop thru symbol initial reference table*/
94 for(sx1= sirt; sx1<&sirt[SZIRT-1]; sx1 =+ 2) {
95 if(*(sx2 = sx1+1)==0) /* this chain is empty*/
96 continue;
97
98 /* symbols on one chain*/
99 sx2 = *sx2; /*first entry on this chain*/
100 while(1) {
101 if((sx2->flags&SYDF || sx2->flags&SYPC) && sx2->flags&SYRO &&
102 sx2->vl1 > loctr) /* [vlh] */
103 sx2->vl1 =- l;
104 if(sx2 == *sx1) /*end of chain*/
105 break;
106 sx2 = sx2->tlnk; /*next entry in chain*/
107 }
108 }
109 }

841
CPM OPERATING SYSTEMS/CPM 68K/1.0X SOURCES/v102/as68/pass2.c Normal file
View File

@@ -0,0 +1,841 @@
/*
Copyright 1981
Alcyon Corporation
8716 Production Ave.
San Diego, Ca. 92121
*/
/*
* pass two for the 68000 assembler
* Bill Allen
* March 1980
*/
#include "as68.h"
#include "cout.h" /*c.out header definition & MAGIC*/
#define MOVEA 0100
int p2gi();
extern char tfilname[]; /*name of it file*/
extern char initfnam[]; /*name of the initilization file*/
int (*p2direct[])();
int opf1(), opf2(), opf3(), opf4(), opf5(), relbr(), opf7(), opf8();
int opf9(), opf11(), opf12(), opf13(), opf15(), opf17(), opf20();
int opf21(), opf22(), opf23();
int (*opfary[])() {
0, /*0*/
opf1, /*1*/
opf2, /*2*/
opf3, /*3*/
opf4, /*4*/
opf5, /*5*/
relbr, /*6*/
opf7, /*7*/
opf8, /*8*/
opf9, /*9*/
opf4, /*10*/
opf11, /*11*/
opf12, /*12*/
opf13, /*13*/
opf9, /*14*/
opf15, /*15*/
opf17, /*16*/
opf17, /*17*/
opf13, /*18*/
opf11, /*19*/
opf20, /*20*/
opf21, /*21*/
opf22, /*22*/
opf23, /*23*/
opf9, /*24*/
opf9, /*25*/
opf5, /*26*/ /* [vlh] cmp, chk, extention verification */
opf4, /*27*/ /* [vlh] addx, subx, extension verification */
opf13, /*28*/ /* [vlh] swap, extension verification */
opf9, /*29*/ /* [vlh] pea, extention verification */
opf15 /*30*/ /* [vlh] lea, extension verification */
};
#define LSTFRMT 30
int f1mode[] {0,0,0100,0,0200};
int f2mode[] {0,0,0100,0,0200};
int f3mode[] {0,010000,030000,0,020000};
int f15mode[] {0,0,0300,0,0700};
int f5mode[] {0,0,0100,0,0200};
int f5amode[] {0,0,0300,0,0700};
int f13mode[] {0,0,0200,0,0300};
int f23mode[] {0,0400,0500,0,0600};
int rlbits[5]; /*holds relocation bits for instr*/
int pline; /*number of last printed line*/
int brkln2 077777; /*pass 2 break line number for debugging*/
int prsp; /*special print alignment flag*/
int amode; /*addressing mode*/
int nitleft;
/*pass two driver*/
pass2()
{
register short *p;
register i;
register (*dirop)();
pitix = itbuf; /* This is init for doitrd*/
xline = LPP;
nitleft = 0;
lbuf.nunused = tbuf.nunused = dabuf.nunused = drbuf.nunused = 512;
lbuf.fildes = lfn; /*set buffered io for binary file*/
lbuf.xfree = &lbuf.buff[0];
tbuf.fildes = trbfn; /*set buffered io for text reloc bits file*/
tbuf.xfree = &tbuf.buff[0];
dabuf.fildes = dafn; /*set buffered io for data bytes*/
dabuf.xfree = &dabuf.buff[0];
drbuf.fildes = drbfn; /*set buffered io for data reloc bits*/
drbuf.xfree = &drbuf.buff[0];
couthd.ch_magic = MAGIC;/*c.out magic number*/
if(savelc[TEXT]&1)
savelc[TEXT]++; /*make it even*/
couthd.ch_tsize = savelc[TEXT]; /*text size*/
if(savelc[DATA]&1)
savelc[DATA]++; /*make it even*/
couthd.ch_dsize = savelc[DATA]; /*data size*/
couthd.ch_bsize = savelc[BSS]; /*bss size*/
/*symbol table size is not known now -- it is set at end of pass 2*/
/* entry point and stack size are zero for now*/
p = &couthd;
for(i=0; i<HDSIZE/2; i++) {
putw(*p++,&lbuf); /*write the file header words*/
}
savelc[0] = 0; savelc[1] = 0; savelc[2] = 0; savelc[3] = 0;
loctr = 0; /*location counter*/
rlflg = TEXT; /*TEXT relocatable*/
p2flg = 1; /*pass two*/
#ifdef UNIX
if (lseek(ifn,0L,0) == -1) { /*beginning of source*/
rpterr("seek error on source file\n");
abort();
}
#else
close(ifn); /* This way for goddamn Whitesmith's */
ifn=open(sfname,0,0); /* Re-open the fucking source file */
if(ifn < 0) /* Couldn't */
{
printf("Unable to open file %s\n",sfname);
abort();
}
#endif
close(itfn);
LASTCHTFN = itfnc;
itfn = openfi(tfilname,0); /*open it for reading*/
pline = 1; /*no lines printed*/
fchr=gchr(); /*get first char*/
while(ristb()) { /*pass 2 main loop*/
p2absln = stbuf[0].itop; /*line number*/
if(p2absln>=brkln2) /*for debugging the assembler*/
i=0;
opcpt = stbuf[2].itop.ptrw2; /*ptr to opcode entry in main tab*/
nite = stbuf[0].itrl & 0377; /*number of it entries*/
pnite = &stbuf[nite]; /*ptr to end of stmt*/
modelen = stbuf[2].itrl; /*instr mode length*/
p1inlen = stbuf[1].itrl; /*pass 1 instr length guess*/
opdix = ITOP1; /*first operand*/
pitw = &stbuf[ITOP1]; /*ptr to first operand*/
prsp = 0; /*special print flag off*/
instrlen = 2; /*default for print*/
if(opcpt->flags&OPDR) { /*opcode is a directive*/
i = opcpt->vl1; /*directive number*/
dirop = p2direct[i];
(*dirop)(); /*handle directive*/
}
else {
gcist(); /*generate code for one statement*/
}
}
}
/* generate code for an instruction*/
/* call with*/
/* intermediate text for instruction in stbuf*/
gcist()
{
register i,j;
if(stbuf[0].itty != ITBS) /*beginning of statement*/
abort();
format = (opcpt->flags)&OPFF;
in_err = 0; /*[vlh] no error this instruction, yet*/
ival = 0; /*initial value for possible operand*/
reloc = ABS;
instrlen = 2; /*at least 2 bytes*/
ins[0] = opcpt->vl1; /*opcode value*/
rlbits[0] = INSABS; /*instruction absolute*/
pins = &ins[1];
prlb = &rlbits[1];
if(nite>ITOP1) { /*operands*/
if(!format) {
uerr(9);
}
else if(format>LSTFRMT) /* [vlh] was a magic number... */
abort();
else {
(*opfary[format])();
}
}
if (!ckein() && !in_err) /* at end of statement ?? */
uerr(6);
print(1); /*print source*/
loctr =+ p1inlen;
if (!in_err && p1inlen != instrlen) /* [vlh] 2nd pass error recovery */
uerr(38);
outinstr(); /*write out instr binary*/
}
/* relative branches*/
relbr()
{
expr(&p2gi);
if(extflg) { /*external reference*/
instrlen =+ 2; /*long relative*/
*pins++ = ival; /*pass constant part*/
*prlb++ = (extref<<3)|EXTREL; /*ext ref*/
return;
}
ival =- (loctr+2); /*calc relative offset*/
if(itype!=ITCN || reloc != rlflg) {
uerr(22); /*invalid relative branch*/
ival = 0;
}
reloc = ABS;
if(p1inlen==4) { /*long displacement*/
if(ival< (-32768L) || ival > (32767L))
uerr(22);
instrlen =+ 2;
*pins++ = ival;
*prlb++ = DABS; /*data absolute*/
}
else { /*short displacement*/
if (ival>127 || ival<-128)
uerr(22);
ins[0] =| (ival.wd2&0377);
}
if (!ival) { /* make it a nop */
opcpt = nopptr;
ins[0] = opcpt->vl1.wd2;
pins = &ins[1];
if (modelen==4) {
*pins++ = opcpt->vl1.wd2;
rlbits[1] = INSABS;
}
}
in_err++; /* ignore extra eg. bra *+$d04(pc) vs. bra *+d04 */
}
/* format one -- add, sub, and, or, cmp, etc.*/
/* one operand must be a D reg (or A reg dest for add, sub, or cmp)*/
opf1()
{
register int *p;
if(get2ops())
return;
if (ins[0]==AND || ins[0]==OR)
if (cksprg(&opnd[1],CCR) || cksprg(&opnd[1],SR)) {
if (ins[0]==AND) opcpt = andiptr;
else opcpt = oriptr;
ins[0] = opcpt->vl1.wd2;
format = (opcpt->flags)&OPFF;
ccr_or_sr();
return;
}
p = f1mode;
if(ckdreg(&opnd[1])) { /*destn is D reg*/
if((opcpt==andptr||opcpt==orptr)&&ckareg(&opnd[0])) /*A source*/
uerr(20);
makef1(opnd[1].ea,p[modelen],&opnd[0]); /*make instr*/
return;
}
else if(ckdreg(&opnd[0]) && memalt(&opnd[1])) { /*source is D reg*/
if (pcea(&opnd[1])) uerr(10);
makef1(opnd[0].ea,p[modelen]+0400,&opnd[1]);
return;
}
else if(ckareg(&opnd[1])) { /*A reg is dstn*/
if(opcpt==addptr)
opcpt = addaptr;
else if(opcpt==cmpptr)
opcpt = cmpaptr;
else if(opcpt==subptr)
opcpt = subaptr;
else {
uerr(20);
return;
}
format = (opcpt->flags)&OPFF;
opnd[1].ea =& 07;
p = f15mode;
makef1(opnd[1].ea,p[modelen],&opnd[0]); /*make instr*/
return;
}
else if(!makeimm()) /*make an immediate instr*/
uerr(20);
}
/* format 2 -- addi, andi, subi, etc*/
opf2()
{
if(get2ops())
return;
if(ins[0]==ANDI || ins[0]==ORI || ins[0]==EORI) {
if(cksprg(&opnd[1],CCR) || cksprg(&opnd[1],SR)) {
ccr_or_sr();
return;
}
}
if(opnd[0].ea != IMM) {
uerr(9);
return;
}
if(!dataalt(&opnd[1]) || pcea(&opnd[1])) {
uerr(20);
return;
}
genimm();
}
/*format #3 -- move and movea*/
opf3()
{
register i,j,k;
if(get2ops())
return;
if(cksprg(&opnd[1],CCR)) {
ins[0] = MOVECCR;
opf3l1:
if (modelen==1 || modelen==4) uerr(34);
if(anysprg(&opnd[0]))
uerr(20);
ins[0] =| opnd[0].ea;
if(!dataea(&opnd[0]))
uerr(9);
doea(&opnd[0]);
return;
}
if(cksprg(&opnd[1],SR)) {
ins[0] = MOVESR;
goto opf3l1;
}
if(cksprg(&opnd[0],SR)) {
if (modelen==1 || modelen==4)
uerr(34);
if(anysprg(&opnd[1]))
uerr(20);
ins[0] = SRMOVE | opnd[1].ea;
if(!dataalt(&opnd[1]) || pcea(&opnd[1]))
uerr(10);
doea(&opnd[1]);
return;
}
if(cksprg(&opnd[0],USP)) {
if (modelen == 1)
uerr(34); /* default is word, can't test */
if (!ckareg(&opnd[1]))
uerr(33);
ins[0] = MOVEUSP|8|(opnd[1].ea&7);
return;
}
if(cksprg(&opnd[1],USP)) {
if (modelen == 1)
uerr(34); /* default is word, can't test */
if (!ckareg(&opnd[0]))
uerr(33);
ins[0] = MOVEUSP|(opnd[0].ea&7);
return;
}
k = ins[0];
ins[0] =| f3mode[modelen];
ckbytea();
ins[0] =| opnd[0].ea; /*source ea*/
doea(&opnd[0]);
ins[0] =| (opnd[1].ea&7)<<9; /*dest register*/
ins[0] =| (opnd[1].ea&070)<<3; /*dest mode*/
doea(&opnd[1]);
if(k==MOVEA) {
if(dataea(&opnd[1]))
uerr(20);
}
else if((pcea(&opnd[1]) && dataea(&opnd[1])) || opnd[1].ea==IMM)
uerr(20);
}
/* format 4 -- abcd, sbcd */
/* format 10 -- cmpm*/
/* format 27 -- addx, subx */
opf4()
{
if(get2ops())
return;
if (format==27) { /*addx,subx add in size bits*/
ins[0] =| f1mode[modelen];
}
else if(format==10) { /*cmpm*/
if((opnd[0].ea&070)!=INDINC || (opnd[1].ea&070)!=INDINC)
uerr(20);
ins[0] =| f1mode[modelen] | ((opnd[0].ea&7)|((opnd[1].ea&7)<<9));
return;
}
if(ckdreg(&opnd[0]) && ckdreg(&opnd[1])) {
ins[0] =| ((opnd[0].ea&7)|((opnd[1].ea&7)<<9));
return;
}
if((opnd[0].ea&070)==DECIND && (opnd[1].ea&070)==DECIND) {
ins[0] =| 010 | ((opnd[0].ea&7)|((opnd[1].ea&7)<<9));
return;
}
uerr(20);
}
/*format 5 -- div, mul*/
/*format 26 -- cmp, chk */
opf5()
{
if(get2ops())
return;
if(!ckdreg(&opnd[1])) {
if(opcpt==cmpptr) {
if(!dataea(&opnd[1])) /* [vlh] made define */
ins[0] =| f5amode[modelen]; /* was pumode */
else if(makeimm())
return;
else
uerr(20);
}
else
uerr(20);
}
if(opcpt==cmpptr) {
ins[0] =| f5mode[modelen]; /* was pumode */
ckbytea();
}
else if(!dataea(&opnd[0]))
uerr(20);
ins[0] =| (opnd[1].ea&7)<<9 | opnd[0].ea;
doea(&opnd[0]);
}
#define BTST 0000
/* format 7 -- bit instrs -- btst, bclr, bset, etc*/
opf7()
{
if(get2ops())
return;
if(opnd[1].ea==IMM||(ins[0]!=BTST&&pcea(&opnd[1]))||ckareg(&opnd[1]))
uerr(20);
if(ckdreg(&opnd[0])) {
ins[0] =| (opnd[0].ea<<9)|0400;
}
else { /*static bit #*/
if(opnd[0].con<0L || opnd[0].con>31 ||
(opnd[1].ea&INDIRECT&&opnd[0].con>7)) /* [vlh] */
uerr(23);
if(opnd[0].ea != IMM)
uerr(17);
ins[0] =| 04000;
dodisp(&opnd[0]);
}
if (modelen==1 && !(memea(&opnd[1]))) /*[vlh]*/
uerr(20);
else if (!(ckdreg(&opnd[1])) && modelen==4)
uerr(20);
ins[0] =| opnd[1].ea;
doea(&opnd[1]);
}
/* format 8 -- shifts and rotates*/
opf8()
{
register i;
getea(0); /*get first operand*/
if(pitw >= pnite) { /*end of all ops*/
if(ckdreg(&opnd[0])) { /*shift dreg one bit*/
cpop01(); /*copy opnd 0 to 1*/
opnd[0].ea = IMM;
opnd[0].con = 1L;
if (!ckdreg(&opnd[1])) uerr(20);
opf8l1:
if(opnd[0].con<1 || opnd[0].con>8) /*[vlh legal range 1..8*/
uerr(37);
ins[0] =| ((opnd[0].con.wd2&7)<<9)|f1mode[modelen]|opnd[1].ea;
return;
}
i = (ins[0]&077)<<6;
ins[0] =& 0177700;
ins[0] =| 0300|i|opnd[0].ea;
if(!memalt(&opnd[0]) || pcea(&opnd[0]) || modelen != 2)
uerr(20);
doea(&opnd[0]);
return;
}
if(!ckcomma()) {
uerr(10);
return;
}
getea(1); /*get second operand*/
if(!ckdreg(&opnd[1])) /* [vlh] second operand must be dreg */
uerr(20);
if(ckdreg(&opnd[0])) { /*first op is D reg*/
ins[0] =| (opnd[0].ea<<9)|040; /*reg # and reg bit*/
}
else {
if(opnd[0].ea != IMM)
uerr(20);
goto opf8l1;
}
ins[0] =| f1mode[modelen] | opnd[1].ea; /*put in size and reg #*/
}
/* format 9 -- jmp, jsr */
/* format 14 -- stop */
/* format 24 -- clr, neg, negx, not */
/* format 25 -- s?? */
/* format 29 -- pea */
/* one operand instructions -- jmp, clr, neg, not, sge, etc.*/
opf9()
{
getea(0);
if(format==24) { /*clr, not, etc*/
ins[0] =| f1mode[modelen]; /*add size bits*/
if(!dataalt(&opnd[0]) || pcea(&opnd[0]))
uerr(20);
}
else if(format==25) { /*tas,scc, etc*/
if(ckareg(&opnd[0]) || pcea(&opnd[0]) || opnd[0].ea==IMM)
uerr(20);
}
else if(format==14) { /*stop*/
if(modelen!=2 || opnd[0].ea!=IMM)
uerr(20);
doea(&opnd[0]);
return;
}
else if(!controlea(&opnd[0])) /*jmp, jsr, etc*/
uerr(20);
ins[0] =| opnd[0].ea;
doea(&opnd[0]);
}
/* format 11 -- dbcc*/
/* format 19 -- link*/
opf11()
{
if(get2ops())
return;
if(format==19) { /*link*/
if(!ckareg(&opnd[0]))
uerr(33);
if(opnd[1].ea != IMM)
uerr(17);
}
else {
if(!ckdreg(&opnd[0]))
uerr(33);
if(opnd[1].drlc!=rlflg) /*[vlh]don't chk opnd[1].ea!=LADDR||SADDR*/
uerr(22);
opnd[1].con =- (loctr+2L);
cksize(&opnd[1]);
opnd[1].drlc = ABS; /*not relocatable*/
}
ins[0] =| opnd[0].ea&7; /*put in reg #*/
dodisp(&opnd[1]);
}
/* format 12 -- exg*/
opf12()
{
register i;
if(get2ops())
return;
if(ckdreg(&opnd[0])) {
if(ckdreg(&opnd[1])) { /*exchange D regs*/
ins[0] =| 0100 | ((opnd[0].ea&7)<<9) | (opnd[1].ea&7);
return;
}
if(ckareg(&opnd[1])) { /*ins[0] <- A and D flag*/
ins[0] =| 0210 | ((opnd[0].ea&7)<<9) | (opnd[1].ea&7);
return;
}
}
if(ckareg(&opnd[0])) {
if(ckareg(&opnd[1])) { /*both a regs*/
ins[0] =| 0110 | ((opnd[0].ea&7)<<9) | (opnd[1].ea&7);
return;
}
if(ckdreg(&opnd[1])) { /*A and D regs*/
i = opnd[0].ea; /*exchg ea's*/
opnd[0].ea = opnd[1].ea;
opnd[1].ea = i;
ins[0] =| 0210 | ((opnd[0].ea&7)<<9) | (opnd[1].ea&7);
return;
}
}
uerr(20);
}
/* format 13 -- ext, unlk*/
/* format 18 -- trap*/
/* format 28 -- swap */
#define UNLK 047130
opf13()
{
getea(0);
if(format==18) { /*trap*/
if(opnd[0].con<0 || opnd[0].con>15)
uerr(15);
ins[0] =| opnd[0].con.wd2;
return;
}
if(ins[0]==UNLK) { /*unlk instr*/
if(!ckareg(&opnd[0]))
uerr(20);
}
else {
if(!ckdreg(&opnd[0]))
uerr(20);
if (format==13) /* ext */
ins[0] =| f13mode[modelen];
}
ins[0] =| opnd[0].ea&7;
}
/* format 15 -- adda, cmpa, suba*/
/* format 30 -- lea */
opf15()
{
register i;
if(get2ops())
return;
if(!ckareg(&opnd[1]))
uerr(33);
if(format==30) {
i = 0700;
if(!controlea(&opnd[0]))
uerr(20);
}
else
i = f15mode[modelen];
makef1(opnd[1].ea&7,i,&opnd[0]);
if (format==15 && opnd[0].ea != 071) cksize(&opnd[0]);
}
/*formats 16 and 17 -- addq, inc, subq, dec*/
opf17()
{
if(format==16) { /*inc or dec*/
clrea(&opnd[0]);
opnd[0].ea = IMM;
opnd[0].con = 1L;
opnd[0].drlc = ABS;
getea(1);
}
else {
if(get2ops())
return;
}
if(opnd[0].ea != IMM || !altea(&opnd[1]) || pcea(&opnd[1]))
uerr(20);
if(opnd[0].con<=0 || opnd[0].con>8)
uerr(15);
if(modelen==1 && !dataea(&opnd[1]))
uerr(34);
ins[0] =| f1mode[modelen]|((opnd[0].con.wd2&7)<<9)|opnd[1].ea;
doea(&opnd[1]);
}
/* format 20 -- movem */
int regmsk0[] {0100000,040000,020000,010000,04000,02000,01000,0400,0200,
0100,040,020,010,4,2,1};
int regmsk1[] {1,2,4,010,020,040,0100,0200,0400,01000,02000,04000,010000,
020000,040000,0100000};
opf20()
{
register dr;
register i,j;
dr = 0;
if(getreg() != -1 || pitw->itty == ITRM) { /*regs to memory*/
if (pitw->itty != ITRM) { /* [vlh] */
pitw--;
j = getrlist(regmsk0);
}
else {
j = pitw->itop;
pitw++;
}
if(!ckcomma())
uerr(10);
}
else
dr = 02000;
getea(0);
if(dr) {
if(!ckcomma())
uerr(10);
if (pitw->itty != ITRM) /* [vlh] */
j = getrlist(regmsk1); /*mem to regs*/
else {
j = pitw->itop;
j = fixmask(j);
pitw++;
}
}
else {
if(controlea(&opnd[0]))
j = fixmask(j);
}
i = opnd[0].ea&070;
if(!controlea(&opnd[0]) && i!=INDINC && i!=DECIND)
uerr(20);
if(modelen==4) /*long*/
ins[0] =| 0100;
ins[0] =| opnd[0].ea|dr;
*pins++ = j; /*reg mask*/
*prlb++ = DABS;
instrlen =+ 2;
doea(&opnd[0]);
if (!dr) { /* 1st argument (2nd is reg list) */
if (pcea(&opnd[0]) || (opnd[0].ea&070)==INDINC)
uerr(20); /* xx(pc), xx(pc,dx), -(ax) */
}
else /* 2nd argument (1st is reg list) */
if ((opnd[0].ea&070)==DECIND)
uerr(20); /* (ax)+ */
}
/*
* get a list of registers for the movem instr
* call with:
* ptr to reg-to-mem or mem-to-reg array of bits
*/
getrlist(ap)
int *ap;
{
register int *p,i,j;
register int mask;
p = ap;
mask = 0;
while((i=getreg()) != -1) {
if(ckitc(pitw,'-')) {
pitw++;
if((j=getreg()) == -1) {
uerr(40);
break;
}
while(i<=j)
mask =| p[i++];
}
else
mask =| p[i];
if(ckitc(pitw,'/'))
pitw++;
else
break;
}
if(!mask)
uerr(40);
return(mask);
}
/*reverse a movem register mask for control ea to memory*/
fixmask(msk)
{
register i,j,k;
k = (msk&1) ? 0100000 : 0;
i = 2;
j = 040000;
while(i) {
if(msk&i)
k =| j;
i =<< 1;
j =>> 1;
}
return(k);
}
/* format 21 -- movep*/
opf21()
{
register m,d;
register char *p;
if(get2ops())
return;
if(ckdreg(&opnd[0])) { /*d reg source*/
m = 0600;
d = opnd[0].ea;
p = &opnd[1];
}
else if(ckdreg(&opnd[1])) { /*d reg dest*/
m = 0400;
d = opnd[1].ea;
p = &opnd[0];
}
else {
uerr(20);
}
if((p->ea&070) != INDDISP)
uerr(20);
if(modelen == 4)
m =| 0100;
ins[0] =| (d<<9)|m|(p->ea&7);
*pins++ = p->con.wd2;
*prlb++ = p->drlc;
instrlen =+ 2;
}
/* format 22 -- moveq*/
opf22()
{
if(get2ops())
return;
if(opnd[0].ea != IMM)
uerr(17);
if(opnd[0].con>255L || opnd[0].con<-256L)
uerr(15);
if(!ckdreg(&opnd[1]))
uerr(33);
ins[0] =| (opnd[1].ea<<9) | (opnd[0].con.wd2&0377);
}
/* format 23 -- eor*/
opf23()
{
if(get2ops())
return;
if (cksprg(&opnd[1],CCR) || cksprg(&opnd[1],SR)) {
opcpt = eoriptr;
ins[0] = opcpt->vl1.wd2;
format = (opcpt->flags)&OPFF;
ccr_or_sr();
return;
}
if(!ckdreg(&opnd[0])) {
if(makeimm()) /*must be immediate*/
return;
uerr(20); /*or error*/
}
if(!dataalt(&opnd[1]) || pcea(&opnd[1]))
uerr(20);
ins[0] =| (opnd[0].ea<<9)|f23mode[modelen]|opnd[1].ea;
doea(&opnd[1]);
}

856
CPM OPERATING SYSTEMS/CPM 68K/1.0X SOURCES/v102/as68/pass2.lis Normal file
View File

@@ -0,0 +1,856 @@
1File: PASS2.C Page 1
1 /*
2 Copyright 1981
3 Alcyon Corporation
4 8716 Production Ave.
5 San Diego, Ca. 92121
6 */
7
8 /*
9 * pass two for the 68000 assembler
10 * Bill Allen
11 * March 1980
12 */
13
14 #include "as68.h"
15 #include "cout.h" /*c.out header definition & MAGIC*/
16
17 #define MOVEA 0100
18
19 int p2gi();
20
21 extern char tfilname[]; /*name of it file*/
22 extern char initfnam[]; /*name of the initilization file*/
23 int (*p2direct[])();
24
25 int opf1(), opf2(), opf3(), opf4(), opf5(), relbr(), opf7(), opf8();
26 int opf9(), opf11(), opf12(), opf13(), opf15(), opf17(), opf20();
27 int opf21(), opf22(), opf23();
28
29 int (*opfary[])() {
30 0, /*0*/
31 opf1, /*1*/
32 opf2, /*2*/
33 opf3, /*3*/
34 opf4, /*4*/
35 opf5, /*5*/
36 relbr, /*6*/
37 opf7, /*7*/
38 opf8, /*8*/
39 opf9, /*9*/
40 opf4, /*10*/
41 opf11, /*11*/
42 opf12, /*12*/
43 opf13, /*13*/
44 opf9, /*14*/
45 opf15, /*15*/
46 opf17, /*16*/
47 opf17, /*17*/
48 opf13, /*18*/
49 opf11, /*19*/
50 opf20, /*20*/
51 opf21, /*21*/
52 opf22, /*22*/
53 opf23, /*23*/
54 opf9, /*24*/
55 opf9, /*25*/
56 opf5, /*26*/ /* [vlh] cmp, chk, extention verification */
57 opf4, /*27*/ /* [vlh] addx, subx, extension verification */
58 opf13, /*28*/ /* [vlh] swap, extension verification */
59 opf9, /*29*/ /* [vlh] pea, extention verification */
1File: PASS2.C Page 2
60 opf15 /*30*/ /* [vlh] lea, extension verification */
61 };
62
63 #define LSTFRMT 30
64
65 int f1mode[] {0,0,0100,0,0200};
66 int f2mode[] {0,0,0100,0,0200};
67 int f3mode[] {0,010000,030000,0,020000};
68 int f15mode[] {0,0,0300,0,0700};
69 int f5mode[] {0,0,0100,0,0200};
70 int f5amode[] {0,0,0300,0,0700};
71 int f13mode[] {0,0,0200,0,0300};
72 int f23mode[] {0,0400,0500,0,0600};
73 int rlbits[5]; /*holds relocation bits for instr*/
74 int pline; /*number of last printed line*/
75 int brkln2 077777; /*pass 2 break line number for debugging*/
76 int prsp; /*special print alignment flag*/
77 int amode; /*addressing mode*/
78 int nitleft;
79 /*pass two driver*/
80 pass2()
81 {
82 register short *p;
83 register i;
84 register (*dirop)();
85
86 pitix = itbuf; /* This is init for doitrd*/
87 xline = LPP;
88 nitleft = 0;
89 lbuf.nunused = tbuf.nunused = dabuf.nunused = drbuf.nunused = 512;
90 lbuf.fildes = lfn; /*set buffered io for binary file*/
91 lbuf.xfree = &lbuf.buff[0];
92 tbuf.fildes = trbfn; /*set buffered io for text reloc bits file*/
93 tbuf.xfree = &tbuf.buff[0];
94 dabuf.fildes = dafn; /*set buffered io for data bytes*/
95 dabuf.xfree = &dabuf.buff[0];
96 drbuf.fildes = drbfn; /*set buffered io for data reloc bits*/
97 drbuf.xfree = &drbuf.buff[0];
98 couthd.ch_magic = MAGIC;/*c.out magic number*/
99 if(savelc[TEXT]&1)
100 savelc[TEXT]++; /*make it even*/
101 couthd.ch_tsize = savelc[TEXT]; /*text size*/
102 if(savelc[DATA]&1)
103 savelc[DATA]++; /*make it even*/
104 couthd.ch_dsize = savelc[DATA]; /*data size*/
105 couthd.ch_bsize = savelc[BSS]; /*bss size*/
106 /*symbol table size is not known now -- it is set at end of pass 2*/
107 /* entry point and stack size are zero for now*/
108 p = &couthd;
109 for(i=0; i<HDSIZE/2; i++) {
110 putw(*p++,&lbuf); /*write the file header words*/
111 }
112 savelc[0] = 0; savelc[1] = 0; savelc[2] = 0; savelc[3] = 0;
113 loctr = 0; /*location counter*/
114 rlflg = TEXT; /*TEXT relocatable*/
115 p2flg = 1; /*pass two*/
116 #ifdef UNIX
117 if (lseek(ifn,0L,0) == -1) { /*beginning of source*/
118 rpterr("seek error on source file\n");
1File: PASS2.C Page 3
119 abort();
120 }
121 #else
122 close(ifn); /* This way for goddamn Whitesmith's */
123 ifn=open(sfname,0,0); /* Re-open the fucking source file */
124 if(ifn < 0) /* Couldn't */
125 {
126 printf("Unable to open file %s\n",sfname);
127 abort();
128 }
129 #endif
130 close(itfn);
131 LASTCHTFN = itfnc;
132 itfn = openfi(tfilname,0); /*open it for reading*/
133 pline = 1; /*no lines printed*/
134 fchr=gchr(); /*get first char*/
135 while(ristb()) { /*pass 2 main loop*/
136 p2absln = stbuf[0].itop; /*line number*/
137 if(p2absln>=brkln2) /*for debugging the assembler*/
138 i=0;
139 opcpt = stbuf[2].itop.ptrw2; /*ptr to opcode entry in main tab*/
140 nite = stbuf[0].itrl & 0377; /*number of it entries*/
141 pnite = &stbuf[nite]; /*ptr to end of stmt*/
142 modelen = stbuf[2].itrl; /*instr mode length*/
143 p1inlen = stbuf[1].itrl; /*pass 1 instr length guess*/
144 opdix = ITOP1; /*first operand*/
145 pitw = &stbuf[ITOP1]; /*ptr to first operand*/
146 prsp = 0; /*special print flag off*/
147 instrlen = 2; /*default for print*/
148 if(opcpt->flags&OPDR) { /*opcode is a directive*/
149 i = opcpt->vl1; /*directive number*/
150 dirop = p2direct[i];
151 (*dirop)(); /*handle directive*/
152 }
153 else {
154 gcist(); /*generate code for one statement*/
155 }
156 }
157 }
158
159 /* generate code for an instruction*/
160 /* call with*/
161 /* intermediate text for instruction in stbuf*/
162 gcist()
163 {
164 register i,j;
165
166 if(stbuf[0].itty != ITBS) /*beginning of statement*/
167 abort();
168 format = (opcpt->flags)&OPFF;
169 in_err = 0; /*[vlh] no error this instruction, yet*/
170 ival = 0; /*initial value for possible operand*/
171 reloc = ABS;
172 instrlen = 2; /*at least 2 bytes*/
173 ins[0] = opcpt->vl1; /*opcode value*/
174 rlbits[0] = INSABS; /*instruction absolute*/
175 pins = &ins[1];
176 prlb = &rlbits[1];
177 if(nite>ITOP1) { /*operands*/
1File: PASS2.C Page 4
178 if(!format) {
179 uerr(9);
180 }
181 else if(format>LSTFRMT) /* [vlh] was a magic number... */
182 abort();
183 else {
184 (*opfary[format])();
185 }
186 }
187 if (!ckein() && !in_err) /* at end of statement ?? */
188 uerr(6);
189 print(1); /*print source*/
190
191 loctr =+ p1inlen;
192 if (!in_err && p1inlen != instrlen) /* [vlh] 2nd pass error recovery */
193 uerr(38);
194 outinstr(); /*write out instr binary*/
195 }
196
197 /* relative branches*/
198 relbr()
199 {
200 expr(&p2gi);
201 if(extflg) { /*external reference*/
202 instrlen =+ 2; /*long relative*/
203 *pins++ = ival; /*pass constant part*/
204 *prlb++ = (extref<<3)|EXTREL; /*ext ref*/
205 return;
206 }
207 ival =- (loctr+2); /*calc relative offset*/
208 if(itype!=ITCN || reloc != rlflg) {
209 uerr(22); /*invalid relative branch*/
210 ival = 0;
211 }
212 reloc = ABS;
213 if(p1inlen==4) { /*long displacement*/
214 if(ival< (-32768L) || ival > (32767L))
215 uerr(22);
216 instrlen =+ 2;
217 *pins++ = ival;
218 *prlb++ = DABS; /*data absolute*/
219 }
220 else { /*short displacement*/
221 if (ival>127 || ival<-128)
222 uerr(22);
223 ins[0] =| (ival.wd2&0377);
224 }
225 if (!ival) { /* make it a nop */
226 opcpt = nopptr;
227 ins[0] = opcpt->vl1.wd2;
228 pins = &ins[1];
229 if (modelen==4) {
230 *pins++ = opcpt->vl1.wd2;
231 rlbits[1] = INSABS;
232 }
233 }
234 in_err++; /* ignore extra eg. bra *+$d04(pc) vs. bra *+d04 */
235 }
236
1File: PASS2.C Page 5
237 /* format one -- add, sub, and, or, cmp, etc.*/
238 /* one operand must be a D reg (or A reg dest for add, sub, or cmp)*/
239 opf1()
240 {
241 register int *p;
242
243 if(get2ops())
244 return;
245 if (ins[0]==AND || ins[0]==OR)
246 if (cksprg(&opnd[1],CCR) || cksprg(&opnd[1],SR)) {
247 if (ins[0]==AND) opcpt = andiptr;
248 else opcpt = oriptr;
249 ins[0] = opcpt->vl1.wd2;
250 format = (opcpt->flags)&OPFF;
251 ccr_or_sr();
252 return;
253 }
254 p = f1mode;
255 if(ckdreg(&opnd[1])) { /*destn is D reg*/
256 if((opcpt==andptr||opcpt==orptr)&&ckareg(&opnd[0])) /*A source*/
257 uerr(20);
258 makef1(opnd[1].ea,p[modelen],&opnd[0]); /*make instr*/
259 return;
260 }
261 else if(ckdreg(&opnd[0]) && memalt(&opnd[1])) { /*source is D reg*/
262 if (pcea(&opnd[1])) uerr(10);
263 makef1(opnd[0].ea,p[modelen]+0400,&opnd[1]);
264 return;
265 }
266 else if(ckareg(&opnd[1])) { /*A reg is dstn*/
267 if(opcpt==addptr)
268 opcpt = addaptr;
269 else if(opcpt==cmpptr)
270 opcpt = cmpaptr;
271 else if(opcpt==subptr)
272 opcpt = subaptr;
273 else {
274 uerr(20);
275 return;
276 }
277 format = (opcpt->flags)&OPFF;
278 opnd[1].ea =& 07;
279 p = f15mode;
280 makef1(opnd[1].ea,p[modelen],&opnd[0]); /*make instr*/
281 return;
282 }
283 else if(!makeimm()) /*make an immediate instr*/
284 uerr(20);
285 }
286
287 /* format 2 -- addi, andi, subi, etc*/
288 opf2()
289 {
290 if(get2ops())
291 return;
292 if(ins[0]==ANDI || ins[0]==ORI || ins[0]==EORI) {
293 if(cksprg(&opnd[1],CCR) || cksprg(&opnd[1],SR)) {
294 ccr_or_sr();
295 return;
1File: PASS2.C Page 6
296 }
297 }
298 if(opnd[0].ea != IMM) {
299 uerr(9);
300 return;
301 }
302 if(!dataalt(&opnd[1]) || pcea(&opnd[1])) {
303 uerr(20);
304 return;
305 }
306 genimm();
307 }
308
309 /*format #3 -- move and movea*/
310 opf3()
311 {
312 register i,j,k;
313
314 if(get2ops())
315 return;
316 if(cksprg(&opnd[1],CCR)) {
317 ins[0] = MOVECCR;
318 opf3l1:
319 if (modelen==1 || modelen==4) uerr(34);
320 if(anysprg(&opnd[0]))
321 uerr(20);
322 ins[0] =| opnd[0].ea;
323 if(!dataea(&opnd[0]))
324 uerr(9);
325 doea(&opnd[0]);
326 return;
327 }
328 if(cksprg(&opnd[1],SR)) {
329 ins[0] = MOVESR;
330 goto opf3l1;
331 }
332 if(cksprg(&opnd[0],SR)) {
333 if (modelen==1 || modelen==4)
334 uerr(34);
335 if(anysprg(&opnd[1]))
336 uerr(20);
337 ins[0] = SRMOVE | opnd[1].ea;
338 if(!dataalt(&opnd[1]) || pcea(&opnd[1]))
339 uerr(10);
340 doea(&opnd[1]);
341 return;
342 }
343 if(cksprg(&opnd[0],USP)) {
344 if (modelen == 1)
345 uerr(34); /* default is word, can't test */
346 if (!ckareg(&opnd[1]))
347 uerr(33);
348 ins[0] = MOVEUSP|8|(opnd[1].ea&7);
349 return;
350 }
351 if(cksprg(&opnd[1],USP)) {
352 if (modelen == 1)
353 uerr(34); /* default is word, can't test */
354 if (!ckareg(&opnd[0]))
1File: PASS2.C Page 7
355 uerr(33);
356 ins[0] = MOVEUSP|(opnd[0].ea&7);
357 return;
358 }
359 k = ins[0];
360 ins[0] =| f3mode[modelen];
361 ckbytea();
362 ins[0] =| opnd[0].ea; /*source ea*/
363 doea(&opnd[0]);
364 ins[0] =| (opnd[1].ea&7)<<9; /*dest register*/
365 ins[0] =| (opnd[1].ea&070)<<3; /*dest mode*/
366 doea(&opnd[1]);
367 if(k==MOVEA) {
368 if(dataea(&opnd[1]))
369 uerr(20);
370 }
371 else if((pcea(&opnd[1]) && dataea(&opnd[1])) || opnd[1].ea==IMM)
372 uerr(20);
373 }
374
375 /* format 4 -- abcd, sbcd */
376 /* format 10 -- cmpm*/
377 /* format 27 -- addx, subx */
378 opf4()
379 {
380 if(get2ops())
381 return;
382 if (format==27) { /*addx,subx add in size bits*/
383 ins[0] =| f1mode[modelen];
384 }
385 else if(format==10) { /*cmpm*/
386 if((opnd[0].ea&070)!=INDINC || (opnd[1].ea&070)!=INDINC)
387 uerr(20);
388 ins[0] =| f1mode[modelen] | ((opnd[0].ea&7)|((opnd[1].ea&7)<<9));
389 return;
390 }
391 if(ckdreg(&opnd[0]) && ckdreg(&opnd[1])) {
392 ins[0] =| ((opnd[0].ea&7)|((opnd[1].ea&7)<<9));
393 return;
394 }
395 if((opnd[0].ea&070)==DECIND && (opnd[1].ea&070)==DECIND) {
396 ins[0] =| 010 | ((opnd[0].ea&7)|((opnd[1].ea&7)<<9));
397 return;
398 }
399 uerr(20);
400 }
401
402 /*format 5 -- div, mul*/
403 /*format 26 -- cmp, chk */
404 opf5()
405 {
406 if(get2ops())
407 return;
408 if(!ckdreg(&opnd[1])) {
409 if(opcpt==cmpptr) {
410 if(!dataea(&opnd[1])) /* [vlh] made define */
411 ins[0] =| f5amode[modelen]; /* was pumode */
412 else if(makeimm())
413 return;
1File: PASS2.C Page 8
414 else
415 uerr(20);
416 }
417 else
418 uerr(20);
419 }
420 if(opcpt==cmpptr) {
421 ins[0] =| f5mode[modelen]; /* was pumode */
422 ckbytea();
423 }
424 else if(!dataea(&opnd[0]))
425 uerr(20);
426 ins[0] =| (opnd[1].ea&7)<<9 | opnd[0].ea;
427 doea(&opnd[0]);
428 }
429
430 #define BTST 0000
431 /* format 7 -- bit instrs -- btst, bclr, bset, etc*/
432 opf7()
433 {
434 if(get2ops())
435 return;
436 if(opnd[1].ea==IMM||(ins[0]!=BTST&&pcea(&opnd[1]))||ckareg(&opnd[1]))
437 uerr(20);
438 if(ckdreg(&opnd[0])) {
439 ins[0] =| (opnd[0].ea<<9)|0400;
440 }
441 else { /*static bit #*/
442 if(opnd[0].con<0L || opnd[0].con>31 ||
443 (opnd[1].ea&INDIRECT&&opnd[0].con>7)) /* [vlh] */
444 uerr(23);
445 if(opnd[0].ea != IMM)
446 uerr(17);
447 ins[0] =| 04000;
448 dodisp(&opnd[0]);
449 }
450 if (modelen==1 && !(memea(&opnd[1]))) /*[vlh]*/
451 uerr(20);
452 else if (!(ckdreg(&opnd[1])) && modelen==4)
453 uerr(20);
454 ins[0] =| opnd[1].ea;
455 doea(&opnd[1]);
456 }
457
458 /* format 8 -- shifts and rotates*/
459 opf8()
460 {
461 register i;
462
463 getea(0); /*get first operand*/
464 if(pitw >= pnite) { /*end of all ops*/
465 if(ckdreg(&opnd[0])) { /*shift dreg one bit*/
466 cpop01(); /*copy opnd 0 to 1*/
467 opnd[0].ea = IMM;
468 opnd[0].con = 1L;
469 if (!ckdreg(&opnd[1])) uerr(20);
470 opf8l1:
471 if(opnd[0].con<1 || opnd[0].con>8) /*[vlh legal range 1..8*/
472 uerr(37);
1File: PASS2.C Page 9
473 ins[0] =| ((opnd[0].con.wd2&7)<<9)|f1mode[modelen]|opnd[1].ea;
474 return;
475 }
476 i = (ins[0]&077)<<6;
477 ins[0] =& 0177700;
478 ins[0] =| 0300|i|opnd[0].ea;
479 if(!memalt(&opnd[0]) || pcea(&opnd[0]) || modelen != 2)
480 uerr(20);
481 doea(&opnd[0]);
482 return;
483 }
484 if(!ckcomma()) {
485 uerr(10);
486 return;
487 }
488 getea(1); /*get second operand*/
489 if(!ckdreg(&opnd[1])) /* [vlh] second operand must be dreg */
490 uerr(20);
491 if(ckdreg(&opnd[0])) { /*first op is D reg*/
492 ins[0] =| (opnd[0].ea<<9)|040; /*reg # and reg bit*/
493 }
494 else {
495 if(opnd[0].ea != IMM)
496 uerr(20);
497 goto opf8l1;
498 }
499 ins[0] =| f1mode[modelen] | opnd[1].ea; /*put in size and reg #*/
500 }
501
502 /* format 9 -- jmp, jsr */
503 /* format 14 -- stop */
504 /* format 24 -- clr, neg, negx, not */
505 /* format 25 -- s?? */
506 /* format 29 -- pea */
507 /* one operand instructions -- jmp, clr, neg, not, sge, etc.*/
508 opf9()
509 {
510 getea(0);
511 if(format==24) { /*clr, not, etc*/
512 ins[0] =| f1mode[modelen]; /*add size bits*/
513 if(!dataalt(&opnd[0]) || pcea(&opnd[0]))
514 uerr(20);
515 }
516 else if(format==25) { /*tas,scc, etc*/
517 if(ckareg(&opnd[0]) || pcea(&opnd[0]) || opnd[0].ea==IMM)
518 uerr(20);
519 }
520 else if(format==14) { /*stop*/
521 if(modelen!=2 || opnd[0].ea!=IMM)
522 uerr(20);
523 doea(&opnd[0]);
524 return;
525 }
526 else if(!controlea(&opnd[0])) /*jmp, jsr, etc*/
527 uerr(20);
528 ins[0] =| opnd[0].ea;
529 doea(&opnd[0]);
530 }
531
1File: PASS2.C Page 10
532 /* format 11 -- dbcc*/
533 /* format 19 -- link*/
534 opf11()
535 {
536 if(get2ops())
537 return;
538 if(format==19) { /*link*/
539 if(!ckareg(&opnd[0]))
540 uerr(33);
541 if(opnd[1].ea != IMM)
542 uerr(17);
543 }
544 else {
545 if(!ckdreg(&opnd[0]))
546 uerr(33);
547 if(opnd[1].drlc!=rlflg) /*[vlh]don't chk opnd[1].ea!=LADDR||SADDR*/
548 uerr(22);
549 opnd[1].con =- (loctr+2L);
550 cksize(&opnd[1]);
551 opnd[1].drlc = ABS; /*not relocatable*/
552 }
553 ins[0] =| opnd[0].ea&7; /*put in reg #*/
554 dodisp(&opnd[1]);
555 }
556
557 /* format 12 -- exg*/
558 opf12()
559 {
560 register i;
561
562 if(get2ops())
563 return;
564 if(ckdreg(&opnd[0])) {
565 if(ckdreg(&opnd[1])) { /*exchange D regs*/
566 ins[0] =| 0100 | ((opnd[0].ea&7)<<9) | (opnd[1].ea&7);
567 return;
568 }
569 if(ckareg(&opnd[1])) { /*ins[0] <- A and D flag*/
570 ins[0] =| 0210 | ((opnd[0].ea&7)<<9) | (opnd[1].ea&7);
571 return;
572 }
573 }
574 if(ckareg(&opnd[0])) {
575 if(ckareg(&opnd[1])) { /*both a regs*/
576 ins[0] =| 0110 | ((opnd[0].ea&7)<<9) | (opnd[1].ea&7);
577 return;
578 }
579 if(ckdreg(&opnd[1])) { /*A and D regs*/
580 i = opnd[0].ea; /*exchg ea's*/
581 opnd[0].ea = opnd[1].ea;
582 opnd[1].ea = i;
583 ins[0] =| 0210 | ((opnd[0].ea&7)<<9) | (opnd[1].ea&7);
584 return;
585 }
586 }
587 uerr(20);
588 }
589
590 /* format 13 -- ext, unlk*/
1File: PASS2.C Page 11
591 /* format 18 -- trap*/
592 /* format 28 -- swap */
593 #define UNLK 047130
594
595 opf13()
596 {
597 getea(0);
598 if(format==18) { /*trap*/
599 if(opnd[0].con<0 || opnd[0].con>15)
600 uerr(15);
601 ins[0] =| opnd[0].con.wd2;
602 return;
603 }
604 if(ins[0]==UNLK) { /*unlk instr*/
605 if(!ckareg(&opnd[0]))
606 uerr(20);
607 }
608 else {
609 if(!ckdreg(&opnd[0]))
610 uerr(20);
611 if (format==13) /* ext */
612 ins[0] =| f13mode[modelen];
613 }
614 ins[0] =| opnd[0].ea&7;
615 }
616
617 /* format 15 -- adda, cmpa, suba*/
618 /* format 30 -- lea */
619 opf15()
620 {
621 register i;
622
623 if(get2ops())
624 return;
625 if(!ckareg(&opnd[1]))
626 uerr(33);
627 if(format==30) {
628 i = 0700;
629 if(!controlea(&opnd[0]))
630 uerr(20);
631 }
632 else
633 i = f15mode[modelen];
634 makef1(opnd[1].ea&7,i,&opnd[0]);
635 if (format==15 && opnd[0].ea != 071) cksize(&opnd[0]);
636 }
637
638 /*formats 16 and 17 -- addq, inc, subq, dec*/
639 opf17()
640 {
641 if(format==16) { /*inc or dec*/
642 clrea(&opnd[0]);
643 opnd[0].ea = IMM;
644 opnd[0].con = 1L;
645 opnd[0].drlc = ABS;
646 getea(1);
647 }
648 else {
649 if(get2ops())
1File: PASS2.C Page 12
650 return;
651 }
652 if(opnd[0].ea != IMM || !altea(&opnd[1]) || pcea(&opnd[1]))
653 uerr(20);
654 if(opnd[0].con<=0 || opnd[0].con>8)
655 uerr(15);
656 if(modelen==1 && !dataea(&opnd[1]))
657 uerr(34);
658 ins[0] =| f1mode[modelen]|((opnd[0].con.wd2&7)<<9)|opnd[1].ea;
659 doea(&opnd[1]);
660 }
661
662 /* format 20 -- movem */
663 int regmsk0[] {0100000,040000,020000,010000,04000,02000,01000,0400,0200,
664 0100,040,020,010,4,2,1};
665 int regmsk1[] {1,2,4,010,020,040,0100,0200,0400,01000,02000,04000,010000,
666 020000,040000,0100000};
667 opf20()
668 {
669 register dr;
670 register i,j;
671
672 dr = 0;
673 if(getreg() != -1 || pitw->itty == ITRM) { /*regs to memory*/
674 if (pitw->itty != ITRM) { /* [vlh] */
675 pitw--;
676 j = getrlist(regmsk0);
677 }
678 else {
679 j = pitw->itop;
680 pitw++;
681 }
682 if(!ckcomma())
683 uerr(10);
684 }
685 else
686 dr = 02000;
687 getea(0);
688 if(dr) {
689 if(!ckcomma())
690 uerr(10);
691 if (pitw->itty != ITRM) /* [vlh] */
692 j = getrlist(regmsk1); /*mem to regs*/
693 else {
694 j = pitw->itop;
695 j = fixmask(j);
696 pitw++;
697 }
698 }
699 else {
700 if(controlea(&opnd[0]))
701 j = fixmask(j);
702 }
703 i = opnd[0].ea&070;
704 if(!controlea(&opnd[0]) && i!=INDINC && i!=DECIND)
705 uerr(20);
706 if(modelen==4) /*long*/
707 ins[0] =| 0100;
708 ins[0] =| opnd[0].ea|dr;
1File: PASS2.C Page 13
709 *pins++ = j; /*reg mask*/
710 *prlb++ = DABS;
711 instrlen =+ 2;
712 doea(&opnd[0]);
713 if (!dr) { /* 1st argument (2nd is reg list) */
714 if (pcea(&opnd[0]) || (opnd[0].ea&070)==INDINC)
715 uerr(20); /* xx(pc), xx(pc,dx), -(ax) */
716 }
717 else /* 2nd argument (1st is reg list) */
718 if ((opnd[0].ea&070)==DECIND)
719 uerr(20); /* (ax)+ */
720 }
721
722 /*
723 * get a list of registers for the movem instr
724 * call with:
725 * ptr to reg-to-mem or mem-to-reg array of bits
726 */
727 getrlist(ap)
728 int *ap;
729 {
730 register int *p,i,j;
731 register int mask;
732
733 p = ap;
734 mask = 0;
735 while((i=getreg()) != -1) {
736 if(ckitc(pitw,'-')) {
737 pitw++;
738 if((j=getreg()) == -1) {
739 uerr(40);
740 break;
741 }
742 while(i<=j)
743 mask =| p[i++];
744 }
745 else
746 mask =| p[i];
747 if(ckitc(pitw,'/'))
748 pitw++;
749 else
750 break;
751 }
752 if(!mask)
753 uerr(40);
754 return(mask);
755 }
756
757 /*reverse a movem register mask for control ea to memory*/
758 fixmask(msk)
759 {
760 register i,j,k;
761
762 k = (msk&1) ? 0100000 : 0;
763 i = 2;
764 j = 040000;
765 while(i) {
766 if(msk&i)
767 k =| j;
1File: PASS2.C Page 14
768 i =<< 1;
769 j =>> 1;
770 }
771 return(k);
772 }
773
774 /* format 21 -- movep*/
775 opf21()
776 {
777 register m,d;
778 register char *p;
779
780 if(get2ops())
781 return;
782 if(ckdreg(&opnd[0])) { /*d reg source*/
783 m = 0600;
784 d = opnd[0].ea;
785 p = &opnd[1];
786 }
787 else if(ckdreg(&opnd[1])) { /*d reg dest*/
788 m = 0400;
789 d = opnd[1].ea;
790 p = &opnd[0];
791 }
792 else {
793 uerr(20);
794 }
795 if((p->ea&070) != INDDISP)
796 uerr(20);
797 if(modelen == 4)
798 m =| 0100;
799 ins[0] =| (d<<9)|m|(p->ea&7);
800 *pins++ = p->con.wd2;
801 *prlb++ = p->drlc;
802 instrlen =+ 2;
803 }
804
805 /* format 22 -- moveq*/
806 opf22()
807 {
808 if(get2ops())
809 return;
810 if(opnd[0].ea != IMM)
811 uerr(17);
812 if(opnd[0].con>255L || opnd[0].con<-256L)
813 uerr(15);
814 if(!ckdreg(&opnd[1]))
815 uerr(33);
816 ins[0] =| (opnd[1].ea<<9) | (opnd[0].con.wd2&0377);
817 }
818
819 /* format 23 -- eor*/
820 opf23()
821 {
822 if(get2ops())
823 return;
824 if (cksprg(&opnd[1],CCR) || cksprg(&opnd[1],SR)) {
825 opcpt = eoriptr;
826 ins[0] = opcpt->vl1.wd2;
1File: PASS2.C Page 15
827 format = (opcpt->flags)&OPFF;
828 ccr_or_sr();
829 return;
830 }
831 if(!ckdreg(&opnd[0])) {
832 if(makeimm()) /*must be immediate*/
833 return;
834 uerr(20); /*or error*/
835 }
836 if(!dataalt(&opnd[1]) || pcea(&opnd[1]))
837 uerr(20);
838 ins[0] =| (opnd[0].ea<<9)|f23mode[modelen]|opnd[1].ea;
839 doea(&opnd[1]);
840 }
841

4
CPM OPERATING SYSTEMS/CPM 68K/1.0X SOURCES/v102/as68/relink.sub Normal file
View File

@@ -0,0 +1,4 @@
$1lo68 -r -o as68.rel -f $1 -unofloat 0$1s.o dir.o expr.o main.o misc.o pass1a.o pass2.o strncmp.o symt.o 0$1lib6.a 0$1clib
era *.o
user 10!make $1

30
CPM OPERATING SYSTEMS/CPM 68K/1.0X SOURCES/v102/as68/strncmp.c Normal file
View File

@@ -0,0 +1,30 @@
/*********************************************************************
* STRNCMP - compares strings up to n chars
*
* WORD strncmp(s1,s2,n)
* BYTE *s1, *s2;
* UWORD n;
*
* 'strncmp' compares null terminated strings s1 and s2, and examines
* at most n chars.
* Always compares at least 1 char.
* n < 0 compares many, many characters.
* Returns:
* strncmp < 0 if s1<s2 (within n chars)
* strncmp = 0 if s1=s2 " " "
* strncmp > 0 if s1>s2 " " "
*********************************************************************/
#include <portab.h>
WORD strncmp(s1,s2,n)
REG BYTE *s1, *s2;
REG WORD n;
{
for( ; --n > 0 && (*s1 == *s2); s1++, s2++ )
{
if( *s1 == NULL )
return(0);
}
return(*s1 - *s2);
}

850
CPM OPERATING SYSTEMS/CPM 68K/1.0X SOURCES/v102/as68/symt.c Normal file
View File

@@ -0,0 +1,850 @@
/*
Copyright 1981
Alcyon Corporation
8716 Production Ave.
San Diego, Ca. 92121
*/
#include "as68.h"
/* symbol table and misc routines*/
int errno;
char *ermsg[];
char tfilname[];
char initfnam[];
char ldfn[];
char tlab1[];
int stdofd;
int ftudp;
int poslab;
/*output it for beginning of statement*/
opitb()
{
stbuf[0].itty = ITBS; /*beginning of statement*/
stbuf[0].itop = (fchr!=EOLC) ? absln : absln-1;
stbuf[1].itty = ITSY; /*label entry*/
stbuf[1].itop.ptrw2 = lblpt; /*pointer to symbol or 0*/
/*put opcode in it buffer*/
stbuf[2].itty = ITSY;
stbuf[2].itrl = modelen; /*mode of instr(byte, word, long)*/
stbuf[2].itop.ptrw2 = opcpt; /*pointer to opcode in main table*/
stbuf[3].itty = ITCN;
stbuf[3].itrl = rlflg; /*relocation base*/
stbuf[3].itop = loctr; /*pass1 location counter*/
itwc = ITOP1; /*next available slot-currently 4*/
pitw = &stbuf[ITOP1].itty; /*init the pointer*/
}
/*
* get an input term (symbol, constant, or special character)
* call with:
* the first character in fchr
* returns:
* item type in itype
* item value in ival if item is a constant or special character
* if it is a symbol it is placed at the end of the main table
* meaning of state table:
* currently getting: symbol(0) constant(1) beginning(2)
* next char:
* digit(0) 0 1 1
* letter(3) 0 3 0
* special char(6) 3 3 3
* contents of the state table is the next state. processing stops when
* state 3 is encountered. state 2 is the beginning state.
*/
int sttbl[] {0,1,1,0,3,0,3,3,3}; /*state table for parser*/
gterm(constpc)
int constpc;
{
register smode, i;
register char *p;
register int tmode;
register char *j;
long num;
char istr[80];
/* if(fchr == '\'' || fchr == '"') */ /* Fucking Whitesmith's */
if(fchr == 047 || fchr == 042)
if(astring()) /*maybe ascii string*/
return;
smode = 2; /*beginning state*/
i = 0;
p = istr;
/*loop to put item on istr*/
while(fchr>=' ') { /*until a control char*/
if(smode==2 && fchr=='.')
tmode = 3;
else if(isalpha(fchr) || fchr=='~' || fchr=='_' || (fchr=='$'&&i))
tmode=3;
else if(isdigit(fchr))
tmode=0;
else
tmode = 6;
tmode = sttbl[tmode+smode]; /*new state*/
if(tmode==3) break; /*end of item*/
smode = tmode;
*p++ = fchr; /*save character*/
i++;
fchr=gchr();
}
/* end of item*/
switch(smode) {
case 0: /*symbol*/
*p = '\0'; /*end of symbol*/
itype = ITSY; /*symbol*/
pack(istr,lmte); /*put symbol at end of main table*/
j = lemt(sirt,FALSE);
if(istr[0]!='~' && !poslab && (j->flags&(SYEQ|SYER))==SYEQ) {
itype = (j->flags&SYRM) ? ITRM : ITCN; /* [vlh] */
ival = j->vl1;
reloc = ((j->flags)&SYRO) ? TEXT : ((j->flags)&SYRA) ? DATA :
((j->flags)&SYBS) ? BSS : ABS;
}
return;
case 1: /*constant*/
if(!constant(&num,istr,i)) {
uerr(17); /*illegal constant*/
num = 0;
}
ival = num;
itype = ITCN;
reloc = ABS;
return;
case 2: /*just a special char*/
switch(fchr) {
case '*': /*location counter*/
if(starmul) { /*multiply*/
starmul = 0;
goto specsy;
}
refpc++; /*referenced pgm ctr*/
reloc = rlflg; /*relocation of location counter*/
ival = loctr;
itype = (constpc) ? ITCN : ITPC;
break;
case '$': /*hex constant*/
oconst(16);
return;
case '@': /*octal const*/
oconst(8);
return;
case '%': /*binary const*/
oconst(2);
return;
case '#':
immed[opdix]++;
goto specsy;
case '(':
indir[opdix]++;
plevel++;
goto specsy;
case ')':
plevel--;
goto specsy;
default:
specsy:
itype = ITSP; /*return special char*/
ival = fchr;
}
if(fchr != EOLC)
fchr=gchr(); /*get next char*/
if((ival=='>' && fchr=='>') || (ival=='<' && fchr=='<'))
fchr=gchr(); /*shift op, ignore second char*/
return;
default:
abort(); /*not possible*/
}
}
/*check for an ascii string enclosed in single quotes*/
astring()
{
register char delim;
/* if(fchr != '\'' && fchr != '"') *//*valid delimiter*/
if(fchr != 047 && fchr != 042)
return;
delim = fchr;
if(equflg || (itype==ITSP && ival.wd2=='#')) { /*immediate operand*/
if(astr1(delim)) {
fchr = gchr();
if(fchr!=delim)
xerr(19);
fchr=gchr();
}
return((equflg) ? 1 : 0);
}
while(astr1(delim)) {
itype = ITSP;
ival = ','; /*separate by commas*/
reloc = ABS;
opitoo();
}
return(0);
}
astr1(adelim)
{
register delim,i,retv;
register long l;
delim = adelim;
i = 0; l = 0;
retv = 1;
while((fchr=gchr()) != EOF) {
if(fchr==delim) {
fchr = gchr();
if(fchr != delim) {
retv = 0; /*end of string*/
break;
}
}
if(fchr == EOLC) {
xerr(19);
retv = 0; /*end of string*/
break;
}
l = (l<<8) | fchr;
if(++i >= modelen) {
if((fchr=gchr()) == delim) {
fchr = gchr();
retv = 0; /*end of string*/
}
else
peekc = fchr; /*next char in string*/
break; /*filled one bucket*/
}
}
while(i < modelen) {
l =<< 8;
i++;
}
itype = ITCN;
ival = l;
reloc = ABS;
if(!equflg)
opitoo(); /*output one operand*/
return(retv);
}
/*get constant given radix*/
oconst(ardx)
{
register trdx,j;
register long i;
switch (ardx) { /* radix as power of 2 */
case 16 : trdx = 4; break;
case 8 : trdx = 3; break;
case 2 : trdx = 1; break;
default :
rpterr("invalid radix in oconst");
abort();
}
i=0;
while(1) {
fchr=gchr();
j=fchr;
if(isdigit(j))
j =- '0';
else if((j=tolower(j))>='a' && j<='f')
j = j-'a'+10;
else
break; /*not valid numeric char*/
if(j>=0 && j<ardx)
i = (i<<trdx)+j;
else
break;
}
ival = i;
itype = ITCN;
reloc = ABS;
}
/*convert ascii constant to binary*/
constant(pnum,pstr,idx)
long *pnum;
char *pstr;
{
register i,j;
register char *p;
register long l;
p = pstr;
l = 0;
for(i=0; i<idx; i++) {
j = *pstr++;
if(isdigit(j))
j =- '0';
if(j<0 || j>=10)
return(0);
l = (l<<3) + (l<<1) + j; /* l = l*10 + j*/
}
*pnum = l;
return(1);
}
/*
* method for looking up entries in the main table
*
* Note: The entry to be looked up must be placed at the end
* of the main table. The global cell 'lmte'(last main
* entry) points to the next available entry in the main
* table. The address of an initial reference table must
* also be provided.
*
* 1) Compute the hash code for the symbol and add it to the base address
* of the initial reference table given as input. Thus, two words are
* accessed which define the chain on which the symbol must be if it
* is in the table at all.
*
* 2) Alter the table link of the last symbol in the chain so that it
* points to the symbol being looked up. Note that the symbol to be
* looked up is always placed at the end of the main table before
* calling the lookup routine. This essentially adds one more element
* to the end of the chain, namely the symbol to be looked up.
*
* 3) Now start at the first symbol in the chain and follow the chain
* looking for a symbol equal to the smbol being looked up. It is
* guaranteed that such a symbol will be found because it is always
* the last symbol on the chain.
*
* 4) When the symbol is found, check to see if it is the last symbol
* on the chain. If not, the symbol being looked for is in the table
* and has been found. If it is the last symbol, the symbol being
* looked up is not in the table.
*
* 5) In the case the looked up symbol is not found, it is usually added
* to the end of the table. This is done simply b changing the
* initial reference table entry which points to the previous
* last symbol on the chain so that is now points to the symbol at the
* end of the main table. In case the symbol just looked up is not to
* be added to the main table then no action is needed . This means
* that the table link of the last symbol on a chain may point any-
* where.
*
* look up entry in the main table
* call with:
* address of initial reference table
* entry to be looked up at the end of the main table
* returns:
* a pointer to the entry. if this pointer is equal to
* lmte then the symbol was not previously in the table.
*/
char *lemt(airt,oplook)
char **airt;
int oplook; /* if true then looking in opcode table */
{
register char *mtpt;
register int *p1, *p2;
register int i, j;
if (oplook) { /* [vlh] get rid of preceding '.', to lowercase */
if (lmte->name[0]=='.') {
lmte->name[NAMELEN-1] = NULL; /* in case of '.' */
j = 1;
}
else j = 0;
for (i=0; j<NAMELEN; i++, j++)
lmte->name[i] = tolower(lmte->name[j]);
}
pirt = airt + hash(); /*hashed ptr to irt*/
mtpt = pirt->irfe; /*pointer to first entry in chain*/
if(!mtpt) /*empty chain*/
mtpt = lmte; /*start at end of main table*/
else
(pirt->irle)->tlnk = lmte; /*last entry in chain is new symbol*/
/*loop to locate entry in main table*/
lemtl:
p1 = &mtpt->name[0];
p2 = &lmte->name[0];
i = NAMELEN/(sizeof i);
while(i) {
if(*p1++ != *p2++) {
mtpt = mtpt->tlnk; /*go to next entry in chain*/
goto lemtl;
}
i--;
}
return(mtpt);
}
/* compute a hash code for the last entry in the main table*/
/* returns the hash code*/
hash()
{
register int i;
register ht1;
register char *p;
ht1 = 0;
p = &lmte->name[0];
for(i=0; i<NAMELEN; i++)
ht1 =+ *p++;
return(ht1&(SZIRT-2)); /*make hash code even and between 0 & SZIRT-2*/
}
/*
* Make an entry in the main table
* assumes :
* entry to be made is pointed at by lmte
* pirt points to the correct initial reference table entry.
*/
mmte()
{
pirt->irle = lmte; /*pointer to last entry in chain*/
if(pirt->irfe == 0) /*first entry in chain*/
pirt->irfe = lmte;
lmte =+ STESIZE; /*bump last main table entry pointer*/
if(lmte>=emte) { /*main table overflow*/
if(sbrk(STESIZE*ICRSZMT) == -1){ /*get more memory*/
rpterr("symbol table overflow\n");
endit();
}
else {
emte =+ STESIZE*ICRSZMT; /*move end of main table*/
cszmt =+ ICRSZMT;
}
}
}
/*
* make an entry in the main table for a directive
* call with:
* pointer to string containing directive name
* address of routine to handle directive in pass one
* address of routine to handle directive in pass two
*/
mdemt(mdstr,dirnum)
char *mdstr;
{
register char *mdept;
pack(mdstr,lmte); /*pack name at end of main table*/
mdept=lemt(oirt,TRUE); /*look up in opcode table*/
if(mdept != lmte) { /*best not be there already*/
uerr(5);
abort();
return;
}
mmte(); /*make main table entry*/
mdept->flags =| OPDR|SYIN; /*directive*/
mdept->vl1 = dirnum; /*directive #*/
}
/*
* pack a string into an entry in the main table
* call with:
* pointer to the string
* pointer to desired entry in the main table
*/
pack(apkstr,apkptr)
char *apkstr, *apkptr;
{
register i;
register char *pkstr, *pkptr;
pkstr = apkstr;
pkptr = apkptr;
i = NAMELEN;
while(*pkstr && i) {
*pkptr++ = *pkstr++;
i--;
}
while(i--)
*pkptr++ = '\0'; /*pad with nulls*/
}
/* function to get characters for source file*/
int xcol = 0; /* Column Counter */
int spcnt = 0; /* Space count for tab expansion */
gchr()
{
register chr1;
if(peekc) {
chr1 = peekc;
peekc = 0;
if(chr1 != SOH)
xcol--;
}
else if (spcnt)
{
spcnt--;
return(' ');
}
else
{
gchr1:
if(sbuflen<=0){ /*nothing on input buffer*/
sbuflen=read(ifn,sbuf,512); /*read in source*/
if(sbuflen<=0)
return(EOF); /*end of file*/
psbuf = sbuf;
}
chr1 = *psbuf++;
sbuflen--;
}
if (chr1 == SOH) /*preprocessor flag*/
goto gchr1; /*ignore it*/
if(chr1 == EOLC) { /*end of line*/
xcol = -1; /* Clear column counter */
if(!p2flg) /*pass 1 only*/
absln++;
}
if(chr1=='\t') /*convert tabs to spaces*/
{
spcnt += 7 - (xcol&7); /* This many spaces */
xcol += spcnt; /* New column number */
chr1 = ' ';
}
xcol++;
return(chr1);
}
/*
* write out intermediate text for one statement
* call with
* the it for the statement in stbuf
*/
wostb()
{
register int woix;
register short *itwo;
register int i;
if(stbuf[0].itty != ITBS) abort(); /*not beginning of stmt*/
itwo = &stbuf;
woix = stbuf[0].itrl & 0377; /*unsigned byte*/
while(woix--) {
for(i=0; i<(sizeof stbuf[0])/(sizeof *itwo); i++) {
doitwr(*itwo++);
}
}
/* debug(); //call debug package*/
}
doitwr(word)
short word;
{
short i;
if( pitix < itbuf || pitix > &itbuf[ITBSZ] ) {
printf("doitwr: it buffer botch\n");
endit();
}
if( pitix >= &itbuf[ITBSZ]) {
if(write(itfn,itbuf,ITBSZ*(sizeof i)) != ITBSZ*(sizeof i)) {
rpterr("it write error errno=%o\n",errno);
endit();
}
pitix = itbuf;
}
*pitix++ = word;
}
/*
* user source error
* call with:
* number to indicate reason for error
* types the error number and the line number on which
* the error occured.
*/
uerr(errn)
{
if(p2flg) { /*pass 2 gets two ampersands*/
in_err++; /* [vlh] instrlen <- pass1 estimation */
printf("&& %d: %s\n",p2absln,ermsg[errn-1]);
}
else
printf("& %d: %s\n",(fchr==EOLC)?absln-1:absln,ermsg[errn-1]);
nerror++;
}
/*
* user error that causes the statement to be abandoned
* call with:
* error number
*/
xerr(xern)
{
uerr(xern); /*type error message*/
if(!p2flg) /*pass one*/
igrst(); /*pass rest of source*/
}
/* abort the assembly*/
abort()
{
rpterr("as68 abort\n");
nerror++;
endit();
}
/*ignore rest of statement*/
igrst()
{
while(fchr!=EOLC && fchr!=EOF) /*until end of line*/
fchr=gchr();
while((fchr=gchr())==EOLC) ; /*ignore null lines*/
}
/*ignore blanks after a label*/
ligblk()
{
if(fchr == EOF) return;
igblk();
if(fchr==EOLC) {
fchr=gchr();
ligblk();
}
}
rubout()
{
nerror = -1;
endit();
}
/* exit from the assembler*/
endit()
{
LASTCHTFN = itfnc;
unlink(tfilname); /*delete temporary files*/
LASTCHTFN = trbfnc;
unlink(tfilname);
LASTCHTFN = dafnc;
unlink(tfilname);
LASTCHTFN = drbfnc;
unlink(tfilname);
if(nerror != -1) { /*not rubout*/
if(ftudp)
putchar('\n');
}
if(nerror > 0) {
fprintf(stderr,"& %d errors\n",nerror);
}
if (initflg)
unlink(ldfn); /* [vlh] get rid of empty .o file */
exit(nerror!=0);
}
/*
* open files
* call with:
* pointer to name of file to open
* flag for how to open
* 0 => read
* 1 => write
*/
openfi(pname,hflag)
char *pname;
{
register fd;
fd = (hflag==1) ? creat(pname,0666,1) : open(pname,hflag,1);
if(fd < 0) { /*open failed*/
rpterr("can't open %s errno=%o\n",pname,errno);
endit();
}
return(fd);
}
/* get a temp file for the intermediate text*/
char lastfile = 'A';
gettempf()
{
register i,j;
register char *p;
LASTCHTFN = lastfile++; /* Creat temp name */
if((j=creat(tfilname,0600,1)) >= 0)
return(j); /* File created OK */
rpterr("Unable to open temporary file\n");
endit();
}
/* move label name from lbt to main table entry pointed to by lmte*/
setname()
{
register i;
register int *p1, *p2;
p1 = &lmte->name[0];
for(p2 = &lbt[0]; p2 < &lbt[NAMELEN]; ) {
*p1++ = *p2;
*p2++ = 0;
}
}
/* get the initialized main table and initial reference tables from*/
/* the initialize file*/
getsymtab()
{
long j; /* length for read / write */
register char **p;
register struct symtab *p1;
register char *p2;
register fd,i;
if((fd=open(initfnam,0,1)) < 0) {
rerr:
printf("& Unable to read init file: %s\n", initfnam);
endit();
}
if(read(fd,sirt,SZIRT*(sizeof sirt[0])) != SZIRT*(sizeof sirt[0])) {
goto rerr;
}
if(read(fd,oirt,SZIRT*(sizeof sirt[0])) != SZIRT*(sizeof sirt[0]))
goto rerr;
if(read(fd,&j,(sizeof j)) != (sizeof j)) /* Read Count */
goto rerr; /* Y-U-K!!! */
if((i=read(fd,bmte,(int)j)) != j) /* Read table */
goto rerr;
if((i%STESIZE) != 0)
goto rerr;
lmte = bmte + i;
p2 = bmte-1;
for(p=sirt; p<&sirt[SZIRT]; p++) {
if(*p)
*p =+ (long)p2;
}
for(p=oirt; p<&oirt[SZIRT]; p++) {
if(*p)
*p =+ (long)p2;
}
for(p1=bmte; p1<lmte; p1++) {
if(p1->tlnk)
p1->tlnk =+ (long)p2;
}
close(fd);
}
/* write the initialization file*/
putsymtab()
{
long j;
register char **p;
register struct symtab *p1;
register char *p2;
register fd,i;
if((fd=creat(initfnam,0644,1))<0) {
printf("& Cannot create init: %s\n", initfnam);
return;
}
/*
* change all pointers so that they are relative to the beginning
* of the symbol table
*/
p2 = bmte-1;
for(p=sirt; p<&sirt[SZIRT]; p++) {
if(*p)
*p =- (long)p2;
}
for(p=oirt; p<&oirt[SZIRT]; p++) {
if(*p)
*p =- (long)p2;
}
for(p1=bmte; p1<lmte; p1++) {
if(p1->tlnk)
p1->tlnk =- (long)p2;
}
if(write(fd,sirt,SZIRT*(sizeof sirt[0])) != SZIRT*(sizeof sirt[0])) {
goto werr;
}
if(write(fd,oirt,SZIRT*(sizeof oirt[0])) != SZIRT*(sizeof oirt[0]))
goto werr;
i = lmte - bmte; /*length of current main table*/
if((i % STESIZE) != 0) {
goto werr;
}
j = i;
if(write(fd,&j,(sizeof j)) != (sizeof j)) /* Y-U-K!! */
goto werr;
if(write(fd,bmte,i) != i) {
werr:
printf("& Write error on init file: %s\n",initfnam);
return;
}
close(fd);
}
/* print an error on file descriptor 2*/
/* used for errors with disasterous consequences*/
rpterr(ptch,x1,x2,x3,x4,x5,x6)
char *ptch;
{
if(prtflg==0) /* Check for paging output */
page(); /* Perform page checks */
fprintf(stderr,"& %d: ",absln);
fprintf(stderr,ptch,x1,x2,x3,x4,x5,x6);
}
/* set the file name for the relocatable object file (sourcefile.o)*/
setldfn(ap)
char *ap;
{
register char *p1,*p2;
p1 = ap;
p2 = ldfn;
while(*p1) {
*p2++ = *p1++;
}
if(*(p2-2) != '.') { /*not name.?*/
*p2++ = '.';
*p2++ = 'o';
}
else { /* is name.? */
*(p2-1) = 'o';
}
*p2 = '\0';
}
savelab()
{
register int *p1, *p2;
p2 = &lmte->name[0];
for(p1= &tlab1[0]; p1 < &tlab1[NAMELEN]; )
*p1++ = *p2++;
}

865
CPM OPERATING SYSTEMS/CPM 68K/1.0X SOURCES/v102/as68/symt.lis Normal file
View File

@@ -0,0 +1,865 @@
1File: SYMT.C Page 1
1 /*
2 Copyright 1981
3 Alcyon Corporation
4 8716 Production Ave.
5 San Diego, Ca. 92121
6 */
7
8 #include "as68.h"
9
10 /* symbol table and misc routines*/
11
12 int errno;
13 char *ermsg[];
14 char tfilname[];
15 char initfnam[];
16 char ldfn[];
17 char tlab1[];
18 int stdofd;
19 int ftudp;
20 int poslab;
21
22 /*output it for beginning of statement*/
23 opitb()
24 {
25 stbuf[0].itty = ITBS; /*beginning of statement*/
26 stbuf[0].itop = (fchr!=EOLC) ? absln : absln-1;
27 stbuf[1].itty = ITSY; /*label entry*/
28 stbuf[1].itop.ptrw2 = lblpt; /*pointer to symbol or 0*/
29
30 /*put opcode in it buffer*/
31 stbuf[2].itty = ITSY;
32 stbuf[2].itrl = modelen; /*mode of instr(byte, word, long)*/
33 stbuf[2].itop.ptrw2 = opcpt; /*pointer to opcode in main table*/
34 stbuf[3].itty = ITCN;
35 stbuf[3].itrl = rlflg; /*relocation base*/
36 stbuf[3].itop = loctr; /*pass1 location counter*/
37 itwc = ITOP1; /*next available slot-currently 4*/
38 pitw = &stbuf[ITOP1].itty; /*init the pointer*/
39 }
40
41 /*
42 * get an input term (symbol, constant, or special character)
43 * call with:
44 * the first character in fchr
45 * returns:
46 * item type in itype
47 * item value in ival if item is a constant or special character
48 * if it is a symbol it is placed at the end of the main table
49
50 * meaning of state table:
51
52 * currently getting: symbol(0) constant(1) beginning(2)
53
54 * next char:
55 * digit(0) 0 1 1
56
57 * letter(3) 0 3 0
58
59 * special char(6) 3 3 3
1File: SYMT.C Page 2
60
61 * contents of the state table is the next state. processing stops when
62 * state 3 is encountered. state 2 is the beginning state.
63 */
64 int sttbl[] {0,1,1,0,3,0,3,3,3}; /*state table for parser*/
65
66 gterm(constpc)
67 int constpc;
68 {
69 register smode, i;
70 register char *p;
71 register int tmode;
72 register char *j;
73 long num;
74 char istr[80];
75
76 /* if(fchr == '\'' || fchr == '"') */ /* Fucking Whitesmith's */
77 if(fchr == 047 || fchr == 042)
78 if(astring()) /*maybe ascii string*/
79 return;
80 smode = 2; /*beginning state*/
81 i = 0;
82 p = istr;
83
84 /*loop to put item on istr*/
85 while(fchr>=' ') { /*until a control char*/
86 if(smode==2 && fchr=='.')
87 tmode = 3;
88 else if(isalpha(fchr) || fchr=='~' || fchr=='_' || (fchr=='$'&&i))
89 tmode=3;
90 else if(isdigit(fchr))
91 tmode=0;
92 else
93 tmode = 6;
94 tmode = sttbl[tmode+smode]; /*new state*/
95 if(tmode==3) break; /*end of item*/
96 smode = tmode;
97 *p++ = fchr; /*save character*/
98 i++;
99 fchr=gchr();
100 }
101
102 /* end of item*/
103 switch(smode) {
104
105 case 0: /*symbol*/
106 *p = '\0'; /*end of symbol*/
107 itype = ITSY; /*symbol*/
108 pack(istr,lmte); /*put symbol at end of main table*/
109 j = lemt(sirt,FALSE);
110 if(istr[0]!='~' && !poslab && (j->flags&(SYEQ|SYER))==SYEQ) {
111 itype = (j->flags&SYRM) ? ITRM : ITCN; /* [vlh] */
112 ival = j->vl1;
113 reloc = ((j->flags)&SYRO) ? TEXT : ((j->flags)&SYRA) ? DATA :
114 ((j->flags)&SYBS) ? BSS : ABS;
115 }
116 return;
117
118 case 1: /*constant*/
1File: SYMT.C Page 3
119 if(!constant(&num,istr,i)) {
120 uerr(17); /*illegal constant*/
121 num = 0;
122 }
123 ival = num;
124 itype = ITCN;
125 reloc = ABS;
126 return;
127
128 case 2: /*just a special char*/
129 switch(fchr) {
130
131 case '*': /*location counter*/
132 if(starmul) { /*multiply*/
133 starmul = 0;
134 goto specsy;
135 }
136 refpc++; /*referenced pgm ctr*/
137 reloc = rlflg; /*relocation of location counter*/
138 ival = loctr;
139 itype = (constpc) ? ITCN : ITPC;
140 break;
141
142
143 case '$': /*hex constant*/
144 oconst(16);
145 return;
146
147 case '@': /*octal const*/
148 oconst(8);
149 return;
150
151 case '%': /*binary const*/
152 oconst(2);
153 return;
154
155 case '#':
156 immed[opdix]++;
157 goto specsy;
158
159 case '(':
160 indir[opdix]++;
161 plevel++;
162 goto specsy;
163
164 case ')':
165 plevel--;
166 goto specsy;
167
168 default:
169 specsy:
170 itype = ITSP; /*return special char*/
171 ival = fchr;
172 }
173 if(fchr != EOLC)
174 fchr=gchr(); /*get next char*/
175 if((ival=='>' && fchr=='>') || (ival=='<' && fchr=='<'))
176 fchr=gchr(); /*shift op, ignore second char*/
177 return;
1File: SYMT.C Page 4
178
179 default:
180 abort(); /*not possible*/
181 }
182 }
183
184 /*check for an ascii string enclosed in single quotes*/
185
186 astring()
187 {
188 register char delim;
189
190 /* if(fchr != '\'' && fchr != '"') *//*valid delimiter*/
191 if(fchr != 047 && fchr != 042)
192 return;
193 delim = fchr;
194 if(equflg || (itype==ITSP && ival.wd2=='#')) { /*immediate operand*/
195 if(astr1(delim)) {
196 fchr = gchr();
197 if(fchr!=delim)
198 xerr(19);
199 fchr=gchr();
200 }
201 return((equflg) ? 1 : 0);
202 }
203 while(astr1(delim)) {
204 itype = ITSP;
205 ival = ','; /*separate by commas*/
206 reloc = ABS;
207 opitoo();
208 }
209 return(0);
210 }
211
212 astr1(adelim)
213 {
214 register delim,i,retv;
215 register long l;
216
217 delim = adelim;
218 i = 0; l = 0;
219 retv = 1;
220 while((fchr=gchr()) != EOF) {
221 if(fchr==delim) {
222 fchr = gchr();
223 if(fchr != delim) {
224 retv = 0; /*end of string*/
225 break;
226 }
227 }
228 if(fchr == EOLC) {
229 xerr(19);
230 retv = 0; /*end of string*/
231 break;
232 }
233 l = (l<<8) | fchr;
234 if(++i >= modelen) {
235 if((fchr=gchr()) == delim) {
236 fchr = gchr();
1File: SYMT.C Page 5
237 retv = 0; /*end of string*/
238 }
239 else
240 peekc = fchr; /*next char in string*/
241 break; /*filled one bucket*/
242 }
243 }
244 while(i < modelen) {
245 l =<< 8;
246 i++;
247 }
248 itype = ITCN;
249 ival = l;
250 reloc = ABS;
251 if(!equflg)
252 opitoo(); /*output one operand*/
253 return(retv);
254 }
255
256 /*get constant given radix*/
257 oconst(ardx)
258 {
259 register trdx,j;
260 register long i;
261
262 switch (ardx) { /* radix as power of 2 */
263 case 16 : trdx = 4; break;
264 case 8 : trdx = 3; break;
265 case 2 : trdx = 1; break;
266 default :
267 rpterr("invalid radix in oconst");
268 abort();
269 }
270 i=0;
271 while(1) {
272 fchr=gchr();
273 j=fchr;
274 if(isdigit(j))
275 j =- '0';
276 else if((j=tolower(j))>='a' && j<='f')
277 j = j-'a'+10;
278 else
279 break; /*not valid numeric char*/
280 if(j>=0 && j<ardx)
281 i = (i<<trdx)+j;
282 else
283 break;
284 }
285 ival = i;
286 itype = ITCN;
287 reloc = ABS;
288 }
289
290
291 /*convert ascii constant to binary*/
292 constant(pnum,pstr,idx)
293 long *pnum;
294 char *pstr;
295 {
1File: SYMT.C Page 6
296 register i,j;
297 register char *p;
298 register long l;
299
300 p = pstr;
301 l = 0;
302 for(i=0; i<idx; i++) {
303 j = *pstr++;
304 if(isdigit(j))
305 j =- '0';
306 if(j<0 || j>=10)
307 return(0);
308 l = (l<<3) + (l<<1) + j; /* l = l*10 + j*/
309 }
310 *pnum = l;
311 return(1);
312 }
313
314 /*
315 * method for looking up entries in the main table
316 *
317 * Note: The entry to be looked up must be placed at the end
318 * of the main table. The global cell 'lmte'(last main
319 * entry) points to the next available entry in the main
320 * table. The address of an initial reference table must
321 * also be provided.
322 *
323 * 1) Compute the hash code for the symbol and add it to the base address
324 * of the initial reference table given as input. Thus, two words are
325 * accessed which define the chain on which the symbol must be if it
326 * is in the table at all.
327 *
328 * 2) Alter the table link of the last symbol in the chain so that it
329 * points to the symbol being looked up. Note that the symbol to be
330 * looked up is always placed at the end of the main table before
331 * calling the lookup routine. This essentially adds one more element
332 * to the end of the chain, namely the symbol to be looked up.
333 *
334 * 3) Now start at the first symbol in the chain and follow the chain
335 * looking for a symbol equal to the smbol being looked up. It is
336 * guaranteed that such a symbol will be found because it is always
337 * the last symbol on the chain.
338 *
339 * 4) When the symbol is found, check to see if it is the last symbol
340 * on the chain. If not, the symbol being looked for is in the table
341 * and has been found. If it is the last symbol, the symbol being
342 * looked up is not in the table.
343 *
344 * 5) In the case the looked up symbol is not found, it is usually added
345 * to the end of the table. This is done simply b changing the
346 * initial reference table entry which points to the previous
347 * last symbol on the chain so that is now points to the symbol at the
348 * end of the main table. In case the symbol just looked up is not to
349 * be added to the main table then no action is needed . This means
350 * that the table link of the last symbol on a chain may point any-
351 * where.
352 *
353 * look up entry in the main table
354 * call with:
1File: SYMT.C Page 7
355 * address of initial reference table
356 * entry to be looked up at the end of the main table
357 * returns:
358 * a pointer to the entry. if this pointer is equal to
359 * lmte then the symbol was not previously in the table.
360 */
361
362 char *lemt(airt,oplook)
363 char **airt;
364 int oplook; /* if true then looking in opcode table */
365 {
366 register char *mtpt;
367 register int *p1, *p2;
368 register int i, j;
369
370 if (oplook) { /* [vlh] get rid of preceding '.', to lowercase */
371 if (lmte->name[0]=='.') {
372 lmte->name[NAMELEN-1] = NULL; /* in case of '.' */
373 j = 1;
374 }
375 else j = 0;
376 for (i=0; j<NAMELEN; i++, j++)
377 lmte->name[i] = tolower(lmte->name[j]);
378 }
379
380 pirt = airt + hash(); /*hashed ptr to irt*/
381 mtpt = pirt->irfe; /*pointer to first entry in chain*/
382 if(!mtpt) /*empty chain*/
383 mtpt = lmte; /*start at end of main table*/
384 else
385 (pirt->irle)->tlnk = lmte; /*last entry in chain is new symbol*/
386
387 /*loop to locate entry in main table*/
388 lemtl:
389 p1 = &mtpt->name[0];
390 p2 = &lmte->name[0];
391 i = NAMELEN/(sizeof i);
392 while(i) {
393 if(*p1++ != *p2++) {
394 mtpt = mtpt->tlnk; /*go to next entry in chain*/
395 goto lemtl;
396 }
397 i--;
398 }
399 return(mtpt);
400 }
401
402 /* compute a hash code for the last entry in the main table*/
403 /* returns the hash code*/
404 hash()
405 {
406 register int i;
407 register ht1;
408 register char *p;
409
410 ht1 = 0;
411 p = &lmte->name[0];
412 for(i=0; i<NAMELEN; i++)
413 ht1 =+ *p++;
1File: SYMT.C Page 8
414 return(ht1&(SZIRT-2)); /*make hash code even and between 0 & SZIRT-2*/
415 }
416
417 /*
418 * Make an entry in the main table
419 * assumes :
420 * entry to be made is pointed at by lmte
421 * pirt points to the correct initial reference table entry.
422 */
423 mmte()
424 {
425 pirt->irle = lmte; /*pointer to last entry in chain*/
426 if(pirt->irfe == 0) /*first entry in chain*/
427 pirt->irfe = lmte;
428 lmte =+ STESIZE; /*bump last main table entry pointer*/
429 if(lmte>=emte) { /*main table overflow*/
430 if(sbrk(STESIZE*ICRSZMT) == -1){ /*get more memory*/
431 rpterr("symbol table overflow\n");
432 endit();
433 }
434 else {
435 emte =+ STESIZE*ICRSZMT; /*move end of main table*/
436 cszmt =+ ICRSZMT;
437 }
438 }
439 }
440
441 /*
442 * make an entry in the main table for a directive
443 * call with:
444 * pointer to string containing directive name
445 * address of routine to handle directive in pass one
446 * address of routine to handle directive in pass two
447 */
448 mdemt(mdstr,dirnum)
449 char *mdstr;
450 {
451 register char *mdept;
452
453 pack(mdstr,lmte); /*pack name at end of main table*/
454 mdept=lemt(oirt,TRUE); /*look up in opcode table*/
455 if(mdept != lmte) { /*best not be there already*/
456 uerr(5);
457 abort();
458 return;
459 }
460 mmte(); /*make main table entry*/
461 mdept->flags =| OPDR|SYIN; /*directive*/
462 mdept->vl1 = dirnum; /*directive #*/
463 }
464
465 /*
466 * pack a string into an entry in the main table
467 * call with:
468 * pointer to the string
469 * pointer to desired entry in the main table
470 */
471 pack(apkstr,apkptr)
472 char *apkstr, *apkptr;
1File: SYMT.C Page 9
473 {
474 register i;
475 register char *pkstr, *pkptr;
476
477 pkstr = apkstr;
478 pkptr = apkptr;
479 i = NAMELEN;
480 while(*pkstr && i) {
481 *pkptr++ = *pkstr++;
482 i--;
483 }
484 while(i--)
485 *pkptr++ = '\0'; /*pad with nulls*/
486 }
487
488 /* function to get characters for source file*/
489 int xcol = 0; /* Column Counter */
490 int spcnt = 0; /* Space count for tab expansion */
491 gchr()
492 {
493 register chr1;
494
495 if(peekc) {
496 chr1 = peekc;
497 peekc = 0;
498 if(chr1 != SOH)
499 xcol--;
500 }
501 else if (spcnt)
502 {
503 spcnt--;
504 return(' ');
505 }
506 else
507 {
508 gchr1:
509 if(sbuflen<=0){ /*nothing on input buffer*/
510 sbuflen=read(ifn,sbuf,512); /*read in source*/
511 if(sbuflen<=0)
512 return(EOF); /*end of file*/
513 psbuf = sbuf;
514 }
515 chr1 = *psbuf++;
516 sbuflen--;
517 }
518 if (chr1 == SOH) /*preprocessor flag*/
519 goto gchr1; /*ignore it*/
520 if(chr1 == EOLC) { /*end of line*/
521 xcol = -1; /* Clear column counter */
522 if(!p2flg) /*pass 1 only*/
523 absln++;
524 }
525 if(chr1=='\t') /*convert tabs to spaces*/
526 {
527 spcnt += 7 - (xcol&7); /* This many spaces */
528 xcol += spcnt; /* New column number */
529 chr1 = ' ';
530 }
531 xcol++;
1File: SYMT.C Page 10
532 return(chr1);
533 }
534
535 /*
536 * write out intermediate text for one statement
537 * call with
538 * the it for the statement in stbuf
539 */
540 wostb()
541 {
542 register int woix;
543 register short *itwo;
544 register int i;
545
546 if(stbuf[0].itty != ITBS) abort(); /*not beginning of stmt*/
547 itwo = &stbuf;
548 woix = stbuf[0].itrl & 0377; /*unsigned byte*/
549 while(woix--) {
550 for(i=0; i<(sizeof stbuf[0])/(sizeof *itwo); i++) {
551 doitwr(*itwo++);
552 }
553 }
554 /* debug(); //call debug package*/
555 }
556
557 doitwr(word)
558 short word;
559 {
560 short i;
561
562 if( pitix < itbuf || pitix > &itbuf[ITBSZ] ) {
563 printf("doitwr: it buffer botch\n");
564 endit();
565 }
566 if( pitix >= &itbuf[ITBSZ]) {
567 if(write(itfn,itbuf,ITBSZ*(sizeof i)) != ITBSZ*(sizeof i)) {
568 rpterr("it write error errno=%o\n",errno);
569 endit();
570 }
571 pitix = itbuf;
572 }
573 *pitix++ = word;
574 }
575
576 /*
577 * user source error
578 * call with:
579 * number to indicate reason for error
580 * types the error number and the line number on which
581 * the error occured.
582 */
583 uerr(errn)
584 {
585 if(p2flg) { /*pass 2 gets two ampersands*/
586 in_err++; /* [vlh] instrlen <- pass1 estimation */
587 printf("&& %d: %s\n",p2absln,ermsg[errn-1]);
588 }
589 else
590 printf("& %d: %s\n",(fchr==EOLC)?absln-1:absln,ermsg[errn-1]);
1File: SYMT.C Page 11
591 nerror++;
592 }
593 /*
594 * user error that causes the statement to be abandoned
595 * call with:
596 * error number
597 */
598 xerr(xern)
599 {
600 uerr(xern); /*type error message*/
601 if(!p2flg) /*pass one*/
602 igrst(); /*pass rest of source*/
603 }
604
605 /* abort the assembly*/
606 abort()
607 {
608 rpterr("as68 abort\n");
609 nerror++;
610 endit();
611 }
612
613 /*ignore rest of statement*/
614 igrst()
615 {
616 while(fchr!=EOLC && fchr!=EOF) /*until end of line*/
617 fchr=gchr();
618 while((fchr=gchr())==EOLC) ; /*ignore null lines*/
619 }
620
621 /*ignore blanks after a label*/
622 ligblk()
623 {
624 if(fchr == EOF) return;
625 igblk();
626 if(fchr==EOLC) {
627 fchr=gchr();
628 ligblk();
629 }
630 }
631
632 rubout()
633 {
634 nerror = -1;
635 endit();
636 }
637
638 /* exit from the assembler*/
639 endit()
640 {
641 LASTCHTFN = itfnc;
642 unlink(tfilname); /*delete temporary files*/
643 LASTCHTFN = trbfnc;
644 unlink(tfilname);
645 LASTCHTFN = dafnc;
646 unlink(tfilname);
647 LASTCHTFN = drbfnc;
648 unlink(tfilname);
649 if(nerror != -1) { /*not rubout*/
1File: SYMT.C Page 12
650 if(ftudp)
651 putchar('\n');
652 }
653 if(nerror > 0) {
654 fprintf(stderr,"& %d errors\n",nerror);
655 }
656 if (initflg)
657 unlink(ldfn); /* [vlh] get rid of empty .o file */
658 exit(nerror!=0);
659 }
660
661 /*
662 * open files
663 * call with:
664 * pointer to name of file to open
665 * flag for how to open
666 * 0 => read
667 * 1 => write
668 */
669 openfi(pname,hflag)
670 char *pname;
671 {
672 register fd;
673
674 fd = (hflag==1) ? creat(pname,0666,1) : open(pname,hflag,1);
675 if(fd < 0) { /*open failed*/
676 rpterr("can't open %s errno=%o\n",pname,errno);
677 endit();
678 }
679 return(fd);
680 }
681
682 /* get a temp file for the intermediate text*/
683 char lastfile = 'A';
684 gettempf()
685 {
686 register i,j;
687 register char *p;
688
689 LASTCHTFN = lastfile++; /* Creat temp name */
690 if((j=creat(tfilname,0600,1)) >= 0)
691 return(j); /* File created OK */
692 rpterr("Unable to open temporary file\n");
693 endit();
694 }
695
696 /* move label name from lbt to main table entry pointed to by lmte*/
697 setname()
698 {
699 register i;
700 register int *p1, *p2;
701
702 p1 = &lmte->name[0];
703 for(p2 = &lbt[0]; p2 < &lbt[NAMELEN]; ) {
704 *p1++ = *p2;
705 *p2++ = 0;
706 }
707 }
708
1File: SYMT.C Page 13
709 /* get the initialized main table and initial reference tables from*/
710 /* the initialize file*/
711 getsymtab()
712 {
713 long j; /* length for read / write */
714 register char **p;
715 register struct symtab *p1;
716 register char *p2;
717 register fd,i;
718
719 if((fd=open(initfnam,0,1)) < 0) {
720 rerr:
721 printf("& Unable to read init file: %s\n", initfnam);
722 endit();
723 }
724 if(read(fd,sirt,SZIRT*(sizeof sirt[0])) != SZIRT*(sizeof sirt[0])) {
725 goto rerr;
726 }
727
728 if(read(fd,oirt,SZIRT*(sizeof sirt[0])) != SZIRT*(sizeof sirt[0]))
729 goto rerr;
730
731 if(read(fd,&j,(sizeof j)) != (sizeof j)) /* Read Count */
732 goto rerr; /* Y-U-K!!! */
733
734 if((i=read(fd,bmte,(int)j)) != j) /* Read table */
735 goto rerr;
736
737 if((i%STESIZE) != 0)
738 goto rerr;
739
740 lmte = bmte + i;
741 p2 = bmte-1;
742 for(p=sirt; p<&sirt[SZIRT]; p++) {
743 if(*p)
744 *p =+ (long)p2;
745 }
746 for(p=oirt; p<&oirt[SZIRT]; p++) {
747 if(*p)
748 *p =+ (long)p2;
749 }
750 for(p1=bmte; p1<lmte; p1++) {
751 if(p1->tlnk)
752 p1->tlnk =+ (long)p2;
753 }
754 close(fd);
755 }
756
757 /* write the initialization file*/
758 putsymtab()
759 {
760 long j;
761 register char **p;
762 register struct symtab *p1;
763 register char *p2;
764 register fd,i;
765
766 if((fd=creat(initfnam,0644,1))<0) {
767 printf("& Cannot create init: %s\n", initfnam);
1File: SYMT.C Page 14
768 return;
769 }
770 /*
771 * change all pointers so that they are relative to the beginning
772 * of the symbol table
773 */
774 p2 = bmte-1;
775 for(p=sirt; p<&sirt[SZIRT]; p++) {
776 if(*p)
777 *p =- (long)p2;
778 }
779 for(p=oirt; p<&oirt[SZIRT]; p++) {
780 if(*p)
781 *p =- (long)p2;
782 }
783 for(p1=bmte; p1<lmte; p1++) {
784 if(p1->tlnk)
785 p1->tlnk =- (long)p2;
786 }
787
788 if(write(fd,sirt,SZIRT*(sizeof sirt[0])) != SZIRT*(sizeof sirt[0])) {
789 goto werr;
790 }
791
792 if(write(fd,oirt,SZIRT*(sizeof oirt[0])) != SZIRT*(sizeof oirt[0]))
793 goto werr;
794
795 i = lmte - bmte; /*length of current main table*/
796 if((i % STESIZE) != 0) {
797 goto werr;
798 }
799 j = i;
800 if(write(fd,&j,(sizeof j)) != (sizeof j)) /* Y-U-K!! */
801 goto werr;
802
803 if(write(fd,bmte,i) != i) {
804 werr:
805 printf("& Write error on init file: %s\n",initfnam);
806 return;
807 }
808 close(fd);
809 }
810
811 /* print an error on file descriptor 2*/
812 /* used for errors with disasterous consequences*/
813 rpterr(ptch,x1,x2,x3,x4,x5,x6)
814 char *ptch;
815 {
816 if(prtflg==0) /* Check for paging output */
817 page(); /* Perform page checks */
818 fprintf(stderr,"& %d: ",absln);
819 fprintf(stderr,ptch,x1,x2,x3,x4,x5,x6);
820 }
821
822 /* set the file name for the relocatable object file (sourcefile.o)*/
823 setldfn(ap)
824 char *ap;
825 {
826 register char *p1,*p2;
1File: SYMT.C Page 15
827
828 p1 = ap;
829 p2 = ldfn;
830 while(*p1) {
831 *p2++ = *p1++;
832 }
833 if(*(p2-2) != '.') { /*not name.?*/
834 *p2++ = '.';
835 *p2++ = 'o';
836 }
837 else { /* is name.? */
838 *(p2-1) = 'o';
839 }
840 *p2 = '\0';
841 }
842
843 savelab()
844 {
845 register int *p1, *p2;
846
847 p2 = &lmte->name[0];
848 for(p1= &tlab1[0]; p1 < &tlab1[NAMELEN]; )
849 *p1++ = *p2++;
850 }

19
CPM OPERATING SYSTEMS/CPM 68K/1.0X SOURCES/v102/as68/up9.sub Normal file
View File

@@ -0,0 +1,19 @@
e:vax DIR.C s
e:vax EXPR.C s
e:vax MAIN.C s
e:vax MISC.C s
e:vax PASS1A.C s
e:vax PASS2.C s
e:vax MAKE.SUB s
e:vax STRNCMP.C s
e:vax SYMT.C s
e:vax VERSION.C s
e:vax AS68.H s
e:vax COUT.H s
e:vax CTYPE.H s
e:vax MACHINE.H s
e:vax RELINK.SUB s
e:vax MACHINE.11 s
e:vax MACHINE.68K s
e:vax MACHINE.VAX s
e:vax AS68INIT. s

1
CPM OPERATING SYSTEMS/CPM 68K/1.0X SOURCES/v102/as68/version.c Normal file
View File

@@ -0,0 +1 @@
char *version "@(#) Tue Nov 23 14:31";

2
CPM OPERATING SYSTEMS/CPM 68K/1.0X SOURCES/v102/as68/version.lis Normal file
View File

@@ -0,0 +1,2 @@
1File: VERSION.C Page 1
1 char *version "@(#) Tue Nov 23 14:31";

15
CPM OPERATING SYSTEMS/CPM 68K/1.0X SOURCES/v102/as68/vmake.com Normal file
View File

@@ -0,0 +1,15 @@
$ asm
$ !
$ ! as68 Version 2.3 make file for VMS
$ !
$ set noon
$ copy machine.vax machine.h
$ cx AS68INIT
$ cx DIR
$ cx EXPR
$ cx MAIN
$ cx MISC
$ cx PASS1A
$ cx PASS2
$ cx SYMT
$ @vrelink

1
CPM OPERATING SYSTEMS/CPM 68K/1.0X SOURCES/v102/as68/vrelink.com Normal file
View File

@@ -0,0 +1 @@
$ clink AS68INIT,DIR,EXPR,MAIN,PASS1A,PASS2,SYMT,MISC,lib:klib/lib as68

26
CPM OPERATING SYSTEMS/CPM 68K/1.0X SOURCES/v102/as68/vsend.com Normal file
View File

@@ -0,0 +1,26 @@
$ set noon
$ vsend AS68.H
$ vsend AS68INIT.
$ vsend AS68INIT.C
$ vsend COUT.H
$ vsend CTYPE.H
$ vsend DIR.C
$ vsend EXPR.C
$ vsend LIST.COM
$ vsend MACHINE.11
$ vsend MACHINE.68K
$ vsend MACHINE.H
$ vsend MACHINE.VAX
$ vsend MAIN.C
$ vsend MAKE.SUB
$ vsend MISC.C
$ vsend PASS1A.C
$ vsend PASS2.C
$ vsend RELINK.SUB
$ vsend STRNCMP.C
$ vsend SYMT.C
$ vsend UP9.SUB
$ vsend VERSION.C
$ vsend VMAKE.COM
$ vsend VRELINK.COM
$ vsend done

13
CPM OPERATING SYSTEMS/CPM 68K/1.0X SOURCES/v102/as68/xer.com Normal file
View File

@@ -0,0 +1,13 @@
$ xer AS68INIT.LIS
$ xer DIR.LIS
$ xer EXPR.LIS
$ xer MAIN.LIS
$ xer MISC.LIS
$ xer PASS1A.LIS
$ xer PASS2.LIS
$ xer SYMT.LIS
$ xer VERSION.LIS
$ xer AS68.LST
$ xer COUT.LST
$ xer CTYPE.LST
$ xer MACHINE.LST

18
CPM OPERATING SYSTEMS/CPM 68K/1.0X SOURCES/v102/as68/xer.com.1 Normal file
View File

@@ -0,0 +1,18 @@
Directory DRB0:[STEVE.CPM68K.V102.AS68]
AS68INIT.LIS;1
DIR.LIS;1
EXPR.LIS;1
MAIN.LIS;1
MISC.LIS;1
PASS1A.LIS;1
PASS2.LIS;1
SYMT.LIS;1
VERSION.LIS;1
AS68.LST;1
COUT.LST;1
CTYPE.LST;1
MACHINE.LST;1
Total of 13 files.