AmigActive 15/AACD15.ISO/AACD/System/MorphOS/Developer/emultools/fd2inline/.#fd2inline.c.1.2

Text File | 2000-11-02 | 69.4 KB | 3,215 lines

/******************************************************************************
 *
 * fd2inline
 *
 * Should be able to parse CBM fd files and generate vanilla inline calls
 * for gcc. Works as a filter.
 *
 * by Wolfgang Baron, all rights reserved.
 *
 * improved, updated, simply made workable by Rainer F. Trunz 1/95
 *
 * Completely reworked Version, cleaned up and removed a whole lot of bugs
 * found by Kamil Iskra.
 *
 * Expect miracles now (hopefully...). Ok, I am just kidding :)
 *
 * Version 0.99a by Rainer F. Trunz 6/95
 *
 * Version 0.99b and later by Kamil Iskra.
 *
 * Version 1.12 by Ralph Schmidt
 *              PowerUP GCC/SAS extensions
 *              I hope Kamil Iskra integrates that
 *              in the official ADE version.
 *
 ******************************************************************************/

/*
 * My whole ixemul includes are messed up * so this is hacky fix
 */

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

/******************************************************************************
 * The program has a few sort of class definitions, which are the result of
 * object oriented thinking, to be imlemented in plain C. I just haven't
 * had the time to learn C++ or install the compiler. The design does however
 * improve robustness, which allows the source to be used over and over again.
 * if you use this code, please leave a little origin note.
 ******************************************************************************/

const static char version_str[] = "$VER: fd2inline " VERSION " (12.12.97)";

/******************************************************************************
 * These are general definitions including types for defining registers etc.
 ******************************************************************************/

#ifdef DEBUG
#define DBP(a) a
#else  /*
        * !DEBUG
        */
#define DBP(a)
#endif /*
        * !DEBUG
        */

#if (defined(__GNUC__) || defined(__SASC)) && 0
#define INLINE __inline                   /*
                                        * Gives 20% *larger* executable with GCC?!
                                        */
#else
#define INLINE
#endif

#define REGS 16                           /*
                                        * d0=0,...,a7=15
                                        */
#define FDS 1000

typedef enum
{
    d0, d1, d2, d3, d4, d5, d6, d7, a0, a1, a2, a3, a4, a5, a6, a7, illegal
}
regs;

typedef unsigned char uchar, shortcard;
typedef unsigned long ulong;

#ifndef  FALSE
#define  FALSE 0
#endif
#ifndef  TRUE
#define  TRUE  1
#endif

typedef enum
{
    false, nodef, real_error
}
Error;

enum
{
    NEW, OLD, STUBS, PROTO, PRAGMA, GATESTUBS
}
output_mode = NEW;

int PowerUP = 0, MorphOS = 0;
int PreLibFlag = 0;
int PostLibFlag = 0;
int LocalFlag = 0;
char *prefixname = "";
char *subprefixname = "";
char *premacro = "";

char BaseName[32 + 32], BaseNamU[32 + 32], BaseNamL[32 + 32];
char    Buffer[512];

const static char *LibExcTable[] =
{
    "BattClockBase", "Node",
    "BattMemBase", "Node",
    "ConsoleDevice", "Device",
    "DiskBase", "DiskResource",
    "DOSBase", "DosLibrary",
    "SysBase", "ExecBase",
    "ExpansionBase", "ExpansionBase",
    "GfxBase", "GfxBase",
    "InputBase", "Device",
    "IntuitionBase", "IntuitionBase",
    "LocaleBase", "LocaleBase",
    "MathIeeeDoubBasBase", "MathIEEEBase",
    "MathIeeeDoubTransBase", "MathIEEEBase",
    "MathIeeeSingBasBase", "MathIEEEBase",
    "MathIeeeSingTransBase", "MathIEEEBase",
    "MiscBase", "Node",
    "PotgoBase", "Node",
    "RamdriveDevice", "Device",
    "RealTimeBase", "RealTimeBase",
    "RexxSysBase", "RxsLib",
    "TimerBase", "Device",
    "UtilityBase", "UtilityBase"
};
const char *StdLib;

/*******************************************
 * just some support functions, no checking
 *******************************************/

char *
NewString(char **new, const char *old)
{
    const char *high;
    ulong len;

    while (*old && (*old == ' ' || *old == '\t'))
        old++;
    len = strlen(old);
    for (high = old + len - 1; high >= old && (*high == ' ' || *high == '\t'); high--) ;
    high++;
    len = high - old;
    *new = malloc(1 + len);
    if (*new)
    {
        strncpy(*new, old, len);
        (*new)[len] = '\0';
    }
    else
        fprintf(stderr, "no mem for string\n");
    return *new;
}

static INLINE void
illparams(const char *funcname)
{
    fprintf(stderr, "%s: illegal Parameters\n", funcname);
}

static INLINE const char *
RegStr(regs reg)
{
    const static char *myregs[] =
    {
        "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
        "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7", "illegal"
    };

    if (reg > illegal)
        reg = illegal;
    if (reg < d0)
        reg = d0;
    return myregs[reg];
}

static INLINE const char *
RegStrU(regs reg)
{
    const static char *myregs[] =
    {
        "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
        "A0", "A1", "A2", "A3", "A4", "A5", "A6", "A7", "illegal"
    };

    if (reg > illegal)
        reg = illegal;
    if (reg < d0)
        reg = d0;
    return myregs[reg];
}

/******************************************************************************
 *    StrNRBrk
 *
 * searches string in from position at downwards, as long as in does not
 * contain any character in not.
 *
 ******************************************************************************/

const char *
StrNRBrk(const char *in, const char *not, const char *at)
{
    const char *chcheck;
    Error ready;

    chcheck = "";                       /*
                                        * if at<in, the result will be NULL
                                        */
    for (ready = false; ready == false && at >= in;)
    {
        for (chcheck = not; *chcheck && *chcheck != *at; chcheck++) ;
        if (*chcheck)
            ready = real_error;
        else
            at--;
    }
    DBP(printf("{%c}", *chcheck));
    return *chcheck ? at : NULL;
}

/*
 * Our own "strupr", since it is a non-standard function.
 */
void
StrUpr(char *str)
{
    while (*str)
    {
        *str = toupper(*str);
        str++;
    }
}

/******************************************************************************
 *    CLASS fdFile
 *
 * stores a file with a temporary buffer (static length, sorry), a line number,
 * an offset (used for library offsets and an error field.
 * When there's no error, line will contain line #lineno and offset will be
 * the last offset set by the interpretation of the last line. If there's been
 * no ##bias line, this field assumes a bias of 30, which is the standard bias.
 * It is assumed offsets are always negative.
 ******************************************************************************/

#define fF_BUFSIZE 1024

/*
 * all you need to know about an fdFile you parse
 */

typedef struct
{
    FILE *file;                           /*
                                        * the file we're reading from
                                        */
    char line[fF_BUFSIZE];               /*
                                        * the current line
                                        */
    ulong lineno;                       /*
                                        * current line number
                                        */
    long offset;                       /*
                                        * current fd offset (-bias)
                                        */
    Error error;                       /*
                                        * is everything o.k.
                                        */
    char private;                       /*
                                        * are we in ##public or ##private
                                        */
}
fdFile;

fdFile *
 fF_ctor(const char *fname);
static void
 fF_dtor(fdFile * obj);
static void
 fF_SetError(fdFile * obj, Error error);
static void
 fF_SetOffset(fdFile * obj, long at);

Error
fF_readln(fdFile * obj);
static Error
 fF_GetError(const fdFile * obj);
static long
 fF_GetOffset(const fdFile * obj);
char *
 fF_FuncName(fdFile * obj);               /*

                                        * return name or null
                                        */
static void
 fF_SetPrivate(fdFile * obj, char priv);
static char
 fF_GetPrivate(const fdFile * obj);

static INLINE void
fF_dtor(fdFile * obj)
{
    fclose(obj->file);
    free(obj);
}

static INLINE void
fF_SetError(fdFile * obj, Error error)
{
    if (obj)
        obj->error = error;
    else
        illparams("fF_SetError");
}

static INLINE void
fF_SetOffset(fdFile * obj, long at)
{
    if (obj)
        obj->offset = at;
    else
        illparams("fFSetOffset");
}

static INLINE void
fF_SetPrivate(fdFile * obj, char priv)
{
    if (obj)
        obj->private = priv;
    else
        illparams("fF_SetPrivate");
}

fdFile *
fF_ctor(const char *fname)
{
    fdFile *result;

    if (fname)
    {
        result = malloc(sizeof(fdFile));
        if (result)
        {
            result->file = fopen(fname, "r");
            if (result->file)
            {
                result->lineno = 0;
                fF_SetOffset(result, -30);
                fF_SetError(result, false);
                fF_SetPrivate(result, 0);
                result->line[0] = '\0';
            }
            else
            {
                free(result);
                result = NULL;
            }
        }
    }
    else
    {
        result = NULL;
        illparams("fF_ctor");
    }
    return result;
}

Error
fF_readln(fdFile * obj)
{
    char *low, *bpoint;
    long glen,                           /*
                                        * the length we read until now
                                        */
     len;                               /*

                                        * the length of the last segment
                                        */

    if (obj)
    {
        low = obj->line;
        glen = 0;

        for (;;)
        {
            obj->lineno++;
            if (!fgets(low, fF_BUFSIZE - 1 - glen, obj->file))
            {
                fF_SetError(obj, real_error);
                obj->line[0] = '\0';
                return real_error;
            }
            if (low == strpbrk(low, "*#/"))
            {
                DBP(printf("in# %s\n", obj->line));
                return false;
            }
            len = strlen(low);
            bpoint = low + len - 1;
            while (len && isspace(*bpoint))
            {
                bpoint--;
                len--;
            }
            if (*bpoint == ';' || *bpoint == ')')
            {
                DBP(printf("\nin: %s\n", obj->line));
                return false;
            }
            glen += len;
            low += len;
            if (glen >= fF_BUFSIZE - 10)    /*
                                             * somewhat pessimistic?
                                             */
            {
                fF_SetError(obj, real_error);
                fprintf(stderr, "line %lu too long.\n", obj->lineno);
                return real_error;
            }
            DBP(printf("+"));
        }
    }
    illparams("fF_readln");
    return real_error;
}

static INLINE Error
fF_GetError(const fdFile * obj)
{
    if (obj)
        return obj->error;
    illparams("fF_GetError");
    return real_error;
}

static INLINE long
fF_GetOffset(const fdFile * obj)
{
    if (obj)
        return obj->offset;
    illparams("fF_GetOffset");
    return -1;
}

/******************************************************************************
 * fF_FuncName
 *
 * checks if it can find a function-name and return it's address, or NULL
 * if the current line does not seem to contain one. The return value will
 * be a pointer into a malloced buffer, thus the caller will have to free().
 ******************************************************************************/

