├── .gitignore
├── Makefile
├── README.md
├── a56.h
├── a56.key
├── a56.y
├── appveyor.yml
├── examples
    ├── Makefile
    ├── README
    ├── caltone.a56
    ├── caltone.inc
    ├── chorus.a56
    ├── defs.inc
    ├── disp.a56
    ├── flange.a56
    ├── intequ.inc
    ├── ioequ.inc
    ├── memtest.a56
    ├── pink.a56
    ├── reverb.a56
    ├── sixcomb.a56
    ├── sloader.a56
    ├── tdsg.a56
    ├── test-dac.a56
    ├── test-int.a56
    └── thru.a56
├── frac2int.c
├── getopt.c
├── keybld.c
├── lex.c
├── main.c
├── subs.c
├── tok.awk
├── toomf.c
└── torom.c


/.gitignore:
--------------------------------------------------------------------------------
 1 | # Compilation results
 2 | *.o
 3 | /keybld
 4 | /toomf
 5 | /a56
 6 | 
 7 | # Auto-generated files
 8 | /toktab.c
 9 | /gram.c
10 | /gram.h
11 | /kparse.c
12 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
  1 | #######################################################
  2 | #
  3 | #  a56 - a DSP56001 assembler
  4 | #
  5 | #  Written by Quinn C. Jensen
  6 | #  July 1990
  7 | #
  8 | #######################################################
  9 | 
 10 | # environment definitions
 11 | # uncomment the ones you like
 12 | 
 13 | # generic unix
 14 | CC = cc
 15 | HOSTCC = cc
 16 | YACC = yacc
 17 | CCDEFS = -DLDEBUG
 18 | MV = mv
 19 | YTABC = y.tab.c
 20 | YTABH = y.tab.h
 21 | POSTPROCESS = echo
 22 | 
 23 | # gcc & bison
 24 | #CC = gcc
 25 | #HOSTCC = gcc
 26 | #YACC = bison -y
 27 | #CCDEFS =
 28 | #MV = mv
 29 | #YTABC = y.tab.c
 30 | #YTABH = y.tab.h
 31 | #POSTPROCESS = echo
 32 | 
 33 | # Delorie's DOS gcc (from ftp://omnigate.clarkson.edu/pub/msdos/djgpp)
 34 | #CC = gcc
 35 | #HOSTCC = gcc
 36 | #YACC = bison -y
 37 | #CCDEFS =
 38 | #MV = ren
 39 | #YTABC = y_tab.c
 40 | #YTABH = y_tab.h
 41 | #POSTPROCESS = coff2exe
 42 | 
 43 | # gcc cross-compile to go32 environment
 44 | #CC = i386-go32-gcc
 45 | #HOSTCC = cc
 46 | #YACC = yacc
 47 | #CCDEFS =
 48 | #MV = mv
 49 | #YTABC = y.tab.c
 50 | #YTABH = y.tab.h
 51 | #POSTPROCESS = echo
 52 | 
 53 | #######################################################
 54 | 
 55 | # -O or -g
 56 | #DEBUG = -O -Olimit 3000
 57 | DEBUG = -O
 58 | 
 59 | SRCS = main.c a56.y lex.c subs.c getopt.c kparse.key
 60 | OBJS = main.o gram.o lex.o toktab.o subs.o getopt.o kparse.o
 61 | 
 62 | DEFINES = $(CCDEFS)
 63 | #DEFINES = -DYYDEBUG -DLDEBUG $(CCDEFS)
 64 | 
 65 | CFLAGS = $(DEBUG) $(DEFINES)
 66 | 
 67 | all:	keybld a56 toomf
 68 | 
 69 | a56:	$(OBJS)
 70 | 	$(CC) $(CFLAGS) -o a56 $(OBJS) -lm
 71 | 	@$(POSTPROCESS) a56
 72 | 
 73 | keybld:	keybld.o ksubs.o
 74 | 	$(HOSTCC) $(CFLAGS) -o keybld keybld.o ksubs.o
 75 | 	@$(POSTPROCESS) keybld
 76 | 
 77 | keybld.o:	keybld.c
 78 | 	$(HOSTCC) $(CFLAGS) -c keybld.c
 79 | 
 80 | ksubs.o:	subs.c
 81 | 	$(HOSTCC) $(CFLAGS) -c subs.c
 82 | 	$(MV) subs.o ksubs.o
 83 | 
 84 | lex.o:	lex.c gram.h
 85 | 
 86 | kparse.c:	a56.key keybld
 87 | 	$(abspath keybld) < a56.key > kparse.c
 88 | 
 89 | gram.c gram.h:	a56.y
 90 | 	@echo "[expect 2 shift/reduce conflicts here]"
 91 | 	$(YACC) -d a56.y
 92 | 	$(MV) $(YTABC) gram.c
 93 | 	$(MV) $(YTABH) gram.h
 94 | 
 95 | toktab.c:	gram.h
 96 | 	awk -f tok.awk < gram.h > toktab.c
 97 | 
 98 | y.output:	a56.y
 99 | 	$(YACC) -v a56.y
100 | 
101 | toomf:	toomf.o
102 | 	$(CC) -o toomf $(CFLAGS) toomf.o
103 | 	@$(POSTPROCESS) toomf
104 | 
105 | torom:	torom.o subs.o
106 | 	$(CC) -o torom $(CFLAGS) torom.o subs.o
107 | 
108 | tape:	toktab.c
109 | 	csh -c 'tar cvbf 1 - `cat files` | gzip > a56.tar.gz'
110 | 
111 | main.o gram.o lex.o:	a56.h
112 | 
113 | clean:	; rm -f a56 toomf y.output *.o *.out tmp *.bak a56.tar.gz keybld
114 | 
115 | spotless:	clean
116 | 	rm -f gram.c lexyy.c gram.h toktab.c kparse.c
117 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | 
  2 | *Based on "a56 - a DSP56001 assembler - version 1.3"*
  3 | 
  4 | ```C
  5 | /*
  6 |  * Copyright (C) 1990-1998 Quinn C. Jensen
  7 |  *
  8 |  * Permission to use, copy, modify, distribute, and sell this software
  9 |  * and its documentation for any purpose is hereby granted without fee,
 10 |  * provided that the above copyright notice appear in all copies and
 11 |  * that both that copyright notice and this permission notice appear
 12 |  * in supporting documentation.  The author makes no representations
 13 |  * about the suitability of this software for any purpose.  It is
 14 |  * provided "as is" without express or implied warranty.
 15 |  *
 16 |  */
 17 | ```
 18 | 
 19 | # Overview
 20 | 
 21 | This program was written as a vehicle to learn the intricacies
 22 | of the DSP56001 instruction set, and to provide a tool for Unix-based
 23 | DSP code development (for those of us without a NeXT machine.)
 24 | 
 25 | The assembler probably generates bogus code here and there, and no doubt
 26 | does not handle all of the syntax.  We welcome all comments, fixes and 
 27 | enhancements.
 28 | 
 29 | 
 30 | # Building
 31 | 
 32 | Type `make`.
 33 | 
 34 | The resulting program, a56, is used as follows:
 35 | 
 36 | ```
 37 | a56 [-b] [-l] [-o output-file] file [...]
 38 | ```
 39 | 
 40 | An assembler listing is sent to the standard-output and an ascii-formatted
 41 | object file (a56.out) is produced.  The `-b` option adds binary to the listing.
 42 | `-l` causes included files to be listed.  `-o` directs the output to the
 43 | specified file rather than the default, a56.out.
 44 | 
 45 | A separate program, toomf, converts a56.out into "OMF" format suitable for 
 46 | downloading to the 56001 via the sloader.a56 program.
 47 | 
 48 | ```
 49 | toomf < a56.out > file.omf
 50 | ```
 51 | 
 52 | 
 53 | # Syntax
 54 | 
 55 | The intent was to provide compatibility with Motorola assembler's syntax.
 56 | But since the author did not have Motorola's assembler or its documentation,
 57 | it is no doubt far from compatible.  Only a few pseudo-ops are implemented--
 58 | probably only partially.
 59 | 
 60 | Macros are not supported, except through the use of an external macro
 61 | preprocessor, such as /lib/cpp.  To facilitate cpp macro expansion, multiple
 62 | assembler statements on a single input line are delimited with an `@`, e.g.:
 63 | 
 64 | ```C
 65 | #define JCHEQ(c,label)	move #c,x0 @cmp x0,a @jeq label
 66 | 
 67 | #define JCHNE(c,label)	move #c,x0 @cmp x0,a @jne label
 68 | ```
 69 | 
 70 | 
 71 | ## Supported pseudo-ops
 72 | 
 73 | The following is a list of the pseudo-ops that are recognized:
 74 | 
 75 | ```Assembly
 76 | <symbol> = <expression>                         ;assign a symbol
 77 | <label> EQU <expression>                        ;ditto
 78 | 
 79 | ALIGN <number>                                  ;set location pointer
 80 |                                                 ;to next integral
 81 |                                                 ;multiple of <number>
 82 | 
 83 | ORG <space:> <expression>                       ;new location pointer
 84 | ORG <space:> <expression>, <space:> <expression>
 85 | 
 86 | DC <dc_list>                                    ;declare constants
 87 | 
 88 | DS <number>                                     ;reserve <number>
 89 |                                                 ;words of space
 90 | 
 91 | <label> DSM <number>                            ;reserve space for
 92 |                                                 ;properly aligned
 93 |                                                 ;modulo-addressed
 94 |                                                 ;buffer of size
 95 |                                                 ;<number>, assigning
 96 |                                                 ;the aligned starting
 97 |                                                 ;address to <label>
 98 | 
 99 | PAGE <number>, <number>, <number>, <number>     ;ignored
100 | 
101 | INCLUDE <file>                                  ;file inclusion
102 | 
103 | END                                             ;end
104 | ```
105 | 
106 | In addition, a `PSECT` pseudo-op was implemented.  It allows program sections
107 | to be defined and bopped in and out of, each with its own location counter and
108 | space.  The Motorola assembler probably does not have this pseudo-op, but no
109 | doubt supports the concept in some way.
110 | 
111 | ```Assembly
112 | PSECT <name> <space:><begin_addr>:<end_addr>    ;define
113 | 
114 | PSECT <name>                                    ;switch to psect <name>
115 | ```
116 | 
117 | ## Examples
118 | 
119 | Example assembly can be found in the "examples" folder.
120 | 


--------------------------------------------------------------------------------
/a56.h:
--------------------------------------------------------------------------------
 1 | /*******************************************************
 2 |  *
 3 |  *  a56 - a DSP56001 assembler
 4 |  *
 5 |  *  Written by Quinn C. Jensen
 6 |  *  July 1990
 7 |  *
 8 |  *******************************************************\
 9 | 
10 | /*
11 |  * Copyright (C) 1990-1994 Quinn C. Jensen
12 |  *
13 |  * Permission to use, copy, modify, distribute, and sell this software
14 |  * and its documentation for any purpose is hereby granted without fee,
15 |  * provided that the above copyright notice appear in all copies and
16 |  * that both that copyright notice and this permission notice appear
17 |  * in supporting documentation.  The author makes no representations
18 |  * about the suitability of this software for any purpose.  It is
19 |  * provided "as is" without express or implied warranty.
20 |  *
21 |  */
22 | 
23 | /*
24 |  *  a56.h - general definitions
25 |  *
26 |  */
27 | 
28 | #include <stdio.h>
29 | 
30 | #ifndef TRUE
31 | #define TRUE 1
32 | #define FALSE 0
33 | #define NOT !
34 | typedef int BOOL;
35 | #endif
36 | 
37 | struct sym {
38 | 	char *name;
39 | 	struct n {
40 | 		short type;
41 | #define UNDEF -1
42 | #define INT 0
43 | #define FLT 1
44 | 		short seg;
45 | #define NONE 0
46 | #define PROG 1
47 | #define XDATA 2
48 | #define YDATA 3
49 | #define LDATA 4
50 | #define ANY 5
51 | 		union val {
52 | 			int i;
53 | 			double f;
54 | 		} val;
55 | 	} n;
56 | 	struct sym *next;
57 | } *find_sym();
58 | 
59 | extern int pass;
60 | 
61 | char *alloc(int size);
62 | 
63 | #define NEW(object) ((object *)alloc(sizeof(object)))
64 | 
65 | #define MAX_NEST 20		/* maximum include file nesting */
66 | 
67 | struct inc {
68 | 	char *file;
69 | 	FILE *fp;
70 | 	int line;
71 | };
72 | extern struct inc inc[];
73 | extern int inc_p;
74 | #define curfile inc[inc_p].file
75 | #define curline inc[inc_p].line
76 | 
77 | extern int ldebug;
78 | 
79 | struct psect {
80 | 	char *name;
81 | 	int seg;
82 | 	unsigned int pc, bottom, top;
83 | 	struct psect *next;
84 | } *find_psect(), *new_psect();
85 | 
86 | FILE *open_read(), *open_write(), *open_append();
87 | 
88 | 	/* save string s somewhere */
89 | #define strsave(s) ((s) != NULL ? \
90 | 		(char *)strcpy((char *)malloc(strlen(s)+1),(s)) : NULL)
91 | 
92 | 	/* after a call to fgets(), remove the newline character */
93 | #define rmcr(s) {if (s[strlen(s)-1] == '\n') s[strlen(s)-1] = '\0';};
94 | 
95 | #define ASSERT(expr, str) \
96 | 		if(expr) fprintf(stderr, "ASSERT: %s: line %d: %s\n", __FILE__, __LINE__, str);
97 | 


--------------------------------------------------------------------------------
/a56.key:
--------------------------------------------------------------------------------
  1 | .code	#include "a56.h"
  2 | .code	#include "gram.h"
  3 | X:		{return XMEM;}
  4 | Y:		{return YMEM;}
  5 | L:		{return LMEM;}
  6 | P:		{return PMEM;}
  7 | A10		{return A10;}
  8 | A		{return AAAA;}
  9 | B10		{return B10;}
 10 | B		{return BBBB;}
 11 | AB		{return AABB;}
 12 | BA		{return BBAA;}
 13 | X		{return XXXX;}
 14 | Y		{return YYYY;}
 15 | SR		{return SR;}
 16 | MR		{return MR;}
 17 | CCR		{return CCR;}
 18 | OMR		{return OMR;}
 19 | SP		{return SP;}
 20 | SSH		{return SSH;}
 21 | SSL		{return SSL;}
 22 | LA		{return LA;}
 23 | LC		{return LC;}
 24 | A0		{yylval.ival = 0; return AREG;}
 25 | A1		{yylval.ival = 1; return AREG;}
 26 | A2		{yylval.ival = 2; return AREG;}
 27 | B0		{yylval.ival = 0; return BREG;}
 28 | B1		{yylval.ival = 1; return BREG;}
 29 | B2		{yylval.ival = 2; return BREG;}
 30 | M0		{yylval.ival = 0; return MREG;}
 31 | M1		{yylval.ival = 1; return MREG;}
 32 | M2		{yylval.ival = 2; return MREG;}
 33 | M3		{yylval.ival = 3; return MREG;}
 34 | M4		{yylval.ival = 4; return MREG;}
 35 | M5		{yylval.ival = 5; return MREG;}
 36 | M6		{yylval.ival = 6; return MREG;}
 37 | M7		{yylval.ival = 7; return MREG;}
 38 | N0		{yylval.ival = 0; return NREG;}
 39 | N1		{yylval.ival = 1; return NREG;}
 40 | N2		{yylval.ival = 2; return NREG;}
 41 | N3		{yylval.ival = 3; return NREG;}
 42 | N4		{yylval.ival = 4; return NREG;}
 43 | N5		{yylval.ival = 5; return NREG;}
 44 | N6		{yylval.ival = 6; return NREG;}
 45 | N7		{yylval.ival = 7; return NREG;}
 46 | R0		{yylval.ival = 0; return RREG;}
 47 | R1		{yylval.ival = 1; return RREG;}
 48 | R2		{yylval.ival = 2; return RREG;}
 49 | R3		{yylval.ival = 3; return RREG;}
 50 | R4		{yylval.ival = 4; return RREG;}
 51 | R5		{yylval.ival = 5; return RREG;}
 52 | R6		{yylval.ival = 6; return RREG;}
 53 | R7		{yylval.ival = 7; return RREG;}
 54 | X0		{yylval.ival = 0; return XREG;}
 55 | X1		{yylval.ival = 1; return XREG;}
 56 | Y0		{yylval.ival = 0; return YREG;}
 57 | Y1		{yylval.ival = 1; return YREG;}
 58 | ABS		{return OP_ABS;}
 59 | ADC		{return OP_ADC;}
 60 | ADD		{return OP_ADD;}
 61 | ADDL	{return OP_ADDL;}
 62 | ADDR	{return OP_ADDR;}
 63 | ASL		{return OP_ASL;}
 64 | ASR		{return OP_ASR;}
 65 | CLR		{return OP_CLR;}
 66 | CMP		{return OP_CMP;}
 67 | CMPM	{return OP_CMPM;}
 68 | DEC		{return OP_DEC;}
 69 | DIV		{return OP_DIV;}
 70 | INC		{return OP_INC;}
 71 | MAC		{return OP_MAC;}
 72 | MACR	{return OP_MACR;}
 73 | MPY		{return OP_MPY;}
 74 | MPYR	{return OP_MPYR;}
 75 | NEG		{return OP_NEG;}
 76 | NORM	{return OP_NORM;}
 77 | RND		{return OP_RND;}
 78 | SBC		{return OP_SBC;}
 79 | SUB		{return OP_SUB;}
 80 | SUBL	{return OP_SUBL;}
 81 | SUBR	{return OP_SUBR;}
 82 | TCC		{yylval.cond = 0x0; return OP_TCC;}
 83 | THS		{yylval.cond = 0x0; return OP_TCC;}
 84 | TGE		{yylval.cond = 0x1; return OP_TCC;}
 85 | TNE		{yylval.cond = 0x2; return OP_TCC;}
 86 | TPL		{yylval.cond = 0x3; return OP_TCC;}
 87 | TNN		{yylval.cond = 0x4; return OP_TCC;}
 88 | TEC		{yylval.cond = 0x5; return OP_TCC;}
 89 | TLC		{yylval.cond = 0x6; return OP_TCC;}
 90 | TGT		{yylval.cond = 0x7; return OP_TCC;}
 91 | TCS		{yylval.cond = 0x8; return OP_TCC;}
 92 | TLO		{yylval.cond = 0x8; return OP_TCC;}
 93 | TLT		{yylval.cond = 0x9; return OP_TCC;}
 94 | TEQ		{yylval.cond = 0xA; return OP_TCC;}
 95 | TMI		{yylval.cond = 0xB; return OP_TCC;}
 96 | TNR		{yylval.cond = 0xC; return OP_TCC;}
 97 | TES		{yylval.cond = 0xD; return OP_TCC;}
 98 | TLS		{yylval.cond = 0xE; return OP_TCC;}
 99 | TLE		{yylval.cond = 0xF; return OP_TCC;}
100 | TFR		{return OP_TFR;}
101 | TST		{return OP_TST;}
102 | AND		{return OP_AND;}
103 | ANDI	{return OP_ANDI;}
104 | EOR		{return OP_EOR;}
105 | LSL		{return OP_LSL;}
106 | LSR		{return OP_LSR;}
107 | NOT		{return OP_NOT;}
108 | OR		{return OP_OR;}
109 | ORI		{return OP_ORI;}
110 | ROL		{return OP_ROL;}
111 | ROR		{return OP_ROR;}
112 | BCLR	{return OP_BCLR;}
113 | BSET	{return OP_BSET;}
114 | BCHG	{return OP_BCHG;}
115 | BTST	{return OP_BTST;}
116 | DO		{return OP_DO;}
117 | ENDDO	{return OP_ENDDO;}
118 | LUA		{return OP_LUA;}
119 | MOVE	{return OP_MOVE;}
120 | MOVEC	{return OP_MOVEC;}
121 | MOVEM	{return OP_MOVEM;}
122 | MOVEP	{return OP_MOVEP;}
123 | INCLUDE	{return OP_INCLUDE;}
124 | ILLEGAL	{return OP_ILLEGAL;}
125 | JCC		{yylval.cond = 0x0; return OP_JCC;}
126 | JHS		{yylval.cond = 0x0; return OP_JCC;}
127 | JGE		{yylval.cond = 0x1; return OP_JCC;}
128 | JNE		{yylval.cond = 0x2; return OP_JCC;}
129 | JPL		{yylval.cond = 0x3; return OP_JCC;}
130 | JNN		{yylval.cond = 0x4; return OP_JCC;}
131 | JEC		{yylval.cond = 0x5; return OP_JCC;}
132 | JLC		{yylval.cond = 0x6; return OP_JCC;}
133 | JGT		{yylval.cond = 0x7; return OP_JCC;}
134 | JCS		{yylval.cond = 0x8; return OP_JCC;}
135 | JLO		{yylval.cond = 0x8; return OP_JCC;}
136 | JLT		{yylval.cond = 0x9; return OP_JCC;}
137 | JEQ		{yylval.cond = 0xA; return OP_JCC;}
138 | JMI		{yylval.cond = 0xB; return OP_JCC;}
139 | JNR		{yylval.cond = 0xC; return OP_JCC;}
140 | JES		{yylval.cond = 0xD; return OP_JCC;}
141 | JLS		{yylval.cond = 0xE; return OP_JCC;}
142 | JLE		{yylval.cond = 0xF; return OP_JCC;}
143 | JMP		{return OP_JMP;}
144 | JCLR	{return OP_JCLR;}
145 | JSET	{return OP_JSET;}
146 | JSCC	{yylval.cond = 0x0; return OP_JSCC;}
147 | JSHS	{yylval.cond = 0x0; return OP_JSCC;}
148 | JSGE	{yylval.cond = 0x1; return OP_JSCC;}
149 | JSNE	{yylval.cond = 0x2; return OP_JSCC;}
150 | JSPL	{yylval.cond = 0x3; return OP_JSCC;}
151 | JSNN	{yylval.cond = 0x4; return OP_JSCC;}
152 | JSEC	{yylval.cond = 0x5; return OP_JSCC;}
153 | JSLC	{yylval.cond = 0x6; return OP_JSCC;}
154 | JSGT	{yylval.cond = 0x7; return OP_JSCC;}
155 | JSCS	{yylval.cond = 0x8; return OP_JSCC;}
156 | JSLO	{yylval.cond = 0x8; return OP_JSCC;}
157 | JSLT	{yylval.cond = 0x9; return OP_JSCC;}
158 | JSEQ	{yylval.cond = 0xA; return OP_JSCC;}
159 | JSMI	{yylval.cond = 0xB; return OP_JSCC;}
160 | JSNR	{yylval.cond = 0xC; return OP_JSCC;}
161 | JSES	{yylval.cond = 0xD; return OP_JSCC;}
162 | JSLS	{yylval.cond = 0xE; return OP_JSCC;}
163 | JSLE	{yylval.cond = 0xF; return OP_JSCC;}
164 | JSR		{return OP_JSR;}
165 | JSCLR	{return OP_JSCLR;}
166 | JSSET	{return OP_JSSET;}
167 | NOP		{return OP_NOP;}
168 | REP		{return OP_REP;}
169 | RESET	{return OP_RESET;}
170 | RTI		{return OP_RTI;}
171 | RTS		{return OP_RTS;}
172 | STOP	{return OP_STOP;}
173 | SWI		{return OP_SWI;}
174 | WAIT	{return OP_WAIT;}
175 | EQU		{return OP_EQU;}
176 | ORG		{return OP_ORG;}
177 | DC		{return OP_DC;}
178 | DS		{return OP_DS;}
179 | DSM		{return OP_DSM;}
180 | INT		{return OP_INT;}
181 | END		{return OP_END;}
182 | PAGE	{return OP_PAGE;}
183 | PSECT	{return OP_PSECT;}
184 | ALIGN	{return OP_ALIGN;}
185 | PI		{return OP_PI;}
186 | SIN		{return OP_SIN;}
187 | COS		{return OP_COS;}
188 | TAN		{return OP_TAN;}
189 | ATAN	{return OP_ATAN;}
190 | ASIN	{return OP_ASIN;}
191 | ACOS	{return OP_ACOS;}
192 | EXP		{return OP_EXP;}
193 | LN		{return OP_LN;}
194 | LOG		{return OP_LOG;}
195 | POW		{return OP_POW;}
196 | 


