Frozen Fish 1: Amiga/FrozenFish-Apr94.iso/bbs/alib/d0xx/d028/cpp.lha/Cpp/cc/cc.c

C/C++ Source or Header | 1986-07-17 | 22.4 KB | 837 lines

/************************************************************************
 *                                    *
 *            Copyright (c) 1985, Fred Fish            *
 *                All Rights Reserved                *
 *                                    *
 *    This software and/or documentation is released into the        *
 *    public domain for personal, non-commercial use only.        *
 *    Limited rights to use, modify, and redistribute are hereby    *
 *    granted for non-commercial purposes, provided that all        *
 *    copyright notices remain intact and all changes are clearly    *
 *    documented.  The author makes no warranty of any kind with    *
 *    respect to this product and explicitly disclaims any implied    *
 *    warranties of merchantability or fitness for any particular    *
 *    purpose.                            *
 *                                    *
 ************************************************************************
 */


/*
 *    cc -- C compiler front end for Amiga and Lattice C.
 *
 *    Somewhat AMIGA/Lattice dependent, but can probably be adapted to
 *    other systems with a minimum of work.  I have attempted to keep
 *    portability in mind as much as possible.
 *
 */

char _sccsid[] = "@(#)cc.c    1.8";

#include <stdio.h>

/*
 *    The following allow use on systems that don't have my macro based
 *    debugging package.  The default, for now, is to assume it is not
 *    available.
 */

#ifdef DBUG
#  include <local/dbug.h>
#else    /* !DBUG */
#  define DBUG_ENTER(a)
#  define DBUG_RETURN(a) return(a)
#  define DBUG_VOID_RETURN return
#  define DBUG_2(a,b)
#  define DBUG_3(a,b,c)
#  define DBUG_4(a,b,c,d)
#  define DBUG_5(a,b,c,d,e)
#  define DBUG_PUSH(a)
#endif    /* DBUG */

/*
 *    IMPLEMENTATION NOTES
 *
 *    Some of the builtin (artificial) limits could be removed by
 *    using dynamically allocated data structures, such as keeping the
 *    operand list as a linked list with space for each link supplied
 *    by malloc.  This would certainly increase the code space, while
 *    reducing the statically allocated data space.  The net result
 *    would probably be a program requiring about the same amount of
 *    total memory for most day to day usages.  When source is not
 *    available to the end user, maximum flexibility is a must and
 *    dynamic allocation is the only way to go.  In this case however
 *    it is not clear that the added complexity is worth it, since
 *    source should be available for anyone wishing to expand the
 *    limits.
 *
 *    One last note, if you are going to have builtin limits then
 *    check the @#$%&* things for overflow.  Running off the end of
 *    an array with no indication that something is wrong, other
 *    than a crash, if definitely unfriendly!
 *
 */


/*
 *    Manifest constants which can be tuned to fit requirements.
 */

#define CMDBUFFERSIZE (1024)    /* Size of command buffer for CLI command */
#define MAXOPERANDS (64)    /* Maximum number of operands on cmd line */
#define MAXDEFINES (32)        /* Maximum number of -D<name> args */
#define MAXUNDEFINES (32)    /* Maximum number of -U<name> args */
#define MAXINCDIRS (16)        /* Maximum number of -I<filename> args */
#define MAXLIBS (16)        /* Maximum number of -l<lib> args */
#define ARGSIZE (64)        /* Size of temp args for cmd line */

#define LOCALSYMTABSIZE (100)    /* Local symbol table size in entries */
#define EXPRTABSIZE (200)    /* Expression table size */
#define CASETABSIZE (256)    /* Case table size */
#define STRTABSIZE (5 * 1024)    /* String table size */

/*
 *    Define QUADDEV to be the default place where you want the compiler
 *    intermediate files (quad files) to be created.  For systems with
 *    512K or more, the preferred place is the ram disk.  However,
 *    really big compiles may need to be done on a hard disk.
 *    In either case, the default can be overridden with the -q option.
 */

#define QUADDEV    "ram:"        /* Keep intermediate files in ram */
/* #define QUADDEV "" */    /* Keep intermediate files in current dir */
#define TEMPNAME "tempxxxx"

/*
 *    Manifest constants which are generally the same on all systems.
 */

#define EOS '\000'        /* End of string character */

