git.sur5r.net Git - cc65/blob - src/grc65/main.c

   1 /* GEOS resource compiler
   2
   3    by Maciej 'YTM/Elysium' Witkowiak
   4
   5    see GEOSLib documentation for license info
   6 */
   7
   8 /* - make it work, then do it better
   9    - more or less comments? it was hard to code, should be even harder to
  10      understand =D
  11    - add loadable icons feature (binary - 63 bytes)
  12 */
  13
  14 /* - err, maybe free allocated memory, huh? (who cares, it's just a little prog...)
  15 */
  16
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19 #include <stdarg.h>
  20 #include <string.h>
  21 #include <errno.h>
  22 #include <time.h>
  23
  24 /* common stuff */
  25 #include "abend.h"
  26 #include "cmdline.h"
  27 #include "fname.h"
  28 #include "chartype.h"
  29 #include "target.h"
  30 #include "version.h"
  31 #include "xmalloc.h"
  32
  33 /* I hope that no one will be able to create a .grc bigger than this... */
  34 #define BLOODY_BIG_BUFFER 65000
  35
  36
  37
  38 struct menuitem {
  39     char *name;
  40     char *type;
  41     char *target;
  42     struct menuitem *next;
  43 };
  44
  45 struct menu {
  46     char *name;
  47     int top, left;
  48     int bot, right;
  49     char *type;
  50     struct menuitem *item;
  51 };
  52
  53 struct appheader {
  54     int year, month, day, hour, min;
  55     int mode;
  56     int dostype;
  57     int geostype;
  58     int structure;
  59     char *dosname;
  60     char *classname;
  61     char *version;
  62     char *author;
  63     char *info;
  64     char *icon;
  65 };
  66
  67 const char *mainToken[] = {"MENU", "HEADER", "ICON", "DIALOG", "MEMORY", ""};
  68
  69 const char *toggle[] = {"off", "no", "0", "on", "yes", "1", ""};
  70
  71 const char *hdrFTypes[] = {"APPLICATION", "AUTO_EXEC", "DESK_ACC", "ASSEMBLY",
  72                            "DISK_DEVICE", "PRINTER", "SYSTEM", ""};
  73
  74 const char *hdrFields[] = {"author", "info", "date", "dostype", "mode", "structure", "icon", ""};
  75
  76 const char *hdrDOSTp[] = {"seq", "SEQ", "prg", "PRG", "usr", "USR", ""};
  77
  78 const char *hdrStructTp[] = {"seq", "SEQ", "vlir", "VLIR", ""};
  79
  80 const char *hdrModes[] = {"any", "40only", "80only", "c64only", ""};
  81
  82 const char *memFields[] = {"stacksize", "overlaysize", "overlaynums", "backbuffer", ""};
  83
  84 const int BSWTab[] = {0, 0x005, 0x007, 0x00b, 0x011, 0x017, 0x01d, 0x023,
  85     0x025, 0x029, 0x02d, 0x033, 0x039, 0x03c, 0x041, 0x043, 0x04a, 0x04f,
  86     0x052, 0x056, 0x05a, 0x05f, 0x063, 0x068, 0x06d, 0x072, 0x077, 0x079,
  87     0x07c, 0x080, 0x084, 0x088, 0x08e, 0x094, 0x09a, 0x09f, 0x0a4, 0x0a9,
  88     0x0ad, 0x0b1, 0x0b6, 0x0bc, 0x0be, 0x0c2, 0x0c8, 0x0cc, 0x0d4, 0x0da,
  89     0x0e0, 0x0e5, 0x0eb, 0x0f0, 0x0f5, 0x0f9, 0x0fe, 0x104, 0x10c, 0x112,
  90     0x118, 0x11e, 0x121, 0x129, 0x12c, 0x132, 0x13a, 0x13e, 0x143, 0x148,
  91     0x14d, 0x152, 0x157, 0x15a, 0x15f, 0x164, 0x166, 0x168, 0x16d, 0x16f,
  92     0x177, 0x17c, 0x182, 0x187, 0x18c, 0x18f, 0x193, 0x196, 0x19b, 0x1a1,
  93     0x1a9, 0x1af, 0x1b4, 0x1ba, 0x1be, 0x1c0, 0x1c4, 0x1ca, 0x1d2, 0x1dd};
  94
  95 const unsigned char icon1[] = {255, 255, 255, 128,   0,   1, 128,   0,   1,
  96                                128,   0,   1, 128,   0,   1, 128,   0,   1,
  97                                128,   0,   1, 128,   0,   1, 128,   0,   1,
  98                                128,   0,   1, 128,   0,   1, 128,   0,   1,
  99                                128,   0,   1, 128,   0,   1, 128,   0,   1,
 100                                128,   0,   1, 128,   0,   1, 128,   0,   1,
 101                                128,   0,   1, 128,   0,   1, 255, 255, 255};
 102
 103 const char *outputCName = NULL;
 104 const char *outputSName = NULL;
 105 FILE *outputCFile, *outputSFile;
 106 int CFnum = 0, SFnum = 0;
 107 int apple = 0;
 108 char outputCMode[2] = "w";
 109 char outputSMode[2] = "w";
 110
 111
 112 static void Usage (void)
 113 {
 114     printf (
 115         "Usage: %s [options] file\n"
 116         "Short options:\n"
 117         "  -V\t\t\tPrint the version number\n"
 118         "  -h\t\t\tHelp (this text)\n"
 119         "  -o name\t\tName the C output file\n"
 120         "  -s name\t\tName the asm output file\n"
 121         "  -t sys\t\tSet the target system\n"
 122         "\n"
 123         "Long options:\n"
 124         "  --help\t\tHelp (this text)\n"
 125         "  --target sys\t\tSet the target system\n"
 126         "  --version\t\tPrint the version number\n",
 127         ProgName);
 128 }
 129
 130
 131 static void OptHelp (const char* Opt attribute ((unused)),
 132                      const char* Arg attribute ((unused)))
 133 /* Print usage information and exit */
 134 {
 135     Usage ();
 136     exit (EXIT_SUCCESS);
 137 }
 138
 139
 140 static void OptTarget (const char* Opt attribute ((unused)), const char* Arg)
 141 /* Set the target system */
 142 {
 143     switch (FindTarget (Arg)) {
 144
 145         case TGT_GEOS_CBM:
 146             apple = 0;
 147             break;
 148
 149         case TGT_GEOS_APPLE:
 150             apple = 1;
 151             break;
 152
 153         case TGT_UNKNOWN:
 154             AbEnd ("Unknown target system `%s'", Arg);
 155             break;
 156
 157         default:
 158             /* Target is known but unsupported */
 159             AbEnd ("Unsupported target system `%s'", Arg);
 160             break;
 161     }
 162 }
 163
 164
 165 static void OptVersion (const char* Opt attribute ((unused)),
 166                         const char* Arg attribute ((unused)))
 167 /* Print the assembler version */
 168 {
 169     fprintf (stderr,
 170         "grc65 V%s - (C) Copyright, Maciej 'YTM/Elysium' Witkowiak\n",
 171         GetVersionAsString ());
 172 }
 173
 174
 175
 176 static void printCHeader (void)
 177 {
 178     fprintf (outputCFile,
 179         "//\n"
 180         "//\tThis file was generated by the GEOS Resource Compiler\n"
 181         "//\n"
 182         "//\tDO NOT EDIT! Any changes will be lost!\n"
 183         "//\n"
 184         "//\tEdit proper resource file instead.\n"
 185         "//\n\n");
 186 }
 187
 188
 189 static void printSHeader (void)
 190 {
 191     fprintf (outputSFile,
 192         ";\n"
 193         ";\tThis file was generated by the GEOS Resource Compiler\n"
 194         ";\n"
 195         ";\tDO NOT EDIT! Any changes will be lost!\n"
 196         ";\n"
 197         ";\tEdit proper resource file instead.\n"
 198         ";\n\n");
 199 }
 200
 201
 202 static void openCFile (void)
 203 {
 204     if ((outputCFile = fopen (outputCName,outputCMode)) == 0) {
 205         AbEnd ("Can't open file %s for writing: %s", outputCName, strerror (errno));
 206     }
 207
 208     if (CFnum == 0) {
 209         outputCMode[0] = 'a';
 210         printCHeader ();
 211         CFnum++;
 212     }
 213 }
 214
 215
 216 static void openSFile (void)
 217 {
 218     if ((outputSFile = fopen (outputSName, outputSMode)) == 0) {
 219         AbEnd ("Can't open file %s for writing: %s", outputSName, strerror (errno));
 220     }
 221
 222     if (SFnum == 0) {
 223         outputSMode[0] = 'a';
 224         printSHeader ();
 225         SFnum++;
 226     }
 227 }
 228
 229
 230 static int findToken (const char **tokenTbl, const char *token)
 231 {
 232     /* takes as input table of tokens and token, returns position in table or -1 if not found */
 233     int a = 0;
 234
 235     while (strlen (tokenTbl[a]) != 0) {
 236         if (strcmp (tokenTbl[a], token) == 0) break;
 237         a++;
 238     }
 239
 240     if (strlen (tokenTbl[a]) == 0) a = -1;
 241     return a;
 242 }
 243
 244
 245 static char *nextPhrase (void)
 246 {
 247     return strtok (NULL, "\"");
 248 }
 249
 250
 251 static char *nextWord (void)
 252 {
 253     return strtok (NULL, " ");
 254 }
 255
 256
 257 static void setLen (char *name, unsigned len)
 258 {
 259     if (strlen (name) > len) {
 260         name[len] = '\0';
 261     }
 262 }
 263
 264
 265 static void fillOut (char *name, int len, char *filler)
 266 {
 267     int a;
 268
 269     setLen(name, len);
 270     fprintf (outputSFile, "\t.byte \"%s\"\n", name);
 271
 272     a = strlen (name);
 273     if (a < len) {
 274         fprintf (outputSFile, "\t.res  (%i - %i), %s\n", len, a, filler);
 275     }
 276 }
 277
 278
 279 static char *bintos (unsigned char a, char out[7])
 280 {
 281     int i=0;
 282
 283     for (; i < 8; i++) {
 284         out[7 - i] = ((a & 1) == 0) ? '0' : '1';
 285         a = a >> 1;
 286     }
 287     out[i] = '\0';
 288
 289     return out;
 290 }
 291
 292
 293 static int getNameSize (const char *word)
 294 {
 295     /* count length of a word using BSW 9 font table */
 296     int a = 0, i = 0;
 297
 298     while (word[i] != '\0') {
 299         a += (BSWTab[word[i] - 31] - BSWTab[word[i] - 32]);
 300         i++;
 301     }
 302
 303     return a;
 304 }
 305
 306
 307 static void DoMenu (void)
 308 {
 309     int a, size, tmpsize, item = 0;
 310     char *token;
 311     char namebuff[255] = "";
 312     struct menu myMenu;
 313     struct menuitem *curItem, *newItem;
 314
 315     openCFile ();
 316
 317     myMenu.name = nextWord ();
 318     myMenu.left = atoi (nextWord ());
 319     myMenu.top = atoi (nextWord ());
 320     myMenu.type = nextWord ();
 321
 322     if (strcmp(nextWord (), "{") != 0) {
 323         AbEnd ("Menu '%s' description has no opening bracket!", myMenu.name);
 324     }
 325     curItem = xmalloc (sizeof(struct menuitem));
 326     myMenu.item = curItem;
 327
 328     for (;;) {
 329         token = nextWord ();
 330         if (strcmp (token, "}") == 0) break;
 331         if (token[strlen(token) - 1] != '"') {
 332             strcpy (namebuff, token);
 333             do {
 334                 token = nextWord ();
 335                 strcat (namebuff, " ");
 336                 strcat (namebuff, token);
 337             } while (token[strlen(token) - 1] != '"');
 338             token = xmalloc (strlen (namebuff));
 339             strcpy (token, namebuff);
 340         }
 341         curItem->name = token;
 342         curItem->type = nextWord ();
 343         curItem->target = nextWord ();
 344         newItem = xmalloc (sizeof(struct menuitem));
 345         curItem->next = newItem;
 346         curItem = newItem;
 347         item++;
 348     }
 349
 350     if (item == 0) AbEnd ("Menu '%s' has 0 items!", myMenu.name);
 351     if (item > 31) AbEnd ("Menu '%s' has too many items!", myMenu.name);
 352
 353     curItem->next = NULL;
 354
 355     /* count menu sizes */
 356     size = 0;
 357     curItem = myMenu.item;
 358     if (strstr (myMenu.type, "HORIZONTAL") != NULL) {
 359         /* menu is HORIZONTAL, ysize=15, sum xsize of all items +~8?*/
 360         myMenu.bot = myMenu.top + 15;
 361         for (a = 0; a != item; a++) {
 362             size += getNameSize (curItem->name);
 363             curItem = curItem->next;
 364         }
 365     } else {
 366         /* menu is VERTICAL, ysize=item*15, count largest xsize of all items +~8? */
 367         myMenu.bot = myMenu.top + (14 * item);
 368         for (a = 0; a != item; a++) {
 369             tmpsize = getNameSize (curItem->name);
 370             size = (size > tmpsize) ? size : tmpsize;
 371             curItem = curItem->next;
 372         }
 373     }
 374     myMenu.right = myMenu.left + size - 1;
 375
 376     curItem = myMenu.item;
 377     for (a = 0; a != item; a++) {
 378         /* print prototype only if MENU_ACTION or DYN_SUB_MENU are present in type */
 379         if ((strstr (curItem->type, "MENU_ACTION") != NULL) || (strstr (curItem->type, "DYN_SUB_MENU") != NULL)) {
 380             fprintf (outputCFile,
 381                 "void %s (void);\n",
 382                 curItem->target);
 383         }
 384         curItem=curItem->next;
 385     }
 386
 387     fprintf (outputCFile,
 388         "\n"
 389         "const void %s = {\n"
 390         "\t(char)%i, (char)%i,\n"
 391         "\t(int)%i, (int)%i,\n"
 392         "\t(char)(%i | %s),\n",
 393         myMenu.name, myMenu.top, myMenu.bot, myMenu.left, myMenu.right, item, myMenu.type);
 394
 395     curItem = myMenu.item;
 396     for (a = 0; a != item; a++) {
 397         fprintf (outputCFile,
 398             "\t%s, (char)%s, (int)",
 399             curItem->name, curItem->type);
 400         if ((strstr (curItem->type, "SUB_MENU") != NULL) && (strstr (curItem->type, "DYN_SUB_MENU") == NULL)) {
 401             fprintf (outputCFile,
 402                 "&");
 403         }
 404         fprintf (outputCFile,
 405             "%s,\n",
 406             curItem->target);
 407         curItem = curItem->next;
 408     }
 409
 410     fprintf (outputCFile,
 411         "};\n\n");
 412
 413     if (fclose (outputCFile) != 0) {
 414         AbEnd ("Error closing %s: %s", outputCName, strerror (errno));
 415     }
 416 }
 417
 418
 419 static void DoHeader (void)
 420 {
 421     time_t t;
 422     struct tm *my_tm;
 423
 424     struct appheader myHead;
 425     char *token;
 426     char i1[9], i2[9], i3[9];
 427     int i;
 428
 429     openSFile ();
 430
 431     token = nextWord ();
 432
 433     i = findToken(hdrFTypes, token);
 434
 435     if (apple == 1) {
 436         switch (i) {
 437             case 0:
 438                 myHead.geostype = 0x82;
 439                 break;
 440             default:
 441                 AbEnd ("Filetype '%s' is not supported yet", token);
 442         }
 443     } else {
 444         switch (i) {
 445             case 0:
 446                 myHead.geostype = 6;
 447                 break;
 448             case 1:
 449                 myHead.geostype = 14;
 450                 break;
 451             default:
 452                 AbEnd ("Filetype '%s' is not supported yet", token);
 453         }
 454     }
 455
 456     myHead.dosname = nextPhrase ();
 457     nextPhrase ();
 458     myHead.classname = nextPhrase ();
 459     nextPhrase ();
 460     myHead.version = nextPhrase ();
 461
 462     /* put default values into myHead here */
 463     myHead.author = "cc65";
 464     myHead.info = "Program compiled with cc65 and GEOSLib.";
 465     myHead.dostype = 128;
 466     if (apple == 0) myHead.dostype += 3;
 467     myHead.structure = 0;
 468     myHead.mode = 0;
 469     myHead.icon = NULL;
 470
 471     t = time (NULL);
 472     my_tm = localtime (&t);
 473
 474     myHead.year = my_tm->tm_year % 100;
 475     myHead.month = my_tm->tm_mon + 1;
 476     myHead.day = my_tm->tm_mday;
 477     myHead.hour = my_tm->tm_hour;
 478     myHead.min = my_tm->tm_min;
 479
 480     if (strcmp (nextWord (), "{") != 0) {
 481         AbEnd ("Header '%s' has no opening bracket!", myHead.dosname);
 482     }
 483
 484     for (;;) {
 485         token = nextWord ();
 486         if (strcmp (token, "}") == 0) break;
 487         switch (findToken (hdrFields, token)) {
 488             case -1:
 489                 AbEnd ("Unknown field '%s' in header '%s'", token, myHead.dosname);
 490                 break;
 491
 492             case 0: /* author */
 493                 myHead.author = nextPhrase ();
 494                 break;
 495
 496             case 1: /* info */
 497                 myHead.info = nextPhrase ();
 498                 break;
 499
 500             case 2: /* date */
 501                 myHead.year = atoi (nextWord ());
 502                 myHead.month = atoi (nextWord ());
 503                 myHead.day = atoi (nextWord ());
 504                 myHead.hour = atoi (nextWord ());
 505                 myHead.min = atoi (nextWord ());
 506                 break;
 507
 508             case 3: /* dostype */
 509                 switch (i = findToken (hdrDOSTp, nextWord ())) {
 510                     case -1:
 511                         AbEnd ("Unknown dostype in header '%s'", myHead.dosname);
 512                         break;
 513                     default:
 514                         if (apple == 0) myHead.dostype = i / 2 + 128 + 1;
 515                         break;
 516                 }
 517                 break;
 518
 519             case 4: /* mode */
 520                 switch (findToken (hdrModes, nextWord ())) {
 521                     case -1:
 522                         AbEnd ("Unknown mode in header '%s'", myHead.dosname);
 523                     case 0:
 524                         if (apple == 0) myHead.mode = 0x40;
 525                         break;
 526                     case 1:
 527                         if (apple == 0) myHead.mode = 0x00;
 528                         break;
 529                     case 2:
 530                         if (apple == 0) myHead.mode = 0xc0;
 531                         break;
 532                     case 3:
 533                         if (apple == 0) myHead.mode = 0x80;
 534                         break;
 535                 }
 536                 break;
 537
 538             case 5: /* structure */
 539                 switch (findToken (hdrStructTp, nextWord ())) {
 540                     case -1:
 541                         AbEnd ("unknown structure type in header '%s'", myHead.dosname);
 542                     case 0:
 543                     case 1:
 544                         myHead.structure = 0;
 545                         break;
 546                     case 2:
 547                     case 3:
 548                         myHead.structure = 1;
 549                         break;
 550                 }
 551                 break;
 552
 553             case 6: /* icon */
 554                 myHead.icon = nextPhrase ();
 555                 break;
 556         }
 557     }
 558
 559     /* OK, all information is gathered, do flushout */
 560
 561     fprintf (outputSFile,
 562         "\t\t.segment \"DIRENTRY\"\n\n");
 563
 564     if (apple == 1) {
 565
 566         if (myHead.structure == 0) {
 567             fprintf (outputSFile,
 568                 "\t.import __VLIR0_START__, __VLIR0_LAST__, __BSS_SIZE__\n\n");
 569         }
 570         fprintf (outputSFile,
 571             "\t.byte %i << 4 | %u\n",
 572             myHead.structure + 2, (unsigned)strlen (myHead.dosname));
 573
 574         fillOut (myHead.dosname, 15, "0");
 575
 576         fprintf (outputSFile,
 577             "\t.byte $%02x\n"
 578             "\t.word 0\n"
 579             "\t.word 0\n"
 580             "\t.word %s\n"
 581             "\t.byte 0\n"
 582             "\t.word %i << 9 | %i << 5 | %i, %i << 8 | %i\n"
 583             "\t.byte 0\n"
 584             "\t.byte 0\n"
 585             "\t.byte 0\n"
 586             "\t.word 0\n"
 587             "\t.word %i << 9 | %i << 5 | %i, %i << 8 | %i\n"
 588             "\t.word 0\n\n",
 589             myHead.geostype,
 590             myHead.structure == 0 ?
 591                 "__VLIR0_LAST__ - __VLIR0_START__ - __BSS_SIZE__" : "0",
 592             myHead.year, myHead.month, myHead.day, myHead.hour, myHead.min,
 593             myHead.year, myHead.month, myHead.day, myHead.hour, myHead.min);
 594
 595     } else {
 596
 597         fprintf (outputSFile,
 598             "\t.byte %i\n"
 599             "\t.word 0\n",
 600             myHead.dostype);
 601
 602         fillOut (myHead.dosname, 16, "$a0");
 603
 604         fprintf (outputSFile,
 605             "\t.word 0\n"
 606             "\t.byte %i\n"
 607             "\t.byte %i\n"
 608             "\t.byte %i, %i, %i, %i, %i\n\n"
 609             "\t.word 0\n"
 610             "\t.byte \"PRG formatted GEOS file V1.0\"\n\n",
 611             myHead.structure, myHead.geostype,
 612             myHead.year, myHead.month, myHead.day, myHead.hour, myHead.min);
 613     }
 614
 615     fprintf (outputSFile,
 616         "\t\t.segment \"FILEINFO\"\n\n"
 617         "\t.import __VLIR0_START__, __STARTUP_RUN__\n\n"
 618         "\t.byte 3, 21, 63 | $80\n");
 619
 620     if (myHead.icon != NULL) {
 621         fprintf (outputSFile,
 622             "\t.incbin \"%s\", 0, 63\n",
 623             myHead.icon);
 624     } else {
 625         for (i = 0; i != 63; i = i + 3) {
 626             fprintf (outputSFile,
 627                 "\t.byte %%%s, %%%s, %%%s\n",
 628                 bintos (icon1[i], i1), bintos (icon1[i+1], i2), bintos (icon1[i+2], i3));
 629         }
 630     }
 631
 632     fprintf (outputSFile,
 633         "\t.byte %i, %i, %i\n"
 634         "\t.word __VLIR0_START__, __VLIR0_START__ - 1, __STARTUP_RUN__\n\n",
 635         myHead.dostype, myHead.geostype, myHead.structure);
 636
 637     fillOut (myHead.classname, 12, "$20");
 638
 639     fillOut (myHead.version, 4, "0");
 640
 641     fprintf (outputSFile,
 642         "\t.byte 0, 0, 0\n"
 643         "\t.byte %i\n\n",
 644         myHead.mode);
 645
 646     setLen (myHead.author, 62);
 647     fprintf (outputSFile,
 648         "\t.byte \"%s\"\n"
 649         "\t.byte 0\n"
 650         "\t.res  (63 - %i)\n\n",
 651         myHead.author, (int)(strlen (myHead.author) + 1));
 652
 653     setLen (myHead.info, 95);
 654     fprintf (outputSFile,
 655         "\t.byte \"%s\"\n"
 656         "\t.byte 0\n\n",
 657         myHead.info);
 658
 659     if (fclose (outputSFile) != 0) {
 660         AbEnd ("Error closing %s: %s", outputSName, strerror (errno));
 661     }
 662 }
 663
 664
 665 static void DoMemory (void)
 666 {
 667     char *token;
 668     int stacksize, overlaysize;
 669     int overlaytable[127];
 670     int number, lastnumber;
 671     int backbuffer;
 672
 673     openSFile ();
 674
 675     stacksize = -1;
 676     overlaysize = -1;
 677     memset (overlaytable, 0, sizeof(overlaytable));
 678     lastnumber = -1;
 679     backbuffer = -1;
 680
 681     if (strcmp(nextWord (), "{") != 0) {
 682         AbEnd ("MEMORY description has no opening bracket!");
 683     }
 684
 685     token = NULL;
 686     for (;;) {
 687         if (token == NULL) token = nextWord ();
 688         if (strcmp (token, "}") == 0) break;
 689         switch (findToken (memFields, token)) {
 690             case -1:
 691                 AbEnd ("Unknown field '%s' in MEMORY description", token);
 692                 break;
 693
 694             case 0: /* stacksize */
 695                 stacksize = strtol (nextWord (), NULL, 0);
 696                 token = NULL;
 697                 break;
 698
 699             case 1: /* overlaysize */
 700                 overlaysize = strtol (nextWord (), NULL, 0);
 701                 token = NULL;
 702                 break;
 703
 704             case 2: /* overlaynums */
 705                 do {
 706                     token = nextWord ();
 707                     if (IsDigit (token[0]) == 0) break;
 708
 709                     number = atoi (token);
 710                     if (number < 0 || number > 126) {
 711                         AbEnd ("Overlay number %i is out of range 0-126", number);
 712                     }
 713                     if (overlaytable[number] == 1) {
 714                         AbEnd ("Overlay number %i is defined twice", number);
 715                     }
 716
 717                     overlaytable[number] = 1;
 718                     if (number > lastnumber) lastnumber = number;
 719
 720                 } while (IsDigit (token[0]) != 0);
 721
 722                 if (lastnumber == -1) {
 723                     AbEnd ("There must be at least one overlay number");
 724                 }
 725
 726                 /* always include number 0 */
 727                 overlaytable[0] = 1;
 728                 break;
 729
 730             case 3: /* backbuffer */
 731                 switch (findToken (toggle, nextWord ())) {
 732                     case -1:
 733                         AbEnd ("Unknown value for 'backbuffer'");
 734                         break;
 735                     case 0:
 736                     case 1:
 737                     case 2:
 738                         backbuffer = 0;
 739                         break;
 740                     default:
 741                         backbuffer = 1;
 742                         break;
 743                 }
 744                 token = NULL;
 745                 break;
 746         }
 747     }
 748
 749     /* OK, all information is gathered, do flushout */
 750
 751     if (lastnumber != -1) {
 752         fprintf (outputSFile,
 753             "\t\t.segment \"RECORDS\"\n\n");
 754
 755         if (apple == 1) {
 756
 757             for (number = 0; number <= lastnumber; number++) {
 758                 fprintf (outputSFile,
 759                     "\t.byte %s\n",
 760                     overlaytable[number] == 1 ? "$00" : "$FF");
 761             }
 762             fprintf (outputSFile,
 763                 "\n");
 764
 765             for (number = 0; number <= lastnumber; number++) {
 766                 if (overlaytable[number] == 1) {
 767                     fprintf (outputSFile,
 768                         "\t\t.segment \"VLIRIDX%i\"\n\n"
 769                         "\t.import __VLIR%i_START__, __VLIR%i_LAST__%s\n\n"
 770                         "\t.res  255\n"
 771                         "\t.byte .lobyte (__VLIR%i_LAST__ - __VLIR%i_START__%s)\n"
 772                         "\t.res  255\n"
 773                         "\t.byte .hibyte (__VLIR%i_LAST__ - __VLIR%i_START__%s)\n\n",
 774                         number, number, number,
 775                         number == 0 ? ", __BSS_SIZE__" : "",
 776                         number, number,
 777                         number == 0 ? " - __BSS_SIZE__" : "",
 778                         number, number,
 779                         number == 0 ? " - __BSS_SIZE__" : "");
 780                 }
 781             }
 782
 783         } else {
 784
 785             for (number = 0; number <= lastnumber; number++) {
 786                 if (overlaytable[number] == 1) {
 787                     fprintf (outputSFile,
 788                         "\t.import __VLIR%i_START__, __VLIR%i_LAST__\n",
 789                         number, number);
 790                 }
 791             }
 792             fprintf (outputSFile,
 793                 "\n");
 794
 795             for (number = 0; number <= lastnumber; number++) {
 796                 if (overlaytable[number] == 1) {
 797                     fprintf (outputSFile,
 798                         "\t.byte .lobyte ((__VLIR%i_LAST__ - __VLIR%i_START__ - 1) /    254) + 1\n"
 799                         "\t.byte .lobyte ((__VLIR%i_LAST__ - __VLIR%i_START__ - 1) .MOD 254) + 2\n",
 800                         number, number, number, number);
 801                 } else {
 802                     fprintf (outputSFile,
 803                         "\t.byte $00\n"
 804                         "\t.byte $FF\n");
 805                 }
 806             }
 807             fprintf (outputSFile,
 808                 "\n");
 809         }
 810
 811         openCFile ();
 812
 813         fprintf (outputCFile,
 814             "extern void _OVERLAYADDR__;\n"
 815             "extern void _OVERLAYSIZE__;\n\n"
 816             "#define OVERLAY_ADDR (char*)   &_OVERLAYADDR__\n"
 817             "#define OVERLAY_SIZE (unsigned)&_OVERLAYSIZE__\n\n");
 818
 819         if (fclose (outputCFile) != 0) {
 820             AbEnd ("Error closing %s: %s", outputCName, strerror (errno));
 821         }
 822     }
 823
 824     if (stacksize != -1) {
 825         fprintf (outputSFile,
 826             "\t.export __STACKSIZE__ : absolute = $%04x\n\n",
 827             stacksize);
 828     }
 829
 830     if (overlaysize != -1 && apple == 0) {
 831         fprintf (outputSFile,
 832             "\t.export __OVERLAYSIZE__ : absolute = $%04x\n\n",
 833             overlaysize);
 834     }
 835
 836     if (backbuffer != -1) {
 837         fprintf (outputSFile,
 838             "\t.export __BACKBUFSIZE__ : absolute = $%04x\n\n",
 839             backbuffer ? 0x2000 : 0x0000);
 840     }
 841
 842     if (fclose (outputSFile) != 0) {
 843         AbEnd ("Error closing %s: %s", outputSName, strerror (errno));
 844     }
 845 }
 846
 847
 848 static char *filterInput (FILE *F, char *tbl)
 849 {
 850     /* loads file into buffer filtering it out */
 851     int a, prevchar = -1, i = 0, bracket = 0, quote = 1;
 852
 853     for (;;) {
 854         a = getc(F);
 855         if ((a == '\n') || (a == '\015')) a = ' ';
 856         if (a == ',' && quote) a = ' ';
 857         if (a == '\042') quote =! quote;
 858         if (quote) {
 859             if ((a == '{') || (a == '(')) bracket++;
 860             if ((a == '}') || (a == ')')) bracket--;
 861         }
 862         if (a == EOF) {
 863             tbl[i] = '\0';
 864             xrealloc (tbl, i + 1);
 865             break;
 866         }
 867         if (IsSpace (a)) {
 868             if ((prevchar != ' ') && (prevchar != -1)) {
 869                 tbl[i++] = ' ';
 870                 prevchar = ' ';
 871             }
 872         } else {
 873             if (a == ';' && quote) {
 874                 do {
 875                     a = getc (F);
 876                 } while (a != '\n');
 877                 fseek (F, -1, SEEK_CUR);
 878             } else {
 879                 tbl[i++] = a;
 880                 prevchar = a;
 881             }
 882         }
 883     }
 884
 885     if (bracket != 0) AbEnd ("There are unclosed brackets!");
 886
 887     return tbl;
 888 }
 889
 890
 891 static void processFile (const char *filename)
 892 {
 893     FILE *F;
 894
 895     char *str;
 896     char *token;
 897
 898     int head = 0;   /* number of processed HEADER sections */
 899     int memory = 0; /* number of processed MEMORY sections */
 900
 901     if ((F = fopen (filename, "r")) == 0) {
 902         AbEnd ("Can't open file %s for reading: %s", filename, strerror (errno));
 903     }
 904
 905     str = filterInput (F, xmalloc (BLOODY_BIG_BUFFER));
 906
 907     token = strtok (str, " ");
 908
 909     do {
 910         if (str != NULL) {
 911             switch (findToken (mainToken, token)) {
 912                 case 0:
 913                     DoMenu ();
 914                     break;
 915                 case 1:
 916                     if (++head != 1) {
 917                         AbEnd ("More than one HEADER section, aborting");
 918                     } else {
 919                         DoHeader ();
 920                     }
 921                     break;
 922                 case 2: break; /* icon not implemented yet */
 923                 case 3: break; /* dialog not implemented yet */
 924                 case 4:
 925                     if (++memory != 1) {
 926                         AbEnd ("More than one MEMORY section, aborting");
 927                     } else {
 928                         DoMemory ();
 929                     }
 930                     break;
 931                 default:
 932                     AbEnd ("Unknown section '%s'", token);
 933                     break;
 934             }
 935         }
 936         token = nextWord ();
 937     } while (token != NULL);
 938 }
 939
 940
 941 int main (int argc, char *argv[])
 942 {
 943     /* Program long options */
 944     static const LongOpt OptTab[] = {
 945         { "--help",    0, OptHelp},
 946         { "--target",  1, OptTarget},
 947         { "--version", 0, OptVersion},
 948     };
 949
 950     unsigned ffile = 0;
 951     unsigned I;
 952
 953     /* Initialize the cmdline module */
 954     InitCmdLine (&argc, &argv, "grc65");
 955
 956     /* Check the parameters */
 957     I = 1;
 958     while (I < ArgCount) {
 959
 960         /* Get the argument */
 961         const char* Arg = ArgVec [I];
 962
 963         /* Check for an option */
 964         if (Arg[0] == '-') {
 965             switch (Arg[1]) {
 966
 967                 case '-':
 968                     LongOption (&I, OptTab, sizeof(OptTab)/sizeof(OptTab[0]));
 969                     break;
 970
 971                 case 'o':
 972                     outputCName = GetArg (&I, 2);
 973                     break;
 974
 975                 case 's':
 976                     outputSName = GetArg (&I, 2);
 977                     break;
 978
 979                 case 't':
 980                     OptTarget (Arg, GetArg (&I, 2));
 981                     break;
 982
 983                 case 'h':
 984                 case '?':
 985                     OptHelp (Arg, 0);
 986                     break;
 987
 988                 case 'V':
 989                     OptVersion (Arg, 0);
 990                     break;
 991
 992                 default:
 993                     UnknownOption (Arg);
 994             }
 995
 996         } else {
 997             ffile++;
 998
 999             if (outputCName == NULL) outputCName = MakeFilename (Arg, ".h");
1000             if (outputSName == NULL) outputSName = MakeFilename (Arg, ".s");
1001
1002             processFile (Arg);
1003         }
1004
1005         /* Next argument */
1006         ++I;
1007     }
1008
1009     if (ffile == 0) AbEnd ("No input file");
1010
1011     return EXIT_SUCCESS;
1012 }