obp/tools/didepend.c

/*
* ========== Copyright Header Begin ==========================================
*
* Hypervisor Software File: didepend.c
*
* Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
*
*  - Do no alter or remove copyright notices
*
*  - Redistribution and use of this software in source and binary forms, with
*    or without modification, are permitted provided that the following
*    conditions are met:
*
*  - Redistribution of source code must retain the above copyright notice,
*    this list of conditions and the following disclaimer.
*
*  - Redistribution in binary form must reproduce the above copyright notice,
*    this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
*    Neither the name of Sun Microsystems, Inc. or the names of contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
*     This software is provided "AS IS," without a warranty of any kind.
* ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
* INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
* PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
* MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
* ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
* DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN
* OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR
* FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
* DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
* ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
* SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
*
* You acknowledge that this software is not designed, licensed or
* intended for use in the design, construction, operation or maintenance of
* any nuclear facility.
*
* ========== Copyright Header End ============================================
*/
/*
 * id: @(#)didepend.c 1.12 04/04/22
 * purpose:
 * copyright: Copyright 1997-2004 Sun Microsystems, Inc.  All Rights Reserved
 * Use is subject to license terms.
 */

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <stdio.h>

#include "defines.h"

#define SOURCE_FLAG     0x01
#define TARGET_FLAG     0x02
#define DEPEND_FLAG     0x04
#define CODE_FLAG       0x08
#define CODE_START      0x10
#define CODE_END        0x20
#define COMPAT_MODE     0x40

#define MAXLINE 512

FILE    *ifd;
char    *buildcmd = NULL;
char    *progname = NULL;
char    *filename = NULL;
char    *codefile  = NULL;
char    *srcfile  = NULL;
char    buffer[ MAXLINE ];
int     flags = 0;
int     line_num = 0;
int     argcount;
int     pedantic = 0;
int     defdepth = 0;
int     showsyms = 0;
int     verbose = 0;

void
usage(void)
{
        fprintf(stderr, "%s: [flag] sourcefile\n", progname);
        fprintf(stderr, "   -D <symbol> : define <symbol>\n");
        fprintf(stderr, "   -U <symbol> : undefine <symbol>\n");
        fprintf(stderr, "   -S          : show symbols used\n");
        fprintf(stderr, "   -s          : print sources\n");
        fprintf(stderr, "   -t          : print targets\n");
        fprintf(stderr, "   -d          : print dependancies\n");
        fprintf(stderr, "   -c          : print code\n");
        fprintf(stderr, "   -p          : pedantic mode\n");
        exit(1);
}

typedef void * retval;

#define CAST(x) (retval) (x)

#define CMD_NULL_ARGS   0x00
#define CMD_OPT_ARGS    0x10
#define CMD_COMPAT      0x20
#define CMD_COMPAT_ONLY 0x40
#define CMD_IFDEF       0x80
#define CMD_MASK        0xf0

typedef struct CMD
{
        char    *name;
        retval  (*fn)(char *arg0, char *line);
        int     flags;
} cmd;

retval enable_cmds(char *line, char *arg0);
retval disable_cmds(char *line, char *arg0);
retval get_source_line(char *line, char *arg0);
retval set_build_cmd(char *arg0, char *line);
retval grab_depend_line(char *arg0, char *line);
retval grab_target_line(char *arg0, char *line);
retval grab_external_line(char *arg0, char *line);
retval grab_source(char *arg0, char *line);
retval comment_line(char *arg0, char *line);
retval unexpected_token(char *arg0, char *line);
retval get_execute_token(char *arg0, char *line);
retval grab_next_file(char *arg0, char *line);
retval set_code_file(char *arg0, char *line);
retval set_build_flags(char *arg0, char *line);
retval do_message(char *arg0, char *line);
retval do_define(char *arg0, char *line);
retval do_undef(char *arg0, char *line);
retval do_ifdef(char *arg0, char *line);
retval do_ifndef(char *arg0, char *line);
retval do_else(char *arg0, char *line);
retval do_endif(char *arg0, char *line);

#define COMPAT_NO_ARGS  CMD_COMPAT|CMD_NULL_ARGS
#define COMPAT_OPT_ARGS CMD_COMPAT|CMD_OPT_ARGS

