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