char *
fF_FuncName(fdFile * obj)
{
    const char *lower;
    const char *upper;
    char *buf;
    long obraces;                       /*

                                        * count of open braces
                                        */
    Error ready;                       /*

                                        * ready with searching
                                        */

    if (!obj || fF_GetError(obj) == real_error)
    {
        illparams("fF_FuncName");
        return NULL;
    }

    lower = obj->line;
    while (*lower && (*lower == ' ' || *lower == '\t'))
        lower++;

    if (!*lower || (!isalpha(*lower) && *lower != '_'))
    {
        fF_SetError(obj, nodef);
        return NULL;
    }

    while (*lower)
    {
        if (!isalnum(*lower) && !isspace(*lower) && *lower != '*' && *lower != ','
            && *lower != '.' && *lower != ';' && *lower != '(' && *lower != ')' &&
            *lower != '[' && *lower != ']' && *lower != '_' && *lower != '\\')
        {
            fF_SetError(obj, nodef);
            return NULL;
        }
        lower++;
    }

    lower = NULL;
    buf = NULL;

    if (obj && fF_GetError(obj) == false)
    {
        if ((upper = strrchr(obj->line, ')')) != 0)
        {
            DBP(printf("end:%s:", upper));

            for (obraces = 1, ready = false; ready == false; upper = lower)
            {
                lower = StrNRBrk(obj->line, "()", --upper);
                if (lower)
                {
                    switch (*lower)
                     {
                     case ')':
                         obraces++;
                         DBP(printf(" )%ld%s", obraces, lower));
                         break;
                     case '(':
                         obraces--;
                         DBP(printf(" (%ld%s", obraces, lower));
                         if (!obraces)
                             ready = nodef;
                         break;
                     default:
                         fprintf(stderr, "faulty StrNRBrk\n");
                     }
                }
                else
                {
                    fprintf(stderr, "'(' or ')' expected in line %lu.\n",
                            obj->lineno);
                    ready = real_error;
                }
            }
            if (ready == nodef)           /*
                                        * we found the matching '('
                                        */
            {
                long newlen;
                const char *name;

                upper--;

                while (upper >= obj->line && (*upper == ' ' || *upper == '\t'))
                    upper--;

                lower = StrNRBrk(obj->line, " \t*)", upper);

                if (!lower)
                    lower = obj->line;
                else
                    lower++;

                for (name = lower; name <= upper; name++)
                    if (!isalnum(*name) && *name != '_')
                    {
                        fF_SetError(obj, nodef);
                        return NULL;
                    }

                newlen = upper - lower + 1;
                buf = malloc(newlen + 1);

                if (buf)
                {
                    strncpy(buf, lower, newlen);
                    buf[newlen] = '\0';
                }
                else
                    fprintf(stderr, "no mem for fF_FuncName");
            }
        }
    }
    else
        illparams("fF_FuncName");
    return buf;
}

static INLINE char
fF_GetPrivate(const fdFile * obj)
{
    if (obj)
        return obj->private;
    illparams("fF_GetPrivate");
    return 0;
}

/*********************
 *    CLASS fdDef    *
 *********************/

typedef struct
{
    char *name;
    char *type;
    long offset;
    regs reg[REGS];
    char *param[REGS];
    char *proto[REGS];
    regs funcpar;                       /*
                                        * number of argument that has type "pointer to function"
                                        */
}
fdDef;

fdDef *
 fD_ctor(void);
void
 fD_dtor(fdDef * obj);
static void
 fD_NewName(fdDef * obj, const char *newname);
void
 fD_NewParam(fdDef * obj, shortcard at, const char *newstr);
void
 fD_NewProto(fdDef * obj, shortcard at, char *newstr);
static void
 fD_NewReg(fdDef * obj, shortcard at, regs reg);
static void
 fD_NewType(fdDef * obj, const char *newstr);
static void
 fD_SetOffset(fdDef * obj, long off);

Error
fD_parsefd(fdDef * obj, fdFile * infile);
Error
fD_parsepr(fdDef * obj, fdFile * infile);
static const char *
 fD_GetName(const fdDef * obj);
static long
 fD_GetOffset(const fdDef * obj);
static const char *
 fD_GetParam(const fdDef * obj, shortcard at);
static regs
 fD_GetReg(const fdDef * obj, shortcard at);
static const char *
 fD_GetRegStr(const fdDef * obj, shortcard at);
static const char *
 fD_GetType(const fdDef * obj);
static shortcard
 fD_ParamNum(const fdDef * obj);
static shortcard
 fD_ProtoNum(const fdDef * obj);
static shortcard
 fD_RegNum(const fdDef * obj);
int
 fD_cmpName(const void *big, const void *small);
void
 fD_write(FILE * outfile, const fdDef * obj);
static shortcard
 fD_GetFuncParNum(const fdDef * obj);
static void
 fD_SetFuncParNum(fdDef * obj, shortcard at);
static void
 fD_adjustargnames(fdDef * obj);

fdDef **arrdefs;
long fds;

char *fD_nostring = "";

fdDef *
fD_ctor(void)
{
    fdDef *result;
    regs count;

    result = malloc(sizeof(fdDef));

    if (result)
    {
        result->name = fD_nostring;
        result->type = fD_nostring;
        result->funcpar = illegal;

        for (count = d0; count < illegal; count++)
        {
            result->reg[count] = illegal;
            result->param[count] = fD_nostring;        /*
                                                     * if (!strlen) dont't free()
                                                     */
            result->proto[count] = fD_nostring;
        }
    }
    return result;
}

/*
 * free all resources and make the object as illegal as possible
 */

void
fD_dtor(fdDef * obj)
{
    regs count;

    if (obj)
    {
        if (!obj->name)
            fprintf(stderr, "fD_dtor: null name");
        else if (obj->name != fD_nostring)
            free(obj->name);

        if (!obj->type)
            fprintf(stderr, "fD_dtor: null type");
        else if (obj->type != fD_nostring)
            free(obj->type);

        obj->name = obj->type = NULL;

        for (count = d0; count < illegal; count++)
        {
            obj->reg[count] = illegal;

            if (!obj->param[count])
                fprintf(stderr, "fD_dtor: null param");
            else if (obj->param[count] != fD_nostring)
                free(obj->param[count]);

            if (!obj->proto[count])
                fprintf(stderr, "fD_dtor: null proto");
            else if (obj->proto[count] != fD_nostring)
                free(obj->proto[count]);

            obj->param[count] = obj->proto[count] = NULL;
        }

        free(obj);
    }
    else
        fprintf(stderr, "fd_dtor(NULL)\n");
}

static INLINE void
fD_NewName(fdDef * obj, const char *newname)
{
    if (obj && newname)
    {
        if (obj->name && obj->name != fD_nostring)
            free(obj->name);
        if (!NewString(&obj->name, newname))
            obj->name = fD_nostring;
    }
    else
        illparams("fD_NewName");
}

void
fD_NewParam(fdDef * obj, shortcard at, const char *newstr)
{
    char *pa;

    if (newstr && obj && at < illegal)
    {
        pa = obj->param[at];

        if (pa && pa != fD_nostring)
            free(pa);

        while (*newstr == ' ' || *newstr == '\t')
            newstr++;

        if (NewString(&pa, newstr))
            obj->param[at] = pa;
        else
            obj->param[at] = fD_nostring;
    }
    else
        illparams("fD_NewParam");
}

/*
 * get first free *reg or illegal
 */

static INLINE shortcard
fD_RegNum(const fdDef * obj)
{
    shortcard count;

    if (obj)
    {
        for (count = d0; count < illegal && obj->reg[count] != illegal; count++) ;
        DBP(printf("< )0> RegNum=%ld\n",count));
        return count;
    }
    else
    {
        illparams("fD_RegNum");
        DBP(printf( "< )0> RegNum illegal\n"));
        return illegal;
    }
}

static INLINE void
fD_NewReg(fdDef * obj, shortcard at, regs reg)
{
    if (obj && at < illegal && reg >= d0 && reg <= illegal)
        obj->reg[at] = reg;
    else
        illparams("fD_NewReg");
}

static INLINE regs
fD_GetReg(const fdDef * obj, shortcard at)
{
    if (obj && at < illegal)
        return obj->reg[at];
    else
    {
        illparams("fD_GetReg");
        return illegal;
    }
}

static INLINE shortcard
fD_GetFuncParNum(const fdDef * obj)
{
    if (obj)
        return (shortcard) obj->funcpar;
    else
    {
        illparams("fD_GetFuncParNum");
        return illegal;
    }
}

static INLINE void
fD_SetFuncParNum(fdDef * obj, shortcard at)
{
    if (obj && at < illegal)
        obj->funcpar = at;
    else
        illparams("fD_SetFuncParNum");
}

void
fD_NewProto(fdDef * obj, shortcard at, char *newstr)
{
    char *pr;

    if (newstr && obj && at < illegal)
    {
        char *t, arr[200];               /*

                                        * I hope 200 will be enough...
                                        */
        int numwords = 1;

        pr = obj->proto[at];

        if (pr && pr != fD_nostring)
            free(pr);

        while (*newstr == ' ' || *newstr == '\t')
            newstr++;                   /*
                                        * Skip leading spaces
                                        */

        t = arr;
        while ((*t++ = *newstr) != 0)
        {
          /*
           * Copy the rest, counting number of words
           */
            if ((*newstr == ' ' || *newstr == '\t') && newstr[1] && newstr[1] != ' ' &&
                newstr[1] != '\t')
                numwords++;
            newstr++;
        }

        t = arr + strlen(arr) - 1;
        while (*t == ' ' || *t == '\t')
            t--;
        t[1] = '\0';                   /*
                                        * Get rid of tailing spaces
                                        */
        if (at != fD_GetFuncParNum(obj))
        {
            if (numwords > 1)           /*
                                        * One word - must be type
                                        */
                if (*t != '*')
                {
                  /*
                   * '*' on the end - no parameter name used
                   */
                    while (*t != ' ' && *t != '\t' && *t != '*')
                        t--;
                    t++;
                    if (strcmp(t, "char") && strcmp(t, "short") && strcmp(t, "int")
                        && strcmp(t, "long"))
                    {
                      /*
                       * Not one of applicable keywords - must be parameter name.
                       * Get rid of it.
                       */
                        t--;
                        while (*t == ' ' || *t == '\t')
                            t--;
                        t[1] = '\0';
                    }
                }
        }
        else
        {
          /*
           * Parameter of type "pointer to function".
           */
            char *end;

            t = strchr(arr, '(');
            while (*t++ != '*') ;
            end = strchr(t, ')');
            memmove(t + 2, end, strlen(end) + 1);
            *t = '%';
            t[1] = 's';
        }

        if (NewString(&pr, arr))
        {
            obj->proto[at] = pr;
            while (*pr == ' ' || *pr == '\t')
                pr++;
            if (!stricmp(pr, "double"))
            {
              /*
               * "double" needs two data registers
               */
                int count, regs = fD_RegNum(obj);

                for (count = at + 1; count < regs; count++)
                    fD_NewReg(obj, count, fD_GetReg(obj, count + 1));
            }
        }
        else
            obj->proto[at] = fD_nostring;
    }
    else
        illparams("fD_NewProto");
}

static INLINE void
fD_NewType(fdDef * obj, const char *newtype)
{
    if (obj && newtype)
    {
        if (obj->type && obj->type != fD_nostring)
            free(obj->type);
        if (!NewString(&obj->type, newtype))
            obj->type = fD_nostring;
    }
    else
        illparams("fD_NewType");
}

static INLINE void
fD_SetOffset(fdDef * obj, long off)
{
    if (obj)
        obj->offset = off;
    else
        illparams("fD_SetOffset");
}