cmd cmds[] = {
        {  "version1",  disable_cmds,           COMPAT_NO_ARGS },
        {  "version2",  enable_cmds,            COMPAT_NO_ARGS },
        {  "build",     set_build_cmd,          CMD_OPT_ARGS | 1 },
        {  "depend",    grab_depend_line,       1 },
        {  "target",    grab_target_line,       2 },
        {  "external",  grab_external_line,     1 },
        {  "source{",   grab_source,            CMD_OPT_ARGS },
        {  "}source",   unexpected_token,       CMD_NULL_ARGS },
        {  "#",         comment_line,           COMPAT_OPT_ARGS },
        {  "-",         get_source_line,        CMD_COMPAT_ONLY },
        {  "include",   grab_next_file,         1 },
        {  "codefile",  set_code_file,          1 },
        {  "buildoptions", set_build_flags,     CMD_OPT_ARGS | 1 },
        {  "message",   do_message,             CMD_OPT_ARGS | 1 },
        {  "#define",   do_define,              1 },
        {  "#undef",    do_undef,               1 },
        {  "#ifdef",    do_ifdef,               CMD_IFDEF | 1 },
        {  "#ifndef",   do_ifndef,              CMD_IFDEF | 1 },
        {  "#else",     do_else,                CMD_IFDEF | CMD_NULL_ARGS },
        {  "#endif",    do_endif,               CMD_IFDEF | CMD_NULL_ARGS },
        {  NULL, NULL, 0 }
};

void
malloc_failed(void *ptr)
{
        if (ptr == NULL) {
                fprintf(stderr, "%s:%d: Malloc failed\n", filename, line_num);
                exit(1);
        }
}

char *
get_arg(char *line, int which, int *rpos)
{
        static char     arg[MAXLINE];
        char            *tokens = " \t";
        char            *start;
        int             strip;
        int             len, end, pos, prev;

        if ((line == NULL) || (*line == 0)) {
                return (NULL);
        }

        end = strlen(line);
        prev = pos = 0;
        start = line;
        while ((which-- >= 0) && (pos < end)) {
                strip = strspn(start, tokens);
                start += strip;
                pos += strip;
                prev = pos;
                len = strcspn(start, tokens);
                pos += len;
                if ((pos >= end) && (which >= 0)) {
                        if (rpos) *rpos = prev;
                        return (NULL);
                }
                if (len) {
                        strncpy(arg, start, len);
                        arg[len] = 0;
                } else {
                        strcpy(arg, start);
                }
                start += len;
        }
        if (rpos) *rpos = prev;
        return (arg);
}

int
count_args(char *line)
{
        int argc;
        char *lastarg;

        if (line == NULL) {
                return (0);
        }

        argc = 0;
        lastarg = line;
        while (lastarg) {
                lastarg = get_arg(line, argc+1, NULL);
                if (lastarg) argc++;
        }
        return (argc);
}

void
automatic_message(char comment)
{
        printf("%c\n", comment);
        printf("%c Warning this is a machine generated file\n", comment);
        printf("%c Changes made here will go away\n", comment);
        printf("%c\n", comment);
}

/* This is gross, but exists for Version1 compatability. */
char *fthsrc =
"id: %" "Z%%" "M%  %" "I%  %" "E%\n"
"purpose: %" "Y%\n"
"copyright: Copyright 1989-1997 Sun Microsystems, Inc. All Rights Reserved\n"
"\n"
"\" /packages/SUNW,builtin-drivers\" find-device\n"
"\n"
": do-fcode ( str$ -- )\n"
"   find-drop-in if\n"
"      2dup 2>r execute-buffer\n"
"      2r> free-drop-in\n"
"   then\n"
";\n\n";

char *
get_line(char *line, int from)
{
        char *argp;
        int  pos;

        argp = get_arg(line, from, &pos);
#if 0
        printf("rem_line: '%s'\n", (argp ? argp : ""));
#endif
        if (argp == NULL) {
                return ("");
        }
        return (line + pos);
}

retval
get_more_source(char *cmd, char *line)
{
        int len;
        char *backslash;

        printf("get_more_source('%s','%s')\n",
            (cmd ? cmd : ""),
            (line ? line : ""));
        len = strlen(line);
        if (len > 1) {
                backslash = line+len-1;
                if (*backslash == '\\') {
                        *backslash = 0;
                        if (cmd == NULL)
                                printf("%s\n", get_line(line, 2));
                        else
                                printf("%s\n", line);
                        return (CAST(get_more_source));
                }
        }
        return (CAST(get_execute_token));
}


