From d1a6ac6d75ccd1515028b6e63eb1333588d0fc48 Mon Sep 17 00:00:00 2001 From: Theodore Tso Date: Tue, 13 Apr 1993 19:56:34 +0000 Subject: [PATCH] *** empty log message *** git-svn-id: svn://anonsvn.mit.edu/krb5/trunk@2533 dc483132-0cff-0310-8789-dd5450dbe970 --- src/util/et/com_err.c | 133 ++++++++++++ src/util/et/com_err.h | 36 ++++ src/util/et/compile_et.c | 359 +++++++++++++++++++++++++++++++ src/util/et/compiler.h | 20 ++ src/util/et/error_message.c | 71 ++++++ src/util/et/error_table.h | 30 +++ src/util/et/et_c.awk | 149 +++++++++++++ src/util/et/et_h.awk | 99 +++++++++ src/util/et/et_lex.lex.l | 26 +++ src/util/et/et_name.c | 43 ++++ src/util/et/init_et.c | 55 +++++ src/util/et/internal.h | 22 ++ src/util/et/mit-sipb-copyright.h | 19 ++ src/util/et/test_et.c | 47 ++++ 14 files changed, 1109 insertions(+) create mode 100644 src/util/et/com_err.c create mode 100644 src/util/et/com_err.h create mode 100644 src/util/et/compile_et.c create mode 100644 src/util/et/compiler.h create mode 100644 src/util/et/error_message.c create mode 100644 src/util/et/error_table.h create mode 100644 src/util/et/et_c.awk create mode 100644 src/util/et/et_h.awk create mode 100644 src/util/et/et_lex.lex.l create mode 100644 src/util/et/et_name.c create mode 100644 src/util/et/init_et.c create mode 100644 src/util/et/internal.h create mode 100644 src/util/et/mit-sipb-copyright.h create mode 100644 src/util/et/test_et.c diff --git a/src/util/et/com_err.c b/src/util/et/com_err.c new file mode 100644 index 000000000..78b91ce0a --- /dev/null +++ b/src/util/et/com_err.c @@ -0,0 +1,133 @@ +/* + * Copyright 1987, 1988 by MIT Student Information Processing Board. + * + * For copyright info, see mit-sipb-copyright.h. + */ + +#include +#include "mit-sipb-copyright.h" + +/* + * If we're using gcc, *always* use stdarg. However, there are a small + * number of native platforms (sun3 and sun4, sunos41) that don't have + * stdarg, but only have varargs... they can define VARARGS in the config + * files, but we'll turn it off here for gcc. + */ + +#ifdef __GNUC__ +#undef VARARGS +#endif + +#if defined(__STDC__) && !defined(VARARGS) +#include +#else +#include +#endif + +#include "error_table.h" +#include "internal.h" + +/* + * Protect us from header version (externally visible) of com_err, so + * we can survive in a environment. I think. + */ +#define com_err com_err_external +#include "com_err.h" +#undef com_err + +#if ! lint +static const char rcsid[] = + "$Header$"; +#endif /* ! lint */ + +static void +#ifdef __STDC__ + default_com_err_proc (const char *whoami, long code, const char *fmt, va_list args) +#else + default_com_err_proc (whoami, code, fmt, args) + const char *whoami; + long code; + const char *fmt; + va_list args; +#endif +{ + if (whoami) { + fputs(whoami, stderr); + fputs(": ", stderr); + } + if (code) { + fputs(error_message(code), stderr); + fputs(" ", stderr); + } + if (fmt) { + vfprintf (stderr, fmt, args); + } + putc('\n', stderr); + /* should do this only on a tty in raw mode */ + putc('\r', stderr); + fflush(stderr); +} + +#ifdef __STDC__ +typedef void (*errf) (const char *, long, const char *, va_list); +#else +typedef void (*errf) (); +#endif + +errf com_err_hook = default_com_err_proc; + +void com_err_va (whoami, code, fmt, args) + const char *whoami; + long code; + const char *fmt; + va_list args; +{ + (*com_err_hook) (whoami, code, fmt, args); +} + +#ifndef VARARGS +void com_err (const char *whoami, + long code, + const char *fmt, ...) +{ +#else +void com_err (va_alist) + va_dcl +{ + const char *whoami, *fmt; + long code; +#endif + va_list pvar; + + if (!com_err_hook) + com_err_hook = default_com_err_proc; +#ifdef VARARGS + va_start (pvar); + whoami = va_arg (pvar, const char *); + code = va_arg (pvar, long); + fmt = va_arg (pvar, const char *); +#else + va_start(pvar, fmt); +#endif + com_err_va (whoami, code, fmt, pvar); + va_end(pvar); +} + +errf set_com_err_hook (new_proc) + errf new_proc; +{ + errf x = com_err_hook; + + if (new_proc) + com_err_hook = new_proc; + else + com_err_hook = default_com_err_proc; + + return x; +} + +errf reset_com_err_hook () { + errf x = com_err_hook; + com_err_hook = default_com_err_proc; + return x; +} diff --git a/src/util/et/com_err.h b/src/util/et/com_err.h new file mode 100644 index 000000000..7bea01004 --- /dev/null +++ b/src/util/et/com_err.h @@ -0,0 +1,36 @@ +/* + * Header file for common error description library. + * + * Copyright 1988, Student Information Processing Board of the + * Massachusetts Institute of Technology. + * + * For copyright and distribution info, see the documentation supplied + * with this package. + */ + +#ifndef __COM_ERR_H + +#ifdef __STDC__ +#ifndef __HIGHC__ /* gives us STDC but not stdarg */ +#include +#else +#include +#endif +/* ANSI C -- use prototypes etc */ +void com_err (const char *, long, const char *, ...); +char const *error_message (long); +void (*com_err_hook) (const char *, long, const char *, va_list); +void (*set_com_err_hook (void (*) (const char *, long, const char *, va_list))) + (const char *, long, const char *, va_list); +void (*reset_com_err_hook ()) (const char *, long, const char *, va_list); +#else +/* no prototypes */ +void com_err (); +char *error_message (); +void (*com_err_hook) (); +void (*set_com_err_hook ()) (); +void (*reset_com_err_hook ()) (); +#endif + +#define __COM_ERR_H +#endif /* ! defined(__COM_ERR_H) */ diff --git a/src/util/et/compile_et.c b/src/util/et/compile_et.c new file mode 100644 index 000000000..79bd4c5b1 --- /dev/null +++ b/src/util/et/compile_et.c @@ -0,0 +1,359 @@ +/* + * + * Copyright 1986, 1987, 1988 + * by MIT Student Information Processing Board. + * + * For copyright info, see "mit-sipb-copyright.h". + * + */ + +#include +#include +#include +#include +#include +#include "mit-sipb-copyright.h" +#include "compiler.h" + +#ifndef __STDC__ +#define const +#endif + +#ifndef lint +static const char copyright[] = + "Copyright 1987,1988 by MIT Student Information Processing Board"; + +static const char rcsid_compile_et_c[] = + "$Header$"; +#endif + +extern char *gensym(); +extern char *current_token; +extern int table_number, current; +char buffer[BUFSIZ]; +char *table_name = (char *)NULL; +FILE *hfile, *cfile; + +/* C library */ +extern char *malloc(); +extern int errno; + +/* lex stuff */ +extern FILE *yyin; +extern int yylineno; + +char * xmalloc (size) unsigned int size; { + char * p = malloc (size); + if (!p) { + perror (whoami); + exit (1); + } + return p; +} + +static int check_arg (str_list, arg) char const *const *str_list, *arg; { + while (*str_list) + if (!strcmp(arg, *str_list++)) + return 1; + return 0; +} + +static const char *const debug_args[] = { + "d", + "debug", + 0, +}; + +static const char *const lang_args[] = { + "lang", + "language", + 0, +}; + +static const char *const language_names[] = { + "C", + "K&R C", + "C++", + 0, +}; + +static const char * const c_src_prolog[] = { + "static const char * const text[] = {\n", + 0, +}; + +static const char * const krc_src_prolog[] = { + "#ifdef __STDC__\n", + "#define NOARGS void\n", + "#else\n", + "#define NOARGS\n", + "#define const\n", + "#endif\n\n", + "static const char * const text[] = {\n", + 0, +}; + +static const char *const struct_def[] = { + "struct error_table {\n", + " char const * const * msgs;\n", + " long base;\n", + " int n_msgs;\n", + "};\n", + "struct et_list {\n", + " struct et_list *next;\n", + " const struct error_table * table;\n", + "};\n", + "extern struct et_list *_et_list;\n", + "\n", 0, +}; + +static const char warning[] = + "/*\n * %s:\n * This file is automatically generated; please do not edit it.\n */\n"; + +/* pathnames */ +char c_file[MAXPATHLEN]; /* output file */ +char h_file[MAXPATHLEN]; /* output */ + +static void usage () { + fprintf (stderr, "%s: usage: %s ERROR_TABLE\n", + whoami, whoami); + exit (1); +} + +static void dup_err (type, one, two) char const *type, *one, *two; { + fprintf (stderr, "%s: multiple %s specified: `%s' and `%s'\n", + whoami, type, one, two); + usage (); +} + +int main (argc, argv) int argc; char **argv; { + char *p, *ename; + int len; + char const * const *cpp; + int got_language = 0; + + /* argument parsing */ + debug = 0; + filename = 0; + whoami = argv[0]; + p = strrchr (whoami, '/'); + if (p) + whoami = p+1; + while (argv++, --argc) { + char *arg = *argv; + if (arg[0] != '-') { + if (filename) + dup_err ("filenames", filename, arg); + filename = arg; + } + else { + arg++; + if (check_arg (debug_args, arg)) + debug++; + else if (check_arg (lang_args, arg)) { + got_language++; + arg = *++argv, argc--; + if (!arg) + usage (); + if (language) + dup_err ("languanges", language_names[(int)language], arg); +#define check_lang(x,v) else if (!strcasecmp(arg,x)) language = v + check_lang ("c", lang_C); + check_lang ("ansi_c", lang_C); + check_lang ("ansi-c", lang_C); + check_lang ("krc", lang_KRC); + check_lang ("kr_c", lang_KRC); + check_lang ("kr-c", lang_KRC); + check_lang ("k&r-c", lang_KRC); + check_lang ("k&r_c", lang_KRC); + check_lang ("c++", lang_CPP); + check_lang ("cplusplus", lang_CPP); + check_lang ("c-plus-plus", lang_CPP); +#undef check_lang + else { + fprintf (stderr, "%s: unknown language name `%s'\n", + whoami, arg); + fprintf (stderr, "\tpick one of: C K&R-C\n"); + exit (1); + } + } + else { + fprintf (stderr, "%s: unknown control argument -`%s'\n", + whoami, arg); + usage (); + } + } + } + if (!filename) + usage (); + if (!got_language) + language = lang_KRC; + else if (language == lang_CPP) { + fprintf (stderr, "%s: Sorry, C++ support is not yet finished.\n", + whoami); + exit (1); + } + + p = xmalloc (strlen (filename) + 5); + strcpy (p, filename); + filename = p; + p = strrchr(filename, '/'); + if (p == (char *)NULL) + p = filename; + else + p++; + ename = p; + len = strlen (ename); + p += len - 3; + if (strcmp (p, ".et")) + p += 3; + *p++ = '.'; + /* now p points to where "et" suffix should start */ + /* generate new filenames */ + strcpy (p, "c"); + strcpy (c_file, ename); + *p = 'h'; + strcpy (h_file, ename); + strcpy (p, "et"); + + yyin = fopen(filename, "r"); + if (!yyin) { + perror(filename); + exit(1); + } + + hfile = fopen(h_file, "w"); + if (hfile == (FILE *)NULL) { + perror(h_file); + exit(1); + } + fprintf (hfile, warning, h_file); + + cfile = fopen(c_file, "w"); + if (cfile == (FILE *)NULL) { + perror(c_file); + exit(1); + } + fprintf (cfile, warning, c_file); + + /* prologue */ + if (language == lang_C) + cpp = c_src_prolog; + else if (language == lang_KRC) + cpp = krc_src_prolog; + else + abort (); + while (*cpp) + fputs (*cpp++, cfile); + + /* parse it */ + yyparse(); + fclose(yyin); /* bye bye input file */ + + fputs (" 0\n};\n\n", cfile); + for (cpp = struct_def; *cpp; cpp++) + fputs (*cpp, cfile); + fprintf(cfile, + "static const struct error_table et = { text, %ldL, %d };\n\n", + table_number, current); + fputs("static struct et_list link = { 0, 0 };\n\n", + cfile); + fprintf(cfile, "void initialize_%s_error_table (%s) {\n", + table_name, (language == lang_C) ? "void" : "NOARGS"); + fputs(" if (!link.table) {\n", cfile); + fputs(" link.next = _et_list;\n", cfile); + fputs(" link.table = &et;\n", cfile); + fputs(" _et_list = &link;\n", cfile); + fputs(" }\n", cfile); + fputs("}\n", cfile); + fclose(cfile); + + fprintf (hfile, "extern void initialize_%s_error_table ();\n", + table_name); + fprintf (hfile, "#define ERROR_TABLE_BASE_%s (%ldL)\n", + table_name, table_number); + /* compatibility... */ + fprintf (hfile, "\n/* for compatibility with older versions... */\n"); + fprintf (hfile, "#define init_%s_err_tbl initialize_%s_error_table\n", + table_name, table_name); + fprintf (hfile, "#define %s_err_base ERROR_TABLE_BASE_%s\n", table_name, + table_name); + fclose(hfile); /* bye bye include file */ + + return 0; +} + +int yyerror(s) char *s; { + fputs(s, stderr); +#ifdef NO_YYLINENO + fprintf(stderr, "\nLast token was '%s'\n", current_token); +#else + fprintf(stderr, "\nLine number %d; last token was '%s'\n", + yylineno, current_token); +#endif +} + +#ifdef NEED_STRCASECMP +/* Need strcasecmp for this machine */ +/* + * Copyright (c) 1987 Regents of the University of California. + * All rights reserved. The Berkeley software License Agreement + * specifies the terms and conditions for redistribution. + */ + +#if defined(LIBC_SCCS) && !defined(lint) +static char sccsid[] = "@(#)strcasecmp.c 1.3 (Berkeley) 8/3/87"; +#endif LIBC_SCCS and not lint + +/* + * This array is designed for mapping upper and lower case letter + * together for a case independent comparison. The mappings are + * based upon ascii character sequences. + */ +static char charmap[] = { + '\000', '\001', '\002', '\003', '\004', '\005', '\006', '\007', + '\010', '\011', '\012', '\013', '\014', '\015', '\016', '\017', + '\020', '\021', '\022', '\023', '\024', '\025', '\026', '\027', + '\030', '\031', '\032', '\033', '\034', '\035', '\036', '\037', + '\040', '\041', '\042', '\043', '\044', '\045', '\046', '\047', + '\050', '\051', '\052', '\053', '\054', '\055', '\056', '\057', + '\060', '\061', '\062', '\063', '\064', '\065', '\066', '\067', + '\070', '\071', '\072', '\073', '\074', '\075', '\076', '\077', + '\100', '\141', '\142', '\143', '\144', '\145', '\146', '\147', + '\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157', + '\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167', + '\170', '\171', '\172', '\133', '\134', '\135', '\136', '\137', + '\140', '\141', '\142', '\143', '\144', '\145', '\146', '\147', + '\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157', + '\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167', + '\170', '\171', '\172', '\173', '\174', '\175', '\176', '\177', + '\200', '\201', '\202', '\203', '\204', '\205', '\206', '\207', + '\210', '\211', '\212', '\213', '\214', '\215', '\216', '\217', + '\220', '\221', '\222', '\223', '\224', '\225', '\226', '\227', + '\230', '\231', '\232', '\233', '\234', '\235', '\236', '\237', + '\240', '\241', '\242', '\243', '\244', '\245', '\246', '\247', + '\250', '\251', '\252', '\253', '\254', '\255', '\256', '\257', + '\260', '\261', '\262', '\263', '\264', '\265', '\266', '\267', + '\270', '\271', '\272', '\273', '\274', '\275', '\276', '\277', + '\300', '\341', '\342', '\343', '\344', '\345', '\346', '\347', + '\350', '\351', '\352', '\353', '\354', '\355', '\356', '\357', + '\360', '\361', '\362', '\363', '\364', '\365', '\366', '\367', + '\370', '\371', '\372', '\333', '\334', '\335', '\336', '\337', + '\340', '\341', '\342', '\343', '\344', '\345', '\346', '\347', + '\350', '\351', '\352', '\353', '\354', '\355', '\356', '\357', + '\360', '\361', '\362', '\363', '\364', '\365', '\366', '\367', + '\370', '\371', '\372', '\373', '\374', '\375', '\376', '\377', +}; + +strcasecmp(s1, s2) + register char *s1, *s2; +{ + register char *cm = charmap; + + while (cm[*s1] == cm[*s2++]) + if (*s1++ == '\0') + return(0); + return(cm[*s1] - cm[*--s2]); +} + +#endif diff --git a/src/util/et/compiler.h b/src/util/et/compiler.h new file mode 100644 index 000000000..43752e286 --- /dev/null +++ b/src/util/et/compiler.h @@ -0,0 +1,20 @@ +/* + * definitions common to the source files of the error table compiler + */ + +#ifndef __STDC__ +/* loser */ +#undef const +#define const +#endif + +enum lang { + lang_C, /* ANSI C (default) */ + lang_KRC, /* C: ANSI + K&R */ + lang_CPP /* C++ */ +}; + +int debug; /* dump debugging info? */ +char *filename; /* error table source */ +enum lang language; +const char *whoami; diff --git a/src/util/et/error_message.c b/src/util/et/error_message.c new file mode 100644 index 000000000..21c926caa --- /dev/null +++ b/src/util/et/error_message.c @@ -0,0 +1,71 @@ +/* + * $Header$ + * $Source$ + * $Locker$ + * + * Copyright 1987 by the Student Information Processing Board + * of the Massachusetts Institute of Technology + * + * For copyright info, see "mit-sipb-copyright.h". + */ + +#include +#include "error_table.h" +#include "mit-sipb-copyright.h" +#include "internal.h" + +static const char rcsid[] = + "$Header$"; +static const char copyright[] = + "Copyright 1986, 1987, 1988 by the Student Information Processing Board\nand the department of Information Systems\nof the Massachusetts Institute of Technology"; + +static char buffer[25]; + +struct et_list * _et_list = (struct et_list *) NULL; + +const char * error_message (code) +long code; +{ + int offset; + struct et_list *et; + int table_num; + int started = 0; + char *cp; + + offset = code & ((1<next) { + if (et->table->base == table_num) { + /* This is the right table */ + if (et->table->n_msgs <= offset) + goto oops; + return(et->table->msgs[offset]); + } + } +oops: + strcpy (buffer, "Unknown code "); + if (table_num) { + strcat (buffer, error_table_name (table_num)); + strcat (buffer, " "); + } + for (cp = buffer; *cp; cp++) + ; + if (offset >= 100) { + *cp++ = '0' + offset / 100; + offset %= 100; + started++; + } + if (started || offset >= 10) { + *cp++ = '0' + offset / 10; + offset %= 10; + } + *cp++ = '0' + offset; + *cp = '\0'; + return(buffer); +} diff --git a/src/util/et/error_table.h b/src/util/et/error_table.h new file mode 100644 index 000000000..78f7db200 --- /dev/null +++ b/src/util/et/error_table.h @@ -0,0 +1,30 @@ +/* + * Copyright 1988 by the Student Information Processing Board of the + * Massachusetts Institute of Technology. + * + * For copyright info, see mit-sipb-copyright.h. + */ + +#ifndef _ET_H +/* Are we using ANSI C? */ +#ifndef __STDC__ +#define const +#endif +extern int errno; +struct error_table { + char const * const * msgs; + long base; + int n_msgs; +}; +struct et_list { + struct et_list *next; + const struct error_table *table; +}; +extern struct et_list * _et_list; + +#define ERRCODE_RANGE 8 /* # of bits to shift table number */ +#define BITS_PER_CHAR 6 /* # bits to shift per character in name */ + +extern const char *error_table_name(); +#define _ET_H +#endif diff --git a/src/util/et/et_c.awk b/src/util/et/et_c.awk new file mode 100644 index 000000000..afb440474 --- /dev/null +++ b/src/util/et/et_c.awk @@ -0,0 +1,149 @@ +BEGIN { +char_shift=64 +## "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_"; +c2n["A"]=1 +c2n["B"]=2 +c2n["C"]=3 +c2n["D"]=4 +c2n["E"]=5 +c2n["F"]=6 +c2n["G"]=7 +c2n["H"]=8 +c2n["I"]=9 +c2n["J"]=10 +c2n["K"]=11 +c2n["L"]=12 +c2n["M"]=13 +c2n["N"]=14 +c2n["O"]=15 +c2n["P"]=16 +c2n["Q"]=17 +c2n["R"]=18 +c2n["S"]=19 +c2n["T"]=20 +c2n["U"]=21 +c2n["V"]=22 +c2n["W"]=23 +c2n["X"]=24 +c2n["Y"]=25 +c2n["Z"]=26 +c2n["a"]=27 +c2n["b"]=28 +c2n["c"]=29 +c2n["d"]=30 +c2n["e"]=31 +c2n["f"]=32 +c2n["g"]=33 +c2n["h"]=34 +c2n["i"]=35 +c2n["j"]=36 +c2n["k"]=37 +c2n["l"]=38 +c2n["m"]=39 +c2n["n"]=40 +c2n["o"]=41 +c2n["p"]=42 +c2n["q"]=43 +c2n["r"]=44 +c2n["s"]=45 +c2n["t"]=46 +c2n["u"]=47 +c2n["v"]=48 +c2n["w"]=49 +c2n["x"]=50 +c2n["y"]=51 +c2n["z"]=52 +c2n["0"]=53 +c2n["1"]=54 +c2n["2"]=55 +c2n["3"]=56 +c2n["4"]=57 +c2n["5"]=58 +c2n["6"]=59 +c2n["7"]=60 +c2n["8"]=61 +c2n["9"]=62 +c2n["_"]=63 +} +/^#/ { next } +/^[ \t]*(error_table|et)[ \t]+[a-zA-Z][a-zA-Z0-9_]+/ { + table_number = 0 + table_name = $2 + for(i=1; i<=length(table_name); i++) { + table_number=(table_number*char_shift)+c2n[substr(table_name,i,1)] + } + table_number_base=table_number*256 + if(table_number_base > 128*256*256*256) { + table_number_base -= 256*256*256*256 + } + curr_table = table_number_base + print "/*" > outfile + print " * " outfile ":" > outfile + print " * This file is automatically generated; please do not edit it." > outfile + print " */" > outfile + + print "#ifdef __STDC__" > outfile + print "#define NOARGS void" > outfile + print "#else" > outfile + print "#define NOARGS" > outfile + print "#define const" > outfile + print "#endif" > outfile + print "" > outfile + print "static const char * const text[] = {" > outfile + table_item_count = 0 +} + +/^[ \t]*(error_code|ec)[ \t]+[A-Z_0-9]+,[ \t]*$/ { + skipone=1 + next +} + +/^[ \t]*(error_code|ec)[ \t]+[A-Z_0-9]+,[ \t]*".*"$/ { + text="" + for (i=3; i<=NF; i++) { + text = text FS $i + } + printf "\t%s,\n", text > outfile + curr_table++ + table_item_count++ +} + +{ + if (skipone) { + printf "\t%s,\n", $0 > outfile + curr_table++ + table_item_count++ + } + skipone=0 +} +END { + + + print " 0" > outfile + print "};" > outfile + print "" > outfile + print "struct error_table {" > outfile + print " char const * const * msgs;" > outfile + print " long base;" > outfile + print " int n_msgs;" > outfile + print "};" > outfile + print "struct et_list {" > outfile + print " struct et_list *next;" > outfile + print " const struct error_table * table;" > outfile + print "};" > outfile + print "extern struct et_list *_et_list;" > outfile + print "" > outfile + print "static const struct error_table et = { text, " sprintf("%d",table_number_base) "L, " table_item_count " };" > outfile + print "" > outfile + print "static struct et_list link = { 0, 0 };" > outfile + print "" > outfile + print "void initialize_" table_name "_error_table (NOARGS) {" > outfile + print " if (!link.table) {" > outfile + print " link.next = _et_list;" > outfile + print " link.table = &et;" > outfile + print " _et_list = &link;" > outfile + print " }" > outfile + print "}" > outfile + + +} diff --git a/src/util/et/et_h.awk b/src/util/et/et_h.awk new file mode 100644 index 000000000..939cdfade --- /dev/null +++ b/src/util/et/et_h.awk @@ -0,0 +1,99 @@ +BEGIN { +char_shift=64 +## "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_"; +c2n["A"]=1 +c2n["B"]=2 +c2n["C"]=3 +c2n["D"]=4 +c2n["E"]=5 +c2n["F"]=6 +c2n["G"]=7 +c2n["H"]=8 +c2n["I"]=9 +c2n["J"]=10 +c2n["K"]=11 +c2n["L"]=12 +c2n["M"]=13 +c2n["N"]=14 +c2n["O"]=15 +c2n["P"]=16 +c2n["Q"]=17 +c2n["R"]=18 +c2n["S"]=19 +c2n["T"]=20 +c2n["U"]=21 +c2n["V"]=22 +c2n["W"]=23 +c2n["X"]=24 +c2n["Y"]=25 +c2n["Z"]=26 +c2n["a"]=27 +c2n["b"]=28 +c2n["c"]=29 +c2n["d"]=30 +c2n["e"]=31 +c2n["f"]=32 +c2n["g"]=33 +c2n["h"]=34 +c2n["i"]=35 +c2n["j"]=36 +c2n["k"]=37 +c2n["l"]=38 +c2n["m"]=39 +c2n["n"]=40 +c2n["o"]=41 +c2n["p"]=42 +c2n["q"]=43 +c2n["r"]=44 +c2n["s"]=45 +c2n["t"]=46 +c2n["u"]=47 +c2n["v"]=48 +c2n["w"]=49 +c2n["x"]=50 +c2n["y"]=51 +c2n["z"]=52 +c2n["0"]=53 +c2n["1"]=54 +c2n["2"]=55 +c2n["3"]=56 +c2n["4"]=57 +c2n["5"]=58 +c2n["6"]=59 +c2n["7"]=60 +c2n["8"]=61 +c2n["9"]=62 +c2n["_"]=63 +} +/^#/ { next } +/^[ \t]*(error_table|et)[ \t]+[a-zA-Z][a-zA-Z0-9_]+/ { + table_number = 0 + table_name = $2 + for(i=1; i<=length(table_name); i++) { + table_number=(table_number*char_shift)+c2n[substr(table_name,i,1)] + } + table_number_base=table_number*256 + if(table_number_base > 128*256*256*256) { + table_number_base -= 256*256*256*256 + } + curr_table = table_number_base + print "/*" > outfile + print " * " outfile ":" > outfile + print " * This file is automatically generated; please do not edit it." > outfile + print " */" > outfile +} + +/^[ \t]*(error_code|ec)[ \t]+[A-Z_0-9]+,/ { + tag=substr($2,1,length($2)-1) + printf "#define %-40s (%ldL)\n", tag, curr_table > outfile + curr_table++ +} + +END { + print "extern void initialize_" table_name "_error_table ();" > outfile + print "#define ERROR_TABLE_BASE_" table_name " (" sprintf("%d",table_number_base) "L)" > outfile + print "" > outfile + print "/* for compatibility with older versions... */" > outfile + print "#define init_" table_name "_err_tbl initialize_" table_name "_error_table" > outfile + print "#define " table_name "_err_base ERROR_TABLE_BASE_" table_name > outfile +} diff --git a/src/util/et/et_lex.lex.l b/src/util/et/et_lex.lex.l new file mode 100644 index 000000000..b3990993d --- /dev/null +++ b/src/util/et/et_lex.lex.l @@ -0,0 +1,26 @@ +PC [^\"] +AN [A-Z_a-z0-9] +%% + +error_table return ERROR_TABLE; +et return ERROR_TABLE; +error_code return ERROR_CODE_ENTRY; +ec return ERROR_CODE_ENTRY; +end return END; + +[\t\n ] ; + +\"{PC}*\" { register char *p; yylval.dynstr = ds(yytext+1); + if (p=strrchr(yylval.dynstr, '"')) *p='\0'; + return QUOTED_STRING; + } + +{AN}* { yylval.dynstr = ds(yytext); return STRING; } + +#.*\n ; + +. { return (*yytext); } +%% +#ifndef lint +static char rcsid_et_lex_lex_l[] = "$Header$"; +#endif diff --git a/src/util/et/et_name.c b/src/util/et/et_name.c new file mode 100644 index 000000000..19da71d30 --- /dev/null +++ b/src/util/et/et_name.c @@ -0,0 +1,43 @@ +/* + * Copyright 1987 by MIT Student Information Processing Board + * + * For copyright info, see mit-sipb-copyright.h. + */ + +#include "error_table.h" +#include "mit-sipb-copyright.h" +#include "internal.h" + +#ifndef lint +static const char copyright[] = + "Copyright 1987,1988 by Student Information Processing Board, Massachusetts Institute of Technology"; +static const char rcsid_et_name_c[] = + "$Header$"; +#endif + +static const char char_set[] = + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_"; + +static char buf[6]; + +const char * error_table_name(num) + int num; +{ + int ch; + int i; + char *p; + + /* num = aa aaa abb bbb bcc ccc cdd ddd d?? ??? ??? */ + p = buf; + num >>= ERRCODE_RANGE; + /* num = ?? ??? ??? aaa aaa bbb bbb ccc ccc ddd ddd */ + num &= 077777777; + /* num = 00 000 000 aaa aaa bbb bbb ccc ccc ddd ddd */ + for (i = 4; i >= 0; i--) { + ch = (num >> BITS_PER_CHAR * i) & ((1 << BITS_PER_CHAR) - 1); + if (ch != 0) + *p++ = char_set[ch-1]; + } + *p = '\0'; + return(buf); +} diff --git a/src/util/et/init_et.c b/src/util/et/init_et.c new file mode 100644 index 000000000..856f0fdc2 --- /dev/null +++ b/src/util/et/init_et.c @@ -0,0 +1,55 @@ +/* + * $Header$ + * $Source$ + * $Locker$ + * + * Copyright 1986, 1987, 1988 by MIT Information Systems and + * the MIT Student Information Processing Board. + * + * For copyright info, see mit-sipb-copyright.h. + */ + +#include +#include "error_table.h" +#include "mit-sipb-copyright.h" + +#ifndef __STDC__ +#define const +#endif + +#ifndef lint +static const char rcsid_init_et_c[] = + "$Header$"; +#endif + +extern char *malloc(), *realloc(); + +struct foobar { + struct et_list etl; + struct error_table et; +}; + +extern struct et_list * _et_list; + +int init_error_table(msgs, base, count) + const char * const * msgs; + int base; + int count; +{ + struct foobar * new_et; + + if (!base || !count || !msgs) + return 0; + + new_et = (struct foobar *) malloc(sizeof(struct foobar)); + if (!new_et) + return errno; /* oops */ + new_et->etl.table = &new_et->et; + new_et->et.msgs = msgs; + new_et->et.base = base; + new_et->et.n_msgs= count; + + new_et->etl.next = _et_list; + _et_list = &new_et->etl; + return 0; +} diff --git a/src/util/et/internal.h b/src/util/et/internal.h new file mode 100644 index 000000000..112c0161e --- /dev/null +++ b/src/util/et/internal.h @@ -0,0 +1,22 @@ +/* + * internal include file for com_err package + */ +#include "mit-sipb-copyright.h" +#ifndef __STDC__ +#undef const +#define const +#endif + +#include + +#ifdef NEED_SYS_ERRLIST +extern char const * const sys_errlist[]; +extern const int sys_nerr; +#endif + +/* AIX and Ultrix have standard conforming header files. */ +#if !defined(ultrix) && !defined(_AIX) +#ifdef __STDC__ +void perror (const char *); +#endif +#endif diff --git a/src/util/et/mit-sipb-copyright.h b/src/util/et/mit-sipb-copyright.h new file mode 100644 index 000000000..2f7eb2950 --- /dev/null +++ b/src/util/et/mit-sipb-copyright.h @@ -0,0 +1,19 @@ +/* + +Copyright 1987, 1988 by the Student Information Processing Board + of the Massachusetts Institute of Technology + +Permission to use, copy, modify, and distribute this software +and its documentation for any purpose and without fee is +hereby granted, provided that the above copyright notice +appear in all copies and that both that copyright notice and +this permission notice appear in supporting documentation, +and that the names of M.I.T. and the M.I.T. S.I.P.B. not be +used in advertising or publicity pertaining to distribution +of the software without specific, written prior permission. +M.I.T. and the M.I.T. S.I.P.B. make no representations about +the suitability of this software for any purpose. It is +provided "as is" without express or implied warranty. + +*/ + diff --git a/src/util/et/test_et.c b/src/util/et/test_et.c new file mode 100644 index 000000000..955cb964a --- /dev/null +++ b/src/util/et/test_et.c @@ -0,0 +1,47 @@ +#include +#include +#include "com_err.h" +#include "test1.h" +#include "test2.h" + +extern int sys_nerr, errno; + +main() +{ + printf("Before initiating error table:\n\n"); + printf("Table name '%s'\n", error_table_name(KRB_MK_AP_TGTEXP)); + printf("UNIX name '%s'\n", error_table_name(EPERM)); + printf("Msg TGT-expired is '%s'\n", error_message(KRB_MK_AP_TGTEXP)); + printf("Msg EPERM is '%s'\n", error_message(EPERM)); + printf("Msg FOO_ERR is '%s'\n", error_message(FOO_ERR)); + printf("Msg {sys_nerr-1} is '%s'\n", error_message(sys_nerr-1)); + printf("Msg {sys_nerr} is '%s'\n", error_message(sys_nerr)); + + printf("With 0: tgt-expired -> %s\n", error_message(KRB_MK_AP_TGTEXP)); + + initialize_krb_error_table(); + printf("KRB error table initialized: base %d (%s), name %s\n", + ERROR_TABLE_BASE_krb, error_message(ERROR_TABLE_BASE_krb), + error_table_name(ERROR_TABLE_BASE_krb)); + initialize_krb_error_table(); + printf("With krb: tgt-expired -> %s\n", + error_message(KRB_MK_AP_TGTEXP)); + + initialize_quux_error_table(); + printf("QUUX error table initialized: base %d (%s), name %s\n", + ERROR_TABLE_BASE_quux, error_message(ERROR_TABLE_BASE_quux), + error_table_name(ERROR_TABLE_BASE_quux)); + + printf("Msg for TGT-expired is '%s'\n", + error_message(KRB_MK_AP_TGTEXP)); + printf("Msg {sys_nerr-1} is '%s'\n", error_message(sys_nerr-1)); + printf("Msg FOO_ERR is '%s'\n", error_message(FOO_ERR)); + printf("Msg KRB_SKDC_CANT is '%s'\n", + error_message(KRB_SKDC_CANT)); + printf("Msg 1e6 (8B 64) is '%s'\n", error_message(1000000)); + printf("\n\nCOM_ERR tests:\n"); + com_err("whoami", FOO_ERR, (char *)NULL); + com_err("whoami", FOO_ERR, " -- message goes %s", "here"); + com_err("whoami", 0, (char *)0); + com_err("whoami", 0, "error number %d\n", 0); +} -- 2.26.2