static INLINE const char *
fD_GetName(const fdDef * obj)
{
    if (obj && obj->name)
        return obj->name;
    else
    {
        illparams("fD_GetName");
        return fD_nostring;
    }
}

static INLINE long
fD_GetOffset(const fdDef * obj)
{
    if (obj)
        return obj->offset;
    else
    {
        illparams("fD_GetOffset");
        return 0;
    }
}

static INLINE const char *
fD_GetProto(const fdDef * obj, shortcard at)
{
    if (obj && at < illegal && obj->proto[at])
        return obj->proto[at];
    else
    {
        illparams("fD_GetProto");
        return fD_nostring;
    }
}

static INLINE const char *
fD_GetParam(const fdDef * obj, shortcard at)
{
    if (obj && at < illegal && obj->param[at])
        return obj->param[at];
    else
    {
        illparams("fD_GetParam");
        return fD_nostring;
    }
}

static INLINE const char *
fD_GetRegStr(const fdDef * obj, shortcard at)
{
    if (obj && at < illegal)
        return RegStr(obj->reg[at]);
    else
    {
        illparams("fD_GetReg");
        return RegStr(illegal);
    }
}

static INLINE const char *
fD_GetRegStrU(const fdDef * obj, shortcard at)
{
    if (obj && at < illegal)
        return RegStrU(obj->reg[at]);
    else
    {
        illparams("fD_GetReg");
        return RegStrU(illegal);
    }
}

static INLINE const char *
fD_GetType(const fdDef * obj)
{
    if (obj && obj->type)
        return obj->type;
    else
    {
        illparams("fD_GetType");
        return fD_nostring;
    }
}

/*
 * get first free param or illegal
 */

static INLINE shortcard
fD_ParamNum(const fdDef * obj)
{
    shortcard count;

    if (obj)
    {
        for (count = d0; count < illegal && obj->param[count] != fD_nostring;
             count++) ;
        return count;
    }
    else
    {
        illparams("fD_ParamNum");
        return illegal;
    }
}

static INLINE shortcard
fD_ProtoNum(const fdDef * obj)
{
    shortcard count;

    if (obj)
    {
        for (count = d0; count < illegal && obj->proto[count] != fD_nostring;
             count++) ;
        return count;
    }
    else
    {
        illparams("fD_ProtoNum");
        return illegal;
    }
}

/******************************************************************************
 *    fD_parsefd
 *
 *  parse the current line. Needs to copy input, in order to insert \0's
 *  RETURN
 *    fF_GetError(infile):
 * false = read a definition.
 * nodef = not a definition on line (so try again)
 * error = real error
 ******************************************************************************/

Error
fD_parsefd(fdDef * obj, fdFile * infile)
{
    enum parse_info
    {
        name, params, regs, ready
    }
    parsing;
    char *buf, *bpoint, *bnext;
    ulong index;

    if (obj && infile && fF_GetError(infile) == false)
    {
        parsing = name;

        if (!NewString(&buf, infile->line))
        {
            fprintf(stderr, "no mem for line %lu\n", infile->lineno);
            fF_SetError(infile, real_error);
        }
        bpoint = buf;                   /*
                                        * so -Wall keeps quiet
                                        */

      /*
       * try to parse the line until there's an error or we are done
       */

        while (parsing != ready && fF_GetError(infile) == false)
        {
            switch (parsing)
             {
             case name:
                 switch (buf[0])
                  {
                  case '#':
                      if (strncmp("##base", buf, 6) == 0)
                      {
                          bnext = buf + 6;
                          while (*bnext == ' ' || *bnext == '\t' || *bnext == '_')
                              bnext++;
                          strcpy(BaseName, bnext);
                          BaseName[strlen(BaseName) - 1] = '\0';
                      }
                      else if (strncmp("##bias", buf, 6) == 0)
                      {
                          if (!sscanf(buf + 6, "%ld", &infile->offset))
                          {
                              fprintf(stderr, "illegal ##bias in line %lu: %s\n",
                                      infile->lineno, infile->line);
                              fF_SetError(infile, real_error);
                              break;   /*
                                        * avoid nodef
                                        */
                          }
                          else
                          {
                              if (fF_GetOffset(infile) > 0)
                                  fF_SetOffset(infile, -fF_GetOffset(infile));
                              DBP(printf( "set offset to %ld\n",
                                          fF_GetOffset(infile)));
                          }
                      }
                      else
                      {
                          if (strncmp("##private", buf, 9) == 0)
                              fF_SetPrivate(infile, 1);
                          else if (strncmp("##public", buf, 8) == 0)
                              fF_SetPrivate(infile, 0);
                      }
                    /*
                     * drop through for error comment
                     */

                  case '*':
                    /*
                     * try again somewhere else
                     */
                      fF_SetError(infile, nodef);
                      break;

                  default:
                    /*
                     * assume a regular line here
                     */
                      if (fF_GetPrivate(infile))
                      {
                        /*
                         * don't store names of privates
                         */
                          fF_SetError(infile, nodef);
                          fF_SetOffset(infile, fF_GetOffset(infile) - 6);
                          break;
                      }
                      parsing = name;  /*
                                        * switch (parsing)
                                        */
                      for (index = 0; buf[index] && buf[index] != '('; index++) ;

                      if (!buf[index])
                      {
                        /*
                         * oops, no fd ?
                         */
                          fprintf(stderr, "not an fd, line %lu: %s\n",
                                  infile->lineno, buf    /*
                                                         * infile->line
                                                         */ );
                          fF_SetError(infile, nodef);
                      }                   /*
                                        * maybe next time
                                        */
                      else
                      {
                          buf[index] = 0;

                          fD_NewName(obj, buf);
                          fD_SetOffset(obj, fF_GetOffset(infile));

                          bpoint = buf + index + 1;
                          parsing = params;        /*
                                                 * continue the loop
                                                 */
                      }
                  }
                 break;

             case params:
                 {
                     char *bptmp;       /*

                                        * needed for fD_NewParam
                                        */

                   /*
                    * look for parameters now
                    */

                     for (bnext = bpoint; *bnext && *bnext != ',' && *bnext != ')';
                          bnext++) ;

                     if (*bnext)
                     {
                         bptmp = bpoint;

                         if (*bnext == ')')
                         {
                             if (bnext[1] != '(')
                             {
                                 fprintf(stderr, "registers expected in line %lu: %s\n",
                                         infile->lineno, infile->line);
                                 fF_SetError(infile, nodef);
                             }
                             else
                             {
                                 parsing = regs;
                                 bpoint = bnext + 2;
                             }
                         }
                         else
                             bpoint = bnext + 1;

                       /*
                        * terminate string and advance to next item
                        */

                         *bnext = '\0';
                         fD_NewParam(obj, fD_ParamNum(obj), bptmp);
                     }
                     else
                     {
                         fF_SetError(infile, nodef);
                         fprintf(stderr, "param expected in line %lu: %s\n",
                                 infile->lineno, infile->line);
                     }
                     break;               /*
                                        * switch parsing
                                        */
                 }

             case regs:
               /*
                * look for parameters now
                */

                 for (bnext = bpoint; *bnext && *bnext != '/' && *bnext != ',' &&
                      *bnext != ')'; bnext++) ;

                 if (*bnext)
                 {
                     if (')' == *bnext)
                     {
                       /*
                        * wow, we've finished
                        */
                         fF_SetOffset(infile, fF_GetOffset(infile) - 6);
                         parsing = ready;
                     }
                     *bnext = '\0';

                     bpoint[0] = tolower(bpoint[0]);

                     if ((bpoint[0] == 'd' || bpoint[0] == 'a') && bpoint[1] >= '0' &&
                         bpoint[1] <= '8' && bnext == bpoint + 2)
                         fD_NewReg(obj, fD_RegNum(obj),
                                   bpoint[1] - '0' + (bpoint[0] == 'a' ? 8 : 0));
                     else if (bnext != bpoint)
                     {
                       /*
                        * it is when our function is void
                        */
                         fprintf(stderr, "illegal register %s in line %ld\n",
                                 bpoint, infile->lineno);
                         fF_SetError(infile, nodef);
                     }
                     bpoint = bnext + 1;
                 }
                 else
                 {
                     fF_SetError(infile, nodef);
                     fprintf(stderr, "reg expected in line %lu\n",
                             infile->lineno);
                 }
                 break;                   /*
                                        * switch parsing
                                        */

             case ready:
                 fprintf(stderr, "internal error, use another compiler.\n");
                 break;
             }
        }

        free(buf);
        return fF_GetError(infile);
    }
    else
    {
        illparams("fD_parsefd");
        return real_error;
    }
}

static void
fD_adjustargnames(fdDef * obj)
{
    int parnum;

    if (output_mode == NEW)
    {

      /*
       * For #define-base output mode, we have to check if argument names are not
       * the same as some words in type names. We check from the first argument
       * to the last, resolving conflicts by changing argument names, if
       * necessary.
       */

        for (parnum = 0; parnum < fD_ParamNum(obj); parnum++)
        {
            const char *parname = fD_GetParam(obj, parnum);
            int finished;

            DBP(printf( "ParNum %ld ParName %s\n",parnum,parname));
            do
            {
                int num;
                const char *type = fD_GetType(obj);
                char *str;

                finished = 1;

                DBP(printf( "DoLoop\n"));
                if ((str = strstr(type, parname)) != 0 &&
                     (str == type || (!isalnum(str[-1]) && str[-1] != '_')) &&
                    (!*(str += strlen(parname)) || (!isalnum(*str) && *str != '_')))
                {
                    char buf[300];       /*
                                * Hope will be enough...
                                */

                    DBP(printf( "str1 %s\n",str));
                    strcpy(buf, parname);
                    strcat(buf, "_");
                    DBP(printf( "NewParam1 ParNum %ld Buf %s\n",parnum,buf));
                    fD_NewParam(obj, parnum, buf);
                    finished = 0;
                }
                else
                {
                    DBP(printf( "str2 %s\n",str));
                    for (num = 0; num < fD_ParamNum(obj); num++)
                    {
                        const char *name = fD_GetParam(obj, num);
                        const char *proto = fD_GetProto(obj, num);

                        DBP(printf( "num %ld name %s proto %s\n",num,name,proto));

                        if ((num < parnum && strcmp(name, parname) == 0) ||
                            ((str = strstr(proto, parname)) != 0 &&
                             (str == proto ||  (!isalnum(str[-1]) && str[-1] != '_')) &&
                             (!*(str += strlen(parname)) || (!isalnum(*str) && *str != '_'))))
                        {
                            char buf[300];    /*
                                     * Hope will be enough...
                                     */
                            strcpy(buf, parname);
                            strcat(buf, "_");
                            DBP(printf( "NewParam2 ParNum %ld Buf %s\n",parnum,buf));
                            fD_NewParam(obj, parnum, buf);
                            //finished = 0;
                            break;
                        }
                    }
                }
            }
            while (!finished);
        }
    }
}