retval
get_source_line(char *cmd, char *line)
{
        char *arg0, *argp, *arg1, *argn;
        static int once = 0;
        int tail;

#if 0
        printf("get_source_line('%s','%s')\n",
            (cmd ? cmd : "NULL"),
            (line ? line : "NULL"));
#endif
        arg0 = arg1 = argn = NULL;
        if (cmd == NULL) {
                argp = get_arg(line, 0, NULL);
                if (argp) arg0 = strdup(get_arg(line, 0, NULL));
                malloc_failed(arg0);
        } else {
                arg0 = strdup(cmd);
        }

        argp = get_arg(line, 1, NULL);
        if (argp) arg1 = strdup(argp);
        malloc_failed(arg1);

        argp = get_line(line, 2);
        if (flags & CODE_FLAG) {
                if (!once) {
                        printf("%s", fthsrc);
                        once++;
                }
                get_more_source(cmd, line);
        }
        if (cmd == NULL) {
                if (flags & SOURCE_FLAG) {
                        printf("%s ", arg0);
                }
                if (flags & TARGET_FLAG) {
                        printf("%s ", arg1);
                }
                if (flags & DEPEND_FLAG) {
                        printf("%s: %s\n\t%s %s %s\n\n",
                            arg0, arg1,
                            buildcmd, arg0, arg1);
                }
        }
        if (arg0) free(arg0);
        if (arg1) free(arg1);
        return (CAST(get_more_source(cmd, line)));
}

retval
enable_cmds(char *arg0, char *line)
{
        flags &= ~COMPAT_MODE;
        return (CAST(get_execute_token));
}

retval
disable_cmds(char *arg0, char *line)
{
        flags |= COMPAT_MODE;
        return (CAST(get_execute_token));
}

retval
set_build_cmd(char *arg0, char *line)
{
        char *sptr;

        if (buildcmd) free(buildcmd);
        sptr = get_line(line, 1);
        if ((sptr == NULL) || ((sptr != NULL) && (strlen(sptr) == 0))) {
                fprintf(stderr, "%s:%d: Error, Missing argument\n",
                    filename, line_num);
                exit(1);
        }
        buildcmd = strdup(sptr);
        malloc_failed(buildcmd);
        return (CAST(get_execute_token));
}

retval
set_code_file(char *arg0, char *line)
{
        char *sptr;

        if (codefile) free(codefile);
        sptr = get_line(line, 1);
        if ((sptr == NULL) || ((sptr != NULL) && (strlen(sptr) == 0))) {
                fprintf(stderr, "%s:%d: Error, Missing argument\n",
                    filename, line_num);
                exit(1);
        }
        codefile = strdup(sptr);
        malloc_failed(codefile);
        return (CAST(get_execute_token));
}

retval
grab_depend_line(char *arg0, char *line)
{
        static int once = 0;

        if (flags & DEPEND_FLAG) {
                if (!once++) automatic_message('#');
                printf("\ninclude %s\n", get_arg(line, 1, NULL));
        }
        return (CAST(get_execute_token));
}

retval
grab_target_line(char *arg0, char *line)
{
        char *cptr, *dptr, *source, *target, *diname;
        int tflags;

        cptr = get_arg(line, 1, NULL);
        source = strdup(cptr);
        malloc_failed(source);
        dptr = strrchr(cptr, '/');
        if (dptr) cptr = dptr+1;
        target = strdup(cptr);
        malloc_failed(target);
        diname = get_arg(line, 2, NULL);
        cptr = strrchr(target, '.');
        if (cptr) *cptr = 0;

        if (flags & TARGET_FLAG) printf("%s.di ", target);
        if (flags & SOURCE_FLAG) printf("%s ", source);
        if (flags & DEPEND_FLAG) {
                printf("\n%s.di: %s %s\n\t%s %s %s\n",
                    target, srcfile, source,
                    buildcmd, source, diname);
        }
        free(target);
        free(source);
        return (CAST(get_execute_token));
}

retval
grab_external_line(char *arg0, char *line)
{
        if (flags & TARGET_FLAG) printf("%s ", get_arg(line, 1, NULL));
        return (CAST(get_execute_token));
}

retval
wait_source_end(char *arg0, char *line)
{
        int end, argc;
        char *last_arg;

        printf("wait_source_end('%s','%s')\n", arg0, line);

        end = (strcmp(arg0, "}source") == 0);
        if (flags & DEPEND_FLAG) {
                if (!end) printf("%s\n", line);
        }
        if (!end) {
                return (CAST(wait_source_end));
        }
        return (CAST(get_execute_token));
}

