tools/genmodule/config.c

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