[unix-history] / .ref-BSD-3 / usr / src / cmd / pi / tCopy.c

    /*
     *	tCopy.c
     *
     *	functions to copy pi trees to pTrees
     */

#include	"whoami"

#ifdef PTREE

#include	"0.h"

#include	"tree.h"

    /*
     *	tCopy
     *	a mongo switch statement to farm out the actual copying 
     *	to the appropriate routines.
     *	given a pointer to a pi tree branch, it returns a pPointer to
     *	a pTree copy of that branch.
     */
pPointer
tCopy( node )
    int	*node;
    {

	if ( node == NIL )
	    return pNIL;
	switch ( node[ 0 ] ) {
	    case T_PROG:	
	    case T_PDEC:
	    case T_FDEC:	
		return PorFCopy( node );
	    case T_TYPTR:
		return PtrTCopy( node );
	    case T_TYPACK:
		return PackTCopy( node );
	    case T_TYSCAL:
		return EnumTCopy( node );
	    case T_TYRANG:
		return RangeTCopy( node );
	    case T_TYARY:
		return ArrayTCopy( node );
	    case T_TYFILE:
		return FileTCopy( node );
	    case T_TYSET:
		return SetTCopy( node );
	    case T_TYREC:
		return RecTCopy( node );
	    case T_FLDLST:
		return FldlstCopy( node );
	    case T_RFIELD:
		return FieldCopy( node );
	    case T_TYVARPT:
		return VarntCopy( node );
	    case T_TYVARNT:
		return VCaseCopy( node );
	    case T_CSTAT:
		return CasedCopy( node );
	    case T_PVAL:
	    case T_PVAR:
		return ParamCopy( node );
	    case T_CSTRNG:
		return sCopy( node[1] );
	    case T_STRNG:
		return sCopy( node[2] );
	    case T_PLUSC:
	    case T_PLUS:
	    case T_MINUSC:
	    case T_MINUS:
	    case T_NOT:
		return UnOpCopy( node );
	    case T_ID:
		return ThreadSymbol( node[1] );
	    case T_TYID:
		return ThreadSymbol( node[2] );
	    case T_CINT:
	    case T_CBINT:
		return iCopy( node[1] );
	    case T_INT:
	    case T_BINT:
		return iCopy( node[2] );
	    case T_CFINT:
		return fCopy( node[1] );
	    case T_FINT:
		return fCopy( node[2] );
	    case T_LISTPP:
		return ListCopy( node );
	    case T_PCALL:
		return PCallCopy( node );
	    case T_BLOCK:
	    case T_BSTL:
		return ListCopy( node[2] );
	    case T_CASE:
		return CaseSCopy( node );
	    case T_WITH:
		return WithCopy( node );
	    case T_WHILE:
		return WhileCopy( node );
	    case T_REPEAT:
		return RepeatCopy( node );
	    case T_FORU:
	    case T_FORD:
		return ForCopy( node );
	    case T_IF:
	    case T_IFEL:
		return IfCopy( node );
	    case T_GOTO:
		return GotoCopy( node );
	    case T_LABEL:
		return LabelCopy( node );
	    case T_ASRT:
		return AssertCopy( node );
	    case T_ASGN:
		return AssignCopy( node );
	    case T_NIL:
		return NilCopy( node );
	    case T_FCALL:
		return FCallCopy( node );
	    case T_CSET:
		return SetCopy( node );
	    case T_RANG:
		return RangeCopy( node );
	    case T_VAR:
		return VarCopy( node );
	    case T_ARY:
		return SubscCopy( node );
	    case T_FIELD:
		return SelCopy( node );
	    case T_PTR:
		return PtrCopy( node );
	    case T_EQ:
	    case T_LT:
	    case T_GT:
	    case T_LE:
	    case T_GE:
	    case T_NE:
	    case T_IN:
	    case T_ADD:
	    case T_SUB:
	    case T_MULT:
	    case T_DIVD:
	    case T_DIV:
	    case T_MOD:
	    case T_OR:
	    case T_AND:
		return BinOpCopy( node );
	    case T_WEXP:
		return WidthCopy( node );
	    default:
		panic("tCopy");
	}
    }

