cmd/proto/proto.c

/***********************************************************************
*                                                                      *
*               This software is part of the ast package               *
*          Copyright (c) 1990-2012 AT&T Intellectual Property          *
*                      and is licensed under the                       *
*                 Eclipse Public License, Version 1.0                  *
*                    by AT&T Intellectual Property                     *
*                                                                      *
*                A copy of the License is available at                 *
*          http://www.eclipse.org/org/documents/epl-v10.html           *
*         (with md5 checksum b35adb5213ca9657e911e9befb180842)         *
*                                                                      *
*              Information and Software Systems Research               *
*                            AT&T Research                             *
*                           Florham Park NJ                            *
*                                                                      *
*                 Glenn Fowler <gsf@research.att.com>                  *
*                                                                      *
***********************************************************************/
#pragma prototyped
/*
 * Glenn Fowler
 * AT&T Research
 *
 * proto - make prototyped C compatible with K&R, ANSI, C++
 *
 * output to stdout unless -r
 *
 * NOTE: coded for minimal library support
 */

#if !PROTO_STANDALONE

static const char usage[] =
"[-?\n@(#)$Id: proto (AT&T Research) 2012-02-20 $\n]"
USAGE_LICENSE
"[+NAME?proto - make prototyped C source compatible with K&R, ANSI and C++]"
"[+DESCRIPTION?\bproto\b converts ANSI C prototype constructs in \afile\a"
"   to constructs compatible with K&R C, ANSI C, and C++. Only files"
"   with the line \b#pragma prototyped\b appearing in one of the first"
"   64 lines are processed; other files are silently ignored. Output is"
"   written to the standard output unless the \b--replace\b option is"
"   specified, in which case \afile\a is modified in-place.]"

