xref: /original-bsd/usr.bin/pascal/src/0.h (revision bbb96de4)
1 /*
2  * Copyright (c) 1980 Regents of the University of California.
3  * All rights reserved.  The Berkeley software License Agreement
4  * specifies the terms and conditions for redistribution.
5  *
6  *	@(#)0.h	5.2 (Berkeley) 06/20/85
7  */
8 
9 #define DEBUG
10 #define CONSETS
11 #define	CHAR
12 #define	STATIC
13 #define hp21mx 0
14 
15 #include	<stdio.h>
16 #include	<sys/types.h>
17 #undef roundup
18 
19 typedef enum {FALSE, TRUE} bool;
20 
21 /*
22  * Option flags
23  *
24  * The following options are recognized in the text of the program
25  * and also on the command line:
26  *
27  *	b	block buffer the file output
28  *
29  *	i	make a listing of the procedures and functions in
30  *		the following include files
31  *
32  *	l	make a listing of the program
33  *
34  *	n	place each include file on a new page with a header
35  *
36  *	p	disable post mortem and statement limit counting
37  *
38  *	t	disable run-time tests
39  *
40  *	u	card image mode; only first 72 chars of input count
41  *
42  *	w	suppress special diagnostic warnings
43  *
44  *	z	generate counters for an execution profile
45  */
46 #ifdef DEBUG
47 bool	fulltrace, errtrace, testtrace, yyunique;
48 #endif DEBUG
49 
50 /*
51  * Each option has a stack of 17 option values, with opts giving
52  * the current, top value, and optstk the value beneath it.
53  * One refers to option `l' as, e.g., opt('l') in the text for clarity.
54  */
55 char	opts[ 'z' - 'A' + 1];
56 short	optstk[ 'z' - 'A' + 1];
57 
58 #define opt(c) opts[c-'A']
59 
60 /*
61  * Monflg is set when we are generating
62  * a pxp profile.  this is set by the -z command line option.
63  */
64 bool	monflg;
65 
66     /*
67      *	profflag is set when we are generating a prof profile.
68      *	this is set by the -p command line option.
69      */
70 #ifdef PC
71 bool	profflag;
72 #endif
73 
74 
75 /*
76  * NOTES ON THE DYNAMIC NATURE OF THE DATA STRUCTURES
77  *
78  * Pi uses expandable tables for
79  * its namelist (symbol table), string table
80  * hash table, and parse tree space.  The following
81  * definitions specify the size of the increments
82  * for these items in fundamental units so that
83  * each uses approximately 1024 bytes.
84  */
85 
86 #define	STRINC	1024		/* string space increment */
87 #define	TRINC	1024		/* tree space increment */
88 #define	HASHINC	509		/* hash table size in words, each increment */
89 #define	NLINC	56		/* namelist increment size in nl structs */
90 
91 /*
92  * The initial sizes of the structures.
93  * These should be large enough to compile
94  * an "average" sized program so as to minimize
95  * storage requests.
96  * On a small system or and 11/34 or 11/40
97  * these numbers can be trimmed to make the
98  * compiler smaller.
99  */
100 #define	ITREE	2000
101 #define	INL	200
102 #define	IHASH	509
103 
104 /*
105  * The following limits on hash and tree tables currently
106  * allow approximately 1200 symbols and 20k words of tree
107  * space.  The fundamental limit of 64k total data space
108  * should be exceeded well before these are full.
109  */
110 /*
111  * TABLE_MULTIPLIER is for uniformly increasing the sizes of the tables
112  */
113 #ifdef ADDR32
114 #define TABLE_MULTIPLIER	8
115 #endif ADDR32
116 #ifdef ADDR16
117 #define TABLE_MULTIPLIER	1
118 #endif ADDR16
119 #define	MAXHASH	(4 * TABLE_MULTIPLIER)
120 #define	MAXNL	(12 * TABLE_MULTIPLIER)
121 #define	MAXTREE	(40 * TABLE_MULTIPLIER)
122 /*
123  * MAXDEPTH is the depth of the parse stack.
124  * STACK_MULTIPLIER is for increasing its size.
125  */
126 #ifdef ADDR32
127 #define	STACK_MULTIPLIER	8
128 #endif ADDR32
129 #ifdef ADDR16
130 #define	STACK_MULTIPLIER	1
131 #endif ADDR16
132 #define	MAXDEPTH ( 150 * STACK_MULTIPLIER )
133 
134 /*
135  * ERROR RELATED DEFINITIONS
136  */
137 
138 /*
139  * Exit statuses to pexit
140  *
141  * AOK
142  * ERRS		Compilation errors inhibit obj productin
143  * NOSTART	Errors before we ever got started
144  * DIED		We ran out of memory or some such
145  */
146 #define	AOK	0
147 #define	ERRS	1
148 #define	NOSTART	2
149 #define	DIED	3
150 
151 bool	Recovery;
152 
153 #define	eholdnl()	Eholdnl = TRUE
154 #define	nocascade()	Enocascade = TRUE
155 
156 bool	Eholdnl, Enocascade;
157 
158 
159 /*
160  * The flag eflg is set whenever we have a hard error.
161  * The character in errpfx will precede the next error message.
162  * When cgenflg is set code generation is suppressed.
163  * This happens whenver we have an error (i.e. if eflg is set)
164  * and when we are walking the tree to determine types only.
165  */
166 bool	eflg;
167 char	errpfx;
168 
169 #define	setpfx(x)	errpfx = x
170 
171 #define	standard()	setpfx('s')
172 #define	warning()	setpfx('w')
173 #define	recovered()	setpfx('e')
174 #define	continuation()	setpfx(' ')
175 
176 int	cgenflg;
177 
178 
179 /*
180  * The flag syneflg is used to suppress the diagnostics of the form
181  *	E 10 a, defined in someprocedure, is neither used nor set
182  * when there were syntax errors in "someprocedure".
183  * In this case, it is likely that these warinings would be spurious.
184  */
185 bool	syneflg;
186 
187 /*
188  * The compiler keeps its error messages in a file.
189  * The variable efil is the unit number on which
190  * this file is open for reading of error message text.
191  * Similarly, the file ofil is the unit of the file
192  * "obj" where we write the interpreter code.
193  */
194 short	efil;
195 
196 #ifdef OBJ
197 short	ofil;
198 
199 short	obuf[518];
200 #endif
201 
202 bool	Enoline;
203 #define	elineoff()	Enoline = TRUE
204 #define	elineon()	Enoline = FALSE
205 
206 
207 /*
208  * SYMBOL TABLE STRUCTURE DEFINITIONS
209  *
210  * The symbol table is henceforth referred to as the "namelist".
211  * It consists of a number of structures of the form "nl" below.
212  * These are contained in a number of segments of the symbol
213  * table which are dynamically allocated as needed.
214  * The major namelist manipulation routines are contained in the
215  * file "nl.c".
216  *
217  * The major components of a namelist entry are the "symbol", giving
218  * a pointer into the string table for the string associated with this
219  * entry and the "class" which tells which of the (currently 19)
220  * possible types of structure this is.
221  *
222  * Many of the classes use the "type" field for a pointer to the type
223  * which the entry has.
224  *
225  * Other pieces of information in more than one class include the block
226  * in which the symbol is defined, flags indicating whether the symbol
227  * has been used and whether it has been assigned to, etc.
228  *
229  * A more complete discussion of the features of the namelist is impossible
230  * here as it would be too voluminous.  Refer to the "PI 1.0 Implementation
231  * Notes" for more details.
232  */
233 
234 /*
235  * The basic namelist structure.
236  * There is a union of data types defining the stored information
237  * as pointers, integers, longs, or a double.
238  *
239  * The array disptab defines the hash header for the symbol table.
240  * Symbols are hashed based on the low 6 bits of their pointer into
241  * the string table; see the routines in the file "lookup.c" and also "fdec.c"
242  * especially "funcend".
243  */
244 extern int	pnumcnt;
245 
246 struct	nl {
247 	char	*symbol;
248 	char	info[4];
249 	struct	nl *type;
250 	struct	nl *chain, *nl_next;
251 	union {
252 		struct nl *un_ptr[5];
253 		int	   un_value[5];
254 		long	   un_range[2];
255 		double	   un_real;
256 		struct nl  *un_nptr[5];	/* Points to conformant array bounds */
257 	} nl_un;
258 #	ifdef PTREE
259 	    pPointer	inTree;
260 #	endif PTREE
261 };
262 
263 #define class		info[0]
264 #define nl_flags	info[1]
265 #define nl_block	info[1]
266 #define extra_flags	info[2]
267 #define align_info	info[3]
268 
269 #define range	nl_un.un_range
270 #define value	nl_un.un_value
271 #define ptr	nl_un.un_ptr
272 #define real	nl_un.un_real
273 #define nptr	nl_un.un_nptr
274 
275 extern struct nl *nlp, *disptab[077+1], *Fp;
276 extern struct nl nl[INL];
277 
278 
279 /*
280  * NL FLAGS BITS
281  *
282  * Definitions of the usage of the bits in
283  * the nl_flags byte. Note that the low 5 bits of the
284  * byte are the "nl_block" and that some classes make use
285  * of this byte as a "width".
286  *
287  * The only non-obvious bit definition here is "NFILES"
288  * which records whether a structure contains any files.
289  * Such structures are not allowed to be dynamically allocated.
290  */
291 
292 #define	BLOCKNO( flag )	( flag & 037 )
293 #define NLFLAGS( flag ) ( flag &~ 037 )
294 
295 #define	NUSED	0100
296 #define	NMOD	0040
297 #define	NFORWD	0200
298 #define	NFILES	0200
299 #ifdef PC
300 #define NEXTERN 0001	/* flag used to mark external funcs and procs */
301 #define	NLOCAL	0002	/* variable is a local */
302 #define	NPARAM	0004	/* variable is a parameter */
303 #define	NGLOBAL	0010	/* variable is a global */
304 #define	NREGVAR	0020	/* or'ed in if variable is in a register */
305 #define NNLOCAL 0040	/* named local variable, not used in symbol table */
306 #endif PC
307 
308 /*
309  * used to mark value[ NL_FORV ] for loop variables
310  */
311 #define	FORVAR		1
312 
313 /*
314  * Definition of the commonly used "value" fields.
315  * The most important one is NL_OFFS which gives
316  * the offset of a variable in its stack mark.
317  */
318 #define NL_OFFS	0
319 
320 #define	NL_CNTR	1
321 #define NL_NLSTRT 2
322 #define	NL_LINENO 3
323 #define	NL_FVAR	3
324 #define	NL_ENTLOC 4	/* FUNC, PROC - entry point */
325 #define	NL_FCHAIN 4	/* FFUNC, FPROC - ptr to formals */
326 
327 #define NL_GOLEV 2
328 #define NL_GOLINE 3
329 #define NL_FORV 1
330 
331     /*
332      *	nlp -> nl_un.un_ptr[] subscripts for records
333      *	NL_FIELDLIST	the chain of fixed fields of a record, in order.
334      *			the fields are also chained through ptr[NL_FIELDLIST].
335      *			this does not include the tag, or fields of variants.
336      *	NL_VARNT	pointer to the variants of a record,
337      *			these are then chained through the .chain field.
338      *	NL_VTOREC	pointer from a VARNT to the RECORD that is the variant.
339      *	NL_TAG		pointer from a RECORD to the tagfield
340      *			if there are any variants.
341      *	align_info	the alignment of a RECORD is in info[3].
342      */
343 #define	NL_FIELDLIST	1
344 #define	NL_VARNT	2
345 #define	NL_VTOREC	2
346 #define	NL_TAG		3
347 /* and align_info is info[3].  #defined above */
348 
349 #define	NL_ELABEL 4	/* SCAL - ptr to definition of enums */
350 
351 /*
352  * For BADUSE nl structures, NL_KINDS is a bit vector
353  * indicating the kinds of illegal usages complained about
354  * so far.  For kind of bad use "kind", "1 << kind" is set.
355  * The low bit is reserved as ISUNDEF to indicate whether
356  * this identifier is totally undefined.
357  */
358 #define	NL_KINDS	0
359 
360 #define	ISUNDEF		1
361 
362     /*
363      *	variables come in three flavors: globals, parameters, locals;
364      *	they can also hide in registers, but that's a different flag
365      */
366 #define PARAMVAR	1
367 #define LOCALVAR	2
368 #define	GLOBALVAR	3
369 #define	NAMEDLOCALVAR	4
370 
371 /*
372  * NAMELIST CLASSES
373  *
374  * The following are the namelist classes.
375  * Different classes make use of the value fields
376  * of the namelist in different ways.
377  *
378  * The namelist should be redesigned by providing
379  * a number of structure definitions with one corresponding
380  * to each namelist class, ala a variant record in Pascal.
381  */
382 #define	BADUSE	0
383 #define	CONST	1
384 #define	TYPE	2
385 #define	VAR	3
386 #define	ARRAY	4
387 #define	PTRFILE	5
388 #define	RECORD	6
389 #define	FIELD	7
390 #define	PROC	8
391 #define	FUNC	9
392 #define	FVAR	10
393 #define	REF	11
394 #define	PTR	12
395 #define	FILET	13
396 #define	SET	14
397 #define	RANGE	15
398 #define	LABEL	16
399 #define	WITHPTR 17
400 #define	SCAL	18
401 #define	STR	19
402 #define	PROG	20
403 #define	IMPROPER 21
404 #define	VARNT	22
405 #define	FPROC	23
406 #define	FFUNC	24
407 #define CRANGE	25
408 
409 /*
410  * Clnames points to an array of names for the
411  * namelist classes.
412  */
413 char	**clnames;
414 
415 /*
416  * PRE-DEFINED NAMELIST OFFSETS
417  *
418  * The following are the namelist offsets for the
419  * primitive types. The ones which are negative
420  * don't actually exist, but are generated and tested
421  * internally. These definitions are sensitive to the
422  * initializations in nl.c.
423  */
424 #define	TFIRST -7
425 #define	TFILE  -7
426 #define	TREC   -6
427 #define	TARY   -5
428 #define	TSCAL  -4
429 #define	TPTR   -3
430 #define	TSET   -2
431 #define	TSTR   -1
432 #define	NIL	0
433 #define	TBOOL	1
434 #define	TCHAR	2
435 #define	TINT	3
436 #define	TDOUBLE	4
437 #define	TNIL	5
438 #define	T1INT	6
439 #define	T2INT	7
440 #define	T4INT	8
441 #define	T1CHAR	9
442 #define	T1BOOL	10
443 #define	T8REAL	11
444 #define TLAST	11
445 
446 /*
447  * SEMANTIC DEFINITIONS
448  */
449 
450 /*
451  * NOCON and SAWCON are flags in the tree telling whether
452  * a constant set is part of an expression.
453  *	these are no longer used,
454  *	since we now do constant sets at compile time.
455  */
456 #define NOCON	0
457 #define SAWCON	1
458 
459 /*
460  * The variable cbn gives the current block number,
461  * the variable bn is set as a side effect of a call to
462  * lookup, and is the block number of the variable which
463  * was found.
464  */
465 short	bn, cbn;
466 
467 /*
468  * The variable line is the current semantic
469  * line and is set in stat.c from the numbers
470  * embedded in statement type tree nodes.
471  */
472 short	line;
473 
474 /*
475  * The size of the display
476  * which defines the maximum nesting
477  * of procedures and functions allowed.
478  * Because of the flags in the current namelist
479  * this must be no greater than 32.
480  */
481 #define	DSPLYSZ 20
482 
483     /*
484      *	the following structure records whether a level declares
485      *	any variables which are (or contain) files.
486      *	this so that the runtime routines for file cleanup can be invoked.
487      */
488 bool	dfiles[ DSPLYSZ ];
489 
490 /*
491  * Structure recording information about a constant
492  * declaration.  It is actually the return value from
493  * the routine "gconst", but since C doesn't support
494  * record valued functions, this is more convenient.
495  */
496 struct {
497 	struct nl	*ctype;
498 	short		cival;
499 	double		crval;
500 	char		*cpval;	/* note used to be int * */
501 } con;
502 
503 /*
504  * The set structure records the lower bound
505  * and upper bound with the lower bound normalized
506  * to zero when working with a set. It is set by
507  * the routine setran in var.c.
508  */
509 struct {
510 	short	lwrb, uprbp;
511 } set;
512 
513     /*
514      *	structures of this kind are filled in by precset and used by postcset
515      *	to indicate things about constant sets.
516      */
517 struct csetstr {
518     struct nl	*csettype;
519     long	paircnt;
520     long	singcnt;
521     bool	comptime;
522 };
523 /*
524  * The following flags are passed on calls to lvalue
525  * to indicate how the reference is to affect the usage
526  * information for the variable being referenced.
527  * MOD is used to set the NMOD flag in the namelist
528  * entry for the variable, ASGN permits diagnostics
529  * to be formed when a for variable is assigned to in
530  * the range of the loop.
531  */
532 #define	NOFLAGS	0
533 #define	MOD	01
534 #define	ASGN	02
535 #define	NOUSE	04
536 
537     /*
538      *	the following flags are passed to lvalue and rvalue
539      *	to tell them whether an lvalue or rvalue is required.
540      *	the semantics checking is done according to the function called,
541      *	but for pc, lvalue may put out an rvalue by indirecting afterwards,
542      *	and rvalue may stop short of putting out the indirection.
543      */
544 #define	LREQ	01
545 #define	RREQ	02
546 
547 double	MAXINT;
548 double	MININT;
549 
550 /*
551  * Variables for generation of profile information.
552  * Monflg is set when we want to generate a profile.
553  * Gocnt record the total number of goto's and
554  * cnts records the current counter for generating
555  * COUNT operators.
556  */
557 short	gocnt;
558 short	cnts;
559 
560 /*
561  * Most routines call "incompat" rather than asking "!compat"
562  * for historical reasons.
563  */
564 #define incompat 	!compat
565 
566 /*
567  * Parts records which declaration parts have been seen.
568  * The grammar allows the "label" "const" "type" "var" and routine
569  * parts to be repeated and to be in any order, so that
570  * they can be detected semantically to give better
571  * error diagnostics.
572  *
573  * The flag NONLOCALVAR indicates that a non-local var has actually
574  * been used hence the display must be saved; NONLOCALGOTO indicates
575  * that a non-local goto has been done hence that a setjmp must be done.
576  */
577 int	parts[ DSPLYSZ ];
578 
579 #define	LPRT		0x0001
580 #define	CPRT		0x0002
581 #define	TPRT		0x0004
582 #define	VPRT		0x0008
583 #define	RPRT		0x0010
584 
585 #define	NONLOCALVAR	0x0020
586 #define	NONLOCALGOTO	0x0040
587 
588 /*
589  * Flags for the "you used / instead of div" diagnostic
590  */
591 bool	divchk;
592 bool	divflg;
593 
594 bool	errcnt[DSPLYSZ];
595 
596 /*
597  * Forechain links those types which are
598  *	^ sometype
599  * so that they can be evaluated later, permitting
600  * circular, recursive list structures to be defined.
601  */
602 struct	nl *forechain;
603 
604 /*
605  * Withlist links all the records which are currently
606  * opened scopes because of with statements.
607  */
608 struct	nl *withlist;
609 
610 struct	nl *intset;
611 struct	nl *input, *output;
612 struct	nl *program;
613 
614 /* progseen flag used by PC to determine if
615  * a routine segment is being compiled (and
616  * therefore no program statement seen)
617  */
618 bool	progseen;
619 
620 
621 /*
622  * STRUCTURED STATEMENT GOTO CHECKING
623  *
624  * The variable level keeps track of the current
625  * "structured statement level" when processing the statement
626  * body of blocks.  This is used in the detection of goto's into
627  * structured statements in a block.
628  *
629  * Each label's namelist entry contains two pieces of information
630  * related to this check. The first `NL_GOLEV' either contains
631  * the level at which the label was declared, `NOTYET' if the label
632  * has not yet been declared, or `DEAD' if the label is dead, i.e.
633  * if we have exited the level in which the label was defined.
634  *
635  * When we discover a "goto" statement, if the label has not
636  * been defined yet, then we record the current level and the current line
637  * for a later error check.  If the label has been already become "DEAD"
638  * then a reference to it is an error.  Now the compiler maintains,
639  * for each block, a linked list of the labels headed by "gotos[bn]".
640  * When we exit a structured level, we perform the routine
641  * ungoto in stat.c. It notices labels whose definition levels have been
642  * exited and makes them be dead. For labels which have not yet been
643  * defined, ungoto will maintain NL_GOLEV as the minimum structured level
644  * since the first usage of the label. It is not hard to see that the label
645  * must eventually be declared at this level or an outer level to this
646  * one or a goto into a structured statement will exist.
647  */
648 short	level;
649 struct	nl *gotos[DSPLYSZ];
650 
651 #define	NOTYET	10000
652 #define	DEAD	10000
653 
654 /*
655  * Noreach is true when the next statement will
656  * be unreachable unless something happens along
657  * (like exiting a looping construct) to save
658  * the day.
659  */
660 bool	noreach;
661 
662 /*
663  * UNDEFINED VARIABLE REFERENCE STRUCTURES
664  */
665 struct	udinfo {
666 	int	ud_line;
667 	struct	udinfo *ud_next;
668 	char	nullch;
669 };
670 
671 /*
672  * CODE GENERATION DEFINITIONS
673  */
674 
675 /*
676  * NSTAND is or'ed onto the abstract machine opcode
677  * for non-standard built-in procedures and functions.
678  */
679 #define	NSTAND	0400
680 
681 #define	codeon()	cgenflg++
682 #define	codeoff()	--cgenflg
683 #define	CGENNING	( cgenflg >= 0 )
684 
685 /*
686  * Codeline is the last lino output in the code generator.
687  * It used to be used to suppress LINO operators but no
688  * more since we now count statements.
689  * Lc is the intepreter code location counter.
690  *
691 short	codeline;
692  */
693 #ifdef OBJ
694 char	*lc;
695 #endif
696 
697 
698 /*
699  * Routines which need types
700  * other than "integer" to be
701  * assumed by the compiler.
702  */
703 double		atof();
704 long		lwidth();
705 long		leven();
706 long		aryconst();
707 long		a8tol();
708 long		roundup();
709 struct nl 	*tmpalloc();
710 struct nl 	*lookup();
711 double		atof();
712 int		*hash();
713 char		*alloc();
714 int		*pcalloc();
715 char		*savestr();
716 char 		*esavestr();
717 char		*parnam();
718 char		*malloc();
719 char		*getlab();
720 char		*getnext();
721 char		*skipbl();
722 char		*nameof();
723 char 		*pstrcpy();
724 char		*myctime();
725 char		*putlab();
726 bool		fcompat();
727 bool 		constval();
728 bool		precset();
729 bool		nilfnil();
730 struct nl	*funccod();
731 struct nl	*pcfunccod();
732 struct nl	*lookup1();
733 struct nl	*hdefnl();
734 struct nl	*defnl();
735 struct nl	*flvalue();
736 struct nl	*plist();
737 struct nl	*enter();
738 struct nl	*nlcopy();
739 struct nl	*tyrec();
740 struct nl	*tyary();
741 struct nl	*tyrang();
742 struct nl	*tyscal();
743 struct nl	*deffld();
744 struct nl	*stklval();
745 struct nl	*scalar();
746 struct nl	*gen();
747 struct nl	*stkrval();
748 struct nl	*funcext();
749 struct nl	*funchdr();
750 struct nl	*funcbody();
751 struct nl 	*yybaduse();
752 struct nl	*stackRV();
753 struct nl	*defvnt();
754 struct nl	*tyrec1();
755 struct nl	*reclook();
756 struct nl	*asgnop1();
757 struct nl	*pcasgconf();
758 struct nl	*gtype();
759 struct nl	*call();
760 struct nl	*lvalue();
761 struct nl	*pclvalue();
762 struct nl	*rvalue();
763 struct nl	*cset();
764 struct nl	*tycrang();
765 struct tnode	*newlist();
766 struct tnode	*addlist();
767 struct tnode	*fixlist();
768 struct tnode	*setupvar();
769 struct tnode	*setuptyrec();
770 struct tnode	*setupfield();
771 struct tnode	*tree();
772 struct tnode	*tree1();
773 struct tnode	*tree2();
774 struct tnode	*tree3();
775 struct tnode	*tree4();
776 struct tnode	*tree5();
777 
778 /*
779  * type cast NIL to keep lint happy (which is not so bad)
780  */
781 #define		NLNIL	( (struct nl *) NIL )
782 #define		TR_NIL	( (struct tnode *) NIL)
783 
784 /*
785  * Funny structures to use
786  * pointers in wild and wooly ways
787  */
788 struct cstruct{
789 	char	pchar;
790 };
791 struct {
792 	short	pint;
793 	short	pint2;
794 };
795 struct lstruct {
796 	long	plong;
797 };
798 struct {
799 	double	pdouble;
800 };
801 
802 #define	OCT	1
803 #define	HEX	2
804 
805 /*
806  * MAIN PROGRAM VARIABLES, MISCELLANY
807  */
808 
809 /*
810  * Variables forming a data base referencing
811  * the command line arguments with the "i" option, e.g.
812  * in "pi -i scanner.i compiler.p".
813  */
814 char	**pflist;
815 short	pflstc;
816 short	pfcnt;
817 
818 char	*filename;		/* current source file name */
819 long	tvec;
820 extern char	*snark;		/* SNARK */
821 extern char	*classes[ ];	/* maps namelist classes to string names */
822 
823 #define	derror error
824 
825 #ifdef	PC
826 
827     /*
828      *	the current function number, for [ lines
829      */
830     int	ftnno;
831 
832     /*
833      *	the pc output stream
834      */
835     FILE *pcstream;
836 
837 #endif PC
838