--------------------------------------------------------------------------------
/a56.y:
--------------------------------------------------------------------------------
   1 | %{
   2 | /*******************************************************
   3 |  *
   4 |  *  a56 - a DSP56001 assembler
   5 |  *
   6 |  *  Written by Quinn C. Jensen
   7 |  *  July 1990
   8 |  *
   9 |  *******************************************************/
  10 | 
  11 | /*
  12 |  * Copyright (C) 1990-1994 Quinn C. Jensen
  13 |  *
  14 |  * Permission to use, copy, modify, distribute, and sell this software
  15 |  * and its documentation for any purpose is hereby granted without fee,
  16 |  * provided that the above copyright notice appear in all copies and
  17 |  * that both that copyright notice and this permission notice appear
  18 |  * in supporting documentation.  The author makes no representations
  19 |  * about the suitability of this software for any purpose.  It is
  20 |  * provided "as is" without express or implied warranty.
  21 |  *
  22 |  */
  23 | 
  24 | /*
  25 |  *  a56.y - The YACC grammar for the assembler.
  26 |  *
  27 |  *  Note:  This module requires a "BIG" version of YACC.  I had to
  28 |  *  recompile YACC in the largest mode available.
  29 |  *
  30 |  *  Other notes:
  31 |  *
  32 |  *  MOVEC, MOVEM and MOVEP must be used explicitly--MOVE can't yet figure
  33 |  *  out which form to use.
  34 |  *
  35 |  */
  36 | 
  37 | #include "a56.h"
  38 | #include <math.h>
  39 | 
  40 | unsigned int w0, w1;			/* workspace for the actual generated code */
  41 | BOOL uses_w1;					/* says whether w1 is alive */
  42 | unsigned int pc;				/* current program counter */
  43 | int seg;						/* current segment P: X: Y: or L: */
  44 | int expr_seg;					/* segment of current expression */
  45 | 
  46 | int just_rep = 0;				/* keeps track of REP instruction */
  47 | int hot_rreg = -1;				/* rreg loaded by prev inst. or -1 */
  48 | int hot_nreg = -1;				/* nreg loaded by prev inst. or -1 */
  49 | int hot_mreg = -1;				/* mreg loaded by prev inst. or -1 */
  50 | int prev_hot_rreg = -1;			/* rreg loaded by prev inst. or -1 */
  51 | int prev_hot_nreg = -1;			/* nreg loaded by prev inst. or -1 */
  52 | int prev_hot_mreg = -1;			/* mreg loaded by prev inst. or -1 */
  53 | 
  54 | int substatement = 0;			/* in a substatement */
  55 | BOOL long_symbolic_expr = FALSE; /* a parser flag */
  56 | char *new_include = NULL;		/* file to be included */
  57 | 
  58 | /* listing stuff */
  59 | 
  60 | char segs[] = "uPXYL*";
  61 | extern BOOL list_on_next;		/* listing to turn on or off */
  62 | BOOL list_on;					/* listing on at the moment */
  63 | extern char *cur_line;			/* points to line being lex'd */
  64 | char list_buf[1024 + 80];		/* listing buffer */
  65 | char list_buf2[1024 + 80];		/* listing buffer for two-line code */
  66 | BOOL uses_buf2 = FALSE;			/* list_buf2 is alive */
  67 | BOOL list_print_line = FALSE;	/* whether or not to print line in listing */
  68 | char *spaces(), *luntab();
  69 | 
  70 | struct n binary_op();
  71 | struct n unary_op();
  72 | struct n sym_ref();
  73 | 
  74 | #define R_R6				0x0001
  75 | #define R_R5				0x0002
  76 | #define R_R4				0x0004
  77 | #define R_DATA_ALU_ACCUM	0x0008
  78 | #define R_CTL_REG			0x0010
  79 | #define R_FUNKY_CTL_REG		0x0020
  80 | #define R_SDX				0x0040
  81 | #define R_SDY				0x0080
  82 | #define R_LSD				0x0100
  83 | #define R_AB				0x0200
  84 | #define R_XREG				0x0400
  85 | #define R_YREG				0x0800
  86 | /* registers to which short immediate move is an unsigned int */
  87 | #define R_UINT				0x1000
  88 | /* registers to which short immediate move is an signed frac */
  89 | #define R_SFRAC				0x2000
  90 | %}
  91 | 
  92 | %union {
  93 | 	int ival;			/* integer value */
  94 | 	struct n n;			/* just like in struct sym */
  95 | 	double dval;		/* floating point value */
  96 | 	char *sval;			/* string */
  97 | 	int cval;			/* character */
  98 | 	char cond;			/* condition */
  99 | 	struct regs {
 100 | 		int r6, r5, r4, data_alu_accum, ctl_reg, funky_ctl_reg;
 101 | 		int sdx, sdy, lsd, ab, xreg, yreg;
 102 | 		int flags;
 103 | 	} regs;
 104 | 	struct ea {
 105 | 		int mode;
 106 | 		int ext;
 107 | 		int pp;
 108 | 	} ea;
 109 | }
 110 | 
 111 | %token <n> CHEX CDEC FRAC 
 112 | %token <ival> AREG BREG MREG NREG RREG XREG YREG
 113 | %token <ival> OP OPA OPP
 114 | %token <cond> OP_JCC OP_JSCC OP_TCC
 115 | %token <sval> SYM
 116 | %token <sval> STRING
 117 | %token <cval> CHAR
 118 | %token XMEM
 119 | %token YMEM
 120 | %token LMEM
 121 | %token PMEM
 122 | %token AAAA
 123 | %token A10
 124 | %token BBBB
 125 | %token B10
 126 | %token AABB
 127 | %token BBAA
 128 | %token XXXX
 129 | %token YYYY
 130 | %token SR
 131 | %token MR
 132 | %token CCR
 133 | %token OMR
 134 | %token SP
 135 | %token SSH
 136 | %token SSL
 137 | %token LA
 138 | %token LC
 139 | %token EOL
 140 | %token EOS
 141 | %token LEXBAD
 142 | 
 143 | %token OP_ABS
 144 | %token OP_ADC
 145 | %token OP_ADD
 146 | %token OP_ADDL
 147 | %token OP_ADDR
 148 | %token OP_ASL
 149 | %token OP_ASR
 150 | %token OP_CLR
 151 | %token OP_CMP
 152 | %token OP_CMPM
 153 | %token OP_DEC
 154 | %token OP_DIV
 155 | %token OP_INC
 156 | %token OP_MAC
 157 | %token OP_MACR
 158 | %token OP_MPY
 159 | %token OP_MPYR
 160 | %token OP_NEG
 161 | %token OP_NORM
 162 | %token OP_RND
 163 | %token OP_SBC
 164 | %token OP_SUB
 165 | %token OP_SUBL
 166 | %token OP_SUBR
 167 | %token OP_TFR
 168 | %token OP_TST
 169 | %token OP_AND
 170 | %token OP_ANDI
 171 | %token OP_EOR
 172 | %token OP_LSL
 173 | %token OP_LSR
 174 | %token OP_NOT
 175 | %token OP_OR
 176 | %token OP_ORI
 177 | %token OP_ROL
 178 | %token OP_ROR
 179 | %token OP_BCLR
 180 | %token OP_BSET
 181 | %token OP_BCHG
 182 | %token OP_BTST
 183 | %token OP_DO
 184 | %token OP_ENDDO
 185 | %token OP_LUA
 186 | %token OP_MOVE
 187 | %token OP_MOVEC
 188 | %token OP_MOVEM
 189 | %token OP_MOVEP
 190 | %token OP_ILLEGAL
 191 | %token OP_INCLUDE
 192 | %token OP_JMP
 193 | %token OP_JCLR
 194 | %token OP_JSET
 195 | %token OP_JSR
 196 | %token OP_JSCLR
 197 | %token OP_JSSET
 198 | %token OP_NOP
 199 | %token OP_REP
 200 | %token OP_RESET
 201 | %token OP_RTI
 202 | %token OP_RTS
 203 | %token OP_STOP
 204 | %token OP_SWI
 205 | %token OP_WAIT
 206 | %token OP_EQU
 207 | %token OP_ORG
 208 | %token OP_DC
 209 | %token OP_DS
 210 | %token OP_DSM
 211 | %token OP_END
 212 | %token OP_PAGE
 213 | %token OP_PSECT
 214 | %token OP_ALIGN
 215 | %token OP_INT
 216 | %token SHL
 217 | %token SHR
 218 | %token OP_PI
 219 | %token OP_SIN
 220 | %token OP_COS
 221 | %token OP_TAN
 222 | %token OP_ATAN
 223 | %token OP_ASIN
 224 | %token OP_ACOS
 225 | %token OP_EXP
 226 | %token OP_LN
 227 | %token OP_LOG
 228 | %token OP_POW
 229 | 
 230 | %type <n> num num_or_sym 
 231 | %type <n> num_or_sym_expr
 232 | %type <n> expr
 233 | %type <n> ix
 234 | %type <n> ix_long
 235 | 
 236 | %type <ival> abs_addr abs_short_addr io_short_addr 
 237 | %type <ival> a_b x_or_y ea b5_10111_max
 238 | %type <ival> p6_ean_a6 ea_no_ext p6_ea_a6 ea_a6 ea_a12
 239 | %type <ival> ea_short
 240 | %type <ival> prog_ctl_reg
 241 | %type <ival> op8_1 op8_2 op8_3 op8_4 op8_5 op8_6 op8_7 op8_8
 242 | %type <ival> mpy_arg mpy_srcs plus_minus
 243 | %type <ival> sd3
 244 | %type <ival> funky_ctl_reg tcc_sd space
 245 | %type <sval> opt_label
 246 | 
 247 | %type <regs> regs
 248 | %type <ea> movep_ea_pp
 249 | 
 250 | %left '|'
 251 | %left '^'
 252 | %left SHL SHR
 253 | %left '&'
 254 | %left '+' '-'
 255 | %left '*' '/' '%'
 256 | %right '~'
 257 | 
 258 | %start input
 259 | 
 260 | %%
 261 | 
 262 | /*%%%********************* top syntax ***********************/
 263 | 
 264 | input	:	/* empty */
 265 | 	|	input statement
 266 | 	;
 267 | 
 268 | statement
 269 | 	:	good_stuff EOL
 270 | 			{
 271 | 			if(pass == 2 && list_on && list_print_line) {
 272 | 				printf(ldebug ? "\n(%s|%s)\n" : "%s%s\n",
 273 | 					list_buf, substatement == 0 ? luntab(cur_line) : "");
 274 | 				if(uses_buf2)
 275 | 					printf(ldebug ? "\n(%s|)\n" : "%s\n",
 276 | 						list_buf2);
 277 | 				list_buf[0] = list_buf2[0] = '\0';
 278 | 			}
 279 | 			curline++;
 280 | 			uses_buf2 = FALSE;
 281 | 			list_print_line = TRUE;
 282 | 			list_on = list_on_next;
 283 | 			substatement = 0;
 284 | 			if(NOT check_psect(seg, pc) && pass == 2)
 285 | 				yyerror("%04X: psect violation", pc);
 286 | 			}
 287 | 	|	good_stuff EOS
 288 | 			{
 289 | 			if(pass == 2 && list_on && list_print_line) {
 290 | 				printf(ldebug ? "\n(%s" : "%s", list_buf);
 291 | 				if(substatement == 0)
 292 | 					printf(ldebug ? "|%s)\n" : "%s\n", luntab(cur_line));
 293 | 				else
 294 | 					printf(ldebug ? ")\n" : "\n");
 295 | 				if(uses_buf2)
 296 | 					printf(ldebug ? "\n(%s|)\n" : "%s\n",
 297 | 						list_buf2);
 298 | 				list_buf[0] = list_buf2[0] = '\0';
 299 | 			}
 300 | 			substatement++;
 301 | 			uses_buf2 = FALSE;
 302 | 			list_print_line = TRUE;
 303 | 			list_on = list_on_next;
 304 | 			if(NOT check_psect(seg, pc) && pass == 2)
 305 | 				yyerror("%04X: psect violation", pc);
 306 | 			}
 307 | 	|	error EOL
 308 | 			{curline++; substatement = 0;}
 309 | 	;
 310 | 
 311 | good_stuff
 312 | 	:	/* empty */
 313 | 			{sprintf(list_buf, "%s", spaces(0));}
 314 | 	|	cpp_droppings
 315 | 			{list_print_line = FALSE;}
 316 | 	|	assembler_ops
 317 | 			{long_symbolic_expr = FALSE;}
 318 | 	|	label_field operation_field
 319 | 			{char *printcode();
 320 | 			if(pass == 2) {
 321 | 				gencode(seg, pc, w0);
 322 | 				sprintf(list_buf, "%c:%04X %s ", segs[seg], pc, printcode(w0));
 323 | 				pc++;
 324 | 				if(uses_w1) {
 325 | 					gencode(seg, pc, w1);
 326 | 					sprintf(list_buf2, "%c:%04X %s", segs[seg], pc,
 327 | 	       					printcode(w1 & 0xFFFFFF));
 328 | 					uses_buf2++;
 329 | 					pc++;
 330 | 				}
 331 | 			} else {
 332 | 				pc++;
 333 | 				if(uses_w1)
 334 | 					pc++;
 335 | 			}
 336 | 			w0 = w1 = 0; uses_w1 = FALSE; 
 337 | 			long_symbolic_expr = FALSE;}
 338 | 	|	SYM 
 339 | 			{sym_def($1, INT, seg, pc);
 340 | 			free($1);
 341 | 			if(pass == 2 && list_on) {
 342 | 				sprintf(list_buf, "%c:%04X%s", segs[seg], pc, spaces(14-8));
 343 | 			long_symbolic_expr = FALSE;
 344 | 			}}
 345 | 	;
 346 | 
 347 | cpp_droppings
 348 | 	:	'#' num STRING
 349 | 			{if(strlen($3) > 0)
 350 | 				curfile = $3;
 351 | 			else
 352 | 				curfile = "<stdin>";
 353 | 			curline = $2.val.i - 1;}
 354 | 	;
 355 | 
 356 | assembler_ops
 357 | 	:	SYM OP_EQU expr
 358 | 			{sym_def($1, $3.type, ANY, $3.val.i, $3.val.f);
 359 | 			free($1);
 360 | 			if(pass == 2 && list_on) {
 361 | 				if($3.type == INT)
 362 | 					sprintf(list_buf, "%06X%s",
 363 | 						$3.val.i & 0xFFFFFF,
 364 | 						spaces(14-8));
 365 | 				else
 366 | 					sprintf(list_buf, "%10g%s", $3.val.f,
 367 | 						spaces(14-4));
 368 | 			}}
 369 | 	|	OP_ALIGN expr
 370 | 			{int ival = n2int($2);
 371 | 			if($2.type == UNDEF) {
 372 | 				yyerror("illegal forward reference");
 373 | 			} else if (ival <= 1) {
 374 | 				yyerror("%d: illegal alignment", ival);
 375 | 			} else {
 376 | 				if(pc % ival != 0)
 377 | 					pc += ival - pc % ival;
 378 | 			}
 379 | 			if(pass == 2 && list_on)
 380 | 				sprintf(list_buf, "%c:%04X%s", segs[seg], pc, 
 381 | 					spaces(14-8));
 382 | 			}
 383 | 	|	OP_PSECT SYM
 384 | 			{struct psect *pp = find_psect($2);
 385 | 			if(NOT pp) {
 386 | 				if(pass == 2)
 387 | 					yyerror("%s: undefined psect", $2);
 388 | 			} else {
 389 | 				seg = pp->seg;
 390 | 				pc = pp->pc;
 391 | 				set_psect(pp);
 392 | 				if(pass == 2 && list_on)
 393 | 					sprintf(list_buf, "%c:%04X%s", segs[seg], pc,
 394 | 						spaces(14-8));
 395 | 			}
 396 | 			free($2);}
 397 | 	|	OP_PSECT SYM space expr ':' expr
 398 | 			{new_psect($2, $3, n2int($4), n2int($6));
 399 | 			if(pass == 2 && list_on)
 400 | 				sprintf(list_buf, "%c:%04X %04X%s", 
 401 | 					segs[$3], n2int($4), n2int($6), spaces(14-8+4+1));
 402 | 			}
 403 | 	|	OP_ORG space expr
 404 | 			{pc = n2int($3);
 405 | 			seg = $2;
 406 | 			if(pass == 2 && list_on)
 407 | 				sprintf(list_buf, "%c:%04X%s", segs[seg], pc, 
 408 | 					spaces(14-8));
 409 | 			}
 410 | 	|	OP_ORG space expr ',' space expr
 411 | 			{pc = n2int($3);
 412 | 			seg = $2;
 413 | 			if(pass == 2 && list_on)
 414 | 				sprintf(list_buf, "%c:%04X%s", segs[seg], pc, 
 415 | 					spaces(14-8));
 416 | 			}
 417 | 	|	label_field OP_DC dc_list
 418 | 	|	label_field OP_DS expr
 419 | 			{pc += n2int($3);
 420 | 			if(pass == 2 && list_on)
 421 | 				sprintf(list_buf, "%c:%04X%s", segs[seg], pc, 
 422 | 					spaces(14-8));
 423 | 			}
 424 | 	|	opt_label OP_DSM expr
 425 | 			{int size = n2int($3);
 426 | 			if(size)
 427 | 			{    int align = 1;
 428 | 			     while(align < size)
 429 | 				 align <<= 1;
 430 | 			     pc += (align - (pc % align));
 431 | 			}
 432 | 			if($1)
 433 | 			{   sym_def($1, INT, seg, pc);
 434 |  			    free($1);
 435 | 			}
 436 | 			pc += size;
 437 | 			}
 438 | 	|	OP_PAGE num ',' num ',' num ',' num
 439 | 			{if(pass == 2 && list_on) {
 440 | 				sprintf(list_buf, "%s", spaces(0));
 441 | 			}}
 442 | 	|	OP_INCLUDE STRING
 443 | 			{if(pass == 2 && list_on) {
 444 | 				printf(ldebug ? "\n(%s|%s)\n" : "%s%s\n",
 445 | 					spaces(0), luntab(cur_line));
 446 | 				list_print_line = FALSE;
 447 | 			}
 448 | 			include($2); /* free($2); */
 449 | 			}
 450 | 	|	OP_END
 451 | 			{if(pass == 2 && list_on) {
 452 | 				sprintf(list_buf, "%s", spaces(0));
 453 | 			}}
 454 | 	;
 455 | 
 456 | dc_list
 457 | 	:	dc_list ',' dc_stuff
 458 | 	|	dc_stuff
 459 | 	;
 460 | 
 461 | dc_stuff
 462 | 	:	STRING
 463 | 			{int len = strlen($1), i; char *cp; w0 = 0;
 464 | 			if(len % 3 == 2)
 465 | 				len++;	/* force empty word */
 466 | 			for(i = 0, cp = $1; i < len; i++, cp++) {
 467 | 				w0 |= (*cp & 0xFF) << (2 - (i % 3)) * 8;
 468 | 				if(i % 3 == 2 || i == len - 1) {
 469 | 					if(pass == 2) {
 470 | 						if(list_on) sprintf(list_buf, "%c:%04X %06X%s",
 471 | 							segs[seg], pc, w0, 
 472 | 							spaces(14-6+5));
 473 | 						gencode(seg, pc, w0);
 474 | 					}
 475 | 					pc++; w0 = 0;
 476 | 				}
 477 | 			}
 478 | 			free($1);}
 479 |  	|	expr
 480 | 			{int frac = n2frac($1);
 481 | 			if(pass == 2) {
 482 | 				if(list_on) {
 483 | 					sprintf(list_buf, "%c:%04X %06X%s", segs[seg], pc, 
 484 | 						frac & 0xFFFFFF, spaces(14-6+5));
 485 | 				}
 486 | 				gencode(seg, pc, frac);
 487 | 			}
 488 | 			pc++;}
 489 | 
 490 | space
 491 | 	:	PMEM
 492 | 			{$$ = PROG;}
 493 | 	|	XMEM
 494 | 			{$$ = XDATA;}
 495 | 	|	YMEM
 496 | 			{$$ = YDATA;}
 497 | 	|	LMEM
 498 | 			{$$ = LDATA;}
 499 | 	;       
 500 | 
 501 | label_field
 502 | 	:	SYM
 503 | 			{sym_def($1, INT, seg, pc);
 504 | 			free($1);}
 505 | 	|	/* empty */
 506 | 	;
 507 | 
 508 | opt_label
 509 | 	:	SYM		{$$ = $1;}
 510 | 	|	/* empty */	{$$ = NULL;}
 511 | 	;
 512 | 
 513 | operation_field
 514 | 	:	operation
 515 | 			{prev_hot_rreg = hot_rreg;
 516 | 			prev_hot_nreg = hot_nreg;
 517 | 			prev_hot_mreg = hot_mreg;
 518 | 			hot_rreg = hot_nreg = hot_mreg = -1;
 519 | 			if(just_rep) 
 520 | 				just_rep--;}
 521 | 	;
 522 | 
 523 | operation
 524 | 	:	no_parallel
 525 | 	|	parallel_ok
 526 | 			{w0 |= 0x200000;}
 527 | 	|	parallel_ok parallel_move
 528 | 	;
 529 | 
 530 | /*%%%************* instructions that allow parallel moves ****************/
 531 | 
 532 | parallel_ok
 533 | 	:
 534 | 		OP_MPY mpy_arg
 535 | 			{w0 |= 0x80 | $2 << 2;}
 536 | 	|	OP_MPYR mpy_arg
 537 | 			{w0 |= 0x81 | $2 << 2;}
 538 | 	|	OP_MAC mpy_arg
 539 | 			{w0 |= 0x82 | $2 << 2;}
 540 | 	|	OP_MACR mpy_arg
 541 | 			{w0 |= 0x83 | $2 << 2;}
 542 | 
 543 | 	|       OP_SUB op8_1
 544 | 			{w0 |= 0x04 | $2 << 3;}
 545 | 	|	OP_ADD op8_1
 546 | 			{w0 |= 0x00 | $2 << 3;}
 547 | 	|	OP_MOVE
 548 | 			{w0 |= 0x00;}
 549 | 
 550 | 	|	OP_TFR op8_2
 551 | 			{w0 |= 0x01 | $2 << 3;}
 552 | 	|	OP_CMP op8_2
 553 | 			{w0 |= 0x05 | $2 << 3;}
 554 | 	|	OP_CMPM op8_2
 555 | 			{w0 |= 0x07 | $2 << 3;}
 556 | 
 557 | 	|	OP_RND op8_3
 558 | 			{w0 |= 0x11 | $2 << 3;}
 559 | 	|	OP_ADDL op8_3
 560 | 			{w0 |= 0x12 | $2 << 3;}
 561 | 	|	OP_CLR op8_3
 562 | 			{w0 |= 0x13 | $2 << 3;}
 563 | 	|	OP_SUBL op8_3
 564 | 			{w0 |= 0x16 | $2 << 3;}
 565 | 	|	OP_NOT op8_3
 566 | 			{w0 |= 0x17 | $2 << 3;}
 567 | 
 568 | 	|	OP_ADDR op8_4
 569 | 			{w0 |= 0x02 | $2 << 3;}
 570 | 	|	OP_TST op8_4
 571 | 			{w0 |= 0x03 | $2 << 3;}
 572 | 	|	OP_SUBR op8_4
 573 | 			{w0 |= 0x06 | $2 << 3;}
 574 | 
 575 | 	|       OP_AND op8_5
 576 | 			{w0 |= 0x46 | $2 << 3;}
 577 | 	|	OP_OR op8_5
 578 | 			{w0 |= 0x42 | $2 << 3;}
 579 | 	|       OP_EOR op8_5
 580 | 			{w0 |= 0x43 | $2 << 3;}
 581 | 
 582 | 	|       OP_ASR op8_6
 583 | 			{w0 |= 0x22 | $2 << 3;}
 584 | 	|       OP_LSR op8_6
 585 | 			{w0 |= 0x23 | $2 << 3;}
 586 | 	|       OP_ABS op8_6
 587 | 			{w0 |= 0x26 | $2 << 3;}
 588 | 	|       OP_ROR op8_6
 589 | 			{w0 |= 0x27 | $2 << 3;}
 590 | 
 591 | 	|       OP_ASL op8_7
 592 | 			{w0 |= 0x32 | $2 << 3;}
 593 | 	|       OP_LSL op8_7
 594 | 			{w0 |= 0x33 | $2 << 3;}
 595 | 	|       OP_NEG op8_7
 596 | 			{w0 |= 0x36 | $2 << 3;}
 597 | 	|       OP_ROL op8_7
 598 | 			{w0 |= 0x37 | $2 << 3;}
 599 | 
 600 | 	|       OP_ADC op8_8
 601 | 			{w0 |= 0x21 | $2 << 3;}
 602 | 	|       OP_SBC op8_8
 603 | 			{w0 |= 0x25 | $2 << 3;}
 604 | 	;
 605 | 
 606 | mpy_arg	:	plus_minus mpy_srcs ',' a_b
 607 | 			{$$ = $1 | $4 << 1 | $2 << 2;}
 608 | 	;
 609 | 
 610 | plus_minus
 611 | 	:	'+'    
 612 | 			{$$ = 0;}
 613 | 	|	'-'    
 614 | 			{$$ = 1;}
 615 | 	|	
 616 | 			{$$ = 0;}
 617 | 	;
 618 | 
 619 | mpy_srcs
 620 | 	:       XREG ',' XREG
 621 | 			{switch ($1 << 4 | $3) {
 622 | 				case 0x00: $$ = 0x0; break;
 623 | 				case 0x01: 
 624 | 				case 0x10: $$ = 0x2; break;
 625 | 				case 0x11: 
 626 | 					yyerror("illegal source operands"); 
 627 | 					break;
 628 | 			}}      			
 629 | 	|	YREG ',' YREG
 630 | 			{switch ($1 << 4 | $3) {
 631 | 				case 0x00: $$ = 0x1; break;
 632 | 				case 0x01: 
 633 | 				case 0x10: $$ = 0x3; break;
 634 | 				case 0x11: 
 635 | 					yyerror("illegal source operands"); 
 636 | 					break;
 637 | 			}}      			
 638 | 	|	XREG ',' YREG
 639 | 			{switch ($1 << 4 | $3) {
 640 | 				case 0x00: $$ = 0x5; break;
 641 | 				case 0x01: $$ = 0x4; break;
 642 | 				case 0x10: $$ = 0x6; break;
 643 | 				case 0x11: $$ = 0x7; break;
 644 | 			}}      			
 645 | 	|	YREG ',' XREG
 646 | 			{switch ($1 << 4 | $3) {
 647 | 				case 0x00: $$ = 0x5; break;
 648 | 				case 0x01: $$ = 0x6; break;
 649 | 				case 0x10: $$ = 0x4; break;
 650 | 				case 0x11: $$ = 0x7; break;
 651 | 			}}      			
 652 | 	;
 653 | 
 654 | op8_1	:	BBBB ',' AAAA
 655 | 			{$$ = 0x2;}
 656 | 	|	AAAA ',' BBBB
 657 | 			{$$ = 0x3;}
 658 | 	|	XXXX ',' a_b
 659 | 			{$$ = 0x4 | $3;}
 660 | 	|	YYYY ',' a_b
 661 | 			{$$ = 0x6 | $3;}
 662 | 	|	XREG ',' a_b
 663 | 			{$$ = 0x8 | $1 << 2 | $3;}
 664 | 	|	YREG ',' a_b
 665 | 			{$$ = 0xA | $1 << 2 | $3;}
 666 | 	;
 667 | 
 668 | op8_2	:	BBBB ',' AAAA
 669 | 			{$$ = 0x0;}
 670 | 	|	AAAA ',' BBBB
 671 | 			{$$ = 0x1;}
 672 | 	|	XREG ',' a_b
 673 | 			{$$ = 0x8 | $1 << 2 | $3;}
 674 | 	|	YREG ',' a_b
 675 | 			{$$ = 0xA | $1 << 2 | $3;}
 676 | 	;
 677 | 
 678 | op8_3	:	AAAA
 679 | 			{$$ = 0x0;}
 680 | 	|	BBBB
 681 | 			{$$ = 0x1;}
 682 | 	|	BBBB ',' AAAA
 683 | 			{$$ = 0x0;}
 684 | 	|	AAAA ',' BBBB
 685 | 			{$$ = 0x1;}
 686 | 	;
 687 | 
 688 | op8_4	:	op8_3
 689 | 			{$$ = $1;}
 690 | 	;
 691 | 
 692 | op8_5	:	XREG ',' a_b
 693 | 			{$$ = 0x0 | $1 << 2 | $3;}
 694 | 	|	YREG ',' a_b
 695 | 			{$$ = 0x2 | $1 << 2 | $3;}
 696 | 	;
 697 | 
 698 | op8_6	:	a_b
 699 | 			{$$ = $1;}
 700 | 	;
 701 | 
 702 | op8_7	:	a_b
 703 | 			{$$ = $1;}
 704 | 	;
 705 | 
 706 | op8_8	:	XXXX ',' a_b
 707 | 			{$$ = 0x0 | $3;}
 708 | 	|	YYYY ',' a_b
 709 | 			{$$ = 0x2 | $3;}
 710 | 	;
 711 | 
 712 | a_b	:	AAAA
 713 | 			{$$ = 0;}
 714 | 	|	BBBB
 715 | 			{$$ = 1;}
 716 | 	;
 717 | 
 718 | no_parallel
 719 | 	:	control_inst
 720 | 			{if(just_rep == 1)
 721 | 				yyerror("instruction not allowed after REP");}
 722 | 	|	bit_inst
 723 | 	|	move_inst
 724 | 	|	arith_inst
 725 | 	;
 726 | 
 727 | /*%%%************** non-parallel arithmetic and logical ********************/
 728 | 
 729 | arith_inst
 730 | 	:	OP_NORM RREG ',' a_b
 731 | 			{w0 |= 0x01D815 | $2 << 8 | $4 << 3;}
 732 | 	|	OP_DIV sd3
 733 | 			{w0 |= 0x018040 | $2 << 3;}
 734 | 	|	or_op ix ',' funky_ctl_reg
 735 | 			{w0 |= 0x0000F8 | (n2int($2) & 0xFF) << 8 | $4;}
 736 | 	|	and_op ix ',' funky_ctl_reg
 737 | 			{w0 |= 0x0000B8 | (n2int($2) & 0xFF) << 8 | $4;}
 738 | 	|	OP_DEC a_b
 739 | 			{w0 |= 0x00000A | $2;}
 740 | 	|	OP_INC a_b
 741 | 			{w0 |= 0x000008 | $2;}
 742 | 	;
 743 | 
 744 | or_op	:	OP_OR
 745 | 	|	OP_ORI
 746 | 	;
 747 | 
 748 | and_op	:	OP_AND
 749 | 	|	OP_ANDI
 750 | 	;
 751 | 
 752 | /*%%%******************************* control instructions **********************/
 753 | 
 754 | control_inst
 755 | 	:	OP_JSCC ea_a12
 756 | 			{if($2) {
 757 | 				w0 |= 0x0BC0A0 | $1 << 0;
 758 | 			} else {
 759 | 				w0 |= 0x0F0000 | $1 << 12;
 760 | 			}}
 761 | 	|	OP_JCC ea_a12
 762 | 			{if($2) {
 763 | 				w0 |= 0x0AC0A0 | $1 << 0;
 764 | 			} else {
 765 | 				w0 |= 0x0E0000 | $1 << 12;
 766 | 			}}
 767 | 	|	OP_JSR ea_a12
 768 | 			{if($2) {
 769 | 				w0 |= 0x0BC080;
 770 | 			} else {
 771 | 				w0 |= 0x0D0000;
 772 | 			}}
 773 | 	|	OP_JMP ea_a12
 774 | 			{if($2) {
 775 | 				w0 |= 0x0AC080;
 776 | 			} else {
 777 | 				w0 |= 0x0C0000;
 778 | 			}}
 779 | 
 780 | 	|	OP_JSSET control_args
 781 | 			{w0 |= 0x0B0020;}
 782 | 	|	OP_JSCLR control_args
 783 | 			{w0 |= 0x0B0000;}
 784 | 	|	OP_JSET control_args
 785 | 			{w0 |= 0x0A0020;}
 786 | 	|	OP_JCLR control_args
 787 | 			{w0 |= 0x0A0000;}
 788 | 
 789 | 	|	OP_REP rep_args
 790 | 			{just_rep = 2;}
 791 | 	|	OP_DO do_args
 792 | 			{uses_w1++;}
 793 | 	|	OP_ENDDO
 794 | 			{w0 |= 0x00008C;}
 795 | 	|	OP_STOP
 796 | 			{w0 |= 0x000087;}
 797 | 	|	OP_WAIT
 798 | 			{w0 |= 0x000086;}
 799 | 	|	OP_RESET
 800 | 			{w0 |= 0x000084;}
 801 | 	|	OP_RTS
 802 | 			{w0 |= 0x00000C;}
 803 | 	|	OP_SWI
 804 | 			{w0 |= 0x000006;}
 805 | 	|	OP_ILLEGAL
 806 | 			{w0 |= 0x000005;}
 807 | 	|	OP_RTI
 808 | 			{w0 |= 0x000004;}
 809 | 	|	OP_NOP
 810 | 			{w0 |= 0x000000;
 811 | 			just_rep = 0;}
 812 | 	;
 813 | 
 814 | do_args
 815 | 	:	ix ',' abs_addr
 816 | 			{int ival = n2int($1);
 817 | 			w0 |= 0x060080 | (ival & 0xFF) << 8 | (ival & 0xF00)>> 8;
 818 | 			if(ival > 0xFFF && pass == 2) {
 819 | 				yywarning("warning: immediate operand truncated");
 820 | 			}
 821 | 			w1 |= $3-1;}
 822 | 	|	regs ',' abs_addr
 823 | 			{w0 |= 0x06C000 | $1.r6 << 8;
 824 | 			hot_rreg = hot_nreg = hot_mreg = -1;
 825 | 			w1 |= $3-1;}
 826 | 	|	x_or_y ea_no_ext ',' abs_addr
 827 | 			{w0 |= 0x064000 | $2 << 8 | $1 << 6;
 828 | 			w1 |= $4-1;}
 829 | 	|	x_or_y abs_short_addr ',' abs_addr	/* allow forced */
 830 | 			{w0 |= 0x060000 | ($2 & 0x3F) << 8 | $1 << 6;
 831 | 			/*
 832 | 			 * $$$ oops, can't check expr_seg because both abs_short_addr and
 833 | 			 * abs_addr touch it
 834 | 			 */
 835 | 			if($2 > 0x003F && pass == 2)
 836 | 				yywarning("warning: address operand truncated");
 837 | 			w1 |= $4-1;}
 838 | 	|	x_or_y abs_addr ',' abs_addr
 839 | 			{w0 |= 0x060000 | ($2 & 0x3F) << 8 | $1 << 6;
 840 | 			/*
 841 | 			 * $$$ oops, can't check expr_seg because both abs_short_addr and
 842 | 			 * abs_addr touch it
 843 | 			 */
 844 | 			if($2 > 0x003F && pass == 2)
 845 | 				yywarning("warning: address operand truncated");
 846 | 			w1 |= $4-1;}
 847 | 	;       		
 848 | 
 849 | rep_args
 850 | 	:	ix
 851 | 			{int ival = n2int($1);
 852 | 			w0 |= 0x0600A0 | (ival & 0xFF) << 8 | (ival & 0xF00)>> 8;
 853 | 			if(ival > 0xFFF && pass == 2) {
 854 | 				yywarning("warning: immediate operand truncated");
 855 | 			}}
 856 | 	|	regs
 857 | 			{w0 |= 0x06C020 | $1.r6 << 8;
 858 | 			hot_rreg = hot_nreg = hot_mreg = -1;}
 859 | 	|	x_or_y ea_no_ext
 860 | 			{w0 |= 0x064020 | $1 << 6 | $2 << 8;}
 861 | 	|	x_or_y abs_addr
 862 | 			{w0 |= 0x060020 | $1 << 6 | ($2 & 0x3F) << 8;
 863 | 			if(expr_seg != ANY && ($1 == 0 && expr_seg != XDATA ||
 864 | 				$1 == 1 && expr_seg != YDATA))
 865 | 				yywarning("warning: space mismatch");
 866 | 			if($2 > 0x003F && pass == 2)
 867 | 				yywarning("warning: address operand truncated");
 868 | 			}
 869 | 	|	x_or_y abs_short_addr	/* forced */
 870 | 			{w0 |= 0x060020 | $1 << 6 | ($2 & 0x3F) << 8;
 871 | 			if(expr_seg != ANY && ($1 == 0 && expr_seg != XDATA ||
 872 | 				$1 == 1 && expr_seg != YDATA))
 873 | 				yywarning("warning: space mismatch");
 874 | 			if($2 > 0x003F && pass == 2)
 875 | 				yywarning("warning: address operand truncated");
 876 | 			}
 877 | 	;
 878 | 
 879 | control_args
 880 | 	:	b5_10111_max ',' x_or_y p6_ean_a6 ',' abs_addr
 881 | 			{w0 |= $1 << 0 | $3 << 6;
 882 | 			uses_w1++;
 883 | 			w1 = $6;}
 884 | 	|	b5_10111_max ',' regs ',' abs_addr
 885 | 			{w0 |= 0x00C000 | $1 << 0 | $3.r6 << 8;
 886 | 			hot_rreg = hot_nreg = hot_mreg = -1;
 887 | 			uses_w1++;
 888 | 			w1 = $5;}
 889 | 	;
 890 | 
 891 | p6_ean_a6
 892 | 	:	abs_addr	/* in pass 2 can always discern size. */
 893 | 				/* Sometimes in pass one, too.  But since */
 894 | 				/* address extension is always used for the */
 895 | 				/* branch target, pass 1 can assume the */
 896 | 				/* symbol value will fit; warning in pass 2 */
 897 | 				/* if it doesn't */
 898 | 			{if($1 != -1) {	/* symbol defined */
 899 | 				w0 |= ($1 & 0x3F) << 8;
 900 | 				if($1 >= 0xFFC0) {
 901 | 					w0 |= 0x008080;
 902 | 				} else {
 903 | 					w0 |= 0x000080;
 904 | 					if($1 > 0x003F && pass == 2)
 905 | 						yywarning("warning: address operand truncated");
 906 | 				}
 907 | 			}}
 908 | 	|	abs_short_addr
 909 | 			{if($1 != -1) {
 910 | 				if($1 > 0x3F && pass == 2)
 911 | 					yywarning("warning: address operand truncated");
 912 | 				w0 |= 0x000080 | ($1 & 0x3F) << 8;
 913 | 			}}
 914 | 	|	io_short_addr
 915 | 			{if($1 != -1) {
 916 | 				if($1 < 0xFFC0 && pass == 2)
 917 | 					yywarning("warning: address operand truncated");
 918 | 				w0 |= 0x008080 | ($1 & 0x3F) << 8;
 919 | 			}}
 920 | 	|	ea_no_ext
 921 | 			{w0 |= 0x004080 | $1 << 8;}
 922 | 	;
 923 | 
 924 | /*%%%**************************** bit instructions ***************************/
 925 | 
 926 | bit_inst
 927 | 	:	OP_BTST bit_args
 928 | 			{w0 |= 0x0B0020;}
 929 | 	|	OP_BCHG bit_args
 930 | 			{w0 |= 0x0B0000;}
 931 | 	|	OP_BSET bit_args
 932 | 			{w0 |= 0x0A0020;}
 933 | 	|	OP_BCLR bit_args
 934 | 			{w0 |= 0x0A0000;}
 935 | 	;       		
 936 | 
 937 | bit_args
 938 | 	:	b5_10111_max ',' x_or_y p6_ea_a6
 939 | 			{w0 |= $1 << 0 | $3 << 6;
 940 | 			}
 941 | 	|	b5_10111_max ',' regs
 942 | 			{w0 |= 0x00C040 | $1 << 0 | $3.r6 << 8;}
 943 | 	;       	
 944 | 
 945 | p6_ea_a6
 946 | 	:	io_short_addr	/* must be forced to tell from abs_addr */
 947 | 			{if($1 != -1) {
 948 | 				w0 |= ($1 & 0x3F) << 8 | 0x008000;
 949 | 				if($1 < 0xFFC0 && pass == 2)
 950 | 					yywarning("warning: address operand truncated");
 951 | 			}}
 952 | 	|	abs_short_addr	/* must be forced to tell from abs_addr */
 953 | 			{if($1 != -1) {
 954 | 				w0 |= ($1 & 0x3F) << 8 | 0x000000;
 955 | 				if($1 > 0x003F && pass == 2)
 956 | 					yywarning("warning: address operand truncated");
 957 | 			}}
 958 | 	|	ea	/* can use abs_addr */
 959 | 			{w0 |= 0x004000;}
 960 | 	;
 961 | 
 962 | /*%%%************************** move instructions **********************/
 963 | 
 964 | move_inst
 965 | 	:	OP_MOVEP movep_args
 966 | 	|	OP_MOVEM movem_args
 967 | 	|	OP_MOVEC movec_args
 968 | 	|	OP_LUA ea_short ',' regs
 969 | 			{w0 |= 0x044010 | $2 << 8 | $4.r4;}
 970 | 	|	OP_TCC tcc_args
 971 | 			{w0 |= $1 << 12;}
 972 | 	;       	
 973 | 
 974 | tcc_args
 975 | 	:	tcc_sd
 976 | 			{w0 |= 0x020000 | $1 << 3;}
 977 | 	|	tcc_sd RREG ',' RREG
 978 | 			{w0 |= 0x030000 | $1 << 3 | $2 << 8 | $4;}
 979 | 	;
 980 | 
 981 | tcc_sd
 982 | 	:	regs /* a_b */ ',' regs /* a_b */
 983 | 			{hot_rreg = hot_nreg = hot_mreg = -1;
 984 | 			if($1.flags & R_AB && $3.flags & R_AB) {
 985 | 				if($1.ab == $3.ab) 
 986 | 					yyerror("source and dest must be different");
 987 | 				$$ = $3.ab;
 988 | 			} else if($1.flags & R_XREG && $3.flags & R_AB) {
 989 | 				$$ = 0x8 | $1.xreg << 2 | $3.ab;
 990 | 			} else if($1.flags & R_YREG && $3.flags & R_AB) {
 991 | 				$$ = 0xA | $1.yreg << 2 | $3.ab;
 992 | 			} else 
 993 | 				yyerror("illegal TCC operands");
 994 | 			}
 995 | 	;
 996 | 
 997 | sd3	:	regs /* XREG */ ',' regs /* a_b */
 998 | 			{hot_rreg = hot_nreg = hot_mreg = -1;
 999 | 			if($1.flags & R_XREG && $3.flags & R_AB) {
1000 | 				$$ = $1.xreg << 2 | $3.ab;
1001 | 			} else if($1.flags & R_YREG && $3.flags & R_AB) {
1002 | 				$$ = $1.yreg << 2 | 2 | $3.ab;
1003 | 			}}
1004 | 	;
1005 | 
1006 | movec_args
1007 | 	:	x_or_y ea ',' regs /* ctl_reg */
1008 | 			{if(NOT ($4.flags & R_CTL_REG))
1009 | 				yyerror("bad MOVEC target register");
1010 | 			if(expr_seg != ANY && ($1 == 0 && expr_seg != XDATA ||
1011 | 				$1 == 1 && expr_seg != YDATA))
1012 | 				yywarning("warning: space mismatch");
1013 | 			if($1 == 0) {
1014 | 				w0 |= 0x05C020 | $4.ctl_reg;
1015 | 			} else {
1016 | 				w0 |= 0x05C060 | $4.ctl_reg;
1017 | 			}}
1018 | 	|	regs /* ctl_reg */ ',' x_or_y ea
1019 | 			{hot_rreg = hot_nreg = hot_mreg = -1;
1020 | 			if(NOT ($1.flags & R_CTL_REG))
1021 | 				yyerror("bad MOVEC source register");
1022 | 			if($3 == 0) {
1023 | 				w0 |= 0x054020 | $1.ctl_reg;
1024 | 			} else {
1025 | 				w0 |= 0x054060 | $1.ctl_reg;
1026 | 			}}
1027 | 	|	ix ',' regs /* ctl_reg */
1028 | 			{int ival = n2int($1);
1029 | 			if(NOT ($3.flags & R_CTL_REG))
1030 | 				yyerror("bad MOVEC target register");
1031 | 			if(ival < 256 && NOT long_symbolic_expr) {
1032 | 				w0 |= 0x0500A0 | (ival & 0xFF) << 8 | $3.ctl_reg; 
1033 | 			} else {
1034 | 				w0 |= 0x05C020 | 0x003400 | $3.ctl_reg;
1035 | 				uses_w1++; w1 = ival & 0xFFFF;
1036 | 			}}
1037 | 	|	x_or_y abs_short_addr ',' regs /* ctl_reg */
1038 | 			{if($1 == 0) {
1039 | 				w0 |= 0x058020 | ($2 & 0x3F) << 8 | $4.ctl_reg;
1040 | 			} else {
1041 | 				w0 |= 0x058060 | ($2 & 0x3F) << 8 | $4.ctl_reg;
1042 | 			}
1043 | 			if(NOT ($4.flags & R_CTL_REG))
1044 | 				yyerror("bad MOVEC target register");
1045 | 			if($2 > 0x003F && pass == 2)
1046 | 				yywarning("warning: address operand truncated");
1047 | 			}
1048 | 	|	regs /* ctl_reg */ ',' x_or_y abs_short_addr
1049 | 			{hot_rreg = hot_nreg = hot_mreg = -1;
1050 | 			if($3 == 0) {
1051 | 				w0 |= 0x050020 | ($4 & 0x3F) << 8 | $1.ctl_reg;
1052 | 			} else {
1053 | 				w0 |= 0x050060 | ($4 & 0x3F) << 8 | $1.ctl_reg;
1054 | 			}
1055 | 			if(NOT ($1.flags & R_CTL_REG))
1056 | 				yyerror("bad MOVEC source register");
1057 | 			if($4 > 0x003F && pass == 2)
1058 | 				yywarning("warning: address operand truncated");
1059 | 			}
1060 | 	|	regs /* ctl_reg */ ',' regs
1061 | 			{if($1.flags & R_CTL_REG) {
1062 | 				w0 |= 0x0440A0 | $3.r6 << 8 | $1.ctl_reg;
1063 | 			} else if($3.flags & R_CTL_REG) {
1064 | 				w0 |= 0x04C0A0 | $1.r6 << 8 | $3.ctl_reg;
1065 | 			} else if($1.flags & $3.flags & R_CTL_REG) {
1066 | 				/* bogus? $$$ */
1067 | 	       			w0 |= 0x04C0A0 | ($1.ctl_reg | 0x20) << 8 | 
1068 | 				$3.ctl_reg;
1069 | 			} else {
1070 | 				yyerror("MOVEC must reference a control reg");
1071 | 			}}
1072 | 	;
1073 | 
1074 | movep_args
1075 | 	:	x_or_y movep_ea_pp ',' x_or_y movep_ea_pp
1076 | 			{w0 |= 0x084080;
1077 | 			switch($2.pp << 1 | $5.pp) {
1078 | 				case 0:	case 3:
1079 | 					yyerror("illegal MOVEP; can't move EA to EA or IO to IO");
1080 | 					break;
1081 | 				case 1:	/* ea, pp */
1082 | 					w0 |= $4 << 16 | 1 << 15 | $1 << 6 |
1083 | 						($5.ext & 0x3F);
1084 | 					if($2.mode == 0x003000) {
1085 | 						w0 |= 0x003000;
1086 | 						uses_w1++;
1087 | 						w1 = $2.ext;
1088 | 					} else {
1089 | 						w0 |= $2.mode;
1090 | 					}
1091 | 					break;
1092 | 				case 2:	/* pp, ea */
1093 | 					w0 |= $1 << 16 | 0 << 15 | $4 << 6 |
1094 | 						($2.ext & 0x3F);
1095 | 					if($5.mode == 0x003000) {
1096 | 						w0 |= 0x003000;
1097 | 						uses_w1++;
1098 | 						w1 = $5.ext;
1099 | 					} else {
1100 | 						w0 |= $5.mode;
1101 | 					}
1102 | 					break;
1103 | 			}}
1104 | 	|	ix ',' x_or_y num_or_sym
1105 | 			{w0 |= 0x084080;
1106 | 			w0 |= $3 << 16 | 1 << 15 | 0x34 << 8 | 
1107 | 				(n2int($4) & 0x3F);
1108 | 			uses_w1++;
1109 | 			w1 = n2int($1);}
1110 | 	|	PMEM ea ',' x_or_y num_or_sym
1111 | 			{w0 |= 0x084040;
1112 | 			w0 |= $4 << 16 | 1 << 15 | (n2int($5) & 0x3F);}
1113 | 	|	x_or_y movep_ea_pp ',' PMEM ea
1114 | 			{w0 |= 0x084040;
1115 | 			if($2.mode != 0x003000 && $2.mode != 0)
1116 | 				yyerror("illegal MOVEP");
1117 | 			w0 |= $1 << 16 | 0 << 15 | ($2.ext & 0x3F);}
1118 | 	|	regs ',' x_or_y num_or_sym
1119 | 			{hot_rreg = hot_nreg = hot_mreg = -1;
1120 | 			w0 |= 0x084000;
1121 | 			w0 |= $3 << 16 | 1 << 15 | $1.r6 << 8 | 
1122 | 				(n2int($4) & 0x3F);}
1123 | 	|	x_or_y movep_ea_pp ',' regs
1124 | 			{hot_rreg = hot_nreg = hot_mreg = -1;
1125 | 			w0 |= 0x084000;
1126 | 			if(!$2.pp)
1127 | 				yyerror("illegal MOVEP");
1128 | 			w0 |= $1 << 16 | 0 << 15 | $4.r6 << 8 | ($2.ext & 0x3F);}
1129 | 	;
1130 | 
1131 | movep_ea_pp
1132 | 	:	abs_addr
1133 | 			{if($1 != UNDEF && $1 >= 0xFFC0) {
1134 | 				/* defined symbol or constant, in i/o range */
1135 | 				$$.pp = 1;
1136 | 				$$.mode = 0;
1137 | 			} else {
1138 | 				/* either out of i/o range or symbol not */
1139 | 				/* yet defined:  assume ea extension */
1140 | 				$$.pp = 0;
1141 | 				$$.mode = 0x003000;
1142 | 			}
1143 | 			$$.ext = $1;}
1144 | 	|	io_short_addr	/* forced i/o short */
1145 | 			{$$.pp = 1;
1146 | 			$$.mode = 0;
1147 | 			if($1 < 0xFFC0 && pass == 2)
1148 | 				yywarning("warning: address operand truncated");
1149 | 			$$.ext = $1;}
1150 | 	|	ea_no_ext
1151 | 			{$$.pp = 0;
1152 | 			$$.mode = $1 << 8;
1153 | 			$$.ext = $1;}
1154 | 	;
1155 | 
1156 | movem_args
1157 | 	:	regs ',' PMEM ea_a6
1158 | 			{w0 |= 0x070000 | 0 << 15 | $1.r6;}
1159 | 	|	PMEM ea_a6 ',' regs
1160 | 			{hot_rreg = hot_nreg = hot_mreg = -1;
1161 | 			w0 |= 0x070000 | 1 << 15 | $4.r6;}
1162 | 	;
1163 | 
1164 | /*%%%**************** memory reference fields ************************/
1165 | 
1166 | b5_10111_max
1167 | 	:	ix
1168 | 			{int ival = n2int($1);
1169 | 			$$ = ival; if(ival > 0x17) 
1170 | 				yyerror("%d: illegal bit number", ival);}
1171 | 	;
1172 | 
1173 | x_or_y
1174 | 	:	XMEM
1175 | 			{$$ = 0;}
1176 | 	|	YMEM
1177 | 			{$$ = 1;}
1178 | 	;
1179 | 
1180 | /*%%%**************** effective address fields ************************/
1181 | 
1182 | ea_a6
1183 | 	:	ea
1184 | 			{w0 |= 0x004080;}
1185 | 	|	abs_short_addr
1186 | 			{w0 |= ($1 & 0x3F) << 8;
1187 | 			if($1 > 0x003F && pass == 2)
1188 | 				yywarning("warning: address operand truncated");
1189 | 			}
1190 | 	;
1191 | 
1192 | ea_a12
1193 | 	:	ea
1194 | 			{$$ = 1;}
1195 | 	|	abs_short_addr
1196 | 			{w0 |= $1 & 0xFFF; $$ = 0;
1197 | 			if($1 > 0x0FFF && pass == 2)
1198 | 				yywarning("warning: address operand truncated");
1199 | 			}
1200 | 	;
1201 | 
1202 | ea	:	abs_addr
1203 | 			{w0 |= 0x003000;
1204 | 			uses_w1++;
1205 | 			w1 |= $1;
1206 | 			$$ = 0x003000;}
1207 | 	|	ea_no_ext
1208 | 			{w0 |= $1 << 8;
1209 | 			$$ = $1 << 8;
1210 | 			expr_seg = ANY;}
1211 | 	;
1212 | 
1213 | ea_no_ext
1214 | 	:	ea_short
1215 | 			{$$ = $1;}
1216 | 	|	'(' RREG ')'
1217 | 			{if($2 == prev_hot_rreg) yywarning("warning: r%d just loaded", $2);
1218 | 			$$ = 4 << 3 | $2;}
1219 | 	|	'(' RREG '+' NREG ')'
1220 | 			{if($2 == prev_hot_rreg) yywarning("warning: r%d just loaded", $2);
1221 | 			if($4 == prev_hot_nreg) yywarning("warning: n%d just loaded", $4);
1222 | 			if($2 == prev_hot_mreg) yywarning("warning: m%d just loaded", $2);
1223 | 			$$ = 5 << 3 | $2;
1224 | 			if($2 != $4) yyerror("Rn and Nn must be same number");}
1225 | 	|	'-' '(' RREG ')'
1226 | 			{if($3 == prev_hot_rreg) yywarning("warning: r%d just loaded", $3);
1227 | 			if($3 == prev_hot_mreg) yywarning("warning: m%d just loaded", $3);
1228 | 			$$ = 7 << 3 | $3;}
1229 | 	;
1230 | 
1231 | ea_short
1232 | 	:	'(' RREG ')' '-' NREG
1233 | 			{if($2 == prev_hot_rreg) yywarning("warning: r%d just loaded", $2);
1234 | 			if($5 == prev_hot_nreg) yywarning("warning: n%d just loaded", $5);
1235 | 			if($2 == prev_hot_mreg) yywarning("warning: m%d just loaded", $2);
1236 | 			$$ = 0 << 3 | $2;
1237 | 			expr_seg = ANY;
1238 | 			if($2 != $5) yyerror("Rn and Nn must be same number");}
1239 | 	|	'(' RREG ')' '+' NREG
1240 | 			{if($2 == prev_hot_rreg) yywarning("warning: r%d just loaded", $2);
1241 | 			if($5 == prev_hot_nreg) yywarning("warning: n%d just loaded", $5);
1242 | 			if($2 == prev_hot_mreg) yywarning("warning: m%d just loaded", $2);
1243 | 			$$ = 1 << 3 | $2;
1244 | 			expr_seg = ANY;
1245 | 			if($2 != $5) yyerror("Rn and Nn must be same number");}
1246 | 	|	'(' RREG ')' '-'
1247 | 			{if($2 == prev_hot_rreg) yywarning("warning: r%d just loaded", $2);
1248 | 			if($2 == prev_hot_mreg) yywarning("warning: m%d just loaded", $2);
1249 | 			expr_seg = ANY;
1250 | 			$$ = 2 << 3 | $2;}
1251 | 	|	'(' RREG ')' '+'
1252 | 			{if($2 == prev_hot_rreg) yywarning("warning: r%d just loaded", $2);
1253 | 			if($2 == prev_hot_mreg) yywarning("warning: m%d just loaded", $2);
1254 | 			expr_seg = ANY;
1255 | 			$$ = 3 << 3 | $2;}
1256 | 	;
1257 | 
1258 | /*%%%******************* register fields ******************************/
1259 | 
1260 | regs
1261 | 	:	XREG
1262 | 			{$$.r6 = $$.r5 = 0x04 | $1;
1263 | 			$$.sdx = $1;
1264 | 			$$.xreg = $1;
1265 | 			$$.flags = R_R6|R_R5|R_XREG|R_SDX|R_SFRAC;}
1266 | 	|	YREG
1267 | 			{$$.r6 = $$.r5 = 0x06 | $1;
1268 | 			$$.sdy = $1;
1269 | 			$$.yreg = $1;
1270 | 			$$.flags = R_R6|R_R5|R_SDY|R_YREG|R_SFRAC;}
1271 | 	|	AREG
1272 | 			{switch($1) {
1273 | 				case 0: 
1274 | 					$$.r6 = $$.r5 = 0x08 | 0; 
1275 | 					break;
1276 | 				case 1: 
1277 | 					$$.r6 = $$.r5 = 0x08 | 4; 
1278 | 					break;
1279 | 				case 2: 
1280 | 					$$.r6 = $$.r5 = 0x08 | 2; 
1281 | 					break;
1282 | 			}
1283 | 			$$.flags = R_R6|R_R5|R_UINT;}
1284 | 	|	BREG
1285 | 			{switch($1) {
1286 | 				case 0: 
1287 | 					$$.r6 = $$.r5 = 0x08 | 1; break;
1288 | 				case 1: 
1289 | 					$$.r6 = $$.r5 = 0x08 | 5; break;
1290 | 				case 2: 
1291 | 					$$.r6 = $$.r5 = 0x08 | 3; break;
1292 | 			}
1293 | 			$$.flags = R_R6|R_R5|R_UINT;}
1294 | 	|	AAAA
1295 | 			{$$.r6 = $$.r5 = 0x0E;
1296 | 			$$.sdx = $$.sdy = 0x2;
1297 | 			$$.ab = 0;
1298 | 			$$.lsd = 4;
1299 | 			$$.flags = R_R6|R_R5|R_SDX|R_SDY|R_AB|R_LSD|R_SFRAC;}
1300 | 	|	BBBB
1301 | 			{$$.r6 = $$.r5 = 0x0F;
1302 | 			$$.sdx = $$.sdy = 0x3;
1303 | 			$$.ab = 1;
1304 | 			$$.lsd = 5;
1305 | 			$$.flags = R_R6|R_R5|R_SDX|R_SDY|R_AB|R_LSD|R_SFRAC;}
1306 | 	|	RREG
1307 | 			{$$.r6 = $$.r5 = 0x10 | $1;
1308 | 			$$.r4 = 0x00 | $1;
1309 | 			$$.flags = R_R6|R_R5|R_R4|R_UINT;
1310 | 			hot_rreg = $1;}
1311 | 	|	NREG
1312 | 			{$$.r6 = $$.r5 = 0x18 | $1;
1313 | 			$$.r4 = 0x08 | $1;
1314 | 			$$.flags = R_R6|R_R5|R_R4|R_UINT;
1315 | 			hot_nreg = $1;}
1316 | 	|	MREG
1317 | 			{$$.r6 = 0x20 | $1;
1318 | 			$$.r5 = -1;
1319 | 			$$.ctl_reg = $1;
1320 | 			$$.flags = R_R6|R_R5|R_CTL_REG|R_UINT;
1321 | 			hot_mreg = $1;}
1322 | 	|	prog_ctl_reg
1323 | 			{$$.r6 = 0x38 | $1;
1324 | 			$$.r5 = -1;
1325 | 			$$.ctl_reg = 0x18 | $1;
1326 | 			$$.flags = R_R6|R_R5|R_CTL_REG|R_UINT;}
1327 | 	|	A10
1328 | 			{$$.lsd  = 0;
1329 | 			$$.flags = R_LSD;}
1330 | 	|	B10
1331 | 			{$$.lsd = 1;
1332 | 			$$.flags = R_LSD;}
1333 | 	|	XXXX
1334 | 			{$$.lsd = 2;
1335 | 			$$.flags = R_LSD;}
1336 | 	|	YYYY
1337 | 			{$$.lsd = 3;
1338 | 			$$.flags = R_LSD;}
1339 | 	|	AABB
1340 | 			{$$.lsd = 6;
1341 | 			$$.flags = R_LSD;}
1342 | 	|	BBAA
1343 | 			{$$.lsd = 7;
1344 | 			$$.flags = R_LSD;}
1345 | 	;
1346 | 
1347 | prog_ctl_reg
1348 | 	:	SR
1349 | 			{$$ = 1;}
1350 | 	|	OMR
1351 | 			{$$ = 2;}
1352 | 	|	SP
1353 | 			{$$ = 3;}
1354 | 	|	SSH
1355 | 			{$$ = 4;}
1356 | 	|	SSL
1357 | 			{$$ = 5;}
1358 | 	|	LA
1359 | 			{$$ = 6;}
1360 | 	|	LC
1361 | 			{$$ = 7;}
1362 | 	;
1363 | 
1364 | funky_ctl_reg
1365 | 	:	MR
1366 | 			{$$ = 0;}
1367 | 	|	CCR
1368 | 			{$$ = 1;}
1369 | 	|	OMR
1370 | 			{$$ = 2;}
1371 | 	;
1372 | 
1373 | /*%%%************************* parallel moves *************/
1374 | 
1375 | parallel_move
1376 | 	:	i_move
1377 | 	|	u_move
1378 | 	|	x_or_y_move
1379 | 	|	xr_move
1380 | 	|	ry_move
1381 | 	|	r_move
1382 | 	|	xy_move
1383 | 	|	l_move
1384 | 	;
1385 | 
1386 | i_move  :	ix ',' regs
1387 | 			{int ival = n2int($1);
1388 | 			int frac = n2frac($1);
1389 | 			int value;
1390 | 			BOOL shortform = FALSE;
1391 | 			if($3.flags & R_CTL_REG) {
1392 | 				yyerror("please use MOVEC for control register moves");
1393 | 				break;
1394 | 			}
1395 | 			if(($3.flags & R_SFRAC) && $1.type == FLT) {
1396 | 				if((frac & 0xFFFF) == 0 && 
1397 | 					NOT long_symbolic_expr) {
1398 | 					value = frac >> 16;
1399 | 					shortform++;
1400 | 				} else {
1401 | 					value = frac;
1402 | 				}
1403 | 			} else {
1404 | 				if(ival <= 0xFF && ival >= -0xFF && NOT long_symbolic_expr) {
1405 | 					value = ival;
1406 | 					shortform++;
1407 | 				} else {
1408 | 					value = ival;
1409 | 				}
1410 | 			}
1411 | 
1412 | 			if(shortform) {
1413 | 				w0 |= 0x200000 | (value & 0xFF) << 8 |
1414 | 					$3.r5 << 16;
1415 | 			} else {
1416 | 				w0 |= 0x400000 | 0x00F400 |
1417 | 					($3.r5 >> 3 & 3) << 20 | 
1418 | 					($3.r5 & 7) << 16;
1419 | 				uses_w1++; w1 = value;
1420 | 			}}
1421 | 	;
1422 | 
1423 | r_move	:	regs ',' regs
1424 | 			{
1425 | 				if($3.flags & R_CTL_REG) {
1426 | 					yyerror("please use MOVEC for control register moves");
1427 | 					break;
1428 | 				}
1429 | 				if($1.flags & R_R5 & $3.flags) 
1430 | 					w0 |= 0x200000 | $3.r5 << 8 | $1.r5 << 13;
1431 | 				else
1432 | 					yyerror("illegal R move");
1433 | 			}	
1434 | 	;
1435 | 
1436 | u_move	:	ea_short
1437 | 			{w0 |= 0x204000 | $1 << 8;}
1438 | 	;
1439 | 
1440 | x_or_y_move
1441 | 	:	x_or_y ea ',' regs
1442 | 			{w0 |= 0x40C000 | $1 << 19;
1443 | 			if(expr_seg != ANY && ($1 == 0 && expr_seg != XDATA ||
1444 | 				$1 == 1 && expr_seg != YDATA))
1445 | 				yywarning("warning: space mismatch");
1446 | 			if($4.flags & R_CTL_REG) {
1447 | 				yyerror("please use MOVEC for control register moves");
1448 | 				break;
1449 | 			}
1450 | 			w0 |= ($4.r5 >> 3 & 3) << 20 | ($4.r5 & 7) << 16;}
1451 | 	|	x_or_y abs_short_addr ',' regs
1452 | 			{w0 |= 0x408000 | $1 << 19 | ($2 & 0x3F) << 8;
1453 | 			if(expr_seg != ANY && ($1 == 0 && expr_seg != XDATA ||
1454 | 				$1 == 1 && expr_seg != YDATA))
1455 | 				yywarning("warning: space mismatch");
1456 | 			if($4.flags & R_CTL_REG) {
1457 | 				yyerror("please use MOVEC for control register moves");
1458 | 				break;
1459 | 			}
1460 | 			if($2 > 0x003F && pass == 2)
1461 | 				yywarning("warning: address operand truncated");
1462 | 			w0 |= ($4.r5>> 3 & 3) << 20 | ($4.r5 & 7) << 16;}
1463 | 	|	regs ',' x_or_y ea
1464 | 			{hot_rreg = hot_nreg = hot_mreg = -1;
1465 | 			w0 |= 0x404000 | $3 << 19;
1466 | 			if(expr_seg != ANY && ($3 == 0 && expr_seg != XDATA ||
1467 | 				$3 == 1 && expr_seg != YDATA))
1468 | 				yywarning("warning: space mismatch");
1469 | 			if($1.flags & R_CTL_REG) {
1470 | 				yyerror("please use MOVEC for control register moves");
1471 | 				break;
1472 | 			}
1473 | 			w0 |= ($1.r5 >> 3 & 3) << 20 | ($1.r5 & 7) << 16;}
1474 | 	|	regs ',' x_or_y abs_short_addr
1475 | 			{hot_rreg = hot_nreg = hot_mreg = -1;
1476 | 			w0 |= 0x400000 | $3 << 19 | ($4 & 0x3F) << 8;
1477 | 			if($1.flags & R_CTL_REG) {
1478 | 				yyerror("please use MOVEC for control register moves");
1479 | 				break;
1480 | 			}
1481 | 			if(expr_seg != ANY && ($3 == 0 && expr_seg != XDATA ||
1482 | 				$3 == 1 && expr_seg != YDATA))
1483 | 				yywarning("warning: space mismatch");
1484 | 			if($4 > 0x003F && pass == 2)
1485 | 				yywarning("warning: address operand truncated");
1486 | 			w0 |= ($1.r5 >> 3 & 3) << 20 | ($1.r5 & 7) << 16;}
1487 | 	|	ix_long ',' regs
1488 | 			{w0 |= 0x400000 | 0x00F400 | ($3.r5 >> 3 & 3) << 20 |
1489 | 			    ($3.r5 & 7) << 16;
1490 | 			if($3.flags & R_CTL_REG) {
1491 | 				yyerror("please use MOVEC for control register moves");
1492 | 				break;
1493 | 			}
1494 | 			uses_w1++; w1 = n2frac($1);
1495 | 			}
1496 | 	;
1497 | 
1498 | xr_move
1499 | 	:	x_or_y /* XMEM */ ea ',' regs	regs /* a_b */ ',' YREG
1500 | 			{hot_rreg = hot_nreg = hot_mreg = -1;
1501 | 			if(expr_seg != ANY && ($1 == 0 && expr_seg != XDATA ||
1502 | 				$1 == 1 && expr_seg != YDATA))
1503 | 				yywarning("warning: space mismatch");
1504 | 			if($1 == 0 && $5.flags & R_AB) {
1505 | 				w0 |= 0x108000 | $4.sdx << 18 | $5.ab << 17 |
1506 | 					$7 << 16;
1507 | 			} else {
1508 | 				yyerror("illegal X:R move");
1509 | 			}}
1510 | 	| 	ix ',' regs		regs /* a_b */ ',' YREG
1511 | 			{hot_rreg = hot_nreg = hot_mreg = -1;
1512 | 			if($4.flags & R_AB) {
1513 | 				w0 |= 0x10B400 | $3.sdx << 18 | $4.ab << 17 |
1514 | 					$6 << 16;
1515 | 				uses_w1++;
1516 | 				w1 |= n2frac($1) & 0xFFFFFF;
1517 | 			} else {
1518 | 				yyerror("illegal X:R move");
1519 | 			}}
1520 | 	|	regs ',' x_or_y /* XMEM */ ea	regs /* a_b */ ',' regs/*YREG*/
1521 | 			{hot_rreg = hot_nreg = hot_mreg = -1;
1522 | 			if(expr_seg != ANY && ($3 == 0 && expr_seg != XDATA ||
1523 | 				$3 == 1 && expr_seg != YDATA))
1524 | 				yywarning("warning: space mismatch");
1525 | 			if($1.flags & R_SDX && $3 == 0 && $5.flags & R_AB &&
1526 | 				$7.flags & R_YREG) {
1527 | 				w0 |= 0x100000 | $1.sdx << 18 | $5.ab << 17 |
1528 | 					$7.yreg << 16;
1529 | 			} else if($1.flags & R_AB && $3 == 0 && 
1530 | 				$5.flags & R_XREG && $7.flags & R_AB) {
1531 | 				if($5.xreg != 0) yyerror("must use X0");
1532 | 				if($1.ab == 0 && $7.ab == 0)
1533 | 					w0 |= 0x080000;
1534 | 				else if($1.ab == 1 && $7.ab == 1)
1535 | 					w0 |= 0x090000;
1536 | 				else
1537 | 					yyerror("illegal X:R move");
1538 | 			} else {
1539 | 				yyerror("illegal X:R move");
1540 | 			}}
1541 | 	;
1542 | 
1543 | ry_move	:	regs /* a_b */ ',' regs /* XREG	*/      YMEM ea ',' regs
1544 | 			{hot_rreg = hot_nreg = hot_mreg = -1;
1545 | 			if($3.flags & R_XREG && $7.flags & (R_YREG|R_AB)) {
1546 | 				w0 |= 0x10C000 | $1.ab << 19 | $3.xreg << 18 |
1547 | 					$7.sdy << 16;
1548 | 			} else {
1549 | 				yyerror("illegal R:Y move");
1550 | 			}}
1551 | 	|	regs /* a_b */ ',' regs /* XREG	*/	ix ',' regs
1552 | 			{hot_rreg = hot_nreg = hot_mreg = -1;
1553 | 			if($3.flags & R_XREG && $6.flags & (R_YREG|R_AB)) {
1554 | 				w0 |= 0x10F400 | $1.ab << 19 | $3.xreg << 18 |
1555 | 					$6.sdy << 16;
1556 | 				uses_w1++;
1557 | 				w1 |= n2frac($4) & 0xFFFFFF;
1558 | 			} else {
1559 | 				yyerror("illegal R:Y move");
1560 | 			}}
1561 | 	|	regs /* a_b */ ',' regs /* XREG	*/	regs ',' YMEM ea
1562 | 			{hot_rreg = hot_nreg = hot_mreg = -1;
1563 | 			if($1.flags & R_AB && $3.flags & R_XREG) {
1564 | 				w0 |= 0x104000 | $1.ab << 19 | $3.xreg << 18 |
1565 | 				$4.sdy << 16;
1566 | 			} else if ($1.flags & R_YREG && $3.flags & R_AB &&
1567 | 				$4.flags & R_AB) {
1568 | 				if($1.yreg != 0) yyerror("must use Y0");
1569 | 				if($3.ab == 0 && $4.ab == 0)
1570 | 					w0 |= 0x088000;
1571 | 				else if($3.ab == 1 && $4.ab == 1)
1572 | 					w0 |= 0x098000;
1573 | 				else
1574 | 					yyerror("illegal R:Y move");
1575 | 			} else {
1576 | 				yyerror("illegal R:Y move");
1577 | 			}}
1578 | 	;
1579 | 
1580 | l_move
1581 | 	:	LMEM ea ',' regs /* lsd */
1582 | 			{if($4.flags & R_CTL_REG) {
1583 | 				yyerror("please use MOVEC for control register moves");
1584 | 				break;
1585 | 			}
1586 | 			w0 |= 0x40C000 | ($4.lsd & 3) << 16 | ($4.lsd >> 2) << 19;}
1587 | 	|	regs /* lsd */ ',' LMEM ea
1588 | 			{hot_rreg = hot_nreg = hot_mreg = -1;
1589 | 			if($1.flags & R_CTL_REG) {
1590 | 				yyerror("please use MOVEC for control register moves");
1591 | 				break;
1592 | 			}
1593 | 			w0 |= 0x404000 | ($1.lsd & 3) << 16 | ($1.lsd >> 2) << 19;}
1594 | 	|	LMEM abs_short_addr ',' regs /* lsd */
1595 | 			{w0 |= 0x408000 | ($4.lsd & 3) << 16 | ($4.lsd >> 2) << 19;
1596 | 			if($4.flags & R_CTL_REG) {
1597 | 				yyerror("please use MOVEC for control register moves");
1598 | 				break;
1599 | 			}
1600 | 			if($2 > 0x003F && pass == 2)
1601 | 				yywarning("warning: address operand truncated");
1602 | 			w0 |= ($2 & 0x3F) << 8;}
1603 | 	|	regs /* lsd */ ',' LMEM abs_short_addr
1604 | 			{hot_rreg = hot_nreg = hot_mreg = -1;
1605 | 			w0 |= 0x400000 | ($1.lsd & 3) << 16 | ($1.lsd >> 2) << 19;
1606 | 			if($1.flags & R_CTL_REG) {
1607 | 				yyerror("please use MOVEC for control register moves");
1608 | 				break;
1609 | 			}
1610 | 			if($4 > 0x003F && pass == 2)
1611 | 				yywarning("warning: address operand truncated");
1612 | 			w0 |= ($4 & 0x3F) << 8;}
1613 | 	;
1614 | 
1615 | xy_move
1616 | 	:	x_or_y /*XMEM*/ ea /*ea_strange*/ ',' regs	YMEM ea /*ea_strange*/ ',' regs
1617 | 			{int eax = $2, eay = $6,
1618 | 			     regx = ($4.flags & R_AB) ? $4.ab | 2 : $4.xreg,
1619 | 			     regy = ($8.flags & R_AB) ? $8.ab | 2 : $8.yreg;
1620 | 			hot_rreg = hot_nreg = hot_mreg = -1;
1621 | 			if((eax & 0x400) == (eay & 0x400))
1622 | 				yyerror("registers must be in opposite halves");
1623 | 			if(!($4.flags & (R_AB | R_XREG)))
1624 | 				yyerror("invalid X move register");
1625 | 			if(!($8.flags & (R_AB | R_YREG)))
1626 | 				yyerror("invalid Y move register");
1627 | 			if($4.flags & R_AB &&
1628 | 			   $8.flags & R_AB &&
1629 | 			   $4.ab == $8.ab)
1630 | 				yyerror("duplicate destination register");
1631 | 			w0 = w0 & 0xFF | 0xC08000;	/* both write */
1632 | 			w0 |= eax & 0x1f00 | (eay & 0x300) << 5 | (eay & 0x1800) << 9 | regx << 18 | regy << 16;}
1633 | 	|	x_or_y /*XMEM*/ ea /*ea_strange*/ ',' regs	regs ',' YMEM ea /*ea_strange*/
1634 | 			{int eax = $2, eay = $8,
1635 | 			     regx = ($4.flags & R_AB) ? $4.ab | 2 : $4.xreg,
1636 | 			     regy = ($5.flags & R_AB) ? $5.ab | 2 : $5.yreg;
1637 | 			hot_rreg = hot_nreg = hot_mreg = -1;
1638 | 			if((eax & 0x400) == (eay & 0x400))
1639 | 				yyerror("registers must be in opposite halves");
1640 | 			if(!($4.flags & (R_AB | R_XREG)))
1641 | 				yyerror("invalid X move register");
1642 | 			if(!($5.flags & (R_AB | R_YREG)))
1643 | 				yyerror("invalid Y move register");
1644 | 			w0 = w0 & 0xFF | 0x808000;	/* X:write, Y:read */
1645 | 			w0 |= eax & 0x1f00 | (eay & 0x300) << 5 | (eay & 0x1800) << 9 | regx << 18 | regy << 16;}
1646 | 	|	regs ',' x_or_y /*XMEM*/ ea /*ea_strange*/	YMEM ea /*ea_strange*/ ',' regs
1647 | 			{int eax = $4, eay = $6,
1648 | 			     regx = ($1.flags & R_AB) ? $1.ab | 2 : $1.xreg,
1649 | 			     regy = ($8.flags & R_AB) ? $8.ab | 2 : $8.yreg;
1650 | 			hot_rreg = hot_nreg = hot_mreg = -1;
1651 | 			if((eax & 0x400) == (eay & 0x400))
1652 | 				yyerror("registers must be in opposite halves");
1653 | 			if(!($1.flags & (R_AB | R_XREG)))
1654 | 				yyerror("invalid X move register");
1655 | 			if(!($8.flags & (R_AB | R_YREG)))
1656 | 				yyerror("invalid Y move register");
1657 | 	      		w0 = w0 & 0xFF | 0xC00000;	/* X:read, Y:write */
1658 | 			w0 |= eax & 0x1f00 | (eay & 0x300) << 5 | (eay & 0x1800) << 9 | regx << 18 | regy << 16;}
1659 | 	|	regs ',' x_or_y /*XMEM*/ ea /*ea_strange*/	regs ',' YMEM ea /*ea_strange*/
1660 | 			{int eax = $4, eay = $8,
1661 | 			     regx = ($1.flags & R_AB) ? $1.ab | 2 : $1.xreg,
1662 | 			     regy = ($5.flags & R_AB) ? $5.ab | 2 : $5.yreg;
1663 | 			hot_rreg = hot_nreg = hot_mreg = -1;
1664 | 			if((eax & 0x400) == (eay & 0x400))
1665 | 				yyerror("registers must be in opposite halves");
1666 | 			if(!($1.flags & (R_AB | R_XREG)))
1667 | 				yyerror("invalid X move register");
1668 | 			if(!($5.flags & (R_AB | R_YREG)))
1669 | 				yyerror("invalid Y move register");
1670 | 	      		w0 = w0 & 0xFF | 0x800000;	/* both read */
1671 | 			w0 |= eax & 0x1f00 | (eay & 0x300) << 5 | (eay & 0x1800) << 9 | regx << 18 | regy << 16;}
1672 | 	;
1673 | 
1674 | /*%%%******* absolute address and immediate data fields ************/
1675 | 
1676 | num	:	CHEX
1677 | 			{$$ = $1;}
1678 | 	|	CDEC
1679 | 			{$$ = $1;}
1680 | 	|	FRAC
1681 | 			{$$ = $1;}
1682 | 	;
1683 | 
1684 | ix	:	'#' expr
1685 | 			{$$ = $2; expr_seg = ANY;}
1686 | 	|	'#' '<' expr
1687 | 			{$$.val.i = n2int($3) & 0xFF;
1688 | 			$$.type = INT;
1689 | 			expr_seg = ANY;
1690 | 			long_symbolic_expr = FALSE;}
1691 | 	;
1692 | 
1693 | ix_long	:	'#' '>' expr
1694 | 			{$$ = $3; expr_seg = ANY;}
1695 | 	;
1696 | 
1697 | abs_addr
1698 | 	:	expr
1699 | 			{$$ = n2int($1);
1700 | 			expr_seg = $1.seg;}
1701 | 	;
1702 | 
1703 | abs_short_addr
1704 | 	:	'<' expr
1705 | 			{$$ = n2int($2);
1706 | 			expr_seg = $2.seg;}
1707 | 	;
1708 | 
1709 | io_short_addr
1710 | 	:	SHL expr
1711 | 			{$$ = n2int($2);
1712 | 			expr_seg = $2.seg;} 
1713 | 	;
1714 | 
1715 | num_or_sym
1716 | 	:	num
1717 | 			{$$ = $1;}
1718 | 	|	SYM
1719 | 			{$$ = sym_ref($1); free($1);}
1720 | 	|	io_short_addr
1721 | 			{$$.type = INT; $$.val.i = $1; $$.seg = expr_seg;}
1722 | 	;
1723 | 
1724 | num_or_sym_expr
1725 | 	:	num
1726 | 			{$$ = $1; expr_seg = $1.seg;}
1727 | 	|	SYM
1728 | 			{$$ = sym_ref($1);
1729 | 			free($1);
1730 | 			long_symbolic_expr++;
1731 | 			expr_seg = $$.seg;
1732 | 			}
1733 | 	|	CHAR
1734 | 			{$$.type = INT; $$.val.i = $1 & 0xFFFFFF; expr_seg = $$.seg = ANY;}
1735 | 	|	'*'
1736 | 			{$$.type = INT; $$.val.i = pc; expr_seg = $$.seg = ANY;}
1737 | 	|	OP_PI
1738 | 			{$$.type = FLT; $$.val.f = acos(-1.0); expr_seg = $$.seg = ANY;}
1739 | 	;
1740 | 
1741 | expr
1742 | 	:	OP_INT '(' expr ')'
1743 | 			{$$.type = INT; 
1744 | 			if($3.type == INT)
1745 | 				$$.val.i = $3.val.i;
1746 | 			else
1747 | 				$$.val.i = $3.val.f;
1748 | 			$$.seg = $3.seg;
1749 | 			}
1750 | 	|	expr '|' expr
1751 | 			{$$ = binary_op($1, '|', $3);}
1752 | 	|	expr '^' expr
1753 | 			{$$ = binary_op($1, '^', $3);}
1754 | 	|	expr '&' expr
1755 | 			{$$ = binary_op($1, '&', $3);}
1756 | 	|	expr SHR expr
1757 | 			{$$ = binary_op($1, SHR, $3);}
1758 | 	|	expr SHL expr
1759 | 			{$$ = binary_op($1, SHL, $3);}
1760 | 	|	expr '-' expr
1761 | 			{$$ = binary_op($1, '-', $3);}
1762 | 	|	expr '+' expr
1763 | 			{$$ = binary_op($1, '+', $3);}
1764 | 	|	expr '%' expr
1765 | 			{$$ = binary_op($1, '%', $3);}
1766 | 	|	expr '/' expr
1767 | 			{$$ = binary_op($1, '/', $3);}
1768 | 	|	expr '*' expr
1769 | 			{$$ = binary_op($1, '*', $3);}
1770 | 	|	'-' expr %prec '~'
1771 | 			{$$ = unary_op('-', $2);}
1772 | 	|	'~' expr
1773 | 			{$$ = unary_op('~', $2);}
1774 | 	|	OP_SIN '(' expr ')'
1775 | 			{$$ = unary_op('s', $3);}
1776 | 	|	OP_COS '(' expr ')'
1777 | 			{$$ = unary_op('c', $3);}
1778 | 	|	OP_TAN '(' expr ')'
1779 | 			{$$ = unary_op('t', $3);}
1780 | 	|	OP_ASIN '(' expr ')'
1781 | 			{$$ = unary_op('S', $3);}
1782 | 	|	OP_ACOS '(' expr ')'
1783 | 			{$$ = unary_op('C', $3);}
1784 | 	|	OP_ATAN '(' expr ')'
1785 | 			{$$ = unary_op('T', $3);}
1786 | 	|	OP_EXP '(' expr ')'
1787 | 			{$$ = unary_op('e', $3);}
1788 | 	|	OP_LN '(' expr ')'
1789 | 			{$$ = unary_op('l', $3);}
1790 | 	|	OP_LOG '(' expr ')'
1791 | 			{$$ = unary_op('L', $3);}
1792 | 	|	OP_ABS '(' expr ')'
1793 | 			{$$ = unary_op('a', $3);}
1794 | 	|	OP_POW '(' expr ',' expr ')'
1795 | 			{$$ = binary_op($3, 'p', $5);}
1796 | 	|	'(' expr ')'
1797 | 			{$$ = $2;}
1798 | 	|	num_or_sym_expr
1799 | 			{$$ = $1;}
1800 | 	;
1801 | 
1802 | /*%%%****************** end ******************************/
1803 | 
1804 | %%
1805 | 
1806 | #include <stdio.h>
1807 | #include <setjmp.h>
1808 | #ifdef _WIN32
1809 | #include <signal.h>
1810 | #else
1811 | #include <sys/signal.h>
1812 | #endif
1813 | 
1814 | int yydebug;
1815 | 
1816 | struct n binary_op(a1, op, a2)
1817 | struct n a1, a2;
1818 | int op;
1819 | {
1820 | 	struct n result;
1821 | 	int iarg1, iarg2;
1822 | 	double farg1, farg2;
1823 | 
1824 | 	if(a1.type == UNDEF || a2.type == UNDEF) {
1825 | 		result.type = UNDEF;
1826 | 		return result;
1827 | 	}
1828 | 
1829 | 	iarg1 = a1.type == INT ? a1.val.i : a1.val.f;
1830 | 	iarg2 = a2.type == INT ? a2.val.i : a2.val.f;
1831 | 
1832 | 	farg1 = a1.type == INT ? a1.val.i : a1.val.f;
1833 | 	farg2 = a2.type == INT ? a2.val.i : a2.val.f;
1834 | 
1835 | 	/* figure out target segment */
1836 | 
1837 | 	if(a1.seg == a2.seg)
1838 | 		result.seg = a1.seg;
1839 | 	else if(a1.seg == ANY)
1840 | 		result.seg = a2.seg;
1841 | 	else if(a2.seg == ANY)
1842 | 		result.seg = a1.seg;
1843 | 	else
1844 | 		result.seg = NONE;
1845 | 
1846 | 	/* promote to float automatically */
1847 | 
1848 | 	if(a1.type != a2.type) {
1849 | 		if(a1.type == INT) {
1850 | 			a1.val.f = a1.val.i;		/* truncate */
1851 | 			a1.type = FLT;
1852 | 		} else {
1853 | 			a2.val.f = a2.val.i;		/* truncate */
1854 | 		}
1855 | 	}
1856 | 	result.type = a1.type;
1857 | 
1858 | 	/* do the op */
1859 | 
1860 | 	switch(op) {
1861 | 	case '+':
1862 | 		if(result.type == INT) result.val.i = a1.val.i + a2.val.i;
1863 | 		else result.val.f = a1.val.f + a2.val.f;
1864 | 		break;
1865 | 	case '-':
1866 | 		if(result.type == INT) result.val.i = a1.val.i - a2.val.i;
1867 | 		else result.val.f = a1.val.f - a2.val.f;
1868 | 		break;
1869 | 	case '*':
1870 | 		if(result.type == INT) result.val.i = a1.val.i * a2.val.i;
1871 | 		else result.val.f = a1.val.f * a2.val.f;
1872 | 		break;
1873 | 	case '/':
1874 | 		if(result.type == INT) result.val.i = a1.val.i / a2.val.i;
1875 | 		else result.val.f = a1.val.f / a2.val.f;
1876 | 		break;
1877 | 	case '%':
1878 | 		result.val.i = iarg1 % iarg2;
1879 | 		result.type = INT;
1880 | 		break;
1881 | 	case SHL:
1882 | 		result.val.i = iarg1 << iarg2;
1883 | 		result.type = INT;
1884 | 		break;
1885 | 	case SHR:
1886 | 		result.val.i = iarg1 >> iarg2;
1887 | 		result.type = INT;
1888 | 		break;
1889 | 	case '|':
1890 | 		result.val.i = iarg1 | iarg2;
1891 | 		result.type = INT;
1892 | 		break;
1893 | 	case '&':
1894 | 		result.val.i = iarg1 & iarg2;
1895 | 		result.type = INT;
1896 | 		break;
1897 | 	case '^':
1898 | 		result.val.i = iarg1 ^ iarg2;
1899 | 		result.type = INT;
1900 | 		break;
1901 | 	case 'p':
1902 | 		result.val.f = pow(farg1, farg2);
1903 | 		result.type = FLT;
1904 | 	}
1905 | 
1906 | 	return result;
1907 | }
1908 | 
1909 | jmp_buf unary_env;
1910 | 
1911 | void
1912 | sigfpu()
1913 | {
1914 | 	longjmp(unary_env, 1);
1915 | }
1916 | 
1917 | char *unary_name(op)
1918 | {
1919 | 	switch(op) {
1920 | 	case 's':	return "sin";
1921 | 	case 'c':	return "cos";
1922 | 	case 't':	return "tan";
1923 | 	case 'S':	return "asin";
1924 | 	case 'C':	return "acos";
1925 | 	case 'T':	return "atan";
1926 | 	case 'e':	return "exp";
1927 |    	case 'l':	return "ln";
1928 | 	case 'L':	return "log";
1929 | 	case 'a':	return "abs";
1930 | 	}
1931 | }
1932 | 
1933 | struct n unary_op(op, a1)
1934 | int op;
1935 | struct n a1;
1936 | {
1937 | 	struct n result;
1938 | 	void (*orig)();
1939 | 	double farg;
1940 | 
1941 | 	if(a1.type == UNDEF) {
1942 | 		result.type = UNDEF;
1943 | 		return result;
1944 | 	}
1945 | 
1946 | 	result.seg = a1.seg;
1947 | 
1948 | 	/* do the op */
1949 | 
1950 | 	orig = signal(SIGFPE, sigfpu);
1951 | 	if(setjmp(unary_env)) {
1952 | 		yyerror("floating point exception in function %s", unary_name(op));
1953 | 		result.val.i = result.val.f = 0;
1954 | 	} else {
1955 | 		farg = a1.type == INT ? (double)a1.val.i : a1.val.f;
1956 | 		switch(op) {
1957 | 		case '-':
1958 | 			result.type = a1.type;
1959 | 			if(a1.type == INT) result.val.i = -a1.val.i;
1960 | 			else result.val.f = -a1.val.f;
1961 | 			break;
1962 | 		case '~':
1963 | 			result.type = a1.type;
1964 | 			if(a1.type == INT) result.val.i = ~a1.val.i;
1965 | 			else result.val.f = ~(int)a1.val.f;
1966 | 			break;
1967 | 		case 'a':
1968 | 			result.type = a1.type;
1969 | 			if(a1.type == INT) result.val.i = a1.val.i < 0 ? -a1.val.i : a1.val.i;
1970 | 			else result.val.f = result.val.f = a1.val.f < 0 ? -a1.val.f : a1.val.f;
1971 | 			break;
1972 | 		case 's':
1973 | 			result.type = FLT;
1974 | 			result.val.f = sin(farg);
1975 | 			break;
1976 | 		case 'c':
1977 | 			result.type = FLT;
1978 | 			result.val.f = cos(farg);
1979 | 			break;
1980 | 		case 't':
1981 | 			result.type = FLT;
1982 | 			result.val.f = tan(farg);
1983 | 			break;
1984 | 		case 'S':
1985 | 			result.type = FLT;
1986 | 			result.val.f = asin(farg);
1987 | 			break;
1988 | 		case 'C':
1989 | 			result.type = FLT;
1990 | 			result.val.f = acos(farg);
1991 | 			break;
1992 | 		case 'T':
1993 | 			result.type = FLT;
1994 | 			result.val.f = atan(farg);
1995 | 			break;
1996 | 		case 'e':
1997 | 			result.type = FLT;
1998 | 			result.val.f = exp(farg);
1999 | 			break;
2000 | 	   	case 'l':
2001 | 			result.type = FLT;
2002 | 			result.val.f = log(farg);
2003 | 			break;
2004 | 		case 'L':
2005 | 			result.type = FLT;
2006 | 			result.val.f = log10(farg);
2007 | 			break;
2008 | 		}
2009 | 	}
2010 | 	signal(SIGFPE, orig);
2011 | 
2012 | 	return result;
2013 | }
2014 | 
2015 | n2int(n)
2016 | struct n n;
2017 | {
2018 | 	if(n.type == UNDEF)
2019 | 		return UNDEF;
2020 | 	else if(n.type == INT)
2021 | 		return n.val.i;
2022 | 	else
2023 | 		return n.val.f;
2024 | }
2025 | 
2026 | n2frac(n)
2027 | struct n n;
2028 | {
2029 | 	double adval = n.val.f >= 0.0 ? n.val.f : -n.val.f;
2030 | 
2031 | 	if(n.type == UNDEF)
2032 | 		return UNDEF;
2033 | 	else if(n.type == INT)
2034 | 		return n.val.i;
2035 | 	else if(n.val.f == -1.0)
2036 | 		return 0x800000;
2037 | 
2038 | 	adval -= (double)(int)adval;
2039 | 	adval *= (double)0x800000;
2040 | 	adval += 0.5;
2041 | 
2042 | 	if(n.val.f >= 0.0)
2043 | 		return adval;
2044 | 	else
2045 | 		return -adval;
2046 | }
2047 | 
2048 | extern struct {int n; char *name;} tok_tab[];
2049 | extern int n_tok;
2050 | 
2051 | char *tok_print(tok)
2052 | int tok;
2053 | {
2054 | 	int i;
2055 | 	static char buf[32];
2056 | 
2057 | 	if(tok == '1') {
2058 | 		i = 1;
2059 | 	}
2060 | 
2061 | 	if(tok < 256) {
2062 | 		sprintf(buf, tok < ' ' ? "\\z%02X" : "%c", tok & 0xFF);
2063 | 		return buf;
2064 | 	} else {
2065 | 		for(i = 0; i < n_tok; i++) {
2066 | 			if(tok == tok_tab[i].n)
2067 | 				return tok_tab[i].name;
2068 | 		}
2069 | 	}
2070 | 	return "*bogus*";
2071 | }
2072 | 
2073 | yyerror(s, a0, a1, a2, a3)
2074 | char *s, *a0, *a1, *a2, *a3;
2075 | {
2076 | 	extern int error;
2077 | 	char buf[1024];
2078 | 
2079 | 	error++;
2080 | 	sprintf(buf, s, a0, a1, a2, a3);
2081 | 
2082 | 	if(pass == 2) {
2083 | 		fprintf(stderr, "%s: line %d: %s (tok=%s)\n", curfile, curline,
2084 | 			buf, tok_print(yychar));
2085 | 		fprintf(stderr, "%s\n", cur_line);
2086 | 		printf("%s: line %d: %s (tok=%s)\n", curfile, curline,
2087 | 			buf, tok_print(yychar));
2088 | 	}
2089 | }
2090 | 
2091 | yywarning(s, a0, a1, a2, a3)
2092 | char *s, *a0, *a1, *a2, *a3;
2093 | {
2094 | 	extern int warning;
2095 | 	char buf[1024];
2096 | 
2097 | 	warning++;
2098 | 	sprintf(buf, s, a0, a1, a2, a3);
2099 | 
2100 | 	if(pass == 2) {
2101 | 		fprintf(stderr, "%s: line %d: %s (tok=%s)\n", curfile, curline,
2102 | 			buf, tok_print(yychar));
2103 | 		fprintf(stderr, "%s\n", cur_line);
2104 | 		printf("%s: line %d: %s (tok=%s)\n", curfile, curline,
2105 | 			buf, tok_print(yychar));
2106 | 	}
2107 | }
2108 | 
2109 | char *luntab(s)
2110 | char *s;
2111 | {
2112 | 	static char buf[1024];
2113 | 	int p;
2114 | 
2115 | 	strcpy(buf, s);
2116 | 
2117 | 	untab(buf);
2118 | 	p = strlen(buf);
2119 | 
2120 | 	if(buf[p - 1] == '\n')
2121 | 		buf[p - 1] = '\0';
2122 | 
2123 | 	return buf;
2124 | }
2125 | 


