/* ---------------------------------------------------------------- 
 * 	node file generated from /usr/local/src/postgres/src/backend/nodes/primnodes.h
 * 
 * 	this file has been generated by the Gen_accessors.sh
 * 	and Gen_creator.sh scripts as part of the initial node
 * 	generation process.
 * ---------------------------------------------------------------- 
 */
#include "/usr/local/src/postgres/src/backend/nodes/primnodes.h"
 
#ifdef NO_NODE_CHECKING
#define NODEAssertArg(x)
#else
#define NODEAssertArg(x)	AssertArg(x)
#endif NO_NODE_CHECKING
 

/* ---------------- 
 *    RInitResdom - Raw initializer for Resdom 
 *  
 *    This function just initializes the internal 
 *    information in a node.  
 * ---------------- 
 */ 
extern void RInitResdom(); 
 
void 
RInitResdom(p) 
Pointer p; 
{ 
	extern void OutResdom(); 
	extern bool EqualResdom(); 
	extern bool CopyResdom(); 

	Resdom node = (Resdom) p;
 
	node->type = classTag(Resdom); 
	node->outFunc = OutResdom; 
	node->equalFunc = EqualResdom; 
	node->copyFunc =  CopyResdom; 

	return;
}
 
/* ---------------- 
 *    Make creator function for Resdom 
 *  
 *    This function is in some sence "broken" because 
 *    it takes parameters for only this nodes slots and 
 *    leaves this nodes inherited slots uninitialized. 
 *  
 *    This is here for backward compatibility with code 
 *    that relies on this behaviour. 
 * ---------------- 
 */ 
extern Resdom MakeResdom(); 
 
Resdom
MakeResdom( resno, restype, rescomplex, reslen, resname, reskey, reskeyop, resjunk)
 	AttributeNumber		resno;
 	ObjectId		restype;
 	bool                    rescomplex;
 	Size			reslen;
 	Name			resname;
 	Index			reskey;
 	OperatorTupleForm	reskeyop ;
 	int			resjunk;
 
{ 
	Resdom node = New_Node(Resdom);
 
	RInitResdom(node);
 
	set_resno(node, resno); 
	set_restype(node, restype); 
	set_rescomplex(node, rescomplex); 
	set_reslen(node, reslen); 
	set_resname(node, resname); 
	set_reskey(node, reskey); 
	set_reskeyop(node, reskeyop); 
	set_resjunk(node, resjunk); 

	return(node);
}
 
/* ---------------- 
 *    Out function for Resdom 
 * ---------------- 
 */ 
extern void OutResdom(); 
; 
void 
OutResdom(str, node) 
	StringInfo str; 
	Resdom	node; 
{
	char buf[100]; 
#ifdef	OutResdomExists 

	appendStringInfo(str, "#S("); 
	_outResdom(str, node); 
	appendStringInfo(str, ")"); 

#else	/* OutResdomExists */ 
	sprintf(buf, "#S(Resdom node at 0x%lx)", node);
 
	appendStringInfo(str, buf); 
#endif	/* OutResdomExists */ 
}
 
/* ---------------- 
 *    Equal function for Resdom 
 * ---------------- 
 */ 
extern bool EqualResdom(); 
 
bool
EqualResdom(a, b) 
	Resdom	a, b; 
{ 
#ifdef	EqualResdomExists 
	return ((bool) _equalResdom(a, b)); 

#else	/* EqualResdomExists */ 
	printf("EqualResdom does not exist!");
 
	return (false); 
#endif	/* EqualResdomExists */ 
}
 
/* ---------------- 
 *    Copy function for Resdom 
 * ---------------- 
 */ 
extern bool CopyResdom(); 
 
bool
CopyResdom(from, to, alloc) 
	Resdom	from; 
	Resdom	*to;	/* return */ 
	char *	(*alloc)(); 
{ 
#ifdef	CopyResdomExists 
	return ((bool) _copyResdom(from, to, alloc)); 

#else	/* CopyResdomExists */ 
	printf("CopyResdom does not exist!");
 
	return (false); 
#endif	/* CopyResdomExists */ 
}
 
/* ---------------- 
 *    IMakeResdom - Inherited Make creator for Resdom 
 *  
 *    This creator function takes a parameter 
 *    for each slot in this class and each slot 
 *    in all inherited classes. 
 * ---------------- 
 */ 
extern Resdom IMakeResdom(); 
 
Resdom
IMakeResdom( resno, restype, rescomplex, reslen, resname, reskey, reskeyop, resjunk)
  AttributeNumber resno ;
  ObjectId restype ;
  bool rescomplex ;
  Size reslen ;
  Name resname ;
  Index reskey ;
  OperatorTupleForm reskeyop  ;
  int resjunk ;
 
{ 
	Resdom node = New_Node(Resdom);
 
	RInitResdom(node);
 
	set_resno(node, resno); 
	set_restype(node, restype); 
	set_rescomplex(node, rescomplex); 
	set_reslen(node, reslen); 
	set_resname(node, resname); 
	set_reskey(node, reskey); 
	set_reskeyop(node, reskeyop); 
	set_resjunk(node, resjunk); 

	return(node);
}
 
/* ---------------- 
 *    RMakeResdom - Raw Make creator for Resdom 
 *  
 *    This creator function does not initialize 
 *    any of its slots..  This is left up to the 
 *    calling routine. 
 * ---------------- 
 */ 
extern Resdom RMakeResdom(); 
 
Resdom
RMakeResdom() 
{ 
	Resdom node = New_Node(Resdom);
 
	RInitResdom(node); 

	return(node);
}
 
/* ---------------- 
 *    RInitFjoin - Raw initializer for Fjoin 
 *  
 *    This function just initializes the internal 
 *    information in a node.  
 * ---------------- 
 */ 
extern void RInitFjoin(); 
 
