tools/genmodule/config.c

   1 /*
   2     Copyright © 1995-2009, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Code to parse the command line options and the module config file for
   6     the genmodule program
   7 */
   8
   9 #include <string.h>
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <time.h>
  13 #include <unistd.h>
  14
  15 #include "functionhead.h"
  16 #include "config.h"
  17
  18 const static char bannertemplate[] =
  19     "/*\n"
  20     "    *** Automatically generated from '%s'. Edits will be lost. ***\n"
  21     "    Copyright © 1995-2009, The AROS Development Team. All rights reserved.\n"
  22     "*/\n";
  23
  24 const char*
  25 getBanner(struct config* config)
  26 {
  27     int bannerlength = strlen(config->conffile) + strlen(bannertemplate) -1;
  28     char * banner = malloc(bannerlength);
  29
  30     snprintf (banner, bannerlength, bannertemplate, config->conffile);
  31
  32     return(banner);
  33 }
  34
  35 void
  36 freeBanner(char *banner)
  37 {
  38     free((void *)banner);
  39 }
  40
  41 const static char usage[] =
  42     "\n"
  43     "Usage: genmodule [-c conffile] [-s suffix] [-d gendir] [-r reffile] [-n]\n"
  44     "       {writefiles|writemakefile|writeincludes|writedummy|writelibdefs|writefunclist} modname modtype\n"
  45 ;
  46
  47 static void readconfig(struct config *);
  48 static struct classinfo *newclass(struct config *);
  49
  50 /* the method prefices for the supported classes */
  51 static const char *muimprefix[] =
  52 {
  53     "__OM_",
  54     "__MUIM_",
  55     NULL
  56 };
  57 static const char *gadgetmprefix[] =
  58 {
  59     "__OM_",
  60     "__GM_",
  61     "__AROSM_",
  62     NULL
  63 };
  64 static const char *dtmprefix[] =
  65 {
  66     "__OM_",
  67     "__GM_",
  68     "__DTM_",
  69     "__PDTM_",
  70     NULL
  71 };
  72
  73 /* Create a config struct. Initialize with the values from the programs command
  74  * line arguments and the contents of the modules .conf file
  75  */
  76 struct config *initconfig(int argc, char **argv)
  77 {
  78     struct config *cfg;
  79     char *s, **argvit = argv + 1;
  80     int hassuffix = 0, c;
  81
  82     cfg = malloc(sizeof(struct config));
  83     if (cfg == NULL)
  84     {
  85         fprintf(stderr, "Out of memory\n");
  86         exit(20);
  87     }
  88
  89     memset(cfg, 0, sizeof(struct config));
  90
  91     while ((c = getopt(argc, argv, ":c:s:d:r:")) != -1)
  92     {
  93         if (c == ':')
  94         {
  95             fprintf(stderr, "Option -%c needs an argument\n",optopt);
  96             exit(20);
  97         }
  98
  99         switch (c)
 100         {
 101         case 'c':
 102             cfg->conffile = optarg;
 103             break;
 104         case 's':
 105             cfg->suffix = optarg;
 106             hassuffix = 1;
 107             break;
 108         case 'd':
 109             /* Remove / at end if present */
 110             if ((optarg)[strlen(*argvit)-1]=='/') (optarg)[strlen(optarg)-1]='\0';
 111             cfg->gendir = optarg;
 112             break;
 113         case 'r':
 114             cfg->reffile = optarg;
 115             break;
 116         default:
 117             fprintf(stderr, "Internal error: Unhandled option\n");
 118             exit(20);
 119         }
 120     }
 121
 122     if (optind + 3 != argc)
 123     {
 124         fprintf(stderr, "Wrong number of arguments.\n%s", usage);
 125         exit(20);
 126     }
 127
 128     if (strcmp(argv[optind], "writefiles") == 0)
 129     {
 130         cfg->command = FILES;
 131     }
 132     else if (strcmp(argv[optind], "writemakefile") == 0)
 133     {
 134         cfg->command = MAKEFILE;
 135     }
 136     else if (strcmp(argv[optind], "writeincludes") == 0)
 137     {
 138         cfg->command = INCLUDES;
 139     }
 140     else if (strcmp(argv[optind], "writelibdefs") == 0)
 141     {
 142         cfg->command = LIBDEFS;
 143     }
 144     else if (strcmp(argv[optind], "writedummy") == 0)
 145     {
 146         cfg->command = DUMMY;
 147     }
 148     else if (strcmp(argv[optind], "writefunclist") == 0)
 149     {
 150         cfg->command = WRITEFUNCLIST;
 151     }
 152     else
 153     {
 154         fprintf(stderr, "Unrecognized argument \"%s\"\n%s", argv[optind], usage);
 155         exit(20);
 156     }
 157
 158     cfg->modulename = argv[optind+1];
 159     cfg->modulenameupper = strdup(cfg->modulename);
 160     for (s=cfg->modulenameupper; *s!='\0'; *s = toupper(*s), s++)
 161         ;
 162
 163     if (strcmp(argv[optind+2],"library")==0)
 164     {
 165         cfg->modtype = LIBRARY;
 166         cfg->moddir = "Libs";
 167     }
 168     else if (strcmp(argv[optind+2],"mcc")==0)
 169     {
 170         cfg->modtype = MCC;
 171         cfg->moddir = "Classes/Zune";
 172     }
 173     else if (strcmp(argv[optind+2],"mui")==0)
 174     {
 175         cfg->modtype = MUI;
 176         cfg->moddir = "Classes/Zune";
 177     }
 178     else if (strcmp(argv[optind+2],"mcp")==0)
 179     {
 180         cfg->modtype = MCP;
 181         cfg->moddir = "Classes/Zune";
 182     }
 183     else if (strcmp(argv[optind+2], "device")==0)
 184     {
 185         cfg->modtype = DEVICE;
 186         cfg->moddir = "Devs";
 187     }
 188     else if (strcmp(argv[optind+2], "resource")==0)
 189     {
 190         cfg->modtype = RESOURCE;
 191         cfg->moddir = "Devs";
 192     }
 193     else if (strcmp(argv[optind+2], "gadget")==0)
 194     {
 195         cfg->modtype = GADGET;
 196         cfg->moddir = "Classes/Gadgets";
 197     }
 198     else if (strcmp(argv[optind+2], "datatype")==0)
 199     {
 200         cfg->modtype = DATATYPE;
 201         cfg->moddir = "Classes/Datatypes";
 202     }
 203     else if (strcmp(argv[optind+2], "usbclass")==0)
 204     {
 205         cfg->modtype = USBCLASS;
 206         cfg->moddir = "Classes/USB";
 207     if(!hassuffix)
 208     {
 209         cfg->suffix = "class";
 210         hassuffix = 1;
 211     }
 212     }
 213     else if (strcmp(argv[optind+2], "hidd")==0)
 214     {
 215         cfg->modtype = HIDD;
 216         cfg->moddir = "Devs/Drivers";
 217     }
 218     else
 219     {
 220         fprintf(stderr, "Unknown modtype \"%s\" specified for second argument\n", argv[2]);
 221         exit(20);
 222     }
 223
 224     if (!hassuffix)
 225         cfg->suffix = argv[optind+2];
 226
 227     /* Fill fields with default value if not specified on the command line */
 228     {
 229         char tmpbuf[256];
 230
 231         if (cfg->conffile == NULL)
 232         {
 233             snprintf(tmpbuf, sizeof(tmpbuf), "%s.conf", cfg->modulename);
 234             cfg->conffile = strdup(tmpbuf);
 235         }
 236
 237         if (cfg->gendir == NULL)
 238             cfg->gendir = ".";
 239
 240         if (cfg->command != FILES && cfg->command != INCLUDES && cfg->command != WRITEFUNCLIST)
 241         {
 242             if (cfg->reffile != NULL)
 243                 fprintf(stderr, "WARNING ! Option -r ingored for %s\n", argv[optind]);
 244         }
 245         else if (cfg->command == FILES && cfg->reffile == NULL)
 246         {
 247             snprintf(tmpbuf, sizeof(tmpbuf), "%s.ref", cfg->modulename);
 248             cfg->reffile = strdup(tmpbuf);
 249         }
 250     }
 251
 252     readconfig(cfg);
 253
 254     /* For a device add the functions given in beginiofunc and abortiofunc to the functionlist
 255      * if they are provided
 256      */
 257     if (cfg->beginiofunc != NULL)
 258     {
 259         struct functionhead *funchead;
 260
 261         cfg->intcfg |= CFG_NOREADREF;
 262
 263         /* Add beginio_func to the list of functions */
 264         funchead = newfunctionhead(cfg->beginiofunc, REGISTERMACRO);
 265         funchead->type = strdup("void");
 266         funchead->lvo = 5;
 267         funcaddarg(funchead, "struct IORequest *ioreq", "A1");
 268
 269         funchead->next = cfg->funclist;
 270         cfg->funclist = funchead;
 271
 272         /* Add abortio_func to the list of functions */
 273         funchead = newfunctionhead(cfg->abortiofunc, REGISTERMACRO);
 274         funchead->type = strdup("LONG");
 275         funchead->lvo = 6;
 276         funcaddarg(funchead, "struct IORequest *ioreq", "A1");
 277
 278         funchead->next = cfg->funclist->next;
 279         cfg->funclist->next = funchead;
 280     }
 281     else if (cfg->modtype == DEVICE && cfg->intcfg & CFG_NOREADREF)
 282     {
 283         fprintf
 284         (
 285             stderr,
 286             "beginio_func and abortio_func missing for a device with a non empty function list\n"
 287         );
 288         exit(20);
 289     }
 290
 291     return cfg;
 292 }
 293
 294 /* Functions to read configuration from the configuration file */
 295
 296 #include "fileread.h"
 297
 298 static char *readsections(struct config *, struct classinfo *, int);
 299 static void readsectionconfig(struct config *, struct classinfo *, int);
 300 static void readsectioncdef(struct config *);
 301 static void readsectioncdefprivate(struct config *);
 302 static void readsectionstartup(struct config *);
 303 static void readsectionfunctionlist(struct config *);
 304 static void readsectionmethodlist(struct classinfo *);
 305 static void readsectionclass(struct config *);
 306
 307 static void readconfig(struct config *cfg)
 308 {
 309     struct classinfo *mainclass = NULL;
 310
 311     /* Create a classinfo structure if this module is a class */
 312     switch (cfg->modtype)
 313     {
 314     case LIBRARY:
 315     case DEVICE:
 316     case RESOURCE:
 317     case USBCLASS:
 318         break;
 319
 320     case MCC:
 321     case MUI:
 322     case MCP:
 323     case GADGET:
 324     case DATATYPE:
 325     case HIDD:
 326         mainclass = newclass(cfg);
 327         mainclass->classtype = cfg->modtype;
 328         break;
 329
 330     default:
 331         fprintf(stderr, "Internal error: unsupported modtype for classinfo creation\n");
 332         exit(20);
 333     }
 334
 335     switch (cfg->modtype)
 336     {
 337     case LIBRARY:
 338     case USBCLASS:
 339         cfg->firstlvo = 5;
 340         break;
 341     case DEVICE:
 342         cfg->firstlvo = 7;
 343         break;
 344     case MCC:
 345     case MUI:
 346     case MCP:
 347         cfg->firstlvo = 6;
 348         mainclass->boopsimprefix = muimprefix;
 349         break;
 350     case RESOURCE:
 351         cfg->firstlvo = 1;
 352         break;
 353     case GADGET:
 354         cfg->firstlvo = 5;
 355         mainclass->boopsimprefix = gadgetmprefix;
 356         break;
 357     case DATATYPE:
 358         cfg->firstlvo = 6;
 359         mainclass->boopsimprefix = dtmprefix;
 360         break;
 361     case HIDD:
 362         cfg->firstlvo = 5;
 363         /* FIXME: need boopsimprefix ? */
 364         break;
 365     default:
 366         fprintf(stderr, "Internal error: unsupported modtype for firstlvo\n");
 367         exit(20);
 368     }
 369
 370     if (!fileopen(cfg->conffile))
 371     {
 372         fprintf(stderr, "In readconfig: Could not open %s\n", cfg->conffile);
 373         exit(20);
 374     }
 375
 376     /* Read all sections and see that we are at the end of the file */
 377     if (readsections(cfg, mainclass, 0) != NULL)
 378         exitfileerror(20, "Syntax error");
 379
 380     fileclose();
 381 }
 382
 383 /* readsections will scan through all the sections in the config file.
 384  * arguments:
 385  * struct config *cfg: The module config data which may be updated by
 386  *     the information in the sections
 387  * struct classinfo *cl: The classdata to be filled with data from the sections.
 388  *     This may be NULL if this is the main part of the configuration file and the
 389  *     type of the module is not a class
 390  * int inclass: Boolean to indicate if we are in a class part. If not we are in the main
 391  *     part of the config file.
 392  */
 393 static char *readsections(struct config *cfg, struct classinfo *cl, int inclass)
 394 {
 395     char *line, *s, *s2;
 396     int hasconfig = 0;
 397
 398     while ((line=readline())!=NULL)
 399     {
 400         if (strncmp(line, "##", 2)==0)
 401         {
 402             static char *parts[] =
 403             {
 404                 "config", "cdefprivate", "cdef", "startup", "functionlist", "methodlist", "class"
 405             };
 406             const unsigned int nums = sizeof(parts)/sizeof(char *);
 407             unsigned int partnum;
 408             int i, atend = 0;
 409
 410             s = line+2;
 411             while (isspace(*s)) s++;
 412
 413             if (strncmp(s, "begin", 5)!=0)
 414                 return line;
 415
 416             s += 5;
 417             if (!isspace(*s))
 418                 exitfileerror(20, "space after begin expected\n");
 419             while (isspace(*s)) s++;
 420
 421             for (i = 0, partnum = 0; partnum==0 && i<nums; i++)
 422             {
 423                 if (strncmp(s, parts[i], strlen(parts[i]))==0)
 424                 {
 425                     partnum = i+1;
 426                     s += strlen(parts[i]);
 427                     while (isspace(*s)) s++;
 428                     if (*s!='\0')
 429                         exitfileerror(20, "unexpected character on position %d\n", s-line);
 430                 }
 431             }
 432             if (partnum==0)
 433                 exitfileerror(20, "unknown start of section\n");
 434             switch (partnum)
 435             {
 436             case 1: /* config */
 437                 readsectionconfig(cfg, cl, inclass);
 438                 hasconfig = 1;
 439                 break;
 440
 441             case 2: /* cdefprivate */
 442                 if (inclass)
 443                     exitfileerror(20, "cdefprivate section not allowed in class section\n");
 444                 readsectioncdefprivate(cfg);
 445                 break;
 446
 447             case 3: /* cdef */
 448                 if (inclass)
 449                     exitfileerror(20, "cdef section not allowed in class section\n");
 450                 readsectioncdef(cfg);
 451                 break;
 452
 453             case 4: /* startup */
 454                 if (inclass)
 455                     exitfileerror(20, "startup section not allowed in class section\n");
 456                 readsectionstartup(cfg);
 457                 break;
 458
 459             case 5: /* functionlist */
 460                 if (inclass)
 461                     exitfileerror(20, "functionlist section not allow in class section\n");
 462                 readsectionfunctionlist(cfg);
 463                 cfg->intcfg |= CFG_NOREADREF;
 464                 break;
 465
 466             case 6: /* methodlist */
 467                 if (cl == NULL)
 468                     exitfileerror(20, "methodlist section when not in a class\n");
 469                 readsectionmethodlist(cl);
 470                 cfg->intcfg |= CFG_NOREADREF;
 471                 break;
 472
 473             case 7: /* class */
 474                 if (inclass)
 475                     exitfileerror(20, "class section may not be nested\n");
 476                 readsectionclass(cfg);
 477                 break;
 478             }
 479         }
 480         else if (strlen(line)!=0)
 481             filewarning("warning line outside section ignored\n");
 482     }
 483
 484     if(!inclass)
 485     {
 486         if (!hasconfig)
 487             exitfileerror(20, "No config section in conffile\n");
 488
 489         /* If no indication was given for generating includes or not
 490            decide on module type and if there are functions
 491          */
 492         if(!((cfg->options & OPTION_INCLUDES) || (cfg->options & OPTION_NOINCLUDES)))
 493         {
 494             switch (cfg->modtype)
 495             {
 496             case LIBRARY:
 497             case RESOURCE:
 498             case USBCLASS:
 499                 cfg->options |= OPTION_INCLUDES;
 500                 break;
 501
 502             case DEVICE:
 503                 cfg->options |= (
 504                     (cfg->funclist != NULL)
 505                     || (cfg->cdeflines != NULL)
 506                     || strcmp(cfg->libbasetypeptrextern, "struct Device *") != 0
 507                 ) ? OPTION_INCLUDES : OPTION_NOINCLUDES;
 508                 break;
 509
 510             case GADGET:
 511             case DATATYPE:
 512             case MCC:
 513             case MUI:
 514             case MCP:
 515             case HIDD:
 516                 cfg->options |= (
 517                     (cfg->funclist != NULL)
 518                     || (cfg->cdeflines != NULL)
 519                 ) ? OPTION_INCLUDES : OPTION_NOINCLUDES;
 520                 break;
 521
 522             default:
 523                 fprintf(stderr, "Internal error writemakefile: unhandled modtype for includes\n");
 524                 exit(20);
 525                 break;
 526             }
 527         }
 528
 529         /* If no indication was given for not generating stubs only generate them if
 530          * the module has functions
 531          */
 532         if(!((cfg->options & OPTION_STUBS) || (cfg->options & OPTION_NOSTUBS)))
 533         {
 534             cfg->options |= (cfg->funclist != NULL) ?
 535                 OPTION_STUBS : OPTION_NOSTUBS;
 536         }
 537
 538         /* If no indication was given for generating autoinit code or not
 539            decide on module type
 540          */
 541         if(!((cfg->options & OPTION_AUTOINIT) || (cfg->options & OPTION_NOAUTOINIT)))
 542         {
 543             switch (cfg->modtype)
 544             {
 545             case LIBRARY:
 546             case USBCLASS:
 547                 cfg->options |= OPTION_AUTOINIT;
 548                 break;
 549
 550             case RESOURCE:
 551             case GADGET:
 552             case DEVICE:
 553             case DATATYPE:
 554             case MCC:
 555             case MUI:
 556             case MCP:
 557             case HIDD:
 558                 cfg->options |= OPTION_NOAUTOINIT;
 559                 break;
 560
 561             default:
 562                 fprintf(stderr, "Internal error writemakefile: unhandled modtype for autoinit\n");
 563                 exit(20);
 564                 break;
 565             }
 566         }
 567     }
 568     return NULL;
 569 }
 570
 571 static void readsectionconfig(struct config *cfg, struct classinfo *cl, int inclass)
 572 {
 573     int atend = 0, i;
 574     char *line, *s, *s2, *libbasetypeextern = NULL;
 575     struct tm date;
 576
 577     while (!atend)
 578     {
 579         line = readline();
 580         if (line==NULL)
 581             exitfileerror(20, "unexpected end of file in section config\n");
 582
 583         if (strncmp(line, "##", 2)!=0)
 584         {
 585             const char *names[] =
 586             {
 587                 "basename", "libbase", "libbasetype", "libbasetypeextern",
 588                 "version", "date", "copyright", "libcall", "forcebase", "superclass",
 589                 "superclass_field", "residentpri", "options", "sysbase_field",
 590                 "seglist_field", "rootbase_field", "classptr_field", "classptr_var",
 591                 "classid", "classdatatype", "beginio_func", "abortio_func", "dispatcher",
 592                 "initpri", "type", "getidfunc"
 593             };
 594             const unsigned int namenums = sizeof(names)/sizeof(char *);
 595             unsigned int namenum;
 596
 597             for (i = 0, namenum = 0; namenum==0 && i<namenums; i++)
 598             {
 599                 if
 600                 (
 601                        strncmp(line, names[i], strlen(names[i]))==0
 602                     && isspace(*(line+strlen(names[i])))
 603                 )
 604                     namenum = i+1;
 605             }
 606             if (namenum==0)
 607                 exitfileerror(20, "unrecognized configuration option\n");
 608
 609             s = line + strlen(names[namenum-1]);
 610             if (!isspace(*s))
 611                 exitfileerror(20, "space character expected after \"%s\"\n", names[namenum-1]);
 612
 613             while (isspace(*s)) s++;
 614             if (*s=='\0')
 615                 exitfileerror(20, "unexpected end of line\n");
 616
 617             s2 = s + strlen(s);
 618             while (isspace(*(s2-1))) s2--;
 619             *s2 = '\0';
 620
 621             switch (namenum)
 622             {
 623             case 1: /* basename */
 624                 if (!inclass)
 625                     cfg->basename = strdup(s);
 626                 if (cl != NULL)
 627                     cl->basename = strdup(s);
 628                 break;
 629
 630             case 2: /* libbase */
 631                 if (inclass)
 632                     exitfileerror(20, "libbase not valid config option when in a class section\n");
 633                 cfg->libbase = strdup(s);
 634                 break;
 635
 636             case 3: /* libbasetype */
 637                 if (inclass)
 638                     exitfileerror(20, "libbasetype not valid config option when in a class section\n");
 639                 cfg->libbasetype = strdup(s);
 640                 break;
 641
 642             case 4: /* libbasetypeextern */
 643                 if (inclass)
 644                     exitfileerror(20, "libbasetype not valid config option when in a class section\n");
 645                 libbasetypeextern = strdup(s);
 646                 break;
 647
 648             case 5: /* version */
 649                 if (inclass)
 650                     exitfileerror(20, "version not valid config option when in a class section\n");
 651                 if (sscanf(s, "%u.%u", &cfg->majorversion, &cfg->minorversion)!=2)
 652                     exitfileerror(20, "wrong version string \"%s\"\n", s);
 653                 break;
 654
 655             case 6: /* date */
 656                 if (inclass)
 657                     exitfileerror(20, "date not valid config option when in a class section\n");
 658                 if (strptime(s, "%e.%m.%Y", &date) == NULL)
 659                 {
 660                     exitfileerror(20, "date string has to have d.m.yyyy format\n");
 661                 }
 662                 cfg->datestring = strdup(s);
 663                 break;
 664
 665             case 7: /* copyright */
 666                 if (inclass)
 667                     exitfileerror(20, "copyright not valid config option when in a class section\n");
 668                 cfg->copyright = strdup(s);
 669                 break;
 670
 671             case 8: /* libcall */
 672                 fprintf(stderr, "libcall specification is deprecated and ignored\n");
 673                 break;
 674
 675             case 9: /* forcebase */
 676                 if (inclass)
 677                     exitfileerror(20, "forcebase not valid config option when in a class section\n");
 678                 slist_append(&cfg->forcelist, s);
 679                 break;
 680
 681             case 10: /* superclass */
 682                 if (cl == NULL)
 683                     exitfileerror(20, "superclass specified when not a BOOPSI class\n");
 684                 cl->superclass = strdup(s);
 685                 break;
 686
 687             case 11: /* superclass_field */
 688                 if (cl == NULL)
 689                     exitfileerror(20, "superclass_field specified when not a BOOPSI class\n");
 690                 cl->superclass_field = strdup(s);
 691                 break;
 692
 693             case 12: /* residentpri */
 694                 if (!inclass)
 695                 {
 696                     int count;
 697                     char dummy;
 698
 699                     count = sscanf(s, "%d%c", &cfg->residentpri, &dummy);
 700                     if (count != 1 ||
 701                         cfg->residentpri < -128 || cfg->residentpri > 127
 702                     )
 703                     {
 704                         exitfileerror(20, "residentpri number format error\n");
 705                     }
 706                 }
 707                 else
 708                     exitfileerror(20, "residentpri not valid config option when in a class section\n");
 709                 break;
 710
 711             case 13: /* options */
 712                 if (!inclass)
 713                 {
 714                     static const char *optionnames[] =
 715                     {
 716                         "noautolib", "noexpunge", "noresident", "peropenerbase",
 717                         "peridbase", "includes", "noincludes", "nostubs",
 718                         "autoinit", "noautoinit"
 719                     };
 720                     const unsigned int optionnums = sizeof(optionnames)/sizeof(char *);
 721                     int optionnum;
 722
 723                     do
 724                     {
 725                         for (i = 0, optionnum = 0; optionnum==0 && i<optionnums; i++)
 726                         {
 727                             if (strncmp(s, optionnames[i], strlen(optionnames[i]))==0)
 728                             {
 729                                 optionnum = i + 1;
 730                                 s += strlen(optionnames[i]);
 731                                 while (isspace(*s)) s++;
 732                                 if (*s == ',')
 733                                     s++;
 734                                 else if (*s != '\0')
 735                                     exitfileerror(20, "Unrecognized option\n");
 736                             }
 737                         }
 738                         if (optionnum == 0)
 739                             exitfileerror(20, "Unrecognized option\n");
 740                         switch (optionnum)
 741                         {
 742                         case 1: /* noautolib */
 743                             cfg->options |= OPTION_NOAUTOLIB;
 744                             break;
 745                         case 2: /* noexpunge */
 746                             cfg->options |= OPTION_NOEXPUNGE;
 747                             break;
 748                         case 3: /* noresident */
 749                             cfg->options |= OPTION_NORESIDENT;
 750                             cfg->firstlvo = 1;
 751                             break;
 752                         case 5: /* peridbase */
 753                             cfg->options |= OPTION_DUPPERID;
 754                             /* Fall through */
 755                         case 4: /* peropenerbase */
 756                             if (cfg->options & OPTION_DUPBASE)
 757                                 exitfileerror(20, "Only one option peropenerbase or peridbase allowed\n");
 758                             cfg->options |= OPTION_DUPBASE;
 759                             break;
 760                         case 6: /* includes */
 761                             if (cfg->options & OPTION_NOINCLUDES)
 762                                 exitfileerror(20, "option includes and noincludes are incompatible\n");
 763                             cfg->options |= OPTION_INCLUDES;
 764                             break;
 765                         case 7: /* noincludes */
 766                             if (cfg->options & OPTION_INCLUDES)
 767                                 exitfileerror(20, "option includes and noincludes are incompatible\n");
 768                             cfg->options |= OPTION_NOINCLUDES;
 769                             break;
 770                         case 8: /* nostubs */
 771                             cfg->options |= OPTION_NOSTUBS;
 772                             break;
 773                         case 9: /* autoinit */
 774                             if (cfg->options & OPTION_NOAUTOINIT)
 775                                 exitfileerror(20, "option autoinit and noautoinit are incompatible\n");
 776                             cfg->options |= OPTION_AUTOINIT;
 777                         case 10: /* noautoinit */
 778                             if (cfg->options & OPTION_AUTOINIT)
 779                                 exitfileerror(20, "option autoinit and noautoinit are incompatible\n");
 780                             cfg->options |= OPTION_NOAUTOINIT;
 781                         }
 782                         while (isspace(*s)) s++;
 783                     } while(*s !='\0');
 784                 }
 785                 else
 786                 {
 787                     static const char *optionnames[] =
 788                     {
 789                         "private"
 790                     };
 791                     const unsigned int optionnums = sizeof(optionnames)/sizeof(char *);
 792                     int optionnum;
 793
 794                     do
 795                     {
 796                         for (i = 0, optionnum = 0; optionnum==0 && i<optionnums; i++)
 797                         {
 798                             if (strncmp(s, optionnames[i], strlen(optionnames[i]))==0)
 799                             {
 800                                 optionnum = i + 1;
 801                                 s += strlen(optionnames[i]);
 802                                 while (isspace(*s)) s++;
 803                                 if (*s == ',')
 804                                     s++;
 805                                 else if (*s != '\0')
 806                                     exitfileerror(20, "Unrecognized option\n");
 807                             }
 808                         }
 809                         if (optionnum == 0)
 810                             exitfileerror(20, "Unrecognized option\n");
 811                         switch (optionnum)
 812                         {
 813                         case 1: /* private */
 814                             cl->options |= COPTION_PRIVATE;
 815                             break;
 816                         }
 817                         while (isspace(*s)) s++;
 818                     } while(*s !='\0');
 819                 }
 820                 break;
 821
 822             case 14: /* sysbase_field */
 823                 if (inclass)
 824                     exitfileerror(20, "sysbase_field not valid config option when in a class section\n");
 825                 cfg->sysbase_field = strdup(s);
 826                 break;
 827
 828             case 15: /* seglist_field */
 829                 if (inclass)
 830                     exitfileerror(20, "seglist_field not valid config option when in a class section\n");
 831                 cfg->seglist_field = strdup(s);
 832                 break;
 833
 834             case 16: /* rootbase_field */
 835                 if (inclass)
 836                     exitfileerror(20, "rootbase_field not valid config option when in a class section\n");
 837                 cfg->rootbase_field = strdup(s);
 838                 break;
 839
 840             case 17: /* classptr_field */
 841                 if (cl == NULL)
 842                 {
 843                     exitfileerror
 844                     (
 845                         20,
 846                         "classptr_field specified when not a BOOPSI class\n"
 847                     );
 848                 }
 849                 cl->classptr_field = strdup(s);
 850                 break;
 851
 852             case 18: /* classptr_var */
 853                 if (cl == NULL)
 854                 {
 855                     exitfileerror
 856                     (
 857                         20,
 858                         "classptr_var specified when not a BOOPSI class\n"
 859                     );
 860                 }
 861                 cl->classptr_var = strdup(s);
 862                 break;
 863
 864             case 19: /* classid */
 865                 if (cl == NULL)
 866                     exitfileerror(20, "classid specified when not a BOOPSI class\n");
 867                 if (cl->classid != NULL)
 868                     exitfileerror(20, "classid specified twice\n");
 869                 cl->classid = strdup(s);
 870                 if (strcmp(cl->classid, "NULL") == 0)
 871                     cl->options |= COPTION_PRIVATE;
 872                 break;
 873
 874             case 20: /* classdatatype */
 875                 if (cl == NULL)
 876                     exitfileerror(20, "classdatatype specified when not a BOOPSI class\n");
 877                 cl->classdatatype = strdup(s);
 878                 break;
 879
 880             case 21: /* beginio_func */
 881                 if (inclass)
 882                     exitfileerror(20, "beginio_func not valid config option when in a class section\n");
 883                 if (cfg->modtype != DEVICE)
 884                     exitfileerror(20, "beginio_func specified when not a device\n");
 885                 cfg->beginiofunc = strdup(s);
 886                 break;
 887
 888             case 22: /* abortio_func */
 889                 if (inclass)
 890                     exitfileerror(20, "abortio_func not valid config option when in a class section\n");
 891                 if (cfg->modtype != DEVICE)
 892                     exitfileerror(20, "abortio_func specified when not a device\n");
 893                 cfg->abortiofunc = strdup(s);
 894                 break;
 895
 896             case 23: /* dispatcher */
 897                 if (cl == NULL)
 898                     exitfileerror(20, "dispatcher specified when not a BOOPSI class\n");
 899                 cl->dispatcher = strdup(s);
 900                 /* function references are not needed when dispatcher is specified */
 901                 cfg->intcfg |= CFG_NOREADREF;
 902                 break;
 903
 904             case 24: /* initpri */
 905                 if (cl != NULL)
 906                 {
 907                     int count;
 908                     char dummy;
 909
 910                     count = sscanf(s, "%d%c", &cl->initpri, &dummy);
 911                     if (count != 1 ||
 912                         cl->initpri < -128 || cl->initpri > 127
 913                     )
 914                     {
 915                         exitfileerror(20, "initpri number format error\n");
 916                     }
 917                 }
 918                 else
 919                     exitfileerror(20, "initpri only valid config option for a BOOPSI class\n");
 920                 break;
 921
 922             case 25: /* type */
 923                 if (!inclass)
 924                     exitfileerror(20, "type only valid config option in a class section\n");
 925                 if (strcmp(s,"mcc")==0)
 926                     cl->classtype = MCC;
 927                 else if (strcmp(s,"mui")==0)
 928                     cl->classtype = MUI;
 929                 else if (strcmp(s,"mcp")==0)
 930                     cl->classtype = MCP;
 931                 else if (strcmp(s, "image")==0)
 932                     cl->classtype = IMAGE;
 933                 else if (strcmp(s, "gadget")==0)
 934                     cl->classtype = GADGET;
 935                 else if (strcmp(s, "datatype")==0)
 936                     cl->classtype = DATATYPE;
 937                 else if (strcmp(s, "usbclass")==0)
 938                     cl->classtype = USBCLASS;
 939                 else if (strcmp(s, "class")==0)
 940                     cl->classtype = CLASS;
 941                 else if (strcmp(s, "hidd")==0)
 942                     cl->classtype = HIDD;
 943                 else
 944                 {
 945                     fprintf(stderr, "Unknown type \"%s\" specified\n", s);
 946                     exit(20);
 947                 }
 948                 break;
 949             case 26: /* getidfunc */
 950                 cfg->getidfunc = strdup(s);
 951                 break;
 952             }
 953         }
 954         else /* Line starts with ## */
 955         {
 956             s = line+2;
 957             while (isspace(*s)) s++;
 958             if (strncmp(s, "end", 3)!=0)
 959                 exitfileerror(20, "\"##end config\" expected\n");
 960
 961             s += 3;
 962             if (!isspace(*s))
 963                 exitfileerror(20, "\"##end config\" expected\n");
 964
 965             while (isspace(*s)) s++;
 966             if (strncmp(s, "config", 6)!=0)
 967                 exitfileerror(20, "\"##end config\" expected\n");
 968
 969             s += 6;
 970             while (isspace(*s)) s++;
 971             if (*s!='\0')
 972                 exitfileerror(20, "\"##end config\" expected\n");
 973
 974             atend = 1;
 975         }
 976     }
 977
 978     /* When not in a class section fill in default values for fields in cfg */
 979     if (!inclass)
 980     {
 981         if (cfg->basename==NULL)
 982         {
 983             cfg->basename = strdup(cfg->modulename);
 984             *cfg->basename = toupper(*cfg->basename);
 985         }
 986         if (cfg->libbase==NULL)
 987         {
 988             unsigned int len = strlen(cfg->basename)+5;
 989             cfg->libbase = malloc(len);
 990             snprintf(cfg->libbase, len, "%sBase", cfg->basename);
 991         }
 992         if (cfg->libbasetype == NULL && libbasetypeextern != NULL)
 993             cfg->libbasetype = strdup(libbasetypeextern);
 994         if (cfg->sysbase_field != NULL && cfg->libbasetype == NULL)
 995             exitfileerror(20, "sysbase_field specified when no libbasetype is given\n");
 996         if (cfg->seglist_field != NULL && cfg->libbasetype == NULL)
 997             exitfileerror(20, "seglist_field specified when no libbasetype is given\n");
 998         /* rootbase_field only allowed when duplicating base */
 999         if (cfg->rootbase_field != NULL && !(cfg->options & OPTION_DUPBASE))
1000             exitfileerror(20, "rootbasefield only valid for option peropenerbase or peridbase\n");
1001         if (cfg->getidfunc != NULL && !(cfg->options & OPTION_DUPPERID))
1002             exitfileerror(20, "getidfunc only valid for option peridbase\n");
1003
1004         /* Set default date to current date */
1005         if (cfg->datestring == NULL)
1006         {
1007             char tmpbuf[256];
1008             time_t now = time(NULL);
1009             struct tm *ltime = localtime(&now);
1010
1011             snprintf(tmpbuf, sizeof(tmpbuf), "%u.%u.%u",
1012                 ltime->tm_mday, 1 + ltime->tm_mon, 1900 + ltime->tm_year);
1013
1014             cfg->datestring = strdup(tmpbuf);
1015         }
1016
1017         if (cfg->copyright == NULL)
1018             cfg->copyright = "";
1019
1020         if ( (cfg->beginiofunc != NULL && cfg->abortiofunc == NULL)
1021              || (cfg->beginiofunc == NULL && cfg->abortiofunc != NULL)
1022         )
1023             exitfileerror(20, "please specify both beginio_func and abortio_func\n");
1024
1025         if (libbasetypeextern==NULL)
1026         {
1027             switch (cfg->modtype)
1028             {
1029             case DEVICE:
1030                 cfg->libbasetypeptrextern = "struct Device *";
1031                 break;
1032             case RESOURCE:
1033                 cfg->libbasetypeptrextern = "APTR ";
1034                 break;
1035             case LIBRARY:
1036             case MUI:
1037             case MCP:
1038             case MCC:
1039             case GADGET:
1040             case DATATYPE:
1041             case USBCLASS:
1042             case HIDD:
1043                 cfg->libbasetypeptrextern = "struct Library *";
1044                 break;
1045             default:
1046                 fprintf(stderr, "Internal error: Unsupported modtype for libbasetypeptrextern\n");
1047                 exit(20);
1048             }
1049         }
1050         else
1051         {
1052             cfg->libbasetypeptrextern = malloc(strlen(libbasetypeextern)+3);
1053             strcpy(cfg->libbasetypeptrextern, libbasetypeextern);
1054             strcat(cfg->libbasetypeptrextern, " *");
1055             free(libbasetypeextern);
1056         }
1057     }
1058
1059     /* When class was given too fill in some defaults when not specified */
1060     if (cl != NULL)
1061     {
1062         if (cl->classtype == UNSPECIFIED)
1063             cl->classtype = CLASS;
1064
1065         if (cl->basename == NULL)
1066         {
1067             if (!inclass)
1068                 cl->basename = cfg->basename;
1069             else
1070                 exitfileerror(20, "basename has to be specified in the config section inside of a class section\n");
1071         }
1072
1073         /* MUI classes are always private */
1074         if (cl->classtype == MUI || cl->classtype == MCC || cl->classtype == MCP)
1075             cl->options |= COPTION_PRIVATE;
1076
1077         if (cl->classid == NULL
1078             && (cl->classtype != MUI && cl->classtype != MCC && cl->classtype != MCP)
1079         )
1080         {
1081             if (cl->classtype == HIDD)
1082             {
1083                 cl->options &= !COPTION_PRIVATE;
1084             }
1085             else if (cl->options & COPTION_PRIVATE)
1086             {
1087                 cl->classid = "NULL";
1088             }
1089             else
1090             {
1091                 char s[256] = "";
1092
1093                 if (cl->classtype == GADGET || cl->classtype == IMAGE || cl->classtype == CLASS || cl->classtype == USBCLASS)
1094                 {
1095                     sprintf(s, "\"%sclass\"", inclass ? cl->basename : cfg->modulename);
1096                 }
1097                 else if (cl->classtype == DATATYPE)
1098                 {
1099                     sprintf(s, "\"%s.datatype\"", inclass ? cl->basename : cfg->modulename);
1100                 }
1101                 cl->classid = strdup(s);
1102             }
1103         }
1104
1105         /* Only specify superclass or superclass_field */
1106         if (cl->superclass != NULL && cl->superclass_field != NULL)
1107             exitfileerror(20, "Only specify one of superclass or superclass_field in config section\n");
1108
1109         /* Give default value to superclass if it is not specified */
1110         if (cl->superclass == NULL && cl->superclass == NULL)
1111         {
1112             switch (cl->classtype)
1113             {
1114             case MUI:
1115             case MCC:
1116                 cl->superclass = "MUIC_Area";
1117                 break;
1118             case MCP:
1119                 cl->superclass = "MUIC_Mccprefs";
1120                 break;
1121             case IMAGE:
1122                 cl->superclass = "IMAGECLASS";
1123                 break;
1124             case GADGET:
1125                 cl->superclass = "GADGETCLASS";
1126                 break;
1127             case DATATYPE:
1128                 cl->superclass = "DATATYPESCLASS";
1129                 break;
1130             case CLASS:
1131                 cl->superclass = "ROOTCLASS";
1132                 break;
1133             case HIDD:
1134                 cl->superclass = "CLID_Root";
1135                 break;
1136             default:
1137                 exitfileerror(20, "Internal error: unhandled classtype in readsectionconfig\n");
1138                 break;
1139             }
1140         }
1141     }
1142 }
1143
1144 static void readsectioncdef(struct config *cfg)
1145 {
1146     int atend = 0;
1147     char *line, *s;
1148
1149     while (!atend)
1150     {
1151         line = readline();
1152         if (line==NULL)
1153             exitfileerror(20, "unexptected end of file in section cdef\n");
1154
1155         if (strncmp(line, "##", 2)!=0)
1156         {
1157             slist_append(&cfg->cdeflines, line);
1158         }
1159         else
1160         {
1161             s = line+2;
1162             while (isspace(*s)) s++;
1163             if (strncmp(s, "end", 3)!=0)
1164                 exitfileerror(20, "\"##end cdef\" expected\n");
1165
1166             s += 3;
1167             while (isspace(*s)) s++;
1168             if (strncmp(s, "cdef", 4)!=0)
1169                 exitfileerror(20, "\"##end cdef\" expected\n");
1170
1171             s += 5;
1172             while (isspace(*s)) s++;
1173             if (*s!='\0')
1174                 exitfileerror(20, "unexpected character at position %d\n");
1175
1176             atend = 1;
1177         }
1178     }
1179 }
1180
1181 static void readsectioncdefprivate(struct config *cfg)
1182 {
1183     int atend = 0;
1184     char *line, *s;
1185
1186     while (!atend)
1187     {
1188         line = readline();
1189         if (line==NULL)
1190             exitfileerror(20, "unexptected end of file in section cdef\n");
1191
1192         if (strncmp(line, "##", 2)!=0)
1193         {
1194             slist_append(&cfg->cdefprivatelines, line);
1195         }
1196         else
1197         {
1198             s = line+2;
1199             while (isspace(*s)) s++;
1200             if (strncmp(s, "end", 3)!=0)
1201                 exitfileerror(20, "\"##end cdefprivate\" expected\n");
1202
1203             s += 3;
1204             while (isspace(*s)) s++;
1205             if (strncmp(s, "cdefprivate", 11)!=0)
1206                 exitfileerror(20, "\"##end cdefprivate\" expected\n");
1207
1208             s += 11;
1209             while (isspace(*s)) s++;
1210             if (*s!='\0')
1211                 exitfileerror(20, "unexpected character at position %d\n");
1212
1213             atend = 1;
1214         }
1215     }
1216 }
1217
1218 static void readsectionstartup(struct config *cfg)
1219 {
1220     int atend = 0;
1221     char *line, *s;
1222
1223     while (!atend)
1224     {
1225         line = readline();
1226         if (line==NULL)
1227             exitfileerror(20, "unexptected end of file in section startup\n");
1228
1229         if (strncmp(line, "##", 2)!=0)
1230         {
1231             slist_append(&cfg->startuplines, line);
1232         }
1233         else
1234         {
1235             s = line+2;
1236             while (isspace(*s)) s++;
1237             if (strncmp(s, "end", 3)!=0)
1238                 exitfileerror(20, "\"##end startup\" expected\n");
1239
1240             s += 3;
1241             while (isspace(*s)) s++;
1242             if (strncmp(s, "startup", 7)!=0)
1243                 exitfileerror(20, "\"##end startup\" expected\n");
1244
1245             s += 7;
1246             while (isspace(*s)) s++;
1247             if (*s!='\0')
1248                 exitfileerror(20, "unexpected character at position %d\n");
1249
1250             atend = 1;
1251         }
1252     }
1253 }
1254
1255 static void readsectionfunctionlist(struct config *cfg)
1256 {
1257     int atend = 0, i;
1258     char *line, *s, *s2;
1259     unsigned int lvo = cfg->firstlvo;
1260     struct functionhead **funclistptr = &cfg->funclist;
1261
1262     if (cfg->basename==NULL)
1263         exitfileerror(20, "section functionlist has to come after section config\n");
1264
1265     while (!atend)
1266     {
1267         line = readline();
1268         if (line==NULL)
1269             exitfileerror(20, "unexptected EOF in functionlist section\n");
1270         if (strlen(line)==0)
1271         {
1272             if (*funclistptr != NULL)
1273                 funclistptr = &((*funclistptr)->next);
1274             lvo++;
1275         }
1276         else if (isspace(*line))
1277         {
1278             s = line;
1279             while (isspace(*s)) s++;
1280             if (*s=='\0')
1281             {
1282                 if (*funclistptr != NULL)
1283                     funclistptr = &((*funclistptr)->next);
1284                 lvo++;
1285             }
1286             else
1287                 exitfileerror(20, "no space allowed before functionname\n");
1288         }
1289         else if (strncmp(line, "##", 2)==0)
1290         {
1291             s = line+2;
1292             while (isspace(*s)) s++;
1293             if (strncmp(s, "end", 3)!=0)
1294                 exitfileerror(20, "\"##end functionlist\" expected\n");
1295
1296             s += 3;
1297             while (isspace(*s)) s++;
1298             if (strncmp(s, "functionlist", 12)!=0)
1299                 exitfileerror(20, "\"##end functionlist\" expected\n");
1300
1301             s += 12;
1302             while (isspace(*s)) s++;
1303             if (*s!='\0')
1304                 exitfileerror(20, "unexpected character on position %d\n", s-line);
1305
1306             atend = 1;
1307         }
1308         else if (*line=='.')
1309         {
1310             s = line+1;
1311             if (strncmp(s, "skip", 4)==0)
1312             {
1313                 int n;
1314
1315                 s += 4;
1316                 if (!isspace(*s))
1317                     exitfileerror(20, "syntax is '.skip n'\n");
1318
1319                 n=strtol(s, &s2, 10);
1320                 if (s2==NULL)
1321                     exitfileerror(20, "positive number expected\n");
1322
1323                 while (isspace(*s2)) s2++;
1324                 if (*s2!='\0')
1325                     exitfileerror(20, "syntax is '.skip n'\n");
1326                 if (*funclistptr != NULL)
1327                     funclistptr = &((*funclistptr)->next);
1328                 lvo += n;
1329             }
1330             else if (strncmp(s, "alias", 5)==0)
1331             {
1332                 s += 5;
1333
1334                 if (!isspace(*s))
1335                     exitfileerror(20, "syntax is '.alias name'\n");
1336
1337                 while (isspace(*s)) s++;
1338                 if (*s == '\0' || !(isalpha(*s) || *s == '_'))
1339                     exitfileerror(20, "syntax is '.alias name'\n");
1340
1341                 s2 = s;
1342                 s++;
1343                 while (isalnum(*s) || *s == '_') s++;
1344
1345                 if (isspace(*s))
1346                 {
1347                     *s = '\0';
1348                     do {
1349                         s++;
1350                     } while (isspace(*s));
1351                 }
1352
1353                 if (*s != '\0')
1354                     exitfileerror(20, "syntax is '.alias name'\n");
1355
1356                 if (*funclistptr == NULL)
1357                     exitfileerror(20, ".alias has to come after a function declaration\n");
1358
1359                 slist_append(&(*funclistptr)->aliases, s2);
1360                 cfg->intcfg |= CFG_GENASTUBS;
1361             }
1362             else if (strncmp(s, "cfunction", 9)==0)
1363             {
1364                 if (*funclistptr == NULL)
1365                     exitfileerror(20, ".cfunction has to come after a function declaration\n");
1366
1367                 (*funclistptr)->libcall = REGISTER;
1368             }
1369             else if (strncmp(s, "private", 7)==0)
1370             {
1371                 if (*funclistptr == NULL)
1372                     exitfileerror(20, ".private has to come after a function declaration\n");
1373
1374                 (*funclistptr)->priv = 1;
1375             }
1376             else if (strncmp(s, "novararg", 8)==0)
1377             {
1378                 if (*funclistptr == NULL)
1379                     exitfileerror(20, ".novararg has to come after a function declaration\n");
1380
1381                 (*funclistptr)->novararg = 1;
1382             }
1383             else
1384                 exitfileerror(20, "Syntax error");
1385         }
1386         else if (*line!='#') /* Ignore line that is a comment, e.g. that starts with a # */
1387         {
1388             /* The line is a function prototype. It can have two syntax
1389              * type funcname(argproto1, argproto2, ...)
1390              * type funcname(argproto1, argproto2, ...) (reg1, reg2, ...)
1391              * The former is for C type function argument passing, the latter for
1392              * register argument passing.
1393              */
1394             char c, *args[64], *regs[64], *funcname;
1395             int len, argcount = 0, regcount = 0, brcount = 0;
1396
1397             /* Parse 'type functionname' at the beginning of the line */
1398             s = strchr(line, '(');
1399             if (s == NULL)
1400                 exitfileerror(20, "( expected at position %d\n", strlen(line) + 1);
1401
1402             s2 = s;
1403             while (isspace(*(s2-1)))
1404                 s2--;
1405             *s2 = '\0';
1406
1407             while (s2 > line && !isspace(*(s2-1)) && !(*(s2-1) == '*'))
1408                 s2--;
1409
1410             if (s2 == line)
1411                 exitfileerror(20, "No type specifier before function name\n");
1412
1413             if (*funclistptr != NULL)
1414                 funclistptr = &((*funclistptr)->next);
1415             *funclistptr = newfunctionhead(s2, STACK);
1416
1417             while (isspace(*(s2-1)))
1418                 s2--;
1419             *s2 = '\0';
1420             (*funclistptr)->type = strdup(line);
1421             (*funclistptr)->lvo = lvo;
1422             lvo++;
1423
1424             /* Parse function prototype */
1425             s++;
1426             while (isspace(*s))
1427                 s++;
1428             c = *s;
1429
1430             while (c != ')')
1431             {
1432                 while (isspace(*s))
1433                     s++;
1434
1435                 args[argcount] = s;
1436                 argcount++;
1437
1438                 while
1439                 (
1440                     *s != '\0'
1441                     && !(brcount == 0 && (*s == ',' || *s == ')'))
1442                 )
1443                 {
1444                     if (*s == '(')
1445                         brcount++;
1446                     if (*s == ')')
1447                     {
1448                         if (brcount > 0)
1449                             brcount--;
1450                         else
1451                             exitfileerror(20, "Unexected ')' at position %d\n", s-line+1);
1452                     }
1453                     s++;
1454                 }
1455
1456                 c = *s;
1457                 if (c == '\0')
1458                     exitfileerror(20, "'(' without ')'");
1459
1460                 s2 = s;
1461                 while (isspace(*(s2-1)))
1462                     s2--;
1463                 *s2 = '\0';
1464
1465                 if (!(s2 > args[argcount - 1]))
1466                     exitfileerror(20, "Syntax error in function prototype\n");
1467
1468                 s++;
1469             }
1470
1471             s++;
1472             while (*s != '\0' && isspace(*s))
1473                 s++;
1474
1475             if (*s == '(')
1476             {
1477                 /* Parse registers specifications if available otherwise this prototype for C type argument passing */
1478
1479                 /* There may be no register specified with () so be sure then c is == ')' */
1480                 s++;
1481                 while(isspace(*s))
1482                     s++;
1483
1484                 c = *s;
1485
1486                 while (c != ')')
1487                 {
1488                     while (isspace(*s))
1489                         s++;
1490
1491                     regs[regcount] = s;
1492                     regcount++;
1493
1494                     if (memchr("AD",s[0],2)!=NULL && memchr("01234567",s[1],8)!=NULL)
1495                     {
1496                         s += 2;
1497                         c = *s;
1498                         if (c == '/')
1499                         {
1500                             if (regcount > 1)
1501                             {
1502                                 if (strchr(regs[0], '/') == NULL)
1503                                     exitfileerror(20, "Either all arguments has to in two registers or none\n");
1504                             }
1505
1506                             s++;
1507                             if (s[0] == s[-3] && s[1] == s[-2] + 1)
1508                             {
1509                                 s += 2;
1510                                 c = *s;
1511                             }
1512                             else
1513                                 exitfileerror(20,
1514                                               "wrong register specification \"%s\" for argument %u\n",
1515                                               regs[regcount-1], regcount
1516                                 );
1517
1518                             if (regcount > 2)
1519                                 exitfileerror(20, "maximum two arguments passed in two registers allowed\n");
1520                         }
1521                         *s = '\0';
1522                     }
1523                     else
1524                         exitfileerror(20,
1525                                       "wrong register \"%s\" for argument %u\n",
1526                                       regs[regcount-1], regcount
1527                         );
1528
1529                     while (isspace(c))
1530                     {
1531                         s++;
1532                         c = *s;
1533                     }
1534                     if (c == '\0')
1535                         exitfileerror(20, "'(' without ')'\n");
1536                     if (c != ',' && c != ')')
1537                         exitfileerror(20, "',' or ')' expected at position %d\n", s-line+1);
1538
1539                     s++;
1540                 }
1541
1542                 s++;
1543                 while (isspace(*s)) s++;
1544                 if (*s!='\0')
1545                     exitfileerror(20, "wrong char '%c' at position %d\n", *s, (int)(s-line) + 1);
1546
1547                 if (argcount != regcount)
1548                     exitfileerror(20, "Number of arguments (%d) and registers (%d) mismatch\n",
1549                                   argcount, regcount
1550                     );
1551
1552                 (*funclistptr)->libcall = REGISTERMACRO;
1553                 for (i = 0; i < argcount; i++)
1554                     funcaddarg(*funclistptr, args[i], regs[i]);
1555             }
1556             else if (*s == '\0')
1557             { /* No registers specified */
1558                 for (i = 0; i < argcount; i++)
1559                     funcaddarg(*funclistptr, args[i], NULL);
1560                 cfg->intcfg |= CFG_GENASTUBS;
1561             }
1562             else
1563                 exitfileerror(20, "wrong char '%c' at position %d\n", *s, (int)(s-line) + 1);
1564         }
1565     }
1566 }
1567
1568 static void readsectionmethodlist(struct classinfo *cl)
1569 {
1570     int atend = 0, i;
1571     char *line, *s, *s2;
1572     struct functionhead **methlistptr = &cl->methlist;
1573     struct stringlist *interface = NULL;
1574
1575     if (cl->basename==NULL)
1576         exitfileerror(20, "section methodlist has to come after section config\n");
1577
1578     while (!atend)
1579     {
1580         line = readline();
1581         if (line==NULL)
1582             exitfileerror(20, "unexptected EOF in methodlist section\n");
1583
1584         /* Ignore empty lines or lines that qre a comment, e.g. that starts with a # */
1585         if (strlen(line)==0 || (line[0] == '#' && line[1] != '#'))
1586             continue;
1587
1588         if (isspace(*line))
1589             exitfileerror(20, "No space allowed at start of the line\n");
1590
1591         if (strncmp(line, "##", 2)==0) /* Is this the end ? */
1592         {
1593             s = line+2;
1594             while (isspace(*s)) s++;
1595             if (strncmp(s, "end", 3)!=0)
1596                 exitfileerror(20, "\"##end methodlist\" expected\n");
1597
1598             s += 3;
1599             while (isspace(*s)) s++;
1600             if (strncmp(s, "methodlist", 10)!=0)
1601                 exitfileerror(20, "\"##end methodlist\" expected\n");
1602
1603             s += 10;
1604             while (isspace(*s)) s++;
1605             if (*s!='\0')
1606                 exitfileerror(20, "unexpected character on position %d\n", s-line);
1607
1608             atend = 1;
1609
1610             continue;
1611         }
1612
1613         if (*line=='.')
1614         {
1615             s = line+1;
1616             if (strncmp(s, "alias", 5)==0)
1617             {
1618                 s += 5;
1619
1620                 if (!isspace(*s))
1621                     exitfileerror(20, "syntax is '.alias name'\n");
1622
1623                 while (isspace(*s)) s++;
1624                 if (*s == '\0' || !(isalpha(*s) || *s == '_'))
1625                     exitfileerror(20, "syntax is '.alias name'\n");
1626
1627                 s2 = s;
1628                 s++;
1629                 while (isalnum(*s) || *s == '_') s++;
1630
1631                 if (isspace(*s))
1632                 {
1633                     *s = '\0';
1634                     do {
1635                         s++;
1636                     } while (isspace(*s));
1637                 }
1638
1639                 if (*s != '\0')
1640                     exitfileerror(20, "syntax is '.alias name'\n");
1641
1642                 if (*methlistptr == NULL)
1643                     exitfileerror(20, ".alias has to come after a function declaration\n");
1644
1645                 slist_append(&(*methlistptr)->aliases, s2);
1646             }
1647             else if (strncmp(s, "function", 8) == 0)
1648             {
1649                 s += 8;
1650
1651                 if (!isspace(*s))
1652                     exitfileerror(20, "Syntax error\n");
1653
1654                 while (isspace(*s)) s++;
1655                 if (*s == '\0' || !(isalpha(*s) || *s == '_'))
1656                     exitfileerror(20, "syntax is '.function name'\n");
1657
1658                 s2 = s;
1659                 s++;
1660                 while (isalnum(*s) || *s == '_') s++;
1661
1662                 if (isspace(*s))
1663                 {
1664                     *s = '\0';
1665                     do {
1666                         s++;
1667                     } while (isspace(*s));
1668                 }
1669
1670                 if (*s != '\0')
1671                     exitfileerror(20, "syntax is '.function name'\n");
1672
1673                 if (*methlistptr == NULL)
1674                     exitfileerror(20, ".function has to come after a function declaration\n");
1675
1676                 free((*methlistptr)->name);
1677                 (*methlistptr)->name = strdup(s2);
1678             }
1679             else if (strncmp(s, "interface", 9) == 0)
1680             {
1681                 if (cl->classtype != HIDD)
1682                     exitfileerror(20, "interface only valid for a HIDD\n");
1683
1684                 s += 9;
1685
1686                 if (!isspace(*s))
1687                     exitfileerror(20, "Syntax error\n");
1688
1689                 while (isspace(*s)) s++;
1690                 if (*s == '\0' || !isalpha(*s))
1691                     exitfileerror(20, "syntax is '.interface name'\n");
1692
1693                 s2 = s;
1694                 s++;
1695                 while (isalnum(*s) || *s == '_') s++;
1696
1697                 if (isspace(*s))
1698                 {
1699                     *s = '\0';
1700                     do {
1701                         s++;
1702                     } while (isspace(*s));
1703                 }
1704
1705                 if (*s != '\0')
1706                     exitfileerror(20, "syntax is '.interface name'\n");
1707
1708                 interface = slist_append(&cl->interfaces, s2);
1709             }
1710             else
1711                 exitfileerror(20, "Syntax error");
1712         }
1713         else if (isalpha(*line))
1714         {
1715             char stmp[256];
1716
1717             for (s = line + 1; isalnum(*s) || *s == '_'; s++)
1718                 ;
1719
1720             if (cl->classtype == HIDD && interface == NULL)
1721                 exitfileerror(20, "For a HIDD the first method has to come after an .interface line\n");
1722
1723             if (*s != '\0')
1724                 exitfileerror(20, "Only letters, digits and an underscore allowed in a methodname\n");
1725
1726             if (*methlistptr != NULL)
1727                 methlistptr = &((*methlistptr)->next);
1728             if (cl->classtype != HIDD)
1729             {
1730                 if (snprintf(stmp, 256, "%s__%s", cl->basename, line) >= 256)
1731                     exitfileerror(20, "Method name too large\n");
1732
1733                 *methlistptr = newfunctionhead(stmp, STACK);
1734                 (*methlistptr)->type = "IPTR";
1735                 funcaddarg(*methlistptr, "Class *cl", NULL);
1736                 funcaddarg(*methlistptr, "Object *o", NULL);
1737                 funcaddarg(*methlistptr, "Msg msg", NULL);
1738             }
1739             else
1740             {
1741                 if (snprintf(stmp, 256, "%s__%s__%s", cl->basename, interface->s, line) >= 256)
1742                     exitfileerror(20, "Method name too large\n");
1743
1744                 *methlistptr = newfunctionhead(stmp, STACK);
1745                 (*methlistptr)->type = "IPTR";
1746                 funcaddarg(*methlistptr, "OOP_Class *cl", NULL);
1747                 funcaddarg(*methlistptr, "OOP_Object *o", NULL);
1748                 funcaddarg(*methlistptr, "OOP_Msg msg", NULL);
1749                 (*methlistptr)->interface = interface;
1750                 if (snprintf(stmp, 256, "mo%s_%s", interface->s, line) >= 256)
1751                     exitfileerror(20, "Method name too large\n");
1752                 (*methlistptr)->method = strdup(stmp);
1753             }
1754             slist_append(&(*methlistptr)->aliases, line);
1755         }
1756         else
1757             exitfileerror(20, "Methodname has to begin with a letter\n");
1758     }
1759 }
1760
1761 static void
1762 readsectionclass(struct config *cfg)
1763 {
1764     char *s;
1765     struct classinfo *cl;
1766
1767     cl = newclass(cfg);
1768     s = readsections(cfg, cl, 1);
1769     if (s == NULL)
1770         exitfileerror(20, "Unexpected end of file\n");
1771
1772     if (strncmp(s, "##", 2) != 0)
1773         exitfileerror(20, "'##end class' expected\n");
1774     s += 2;
1775
1776     while (isspace(*s)) s++;
1777
1778     if (strncmp(s, "end", 3) != 0)
1779         exitfileerror(20, "'##end class' expected\n");
1780     s += 3;
1781
1782     if (!isspace(*s))
1783         exitfileerror(20, "'##end class' expected\n");
1784     while (isspace(*s)) s++;
1785
1786     if (strncmp(s, "class", 5) != 0)
1787         exitfileerror(20, "'##end class' expected\n");
1788     s += 5;
1789
1790     while (isspace(*s)) s++;
1791     if (*s != '\0')
1792         exitfileerror(20, "'##end class' expected\n");
1793 }
1794
1795 static struct classinfo *newclass(struct config *cfg)
1796 {
1797     struct classinfo *cl, *classlistit;
1798
1799     cl = malloc(sizeof(struct classinfo));
1800     if (cl == NULL)
1801     {
1802         fprintf(stderr, "Out of memory\n");
1803         exit(20);
1804     }
1805     memset(cl, 0, sizeof(struct classinfo));
1806
1807     /* By default the classes are initialized with a priority of 1 so they
1808      * are initialized before any user added initialization with priority 1
1809      */
1810     cl->initpri = 1;
1811
1812     if (cfg->classlist == NULL)
1813         cfg->classlist = cl;
1814     else
1815     {
1816         for
1817         (
1818             classlistit = cfg->classlist;
1819             classlistit->next != NULL;
1820             classlistit = classlistit->next
1821         )
1822             ;
1823         classlistit->next = cl;
1824     }
1825
1826     return cl;
1827 }