/*
 *    Command line arguments that represent files to be compiled, assembled,
 *    or linked, are kept track of via an "Operand" array.  If, for example,
 *    the file name is "df0:mydir/junk.c", then the Rootname is
 *    "df0:mydir/junk", the Basename is "junk", and the Suffix is "c".
 *    String suffixes are used, rather than single character suffixes, to
 *    allow use of names with multicharacter suffixes.
 */

struct Operand {        /* Info about each operand (non option) */
    char *Rootname;        /* Name minus any suffix */
    char *Basename;        /* Name minus any prefix or suffix */
    char *Suffix;        /* Suffix of operand */
};

static struct Operand Operands[MAXOPERANDS];    /* Table of operands */
static int NOperands = 0;            /* Number of operands found */
static char *Defines[MAXDEFINES];        /* Table of defines */
static int NDefines = 0;            /* Number of defines */
static char *UnDefines[MAXUNDEFINES];        /* Table of undefines */
static int NUnDefines = 0;            /* Number of undefines */
static char *UserInc[MAXINCDIRS];        /* Table of include dirs */
static int NUserInc = 0;            /* Number of include dirs */
static char *Libs[MAXLIBS];            /* Table of library args */
static int NLibs = 0;                /* Number of library args */

/*
 *    The command line buffer for child commands is allocated statically,
 *    rather than as an automatic, to forstall problems with stack limits
 *    in initial implementations.  Hopefully, automatic stack growth will
 *    be implemented in future release of the C compiler.  If nothing
 *    else, someday I will read the manuals and figure out how to explicitly
 *    grow the stack...
 *
 */

static char Command[CMDBUFFERSIZE];        /* Command line buffer */
static char *EndCommand = Command;        /* End of current command */

/*
 *    Macros to determine the suffix type of a file given a pointer to
 *    its operand structure.
 */

#define CFILE(op) (strcmp(op->Suffix,"c")==0)
#define SFILE(op) (strcmp(op->Suffix,"s")==0)
#define OFILE(op) (strcmp(op->Suffix,"o")==0)
extern int strcmp ();

/*
 *    Now some macros to map from unix names to the AMIGA equivalents,
 *    and to enable abort on control-C.
 */

#ifdef amiga
#  define system(a) (Execute(a,0,0))
#  define ENABLE_ABORT (Enable_Abort = 1)
#  define DISABLE_ABORT (Enable_Abort = 0)
#  define CHECK_ABORT Check_Abort()
   extern int Enable_Abort;            /* Enable abort on CNTL-C */
   static void Check_Abort ();        /* Test for abort requested */
#else
#  define ENABLE_ABORT                /* Null expansion */
#  define DISABLE_ABORT                /* Null expansion */
#  define CHECK_ABORT                /* Null expansion */
#endif    /* amiga */

/*
 *    Set list of places to search for various executables, libraries, etc.
 *    Searched in order, first match wins, null string is current directory.
 *    Note that these names are used as prefixes exactly as given, so
 *    device names must end in ':' and directory names must end in '/'.
 *
 */

static char *Devices[] = {
    "",
    "ram:",
    "df0:",
    "df1:",
    NULL
};

static char *BinDirs[] = {
    "",
    "ram:c/",
    "df0:c/",
    "df1:c/",
    NULL
};

static char *LibDirs[] = {
    "",
    "ram:lib/",
    "df0:lib/",
    "df1:lib/",
    NULL
};

static char *IncDirs[] = {
    "ram:include/",
    "df0:include/",
    "df1:include/",
    NULL
};

/*
 *    Flags set by command line arguments/
 */

static int cflag;            /* -c flag given */
static int Hflag;            /* -H flag given */
static int Pflag;            /* -P flag given */
static int Sflag;            /* -S flag given */
static int Vflag;            /* -V flag given (non-standard) */

static int ErrCount = 0;        /* Count of compile/assemble errors */
static char *outfile = "a.out";        /* Output file name from linker */
static char *QuadDev = QUADDEV;        /* Where to keep quad files */

static char *predefines = "-Damiga -Dm68000 -Dmanx";

static char *Locate ();            /* Find a file */
static void AddToCommand ();        /* Add argument to command buffer */
static void InitCommand ();        /* Initialize command buffer */
static void Fatal ();            /* Quit with fatal error */
static void Warning ();            /* Issue warning message */
static void AddOperandToList ();    /* Add .c, .s, or .o file to list */
static void CleanObjects ();        /* Remove .o for link and go mode */
static void MakeObjects ();        /* Reduce to list of object files */
static void ParseCommandLine ();    /* Deal with command line */
static void Compile ();            /* Translate from .c to .o */
static int Assemble ();            /* Translate from .s to .o */
static void Link ();            /* Gather .o's into executable */

