/* ---------------------------------------------------------------- 
 * 	node file generated from /usr/local/src/postgres/src/backend/nodes/relation.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/relation.h"
 
#ifdef NO_NODE_CHECKING
#define NODEAssertArg(x)
#else
#define NODEAssertArg(x)	AssertArg(x)
#endif NO_NODE_CHECKING
 

/* ---------------- 
 *    RInitRel - Raw initializer for Rel 
 *  
 *    This function just initializes the internal 
 *    information in a node.  
 * ---------------- 
 */ 
extern void RInitRel(); 
 
void 
RInitRel(p) 
Pointer p; 
{ 
	extern void OutRel(); 
	extern bool EqualRel(); 
	extern bool CopyRel(); 

	Rel node = (Rel) p;
 
	node->type = classTag(Rel); 
	node->outFunc = OutRel; 
	node->equalFunc = EqualRel; 
	node->copyFunc =  CopyRel; 

	return;
}
 
/* ---------------- 
 *    Make creator function for Rel 
 *  
 *    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 Rel MakeRel(); 
 
Rel
MakeRel( relids, indexed, pages, tuples, size, width, targetlist, pathlist, unorderedpath, cheapestpath, pruneable, classlist, indexkeys, indproc, indpred, ordering, clauseinfo, joininfo, innerjoin, superrels)
 	Relid	relids;
 	bool	indexed;
 	Count	pages;
 	Count	tuples;
 	Count	size;
 	Count	width;
 	List	targetlist;
 	List	pathlist;
 	PathPtr	unorderedpath;
 	PathPtr	cheapestpath;
 	bool    pruneable;
 	List	classlist;
 	List	indexkeys;
 	oid	indproc;
 	List	indpred;
 	List	ordering;
 	List	clauseinfo;
 	List	joininfo;
 	List	innerjoin;
 	List	superrels;
 
{ 
	Rel node = New_Node(Rel);
 
	RInitRel(node);
 
	set_relids(node, relids); 
	set_indexed(node, indexed); 
	set_pages(node, pages); 
	set_tuples(node, tuples); 
	set_size(node, size); 
	set_width(node, width); 
	set_targetlist(node, targetlist); 
	set_pathlist(node, pathlist); 
	set_unorderedpath(node, unorderedpath); 
	set_cheapestpath(node, cheapestpath); 
	set_pruneable(node, pruneable); 
	set_classlist(node, classlist); 
	set_indexkeys(node, indexkeys); 
	set_indproc(node, indproc); 
	set_indpred(node, indpred); 
	set_ordering(node, ordering); 
	set_clauseinfo(node, clauseinfo); 
	set_joininfo(node, joininfo); 
	set_innerjoin(node, innerjoin); 
	set_superrels(node, superrels); 

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

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

#else	/* OutRelExists */ 
	sprintf(buf, "#S(Rel node at 0x%lx)", node);
 
	appendStringInfo(str, buf); 
#endif	/* OutRelExists */ 
}
 
/* ---------------- 
 *    Equal function for Rel 
 * ---------------- 
 */ 
extern bool EqualRel(); 
 
bool
EqualRel(a, b) 
	Rel	a, b; 
{ 
#ifdef	EqualRelExists 
	return ((bool) _equalRel(a, b)); 

#else	/* EqualRelExists */ 
	printf("EqualRel does not exist!");
 
	return (false); 
#endif	/* EqualRelExists */ 
}
 
/* ---------------- 
 *    Copy function for Rel 
 * ---------------- 
 */ 
extern bool CopyRel(); 
 
bool
CopyRel(from, to, alloc) 
	Rel	from; 
	Rel	*to;	/* return */ 
	char *	(*alloc)(); 
{ 
#ifdef	CopyRelExists 
	return ((bool) _copyRel(from, to, alloc)); 

#else	/* CopyRelExists */ 
	printf("CopyRel does not exist!");
 
	return (false); 
#endif	/* CopyRelExists */ 
}
 
/* ---------------- 
 *    IMakeRel - Inherited Make creator for Rel 
 *  
 *    This creator function takes a parameter 
 *    for each slot in this class and each slot 
 *    in all inherited classes. 
 * ---------------- 
 */ 
extern Rel IMakeRel(); 
 
Rel
IMakeRel( relids, indexed, pages, tuples, size, width, targetlist, pathlist, unorderedpath, cheapestpath, pruneable, classlist, indexkeys, indproc, indpred, ordering, clauseinfo, joininfo, innerjoin, superrels)
  Relid relids ;
  bool indexed ;
  Count pages ;
  Count tuples ;
  Count size ;
  Count width ;
  List targetlist ;
  List pathlist ;
  PathPtr unorderedpath ;
  PathPtr cheapestpath ;
  bool pruneable ;
  List classlist ;
  List indexkeys ;
  oid indproc ;
  List indpred ;
  List ordering ;
  List clauseinfo ;
  List joininfo ;
  List innerjoin ;
  List superrels ;
 
{ 
	Rel node = New_Node(Rel);
 
	RInitRel(node);
 
	set_relids(node, relids); 
	set_indexed(node, indexed); 
	set_pages(node, pages); 
	set_tuples(node, tuples); 
	set_size(node, size); 
	set_width(node, width); 
	set_targetlist(node, targetlist); 
	set_pathlist(node, pathlist); 
	set_unorderedpath(node, unorderedpath); 
	set_cheapestpath(node, cheapestpath); 
	set_pruneable(node, pruneable); 
	set_classlist(node, classlist); 
	set_indexkeys(node, indexkeys); 
	set_indproc(node, indproc); 
	set_indpred(node, indpred); 
	set_ordering(node, ordering); 
	set_clauseinfo(node, clauseinfo); 
	set_joininfo(node, joininfo); 
	set_innerjoin(node, innerjoin); 
	set_superrels(node, superrels); 

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

	return(node);
}
 
/* ---------------- 
 *    RInitSortKey - Raw initializer for SortKey 
 *  
 *    This function just initializes the internal 
 *    information in a node.  
 * ---------------- 
 */ 
extern void RInitSortKey(); 
 
void 
RInitSortKey(p) 
Pointer p; 
{ 
	extern void OutSortKey(); 
	extern bool EqualSortKey(); 
	extern bool CopySortKey(); 

	SortKey node = (SortKey) p;
 
	node->type = classTag(SortKey); 
	node->outFunc = OutSortKey; 
	node->equalFunc = EqualSortKey; 
	node->copyFunc =  CopySortKey; 

	return;
}
 
/* ---------------- 
 *    Make creator function for SortKey 
 *  
 *    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 SortKey MakeSortKey(); 
 
SortKey
MakeSortKey( varkeys, sortkeys, relid, sortorder)
 	List		varkeys;
 	List		sortkeys;
 	Relid		relid;
 	List		sortorder;
 
{ 
	SortKey node = New_Node(SortKey);
 
	RInitSortKey(node);
 
	set_varkeys(node, varkeys); 
	set_sortkeys(node, sortkeys); 
	set_relid(node, relid); 
	set_sortorder(node, sortorder); 

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

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

#else	/* OutSortKeyExists */ 
	sprintf(buf, "#S(SortKey node at 0x%lx)", node);
 
	appendStringInfo(str, buf); 
#endif	/* OutSortKeyExists */ 
}
 
/* ---------------- 
 *    Equal function for SortKey 
 * ---------------- 
 */ 
