Debian Codegraph @

libctgraphics/pol.cpp

raw
1 /*****************************************************************************
2 ** FILE IDENTIFICATION
3 **
4 ** POL - Problem Oriented Language
5 **
6 ** This is part of the CTSim program
7 ** Copyright (c) 1983-2009 Kevin Rosenberg
8 **
9 ** This program is free software; you can redistribute it and/or modify
10 ** it under the terms of the GNU General Public License (version 2) as
11 ** published by the Free Software Foundation.
12 **
13 ** This program is distributed in the hope that it will be useful,
14 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
15 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 ** GNU General Public License for more details.
17 **
18 ** You should have received a copy of the GNU General Public License
19 ** along with this program; if not, write to the Free Software
20 ** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 ******************************************************************************/
22
23 #include "ct.h"
24 #include <math.h>
25 #include <stdio.h>
26 #include <ctype.h>
27 #include "ctsupport.h"
28 #include "pol.h"
29
30
31 const struct POL::KeywordCodeList POL::cmdlist[] = {
32 { "eoc", PC_EOC,},
33 { "str", PC_STR,},
34 { "com", PC_COM,},
35 { "cmd", PC_CMD,},
36 { "prg", PC_PRG,},
37 { "con", PC_CON,},
38 { "out", PC_OUT,},
39 { "ter", PC_TER,},
40 { "inb", PC_INB,},
41
42 { "nl_eoc",PC_NL_EOC,},
43 { "nl_neoc", PC_NL_NEOC,},
44 { "tron", PC_TRON,},
45 { "troff", PC_TROFF,},
46 { "file", PC_FILE,},
47 { "dump", PC_DUMP,},
48 };
49
50 const unsigned int POL::NUMCMD = (sizeof(POL::cmdlist) / sizeof (struct POL::KeywordCodeList));
51
52
53 POL::POL()
54 {
55 currentf = -1;
56 m_bTrace = false;
57 init();
58 }
59
60 POL::~POL()
61 {
62 }
63
64 void
65 POL::init ()
66 {
67 meta.eoc = SEMICOL;
68 meta.str = DQUOTE;
69 meta.com = SHARP;
70 meta.cmd = EXCLAM;
71 meta.prg = ATSIGN;
72 meta.con = AMPERSAND;
73 meta.out = DOLLAR;
74 meta.ter = PERCENT;
75 meta.inb = LBRACK;
76
77 m_bNewlineIsEOC = true;
78 m_szSkipChars[0] = EOS;
79
80
81 for (unsigned int i = 0; i < NUMCMD; i++)
82 cmdtable.installKeywordCode (cmdlist[i].keyword, cmdlist[i].code);
83
84 token.ready = false; // no token read yet
85 }
86
87
88 /* addSkipWord (w)
89 *
90 * char *w - word for pol to ignore and skip over in input
91 *
92 * tok() compares all tokens to words given to this routine. If it finds it,
93 * it will immediately read another token.
94 */
95
96 void
97 POL::addSkipWord (const char* const w)
98 {
99 skiptable.installKeywordCode (w, 0);
100 }
101
102 /* skpchar (s)
103 *
104 * skip all characters that appear in string s
105 */
106 void
107 POL::addSkipChar (int c)
108 {
109 int n = strlen (m_szSkipChars);
110 if (n < MAXSKIPCHAR) {
111 m_szSkipChars[n] = c;
112 m_szSkipChars[n+1] = 0;
113 }
114 }
115
116 // installKeyword (str, code)
117 //
118 // char *str - token string to install
119 // int code - code to return for token
120 //
121 // tok() looks for these user defined tokens. If it finds one,
122 // it stores the tokens code in the token structure and returns TT_USERTOK
123 void
124 POL::addKeyword (const char* const str, int code)
125 {
126 usertable.installKeywordCode (str, code);
127 }
128
129 /* get_word - matches tokens on a letter by letter basis
130 *
131 * char *search - string to search for
132 * int nlet - maximum number of chars to search for match
133 */
134
135 bool
136 POL::readWord (const char *search, int nlet)
137 {
138 tok (&token);
139 if (m_bTrace)
140 sys_error (ERR_TRACE, "POL matching current token %s against word %s\n", token.tokstr, search);
141
142 if (strncasecmp (search, token.tokstr, nlet) == 0) {
143 dumptok (&token);
144 return (true);
145 } else
146 return (false);
147 }
148
149 /* usertok (str,code)
150 * see if current token is a user defined token set with install()
151 *
152 * char *str - token string as read from input
153 * int *code - returned code for user defined symbol
154 * return value - true if current token has been user defined
155 * false if current token is not user defined
156 */
157 bool
158 POL::readUserToken (char *str, int *code)
159 {
160 tok (&token);
161
162 if (m_bTrace)
163 sys_error (ERR_TRACE, "POL checking if current token '%s' is user defined\n", token.tokstr);
164
165 if (token.type == TT_USERTOK) {
166 *code = token.code;
167 strcpy (str, token.tokstr);
168 dumptok (&token);
169 return (true);
170 } else {
171 *code = 0;
172 return (false);
173 }
174 }
175
176 /* isstring (s) - returns true if current token is a string
177 *
178 * char *s - pointer to place to store token string
179 */
180
181 bool
182 POL::readString (char *str)
183 {
184 tok (&token);
185
186 if (token.type == TT_STRING) {
187 strcpy (str, token.tokstr);
188 dumptok (&token);
189 return (true);
190 } else
191 return (false);
192 }
193
194 /* integer - test for an integer
195 *
196 * int *n: returned integer value
197 * int typecode = TT_INT if accept only integer values
198 * = TT_REAL if accept both real and integer values
199 * int boundcode= true if force to lie between boundries
200 * = false can take any value it likes
201 * int bb1: lower bound
202 * int bb2: upper bound
203 */
204 bool
205 POL::readInteger (int *n, int typecode, bool boundcode, int bb1, int bb2)
206 {
207 tok (&token);
208
209 if (m_bTrace)
210 sys_error (ERR_TRACE, "POL checking if current token %s is an integer\n", token.tokstr);
211
212 if (token.type == TT_INT || token.type == TT_REAL) {
213 if (boundcode) {
214 if (token.inum < bb1)
215 *n = bb1;
216 else if (token.inum > bb2)
217 *n = bb2;
218 else
219 *n = token.inum;
220 } else
221 *n = token.inum;
222 dumptok (&token);
223 return (true);
224 }
225 *n = 0;
226 return (false);
227 }
228
229 bool
230 POL::readFloat (double *n, double typecode, bool boundcode, double bb1, double bb2)
231 {
232 tok (&token);
233
234 if (m_bTrace)
235 sys_error (ERR_TRACE, "POL checking if current token %s is an floating point number\n", token.tokstr);
236
237 if (token.type == TT_INT || token.type == TT_REAL) {
238 if (boundcode) {
239 if (token.fnum < bb1)
240 *n = bb1;
241 else if (token.fnum > bb2)
242 *n = bb2;
243 else
244 *n = token.fnum;
245 } else
246 *n = token.fnum;
247 dumptok (&token);
248 return (true);
249 }
250 *n = 0.0;
251 return (false);
252 }
253
254 /*----------------------------------------------------------------------*/
255 /* skip() - skip over any token except for end of command sequence */
256 /* */
257 /* returns true if succesful skip */
258 /* returns false if already at end of command or EOF */
259 /*----------------------------------------------------------------------*/
260
261 bool
262 POL::skipTokens()
263 {
264 char term[5]; /* string of characters not to skip */
265
266 term[0] = meta.eoc;
267 if (m_bNewlineIsEOC) {
268 term[1] = NEWLINE;
269 term[2] = EOS;
270 } else
271 term[1] = EOS;
272
273 return (skipSingleToken (term));
274 }
275
276 void
277 POL::reader()
278 {
279 while (skipTokens())
280 ;
281
282 dumptok (&token); /* skip end of command token */
283 }
284
285 /* skiptok (term) - skip a token unless the first character of a token is
286 * in the string of terminators, term.
287 * char *term - string of termination characters, don't skip these characters
288 * skiptok() also does NOT skip TT_EOF
289 * returns (true) if succesful skip of a token
290 * returns (false) if didn't skip, read termination character or TT_EOF
291 */
292
293 bool
294 POL::skipSingleToken (char term[])
295 {
296 tok (&token);
297
298 if (token.type == TT_EOF
299 || (token.type == TT_SPECLCHAR && strchr(term, token.tokstr[0]) != NULL))
300 return (false);
301 else {
302 dumptok (&token);
303 return (true);
304 }
305 }
306
307 int
308 POL::tok (struct token_st *token)
309 {
310 if (token->ready == false)
311 getpol_tok(token);
312 else {
313 if (token->type == TT_EOF && lookchar() != EOF)
314 getpol_tok(token);
315 }
316 return (token->type);
317 }
318
319 void
320 POL::dumptok (struct token_st *token)
321 {
322 if (token->ready == false)
323 getpol_tok(token);
324 token->ready = false;
325 }
326
327 int
328 POL::getpol_tok (struct token_st *token)
329 {
330 KeywordCodeEntry* sym;
331
332 token->ready = false;
333 nexttok:
334 gettok (token);
335
336 if (token->type == TT_BLANK)
337 goto nexttok;
338 if (token->type == TT_SPECLCHAR) {
339 if (strchr(m_szSkipChars, token->tokstr[0]) != NULL)
340 goto nexttok;
341 if (token->tokstr[0] == NEWLINE)
342 goto nexttok;
343 if (token->tokstr[0] == meta.cmd) {
344 getcmd();
345 goto nexttok;
346 }
347 if (token->tokstr[0] == meta.com) { /* skip comment */
348 eatline ();
349 goto nexttok;
350 }
351 if (token->tokstr[0] == meta.out) {
352 getescape(token->tokstr, meta.out, MAXTOK);
353 fputs (token->tokstr, stderr);
354 goto nexttok;
355 }
356 if (token->tokstr[0] == meta.con) { /* continuation across NEWLINE */
357 while (lookchar() == BLANK || lookchar() == TAB)
358 inchar();
359 if (lookchar() == NEWLINE)
360 inchar();
361 }
362 if (token->tokstr[0] == meta.ter) { /* get input from terminal */
363 usefile (P_USE_FILE, "");
364 tok (token);
365 closefile();
366 return (token->type);
367 }
368 }
369
370 /* look for filler words */
371
372 if (skiptable.lookup (token->tokstr) != NULL) /* ignore words in skip table */
373 goto nexttok;
374
375 /* look for user defined symbols */
376
377 if ((sym = usertable.lookup (token->tokstr)) != NULL) {
378 token->type = TT_USERTOK;
379 token->code = sym->getCode();
380 } else
381 token->code = 0;
382
383 if (m_bTrace)
384 sys_error (ERR_TRACE, "POL read token '%s', type = %d\n", token->tokstr, token->type);
385
386 return (token->type);
387 }
388
389
390 int
391 POL::getcmd()
392 {
393 int tt, found;
394 char str[MAXTOK+1];
395 KeywordCodeEntry *cmd;
396 TOKEN tok;
397
398 tt = getalpha (str, MAXTOK);
399 if (tt == TT_ERROR) {
400 sys_error (ERR_WARNING, "Error in POL parameter command");
401 reader();
402 return(false);
403 }
404 if ((cmd = cmdtable.lookup (str)) == NULL) {
405 sys_error (ERR_WARNING, "POL: Unrecognized command %s", cmd);
406 reader();
407 return (false);
408 } else {
409 found = false;
410 switch (cmd->getCode()) {
411 case PC_TRON:
412 m_bTrace = true;
413 found = true;
414 break;
415 case PC_TROFF:
416 m_bTrace = false;
417 found = true;
418 break;
419 case PC_FILE:
420 found = true;
421 tt = gettok (&tok);
422 usefile (P_USE_FILE, tok.tokstr);
423 break;
424 case PC_NL_EOC:
425 found = true;
426 m_bNewlineIsEOC = true;
427 break;
428 case PC_NL_NEOC:
429 found = true;
430 m_bNewlineIsEOC = false;
431 break;
432 case PC_DUMP:
433 found = true;
434 printf("eoc = %c str = %c com = %c cmd = %c prg = %c\n",
435 meta.eoc, meta.str, meta.com, meta.cmd, meta.prg);
436 printf("con = %c out = %c ter = %c inb = %c\n",
437 meta.con, meta.out, meta.ter, meta.inb);
438 break;
439 }
440 if (found == false) {
441 tt = gettok (&tok);
442 if (tt != TT_SPECLCHAR) {
443 sys_error (ERR_SEVERE, "POL: Illegal command character");
444 return (false);
445 }
446 switch(cmd->getCode()) {
447 case PC_EOC:
448 meta.eoc = tok.tokstr[0];
449 break;
450 case PC_STR:
451 meta.str = tok.tokstr[0];
452 break;
453 case PC_COM:
454 meta.com = tok.tokstr[0];
455 break;
456 case PC_CMD:
457 meta.cmd = tok.tokstr[0];
458 break;
459 case PC_PRG:
460 meta.prg = tok.tokstr[0];
461 break;
462 case PC_CON:
463 meta.con = tok.tokstr[0];
464 break;
465 case PC_OUT:
466 meta.out = tok.tokstr[0];
467 break;
468 case PC_TER:
469 meta.ter = tok.tokstr[0];
470 break;
471 case PC_INB:
472 meta.inb = tok.tokstr[0];
473 break;
474 default:
475 printf("command not implemented\n");
476 break;
477 } /* switch (tok->type) */
478 } /* if (found == false) */
479 reader(); /* clean up command */
480 } /* if legal command */
481
482 return (true);
483 }
484
485
486 int
487 POL::gettok (TOKEN *tok)
488 {
489 int c, toktype;
490 int inum;
491 double fnum;
492 int toksiz = MAXTOK; /* maximum length of token string */
493
494 while ((c = inchar()) == BLANK || c == TAB)
495 ;
496 ungetch (c);
497
498 c = lookchar();
499 toktype = type(c);
500
501 fnum = 0.0;
502 inum = 0;
503
504 if (c == BLANK || c == TAB) { /* skip white space */
505 getblank(tok->tokstr, toksiz);
506 toktype = TT_BLANK;
507 } else if (toktype == LETTER) {
508 toktype = getalpha (tok->tokstr, toksiz);
509 } else if (c == meta.str) { /* quoted string */
510 getquote (tok->tokstr, toksiz);
511 toktype = TT_STRING;
512 } else if (type(c) == DIGIT || c == PLUS || c == HYPHEN || c == PERIOD) {
513 toktype = getnumber (tok->tokstr, toksiz, &fnum, &inum);
514 } else if (c == EOF) {
515 tok->tokstr[0] = EOS;
516 toktype = TT_EOF;
517 } else {
518 c = inchar();
519 tok->tokstr[0] = c;
520 tok->tokstr[1] = EOS;
521 toktype = TT_SPECLCHAR;
522 }
523
524 tok->type = toktype;
525 tok->ready = true;
526 if (tok->type == TT_REAL || tok->type == TT_INT) {
527 tok->fnum = fnum;
528 tok->inum = inum;
529 } else {
530 tok->fnum = 0.0;
531 tok->inum = 0;
532 }
533
534 return (toktype);
535 }
536
537
538 void
539 POL::getblank (char *s, int toksiz)
540 {
541 int c;
542
543 while ((c = inchar()) == BLANK || c == TAB)
544 ;
545 ungetch(c);
546
547 s[0] = BLANK;
548 s[1] = EOS;
549 }
550
551
552 int
553 POL::getalpha (char *s, int toksiz)
554 {
555 int i, chartype, alphatype;
556
557 if (type(lookchar()) != LETTER) {
558 s[0] = EOS;
559 return (TT_ERROR);
560 }
561
562 alphatype = TT_ALPHA;
563 for (i = 0; i < toksiz; i++) { /* get alphanumeric token */
564 s[i] = inchar();
565 chartype = type (s[i]);
566 if (chartype != LETTER && chartype != DIGIT)
567 break;
568 if (chartype == DIGIT)
569 alphatype = TT_ALPNUM;
570 }
571 ungetch(s[i]);
572
573 if (i >= toksiz)
574 sys_error (ERR_SEVERE, "POL token too long.");
575
576 s[i] = EOS; /* terminate token */
577 return (alphatype);
578 }
579
580
581 /* getquote - get quoted string from file */
582 /* have already gotten delimiter in qs[0] */
583 void
584 POL::getquote (char *qs, int toksiz)
585 {
586 int delim;
587
588 delim = inchar(); /* char = delimiter */
589 getescape(qs, delim, toksiz);
590 }
591
592
593 void
594 POL::getescape ( /* reads up to delim */
595 char *s,
596 int delim,
597 int toksiz
598 )
599 {
600 int i, c;
601
602 for (i = 0; (c = inchar()) != delim; i++) {
603 if (c == NEWLINE) {
604 sys_error (ERR_WARNING, "Missing closing delimiter.");
605 break;
606 }
607 if (i >= toksiz) {
608 sys_error (ERR_SEVERE, "string too long.");
609 break;
610 }
611 if (c == EOF) {
612 ungetch(c);
613 sys_error (ERR_SEVERE, "end of file inside quotation");
614 break;
615 } else if (c == BSLASH) { /* escape character */
616 s[i++] = c;
617 c = inchar(); /* get escaped character */
618 }
619 s[i] = c;
620 }
621 s[i] = EOS;
622 }
623
624
625 bool
626 POL::readText (char *str, int lim)
627 {
628 int c;
629 while ((c = inchar()) == BLANK || c == TAB)
630 ;
631 ungetch (c);
632 if (c == EOF) {
633 str[0] = 0;
634 return false;
635 }
636
637 int i;
638 for (i = 0; i < lim && (c = inchar()) != EOF && c != NEWLINE; i++)
639 str[i] = c;
640 ungetch (c);
641 str[i] = 0;
642
643 return true;
644 }
645
646 //----------------------------------------------
647 // Get a number for gettok()
648 //----------------------------------------------
649
650 int
651 POL::getnumber
652 (
653 char str[], /* string to return token in */
654 int strsize, /* maximum length of token string */
655 double *fnum, /* floating point value of number read */
656 int *inum /* integer value of number read */
657 )
658 {
659 int sp = 0;
660 double sign = 1.0;
661 bool isSigned = false; /* true if number prefixed by '+' or '-' */
662 *fnum = 0.0;
663 *inum = 0;
664 str[0] = EOS;
665
666 int c = inchar();
667 if (c == HYPHEN) {
668 str[sp++] = c;
669 isSigned = true;
670 sign = -1.0;
671 } else if (c == PLUS) {
672 str[sp++] = c;
673 isSigned = true;
674 sign = 1.0;
675 } else if (c == PERIOD) {
676 if (type(lookchar()) != DIGIT) {
677 str[0] = PERIOD;
678 str[1] = EOS;
679 return (TT_SPECLCHAR);
680 } else
681 ungetch (PERIOD);
682 } else if (type(c) != DIGIT) {
683 ungetch (c);
684 return (TT_ERROR);
685 } else
686 ungetch (c);
687
688 if (isSigned) {
689 c = lookchar();
690 if (c == PERIOD) {
691 inchar(); /* get period */
692 c = lookchar(); /* look at character past period */
693 ungetch (PERIOD); /* put back period */
694 if (type(c) != DIGIT) {
695 str[sp] = EOS;
696 return (TT_SPECLCHAR);
697 }
698 } else if (type (c) != DIGIT) {
699 str[sp] = EOS;
700 return (TT_SPECLCHAR);
701 }
702 }
703
704 double whole = 0.0;
705 while (type(c = inchar()) == DIGIT) {
706 if (sp < strsize)
707 str[sp++] = c;
708 whole = 10.0 * whole + (c - '0');
709 }
710 ungetch (c); /* put back non-numeric character */
711
712 if (c != PERIOD && tolower(c) != 'e') {
713 str[sp] = EOS;
714 *fnum = whole * sign;
715 if (*fnum < MIN_INT)
716 *inum = MIN_INT;
717 else if (*fnum > MAX_INT)
718 *inum = MAX_INT;
719 else
720 *inum = (int) *fnum;
721 return (TT_INT);
722 }
723
724 if (lookchar() == PERIOD) {
725 inchar();
726 if (sp < strsize)
727 str[sp++] = PERIOD;
728 }
729
730 double frac = 0.0;
731 double powerof10 = 10.0;
732
733 while (type(c = inchar()) == DIGIT) {
734 if (sp < strsize)
735 str[sp++] = c;
736 frac += (double) (c - '0') / powerof10;
737 powerof10 *= 10.0;
738 }
739 ungetch (c);
740
741 double exp = 0.0;
742 double expsign = 1.0;
743 c = inchar();
744 if (tolower(c) != 'e')
745 ungetch (c);
746 else {
747 if (sp < strsize)
748 str[sp++] = c;
749 if ((c = inchar()) == PLUS) {
750 if (sp < strsize)
751 str[sp++] = c;
752 expsign = 1.0;
753 } else if (c == HYPHEN) {
754 if (sp < strsize)
755 str[sp++] = c;
756 expsign = -1.0;
757 } else if (type(c) != DIGIT) {
758 --sp; /* erase 'e' */
759 ungetch (c);
760 ungetch ('e');
761 goto getnumexit;
762 } else
763 ungetch(c);
764
765 exp = 0;
766 while (type(c = inchar()) == DIGIT) {
767 if (sp < strsize)
768 str[sp++] = c;
769 exp = 10 * exp + (c - '0');
770 }
771 ungetch (c);
772 }
773
774 getnumexit:
775 str[sp] = EOS;
776 *fnum = sign * (whole + frac) * pow (10.0, expsign * exp);
777 if (*fnum < MIN_INT)
778 *inum = MIN_INT;
779 else if (*fnum > MAX_INT)
780 *inum = MAX_INT;
781 else
782 *inum = (int) *fnum;
783 return (TT_REAL);
784 }
785
786 void
787 POL::eatline ()
788 {
789 char term [2];
790
791 term[0] = NEWLINE;
792 term[1] = EOS;
793 skipSingleToken (term);
794 }
795
796 // return type of ASCII character
797 int
798 POL::type (int c)
799 {
800 if (isalpha(c) || c == UNDERLIN)
801 return (LETTER);
802 else if (isdigit(c))
803 return (DIGIT);
804 else
805 return (c);
806 }
807
808
809 //----------------------------------------------------------------------
810 // POL INPUT
811 //----------------------------------------------------------------------
812
813
814 /* usefile - set source of POL input
815 *
816 * int source - source of input
817 * P_USE_STR - have POL use strings as input
818 * P_USE_FILE - use file. filename is in str
819 *
820 */
821
822 void
823 POL::usefile (int source, const char *fn)
824 {
825 FILE *fp;
826
827 ++currentf;
828 if (currentf >= MAXFILE) {
829 --currentf;
830 sys_error (ERR_SEVERE, "files nested too deeply");
831 return;
832 }
833
834 while (! m_stackPushBackInput.empty())
835 m_stackPushBackInput.pop();
836
837 if (source == P_USE_STR) {
838 filep[currentf] = NULL;
839 } else if (source == P_USE_FILE) {
840 if (fn == NULL || strlen(fn) == 0) {
841 fp = stdin;
842 } else if ((fp = fopen(fn, "r")) == NULL) {
843 --currentf;
844 sys_error (ERR_SEVERE, "can't open file");
845 return;
846 }
847 filep[currentf] = fp;
848 fname[currentf] = strdup (fn);
849 }
850 }
851
852 void
853 POL::closefile()
854 {
855 if (currentf >= 0) {
856 if (filep[currentf] != NULL)
857 fclose (filep[currentf]);
858 --currentf;
859 }
860 }
861
862 /*-----------------------------*/
863 /* Lowest Level Input Routines */
864 /*-----------------------------*/
865
866
867 int
868 POL::lookchar()
869 {
870 int c;
871
872 c = inchar();
873 ungetch (c);
874 return (c);
875 }
876
877 int
878 POL::inchar()
879 {
880 int c = 0;
881
882 if (currentf < 0)
883 return (EOF);
884
885 while (currentf >= 0 && (c = getch(filep[currentf])) == EOF && filep[currentf] != NULL) {
886 closefile ();
887 }
888
889 return (c);
890 }
891
892 /*--------------------------------------------------------------*/
893 /* getch - get a (possibly pushed back) character */
894 /* if fp == NULL, then get character from inputline */
895 /*--------------------------------------------------------------*/
896
897 int
898 POL::getch (FILE *fp)
899 {
900 int c;
901 if (m_stackPushBackInput.size() > 0) {
902 c = m_stackPushBackInput.top();
903 m_stackPushBackInput.pop();
904 return c;
905 }
906
907 if (fp == NULL) {
908 if ((c = inputline[lineptr]) == EOS)
909 return (EOF);
910 else {
911 ++lineptr;
912 return (c);
913 }
914 } else
915 c = fgetc(fp);
916
917 return (c);
918 }
919
920 // push character back on input
921 void
922 POL::ungetch (int c)
923 {
924 m_stackPushBackInput.push (c);
925 }
926
927
928 int
929 POL::get_inputline (FILE *fp)
930 {
931 while (! m_stackPushBackInput.empty())
932 m_stackPushBackInput.pop();
933
934 lineptr = 0;
935 if (fgets (inputline, MAXLINE, fp) == NULL)
936 return (EOF);
937 else
938 return (OK);
939 }
940
941 void
942 POL::set_inputline (const char* const line)
943 {
944 while (! m_stackPushBackInput.empty())
945 m_stackPushBackInput.pop();
946
947 strncpy (inputline, line, MAXLINE);
948 lineptr = 0;
949 }