--------------------------------------------------------------------------------
/appveyor.yml:
--------------------------------------------------------------------------------
 1 | environment:
 2 |   PATH: C:\msys64\mingw64\bin;C:\msys64\usr\bin;%PATH%
 3 | configuration:
 4 | - Release
 5 | build_script:
 6 | - cmd: make
 7 | after_build:
 8 | - cmd: 7z u %APPVEYOR_BUILD_FOLDER%\export\%CONFIGURATION%.zip a56.exe keybld.exe toomf.exe
 9 | artifacts:
10 | - path: export/*.zip
11 | 


--------------------------------------------------------------------------------
/examples/Makefile:
--------------------------------------------------------------------------------
 1 | STUFF = caltone.omf memtest.omf pink.omf sloader.omf test-dac.omf \
 2 | 	test-int.omf thru.omf reverb.omf flange.omf chorus.omf sixcomb.omf
 3 | 
 4 | M4 = m4
 5 | CPP = /lib/cpp
 6 | 
 7 | all:	$(STUFF)
 8 | 
 9 | clean:	; rm -f *.out *.omf *.lis tmp.a56 *.bak .jrc LOG ERR x.a56
10 | 
11 | sixcomb.omf:	sixcomb.a56
12 | 		$(M4) $*.a56 > x.a56
13 | 		make x.omf
14 | 		mv x.out sixcomb.out
15 | 		mv x.lis sixcomb.lis
16 | 
17 | .SUFFIXES:	.a56 .omf
18 | 
19 | .a56.omf:	$*.a56
20 | 		$(CPP) -Uicon $*.a56 > tmp.a56
21 | 		a56 -o $*.out tmp.a56 > $*.lis
22 | 		rm tmp.a56
23 | 		toomf < $*.out > $*.omf
24 | 


--------------------------------------------------------------------------------
/examples/README:
--------------------------------------------------------------------------------
 1 | DSP56001 code examples -
 2 | 
 3 | These code samples are fragments that run at interrupt time to generate
 4 | the next sample.  Additional code is required to set up the processor
 5 | and hardware based on your specific configuration.  A portion of my runtime
 6 | environment is illustrated in tdsg.basic.a56, which is included by most
 7 | of the examples.  It is assumed that external 0-wait-state RAM exists in
 8 | all spaces, and that a stereo A/D and DAC are hooked up to the SSI ports,
 9 | in alternating L/R format.
10 | 
11 | Some of the code is based on stuff from the Motorola Dr. Bubb BBS and
12 | Todd Day's archives.
13 | 
14 | The Makefile processes .a56 files by first running them through cpp and/or m4.
15 | The resulting .omf files are suitable for downloading by sloader.a56.
16 | 
17 | On my hardware, the MSG macro, and the disp subroutine output stuff to a
18 | two-digit hex display.  
19 | 
20 | FILES
21 | 
22 | Makefile	Builds all of the examples
23 | *.lis		Reference listings
24 | README		This file
25 | caltone.a56	A calibration tone generator using table lookup and
26 | 		interpolation.
27 | caltone.inc	Include file for caltone.a56 that sets the frequency
28 | chorus.a56	Stereo chorus effect
29 | disp.a56	Display subroutine for my 2-digit hex display
30 | flange.a56	Stereo flanger
31 | ioequ.inc	Equate file from Mot BBS
32 | memtest.a56	Simple memory test for my board
33 | pink.a56	Pink noise generator (sorta)
34 | reverb.a56	My first attempt at stereo reverb.  Fairly crude.
35 | rvb2.asm	4-comb Moorer-type reverb from Mot BBS.
36 | sixcomb.a56	My implementation of the six-comb Moorer reverb.  Much
37 | 		improved over reverb.a56.
38 | sloader.a56	Serial loader.  I use this on my board's midi port
39 | tdsg.a56	My board's hardware-specific environment
40 | test-dac.a56	A simple program I use to test my DACs
41 | test-int.a56	Interrupt-driven version of test-dac.a56
42 | thru.a56	Simple copy-in-to-out program
43 | 


--------------------------------------------------------------------------------
/examples/caltone.a56:
--------------------------------------------------------------------------------
 1 | ; Output a calibration tone using table lookup and interpolation.
 2 | ; 
 3 | ; written by Quinn Jensen (jensenq@zdomain.com)
 4 | ; ref: _Digital Sine-Wave Synthesis Using the DSP56001_,
 5 | ;	Motorola app note APR1/D rev 1
 6 | ;
 7 | 
 8 | include "tdsg.a56"
 9 | 
10 | ;***************************************************************
11 | ;
12 | ;	sample rate computations
13 | ;
14 | ;***************************************************************
15 | 
16 | dot
17 | 	org	x:$20
18 | 
19 | include	"caltone.inc"
20 | 
21 | dphase	dc	dphase_h
22 | 	org	y:$20
23 | 	dc	dphase_l
24 | 	org	x:$21
25 | phase	dc	0
26 | sinetab	equ	$100
27 | 
28 | 	org	p:dot
29 | ;
30 | ; non-interrupt code
31 | ;
32 | 
33 | hf_init
34 | 	ori	#4,omr
35 | 	rts
36 | 
37 | eff1_on
38 | eff1_off
39 | eff2_on
40 | eff2_off
41 | eff3_on
42 | eff3_off
43 | eff4_on
44 | eff4_off
45 | 	rts
46 | 
47 | ;
48 | ; fs = 32.552083 kHz
49 | ;
50 | 
51 | hf_comp
52 | 	jsr	<saveregs
53 | 
54 | #if 0
55 | 	move		x:<in_l,a
56 | 	move		a,x:<out_l
57 | 	move		x:<in_r,a
58 | 	move		a,x:<out_r
59 | #endif
60 | 
61 | 	move		l:<phase,a
62 | 	move		l:<dphase,y
63 | 	move		y0,b
64 | 	lsr	b
65 | 	move		b1,x1		;x1 = frac
66 | 	add	y,a
67 | 	move		#>$0000FF,y1
68 | 	and	y1,a
69 | 	move		a,l:<phase
70 | 	move		a1,n0
71 | 	move		#sinetab,r0
72 | 	movec		#$FF,m0
73 | 	nop
74 | 
75 | 	move		y:(r0+n0),y0
76 | 	move		y0,a
77 | #if 0
78 | 	macr	-x1,y0,a
79 | 	move		(r0)+
80 | 	move		y:(r0+n0),y0
81 | 	macr	y0,x1,a
82 | #endif
83 | 
84 | 	move		a,y0
85 | 	move		#ampl,y1
86 | 	mpyr	y0,y1,a
87 | 
88 | 	move		a,x:<out_l
89 | 	move		a,x:<out_r
90 | 
91 | bypass
92 | 	jsr	<restregs
93 | 	rts
94 | 
95 | 	end
96 | 


--------------------------------------------------------------------------------
/examples/caltone.inc:
--------------------------------------------------------------------------------
 1 | ;  Calibrate tone          
 2 | ;  Mon Apr 15 17:45:10 1991
 3 | ;  
 4 | ;      Sample rate                      32.5520830 kHz      
 5 | ;      0 VU level from peak            -15.0000000 dB       
 6 | ;      Full scale peak voltage           3.0000000 V        
 7 | ;      Freq                           1000.0000000 Hz       
 8 | ;      Table size                 256
 9 | ;  
10 | ;      delta phase                       7.8643201
11 | ;      cal tone amplitude        5827    0.1778279
12 | ;                                        0.5334838 V pk     
13 | ;  
14 | 
15 | ampl equ                                 0.1778279
16 | dphase_l equ                 14500885 ;  0.8643201
17 | dphase_h equ                        7 ;  7.0000000
18 | 


--------------------------------------------------------------------------------
/examples/chorus.a56:
--------------------------------------------------------------------------------
  1 | ;***************************************************************
  2 | ; 
  3 | ; Stereo chorus for the DSP56001 signal processor.
  4 | ; Developed by Quinn Jensen (jensenq@zdomain.com).
  5 | ; 
  6 | ; This program fragment implements a stereo "chorus" effect
  7 | ; on a DSP56001 processor.  Chorus adds depth and warmth to
  8 | ; sound by creating the illusion that more instruments
  9 | ; are involved in the sound than really are.  It does this by
 10 | ; mixing together a delayed version of the input with the input
 11 | ; itself.  This program uses the following signal flow.
 12 | ;
 13 | ;
 14 | ;  Left in ------+------- "dry" gain -----------> sum -----> Left out
 15 | ;                |                                 ^
 16 | ;                v                                 |
 17 | ;               sum --> delay ---> "wet" gain -----+
 18 | ;                ^                                 |
 19 | ;                |                                 v -
 20 | ;  Right in -----+------- "dry" gain -----------> sum -----> Right out
 21 | ;
 22 | ;
 23 | ; Note that the delay line output is negated before summing with the
 24 | ; right input signal.  This throws in 180 degrees of phase shift
 25 | ; making for interesting results even with mono inputs 
 26 | ; (i.e. Left in == Right in).
 27 | ; 
 28 | ; Chorus uses a delay time of between about 10 and 50ms in some commercial
 29 | ; units.  This program can be configured for longer delays.
 30 | ; In the chorus effect, the delay time is slowly varied, adding a very
 31 | ; subtle pitch shift.  The depth and speed of the delay-time modulation
 32 | ; are adjustable to taste.  The greater the depth or speed, the greater
 33 | ; the coloration of the signal.
 34 | ;
 35 | ; Variations in this algorithm are possible and encouraged.  I came
 36 | ; up with this code after studying the impulse response and characteristics
 37 | ; of a commercial stereo chorus pedal and reading various articles in magazines
 38 | ; and on usenet over the years.  My somewhat dry TX81 synthesizer sounds pretty
 39 | ; good with this and other effects I run on the 56001.
 40 | ;
 41 | ; A recent article with a pretty good not-too-technical overview of chorus 
 42 | ; and other effects:  Gary Hall, "From the Top: Effects, the Essential Musical
 43 | ; Spice," _Electronic Musician_, August 1991, pp. 62-68.
 44 | ;
 45 | ; I would enjoy seeing any improvements to the code.
 46 | ;
 47 | include "tdsg.a56"	;hardware specific initialization code
 48 | 
 49 | ;***************************************************************
 50 | ;
 51 | ;	Data and constants
 52 | ;
 53 | ;***************************************************************
 54 | 
 55 | dot				;remember where we were in P-space
 56 | 	org	x:$20		;put runtime variables in on-chip X-space
 57 | 
 58 | ; A spreadsheet was used to calculate the following numbers
 59 | 
 60 | ; Sample rate              32.5500 kc         
 61 | ; 
 62 | ; Delay time (4-52)        28.0000 ms		delay time knob
 63 | ; Depth (1-10)             10.0000		depth knob (I like it deep)
 64 | ; Speed (1-10)              0.0000		speed knob (I like it slow)
 65 | ; 
 66 | ; max depth +/-            24.0000 ms         
 67 | ; min delay                 4.0000 ms         
 68 | ; max delay                52.0000 ms         
 69 | ; 1/2 cycle period          5.0000 s          
 70 | ; samples per 1/2 cyc  162750.0000
 71 | ; time delta/samp           0.2949 us         
 72 | ; offset samp/samp          0.0096
 73 | ; 
 74 |   doff_i equ                              -130	;initial delay offset (tap)
 75 |   ddeltaf equ                           0.0096	;delta-delay, per sample
 76 |   dspeed_i equ                          162750	;number of samples per
 77 | 						;half cycle of triangle wave
 78 | 						;delay-time modulator
 79 | ; 
 80 | ; Delay time (ms)              tap                   tap     delay
 81 | ; 
 82 | ;                   1      32.5500                     1      0.03
 83 | ;                   2      65.1000                     2      0.06
 84 | ;                   4     130.2000                     4      0.12
 85 | ;                   5     162.7500                     8      0.25
 86 | ;                   8     260.4000                    16      0.49
 87 | ;                  10     325.5000                    32      0.98
 88 | ;                  20     651.0000                    64      1.97
 89 | ;                  25     813.7500                   128      3.93
 90 | ;                  40    1302.0000                   256      7.86
 91 | ;                  50    1627.5000                   512     15.73
 92 | ;                  60    1953.0000                  1024     31.46
 93 | ;                  70    2278.5000                  2048     62.92
 94 | ;                  80    2604.0000                  4096    125.84
 95 | ;                  90    2929.5000                  8192    251.67
 96 | ;                 100    3255.0000                 16384    503.35
 97 | 
 98 | ;
 99 | ;	The delay line is in off-chip X memory
100 | ;
101 | delay	equ	$2000
102 | dmax	equ	4096		;125 ms (probably way too long)
103 | ;
104 | ; doff and ddelta are 48-bit quantities
105 | ;
106 | doff	dc	doff_i    	;current delay distance
107 | 	org	y:doff
108 | 	dc	0
109 | 
110 | 	org	x:doff+1
111 | ddelta	dc	0		;delta delay per sample
112 | 	org	y:ddelta
113 | 	dc	ddeltaf
114 | 
115 | 	org	x:ddelta+1
116 | 
117 | dspeed	dc	dspeed_i	;samples per half cycle of triangle modulator
118 | dtoggle	dc	0		;current sample count
119 | delayout
120 | 	dc	0		;current delay-line output
121 | 
122 | 	org	y:$0
123 | 
124 | 	org	p:dot		;go back to P-space
125 | ;***************************************************************
126 | ;
127 | ; Initialization code
128 | ;
129 | ;***************************************************************
130 | hf_init
131 | 	move	#delay,r1			;delay line input
132 |  	movec	#dmax-1,m1			;
133 | 	move	#doff_i,n1			;distance to output
134 | 	rts
135 | ;
136 | ;***************************************************************
137 | ;
138 | ;	Sample-rate computations.  Call chorus_compute at
139 | ;	interrupt time when both left and right inputs are
140 | ;	ready.
141 | ;
142 | ;	fs = 32.552083 kHz
143 | ;
144 | ;	x:<in_l		left-channel input
145 | ;	x:<in_r		right-channel input
146 | ;	x:<out_l	left-channel output
147 | ;	x:<out_r	right-channel output
148 | ;
149 | ;***************************************************************
150 | 
151 | hf_comp
152 | 	jsr	<saveregs
153 | ;
154 | ;	output and input mix
155 | ;
156 | 	clr	a	#.4375,x1		;clr a, get input scale
157 | 	clr	b	#.5,y1			;clr b, get output scaler
158 | 
159 | 	move		x:<delayout,y0		;get delay out
160 | 
161 | 	macr	y0,y1,b	x:<in_l,x0		;b = .5 * delay, x0=in_l
162 | 	macr	x0,y1,b		b,y0       	;b += .5 * in_l, y0=b
163 | 	macr	x0,x1,a b,x:<out_l		;a = x1 * in_l, L = b
164 | 	move			y0,b		;b = -y0
165 | 	neg	b	x:<in_r,x0		;x0 = in_r
166 | 	macr	x0,y1,b				;b += .5 * in_r
167 | 	macr	x0,x1,a	b,x:<out_r		;R = b, a += x1 * in_r
168 | ;
169 | ;	delay line in
170 | ;
171 | 	move	a,x:(r1)+
172 | ;
173 | ;	delay line length modulation.  A simple triangle-wave modulator
174 | ;	is used.  A sine-wave modulator would be much better, especially
175 | ;	with deeper and/or faster settings.
176 | ;
177 | 	move		l:<doff,a		;a = current offset
178 | 	move		l:<ddelta,x		;x = current delta
179 | 	add	x,a
180 | 	move		a,l:<doff		;new offset = a + x
181 | 	move		a1,n1
182 | 
183 | 	move		x1,b			;save delta for later use
184 | ;
185 | ; smoothly transition between delay-line offsets by
186 | ; interpolating the current sample with the previous or next
187 | ; one depending on whether the delay is currently getting longer or
188 | ; shorter.  Otherwise, an obnoxious click results when the offset snaps
189 | ; to the next integral value.  This does have a low-pass effect on the
190 | ; delayed signal path but it is not objectionable.
191 | ;
192 | 	move			y:<doff,a	;compute |frac(doff)|
193 | 	lsr	a	#$800000,x0
194 | 	or	x0,a	#.5,x1
195 | 	move		a1,x0
196 | 	mpy	-x0,x1,a
197 | 	tst	b		a,y0		;y0 = 0.5 * |frac(doff)|
198 | 	jpl	shorter				;on positive delta, the
199 | 						;delay is shortening
200 | 
201 | 	move		(r1)-			;get previous sample
202 | 	move		x:(r1+n1),x0
203 | 	mpy	y0,x0,a	#.5,b			;scale
204 | 	sub	y0,b	(r1)+			;compute scale for cur sample
205 | 	move			b,y0
206 | 	move		x:(r1+n1),x0		;get cur sample
207 | 	mac	x0,y0,a				;scale and sum
208 | 	jmp	endpan
209 | 
210 | shorter
211 | 	move		x:(r1+n1),x0		;get cur sample
212 | 	mpy	y0,x0,a	#.5,b			;scale
213 | 	sub	y0,b	(r1)+			;compute scale for next sample
214 | 	move			b,y0
215 | 	move		x:(r1+n1),x0		;get next sample
216 | 	mac	x0,y0,a	(r1)-			;scale and sum
217 | endpan
218 | 	move		a,x:<delayout		;store resulting output
219 | ;
220 | ; update the triangle wave modulation (sinewave would be better)
221 | ;
222 | 	move		x:<dtoggle,a		;decrement toggle count
223 | 	move		#>1,x0
224 | 	sub	x0,a
225 | 	move		a,x:<dtoggle
226 | 	jgt	notogg				;time to toggle?
227 | 	move		x:<dspeed,x0		;yes, negate delta and reset
228 | 	move		l:<ddelta,a
229 | 	neg	a	x0,x:<dtoggle
230 | 	move		a,l:<ddelta
231 | notogg
232 | bypass
233 | 	jsr	<restregs
234 | 	rts
235 | 
236 | 	end
237 | 


--------------------------------------------------------------------------------
/examples/defs.inc:
--------------------------------------------------------------------------------
 1 | ; defs.inc
 2 | ; Todd Day (todd@ivucsb.sba.ca.us)
 3 | ; Wed Aug  2 23:43:22 PDT 1989
 4 | ; miscellaneous definitions that I've found useful
 5 | ; sometimes I use them in programs I write
 6 | 
 7 | ; number of samples per second = 20 MHz / 512 (your value here)
 8 | numsamp	equ	39062
 9 | 
10 | ; program starting point (we aren't using the host vectors - $40 if you do)
11 | pgmram	equ	$0020
12 | 
13 | ; beginning of internal data ram
14 | intram	equ	$0000
15 | 
16 | ; beginning of internal data rom
17 | introm	equ	$0100
18 | 
19 | ; beginning of external data ram
20 | extram	equ	$0200
21 | 
22 | ; end of external data ram
23 | endram	equ	$ffbf
24 | 


--------------------------------------------------------------------------------
/examples/disp.a56:
--------------------------------------------------------------------------------
 1 | ;
 2 | ; disp:	display	the character in the high byte of A1 on	the readout
 3 | ;
 4 | disp
 5 | 	move	#~($F<<7),x0	a,y1	;save a, x0=mask
 6 | ;
 7 | ;	copy in	the low	nibble
 8 | ;
 9 | 	movep	x:m_pbd,a1		;get b port contents
10 | 	and	x0,a	#$F<<7,x1	;clear display nibble, x1=mask
11 | 	move	y1,b			;get char
12 | 	rep	#16-7			;shift it down
13 | 	lsr	b
14 | 	and	x1,b			;mask nibble
15 | 	move	b1,y0			;and or	it into	b port
16 | 	or	y0,a
17 | 	movep	a1,x:m_pbd		;and write back	b port
18 | ;
19 | ;	write out to the display
20 | ;
21 | 	bclr	#11,x:<<m_pbd		;strobe (setup=25, hold=25, pw=50)
22 | 	bset	#11,x:<<m_pbd		;and negate
23 | ;
24 | ;	copy in	the high nibble
25 | ;
26 | 	and	x0,a			;a has port b, clear nibble again
27 | 	move	y1,b			;get char
28 | 	rep	#16-7+4			;shift down the	high nibble
29 | 	lsr	b
30 | 	and	x1,b			;mask the nibble
31 | 	move	b1,y0			;and or	into b data
32 | 	or	y0,a
33 | 	movep	a1,x:m_pbd		;write back to port
34 | ;
35 | ;	write out to the display
36 | ;
37 | 	bclr	#12,x:<<m_pbd		;assert	the strobe
38 | 	bset	#12,x:<<m_pbd		;and negate
39 | ;
40 | ;	restore	a and return
41 | ;
42 | 	move	y1,a
43 | 	rts
44 | 


--------------------------------------------------------------------------------
/examples/flange.a56:
--------------------------------------------------------------------------------
  1 | ;***************************************************************
  2 | ;
  3 | ;	Stereo Flange for the DSP56001 processor
  4 | ;	Developed by Quinn Jensen (jensenq@zdomain.com)
  5 | ;
  6 | ;***************************************************************
  7 | include "tdsg.a56"
  8 | 
  9 | dot
 10 | 	org	x:$20
 11 | 
 12 | ; Sample rate              32.5500 kc         
 13 | ; 
 14 | ; Delay time (1-12)         6.0000 ms         
 15 | ; Depth (1-10)             10.0000
 16 | ; Speed (1-10)              1.0000
 17 | ; Regen (1-10)              9.0000
 18 | ; 
 19 | ; max depth +/-             6.0000 ms         
 20 | ; min delay                 1.0000 ms         
 21 | ; max delay                12.0000 ms         
 22 | ; 1/2 cycle period          4.5100 s          
 23 | ; samples per 1/2 cyc  146800.5000
 24 | ; time delta/samp           0.0817 us         
 25 | ; offset samp/samp          0.0027
 26 | ; 
 27 |   doff_i equ                               -33
 28 |   ddeltaf equ                     0.0026607539
 29 |   dspeed_i equ                          146800
 30 |   dregen equ                      0.8888888889
 31 | 
 32 | delay	equ	$2000
 33 | dmax	equ	4096		;125 ms
 34 | doff	dc	doff_i    	;current delay distance
 35 | 	org	y:doff
 36 | 	dc	0
 37 | 
 38 | 	org	x:doff+1
 39 | ddelta	dc	0		;
 40 | 	org	y:ddelta
 41 | 	dc	ddeltaf
 42 | 
 43 | 	org	x:ddelta+1
 44 | 
 45 | dspeed	dc	dspeed_i
 46 | dtoggle	dc	0		;
 47 | delayout
 48 | 	dc	0
 49 | 
 50 | 	org	y:$0
 51 | 
 52 | 	org	p:dot		;go back to P-space
 53 | ;
 54 | ; non-interrupt code
 55 | ;
 56 | 
 57 | hf_init
 58 | 	move	#delay,r1			;delay line input
 59 |  	movec	#dmax-1,m1			;
 60 | 	move	#doff_i,n1			;distance to output
 61 | 	rts
 62 | 
 63 | ;
 64 | ; fs = 32.552083 kHz
 65 | ;
 66 | 
 67 | hf_comp
 68 | 	jsr	<saveregs
 69 | ;
 70 | ;	output and input mix
 71 | ;
 72 | 	clr	a	#.4375,x1		;clr a, get input scale
 73 | 	clr	b	#.5,y1			;clr b, get output scaler
 74 | 
 75 | 	move		x:<delayout,y0		;get delay out
 76 | 
 77 | 	move		#.70,x0			;do regen term
 78 | 	macr	x0,y0,a
 79 | 	macr	x0,y0,a
 80 | 
 81 | 	move		#.75,x0
 82 | 
 83 | 	macr	y0,x0,b	x:<in_l,x0		;b = .5 * delay, x0=in_l
 84 | 	macr	x0,y1,b		b,y0       	;b += .5 * in_l, y0=b
 85 | 	macr	x0,x1,a b,x:<out_l		;a += x1 * in_l, L = b
 86 | 	move			y0,b		;b = -y0
 87 | 	neg	b	x:<in_r,x0		;x0 = in_r
 88 | 	macr	x0,y1,b				;b += .5 * in_r
 89 | 	macr	x0,x1,a	b,x:<out_r		;R = b, a += x1 * in_r
 90 | ;
 91 | ;	delay line in
 92 | ;
 93 | 	move		a,x:(r1)+
 94 | ;
 95 | ;	delay line length modulation
 96 | ;
 97 | 	move		l:<doff,a		;a = current offset
 98 | 	move		l:<ddelta,x		;x = current delta
 99 | 	add	x,a
100 | 	move		a,l:<doff		;new offset = a + x
101 | 	move		a1,n1
102 | 
103 | 	move		x1,b			;save delta for later use
104 | 
105 | ; smoothly transition between delay-line offsets by
106 | ; interpolating the current sample with the previous or next
107 | ; one depending on whether the delay is currently getting longer or
108 | ; shorter.  Otherwise, an obnoxious click results when the offset snaps
109 | ; to the next integral value.
110 | 
111 | 	move			y:<doff,a	;compute |frac(doff)|
112 | 	lsr	a	#$800000,x0
113 | 	or	x0,a	#.5,x1
114 | 	move		a1,x0
115 | 	mpy	-x0,x1,a
116 | 	tst	b		a,y0		;y0 = 0.5 * |frac(doff)|
117 | 	jpl	shorter				;on positive delta, the
118 | 						;delay is shortening
119 | 
120 | 	move		(r1)-			;get previous sample
121 | 	move		x:(r1+n1),x0
122 | 	mpy	y0,x0,a	#.5,b			;scale
123 | 	sub	y0,b	(r1)+			;compute scale for cur sample
124 | 	move			b,y0
125 | 	move		x:(r1+n1),x0		;get cur sample
126 | 	mac	x0,y0,a				;scale and sum
127 | 	jmp	endpan
128 | 
129 | shorter
130 | 	move		x:(r1+n1),x0		;get cur sample
131 | 	mpy	y0,x0,a	#.5,b			;scale
132 | 	sub	y0,b	(r1)+			;compute scale for next sample
133 | 	move			b,y0
134 | 	move		x:(r1+n1),x0		;get next sample
135 | 	mac	x0,y0,a	(r1)-			;scale and sum
136 | endpan
137 | 	move		a,x:<delayout		;store resulting output
138 | 
139 | ; update the triangle wave modulation
140 | 
141 | 	move		x:<dtoggle,a		;decrement toggle count
142 | 	move		#>1,x0
143 | 	sub	x0,a
144 | 	move		a,x:<dtoggle
145 | 	jgt	notogg				;time to toggle?
146 | 	move		x:<dspeed,x0		;yes, negate delta and reset
147 | 	move		l:<ddelta,a
148 | 	neg	a	x0,x:<dtoggle
149 | 	move		a,l:<ddelta
150 | notogg
151 | bypass
152 | 	jsr	<restregs
153 | 	rts
154 | 
155 | 	end
156 | 


--------------------------------------------------------------------------------
/examples/intequ.inc:
--------------------------------------------------------------------------------
 1 | ; intequ.inc
 2 | ; Wed Aug  2 23:50:28 PDT 1989
 3 | ; DSP 56000 interrupt vector equates
 4 | ; This file came from Motorola's Dr. BuB DSP board
 5 | 
 6 | ;************************************************************************
 7 | ;
 8 | ;       EQUATES for DSP56000 interrupts
 9 | ;       Reference: DSP56000 User's Manual, Table 8.1, Interrupt Sources
10 | ;
11 | ;************************************************************************
12 | 
13 | i_reset EQU     $0000   ; hardware _RESET
14 | i_stack EQU     $0002   ; stack error
15 | i_trace EQU     $0004   ; trace
16 | i_swi   EQU     $0006   ; SWI
17 | i_irqa  EQU     $0008   ; _IRQA
18 | i_irqb  EQU     $000A   ; _IRQB
19 |  
20 | i_ssird EQU     $000C   ; SSI receive data
21 | i_ssirde EQU    $000E   ; SSI receive data with exception status
22 | i_ssitd EQU     $0010   ; SSI transmit data
23 | i_ssitde EQU    $0012   ; SSI transmit data with exception status
24 |  
25 | i_scird EQU     $0014   ; SCI receive data
26 | i_scirde EQU    $0016   ; SCI receive data with exception status
27 | i_scitd EQU     $0018   ; SCI transmit data
28 | i_sciil EQU     $001A   ; SCI idle line
29 | i_scitm EQU     $001C   ; SCI timer
30 |  
31 | i_hstrd EQU     $0020   ; host receive data
32 | i_hsttd EQU     $0022   ; host transmit data
33 | i_hstcm EQU     $0024   ; host command (default)
34 | 
35 | 


--------------------------------------------------------------------------------
/examples/ioequ.inc:
--------------------------------------------------------------------------------
  1 | ; ioequ.inc
  2 | ; DSP 56000 I/O address and register equates
  3 | ; This file came from Motorola's Dr. BuB DSP board
  4 | 
  5 | ; Last Update 25 Aug 87   Version 1.1  (fixed m_of)
  6 | ;
  7 | ;************************************************************************
  8 | ;
  9 | ;       EQUATES for DSP56000 I/O registers and ports
 10 | ;
 11 | ;************************************************************************
 12 | 
 13 | ;------------------------------------------------------------------------
 14 | ;
 15 | ;       EQUATES for I/O Port Programming
 16 | ;
 17 | ;------------------------------------------------------------------------
 18 | 
 19 | ;       Register Addresses
 20 | 
 21 | m_bcr   EQU     $FFFE           ; Port A Bus Control Register
 22 | m_pbc   EQU     $FFE0           ; Port B Control Register
 23 | m_pbddr EQU     $FFE2           ; Port B Data Direction Register
 24 | m_pbd   EQU     $FFE4           ; Port B Data Register
 25 | m_pcc   EQU     $FFE1           ; Port C Control Register
 26 | m_pcddr EQU     $FFE3           ; Port C Data Direction Register
 27 | m_pcd   EQU     $FFE5           ; Port C Data Register
 28 | 
 29 | 
 30 | ;------------------------------------------------------------------------
 31 | ;
 32 | ;       EQUATES for Host Interface
 33 | ;
 34 | ;------------------------------------------------------------------------
 35 | 
 36 | ;       Register Addresses
 37 | 
 38 | m_hcr   EQU     $FFE8           ; Host Control Register
 39 | m_hsr   EQU     $FFE9           ; Host Status Register
 40 | m_hrx   EQU     $FFEB           ; Host Receive Data Register
 41 | m_htx   EQU     $FFEB           ; Host Transmit Data Register
 42 | 
 43 | ;       Host Control Register Bit Flags
 44 | 
 45 | m_hrie  EQU     0               ; Host Receive Interrupt Enable
 46 | m_htie  EQU     1               ; Host Transmit Interrupt Enable
 47 | m_hcie  EQU     2               ; Host Command Interrupt Enable
 48 | m_hf2   EQU     3               ; Host Flag 2
 49 | m_hf3   EQU     4               ; Host Flag 3
 50 | 
 51 | ;       Host Status Register Bit Flags
 52 | 
 53 | m_hrdf  EQU     0               ; Host Receive Data Full
 54 | m_htde  EQU     1               ; Host Transmit Data Empty
 55 | m_hcp   EQU     2               ; Host Command Pending
 56 | m_hf    EQU     $18             ; Host Flag Mask
 57 | m_hf0   EQU     3               ; Host Flag 0
 58 | m_hf1   EQU     4               ; Host Flag 1
 59 | m_dma   EQU     7               ; DMA Status
 60 | 
 61 | ;------------------------------------------------------------------------
 62 | ;
 63 | ;       EQUATES for Serial Communications Interface (SCI)
 64 | ;
 65 | ;------------------------------------------------------------------------
 66 | 
 67 | ;       Register Addresses
 68 | 
 69 | m_srxl  EQU     $FFF4           ; SCI Receive Data Register (low)
 70 | m_srxm  EQU     $FFF5           ; SCI Receive Data Register (middle)
 71 | m_srxh  EQU     $FFF6           ; SCI Receive Data Register (high)
 72 | m_stxl  EQU     $FFF4           ; SCI Transmit Data Register (low)
 73 | m_stxm  EQU     $FFF5           ; SCI Transmit Data Register (middle)
 74 | m_stxh  EQU     $FFF6           ; SCI Transmit Data Register (high)
 75 | m_stxa  EQU     $FFF3           ; SCI Transmit Data Address Register
 76 | m_scr   EQU     $FFF0           ; SCI Control Register
 77 | m_ssr   EQU     $FFF1           ; SCI Status Register
 78 | m_sccr  EQU     $FFF2           ; SCI Clock Control Register
 79 | 
 80 | ;       SCI Control Register Bit Flags
 81 | 
 82 | m_wds   EQU     $3              ; Word Select Mask
 83 | m_wds0  EQU     0               ; Word Select 0
 84 | m_wds1  EQU     1               ; Word Select 1
 85 | m_wds2  EQU     2               ; Word Select 2
 86 | m_sbk   EQU     4               ; Send Break
 87 | m_wake  EQU     5               ; Wake-up Mode Select
 88 | m_rwi   EQU     6               ; Receiver Wake-up Enable
 89 | m_woms  EQU     7               ; Wired-OR Mode Select
 90 | m_re    EQU     8               ; Receiver Enable
 91 | m_te    EQU     9               ; Transmitter Enable
 92 | m_ilie  EQU     10              ; Idle Line Interrupt Enable
 93 | m_rie   EQU     11              ; Receive Interrupt Enable
 94 | m_tie   EQU     12              ; Transmit Interrupt Enable
 95 | m_tmie  EQU     13              ; Timer Interrupt Enable
 96 | 
 97 | ;       SCI Status Register Bit Flags
 98 | 
 99 | m_trne  EQU     0               ; Transmitter Empty
100 | m_tdre  EQU     1               ; Transmit Data Register Empty
101 | m_rdrf  EQU     2               ; Receive Data Register Full
102 | m_idle  EQU     3               ; Idle Line
103 | m_or    EQU     4               ; Overrun Error
104 | m_pe    EQU     5               ; Parity Error
105 | m_fe    EQU     6               ; Framing Error
106 | m_r8    EQU     7               ; Received Bit 8
107 | 
108 | ;       SCI Clock Control Register Bit Flags
109 | 
110 | m_cd    EQU     $FFF            ; Clock Divider Mask
111 | m_cod   EQU     12              ; Clock Out Divider
112 | m_scp   EQU     13              ; Clock Prescaler
113 | m_rcm   EQU     14              ; Receive Clock Source
114 | m_tcm   EQU     15              ; Transmit Clock Source
115 | 
116 | ;------------------------------------------------------------------------
117 | ;
118 | ;       EQUATES for Synchronous Serial Interface (SSI)
119 | ;
120 | ;------------------------------------------------------------------------
121 | 
122 | ;       Register Addresses
123 | 
124 | m_rx    EQU     $FFEF           ; Serial Receive Data Register
125 | m_tx    EQU     $FFEF           ; Serial Transmit Data Register
126 | m_cra   EQU     $FFEC           ; SSI Control Register A
127 | m_crb   EQU     $FFED           ; SSI Control Register B
128 | m_sr    EQU     $FFEE           ; SSI Status Register
129 | m_tsr   EQU     $FFEE           ; SSI Time Slot Register
130 | 
131 | ;       SSI Control Register A Bit Flags
132 | 
133 | m_pm    EQU     $FF             ; Prescale Modulus Select Mask
134 | m_dc    EQU     $1F00           ; Frame Rate Divider Control Mask
135 | m_wl    EQU     $6000           ; Word Length Control Mask
136 | m_wl0   EQU     13              ; Word Length Control 0
137 | m_wl1   EQU     14              ; Word Length Control 1
138 | m_psr   EQU     15              ; Prescaler Range
139 | 
140 | ;       SSI Control Register B Bit Flags
141 | 
142 | m_of    EQU     $3              ; Serial Output Flag Mask
143 | m_of0   EQU     0               ; Serial Output Flag 0
144 | m_of1   EQU     1               ; Serial Output Flag 1
145 | m_scd   EQU     $1C             ; Serial Control Direction Mask
146 | m_scd0  EQU     2               ; Serial Control 0 Direction
147 | m_scd1  EQU     3               ; Serial Control 1 Direction
148 | m_scd2  EQU     4               ; Serial Control 2 Direction
149 | m_sckd  EQU     5               ; Clock Source Direction
150 | m_fsl   EQU     8               ; Frame Sync Length
151 | m_syn   EQU     9               ; Sync/Async Control
152 | m_gck   EQU     10              ; Gated Clock Control
153 | m_mod   EQU     11              ; Mode Select
154 | m_ste   EQU     12              ; SSI Transmit Enable
155 | m_sre   EQU     13              ; SSI Receive Enable
156 | m_stie  EQU     14              ; SSI Transmit Interrupt Enable
157 | m_srie  EQU     15              ; SSI Receive Interrupt Enable
158 | 
159 | ;       SSI Status Register Bit Flags
160 | 
161 | m_if    EQU     $2              ; Serial Input Flag Mask
162 | m_if0   EQU     0               ; Serial Input Flag 0
163 | m_if1   EQU     1               ; Serial Input Flag 1
164 | m_tfs   EQU     2               ; Transmit Frame Sync
165 | m_rfs   EQU     3               ; Receive Frame Sync
166 | m_tue   EQU     4               ; Transmitter Underrun Error
167 | m_roe   EQU     5               ; Receiver Overrun Error
168 | m_tde   EQU     6               ; Transmit Data Register Empty
169 | m_rdf   EQU     7               ; Receive Data Register Full
170 | 
171 | ;------------------------------------------------------------------------
172 | ;
173 | ;       EQUATES for Exception Processing
174 | ;
175 | ;------------------------------------------------------------------------
176 | 
177 | ;       Register Addresses
178 | 
179 | m_ipr   EQU     $FFFF           ; Interrupt Priority Register
180 | 
181 | ;       Interrupt Priority Register Bit Flags
182 | 
183 | m_ial   EQU     $7              ; IRQA Mode Mask
184 | m_ial0  EQU     0               ; IRQA Mode Interrupt Priority Level (low)
185 | m_ial1  EQU     1               ; IRQA Mode Interrupt Priority Level (high)
186 | m_ial2  EQU     2               ; IRQA Mode Trigger Mode
187 | m_ibl   EQU     $38             ; IRQB Mode Mask
188 | m_ibl0  EQU     3               ; IRQB Mode Interrupt Priority Level (low)
189 | m_ibl1  EQU     4               ; IRQB Mode Interrupt Priority Level (high)
190 | m_ibl2  EQU     5               ; IRQB Mode Trigger Mode
191 | m_hpl   EQU     $C00            ; Host Interrupt Priority Level Mask
192 | m_hpl0  EQU     10              ; Host Interrupt Priority Level Mask (low)
193 | m_hpl1  EQU     11              ; Host Interrupt Priority Level Mask (high)
194 | m_ssl   EQU     $3000           ; SSI Interrupt Priority Level Mask
195 | m_ssl0  EQU     12              ; SSI Interrupt Priority Level Mask (low)
196 | m_ssl1  EQU     13              ; SSI Interrupt Priority Level Mask (high)
197 | m_scl   EQU     $C000           ; SCI Interrupt Priority Level Mask
198 | m_scl0  EQU     14              ; SCI Interrupt Priority Level Mask (low)
199 | m_scl1  EQU     15              ; SCI Interrupt Priority Level Mask (high)
200 | 
201 | 


--------------------------------------------------------------------------------
/examples/memtest.a56:
--------------------------------------------------------------------------------
  1 | ; simple memory test - runs test patterns through off-chip RAM
  2 | ;
  3 | ; written by Quinn Jensen (jensenq@zdomain.com)
  4 | ;
  5 | 
  6 | include "ioequ.inc"
  7 | 
  8 | #define MSG(m) movep	#(m)<<7,x:m_pbd
  9 | 
 10 | start	equ	$0000
 11 | length	equ	$ff00
 12 | 
 13 | 	org	p:$0000
 14 | 	jmp	begin
 15 | 
 16 | 	org	p:$40
 17 | begin
 18 | 	movep	#$0f0f,x:m_bcr	;wait states
 19 | 	movep	#0,x:m_pbc	;port B: parallel I/O
 20 | 	movep	#-1,x:m_pbddr	;port B: all output
 21 | 	MSG($1)
 22 | 	MSG($1|3<<4)		;clear strobes
 23 | 
 24 | loop
 25 | 	move	#>$000000,x0	;pattern
 26 | 	jsr	<dopat
 27 | 	move	#>$AAAAAA,x0	;pattern
 28 | 	jsr	<dopat
 29 | 	jsr	<iatest
 30 | 	move	#>$555555,x0	;pattern
 31 | 	jsr	<dopat
 32 | 	jsr	<iatest
 33 | 	move	#>$FFFFFF,x0	;pattern
 34 | 	jsr	<dopat
 35 | 	move	#>$DEADEE,x0	;pattern
 36 | 	jsr	<dopat
 37 | 	jsr	<iatest
 38 | 	move	#>$123456,x0	;pattern
 39 | 	jsr	<dopat
 40 | 	move	#>$876543,x0	;pattern
 41 | 	jsr	<dopat
 42 | 	jsr	<iatest
 43 | 	jmp	<loop
 44 | 
 45 | iatest
 46 | 	move	#$1a,a
 47 | 	jsr	<disp		;show which test
 48 | 	move	#start,r0
 49 | 	move	#length,x1
 50 | 	do	x1,iafill
 51 | 	move	r0,a
 52 | 	not	a
 53 | 	move	a,x:(r0)+
 54 | iafill
 55 | 	move	#start,r0
 56 | 	move	#length,x1
 57 | 	do	x1,iacheck
 58 | 	move	x:(r0)+,a1
 59 | 	move	r0,b
 60 | 	not	b
 61 | 	move	b,x0
 62 | 	eor	x0,a
 63 | 	jne	<error
 64 | iacheck
 65 | 
 66 | 	rts
 67 | 
 68 | dopat
 69 | 	move	x0,n7
 70 | 	move	x0,a
 71 | 	jsr	<disp		;show which pattern
 72 | 	move	n7,x0
 73 | 	move	#length,x1
 74 | 	jsr	<patfill
 75 | 	jsr	<patcheck
 76 | 	rts
 77 | 
 78 | patfill
 79 | 	move	#start,r0
 80 | 	do	x1,lfill
 81 | 	move	x0,x:(r0)+
 82 | lfill
 83 | 	rts
 84 | 
 85 | patcheck
 86 | 	move	#start,r0
 87 | 	do	x1,lcheck
 88 | 	move	x:(r0)+,a1
 89 | 	eor	x0,a
 90 | 	jne	<error
 91 | lcheck
 92 | 	rts
 93 | 
 94 | blink1	equ	300
 95 | blink2	equ	4000
 96 | 
 97 | error
 98 | 	move	x0,a1
 99 | 	jsr	<disp		;display error code
100 | eloop
101 | 	bclr	#13,x:m_pbd
102 | 	bclr	#14,x:m_pbd
103 | 	do	#blink1,el1
104 | 	rep	#blink2
105 | 	nop
106 | el1
107 | 	bset	#13,x:m_pbd
108 | 	bset	#14,x:m_pbd
109 | 	do	#blink1,el2
110 | 	rep	#blink2
111 | 	nop
112 | el2
113 | 	jmp	<eloop
114 | 
115 | include "disp.a56"
116 | 


--------------------------------------------------------------------------------
/examples/pink.a56:
--------------------------------------------------------------------------------
 1 | ; pink noise (1/f) generator
 2 | ; (actually white noise into a one-pole low-pass filter)
 3 | ; based on noise generator from Dr. Bubb but extended to 24 bits
 4 | ; uses simple one-tap recursive filter
 5 | ;
 6 | ; written by: Quinn Jensen (jensenq@zdomain.com)
 7 | ;
 8 | 
 9 | include "tdsg.a56"
10 | ;***************************************************************
11 | ;
12 | ;	sample rate computations
13 | ;
14 | ;***************************************************************
15 | 
16 | dot
17 | 	org	x:$10
18 | 
19 | NSTATE  dc      1               ;STATE OF NOISE GENERATOR (SHIFT REG)
20 | 
21 | 
22 | 	org	y:$0
23 | 
24 | 	org	p:dot		;go back to P-space
25 | ;
26 | ; non-interrupt code
27 | ;
28 | 
29 | hf_init
30 |         MOVE    #$FEEDEE,X0         ;INITIAL STATE OF NOISE GENERATOR
31 |         MOVE    X0,X:<NSTATE
32 | 	rts
33 | 
34 | ;
35 | ; fs = 32.552083 kHz
36 | ;
37 | 
38 | hf_comp
39 | 	jsr	<saveregs
40 | 	jsr	NOISE
41 | 	move		#.005,x1
42 | 	move		#.990,y1
43 | 	move		a,x0
44 | 	mpyr	x0,x1,a	x:<out_l,x0
45 | 	macr	x0,y1,a
46 | 	move		a,x:<out_l
47 | 	jsr	NOISE
48 | 	move		a,x0
49 | 	mpyr	x0,x1,a	x:<out_r,x0
50 | 	macr	x0,y1,a
51 | 	move		a,x:<out_r
52 | 	jsr	<restregs
53 | 	rts
54 | 
55 | ;       NOISE GENERATION ROUTINE.  THIS ROUTINE USES A 15 BIT SHIFT
56 | ;       REGISTER LEFT JUSTIFIED IN THE VARIABLE "NSTATE".  AFTER THE STATE
57 | ;       IS LOADED, IT IS CHECKED TO SEE IF IT IS NORMALIZED.  IF IT IS
58 | ;       NORMALIZED (TOP TWO BITS ARE DIFFERENT), A 1 IS SET AS THE INPUT
59 | ;       TO THE SHIFT REGISTER AND THE REGISTER IS SHIFTED AND SAVED.
60 | ;
61 | ;         B23     B22                            B9      B8
62 | ;        ______________________________________________
63 | ;       | S14   | S13 |                        | S0   |
64 | ;       |       |     |      . . .             |      |<----------
65 | ;       |_______|_____|________________________|_______          |
66 | ;           |      |                                             |
67 | ;            \    /                                              |
68 | ;              XOR                                               |
69 | ;               \_________________________________________________
70 | ;
71 | ;
72 | ;       ASSUMES SCALING MODE IS OFF
73 | ;
74 | NOISE                                   ;DO NOISE GENERATION LOOP
75 |         CLR     B       X:<NSTATE,A     ;GET A ZERO IN B
76 |         TST     A   #>$000001,X0        ;CHECK A, GET A 1 IN LSB POSITION
77 |         TNR     X0,B                    ;IF NORMALIZED, THEN XOR=1
78 |         ADD     B,A                     ;SET LSB
79 |         ASL     A                       ;SHIFT BITS
80 |         MOVE    A1,X:<NSTATE            ;SAVE STATE
81 |         RTS                             ;RETURN WITH STATE
82 | 
83 |         END
84 | 


--------------------------------------------------------------------------------
/examples/reverb.a56:
--------------------------------------------------------------------------------
  1 | ;***************************************************************
  2 | ; 
  3 | ; A stereo reverb for the DSP56001 signal processor.
  4 | ; Developed by Quinn Jensen (jensenq@zdomain.com) using
  5 | ; Dr. Vercoe and company's csound code as a reference for the 
  6 | ; configuration and gain values.
  7 | ; 
  8 | ; 	NOTE - A much improved reverb algorithm is in sixcomb.a56
  9 | ; 
 10 | ; This program fragment implements a stereo reberb effect
 11 | ; on a DSP56001 processor.  The "depth" and wet/dry mix are
 12 | ; adjustable.  The following filter configuration is employed:
 13 | ;
 14 | ;
 15 | ;  Left in ------+------- "dry" gain -----------> sum -----> Left out
 16 | ;                |                                 ^
 17 | ;                v                                 |
 18 | ;               sum --> reverb --> "wet" gain -----+
 19 | ;                ^                                 |
 20 | ;                |                                 v -
 21 | ;  Right in -----+------- "dry" gain -----------> sum -----> Right out
 22 | ;
 23 | ;
 24 | ; Note that the reverb path output is negated before summing with the
 25 | ; right input signal.  This throws in 180 degrees of phase shift
 26 | ; making for interesting results even with mono inputs 
 27 | ; (i.e. Left in == Right in).
 28 | ; 
 29 | ; The reverb element looks like this:
 30 | ;
 31 | ;
 32 | ; Input ----+-----> comb1 ------+
 33 | ;           |                   |
 34 | ;           +-----> comb2 ---\  v
 35 | ;           |                  sum -----> allpass1 --> allpass2 ---> output
 36 | ;           +-----> comb3 ---/  ^
 37 | ;           |                   |
 38 | ;           +-----> comb4 ------+
 39 | ;
 40 | ; Each comb stage looks like this:
 41 | ;
 42 | ;                        +---- gain <-----+
 43 | ;                        |                |
 44 | ;                        v                |
 45 | ; Input ---> gain ----> sum ---> delay ---+--> out
 46 | ;
 47 | ;
 48 | ; The allpass stages look like:
 49 | ;
 50 | ;                         +--------- gain <---------+
 51 | ;                         |                         |
 52 | ;                         v                         |
 53 | ; Input ---> gain --+--> sum ---> delay ---> sum ---+----> out
 54 | ;                   |                         ^
 55 | ;                   |                         |
 56 | ;                   +--------> gain ----------+
 57 | ;
 58 | ; or,
 59 | ;
 60 | ;                             +-------> gain ----+
 61 | ;                             |                  |
 62 | ;                             |                  v
 63 | ; Input ---> gain ----> sum --+--> delay --+--> sum -----> out
 64 | ;                        ^                 |
 65 | ;                        |                 |
 66 | ;                        +----- gain <-----+
 67 | ;
 68 | ;
 69 | ; I've seen both configurations in the literature, so I plotted the
 70 | ; Z-transform and they are equivalent in the steady state.  They are indeed
 71 | ; all-pass in the steady state but are supposed to have a subtle, discernable
 72 | ; effect in "transient" audio signals.
 73 | ;
 74 | ; I think it could really use a couple more comb stages to fill in some of the 
 75 | ; graininess.  The best possible "diffusion" is desired.  By the way, 
 76 | ; I'd enjoy seeing any optimizations to the code.
 77 | ;
 78 | 
 79 | ;hardware specific initialization code
 80 | 
 81 | include "tdsg.a56"
 82 | 
 83 | ;***************************************************************
 84 | ;
 85 | ;	Data and constants
 86 | ;
 87 | ;***************************************************************
 88 | 
 89 | dot				;remember where we were in P-space
 90 | 	org	x:$10		;put runtime variables in on-chip X-space
 91 | 
 92 | ; A spreadsheet was used to calculate the following numbers
 93 | ;
 94 | ; The gain of each feedback stage is given by
 95 | ;
 96 | ;	feedback gain = exp(delay * ln(.001)/duration)
 97 | ;
 98 | ; where "delay" is the delay of the comb or allpass stage in seconds,
 99 | ; and "duration" is the time in seconds for the reverberated sound
100 | ; to decay to 1/1000 of its original amplitude.
101 | ;
102 | 
103 | ;  Reverb filter lengths and coefficients  
104 | ;  Sun Aug  4 16:36:16 1991    
105 | ;  
106 | ;      Sample rate               32.5520830 kHz      
107 | ;      Reverb duration            4.0000000 s        
108 | ;  
109 | ;  stage    delay(ms)    length        gain    actual
110 | ;  -----------------------------------------------------       
111 | ;  Comb1   29.7000000       967   0.9500031     29.71
112 | ;  Comb2   37.1000000      1208   0.9379399     37.11
113 | ;  Comb3   41.1000000      1338   0.9314831     41.10
114 | ;  Comb4   43.7000000      1423   0.9273101     43.71
115 | ;  All-1    5.0000000       163   0.9914025      5.01
116 | ;  All-2    1.7000000        55   0.9970685      1.69
117 | 
118 | in_atten equ                      0.3409091
119 | comb_atten equ                    0.0416667
120 | dry_init equ                      0.4000000	; initial "dry" gain
121 | reverb_init equ  	          0.9900000	; initial "wet" gain
122 | 
123 | ; comb 1 data and parameters
124 | 
125 | c1d equ                   $4000
126 | c1r  dc                     c1d
127 | c1m equ                     966
128 | c1c equ                           0.9500031
129 | 
130 | ; comb 2 data and parameters
131 | 
132 | c2d equ          c1d+      2048
133 | c2r  dc                     c2d
134 | c2m equ                    1207
135 | c2c equ                           0.9379399
136 | 
137 | ; comb 3 data and parameters
138 | 
139 | c3d equ          c2d+      2048
140 | c3r  dc                     c3d
141 | c3m equ                    1337
142 | c3c equ                           0.9314831
143 | 
144 | ; comb 4 data and parameters
145 | 
146 | c4d equ          c3d+      2048
147 | c4r  dc                     c4d
148 | c4m equ                    1422
149 | c4c equ                           0.9273101
150 | 
151 | ; allpass 1 data and parameters
152 | 
153 | a1d equ          c4d+      2048
154 | a1r  dc                     a1d
155 | a1m equ                     162
156 | a1c equ                           0.9914025
157 | 
158 | ; allpass 2 data and parameters
159 | 
160 | a2d equ          a1d+      2048
161 | a2r  dc                     a2d
162 | a2m equ                      54
163 | a2c equ                           0.9970685
164 | 
165 | 	org	y:$0
166 | 
167 | reverb_on equ	reverb_init
168 | reverb_off equ	0
169 | 
170 | reverb_gain
171 | 	dc	reverb_on
172 | dry_gain
173 | 	dc	dry_init
174 | 
175 | 	org	p:dot		;go back to P-space
176 | 
177 | ;*****************************************************
178 | ;
179 | ; reverb initialization code
180 | ;
181 | ;*****************************************************
182 | 
183 | hf_init
184 | 	rts
185 | 
186 | ;*****************************************************
187 | ;
188 | ; run-time controls
189 | ;
190 | ;*****************************************************
191 | 
192 | eff1_on		;enable reverb
193 | 	move			#reverb_on,y0
194 | 	move			y0,y:<reverb_gain
195 | 	rts
196 | 
197 | eff1_off	;bypass reverb
198 | 	move			#reverb_off,y0
199 | 	move			y0,y:<reverb_gain
200 | 	rts
201 | 
202 | ;*****************************************************
203 | ;
204 | ; interrupt time calculations
205 | ;
206 | ;*****************************************************
207 | 
208 | ;
209 | ; fs = 32.552083 kHz
210 | ;
211 | 
212 | hf_comp
213 | 	jsr	<saveregs
214 | ;
215 | ;	L/R mix
216 | ;
217 | 	clr	a	#in_atten,x1		;clr a, get scale for mix
218 | 	move		x:<in_l,x0		;get left in
219 | 	move		x0,x:<in_ls		;save
220 | 	macr	x0,x1,a x:<in_r,x0		;a = scale * left, get right
221 | 	macr	x0,x1,a	x0,x:<in_rs		;a += scale * right, save right
222 | 	clr	b		a,y0		;y0 goes to the combs, b is sum
223 | ;
224 | ;	comb 1 
225 | ;
226 | 	move		x:<c1r,r0
227 | 	movec		#c1m,m0
228 | 	move			y0,a
229 | 	move		x:(r0),x1
230 | 	add	x1,b	#c1c,x0
231 | 	macr	x0,x1,a
232 | 	move		a,x:(r0)+
233 | 	move		r0,x:<c1r
234 | ;
235 | ;	comb 2
236 | ;
237 | 	move		x:<c2r,r0
238 | 	movec		#c2m,m0
239 | 	move			y0,a
240 | 	move		x:(r0),x1
241 | 	add	x1,b	#c2c,x0
242 | 	macr	x0,x1,a
243 | 	move		a,x:(r0)+
244 | 	move		r0,x:<c2r
245 | ;
246 | ;	comb 3
247 | ;
248 | 	move		x:<c3r,r0
249 | 	movec		#c3m,m0
250 | 	move			y0,a
251 | 	move		x:(r0),x1
252 | 	add	x1,b	#c3c,x0
253 | 	macr	x0,x1,a
254 | 	move		a,x:(r0)+
255 | 	move		r0,x:<c3r
256 | ;
257 | ;	comb 4
258 | ;
259 | 	move		x:<c4r,r0
260 | 	movec		#c4m,m0
261 | 	move			y0,a
262 | 	move		x:(r0),x1
263 | 	add	x1,b	#c4c,x0
264 | 	macr	x0,x1,a
265 | 	move		a,x:(r0)+
266 | 	move		r0,x:<c4r
267 | ;
268 | ;	scale
269 | ;
270 | 	move		#comb_atten,x0	b,y0
271 | 	mpyr	x0,y0,b
272 | 
273 | ;
274 | ;	allpass 1
275 | ;
276 | 	move		x:<a1r,r0
277 | 	movec		#a1m,m0
278 | 	move		#a1c,x0
279 | 	move		x:(r0),x1
280 | 	macr	x0,x1,b	x1,a
281 | 	move			b,y0
282 | 	macr	-x0,y0,a b,x:(r0)+
283 | 	move		r0,x:<a1r
284 | ;
285 | ;	allpass 2
286 | ;
287 | 	move		x:<a2r,r0
288 | 	movec		#a2m,m0
289 | 	move		#a2c,x0
290 | 	move		x:(r0),x1
291 | 	macr	x0,x1,a	x1,b
292 | 	move			a,y0
293 | 	macr	-x0,y0,b a,x:(r0)+
294 | 	move		r0,x:<a2r
295 | ;
296 | ;	output mix
297 | ;
298 | 	move		b,x0
299 | 	move			y:<reverb_gain,y0
300 | 	mpyr	x0,y0,b		y:<dry_gain,y0
301 | 	move		x:<in_ls,x0
302 | 	move		b,a
303 | 	macr	x0,y0,a	x:<in_rs,x0
304 | 	macr	x0,y0,b	a,x:<out_l
305 | 	move		b,x:<out_r
306 | 
307 | 	jsr	<restregs
308 | 	rts
309 | 
310 | 	end
311 | 
312 | 


--------------------------------------------------------------------------------
/examples/sixcomb.a56:
--------------------------------------------------------------------------------
  1 | ;***************************************************************
  2 | ; 
  3 | ; A stereo reverb for the DSP56001 signal processor.  Based on,
  4 | ; 
  5 | ;	Moorer, James A. "About This Reverberation Business."
  6 | ;	Computer Music Journal Vol 3, No. 2 (1979), pp. 13-28.
  7 | ;
  8 | ;   reprinted in,
  9 | ;
 10 | ;	Roads, Curtis, and Strawn, John, ed., _Foundations
 11 | ;	of Computer Music_, pp. 605-639, MIT Press, 1985.
 12 | ;	ISBN 0-262-68051-3 (paper)
 13 | ;	ISBN 0-262-181142 (hard)
 14 | ;
 15 | ; Each comb filter uses a low-pass filter in the feedback path.
 16 | ; The combs and all-pass filter delay lines use a prime-number
 17 | ; of stages to improve diffusion.
 18 | ;
 19 | ; The output all-pass stage is replicated for left/right
 20 | ; decorrelation.  Each side uses slightly different gains
 21 | ; and delay lengths.  This works a lot better than just inverting
 22 | ; one side and adding in the input.
 23 | ;
 24 | ; I left out the early-reflection FIR filter because I needed the cycles
 25 | ; for other effects.
 26 | ;
 27 | ; Quinn Jensen (jensenq@zdomain.com)
 28 | ;
 29 | ;***************************************************************
 30 | 	psect	vectors		p:$0000:$0040
 31 | 	psect	hf_code		p:$0040:$0200
 32 | 	psect	hf_datax	x:$0000:$0040
 33 | 	psect	hf_datax1	x:$0040:$0100
 34 | 	psect	hf_datay	y:$0000:$0040
 35 | 	psect	hf_datay1	y:$0040:$0100
 36 | 	psect	midi_data	x:$0400:$1000
 37 | 	psect	lo_data		x:$1000:$F000
 38 | 	psect	lo_code		p:$F000:$FE00
 39 | 	psect	loader		p:$FE00:$FFFF
 40 | 	psect	iox		x:$FFC0:$FFFF
 41 | 	psect	ioy		y:$FFC0:$FFFF
 42 | ;
 43 | ; some oft-used constants
 44 | ;
 45 | 	psect	hf_datax
 46 | ffff	dc	$FFFF		;used a lot for modulus
 47 | ONE	equ	$7FFFFF		;"one"
 48 | one	dc	ONE		;"one"
 49 | ;
 50 | ; L/R inputs and outputs
 51 | ;
 52 | in_l	dc	0.0      
 53 | in_r	dc	0.0      
 54 | out_l	dc	0.0      
 55 | out_r	dc	0.0      
 56 | ;
 57 | ; recompute comb gains g1 and g2
 58 | ;
 59 | recalc_comb_gains
 60 | 	move		x:<constsp,r0
 61 | 	movec		x:<ffff,m0
 62 | 	move		x:lowpass_cutoff_start,b
 63 | 	move		x:lowpass_cutoff_slope,y1
 64 | 	move		x:comb_g,x1
 65 | 	move		#0.5,x0
 66 | 
 67 | 	do	#6,recalc_loop
 68 | 	  clr	a	(r0)+		;skip over the modulus const
 69 | 	  add	x0,a	b,y0
 70 | 	  mac	x0,y0,a			;g1 = .5 * b + .5
 71 | 	  clr	a	a,y0		;y0 = g1
 72 | 	  add	x1,a	y0,y:(r0)+	;store g1 in table
 73 | 	  macr	-x1,y0,a		;g2 = g(1-g1) = g - g*g1 with limiting
 74 | 	  add	y1,b	a,y:(r0)+	;update b, store g2 in table
 75 | recalc_loop
 76 | 	rts
 77 | 
 78 | 	psect	midi_data
 79 | ;
 80 | ; default values for midi-derived parameters
 81 | ;
 82 | lowpass_cutoff_start
 83 | 	dc	-0.3906250	; ctl value of 39
 84 | lowpass_cutoff_slope
 85 | 	dc	0.0468750	; ctl value of 67
 86 | comb_g
 87 | 	dc	0.8325507974	; ctl value of 57
 88 | ;
 89 | ; preset comb-length arrays
 90 | ;
 91 | define(COMBLEN, `
 92 | ; comb lenths $2,$3,$4,$5,$6,$7
 93 | comblen_$1
 94 | 	dc	$2-1
 95 | 	dc	$3-1
 96 | 	dc	$4-1
 97 | 	dc	$5-1
 98 | 	dc	$6-1
 99 | 	dc	$7-1
100 | ')
101 | 
102 | COMBLEN(1, 383, 433, 467, 523, 557, 601)
103 | COMBLEN(2, 509, 577, 631, 701, 743, 797)
104 | COMBLEN(3, 683, 769, 839, 937, 991, 1069)
105 | COMBLEN(4, 919, 1021, 1117, 1249, 1319, 1427)
106 | COMBLEN(5, 1223, 1367, 1489, 1657, 1759, 1901)
107 | COMBLEN(6, 1627, 1823, 1987, 2213, 2341, 2539)
108 | 
109 | ;;;;;;;;;;;;;;;;;;;;;;;
110 | ; reverb filters
111 | ;;;;;;;;;;;;;;;;;;;;;;;
112 | 
113 | ;  Reverb filter lengths and coefficients     
114 | ;  6 comb reverb with prime delay lines
115 | ;  Sun Oct 24 13:53:51 1993
116 | ;  
117 | ;                          Sample rate        32.5520830 kHz      
118 | ;                          g                   0.8400000
119 | ;  
120 | ;                    status      STABLE       
121 | ;         delay      near prime lengths actual
122 | ;  stage   (ms)   len  high   low  best  delay        g1        g2
123 | ;  ---------------------------------------------------------------
124 | ;  Comb 1  50.0  1628  1637  1627  1627 49.981 0.3064583 0.5825750
125 | ;  Comb 2  56.0  1823  1823  1823  1823 56.003 0.3264583 0.5657750
126 | ;  Comb 3  61.0  1986  1987  1979  1987 61.041 0.3464583 0.5489750
127 | ;  Comb 4  68.0  2214  2221  2213  2213 67.983 0.3594792 0.5380375
128 | ;  Comb 5  72.0  2344  2347  2341  2341 71.916 0.3694792 0.5296375
129 | ;  Comb 6  78.0  2539  2539  2539  2539 77.998 0.4243750 0.4835250
130 | ;  All      6.0   195   197   193   193  5.929 0.7000000
131 | 
132 | ; COMB(name, length, modulus, g1, g2)
133 | 
134 | define(COMB, `
135 | ; storage for "$1" length=$2 modulus=$3 g1=$4 g2=$5
136 | 
137 | 	psect	lo_data
138 | 	align	$3
139 | $1d
140 | $1m	equ	$2-1
141 | 	org	x:$1d+$1m
142 | 	psect	hf_datax
143 | $1g1	equ	$4
144 | $1g2	equ	$5
145 | ')
146 | 
147 | COMB(c1, 1627, 2048, 0.3046875, 0.5812382)
148 | COMB(a1, 193, 256, 0.7000000, 0.0000000)
149 | COMB(c2, 1823, 2048, 0.3281250, 0.5616459)
150 | COMB(c3, 1987, 2048, 0.3515625, 0.5420536)
151 | COMB(c4, 2213, 4096, 0.3750000, 0.5224613)
152 | COMB(a2, 207, 256, 0.7500000, 0.0000000)
153 | COMB(c5, 2341, 4096, 0.3984375, 0.5028690)
154 | COMB(c6, 2539, 4096, 0.4218750, 0.4832767)
155 | 
156 | 	psect	hf_datax
157 | a1r	dc	a1d
158 | a1md	dc	a1m
159 | a1g1d	dc	a1g1
160 | a2r	dc	a2d
161 | a2md	dc	a2m
162 | a2g1d	dc	a2g1
163 | 	psect	hf_datay
164 | curaddrp
165 | 	dc	curaddr
166 | 	psect	hf_datax
167 | constsp	dc	consts
168 | lowstatep
169 | 	dc	lowstate
170 | 
171 | 	psect	hf_datax1
172 | curaddr
173 | 	dc	c1d
174 | 	dc	c2d
175 | 	dc	c3d
176 | 	dc	c4d
177 | 	dc	c5d
178 | 	dc	c6d
179 | 
180 | 	psect	hf_datay1
181 | consts
182 | 	dc	c1m
183 | 	dc	c1g1
184 | 	dc	c1g2
185 | 	dc	c2m
186 | 	dc	c2g1
187 | 	dc	c2g2
188 | 	dc	c3m
189 | 	dc	c3g1
190 | 	dc	c3g2
191 | 	dc	c4m
192 | 	dc	c4g1
193 | 	dc	c4g2
194 | 	dc	c5m
195 | 	dc	c5g1
196 | 	dc	c5g2
197 | 	dc	c6m
198 | 	dc	c6g1
199 | 	dc	c6g2
200 | 
201 | 	psect	hf_datax1
202 | lowstate
203 | 	dc	0
204 | 	dc	0
205 | 	dc	0
206 | 	dc	0
207 | 	dc	0
208 | 	dc	0
209 | 
210 | ;;;;;;;;;;;;;;;;;;;;;;;
211 | ; miscellaneous signals
212 | ;;;;;;;;;;;;;;;;;;;;;;;
213 | 
214 | 	psect	hf_datax
215 | L_overall
216 | 	dc	$7FFFFF
217 | R_overall
218 | 	dc	$7FFFFF
219 | 
220 | ;;;;;;;;;;;;;;;;;;;;;;;
221 | ; signal vector
222 | ;;;;;;;;;;;;;;;;;;;;;;;
223 | 	psect	hf_datax
224 | 	align 8
225 | signal_vector
226 | Lin	dc	0.0
227 | Rin	dc	0.0
228 | Reverb_L
229 | 	dc	0.0
230 | Reverb_R	
231 | 	dc	0.0
232 | 
233 | Lout
234 | 	dc	0
235 | Rout
236 | 	dc	0
237 | 
238 | 	psect hf_datay
239 | signal_vectorp
240 | 	dc	signal_vector
241 | signal_mod
242 | 	dc	4-1
243 | 
244 | gain_vectorsp
245 | 	dc	gain_vectors
246 | ;;;;;;;;;;;;;;;;;;;;;;;
247 | ; gain matrix
248 | ;;;;;;;;;;;;;;;;;;;;;;;
249 | 	psect	hf_datay1
250 | gain_vectors
251 | Reverb_gain_vector
252 | Reverb_Lin	dc 0.5
253 | Reverb_Rin	dc 0.5
254 | Reverb_Reverb_L	dc 0.0
255 | Reverb_Reverb_R	dc 0.0
256 | 
257 | Lout_gain_vector
258 | Lout_Lin	dc 0.0
259 | Lout_Rin	dc 0.0
260 | Lout_Reverb_L	dc ONE
261 | Lout_Reverb_R	dc 0.0
262 | 
263 | Rout_gain_vector
264 | Rout_Lin	dc 0.0
265 | Rout_Rin	dc 0.0
266 | Rout_Reverb_L	dc 0.0
267 | Rout_Reverb_R	dc -1.0
268 | 
269 | ;***************************************************************
270 | ;
271 | ;	init code - call hf_init at first and any time when
272 | ;	parameters change
273 | ;
274 | ;***************************************************************
275 | 	psect	lo_code
276 | 
277 | hf_init
278 | ;
279 | ;	clear out the filter delay lines
280 | ;
281 | define(CLEAR_LINE, `
282 | 	move		#$1d,r0
283 | 	movec		#$1m,m0
284 | 	jsr	clear_line_r0
285 | ')
286 | 
287 | CLEAR_LINE(c1)
288 | CLEAR_LINE(c2)
289 | CLEAR_LINE(c3)
290 | CLEAR_LINE(c4)
291 | CLEAR_LINE(c5)
292 | CLEAR_LINE(c6)
293 | CLEAR_LINE(a1)
294 | CLEAR_LINE(a2)
295 | 	jsr	recalc_comb_gains
296 | 	rts
297 | 
298 | clear_line_r0
299 | 	clr	a
300 | 	rep	#0
301 | 	  move		a,x:(r0)+
302 | 	rts
303 | 
304 | ;***************************************************************
305 | ;
306 | ;	sample rate computations
307 | ;
308 | ;	Call hf_comp once per sample.
309 | ;	Globals in_l and in_r should have the left and right
310 | ;	input samples.  When hf_comp returns, out_l and out_r
311 | ;	will be ready.
312 | ;
313 | ;***************************************************************
314 | 
315 | ;
316 | ; fs = 32.552083 kHz
317 | ;
318 | 	psect	hf_code
319 | 
320 | hf_comp
321 | ;
322 | ;	copy inputs
323 | ;
324 | 	move		x:<in_l,a
325 | 	move		a,x:<Lin
326 | 	move		x:<in_r,a
327 | 	move		a,x:<Rin
328 | ;
329 | ;	compute outputs using matrix multiply
330 | ;
331 | ; [reverb_in out_l out_r] = [gain_vector] * [signal_vector]
332 | ;
333 | 	move		y:<signal_vectorp,r0
334 | 	movec		y:<signal_mod,m0
335 | 	move		y:<gain_vectorsp,r4
336 | 	movec		x:<ffff,m4
337 | 	move		x:<L_overall,y1		;and wait for m4
338 | 	clr	a	x:(r0)+,x0 y:(r4)+,y0
339 | 	mac	x0,y0,a	x:(r0)+,x0 y:(r4)+,y0
340 | 	mac	x0,y0,a	x:(r0)+,x0 y:(r4)+,y0
341 | 	mac	x0,y0,a	x:(r0)+,x0 y:(r4)+,y0
342 | 	macr	x0,y0,a	x:(r0)+,x0 y:(r4)+,y0
343 | 	clr	a	a,b			;b is reverb_in
344 | 	mac	x0,y0,a	x:(r0)+,x0 y:(r4)+,y0
345 | 	mac	x0,y0,a	x:(r0)+,x0 y:(r4)+,y0
346 | 	mac	x0,y0,a	x:(r0)+,x0 y:(r4)+,y0
347 | 	macr	x0,y0,a	x:(r0)+,x0 y:(r4)+,y0
348 | 	clr	a	a,x1
349 | 	mpy	x1,y1,a	x:<R_overall,y1
350 | 	clr	a	a,x:<out_l
351 | 	mac	x0,y0,a	x:(r0)+,x0 y:(r4)+,y0
352 | 	mac	x0,y0,a	x:(r0)+,x0 y:(r4)+,y0
353 | 	mac	x0,y0,a	x:(r0)+,x0 y:(r4)+,y0
354 | 	macr	x0,y0,a	x:(r0)+,x0 y:(r4)+,y0
355 | 	clr	a	a,x1
356 | 	mpy	x1,y1,a
357 | 	clr	a	a,x:<out_r
358 | ;
359 | ; r1	lowstate vector
360 | ; m1	-1
361 | ; r4	ptr to modulus,g1,g2 constants
362 | ; m4	-1
363 | ; r5	curaddr ptr
364 | ; m5	-1
365 | ; b	comb out accum
366 | ; x0	scaled comb in
367 | ;
368 | ;
369 | ;	set up reverb input
370 | ;
371 | 	clr	b	b,x0			;get reverb_in
372 | 	move		#1.0/16,x1		;allow 4 bits of headroom
373 | 	mpyr	x0,x1,a				;and 4 bits of noise
374 | 	move		a,x0
375 | 	move		x:<lowstatep,r1
376 | 	movec		x:<ffff,m1
377 | 	move		x:<constsp,r4
378 | 	movec		m1,m4
379 | 	move			y:<curaddrp,r5
380 | 	movec		m1,m5
381 | ;
382 | ;	do the six combs
383 | ;
384 | 	do	#6,comb_loop
385 | 	  move		x:(r5),r0		;r0=curaddr
386 | 	  movec		y:(r4)+,m0		;m0=modulus
387 | 	  move		x:(r1),x1 y:(r4)+,y1	;x1=lowstate, y1=g1, wait for m0
388 | 	  move		x:(r0)+,y0		;y0=delay out
389 | 	  add	y0,b		y0,a		;a=delay out
390 | 	  macr	x1,y1,a		y:(r4)+,y1	;a=out+g1*lowstate, y1=g2
391 | 	  clr	a      	a,x:(r1)+ a,y0		;y0=new lowstate
392 | 	  add	x0,a	r0,x:(r5)+		;a=in, save ptr
393 | 	  macr	y0,y1,a				;a=in+g2*g1*lowstate
394 | 	  move		a,x:-(r0)		;store delay in (takes 2 cyc)
395 | comb_loop
396 | ;
397 | ;	scale
398 | ;
399 | 	rnd	b	#$15,x0		;scale by ~1/6
400 | 	move		b,y0
401 | 	mpyr	x0,y0,b
402 | 	move		b,y1		;save b for right chan
403 | ;
404 | ;	allpass L
405 | ;
406 | 	move		x:<a1r,r0
407 | 	movec		x:<a1md,m0
408 | 	move		x:<a1g1d,x0
409 | 	move		x:(r0),x1
410 | 	macr	x0,x1,b	x1,a
411 | 	move			b,y0
412 | 	macr	-x0,y0,a b,x:(r0)+
413 | 	asl	a      	r0,x:<a1r
414 | 	asl	a			;get rid of the headroom
415 | 	asl	a
416 | 	asl	a
417 | 	move		a,x:<Reverb_L
418 | ;
419 | ;	allpass R
420 | ;
421 | 	tfr	y1,b	x:<a2r,r0
422 | 	movec		x:<a2md,m0
423 | 	neg	b	x:<a2g1d,x0
424 | 	move		x:(r0),x1
425 | 	macr	x0,x1,b	x1,a
426 | 	move			b,y0
427 | 	macr	-x0,y0,a b,x:(r0)+
428 | 	asl	a	r0,x:<a2r
429 | 	asl	a
430 | 	asl	a
431 | 	asl	a
432 | 	move		a,x:<Reverb_R
433 | ;
434 | ;	done
435 | ;
436 | 	rts
437 | 
438 | 	end
439 | 


--------------------------------------------------------------------------------
/examples/sloader.a56:
--------------------------------------------------------------------------------
  1 | ; Originally taken from came from Motorola's Dr. BuB DSP board.
  2 | ; Obtained from Todd Day's FTP archive as sloader.asm
  3 | ; Modified for TDSG56 project by Quinn Jensen (jensenq@zdomain.com)
  4 | ;
  5 | ; Text from original:
  6 | ;	Serial Loader for the DSP56000.
  7 | ;	This loader initializes	the serial communications interface (SCI)
  8 | ;	on the DSP56001	for 9600 baud and then loads OMF records (output
  9 | ;	by the DSP56000	assembler) into	internal memory.  The loader takes
 10 | ;	the upper 128 bytes of P memory	allowing the lower memory from
 11 | ;	$0000-(LDRMEM-1) to be used by the user.  The following	records	are
 12 | ;	interpreted:
 13 | ;	    _DATA X ADDR
 14 | ;	    _DATA Y ADDR
 15 | ;	    _DATA P ADDR
 16 | ;	    _END ADDR
 17 | ;	After the END record is	encountered, the loader	jumps to the address
 18 | ;	in the END record.  Note that an address MUST be present in the
 19 | ;	END record (the	program	must contain at	least one P segment).
 20 | ;
 21 | ;	To generate a EPROM of this loader (8Kx8), perform the following:
 22 | ;	$ asm56000 -b -l -a sloader
 23 | ;	$ srec sloader
 24 | ;
 25 | ;	The EPROM is in	file SLOADER.P.	 To program the	EPROM, set the
 26 | ;	programmer to MOTOROLA S record	format,	download the file with
 27 | ;	a zero address offset and program the part.
 28 | ;
 29 | ;	BTW, S record format is	LSB MidSB MSB (what! Intel format? :-)
 30 | ;	Took me	a few hours to figure this one out!  [Not really.  S records
 31 | ;	are big-endian, its just the 56001 boot loader that wants LSB first.
 32 | ;	-QJ]
 33 | ;
 34 | ;	If you don't have the program srec (where can I	get this?),
 35 | ;	you have to do some gnarly contortions on the .LOD file.
 36 | ;
 37 | ;	So, if your .LOD file resulting	from compiling this program
 38 | ;	looks like this:
 39 | ;
 40 | ;	_START SLOADER 0000 0000
 41 | ;
 42 | ;	_DATA P	0020
 43 | ;	010203 040506 070809
 44 | ;	_END 0020
 45 | ;
 46 | ;	then, program your PROM	with this sequence:
 47 | ;	$0020	0302  0106  0504  0908	07.....	etc. (Fun, eh? :)
 48 | ;
 49 | ;
 50 | ;	The loader loads the following memory spaces:
 51 | ;	    X -	0 to FF
 52 | ;	    Y -	0 to FF
 53 | ;	    P -	0 to LDRMEM-1
 54 | ;
 55 | 	PAGE	68,66,1,1
 56 | 
 57 | SCR	EQU	$FFF0		;SCI CONTROL REGISTER
 58 | SCCR	EQU	$FFF2		;SCI CLOCK CONTROL REGISTER
 59 | PCC	EQU	$FFE1		;PORT C	CONTROL	REGISTER
 60 | RDRF	EQU	$2		;RECEIVE DATA REGISTER FULL FLAG
 61 | SSR	EQU	$FFF1		;SCI STATUS REGISTER
 62 | SRXH	EQU	$FFF6		;SCI RECEIVE IN	HIGH BYTE
 63 | PBC	equ	$FFE0		;port B	control
 64 | PBDDR	equ	$FFE2		;port B	data direction
 65 | PBD	equ	$FFE4		;port B	data
 66 | BCR	equ	$FFFE		;port a bus control reg
 67 | #ifdef ROM
 68 | LDRMEM	EQU	$198		;START OF LOADER IN P MEMORY
 69 | #else
 70 | #ifdef HIGH
 71 | LDRMEM	EQU	$F000		;START OF LOADER IN P MEMORY
 72 | #else
 73 | LDRMEM	EQU	$80		;START OF LOADER IN P MEMORY
 74 | #endif
 75 | #endif
 76 | 
 77 | 	ORG	P:$0000		;RESET VECTOR FOR BOOTING
 78 | RVEC
 79 | 	JMP	<LOAD		;GO EXECUTE LOADER
 80 | 
 81 | 	ORG	P:LDRMEM,P:3*LDRMEM
 82 | LOAD
 83 | 	MOVEP	#$0302,X:SCR	;ENABLE	TX,RX: 8 BIT 1 START, 1	STOP
 84 | 
 85 | 				; *** You will probably	have to
 86 | 				; *** change the line below!
 87 | 	movep	#12,x:SCCR	;CD=12 (/13), int clk @ 31.25 Kbaud-4%
 88 | 	MOVEP	#$0007,X:PCC	;ENABLE	SCI
 89 | 
 90 | #define MSG(m) movep	#m<<7,x:PBD
 91 | 
 92 | 	MSG(0)
 93 | 	movep	#0,x:PBC	;port B: parallel I/O
 94 | 	movep	#-1,x:PBDDR	;port B: all output
 95 | 	bset	#3,x:PBD	;assert "ROM"; allows RAM to respond in P space
 96 |         movep	#$2f2f,x:BCR    ;wait states: 0 for RAM, 15 for ROM and I/O
 97 | 	MSG($c)
 98 | 	MSG($c|3<<4)		;clear strobes
 99 | 
100 | WTUS
101 | 	JSR	<GETCH		;INPUT CHARACTER
102 | 	MOVE	#'_',X0		;GET UNDERSCORE	CHARACTER
103 | 	CMP	X0,A		;SEE IF	"_" YET
104 | 	JNE	<WTUS		;NO
105 | GOTUS
106 | 	JSR	<GETCH		;GET A CHARACTER
107 | 	MOVE	#'D',X0		;GET A D FOR DATA
108 | 	CMP	X0,A	#'E',X0	;COMPARE TO D, GET E
109 | 	JEQ	<DATAREC	;IF "D", THEN DATA RECORD
110 | 	CMP	X0,A		;SEE IF	END RECORD
111 | 	JNE	<WTUS		;NO, GO	WAIT FOR ANOTHER UNDERSCORE
112 | _WTSPC
113 | 	MSG($e)
114 | 	JSR	<GETCH		;GET CHARACTER
115 | 	MOVE	#$20,X0		;GET SPACE
116 | 	CMP	X0,A		;WAIT FOR SPACE	AFTER "END"
117 | 	JNE	<_WTSPC		;WAIT FOR SPACE
118 | 	JSR	<IN4		;GET TRANSFER ADDRESS
119 | 	MOVE	B1,R0		;MOVE TRANSFER ADDRESS
120 | 	NOP			;CLEAR ADDRESS PIPE
121 | 	MSG($a)
122 | 	JMP	(R0)		;GO EXECUTE USER CODE
123 | DATAREC
124 | 	MSG($d)
125 | 	JSR	<GETCH		;GET CHARACTER
126 | 	MOVE	#$20,X0		;GET SPACE
127 | 	CMP	X0,A		;SEE IF	SPACE
128 | 	JNE	<DATAREC	;NO
129 | 	JSR	<GETCH		;GET [P,X,Y]
130 | 	MOVE	A1,Y0		;SAVE CHARACTER
131 | 	JSR	<IN4		;GET ADDRESS OF	DATA RECORD
132 | 	MOVE	B1,R0		;SAVE ADDRESS
133 | 	MOVE		#'X',A	;GET X
134 | 	CMP	Y0,A	#'Y',A	;SEE IF	X, GET Y
135 | 	JEQ	<_LDX		;LOAD DATA INTO	X MEMORY
136 | 	CMP	Y0,A		;SEE IF	Y
137 | 	JEQ	<_LDY		;LOAD DATA INTO	Y MEMORY
138 | _LDP
139 | 	JSR	<IN6		;GET DATA
140 | 	MOVEM	B1,P:(R0)+	;LOAD P	MEMORY
141 | 	JMP	<_LDP
142 | _LDX
143 | 	JSR	<IN6		;GET DATA
144 | 	MOVE	B1,X:(R0)+	;LOAD X	MEMORY
145 | 	JMP	<_LDX
146 | _LDY
147 | 	JSR	<IN6		;GET DATA
148 | 	MOVE	B1,Y:(R0)+	;LOAD Y	MEMORY
149 | 	JMP	<_LDY
150 | 
151 | GETCH
152 | 	JCLR	#RDRF,X:SSR,*	;WAIT FOR DATA IN SCI
153 | 	MOVEP	X:SRXH,A	;GET SCI DATA IN HIGH BYTE
154 | 	LSL	A		;SHIFT OUT PARITY
155 | 	LSR	A		;clear parity bit
156 | 	MOVE	A1,A		;SIGN EXTEND AND ZERO
157 | 	MOVEP	A,X:SRXH	;put sci data in high byte
158 |         RTS
159 | IN4
160 | 	MSG($4)
161 | 	CLR	B	#>4,X0	;CLEAR VALUE, GET 4
162 | 	JMP	<READHEX	;READ 4	HEX CHARACTERS
163 | IN6
164 | 	MSG($6)
165 | 	CLR	B	#>6,X0	;CLEAR VALUE, GET 6
166 | READHEX
167 | 	DO	X0,_READHEX	;READ ASCII HEX	AND CONVERT TO BINARY
168 | _GET
169 | 	JSR	<GETCH		;GET A CHARACTER
170 | 	MOVE	#'_',X0		;GET UNDERSCORE
171 | 	CMP	X0,A	#'F',X0	;SEE IF	UNDERSCORE
172 | 	JNE	<_NOTUS		;NO
173 | 	ENDDO			;EXIT LOOP
174 | 	MOVEC	SSH,X0		;POP RETURN ADDRESS
175 | 	JMP	<GOTUS		;GO PROCESS NEW	INPUT RECORD
176 | _NOTUS
177 | 	CMP	X0,A	#'0',X0	;SEE IF	GREATER	THAN F
178 | 	JGT	<_GET		;YES, IGNORE
179 | 	CMP	X0,A		;SEE IF	LESS THAN 0
180 | 	JLT	<_GET		;YES, IGNORE
181 | 	SUB	X0,A	#10,X0	;ADJUST	FOR ASCII TO BINARY
182 | 	CMP	X0,A	#7,X0	;SEE IF	A-F
183 | 	JLT	<_NOTALPHA	;NO
184 | 	SUB	X0,A		;ADJUST	FOR 1-F
185 | _NOTALPHA
186 | 	REP	#4		;SHIFT OLD VALUE LEFT 1	NIBBLE
187 | 	LSL	B
188 | 	REP	#16		;SHIFT NEW NIBBLE DOWN TO LSB
189 | 	LSR	A
190 | 	ADD	A,B		;ADD NEW NIBBLE	IN
191 | _READHEX
192 | 	RTS
193 | 	END
194 | 
195 | 


--------------------------------------------------------------------------------
/examples/tdsg.a56:
--------------------------------------------------------------------------------
  1 | ;***************************************************************
  2 | ;
  3 | ;	basic run-time
  4 | ;
  5 | ;***************************************************************
  6 | include	"ioequ.inc"
  7 | ;
  8 | ; vectors
  9 | ;
 10 | 	org	p:$0000
 11 |         movep	#$0f0f,x:m_bcr			;wait: RAM:0;ROM,I/O:15
 12 | 	jmp	<start
 13 | 
 14 | 	org	p:$000C
 15 | 	jsr	<ssi_int			;go handle SSI interrupt
 16 | 	org	p:$0010
 17 | ssix	jsr	<ssi_int			;go handle SSI interrupt
 18 | 
 19 | ;
 20 | ; global data areas
 21 | ;
 22 | 	org	x:$0
 23 | in_l	dc	0	   			;input queue
 24 | in_r	dc	0
 25 | in_ls	dc	0   				;saved left
 26 | in_rs	dc	0   				;and right
 27 | out_l	dc	0				;output queue
 28 | out_r	dc	0
 29 | 
 30 | savea10 dc	0				;places to save regs
 31 | savea2	dc	0				;N.B. uses YMEM also!
 32 | saveb10	dc	0
 33 | saveb2	dc	0
 34 | savex	dc	0
 35 | savey	dc	0
 36 | 
 37 | ;
 38 | ; global register assignments
 39 | ;
 40 | ; r5,m5		Stereo input queue pointer (alternating L/R)
 41 | ; r4,m4		Stereo output queue pointer (alternating L/R)
 42 | 
 43 | ;***************************************************************
 44 | ;
 45 | ;	initialization
 46 | ;
 47 | ;***************************************************************
 48 | 	org	p:$40		;$$$ move to external RAM
 49 | start
 50 | 	movec	#$0300,sr			;go to IPL 3
 51 | 
 52 | 	jsr	hf_init
 53 | ;
 54 | ; set up SSI
 55 | ;
 56 | 	movep	#2<<13|1<<8,x:m_cra		;16-bit word, 2 time slots
 57 | 	movep	#1<<14|3<<12|1<<11|1<<9,x:m_crb	;sync,network,enable,SC2 in
 58 | 
 59 | 	movep	#0,x:m_pcddr			;port C is SSI/SCI
 60 | 	movep	#$1FF,x:m_pcc			;port C is SSI/SCI
 61 | 	jsr	init_stereo
 62 | ;
 63 | ; enable interrupts
 64 | ;
 65 | 	movep	#1<<12,x:m_ipr			;SSI at 1, others off
 66 | 	movec	#0,sr				;lower IPL
 67 | 	jset	#0,x:m_sr,*			;sync up with left chan
 68 | 	jclr	#0,x:m_sr,*			;
 69 | 	jsr	init_stereo
 70 | 
 71 | 	jmp	mainloop
 72 | 
 73 | init_stereo
 74 | 	move		#>in_l,r5		;base of stereo input queue
 75 | 	move		#>out_l,r4		;base of stereo output queue
 76 |  	movec		#2-1,m5			;modulus of stereo input queue
 77 | 	movec		#2-1,m4			;modulus of stereo output queue
 78 | 	rts
 79 | 
 80 | ;***************************************************************
 81 | ;
 82 | ;	main loop
 83 | ;
 84 | ;***************************************************************
 85 | mainloop
 86 | ;       
 87 | ;	do any polling or foreground tasks here
 88 | ;
 89 | 	jmp	<mainloop
 90 | 
 91 | ;***************************************************************
 92 | ;
 93 | ;	interrupt service
 94 | ;
 95 | ;***************************************************************
 96 | 	
 97 | ;
 98 | ; SSI interrupt routine
 99 | ;
100 | 
101 | ; keep in on-chip RAM
102 | 
103 | ssi_int
104 | 	movep	x:m_rx,x:(r5)+			;bring in L or R
105 | 	movep	x:(r4)+,x:m_tx			;and output L or R
106 | 	jsset	#0,x:m_sr,hf_comp		;
107 | 	rti
108 | 
109 | saveregs
110 | 	move		a2,x:<savea2
111 | 	move		a1,x:<savea10
112 | 	move		a0,y:<savea10
113 | 	move		x,l:<savex
114 | 	move		b2,l:<saveb2
115 | 	move		b1,x:<saveb10
116 | 	move		b0,y:<saveb10
117 | 	move		y,l:<savey
118 | 	rts
119 | 
120 | restregs
121 | 	move		l:<savea10,a
122 | 	move		x:<savea2,a2
123 | 	move		l:<savex,x
124 | 	move		l:<saveb10,b
125 | 	move		x:<saveb2,b2
126 | 	move		l:<savey,y
127 | 	rts
128 | 
129 | 


--------------------------------------------------------------------------------
/examples/test-dac.a56:
--------------------------------------------------------------------------------
  1 | ; Various tests for output filter and DAC.  I used a Nippon Precision Circuits
  2 | ; SM5813AP dual-channel 8-times oversampling digital filter into a Burr Brown
  3 | ; PCM1700P dual-channel 18-bit DAC.  The code is very specific to my hardware.
  4 | ;
  5 | ; available signals:
  6 | ;	impulse
  7 | ;	square
  8 | ;	triangle
  9 | ;	sine		(uses twin-integrator harmonic oscillator)
 10 | ;
 11 | ; This code is not interrupt driven but simple spins waiting for transmitter
 12 | ; ready on each sample.
 13 | ;
 14 | ;
 15 | ; written by Quinn Jensen
 16 | ; home: jensenq@zdomain.com
 17 | ;
 18 | include	"ioequ.inc"
 19 | 
 20 | 	org	p:$0000
 21 | 	jmp	<start
 22 | 
 23 | 	org	p:$000C
 24 | ;ssi	jsr	ssi_int				;go handle SSI interrupt
 25 | 
 26 | ; data areas
 27 | 
 28 | 	org	x:$0
 29 | i_left	dc	0				;left channel in
 30 | i_right	dc	0				;right channel in
 31 | 
 32 | 	org	p:$40
 33 | start
 34 | 
 35 | ; assign mode
 36 | 
 37 | 	movec	#$0300,sr			;go to IPL 3
 38 | 
 39 | ; set up interrupts
 40 | 
 41 | ;       movep	#0<<13|3<<12|0<<10,x:m_ipr	;put SSI at lev 3, others off
 42 | 
 43 | ; set system sample rate
 44 | 
 45 | 	bclr	#6,x:<<m_pbd			;32.55 kHz
 46 | 	bset	#5,x:<<m_pbd			;
 47 | 	bclr	#4,x:<<m_pbd			;
 48 | 
 49 | ; set up SSI
 50 | 
 51 | 	movep	#2<<13|1<<8,x:m_cra		;16-bit word, 2 time slots
 52 | 	movep	#0<<15|3<<12|1<<11|1<<9,x:m_crb	;sync,network,enable
 53 | 
 54 | 	movep	#0,x:m_pcddr			;port C is SSI/SCI
 55 | 	movep	#$1FF,x:m_pcc			;port C is SSI/SCI
 56 | 
 57 | ; enable interrupts
 58 | 
 59 | ;       movec	#0,sr				;lower IPL
 60 | 
 61 | 	jmp	<impulse			;jump to the desired signal
 62 | 
 63 | ; impulse
 64 | 
 65 | impulse
 66 | 	move	#>-.5,a
 67 | 
 68 | im1
 69 | 	do	#400,im0
 70 | 	jsr	<imp
 71 | im0     
 72 | 	neg	a
 73 | 	jsr	<imp
 74 | 	neg	a
 75 | 	jmp	<im1
 76 | 
 77 | imp
 78 | 	jclr	#6,x:m_sr,*			;wait for transmitter ready
 79 | 	movep	a,x:m_tx
 80 | 	jclr	#6,x:m_sr,*			;wait for transmitter ready
 81 | 	movep	a,x:m_tx
 82 | 	rts
 83 | 
 84 | ; square wave
 85 | 
 86 | square
 87 | 	move	#>-.1,a
 88 | 
 89 | sq1
 90 | 	do	#200,sq0
 91 | 	jclr	#6,x:m_sr,*			;wait for transmitter ready
 92 | 	movep	a,x:m_tx
 93 | 	jclr	#6,x:m_sr,*			;wait for transmitter ready
 94 | 	movep	a,x:m_tx
 95 | sq0     
 96 | 	neg	a
 97 | 	jmp	<sq1
 98 | 
 99 | 
100 | ; triangle wave
101 | 
102 | triangle
103 | 	move	#>.010,x0
104 | 	move	#>-.9,a
105 | 
106 | l0      
107 | 	do	#90*2,l1
108 | 	add	x0,a
109 | 	jclr	#6,x:m_sr,*			;wait for transmitter ready
110 | 	movep	a,x:m_tx
111 | 	jclr	#6,x:m_sr,*			;wait for transmitter ready
112 | 	movep	a,x:m_tx
113 | l1
114 | 	move	x0,b
115 | 	neg	b
116 | 	move	b,x0
117 | 	jmp	<l0
118 | 
119 | 
120 | ; sine wave
121 | 
122 | sine
123 | 	move	#>.050,x0			;oscillator freq
124 | 	move	#>-.209,a			;initial conditions
125 | 	move	#>.2090,b			;
126 | 
127 | loop
128 | 	mac	x0,y0,a
129 | 	move	a,y0
130 | 	jclr	#6,x:m_sr,*			;wait for transmitter ready
131 | 	movep	a,x:m_tx		
132 | 	mac	-x0,y0,b
133 | 	move	b,y0
134 | 	jclr	#6,x:m_sr,*			;wait for transmitter ready
135 | 	movep	b,x:m_tx		
136 | 
137 | 	jmp	<loop
138 | 
139 | 	end
140 | 


--------------------------------------------------------------------------------
/examples/test-int.a56:
--------------------------------------------------------------------------------
  1 | ; Interrupt-driven version of test-dac.a56.
  2 | ;
  3 | include	"ioequ.inc"
  4 | 
  5 | 	org	p:$0000
  6 | 	jmp	<start
  7 | 
  8 | 	org	p:$000C
  9 | ssi	jsr	<ssi_int			;go handle SSI interrupt
 10 | 
 11 | ; data areas
 12 | 
 13 | 	org	x:$0
 14 | i_left	dc	0				;left channel in
 15 | i_right	dc	0				;right channel in
 16 | 
 17 | 	org	p:$40
 18 | start
 19 | 
 20 | ; assign mode
 21 | 
 22 | 	movec	#$0300,sr			;go to IPL 3
 23 | 
 24 | ; set up interrupts
 25 | 
 26 | 	movep	#0<<13|3<<12|0<<10,x:m_ipr	;put SSI at lev 3, others off
 27 | 
 28 | ; set system sample rate
 29 | 
 30 | 	bclr	#6,x:<<m_pbd			;32.55 kHz
 31 | 	bset	#5,x:<<m_pbd			;
 32 | 	bclr	#4,x:<<m_pbd			;
 33 | 
 34 | ; set up SSI
 35 | 
 36 | 	movep	#2<<13|1<<8,x:m_cra		;16-bit word, 2 time slots
 37 | 	movep	#0<<15|3<<12|1<<11|1<<9,x:m_crb	;sync,network,enable
 38 | 
 39 | 	movep	#0,x:m_pcddr			;port C is SSI/SCI
 40 | 	movep	#$1FF,x:m_pcc			;port C is SSI/SCI
 41 | 
 42 | ; enable interrupts and spin
 43 | 
 44 | 	jsr	<init				;initialize
 45 | 	movec	#0,sr				;lower IPL
 46 | 	jmp	<*
 47 | 
 48 | init	jmp	<init_sine
 49 | 
 50 | ssi_int	jsr	<sine_int
 51 | 	rti
 52 | 
 53 | ; square wave
 54 | 
 55 | square
 56 | 	move	#>-.1,a
 57 | 
 58 | sq1
 59 | 	do	#200,sq0
 60 | 	jclr	#6,x:m_sr,*			;wait for transmitter ready
 61 | 	movep	a,x:m_tx
 62 | 	jclr	#6,x:m_sr,*			;wait for transmitter ready
 63 | 	movep	a,x:m_tx
 64 | sq0     
 65 | 	neg	a
 66 | 	jmp	<sq1
 67 | 
 68 | 
 69 | ; triangle wave
 70 | 
 71 | triangle
 72 | 	move	#>.010,x0
 73 | 	move	#>-.9,a
 74 | 
 75 | l0      
 76 | 	do	#90*2,l1
 77 | 	add	x0,a
 78 | 	jclr	#6,x:m_sr,*			;wait for transmitter ready
 79 | 	movep	a,x:m_tx
 80 | 	jclr	#6,x:m_sr,*			;wait for transmitter ready
 81 | 	movep	a,x:m_tx
 82 | l1
 83 | 	move	x0,b
 84 | 	neg	b
 85 | 	move	b,x0
 86 | 	jmp	<l0
 87 | 
 88 | 
 89 | ; sine wave
 90 | 
 91 | init_sine
 92 | 	move	#>.050,x0			;oscillator freq
 93 | 	move	#>-.209,a			;initial conditions
 94 | 	move	#>.2090,b			;
 95 | 	rts
 96 | 
 97 | sine_int
 98 | 	mac	x0,y0,a
 99 | 	move	a,y0
100 | 	jclr	#6,x:m_sr,*			;wait for transmitter ready
101 | 	movep	a,x:m_tx		
102 | 	mac	-x0,y0,b
103 | 	move	b,y0
104 | 	jclr	#6,x:m_sr,*			;wait for transmitter ready
105 | 	movep	b,x:m_tx		
106 | 	rts
107 | 
108 | 	end
109 | 


--------------------------------------------------------------------------------
/examples/thru.a56:
--------------------------------------------------------------------------------
 1 | ; basic interrupt routine - pass through ins to outs
 2 | ;
 3 | ; written by Quinn Jensen
 4 | 
 5 | include "tdsg.a56"
 6 | 
 7 | ;***************************************************************
 8 | ;
 9 | ;	sample rate computations
10 | ;
11 | ;***************************************************************
12 | 
13 | ;
14 | ; non-interrupt code
15 | ;
16 | 
17 | hf_init
18 | 	rts
19 | 
20 | eff1_on
21 | eff1_off
22 | eff2_on
23 | eff2_off
24 | eff3_on
25 | eff3_off
26 | eff4_on
27 | eff4_off
28 | 	rts
29 | 
30 | ;
31 | ; fs = 32.552083 kHz
32 | ;
33 | 
34 | hf_comp
35 | 	jsr	<saveregs
36 | 
37 | 	move		x:<in_l,a
38 | 	move		a,x:<out_l
39 | 	move		x:<in_r,a
40 | 	move		a,x:<out_r
41 | bypass
42 | 	jsr	<restregs
43 | 	rts
44 | 
45 | 	end
46 | 


--------------------------------------------------------------------------------
/frac2int.c:
--------------------------------------------------------------------------------
  1 | #if 0
  2 | +----------------------------------------------------------------------+
  3 | |   Question: My filter design package gives me decimal fractional     |
  4 | |             numbers  as output  for my  FIR filter coefficients.     |
  5 | |             How  do I convert  these decimal fractions  into the     |
  6 | |             DSP56200's format?                                       |
  7 | +----------------------------------------------------------------------+
  8 | 
  9 |       Answer:
 10 |            It's fairly easy to convert decimal fractions into  the
 11 |       data  format required by the DSP56200.  The DSP56200 coeffi-
 12 |       cients are represented as  24-bit  signed,  fractional,  2's
 13 |       complement numbers as shown in Table 1.
 14 | 
 15 |          TABLE 1 - Representations for FIR Filter Coefficients
 16 |          -----------------------------------------------------
 17 | 
 18 |           Decimal                                  Hexadecimal
 19 |           Fraction       24-Bit Binary Value       Coefficient
 20 |           --------       -------------------       ----------
 21 | 
 22 |             0.75     0.1100000 00000000 00000000    60 00 00
 23 |             0.5      0.1000000 00000000 00000000    40 00 00
 24 |             0.25     0.0100000 00000000 00000000    20 00 00
 25 |             0.125    0.0010000 00000000 00000000    10 00 00
 26 |            -0.125    1.1110000 00000000 00000000    F0 00 00
 27 |            -0.75     1.0100000 00000000 00000000    A0 00 00
 28 | 
 29 |       Each  24-bit  coefficient  is  separated  into  three  bytes
 30 |       corresponding  to the high, middle, and low bytes.  The high
 31 |       byte is written to the DSP56200 at  address  0A  (hex),  the
 32 |       middle byte to address 0B (hex), and the low byte to address
 33 |       0C (hex).
 34 | 
 35 |       Conversion Procedure:
 36 | 
 37 |          Step 1:  Multiply the decimal fraction by 8388608.0 (decimal).
 38 |                   Note that 8388608 = 2 raised to the 23rd power.
 39 |          Step 2:  Truncate or round the result into an integer.
 40 |          Step 3:  Logically AND this integer with 00FFFFFF (hex).
 41 |          Step 4:  Write the result to an output file as a hex integer.
 42 | 
 43 |       It is easy to write a program to perform this conversion  on
 44 |       a  set  of  coefficients.  If done by computer program, make
 45 |       sure that all integer  variables  are  represented  with  at
 46 |       least  24-bits.   An  example  of  a  short  "C"  program is
 47 |       included at the end of this answer.
 48 | 
 49 |       Things to watch for:
 50 | 
 51 |          (1) Avoid letting a coefficient value be exactly 800000
 52 |              (-1.0 in a fractional system).  If this coefficient
 53 |              is multiplied by a data sample with value -1.0, the
 54 |              result is -1.0 instead of +1.0 as expected. This is
 55 |              because +1.0 cannot be represented in a signed, 2's
 56 |              complement, fractional system.
 57 | 
 58 |          (2) The filter coefficients must  be carefully selected
 59 |              to prevent overflow.   If there is a possibility of
 60 |              overflow with a set of filter coefficients, then all
 61 |              coefficients must be scaled by a constant value. The
 62 |              DSP56200's 24-bit coefficients  allow plenty of room
 63 |              for scaling.   If 12-bit input data samples are used
 64 |              in a system,  the potential  for overflow is greatly
 65 |              reduced if the samples are right justified and sign-
 66 |              extended four bits before they are sent to the 
 67 |              DSP56200.
 68 | 
 69 | "C" Program:
 70 | #endif
 71 |            /****************************************\
 72 |            **  DECIMAL FRACTION TO HEX CONVERSION  **
 73 |            \****************************************/
 74 | 
 75 | /******************************************************************\
 76 | *  This program converts one decimal, fractional number to a hex   *
 77 | *  number which can be written to the DSP56200's Coefficient RAM   *
 78 | *  Access registers.  It prompts the user for a decimal fraction   *
 79 | *  and returns the corresponding hex number.                       *
 80 | *                                                                  *
 81 | *   Examples of Program Results (useful for checking programs)     *
 82 | *        Inputs                    Outputs                         *
 83 | *        ------                    -------                         *
 84 | *         0.750                =>  600000                          *
 85 | *         0.500                =>  400000                          *
 86 | *         0.250                =>  200000                          *
 87 | *         0.125                =>  100000                          *
 88 | *        -0.125                =>  f00000                          *
 89 | *        -0.750                =>  a00000                          *
 90 | *         0.00784313678741455  =>  010101                          *
 91 | *        -0.00784313678741455  =>  fefeff                          *
 92 | *                                                                  *
 93 | *   Note: The program assumes that the variable type "long" is an  *
 94 | *         integer which is at least 24-bits wide.                  *
 95 | *                                                                  *
 96 | *   Also: The DSP56200 cannot  use any coefficient value with a    *
 97 | *         magnitude of 1.0 or larger.  All coefficients must be    *
 98 | *         signed, fractional quantities.                           *
 99 | \******************************************************************/