extern bool EqualSortKey(); 
 
bool
EqualSortKey(a, b) 
	SortKey	a, b; 
{ 
#ifdef	EqualSortKeyExists 
	return ((bool) _equalSortKey(a, b)); 

#else	/* EqualSortKeyExists */ 
	printf("EqualSortKey does not exist!");
 
	return (false); 
#endif	/* EqualSortKeyExists */ 
}
 
/* ---------------- 
 *    Copy function for SortKey 
 * ---------------- 
 */ 
extern bool CopySortKey(); 
 
bool
CopySortKey(from, to, alloc) 
	SortKey	from; 
	SortKey	*to;	/* return */ 
	char *	(*alloc)(); 
{ 
#ifdef	CopySortKeyExists 
	return ((bool) _copySortKey(from, to, alloc)); 

#else	/* CopySortKeyExists */ 
	printf("CopySortKey does not exist!");
 
	return (false); 
#endif	/* CopySortKeyExists */ 
}
 
/* ---------------- 
 *    IMakeSortKey - Inherited Make creator for SortKey 
 *  
 *    This creator function takes a parameter 
 *    for each slot in this class and each slot 
 *    in all inherited classes. 
 * ---------------- 
 */ 
extern SortKey IMakeSortKey(); 
 
SortKey
IMakeSortKey( varkeys, sortkeys, relid, sortorder)
  List varkeys ;
  List sortkeys ;
  Relid relid ;
  List sortorder ;
 
{ 
	SortKey node = New_Node(SortKey);
 
	RInitSortKey(node);
 
	set_varkeys(node, varkeys); 
	set_sortkeys(node, sortkeys); 
	set_relid(node, relid); 
	set_sortorder(node, sortorder); 

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

	return(node);
}
 
/* ---------------- 
 *    RInitPath - Raw initializer for Path 
 *  
 *    This function just initializes the internal 
 *    information in a node.  
 * ---------------- 
 */ 
extern void RInitPath(); 
 
void 
RInitPath(p) 
Pointer p; 
{ 
	extern void OutPath(); 
	extern bool EqualPath(); 
	extern bool CopyPath(); 

	Path node = (Path) p;
 
	node->type = classTag(Path); 
	node->outFunc = OutPath; 
	node->equalFunc = EqualPath; 
	node->copyFunc =  CopyPath; 

	return;
}
 
/* ---------------- 
 *    Make creator function for Path 
 *  
 *    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 Path MakePath(); 
 
Path
MakePath( pathtype, parent, path_cost, p_ordering, keys, pathsortkey, outerjoincost, joinid, locclauseinfo)
 	int32		pathtype ;
 	Rel		parent ;
 	Cost		path_cost ;
 	List		p_ordering ;
 	List		keys ;
 	SortKey		pathsortkey ;
 	Cost		outerjoincost ;
 	Relid		joinid ;
 	List            locclauseinfo;
 
{ 
	Path node = New_Node(Path);
 
	RInitPath(node);
 
	set_pathtype(node, pathtype); 
	set_parent(node, parent); 
	set_path_cost(node, path_cost); 
	set_p_ordering(node, p_ordering); 
	set_keys(node, keys); 
	set_pathsortkey(node, pathsortkey); 
	set_outerjoincost(node, outerjoincost); 
	set_joinid(node, joinid); 
	set_locclauseinfo(node, locclauseinfo); 

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

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

#else	/* OutPathExists */ 
	sprintf(buf, "#S(Path node at 0x%lx)", node);
 
	appendStringInfo(str, buf); 
#endif	/* OutPathExists */ 
}
 
/* ---------------- 
 *    Equal function for Path 
 * ---------------- 
 */ 
extern bool EqualPath(); 
 
bool
EqualPath(a, b) 
	Path	a, b; 
{ 
#ifdef	EqualPathExists 
	return ((bool) _equalPath(a, b)); 

#else	/* EqualPathExists */ 
	printf("EqualPath does not exist!");
 
	return (false); 
#endif	/* EqualPathExists */ 
}
 
/* ---------------- 
 *    Copy function for Path 
 * ---------------- 
 */ 
extern bool CopyPath(); 
 
bool
CopyPath(from, to, alloc) 
	Path	from; 
	Path	*to;	/* return */ 
	char *	(*alloc)(); 
{ 
#ifdef	CopyPathExists 
	return ((bool) _copyPath(from, to, alloc)); 

#else	/* CopyPathExists */ 
	printf("CopyPath does not exist!");
 
	return (false); 
#endif	/* CopyPathExists */ 
}
 
/* ---------------- 
 *    IMakePath - Inherited Make creator for Path 
 *  
 *    This creator function takes a parameter 
 *    for each slot in this class and each slot 
 *    in all inherited classes. 
 * ---------------- 
 */ 
extern Path IMakePath(); 
 
Path
IMakePath( pathtype, parent, path_cost, p_ordering, keys, pathsortkey, outerjoincost, joinid, locclauseinfo)
  int32 pathtype  ;
  Rel parent  ;
  Cost path_cost  ;
  List p_ordering  ;
  List keys  ;
  SortKey pathsortkey  ;
  Cost outerjoincost  ;
  Relid joinid  ;
  List locclauseinfo ;
 
{ 
	Path node = New_Node(Path);
 
	RInitPath(node);
 
	set_pathtype(node, pathtype); 
	set_parent(node, parent); 
	set_path_cost(node, path_cost); 
	set_p_ordering(node, p_ordering); 
	set_keys(node, keys); 
	set_pathsortkey(node, pathsortkey); 
	set_outerjoincost(node, outerjoincost); 
	set_joinid(node, joinid); 
	set_locclauseinfo(node, locclauseinfo); 

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

	return(node);
}
 
/* ---------------- 
 *    RInitIndexPath - Raw initializer for IndexPath 
 *  
 *    This function just initializes the internal 
 *    information in a node.  
 * ---------------- 
 */ 
extern void RInitIndexPath(); 
 
void 
RInitIndexPath(p) 
Pointer p; 
{ 
	extern void OutIndexPath(); 
	extern bool EqualIndexPath(); 
	extern bool CopyIndexPath(); 

	IndexPath node = (IndexPath) p;
 
	node->type = classTag(IndexPath); 
	node->outFunc = OutIndexPath; 
	node->equalFunc = EqualIndexPath; 
	node->copyFunc =  CopyIndexPath; 

	return;
}
 
/* ---------------- 
 *    Make creator function for IndexPath 
 *  
 *    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 IndexPath MakeIndexPath(); 
 
IndexPath
MakeIndexPath( indexid, indexqual)
 	List		indexid;
 	List		indexqual;
 
{ 
	IndexPath node = New_Node(IndexPath);
 
	RInitIndexPath(node);
 
	set_indexid(node, indexid); 
	set_indexqual(node, indexqual); 

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

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

#else	/* OutIndexPathExists */ 
	sprintf(buf, "#S(IndexPath node at 0x%lx)", node);
 
	appendStringInfo(str, buf); 
#endif	/* OutIndexPathExists */ 
}
 
/* ---------------- 
 *    Equal function for IndexPath 
 * ---------------- 
 */ 
extern bool EqualIndexPath(); 
 
bool
EqualIndexPath(a, b) 
	IndexPath	a, b; 
{ 
#ifdef	EqualIndexPathExists 
	return ((bool) _equalIndexPath(a, b)); 

#else	/* EqualIndexPathExists */ 
	printf("EqualIndexPath does not exist!");
 
	return (false); 
#endif	/* EqualIndexPathExists */ 
}
 