void 
RInitFjoin(p) 
Pointer p; 
{ 
	extern void OutFjoin(); 
	extern bool EqualFjoin(); 
	extern bool CopyFjoin(); 

	Fjoin node = (Fjoin) p;
 
	node->type = classTag(Fjoin); 
	node->outFunc = OutFjoin; 
	node->equalFunc = EqualFjoin; 
	node->copyFunc =  CopyFjoin; 

	return;
}
 
/* ---------------- 
 *    Make creator function for Fjoin 
 *  
 *    This function is in some sence "broken" because 
 *    it takes parameters for only this nodes slots and 
 *    leaves this nodes inherited slots uninitialized. 
 *  
 *    This is here for backward compatibility with code 
 *    that relies on this behaviour. 
 * ---------------- 
 */ 
extern Fjoin MakeFjoin(); 
 
Fjoin
MakeFjoin( fj_initialized, fj_nNodes, fj_innerNode, fj_results, fj_alwaysDone)
 	bool			fj_initialized;
 	int			fj_nNodes;
 	List			fj_innerNode;
 	DatumPtr		fj_results;
 	BoolPtr			fj_alwaysDone;
 
{ 
	Fjoin node = New_Node(Fjoin);
 
	RInitFjoin(node);
 
	set_fj_initialized(node, fj_initialized); 
	set_fj_nNodes(node, fj_nNodes); 
	set_fj_innerNode(node, fj_innerNode); 
	set_fj_results(node, fj_results); 
	set_fj_alwaysDone(node, fj_alwaysDone); 

	return(node);
}
 
/* ---------------- 
 *    Out function for Fjoin 
 * ---------------- 
 */ 
extern void OutFjoin(); 
; 
void 
OutFjoin(str, node) 
	StringInfo str; 
	Fjoin	node; 
{
	char buf[100]; 
#ifdef	OutFjoinExists 

	appendStringInfo(str, "#S("); 
	_outFjoin(str, node); 
	appendStringInfo(str, ")"); 

#else	/* OutFjoinExists */ 
	sprintf(buf, "#S(Fjoin node at 0x%lx)", node);
 
	appendStringInfo(str, buf); 
#endif	/* OutFjoinExists */ 
}
 
/* ---------------- 
 *    Equal function for Fjoin 
 * ---------------- 
 */ 
extern bool EqualFjoin(); 
 
bool
EqualFjoin(a, b) 
	Fjoin	a, b; 
{ 
#ifdef	EqualFjoinExists 
	return ((bool) _equalFjoin(a, b)); 

#else	/* EqualFjoinExists */ 
	printf("EqualFjoin does not exist!");
 
	return (false); 
#endif	/* EqualFjoinExists */ 
}
 
/* ---------------- 
 *    Copy function for Fjoin 
 * ---------------- 
 */ 
extern bool CopyFjoin(); 
 
bool
CopyFjoin(from, to, alloc) 
	Fjoin	from; 
	Fjoin	*to;	/* return */ 
	char *	(*alloc)(); 
{ 
#ifdef	CopyFjoinExists 
	return ((bool) _copyFjoin(from, to, alloc)); 

#else	/* CopyFjoinExists */ 
	printf("CopyFjoin does not exist!");
 
	return (false); 
#endif	/* CopyFjoinExists */ 
}
 
/* ---------------- 
 *    IMakeFjoin - Inherited Make creator for Fjoin 
 *  
 *    This creator function takes a parameter 
 *    for each slot in this class and each slot 
 *    in all inherited classes. 
 * ---------------- 
 */ 
extern Fjoin IMakeFjoin(); 
 
Fjoin
IMakeFjoin( fj_initialized, fj_nNodes, fj_innerNode, fj_results, fj_alwaysDone)
  bool fj_initialized ;
  int fj_nNodes ;
  List fj_innerNode ;
  DatumPtr fj_results ;
  BoolPtr fj_alwaysDone ;
 
{ 
	Fjoin node = New_Node(Fjoin);
 
	RInitFjoin(node);
 
	set_fj_initialized(node, fj_initialized); 
	set_fj_nNodes(node, fj_nNodes); 
	set_fj_innerNode(node, fj_innerNode); 
	set_fj_results(node, fj_results); 
	set_fj_alwaysDone(node, fj_alwaysDone); 

	return(node);
}
 
/* ---------------- 
 *    RMakeFjoin - Raw Make creator for Fjoin 
 *  
 *    This creator function does not initialize 
 *    any of its slots..  This is left up to the 
 *    calling routine. 
 * ---------------- 
 */ 
extern Fjoin RMakeFjoin(); 
 
Fjoin
RMakeFjoin() 
{ 
	Fjoin node = New_Node(Fjoin);
 
	RInitFjoin(node); 

	return(node);
}
 
/* ---------------- 
 *    RInitExpr - Raw initializer for Expr 
 *  
 *    This function just initializes the internal 
 *    information in a node.  
 * ---------------- 
 */ 
extern void RInitExpr(); 
 
void 
RInitExpr(p) 
Pointer p; 
{ 
	extern void OutExpr(); 
	extern bool EqualExpr(); 
	extern bool CopyExpr(); 

	Expr node = (Expr) p;
 
	node->type = classTag(Expr); 
	node->outFunc = OutExpr; 
	node->equalFunc = EqualExpr; 
	node->copyFunc =  CopyExpr; 

	return;
}
 
/* ---------------- 
 *    Make creator function for Expr 
 *  
 *    This function is in some sence "broken" because 
 *    it takes parameters for only this nodes slots and 
 *    leaves this nodes inherited slots uninitialized. 
 *  
 *    This is here for backward compatibility with code 
 *    that relies on this behaviour. 
 * ---------------- 
 */ 
extern Expr MakeExpr(); 
 
Expr
MakeExpr( fj_initialized)
 
{ 
	Expr node = New_Node(Expr);
 
	RInitExpr(node);
 

	return(node);
}
 
