AmigActive 15/AACD15.ISO/AACD/Programming/Python2/Python20_source/Amiga_Misc/ParseSetup.c

C/C++ Source or Header | 1998-11-10 | 5.3 KB | 302 lines

/******************************************************************

    Processor for Modules/Setup.in & Modules/Config.c.in,
    to generate appropriate Modules/Config.c file.
    Part of AmigaPython source distribution.

    Sorry but this program cannot be written in Python!
    (because people building Python need this program,
    and don't yet have a Python executable ofcourse).


    Written June 1998 by Irmen de Jong. ([e-mail])

******************************************************************/

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#define SETUPFILENAME "Setup"
#define CONFIGFILENAME_IN "config.c.in"
#define CONFIGFILENAME_OUT "config.c"

typedef enum { L_SKIP, L_MODULE, L_DEFINE, L_OPTION } lineType;

struct Node
{
    char *string;
    int line;
    struct Node *next;
};

static struct Node *moduleList = NULL;
static struct Node *moduleTail = NULL;
static struct Node *defineList = NULL;
static struct Node *defineTail = NULL;

static struct Node *protoList = NULL;
static struct Node *protoTail = NULL;
static struct Node *configentryList = NULL;
static struct Node *configentryTail = NULL;

static int lineNumber;

static char *setup_filename=SETUPFILENAME;
static char *configin_filename=CONFIGFILENAME_IN;
static char *configout_filename=CONFIGFILENAME_OUT;


/// Utility functions
static void addTail(struct Node **listhead, struct Node **listtail, struct Node *node)
{
    node->next = NULL;
    if(*listhead)
    {
        (*listtail)->next=node;
    }
    else
    {
        (*listhead)=node;
    }
    (*listtail)=node;
}

static void addStrToList(struct Node **listHead, struct Node **listTail, const char *string)
{
    struct Node *node;

    if(node=malloc(sizeof(struct Node)))
    {
        if(node->string = strdup(string))
        {
            node->line = lineNumber;
            addTail(listHead,listTail,node);
            return;
        }
        free(node);
    }

    puts("NO MEM");
}


static lineType classifyLine(char *string)
{
    switch (string[0])
    {
        case '#':
        case '\0':
        case '\n':
                return L_SKIP;
        case '*':
                return L_OPTION;
        default:
            {
                if(strchr(string,'='))
                    return L_DEFINE;
                else
                    return L_MODULE;
            }
    }
}

static void stripNL(char *string)
{
    int l;

    l=strlen(string)-1;
    if(l>=0)
    {
        if(string[l]=='\n')
            string[l]='\0';
    }
}

static void stripComment(char *moduleline)
{
    char *pos;

    pos=strchr(moduleline,'#');
    if(pos)
    {
        // strip comment and preceding tabs/spaces
        *pos=' ';
        while(pos>=moduleline && *pos==' ' || *pos=='\t')
        {
            *pos='\0';
            pos--;
        }
    }
}
///

/// Process functions
static int processModules(void)
{
    struct Node *node;
    char *moduleName;
    char moduleSources[BUFSIZ];
    char buf[BUFSIZ];

    moduleSources[0]='\0';
    node=moduleList;
    while(node)
    {
        char *ptr;
        moduleSources[0]='\0';
        ptr = strtok(node->string," \t");
        if(ptr)
        {
            moduleName=ptr;
            ptr=strtok(NULL," \t");
            while(ptr)
            {
                int i;
                i=strlen(ptr);
                // if it is a .c file, add it to the sources string
                // otherwise, break the loop
                if(i>2 && (ptr[i-2]=='.' && (ptr[i-1]=='c' || ptr[i-1]=='C')))
                {
                    strcat(moduleSources," ");
                    strcat(moduleSources,ptr);
                    ptr=strtok(NULL," \t");
                }
                else break;
            }

            // generate prototype
            sprintf(buf,"void init%s(void);\n",moduleName);
            addStrToList(&protoList, &protoTail, buf);
            // generate configentry
            sprintf(buf,"\t{ \"%s\", init%s },\n", moduleName, moduleName);
            addStrToList(&configentryList, &configentryTail, buf);
        }

        node=node->next;
    }

    // Read config and add lines

    // open CONFIGFILENAME_IN as source
    // open CONFIGFILENAME_OUT as destination
    // copy lines until MARKER 1
    // write all protos:
/*
    node=protoList;
    while(node)
    {
        fprintf(outfile,node->string);
        node=node->next;
    }
*/
    // copy lines until MARKER 2
    // write all configentries:
/*
    node=configentryList;
    while(node)
    {
        fprintf(outfile,node->string);
        node=node->next;
    }
*/
    // copy remaining lines

    return 1;
}

static int processDefines(void)
{
    struct Node *node;

    node=defineList;
    while(node)
    {
        printf("%3d:DEFINE: %s\n",node->line,node->string);
        node=node->next;
    }

    return 1;
}
///

/// Main
int main(int argc, char **argv)
{
    FILE *fh;
    int RC=10;
    char readbuf[BUFSIZ];

    argc--; argv++;
    if(argc>0)
    {
        setup_filename = *argv;
        argc--; argv++;
    }
    if(argc>0)
    {
        configin_filename = *argv;
        argc--; argv++;
    }
    if(argc>0)
    {
        configout_filename = *argv;
        argc--; argv++;
    }

    printf("Files: Setup=%s, Config in=%s, Config out=%s\n",
        setup_filename,configin_filename,configout_filename);

    if(fh=fopen(setup_filename,"r"))
    {
        int skip=0;

        lineNumber=1;

        while(fgets(readbuf,BUFSIZ,fh)!=NULL)
        {
            stripNL(readbuf);
            switch (classifyLine(readbuf))
            {
            case L_SKIP:
                // skip this line
                break;
            case L_MODULE:
                if(!skip)
                {
                    stripComment(readbuf);
                    addStrToList(&moduleList, &moduleTail, readbuf);
                }
                break;
            case L_DEFINE:
                if(!skip)
                {
                    addStrToList(&defineList, &defineTail, readbuf);
                }
                break;
            case L_OPTION:
                if(strcmp(readbuf,"*static*")==NULL) skip=0;
                if(strcmp(readbuf,"*doconfig*")==NULL) skip=0;
                if(strcmp(readbuf,"*shared*")==NULL) skip=1;
                if(strcmp(readbuf,"*noconfig*")==NULL) skip=1;
                break;
            }

            lineNumber++;
        }

        fclose(fh);

        if(processDefines() && processModules())
            RC=0;
    }
    else
    {
        printf("Cannot read `%s'\n",setup_filename);
    }

    return RC;
}
///