/* ---------------- 
 *    Copy function for IndexPath 
 * ---------------- 
 */ 
extern bool CopyIndexPath(); 
 
bool
CopyIndexPath(from, to, alloc) 
	IndexPath	from; 
	IndexPath	*to;	/* return */ 
	char *	(*alloc)(); 
{ 
#ifdef	CopyIndexPathExists 
	return ((bool) _copyIndexPath(from, to, alloc)); 

#else	/* CopyIndexPathExists */ 
	printf("CopyIndexPath does not exist!");
 
	return (false); 
#endif	/* CopyIndexPathExists */ 
}
 
/* ---------------- 
 *    IMakeIndexPath - Inherited Make creator for IndexPath 
 *  
 *    This creator function takes a parameter 
 *    for each slot in this class and each slot 
 *    in all inherited classes. 
 * ---------------- 
 */ 
extern IndexPath IMakeIndexPath(); 
 
IndexPath
IMakeIndexPath( indexid, indexqual)
  List indexid ;
  List indexqual ;
 
{ 
	IndexPath node = New_Node(IndexPath);
 
	RInitIndexPath(node);
 
	set_indexid(node, indexid); 
	set_indexqual(node, indexqual); 

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

	return(node);
}
 
/* ---------------- 
 *    RInitJoinPath - Raw initializer for JoinPath 
 *  
 *    This function just initializes the internal 
 *    information in a node.  
 * ---------------- 
 */ 
extern void RInitJoinPath(); 
 
void 
RInitJoinPath(p) 
Pointer p; 
{ 
	extern void OutJoinPath(); 
	extern bool EqualJoinPath(); 
	extern bool CopyJoinPath(); 

	JoinPath node = (JoinPath) p;
 
	node->type = classTag(JoinPath); 
	node->outFunc = OutJoinPath; 
	node->equalFunc = EqualJoinPath; 
	node->copyFunc =  CopyJoinPath; 

	return;
}
 
/* ---------------- 
 *    Make creator function for JoinPath 
 *  
 *    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 JoinPath MakeJoinPath(); 
 
JoinPath
MakeJoinPath( pathclauseinfo, outerjoinpath, innerjoinpath)
 	List		pathclauseinfo ;
 	pathPtr	outerjoinpath ;
 	pathPtr	innerjoinpath;
 
{ 
	JoinPath node = New_Node(JoinPath);
 
	RInitJoinPath(node);
 
	set_pathclauseinfo(node, pathclauseinfo); 
	set_outerjoinpath(node, outerjoinpath); 
	set_innerjoinpath(node, innerjoinpath); 

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

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

#else	/* OutJoinPathExists */ 
	sprintf(buf, "#S(JoinPath node at 0x%lx)", node);
 
	appendStringInfo(str, buf); 
#endif	/* OutJoinPathExists */ 
}
 
/* ---------------- 
 *    Equal function for JoinPath 
 * ---------------- 
 */ 
extern bool EqualJoinPath(); 
 
bool
EqualJoinPath(a, b) 
	JoinPath	a, b; 
{ 
#ifdef	EqualJoinPathExists 
	return ((bool) _equalJoinPath(a, b)); 

#else	/* EqualJoinPathExists */ 
	printf("EqualJoinPath does not exist!");
 
	return (false); 
#endif	/* EqualJoinPathExists */ 
}
 
/* ---------------- 
 *    Copy function for JoinPath 
 * ---------------- 
 */ 
extern bool CopyJoinPath(); 
 
bool
CopyJoinPath(from, to, alloc) 
	JoinPath	from; 
	JoinPath	*to;	/* return */ 
	char *	(*alloc)(); 
{ 
#ifdef	CopyJoinPathExists 
	return ((bool) _copyJoinPath(from, to, alloc)); 

#else	/* CopyJoinPathExists */ 
	printf("CopyJoinPath does not exist!");
 
	return (false); 
#endif	/* CopyJoinPathExists */ 
}
 
/* ---------------- 
 *    IMakeJoinPath - Inherited Make creator for JoinPath 
 *  
 *    This creator function takes a parameter 
 *    for each slot in this class and each slot 
 *    in all inherited classes. 
 * ---------------- 
 */ 
extern JoinPath IMakeJoinPath(); 
 
JoinPath
IMakeJoinPath( pathclauseinfo, outerjoinpath, innerjoinpath)
  List pathclauseinfo  ;
  pathPtr outerjoinpath  ;
  pathPtr innerjoinpath ;
 
{ 
	JoinPath node = New_Node(JoinPath);
 
	RInitJoinPath(node);
 
	set_pathclauseinfo(node, pathclauseinfo); 
	set_outerjoinpath(node, outerjoinpath); 
	set_innerjoinpath(node, innerjoinpath); 

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

	return(node);
}
 
/* ---------------- 
 *    RInitMergePath - Raw initializer for MergePath 
 *  
 *    This function just initializes the internal 
 *    information in a node.  
 * ---------------- 
 */ 
extern void RInitMergePath(); 
 
void 
RInitMergePath(p) 
Pointer p; 
{ 
	extern void OutMergePath(); 
	extern bool EqualMergePath(); 
	extern bool CopyMergePath(); 

	MergePath node = (MergePath) p;
 
	node->type = classTag(MergePath); 
	node->outFunc = OutMergePath; 
	node->equalFunc = EqualMergePath; 
	node->copyFunc =  CopyMergePath; 

	return;
}
 
/* ---------------- 
 *    Make creator function for MergePath 
 *  
 *    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 MergePath MakeMergePath(); 
 
MergePath
MakeMergePath( path_mergeclauses, outersortkeys, innersortkeys)
 	List		path_mergeclauses;
 	List		outersortkeys;
 	List		innersortkeys;
 
{ 
	MergePath node = New_Node(MergePath);
 
	RInitMergePath(node);
 
	set_path_mergeclauses(node, path_mergeclauses); 
	set_outersortkeys(node, outersortkeys); 
	set_innersortkeys(node, innersortkeys); 

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

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

#else	/* OutMergePathExists */ 
	sprintf(buf, "#S(MergePath node at 0x%lx)", node);
 
	appendStringInfo(str, buf); 
#endif	/* OutMergePathExists */ 
}
 
/* ---------------- 
 *    Equal function for MergePath 
 * ---------------- 
 */ 
extern bool EqualMergePath(); 
 
bool
EqualMergePath(a, b) 
	MergePath	a, b; 
{ 
#ifdef	EqualMergePathExists 
	return ((bool) _equalMergePath(a, b)); 

#else	/* EqualMergePathExists */ 
	printf("EqualMergePath does not exist!");
 
	return (false); 
#endif	/* EqualMergePathExists */ 
}
 
/* ---------------- 
 *    Copy function for MergePath 
 * ---------------- 
 */ 
extern bool CopyMergePath(); 
 
bool
CopyMergePath(from, to, alloc) 
	MergePath	from; 
	MergePath	*to;	/* return */ 
	char *	(*alloc)(); 
{ 
#ifdef	CopyMergePathExists 
	return ((bool) _copyMergePath(from, to, alloc)); 

#else	/* CopyMergePathExists */ 
	printf("CopyMergePath does not exist!");
 
	return (false); 
#endif	/* CopyMergePathExists */ 
}
 
