home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume44 / c++2latex / part05 < prev    next >
Internet Message Format  |  1994-08-07  |  61KB
  1. From: joke@germany.eu.net (Joerg Heitkoetter)
  2. Newsgroups: comp.sources.misc
  3. Subject: v44i014:  c++2latex - A set of LaTeX converters for the whole C family, v3.0, Part05/08
  4. Date: 7 Aug 1994 16:43:13 -0500
  5. Organization: Sterling Software
  6. Sender: kent@sparky.sterling.com
  7. Approved: kent@sparky.sterling.com
  8. Message-ID: <323khh$gmk@sparky.sterling.com>
  9. X-Md4-Signature: 3fb676ef526224c6ceffd9a1432eb362
  10.  
  11. Submitted-by: joke@germany.eu.net (Joerg Heitkoetter)
  12. Posting-number: Volume 44, Issue 14
  13. Archive-name: c++2latex/part05
  14. Environment: UNIX, Flex, LaTeX, Sun
  15.  
  16. #! /bin/sh
  17. # This is a shell archive.  Remove anything before this line, then feed it
  18. # into a shell via "sh file" or similar.  To overwrite existing files,
  19. # type "sh file -c".
  20. # Contents:  docs/sample.c src/c++2latex.c.B src/c++2latex.l
  21. #   src/objc2latex.c.B
  22. # Wrapped by kent@sparky on Sun Aug  7 16:11:53 1994
  23. PATH=/bin:/usr/bin:/usr/ucb:/usr/local/bin:/usr/lbin:$PATH ; export PATH
  24. echo If this archive is complete, you will see the following message:
  25. echo '          "shar: End of archive 5 (of 8)."'
  26. if test -f 'docs/sample.c' -a "${1}" != "-c" ; then 
  27.   echo shar: Will not clobber existing file \"'docs/sample.c'\"
  28. else
  29.   echo shar: Extracting \"'docs/sample.c'\" \(1714 characters\)
  30.   sed "s/^X//" >'docs/sample.c' <<'END_OF_FILE'
  31. X//
  32. X//  Copyright (c) 1991-1994 University of Dortmund
  33. X//
  34. X//  Permission to use, copy, modify, distribute, and sell this software and its
  35. X//  documentation for any purpose is hereby granted without fee, provided
  36. X//  that the above copyright notice appear in all copies and that both that
  37. X//  copyright notice and this permission notice appear in supporting
  38. X//  documentation, and that the name of UNIDO not be used in advertising or
  39. X//  publicity pertaining to distribution of the software without specific,
  40. X//  written prior permission.  UNIDO makes no representations about
  41. X//  the suitability of this software for any purpose.  It is provided "as is"
  42. X//  without express or implied warranty.
  43. X//
  44. X//  UNIDO DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  45. X//  INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
  46. X//  IN NO EVENT SHALL UNIDO BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  47. X//  CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
  48. X//  FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
  49. X//  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  50. X//  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  51. X//
  52. X
  53. X/*
  54. X *    this is a comment
  55. X */
  56. X
  57. X#include <stdio.h>
  58. X
  59. X#define FATAL(X)    {printf(#X); exit(1);}
  60. X#define TEMP (i)    temp ## i
  61. X
  62. X/* NOARGS */
  63. Xmain (argc, argv)
  64. Xint argc;
  65. Xchar **argv;
  66. X{
  67. X    int a; // this is a variable
  68. X    int b; /* another variable */
  69. X
  70. X    // busy doing nothing...
  71. X    int c;
  72. X
  73. X        /* no more */
  74. X    int d;
  75. X
  76. X    switch (something) {
  77. X        case THISCASE:
  78. X            something = 99; // who knows why?
  79. X            break;
  80. X        case default:
  81. X            somethingelse = 100; // completetly arbitrary
  82. X            break;
  83. X    } // end of switch
  84. X
  85. X    for (i=0; i<j; i++) {
  86. X    } /* loop */
  87. X
  88. X    return (0);
  89. X} /* end of main */
  90. END_OF_FILE
  91.   if test 1714 -ne `wc -c <'docs/sample.c'`; then
  92.     echo shar: \"'docs/sample.c'\" unpacked with wrong size!
  93.   fi
  94.   # end of 'docs/sample.c'
  95. fi
  96. if test -f 'src/c++2latex.c.B' -a "${1}" != "-c" ; then 
  97.   echo shar: Will not clobber existing file \"'src/c++2latex.c.B'\"
  98. else
  99.   echo shar: Extracting \"'src/c++2latex.c.B'\" \(24230 characters\)
  100.   sed "s/^X//" >'src/c++2latex.c.B' <<'END_OF_FILE'
  101. X# line 87 "src/c++2latex.l"
  102. Xcase 62:
  103. X# line 88 "src/c++2latex.l"
  104. Xcase 63:
  105. X# line 89 "src/c++2latex.l"
  106. Xcase 64:
  107. X# line 90 "src/c++2latex.l"
  108. Xcase 65:
  109. X# line 91 "src/c++2latex.l"
  110. Xcase 66:
  111. X# line 92 "src/c++2latex.l"
  112. Xcase 67:
  113. X# line 93 "src/c++2latex.l"
  114. Xcase 68:
  115. X# line 94 "src/c++2latex.l"
  116. Xcase 69:
  117. X# line 95 "src/c++2latex.l"
  118. Xcase 70:
  119. X# line 96 "src/c++2latex.l"
  120. Xcase 71:
  121. X# line 97 "src/c++2latex.l"
  122. Xcase 72:
  123. X# line 98 "src/c++2latex.l"
  124. Xcase 73:
  125. X# line 99 "src/c++2latex.l"
  126. Xcase 74:
  127. X# line 100 "src/c++2latex.l"
  128. Xcase 75:
  129. X# line 101 "src/c++2latex.l"
  130. Xcase 76:
  131. X# line 102 "src/c++2latex.l"
  132. Xcase 77:
  133. X# line 103 "src/c++2latex.l"
  134. Xcase 78:
  135. XYY_USER_ACTION
  136. X# line 103 "src/c++2latex.l"
  137. XKEY;
  138. X    YY_BREAK
  139. Xcase 79:
  140. XYY_USER_ACTION
  141. X# line 106 "src/c++2latex.l"
  142. XSYM ("rightarrow");
  143. X    YY_BREAK
  144. Xcase 80:
  145. XYY_USER_ACTION
  146. X# line 107 "src/c++2latex.l"
  147. XSYM ("ll");
  148. X    YY_BREAK
  149. Xcase 81:
  150. XYY_USER_ACTION
  151. X# line 108 "src/c++2latex.l"
  152. XSYM ("gg");
  153. X    YY_BREAK
  154. Xcase 82:
  155. XYY_USER_ACTION
  156. X# line 109 "src/c++2latex.l"
  157. XSYM ("leq");
  158. X    YY_BREAK
  159. Xcase 83:
  160. XYY_USER_ACTION
  161. X# line 110 "src/c++2latex.l"
  162. XSYM ("geq");
  163. X    YY_BREAK
  164. Xcase 84:
  165. XYY_USER_ACTION
  166. X# line 111 "src/c++2latex.l"
  167. XSYM ("neq");
  168. X    YY_BREAK
  169. Xcase 85:
  170. XYY_USER_ACTION
  171. X# line 112 "src/c++2latex.l"
  172. XSYM ("mid\\mid");
  173. X    YY_BREAK
  174. Xcase 86:
  175. XYY_USER_ACTION
  176. X# line 113 "src/c++2latex.l"
  177. XSYM ("ldots");
  178. X    YY_BREAK
  179. Xcase 87:
  180. XYY_USER_ACTION
  181. X# line 114 "src/c++2latex.l"
  182. XSYM ("ast=");
  183. X    YY_BREAK
  184. Xcase 88:
  185. XYY_USER_ACTION
  186. X# line 115 "src/c++2latex.l"
  187. XSYM ("ll=");
  188. X    YY_BREAK
  189. Xcase 89:
  190. XYY_USER_ACTION
  191. X# line 116 "src/c++2latex.l"
  192. XSYM ("gg=");
  193. X    YY_BREAK
  194. Xcase 90:
  195. XYY_USER_ACTION
  196. X# line 117 "src/c++2latex.l"
  197. XSYM ("vee=");
  198. X    YY_BREAK
  199. Xcase 91:
  200. XYY_USER_ACTION
  201. X# line 118 "src/c++2latex.l"
  202. XSYM ("mid=");
  203. X    YY_BREAK
  204. Xcase 92:
  205. XYY_USER_ACTION
  206. X# line 119 "src/c++2latex.l"
  207. XSYM ("sim");
  208. X    YY_BREAK
  209. Xcase 93:
  210. XYY_USER_ACTION
  211. X# line 120 "src/c++2latex.l"
  212. XSYM ("ast");
  213. X    YY_BREAK
  214. Xcase 94:
  215. XYY_USER_ACTION
  216. X# line 121 "src/c++2latex.l"
  217. XSYM ("wedge");
  218. X    YY_BREAK
  219. Xcase 95:
  220. XYY_USER_ACTION
  221. X# line 122 "src/c++2latex.l"
  222. XSYM ("mid");
  223. X    YY_BREAK
  224. Xcase 96:
  225. XYY_USER_ACTION
  226. X# line 123 "src/c++2latex.l"
  227. XSYM ("rightarrow\\ast");
  228. X    YY_BREAK
  229. Xcase 97:
  230. XYY_USER_ACTION
  231. X# line 124 "src/c++2latex.l"
  232. XOUT ("$/$");
  233. X    YY_BREAK
  234. Xcase 98:
  235. XYY_USER_ACTION
  236. X# line 125 "src/c++2latex.l"
  237. XOUT ("$<$");
  238. X    YY_BREAK
  239. Xcase 99:
  240. XYY_USER_ACTION
  241. X# line 126 "src/c++2latex.l"
  242. XOUT ("$>$");
  243. X    YY_BREAK
  244. Xcase 100:
  245. XYY_USER_ACTION
  246. X# line 127 "src/c++2latex.l"
  247. XOUT ("\\&\\&");
  248. X    YY_BREAK
  249. Xcase 101:
  250. XYY_USER_ACTION
  251. X# line 128 "src/c++2latex.l"
  252. XOUT ("\\%=");
  253. X    YY_BREAK
  254. Xcase 102:
  255. XYY_USER_ACTION
  256. X# line 129 "src/c++2latex.l"
  257. XOUT ("\\&=");
  258. X    YY_BREAK
  259. Xcase 103:
  260. XYY_USER_ACTION
  261. X# line 130 "src/c++2latex.l"
  262. XOUT ("\\{");
  263. X    YY_BREAK
  264. Xcase 104:
  265. XYY_USER_ACTION
  266. X# line 131 "src/c++2latex.l"
  267. XOUT ("\\}");
  268. X    YY_BREAK
  269. Xcase 105:
  270. XYY_USER_ACTION
  271. X# line 132 "src/c++2latex.l"
  272. XOUT ("\\&");
  273. X    YY_BREAK
  274. Xcase 106:
  275. XYY_USER_ACTION
  276. X# line 133 "src/c++2latex.l"
  277. XOUT ("\\%");
  278. X    YY_BREAK
  279. Xcase 107:
  280. XYY_USER_ACTION
  281. X# line 134 "src/c++2latex.l"
  282. XOUT ("-{}-");
  283. X    YY_BREAK
  284. Xcase 108:
  285. XYY_USER_ACTION
  286. X# line 135 "src/c++2latex.l"
  287. XOUT (".$\\ast$");
  288. X    YY_BREAK
  289. Xcase 109:
  290. X# line 137 "src/c++2latex.l"
  291. Xcase 110:
  292. X# line 138 "src/c++2latex.l"
  293. Xcase 111:
  294. X# line 139 "src/c++2latex.l"
  295. Xcase 112:
  296. X# line 140 "src/c++2latex.l"
  297. Xcase 113:
  298. X# line 141 "src/c++2latex.l"
  299. Xcase 114:
  300. X# line 142 "src/c++2latex.l"
  301. Xcase 115:
  302. X# line 143 "src/c++2latex.l"
  303. Xcase 116:
  304. X# line 144 "src/c++2latex.l"
  305. Xcase 117:
  306. X# line 145 "src/c++2latex.l"
  307. Xcase 118:
  308. X# line 146 "src/c++2latex.l"
  309. Xcase 119:
  310. X# line 147 "src/c++2latex.l"
  311. Xcase 120:
  312. X# line 148 "src/c++2latex.l"
  313. Xcase 121:
  314. X# line 149 "src/c++2latex.l"
  315. Xcase 122:
  316. X# line 150 "src/c++2latex.l"
  317. Xcase 123:
  318. X# line 151 "src/c++2latex.l"
  319. Xcase 124:
  320. X# line 152 "src/c++2latex.l"
  321. Xcase 125:
  322. X# line 153 "src/c++2latex.l"
  323. Xcase 126:
  324. X# line 154 "src/c++2latex.l"
  325. Xcase 127:
  326. XYY_USER_ACTION
  327. X# line 154 "src/c++2latex.l"
  328. XECHO;
  329. X    YY_BREAK
  330. X /*    identifiers: may contain $ chars */
  331. Xcase 128:
  332. XYY_USER_ACTION
  333. X# line 158 "src/c++2latex.l"
  334. XSUB (yytext);
  335. X    YY_BREAK
  336. X /*    1.   Asterisk comments mini scanner */
  337. X /*    1.1. Curly  brace comment */
  338. Xcase 129:
  339. XYY_USER_ACTION
  340. X# line 163 "src/c++2latex.l"
  341. X{ BEGIN (ASTCOMMENT);
  342. X                                OUT ("\\}");
  343. X                                BTAB;
  344. X                                FONT (comment_font);
  345. X                                OUT ("/$\\ast$"); }
  346. X    YY_BREAK
  347. X /*    1.2. Comments at the beginning of a line */
  348. Xcase 130:
  349. XYY_USER_ACTION
  350. X# line 170 "src/c++2latex.l"
  351. X{ BEGIN (ASTCOMMENT);
  352. X                FONT (comment_font);
  353. X                                REPARSE; }
  354. X    YY_BREAK
  355. X /*    1.3. Other comments, aligned to right side of paper */
  356. Xcase 131:
  357. XYY_USER_ACTION
  358. X# line 175 "src/c++2latex.l"
  359. X{ BEGIN (ASTCOMMENT);
  360. X                                if (aligntoright) {
  361. X                    OUT ("\\hfill");
  362. X                } else {
  363. X                    CTAB;
  364. X                }
  365. X                FONT (comment_font);
  366. X                                OUT ("/$\\ast$"); }
  367. X    YY_BREAK
  368. Xcase 132:
  369. XYY_USER_ACTION
  370. X# line 184 "src/c++2latex.l"
  371. X{ INIT; OUT ("$\\ast$/}"); }
  372. X    YY_BREAK
  373. Xcase 133:
  374. XYY_USER_ACTION
  375. X# line 185 "src/c++2latex.l"
  376. X{ OUT ("}\\mbox{}\\\\\n"); FONT (comment_font); }
  377. X    YY_BREAK
  378. Xcase 134:
  379. XYY_USER_ACTION
  380. X# line 186 "src/c++2latex.l"
  381. XIND;
  382. X    YY_BREAK
  383. Xcase 135:
  384. XYY_USER_ACTION
  385. X# line 187 "src/c++2latex.l"
  386. XSUB (yytext);
  387. X    YY_BREAK
  388. X /*    2.   Double slash ``//'' comments mini scanner */
  389. X /*    2.1. Curly brace comment */
  390. Xcase 136:
  391. XYY_USER_ACTION
  392. X# line 191 "src/c++2latex.l"
  393. X{ BEGIN (SLASHCOMMENT);
  394. X                                OUT ("\\}");
  395. X                                BTAB;
  396. X                FONT (comment_font);
  397. X                                OUT ("//");}
  398. X    YY_BREAK
  399. X /*    2.2. Complete line comment */
  400. Xcase 137:
  401. XYY_USER_ACTION
  402. X# line 198 "src/c++2latex.l"
  403. X{ BEGIN (SLASHCOMMENT);
  404. X                                FONT (comment_font);
  405. X                REPARSE; }
  406. X    YY_BREAK
  407. X /*    2.3. Other comments */
  408. Xcase 138:
  409. XYY_USER_ACTION
  410. X# line 203 "src/c++2latex.l"
  411. X{ BEGIN (SLASHCOMMENT);
  412. X                                if (aligntoright) {
  413. X                    OUT ("\\hfill");
  414. X                } else {
  415. X                    CTAB;
  416. X                }
  417. X                FONT (comment_font);
  418. X                                OUT ("//"); }
  419. X    YY_BREAK
  420. Xcase 139:
  421. XYY_USER_ACTION
  422. X# line 212 "src/c++2latex.l"
  423. X{ INIT; OUT ("}\\mbox{}\\\\\n"); }
  424. X    YY_BREAK
  425. Xcase 140:
  426. XYY_USER_ACTION
  427. X# line 213 "src/c++2latex.l"
  428. XIND;
  429. X    YY_BREAK
  430. Xcase 141:
  431. XYY_USER_ACTION
  432. X# line 214 "src/c++2latex.l"
  433. XSUB (yytext);
  434. X    YY_BREAK
  435. Xcase 142:
  436. XYY_USER_ACTION
  437. X# line 217 "src/c++2latex.l"
  438. X{ BEGIN (STRING);
  439. X                FONT (string_font); OUT ("\""); }
  440. X    YY_BREAK
  441. Xcase 143:
  442. XYY_USER_ACTION
  443. X# line 219 "src/c++2latex.l"
  444. XOUT ("$\\backslash\\backslash$");
  445. X    YY_BREAK
  446. Xcase 144:
  447. XYY_USER_ACTION
  448. X# line 220 "src/c++2latex.l"
  449. X{ OUT ("$\\backslash$"); SUB (yytext+1); }
  450. X    YY_BREAK
  451. Xcase 145:
  452. XYY_USER_ACTION
  453. X# line 221 "src/c++2latex.l"
  454. X{ INIT; OUT ("\"}"); }
  455. X    YY_BREAK
  456. Xcase 146:
  457. XYY_USER_ACTION
  458. X# line 222 "src/c++2latex.l"
  459. XOUT ("\\mbox{}\\\\\n");
  460. X    YY_BREAK
  461. Xcase 147:
  462. XYY_USER_ACTION
  463. X# line 223 "src/c++2latex.l"
  464. XIND;
  465. X    YY_BREAK
  466. Xcase 148:
  467. XYY_USER_ACTION
  468. X# line 224 "src/c++2latex.l"
  469. XSUB (yytext);
  470. X    YY_BREAK
  471. Xcase 149:
  472. XYY_USER_ACTION
  473. X# line 226 "src/c++2latex.l"
  474. XECHO;
  475. X    YY_BREAK
  476. Xcase 150:
  477. XYY_USER_ACTION
  478. X# line 228 "src/c++2latex.l"
  479. XECHO;
  480. X    YY_BREAK
  481. Xcase 151:
  482. X# line 231 "src/c++2latex.l"
  483. Xcase 152:
  484. X# line 232 "src/c++2latex.l"
  485. Xcase 153:
  486. X# line 233 "src/c++2latex.l"
  487. Xcase 154:
  488. XYY_USER_ACTION
  489. X# line 233 "src/c++2latex.l"
  490. XECHO;
  491. X    YY_BREAK
  492. Xcase 155:
  493. XYY_USER_ACTION
  494. X# line 235 "src/c++2latex.l"
  495. XECHO;
  496. X    YY_BREAK
  497. Xcase 156:
  498. X# line 238 "src/c++2latex.l"
  499. Xcase 157:
  500. X# line 239 "src/c++2latex.l"
  501. Xcase 158:
  502. X# line 240 "src/c++2latex.l"
  503. Xcase 159:
  504. XYY_USER_ACTION
  505. X# line 240 "src/c++2latex.l"
  506. XSUB (yytext);
  507. X    YY_BREAK
  508. Xcase 160:
  509. XYY_USER_ACTION
  510. X# line 243 "src/c++2latex.l"
  511. XOUT ("$\\backslash$\\\\\n");
  512. X    YY_BREAK
  513. Xcase 161:
  514. XYY_USER_ACTION
  515. X# line 244 "src/c++2latex.l"
  516. XIND;
  517. X    YY_BREAK
  518. Xcase 162:
  519. XYY_USER_ACTION
  520. X# line 245 "src/c++2latex.l"
  521. XECHO;
  522. X    YY_BREAK
  523. Xcase 163:
  524. XYY_USER_ACTION
  525. X# line 246 "src/c++2latex.l"
  526. XOUT ("\\newpage\n");
  527. X    YY_BREAK
  528. Xcase 164:
  529. XYY_USER_ACTION
  530. X# line 247 "src/c++2latex.l"
  531. XOUT ("\\mbox{}\\\\\n");
  532. X    YY_BREAK
  533. Xcase 165:
  534. XYY_USER_ACTION
  535. X# line 248 "src/c++2latex.l"
  536. XECHO;
  537. X    YY_BREAK
  538. Xcase YY_STATE_EOF(INITIAL):
  539. Xcase YY_STATE_EOF(STRING):
  540. Xcase YY_STATE_EOF(INCLUDE):
  541. Xcase YY_STATE_EOF(ASTCOMMENT):
  542. Xcase YY_STATE_EOF(SLASHCOMMENT):
  543. X    yyterminate();
  544. X
  545. X    case YY_END_OF_BUFFER:
  546. X        {
  547. X        /* Amount of text matched not including the EOB char. */
  548. X        int yy_amount_of_matched_text = yy_cp - yytext_ptr - 1;
  549. X
  550. X        /* Undo the effects of YY_DO_BEFORE_ACTION. */
  551. X        *yy_cp = yy_hold_char;
  552. X
  553. X        if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
  554. X            {
  555. X            /* We're scanning a new file or input source.  It's
  556. X             * possible that this happened because the user
  557. X             * just pointed yyin at a new source and called
  558. X             * yylex().  If so, then we have to assure
  559. X             * consistency between yy_current_buffer and our
  560. X             * globals.  Here is the right place to do so, because
  561. X             * this is the first action (other than possibly a
  562. X             * back-up) that will match for the new input source.
  563. X             */
  564. X            yy_n_chars = yy_current_buffer->yy_n_chars;
  565. X            yy_current_buffer->yy_input_file = yyin;
  566. X            yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
  567. X            }
  568. X
  569. X        /* Note that here we test for yy_c_buf_p "<=" to the position
  570. X         * of the first EOB in the buffer, since yy_c_buf_p will
  571. X         * already have been incremented past the NUL character
  572. X         * (since all states make transitions on EOB to the
  573. X         * end-of-buffer state).  Contrast this with the test
  574. X         * in input().
  575. X         */
  576. X        if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
  577. X            { /* This was really a NUL. */
  578. X            yy_state_type yy_next_state;
  579. X
  580. X            yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
  581. X
  582. X            yy_current_state = yy_get_previous_state();
  583. X
  584. X            /* Okay, we're now positioned to make the NUL
  585. X             * transition.  We couldn't have
  586. X             * yy_get_previous_state() go ahead and do it
  587. X             * for us because it doesn't know how to deal
  588. X             * with the possibility of jamming (and we don't
  589. X             * want to build jamming into it because then it
  590. X             * will run more slowly).
  591. X             */
  592. X
  593. X            yy_next_state = yy_try_NUL_trans( yy_current_state );
  594. X
  595. X            yy_bp = yytext_ptr + YY_MORE_ADJ;
  596. X
  597. X            if ( yy_next_state )
  598. X                {
  599. X                /* Consume the NUL. */
  600. X                yy_cp = ++yy_c_buf_p;
  601. X                yy_current_state = yy_next_state;
  602. X                goto yy_match;
  603. X                }
  604. X
  605. X            else
  606. X                {
  607. X                            yy_cp = yy_c_buf_p;
  608. X                goto yy_find_action;
  609. X                }
  610. X            }
  611. X
  612. X        else switch ( yy_get_next_buffer() )
  613. X            {
  614. X            case EOB_ACT_END_OF_FILE:
  615. X                {
  616. X                yy_did_buffer_switch_on_eof = 0;
  617. X
  618. X                if ( yywrap() )
  619. X                    {
  620. X                    /* Note: because we've taken care in
  621. X                     * yy_get_next_buffer() to have set up
  622. X                     * yytext, we can now set up
  623. X                     * yy_c_buf_p so that if some total
  624. X                     * hoser (like flex itself) wants to
  625. X                     * call the scanner after we return the
  626. X                     * YY_NULL, it'll still work - another
  627. X                     * YY_NULL will get returned.
  628. X                     */
  629. X                    yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
  630. X
  631. X                    yy_act = YY_STATE_EOF(YY_START);
  632. X                    goto do_action;
  633. X                    }
  634. X
  635. X                else
  636. X                    {
  637. X                    if ( ! yy_did_buffer_switch_on_eof )
  638. X                        YY_NEW_FILE;
  639. X                    }
  640. X                break;
  641. X                }
  642. X
  643. X            case EOB_ACT_CONTINUE_SCAN:
  644. X                yy_c_buf_p =
  645. X                    yytext_ptr + yy_amount_of_matched_text;
  646. X
  647. X                yy_current_state = yy_get_previous_state();
  648. X
  649. X                yy_cp = yy_c_buf_p;
  650. X                yy_bp = yytext_ptr + YY_MORE_ADJ;
  651. X                goto yy_match;
  652. X
  653. X            case EOB_ACT_LAST_MATCH:
  654. X                yy_c_buf_p =
  655. X                &yy_current_buffer->yy_ch_buf[yy_n_chars];
  656. X
  657. X                yy_current_state = yy_get_previous_state();
  658. X
  659. X                yy_cp = yy_c_buf_p;
  660. X                yy_bp = yytext_ptr + YY_MORE_ADJ;
  661. X                goto yy_find_action;
  662. X            }
  663. X        break;
  664. X        }
  665. X
  666. X    default:
  667. X        YY_FATAL_ERROR(
  668. X            "fatal flex scanner internal error--no action found" );
  669. X    } /* end of action switch */
  670. X        } /* end of scanning one token */
  671. X    } /* end of yylex */
  672. X
  673. X
  674. X/* yy_get_next_buffer - try to read in a new buffer
  675. X *
  676. X * Returns a code representing an action:
  677. X *    EOB_ACT_LAST_MATCH -
  678. X *    EOB_ACT_CONTINUE_SCAN - continue scanning from current position
  679. X *    EOB_ACT_END_OF_FILE - end of file
  680. X */
  681. X
  682. Xstatic int yy_get_next_buffer()
  683. X    {
  684. X    register char *dest = yy_current_buffer->yy_ch_buf;
  685. X    register char *source = yytext_ptr - 1; /* copy prev. char, too */
  686. X    register int number_to_move, i;
  687. X    int ret_val;
  688. X
  689. X    if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
  690. X        YY_FATAL_ERROR(
  691. X        "fatal flex scanner internal error--end of buffer missed" );
  692. X
  693. X    if ( yy_current_buffer->yy_fill_buffer == 0 )
  694. X        { /* Don't try to fill the buffer, so this is an EOF. */
  695. X        if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
  696. X            {
  697. X            /* We matched a singled characater, the EOB, so
  698. X             * treat this as a final EOF.
  699. X             */
  700. X            return EOB_ACT_END_OF_FILE;
  701. X            }
  702. X
  703. X        else
  704. X            {
  705. X            /* We matched some text prior to the EOB, first
  706. X             * process it.
  707. X             */
  708. X            return EOB_ACT_LAST_MATCH;
  709. X            }
  710. X        }
  711. X
  712. X    /* Try to read more data. */
  713. X
  714. X    /* First move last chars to start of buffer. */
  715. X    number_to_move = yy_c_buf_p - yytext_ptr;
  716. X
  717. X    for ( i = 0; i < number_to_move; ++i )
  718. X        *(dest++) = *(source++);
  719. X
  720. X    if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
  721. X        /* don't do the read, it's not guaranteed to return an EOF,
  722. X         * just force an EOF
  723. X         */
  724. X        yy_n_chars = 0;
  725. X
  726. X    else
  727. X        {
  728. X        int num_to_read =
  729. X            yy_current_buffer->yy_buf_size - number_to_move - 1;
  730. X
  731. X        while ( num_to_read <= 0 )
  732. X            { /* Not enough room in the buffer - grow it. */
  733. X#ifdef YY_USES_REJECT
  734. X            YY_FATAL_ERROR(
  735. X"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
  736. X#else
  737. X
  738. X            /* just a shorter name for the current buffer */
  739. X            YY_BUFFER_STATE b = yy_current_buffer;
  740. X
  741. X            int yy_c_buf_p_offset = yy_c_buf_p - b->yy_ch_buf;
  742. X
  743. X            b->yy_buf_size *= 2;
  744. X            b->yy_ch_buf = (char *)
  745. X                yy_flex_realloc( (void *) b->yy_ch_buf,
  746. X                         b->yy_buf_size );
  747. X
  748. X            if ( ! b->yy_ch_buf )
  749. X                YY_FATAL_ERROR(
  750. X                "fatal error - scanner input buffer overflow" );
  751. X
  752. X            yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
  753. X
  754. X            num_to_read = yy_current_buffer->yy_buf_size -
  755. X                        number_to_move - 1;
  756. X#endif
  757. X            }
  758. X
  759. X        if ( num_to_read > YY_READ_BUF_SIZE )
  760. X            num_to_read = YY_READ_BUF_SIZE;
  761. X
  762. X        /* Read in more data. */
  763. X        YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
  764. X            yy_n_chars, num_to_read );
  765. X        }
  766. X
  767. X    if ( yy_n_chars == 0 )
  768. X        {
  769. X        if ( number_to_move - YY_MORE_ADJ == 1 )
  770. X            {
  771. X            ret_val = EOB_ACT_END_OF_FILE;
  772. X            yyrestart( yyin );
  773. X            }
  774. X
  775. X        else
  776. X            {
  777. X            ret_val = EOB_ACT_LAST_MATCH;
  778. X            yy_current_buffer->yy_buffer_status =
  779. X                YY_BUFFER_EOF_PENDING;
  780. X            }
  781. X        }
  782. X
  783. X    else
  784. X        ret_val = EOB_ACT_CONTINUE_SCAN;
  785. X
  786. X    yy_n_chars += number_to_move;
  787. X    yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
  788. X    yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
  789. X
  790. X    /* yytext begins at the second character in yy_ch_buf; the first
  791. X     * character is the one which preceded it before reading in the latest
  792. X     * buffer; it needs to be kept around in case it's a newline, so
  793. X     * yy_get_previous_state() will have with '^' rules active.
  794. X     */
  795. X
  796. X    yytext_ptr = &yy_current_buffer->yy_ch_buf[1];
  797. X
  798. X    return ret_val;
  799. X    }
  800. X
  801. X
  802. X/* yy_get_previous_state - get the state just before the EOB char was reached */
  803. X
  804. Xstatic yy_state_type yy_get_previous_state()
  805. X    {
  806. X    register yy_state_type yy_current_state;
  807. X    register char *yy_cp;
  808. X
  809. X    register char *yy_bp = yytext_ptr;
  810. X
  811. X    yy_current_state = yy_start;
  812. X    if ( yy_bp[-1] == '\n' )
  813. X        ++yy_current_state;
  814. X
  815. X    for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
  816. X        {
  817. X        register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
  818. X        if ( yy_accept[yy_current_state] )
  819. X            {
  820. X            yy_last_accepting_state = yy_current_state;
  821. X            yy_last_accepting_cpos = yy_cp;
  822. X            }
  823. X        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  824. X            {
  825. X            yy_current_state = (int) yy_def[yy_current_state];
  826. X            if ( yy_current_state >= 467 )
  827. X                yy_c = yy_meta[(unsigned int) yy_c];
  828. X            }
  829. X        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
  830. X        }
  831. X
  832. X    return yy_current_state;
  833. X    }
  834. X
  835. X
  836. X/* yy_try_NUL_trans - try to make a transition on the NUL character
  837. X *
  838. X * synopsis
  839. X *    next_state = yy_try_NUL_trans( current_state );
  840. X */
  841. X
  842. X#ifdef YY_USE_PROTOS
  843. Xstatic yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
  844. X#else
  845. Xstatic yy_state_type yy_try_NUL_trans( yy_current_state )
  846. Xyy_state_type yy_current_state;
  847. X#endif
  848. X    {
  849. X    register int yy_is_jam;
  850. X    register char *yy_cp = yy_c_buf_p;
  851. X
  852. X    register YY_CHAR yy_c = 1;
  853. X    if ( yy_accept[yy_current_state] )
  854. X        {
  855. X        yy_last_accepting_state = yy_current_state;
  856. X        yy_last_accepting_cpos = yy_cp;
  857. X        }
  858. X    while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  859. X        {
  860. X        yy_current_state = (int) yy_def[yy_current_state];
  861. X        if ( yy_current_state >= 467 )
  862. X            yy_c = yy_meta[(unsigned int) yy_c];
  863. X        }
  864. X    yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
  865. X    yy_is_jam = (yy_current_state == 466);
  866. X
  867. X    return yy_is_jam ? 0 : yy_current_state;
  868. X    }
  869. X
  870. X
  871. X#ifdef YY_USE_PROTOS
  872. Xstatic void yyunput( int c, register char *yy_bp )
  873. X#else
  874. Xstatic void yyunput( c, yy_bp )
  875. Xint c;
  876. Xregister char *yy_bp;
  877. X#endif
  878. X    {
  879. X    register char *yy_cp = yy_c_buf_p;
  880. X
  881. X    /* undo effects of setting up yytext */
  882. X    *yy_cp = yy_hold_char;
  883. X
  884. X    if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
  885. X        { /* need to shift things up to make room */
  886. X        /* +2 for EOB chars. */
  887. X        register int number_to_move = yy_n_chars + 2;
  888. X        register char *dest = &yy_current_buffer->yy_ch_buf[
  889. X                    yy_current_buffer->yy_buf_size + 2];
  890. X        register char *source =
  891. X                &yy_current_buffer->yy_ch_buf[number_to_move];
  892. X
  893. X        while ( source > yy_current_buffer->yy_ch_buf )
  894. X            *--dest = *--source;
  895. X
  896. X        yy_cp += dest - source;
  897. X        yy_bp += dest - source;
  898. X        yy_n_chars = yy_current_buffer->yy_buf_size;
  899. X
  900. X        if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
  901. X            YY_FATAL_ERROR( "flex scanner push-back overflow" );
  902. X        }
  903. X
  904. X    if ( yy_cp > yy_bp && yy_cp[-1] == '\n' )
  905. X        yy_cp[-2] = '\n';
  906. X
  907. X    *--yy_cp = (char) c;
  908. X
  909. X
  910. X    /* Note: the formal parameter *must* be called "yy_bp" for this
  911. X     * macro to now work correctly.
  912. X     */
  913. X    YY_DO_BEFORE_ACTION; /* set up yytext again */
  914. X    }
  915. X
  916. X
  917. X#ifdef __cplusplus
  918. Xstatic int yyinput()
  919. X#else
  920. Xstatic int input()
  921. X#endif
  922. X    {
  923. X    int c;
  924. X
  925. X    *yy_c_buf_p = yy_hold_char;
  926. X
  927. X    if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
  928. X        {
  929. X        /* yy_c_buf_p now points to the character we want to return.
  930. X         * If this occurs *before* the EOB characters, then it's a
  931. X         * valid NUL; if not, then we've hit the end of the buffer.
  932. X         */
  933. X        if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
  934. X            /* This was really a NUL. */
  935. X            *yy_c_buf_p = '\0';
  936. X
  937. X        else
  938. X            { /* need more input */
  939. X            yytext_ptr = yy_c_buf_p;
  940. X            ++yy_c_buf_p;
  941. X
  942. X            switch ( yy_get_next_buffer() )
  943. X                {
  944. X                case EOB_ACT_END_OF_FILE:
  945. X                    {
  946. X                    if ( yywrap() )
  947. X                        {
  948. X                        yy_c_buf_p =
  949. X                        yytext_ptr + YY_MORE_ADJ;
  950. X                        return EOF;
  951. X                        }
  952. X
  953. X                    YY_NEW_FILE;
  954. X#ifdef __cplusplus
  955. X                    return yyinput();
  956. X#else
  957. X                    return input();
  958. X#endif
  959. X                    }
  960. X
  961. X                case EOB_ACT_CONTINUE_SCAN:
  962. X                    yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
  963. X                    break;
  964. X
  965. X                case EOB_ACT_LAST_MATCH:
  966. X#ifdef __cplusplus
  967. X                    YY_FATAL_ERROR(
  968. X                    "unexpected last match in yyinput()" );
  969. X#else
  970. X                    YY_FATAL_ERROR(
  971. X                    "unexpected last match in input()" );
  972. X#endif
  973. X                }
  974. X            }
  975. X        }
  976. X
  977. X    c = *(unsigned char *) yy_c_buf_p;    /* cast for 8-bit char's */
  978. X    *yy_c_buf_p = '\0';    /* preserve yytext */
  979. X    yy_hold_char = *++yy_c_buf_p;
  980. X
  981. X    return c;
  982. X    }
  983. X
  984. X
  985. X#ifdef YY_USE_PROTOS
  986. Xvoid yyrestart( FILE *input_file )
  987. X#else
  988. Xvoid yyrestart( input_file )
  989. XFILE *input_file;
  990. X#endif
  991. X    {
  992. X    if ( ! yy_current_buffer )
  993. X        yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
  994. X
  995. X    yy_init_buffer( yy_current_buffer, input_file );
  996. X    yy_load_buffer_state();
  997. X    }
  998. X
  999. X
  1000. X#ifdef YY_USE_PROTOS
  1001. Xvoid yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
  1002. X#else
  1003. Xvoid yy_switch_to_buffer( new_buffer )
  1004. XYY_BUFFER_STATE new_buffer;
  1005. X#endif
  1006. X    {
  1007. X    if ( yy_current_buffer == new_buffer )
  1008. X        return;
  1009. X
  1010. X    if ( yy_current_buffer )
  1011. X        {
  1012. X        /* Flush out information for old buffer. */
  1013. X        *yy_c_buf_p = yy_hold_char;
  1014. X        yy_current_buffer->yy_buf_pos = yy_c_buf_p;
  1015. X        yy_current_buffer->yy_n_chars = yy_n_chars;
  1016. X        }
  1017. X
  1018. X    yy_current_buffer = new_buffer;
  1019. X    yy_load_buffer_state();
  1020. X
  1021. X    /* We don't actually know whether we did this switch during
  1022. X     * EOF (yywrap()) processing, but the only time this flag
  1023. X     * is looked at is after yywrap() is called, so it's safe
  1024. X     * to go ahead and always set it.
  1025. X     */
  1026. X    yy_did_buffer_switch_on_eof = 1;
  1027. X    }
  1028. X
  1029. X
  1030. X#ifdef YY_USE_PROTOS
  1031. Xvoid yy_load_buffer_state( void )
  1032. X#else
  1033. Xvoid yy_load_buffer_state()
  1034. X#endif
  1035. X    {
  1036. X    yy_n_chars = yy_current_buffer->yy_n_chars;
  1037. X    yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
  1038. X    yyin = yy_current_buffer->yy_input_file;
  1039. X    yy_hold_char = *yy_c_buf_p;
  1040. X    }
  1041. X
  1042. X
  1043. X#ifdef YY_USE_PROTOS
  1044. XYY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
  1045. X#else
  1046. XYY_BUFFER_STATE yy_create_buffer( file, size )
  1047. XFILE *file;
  1048. Xint size;
  1049. X#endif
  1050. X    {
  1051. X    YY_BUFFER_STATE b;
  1052. X
  1053. X    b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
  1054. X
  1055. X    if ( ! b )
  1056. X        YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
  1057. X
  1058. X    b->yy_buf_size = size;
  1059. X
  1060. X    /* yy_ch_buf has to be 2 characters longer than the size given because
  1061. X     * we need to put in 2 end-of-buffer characters.
  1062. X     */
  1063. X    b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
  1064. X
  1065. X    if ( ! b->yy_ch_buf )
  1066. X        YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
  1067. X
  1068. X    yy_init_buffer( b, file );
  1069. X
  1070. X    return b;
  1071. X    }
  1072. X
  1073. X
  1074. X#ifdef YY_USE_PROTOS
  1075. Xvoid yy_delete_buffer( YY_BUFFER_STATE b )
  1076. X#else
  1077. Xvoid yy_delete_buffer( b )
  1078. XYY_BUFFER_STATE b;
  1079. X#endif
  1080. X    {
  1081. X    if ( b == yy_current_buffer )
  1082. X        yy_current_buffer = (YY_BUFFER_STATE) 0;
  1083. X
  1084. X    yy_flex_free( (void *) b->yy_ch_buf );
  1085. X    yy_flex_free( (void *) b );
  1086. X    }
  1087. X
  1088. X
  1089. X#ifdef YY_USE_PROTOS
  1090. Xvoid yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
  1091. X#else
  1092. Xvoid yy_init_buffer( b, file )
  1093. XYY_BUFFER_STATE b;
  1094. XFILE *file;
  1095. X#endif
  1096. X    {
  1097. X    b->yy_input_file = file;
  1098. X
  1099. X    /* We put in the '\n' and start reading from [1] so that an
  1100. X     * initial match-at-newline will be true.
  1101. X     */
  1102. X
  1103. X    b->yy_ch_buf[0] = '\n';
  1104. X    b->yy_n_chars = 1;
  1105. X
  1106. X    /* We always need two end-of-buffer characters.  The first causes
  1107. X     * a transition to the end-of-buffer state.  The second causes
  1108. X     * a jam in that state.
  1109. X     */
  1110. X    b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
  1111. X    b->yy_ch_buf[2] = YY_END_OF_BUFFER_CHAR;
  1112. X
  1113. X    b->yy_buf_pos = &b->yy_ch_buf[1];
  1114. X
  1115. X    b->yy_is_interactive = file ? isatty( fileno(file) ) : 0;
  1116. X
  1117. X    b->yy_fill_buffer = 1;
  1118. X
  1119. X    b->yy_buffer_status = YY_BUFFER_NEW;
  1120. X    }
  1121. X
  1122. X
  1123. X#ifdef YY_USE_PROTOS
  1124. Xstatic void yy_push_state( int new_state )
  1125. X#else
  1126. Xstatic void yy_push_state( new_state )
  1127. Xint new_state;
  1128. X#endif
  1129. X    {
  1130. X    if ( yy_start_stack_ptr >= yy_start_stack_depth )
  1131. X        {
  1132. X        int new_size;
  1133. X
  1134. X        yy_start_stack_depth += YY_START_STACK_INCR;
  1135. X        new_size = yy_start_stack_depth * sizeof( int );
  1136. X
  1137. X        if ( ! yy_start_stack )
  1138. X            yy_start_stack = (int *) yy_flex_alloc( new_size );
  1139. X
  1140. X        else
  1141. X            yy_start_stack = (int *) yy_flex_realloc(
  1142. X                    (void *) yy_start_stack, new_size );
  1143. X
  1144. X        if ( ! yy_start_stack )
  1145. X            YY_FATAL_ERROR(
  1146. X            "out of memory expanding start-condition stack" );
  1147. X        }
  1148. X
  1149. X    yy_start_stack[yy_start_stack_ptr++] = YY_START;
  1150. X
  1151. X    BEGIN(new_state);
  1152. X    }
  1153. X
  1154. X
  1155. Xstatic void yy_pop_state()
  1156. X    {
  1157. X    if ( --yy_start_stack_ptr < 0 )
  1158. X        YY_FATAL_ERROR( "start-condition stack underflow" );
  1159. X
  1160. X    BEGIN(yy_start_stack[yy_start_stack_ptr]);
  1161. X    }
  1162. X
  1163. X
  1164. Xstatic int yy_top_state()
  1165. X    {
  1166. X    return yy_start_stack[yy_start_stack_ptr - 1];
  1167. X    }
  1168. X
  1169. X
  1170. X#ifdef YY_USE_PROTOS
  1171. Xstatic void yy_fatal_error( const char msg[] )
  1172. X#else
  1173. Xstatic void yy_fatal_error( msg )
  1174. Xchar msg[];
  1175. X#endif
  1176. X    {
  1177. X    (void) fprintf( stderr, "%s\n", msg );
  1178. X    exit( 1 );
  1179. X    }
  1180. X
  1181. X
  1182. X
  1183. X/* Redefine yyless() so it works in section 3 code. */
  1184. X
  1185. X#undef yyless
  1186. X#define yyless(n) \
  1187. X    do \
  1188. X        { \
  1189. X        /* Undo effects of setting up yytext. */ \
  1190. X        yytext[yyleng] = yy_hold_char; \
  1191. X        yy_c_buf_p = yytext + n - YY_MORE_ADJ; \
  1192. X        yy_hold_char = *yy_c_buf_p; \
  1193. X        *yy_c_buf_p = '\0'; \
  1194. X        yyleng = n; \
  1195. X        } \
  1196. X    while ( 0 )
  1197. X
  1198. X
  1199. X/* Internal utility routines. */
  1200. X
  1201. X#ifndef yytext_ptr
  1202. X#ifdef YY_USE_PROTOS
  1203. Xstatic void yy_flex_strncpy( char *s1, const char *s2, int n )
  1204. X#else
  1205. Xstatic void yy_flex_strncpy( s1, s2, n )
  1206. Xchar *s1;
  1207. Xconst char *s2;
  1208. Xint n;
  1209. X#endif
  1210. X    {
  1211. X    register int i;
  1212. X    for ( i = 0; i < n; ++i )
  1213. X        s1[i] = s2[i];
  1214. X    }
  1215. X#endif
  1216. X
  1217. X
  1218. X#ifdef YY_USE_PROTOS
  1219. Xstatic void *yy_flex_alloc( unsigned int size )
  1220. X#else
  1221. Xstatic void *yy_flex_alloc( size )
  1222. Xunsigned int size;
  1223. X#endif
  1224. X    {
  1225. X    return (void *) malloc( size );
  1226. X    }
  1227. X
  1228. X#ifdef YY_USE_PROTOS
  1229. Xstatic void *yy_flex_realloc( void *ptr, unsigned int size )
  1230. X#else
  1231. Xstatic void *yy_flex_realloc( ptr, size )
  1232. Xvoid *ptr;
  1233. Xunsigned int size;
  1234. X#endif
  1235. X    {
  1236. X    return (void *) realloc( ptr, size );
  1237. X    }
  1238. X
  1239. X#ifdef YY_USE_PROTOS
  1240. Xstatic void yy_flex_free( void *ptr )
  1241. X#else
  1242. Xstatic void yy_flex_free( ptr )
  1243. Xvoid *ptr;
  1244. X#endif
  1245. X    {
  1246. X    free( ptr );
  1247. X    }
  1248. X# line 248 "src/c++2latex.l"
  1249. X
  1250. X
  1251. X#include "main.c"
  1252. END_OF_FILE
  1253.   if test 24230 -ne `wc -c <'src/c++2latex.c.B'`; then
  1254.     echo shar: \"'src/c++2latex.c.B'\" unpacked with wrong size!
  1255.   elif test -f 'src/c++2latex.c.A'; then
  1256.     echo shar: Combining  \"'src/c++2latex.c'\" \(60263 characters\)
  1257.     cat 'src/c++2latex.c.A' 'src/c++2latex.c.B' > 'src/c++2latex.c'
  1258.     if test 60263 -ne `wc -c <'src/c++2latex.c'`; then
  1259.       echo shar: \"'src/c++2latex.c'\" combined with wrong size!
  1260.     else
  1261.       rm src/c++2latex.c.A src/c++2latex.c.B 
  1262.     fi
  1263.   fi
  1264.   # end of 'src/c++2latex.c.B'
  1265. fi
  1266. if test -f 'src/c++2latex.l' -a "${1}" != "-c" ; then 
  1267.   echo shar: Will not clobber existing file \"'src/c++2latex.l'\"
  1268. else
  1269.   echo shar: Extracting \"'src/c++2latex.l'\" \(5174 characters\)
  1270.   sed "s/^X//" >'src/c++2latex.l' <<'END_OF_FILE'
  1271. X/* $Id: c++2latex.l,v 3.0 1994/01/15 17:07:02 joke Rel $ */
  1272. X
  1273. X%x STRING INCLUDE ASTCOMMENT SLASHCOMMENT
  1274. X
  1275. X%{
  1276. X#include "defs.h"
  1277. X%}
  1278. X
  1279. X%%
  1280. X            INIT;
  1281. X
  1282. X"#"[ \t]*"include"    { CPP; BEGIN (INCLUDE); }
  1283. X
  1284. X"#"[ \t]*"define"    |
  1285. X"#"[ \t]*"elif"        |
  1286. X"#"[ \t]*"else"        |
  1287. X"#"[ \t]*"endif"    |
  1288. X"#"[ \t]*"error"    |
  1289. X"#"[ \t]*"ex"        |    /* GCC special */
  1290. X"#"[ \t]*"if"        |
  1291. X"#"[ \t]*"ifdef"    |
  1292. X"#"[ \t]*"ifndef"    |
  1293. X"#"[ \t]*"line"        |
  1294. X"#"[ \t]*"pragma"    |
  1295. X"#"[ \t]*"undef"    CPP;
  1296. X
  1297. X /*    cpp unary # and binary ## commands */
  1298. X"#"            CPP;
  1299. X
  1300. X
  1301. X<INCLUDE>"<"[^>]*/">"    { OUT ("$<$"); FONT (string_font);
  1302. X              SUB (yytext+1); OUT ("}$>$");
  1303. X              input(); INIT; }
  1304. X<INCLUDE>\"[^\"]*/\"    { OUT ("\""); FONT (string_font);
  1305. X              SUB (yytext+1); OUT ("}\"");
  1306. X              input(); INIT; }
  1307. X<INCLUDE>[ \t]+        ECHO;
  1308. X<INCLUDE>[\n]        OUT ("\\mbox{}\\\\\n");
  1309. X<INCLUDE>.        { REPARSE; INIT; }
  1310. X
  1311. X
  1312. X    /* from: gcc-2.2/c-parse.gperf */
  1313. X"asm"            |
  1314. X"auto"            |
  1315. X"break"            |
  1316. X"char"            |
  1317. X"case"            |
  1318. X"const"            |    /* ANSI */
  1319. X"continue"        |
  1320. X"default"        |
  1321. X"do"            |
  1322. X"double"        |
  1323. X"else"            |
  1324. X"enum"            |
  1325. X"extern"        |
  1326. X"float"            |
  1327. X"for"            |
  1328. X"goto"            |
  1329. X"if"            |
  1330. X"inline"        |    /* GCC special */
  1331. X"int"            |
  1332. X"long"            |
  1333. X"register"        |
  1334. X"return"        |
  1335. X"short"            |
  1336. X"signed"        |    /* ANSI */
  1337. X"sizeof"        |
  1338. X"static"        |
  1339. X"struct"        |
  1340. X"switch"        |
  1341. X"typedef"        |
  1342. X"typeof"        |    /* GCC special */
  1343. X"union"            |
  1344. X"unsigned"        |
  1345. X"void"            |
  1346. X"volatile"        |
  1347. X"while"            |
  1348. X
  1349. X    /* from: gcc-2.2/gplus.gperf */
  1350. X"all"            |    /* GCC special */
  1351. X"except"        |    /* GCC special */
  1352. X"exception"        |    /* GCC special */
  1353. X"raise"            |    /* GCC special */
  1354. X"raises"        |    /* GCC special */
  1355. X"reraise"        |    /* GCC special */
  1356. X"throw"            |    /* GCC special */
  1357. X"try"            |    /* GCC special */
  1358. X"catch"            |
  1359. X"class"            |
  1360. X"classof"        |
  1361. X"delete"        |
  1362. X"dynamic"        |
  1363. X"friend"        |
  1364. X"headof"        |
  1365. X"new"            |
  1366. X"operator"        |
  1367. X"overload"        |
  1368. X"private"        |
  1369. X"protected"        |
  1370. X"public"        |
  1371. X"this"            |
  1372. X"template"        |
  1373. X"virtual"        KEY;
  1374. X
  1375. X
  1376. X"->"            SYM ("rightarrow");
  1377. X"<<"            SYM ("ll");
  1378. X">>"            SYM ("gg");
  1379. X"<="            SYM ("leq");
  1380. X">="            SYM ("geq");
  1381. X"!="            SYM ("neq");
  1382. X"||"            SYM ("mid\\mid");
  1383. X"..."            SYM ("ldots");
  1384. X"*="            SYM ("ast=");
  1385. X"<<="            SYM ("ll=");
  1386. X">>="            SYM ("gg=");
  1387. X"^="            SYM ("vee=");
  1388. X"|="            SYM ("mid=");
  1389. X"~"            SYM ("sim");
  1390. X"*"            SYM ("ast");
  1391. X"^"            SYM ("wedge");
  1392. X"|"            SYM ("mid");
  1393. X"->*"            SYM ("rightarrow\\ast");
  1394. X"/"            OUT ("$/$");
  1395. X"<"            OUT ("$<$");
  1396. X">"            OUT ("$>$");
  1397. X"&&"            OUT ("\\&\\&");
  1398. X"%="            OUT ("\\%=");
  1399. X"&="            OUT ("\\&=");
  1400. X"{"            OUT ("\\{");
  1401. X"}"            OUT ("\\}");
  1402. X"&"            OUT ("\\&");
  1403. X"%"            OUT ("\\%");
  1404. X"--"            OUT ("-{}-");
  1405. X".*"            OUT (".$\\ast$");
  1406. X"?"            |
  1407. X":"            |
  1408. X"="            |
  1409. X","            |
  1410. X"."            |
  1411. X";"            |
  1412. X"!"            |
  1413. X"-"            |
  1414. X"+"            |
  1415. X"/="            |
  1416. X"=="            |
  1417. X"++"            |
  1418. X"+="            |
  1419. X"-="            |
  1420. X"("            |
  1421. X")"            |
  1422. X"["            |
  1423. X"]"            |
  1424. X"::"            ECHO;
  1425. X
  1426. X
  1427. X /*    identifiers: may contain $ chars */
  1428. X[a-zA-Z_$][a-zA-Z_$0-9]*    SUB (yytext);
  1429. X
  1430. X
  1431. X /*    1.   Asterisk comments mini scanner */
  1432. X /*    1.1. Curly  brace comment */
  1433. X"}"[ \t]*"/*"                  { BEGIN (ASTCOMMENT);
  1434. X                                OUT ("\\}");
  1435. X                                BTAB;
  1436. X                                FONT (comment_font);
  1437. X                                OUT ("/$\\ast$"); }
  1438. X
  1439. X /*    1.2. Comments at the beginning of a line */
  1440. X^[ \t]*"/*"              { BEGIN (ASTCOMMENT);
  1441. X                FONT (comment_font);
  1442. X                                REPARSE; }
  1443. X
  1444. X /*    1.3. Other comments, aligned to right side of paper */
  1445. X"/*"                  { BEGIN (ASTCOMMENT);
  1446. X                                if (aligntoright) {
  1447. X                    OUT ("\\hfill");
  1448. X                } else {
  1449. X                    CTAB;
  1450. X                }
  1451. X                FONT (comment_font);
  1452. X                                OUT ("/$\\ast$"); }
  1453. X
  1454. X<ASTCOMMENT>"*/"          { INIT; OUT ("$\\ast$/}"); }
  1455. X<ASTCOMMENT>"\n"          { OUT ("}\\mbox{}\\\\\n"); FONT (comment_font); }
  1456. X<ASTCOMMENT>[ \t]+        IND;
  1457. X<ASTCOMMENT>.            SUB (yytext);
  1458. X
  1459. X /*    2.   Double slash ``//'' comments mini scanner */
  1460. X /*    2.1. Curly brace comment */
  1461. X}[ \t]*"//"        { BEGIN (SLASHCOMMENT);
  1462. X                                OUT ("\\}");
  1463. X                                BTAB;
  1464. X                FONT (comment_font);
  1465. X                                OUT ("//");}
  1466. X
  1467. X /*    2.2. Complete line comment */
  1468. X^[ \t]*"//"        { BEGIN (SLASHCOMMENT);
  1469. X                                FONT (comment_font);
  1470. X                REPARSE; }
  1471. X
  1472. X /*    2.3. Other comments */
  1473. X"//"            { BEGIN (SLASHCOMMENT);
  1474. X                                if (aligntoright) {
  1475. X                    OUT ("\\hfill");
  1476. X                } else {
  1477. X                    CTAB;
  1478. X                }
  1479. X                FONT (comment_font);
  1480. X                                OUT ("//"); }
  1481. X
  1482. X<SLASHCOMMENT>"\n"          { INIT; OUT ("}\\mbox{}\\\\\n"); }
  1483. X<SLASHCOMMENT>[ \t]+        IND;
  1484. X<SLASHCOMMENT>.                SUB (yytext);
  1485. X
  1486. X
  1487. XL?\"                       { BEGIN (STRING);
  1488. X                FONT (string_font); OUT ("\""); }
  1489. X<STRING>\\\\            OUT ("$\\backslash\\backslash$");
  1490. X<STRING>\\[bfnrtv'"]          { OUT ("$\\backslash$"); SUB (yytext+1); }
  1491. X<STRING>\"              { INIT; OUT ("\"}"); }
  1492. X<STRING>"\n"            OUT ("\\mbox{}\\\\\n");
  1493. X<STRING>^[ \t]+            IND;
  1494. X<STRING>.            SUB (yytext);
  1495. X
  1496. X0[0-7]+[uUlL]?            ECHO;
  1497. X
  1498. X0x[0-9a-fA-F]+[uUlL]?        ECHO;
  1499. X
  1500. X([0-9]*\.[0-9]+[fFlL]?)         |
  1501. X([0-9]+\.[0-9]*[fFlL]?)         |
  1502. X([0-9]*\.?[0-9]+[eE][+-]?[0-9]+) |
  1503. X([0-9]+\.?[0-9]*[eE][+-]?[0-9]+) ECHO;
  1504. X
  1505. X[0-9]+[uUlL]?            ECHO;
  1506. X
  1507. XL?'[ -~]'            |
  1508. XL?'\\[ntvbrfa\\?'"]'        |
  1509. XL?'\\[0-7]{1,3}'        |
  1510. XL?'\\x[0-9a-fA-F]{1,2}'        SUB (yytext);
  1511. X
  1512. X
  1513. X"\\\n"                OUT ("$\\backslash$\\\\\n");
  1514. X^[ \t]+                IND;
  1515. X[ \t]+                ECHO;
  1516. X"\f"[\n]?            OUT ("\\newpage\n");
  1517. X"\n"                OUT ("\\mbox{}\\\\\n");
  1518. X%%
  1519. X
  1520. X#include "main.c"
  1521. END_OF_FILE
  1522.   if test 5174 -ne `wc -c <'src/c++2latex.l'`; then
  1523.     echo shar: \"'src/c++2latex.l'\" unpacked with wrong size!
  1524.   fi
  1525.   # end of 'src/c++2latex.l'
  1526. fi
  1527. if test -f 'src/objc2latex.c.B' -a "${1}" != "-c" ; then 
  1528.   echo shar: Will not clobber existing file \"'src/objc2latex.c.B'\"
  1529. else
  1530.   echo shar: Extracting \"'src/objc2latex.c.B'\" \(23224 characters\)
  1531.   sed "s/^X//" >'src/objc2latex.c.B' <<'END_OF_FILE'
  1532. XYY_USER_ACTION
  1533. X# line 94 "src/objc2latex.l"
  1534. XSYM ("gg");
  1535. X    YY_BREAK
  1536. Xcase 68:
  1537. XYY_USER_ACTION
  1538. X# line 95 "src/objc2latex.l"
  1539. XSYM ("leq");
  1540. X    YY_BREAK
  1541. Xcase 69:
  1542. XYY_USER_ACTION
  1543. X# line 96 "src/objc2latex.l"
  1544. XSYM ("geq");
  1545. X    YY_BREAK
  1546. Xcase 70:
  1547. XYY_USER_ACTION
  1548. X# line 97 "src/objc2latex.l"
  1549. XSYM ("neq");
  1550. X    YY_BREAK
  1551. Xcase 71:
  1552. XYY_USER_ACTION
  1553. X# line 98 "src/objc2latex.l"
  1554. XSYM ("mid\\mid");
  1555. X    YY_BREAK
  1556. Xcase 72:
  1557. XYY_USER_ACTION
  1558. X# line 99 "src/objc2latex.l"
  1559. XSYM ("ldots");
  1560. X    YY_BREAK
  1561. Xcase 73:
  1562. XYY_USER_ACTION
  1563. X# line 100 "src/objc2latex.l"
  1564. XSYM ("ast=");
  1565. X    YY_BREAK
  1566. Xcase 74:
  1567. XYY_USER_ACTION
  1568. X# line 101 "src/objc2latex.l"
  1569. XSYM ("ll=");
  1570. X    YY_BREAK
  1571. Xcase 75:
  1572. XYY_USER_ACTION
  1573. X# line 102 "src/objc2latex.l"
  1574. XSYM ("gg=");
  1575. X    YY_BREAK
  1576. Xcase 76:
  1577. XYY_USER_ACTION
  1578. X# line 103 "src/objc2latex.l"
  1579. XSYM ("vee=");
  1580. X    YY_BREAK
  1581. Xcase 77:
  1582. XYY_USER_ACTION
  1583. X# line 104 "src/objc2latex.l"
  1584. XSYM ("mid=");
  1585. X    YY_BREAK
  1586. Xcase 78:
  1587. XYY_USER_ACTION
  1588. X# line 105 "src/objc2latex.l"
  1589. XSYM ("sim");
  1590. X    YY_BREAK
  1591. Xcase 79:
  1592. XYY_USER_ACTION
  1593. X# line 106 "src/objc2latex.l"
  1594. XSYM ("ast");
  1595. X    YY_BREAK
  1596. Xcase 80:
  1597. XYY_USER_ACTION
  1598. X# line 107 "src/objc2latex.l"
  1599. XSYM ("wedge");
  1600. X    YY_BREAK
  1601. Xcase 81:
  1602. XYY_USER_ACTION
  1603. X# line 108 "src/objc2latex.l"
  1604. XSYM ("mid");
  1605. X    YY_BREAK
  1606. Xcase 82:
  1607. XYY_USER_ACTION
  1608. X# line 109 "src/objc2latex.l"
  1609. XOUT ("$/$");
  1610. X    YY_BREAK
  1611. Xcase 83:
  1612. XYY_USER_ACTION
  1613. X# line 110 "src/objc2latex.l"
  1614. XOUT ("$<$");
  1615. X    YY_BREAK
  1616. Xcase 84:
  1617. XYY_USER_ACTION
  1618. X# line 111 "src/objc2latex.l"
  1619. XOUT ("$>$");
  1620. X    YY_BREAK
  1621. Xcase 85:
  1622. XYY_USER_ACTION
  1623. X# line 112 "src/objc2latex.l"
  1624. XOUT ("\\&\\&");
  1625. X    YY_BREAK
  1626. Xcase 86:
  1627. XYY_USER_ACTION
  1628. X# line 113 "src/objc2latex.l"
  1629. XOUT ("\\%=");
  1630. X    YY_BREAK
  1631. Xcase 87:
  1632. XYY_USER_ACTION
  1633. X# line 114 "src/objc2latex.l"
  1634. XOUT ("\\&=");
  1635. X    YY_BREAK
  1636. Xcase 88:
  1637. XYY_USER_ACTION
  1638. X# line 115 "src/objc2latex.l"
  1639. XOUT ("\\{");
  1640. X    YY_BREAK
  1641. Xcase 89:
  1642. XYY_USER_ACTION
  1643. X# line 116 "src/objc2latex.l"
  1644. XOUT ("\\}");
  1645. X    YY_BREAK
  1646. Xcase 90:
  1647. XYY_USER_ACTION
  1648. X# line 117 "src/objc2latex.l"
  1649. XOUT ("\\&");
  1650. X    YY_BREAK
  1651. Xcase 91:
  1652. XYY_USER_ACTION
  1653. X# line 118 "src/objc2latex.l"
  1654. XOUT ("\\%");
  1655. X    YY_BREAK
  1656. Xcase 92:
  1657. XYY_USER_ACTION
  1658. X# line 119 "src/objc2latex.l"
  1659. XOUT ("-{}-");
  1660. X    YY_BREAK
  1661. Xcase 93:
  1662. X# line 121 "src/objc2latex.l"
  1663. Xcase 94:
  1664. X# line 122 "src/objc2latex.l"
  1665. Xcase 95:
  1666. X# line 123 "src/objc2latex.l"
  1667. Xcase 96:
  1668. X# line 124 "src/objc2latex.l"
  1669. Xcase 97:
  1670. X# line 125 "src/objc2latex.l"
  1671. Xcase 98:
  1672. X# line 126 "src/objc2latex.l"
  1673. Xcase 99:
  1674. X# line 127 "src/objc2latex.l"
  1675. Xcase 100:
  1676. X# line 128 "src/objc2latex.l"
  1677. Xcase 101:
  1678. X# line 129 "src/objc2latex.l"
  1679. Xcase 102:
  1680. X# line 130 "src/objc2latex.l"
  1681. Xcase 103:
  1682. X# line 131 "src/objc2latex.l"
  1683. Xcase 104:
  1684. X# line 132 "src/objc2latex.l"
  1685. Xcase 105:
  1686. X# line 133 "src/objc2latex.l"
  1687. Xcase 106:
  1688. X# line 134 "src/objc2latex.l"
  1689. Xcase 107:
  1690. X# line 135 "src/objc2latex.l"
  1691. Xcase 108:
  1692. X# line 136 "src/objc2latex.l"
  1693. Xcase 109:
  1694. X# line 137 "src/objc2latex.l"
  1695. Xcase 110:
  1696. XYY_USER_ACTION
  1697. X# line 137 "src/objc2latex.l"
  1698. XECHO;
  1699. X    YY_BREAK
  1700. X /*    identifiers: may contain $ chars */
  1701. Xcase 111:
  1702. XYY_USER_ACTION
  1703. X# line 141 "src/objc2latex.l"
  1704. XSUB (yytext);
  1705. X    YY_BREAK
  1706. X /*    1.   Asterisk comments mini scanner */
  1707. X /*    1.1. Curly  brace comment */
  1708. Xcase 112:
  1709. XYY_USER_ACTION
  1710. X# line 145 "src/objc2latex.l"
  1711. X{ BEGIN (ASTCOMMENT);
  1712. X                                OUT ("\\}");
  1713. X                                BTAB;
  1714. X                                FONT (comment_font);
  1715. X                                OUT ("/$\\ast$"); }
  1716. X    YY_BREAK
  1717. X /*    1.2. Comments at the beginning of a line */
  1718. Xcase 113:
  1719. XYY_USER_ACTION
  1720. X# line 152 "src/objc2latex.l"
  1721. X{ BEGIN (ASTCOMMENT);
  1722. X                FONT (comment_font);
  1723. X                                REPARSE; }
  1724. X    YY_BREAK
  1725. X /*    1.3. Other comments, aligned to right side of paper */
  1726. Xcase 114:
  1727. XYY_USER_ACTION
  1728. X# line 157 "src/objc2latex.l"
  1729. X{ BEGIN (ASTCOMMENT);
  1730. X                                if (aligntoright) {
  1731. X                    OUT ("\\hfill");
  1732. X                } else {
  1733. X                    CTAB;
  1734. X                }
  1735. X                FONT (comment_font);
  1736. X                                OUT ("/$\\ast$"); }
  1737. X    YY_BREAK
  1738. Xcase 115:
  1739. XYY_USER_ACTION
  1740. X# line 166 "src/objc2latex.l"
  1741. X{ INIT; OUT ("$\\ast$/}"); }
  1742. X    YY_BREAK
  1743. Xcase 116:
  1744. XYY_USER_ACTION
  1745. X# line 167 "src/objc2latex.l"
  1746. X{ OUT ("}\\mbox{}\\\\\n"); FONT (comment_font); }
  1747. X    YY_BREAK
  1748. Xcase 117:
  1749. XYY_USER_ACTION
  1750. X# line 168 "src/objc2latex.l"
  1751. XIND;
  1752. X    YY_BREAK
  1753. Xcase 118:
  1754. XYY_USER_ACTION
  1755. X# line 169 "src/objc2latex.l"
  1756. XSUB (yytext);
  1757. X    YY_BREAK
  1758. X /*    2.   Double slash ``//'' comments mini scanner */
  1759. X /*    2.1. Curly brace comment */
  1760. Xcase 119:
  1761. XYY_USER_ACTION
  1762. X# line 173 "src/objc2latex.l"
  1763. X{ BEGIN (SLASHCOMMENT);
  1764. X                                OUT ("\\}");
  1765. X                                BTAB;
  1766. X                FONT (comment_font);
  1767. X                                OUT ("//");}
  1768. X    YY_BREAK
  1769. X /*    2.2. Complete line comment */
  1770. Xcase 120:
  1771. XYY_USER_ACTION
  1772. X# line 180 "src/objc2latex.l"
  1773. X{ BEGIN (SLASHCOMMENT);
  1774. X                                FONT (comment_font);
  1775. X                REPARSE; }
  1776. X    YY_BREAK
  1777. X /*    2.3. Other comments */
  1778. Xcase 121:
  1779. XYY_USER_ACTION
  1780. X# line 185 "src/objc2latex.l"
  1781. X{ BEGIN (SLASHCOMMENT);
  1782. X                                if (aligntoright) {
  1783. X                    OUT ("\\hfill");
  1784. X                } else {
  1785. X                    CTAB;
  1786. X                }
  1787. X                FONT (comment_font);
  1788. X                                OUT ("//"); }
  1789. X    YY_BREAK
  1790. Xcase 122:
  1791. XYY_USER_ACTION
  1792. X# line 194 "src/objc2latex.l"
  1793. X{ INIT; OUT ("}\\mbox{}\\\\\n"); }
  1794. X    YY_BREAK
  1795. Xcase 123:
  1796. XYY_USER_ACTION
  1797. X# line 195 "src/objc2latex.l"
  1798. XIND;
  1799. X    YY_BREAK
  1800. Xcase 124:
  1801. XYY_USER_ACTION
  1802. X# line 196 "src/objc2latex.l"
  1803. XSUB (yytext);
  1804. X    YY_BREAK
  1805. Xcase 125:
  1806. XYY_USER_ACTION
  1807. X# line 199 "src/objc2latex.l"
  1808. X{ BEGIN (STRING);
  1809. X                FONT (string_font); OUT ("\""); }
  1810. X    YY_BREAK
  1811. Xcase 126:
  1812. XYY_USER_ACTION
  1813. X# line 201 "src/objc2latex.l"
  1814. XOUT ("$\\backslash\\backslash$");
  1815. X    YY_BREAK
  1816. Xcase 127:
  1817. XYY_USER_ACTION
  1818. X# line 202 "src/objc2latex.l"
  1819. X{ OUT ("$\\backslash$"); SUB (yytext+1); }
  1820. X    YY_BREAK
  1821. Xcase 128:
  1822. XYY_USER_ACTION
  1823. X# line 203 "src/objc2latex.l"
  1824. X{ INIT; OUT ("\"}"); }
  1825. X    YY_BREAK
  1826. Xcase 129:
  1827. XYY_USER_ACTION
  1828. X# line 204 "src/objc2latex.l"
  1829. XOUT ("\\mbox{}\\\\\n");
  1830. X    YY_BREAK
  1831. Xcase 130:
  1832. XYY_USER_ACTION
  1833. X# line 205 "src/objc2latex.l"
  1834. XIND;
  1835. X    YY_BREAK
  1836. Xcase 131:
  1837. XYY_USER_ACTION
  1838. X# line 206 "src/objc2latex.l"
  1839. XSUB (yytext);
  1840. X    YY_BREAK
  1841. Xcase 132:
  1842. XYY_USER_ACTION
  1843. X# line 209 "src/objc2latex.l"
  1844. XECHO;
  1845. X    YY_BREAK
  1846. Xcase 133:
  1847. XYY_USER_ACTION
  1848. X# line 211 "src/objc2latex.l"
  1849. XECHO;
  1850. X    YY_BREAK
  1851. Xcase 134:
  1852. X# line 214 "src/objc2latex.l"
  1853. Xcase 135:
  1854. X# line 215 "src/objc2latex.l"
  1855. Xcase 136:
  1856. X# line 216 "src/objc2latex.l"
  1857. Xcase 137:
  1858. XYY_USER_ACTION
  1859. X# line 216 "src/objc2latex.l"
  1860. XECHO;
  1861. X    YY_BREAK
  1862. Xcase 138:
  1863. XYY_USER_ACTION
  1864. X# line 218 "src/objc2latex.l"
  1865. XECHO;
  1866. X    YY_BREAK
  1867. Xcase 139:
  1868. X# line 221 "src/objc2latex.l"
  1869. Xcase 140:
  1870. X# line 222 "src/objc2latex.l"
  1871. Xcase 141:
  1872. X# line 223 "src/objc2latex.l"
  1873. Xcase 142:
  1874. XYY_USER_ACTION
  1875. X# line 223 "src/objc2latex.l"
  1876. XSUB (yytext);
  1877. X    YY_BREAK
  1878. Xcase 143:
  1879. XYY_USER_ACTION
  1880. X# line 226 "src/objc2latex.l"
  1881. XOUT ("$\\backslash$\\\\\n");
  1882. X    YY_BREAK
  1883. Xcase 144:
  1884. XYY_USER_ACTION
  1885. X# line 227 "src/objc2latex.l"
  1886. XIND;
  1887. X    YY_BREAK
  1888. Xcase 145:
  1889. XYY_USER_ACTION
  1890. X# line 228 "src/objc2latex.l"
  1891. XECHO;
  1892. X    YY_BREAK
  1893. Xcase 146:
  1894. XYY_USER_ACTION
  1895. X# line 229 "src/objc2latex.l"
  1896. XOUT ("\\newpage\n");
  1897. X    YY_BREAK
  1898. Xcase 147:
  1899. XYY_USER_ACTION
  1900. X# line 230 "src/objc2latex.l"
  1901. XOUT ("\\mbox{}\\\\\n");
  1902. X    YY_BREAK
  1903. Xcase 148:
  1904. XYY_USER_ACTION
  1905. X# line 231 "src/objc2latex.l"
  1906. XECHO;
  1907. X    YY_BREAK
  1908. Xcase YY_STATE_EOF(INITIAL):
  1909. Xcase YY_STATE_EOF(STRING):
  1910. Xcase YY_STATE_EOF(INCLUDE):
  1911. Xcase YY_STATE_EOF(ASTCOMMENT):
  1912. Xcase YY_STATE_EOF(SLASHCOMMENT):
  1913. X    yyterminate();
  1914. X
  1915. X    case YY_END_OF_BUFFER:
  1916. X        {
  1917. X        /* Amount of text matched not including the EOB char. */
  1918. X        int yy_amount_of_matched_text = yy_cp - yytext_ptr - 1;
  1919. X
  1920. X        /* Undo the effects of YY_DO_BEFORE_ACTION. */
  1921. X        *yy_cp = yy_hold_char;
  1922. X
  1923. X        if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
  1924. X            {
  1925. X            /* We're scanning a new file or input source.  It's
  1926. X             * possible that this happened because the user
  1927. X             * just pointed yyin at a new source and called
  1928. X             * yylex().  If so, then we have to assure
  1929. X             * consistency between yy_current_buffer and our
  1930. X             * globals.  Here is the right place to do so, because
  1931. X             * this is the first action (other than possibly a
  1932. X             * back-up) that will match for the new input source.
  1933. X             */
  1934. X            yy_n_chars = yy_current_buffer->yy_n_chars;
  1935. X            yy_current_buffer->yy_input_file = yyin;
  1936. X            yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
  1937. X            }
  1938. X
  1939. X        /* Note that here we test for yy_c_buf_p "<=" to the position
  1940. X         * of the first EOB in the buffer, since yy_c_buf_p will
  1941. X         * already have been incremented past the NUL character
  1942. X         * (since all states make transitions on EOB to the
  1943. X         * end-of-buffer state).  Contrast this with the test
  1944. X         * in input().
  1945. X         */
  1946. X        if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
  1947. X            { /* This was really a NUL. */
  1948. X            yy_state_type yy_next_state;
  1949. X
  1950. X            yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
  1951. X
  1952. X            yy_current_state = yy_get_previous_state();
  1953. X
  1954. X            /* Okay, we're now positioned to make the NUL
  1955. X             * transition.  We couldn't have
  1956. X             * yy_get_previous_state() go ahead and do it
  1957. X             * for us because it doesn't know how to deal
  1958. X             * with the possibility of jamming (and we don't
  1959. X             * want to build jamming into it because then it
  1960. X             * will run more slowly).
  1961. X             */
  1962. X
  1963. X            yy_next_state = yy_try_NUL_trans( yy_current_state );
  1964. X
  1965. X            yy_bp = yytext_ptr + YY_MORE_ADJ;
  1966. X
  1967. X            if ( yy_next_state )
  1968. X                {
  1969. X                /* Consume the NUL. */
  1970. X                yy_cp = ++yy_c_buf_p;
  1971. X                yy_current_state = yy_next_state;
  1972. X                goto yy_match;
  1973. X                }
  1974. X
  1975. X            else
  1976. X                {
  1977. X                            yy_cp = yy_c_buf_p;
  1978. X                goto yy_find_action;
  1979. X                }
  1980. X            }
  1981. X
  1982. X        else switch ( yy_get_next_buffer() )
  1983. X            {
  1984. X            case EOB_ACT_END_OF_FILE:
  1985. X                {
  1986. X                yy_did_buffer_switch_on_eof = 0;
  1987. X
  1988. X                if ( yywrap() )
  1989. X                    {
  1990. X                    /* Note: because we've taken care in
  1991. X                     * yy_get_next_buffer() to have set up
  1992. X                     * yytext, we can now set up
  1993. X                     * yy_c_buf_p so that if some total
  1994. X                     * hoser (like flex itself) wants to
  1995. X                     * call the scanner after we return the
  1996. X                     * YY_NULL, it'll still work - another
  1997. X                     * YY_NULL will get returned.
  1998. X                     */
  1999. X                    yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
  2000. X
  2001. X                    yy_act = YY_STATE_EOF(YY_START);
  2002. X                    goto do_action;
  2003. X                    }
  2004. X
  2005. X                else
  2006. X                    {
  2007. X                    if ( ! yy_did_buffer_switch_on_eof )
  2008. X                        YY_NEW_FILE;
  2009. X                    }
  2010. X                break;
  2011. X                }
  2012. X
  2013. X            case EOB_ACT_CONTINUE_SCAN:
  2014. X                yy_c_buf_p =
  2015. X                    yytext_ptr + yy_amount_of_matched_text;
  2016. X
  2017. X                yy_current_state = yy_get_previous_state();
  2018. X
  2019. X                yy_cp = yy_c_buf_p;
  2020. X                yy_bp = yytext_ptr + YY_MORE_ADJ;
  2021. X                goto yy_match;
  2022. X
  2023. X            case EOB_ACT_LAST_MATCH:
  2024. X                yy_c_buf_p =
  2025. X                &yy_current_buffer->yy_ch_buf[yy_n_chars];
  2026. X
  2027. X                yy_current_state = yy_get_previous_state();
  2028. X
  2029. X                yy_cp = yy_c_buf_p;
  2030. X                yy_bp = yytext_ptr + YY_MORE_ADJ;
  2031. X                goto yy_find_action;
  2032. X            }
  2033. X        break;
  2034. X        }
  2035. X
  2036. X    default:
  2037. X        YY_FATAL_ERROR(
  2038. X            "fatal flex scanner internal error--no action found" );
  2039. X    } /* end of action switch */
  2040. X        } /* end of scanning one token */
  2041. X    } /* end of yylex */
  2042. X
  2043. X
  2044. X/* yy_get_next_buffer - try to read in a new buffer
  2045. X *
  2046. X * Returns a code representing an action:
  2047. X *    EOB_ACT_LAST_MATCH -
  2048. X *    EOB_ACT_CONTINUE_SCAN - continue scanning from current position
  2049. X *    EOB_ACT_END_OF_FILE - end of file
  2050. X */
  2051. X
  2052. Xstatic int yy_get_next_buffer()
  2053. X    {
  2054. X    register char *dest = yy_current_buffer->yy_ch_buf;
  2055. X    register char *source = yytext_ptr - 1; /* copy prev. char, too */
  2056. X    register int number_to_move, i;
  2057. X    int ret_val;
  2058. X
  2059. X    if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
  2060. X        YY_FATAL_ERROR(
  2061. X        "fatal flex scanner internal error--end of buffer missed" );
  2062. X
  2063. X    if ( yy_current_buffer->yy_fill_buffer == 0 )
  2064. X        { /* Don't try to fill the buffer, so this is an EOF. */
  2065. X        if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
  2066. X            {
  2067. X            /* We matched a singled characater, the EOB, so
  2068. X             * treat this as a final EOF.
  2069. X             */
  2070. X            return EOB_ACT_END_OF_FILE;
  2071. X            }
  2072. X
  2073. X        else
  2074. X            {
  2075. X            /* We matched some text prior to the EOB, first
  2076. X             * process it.
  2077. X             */
  2078. X            return EOB_ACT_LAST_MATCH;
  2079. X            }
  2080. X        }
  2081. X
  2082. X    /* Try to read more data. */
  2083. X
  2084. X    /* First move last chars to start of buffer. */
  2085. X    number_to_move = yy_c_buf_p - yytext_ptr;
  2086. X
  2087. X    for ( i = 0; i < number_to_move; ++i )
  2088. X        *(dest++) = *(source++);
  2089. X
  2090. X    if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
  2091. X        /* don't do the read, it's not guaranteed to return an EOF,
  2092. X         * just force an EOF
  2093. X         */
  2094. X        yy_n_chars = 0;
  2095. X
  2096. X    else
  2097. X        {
  2098. X        int num_to_read =
  2099. X            yy_current_buffer->yy_buf_size - number_to_move - 1;
  2100. X
  2101. X        while ( num_to_read <= 0 )
  2102. X            { /* Not enough room in the buffer - grow it. */
  2103. X#ifdef YY_USES_REJECT
  2104. X            YY_FATAL_ERROR(
  2105. X"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
  2106. X#else
  2107. X
  2108. X            /* just a shorter name for the current buffer */
  2109. X            YY_BUFFER_STATE b = yy_current_buffer;
  2110. X
  2111. X            int yy_c_buf_p_offset = yy_c_buf_p - b->yy_ch_buf;
  2112. X
  2113. X            b->yy_buf_size *= 2;
  2114. X            b->yy_ch_buf = (char *)
  2115. X                yy_flex_realloc( (void *) b->yy_ch_buf,
  2116. X                         b->yy_buf_size );
  2117. X
  2118. X            if ( ! b->yy_ch_buf )
  2119. X                YY_FATAL_ERROR(
  2120. X                "fatal error - scanner input buffer overflow" );
  2121. X
  2122. X            yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
  2123. X
  2124. X            num_to_read = yy_current_buffer->yy_buf_size -
  2125. X                        number_to_move - 1;
  2126. X#endif
  2127. X            }
  2128. X
  2129. X        if ( num_to_read > YY_READ_BUF_SIZE )
  2130. X            num_to_read = YY_READ_BUF_SIZE;
  2131. X
  2132. X        /* Read in more data. */
  2133. X        YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
  2134. X            yy_n_chars, num_to_read );
  2135. X        }
  2136. X
  2137. X    if ( yy_n_chars == 0 )
  2138. X        {
  2139. X        if ( number_to_move - YY_MORE_ADJ == 1 )
  2140. X            {
  2141. X            ret_val = EOB_ACT_END_OF_FILE;
  2142. X            yyrestart( yyin );
  2143. X            }
  2144. X
  2145. X        else
  2146. X            {
  2147. X            ret_val = EOB_ACT_LAST_MATCH;
  2148. X            yy_current_buffer->yy_buffer_status =
  2149. X                YY_BUFFER_EOF_PENDING;
  2150. X            }
  2151. X        }
  2152. X
  2153. X    else
  2154. X        ret_val = EOB_ACT_CONTINUE_SCAN;
  2155. X
  2156. X    yy_n_chars += number_to_move;
  2157. X    yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
  2158. X    yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
  2159. X
  2160. X    /* yytext begins at the second character in yy_ch_buf; the first
  2161. X     * character is the one which preceded it before reading in the latest
  2162. X     * buffer; it needs to be kept around in case it's a newline, so
  2163. X     * yy_get_previous_state() will have with '^' rules active.
  2164. X     */
  2165. X
  2166. X    yytext_ptr = &yy_current_buffer->yy_ch_buf[1];
  2167. X
  2168. X    return ret_val;
  2169. X    }
  2170. X
  2171. X
  2172. X/* yy_get_previous_state - get the state just before the EOB char was reached */
  2173. X
  2174. Xstatic yy_state_type yy_get_previous_state()
  2175. X    {
  2176. X    register yy_state_type yy_current_state;
  2177. X    register char *yy_cp;
  2178. X
  2179. X    register char *yy_bp = yytext_ptr;
  2180. X
  2181. X    yy_current_state = yy_start;
  2182. X    if ( yy_bp[-1] == '\n' )
  2183. X        ++yy_current_state;
  2184. X
  2185. X    for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
  2186. X        {
  2187. X        register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
  2188. X        if ( yy_accept[yy_current_state] )
  2189. X            {
  2190. X            yy_last_accepting_state = yy_current_state;
  2191. X            yy_last_accepting_cpos = yy_cp;
  2192. X            }
  2193. X        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  2194. X            {
  2195. X            yy_current_state = (int) yy_def[yy_current_state];
  2196. X            if ( yy_current_state >= 417 )
  2197. X                yy_c = yy_meta[(unsigned int) yy_c];
  2198. X            }
  2199. X        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
  2200. X        }
  2201. X
  2202. X    return yy_current_state;
  2203. X    }
  2204. X
  2205. X
  2206. X/* yy_try_NUL_trans - try to make a transition on the NUL character
  2207. X *
  2208. X * synopsis
  2209. X *    next_state = yy_try_NUL_trans( current_state );
  2210. X */
  2211. X
  2212. X#ifdef YY_USE_PROTOS
  2213. Xstatic yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
  2214. X#else
  2215. Xstatic yy_state_type yy_try_NUL_trans( yy_current_state )
  2216. Xyy_state_type yy_current_state;
  2217. X#endif
  2218. X    {
  2219. X    register int yy_is_jam;
  2220. X    register char *yy_cp = yy_c_buf_p;
  2221. X
  2222. X    register YY_CHAR yy_c = 1;
  2223. X    if ( yy_accept[yy_current_state] )
  2224. X        {
  2225. X        yy_last_accepting_state = yy_current_state;
  2226. X        yy_last_accepting_cpos = yy_cp;
  2227. X        }
  2228. X    while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  2229. X        {
  2230. X        yy_current_state = (int) yy_def[yy_current_state];
  2231. X        if ( yy_current_state >= 417 )
  2232. X            yy_c = yy_meta[(unsigned int) yy_c];
  2233. X        }
  2234. X    yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
  2235. X    yy_is_jam = (yy_current_state == 416);
  2236. X
  2237. X    return yy_is_jam ? 0 : yy_current_state;
  2238. X    }
  2239. X
  2240. X
  2241. X#ifdef YY_USE_PROTOS
  2242. Xstatic void yyunput( int c, register char *yy_bp )
  2243. X#else
  2244. Xstatic void yyunput( c, yy_bp )
  2245. Xint c;
  2246. Xregister char *yy_bp;
  2247. X#endif
  2248. X    {
  2249. X    register char *yy_cp = yy_c_buf_p;
  2250. X
  2251. X    /* undo effects of setting up yytext */
  2252. X    *yy_cp = yy_hold_char;
  2253. X
  2254. X    if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
  2255. X        { /* need to shift things up to make room */
  2256. X        /* +2 for EOB chars. */
  2257. X        register int number_to_move = yy_n_chars + 2;
  2258. X        register char *dest = &yy_current_buffer->yy_ch_buf[
  2259. X                    yy_current_buffer->yy_buf_size + 2];
  2260. X        register char *source =
  2261. X                &yy_current_buffer->yy_ch_buf[number_to_move];
  2262. X
  2263. X        while ( source > yy_current_buffer->yy_ch_buf )
  2264. X            *--dest = *--source;
  2265. X
  2266. X        yy_cp += dest - source;
  2267. X        yy_bp += dest - source;
  2268. X        yy_n_chars = yy_current_buffer->yy_buf_size;
  2269. X
  2270. X        if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
  2271. X            YY_FATAL_ERROR( "flex scanner push-back overflow" );
  2272. X        }
  2273. X
  2274. X    if ( yy_cp > yy_bp && yy_cp[-1] == '\n' )
  2275. X        yy_cp[-2] = '\n';
  2276. X
  2277. X    *--yy_cp = (char) c;
  2278. X
  2279. X
  2280. X    /* Note: the formal parameter *must* be called "yy_bp" for this
  2281. X     * macro to now work correctly.
  2282. X     */
  2283. X    YY_DO_BEFORE_ACTION; /* set up yytext again */
  2284. X    }
  2285. X
  2286. X
  2287. X#ifdef __cplusplus
  2288. Xstatic int yyinput()
  2289. X#else
  2290. Xstatic int input()
  2291. X#endif
  2292. X    {
  2293. X    int c;
  2294. X
  2295. X    *yy_c_buf_p = yy_hold_char;
  2296. X
  2297. X    if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
  2298. X        {
  2299. X        /* yy_c_buf_p now points to the character we want to return.
  2300. X         * If this occurs *before* the EOB characters, then it's a
  2301. X         * valid NUL; if not, then we've hit the end of the buffer.
  2302. X         */
  2303. X        if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
  2304. X            /* This was really a NUL. */
  2305. X            *yy_c_buf_p = '\0';
  2306. X
  2307. X        else
  2308. X            { /* need more input */
  2309. X            yytext_ptr = yy_c_buf_p;
  2310. X            ++yy_c_buf_p;
  2311. X
  2312. X            switch ( yy_get_next_buffer() )
  2313. X                {
  2314. X                case EOB_ACT_END_OF_FILE:
  2315. X                    {
  2316. X                    if ( yywrap() )
  2317. X                        {
  2318. X                        yy_c_buf_p =
  2319. X                        yytext_ptr + YY_MORE_ADJ;
  2320. X                        return EOF;
  2321. X                        }
  2322. X
  2323. X                    YY_NEW_FILE;
  2324. X#ifdef __cplusplus
  2325. X                    return yyinput();
  2326. X#else
  2327. X                    return input();
  2328. X#endif
  2329. X                    }
  2330. X
  2331. X                case EOB_ACT_CONTINUE_SCAN:
  2332. X                    yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
  2333. X                    break;
  2334. X
  2335. X                case EOB_ACT_LAST_MATCH:
  2336. X#ifdef __cplusplus
  2337. X                    YY_FATAL_ERROR(
  2338. X                    "unexpected last match in yyinput()" );
  2339. X#else
  2340. X                    YY_FATAL_ERROR(
  2341. X                    "unexpected last match in input()" );
  2342. X#endif
  2343. X                }
  2344. X            }
  2345. X        }
  2346. X
  2347. X    c = *(unsigned char *) yy_c_buf_p;    /* cast for 8-bit char's */
  2348. X    *yy_c_buf_p = '\0';    /* preserve yytext */
  2349. X    yy_hold_char = *++yy_c_buf_p;
  2350. X
  2351. X    return c;
  2352. X    }
  2353. X
  2354. X
  2355. X#ifdef YY_USE_PROTOS
  2356. Xvoid yyrestart( FILE *input_file )
  2357. X#else
  2358. Xvoid yyrestart( input_file )
  2359. XFILE *input_file;
  2360. X#endif
  2361. X    {
  2362. X    if ( ! yy_current_buffer )
  2363. X        yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
  2364. X
  2365. X    yy_init_buffer( yy_current_buffer, input_file );
  2366. X    yy_load_buffer_state();
  2367. X    }
  2368. X
  2369. X
  2370. X#ifdef YY_USE_PROTOS
  2371. Xvoid yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
  2372. X#else
  2373. Xvoid yy_switch_to_buffer( new_buffer )
  2374. XYY_BUFFER_STATE new_buffer;
  2375. X#endif
  2376. X    {
  2377. X    if ( yy_current_buffer == new_buffer )
  2378. X        return;
  2379. X
  2380. X    if ( yy_current_buffer )
  2381. X        {
  2382. X        /* Flush out information for old buffer. */
  2383. X        *yy_c_buf_p = yy_hold_char;
  2384. X        yy_current_buffer->yy_buf_pos = yy_c_buf_p;
  2385. X        yy_current_buffer->yy_n_chars = yy_n_chars;
  2386. X        }
  2387. X
  2388. X    yy_current_buffer = new_buffer;
  2389. X    yy_load_buffer_state();
  2390. X
  2391. X    /* We don't actually know whether we did this switch during
  2392. X     * EOF (yywrap()) processing, but the only time this flag
  2393. X     * is looked at is after yywrap() is called, so it's safe
  2394. X     * to go ahead and always set it.
  2395. X     */
  2396. X    yy_did_buffer_switch_on_eof = 1;
  2397. X    }
  2398. X
  2399. X
  2400. X#ifdef YY_USE_PROTOS
  2401. Xvoid yy_load_buffer_state( void )
  2402. X#else
  2403. Xvoid yy_load_buffer_state()
  2404. X#endif
  2405. X    {
  2406. X    yy_n_chars = yy_current_buffer->yy_n_chars;
  2407. X    yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
  2408. X    yyin = yy_current_buffer->yy_input_file;
  2409. X    yy_hold_char = *yy_c_buf_p;
  2410. X    }
  2411. X
  2412. X
  2413. X#ifdef YY_USE_PROTOS
  2414. XYY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
  2415. X#else
  2416. XYY_BUFFER_STATE yy_create_buffer( file, size )
  2417. XFILE *file;
  2418. Xint size;
  2419. X#endif
  2420. X    {
  2421. X    YY_BUFFER_STATE b;
  2422. X
  2423. X    b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
  2424. X
  2425. X    if ( ! b )
  2426. X        YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
  2427. X
  2428. X    b->yy_buf_size = size;
  2429. X
  2430. X    /* yy_ch_buf has to be 2 characters longer than the size given because
  2431. X     * we need to put in 2 end-of-buffer characters.
  2432. X     */
  2433. X    b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
  2434. X
  2435. X    if ( ! b->yy_ch_buf )
  2436. X        YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
  2437. X
  2438. X    yy_init_buffer( b, file );
  2439. X
  2440. X    return b;
  2441. X    }
  2442. X
  2443. X
  2444. X#ifdef YY_USE_PROTOS
  2445. Xvoid yy_delete_buffer( YY_BUFFER_STATE b )
  2446. X#else
  2447. Xvoid yy_delete_buffer( b )
  2448. XYY_BUFFER_STATE b;
  2449. X#endif
  2450. X    {
  2451. X    if ( b == yy_current_buffer )
  2452. X        yy_current_buffer = (YY_BUFFER_STATE) 0;
  2453. X
  2454. X    yy_flex_free( (void *) b->yy_ch_buf );
  2455. X    yy_flex_free( (void *) b );
  2456. X    }
  2457. X
  2458. X
  2459. X#ifdef YY_USE_PROTOS
  2460. Xvoid yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
  2461. X#else
  2462. Xvoid yy_init_buffer( b, file )
  2463. XYY_BUFFER_STATE b;
  2464. XFILE *file;
  2465. X#endif
  2466. X    {
  2467. X    b->yy_input_file = file;
  2468. X
  2469. X    /* We put in the '\n' and start reading from [1] so that an
  2470. X     * initial match-at-newline will be true.
  2471. X     */
  2472. X
  2473. X    b->yy_ch_buf[0] = '\n';
  2474. X    b->yy_n_chars = 1;
  2475. X
  2476. X    /* We always need two end-of-buffer characters.  The first causes
  2477. X     * a transition to the end-of-buffer state.  The second causes
  2478. X     * a jam in that state.
  2479. X     */
  2480. X    b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
  2481. X    b->yy_ch_buf[2] = YY_END_OF_BUFFER_CHAR;
  2482. X
  2483. X    b->yy_buf_pos = &b->yy_ch_buf[1];
  2484. X
  2485. X    b->yy_is_interactive = file ? isatty( fileno(file) ) : 0;
  2486. X
  2487. X    b->yy_fill_buffer = 1;
  2488. X
  2489. X    b->yy_buffer_status = YY_BUFFER_NEW;
  2490. X    }
  2491. X
  2492. X
  2493. X#ifdef YY_USE_PROTOS
  2494. Xstatic void yy_push_state( int new_state )
  2495. X#else
  2496. Xstatic void yy_push_state( new_state )
  2497. Xint new_state;
  2498. X#endif
  2499. X    {
  2500. X    if ( yy_start_stack_ptr >= yy_start_stack_depth )
  2501. X        {
  2502. X        int new_size;
  2503. X
  2504. X        yy_start_stack_depth += YY_START_STACK_INCR;
  2505. X        new_size = yy_start_stack_depth * sizeof( int );
  2506. X
  2507. X        if ( ! yy_start_stack )
  2508. X            yy_start_stack = (int *) yy_flex_alloc( new_size );
  2509. X
  2510. X        else
  2511. X            yy_start_stack = (int *) yy_flex_realloc(
  2512. X                    (void *) yy_start_stack, new_size );
  2513. X
  2514. X        if ( ! yy_start_stack )
  2515. X            YY_FATAL_ERROR(
  2516. X            "out of memory expanding start-condition stack" );
  2517. X        }
  2518. X
  2519. X    yy_start_stack[yy_start_stack_ptr++] = YY_START;
  2520. X
  2521. X    BEGIN(new_state);
  2522. X    }
  2523. X
  2524. X
  2525. Xstatic void yy_pop_state()
  2526. X    {
  2527. X    if ( --yy_start_stack_ptr < 0 )
  2528. X        YY_FATAL_ERROR( "start-condition stack underflow" );
  2529. X
  2530. X    BEGIN(yy_start_stack[yy_start_stack_ptr]);
  2531. X    }
  2532. X
  2533. X
  2534. Xstatic int yy_top_state()
  2535. X    {
  2536. X    return yy_start_stack[yy_start_stack_ptr - 1];
  2537. X    }
  2538. X
  2539. X
  2540. X#ifdef YY_USE_PROTOS
  2541. Xstatic void yy_fatal_error( const char msg[] )
  2542. X#else
  2543. Xstatic void yy_fatal_error( msg )
  2544. Xchar msg[];
  2545. X#endif
  2546. X    {
  2547. X    (void) fprintf( stderr, "%s\n", msg );
  2548. X    exit( 1 );
  2549. X    }
  2550. X
  2551. X
  2552. X
  2553. X/* Redefine yyless() so it works in section 3 code. */
  2554. X
  2555. X#undef yyless
  2556. X#define yyless(n) \
  2557. X    do \
  2558. X        { \
  2559. X        /* Undo effects of setting up yytext. */ \
  2560. X        yytext[yyleng] = yy_hold_char; \
  2561. X        yy_c_buf_p = yytext + n - YY_MORE_ADJ; \
  2562. X        yy_hold_char = *yy_c_buf_p; \
  2563. X        *yy_c_buf_p = '\0'; \
  2564. X        yyleng = n; \
  2565. X        } \
  2566. X    while ( 0 )
  2567. X
  2568. X
  2569. X/* Internal utility routines. */
  2570. X
  2571. X#ifndef yytext_ptr
  2572. X#ifdef YY_USE_PROTOS
  2573. Xstatic void yy_flex_strncpy( char *s1, const char *s2, int n )
  2574. X#else
  2575. Xstatic void yy_flex_strncpy( s1, s2, n )
  2576. Xchar *s1;
  2577. Xconst char *s2;
  2578. Xint n;
  2579. X#endif
  2580. X    {
  2581. X    register int i;
  2582. X    for ( i = 0; i < n; ++i )
  2583. X        s1[i] = s2[i];
  2584. X    }
  2585. X#endif
  2586. X
  2587. X
  2588. X#ifdef YY_USE_PROTOS
  2589. Xstatic void *yy_flex_alloc( unsigned int size )
  2590. X#else
  2591. Xstatic void *yy_flex_alloc( size )
  2592. Xunsigned int size;
  2593. X#endif
  2594. X    {
  2595. X    return (void *) malloc( size );
  2596. X    }
  2597. X
  2598. X#ifdef YY_USE_PROTOS
  2599. Xstatic void *yy_flex_realloc( void *ptr, unsigned int size )
  2600. X#else
  2601. Xstatic void *yy_flex_realloc( ptr, size )
  2602. Xvoid *ptr;
  2603. Xunsigned int size;
  2604. X#endif
  2605. X    {
  2606. X    return (void *) realloc( ptr, size );
  2607. X    }
  2608. X
  2609. X#ifdef YY_USE_PROTOS
  2610. Xstatic void yy_flex_free( void *ptr )
  2611. X#else
  2612. Xstatic void yy_flex_free( ptr )
  2613. Xvoid *ptr;
  2614. X#endif
  2615. X    {
  2616. X    free( ptr );
  2617. X    }
  2618. X# line 231 "src/objc2latex.l"
  2619. X
  2620. X
  2621. X#include "main.c"
  2622. END_OF_FILE
  2623.   if test 23224 -ne `wc -c <'src/objc2latex.c.B'`; then
  2624.     echo shar: \"'src/objc2latex.c.B'\" unpacked with wrong size!
  2625.   elif test -f 'src/objc2latex.c.A'; then
  2626.     echo shar: Combining  \"'src/objc2latex.c'\" \(58178 characters\)
  2627.     cat 'src/objc2latex.c.A' 'src/objc2latex.c.B' > 'src/objc2latex.c'
  2628.     if test 58178 -ne `wc -c <'src/objc2latex.c'`; then
  2629.       echo shar: \"'src/objc2latex.c'\" combined with wrong size!
  2630.     else
  2631.       rm src/objc2latex.c.A src/objc2latex.c.B 
  2632.     fi
  2633.   fi
  2634.   # end of 'src/objc2latex.c.B'
  2635. fi
  2636. echo shar: End of archive 5 \(of 8\).
  2637. cp /dev/null ark5isdone
  2638. MISSING=""
  2639. for I in 1 2 3 4 5 6 7 8 ; do
  2640.     if test ! -f ark${I}isdone ; then
  2641.     MISSING="${MISSING} ${I}"
  2642.     fi
  2643. done
  2644. if test "${MISSING}" = "" ; then
  2645.     echo You have unpacked all 8 archives.
  2646.     rm -f ark[1-9]isdone
  2647. else
  2648.     echo You still must unpack the following archives:
  2649.     echo "        " ${MISSING}
  2650. fi
  2651. exit 0
  2652. exit 0 # Just in case...
  2653.