BSD 4_3_Tahoe development

Work on file usr/lib/lex/nrform
Work on file usr/lib/lex/ncform
Work on file usr/lib/lint/llib-lm
Work on file usr/lib/lint/llib-lmp
Work on file usr/lib/lint/llib-ltermlib.ln
Work on file usr/lib/lint/llib-ltermlib

Synthesized-from: CSRG/cd2/4.3tahoe

diff --git a/usr/lib/lex/ncform b/usr/lib/lex/ncform
new file mode 100755 (executable)
index 0000000..789650d
--- /dev/null
+++ b/usr/lib/lex/ncform
@@ -0,0 +1,181 @@
+/*     ncform  4.1     83/08/11        */
+
+int yylineno =1;
+# define YYU(x) x
+# define NLSTATE yyprevious=YYNEWLINE
+char yytext[YYLMAX];
+struct yysvf *yylstate [YYLMAX], **yylsp, **yyolsp;
+char yysbuf[YYLMAX];
+char *yysptr = yysbuf;
+int *yyfnd;
+extern struct yysvf *yyestate;
+int yyprevious = YYNEWLINE;
+yylook(){
+       register struct yysvf *yystate, **lsp;
+       register struct yywork *yyt;
+       struct yysvf *yyz;
+       int yych;
+       struct yywork *yyr;
+# ifdef LEXDEBUG
+       int debug;
+# endif
+       char *yylastch;
+       /* start off machines */
+# ifdef LEXDEBUG
+       debug = 0;
+# endif
+       if (!yymorfg)
+               yylastch = yytext;
+       else {
+               yymorfg=0;
+               yylastch = yytext+yyleng;
+               }
+       for(;;){
+               lsp = yylstate;
+               yyestate = yystate = yybgin;
+               if (yyprevious==YYNEWLINE) yystate++;
+               for (;;){
+# ifdef LEXDEBUG
+                       if(debug)fprintf(yyout,"state %d\n",yystate-yysvec-1);
+# endif
+                       yyt = yystate->yystoff;
+                       if(yyt == yycrank){             /* may not be any transitions */
+                               yyz = yystate->yyother;
+                               if(yyz == 0)break;
+                               if(yyz->yystoff == yycrank)break;
+                               }
+                       *yylastch++ = yych = input();
+               tryagain:
+# ifdef LEXDEBUG
+                       if(debug){
+                               fprintf(yyout,"char ");
+                               allprint(yych);
+                               putchar('\n');
+                               }
+# endif
+                       yyr = yyt;
+                       if ( (int)yyt > (int)yycrank){
+                               yyt = yyr + yych;
+                               if (yyt <= yytop && yyt->verify+yysvec == yystate){
+                                       if(yyt->advance+yysvec == YYLERR)       /* error transitions */
+                                               {unput(*--yylastch);break;}
+                                       *lsp++ = yystate = yyt->advance+yysvec;
+                                       goto contin;
+                                       }
+                               }
+# ifdef YYOPTIM
+                       else if((int)yyt < (int)yycrank) {              /* r < yycrank */
+                               yyt = yyr = yycrank+(yycrank-yyt);
+# ifdef LEXDEBUG
+                               if(debug)fprintf(yyout,"compressed state\n");
+# endif
+                               yyt = yyt + yych;
+                               if(yyt <= yytop && yyt->verify+yysvec == yystate){
+                                       if(yyt->advance+yysvec == YYLERR)       /* error transitions */
+                                               {unput(*--yylastch);break;}
+                                       *lsp++ = yystate = yyt->advance+yysvec;
+                                       goto contin;
+                                       }
+                               yyt = yyr + YYU(yymatch[yych]);
+# ifdef LEXDEBUG
+                               if(debug){
+                                       fprintf(yyout,"try fall back character ");
+                                       allprint(YYU(yymatch[yych]));
+                                       putchar('\n');
+                                       }
+# endif
+                               if(yyt <= yytop && yyt->verify+yysvec == yystate){
+                                       if(yyt->advance+yysvec == YYLERR)       /* error transition */
+                                               {unput(*--yylastch);break;}
+                                       *lsp++ = yystate = yyt->advance+yysvec;
+                                       goto contin;
+                                       }
+                               }
+                       if ((yystate = yystate->yyother) && (yyt= yystate->yystoff) != yycrank){
+# ifdef LEXDEBUG
+                               if(debug)fprintf(yyout,"fall back to state %d\n",yystate-yysvec-1);
+# endif
+                               goto tryagain;
+                               }
+# endif
+                       else
+                               {unput(*--yylastch);break;}
+               contin:
+# ifdef LEXDEBUG
+                       if(debug){
+                               fprintf(yyout,"state %d char ",yystate-yysvec-1);
+                               allprint(yych);
+                               putchar('\n');
+                               }
+# endif
+                       ;
+                       }
+# ifdef LEXDEBUG
+               if(debug){
+                       fprintf(yyout,"stopped at %d with ",*(lsp-1)-yysvec-1);
+                       allprint(yych);
+                       putchar('\n');
+                       }
+# endif
+               while (lsp-- > yylstate){
+                       *yylastch-- = 0;
+                       if (*lsp != 0 && (yyfnd= (*lsp)->yystops) && *yyfnd > 0){
+                               yyolsp = lsp;
+                               if(yyextra[*yyfnd]){            /* must backup */
+                                       while(yyback((*lsp)->yystops,-*yyfnd) != 1 && lsp > yylstate){
+                                               lsp--;
+                                               unput(*yylastch--);
+                                               }
+                                       }
+                               yyprevious = YYU(*yylastch);
+                               yylsp = lsp;
+                               yyleng = yylastch-yytext+1;
+                               yytext[yyleng] = 0;
+# ifdef LEXDEBUG
+                               if(debug){
+                                       fprintf(yyout,"\nmatch ");
+                                       sprint(yytext);
+                                       fprintf(yyout," action %d\n",*yyfnd);
+                                       }
+# endif
+                               return(*yyfnd++);
+                               }
+                       unput(*yylastch);
+                       }
+               if (yytext[0] == 0  /* && feof(yyin) */)
+                       {
+                       yysptr=yysbuf;
+                       return(0);
+                       }
+               yyprevious = yytext[0] = input();
+               if (yyprevious>0)
+                       output(yyprevious);
+               yylastch=yytext;
+# ifdef LEXDEBUG
+               if(debug)putchar('\n');
+# endif
+               }
+       }
+yyback(p, m)
+       int *p;
+{
+if (p==0) return(0);
+while (*p)
+       {
+       if (*p++ == m)
+               return(1);
+       }
+return(0);
+}
+       /* the following are only used in the lex library */
+yyinput(){
+       return(input());
+       }
+yyoutput(c)
+  int c; {
+       output(c);
+       }
+yyunput(c)
+   int c; {
+       unput(c);
+       }