/* ---------------- 
 *    IMakeMergePath - Inherited Make creator for MergePath 
 *  
 *    This creator function takes a parameter 
 *    for each slot in this class and each slot 
 *    in all inherited classes. 
 * ---------------- 
 */ 
extern MergePath IMakeMergePath(); 
 
MergePath
IMakeMergePath( path_mergeclauses, outersortkeys, innersortkeys)
  List path_mergeclauses ;
  List outersortkeys ;
  List innersortkeys ;
 
{ 
	MergePath node = New_Node(MergePath);
 
	RInitMergePath(node);
 
	set_path_mergeclauses(node, path_mergeclauses); 
	set_outersortkeys(node, outersortkeys); 
	set_innersortkeys(node, innersortkeys); 

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

	return(node);
}
 
/* ---------------- 
 *    RInitHashPath - Raw initializer for HashPath 
 *  
 *    This function just initializes the internal 
 *    information in a node.  
 * ---------------- 
 */ 
extern void RInitHashPath(); 
 
void 
RInitHashPath(p) 
Pointer p; 
{ 
	extern void OutHashPath(); 
	extern bool EqualHashPath(); 
	extern bool CopyHashPath(); 

	HashPath node = (HashPath) p;
 
	node->type = classTag(HashPath); 
	node->outFunc = OutHashPath; 
	node->equalFunc = EqualHashPath; 
	node->copyFunc =  CopyHashPath; 

	return;
}
 
/* ---------------- 
 *    Make creator function for HashPath 
 *  
 *    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 HashPath MakeHashPath(); 
 
HashPath
MakeHashPath( path_hashclauses, outerhashkeys, innerhashkeys)
 	List		path_hashclauses;
 	List		outerhashkeys;
 	List		innerhashkeys;
 
{ 
	HashPath node = New_Node(HashPath);
 
	RInitHashPath(node);
 
	set_path_hashclauses(node, path_hashclauses); 
	set_outerhashkeys(node, outerhashkeys); 
	set_innerhashkeys(node, innerhashkeys); 

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

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

#else	/* OutHashPathExists */ 
	sprintf(buf, "#S(HashPath node at 0x%lx)", node);
 
	appendStringInfo(str, buf); 
#endif	/* OutHashPathExists */ 
}
 
/* ---------------- 
 *    Equal function for HashPath 
 * ---------------- 
 */ 
extern bool EqualHashPath(); 
 
bool
EqualHashPath(a, b) 
	HashPath	a, b; 
{ 
#ifdef	EqualHashPathExists 
	return ((bool) _equalHashPath(a, b)); 

#else	/* EqualHashPathExists */ 
	printf("EqualHashPath does not exist!");
 
	return (false); 
#endif	/* EqualHashPathExists */ 
}
 
/* ---------------- 
 *    Copy function for HashPath 
 * ---------------- 
 */ 
extern bool CopyHashPath(); 
 
bool
CopyHashPath(from, to, alloc) 
	HashPath	from; 
	HashPath	*to;	/* return */ 
	char *	(*alloc)(); 
{ 
#ifdef	CopyHashPathExists 
	return ((bool) _copyHashPath(from, to, alloc)); 

#else	/* CopyHashPathExists */ 
	printf("CopyHashPath does not exist!");
 
	return (false); 
#endif	/* CopyHashPathExists */ 
}
 
/* ---------------- 
 *    IMakeHashPath - Inherited Make creator for HashPath 
 *  
 *    This creator function takes a parameter 
 *    for each slot in this class and each slot 
 *    in all inherited classes. 
 * ---------------- 
 */ 
extern HashPath IMakeHashPath(); 
 
HashPath
IMakeHashPath( path_hashclauses, outerhashkeys, innerhashkeys)
  List path_hashclauses ;
  List outerhashkeys ;
  List innerhashkeys ;
 
{ 
	HashPath node = New_Node(HashPath);
 
	RInitHashPath(node);
 
	set_path_hashclauses(node, path_hashclauses); 
	set_outerhashkeys(node, outerhashkeys); 
	set_innerhashkeys(node, innerhashkeys); 

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

	return(node);
}
 
/* ---------------- 
 *    RInitOrderKey - Raw initializer for OrderKey 
 *  
 *    This function just initializes the internal 
 *    information in a node.  
 * ---------------- 
 */ 
extern void RInitOrderKey(); 
 
void 
RInitOrderKey(p) 
Pointer p; 
{ 
	extern void OutOrderKey(); 
	extern bool EqualOrderKey(); 
	extern bool CopyOrderKey(); 

	OrderKey node = (OrderKey) p;
 
	node->type = classTag(OrderKey); 
	node->outFunc = OutOrderKey; 
	node->equalFunc = EqualOrderKey; 
	node->copyFunc =  CopyOrderKey; 

	return;
}
 
/* ---------------- 
 *    Make creator function for OrderKey 
 *  
 *    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 OrderKey MakeOrderKey(); 
 
OrderKey
MakeOrderKey( attribute_number, array_index)
 	int 	attribute_number;
 	Index	array_index;
 
{ 
	OrderKey node = New_Node(OrderKey);
 
	RInitOrderKey(node);
 
	set_attribute_number(node, attribute_number); 
	set_array_index(node, array_index); 

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

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

#else	/* OutOrderKeyExists */ 
	sprintf(buf, "#S(OrderKey node at 0x%lx)", node);
 
	appendStringInfo(str, buf); 
#endif	/* OutOrderKeyExists */ 
}
 
/* ---------------- 
 *    Equal function for OrderKey 
 * ---------------- 
 */ 
extern bool EqualOrderKey(); 
 
bool
EqualOrderKey(a, b) 
	OrderKey	a, b; 
{ 
#ifdef	EqualOrderKeyExists 
	return ((bool) _equalOrderKey(a, b)); 

#else	/* EqualOrderKeyExists */ 
	printf("EqualOrderKey does not exist!");
 
	return (false); 
#endif	/* EqualOrderKeyExists */ 
}
 
/* ---------------- 
 *    Copy function for OrderKey 
 * ---------------- 
 */ 
extern bool CopyOrderKey(); 
 
bool
CopyOrderKey(from, to, alloc) 
	OrderKey	from; 
	OrderKey	*to;	/* return */ 
	char *	(*alloc)(); 
{ 
#ifdef	CopyOrderKeyExists 
	return ((bool) _copyOrderKey(from, to, alloc)); 

#else	/* CopyOrderKeyExists */ 
	printf("CopyOrderKey does not exist!");
 
	return (false); 
#endif	/* CopyOrderKeyExists */ 
}
 
/* ---------------- 
 *    IMakeOrderKey - Inherited Make creator for OrderKey 
 *  
 *    This creator function takes a parameter 
 *    for each slot in this class and each slot 
 *    in all inherited classes. 
 * ---------------- 
 */ 
extern OrderKey IMakeOrderKey(); 
 
OrderKey
IMakeOrderKey( attribute_number, array_index)
  int attribute_number ;
  Index array_index ;
 
{ 
	OrderKey node = New_Node(OrderKey);
 
	RInitOrderKey(node);
 
	set_attribute_number(node, attribute_number); 
	set_array_index(node, array_index); 

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

	return(node);
}
 
/* ---------------- 
 *    RInitJoinKey - Raw initializer for JoinKey 
 *  
 *    This function just initializes the internal 
 *    information in a node.  
 * ---------------- 
 */ 
