Mercurial > hg > forks > dxa

comparison structures.h @ 0:4410c9c7750d

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Initial import.
author Matti Hamalainen <ccr@tnsp.org>
date Tue, 24 Feb 2015 18:53:52 +0200
parents
children 0990d9322fc8
comparison
equal deleted inserted replaced
-1:000000000000 0:4410c9c7750d
1 /*\
2 * dxa v0.1.1 -- symbolic 65xx disassembler
3 *
4 * Copyright (C) 1993, 1994 Marko M\"akel\"a
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 *
20 * Contacting the author:
21 *
22 * Via Internet E-mail:
23 * <Marko.Makela@FTP.FUNET.FI>
24 *
25 * Via Snail Mail:
26 * Marko M\"akel\"a
27 * Sillitie 10 A
28 * FIN-01480 VANTAA
29 * Finland
30 \*/
31
32 /* structures.h - memory structures and related constants and macros */
33 #ifndef _STRUCTURES_H_
34 #define _STRUCTURES_H_
35
36 #ifndef FALSE
37 #define FALSE 0
38 #define TRUE !FALSE
39 #endif
40
41 #ifndef NULL
42 #define NULL (void *)0
43 #endif
44
45 #define MAXLINE 50 /* maximum amount of bytes used when reading a label in */
46
47 typedef unsigned short int ADDR_T; /* 16-bit unsigned integer */
48 typedef unsigned char DATA_T; /* 8-bit unsigned integer */
49
50 /********************\
51 * Program code table *
52 \********************/
53
54 #ifndef _MAIN_C_
55 extern
56 #endif
57 DATA_T Memory[1 << 16];
58
59 /*************************\
60 * Memory place type table *
61 \*************************/
62
63 #ifndef _MAIN_C_
64 extern
65 #endif
66 unsigned MemType[(1 << 14) / sizeof(unsigned)];
67
68 #define GetMemType(address) \
69 ((MemType[((ADDR_T)address) / (4 * sizeof *MemType)] >> \
70 ((address % (4 * sizeof *MemType)) << 1)) & 3)
71
72 #define SetMemType(address, type) \
73 (MemType[((ADDR_T)address) / (4 * sizeof *MemType)] = \
74 (MemType[((ADDR_T)address) / (4 * sizeof *MemType)] & \
75 ~(3 << ((address % (4 * sizeof *MemType)) << 1))) | \
76 (type << ((address % (4 * sizeof *MemType)) << 1)))
77
78 /* The table consists of bit pairs with the following values: */
79
80 #define MEM_UNPROCESSED 0 /* the memory place has not been processed yet */
81 #define MEM_INSTRUCTION 1 /* a machine language instruction starts at
82 this memory place */
83 #define MEM_DATA 2 /* the memory place contains data */
84 #define MEM_PARAMETER 3 /* a parameter of a machine language
85 instruction is at this place */
86
87 /*************************\
88 * Memory place flag table *
89 \*************************/
90
91 #ifndef _MAIN_C_
92 extern
93 #endif
94 unsigned
95 MemFlag[(1 << 13) / sizeof(unsigned)],
96 MemLabel[(1 << 13) / sizeof(unsigned)],
97 LowByte[(1 << 8) / sizeof(unsigned)],
98 HighByte[(1 << 8) / sizeof(unsigned)];
99
100 #define GetMemFlag(address) \
101 ((MemFlag[((ADDR_T)address) / (8 * sizeof *MemFlag)] >> \
102 (address % (8 * sizeof *MemFlag))) & 1)
103
104 #define SetMemFlag(address) \
105 (MemFlag[((ADDR_T)address) / (8 * sizeof *MemFlag)] |= \
106 (1 << (address % (8 * sizeof *MemFlag))))
107
108 /* The flag table indicates if there may be a valid routine at the address.
109 If a flag is set, there cannot be valid routines at the address. */
110
111 #define IsLabeled(address) \
112 ((MemLabel[((ADDR_T)address) / (8 * sizeof *MemLabel)] >> \
113 (address % (8 * sizeof *MemLabel))) & 1)
114
115 #define PutLabel(address) \
116 (MemLabel[((ADDR_T)address) / (8 * sizeof *MemLabel)] |= \
117 (1 << (address % (8 * sizeof *MemLabel))))
118
119 /* These macros tell if there is a label for a given address, or cause a
120 label to be produced for an address. */
121
122 #define IsLowByte(address) \
123 ((LowByte[((unsigned char)address) / (8 * sizeof *LowByte)] >> \
124 (address % (8 * sizeof *LowByte))) & 1)
125
126 #define PutLowByte(address) \
127 (LowByte[((unsigned char)address) / (8 * sizeof *LowByte)] |= \
128 (1 << (address % (8 * sizeof *LowByte))))
129
130 /* Corresponding macros for the low byte address table. */
131
132 #define IsHighByte(address) \
133 ((HighByte[(address >> 8) / (8 * sizeof *HighByte)] >> \
134 ((address >> 8) % (8 * sizeof *HighByte))) & 1)
135
136 #define PutHighByte(address) \
137 (HighByte[(address >> 8) / (8 * sizeof *HighByte)] |= \
138 (1 << ((address >> 8) % (8 * sizeof *HighByte))))
139
140 /* Corresponding macros for the high byte address table. */
141
142 /***************************************\
143 * Routine/warning address table entries *
144 \***************************************/
145
146 typedef struct table
147 {
148 ADDR_T address;
149 ADDR_T parent;
150 unsigned char type;
151 } table;
152
153 /* The table.type byte has the following format: */
154
155 #define RTN_SURE 0x80 /* address must point to a valid subprogram */
156 #define RTN_POTENTIAL 0x81 /* address may point to a valid subprogram (an
157 address following a conditional branch
158 instruction) */
159 #define RTN_SUSPECTED 0x82 /* address might point to a valid subprogram
160 (an address encountered during processing
161 an RTN_POTENTIAL entry) */
162 #define RTN_SUSP_POT 0x83 /* address might point to a subprogram (an
163 address following a conditional branch
164 instruction that was encountered during
165 processing an RTN_SUSPECTED or
166 RTN_POTENTIAL entry) */
167 #define RTN_B_TEMPORARY 0x10 /* declares the entry as temporary */
168 #define RTN_B_PROCESSED 0x20 /* address seems to point to a valid
169 subprogram (a successfully processed
170 RTN_SUSPECTED entry is
171 RTN_SUSPECTED | RTN_B_PROCESSED) */
172
173 #define MASK_ANY 0xc0 /* mask for determining the type of the entry */
174
175 #define RTN_ANY 0x80 /* mask for determining if an entry is a
176 routine or not */
177
178 #define WRN_PARAM_WRITTEN_TO 0x40 /* the parameter of the instruction is
179 written to */
180 #define WRN_INSTR_WRITTEN_TO 0x41 /* the instruction is modified by the
181 program */
182
183 #define WRN_PARAM_JUMPED_TO 0x42 /* a jump occurs in the middle of the
184 instruction, e.g. BIT $01A9 */
185 #define WRN_RTN_TRUNCATED 0x43 /* the routine is truncated, the rest of
186 the instructions are retrieved outside
187 the loaded file (very fatal error) */
188 #define WRN_I_ACCESSED 0x44 /* not an actual warning: an unprocessed
189 memory place is accessed by an
190 RTN_POTENTIAL or RTN_SUSPECTED routine */
191 #define WRN_I_LABEL_NEEDED 0x45 /* not an actual warning: a label will be
192 needed for this memory place */
193
194 #define WRN_B_TEMPORARY 0x20 /* mask for determining whether a warning
195 is temporary and may be deleted later */
196
197 #define WRN_ANY 0x40 /* mask for determining whether an
198 entry is a warning or not */
199
200 #define TBL_DELETED 0 /* the entry may be reused */
201
202 /*********************\
203 * Label table entries *
204 \*********************/
205
206 typedef struct label
207 {
208 ADDR_T address;
209 char *name;
210 } label;
211
212 /********************\
213 * Word table entries *
214 \********************/
215
216 typedef struct words
217 {
218 ADDR_T start, end;
219 } words;
220
221 #ifndef _MAIN_C_
222 extern char *prog;
223 extern ADDR_T StartAddress, EndAddress;
224 extern int fVerbose;
225 #else
226 char *prog;
227 ADDR_T StartAddress, EndAddress;
228 int fVerbose = FALSE;
229 #endif /* _MAIN_C_ */
230
231 #ifndef _TABLE_C_
232 extern unsigned int entrycount;
233 extern table *scantable; /* table of all warnings generated or routines
234 encountered */
235 #else
236 unsigned int entrycount = 0;
237 table *scantable = NULL;
238 #endif /* _TABLE_C_ */
239
240 #ifndef _DUMP_C_
241 extern int listwidth; /* maximum amount of bytes dumped on a source line */
242 #else
243 int listwidth = 0;
244 #endif /* _DUMP_C_ */
245
246 #endif /* _STRUCTURES_H_ */