/* ---------------- 
 *    Out function for Expr 
 * ---------------- 
 */ 
extern void OutExpr(); 
; 
void 
OutExpr(str, node) 
	StringInfo str; 
	Expr	node; 
{
	char buf[100]; 
#ifdef	OutExprExists 

	appendStringInfo(str, "#S("); 
	_outExpr(str, node); 
	appendStringInfo(str, ")"); 

#else	/* OutExprExists */ 
	sprintf(buf, "#S(Expr node at 0x%lx)", node);
 
	appendStringInfo(str, buf); 
#endif	/* OutExprExists */ 
}
 
/* ---------------- 
 *    Equal function for Expr 
 * ---------------- 
 */ 
extern bool EqualExpr(); 
 
bool
EqualExpr(a, b) 
	Expr	a, b; 
{ 
#ifdef	EqualExprExists 
	return ((bool) _equalExpr(a, b)); 

#else	/* EqualExprExists */ 
	printf("EqualExpr does not exist!");
 
	return (false); 
#endif	/* EqualExprExists */ 
}
 
/* ---------------- 
 *    Copy function for Expr 
 * ---------------- 
 */ 
extern bool CopyExpr(); 
 
bool
CopyExpr(from, to, alloc) 
	Expr	from; 
	Expr	*to;	/* return */ 
	char *	(*alloc)(); 
{ 
#ifdef	CopyExprExists 
	return ((bool) _copyExpr(from, to, alloc)); 

#else	/* CopyExprExists */ 
	printf("CopyExpr does not exist!");
 
	return (false); 
#endif	/* CopyExprExists */ 
}
 
/* ---------------- 
 *    IMakeExpr - Inherited Make creator for Expr 
 *  
 *    This creator function takes a parameter 
 *    for each slot in this class and each slot 
 *    in all inherited classes. 
 * ---------------- 
 */ 
extern Expr IMakeExpr(); 
 
Expr
IMakeExpr( )
 
{ 
	Expr node = New_Node(Expr);
 
	RInitExpr(node);
 

	return(node);
}
 
/* ---------------- 
 *    RMakeExpr - Raw Make creator for Expr 
 *  
 *    This creator function does not initialize 
 *    any of its slots..  This is left up to the 
 *    calling routine. 
 * ---------------- 
 */ 
extern Expr RMakeExpr(); 
 
Expr
RMakeExpr() 
{ 
	Expr node = New_Node(Expr);
 
	RInitExpr(node); 

	return(node);
}
 
/* ---------------- 
 *    RInitVar - Raw initializer for Var 
 *  
 *    This function just initializes the internal 
 *    information in a node.  
 * ---------------- 
 */ 
extern void RInitVar(); 
 
void 
RInitVar(p) 
Pointer p; 
{ 
	extern void OutVar(); 
	extern bool EqualVar(); 
	extern bool CopyVar(); 

	Var node = (Var) p;
 
	node->type = classTag(Var); 
	node->outFunc = OutVar; 
	node->equalFunc = EqualVar; 
	node->copyFunc =  CopyVar; 

	return;
}
 
/* ---------------- 
 *    Make creator function for Var 
 *  
 *    This function is in some sence "broken" because 
 *    it takes parameters for only this nodes slots and 
 *    leaves this nodes inherited slots uninitialized. 
 *  
 *    This is here for backward compatibility with code 
 *    that relies on this behaviour. 
 * ---------------- 
 */ 
extern Var MakeVar(); 
 
Var
MakeVar( varno, varattno, vartype, varid, varslot)
 	Index			varno ;
 	AttributeNumber		varattno;
 	ObjectId		vartype;
 	List			varid;
 	Pointer			varslot;
 
{ 
	Var node = New_Node(Var);
 
	RInitVar(node);
 
	set_varno(node, varno); 
	set_varattno(node, varattno); 
	set_vartype(node, vartype); 
	set_varid(node, varid); 
	set_varslot(node, varslot); 

	return(node);
}
 
/* ---------------- 
 *    Out function for Var 
 * ---------------- 
 */ 
extern void OutVar(); 
; 
void 
OutVar(str, node) 
	StringInfo str; 
	Var	node; 
{
	char buf[100]; 
#ifdef	OutVarExists 

	appendStringInfo(str, "#S("); 
	_outVar(str, node); 
	appendStringInfo(str, ")"); 

#else	/* OutVarExists */ 
	sprintf(buf, "#S(Var node at 0x%lx)", node);
 
	appendStringInfo(str, buf); 
#endif	/* OutVarExists */ 
}
 
/* ---------------- 
 *    Equal function for Var 
 * ---------------- 
 */ 
extern bool EqualVar(); 
 
bool
EqualVar(a, b) 
	Var	a, b; 
{ 
#ifdef	EqualVarExists 
	return ((bool) _equalVar(a, b)); 

#else	/* EqualVarExists */ 
	printf("EqualVar does not exist!");
 
	return (false); 
#endif	/* EqualVarExists */ 
}
 
/* ---------------- 
 *    Copy function for Var 
 * ---------------- 
 */ 
extern bool CopyVar(); 
 
bool
CopyVar(from, to, alloc) 
	Var	from; 
	Var	*to;	/* return */ 
	char *	(*alloc)(); 
{ 
#ifdef	CopyVarExists 
	return ((bool) _copyVar(from, to, alloc)); 

#else	/* CopyVarExists */ 
	printf("CopyVar does not exist!");
 
	return (false); 
#endif	/* CopyVarExists */ 
}
 
/* ---------------- 
 *    IMakeVar - Inherited Make creator for Var 
 *  
 *    This creator function takes a parameter 
 *    for each slot in this class and each slot 
 *    in all inherited classes. 
 * ---------------- 
 */ 
extern Var IMakeVar(); 
 