extern void RInitJoinKey(); 
 
void 
RInitJoinKey(p) 
Pointer p; 
{ 
	extern void OutJoinKey(); 
	extern bool EqualJoinKey(); 
	extern bool CopyJoinKey(); 

	JoinKey node = (JoinKey) p;
 
	node->type = classTag(JoinKey); 
	node->outFunc = OutJoinKey; 
	node->equalFunc = EqualJoinKey; 
	node->copyFunc =  CopyJoinKey; 

	return;
}
 
/* ---------------- 
 *    Make creator function for JoinKey 
 *  
 *    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 JoinKey MakeJoinKey(); 
 
JoinKey
MakeJoinKey( outer, inner)
 	LispValue outer;
 	LispValue  inner;
 
{ 
	JoinKey node = New_Node(JoinKey);
 
	RInitJoinKey(node);
 
	set_outer(node, outer); 
	set_inner(node, inner); 

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

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

#else	/* OutJoinKeyExists */ 
	sprintf(buf, "#S(JoinKey node at 0x%lx)", node);
 
	appendStringInfo(str, buf); 
#endif	/* OutJoinKeyExists */ 
}
 
/* ---------------- 
 *    Equal function for JoinKey 
 * ---------------- 
 */ 
extern bool EqualJoinKey(); 
 
bool
EqualJoinKey(a, b) 
	JoinKey	a, b; 
{ 
#ifdef	EqualJoinKeyExists 
	return ((bool) _equalJoinKey(a, b)); 

#else	/* EqualJoinKeyExists */ 
	printf("EqualJoinKey does not exist!");
 
	return (false); 
#endif	/* EqualJoinKeyExists */ 
}
 
/* ---------------- 
 *    Copy function for JoinKey 
 * ---------------- 
 */ 
extern bool CopyJoinKey(); 
 
bool
CopyJoinKey(from, to, alloc) 
	JoinKey	from; 
	JoinKey	*to;	/* return */ 
	char *	(*alloc)(); 
{ 
#ifdef	CopyJoinKeyExists 
	return ((bool) _copyJoinKey(from, to, alloc)); 

#else	/* CopyJoinKeyExists */ 
	printf("CopyJoinKey does not exist!");
 
	return (false); 
#endif	/* CopyJoinKeyExists */ 
}
 
/* ---------------- 
 *    IMakeJoinKey - Inherited Make creator for JoinKey 
 *  
 *    This creator function takes a parameter 
 *    for each slot in this class and each slot 
 *    in all inherited classes. 
 * ---------------- 
 */ 
extern JoinKey IMakeJoinKey(); 
 
JoinKey
IMakeJoinKey( outer, inner)
  LispValue outer ;
  LispValue inner ;
 
{ 
	JoinKey node = New_Node(JoinKey);
 
	RInitJoinKey(node);
 
	set_outer(node, outer); 
	set_inner(node, inner); 

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

	return(node);
}
 
/* ---------------- 
 *    RInitMergeOrder - Raw initializer for MergeOrder 
 *  
 *    This function just initializes the internal 
 *    information in a node.  
 * ---------------- 
 */ 
extern void RInitMergeOrder(); 
 
void 
RInitMergeOrder(p) 
Pointer p; 
{ 
	extern void OutMergeOrder(); 
	extern bool EqualMergeOrder(); 
	extern bool CopyMergeOrder(); 

	MergeOrder node = (MergeOrder) p;
 
	node->type = classTag(MergeOrder); 
	node->outFunc = OutMergeOrder; 
	node->equalFunc = EqualMergeOrder; 
	node->copyFunc =  CopyMergeOrder; 

	return;
}
 
/* ---------------- 
 *    Make creator function for MergeOrder 
 *  
 *    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 MergeOrder MakeMergeOrder(); 
 
MergeOrder
MakeMergeOrder( join_operator, left_operator, right_operator, left_type, right_type)
 	ObjectId join_operator;
 	ObjectId left_operator;
 	ObjectId right_operator;
 	ObjectId left_type;
 	ObjectId right_type;
 
{ 
	MergeOrder node = New_Node(MergeOrder);
 
	RInitMergeOrder(node);
 
	set_join_operator(node, join_operator); 
	set_left_operator(node, left_operator); 
	set_right_operator(node, right_operator); 
	set_left_type(node, left_type); 
	set_right_type(node, right_type); 

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

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

#else	/* OutMergeOrderExists */ 
	sprintf(buf, "#S(MergeOrder node at 0x%lx)", node);
 
	appendStringInfo(str, buf); 
#endif	/* OutMergeOrderExists */ 
}
 
/* ---------------- 
 *    Equal function for MergeOrder 
 * ---------------- 
 */ 
extern bool EqualMergeOrder(); 
 
bool
EqualMergeOrder(a, b) 
	MergeOrder	a, b; 
{ 
#ifdef	EqualMergeOrderExists 
	return ((bool) _equalMergeOrder(a, b)); 

#else	/* EqualMergeOrderExists */ 
	printf("EqualMergeOrder does not exist!");
 
	return (false); 
#endif	/* EqualMergeOrderExists */ 
}
 
/* ---------------- 
 *    Copy function for MergeOrder 
 * ---------------- 
 */ 
extern bool CopyMergeOrder(); 
 
bool
CopyMergeOrder(from, to, alloc) 
	MergeOrder	from; 
	MergeOrder	*to;	/* return */ 
	char *	(*alloc)(); 
{ 
#ifdef	CopyMergeOrderExists 
	return ((bool) _copyMergeOrder(from, to, alloc)); 

#else	/* CopyMergeOrderExists */ 
	printf("CopyMergeOrder does not exist!");
 
	return (false); 
#endif	/* CopyMergeOrderExists */ 
}
 
/* ---------------- 
 *    IMakeMergeOrder - Inherited Make creator for MergeOrder 
 *  
 *    This creator function takes a parameter 
 *    for each slot in this class and each slot 
 *    in all inherited classes. 
 * ---------------- 
 */ 
extern MergeOrder IMakeMergeOrder(); 
 
MergeOrder
IMakeMergeOrder( join_operator, left_operator, right_operator, left_type, right_type)
  ObjectId join_operator ;
  ObjectId left_operator ;
  ObjectId right_operator ;
  ObjectId left_type ;
  ObjectId right_type ;
 
{ 
	MergeOrder node = New_Node(MergeOrder);
 
	RInitMergeOrder(node);
 
	set_join_operator(node, join_operator); 
	set_left_operator(node, left_operator); 
	set_right_operator(node, right_operator); 
	set_left_type(node, left_type); 
	set_right_type(node, right_type); 

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

	return(node);
}
 
/* ---------------- 
 *    RInitCInfo - Raw initializer for CInfo 
 *  
 *    This function just initializes the internal 
 *    information in a node.  
 * ---------------- 
 */ 
extern void RInitCInfo(); 
 
void 
RInitCInfo(p) 
Pointer p; 
{ 
	extern void OutCInfo(); 
	extern bool EqualCInfo(); 
	extern bool CopyCInfo(); 

	CInfo node = (CInfo) p;
 
	node->type = classTag(CInfo); 
	node->outFunc = OutCInfo; 
	node->equalFunc = EqualCInfo; 
	node->copyFunc =  CopyCInfo; 

	return;
}
 