extern void exit ();            /* See exit(2) */

/*
 *    Main entry point.  Note that despite common usage where main is
 *    essentially of type void, we declare it explicitly to return
 *    an int, and actually return a value.  In most implementations,
 *    the value returned from main is the exit status of the program.
 *    Whether this applies to Lattice C or not, I'm not sure yet.
 */

int main (argc, argv)
int argc;
char *argv[];
{
    DBUG_ENTER ("main");
    ENABLE_ABORT;
    ParseCommandLine (argc, argv);
    MakeObjects ();
    if (!cflag && !Pflag && !Sflag && ErrCount == 0) {
    Link ();
    CleanObjects ();
    }
    DBUG_RETURN (0);
}

/*
 *    The following macro is used to allow optional whitespace between
 *    an option and it's argument.  Argp is left pointing at the option
 *    and argv and argc are adjusted accordingly if necessary.
 *
 *    Note that there is no check for missing option arguments.  In
 *    particular, -o -V will blindly take -V as the output file name.
 *
 */

#define XARG(argc,argv,argp) {if(*++argp==EOS){argp=(*argv++);argc--;}}

static void ParseCommandLine (argc, argv)
int argc;
char **argv;
{
    register char *argp;

    DBUG_ENTER ("ParseCommandLine");
    argc--;
    argv++;
    while (argc-- > 0) {
    CHECK_ABORT;
    argp = *argv++;
    if (*argp != '-') {
        AddOperandToList (argp);
    } else {
        switch (*++argp) {
        case '#':
            XARG (argc, argv, argp);
            DBUG_PUSH (argp);
            break;
        case 'c':
            cflag++;
            break;
        case 'D':
            XARG (argc, argv, argp);
            if (NDefines >= MAXDEFINES) {
            Fatal ("too many -D args (%d max)", MAXDEFINES);
            }
            Defines[NDefines++] = argp;
            break;
        case 'E':
            Warning ("-E unimplemented, converted to -P instead");
            Pflag++;
            break;
        case 'f':
            break;    /* NOP for now, just eat it */
        case 'g':
            break;    /* NOP for now, just eat it */
        case 'H':
            Hflag++;
            break;
        case 'I':
            XARG (argc, argv, argp);
            if (NUserInc >= MAXINCDIRS) {
            Fatal ("too many -I args (%d max)", MAXINCDIRS);
            }
            UserInc[NUserInc++] = argp;
            break;
        case 'l':
            XARG (argc, argv, argp);
            if (NLibs > MAXLIBS) {
            Fatal ("too many -l args (%d max)", MAXLIBS);
            }
            Libs[NLibs++] = argp;
            break;
        case 'O':
            break;    /* NOP for now, just eat it */
        case 'o':
            XARG (argc, argv, argp);
            outfile = argp;
            break;
        case 'P':
            Pflag++;
            break;
        case 'q':        /* Warning, non-standard */
            XARG (argc, argv, argp);
            QuadDev = argp;
            break;
        case 'S':
            Sflag++;
            break;
        case 's':
            break;        /* NOP for now, just eat it */
        case 'U':
            XARG (argc, argv, argp);
            if (NUnDefines >= MAXUNDEFINES) {
            Fatal ("too many -U args (%d max)", MAXUNDEFINES);
            }
            UnDefines[NUnDefines++] = argp;
            break;
        case 'V':
            Vflag++;
            break;
        default:
            Warning ("unknown option '%c'", (char *) *argp);
            break;
        }
    }
    }
    DBUG_VOID_RETURN;
}

/*
 *    For each operand, do compilation or assembly as necessary, to
 *    reduce to an object file in the current directory.
 */

