![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dCopy.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 3BSD / cmd / pi|
Return to dCopy.c CVS log | Up to [CSRG BSD Unix] / 3BSD / cmd / pi |
1.1 root 1: /*
2: * dCopy.c
3: *
4: * functions to copy pi declarations to pTrees
5: * these should be all the functions
6: * that mark the inTree field of the namelist
7: */
8:
9: #include "whoami"
10:
11: #ifdef PTREE
12:
13: #include "0.h"
14:
15: #include "tree.h"
16:
17: /*
18: * copy a T_PROG, T_PDEC, or T_FDEC into a PorFNode
19: * porf [0] T_PROG T_PDEC or T_FDEC
20: * [1] lineof "program" or trailing ";"
21: * [2] program, procedure, or function name
22: * [3] file or formal parameter list
23: * [4] function return type or pNIL
24: */
25: pPointer
26: PorFCopy( porf )
27: int *porf;
28: {
29: pPointer PorF;
30: union pNodeBodies *PorFp;
31: struct nl *nlporf;
32: extern struct nl *program;
33:
34: /*
35: * programs are defnl'ed but not entered, but extern program works
36: */
37: if ( porf[0] == T_PROG )
38: nlporf = program;
39: else nlporf = nllook( porf[2] );
40: if ( nlporf -> inTree != pNIL ) {
41: pDEF( nlporf -> inTree ).PorFForward = TRUE;
42: return;
43: }
44: PorF = pNewNode( PorFTAG , sizeof( struct PorFNode ) );
45: pSeize( PorF );
46: PorFp = &( pDEF( PorF ) );
47: PorFp -> PorFName = sCopy( porf[2] );
48: PorFHeader[ ++ nesting ] = PorF;
49: if ( porf[0] != T_PROG )
50: PorFp -> PorFParams = tCopy( porf[3] );
51: else PorFp -> PorFParams = FileCopy( porf[3] );
52: nesting --;
53: PorFp -> PorFLabels = pNIL;
54: PorFp -> PorFConsts = pNIL;
55: PorFp -> PorFTypes = pNIL;
56: PorFp -> PorFVars = pNIL;
57: PorFp -> PorFPFs = pNIL;
58: PorFp -> PorFBody = pNIL;
59: PorFp -> PorFReturns = tCopy( porf[4] );
60: PorFp -> PorFForward = FALSE;
61: pRelease( PorF );
62: nlporf -> inTree = PorF;
63: return PorF;
64: }
65:
66: /*
67: * looks for defined (but not entered) symbols
68: * (either files or formal parameters)
69: * which hang down the chain field of
70: * program, procedure or function namelist entry.
71: */
72: struct nl *
73: chainlookup( porf , symb )
74: struct nl *porf;
75: char *symb;
76: {
77: struct nl *paramp;
78:
79: for ( paramp = porf->chain ; paramp != NIL ; paramp = paramp->chain )
80: if ( paramp -> symbol == symb )
81: break;
82: return paramp;
83: }
84:
85: /*
86: * copy a list of file names to a list of threads to VarDNodes
87: * (or threads to the BVarNodes for input or output)
88: * for later inclusion in the variable declaration list.
89: * as a special case, the files are found chained to the program nl entry.
90: */
91: pPointer
92: FileCopy( files )
93: int *files;
94: {
95: int *filep;
96: pPointer Thread;
97: pPointer List;
98: pPointer First;
99: pPointer After;
100: extern struct nl *program;
101: extern struct nl *input;
102: extern struct nl *output;
103:
104: First = After = pNIL;
105: for ( filep = files ; filep != NIL ; filep = (int *) filep[2] ) {
106: struct nl *file = chainlookup( program , filep[1] );
107:
108: if ( filep[1] == input -> symbol ) {
109: file -> inTree = input -> inTree;
110: Thread = ThreadName( input );
111: } else if ( filep[1] == output -> symbol ) {
112: file -> inTree = output -> inTree;
113: Thread = ThreadName( output );
114: } else {
115: pPointer File = pNewNode( VarDTAG
116: , sizeof( struct VarDNode ) );
117: pPointer Name = sCopy( filep[1] );
118:
119: pDEF( File ).VarDName = Name;
120: pDEF( File ).VarDType = pNIL;
121: file -> inTree = File;
122: Thread = ThreadName( file );
123: }
124: List = pNewNode( ListTAG , sizeof( struct ListNode ) );
125: pDEF( List ).ListItem = Thread;
126: pDEF( List ).ListUp = After;
127: pDEF( List ).ListDown = pNIL;
128: if ( After == pNIL )
129: First = List;
130: else pDEF( After ).ListDown = List;
131: After = List;
132: }
133: return First;
134: }
135:
136: /*
137: * copy a formal parameter declaration to a TypedNode
138: * and a list of ValPNodes or VarPNodes.
139: * param [0] T_PVAL or T_PVAR
140: * [1] id_list
141: * [2] type
142: */
143: pPointer
144: ParamCopy( param )
145: int *param;
146: {
147: int *idl;
148: pPointer Param;
149: pPointer Name;
150: pPointer Typed = pNewNode( TypedTAG , sizeof( struct TypedNode ) );
151: pPointer Type = tCopy( param[2] );
152: pPointer List;
153: pPointer After;
154: char *name;
155: struct nl *porf;
156:
157: Name = pUSE( PorFHeader[ nesting ] ).PorFName;
158: name = *hash( pUSE( Name ).StringValue , 0 );
159: porf = nllook( name );
160: if ( porf == NIL )
161: panic( "ParamCopy:nllook" );
162: pDEF( Typed ).TypedType = Type;
163: After = pNIL;
164: for ( idl = (int *)param[1] ; idl != NIL ; idl = (int *)idl[2] ) {
165: switch ( param[0] ) {
166: case T_PVAL:
167: Param = pNewNode( ValPTAG , sizeof( struct ValPNode ) );
168: break;
169: case T_PVAR:
170: Param = pNewNode( VarPTAG , sizeof( struct VarPNode ) );
171: break;
172: default:
173: panic("ParamCopy:param[0]");
174: };
175: Name = sCopy( idl[1] );
176: pDEF( Param ).ParamDName = Name;
177: pDEF( Param ).ParamDType = Type;
178: chainlookup( porf , idl[1] ) -> inTree = Param;
179: List = pNewNode( ListTAG , sizeof( struct ListNode ) );
180: pDEF( List ).ListItem = Param;
181: pDEF( List ).ListUp = After;
182: pDEF( List ).ListDown = pNIL;
183: if ( After == pNIL )
184: pDEF( Typed ).TypedNames = List;
185: else pDEF( After ).ListDown = List;
186: After = List;
187: }
188: return Typed;
189: }
190:
191: /*
192: * construct a list of LabelDNodes from a list of YINTs
193: */
194: pPointer
195: LabelDCopy( labels )
196: int *labels;
197: {
198: int *labelp;
199: pPointer Label;
200: pPointer Name;
201: pPointer List;
202: pPointer First;
203: pPointer After;
204:
205: After = pNIL;
206: for ( labelp = labels ; labelp != NIL ; labelp = (int *) labelp[2] ) {
207: Label = pNewNode( LabelDTAG , sizeof( struct LabelDNode ) );
208: Name = sCopy( labelp[1] );
209: pDEF( Label ).LabelDName = Name;
210: nllook( labelp[1] ) -> inTree = Label;
211: List = pNewNode( ListTAG , sizeof( struct ListNode ) );
212: pDEF( List ).ListItem = Label;
213: pDEF( List ).ListUp = After;
214: pDEF( List ).ListDown = pNIL;
215: if ( After == pNIL )
216: First = List;
217: else pDEF( After ).ListDown = List;
218: After = List;
219: }
220: return First;
221: }
222:
223: /*
224: * copy a constant declaration to a ConstDNode
225: */
226: pPointer
227: ConstDecl( id , decl )
228: char *id;
229: int *decl;
230: {
231: pPointer Const = pNewNode( ConstDTAG , sizeof( struct ConstDNode ) );
232: pPointer Name = sCopy( id );
233: pPointer ConstValue = tCopy( decl );
234:
235: pDEF( Const ).ConstDName = Name;
236: pDEF( Const ).ConstDValue = ConstValue;
237: nllook( id ) -> inTree = Const;
238: return Const;
239: }
240:
241: /*
242: * copy a type declaration to a TypeDNode.
243: * note that pointers' types are filled in later.
244: */
245: pPointer
246: TypeDecl( id , decl )
247: char *id;
248: int *decl;
249: {
250: pPointer Type = pNewNode( TypeDTAG , sizeof( struct TypeDNode ) );
251: pPointer Name = sCopy( id );
252: pPointer TypeType = tCopy( decl );
253: struct nl *np = nllook( id );
254:
255: pDEF( Type ).TypeDName = Name;
256: pDEF( Type ).TypeDType = TypeType;
257: np -> inTree = Type;
258: if ( ( np -> type ) -> class == PTR ) {
259: ( np -> type ) -> inTree = TypeType;
260: }
261: return Type;
262: }
263:
264: /*
265: * copies a T_RFIELD node to a TypedNode
266: * with a type and a list of FieldDNodes
267: * rfield[0] T_RFIELD
268: * [1] lineof ":"
269: * [2] id_list
270: * [3] type
271: * uses the extern inrecord to know which record its in.
272: */
273: pPointer
274: FieldCopy( rfield )
275: int *rfield;
276: {
277: extern struct nl *inrecord;
278: pPointer Typed = pNewNode( TypedTAG , sizeof( struct TypedNode ) );
279: int *idlp;
280: pPointer Type = tCopy( rfield[3] );
281: pPointer List;
282: pPointer After;
283:
284: pDEF( Typed ).TypedNames = pNIL;
285: pDEF( Typed ).TypedType = Type;
286: After = pNIL;
287: for ( idlp = (int *)rfield[2] ; idlp != NIL ; idlp = (int *)idlp[2] ) {
288: pPointer FieldD
289: = pNewNode( FieldDTAG , sizeof( struct FieldDNode ) );
290: pPointer Name = sCopy( idlp[1] );
291: struct nl *field;
292:
293: if ( inrecord == NIL )
294: panic( "FieldCopy:inrecord" );
295: field = reclook( inrecord , idlp[1] );
296: if ( field == NIL )
297: panic( "FieldCopy:reclook" );
298: pDEF( FieldD ).FieldDName = Name;
299: pDEF( FieldD ).FieldDType = Type;
300: field -> inTree = FieldD;
301: List = pNewNode( ListTAG , sizeof( struct ListNode ) );
302: pDEF( List ).ListItem = FieldD;
303: pDEF( List ).ListUp = After;
304: pDEF( List ).ListDown = pNIL;
305: if ( After == pNIL )
306: pDEF( Typed ).TypedNames = List;
307: else pDEF( After ).ListDown = List;
308: After = List;
309: }
310: return Typed;
311: }
312:
313: /*
314: * copies a T_VARPT node to a VarntNode and a FieldDNode
315: * varpt [0] T_TYVARPT
316: * [1] lineof "case"
317: * [2] tag id (or nil)
318: * [3] tag type
319: * [4] list of variant cases
320: * uses the extern inrecord to know which record its in.
321: */
322: pPointer
323: VarntCopy( tyvarpt )
324: int *tyvarpt;
325: {
326: extern struct nl *inrecord;
327: pPointer Varnt = pNewNode( VarntTAG , sizeof( struct VarntNode ) );
328: pPointer Tag = pNewNode( FieldDTAG , sizeof( struct FieldDNode ) );
329: pPointer Name = sCopy( tyvarpt[2] );
330: pPointer Type = tCopy( tyvarpt[3] );
331: pPointer Cases = tCopy( tyvarpt[4] );
332:
333: pDEF( Tag ).FieldDName = Name;
334: pDEF( Tag ).FieldDType = Type;
335: if ( tyvarpt[2] != NIL )
336: reclook( inrecord , tyvarpt[2] ) -> inTree = Tag;
337: pDEF( Varnt ).VarntTag = Tag;
338: pDEF( Varnt ).VarntCases = Cases;
339: return Varnt;
340: }
341:
342: /*
343: * copies a T_TYSCAL node to an EnumTNode and a list of ScalDNodes
344: * tyscal [0] T_TYSCAL
345: * [1] lineof "("
346: * [2] id_list
347: */
348: pPointer
349: EnumTCopy( tyscal )
350: int *tyscal;
351: {
352: pPointer EnumT = pNewNode( EnumTTAG , sizeof( struct EnumTNode ) );
353: pPointer ScalD;
354: pPointer Name;
355: int *idp;
356: pPointer List;
357: pPointer After;
358:
359: After = pNIL;
360: for ( idp = (int *) tyscal[2] ; idp != NIL ; idp = (int *) idp[2] ) {
361: ScalD = pNewNode( ScalDTAG , sizeof( struct ScalDNode ) );
362: Name = sCopy( idp[1] );
363: pDEF( ScalD ).ScalDName = Name;
364: nllook( idp[1] ) -> inTree = ScalD;
365: List = pNewNode( ListTAG , sizeof( struct ListNode ) );
366: pDEF( List ).ListItem = ScalD;
367: pDEF( List ).ListUp = After;
368: pDEF( List ).ListDown = pNIL;
369: if ( After == pNIL )
370: pDEF( EnumT ).EnumTScalars = List;
371: else pDEF( After ).ListDown = List;
372: After = List;
373: }
374: return EnumT;
375: }
376:
377: /*
378: * copies a variable declaration to a TypedNode
379: * with a type and a list of VarDNodes
380: * also, deals with previously declared (e.g. program files) variables.
381: */
382: pPointer
383: VarDecl( idl , type )
384: int *idl;
385: int *type;
386: {
387: pPointer Typed = pNewNode( TypedTAG , sizeof( struct TypedNode ) );
388: int *idlp;
389: struct nl *var;
390: pPointer VarD;
391: pPointer Name;
392: pPointer Type = tCopy( type );
393: pPointer List;
394: pPointer After;
395:
396: pDEF( Typed ).TypedNames = pNIL;
397: pDEF( Typed ).TypedType = Type;
398: After = pNIL;
399: for ( idlp = (int *) idl ; idlp != NIL ; idlp = (int *) idlp[2] ) {
400: if ( ( var = nllook( idlp[1] ) ) -> inTree == pNIL ) {
401: /*
402: * usual case, a new variable
403: */
404: VarD = pNewNode( VarDTAG , sizeof( struct VarDNode ) );
405: Name = sCopy( idlp[1] );
406: pDEF( VarD ).VarDName = Name;
407: var -> inTree = VarD;
408: } else {
409: /*
410: * previously declared (file) variable, already in tree
411: * gets hung on list of variables, in addition
412: */
413: VarD = var -> inTree;
414: }
415: pDEF( VarD ).VarDType = Type;
416: if ( ( var -> type ) -> class == PTR ) {
417: ( var -> type ) -> inTree = Type;
418: }
419: List = pNewNode( ListTAG , sizeof( struct ListNode ) );
420: pDEF( List ).ListItem = VarD;
421: pDEF( List ).ListUp = After;
422: pDEF( List ).ListDown = pNIL;
423: if ( After == pNIL )
424: pDEF( Typed ).TypedNames = List;
425: else pDEF( After ).ListDown = List;
426: After = List;
427: }
428: return Typed;
429: }
430:
431:
432: /*
433: * initialize the pTree
434: * including cheapo versions of all the builtins (eech!)
435: */
436: pTreeInit()
437: {
438: extern char *in_consts[];
439: extern char *in_types[];
440: extern char *in_ctypes[];
441: extern char *in_vars[];
442: extern char *in_funcs[];
443: extern char *in_procs[];
444: union pNodeBodies *Glob;
445: pPointer List;
446: char **cp;
447:
448: nesting = 0;
449: PorFHeader[ nesting ] = pNewNode( GlobTAG , sizeof( struct GlobNode ) );
450: pWorld = PorFHeader[ nesting ];
451: pSeize( PorFHeader[ nesting ] );
452: Glob = &( pDEF( PorFHeader[ nesting ] ) );
453: /*
454: * built in constants
455: */
456: dumpnl( NIL , "pTreeInit" );
457: List = pNIL;
458: for ( cp = in_consts ; *cp ; cp ++ ) {
459: pPointer BCon = pNewNode( BConstTAG , sizeof( struct BConstNode ) );
460: pPointer Name = sCopy( *cp );
461:
462: pDEF( BCon ).BConstName = Name;
463: List = ListAppend( List , BCon );
464: nllook( *cp ) -> inTree = BCon;
465: }
466: Glob -> GlobConsts = List;
467: /*
468: * built in simple and constructed types
469: */
470: List = pNIL;
471: /*
472: * simple types
473: */
474: for ( cp = in_types ; *cp ; cp ++ ) {
475: pPointer BType = pNewNode( BTypeTAG , sizeof( struct BTypeNode ) );
476: pPointer Name = sCopy( *cp );
477:
478: pDEF( BType ).BTypeName = Name;
479: List = ListAppend( List , BType );
480: nllook( *cp ) -> inTree = BType;
481: }
482: /*
483: * constructed types (aren't any more difficult)
484: */
485: for ( cp = in_ctypes ; *cp ; cp ++ ) {
486: pPointer BType = pNewNode( BTypeTAG , sizeof( struct BTypeNode ) );
487: pPointer Name = sCopy( *cp );
488:
489: pDEF( BType ).BTypeName = Name;
490: List = ListAppend( List , BType );
491: nllook( *cp ) -> inTree = BType;
492: }
493: Glob -> GlobType = List;
494: /*
495: * built in variables
496: */
497: List = pNIL;
498: for ( cp = in_vars ; *cp ; cp ++ ) {
499: pPointer BVar = pNewNode( BVarTAG , sizeof( struct BVarNode ) );
500: pPointer Name = sCopy( *cp );
501:
502: pDEF( BVar ).BVarName = Name;
503: List = ListAppend( List , BVar );
504: nllook( *cp ) -> inTree = BVar;
505: }
506: Glob -> GlobVars = List;
507: /*
508: * built in functions and procedures
509: */
510: List = pNIL;
511: /*
512: * built in functions
513: */
514: for ( cp = in_funcs ; *cp ; cp ++ ) {
515: pPointer BFunc = pNewNode( BFuncTAG , sizeof( struct BFuncNode ) );
516: pPointer Name = sCopy( *cp );
517:
518: pDEF( BFunc ).BFuncName = Name;
519: List = ListAppend( List , BFunc );
520: nllook( *cp ) -> inTree = BFunc;
521: }
522: /*
523: * built in procedures
524: */
525: for ( cp = in_procs ; *cp ; cp ++ ) {
526: pPointer BProc = pNewNode( BProcTAG , sizeof( struct BProcNode ) );
527: pPointer Name = sCopy( *cp );
528:
529: pDEF( BProc ).BProcName = Name;
530: List = ListAppend( List , BProc );
531: nllook( *cp ) -> inTree = BProc;
532: }
533: Glob -> GlobPFs = List;
534: pRelease( PorFHeader[ nesting ] );
535: }
536:
537: /*
538: * find a symbol in the
539: * block structure symbol
540: * table and returns a pointer to
541: * its namelist entry.
542: * [this is a copy of lookup, except it calls nllook1
543: * whose only variation from lookup1 is that it doesn't set NUSED]
544: */
545: struct nl *
546: nllook(s)
547: register char *s;
548: {
549: register struct nl *p;
550: register struct udinfo *udp;
551:
552: if (s == NIL) {
553: nocascade();
554: return (NIL);
555: }
556: p = nllook1(s);
557: if (p == NIL) {
558: derror("%s is undefined", s);
559: return (NIL);
560: }
561: if (p->class == FVAR) {
562: p = p->chain;
563: bn--;
564: }
565: return (p);
566: }
567:
568: /*
569: * an internal nllook.
570: * It is not an error to call nllook1 if the symbol is not defined.
571: * Also nllook1 will return FVARs while nllook never will.
572: * [this is a copy of lookup1, except that it doesn't set NUSED]
573: */
574:
575: struct nl *
576: nllook1(s)
577: register char *s;
578: {
579: register struct nl *p;
580: # ifndef PI0
581: register struct nl *q;
582: # endif
583: register int i;
584:
585: if (s == NIL)
586: return (NIL);
587: bn = cbn;
588: #ifndef PI0
589: /*
590: * We first check the field names
591: * of the currently active with
592: * statements (expensive since they
593: * are not hashed).
594: */
595: for (p = withlist; p != NIL; p = p->nl_next) {
596: q = p->type;
597: if (q == NIL)
598: continue;
599: if (reclook(q, s) != NIL)
600: /*
601: * Return the WITHPTR, lvalue understands.
602: */
603: return (p);
604: }
605: #endif
606: /*
607: * Symbol table is a 64 way hash
608: * on the low bits of the character
609: * pointer value. (Simple, but effective)
610: */
611: i = (int) s & 077;
612: for (p = disptab[i]; p != NIL; p = p->nl_next)
613: if (p->symbol == s && p->class != FIELD && p->class != BADUSE) {
614: bn = (p->nl_block & 037);
615: return (p);
616: }
617: return (NIL);
618: }
619:
620: #endif PTREE
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.