/* ---------------- 
 *    Make creator function for CInfo 
 *  
 *    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 CInfo MakeCInfo(); 
 
CInfo
MakeCInfo( clause, selectivity, notclause, indexids, mergesortorder, hashjoinoperator, cinfojoinid)
 	LispValue	clause;
 	Cost		selectivity;
 	bool		notclause;
 	List		indexids;
 	MergeOrder	mergesortorder;
 	ObjectId	hashjoinoperator;
 	Relid		cinfojoinid;
 
{ 
	CInfo node = New_Node(CInfo);
 
	RInitCInfo(node);
 
	set_clause(node, clause); 
	set_selectivity(node, selectivity); 
	set_notclause(node, notclause); 
	set_indexids(node, indexids); 
	set_mergesortorder(node, mergesortorder); 
	set_hashjoinoperator(node, hashjoinoperator); 
	set_cinfojoinid(node, cinfojoinid); 

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

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

#else	/* OutCInfoExists */ 
	sprintf(buf, "#S(CInfo node at 0x%lx)", node);
 
	appendStringInfo(str, buf); 
#endif	/* OutCInfoExists */ 
}
 
/* ---------------- 
 *    Equal function for CInfo 
 * ---------------- 
 */ 
extern bool EqualCInfo(); 
 
bool
EqualCInfo(a, b) 
	CInfo	a, b; 
{ 
#ifdef	EqualCInfoExists 
	return ((bool) _equalCInfo(a, b)); 

#else	/* EqualCInfoExists */ 
	printf("EqualCInfo does not exist!");
 
	return (false); 
#endif	/* EqualCInfoExists */ 
}
 
/* ---------------- 
 *    Copy function for CInfo 
 * ---------------- 
 */ 
extern bool CopyCInfo(); 
 
bool
CopyCInfo(from, to, alloc) 
	CInfo	from; 
	CInfo	*to;	/* return */ 
	char *	(*alloc)(); 
{ 
#ifdef	CopyCInfoExists 
	return ((bool) _copyCInfo(from, to, alloc)); 

#else	/* CopyCInfoExists */ 
	printf("CopyCInfo does not exist!");
 
	return (false); 
#endif	/* CopyCInfoExists */ 
}
 
/* ---------------- 
 *    IMakeCInfo - Inherited Make creator for CInfo 
 *  
 *    This creator function takes a parameter 
 *    for each slot in this class and each slot 
 *    in all inherited classes. 
 * ---------------- 
 */ 
extern CInfo IMakeCInfo(); 
 
CInfo
IMakeCInfo( clause, selectivity, notclause, indexids, mergesortorder, hashjoinoperator, cinfojoinid)
  LispValue clause ;
  Cost selectivity ;
  bool notclause ;
  List indexids ;
  MergeOrder mergesortorder ;
  ObjectId hashjoinoperator ;
  Relid cinfojoinid ;
 
{ 
	CInfo node = New_Node(CInfo);
 
	RInitCInfo(node);
 
	set_clause(node, clause); 
	set_selectivity(node, selectivity); 
	set_notclause(node, notclause); 
	set_indexids(node, indexids); 
	set_mergesortorder(node, mergesortorder); 
	set_hashjoinoperator(node, hashjoinoperator); 
	set_cinfojoinid(node, cinfojoinid); 

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

	return(node);
}
 
/* ---------------- 
 *    RInitJoinMethod - Raw initializer for JoinMethod 
 *  
 *    This function just initializes the internal 
 *    information in a node.  
 * ---------------- 
 */ 
extern void RInitJoinMethod(); 
 
void 
RInitJoinMethod(p) 
Pointer p; 
{ 
	extern void OutJoinMethod(); 
	extern bool EqualJoinMethod(); 
	extern bool CopyJoinMethod(); 

	JoinMethod node = (JoinMethod) p;
 
	node->type = classTag(JoinMethod); 
	node->outFunc = OutJoinMethod; 
	node->equalFunc = EqualJoinMethod; 
	node->copyFunc =  CopyJoinMethod; 

	return;
}
 
/* ---------------- 
 *    Make creator function for JoinMethod 
 *  
 *    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 JoinMethod MakeJoinMethod(); 
 
JoinMethod
MakeJoinMethod( jmkeys, clauses)
 	List            jmkeys ;
 	List            clauses;
 
{ 
	JoinMethod node = New_Node(JoinMethod);
 
	RInitJoinMethod(node);
 
	set_jmkeys(node, jmkeys); 
	set_clauses(node, clauses); 

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

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

#else	/* OutJoinMethodExists */ 
	sprintf(buf, "#S(JoinMethod node at 0x%lx)", node);
 
	appendStringInfo(str, buf); 
#endif	/* OutJoinMethodExists */ 
}
 
/* ---------------- 
 *    Equal function for JoinMethod 
 * ---------------- 
 */ 
extern bool EqualJoinMethod(); 
 
bool
EqualJoinMethod(a, b) 
	JoinMethod	a, b; 
{ 
#ifdef	EqualJoinMethodExists 
	return ((bool) _equalJoinMethod(a, b)); 

#else	/* EqualJoinMethodExists */ 
	printf("EqualJoinMethod does not exist!");
 
	return (false); 
#endif	/* EqualJoinMethodExists */ 
}
 
/* ---------------- 
 *    Copy function for JoinMethod 
 * ---------------- 
 */ 
extern bool CopyJoinMethod(); 
 
bool
CopyJoinMethod(from, to, alloc) 
	JoinMethod	from; 
	JoinMethod	*to;	/* return */ 
	char *	(*alloc)(); 
{ 
#ifdef	CopyJoinMethodExists 
	return ((bool) _copyJoinMethod(from, to, alloc)); 

#else	/* CopyJoinMethodExists */ 
	printf("CopyJoinMethod does not exist!");
 
	return (false); 
#endif	/* CopyJoinMethodExists */ 
}
 
/* ---------------- 
 *    IMakeJoinMethod - Inherited Make creator for JoinMethod 
 *  
 *    This creator function takes a parameter 
 *    for each slot in this class and each slot 
 *    in all inherited classes. 
 * ---------------- 
 */ 
extern JoinMethod IMakeJoinMethod(); 
 
JoinMethod
IMakeJoinMethod( jmkeys, clauses)
  List jmkeys  ;
  List clauses ;
 
{ 
	JoinMethod node = New_Node(JoinMethod);
 
	RInitJoinMethod(node);
 
	set_jmkeys(node, jmkeys); 
	set_clauses(node, clauses); 

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

	return(node);
}
 
/* ---------------- 
 *    RInitHInfo - Raw initializer for HInfo 
 *  
 *    This function just initializes the internal 
 *    information in a node.  
 * ---------------- 
 */ 
extern void RInitHInfo(); 
 
void 
RInitHInfo(p) 
Pointer p; 
{ 
	extern void OutHInfo(); 
	extern bool EqualHInfo(); 
	extern bool CopyHInfo(); 

	HInfo node = (HInfo) p;
 
	node->type = classTag(HInfo); 
	node->outFunc = OutHInfo; 
	node->equalFunc = EqualHInfo; 
	node->copyFunc =  CopyHInfo; 

	return;
}
 