static void MakeObjects ()
{
    register int index;
    register struct Operand *op;
    auto char buffer[ARGSIZE];

    DBUG_ENTER ("MakeObjects");
    for (index = 0; index < NOperands; index++) {
    CHECK_ABORT;
    op = &Operands[index];
    if (NOperands > 1 && (CFILE (op) || SFILE (op))) {
        printf ("%s.%s:\n", op -> Rootname, op -> Suffix);
    }
    if (CFILE (op)) {
        Preprocess (op);
        Compile (op);
        sprintf (buffer, "%s%s.c", QuadDev, TEMPNAME);
        if (!DeleteFile (buffer)) {
        Warning ("can't delete '%s'", buffer);
        }
        if (!Sflag) {
        Assemble (op);
        sprintf (buffer, "%s%s.s", QuadDev, op -> Basename);
        if (!DeleteFile (buffer)) {
            Warning ("can't delete '%s'", buffer);
        }
        }
    } else if (SFILE (op)) {
        Assemble (op);
    }
    }
    DBUG_VOID_RETURN;
}

/*
 *    Note that commands to cc of the form "-l<name>" get interpreted
 *    to mean use a library called "name.lib" from the library
 *    directory.
 */

static void Link ()
{
    register int index;
    register struct Operand *op;
    register char *name;
    auto char buffer[ARGSIZE];

    DBUG_ENTER ("Link");
    InitCommand ();
    AddToCommand ("%s", Locate ("ln", BinDirs));
    AddToCommand (" -o %s", outfile);
    for (index = 0; index < NOperands; index++) {
    op = &Operands[index];
    if (OFILE (op)) {
        name = op -> Rootname;
    } else {
        name = op -> Basename;
    }
    AddToCommand (" %s.o", name);
    }
    for (index = 0; index < NLibs; index++) {
    if (!Hflag) {
        sprintf (buffer, "%s32.lib", Libs[index]);
    } else {
        sprintf (buffer, "%s.lib", Libs[index]);
    }
    AddToCommand (" %s", Locate (buffer, LibDirs));
    }
    if (!Hflag) {
    AddToCommand (" %s", Locate ("c32.lib", LibDirs));
    } else {
    AddToCommand (" %s", Locate ("c.lib", LibDirs));
    }
    (void) RunCommand ();
    DBUG_VOID_RETURN;
}

/*VARARGS1*/
static void Warning (fmt, arg1, arg2, arg3)
char *fmt;
char *arg1;
char *arg2;
char *arg3;
{
    fprintf (stderr, "cc -- warning: ");
    fprintf (stderr, fmt, arg1, arg2, arg3);
    fprintf (stderr, "\n");
    (void) fflush (stderr);
}

/*VARARGS1*/
static void Fatal (fmt, arg1, arg2, arg3)
char *fmt;
char *arg1;
char *arg2;
char *arg3;
{
    fprintf (stderr, "cc -- fatal error: ");
    fprintf (stderr, fmt, arg1, arg2, arg3);
    fprintf (stderr, "\n");
    (void) fflush (stderr);
    exit (1);
}

/*
 *    Split an operand name into rootname, basename, and suffix
 *    components.  The rootname is the full name, minus any suffix,
 *    but including any prefix.  The basename is the rootname minus
 *    any prefix.  The suffix is anything after the last '.' character.
 *    Only the suffix is allowed to be the null string.
 */

static void AddOperandToList (filename)
char *filename;
{
    register char *split;
    register struct Operand *op;
    extern char *strrchr ();

    DBUG_ENTER ("AddOperandToList");
    DBUG_3 ("ops", "add file '%s' to operand list", filename);
    if (NOperands >= MAXOPERANDS) {
    Fatal ("too many files (%d max)\n", MAXOPERANDS);
    }
    op = &Operands[NOperands];
    op -> Rootname = filename;
    if ((split = strrchr (filename, '/')) == NULL) {
    split = strrchr (filename, ':');
    }
    if (split == NULL) {
    op -> Basename = filename;
    } else {
    op -> Basename = ++split;
    }
    if ((split = strrchr (filename, '.')) == NULL) {
    op -> Suffix = "";
    } else {
    *split++ = EOS;
    op -> Suffix = split;
    }
    DBUG_3 ("ops", "rootname '%s'", op -> Rootname);
    DBUG_3 ("ops", "basename '%s'", op -> Basename);
    DBUG_3 ("ops", "suffix '%s'", op -> Suffix);
    NOperands++;
    DBUG_VOID_RETURN;
}

/*
 *    Compile one operand from a C source program to an object module.
 */

static void Compile (op)
struct Operand *op;
{
    DBUG_ENTER ("Compile");
    Pass1 (op);
    CHECK_ABORT;
    DBUG_VOID_RETURN;
}