Error    fD_parsepr(fdDef * obj, fdFile * infile)
{
char *buf;                           /*

                                    * a copy of infile->line
                                    */
char *bpoint,                       /*
                                    * cursor in buf
                                    */
*bnext,                               /*
                                    * looking for the end
                                    */
*lowarg;                           /*

                                    * beginning of this argument
                                    */
long obraces;                       /*

                                    * count of open braces
                                    */
regs count,                           /*
                                    * count parameter number
                                    */
args;                               /*

                                    * the number of arguments for this function
                                    */

    if (!(obj && infile && fF_GetError(infile) == false))
    {
        illparams("fD_parsepr");
        fF_SetError(infile, real_error);
        return real_error;
    }
    if (!NewString(&buf, infile->line))
    {
        fprintf(stderr, "no mem for fD_parsepr\n");
        fF_SetError(infile, real_error);
        return real_error;
    }
    fF_SetError(infile, false);


    DBP(printf("buf %s\n",buf));
    bpoint = strchr(buf, '(');
    while (--bpoint >= buf && strstr(bpoint, fD_GetName(obj)) != bpoint) ;

    if (bpoint >= buf)
    {
        while (--bpoint >= buf && (*bpoint == ' ' || *bpoint == '\t')) ;
        *++bpoint = '\0';

        fD_NewType(obj, buf);

        while (bpoint && *bpoint++ != '(') ;    /*
                                                 * one beyond '('
                                                 */

        lowarg = bpoint;
        obraces = 0;

        for (count = 0, args = fD_RegNum(obj); count < args; bpoint = bnext + 1)
        {
            while (*bpoint && (*bpoint == ' ' || *bpoint == '\t'))
                bpoint++;

            DBP(printf("count %ld args %ld\n",count,args));
            DBP(printf("bpoint %s\n",bpoint));
            bnext = strpbrk(bpoint, "(),");
            DBP(printf("bnext %s\n",bnext));

            if (bnext)
            {
                switch (*bnext)
                {
                 case '(':
                     if (!obraces)
                     {
                        if ((PowerUP==0) && (MorphOS==0))
                        {
                            if (fD_GetFuncParNum(obj) != illegal &&
                                 fD_GetFuncParNum(obj) != count)
                                 fprintf(stderr, "Warning: two parameters of type "
                                         "pointer to function are used.\nThis is not "
                                         "supported!\n");
                        }
                        fD_SetFuncParNum(obj, count);
                     }
                     obraces++;
                     DBP(printf( "< (%ld%s >", obraces, bnext));
                     break;

                 case ')':
                     if (obraces)
                     {
                         DBP(printf( "< )%ld%s >", obraces, bnext));
                         obraces--;
                     }
                     else
                     {
                         *bnext = '\0';
                         DBP(printf( "< )0> [LAST PROTO=%s]", lowarg));
                         fD_NewProto(obj, count, lowarg);
                         lowarg = bnext + 1;

                         if (count != args - 1)
                         {
                             DBP(printf( "%s needs %u arguments and got %u.\n",
                                         fD_GetName(obj), args, count + 1));
                             fF_SetError(infile, nodef);
                         }
                         count++;
                     }
                     break;

                 case ',':
                     if (!obraces)
                     {
                         *bnext = '\0';
                         DBP(printf( " [PROTO=%s] ", lowarg));
                         fD_NewProto(obj, count, lowarg);
                         lowarg = bnext + 1;
                         count++;
                     }
                     break;

                 default:
                     fprintf(stderr, "faulty strpbrk in line %lu.\n",
                             infile->lineno);
                 }
            }
            else
            {
                DBP(printf( "faulty argument %u in line %lu.\n", count + 1,
                            infile->lineno));
                count = args;           /*
                                        * this will effectively quit the for loop
                                        */
                fF_SetError(infile, nodef);
            }
        }
        if (fD_ProtoNum(obj) != fD_RegNum(obj))
            fF_SetError(infile, nodef);
    }
    else
    {
        fprintf(stderr, "fD_parsepr was fooled in line %lu\n", infile->lineno);
        fprintf(stderr, "function , definition %s.\n",
      /*
       * fD_GetName(obj),
       */ infile->line);
        fF_SetError(infile, nodef);
    }

    free(buf);

    fD_adjustargnames(obj);

    return fF_GetError(infile);
}

int    fD_cmpName(const void *big, const void *small)
{
    return strcmp(fD_GetName(*(fdDef **) big), fD_GetName(*(fdDef **) small));
}

const static char *TagExcTable[] =
{
    "BuildEasyRequestArgs", "BuildEasyRequest",
    "DoDTMethodA", "DoDTMethod",
    "DoGadgetMethodA", "DoGadgetMethod",
    "EasyRequestArgs", "EasyRequest",
    "MUI_MakeObjectA", "MUI_MakeObject",
    "vsyslog", "syslog",
    "MUI_RequestA", "MUI_Request",
    "PrintDTObjectA", "PrintDTObject",
    "RefreshDTObjectA", "RefreshDTObjects",
    "UMSVLog", "UMSLog",
    "VFWritef", "FWritef",
    "VFPrintf", "FPrintf",
    "VPrintf", "Printf",
};

const char *taggedfunction(const fdDef * obj)
{
    shortcard numregs = fD_RegNum(obj);
    unsigned int count;
    const char *name = fD_GetName(obj);
    static char newname[200];

    const char *lastarg;
    const static char *TagExcTable2[] =
    {
        "ApplyTagChanges",
        "CloneTagItems",
        "FindTagItem",
        "FreeTagItems",
        "GetTagData",
        "PackBoolTags",
        "PackStructureTags",
        "RefreshTagItemClones",
        "UnpackStructureTags",
    };

    if (!numregs)
    {
        return NULL;
    }

    for (count = 0; count < sizeof TagExcTable / sizeof TagExcTable[0]; count += 2)
    {
        if (strcmp(name, TagExcTable[count]) == 0)
        {
            return TagExcTable[count + 1];
        }
    }

    for (count = 0; count < sizeof TagExcTable2 / sizeof TagExcTable2[0]; count++)
    {
        if (strcmp(name, TagExcTable2[count]) == 0)
        {
            return NULL;
        }
    }
    lastarg = fD_GetProto(obj, numregs - 1);

    if (strncmp(lastarg, "struct", 6))
    {
        return NULL;
    }
    lastarg += 6;

    while (*lastarg == ' ' || *lastarg == '\t')
    {
        lastarg++;
    }

    if (strncmp(lastarg, "TagItem", 7))
    {
        return NULL;
    }
    lastarg += 7;

    while (*lastarg == ' ' || *lastarg == '\t')
    {
        lastarg++;
    }

    if (strcmp(lastarg, "*"))
    {
        return NULL;
    }

    strcpy(newname, name);
    if (newname[strlen(newname) - 1] == 'A')
    {
        newname[strlen(newname) - 1] = '\0';
    }
    else if (strlen(newname) > 7 && !strcmp(newname + strlen(newname) - 7, "TagList"))
    {
        strcpy(newname + strlen(newname) - 4, "s");
    }
    else
    {
        strcat(newname, "Tags");
    }
    return newname;
}

const char *aliasfunction(const char *name)
{
    const static char *AliasTable[] =
    {
        "AllocDosObject", "AllocDosObjectTagList",
        "CreateNewProc", "CreateNewProcTagList",
        "NewLoadSeg", "NewLoadSegTagList",
        "System", "SystemTagList",
    };
    unsigned int count;

    for (count = 0; count < sizeof AliasTable / sizeof AliasTable[0]; count++)
        if (strcmp(name, AliasTable[count]) == 0)
            return AliasTable[count + (count % 2 ? -1 : 1)];
    return NULL;
}

