1 /* output.c, output generator for dlg
2  *
3  * Output Notes:
4  *
5  * DfaStates == number of dfa nodes in automaton (just a #define)
6  * DfaState == type large enough to index every node in automaton
7  *         <256 unsigned char, <65536 unsigned short, etc.
8  *
9  * Thus, the elements in each of the automaton states (st%d) are type DfaState
10  * and are size appropriately, since they must be able to index the next
11  * automaton state.
12  *
13  * dfa[] == a linear array that points to all the automaton states (st%d)
14  *         (dfa_base[] should be the same, but isn't right now)
15  *
16  * accepts[] == Taking a closer look at this one, it probably shouldn't be type
17  *         DfaState because there is no real requirement that the number of
18  *         accepts states is less than the number of dfa state.  However, if
19  *         the number of accept states was more than the number of DFA states
20  *         then the lexical specification would be really ambiguous.
21  *
22  *         Another note. Is that is should be possible to fold accepts[] and
23  *         actions[] together.  If this is done, I would suggest get rid of
24  *         accept[] and make actions[] have an entry for each state (st%d) in
25  *         the automaton.
26  *
27  * dfa_base[] == starting location for each lexical mode.  This should be
28  *         Dfastate type (but isn't right now), since it points to the states
29  *         in the automaton.
30  *
31  * dfa_class_no[] == indicates the number of columns each lexical mode has.
32  *
33  * b_class_no[] == pointer to the start of the translation array used to
34  *         convert from input character to character class.  This could cause
35  *         problems if there are more than 256 classes
36  *
37  * shift%d[] == the actual translation arrays that convert the input character
38  *         into the character class.  These will have to change if there are
39  *         more than 256 character classes.
40  *
41  * SOFTWARE RIGHTS
42  *
43  * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
44  * Set (PCCTS) -- PCCTS is in the public domain.  An individual or
45  * company may do whatever they wish with source code distributed with
46  * PCCTS or the code generated by PCCTS, including the incorporation of
47  * PCCTS, or its output, into commerical software.
48  *
49  * We encourage users to develop software with PCCTS.  However, we do ask
50  * that credit is given to us for developing PCCTS.  By "credit",
51  * we mean that if you incorporate our source code into one of your
52  * programs (commercial product, research project, or otherwise) that you
53  * acknowledge this fact somewhere in the documentation, research report,
54  * etc...  If you like PCCTS and have developed a nice tool with the
55  * output, please mention that you developed it using PCCTS.  In
56  * addition, we ask that this header remain intact in our source code.
57  * As long as these guidelines are kept, we expect to continue enhancing
58  * this system and expect to make other tools available as they are
59  * completed.
60  *
61  * DLG 1.33
62  * Will Cohen
63  * With mods by Terence Parr; AHPCRC, University of Minnesota
64  * 1989-2001
65  */
66 
67 #include <stdio.h>
68 #include <string.h>
69 #include "dlg.h"
70 #ifdef MEMCHK
71 #include "trax.h"
72 #else
73 #ifdef __STDC__
74 #include <stdlib.h>
75 #else
76 #include <malloc.h>
77 #endif /* __STDC__ */
78 #endif
79 
80 static char *mode_name[MAX_MODES];
81 static int mode_number[MAX_MODES];
82 static int cur_mode=0;
83 
84 int operation_no = 0; /* used to mark nodes so that infinite loops avoided */
85 int dfa_basep[MAX_MODES]; 	/* start of each group of states */
86 int dfa_class_nop[MAX_MODES];	/* number of elements in each group of states*/
87 
88 int gen_ansi = FALSE;		/* allows ansi code to be generated */
89 
90 FILE *input_stream;	/* where to read description from */
91 FILE *output_stream;	/* where to put the output	  */
92 FILE *mode_stream;	/* where to put the mode.h stuff */
93 FILE *class_stream;	/* where to put the scan.h stuff (if gen_cpp) */
94 
95 /* NOTE: This section is MACHINE DEPENDENT */
96 #define DIF_SIZE 4
97 #if defined(PC) && !defined(PC32)
98 unsigned long typesize[DIF_SIZE]  = { 0x7f, 0x7fff, 0x7ffful, 0x7ffffffful }; /* MR20 */
99 char t0[] = "unsigned char";
100 char t1[] = "unsigned short";
101 char t2[] = "unsigned int";
102 char t3[] = "unsigned long";
103 char *typevar[DIF_SIZE] = { t0, t1, t2, t3};
104 #else
105 unsigned long typesize[DIF_SIZE]  = { 0x7f, 0x7fff, 0x7ffffffful, 0x7ffffffful }; /* MR20 */
106 char t0[] = "unsigned char";
107 char t1[] = "unsigned short";
108 char t2[] = "unsigned int";
109 char t3[] = "unsigned long";
110 char *typevar[DIF_SIZE] = { t0, t1, t2, t3};
111 #endif
112 
113 /* Added by TJP August 1994 */
114 /* Take in MyLexer and return MyLexer_h */
115 
116 static char *
117 #ifdef __USE_PROTOS
gate_symbol(char * name)118 gate_symbol(char *name)
119 #else
120 gate_symbol(name)
121 char *name;
122 #endif
123 {
124 	static char buf[100];
125 	sprintf(buf, "%s_h", name);
126 	return buf;
127 }
128 
129 /* Added by TJP August 1994 */
130 static char *
131 #ifdef __USE_PROTOS
mystrdup(char * s)132 mystrdup(char *s)
133 #else
134 mystrdup(s)
135 char *s;
136 #endif
137 {
138 	char *p = (char *)malloc(strlen(s)+1);
139 	strcpy(p, s);
140 	return p;
141 }
142 
143 #ifdef __USE_PROTOS
p_class_hdr(void)144 void p_class_hdr(void)
145 #else
146 void p_class_hdr()
147 #endif
148 {
149 	if ( class_stream == NULL ) return;
150 	fprintf(class_stream, "#ifndef %s\n", gate_symbol(ClassName("")));
151 	fprintf(class_stream, "#define %s\n", gate_symbol(ClassName("")));
152 	fprintf(class_stream, "/*\n");
153 	fprintf(class_stream, " * D L G L e x e r  C l a s s  D e f i n i t i o n\n");
154 	fprintf(class_stream, " *\n");
155 	fprintf(class_stream, " * Generated from:");
156 	fprintf(class_stream, " %s", file_str[0]);
157 	fprintf(class_stream, "\n");
158 	fprintf(class_stream, " *\n");
159 	fprintf(class_stream, " * 1989-2001 by  Will Cohen, Terence Parr, and Hank Dietz\n");
160 	fprintf(class_stream, " * Purdue University Electrical Engineering\n");
161 	fprintf(class_stream, " * DLG Version %s\n", version);
162 	fprintf(class_stream, " */\n\n");
163 	fprintf(class_stream, "\n");
164 	fprintf(class_stream, "#include \"%s\"\n", DLEXERBASE_H);
165 }
166 
167 /* MR1									*/
168 /* MR1 16-Apr-97  Split printing of class header up into several parts  */
169 /* MR1		    so that #lexprefix <<...>>and #lexmember <<...>>	*/
170 /* MR1		    can be inserted in the appropriate spots		*/
171 /* MR1									*/
172 
173 #ifdef __USE_PROTOS
p_class_def1(void)174 void p_class_def1(void)
175 #else
176 void p_class_def1()
177 #endif
178 {
179 	if ( class_stream == NULL ) return;
180 	fprintf(class_stream, "\nclass %s : public DLGLexerBase {\n", ClassName(""));
181 	fprintf(class_stream, "public:\n");
182 }
183 
184 #ifdef __USE_PROTOS
p_class_def2(void)185 void p_class_def2(void)
186 #else
187 void p_class_def2()
188 #endif
189 {
190 	int i, m;
191 	if ( class_stream == NULL ) return;
192 	fprintf(class_stream, "public:\n");
193 	fprintf(class_stream, "\tstatic const int MAX_MODE;\n");
194 	fprintf(class_stream, "\tstatic const int DfaStates;\n");
195 	for (i=0; i<cur_mode; i++) {
196 		fprintf(class_stream, "\tstatic const int %s;\n", mode_name[i]);
197 	}
198 
199 	fprintf(class_stream, "\ttypedef %s DfaState;\n\n", minsize(dfa_allocated));
200 	fprintf(class_stream, "\t%s(DLGInputStream *in,\n",ClassName(""));
201 	fprintf(class_stream, "\t\tunsigned bufsize=2000)\n");
202 	fprintf(class_stream, "\t\t: DLGLexerBase(in, bufsize, %d)\n", interactive);
203 	fprintf(class_stream, "\t{\n");
204 	fprintf(class_stream, "\t;\n");
205 	fprintf(class_stream, "\t}\n");
206 	fprintf(class_stream, "\tvoid	  mode(int);\n");
207 	fprintf(class_stream, "\tANTLRTokenType nextTokenType(void);\n");
208 	fprintf(class_stream, "\tvoid     advance(void);\n");
209 	fprintf(class_stream, "protected:\n");
210 	for (i=1; i<=action_no; ++i) {
211 		fprintf(class_stream, "\tANTLRTokenType act%d();\n", i);
212 	}
213 
214 	for(m=0; m<(mode_counter-1); ++m){
215 		for(i=dfa_basep[m]; i<dfa_basep[m+1]; ++i)
216 			fprintf(class_stream, "\tstatic DfaState st%d[%d];\n", i-1, dfa_class_nop[m]+1);
217 	}
218 	for(i=dfa_basep[m]; i<=dfa_allocated; ++i)
219 		fprintf(class_stream, "\tstatic DfaState st%d[%d];\n", i-1, dfa_class_nop[m]+1);
220 
221 	fprintf(class_stream, "\tstatic DfaState *dfa[%d];\n", dfa_allocated);
222 	fprintf(class_stream, "\tstatic DfaState dfa_base[];\n");
223 /*	fprintf(class_stream, "\tstatic int dfa_base_no[];\n"); */
224 	fprintf(class_stream, "\tstatic unsigned char *b_class_no[];\n");
225 	fprintf(class_stream, "\tstatic DfaState accepts[%d];\n",dfa_allocated+1);
226 	fprintf(class_stream, "\tstatic DLGChar alternatives[%d];\n",dfa_allocated+1);
227 	/* WARNING: should be ANTLRTokenType for action table, but g++ 2.5.6 is hosed */
228 	fprintf(class_stream, "\tstatic ANTLRTokenType (%s::*actions[%d])();\n", ClassName(""), action_no+1);
229 	for(m=0; m<mode_counter; ++m) {
230 		fprintf(class_stream, "\tstatic unsigned char shift%d[%d];\n",
231 			m, CHAR_RANGE);
232 	}
233 	if (comp_level)
234 		fprintf(class_stream, "\tint ZZSHIFT(int c) { return b_class_no[automaton][1+c]; }\n");
235 	else
236 		fprintf(class_stream, "\tint ZZSHIFT(int c) { return 1+c; }\n");
237 
238 /* MR1									  */
239 /* MR1 11-APr-97   Kludge to allow inclusion of user-defined code in	  */
240 /* MR1			 DLGLexer class header				  */
241 /* MR1		   Deprecated in favor of 133MR1 addition #lexmember <<>> */
242 /* MR1									  */
243 /* MR1 */	fprintf(class_stream,"//\n");
244 /* MR1 */	fprintf(class_stream,
245 /* MR1 */	   "// 133MR1 Deprecated feature to allow inclusion of ");
246 /* MR1 */	fprintf(class_stream,
247 /* MR1 */	   "user-defined code in DLG class header\n");
248 /* MR1 */	fprintf(class_stream,"//\n");
249 /* MR1 */
250 /* MR1 */	fprintf(class_stream,"#ifdef DLGLexerIncludeFile\n");
251 /* MR1 */	fprintf(class_stream,"#include DLGLexerIncludeFile\n");
252 /* MR1 */	fprintf(class_stream,"#endif\n");
253 
254 	fprintf(class_stream, "};\n");
255 
256 	fprintf(class_stream, "typedef ANTLRTokenType (%s::*Ptr%sMemberFunc)();\n",
257 			ClassName(""), ClassName(""));
258 
259 	fprintf(class_stream, "#endif\n");
260 }
261 
262 /* generate required header on output */
263 
264 #ifdef __USE_PROTOS
p_head(void)265 void p_head(void)
266 #else
267 void p_head()
268 #endif
269 {
270 	fprintf(OUT, "/*\n");
271 	fprintf(OUT, " * D L G tables\n");
272 	fprintf(OUT, " *\n");
273 	fprintf(OUT, " * Generated from:");
274 	fprintf(OUT, " %s", file_str[0]);
275 	fprintf(OUT, "\n");
276 	fprintf(OUT, " *\n");
277 	fprintf(OUT, " * 1989-2001 by  Will Cohen, Terence Parr, and Hank Dietz\n");
278 	fprintf(OUT, " * Purdue University Electrical Engineering\n");
279 	fprintf(OUT, " * DLG Version %s\n", version);
280 	fprintf(OUT, " */\n\n");
281 	if ( gen_cpp)  fprintf(OUT, "#include \"pcctscfg.h\"\n");
282 	if ( gen_cpp ) fprintf(OUT, "#include \"pccts_stdio.h\"\n");
283 	if ( !gen_cpp ) fprintf(OUT, "#include \"%s\"\n\n", mode_file);
284 	fprintf(OUT,"\n");
285 }
286 
287 #ifdef __USE_PROTOS
p_includes(void)288 void p_includes(void)
289 #else
290 void p_includes()
291 #endif
292 {
293 	fprintf(OUT, "#include \"%s\"\n", APARSER_H);
294 	fprintf(OUT, "#include \"%s\"\n", DLEXERBASE_H);
295 	fprintf(OUT, "#include \"%s\"\n", ClassName(".h"));
296 }
297 
298 /* generate code to tie up any loose ends */
299 
300 #ifdef __USE_PROTOS
p_tail(void)301 void p_tail(void)   				/* MR1 */
302 #else
303 void p_tail()						/* MR1 */
304 #endif
305 {
306 	if ( gen_cpp ) {
307 		if ( strcmp(ClassName(""), DEFAULT_CLASSNAME)!=0 )
308 			fprintf(OUT, "#define DLGLexer %s\n", ClassName(""));
309 		fprintf(OUT, "#include \"%s\"\n", DLEXER_H);  /* MR23 Rename DLexer.cpp to DLexer.h */
310 		return;
311 	}
312 	fprintf(OUT, "\n");
313 	fprintf(OUT, "\n");
314 	if (comp_level)
315 		fprintf(OUT, "#define ZZSHIFT(c) (b_class_no[zzauto][1+c])\n");
316 	else
317 		fprintf(OUT, "#define ZZSHIFT(c) (1+c)\n");
318 	if ( !gen_cpp ) fprintf(OUT, "#define MAX_MODE %d\n",mode_counter);
319 	fprintf(OUT, "#include \"dlgauto.h\"\n");
320 }
321 
322 
323 /* output the table of DFA for general use */
324 
325 #ifdef __USE_PROTOS
p_tables()326 void p_tables()
327 #else
328 void p_tables()
329 #endif
330 {
331 	if ( !gen_cpp ) {
332 		fprintf(OUT, "#define DfaStates\t%d\n", dfa_allocated);
333 		fprintf(OUT, "typedef %s DfaState;\n\n", minsize(dfa_allocated));
334 	}
335 
336 	if ( gen_cpp ) {
337 		int i;
338 		fprintf(OUT, "\n");
339 		fprintf(OUT, "const int %s::MAX_MODE=%d;\n",
340 				ClassName(""),
341 				mode_counter);
342 		fprintf(OUT, "const int %s::DfaStates=%d;\n",
343 				ClassName(""),
344 				dfa_allocated);
345 		for (i=0; i<cur_mode; i++) {
346 			fprintf(OUT, "const int %s::%s=%d;\n",
347 					ClassName(""), mode_name[i], mode_number[i]);
348 		}
349 		fprintf(OUT, "\n");
350 	}
351 
352 	p_node_table();
353 	p_dfa_table();
354 	p_accept_table();
355 	p_action_table();
356 	p_base_table();
357 	p_class_table();
358 	if (comp_level)
359 		p_bshift_table();
360 	if (interactive || gen_cpp )
361 		p_alternative_table();
362 }
363 
364 
365 /* figures out the smallest variable type that will hold the transitions
366  */
367 
368 #ifdef __USE_PROTOS
minsize(int elements)369 char *minsize(int elements)
370 #else
371 char *minsize(elements)
372 int elements;
373 #endif
374 {
375 	int i = 0;
376 
377 	while ((unsigned long) elements > typesize[i]) /* MR20 */
378 		++i;
379 	return typevar[i];
380 }
381 
382 
383 #ifdef __USE_PROTOS
p_node_table(void)384 void p_node_table(void)
385 #else
386 void p_node_table()
387 #endif
388 {
389 	register int	i;
390 	register int	m = 0;
391 
392 	for(m=0; m<(mode_counter-1); ++m){
393 		for(i=dfa_basep[m]; i<dfa_basep[m+1]; ++i)
394 			p_single_node(i,dfa_class_nop[m]);
395 	}
396 	for(i=dfa_basep[m]; i<=dfa_allocated; ++i)
397 		p_single_node(i,dfa_class_nop[m]);
398 }
399 
400 
401 #ifdef __USE_PROTOS
p_single_node(int i,int classes)402 void p_single_node(int i,int classes)
403 #else
404 void p_single_node(i,classes)
405 int i,classes;
406 #endif
407 {
408 	register int	j;
409 	register int	trans, items_on_line;
410 
411 #if 1
412 	/* extra state (classes+1) for invalid characters */
413 	fprintf(OUT, "%sDfaState %sst%d[%d] = {\n  ",
414 		gen_cpp?ClassName("::"):"static ",
415 		gen_cpp?ClassName("::"):"",(i-1), (classes+1));
416 #else
417 	fprintf(OUT, "static DfaState st%d[%d] = {\n  ", (i-1), classes);
418 #endif
419 	items_on_line = MAX_ON_LINE;
420 	for(j=0; j<classes; ++j){
421 		DAWDLE;
422 		trans = DFA(i)->trans[j];
423 		if (trans == NIL_INDEX)
424 			trans = dfa_allocated+1;
425 		/* all of DFA moved down one in array */
426 		fprintf(OUT, "%d", trans-1);
427 		fprintf(OUT, ", ");
428 		if (!(--items_on_line)){
429 			fprintf(OUT, "\n  ");
430 			items_on_line = MAX_ON_LINE;
431 		}
432 	}
433 #if 1
434 	/* put in jump to error state */
435 	fprintf(OUT, "%d\n};\n\n", dfa_allocated);
436 #else
437 	fprintf(OUT, "\n};\n\n");
438 #endif
439 }
440 
441 
442 #ifdef __USE_PROTOS
p_dfa_table(void)443 void p_dfa_table(void)
444 #else
445 void p_dfa_table()
446 #endif
447 {
448 	register int	i;
449 
450 	fprintf(OUT, "\n%sDfaState *%sdfa[%d] = {\n",
451 		gen_cpp?ClassName("::"):"",gen_cpp?ClassName("::"):"", dfa_allocated);
452 	for (i=0; i<(dfa_allocated-1); ++i){
453 		fprintf(OUT, "\tst%d,\n", i);
454 	}
455 	fprintf(OUT, "\tst%d\n", i);
456 	fprintf(OUT, "};\n\n");
457 }
458 
459 
460 #ifdef __USE_PROTOS
p_accept_table(void)461 void p_accept_table(void)
462 #else
463 void p_accept_table()
464 #endif
465 {
466 	register int	i = 1;
467 	register int	items_on_line = 0;
468 	int		true_interactive = TRUE;
469 
470 	/* make sure element for one past (zzerraction) -WEC 12/16/92 */
471 	fprintf(OUT,"\n%sDfaState %saccepts[%d] = {\n  ",
472 			gen_cpp?ClassName("::"):"",
473 			gen_cpp?ClassName("::"):"",
474 			dfa_allocated+1);
475 	/* don't do anything if no dfa nodes */
476 	if (i>dfa_allocated) goto skip_accepts;
477 	for (;;) {
478 		int accept=0;   /* MR14a - Manuel Kessler (mlkessle@cip.physik.uni-wuerzburg.de) */
479 		set accept_set;
480 		set nfa_states;
481 		unsigned int *t, *nfa_i;
482 		unsigned int *q, *regular_expr;
483 
484 		accept_set = empty;
485 		nfa_states = DFA(i)->nfa_states;
486 		t = nfa_i = set_pdq(nfa_states);
487 		/* NOTE: picks lowest accept because accepts monotonic	*/
488 		/*	with respect to nfa node numbers and set_pdq	*/
489 		/*	returns in that order				*/
490 		while((*nfa_i != nil) && (!(accept = NFA(*nfa_i)->accept))){
491 			nfa_i++;
492 		}
493 
494 		/* figure out if more than one accept state there */
495 		if (warn_ambig ){
496 			set_orel(accept, &accept_set);
497 			while(*nfa_i != nil){
498 				set_orel(NFA(*nfa_i)->accept, &accept_set);
499 				nfa_i++;
500 			}
501 			/* remove error action from consideration */
502 			set_rm(0, accept_set);
503 
504 			if( set_deg(accept_set)>1){
505 				fprintf(stderr, "dlg warning: ambiguous regular expression ");
506 				q = regular_expr = set_pdq(accept_set);
507 				while(*regular_expr != nil){
508 					fprintf(stderr," %d ", *regular_expr);
509 					++regular_expr;
510 				}
511 				fprintf(stderr, "\n");
512 				free(q);
513 			}
514 		}
515 
516 		if ((DFA(i)->alternatives) && (accept != 0)){
517 			true_interactive = FALSE;
518 		}
519 		fprintf(OUT, "%d, ", accept);
520 
521 		/* free up memory before we "break" below -ATG 4/6/95 */
522 		free(t);
523 		set_free(accept_set);
524 
525 		if ((++i)>dfa_allocated)
526 			break;
527 		if ((++items_on_line)>=MAX_ON_LINE){
528 			fprintf(OUT,"\n  ");
529 			items_on_line = 0;
530 		}
531 /*
532 		free(t);
533 		set_free(accept_set);
534 */
535 	}
536 	/* make sure element for one past (zzerraction) -WEC 12/16/92 */
537 skip_accepts:
538 	fprintf(OUT, "0\n};\n\n");
539 }
540 
541 
542 #ifdef __USE_PROTOS
p_action_table(void)543 void p_action_table(void)
544 #else
545 void p_action_table()
546 #endif
547 {
548 	register int	i;
549 	char* theClassName = ClassName("");
550 
551 	if ( gen_cpp )
552 		fprintf(OUT, "Ptr%sMemberFunc %s::actions[%d] = {\n", theClassName,
553 					theClassName, action_no+1);
554 	else
555 		fprintf(OUT, "void (*actions[%d])() = {\n", action_no+1);
556 	if ( gen_cpp )
557 /*		fprintf(OUT, "\t(Ptr%sMemberFunc)&%s::erraction,\n", theClassName, theClassName);*/
558 		fprintf(OUT, "\t&%s::erraction,\n", theClassName);
559 	else
560 		fprintf(OUT, "\tzzerraction,\n");
561 	for (i=1; i<action_no; ++i) {
562 		if ( gen_cpp )
563 /*			fprintf(OUT,"\t(Ptr%sMemberFunc)&%s::act%d,\n", theClassName, theClassName, i);*/
564 			fprintf(OUT,"\t&%s::act%d,\n", theClassName, i);
565 		else
566 			fprintf(OUT,"\tact%d,\n", i);
567 		DAWDLE;
568 	}
569 	if ( gen_cpp )
570 /*		fprintf(OUT,"\t(Ptr%sMemberFunc)&%s::act%d\n", theClassName, theClassName, i);*/
571 		fprintf(OUT,"\t&%s::act%d\n", theClassName, i);
572 	else
573 		fprintf(OUT,"\tact%d\n", i);
574 	fprintf(OUT, "};\n\n");
575 }
576 
577 
578 #ifdef __USE_PROTOS
p_shift_table(int m)579 void p_shift_table(int m)  				    /* MR1 */
580 #else
581 void p_shift_table(m)						/* MR1 */
582 int m;
583 #endif
584 {
585 	register int	i = 0, j;
586 	register int	items_on_line = 0;
587 
588 	fprintf(OUT, "%s unsigned char %sshift%d[%d] = {\n  ",
589 		gen_cpp?"":"static",
590 		gen_cpp?ClassName("::"):"", m, CHAR_RANGE);
591 	for (;;) {
592 		/* find which partition character i is in */
593 		for (j=0; j<dfa_class_nop[mode_counter]; ++j){
594 			if (set_el(i,class_sets[j]))
595 				break;
596 			}
597 		fprintf(OUT,"%d",j);
598 		if ((++i)>=CHAR_RANGE)
599 			break;
600 		fprintf(OUT,", ");
601 		if ((++items_on_line)>=MAX_ON_LINE){
602 			fprintf(OUT,"\n  ");
603 			items_on_line = 0;
604 			}
605 		}
606 	fprintf(OUT, "\n};\n\n");
607 }
608 
609 
610 #ifdef __USE_PROTOS
p_base_table(void)611 void p_base_table(void)
612 #else
613 void p_base_table()
614 #endif
615 {
616 	register int m;
617 
618 	fprintf(OUT, "%sDfaState %sdfa_base[] = {\n",
619 			gen_cpp?ClassName("::"):"static ",
620 			gen_cpp?ClassName("::"):"");
621 	for(m=0; m<(mode_counter-1); ++m)
622 		fprintf(OUT, "\t%d,\n", dfa_basep[m]-1);
623 	fprintf(OUT, "\t%d\n};\n\n", dfa_basep[m]-1);
624 }
625 
626 
627 #ifdef __USE_PROTOS
p_class_table(void)628 void p_class_table(void)    				/* MR1 */
629 #else
630 void p_class_table()						/* MR1 */
631 #endif
632 {
633 #if 0
634 	register int m;
635 
636 	fprintf(OUT,"%s int %sdfa_class_no[] = {\n",
637 			gen_cpp?"":"static",
638 			gen_cpp?ClassName("::"):"");
639 	for(m=0; m<(mode_counter-1); ++m)
640 		fprintf(OUT,"\t%d,\n", dfa_class_nop[m]);
641 	fprintf(OUT,"\t%d\n};\n\n", dfa_class_nop[m]);
642 #endif
643 }
644 
645 
646 #ifdef __USE_PROTOS
p_bshift_table(void)647 void p_bshift_table(void)					/* MR1 */
648 #else
649 void p_bshift_table()						/* MR1 */
650 #endif
651 {
652 	register int m;
653 
654 	fprintf(OUT,"%s unsigned char *%sb_class_no[] = {\n",
655 		gen_cpp?"":"static",
656 		gen_cpp?ClassName("::"):"");
657 	for(m=0; m<(mode_counter-1); ++m)
658 		fprintf(OUT, "\tshift%d,\n", m);
659 	fprintf(OUT, "\tshift%d\n};\n\n", m);
660 }
661 
662 
663 #ifdef __USE_PROTOS
p_alternative_table(void)664 void p_alternative_table(void)				/* MR1 */
665 #else
666 void p_alternative_table()					/* MR1 */
667 #endif
668 {
669 	register int i;
670 
671 	if ( !gen_cpp ) fprintf(OUT, "#define ZZINTERACTIVE\n\n");
672 	if ( gen_cpp )
673 		fprintf(OUT, "DLGChar %salternatives[%d] = {\n",  /* mr23 vhs %sDfaStates+1 */
674 				ClassName("::"),
675 				dfa_allocated+1); /* vhs ClassName("::")); */
676 	else
677 		fprintf(OUT, "static %s zzalternatives[DfaStates+1] = {\n",
678 				minsize(dfa_allocated));
679 
680 	for(i=1; i<=dfa_allocated; ++i)
681 		fprintf(OUT, "\t%d,\n", DFA(i)->alternatives);
682 	fprintf(OUT, "/* must have 0 for zzalternatives[DfaStates] */\n");
683 	fprintf(OUT, "\t0\n};\n\n");
684 }
685 
686 
687 #ifdef __USE_PROTOS
p_mode_def(char * s,int m)688 void p_mode_def(char *s,int m)			/* MR1 */
689 #else
690 void p_mode_def(s,m)					/* MR1 */
691 char *s;
692 int m;
693 #endif
694 {
695 	if ( gen_cpp )
696 	{
697 		mode_name[cur_mode] = mystrdup(s);
698 		mode_number[cur_mode] = m;
699 		cur_mode++;
700 	}
701 	else
702 		fprintf(mode_stream, "#define %s %d\n", s, m);
703 }
704 
705 #ifdef __USE_PROTOS
ClassName(char * suffix)706 char * ClassName(char *suffix)
707 #else
708 char * ClassName(suffix)
709 char *suffix;
710 #endif
711 {
712 	static char buf[200];
713 	extern char *class_name;
714 
715 	sprintf(buf, "%s%s", class_name, suffix);
716 	return buf;
717 }
718 
719 #ifdef DEBUG
720 
721 /* print out a particular nfa node that is pointed to by p */
722 
723 #ifdef __USE_PROTOS
p_nfa_node(nfa_node * p)724 void p_nfa_node(nfa_node *p)
725 #else
726 void p_nfa_node(p)
727 nfa_node *p;
728 #endif
729 {
730 	 register nfa_node *t;
731 
732 	if (p != NIL_INDEX){
733 		printf("NFA state : %d\naccept state : %d\n",
734 			NFA_NO(p),p->accept);
735 		if (p->trans[0] != NIL_INDEX){
736 			printf("trans[0] => %d on ", NFA_NO(p->trans[0]));
737 			p_set(p->label);
738 			printf("\n");
739 			}
740 		else
741 			printf("trans[0] => nil\n");
742 		if (p->trans[1] != NIL_INDEX)
743 			printf("trans[1] => %d on epsilon\n",
744 				NFA_NO(p->trans[1]));
745 		else
746 			printf("trans[1] => nil\n");
747 		printf("\n");
748 		}
749 }
750 #endif
751 
752 #ifdef  DEBUG
753 
754 /* code to print out special structures when using a debugger */
755 
756 #ifdef __USE_PROTOS
p_nfa(p)757 void p_nfa(p)
758 #else
759 void p_nfa(nfa_node *p)
760 nfa_node *p;	/* state number also index into array */
761 #endif
762 {
763 /* each node has a marker on it so it only gets printed once */
764 
765 	operation_no++; /* get new number */
766 	s_p_nfa(p);
767 }
768 
769 #ifdef __USE_PROTOS
s_p_nfa(nfa_node * p)770 void s_p_nfa(nfa_node *p)
771 #else
772 void s_p_nfa(p)
773 nfa_node *p;	/* state number also index into array */
774 #endif
775 {
776 	if ((p != NIL_INDEX) && (p->nfa_set != operation_no)){
777 		/* so it is only printed once */
778 		p->nfa_set = operation_no;
779 		p_nfa_node(p);
780 		s_p_nfa(p->trans[0]);
781 		s_p_nfa(p->trans[1]);
782 		}
783 }
784 
785 #ifdef __USE_PROTOS
p_dfa_node(dfa_node * p)786 void p_dfa_node(dfa_node *p)
787 #else
788 void p_dfa_node(p)
789 dfa_node *p;
790 #endif
791 {
792 	int i;
793 
794 	if (p != NIL_INDEX){
795 		printf("DFA state :%d\n",NFA_NO(p));
796 		if (p->done)
797 			printf("done\n");
798 		else
799 			printf("undone\n");
800 		printf("from nfa states : ");
801 		p_set(p->nfa_states);
802 		printf("\n");
803 		/* NOTE: trans arcs stored as ints rather than pointer*/
804 		for (i=0; i<class_no; i++){
805 			printf("%d ",p->trans[i]);
806 			}
807 		printf("\n\n");
808 		}
809 }
810 
811 #ifdef __USE_PROTOS
p_dfa(void)812 void p_dfa(void)
813 #else
814 void p_dfa()
815 #endif
816 {
817 /* prints out all the dfa nodes actually allocated */
818 
819 	int i;
820 
821 	for (i = 1; i<=dfa_allocated; i++)
822 		p_dfa_node(NFA(i));
823 }
824 
825 
826 /* print out numbers in the set label */
827 
828 #ifdef __USE_PROTOS
p_set(set label)829 void p_set(set label)
830 #else
831 void p_set(label)
832 set label;
833 #endif
834 {
835 	unsigned *t, *e;
836 
837 	if (set_nil(label)){
838 		printf("epsilon\n");
839 	}else{
840 		t = e = set_pdq(label);
841 		while(*e != nil){
842 			printf("%d ", (*e+MIN_CHAR));
843 			e++;
844 		}
845 		printf("\n");
846 		free(t);
847 	}
848 
849 }
850 #endif
851