diff --git a/usr/lib/lex/nrform b/usr/lib/lex/nrform
new file mode 100755 (executable)
index 0000000..8621ef9
--- /dev/null
+++ b/usr/lib/lex/nrform
@@ -0,0 +1,155 @@
+block data
+integer cshift, csize, yynlin
+common /yyllib/ cshift, csize, yynlin
+data yynlin/YYNEWLINE/
+end
+block data
+common /yyldat/ yyfnd, ymorf, yyprev, yybgin, yytop
+integer yyfnd, yymorf, yyprev, yybgin, yytop
+data yybgin/1/
+data yyprev/YYNEWLINE/
+data yytop/YYTOPVAL/
+end
+integer function yylook(dummy)
+common /Lverif/ verif
+common /Ladvan/ advan
+common /Lstoff/ stoff
+common /Lsfall/ sfall
+common /Latable/ atable
+common /Lextra/ extra
+common /Lvstop/ vstop
+integer verif(Sverif), advan(Sadvan),stoff(Sstoff),match(Smatch)
+integer sfall(Ssfall),atable(Satable),extra(Sextra), vstop(Svstop)
+integer state, lsp, r
+integer  ch, n
+common /yyldat/ yyfnd, yymorf, yyprev, yybgin, yytop, yylsp, yylsta(YYLMAX)
+common /yyxel/ yyleng, yytext
+integer yyfnd, yymorf, yylsta, yylsp, yytext, yyprev, yyleng, yytop
+integer  lexshf, yytext(YYLMAX), yyback, yybgin
+integer z, t
+if (yymorf .eq. 0)
+       yyleng = 0
+else
+       yymorf=0
+1776
+       lsp = 1
+       state = yybgin
+       if (yyprev .eq. YYNEWLINE)
+               state = state + 1
+       for (;;){
+               r = stoff(state)
+               if (r .eq. 0){
+                       z = sfall(state)
+                       if (z .eq. 0)
+                               break
+                       if(stoff(z) == 0) break
+                       }
+               ch = input(dummy)
+               ich = lexshf(ch)
+               yyleng = yyleng+1
+               yytext(yyleng) = ch
+               1984
+               if(r .gt. 0){
+                       t = r + ich
+                       if (t<= yytop){
+                         if (verif(t) .eq. state){
+                               if(advan(t) == YYERROR){
+                                       call unput(yytext(yyleng))
+                                       yyleng = yyleng - 1
+                                       break
+                                       }
+                               state = advan(t)
+                               yylsta(lsp) = state
+                               lsp = lsp +1
+                               goto 2001
+                               }
+                         }
+                       }
+               if(r < 0){
+                       t = r + ich
+                       if (t <= yytop .and. verif(t) .eq. state){
+                               if(advan(t) == YYERROR){
+                                       call unput(yytext(yyleng))
+                                       yyleng = yyleng - 1
+                                       break
+                                       }
+                               state = advan(t)
+                               yylsta(lsp) = state
+                               lsp = lsp +1
+                               goto 2001
+                               }
+                       t = r + match(ich)
+                       if(t <= yytop && state == verif(t)){
+                               if(advan(t) == YYERROR){
+                                       call unput(yytext(yyleng))
+                                       yyleng = yyleng - 1
+                                       break
+                                       }
+                       state = advan(t)
+                       yylsta(lsp) = state
+                       lsp = lsp + 1
+                       goto 2001
+                       }
+               }
+               else {
+                       if (state > 0) state = sfall(state)
+                       if (state .gt. 0) r = stoff(state)
+                       if (state .gt. 0 .and. r .ne. 0)
+                               goto 1984
+                       call unput(yytext(yyleng))
+                       yyleng = yyleng -1
+                       break
+                       }
+       2001
+               continue
+               }
+       while (lsp .gt. 1){
+               lsp = lsp -1
+               ilsp = yylsta(lsp)
+               yyfnd = atable(ilsp)
+               if (yyfnd .gt. 0)
+                       if (vstop(yyfnd) .gt. 0){
+                               r = vstop(yyfnd)
+                               if (extra(r) .ne. 0){
+                                       for(;;){
+                                       ilsp = yylsta(lsp)
+                                       if (yyback(atable(ilsp), -r) .eq. 1)
+                                               break
+                                       lsp= lsp -1
+                                       call unput(yytext(yyleng))
+                                       yyleng = yyleng -1
+                                       }
+                                       }
+                               yyprev = lexshf(yytext(yyleng))
+                               yylsp = lsp
+                               yyfnd = yyfnd + 1
+                               yylook = r
+                               yytext(yyleng+1) = 0
+                               return
+                               }
+               call unput(yytext(yyleng))
+               }
+       if (yytext(1) .eq. 0){
+               yylook=0
+               return
+               }
+       yyprev = input(dummy)
+       call output(yyprev)
+       yyprev = lexshf(yyprev)
+       yyleng = 0
+       goto 1776
+end
+integer function yyback (isub, n)
+common /Lvstop/ vstop
+integer vstop(Svstop)
+if (isub .ne. 0)
+while (vstop(isub) .ne. 0){
+       if (vstop(isub) .eq. m){
+               yyback = 1
+               return
+               }
+       isub = isub + 1
+       }
+yyback = 0
+return 
+end

