home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / compsrcs / misc / volume07 / kraut < prev    next >
Encoding:
Internet Message Format  |  1991-08-27  |  25.1 KB
  1. From decwrl!ucbvax!tut.cis.ohio-state.edu!cs.utexas.edu!uunet!allbery Sun Jun  4 14:43:37 PDT 1989
  2. Article 893 of comp.sources.misc:
  3. Path: decwrl!ucbvax!tut.cis.ohio-state.edu!cs.utexas.edu!uunet!allbery
  4. From: allbery@uunet.UU.NET (Brandon S. Allbery - comp.sources.misc)
  5. Newsgroups: comp.sources.misc
  6. Subject: v07i004: Kraut - English to German-accent text translator
  7. Message-ID: <56704@uunet.UU.NET>
  8. Date: 4 Jun 89 01:27:17 GMT
  9. Sender: allbery@uunet.UU.NET
  10. Reply-To: sparks@corpane.uucp
  11. Lines: 1090
  12. Approved: allbery@uunet.UU.NET (Brandon S. Allbery - comp.sources.misc)
  13.  
  14. Posting-number: Volume 7, Issue 4
  15. Submitted-by: sparks@corpane.uucp
  16. Archive-name: kraut
  17.  
  18. [I'm tempted to put a disclaimer here myself, considering the (minor) uproar
  19. that happened over jive and valspeak.  (I'm part German myself, and unoffended
  20. by this, and hard put to understand why anyone would be... oh, well.)
  21.  
  22. More serious note:  I see a comment ended with "*\" -- yes, that's a BACKSLASH.
  23. If you get strange errors, check for that.  (The compiler speaks with an accent
  24. as well???  ;-)  ++bsa]
  25.  
  26.                                  Kraut v0.9
  27. ==============================================================================
  28. English:
  29. Kraut is a lexical converter like Jive and Valspeak, which everyone is most
  30. likely familiar with. It takes normal (English) text and converts it into
  31. text with a German accent. For example, this was normal text that was run
  32. through Kraut (see below for the kraut version). 
  33.  
  34. Disclaimer: Kraut is intended as humor only. It is not meant to be derogatory
  35. to anybody, race, creed, or nationality. Please accept it in the vein that
  36. I wrote it, as humor. [I am half German myself, was born in Augsburg, and
  37. lived there off and on for about 8 years. I have the utmost respect for the
  38. German people and their culture.]
  39.  
  40. John Sparks
  41. uunet!ukma!corpane!sparks
  42.  
  43. -----------------
  44.  
  45. Kraut:
  46. Kraut ist a lexical konferter like Jife undt Falspeak, vhich eferyone ist most
  47. likely familiar vid. It takes normal (Englisch) text undt conferts it into
  48. text mitt a German accent. For example, dis vas normal text dat vas r-r-run
  49. drough Kraut. 
  50.  
  51. Disclaimer: Kraut ist intended as humor only. It ist not meant to be derogatory
  52. to anybody, r-r-race, kreed, or nationality. Please accept it in ze fein dat
  53. I wrote it, as humor. [I am half German meinself, vas born in Augsburg, and
  54. lifed dere off undt on for about 8 years. I hafe ze utmost r-r-respect for de
  55. German people undt deir kulture.]
  56.  
  57. Johann Sparks
  58.  
  59. ----
  60. This is a shell archive. cut everything off above (and including) 
  61. the ---cut me--- line below. rename the portion remaining to kraut.shar and
  62. do the following command (unix) to restore the files:
  63.  
  64.      $ sh kraut.shar
  65.  
  66. ------------------8<-------cut me-----------------------8<----------------
  67. echo x - destructions
  68. sed 's/^X//' >destructions <<'*-*-END-of-destructions-*-*'
  69. X                                     Kraut
  70. X                               +++++++++++++++++
  71. XCompiling Kraut:
  72. X
  73. XYou should have the files: kraut.c and kraut.l and lex.yy.c
  74. X
  75. X
  76. Xkraut.l must be run thru the unix 'lex' utility to produce the file lex.yy.c
  77. XThen compile kraut.c and lex.yy.c to produce kraut
  78. X
  79. X     $lex kraut.l
  80. X     $cc kraut.c lex.yy.c -o kraut
  81. X  (You may get a list of warnings from the compiler. Ignore them.)
  82. X
  83. XNote: lex.yy.c is included in this package. You only need to use lex if you
  84. Xwish to make changes to kraut. 
  85. X
  86. XUsing Kraut:
  87. X
  88. X Kraut uses standard input and output.
  89. X
  90. Xexamples:
  91. X
  92. XTo translate a file called 'note' and output kraut to a file called 'knote':
  93. X
  94. X     $ cat note | kraut > knote
  95. X
  96. XTo translate a file called 'note' and just print it to the screen:
  97. X
  98. X     $ cat note | kraut
  99. X
  100. XTo have kraut wait to translate what you type at the keyboard and return it in
  101. Xkraut on your screen:
  102. X
  103. X     $ kraut
  104. X
  105. *-*-END-of-destructions-*-*
  106. echo x - kraut.c
  107. sed 's/^X//' >kraut.c <<'*-*-END-of-kraut.c-*-*'
  108. X#include <stdio.h>
  109. X/* Kraut v0.9  */
  110. X/*     by      */
  111. X/* John Sparks */
  112. X/*  5-5-1989   */
  113. X
  114. X/* This is in the public domain. Do with it as you will. *\
  115. X
  116. Xmain()
  117. X{
  118. Xchar *line; 
  119. X
  120. X    while(line = (char *) yylex()){
  121. X         printf("%s", line);
  122. X    }
  123. X}
  124. X
  125. Xyywrap ()
  126. X{
  127. X    return (1);
  128. X}
  129. *-*-END-of-kraut.c-*-*
  130. echo x - kraut.l
  131. sed 's/^X//' >kraut.l <<'*-*-END-of-kraut.l-*-*'
  132. X%e 2000
  133. X%p 5000
  134. X%n 1000
  135. X%k 500
  136. X%a 4000
  137. X%o 2000
  138. XBW [      ]
  139. XEW [      .,;!?]
  140. X
  141. X%{
  142. X     char buf[128];
  143. X
  144. X%}
  145. X
  146. X%%
  147. Xing                  return("ingkt");
  148. X" the "             return(" ze ");
  149. X"The "              return("Ze ");
  150. X" with "            return(" mitt ");
  151. X"With "             return("Mitt ");
  152. Xwr                  return("w-r-r");
  153. XWr                  return("W-r-r");
  154. XR                   return("R-r-r");
  155. X"Yes "              return("Jawohl ");
  156. X" r"                return(" r-r-r");
  157. X"Yes."              return("Jawohl.");
  158. X"Yes!"              return("Jawohl!");
  159. X"YES!"              return("JAWOHL!");
  160. X" yes "             return(" ja ");
  161. X" yes."             return(" ja.");
  162. X" yes!"             return(" yes!");
  163. X"No "               return("Nein ");
  164. X"No!"               return("Nein!");
  165. X"No?"               return("Nein?");
  166. X" no "              return(" nein ");
  167. X" no."              return(" nein.");
  168. X" no!"              return(" nein!");
  169. X" no?"              return(" nein?");
  170. X[Mm]"r."            return("Herr");
  171. X[Mm]"rs."           return("Frau");
  172. XMiss                return("Fraulein");
  173. X" of "              return(" uff ");
  174. X"Of "               return("Uff ");
  175. Xmy                  return("mein");
  176. XMy                  return("Mein");
  177. X" and "             return(" undt ");
  178. X"And "              return("Undt ");
  179. X"One "              return("Ein ");
  180. X" one"              return(" ein");
  181. X"Is "               return("Ist ");
  182. X" is "              return(" ist ");
  183. X"ow "               return("ow ");
  184. X"w "                return("w ");
  185. Xsh                  return("sch");
  186. XSh                  return("Sch");
  187. Xch                  return("ch");
  188. XCh                  return("Ch");
  189. X" c"                return(" k");
  190. X" C"                return(" K");
  191. X
  192. Xv                   return("f");
  193. XV                   return("F");
  194. X" w"                return(" v");
  195. XW                   return("V");
  196. Xth                  return("d");
  197. XTh                  return("D");
  198. X[Jj]ohn             return("Johann");
  199. X[Ww]illiam          return("Wilhelm");
  200. X[Bb]rad             return("Wilhelm");
  201. X[Gg]ary             return("Gerhardt");
  202. X[Jj]on              return("Hansel");
  203. X
  204. X[a-f]"!"       {sprintf(buf,"%s Naturlich!",yytext);return(buf);}
  205. X[p-z]"!"       {sprintf(buf,"%s Seig Heil!",yytext);return(buf);}
  206. X.              return(yytext);
  207. X\n             return("\n");
  208. X
  209. X%%
  210. X
  211. X
  212. *-*-END-of-kraut.l-*-*
  213. echo x - lex.yy.c
  214. sed 's/^X//' >lex.yy.c <<'*-*-END-of-lex.yy.c-*-*'
  215. X# include "stdio.h"
  216. X# define U(x) x
  217. X# define NLSTATE yyprevious=YYNEWLINE
  218. X# define BEGIN yybgin = yysvec + 1 +
  219. X# define INITIAL 0
  220. X# define YYLERR yysvec
  221. X# define YYSTATE (yyestate-yysvec-1)
  222. X# define YYOPTIM 1
  223. X# define YYLMAX 200
  224. X# define output(c) putc(c,yyout)
  225. X# define input() (((yytchar=yysptr>yysbuf?U(*--yysptr):getc(yyin))==10?(yylineno++,yytchar):yytchar)==EOF?0:yytchar)
  226. X# define unput(c) {yytchar= (c);if(yytchar=='\n')yylineno--;*yysptr++=yytchar;}
  227. X# define yymore() (yymorfg=1)
  228. X# define ECHO fprintf(yyout, "%s",yytext)
  229. X# define REJECT { nstr = yyreject(); goto yyfussy;}
  230. Xint yyleng; extern char yytext[];
  231. Xint yymorfg;
  232. Xextern char *yysptr, yysbuf[];
  233. Xint yytchar;
  234. XFILE *yyin = {stdin}, *yyout = {stdout};
  235. Xextern int yylineno;
  236. Xstruct yysvf { 
  237. X    struct yywork *yystoff;
  238. X    struct yysvf *yyother;
  239. X    int *yystops;};
  240. Xstruct yysvf *yyestate;
  241. Xextern struct yysvf yysvec[], *yybgin;
  242. X     char buf[128];
  243. X
  244. X# define YYNEWLINE 10
  245. Xyylex(){
  246. Xint nstr; extern int yyprevious;
  247. Xwhile((nstr = yylook()) >= 0)
  248. Xyyfussy: switch(nstr){
  249. Xcase 0:
  250. Xif(yywrap()) return(0); break;
  251. Xcase 1:
  252. X                 return("ingkt");
  253. Xbreak;
  254. Xcase 2:
  255. X            return(" ze ");
  256. Xbreak;
  257. Xcase 3:
  258. X             return("Ze ");
  259. Xbreak;
  260. Xcase 4:
  261. X           return(" mitt ");
  262. Xbreak;
  263. Xcase 5:
  264. X            return("Mitt ");
  265. Xbreak;
  266. Xcase 6:
  267. X                 return("w-r-r");
  268. Xbreak;
  269. Xcase 7:
  270. X                 return("W-r-r");
  271. Xbreak;
  272. Xcase 8:
  273. X                  return("R-r-r");
  274. Xbreak;
  275. Xcase 9:
  276. X             return("Jawohl ");
  277. Xbreak;
  278. Xcase 10:
  279. X               return(" r-r-r");
  280. Xbreak;
  281. Xcase 11:
  282. X             return("Jawohl.");
  283. Xbreak;
  284. Xcase 12:
  285. X             return("Jawohl!");
  286. Xbreak;
  287. Xcase 13:
  288. X             return("JAWOHL!");
  289. Xbreak;
  290. Xcase 14:
  291. X            return(" ja ");
  292. Xbreak;
  293. Xcase 15:
  294. X            return(" ja.");
  295. Xbreak;
  296. Xcase 16:
  297. X            return(" yes!");
  298. Xbreak;
  299. Xcase 17:
  300. X              return("Nein ");
  301. Xbreak;
  302. Xcase 18:
  303. X              return("Nein!");
  304. Xbreak;
  305. Xcase 19:
  306. X              return("Nein?");
  307. Xbreak;
  308. Xcase 20:
  309. X             return(" nein ");
  310. Xbreak;
  311. Xcase 21:
  312. X             return(" nein.");
  313. Xbreak;
  314. Xcase 22:
  315. X             return(" nein!");
  316. Xbreak;
  317. Xcase 23:
  318. X             return(" nein?");
  319. Xbreak;
  320. Xcase 24:
  321. X           return("Herr");
  322. Xbreak;
  323. Xcase 25:
  324. X          return("Frau");
  325. Xbreak;
  326. Xcase 26:
  327. X               return("Fraulein");
  328. Xbreak;
  329. Xcase 27:
  330. X             return(" uff ");
  331. Xbreak;
  332. Xcase 28:
  333. X              return("Uff ");
  334. Xbreak;
  335. Xcase 29:
  336. X                 return("mein");
  337. Xbreak;
  338. Xcase 30:
  339. X                 return("Mein");
  340. Xbreak;
  341. Xcase 31:
  342. X            return(" undt ");
  343. Xbreak;
  344. Xcase 32:
  345. X             return("Undt ");
  346. Xbreak;
  347. Xcase 33:
  348. X             return("Ein ");
  349. Xbreak;
  350. Xcase 34:
  351. X             return(" ein");
  352. Xbreak;
  353. Xcase 35:
  354. X              return("Ist ");
  355. Xbreak;
  356. Xcase 36:
  357. X             return(" ist ");
  358. Xbreak;
  359. Xcase 37:
  360. X              return("ow ");
  361. Xbreak;
  362. Xcase 38:
  363. X               return("w ");
  364. Xbreak;
  365. Xcase 39:
  366. X                 return("sch");
  367. Xbreak;
  368. Xcase 40:
  369. X                 return("Sch");
  370. Xbreak;
  371. Xcase 41:
  372. X                 return("ch");
  373. Xbreak;
  374. Xcase 42:
  375. X                 return("Ch");
  376. Xbreak;
  377. Xcase 43:
  378. X               return(" k");
  379. Xbreak;
  380. Xcase 44:
  381. X               return(" K");
  382. Xbreak;
  383. Xcase 45:
  384. X                  return("f");
  385. Xbreak;
  386. Xcase 46:
  387. X                  return("F");
  388. Xbreak;
  389. Xcase 47:
  390. X               return(" v");
  391. Xbreak;
  392. Xcase 48:
  393. X                  return("V");
  394. Xbreak;
  395. Xcase 49:
  396. X                 return("d");
  397. Xbreak;
  398. Xcase 50:
  399. X                 return("D");
  400. Xbreak;
  401. Xcase 51:
  402. X            return("Johann");
  403. Xbreak;
  404. Xcase 52:
  405. X         return("Wilhelm");
  406. Xbreak;
  407. Xcase 53:
  408. X            return("Wilhelm");
  409. Xbreak;
  410. Xcase 54:
  411. X            return("Gerhardt");
  412. Xbreak;
  413. Xcase 55:
  414. X             return("Hansel");
  415. Xbreak;
  416. Xcase 56:
  417. X      {sprintf(buf,"%s Naturlich!",yytext);return(buf);}
  418. Xbreak;
  419. Xcase 57:
  420. X      {sprintf(buf,"%s Seig Heil!",yytext);return(buf);}
  421. Xbreak;
  422. Xcase 58:
  423. X             return(yytext);
  424. Xbreak;
  425. Xcase 59:
  426. X            return("\n");
  427. Xbreak;
  428. Xcase -1:
  429. Xbreak;
  430. Xdefault:
  431. Xfprintf(yyout,"bad switch yylook %d",nstr);
  432. X} return(0); }
  433. X/* end of yylex */
  434. X
  435. X
  436. Xint yyvstop[] = {
  437. X0,
  438. X
  439. X58,
  440. X0,
  441. X
  442. X59,
  443. X0,
  444. X
  445. X58,
  446. X0,
  447. X
  448. X58,
  449. X0,
  450. X
  451. X58,
  452. X0,
  453. X
  454. X58,
  455. X0,
  456. X
  457. X58,
  458. X0,
  459. X
  460. X58,
  461. X0,
  462. X
  463. X58,
  464. X0,
  465. X
  466. X58,
  467. X0,
  468. X
  469. X58,
  470. X0,
  471. X
  472. X58,
  473. X0,
  474. X
  475. X8,
  476. X58,
  477. X0,
  478. X
  479. X58,
  480. X0,
  481. X
  482. X58,
  483. X0,
  484. X
  485. X46,
  486. X58,
  487. X0,
  488. X
  489. X48,
  490. X58,
  491. X0,
  492. X
  493. X58,
  494. X0,
  495. X
  496. X58,
  497. X0,
  498. X
  499. X58,
  500. X0,
  501. X
  502. X58,
  503. X0,
  504. X
  505. X58,
  506. X0,
  507. X
  508. X58,
  509. X0,
  510. X
  511. X58,
  512. X0,
  513. X
  514. X58,
  515. X0,
  516. X
  517. X58,
  518. X0,
  519. X
  520. X58,
  521. X0,
  522. X
  523. X45,
  524. X58,
  525. X0,
  526. X
  527. X58,
  528. X0,
  529. X
  530. X44,
  531. X0,
  532. X
  533. X43,
  534. X0,
  535. X
  536. X10,
  537. X0,
  538. X
  539. X47,
  540. X0,
  541. X
  542. X42,
  543. X0,
  544. X
  545. X30,
  546. X0,
  547. X
  548. X40,
  549. X0,
  550. X
  551. X50,
  552. X0,
  553. X
  554. X7,
  555. X0,
  556. X
  557. X56,
  558. X0,
  559. X
  560. X41,
  561. X0,
  562. X
  563. X29,
  564. X0,
  565. X
  566. X57,
  567. X0,
  568. X
  569. X39,
  570. X0,
  571. X
  572. X49,
  573. X0,
  574. X
  575. X38,
  576. X0,
  577. X
  578. X6,
  579. X0,
  580. X
  581. X35,
  582. X0,
  583. X
  584. X55,
  585. X0,
  586. X
  587. X24,
  588. X0,
  589. X
  590. X17,
  591. X0,
  592. X
  593. X18,
  594. X0,
  595. X
  596. X19,
  597. X0,
  598. X
  599. X28,
  600. X0,
  601. X
  602. X1,
  603. X0,
  604. X
  605. X37,
  606. X0,
  607. X
  608. X36,
  609. X0,
  610. X
  611. X20,
  612. X0,
  613. X
  614. X22,
  615. X0,
  616. X
  617. X21,
  618. X0,
  619. X
  620. X23,
  621. X0,
  622. X
  623. X27,
  624. X0,
  625. X
  626. X34,
  627. X0,
  628. X
  629. X32,
  630. X0,
  631. X
  632. X53,
  633. X0,
  634. X
  635. X54,
  636. X0,
  637. X
  638. X51,
  639. X0,
  640. X
  641. X26,
  642. X0,
  643. X
  644. X25,
  645. X0,
  646. X
  647. X33,
  648. X0,
  649. X
  650. X3,
  651. X0,
  652. X
  653. X13,
  654. X0,
  655. X
  656. X9,
  657. X0,
  658. X
  659. X12,
  660. X0,
  661. X
  662. X11,
  663. X0,
  664. X
  665. X31,
  666. X0,
  667. X
  668. X2,
  669. X0,
  670. X
  671. X14,
  672. X0,
  673. X
  674. X16,
  675. X0,
  676. X
  677. X15,
  678. X0,
  679. X
  680. X5,
  681. X0,
  682. X
  683. X4,
  684. X0,
  685. X
  686. X52,
  687. X0,
  688. X0};
  689. X# define YYTYPE int
  690. Xstruct yywork { YYTYPE verify, advance; } yycrank[] = {
  691. X0,0,     0,0, 1,3, 0,0, 
  692. X0,0,     0,0, 0,0, 0,0, 
  693. X0,0,     0,0, 0,0, 1,4, 
  694. X0,0,     0,0, 0,0, 0,0, 
  695. X0,0,     0,0, 0,0, 0,0, 
  696. X0,0,     0,0, 0,0, 0,0, 
  697. X0,0,     0,0, 0,0, 0,0, 
  698. X0,0,     0,0, 0,0, 0,0, 
  699. X0,0,     1,5, 0,0, 21,60,    
  700. X0,0,     0,0, 23,60,    27,65,    
  701. X0,0,     0,0, 0,0, 0,0, 
  702. X0,0,     22,60,    0,0, 0,0, 
  703. X0,0,     0,0, 0,0, 0,0, 
  704. X0,0,     0,0, 0,0, 0,0, 
  705. X0,0,     0,0, 0,0, 0,0, 
  706. X0,0,     0,0, 28,65,    0,0, 
  707. X0,0,     0,0, 1,6, 1,7, 
  708. X1,8,     46,82,    0,0, 20,58,    
  709. X1,9,     0,0, 1,10,     1,11,     
  710. X31,68,   31,65,    1,12,     1,13,     
  711. X1,14,    52,91,    0,0, 1,15,     
  712. X1,16,    1,17,     0,0, 1,18,     
  713. X1,19,    2,5, 1,20,     0,0, 
  714. X0,0,     0,0, 64,99,    0,0, 
  715. X72,101,  0,0, 1,21,     1,22,     
  716. X1,23,    9,45,     74,106,   20,59,    
  717. X79,111,  8,44,     1,24,     16,54,    
  718. X17,55,   23,61,    1,25,     6,42,     
  719. X1,26,    1,27,     11,47,    7,43,     
  720. X1,28,    1,29,     10,46,    1,30,     
  721. X1,31,    13,51,    2,6, 14,52,    
  722. X2,8,     19,56,    22,43,    5,32,     
  723. X12,48,   24,62,    2,10,     14,53,    
  724. X26,64,   28,66,    19,57,    2,13,     
  725. X2,14,    12,49,    25,49,    2,15,     
  726. X2,16,    2,17,     29,67,    2,18,     
  727. X12,50,   25,63,    2,20,     33,71,    
  728. X35,72,   31,69,    36,73,    39,76,    
  729. X37,74,   40,77,    41,78,    42,79,    
  730. X2,23,    5,33,     31,70,    5,34,     
  731. X37,75,   43,80,    2,24,     45,81,    
  732. X48,85,   5,35,     2,25,     49,86,    
  733. X2,26,    53,92,    5,36,     5,37,     
  734. X2,28,    2,29,     5,38,     2,30,     
  735. X5,39,    47,83,    55,93,    5,40,     
  736. X56,94,   5,41,     58,96,    47,84,    
  737. X51,88,   51,89,    59,97,    62,98,    
  738. X56,95,   69,94,    71,100,   73,102,   
  739. X73,103,  75,107,   76,108,   77,109,   
  740. X78,110,  80,112,   81,113,   83,114,   
  741. X85,115,  87,116,   92,117,   93,118,   
  742. X94,119,  73,104,   95,120,   96,121,   
  743. X100,125, 97,122,   97,123,   108,126,  
  744. X109,127, 110,128,  110,129,  51,90,    
  745. X119,131, 120,132,  127,133,  131,134,  
  746. X134,135, 0,0, 73,105,   97,124,   
  747. X0,0,     0,0, 0,0, 110,130,  
  748. X0,0,     0,0, 0,0, 0,0, 
  749. X0,0,     0,0, 0,0, 0,0, 
  750. X49,87,   0,0, 0,0, 0,0, 
  751. X0,0};
  752. Xstruct yysvf yysvec[] = {
  753. X0,  0,   0,
  754. Xyycrank+-1,   0,        0,   
  755. Xyycrank+-57,  yysvec+1, 0,   
  756. Xyycrank+0,    0,        yyvstop+1,
  757. Xyycrank+0,    0,        yyvstop+3,
  758. Xyycrank+60,   0,        yyvstop+5,
  759. Xyycrank+1,    0,        yyvstop+7,
  760. Xyycrank+1,    0,        yyvstop+9,
  761. Xyycrank+1,    0,        yyvstop+11,
  762. Xyycrank+4,    0,        yyvstop+13,
  763. Xyycrank+3,    0,        yyvstop+15,
  764. Xyycrank+3,    0,        yyvstop+17,
  765. Xyycrank+23,   0,        yyvstop+19,
  766. Xyycrank+10,   0,        yyvstop+21,
  767. Xyycrank+21,   0,        yyvstop+23,
  768. Xyycrank+0,    0,        yyvstop+25,
  769. Xyycrank+3,    0,        yyvstop+28,
  770. Xyycrank+4,    0,        yyvstop+30,
  771. Xyycrank+0,    0,        yyvstop+32,
  772. Xyycrank+20,   0,        yyvstop+35,
  773. Xyycrank+2,    0,        yyvstop+38,
  774. Xyycrank+2,    0,        yyvstop+40,
  775. Xyycrank+12,   0,        yyvstop+42,
  776. Xyycrank+5,    0,        yyvstop+44,
  777. Xyycrank+19,   0,        yyvstop+46,
  778. Xyycrank+24,   0,        yyvstop+48,
  779. Xyycrank+13,   0,        yyvstop+50,
  780. Xyycrank+6,    0,        yyvstop+52,
  781. Xyycrank+29,   0,        yyvstop+54,
  782. Xyycrank+38,   yysvec+28,     yyvstop+56,
  783. Xyycrank+0,    yysvec+27,     yyvstop+58,
  784. Xyycrank+44,   0,        yyvstop+61,
  785. Xyycrank+0,    0,        yyvstop+63,
  786. Xyycrank+37,   0,        0,   
  787. Xyycrank+0,    0,        yyvstop+65,
  788. Xyycrank+33,   0,        0,   
  789. Xyycrank+39,   0,        0,   
  790. Xyycrank+50,   0,        0,   
  791. Xyycrank+0,    0,        yyvstop+67,
  792. Xyycrank+47,   0,        0,   
  793. Xyycrank+48,   0,        yyvstop+69,
  794. Xyycrank+53,   0,        0,   
  795. Xyycrank+55,   0,        0,   
  796. Xyycrank+64,   0,        0,   
  797. Xyycrank+0,    0,        yyvstop+71,
  798. Xyycrank+49,   0,        0,   
  799. Xyycrank+37,   0,        0,   
  800. Xyycrank+73,   0,        0,   
  801. Xyycrank+49,   0,        0,   
  802. Xyycrank+121,  0,        0,   
  803. Xyycrank+0,    0,        yyvstop+73,
  804. Xyycrank+152,  0,        0,   
  805. Xyycrank+49,   0,        0,   
  806. Xyycrank+68,   0,        0,   
  807. Xyycrank+0,    0,        yyvstop+75,
  808. Xyycrank+77,   0,        yyvstop+77,
  809. Xyycrank+72,   0,        0,   
  810. Xyycrank+0,    0,        yyvstop+79,
  811. Xyycrank+99,   0,        0,   
  812. Xyycrank+71,   0,        0,   
  813. Xyycrank+0,    0,        yyvstop+81,
  814. Xyycrank+0,    0,        yyvstop+83,
  815. Xyycrank+84,   0,        0,   
  816. Xyycrank+0,    0,        yyvstop+85,
  817. Xyycrank+62,   0,        0,   
  818. Xyycrank+0,    0,        yyvstop+87,
  819. Xyycrank+0,    0,        yyvstop+89,
  820. Xyycrank+0,    0,        yyvstop+91,
  821. Xyycrank+0,    0,        yyvstop+93,
  822. Xyycrank+81,   0,        0,   
  823. Xyycrank+0,    0,        yyvstop+95,
  824. Xyycrank+90,   0,        0,   
  825. Xyycrank+64,   0,        0,   
  826. Xyycrank+159,  0,        0,   
  827. Xyycrank+70,   0,        0,   
  828. Xyycrank+92,   0,        0,   
  829. Xyycrank+93,   0,        0,   
  830. Xyycrank+79,   0,        0,   
  831. Xyycrank+81,   0,        0,   
  832. Xyycrank+72,   0,        0,   
  833. Xyycrank+97,   0,        0,   
  834. Xyycrank+77,   0,        0,   
  835. Xyycrank+0,    0,        yyvstop+97,
  836. Xyycrank+89,   0,        0,   
  837. Xyycrank+0,    0,        yyvstop+99,
  838. Xyycrank+85,   0,        0,   
  839. Xyycrank+0,    0,        yyvstop+101,
  840. Xyycrank+155,  0,        0,   
  841. Xyycrank+0,    0,        yyvstop+103,
  842. Xyycrank+0,    0,        yyvstop+105,
  843. Xyycrank+0,    0,        yyvstop+107,
  844. Xyycrank+0,    0,        yyvstop+109,
  845. Xyycrank+170,  0,        0,   
  846. Xyycrank+171,  0,        0,   
  847. Xyycrank+96,   0,        0,   
  848. Xyycrank+102,  0,        0,   
  849. Xyycrank+174,  0,        0,   
  850. Xyycrank+177,  0,        0,   
  851. Xyycrank+0,    0,        yyvstop+111,
  852. Xyycrank+0,    0,        yyvstop+113,
  853. Xyycrank+176,  0,        0,   
  854. Xyycrank+0,    0,        yyvstop+115,
  855. Xyycrank+0,    0,        yyvstop+117,
  856. Xyycrank+0,    0,        yyvstop+119,
  857. Xyycrank+0,    0,        yyvstop+121,
  858. Xyycrank+0,    0,        yyvstop+123,
  859. Xyycrank+0,    0,        yyvstop+125,
  860. Xyycrank+0,    0,        yyvstop+127,
  861. Xyycrank+179,  0,        0,   
  862. Xyycrank+108,  0,        0,   
  863. Xyycrank+181,  0,        0,   
  864. Xyycrank+0,    0,        yyvstop+129,
  865. Xyycrank+0,    0,        yyvstop+131,
  866. Xyycrank+0,    0,        yyvstop+133,
  867. Xyycrank+0,    0,        yyvstop+135,
  868. Xyycrank+0,    0,        yyvstop+137,
  869. Xyycrank+0,    0,        yyvstop+139,
  870. Xyycrank+0,    0,        yyvstop+141,
  871. Xyycrank+0,    0,        yyvstop+143,
  872. Xyycrank+111,  0,        0,   
  873. Xyycrank+185,  0,        0,   
  874. Xyycrank+0,    0,        yyvstop+145,
  875. Xyycrank+0,    0,        yyvstop+147,
  876. Xyycrank+0,    0,        yyvstop+149,
  877. Xyycrank+0,    0,        yyvstop+151,
  878. Xyycrank+0,    0,        yyvstop+153,
  879. Xyycrank+0,    0,        yyvstop+155,
  880. Xyycrank+186,  0,        0,   
  881. Xyycrank+0,    0,        yyvstop+157,
  882. Xyycrank+0,    0,        yyvstop+159,
  883. Xyycrank+0,    0,        yyvstop+161,
  884. Xyycrank+122,  0,        0,   
  885. Xyycrank+0,    0,        yyvstop+163,
  886. Xyycrank+0,    0,        yyvstop+165,
  887. Xyycrank+111,  0,        0,   
  888. Xyycrank+0,    0,        yyvstop+167,
  889. X0,  0,   0};
  890. Xstruct yywork *yytop = yycrank+236;
  891. Xstruct yysvf *yybgin = yysvec+1;
  892. Xchar yymatch[] = {
  893. X00  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  894. X01  ,01  ,012 ,01  ,01  ,01  ,01  ,01  ,
  895. X01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  896. X01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  897. X01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  898. X01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  899. X01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  900. X01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  901. X01  ,01  ,'B' ,01  ,01  ,01  ,01  ,'G' ,
  902. X01  ,01  ,'J' ,01  ,01  ,'M' ,01  ,01  ,
  903. X01  ,01  ,01  ,01  ,01  ,01  ,01  ,'W' ,
  904. X01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  905. X01  ,'a' ,'b' ,'a' ,'a' ,'a' ,'a' ,'G' ,
  906. X01  ,01  ,'J' ,01  ,01  ,'M' ,01  ,01  ,
  907. X'p' ,'p' ,'p' ,'p' ,'p' ,'p' ,'p' ,'w' ,
  908. X'p' ,'p' ,'p' ,01  ,01  ,01  ,01  ,01  ,
  909. X0};
  910. Xchar yyextra[] = {
  911. X0,0,0,0,0,0,0,0,
  912. X0,0,0,0,0,0,0,0,
  913. X0,0,0,0,0,0,0,0,
  914. X0,0,0,0,0,0,0,0,
  915. X0,0,0,0,0,0,0,0,
  916. X0,0,0,0,0,0,0,0,
  917. X0,0,0,0,0,0,0,0,
  918. X0,0,0,0,0,0,0,0,
  919. X0};
  920. X#ident   "@(#)libl:lib/ncform     1.3"
  921. Xint yylineno =1;
  922. X# define YYU(x) x
  923. X# define NLSTATE yyprevious=YYNEWLINE
  924. Xchar yytext[YYLMAX];
  925. Xstruct yysvf *yylstate [YYLMAX], **yylsp, **yyolsp;
  926. Xchar yysbuf[YYLMAX];
  927. Xchar *yysptr = yysbuf;
  928. Xint *yyfnd;
  929. Xextern struct yysvf *yyestate;
  930. Xint yyprevious = YYNEWLINE;
  931. Xyylook(){
  932. X    register struct yysvf *yystate, **lsp;
  933. X    register struct yywork *yyt;
  934. X    struct yysvf *yyz;
  935. X    int yych, yyfirst;
  936. X    struct yywork *yyr;
  937. X# ifdef LEXDEBUG
  938. X    int debug;
  939. X# endif
  940. X    char *yylastch;
  941. X    /* start off machines */
  942. X# ifdef LEXDEBUG
  943. X    debug = 0;
  944. X# endif
  945. X    yyfirst=1;
  946. X    if (!yymorfg)
  947. X         yylastch = yytext;
  948. X    else {
  949. X         yymorfg=0;
  950. X         yylastch = yytext+yyleng;
  951. X         }
  952. X    for(;;){
  953. X         lsp = yylstate;
  954. X         yyestate = yystate = yybgin;
  955. X         if (yyprevious==YYNEWLINE) yystate++;
  956. X         for (;;){
  957. X# ifdef LEXDEBUG
  958. X              if(debug)fprintf(yyout,"state %d\n",yystate-yysvec-1);
  959. X# endif
  960. X              yyt = yystate->yystoff;
  961. X              if(yyt == yycrank && !yyfirst){  /* may not be any transitions */
  962. X                   yyz = yystate->yyother;
  963. X                   if(yyz == 0)break;
  964. X                   if(yyz->yystoff == yycrank)break;
  965. X                   }
  966. X              *yylastch++ = yych = input();
  967. X              yyfirst=0;
  968. X         tryagain:
  969. X# ifdef LEXDEBUG
  970. X              if(debug){
  971. X                   fprintf(yyout,"char ");
  972. X                   allprint(yych);
  973. X                   putchar('\n');
  974. X                   }
  975. X# endif
  976. X              yyr = yyt;
  977. X              if ( (int)yyt > (int)yycrank){
  978. X                   yyt = yyr + yych;
  979. X                   if (yyt <= yytop && yyt->verify+yysvec == yystate){
  980. X                        if(yyt->advance+yysvec == YYLERR)  /* error transitions */
  981. X                             {unput(*--yylastch);break;}
  982. X                        *lsp++ = yystate = yyt->advance+yysvec;
  983. X                        goto contin;
  984. X                        }
  985. X                   }
  986. X# ifdef YYOPTIM
  987. X              else if((int)yyt < (int)yycrank) {      /* r < yycrank */
  988. X                   yyt = yyr = yycrank+(yycrank-yyt);
  989. X# ifdef LEXDEBUG
  990. X                   if(debug)fprintf(yyout,"compressed state\n");
  991. X# endif
  992. X                   yyt = yyt + yych;
  993. X                   if(yyt <= yytop && yyt->verify+yysvec == yystate){
  994. X                        if(yyt->advance+yysvec == YYLERR)  /* error transitions */
  995. X                             {unput(*--yylastch);break;}
  996. X                        *lsp++ = yystate = yyt->advance+yysvec;
  997. X                        goto contin;
  998. X                        }
  999. X                   yyt = yyr + YYU(yymatch[yych]);
  1000. X# ifdef LEXDEBUG
  1001. X                   if(debug){
  1002. X                        fprintf(yyout,"try fall back character ");
  1003. X                        allprint(YYU(yymatch[yych]));
  1004. X                        putchar('\n');
  1005. X                        }
  1006. X# endif
  1007. X                   if(yyt <= yytop && yyt->verify+yysvec == yystate){
  1008. X                        if(yyt->advance+yysvec == YYLERR)  /* error transition */
  1009. X                             {unput(*--yylastch);break;}
  1010. X                        *lsp++ = yystate = yyt->advance+yysvec;
  1011. X                        goto contin;
  1012. X                        }
  1013. X                   }
  1014. X              if ((yystate = yystate->yyother) && (yyt= yystate->yystoff) != yycrank){
  1015. X# ifdef LEXDEBUG
  1016. X                   if(debug)fprintf(yyout,"fall back to state %d\n",yystate-yysvec-1);
  1017. X# endif
  1018. X                   goto tryagain;
  1019. X                   }
  1020. X# endif
  1021. X              else
  1022. X                   {unput(*--yylastch);break;}
  1023. X         contin:
  1024. X# ifdef LEXDEBUG
  1025. X              if(debug){
  1026. X                   fprintf(yyout,"state %d char ",yystate-yysvec-1);
  1027. X                   allprint(yych);
  1028. X                   putchar('\n');
  1029. X                   }
  1030. X# endif
  1031. X              ;
  1032. X              }
  1033. X# ifdef LEXDEBUG
  1034. X         if(debug){
  1035. X              fprintf(yyout,"stopped at %d with ",*(lsp-1)-yysvec-1);
  1036. X              allprint(yych);
  1037. X              putchar('\n');
  1038. X              }
  1039. X# endif
  1040. X         while (lsp-- > yylstate){
  1041. X              *yylastch-- = 0;
  1042. X              if (*lsp != 0 && (yyfnd= (*lsp)->yystops) && *yyfnd > 0){
  1043. X                   yyolsp = lsp;
  1044. X                   if(yyextra[*yyfnd]){          /* must backup */
  1045. X                        while(yyback((*lsp)->yystops,-*yyfnd) != 1 && lsp > yylstate){
  1046. X                             lsp--;
  1047. X                             unput(*yylastch--);
  1048. X                             }
  1049. X                        }
  1050. X                   yyprevious = YYU(*yylastch);
  1051. X                   yylsp = lsp;
  1052. X                   yyleng = yylastch-yytext+1;
  1053. X                   yytext[yyleng] = 0;
  1054. X# ifdef LEXDEBUG
  1055. X                   if(debug){
  1056. X                        fprintf(yyout,"\nmatch ");
  1057. X                        sprint(yytext);
  1058. X                        fprintf(yyout," action %d\n",*yyfnd);
  1059. X                        }
  1060. X# endif
  1061. X                   return(*yyfnd++);
  1062. X                   }
  1063. X              unput(*yylastch);
  1064. X              }
  1065. X         if (yytext[0] == 0  /* && feof(yyin) */)
  1066. X              {
  1067. X              yysptr=yysbuf;
  1068. X              return(0);
  1069. X              }
  1070. X         yyprevious = yytext[0] = input();
  1071. X         if (yyprevious>0)
  1072. X              output(yyprevious);
  1073. X         yylastch=yytext;
  1074. X# ifdef LEXDEBUG
  1075. X         if(debug)putchar('\n');
  1076. X# endif
  1077. X         }
  1078. X    }
  1079. Xyyback(p, m)
  1080. X    int *p;
  1081. X{
  1082. Xif (p==0) return(0);
  1083. Xwhile (*p)
  1084. X    {
  1085. X    if (*p++ == m)
  1086. X         return(1);
  1087. X    }
  1088. Xreturn(0);
  1089. X}
  1090. X    /* the following are only used in the lex library */
  1091. Xyyinput(){
  1092. X    return(input());
  1093. X    }
  1094. Xyyoutput(c)
  1095. X  int c; {
  1096. X    output(c);
  1097. X    }
  1098. Xyyunput(c)
  1099. X   int c; {
  1100. X    unput(c);
  1101. X    }
  1102. *-*-END-of-lex.yy.c-*-*
  1103. exit
  1104.  
  1105.  
  1106.