void    fD_write(FILE * outfile, const fdDef * obj)
{
    shortcard count, numregs;
    const char *chtmp, *tagname, *name, *rettype;
    int vd = 0, a45 = 0, d7 = 0;

    DBP(printf( "func %s\n", fD_GetName(obj)));

    numregs = fD_RegNum(obj);

    if ((rettype = fD_GetType(obj)) == fD_nostring)
    {
        fprintf(stderr, "%s has no prototype.\n", fD_GetName(obj));
        return;
    }
    if (!stricmp(rettype, "void"))
    {
        vd = 1;
    }

    for (count = d0; count < numregs; count++)
    {
        const char *reg = fD_GetRegStr(obj, count);

        if (!((output_mode == NEW) && (PowerUP == TRUE)))
        {
            if (strcmp(reg, "a4") == 0 || strcmp(reg, "a5") == 0)
            {
                if (!a45)
                {
                    a45 = (strcmp(reg, "a4") ? 5 : 4);
                }
                else
                {
                    fprintf(stderr, "Warning: both a4 and a5 are used. This is not "
                            "supported!\n");
                }
            }
            if (strcmp(reg, "d7") == 0)
            {
                d7 = 1;
            }
        }
    }

    if (!((output_mode == NEW) && (PowerUP == TRUE)))
    {
        if (a45 && d7)
        {
            fprintf(stderr, "Warning: d7 and a4 or a5 are used. This is not "
                    "supported!\n");
        }
    }

    name = fD_GetName(obj);

    if (fD_ProtoNum(obj) != numregs)
    {
        fprintf(stderr, "%s gets %d fd args and %d proto%s.\n", name, numregs,
                fD_ProtoNum(obj), fD_ProtoNum(obj) != 1 ? "s" : "");
        return;
    }

    if ((output_mode == NEW) && (PowerUP == FALSE) && (MorphOS == FALSE))
    {
        fprintf(outfile, "#define %s(", name);

        if (numregs > 0)
        {
            for (count = d0; count < numregs - 1; count++)
                fprintf(outfile, "%s, ", fD_GetParam(obj, count));
            fprintf(outfile, "%s", fD_GetParam(obj, count));
        }

        fprintf(outfile, ") \\\n\tLP%d%s%s%s%s(0x%lx, ", numregs,
                (vd ? "NR" : ""), (a45 ? (a45 == 4 ? "A4" : "A5") : ""),
                (BaseName[0] ? "" : "UB"),
                (fD_GetFuncParNum(obj) == illegal ? "" : "FP"), -fD_GetOffset(obj));
        if (!vd)
            fprintf(outfile, "%s, ", rettype);
        fprintf(outfile, "%s, ", name);

        for (count = d0; count < numregs; count++)
        {
            chtmp = fD_GetRegStr(obj, count);
            if (a45 && (strcmp(chtmp, "a4") == 0 || strcmp(chtmp, "a5") == 0))
                chtmp = "d7";
            fprintf(outfile, "%s, %s, %s%s", (fD_GetFuncParNum(obj) == count ?
                                              "__fpt" : fD_GetProto(obj, count)), fD_GetParam(obj, count),
                    chtmp, (count == numregs - 1 && !BaseName[0] ? "" : ", "));
        }

        if (BaseName[0])               /*
                                        * was "##base" used?
                                        */
            fprintf(outfile, "\\\n\t, %s_BASE_NAME", BaseNamU);
        if (fD_GetFuncParNum(obj) != illegal)
        {
            fprintf(outfile, ", ");
            fprintf(outfile, fD_GetProto(obj, fD_GetFuncParNum(obj)), "__fpt");
        }
        fprintf(outfile, ")\n\n");
    }
    else if ((output_mode == NEW) && (PowerUP == TRUE || MorphOS == TRUE))
    {
        fprintf(outfile, "#define %s(", name);

        if (numregs > 0)
        {
            for (count = d0; count < numregs - 1; count++)
                fprintf(outfile, "%s, ", fD_GetParam(obj, count));
            fprintf(outfile, "%s", fD_GetParam(obj, count));
        }
/*
 * PPC doesn`t care anymore for A4,A5 registers problems the 68k engine has
 */

        fprintf(outfile, ") \\\n\tLP%d%s%s%s(0x%lx, ",
                numregs,
                (vd ? "NR" : ""),
                (BaseName[0] ? "" : "UB"),
                (fD_GetFuncParNum(obj) == illegal ? "" : "FP"), -fD_GetOffset(obj));
        if (!vd)
            fprintf(outfile, "%s, ", rettype);
        fprintf(outfile, "%s, ", name);

        for (count = d0; count < numregs; count++)
        {
            chtmp = fD_GetRegStr(obj, count);
            fprintf(outfile, "%s, %s, %s%s",
                    (fD_GetFuncParNum(obj) == count ? "__fpt" : fD_GetProto(obj, count)),
                    fD_GetParam(obj, count),
                    chtmp,
                    (count == numregs - 1 && !BaseName[0] ? "" : ", "));
        }

        if (BaseName[0])               /*
                                        * was "##base" used?
                                        */
            fprintf(outfile, "\\\n\t, %s_BASE_NAME", BaseNamU);
        if (fD_GetFuncParNum(obj) != illegal)
        {
            fprintf(outfile, ", ");
            fprintf(outfile, fD_GetProto(obj, fD_GetFuncParNum(obj)), "__fpt");
        }
/*
 * Here it would make sense to create a database file to integrate optimizations * automaticly into every new
 * build. * Not every function needs a complete flush. For example functions with no parameter * wouldn`t
 * need a PPC flush normally. * Or Read(File,Addr,Size); would only need a flush for Addr with the Size
 */
        fprintf(outfile, ", IF_CACHEFLUSHALL, NULL, 0, IF_CACHEFLUSHALL, NULL, 0");
        fprintf(outfile, ")\n\n");

    }
    else if (output_mode == PRAGMA)
    {
        if (PowerUP == TRUE || MorphOS == TRUE)
        {

            fprintf(outfile, "#define\t%s",
                    name);

            if (numregs)
            {
                fprintf(outfile, "(");

                if (numregs > 0)
                {
                    for (count = d0; count < numregs - 1; count++)
                    {
                        fprintf(outfile, "%s, ", fD_GetParam(obj, count));
                    }
                    fprintf(outfile, "%s", fD_GetParam(obj, count));
                }

                fprintf(outfile, ")");

                if (BaseName[0])       /*
                                        * was "##base" used?
                                        */
                {
                    fprintf(outfile, "\t_%s(%s_BASE_NAME%s",
                            name,
                            BaseNamU,
                            numregs ? ", " : "");
                }
                else
                {
                    fprintf(outfile, "\t_%s(",
                            name);
                }

                if (numregs > 0)
                {
                    for (count = d0; count < numregs - 1; count++)
                    {
                        fprintf(outfile, "%s, ", fD_GetParam(obj, count));
                    }
                    fprintf(outfile, "%s", fD_GetParam(obj, count));
                }

                fprintf(outfile, ")\n\n");
            }
            else
            {
                if (BaseName[0])       /*
                                        * was "##base" used?
                                        */
                {
                    fprintf(outfile, "()\t_%s(%s_BASE_NAME)\n\n",
                            name,
                            BaseNamU);
                }
                else
                {
                    fprintf(outfile, "()\t_%s()\n\n",
                            name);
                }
            }

            fprintf(outfile, "static __inline %s\n_%s(%s%s%s",
                    rettype,
                    name,
                    BaseName[0] ? "void *" : "",
                    BaseName[0] ? BaseName : "",
                    (BaseName[0] ? (numregs ? ", " : "") : ""));

            for (count = d0; count < numregs; count++)
            {
                chtmp = fD_GetProto(obj, count);
                if (fD_GetFuncParNum(obj) == count)
                {
                    fprintf(outfile, chtmp, fD_GetParam(obj, count));
                }
                else
                {
                    fprintf(outfile, "%s%s%s", chtmp, (*(chtmp + strlen(chtmp) - 1) == '*' ?
                                                       "" : " "), fD_GetParam(obj, count));
                }
                if (count < numregs - 1)
                {
                    fprintf(outfile, ", ");
                }
            }

            fprintf(outfile, ")\n");
            fprintf(outfile, "{\n");
            fprintf(outfile, "struct Caos\tMyCaos;\n");
            fprintf(outfile, "\tMyCaos.M68kCacheMode\t=\tIF_CACHEFLUSHALL;\n");
            fprintf(outfile, "//\tMyCaos.M68kStart\t=\tNULL;\n");
            fprintf(outfile, "//\tMyCaos.M68kSize\t\t=\t0;\n");
            fprintf(outfile, "\tMyCaos.PPCCacheMode\t=\tIF_CACHEFLUSHALL;\n");
            fprintf(outfile, "//\tMyCaos.PPCStart\t\t=\tNULL;\n");
            fprintf(outfile, "//\tMyCaos.PPCSize\t\t=\t0;\n");

            if (numregs > 0)
            {
                for (count = d0; count < numregs; count++)
                {
                    fprintf(outfile, "\tMyCaos.%s\t\t=(ULONG) %s;\n",
                            fD_GetRegStr(obj, count),
                            fD_GetParam(obj, count));
                }
            }

            fprintf(outfile, "\tMyCaos.caos_Un.Offset\t=\t(%ld);\n",
                    fD_GetOffset(obj));

            if (BaseName[0])           /*
                                        * was "##base" used?
                                        */
            {
                fprintf(outfile, "\tMyCaos.a6\t\t=(ULONG) %s;\t\n",
                        BaseName);
            }
            if (vd)
            {
                fprintf(outfile, "\tPPCCallOS(&MyCaos);\n}\n\n");
            }
            else
            {
                fprintf(outfile, "\treturn((%s)PPCCallOS(&MyCaos));\n}\n\n",
                        rettype);
/*
 * fprintf(outfile, "\treturn((%s)MyCaos.d0);\n}\n\n", rettype);
 */
            }

        }
        else
        {
          /*
           * No M68k support yet
           */
        }
    }
    else if (output_mode == GATESTUBS)
    {
        fprintf(outfile, "%s %s%s(void)\n{\n",
                rettype,
                prefixname,
                name);

        if (numregs > 0)
        {
            for (count = d0; count < numregs; count++)
            {
                if (strchr(fD_GetProto(obj, count),'%'))
                {
                    /* Function parameter */
                    fprintf(outfile, "\t");

                    sprintf(Buffer,
                        fD_GetProto(obj, count),
                        fD_GetParam(obj, count));
                    fprintf(outfile, Buffer);

                    fprintf(outfile, "\t=(");

                    sprintf(Buffer,
                        fD_GetProto(obj, count),
                        "");
                    fprintf(outfile, Buffer);

                    fprintf(outfile, ") REG_%s;\n",
                            fD_GetRegStrU(obj, count));
                }
                else
                {
                    fprintf(outfile, "\t%s %s\t=(%s) REG_%s;\n",
                            fD_GetProto(obj, count),
                            fD_GetParam(obj, count),
                            fD_GetProto(obj, count),
                            fD_GetRegStrU(obj, count));
                }
            }
        }
        if (vd)
        {
            fprintf(outfile, "\t(%s%s(",
                    subprefixname,
                    name);
        }
        else
        {
            fprintf(outfile, "\treturn(%s%s(",
                    subprefixname,
                    name);
        }
        if (numregs > 0)
        {
            if (PreLibFlag)
            {
                fprintf(outfile, "BASE_NAME,");
            }

            for (count = d0; count < numregs; count++)
            {
                if (count >= numregs - 1)
                {
                    if (PostLibFlag)
                    {
                        fprintf(outfile, "%s,BASE_NAME));\n}\n",
                            fD_GetParam(obj, count));
                    }
                    else
                    {
                        fprintf(outfile, "%s));\n}\n",
                            fD_GetParam(obj, count));
                    }
                }
                else
                {
                    fprintf(outfile, "%s,",
                            fD_GetParam(obj, count));
                }
            }
        }
        else
        {
            if (PreLibFlag || PostLibFlag)
            {
                fprintf(outfile, "BASE_NAME));\n}\n");
            }
            else
            {
                fprintf(outfile, "));\n}\n");
            }
        }

    }
    else
    {
        if (PowerUP == TRUE)
        {
            fprintf(outfile, "%sstatic __inline %s\n%s(%s",
                    (output_mode == STUBS ? "" : "extern "), rettype, name,
                    (BaseName[0] ? (numregs ? "BASE_PAR_DECL " : "BASE_PAR_DECL0") : ""));

            for (count = d0; count < numregs; count++)
            {
                chtmp = fD_GetProto(obj, count);
                if (fD_GetFuncParNum(obj) == count)
                    fprintf(outfile, chtmp, fD_GetParam(obj, count));
                else
                    fprintf(outfile, "%s%s%s", chtmp, (*(chtmp + strlen(chtmp) - 1) == '*' ?
                                                       "" : " "), fD_GetParam(obj, count));
                if (count < numregs - 1)
                    fprintf(outfile, ", ");
            }

            fprintf(outfile, ")\t\n");
            fprintf(outfile, "{\t\n");
            fprintf(outfile, "struct Caos\tMyCaos;\n");
            fprintf(outfile, "\tMyCaos.M68kCacheMode\t=\tIF_CACHEFLUSHALL;\t\n");
            fprintf(outfile, "//\tMyCaos.M68kStart\t=\tNULL;\t\n");
            fprintf(outfile, "//\tMyCaos.M68kSize\t\t=\t0;\t\n");
            fprintf(outfile, "\tMyCaos.PPCCacheMode\t=\tIF_CACHEFLUSHALL;\t\n");
            fprintf(outfile, "//\tMyCaos.PPCStart\t\t=\tNULL;\t\n");
            fprintf(outfile, "//\tMyCaos.PPCSize\t\t=\t0;\t\n");

            if (numregs > 0)
            {
                for (count = d0; count < numregs; count++)
                {
                    fprintf(outfile, "\tMyCaos.%s\t\t=(ULONG) %s;\t\n",
                            fD_GetRegStr(obj, count),
                            fD_GetParam(obj, count));
                }
            }

            fprintf(outfile, "\tMyCaos.caos_Un.Offset\t=\t(%ld);\t\n", fD_GetOffset(obj));
            if (BaseName[0])           /*
                                        * was "##base" used?
                                        */
            {
                fprintf(outfile, "\tMyCaos.a6\t\t=\t(ULONG) %s_BASE_NAME;\t\n",
                        BaseNamU);
            }
            if (vd)
            {
                fprintf(outfile, "\tPPCCallOS(&MyCaos);\t\n}\n\n");
            }
            else
            {
                fprintf(outfile, "\treturn((%s)PPCCallOS(&MyCaos));\n}\n\n",
                        rettype);
/*
 * fprintf(outfile, "\treturn((%s)MyCaos.d0);\t\n}\n\n", rettype);
 */
            }
        }
        else if (MorphOS == TRUE)
        {
            fprintf(outfile, "%s%s\n%s(%s",
                    (output_mode == STUBS ? "" : "static __inline "), rettype, name,
                    (BaseName[0] ? (numregs ? "BASE_PAR_DECL " : "BASE_PAR_DECL0") : ""));

            for (count = d0; count < numregs; count++)
            {
                chtmp = fD_GetProto(obj, count);
                if (fD_GetFuncParNum(obj) == count)
                    fprintf(outfile, chtmp, fD_GetParam(obj, count));
                else
                    fprintf(outfile, "%s%s%s", chtmp, (*(chtmp + strlen(chtmp) - 1) == '*' ?
                                                       "" : " "), fD_GetParam(obj, count));
                if (count < numregs - 1)
                    fprintf(outfile, ", ");
            }

            fprintf(outfile, ")\t\n");
            fprintf(outfile, "{\t\n");
            fprintf(outfile, "struct EmulCaos\tMyCaos;\n");

            if (numregs > 0)
            {
                for (count = d0; count < numregs; count++)
                {
                    fprintf(outfile, "\tMyCaos.reg_%s\t\t=\t(ULONG) %s;\n",
                            fD_GetRegStr(obj, count), fD_GetParam(obj, count));
                }
            }

            fprintf(outfile, "\tMyCaos.caos_Un.Offset\t=\t(%ld);\n", fD_GetOffset(obj));
            if (BaseName[0])           /*
                                        * was "##base" used?
                                        */
            {
                fprintf(outfile, "\tMyCaos.reg_a6\t\t=\t(ULONG) BASE_NAME;\n");
            }
            if (vd)
            {
                fprintf(outfile, "\t(*MyEmulHandle->EmulCallOS)(&MyCaos);\n}\n\n");
            }
            else
            {
                fprintf(outfile, "\treturn((%s)(*MyEmulHandle->EmulCallOS)(&MyCaos));\n}\n\n",
                        rettype);
/*
 * fprintf(outfile, "\treturn((%s)MyCaos.d0);\t\n}\n\n", rettype);
 */
            }
        }
        else
        {
            fprintf(outfile, "%s__inline %s\n%s(%s",
                    (output_mode == STUBS ? "" : "extern "), rettype, name,
                    (BaseName[0] ? (numregs ? "BASE_PAR_DECL " : "BASE_PAR_DECL0") : ""));

            for (count = d0; count < numregs; count++)
            {
                chtmp = fD_GetProto(obj, count);
                if (fD_GetFuncParNum(obj) == count)
                    fprintf(outfile, chtmp, fD_GetParam(obj, count));
                else
                    fprintf(outfile, "%s%s%s", chtmp, (*(chtmp + strlen(chtmp) - 1) == '*' ?
                                                       "" : " "), fD_GetParam(obj, count));
                if (count < numregs - 1)
                    fprintf(outfile, ", ");
            }
            fprintf(outfile, ")\n{\n%s", (BaseName[0] ? "   BASE_EXT_DECL\n" : ""));
            if (!vd)
                fprintf(outfile, "   register %s%sres __asm(\"d0\");\n", rettype,
                        (*(rettype + strlen(rettype) - 1) == '*' ? "" : " "));

            if (BaseName[0])
                fprintf(outfile, "   register struct %s *a6 __asm(\"a6\") = BASE_NAME;\n",
                        StdLib);

            for (count = d0; count < numregs; count++)
            {
                chtmp = fD_GetRegStr(obj, count);
                if (a45 && (strcmp(chtmp, "a4") == 0 || strcmp(chtmp, "a5") == 0))
                    chtmp = "d7";
                if (fD_GetFuncParNum(obj) == count)
                {
                    fprintf(outfile, "   register ");
                    fprintf(outfile, fD_GetProto(obj, count), chtmp);
                    fprintf(outfile, " __asm(\"%s\") = %s;\n", chtmp, fD_GetParam(obj,
                                                                                  count));
                }
                else
                {
                    const char *proto = fD_GetProto(obj, count);

                    fprintf(outfile, "   register %s%s%s __asm(\"%s\") = %s;\n",
                            proto, (*(proto + strlen(proto) - 1) == '*' ? "" : " "), chtmp,
                            chtmp, fD_GetParam(obj, count));
                }
            }
            if (a45)
                fprintf(outfile, "   __asm volatile (\"exg d7,%s\\n\\t"
                        "jsr a6@(-0x%lx:W)\\n\\texg d7,%s\"\n", (a45 == 4 ? "a4" : "a5"),
                        -fD_GetOffset(obj), (a45 == 4 ? "a4" : "a5"));
            else
                fprintf(outfile, "   __asm volatile (\"jsr a6@(-0x%lx:W)\"\n",
                        -fD_GetOffset(obj));

            fprintf(outfile, (vd ? "   : /* No Output */\n" : "   : \"=r\" (res)\n"));

            fprintf(outfile, "   : ");
            if (BaseName[0])
                fprintf(outfile, "\"r\" (a6)%s", (numregs ? ", " : ""));

            for (count = d0; count < numregs; count++)
            {
                chtmp = fD_GetRegStr(obj, count);
                if (a45 && (strcmp(chtmp, "a4") == 0 || strcmp(chtmp, "a5") == 0))
                    chtmp = "d7";
                fprintf(outfile, "\"r\" (%s)%s", chtmp, (count < numregs - 1 ? ", " : ""));
            }
            fprintf(outfile, "\n   : \"d0\", \"d1\", \"a0\", \"a1\", \"fp0\", \"fp1\"");

            if (vd)
                fprintf(outfile, ", \"cc\", \"memory\");\n}\n\n");    /*
                                                                     * {
                                                                     */
            else
                fprintf(outfile, ", \"cc\", \"memory\");\n   return res;\n}\n\n");
        }
    }

    if ((tagname = aliasfunction(fD_GetName(obj))) != 0)
    {
        fprintf(outfile, "#define %s(", tagname);
        for (count = d0; count < numregs - 1; count++)
            fprintf(outfile, "a%d, ", count);
        fprintf(outfile, "a%d) %s (", count, name);
        for (count = d0; count < numregs - 1; count++)
            fprintf(outfile, "(a%d), ", count);
        fprintf(outfile, "(a%d))\n\n", count);
    }

    if ((tagname = taggedfunction(obj)) != 0)
    {
        if (output_mode != STUBS)
        {
            if (PowerUP || MorphOS)
            {
                fprintf(outfile, "#ifndef NO_PPCINLINE_STDARG\n#define %s(", tagname);
            }
            else
            {
                fprintf(outfile, "#ifndef NO_INLINE_STDARG\n#define %s(", tagname);
            }

            for (count = d0; count < numregs - 1; count++)
                fprintf(outfile, "a%d, ", count);

            fprintf(outfile, "tags...) \\\n\t({ULONG _tags[] = { tags }; %s(",
                    name);

            for (count = d0; count < numregs - 1; count++)
                fprintf(outfile, "(a%d), ", count);

            if (PowerUP || MorphOS)
            {
                fprintf(outfile, "(%s)_tags);})\n#endif /* !NO_PPCINLINE_STDARG */\n\n",
                        fD_GetProto(obj, fD_RegNum(obj) - 1));
            }
            else
            {
                fprintf(outfile, "(%s)_tags);})\n#endif /* !NO_INLINE_STDARG */\n\n",
                        fD_GetProto(obj, fD_RegNum(obj) - 1));
            }
        }
        else
        {
            if (MorphOS)
            {
                int n = 9 - numregs;
                int d = n & 1 ? 4 : 0;
                int local = (n * 4 + d + 16 + 64 + 15) & ~15;    /*

                                                                 * size of the stack frame
                                                                 */
              /*
               *  Stack frame:
               *
               *   0 -  3: next frame ptr
               *   4 -  7: save lr
               *   8 - 71: struct Caos
               *  72 - 72+n*4+d+8-1: tag list start
               *   ? - local-1: padding
               */

                fprintf(outfile,
                        "asm(\".align\t2\\n\"\n"
                        "\"\t.globl\t%s\\n\"\n"
                        "\"\t.type\t%s,@function\\n\"\n"
                        "\"%s:\\n\"\n"
                        "\"\tstwu\t1,-%d(1)\\n\"\n"        /*
                                                         * create stack frame
                                                         */
                        "\"\tmflr\t0\\n\"\n"
                        "\"\tstw\t0,%d(1)\\n\"\n",
                        tagname, tagname, tagname, local, local + 4);

              /*
               * If n is odd, one tag is split between regs and stack.
               * * Copy its ti_Data together with the ti_Tag.
               */
                if (d)
                    fprintf(outfile, "\"\tlwz\t0,%d(1)\\n\"\n", local + 8);        /*
                                                                                 * read ti_Data
                                                                                 */

              /*
               * Save the registers
               */
                for (count = numregs; count <= 8; count++)
                    fprintf(outfile, "\"\tstw\t%d,%d(1)\\n\"\n", count + 2, (count - numregs) * 4 + 8 + 64);

                if (d)
                    fprintf(outfile, "\"\tstw\t0,%d(1)\\n\"\n", 8 + 64 + n * 4);    /*
                                                                                     * write ti_Data
                                                                                     */

              /*
               * Caos.Offset = -fD_GetOffset(obj)
               */
                fprintf(outfile,
                        "\"\tli\t0,%ld\\n\"\n"
                        "\"\tstw\t0,8(1)\\n\"\n",
                        fD_GetOffset(obj));

              /*
               * Save the non-varargs registers in the Caos struct.
               */
                for (count = 0; count < numregs - 1; count++)
                {
                    int r = fD_GetReg(obj, count);

                    fprintf(outfile, "\"\tstw\t%d,%d(1)\\n\"\n", count + 3, 8 + 4 + r * 4);
                }

                fprintf(outfile,
                        "\"\taddi\t0,1,72\\n\"\n"
                        "\"\tstw\t0,%d(1)\\n\"\n"    /*
                                                     * Caos.reg_?? = taglist
                                                     */

                        "\"\tlis\t3,%s@ha\\n\"\n"
                        "\"\tlwz\t0,%s@l(3)\\n\"\n"
                        "\"\tstw\t0,68(1)\\n\"\n"    /*
                                                     * Caos.reg_a6 = libbase
                                                     */

                        "\"\tli\t0,2\\n\"\n"
                        "\"\tstw\t0,%d(1)\\n\"\n"    /*
                                                     * ti_Tag = TAG_MORE
                                                     */

                        "\"\taddi\t0,1,%d\\n\"\n"
                        "\"\tstw\t0,%d(1)\\n\"\n"    /*
                                                     * ti_Data = &stack_params
                                                     */

                        "\"\tlwz\t0,88(2)\\n\"\n"
                        "\"\taddi\t3,1,8\\n\"\n"
                        "\"\tmtlr\t0\\n\"\n"
                        "\"\tblrl\\n\"\n"    /*
                                             * EmulCallOS()
                                             */

                        "\"\tlwz\t0,%d(1)\\n\"\n"    /*
                                                     * clear stack frame & return
                                                     */
                        "\"\tmtlr\t0\\n\"\n"
                        "\"\taddi\t1,1,%d\\n\"\n"
                        "\"\tblr\\n\"\n"
                        "\".L%se1:\\n\"\n"
                        "\"\t.size\t%s,.L%se1-%s\\n\"\n);\n\n",
                        12 + 4 * fD_GetReg(obj, numregs - 1), BaseName, BaseName,
                        8 + 64 + n * 4 + d, local + 8 + d, 8 + 64 + n * 4 + d + 4, local + 4, local,
                        name, name, name, name);

            }
            else
            {
                fprintf(outfile, "%s %s(", rettype, tagname);

                for (count = d0; count < numregs - 1; count++)
                {
                    chtmp = fD_GetProto(obj, count);
                    if (count == fD_GetFuncParNum(obj))
                        fprintf(outfile, chtmp, fD_GetParam(obj, count));
                    else
                        fprintf(outfile, "%s%s%s", chtmp,
                                (*(chtmp + strlen(chtmp) - 1) == '*' ? "" : " "),
                                fD_GetParam(obj, count));
                    fprintf(outfile, ", ");
                }

                fprintf(outfile, "int tag, ...)\n{\n   ");
                if (!vd)
                    fprintf(outfile, "return ");

                fprintf(outfile, "%s(", name);
                for (count = d0; count < numregs - 1; count++)
                    fprintf(outfile, "%s, ", fD_GetParam(obj, count));

                fprintf(outfile, "(%s)&tag);\n}\n\n", fD_GetProto(obj, fD_RegNum(obj) - 1));
            }
        }
    }

    if (strcmp(name, "DoPkt") == 0)
    {
        fdDef *objnc = (fdDef *) obj;
        char newname[7] = "DoPkt0";

        objnc->name = newname;
        for (count = 2; count < 7; count++)
        {
            regs reg = objnc->reg[count];
            char *proto = objnc->proto[count];

            objnc->reg[count] = illegal;
            objnc->proto[count] = fD_nostring;
            fD_write(outfile, objnc);
            objnc->reg[count] = reg;
            objnc->proto[count] = proto;
            newname[5]++;
        }
        objnc->name = (char *)name;
    }
}