"[c:comment?\ab[m[e]]]]\a are the beginning, middle, and end comment"
"   characters. If \ae\a is omitted then it defaults to \ab\a. If \am\a is"
"   omitted then it defaults to \ab\a. Use \"\b/*\b\" for C comments,"
"   \"\b#\b\" for shell, and \"\b(*)\b\" for pascal. If \abme\a is \"\""
"   (the empty string) then the comment style is determined from the"
"   input \afile\a suffix; no notice is prepended if the comment"
"   style cannot be determined.]:[bme:=\"/*\"]"
"[d:disable?Disable prototype conversion but still emit the identification"
"   comment.]"
"[e:externs?All \bextern\b references are for \apackage\a. Some systems"
"   require special attributes for imported and exported dll data symbols."
"   If \b_BLD_\b\apackage\a is not defined then \bextern\b data references"
"   will be assigned the dll import attribute when supported by the local"
"   compiler.]:[package]"
"[f:force?Force conversion for files that do not contain"
"   \b#pragma prototyped\b.]"
"[h!:header?Emit the \bproto\b header definition preamble.]"
"[i:inverse?Specifies inverse proto: classic function definitions are"
"   converted to ANSI prototype form and non-ANSI directives are"
"   commented out. In this case files with the line"
"   \b#pragma noprototyped\b within the first 64 lines are silently"
"   ignored. If \b--header\b is also specified then only \bextern\b"
"   prototypes are emitted for each non-static function. This option"
"   requires that all classic function formal arguments be declared,"
"   i.e., omitted declarations for \bint\b formals will not generate"
"   the correct prototype. Typical usage would be to first run"
"   \bproto --inverse --header *.c\b to generate the external prototypes"
"   that should be placed in a \b.h\b file shared by \b*.c\b and then"
"   \bproto --inverse --replace *.c\b to convert the function prototypes"
"   in place. Note that prototype code conditioned on \b__STDC__\b will"
"   most likely confuse \b--inverse\b.]"
"[l:license?Generate a license notice comment at the top of the output"
"   controlled by one or more \aname\a=\avalue\a pairs in \afile\a."
"   If a \avalue\a contains space characters then it must be enclosed in"
"   either single or double quotes. \aname\a may"
"   be:]:[file]{"
"       [+type?The license type:]{"
"           [+bsd?The BSD open source license.]"
"           [+cpl?The Common Public License.]"
"           [+epl?The Eclipse Public License.]"
"           [+gpl?The GNU Public License.]"
"           [+mit?The MIT open source license.]"
"           [+inline?License text already in source.]"
"           [+none?No license.]"
"           [+noncommercial?Non-commercial use.]"
"           [+nonexclusive?Single person non-commercial use.]"
"           [+open?Open source.]"
"           [+proprietary?Only by individual agreement.]"
"           [+special?License text in \bnotice\b.]"
"           [+usage?License specific \boptget\b(3) usage strings.]"
"           [+verbose?Include the disclaimer notice if any.]"
"           [+zlib?The ZLIB open source license.]"
"       }"
"       [+author?A \b,\b separated list of \aname\a <\aemail\a> pairs.]"
"       [+class?The license class. The default values are:]{"
"           [+gpl?The GNU Public License.]"
"           [+open?\bwww.opensource.org\b sanctioned open source.]"
"           [+proprietary?Internal or non-disclosure use only.]"
"           [+special?Nonstandard license text and notices.]"
"       }"
"       [+corporation?Within the parent, e.g., \bAT&T\b.]"
"       [+company?Within the corporation, e.g., \bResearch\b.]"
"       [+location?Company location.]"
"       [+organization?Within the company, e.g., \bNetwork Services"
"           Research Department\b.]"
"       [+notice?\btype=special\b notice text with embedded newlines"
"           or additional notice text listed by \btype=verbose\b.]"
"       [+package?The generic software package name, e.g., \bast\b.]"
"       [+parent?They own it all, e.g., \bAT&T\b.]"
"       [+since?The year the software was first released.]"
"       [+source?The year the input files was modified.]"
"       [+start?The year the license was first applied to the software.]"
"       [+url?The URL of the detailed license text, e.g.,"
"       \bhttp://www.research.att.com/sw/license/open-ast.html\b.]"
"       [+urlmd5?The \bmd5sum\b(1) of the downloaded URL data. Note that"
"           the downloaded data may have embedded \b\\r\b not present"
"           in the original source.]"
"       [+query=\atext\a?If \atext\a is one of the \aname\as above"
"           then its value is expanded, otherwise"
"           \b${\b\aname\a\b}\b in \atext\a is expanded. The"
"           result is printed as a line on the standard output"
"           and \bproto\b exits. This should only be used via"
"           \b--options\b.]"
"}"
"[n:sync?Output C style line syncs to retain the original line structure.]"
"[o:options?Additional space or \b,\b separated \aname=value\a \b--license\b"
"   options.]:[name=value,...]"
"[p:pass?Pass input to output, even if not converted.]"
"[r:replace?Process the input files in place; original information is"
"   replaced by \bproto\b output.]"
"[s:include?Output \b#include <prototyped.h>\b rather than expanding the"
"   equivalent inline.]"
"[t:test?Enable test code. Use at your own risk.]"
"[v:verbose?List each file as it is processed.]"
"[x:externalize?Convert \bstatic\b function attributes to \bextern\b.  Used"
"   for analysis programs that only instrument \bextern\b functions.]"
"[z:zap?Disable conversion and remove \b#pragma prototyped\b.]"
"[C:copy?Convert each input \afile\a to \adirectory\a/\afile\a,"
"   making intermediate directories as necessary.]:[directory]"
"[L:list?Input file names are read one per line from \afile\a.]:[file]"
"[P|+:plusplus?Convert \bextern()\b to \bextern(...)\b.]"
"[S:shell?Equivalent to \b--comment=\"#\".]"

"\n"
"\nfile ...\n"
"\n"

"[+SEE ALSO?\bcc\b(1), \bcpp\b(1)]"
;

#include <ast.h>
#include <error.h>
#include <times.h>

#define utime(p,t)  touch(p,t[0],t[1],0)

#endif

#define PROTOMAIN   1

/*DELAY_CONTROL*/

#ifndef __STDC__
#ifndef creat
#define creat       _huh_creat
#endif
#if PROTO_STANDALONE
#ifndef access
#define access      _huh_access
#endif
#ifndef ctime
#define ctime       _huh_ctime
#endif
#ifndef mkdir
#define mkdir       _huh_mkdir
#endif
#endif
#endif

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#if PROTO_STANDALONE
#include <stdio.h>
#else
#include <time.h>
#endif

#ifndef __STDC__
#undef  access
#undef  ctime
#undef  creat
#undef  mkdir
#endif

#ifndef O_RDONLY
#define O_RDONLY    0
#endif