Var
IMakeVar( varno, varattno, vartype, varid, varslot)
  Index varno  ;
  AttributeNumber varattno ;
  ObjectId vartype ;
  List varid ;
  Pointer varslot ;
 
{ 
	Var node = New_Node(Var);
 
	RInitVar(node);
 
	set_varno(node, varno); 
	set_varattno(node, varattno); 
	set_vartype(node, vartype); 
	set_varid(node, varid); 
	set_varslot(node, varslot); 

	return(node);
}
 
/* ---------------- 
 *    RMakeVar - Raw Make creator for Var 
 *  
 *    This creator function does not initialize 
 *    any of its slots..  This is left up to the 
 *    calling routine. 
 * ---------------- 
 */ 
extern Var RMakeVar(); 
 
Var
RMakeVar() 
{ 
	Var node = New_Node(Var);
 
	RInitVar(node); 

	return(node);
}
 
/* ---------------- 
 *    RInitOper - Raw initializer for Oper 
 *  
 *    This function just initializes the internal 
 *    information in a node.  
 * ---------------- 
 */ 
extern void RInitOper(); 
 
void 
RInitOper(p) 
Pointer p; 
{ 
	extern void OutOper(); 
	extern bool EqualOper(); 
	extern bool CopyOper(); 

	Oper node = (Oper) p;
 
	node->type = classTag(Oper); 
	node->outFunc = OutOper; 
	node->equalFunc = EqualOper; 
	node->copyFunc =  CopyOper; 

	return;
}
 
/* ---------------- 
 *    Make creator function for Oper 
 *  
 *    This function is in some sence "broken" because 
 *    it takes parameters for only this nodes slots and 
 *    leaves this nodes inherited slots uninitialized. 
 *  
 *    This is here for backward compatibility with code 
 *    that relies on this behaviour. 
 * ---------------- 
 */ 
extern Oper MakeOper(); 
 
Oper
MakeOper( opno, opid, oprelationlevel, opresulttype, opsize, op_fcache)
 	ObjectId		opno;
 	ObjectId		opid;
 	bool			oprelationlevel;
 	ObjectId		opresulttype;
 	int			opsize;
 	FunctionCachePtr	op_fcache;
 
{ 
	Oper node = New_Node(Oper);
 
	RInitOper(node);
 
	set_opno(node, opno); 
	set_opid(node, opid); 
	set_oprelationlevel(node, oprelationlevel); 
	set_opresulttype(node, opresulttype); 
	set_opsize(node, opsize); 
	set_op_fcache(node, op_fcache); 

	return(node);
}
 
/* ---------------- 
 *    Out function for Oper 
 * ---------------- 
 */ 
extern void OutOper(); 
; 
void 
OutOper(str, node) 
	StringInfo str; 
	Oper	node; 
{
	char buf[100]; 
#ifdef	OutOperExists 

	appendStringInfo(str, "#S("); 
	_outOper(str, node); 
	appendStringInfo(str, ")"); 

#else	/* OutOperExists */ 
	sprintf(buf, "#S(Oper node at 0x%lx)", node);
 
	appendStringInfo(str, buf); 
#endif	/* OutOperExists */ 
}
 
/* ---------------- 
 *    Equal function for Oper 
 * ---------------- 
 */ 
extern bool EqualOper(); 
 
bool
EqualOper(a, b) 
	Oper	a, b; 
{ 
#ifdef	EqualOperExists 
	return ((bool) _equalOper(a, b)); 

#else	/* EqualOperExists */ 
	printf("EqualOper does not exist!");
 
	return (false); 
#endif	/* EqualOperExists */ 
}
 
/* ---------------- 
 *    Copy function for Oper 
 * ---------------- 
 */ 
extern bool CopyOper(); 
 
bool
CopyOper(from, to, alloc) 
	Oper	from; 
	Oper	*to;	/* return */ 
	char *	(*alloc)(); 
{ 
#ifdef	CopyOperExists 
	return ((bool) _copyOper(from, to, alloc)); 

#else	/* CopyOperExists */ 
	printf("CopyOper does not exist!");
 
	return (false); 
#endif	/* CopyOperExists */ 
}
 
/* ---------------- 
 *    IMakeOper - Inherited Make creator for Oper 
 *  
 *    This creator function takes a parameter 
 *    for each slot in this class and each slot 
 *    in all inherited classes. 
 * ---------------- 
 */ 
extern Oper IMakeOper(); 
 
Oper
IMakeOper( opno, opid, oprelationlevel, opresulttype, opsize, op_fcache)
  ObjectId opno ;
  ObjectId opid ;
  bool oprelationlevel ;
  ObjectId opresulttype ;
  int opsize ;
  FunctionCachePtr op_fcache ;
 
{ 
	Oper node = New_Node(Oper);
 
	RInitOper(node);
 
	set_opno(node, opno); 
	set_opid(node, opid); 
	set_oprelationlevel(node, oprelationlevel); 
	set_opresulttype(node, opresulttype); 
	set_opsize(node, opsize); 
	set_op_fcache(node, op_fcache); 

	return(node);
}
 
/* ---------------- 
 *    RMakeOper - Raw Make creator for Oper 
 *  
 *    This creator function does not initialize 
 *    any of its slots..  This is left up to the 
 *    calling routine. 
 * ---------------- 
 */ 
extern Oper RMakeOper(); 
 
Oper
RMakeOper() 
{ 
	Oper node = New_Node(Oper);
 
	RInitOper(node); 

	return(node);
}
 
/* ---------------- 
 *    RInitConst - Raw initializer for Const 
 *  
 *    This function just initializes the internal 
 *    information in a node.  
 * ---------------- 
 */ 
extern void RInitConst(); 
 
void 
RInitConst(p) 
Pointer p; 
{ 
	extern void OutConst(); 
	extern bool EqualConst(); 
	extern bool CopyConst(); 

	Const node = (Const) p;
 
	node->type = classTag(Const); 
	node->outFunc = OutConst; 
	node->equalFunc = EqualConst; 
	node->copyFunc =  CopyConst; 

	return;
}
 