100 | 
101 | main()
102 | {
103 |            double fractnum;              /* double precision floating pt */
104 |            long   hexval;                /* long integer */
105 | 
106 |     for(;;) {
107 |         /* Read 1 Decimal Floating Point Number from the Keyboard */
108 |            printf("Enter the decimal fraction: ");
109 |            scanf("%lf", &fractnum);
110 | 
111 |         /* Convert to a Hex Integer which can be used by the DSP56200 */
112 |            hexval =  (long) (8388608.0 * fractnum);
113 |            hexval =  0x00ffffffL & hexval;
114 | 
115 |         /* Write the Hex number out to the Terminal */
116 |            printf("DSP56200 Coefficient = %06lx\n", hexval);
117 |     }
118 | }
119 | 


--------------------------------------------------------------------------------
/getopt.c:
--------------------------------------------------------------------------------
  1 | /*
  2 | 	I got this off net.sources from Henry Spencer.
  3 | 	It is a public domain getopt(3) like in System V.
  4 | 	I have made the following modifications:
  5 | 
  6 | 	index(s,c) was added because too many people could
  7 | 	not compile getopt without it.
  8 | 
  9 | 	A test main program was added, ifdeffed by GETOPT.
 10 | 	This main program is a public domain implementation
 11 | 	of the getopt(1) program like in System V.  The getopt
 12 | 	program can be used to standardize shell option handling.
 13 | 		e.g.  cc -DGETOPT getopt.c -o getopt
 14 | */
 15 | #include <stdio.h>
 16 | 
 17 | #ifndef lint
 18 | static	char	sccsfid[] = "@(#) getopt.c 5.0 (UTZoo) 1985";
 19 | #endif
 20 | 
 21 | #define	ARGCH    (int)':'
 22 | #define BADCH	 (int)'?'
 23 | #define EMSG	 ""
 24 | #define	ENDARGS  "--"
 25 | 
 26 | /* this is included because index is not on some UNIX systems */
 27 | char *
 28 | index (s, c)
 29 | register	char	*s;
 30 | register	int 	c;
 31 | 	{
 32 | 	while (*s)
 33 | 		if (c == *s) return (s);
 34 | 		else s++;
 35 | 	return (NULL);
 36 | 	}
 37 | 
 38 | /*
 39 |  * get option letter from argument vector
 40 |  */
 41 | int	opterr = 1,		/* useless, never set or used */
 42 | 	optind = 1,		/* index into parent argv vector */
 43 | 	optopt;			/* character checked for validity */
 44 | char	*optarg;		/* argument associated with option */
 45 | 
 46 | #define tell(s)	fputs(*nargv,stderr);fputs(s,stderr); \
 47 | 		fputc(optopt,stderr);fputc('\n',stderr);return(BADCH);
 48 | 
 49 | 
 50 | getopt(nargc,nargv,ostr)
 51 | int	nargc;
 52 | char	**nargv,
 53 | 	*ostr;
 54 | {
 55 | 	static char	*place = EMSG;	/* option letter processing */
 56 | 	register char	*oli;		/* option letter list index */
 57 | 	char	*index();
 58 | 
 59 | 	if(!*place) {			/* update scanning pointer */
 60 | 		if(optind >= nargc || *(place = nargv[optind]) != '-' || !*++place) return(EOF);
 61 | 		if (*place == '-') {	/* found "--" */
 62 | 			++optind;
 63 | 			return(EOF);
 64 | 		}
 65 | 	}				/* option letter okay? */
 66 | 	if ((optopt = (int)*place++) == ARGCH || !(oli = index(ostr,optopt))) {
 67 | 		if(!*place) ++optind;
 68 | 		tell(": illegal option -- ");
 69 | 	}
 70 | 	if (*++oli != ARGCH) {		/* don't need argument */
 71 | 		optarg = NULL;
 72 | 		if (!*place) ++optind;
 73 | 	}
 74 | 	else {				/* need an argument */
 75 | 		if (*place) optarg = place;	/* no white space */
 76 | 		else if (nargc <= ++optind) {	/* no arg */
 77 | 			place = EMSG;
 78 | 			tell(": option requires an argument -- ");
 79 | 		}
 80 | 	 	else optarg = nargv[optind];	/* white space */
 81 | 		place = EMSG;
 82 | 		++optind;
 83 | 	}
 84 | 	return(optopt);			/* dump back option letter */
 85 | }
 86 | 
 87 | 
 88 | #ifdef GETOPT
 89 | 
 90 | #ifndef lint
 91 | static	char	sccspid[] = "@(#) getopt.c 5.1 (WangInst) 6/15/85";
 92 | #endif
 93 | 
 94 | main (argc, argv) char **argv;
 95 | 	{
 96 | 	char	*optstring = argv[1];
 97 | 	char	*argv0 = argv[0];
 98 | 	extern	int 	optind;
 99 | 	extern	char	*optarg;
100 | 	int 	opterr = 0;
101 | 	int 	C;
102 | 	char	*opi;
103 | 	if (argc == 1)
104 | 		{
105 | 		fprintf (stderr, "Usage: %s optstring args\n", argv0);
106 | 		exit (1);
107 | 		}
108 | 	argv++;
109 | 	argc--;
110 | 	argv[0] = argv0;
111 | 	while ((C = getopt (argc, argv, optstring)) != EOF)
112 | 		{
113 | 		if (C == BADCH) opterr++;
114 | 		printf ("-%c ", C);
115 | 		opi = index (optstring, C);
116 | 		if (opi && opi[1] == ARGCH)
117 | 			if (optarg)
118 | 				printf ("\"%s\" ", optarg);
119 | 			else opterr++;
120 | 		}
121 | 	printf ("%s", ENDARGS);
122 | 	while (optind < argc)
123 | 		printf (" \"%s\"", argv[optind++]);
124 | 	putchar ('\n');
125 | 	exit (opterr);
126 | 	}
127 | 
128 | #endif
129 | 