#ifndef S_IRUSR
#define S_IRUSR     0400
#endif
#ifndef S_IWUSR
#define S_IWUSR     0200
#endif
#ifndef S_IXUSR
#define S_IXUSR     0100
#endif
#ifndef S_IRGRP
#define S_IRGRP     0040
#endif
#ifndef S_IWGRP
#define S_IWGRP     0020
#endif
#ifndef S_IXGRP
#define S_IXGRP     0010
#endif
#ifndef S_IROTH
#define S_IROTH     0004
#endif
#ifndef S_IWOTH
#define S_IWOTH     0002
#endif
#ifndef S_IXOTH
#define S_IXOTH     0001
#endif

#ifndef __STDC__
#if !_WIN32 && !_WINIX
#define remove(x)   unlink(x)
#define rename(x,y) ((link(x,y)||remove(x))?-1:0)
#endif

#if PROTO_STANDALONE
extern int  access(const char*, int);
extern int  mkdir(const char*, int);
#endif

#endif

#if PROTO_STANDALONE
extern int  utime(const char*, time_t*);
#endif

/*
 * rename newfile to oldfile
 * preserve!=0 preserves atime,mtime
 */

int
replace(const char* newfile, const char* oldfile, int preserve)
{
    struct stat st;
    time_t      ut[2];

    if (stat(oldfile, &st))
    {
        if (preserve)
            return -1;
        st.st_mode = 0;
    }
    if (remove(oldfile) || rename(newfile, oldfile))
        return -1;
    if (st.st_mode &= (S_IRUSR|S_IWUSR|S_IXUSR|S_IRGRP|S_IWGRP|S_IXGRP|S_IROTH|S_IWOTH|S_IXOTH))
        chmod(oldfile, st.st_mode);
    if (preserve)
    {
        ut[0] = st.st_atime;
        ut[1] = st.st_mtime;
        preserve = utime(oldfile, ut);
    }
    return preserve;
}

#undef  utime
#define utime       ______utime

/*NODELAY_CONTROL*/

#include "ppproto.c"

#define PROTO_ERROR (PROTO_USER<<0)
#define PROTO_REPLACE   (PROTO_USER<<1)
#define PROTO_VERBOSE   (PROTO_USER<<2)

static int
proto(char* file, char* license, char* options, char* package, char* copy, char* comment, int flags)
{
    char*       b;
    char*       e;
    char*       p;
    int     n;
    int     m;
    int     x;
    int     fd;
    char        buf[1024];

    if (file && access(file, 4))
        proto_error(NiL, 2, file, "not found");
    else if (b = pppopen(file, 0, license, options, package, comment, flags))
    {
        if (!file)
            fd = 1;
        else if (flags & PROTO_REPLACE)
        {
            e = file + strlen(file) - 1;
            x = *e;
            *e = '_';
            if ((fd = creat(file, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)) < 0)
            {
                proto_error(b, 2, file, "cannot create temporary file");
                pppclose(b);
                return flags | PROTO_ERROR;
            }
            *e = x;
        }
        else if (copy)
        {
            if (((n = strlen(copy)) + strlen(file) + 2) > sizeof(buf))
            {
                proto_error(b, 2, copy, "copy path too long");
                pppclose(b);
                return flags | PROTO_ERROR;
            }
            strcpy(buf, copy);
            e = buf + n;
            if (*file != '/')
                *e++ = '/';
            strcpy(e, file);
            if ((fd = creat(buf, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)) < 0)
            {
                for (e = buf; *e == '/'; e++);
                do
                {
                    if (*e == '/')
                    {
                        *e = 0;
                        if (access(buf, 0) && mkdir(buf, S_IRUSR|S_IWUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH))
                        {
                            proto_error(b, 2, buf, "cannot create copy directory");
                            pppclose(b);
                            return flags | PROTO_ERROR;
                        }
                        *e = '/';
                    }
                } while (*e++);
                if ((fd = creat(buf, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)) < 0)
                {
                    proto_error(b, 2, buf, "cannot create copy file");
                    pppclose(b);
                    return flags | PROTO_ERROR;
                }
            }
            file = buf;
        }
        else
            fd = 1;
        if (file && (flags & PROTO_VERBOSE))
            proto_error(b, 0, "convert to", file);
        while ((n = pppread(b)) > 0)
        {
            p = b;
            for (;;)
            {
                if ((m = write(fd, p, n)) <= 0)
                {
                    proto_error(b, 2, "write error", NiL);
                    flags |= PROTO_ERROR;
                    break;
                }
                if ((n -= m) <= 0)
                    break;
                p += m;
            }
            if (m < 0)
                break;
        }
        if (fd > 1)
            close(fd);
        if (file && (flags & PROTO_REPLACE))
        {
            *e = '_';
            strcpy(b, file);
            *e = x;
            if (replace(b, file, !(flags & PROTO_CLASSIC)))
                proto_error(b, 2, "cannot rename to", file);
        }
        pppclose(b);
    }
    return flags;
}

