tools/genmodule/config.c

   1 /*
   2     Copyright © 1995-2014, 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 #define __USE_XOPEN
  13 #include <time.h>
  14 #include <unistd.h>
  15 #include <limits.h>
  16
  17 #include "functionhead.h"
  18 #include "config.h"
  19
  20 const static char bannertemplate[] =
  21     "/*\n"
  22     "    *** Automatically generated from '%s'. Edits will be lost. ***\n"
  23     "    Copyright © 1995-%4u, The AROS Development Team. All rights reserved.\n"
  24     "*/\n";
  25
  26 char*
  27 getBanner(struct config* config)
  28 {
  29     static unsigned currentyear = 0;
  30
  31     int bannerlength = strlen(config->conffile) + strlen(bannertemplate);
  32     // No additional bytes needed because
  33     // + 1 (NUL) + 4 (4 digit year) - strlen("%s") - strlen("%4u) = 0
  34
  35     char * banner = malloc(bannerlength);
  36
  37     if (currentyear == 0)
  38     {
  39         time_t rawtime;
  40         time(&rawtime);
  41         struct tm *utctm = gmtime(&rawtime);
  42         currentyear = utctm->tm_year + 1900;
  43     }
  44
  45     snprintf (banner, bannerlength, bannertemplate, config->conffile, currentyear);
  46
  47     return(banner);
  48 }
  49
  50 void
  51 freeBanner(char *banner)
  52 {
  53     free((void *)banner);
  54 }
  55
  56 const static char usage[] =
  57     "\n"
  58     "Usage: genmodule [-c conffile] [-s suffix] [-d gendir] [-v versionextra]\n"
  59     "       {writefiles|writemakefile|writeincludes|writelibdefs|writefunclist|writefd|writeskel} modname modtype\n"
  60 ;
  61
  62 static void readconfig(struct config *);
  63 static struct classinfo *newclass(struct config *);
  64 static struct handlerinfo *newhandler(struct config *);
  65 static struct interfaceinfo *newinterface(struct config *);
  66
  67 /* the method prefices for the supported classes */
  68 static const char *muimprefix[] =
  69 {
  70     "__OM_",
  71     "__MUIM_",
  72     NULL
  73 };
  74 static const char *gadgetmprefix[] =
  75 {
  76     "__OM_",
  77     "__GM_",
  78     "__AROSM_",
  79     NULL
  80 };
  81 static const char *dtmprefix[] =
  82 {
  83     "__OM_",
  84     "__GM_",
  85     "__DTM_",
  86     "__PDTM_",
  87     NULL
  88 };
  89
  90 /* Create a config struct. Initialize with the values from the programs command
  91  * line arguments and the contents of the modules .conf file
  92  */
  93 struct config *initconfig(int argc, char **argv)
  94 {
  95     struct config *cfg;
  96     char *s, **argvit = argv + 1;
  97     int hassuffix = 0, c;
  98
  99     cfg = malloc(sizeof(struct config));
 100     if (cfg == NULL)
 101     {
 102         fprintf(stderr, "Out of memory\n");
 103         exit(20);
 104     }
 105
 106     memset(cfg, 0, sizeof(struct config));
 107
 108     while ((c = getopt(argc, argv, ":c:s:d:v:")) != -1)
 109     {
 110         if (c == ':')
 111         {
 112             fprintf(stderr, "Option -%c needs an argument\n",optopt);
 113             exit(20);
 114         }
 115
 116         switch (c)
 117         {
 118         case 'c':
 119             cfg->conffile = optarg;
 120             break;
 121
 122         case 's':
 123             cfg->suffix = optarg;
 124             hassuffix = 1;
 125             break;
 126
 127         case 'd':
 128             /* Remove / at end if present */
 129             if ((optarg)[strlen(*argvit)-1]=='/') (optarg)[strlen(optarg)-1]='\0';
 130             cfg->gendir = optarg;
 131             break;
 132
 133         case 'v':
 134             cfg->versionextra = optarg;
 135             break;
 136
 137         default:
 138             fprintf(stderr, "Internal error: Unhandled option\n");
 139             exit(20);
 140         }
 141     }
 142
 143     if (optind + 3 != argc)
 144     {
 145         fprintf(stderr, "Wrong number of arguments.\n%s", usage);
 146         exit(20);
 147     }
 148
 149     if (strcmp(argv[optind], "writefiles") == 0)
 150     {
 151         cfg->command = FILES;
 152     }
 153     else if (strcmp(argv[optind], "writemakefile") == 0)
 154     {
 155         cfg->command = MAKEFILE;
 156     }
 157     else if (strcmp(argv[optind], "writeincludes") == 0)
 158     {
 159         cfg->command = INCLUDES;
 160     }
 161     else if (strcmp(argv[optind], "writelibdefs") == 0)
 162     {
 163         cfg->command = LIBDEFS;
 164     }
 165     else if (strcmp(argv[optind], "writefunclist") == 0)
 166     {
 167         cfg->command = WRITEFUNCLIST;
 168     }
 169     else if (strcmp(argv[optind], "writefd") == 0)
 170     {
 171         cfg->command = WRITEFD;
 172     }
 173     else if (strcmp(argv[optind], "writeskel") == 0)
 174     {
 175         cfg->command = WRITESKEL;
 176     }
 177     else
 178     {
 179         fprintf(stderr, "Unrecognized argument \"%s\"\n%s", argv[optind], usage);
 180         exit(20);
 181     }
 182
 183     cfg->modulename = argv[optind+1];
 184     cfg->modulenameupper = strdup(cfg->modulename);
 185     for (s=cfg->modulenameupper; *s!='\0'; *s = toupper(*s), s++) {
 186         if (!isalnum(*s)) *s = '_';
 187     }
 188
 189     if (strcmp(argv[optind+2],"library")==0)
 190     {
 191         cfg->modtype = LIBRARY;
 192         cfg->moddir = "Libs";
 193     }
 194     else if (strcmp(argv[optind+2],"mcc")==0)
 195     {
 196         cfg->modtype = MCC;
 197         cfg->moddir = "Classes/Zune";
 198     }
 199     else if (strcmp(argv[optind+2],"mui")==0)
 200     {
 201         cfg->modtype = MUI;
 202         cfg->moddir = "Classes/Zune";
 203     }
 204     else if (strcmp(argv[optind+2],"mcp")==0)
 205     {
 206         cfg->modtype = MCP;
 207         cfg->moddir = "Classes/Zune";
 208     }
 209     else if (strcmp(argv[optind+2], "device")==0)
 210     {
 211         cfg->modtype = DEVICE;
 212         cfg->moddir = "Devs";
 213     }
 214     else if (strcmp(argv[optind+2], "resource")==0)
 215     {
 216         cfg->modtype = RESOURCE;
 217         cfg->moddir = "Devs";
 218     }
 219     else if (strcmp(argv[optind+2], "gadget")==0)
 220     {
 221         cfg->modtype = GADGET;
 222         cfg->moddir = "Classes/Gadgets";
 223     }
 224     else if (strcmp(argv[optind+2], "datatype")==0)
 225     {
 226         cfg->modtype = DATATYPE;
 227         cfg->moddir = "Classes/DataTypes";
 228     }
 229     else if (strcmp(argv[optind+2], "usbclass")==0)
 230     {
 231         cfg->modtype = USBCLASS;
 232         cfg->moddir = "Classes/USB";
 233         if(!hassuffix)
 234         {
 235             cfg->suffix = "class";
 236             hassuffix = 1;
 237         }
 238     }
 239     else if (strcmp(argv[optind+2], "hidd")==0)
 240     {
 241         cfg->modtype = HIDD;
 242         cfg->moddir = "Devs/Drivers";
 243     }
 244     else if (strcmp(argv[optind+2], "handler")==0)
 245     {
 246         cfg->modtype = HANDLER;
 247         cfg->moddir = "$(AROS_DIR_FS)";
 248     }
 249     else if (strcmp(argv[optind+2], "hook")==0)
 250     {
 251         cfg->modtype = HANDLER;
 252         cfg->moddir = "Devs";
 253     }
 254     else
 255     {
 256         fprintf(stderr, "Unknown modtype \"%s\" specified for second argument\n", argv[optind+2]);
 257         exit(20);
 258     }
 259     cfg->modtypestr = argv[optind+2];
 260
 261     if (!hassuffix)
 262         cfg->suffix = argv[optind+2];
 263
 264     /* Fill fields with default value if not specified on the command line */
 265     {
 266         char tmpbuf[256];
 267
 268         if (cfg->conffile == NULL)
 269         {
 270             snprintf(tmpbuf, sizeof(tmpbuf), "%s.conf", cfg->modulename);
 271             cfg->conffile = strdup(tmpbuf);
 272         }
 273
 274         if (cfg->gendir == NULL)
 275             cfg->gendir = ".";
 276     }
 277
 278     readconfig(cfg);
 279
 280     /* For a device add the functions given in beginiofunc and abortiofunc to the functionlist
 281      * if they are provided
 282      */
 283     if (cfg->beginiofunc != NULL)
 284     {
 285         struct functionhead *funchead;
 286
 287         cfg->intcfg |= CFG_NOREADFUNCS;
 288
 289         /* Add beginio_func to the list of functions */
 290         funchead = newfunctionhead(cfg->beginiofunc, REGISTERMACRO);
 291         funchead->type = strdup("void");
 292         funchead->lvo = 5;
 293         funcaddarg(funchead, "struct IORequest *ioreq", "A1");
 294
 295         funchead->next = cfg->funclist;
 296         cfg->funclist = funchead;
 297
 298         /* Add abortio_func to the list of functions */
 299         funchead = newfunctionhead(cfg->abortiofunc, REGISTERMACRO);
 300         funchead->type = strdup("LONG");
 301         funchead->lvo = 6;
 302         funcaddarg(funchead, "struct IORequest *ioreq", "A1");
 303
 304         funchead->next = cfg->funclist->next;
 305         cfg->funclist->next = funchead;
 306     }
 307     else if (cfg->modtype == DEVICE && cfg->intcfg & CFG_NOREADFUNCS)
 308     {
 309         fprintf
 310         (
 311             stderr,
 312             "beginio_func and abortio_func missing for a device with a non empty function list\n"
 313         );
 314         exit(20);
 315     }
 316
 317     /* See if we have any stackcall options */
 318     if (cfg->funclist) {
 319         struct functionhead *funchead;
 320
 321         for (funchead = cfg->funclist; funchead; funchead = funchead->next) {
 322             if (funchead->libcall == STACK) {
 323                 cfg->options |= OPTION_STACKCALL;
 324                 break;
 325             }
 326         }
 327     }
 328
 329     /* Provide default version for functions that didnt have it */
 330     if (cfg->funclist) {
 331         struct functionhead *funchead;
 332         int defversion = cfg->majorversion; /* Assume library version is default */
 333
 334         for (funchead = cfg->funclist; funchead; funchead = funchead->next) {
 335             if (funchead->version > -1) {
 336                 /* There was at least one .version tag. Assume 0 is default */
 337                 defversion = 0;
 338                 break;
 339             }
 340         }
 341
 342         for (funchead = cfg->funclist; funchead; funchead = funchead->next) {
 343             if (funchead->version == -1) {
 344                 funchead->version = defversion;
 345             }
 346         }
 347     }
 348
 349     /* Verify that a handler has a handler */
 350     if (cfg->modtype == HANDLER) {
 351         if (cfg->handlerfunc == NULL) {
 352             fprintf(stderr, "handler modules require a 'handler_func' ##config option\n");
 353             exit(20);
 354         }
 355         cfg->options |= OPTION_NOAUTOLIB | OPTION_NOEXPUNGE | OPTION_NOOPENCLOSE;
 356     }
 357
 358     return cfg;
 359 }
 360
 361 /* Functions to read configuration from the configuration file */
 362
 363 #include "fileread.h"
 364
 365 static char *readsections(struct config *, struct classinfo *cl, struct interfaceinfo *in, int inclass);
 366 static void readsectionconfig(struct config *, struct classinfo *cl, struct interfaceinfo *in, int inclass);
 367 static void readsectioncdef(struct config *);
 368 static void readsectioncdefprivate(struct config *);
 369 static void readsectionstartup(struct config *);
 370 static void readsectionfunctionlist(const char *type, struct functionhead **funclistptr, unsigned int firstlvo, int isattribute, enum libcall def_libcall);
 371 static void readsectionclass_methodlist(struct classinfo *);
 372 static void readsectionclass(struct config *);
 373 static void readsectionhandler(struct config *);
 374 static void readsectioninterface(struct config *);
 375
 376 static void readconfig(struct config *cfg)
 377 {
 378     struct classinfo *mainclass = NULL;
 379
 380     /* Create a classinfo structure if this module is a class */
 381     switch (cfg->modtype)
 382     {
 383     case LIBRARY:
 384     case DEVICE:
 385     case RESOURCE:
 386     case USBCLASS:
 387     case HANDLER:
 388         break;
 389
 390     case MCC:
 391     case MUI:
 392     case MCP:
 393     case GADGET:
 394     case DATATYPE:
 395     case HIDD:
 396         mainclass = newclass(cfg);
 397         mainclass->classtype = cfg->modtype;
 398         break;
 399
 400     default:
 401         fprintf(stderr, "Internal error: unsupported modtype for classinfo creation\n");
 402         exit(20);
 403     }
 404
 405     switch (cfg->modtype)
 406     {
 407     case LIBRARY:
 408     case USBCLASS:
 409         cfg->firstlvo = 5;
 410         break;
 411     case DEVICE:
 412         cfg->firstlvo = 7;
 413         break;
 414     case MCC:
 415     case MUI:
 416     case MCP:
 417         cfg->firstlvo = 6;
 418         mainclass->boopsimprefix = muimprefix;
 419         break;
 420     case HANDLER:
 421     case RESOURCE:
 422         cfg->firstlvo = 1;
 423         break;
 424     case GADGET:
 425         cfg->firstlvo = 5;
 426         mainclass->boopsimprefix = gadgetmprefix;
 427         break;
 428     case DATATYPE:
 429         cfg->firstlvo = 6;
 430         mainclass->boopsimprefix = dtmprefix;
 431         break;
 432     case HIDD:
 433         cfg->firstlvo = 5;
 434         /* FIXME: need boopsimprefix ? */
 435         break;
 436     default:
 437         fprintf(stderr, "Internal error: unsupported modtype for firstlvo\n");
 438         exit(20);
 439     }
 440
 441     if (!fileopen(cfg->conffile))
 442     {
 443         fprintf(stderr, "In readconfig: Could not open %s\n", cfg->conffile);
 444         exit(20);
 445     }
 446
 447     /* Read all sections and see that we are at the end of the file */
 448     if (readsections(cfg, mainclass, NULL, 0) != NULL)
 449         exitfileerror(20, "Syntax error");
 450
 451     fileclose();
 452 }
 453
 454 /* readsections will scan through all the sections in the config file.
 455  * arguments:
 456  * struct config *cfg: The module config data which may be updated by
 457  *     the information in the sections
 458  * struct classinfo *cl: The classdata to be filled with data from the sections.
 459  *     This may be NULL if this is the main part of the configuration file and the
 460  *     type of the module is not a class
 461  * int inclass: Boolean to indicate if we are in a class part. If not we are in the main
 462  *     part of the config file.
 463  */
 464 static char *readsections(struct config *cfg, struct classinfo *cl, struct interfaceinfo *in, int inclass)
 465 {
 466     char *line, *s, *s2;
 467     int hasconfig = 0;
 468
 469     while ((line=readline())!=NULL)
 470     {
 471         if (strncmp(line, "##", 2)==0)
 472         {
 473             static char *parts[] =
 474             {
 475                 "config", "cdefprivate", "cdef", "startup", "functionlist", "methodlist", "class", "handler", "interface", "attributelist", "cfunctionlist"
 476             };
 477             const unsigned int nums = sizeof(parts)/sizeof(char *);
 478             unsigned int partnum;
 479             int i, atend = 0;
 480
 481             s = line+2;
 482             while (isspace(*s)) s++;
 483
 484             if (strncmp(s, "begin", 5)!=0)
 485                 return line;
 486
 487             s += 5;
 488             if (!isspace(*s))
 489                 exitfileerror(20, "space after begin expected\n");
 490             while (isspace(*s)) s++;
 491
 492             for (i = 0, partnum = 0; partnum==0 && i<nums; i++)
 493             {
 494                 if (strncmp(s, parts[i], strlen(parts[i]))==0)
 495                 {
 496                     partnum = i+1;
 497                     s += strlen(parts[i]);
 498                     while (isspace(*s)) s++;
 499                     if (*s!='\0')
 500                         exitfileerror(20, "unexpected character on position %d\n", s-line);
 501                 }
 502             }
 503             if (partnum==0)
 504                 exitfileerror(20, "unknown start of section\n");
 505             switch (partnum)
 506             {
 507             case 1: /* config */
 508                 readsectionconfig(cfg, cl, in, inclass);
 509                 hasconfig = 1;
 510                 break;
 511
 512             case 2: /* cdefprivate */
 513                 if (inclass)
 514                     exitfileerror(20, "cdefprivate section not allowed in class section\n");
 515                 readsectioncdefprivate(cfg);
 516                 break;
 517
 518             case 3: /* cdef */
 519                 if (inclass)
 520                     exitfileerror(20, "cdef section not allowed in class section\n");
 521                 readsectioncdef(cfg);
 522                 break;
 523
 524             case 4: /* startup */
 525                 if (inclass)
 526                     exitfileerror(20, "startup section not allowed in class section\n");
 527                 readsectionstartup(cfg);
 528                 break;
 529
 530             case 5: /* functionlist */
 531                 if (inclass)
 532                     exitfileerror(20, "functionlist section not allow in class section\n");
 533                 if (cfg->basename==NULL)
 534                     exitfileerror(20, "section functionlist has to come after section config\n");
 535
 536                 readsectionfunctionlist("functionlist", &cfg->funclist, cfg->firstlvo, 0, REGISTERMACRO);
 537                 cfg->intcfg |= CFG_NOREADFUNCS;
 538                 break;
 539
 540             case 6: /* methodlist */
 541                 if (cl == NULL && in == NULL)
 542                     exitfileerror(20, "methodlist section when not in a class or interface\n");
 543                 if (cl)
 544                     readsectionclass_methodlist(cl);
 545                 else
 546                     readsectionfunctionlist("methodlist", &in->methodlist, 0, 0, REGISTERMACRO);
 547                 cfg->intcfg |= CFG_NOREADFUNCS;
 548                 break;
 549
 550             case 7: /* class */
 551                 if (inclass)
 552                     exitfileerror(20, "class section may not be in nested\n");
 553                 readsectionclass(cfg);
 554                 break;
 555             case 8: /* handler */
 556                 readsectionhandler(cfg);
 557                 break;
 558             case 9: /* interface */
 559                 if (inclass)
 560                     exitfileerror(20, "interface section may not be nested\n");
 561                 readsectioninterface(cfg);
 562                 break;
 563             case 10: /* attributelist */
 564                 if (!in)
 565                     exitfileerror(20, "attributelist only valid in interface sections\n");
 566                 readsectionfunctionlist("attributelist", &in->attributelist, 0, 1, INVALID);
 567                 break;
 568         case 11: /* cfunctionlist */
 569             if (inclass)
 570                 exitfileerror(20, "cfunctionlist section not allow in class section\n");
 571                     if (cfg->basename==NULL)
 572                         exitfileerror(20, "section cfunctionlist has to come after section config\n");
 573
 574             readsectionfunctionlist("cfunctionlist", &cfg->funclist, cfg->firstlvo, 0, REGISTER);
 575             cfg->intcfg |= CFG_NOREADFUNCS;
 576             break;
 577             }
 578         }
 579         else if (strlen(line)!=0)
 580             filewarning("warning line outside section ignored\n");
 581     }
 582
 583     if(!inclass)
 584     {
 585         if (!hasconfig)
 586             exitfileerror(20, "No config section in conffile\n");
 587
 588         /* If no indication was given for generating includes or not
 589            decide on module type and if there are functions
 590          */
 591         if(!((cfg->options & OPTION_INCLUDES) || (cfg->options & OPTION_NOINCLUDES)))
 592         {
 593             switch (cfg->modtype)
 594             {
 595             case LIBRARY:
 596             case RESOURCE:
 597                 cfg->options |= OPTION_INCLUDES;
 598                 break;
 599
 600             case HANDLER:
 601             case MCC:
 602             case MUI:
 603             case MCP:
 604             case USBCLASS:
 605                 cfg->options |= OPTION_NOINCLUDES;
 606                 break;
 607
 608             case DEVICE:
 609                 cfg->options |= (
 610                     (cfg->funclist != NULL)
 611                     || (cfg->cdeflines != NULL)
 612                     || strcmp(cfg->libbasetypeptrextern, "struct Device *") != 0
 613                 ) ? OPTION_INCLUDES : OPTION_NOINCLUDES;
 614                 break;
 615
 616             case GADGET:
 617             case DATATYPE:
 618             case HIDD:
 619                 cfg->options |= (
 620                     (cfg->funclist != NULL)
 621                 ) ? OPTION_INCLUDES : OPTION_NOINCLUDES;
 622                 break;
 623
 624             default:
 625                 fprintf(stderr, "Internal error writemakefile: unhandled modtype for includes\n");
 626                 exit(20);
 627                 break;
 628             }
 629         }
 630
 631         /* If no indication was given for not generating stubs only generate them if
 632          * the module has functions
 633          */
 634         if(!((cfg->options & OPTION_STUBS) || (cfg->options & OPTION_NOSTUBS)))
 635         {
 636             switch (cfg->modtype)
 637             {
 638             case LIBRARY:
 639                 cfg->options |= (cfg->funclist != NULL) ? OPTION_STUBS : OPTION_NOSTUBS;
 640                 break;
 641
 642             case USBCLASS:
 643             case RESOURCE:
 644             case GADGET:
 645             case DEVICE:
 646             case DATATYPE:
 647             case MCC:
 648             case MUI:
 649             case MCP:
 650             case HIDD:
 651             case HANDLER:
 652                 cfg->options |= OPTION_NOSTUBS;
 653                 break;
 654
 655             default:
 656                 fprintf(stderr, "Internal error writemakefile: unhandled modtype for stubs\n");
 657                 exit(20);
 658                 break;
 659             }
 660         }
 661
 662         /* If no indication was given for generating autoinit code or not
 663            decide on module type
 664          */
 665         if(!((cfg->options & OPTION_AUTOINIT) || (cfg->options & OPTION_NOAUTOINIT)))
 666         {
 667             switch (cfg->modtype)
 668             {
 669             case LIBRARY:
 670                 cfg->options |= OPTION_AUTOINIT;
 671                 break;
 672
 673             case USBCLASS:
 674             case RESOURCE:
 675             case GADGET:
 676             case DEVICE:
 677             case DATATYPE:
 678             case MCC:
 679             case MUI:
 680             case MCP:
 681             case HIDD:
 682             case HANDLER:
 683                 cfg->options |= OPTION_NOAUTOINIT;
 684                 break;
 685
 686             default:
 687                 fprintf(stderr, "Internal error writemakefile: unhandled modtype for autoinit\n");
 688                 exit(20);
 689                 break;
 690             }
 691         }
 692
 693         if ((cfg->modtype == RESOURCE) || (cfg->modtype == HANDLER))
 694             /* Enforce noopenclose for resources and handlers */
 695             cfg->options |= OPTION_NOOPENCLOSE;
 696         else if (!(cfg->options & OPTION_SELFINIT))
 697             /* Enforce using RTF_AUTOINIT for everything except resources */
 698             cfg->options |= OPTION_RESAUTOINIT;
 699     }
 700
 701     return NULL;
 702 }
 703
 704 static void readsectionconfig(struct config *cfg, struct classinfo *cl, struct interfaceinfo *in, int inclass)
 705 {
 706     int atend = 0, i;
 707     char *line, *s, *s2, *libbasetypeextern = NULL;
 708     struct tm date;
 709
 710     while (!atend)
 711     {
 712         line = readline();
 713         if (line==NULL)
 714             exitfileerror(20, "unexpected end of file in section config\n");
 715
 716         if (strncmp(line, "##", 2)!=0)
 717         {
 718             const char *names[] =
 719             {
 720                 "basename", "libbase", "libbasetype", "libbasetypeextern",
 721                 "version", "date", "copyright", "libcall", "forcebase", "superclass",
 722                 "superclass_field", "residentpri", "options", "sysbase_field",
 723                 "seglist_field", "rootbase_field", "classptr_field", "classptr_var",
 724                 "classid", "classdatatype", "beginio_func", "abortio_func", "dispatcher",
 725                 "initpri", "type", "addromtag", "oopbase_field",
 726                 "rellib", "interfaceid", "interfacename",
 727                 "methodstub", "methodbase", "attributebase", "handler_func",
 728                 "includename"
 729             };
 730             const unsigned int namenums = sizeof(names)/sizeof(char *);
 731             unsigned int namenum;
 732
 733             for (i = 0, namenum = 0; namenum==0 && i<namenums; i++)
 734             {
 735                 if
 736                 (
 737                        strncmp(line, names[i], strlen(names[i]))==0
 738                     && isspace(*(line+strlen(names[i])))
 739                 )
 740                     namenum = i+1;
 741             }
 742             if (namenum==0)
 743                 exitfileerror(20, "unrecognized configuration option\n");
 744
 745             s = line + strlen(names[namenum-1]);
 746             if (!isspace(*s))
 747                 exitfileerror(20, "space character expected after \"%s\"\n", names[namenum-1]);
 748
 749             while (isspace(*s)) s++;
 750             if (*s=='\0')
 751                 exitfileerror(20, "unexpected end of line\n");
 752
 753             s2 = s + strlen(s);
 754             while (isspace(*(s2-1))) s2--;
 755             *s2 = '\0';
 756
 757             switch (namenum)
 758             {
 759             case 1: /* basename */
 760                 if (!inclass)
 761                     cfg->basename = strdup(s);
 762                 if (cl != NULL)
 763                     cl->basename = strdup(s);
 764                 if (in != NULL)
 765                     exitfileerror(20, "basename not valid config option when in an interface section\n");
 766                 break;
 767
 768             case 2: /* libbase */
 769                 if (inclass)
 770                     exitfileerror(20, "libbase not valid config option when in a class section\n");
 771                 cfg->libbase = strdup(s);
 772                 break;
 773
 774             case 3: /* libbasetype */
 775                 if (inclass)
 776                     exitfileerror(20, "libbasetype not valid config option when in a class section\n");
 777                 cfg->libbasetype = strdup(s);
 778                 break;
 779
 780             case 4: /* libbasetypeextern */
 781                 if (inclass)
 782                     exitfileerror(20, "libbasetype not valid config option when in a class section\n");
 783                 libbasetypeextern = strdup(s);
 784                 break;
 785
 786             case 5: /* version */
 787                 if (inclass)
 788                     exitfileerror(20, "version not valid config option when in a class section\n");
 789                 if (sscanf(s, "%u.%u", &cfg->majorversion, &cfg->minorversion)!=2)
 790                     exitfileerror(20, "wrong version string \"%s\"\n", s);
 791                 break;
 792
 793             case 6: /* date */
 794                 if (inclass)
 795                     exitfileerror(20, "date not valid config option when in a class section\n");
 796 #ifndef _WIN32
 797                 if (strptime(s, "%e.%m.%Y", &date) == NULL)
 798                 {
 799                     exitfileerror(20, "date string has to have d.m.yyyy format\n");
 800                 }
 801 #endif
 802                 cfg->datestring = strdup(s);
 803                 break;
 804
 805             case 7: /* copyright */
 806                 if (inclass)
 807                     exitfileerror(20, "copyright not valid config option when in a class section\n");
 808                 cfg->copyright = strdup(s);
 809                 break;
 810
 811             case 8: /* libcall */
 812                 fprintf(stderr, "libcall specification is deprecated and ignored\n");
 813                 break;
 814
 815             case 9: /* forcebase */
 816                 if (inclass)
 817                     exitfileerror(20, "forcebase not valid config option when in a class section\n");
 818                 slist_append(&cfg->forcelist, s);
 819                 break;
 820
 821             case 10: /* superclass */
 822                 if (cl == NULL)
 823                     exitfileerror(20, "superclass specified when not a BOOPSI class\n");
 824                 cl->superclass = strdup(s);
 825                 break;
 826
 827             case 11: /* superclass_field */
 828                 if (cl == NULL)
 829                     exitfileerror(20, "superclass_field specified when not a BOOPSI class\n");
 830                 cl->superclass_field = strdup(s);
 831                 break;
 832
 833             case 12: /* residentpri */
 834                 if (!inclass)
 835                 {
 836                     int count;
 837                     char dummy;
 838
 839                     count = sscanf(s, "%d%c", &cfg->residentpri, &dummy);
 840                     if (count != 1 ||
 841                         cfg->residentpri < -128 || cfg->residentpri > 127
 842                     )
 843                     {
 844                         exitfileerror(20, "residentpri number format error\n");
 845                     }
 846                 }
 847                 else
 848                     exitfileerror(20, "residentpri not valid config option when in a class section\n");
 849                 break;
 850
 851             case 13: /* options */
 852                 if (!inclass)
 853                 {
 854                     static const char *optionnames[] =
 855                     {
 856                         "noautolib", "noexpunge", "noresident", "peropenerbase",
 857                         "pertaskbase", "includes", "noincludes", "nostubs",
 858                         "autoinit", "noautoinit", "resautoinit", "noopenclose",
 859                         "selfinit"
 860                     };
 861                     const unsigned int optionnums = sizeof(optionnames)/sizeof(char *);
 862                     int optionnum;
 863
 864                     do
 865                     {
 866                         for (i = 0, optionnum = 0; optionnum==0 && i<optionnums; i++)
 867                         {
 868                             if (strncmp(s, optionnames[i], strlen(optionnames[i]))==0)
 869                             {
 870                                 optionnum = i + 1;
 871                                 s += strlen(optionnames[i]);
 872                                 while (isspace(*s)) s++;
 873                                 if (*s == ',')
 874                                     s++;
 875                                 else if (*s != '\0')
 876                                     exitfileerror(20, "Unrecognized option\n");
 877                             }
 878                         }
 879                         if (optionnum == 0)
 880                             exitfileerror(20, "Unrecognized option\n");
 881                         switch (optionnum)
 882                         {
 883                         case 1: /* noautolib */
 884                             cfg->options |= OPTION_NOAUTOLIB;
 885                             break;
 886                         case 2: /* noexpunge */
 887                             cfg->options |= OPTION_NOEXPUNGE;
 888                             break;
 889                         case 3: /* noresident */
 890                             cfg->options |= OPTION_NORESIDENT;
 891                             cfg->firstlvo = 1;
 892                             break;
 893                         case 5: /* pertaskbase */
 894                             cfg->options |= OPTION_PERTASKBASE;
 895                             /* Fall through */
 896                         case 4: /* peropenerbase */
 897                             if (cfg->options & OPTION_DUPBASE)
 898                                 exitfileerror(20, "Only one option peropenerbase or pertaskbase allowed\n");
 899                             cfg->options |= OPTION_DUPBASE;
 900                             break;
 901                         case 6: /* includes */
 902                             if (cfg->options & OPTION_NOINCLUDES)
 903                                 exitfileerror(20, "option includes and noincludes are incompatible\n");
 904                             cfg->options |= OPTION_INCLUDES;
 905                             break;
 906                         case 7: /* noincludes */
 907                             if (cfg->options & OPTION_INCLUDES)
 908                                 exitfileerror(20, "option includes and noincludes are incompatible\n");
 909                             cfg->options |= OPTION_NOINCLUDES;
 910                             break;
 911                         case 8: /* nostubs */
 912                             cfg->options |= OPTION_NOSTUBS;
 913                             break;
 914                         case 9: /* autoinit */
 915                             if (cfg->options & OPTION_NOAUTOINIT)
 916                                 exitfileerror(20, "option autoinit and noautoinit are incompatible\n");
 917                             cfg->options |= OPTION_AUTOINIT;
 918                             break;
 919                         case 10: /* noautoinit */
 920                             if (cfg->options & OPTION_AUTOINIT)
 921                                 exitfileerror(20, "option autoinit and noautoinit are incompatible\n");
 922                             cfg->options |= OPTION_NOAUTOINIT;
 923                             break;
 924                         case 11: /* resautoinit */
 925                                 if (cfg->options & OPTION_SELFINIT)
 926                                         exitfileerror(20, "option resautoinit and selfinit are incompatible\n");
 927                             cfg->options |= OPTION_RESAUTOINIT;
 928                             break;
 929                         case 12:
 930                             cfg->options |= OPTION_NOOPENCLOSE;
 931                             break;
 932                         case 13: /* noresautoinit */
 933                                 if (cfg->options & OPTION_RESAUTOINIT)
 934                                         exitfileerror(20, "option resautoinit and selfinit are incompatible\n");
 935                             cfg->options |= OPTION_SELFINIT;
 936                             break;
 937                         }
 938                         while (isspace(*s)) s++;
 939                     } while(*s !='\0');
 940                 }
 941                 else
 942                 {
 943                     static const char *optionnames[] =
 944                     {
 945                         "private"
 946                     };
 947                     const unsigned int optionnums = sizeof(optionnames)/sizeof(char *);
 948                     int optionnum;
 949
 950                     do
 951                     {
 952                         for (i = 0, optionnum = 0; optionnum==0 && i<optionnums; i++)
 953                         {
 954                             if (strncmp(s, optionnames[i], strlen(optionnames[i]))==0)
 955                             {
 956                                 optionnum = i + 1;
 957                                 s += strlen(optionnames[i]);
 958                                 while (isspace(*s)) s++;
 959                                 if (*s == ',')
 960                                     s++;
 961                                 else if (*s != '\0')
 962                                     exitfileerror(20, "Unrecognized option\n");
 963                             }
 964                         }
 965                         if (optionnum == 0)
 966                             exitfileerror(20, "Unrecognized option\n");
 967                         switch (optionnum)
 968                         {
 969                         case 1: /* private */
 970                             cl->options |= COPTION_PRIVATE;
 971                             break;
 972                         }
 973                         while (isspace(*s)) s++;
 974                     } while(*s !='\0');
 975                 }
 976                 break;
 977
 978             case 14: /* sysbase_field */
 979                 if (inclass)
 980                     exitfileerror(20, "sysbase_field not valid config option when in a class section\n");
 981                 cfg->sysbase_field = strdup(s);
 982                 break;
 983
 984             case 15: /* seglist_field */
 985                 if (inclass)
 986                     exitfileerror(20, "seglist_field not valid config option when in a class section\n");
 987                 cfg->seglist_field = strdup(s);
 988                 break;
 989
 990             case 16: /* rootbase_field */
 991                 if (inclass)
 992                     exitfileerror(20, "rootbase_field not valid config option when in a class section\n");
 993                 cfg->rootbase_field = strdup(s);
 994                 break;
 995
 996             case 17: /* classptr_field */
 997                 if (cl == NULL)
 998                 {
 999                     exitfileerror
1000                     (
1001                         20,
1002                         "classptr_field specified when not a BOOPSI class\n"
1003                     );
1004                 }
1005                 cl->classptr_field = strdup(s);
1006                 break;
1007
1008             case 18: /* classptr_var */
1009                 if (cl == NULL)
1010                 {
1011                     exitfileerror
1012                     (
1013                         20,
1014                         "classptr_var specified when not a BOOPSI class\n"
1015                     );
1016                 }
1017                 cl->classptr_var = strdup(s);
1018                 break;
1019
1020             case 19: /* classid */
1021                 if (cl == NULL)
1022                     exitfileerror(20, "classid specified when not a BOOPSI class\n");
1023                 if (cl->classid != NULL)
1024                     exitfileerror(20, "classid specified twice\n");
1025                 cl->classid = strdup(s);
1026                 if (strcmp(cl->classid, "NULL") == 0)
1027                     cl->options |= COPTION_PRIVATE;
1028                 break;
1029
1030             case 20: /* classdatatype */
1031                 if (cl == NULL)
1032                     exitfileerror(20, "classdatatype specified when not a BOOPSI class\n");
1033                 cl->classdatatype = strdup(s);
1034                 break;
1035
1036             case 21: /* beginio_func */
1037                 if (inclass)
1038                     exitfileerror(20, "beginio_func not valid config option when in a class section\n");
1039                 if (cfg->modtype != DEVICE)
1040                     exitfileerror(20, "beginio_func specified when not a device\n");
1041                 cfg->beginiofunc = strdup(s);
1042                 break;
1043
1044             case 22: /* abortio_func */
1045                 if (inclass)
1046                     exitfileerror(20, "abortio_func not valid config option when in a class section\n");
1047                 if (cfg->modtype != DEVICE)
1048                     exitfileerror(20, "abortio_func specified when not a device\n");
1049                 cfg->abortiofunc = strdup(s);
1050                 break;
1051
1052             case 23: /* dispatcher */
1053                 if (cl == NULL)
1054                     exitfileerror(20, "dispatcher specified when not a BOOPSI class\n");
1055                 cl->dispatcher = strdup(s);
1056                 /* function references are not needed when dispatcher is specified */
1057                 cfg->intcfg |= CFG_NOREADFUNCS;
1058                 break;
1059
1060             case 24: /* initpri */
1061                 if (cl != NULL)
1062                 {
1063                     int count;
1064                     char dummy;
1065
1066                     count = sscanf(s, "%d%c", &cl->initpri, &dummy);
1067                     if (count != 1 ||
1068                         cl->initpri < -128 || cl->initpri > 127
1069                     )
1070                     {
1071                         exitfileerror(20, "initpri number format error\n");
1072                     }
1073                 }
1074                 else
1075                     exitfileerror(20, "initpri only valid config option for a BOOPSI class\n");
1076                 break;
1077
1078             case 25: /* type */
1079                 if (!inclass)
1080                     exitfileerror(20, "type only valid config option in a class section\n");
1081                 if (strcmp(s,"mcc")==0)
1082                     cl->classtype = MCC;
1083                 else if (strcmp(s,"mui")==0)
1084                     cl->classtype = MUI;
1085                 else if (strcmp(s,"mcp")==0)
1086                     cl->classtype = MCP;
1087                 else if (strcmp(s, "image")==0)
1088                     cl->classtype = IMAGE;
1089                 else if (strcmp(s, "gadget")==0)
1090                     cl->classtype = GADGET;
1091                 else if (strcmp(s, "datatype")==0)
1092                     cl->classtype = DATATYPE;
1093                 else if (strcmp(s, "usbclass")==0)
1094                     cl->classtype = USBCLASS;
1095                 else if (strcmp(s, "class")==0)
1096                     cl->classtype = CLASS;
1097                 else if (strcmp(s, "hidd")==0)
1098                     cl->classtype = HIDD;
1099                 else
1100                 {
1101                     fprintf(stderr, "Unknown type \"%s\" specified\n", s);
1102                     exit(20);
1103                 }
1104                 break;
1105
1106             case 26: /* addromtag */
1107                 cfg->addromtag = strdup(s);
1108                 break;
1109
1110             case 27: /* oopbase_field */
1111                 cfg->oopbase_field = strdup(s);
1112                 break;
1113             case 28: /* rellib */
1114                 slist_append(&cfg->rellibs, s);
1115                 break;
1116             case 29: /* interfaceid */
1117                 if (!in)
1118                     exitfileerror(20, "interfaceid only valid config option for an interface\n");
1119                 in->interfaceid = strdup(s);
1120                 break;
1121             case 30: /* interfacename */
1122                 if (!in)
1123                     exitfileerror(20, "interfacename only valid config option for an interface\n");
1124                 in->interfacename = strdup(s);
1125                 break;
1126             case 31: /* methodstub */
1127                 if (!in)
1128                     exitfileerror(20, "methodstub only valid config option for an interface\n");
1129                 in->methodstub = strdup(s);
1130                 break;
1131             case 32: /* methodbase */
1132                 if (!in)
1133                     exitfileerror(20, "methodbase only valid config option for an interface\n");
1134                 in->methodbase = strdup(s);
1135                 break;
1136             case 33: /* attributebase */
1137                 if (!in)
1138                     exitfileerror(20, "attributebase only valid config option for an interface\n");
1139                 in->attributebase = strdup(s);
1140                 break;
1141             case 34: /* handler_func */
1142                 if (cfg->modtype != HANDLER)
1143                     exitfileerror(20, "handler specified when not a handler\n");
1144                 cfg->handlerfunc = strdup(s);
1145                 break;
1146             case 35: /* includename */
1147                 if (inclass)
1148                     exitfileerror(20, "includename not valid config option"
1149                         " when in a class section\n");
1150                 cfg->includename = strdup(s);
1151                 break;
1152             }
1153         }
1154         else /* Line starts with ## */
1155         {
1156             s = line+2;
1157             while (isspace(*s)) s++;
1158             if (strncmp(s, "end", 3)!=0)
1159                 exitfileerror(20, "\"##end config\" expected\n");
1160
1161             s += 3;
1162             if (!isspace(*s))
1163                 exitfileerror(20, "\"##end config\" expected\n");
1164
1165             while (isspace(*s)) s++;
1166             if (strncmp(s, "config", 6)!=0)
1167                 exitfileerror(20, "\"##end config\" expected\n");
1168
1169             s += 6;
1170             while (isspace(*s)) s++;
1171             if (*s!='\0')
1172                 exitfileerror(20, "\"##end config\" expected\n");
1173
1174             atend = 1;
1175         }
1176     }
1177
1178     /* When not in a class section fill in default values for fields in cfg */
1179     if (!inclass)
1180     {
1181         if (cfg->basename==NULL)
1182         {
1183             cfg->basename = strdup(cfg->modulename);
1184             *cfg->basename = toupper(*cfg->basename);
1185         }
1186         if (cfg->libbase==NULL)
1187         {
1188             unsigned int len = strlen(cfg->basename)+5;
1189             cfg->libbase = malloc(len);
1190             snprintf(cfg->libbase, len, "%sBase", cfg->basename);
1191         }
1192         if (cfg->libbasetype == NULL && libbasetypeextern != NULL)
1193             cfg->libbasetype = strdup(libbasetypeextern);
1194         if (cfg->sysbase_field != NULL && cfg->libbasetype == NULL)
1195             exitfileerror(20, "sysbase_field specified when no libbasetype is given\n");
1196         if (cfg->seglist_field != NULL && cfg->libbasetype == NULL)
1197             exitfileerror(20, "seglist_field specified when no libbasetype is given\n");
1198         if (cfg->oopbase_field != NULL && cfg->libbasetype == NULL)
1199             exitfileerror(20, "oopbase_field specified when no libbasetype is given\n");
1200         /* rootbase_field only allowed when duplicating base */
1201         if (cfg->rootbase_field != NULL && !(cfg->options & OPTION_DUPBASE))
1202             exitfileerror(20, "rootbasefield only valid for option peropenerbase or pertaskbase\n");
1203
1204         /* Set default date to current date */
1205         if (cfg->datestring == NULL)
1206         {
1207             char tmpbuf[256];
1208             time_t now = time(NULL);
1209             struct tm *ltime = localtime(&now);
1210
1211             snprintf(tmpbuf, sizeof(tmpbuf), "%u.%u.%u",
1212                 ltime->tm_mday, 1 + ltime->tm_mon, 1900 + ltime->tm_year);
1213
1214             cfg->datestring = strdup(tmpbuf);
1215         }
1216
1217         if (cfg->copyright == NULL)
1218             cfg->copyright = "";
1219
1220         if ( (cfg->beginiofunc != NULL && cfg->abortiofunc == NULL)
1221              || (cfg->beginiofunc == NULL && cfg->abortiofunc != NULL)
1222         )
1223             exitfileerror(20, "please specify both beginio_func and abortio_func\n");
1224
1225         if (libbasetypeextern==NULL)
1226         {
1227             switch (cfg->modtype)
1228             {
1229             case DEVICE:
1230                 cfg->libbasetypeptrextern = "struct Device *";
1231                 break;
1232             case HANDLER:
1233             case RESOURCE:
1234                 cfg->libbasetypeptrextern = "APTR ";
1235                 break;
1236             case LIBRARY:
1237             case MUI:
1238             case MCP:
1239             case MCC:
1240             case GADGET:
1241             case DATATYPE:
1242             case USBCLASS:
1243             case HIDD:
1244                 cfg->libbasetypeptrextern = "struct Library *";
1245                 break;
1246             default:
1247                 fprintf(stderr, "Internal error: Unsupported modtype for libbasetypeptrextern\n");
1248                 exit(20);
1249             }
1250         }
1251         else
1252         {
1253             cfg->libbasetypeptrextern = malloc(strlen(libbasetypeextern)+3);
1254             strcpy(cfg->libbasetypeptrextern, libbasetypeextern);
1255             strcat(cfg->libbasetypeptrextern, " *");
1256             free(libbasetypeextern);
1257         }
1258
1259         if (cfg->includename == NULL)
1260             cfg->includename = cfg->modulename;
1261         cfg->includenameupper = strdup(cfg->includename);
1262         for (s=cfg->includenameupper; *s!='\0'; *s = toupper(*s), s++)
1263             if (!isalnum(*s)) *s = '_';
1264     }
1265
1266     /* When class was given too fill in some defaults when not specified */
1267     if (cl != NULL)
1268     {
1269         if (cl->classtype == UNSPECIFIED)
1270             cl->classtype = CLASS;
1271
1272         if (cl->basename == NULL)
1273         {
1274             if (!inclass)
1275                 cl->basename = cfg->basename;
1276             else
1277                 exitfileerror(20, "basename has to be specified in the config section inside of a class section\n");
1278         }
1279
1280         /* MUI classes are always private */
1281         if (cl->classtype == MUI || cl->classtype == MCC || cl->classtype == MCP)
1282             cl->options |= COPTION_PRIVATE;
1283
1284         if (cl->classid == NULL
1285             && (cl->classtype != MUI && cl->classtype != MCC && cl->classtype != MCP)
1286         )
1287         {
1288             if (cl->classtype == HIDD)
1289             {
1290                 cl->options &= !COPTION_PRIVATE;
1291             }
1292             else if (cl->options & COPTION_PRIVATE)
1293             {
1294                 cl->classid = "NULL";
1295             }
1296             else
1297             {
1298                 char s[256] = "";
1299
1300                 if (cl->classtype == GADGET || cl->classtype == IMAGE || cl->classtype == CLASS || cl->classtype == USBCLASS)
1301                 {
1302                     sprintf(s, "\"%sclass\"", inclass ? cl->basename : cfg->modulename);
1303                 }
1304                 else if (cl->classtype == DATATYPE)
1305                 {
1306                     sprintf(s, "\"%s.datatype\"", inclass ? cl->basename : cfg->modulename);
1307                 }
1308                 cl->classid = strdup(s);
1309             }
1310         }
1311
1312         /* Only specify superclass or superclass_field */
1313         if (cl->superclass != NULL && cl->superclass_field != NULL)
1314             exitfileerror(20, "Only specify one of superclass or superclass_field in config section\n");
1315
1316         /* Give default value to superclass if it is not specified */
1317         if (cl->superclass == NULL && cl->superclass == NULL)
1318         {
1319             switch (cl->classtype)
1320             {
1321             case MUI:
1322             case MCC:
1323                 cl->superclass = "MUIC_Area";
1324                 break;
1325             case MCP:
1326                 cl->superclass = "MUIC_Mccprefs";
1327                 break;
1328             case IMAGE:
1329                 cl->superclass = "IMAGECLASS";
1330                 break;
1331             case GADGET:
1332                 cl->superclass = "GADGETCLASS";
1333                 break;
1334             case DATATYPE:
1335                 cl->superclass = "DATATYPESCLASS";
1336                 break;
1337             case CLASS:
1338                 cl->superclass = "ROOTCLASS";
1339                 break;
1340             case HIDD:
1341                 cl->superclass = "CLID_Root";
1342                 break;
1343             default:
1344                 exitfileerror(20, "Internal error: unhandled classtype in readsectionconfig\n");
1345                 break;
1346             }
1347         }
1348     }
1349 }
1350
1351 static void readsectioncdef(struct config *cfg)
1352 {
1353     int atend = 0;
1354     char *line, *s;
1355
1356     while (!atend)
1357     {
1358         line = readline();
1359         if (line==NULL)
1360             exitfileerror(20, "unexptected end of file in section cdef\n");
1361
1362         if (strncmp(line, "##", 2)!=0)
1363         {
1364             slist_append(&cfg->cdeflines, line);
1365         }
1366         else
1367         {
1368             s = line+2;
1369             while (isspace(*s)) s++;
1370             if (strncmp(s, "end", 3)!=0)
1371                 exitfileerror(20, "\"##end cdef\" expected\n");
1372
1373             s += 3;
1374             while (isspace(*s)) s++;
1375             if (strncmp(s, "cdef", 4)!=0)
1376                 exitfileerror(20, "\"##end cdef\" expected\n");
1377
1378             s += 5;
1379             while (isspace(*s)) s++;
1380             if (*s!='\0')
1381                 exitfileerror(20, "unexpected character at position %d\n");
1382
1383             atend = 1;
1384         }
1385     }
1386 }
1387
1388 static void readsectioncdefprivate(struct config *cfg)
1389 {
1390     int atend = 0;
1391     char *line, *s;
1392
1393     while (!atend)
1394     {
1395         line = readline();
1396         if (line==NULL)
1397             exitfileerror(20, "unexptected end of file in section cdef\n");
1398
1399         if (strncmp(line, "##", 2)!=0)
1400         {
1401             slist_append(&cfg->cdefprivatelines, line);
1402         }
1403         else
1404         {
1405             s = line+2;
1406             while (isspace(*s)) s++;
1407             if (strncmp(s, "end", 3)!=0)
1408                 exitfileerror(20, "\"##end cdefprivate\" expected\n");
1409
1410             s += 3;
1411             while (isspace(*s)) s++;
1412             if (strncmp(s, "cdefprivate", 11)!=0)
1413                 exitfileerror(20, "\"##end cdefprivate\" expected\n");
1414
1415             s += 11;
1416             while (isspace(*s)) s++;
1417             if (*s!='\0')
1418                 exitfileerror(20, "unexpected character at position %d\n");
1419
1420             atend = 1;
1421         }
1422     }
1423 }
1424
1425 static void readsectionstartup(struct config *cfg)
1426 {
1427     int atend = 0;
1428     char *line, *s;
1429
1430     while (!atend)
1431     {
1432         line = readline();
1433         if (line==NULL)
1434             exitfileerror(20, "unexptected end of file in section startup\n");
1435
1436         if (strncmp(line, "##", 2)!=0)
1437         {
1438             slist_append(&cfg->startuplines, line);
1439         }
1440         else
1441         {
1442             s = line+2;
1443             while (isspace(*s)) s++;
1444             if (strncmp(s, "end", 3)!=0)
1445                 exitfileerror(20, "\"##end startup\" expected\n");
1446
1447             s += 3;
1448             while (isspace(*s)) s++;
1449             if (strncmp(s, "startup", 7)!=0)
1450                 exitfileerror(20, "\"##end startup\" expected\n");
1451
1452             s += 7;
1453             while (isspace(*s)) s++;
1454             if (*s!='\0')
1455                 exitfileerror(20, "unexpected character at position %d\n");
1456
1457             atend = 1;
1458         }
1459     }
1460 }
1461
1462 static void readsectionfunctionlist(const char *type, struct functionhead **funclistptr, unsigned int firstlvo, int isattribute, enum libcall def_libcall)
1463 {
1464     int atend = 0, i;
1465     char *line, *s, *s2;
1466     unsigned int lvo = firstlvo;
1467     int minversion = -1;
1468
1469     while (!atend)
1470     {
1471         line = readline();
1472         if (line==NULL)
1473             exitfileerror(20, "unexpected EOF in functionlist section\n");
1474         if (strlen(line)==0)
1475         {
1476             if (*funclistptr != NULL)
1477                 funclistptr = &((*funclistptr)->next);
1478             lvo++;
1479         }
1480         else if (isspace(*line))
1481         {
1482             s = line;
1483             while (isspace(*s)) s++;
1484             if (*s=='\0')
1485             {
1486                 if (*funclistptr != NULL)
1487                     funclistptr = &((*funclistptr)->next);
1488                 lvo++;
1489             }
1490             else
1491                 exitfileerror(20, "no space allowed before functionname\n");
1492         }
1493         else if (strncmp(line, "##", 2)==0)
1494         {
1495             s = line+2;
1496             while (isspace(*s)) s++;
1497             if (strncmp(s, "end", 3)!=0)
1498                 exitfileerror(20, "\"##end %s\" expected\n", type);
1499
1500             s += 3;
1501             while (isspace(*s)) s++;
1502             if (strncmp(s, type, strlen(type))!=0)
1503                 exitfileerror(20, "\"##end %s\" expected\n", type);
1504
1505             s += strlen(type);
1506             while (isspace(*s)) s++;
1507             if (*s!='\0')
1508                 exitfileerror(20, "unexpected character on position %d\n", s-line);
1509
1510             atend = 1;
1511         }
1512         else if (*line=='.')
1513         {
1514             s = line+1;
1515             if (strncmp(s, "skip", 4)==0)
1516             {
1517                 int n;
1518
1519                 s += 4;
1520                 if (!isspace(*s))
1521                     exitfileerror(20, "syntax is '.skip n'\n");
1522
1523                 n=strtol(s, &s2, 10);
1524                 if (s2==NULL)
1525                     exitfileerror(20, "positive number expected\n");
1526
1527                 while (isspace(*s2)) s2++;
1528                 if ((*s2 != '\0') && (*s2 != '#'))
1529                     exitfileerror(20, "syntax is '.skip n'\n");
1530                 if (*funclistptr != NULL)
1531                     funclistptr = &((*funclistptr)->next);
1532                 lvo += n;
1533             }
1534             else if (strncmp(s, "alias", 5)==0)
1535             {
1536                 s += 5;
1537
1538                 if (!isspace(*s))
1539                     exitfileerror(20, "syntax is '.alias name'\n");
1540
1541                 while (isspace(*s)) s++;
1542                 if (*s == '\0' || !(isalpha(*s) || *s == '_'))
1543                     exitfileerror(20, "syntax is '.alias name'\n");
1544
1545                 s2 = s;
1546                 s++;
1547                 while (isalnum(*s) || *s == '_') s++;
1548
1549                 if (isspace(*s))
1550                 {
1551                     *s = '\0';
1552                     do {
1553                         s++;
1554                     } while (isspace(*s));
1555                 }
1556
1557                 if (*s != '\0')
1558                     exitfileerror(20, "syntax is '.alias name'\n");
1559
1560                 if (*funclistptr == NULL)
1561                     exitfileerror(20, ".alias has to come after a function declaration\n");
1562
1563                 slist_append(&(*funclistptr)->aliases, s2);
1564             }
1565             else if (strncmp(s, "function", 8) == 0)
1566             {
1567                 s += 8;
1568
1569                 if (!isspace(*s))
1570                     exitfileerror(20, "Syntax error\n");
1571
1572                 while (isspace(*s)) s++;
1573                 if (*s == '\0' || !(isalpha(*s) || *s == '_'))
1574                     exitfileerror(20, "syntax is '.function name'\n");
1575
1576                 s2 = s;
1577                 s++;
1578                 while (isalnum(*s) || *s == '_') s++;
1579
1580                 if (isspace(*s))
1581                 {
1582                     *s = '\0';
1583                     do {
1584                         s++;
1585                     } while (isspace(*s));
1586                 }
1587
1588                 if (*s != '\0')
1589                     exitfileerror(20, "syntax is '.function name'\n");
1590
1591                 if (*funclistptr == NULL)
1592                     exitfileerror(20, ".function has to come after a function declaration\n");
1593
1594                 funcsetinternalname(*funclistptr, s2);
1595             }
1596             else if (strncmp(s, "cfunction", 9)==0)
1597             {
1598                 if (*funclistptr == NULL)
1599                     exitfileerror(20, ".cfunction has to come after a function declaration\n");
1600
1601                 (*funclistptr)->libcall = REGISTER;
1602             }
1603             else if (strncmp(s, "private", 7)==0)
1604             {
1605                 if (*funclistptr == NULL)
1606                     exitfileerror(20, ".private has to come after a function declaration\n");
1607
1608                 (*funclistptr)->priv = 1;
1609             }
1610             else if (strncmp(s, "novararg", 8)==0)
1611             {
1612                 if (*funclistptr == NULL)
1613                     exitfileerror(20, ".novararg has to come after a function declaration\n");
1614
1615                 (*funclistptr)->novararg = 1;
1616             }
1617             else if (strncmp(s, "version", 7) == 0)
1618             {
1619                 /* Mark version number for the following
1620                  * functions, so that the automatic OpenLibrary()
1621                  * will know what version to use.
1622                  */
1623                 char *tmp;
1624                 int ver;
1625
1626                 s += 7;
1627
1628                 while (isspace(*s)) s++;
1629                 ver = (int)strtol(s, &tmp, 0);
1630
1631                 if (s == tmp)
1632                     exitfileerror(20, ".version expects an integer\n");
1633
1634                 s = tmp;
1635                 while (isspace(*s)) s++;
1636
1637                 if (*s && *s != '#')
1638                     exitfileerror(20, ".version has junk after the version number\n");
1639
1640                 minversion = ver;
1641             }
1642             else if (strncmp(s, "unusedlibbase", 13) == 0)
1643             {
1644                 if (*funclistptr == NULL)
1645                     exitfileerror(20, ".unusedlibbase has to come after a function declaration\n");
1646                 (*funclistptr)->unusedlibbase = 1;
1647             }
1648             else
1649                 exitfileerror(20, "Syntax error");
1650         }
1651         else if (*line!='#') /* Ignore line that is a comment, e.g. that starts with a # */
1652         {
1653             /* The line is a function or attribute prototype.
1654              * A function can have one of two syntaxes:
1655              * type funcname(argproto1, argproto2, ...)
1656              * type funcname(argproto1, argproto2, ...) (reg1, reg2, ...)
1657              * The former is for C type function argument passing, the latter for
1658              * register argument passing.
1659              * An attribute has the following syntax:
1660              * type attribute
1661              */
1662             char c, *args[64], *regs[64], *funcname, *cp;
1663             int len, argcount = 0, regcount = 0, brcount = 0;
1664
1665             cp = strchr(line,'#');
1666             if (cp)
1667                 *(cp++) = 0;
1668
1669             /* Parse 'type functionname' at the beginning of the line */
1670             if (isattribute) {
1671                 s = line + strlen(line);
1672             } else {
1673                 s = strchr(line, '(');
1674                 if (s == NULL)
1675                     exitfileerror(20, "( expected at position %d\n", strlen(line) + 1);
1676             }
1677
1678             s2 = s;
1679             while (isspace(*(s2-1)))
1680                 s2--;
1681             *s2 = '\0';
1682
1683             while (s2 > line && !isspace(*(s2-1)) && !(*(s2-1) == '*'))
1684                 s2--;
1685
1686             if (s2 == line)
1687                 exitfileerror(20, "No type specifier before %s name\n", isattribute ? "attribute" : "function");
1688
1689             if (*funclistptr != NULL)
1690                 funclistptr = &((*funclistptr)->next);
1691             *funclistptr = newfunctionhead(s2, STACK);
1692
1693             if (cp)
1694                 (*funclistptr)->comment = strdup(cp);
1695             else
1696                 (*funclistptr)->comment = NULL;
1697
1698             while (isspace(*(s2-1)))
1699                 s2--;
1700             *s2 = '\0';
1701             (*funclistptr)->type = strdup(line);
1702             (*funclistptr)->lvo = lvo;
1703             (*funclistptr)->version = minversion;
1704             lvo++;
1705
1706             if (isattribute)
1707                 continue;
1708
1709             /* Parse function prototype */
1710             s++;
1711             while (isspace(*s))
1712                 s++;
1713             c = *s;
1714
1715             while (c != ')')
1716             {
1717                 while (isspace(*s))
1718                     s++;
1719
1720                 args[argcount] = s;
1721                 argcount++;
1722
1723                 while
1724                 (
1725                     *s != '\0'
1726                     && !(brcount == 0 && (*s == ',' || *s == ')'))
1727                 )
1728                 {
1729                     if (*s == '(')
1730                         brcount++;
1731                     if (*s == ')')
1732                     {
1733                         if (brcount > 0)
1734                             brcount--;
1735                         else
1736                             exitfileerror(20, "Unexected ')' at position %d\n", s-line+1);
1737                     }
1738                     s++;
1739                 }
1740
1741                 c = *s;
1742                 if (c == '\0')
1743                     exitfileerror(20, "'(' without ')'");
1744
1745                 s2 = s;
1746                 while (isspace(*(s2-1)))
1747                     s2--;
1748                 *s2 = '\0';
1749
1750                 if (!(s2 > args[argcount - 1]))
1751                     exitfileerror(20, "Syntax error in function prototype\n");
1752
1753                 s++;
1754             }
1755
1756             s++;
1757             while (*s != '\0' && isspace(*s))
1758                 s++;
1759
1760             if (*s == '(')
1761             {
1762                 /* Parse registers specifications if available otherwise this prototype for C type argument passing */
1763
1764                 /* There may be no register specified with () so be sure then c is == ')' */
1765                 s++;
1766                 while(isspace(*s))
1767                     s++;
1768
1769                 c = *s;
1770
1771                 while (c != ')')
1772                 {
1773                     while (isspace(*s))
1774                         s++;
1775
1776                     regs[regcount] = s;
1777                     regcount++;
1778
1779                     if (memchr("AD",s[0],2)!=NULL && memchr("01234567",s[1],8)!=NULL)
1780                     {
1781                         s += 2;
1782                         c = *s;
1783                         if (c == '/')
1784                         {
1785                             s++;
1786                             if (s[0] == s[-3] && s[1] == s[-2] + 1)
1787                             {
1788                                 s += 2;
1789                                 c = *s;
1790                             }
1791                             else
1792                                 exitfileerror(20,
1793                                               "wrong register specification \"%s\" for argument %u\n",
1794                                               regs[regcount-1], regcount
1795                                 );
1796
1797                             if (regcount > 4)
1798                                 exitfileerror(20, "maximum four arguments passed in two registers allowed (%d, %s) \n", regcount, regs[regcount-1]);
1799                         }
1800                         *s = '\0';
1801                     }
1802                     else
1803                         exitfileerror(20,
1804                                       "wrong register \"%s\" for argument %u\n",
1805                                       regs[regcount-1], regcount
1806                         );
1807
1808                     while (isspace(c))
1809                     {
1810                         s++;
1811                         c = *s;
1812                     }
1813                     if (c == '\0')
1814                         exitfileerror(20, "'(' without ')'\n");
1815                     if (c != ',' && c != ')')
1816                         exitfileerror(20, "',' or ')' expected at position %d\n", s-line+1);
1817
1818                     s++;
1819                 }
1820
1821                 s++;
1822                 while (isspace(*s)) s++;
1823                 if (*s!='\0')
1824                     exitfileerror(20, "wrong char '%c' at position %d\n", *s, (int)(s-line) + 1);
1825
1826                 if (argcount != regcount)
1827                     exitfileerror(20, "Number of arguments (%d) and registers (%d) mismatch\n",
1828                                   argcount, regcount
1829                     );
1830
1831                 (*funclistptr)->libcall = def_libcall;
1832                 for (i = 0; i < argcount; i++)
1833                     funcaddarg(*funclistptr, args[i], regs[i]);
1834             }
1835             else if (*s == '\0')
1836             { /* No registers specified */
1837                 for (i = 0; i < argcount; i++)
1838                     funcaddarg(*funclistptr, args[i], NULL);
1839             }
1840             else
1841                 exitfileerror(20, "wrong char '%c' at position %d\n", *s, (int)(s-line) + 1);
1842         }
1843     }
1844 }
1845
1846 static void readsectionclass_methodlist(struct classinfo *cl)
1847 {
1848     int atend = 0, i;
1849     char *line, *s, *s2;
1850     struct functionhead **methlistptr = &cl->methlist;
1851     struct stringlist *interface = NULL;
1852
1853     if (cl->basename==NULL)
1854         exitfileerror(20, "section methodlist has to come after section config\n");
1855
1856     while (!atend)
1857     {
1858         line = readline();
1859         if (line==NULL)
1860             exitfileerror(20, "unexptected EOF in methodlist section\n");
1861
1862         /* Ignore empty lines or lines that qre a comment, e.g. that starts with a # */
1863         if (strlen(line)==0 || (line[0] == '#' && line[1] != '#'))
1864             continue;
1865
1866         if (isspace(*line))
1867             exitfileerror(20, "No space allowed at start of the line\n");
1868
1869         if (strncmp(line, "##", 2)==0) /* Is this the end ? */
1870         {
1871             s = line+2;
1872             while (isspace(*s)) s++;
1873             if (strncmp(s, "end", 3)!=0)
1874                 exitfileerror(20, "\"##end methodlist\" expected\n");
1875
1876             s += 3;
1877             while (isspace(*s)) s++;
1878             if (strncmp(s, "methodlist", 10)!=0)
1879                 exitfileerror(20, "\"##end methodlist\" expected\n");
1880
1881             s += 10;
1882             while (isspace(*s)) s++;
1883             if (*s!='\0')
1884                 exitfileerror(20, "unexpected character on position %d\n", s-line);
1885
1886             atend = 1;
1887
1888             continue;
1889         }
1890
1891         if (*line=='.')
1892         {
1893             s = line+1;
1894             if (strncmp(s, "alias", 5)==0)
1895             {
1896                 s += 5;
1897
1898                 if (!isspace(*s))
1899                     exitfileerror(20, "syntax is '.alias name'\n");
1900
1901                 while (isspace(*s)) s++;
1902                 if (*s == '\0' || !(isalpha(*s) || *s == '_'))
1903                     exitfileerror(20, "syntax is '.alias name'\n");
1904
1905                 s2 = s;
1906                 s++;
1907                 while (isalnum(*s) || *s == '_') s++;
1908
1909                 if (isspace(*s))
1910                 {
1911                     *s = '\0';
1912                     do {
1913                         s++;
1914                     } while (isspace(*s));
1915                 }
1916
1917                 if (*s != '\0')
1918                     exitfileerror(20, "syntax is '.alias name'\n");
1919
1920                 if (*methlistptr == NULL)
1921                     exitfileerror(20, ".alias has to come after a function declaration\n");
1922
1923                 slist_append(&(*methlistptr)->aliases, s2);
1924             }
1925             else if (strncmp(s, "function", 8) == 0)
1926             {
1927                 s += 8;
1928
1929                 if (!isspace(*s))
1930                     exitfileerror(20, "Syntax error\n");
1931
1932                 while (isspace(*s)) s++;
1933                 if (*s == '\0' || !(isalpha(*s) || *s == '_'))
1934                     exitfileerror(20, "syntax is '.function name'\n");
1935
1936                 s2 = s;
1937                 s++;
1938                 while (isalnum(*s) || *s == '_') s++;
1939
1940                 if (isspace(*s))
1941                 {
1942                     *s = '\0';
1943                     do {
1944                         s++;
1945                     } while (isspace(*s));
1946                 }
1947
1948                 if (*s != '\0')
1949                     exitfileerror(20, "syntax is '.function name'\n");
1950
1951                 if (*methlistptr == NULL)
1952                     exitfileerror(20, ".function has to come after a function declaration\n");
1953
1954                 funcsetinternalname(*methlistptr, s2);
1955             }
1956             else if (strncmp(s, "interface", 9) == 0)
1957             {
1958                 if (cl->classtype != HIDD)
1959                     exitfileerror(20, "interface only valid for a HIDD\n");
1960
1961                 s += 9;
1962
1963                 if (!isspace(*s))
1964                     exitfileerror(20, "Syntax error\n");
1965
1966                 while (isspace(*s)) s++;
1967                 if (*s == '\0' || !isalpha(*s))
1968                     exitfileerror(20, "syntax is '.interface name'\n");
1969
1970                 s2 = s;
1971                 s++;
1972                 while (isalnum(*s) || *s == '_') s++;
1973
1974                 if (isspace(*s))
1975                 {
1976                     *s = '\0';
1977                     do {
1978                         s++;
1979                     } while (isspace(*s));
1980                 }
1981
1982                 if (*s != '\0')
1983                     exitfileerror(20, "syntax is '.interface name'\n");
1984
1985                 interface = slist_append(&cl->interfaces, s2);
1986             }
1987             else
1988                 exitfileerror(20, "Syntax error");
1989         }
1990         else if (isalpha(*line))
1991         {
1992             char stmp[256];
1993
1994             for (s = line + 1; isalnum(*s) || *s == '_'; s++)
1995                 ;
1996
1997             if (cl->classtype == HIDD && interface == NULL)
1998                 exitfileerror(20, "For a HIDD the first method has to come after an .interface line\n");
1999
2000             if (*s != '\0')
2001                 exitfileerror(20, "Only letters, digits and an underscore allowed in a methodname\n");
2002
2003             if (*methlistptr != NULL)
2004                 methlistptr = &((*methlistptr)->next);
2005             if (cl->classtype != HIDD)
2006             {
2007                 if (snprintf(stmp, 256, "%s__%s", cl->basename, line) >= 256)
2008                     exitfileerror(20, "Method name too large\n");
2009
2010                 *methlistptr = newfunctionhead(stmp, STACK);
2011                 (*methlistptr)->type = "IPTR";
2012                 funcaddarg(*methlistptr, "Class *cl", NULL);
2013                 funcaddarg(*methlistptr, "Object *o", NULL);
2014                 funcaddarg(*methlistptr, "Msg msg", NULL);
2015             }
2016             else
2017             {
2018                 if (snprintf(stmp, 256, "%s__%s__%s", cl->basename, interface->s, line) >= 256)
2019                     exitfileerror(20, "Method name too large\n");
2020
2021                 *methlistptr = newfunctionhead(stmp, STACK);
2022                 (*methlistptr)->type = "IPTR";
2023                 funcaddarg(*methlistptr, "OOP_Class *cl", NULL);
2024                 funcaddarg(*methlistptr, "OOP_Object *o", NULL);
2025                 funcaddarg(*methlistptr, "OOP_Msg msg", NULL);
2026                 (*methlistptr)->interface = interface;
2027                 if (snprintf(stmp, 256, "mo%s_%s", interface->s, line) >= 256)
2028                     exitfileerror(20, "Method name too large\n");
2029                 (*methlistptr)->method = strdup(stmp);
2030             }
2031             slist_append(&(*methlistptr)->aliases, line);
2032         }
2033         else
2034             exitfileerror(20, "Methodname has to begin with a letter\n");
2035     }
2036 }
2037
2038 static void
2039 readsectioninterface(struct config *cfg)
2040 {
2041     char *s;
2042     struct interfaceinfo *in;
2043
2044     in = newinterface(cfg);
2045     s = readsections(cfg, NULL, in, 1);
2046     if (s == NULL)
2047         exitfileerror(20, "Unexpected end of file\n");
2048
2049     if (strncmp(s, "##", 2) != 0)
2050         exitfileerror(20, "'##end interface' expected\n");
2051     s += 2;
2052
2053     while (isspace(*s)) s++;
2054
2055     if (strncmp(s, "end", 3) != 0)
2056         exitfileerror(20, "'##end interface' expected\n");
2057     s += 3;
2058
2059     if (!isspace(*s))
2060         exitfileerror(20, "'##end interface' expected\n");
2061     while (isspace(*s)) s++;
2062
2063     if (strncmp(s, "interface", 9) != 0)
2064         exitfileerror(20, "'##end interface' expected\n");
2065     s += 9;
2066
2067     while (isspace(*s)) s++;
2068     if (*s != '\0')
2069         exitfileerror(20, "'##end interface' expected\n");
2070
2071     if (!in->interfaceid)
2072         exitfileerror(20, "interface has no 'interfaceid' defined!\n");
2073
2074     if (!in->interfacename)
2075         exitfileerror(20, "interface has no 'interfacename' defined!\n");
2076
2077     if (!in->methodstub)
2078         in->methodstub = strdup(in->interfacename);
2079
2080     if (!in->methodbase) {
2081         int len = strlen(in->interfacename);
2082         in->methodbase = malloc(len + 4 + 1);
2083         strcpy(in->methodbase, in->interfacename);
2084         strcat(in->methodbase, "Base");
2085     }
2086
2087     if (!in->attributebase) {
2088         int len = strlen(in->interfacename);
2089         in->attributebase = malloc(len + 4 + 4 + 1);
2090         strcpy(in->attributebase, in->interfacename);
2091         strcat(in->attributebase, "AttrBase");
2092     }
2093 }
2094
2095 static void
2096 readsectionclass(struct config *cfg)
2097 {
2098     char *s;
2099     struct classinfo *cl;
2100
2101     cl = newclass(cfg);
2102     s = readsections(cfg, cl, NULL, 1);
2103     if (s == NULL)
2104         exitfileerror(20, "Unexpected end of file\n");
2105
2106     if (strncmp(s, "##", 2) != 0)
2107         exitfileerror(20, "'##end class' expected\n");
2108     s += 2;
2109
2110     while (isspace(*s)) s++;
2111
2112     if (strncmp(s, "end", 3) != 0)
2113         exitfileerror(20, "'##end class' expected\n");
2114     s += 3;
2115
2116     if (!isspace(*s))
2117         exitfileerror(20, "'##end class' expected\n");
2118     while (isspace(*s)) s++;
2119
2120     if (strncmp(s, "class", 5) != 0)
2121         exitfileerror(20, "'##end class' expected\n");
2122     s += 5;
2123
2124     while (isspace(*s)) s++;
2125     if (*s != '\0')
2126         exitfileerror(20, "'##end class' expected\n");
2127 }
2128
2129 static struct classinfo *newclass(struct config *cfg)
2130 {
2131     struct classinfo *cl, *classlistit;
2132
2133     cl = malloc(sizeof(struct classinfo));
2134     if (cl == NULL)
2135     {
2136         fprintf(stderr, "Out of memory\n");
2137         exit(20);
2138     }
2139     memset(cl, 0, sizeof(struct classinfo));
2140
2141     /* By default the classes are initialized with a priority of 1 so they
2142      * are initialized before any user added initialization with priority 1
2143      */
2144     cl->initpri = 1;
2145
2146     if (cfg->classlist == NULL)
2147         cfg->classlist = cl;
2148     else
2149     {
2150         for
2151         (
2152             classlistit = cfg->classlist;
2153             classlistit->next != NULL;
2154             classlistit = classlistit->next
2155         )
2156             ;
2157         classlistit->next = cl;
2158     }
2159
2160     return cl;
2161 }
2162
2163 static struct handlerinfo *newhandler(struct config *cfg)
2164 {
2165     struct handlerinfo *hl;
2166
2167     hl = calloc(1,sizeof(*hl));
2168     hl->next = cfg->handlerlist;
2169     cfg->handlerlist = hl;
2170     return hl;
2171 }
2172
2173 static struct interfaceinfo *newinterface(struct config *cfg)
2174 {
2175     struct interfaceinfo *in, *interfacelistit;
2176
2177     in = malloc(sizeof(struct interfaceinfo));
2178     if (in == NULL)
2179     {
2180         fprintf(stderr, "Out of memory\n");
2181         exit(20);
2182     }
2183     memset(in, 0, sizeof(struct interfaceinfo));
2184
2185     if (cfg->interfacelist == NULL)
2186         cfg->interfacelist = in;
2187     else
2188     {
2189         for
2190         (
2191             interfacelistit = cfg->interfacelist;
2192             interfacelistit->next != NULL;
2193             interfacelistit = interfacelistit->next
2194         )
2195             ;
2196         interfacelistit->next = in;
2197     }
2198
2199     return in;
2200 }
2201
2202
2203 static int getdirective(char *s, const char *directive, int range_min, int range_max, int *val)
2204 {
2205     char *tmp;
2206     int newval;
2207
2208     if (strncmp(s, directive, strlen(directive)) != 0)
2209         return 0;
2210
2211     s += strlen(directive);
2212     if (*s && !isspace(*s))
2213         exitfileerror(20, "Unrecognized directive \".%s\"\n", directive);
2214
2215     while (isspace(*s)) s++;
2216     if (!*s)
2217         exitfileerror(20, "No .%s value specified\n", directive);
2218
2219     newval = strtol(s, &tmp, 0);
2220     if (s == tmp || !(newval >= range_min && newval <= range_max)) {
2221         tmp = s;
2222         while (*tmp && !isspace(*tmp)) tmp++;
2223         exitfileerror(20, "Invalid .%s value of %.*s\n", directive, tmp - s, s);
2224     }
2225
2226     *val = newval;
2227     return 1;
2228 }
2229
2230 static void
2231 readsectionhandler(struct config *cfg)
2232 {
2233     char *line = NULL, *s;
2234     struct handlerinfo *hl;
2235     unsigned char autolevel = 0;
2236     unsigned int stacksize = 0;
2237     int startup = 0;
2238     char priority = 10;
2239     int bootpri = -128;
2240     int has_filesystem = 0;
2241
2242     for (;;)
2243     {
2244         char *function;
2245         int function_len;
2246         char *tmp;
2247
2248         s = line = readline();
2249
2250         if (s==NULL)
2251             exitfileerror(20, "unexpected end of file in section hanlder\n");
2252
2253         if (strncmp(s, "##", 2)==0)
2254             break;
2255
2256         /* Ignore comments */
2257         if (strncmp(s, "#", 1)==0)
2258             continue;
2259
2260         /* Skip ahead to function name */
2261         while (*s && isspace(*s)) s++;
2262
2263         /* Permit blank lines */
2264         if (!*s)
2265             continue;
2266
2267         if (*s == '.') {
2268             int val;
2269             s++;
2270
2271             if (getdirective(s, "autodetect", 0, 127, &val)) {
2272                 autolevel = val;
2273             } else if (getdirective(s, "stacksize", 0, INT_MAX, &val)) {
2274                 stacksize = val;
2275             } else if (getdirective(s, "priority", -128, 127, &val)) {
2276                 priority = val;
2277             } else if (getdirective(s, "bootpri", -128, 127, &val)) {
2278                 bootpri = val;
2279             } else if (getdirective(s, "startup", INT_MIN, INT_MAX, &val)) {
2280                 startup = val;
2281             } else {
2282                 exitfileerror(20, "Unrecognized directive \"%s\"\n", line);
2283             }
2284             continue;
2285         }
2286
2287         do {
2288             unsigned int id = 0;
2289
2290             if (strncasecmp(s,"resident=",9)==0) {
2291                 char *res;
2292
2293                 s = strchr(s, '=') + 1;
2294                 res = s;
2295                 while (*s && !isspace(*s)) s++;
2296                 if (res == s)
2297                     exitfileerror(20, "Empty resident= is not permitted\n");
2298
2299                 if (*s)
2300                     *(s++) = 0;
2301
2302                 hl = newhandler(cfg);
2303                 hl->type = HANDLER_RESIDENT;
2304                 hl->id = 0;
2305                 hl->name = strdup(res);
2306                 hl->autodetect = autolevel--;
2307                 hl->stacksize = stacksize;
2308                 hl->priority = priority;
2309                 hl->startup = startup;
2310             } else if (strncasecmp(s,"dosnode=",8)==0) {
2311                 char *dev;
2312
2313                 s = strchr(s, '=') + 1;
2314                 dev = s;
2315                 while (*s && !isspace(*s)) s++;
2316                 if (dev == s)
2317                     exitfileerror(20, "Empty dosnode= is not permitted\n");
2318
2319                 if (*s)
2320                     *(s++) = 0;
2321
2322                 hl = newhandler(cfg);
2323                 hl->type = HANDLER_DOSNODE;
2324                 hl->id = 0;
2325                 hl->name = strdup(dev);
2326                 hl->autodetect = autolevel ? autolevel-- : 0;
2327                 hl->stacksize = stacksize;
2328                 hl->priority = priority;
2329                 hl->startup = startup;
2330                 hl->bootpri = bootpri;
2331             } else if (strncasecmp(s,"dostype=",8) == 0) {
2332                 s = strchr(s, '=') + 1;
2333
2334                 id = (unsigned int)strtoul(s, &tmp, 0);
2335
2336                 if (s == tmp) {
2337                     while (*tmp && !isspace(*tmp))
2338                         tmp++;
2339                     exitfileerror(20, "\"%.*s\" is not a numerical DOS ID\n", (tmp -s), s);
2340                 }
2341                 s = tmp;
2342
2343                 if (id == 0 || id == ~0) {
2344                     exitfileerror(20, "DOS ID 0x%08x is not permitted\n", id);
2345                 }
2346
2347                 hl = newhandler(cfg);
2348                 hl->type = HANDLER_DOSTYPE;
2349                 hl->id = id;
2350                 hl->name = NULL;
2351                 hl->autodetect = autolevel ? autolevel-- : 0;
2352                 hl->stacksize = stacksize;
2353                 hl->priority = priority;
2354                 hl->startup = startup;
2355             } else {
2356                 for (tmp = s; !isspace(*tmp); tmp++);
2357                 exitfileerror(20, "Unknown option \"%.*s\"\n", tmp - s, s);
2358             }
2359
2360             /* Advance to next ID */
2361             while (*s && isspace(*s)) s++;
2362
2363         } while (*s);
2364     }
2365
2366     if (s == NULL)
2367         exitfileerror(20, "Unexpected end of file\n");
2368
2369     if (strncmp(s, "##", 2) != 0)
2370         exitfileerror(20, "'##end handler' expected\n");
2371     s += 2;
2372
2373     while (isspace(*s)) s++;
2374
2375     if (strncmp(s, "end", 3) != 0)
2376         exitfileerror(20, "'##end handler' expected\n");
2377     s += 3;
2378
2379     while (isspace(*s)) s++;
2380
2381     if (strncmp(s, "handler", 7) != 0)
2382         exitfileerror(20, "'##end handler' expected\n");
2383     s += 7;
2384
2385     while (isspace(*s)) s++;
2386     if (*s != '\0')
2387         exitfileerror(20, "'##end handler' expected\n");
2388 }
2389
2390