/* ---------------- 
 *    Make creator function for HInfo 
 *  
 *    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 HInfo MakeHInfo(); 
 
HInfo
MakeHInfo( hashop)
 	ObjectId        hashop;
 
{ 
	HInfo node = New_Node(HInfo);
 
	RInitHInfo(node);
 
	set_hashop(node, hashop); 

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

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

#else	/* OutHInfoExists */ 
	sprintf(buf, "#S(HInfo node at 0x%lx)", node);
 
	appendStringInfo(str, buf); 
#endif	/* OutHInfoExists */ 
}
 
/* ---------------- 
 *    Equal function for HInfo 
 * ---------------- 
 */ 
extern bool EqualHInfo(); 
 
bool
EqualHInfo(a, b) 
	HInfo	a, b; 
{ 
#ifdef	EqualHInfoExists 
	return ((bool) _equalHInfo(a, b)); 

#else	/* EqualHInfoExists */ 
	printf("EqualHInfo does not exist!");
 
	return (false); 
#endif	/* EqualHInfoExists */ 
}
 
/* ---------------- 
 *    Copy function for HInfo 
 * ---------------- 
 */ 
extern bool CopyHInfo(); 
 
bool
CopyHInfo(from, to, alloc) 
	HInfo	from; 
	HInfo	*to;	/* return */ 
	char *	(*alloc)(); 
{ 
#ifdef	CopyHInfoExists 
	return ((bool) _copyHInfo(from, to, alloc)); 

#else	/* CopyHInfoExists */ 
	printf("CopyHInfo does not exist!");
 
	return (false); 
#endif	/* CopyHInfoExists */ 
}
 
/* ---------------- 
 *    IMakeHInfo - Inherited Make creator for HInfo 
 *  
 *    This creator function takes a parameter 
 *    for each slot in this class and each slot 
 *    in all inherited classes. 
 * ---------------- 
 */ 
extern HInfo IMakeHInfo(); 
 
HInfo
IMakeHInfo( hashop)
  ObjectId hashop ;
 
{ 
	HInfo node = New_Node(HInfo);
 
	RInitHInfo(node);
 
	set_hashop(node, hashop); 

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

	return(node);
}
 
/* ---------------- 
 *    RInitMInfo - Raw initializer for MInfo 
 *  
 *    This function just initializes the internal 
 *    information in a node.  
 * ---------------- 
 */ 
extern void RInitMInfo(); 
 
void 
RInitMInfo(p) 
Pointer p; 
{ 
	extern void OutMInfo(); 
	extern bool EqualMInfo(); 
	extern bool CopyMInfo(); 

	MInfo node = (MInfo) p;
 
	node->type = classTag(MInfo); 
	node->outFunc = OutMInfo; 
	node->equalFunc = EqualMInfo; 
	node->copyFunc =  CopyMInfo; 

	return;
}
 
/* ---------------- 
 *    Make creator function for MInfo 
 *  
 *    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 MInfo MakeMInfo(); 
 
MInfo
MakeMInfo( m_ordering)
 	MergeOrder         m_ordering;
 
{ 
	MInfo node = New_Node(MInfo);
 
	RInitMInfo(node);
 
	set_m_ordering(node, m_ordering); 

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

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

#else	/* OutMInfoExists */ 
	sprintf(buf, "#S(MInfo node at 0x%lx)", node);
 
	appendStringInfo(str, buf); 
#endif	/* OutMInfoExists */ 
}
 
/* ---------------- 
 *    Equal function for MInfo 
 * ---------------- 
 */ 
extern bool EqualMInfo(); 
 
bool
EqualMInfo(a, b) 
	MInfo	a, b; 
{ 
#ifdef	EqualMInfoExists 
	return ((bool) _equalMInfo(a, b)); 

#else	/* EqualMInfoExists */ 
	printf("EqualMInfo does not exist!");
 
	return (false); 
#endif	/* EqualMInfoExists */ 
}
 
/* ---------------- 
 *    Copy function for MInfo 
 * ---------------- 
 */ 
extern bool CopyMInfo(); 
 
bool
CopyMInfo(from, to, alloc) 
	MInfo	from; 
	MInfo	*to;	/* return */ 
	char *	(*alloc)(); 
{ 
#ifdef	CopyMInfoExists 
	return ((bool) _copyMInfo(from, to, alloc)); 

#else	/* CopyMInfoExists */ 
	printf("CopyMInfo does not exist!");
 
	return (false); 
#endif	/* CopyMInfoExists */ 
}
 
/* ---------------- 
 *    IMakeMInfo - Inherited Make creator for MInfo 
 *  
 *    This creator function takes a parameter 
 *    for each slot in this class and each slot 
 *    in all inherited classes. 
 * ---------------- 
 */ 
extern MInfo IMakeMInfo(); 
 
MInfo
IMakeMInfo( m_ordering)
  MergeOrder m_ordering ;
 
{ 
	MInfo node = New_Node(MInfo);
 
	RInitMInfo(node);
 
	set_m_ordering(node, m_ordering); 

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

	return(node);
}
 
/* ---------------- 
 *    RInitJInfo - Raw initializer for JInfo 
 *  
 *    This function just initializes the internal 
 *    information in a node.  
 * ---------------- 
 */ 
extern void RInitJInfo(); 
 
void 
RInitJInfo(p) 
Pointer p; 
{ 
	extern void OutJInfo(); 
	extern bool EqualJInfo(); 
	extern bool CopyJInfo(); 

	JInfo node = (JInfo) p;
 
	node->type = classTag(JInfo); 
	node->outFunc = OutJInfo; 
	node->equalFunc = EqualJInfo; 
	node->copyFunc =  CopyJInfo; 

	return;
}
 
/* ---------------- 
 *    Make creator function for JInfo 
 *  
 *    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 JInfo MakeJInfo(); 
 
JInfo
MakeJInfo( otherrels, jinfoclauseinfo, mergesortable, hashjoinable, inactive)
 	List		otherrels;
 	List		jinfoclauseinfo;
 	bool		mergesortable;
 	bool		hashjoinable;
 	bool		inactive;
 
{ 
	JInfo node = New_Node(JInfo);
 
	RInitJInfo(node);
 
	set_otherrels(node, otherrels); 
	set_jinfoclauseinfo(node, jinfoclauseinfo); 
	set_mergesortable(node, mergesortable); 
	set_hashjoinable(node, hashjoinable); 
	set_inactive(node, inactive); 

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

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

#else	/* OutJInfoExists */ 
	sprintf(buf, "#S(JInfo node at 0x%lx)", node);
 
	appendStringInfo(str, buf); 
#endif	/* OutJInfoExists */ 
}
 
/* ---------------- 
 *    Equal function for JInfo 
 * ---------------- 
 */ 
extern bool EqualJInfo(); 
 
bool
EqualJInfo(a, b) 
	JInfo	a, b; 
{ 
#ifdef	EqualJInfoExists 
	return ((bool) _equalJInfo(a, b)); 

#else	/* EqualJInfoExists */ 
	printf("EqualJInfo does not exist!");
 
	return (false); 
#endif	/* EqualJInfoExists */ 
}
 
/* ---------------- 
 *    Copy function for JInfo 
 * ---------------- 
 */ 
extern bool CopyJInfo(); 
 
bool
CopyJInfo(from, to, alloc) 
	JInfo	from; 
	JInfo	*to;	/* return */ 
	char *	(*alloc)(); 
{ 
#ifdef	CopyJInfoExists 
	return ((bool) _copyJInfo(from, to, alloc)); 

#else	/* CopyJInfoExists */ 
	printf("CopyJInfo does not exist!");
 
	return (false); 
#endif	/* CopyJInfoExists */ 
}
 