#if !PROTO_STANDALONE
#undef  error
#endif

typedef struct Sufcom_s
{
    char        suffix[4];
    char        comment[4];
} Sufcom_t;

static const Sufcom_t   sufcom[] =
{
    "c",        "/*",
    "cpp",      "/*",
    "cxx",      "/*",
    "c++",      "/*",
    "C",        "/*",
    "CPP",      "/*",
    "CXX",      "/*",
    "C++",      "/*",
    "f",        "C",
    "F",        "C",
    "h",        "/*",
    "hpp",      "/*",
    "hxx",      "/*",
    "H",        "/*",
    "HPP",      "/*",
    "HXX",      "/*",
    "ksh",      "#",
    "KSH",      "#",
    "l",        "/*",
    "L",        "/*",
    "p",        "(*)",
    "pas",      "(*)",
    "P",        "(*)",
    "PAS",      "(*)",
    "pl",       "#",
    "PL",       "#",
    "pl1",      "/*",
    "pli",      "/*",
    "PL1",      "/*",
    "PLI",      "/*",
    "sh",       "#",
    "SH",       "#",
    "sml",      "(*)",
    "SML",      "(*)",
    "y",        "/*",
    "Y",        "/*",
};

/*
 * if !comment || !*comment then return a value compatible with file
 */

static char*
type(register char* file, char* comment)
{
    register char*  suffix;
    register int    i;

    if (file && (!comment || !*comment))
    {
        suffix = 0;
        while (*file)
            if (*file++ == '.')
                suffix = file;
        if (suffix && strlen(suffix) <= 3)
            for (i = 0; i < sizeof(sufcom) / sizeof(sufcom[0]); i++)
                if (!strcmp(suffix, sufcom[i].suffix))
                    return (char*)sufcom[i].comment;
    }
    return comment;
}