\f
    /*
     *	copy a list of nodes into ListNodes
     *	(with a hack for appending one list to another
     *	    for example: labelled statements)
     *	listnode[0]	T_LISTPP
     *		[1]	"list_element"
     *		[2]	"list_next"
     */
pPointer
ListCopy( listnode )
    int	*listnode;
    {
	pPointer	First;
	pPointer	After;
	int		*listp;
	pPointer	Item;
	pPointer	List;
	pPointer	Furthur;

	First = pNIL;
	After = pNIL;
	for ( listp = listnode ; listp != NIL ; listp = (int *) listp[2] ) {
	    List = pNewNode( ListTAG , sizeof( struct ListNode ) );
	    if ( First == pNIL )
		First = List;
	    Item = tCopy( listp[1] );
	    pDEF( List ).ListItem = Item;
	    pDEF( List ).ListDown = pNIL;
	    pDEF( List ).ListUp = After;
	    if ( After != pNIL )
		pDEF( After ).ListDown = List;
	    After = List;
	    /*
	     *	if ListItem is a ListNode whose ListUp is non-pNIL
	     *	append that list to this list, using that ListUp
	     *	as an additional ListItem.
	     */
	    Furthur = Item;
	    if (  Furthur != pNIL
	       && pTAG( Furthur ) == ListTAG
	       && pUSE( Furthur ).ListUp != pNIL ) {
		Item = pUSE( Furthur ).ListUp;
		pDEF( List ).ListItem = Item;
		pDEF( Furthur ).ListUp = List;
		pDEF( List ).ListDown = Furthur;
		do {
		    After = Furthur;
		    Furthur = pUSE( After ).ListDown;
		} while ( Furthur != pNIL );
	    }
	}
	return First;
    }

    /*
     *	ListAppend
     *	append a random item to the end of a list
     *	(with a hack for appending one list to another
     *	 e.g. labelled statments)
     */
pPointer
ListAppend( list , item )
    pPointer	list;
    pPointer	item;
    {
	pPointer	List = pNewNode( ListTAG , sizeof( struct ListNode ) );
	pPointer	First;
	pPointer	After;
	pPointer	Furthur;

	pDEF( List ).ListItem = item;
	pDEF( List ).ListDown = pNIL;
	First = After = list;
	if ( First == pNIL ) {
		First = List;
	} else {
		while ( ( Furthur = pUSE( After ).ListDown ) != pNIL )
		    After = Furthur;
		pDEF( After ).ListDown = List;
	}
	pDEF( List ).ListUp = After;
	/*
	 *	if item is a ListNode whose ListUp is non-pNIL
	 *	append that list to this list, using that ListUp
	 *	as an additional ListItem.
	 */
	Furthur = item;
	if (  Furthur != pNIL
	   && pTAG( Furthur ) == ListTAG
	   && pUSE( Furthur ).ListUp != pNIL ) {
	    pDEF( List ).ListDown = Furthur;
	    pDEF( List ).ListItem = pUSE( Furthur ).ListUp;
	    pDEF( Furthur ).ListUp = List;
	}
	return First;
    }

    /*
     *	iCopy
     *	copy an integer (string) to an IntNode
     */
pPointer
iCopy( intstring )
    char *intstring;
    {
	pPointer	Int = pNewNode( IntTAG , sizeof( struct IntNode ) );

	pDEF( Int ).IntValue = atol( intstring );
	return Int;
    }

    /*
     *	fCopy
     *	copy a float (string) to a RealNode
     */
pPointer
fCopy( realstring )
    char *realstring;
    {
	pPointer	Real = pNewNode( RealTAG , sizeof( struct RealNode ) );

	pDEF( Real ).RealValue = atof( realstring );
	return Real;
    }

    /*
     *	sCopy
     *	copy a string to a StringNode
     */
pPointer
sCopy( string )
    char *string;
    {
	pPointer	String;

	if ( string == NIL )
	    return pNIL;
	String = pNewNode( StringTAG , strlen( string ) + 1 );
	strcpy( pDEF( String ).StringValue , string );
	return String;
    }