--------------------------------------------------------------------------------
/keybld.c:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright (C) 1990-1994 Quinn C. Jensen
  3 |  *
  4 |  * Permission to use, copy, modify, distribute, and sell this software
  5 |  * and its documentation for any purpose is hereby granted without fee,
  6 |  * provided that the above copyright notice appear in all copies and
  7 |  * that both that copyright notice and this permission notice appear
  8 |  * in supporting documentation.  The author makes no representations
  9 |  * about the suitability of this software for any purpose.  It is
 10 |  * provided "as is" without express or implied warranty.
 11 |  *
 12 |  */
 13 | static char *Copyright = "Copyright (C) 1990-1994 Quinn C. Jensen";
 14 | 
 15 | /*
 16 |  * keybld - builds a finite-state parser for the given keyword list
 17 |  *
 18 |  */
 19 | 
 20 | #include <stdio.h>
 21 | #include "a56.h"
 22 | 
 23 | char buf[1024];
 24 | 
 25 | main()
 26 | {
 27 | 	int line = 0;
 28 | 
 29 | 	while(fgets(buf, sizeof(buf), stdin)) {
 30 | 		char *bp = buf;
 31 | 		line++;
 32 | 		while(*bp != '\t' && *bp != ' ') bp++;
 33 | 		*bp++ = '\0';
 34 | 		while(*bp == '\t' || *bp == ' ') bp++;
 35 | 		if(strcmp(buf, ".code") == 0) {
 36 | 			printf("%s\n", bp);
 37 | 		} else if(add_tok(buf, bp) == -1) {
 38 | 			fprintf(stderr, "input line %d: ambiguous\n", line);
 39 | 		}
 40 | 	}
 41 | 
 42 | 	dump_machine();
 43 | 	return 0;
 44 | }
 45 | 
 46 | #define MAX_CHAR 'z'
 47 | 
 48 | #define TRANSITIONS (MAX_CHAR + 1)
 49 | 
 50 | struct state {
 51 | 	int number;
 52 | 	char *seen;
 53 | 	struct trans {
 54 | 		char action;
 55 | 		void *arg;
 56 | 	} trans[TRANSITIONS];
 57 | 	struct state *next;
 58 | } empty_state, *stop = NULL, *scur = NULL, *new_state();
 59 | int n_states = 0;
 60 | 
 61 | /* actions */
 62 | #define NOMATCH 0	/* argument is nothing */
 63 | #define GOTO 1		/* argument is target state */
 64 | #define TERMINAL 2	/* argument is which user action to perform */
 65 | 
 66 | struct user_action {
 67 | 	char *action;
 68 | 	struct user_action *next;
 69 | } *utop = NULL, *ucur = NULL;
 70 | int n_user_actions = 0;
 71 | 
 72 | add_tok(tok, actions)
 73 | char *tok, *actions;
 74 | {
 75 | 	struct state *scur;
 76 | 	struct user_action *unew = (struct user_action *)alloc(sizeof *unew);
 77 | 	unew->action = strsave(actions);
 78 | 	unew->next = NULL;
 79 | 	if(ucur)
 80 | 		ucur->next = unew;
 81 | 	ucur = unew;
 82 | 	if(utop == NULL)
 83 | 		utop = unew;
 84 | 
 85 | 	if(stop == NULL)
 86 | 		new_state(NULL);
 87 | 
 88 | 	if(follow(*tok, tok + 1, stop) == -1)
 89 | 		return -1;
 90 | 
 91 | 	n_user_actions++;
 92 | 	return 0;
 93 | }
 94 | 
 95 | follow(c, tp, sp)
 96 | char c;
 97 | char *tp;
 98 | struct state *sp;
 99 | {
100 | 	struct trans *arcp, *arcup;
101 | 	
102 | 	if(c >= 'a' && c <= 'z') {
103 | 		c -= 'a' - 'A';
104 | 	}
105 | 	arcp = sp->trans + c;
106 | 
107 | 	if(c >= 'A' && c <= 'Z') {
108 | 		arcup = sp->trans + c + 'a' - 'A';
109 | 	} else {
110 | 		arcup = arcp;
111 | 	}
112 | 
113 | 	if(c == '\0') {
114 | 		if(arcp->action == TERMINAL) {
115 | 			return -1;
116 | 		} else {
117 | 			arcp->action = arcup->action = TERMINAL;
118 | 			arcp->arg = arcup->arg = (void *)n_user_actions;
119 | 			return 0;
120 | 		}
121 | 	} else {
122 | 		if(arcp->action == GOTO) {
123 | 			return follow(*tp, tp + 1, arcp->arg);
124 | 		} else {
125 | 			struct state *new = new_state(tp);
126 | 			arcp->action = arcup->action = GOTO;
127 | 			arcp->arg = arcup->arg = (void *)new;
128 | 			return follow(*tp, tp + 1, new);
129 | 		}
130 | 	}
131 | }
132 | 
133 | struct state *new_state(tp)
134 | char *tp;
135 | {
136 | 	struct state *snew = (struct state *)alloc(sizeof *snew);
137 | 	char tmp[1024];
138 | 
139 | 	*snew = empty_state;
140 | 
141 | 	snew->number = n_states++;
142 | 
143 | 	snew->next = NULL;
144 | 
145 | 	if(scur)
146 | 		scur->next = snew;
147 | 	scur = snew;
148 | 
149 | 	if(stop == NULL)
150 | 		stop = snew;
151 | 
152 | 	if(tp) {
153 | 		strncpy(tmp, buf, tp - buf);
154 | 		tmp[tp - buf] = '\0';
155 | 	} else
156 | 		strcpy(tmp, "<nothing>");
157 | 
158 | 	snew->seen = strsave(tmp);
159 | 
160 | 	return snew;
161 | }
162 | 
163 | dump_machine()
164 | {
165 | 	struct state *sp;
166 | 	struct user_action *up;
167 | 	int n, a;
168 | 
169 | 	printf("/* state machine generated by keybld */\n");
170 | 	printf("/* states=%d actions=%d */\n", n_states, n_user_actions);
171 | 	printf("/* %d bytes required for transition table storage */\n",
172 | 		sizeof(short) * TRANSITIONS * n_states);
173 | 
174 | 	printf("short transitions[%d][%d] = {\n", n_states, TRANSITIONS);
175 | 	for(n = 0, sp = stop; sp; sp = sp->next, n++) {
176 | 		printf("	/* state %d: \"%s\" */\n", n, sp->seen);
177 | 		printf("	{");
178 | 		for(a = 0; a < TRANSITIONS; a++) {
179 | 			struct trans *tp = sp->trans + a;
180 | 			switch(tp->action) {
181 | 			case GOTO:
182 | 				printf("%d", ((struct state *)tp->arg)->number);
183 | 				break;
184 | 			case TERMINAL:
185 | 				printf("%d", -(int)tp->arg - 1);
186 | 				break;
187 | 			case NOMATCH:
188 | 				printf("0");
189 | 				break;
190 | 			}
191 | 			printf(",%s", a % 20 == 19 ? "\n\t\t" : "");
192 | 		};
193 | 		printf("},\n");
194 | 	}
195 | 
196 | 	printf("};\n");
197 | 
198 | 	printf("\
199 | \n\
200 | kparse(kp)\n\
201 | char *kp;\n\
202 | {\n\
203 | 	int state = 0;\n\
204 | \n\
205 | 	for(;;) {\n\
206 | 		short transition = transitions[state][*kp];\n");
207 | 
208 | printf("\
209 | 		if(transition == 0) {\n\
210 | 			return 0;\n\
211 | 		} else if(transition > 0) {\n\
212 | 			kp++;\n\
213 | 			state = transition;\n\
214 | 		} else {\n\
215 | 			switch(-transition) {\n");
216 | 
217 | 	for(n = 1, up = utop; up; up = up->next, n++) {
218 | 		printf("\
219 | 			case %d:\n\
220 | 				%s;\n\
221 | 				break;\n", n, up->action);
222 | 	}
223 | 
224 | 	printf("\
225 | 			}\n\
226 | 			return transition;\n\
227 | 		}\n\
228 | 	}\n\
229 | }\n");
230 | 
231 | }
232 | 