diff --git a/usr/lib/lint/llib-lm b/usr/lib/lint/llib-lm
new file mode 100644 (file)
index 0000000..aae5aef
--- /dev/null
+++ b/usr/lib/lint/llib-lm
@@ -0,0 +1,45 @@
+/*     llib-lm 1.4     87/04/13        */
+    /* LINTLIBRARY */
+double acos(x) double x; { return x; }
+double acosh(x) double x; { return x; }
+double asin(x) double x; { return x; }
+double asinh(x) double x; { return x; }
+double atan(x) double x; { return x; }
+double atanh(x) double x; { return x; }
+double atan2(x,y) double x,y; { return x; }
+double cabs(z) struct {double x, y;} z; { return z.x; }
+double cbrt(x) double x; { return x; }
+double ceil(x) double x; { return x; }
+double copysign(x,y) double x,y; { return x; }
+double cos(x) double x; { return x; }
+double cosh(x) double x; { return x; }
+double drem(x,y) double x,y; { return x; }
+double erf(x) double x; { return x; }
+double erfc(x) double x; { return x; }
+double exp(x) double x; { return x; }
+double expm1(x) double x; { return x; }
+double fabs(x) double x; { return x; }
+int    finite(x) double x; { return 0; }
+double floor(x) double x; { return x; }
+double gamma(x) double x; { return x; }
+double hypot(x,y) double x,y; { return x; }
+double infnan(i) { return 1.0; };
+double j0(x) double x; { return x; }
+double j1(x) double x; { return x; }
+double jn(n,x) double x; { return x; }
+double lgamma(x) double x; { return x; }
+double log(x) double x; { return x; }
+double logb(x) double x; { return x; }
+double log10(x) double x; { return x; }
+double log1p(x) double x; { return x; }
+double pow(x,y) double x,y; { return x; }
+double rint(x) double x; { return x; }
+double scalb(x,n) double x; { return x; }
+double sin(x) double x; { return x; }
+double sinh(x) double x; { return x; }
+double sqrt(x) double x; { return x; }
+double tan(x) double x; { return x; }
+double tanh(x) double x; { return x; }
+double y0(x) double x; { return x; }
+double y1(x) double x; { return x; }
+double yn(n,x) double x; { return x; }