/*
 *    Note that because of brain-damage in the fact that -p to lc1 removes
 *    all predefined defs, we must add them so replacing -c with -P in the
 *    cc command line will result in the same set of predefined symbols.
 *    This is rather ugly and leaves a hole for future problems if we
 *    get out of sync with respect to what names the compiler predefines.
 */

static int Pass1 (op)
register struct Operand *op;
{
    register int status;
    register int index;

    DBUG_ENTER ("Pass1");
    InitCommand ();
    AddToCommand ("%s", Locate ("ccom", LibDirs));
    AddToCommand (" -B");
    AddToCommand (" -L%d", LOCALSYMTABSIZE);
    AddToCommand (" -E%d", EXPRTABSIZE);
    AddToCommand (" -Y%d", CASETABSIZE);
    AddToCommand (" -Z%d", STRTABSIZE);
    if (!Hflag) {
    AddToCommand (" +L");
    }
    if (Sflag) {
    AddToCommand (" -A -T -o %s.s", op -> Basename);
    } else {
    AddToCommand (" -A -o %s%s.s", QuadDev, op -> Basename);
    }
    AddToCommand (" %s%s.c", QuadDev, TEMPNAME);
    status = RunCommand ();
    DBUG_RETURN (status);
}

static int Preprocess (op)
register struct Operand *op;
{
    register int status;
    register int index;

    DBUG_ENTER ("Preprocess");
    InitCommand ();
    AddToCommand ("%s", Locate ("cpp", LibDirs));
    AddToCommand (" %s", predefines);
    for (index = 0; index <NUserInc; index++) {
    AddToCommand (" -I%s", UserInc[index]);
    }
    for (index = 0; index <NUnDefines; index++) {
    /*************************
    AddToCommand (" -u%s", UnDefines[index]);
    **************************/
    Warning ("-U%s ignored! (unimplemented)", UnDefines[index]);
    }
    for (index = 0; index <NDefines; index++) {
    AddToCommand (" -D%s", Defines[index]);
    }
    AddToCommand (" -I%s", Locate ("include", Devices));
    AddToCommand (" %s.%s", op -> Rootname, op -> Suffix);
    AddToCommand (" %s%s.c", QuadDev, TEMPNAME);
    status = RunCommand ();
    DBUG_RETURN (status);
}

/*
 *    I have not yet had occasion to use the macro assembler, so this
 *    part is not yet implemented.  If anyone wants to send me the
 *    appropriate code, I will be glad to install it.
 */

static int Assemble (op)
struct Operand *op;
{
    register int status;
    register int index;

    DBUG_ENTER ("Assemble");
    InitCommand ();
    AddToCommand ("%s", Locate ("as", BinDirs));
    AddToCommand (" -o %s.o", op -> Basename);
    if (CFILE (op)) {
        AddToCommand (" %s%s.s", QuadDev, op -> Basename);
    } else {
        AddToCommand (" %s.%s", op -> Rootname, op -> Suffix);
    }
    status = RunCommand ();
    DBUG_RETURN (status);
}

/*
 *    As far as I can tell, the child status is not returned, only
 *    whether or not the child could be run.  So, how do we find out
 *    whether there was an error or not?  It's probably in the manuals
 *    somewhere, I just haven't had time to dig yet.
 *
 *    Note that because Lattice printf is not capable of printing more
 *    than 200 characters at a time, we must spit them out one at a time
 *    to make sure the entire command line gets printed when -V is used.
 *
 */

static int RunCommand ()
{
    int status;
    register char *cmdp;

    DBUG_ENTER ("RunCommand");
    DBUG_3 ("cmd", "execute '%s'", Command);
    if (Vflag) {
    for (cmdp = Command; *cmdp != EOS; cmdp++) {
        putchar (*cmdp);                /* see above */
    }
    putchar ('\n');
    (void) fflush (stdout);
    }
    CHECK_ABORT;
    status = system (Command);
    DBUG_3 ("sys", "subcommand returns status %d", status);
    if (!status) {
    ErrCount++;
    }
    DBUG_RETURN (status);
}

/*
 *    Look through the list of paths pointed to by "vec" until we find
 *    a file with name given pointed to by "namep".  If none is found,
 *    the name pointed to by namep is returned.
 */