/* ---------------- 
 *    Make creator function for Const 
 *  
 *    This function is in some sence "broken" because 
 *    it takes parameters for only this nodes slots and 
 *    leaves this nodes inherited slots uninitialized. 
 *  
 *    This is here for backward compatibility with code 
 *    that relies on this behaviour. 
 * ---------------- 
 */ 
extern Const MakeConst(); 
 
Const
MakeConst( consttype, constlen, constvalue, constisnull, constbyval)
 	ObjectId		consttype;
 	Size			constlen;
 	Datum			constvalue;
 	bool			constisnull;
 	bool			constbyval;
 
{ 
	Const node = New_Node(Const);
 
	RInitConst(node);
 
	set_consttype(node, consttype); 
	set_constlen(node, constlen); 
	set_constvalue(node, constvalue); 
	set_constisnull(node, constisnull); 
	set_constbyval(node, constbyval); 

	return(node);
}
 
/* ---------------- 
 *    Out function for Const 
 * ---------------- 
 */ 
extern void OutConst(); 
; 
void 
OutConst(str, node) 
	StringInfo str; 
	Const	node; 
{
	char buf[100]; 
#ifdef	OutConstExists 

	appendStringInfo(str, "#S("); 
	_outConst(str, node); 
	appendStringInfo(str, ")"); 

#else	/* OutConstExists */ 
	sprintf(buf, "#S(Const node at 0x%lx)", node);
 
	appendStringInfo(str, buf); 
#endif	/* OutConstExists */ 
}
 
/* ---------------- 
 *    Equal function for Const 
 * ---------------- 
 */ 
extern bool EqualConst(); 
 
bool
EqualConst(a, b) 
	Const	a, b; 
{ 
#ifdef	EqualConstExists 
	return ((bool) _equalConst(a, b)); 

#else	/* EqualConstExists */ 
	printf("EqualConst does not exist!");
 
	return (false); 
#endif	/* EqualConstExists */ 
}
 
/* ---------------- 
 *    Copy function for Const 
 * ---------------- 
 */ 
extern bool CopyConst(); 
 
bool
CopyConst(from, to, alloc) 
	Const	from; 
	Const	*to;	/* return */ 
	char *	(*alloc)(); 
{ 
#ifdef	CopyConstExists 
	return ((bool) _copyConst(from, to, alloc)); 

#else	/* CopyConstExists */ 
	printf("CopyConst does not exist!");
 
	return (false); 
#endif	/* CopyConstExists */ 
}
 
/* ---------------- 
 *    IMakeConst - Inherited Make creator for Const 
 *  
 *    This creator function takes a parameter 
 *    for each slot in this class and each slot 
 *    in all inherited classes. 
 * ---------------- 
 */ 
extern Const IMakeConst(); 
 
Const
IMakeConst( consttype, constlen, constvalue, constisnull, constbyval)
  ObjectId consttype ;
  Size constlen ;
  Datum constvalue ;
  bool constisnull ;
  bool constbyval ;
 
{ 
	Const node = New_Node(Const);
 
	RInitConst(node);
 
	set_consttype(node, consttype); 
	set_constlen(node, constlen); 
	set_constvalue(node, constvalue); 
	set_constisnull(node, constisnull); 
	set_constbyval(node, constbyval); 

	return(node);
}
 
/* ---------------- 
 *    RMakeConst - Raw Make creator for Const 
 *  
 *    This creator function does not initialize 
 *    any of its slots..  This is left up to the 
 *    calling routine. 
 * ---------------- 
 */ 
extern Const RMakeConst(); 
 
Const
RMakeConst() 
{ 
	Const node = New_Node(Const);
 
	RInitConst(node); 

	return(node);
}
 
/* ---------------- 
 *    RInitParam - Raw initializer for Param 
 *  
 *    This function just initializes the internal 
 *    information in a node.  
 * ---------------- 
 */ 
extern void RInitParam(); 
 
void 
RInitParam(p) 
Pointer p; 
{ 
	extern void OutParam(); 
	extern bool EqualParam(); 
	extern bool CopyParam(); 

	Param node = (Param) p;
 
	node->type = classTag(Param); 
	node->outFunc = OutParam; 
	node->equalFunc = EqualParam; 
	node->copyFunc =  CopyParam; 

	return;
}
 
/* ---------------- 
 *    Make creator function for Param 
 *  
 *    This function is in some sence "broken" because 
 *    it takes parameters for only this nodes slots and 
 *    leaves this nodes inherited slots uninitialized. 
 *  
 *    This is here for backward compatibility with code 
 *    that relies on this behaviour. 
 * ---------------- 
 */ 
extern Param MakeParam(); 
 
Param
MakeParam( paramkind, paramid, paramname, paramtype, param_tlist)
 	int			paramkind;
 	AttributeNumber		paramid;
 	Name			paramname;
 	ObjectId		paramtype;
 	List                    param_tlist;
 
{ 
	Param node = New_Node(Param);
 
	RInitParam(node);
 
	set_paramkind(node, paramkind); 
	set_paramid(node, paramid); 
	set_paramname(node, paramname); 
	set_paramtype(node, paramtype); 
	set_param_tlist(node, param_tlist); 

	return(node);
}
 
/* ---------------- 
 *    Out function for Param 
 * ---------------- 
 */ 
extern void OutParam(); 
; 
void 
OutParam(str, node) 
	StringInfo str; 
	Param	node; 
{
	char buf[100]; 
#ifdef	OutParamExists 

	appendStringInfo(str, "#S("); 
	_outParam(str, node); 
	appendStringInfo(str, ")"); 

#else	/* OutParamExists */ 
	sprintf(buf, "#S(Param node at 0x%lx)", node);
 
	appendStringInfo(str, buf); 
#endif	/* OutParamExists */ 
}
 
