home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1994 March / Source_Code_CD-ROM_Walnut_Creek_March_1994.iso / compsrcs / x / volume18 / bibview / part04 < prev    next >
Encoding:
Text File  |  1992-08-26  |  50.2 KB  |  1,895 lines
  1. Path: uunet!dtix!darwin.sura.net!mips!msi!dcmartin
  2. From: liebla@informatik.tu-muenchen.de (Armin Liebl)
  3. Newsgroups: comp.sources.x
  4. Subject: v18i102: bibview - BibTeX GUI, Part04/20
  5. Message-ID: <1992Aug27.161419.25285@msi.com>
  6. Date: 27 Aug 92 16:14:19 GMT
  7. References: <csx-18i099-bibview@uunet.UU.NET>
  8. Sender: dcmartin@msi.com (David C. Martin - Moderator)
  9. Organization: Molecular Simulations, Inc.
  10. Lines: 1881
  11. Approved: dcmartin@msi.com
  12. Originator: dcmartin@fascet
  13.  
  14. Submitted-by: Armin Liebl <liebla@informatik.tu-muenchen.de>
  15. Posting-number: Volume 18, Issue 102
  16. Archive-name: bibview/part04
  17.  
  18. #!/bin/sh
  19. # this is part.04 (part 4 of a multipart archive)
  20. # do not concatenate these parts, unpack them in order with /bin/sh
  21. # file bib_file.c continued
  22. #
  23. if test ! -r _shar_seq_.tmp; then
  24.     echo 'Please unpack part 1 first!'
  25.     exit 1
  26. fi
  27. (read Scheck
  28.  if test "$Scheck" != 4; then
  29.     echo Please unpack part "$Scheck" next!
  30.     exit 1
  31.  else
  32.     exit 0
  33.  fi
  34. ) < _shar_seq_.tmp || exit 1
  35. if test ! -f _shar_wnt_.tmp; then
  36.     echo 'x - still skipping bib_file.c'
  37. else
  38. echo 'x - continuing file bib_file.c'
  39. sed 's/^X//' << 'SHAR_EOF' >> 'bib_file.c' &&
  40. X    "allstringR : ZEICHEN",
  41. X    "allstringR : BUCHSTABE_ZAHL",
  42. X    "allstringR : KOMMA",
  43. X    "allstringR : EQ",
  44. X    "allstringR : ZAUN",
  45. X    "allstringR : DAZ",
  46. X    "eintrag : eingabetyp LGKL schluessel KOMMA felder leerraum RGKL",
  47. X    "eintrag : eingabetyp leerraum LGKL schluessel KOMMA felder leerraum RGKL",
  48. X    "eintrag : eingabetyp LGKL schluessel KOMMA felder RGKL",
  49. X    "eintrag : eingabetyp leerraum LGKL schluessel KOMMA felder RGKL",
  50. X    "eintrag : eingabetyp LRKL schluessel KOMMA felder leerraum RRKL",
  51. X    "eintrag : eingabetyp leerraum LRKL schluessel KOMMA felder leerraum RRKL",
  52. X    "eintrag : eingabetyp LRKL schluessel KOMMA felder RRKL",
  53. X    "eintrag : eingabetyp leerraum LRKL schluessel KOMMA felder RRKL",
  54. X    "eingabetyp : ARTICLE",
  55. X    "eingabetyp : BOOK",
  56. X    "eingabetyp : BOOKLET",
  57. X    "eingabetyp : CONFERENCE",
  58. X    "eingabetyp : INBOOK",
  59. X    "eingabetyp : INCOLLECTION",
  60. X    "eingabetyp : INPROCEEDINGS",
  61. X    "eingabetyp : MANUAL",
  62. X    "eingabetyp : MASTERSTHESIS",
  63. X    "eingabetyp : MISC",
  64. X    "eingabetyp : PHDTHESIS",
  65. X    "eingabetyp : PROCEEDINGS",
  66. X    "eingabetyp : TECHREPORT",
  67. X    "eingabetyp : UNPUBLISHED",
  68. X    "schluessel : leerraum schl",
  69. X    "schluessel : schl leerraum",
  70. X    "schluessel : leerraum schl leerraum",
  71. X    "schluessel : schl",
  72. X    "schl : BUCHSTABE_ZAHL schl",
  73. X    "schl : ZEICHEN schl",
  74. X    "schl : BUCHSTABE_ZAHL",
  75. X    "schl : ZEICHEN",
  76. X    "schl : EQ",
  77. X    "felder : leerraum feld KOMMA felder",
  78. X    "felder : feld KOMMA felder",
  79. X    "felder : leerraum feld KOMMA",
  80. X    "felder : leerraum feld KOMMA leerraum",
  81. X    "felder : feld KOMMA",
  82. X    "felder : feld KOMMA leerraum",
  83. X    "felder : leerraum feld",
  84. X    "felder : feld",
  85. X    "felder : feld leerraum",
  86. X    "feld : feldname leerraum EQ konkatenation",
  87. X    "feld : feldname EQ konkatenation",
  88. X    "feldname : BUCHSTABE_ZAHL feldname",
  89. X    "feldname : BUCHSTABE_ZAHL",
  90. X    "leerraum : WHITE_SPACE leerraum",
  91. X    "leerraum : WHITE_SPACE",
  92. X    "konkatenation : konkatenation ZAUN konkatenation",
  93. X    "konkatenation : feldinhalt",
  94. X    "konkatenation : feldinhalt leerraum",
  95. X    "konkatenation : leerraum feldinhalt",
  96. X    "konkatenation : leerraum feldinhalt leerraum",
  97. X    "feldinhalt : LGKL allstringG RGKL",
  98. X    "feldinhalt : DAZ dazfeldinhalt DAZ",
  99. X    "feldinhalt : DAZ DAZ",
  100. X    "feldinhalt : LGKL RGKL",
  101. X    "feldinhalt : makro",
  102. X    "makro : BUCHSTABE_ZAHL makro",
  103. X    "makro : ZEICHEN makro",
  104. X    "makro : BUCHSTABE_ZAHL",
  105. X    "makro : ZEICHEN",
  106. X    "dazfeldinhalt : WHITE_SPACE dazfeldinhalt",
  107. X    "dazfeldinhalt : BUCHSTABE_ZAHL dazfeldinhalt",
  108. X    "dazfeldinhalt : ZEICHEN dazfeldinhalt",
  109. X    "dazfeldinhalt : LRKL dazfeldinhalt",
  110. X    "dazfeldinhalt : RRKL dazfeldinhalt",
  111. X    "dazfeldinhalt : LGKL dazdaz RGKL",
  112. X    "dazfeldinhalt : LGKL dazdaz RGKL dazfeldinhalt",
  113. X    "dazfeldinhalt : LGKL RGKL",
  114. X    "dazfeldinhalt : LGKL RGKL dazfeldinhalt",
  115. X    "dazfeldinhalt : WHITE_SPACE",
  116. X    "dazfeldinhalt : BUCHSTABE_ZAHL",
  117. X    "dazfeldinhalt : KOMMA dazfeldinhalt",
  118. X    "dazfeldinhalt : EQ dazfeldinhalt",
  119. X    "dazfeldinhalt : ZEICHEN",
  120. X    "dazfeldinhalt : LRKL",
  121. X    "dazfeldinhalt : RRKL",
  122. X    "dazfeldinhalt : KOMMA",
  123. X    "dazdaz : WHITE_SPACE dazdaz",
  124. X    "dazdaz : BUCHSTABE_ZAHL dazdaz",
  125. X    "dazdaz : ZEICHEN dazdaz",
  126. X    "dazdaz : LRKL dazdaz",
  127. X    "dazdaz : RRKL dazdaz",
  128. X    "dazdaz : LGKL dazdaz RGKL",
  129. X    "dazdaz : LGKL dazdaz RGKL dazdaz",
  130. X    "dazdaz : WHITE_SPACE",
  131. X    "dazdaz : BUCHSTABE_ZAHL",
  132. X    "dazdaz : KOMMA dazdaz",
  133. X    "dazdaz : DAZ dazdaz",
  134. X    "dazdaz : EQ dazdaz",
  135. X    "dazdaz : ZEICHEN",
  136. X    "dazdaz : LRKL",
  137. X    "dazdaz : RRKL",
  138. X    "dazdaz : KOMMA",
  139. X    "dazdaz : DAZ",
  140. };
  141. #endif /* YYDEBUG */
  142. #define YYFLAG  (-3000)
  143. /* @(#) $Revision: 66.3 $ */    
  144. X
  145. /*
  146. ** Skeleton parser driver for yacc output
  147. */
  148. X
  149. #if defined(NLS) && !defined(NL_SETN)
  150. #include <msgbuf.h>
  151. #endif
  152. X
  153. #ifndef nl_msg
  154. #define nl_msg(i,s) (s)
  155. #endif
  156. X
  157. /*
  158. ** yacc user known macros and defines
  159. */
  160. #define YYERROR        goto yyerrlab
  161. X
  162. #ifndef __RUNTIME_YYMAXDEPTH
  163. #define YYACCEPT    return(0)
  164. #define YYABORT        return(1)
  165. #else
  166. #define YYACCEPT    {free_stacks(); return(0);}
  167. #define YYABORT        {free_stacks(); return(1);}
  168. #endif
  169. X
  170. #define YYBACKUP( newtoken, newvalue )\
  171. {\
  172. X    if ( yychar >= 0 || ( yyr2[ yytmp ] >> 1 ) != 1 )\
  173. X    {\
  174. X        yyerror( (nl_msg(30001,"syntax error - cannot backup")) );\
  175. X        goto yyerrlab;\
  176. X    }\
  177. X    yychar = newtoken;\
  178. X    yystate = *yyps;\
  179. X    yylval = newvalue;\
  180. X    goto yynewstate;\
  181. }
  182. #define YYRECOVERING()    (!!yyerrflag)
  183. #ifndef YYDEBUG
  184. #    define YYDEBUG    1    /* make debugging available */
  185. #endif
  186. X
  187. /*
  188. ** user known globals
  189. */
  190. int yydebug;            /* set to 1 to get debugging */
  191. X
  192. /*
  193. ** driver internal defines
  194. */
  195. /* define for YYFLAG now generated by yacc program. */
  196. /*#define YYFLAG        (FLAGVAL)*/
  197. X
  198. /*
  199. ** global variables used by the parser
  200. */
  201. # ifndef __RUNTIME_YYMAXDEPTH
  202. __YYSCLASS YYSTYPE yyv[ YYMAXDEPTH ];    /* value stack */
  203. __YYSCLASS int yys[ YYMAXDEPTH ];        /* state stack */
  204. # else
  205. __YYSCLASS YYSTYPE *yyv;            /* pointer to malloc'ed value stack */
  206. __YYSCLASS int *yys;            /* pointer to malloc'ed stack stack */
  207. X
  208. static int allocate_stacks(); 
  209. static void free_stacks();
  210. # ifndef YYINCREMENT
  211. # define YYINCREMENT (YYMAXDEPTH/2) + 10
  212. # endif
  213. # endif    /* __RUNTIME_YYMAXDEPTH */
  214. long  yymaxdepth = YYMAXDEPTH;
  215. X
  216. __YYSCLASS YYSTYPE *yypv;            /* top of value stack */
  217. __YYSCLASS int *yyps;            /* top of state stack */
  218. X
  219. __YYSCLASS int yystate;            /* current state */
  220. __YYSCLASS int yytmp;            /* extra var (lasts between blocks) */
  221. X
  222. int yynerrs;            /* number of errors */
  223. __YYSCLASS int yyerrflag;            /* error recovery flag */
  224. int yychar;            /* current input token number */
  225. X
  226. X
  227. X
  228. /*
  229. ** yyparse - return 0 if worked, 1 if syntax error not recovered from
  230. */
  231. int
  232. yyparse()
  233. {
  234. X    register YYSTYPE *yypvt;    /* top of value stack for $vars */
  235. X
  236. X    /*
  237. X    ** Initialize externals - yyparse may be called more than once
  238. X    */
  239. # ifdef __RUNTIME_YYMAXDEPTH
  240. X    if (allocate_stacks()) YYABORT;
  241. # endif
  242. X    yypv = &yyv[-1];
  243. X    yyps = &yys[-1];
  244. X    yystate = 0;
  245. X    yytmp = 0;
  246. X    yynerrs = 0;
  247. X    yyerrflag = 0;
  248. X    yychar = -1;
  249. X
  250. X    goto yystack;
  251. X    {
  252. X        register YYSTYPE *yy_pv;    /* top of value stack */
  253. X        register int *yy_ps;        /* top of state stack */
  254. X        register int yy_state;        /* current state */
  255. X        register int  yy_n;        /* internal state number info */
  256. X
  257. X        /*
  258. X        ** get globals into registers.
  259. X        ** branch to here only if YYBACKUP was called.
  260. X        */
  261. X    yynewstate:
  262. X        yy_pv = yypv;
  263. X        yy_ps = yyps;
  264. X        yy_state = yystate;
  265. X        goto yy_newstate;
  266. X
  267. X        /*
  268. X        ** get globals into registers.
  269. X        ** either we just started, or we just finished a reduction
  270. X        */
  271. X    yystack:
  272. X        yy_pv = yypv;
  273. X        yy_ps = yyps;
  274. X        yy_state = yystate;
  275. X
  276. X        /*
  277. X        ** top of for (;;) loop while no reductions done
  278. X        */
  279. X    yy_stack:
  280. X        /*
  281. X        ** put a state and value onto the stacks
  282. X        */
  283. #if YYDEBUG
  284. X        /*
  285. X        ** if debugging, look up token value in list of value vs.
  286. X        ** name pairs.  0 and negative (-1) are special values.
  287. X        ** Note: linear search is used since time is not a real
  288. X        ** consideration while debugging.
  289. X        */
  290. X        if ( yydebug )
  291. X        {
  292. X            register int yy_i;
  293. X
  294. X            printf( "State %d, token ", yy_state );
  295. X            if ( yychar == 0 )
  296. X                printf( "end-of-file\n" );
  297. X            else if ( yychar < 0 )
  298. X                printf( "-none-\n" );
  299. X            else
  300. X            {
  301. X                for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
  302. X                    yy_i++ )
  303. X                {
  304. X                    if ( yytoks[yy_i].t_val == yychar )
  305. X                        break;
  306. X                }
  307. X                printf( "%s\n", yytoks[yy_i].t_name );
  308. X            }
  309. X        }
  310. #endif /* YYDEBUG */
  311. X        if ( ++yy_ps >= &yys[ yymaxdepth ] )    /* room on stack? */
  312. X        {
  313. # ifndef __RUNTIME_YYMAXDEPTH
  314. X            yyerror( (nl_msg(30002,"yacc stack overflow")) );
  315. X            YYABORT;
  316. # else
  317. X            /* save old stack bases to recalculate pointers */
  318. X            YYSTYPE * yyv_old = yyv;
  319. X            int * yys_old = yys;
  320. X            yymaxdepth += YYINCREMENT;
  321. X            yys = (int *) realloc(yys, yymaxdepth * sizeof(int));
  322. X            yyv = (YYSTYPE *) realloc(yyv, yymaxdepth * sizeof(YYSTYPE));
  323. X            if (yys==0 || yyv==0) {
  324. X                yyerror( (nl_msg(30002,"yacc stack overflow")) );
  325. X                YYABORT;
  326. X                }
  327. X            /* Reset pointers into stack */
  328. X            yy_ps = (yy_ps - yys_old) + yys;
  329. X            yyps = (yyps - yys_old) + yys;
  330. X            yy_pv = (yy_pv - yyv_old) + yyv;
  331. X            yypv = (yypv - yyv_old) + yyv;
  332. # endif
  333. X
  334. X        }
  335. X        *yy_ps = yy_state;
  336. X        *++yy_pv = yyval;
  337. X
  338. X        /*
  339. X        ** we have a new state - find out what to do
  340. X        */
  341. X    yy_newstate:
  342. X        if ( ( yy_n = yypact[ yy_state ] ) <= YYFLAG )
  343. X            goto yydefault;        /* simple state */
  344. #if YYDEBUG
  345. X        /*
  346. X        ** if debugging, need to mark whether new token grabbed
  347. X        */
  348. X        yytmp = yychar < 0;
  349. #endif
  350. X        if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) )
  351. X            yychar = 0;        /* reached EOF */
  352. #if YYDEBUG
  353. X        if ( yydebug && yytmp )
  354. X        {
  355. X            register int yy_i;
  356. X
  357. X            printf( "Received token " );
  358. X            if ( yychar == 0 )
  359. X                printf( "end-of-file\n" );
  360. X            else if ( yychar < 0 )
  361. X                printf( "-none-\n" );
  362. X            else
  363. X            {
  364. X                for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
  365. X                    yy_i++ )
  366. X                {
  367. X                    if ( yytoks[yy_i].t_val == yychar )
  368. X                        break;
  369. X                }
  370. X                printf( "%s\n", yytoks[yy_i].t_name );
  371. X            }
  372. X        }
  373. #endif /* YYDEBUG */
  374. X        if ( ( ( yy_n += yychar ) < 0 ) || ( yy_n >= YYLAST ) )
  375. X            goto yydefault;
  376. X        if ( yychk[ yy_n = yyact[ yy_n ] ] == yychar )    /*valid shift*/
  377. X        {
  378. X            yychar = -1;
  379. X            yyval = yylval;
  380. X            yy_state = yy_n;
  381. X            if ( yyerrflag > 0 )
  382. X                yyerrflag--;
  383. X            goto yy_stack;
  384. X        }
  385. X
  386. X    yydefault:
  387. X        if ( ( yy_n = yydef[ yy_state ] ) == -2 )
  388. X        {
  389. #if YYDEBUG
  390. X            yytmp = yychar < 0;
  391. #endif
  392. X            if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) )
  393. X                yychar = 0;        /* reached EOF */
  394. #if YYDEBUG
  395. X            if ( yydebug && yytmp )
  396. X            {
  397. X                register int yy_i;
  398. X
  399. X                printf( "Received token " );
  400. X                if ( yychar == 0 )
  401. X                    printf( "end-of-file\n" );
  402. X                else if ( yychar < 0 )
  403. X                    printf( "-none-\n" );
  404. X                else
  405. X                {
  406. X                    for ( yy_i = 0;
  407. X                        yytoks[yy_i].t_val >= 0;
  408. X                        yy_i++ )
  409. X                    {
  410. X                        if ( yytoks[yy_i].t_val
  411. X                            == yychar )
  412. X                        {
  413. X                            break;
  414. X                        }
  415. X                    }
  416. X                    printf( "%s\n", yytoks[yy_i].t_name );
  417. X                }
  418. X            }
  419. #endif /* YYDEBUG */
  420. X            /*
  421. X            ** look through exception table
  422. X            */
  423. X            {
  424. X                register int *yyxi = yyexca;
  425. X
  426. X                while ( ( *yyxi != -1 ) ||
  427. X                    ( yyxi[1] != yy_state ) )
  428. X                {
  429. X                    yyxi += 2;
  430. X                }
  431. X                while ( ( *(yyxi += 2) >= 0 ) &&
  432. X                    ( *yyxi != yychar ) )
  433. X                    ;
  434. X                if ( ( yy_n = yyxi[1] ) < 0 )
  435. X                    YYACCEPT;
  436. X            }
  437. X        }
  438. X
  439. X        /*
  440. X        ** check for syntax error
  441. X        */
  442. X        if ( yy_n == 0 )    /* have an error */
  443. X        {
  444. X            /* no worry about speed here! */
  445. X            switch ( yyerrflag )
  446. X            {
  447. X            case 0:        /* new error */
  448. X                yyerror( (nl_msg(30003,"syntax error")) );
  449. X                yynerrs++;
  450. X                goto skip_init;
  451. X            yyerrlab:
  452. X                /*
  453. X                ** get globals into registers.
  454. X                ** we have a user generated syntax type error
  455. X                */
  456. X                yy_pv = yypv;
  457. X                yy_ps = yyps;
  458. X                yy_state = yystate;
  459. X                yynerrs++;
  460. X            skip_init:
  461. X            case 1:
  462. X            case 2:        /* incompletely recovered error */
  463. X                    /* try again... */
  464. X                yyerrflag = 3;
  465. X                /*
  466. X                ** find state where "error" is a legal
  467. X                ** shift action
  468. X                */
  469. X                while ( yy_ps >= yys )
  470. X                {
  471. X                    yy_n = yypact[ *yy_ps ] + YYERRCODE;
  472. X                    if ( yy_n >= 0 && yy_n < YYLAST &&
  473. X                        yychk[yyact[yy_n]] == YYERRCODE)                    {
  474. X                        /*
  475. X                        ** simulate shift of "error"
  476. X                        */
  477. X                        yy_state = yyact[ yy_n ];
  478. X                        goto yy_stack;
  479. X                    }
  480. X                    /*
  481. X                    ** current state has no shift on
  482. X                    ** "error", pop stack
  483. X                    */
  484. #if YYDEBUG
  485. #    define _POP_ "Error recovery pops state %d, uncovers state %d\n"
  486. X                    if ( yydebug )
  487. X                        printf( _POP_, *yy_ps,
  488. X                            yy_ps[-1] );
  489. #    undef _POP_
  490. #endif
  491. X                    yy_ps--;
  492. X                    yy_pv--;
  493. X                }
  494. X                /*
  495. X                ** there is no state on stack with "error" as
  496. X                ** a valid shift.  give up.
  497. X                */
  498. X                YYABORT;
  499. X            case 3:        /* no shift yet; eat a token */
  500. #if YYDEBUG
  501. X                /*
  502. X                ** if debugging, look up token in list of
  503. X                ** pairs.  0 and negative shouldn't occur,
  504. X                ** but since timing doesn't matter when
  505. X                ** debugging, it doesn't hurt to leave the
  506. X                ** tests here.
  507. X                */
  508. X                if ( yydebug )
  509. X                {
  510. X                    register int yy_i;
  511. X
  512. X                    printf( "Error recovery discards " );
  513. X                    if ( yychar == 0 )
  514. X                        printf( "token end-of-file\n" );
  515. X                    else if ( yychar < 0 )
  516. X                        printf( "token -none-\n" );
  517. X                    else
  518. X                    {
  519. X                        for ( yy_i = 0;
  520. X                            yytoks[yy_i].t_val >= 0;
  521. X                            yy_i++ )
  522. X                        {
  523. X                            if ( yytoks[yy_i].t_val
  524. X                                == yychar )
  525. X                            {
  526. X                                break;
  527. X                            }
  528. X                        }
  529. X                        printf( "token %s\n",
  530. X                            yytoks[yy_i].t_name );
  531. X                    }
  532. X                }
  533. #endif /* YYDEBUG */
  534. X                if ( yychar == 0 )    /* reached EOF. quit */
  535. X                    YYABORT;
  536. X                yychar = -1;
  537. X                goto yy_newstate;
  538. X            }
  539. X        }/* end if ( yy_n == 0 ) */
  540. X        /*
  541. X        ** reduction by production yy_n
  542. X        ** put stack tops, etc. so things right after switch
  543. X        */
  544. #if YYDEBUG
  545. X        /*
  546. X        ** if debugging, print the string that is the user's
  547. X        ** specification of the reduction which is just about
  548. X        ** to be done.
  549. X        */
  550. X        if ( yydebug )
  551. X            printf( "Reduce by (%d) \"%s\"\n",
  552. X                yy_n, yyreds[ yy_n ] );
  553. #endif
  554. X        yytmp = yy_n;            /* value to switch over */
  555. X        yypvt = yy_pv;            /* $vars top of value stack */
  556. X        /*
  557. X        ** Look in goto table for next state
  558. X        ** Sorry about using yy_state here as temporary
  559. X        ** register variable, but why not, if it works...
  560. X        ** If yyr2[ yy_n ] doesn't have the low order bit
  561. X        ** set, then there is no action to be done for
  562. X        ** this reduction.  So, no saving & unsaving of
  563. X        ** registers done.  The only difference between the
  564. X        ** code just after the if and the body of the if is
  565. X        ** the goto yy_stack in the body.  This way the test
  566. X        ** can be made before the choice of what to do is needed.
  567. X        */
  568. X        {
  569. X            /* length of production doubled with extra bit */
  570. X            register int yy_len = yyr2[ yy_n ];
  571. X
  572. X            if ( !( yy_len & 01 ) )
  573. X            {
  574. X                yy_len >>= 1;
  575. X                yyval = ( yy_pv -= yy_len )[1];    /* $$ = $1 */
  576. X                yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +
  577. X                    *( yy_ps -= yy_len ) + 1;
  578. X                if ( yy_state >= YYLAST ||
  579. X                    yychk[ yy_state =
  580. X                    yyact[ yy_state ] ] != -yy_n )
  581. X                {
  582. X                    yy_state = yyact[ yypgo[ yy_n ] ];
  583. X                }
  584. X                goto yy_stack;
  585. X            }
  586. X            yy_len >>= 1;
  587. X            yyval = ( yy_pv -= yy_len )[1];    /* $$ = $1 */
  588. X            yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +
  589. X                *( yy_ps -= yy_len ) + 1;
  590. X            if ( yy_state >= YYLAST ||
  591. X                yychk[ yy_state = yyact[ yy_state ] ] != -yy_n )
  592. X            {
  593. X                yy_state = yyact[ yypgo[ yy_n ] ];
  594. X            }
  595. X        }
  596. X                    /* save until reenter driver code */
  597. X        yystate = yy_state;
  598. X        yyps = yy_ps;
  599. X        yypv = yy_pv;
  600. X    }
  601. X    /*
  602. X    ** code supplied by user is placed in this switch
  603. X    */
  604. X    switch( yytmp )
  605. X    {
  606. X        
  607. case 17:{         
  608. X                beginIdx = SkipNewLineSpace(uebergabe);
  609. X                fprintf(tempDatei,"@STRING"); 
  610. X                fprintf(tempDatei,"%s\n",&uebergabe[beginIdx]); 
  611. X                ueIdx = 0;
  612. X              } break;
  613. case 18:{         
  614. X                beginIdx = SkipNewLineSpace(uebergabe);
  615. X                fprintf(tempDatei,"@STRING"); 
  616. X                fprintf(tempDatei,"%s\n",&uebergabe[beginIdx]); 
  617. X                ueIdx = 0;
  618. X              } break;
  619. case 19:{         
  620. X                beginIdx = SkipNewLineSpace(uebergabe);
  621. X                fprintf(tempDatei,"@STRING"); 
  622. X                fprintf(tempDatei,"%s\n",&uebergabe[beginIdx]); 
  623. X                ueIdx = 0;
  624. X              } break;
  625. case 20:{         
  626. X                beginIdx = SkipNewLineSpace(uebergabe);
  627. X                fprintf(tempDatei,"@STRING"); 
  628. X                fprintf(tempDatei,"%s\n",&uebergabe[beginIdx]); 
  629. X                ueIdx = 0;
  630. X              } break;
  631. case 21:{         
  632. X                beginIdx = SkipNewLineSpace(uebergabe);
  633. X                fprintf(tempDatei,"@PREAMBLE"); 
  634. X                fprintf(tempDatei,"%s\n",&uebergabe[beginIdx]); 
  635. X                ueIdx = 0;
  636. X              } break;
  637. case 22:{         
  638. X                beginIdx = SkipNewLineSpace(uebergabe);
  639. X                fprintf(tempDatei,"@PREAMBLE"); 
  640. X                fprintf(tempDatei,"%s\n",&uebergabe[beginIdx]); 
  641. X                ueIdx = 0;
  642. X              } break;
  643. case 23:{         
  644. X                beginIdx = SkipNewLineSpace(uebergabe);
  645. X                fprintf(tempDatei,"@PREAMBLE"); 
  646. X                fprintf(tempDatei,"%s\n",&uebergabe[beginIdx]); 
  647. X                ueIdx = 0;
  648. X              } break;
  649. case 24:{         
  650. X                beginIdx = SkipNewLineSpace(uebergabe);
  651. X                fprintf(tempDatei,"@PREAMBLE"); 
  652. X                fprintf(tempDatei,"%s\n",&uebergabe[beginIdx]); 
  653. X                ueIdx = 0;
  654. X              } break;
  655. case 67:{                 
  656. X                  GetKey();
  657. X                } break;
  658. case 68:{
  659. X                  GetKey();
  660. X                } break;
  661. case 69:{
  662. X                  GetKey();
  663. X                } break;
  664. case 70:{
  665. X                  GetKey();
  666. X                } break;
  667. case 71:{
  668. X                  GetKey();
  669. X                } break;
  670. case 72:{
  671. X                  GetKey();
  672. X                } break;
  673. case 73:{
  674. X                  GetKey();
  675. X                } break;
  676. case 74:{
  677. X                  GetKey();
  678. X                } break;
  679. case 75:{
  680. X          err = dbtMakeCard(&card);
  681. X          card->cardtype = article; 
  682. X          Scalloc(&card->cardtypestr, "article");
  683. X                } break;
  684. case 76:{
  685. X          err = dbtMakeCard(&card);
  686. X          card->cardtype = book; 
  687. X          Scalloc(&card->cardtypestr, "book");
  688. X                } break;
  689. case 77:{
  690. X          err = dbtMakeCard(&card);
  691. X          card->cardtype = booklet; 
  692. X          Scalloc(&card->cardtypestr, "booklet");
  693. X                } break;
  694. case 78:{
  695. X          err = dbtMakeCard(&card);
  696. X          card->cardtype = conference; 
  697. X          Scalloc(&card->cardtypestr, "conference");
  698. X                } break;
  699. case 79:{
  700. X          err = dbtMakeCard(&card);
  701. X          card->cardtype = inbook; 
  702. X          Scalloc(&card->cardtypestr, "inbook");
  703. X                } break;
  704. case 80:{
  705. X          err = dbtMakeCard(&card);
  706. X          card->cardtype = incollection; 
  707. X          Scalloc(&card->cardtypestr, "incollection");
  708. X                } break;
  709. case 81:{
  710. X          err = dbtMakeCard(&card);
  711. X          card->cardtype = inproceedings; 
  712. X          Scalloc(&card->cardtypestr, "inproceedings");
  713. X                } break;
  714. case 82:{
  715. X          err = dbtMakeCard(&card);
  716. X          card->cardtype = manual; 
  717. X          Scalloc(&card->cardtypestr, "manual");
  718. X                } break;
  719. case 83:{
  720. X          err = dbtMakeCard(&card);
  721. X          card->cardtype = mastersthesis; 
  722. X          Scalloc(&card->cardtypestr, "mastersthesis");
  723. X                } break;
  724. case 84:{
  725. X          err = dbtMakeCard(&card);
  726. X          card->cardtype = misc; 
  727. X          Scalloc(&card->cardtypestr, "misc");
  728. X                } break;
  729. case 85:{
  730. X          err = dbtMakeCard(&card);
  731. X          card->cardtype = phdthesis; 
  732. X          Scalloc(&card->cardtypestr, "phdthesis");
  733. X                } break;
  734. case 86:{
  735. X          err = dbtMakeCard(&card);
  736. X          card->cardtype = proceedings; 
  737. X          Scalloc(&card->cardtypestr, "proceedings");
  738. X                } break;
  739. case 87:{
  740. X          err = dbtMakeCard(&card);
  741. X          card->cardtype = techreport; 
  742. X          Scalloc(&card->cardtypestr, "techreport");
  743. X                } break;
  744. case 88:{
  745. X          err = dbtMakeCard(&card);
  746. X          card->cardtype = unpublished; 
  747. X          Scalloc(&card->cardtypestr, "unpublished");
  748. X                } break;
  749. case 93:{
  750. X                  PushSign(&key, yypvt[-1]);
  751. X                } break;
  752. case 94:{
  753. X                  PushSign(&key, yypvt[-1]);
  754. X                } break;
  755. case 95:{
  756. X                  PushSign(&key, yypvt[-0]);
  757. X                } break;
  758. case 96:{
  759. X                  PushSign(&key, yypvt[-0]);
  760. X                } break;
  761. case 97:{
  762. X                  PushSign(&key, yypvt[-0]);
  763. X                } break;
  764. case 107:{
  765. X                  GetFldNameCont();
  766. X                } break;
  767. case 108:{
  768. X                  GetFldNameCont();
  769. X                } break;
  770. case 109:{
  771. X                  PushSign(&fldname, yypvt[-1]);
  772. X                  ueIdx = 0;
  773. X                } break;
  774. case 110:{
  775. X                  PushSign(&fldname, yypvt[-0]);
  776. X                  ueIdx = 0;
  777. X                } break;
  778. X    }
  779. X    goto yystack;        /* reset registers in driver code */
  780. }
  781. X
  782. # ifdef __RUNTIME_YYMAXDEPTH
  783. X
  784. static int allocate_stacks() {
  785. X    /* allocate the yys and yyv stacks */
  786. X    yys = (int *) malloc(yymaxdepth * sizeof(int));
  787. X    yyv = (YYSTYPE *) malloc(yymaxdepth * sizeof(YYSTYPE));
  788. X
  789. X    if (yys==0 || yyv==0) {
  790. X       yyerror( (nl_msg(30004,"unable to allocate space for yacc stacks")) );
  791. X       return(1);
  792. X       }
  793. X    else return(0);
  794. X
  795. }
  796. X
  797. X
  798. static void free_stacks() {
  799. X    if (yys!=0) free((char *) yys);
  800. X    if (yyv!=0) free((char *) yyv);
  801. }
  802. X
  803. # endif  /* defined(__RUNTIME_YYMAXDEPTH) */
  804. X
  805. SHAR_EOF
  806. echo 'File bib_file.c is complete' &&
  807. chmod 0644 bib_file.c ||
  808. echo 'restore of bib_file.c failed'
  809. Wc_c="`wc -c < 'bib_file.c'`"
  810. test 54434 -eq "$Wc_c" ||
  811.     echo 'bib_file.c: original size 54434, current size' "$Wc_c"
  812. rm -f _shar_wnt_.tmp
  813. fi
  814. # ============= bib_flex.c ==============
  815. if test -f 'bib_flex.c' -a X"$1" != X"-c"; then
  816.     echo 'x - skipping bib_flex.c (File already exists)'
  817.     rm -f _shar_wnt_.tmp
  818. else
  819. > _shar_wnt_.tmp
  820. echo 'x - extracting bib_flex.c (Text)'
  821. sed 's/^X//' << 'SHAR_EOF' > 'bib_flex.c' &&
  822. /* A lexical scanner generated by flex */
  823. X
  824. /* scanner skeleton version:
  825. X * $Header: /usr/fsys/odin/a/vern/flex/RCS/flex.skel,v 2.16 90/08/03 14:09:36 vern Exp $
  826. X */
  827. X
  828. #define FLEX_SCANNER
  829. X
  830. #include <stdio.h>
  831. X
  832. X
  833. /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
  834. #ifdef c_plusplus
  835. #ifndef __cplusplus
  836. #define __cplusplus
  837. #endif
  838. #endif
  839. X
  840. X
  841. #ifdef __cplusplus
  842. X
  843. #include <stdlib.h>
  844. #include <osfcn.h>
  845. X
  846. /* use prototypes in function declarations */
  847. #define YY_USE_PROTOS
  848. X
  849. /* the "const" storage-class-modifier is valid */
  850. #define YY_USE_CONST
  851. X
  852. #else    /* ! __cplusplus */
  853. X
  854. #ifdef __STDC__
  855. X
  856. #ifdef __GNUC__
  857. #else
  858. #include <stdlib.h>
  859. #endif    /* __GNUC__ */
  860. X
  861. #define YY_USE_PROTOS
  862. #define YY_USE_CONST
  863. X
  864. #endif    /* __STDC__ */
  865. #endif    /* ! __cplusplus */
  866. X
  867. X
  868. #ifdef __TURBOC__
  869. #define YY_USE_CONST
  870. #endif
  871. X
  872. X
  873. #ifndef YY_USE_CONST
  874. #define const
  875. #endif
  876. X
  877. X
  878. #ifdef YY_USE_PROTOS
  879. #define YY_PROTO(proto) proto
  880. #else
  881. #define YY_PROTO(proto) ()
  882. /* we can't get here if it's an ANSI C compiler, or a C++ compiler,
  883. X * so it's got to be a K&R compiler, and therefore there's no standard
  884. X * place from which to include these definitions
  885. X */
  886. char *malloc();
  887. int free();
  888. int read();
  889. #endif
  890. X
  891. X
  892. /* amount of stuff to slurp up with each read */
  893. #ifndef YY_READ_BUF_SIZE
  894. #define YY_READ_BUF_SIZE 8192
  895. #endif
  896. X
  897. /* returned upon end-of-file */
  898. #define YY_END_TOK 0
  899. X
  900. /* copy whatever the last rule matched to the standard output */
  901. X
  902. /* cast to (char *) is because for 8-bit chars, yytext is (unsigned char *) */
  903. /* this used to be an fputs(), but since the string might contain NUL's,
  904. X * we now use fwrite()
  905. X */
  906. #define ECHO (void) fwrite( (char *) yytext, yyleng, 1, yyout )
  907. X
  908. /* gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
  909. X * is returned in "result".
  910. X */
  911. #define YY_INPUT(buf,result,max_size) \
  912. X    if ( (result = read( fileno(yyin), (char *) buf, max_size )) < 0 ) \
  913. X        YY_FATAL_ERROR( "read() in flex scanner failed" );
  914. #define YY_NULL 0
  915. X
  916. /* no semi-colon after return; correct usage is to write "yyterminate();" -
  917. X * we don't want an extra ';' after the "return" because that will cause
  918. X * some compilers to complain about unreachable statements.
  919. X */
  920. #define yyterminate() return ( YY_NULL )
  921. X
  922. /* report a fatal error */
  923. X
  924. /* The funky do-while is used to turn this macro definition into
  925. X * a single C statement (which needs a semi-colon terminator).
  926. X * This avoids problems with code like:
  927. X *
  928. X *     if ( something_happens )
  929. X *        YY_FATAL_ERROR( "oops, the something happened" );
  930. X *    else
  931. X *        everything_okay();
  932. X *
  933. X * Prior to using the do-while the compiler would get upset at the
  934. X * "else" because it interpreted the "if" statement as being all
  935. X * done when it reached the ';' after the YY_FATAL_ERROR() call.
  936. X */
  937. X
  938. #define YY_FATAL_ERROR(msg) \
  939. X    do \
  940. X        { \
  941. X        (void) fputs( msg, stderr ); \
  942. X        (void) putc( '\n', stderr ); \
  943. X        exit( 1 ); \
  944. X        } \
  945. X    while ( 0 )
  946. X
  947. /* default yywrap function - always treat EOF as an EOF */
  948. #define yywrap() 1
  949. X
  950. /* enter a start condition.  This macro really ought to take a parameter,
  951. X * but we do it the disgusting crufty way forced on us by the ()-less
  952. X * definition of BEGIN
  953. X */
  954. #define BEGIN yy_start = 1 + 2 *
  955. X
  956. /* action number for EOF rule of a given start state */
  957. #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
  958. X
  959. /* special action meaning "start processing a new file" */
  960. #define YY_NEW_FILE \
  961. X    do \
  962. X        { \
  963. X        yy_init_buffer( yy_current_buffer, yyin ); \
  964. X        yy_load_buffer_state(); \
  965. X        } \
  966. X    while ( 0 )
  967. X
  968. /* default declaration of generated scanner - a define so the user can
  969. X * easily add parameters
  970. X */
  971. #define YY_DECL int yylex YY_PROTO(( void )) 
  972. X
  973. /* code executed at the end of each rule */
  974. #define YY_BREAK break;
  975. X
  976. #define YY_END_OF_BUFFER_CHAR 0
  977. X
  978. #ifndef YY_BUF_SIZE
  979. #define YY_BUF_SIZE (YY_READ_BUF_SIZE * 2) /* size of default input buffer */
  980. #endif
  981. X
  982. typedef struct yy_buffer_state *YY_BUFFER_STATE;
  983. X
  984. #define YY_CHAR char
  985. # line 1 "b.l"
  986. #define INITIAL 0
  987. # line 2 "b.l"
  988. #include "b.tab.h"
  989. #include <X11/Intrinsic.h>
  990. #include "bibview.h"
  991. X
  992. extern char yylval;
  993. extern int ueIdx;
  994. extern char uebergabe[];
  995. extern int yynline;
  996. extern int yynflexcalls;
  997. X
  998. X
  999. # line 16 "b.l"
  1000. X
  1001. /* done after the current pattern has been matched and before the
  1002. X * corresponding action - sets up yytext
  1003. X */
  1004. #define YY_DO_BEFORE_ACTION \
  1005. X    yytext = yy_bp; \
  1006. X    yyleng = yy_cp - yy_bp; \
  1007. X    yy_hold_char = *yy_cp; \
  1008. X    *yy_cp = '\0'; \
  1009. X    yy_c_buf_p = yy_cp;
  1010. X
  1011. #define EOB_ACT_CONTINUE_SCAN 0
  1012. #define EOB_ACT_END_OF_FILE 1
  1013. #define EOB_ACT_LAST_MATCH 2
  1014. X
  1015. /* return all but the first 'n' matched characters back to the input stream */
  1016. #define yyless(n) \
  1017. X    do \
  1018. X        { \
  1019. X        /* undo effects of setting up yytext */ \
  1020. X        *yy_cp = yy_hold_char; \
  1021. X        yy_c_buf_p = yy_cp = yy_bp + n; \
  1022. X        YY_DO_BEFORE_ACTION; /* set up yytext again */ \
  1023. X        } \
  1024. X    while ( 0 )
  1025. X
  1026. #define unput(c) yyunput( c, yytext )
  1027. X
  1028. X
  1029. struct yy_buffer_state
  1030. X    {
  1031. X    FILE *yy_input_file;
  1032. X
  1033. X    YY_CHAR *yy_ch_buf;        /* input buffer */
  1034. X    YY_CHAR *yy_buf_pos;    /* current position in input buffer */
  1035. X
  1036. X    /* size of input buffer in bytes, not including room for EOB characters*/
  1037. X    int yy_buf_size;    
  1038. X
  1039. X    /* number of characters read into yy_ch_buf, not including EOB characters */
  1040. X    int yy_n_chars;
  1041. X
  1042. X    int yy_eof_status;        /* whether we've seen an EOF on this buffer */
  1043. #define EOF_NOT_SEEN 0
  1044. X    /* "pending" happens when the EOF has been seen but there's still
  1045. X     * some text process
  1046. X     */
  1047. #define EOF_PENDING 1
  1048. #define EOF_DONE 2
  1049. X    };
  1050. X
  1051. static YY_BUFFER_STATE yy_current_buffer;
  1052. X
  1053. /* we provide macros for accessing buffer states in case in the
  1054. X * future we want to put the buffer states in a more general
  1055. X * "scanner state"
  1056. X */
  1057. #define YY_CURRENT_BUFFER yy_current_buffer
  1058. X
  1059. X
  1060. /* yy_hold_char holds the character lost when yytext is formed */
  1061. static YY_CHAR yy_hold_char;
  1062. X
  1063. static int yy_n_chars;        /* number of characters read into yy_ch_buf */
  1064. X
  1065. X
  1066. X
  1067. #ifndef YY_USER_ACTION
  1068. #define YY_USER_ACTION
  1069. #endif
  1070. X
  1071. #ifndef YY_USER_INIT
  1072. #define YY_USER_INIT
  1073. #endif
  1074. X
  1075. extern YY_CHAR *yytext;
  1076. extern int yyleng;
  1077. extern FILE *yyin, *yyout;
  1078. X
  1079. YY_CHAR *yytext;
  1080. int yyleng;
  1081. X
  1082. FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
  1083. X
  1084. #define YY_END_OF_BUFFER 30
  1085. typedef int yy_state_type;
  1086. static const short int yy_accept[141] =
  1087. X    {   0,
  1088. X        0,    0,   30,   28,   25,   25,   24,   17,   19,   20,
  1089. X       18,   26,   23,   28,   21,   22,    0,    0,    0,    0,
  1090. X        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  1091. X        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  1092. X        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  1093. X        0,    0,    4,    0,    0,    0,    0,    0,    0,   12,
  1094. X        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  1095. X        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  1096. X        0,    0,    0,    7,    0,    0,   10,    0,    0,    0,
  1097. X        0,    1,    0,    0,    3,    5,    0,    0,    0,    0,
  1098. X
  1099. X        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  1100. X        2,    0,    0,    0,    0,    0,    0,    0,   13,    0,
  1101. X        0,    0,    6,    0,    0,    0,    0,   15,    0,    0,
  1102. X        0,    0,   14,   16,    8,    0,    0,    9,   11,    0
  1103. X    } ;
  1104. X
  1105. static const YY_CHAR yy_ec[128] =
  1106. X    {   0,
  1107. X        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
  1108. X        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  1109. X        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  1110. X        1,    2,    1,    4,    5,    1,    1,    1,    1,    6,
  1111. X        7,    1,    1,    8,    1,    1,    1,    9,    9,    9,
  1112. X        9,    9,    9,    9,    9,    9,    9,    1,    1,    1,
  1113. X       10,    1,    1,   11,   12,   13,   14,   15,   16,   17,
  1114. X       18,   19,   20,    9,   21,   22,   23,   24,   25,   26,
  1115. X        9,   27,   28,   29,   30,    9,    9,    9,    9,    9,
  1116. X        1,    1,    1,    1,    1,    1,   12,   13,   14,   15,
  1117. X
  1118. X       16,   17,   18,   19,   20,    9,   21,   22,   23,   24,
  1119. X       25,   26,    9,   27,   28,   29,   30,    9,    9,    9,
  1120. X        9,    9,   31,    1,   32,    1,    1
  1121. X    } ;
  1122. X
  1123. static const YY_CHAR yy_meta[33] =
  1124. X    {   0,
  1125. X        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  1126. X        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  1127. X        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  1128. X        1,    1
  1129. X    } ;
  1130. X
  1131. static const short int yy_base[142] =
  1132. X    {   0,
  1133. X        0,   32,  155,  156,  156,  156,  156,  156,  156,  156,
  1134. X      156,  156,  156,   53,  156,  156,  127,  128,  127,  127,
  1135. X        0,    0,  121,  133,  124,  118,  121,  121,    0,    0,
  1136. X      116,  128,    0,  115,  127,  114,  119,  117,  120,  111,
  1137. X      110,  107,  103,  103,  117,  101,  117,  114,  107,  107,
  1138. X       95,  110,  101,  106,   96,   98,   94,  106,  101,  156,
  1139. X       97,   92,   98,   89,   85,   98,   88,   93,   81,   86,
  1140. X       84,   91,   82,   76,   86,   88,   84,   81,   82,   75,
  1141. X       80,   66,   78,  156,   77,   76,  156,   63,   62,   67,
  1142. X       73,  156,   61,   66,  156,  156,   61,   70,   64,   49,
  1143. X
  1144. X       57,   59,   54,   47,   43,   56,   40,   53,   43,   33,
  1145. X      156,   36,   32,   39,   41,   36,   35,   38,  156,   35,
  1146. X       23,   35,  156,   25,   25,   20,   19,  156,   31,   21,
  1147. X       26,   21,  156,  156,  156,    2,    1,  156,  156,  156,
  1148. X        8
  1149. X    } ;
  1150. X
  1151. static const short int yy_def[142] =
  1152. X    {   0,
  1153. X      141,  141,  140,  140,  140,  140,  140,  140,  140,  140,
  1154. X      140,  140,  140,  140,  140,  140,  140,  140,  140,  140,
  1155. X      140,  140,  140,  140,  140,  140,  140,  140,  140,  140,
  1156. X      140,  140,  140,  140,  140,  140,  140,  140,  140,  140,
  1157. X      140,  140,  140,  140,  140,  140,  140,  140,  140,  140,
  1158. X      140,  140,  140,  140,  140,  140,  140,  140,  140,  140,
  1159. X      140,  140,  140,  140,  140,  140,  140,  140,  140,  140,
  1160. X      140,  140,  140,  140,  140,  140,  140,  140,  140,  140,
  1161. X      140,  140,  140,  140,  140,  140,  140,  140,  140,  140,
  1162. X      140,  140,  140,  140,  140,  140,  140,  140,  140,  140,
  1163. X
  1164. X      140,  140,  140,  140,  140,  140,  140,  140,  140,  140,
  1165. X      140,  140,  140,  140,  140,  140,  140,  140,  140,  140,
  1166. X      140,  140,  140,  140,  140,  140,  140,  140,  140,  140,
  1167. X      140,  140,  140,  140,  140,  140,  140,  140,  140,    0,
  1168. X      140
  1169. X    } ;
  1170. X
  1171. static const short int yy_nxt[189] =
  1172. X    {   0,
  1173. X        4,    5,    6,    7,    8,    9,   10,   11,   12,   13,
  1174. X       14,   30,   40,   41,  140,   47,  140,  140,   32,   31,
  1175. X      140,  140,  140,   43,   48,   42,   33,   44,  139,  138,
  1176. X       15,   16,    4,    5,    6,    7,    8,    9,   10,   11,
  1177. X      137,   13,   14,  136,  135,  134,  133,  132,  131,  130,
  1178. X      129,  128,  127,  126,  125,  124,  123,  122,  121,  120,
  1179. X      119,  118,   15,   16,   17,   18,   19,  117,  116,  115,
  1180. X      114,  113,   20,  112,  111,   21,  110,  109,   22,  108,
  1181. X       23,   24,   25,  107,  106,  105,  104,  103,  102,  101,
  1182. X      100,   99,   98,   97,   96,   95,   94,   93,   92,   91,
  1183. X
  1184. X       90,   89,   88,   87,   86,   85,   84,   83,   82,   81,
  1185. X       80,   79,   78,   77,   76,   75,   74,   73,   72,   71,
  1186. X       70,   69,   68,   67,   66,   65,   64,   63,   62,   61,
  1187. X       60,   59,   58,   57,   56,   55,   54,   53,   52,   51,
  1188. X       50,   49,   46,   45,   39,   38,   37,   36,   35,   34,
  1189. X       29,   28,   27,   26,  140,    3,  140,  140,  140,  140,
  1190. X      140,  140,  140,  140,  140,  140,  140,  140,  140,  140,
  1191. X      140,  140,  140,  140,  140,  140,  140,  140,  140,  140,
  1192. X      140,  140,  140,  140,  140,  140,  140,  140
  1193. X    } ;
  1194. X
  1195. static const short int yy_chk[189] =
  1196. X    {   0,
  1197. X        1,    1,    1,    1,    1,    1,    1,    1,  141,    1,
  1198. X        1,   21,   29,   29,    0,   33,    0,    0,   22,   21,
  1199. X        0,    0,    0,   30,   33,   29,   22,   30,  137,  136,
  1200. X        1,    1,    2,    2,    2,    2,    2,    2,    2,    2,
  1201. X      132,    2,    2,  131,  130,  129,  127,  126,  125,  124,
  1202. X      122,  121,  120,  118,  117,  116,  115,  114,  113,  112,
  1203. X      110,  109,    2,    2,   14,   14,   14,  108,  107,  106,
  1204. X      105,  104,   14,  103,  102,   14,  101,  100,   14,   99,
  1205. X       14,   14,   14,   98,   97,   94,   93,   91,   90,   89,
  1206. X       88,   86,   85,   83,   82,   81,   80,   79,   78,   77,
  1207. X
  1208. X       76,   75,   74,   73,   72,   71,   70,   69,   68,   67,
  1209. X       66,   65,   64,   63,   62,   61,   59,   58,   57,   56,
  1210. X       55,   54,   53,   52,   51,   50,   49,   48,   47,   46,
  1211. X       45,   44,   43,   42,   41,   40,   39,   38,   37,   36,
  1212. X       35,   34,   32,   31,   28,   27,   26,   25,   24,   23,
  1213. X       20,   19,   18,   17,    3,  140,  140,  140,  140,  140,
  1214. X      140,  140,  140,  140,  140,  140,  140,  140,  140,  140,
  1215. X      140,  140,  140,  140,  140,  140,  140,  140,  140,  140,
  1216. X      140,  140,  140,  140,  140,  140,  140,  140
  1217. X    } ;
  1218. X
  1219. static yy_state_type yy_last_accepting_state;
  1220. static YY_CHAR *yy_last_accepting_cpos;
  1221. X
  1222. /* the intent behind this definition is that it'll catch
  1223. X * any uses of REJECT which flex missed
  1224. X */
  1225. #define REJECT reject_used_but_not_detected
  1226. #define yymore() yymore_used_but_not_detected
  1227. #define YY_MORE_ADJ 0
  1228. X
  1229. /* these variables are all declared out here so that section 3 code can
  1230. X * manipulate them
  1231. X */
  1232. /* points to current character in buffer */
  1233. static YY_CHAR *yy_c_buf_p = (YY_CHAR *) 0;
  1234. int yy_init = 1;        /* whether we need to initialize */
  1235. static int yy_start = 0;    /* start state number */
  1236. X
  1237. /* flag which is used to allow yywrap()'s to do buffer switches
  1238. X * instead of setting up a fresh yyin.  A bit of a hack ...
  1239. X */
  1240. static int yy_did_buffer_switch_on_eof;
  1241. X
  1242. static yy_state_type yy_get_previous_state YY_PROTO(( void ));
  1243. static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
  1244. static int yy_get_next_buffer YY_PROTO(( void ));
  1245. static void yyunput YY_PROTO(( YY_CHAR c, YY_CHAR *buf_ptr ));
  1246. void yyrestart YY_PROTO(( FILE *input_file ));
  1247. void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
  1248. void yy_load_buffer_state YY_PROTO(( void ));
  1249. YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
  1250. void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
  1251. void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
  1252. X
  1253. #define yy_new_buffer yy_create_buffer
  1254. X
  1255. #ifdef __cplusplus
  1256. static int yyinput YY_PROTO(( void ));
  1257. #else
  1258. static int input YY_PROTO(( void ));
  1259. #endif
  1260. X
  1261. YY_DECL
  1262. X    {
  1263. X    register yy_state_type yy_current_state;
  1264. X    register YY_CHAR *yy_cp, *yy_bp;
  1265. X    register int yy_act;
  1266. X
  1267. X
  1268. X
  1269. X
  1270. X
  1271. X    if ( yy_init )
  1272. X    {
  1273. X    YY_USER_INIT;
  1274. X
  1275. X    if ( ! yy_start )
  1276. X        yy_start = 1;    /* first start state */
  1277. X
  1278. X    if ( ! yyin )
  1279. X        yyin = stdin;
  1280. X
  1281. X    if ( ! yyout )
  1282. X        yyout = stdout;
  1283. X
  1284. X    if ( yy_current_buffer )
  1285. X        yy_init_buffer( yy_current_buffer, yyin );
  1286. X    else
  1287. X        yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
  1288. X
  1289. X    yy_load_buffer_state();
  1290. X
  1291. X    yy_init = 0;
  1292. X    }
  1293. X
  1294. X    while ( 1 )        /* loops until end-of-file is reached */
  1295. X    {
  1296. X    yy_cp = yy_c_buf_p;
  1297. X
  1298. X    /* support of yytext */
  1299. X    *yy_cp = yy_hold_char;
  1300. X
  1301. X    /* yy_bp points to the position in yy_ch_buf of the start of the
  1302. X     * current run.
  1303. X     */
  1304. X    yy_bp = yy_cp;
  1305. X
  1306. X    yy_current_state = yy_start;
  1307. yy_match:
  1308. X    do
  1309. X        {
  1310. X        register YY_CHAR yy_c = yy_ec[*yy_cp];
  1311. X        if ( yy_accept[yy_current_state] )
  1312. X        {
  1313. X        yy_last_accepting_state = yy_current_state;
  1314. X        yy_last_accepting_cpos = yy_cp;
  1315. X        }
  1316. X        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  1317. X        {
  1318. X        yy_current_state = yy_def[yy_current_state];
  1319. X        if ( yy_current_state >= 141 )
  1320. X            yy_c = yy_meta[yy_c];
  1321. X        }
  1322. X        yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
  1323. X        ++yy_cp;
  1324. X        }
  1325. X    while ( yy_current_state != 140 );
  1326. X    yy_cp = yy_last_accepting_cpos;
  1327. X    yy_current_state = yy_last_accepting_state;
  1328. X
  1329. yy_find_action:
  1330. X    yy_act = yy_accept[yy_current_state];
  1331. X
  1332. X    YY_DO_BEFORE_ACTION;
  1333. X    YY_USER_ACTION;
  1334. X
  1335. do_action:    /* this label is used only to access EOF actions */
  1336. X
  1337. X
  1338. X    switch ( yy_act )
  1339. X        {
  1340. X        case 0: /* must backtrack */
  1341. X        /* undo the effects of YY_DO_BEFORE_ACTION */
  1342. X        *yy_cp = yy_hold_char;
  1343. X        yy_cp = yy_last_accepting_cpos;
  1344. X        yy_current_state = yy_last_accepting_state;
  1345. X        goto yy_find_action;
  1346. X
  1347. case 1:
  1348. # line 19 "b.l"
  1349. {
  1350. X            yynflexcalls += 1;
  1351. X        return STRING; 
  1352. X           }
  1353. X    YY_BREAK
  1354. case 2:
  1355. # line 26 "b.l"
  1356. {
  1357. X              yynflexcalls += 1;
  1358. X              return PREAMBLE; 
  1359. X             }
  1360. X    YY_BREAK
  1361. case 3:
  1362. # line 32 "b.l"
  1363. {
  1364. X                   yynflexcalls += 1;
  1365. X                   return ARTICLE;
  1366. X                  }
  1367. X    YY_BREAK
  1368. case 4:
  1369. # line 37 "b.l"
  1370. {
  1371. X                   yynflexcalls += 1;
  1372. X                   return BOOK;
  1373. X                  }
  1374. X    YY_BREAK
  1375. case 5:
  1376. # line 42 "b.l"
  1377. {
  1378. X                   yynflexcalls += 1;
  1379. X                   return BOOKLET;
  1380. X                  }
  1381. X    YY_BREAK
  1382. case 6:
  1383. # line 47 "b.l"
  1384. {
  1385. X                   yynflexcalls += 1;
  1386. X                   return CONFERENCE;
  1387. X                  }
  1388. X    YY_BREAK
  1389. case 7:
  1390. # line 52 "b.l"
  1391. {
  1392. X                   yynflexcalls += 1;
  1393. X                   return INBOOK;
  1394. X                  }
  1395. X    YY_BREAK
  1396. case 8:
  1397. # line 57 "b.l"
  1398. {
  1399. X                   yynflexcalls += 1;
  1400. X                   return INCOLLECTION;
  1401. X                  }
  1402. X    YY_BREAK
  1403. case 9:
  1404. # line 62 "b.l"
  1405. {
  1406. X                   yynflexcalls += 1;
  1407. X                   return INPROCEEDINGS;
  1408. X                  }
  1409. X    YY_BREAK
  1410. case 10:
  1411. # line 67 "b.l"
  1412. {
  1413. X                   yynflexcalls += 1;
  1414. X                   return MANUAL;
  1415. X                  }
  1416. X    YY_BREAK
  1417. case 11:
  1418. # line 72 "b.l"
  1419. {
  1420. X                   yynflexcalls += 1;
  1421. X                   return MASTERSTHESIS;
  1422. X                  }
  1423. X    YY_BREAK
  1424. case 12:
  1425. # line 77 "b.l"
  1426. {
  1427. X                   yynflexcalls += 1;
  1428. X                   return MISC;
  1429. X                  }
  1430. X    YY_BREAK
  1431. case 13:
  1432. # line 82 "b.l"
  1433. {
  1434. X                   yynflexcalls += 1;
  1435. X                   return PHDTHESIS;
  1436. X                  }
  1437. X    YY_BREAK
  1438. case 14:
  1439. # line 87 "b.l"
  1440. {
  1441. X                   yynflexcalls += 1;
  1442. X                   return PROCEEDINGS;
  1443. X                  }
  1444. X    YY_BREAK
  1445. case 15:
  1446. # line 92 "b.l"
  1447. {
  1448. X                   yynflexcalls += 1;
  1449. X                   return TECHREPORT;
  1450. X                  }
  1451. X    YY_BREAK
  1452. case 16:
  1453. # line 97 "b.l"
  1454. {
  1455. X                   yynflexcalls += 1;
  1456. X                   return UNPUBLISHED;
  1457. X                  }
  1458. X    YY_BREAK
  1459. case 17:
  1460. # line 102 "b.l"
  1461. {
  1462. X             yynflexcalls += 1;
  1463. X             yylval = yytext[0];
  1464. X             uebergabe[ueIdx] = yytext[0];
  1465. X             uebergabe[ueIdx+1] = '\0';
  1466. X             ueIdx++;
  1467. X             return ZAUN;
  1468. X           }
  1469. X    YY_BREAK
  1470. case 18:
  1471. # line 113 "b.l"
  1472. {
  1473. X             yynflexcalls += 1;
  1474. X             yylval = yytext[0];
  1475. X             uebergabe[ueIdx] = yytext[0];
  1476. X             uebergabe[ueIdx+1] = '\0';
  1477. X             ueIdx++;
  1478. X             return KOMMA;
  1479. X           }
  1480. X    YY_BREAK
  1481. case 19:
  1482. # line 123 "b.l"
  1483. {
  1484. X             yynflexcalls += 1;
  1485. X             yylval = yytext[0];
  1486. X             uebergabe[ueIdx] = yytext[0];
  1487. X             uebergabe[ueIdx+1] = '\0';
  1488. X             ueIdx++;
  1489. X             return LRKL;
  1490. X           }
  1491. X    YY_BREAK
  1492. case 20:
  1493. # line 133 "b.l"
  1494. {
  1495. X             yynflexcalls += 1;
  1496. X             yylval = yytext[0];
  1497. X             uebergabe[ueIdx] = yytext[0];
  1498. X             uebergabe[ueIdx+1] = '\0';
  1499. X             ueIdx++;
  1500. X             return RRKL;
  1501. X           }
  1502. X    YY_BREAK
  1503. case 21:
  1504. # line 143 "b.l"
  1505. {
  1506. X             yynflexcalls += 1;
  1507. X             yylval = yytext[0];
  1508. X             uebergabe[ueIdx] = yytext[0];
  1509. X             uebergabe[ueIdx+1] = '\0';
  1510. X             ueIdx++;
  1511. X             return LGKL;
  1512. X           }
  1513. X    YY_BREAK
  1514. case 22:
  1515. # line 153 "b.l"
  1516. {
  1517. X             yynflexcalls += 1;
  1518. X             yylval = yytext[0];
  1519. X             uebergabe[ueIdx] = yytext[0];
  1520. X             uebergabe[ueIdx+1] = '\0';
  1521. X             ueIdx++;
  1522. X             return RGKL;
  1523. X           }
  1524. X    YY_BREAK
  1525. case 23:
  1526. # line 163 "b.l"
  1527. {
  1528. X             yynflexcalls += 1;
  1529. X             yylval = yytext[0];
  1530. X             uebergabe[ueIdx] = yytext[0];
  1531. X             uebergabe[ueIdx+1] = '\0';
  1532. X             ueIdx++;
  1533. X             return EQ;
  1534. X           }
  1535. X    YY_BREAK
  1536. case 24:
  1537. # line 173 "b.l"
  1538. {
  1539. X             yynflexcalls += 1;
  1540. X             yylval = yytext[0];
  1541. X             uebergabe[ueIdx] = yytext[0];
  1542. X             uebergabe[ueIdx+1] = '\0';
  1543. X             ueIdx++;
  1544. X             return DAZ;
  1545. X           }
  1546. X    YY_BREAK
  1547. case 25:
  1548. # line 183 "b.l"
  1549. {
  1550. X             yynflexcalls += 1;
  1551. X             yylval = yytext[0];
  1552. X             uebergabe[ueIdx] = yytext[0];
  1553. X             uebergabe[ueIdx+1] = '\0';
  1554. X             ueIdx++;
  1555. X             if (yytext[0] == '\n') yynline += 1;
  1556. X             return WHITE_SPACE;
  1557. X           }
  1558. X    YY_BREAK
  1559. case 26:
  1560. # line 194 "b.l"
  1561. {
  1562. X               yynflexcalls += 1;
  1563. X               yylval = yytext[0];
  1564. X               uebergabe[ueIdx] = yytext[0];
  1565. X               uebergabe[ueIdx+1] = '\0';
  1566. X               ueIdx++;
  1567. X               return BUCHSTABE_ZAHL;
  1568. X             }
  1569. X    YY_BREAK
  1570. case YY_STATE_EOF(INITIAL):
  1571. # line 204 "b.l"
  1572. {
  1573. X           yynflexcalls += 1;
  1574. X           YY_NEW_FILE;
  1575. X  /*         uebergabe[0] = '\0'; */
  1576. X           ueIdx = 0;
  1577. X           return 0;
  1578. X         }
  1579. X    YY_BREAK
  1580. case 28:
  1581. # line 214 "b.l"
  1582. {
  1583. X             yynflexcalls += 1;
  1584. X             yylval = yytext[0];
  1585. X             uebergabe[ueIdx] = yytext[0];
  1586. X             uebergabe[ueIdx+1] = '\0';
  1587. X             ueIdx++;
  1588. X             return ZEICHEN;
  1589. X           }
  1590. X    YY_BREAK
  1591. case 29:
  1592. # line 225 "b.l"
  1593. ECHO;
  1594. X    YY_BREAK
  1595. X
  1596. X        case YY_END_OF_BUFFER:
  1597. X        {
  1598. X        /* amount of text matched not including the EOB char */
  1599. X        int yy_amount_of_matched_text = yy_cp - yytext - 1;
  1600. X
  1601. X        /* undo the effects of YY_DO_BEFORE_ACTION */
  1602. X        *yy_cp = yy_hold_char;
  1603. X
  1604. X        /* note that here we test for yy_c_buf_p "<=" to the position
  1605. X         * of the first EOB in the buffer, since yy_c_buf_p will
  1606. X         * already have been incremented past the NUL character
  1607. X         * (since all states make transitions on EOB to the end-
  1608. X         * of-buffer state).  Contrast this with the test in yyinput().
  1609. X         */
  1610. X        if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
  1611. X            /* this was really a NUL */
  1612. X            {
  1613. X            yy_state_type yy_next_state;
  1614. X
  1615. X            yy_c_buf_p = yytext + yy_amount_of_matched_text;
  1616. X
  1617. X            yy_current_state = yy_get_previous_state();
  1618. X
  1619. X            /* okay, we're now positioned to make the
  1620. X             * NUL transition.  We couldn't have
  1621. X             * yy_get_previous_state() go ahead and do it
  1622. X             * for us because it doesn't know how to deal
  1623. X             * with the possibility of jamming (and we
  1624. X             * don't want to build jamming into it because
  1625. X             * then it will run more slowly)
  1626. X             */
  1627. X
  1628. X            yy_next_state = yy_try_NUL_trans( yy_current_state );
  1629. X
  1630. X            yy_bp = yytext + YY_MORE_ADJ;
  1631. X
  1632. X            if ( yy_next_state )
  1633. X            {
  1634. X            /* consume the NUL */
  1635. X            yy_cp = ++yy_c_buf_p;
  1636. X            yy_current_state = yy_next_state;
  1637. X            goto yy_match;
  1638. X            }
  1639. X
  1640. X            else
  1641. X            {
  1642. X                yy_cp = yy_last_accepting_cpos;
  1643. X                yy_current_state = yy_last_accepting_state;
  1644. X            goto yy_find_action;
  1645. X            }
  1646. X            }
  1647. X
  1648. X        else switch ( yy_get_next_buffer() )
  1649. X            {
  1650. X            case EOB_ACT_END_OF_FILE:
  1651. X            {
  1652. X            yy_did_buffer_switch_on_eof = 0;
  1653. X
  1654. X            if ( yywrap() )
  1655. X                {
  1656. X                /* note: because we've taken care in
  1657. X                 * yy_get_next_buffer() to have set up yytext,
  1658. X                 * we can now set up yy_c_buf_p so that if some
  1659. X                 * total hoser (like flex itself) wants
  1660. X                 * to call the scanner after we return the
  1661. X                 * YY_NULL, it'll still work - another YY_NULL
  1662. X                 * will get returned.
  1663. X                 */
  1664. X                yy_c_buf_p = yytext + YY_MORE_ADJ;
  1665. X
  1666. X                yy_act = YY_STATE_EOF((yy_start - 1) / 2);
  1667. X                goto do_action;
  1668. X                }
  1669. X
  1670. X            else
  1671. X                {
  1672. X                if ( ! yy_did_buffer_switch_on_eof )
  1673. X                YY_NEW_FILE;
  1674. X                }
  1675. X            }
  1676. X            break;
  1677. X
  1678. X            case EOB_ACT_CONTINUE_SCAN:
  1679. X            yy_c_buf_p = yytext + yy_amount_of_matched_text;
  1680. X
  1681. X            yy_current_state = yy_get_previous_state();
  1682. X
  1683. X            yy_cp = yy_c_buf_p;
  1684. X            yy_bp = yytext + YY_MORE_ADJ;
  1685. X            goto yy_match;
  1686. X
  1687. X            case EOB_ACT_LAST_MATCH:
  1688. X            yy_c_buf_p =
  1689. X                &yy_current_buffer->yy_ch_buf[yy_n_chars];
  1690. X
  1691. X            yy_current_state = yy_get_previous_state();
  1692. X
  1693. X            yy_cp = yy_c_buf_p;
  1694. X            yy_bp = yytext + YY_MORE_ADJ;
  1695. X            goto yy_find_action;
  1696. X            }
  1697. X        break;
  1698. X        }
  1699. X
  1700. X        default:
  1701. #ifdef FLEX_DEBUG
  1702. X        printf( "action # %d\n", yy_act );
  1703. #endif
  1704. X        YY_FATAL_ERROR(
  1705. X            "fatal flex scanner internal error--no action found" );
  1706. X        }
  1707. X    }
  1708. X    }
  1709. X
  1710. X
  1711. /* yy_get_next_buffer - try to read in a new buffer
  1712. X *
  1713. X * synopsis
  1714. X *     int yy_get_next_buffer();
  1715. X *     
  1716. X * returns a code representing an action
  1717. X *     EOB_ACT_LAST_MATCH - 
  1718. X *     EOB_ACT_CONTINUE_SCAN - continue scanning from current position
  1719. X *     EOB_ACT_END_OF_FILE - end of file
  1720. X */
  1721. X
  1722. static int yy_get_next_buffer()
  1723. X
  1724. X    {
  1725. X    register YY_CHAR *dest = yy_current_buffer->yy_ch_buf;
  1726. X    register YY_CHAR *source = yytext - 1; /* copy prev. char, too */
  1727. X    register int number_to_move, i;
  1728. X    int ret_val;
  1729. X
  1730. X    if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
  1731. X    YY_FATAL_ERROR(
  1732. X        "fatal flex scanner internal error--end of buffer missed" );
  1733. X
  1734. X    /* try to read more data */
  1735. X
  1736. X    /* first move last chars to start of buffer */
  1737. X    number_to_move = yy_c_buf_p - yytext;
  1738. X
  1739. X    for ( i = 0; i < number_to_move; ++i )
  1740. X    *(dest++) = *(source++);
  1741. X
  1742. X    if ( yy_current_buffer->yy_eof_status != EOF_NOT_SEEN )
  1743. X    /* don't do the read, it's not guaranteed to return an EOF,
  1744. X     * just force an EOF
  1745. X     */
  1746. X    yy_n_chars = 0;
  1747. X
  1748. X    else
  1749. X    {
  1750. X    int num_to_read = yy_current_buffer->yy_buf_size - number_to_move - 1;
  1751. X
  1752. X    if ( num_to_read > YY_READ_BUF_SIZE )
  1753. X        num_to_read = YY_READ_BUF_SIZE;
  1754. X
  1755. X    else if ( num_to_read <= 0 )
  1756. X        YY_FATAL_ERROR( "fatal error - scanner input buffer overflow" );
  1757. X
  1758. X    /* read in more data */
  1759. X    YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
  1760. X          yy_n_chars, num_to_read );
  1761. X    }
  1762. X
  1763. X    if ( yy_n_chars == 0 )
  1764. X    {
  1765. X    if ( number_to_move == 1 )
  1766. X        {
  1767. X        ret_val = EOB_ACT_END_OF_FILE;
  1768. X        yy_current_buffer->yy_eof_status = EOF_DONE;
  1769. X        }
  1770. X
  1771. X    else
  1772. X        {
  1773. X        ret_val = EOB_ACT_LAST_MATCH;
  1774. X        yy_current_buffer->yy_eof_status = EOF_PENDING;
  1775. X        }
  1776. X    }
  1777. X
  1778. X    else
  1779. X    ret_val = EOB_ACT_CONTINUE_SCAN;
  1780. X
  1781. X    yy_n_chars += number_to_move;
  1782. X    yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
  1783. X    yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
  1784. X
  1785. X    /* yytext begins at the second character in yy_ch_buf; the first
  1786. X     * character is the one which preceded it before reading in the latest
  1787. X     * buffer; it needs to be kept around in case it's a newline, so
  1788. X     * yy_get_previous_state() will have with '^' rules active
  1789. X     */
  1790. X
  1791. X    yytext = &yy_current_buffer->yy_ch_buf[1];
  1792. X
  1793. X    return ( ret_val );
  1794. X    }
  1795. X
  1796. X
  1797. /* yy_get_previous_state - get the state just before the EOB char was reached
  1798. X *
  1799. X * synopsis
  1800. X *     yy_state_type yy_get_previous_state();
  1801. X */
  1802. X
  1803. static yy_state_type yy_get_previous_state()
  1804. X
  1805. X    {
  1806. X    register yy_state_type yy_current_state;
  1807. X    register YY_CHAR *yy_cp;
  1808. X
  1809. X    yy_current_state = yy_start;
  1810. X
  1811. X    for ( yy_cp = yytext + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
  1812. X    {
  1813. X    register YY_CHAR yy_c = (*yy_cp ? yy_ec[*yy_cp] : 1);
  1814. X    if ( yy_accept[yy_current_state] )
  1815. X        {
  1816. X        yy_last_accepting_state = yy_current_state;
  1817. X        yy_last_accepting_cpos = yy_cp;
  1818. X        }
  1819. X    while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  1820. X        {
  1821. X        yy_current_state = yy_def[yy_current_state];
  1822. X        if ( yy_current_state >= 141 )
  1823. X        yy_c = yy_meta[yy_c];
  1824. X        }
  1825. X    yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
  1826. X    }
  1827. X
  1828. X    return ( yy_current_state );
  1829. X    }
  1830. X
  1831. X
  1832. /* yy_try_NUL_trans - try to make a transition on the NUL character
  1833. X *
  1834. X * synopsis
  1835. X *     next_state = yy_try_NUL_trans( current_state );
  1836. X */
  1837. X
  1838. #ifdef YY_USE_PROTOS
  1839. static yy_state_type yy_try_NUL_trans( register yy_state_type yy_current_state )
  1840. #else
  1841. static yy_state_type yy_try_NUL_trans( yy_current_state )
  1842. register yy_state_type yy_current_state;
  1843. #endif
  1844. X
  1845. X    {
  1846. X    register int yy_is_jam;
  1847. X    register YY_CHAR *yy_cp = yy_c_buf_p;
  1848. X
  1849. X    register YY_CHAR yy_c = 1;
  1850. X    if ( yy_accept[yy_current_state] )
  1851. X    {
  1852. X    yy_last_accepting_state = yy_current_state;
  1853. X    yy_last_accepting_cpos = yy_cp;
  1854. X    }
  1855. X    while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  1856. X    {
  1857. X    yy_current_state = yy_def[yy_current_state];
  1858. X    if ( yy_current_state >= 141 )
  1859. X        yy_c = yy_meta[yy_c];
  1860. X    }
  1861. X    yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
  1862. X    yy_is_jam = (yy_current_state == 140);
  1863. X
  1864. X    return ( yy_is_jam ? 0 : yy_current_state );
  1865. X    }
  1866. X
  1867. X
  1868. #ifdef YY_USE_PROTOS
  1869. static void yyunput( YY_CHAR c, register YY_CHAR *yy_bp )
  1870. #else
  1871. static void yyunput( c, yy_bp )
  1872. YY_CHAR c;
  1873. register YY_CHAR *yy_bp;
  1874. #endif
  1875. X
  1876. X    {
  1877. X    register YY_CHAR *yy_cp = yy_c_buf_p;
  1878. X
  1879. X    /* undo effects of setting up yytext */
  1880. X    *yy_cp = yy_hold_char;
  1881. X
  1882. X    if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
  1883. SHAR_EOF
  1884. true || echo 'restore of bib_flex.c failed'
  1885. fi
  1886. echo 'End of  part 4'
  1887. echo 'File bib_flex.c is continued in part 5'
  1888. echo 5 > _shar_seq_.tmp
  1889. exit 0
  1890. -- 
  1891. Senior Systems Scientist        mail: dcmartin@msi.com
  1892. Molecular Simulations, Inc.        uucp: uunet!dcmartin
  1893. 796 North Pastoria Avenue        at&t: 408/522-9236
  1894. Sunnyvale, California 94086        fax: 408/732-0831
  1895.