#endif PTREE
Commit	Line	Data
6172cbb3 CH	1	/*
	2	* tCopy.c
	3	*
	4	* functions to copy pi trees to pTrees
	5	*/
	6
	7	#include "whoami"
	8
	9	#ifdef PTREE
	10
	11	#include "0.h"
	12
	13	#include "tree.h"
	14
	15	/*
	16	* tCopy
	17	* a mongo switch statement to farm out the actual copying
	18	* to the appropriate routines.
	19	* given a pointer to a pi tree branch, it returns a pPointer to
	20	* a pTree copy of that branch.
	21	*/
	22	pPointer
	23	tCopy( node )
	24	int *node;
	25	{
	26
	27	if ( node == NIL )
	28	return pNIL;
	29	switch ( node[ 0 ] ) {
	30	case T_PROG:
	31	case T_PDEC:
	32	case T_FDEC:
	33	return PorFCopy( node );
	34	case T_TYPTR:
	35	return PtrTCopy( node );
	36	case T_TYPACK:
	37	return PackTCopy( node );
	38	case T_TYSCAL:
	39	return EnumTCopy( node );
	40	case T_TYRANG:
	41	return RangeTCopy( node );
	42	case T_TYARY:
	43	return ArrayTCopy( node );
	44	case T_TYFILE:
	45	return FileTCopy( node );
	46	case T_TYSET:
	47	return SetTCopy( node );
	48	case T_TYREC:
	49	return RecTCopy( node );
	50	case T_FLDLST:
	51	return FldlstCopy( node );
	52	case T_RFIELD:
	53	return FieldCopy( node );
	54	case T_TYVARPT:
	55	return VarntCopy( node );
	56	case T_TYVARNT:
	57	return VCaseCopy( node );
	58	case T_CSTAT:
	59	return CasedCopy( node );
	60	case T_PVAL:
	61	case T_PVAR:
	62	return ParamCopy( node );
	63	case T_CSTRNG:
	64	return sCopy( node[1] );
65	case T_STRNG:
66	return sCopy( node[2] );
67	case T_PLUSC:
68	case T_PLUS:
69	case T_MINUSC:
70	case T_MINUS:
71	case T_NOT:
72	return UnOpCopy( node );
73	case T_ID:
74	return ThreadSymbol( node[1] );
75	case T_TYID:
76	return ThreadSymbol( node[2] );
77	case T_CINT:
78	case T_CBINT:
79	return iCopy( node[1] );
80	case T_INT:
81	case T_BINT:
82	return iCopy( node[2] );
83	case T_CFINT:
84	return fCopy( node[1] );
85	case T_FINT:
86	return fCopy( node[2] );
87	case T_LISTPP:
88	return ListCopy( node );
89	case T_PCALL:
90	return PCallCopy( node );
91	case T_BLOCK:
92	case T_BSTL:
93	return ListCopy( node[2] );
94	case T_CASE:
95	return CaseSCopy( node );
96	case T_WITH:
97	return WithCopy( node );
98	case T_WHILE:
99	return WhileCopy( node );
100	case T_REPEAT:
101	return RepeatCopy( node );
102	case T_FORU:
103	case T_FORD:
104	return ForCopy( node );
105	case T_IF:
106	case T_IFEL:
107	return IfCopy( node );
108	case T_GOTO:
109	return GotoCopy( node );
110	case T_LABEL:
111	return LabelCopy( node );
112	case T_ASRT:
113	return AssertCopy( node );
114	case T_ASGN:
115	return AssignCopy( node );
116	case T_NIL:
117	return NilCopy( node );
118	case T_FCALL:
119	return FCallCopy( node );
120	case T_CSET:
121	return SetCopy( node );
122	case T_RANG:
123	return RangeCopy( node );
124	case T_VAR:
125	return VarCopy( node );
126	case T_ARY:
127	return SubscCopy( node );
128	case T_FIELD:
129	return SelCopy( node );
130	case T_PTR:
131	return PtrCopy( node );
132	case T_EQ:
133	case T_LT:
134	case T_GT:
135	case T_LE:
136	case T_GE:
137	case T_NE:
138	case T_IN:
139	case T_ADD:
140	case T_SUB:
141	case T_MULT:
142	case T_DIVD:
143	case T_DIV:
144	case T_MOD:
145	case T_OR:
146	case T_AND:
147	return BinOpCopy( node );
148	case T_WEXP:
149	return WidthCopy( node );
150	default:
151	panic("tCopy");
152	}
153	}
154
155	\f
156	/*
157	* copy a list of nodes into ListNodes
158	* (with a hack for appending one list to another
159	* for example: labelled statements)
160	* listnode[0] T_LISTPP
161	* [1] "list_element"
162	* [2] "list_next"
163	*/
164	pPointer
165	ListCopy( listnode )
166	int *listnode;
167	{
168	pPointer First;
169	pPointer After;
170	int *listp;
171	pPointer Item;
172	pPointer List;
173	pPointer Furthur;
174
175	First = pNIL;
176	After = pNIL;
177	for ( listp = listnode ; listp != NIL ; listp = (int *) listp[2] ) {
178	List = pNewNode( ListTAG , sizeof( struct ListNode ) );
179	if ( First == pNIL )
180	First = List;
181	Item = tCopy( listp[1] );
182	pDEF( List ).ListItem = Item;
183	pDEF( List ).ListDown = pNIL;
184	pDEF( List ).ListUp = After;
185	if ( After != pNIL )
186	pDEF( After ).ListDown = List;
187	After = List;
188	/*
189	* if ListItem is a ListNode whose ListUp is non-pNIL
190	* append that list to this list, using that ListUp
191	* as an additional ListItem.
192	*/
193	Furthur = Item;
194	if ( Furthur != pNIL
195	&& pTAG( Furthur ) == ListTAG
196	&& pUSE( Furthur ).ListUp != pNIL ) {
197	Item = pUSE( Furthur ).ListUp;
198	pDEF( List ).ListItem = Item;
199	pDEF( Furthur ).ListUp = List;
200	pDEF( List ).ListDown = Furthur;
201	do {
202	After = Furthur;
203	Furthur = pUSE( After ).ListDown;
204	} while ( Furthur != pNIL );
205	}
206	}
207	return First;
208	}
209
210	/*
211	* ListAppend
212	* append a random item to the end of a list
213	* (with a hack for appending one list to another
214	* e.g. labelled statments)
215	*/
216	pPointer
217	ListAppend( list , item )
218	pPointer list;
219	pPointer item;
220	{
221	pPointer List = pNewNode( ListTAG , sizeof( struct ListNode ) );
222	pPointer First;
223	pPointer After;
224	pPointer Furthur;
225
226	pDEF( List ).ListItem = item;
227	pDEF( List ).ListDown = pNIL;
228	First = After = list;
229	if ( First == pNIL ) {
230	First = List;
231	} else {
232	while ( ( Furthur = pUSE( After ).ListDown ) != pNIL )
233	After = Furthur;
234	pDEF( After ).ListDown = List;
235	}
236	pDEF( List ).ListUp = After;
237	/*
238	* if item is a ListNode whose ListUp is non-pNIL
239	* append that list to this list, using that ListUp
240	* as an additional ListItem.
241	*/
242	Furthur = item;
243	if ( Furthur != pNIL
244	&& pTAG( Furthur ) == ListTAG
245	&& pUSE( Furthur ).ListUp != pNIL ) {
246	pDEF( List ).ListDown = Furthur;
247	pDEF( List ).ListItem = pUSE( Furthur ).ListUp;
248	pDEF( Furthur ).ListUp = List;
249	}
250	return First;
251	}
252
253	/*
254	* iCopy
255	* copy an integer (string) to an IntNode
256	*/
257	pPointer
258	iCopy( intstring )
259	char *intstring;
260	{
261	pPointer Int = pNewNode( IntTAG , sizeof( struct IntNode ) );
262
263	pDEF( Int ).IntValue = atol( intstring );
264	return Int;
265	}
266
267	/*
268	* fCopy
269	* copy a float (string) to a RealNode
270	*/
271	pPointer
272	fCopy( realstring )
273	char *realstring;
274	{
275	pPointer Real = pNewNode( RealTAG , sizeof( struct RealNode ) );
276
277	pDEF( Real ).RealValue = atof( realstring );
278	return Real;
279	}
280
281	/*
282	* sCopy
283	* copy a string to a StringNode
284	*/
285	pPointer
286	sCopy( string )
287	char *string;
288	{
289	pPointer String;
290
291	if ( string == NIL )
292	return pNIL;
293	String = pNewNode( StringTAG , strlen( string ) + 1 );
294	strcpy( pDEF( String ).StringValue , string );
295	return String;
296	}
297
298	#endif PTREE