mirror/freebsd
1
0
Fork 0
mirror of https://git.FreeBSD.org/src.git synced 2025-01-04 12:52:15 +00:00
Code Issues Releases Activity

Fix up this for the build; some compatibility files have been added -

Browse Source 
these will be submitted back to KTH for inclusion.
This commit is contained in:
Mark Murray 1999-09-04 09:49:02 +00:00
parent a828799ddd
commit f9ce010afd
Notes: svn2git 2020-12-20 02:59:44 +00:00 
svn path=/head/; revision=50880
9 changed files with 632 additions and 11 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

96
contrib/com_err/com_err.3 Normal file
View File

@ -0,0 +1,96 @@
.\" Copyright (c) 1988 Massachusetts Institute of Technology,
.\" Student Information Processing Board. All rights reserved.
.\"
.\" $FreeBSD$
.\"
.TH COM_ERR 3 "22 Nov 1988" SIPB
.SH NAME
com_err \- common error display routine
.SH SYNOPSIS
.nf
#include <com_err.h>
.PP
void com_err (whoami, code, format, ...);
const char *whoami;
long code;
const char *format;
.PP
proc = set_com_err_hook (proc);
.fi
void (*
.I proc
) (const char *, long, const char *, va_list);
.nf
.PP
proc = reset_com_err_hook ();
.PP
void initialize_XXXX_error_table ();
.fi
.SH DESCRIPTION
.I Com_err
displays an error message on the standard error stream
.I stderr
(see
.IR stdio (3S))
composed of the
.I whoami
string, which should specify the program name or some subportion of
a program, followed by an error message generated from the
.I code
value (derived from
.IR compile_et (1)),
and a string produced using the
.I format
string and any following arguments, in the same style as
.IR fprintf (3).
The behavior of
.I com_err
can be modified using
.I set_com_err_hook;
this defines a procedure which is called with the arguments passed to
.I com_err,
instead of the default internal procedure which sends the formatted
text to error output. Thus the error messages from a program can all
easily be diverted to another form of diagnostic logging, such as
.IR syslog (3).
.I Reset_com_err_hook
may be used to restore the behavior of
.I com_err
to its default form. Both procedures return the previous ``hook''
value. These ``hook'' procedures must have the declaration given for
.I proc
above in the synopsis.
The
.I initialize_XXXX_error_table
routine is generated mechanically by
.IR compile_et (1)
from a source file containing names and associated strings. Each
table has a name of up to four characters, which is used in place of
the
.B XXXX
in the name of the routine. These routines should be called before
any of the corresponding error codes are used, so that the
.I com_err
library will recognize error codes from these tables when they are
used.
The
.B com_err.h
header file should be included in any source file that uses routines
from the
.I com_err
library; executable files must be linked using
.I ``-lcom_err''
in order to cause the
.I com_err
library to be included.
.\" .IR for manual entries
.\" .PP for paragraph breaks
.SH "SEE ALSO"
compile_et (1), syslog (3).
Ken Raeburn, "A Common Error Description Library for UNIX".

1
contrib/com_err/com_err.c
View File

@ -43,7 +43,6 @@ RCSID("$Id: com_err.c,v 1.13 1999/03/12 15:17:08 bg Exp $");
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <roken.h>
#include "com_err.h"
struct et_list *_et_list;

78
contrib/com_err/compile_et.1 Normal file
View File

@ -0,0 +1,78 @@
.\" Copyright (c) 1988 Massachusetts Institute of Technology,
.\" Student Information Processing Board. All rights reserved.
.\"
.\" $FreeBSD$
.\"
.Dd November 22, 1988
.Os
.Dt COMPILE_ET 1
.Sh NAME
.Nm compile_et
.Nd error table compiler
.Sh SYNOPSIS
.Nm compile_et
.Ar file
.Sh DESCRIPTION
.Nm Compile_et
converts a table listing error-code names and associated messages into
a C source file suitable for use with the
.Xr com_err 3
library.
.Pp
The source file name must end with a suffix of ``.et''; the file
consists of a declaration supplying the name (up to four characters
long) of the error-code table:
.Em error_table name
followed by up to 256 entries of the form:
.Em error_code name ,
"
.Em string
"
and a final
.Em end
to indicate the end of the table.
.Pp
The name of the table is used to construct the name of a subroutine
.Em initialize_XXXX_error_table
which must be called in order for the
.Xr com_err 3
library to recognize the error table.
.Pp
The various error codes defined are assigned sequentially increasing
numbers (starting with a large number computed as a hash function of
the name of the table); thus for compatibility it is suggested that
new codes be added only to the end of an existing table, and that no
codes be removed from tables.
.Pp
The names defined in the table are placed into a C header file with
preprocessor directives defining them as integer constants of up to
32 bits in magnitude.
.Pp
A C source file is also generated which should be compiled and linked
with the object files which reference these error codes; it contains
the text of the messages and the initialization subroutine. Both C
files have names derived from that of the original source file, with
the ``.et'' suffix replaced by ``.c'' and ``.h''.
.Pp
A ``#'' in the source file is treated as a comment character, and all
remaining text to the end of the source line will be ignored.
.Sh BUGS
Since
.Nm compile_et
uses a very simple parser based on
.Xr yacc 1 ,
its error recovery leaves much to be desired.
.Sh "SEE ALSO"
.Xr yacc 1 ,
.Xr com_err 3
.Pp
.Rs
.%A Ken Raeburn
.%T "A Common Error Description Library for UNIX"
.Re