int    varargsfunction(const char *proto, const char *funcname)
{
    const char *end = proto + strlen(proto) - 1;

    while (isspace(*end))
    {
        end--;
    }
    if (*end-- == ';')
    {
        while (isspace(*end))
        {
            end--;
        }
        if (*end-- == ')')
        {
            while (isspace(*end))
            {
                end--;
            }
            if (!strncmp(end - 2, "...", 3))
            {
              /*
               * Seems to be a varargs function. Check if it will be recognized
               * as "tagged".
               */
                unsigned int count;
                char fixedname[200];   /*

                                        * Hope will be enough...
                                        */
                fdDef *tmpdef;


                for (count = 0; count < sizeof TagExcTable / sizeof TagExcTable[0]; count += 2)
                {
                    if (strcmp(funcname, TagExcTable[count + 1]) == 0)
                    {
                        return 1;
                    }
                }

                if (!(tmpdef = fD_ctor()))
                {
                    fprintf(stderr, "No mem for FDs\n");
                    exit(EXIT_FAILURE);
                }

                strcpy(fixedname, funcname);
                if (strlen(funcname) > 4 &&
                    !strcmp(funcname + strlen(funcname) - 4, "Tags"))
                {
                  /*
                   * Might be either nothing or "TagList".
                   */
                    fixedname[strlen(fixedname) - 4] = '\0';
                    fD_NewName(tmpdef, fixedname);
                    if (bsearch(&tmpdef, arrdefs, fds, sizeof arrdefs[0],fD_cmpName))
                    {
                        return 1;
                    }

                    strcat(fixedname, "TagList");
                    fD_NewName(tmpdef, fixedname);
                    if (bsearch(&tmpdef, arrdefs, fds, sizeof arrdefs[0],fD_cmpName))
                    {
                        return 1;
                    }
                }
                else
                {
                    strcat(fixedname, "A");
                    fD_NewName(tmpdef, fixedname);
                    if (bsearch(&tmpdef, arrdefs, fds, sizeof arrdefs[0],fD_cmpName))
                    {
                        return 1;
                    }
                }
            }
        }
    }
    return 0;
}