diff --git a/usr/lib/lint/llib-lmp b/usr/lib/lint/llib-lmp
new file mode 100644 (file)
index 0000000..7ce3c58
--- /dev/null
+++ b/usr/lib/lint/llib-lmp
@@ -0,0 +1,39 @@
+/*     llib-lmp        1.2     86/03/13        */
+/* LINTLIBRARY */
+#include <stdio.h>
+#include <mp.h>
+       gcd(a,b,c) MINT *a,*b,*c; {}
+       invert(a, b, c) MINT *a, *b, *c; {}
+       m_add(a,b,c) struct mint *a,*b,*c; {}
+       madd(a,b,c) struct mint *a,*b,*c; {}
+       m_sub(a,b,c) struct mint *a,*b,*c; {}
+       msub(a,b,c) struct mint *a,*b,*c; {}
+       mdiv(a,b,q,r) MINT *a,*b,*q,*r; {}
+int    m_dsb(q,n,a,b) short *a,*b; { return 0; }
+long   m_trq(v1,v2,u1,u2,u3) { return 0L; }
+       m_div(a,b,q,r) MINT *a,*b,*q,*r; {}
+int    m_in(a,b,f) MINT *a; FILE *f; { return EOF; }
+       m_out(a,b,f) MINT *a; FILE *f; {}
+       sdiv(a,n,q,r) MINT *a,*q; short n; short *r; {}
+       s_div(a,n,q,r) MINT *a,*q; short n; short *r; {}
+int    min(a) MINT *a; { return 0; }
+int    omin(a) MINT *a; { return 0; }
+       mout(a) MINT *a; {}
+       omout(a) MINT *a; {}
+       fmout(a,f) MINT *a; FILE *f; {}
+int    fmin(a,f) MINT *a; FILE *f; {}
+int    msqrt(a,b,r) MINT *a,*b,*r; { return 0; }
+       mult(a,b,c) struct mint *a,*b,*c; {}
+       m_mult(a,b,c) struct mint *a,*b,*c; {}
+       tradd(a,b,c) long c; int *a; union g {long xx; struct half yy;} *b; {}
+       pow(a,b,c,d) MINT *a,*b,*c,*d; {}
+       rpow(a,n,b) MINT *a,*b; {}
+       move(a,b) MINT *a,*b; {}
+       dummy(){}
+       /* VARARGS */
+short *        xalloc(nint,s) char *s; { static short sh; return &sh; }
+       fatal(s) char *s; { /* NOTREACHED */ }
+       xfree(c) MINT *c; {}
+       mcan(a) MINT *a; {}
+MINT * itom(n) { static MINT m; return &m; }
+int    mcmp(a,b) MINT *a,*b; { return 0; }

diff --git a/usr/lib/lint/llib-ltermlib b/usr/lib/lint/llib-ltermlib
new file mode 120000 (symlink)
index 0000000..68139d9
--- /dev/null
+++ b/usr/lib/lint/llib-ltermlib
@@ -0,0 +1 @@
+llib-ltermcap
\ No newline at end of file

diff --git a/usr/lib/lint/llib-ltermlib.ln b/usr/lib/lint/llib-ltermlib.ln
new file mode 120000 (symlink)
index 0000000..881bd5e
--- /dev/null
+++ b/usr/lib/lint/llib-ltermlib.ln
@@ -0,0 +1 @@
+llib-ltermcap.ln
\ No newline at end of file