Usenet 1994 January

home *** CD-ROM | disk | FTP | other *** search

/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / misc / volume18 / perl / part17 < prev next >

Wrap

Internet Message Format | 1991-04-16 | 52KB

From: lwall@netlabs.com (Larry Wall) Newsgroups: comp.sources.misc Subject: v18i035: perl - The perl programming language, Part17/36 Message-ID: <1991Apr16.185449.931@sparky.IMD.Sterling.COM> Date: 16 Apr 91 18:54:49 GMT Approved: kent@sparky.imd.sterling.com X-Checksum-Snefru: d636a17b 9d9bfb8c 10b58cd4 517fca7f Submitted-by: Larry Wall <lwall@netlabs.com> Posting-number: Volume 18, Issue 35 Archive-name: perl/part17 [There are 36 kits for perl version 4.0.] #! /bin/sh # Make a new directory for the perl sources, cd to it, and run kits 1 # thru 36 through sh. When all 36 kits have been run, read README. echo "This is perl 4.0 kit 17 (of 36). If kit 17 is complete, the line" echo '"'"End of kit 17 (of 36)"'" will echo at the end.' echo "" export PATH || (echo "You didn't use sh, you clunch." ; kill $$) mkdir lib 2>/dev/null echo Extracting util.c sed >util.c <<'!STUFFY!FUNK!' -e 's/X//' X/* $RCSfile: util.c,v $$Revision: 4.0.1.1 $$Date: 91/04/12 09:19:25 $ X * X * Copyright (c) 1989, Larry Wall X * X * You may distribute under the terms of the GNU General Public License X * as specified in the README file that comes with the perl 3.0 kit. X * X * $Log: util.c,v $ X * Revision 4.0.1.1 91/04/12 09:19:25 lwall X * patch1: random cleanup in cpp namespace X * X * Revision 4.0 91/03/20 01:56:39 lwall X * 4.0 baseline. X * X */ X X#include "EXTERN.h" X#include "perl.h" X X#if !defined(NSIG) || defined(M_UNIX) || defined(M_XENIX) X#include <signal.h> X#endif X X#ifdef I_VFORK X# include <vfork.h> X#endif X X#ifdef I_VARARGS X# include <varargs.h> X#endif X X#ifdef I_FCNTL X# include <fcntl.h> X#endif X#ifdef I_SYS_FILE X# include <sys/file.h> X#endif X X#define FLUSH X Xstatic char nomem[] = "Out of memory!\n"; X X/* paranoid version of malloc */ X X#ifdef DEBUGGING Xstatic int an = 0; X#endif X X/* NOTE: Do not call the next three routines directly. Use the macros X * in handy.h, so that we can easily redefine everything to do tracking of X * allocated hunks back to the original New to track down any memory leaks. X */ X Xchar * Xsafemalloc(size) X#ifdef MSDOS Xunsigned long size; X#else XMEM_SIZE size; X#endif /* MSDOS */ X{ X char *ptr; X#ifndef __STDC__ X char *malloc(); X#endif /* ! __STDC__ */ X X#ifdef MSDOS X if (size > 0xffff) { X fprintf(stderr, "Allocation too large: %lx\n", size) FLUSH; X exit(1); X } X#endif /* MSDOS */ X#ifdef DEBUGGING X if ((long)size < 0) X fatal("panic: malloc"); X#endif X ptr = malloc(size?size:1); /* malloc(0) is NASTY on our system */ X#ifdef DEBUGGING X# ifndef I286 X if (debug & 128) X fprintf(stderr,"0x%x: (%05d) malloc %d bytes\n",ptr,an++,size); X# else X if (debug & 128) X fprintf(stderr,"0x%lx: (%05d) malloc %d bytes\n",ptr,an++,size); X# endif X#endif X if (ptr != Nullch) X return ptr; X else { X fputs(nomem,stderr) FLUSH; X exit(1); X } X /*NOTREACHED*/ X#ifdef lint X return ptr; X#endif X} X X/* paranoid version of realloc */ X Xchar * Xsaferealloc(where,size) Xchar *where; X#ifndef MSDOS XMEM_SIZE size; X#else Xunsigned long size; X#endif /* MSDOS */ X{ X char *ptr; X#ifndef __STDC__ X char *realloc(); X#endif /* ! __STDC__ */ X X#ifdef MSDOS X if (size > 0xffff) { X fprintf(stderr, "Reallocation too large: %lx\n", size) FLUSH; X exit(1); X } X#endif /* MSDOS */ X if (!where) X fatal("Null realloc"); X#ifdef DEBUGGING X if ((long)size < 0) X fatal("panic: realloc"); X#endif X ptr = realloc(where,size?size:1); /* realloc(0) is NASTY on our system */ X#ifdef DEBUGGING X# ifndef I286 X if (debug & 128) { X fprintf(stderr,"0x%x: (%05d) rfree\n",where,an++); X fprintf(stderr,"0x%x: (%05d) realloc %d bytes\n",ptr,an++,size); X } X# else X if (debug & 128) { X fprintf(stderr,"0x%lx: (%05d) rfree\n",where,an++); X fprintf(stderr,"0x%lx: (%05d) realloc %d bytes\n",ptr,an++,size); X } X# endif X#endif X if (ptr != Nullch) X return ptr; X else { X fputs(nomem,stderr) FLUSH; X exit(1); X } X /*NOTREACHED*/ X#ifdef lint X return ptr; X#endif X} X X/* safe version of free */ X Xvoid Xsafefree(where) Xchar *where; X{ X#ifdef DEBUGGING X# ifndef I286 X if (debug & 128) X fprintf(stderr,"0x%x: (%05d) free\n",where,an++); X# else X if (debug & 128) X fprintf(stderr,"0x%lx: (%05d) free\n",where,an++); X# endif X#endif X if (where) { X free(where); X } X} X X#ifdef LEAKTEST X X#define ALIGN sizeof(long) X Xchar * Xsafexmalloc(x,size) Xint x; XMEM_SIZE size; X{ X register char *where; X X where = safemalloc(size + ALIGN); X xcount[x]++; X where[0] = x % 100; X where[1] = x / 100; X return where + ALIGN; X} X Xchar * Xsafexrealloc(where,size) Xchar *where; XMEM_SIZE size; X{ X return saferealloc(where - ALIGN, size + ALIGN) + ALIGN; X} X Xvoid Xsafexfree(where) Xchar *where; X{ X int x; X X if (!where) X return; X where -= ALIGN; X x = where[0] + 100 * where[1]; X xcount[x]--; X safefree(where); X} X Xxstat() X{ X register int i; X X for (i = 0; i < MAXXCOUNT; i++) { X if (xcount[i] != lastxcount[i]) { X fprintf(stderr,"%2d %2d\t%ld\n", i / 100, i % 100, xcount[i]); X lastxcount[i] = xcount[i]; X } X } X} X X#endif /* LEAKTEST */ X X/* copy a string up to some (non-backslashed) delimiter, if any */ X Xchar * Xcpytill(to,from,fromend,delim,retlen) Xregister char *to; Xregister char *from; Xregister char *fromend; Xregister int delim; Xint *retlen; X{ X char *origto = to; X X for (; from < fromend; from++,to++) { X if (*from == '\\') { X if (from[1] == delim) X from++; X else if (from[1] == '\\') X *to++ = *from++; X } X else if (*from == delim) X break; X *to = *from; X } X *to = '\0'; X *retlen = to - origto; X return from; X} X X/* return ptr to little string in big string, NULL if not found */ X/* This routine was donated by Corey Satten. */ X Xchar * Xinstr(big, little) Xregister char *big; Xregister char *little; X{ X register char *s, *x; X register int first; X X if (!little) X return big; X first = *little++; X if (!first) X return big; X while (*big) { X if (*big++ != first) X continue; X for (x=big,s=little; *s; /**/ ) { X if (!*x) X return Nullch; X if (*s++ != *x++) { X s--; X break; X } X } X if (!*s) X return big-1; X } X return Nullch; X} X X/* same as instr but allow embedded nulls */ X Xchar * Xninstr(big, bigend, little, lend) Xregister char *big; Xregister char *bigend; Xchar *little; Xchar *lend; X{ X register char *s, *x; X register int first = *little; X register char *littleend = lend; X X if (!first && little > littleend) X return big; X bigend -= littleend - little++; X while (big <= bigend) { X if (*big++ != first) X continue; X for (x=big,s=little; s < littleend; /**/ ) { X if (*s++ != *x++) { X s--; X break; X } X } X if (s >= littleend) X return big-1; X } X return Nullch; X} X X/* reverse of the above--find last substring */ X Xchar * Xrninstr(big, bigend, little, lend) Xregister char *big; Xchar *bigend; Xchar *little; Xchar *lend; X{ X register char *bigbeg; X register char *s, *x; X register int first = *little; X register char *littleend = lend; X X if (!first && little > littleend) X return bigend; X bigbeg = big; X big = bigend - (littleend - little++); X while (big >= bigbeg) { X if (*big-- != first) X continue; X for (x=big+2,s=little; s < littleend; /**/ ) { X if (*s++ != *x++) { X s--; X break; X } X } X if (s >= littleend) X return big+1; X } X return Nullch; X} X Xunsigned char fold[] = { X 0, 1, 2, 3, 4, 5, 6, 7, X 8, 9, 10, 11, 12, 13, 14, 15, X 16, 17, 18, 19, 20, 21, 22, 23, X 24, 25, 26, 27, 28, 29, 30, 31, X 32, 33, 34, 35, 36, 37, 38, 39, X 40, 41, 42, 43, 44, 45, 46, 47, X 48, 49, 50, 51, 52, 53, 54, 55, X 56, 57, 58, 59, 60, 61, 62, 63, X 64, 'a', 'b', 'c', 'd', 'e', 'f', 'g', X 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', X 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', X 'x', 'y', 'z', 91, 92, 93, 94, 95, X 96, 'A', 'B', 'C', 'D', 'E', 'F', 'G', X 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', X 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', X 'X', 'Y', 'Z', 123, 124, 125, 126, 127, X 128, 129, 130, 131, 132, 133, 134, 135, X 136, 137, 138, 139, 140, 141, 142, 143, X 144, 145, 146, 147, 148, 149, 150, 151, X 152, 153, 154, 155, 156, 157, 158, 159, X 160, 161, 162, 163, 164, 165, 166, 167, X 168, 169, 170, 171, 172, 173, 174, 175, X 176, 177, 178, 179, 180, 181, 182, 183, X 184, 185, 186, 187, 188, 189, 190, 191, X 192, 193, 194, 195, 196, 197, 198, 199, X 200, 201, 202, 203, 204, 205, 206, 207, X 208, 209, 210, 211, 212, 213, 214, 215, X 216, 217, 218, 219, 220, 221, 222, 223, X 224, 225, 226, 227, 228, 229, 230, 231, X 232, 233, 234, 235, 236, 237, 238, 239, X 240, 241, 242, 243, 244, 245, 246, 247, X 248, 249, 250, 251, 252, 253, 254, 255 X}; X Xstatic unsigned char freq[] = { X 1, 2, 84, 151, 154, 155, 156, 157, X 165, 246, 250, 3, 158, 7, 18, 29, X 40, 51, 62, 73, 85, 96, 107, 118, X 129, 140, 147, 148, 149, 150, 152, 153, X 255, 182, 224, 205, 174, 176, 180, 217, X 233, 232, 236, 187, 235, 228, 234, 226, X 222, 219, 211, 195, 188, 193, 185, 184, X 191, 183, 201, 229, 181, 220, 194, 162, X 163, 208, 186, 202, 200, 218, 198, 179, X 178, 214, 166, 170, 207, 199, 209, 206, X 204, 160, 212, 216, 215, 192, 175, 173, X 243, 172, 161, 190, 203, 189, 164, 230, X 167, 248, 227, 244, 242, 255, 241, 231, X 240, 253, 169, 210, 245, 237, 249, 247, X 239, 168, 252, 251, 254, 238, 223, 221, X 213, 225, 177, 197, 171, 196, 159, 4, X 5, 6, 8, 9, 10, 11, 12, 13, X 14, 15, 16, 17, 19, 20, 21, 22, X 23, 24, 25, 26, 27, 28, 30, 31, X 32, 33, 34, 35, 36, 37, 38, 39, X 41, 42, 43, 44, 45, 46, 47, 48, X 49, 50, 52, 53, 54, 55, 56, 57, X 58, 59, 60, 61, 63, 64, 65, 66, X 67, 68, 69, 70, 71, 72, 74, 75, X 76, 77, 78, 79, 80, 81, 82, 83, X 86, 87, 88, 89, 90, 91, 92, 93, X 94, 95, 97, 98, 99, 100, 101, 102, X 103, 104, 105, 106, 108, 109, 110, 111, X 112, 113, 114, 115, 116, 117, 119, 120, X 121, 122, 123, 124, 125, 126, 127, 128, X 130, 131, 132, 133, 134, 135, 136, 137, X 138, 139, 141, 142, 143, 144, 145, 146 X}; X Xvoid Xfbmcompile(str, iflag) XSTR *str; Xint iflag; X{ X register unsigned char *s; X register unsigned char *table; X register int i; X register int len = str->str_cur; X int rarest = 0; X unsigned int frequency = 256; X X Str_Grow(str,len+258); X#ifndef lint X table = (unsigned char*)(str->str_ptr + len + 1); X#else X table = Null(unsigned char*); X#endif X s = table - 2; X for (i = 0; i < 256; i++) { X table[i] = len; X } X i = 0; X#ifndef lint X while (s >= (unsigned char*)(str->str_ptr)) X#endif X { X if (table[*s] == len) { X#ifndef pdp11 X if (iflag) X table[*s] = table[fold[*s]] = i; X#else X if (iflag) { X int j; X j = fold[*s]; X table[j] = i; X table[*s] = i; X } X#endif /* pdp11 */ X else X table[*s] = i; X } X s--,i++; X } X str->str_pok |= SP_FBM; /* deep magic */ X X#ifndef lint X s = (unsigned char*)(str->str_ptr); /* deeper magic */ X#else X s = Null(unsigned char*); X#endif X if (iflag) { X register unsigned int tmp, foldtmp; X str->str_pok |= SP_CASEFOLD; X for (i = 0; i < len; i++) { X tmp=freq[s[i]]; X foldtmp=freq[fold[s[i]]]; X if (tmp < frequency && foldtmp < frequency) { X rarest = i; X /* choose most frequent among the two */ X frequency = (tmp > foldtmp) ? tmp : foldtmp; X } X } X } X else { X for (i = 0; i < len; i++) { X if (freq[s[i]] < frequency) { X rarest = i; X frequency = freq[s[i]]; X } X } X } X str->str_rare = s[rarest]; X str->str_state = rarest; X#ifdef DEBUGGING X if (debug & 512) X fprintf(stderr,"rarest char %c at %d\n",str->str_rare, str->str_state); X#endif X} X Xchar * Xfbminstr(big, bigend, littlestr) Xunsigned char *big; Xregister unsigned char *bigend; XSTR *littlestr; X{ X register unsigned char *s; X register int tmp; X register int littlelen; X register unsigned char *little; X register unsigned char *table; X register unsigned char *olds; X register unsigned char *oldlittle; X X#ifndef lint X if (!(littlestr->str_pok & SP_FBM)) X return ninstr((char*)big,(char*)bigend, X littlestr->str_ptr, littlestr->str_ptr + littlestr->str_cur); X#endif X X littlelen = littlestr->str_cur; X#ifndef lint X if (littlestr->str_pok & SP_TAIL && !multiline) { /* tail anchored? */ X if (littlelen > bigend - big) X return Nullch; X little = (unsigned char*)littlestr->str_ptr; X if (littlestr->str_pok & SP_CASEFOLD) { /* oops, fake it */ X big = bigend - littlelen; /* just start near end */ X if (bigend[-1] == '\n' && little[littlelen-1] != '\n') X big--; X } X else { X s = bigend - littlelen; X if (*s == *little && bcmp(s,little,littlelen)==0) X return (char*)s; /* how sweet it is */ X else if (bigend[-1] == '\n' && little[littlelen-1] != '\n' X && s > big) { X s--; X if (*s == *little && bcmp(s,little,littlelen)==0) X return (char*)s; X } X return Nullch; X } X } X table = (unsigned char*)(littlestr->str_ptr + littlelen + 1); X#else X table = Null(unsigned char*); X#endif X if (--littlelen >= bigend - big) X return Nullch; X s = big + littlelen; X oldlittle = little = table - 2; X if (littlestr->str_pok & SP_CASEFOLD) { /* case insensitive? */ X if (s < bigend) { X top1: X if (tmp = table[*s]) { X#ifdef POINTERRIGOR X if (bigend - s > tmp) { X s += tmp; X goto top1; X } X#else X if ((s += tmp) < bigend) X goto top1; X#endif X return Nullch; X } X else { X tmp = littlelen; /* less expensive than calling strncmp() */ X olds = s; X while (tmp--) { X if (*--s == *--little || fold[*s] == *little) X continue; X s = olds + 1; /* here we pay the price for failure */ X little = oldlittle; X if (s < bigend) /* fake up continue to outer loop */ X goto top1; X return Nullch; X } X#ifndef lint X return (char *)s; X#endif X } X } X } X else { X if (s < bigend) { X top2: X if (tmp = table[*s]) { X#ifdef POINTERRIGOR X if (bigend - s > tmp) { X s += tmp; X goto top2; X } X#else X if ((s += tmp) < bigend) X goto top2; X#endif X return Nullch; X } X else { X tmp = littlelen; /* less expensive than calling strncmp() */ X olds = s; X while (tmp--) { X if (*--s == *--little) X continue; X s = olds + 1; /* here we pay the price for failure */ X little = oldlittle; X if (s < bigend) /* fake up continue to outer loop */ X goto top2; X return Nullch; X } X#ifndef lint X return (char *)s; X#endif X } X } X } X return Nullch; X} X Xchar * Xscreaminstr(bigstr, littlestr) XSTR *bigstr; XSTR *littlestr; X{ X register unsigned char *s, *x; X register unsigned char *big; X register int pos; X register int previous; X register int first; X register unsigned char *little; X register unsigned char *bigend; X register unsigned char *littleend; X X if ((pos = screamfirst[littlestr->str_rare]) < 0) X return Nullch; X#ifndef lint X little = (unsigned char *)(littlestr->str_ptr); X#else X little = Null(unsigned char *); X#endif X littleend = little + littlestr->str_cur; X first = *little++; X previous = littlestr->str_state; X#ifndef lint X big = (unsigned char *)(bigstr->str_ptr); X#else X big = Null(unsigned char*); X#endif X bigend = big + bigstr->str_cur; X big -= previous; X while (pos < previous) { X#ifndef lint X if (!(pos += screamnext[pos])) X#endif X return Nullch; X } X if (littlestr->str_pok & SP_CASEFOLD) { /* case insignificant? */ X do { X if (big[pos] != first && big[pos] != fold[first]) X continue; X for (x=big+pos+1,s=little; s < littleend; /**/ ) { X if (x >= bigend) X return Nullch; X if (*s++ != *x++ && fold[*(s-1)] != *(x-1)) { X s--; X break; X } X } X if (s == littleend) X#ifndef lint X return (char *)(big+pos); X#else X return Nullch; X#endif X } while ( X#ifndef lint X pos += screamnext[pos] /* does this goof up anywhere? */ X#else X pos += screamnext[0] X#endif X ); X } X else { X do { X if (big[pos] != first) X continue; X for (x=big+pos+1,s=little; s < littleend; /**/ ) { X if (x >= bigend) X return Nullch; X if (*s++ != *x++) { X s--; X break; X } X } X if (s == littleend) X#ifndef lint X return (char *)(big+pos); X#else X return Nullch; X#endif X } while ( X#ifndef lint X pos += screamnext[pos] X#else X pos += screamnext[0] X#endif X ); X } X return Nullch; X} X X/* copy a string to a safe spot */ X Xchar * Xsavestr(str) Xchar *str; X{ X register char *newaddr; X X New(902,newaddr,strlen(str)+1,char); X (void)strcpy(newaddr,str); X return newaddr; X} X X/* same thing but with a known length */ X Xchar * Xnsavestr(str, len) Xchar *str; Xregister int len; X{ X register char *newaddr; X X New(903,newaddr,len+1,char); X (void)bcopy(str,newaddr,len); /* might not be null terminated */ X newaddr[len] = '\0'; /* is now */ X return newaddr; X} X X/* grow a static string to at least a certain length */ X Xvoid Xgrowstr(strptr,curlen,newlen) Xchar **strptr; Xint *curlen; Xint newlen; X{ X if (newlen > *curlen) { /* need more room? */ X if (*curlen) X Renew(*strptr,newlen,char); X else X New(905,*strptr,newlen,char); X *curlen = newlen; X } X} X X#ifndef I_VARARGS X/*VARARGS1*/ Xmess(pat,a1,a2,a3,a4) Xchar *pat; Xlong a1, a2, a3, a4; X{ X char *s; X X s = buf; X (void)sprintf(s,pat,a1,a2,a3,a4); X s += strlen(s); X if (s[-1] != '\n') { X if (curcmd->c_line) { X (void)sprintf(s," at %s line %ld", X stab_val(curcmd->c_filestab)->str_ptr, (long)curcmd->c_line); X s += strlen(s); X } X if (last_in_stab && X stab_io(last_in_stab) && X stab_io(last_in_stab)->lines ) { X (void)sprintf(s,", <%s> line %ld", X last_in_stab == argvstab ? "" : stab_name(last_in_stab), X (long)stab_io(last_in_stab)->lines); X s += strlen(s); X } X (void)strcpy(s,".\n"); X } X} X X/*VARARGS1*/ Xfatal(pat,a1,a2,a3,a4) Xchar *pat; Xlong a1, a2, a3, a4; X{ X extern FILE *e_fp; X extern char *e_tmpname; X char *tmps; X X mess(pat,a1,a2,a3,a4); X if (in_eval) { X str_set(stab_val(stabent("@",TRUE)),buf); X tmps = "_EVAL_"; X while (loop_ptr >= 0 && (!loop_stack[loop_ptr].loop_label || X strNE(tmps,loop_stack[loop_ptr].loop_label) )) { X#ifdef DEBUGGING X if (debug & 4) { X deb("(Skipping label #%d %s)\n",loop_ptr, X loop_stack[loop_ptr].loop_label); X } X#endif X loop_ptr--; X } X#ifdef DEBUGGING X if (debug & 4) { X deb("(Found label #%d %s)\n",loop_ptr, X loop_stack[loop_ptr].loop_label); X } X#endif X if (loop_ptr < 0) { X in_eval = 0; X fatal("Bad label: %s", tmps); X } X longjmp(loop_stack[loop_ptr].loop_env, 1); X } X fputs(buf,stderr); X (void)fflush(stderr); X if (e_fp) X (void)UNLINK(e_tmpname); X statusvalue >>= 8; X exit((int)((errno&255)?errno:((statusvalue&255)?statusvalue:255))); X} X X/*VARARGS1*/ Xwarn(pat,a1,a2,a3,a4) Xchar *pat; Xlong a1, a2, a3, a4; X{ X mess(pat,a1,a2,a3,a4); X fputs(buf,stderr); X#ifdef LEAKTEST X#ifdef DEBUGGING X if (debug & 4096) X xstat(); X#endif X#endif X (void)fflush(stderr); X} X#else X/*VARARGS0*/ Xmess(args) Xva_list args; X{ X char *pat; X char *s; X#ifdef CHARVSPRINTF X char *vsprintf(); X#else X int vsprintf(); X#endif X X s = buf; X#ifdef lint X pat = Nullch; X#else X pat = va_arg(args, char *); X#endif X (void) vsprintf(s,pat,args); X X s += strlen(s); X if (s[-1] != '\n') { X if (curcmd->c_line) { X (void)sprintf(s," at %s line %ld", X stab_val(curcmd->c_filestab)->str_ptr, (long)curcmd->c_line); X s += strlen(s); X } X if (last_in_stab && X stab_io(last_in_stab) && X stab_io(last_in_stab)->lines ) { X (void)sprintf(s,", <%s> line %ld", X last_in_stab == argvstab ? "" : last_in_stab->str_magic->str_ptr, X (long)stab_io(last_in_stab)->lines); X s += strlen(s); X } X (void)strcpy(s,".\n"); X } X} X X/*VARARGS0*/ Xfatal(va_alist) Xva_dcl X{ X va_list args; X extern FILE *e_fp; X extern char *e_tmpname; X char *tmps; X X#ifndef lint X va_start(args); X#else X args = 0; X#endif X mess(args); X va_end(args); X if (in_eval) { X str_set(stab_val(stabent("@",TRUE)),buf); X tmps = "_EVAL_"; X while (loop_ptr >= 0 && (!loop_stack[loop_ptr].loop_label || X strNE(tmps,loop_stack[loop_ptr].loop_label) )) { X#ifdef DEBUGGING X if (debug & 4) { X deb("(Skipping label #%d %s)\n",loop_ptr, X loop_stack[loop_ptr].loop_label); X } X#endif X loop_ptr--; X } X#ifdef DEBUGGING X if (debug & 4) { X deb("(Found label #%d %s)\n",loop_ptr, X loop_stack[loop_ptr].loop_label); X } X#endif X if (loop_ptr < 0) { X in_eval = 0; X fatal("Bad label: %s", tmps); X } X longjmp(loop_stack[loop_ptr].loop_env, 1); X } X fputs(buf,stderr); X (void)fflush(stderr); X if (e_fp) X (void)UNLINK(e_tmpname); X statusvalue >>= 8; X exit((int)((errno&255)?errno:((statusvalue&255)?statusvalue:255))); X} X X/*VARARGS0*/ Xwarn(va_alist) Xva_dcl X{ X va_list args; X X#ifndef lint X va_start(args); X#else X args = 0; X#endif X mess(args); X va_end(args); X X fputs(buf,stderr); X#ifdef LEAKTEST X#ifdef DEBUGGING X if (debug & 4096) X xstat(); X#endif X#endif X (void)fflush(stderr); X} X#endif X Xvoid Xsetenv(nam,val) Xchar *nam, *val; X{ X register int i=envix(nam); /* where does it go? */ X X if (environ == origenviron) { /* need we copy environment? */ X int j; X int max; X char **tmpenv; X X for (max = i; environ[max]; max++) ; X New(901,tmpenv, max+2, char*); X for (j=0; j<max; j++) /* copy environment */ X tmpenv[j] = savestr(environ[j]); X tmpenv[max] = Nullch; X environ = tmpenv; /* tell exec where it is now */ X } X if (!val) { X while (environ[i]) { X environ[i] = environ[i+1]; X i++; X } X return; X } X if (!environ[i]) { /* does not exist yet */ X Renew(environ, i+2, char*); /* just expand it a bit */ X environ[i+1] = Nullch; /* make sure it's null terminated */ X } X else X Safefree(environ[i]); X New(904, environ[i], strlen(nam) + strlen(val) + 2, char); X#ifndef MSDOS X (void)sprintf(environ[i],"%s=%s",nam,val);/* all that work just for this */ X#else X /* MS-DOS requires environment variable names to be in uppercase */ X /* [Tom Dinger, 27 August 1990: Well, it doesn't _require_ it, but X * some utilities and applications may break because they only look X * for upper case strings. (Fixed strupr() bug here.)] X */ X strcpy(environ[i],nam); strupr(environ[i]); X (void)sprintf(environ[i] + strlen(nam),"=%s",val); X#endif /* MSDOS */ X} X Xint Xenvix(nam) Xchar *nam; X{ X register int i, len = strlen(nam); X X for (i = 0; environ[i]; i++) { X if (strnEQ(environ[i],nam,len) && environ[i][len] == '=') X break; /* strnEQ must come first to avoid */ X } /* potential SEGV's */ X return i; X} X X#ifdef EUNICE Xunlnk(f) /* unlink all versions of a file */ Xchar *f; X{ X int i; X X for (i = 0; unlink(f) >= 0; i++) ; X return i ? 0 : -1; X} X#endif X X#ifndef HAS_MEMCPY X#ifndef HAS_BCOPY Xchar * Xbcopy(from,to,len) Xregister char *from; Xregister char *to; Xregister int len; X{ X char *retval = to; X X while (len--) X *to++ = *from++; X return retval; X} X#endif X X#ifndef HAS_BZERO Xchar * Xbzero(loc,len) Xregister char *loc; Xregister int len; X{ X char *retval = loc; X X while (len--) X *loc++ = 0; X return retval; X} X#endif X#endif X X#ifdef I_VARARGS X#ifndef HAS_VPRINTF X X#ifdef CHARVSPRINTF Xchar * X#else Xint X#endif Xvsprintf(dest, pat, args) Xchar *dest, *pat, *args; X{ X FILE fakebuf; X X fakebuf._ptr = dest; X fakebuf._cnt = 32767; X#ifndef _IOSTRG X#define _IOSTRG 0 X#endif X fakebuf._flag = _IOWRT|_IOSTRG; X _doprnt(pat, args, &fakebuf); /* what a kludge */ X (void)putc('\0', &fakebuf); X#ifdef CHARVSPRINTF X return(dest); X#else X return 0; /* perl doesn't use return value */ X#endif X} X X#ifdef DEBUGGING Xint Xvfprintf(fd, pat, args) XFILE *fd; Xchar *pat, *args; X{ X _doprnt(pat, args, fd); X return 0; /* wrong, but perl doesn't use the return value */ X} X#endif X#endif /* HAS_VPRINTF */ X#endif /* I_VARARGS */ X X#ifdef MYSWAP X#if BYTEORDER != 0x4321 Xshort Xmy_swap(s) Xshort s; X{ X#if (BYTEORDER & 1) == 0 X short result; X X result = ((s & 255) << 8) + ((s >> 8) & 255); X return result; X#else X return s; X#endif X} X Xlong Xhtonl(l) Xregister long l; X{ X union { X long result; X char c[sizeof(long)]; X } u; X X#if BYTEORDER == 0x1234 X u.c[0] = (l >> 24) & 255; X u.c[1] = (l >> 16) & 255; X u.c[2] = (l >> 8) & 255; X u.c[3] = l & 255; X return u.result; X#else X#if ((BYTEORDER - 0x1111) & 0x444) || !(BYTEORDER & 0xf) X fatal("Unknown BYTEORDER\n"); X#else X register int o; X register int s; X X for (o = BYTEORDER - 0x1111, s = 0; s < (sizeof(long)*8); o >>= 4, s += 8) { X u.c[o & 0xf] = (l >> s) & 255; X } X return u.result; X#endif X#endif X} X Xlong Xntohl(l) Xregister long l; X{ X union { X long l; X char c[sizeof(long)]; X } u; X X#if BYTEORDER == 0x1234 X u.c[0] = (l >> 24) & 255; X u.c[1] = (l >> 16) & 255; X u.c[2] = (l >> 8) & 255; X u.c[3] = l & 255; X return u.l; X#else X#if ((BYTEORDER - 0x1111) & 0x444) || !(BYTEORDER & 0xf) X fatal("Unknown BYTEORDER\n"); X#else X register int o; X register int s; X X u.l = l; X l = 0; X for (o = BYTEORDER - 0x1111, s = 0; s < (sizeof(long)*8); o >>= 4, s += 8) { X l |= (u.c[o & 0xf] & 255) << s; X } X return l; X#endif X#endif X} X X#endif /* BYTEORDER != 0x4321 */ X#endif /* HAS_HTONS */ X X#ifndef MSDOS XFILE * Xmypopen(cmd,mode) Xchar *cmd; Xchar *mode; X{ X int p[2]; X register int this, that; X register int pid; X STR *str; X int doexec = strNE(cmd,"-"); X X if (pipe(p) < 0) X return Nullfp; X this = (*mode == 'w'); X that = !this; X while ((pid = (doexec?vfork():fork())) < 0) { X if (errno != EAGAIN) { X close(p[this]); X if (!doexec) X fatal("Can't fork"); X return Nullfp; X } X sleep(5); X } X if (pid == 0) { X#define THIS that X#define THAT this X close(p[THAT]); X if (p[THIS] != (*mode == 'r')) { X dup2(p[THIS], *mode == 'r'); X close(p[THIS]); X } X if (doexec) { X#if !defined(I_FCNTL) || !defined(F_SETFD) X int fd; X X#ifndef NOFILE X#define NOFILE 20 X#endif X for (fd = 3; fd < NOFILE; fd++) X close(fd); X#endif X do_exec(cmd); /* may or may not use the shell */ X _exit(1); X } X if (tmpstab = stabent("$",allstabs)) X str_numset(STAB_STR(tmpstab),(double)getpid()); X forkprocess = 0; X hclear(pidstatus, FALSE); /* we have no children */ X return Nullfp; X#undef THIS X#undef THAT X } X do_execfree(); /* free any memory malloced by child on vfork */ X close(p[that]); X if (p[that] < p[this]) { X dup2(p[this], p[that]); X close(p[this]); X p[this] = p[that]; X } X str = afetch(fdpid,p[this],TRUE); X str->str_u.str_useful = pid; X forkprocess = pid; X return fdopen(p[this], mode); X} X#endif /* !MSDOS */ X X#ifdef NOTDEF Xdumpfds(s) Xchar *s; X{ X int fd; X struct stat tmpstatbuf; X X fprintf(stderr,"%s", s); X for (fd = 0; fd < 32; fd++) { X if (fstat(fd,&tmpstatbuf) >= 0) X fprintf(stderr," %d",fd); X } X fprintf(stderr,"\n"); X} X#endif X X#ifndef HAS_DUP2 Xdup2(oldfd,newfd) Xint oldfd; Xint newfd; X{ X#if defined(HAS_FCNTL) && defined(F_DUPFD) X close(newfd); X fcntl(oldfd, F_DUPFD, newfd); X#else X int fdtmp[20]; X int fdx = 0; X int fd; X X if (oldfd == newfd) X return 0; X close(newfd); X while ((fd = dup(oldfd)) != newfd) /* good enough for low fd's */ X fdtmp[fdx++] = fd; X while (fdx > 0) X close(fdtmp[--fdx]); X#endif X} X#endif X X#ifndef MSDOS Xint Xmypclose(ptr) XFILE *ptr; X{ X#ifdef VOIDSIG X void (*hstat)(), (*istat)(), (*qstat)(); X#else X int (*hstat)(), (*istat)(), (*qstat)(); X#endif X int status; X STR *str; X int pid; X X str = afetch(fdpid,fileno(ptr),TRUE); X astore(fdpid,fileno(ptr),Nullstr); X fclose(ptr); X pid = (int)str->str_u.str_useful; X hstat = signal(SIGHUP, SIG_IGN); X istat = signal(SIGINT, SIG_IGN); X qstat = signal(SIGQUIT, SIG_IGN); X pid = wait4pid(pid, &status, 0); X signal(SIGHUP, hstat); X signal(SIGINT, istat); X signal(SIGQUIT, qstat); X return(pid < 0 ? pid : status); X} X Xint Xwait4pid(pid,statusp,flags) Xint pid; Xint *statusp; Xint flags; X{ X int result; X STR *str; X char spid[16]; X X if (!pid) X return -1; X#ifdef HAS_WAIT4 X return wait4((pid==-1)?0:pid,statusp,flags,Null(struct rusage *)); X#else X#ifdef HAS_WAITPID X return waitpid(pid,statusp,flags); X#else X if (pid > 0) { X sprintf(spid, "%d", pid); X str = hfetch(pidstatus,spid,strlen(spid),FALSE); X if (str != &str_undef) { X *statusp = (int)str->str_u.str_useful; X hdelete(pidstatus,spid,strlen(spid)); X return pid; X } X } X else { X HENT *entry; X X hiterinit(pidstatus); X if (entry = hiternext(pidstatus)) { X pid = atoi(hiterkey(entry,statusp)); X str = hiterval(entry); X *statusp = (int)str->str_u.str_useful; X sprintf(spid, "%d", pid); X hdelete(pidstatus,spid,strlen(spid)); X return pid; X } X } X if (flags) X fatal("Can't do waitpid with flags"); X else { X while ((result = wait(statusp)) != pid && pid > 0 && result >= 0) X pidgone(result,*statusp); X if (result < 0) X *statusp = -1; X } X return result; X#endif X#endif X} X Xpidgone(pid,status) Xint pid; Xint status; X{ X#if defined(HAS_WAIT4) || defined(HAS_WAITPID) X#else X register STR *str; X char spid[16]; X X sprintf(spid, "%d", pid); X str = hfetch(pidstatus,spid,strlen(spid),TRUE); X str->str_u.str_useful = status; X#endif X return; X} X#endif /* !MSDOS */ X X#ifndef HAS_MEMCMP Xmemcmp(s1,s2,len) Xregister unsigned char *s1; Xregister unsigned char *s2; Xregister int len; X{ X register int tmp; X X while (len--) { X if (tmp = *s1++ - *s2++) X return tmp; X } X return 0; X} X#endif /* HAS_MEMCMP */ X Xvoid Xrepeatcpy(to,from,len,count) Xregister char *to; Xregister char *from; Xint len; Xregister int count; X{ X register int todo; X register char *frombase = from; X X if (len == 1) { X todo = *from; X while (count-- > 0) X *to++ = todo; X return; X } X while (count-- > 0) { X for (todo = len; todo > 0; todo--) { X *to++ = *from++; X } X from = frombase; X } X} X X#ifndef CASTNEGFLOAT Xunsigned long Xcastulong(f) Xdouble f; X{ X long along; X X#if CASTFLAGS & 2 X# define BIGDOUBLE 2147483648.0 X if (f >= BIGDOUBLE) X return (unsigned long)(f-(long)(f/BIGDOUBLE)*BIGDOUBLE)|0x80000000; X#endif X if (f >= 0.0) X return (unsigned long)f; X along = (long)f; X return (unsigned long)along; X} X#endif X X#ifndef HAS_RENAME Xint Xsame_dirent(a,b) Xchar *a; Xchar *b; X{ X char *fa = rindex(a,'/'); X char *fb = rindex(b,'/'); X struct stat tmpstatbuf1; X struct stat tmpstatbuf2; X#ifndef MAXPATHLEN X#define MAXPATHLEN 1024 X#endif X char tmpbuf[MAXPATHLEN+1]; X X if (fa) X fa++; X else X fa = a; X if (fb) X fb++; X else X fb = b; X if (strNE(a,b)) X return FALSE; X if (fa == a) X strcpy(tmpbuf,"."); X else X strncpy(tmpbuf, a, fa - a); X if (stat(tmpbuf, &tmpstatbuf1) < 0) X return FALSE; X if (fb == b) X strcpy(tmpbuf,"."); X else X strncpy(tmpbuf, b, fb - b); X if (stat(tmpbuf, &tmpstatbuf2) < 0) X return FALSE; X return tmpstatbuf1.st_dev == tmpstatbuf2.st_dev && X tmpstatbuf1.st_ino == tmpstatbuf2.st_ino; X} X#endif /* !HAS_RENAME */ X Xunsigned long Xscanoct(start, len, retlen) Xchar *start; Xint len; Xint *retlen; X{ X register char *s = start; X register unsigned long retval = 0; X X while (len-- && *s >= '0' && *s <= '7') { X retval <<= 3; X retval |= *s++ - '0'; X } X *retlen = s - start; X return retval; X} X Xunsigned long Xscanhex(start, len, retlen) Xchar *start; Xint len; Xint *retlen; X{ X register char *s = start; X register unsigned long retval = 0; X char *tmp; X X while (len-- && *s && (tmp = index(hexdigit, *s))) { X retval <<= 4; X retval |= (tmp - hexdigit) & 15; X s++; X } X *retlen = s - start; X return retval; X} !STUFFY!FUNK! echo Extracting PACKINGLIST@3 sed >PACKINGLIST@3 <<'!STUFFY!FUNK!' -e 's/X//' XAfter all the perl kits are run you should have the following files: X XFilename Kit Description X-------- --- ----------- XConfigure:AA 7 Run this first XConfigure:AB 14 XCopying 15 The GNU General Public License XEXTERN.h 36 Included before foreign .h files XINTERN.h 36 Included before domestic .h files XMANIFEST 27 This list of files XMakefile.SH 28 Precursor to Makefile XPACKINGLIST 17 Which files came from which kits XREADME 1 The Instructions XREADME.uport 1 Special instructions for Microports XREADME.xenix 1 Special instructions for Xenix XWishlist 36 Some things that may or may not happen Xarg.h 20 Public declarations for the above Xarray.c 30 Numerically subscripted arrays Xarray.h 36 Public declarations for the above Xcflags.SH 34 A script that emits C compilation flags per file Xclient 36 A client to test sockets Xcmd.c 19 Command interpreter Xcmd.h 31 Public declarations for the above Xconfig.H 25 Sample config.h Xconfig_h.SH 23 Produces config.h Xcons.c 13 Routines to construct cmd nodes of a parse tree Xconsarg.c 20 Routines to construct arg nodes of a parse tree Xdoarg.c 12 Scalar expression evaluation Xdoio.c:AA 3 I/O operations Xdoio.c:AB 28 Xdolist.c 11 Array expression evaluation Xdump.c 29 Debugging output Xeg/ADB 36 An adb wrapper to put in your crash dir Xeg/README 1 Intro to example perl scripts Xeg/changes 35 A program to list recently changed files Xeg/down 36 A program to do things to subdirectories Xeg/dus 36 A program to do du -s on non-mounted dirs Xeg/findcp 35 A find wrapper that implements a -cp switch Xeg/findtar 22 A find wrapper that pumps out a tar file Xeg/g/gcp 33 A program to do a global rcp Xeg/g/gcp.man 34 Manual page for gcp Xeg/g/ged 36 A program to do a global edit Xeg/g/ghosts 35 A sample /etc/ghosts file Xeg/g/gsh 33 A program to do a global rsh Xeg/g/gsh.man 33 Manual page for gsh Xeg/muck 26 A program to find missing make dependencies Xeg/muck.man 36 Manual page for muck Xeg/myrup 35 A program to find lightly loaded machines Xeg/nih 10 Script to insert #! workaround Xeg/relink 33 A program to change symbolic links Xeg/rename 34 A program to rename files Xeg/rmfrom 36 A program to feed doomed filenames to Xeg/scan/scan_df 34 Scan for filesystem anomalies Xeg/scan/scan_last 34 Scan for login anomalies Xeg/scan/scan_messages 30 Scan for console message anomalies Xeg/scan/scan_passwd 35 Scan for passwd file anomalies Xeg/scan/scan_ps 18 Scan for process anomalies Xeg/scan/scan_sudo 35 Scan for sudo anomalies Xeg/scan/scan_suid 33 Scan for setuid anomalies Xeg/scan/scanner 34 An anomaly reporter Xeg/shmkill 36 A program to remove unused shared memory Xeg/sysvipc/README 1 Intro to Sys V IPC examples Xeg/sysvipc/ipcmsg 35 Example of SYS V IPC message queues Xeg/sysvipc/ipcsem 35 Example of Sys V IPC semaphores Xeg/sysvipc/ipcshm 35 Example of Sys V IPC shared memory Xeg/travesty 35 A program to print travesties of its input text Xeg/van/empty 35 A program to empty the trashcan Xeg/van/unvanish 34 A program to undo what vanish does Xeg/van/vanexp 36 A program to expire vanished files Xeg/van/vanish 34 A program to put files in a trashcan Xeg/who 36 A sample who program Xemacs/perl-mode.el 21 Emacs major mode for perl Xemacs/perldb.el 18 Emacs debugging Xemacs/perldb.pl 16 Emacs debugging Xemacs/tedstuff 27 Some optional patches Xeval.c:AA 6 The expression evaluator Xeval.c:AB 23 Xform.c 28 Format processing Xform.h 35 Public declarations for the above Xgettest 36 A little script to test the get* routines Xh2ph.SH 11 A thing to turn C .h file into perl .ph files Xh2pl/README 1 How to turn .ph files into .pl files Xh2pl/cbreak.pl 36 cbreak routines using .ph Xh2pl/cbreak2.pl 36 cbreak routines using .pl Xh2pl/eg/sizeof.ph 36 Sample sizeof array initialization Xh2pl/eg/sys/errno.pl 34 Sample translated errno.pl Xh2pl/eg/sys/ioctl.pl 31 Sample translated ioctl.pl Xh2pl/eg/sysexits.pl 36 Sample translated sysexits.pl Xh2pl/getioctlsizes 36 Program to extract types from ioctl.h Xh2pl/mksizes 35 Program to make %sizeof array. Xh2pl/mkvars 35 Program to make .pl from .ph files Xh2pl/tcbreak 36 cbreak test routine using .ph Xh2pl/tcbreak2 25 cbreak test routine using .pl Xhandy.h 32 Handy definitions Xhash.c 26 Associative arrays Xhash.h 34 Public declarations for the above Xhints/3b2.sh 36 Xhints/aix_rs.sh 36 Xhints/aix_rt.sh 36 Xhints/apollo_C6_7.sh 36 Xhints/aux.sh 36 Xhints/dnix.sh 36 Xhints/dynix.sh 36 Xhints/fps.sh 36 Xhints/genix.sh 36 Xhints/hp9000_300.sh 36 Xhints/hp9000_400.sh 36 Xhints/hpux.sh 36 Xhints/i386.sh 36 Xhints/mips.sh 36 Xhints/ncr_tower.sh 36 Xhints/next.sh 36 Xhints/osf_1.sh 36 Xhints/sco_2_3_0.sh 36 Xhints/sco_2_3_1.sh 36 Xhints/sco_2_3_2.sh 36 Xhints/sco_2_3_3.sh 36 Xhints/sco_3.sh 36 Xhints/sgi.sh 36 Xhints/sunos_3_4.sh 36 Xhints/sunos_3_5.sh 36 Xhints/sunos_4_0_1.sh 36 Xhints/sunos_4_0_2.sh 36 Xhints/ultrix_3.sh 36 Xhints/ultrix_4.sh 36 Xhints/uts.sh 35 Xinstallperl 31 Perl script to do "make install" dirty work Xioctl.pl 32 Sample ioctl.pl Xlib/abbrev.pl 36 An abbreviation table builder Xlib/bigfloat.pl 29 An arbitrary precision floating point package Xlib/bigint.pl 29 An arbitrary precision integer arithmetic package Xlib/bigrat.pl 31 An arbitrary precision rational arithmetic package Xlib/cacheout.pl 28 Manages output filehandles when you need too many Xlib/complete.pl 34 A command completion subroutine Xlib/ctime.pl 23 A ctime workalike Xlib/dumpvar.pl 35 A variable dumper Xlib/flush.pl 36 Routines to do single flush Xlib/getopt.pl 35 Perl library supporting option parsing Xlib/getopts.pl 35 Perl library supporting option parsing Xlib/importenv.pl 36 Perl routine to get environment into variables Xlib/look.pl 35 A "look" equivalent Xlib/perldb.pl 26 Perl debugging routines Xlib/pwd.pl 35 Routines to keep track of PWD environment variable Xlib/stat.pl 17 Perl library supporting stat function Xlib/syslog.pl 30 Perl library supporting syslogging Xlib/termcap.pl 32 Perl library supporting termcap usage Xlib/timelocal.pl 31 Perl library supporting inverse of localtime, gmtime Xlib/validate.pl 32 Perl library supporting wholesale file mode validation Xmakedepend.SH 30 Precursor to makedepend Xmakedir.SH 34 Precursor to makedir Xmalloc.c 12 A version of malloc you might not want Xmsdos/Changes.dds 13 Expanation of MS-DOS patches by Diomidis Spinellis Xmsdos/Makefile 24 MS-DOS makefile Xmsdos/README.msdos 1 Compiling and usage information Xmsdos/Wishlist.dds 35 My wishlist Xmsdos/chdir.c 32 A chdir that can change drives Xmsdos/config.h 22 Definitions for msdos Xmsdos/dir.h 34 MS-DOS header for directory access functions Xmsdos/directory.c 32 MS-DOS directory access functions. Xmsdos/eg/crlf.bat 35 Convert files from unix to MS-DOS line termination Xmsdos/eg/drives.bat 35 List the system drives and their characteristics Xmsdos/eg/lf.bat 35 Convert files from MS-DOS to Unix line termination Xmsdos/glob.c 36 A command equivalent to csh glob Xmsdos/msdos.c 30 MS-DOS ioctl, sleep, gete?[gu]if, spawn, aspawn Xmsdos/popen.c 32 My_popen and my_pclose for MS-DOS Xmsdos/usage.c 34 How to invoke perl under MS-DOS Xos2/Makefile 33 Makefile for OS/2 Xos2/README.OS2 1 Notes for OS/2 Xos2/a2p.cs 36 Compiler script for a2p Xos2/a2p.def 36 Linker defs for a2p Xos2/alarm.c 31 An implementation of alarm() Xos2/alarm.h 36 Header file for same Xos2/config.h 25 Configuration file for OS/2 Xos2/dir.h 34 Directory header Xos2/director.c 30 Directory routines Xos2/eg/alarm.pl 36 Example of alarm code Xos2/eg/os2.pl 34 Sample script for OS/2 Xos2/eg/syscalls.pl 36 Example of syscall on OS/2 Xos2/glob.c 34 Globbing routines Xos2/makefile 33 Make file Xos2/mktemp.c 36 Mktemp() using TMP Xos2/os2.c 30 Unix compatibility functions Xos2/perl.bad 36 names of protect-only API calls for BIND Xos2/perl.cs 36 Compiler script for perl Xos2/perl.def 36 Linker defs for perl Xos2/perldb.dif 35 Changes to make the debugger work Xos2/perlglob.bad 36 names of protect-only API calls for BIND Xos2/perlglob.cs 36 Compiler script for perlglob Xos2/perlglob.def 36 Linker defs for perlglob Xos2/perlsh.cmd 36 Poor man's shell for os2 Xos2/popen.c 25 Code for opening pipes Xos2/s2p.cmd 28 s2p as command file Xos2/selfrun.bat 36 A self running perl script for DOS Xos2/selfrun.cmd 36 Example of extproc feature Xos2/suffix.c 29 Code for creating backup filenames Xpatchlevel.h 19 The current patch level of perl Xperl.c 16 main() Xperl.h 19 Global declarations Xperl.man:AA 2 The manual page(s) Xperl.man:AB 5 Xperl.man:AC 8 Xperl.man:AD 10 Xperlsh 16 A poor man's perl shell Xperly.fixer 32 A program to remove yacc stack limitations Xperly.y 22 Yacc grammar for perl Xregcomp.c 18 Regular expression compiler Xregcomp.h 29 Private declarations for above Xregexec.c 21 Regular expression evaluator Xregexp.h 35 Public declarations for the above Xserver 36 A server to test sockets Xspat.h 34 Search pattern declarations Xstab.c 24 Symbol table stuff Xstab.h 32 Public declarations for the above Xstr.c 15 String handling package Xstr.h 31 Public declarations for the above Xt/README 1 Instructions for regression tests Xt/TEST 34 The regression tester Xt/base/cond.t 36 See if conditionals work Xt/base/if.t 36 See if if works Xt/base/lex.t 35 See if lexical items work Xt/base/pat.t 36 See if pattern matching works Xt/base/term.t 35 See if various terms work Xt/cmd/elsif.t 36 See if else-if works Xt/cmd/for.t 35 See if for loops work Xt/cmd/mod.t 36 See if statement modifiers work Xt/cmd/subval.t 32 See if subroutine values work Xt/cmd/switch.t 15 See if switch optimizations work Xt/cmd/while.t 33 See if while loops work Xt/comp/cmdopt.t 33 See if command optimization works Xt/comp/cpp.t 36 See if C preprocessor works Xt/comp/decl.t 36 See if declarations work Xt/comp/multiline.t 35 See if multiline strings work Xt/comp/package.t 36 See if packages work Xt/comp/script.t 36 See if script invokation works Xt/comp/term.t 34 See if more terms work Xt/io/argv.t 35 See if ARGV stuff works Xt/io/dup.t 36 See if >& works right Xt/io/fs.t 33 See if directory manipulations work Xt/io/inplace.t 36 See if inplace editing works Xt/io/pipe.t 35 See if secure pipes work Xt/io/print.t 36 See if print commands work Xt/io/tell.t 35 See if file seeking works Xt/lib/big.t 31 See if lib/bigint.pl works Xt/op/append.t 36 See if . works Xt/op/array.t 31 See if array operations work Xt/op/auto.t 33 See if autoincrement et all work Xt/op/chop.t 36 See if chop works Xt/op/cond.t 36 See if conditional expressions work Xt/op/dbm.t 33 See if dbm binding works Xt/op/delete.t 14 See if delete works Xt/op/do.t 35 See if subroutines work Xt/op/each.t 35 See if associative iterators work Xt/op/eval.t 35 See if eval operator works Xt/op/exec.t 36 See if exec and system work Xt/op/exp.t 36 See if math functions work Xt/op/flip.t 36 See if range operator works Xt/op/fork.t 12 See if fork works Xt/op/glob.t 36 See if <*> works Xt/op/goto.t 36 See if goto works Xt/op/groups.t 36 See if $( works Xt/op/index.t 34 See if index works Xt/op/int.t 36 See if int works Xt/op/join.t 36 See if join works Xt/op/list.t 33 See if array lists work Xt/op/local.t 35 See if local works Xt/op/magic.t 35 See if magic variables work Xt/op/mkdir.t 36 See if mkdir works Xt/op/oct.t 36 See if oct and hex work Xt/op/ord.t 36 See if ord works Xt/op/pack.t 36 See if pack and unpack work Xt/op/pat.t 32 See if esoteric patterns work Xt/op/push.t 35 See if push and pop work Xt/op/range.t 35 See if .. works Xt/op/re_tests 33 Input file for op.regexp Xt/op/read.t 21 See if read() works Xt/op/regexp.t 35 See if regular expressions work Xt/op/repeat.t 34 See if x operator works Xt/op/s.t 31 See if substitutions work Xt/op/sleep.t 36 See if sleep works Xt/op/sort.t 27 See if sort works Xt/op/split.t 34 See if split works Xt/op/sprintf.t 36 See if sprintf works Xt/op/stat.t 30 See if stat works Xt/op/study.t 1 See if study works Xt/op/substr.t 34 See if substr works Xt/op/time.t 35 See if time functions work Xt/op/undef.t 34 See if undef works Xt/op/unshift.t 36 See if unshift works Xt/op/vec.t 35 See if vectors work Xt/op/write.t 34 See if write works Xtoke.c:AA 4 The tokener Xtoke.c:AB 28 Xusersub.c 32 User supplied (possibly proprietary) subroutines Xusub/Makefile 36 Makefile for curseperl Xusub/README 1 Instructions for user supplied subroutines Xusub/curses.mus 14 Glue routines for BSD curses Xusub/man2mus 34 A manual page to .mus translator Xusub/mus 33 A .mus to .c translator Xusub/pager 32 A sample pager in curseperl Xusub/usersub.c 36 An initialization file to call curses glue routines Xutil.c 17 Utility routines Xutil.h 35 Public declarations for the above Xx2p/EXTERN.h 36 Same as above Xx2p/INTERN.h 36 Same as above Xx2p/Makefile.SH 33 Precursor to Makefile Xx2p/a2p.h 29 Global declarations Xx2p/a2p.man 29 Manual page for awk to perl translator Xx2p/a2p.y 27 A yacc grammer for awk Xx2p/a2py.c 24 Awk compiler, sort of Xx2p/find2perl.SH 26 A find to perl translator Xx2p/handy.h 35 Handy definitions Xx2p/hash.c 31 Associative arrays again Xx2p/hash.h 34 Public declarations for the above Xx2p/s2p.SH 27 Sed to perl translator Xx2p/s2p.man 33 Manual page for sed to perl translator Xx2p/str.c 13 String handling package Xx2p/str.h 35 Public declarations for the above Xx2p/util.c 30 Utility routines Xx2p/util.h 35 Public declarations for the above Xx2p/walk.c 9 Parse tree walker !STUFFY!FUNK! echo Extracting lib/stat.pl sed >lib/stat.pl <<'!STUFFY!FUNK!' -e 's/X//' X;# $Header: stat.pl,v 4.0 91/03/20 01:26:16 lwall Locked $ X X;# Usage: X;# require 'stat.pl'; X;# @ary = stat(foo); X;# $st_dev = @ary[$ST_DEV]; X;# X$ST_DEV = 0 + $[; X$ST_INO = 1 + $[; X$ST_MODE = 2 + $[; X$ST_NLINK = 3 + $[; X$ST_UID = 4 + $[; X$ST_GID = 5 + $[; X$ST_RDEV = 6 + $[; X$ST_SIZE = 7 + $[; X$ST_ATIME = 8 + $[; X$ST_MTIME = 9 + $[; X$ST_CTIME = 10 + $[; X$ST_BLKSIZE = 11 + $[; X$ST_BLOCKS = 12 + $[; X X;# Usage: X;# require 'stat.pl'; X;# do Stat('foo'); # sets st_* as a side effect X;# Xsub Stat { X ($st_dev,$st_ino,$st_mode,$st_nlink,$st_uid,$st_gid,$st_rdev,$st_size, X $st_atime,$st_mtime,$st_ctime,$st_blksize,$st_blocks) = stat(shift(@_)); X} X X1; !STUFFY!FUNK! echo " " echo "End of kit 17 (of 36)" cat /dev/null >kit17isdone run='' config='' for iskit in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36; do if test -f kit${iskit}isdone; then run="$run $iskit" else todo="$todo $iskit" fi done case $todo in '') echo "You have run all your kits. Please read README and then type Configure." for combo in *:AA; do if test -f "$combo"; then realfile=`basename $combo :AA` cat $realfile:[A-Z][A-Z] >$realfile rm -rf $realfile:[A-Z][A-Z] fi done rm -rf kit*isdone chmod 755 Configure ;; *) echo "You have run$run." echo "You still need to run$todo." ;; esac : Someone might mail this, so... exit exit 0 # Just in case... -- Kent Landfield INTERNET: kent@sparky.IMD.Sterling.COM Sterling Software, IMD UUCP: uunet!sparky!kent Phone: (402) 291-8300 FAX: (402) 291-4362 Please send comp.sources.misc-related mail to kent@uunet.uu.net.