retval
grab_source(char *arg0, char *line)
{
        static int start_code = 0;
        static int once = 0;
        int end, start;
        int codebase, codeend, codelen;
        retval (*fn)(char *, char *);
        char *args;
        char *lptr = strdup(line);

        malloc_failed(lptr);

        fn = grab_source;
        start = (strcmp(arg0, "source{") == 0);
        if ((start) && (start_code++)) {
                fprintf(stderr, "%s:%d: Warning, unbalanced start{ tokens\n",
                    filename, line_num);
                if (pedantic) exit(1);
        }
        if (argcount)
                (void) get_arg(line, 1, &codebase);
        else
                codebase = strlen(arg0);
        args = get_arg(lptr, argcount, &codeend);
        end = (strcmp(args, "}source") == 0);

        if (!start)     codebase = 0;
        if (!end)       codeend  = strlen(line);

        codelen = (codeend-codebase);
        strncpy(lptr, line + codebase, codelen);
        lptr[codelen] = 0;

        if (flags & CODE_FLAG) {
                if (start && !once++) automatic_message('\\');
                printf("%s\n", lptr);
        }

        if (end) {
                start_code--;
                fn = get_execute_token;
        }
        free(lptr);
        return (CAST(fn));
}

retval
set_build_flags(char *arg0, char *line)
{
        if (flags & DEPEND_FLAG) {
                printf("\n%s", get_line(line, 1));
        }
        return (CAST(get_execute_token));
}

retval
comment_line(char *arg0, char *line)
{
        return (CAST(get_execute_token));
}

retval
do_message(char *arg0, char *line)
{
        if (flags & CODE_FLAG) {
                fprintf(stderr, "%s:%d: %s\n",
                    filename, line_num, get_line(line, 1));
        }
        return (CAST(get_execute_token));
}

retval
do_define(char *arg0, char *line)
{
        define_symbol(get_arg(line, 1, NULL), FORTH_DEFINE);
        return (CAST(get_execute_token));
}

retval
do_undef(char *arg0, char *line)
{
        define_symbol(get_arg(line, 1, NULL), FORTH_UNDEF);
        return (CAST(get_execute_token));
}

#define DEF_ELSE        1
#define DEF_ENDIF       2
#define DEF_SKIP        4
#define MAX_DEF_DEPTH   5

#define defskip (def_state[defdepth] & DEF_SKIP)

