1d452cf5123cb6ac0a013a4dbd4dcceeb0da314dahrens#pragma prototyped

1d452cf5123cb6ac0a013a4dbd4dcceeb0da314dahrens

1d452cf5123cb6ac0a013a4dbd4dcceeb0da314dahrens#if !PROTO_STANDALONE

1d452cf5123cb6ac0a013a4dbd4dcceeb0da314dahrens

1d452cf5123cb6ac0a013a4dbd4dcceeb0da314dahrensstatic const char usage[] =

3b2aab18808792cbd248a12f1edf139b89833c13Matthew Ahrens

;

#include <ast.h>

#include <error.h>

#include <times.h>

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

#endif

#define PROTOMAIN 1

#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

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

#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", "/*",

};

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;

}

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;

}