static char *Locate (namep, vec)
char *namep;
char **vec;
{
    static char namebuf[ARGSIZE];

    DBUG_ENTER ("Locate");
    while (*vec != NULL) {
    (void) sprintf (namebuf, "%s%s", *vec, namep);
    DBUG_3 ("try", "look for '%s'", namebuf);
    if (Readable (namebuf)) {
        namep = namebuf;
        break;
    }
    vec++;
    }
    DBUG_RETURN (namep);
}

/*
 *    Check to see if the file exists and is readable.
 */

#ifdef unix
#  include <fcntl.h>
#else
#  include <libraries/dos.h>
#endif

static int Readable (name)
char *name;
{
    register int status = 0;
    register int fildes;

    DBUG_ENTER ("Readable");
#ifdef unix
    fildes = open (name, O_RDONLY);
    if (fildes >= 0) {
    (void) close (fildes);
    status = 1;
    }
#else
    fildes = Lock (name, ACCESS_READ);
    if (fildes != 0) {
        UnLock (fildes);
    status = 1;
    }
#endif
    DBUG_RETURN (status);
}

/*
 *    Do explicit check for abort.  When Enable_Abort is non-zero,
 *    Chk_Abort() cause program termination if CNTRL-C or CNTRL-D has
 *    been received.  Thus, we temporarily set it back to zero while we
 *    do the explicit test, so we can do our own clean up and exit.
 *    Note that if the -V flag was used, we spit out a confirming message
 *    that we are quitting.
 *
 *    Since we previously set Check_Abort to non-zero, this routine may be
 *    overkill.
 */

#ifdef amiga
static void Check_Abort ()
{
    extern int Chk_Abort ();

    DBUG_ENTER ("Check_Abort");
    DBUG_2 ("abort", "do explicit test for CNTRL-C");
    DISABLE_ABORT;
    if (Chk_Abort () != 0) {
    if (Vflag) {
        printf ("cc - terminated by request\n");
    }
    exit (1);
    }
    ENABLE_ABORT;
    DBUG_VOID_RETURN;
}
#endif

/*
 *    Initialize the command line buffer and associated variables to
 *    discard any previous command line.
 */

static void InitCommand ()
{
    Command[0] = EOS;
    EndCommand = Command;
}

/*
 *    Build string to add to end of current command line, checking
 *    for overflow in the command buffer and maintaining the pointer
 *    to the end of the current command.
 *
 *    Note that we are a "printf type" of command, and can be called
 *    with up to three "char *" arguments.  There is a portability
 *    problem here, but Lattice hasn't yet made "varargs" a standard
 *    part of their distribution.
 *
 *    Also, note that the return argument of sprintf is supposed to be
 *    the number of characters to be added to the buffer.  This is
 *    not always true for some C implementations.  In particular,
 *    sprintf in BSD4.1 returns a pointer.  Thus we don't use the
 *    return argument.
 *
 */

/*VARARGS1*/
static void AddToCommand (fmt, arg1, arg2, arg3)
char *fmt;
char *arg1, *arg2, *arg3;
{
    register int length;
    auto char buffer[ARGSIZE];

    (void) sprintf (buffer, fmt, arg1, arg2, arg3);
    length = strlen (buffer);
    if ((EndCommand - Command) + length >= sizeof (Command)) {
    Fatal ("command line too long (%d char max)", sizeof (Command));
    } else {
    (void) strcat (EndCommand, buffer);
    EndCommand += length;
    }
}

/*
 *    If an executable is made from a single C file, the normal behavior
 *    for the unix environment is to treat the .o file as an intermediate
 *    file and remove it, so we follow suit.
 */

static void CleanObjects ()
{
    auto char buffer[ARGSIZE];
    register struct Operand *op;

    DBUG_ENTER ("CleanObjects");
    if (NOperands == 1) {
    op = &Operands[0];
    if (CFILE (op) || SFILE (op)) {
        sprintf (buffer, "%s.o", op -> Basename);
        if (!DeleteFile (buffer)) {
        Warning ("can't delete '%s'", buffer);
        }
    }
    }
    DBUG_VOID_RETURN;
}

#if defined(amiga) && defined(manx) /* In Lattice C lib, but not Manx's */
char *strrchr (s, c)
char *s;
char c;
{
    register char *scan = s;

    DBUG_ENTER ("strrchr");
    while (*scan++ != EOS) {;}
    while (scan > s && *(--scan) != c) {;}
    DBUG_RETURN (*scan == c ? scan : NULL);
}
#endif    /* amiga && manx */