10
contrib/com_err/compile_et.c
View File

@ -40,9 +40,10 @@
#include "compile_et.h"
#include <getarg.h>
#if 0
RCSID("$Id: compile_et.c,v 1.12 1999/04/01 09:13:52 joda Exp $");
#endif
#include <roken.h>
#include <err.h>
#include "parse.h"
@ -180,10 +181,8 @@ generate(void)
return generate_c() || generate_h();
}
int version_flag;
int help_flag;
struct getargs args[] = {
{ "version", 0, arg_flag, &version_flag },
{ "help", 0, arg_flag, &help_flag }
};
int num_args = sizeof(args) / sizeof(args[0]);
@ -201,15 +200,10 @@ main(int argc, char **argv)
char *p;
int optind = 0;
set_progname(argv[0]);
if(getarg(args, num_args, argc, argv, &optind))
usage(1);
if(help_flag)
usage(0);
if(version_flag) {
print_version(NULL);
exit(0);
}
if(optind == argc)
usage(1);

2
contrib/com_err/compile_et.h
View File

@ -51,8 +51,6 @@
#include <stdarg.h>
#include <ctype.h>
#include <roken.h>
extern long base;
extern int number;
extern char *prefix;

376
contrib/com_err/getarg.c Normal file
View File

@ -0,0 +1,376 @@
/*
* Copyright (c) 1997, 1998 Kungliga Tekniska Högskolan
* (Royal Institute of Technology, Stockholm, Sweden).
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions 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.
*
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by Kungliga Tekniska
* Högskolan and its contributors.
*
* 4. Neither the name of the Institute nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#if 0
RCSID("$Id: getarg.c,v 1.25 1998/11/22 09:45:05 assar Exp $");
#endif
#include <sys/ttycom.h>
#include <time.h>
#include <stdio.h>
#include "getarg.h"
#define ISFLAG(X) ((X).type == arg_flag || (X).type == arg_negative_flag)
static size_t
print_arg (char *string, size_t len, int mdoc, int longp, struct getargs *arg)
{
const char *s;
*string = '\0';
if (ISFLAG(*arg))
return 0;
if(mdoc){
if(longp)
strncat(string, "= Ns", len);
strncat(string, " Ar ", len);
}else
if (longp)
strncat (string, "=", len);
else
strncat (string, " ", len);
if (arg->arg_help)
s = arg->arg_help;
else if (arg->type == arg_integer)
s = "number";
else if (arg->type == arg_string)
s = "string";
else
s = "<undefined>";
strncat(string, s, len);
return 1 + strlen(s);
}
static int
check_column(FILE *f, int col, int len, int columns)
{
if(col + len > columns) {
fprintf(f, "\n");
col = fprintf(f, " ");
}
return col;
}
void
arg_printusage (struct getargs *args,
size_t num_args,
const char *progname,
const char *extra_string)
{
int i;
size_t max_len = 0;
char buf[128];
int col = 0, columns;
struct winsize ws;
columns = 80;
col = 0;
col += fprintf (stderr, "Usage: %s", progname);
for (i = 0; i < num_args; ++i) {
size_t len = 0;
if (args[i].long_name) {
buf[0] = '\0';
strncat(buf, "[--", sizeof(buf));
len += 2;
if(args[i].type == arg_negative_flag) {
strncat(buf, "no-", sizeof(buf));
len += 3;
}
strncat(buf, args[i].long_name, sizeof(buf));
len += strlen(args[i].long_name);
len += print_arg(buf + strlen(buf), sizeof(buf) - strlen(buf),
0, 1, &args[i]);
strncat(buf, "]", sizeof(buf));
if(args[i].type == arg_strings)
strncat(buf, "...", sizeof(buf));
col = check_column(stderr, col, strlen(buf) + 1, columns);
col += fprintf(stderr, " %s", buf);
}
if (args[i].short_name) {
snprintf(buf, sizeof(buf), "[-%c", args[i].short_name);
len += 2;
len += print_arg(buf + strlen(buf), sizeof(buf) - strlen(buf),
0, 0, &args[i]);
strncat(buf, "]", sizeof(buf));
if(args[i].type == arg_strings)
strncat(buf, "...", sizeof(buf));
col = check_column(stderr, col, strlen(buf) + 1, columns);
col += fprintf(stderr, " %s", buf);
}
if (args[i].long_name && args[i].short_name)
len += 2; /* ", " */
max_len = max(max_len, len);
}
if (extra_string) {
col = check_column(stderr, col, strlen(extra_string) + 1, columns);
fprintf (stderr, " %s\n", extra_string);
} else
fprintf (stderr, "\n");
for (i = 0; i < num_args; ++i) {
if (args[i].help) {
size_t count = 0;
if (args[i].short_name) {
count += fprintf (stderr, "-%c", args[i].short_name);
print_arg (buf, sizeof(buf), 0, 0, &args[i]);
count += fprintf(stderr, "%s", buf);
}
if (args[i].short_name && args[i].long_name)
count += fprintf (stderr, ", ");
if (args[i].long_name) {
count += fprintf (stderr, "--");
if (args[i].type == arg_negative_flag)
count += fprintf (stderr, "no-");
count += fprintf (stderr, "%s", args[i].long_name);
print_arg (buf, sizeof(buf), 0, 1, &args[i]);
count += fprintf(stderr, "%s", buf);
}
while(count++ <= max_len)
putc (' ', stderr);
fprintf (stderr, "%s\n", args[i].help);
}
}
}
static void
add_string(getarg_strings *s, char *value)
{
s->strings = realloc(s->strings, (s->num_strings + 1) * sizeof(*s->strings));
s->strings[s->num_strings] = value;
s->num_strings++;
}
static int
arg_match_long(struct getargs *args, size_t num_args,
char *argv)
{
int i;
char *optarg = NULL;
int negate = 0;
int partial_match = 0;
struct getargs *partial = NULL;
struct getargs *current = NULL;
int argv_len;
char *p;
argv_len = strlen(argv);
p = strchr (argv, '=');
if (p != NULL)
argv_len = p - argv;
for (i = 0; i < num_args; ++i) {
if(args[i].long_name) {
int len = strlen(args[i].long_name);
char *p = argv;
int p_len = argv_len;
negate = 0;
for (;;) {
if (strncmp (args[i].long_name, p, p_len) == 0) {
if(p_len == len)
current = &args[i];
else {
++partial_match;
partial = &args[i];
}
optarg = p + p_len;
} else if (ISFLAG(args[i]) && strncmp (p, "no-", 3) == 0) {
negate = !negate;
p += 3;
p_len -= 3;
continue;
}
break;
}
if (current)
break;
}
}
if (current == NULL) {
if (partial_match == 1)
current = partial;
else
return ARG_ERR_NO_MATCH;
}
if(*optarg == '\0' && !ISFLAG(*current))
return ARG_ERR_NO_MATCH;
switch(current->type){
case arg_integer:
{
int tmp;
if(sscanf(optarg + 1, "%d", &tmp) != 1)
return ARG_ERR_BAD_ARG;
*(int*)current->value = tmp;
return 0;
}
case arg_string:
{
*(char**)current->value = optarg + 1;
return 0;
}
case arg_strings:
{
add_string((getarg_strings*)current->value, optarg + 1);
return 0;
}
case arg_flag:
case arg_negative_flag:
{
int *flag = current->value;
if(*optarg == '\0' ||
strcmp(optarg + 1, "yes") == 0 ||
strcmp(optarg + 1, "true") == 0){
*flag = !negate;
return 0;
} else if (*optarg && strcmp(optarg + 1, "maybe") == 0) {
*flag = rand() & 1;
} else {
*flag = negate;
return 0;
}
return ARG_ERR_BAD_ARG;
}
default:
abort ();
}
}
int
getarg(struct getargs *args, size_t num_args,
int argc, char **argv, int *optind)
{
int i, j, k;
int ret = 0;
srand (time(NULL));
(*optind)++;
for(i = *optind; i < argc; i++) {
if(argv[i][0] != '-')
break;
if(argv[i][1] == '-'){
if(argv[i][2] == 0){
i++;
break;
}
ret = arg_match_long (args, num_args, argv[i] + 2);
if(ret)
return ret;
}else{
for(j = 1; argv[i][j]; j++) {
for(k = 0; k < num_args; k++) {
char *optarg;
if(args[k].short_name == 0)
continue;
if(argv[i][j] == args[k].short_name){
if(args[k].type == arg_flag){
*(int*)args[k].value = 1;
break;
}
if(args[k].type == arg_negative_flag){
*(int*)args[k].value = 0;
break;
}
if(argv[i][j + 1])
optarg = &argv[i][j + 1];
else{
i++;
optarg = argv[i];
}
if(optarg == NULL)
return ARG_ERR_NO_ARG;
if(args[k].type == arg_integer){
int tmp;
if(sscanf(optarg, "%d", &tmp) != 1)
return ARG_ERR_BAD_ARG;
*(int*)args[k].value = tmp;
goto out;
}else if(args[k].type == arg_string){
*(char**)args[k].value = optarg;
goto out;
}else if(args[k].type == arg_strings){
add_string((getarg_strings*)args[k].value, optarg);
goto out;
}
return ARG_ERR_BAD_ARG;
}
}
if (k == num_args)
return ARG_ERR_NO_MATCH;
}
out:;
}
}
*optind = i;
return 0;
}
#if TEST
int foo_flag = 2;
int flag1 = 0;
int flag2 = 0;
int bar_int;
char *baz_string;
struct getargs args[] = {
{ NULL, '1', arg_flag, &flag1, "one", NULL },
{ NULL, '2', arg_flag, &flag2, "two", NULL },
{ "foo", 'f', arg_negative_flag, &foo_flag, "foo", NULL },
{ "bar", 'b', arg_integer, &bar_int, "bar", "seconds"},
{ "baz", 'x', arg_string, &baz_string, "baz", "name" },
};
int main(int argc, char **argv)
{
int optind = 0;
while(getarg(args, 5, argc, argv, &optind))
printf("Bad arg: %s\n", argv[optind]);
printf("flag1 = %d\n", flag1);
printf("flag2 = %d\n", flag2);
printf("foo_flag = %d\n", foo_flag);
printf("bar_int = %d\n", bar_int);
printf("baz_flag = %s\n", baz_string);
arg_printusage (args, 5, argv[0], "nothing here");
}
#endif