--------------------------------------------------------------------------------
/lex.c:
--------------------------------------------------------------------------------
  1 | /*******************************************************
  2 |  *
  3 |  *  a56 - a DSP56001 assembler
  4 |  *
  5 |  *  Written by Quinn C. Jensen
  6 |  *  July 1990
  7 |  *
  8 |  *******************************************************\
  9 | 
 10 | /*
 11 |  *  lex.c - lexical analyzer envelope.  lexyy.c, included below,
 12 |  *  is the LEX-generated code.
 13 |  *
 14 |  */
 15 | 
 16 | #include "a56.h"
 17 | #include "gram.h"
 18 | 
 19 | int ldebug = 0;
 20 | #ifdef LDEBUG
 21 | #define RET(val) \
 22 | 	{\
 23 | 		if(ldebug) {\
 24 | 			printf("[%s]", tok_print(val));\
 25 | 			fflush(stdout);\
 26 | 		}\
 27 | 		return val;\
 28 | 	}
 29 | #else
 30 | #define RET(val) {return val;}
 31 | #endif
 32 | 
 33 | extern YYSTYPE yyval;
 34 | 
 35 | double atof();
 36 | 
 37 | /**************** yylex - returns next token *****************************/
 38 | 
 39 | #define MAX_TOK 1024
 40 | char tok[MAX_TOK];
 41 | 
 42 | yylex()
 43 | {
 44 | 	int ltok = next_tok();
 45 | 	int itok;
 46 | 
 47 | 	switch(ltok) {
 48 | 	case EOF:
 49 | 		if(yywrap() == 1)
 50 | 			return 0;
 51 | 		else
 52 | 			return yylex();
 53 | 		break;
 54 | 	case SYM:
 55 | 		if(itok = is_keyword(tok)) {
 56 | 			RET(itok);
 57 | 		} else {
 58 | 			yylval.sval = strsave(tok);
 59 | 			RET(SYM);
 60 | 		}
 61 | 		break;
 62 | 	case CHEX:
 63 | 		yylval.n.type = INT;
 64 | 		yylval.n.seg = ANY;
 65 | 		yylval.n.val.i = strtol(tok, 0, 16);
 66 | 		RET(CHEX);
 67 | 		break;
 68 | 	case CDEC:
 69 | 		yylval.n.type= INT;
 70 | 		yylval.n.seg = ANY;
 71 | 		yylval.n.val.i = atoi(tok);
 72 | 		RET(CDEC);
 73 | 		break;
 74 | 	case FRAC:
 75 | 		yylval.n.type = FLT;
 76 | 		yylval.n.seg = ANY;
 77 | 		yylval.n.val.f = atof(tok);
 78 | 		RET(FRAC);
 79 | 	case CHAR:
 80 | 		yylval.cval = *tok;
 81 | 		RET(CHAR);
 82 | 	case STRING:
 83 | 		yylval.sval = (char *)fixstring(tok);
 84 | 		yylval.sval = strsave(yylval.sval);
 85 | 		RET(STRING);
 86 | 	default:
 87 | 		RET(ltok);
 88 | 	}
 89 | }
 90 | 
 91 | is_keyword(tok)
 92 | char *tok;
 93 | {
 94 | 	int kval = kparse(tok);
 95 | 	if(kval > 0)
 96 | 		return kval;
 97 | 
 98 | 	return 0;
 99 | }