int    ishandleddifferently(const char *proto, const char *funcname)
{
  /*
   * First check if this is a vararg call?
   */
    if (varargsfunction(proto, funcname))
    {
        return(1);
    }

  /*
   * It might be a dos.library "alias" name.
   */
    if (aliasfunction(funcname))
    {
        return(1);
    }

  /*
   * It might be one from dos.library/DoPkt() family.
   */
    if (strlen(funcname) == 6 &&
       !strncmp(funcname, "DoPkt", 5) &&
       funcname[5] >= '0' &&
       funcname[6] <= '4')
    {
        return(1);
    }

  /*
   * Finally, it can be intuition.library/ReportMouse1().
   */
    return(!strcmp(funcname, "ReportMouse1"));
}

void    output_proto(FILE * outfile)
{
    if (PowerUP || MorphOS)
    {
        fprintf(outfile,
                "/* Automatically generated header! Do not edit! */\n\n"
                "#ifndef PROTO_%s_H\n"
                "#define PROTO_%s_H\n\n"
                "#include <clib/%s_protos.h>\n\n"
                "#ifdef __GNUC__\n"
                "#ifdef __PPC__\n"
                "#include <ppcinline/%s.h>\n"
                "#else\n"
                "#include <inline/%s.h>\n"
                "#endif /* __PPC__ */\n"
                "#else\n"
                "#include <pragmas/%s_pragmas.h>\n"
                "#endif /* __GNUC__ */\n\n",
                BaseNamU, BaseNamU, BaseNamL, BaseNamL, BaseNamL, BaseNamL);
    }
    else
    {
        fprintf(outfile,
                "/* Automatically generated header! Do not edit! */\n\n"
                "#ifndef PROTO_%s_H\n"
                "#define PROTO_%s_H\n\n"
                "#include <clib/%s_protos.h>\n\n"
                "#ifdef __GNUC__\n"
                "#include <inline/%s.h>\n"
                "#endif /* __GNUC__ */\n\n",
                BaseNamU, BaseNamU, BaseNamL, BaseNamL);
    }
    if (BaseName[0])
        fprintf(outfile,
                "#ifndef __NOLIBBASE__\n"
                "extern struct %s *\n"
                "#ifdef __CONSTLIBBASEDECL__\n"
                "__CONSTLIBBASEDECL__\n"
                "#endif /* __CONSTLIBBASEDECL__ */\n"
                "%s;\n"
                "#endif /* !__NOLIBBASE__ */\n\n",
                StdLib, BaseName);

    if (PowerUP || MorphOS)
    {
        fprintf(outfile,
                "#endif /* !PPCPROTO_%s_H */\n", BaseNamU);
    }
    else
    {
        fprintf(outfile,
                "#endif /* !PROTO_%s_H */\n", BaseNamU);
    }
}

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

void    printusage(const char *exename)
{
    fprintf(stderr,
            "Usage: %s [options] [--prefix name] [--subprefix name] [--premacro name] fd-file clib-file [[-o] output-file]\n"
            "Options:\n"
            "--new\t\t\tpreprocessor based (default)\n"
            "--old\t\t\tinline based\n"
            "--stubs\t\t\tlibrary stubs\n"
            "--proto\t\t\tbuild proto files (no clib-file required)\n"
            "--pragma\t\tbuild pragma file\n"
            "--powerup\t\tpowerup flag\n"
            "--morphos\t\tmorphos flag\n"
            "--gatestubs\t\tlibrary stubs\n"
            "--prelib\t\tgatestub pre library arg\n"
            "--postlib\t\tgatestub pre library arg\n"
            "--local\t\tlocal includes\n"
            "--version\t\tprint version number and exit\n", exename);
}