static int def_state[10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

void
def_state_check(int state, int flag, char *msg)
{
        if ((state & flag) == 0) {
                fprintf(stderr, "%s:%d: Parse Error, %s\n",
                    filename, line_num, msg);
                exit(1);
        }
        if (defdepth > MAX_DEF_DEPTH) {
                fprintf(stderr, "%s:%d: too many Nested IFDEF's\n",
                    filename, line_num);
                exit(1);
        }
}

void
do_common_ifdef(char *arg0, char *line, int do_true)
{
        int state = (DEF_ELSE | DEF_ENDIF);
        int def;

        def_state_check(1, 1, "");
        state |= def_state[defdepth++] & DEF_SKIP;
        def = symbol_defined(get_arg(line, 1, NULL));
        if ((do_true && !def) || (!do_true && def)) {
                state |= DEF_SKIP;
        }
        def_state[defdepth] = state;
}

retval
do_ifdef(char *arg0, char *line)
{
        do_common_ifdef(arg0, line, 1);
        return (CAST(get_execute_token));
}

retval
do_ifndef(char *arg0, char *line)
{
        do_common_ifdef(arg0, line, 0);
        return (CAST(get_execute_token));
}

retval
do_else(char *arg0, char *line)
{
        def_state_check(def_state[defdepth], DEF_ELSE, "Dangling #else");
        def_state[defdepth] &= ~DEF_ELSE;
        def_state[defdepth] ^= DEF_SKIP;
        def_state[defdepth] |= def_state[defdepth-1] & DEF_SKIP;
        return (CAST(get_execute_token));
}

retval
do_endif(char *arg0, char *line)
{
        def_state_check(def_state[defdepth], DEF_ENDIF, "Dangling #endif");
        def_state[defdepth--] &= ~DEF_ENDIF;
        return (CAST(get_execute_token));
}

retval
unexpected_token(char *arg0, char *line)
{
        fprintf(stderr, "%s:%d: bad token '%s'\n", filename, line_num, arg0);
        exit(1);
        return (NULL);
}

retval
get_execute_token(char *token, char *line)
{
        retval (*fn)(char *p, char *);
        cmd     *cptr = cmds;

        fn = unexpected_token;
        while (cptr->name != NULL) {
                int nargs;

                if (strcmp(cptr->name, token) != 0) {
                        cptr++;
                        continue;
                }

                if (((flags & COMPAT_MODE) && !(cptr->flags & CMD_COMPAT)) ||
                    (!(flags & COMPAT_MODE) && (cptr->flags & CMD_COMPAT_ONLY)))
                        unexpected_token(token, line);

                nargs = cptr->flags & ~CMD_MASK;
                if (verbose) {
                        printf("[%d,%d] CMD: '%s' args = %d, argc = %d\n",
                            defdepth, defskip, token, nargs, argcount);
                }

                if ((argcount > nargs) && (!(cptr->flags & CMD_OPT_ARGS))) {
                        fprintf(stderr,
                            "%s:%d: Warning, extra arguments for '%s'\n",
                            filename, line_num, token);
                        if (pedantic) exit(1);
                }

                if (argcount < nargs) {
                        fprintf(stderr,
                            "%s:%d: Missing arguments for '%s'\n",
                            filename, line_num, token);
                        exit(1);
                }
                fn = cptr->fn;
                break;
        }
        if ((flags & COMPAT_MODE) && (fn == unexpected_token)) {
                return (CAST(get_source_line(NULL, line)));
        }
        if (!(cptr->flags & CMD_IFDEF) && defskip) {
                fn = comment_line;
        }
        return (CAST((*fn)(token, line)));
}

void
process_file(char *name, int recurse)
{
        char    comment = 0;
        char    *savename;
        FILE    *infile;
        int     linenum;
        int     done = 0;
        retval (*process)(char *line, char *arg);

        /*
         * This is a gross hack! I should have made this entire thing parameter
         * driven, instead I chose to use globals :(
         * So I need to save and restore them for this cruft to work.
         */
        if (recurse) {
                if (flags & DEPEND_FLAG) printf("\n%s: %s\n", codefile, name);
                linenum = line_num;
                infile   = ifd;
                savename = filename;
                if (flags & CODE_FLAG) {
                        comment = '\\';
                } else if (flags & DEPEND_FLAG) {
                        comment = '#';
                }
                if (comment) printf("\n%c Included from %s\n", comment, name);
        }
        filename = strdup(name);
        malloc_failed(filename);
        ifd = fopen(filename, "r");
        if (ifd == NULL) {
                fprintf(stderr, "%s: unable to open: %s for reading",
                    progname, filename);
                exit(1);
        }

        process = get_execute_token;
        line_num = 0;
        while (!done) {
                char    *line, *cptr;
                char    cmd[MAXLINE];

                line_num++;
                line = fgets(buffer, MAXLINE, ifd);
                cmd[0] = 0;

                if (line) {
                        cptr = strchr(line, '\n');
                        if (cptr) *cptr = 0;
                        argcount = count_args(line);
                        cptr = get_arg(line, 0, NULL);
                        if (cptr) strcpy(cmd, cptr);
                }
                done = (line == NULL) || feof(ifd);

                if (!done) {
                        if (*cmd != 0)
                                process = (retval (*)()) process(cmd, line);
                }
        }
        fclose(ifd);
        free(filename);
        if (recurse) {
                line_num = linenum;
                ifd = infile;
                filename = savename;
                if (comment) printf("\n%c back to %s\n", comment, filename);
        }
}

retval
grab_next_file(char *arg0, char *line)
{
        char *cptr, eptr;

        cptr = get_arg(line, 1, NULL);

        if (flags & DEPEND_FLAG) {
                printf("\n%s: %s\n", codefile, cptr);
        }

        process_file(cptr, 1);

        return (CAST(get_execute_token));
}

main(int argc, char **argv)
{
        extern char *optarg;
        extern int optind;
        int errflg = 0;
        int c;

        progname = argv[0];
        while ((c = getopt(argc, argv, "D:U:SVstdcp")) != EOF)
                switch (c) {
                case 'D':
                        define_symbol(optarg, CMD_DEFINE);
                        break;
                case 'U':
                        define_symbol(optarg, CMD_UNDEF);
                        break;
                case 'S':
                        showsyms = 1;
                        break;
                case 'V':
                        verbose = 1;
                        break;
                case 's':
                        if (!flags) flags = SOURCE_FLAG; else usage();
                        break;

                case 't':
                        if (!flags) flags = TARGET_FLAG; else usage();
                        break;

                case 'd':
                        if (!flags) flags = DEPEND_FLAG; else usage();
                        break;

                case 'c':
                        if (!flags) flags = CODE_FLAG; else usage();
                        break;

                case 'p':
                        pedantic++;
                        break;

                default:
                        usage();
                }

        if (!flags) usage();
        flags |= COMPAT_MODE;

        progname = argv[0];
        (void) set_build_cmd(NULL, "build\t${MAKEDI}");
        (void) set_code_file(NULL, "codefile\tbuiltin.fth");
        srcfile = argv[optind];
        process_file(srcfile, 0);
        finish_symbols(showsyms);
        exit(0);
}