allbery@uunet.UU.NET (Brandon S. Allbery - comp.sources.misc) (06/04/89)
Posting-number: Volume 7, Issue 4
Submitted-by: sparks@corpane.uucp
Archive-name: kraut
[I'm tempted to put a disclaimer here myself, considering the (minor) uproar
that happened over jive and valspeak. (I'm part German myself, and unoffended
by this, and hard put to understand why anyone would be... oh, well.)
More serious note: I see a comment ended with "*\" -- yes, that's a BACKSLASH.
If you get strange errors, check for that. (The compiler speaks with an accent
as well??? ;-) ++bsa]
Kraut v0.9
==============================================================================
English:
Kraut is a lexical converter like Jive and Valspeak, which everyone is most
likely familiar with. It takes normal (English) text and converts it into
text with a German accent. For example, this was normal text that was run
through Kraut (see below for the kraut version).
Disclaimer: Kraut is intended as humor only. It is not meant to be derogatory
to anybody, race, creed, or nationality. Please accept it in the vein that
I wrote it, as humor. [I am half German myself, was born in Augsburg, and
lived there off and on for about 8 years. I have the utmost respect for the
German people and their culture.]
John Sparks
uunet!ukma!corpane!sparks
-----------------
Kraut:
Kraut ist a lexical konferter like Jife undt Falspeak, vhich eferyone ist most
likely familiar vid. It takes normal (Englisch) text undt conferts it into
text mitt a German accent. For example, dis vas normal text dat vas r-r-run
drough Kraut.
Disclaimer: Kraut ist intended as humor only. It ist not meant to be derogatory
to anybody, r-r-race, kreed, or nationality. Please accept it in ze fein dat
I wrote it, as humor. [I am half German meinself, vas born in Augsburg, and
lifed dere off undt on for about 8 years. I hafe ze utmost r-r-respect for de
German people undt deir kulture.]
Johann Sparks
----
This is a shell archive. cut everything off above (and including)
the ---cut me--- line below. rename the portion remaining to kraut.shar and
do the following command (unix) to restore the files:
$ sh kraut.shar
------------------8<-------cut me-----------------------8<----------------
echo x - destructions
sed 's/^X//' >destructions <<'*-*-END-of-destructions-*-*'
X Kraut
X +++++++++++++++++
XCompiling Kraut:
X
XYou should have the files: kraut.c and kraut.l and lex.yy.c
X
X
Xkraut.l must be run thru the unix 'lex' utility to produce the file lex.yy.c
XThen compile kraut.c and lex.yy.c to produce kraut
X
X $lex kraut.l
X $cc kraut.c lex.yy.c -o kraut
X (You may get a list of warnings from the compiler. Ignore them.)
X
XNote: lex.yy.c is included in this package. You only need to use lex if you
Xwish to make changes to kraut.
X
XUsing Kraut:
X
X Kraut uses standard input and output.
X
Xexamples:
X
XTo translate a file called 'note' and output kraut to a file called 'knote':
X
X $ cat note | kraut > knote
X
XTo translate a file called 'note' and just print it to the screen:
X
X $ cat note | kraut
X
XTo have kraut wait to translate what you type at the keyboard and return it in
Xkraut on your screen:
X
X $ kraut
X
*-*-END-of-destructions-*-*
echo x - kraut.c
sed 's/^X//' >kraut.c <<'*-*-END-of-kraut.c-*-*'
X#include <stdio.h>
X/* Kraut v0.9 */
X/* by */
X/* John Sparks */
X/* 5-5-1989 */
X
X/* This is in the public domain. Do with it as you will. *\
X
Xmain()
X{
Xchar *line;
X
X while(line = (char *) yylex()){
X printf("%s", line);
X }
X}
X
Xyywrap ()
X{
X return (1);
X}
*-*-END-of-kraut.c-*-*
echo x - kraut.l
sed 's/^X//' >kraut.l <<'*-*-END-of-kraut.l-*-*'
X%e 2000
X%p 5000
X%n 1000
X%k 500
X%a 4000
X%o 2000
XBW [ ]
XEW [ .,;!?]
X
X%{
X char buf[128];
X
X%}
X
X%%
Xing return("ingkt");
X" the " return(" ze ");
X"The " return("Ze ");
X" with " return(" mitt ");
X"With " return("Mitt ");
Xwr return("w-r-r");
XWr return("W-r-r");
XR return("R-r-r");
X"Yes " return("Jawohl ");
X" r" return(" r-r-r");
X"Yes." return("Jawohl.");
X"Yes!" return("Jawohl!");
X"YES!" return("JAWOHL!");
X" yes " return(" ja ");
X" yes." return(" ja.");
X" yes!" return(" yes!");
X"No " return("Nein ");
X"No!" return("Nein!");
X"No?" return("Nein?");
X" no " return(" nein ");
X" no." return(" nein.");
X" no!" return(" nein!");
X" no?" return(" nein?");
X[Mm]"r." return("Herr");
X[Mm]"rs." return("Frau");
XMiss return("Fraulein");
X" of " return(" uff ");
X"Of " return("Uff ");
Xmy return("mein");
XMy return("Mein");
X" and " return(" undt ");
X"And " return("Undt ");
X"One " return("Ein ");
X" one" return(" ein");
X"Is " return("Ist ");
X" is " return(" ist ");
X"ow " return("ow ");
X"w " return("w ");
Xsh return("sch");
XSh return("Sch");
Xch return("ch");
XCh return("Ch");
X" c" return(" k");
X" C" return(" K");
X
Xv return("f");
XV return("F");
X" w" return(" v");
XW return("V");
Xth return("d");
XTh return("D");
X[Jj]ohn return("Johann");
X[Ww]illiam return("Wilhelm");
X[Bb]rad return("Wilhelm");
X[Gg]ary return("Gerhardt");
X[Jj]on return("Hansel");
X
X[a-f]"!" {sprintf(buf,"%s Naturlich!",yytext);return(buf);}
X[p-z]"!" {sprintf(buf,"%s Seig Heil!",yytext);return(buf);}
X. return(yytext);
X\n return("\n");
X
X%%
X
X
*-*-END-of-kraut.l-*-*
echo x - lex.yy.c
sed 's/^X//' >lex.yy.c <<'*-*-END-of-lex.yy.c-*-*'
X# include "stdio.h"
X# define U(x) x
X# define NLSTATE yyprevious=YYNEWLINE
X# define BEGIN yybgin = yysvec + 1 +
X# define INITIAL 0
X# define YYLERR yysvec
X# define YYSTATE (yyestate-yysvec-1)
X# define YYOPTIM 1
X# define YYLMAX 200
X# define output(c) putc(c,yyout)
X# define input() (((yytchar=yysptr>yysbuf?U(*--yysptr):getc(yyin))==10?(yylineno++,yytchar):yytchar)==EOF?0:yytchar)
X# define unput(c) {yytchar= (c);if(yytchar=='\n')yylineno--;*yysptr++=yytchar;}
X# define yymore() (yymorfg=1)
X# define ECHO fprintf(yyout, "%s",yytext)
X# define REJECT { nstr = yyreject(); goto yyfussy;}
Xint yyleng; extern char yytext[];
Xint yymorfg;
Xextern char *yysptr, yysbuf[];
Xint yytchar;
XFILE *yyin = {stdin}, *yyout = {stdout};
Xextern int yylineno;
Xstruct yysvf {
X struct yywork *yystoff;
X struct yysvf *yyother;
X int *yystops;};
Xstruct yysvf *yyestate;
Xextern struct yysvf yysvec[], *yybgin;
X char buf[128];
X
X# define YYNEWLINE 10
Xyylex(){
Xint nstr; extern int yyprevious;
Xwhile((nstr = yylook()) >= 0)
Xyyfussy: switch(nstr){
Xcase 0:
Xif(yywrap()) return(0); break;
Xcase 1:
X return("ingkt");
Xbreak;
Xcase 2:
X return(" ze ");
Xbreak;
Xcase 3:
X return("Ze ");
Xbreak;
Xcase 4:
X return(" mitt ");
Xbreak;
Xcase 5:
X return("Mitt ");
Xbreak;
Xcase 6:
X return("w-r-r");
Xbreak;
Xcase 7:
X return("W-r-r");
Xbreak;
Xcase 8:
X return("R-r-r");
Xbreak;
Xcase 9:
X return("Jawohl ");
Xbreak;
Xcase 10:
X return(" r-r-r");
Xbreak;
Xcase 11:
X return("Jawohl.");
Xbreak;
Xcase 12:
X return("Jawohl!");
Xbreak;
Xcase 13:
X return("JAWOHL!");
Xbreak;
Xcase 14:
X return(" ja ");
Xbreak;
Xcase 15:
X return(" ja.");
Xbreak;
Xcase 16:
X return(" yes!");
Xbreak;
Xcase 17:
X return("Nein ");
Xbreak;
Xcase 18:
X return("Nein!");
Xbreak;
Xcase 19:
X return("Nein?");
Xbreak;
Xcase 20:
X return(" nein ");
Xbreak;
Xcase 21:
X return(" nein.");
Xbreak;
Xcase 22:
X return(" nein!");
Xbreak;
Xcase 23:
X return(" nein?");
Xbreak;
Xcase 24:
X return("Herr");
Xbreak;
Xcase 25:
X return("Frau");
Xbreak;
Xcase 26:
X return("Fraulein");
Xbreak;
Xcase 27:
X return(" uff ");
Xbreak;
Xcase 28:
X return("Uff ");
Xbreak;
Xcase 29:
X return("mein");
Xbreak;
Xcase 30:
X return("Mein");
Xbreak;
Xcase 31:
X return(" undt ");
Xbreak;
Xcase 32:
X return("Undt ");
Xbreak;
Xcase 33:
X return("Ein ");
Xbreak;
Xcase 34:
X return(" ein");
Xbreak;
Xcase 35:
X return("Ist ");
Xbreak;
Xcase 36:
X return(" ist ");
Xbreak;
Xcase 37:
X return("ow ");
Xbreak;
Xcase 38:
X return("w ");
Xbreak;
Xcase 39:
X return("sch");
Xbreak;
Xcase 40:
X return("Sch");
Xbreak;
Xcase 41:
X return("ch");
Xbreak;
Xcase 42:
X return("Ch");
Xbreak;
Xcase 43:
X return(" k");
Xbreak;
Xcase 44:
X return(" K");
Xbreak;
Xcase 45:
X return("f");
Xbreak;
Xcase 46:
X return("F");
Xbreak;
Xcase 47:
X return(" v");
Xbreak;
Xcase 48:
X return("V");
Xbreak;
Xcase 49:
X return("d");
Xbreak;
Xcase 50:
X return("D");
Xbreak;
Xcase 51:
X return("Johann");
Xbreak;
Xcase 52:
X return("Wilhelm");
Xbreak;
Xcase 53:
X return("Wilhelm");
Xbreak;
Xcase 54:
X return("Gerhardt");
Xbreak;
Xcase 55:
X return("Hansel");
Xbreak;
Xcase 56:
X {sprintf(buf,"%s Naturlich!",yytext);return(buf);}
Xbreak;
Xcase 57:
X {sprintf(buf,"%s Seig Heil!",yytext);return(buf);}
Xbreak;
Xcase 58:
X return(yytext);
Xbreak;
Xcase 59:
X return("\n");
Xbreak;
Xcase -1:
Xbreak;
Xdefault:
Xfprintf(yyout,"bad switch yylook %d",nstr);
X} return(0); }
X/* end of yylex */
X
X
Xint yyvstop[] = {
X0,
X
X58,
X0,
X
X59,
X0,
X
X58,
X0,
X
X58,
X0,
X
X58,
X0,
X
X58,
X0,
X
X58,
X0,
X
X58,
X0,
X
X58,
X0,
X
X58,
X0,
X
X58,
X0,
X
X58,
X0,
X
X8,
X58,
X0,
X
X58,
X0,
X
X58,
X0,
X
X46,
X58,
X0,
X
X48,
X58,
X0,
X
X58,
X0,
X
X58,
X0,
X
X58,
X0,
X
X58,
X0,
X
X58,
X0,
X
X58,
X0,
X
X58,
X0,
X
X58,
X0,
X
X58,
X0,
X
X58,
X0,
X
X45,
X58,
X0,
X
X58,
X0,
X
X44,
X0,
X
X43,
X0,
X
X10,
X0,
X
X47,
X0,
X
X42,
X0,
X
X30,
X0,
X
X40,
X0,
X
X50,
X0,
X
X7,
X0,
X
X56,
X0,
X
X41,
X0,
X
X29,
X0,
X
X57,
X0,
X
X39,
X0,
X
X49,
X0,
X
X38,
X0,
X
X6,
X0,
X
X35,
X0,
X
X55,
X0,
X
X24,
X0,
X
X17,
X0,
X
X18,
X0,
X
X19,
X0,
X
X28,
X0,
X
X1,
X0,
X
X37,
X0,
X
X36,
X0,
X
X20,
X0,
X
X22,
X0,
X
X21,
X0,
X
X23,
X0,
X
X27,
X0,
X
X34,
X0,
X
X32,
X0,
X
X53,
X0,
X
X54,
X0,
X
X51,
X0,
X
X26,
X0,
X
X25,
X0,
X
X33,
X0,
X
X3,
X0,
X
X13,
X0,
X
X9,
X0,
X
X12,
X0,
X
X11,
X0,
X
X31,
X0,
X
X2,
X0,
X
X14,
X0,
X
X16,
X0,
X
X15,
X0,
X
X5,
X0,
X
X4,
X0,
X
X52,
X0,
X0};
X# define YYTYPE int
Xstruct yywork { YYTYPE verify, advance; } yycrank[] = {
X0,0, 0,0, 1,3, 0,0,
X0,0, 0,0, 0,0, 0,0,
X0,0, 0,0, 0,0, 1,4,
X0,0, 0,0, 0,0, 0,0,
X0,0, 0,0, 0,0, 0,0,
X0,0, 0,0, 0,0, 0,0,
X0,0, 0,0, 0,0, 0,0,
X0,0, 0,0, 0,0, 0,0,
X0,0, 1,5, 0,0, 21,60,
X0,0, 0,0, 23,60, 27,65,
X0,0, 0,0, 0,0, 0,0,
X0,0, 22,60, 0,0, 0,0,
X0,0, 0,0, 0,0, 0,0,
X0,0, 0,0, 0,0, 0,0,
X0,0, 0,0, 0,0, 0,0,
X0,0, 0,0, 28,65, 0,0,
X0,0, 0,0, 1,6, 1,7,
X1,8, 46,82, 0,0, 20,58,
X1,9, 0,0, 1,10, 1,11,
X31,68, 31,65, 1,12, 1,13,
X1,14, 52,91, 0,0, 1,15,
X1,16, 1,17, 0,0, 1,18,
X1,19, 2,5, 1,20, 0,0,
X0,0, 0,0, 64,99, 0,0,
X72,101, 0,0, 1,21, 1,22,
X1,23, 9,45, 74,106, 20,59,
X79,111, 8,44, 1,24, 16,54,
X17,55, 23,61, 1,25, 6,42,
X1,26, 1,27, 11,47, 7,43,
X1,28, 1,29, 10,46, 1,30,
X1,31, 13,51, 2,6, 14,52,
X2,8, 19,56, 22,43, 5,32,
X12,48, 24,62, 2,10, 14,53,
X26,64, 28,66, 19,57, 2,13,
X2,14, 12,49, 25,49, 2,15,
X2,16, 2,17, 29,67, 2,18,
X12,50, 25,63, 2,20, 33,71,
X35,72, 31,69, 36,73, 39,76,
X37,74, 40,77, 41,78, 42,79,
X2,23, 5,33, 31,70, 5,34,
X37,75, 43,80, 2,24, 45,81,
X48,85, 5,35, 2,25, 49,86,
X2,26, 53,92, 5,36, 5,37,
X2,28, 2,29, 5,38, 2,30,
X5,39, 47,83, 55,93, 5,40,
X56,94, 5,41, 58,96, 47,84,
X51,88, 51,89, 59,97, 62,98,
X56,95, 69,94, 71,100, 73,102,
X73,103, 75,107, 76,108, 77,109,
X78,110, 80,112, 81,113, 83,114,
X85,115, 87,116, 92,117, 93,118,
X94,119, 73,104, 95,120, 96,121,
X100,125, 97,122, 97,123, 108,126,
X109,127, 110,128, 110,129, 51,90,
X119,131, 120,132, 127,133, 131,134,
X134,135, 0,0, 73,105, 97,124,
X0,0, 0,0, 0,0, 110,130,
X0,0, 0,0, 0,0, 0,0,
X0,0, 0,0, 0,0, 0,0,
X49,87, 0,0, 0,0, 0,0,
X0,0};
Xstruct yysvf yysvec[] = {
X0, 0, 0,
Xyycrank+-1, 0, 0,
Xyycrank+-57, yysvec+1, 0,
Xyycrank+0, 0, yyvstop+1,
Xyycrank+0, 0, yyvstop+3,
Xyycrank+60, 0, yyvstop+5,
Xyycrank+1, 0, yyvstop+7,
Xyycrank+1, 0, yyvstop+9,
Xyycrank+1, 0, yyvstop+11,
Xyycrank+4, 0, yyvstop+13,
Xyycrank+3, 0, yyvstop+15,
Xyycrank+3, 0, yyvstop+17,
Xyycrank+23, 0, yyvstop+19,
Xyycrank+10, 0, yyvstop+21,
Xyycrank+21, 0, yyvstop+23,
Xyycrank+0, 0, yyvstop+25,
Xyycrank+3, 0, yyvstop+28,
Xyycrank+4, 0, yyvstop+30,
Xyycrank+0, 0, yyvstop+32,
Xyycrank+20, 0, yyvstop+35,
Xyycrank+2, 0, yyvstop+38,
Xyycrank+2, 0, yyvstop+40,
Xyycrank+12, 0, yyvstop+42,
Xyycrank+5, 0, yyvstop+44,
Xyycrank+19, 0, yyvstop+46,
Xyycrank+24, 0, yyvstop+48,
Xyycrank+13, 0, yyvstop+50,
Xyycrank+6, 0, yyvstop+52,
Xyycrank+29, 0, yyvstop+54,
Xyycrank+38, yysvec+28, yyvstop+56,
Xyycrank+0, yysvec+27, yyvstop+58,
Xyycrank+44, 0, yyvstop+61,
Xyycrank+0, 0, yyvstop+63,
Xyycrank+37, 0, 0,
Xyycrank+0, 0, yyvstop+65,
Xyycrank+33, 0, 0,
Xyycrank+39, 0, 0,
Xyycrank+50, 0, 0,
Xyycrank+0, 0, yyvstop+67,
Xyycrank+47, 0, 0,
Xyycrank+48, 0, yyvstop+69,
Xyycrank+53, 0, 0,
Xyycrank+55, 0, 0,
Xyycrank+64, 0, 0,
Xyycrank+0, 0, yyvstop+71,
Xyycrank+49, 0, 0,
Xyycrank+37, 0, 0,
Xyycrank+73, 0, 0,
Xyycrank+49, 0, 0,
Xyycrank+121, 0, 0,
Xyycrank+0, 0, yyvstop+73,
Xyycrank+152, 0, 0,
Xyycrank+49, 0, 0,
Xyycrank+68, 0, 0,
Xyycrank+0, 0, yyvstop+75,
Xyycrank+77, 0, yyvstop+77,
Xyycrank+72, 0, 0,
Xyycrank+0, 0, yyvstop+79,
Xyycrank+99, 0, 0,
Xyycrank+71, 0, 0,
Xyycrank+0, 0, yyvstop+81,
Xyycrank+0, 0, yyvstop+83,
Xyycrank+84, 0, 0,
Xyycrank+0, 0, yyvstop+85,
Xyycrank+62, 0, 0,
Xyycrank+0, 0, yyvstop+87,
Xyycrank+0, 0, yyvstop+89,
Xyycrank+0, 0, yyvstop+91,
Xyycrank+0, 0, yyvstop+93,
Xyycrank+81, 0, 0,
Xyycrank+0, 0, yyvstop+95,
Xyycrank+90, 0, 0,
Xyycrank+64, 0, 0,
Xyycrank+159, 0, 0,
Xyycrank+70, 0, 0,
Xyycrank+92, 0, 0,
Xyycrank+93, 0, 0,
Xyycrank+79, 0, 0,
Xyycrank+81, 0, 0,
Xyycrank+72, 0, 0,
Xyycrank+97, 0, 0,
Xyycrank+77, 0, 0,
Xyycrank+0, 0, yyvstop+97,
Xyycrank+89, 0, 0,
Xyycrank+0, 0, yyvstop+99,
Xyycrank+85, 0, 0,
Xyycrank+0, 0, yyvstop+101,
Xyycrank+155, 0, 0,
Xyycrank+0, 0, yyvstop+103,
Xyycrank+0, 0, yyvstop+105,
Xyycrank+0, 0, yyvstop+107,
Xyycrank+0, 0, yyvstop+109,
Xyycrank+170, 0, 0,
Xyycrank+171, 0, 0,
Xyycrank+96, 0, 0,
Xyycrank+102, 0, 0,
Xyycrank+174, 0, 0,
Xyycrank+177, 0, 0,
Xyycrank+0, 0, yyvstop+111,
Xyycrank+0, 0, yyvstop+113,
Xyycrank+176, 0, 0,
Xyycrank+0, 0, yyvstop+115,
Xyycrank+0, 0, yyvstop+117,
Xyycrank+0, 0, yyvstop+119,
Xyycrank+0, 0, yyvstop+121,
Xyycrank+0, 0, yyvstop+123,
Xyycrank+0, 0, yyvstop+125,
Xyycrank+0, 0, yyvstop+127,
Xyycrank+179, 0, 0,
Xyycrank+108, 0, 0,
Xyycrank+181, 0, 0,
Xyycrank+0, 0, yyvstop+129,
Xyycrank+0, 0, yyvstop+131,
Xyycrank+0, 0, yyvstop+133,
Xyycrank+0, 0, yyvstop+135,
Xyycrank+0, 0, yyvstop+137,
Xyycrank+0, 0, yyvstop+139,
Xyycrank+0, 0, yyvstop+141,
Xyycrank+0, 0, yyvstop+143,
Xyycrank+111, 0, 0,
Xyycrank+185, 0, 0,
Xyycrank+0, 0, yyvstop+145,
Xyycrank+0, 0, yyvstop+147,
Xyycrank+0, 0, yyvstop+149,
Xyycrank+0, 0, yyvstop+151,
Xyycrank+0, 0, yyvstop+153,
Xyycrank+0, 0, yyvstop+155,
Xyycrank+186, 0, 0,
Xyycrank+0, 0, yyvstop+157,
Xyycrank+0, 0, yyvstop+159,
Xyycrank+0, 0, yyvstop+161,
Xyycrank+122, 0, 0,
Xyycrank+0, 0, yyvstop+163,
Xyycrank+0, 0, yyvstop+165,
Xyycrank+111, 0, 0,
Xyycrank+0, 0, yyvstop+167,
X0, 0, 0};
Xstruct yywork *yytop = yycrank+236;
Xstruct yysvf *yybgin = yysvec+1;
Xchar yymatch[] = {
X00 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
X01 ,01 ,012 ,01 ,01 ,01 ,01 ,01 ,
X01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
X01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
X01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
X01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
X01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
X01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
X01 ,01 ,'B' ,01 ,01 ,01 ,01 ,'G' ,
X01 ,01 ,'J' ,01 ,01 ,'M' ,01 ,01 ,
X01 ,01 ,01 ,01 ,01 ,01 ,01 ,'W' ,
X01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
X01 ,'a' ,'b' ,'a' ,'a' ,'a' ,'a' ,'G' ,
X01 ,01 ,'J' ,01 ,01 ,'M' ,01 ,01 ,
X'p' ,'p' ,'p' ,'p' ,'p' ,'p' ,'p' ,'w' ,
X'p' ,'p' ,'p' ,01 ,01 ,01 ,01 ,01 ,
X0};
Xchar yyextra[] = {
X0,0,0,0,0,0,0,0,
X0,0,0,0,0,0,0,0,
X0,0,0,0,0,0,0,0,
X0,0,0,0,0,0,0,0,
X0,0,0,0,0,0,0,0,
X0,0,0,0,0,0,0,0,
X0,0,0,0,0,0,0,0,
X0,0,0,0,0,0,0,0,
X0};
X#ident "@(#)libl:lib/ncform 1.3"
Xint yylineno =1;
X# define YYU(x) x
X# define NLSTATE yyprevious=YYNEWLINE
Xchar yytext[YYLMAX];
Xstruct yysvf *yylstate [YYLMAX], **yylsp, **yyolsp;
Xchar yysbuf[YYLMAX];
Xchar *yysptr = yysbuf;
Xint *yyfnd;
Xextern struct yysvf *yyestate;
Xint yyprevious = YYNEWLINE;
Xyylook(){
X register struct yysvf *yystate, **lsp;
X register struct yywork *yyt;
X struct yysvf *yyz;
X int yych, yyfirst;
X struct yywork *yyr;
X# ifdef LEXDEBUG
X int debug;
X# endif
X char *yylastch;
X /* start off machines */
X# ifdef LEXDEBUG
X debug = 0;
X# endif
X yyfirst=1;
X if (!yymorfg)
X yylastch = yytext;
X else {
X yymorfg=0;
X yylastch = yytext+yyleng;
X }
X for(;;){
X lsp = yylstate;
X yyestate = yystate = yybgin;
X if (yyprevious==YYNEWLINE) yystate++;
X for (;;){
X# ifdef LEXDEBUG
X if(debug)fprintf(yyout,"state %d\n",yystate-yysvec-1);
X# endif
X yyt = yystate->yystoff;
X if(yyt == yycrank && !yyfirst){ /* may not be any transitions */
X yyz = yystate->yyother;
X if(yyz == 0)break;
X if(yyz->yystoff == yycrank)break;
X }
X *yylastch++ = yych = input();
X yyfirst=0;
X tryagain:
X# ifdef LEXDEBUG
X if(debug){
X fprintf(yyout,"char ");
X allprint(yych);
X putchar('\n');
X }
X# endif
X yyr = yyt;
X if ( (int)yyt > (int)yycrank){
X yyt = yyr + yych;
X if (yyt <= yytop && yyt->verify+yysvec == yystate){
X if(yyt->advance+yysvec == YYLERR) /* error transitions */
X {unput(*--yylastch);break;}
X *lsp++ = yystate = yyt->advance+yysvec;
X goto contin;
X }
X }
X# ifdef YYOPTIM
X else if((int)yyt < (int)yycrank) { /* r < yycrank */
X yyt = yyr = yycrank+(yycrank-yyt);
X# ifdef LEXDEBUG
X if(debug)fprintf(yyout,"compressed state\n");
X# endif
X yyt = yyt + yych;
X if(yyt <= yytop && yyt->verify+yysvec == yystate){
X if(yyt->advance+yysvec == YYLERR) /* error transitions */
X {unput(*--yylastch);break;}
X *lsp++ = yystate = yyt->advance+yysvec;
X goto contin;
X }
X yyt = yyr + YYU(yymatch[yych]);
X# ifdef LEXDEBUG
X if(debug){
X fprintf(yyout,"try fall back character ");
X allprint(YYU(yymatch[yych]));
X putchar('\n');
X }
X# endif
X if(yyt <= yytop && yyt->verify+yysvec == yystate){
X if(yyt->advance+yysvec == YYLERR) /* error transition */
X {unput(*--yylastch);break;}
X *lsp++ = yystate = yyt->advance+yysvec;
X goto contin;
X }
X }
X if ((yystate = yystate->yyother) && (yyt= yystate->yystoff) != yycrank){
X# ifdef LEXDEBUG
X if(debug)fprintf(yyout,"fall back to state %d\n",yystate-yysvec-1);
X# endif
X goto tryagain;
X }
X# endif
X else
X {unput(*--yylastch);break;}
X contin:
X# ifdef LEXDEBUG
X if(debug){
X fprintf(yyout,"state %d char ",yystate-yysvec-1);
X allprint(yych);
X putchar('\n');
X }
X# endif
X ;
X }
X# ifdef LEXDEBUG
X if(debug){
X fprintf(yyout,"stopped at %d with ",*(lsp-1)-yysvec-1);
X allprint(yych);
X putchar('\n');
X }
X# endif
X while (lsp-- > yylstate){
X *yylastch-- = 0;
X if (*lsp != 0 && (yyfnd= (*lsp)->yystops) && *yyfnd > 0){
X yyolsp = lsp;
X if(yyextra[*yyfnd]){ /* must backup */
X while(yyback((*lsp)->yystops,-*yyfnd) != 1 && lsp > yylstate){
X lsp--;
X unput(*yylastch--);
X }
X }
X yyprevious = YYU(*yylastch);
X yylsp = lsp;
X yyleng = yylastch-yytext+1;
X yytext[yyleng] = 0;
X# ifdef LEXDEBUG
X if(debug){
X fprintf(yyout,"\nmatch ");
X sprint(yytext);
X fprintf(yyout," action %d\n",*yyfnd);
X }
X# endif
X return(*yyfnd++);
X }
X unput(*yylastch);
X }
X if (yytext[0] == 0 /* && feof(yyin) */)
X {
X yysptr=yysbuf;
X return(0);
X }
X yyprevious = yytext[0] = input();
X if (yyprevious>0)
X output(yyprevious);
X yylastch=yytext;
X# ifdef LEXDEBUG
X if(debug)putchar('\n');
X# endif
X }
X }
Xyyback(p, m)
X int *p;
X{
Xif (p==0) return(0);
Xwhile (*p)
X {
X if (*p++ == m)
X return(1);
X }
Xreturn(0);
X}
X /* the following are only used in the lex library */
Xyyinput(){
X return(input());
X }
Xyyoutput(c)
X int c; {
X output(c);
X }
Xyyunput(c)
X int c; {
X unput(c);
X }
*-*-END-of-lex.yy.c-*-*
exit