/* ---------------- 
 *    Equal function for Param 
 * ---------------- 
 */ 
extern bool EqualParam(); 
 
bool
EqualParam(a, b) 
	Param	a, b; 
{ 
#ifdef	EqualParamExists 
	return ((bool) _equalParam(a, b)); 

#else	/* EqualParamExists */ 
	printf("EqualParam does not exist!");
 
	return (false); 
#endif	/* EqualParamExists */ 
}
 
/* ---------------- 
 *    Copy function for Param 
 * ---------------- 
 */ 
extern bool CopyParam(); 
 
bool
CopyParam(from, to, alloc) 
	Param	from; 
	Param	*to;	/* return */ 
	char *	(*alloc)(); 
{ 
#ifdef	CopyParamExists 
	return ((bool) _copyParam(from, to, alloc)); 

#else	/* CopyParamExists */ 
	printf("CopyParam does not exist!");
 
	return (false); 
#endif	/* CopyParamExists */ 
}
 
/* ---------------- 
 *    IMakeParam - Inherited Make creator for Param 
 *  
 *    This creator function takes a parameter 
 *    for each slot in this class and each slot 
 *    in all inherited classes. 
 * ---------------- 
 */ 
extern Param IMakeParam(); 
 
Param
IMakeParam( paramkind, paramid, paramname, paramtype, param_tlist)
  int paramkind ;
  AttributeNumber paramid ;
  Name paramname ;
  ObjectId paramtype ;
  List param_tlist ;
 
{ 
	Param node = New_Node(Param);
 
	RInitParam(node);
 
	set_paramkind(node, paramkind); 
	set_paramid(node, paramid); 
	set_paramname(node, paramname); 
	set_paramtype(node, paramtype); 
	set_param_tlist(node, param_tlist); 

	return(node);
}
 
/* ---------------- 
 *    RMakeParam - Raw Make creator for Param 
 *  
 *    This creator function does not initialize 
 *    any of its slots..  This is left up to the 
 *    calling routine. 
 * ---------------- 
 */ 
extern Param RMakeParam(); 
 
Param
RMakeParam() 
{ 
	Param node = New_Node(Param);
 
	RInitParam(node); 

	return(node);
}
 
/* ---------------- 
 *    RInitFunc - Raw initializer for Func 
 *  
 *    This function just initializes the internal 
 *    information in a node.  
 * ---------------- 
 */ 
extern void RInitFunc(); 
 
void 
RInitFunc(p) 
Pointer p; 
{ 
	extern void OutFunc(); 
	extern bool EqualFunc(); 
	extern bool CopyFunc(); 

	Func node = (Func) p;
 
	node->type = classTag(Func); 
	node->outFunc = OutFunc; 
	node->equalFunc = EqualFunc; 
	node->copyFunc =  CopyFunc; 

	return;
}
 
/* ---------------- 
 *    Make creator function for Func 
 *  
 *    This function is in some sence "broken" because 
 *    it takes parameters for only this nodes slots and 
 *    leaves this nodes inherited slots uninitialized. 
 *  
 *    This is here for backward compatibility with code 
 *    that relies on this behaviour. 
 * ---------------- 
 */ 
extern Func MakeFunc(); 
 
Func
MakeFunc( funcid, functype, funcisindex, funcsize, func_fcache, func_tlist, func_planlist)
 	ObjectId		funcid;
 	ObjectId		functype;
 	bool			funcisindex;
 	int			funcsize;
 	FunctionCachePtr	func_fcache;
 	List                    func_tlist;
 	List                    func_planlist;
 
{ 
	Func node = New_Node(Func);
 
	RInitFunc(node);
 
	set_funcid(node, funcid); 
	set_functype(node, functype); 
	set_funcisindex(node, funcisindex); 
	set_funcsize(node, funcsize); 
	set_func_fcache(node, func_fcache); 
	set_func_tlist(node, func_tlist); 
	set_func_planlist(node, func_planlist); 

	return(node);
}
 
/* ---------------- 
 *    Out function for Func 
 * ---------------- 
 */ 
extern void OutFunc(); 
; 
void 
OutFunc(str, node) 
	StringInfo str; 
	Func	node; 
{
	char buf[100]; 
#ifdef	OutFuncExists 

	appendStringInfo(str, "#S("); 
	_outFunc(str, node); 
	appendStringInfo(str, ")"); 

#else	/* OutFuncExists */ 
	sprintf(buf, "#S(Func node at 0x%lx)", node);
 
	appendStringInfo(str, buf); 
#endif	/* OutFuncExists */ 
}
 
/* ---------------- 
 *    Equal function for Func 
 * ---------------- 
 */ 
extern bool EqualFunc(); 
 
bool
EqualFunc(a, b) 
	Func	a, b; 
{ 
#ifdef	EqualFuncExists 
	return ((bool) _equalFunc(a, b)); 

#else	/* EqualFuncExists */ 
	printf("EqualFunc does not exist!");
 
	return (false); 
#endif	/* EqualFuncExists */ 
}
 
/* ---------------- 
 *    Copy function for Func 
 * ---------------- 
 */ 
extern bool CopyFunc(); 
 
bool
CopyFunc(from, to, alloc) 
	Func	from; 
	Func	*to;	/* return */ 
	char *	(*alloc)(); 
{ 
#ifdef	CopyFuncExists 
	return ((bool) _copyFunc(from, to, alloc)); 

#else	/* CopyFuncExists */ 
	printf("CopyFunc does not exist!");
 
	return (false); 
#endif	/* CopyFuncExists */ 
}
 
/* ---------------- 
 *    IMakeFunc - Inherited Make creator for Func 
 *  
 *    This creator function takes a parameter 
 *    for each slot in this class and each slot 
 *    in all inherited classes. 
 * ---------------- 
 */ 
extern Func IMakeFunc(); 
 
