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 program version */
 168 {
 169     fprintf (stderr, "%s V%s\n", ProgName, GetVersionAsString ());
 170     exit(EXIT_SUCCESS);
 171 }
 172
 173
 174
 175 static void printCHeader (void)
 176 {
 177     fprintf (outputCFile,
 178         "//\n"
 179         "//\tThis file was generated by the GEOS Resource Compiler\n"
 180         "//\n"
 181         "//\tDO NOT EDIT! Any changes will be lost!\n"
 182         "//\n"
 183         "//\tEdit proper resource file instead.\n"
 184         "//\n\n");
 185 }
 186
 187
 188 static void printSHeader (void)
 189 {
 190     fprintf (outputSFile,
 191         ";\n"
 192         ";\tThis file was generated by the GEOS Resource Compiler\n"
 193         ";\n"
 194         ";\tDO NOT EDIT! Any changes will be lost!\n"
 195         ";\n"
 196         ";\tEdit proper resource file instead.\n"
 197         ";\n\n");
 198 }
 199
 200
 201 static void openCFile (void)
 202 {
 203     if ((outputCFile = fopen (outputCName,outputCMode)) == 0) {
 204         AbEnd ("Can't open file %s for writing: %s", outputCName, strerror (errno));
 205     }
 206
 207     if (CFnum == 0) {
 208         outputCMode[0] = 'a';
 209         printCHeader ();
 210         CFnum++;
 211     }
 212 }
 213
 214
 215 static void openSFile (void)
 216 {
 217     if ((outputSFile = fopen (outputSName, outputSMode)) == 0) {
 218         AbEnd ("Can't open file %s for writing: %s", outputSName, strerror (errno));
 219     }
 220
 221     if (SFnum == 0) {
 222         outputSMode[0] = 'a';
 223         printSHeader ();
 224         SFnum++;
 225     }
 226 }
 227
 228
 229 static int findToken (const char * const *tokenTbl, const char *token)
 230 {
 231     /* takes as input table of tokens and token, returns position in table or -1 if not found */
 232     int i;
 233
 234     for (i = 0; tokenTbl[i][0]; i++) {
 235         if (strcmp (tokenTbl[i], token) == 0) {
 236             return i;
 237         }
 238     }
 239
 240     return -1;
 241 }
 242
 243
 244 static char *nextPhrase (void)
 245 {
 246     return strtok (NULL, "\"");
 247 }
 248
 249
 250 static char *nextWord (void)
 251 {
 252     return strtok (NULL, " ");
 253 }
 254
 255
 256 static void setLen (char *name, unsigned len)
 257 {
 258     if (strlen (name) > len) {
 259         name[len] = '\0';
 260     }
 261 }
 262
 263
 264 static void fillOut (char *name, int len, char *filler)
 265 {
 266     int a;
 267
 268     setLen (name, len);
 269     fprintf (outputSFile, "\t.byte \"%s\"\n", name);
 270
 271     a = strlen (name);
 272     if (a < len) {
 273         fprintf (outputSFile, "\t.res  (%i - %i), %s\n", len, a, filler);
 274     }
 275 }
 276
 277
 278 static char *bintos (unsigned char a, char out[7])
 279 {
 280     int i=0;
 281
 282     for (; i < 8; i++) {
 283         out[7 - i] = ((a & 1) == 0) ? '0' : '1';
 284         a = a >> 1;
 285     }
 286     out[i] = '\0';
 287
 288     return out;
 289 }
 290
 291
 292 static int getNameSize (const char *word)
 293 {
 294     /* count length of a word using BSW 9 font table */
 295     int a = 0, i = 0;
 296
 297     while (word[i] != '\0') {
 298         a += (BSWTab[word[i] - 31] - BSWTab[word[i] - 32]);
 299         i++;
 300     }
 301
 302     return a;
 303 }
 304
 305
 306 static void DoMenu (void)
 307 {
 308     int a, size, tmpsize, item = 0;
 309     char *token;
 310     char namebuff[255] = "";
 311     struct menu myMenu;
 312     struct menuitem *curItem, *newItem;
 313
 314     openCFile ();
 315
 316     myMenu.name = nextWord ();
 317     myMenu.left = atoi (nextWord ());
 318     myMenu.top = atoi (nextWord ());
 319     myMenu.type = nextWord ();
 320
 321     if (strcmp (nextWord (), "{") != 0) {
 322         AbEnd ("Menu '%s' description has no opening bracket!", myMenu.name);
 323     }
 324     curItem = xmalloc (sizeof(struct menuitem));
 325     myMenu.item = curItem;
 326
 327     for (;;) {
 328         token = nextWord ();
 329         if (strcmp (token, "}") == 0) break;
 330         if (token[strlen (token) - 1] != '"') {
 331             strcpy (namebuff, token);
 332             do {
 333                 token = nextWord ();
 334                 strcat (namebuff, " ");
 335                 strcat (namebuff, token);
 336             } while (token[strlen (token) - 1] != '"');
 337             token = xmalloc (strlen (namebuff));
 338             strcpy (token, namebuff);
 339         }
 340         curItem->name = token;
 341         curItem->type = nextWord ();
 342         curItem->target = nextWord ();
 343         newItem = xmalloc (sizeof(struct menuitem));
 344         curItem->next = newItem;
 345         curItem = newItem;
 346         item++;
 347     }
 348
 349     if (item == 0) AbEnd ("Menu '%s' has 0 items!", myMenu.name);
 350     if (item > 31) AbEnd ("Menu '%s' has too many items!", myMenu.name);
 351
 352     curItem->next = NULL;
 353
 354     /* count menu sizes */
 355     size = 0;
 356     curItem = myMenu.item;
 357     if (strstr (myMenu.type, "HORIZONTAL") != NULL) {
 358         /* menu is HORIZONTAL, ysize=15, sum xsize of all items +~8?*/
 359         myMenu.bot = myMenu.top + 15;
 360         for (a = 0; a != item; a++) {
 361             size += getNameSize (curItem->name);
 362             curItem = curItem->next;
 363         }
 364     } else {
 365         /* menu is VERTICAL, ysize=item*15, count largest xsize of all items +~8? */
 366         myMenu.bot = myMenu.top + (14 * item);
 367         for (a = 0; a != item; a++) {
 368             tmpsize = getNameSize (curItem->name);
 369             size = (size > tmpsize) ? size : tmpsize;
 370             curItem = curItem->next;
 371         }
 372     }
 373     myMenu.right = myMenu.left + size - 1;
 374
 375     curItem = myMenu.item;
 376     for (a = 0; a != item; a++) {
 377         /* print prototype only if MENU_ACTION or DYN_SUB_MENU are present in type */
 378         if ((strstr (curItem->type, "MENU_ACTION") != NULL) || (strstr (curItem->type, "DYN_SUB_MENU") != NULL)) {
 379             fprintf (outputCFile,
 380                 "void %s (void);\n",
 381                 curItem->target);
 382         }
 383         curItem=curItem->next;
 384     }
 385
 386     fprintf (outputCFile,
 387         "\n"
 388         "const void %s = {\n"
 389         "\t(char)%i, (char)%i,\n"
 390         "\t(int)%i, (int)%i,\n"
 391         "\t(char)(%i | %s),\n",
 392         myMenu.name, myMenu.top, myMenu.bot, myMenu.left, myMenu.right, item, myMenu.type);
 393
 394     curItem = myMenu.item;
 395     for (a = 0; a != item; a++) {
 396         fprintf (outputCFile,
 397             "\t%s, (char)%s, (int)",
 398             curItem->name, curItem->type);
 399         if ((strstr (curItem->type, "SUB_MENU") != NULL) && (strstr (curItem->type, "DYN_SUB_MENU") == NULL)) {
 400             fprintf (outputCFile,
 401                 "&");
 402         }
 403         fprintf (outputCFile,
 404             "%s,\n",
 405             curItem->target);
 406         curItem = curItem->next;
 407     }
 408
 409     fprintf (outputCFile,
 410         "};\n\n");
 411
 412     if (fclose (outputCFile) != 0) {
 413         AbEnd ("Error closing %s: %s", outputCName, strerror (errno));
 414     }
 415 }
 416
 417
 418 static void DoHeader (void)
 419 {
 420     time_t t;
 421     struct tm *my_tm;
 422
 423     struct appheader myHead;
 424     char *token;
 425     char i1[9], i2[9], i3[9];
 426     int i;
 427
 428     openSFile ();
 429
 430     token = nextWord ();
 431
 432     i = findToken (hdrFTypes, token);
 433
 434     if (apple == 1) {
 435         switch (i) {
 436             case 0:
 437                 myHead.geostype = 0x82;
 438                 break;
 439             default:
 440                 AbEnd ("Filetype '%s' is not supported yet", token);
 441         }
 442     } else {
 443         switch (i) {
 444             case 0:
 445                 myHead.geostype = 6;
 446                 break;
 447             case 1:
 448                 myHead.geostype = 14;
 449                 break;
 450             default:
 451                 AbEnd ("Filetype '%s' is not supported yet", token);
 452         }
 453     }
 454
 455     myHead.dosname = nextPhrase ();
 456     nextPhrase ();
 457     myHead.classname = nextPhrase ();
 458     nextPhrase ();
 459     myHead.version = nextPhrase ();
 460
 461     /* put default values into myHead here */
 462     myHead.author = "cc65";
 463     myHead.info = "Program compiled with cc65 and GEOSLib.";
 464     myHead.dostype = 128;
 465     if (apple == 0) myHead.dostype += 3;
 466     myHead.structure = 0;
 467     myHead.mode = 0;
 468     myHead.icon = NULL;
 469
 470     t = time (NULL);
 471     my_tm = localtime (&t);
 472
 473     myHead.year = my_tm->tm_year % 100;
 474     myHead.month = my_tm->tm_mon + 1;
 475     myHead.day = my_tm->tm_mday;
 476     myHead.hour = my_tm->tm_hour;
 477     myHead.min = my_tm->tm_min;
 478
 479     if (strcmp (nextWord (), "{") != 0) {
 480         AbEnd ("Header '%s' has no opening bracket!", myHead.dosname);
 481     }
 482
 483     for (;;) {
 484         token = nextWord ();
 485         if (strcmp (token, "}") == 0) break;
 486         switch (findToken (hdrFields, token)) {
 487             case -1:
 488                 AbEnd ("Unknown field '%s' in header '%s'", token, myHead.dosname);
 489                 break;
 490
 491             case 0: /* author */
 492                 myHead.author = nextPhrase ();
 493                 break;
 494
 495             case 1: /* info */
 496                 myHead.info = nextPhrase ();
 497                 break;
 498
 499             case 2: /* date */
 500                 myHead.year = atoi (nextWord ());
 501                 myHead.month = atoi (nextWord ());
 502                 myHead.day = atoi (nextWord ());
 503                 myHead.hour = atoi (nextWord ());
 504                 myHead.min = atoi (nextWord ());
 505                 break;
 506
 507             case 3: /* dostype */
 508                 switch (i = findToken (hdrDOSTp, nextWord ())) {
 509                     case -1:
 510                         AbEnd ("Unknown dostype in header '%s'", myHead.dosname);
 511                         break;
 512                     default:
 513                         if (apple == 0) myHead.dostype = i / 2 + 128 + 1;
 514                         break;
 515                 }
 516                 break;
 517
 518             case 4: /* mode */
 519                 switch (findToken (hdrModes, nextWord ())) {
 520                     case -1:
 521                         AbEnd ("Unknown mode in header '%s'", myHead.dosname);
 522                     case 0:
 523                         if (apple == 0) myHead.mode = 0x40;
 524                         break;
 525                     case 1:
 526                         if (apple == 0) myHead.mode = 0x00;
 527                         break;
 528                     case 2:
 529                         if (apple == 0) myHead.mode = 0xc0;
 530                         break;
 531                     case 3:
 532                         if (apple == 0) myHead.mode = 0x80;
 533                         break;
 534                 }
 535                 break;
 536
 537             case 5: /* structure */
 538                 switch (findToken (hdrStructTp, nextWord ())) {
 539                     case -1:
 540                         AbEnd ("unknown structure type in header '%s'", myHead.dosname);
 541                     case 0:
 542                     case 1:
 543                         myHead.structure = 0;
 544                         break;
 545                     case 2:
 546                     case 3:
 547                         myHead.structure = 1;
 548                         break;
 549                 }
 550                 break;
 551
 552             case 6: /* icon */
 553                 myHead.icon = nextPhrase ();
 554                 break;
 555         }
 556     }
 557
 558     /* OK, all information is gathered, do flushout */
 559
 560     fprintf (outputSFile,
 561         "\t\t.segment \"DIRENTRY\"\n\n");
 562
 563     if (apple == 1) {
 564
 565         if (myHead.structure == 0) {
 566             fprintf (outputSFile,
 567                 "\t.import __VLIR0_START__, __VLIR0_LAST__, __BSS_SIZE__\n\n");
 568         }
 569         fprintf (outputSFile,
 570             "\t.byte %i << 4 | %u\n",
 571             myHead.structure + 2, (unsigned)strlen (myHead.dosname));
 572
 573         fillOut (myHead.dosname, 15, "0");
 574
 575         fprintf (outputSFile,
 576             "\t.byte $%02x\n"
 577             "\t.word 0\n"
 578             "\t.word 0\n"
 579             "\t.word %s\n"
 580             "\t.byte 0\n"
 581             "\t.word %i << 9 | %i << 5 | %i, %i << 8 | %i\n"
 582             "\t.byte 0\n"
 583             "\t.byte 0\n"
 584             "\t.byte 0\n"
 585             "\t.word 0\n"
 586             "\t.word %i << 9 | %i << 5 | %i, %i << 8 | %i\n"
 587             "\t.word 0\n\n",
 588             myHead.geostype,
 589             myHead.structure == 0 ?
 590                 "__VLIR0_LAST__ - __VLIR0_START__ - __BSS_SIZE__" : "0",
 591             myHead.year, myHead.month, myHead.day, myHead.hour, myHead.min,
 592             myHead.year, myHead.month, myHead.day, myHead.hour, myHead.min);
 593
 594     } else {
 595
 596         fprintf (outputSFile,
 597             "\t.byte %i\n"
 598             "\t.word 0\n",
 599             myHead.dostype);
 600
 601         fillOut (myHead.dosname, 16, "$a0");
 602
 603         fprintf (outputSFile,
 604             "\t.word 0\n"
 605             "\t.byte %i\n"
 606             "\t.byte %i\n"
 607             "\t.byte %i, %i, %i, %i, %i\n\n"
 608             "\t.word 0\n"
 609             "\t.byte \"PRG formatted GEOS file V1.0\"\n\n",
 610             myHead.structure, myHead.geostype,
 611             myHead.year, myHead.month, myHead.day, myHead.hour, myHead.min);
 612     }
 613
 614     fprintf (outputSFile,
 615         "\t\t.segment \"FILEINFO\"\n\n"
 616         "\t.import __VLIR0_START__, __STARTUP_RUN__\n\n"
 617         "\t.byte 3, 21, 63 | $80\n");
 618
 619     if (myHead.icon != NULL) {
 620         fprintf (outputSFile,
 621             "\t.incbin \"%s\", 0, 63\n",
 622             myHead.icon);
 623     } else {
 624         for (i = 0; i != 63; i = i + 3) {
 625             fprintf (outputSFile,
 626                 "\t.byte %%%s, %%%s, %%%s\n",
 627                 bintos (icon1[i], i1), bintos (icon1[i+1], i2), bintos (icon1[i+2], i3));
 628         }
 629     }
 630
 631     fprintf (outputSFile,
 632         "\t.byte %i, %i, %i\n"
 633         "\t.word __VLIR0_START__, __VLIR0_START__ - 1, __STARTUP_RUN__\n\n",
 634         myHead.dostype, myHead.geostype, myHead.structure);
 635
 636     fillOut (myHead.classname, 12, "$20");
 637
 638     fillOut (myHead.version, 4, "0");
 639
 640     fprintf (outputSFile,
 641         "\t.byte 0, 0, 0\n"
 642         "\t.byte %i\n\n",
 643         myHead.mode);
 644
 645     setLen (myHead.author, 62);
 646     fprintf (outputSFile,
 647         "\t.byte \"%s\"\n"
 648         "\t.byte 0\n"
 649         "\t.res  (63 - %i)\n\n",
 650         myHead.author, (int)(strlen (myHead.author) + 1));
 651
 652     setLen (myHead.info, 95);
 653     fprintf (outputSFile,
 654         "\t.byte \"%s\"\n"
 655         "\t.byte 0\n\n",
 656         myHead.info);
 657
 658     if (fclose (outputSFile) != 0) {
 659         AbEnd ("Error closing %s: %s", outputSName, strerror (errno));
 660     }
 661 }
 662
 663
 664 static void DoMemory (void)
 665 {
 666     char *token;
 667     int stacksize, overlaysize;
 668     int overlaytable[127];
 669     int number, lastnumber;
 670     int backbuffer;
 671
 672     openSFile ();
 673
 674     stacksize = -1;
 675     overlaysize = -1;
 676     memset (overlaytable, 0, sizeof (overlaytable));
 677     lastnumber = -1;
 678     backbuffer = -1;
 679
 680     if (strcmp (nextWord (), "{") != 0) {
 681         AbEnd ("MEMORY description has no opening bracket!");
 682     }
 683
 684     token = NULL;
 685     for (;;) {
 686         if (token == NULL) token = nextWord ();
 687         if (strcmp (token, "}") == 0) break;
 688         switch (findToken (memFields, token)) {
 689             case -1:
 690                 AbEnd ("Unknown field '%s' in MEMORY description", token);
 691                 break;
 692
 693             case 0: /* stacksize */
 694                 stacksize = strtol (nextWord (), NULL, 0);
 695                 token = NULL;
 696                 break;
 697
 698             case 1: /* overlaysize */
 699                 overlaysize = strtol (nextWord (), NULL, 0);
 700                 token = NULL;
 701                 break;
 702
 703             case 2: /* overlaynums */
 704                 do {
 705                     token = nextWord ();
 706                     if (IsDigit (token[0]) == 0) break;
 707
 708                     number = atoi (token);
 709                     if (number < 0 || number > 126) {
 710                         AbEnd ("Overlay number %i is out of range 0-126", number);
 711                     }
 712                     if (overlaytable[number] == 1) {
 713                         AbEnd ("Overlay number %i is defined twice", number);
 714                     }
 715
 716                     overlaytable[number] = 1;
 717                     if (number > lastnumber) lastnumber = number;
 718
 719                 } while (IsDigit (token[0]) != 0);
 720
 721                 if (lastnumber == -1) {
 722                     AbEnd ("There must be at least one overlay number");
 723                 }
 724
 725                 /* always include number 0 */
 726                 overlaytable[0] = 1;
 727                 break;
 728
 729             case 3: /* backbuffer */
 730                 switch (findToken (toggle, nextWord ())) {
 731                     case -1:
 732                         AbEnd ("Unknown value for 'backbuffer'");
 733                         break;
 734                     case 0:
 735                     case 1:
 736                     case 2:
 737                         backbuffer = 0;
 738                         break;
 739                     default:
 740                         backbuffer = 1;
 741                         break;
 742                 }
 743                 token = NULL;
 744                 break;
 745         }
 746     }
 747
 748     /* OK, all information is gathered, do flushout */
 749
 750     if (lastnumber != -1) {
 751         fprintf (outputSFile,
 752             "\t\t.segment \"RECORDS\"\n\n");
 753
 754         if (apple == 1) {
 755
 756             for (number = 0; number <= lastnumber; number++) {
 757                 fprintf (outputSFile,
 758                     "\t.byte %s\n",
 759                     overlaytable[number] == 1 ? "$00" : "$FF");
 760             }
 761             fprintf (outputSFile,
 762                 "\n");
 763
 764             for (number = 0; number <= lastnumber; number++) {
 765                 if (overlaytable[number] == 1) {
 766                     fprintf (outputSFile,
 767                         "\t\t.segment \"VLIRIDX%i\"\n\n"
 768                         "\t.import __VLIR%i_START__, __VLIR%i_LAST__%s\n\n"
 769                         "\t.res  255\n"
 770                         "\t.byte .lobyte (__VLIR%i_LAST__ - __VLIR%i_START__%s)\n"
 771                         "\t.res  255\n"
 772                         "\t.byte .hibyte (__VLIR%i_LAST__ - __VLIR%i_START__%s)\n\n",
 773                         number, number, number,
 774                         number == 0 ? ", __BSS_SIZE__" : "",
 775                         number, number,
 776                         number == 0 ? " - __BSS_SIZE__" : "",
 777                         number, number,
 778                         number == 0 ? " - __BSS_SIZE__" : "");
 779                 }
 780             }
 781
 782         } else {
 783
 784             for (number = 0; number <= lastnumber; number++) {
 785                 if (overlaytable[number] == 1) {
 786                     fprintf (outputSFile,
 787                         "\t.import __VLIR%i_START__, __VLIR%i_LAST__%s\n",
 788                         number, number, number == 0 ? ", __BSS_SIZE__" : "");
 789                 }
 790             }
 791             fprintf (outputSFile,
 792                 "\n");
 793
 794             for (number = 0; number <= lastnumber; number++) {
 795                 if (overlaytable[number] == 1) {
 796                     fprintf (outputSFile,
 797                         "\t.byte .lobyte ((__VLIR%i_LAST__ - __VLIR%i_START__%s - 1) /    254) + 1\n"
 798                         "\t.byte .lobyte ((__VLIR%i_LAST__ - __VLIR%i_START__%s - 1) .MOD 254) + 2\n",
 799                         number, number, number == 0 ? " - __BSS_SIZE__" : "",
 800                         number, number, number == 0 ? " - __BSS_SIZE__" : "");
 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) {
 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 }