/* copied from make_random_colormap in colors.c */
static void
make_mondrian_colormap (Screen *screen, Visual *visual, Colormap cmap,
XColor *colors, int *ncolorsP,
Bool allocate_p,
Bool *writable_pP,
Bool verbose_p)
{
Display *dpy = DisplayOfScreen (screen);
Bool wanted_writable = (allocate_p && writable_pP && *writable_pP);
int ncolors = 8;
int i;
if (*ncolorsP <= 0) return;
/* If this visual doesn't support writable cells, don't bother trying. */
if (wanted_writable && !has_writable_cells(screen, visual))
*writable_pP = False;
for (i = 0; i < ncolors; i++)
{
colors[i].flags = DoRed|DoGreen|DoBlue;
colors[i].red = 0;
colors[i].green = 0;
colors[i].blue = 0;
switch(i) {
case 0: case 1: case 2: case 3: case 7: /* white */
colors[i].red = 0xE800;
colors[i].green = 0xE800;
colors[i].blue = 0xE800;
break;
case 4:
colors[i].red = 0xCFFF; break; /* red */
case 5:
colors[i].red = 0x2000;
colors[i].blue = 0xCFFF; break; /* blue */
case 6:
colors[i].red = 0xDFFF; /* yellow */
colors[i].green = 0xCFFF; break;
}
}
if (!allocate_p)
return;
RETRY_NON_WRITABLE:
if (writable_pP && *writable_pP)
{
unsigned long *pixels = (unsigned long *)
malloc(sizeof(*pixels) * (ncolors + 1));
allocate_writable_colors (screen, cmap, pixels, &ncolors);
if (ncolors > 0)
for (i = 0; i < ncolors; i++)
colors[i].pixel = pixels[i];
free (pixels);
if (ncolors > 0)
XStoreColors (dpy, cmap, colors, ncolors);
}
else
{
for (i = 0; i < ncolors; i++)
{
XColor color;
color = colors[i];
if (!XAllocColor (dpy, cmap, &color))
break;
colors[i].pixel = color.pixel;
}
ncolors = i;
}
/* If we tried for writable cells and got none, try for non-writable. */
if (allocate_p && ncolors == 0 && writable_pP && *writable_pP)
{
ncolors = *ncolorsP;
*writable_pP = False;
goto RETRY_NON_WRITABLE;
}
#if 0
/* I don't think we need to bother copying or linking to the complain
function. */
if (verbose_p)
complain(*ncolorsP, ncolors, wanted_writable,
wanted_writable && *writable_pP);
#endif
*ncolorsP = ncolors;
}
int WriteMessage(OSCbuf *buf, char *messageName, int numArgs, typedArg *args) {
int j, returnVal;
returnVal = 0;
#ifdef DEBUG
printf("WriteMessage: %s ", messageName);
for (j = 0; j < numArgs; j++) {
switch (args[j].type) {
case INT:
printf("%d ", args[j].datum.i);
break;
case FLOAT:
printf("%f ", args[j].datum.f);
break;
case STRING:
printf("%s ", args[j].datum.s);
break;
default:
fatal_error("Unrecognized arg type");
exit(5);
}
}
printf("\n");
#endif
if (!useTypeTags) {
returnVal = OSC_writeAddress(buf, messageName);
if (returnVal) {
complain("Problem writing address: %s\n", OSC_errorMessage);
}
} else {
/* First figure out the type tags */
char typeTags[MAX_ARGS+2];
int i;
typeTags[0] = ',';
for (i = 0; i < numArgs; ++i) {
switch (args[i].type) {
case INT:
typeTags[i+1] = 'i';
break;
case FLOAT:
typeTags[i+1] = 'f';
break;
case STRING:
typeTags[i+1] = 's';
break;
default:
fatal_error("Unrecognized arg type");
exit(5);
}
}
typeTags[i+1] = '\0';
returnVal = OSC_writeAddressAndTypes(buf, messageName, typeTags);
if (returnVal) {
complain("Problem writing address: %s\n", OSC_errorMessage);
}
}
for (j = 0; j < numArgs; j++) {
switch (args[j].type) {
case INT:
if ((returnVal = OSC_writeIntArg(buf, args[j].datum.i)) != 0) {
return returnVal;
}
break;
case FLOAT:
if ((returnVal = OSC_writeFloatArg(buf, args[j].datum.f)) != 0) {
return returnVal;
}
break;
case STRING:
if ((returnVal = OSC_writeStringArg(buf, args[j].datum.s)) != 0) {
return returnVal;
}
break;
default:
fatal_error("Unrecognized arg type");
exit(5);
}
}
return returnVal;
}
int main(int argc, char *argv[]) {
char *hostname = 0;
void *handle;
argc--;
argv++;
if (argc == 0) {
goto usageerror;
}
if (argc >= 1 && (strncmp(*argv, "-notypetags", 2) == 0)) {
useTypeTags = 0;
argv++;
argc--;
}
if (argc >= 2 && (strncmp(*argv, "-r", 2) == 0)) {
hostname = getenv("MCAST_ADDR");
if (hostname == NULL) {
complain("sendSC -r: MCAST_ADDR not in environment\n");
exit(4);
}
argv++;
argc--;
}
if (argc >= 3 && (strncmp(*argv, "-g", 2) == 0)) {
hostname = argv[1];
argv += 2;
argc -= 2;
}
portnumber = atoi(*argv);
argv++;
argc--;
printf("Multicast sender on %s\n", hostname );
handle = OpenMCASTSocket(hostname);
if (!handle) {
perror("Couldn't open socket: ");
exit(3);
}
if (argc > 0) {
printf("host %s, port %d, %s\n", hostname, portnumber,
useTypeTags ? "use type tags" : "don't use type tags");
CommandLineMode(argc, argv, handle);
} else {
printf("sendOSC version " VERSION "\n");
printf("by Matt Wright. Copyright (c) 1996, 1997 Regents of the University of California.\n");
printf("host %s, port %d, %s\n", hostname, portnumber,
useTypeTags ? "use type tags" : "don't use type tags");
InteractiveMode(handle);
}
CloseMCASTSocket(handle);
exit(exitStatus);
usageerror:
complain("usage: %s [-notypetags] [-r] [-g group_name] port_number [message...]\n",
argv[-1]);
exit(4);
}
int main(int ac, char **av)
{
int c, i, nnodes=0;
long node=-1;
char *end;
char shortopts[array_len(opts)*2 + 1];
struct bitmask *mask = NULL;
get_short_opts(opts,shortopts);
while ((c = getopt_long(ac, av, shortopts, opts, NULL)) != -1) {
switch (c) {
case 's': /* --show */
show();
exit(0);
case 'H': /* --hardware */
nopolicy();
hardware();
exit(0);
case 'i': /* --interleave */
checknuma();
mask = numactl_parse_nodestring(optarg);
if (!mask) {
printf ("<%s> is invalid\n", optarg);
usage();
}
errno = 0;
setpolicy(MPOL_INTERLEAVE);
if (shmfd >= 0)
numa_interleave_memory(shmptr, shmlen, mask);
else
numa_set_interleave_mask(mask);
checkerror("setting interleave mask");
break;
case 'N': /* --cpunodebind */
case 'c': /* --cpubind */
dontshm("-c/--cpubind/--cpunodebind");
checknuma();
mask = numactl_parse_nodestring(optarg);
if (!mask) {
printf ("<%s> is invalid\n", optarg);
usage();
}
errno = 0;
check_cpubind(do_shm);
did_cpubind = 1;
numa_run_on_node_mask(mask);
checkerror("sched_setaffinity");
break;
case 'C': /* --physcpubind */
{
struct bitmask *cpubuf;
dontshm("-C/--physcpubind");
cpubuf = numa_parse_cpustring(optarg);
if (!cpubuf) {
printf ("<%s> is invalid\n", optarg);
usage();
}
errno = 0;
check_cpubind(do_shm);
did_cpubind = 1;
numa_sched_setaffinity(0, cpubuf);
checkerror("sched_setaffinity");
free(cpubuf);
break;
}
case 'm': /* --membind */
checknuma();
setpolicy(MPOL_BIND);
mask = numactl_parse_nodestring(optarg);
if (!mask) {
printf ("<%s> is invalid\n", optarg);
usage();
}
errno = 0;
numa_set_bind_policy(1);
if (shmfd >= 0) {
numa_tonodemask_memory(shmptr, shmlen, mask);
} else {
numa_set_membind(mask);
}
numa_set_bind_policy(0);
checkerror("setting membind");
break;
case 'p': /* --preferred */
checknuma();
setpolicy(MPOL_PREFERRED);
mask = numactl_parse_nodestring(optarg);
if (!mask) {
printf ("<%s> is invalid\n", optarg);
usage();
}
for (i=0; i<mask->size; i++) {
if (numa_bitmask_isbitset(mask, i)) {
node = i;
nnodes++;
}
}
if (nnodes != 1)
usage();
numa_bitmask_free(mask);
errno = 0;
numa_set_bind_policy(0);
if (shmfd >= 0)
numa_tonode_memory(shmptr, shmlen, node);
else
numa_set_preferred(node);
checkerror("setting preferred node");
break;
case 'l': /* --local */
checknuma();
setpolicy(MPOL_DEFAULT);
errno = 0;
if (shmfd >= 0)
numa_setlocal_memory(shmptr, shmlen);
else
numa_set_localalloc();
checkerror("local allocation");
break;
case 'S': /* --shm */
check_cpubind(did_cpubind);
nopolicy();
attach_sysvshm(optarg, "--shm");
shmattached = 1;
break;
case 'f': /* --file */
check_cpubind(did_cpubind);
nopolicy();
attach_shared(optarg, "--file");
shmattached = 1;
break;
case 'L': /* --length */
noshm("--length");
shmlen = memsize(optarg);
break;
case 'M': /* --shmmode */
noshm("--shmmode");
shmmode = strtoul(optarg, &end, 8);
if (end == optarg || *end)
usage();
break;
case 'd': /* --dump */
if (shmfd < 0)
complain(
"Cannot do --dump without shared memory.\n");
dump_shm();
do_dump = 1;
break;
case 'D': /* --dump-nodes */
if (shmfd < 0)
complain(
"Cannot do --dump-nodes without shared memory.\n");
dump_shm_nodes();
do_dump = 1;
break;
case 't': /* --strict */
did_strict = 1;
numa_set_strict(1);
break;
case 'I': /* --shmid */
shmid = strtoul(optarg, &end, 0);
if (end == optarg || *end)
usage();
break;
case 'u': /* --huge */
noshm("--huge");
shmflags |= SHM_HUGETLB;
break;
case 'o': /* --offset */
noshm("--offset");
shmoffset = memsize(optarg);
break;
case 'T': /* --touch */
needshm("--touch");
check_shmbeyond("--touch");
numa_police_memory(shmptr, shmlen);
break;
case 'V': /* --verify */
needshm("--verify");
if (set_policy < 0)
complain("Need a policy first to verify");
check_shmbeyond("--verify");
numa_police_memory(shmptr, shmlen);
if (!mask)
complain("Need a mask to verify");
else
verify_shm(set_policy, mask);
break;
default:
usage();
}
}
av += optind;
ac -= optind;
if (shmfd >= 0) {
if (*av)
usage();
exit(exitcode);
}
if (did_strict)
fprintf(stderr,
"numactl: warning. Strict flag for process ignored.\n");
if (do_dump)
usage_msg("cannot do --dump|--dump-shm for process");
if (shmoption)
usage_msg("shm related option %s for process", shmoption);
if (*av == NULL)
usage();
execvp(*av, av);
complain("execution of `%s': %s\n", av[0], strerror(errno));
return 0; /* not reached */
}
void ParseInteractiveLine(OSCbuf *buf, char *mesg) {
char *messageName, *token, *p;
typedArg args[MAX_ARGS];
int thisArg;
p = mesg;
while (isspace(*p)) p++;
if (*p == '\0') return;
messageName = p;
if (strcmp(messageName, "play\n") == 0) {
/* Special kludge feature to save typing */
typedArg arg;
if (OSC_openBundle(buf, OSCTT_Immediately())) {
complain("Problem opening bundle: %s\n", OSC_errorMessage);
return;
}
arg.type = INT;
arg.datum.i = 0;
WriteMessage(buf, "/voices/0/tp/timbre_index", 1, &arg);
arg.type = FLOAT;
arg.datum.i = 0.0f;
WriteMessage(buf, "/voices/0/tm/goto", 1, &arg);
if (OSC_closeBundle(buf)) {
complain("Problem closing bundle: %s\n", OSC_errorMessage);
}
return;
}
while (!isspace(*p) && *p != '\0') p++;
if (isspace(*p)) {
*p = '\0';
p++;
}
thisArg = 0;
while (*p != '\0') {
/* flush leading whitespace */
while (isspace(*p)) p++;
if (*p == '\0') break;
if (*p == '"') {
/* A string argument: scan for close quotes */
p++;
args[thisArg].type = STRING;
args[thisArg].datum.s = p;
while (*p != '"') {
if (*p == '\0') {
complain("Unterminated quote mark: ignoring line\n");
return;
}
p++;
}
*p = '\0';
p++;
} else {
token = p;
while (!isspace(*p) && (*p != '\0')) p++;
if (isspace(*p)) {
*p = '\0';
p++;
}
args[thisArg] = ParseToken(token);
}
thisArg++;
if (thisArg >= MAX_ARGS) {
complain("Sorry, your message has more than MAX_ARGS (%d) arguments; ignoring the rest.\n",
MAX_ARGS);
break;
}
}
if (WriteMessage(buf, messageName, thisArg, args) != 0) {
complain("Problem sending message: %s\n", OSC_errorMessage);
}
}
void
process(FILE *f)
{
int i, n;
char line[256]; /* the current line */
char mac[5]; /* The current macro or nroff command */
int pl;
stktop = -1;
for (lineno = 1; fgets(line, sizeof line, f); lineno++) {
if (line[0] == '.') {
/*
* find and isolate the macro/command name.
*/
strncpy(mac, line+1, 4);
if (isspace((unsigned char)mac[0])) {
pe(lineno);
printf("Empty command\n");
} else if (isspace((unsigned char)mac[1])) {
mac[1] = 0;
} else if (isspace((unsigned char)mac[2])) {
mac[2] = 0;
} else if (mac[0] != '\\' || mac[1] != '\"') {
pe(lineno);
printf("Command too long\n");
}
/*
* Is it a known command?
*/
checkknown(mac);
/*
* Should we add it?
*/
if (eq(mac, "de"))
addcmd(line);
chkcmd(line, mac);
}
/*
* At this point we process the line looking
* for \s and \f.
*/
for (i=0; line[i]; i++)
if (line[i]=='\\' && (i==0 || line[i-1]!='\\')) {
if (!sflag && line[++i]=='s') {
pl = line[++i];
if (isdigit((unsigned char)pl)) {
n = pl - '0';
pl = ' ';
} else
n = 0;
while (isdigit((unsigned char)line[++i]))
n = 10 * n + line[i] - '0';
i--;
if (n == 0) {
if (stktop >= 0 &&
stk[stktop].opno == SZ) {
stktop--;
} else {
pe(lineno);
printf("unmatched \\s0\n");
}
} else {
stk[++stktop].opno = SZ;
stk[stktop].pl = pl;
stk[stktop].parm = n;
stk[stktop].lno = lineno;
}
} else if (!fflag && line[i]=='f') {
n = line[++i];
if (n == 'P') {
if (stktop >= 0 &&
stk[stktop].opno == FT) {
stktop--;
} else {
pe(lineno);
printf("unmatched \\fP\n");
}
} else {
stk[++stktop].opno = FT;
stk[stktop].pl = 1;
stk[stktop].parm = n;
stk[stktop].lno = lineno;
}
}
}
}
/*
* We've hit the end and look at all this stuff that hasn't been
* matched yet! Complain, complain.
*/
for (i=stktop; i>=0; i--) {
complain(i);
}
}
static void
ct_room(dbref player, dbref i, warn_type flags)
{
if ((flags & W_ROOM_DESC) && !atr_get(i, "DESCRIBE"))
complain(player, i, "room-desc", T("room has no description"));
}
/* struct|union ... */
static bool tok_take_conglom(struct parse_state *ps,
enum cdump_type_kind conglom_kind)
{
struct cdump_type *e;
const char *name;
size_t n;
assert(conglom_kind == CDUMP_STRUCT || conglom_kind == CDUMP_UNION);
name = tok_take_ident(ps->defs, &ps->toks);
if (!name) {
complain(ps, "Invalid struct/union name");
return false;
}
e = get_type(ps->defs, conglom_kind, name);
if (type_defined(e)) {
complain(ps, "Type already defined");
return false;
}
if (!tok_take_if(&ps->toks, "{")) {
complain(ps, "Expected { for struct/union");
return false;
}
e->u.members = tal_arr(e, struct cdump_member, n = 0);
while (!tok_is(&ps->toks, "}")) {
struct cdump_type *basetype;
const struct token *quals;
unsigned int num_quals = 0;
/* Anything can have these prepended. */
quals = ps->toks;
while (tok_take_if(&ps->toks, "const")
|| tok_take_if(&ps->toks, "volatile"))
num_quals++;
/* eg. "struct foo" or "varint_t" */
if (!tok_take_type(ps, &basetype)) {
complain(ps, "Expected typename inside struct/union");
return false;
}
do {
struct cdump_member *m;
tal_resize(&e->u.members, n+1);
m = &e->u.members[n++];
m->type = basetype;
if (num_quals) {
m->qualifiers
= string_of_toks(e, quals,
quals + num_quals);
} else
m->qualifiers = NULL;
/* May have multiple asterisks. */
while (tok_take_if(&ps->toks, "*"))
m->type = ptr_of(ps, m->type);
m->name = tok_take_ident(e, &ps->toks);
if (!m->name) {
complain(ps, "Expected name for member");
return false;
}
/* May be an array. */
while (tok_take_if(&ps->toks, "[")) {
if (!tok_take_array(ps, &m->type))
return false;
}
} while (tok_take_if(&ps->toks, ","));
if (!tok_take_if(&ps->toks, ";")) {
complain(ps, "Expected ; at end of member");
return false;
}
}
if (tok_take_if(&ps->toks, "}") && tok_take_if(&ps->toks, ";"))
return true;
complain(ps, "Expected }; at end of struct/union");
return false;
}
void
show_msd ( Msd *msd, Flags flags,FILE *FD,double starttime,double endtime,long *offset, double *time0)
{
char net[16], sta[16], chan[16], loc[16] ;
char filename[FILENAME_MAX] ;
double samprate, nominal, time, samptime, reltime ;
int nsamp, has_sdh, has_b100, has_b1000, has_b1001 ;
int dataformat, fpr, fdf, sparc_order, activity, io,
level, quality, samprate_flags, record_size, correction ;
int has_opaque ;
Tbl *opaque ;
char *s ;
long i;
static int *data;
long npts=0;
msdget ( msd,
MSD_NET, net,
MSD_STA, sta,
MSD_CHAN, chan,
MSD_LOC, loc,
MSD_SAMPRATE, &samprate,
MSD_NOMINAL_SAMPRATE, &nominal,
MSD_TIME, &time,
MSD_NSAMP, &nsamp,
MSD_HAS_SEED_HEADER, &has_sdh,
MSD_HAS_B100, &has_b100,
MSD_HAS_B1000, &has_b1000,
MSD_HAS_B1001, &has_b1001,
MSD_LEVEL, &level,
MSD_DATAFORMAT, &dataformat,
MSD_FRAMES_PER_RECORD, &fpr,
MSD_FIRST_DATA_FRAME, &fdf,
MSD_SPARC_ORDER, &sparc_order,
MSD_FILENAME, filename,
MSD_ACTIVITY_FLAGS, &activity,
MSD_IO_FLAGS, &io,
MSD_QUALITY_FLAGS, &quality,
MSD_SAMPRATE_FLAGS, &samprate_flags,
MSD_RECORD_SIZE, &record_size,
MSD_TIME_CORRECTION, &correction,
MSD_HAS_OPAQUE, &has_opaque,
MSD_OPAQUE, &opaque,
0 ) ;
if ( dataformat> 0) {
if ( umsd ( msd, &data, &npts ) ) {
complain ( 0, "umsd failed" ) ;
} else {
if (flags.verbose) {
printf ( "%2s %5s %3s %2s %s %5d %10.4f\n",
net, sta, chan, loc, s=strydtime(time), nsamp, samprate ) ;
free(s) ;
}
for ( i=0 ; i<npts ; i++ ) {
//samptime=SAMP2TIME(time,samprate,i);
samptime=SAMP2TIME(time,samprate,i);
if ((samptime >= starttime) && (samptime <= endtime) ) {
reltime=SAMP2TIME(0,samprate,*offset);
if (*time0==0.0) {
*time0=SAMP2TIME(time,samprate,i);
fprintf(FD,"time0=%s\n",s=strtime(*time0));free(s);
}
fprintf (FD, "%ld 00:00:%06.3f %f\n", *offset,reltime,flags.calib * data[i] ) ;
//fprintf (FD, "%8ld %s %8d\n", *offset,s=epoch2str(samptime,"%H:%M:%S.%s"),data[i] ) ;
//free(s);
(*offset)+=1;
}
}
}
}
}
void
make_random_colormap(ModeInfo * mi, Colormap cmap,
XColor * colors, int *ncolorsP,
Bool bright_p,
Bool allocate_p,
Bool * writable_pP)
{
Bool wanted_writable = (allocate_p && writable_pP && *writable_pP);
int ncolors = *ncolorsP;
int i;
if (*ncolorsP <= 0)
return;
/* If this visual doesn't support writable cells, don't bother trying. */
if (wanted_writable && !has_writable_cells(mi))
*writable_pP = False;
for (i = 0; i < ncolors; i++) {
colors[i].flags = DoRed | DoGreen | DoBlue;
if (bright_p) {
int H = (int) LRAND() % 360; /* range 0-360 */
double S = ((double) (LRAND() % 70) + 30) / 100.0; /* range 30%-100% */
double V = ((double) (LRAND() % 34) + 66) / 100.0; /* range 66%-100% */
hsv_to_rgb(H, S, V,
&colors[i].red, &colors[i].green, &colors[i].blue);
} else {
colors[i].red = (unsigned short) (LRAND() % 0xFFFF);
colors[i].green = (unsigned short) (LRAND() % 0xFFFF);
colors[i].blue = (unsigned short) (LRAND() % 0xFFFF);
}
}
if (!allocate_p)
return;
RETRY_NON_WRITABLE:
if (writable_pP && *writable_pP) {
unsigned long *pixels = (unsigned long *)
malloc(sizeof (unsigned long) * (ncolors + 1));
allocate_writable_colors(MI_DISPLAY(mi), cmap, pixels, &ncolors);
if (ncolors > 0)
for (i = 0; i < ncolors; i++)
colors[i].pixel = pixels[i];
free(pixels);
if (ncolors > 0)
XStoreColors(MI_DISPLAY(mi), cmap, colors, ncolors);
} else {
for (i = 0; i < ncolors; i++) {
XColor color;
color = colors[i];
if (!XAllocColor(MI_DISPLAY(mi), cmap, &color))
break;
colors[i].pixel = color.pixel;
}
ncolors = i;
}
/* If we tried for writable cells and got none, try for non-writable. */
if (allocate_p && ncolors == 0 && writable_pP && *writable_pP) {
ncolors = *ncolorsP;
*writable_pP = False;
goto RETRY_NON_WRITABLE;
}
if (MI_IS_VERBOSE(mi) || MI_IS_DEBUG(mi))
complain(*ncolorsP, ncolors, wanted_writable,
wanted_writable && *writable_pP);
*ncolorsP = ncolors;
}
static void tok_take_unknown_statement(struct parse_state *ps)
{
complain(ps, "Ignoring unknown statement until next semicolon");
tal_free(tok_take_until(NULL, &ps->toks, ";"));
tok_take_if(&ps->toks, ";");
}
void
make_smooth_colormap(ModeInfo * mi, Colormap cmap,
XColor * colors, int *ncolorsP,
Bool allocate_p,
Bool * writable_pP)
{
int npoints;
int ncolors = *ncolorsP;
Bool wanted_writable = (allocate_p && writable_pP && *writable_pP);
int i;
int h[MAXPOINTS];
double s[MAXPOINTS];
double v[MAXPOINTS];
double total_s = 0;
double total_v = 0;
if (*ncolorsP <= 0)
return;
{
int n = (int) (LRAND() % 20);
if (n <= 5)
npoints = 2; /* 30% of the time */
else if (n <= 15)
npoints = 3; /* 50% of the time */
else if (n <= 18)
npoints = 4; /* 15% of the time */
else
npoints = 5; /* 5% of the time */
}
REPICK_ALL_COLORS:
for (i = 0; i < npoints; i++) {
REPICK_THIS_COLOR:
h[i] = (int) (LRAND() % 360);
s[i] = LRAND() / MAXRAND;
v[i] = 0.8 * LRAND() / MAXRAND + 0.2;
/* Make sure that no two adjascent colors are *too* close together.
If they are, try again.
*/
if (i > 0) {
int j = (i + 1 == npoints) ? 0 : (i - 1);
double hi = ((double) h[i]) / 360;
double hj = ((double) h[j]) / 360;
double dh = hj - hi;
double distance;
if (dh < 0)
dh = -dh;
if (dh > 0.5)
dh = 0.5 - (dh - 0.5);
distance = sqrt((dh * dh) +
((s[j] - s[i]) * (s[j] - s[i])) +
((v[j] - v[i]) * (v[j] - v[i])));
if (distance < 0.2)
goto REPICK_THIS_COLOR;
}
total_s += s[i];
total_v += v[i];
}
/* If the average saturation or intensity are too low, repick the colors,
so that we don't end up with a black-and-white or too-dark map.
*/
if (total_s / npoints < 0.2)
goto REPICK_ALL_COLORS;
if (total_v / npoints < 0.3)
goto REPICK_ALL_COLORS;
/* If this visual doesn't support writable cells, don't bother trying.
*/
if (wanted_writable && !has_writable_cells(mi))
*writable_pP = False;
RETRY_NON_WRITABLE:
make_color_path(MI_DISPLAY(mi), cmap, npoints, h, s, v, colors, &ncolors,
allocate_p, (writable_pP && *writable_pP));
/* If we tried for writable cells and got none, try for non-writable. */
if (allocate_p && *ncolorsP == 0 && *writable_pP) {
*writable_pP = False;
goto RETRY_NON_WRITABLE;
}
if (MI_IS_VERBOSE(mi) || MI_IS_DEBUG(mi))
complain(*ncolorsP, ncolors, wanted_writable,
wanted_writable && *writable_pP);
*ncolorsP = ncolors;
}
static
#define getopt_std_args int argc, CHAR *const argv[], const CHAR *optstring
int getopt_parse( int mode, getopt_std_args, ... )
{
/* Common core implementation for ALL `getopt' functions.
*/
static int argind = 0;
static int optbase = 0;
static const CHAR *nextchar = NULL;
static int optmark = 0;
unsigned int optreset = 0;
if( (optreset |= (optind < 1)) || (optind < optbase) )
{
/* POSIX does not prescribe any definitive mechanism for restarting
* a `getopt' scan, but some applications may require such capability.
* We will support it, by allowing the caller to adjust the value of
* `optind' downwards, (nominally setting it to zero). Since POSIX
* wants `optind' to have an initial value of one, but we want all
* of our internal place holders to be initialised to zero, when we
* are called for the first time, we will handle such a reset by
* adjusting all of the internal place holders to one less than
* the adjusted `optind' value, (but never to less than zero).
*/
if( optreset )
{
/* User has explicitly requested reinitialisation...
* We need to reset `optind' to it's normal initial value of 1,
* to avoid a potential infinitely recursive loop; by doing this
* up front, we also ensure that the remaining place holders
* will be correctly reinitialised to no less than zero.
*/
optind = 1;
/* We also need to clear the `optreset' request...
*/
optreset = 0;
}
/* Now, we may safely reinitialise the internal place holders, to
* one less than `optind', without fear of making them negative.
*/
optmark = optbase = argind = optind - 1;
nextchar = NULL;
}
/* From a POSIX perspective, the following is `undefined behaviour';
* we implement it thus, for compatibility with GNU and BSD getopt.
*/
else if( optind > (argind + 1) )
{
/* Some applications expect to be able to manipulate `optind',
* causing `getopt' to skip over one or more elements of `argv';
* POSIX doesn't require us to support this brain-damaged concept;
* (indeed, POSIX defines no particular behaviour, in the event of
* such usage, so it must be considered a bug for an application
* to rely on any particular outcome); nonetheless, Mac-OS-X and
* BSD actually provide *documented* support for this capability,
* so we ensure that our internal place holders keep track of
* external `optind' increments; (`argind' must lag by one).
*/
argind = optind - 1;
/* When `optind' is misused, in this fashion, we also abandon any
* residual text in the argument we had been parsing; this is done
* without any further processing of such abandoned text, assuming
* that the caller is equipped to handle it appropriately.
*/
nextchar = NULL;
}
if( nextchar && *nextchar )
{
/* we are parsing a standard, or short format, option argument ...
*/
const CHAR *optchar;
if( (optchar = getopt_match( optopt = *nextchar++, optstring )) != NULL )
{
/* we have identified it as valid ...
*/
if( optchar[1] == getopt_takes_argument )
{
/* and determined that it requires an associated argument ...
*/
if( ! *(optarg = (char *)(nextchar)) )
{
/* the argument is NOT attached ...
*/
if( optchar[2] == getopt_takes_argument )
/*
* but this GNU extension marks it as optional,
* so we don't provide one on this occasion.
*/
optarg = NULL;
/* otherwise this option takes a mandatory argument,
* so, provided there is one available ...
*/
else if( (argc - argind) > 1 )
/*
* we take the following command line argument,
* as the appropriate option argument.
*/
optarg = argv[++argind];
/* but if no further argument is available,
* then there is nothing we can do, except for
* issuing the requisite diagnostic message.
*/
else
{
complain( "option requires an argument -- %c", optopt );
return getopt_missing_arg( optstring );
}
}
optind = argind + 1;
nextchar = NULL;
}
else
optarg = NULL;
optind = (nextchar && *nextchar) ? argind : argind + 1;
return optopt;
}
/* if we didn't find a valid match for the specified option character,
* then we fall through to here, so take appropriate diagnostic action.
*/
if( mode == getopt_mode_long_only )
{
complain( "unrecognised option `-%s'", --nextchar );
nextchar = NULL;
optopt = 0;
}
else
complain( "invalid option -- %c", optopt );
optind = (nextchar && *nextchar) ? argind : argind + 1;
return getopt_unknown;
}
if( optmark > optbase )
{
/* This can happen, in GNU parsing mode ONLY, when we have
* skipped over non-option arguments, and found a subsequent
* option argument; in this case we permute the arguments.
*/
int index;
/*
* `optspan' specifies the number of contiguous arguments
* which are spanned by the current option, and so must be
* moved together during permutation.
*/
int optspan = argind - optmark + 1;
/*
* we use `this_arg' to store these temporarily.
*/
#ifdef _MSC_VER
#define alloca _alloca
#endif
CHAR ** this_arg = (CHAR **)alloca(sizeof(CHAR *) * optspan);
/*
* we cannot manipulate `argv' directly, since the `getopt'
* API prototypes it as `read-only'; this cast to `arglist'
* allows us to work around that restriction.
*/
CHAR **arglist = (char **)(argv);
/* save temporary copies of the arguments which are associated
* with the current option ...
*/
for( index = 0; index < optspan; ++index )
this_arg[index] = arglist[optmark + index];
/* move all preceding non-option arguments to the right,
* overwriting these saved arguments, while making space
* to replace them in their permuted location.
*/
for( --optmark; optmark >= optbase; --optmark )
arglist[optmark + optspan] = arglist[optmark];
/* restore the temporarily saved option arguments to
* their permuted location.
*/
for( index = 0; index < optspan; ++index )
arglist[optbase + index] = this_arg[index];
/* adjust `optbase', to account for the relocated option.
*/
optbase += optspan;
}
else
/* no permutation occurred ...
* simply adjust `optbase' for all options parsed so far.
*/
optbase = argind + 1;
/* enter main parsing loop ...
*/
while( argc > ++argind )
{
/* inspect each argument in turn, identifying possible options ...
*/
if( is_switchar( *(nextchar = argv[optmark = argind]) ) && *++nextchar )
{
/* we've found a candidate option argument ... */
if( is_switchar( *nextchar ) )
{
/* it's a double hyphen argument ... */
const CHAR *refchar = nextchar;
if( *++refchar )
{
/* and it looks like a long format option ...
* `getopt_long' mode must be active to accept it as such,
* `getopt_long_only' also qualifies, but we must downgrade
* it to force explicit handling as a long format option.
*/
if( mode >= getopt_mode_long )
{
nextchar = refchar;
mode = getopt_mode_long;
}
}
else
{
/* this is an explicit `--' end of options marker, so wrap up now!
*/
if( optmark > optbase )
{
/* permuting the argument list as necessary ...
* (note use of `this_arg' and `arglist', as above).
*/
CHAR *this_arg = argv[optmark];
CHAR **arglist = (CHAR **)(argv);
/* move all preceding non-option arguments to the right ...
*/
do arglist[optmark] = arglist[optmark - 1];
while( optmark-- > optbase );
/* reinstate the `--' marker, in its permuted location.
*/
arglist[optbase] = this_arg;
}
/* ... before finally bumping `optbase' past the `--' marker,
* and returning the `all done' completion indicator.
*/
optind = ++optbase;
return getopt_all_done;
}
}
else if( mode < getopt_mode_long_only )
{
/* it's not an explicit long option, and `getopt_long_only' isn't active,
* so we must explicitly try to match it as a short option.
*/
mode = getopt_mode_standard;
}
if( mode >= getopt_mode_long )
{
/* the current argument is a long form option, (either explicitly,
* introduced by a double hyphen, or implicitly because we were called
* by `getopt_long_only'); this is where we parse it.
*/
int lookup;
int matched = -1;
/* we need to fetch the `extra' function arguments, which are
* specified for the `getopt_long' APIs.
*/
va_list refptr;
va_start( refptr, optstring );
struct option *longopts = va_arg( refptr, struct option * );
int *optindex = va_arg( refptr, int * );
va_end( refptr );
/* ensuring that `optarg' does not inherit any junk, from parsing
* preceding arguments ...
*/
optarg = NULL;
for( lookup = 0; longopts && longopts[lookup].name; ++lookup )
{
/* scan the list of defined long form options ...
*/
switch( getopt_match_long( nextchar, longopts[lookup].name ) )
{
/* looking for possible matches for the current argument.
*/
case getopt_exact_match:
/*
* when an exact match is found,
* return it immediately, setting `nextchar' to NULL,
* to ensure we don't mistakenly try to match any
* subsequent characters as short form options.
*/
nextchar = NULL;
return getopt_resolved( mode, argc, argv, &argind,
longopts, lookup, optindex, optstring );
case getopt_abbreviated_match:
/*
* but, for a partial (initial substring) match ...
*/
if( matched >= 0 )
{
/* if this is not the first, then we have an ambiguity ...
*/
if( (mode == getopt_mode_long_only)
/*
* However, in the case of getopt_long_only(), if
* the entire ambiguously matched string represents
* a valid short option specification, then we may
* proceed to interpret it as such.
*/
&& getopt_verify( nextchar, optstring ) )
return getopt_parse( mode, argc, argv, optstring );
/* If we get to here, then the ambiguously matched
* partial long option isn't valid for short option
* evaluation; reset parser context to resume with
* the following command line argument, diagnose
* ambiguity, and bail out.
*/
optopt = 0;
nextchar = NULL;
optind = argind + 1;
complain( "option `%s' is ambiguous", argv[argind] );
return getopt_unknown;
}
/* otherwise just note that we've found a possible match ...
*/
matched = lookup;
}
}
if( matched >= 0 )
{
/* if we get to here, then we found exactly one partial match,
* so return it, as for an exact match.
*/
nextchar = NULL;
return getopt_resolved( mode, argc, argv, &argind,
longopts, matched, optindex, optstring );
}
/* if here, then we had what SHOULD have been a long form option,
* but it is unmatched ...
*/
if( (mode < getopt_mode_long_only)
/*
* ... although paradoxically, `mode == getopt_mode_long_only'
* allows us to still try to match it as a short form option.
*/
|| (getopt_verify( nextchar, optstring ) == 0) )
{
/* When it cannot be matched, reset the parsing context to
* resume from the next argument, diagnose the failed match,
* and bail out.
*/
optopt = 0;
nextchar = NULL;
optind = argind + 1;
complain( "unrecognised option `%s'", argv[argind] );
return getopt_unknown;
}
}
/* fall through to handle standard short form options...
* when the option argument format is neither explictly identified
* as long, nor implicitly matched as such, and the argument isn't
* just a bare hyphen, (which isn't an option), then we make one
* recursive call to explicitly interpret it as short format.
*/
if( *nextchar )
return getopt_parse( mode, argc, argv, optstring );
}
/* if we get to here, then we've parsed a non-option argument ...
* in GNU compatibility mode, we step over it, so we can permute
* any subsequent option arguments, but ...
*/
if( *optstring == getopt_switchar )
{
/* if `optstring' begins with a `-' character, this special
* GNU specific behaviour requires us to return the non-option
* arguments in strict order, as pseudo-arguments to a special
* option, with return value defined as `getopt_ordered'.
*/
nextchar = NULL;
optind = argind + 1;
optarg = argv[argind];
return getopt_ordered;
}
if( getopt_conventions( *optstring ) & getopt_posixly_correct )
/*
* otherwise ...
* for POSIXLY_CORRECT behaviour, or if `optstring' begins with
* a `+' character, then we break out of the parsing loop, so that
* the scan ends at the current argument, with no permutation.
*/
break;
}
int main(int argc, char **argv)
{ Pf *pf;
char *orbname,
*dbname,
*expr,
*table,
*rowtemp,
verbose;
int orb,
totalrecords,
records,
record;
Dbptr db,
dbinput,
dbscratch;
elog_init(argc,argv);
/* initialize variables */
verbose = 0;
expr = NULL;
loop = 0;
record = 0;
totalrecords = 0;
rowtemp = malloc(ROW_MAX_LENGTH);
if (rowtemp == NULL) die(1,"malloc() error.\n");
/* read in command line options */
{ int c;
unsigned char errflg = 0;
while (( c = getopt( argc, argv, "vl:s:")) != -1)
switch (c) {
case 'l': loop = atoi(optarg);
sigset(SIGINT,done);
break;
case 's': expr = optarg;
break;
case 'v': verbose = 1;
break;
case '?': errflg++;
}
if ( (argc - optind) != 3 ) errflg++;
if (errflg)
{ elog_die(0,"usage: %s [-v] [-s subset] [-l delay] db table orb\n",argv[0]);
}
dbname = argv[optind++];
table = argv[optind++];
orbname= argv[optind++];
}
/* start our work */
if ( dbopen ( dbname, "r+", &dbinput ) == dbINVALID )
{ elog_die(1,"Couldn't open input database, \"%s\".\n",dbname); }
dbinput = dblookup( dbinput, 0, table, 0, 0);
dbscratch = dblookup( dbinput, 0, 0, 0, "dbSCRATCH");
if ( dbinput.table == dbINVALID )
{ elog_die(1,"Couldn't lookup the table \"%s\" in the database \"%s\".\n",
table,dbname); }
if ( dbscratch.record == dbINVALID )
{ elog_die(1,"Couldn't lookup the scratch record in the database \"%s\".\n",
dbname); }
if ( dbquery( dbinput, dbRECORD_COUNT, &records) < 0 )
{ elog_die(1,"dbquery dbRECORD_COUNT failed.\n"); }
orb = orbopen( orbname, "w&" );
if ( orb == -1 )
{ elog_die(1,"Couldn't open the orb, \"%s\".\n",orbname); }
if (loop == 0) loop = -1;
while (loop)
{ db = dbinput;
if ( expr != NULL) db = dbsubset( db, expr, 0 );
db.record = record;
if ( dbquery( db, dbRECORD_COUNT, &records) < 0 )
elog_die(1,"dbquery dbRECORD_COUNT failed.\n");
for (;db.record<records;db.record++)
{ if (verbose) printf("writing record %d to orb...\n",db.record);
/* copy the row from what could be a view into the scratch record of the
input database, so as to avoid putting a view on the ORB */
if ( dbget( db, rowtemp) == dbINVALID ) die(1,"dbget error.\n");
if ( dbput( dbscratch, rowtemp) == dbINVALID ) die(1,"dbput error.\n");
if ( db2orbpkt( dbscratch, orb ) < 0 )
{ complain ( 0, "Couldn't write record #%d to %s.\n",
db.record, orbname); }
totalrecords++;
}
record = db.record;
/* if a subset expression was supplied, then we're working with
a view, which should be freed. */
if ( expr != NULL) dbfree(db);
if ( loop == -1 ) loop = 0;
sleep(loop);
}
printf("posted %d records from database %s to orb %s.\n",totalrecords,dbname,orbname);
dbclose(dbinput);
orbclose(orb);
free(rowtemp);
}
/* Check the result of a unary operation. */
static void
check_result_for_unary(const irop_t *op, const test_data_t *data)
{
const opnd_t *result = &data->result;
const opnd_t *opnd = &data->opnds[0];
unsigned num_bits = result->vbits.num_bits;
vbits_t expected_vbits;
/* Only handle those undef-kinds that actually occur. */
switch (op->undef_kind) {
case UNDEF_ALL:
expected_vbits = undefined_vbits(num_bits);
break;
case UNDEF_SAME:
expected_vbits = opnd->vbits;
break;
case UNDEF_TRUNC:
expected_vbits = truncate_vbits(opnd->vbits, num_bits);
break;
case UNDEF_LEFT:
expected_vbits = left_vbits(opnd->vbits, num_bits);
break;
case UNDEF_UPPER:
assert(num_bits * 2 == opnd->vbits.num_bits);
expected_vbits = upper_vbits(opnd->vbits);
break;
case UNDEF_SEXT:
expected_vbits = sextend_vbits(opnd->vbits, num_bits);
break;
case UNDEF_ZEXT:
expected_vbits = zextend_vbits(opnd->vbits, num_bits);
break;
case UNDEF_ALL_64x2:
assert(num_bits == 128);
expected_vbits = undefined_vbits_BxE(64, 2, opnd->vbits);
break;
case UNDEF_ALL_32x4:
assert(num_bits == 128);
expected_vbits = undefined_vbits_BxE(32, 4, opnd->vbits);
break;
case UNDEF_ALL_16x8:
assert(num_bits == 128);
expected_vbits = undefined_vbits_BxE(16, 8, opnd->vbits);
break;
case UNDEF_ALL_8x16:
assert(num_bits == 128);
expected_vbits = undefined_vbits_BxE(8, 16, opnd->vbits);
break;
case UNDEF_64x2_TRANSPOSE:
assert(num_bits == 128);
expected_vbits = undefined_vbits_64x2_transpose(opnd->vbits);
break;
default:
panic(__func__);
}
if (! equal_vbits(result->vbits, expected_vbits))
complain(op, data, expected_vbits);
}
int main (int argc, char **argv) {
int c,
errflg = 0;
Dbptr db, tr;
char *database,*outfile, *pfname=0;
Flags flags ;
Pf *pf,*pf_def,*pf_sta=NULL,*pf_stas;
Tbl *input;
char *start, *stop, *triggertimestring=NULL ;
char *subset=0 ;
long nrecords,nsamp1 ;
int duration,nframes,sampsperframe;
double tstart, tstop, triggertime=0;
char sta[STA_LEN],sta1[STA_LEN];
char chan[STA_LEN],chan1[STA_LEN];
double samprate,samprate1,t1,t2;
FILE *fout;
size_t nw;
unsigned char *hdrbuf=malloc(2040);
unsigned char *framebuf=malloc(32);
unsigned char *tagbuf=malloc(16);
unsigned short cksum;
unsigned char wfarr[3 * 12 * 100]; /*1000sps * 0.1 sec * 12 chan * 3bytes*/
int sampindex=0;
K2EvtFile *myhdr=malloc(2040);
K2EvtTag *mytag=malloc(sizeof(K2EvtTag));
K2EvtFrame *myframe=malloc(sizeof(K2EvtFrame));
float *data[12] ;
unsigned short channelBitmap=0;
int pf_serialno,pf_sensortype;
double pf_sensitivity, pf_fullscale, pf_lat, pf_lon, pf_elev;
memset ( &flags, 0, sizeof(flags));
elog_init ( argc, argv ) ;
while ((c = getopt (argc, argv, "do:p:s:t:v")) != -1) {
switch (c) {
case 'd':
flags.display = 1 ;
break ;
case 'p':
pfname= optarg ;
break;
case 's':
subset = optarg ;
break ;
case 't':
triggertimestring = optarg ;
break ;
case 'v':
flags.verbose++ ;
break;
default:
errflg++;
break ;
}
}
if (errflg || argc-optind != 4)
usage ();
if (pfname==NULL) {
pfname=Program_Name;
}
if (pfread (pfname, &pf) != 0)
die (0, "Can't read parameter file %s\n",pfname);
database = argv[optind++];
outfile = argv[optind++];
start = argv[optind++];
stop = argv[optind++];
tstart=str2epoch(start);
tstop=str2epoch(stop);
tstart=ceil(tstart); /* make sure we have second boundaries,
this also makes sure we have a integer number of frames */
tstop=floor(tstop);
duration=tstop - tstart;
if ( dbopen(database, "r", &db) ) {
die ( 0, "Can't open database %s", database ) ;
}
input = pfget_tbl (pf, "view" ) ;
db = dbprocess ( db, input, 0 ) ;
if (subset) {
db=dbsubset(db,subset,0);
}
tr = dbinvalid() ;
if ( trload_css ( db, start, stop, &tr, 0, 0 ) ) {
die ( 1, "trload_css failed" ) ;
}
if ( trsplit(tr, 0, 0) ) {
complain ( 0, "trsplit failed" ) ;
}
if ( trsplice(tr, 0, 0, 0) ) {
complain ( 0, "trsplice failed" ) ;
}
if ( flags.display ) {
trdisp (tr, "will try to convert this stuff to evt") ;
}
tr.record=0;
dbgetv(tr,0,"time",&t1,"endtime",&t2,"sta",sta1,"chan",chan1,"samprate",&samprate1,"nsamp",&nsamp1,NULL);
samprate1=round(samprate1);
dbquery ( tr, dbRECORD_COUNT, &nrecords ) ;
if (nrecords > 12) {
printf("will only use the first 12 channels, consider modifying the subset...");
nrecords=12;
}
for ( tr.record = 0 ; tr.record < nrecords ; tr.record++ ) {
double ts,te;
dbgetv(tr,0,"time",&ts,"endtime",&te,"samprate",&samprate,"sta",sta,"chan",chan,NULL);
samprate=round(samprate);
if (t1 != ts || t2 != te) {
die ( 0, "this simplistic version only works with 101% correct times and/or subsets, sorry..." ) ;
}
if (strcmp(sta,sta1) !=0) {
die ( 0, "%s <=> %s this simplistic version only works with ONE station, but the subset left more",sta,sta1 ) ;
}
if (samprate != samprate1) {
die ( 0, "all channels in a K2-EVT File MUST have the same samplerate!" );
}
}
newFileHeader(&myhdr, pf, sta);
if (parse_param (pf, "sta_defaults", P_ARRPF, 1, &pf_def) < 0) {
elog_die (0, "error parsing array sta_defaults.\n");
}
if (parse_param (pf, "sta_params", P_ARRPF, 1, &pf_stas) < 0) {
elog_die (0, "error parsing array sta_params.\n");
}
if (parse_param (pf_stas, sta, P_ARRPF, 0, &pf_sta) < 0) {
elog_die (0, "error parsing sta_params{%s}\n.",sta);
}
if (parse_param(pf_def,"sensortype",P_LINT,1,&pf_sensortype)< 0 ) {
elog_die (0, "error parsing default sensortype.\n");
}
if (parse_param(pf_def,"serialno",P_LINT,1,&pf_serialno)< 0 ) {
elog_die (0, "error parsing default serialno.\n");
}
if (parse_param(pf_def,"sensitivity",P_DBL,1,&pf_sensitivity)< 0 ) {
elog_die (0, "error parsing default sensitivity.\n");
}
if (parse_param(pf_def,"fullscale",P_DBL,1,&pf_fullscale)< 0 ) {
elog_die (0, "error parsing default fullscale.\n");
}
if (parse_param(pf_def,"lat",P_DBL,1,&pf_lat)< 0 ) {
elog_die (0, "error parsing default lat.\n");
}
if (parse_param(pf_def,"lon",P_DBL,1,&pf_lon)< 0 ) {
elog_die (0, "error parsing default lon.\n");
}
if (parse_param(pf_def,"elev",P_DBL,1,&pf_elev)< 0 ) {
elog_die (0, "error parsing default elev.\n");
}
if (pf_sta==NULL) {
elog_notify (0, "can't parse array sta_params{%s}, will use defaults\n.",sta);
pf_sta=pf_def;
} else {
if (parse_param(pf_def,"sensortype",P_LINT,0,&pf_sensortype)< 0 ) {
elog_die (0, "error parsing sensortype.\n");
}
if (parse_param(pf_sta,"serialno",P_LINT,0,&pf_serialno)< 0 ) {
elog_die (0, "error parsing serialno.\n");
}
if (parse_param(pf_sta,"sensitivity",P_DBL,0,&pf_sensitivity)< 0 ) {
elog_die (0, "error parsing sensitivity.\n");
}
if (parse_param(pf_sta,"fullscale",P_DBL,0,&pf_fullscale)< 0 ) {
elog_die (0, "error parsing fullscale.\n");
}
if (parse_param(pf_sta,"lat",P_DBL,0,&pf_lat)< 0 ) {
elog_die (0, "error parsing lat.\n");
}
if (parse_param(pf_sta,"lon",P_DBL,0,&pf_lon)< 0 ) {
elog_die (0, "error parsing lon.\n");
}
if (parse_param(pf_sta,"elev",P_DBL,0,&pf_elev)< 0 ) {
elog_die (0, "error parsing elev.\n");
}
}
myhdr->rw_stream.sps=samprate; /* sampling rate */
myhdr->rw_stream.preEvent=1; /* in seconds */
myhdr->rw_stream.postEvent=5; /* in seconds */
myhdr->rw_stream.minRunTime=6; /* in seconds */
myhdr->ro_stream.duration=duration;
myhdr->ro_stream.nscans=duration* 10;
myhdr->ro_stream.startTime=epoch2k2time(t1);
myhdr->ro_stream.startTimeMsec=0;
int ttms=0;
if (triggertimestring) {
triggertime=str2epoch(triggertimestring);
ttms=remainder(triggertime,1.0 ) * 1000.0;
triggertime=epoch2k2time(triggertime);
} else {
triggertime=epoch2k2time(t1)+5;
ttms=0;
}
myhdr->ro_stream.triggerTime=triggertime;
myhdr->ro_stream.triggerTimeMsec=ttms;
myhdr->rw_misc.nchannels=nrecords;
for (int channo=0;channo< nrecords;channo++) {
myhdr->rw_channel[channo].sensitivity=pf_sensitivity;
myhdr->rw_channel[channo].sensitivity=pf_fullscale;
}
myhdr->rw_misc.elevation=pf_elev; /* meters above sea level */
myhdr->rw_misc.latitude=pf_lat; /* degrees north */
myhdr->rw_misc.longitude=pf_lon; /* degrees east */
nframes=duration * 10;
myhdr->ro_stream.duration=nframes;
myhdr->ro_stream.nscans=duration*samprate;
channelBitmap=chanbitmap(nrecords);
for ( tr.record = 0 ; tr.record < nrecords ; tr.record++ ) {
unsigned long i ;
int nsamp;
char chan[7];
unsigned long minoffset=0;
unsigned long maxoffset=0;
int max=INT_MIN;
int min=INT_MAX;
dbgetv(tr, 0, "chan",chan,"data", &data[tr.record], "nsamp", &nsamp, NULL ) ;
for ( i=0 ; i<nsamp ; i++ ) {
if (data[tr.record][i] > max) {
max=data[tr.record][i];
maxoffset=i;
}
if (data[tr.record][i] < min) {
min=data[tr.record][i];
minoffset=i;
}
}
myhdr->ro_channel[tr.record].maxPeak=max;
myhdr->ro_channel[tr.record].maxPeakOffset=maxoffset;
myhdr->ro_channel[tr.record].minPeak=min;
myhdr->ro_channel[tr.record].minPeakOffset=minoffset;
memcpy(myhdr->rw_channel[tr.record].id,chan,K2EVT_CHANNEL_ID_LENGTH);
}
for ( tr.record = 0 ; tr.record < nrecords ; tr.record++ ) {
}
newTag(&mytag,0, 2040, 0, 128,1234);
encodek2header(hdrbuf,myhdr);
cksum=k2_checksum(hdrbuf,2040);
mytag->length=2040;/*header size*/
mytag->dataLength=0;
mytag->checksum=cksum;
encodek2tag(tagbuf,mytag);
fout=fopen(outfile,"w+");
nw=fwrite(tagbuf,16,1,fout);
nw=fwrite(hdrbuf,2040,1,fout);
double t=t1 ;
double k2t=round(epoch2k2time(t));
newFrameHeader(&myframe,128,(sampsperframe*3*nrecords)+32, k2t);
sampsperframe=TIME2SAMP(0,samprate,0.1);/*samples per frame*/
for (int fn=0;fn < nframes;fn++) {
cksum=0;
sampindex=0;
for (int s=0;s<sampsperframe;s++) {
long val;
unsigned char buf[4];
for ( int channo = 0 ; channo < nrecords ; channo++ ) {
int index=((fn*sampsperframe) + s);
val=round(data[channo][index]);
/*debugging...*/
//val=66051;/*0x010203*/
memcpy(&buf,&val,4);
val <<=8;
#ifdef WORDS_BIGENDIAN
cksum+=buf[1];
cksum+=buf[2];
cksum+=buf[3];
wfarr[sampindex++]=buf[1];
wfarr[sampindex++]=buf[2];
wfarr[sampindex++]=buf[3];
#else
cksum+=buf[2];
cksum+=buf[1];
cksum+=buf[0];
wfarr[sampindex++]=buf[2];
wfarr[sampindex++]=buf[1];
wfarr[sampindex++]=buf[0];
#endif
}
}
mytag->checksum=cksum;
mytag->length=32;/*header size*/
mytag->dataLength=sampsperframe * nrecords * 3;
myframe->frameSize=(sampsperframe*3*nrecords)+32;
myframe->blockTime=round(k2t);
myframe->msec=fmod(k2t,1.0) * 1000;
myframe->channelBitMap=channelBitmap;
encodek2Frame(framebuf,myframe);
mytag->checksum+=k2_checksum(framebuf,32);
encodek2tag(tagbuf,mytag);
k2t+=0.1;
//k2t=round((k2t+0.1)*10.0)/10.0;
nw=fwrite(tagbuf,1,16,fout);
if (nw!= 16) {
die(0,"could not write file tag, wrote %d bytes instead of 16",nw);
}
nw=fwrite(framebuf,32,1,fout);
nw=fwrite(&wfarr, 1,sampsperframe * 3 * nrecords, fout);
}
fclose(fout);
tr.table = dbALL ;
trfree(tr) ;
pffree(pf) ;
return 0;
}
void
conflicts_print (void)
{
/* Is the number of SR conflicts OK? Either EXPECTED_CONFLICTS is
not set, and then we want 0 SR, or else it is specified, in which
case we want equality. */
bool src_ok;
bool rrc_ok;
int src_total = 0;
int rrc_total = 0;
int src_expected;
int rrc_expected;
/* Conflicts by state. */
{
state_number i;
for (i = 0; i < nstates; i++)
if (conflicts[i])
{
src_total += count_sr_conflicts (states[i]);
rrc_total += count_rr_conflicts (states[i], true);
}
}
if (! glr_parser && rrc_total > 0 && expected_rr_conflicts != -1)
{
warn (_("%%expect-rr applies only to GLR parsers"));
expected_rr_conflicts = -1;
}
src_expected = expected_sr_conflicts == -1 ? 0 : expected_sr_conflicts;
rrc_expected = expected_rr_conflicts == -1 ? 0 : expected_rr_conflicts;
src_ok = src_total == src_expected;
rrc_ok = rrc_total == rrc_expected;
/* If there are as many RR conflicts and SR conflicts as
expected, then there is nothing to report. */
if (rrc_ok & src_ok)
return;
/* Report the total number of conflicts on STDERR. */
if (expected_sr_conflicts == -1 && expected_rr_conflicts == -1)
{
if (!(warnings_flag & warnings_conflicts_sr))
src_total = 0;
if (!(warnings_flag & warnings_conflicts_rr))
rrc_total = 0;
}
if (src_total | rrc_total)
{
if (expected_sr_conflicts == -1 && expected_rr_conflicts == -1)
set_warning_issued ();
if (! yacc_flag)
fprintf (stderr, "%s: ", current_file);
conflict_report (stderr, src_total, rrc_total);
}
if (expected_sr_conflicts != -1 || expected_rr_conflicts != -1)
{
if (! src_ok)
complain (ngettext ("expected %d shift/reduce conflict",
"expected %d shift/reduce conflicts",
src_expected),
src_expected);
if (! rrc_ok)
complain (ngettext ("expected %d reduce/reduce conflict",
"expected %d reduce/reduce conflicts",
rrc_expected),
rrc_expected);
}
}
int main(int ac, char **av)
{
FILE *ifh;
char *p;
int n;
int linenum;
char *line = NULL;
size_t linel = 0;
for (;;) {
int c = getopt_long(ac,av,"c:s",lopt,NULL);
if (c == -1) break;
switch (c) {
default:
case '?':
usage();
case 'c':
fname = optarg;
break;
case 's':
use_syslog = 1;
break;
}
}
if (use_syslog)
openlog("nameif",0,LOG_LOCAL0);
while (optind < ac) {
struct change *ch = xmalloc(sizeof(struct change));
char pos[30];
if ((ac-optind) & 1)
usage();
if (strlen(av[optind])+1>IFNAMSIZ)
complain(_("interface name `%s' too long"), av[optind]);
strcpy(ch->ifname, av[optind]);
optind++;
sprintf(pos,_("argument %d"),optind);
addchange(av[optind], ch, pos);
optind++;
}
if (!clist || fname != default_conf)
readconf();
ifh = fopen("/proc/net/dev", "r");
if (!ifh) complain(_("open of /proc/net/dev: %s"), strerror(errno));
linenum = 0;
while (getdelim(&line, &linel, '\n', ifh) > 0) {
struct change *ch;
unsigned char mac[6];
if (linenum++ < 2)
continue;
p = line;
while (isspace(*p))
++p;
n = strcspn(p, ": \t");
p[n] = 0;
if (n > IFNAMSIZ-1)
complain(_("interface name `%s' too long"), p);
if (getmac(p, mac) < 0)
continue;
ch = lookupmac(mac);
if (!ch)
continue;
*ch->pprev = ch->next;
if (strcmp(p, ch->ifname)) {
if (setname(p, ch->ifname) < 0)
complain(_("cannot change name of %s to %s: %s"),
p, ch->ifname, strerror(errno));
}
free(ch);
}
fclose(ifh);
while (clist) {
struct change *ch = clist;
clist = clist->next;
warning(_("interface '%s' not found"), ch->ifname);
free(ch);
}
if (use_syslog)
closelog();
return 0;
}
static void
elf_symtab_read (struct objfile *objfile, int dynamic)
{
long storage_needed;
asymbol *sym;
asymbol **symbol_table;
long number_of_symbols;
long i;
int index;
struct cleanup *back_to;
CORE_ADDR symaddr;
CORE_ADDR offset;
enum minimal_symbol_type ms_type;
/* If sectinfo is nonNULL, it contains section info that should end up
filed in the objfile. */
struct stab_section_info *sectinfo = NULL;
/* If filesym is nonzero, it points to a file symbol, but we haven't
seen any section info for it yet. */
asymbol *filesym = 0;
#ifdef SOFUN_ADDRESS_MAYBE_MISSING
/* Name of filesym, as saved on the symbol_obstack. */
char *filesymname = obsavestring ("", 0, &objfile->symbol_obstack);
#endif
struct dbx_symfile_info *dbx = objfile->sym_stab_info;
unsigned long size;
int stripped = (bfd_get_symcount (objfile->obfd) == 0);
if (dynamic)
{
storage_needed = bfd_get_dynamic_symtab_upper_bound (objfile->obfd);
/* Nothing to be done if there is no dynamic symtab. */
if (storage_needed < 0)
return;
}
else
{
storage_needed = bfd_get_symtab_upper_bound (objfile->obfd);
if (storage_needed < 0)
error ("Can't read symbols from %s: %s", bfd_get_filename (objfile->obfd),
bfd_errmsg (bfd_get_error ()));
}
if (storage_needed > 0)
{
symbol_table = (asymbol **) xmalloc (storage_needed);
back_to = make_cleanup (xfree, symbol_table);
if (dynamic)
number_of_symbols = bfd_canonicalize_dynamic_symtab (objfile->obfd,
symbol_table);
else
number_of_symbols = bfd_canonicalize_symtab (objfile->obfd, symbol_table);
if (number_of_symbols < 0)
error ("Can't read symbols from %s: %s", bfd_get_filename (objfile->obfd),
bfd_errmsg (bfd_get_error ()));
for (i = 0; i < number_of_symbols; i++)
{
sym = symbol_table[i];
if (sym->name == NULL || *sym->name == '\0')
{
/* Skip names that don't exist (shouldn't happen), or names
that are null strings (may happen). */
continue;
}
offset = ANOFFSET (objfile->section_offsets, sym->section->index);
if (dynamic
&& sym->section == &bfd_und_section
&& (sym->flags & BSF_FUNCTION))
{
struct minimal_symbol *msym;
/* Symbol is a reference to a function defined in
a shared library.
If its value is non zero then it is usually the address
of the corresponding entry in the procedure linkage table,
plus the desired section offset.
If its value is zero then the dynamic linker has to resolve
the symbol. We are unable to find any meaningful address
for this symbol in the executable file, so we skip it. */
symaddr = sym->value;
if (symaddr == 0)
continue;
symaddr += offset;
msym = record_minimal_symbol_and_info
((char *) sym->name, symaddr,
mst_solib_trampoline, NULL, sym->section, objfile);
#ifdef SOFUN_ADDRESS_MAYBE_MISSING
if (msym != NULL)
msym->filename = filesymname;
#endif
continue;
}
/* If it is a nonstripped executable, do not enter dynamic
symbols, as the dynamic symbol table is usually a subset
of the main symbol table. */
if (dynamic && !stripped)
continue;
if (sym->flags & BSF_FILE)
{
/* STT_FILE debugging symbol that helps stabs-in-elf debugging.
Chain any old one onto the objfile; remember new sym. */
if (sectinfo != NULL)
{
sectinfo->next = dbx->stab_section_info;
dbx->stab_section_info = sectinfo;
sectinfo = NULL;
}
filesym = sym;
#ifdef SOFUN_ADDRESS_MAYBE_MISSING
filesymname =
obsavestring ((char *) filesym->name, strlen (filesym->name),
&objfile->symbol_obstack);
#endif
}
else if (sym->flags & (BSF_GLOBAL | BSF_LOCAL | BSF_WEAK))
{
struct minimal_symbol *msym;
/* Select global/local/weak symbols. Note that bfd puts abs
symbols in their own section, so all symbols we are
interested in will have a section. */
/* Bfd symbols are section relative. */
symaddr = sym->value + sym->section->vma;
/* Relocate all non-absolute symbols by the section offset. */
if (sym->section != &bfd_abs_section)
{
symaddr += offset;
}
/* For non-absolute symbols, use the type of the section
they are relative to, to intuit text/data. Bfd provides
no way of figuring this out for absolute symbols. */
if (sym->section == &bfd_abs_section)
{
/* This is a hack to get the minimal symbol type
right for Irix 5, which has absolute addresses
with special section indices for dynamic symbols. */
unsigned short shndx =
((elf_symbol_type *) sym)->internal_elf_sym.st_shndx;
switch (shndx)
{
case SHN_MIPS_TEXT:
ms_type = mst_text;
break;
case SHN_MIPS_DATA:
ms_type = mst_data;
break;
case SHN_MIPS_ACOMMON:
ms_type = mst_bss;
break;
default:
ms_type = mst_abs;
}
/* If it is an Irix dynamic symbol, skip section name
symbols, relocate all others by section offset. */
if (ms_type != mst_abs)
{
if (sym->name[0] == '.')
continue;
symaddr += offset;
}
}
else if (sym->section->flags & SEC_CODE)
{
if (sym->flags & BSF_GLOBAL)
{
ms_type = mst_text;
}
else if ((sym->name[0] == '.' && sym->name[1] == 'L')
|| ((sym->flags & BSF_LOCAL)
&& sym->name[0] == '$'
&& sym->name[1] == 'L'))
/* Looks like a compiler-generated label. Skip
it. The assembler should be skipping these (to
keep executables small), but apparently with
gcc on the (OBSOLETE) delta m88k SVR4, it
loses. So to have us check too should be
harmless (but I encourage people to fix this in
the assembler instead of adding checks here). */
continue;
else
{
ms_type = mst_file_text;
}
}
else if (sym->section->flags & SEC_ALLOC)
{
if (sym->flags & (BSF_GLOBAL | BSF_WEAK))
{
if (sym->section->flags & SEC_LOAD)
{
ms_type = mst_data;
}
else
{
ms_type = mst_bss;
}
}
else if (sym->flags & BSF_LOCAL)
{
/* Named Local variable in a Data section. Check its
name for stabs-in-elf. The STREQ macro checks the
first character inline, so we only actually do a
strcmp function call on names that start with 'B'
or 'D' */
index = SECT_OFF_MAX;
if (STREQ ("Bbss.bss", sym->name))
{
index = SECT_OFF_BSS (objfile);
}
else if (STREQ ("Ddata.data", sym->name))
{
index = SECT_OFF_DATA (objfile);
}
else if (STREQ ("Drodata.rodata", sym->name))
{
index = SECT_OFF_RODATA (objfile);
}
if (index != SECT_OFF_MAX)
{
/* Found a special local symbol. Allocate a
sectinfo, if needed, and fill it in. */
if (sectinfo == NULL)
{
sectinfo = (struct stab_section_info *)
xmmalloc (objfile->md, sizeof (*sectinfo));
memset (sectinfo, 0,
sizeof (*sectinfo));
if (filesym == NULL)
{
complain (§ion_info_complaint,
sym->name);
}
else
{
sectinfo->filename =
(char *) filesym->name;
}
}
if (index != -1)
{
if (sectinfo->sections[index] != 0)
{
complain (§ion_info_dup_complaint,
sectinfo->filename);
}
}
else
internal_error (__FILE__, __LINE__,
"Section index uninitialized.");
/* Bfd symbols are section relative. */
symaddr = sym->value + sym->section->vma;
/* Relocate non-absolute symbols by the section offset. */
if (sym->section != &bfd_abs_section)
{
symaddr += offset;
}
if (index != -1)
sectinfo->sections[index] = symaddr;
else
internal_error (__FILE__, __LINE__,
"Section index uninitialized.");
/* The special local symbols don't go in the
minimal symbol table, so ignore this one. */
continue;
}
/* Not a special stabs-in-elf symbol, do regular
symbol processing. */
if (sym->section->flags & SEC_LOAD)
{
ms_type = mst_file_data;
}
else
{
ms_type = mst_file_bss;
}
}
else
{
ms_type = mst_unknown;
}
}
else
{
/* FIXME: Solaris2 shared libraries include lots of
odd "absolute" and "undefined" symbols, that play
hob with actions like finding what function the PC
is in. Ignore them if they aren't text, data, or bss. */
/* ms_type = mst_unknown; */
continue; /* Skip this symbol. */
}
/* Pass symbol size field in via BFD. FIXME!!! */
size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
msym = record_minimal_symbol_and_info
((char *) sym->name, symaddr,
ms_type, (void *) size, sym->section, objfile);
#ifdef SOFUN_ADDRESS_MAYBE_MISSING
if (msym != NULL)
msym->filename = filesymname;
#endif
ELF_MAKE_MSYMBOL_SPECIAL (sym, msym);
}
}
do_cleanups (back_to);
}
}
/*
* send mail
*/
int
mail(Fs *f, char *rcvr, char *user, long et)
{
int pid, i, fd;
int pfd[2];
char *ct, *p;
Waitmsg *w;
char buf[128];
if(pipe(pfd) < 0){
complain("out of pipes: %r");
return 0;
}
switch(pid = fork()){
case -1:
complain("can't fork: %r");
return 0;
case 0:
break;
default:
if(debug)
fprint(2, "started %d\n", pid);
close(pfd[0]);
ct = ctime(et);
p = strchr(ct, '\n');
*p = '.';
fprint(pfd[1], "User '%s's %s expires on %s\n", user, f->msg, ct);
if(f != fs)
fprint(pfd[1], "If you wish to renew contact your local administrator.\n");
p = strrchr(f->keys, '/');
if(p)
p++;
else
p = f->keys;
snprint(buf, sizeof buf, "/adm/warn.%s", p);
fd = open(buf, OREAD);
if(fd >= 0){
while((i = read(fd, buf, sizeof(buf))) > 0)
write(pfd[1], buf, i);
close(fd);
}
close(pfd[1]);
/* wait for warning to be mailed */
for(;;){
w = wait();
if(w == nil)
break;
if(w->pid == pid){
if(debug)
fprint(2, "%d terminated: %s\n", pid, w->msg);
if(w->msg[0] == 0){
free(w);
break;
}else{
free(w);
return 0;
}
}else
free(w);
}
return 1;
}
/* get out of the current namespace */
newns("none", 0);
dup(pfd[0], 0);
close(pfd[0]);
close(pfd[1]);
putenv("upasname", "netkeys");
if(debug){
print("\nto %s\n", rcvr);
execl("/bin/cat", "cat", nil);
}
execl("/bin/upas/send", "send", "-r", rcvr, nil);
/* just in case */
sysfatal("can't exec send: %r");
return 0; /* for compiler */
}
static void
ct_exit(dbref player, dbref i, warn_type flags)
{
dbref j, src, dst;
int count = 0;
int lt;
bool global_return = 0;
/* i must be an exit, must be in a valid room, and must lead to a
* different room
* Remember, for exit i, Exits(i) = source room
* and Location(i) = destination room
*/
dst = Destination(i);
if ((flags & W_EXIT_UNLINKED) && (dst == NOTHING))
complain(player, i, "exit-unlinked",
T("exit is unlinked; anyone can steal it"));
if ((flags & W_EXIT_UNLINKED) && dst == AMBIGUOUS) {
ATTR *a;
const char *var = "DESTINATION";
a = atr_get(i, "DESTINATION");
if (!a)
a = atr_get(i, "EXITTO");
if (a)
var = "EXITTO";
if (!a)
complain(player, i, "exit-unlinked",
T("Variable exit has no %s attribute"), var);
else {
const char *x = atr_value(a);
if (!x || !*x)
complain(player, i, "exit-unlinked",
T("Variable exit has empty %s attribute"), var);
}
}
if (!Dark(i)) {
if (flags & W_EXIT_MSGS) {
lt = warning_lock_type(getlock(i, Basic_Lock));
if ((lt & W_UNLOCKED) &&
(!atr_get(i, "OSUCCESS") || !atr_get(i, "ODROP") ||
!atr_get(i, "SUCCESS")))
complain(player, i, "exit-msgs",
T("possibly unlocked exit missing succ/osucc/odrop"));
if ((lt & W_LOCKED) && !atr_get(i, "FAILURE"))
complain(player, i, "exit-msgs",
T("possibly locked exit missing fail"));
}
if (flags & W_EXIT_DESC) {
if (!atr_get(i, "DESCRIBE"))
complain(player, i, "exit-desc", T("exit is missing description"));
}
}
src = Source(i);
if (!GoodObject(src) || !IsRoom(src))
return;
if (src == dst)
return;
/* Don't complain about exits linked to HOME or variable exits. */
if (!GoodObject(dst))
return;
for (j = Exits(dst); GoodObject(j); j = Next(j)) {
if (Location(j) == src)
count++;
}
for (j = Exits(MASTER_ROOM); GoodObject(j); j = Next(j)) {
if (Location(j) == src) {
global_return = 1;
count++;
}
}
if (count <= 1 && flags & W_EXIT_ONEWAY) {
if (global_return)
complain(player, i, "exit-oneway",
T("exit only has a global return exit"));
else if (count == 0)
complain(player, i, "exit-oneway", T("exit has no return exit"));
} else if ((count > 1) && (flags & W_EXIT_MULTIPLE)) {
if (global_return)
complain(player, i, "exit-multiple",
T("exit has multiple (%d) return exits including global exits"),
count);
else
complain(player, i, "exit-multiple",
T("exit has multiple (%d) return exits"), count);
}
}
static void
process(FILE *f)
{
int i, n;
char mac[512]; /* The current macro or nroff command */
int pl;
stktop = -1;
for (lineno = 1; getline(&line, &linesize, f) > 0; lineno++) {
if (line[0] == '.') {
/*
* find and isolate the macro/command name.
*/
strncpy(mac, line+1, sizeof mac-1)[sizeof mac-1] = 0;
if (isspace(mac[0]&0377)) {
pe(lineno);
printf("Empty command\n");
} else {
for (i = 1; mac[i]; i++)
if (isspace(mac[i]&0377)) {
mac[i] = 0;
break;
}
}
/*
* Is it a known command?
*/
checkknown(mac);
/*
* Should we add it?
*/
if (eq(mac, "de"))
addcmd(line);
chkcmd(line, mac);
}
/*
* At this point we process the line looking
* for \s and \f.
*/
for (i = 0; line[i]; i++)
if (line[i] == '\\' && (i == 0 || line[i-1] != '\\')) {
if (!sflag && line[++i] == 's') {
pl = line[++i]&0377;
if (isdigit(pl)) {
n = pl - '0';
pl = ' ';
} else
n = 0;
while (isdigit(line[++i]&0377))
n = 10 * n + line[i] - '0';
i--;
if (n == 0) {
if (stk[stktop].opno == SZ) {
stktop--;
} else {
pe(lineno);
printf(
"unmatched \\s0\n");
}
} else {
growstk();
stk[stktop].opno = SZ;
stk[stktop].pl = pl;
stk[stktop].parm = n;
stk[stktop].lno = lineno;
}
} else if (!fflag && line[i] == 'f') {
n = line[++i];
if (n == 'P') {
if (stk[stktop].opno == FT) {
stktop--;
} else {
pe(lineno);
printf(
"unmatched \\fP\n");
}
} else {
growstk();
stk[stktop].opno = FT;
stk[stktop].pl = 1;
stk[stktop].parm = n;
stk[stktop].lno = lineno;
}
}
}
}
/*
* We've hit the end and look at all this stuff that hasn't been
* matched yet! Complain, complain.
*/
for (i = stktop; i >= 0; i--) {
complain(i);
}
}