int    main(int argc, char **argv)
{
    fdDef *tmpdef,                       /*
                                        * a dummy to contain the name to look for
                                        */
    *founddef;                           /*

                                        * the fdDef for which we found a prototype
                                        */
    fdFile *myfile;
    char *tmpstr;
    FILE *outfile;
    char *fdfilename = 0, *clibfilename = 0, *outfilename = 0;

    int count;
    Error lerror;

    for (count = 1; count < argc; count++)
    {
        char *option = argv[count];

        if (*option == '-')
        {
            option++;
            if (strcmp(option, "o") == 0)
            {
                if (count == argc - 1 || outfilename)
                {
                    printusage(argv[0]);
                    return EXIT_FAILURE;
                }
                if (strcmp(argv[++count], "-"))
                    outfilename = argv[count];
            }
            else
            {
                if (*option == '-')       /*
                                * Accept GNU-style '--' options
                                */
                    option++;
                if (strcmp(option, "new") == 0)
                    output_mode = NEW;
                else if (strcmp(option, "old") == 0)
                    output_mode = OLD;
                else if (strcmp(option, "stubs") == 0)
                    output_mode = STUBS;
                else if (strcmp(option, "proto") == 0)
                    output_mode = PROTO;
                else if (strcmp(option, "pragma") == 0)
                    output_mode = PRAGMA;
                else if (strcmp(option, "gatestubs")==0)
                    output_mode=GATESTUBS;
                else if (strcmp(option, "powerup") == 0)
                    PowerUP = TRUE;
                else if (strcmp(option, "morphos") == 0)
                    MorphOS = TRUE;
                else if (strcmp(option, "prelib") == 0)
                {
                    if (PostLibFlag)
                    {
                        printusage(argv[0]);
                        return EXIT_FAILURE;
                    }
                    PreLibFlag = TRUE;
                }
                else if (strcmp(option, "postlib") == 0)
                {
                    if (PreLibFlag)
                    {
                        printusage(argv[0]);
                        return EXIT_FAILURE;
                    }
                    PostLibFlag = TRUE;
                }
                else if (strcmp(option, "local") == 0)
                {
                    LocalFlag = TRUE;
                }
                else if (strcmp(option, "prefix") == 0)
                {

                    if (count == argc - 1 || outfilename)
                    {
                        printusage(argv[0]);
                        return EXIT_FAILURE;
                    }
                    if (strcmp(argv[++count], "-"))
                    {
                        prefixname = argv[count];
                    }
                }
                else if (strcmp(option, "subprefix") == 0)
                {

                    if (count == argc - 1 || outfilename)
                    {
                        printusage(argv[0]);
                        return EXIT_FAILURE;
                    }
                    if (strcmp(argv[++count], "-"))
                    {
                        subprefixname = argv[count];
                    }
                }
                else if (strcmp(option, "premacro") == 0)
                {

                    if (count == argc - 1 || outfilename)
                    {
                        printusage(argv[0]);
                        return EXIT_FAILURE;
                    }
                    if (strcmp(argv[++count], "-"))
                    {
                        premacro = argv[count];
                    }
                }
                else if (strcmp(option, "version") == 0)
                {
                    fprintf(stderr, "fd2inline version " VERSION "\n");
                    return EXIT_SUCCESS;
                }
                else
                {
                    printusage(argv[0]);
                    return EXIT_FAILURE;
                }
            }
        }
        else
        {
          /*
           * One of the filenames
           */
            if (!fdfilename)
                fdfilename = option;
            else if (!clibfilename)
                clibfilename = option;
            else if (!outfilename)
                outfilename = option;
            else
            {
                printusage(argv[0]);
                return EXIT_FAILURE;
            }
        }
    }

    if (!fdfilename || (!clibfilename && output_mode != PROTO))
    {
        printusage(argv[0]);
        return EXIT_FAILURE;
    }

    if (!(arrdefs = malloc(FDS * sizeof(fdDef *))))
    {
        fprintf(stderr, "No mem for FDs\n");
        return EXIT_FAILURE;
    }
    for (count = 0; count < FDS; count++)
        arrdefs[count] = NULL;

    if (!(myfile = fF_ctor(fdfilename)))
    {
        fprintf(stderr, "Couldn't open file '%s'.\n", fdfilename);
        return EXIT_FAILURE;
    }

    lerror = false;

    for (count = 0; count < FDS && lerror == false; count++)
    {
        if (!(arrdefs[count] = fD_ctor()))
        {
            fprintf(stderr, "No mem for FDs\n");
            return EXIT_FAILURE;
        }
        do
        {
            if ((lerror = fF_readln(myfile)) == false)
            {
                fF_SetError(myfile, false);
                lerror = fD_parsefd(arrdefs[count], myfile);
            }
        }
        while (lerror == nodef);
    }
    if (count < FDS)
    {
        count--;
        fD_dtor(arrdefs[count]);
        arrdefs[count] = NULL;
    }
    fds = count;

    qsort(arrdefs, count, sizeof arrdefs[0], fD_cmpName);

    if (output_mode != NEW)
    {
        unsigned int count2;

        StdLib = "Library";

        for (count2 = 0; count2 < sizeof LibExcTable / sizeof LibExcTable[0]; count2 += 2)
            if (strcmp(BaseName, LibExcTable[count2]) == 0)
            {
                StdLib = LibExcTable[count2 + 1];
                break;
            }
    }

    fF_dtor(myfile);

    if (output_mode != PROTO)
    {
        if (!(myfile = fF_ctor(clibfilename)))
        {
            fprintf(stderr, "Couldn't open file '%s'.\n", clibfilename);
            return EXIT_FAILURE;
        }

        if (!(tmpdef = fD_ctor()))
        {
            fprintf(stderr, "No mem for FDs\n");
            return EXIT_FAILURE;
        }

        for (lerror = false; lerror == false || lerror == nodef;)
        {
            if ((lerror = fF_readln(myfile)) == false)
            {
                /*
                 * continue even on errors
                 */
                fF_SetError(myfile, false);

                tmpstr = fF_FuncName(myfile);

                if (tmpstr)
                {
                    fdDef **res;

                    fD_NewName(tmpdef, tmpstr);
                    res = (fdDef **) bsearch(&tmpdef, arrdefs, fds, sizeof arrdefs[0], fD_cmpName);

                    if (res)
                    {
                        founddef = *res;
                        DBP(printf( "found (%s).\n", fD_GetName(founddef)));
                        fF_SetError(myfile, false);
                        lerror = fD_parsepr(founddef, myfile);
                    }
                    else if (!ishandleddifferently(myfile->line, tmpstr))
                    {
                        fprintf(stderr, "don't know what to do with <%s> in line %lu.\n",
                                tmpstr, myfile->lineno);
                    }
                    free(tmpstr);
                }
            }
        }
        fD_dtor(tmpdef);

        fF_dtor(myfile);
    }

    if (strlen(fdfilename) > 7 &&
        !strcmp(fdfilename + strlen(fdfilename) - 7, "_lib.fd"))
    {
        char *str = fdfilename + strlen(fdfilename) - 8;

        while (str != fdfilename && str[-1] != '/' && str[-1] != ':')
            str--;
        strncpy(BaseNamL, str, strlen(str) - 7);
        strncpy(BaseNamU, str, strlen(str) - 7);
        BaseNamU[strlen(str) - 7] = '\0';
    }
    else
    {
      /*
       * Shouldn't really happen, but...
       */
        strcpy(BaseNamU, BaseName);
        if (strlen(BaseNamU) > 4 && strcmp(BaseNamU + strlen(BaseNamU) - 4, "Base") == 0)
            BaseNamU[strlen(BaseNamU) - 4] = '\0';
    }
    StrUpr(BaseNamU);

    if (outfilename)
    {
        if (!(outfile = fopen(outfilename, "w")))
        {
            fprintf(stderr, "Couldn't open output file.\n");
            return EXIT_FAILURE;
        }
    }
    else
        outfile = stdout;

    if (output_mode == PROTO)
    {
        output_proto(outfile);
    }
    else
    {
        if (output_mode == NEW)
        {
            if (PowerUP || MorphOS)
            {
                fprintf(outfile,
                        "/* Automatically generated header! Do not edit! */\n\n"
                        "#ifndef _PPCINLINE_%s_H\n"
                        "#define _PPCINLINE_%s_H\n\n"
                        "#ifndef __PPCINLINE_MACROS_H\n"
                        "#include <ppcinline/macros.h>\n"
                        "#endif /* !__PPCINLINE_MACROS_H */\n\n",
                        BaseNamU,
                        BaseNamU);
            }
            else
            {
                fprintf(outfile,
                        "/* Automatically generated header! Do not edit! */\n\n"
                        "#ifndef _INLINE_%s_H\n"
                        "#define _INLINE_%s_H\n\n"
                        "#ifndef __INLINE_MACROS_H\n"
                        "#include <inline/macros.h>\n"
                        "#endif /* !__INLINE_MACROS_H */\n\n",
                        BaseNamU,
                        BaseNamU);
            }
        }
        else if (output_mode == PRAGMA)
        {
            if (PowerUP || MorphOS)
            {
                fprintf(outfile,
                    "/* Automatically generated header! Do not edit! */\n\n"
                    "#ifndef _PPCPRAGMA_%s_H\n"
                    "#define _PPCPRAGMA_%s_H\n"
                    "#ifdef __GNUC__\n"
                    "#ifndef _PPCINLINE__%s_H\n"
                    "#include <ppcinline/%s.h>\n"
                    "#endif\n"
                    "#else\n\n"
                    "#ifndef POWERUP_PPCLIB_INTERFACE_H\n"
                    "#include <ppclib/interface.h>\n"
                    "#endif\n\n"
                    "#ifndef POWERUP_GCCLIB_PROTOS_H\n"
                    "#include <gcclib/powerup_protos.h>\n"
                    "#endif\n\n"
                    "#ifndef NO_PPCINLINE_STDARG\n"
                    "#define NO_PPCINLINE_STDARG\n"
                    "#endif"
                    "/* SAS C PPC inlines */\n\n",
                    BaseNamU,
                    BaseNamU,
                    BaseNamU,
                    BaseNamL);
            }
            else
            {
                fprintf(outfile,
                        "/* Automatically generated header! Do not edit! */\n\n"
                        "#ifndef _INLINE__%s_H\n"
                        "#include <inline/%s.h>\n\n",
                        BaseNamU,
                        BaseNamL);
            }

        }
        else if (output_mode == GATESTUBS)
        {
            if (LocalFlag)
            {
                fprintf(outfile,
                    "/* Automatically generated gate stubs */\n\n"
                    "%s\n"
                    "#include \"%s_protos.h\"\n\n"
                    "#include <emul/emulregs.h>\n",
                    premacro,
                    BaseNamL);
            }
            else
            {
                fprintf(outfile,
                    "/* Automatically generated gate stubs */\n\n"
                    "%s\n"
                    "#include <clib/%s_protos.h>\n\n"
                    "#include <emul/emulregs.h>\n",
                    premacro,
                    BaseNamL);
            }
        }
        else
        {
            if (PowerUP || MorphOS)
            {
                fprintf(outfile,
                    "/* Automatically generated header! Do not edit! */\n\n"
                    "#ifndef _PPCINLINE_%s_H\n"
                    "#define _PPCINLINE_%s_H\n\n"
                    "#ifndef __PPCINLINE_STUB_H\n"
                    "#include <ppcinline/stubs.h>\n"
                    "#endif /* !__PPCINLINE_STUB_H */\n\n",
                    BaseNamU,
                    BaseNamU);
                if (MorphOS)
                    fprintf(outfile, "#include <emul/emulregs.h>\n");
            }
            else
            {
                fprintf(outfile,
                    "/* Automatically generated header! Do not edit! */\n\n"
                    "#ifndef _INLINE_%s_H\n"
                    "#define _INLINE_%s_H\n\n"
                    "#ifndef __INLINE_STUB_H\n"
                    "#include <inline/stubs.h>\n"
                    "#endif /* !__INLINE_STUB_H */\n\n",
                    BaseNamU,
                    BaseNamU);
            }
        }

        if (BaseName[0])
        {
            if (output_mode == NEW || (output_mode == PRAGMA && (PowerUP == TRUE || MorphOS == TRUE)))
            {
                fprintf(outfile,
                        "#ifndef %s_BASE_NAME\n"
                        "#define %s_BASE_NAME %s\n"
                        "#endif /* !%s_BASE_NAME */\n\n",
                        BaseNamU, BaseNamU, BaseName, BaseNamU);
            }
            else
            {
                fprintf(outfile,
                        "#ifndef BASE_EXT_DECL\n"
                        "#define BASE_EXT_DECL\n"
                        "#define BASE_EXT_DECL0 extern struct %s *%s;\n"
                        "#endif /* !BASE_EXT_DECL */\n"
                        "#ifndef BASE_PAR_DECL\n"
                        "#define BASE_PAR_DECL\n"
                        "#define BASE_PAR_DECL0 void\n"
                        "#endif /* !BASE_PAR_DECL */\n"
                        "#ifndef BASE_NAME\n"
                        "#define BASE_NAME %s\n"
                        "#endif /* !BASE_NAME */\n\n"
                        "BASE_EXT_DECL0\n\n", StdLib, BaseName, BaseName);
            }
        }

        for (count = 0; count < FDS && arrdefs[count]; count++)
        {
            DBP(printf( "outputting %ld...\n", count));

            fD_write(outfile, arrdefs[count]);
            fD_dtor(arrdefs[count]);
            arrdefs[count] = NULL;
        }

        if (output_mode == OLD || output_mode == STUBS)
        {
            if (BaseName[0])
            {
                fprintf(outfile,
                        "#undef BASE_EXT_DECL\n"
                        "#undef BASE_EXT_DECL0\n"
                        "#undef BASE_PAR_DECL\n"
                        "#undef BASE_PAR_DECL0\n"
                        "#undef BASE_NAME\n\n");
            }

            if (PowerUP || MorphOS)
            {
                fprintf(outfile, "#endif /* !_PPCINLINE_%s_H */\n", BaseNamU);
            }
            else
            {
                fprintf(outfile, "#endif /* !_INLINE_%s_H */\n", BaseNamU);
            }
        }
        else if (output_mode == PRAGMA)
        {
            fprintf(outfile, "#endif /* SASC Pragmas */\n");
            if (PowerUP || MorphOS)
            {
                fprintf(outfile, "#endif /* !_PPCPRAGMA_%s_H */\n", BaseNamU);
            }
            else
            {
                fprintf(outfile, "#endif /* !_PRAGMA_%s_H */\n", BaseNamU);
            }
        }
        else if (output_mode == NEW)
        {
            if (PowerUP || MorphOS)
            {
                fprintf(outfile, "#endif /* !_PPCINLINE_%s_H */\n", BaseNamU);
            }
            else
            {
                fprintf(outfile, "#endif /* !_INLINE_%s_H */\n", BaseNamU);
            }
        }

    }

    free(arrdefs);

    return EXIT_SUCCESS;
}