BSD 4_3 development

Work on file usr/lib/lex/ncform
Work on file usr/lib/lex/nrform

Synthesized-from: CSRG/cd1/4.3

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