Func
IMakeFunc( funcid, functype, funcisindex, funcsize, func_fcache, func_tlist, func_planlist)
  ObjectId funcid ;
  ObjectId functype ;
  bool funcisindex ;
  int funcsize ;
  FunctionCachePtr func_fcache ;
  List func_tlist ;
  List func_planlist ;
 
{ 
	Func node = New_Node(Func);
 
	RInitFunc(node);
 
	set_funcid(node, funcid); 
	set_functype(node, functype); 
	set_funcisindex(node, funcisindex); 
	set_funcsize(node, funcsize); 
	set_func_fcache(node, func_fcache); 
	set_func_tlist(node, func_tlist); 
	set_func_planlist(node, func_planlist); 

	return(node);
}
 
/* ---------------- 
 *    RMakeFunc - Raw Make creator for Func 
 *  
 *    This creator function does not initialize 
 *    any of its slots..  This is left up to the 
 *    calling routine. 
 * ---------------- 
 */ 
extern Func RMakeFunc(); 
 
Func
RMakeFunc() 
{ 
	Func node = New_Node(Func);
 
	RInitFunc(node); 

	return(node);
}
 
/* ---------------- 
 *    RInitArray - Raw initializer for Array 
 *  
 *    This function just initializes the internal 
 *    information in a node.  
 * ---------------- 
 */ 
extern void RInitArray(); 
 
void 
RInitArray(p) 
Pointer p; 
{ 
	extern void OutArray(); 
	extern bool EqualArray(); 
	extern bool CopyArray(); 

	Array node = (Array) p;
 
	node->type = classTag(Array); 
	node->outFunc = OutArray; 
	node->equalFunc = EqualArray; 
	node->copyFunc =  CopyArray; 

	return;
}
 
/* ---------------- 
 *    Make creator function for Array 
 *  
 *    This function is in some sence "broken" because 
 *    it takes parameters for only this nodes slots and 
 *    leaves this nodes inherited slots uninitialized. 
 *  
 *    This is here for backward compatibility with code 
 *    that relies on this behaviour. 
 * ---------------- 
 */ 
extern Array MakeArray(); 
 
Array
MakeArray( arrayelemtype, arrayelemlength, arrayelembyval, arrayndim, arraylow, arrayhigh, arraylen)
 	ObjectId		arrayelemtype;
 	int				arrayelemlength;
 	bool			arrayelembyval;
 	int 			arrayndim;
 	IntArray		arraylow;
 	IntArray		arrayhigh;
 	int				arraylen;
 
{ 
	Array node = New_Node(Array);
 
	RInitArray(node);
 
	set_arrayelemtype(node, arrayelemtype); 
	set_arrayelemlength(node, arrayelemlength); 
	set_arrayelembyval(node, arrayelembyval); 
	set_arrayndim(node, arrayndim); 
	set_arraylow(node, arraylow); 
	set_arrayhigh(node, arrayhigh); 
	set_arraylen(node, arraylen); 

	return(node);
}
 
/* ---------------- 
 *    Out function for Array 
 * ---------------- 
 */ 
extern void OutArray(); 
; 
void 
OutArray(str, node) 
	StringInfo str; 
	Array	node; 
{
	char buf[100]; 
#ifdef	OutArrayExists 

	appendStringInfo(str, "#S("); 
	_outArray(str, node); 
	appendStringInfo(str, ")"); 

#else	/* OutArrayExists */ 
	sprintf(buf, "#S(Array node at 0x%lx)", node);
 
	appendStringInfo(str, buf); 
#endif	/* OutArrayExists */ 
}
 
/* ---------------- 
 *    Equal function for Array 
 * ---------------- 
 */ 
extern bool EqualArray(); 
 
bool
EqualArray(a, b) 
	Array	a, b; 
{ 
#ifdef	EqualArrayExists 
	return ((bool) _equalArray(a, b)); 

#else	/* EqualArrayExists */ 
	printf("EqualArray does not exist!");
 
	return (false); 
#endif	/* EqualArrayExists */ 
}
 
/* ---------------- 
 *    Copy function for Array 
 * ---------------- 
 */ 
extern bool CopyArray(); 
 
bool
CopyArray(from, to, alloc) 
	Array	from; 
	Array	*to;	/* return */ 
	char *	(*alloc)(); 
{ 
#ifdef	CopyArrayExists 
	return ((bool) _copyArray(from, to, alloc)); 

#else	/* CopyArrayExists */ 
	printf("CopyArray does not exist!");
 
	return (false); 
#endif	/* CopyArrayExists */ 
}
 
/* ---------------- 
 *    IMakeArray - Inherited Make creator for Array 
 *  
 *    This creator function takes a parameter 
 *    for each slot in this class and each slot 
 *    in all inherited classes. 
 * ---------------- 
 */ 
extern Array IMakeArray(); 
 
Array
IMakeArray( arrayelemtype, arrayelemlength, arrayelembyval, arrayndim, arraylow, arrayhigh, arraylen)
  ObjectId arrayelemtype ;
  int arrayelemlength ;
  bool arrayelembyval ;
  int arrayndim ;
  IntArray arraylow ;
  IntArray arrayhigh ;
  int arraylen ;
 
{ 
	Array node = New_Node(Array);
 
	RInitArray(node);
 
	set_arrayelemtype(node, arrayelemtype); 
	set_arrayelemlength(node, arrayelemlength); 
	set_arrayelembyval(node, arrayelembyval); 
	set_arrayndim(node, arrayndim); 
	set_arraylow(node, arraylow); 
	set_arrayhigh(node, arrayhigh); 
	set_arraylen(node, arraylen); 

	return(node);
}
 
/* ---------------- 
 *    RMakeArray - Raw Make creator for Array 
 *  
 *    This creator function does not initialize 
 *    any of its slots..  This is left up to the 
 *    calling routine. 
 * ---------------- 
 */ 