100 | 
101 | struct ascii_tab {
102 | 	char *str;
103 | 	int flags;
104 | } ascii_tab[];
105 | #define IS_NONE		0x0000
106 | #define IS_NUM		0x0001
107 | #define IS_ALPHA	0x0002
108 | #define IS_HEX		0x0004
109 | #define IS_WHITE	0x0008
110 | 
111 | extern FILE *yyin;
112 | 
113 | int next_tok()
114 | {
115 | 	char *tp = tok;
116 | 	enum {S_TOP, S_HEXNUM, S_NUM, S_ALNUM, S_CHAR, S_ESC_CHAR, S_COMMENT,
117 | 		S_SQ_STRING, S_DQ_STRING, S_SHL, S_SHR} state = S_TOP;
118 | 	static int unget = 0;
119 | 	BOOL dot_seen = FALSE;
120 | 
121 | 	for(;;) {
122 | 		int c = unget ? unget : lgetc(yyin);
123 | 		int flags;
124 | 		unget = 0;
125 | 		flags = ascii_tab[c & 0x7F].flags;
126 | 		if(tp > tok + MAX_TOK - 2) return LEXBAD;
127 | 		switch(state) {
128 | 		case S_TOP:
129 | 			if(c == EOF) {
130 | 				return EOF;
131 | 			} else if(flags & IS_WHITE) {
132 | 				/* ignore */ ;
133 | 			} else if(flags & IS_ALPHA) {
134 | 				*tp++ = c;
135 | 				state = S_ALNUM;
136 | 			} else if((flags & IS_NUM) || c == '.') {
137 | 				unget = c;
138 | 				state = S_NUM;
139 | 			} else {
140 | 				switch(c) {
141 | 				case '$': state = S_HEXNUM; break;
142 | 				case '"': state = S_DQ_STRING; break;
143 | 				case '\'': state = S_CHAR; break;
144 | 				case '>': state = S_SHR; break;
145 | 				case '<': state = S_SHL; break;
146 | 				case ';': state = S_COMMENT; break;
147 | 				case '\n': return EOL;
148 | 				case '@': return EOS;
149 | 				default: return c;
150 | 				}
151 | 			}
152 | 			break;
153 | 		case S_COMMENT:
154 | 			if(c == EOF) {
155 | 				unget = EOF;
156 | 				*tp = '\0';
157 | 				return EOL;
158 | 			} else if(c == '\n') {
159 | 				return EOL;
160 | 			}
161 | 			break;
162 | 		case S_SHR:
163 | 			if(c == EOF) {
164 | 				unget = EOF;
165 | 				*tp = '\0';
166 | 				return '>';
167 | 			} else if(c == '>') {
168 | 				return SHR;
169 | 			} else {
170 | 				unget = c;
171 | 				return '>';
172 | 			}
173 | 			break;
174 | 		case S_SHL:
175 | 			if(c == EOF) {
176 | 				unget = EOF;
177 | 				*tp = '\0';
178 | 				return '<';
179 | 			} else if(c == '<') {
180 | 				return SHL;
181 | 			} else {
182 | 				unget = c;
183 | 				return '<';
184 | 			}
185 | 			break;
186 | 		case S_HEXNUM:
187 | 			if(c == EOF) {
188 | 				unget = EOF;
189 | 				*tp = '\0';
190 | 				return CHEX;
191 | 			} else if(flags & IS_HEX) {
192 | 				*tp++ = c;
193 | 				break;
194 | 			} else {
195 | 				unget = c;
196 | 				*tp = '\0';
197 | 				return CHEX;
198 | 			}
199 | 			break;
200 | 		case S_ALNUM:
201 | 			if(c == EOF) {
202 | 				unget = EOF;
203 | 				*tp = '\0';
204 | 				return SYM;
205 | 			} else if(c == ':') {
206 | 				*tp++ = c;
207 | 				*tp = '\0';
208 | 				return SYM;
209 | 				break;
210 | 			} else if(flags & (IS_ALPHA|IS_NUM)) {
211 | 				*tp++ = c;
212 | 				break;
213 | 			} else {
214 | 				unget = c;
215 | 				*tp = '\0';
216 | 				return SYM;
217 | 			}
218 | 			break;
219 | 		case S_NUM:
220 | 			if(c == EOF) {
221 | 				unget = EOF;
222 | 				*tp = '\0';
223 | 				return dot_seen ? FRAC : CDEC;
224 | 			} else if((flags & IS_NUM) || (c == '.' && NOT dot_seen)) {
225 | 				*tp++ = c;
226 | 				if(c == '.') dot_seen = TRUE;
227 | 				break;
228 | 			} else {
229 | 				unget = c;
230 | 				*tp = '\0';
231 | 				return dot_seen ? FRAC : CDEC;
232 | 			}
233 | 			break;
234 | 		case S_CHAR:
235 | 			if(c == EOF) {
236 | 				unget = EOF;
237 | 				*tp = '\0';
238 | 				return CHAR;
239 | 			} else if(c == '\\') {
240 | 				state = S_ESC_CHAR;
241 | 			} else if(c == '\'') {
242 | 				*tp = '\0';
243 | 				return CHAR;
244 | 			} else {
245 | 				*tp++ = c;
246 | 				if(tp > tok + 1)
247 | 					state = S_SQ_STRING;
248 | 			}
249 | 			break;
250 | 		case S_ESC_CHAR:
251 | 			if(c == EOF) {
252 | 				unget = EOF;
253 | 				*tp = '\0';
254 | 				return CHAR;
255 | 			}
256 | 			switch(c) {
257 | 			case 'b': *tp = '\b'; break;
258 | 			case 'f': *tp = '\f'; break;
259 | 			case 'n': *tp = '\n'; break;
260 | 			case 'r': *tp = '\r'; break;
261 | 			case 't': *tp = '\t'; break;
262 | 			case '\\': *tp = '\\'; break;
263 | 			case '\'':
264 | 				*tp = '\0';
265 | 				return CHAR;
266 | 				break;
267 | 			default:
268 | 				*tp++ = c;
269 | 				state = S_SQ_STRING;
270 | 				break;
271 | 			}
272 | 			break;
273 | 		case S_SQ_STRING:
274 | 			if(c == EOF) {
275 | 				unget = EOF;
276 | 				*tp = '\0';
277 | 				return STRING;
278 | 			} else if(c == '\'') {
279 | 				*tp = '\0';
280 | 				return STRING;
281 | 			} else {
282 | 				*tp++ = c;
283 | 			}
284 | 			break;
285 | 		case S_DQ_STRING:
286 | 			if(c == EOF) {
287 | 				unget = EOF;
288 | 				*tp = '\0';
289 | 				return STRING;
290 | 			} else if(c == '"') {
291 | 				*tp = '\0';
292 | 				return STRING;
293 | 			} else {
294 | 				*tp++ = c;
295 | 			}
296 | 			break;
297 | 		} /* switch(state) */
298 | 	} /* for(;;) */
299 | }
300 | 
301 | struct ascii_tab ascii_tab[] = {
302 | 	{"\\z00",	IS_NONE					/* 0x00 */},
303 | 	{"\\z01",	IS_NONE					/* 0x01 */},
304 | 	{"\\z02",	IS_NONE					/* 0x02 */},
305 | 	{"\\z03",	IS_NONE					/* 0x03 */},
306 | 	{"\\z04",	IS_NONE					/* 0x04 */},
307 | 	{"\\z05",	IS_NONE					/* 0x05 */},
308 | 	{"\\z06",	IS_NONE					/* 0x06 */},
309 | 	{"\\z07",	IS_NONE					/* 0x07 */},
310 | 	{"\\b",		IS_NONE					/* 0x08 */},
311 | 	{"\\t",		IS_NONE|IS_WHITE		/* 0x09 */},
312 | 	{"\\n",		IS_NONE					/* 0x0A */},
313 | 	{"\\z0B",	IS_NONE					/* 0x0B */},
314 | 	{"\\z0C",	IS_NONE					/* 0x0C */},
315 | 	{"\\r",		IS_NONE					/* 0x0D */},
316 | 	{"\\z0E",	IS_NONE					/* 0x0E */},
317 | 	{"\\z0F",	IS_NONE					/* 0x0F */},
318 | 	{"\\z10",	IS_NONE					/* 0x10 */},
319 | 	{"\\z11",	IS_NONE					/* 0x11 */},
320 | 	{"\\z12",	IS_NONE					/* 0x12 */},
321 | 	{"\\z13",	IS_NONE					/* 0x13 */},
322 | 	{"\\z14",	IS_NONE					/* 0x14 */},
323 | 	{"\\z15",	IS_NONE					/* 0x15 */},
324 | 	{"\\z16",	IS_NONE					/* 0x16 */},
325 | 	{"\\z17",	IS_NONE					/* 0x17 */},
326 | 	{"\\z18",	IS_NONE					/* 0x18 */},
327 | 	{"\\z19",	IS_NONE					/* 0x19 */},
328 | 	{"\\z1A",	IS_NONE					/* 0x1A */},
329 | 	{"\\z1B",	IS_NONE					/* 0x1B */},
330 | 	{"\\z1C",	IS_NONE					/* 0x1C */},
331 | 	{"\\z1D",	IS_NONE					/* 0x1D */},
332 | 	{"\\z1E",	IS_NONE					/* 0x1E */},
333 | 	{"\\z1F",	IS_NONE					/* 0x1F */},
334 | 	{" ",		IS_NONE|IS_WHITE		/* 0x20 */},
335 | 	{"!",		IS_NONE					/* 0x21 */},
336 | 	{"\"",		IS_NONE					/* 0x22 */},
337 | 	{"#",		IS_NONE					/* 0x23 */},
338 | 	{"$",		IS_NONE					/* 0x24 */},
339 | 	{"%",		IS_NONE					/* 0x25 */},
340 | 	{"&",		IS_NONE					/* 0x26 */},
341 | 	{"'",		IS_NONE					/* 0x27 */},
342 | 	{"(",		IS_NONE					/* 0x28 */},
343 | 	{")",		IS_NONE					/* 0x29 */},
344 | 	{"*",		IS_NONE					/* 0x2A */},
345 | 	{"+",		IS_NONE					/* 0x2B */},
346 | 	{",",		IS_NONE					/* 0x2C */},
347 | 	{"-",		IS_NONE					/* 0x2D */},
348 | 	{".",		IS_NONE					/* 0x2E */},
349 | 	{"/",		IS_NONE					/* 0x2F */},
350 | 	{"0",		IS_NONE|IS_NUM|IS_HEX	/* 0x30 */},
351 | 	{"1",		IS_NONE|IS_NUM|IS_HEX	/* 0x31 */},
352 | 	{"2",		IS_NONE|IS_NUM|IS_HEX	/* 0x32 */},
353 | 	{"3",		IS_NONE|IS_NUM|IS_HEX	/* 0x33 */},
354 | 	{"4",		IS_NONE|IS_NUM|IS_HEX	/* 0x34 */},
355 | 	{"5",		IS_NONE|IS_NUM|IS_HEX	/* 0x35 */},
356 | 	{"6",		IS_NONE|IS_NUM|IS_HEX	/* 0x36 */},
357 | 	{"7",		IS_NONE|IS_NUM|IS_HEX	/* 0x37 */},
358 | 	{"8",		IS_NONE|IS_NUM|IS_HEX	/* 0x38 */},
359 | 	{"9",		IS_NONE|IS_NUM|IS_HEX	/* 0x39 */},
360 | 	{":",		IS_NONE					/* 0x3A */},
361 | 	{";",		IS_NONE					/* 0x3B */},
362 | 	{"<",		IS_NONE					/* 0x3C */},
363 | 	{"=",		IS_NONE					/* 0x3D */},
364 | 	{">",		IS_NONE					/* 0x3E */},
365 | 	{"?",		IS_NONE					/* 0x3F */},
366 | 	{"@",		IS_NONE					/* 0x40 */},
367 | 	{"A",		IS_NONE|IS_ALPHA|IS_HEX	/* 0x41 */},
368 | 	{"B",		IS_NONE|IS_ALPHA|IS_HEX	/* 0x42 */},
369 | 	{"C",		IS_NONE|IS_ALPHA|IS_HEX	/* 0x43 */},
370 | 	{"D",		IS_NONE|IS_ALPHA|IS_HEX	/* 0x44 */},
371 | 	{"E",		IS_NONE|IS_ALPHA|IS_HEX	/* 0x45 */},
372 | 	{"F",		IS_NONE|IS_ALPHA|IS_HEX	/* 0x46 */},
373 | 	{"G",		IS_NONE|IS_ALPHA		/* 0x47 */},
374 | 	{"H",		IS_NONE|IS_ALPHA		/* 0x48 */},
375 | 	{"I",		IS_NONE|IS_ALPHA		/* 0x49 */},
376 | 	{"J",		IS_NONE|IS_ALPHA		/* 0x4A */},
377 | 	{"K",		IS_NONE|IS_ALPHA		/* 0x4B */},
378 | 	{"L",		IS_NONE|IS_ALPHA		/* 0x4C */},
379 | 	{"M",		IS_NONE|IS_ALPHA		/* 0x4D */},
380 | 	{"N",		IS_NONE|IS_ALPHA		/* 0x4E */},
381 | 	{"O",		IS_NONE|IS_ALPHA		/* 0x4F */},
382 | 	{"P",		IS_NONE|IS_ALPHA		/* 0x50 */},
383 | 	{"Q",		IS_NONE|IS_ALPHA		/* 0x51 */},
384 | 	{"R",		IS_NONE|IS_ALPHA		/* 0x52 */},
385 | 	{"S",		IS_NONE|IS_ALPHA		/* 0x53 */},
386 | 	{"T",		IS_NONE|IS_ALPHA		/* 0x54 */},
387 | 	{"U",		IS_NONE|IS_ALPHA		/* 0x55 */},
388 | 	{"V",		IS_NONE|IS_ALPHA		/* 0x56 */},
389 | 	{"W",		IS_NONE|IS_ALPHA		/* 0x57 */},
390 | 	{"X",		IS_NONE|IS_ALPHA		/* 0x58 */},
391 | 	{"Y",		IS_NONE|IS_ALPHA		/* 0x59 */},
392 | 	{"Z",		IS_NONE|IS_ALPHA		/* 0x5A */},
393 | 	{"[",		IS_NONE					/* 0x5B */},
394 | 	{"\\",		IS_NONE					/* 0x5C */},
395 | 	{"]",		IS_NONE					/* 0x5D */},
396 | 	{"^",		IS_NONE					/* 0x5E */},
397 | 	{"_",		IS_NONE|IS_ALPHA		/* 0x5F */},
398 | 	{"`",		IS_NONE					/* 0x60 */},
399 | 	{"a",		IS_NONE|IS_ALPHA|IS_HEX	/* 0x61 */},
400 | 	{"b",		IS_NONE|IS_ALPHA|IS_HEX	/* 0x62 */},
401 | 	{"c",		IS_NONE|IS_ALPHA|IS_HEX	/* 0x63 */},
402 | 	{"d",		IS_NONE|IS_ALPHA|IS_HEX	/* 0x64 */},
403 | 	{"e",		IS_NONE|IS_ALPHA|IS_HEX	/* 0x65 */},
404 | 	{"f",		IS_NONE|IS_ALPHA|IS_HEX	/* 0x66 */},
405 | 	{"g",		IS_NONE|IS_ALPHA		/* 0x67 */},
406 | 	{"h",		IS_NONE|IS_ALPHA		/* 0x68 */},
407 | 	{"i",		IS_NONE|IS_ALPHA		/* 0x69 */},
408 | 	{"j",		IS_NONE|IS_ALPHA		/* 0x6A */},
409 | 	{"k",		IS_NONE|IS_ALPHA		/* 0x6B */},
410 | 	{"l",		IS_NONE|IS_ALPHA		/* 0x6C */},
411 | 	{"m",		IS_NONE|IS_ALPHA		/* 0x6D */},
412 | 	{"n",		IS_NONE|IS_ALPHA		/* 0x6E */},
413 | 	{"o",		IS_NONE|IS_ALPHA		/* 0x6F */},
414 | 	{"p",		IS_NONE|IS_ALPHA		/* 0x70 */},
415 | 	{"q",		IS_NONE|IS_ALPHA		/* 0x71 */},
416 | 	{"r",		IS_NONE|IS_ALPHA		/* 0x72 */},
417 | 	{"s",		IS_NONE|IS_ALPHA		/* 0x73 */},
418 | 	{"t",		IS_NONE|IS_ALPHA		/* 0x74 */},
419 | 	{"u",		IS_NONE|IS_ALPHA		/* 0x75 */},
420 | 	{"v",		IS_NONE|IS_ALPHA		/* 0x76 */},
421 | 	{"w",		IS_NONE|IS_ALPHA		/* 0x77 */},
422 | 	{"x",		IS_NONE|IS_ALPHA		/* 0x78 */},
423 | 	{"y",		IS_NONE|IS_ALPHA		/* 0x79 */},
424 | 	{"z",		IS_NONE|IS_ALPHA		/* 0x7A */},
425 | 	{"{",		IS_NONE					/* 0x7B */},
426 | 	{"|",		IS_NONE					/* 0x7C */},
427 | 	{"}",		IS_NONE					/* 0x7D */},
428 | 	{"~",		IS_NONE					/* 0x7E */},
429 | 	{"\\z7F",	IS_NONE					/* 0x7F */},
430 | };
431 | 
432 | 
433 | /**************** lgetc - returns next character *************************/
434 | 
435 | #define INLINE 1024
436 | 
437 | char line_buf[INLINE];
438 | char *cur_line = line_buf;		/* points to current line buffer */
439 | char *clp = NULL;				/* where we're at in cur_line */
440 | 
441 | lgetc(fp)
442 | FILE *fp;
443 | {
444 | 	int c;
445 | 
446 | 	if(clp == NULL) {
447 | 		if(fgets(cur_line, INLINE, fp) == NULL) {
448 | 			c = EOF;
449 | 		} else {
450 | 			clp = cur_line;
451 | 			c = *clp++;
452 | 		}
453 | 	} else {
454 | 		c = *clp++;
455 | 	}
456 | 
457 | 	switch(c) {
458 | 	case EOF:
459 | 		/* at EOF: all done */
460 | 		if(ldebug)
461 | 			printf("<eof>\n");
462 | 		return EOF;
463 | 		break;
464 | 	case '\0':
465 | 		c = '\n';
466 | 	case '\n':
467 | 		clp = NULL;
468 | 		break;
469 | 	default:
470 | 		break;
471 | 	}
472 | 
473 | 	if(ldebug)
474 | 		printf(c < ' ' ? "<\\z%02X>%s" : "<%c>", c, c == '\n' ? "\n" : "");
475 | 
476 | 	return c;
477 | }
478 | 