int
main(int argc, char** argv)
{
    char*       b;
    char*       file;
    int     fd;
    int     n;
    char*       op;
    char*       oe;
    char*       comment = 0;
    char*       copy = 0;
    char*       list = 0;
    char*       license = 0;
    char*       options = 0;
    char*       package = 0;
    int     flags = PROTO_HEADER;
    char        buf[1024];
    char        opt[4 * 1024];

    NoP(argc);
#if PROTO_STANDALONE
    while ((file = *++argv) && *file == '-' && *(file + 1))
    {
        for (;;)
        {
            switch (*++file)
            {
            case 0:
                break;
            case 'c':
                if (!*(comment = ++file))
                    comment = *++argv;
                break;
            case 'd':
                flags |= PROTO_DISABLE;
                continue;
            case 'e':
                if (!*(package = ++file) && !(package = *++argv))
                {
                    file = "??";
                    continue;
                }
                break;
            case 'f':
                flags |= PROTO_FORCE;
                continue;
            case 'h':
                flags &= ~PROTO_HEADER;
                continue;
            case 'i':
                flags |= PROTO_CLASSIC;
                continue;
            case 'l':
                if (!*(license = ++file) && !(license = *++argv))
                {
                    file = "??";
                    continue;
                }
                break;
            case 'n':
                flags |= PROTO_LINESYNC;
                continue;
            case 'o':
                if (!*(b = ++file) && !(b = *++argv))
                {
                    file = "??";
                    continue;
                }
                if (!options)
                {
                    options = op = opt;
                    oe = op + sizeof(opt) - 1;
                }
                n = strlen(b);
                if ((n + 1) >= (oe - op))
                    proto_error(NiL, 3, b, "too many options");
                else
                {
                    *op++ = '\n';
                    memcpy(op, b, n + 1);
                    op += n;
                }
                break;
            case 'p':
                flags |= PROTO_PASS;
                continue;
            case 'r':
                flags |= PROTO_REPLACE;
                continue;
            case 's':
                flags |= PROTO_INCLUDE;
                continue;
            case 't':
                flags |= PROTO_TEST;
                continue;
            case 'v':
                flags |= PROTO_VERBOSE;
                continue;
            case 'x':
                flags |= PROTO_EXTERNALIZE;
                continue;
            case 'z':
                flags |= PROTO_DISABLE|PROTO_NOPRAGMA;
                continue;
            case 'C':
                if (!*(copy = ++file) && !(copy = *++argv))
                {
                    file = "??";
                    continue;
                }
                break;
            case 'L':
                if (!*(list = ++file) && !(list = *++argv))
                {
                    file = "??";
                    continue;
                }
                break;
            case 'P':
            case '+':
                flags |= PROTO_PLUSPLUS;
                continue;
            case 'S':
                comment = "#";
                continue;
            default:
                proto_error(NiL, 2, file, "unknown option");
                /*FALLTHROUGH*/
            case '?':
                b = "Usage: proto [-dfhinprstvzP+S] [-C directory] [-e package] [-l file]\n             [-o \"name='value' ...\"] [-L file] file ...\n";
                write(2, b, strlen(b));
                return 2;
            }
            break;
        }
    }
#else
    error_info.id = "proto";
    for (;;)
    {
        switch (optget(argv, usage))
        {
        case 'c':
            comment = opt_info.arg;
            continue;
        case 'd':
            flags |= PROTO_DISABLE;
            continue;
        case 'e':
            package = opt_info.arg;
            continue;
        case 'f':
            flags |= PROTO_FORCE;
            continue;
        case 'h':
            flags &= ~PROTO_HEADER;
            continue;
        case 'i':
            flags |= PROTO_CLASSIC;
            continue;
        case 'l':
            license = opt_info.arg;
            continue;
        case 'n':
            flags |= PROTO_LINESYNC;
            continue;
        case 'o':
            if (!options)
            {
                options = op = opt;
                oe = op + sizeof(opt) - 1;
            }
            n = strlen(opt_info.arg);
            if ((n + 1) >= (oe - op))
                error(3, "%s: too many options", opt_info.arg);
            else
            {
                *op++ = '\n';
                memcpy(op, opt_info.arg, n + 1);
                op += n;
            }
            continue;
        case 'p':
            flags |= PROTO_PASS;
            continue;
        case 'r':
            flags |= PROTO_REPLACE;
            continue;
        case 's':
            flags |= PROTO_INCLUDE;
            continue;
        case 't':
            flags |= PROTO_TEST;
            continue;
        case 'v':
            flags |= PROTO_VERBOSE;
            continue;
        case 'x':
            flags |= PROTO_EXTERNALIZE;
            continue;
        case 'z':
            flags |= PROTO_DISABLE|PROTO_NOPRAGMA;
            continue;
        case 'C':
            copy = opt_info.arg;
            continue;
        case 'L':
            list = opt_info.arg;
            continue;
        case 'P':
            flags |= PROTO_PLUSPLUS;
            continue;
        case 'S':
            comment = "#";
            continue;
        case '?':
            error(ERROR_USAGE|4, "%s", opt_info.arg);
            continue;
        case ':':
            error(2, "%s", opt_info.arg);
            continue;
        }
        break;
    }
    if (error_info.errors)
        error(ERROR_USAGE|4, "%s", optusage(NiL));
    argv += opt_info.index;
    file = *argv;
#endif
    if (list)
    {
        if (*list == '-' && !*(list + 1))
            fd = 0;
        else if ((fd = open(list, O_RDONLY)) < 0)
            proto_error(NiL, 3, list, "not found");
        do
        {
            for (b = buf; (n = read(fd, b, 1)) > 0 && *b != '\n' && b < &buf[sizeof(buf) - 1]; b++);
            if (b > buf)
            {
                *b = 0;
                flags = proto(buf, license, options, package, copy, type(buf, comment), flags);
            }
        } while (n > 0);
        if (fd > 0)
            close(fd);
    }
    if (file)
        do flags = proto(file, license, options, package, copy, type(file, comment), flags); while (file = *++argv);
    else if (!list)
        flags = proto(file, license, options, package, copy, type(file, comment), flags);
    return errors ? 1 : (flags & PROTO_ERROR) ? 2 : 0;
}