/* ---------------- 
 *    IMakeJInfo - Inherited Make creator for JInfo 
 *  
 *    This creator function takes a parameter 
 *    for each slot in this class and each slot 
 *    in all inherited classes. 
 * ---------------- 
 */ 
extern JInfo IMakeJInfo(); 
 
JInfo
IMakeJInfo( otherrels, jinfoclauseinfo, mergesortable, hashjoinable, inactive)
  List otherrels ;
  List jinfoclauseinfo ;
  bool mergesortable ;
  bool hashjoinable ;
  bool inactive ;
 
{ 
	JInfo node = New_Node(JInfo);
 
	RInitJInfo(node);
 
	set_otherrels(node, otherrels); 
	set_jinfoclauseinfo(node, jinfoclauseinfo); 
	set_mergesortable(node, mergesortable); 
	set_hashjoinable(node, hashjoinable); 
	set_inactive(node, inactive); 

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

	return(node);
}
 
/* ---------------- 
 *    RInitIter - Raw initializer for Iter 
 *  
 *    This function just initializes the internal 
 *    information in a node.  
 * ---------------- 
 */ 
extern void RInitIter(); 
 
void 
RInitIter(p) 
Pointer p; 
{ 
	extern void OutIter(); 
	extern bool EqualIter(); 
	extern bool CopyIter(); 

	Iter node = (Iter) p;
 
	node->type = classTag(Iter); 
	node->outFunc = OutIter; 
	node->equalFunc = EqualIter; 
	node->copyFunc =  CopyIter; 

	return;
}
 
/* ---------------- 
 *    Make creator function for Iter 
 *  
 *    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 Iter MakeIter(); 
 
Iter
MakeIter( iterexpr)
 	LispValue            iterexpr;
 
{ 
	Iter node = New_Node(Iter);
 
	RInitIter(node);
 
	set_iterexpr(node, iterexpr); 

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

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

#else	/* OutIterExists */ 
	sprintf(buf, "#S(Iter node at 0x%lx)", node);
 
	appendStringInfo(str, buf); 
#endif	/* OutIterExists */ 
}
 
/* ---------------- 
 *    Equal function for Iter 
 * ---------------- 
 */ 
extern bool EqualIter(); 
 
bool
EqualIter(a, b) 
	Iter	a, b; 
{ 
#ifdef	EqualIterExists 
	return ((bool) _equalIter(a, b)); 

#else	/* EqualIterExists */ 
	printf("EqualIter does not exist!");
 
	return (false); 
#endif	/* EqualIterExists */ 
}
 
/* ---------------- 
 *    Copy function for Iter 
 * ---------------- 
 */ 
extern bool CopyIter(); 
 
bool
CopyIter(from, to, alloc) 
	Iter	from; 
	Iter	*to;	/* return */ 
	char *	(*alloc)(); 
{ 
#ifdef	CopyIterExists 
	return ((bool) _copyIter(from, to, alloc)); 

#else	/* CopyIterExists */ 
	printf("CopyIter does not exist!");
 
	return (false); 
#endif	/* CopyIterExists */ 
}
 
/* ---------------- 
 *    IMakeIter - Inherited Make creator for Iter 
 *  
 *    This creator function takes a parameter 
 *    for each slot in this class and each slot 
 *    in all inherited classes. 
 * ---------------- 
 */ 
extern Iter IMakeIter(); 
 
Iter
IMakeIter( iterexpr)
  LispValue iterexpr ;
 
{ 
	Iter node = New_Node(Iter);
 
	RInitIter(node);
 
	set_iterexpr(node, iterexpr); 

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

	return(node);
}
 
/* ---------------- 
 *    RInitStream - Raw initializer for Stream 
 *  
 *    This function just initializes the internal 
 *    information in a node.  
 * ---------------- 
 */ 
extern void RInitStream(); 
 
void 
RInitStream(p) 
Pointer p; 
{ 
	extern void OutStream(); 
	extern bool EqualStream(); 
	extern bool CopyStream(); 

	Stream node = (Stream) p;
 
	node->type = classTag(Stream); 
	node->outFunc = OutStream; 
	node->equalFunc = EqualStream; 
	node->copyFunc =  CopyStream; 

	return;
}
 
/* ---------------- 
 *    Make creator function for Stream 
 *  
 *    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 Stream MakeStream(); 
 
Stream
MakeStream( pathptr, cinfo, clausetype, upstream, downstream, groupup, groupcost, groupsel)
 	pathPtr pathptr;
 	CInfo cinfo;
 	int clausetype;
         StreamPtr upstream;
 	StreamPtr downstream;
 	bool groupup;
 	Cost groupcost;
 	Cost groupsel;
 
{ 
	Stream node = New_Node(Stream);
 
	RInitStream(node);
 
	set_pathptr(node, pathptr); 
	set_cinfo(node, cinfo); 
	set_clausetype(node, clausetype); 
	set_upstream(node, upstream); 
	set_downstream(node, downstream); 
	set_groupup(node, groupup); 
	set_groupcost(node, groupcost); 
	set_groupsel(node, groupsel); 

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

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

#else	/* OutStreamExists */ 
	sprintf(buf, "#S(Stream node at 0x%lx)", node);
 
	appendStringInfo(str, buf); 
#endif	/* OutStreamExists */ 
}
 
/* ---------------- 
 *    Equal function for Stream 
 * ---------------- 
 */ 
extern bool EqualStream(); 
 
bool
EqualStream(a, b) 
	Stream	a, b; 
{ 
#ifdef	EqualStreamExists 
	return ((bool) _equalStream(a, b)); 

#else	/* EqualStreamExists */ 
	printf("EqualStream does not exist!");
 
	return (false); 
#endif	/* EqualStreamExists */ 
}
 
/* ---------------- 
 *    Copy function for Stream 
 * ---------------- 
 */ 
extern bool CopyStream(); 
 
bool
CopyStream(from, to, alloc) 
	Stream	from; 
	Stream	*to;	/* return */ 
	char *	(*alloc)(); 
{ 
#ifdef	CopyStreamExists 
	return ((bool) _copyStream(from, to, alloc)); 

#else	/* CopyStreamExists */ 
	printf("CopyStream does not exist!");
 
	return (false); 
#endif	/* CopyStreamExists */ 
}
 
/* ---------------- 
 *    IMakeStream - Inherited Make creator for Stream 
 *  
 *    This creator function takes a parameter 
 *    for each slot in this class and each slot 
 *    in all inherited classes. 
 * ---------------- 
 */ 
extern Stream IMakeStream(); 
 
Stream
IMakeStream( pathptr, cinfo, clausetype, upstream, downstream, groupup, groupcost, groupsel)
  pathPtr pathptr ;
  CInfo cinfo ;
  int clausetype ;
  StreamPtr upstream ;
  StreamPtr downstream ;
  bool groupup ;
  Cost groupcost ;
  Cost groupsel ;
 
{ 
	Stream node = New_Node(Stream);
 
	RInitStream(node);
 
	set_pathptr(node, pathptr); 
	set_cinfo(node, cinfo); 
	set_clausetype(node, clausetype); 
	set_upstream(node, upstream); 
	set_downstream(node, downstream); 
	set_groupup(node, groupup); 
	set_groupcost(node, groupcost); 
	set_groupsel(node, groupsel); 

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

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