76
contrib/com_err/getarg.h Normal file
View File

@ -0,0 +1,76 @@
/*
* Copyright (c) 1997 Kungliga Tekniska Högskolan
* (Royal Institute of Technology, Stockholm, Sweden).
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions 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.
*
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by Kungliga Tekniska
* Högskolan and its contributors.
*
* 4. Neither the name of the Institute nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
/* $Id: getarg.h,v 1.5 1998/08/18 20:26:11 assar Exp $ */
#ifndef __GETARG_H__
#define __GETARG_H__
#include <stddef.h>
#define max(a,b) (((a)>(b))?(a):(b))
struct getargs{
const char *long_name;
char short_name;
enum { arg_integer, arg_string, arg_flag, arg_negative_flag, arg_strings } type;
void *value;
const char *help;
const char *arg_help;
};
enum {
ARG_ERR_NO_MATCH = 1,
ARG_ERR_BAD_ARG,
ARG_ERR_NO_ARG
};
typedef struct getarg_strings {
int num_strings;
char **strings;
} getarg_strings;
int getarg(struct getargs *args, size_t num_args,
int argc, char **argv, int *optind);
void arg_printusage (struct getargs *args,
size_t num_args,
const char *progname,
const char *extra_string);
#endif /* __GETARG_H__ */

2
contrib/com_err/lex.l
View File

@ -48,7 +48,9 @@
#include "compile_et.h"
#include "parse.h"
#if 0
RCSID("$Id: lex.l,v 1.4 1998/11/20 05:58:52 assar Exp $");
#endif
static unsigned lineno = 1;
void error_message(char *, ...);

2
contrib/com_err/parse.y
View File

@ -38,7 +38,9 @@
*/
#include "compile_et.h"
#if 0
RCSID("$Id: parse.y,v 1.9 1999/07/04 14:54:58 assar Exp $");
#endif
void yyerror (char *s);
long name2number(const char *str);