--------------------------------------------------------------------------------
/main.c:
--------------------------------------------------------------------------------
  1 | /*******************************************************
  2 |  *
  3 |  *  a56 - a DSP56001 assembler
  4 |  *
  5 |  *  Written by Quinn C. Jensen
  6 |  *  July 1990
  7 |  *
  8 |  *******************************************************\
  9 | 
 10 | /*
 11 |  * Copyright (C) 1990-1994 Quinn C. Jensen
 12 |  *
 13 |  * Permission to use, copy, modify, distribute, and sell this software
 14 |  * and its documentation for any purpose is hereby granted without fee,
 15 |  * provided that the above copyright notice appear in all copies and
 16 |  * that both that copyright notice and this permission notice appear
 17 |  * in supporting documentation.  The author makes no representations
 18 |  * about the suitability of this software for any purpose.  It is
 19 |  * provided "as is" without express or implied warranty.
 20 |  *
 21 |  */
 22 | static char *Copyright = "Copyright (C) 1990-1994 Quinn C. Jensen";
 23 | 
 24 | /*
 25 |  *  main.c - The "main" code for the assembler.
 26 |  *
 27 |  */
 28 | 
 29 | #include "a56.h"
 30 | 
 31 | #define MAX 1024
 32 | 
 33 | int pass;
 34 | int error, warning;
 35 | extern unsigned long pc;
 36 | extern int seg;
 37 | BOOL binary_listing = FALSE;
 38 | BOOL list_includes = FALSE;
 39 | FILE *obj = NULL;
 40 | extern BOOL list_on;
 41 | BOOL list_on_next = TRUE;
 42 | char *alloc();
 43 | 
 44 | main(argc,argv)
 45 | int argc;
 46 | char *argv[];
 47 | {
 48 | 	int i;
 49 | 	extern char *optarg;
 50 | 	extern int optind;
 51 | 	int c;
 52 | 	char *output_file = "a56.out";
 53 | 	char *input_file;
 54 | 	char *usage = "usage: a56  [-b]  [-l]  [-d]  [-o output-file]  input-file\n";
 55 | 
 56 | 	while((c = getopt(argc, argv, "bldo:")) != EOF) switch (c) {
 57 | 		case 'b':
 58 | 			binary_listing++;
 59 | 			break;
 60 | 		case 'l':
 61 | 			list_includes++;
 62 | 			break;
 63 | 		case 'd':
 64 | 			ldebug++;
 65 | 			break;
 66 | 		case 'o':
 67 | 			output_file = optarg;
 68 | 			break;
 69 | 		case '?':
 70 | 		default:
 71 | 			fatal(usage);
 72 | 	}
 73 | 	input_file = argv[optind++];
 74 | 	if(input_file == NULL) fatal(usage);
 75 | 	obj = open_write(output_file);
 76 | 
 77 | 	pc = 0;
 78 | 	seg = 0;
 79 | 	pass = 1;
 80 | 	reset_psects();
 81 | 	include(input_file);
 82 | 
 83 | 	pc = 0;
 84 | 	seg = 0;
 85 | 	pass = 2;
 86 | 	reset_psects();
 87 | 	include(input_file);
 88 | 
 89 | 	psect_summary();
 90 | 	dump_symtab();
 91 | 	fclose(obj);
 92 | 	printf("errors=%d\n", error);
 93 | 	printf("warnings=%d\n", warning);
 94 | 	return error ? 1 : 0;
 95 | }
 96 | 
 97 | struct inc inc[MAX_NEST];
 98 | int inc_p = 0;
 99 | FILE *yyin;
100 | 
101 | include(file)
102 | char *file;
103 | {
104 | 	FILE *fp = open_read(file);
105 | 
106 | 	inc_p++;
107 | 	if(inc_p >= MAX_NEST)
108 | 		fatal("%s: include nesting too deep\n", file);
109 | 
110 | 	inc[inc_p].file = file;
111 | 	inc[inc_p].fp = fp;
112 | 	inc[inc_p].line = 1;
113 | 
114 | 	list_on_next = TRUE;
115 | 	if(inc_p > 1 && NOT list_includes)
116 | 		list_on_next = FALSE;
117 | 
118 | 	yyin = inc[inc_p].fp;
119 | 	if(inc_p == 1)
120 | #ifdef FLEX
121 | 	{
122 | 		static int started = 0;
123 | 		if(started)
124 | 			yyrestart(yyin);
125 | 		else
126 | 			started = 1;
127 | 		yyparse();
128 | 	}
129 | #else
130 | 		yyparse();
131 | #endif
132 | }
133 | 
134 | yywrap()
135 | {
136 | 	fclose(inc[inc_p].fp);
137 | 	inc_p--;
138 | 	list_on = list_on_next = TRUE;
139 | 	if(inc_p > 1)
140 | 		list_on = list_on_next = FALSE;
141 | 	if(inc_p) {
142 | 		yyin = inc[inc_p].fp;
143 | 		return 0;
144 | 	} else {
145 | 		return 1;
146 | 	}
147 | }
148 | 
149 | struct n
150 | sym_ref(sym)		/* return symbol value or UNDEF if not defined yet */
151 | char *sym;
152 | {
153 | 	struct sym *sp, *find_sym();
154 | 	struct n result;
155 | 
156 | 	result.type = UNDEF;
157 | 
158 | 	sp = find_sym(sym);
159 | 	if(NOT sp) {
160 | 		if(pass == 2) {
161 | 			yyerror("%s: undefined symbol", sym);
162 | 		}		   
163 | 		return result;
164 | 	}
165 | 
166 | 	return sp->n;
167 | }
168 | 
169 | #define HASHSIZE 128
170 | 
171 | #define HASH(sym) (((sym)[0] ^ sym[1]) % HASHSIZE)
172 | 
173 | struct sym *symtab[HASHSIZE];
174 | 
175 | sym_def(sym, type, seg, i, f)
176 | char *sym;
177 | int type;
178 | int seg;
179 | int i;
180 | double f;
181 | {
182 | 	struct sym *sp, **stop, *find_sym();
183 | 
184 | 	if(pass == 1) {
185 | 		if(find_sym(sym)) {
186 | 			pass = 2;				/* what a kludge */
187 | 			yyerror("%s: multiply defined symbol", sym);
188 | 			pass = 1;
189 | 			return;
190 | 		}
191 | 		stop = &symtab[HASH(sym)];
192 | 		sp = NEW(struct sym);
193 | 		sp->next = *stop;
194 | 		*stop = sp;
195 | 		sp->name = strsave(sym);
196 | 		sp->n.type = type;
197 | 		sp->n.seg = seg;
198 | 		if(type == INT)
199 | 			sp->n.val.i = i & 0xFFFFFF;
200 | 		else
201 | 			sp->n.val.f = f;
202 | 	} else {
203 | 		sp = find_sym(sym);
204 | 		if(NOT sp)
205 | 			fatal("internal error 304\n");
206 | 		if(sp->n.type != type ||
207 | 			type == INT && sp->n.val.i != (i & 0xFFFFFF) ||
208 | 			type == FLT && sp->n.val.f != f)
209 | 			yyerror("%s: assembler phase error", sym);
210 | 	}		
211 | }
212 | 
213 | struct sym *find_sym(sym)
214 | char *sym;
215 | {
216 | 	struct sym *sp, **stop;
217 | 
218 | 	stop = &symtab[HASH(sym)];
219 | 	for(sp = *stop; sp; sp = sp->next)
220 | 		if(strcmp(sp->name, sym) == 0)
221 | 			return sp;
222 | 		
223 | 	return NULL;
224 | }
225 | 
226 | extern char segs[];
227 | dump_symtab()
228 | {
229 | 	struct sym *sp, **stop;
230 | 	int i;
231 | 
232 | 	printf("\n\
233 | Symbol Table\n\
234 | -------------------------------------\n");
235 | /*
236 | SSSSSSSSSSSSSSSS S XXXXXX
237 | SSSSSSSSSSSSSSSS S DDDDDDDDD.DDDDDDDDDD
238 | */
239 | 
240 | 	for(i = 0, stop = symtab; i < HASHSIZE; i++, stop++) {
241 | 		for(sp = *stop; sp; sp = sp->next) {
242 | 			if(sp->n.type == INT) {
243 | 				printf("%16s %c %06X\n", sp->name, segs[sp->n.seg], sp->n.val.i);
244 | 				fprintf(obj, "I %06X %s\n", sp->n.val.i, sp->name);
245 | 			} else {
246 | 				printf("%16s %c %.10f\n", sp->name, segs[sp->n.seg], sp->n.val.f);
247 | 				fprintf(obj, "F %.10f %s\n", sp->n.val.f, sp->name);
248 | 			}
249 | 		}
250 | 	}   
251 | }
252 | 
253 | char *printcode(word)
254 | int word;
255 | {
256 | 	static char list[MAX], *lp;
257 | 	int i;
258 | 
259 | 	word &= 0xFFFFFF;
260 | 
261 | 	if(binary_listing) {
262 | 		sprintf(list, "%06X<", word);
263 | 		for(i = 0, lp = &list[7]; i < 24; i++, lp++) {
264 | 			*lp = word & 1 << 23 - i ? '1' : '0';
265 | 			if(i && i % 4 == 3)
266 | 				*++lp = i % 8 == 7 ? ' ' : ',';
267 | 		}
268 | 		lp[-1] = '>';
269 | 		lp[0] = '\0';
270 | 	} else {
271 | 		sprintf(list, "%06X", word);
272 | 	}
273 | 	return list;
274 | }
275 | 
276 | char *spacespace[2] = {
277 | /*P:XXXX_XXXXXX_*/
278 |  "              ",
279 | /*P:XXXX_XXXXXX(XXXX_XXXX_XXXX_XXXX_XXXX_XXXX)_*/
280 |  "                                             "};
281 | char *spaces(n)
282 | int n;
283 | {
284 | 	return spacespace[binary_listing ? 1 : 0] + n;
285 | }
286 | 
287 | extern char segs[];
288 | 
289 | gencode(seg, pc, word)
290 | int seg, pc, word;
291 | {
292 | 	fprintf(obj, "%c %04X %06X\n", segs[seg], pc, word & 0xFFFFFF);
293 | }
294 | 
295 | char fixbuf[1024];
296 | 
297 | char *fixstring(s)
298 | char *s;
299 | {
300 | 	char *bp = fixbuf;
301 | 	int ival;
302 | 
303 | 	while(*s) {
304 | 		switch (*s) {
305 | 			case '\'':
306 | 			case '\"':
307 | 				s++;
308 | 				break;
309 | 			case '\\':
310 | 				switch (*++s) {
311 | 					case 'b': *bp++ = '\b'; break;
312 | 					case 'r': *bp++ = '\r'; break;
313 | 					case 'f': *bp++ = '\f'; break;
314 | 					case 'n': *bp++ = '\n'; break;
315 | 					case 't': *bp++ = '\t'; break;
316 | 					case '\\': *bp++ = '\\'; break;
317 | 					case '0':
318 | 						ival = 0;
319 | 						while(*s >= '0' && *s <= '9') {
320 | 							ival <<= 3;
321 | 							ival += *s++ - '0';
322 | 						}
323 | 						*bp++ = ival;
324 | 						break;
325 | 				}
326 | 				break;
327 | 			default:
328 | 				*bp++ = *s++;
329 | 				break;
330 | 		}
331 | 	}
332 | 	*bp = '\0';
333 | 	return fixbuf;
334 | }
335 | 
336 | #define ONE 0x4000000
337 | 
338 | makefrac(s)
339 | char *s;
340 | {
341 | 	int frac = 0, div = 1;
342 | 	int scale = 1;
343 | 
344 | 	while(*s) {
345 | 		switch(*s) {
346 | 			case '-':
347 | 				scale = -1;
348 | 				break;
349 | 			case '.':
350 | 				div = 10;
351 | 				break;
352 | 			default:
353 | 				frac += (*s - '0') * scale * ONE / div;
354 | 				div *= 10;
355 | 				break;
356 | 		}
357 | 		s++;
358 | 	}
359 | 
360 | 	return frac + scale * 4 >> 3 & 0xFFFFFF;
361 | }
362 | 
363 | /***************** psect stuff ************************/
364 | 
365 | struct psect *ptop = NULL, *cur_psect = NULL;
366 | 
367 | reset_psects()
368 | {
369 | 	struct psect *pp;
370 | 
371 | 	for(pp = ptop; pp; pp = pp->next) {
372 | 		pp->pc = pp->bottom;
373 | 	}
374 | 
375 | 	set_psect(NULL);
376 | }
377 | 
378 | psect_summary()
379 | {
380 | 	printf("\nSummary of psect usage\n\n");
381 | 
382 | 	printf("\
383 |                  section seg base last top      used       avail    total\n\
384 | -------------------------------------------------------------------------\n");
385 | /*
386 | SSSSSSSSSSSSSSSSSSSSSSSS  X  FFFF FFFF FFFF 99999 100%  99999 100%  99999
387 | */
388 | 
389 | 	summarize(ptop);	/* do it recursively to place back in order */
390 | 	printf("\n");
391 | }
392 | 
393 | summarize(pp)
394 | struct psect *pp;
395 | {
396 | 	int used, avail, of;
397 | 
398 | 	if(pp == NULL)
399 | 		return;
400 | 
401 | 	used = pp->pc - pp->bottom;
402 | 	avail = pp->top - pp->pc;
403 | 	of = pp->top - pp->bottom;
404 | 
405 | 	summarize(pp->next);
406 | 
407 | 	printf("%24.24s  %c  %04X %04X %04X %5d %3d%%  %5d %3d%%  %5d\n",
408 | 		pp->name, segs[pp->seg], pp->bottom, pp->pc, pp->top,
409 | 		used, of ? used * 100 / of : 0, avail, of ? avail * 100 / of : 0,
410 | 		of);
411 | }
412 | 
413 | struct psect *find_psect(name)
414 | char *name;
415 | {
416 | 	struct psect *pp;
417 | 
418 | 	for(pp = ptop; pp; pp = pp->next)
419 | 		if(strcmp(pp->name, name) == 0)
420 | 			return pp;
421 | 
422 | 	return NULL;
423 | }
424 | 
425 | set_psect(pp)
426 | struct psect *pp;
427 | {
428 | 	cur_psect = pp;
429 | }
430 | 
431 | check_psect(seg, pc)
432 | int seg;
433 | unsigned int pc;
434 | {
435 | 	if(cur_psect) {
436 | 		if(seg == cur_psect->seg && pc >= cur_psect->bottom && 
437 | 			pc <= cur_psect->top) {
438 | 			cur_psect->pc = pc;
439 | 			return TRUE;
440 | 		} else {
441 | 			return FALSE;
442 | 		}
443 | 	} else {
444 | 		return TRUE;
445 | 	}
446 | }
447 | 
448 | struct psect *new_psect(name, seg, bottom, top)
449 | char *name;
450 | int seg;
451 | unsigned int bottom, top;
452 | {
453 | 	struct psect *pp = find_psect(name);
454 | 
455 | 	if(NOT pp) {
456 | 		pp = (struct psect *)alloc(sizeof *pp);
457 | 		pp->next = ptop;
458 | 		ptop = pp;
459 | 		pp->name = strsave(name);
460 | 		pp->seg = seg;
461 | 		pp->pc = bottom;
462 | 	}
463 | 	pp->bottom = bottom;
464 | 	pp->top = top;
465 | 
466 | 	return pp;
467 | }
468 | 


--------------------------------------------------------------------------------
/subs.c:
--------------------------------------------------------------------------------
  1 | /*******************************************************
  2 |  *
  3 |  *  a56 - a DSP56001 assembler
  4 |  *
  5 |  *  Written by Quinn C. Jensen
  6 |  *  July 1990
  7 |  *
  8 |  *******************************************************\
  9 | 
 10 | /*
 11 |  * Copyright (C) 1990-1994 Quinn C. Jensen
 12 |  *
 13 |  * Permission to use, copy, modify, distribute, and sell this software
 14 |  * and its documentation for any purpose is hereby granted without fee,
 15 |  * provided that the above copyright notice appear in all copies and
 16 |  * that both that copyright notice and this permission notice appear
 17 |  * in supporting documentation.  The author makes no representations
 18 |  * about the suitability of this software for any purpose.  It is
 19 |  * provided "as is" without express or implied warranty.
 20 |  *
 21 |  */
 22 | static char *Copyright = "Copyright (C) 1990-1994 Quinn C. Jensen";
 23 | 
 24 | /*
 25 |  *  subs.c - Some subroutines for the assembler.
 26 |  *
 27 |  */
 28 | 
 29 | #include "a56.h"
 30 | 
 31 | #define MAX 1024
 32 | 
 33 | FILE *open_read(file)
 34 | char *file;
 35 | {
 36 | 	FILE *fp;
 37 | 
 38 | 	if(strcmp(file, "-") == 0)
 39 | 		fp = stdin;
 40 | 	else if ((fp = fopen(file, "r")) == NULL) {
 41 | 		perror(file);
 42 | 		exit(1);
 43 | 	}	
 44 | 	return fp;
 45 | }
 46 | 
 47 | FILE *open_write(file)
 48 | char *file;
 49 | {
 50 | 	FILE *fp;
 51 | 	if ((fp = fopen(file, "w")) == NULL) {
 52 | 		perror(file);
 53 | 		exit(1);
 54 | 	}	
 55 | 	return fp;
 56 | }
 57 | 
 58 | FILE *open_append(file)
 59 | char *file;
 60 | {
 61 | 	FILE *fp;
 62 | 	if ((fp = fopen(file, "a")) == NULL) {
 63 | 		perror(file);
 64 | 		exit(1);
 65 | 	}	
 66 | 	return fp;
 67 | }
 68 | 
 69 | fatal(c, a1, a2, a3, a4, a5, a6, a7, a8)
 70 | char *c, *a1, *a2, *a3, *a4, *a5, *a6, *a7, *a8;
 71 | {
 72 | 	fprintf(stderr, c, a1, a2, a3, a4, a5, a6, a7, a8);
 73 | 	exit(1);
 74 | }
 75 | 
 76 | #define TABS 8
 77 | #define MAX_BUF 256
 78 | 
 79 | char tabbuf[MAX_BUF], *untabn();
 80 | char *untab(s)	/* expand tabs in s */
 81 | register char *s;
 82 | {
 83 | 	return untabn(s, TABS);
 84 | }
 85 | 
 86 | char *untabn(s, stops)	/* expand tabs in s */
 87 | register char *s;
 88 | register int stops;
 89 | {
 90 | 	char *o = s;
 91 | 
 92 | 	/* copy input string into buffer to scan while input string is modified */
 93 | 
 94 | 	register char *b = tabbuf;
 95 | 	
 96 | 	strncpy(b, s, MAX_BUF);
 97 | 
 98 | 	/* iterate until the copy of the input string is depleted */
 99 | 
100 | 	while(*b) {
101 | 		if(*b == '\t') {
102 | 			do
103 | 				*s = ' ';
104 | 			while ((++s - o) % stops);
105 | 		} else {
106 | 			*s = *b; s++;
107 | 		}
108 | 		b++;
109 | 	}
110 | 
111 | 	/* null terminate the resultant string */
112 | 
113 | 	*s = '\0';
114 | 
115 | 	return o;
116 | }
117 | 
118 | char *alloc(int size)
119 | {
120 | 	char *p = (char *)malloc(size);
121 | 	if(NOT p)
122 | 		fatal("alloc:  insufficient virtual memory to allocate %d bytes\n", 
123 | 			size);
124 | 	return p;
125 | }
126 | 
127 | #define ascii2n(c)  \
128 | 	((c) >= 'a' ? (c) - 'a' + 10 : ((c) >= 'A' ? (c) - 'A' + 10 : (c) - '0'))
129 | 
130 | #define valid(c) ((c) >= '0' && (c) <= '9' || \
131 | 	(c) >= 'A' && (c) <= 'Z' || \
132 | 	(c) >= 'a' && (c) <= 'z')
133 | 
134 | strtol(s, p, base)
135 | register char *s, **p;
136 | register int base;
137 | {
138 | 	register long result = 0;
139 | 	register int sign = 0;
140 | 
141 | 	while(*s == ' ' || *s == '\t')
142 | 		s++;
143 | 
144 | 	if(*s == '-') {
145 | 		s++;
146 | 		sign++;
147 | 	}
148 | 
149 | 	while(valid(*s)) {
150 | 		register int dig = ascii2n(*s);
151 | 		if(dig >= base)
152 | 			break;
153 | 		result *= base;
154 | 		result += dig;
155 |  		s++;
156 | 	}
157 | 
158 | 	if(p)
159 | 		*p = s;
160 | 
161 | 	return sign ? -result : result;
162 | }
163 | 


--------------------------------------------------------------------------------
/tok.awk:
--------------------------------------------------------------------------------
1 | BEGIN		{printf("struct {int n; char *name;} tok_tab[] = {\n");}
2 | /#define/	{printf("    {%d, \"%s\"},\n", $3, $2);}
3 | /# define/	{printf("    {%d, \"%s\"},\n", $4, $3);}
4 | END		{printf("};\n#define N_TOK (sizeof tok_tab / sizeof tok_tab[0])\nint n_tok = N_TOK;\n");}
5 | 


--------------------------------------------------------------------------------
/toomf.c:
--------------------------------------------------------------------------------
 1 | /*******************************************************
 2 |  *
 3 |  *  a56 - a DSP56001 assembler
 4 |  *
 5 |  *  Written by Quinn C. Jensen
 6 |  *  July 1990
 7 |  *
 8 |  *******************************************************\
 9 | 
10 | /*
11 |  * Copyright (C) 1990-1994 Quinn C. Jensen
12 |  *
13 |  * Permission to use, copy, modify, distribute, and sell this software
14 |  * and its documentation for any purpose is hereby granted without fee,
15 |  * provided that the above copyright notice appear in all copies and
16 |  * that both that copyright notice and this permission notice appear
17 |  * in supporting documentation.  The author makes no representations
18 |  * about the suitability of this software for any purpose.  It is
19 |  * provided "as is" without express or implied warranty.
20 |  *
21 |  */
22 | static char *Copyright = "Copyright (C) 1990-1994 Quinn C. Jensen";
23 | 
24 | /*
25 |  *  This small program converts the a56.out file from the assembler
26 |  *  into a file suitable for loading into 56001 memory via the
27 |  *  SLOADER.ASM serial loader program provided on the Motorola
28 |  *  Dr. Bubb BBS.
29 |  *
30 |  */
31 | 
32 | #include <stdio.h>
33 | 
34 | #define MAX 256
35 | 
36 | main(argc,argv)
37 | int argc;
38 | char *argv[];
39 | {
40 | 	char buf[MAX];
41 | 	int curaddr = 0;
42 | 	int line = 0;
43 | 	int curseg = '\0';
44 | 	int startaddr = -1;
45 | 
46 | 	while(fgets(buf, sizeof(buf), stdin)) {
47 | 		char seg;
48 | 		int addr, data;
49 | 		line++;
50 | 		if(sscanf(buf, "%c%x%x", &seg, &addr, &data) == 3) {
51 | 			if(seg == 'I' || seg == 'F') break;
52 | 			if(seg != curseg || curaddr != addr) {
53 | 				printf("\n_DATA %c %04X\n", curseg = seg, curaddr = addr);
54 | 			}   
55 | 			if(startaddr == -1 && seg == 'P')
56 | 				startaddr = addr;
57 | 			printf("%06X ", data & 0xFFFFFF);
58 | 			curaddr++;
59 | 		}
60 | 	}
61 | 	printf("\n_END %04X\n", startaddr);
62 | }
63 | 


--------------------------------------------------------------------------------
/torom.c:
--------------------------------------------------------------------------------
 1 | /*******************************************************
 2 |  *
 3 |  *  a56 - a DSP56001 assembler
 4 |  *
 5 |  *  Written by Quinn C. Jensen
 6 |  *  July 1990
 7 |  *
 8 |  *******************************************************\
 9 | 
10 | /*
11 |  * Copyright (C) 1990-1994 Quinn C. Jensen
12 |  *
13 |  * Permission to use, copy, modify, distribute, and sell this software
14 |  * and its documentation for any purpose is hereby granted without fee,
15 |  * provided that the above copyright notice appear in all copies and
16 |  * that both that copyright notice and this permission notice appear
17 |  * in supporting documentation.  The author makes no representations
18 |  * about the suitability of this software for any purpose.  It is
19 |  * provided "as is" without express or implied warranty.
20 |  *
21 |  */
22 | static char *Copyright = "Copyright (C) 1990-1994 Quinn C. Jensen";
23 | 
24 | /*
25 |  *  This program converts the a56.out assembler output file into
26 |  *  raw binary, suitable for conversion to S-records for an EPROM burner.
27 |  *
28 |  */
29 | 
30 | #include <stdio.h>
31 | 
32 | #define MAX 256
33 | 
34 | main(argc,argv)
35 | int argc;
36 | char *argv[];
37 | {
38 | 	char buf[MAX];
39 | 	int curaddr = 0;
40 | 	int line = 0;
41 | 
42 | 	while(fgets(buf, sizeof(buf), stdin)) {
43 | 		char seg;
44 | 		int addr, data;
45 | 		line++;
46 | 		if(sscanf(buf, "%c%x%x", &seg, &addr, &data) == 3) {
47 | 			if(seg == 'I') {
48 | 				break;
49 | 			} else {
50 | 				if(addr < curaddr) {
51 | 					fatal("%s: input line %d: can't go back\n", argv[0], line);
52 | 				} else if(addr != curaddr) {
53 | 					while(curaddr < addr) {
54 | 						putword(0);
55 | 						curaddr++;
56 | 					}
57 | 				}
58 | 				putword(data);
59 | 				curaddr++;
60 | 			}
61 | 		}
62 | 	}
63 | }
64 | 
65 | putword(data)
66 | int data;
67 | {
68 | 	putchar(data >>  0 & 0xFF);
69 | 	putchar(data >>  8 & 0xFF);
70 | 	putchar(data >> 16 & 0xFF);
71 | }
72 | 


--------------------------------------------------------------------------------