extern Array RMakeArray(); 
 
Array
RMakeArray() 
{ 
	Array node = New_Node(Array);
 
	RInitArray(node); 

	return(node);
}
 
/* ---------------- 
 *    RInitArrayRef - Raw initializer for ArrayRef 
 *  
 *    This function just initializes the internal 
 *    information in a node.  
 * ---------------- 
 */ 
extern void RInitArrayRef(); 
 
void 
RInitArrayRef(p) 
Pointer p; 
{ 
	extern void OutArrayRef(); 
	extern bool EqualArrayRef(); 
	extern bool CopyArrayRef(); 

	ArrayRef node = (ArrayRef) p;
 
	node->type = classTag(ArrayRef); 
	node->outFunc = OutArrayRef; 
	node->equalFunc = EqualArrayRef; 
	node->copyFunc =  CopyArrayRef; 

	return;
}
 
/* ---------------- 
 *    Make creator function for ArrayRef 
 *  
 *    This function is in some sence "broken" because 
 *    it takes parameters for only this nodes slots and 
 *    leaves this nodes inherited slots uninitialized. 
 *  
 *    This is here for backward compatibility with code 
 *    that relies on this behaviour. 
 * ---------------- 
 */ 
extern ArrayRef MakeArrayRef(); 
 
ArrayRef
MakeArrayRef( refattrlength, refelemlength, refelemtype, refelembyval, refupperindexpr, reflowerindexpr, refexpr, refassgnexpr)
 	int			refattrlength;
 	int			refelemlength;
 	ObjectId		refelemtype;
 	bool			refelembyval;
 	LispValue		refupperindexpr;
 	LispValue		reflowerindexpr;
 	LispValue		refexpr;
 	LispValue		refassgnexpr;
 
{ 
	ArrayRef node = New_Node(ArrayRef);
 
	RInitArrayRef(node);
 
	set_refattrlength(node, refattrlength); 
	set_refelemlength(node, refelemlength); 
	set_refelemtype(node, refelemtype); 
	set_refelembyval(node, refelembyval); 
	set_refupperindexpr(node, refupperindexpr); 
	set_reflowerindexpr(node, reflowerindexpr); 
	set_refexpr(node, refexpr); 
	set_refassgnexpr(node, refassgnexpr); 

	return(node);
}
 
/* ---------------- 
 *    Out function for ArrayRef 
 * ---------------- 
 */ 
extern void OutArrayRef(); 
; 
void 
OutArrayRef(str, node) 
	StringInfo str; 
	ArrayRef	node; 
{
	char buf[100]; 
#ifdef	OutArrayRefExists 

	appendStringInfo(str, "#S("); 
	_outArrayRef(str, node); 
	appendStringInfo(str, ")"); 

#else	/* OutArrayRefExists */ 
	sprintf(buf, "#S(ArrayRef node at 0x%lx)", node);
 
	appendStringInfo(str, buf); 
#endif	/* OutArrayRefExists */ 
}
 
/* ---------------- 
 *    Equal function for ArrayRef 
 * ---------------- 
 */ 
extern bool EqualArrayRef(); 
 
bool
EqualArrayRef(a, b) 
	ArrayRef	a, b; 
{ 
#ifdef	EqualArrayRefExists 
	return ((bool) _equalArrayRef(a, b)); 

#else	/* EqualArrayRefExists */ 
	printf("EqualArrayRef does not exist!");
 
	return (false); 
#endif	/* EqualArrayRefExists */ 
}
 
/* ---------------- 
 *    Copy function for ArrayRef 
 * ---------------- 
 */ 
extern bool CopyArrayRef(); 
 
bool
CopyArrayRef(from, to, alloc) 
	ArrayRef	from; 
	ArrayRef	*to;	/* return */ 
	char *	(*alloc)(); 
{ 
#ifdef	CopyArrayRefExists 
	return ((bool) _copyArrayRef(from, to, alloc)); 

#else	/* CopyArrayRefExists */ 
	printf("CopyArrayRef does not exist!");
 
	return (false); 
#endif	/* CopyArrayRefExists */ 
}
 
/* ---------------- 
 *    IMakeArrayRef - Inherited Make creator for ArrayRef 
 *  
 *    This creator function takes a parameter 
 *    for each slot in this class and each slot 
 *    in all inherited classes. 
 * ---------------- 
 */ 
extern ArrayRef IMakeArrayRef(); 
 
ArrayRef
IMakeArrayRef( refattrlength, refelemlength, refelemtype, refelembyval, refupperindexpr, reflowerindexpr, refexpr, refassgnexpr)
  int refattrlength ;
  int refelemlength ;
  ObjectId refelemtype ;
  bool refelembyval ;
  LispValue refupperindexpr ;
  LispValue reflowerindexpr ;
  LispValue refexpr ;
  LispValue refassgnexpr ;
 
{ 
	ArrayRef node = New_Node(ArrayRef);
 
	RInitArrayRef(node);
 
	set_refattrlength(node, refattrlength); 
	set_refelemlength(node, refelemlength); 
	set_refelemtype(node, refelemtype); 
	set_refelembyval(node, refelembyval); 
	set_refupperindexpr(node, refupperindexpr); 
	set_reflowerindexpr(node, reflowerindexpr); 
	set_refexpr(node, refexpr); 
	set_refassgnexpr(node, refassgnexpr); 

	return(node);
}
 
/* ---------------- 
 *    RMakeArrayRef - Raw Make creator for ArrayRef 
 *  
 *    This creator function does not initialize 
 *    any of its slots..  This is left up to the 
 *    calling routine. 
 * ---------------- 
 */ 
extern ArrayRef RMakeArrayRef(); 
 
ArrayRef
RMakeArrayRef() 
{ 
	ArrayRef node = New_Node(ArrayRef);
 
	RInitArrayRef(node); 

	return(node);
}
 
/* end-of-file */