1 %{ 2 /* $OpenBSD: fgen.l,v 1.14 2021/12/13 18:28:40 deraadt Exp $ */ 3 /* $NetBSD: fgen.l,v 1.37 2016/03/08 20:13:44 christos Exp $ */ 4 /* FLEX input for FORTH input file scanner */ 5 /* 6 * Copyright (c) 1998 Eduardo Horvath. 7 * All rights reserved. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 23 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 */ 29 /* 30 Specifications are as follows: 31 32 The function "yylex()" always returns a pointer to a structure: 33 34 struct tok { 35 int type; 36 char *text; 37 } 38 #define TOKEN struct tok 39 */ 40 41 %} 42 43 %option yylineno 44 45 hex [0-9A-Fa-f] 46 hexdot [0-9A-Fa-f.] 47 white [ \t\n\r\f] 48 tail {white} 49 50 %{ 51 #include <sys/types.h> 52 #include <arpa/inet.h> 53 54 #include <assert.h> 55 #include <err.h> 56 #include <errno.h> 57 #include <fcntl.h> 58 #include <stdarg.h> 59 #include <stdio.h> 60 #include <string.h> 61 #include <unistd.h> 62 #include <util.h> 63 64 #include "fgen.h" 65 static TOKEN ltoken; 66 67 /* 68 * Global variables that control the parse state. 69 */ 70 71 static struct fcode *dictionary = NULL; 72 static struct macro *aliases = NULL; 73 static int outf = 1; /* stdout */ 74 static int state = 0; 75 static int nextfcode = 0x800; 76 static int numbase = TOK_HEX; 77 static long outpos; 78 static char *outbuf = NULL; 79 static char *outfile, *infile; 80 #define BUFCLICK (1024*1024) 81 static size_t outbufsiz = 0; 82 static char *myname = NULL; 83 static int offsetsize = 8; 84 static int defining = 0; 85 static int tokenizer = 0; 86 static int need_end0 = 1; 87 88 #define PSTKSIZ 1024 89 static Cell parse_stack[PSTKSIZ]; 90 static int parse_stack_ptr = 0; 91 92 static void token_err(int, const char *, const char *, const char *, ...) 93 __attribute__((__format__ (printf, 4, 5))) __dead; 94 static YY_DECL; 95 96 static int debug = 0; 97 #define ASSERT if (debug) assert 98 #define STATE(y, x) do { if (debug) printf("%lx State %s: token `%s'\n", outpos, x, y); } while (0) 99 static int mark_fload = 0; 100 101 void * 102 emalloc(size_t sz) 103 { 104 void *p = malloc(sz); 105 if (p == NULL) 106 err(1, NULL); 107 return p; 108 } 109 110 char * 111 estrdup(const char *s) 112 { 113 char *p = strdup(s); 114 if (p == NULL) 115 err(1, NULL); 116 return p; 117 } 118 119 void * 120 erealloc(void *p, size_t sz) 121 { 122 void *q = realloc(p, sz); 123 if (q == NULL) 124 err(1, NULL); 125 return q; 126 } 127 128 %} 129 130 %option nounput 131 132 %% 133 134 0 { ltoken.type = TOK_OTHER; ltoken.text = yytext; return <oken; } 135 136 1 { ltoken.type = TOK_OTHER; ltoken.text = yytext; return <oken; } 137 138 2 { ltoken.type = TOK_OTHER; ltoken.text = yytext; return <oken; } 139 140 3 { ltoken.type = TOK_OTHER; ltoken.text = yytext; return <oken; } 141 142 -1 { ltoken.type = TOK_OTHER; ltoken.text = yytext; return <oken; } 143 144 \. { ltoken.type = TOK_OTHER; ltoken.text = yytext; return <oken; } 145 146 {white}* /* whitespace -- keep looping */ ; 147 148 \\[^\n]*\n /* end of line comment -- keep looping */ { STATE(yytext, "EOL comment"); } 149 150 -?{hex}{hexdot}* { ltoken.type = TOK_NUMBER; ltoken.text = yytext; 151 return <oken; } 152 153 \'.\' { ltoken.type = TOK_C_LIT; ltoken.text = yytext; return <oken; } 154 155 \"{white}*(\\\"|[^"])*\" { ltoken.type = TOK_STRING_LIT; ltoken.text = yytext; 156 return <oken; } /* String started by `"' or `."' */ 157 158 \.\({white}*(\\\"|[^)])*\) { ltoken.type = TOK_PSTRING; ltoken.text = yytext; 159 return <oken; } /* String of type `.(.....)' */ 160 161 \.\"{white}*(\\\"|[^"])*\" { ltoken.type = TOK_PSTRING; ltoken.text = yytext; 162 return <oken; } 163 164 [aA][bB][oO][rR][tT]\"{white}*(\\\"|[^"])*\" { ltoken.type = TOK_ABORT_S; 165 ltoken.text = yytext; return <oken; } 166 167 "(" { ltoken.type = TOK_COMMENT; ltoken.text = yytext; 168 return <oken; } 169 170 ":" { ltoken.type = TOK_COLON; ltoken.text = yytext; 171 return <oken; } 172 173 ";" { ltoken.type = TOK_SEMICOLON; ltoken.text = yytext; 174 return <oken; } 175 176 \' { ltoken.type = TOK_TOKENIZE; ltoken.text = yytext; 177 return <oken; } 178 179 [aA][gG][aA][iI][nN] { ltoken.type = TOK_AGAIN; ltoken.text = yytext; 180 return <oken; } 181 182 [aA][lL][iI][aA][sS] { ltoken.type = TOK_ALIAS; ltoken.text = yytext; 183 return <oken; } 184 185 \[\'\] { ltoken.type = TOK_GETTOKEN; ltoken.text = yytext; 186 return <oken; } 187 188 [aA][sS][cC][iI][iI] { ltoken.type = TOK_ASCII; ltoken.text = yytext; 189 return <oken; } 190 191 [bB][eE][gG][iI][nN] { ltoken.type = TOK_BEGIN; ltoken.text = yytext; 192 return <oken; } 193 194 [bB][uU][fF][fF][eE][rR]: { ltoken.type = TOK_BUFFER; ltoken.text = yytext; 195 return <oken; } 196 197 [cC][aA][sS][eE] { ltoken.type = TOK_CASE; ltoken.text = yytext; 198 return <oken; } 199 200 [cC][oO][nN][sS][tT][aA][nN][tT] { ltoken.type = TOK_CONSTANT; ltoken.text = yytext; 201 return <oken; } 202 203 [cC][oO][nN][tT][rR][oO][lL] { ltoken.type = TOK_CONTROL; ltoken.text = yytext; 204 return <oken; } 205 206 [cC][rR][eE][aA][tT][eE] { ltoken.type = TOK_CREATE; ltoken.text = yytext; 207 return <oken; } 208 209 [dD]# { ltoken.type = TOK_DECIMAL; ltoken.text = yytext; 210 return <oken; } 211 212 [dD][eE][cC][iI][mM][aA][lL] { ltoken.type = TOK_DECIMAL; ltoken.text = yytext; 213 return <oken; } 214 215 [dD][eE][fF][eE][rR] { ltoken.type = TOK_DEFER; ltoken.text = yytext; 216 return <oken; } 217 218 \??[dD][oO] { ltoken.type = TOK_DO; ltoken.text = yytext; 219 return <oken; } 220 221 [eE][lL][sS][eE] { ltoken.type = TOK_ELSE; ltoken.text = yytext; 222 return <oken; } 223 224 [eE][nN][dD]0 { ltoken.type = TOK_END0; ltoken.text = yytext; 225 return <oken; } 226 227 [eE][nN][dD][cC][aA][sS][eE] { ltoken.type = TOK_ENDCASE; ltoken.text = yytext; 228 return <oken; } 229 230 [eE][nN][dD][oO][fF] { ltoken.type = TOK_ENDOF; ltoken.text = yytext; 231 return <oken; } 232 233 [eE][xX][tT][eE][rR][nN][aA][lL] { ltoken.type = TOK_EXTERNAL; ltoken.text = yytext; 234 return <oken; } 235 236 [fF][cC][oO][dD][eE]-[vV][eE][rR][sS][iI][oO][nN]2 { 237 ltoken.type = TOK_FCODE_VERSION2; ltoken.text = yytext; 238 return <oken; } 239 240 [fF][cC][oO][dD][eE]-[eE][nN][dD] { ltoken.type = TOK_FCODE_END; ltoken.text = yytext; 241 return <oken; } 242 243 [fF][iI][eE][lL][dD] { ltoken.type = TOK_FIELD; ltoken.text = yytext; 244 return <oken; } 245 246 [hH]# { ltoken.type = TOK_HEX; ltoken.text = yytext; 247 return <oken; } 248 249 [hH][eE][aA][dD][eE][rR][lL][eE][sS][sS] { ltoken.type = TOK_HEADERLESS; ltoken.text = yytext; 250 return <oken; } 251 252 [hH][eE][aA][dD][eE][rR][sS] { ltoken.type = TOK_HEADERS; ltoken.text = yytext; 253 return <oken; } 254 255 [hH][eE][xX] { ltoken.type = TOK_HEX; ltoken.text = yytext; 256 return <oken; } 257 258 [iI][fF] { ltoken.type = TOK_IF; ltoken.text = yytext; 259 return <oken; } 260 261 \??[lL][eE][aA][vV][eE] { ltoken.type = TOK_LEAVE; ltoken.text = yytext; 262 return <oken; } 263 264 \+?[lL][oO][oO][pP] { ltoken.type = TOK_LOOP; ltoken.text = yytext; 265 return <oken; } 266 267 [oO]# { ltoken.type = TOK_OCTAL; ltoken.text = yytext; 268 return <oken; } 269 270 [oO][cC][tT][aA][lL] { ltoken.type = TOK_OCTAL; ltoken.text = yytext; 271 return <oken; } 272 273 [oO][fF] { ltoken.type = TOK_OF; ltoken.text = yytext; 274 return <oken; } 275 276 [oO][fF][fF][sS][eE][tT]16 { ltoken.type = TOK_OFFSET16; ltoken.text = yytext; 277 return <oken; } 278 279 [rR][eE][pP][eE][aA][tT] { ltoken.type = TOK_REPEAT; ltoken.text = yytext; 280 return <oken; } 281 282 [sS][tT][aA][rR][tT][0124] { ltoken.type = TOK_STARTX; ltoken.text = yytext; 283 return <oken; } 284 285 [tT][hH][eE][nN] { ltoken.type = TOK_THEN; ltoken.text = yytext; 286 return <oken; } 287 288 [tT][oO] { ltoken.type = TOK_TO; ltoken.text = yytext; 289 return <oken; } 290 291 [uU][nN][tT][iI][lL] { ltoken.type = TOK_UNTIL; ltoken.text = yytext; 292 return <oken; } 293 294 [vV][aA][lL][uU][eE] { ltoken.type = TOK_VALUE; ltoken.text = yytext; 295 return <oken; } 296 297 [vV][aA][rR][iI][aA][bB][lL][eE] { ltoken.type = TOK_VARIABLE; ltoken.text = yytext; 298 return <oken; } 299 300 [vV][eE][rR][sS][iI][oO][nN]1 { ltoken.type = TOK_VERSION1; ltoken.text = yytext; 301 return <oken; } 302 303 [wW][hH][iI][lL][eE] { ltoken.type = TOK_WHILE; ltoken.text = yytext; 304 return <oken; } 305 306 tokenizer\[ { ltoken.type = TOK_BEGTOK; ltoken.text = yytext; 307 return <oken; } 308 309 emit-byte { ltoken.type = TOK_EMIT_BYTE; ltoken.text = yytext; 310 return <oken; } 311 312 \]tokenizer { ltoken.type = TOK_ENDTOK; ltoken.text = yytext; 313 return <oken; } 314 315 [fF][lL][oO][aA][dD] { ltoken.type = TOK_FLOAD; ltoken.text = yytext; 316 return <oken; } 317 318 319 [^ \n\t\r\f]+ { ltoken.type = TOK_OTHER; ltoken.text = yytext; 320 return <oken; } 321 322 <<EOF>> { return NULL; } 323 %% 324 325 /* Function definitions */ 326 static void push(Cell); 327 static Cell pop(void); 328 static int depth(void); 329 static int fadd(struct fcode *, struct fcode *); 330 static struct fcode *flookup(struct fcode *, const char *); 331 static int aadd(struct macro *, struct macro *); 332 static struct macro *alookup(struct macro *, const char *); 333 static void initdic(void); 334 __dead static void usage(void); 335 static void tokenize(YY_BUFFER_STATE); 336 static int emit(const char *); 337 static int spit(long); 338 static int offspit(long); 339 static void sspit(const char *); 340 static int apply_macros(YY_BUFFER_STATE, const char *); 341 static Cell cvt(const char *, char **, int base); 342 343 /* 344 * Standard FCode names and numbers. Includes standard 345 * tokenizer aliases. 346 */ 347 static struct fcode fcodes[] = { 348 { "end0", 0x0000, 0, NULL, NULL }, 349 { "b(lit)", 0x0010, 0, NULL, NULL }, 350 { "b(')", 0x0011, 0, NULL, NULL }, 351 { "b(\")", 0x0012, 0, NULL, NULL }, 352 { "bbranch", 0x0013, 0, NULL, NULL }, 353 { "b?branch", 0x0014, 0, NULL, NULL }, 354 { "b(loop)", 0x0015, 0, NULL, NULL }, 355 { "b(+loop)", 0x0016, 0, NULL, NULL }, 356 { "b(do)", 0x0017, 0, NULL, NULL }, 357 { "b(?do)", 0x0018, 0, NULL, NULL }, 358 { "i", 0x0019, 0, NULL, NULL }, 359 { "j", 0x001a, 0, NULL, NULL }, 360 { "b(leave)", 0x001b, 0, NULL, NULL }, 361 { "b(of)", 0x001c, 0, NULL, NULL }, 362 { "execute", 0x001d, 0, NULL, NULL }, 363 { "+", 0x001e, 0, NULL, NULL }, 364 { "-", 0x001f, 0, NULL, NULL }, 365 { "*", 0x0020, 0, NULL, NULL }, 366 { "/", 0x0021, 0, NULL, NULL }, 367 { "mod", 0x0022, 0, NULL, NULL }, 368 { "and", 0x0023, 0, NULL, NULL }, 369 { "or", 0x0024, 0, NULL, NULL }, 370 { "xor", 0x0025, 0, NULL, NULL }, 371 { "invert", 0x0026, 0, NULL, NULL }, 372 { "lshift", 0x0027, 0, NULL, NULL }, 373 { "rshift", 0x0028, 0, NULL, NULL }, 374 { ">>a", 0x0029, 0, NULL, NULL }, 375 { "/mod", 0x002a, 0, NULL, NULL }, 376 { "u/mod", 0x002b, 0, NULL, NULL }, 377 { "negate", 0x002c, 0, NULL, NULL }, 378 { "abs", 0x002d, 0, NULL, NULL }, 379 { "min", 0x002e, 0, NULL, NULL }, 380 { "max", 0x002f, 0, NULL, NULL }, 381 { ">r", 0x0030, 0, NULL, NULL }, 382 { "r>", 0x0031, 0, NULL, NULL }, 383 { "r@", 0x0032, 0, NULL, NULL }, 384 { "exit", 0x0033, 0, NULL, NULL }, 385 { "0=", 0x0034, 0, NULL, NULL }, 386 { "0<>", 0x0035, 0, NULL, NULL }, 387 { "0<", 0x0036, 0, NULL, NULL }, 388 { "0<=", 0x0037, 0, NULL, NULL }, 389 { "0>", 0x0038, 0, NULL, NULL }, 390 { "0>=", 0x0039, 0, NULL, NULL }, 391 { "<", 0x003a, 0, NULL, NULL }, 392 { ">", 0x003b, 0, NULL, NULL }, 393 { "=", 0x003c, 0, NULL, NULL }, 394 { "<>", 0x003d, 0, NULL, NULL }, 395 { "u>", 0x003e, 0, NULL, NULL }, 396 { "u<=", 0x003f, 0, NULL, NULL }, 397 { "u<", 0x0040, 0, NULL, NULL }, 398 { "u>=", 0x0041, 0, NULL, NULL }, 399 { ">=", 0x0042, 0, NULL, NULL }, 400 { "<=", 0x0043, 0, NULL, NULL }, 401 { "between", 0x0044, 0, NULL, NULL }, 402 { "within", 0x0045, 0, NULL, NULL }, 403 { "drop", 0x0046, 0, NULL, NULL }, 404 { "dup", 0x0047, 0, NULL, NULL }, 405 { "over", 0x0048, 0, NULL, NULL }, 406 { "swap", 0x0049, 0, NULL, NULL }, 407 { "rot", 0x004a, 0, NULL, NULL }, 408 { "-rot", 0x004b, 0, NULL, NULL }, 409 { "tuck", 0x004c, 0, NULL, NULL }, 410 { "nip", 0x004d, 0, NULL, NULL }, 411 { "pick", 0x004e, 0, NULL, NULL }, 412 { "roll", 0x004f, 0, NULL, NULL }, 413 { "?dup", 0x0050, 0, NULL, NULL }, 414 { "depth", 0x0051, 0, NULL, NULL }, 415 { "2drop", 0x0052, 0, NULL, NULL }, 416 { "2dup", 0x0053, 0, NULL, NULL }, 417 { "2over", 0x0054, 0, NULL, NULL }, 418 { "2swap", 0x0055, 0, NULL, NULL }, 419 { "2rot", 0x0056, 0, NULL, NULL }, 420 { "2/", 0x0057, 0, NULL, NULL }, 421 { "u2/", 0x0058, 0, NULL, NULL }, 422 { "2*", 0x0059, 0, NULL, NULL }, 423 { "/c", 0x005a, 0, NULL, NULL }, 424 { "/w", 0x005b, 0, NULL, NULL }, 425 { "/l", 0x005c, 0, NULL, NULL }, 426 { "/n", 0x005d, 0, NULL, NULL }, 427 { "ca+", 0x005e, 0, NULL, NULL }, 428 { "wa+", 0x005f, 0, NULL, NULL }, 429 { "la+", 0x0060, 0, NULL, NULL }, 430 { "na+", 0x0061, 0, NULL, NULL }, 431 { "char+", 0x0062, 0, NULL, NULL }, 432 { "wa1+", 0x0063, 0, NULL, NULL }, 433 { "la1+", 0x0064, 0, NULL, NULL }, 434 { "cell+", 0x0065, 0, NULL, NULL }, 435 { "chars", 0x0066, 0, NULL, NULL }, 436 { "/w*", 0x0067, 0, NULL, NULL }, 437 { "/l*", 0x0068, 0, NULL, NULL }, 438 { "cells", 0x0069, 0, NULL, NULL }, 439 { "on", 0x006a, 0, NULL, NULL }, 440 { "off", 0x006b, 0, NULL, NULL }, 441 { "+!", 0x006c, 0, NULL, NULL }, 442 { "@", 0x006d, 0, NULL, NULL }, 443 { "l@", 0x006e, 0, NULL, NULL }, 444 { "w@", 0x006f, 0, NULL, NULL }, 445 { "<w@", 0x0070, 0, NULL, NULL }, 446 { "c@", 0x0071, 0, NULL, NULL }, 447 { "!", 0x0072, 0, NULL, NULL }, 448 { "l!", 0x0073, 0, NULL, NULL }, 449 { "w!", 0x0074, 0, NULL, NULL }, 450 { "c!", 0x0075, 0, NULL, NULL }, 451 { "2@", 0x0076, 0, NULL, NULL }, 452 { "2!", 0x0077, 0, NULL, NULL }, 453 { "move", 0x0078, 0, NULL, NULL }, 454 { "fill", 0x0079, 0, NULL, NULL }, 455 { "comp", 0x007a, 0, NULL, NULL }, 456 { "noop", 0x007b, 0, NULL, NULL }, 457 { "lwsplit", 0x007c, 0, NULL, NULL }, 458 { "wjoin", 0x007d, 0, NULL, NULL }, 459 { "lbsplit", 0x007e, 0, NULL, NULL }, 460 { "bljoin", 0x007f, 0, NULL, NULL }, 461 { "wbflip", 0x0080, 0, NULL, NULL }, 462 { "upc", 0x0081, 0, NULL, NULL }, 463 { "lcc", 0x0082, 0, NULL, NULL }, 464 { "pack", 0x0083, 0, NULL, NULL }, 465 { "count", 0x0084, 0, NULL, NULL }, 466 { "body>", 0x0085, 0, NULL, NULL }, 467 { ">body", 0x0086, 0, NULL, NULL }, 468 { "fcode-revision", 0x0087, 0, NULL, NULL }, 469 { "span", 0x0088, 0, NULL, NULL }, 470 { "unloop", 0x0089, 0, NULL, NULL }, 471 { "expect", 0x008a, 0, NULL, NULL }, 472 { "alloc-mem", 0x008b, 0, NULL, NULL }, 473 { "free-mem", 0x008c, 0, NULL, NULL }, 474 { "key?", 0x008d, 0, NULL, NULL }, 475 { "key", 0x008e, 0, NULL, NULL }, 476 { "emit", 0x008f, 0, NULL, NULL }, 477 { "type", 0x0090, 0, NULL, NULL }, 478 { "(cr", 0x0091, 0, NULL, NULL }, 479 { "cr", 0x0092, 0, NULL, NULL }, 480 { "#out", 0x0093, 0, NULL, NULL }, 481 { "#line", 0x0094, 0, NULL, NULL }, 482 { "hold", 0x0095, 0, NULL, NULL }, 483 { "<#", 0x0096, 0, NULL, NULL }, 484 { "u#>", 0x0097, 0, NULL, NULL }, 485 { "sign", 0x0098, 0, NULL, NULL }, 486 { "u#", 0x0099, 0, NULL, NULL }, 487 { "u#s", 0x009a, 0, NULL, NULL }, 488 { "u.", 0x009b, 0, NULL, NULL }, 489 { "u.r", 0x009c, 0, NULL, NULL }, 490 { ".", 0x009d, 0, NULL, NULL }, 491 { ".r", 0x009e, 0, NULL, NULL }, 492 { ".s", 0x009f, 0, NULL, NULL }, 493 { "base", 0x00a0, 0, NULL, NULL }, 494 { "convert", 0x00a1, 0, NULL, NULL }, 495 { "$number", 0x00a2, 0, NULL, NULL }, 496 { "digit", 0x00a3, 0, NULL, NULL }, 497 { "-1", 0x00a4, 0, NULL, NULL }, 498 { "true", 0x00a4, 0, NULL, NULL }, 499 { "0", 0x00a5, 0, NULL, NULL }, 500 { "1", 0x00a6, 0, NULL, NULL }, 501 { "2", 0x00a7, 0, NULL, NULL }, 502 { "3", 0x00a8, 0, NULL, NULL }, 503 { "bl", 0x00a9, 0, NULL, NULL }, 504 { "bs", 0x00aa, 0, NULL, NULL }, 505 { "bell", 0x00ab, 0, NULL, NULL }, 506 { "bounds", 0x00ac, 0, NULL, NULL }, 507 { "here", 0x00ad, 0, NULL, NULL }, 508 { "aligned", 0x00ae, 0, NULL, NULL }, 509 { "wbsplit", 0x00af, 0, NULL, NULL }, 510 { "bwjoin", 0x00b0, 0, NULL, NULL }, 511 { "b(<mark)", 0x00b1, 0, NULL, NULL }, 512 { "b(>resolve)", 0x00b2, 0, NULL, NULL }, 513 { "set-token-table", 0x00b3, 0, NULL, NULL }, 514 { "set-table", 0x00b4, 0, NULL, NULL }, 515 { "new-token", 0x00b5, 0, NULL, NULL }, 516 { "named-token", 0x00b6, 0, NULL, NULL }, 517 { "b(:)", 0x00b7, 0, NULL, NULL }, 518 { "b(value)", 0x00b8, 0, NULL, NULL }, 519 { "b(variable)", 0x00b9, 0, NULL, NULL }, 520 { "b(constant)", 0x00ba, 0, NULL, NULL }, 521 { "b(create)", 0x00bb, 0, NULL, NULL }, 522 { "b(defer)", 0x00bc, 0, NULL, NULL }, 523 { "b(buffer:)", 0x00bd, 0, NULL, NULL }, 524 { "b(field)", 0x00be, 0, NULL, NULL }, 525 { "b(code)", 0x00bf, 0, NULL, NULL }, 526 { "instance", 0x00c0, 0, NULL, NULL }, 527 { "b(;)", 0x00c2, 0, NULL, NULL }, 528 { "b(to)", 0x00c3, 0, NULL, NULL }, 529 { "b(case)", 0x00c4, 0, NULL, NULL }, 530 { "b(endcase)", 0x00c5, 0, NULL, NULL }, 531 { "b(endof)", 0x00c6, 0, NULL, NULL }, 532 { "#", 0x00c7, 0, NULL, NULL }, 533 { "#s", 0x00c8, 0, NULL, NULL }, 534 { "#>", 0x00c9, 0, NULL, NULL }, 535 { "external-token", 0x00ca, 0, NULL, NULL }, 536 { "$find", 0x00cb, 0, NULL, NULL }, 537 { "offset16", 0x00cc, 0, NULL, NULL }, 538 { "evaluate", 0x00cd, 0, NULL, NULL }, 539 { "c,", 0x00d0, 0, NULL, NULL }, 540 { "w,", 0x00d1, 0, NULL, NULL }, 541 { "l,", 0x00d2, 0, NULL, NULL }, 542 { ",", 0x00d3, 0, NULL, NULL }, 543 { "um*", 0x00d4, 0, NULL, NULL }, 544 { "um/mod", 0x00d5, 0, NULL, NULL }, 545 { "d+", 0x00d8, 0, NULL, NULL }, 546 { "d-", 0x00d9, 0, NULL, NULL }, 547 { "get-token", 0x00da, 0, NULL, NULL }, 548 { "set-token", 0x00db, 0, NULL, NULL }, 549 { "state", 0x00dc, 0, NULL, NULL }, 550 { "compile,", 0x00dd, 0, NULL, NULL }, 551 { "behavior", 0x00de, 0, NULL, NULL }, 552 { "start0", 0x00f0, 0, NULL, NULL }, 553 { "start1", 0x00f1, 0, NULL, NULL }, 554 { "start2", 0x00f2, 0, NULL, NULL }, 555 { "start4", 0x00f3, 0, NULL, NULL }, 556 { "ferror", 0x00fc, 0, NULL, NULL }, 557 { "version1", 0x00fd, 0, NULL, NULL }, 558 { "4-byte-id", 0x00fe, 0, NULL, NULL }, 559 { "end1", 0x00ff, 0, NULL, NULL }, 560 { "dma-alloc", 0x0101, 0, NULL, NULL }, 561 { "my-address", 0x0102, 0, NULL, NULL }, 562 { "my-space", 0x0103, 0, NULL, NULL }, 563 { "memmap", 0x0104, 0, NULL, NULL }, 564 { "free-virtual", 0x0105, 0, NULL, NULL }, 565 { ">physical", 0x0106, 0, NULL, NULL }, 566 { "my-params", 0x010f, 0, NULL, NULL }, 567 { "property", 0x0110, 0, NULL, NULL }, 568 { "encode-int", 0x0111, 0, NULL, NULL }, 569 { "encode+", 0x0112, 0, NULL, NULL }, 570 { "encode-phys", 0x0113, 0, NULL, NULL }, 571 { "encode-string", 0x0114, 0, NULL, NULL }, 572 { "encode-bytes", 0x0115, 0, NULL, NULL }, 573 { "reg", 0x0116, 0, NULL, NULL }, 574 { "intr", 0x0117, 0, NULL, NULL }, 575 { "driver", 0x0118, 0, NULL, NULL }, 576 { "model", 0x0119, 0, NULL, NULL }, 577 { "device-type", 0x011a, 0, NULL, NULL }, 578 { "parse-2int", 0x011b, 0, NULL, NULL }, 579 { "is-install", 0x011c, 0, NULL, NULL }, 580 { "is-remove", 0x011d, 0, NULL, NULL }, 581 { "is-selftest", 0x011e, 0, NULL, NULL }, 582 { "new-device", 0x011f, 0, NULL, NULL }, 583 { "diagnostic-mode?", 0x0120, 0, NULL, NULL }, 584 { "display-status", 0x0121, 0, NULL, NULL }, 585 { "memory-test-suite", 0x0122, 0, NULL, NULL }, 586 { "group-code", 0x0123, 0, NULL, NULL }, 587 { "mask", 0x0124, 0, NULL, NULL }, 588 { "get-msecs", 0x0125, 0, NULL, NULL }, 589 { "ms", 0x0126, 0, NULL, NULL }, 590 { "finish-device", 0x0127, 0, NULL, NULL }, 591 { "decode-phys", 0x0128, 0, NULL, NULL }, 592 { "map-low", 0x0130, 0, NULL, NULL }, 593 { "sbus-intr>cpu", 0x0131, 0, NULL, NULL }, 594 { "#lines", 0x0150, 0, NULL, NULL }, 595 { "#columns", 0x0151, 0, NULL, NULL }, 596 { "line#", 0x0152, 0, NULL, NULL }, 597 { "column#", 0x0153, 0, NULL, NULL }, 598 { "inverse?", 0x0154, 0, NULL, NULL }, 599 { "inverse-screen?", 0x0155, 0, NULL, NULL }, 600 { "frame-buffer-busy?", 0x0156, 0, NULL, NULL }, 601 { "draw-character", 0x0157, 0, NULL, NULL }, 602 { "reset-screen", 0x0158, 0, NULL, NULL }, 603 { "toggle-cursor", 0x0159, 0, NULL, NULL }, 604 { "erase-screen", 0x015a, 0, NULL, NULL }, 605 { "blink-screen", 0x015b, 0, NULL, NULL }, 606 { "invert-screen", 0x015c, 0, NULL, NULL }, 607 { "insert-characters", 0x015d, 0, NULL, NULL }, 608 { "delete-characters", 0x015e, 0, NULL, NULL }, 609 { "insert-lines", 0x015f, 0, NULL, NULL }, 610 { "delete-lines", 0x0160, 0, NULL, NULL }, 611 { "draw-logo", 0x0161, 0, NULL, NULL }, 612 { "frame-buffer-addr", 0x0162, 0, NULL, NULL }, 613 { "screen-height", 0x0163, 0, NULL, NULL }, 614 { "screen-width", 0x0164, 0, NULL, NULL }, 615 { "window-top", 0x0165, 0, NULL, NULL }, 616 { "window-left", 0x0166, 0, NULL, NULL }, 617 { "default-font", 0x016a, 0, NULL, NULL }, 618 { "set-font", 0x016b, 0, NULL, NULL }, 619 { "char-height", 0x016c, 0, NULL, NULL }, 620 { "char-width", 0x016d, 0, NULL, NULL }, 621 { ">font", 0x016e, 0, NULL, NULL }, 622 { "fontbytes", 0x016f, 0, NULL, NULL }, 623 { "fb8-draw-character", 0x0180, 0, NULL, NULL }, 624 { "fb8-reset-screen", 0x0181, 0, NULL, NULL }, 625 { "fb8-toggle-cursor", 0x0182, 0, NULL, NULL }, 626 { "fb8-erase-screen", 0x0183, 0, NULL, NULL }, 627 { "fb8-blink-screen", 0x0184, 0, NULL, NULL }, 628 { "fb8-invert-screen", 0x0185, 0, NULL, NULL }, 629 { "fb8-insert-characters", 0x0186, 0, NULL, NULL }, 630 { "fb8-delete-characters", 0x0187, 0, NULL, NULL }, 631 { "fb8-inisert-lines", 0x0188, 0, NULL, NULL }, 632 { "fb8-delete-lines", 0x0189, 0, NULL, NULL }, 633 { "fb8-draw-logo", 0x018a, 0, NULL, NULL }, 634 { "fb8-install", 0x018b, 0, NULL, NULL }, 635 { "return-buffer", 0x01a0, 0, NULL, NULL }, 636 { "xmit-packet", 0x01a1, 0, NULL, NULL }, 637 { "poll-packet", 0x01a2, 0, NULL, NULL }, 638 { "mac-address", 0x01a4, 0, NULL, NULL }, 639 { "device-name", 0x0201, 0, NULL, NULL }, 640 { "my-args", 0x0202, 0, NULL, NULL }, 641 { "my-self", 0x0203, 0, NULL, NULL }, 642 { "find-package", 0x0204, 0, NULL, NULL }, 643 { "open-package", 0x0205, 0, NULL, NULL }, 644 { "close-package", 0x0206, 0, NULL, NULL }, 645 { "find-method", 0x0207, 0, NULL, NULL }, 646 { "call-package", 0x0208, 0, NULL, NULL }, 647 { "$call-parent", 0x0209, 0, NULL, NULL }, 648 { "my-parent", 0x020a, 0, NULL, NULL }, 649 { "ihandle>phandle", 0x020b, 0, NULL, NULL }, 650 { "my-unit", 0x020d, 0, NULL, NULL }, 651 { "$call-method", 0x020e, 0, NULL, NULL }, 652 { "$open-package", 0x020f, 0, NULL, NULL }, 653 { "processor-type", 0x0210, 0, NULL, NULL }, 654 { "firmware-version", 0x0211, 0, NULL, NULL }, 655 { "fcode-version", 0x0212, 0, NULL, NULL }, 656 { "alarm", 0x0213, 0, NULL, NULL }, 657 { "(is-user-word)", 0x0214, 0, NULL, NULL }, 658 { "suspend-fcode", 0x0215, 0, NULL, NULL }, 659 { "abort", 0x0216, 0, NULL, NULL }, 660 { "catch", 0x0217, 0, NULL, NULL }, 661 { "throw", 0x0218, 0, NULL, NULL }, 662 { "user-abort", 0x0219, 0, NULL, NULL }, 663 { "get-my-property", 0x021a, 0, NULL, NULL }, 664 { "decode-int", 0x021b, 0, NULL, NULL }, 665 { "decode-string", 0x021c, 0, NULL, NULL }, 666 { "get-inherited-property", 0x021d, 0, NULL, NULL }, 667 { "delete-property", 0x021e, 0, NULL, NULL }, 668 { "get-package-property", 0x021f, 0, NULL, NULL }, 669 { "cpeek", 0x0220, 0, NULL, NULL }, 670 { "wpeek", 0x0221, 0, NULL, NULL }, 671 { "lpeek", 0x0222, 0, NULL, NULL }, 672 { "cpoke", 0x0223, 0, NULL, NULL }, 673 { "wpoke", 0x0224, 0, NULL, NULL }, 674 { "lpoke", 0x0225, 0, NULL, NULL }, 675 { "lwflip", 0x0226, 0, NULL, NULL }, 676 { "lbflip", 0x0227, 0, NULL, NULL }, 677 { "lbflips", 0x0228, 0, NULL, NULL }, 678 { "adr-mask", 0x0229, 0, NULL, NULL }, 679 { "rb@", 0x0230, 0, NULL, NULL }, 680 { "rb!", 0x0231, 0, NULL, NULL }, 681 { "rw@", 0x0232, 0, NULL, NULL }, 682 { "rw!", 0x0233, 0, NULL, NULL }, 683 { "rl@", 0x0234, 0, NULL, NULL }, 684 { "rl!", 0x0235, 0, NULL, NULL }, 685 { "wbflips", 0x0236, 0, NULL, NULL }, 686 { "lwflips", 0x0237, 0, NULL, NULL }, 687 { "probe", 0x0238, 0, NULL, NULL }, 688 { "probe-virtual", 0x0239, 0, NULL, NULL }, 689 { "child", 0x023b, 0, NULL, NULL }, 690 { "peer", 0x023c, 0, NULL, NULL }, 691 { "next-property", 0x023d, 0, NULL, NULL }, 692 { "byte-load", 0x023e, 0, NULL, NULL }, 693 { "set-args", 0x023f, 0, NULL, NULL }, 694 { "left-parse-string", 0x0240, 0, NULL, NULL }, 695 /* 64-bit FCode extensions */ 696 { "bxjoin", 0x0241, 0, NULL, NULL }, 697 { "<l@", 0x0242, 0, NULL, NULL }, 698 { "lxjoin", 0x0243, 0, NULL, NULL }, 699 { "rx@", 0x022e, 0, NULL, NULL }, 700 { "rx!", 0x022f, 0, NULL, NULL }, 701 { "wxjoin", 0x0244, 0, NULL, NULL }, 702 { "x,", 0x0245, 0, NULL, NULL }, 703 { "x@", 0x0246, 0, NULL, NULL }, 704 { "x!", 0x0247, 0, NULL, NULL }, 705 { "/x", 0x0248, 0, NULL, NULL }, 706 { "/x*", 0x0249, 0, NULL, NULL }, 707 { "xa+", 0x024a, 0, NULL, NULL }, 708 { "xa1+", 0x024b, 0, NULL, NULL }, 709 { "xbflip", 0x024c, 0, NULL, NULL }, 710 { "xbflips", 0x024d, 0, NULL, NULL }, 711 { "xbsplit", 0x024e, 0, NULL, NULL }, 712 { "xlflip", 0x024f, 0, NULL, NULL }, 713 { "xlflips", 0x0250, 0, NULL, NULL }, 714 { "xlsplit", 0x0251, 0, NULL, NULL }, 715 { "xwflip", 0x0252, 0, NULL, NULL }, 716 { "xwflips", 0x0253, 0, NULL, NULL }, 717 { "xwsplit", 0x0254, 0, NULL, NULL }, 718 { NULL, 0, 0, NULL, NULL } 719 }; 720 721 /* 722 * Default macros -- can be overridden by colon definitions. 723 */ 724 static struct macro macros[] = { 725 { "eval", "evaluate", 0, NULL, NULL }, /* Build a more balanced tree */ 726 { "(.)", "dup abs <# u#s swap sign u#>", 0, NULL, NULL }, 727 { "<<", "lshift", 0, NULL, NULL }, 728 { ">>", "rshift", 0, NULL, NULL }, 729 { "?", "@ .", 0, NULL, NULL }, 730 { "1+", "1 +", 0, NULL, NULL }, 731 { "1-", "1 -", 0, NULL, NULL }, 732 { "2+", "2 +", 0, NULL, NULL }, 733 { "2-", "2 -", 0, NULL, NULL }, 734 { "abort\"", "-2 throw", 0, NULL, NULL }, 735 { "accept", "span @ -rot expect span @ swap span !", 0, NULL, NULL }, 736 { "allot", "0 max 0 ?do 0 c, loop", 0, NULL, NULL }, 737 { "blank", "bl fill", 0, NULL, NULL }, 738 { "/c*", "chars", 0, NULL, NULL }, 739 { "ca1+", "char+", 0, NULL, NULL }, 740 { "carret", "b(lit) 00 00 00 h# 0d", 0, NULL, NULL }, 741 { ".d", "base @ swap d# 0a base ! . base !", 0, NULL, NULL }, 742 { "decode-bytes", ">r over r@ + swap r@ - rot r>", 0, NULL, NULL }, 743 { "3drop", "drop 2drop", 0, NULL, NULL }, 744 { "3dup", "2 pick 2 pick 2 pick", 0, NULL, NULL }, 745 { "erase", "0 fill", 0, NULL, NULL }, 746 { "false", "0", 0, NULL, NULL }, 747 { ".h", "base @ swap d# 10 base ! . base !", 0, NULL, NULL }, 748 { "linefeed", "b(lit) 00 00 00 d# 0a", 0, NULL, NULL }, 749 { "/n*", "cells", 0, NULL, NULL }, 750 { "na1+", "cell+", 0, NULL, NULL }, 751 { "not", "invert", 0, NULL, NULL }, 752 { "s.", "(.) type space", 0, NULL, NULL }, 753 { "space", "bl emit", 0, NULL, NULL }, 754 { "spaces", "0 max 0 ?do space loop", 0, NULL, NULL }, 755 { "struct", "0", 0, NULL, NULL }, 756 { "true", "-1", 0, NULL, NULL }, 757 { "(u,)", "<# u#s u#>", 0, NULL, NULL }, 758 { NULL, NULL, 0, NULL, NULL } 759 }; 760 761 /* 762 * Utility functions. 763 */ 764 765 /* 766 * ASCII -> long int converter, eats `.'s 767 */ 768 #define strtol(x, y, z) cvt(x, y, z) 769 static Cell 770 cvt(const char *s, char **e, int base) 771 { 772 Cell v = 0; 773 int c, n = 0; 774 775 c = *s; 776 if (c == '-') { n = 1; s++; } 777 778 for (c = *s; (c = *s); s++) { 779 780 /* Ignore `.' */ 781 if (c == '.') 782 continue; 783 if (c >= '0' && c <= '9') 784 c -= '0'; 785 else if (c >= 'a' && c <= 'f') 786 c += 10 - 'a'; 787 else if (c >= 'A' && c <= 'F') 788 c += 10 - 'A'; 789 if (c >= base) 790 break; 791 v *= base; 792 v += c; 793 } 794 if (e) 795 *e = (char *)s; 796 if (n) 797 return (-v); 798 return (v); 799 } 800 801 /* 802 * Parser stack control functions. 803 */ 804 805 static void 806 push(Cell val) 807 { 808 if (debug > 1) 809 printf("push %lx\n", (long)val); 810 parse_stack[parse_stack_ptr++] = val; 811 if (parse_stack_ptr >= PSTKSIZ) 812 errx(EXIT_FAILURE, "Parse stack overflow"); 813 } 814 815 static Cell 816 pop(void) 817 { 818 ASSERT(parse_stack_ptr); 819 if (debug > 1) 820 printf("pop %lx\n", (long)parse_stack[parse_stack_ptr-1]); 821 return parse_stack[--parse_stack_ptr]; 822 } 823 824 static int 825 depth(void) 826 { 827 return (parse_stack_ptr); 828 } 829 830 /* 831 * Insert fcode into dictionary. 832 */ 833 static int 834 fadd(struct fcode *dict, struct fcode *new) 835 { 836 int res = strcmp(dict->name, new->name); 837 838 new->type = FCODE; 839 ASSERT(dict->type == FCODE); 840 if (!res) { 841 /* 842 * Duplicate entry. Give the old name the new FCode 843 * number. 844 */ 845 dict->num = new->num; 846 return (0); 847 } 848 if (res < 0) { 849 if (dict->l) 850 return fadd(dict->l, new); 851 else { 852 if (debug > 5) 853 printf("fadd: new FCode `%s' is %lx\n", 854 new->name, new->num); 855 new->l = new->r = NULL; 856 dict->l = new; 857 } 858 } else { 859 if (dict->r) 860 return fadd(dict->r, new); 861 else { 862 if (debug > 5) 863 printf("fadd: new FCode `%s' is %lx\n", 864 new->name, new->num); 865 new->l = new->r = NULL; 866 dict->r = new; 867 } 868 } 869 return (1); 870 } 871 872 /* 873 * Look for a code in the dictionary. 874 */ 875 static struct fcode * 876 flookup(struct fcode *dict, const char *str) 877 { 878 int res; 879 if (!dict) return (dict); 880 881 res = strcmp(dict->name, str); 882 ASSERT(dict->type == FCODE); 883 if (debug > 5) 884 printf("flookup: `%s' and `%s' %s match\n", 885 str, dict->name, res?"don't":"do"); 886 if (!res) return (dict); 887 if (res < 0) 888 return (flookup(dict->l, str)); 889 else 890 return (flookup(dict->r, str)); 891 892 } 893 894 /* 895 * Insert alias into macros. 896 */ 897 static int 898 aadd(struct macro *dict, struct macro *new) 899 { 900 int res = strcmp(dict->name, new->name); 901 902 new->type = MACRO; 903 ASSERT(dict->type == MACRO); 904 if (!res) { 905 /* Duplicate name. Replace the old macro */ 906 dict->equiv = new->equiv; 907 /* We can't free the old equiv since it may be static data. */ 908 return (0); 909 } 910 if (res < 0) { 911 if (dict->l) 912 return aadd(dict->l, new); 913 else { 914 new->l = new->r = NULL; 915 dict->l = new; 916 if (debug > 5) 917 printf("aadd: new alias `%s' to `%s'\n", 918 new->name, new->equiv); 919 } 920 } else { 921 if (dict->r) 922 return aadd(dict->r, new); 923 else { 924 new->l = new->r = NULL; 925 dict->r = new; 926 if (debug > 5) 927 printf("aadd: new alias `%s' to `%s'\n", 928 new->name, new->equiv); 929 } 930 } 931 return (1); 932 } 933 934 /* 935 * Look for a macro in the aliases. 936 */ 937 static struct macro * 938 alookup(struct macro *dict, const char *str) 939 { 940 int res; 941 if (!dict) return (dict); 942 943 ASSERT(dict->type == MACRO); 944 res = strcmp(dict->name, str); 945 if (!res) return (dict); 946 if (res < 0) 947 return (alookup(dict->l, str)); 948 else 949 return (alookup(dict->r, str)); 950 951 } 952 953 /* 954 * Bootstrap the dictionary and then install 955 * all the standard FCodes. 956 */ 957 static void 958 initdic(void) 959 { 960 struct fcode *code = fcodes; 961 struct macro *alias = macros; 962 963 ASSERT(dictionary == NULL); 964 code->l = code->r = NULL; 965 dictionary = code; 966 code->type = FCODE; 967 968 while ((++code)->name) { 969 if(!fadd(dictionary, code)) { 970 warnx("%s: duplicate dictionary entry `%s'", __func__, 971 code->name); 972 } 973 } 974 975 ASSERT(aliases == NULL); 976 aliases = alias; 977 alias->l = alias->r = NULL; 978 alias->type = MACRO; 979 while ((++alias)->name) { 980 if(!aadd(aliases, alias)) { 981 warnx("%s: duplicate macro entry `%s'", __func__, 982 alias->name); 983 } 984 } 985 986 } 987 988 static int 989 apply_macros(YY_BUFFER_STATE yinput, const char *str) 990 { 991 struct macro *xform = alookup(aliases, str); 992 993 if (xform) { 994 YY_BUFFER_STATE newbuf; 995 996 if (debug > 1) 997 printf("Expanding %s to %s\n", str, xform->equiv); 998 999 newbuf = yy_scan_string(xform->equiv); 1000 yy_switch_to_buffer(newbuf); 1001 tokenize(newbuf); 1002 yy_switch_to_buffer(yinput); 1003 yy_delete_buffer(newbuf); 1004 } 1005 return (xform != NULL); 1006 } 1007 1008 static void 1009 usage(void) 1010 { 1011 (void)fprintf(stderr, "%s: [-d level] [-o outfile] <infile>\n", 1012 getprogname()); 1013 exit(EXIT_FAILURE); 1014 } 1015 1016 int 1017 main(int argc, char *argv[]) 1018 { 1019 int ch; 1020 FILE *inf; 1021 struct fcode_header *fheader; 1022 YY_BUFFER_STATE inbuf; 1023 const char *hdrtype = "version1"; 1024 int i; 1025 1026 outf = 1; /* stdout */ 1027 1028 while ((ch = getopt(argc, argv, "d:o:")) != -1) 1029 switch(ch) { 1030 case 'd': 1031 mark_fload = 1; 1032 debug = atol(optarg); 1033 break; 1034 case 'o': 1035 outfile = optarg; 1036 break; 1037 default: 1038 usage(); 1039 } 1040 argc -= optind; 1041 argv += optind; 1042 1043 if (argc != 1) 1044 usage(); 1045 1046 infile = argv[0]; 1047 1048 /* 1049 * Initialization stuff. 1050 */ 1051 initdic(); 1052 outbufsiz = BUFCLICK; 1053 fheader = emalloc(outbufsiz); 1054 outbuf = (void *)fheader; 1055 outpos = 0; 1056 emit(hdrtype); 1057 outpos = sizeof(*fheader); 1058 1059 /* 1060 * Do it. 1061 */ 1062 if ((inf = fopen(infile, "r")) == NULL) 1063 err(EXIT_FAILURE, "Cannot open `%s'", infile); 1064 1065 inbuf = yy_create_buffer(inf, YY_BUF_SIZE); 1066 yy_switch_to_buffer(inbuf); 1067 tokenize(inbuf); 1068 yy_delete_buffer(inbuf); 1069 fclose(inf); 1070 if (need_end0) emit("end0"); 1071 1072 /* Now calculate length and checksum and stick them in the header */ 1073 fheader->format = 0x08; 1074 fheader->length = htonl(outpos); 1075 fheader->checksum = 0; 1076 for (i = sizeof(*fheader); i<outpos; i++) 1077 fheader->checksum += (unsigned char)outbuf[i]; 1078 fheader->checksum = htons(fheader->checksum); 1079 1080 if ((outf = open(outfile, O_WRONLY|O_CREAT|O_TRUNC, 0666)) == -1) 1081 err(EXIT_FAILURE, "Cannot open `%s'", outfile); 1082 1083 if (write(outf, outbuf, outpos) != outpos) { 1084 int serrno = errno; 1085 close(outf); 1086 unlink(outfile); 1087 errc(EXIT_FAILURE, serrno, "write error"); 1088 } 1089 close(outf); 1090 return EXIT_SUCCESS; 1091 }; 1092 1093 /* 1094 * Tokenize one file. This is a separate function so it can 1095 * be called recursively to parse mutiple levels of include files. 1096 */ 1097 1098 static void 1099 tokenize(YY_BUFFER_STATE yinput) 1100 { 1101 FILE *inf; 1102 YY_BUFFER_STATE inbuf; 1103 TOKEN *token; 1104 const char *last_token = ""; 1105 struct fcode *fcode; 1106 int pos, off; 1107 1108 while ((token = yylex()) != NULL) { 1109 switch (token->type) { 1110 case TOK_NUMBER: 1111 STATE(token->text, "TOK_NUMBER"); 1112 { 1113 char *end; 1114 Cell value; 1115 1116 if (tokenizer) { 1117 push(strtol(token->text, &end, 16)); 1118 break; 1119 } 1120 value = strtol(token->text, &end, numbase); 1121 if (*end != 0) 1122 token_err(yylineno, infile, yytext, 1123 "illegal number conversion"); 1124 1125 /* 1126 * If this is a 64-bit value we need to store two literals 1127 * and issue a `lxjoin' to combine them. But that's a future 1128 * project. 1129 */ 1130 emit("b(lit)"); 1131 spit((value>>24)&0x0ff); 1132 spit((value>>16)&0x0ff); 1133 spit((value>>8)&0x0ff); 1134 spit(value&0x0ff); 1135 if ((value>>32) != value && (value>>32) != 0 && 1136 (value>>32) != -1) { 1137 emit("b(lit)"); 1138 spit((value>>56)&0x0ff); 1139 spit((value>>48)&0x0ff); 1140 spit((value>>40)&0x0ff); 1141 spit((value>>32)&0x0ff); 1142 emit("lxjoin"); 1143 } 1144 } 1145 break; 1146 case TOK_C_LIT: 1147 STATE(token->text, "TOK_C_LIT"); 1148 emit("b(lit)"); 1149 spit(0); 1150 spit(0); 1151 spit(0); 1152 spit(token->text[1]); 1153 break; 1154 case TOK_STRING_LIT: 1155 STATE(token->text, "TOK_STRING_LIT:"); 1156 { 1157 size_t len; 1158 char *p = token->text; 1159 1160 ++p; /* Skip the quote */ 1161 len = strlen(++p); /* Skip the 1st space */ 1162 1163 #define ERR_TOOLONG \ 1164 token_err(yylineno, infile, yytext, "string length %zu too long", len) 1165 1166 if (len > 255) 1167 ERR_TOOLONG; 1168 1169 if (p[len-1] == ')' || 1170 p[len-1] == '"') { 1171 p[len-1] = 0; 1172 } 1173 emit("b(\")"); 1174 sspit(p); 1175 } 1176 break; 1177 case TOK_PSTRING: 1178 STATE(token->text, "TOK_PSTRING:"); 1179 { 1180 size_t len; 1181 char *p = token->text; 1182 1183 if (*p++ == '.') p++; /* Skip over delimiter */ 1184 p++; /* Skip over space/tab */ 1185 1186 len = strlen(p); 1187 if (len > 255) 1188 ERR_TOOLONG; 1189 1190 if (p[len-1] == ')' || 1191 p[len-1] == '"') { 1192 p[len-1] = 0; 1193 } 1194 emit("b(\")"); 1195 sspit(p); 1196 emit("type"); 1197 } 1198 break; 1199 case TOK_ABORT_S: 1200 STATE(token->text, "TOK_PSTRING:"); 1201 { 1202 size_t len; 1203 Cell value = -2; 1204 char *p = token->text; 1205 1206 while (*p++ != ' '); /* Skip to the string */ 1207 1208 len = strlen(p); 1209 if (len > 255) 1210 ERR_TOOLONG; 1211 1212 if (p[len-1] == '"') { 1213 p[len-1] = 0; 1214 } 1215 emit("b?branch"); 1216 push(outpos); 1217 offspit(0); 1218 emit("b(\")"); 1219 sspit(p); 1220 emit("type"); 1221 emit("cr"); 1222 emit("b(lit)"); 1223 spit((value>>24)&0x0ff); 1224 spit((value>>16)&0x0ff); 1225 spit((value>>8)&0x0ff); 1226 spit(value&0x0ff); 1227 emit("throw"); 1228 emit("b(>resolve)"); 1229 pos = outpos; 1230 outpos = pop(); 1231 off = pos - outpos; 1232 offspit(off); 1233 outpos = pos; 1234 } 1235 break; 1236 1237 case TOK_TOKENIZE: 1238 STATE(token->text, "TOK_TOKENIZE"); 1239 /* The next pass should tokenize the FCODE number */ 1240 emit("b(')"); 1241 break; 1242 case TOK_COMMENT: 1243 STATE(token->text, "TOK_COMMENT:"); 1244 do { 1245 off = input(); 1246 } while ((off != ')') && (off != '\n') && 1247 (off != EOF)); 1248 break; 1249 case TOK_COLON: 1250 STATE(token->text, "TOK_COLON:"); 1251 1252 token = yylex(); 1253 if (token == NULL) 1254 token_err(yylineno, infile, yytext, 1255 "EOF in colon definition"); 1256 1257 /* Add new code to dictionary */ 1258 fcode = emalloc(sizeof(*fcode)); 1259 fcode->num = nextfcode++; 1260 fcode->name = estrdup(token->text); 1261 if (!fadd(dictionary, fcode)) { 1262 /* Duplicate definition. Free the memory. */ 1263 if (debug) 1264 printf("%s: duplicate FCode\n", 1265 token->text); 1266 free((void *)fcode->name); 1267 free(fcode); 1268 } 1269 if (debug) 1270 printf("Adding %s to dictionary\n", token->text); 1271 if (state == 0) 1272 emit("new-token"); 1273 else { 1274 if (state == TOK_EXTERNAL) 1275 emit("external-token"); 1276 else 1277 /* Here we have a choice of new-token or named-token */ 1278 emit("named-token"); 1279 sspit(token->text); 1280 } 1281 spit(fcode->num); 1282 emit("b(:)"); 1283 last_token = fcode->name; 1284 defining = 1; 1285 break; 1286 case TOK_SEMICOLON: 1287 STATE(token->text, "TOK_SEMICOLON:"); 1288 emit("b(;)"); 1289 defining = 0; 1290 if (depth()) { 1291 token_err(yylineno, infile, NULL, 1292 "Warning: stack depth %d at end of %s\n", 1293 depth(), last_token); 1294 } 1295 last_token = ""; 1296 break; 1297 1298 /* These are special */ 1299 case TOK_AGAIN: 1300 STATE(token->text, "TOK_AGAIN"); 1301 emit("bbranch"); 1302 pos = pop(); 1303 pos = pos - outpos; 1304 offspit(pos); 1305 break; 1306 case TOK_ALIAS: 1307 STATE(token->text, "TOK_ALIAS"); 1308 { 1309 struct macro *alias; 1310 1311 token = yylex(); 1312 if (token == NULL) { 1313 warnx("EOF in alias definition"); 1314 return; 1315 } 1316 if (token->type != TOK_OTHER) { 1317 warnx("ENDCOMMENT aliasing weird token type %d", 1318 token->type); 1319 } 1320 alias = emalloc(sizeof(*alias)); 1321 alias->name = estrdup(token->text); 1322 token = yylex(); 1323 if (token == NULL) { 1324 warnx("EOF in alias definition"); 1325 free((void *)alias->name); 1326 free(alias); 1327 return; 1328 } 1329 alias->equiv = estrdup(token->text); 1330 if (!aadd(aliases, alias)) { 1331 free((void *)alias->name); 1332 free(alias); 1333 } 1334 } 1335 break; 1336 case TOK_GETTOKEN: 1337 STATE(token->text, "TOK_GETTOKEN"); 1338 /* This is caused by ['] */ 1339 emit("b(')"); 1340 token = yylex(); 1341 if (token == NULL) { 1342 warnx("EOF in [']"); 1343 return; 1344 } 1345 if ((fcode = flookup(dictionary, token->text)) == NULL) 1346 errx(EXIT_FAILURE, "[']: %s not found", 1347 token->text); 1348 spit(fcode->num); 1349 break; 1350 case TOK_ASCII: 1351 STATE(token->text, "TOK_ASCII"); 1352 token = yylex(); 1353 if (token == NULL) 1354 errx(EXIT_FAILURE, "EOF after \"ascii\""); 1355 emit("b(lit)"); 1356 spit(0); 1357 spit(0); 1358 spit(0); 1359 spit(token->text[0]); 1360 break; 1361 case TOK_BEGIN: 1362 STATE(token->text, "TOK_BEGIN"); 1363 emit("b(<mark)"); 1364 push(outpos); 1365 break; 1366 case TOK_BUFFER: 1367 STATE(token->text, "TOK_BUFFER"); 1368 1369 token = yylex(); 1370 if (token == NULL) { 1371 warnx("EOF in colon definition"); 1372 return; 1373 } 1374 1375 /* Add new code to dictionary */ 1376 fcode = emalloc(sizeof(*fcode)); 1377 fcode->num = nextfcode++; 1378 fcode->name = estrdup(token->text); 1379 fadd(dictionary, fcode); 1380 1381 if (state == 0) 1382 emit("new-token"); 1383 else { 1384 if (state == TOK_EXTERNAL) 1385 emit("external-token"); 1386 else 1387 /* Here we have a choice of new-token or named-token */ 1388 emit("named-token"); 1389 sspit(token->text); 1390 } 1391 spit(fcode->num); 1392 emit("b(buffer:)"); 1393 break; 1394 case TOK_CASE: 1395 STATE(token->text, "TOK_CASE"); 1396 emit("b(case)"); 1397 push(0); 1398 break; 1399 case TOK_CONSTANT: 1400 STATE(token->text, "TOK_CONSTANT"); 1401 1402 token = yylex(); 1403 if (token == NULL) { 1404 warnx("EOF in constant definition"); 1405 return; 1406 } 1407 1408 /* Add new code to dictionary */ 1409 fcode = emalloc(sizeof(*fcode)); 1410 fcode->num = nextfcode++; 1411 fcode->name = estrdup(token->text); 1412 fadd(dictionary, fcode); 1413 1414 if (state == 0) 1415 emit("new-token"); 1416 else { 1417 if (state == TOK_EXTERNAL) 1418 emit("external-token"); 1419 else 1420 /* Here we have a choice of new-token or named-token */ 1421 emit("named-token"); 1422 sspit(token->text); 1423 } 1424 spit(fcode->num); 1425 emit("b(constant)"); 1426 break; 1427 case TOK_CONTROL: 1428 STATE(token->text, "TOK_CONTROL"); 1429 token = yylex(); 1430 if (token == NULL) 1431 errx(EXIT_FAILURE, "EOF after \"ascii\""); 1432 emit("b(lit)"); 1433 spit(0); 1434 spit(0); 1435 spit(0); 1436 spit(token->text[0]&0x1f); 1437 break; 1438 case TOK_CREATE: 1439 STATE(token->text, "TOK_CREATE"); 1440 /* Don't know what this does or if it's right */ 1441 token = yylex(); 1442 if (token == NULL) { 1443 warnx("EOF in create definition"); 1444 return; 1445 } 1446 1447 /* Add new code to dictionary */ 1448 fcode = emalloc(sizeof(*fcode)); 1449 fcode->num = nextfcode++; 1450 fcode->name = estrdup(token->text); 1451 fadd(dictionary, fcode); 1452 1453 if (state == 0) 1454 emit("new-token"); 1455 else { 1456 if (state == TOK_EXTERNAL) 1457 emit("external-token"); 1458 else 1459 /* Here we have a choice of new-token or named-token */ 1460 emit("named-token"); 1461 sspit(token->text); 1462 } 1463 spit(fcode->num); 1464 emit("b(create)"); 1465 break; 1466 case TOK_DECIMAL: 1467 STATE(token->text, "TOK_DECIMAL"); 1468 if (token->text[1] != '#') { 1469 if (defining) { 1470 emit("b(lit)"); 1471 spit(0); 1472 spit(0); 1473 spit(0); 1474 spit(10); 1475 emit("base"); 1476 emit("!"); 1477 } else 1478 numbase = TOK_DECIMAL; 1479 } else { 1480 char *end; 1481 Cell value; 1482 1483 token = yylex(); 1484 if (token == NULL) { 1485 warnx("EOF after d#"); 1486 return; 1487 } 1488 if (token->type == TOK_OTHER) { 1489 if (strcmp("-1", token->text) == 0) { 1490 emit(token->text); 1491 break; 1492 } 1493 } 1494 value = strtol(token->text, &end, 10); 1495 if (*end != 0) 1496 token_err(yylineno, infile, NULL, 1497 "Illegal number conversion: %s", token->text); 1498 1499 /* 1500 * If this is a 64-bit value we need to store two literals 1501 * and issue a `lxjoin' to combine them. But that's a future 1502 * project. 1503 */ 1504 emit("b(lit)"); 1505 spit((value>>24)&0x0ff); 1506 spit((value>>16)&0x0ff); 1507 spit((value>>8)&0x0ff); 1508 spit(value&0x0ff); 1509 if ((value>>32) != value && (value>>32) != 0) { 1510 emit("b(lit)"); 1511 spit((value>>56)&0x0ff); 1512 spit((value>>48)&0x0ff); 1513 spit((value>>40)&0x0ff); 1514 spit((value>>32)&0x0ff); 1515 emit("lxjoin"); 1516 } 1517 } 1518 break; 1519 case TOK_DEFER: 1520 STATE(token->text, "TOK_DEFER"); 1521 /* Don't know what this does or if it's right */ 1522 token = yylex(); 1523 if (token == NULL) { 1524 warnx("EOF in colon definition"); 1525 return; 1526 } 1527 1528 /* Add new code to dictionary */ 1529 fcode = emalloc(sizeof(*fcode)); 1530 fcode->num = nextfcode++; 1531 fcode->name = estrdup(token->text); 1532 fadd(dictionary, fcode); 1533 1534 if (state == 0) 1535 emit("new-token"); 1536 else { 1537 if (state == TOK_EXTERNAL) 1538 emit("external-token"); 1539 else 1540 /* Here we have a choice of new-token or named-token */ 1541 emit("named-token"); 1542 sspit(token->text); 1543 } 1544 spit(fcode->num); 1545 emit("b(defer)"); 1546 break; 1547 case TOK_DO: 1548 STATE(token->text, "TOK_DO"); 1549 /* 1550 * From the 1275 spec. B is branch location, T is branch target. 1551 * 1552 * b(do) offset1 ... b(loop) offset2 ... 1553 * b(do) offset1 ... b(+loop) offset2 ... 1554 * b(?do) offset1 ... b(loop) offset2 ... 1555 * b(?do) offset1 ... b(+loop) offset2 ... 1556 * ^ ^ 1557 * B1 ^ ^ T1 1558 * T2 B2 1559 * 1560 * How we do this is we generate the b(do) or b(?do), spit out a 1561 * zero offset while remembering b1 and t2. Then we call tokenize() 1562 * to generate the body. When tokenize() finds a b(loop) or b(+loop), 1563 * it generates the FCode and returns, with outpos at b2. We then 1564 * calculate the offsets, put them in the right slots and finishup. 1565 */ 1566 1567 if (token->text[0] == '?') 1568 emit("b(?do)"); 1569 else 1570 emit("b(do)"); 1571 push(outpos); 1572 offspit(0); /* Place holder for later */ 1573 push(outpos); 1574 break; 1575 case TOK_END0: 1576 STATE(token->text, "TOK_END0"); 1577 emit("end0"); 1578 /* Remember we already generated end0 */ 1579 need_end0 = 0; 1580 break; 1581 case TOK_ELSE: 1582 STATE(token->text, "TOK_ELSE"); 1583 /* Get where we need to patch */ 1584 off = pop(); 1585 emit("bbranch"); 1586 /* Save where we are now. */ 1587 push(outpos); 1588 offspit(0); /* Place holder for later */ 1589 emit("b(>resolve)"); 1590 /* Rewind and patch the if branch */ 1591 pos = outpos; 1592 outpos = off; 1593 off = pos - off; 1594 offspit(off); /* Place holder for later */ 1595 /* revert to the end */ 1596 outpos = pos; 1597 break; 1598 case TOK_ENDCASE: 1599 STATE(token->text, "TOK_ENDCASE:"); 1600 emit("b(endcase)"); 1601 pos = outpos; /* Remember where we need to branch to */ 1602 1603 /* Thread our way backwards and install proper offsets */ 1604 off = pop(); 1605 while (off) { 1606 int disp; 1607 int next; 1608 1609 /* Move to this offset */ 1610 outpos = off; 1611 /* Load next offset to process */ 1612 disp = (signed char)(outbuf[outpos]); 1613 if (offsetsize == 16) { 1614 disp = (disp << 8) | 1615 (unsigned char)outbuf[outpos+1]; 1616 } 1617 next = outpos + disp; 1618 if (debug > -3) 1619 printf("Next endof: %x at %x\n", 1620 disp, next); 1621 1622 /* process this offset */ 1623 off = pos - outpos; 1624 offspit(off); 1625 if ((off = disp)) 1626 off = next; 1627 } 1628 outpos = pos; 1629 break; 1630 case TOK_ENDOF: 1631 STATE(token->text, "TOK_ENDOF"); 1632 off = pop(); 1633 emit("b(endof)"); 1634 /* 1635 * Save back pointer in the offset field so we can traverse 1636 * the linked list and patch it in the endcase. 1637 */ 1638 pos = pop(); /* get position of prev link. */ 1639 push(outpos); /* save position of this link. */ 1640 if (pos) 1641 /* save potision of prev link. */ 1642 offspit(pos - outpos); 1643 else 1644 /* This is the first statement */ 1645 offspit(0); 1646 pos = outpos; 1647 /* Now point the offset from b(of) here. */ 1648 outpos = off; 1649 off = pos - off; 1650 offspit(off); 1651 /* Restore position */ 1652 outpos = pos; 1653 break; 1654 case TOK_EXTERNAL: 1655 STATE(token->text, "TOK_EXTERNAL"); 1656 state = TOK_EXTERNAL; 1657 break; 1658 case TOK_FCODE_VERSION2: 1659 /* This is actually a tokenizer directive. */ 1660 STATE(token->text, "TOK_FCODE_VERSION2"); 1661 offsetsize = 16; 1662 pos = outpos; 1663 outpos = 0; 1664 emit("start1"); 1665 outpos = pos; 1666 break; 1667 case TOK_FCODE_END: 1668 /* 1669 * Another tokenizer directive. 1670 * 1671 * This should generate end0 and finish filling in 1672 * the FCode header. But that's all done in main(). 1673 */ 1674 STATE(token->text, "TOK_FCODE_END"); 1675 return; 1676 case TOK_FIELD: 1677 STATE(token->text, "TOK_FIELD"); 1678 1679 token = yylex(); 1680 if (token == NULL) { 1681 warnx("EOF in field definition"); 1682 return; 1683 } 1684 1685 /* Add new code to dictionary */ 1686 fcode = emalloc(sizeof(*fcode)); 1687 fcode->num = nextfcode++; 1688 fcode->name = estrdup(token->text); 1689 fadd(dictionary, fcode); 1690 1691 if (state == 0) 1692 emit("new-token"); 1693 else { 1694 if (state == TOK_EXTERNAL) 1695 emit("external-token"); 1696 else 1697 /* Here we have a choice of new-token or named-token */ 1698 emit("named-token"); 1699 sspit(token->text); 1700 } 1701 spit(fcode->num); 1702 emit("b(field)"); 1703 break; 1704 1705 case TOK_HEX: 1706 STATE(token->text, "TOK_HEX"); 1707 if (token->text[1] != '#') { 1708 if (defining) { 1709 emit("b(lit)"); 1710 spit(0); 1711 spit(0); 1712 spit(0); 1713 spit(16); 1714 emit("base"); 1715 emit("!"); 1716 } else 1717 numbase = TOK_HEX; 1718 } else { 1719 char *end; 1720 Cell value; 1721 1722 token = yylex(); 1723 if (token == NULL) { 1724 warnx("EOF after h#"); 1725 return; 1726 } 1727 value = strtol(token->text, &end, 16); 1728 if (*end != 0) 1729 errx(EXIT_FAILURE, "Illegal number" 1730 " conversion:%s:%d: %s\n", 1731 infile, yylineno, yytext); 1732 /* 1733 * If this is a 64-bit value we need to store two literals 1734 * and issue a `lxjoin' to combine them. But that's a future 1735 * project. 1736 */ 1737 emit("b(lit)"); 1738 spit((value>>24)&0x0ff); 1739 spit((value>>16)&0x0ff); 1740 spit((value>>8)&0x0ff); 1741 spit(value&0x0ff); 1742 if ((value>>32) != value && (value>>32) != 0) { 1743 emit("b(lit)"); 1744 spit((value>>56)&0x0ff); 1745 spit((value>>48)&0x0ff); 1746 spit((value>>40)&0x0ff); 1747 spit((value>>32)&0x0ff); 1748 emit("lxjoin"); 1749 } 1750 } 1751 break; 1752 case TOK_HEADERLESS: 1753 STATE(token->text, "TOK_HEADERLESS"); 1754 state = 0; 1755 break; 1756 case TOK_HEADERS: 1757 STATE(token->text, "TOK_HEADERS"); 1758 state = TOK_HEADERS; 1759 break; 1760 case TOK_IF: 1761 STATE(token->text, "TOK_IF"); 1762 /* 1763 * Similar to do but simpler since we only deal w/one branch. 1764 */ 1765 emit("b?branch"); 1766 push(outpos); 1767 offspit(0); /* Place holder for later */ 1768 break; 1769 case TOK_LEAVE: 1770 STATE(token->text, "TOK_LEAVE"); 1771 emit("b(leave)"); 1772 break; 1773 case TOK_LOOP: 1774 STATE(token->text, "TOK_LOOP"); 1775 1776 if (token->text[0] == '+') 1777 emit("b(+loop)"); 1778 else 1779 emit("b(loop)"); 1780 /* First do backwards branch of loop */ 1781 pos = pop(); 1782 off = pos - outpos; 1783 offspit(off); 1784 /* Now do forward branch of do */ 1785 pos = outpos; 1786 outpos = pop(); 1787 off = pos - outpos; 1788 spit(off); 1789 /* Restore output position */ 1790 outpos = pos; 1791 break; 1792 case TOK_OCTAL: 1793 STATE(token->text, "TOK_OCTAL"); 1794 if (token->text[1] != '#') { 1795 if (defining) { 1796 spit(16); 1797 emit("base"); 1798 emit("!"); 1799 } else 1800 numbase = TOK_OCTAL; 1801 } else { 1802 char *end; 1803 Cell value; 1804 1805 token = yylex(); 1806 if (token == NULL) { 1807 warnx("EOF after o#"); 1808 return; 1809 } 1810 value = strtol(token->text, &end, 8); 1811 if (*end != 0) { 1812 errx(EXIT_FAILURE, "Illegal number" 1813 " conversion:%s:%d: %s\n", 1814 infile, yylineno, yytext); 1815 } 1816 /* 1817 * If this is a 64-bit value we need to store two literals 1818 * and issue a `lxjoin' to combine them. But that's a future 1819 * project. 1820 */ 1821 emit("b(lit)"); 1822 spit((value>>24)&0x0ff); 1823 spit((value>>16)&0x0ff); 1824 spit((value>>8)&0x0ff); 1825 spit(value&0x0ff); 1826 if ((value>>32) != value && (value>>32) != 0) { 1827 emit("b(lit)"); 1828 spit((value>>56)&0x0ff); 1829 spit((value>>48)&0x0ff); 1830 spit((value>>40)&0x0ff); 1831 spit((value>>32)&0x0ff); 1832 emit("lxjoin"); 1833 } 1834 } 1835 break; 1836 case TOK_OF: 1837 STATE(token->text, "TOK_OF"); 1838 /* 1839 * Let's hope I get the semantics right. 1840 * 1841 * The `of' behaves almost the same as an 1842 * `if'. The difference is that `endof' 1843 * takes a branch offset to the associated 1844 * `endcase'. Here we will generate a temporary 1845 * offset of the `of' associated with the `endof'. 1846 * Then in `endcase' we should be pointing just 1847 * after the offset of the last `endof' so we 1848 * calculate the offset and thread our way backwards 1849 * searching for the previous `b(case)' or `b(endof)'. 1850 */ 1851 emit("b(of)"); 1852 push(outpos); 1853 offspit(0); /* Place holder for later */ 1854 break; 1855 case TOK_OFFSET16: 1856 STATE(token->text, "TOK_OFFSET16"); 1857 offsetsize = 16; 1858 emit("offset16"); 1859 break; 1860 case TOK_REPEAT: 1861 STATE(token->text, "TOK_REPEAT"); 1862 emit("bbranch"); 1863 pos = pop(); 1864 off = pop(); 1865 /* First the offset for the branch back to the begin */ 1866 off -= outpos; 1867 offspit(off); 1868 emit("b(>resolve)"); 1869 /* Now point the offset of the while here. */ 1870 off = outpos; 1871 outpos = pos; 1872 pos = off - pos; 1873 offspit(pos); 1874 /* Return to the end of the output */ 1875 outpos = off; 1876 break; 1877 case TOK_STARTX: 1878 /* Put a "startX" at addr 0. */ 1879 STATE(token->text, "TOK_FCODE_VERSION2"); 1880 offsetsize = 16; 1881 pos = outpos; 1882 outpos = 0; 1883 emit(token->text); 1884 outpos = pos; 1885 break; 1886 case TOK_THEN: 1887 STATE(token->text, "TOK_THEN"); 1888 emit("b(>resolve)"); 1889 pos = outpos; 1890 outpos = pop(); 1891 off = pos - outpos; 1892 offspit(off); 1893 outpos = pos; 1894 break; 1895 case TOK_TO: 1896 STATE(token->text, "TOK_TO"); 1897 /* The next pass should tokenize the FCODE number */ 1898 emit("b(to)"); 1899 break; 1900 case TOK_UNTIL: 1901 STATE(token->text, "TOK_UNTIL"); 1902 emit("b?branch"); 1903 pos = pop(); 1904 pos -= outpos; 1905 offspit(pos); 1906 break; 1907 case TOK_VALUE: 1908 STATE(token->text, "TOK_VALUE"); 1909 1910 token = yylex(); 1911 if (token == NULL) { 1912 warnx("EOF in value definition"); 1913 return; 1914 } 1915 1916 /* Add new code to dictionary */ 1917 fcode = emalloc(sizeof(*fcode)); 1918 fcode->num = nextfcode++; 1919 fcode->name = estrdup(token->text); 1920 fadd(dictionary, fcode); 1921 1922 if (state == 0) 1923 emit("new-token"); 1924 else { 1925 if (state == TOK_EXTERNAL) 1926 emit("external-token"); 1927 else 1928 /* Here we have a choice of new-token or named-token */ 1929 emit("named-token"); 1930 sspit(token->text); 1931 } 1932 spit(fcode->num); 1933 emit("b(value)"); 1934 break; 1935 case TOK_VARIABLE: 1936 STATE(token->text, "TOK_VARIABLE"); 1937 1938 token = yylex(); 1939 if (token == NULL) { 1940 warnx("EOF in variable definition"); 1941 return; 1942 } 1943 1944 /* Add new code to dictionary */ 1945 fcode = emalloc(sizeof(*fcode)); 1946 fcode->num = nextfcode++; 1947 fcode->name = estrdup(token->text); 1948 fadd(dictionary, fcode); 1949 1950 if (state == 0) 1951 emit("new-token"); 1952 else { 1953 if (state == TOK_EXTERNAL) 1954 emit("external-token"); 1955 else 1956 /* Here we have a choice of new-token or named-token */ 1957 emit("named-token"); 1958 sspit(token->text); 1959 } 1960 spit(fcode->num); 1961 emit("b(variable)"); 1962 break; 1963 case TOK_VERSION1: 1964 /* This is actually a tokenizer directive. */ 1965 STATE(token->text, "TOK_FCODE_VERSION1"); 1966 offsetsize = 8; 1967 pos = outpos; 1968 outpos = 0; 1969 emit("version1"); 1970 outpos = pos; 1971 break; 1972 case TOK_WHILE: 1973 STATE(token->text, "TOK_WHILE"); 1974 emit("b?branch"); 1975 push(outpos); 1976 offspit(0); 1977 break; 1978 1979 /* Tokenizer directives */ 1980 case TOK_BEGTOK: 1981 STATE(token->text, "TOK_BEGTOK"); 1982 tokenizer = 1; 1983 break; 1984 case TOK_EMIT_BYTE: 1985 STATE(token->text, "TOK_EMIT_BYTE"); 1986 spit(pop()); 1987 break; 1988 case TOK_ENDTOK: 1989 STATE(token->text, "TOK_ENDTOK"); 1990 tokenizer = 0; 1991 break; 1992 case TOK_FLOAD: 1993 { 1994 char *oldinfile = infile; 1995 1996 STATE(token->text, "TOK_FLOAD"); 1997 /* Parse a different file for a while */ 1998 token = yylex(); 1999 if ((inf = fopen(token->text, "r")) == NULL) { 2000 warn("Cannot open `%s'", token->text); 2001 break; 2002 } 2003 infile = estrdup(token->text); 2004 if (mark_fload) { 2005 /* 2006 * Insert commands to print out the 2007 * filename into the instruction 2008 * stream 2009 */ 2010 emit("b(\")"); 2011 sspit("fload-ing "); 2012 emit("type"); 2013 emit("b(\")"); 2014 sspit(infile); 2015 emit("type"); 2016 emit("cr"); 2017 emit(".s"); 2018 } 2019 inbuf = yy_create_buffer(inf, YY_BUF_SIZE); 2020 yy_switch_to_buffer(inbuf); 2021 2022 printf("======= fload file %s\n", infile); 2023 tokenize(inbuf); 2024 printf("======= done file %s\n", infile); 2025 yy_switch_to_buffer(yinput); 2026 yy_delete_buffer(inbuf); 2027 fclose(inf); 2028 if (mark_fload) { 2029 /* 2030 * Insert commands to print out the 2031 * filename into the instruction 2032 * stream 2033 */ 2034 emit("b(\")"); 2035 sspit("fload-ed "); 2036 emit("type"); 2037 emit("b(\")"); 2038 sspit(infile); 2039 emit("type"); 2040 emit("cr"); 2041 emit(".s"); 2042 emit("cr"); 2043 } 2044 free(infile); 2045 infile = oldinfile; 2046 } 2047 break; 2048 case TOK_OTHER: 2049 STATE(token->text, "TOK_OTHER"); 2050 if (apply_macros(yinput, token->text)) 2051 break; 2052 if (emit(token->text)) { 2053 #if 0 2054 /* 2055 * Call an external command 2056 * 2057 * XXXXX assumes it will always find the command 2058 */ 2059 sspit(token->text); 2060 emit("$find"); 2061 emit("drop"); 2062 emit("execute"); 2063 #else 2064 token_err(yylineno, infile, yytext, 2065 "%s: undefined token `%s'\n", 2066 myname, token->text); 2067 #endif 2068 } 2069 break; 2070 default: 2071 /* Nothing */ ; 2072 } 2073 } 2074 return; 2075 } 2076 2077 /* 2078 * print a tokenizer error message 2079 */ 2080 static void 2081 token_err(int lineno, const char *file, const char *text, const char *fmt, ...) 2082 { 2083 va_list ap; 2084 2085 va_start(ap, fmt); 2086 fprintf(stderr, "%s: ", getprogname()); 2087 if (file) 2088 (void)fprintf(stderr, "%s,%d: ", file, lineno); 2089 if (fmt) 2090 (void)vfprintf(stderr, fmt, ap); 2091 fputc('\n', stderr); 2092 if (text) 2093 fprintf(stderr, "\t%s", text); 2094 va_end(ap); 2095 exit(EXIT_FAILURE); 2096 } 2097 2098 /* 2099 * Lookup fcode string in dictionary and spit it out. 2100 * 2101 * Fcode must be in dictionary. No alias conversion done. 2102 */ 2103 static int 2104 emit(const char *str) 2105 { 2106 struct fcode *code; 2107 if ((code = flookup(dictionary, str))) 2108 spit(code->num); 2109 if (debug > 1) { 2110 if (code) 2111 printf("emitting `%s'\n", code->name); 2112 else 2113 printf("emit: not found `%s'\n", str); 2114 } 2115 return (code == NULL); 2116 } 2117 2118 /* 2119 * Spit out an integral value as a series of FCodes. 2120 * 2121 * It will spit out one zero byte or as many bytes as are 2122 * non-zero. 2123 */ 2124 static int 2125 spit(long n) 2126 { 2127 int count = 1; 2128 2129 if (n >> 8) 2130 count += spit(n >> 8); 2131 if ((size_t)outpos >= outbufsiz) { 2132 while ((size_t)outpos >= outbufsiz) outbufsiz += BUFCLICK; 2133 outbuf = erealloc(outbuf, outbufsiz); 2134 } 2135 if (debug > 3) printf("%lx: spitting %2.2x\n", outpos, (unsigned char)n); 2136 outbuf[outpos++] = n; 2137 return (count); 2138 } 2139 2140 /* 2141 * Spit out an FCode string. 2142 */ 2143 static void 2144 sspit(const char *s) 2145 { 2146 int len = strlen(s); 2147 2148 if (len > 255) { 2149 warnx("string length %d too long", len); 2150 return; 2151 } 2152 if (debug > 2) 2153 printf("sspit: len %d str `%s'\n", len, s); 2154 spit(len); 2155 while (len--) 2156 spit(*s++); 2157 } 2158 2159 /* 2160 * Spit out an offset. Offsets can be 8 or 16 bits. 2161 * Bail if the value overflows. This is a little complicated since 2162 * offsets can be negative numbers. 2163 */ 2164 static int 2165 offspit(long n) 2166 { 2167 2168 if (offsetsize == 16) { 2169 volatile int16_t off16 = n; 2170 2171 if (n != off16) 2172 token_err(yylineno, infile, NULL, 2173 "Offset16 offset overflow: %lx != %x\n", 2174 n, off16); 2175 spit((n>>8) & 0xff); 2176 return spit(n & 0xff); 2177 } else { 2178 volatile int8_t off8 = n; 2179 2180 if (n != off8) 2181 token_err(yylineno, infile, NULL, 2182 "Offset8 offset overflow: %lx != %x\n", 2183 n, off8); 2184 return spit(n & 0x0ffL); 2185 } 2186 } 2187 2188 int 2189 yywrap(void) 2190 { 2191 /* Always generate EOF */ 2192 return (1); 2193 } 2194