Jspice3
parser.c
Go to the documentation of this file.
1 /***************************************************************************
2 SCED - Schematic Capture Editor
3 JSPICE3 adaptation of Spice3e2 - Copyright (c) Stephen R. Whiteley 1992
4 Copyright 1990 Regents of the University of California. All rights reserved.
5 Authors: 1981 Giles C. Billingsley (parts of KIC layout editor)
6  1992 Stephen R. Whiteley
7 ****************************************************************************/
8 
9 /*
10  * Fast CIF file parser.
11  *
12  * It is easy to use it to write programs that traverse a CIF file.
13  *
14  * Examples follows.
15  * 1. A program that translates CIF to STREAM.
16  * 2. A pattern factoring program for PG tape generation.
17  * See TI's PFP.
18  * 3. A statistics generation program.
19  * 4. A program that extracts each symbol, generates a name for it, and
20  * writes it to a file. See the CD package.
21  * 5. A program that builds a binary representation of the CIF file that can
22  * then be edited via procedure calls and then written back to the CIF
23  * file. See the CD package.
24  *
25  * Here's how you use it.
26  *
27  * First, you include the files actions.c and parser.h.
28  * Then you invoke PCIF(CIFFileName,StatusString,StatusInt).
29  * Each time the parser recognizes a CIF command, it invokes an action routine.
30  * You should fill in the action routines in the file Actions.c.
31  * Each action routine name is prefixed by A.
32  *
33  * Each parser routine and global variable name is prefixed by P.
34  * StatusInt == PFAILED if the parse failed and an error message along with
35  * about where in the CIF file the error is in the StatusString.
36  * Else StatusInt == PSUCCEEDED and StatusString == "".
37  *
38  */
39 
40 #include "cddefs.h"
41 #include "cdparser.h"
42 
44 char PStatus[80*3+1];
45 long PInt;
46 int PChar;
49 
50 #ifdef __STDC__
51 static int p_primitive_cmd(void);
52 static int p_end(void);
53 static int p_symbol(void);
54 static int p_delete_symbol(void);
55 static int p_call(void);
56 static int p_polygon(void);
57 static int p_box(void);
58 static int p_round_flash(void);
59 static int p_wire(void);
60 static int p_path(struct p**);
61 static int p_point(long*,long*);
62 static int p_layer(void);
63 static int p_user_extension(void);
64 static int p_comment(void);
65 static void p_error(char*);
66 static void p_error_EOF(void);
67 static void p_error_nosemi(void);
68 static void p_error_badlayer(int,char*);
69 static void p_error_CD(void);
70 static int p_white_space(int,int);
71 static int p_white_space_1(int);
72 static int p_look_ahead(int,int);
73 static int p_look_for_semi(void);
74 static int p_integer(int);
75 #else
76 static int p_primitive_cmd();
77 static int p_end();
78 static int p_symbol();
79 static int p_delete_symbol();
80 static int p_call();
81 static int p_polygon();
82 static int p_box();
83 static int p_round_flash();
84 static int p_wire();
85 static int p_path();
86 static int p_point();
87 static int p_layer();
88 static int p_user_extension();
89 static int p_comment();
90 static void p_error();
91 static void p_error_EOF();
92 static void p_error_nosemi();
93 static void p_error_badlayer();
94 static void p_error_CD();
95 static int p_white_space();
96 static int p_white_space_1();
97 static int p_white_space_2();
98 static int p_white_space_1();
99 static int p_look_ahead();
100 static int p_look_for_semi();
101 static int p_integer();
102 #endif
103 
104 void
108 {
109  PStatus[0] = EOS;
110  *StatusString = PStatus;
111  if((PCIFFileDesc = POpen(CIFFileName,"r",(char **)NULL))
112  == NULL){
113  PChar = EOF;
114  p_error("Can't open CIF file.");
115  *StatusInt = PFAILED;
116  return;
117  }
121  fclose(PCIFFileDesc);
122  *StatusInt = PFAILED;
123  return;
124  }
125  elif(PChar == 'D'){
127  if(PReturned == PFAILED){
128  fclose(PCIFFileDesc);
129  *StatusInt = PFAILED;
130  return;
131  }
132  elif(PChar == 'S'){
133  if(p_symbol() == PFAILED){
134  fclose(PCIFFileDesc);
135  *StatusInt = PFAILED;
136  return;
137  }
138  }
139  elif(PChar == 'D'){
140  if(p_delete_symbol() == PFAILED){
141  fclose(PCIFFileDesc);
142  *StatusInt = PFAILED;
143  return;
144  }
145  }
146  }
147  elif(PChar == 'E'){
148  *StatusInt = p_end();
149  return;
150  }
152  fclose(PCIFFileDesc);
153  *StatusInt = PFAILED;
154  return;
155  }
157  p_error("Can't understand next command.");
158  fclose(PCIFFileDesc);
159  *StatusInt = PFAILED;
160  return;
161  }
162  }
163 }
164 
165 static int
167 {
168  if(PChar == 'P')
169  return(p_polygon());
170  elif(PChar == 'B')
171  return(p_box());
172  elif(PChar == 'W')
173  return(p_wire());
174  elif(PChar == 'L')
175  return(p_layer());
176  elif(PChar == 'C')
177  return(p_call());
178  elif(PChar == 'R')
179  return(p_round_flash());
180  elif('0' <= PChar And PChar <= '9')
181  return(p_user_extension());
182  elif(PChar == '(')
183  return(p_comment());
184  elif(PChar == ';')
185  return(PSUCCEEDED);
186  else
187  return(PNOTAPPLICABLE);
188 }
189 
190 static int
192 {
193  AEnd();
194  fclose(PCIFFileDesc);
195  return(PSUCCEEDED);
196 }
197 
198 static int
200 {
201  char For;
202  int SymbolNum;
203  long A,B;
204 
205 #ifdef TRACE
206 fprintf(stderr," ENTERING PSYMBOL\n");
207 #endif
209  if(PReturned == PFAILED)
210  return(PFAILED);
211  SymbolNum = PInt;
212  A = B = 1;
213  /* look for scaling factor */
214  for(For = '0'; For <= '9'; ++For){
216  if(PReturned == PFAILED)
217  return(PFAILED);
218  if(PChar == For){
219  ungetc(For,PCIFFileDesc);
220  if(p_point(&A,&B) == PFAILED)
221  return(PFAILED);
222  break;
223  }
224  }
226  if(PReturned == PFAILED)
227  return(PFAILED);
228  if(ABeginSymbol((int)SymbolNum,(int)A,(int)B) == PFAILED){
229  p_error_CD();
230  return(PFAILED);
231  }
232  if(PReturned == PFAILED)
233  return(PFAILED);
234  loop{
236  if(PReturned == PFAILED)
237  return(PFAILED);
238  if((PReturned = p_primitive_cmd()) == PFAILED)
239  return(PFAILED);
241  break;
242  }
243  if(PChar != 'D')
244  return(PFAILED);
246  if(PReturned == PFAILED)
247  return(PFAILED);
248  if(PChar != 'F')
249  return(PFAILED);
251  if(PReturned == PFAILED)
252  return(PFAILED);
253  AEndSymbol();
254  return(PSUCCEEDED);
255 }
256 
257 static int
259 {
261  if(PReturned == PFAILED)
262  return(PFAILED);
263  else{
265  if(PReturned == PFAILED)
266  return(PFAILED);
268  return(PSUCCEEDED);
269  }
270 }
271 
272 static int
274 {
275  int SymbolNum;
276  long X,Y;
277 
279  if(PReturned == PFAILED)
280  return(PFAILED);
281  SymbolNum = PInt;
282  if(ABeginCall(SymbolNum) == PFAILED){
283  p_error_CD();
284  return(PFAILED);
285  }
286  loop{
288  if(PReturned == PFAILED)
289  return(PFAILED);
290  elif(PChar == 'T'){
291  if(p_point(&X,&Y) == PFAILED){
292  p_error("Can't parse translation transform.");
293  return(PFAILED);
294  }
295  elif(AT(CDTRANSLATE,X,Y) == PFAILED){
296  p_error_CD();
297  return(PFAILED);
298  }
299  }
300  elif(PChar == 'M'){
302  if(PReturned == PFAILED){
303  p_error_EOF();
304  return(PFAILED);
305  }
306  elif(PChar == 'X'){
307  if(AT(CDMIRRORX,X,Y) == PFAILED){
308  p_error_CD();
309  return(PFAILED);
310  }
311  }
312  elif(PChar == 'Y'){
313  if(AT(CDMIRRORY,X,Y) == PFAILED){
314  p_error_CD();
315  return(PFAILED);
316  }
317  }
318  else{
319  p_error("Can't parse mirror transform.");
320  return(PFAILED);
321  }
322  }
323  elif(PChar == 'R'){
324  if(p_point(&X,&Y) == PFAILED){
325  p_error("Can't parse rotation transform.");
326  return(PFAILED);
327  }
328  if(AT(CDROTATE,X,Y) == PFAILED){
329  p_error_CD();
330  return(PFAILED);
331  }
332  }
333  elif(PChar == ';')
334  break;
335  else{
336  p_error("Can't parse transformation.");
337  return(PFAILED);
338  }
339  }
340  if(AEndCall() == PFAILED){
341  p_error_CD();
342  return(PFAILED);
343  }
344  return(PSUCCEEDED);
345 }
346 
347 static int
349 {
350  struct p *Path, *Pt;
351 
352 #ifdef TRACE
353 fprintf(stderr," ENTERING PPOLYGON\n");
354 #endif
355  if(p_path(&Path) == PFAILED)
356  return(PFAILED);
357 #ifdef TRACE
358 fprintf(stderr," LEAVING PPATH\n");
359 #endif
360 
361 /* ignore polygons found in input
362 
363  if(APolygon(Path) == PFAILED){
364  p_error_CD();
365  return(PFAILED);
366  }
367 */
368  for (Pt = Path; Pt; Pt = Path) {
369  Path = Pt->pSucc;
370  txfree(Pt);
371  }
372 
373 
374 #ifdef TRACE
375 fprintf(stderr," LEAVING PPOLYGON\n");
376 #endif
377  return(PSUCCEEDED);
378 }
379 
380 static int
382 {
383  long Length,Width,X,Y;
384  long XDirection,YDirection;
385 
386  XDirection = 1;
387  YDirection = 0;
389  if(PReturned == PFAILED)
390  return(PFAILED);
391  Length = PInt;
393  if(PReturned == PFAILED)
394  return(PFAILED);
395  Width = PInt;
396  if(p_point(&X,&Y) == PFAILED)
397  return(PFAILED);
399  if(PReturned == PFAILED)
400  return(PFAILED);
401  elif(PChar != ';'){
402  if(p_point(&XDirection,&YDirection) == PFAILED)
403  return(PFAILED);
405  if(PReturned == PFAILED Or PChar != ';'){
406  p_error_nosemi();
407  return(PFAILED);
408  }
409  }
410  if(ABox(Length,Width,X,Y,(int)XDirection,(int)YDirection) == PFAILED){
411  p_error_CD();
412  return(PFAILED);
413  }
414  return(PSUCCEEDED);
415 }
416 
417 static int
419 {
420  long Width,X,Y;
421 
423  if(PReturned == PFAILED)
424  return(PFAILED);
425  Width = PInt;
426  if(p_point(&X,&Y) == PFAILED)
427  return(PFAILED);
429  if(PReturned == PFAILED)
430  return(PFAILED);
431  elif(PChar != ';'){
432  p_error_nosemi();
433  return(PFAILED);
434  }
435  if(ARoundFlash(Width,X,Y) == PFAILED){
436  p_error_CD();
437  return(PFAILED);
438  }
439  return(PSUCCEEDED);
440 }
441 
442 static int
444 {
445  long Width;
446  struct p *Path;
447 
448 #ifdef TRACE
449 fprintf(stderr," ENTERING PWIRE\n");
450 #endif
452  if(PReturned == PFAILED)
453  return(PFAILED);
454  Width = PInt;
455 #ifdef TRACE
456 fprintf(stderr," ENTERING PPATH\n");
457 #endif
458  if(p_path(&Path) == PFAILED)
459  return(PFAILED);
460  if(AWire(Width,Path) == PFAILED){
461  p_error_CD();
462  return(PFAILED);
463  }
464  return(PSUCCEEDED);
465 }
466 
467 static int
468 p_path(Path)
469 struct p **Path;
470 {
471  long X,Y;
472  struct p *Pair;
473 
474  *Path = NULL;
475  loop{
477 #ifdef TRACE
478 if(PReturned == PFAILED)
479  fprintf(stderr," PPATH FAILED AFTER PLOOKAHEAD\n");
480 #endif
481  if(PReturned == PFAILED)
482  return(PFAILED);
483  elif(PChar == ';')
484  break;
485  else{
486  if(p_point(&X,&Y) == PFAILED)
487  return(PFAILED);
488 #ifdef TRACE
489 fprintf(stderr," PPATH POINT %ld, %ld\n",X,Y);
490 #endif
491  if((Pair = alloc(p)) == NULL){
492  p_error("Out of memory.");
493  return(PFAILED);
494  }
495  Pair->pSucc = *Path;
496  Pair->pX = X;
497  Pair->pY = Y;
498  *Path = Pair;
499  }
500  }
501  return(PSUCCEEDED);
502 }
503 
504 static int
506 long *X,*Y;
507 {
508  /* it is assumed that a LookAhead is done prior to calling p_point */
510  if(PReturned == PFAILED)
511  return(PFAILED);
512  *X = PInt;
514  if(PReturned == PFAILED)
515  return(PFAILED);
516  elif(PChar == ';'){
517  p_error("Bad X,Y path element.");
518  return(PFAILED);
519  }
521  if(PReturned == PFAILED)
522  return(PFAILED);
523  *Y = PInt;
524  return(PSUCCEEDED);
525 }
526 
527 static int
529 {
530  char Technology,Mask[4];
531  int i;
532 
533  Mask[0] = Mask[1] = Mask[2] = ' '; Mask[3] = '\0';
535  if(PReturned == PFAILED)
536  return(PFAILED);
537  if(PChar == ';'){
538  p_error("At least one character expected after L in layer command.");
539  return(PFAILED);
540  }
541  Technology = PChar;
542  for(i=0; i<3; ++i){
543  if((PChar = getc(PCIFFileDesc)) == EOF){
544  p_error_EOF();
545  return(PFAILED);
546  }
547  elif(PChar == ';'){
548  if(ALayer(Technology,Mask) == PSUCCEEDED)
549  return(PSUCCEEDED);
550  else{
551  p_error_badlayer(Technology,Mask);
552  return(PFAILED);
553  }
554  }
555  Mask[i] = PChar;
556  /* check for valid CIF layer name character */
557  if(Not ((PChar >= '0' And PChar <= '9') Or
558  (PChar >= 'A' And PChar <= 'Z'))){
559  p_error_badlayer(Technology,Mask);
560  return(PFAILED);
561  }
562  }
563  /* clear the semicolon */
565  if(PReturned == PFAILED)
566  return(PFAILED);
567  elif(PChar == ';'){
568  if(ALayer(Technology,Mask) == PSUCCEEDED)
569  return(PSUCCEEDED);
570  else{
571  p_error_badlayer(Technology,Mask);
572  return(PFAILED);
573  }
574  }
575  p_error("Illegal CIF layer name with > 4 characters discovered.");
576  return(PFAILED);
577 }
578 
579 static int
581 {
582  char Digit;
583  int Int1;
584 
585  Digit = PChar;
586  Int1 = 0;
587  loop{
589  if(PReturned == PFAILED)
590  return(PFAILED);
591  elif(PChar == ';'){
592  PString[Int1] = EOS;
593  if(AUserExtension(Digit,PString) == PFAILED){
594  p_error_CD();
595  return(PFAILED);
596  }
597 #ifdef TRACE
598 fprintf(stderr,"PString = %s\n",PString);
599 #endif
600  return(PSUCCEEDED);
601  }
602  elif(Int1 == PSTRINGSIZE){
603  p_error("User extension command longer than 1920 characters.");
604  return(PFAILED);
605  }
606  else PString[Int1++] = PChar;
607  }
608 }
609 
610 static int
612 {
613  int Int1;
614 
615  Int1 = 0;
616  loop{
618  if(PReturned == PFAILED)
619  return(PFAILED);
620  elif(PChar == ')'){
622  if(PReturned == PFAILED)
623  return(PFAILED);
624  elif(PChar == ';'){
625  PString[Int1] = EOS;
626  AComment(PString);
627  return(PSUCCEEDED);
628  }
629  elif(Int1 == PSTRINGSIZE){
630  p_error("Comment command longer than 1920 characters.");
631  return(PFAILED);
632  }
633  else{
634  p_error_nosemi();
635  return(PFAILED);
636  }
637  }
638  else PString[Int1++] = PChar;
639  }
640 }
641 
642 static void
643 p_error(PErrorMessage)
644 char *PErrorMessage;
645 {
646  int Int1;
647 
648  for(Int1 = 0;Int1 < 20;++Int1){
649  if(PChar == EOF)
650  break;
652  if(PReturned == PFAILED)
653  break;
654  PString[Int1] = PChar;
655  }
656  PString[Int1] = EOS;
657  sprintf(PStatus,"%s Failed at around %s.",PErrorMessage,PString);
658 #ifdef TRACE
659 fprintf(stderr,"%s\n",PErrorMessage);
660 #endif
661 }
662 
663 static void
665 {
666  p_error("Early EOF.");
667 }
668 
669 static void
671 {
672  p_error("; expected and not found.");
673 }
674 
675 static void
677 char Tech,*Mask;
678 {
679  char buf[35];
680  sprintf(buf,"Undefined layer: %c%s. ",Tech,Mask);
681  p_error(buf);
682 }
683 
684 static void
686 {
688 }
689 
690 
691 /* the following functions used to be macros */
692 
693 int
694 PCharacter(WhiteSpaceControl,EOFControl)
695 int WhiteSpaceControl,EOFControl;
696 {
697  int Returned;
698 
699  Returned = p_white_space(WhiteSpaceControl,EOFControl);
700  if(Returned != PFAILED){
701  PChar = getc(PCIFFileDesc);
702  if(PChar == EOF){
703  if(EOFControl != PDONTFAILONEOF){
704  p_error_EOF();
705  Returned = PFAILED;
706  }
707  }
708  }
709  return Returned;
710 }
711 
712 static int
713 p_white_space(WhiteSpaceControl,EOFControl)
714 int WhiteSpaceControl,EOFControl;
715 {
716  int Returned = PSUCCEEDED;
717 
718  if(WhiteSpaceControl == PSTRIPWHITESPACE1){
719  while((PChar = getc(PCIFFileDesc)) == ' ' Or PChar == '\t' Or
720  PChar == '\n' Or PChar == ','){
721  if(PChar == EOF){
722  if(EOFControl != PDONTFAILONEOF){
723  p_error_EOF();
724  Returned = PFAILED;
725  }
726  break;
727  }
728  }
729  ungetc((char)PChar,PCIFFileDesc);
730  }
731  elif(WhiteSpaceControl == PSTRIPWHITESPACE2){
732  while((PChar = getc(PCIFFileDesc)) != '-' And PChar != '('
733  And PChar != ')' And (PChar < 'A' Or PChar > 'Z')
734  And (PChar < '0' Or PChar > '9') And PChar != ';'){
735  if(PChar == EOF){
736  if(EOFControl != PDONTFAILONEOF) {
737  p_error_EOF();
738  Returned = PFAILED;
739  }
740  break;
741  }
742  }
743  ungetc((char)PChar,PCIFFileDesc);
744  }
745  elif(WhiteSpaceControl == PSTRIPWHITESPACE3){
746  while((PChar = getc(PCIFFileDesc)) != '-' And PChar != '('
747  And PChar != ')' And (PChar< '0' Or PChar > '9') And
748  PChar != ';'){
749  if(PChar == EOF){
750  if(EOFControl != PDONTFAILONEOF){
751  p_error_EOF();
752  Returned = PFAILED;
753  }
754  break;
755  }
756  }
757  ungetc((char)PChar,PCIFFileDesc);
758  }
759  return Returned;
760 }
761 
762 static int
763 p_white_space_1(EOFControl)
764 int EOFControl;
765 {
766  int Returned = PSUCCEEDED;
767 
768  while((PChar = getc(PCIFFileDesc)) != '-' And PChar != '('
769  And PChar != ')' And (PChar< '0' Or PChar > '9') And
770  PChar != ';'){
771  if(PChar == EOF){
772  if(EOFControl != PDONTFAILONEOF){
773  p_error_EOF();
774  Returned = PFAILED;
775  }
776  break;
777  }
778  }
779  ungetc((char)PChar,PCIFFileDesc);
780  return Returned;
781 }
782 
783 static int
784 p_look_ahead(WhiteSpaceControl, For)
785 int WhiteSpaceControl, For;
786 {
787  int Returned;
788 
789  Returned = PCharacter(WhiteSpaceControl,PFAILONEOF);
790  if(PChar != For && Returned != PFAILED)
791  ungetc((char)PChar,PCIFFileDesc);
792  return Returned;
793 }
794 
795 static int
797 {
798  int Returned;
799 
800  Returned = p_white_space_1(PFAILONEOF);
801  if(Returned != PFAILED){
802  PChar = getc(PCIFFileDesc);
803  if(PChar == EOF){
804  p_error_EOF();
805  Returned = PFAILED;
806  }
807  elif(PChar != ';')
808  ungetc((char)PChar,PCIFFileDesc);
809  }
810  return Returned;
811 }
812 
813 static int
814 p_integer(EOFControl)
815 int EOFControl;
816 {
817  int Returned;
818 
819  loop{
820  PReturned = p_white_space_1(EOFControl);
821  if(PReturned == PFAILED){
822  Returned = PFAILED;
823  break;
824  }
825  if((PChar >= '0' And PChar <= '9') Or
826  (PChar == '-' Or PChar == '+')) {
827  /* read integer */
828  if((fscanf(PCIFFileDesc,"%ld",&PInt)) == EOF){
829  if(EOFControl != PDONTFAILONEOF){
830  PChar = EOF;
831  p_error_EOF();
832  Returned = PFAILED;
833  }
834  }
835  Returned = PSUCCEEDED;
836  break;
837  }
838  /* drop unwanted characters */
839  PReturned = PCharacter(PSTRIPWHITESPACE1,EOFControl);
840  if(PReturned == PFAILED){
841  Returned = PFAILED;
842  break;
843  }
844  }
845  return Returned;
846 }
847 
static char buf[MAXPROMPT]
Definition: arg.c:18
int AWire()
void char * CIFFileName
Definition: parser.c:106
#define Or
Definition: cdmacs.h:15
void AEnd()
Definition: actions.c:34
static int p_integer()
static int p_white_space_1()
int PCharacter(int WhiteSpaceControl, int EOFControl)
Definition: parser.c:694
static int p_box()
Definition: parser.c:381
int PReturned
Definition: parser.c:48
#define PFAILED
Definition: cdparser.h:51
static int p_white_space()
#define Not
Definition: cdmacs.h:16
static int p_comment()
Definition: parser.c:611
static int p_symbol()
Definition: parser.c:199
#define PSTRINGSIZE
Definition: cdparser.h:17
int * StatusInt
Definition: parser.c:107
static void p_error_badlayer()
#define PDONTFAILONEOF
Definition: cdparser.h:58
#define PSTRIPWHITESPACE1
Definition: cdparser.h:63
#define PSTRIPWHITESPACE2
Definition: cdparser.h:65
Definition: cddefs.h:215
char PString[PSTRINGSIZE]
Definition: parser.c:47
#define PFAILONEOF
Definition: cdparser.h:57
#define alloc(type)
Definition: cdmacs.h:21
static void p_error()
static int p_polygon()
Definition: parser.c:348
long pY
Definition: cddefs.h:216
#define PLEAVEWHITESPACE
Definition: cdparser.h:69
long X
Definition: actions.c:450
static int p_point()
char PStatus[80 *3+1]
Definition: parser.c:44
static int p_path()
void txfree()
#define NULL
Definition: spdefs.h:121
static int p_wire()
Definition: parser.c:443
static void p_error_CD()
Definition: parser.c:685
elif(PChar== 'D')
Definition: parser.c:125
int ALayer()
static int p_delete_symbol()
Definition: parser.c:258
loop
Definition: parser.c:118
static void p_error_nosemi()
Definition: parser.c:670
#define CDROTATE
Definition: cddefs.h:55
static int p_call()
Definition: parser.c:273
static void p_error_EOF()
Definition: parser.c:664
static int p_user_extension()
Definition: parser.c:580
static int p_white_space_2()
long pX
Definition: cddefs.h:216
int ABeginSymbol()
static int p_round_flash()
Definition: parser.c:418
#define PSUCCEEDED
Definition: cdparser.h:50
char * CDStatusString
Definition: cd.c:77
static int p_layer()
Definition: parser.c:528
int ARoundFlash()
int ABox()
#define EOS
Definition: cdmacs.h:9
static int p_primitive_cmd()
Definition: parser.c:166
#define And
Definition: cdmacs.h:14
FILE * PCIFFileDesc
Definition: parser.c:43
void ADeleteSymbol()
long PInt
Definition: parser.c:45
#define CDTRANSLATE
Definition: cddefs.h:56
int AUserExtension()
static int p_look_for_semi()
Definition: parser.c:796
void AComment()
void char ** StatusString
Definition: parser.c:106
#define CDMIRRORY
Definition: cddefs.h:54
FILE * POpen()
static int p_look_ahead()
#define PNOTAPPLICABLE
Definition: cdparser.h:52
#define CDMIRRORX
Definition: cddefs.h:53
struct p * pSucc
Definition: cddefs.h:217
long Y
Definition: actions.c:450
int ABeginCall()
void AEndSymbol()
Definition: actions.c:348
#define PSTRIPWHITESPACE3
Definition: cdparser.h:67
void PCIF()
int PChar
Definition: parser.c:46
int AEndCall()
Definition: actions.c:414
static int p_end()
Definition: parser.c:191
int AT()