/* ---------------------------------------------------------------- * node file generated from /usr/local/src/postgres/src/backend/nodes/execnodes.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/execnodes.h" #ifdef NO_NODE_CHECKING #define NODEAssertArg(x) #else #define NODEAssertArg(x) AssertArg(x) #endif NO_NODE_CHECKING /* ---------------- * RInitIndexInfo - Raw initializer for IndexInfo * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitIndexInfo(); void RInitIndexInfo(p) Pointer p; { extern void OutIndexInfo(); extern bool EqualIndexInfo(); extern bool CopyIndexInfo(); IndexInfo node = (IndexInfo) p; node->type = classTag(IndexInfo); node->outFunc = OutIndexInfo; node->equalFunc = EqualIndexInfo; node->copyFunc = CopyIndexInfo; return; } /* ---------------- * Make creator function for IndexInfo * * 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 IndexInfo MakeIndexInfo(); IndexInfo MakeIndexInfo( ii_NumKeyAttributes, ii_KeyAttributeNumbers, ii_FuncIndexInfo, ii_Predicate) int ii_NumKeyAttributes; AttributeNumberPtr ii_KeyAttributeNumbers; FuncIndexInfoPtr ii_FuncIndexInfo; List ii_Predicate; { IndexInfo node = New_Node(IndexInfo); RInitIndexInfo(node); set_ii_NumKeyAttributes(node, ii_NumKeyAttributes); set_ii_KeyAttributeNumbers(node, ii_KeyAttributeNumbers); set_ii_FuncIndexInfo(node, ii_FuncIndexInfo); set_ii_Predicate(node, ii_Predicate); return(node); } /* ---------------- * Out function for IndexInfo * ---------------- */ extern void OutIndexInfo(); ; void OutIndexInfo(str, node) StringInfo str; IndexInfo node; { char buf[100]; #ifdef OutIndexInfoExists appendStringInfo(str, "#S("); _outIndexInfo(str, node); appendStringInfo(str, ")"); #else /* OutIndexInfoExists */ sprintf(buf, "#S(IndexInfo node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutIndexInfoExists */ } /* ---------------- * Equal function for IndexInfo * ---------------- */ extern bool EqualIndexInfo(); bool EqualIndexInfo(a, b) IndexInfo a, b; { #ifdef EqualIndexInfoExists return ((bool) _equalIndexInfo(a, b)); #else /* EqualIndexInfoExists */ printf("EqualIndexInfo does not exist!"); return (false); #endif /* EqualIndexInfoExists */ } /* ---------------- * Copy function for IndexInfo * ---------------- */ extern bool CopyIndexInfo(); bool CopyIndexInfo(from, to, alloc) IndexInfo from; IndexInfo *to; /* return */ char * (*alloc)(); { #ifdef CopyIndexInfoExists return ((bool) _copyIndexInfo(from, to, alloc)); #else /* CopyIndexInfoExists */ printf("CopyIndexInfo does not exist!"); return (false); #endif /* CopyIndexInfoExists */ } /* ---------------- * IMakeIndexInfo - Inherited Make creator for IndexInfo * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern IndexInfo IMakeIndexInfo(); IndexInfo IMakeIndexInfo( ii_NumKeyAttributes, ii_KeyAttributeNumbers, ii_FuncIndexInfo, ii_Predicate) int ii_NumKeyAttributes ; AttributeNumberPtr ii_KeyAttributeNumbers ; FuncIndexInfoPtr ii_FuncIndexInfo ; List ii_Predicate ; { IndexInfo node = New_Node(IndexInfo); RInitIndexInfo(node); set_ii_NumKeyAttributes(node, ii_NumKeyAttributes); set_ii_KeyAttributeNumbers(node, ii_KeyAttributeNumbers); set_ii_FuncIndexInfo(node, ii_FuncIndexInfo); set_ii_Predicate(node, ii_Predicate); return(node); } /* ---------------- * RMakeIndexInfo - Raw Make creator for IndexInfo * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern IndexInfo RMakeIndexInfo(); IndexInfo RMakeIndexInfo() { IndexInfo node = New_Node(IndexInfo); RInitIndexInfo(node); return(node); } /* ---------------- * RInitRelationInfo - Raw initializer for RelationInfo * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitRelationInfo(); void RInitRelationInfo(p) Pointer p; { extern void OutRelationInfo(); extern bool EqualRelationInfo(); extern bool CopyRelationInfo(); RelationInfo node = (RelationInfo) p; node->type = classTag(RelationInfo); node->outFunc = OutRelationInfo; node->equalFunc = EqualRelationInfo; node->copyFunc = CopyRelationInfo; return; } /* ---------------- * Make creator function for RelationInfo * * 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 RelationInfo MakeRelationInfo(); RelationInfo MakeRelationInfo( ri_RangeTableIndex, ri_RelationDesc, ri_NumIndices, ri_IndexRelationDescs, ri_IndexRelationInfo) Index ri_RangeTableIndex; Relation ri_RelationDesc; int ri_NumIndices; RelationPtr ri_IndexRelationDescs; IndexInfoPtr ri_IndexRelationInfo; { RelationInfo node = New_Node(RelationInfo); RInitRelationInfo(node); set_ri_RangeTableIndex(node, ri_RangeTableIndex); set_ri_RelationDesc(node, ri_RelationDesc); set_ri_NumIndices(node, ri_NumIndices); set_ri_IndexRelationDescs(node, ri_IndexRelationDescs); set_ri_IndexRelationInfo(node, ri_IndexRelationInfo); return(node); } /* ---------------- * Out function for RelationInfo * ---------------- */ extern void OutRelationInfo(); ; void OutRelationInfo(str, node) StringInfo str; RelationInfo node; { char buf[100]; #ifdef OutRelationInfoExists appendStringInfo(str, "#S("); _outRelationInfo(str, node); appendStringInfo(str, ")"); #else /* OutRelationInfoExists */ sprintf(buf, "#S(RelationInfo node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutRelationInfoExists */ } /* ---------------- * Equal function for RelationInfo * ---------------- */ extern bool EqualRelationInfo(); bool EqualRelationInfo(a, b) RelationInfo a, b; { #ifdef EqualRelationInfoExists return ((bool) _equalRelationInfo(a, b)); #else /* EqualRelationInfoExists */ printf("EqualRelationInfo does not exist!"); return (false); #endif /* EqualRelationInfoExists */ } /* ---------------- * Copy function for RelationInfo * ---------------- */ extern bool CopyRelationInfo(); bool CopyRelationInfo(from, to, alloc) RelationInfo from; RelationInfo *to; /* return */ char * (*alloc)(); { #ifdef CopyRelationInfoExists return ((bool) _copyRelationInfo(from, to, alloc)); #else /* CopyRelationInfoExists */ printf("CopyRelationInfo does not exist!"); return (false); #endif /* CopyRelationInfoExists */ } /* ---------------- * IMakeRelationInfo - Inherited Make creator for RelationInfo * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern RelationInfo IMakeRelationInfo(); RelationInfo IMakeRelationInfo( ri_RangeTableIndex, ri_RelationDesc, ri_NumIndices, ri_IndexRelationDescs, ri_IndexRelationInfo) Index ri_RangeTableIndex ; Relation ri_RelationDesc ; int ri_NumIndices ; RelationPtr ri_IndexRelationDescs ; IndexInfoPtr ri_IndexRelationInfo ; { RelationInfo node = New_Node(RelationInfo); RInitRelationInfo(node); set_ri_RangeTableIndex(node, ri_RangeTableIndex); set_ri_RelationDesc(node, ri_RelationDesc); set_ri_NumIndices(node, ri_NumIndices); set_ri_IndexRelationDescs(node, ri_IndexRelationDescs); set_ri_IndexRelationInfo(node, ri_IndexRelationInfo); return(node); } /* ---------------- * RMakeRelationInfo - Raw Make creator for RelationInfo * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern RelationInfo RMakeRelationInfo(); RelationInfo RMakeRelationInfo() { RelationInfo node = New_Node(RelationInfo); RInitRelationInfo(node); return(node); } /* ---------------- * RInitTupleCount - Raw initializer for TupleCount * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitTupleCount(); void RInitTupleCount(p) Pointer p; { extern void OutTupleCount(); extern bool EqualTupleCount(); extern bool CopyTupleCount(); TupleCount node = (TupleCount) p; node->type = classTag(TupleCount); node->outFunc = OutTupleCount; node->equalFunc = EqualTupleCount; node->copyFunc = CopyTupleCount; return; } /* ---------------- * Make creator function for TupleCount * * 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 TupleCount MakeTupleCount(); TupleCount MakeTupleCount( tc_retrieved, tc_appended, tc_deleted, tc_replaced, tc_inserted, tc_processed) int tc_retrieved; int tc_appended; int tc_deleted; int tc_replaced; int tc_inserted; int tc_processed; { TupleCount node = New_Node(TupleCount); RInitTupleCount(node); set_tc_retrieved(node, tc_retrieved); set_tc_appended(node, tc_appended); set_tc_deleted(node, tc_deleted); set_tc_replaced(node, tc_replaced); set_tc_inserted(node, tc_inserted); set_tc_processed(node, tc_processed); return(node); } /* ---------------- * Out function for TupleCount * ---------------- */ extern void OutTupleCount(); ; void OutTupleCount(str, node) StringInfo str; TupleCount node; { char buf[100]; #ifdef OutTupleCountExists appendStringInfo(str, "#S("); _outTupleCount(str, node); appendStringInfo(str, ")"); #else /* OutTupleCountExists */ sprintf(buf, "#S(TupleCount node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutTupleCountExists */ } /* ---------------- * Equal function for TupleCount * ---------------- */ extern bool EqualTupleCount(); bool EqualTupleCount(a, b) TupleCount a, b; { #ifdef EqualTupleCountExists return ((bool) _equalTupleCount(a, b)); #else /* EqualTupleCountExists */ printf("EqualTupleCount does not exist!"); return (false); #endif /* EqualTupleCountExists */ } /* ---------------- * Copy function for TupleCount * ---------------- */ extern bool CopyTupleCount(); bool CopyTupleCount(from, to, alloc) TupleCount from; TupleCount *to; /* return */ char * (*alloc)(); { #ifdef CopyTupleCountExists return ((bool) _copyTupleCount(from, to, alloc)); #else /* CopyTupleCountExists */ printf("CopyTupleCount does not exist!"); return (false); #endif /* CopyTupleCountExists */ } /* ---------------- * IMakeTupleCount - Inherited Make creator for TupleCount * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern TupleCount IMakeTupleCount(); TupleCount IMakeTupleCount( tc_retrieved, tc_appended, tc_deleted, tc_replaced, tc_inserted, tc_processed) int tc_retrieved ; int tc_appended ; int tc_deleted ; int tc_replaced ; int tc_inserted ; int tc_processed ; { TupleCount node = New_Node(TupleCount); RInitTupleCount(node); set_tc_retrieved(node, tc_retrieved); set_tc_appended(node, tc_appended); set_tc_deleted(node, tc_deleted); set_tc_replaced(node, tc_replaced); set_tc_inserted(node, tc_inserted); set_tc_processed(node, tc_processed); return(node); } /* ---------------- * RMakeTupleCount - Raw Make creator for TupleCount * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern TupleCount RMakeTupleCount(); TupleCount RMakeTupleCount() { TupleCount node = New_Node(TupleCount); RInitTupleCount(node); return(node); } /* ---------------- * RInitTupleTableSlot - Raw initializer for TupleTableSlot * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitTupleTableSlot(); void RInitTupleTableSlot(p) Pointer p; { extern void OutTupleTableSlot(); extern bool EqualTupleTableSlot(); extern bool CopyTupleTableSlot(); TupleTableSlot node = (TupleTableSlot) p; node->type = classTag(TupleTableSlot); node->outFunc = OutTupleTableSlot; node->equalFunc = EqualTupleTableSlot; node->copyFunc = CopyTupleTableSlot; return; } /* ---------------- * Make creator function for TupleTableSlot * * 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 TupleTableSlot MakeTupleTableSlot(); TupleTableSlot MakeTupleTableSlot( ttc_shouldFree, ttc_descIsNew, ttc_tupleDescriptor, ttc_execTupDescriptor, ttc_buffer, ttc_whichplan) bool ttc_shouldFree; bool ttc_descIsNew; TupleDescriptor ttc_tupleDescriptor; ExecTupDescriptor ttc_execTupDescriptor; Buffer ttc_buffer; int ttc_whichplan; { TupleTableSlot node = New_Node(TupleTableSlot); RInitTupleTableSlot(node); set_ttc_shouldFree(node, ttc_shouldFree); set_ttc_descIsNew(node, ttc_descIsNew); set_ttc_tupleDescriptor(node, ttc_tupleDescriptor); set_ttc_execTupDescriptor(node, ttc_execTupDescriptor); set_ttc_buffer(node, ttc_buffer); set_ttc_whichplan(node, ttc_whichplan); return(node); } /* ---------------- * Out function for TupleTableSlot * ---------------- */ extern void OutTupleTableSlot(); ; void OutTupleTableSlot(str, node) StringInfo str; TupleTableSlot node; { char buf[100]; #ifdef OutTupleTableSlotExists appendStringInfo(str, "#S("); _outTupleTableSlot(str, node); appendStringInfo(str, ")"); #else /* OutTupleTableSlotExists */ sprintf(buf, "#S(TupleTableSlot node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutTupleTableSlotExists */ } /* ---------------- * Equal function for TupleTableSlot * ---------------- */ extern bool EqualTupleTableSlot(); bool EqualTupleTableSlot(a, b) TupleTableSlot a, b; { #ifdef EqualTupleTableSlotExists return ((bool) _equalTupleTableSlot(a, b)); #else /* EqualTupleTableSlotExists */ printf("EqualTupleTableSlot does not exist!"); return (false); #endif /* EqualTupleTableSlotExists */ } /* ---------------- * Copy function for TupleTableSlot * ---------------- */ extern bool CopyTupleTableSlot(); bool CopyTupleTableSlot(from, to, alloc) TupleTableSlot from; TupleTableSlot *to; /* return */ char * (*alloc)(); { #ifdef CopyTupleTableSlotExists return ((bool) _copyTupleTableSlot(from, to, alloc)); #else /* CopyTupleTableSlotExists */ printf("CopyTupleTableSlot does not exist!"); return (false); #endif /* CopyTupleTableSlotExists */ } /* ---------------- * IMakeTupleTableSlot - Inherited Make creator for TupleTableSlot * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern TupleTableSlot IMakeTupleTableSlot(); TupleTableSlot IMakeTupleTableSlot( ttc_shouldFree, ttc_descIsNew, ttc_tupleDescriptor, ttc_execTupDescriptor, ttc_buffer, ttc_whichplan) bool ttc_shouldFree ; bool ttc_descIsNew ; TupleDescriptor ttc_tupleDescriptor ; ExecTupDescriptor ttc_execTupDescriptor ; Buffer ttc_buffer ; int ttc_whichplan ; { TupleTableSlot node = New_Node(TupleTableSlot); RInitTupleTableSlot(node); set_ttc_shouldFree(node, ttc_shouldFree); set_ttc_descIsNew(node, ttc_descIsNew); set_ttc_tupleDescriptor(node, ttc_tupleDescriptor); set_ttc_execTupDescriptor(node, ttc_execTupDescriptor); set_ttc_buffer(node, ttc_buffer); set_ttc_whichplan(node, ttc_whichplan); return(node); } /* ---------------- * RMakeTupleTableSlot - Raw Make creator for TupleTableSlot * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern TupleTableSlot RMakeTupleTableSlot(); TupleTableSlot RMakeTupleTableSlot() { TupleTableSlot node = New_Node(TupleTableSlot); RInitTupleTableSlot(node); return(node); } /* ---------------- * RInitExprContext - Raw initializer for ExprContext * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitExprContext(); void RInitExprContext(p) Pointer p; { extern void OutExprContext(); extern bool EqualExprContext(); extern bool CopyExprContext(); ExprContext node = (ExprContext) p; node->type = classTag(ExprContext); node->outFunc = OutExprContext; node->equalFunc = EqualExprContext; node->copyFunc = CopyExprContext; return; } /* ---------------- * Make creator function for ExprContext * * 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 ExprContext MakeExprContext(); ExprContext MakeExprContext( ecxt_scantuple, ecxt_innertuple, ecxt_outertuple, ecxt_relation, ecxt_relid, ecxt_param_list_info, ecxt_range_table) TupleTableSlot ecxt_scantuple ; TupleTableSlot ecxt_innertuple ; TupleTableSlot ecxt_outertuple ; Relation ecxt_relation ; Index ecxt_relid ; ParamListInfo ecxt_param_list_info ; List ecxt_range_table; { ExprContext node = New_Node(ExprContext); RInitExprContext(node); set_ecxt_scantuple(node, ecxt_scantuple); set_ecxt_innertuple(node, ecxt_innertuple); set_ecxt_outertuple(node, ecxt_outertuple); set_ecxt_relation(node, ecxt_relation); set_ecxt_relid(node, ecxt_relid); set_ecxt_param_list_info(node, ecxt_param_list_info); set_ecxt_range_table(node, ecxt_range_table); return(node); } /* ---------------- * Out function for ExprContext * ---------------- */ extern void OutExprContext(); ; void OutExprContext(str, node) StringInfo str; ExprContext node; { char buf[100]; #ifdef OutExprContextExists appendStringInfo(str, "#S("); _outExprContext(str, node); appendStringInfo(str, ")"); #else /* OutExprContextExists */ sprintf(buf, "#S(ExprContext node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutExprContextExists */ } /* ---------------- * Equal function for ExprContext * ---------------- */ extern bool EqualExprContext(); bool EqualExprContext(a, b) ExprContext a, b; { #ifdef EqualExprContextExists return ((bool) _equalExprContext(a, b)); #else /* EqualExprContextExists */ printf("EqualExprContext does not exist!"); return (false); #endif /* EqualExprContextExists */ } /* ---------------- * Copy function for ExprContext * ---------------- */ extern bool CopyExprContext(); bool CopyExprContext(from, to, alloc) ExprContext from; ExprContext *to; /* return */ char * (*alloc)(); { #ifdef CopyExprContextExists return ((bool) _copyExprContext(from, to, alloc)); #else /* CopyExprContextExists */ printf("CopyExprContext does not exist!"); return (false); #endif /* CopyExprContextExists */ } /* ---------------- * IMakeExprContext - Inherited Make creator for ExprContext * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern ExprContext IMakeExprContext(); ExprContext IMakeExprContext( ecxt_scantuple, ecxt_innertuple, ecxt_outertuple, ecxt_relation, ecxt_relid, ecxt_param_list_info, ecxt_range_table) TupleTableSlot ecxt_scantuple ; TupleTableSlot ecxt_innertuple ; TupleTableSlot ecxt_outertuple ; Relation ecxt_relation ; Index ecxt_relid ; ParamListInfo ecxt_param_list_info ; List ecxt_range_table ; { ExprContext node = New_Node(ExprContext); RInitExprContext(node); set_ecxt_scantuple(node, ecxt_scantuple); set_ecxt_innertuple(node, ecxt_innertuple); set_ecxt_outertuple(node, ecxt_outertuple); set_ecxt_relation(node, ecxt_relation); set_ecxt_relid(node, ecxt_relid); set_ecxt_param_list_info(node, ecxt_param_list_info); set_ecxt_range_table(node, ecxt_range_table); return(node); } /* ---------------- * RMakeExprContext - Raw Make creator for ExprContext * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern ExprContext RMakeExprContext(); ExprContext RMakeExprContext() { ExprContext node = New_Node(ExprContext); RInitExprContext(node); return(node); } /* ---------------- * RInitProjectionInfo - Raw initializer for ProjectionInfo * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitProjectionInfo(); void RInitProjectionInfo(p) Pointer p; { extern void OutProjectionInfo(); extern bool EqualProjectionInfo(); extern bool CopyProjectionInfo(); ProjectionInfo node = (ProjectionInfo) p; node->type = classTag(ProjectionInfo); node->outFunc = OutProjectionInfo; node->equalFunc = EqualProjectionInfo; node->copyFunc = CopyProjectionInfo; return; } /* ---------------- * Make creator function for ProjectionInfo * * 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 ProjectionInfo MakeProjectionInfo(); ProjectionInfo MakeProjectionInfo( pi_targetlist, pi_len, pi_tupValue, pi_exprContext, pi_slot) List pi_targetlist; int pi_len; Pointer pi_tupValue; ExprContext pi_exprContext; TupleTableSlot pi_slot; { ProjectionInfo node = New_Node(ProjectionInfo); RInitProjectionInfo(node); set_pi_targetlist(node, pi_targetlist); set_pi_len(node, pi_len); set_pi_tupValue(node, pi_tupValue); set_pi_exprContext(node, pi_exprContext); set_pi_slot(node, pi_slot); return(node); } /* ---------------- * Out function for ProjectionInfo * ---------------- */ extern void OutProjectionInfo(); ; void OutProjectionInfo(str, node) StringInfo str; ProjectionInfo node; { char buf[100]; #ifdef OutProjectionInfoExists appendStringInfo(str, "#S("); _outProjectionInfo(str, node); appendStringInfo(str, ")"); #else /* OutProjectionInfoExists */ sprintf(buf, "#S(ProjectionInfo node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutProjectionInfoExists */ } /* ---------------- * Equal function for ProjectionInfo * ---------------- */ extern bool EqualProjectionInfo(); bool EqualProjectionInfo(a, b) ProjectionInfo a, b; { #ifdef EqualProjectionInfoExists return ((bool) _equalProjectionInfo(a, b)); #else /* EqualProjectionInfoExists */ printf("EqualProjectionInfo does not exist!"); return (false); #endif /* EqualProjectionInfoExists */ } /* ---------------- * Copy function for ProjectionInfo * ---------------- */ extern bool CopyProjectionInfo(); bool CopyProjectionInfo(from, to, alloc) ProjectionInfo from; ProjectionInfo *to; /* return */ char * (*alloc)(); { #ifdef CopyProjectionInfoExists return ((bool) _copyProjectionInfo(from, to, alloc)); #else /* CopyProjectionInfoExists */ printf("CopyProjectionInfo does not exist!"); return (false); #endif /* CopyProjectionInfoExists */ } /* ---------------- * IMakeProjectionInfo - Inherited Make creator for ProjectionInfo * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern ProjectionInfo IMakeProjectionInfo(); ProjectionInfo IMakeProjectionInfo( pi_targetlist, pi_len, pi_tupValue, pi_exprContext, pi_slot) List pi_targetlist ; int pi_len ; Pointer pi_tupValue ; ExprContext pi_exprContext ; TupleTableSlot pi_slot ; { ProjectionInfo node = New_Node(ProjectionInfo); RInitProjectionInfo(node); set_pi_targetlist(node, pi_targetlist); set_pi_len(node, pi_len); set_pi_tupValue(node, pi_tupValue); set_pi_exprContext(node, pi_exprContext); set_pi_slot(node, pi_slot); return(node); } /* ---------------- * RMakeProjectionInfo - Raw Make creator for ProjectionInfo * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern ProjectionInfo RMakeProjectionInfo(); ProjectionInfo RMakeProjectionInfo() { ProjectionInfo node = New_Node(ProjectionInfo); RInitProjectionInfo(node); return(node); } /* ---------------- * RInitJunkFilter - Raw initializer for JunkFilter * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitJunkFilter(); void RInitJunkFilter(p) Pointer p; { extern void OutJunkFilter(); extern bool EqualJunkFilter(); extern bool CopyJunkFilter(); JunkFilter node = (JunkFilter) p; node->type = classTag(JunkFilter); node->outFunc = OutJunkFilter; node->equalFunc = EqualJunkFilter; node->copyFunc = CopyJunkFilter; return; } /* ---------------- * Make creator function for JunkFilter * * 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 JunkFilter MakeJunkFilter(); JunkFilter MakeJunkFilter( jf_targetList, jf_length, jf_tupType, jf_cleanTargetList, jf_cleanLength, jf_cleanTupType, jf_cleanMap) List jf_targetList; int jf_length; TupleDescriptor jf_tupType; List jf_cleanTargetList; int jf_cleanLength; TupleDescriptor jf_cleanTupType; AttributeNumberPtr jf_cleanMap; { JunkFilter node = New_Node(JunkFilter); RInitJunkFilter(node); set_jf_targetList(node, jf_targetList); set_jf_length(node, jf_length); set_jf_tupType(node, jf_tupType); set_jf_cleanTargetList(node, jf_cleanTargetList); set_jf_cleanLength(node, jf_cleanLength); set_jf_cleanTupType(node, jf_cleanTupType); set_jf_cleanMap(node, jf_cleanMap); return(node); } /* ---------------- * Out function for JunkFilter * ---------------- */ extern void OutJunkFilter(); ; void OutJunkFilter(str, node) StringInfo str; JunkFilter node; { char buf[100]; #ifdef OutJunkFilterExists appendStringInfo(str, "#S("); _outJunkFilter(str, node); appendStringInfo(str, ")"); #else /* OutJunkFilterExists */ sprintf(buf, "#S(JunkFilter node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutJunkFilterExists */ } /* ---------------- * Equal function for JunkFilter * ---------------- */ extern bool EqualJunkFilter(); bool EqualJunkFilter(a, b) JunkFilter a, b; { #ifdef EqualJunkFilterExists return ((bool) _equalJunkFilter(a, b)); #else /* EqualJunkFilterExists */ printf("EqualJunkFilter does not exist!"); return (false); #endif /* EqualJunkFilterExists */ } /* ---------------- * Copy function for JunkFilter * ---------------- */ extern bool CopyJunkFilter(); bool CopyJunkFilter(from, to, alloc) JunkFilter from; JunkFilter *to; /* return */ char * (*alloc)(); { #ifdef CopyJunkFilterExists return ((bool) _copyJunkFilter(from, to, alloc)); #else /* CopyJunkFilterExists */ printf("CopyJunkFilter does not exist!"); return (false); #endif /* CopyJunkFilterExists */ } /* ---------------- * IMakeJunkFilter - Inherited Make creator for JunkFilter * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern JunkFilter IMakeJunkFilter(); JunkFilter IMakeJunkFilter( jf_targetList, jf_length, jf_tupType, jf_cleanTargetList, jf_cleanLength, jf_cleanTupType, jf_cleanMap) List jf_targetList ; int jf_length ; TupleDescriptor jf_tupType ; List jf_cleanTargetList ; int jf_cleanLength ; TupleDescriptor jf_cleanTupType ; AttributeNumberPtr jf_cleanMap ; { JunkFilter node = New_Node(JunkFilter); RInitJunkFilter(node); set_jf_targetList(node, jf_targetList); set_jf_length(node, jf_length); set_jf_tupType(node, jf_tupType); set_jf_cleanTargetList(node, jf_cleanTargetList); set_jf_cleanLength(node, jf_cleanLength); set_jf_cleanTupType(node, jf_cleanTupType); set_jf_cleanMap(node, jf_cleanMap); return(node); } /* ---------------- * RMakeJunkFilter - Raw Make creator for JunkFilter * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern JunkFilter RMakeJunkFilter(); JunkFilter RMakeJunkFilter() { JunkFilter node = New_Node(JunkFilter); RInitJunkFilter(node); return(node); } /* ---------------- * RInitEState - Raw initializer for EState * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitEState(); void RInitEState(p) Pointer p; { extern void OutEState(); extern bool EqualEState(); extern bool CopyEState(); EState node = (EState) p; node->type = classTag(EState); node->outFunc = OutEState; node->equalFunc = EqualEState; node->copyFunc = CopyEState; return; } /* ---------------- * Make creator function for EState * * 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 EState MakeEState(); EState MakeEState( es_direction, es_time, es_owner, es_locks, es_subplan_info, es_error_message, es_range_table, es_qualification_tuple, es_qualification_tuple_id, es_qualification_tuple_buffer, es_raw_qualification_tuple, es_relation_relation_descriptor, es_into_relation_descriptor, es_result_relation_info, es_tuplecount, es_param_list_info, es_prs2_info, es_explain_relation, es_BaseId, es_tupleTable, es_junkFilter, es_result_rel_scanstate, es_whichplan, es_result_relation_info_list, es_junkFilter_list, es_result_rel_ruleinfo, es_refcount) ScanDirection es_direction; abstime es_time; ObjectId es_owner; List es_locks; List es_subplan_info; Name es_error_message; List es_range_table; HeapTuple es_qualification_tuple; ItemPointer es_qualification_tuple_id; Buffer es_qualification_tuple_buffer; HeapTuple es_raw_qualification_tuple; Relation es_relation_relation_descriptor; Relation es_into_relation_descriptor; RelationInfo es_result_relation_info; TupleCount es_tuplecount; ParamListInfo es_param_list_info; Prs2EStateInfo es_prs2_info; Relation es_explain_relation; int es_BaseId; TupleTable es_tupleTable; JunkFilter es_junkFilter; Pointer es_result_rel_scanstate; int es_whichplan; List es_result_relation_info_list; List es_junkFilter_list; RelationRuleInfo es_result_rel_ruleinfo; intPtr es_refcount; { EState node = New_Node(EState); RInitEState(node); set_es_direction(node, es_direction); set_es_time(node, es_time); set_es_owner(node, es_owner); set_es_locks(node, es_locks); set_es_subplan_info(node, es_subplan_info); set_es_error_message(node, es_error_message); set_es_range_table(node, es_range_table); set_es_qualification_tuple(node, es_qualification_tuple); set_es_qualification_tuple_id(node, es_qualification_tuple_id); set_es_qualification_tuple_buffer(node, es_qualification_tuple_buffer); set_es_raw_qualification_tuple(node, es_raw_qualification_tuple); set_es_relation_relation_descriptor(node, es_relation_relation_descriptor); set_es_into_relation_descriptor(node, es_into_relation_descriptor); set_es_result_relation_info(node, es_result_relation_info); set_es_tuplecount(node, es_tuplecount); set_es_param_list_info(node, es_param_list_info); set_es_prs2_info(node, es_prs2_info); set_es_explain_relation(node, es_explain_relation); set_es_BaseId(node, es_BaseId); set_es_tupleTable(node, es_tupleTable); set_es_junkFilter(node, es_junkFilter); set_es_result_rel_scanstate(node, es_result_rel_scanstate); set_es_whichplan(node, es_whichplan); set_es_result_relation_info_list(node, es_result_relation_info_list); set_es_junkFilter_list(node, es_junkFilter_list); set_es_result_rel_ruleinfo(node, es_result_rel_ruleinfo); set_es_refcount(node, es_refcount); return(node); } /* ---------------- * Out function for EState * ---------------- */ extern void OutEState(); ; void OutEState(str, node) StringInfo str; EState node; { char buf[100]; #ifdef OutEStateExists appendStringInfo(str, "#S("); _outEState(str, node); appendStringInfo(str, ")"); #else /* OutEStateExists */ sprintf(buf, "#S(EState node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutEStateExists */ } /* ---------------- * Equal function for EState * ---------------- */ extern bool EqualEState(); bool EqualEState(a, b) EState a, b; { #ifdef EqualEStateExists return ((bool) _equalEState(a, b)); #else /* EqualEStateExists */ printf("EqualEState does not exist!"); return (false); #endif /* EqualEStateExists */ } /* ---------------- * Copy function for EState * ---------------- */ extern bool CopyEState(); bool CopyEState(from, to, alloc) EState from; EState *to; /* return */ char * (*alloc)(); { #ifdef CopyEStateExists return ((bool) _copyEState(from, to, alloc)); #else /* CopyEStateExists */ printf("CopyEState does not exist!"); return (false); #endif /* CopyEStateExists */ } /* ---------------- * IMakeEState - Inherited Make creator for EState * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern EState IMakeEState(); EState IMakeEState( es_direction, es_time, es_owner, es_locks, es_subplan_info, es_error_message, es_range_table, es_qualification_tuple, es_qualification_tuple_id, es_qualification_tuple_buffer, es_raw_qualification_tuple, es_relation_relation_descriptor, es_into_relation_descriptor, es_result_relation_info, es_tuplecount, es_param_list_info, es_prs2_info, es_explain_relation, es_BaseId, es_tupleTable, es_junkFilter, es_result_rel_scanstate, es_whichplan, es_result_relation_info_list, es_junkFilter_list, es_result_rel_ruleinfo, es_refcount) ScanDirection es_direction ; abstime es_time ; ObjectId es_owner ; List es_locks ; List es_subplan_info ; Name es_error_message ; List es_range_table ; HeapTuple es_qualification_tuple ; ItemPointer es_qualification_tuple_id ; Buffer es_qualification_tuple_buffer ; HeapTuple es_raw_qualification_tuple ; Relation es_relation_relation_descriptor ; Relation es_into_relation_descriptor ; RelationInfo es_result_relation_info ; TupleCount es_tuplecount ; ParamListInfo es_param_list_info ; Prs2EStateInfo es_prs2_info ; Relation es_explain_relation ; int es_BaseId ; TupleTable es_tupleTable ; JunkFilter es_junkFilter ; Pointer es_result_rel_scanstate ; int es_whichplan ; List es_result_relation_info_list ; List es_junkFilter_list ; RelationRuleInfo es_result_rel_ruleinfo ; intPtr es_refcount ; { EState node = New_Node(EState); RInitEState(node); set_es_direction(node, es_direction); set_es_time(node, es_time); set_es_owner(node, es_owner); set_es_locks(node, es_locks); set_es_subplan_info(node, es_subplan_info); set_es_error_message(node, es_error_message); set_es_range_table(node, es_range_table); set_es_qualification_tuple(node, es_qualification_tuple); set_es_qualification_tuple_id(node, es_qualification_tuple_id); set_es_qualification_tuple_buffer(node, es_qualification_tuple_buffer); set_es_raw_qualification_tuple(node, es_raw_qualification_tuple); set_es_relation_relation_descriptor(node, es_relation_relation_descriptor); set_es_into_relation_descriptor(node, es_into_relation_descriptor); set_es_result_relation_info(node, es_result_relation_info); set_es_tuplecount(node, es_tuplecount); set_es_param_list_info(node, es_param_list_info); set_es_prs2_info(node, es_prs2_info); set_es_explain_relation(node, es_explain_relation); set_es_BaseId(node, es_BaseId); set_es_tupleTable(node, es_tupleTable); set_es_junkFilter(node, es_junkFilter); set_es_result_rel_scanstate(node, es_result_rel_scanstate); set_es_whichplan(node, es_whichplan); set_es_result_relation_info_list(node, es_result_relation_info_list); set_es_junkFilter_list(node, es_junkFilter_list); set_es_result_rel_ruleinfo(node, es_result_rel_ruleinfo); set_es_refcount(node, es_refcount); return(node); } /* ---------------- * RMakeEState - Raw Make creator for EState * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern EState RMakeEState(); EState RMakeEState() { EState node = New_Node(EState); RInitEState(node); return(node); } /* ---------------- * RInitHookNode - Raw initializer for HookNode * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitHookNode(); void RInitHookNode(p) Pointer p; { extern void OutHookNode(); extern bool EqualHookNode(); extern bool CopyHookNode(); HookNode node = (HookNode) p; node->type = classTag(HookNode); node->outFunc = OutHookNode; node->equalFunc = EqualHookNode; node->copyFunc = CopyHookNode; return; } /* ---------------- * Make creator function for HookNode * * 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 HookNode MakeHookNode(); HookNode MakeHookNode( hook_at_initnode, hook_pre_procnode, hook_pre_endnode, hook_post_initnode, hook_post_procnode, hook_post_endnode, hook_data) HookFunction hook_at_initnode ; HookFunction hook_pre_procnode ; HookFunction hook_pre_endnode ; HookFunction hook_post_initnode ; HookFunction hook_post_procnode ; HookFunction hook_post_endnode ; Pointer hook_data; { HookNode node = New_Node(HookNode); RInitHookNode(node); set_hook_at_initnode(node, hook_at_initnode); set_hook_pre_procnode(node, hook_pre_procnode); set_hook_pre_endnode(node, hook_pre_endnode); set_hook_post_initnode(node, hook_post_initnode); set_hook_post_procnode(node, hook_post_procnode); set_hook_post_endnode(node, hook_post_endnode); set_hook_data(node, hook_data); return(node); } /* ---------------- * Out function for HookNode * ---------------- */ extern void OutHookNode(); ; void OutHookNode(str, node) StringInfo str; HookNode node; { char buf[100]; #ifdef OutHookNodeExists appendStringInfo(str, "#S("); _outHookNode(str, node); appendStringInfo(str, ")"); #else /* OutHookNodeExists */ sprintf(buf, "#S(HookNode node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutHookNodeExists */ } /* ---------------- * Equal function for HookNode * ---------------- */ extern bool EqualHookNode(); bool EqualHookNode(a, b) HookNode a, b; { #ifdef EqualHookNodeExists return ((bool) _equalHookNode(a, b)); #else /* EqualHookNodeExists */ printf("EqualHookNode does not exist!"); return (false); #endif /* EqualHookNodeExists */ } /* ---------------- * Copy function for HookNode * ---------------- */ extern bool CopyHookNode(); bool CopyHookNode(from, to, alloc) HookNode from; HookNode *to; /* return */ char * (*alloc)(); { #ifdef CopyHookNodeExists return ((bool) _copyHookNode(from, to, alloc)); #else /* CopyHookNodeExists */ printf("CopyHookNode does not exist!"); return (false); #endif /* CopyHookNodeExists */ } /* ---------------- * IMakeHookNode - Inherited Make creator for HookNode * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern HookNode IMakeHookNode(); HookNode IMakeHookNode( hook_at_initnode, hook_pre_procnode, hook_pre_endnode, hook_post_initnode, hook_post_procnode, hook_post_endnode, hook_data) HookFunction hook_at_initnode ; HookFunction hook_pre_procnode ; HookFunction hook_pre_endnode ; HookFunction hook_post_initnode ; HookFunction hook_post_procnode ; HookFunction hook_post_endnode ; Pointer hook_data ; { HookNode node = New_Node(HookNode); RInitHookNode(node); set_hook_at_initnode(node, hook_at_initnode); set_hook_pre_procnode(node, hook_pre_procnode); set_hook_pre_endnode(node, hook_pre_endnode); set_hook_post_initnode(node, hook_post_initnode); set_hook_post_procnode(node, hook_post_procnode); set_hook_post_endnode(node, hook_post_endnode); set_hook_data(node, hook_data); return(node); } /* ---------------- * RMakeHookNode - Raw Make creator for HookNode * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern HookNode RMakeHookNode(); HookNode RMakeHookNode() { HookNode node = New_Node(HookNode); RInitHookNode(node); return(node); } /* ---------------- * RInitBaseNode - Raw initializer for BaseNode * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitBaseNode(); void RInitBaseNode(p) Pointer p; { extern void OutBaseNode(); extern bool EqualBaseNode(); extern bool CopyBaseNode(); BaseNode node = (BaseNode) p; node->type = classTag(BaseNode); node->outFunc = OutBaseNode; node->equalFunc = EqualBaseNode; node->copyFunc = CopyBaseNode; return; } /* ---------------- * Make creator function for BaseNode * * 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 BaseNode MakeBaseNode(); BaseNode MakeBaseNode( base_id, base_parent, base_parent_state, base_hook) int base_id ; Pointer base_parent ; Pointer base_parent_state ; HookNode base_hook; { BaseNode node = New_Node(BaseNode); RInitBaseNode(node); set_base_id(node, base_id); set_base_parent(node, base_parent); set_base_parent_state(node, base_parent_state); set_base_hook(node, base_hook); return(node); } /* ---------------- * Out function for BaseNode * ---------------- */ extern void OutBaseNode(); ; void OutBaseNode(str, node) StringInfo str; BaseNode node; { char buf[100]; #ifdef OutBaseNodeExists appendStringInfo(str, "#S("); _outBaseNode(str, node); appendStringInfo(str, ")"); #else /* OutBaseNodeExists */ sprintf(buf, "#S(BaseNode node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutBaseNodeExists */ } /* ---------------- * Equal function for BaseNode * ---------------- */ extern bool EqualBaseNode(); bool EqualBaseNode(a, b) BaseNode a, b; { #ifdef EqualBaseNodeExists return ((bool) _equalBaseNode(a, b)); #else /* EqualBaseNodeExists */ printf("EqualBaseNode does not exist!"); return (false); #endif /* EqualBaseNodeExists */ } /* ---------------- * Copy function for BaseNode * ---------------- */ extern bool CopyBaseNode(); bool CopyBaseNode(from, to, alloc) BaseNode from; BaseNode *to; /* return */ char * (*alloc)(); { #ifdef CopyBaseNodeExists return ((bool) _copyBaseNode(from, to, alloc)); #else /* CopyBaseNodeExists */ printf("CopyBaseNode does not exist!"); return (false); #endif /* CopyBaseNodeExists */ } /* ---------------- * IMakeBaseNode - Inherited Make creator for BaseNode * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern BaseNode IMakeBaseNode(); BaseNode IMakeBaseNode( base_id, base_parent, base_parent_state, base_hook) int base_id ; Pointer base_parent ; Pointer base_parent_state ; HookNode base_hook ; { BaseNode node = New_Node(BaseNode); RInitBaseNode(node); set_base_id(node, base_id); set_base_parent(node, base_parent); set_base_parent_state(node, base_parent_state); set_base_hook(node, base_hook); return(node); } /* ---------------- * RMakeBaseNode - Raw Make creator for BaseNode * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern BaseNode RMakeBaseNode(); BaseNode RMakeBaseNode() { BaseNode node = New_Node(BaseNode); RInitBaseNode(node); return(node); } /* ---------------- * RInitCommonState - Raw initializer for CommonState * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitCommonState(); void RInitCommonState(p) Pointer p; { extern void OutCommonState(); extern bool EqualCommonState(); extern bool CopyCommonState(); CommonState node = (CommonState) p; node->type = classTag(CommonState); node->outFunc = OutCommonState; node->equalFunc = EqualCommonState; node->copyFunc = CopyCommonState; return; } /* ---------------- * Make creator function for CommonState * * 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 CommonState MakeCommonState(); CommonState MakeCommonState( cs_OuterTupleSlot, cs_ResultTupleSlot, cs_ExprContext, cs_ProjInfo, cs_NumScanAttributes, cs_ScanAttributes, cs_TupFromTlist) TupleTableSlot cs_OuterTupleSlot ; TupleTableSlot cs_ResultTupleSlot ; ExprContext cs_ExprContext ; ProjectionInfo cs_ProjInfo ; int cs_NumScanAttributes ; AttributeNumberPtr cs_ScanAttributes ; bool cs_TupFromTlist; { CommonState node = New_Node(CommonState); RInitCommonState(node); set_cs_OuterTupleSlot(node, cs_OuterTupleSlot); set_cs_ResultTupleSlot(node, cs_ResultTupleSlot); set_cs_ExprContext(node, cs_ExprContext); set_cs_ProjInfo(node, cs_ProjInfo); set_cs_NumScanAttributes(node, cs_NumScanAttributes); set_cs_ScanAttributes(node, cs_ScanAttributes); set_cs_TupFromTlist(node, cs_TupFromTlist); return(node); } /* ---------------- * Out function for CommonState * ---------------- */ extern void OutCommonState(); ; void OutCommonState(str, node) StringInfo str; CommonState node; { char buf[100]; #ifdef OutCommonStateExists appendStringInfo(str, "#S("); _outCommonState(str, node); appendStringInfo(str, ")"); #else /* OutCommonStateExists */ sprintf(buf, "#S(CommonState node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutCommonStateExists */ } /* ---------------- * Equal function for CommonState * ---------------- */ extern bool EqualCommonState(); bool EqualCommonState(a, b) CommonState a, b; { #ifdef EqualCommonStateExists return ((bool) _equalCommonState(a, b)); #else /* EqualCommonStateExists */ printf("EqualCommonState does not exist!"); return (false); #endif /* EqualCommonStateExists */ } /* ---------------- * Copy function for CommonState * ---------------- */ extern bool CopyCommonState(); bool CopyCommonState(from, to, alloc) CommonState from; CommonState *to; /* return */ char * (*alloc)(); { #ifdef CopyCommonStateExists return ((bool) _copyCommonState(from, to, alloc)); #else /* CopyCommonStateExists */ printf("CopyCommonState does not exist!"); return (false); #endif /* CopyCommonStateExists */ } /* ---------------- * IMakeCommonState - Inherited Make creator for CommonState * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern CommonState IMakeCommonState(); CommonState IMakeCommonState( cs_OuterTupleSlot, cs_ResultTupleSlot, cs_ExprContext, cs_ProjInfo, cs_NumScanAttributes, cs_ScanAttributes, cs_TupFromTlist) TupleTableSlot cs_OuterTupleSlot ; TupleTableSlot cs_ResultTupleSlot ; ExprContext cs_ExprContext ; ProjectionInfo cs_ProjInfo ; int cs_NumScanAttributes ; AttributeNumberPtr cs_ScanAttributes ; bool cs_TupFromTlist ; { CommonState node = New_Node(CommonState); RInitCommonState(node); set_cs_OuterTupleSlot(node, cs_OuterTupleSlot); set_cs_ResultTupleSlot(node, cs_ResultTupleSlot); set_cs_ExprContext(node, cs_ExprContext); set_cs_ProjInfo(node, cs_ProjInfo); set_cs_NumScanAttributes(node, cs_NumScanAttributes); set_cs_ScanAttributes(node, cs_ScanAttributes); set_cs_TupFromTlist(node, cs_TupFromTlist); return(node); } /* ---------------- * RMakeCommonState - Raw Make creator for CommonState * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern CommonState RMakeCommonState(); CommonState RMakeCommonState() { CommonState node = New_Node(CommonState); RInitCommonState(node); return(node); } /* ---------------- * RInitResultState - Raw initializer for ResultState * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitResultState(); void RInitResultState(p) Pointer p; { extern void OutResultState(); extern bool EqualResultState(); extern bool CopyResultState(); ResultState node = (ResultState) p; node->type = classTag(ResultState); node->outFunc = OutResultState; node->equalFunc = EqualResultState; node->copyFunc = CopyResultState; return; } /* ---------------- * Make creator function for ResultState * * 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 ResultState MakeResultState(); ResultState MakeResultState( rs_Loop) int rs_Loop; { ResultState node = New_Node(ResultState); RInitResultState(node); set_rs_Loop(node, rs_Loop); return(node); } /* ---------------- * Out function for ResultState * ---------------- */ extern void OutResultState(); ; void OutResultState(str, node) StringInfo str; ResultState node; { char buf[100]; #ifdef OutResultStateExists appendStringInfo(str, "#S("); _outResultState(str, node); appendStringInfo(str, ")"); #else /* OutResultStateExists */ sprintf(buf, "#S(ResultState node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutResultStateExists */ } /* ---------------- * Equal function for ResultState * ---------------- */ extern bool EqualResultState(); bool EqualResultState(a, b) ResultState a, b; { #ifdef EqualResultStateExists return ((bool) _equalResultState(a, b)); #else /* EqualResultStateExists */ printf("EqualResultState does not exist!"); return (false); #endif /* EqualResultStateExists */ } /* ---------------- * Copy function for ResultState * ---------------- */ extern bool CopyResultState(); bool CopyResultState(from, to, alloc) ResultState from; ResultState *to; /* return */ char * (*alloc)(); { #ifdef CopyResultStateExists return ((bool) _copyResultState(from, to, alloc)); #else /* CopyResultStateExists */ printf("CopyResultState does not exist!"); return (false); #endif /* CopyResultStateExists */ } /* ---------------- * IMakeResultState - Inherited Make creator for ResultState * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern ResultState IMakeResultState(); ResultState IMakeResultState( rs_Loop) int rs_Loop ; { ResultState node = New_Node(ResultState); RInitResultState(node); set_rs_Loop(node, rs_Loop); return(node); } /* ---------------- * RMakeResultState - Raw Make creator for ResultState * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern ResultState RMakeResultState(); ResultState RMakeResultState() { ResultState node = New_Node(ResultState); RInitResultState(node); return(node); } /* ---------------- * RInitAppendState - Raw initializer for AppendState * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitAppendState(); void RInitAppendState(p) Pointer p; { extern void OutAppendState(); extern bool EqualAppendState(); extern bool CopyAppendState(); AppendState node = (AppendState) p; node->type = classTag(AppendState); node->outFunc = OutAppendState; node->equalFunc = EqualAppendState; node->copyFunc = CopyAppendState; return; } /* ---------------- * Make creator function for AppendState * * 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 AppendState MakeAppendState(); AppendState MakeAppendState( as_whichplan, as_nplans, as_initialized, as_rtentries) int as_whichplan; int as_nplans; ListPtr as_initialized; List as_rtentries; { AppendState node = New_Node(AppendState); RInitAppendState(node); set_as_whichplan(node, as_whichplan); set_as_nplans(node, as_nplans); set_as_initialized(node, as_initialized); set_as_rtentries(node, as_rtentries); return(node); } /* ---------------- * Out function for AppendState * ---------------- */ extern void OutAppendState(); ; void OutAppendState(str, node) StringInfo str; AppendState node; { char buf[100]; #ifdef OutAppendStateExists appendStringInfo(str, "#S("); _outAppendState(str, node); appendStringInfo(str, ")"); #else /* OutAppendStateExists */ sprintf(buf, "#S(AppendState node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutAppendStateExists */ } /* ---------------- * Equal function for AppendState * ---------------- */ extern bool EqualAppendState(); bool EqualAppendState(a, b) AppendState a, b; { #ifdef EqualAppendStateExists return ((bool) _equalAppendState(a, b)); #else /* EqualAppendStateExists */ printf("EqualAppendState does not exist!"); return (false); #endif /* EqualAppendStateExists */ } /* ---------------- * Copy function for AppendState * ---------------- */ extern bool CopyAppendState(); bool CopyAppendState(from, to, alloc) AppendState from; AppendState *to; /* return */ char * (*alloc)(); { #ifdef CopyAppendStateExists return ((bool) _copyAppendState(from, to, alloc)); #else /* CopyAppendStateExists */ printf("CopyAppendState does not exist!"); return (false); #endif /* CopyAppendStateExists */ } /* ---------------- * IMakeAppendState - Inherited Make creator for AppendState * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern AppendState IMakeAppendState(); AppendState IMakeAppendState( as_whichplan, as_nplans, as_initialized, as_rtentries) int as_whichplan ; int as_nplans ; ListPtr as_initialized ; List as_rtentries ; { AppendState node = New_Node(AppendState); RInitAppendState(node); set_as_whichplan(node, as_whichplan); set_as_nplans(node, as_nplans); set_as_initialized(node, as_initialized); set_as_rtentries(node, as_rtentries); return(node); } /* ---------------- * RMakeAppendState - Raw Make creator for AppendState * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern AppendState RMakeAppendState(); AppendState RMakeAppendState() { AppendState node = New_Node(AppendState); RInitAppendState(node); return(node); } /* ---------------- * RInitCommonScanState - Raw initializer for CommonScanState * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitCommonScanState(); void RInitCommonScanState(p) Pointer p; { extern void OutCommonScanState(); extern bool EqualCommonScanState(); extern bool CopyCommonScanState(); CommonScanState node = (CommonScanState) p; node->type = classTag(CommonScanState); node->outFunc = OutCommonScanState; node->equalFunc = EqualCommonScanState; node->copyFunc = CopyCommonScanState; return; } /* ---------------- * Make creator function for CommonScanState * * 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 CommonScanState MakeCommonScanState(); CommonScanState MakeCommonScanState( css_currentRelation, css_currentScanDesc, css_ruleInfo, css_ScanTupleSlot, css_RawTupleSlot) Relation css_currentRelation ; HeapScanDesc css_currentScanDesc ; RelationRuleInfo css_ruleInfo ; TupleTableSlot css_ScanTupleSlot ; TupleTableSlot css_RawTupleSlot; { CommonScanState node = New_Node(CommonScanState); RInitCommonScanState(node); set_css_currentRelation(node, css_currentRelation); set_css_currentScanDesc(node, css_currentScanDesc); set_css_ruleInfo(node, css_ruleInfo); set_css_ScanTupleSlot(node, css_ScanTupleSlot); set_css_RawTupleSlot(node, css_RawTupleSlot); return(node); } /* ---------------- * Out function for CommonScanState * ---------------- */ extern void OutCommonScanState(); ; void OutCommonScanState(str, node) StringInfo str; CommonScanState node; { char buf[100]; #ifdef OutCommonScanStateExists appendStringInfo(str, "#S("); _outCommonScanState(str, node); appendStringInfo(str, ")"); #else /* OutCommonScanStateExists */ sprintf(buf, "#S(CommonScanState node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutCommonScanStateExists */ } /* ---------------- * Equal function for CommonScanState * ---------------- */ extern bool EqualCommonScanState(); bool EqualCommonScanState(a, b) CommonScanState a, b; { #ifdef EqualCommonScanStateExists return ((bool) _equalCommonScanState(a, b)); #else /* EqualCommonScanStateExists */ printf("EqualCommonScanState does not exist!"); return (false); #endif /* EqualCommonScanStateExists */ } /* ---------------- * Copy function for CommonScanState * ---------------- */ extern bool CopyCommonScanState(); bool CopyCommonScanState(from, to, alloc) CommonScanState from; CommonScanState *to; /* return */ char * (*alloc)(); { #ifdef CopyCommonScanStateExists return ((bool) _copyCommonScanState(from, to, alloc)); #else /* CopyCommonScanStateExists */ printf("CopyCommonScanState does not exist!"); return (false); #endif /* CopyCommonScanStateExists */ } /* ---------------- * IMakeCommonScanState - Inherited Make creator for CommonScanState * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern CommonScanState IMakeCommonScanState(); CommonScanState IMakeCommonScanState( css_currentRelation, css_currentScanDesc, css_ruleInfo, css_ScanTupleSlot, css_RawTupleSlot) Relation css_currentRelation ; HeapScanDesc css_currentScanDesc ; RelationRuleInfo css_ruleInfo ; TupleTableSlot css_ScanTupleSlot ; TupleTableSlot css_RawTupleSlot ; { CommonScanState node = New_Node(CommonScanState); RInitCommonScanState(node); set_css_currentRelation(node, css_currentRelation); set_css_currentScanDesc(node, css_currentScanDesc); set_css_ruleInfo(node, css_ruleInfo); set_css_ScanTupleSlot(node, css_ScanTupleSlot); set_css_RawTupleSlot(node, css_RawTupleSlot); return(node); } /* ---------------- * RMakeCommonScanState - Raw Make creator for CommonScanState * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern CommonScanState RMakeCommonScanState(); CommonScanState RMakeCommonScanState() { CommonScanState node = New_Node(CommonScanState); RInitCommonScanState(node); return(node); } /* ---------------- * RInitScanState - Raw initializer for ScanState * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitScanState(); void RInitScanState(p) Pointer p; { extern void OutScanState(); extern bool EqualScanState(); extern bool CopyScanState(); ScanState node = (ScanState) p; node->type = classTag(ScanState); node->outFunc = OutScanState; node->equalFunc = EqualScanState; node->copyFunc = CopyScanState; return; } /* ---------------- * Make creator function for ScanState * * 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 ScanState MakeScanState(); ScanState MakeScanState( ss_ProcOuterFlag, ss_OldRelId) bool ss_ProcOuterFlag; Index ss_OldRelId; { ScanState node = New_Node(ScanState); RInitScanState(node); set_ss_ProcOuterFlag(node, ss_ProcOuterFlag); set_ss_OldRelId(node, ss_OldRelId); return(node); } /* ---------------- * Out function for ScanState * ---------------- */ extern void OutScanState(); ; void OutScanState(str, node) StringInfo str; ScanState node; { char buf[100]; #ifdef OutScanStateExists appendStringInfo(str, "#S("); _outScanState(str, node); appendStringInfo(str, ")"); #else /* OutScanStateExists */ sprintf(buf, "#S(ScanState node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutScanStateExists */ } /* ---------------- * Equal function for ScanState * ---------------- */ extern bool EqualScanState(); bool EqualScanState(a, b) ScanState a, b; { #ifdef EqualScanStateExists return ((bool) _equalScanState(a, b)); #else /* EqualScanStateExists */ printf("EqualScanState does not exist!"); return (false); #endif /* EqualScanStateExists */ } /* ---------------- * Copy function for ScanState * ---------------- */ extern bool CopyScanState(); bool CopyScanState(from, to, alloc) ScanState from; ScanState *to; /* return */ char * (*alloc)(); { #ifdef CopyScanStateExists return ((bool) _copyScanState(from, to, alloc)); #else /* CopyScanStateExists */ printf("CopyScanState does not exist!"); return (false); #endif /* CopyScanStateExists */ } /* ---------------- * IMakeScanState - Inherited Make creator for ScanState * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern ScanState IMakeScanState(); ScanState IMakeScanState( ss_ProcOuterFlag, ss_OldRelId) bool ss_ProcOuterFlag ; Index ss_OldRelId ; { ScanState node = New_Node(ScanState); RInitScanState(node); set_ss_ProcOuterFlag(node, ss_ProcOuterFlag); set_ss_OldRelId(node, ss_OldRelId); return(node); } /* ---------------- * RMakeScanState - Raw Make creator for ScanState * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern ScanState RMakeScanState(); ScanState RMakeScanState() { ScanState node = New_Node(ScanState); RInitScanState(node); return(node); } /* ---------------- * RInitScanTempState - Raw initializer for ScanTempState * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitScanTempState(); void RInitScanTempState(p) Pointer p; { extern void OutScanTempState(); extern bool EqualScanTempState(); extern bool CopyScanTempState(); ScanTempState node = (ScanTempState) p; node->type = classTag(ScanTempState); node->outFunc = OutScanTempState; node->equalFunc = EqualScanTempState; node->copyFunc = CopyScanTempState; return; } /* ---------------- * Make creator function for ScanTempState * * 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 ScanTempState MakeScanTempState(); ScanTempState MakeScanTempState( st_whichplan, st_nplans) int st_whichplan; int st_nplans; { ScanTempState node = New_Node(ScanTempState); RInitScanTempState(node); set_st_whichplan(node, st_whichplan); set_st_nplans(node, st_nplans); return(node); } /* ---------------- * Out function for ScanTempState * ---------------- */ extern void OutScanTempState(); ; void OutScanTempState(str, node) StringInfo str; ScanTempState node; { char buf[100]; #ifdef OutScanTempStateExists appendStringInfo(str, "#S("); _outScanTempState(str, node); appendStringInfo(str, ")"); #else /* OutScanTempStateExists */ sprintf(buf, "#S(ScanTempState node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutScanTempStateExists */ } /* ---------------- * Equal function for ScanTempState * ---------------- */ extern bool EqualScanTempState(); bool EqualScanTempState(a, b) ScanTempState a, b; { #ifdef EqualScanTempStateExists return ((bool) _equalScanTempState(a, b)); #else /* EqualScanTempStateExists */ printf("EqualScanTempState does not exist!"); return (false); #endif /* EqualScanTempStateExists */ } /* ---------------- * Copy function for ScanTempState * ---------------- */ extern bool CopyScanTempState(); bool CopyScanTempState(from, to, alloc) ScanTempState from; ScanTempState *to; /* return */ char * (*alloc)(); { #ifdef CopyScanTempStateExists return ((bool) _copyScanTempState(from, to, alloc)); #else /* CopyScanTempStateExists */ printf("CopyScanTempState does not exist!"); return (false); #endif /* CopyScanTempStateExists */ } /* ---------------- * IMakeScanTempState - Inherited Make creator for ScanTempState * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern ScanTempState IMakeScanTempState(); ScanTempState IMakeScanTempState( st_whichplan, st_nplans) int st_whichplan ; int st_nplans ; { ScanTempState node = New_Node(ScanTempState); RInitScanTempState(node); set_st_whichplan(node, st_whichplan); set_st_nplans(node, st_nplans); return(node); } /* ---------------- * RMakeScanTempState - Raw Make creator for ScanTempState * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern ScanTempState RMakeScanTempState(); ScanTempState RMakeScanTempState() { ScanTempState node = New_Node(ScanTempState); RInitScanTempState(node); return(node); } /* ---------------- * RInitIndexScanState - Raw initializer for IndexScanState * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitIndexScanState(); void RInitIndexScanState(p) Pointer p; { extern void OutIndexScanState(); extern bool EqualIndexScanState(); extern bool CopyIndexScanState(); IndexScanState node = (IndexScanState) p; node->type = classTag(IndexScanState); node->outFunc = OutIndexScanState; node->equalFunc = EqualIndexScanState; node->copyFunc = CopyIndexScanState; return; } /* ---------------- * Make creator function for IndexScanState * * 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 IndexScanState MakeIndexScanState(); IndexScanState MakeIndexScanState( iss_NumIndices, iss_IndexPtr, iss_ScanKeys, iss_NumScanKeys, iss_RuntimeKeyInfo, iss_RelationDescs, iss_ScanDescs) int iss_NumIndices; int iss_IndexPtr; ScanKeyPtr iss_ScanKeys; IntPtr iss_NumScanKeys; Pointer iss_RuntimeKeyInfo; RelationPtr iss_RelationDescs; IndexScanDescPtr iss_ScanDescs; { IndexScanState node = New_Node(IndexScanState); RInitIndexScanState(node); set_iss_NumIndices(node, iss_NumIndices); set_iss_IndexPtr(node, iss_IndexPtr); set_iss_ScanKeys(node, iss_ScanKeys); set_iss_NumScanKeys(node, iss_NumScanKeys); set_iss_RuntimeKeyInfo(node, iss_RuntimeKeyInfo); set_iss_RelationDescs(node, iss_RelationDescs); set_iss_ScanDescs(node, iss_ScanDescs); return(node); } /* ---------------- * Out function for IndexScanState * ---------------- */ extern void OutIndexScanState(); ; void OutIndexScanState(str, node) StringInfo str; IndexScanState node; { char buf[100]; #ifdef OutIndexScanStateExists appendStringInfo(str, "#S("); _outIndexScanState(str, node); appendStringInfo(str, ")"); #else /* OutIndexScanStateExists */ sprintf(buf, "#S(IndexScanState node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutIndexScanStateExists */ } /* ---------------- * Equal function for IndexScanState * ---------------- */ extern bool EqualIndexScanState(); bool EqualIndexScanState(a, b) IndexScanState a, b; { #ifdef EqualIndexScanStateExists return ((bool) _equalIndexScanState(a, b)); #else /* EqualIndexScanStateExists */ printf("EqualIndexScanState does not exist!"); return (false); #endif /* EqualIndexScanStateExists */ } /* ---------------- * Copy function for IndexScanState * ---------------- */ extern bool CopyIndexScanState(); bool CopyIndexScanState(from, to, alloc) IndexScanState from; IndexScanState *to; /* return */ char * (*alloc)(); { #ifdef CopyIndexScanStateExists return ((bool) _copyIndexScanState(from, to, alloc)); #else /* CopyIndexScanStateExists */ printf("CopyIndexScanState does not exist!"); return (false); #endif /* CopyIndexScanStateExists */ } /* ---------------- * IMakeIndexScanState - Inherited Make creator for IndexScanState * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern IndexScanState IMakeIndexScanState(); IndexScanState IMakeIndexScanState( iss_NumIndices, iss_IndexPtr, iss_ScanKeys, iss_NumScanKeys, iss_RuntimeKeyInfo, iss_RelationDescs, iss_ScanDescs) int iss_NumIndices ; int iss_IndexPtr ; ScanKeyPtr iss_ScanKeys ; IntPtr iss_NumScanKeys ; Pointer iss_RuntimeKeyInfo ; RelationPtr iss_RelationDescs ; IndexScanDescPtr iss_ScanDescs ; { IndexScanState node = New_Node(IndexScanState); RInitIndexScanState(node); set_iss_NumIndices(node, iss_NumIndices); set_iss_IndexPtr(node, iss_IndexPtr); set_iss_ScanKeys(node, iss_ScanKeys); set_iss_NumScanKeys(node, iss_NumScanKeys); set_iss_RuntimeKeyInfo(node, iss_RuntimeKeyInfo); set_iss_RelationDescs(node, iss_RelationDescs); set_iss_ScanDescs(node, iss_ScanDescs); return(node); } /* ---------------- * RMakeIndexScanState - Raw Make creator for IndexScanState * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern IndexScanState RMakeIndexScanState(); IndexScanState RMakeIndexScanState() { IndexScanState node = New_Node(IndexScanState); RInitIndexScanState(node); return(node); } /* ---------------- * RInitJoinState - Raw initializer for JoinState * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitJoinState(); void RInitJoinState(p) Pointer p; { extern void OutJoinState(); extern bool EqualJoinState(); extern bool CopyJoinState(); JoinState node = (JoinState) p; node->type = classTag(JoinState); node->outFunc = OutJoinState; node->equalFunc = EqualJoinState; node->copyFunc = CopyJoinState; return; } /* ---------------- * Make creator function for JoinState * * 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 JoinState MakeJoinState(); JoinState MakeJoinState( iss_NumIndices) { JoinState node = New_Node(JoinState); RInitJoinState(node); return(node); } /* ---------------- * Out function for JoinState * ---------------- */ extern void OutJoinState(); ; void OutJoinState(str, node) StringInfo str; JoinState node; { char buf[100]; #ifdef OutJoinStateExists appendStringInfo(str, "#S("); _outJoinState(str, node); appendStringInfo(str, ")"); #else /* OutJoinStateExists */ sprintf(buf, "#S(JoinState node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutJoinStateExists */ } /* ---------------- * Equal function for JoinState * ---------------- */ extern bool EqualJoinState(); bool EqualJoinState(a, b) JoinState a, b; { #ifdef EqualJoinStateExists return ((bool) _equalJoinState(a, b)); #else /* EqualJoinStateExists */ printf("EqualJoinState does not exist!"); return (false); #endif /* EqualJoinStateExists */ } /* ---------------- * Copy function for JoinState * ---------------- */ extern bool CopyJoinState(); bool CopyJoinState(from, to, alloc) JoinState from; JoinState *to; /* return */ char * (*alloc)(); { #ifdef CopyJoinStateExists return ((bool) _copyJoinState(from, to, alloc)); #else /* CopyJoinStateExists */ printf("CopyJoinState does not exist!"); return (false); #endif /* CopyJoinStateExists */ } /* ---------------- * IMakeJoinState - Inherited Make creator for JoinState * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern JoinState IMakeJoinState(); JoinState IMakeJoinState( ) { JoinState node = New_Node(JoinState); RInitJoinState(node); return(node); } /* ---------------- * RMakeJoinState - Raw Make creator for JoinState * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern JoinState RMakeJoinState(); JoinState RMakeJoinState() { JoinState node = New_Node(JoinState); RInitJoinState(node); return(node); } /* ---------------- * RInitNestLoopState - Raw initializer for NestLoopState * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitNestLoopState(); void RInitNestLoopState(p) Pointer p; { extern void OutNestLoopState(); extern bool EqualNestLoopState(); extern bool CopyNestLoopState(); NestLoopState node = (NestLoopState) p; node->type = classTag(NestLoopState); node->outFunc = OutNestLoopState; node->equalFunc = EqualNestLoopState; node->copyFunc = CopyNestLoopState; return; } /* ---------------- * Make creator function for NestLoopState * * 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 NestLoopState MakeNestLoopState(); NestLoopState MakeNestLoopState( nl_PortalFlag) bool nl_PortalFlag; { NestLoopState node = New_Node(NestLoopState); RInitNestLoopState(node); set_nl_PortalFlag(node, nl_PortalFlag); return(node); } /* ---------------- * Out function for NestLoopState * ---------------- */ extern void OutNestLoopState(); ; void OutNestLoopState(str, node) StringInfo str; NestLoopState node; { char buf[100]; #ifdef OutNestLoopStateExists appendStringInfo(str, "#S("); _outNestLoopState(str, node); appendStringInfo(str, ")"); #else /* OutNestLoopStateExists */ sprintf(buf, "#S(NestLoopState node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutNestLoopStateExists */ } /* ---------------- * Equal function for NestLoopState * ---------------- */ extern bool EqualNestLoopState(); bool EqualNestLoopState(a, b) NestLoopState a, b; { #ifdef EqualNestLoopStateExists return ((bool) _equalNestLoopState(a, b)); #else /* EqualNestLoopStateExists */ printf("EqualNestLoopState does not exist!"); return (false); #endif /* EqualNestLoopStateExists */ } /* ---------------- * Copy function for NestLoopState * ---------------- */ extern bool CopyNestLoopState(); bool CopyNestLoopState(from, to, alloc) NestLoopState from; NestLoopState *to; /* return */ char * (*alloc)(); { #ifdef CopyNestLoopStateExists return ((bool) _copyNestLoopState(from, to, alloc)); #else /* CopyNestLoopStateExists */ printf("CopyNestLoopState does not exist!"); return (false); #endif /* CopyNestLoopStateExists */ } /* ---------------- * IMakeNestLoopState - Inherited Make creator for NestLoopState * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern NestLoopState IMakeNestLoopState(); NestLoopState IMakeNestLoopState( nl_PortalFlag) bool nl_PortalFlag ; { NestLoopState node = New_Node(NestLoopState); RInitNestLoopState(node); set_nl_PortalFlag(node, nl_PortalFlag); return(node); } /* ---------------- * RMakeNestLoopState - Raw Make creator for NestLoopState * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern NestLoopState RMakeNestLoopState(); NestLoopState RMakeNestLoopState() { NestLoopState node = New_Node(NestLoopState); RInitNestLoopState(node); return(node); } /* ---------------- * RInitMergeJoinState - Raw initializer for MergeJoinState * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitMergeJoinState(); void RInitMergeJoinState(p) Pointer p; { extern void OutMergeJoinState(); extern bool EqualMergeJoinState(); extern bool CopyMergeJoinState(); MergeJoinState node = (MergeJoinState) p; node->type = classTag(MergeJoinState); node->outFunc = OutMergeJoinState; node->equalFunc = EqualMergeJoinState; node->copyFunc = CopyMergeJoinState; return; } /* ---------------- * Make creator function for MergeJoinState * * 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 MergeJoinState MakeMergeJoinState(); MergeJoinState MakeMergeJoinState( mj_OSortopI, mj_ISortopO, mj_JoinState, mj_MarkedTupleSlot) List mj_OSortopI; List mj_ISortopO; int mj_JoinState; TupleTableSlot mj_MarkedTupleSlot; { MergeJoinState node = New_Node(MergeJoinState); RInitMergeJoinState(node); set_mj_OSortopI(node, mj_OSortopI); set_mj_ISortopO(node, mj_ISortopO); set_mj_JoinState(node, mj_JoinState); set_mj_MarkedTupleSlot(node, mj_MarkedTupleSlot); return(node); } /* ---------------- * Out function for MergeJoinState * ---------------- */ extern void OutMergeJoinState(); ; void OutMergeJoinState(str, node) StringInfo str; MergeJoinState node; { char buf[100]; #ifdef OutMergeJoinStateExists appendStringInfo(str, "#S("); _outMergeJoinState(str, node); appendStringInfo(str, ")"); #else /* OutMergeJoinStateExists */ sprintf(buf, "#S(MergeJoinState node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutMergeJoinStateExists */ } /* ---------------- * Equal function for MergeJoinState * ---------------- */ extern bool EqualMergeJoinState(); bool EqualMergeJoinState(a, b) MergeJoinState a, b; { #ifdef EqualMergeJoinStateExists return ((bool) _equalMergeJoinState(a, b)); #else /* EqualMergeJoinStateExists */ printf("EqualMergeJoinState does not exist!"); return (false); #endif /* EqualMergeJoinStateExists */ } /* ---------------- * Copy function for MergeJoinState * ---------------- */ extern bool CopyMergeJoinState(); bool CopyMergeJoinState(from, to, alloc) MergeJoinState from; MergeJoinState *to; /* return */ char * (*alloc)(); { #ifdef CopyMergeJoinStateExists return ((bool) _copyMergeJoinState(from, to, alloc)); #else /* CopyMergeJoinStateExists */ printf("CopyMergeJoinState does not exist!"); return (false); #endif /* CopyMergeJoinStateExists */ } /* ---------------- * IMakeMergeJoinState - Inherited Make creator for MergeJoinState * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern MergeJoinState IMakeMergeJoinState(); MergeJoinState IMakeMergeJoinState( mj_OSortopI, mj_ISortopO, mj_JoinState, mj_MarkedTupleSlot) List mj_OSortopI ; List mj_ISortopO ; int mj_JoinState ; TupleTableSlot mj_MarkedTupleSlot ; { MergeJoinState node = New_Node(MergeJoinState); RInitMergeJoinState(node); set_mj_OSortopI(node, mj_OSortopI); set_mj_ISortopO(node, mj_ISortopO); set_mj_JoinState(node, mj_JoinState); set_mj_MarkedTupleSlot(node, mj_MarkedTupleSlot); return(node); } /* ---------------- * RMakeMergeJoinState - Raw Make creator for MergeJoinState * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern MergeJoinState RMakeMergeJoinState(); MergeJoinState RMakeMergeJoinState() { MergeJoinState node = New_Node(MergeJoinState); RInitMergeJoinState(node); return(node); } /* ---------------- * RInitHashJoinState - Raw initializer for HashJoinState * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitHashJoinState(); void RInitHashJoinState(p) Pointer p; { extern void OutHashJoinState(); extern bool EqualHashJoinState(); extern bool CopyHashJoinState(); HashJoinState node = (HashJoinState) p; node->type = classTag(HashJoinState); node->outFunc = OutHashJoinState; node->equalFunc = EqualHashJoinState; node->copyFunc = CopyHashJoinState; return; } /* ---------------- * Make creator function for HashJoinState * * 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 HashJoinState MakeHashJoinState(); HashJoinState MakeHashJoinState( hj_HashTable, hj_HashTableShmId, hj_CurBucket, hj_CurTuple, hj_CurOTuple, hj_InnerHashKey, hj_OuterBatches, hj_InnerBatches, hj_OuterReadPos, hj_OuterReadBlk, hj_OuterTupleSlot, hj_HashTupleSlot) HashJoinTable hj_HashTable; IpcMemoryId hj_HashTableShmId; HashBucket hj_CurBucket; HeapTuple hj_CurTuple; OverflowTuple hj_CurOTuple; Var hj_InnerHashKey; FileP hj_OuterBatches; FileP hj_InnerBatches; charP hj_OuterReadPos; int hj_OuterReadBlk; Pointer hj_OuterTupleSlot; Pointer hj_HashTupleSlot; { HashJoinState node = New_Node(HashJoinState); RInitHashJoinState(node); set_hj_HashTable(node, hj_HashTable); set_hj_HashTableShmId(node, hj_HashTableShmId); set_hj_CurBucket(node, hj_CurBucket); set_hj_CurTuple(node, hj_CurTuple); set_hj_CurOTuple(node, hj_CurOTuple); set_hj_InnerHashKey(node, hj_InnerHashKey); set_hj_OuterBatches(node, hj_OuterBatches); set_hj_InnerBatches(node, hj_InnerBatches); set_hj_OuterReadPos(node, hj_OuterReadPos); set_hj_OuterReadBlk(node, hj_OuterReadBlk); set_hj_OuterTupleSlot(node, hj_OuterTupleSlot); set_hj_HashTupleSlot(node, hj_HashTupleSlot); return(node); } /* ---------------- * Out function for HashJoinState * ---------------- */ extern void OutHashJoinState(); ; void OutHashJoinState(str, node) StringInfo str; HashJoinState node; { char buf[100]; #ifdef OutHashJoinStateExists appendStringInfo(str, "#S("); _outHashJoinState(str, node); appendStringInfo(str, ")"); #else /* OutHashJoinStateExists */ sprintf(buf, "#S(HashJoinState node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutHashJoinStateExists */ } /* ---------------- * Equal function for HashJoinState * ---------------- */ extern bool EqualHashJoinState(); bool EqualHashJoinState(a, b) HashJoinState a, b; { #ifdef EqualHashJoinStateExists return ((bool) _equalHashJoinState(a, b)); #else /* EqualHashJoinStateExists */ printf("EqualHashJoinState does not exist!"); return (false); #endif /* EqualHashJoinStateExists */ } /* ---------------- * Copy function for HashJoinState * ---------------- */ extern bool CopyHashJoinState(); bool CopyHashJoinState(from, to, alloc) HashJoinState from; HashJoinState *to; /* return */ char * (*alloc)(); { #ifdef CopyHashJoinStateExists return ((bool) _copyHashJoinState(from, to, alloc)); #else /* CopyHashJoinStateExists */ printf("CopyHashJoinState does not exist!"); return (false); #endif /* CopyHashJoinStateExists */ } /* ---------------- * IMakeHashJoinState - Inherited Make creator for HashJoinState * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern HashJoinState IMakeHashJoinState(); HashJoinState IMakeHashJoinState( hj_HashTable, hj_HashTableShmId, hj_CurBucket, hj_CurTuple, hj_CurOTuple, hj_InnerHashKey, hj_OuterBatches, hj_InnerBatches, hj_OuterReadPos, hj_OuterReadBlk, hj_OuterTupleSlot, hj_HashTupleSlot) HashJoinTable hj_HashTable ; IpcMemoryId hj_HashTableShmId ; HashBucket hj_CurBucket ; HeapTuple hj_CurTuple ; OverflowTuple hj_CurOTuple ; Var hj_InnerHashKey ; FileP hj_OuterBatches ; FileP hj_InnerBatches ; charP hj_OuterReadPos ; int hj_OuterReadBlk ; Pointer hj_OuterTupleSlot ; Pointer hj_HashTupleSlot ; { HashJoinState node = New_Node(HashJoinState); RInitHashJoinState(node); set_hj_HashTable(node, hj_HashTable); set_hj_HashTableShmId(node, hj_HashTableShmId); set_hj_CurBucket(node, hj_CurBucket); set_hj_CurTuple(node, hj_CurTuple); set_hj_CurOTuple(node, hj_CurOTuple); set_hj_InnerHashKey(node, hj_InnerHashKey); set_hj_OuterBatches(node, hj_OuterBatches); set_hj_InnerBatches(node, hj_InnerBatches); set_hj_OuterReadPos(node, hj_OuterReadPos); set_hj_OuterReadBlk(node, hj_OuterReadBlk); set_hj_OuterTupleSlot(node, hj_OuterTupleSlot); set_hj_HashTupleSlot(node, hj_HashTupleSlot); return(node); } /* ---------------- * RMakeHashJoinState - Raw Make creator for HashJoinState * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern HashJoinState RMakeHashJoinState(); HashJoinState RMakeHashJoinState() { HashJoinState node = New_Node(HashJoinState); RInitHashJoinState(node); return(node); } /* ---------------- * RInitMaterialState - Raw initializer for MaterialState * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitMaterialState(); void RInitMaterialState(p) Pointer p; { extern void OutMaterialState(); extern bool EqualMaterialState(); extern bool CopyMaterialState(); MaterialState node = (MaterialState) p; node->type = classTag(MaterialState); node->outFunc = OutMaterialState; node->equalFunc = EqualMaterialState; node->copyFunc = CopyMaterialState; return; } /* ---------------- * Make creator function for MaterialState * * 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 MaterialState MakeMaterialState(); MaterialState MakeMaterialState( mat_Flag, mat_TempRelation) bool mat_Flag; Relation mat_TempRelation; { MaterialState node = New_Node(MaterialState); RInitMaterialState(node); set_mat_Flag(node, mat_Flag); set_mat_TempRelation(node, mat_TempRelation); return(node); } /* ---------------- * Out function for MaterialState * ---------------- */ extern void OutMaterialState(); ; void OutMaterialState(str, node) StringInfo str; MaterialState node; { char buf[100]; #ifdef OutMaterialStateExists appendStringInfo(str, "#S("); _outMaterialState(str, node); appendStringInfo(str, ")"); #else /* OutMaterialStateExists */ sprintf(buf, "#S(MaterialState node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutMaterialStateExists */ } /* ---------------- * Equal function for MaterialState * ---------------- */ extern bool EqualMaterialState(); bool EqualMaterialState(a, b) MaterialState a, b; { #ifdef EqualMaterialStateExists return ((bool) _equalMaterialState(a, b)); #else /* EqualMaterialStateExists */ printf("EqualMaterialState does not exist!"); return (false); #endif /* EqualMaterialStateExists */ } /* ---------------- * Copy function for MaterialState * ---------------- */ extern bool CopyMaterialState(); bool CopyMaterialState(from, to, alloc) MaterialState from; MaterialState *to; /* return */ char * (*alloc)(); { #ifdef CopyMaterialStateExists return ((bool) _copyMaterialState(from, to, alloc)); #else /* CopyMaterialStateExists */ printf("CopyMaterialState does not exist!"); return (false); #endif /* CopyMaterialStateExists */ } /* ---------------- * IMakeMaterialState - Inherited Make creator for MaterialState * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern MaterialState IMakeMaterialState(); MaterialState IMakeMaterialState( mat_Flag, mat_TempRelation) bool mat_Flag ; Relation mat_TempRelation ; { MaterialState node = New_Node(MaterialState); RInitMaterialState(node); set_mat_Flag(node, mat_Flag); set_mat_TempRelation(node, mat_TempRelation); return(node); } /* ---------------- * RMakeMaterialState - Raw Make creator for MaterialState * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern MaterialState RMakeMaterialState(); MaterialState RMakeMaterialState() { MaterialState node = New_Node(MaterialState); RInitMaterialState(node); return(node); } /* ---------------- * RInitAggState - Raw initializer for AggState * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitAggState(); void RInitAggState(p) Pointer p; { extern void OutAggState(); extern bool EqualAggState(); extern bool CopyAggState(); AggState node = (AggState) p; node->type = classTag(AggState); node->outFunc = OutAggState; node->equalFunc = EqualAggState; node->copyFunc = CopyAggState; return; } /* ---------------- * Make creator function for AggState * * 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 AggState MakeAggState(); AggState MakeAggState( agg_Flag, agg_TempRelation) bool agg_Flag; Relation agg_TempRelation; { AggState node = New_Node(AggState); RInitAggState(node); set_agg_Flag(node, agg_Flag); set_agg_TempRelation(node, agg_TempRelation); return(node); } /* ---------------- * Out function for AggState * ---------------- */ extern void OutAggState(); ; void OutAggState(str, node) StringInfo str; AggState node; { char buf[100]; #ifdef OutAggStateExists appendStringInfo(str, "#S("); _outAggState(str, node); appendStringInfo(str, ")"); #else /* OutAggStateExists */ sprintf(buf, "#S(AggState node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutAggStateExists */ } /* ---------------- * Equal function for AggState * ---------------- */ extern bool EqualAggState(); bool EqualAggState(a, b) AggState a, b; { #ifdef EqualAggStateExists return ((bool) _equalAggState(a, b)); #else /* EqualAggStateExists */ printf("EqualAggState does not exist!"); return (false); #endif /* EqualAggStateExists */ } /* ---------------- * Copy function for AggState * ---------------- */ extern bool CopyAggState(); bool CopyAggState(from, to, alloc) AggState from; AggState *to; /* return */ char * (*alloc)(); { #ifdef CopyAggStateExists return ((bool) _copyAggState(from, to, alloc)); #else /* CopyAggStateExists */ printf("CopyAggState does not exist!"); return (false); #endif /* CopyAggStateExists */ } /* ---------------- * IMakeAggState - Inherited Make creator for AggState * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern AggState IMakeAggState(); AggState IMakeAggState( agg_Flag, agg_TempRelation) bool agg_Flag ; Relation agg_TempRelation ; { AggState node = New_Node(AggState); RInitAggState(node); set_agg_Flag(node, agg_Flag); set_agg_TempRelation(node, agg_TempRelation); return(node); } /* ---------------- * RMakeAggState - Raw Make creator for AggState * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern AggState RMakeAggState(); AggState RMakeAggState() { AggState node = New_Node(AggState); RInitAggState(node); return(node); } /* ---------------- * RInitSortState - Raw initializer for SortState * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitSortState(); void RInitSortState(p) Pointer p; { extern void OutSortState(); extern bool EqualSortState(); extern bool CopySortState(); SortState node = (SortState) p; node->type = classTag(SortState); node->outFunc = OutSortState; node->equalFunc = EqualSortState; node->copyFunc = CopySortState; return; } /* ---------------- * Make creator function for SortState * * 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 SortState MakeSortState(); SortState MakeSortState( sort_Flag, sort_Keys, sort_TempRelation) bool sort_Flag ; Pointer sort_Keys ; Relation sort_TempRelation; { SortState node = New_Node(SortState); RInitSortState(node); set_sort_Flag(node, sort_Flag); set_sort_Keys(node, sort_Keys); set_sort_TempRelation(node, sort_TempRelation); return(node); } /* ---------------- * Out function for SortState * ---------------- */ extern void OutSortState(); ; void OutSortState(str, node) StringInfo str; SortState node; { char buf[100]; #ifdef OutSortStateExists appendStringInfo(str, "#S("); _outSortState(str, node); appendStringInfo(str, ")"); #else /* OutSortStateExists */ sprintf(buf, "#S(SortState node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutSortStateExists */ } /* ---------------- * Equal function for SortState * ---------------- */ extern bool EqualSortState(); bool EqualSortState(a, b) SortState a, b; { #ifdef EqualSortStateExists return ((bool) _equalSortState(a, b)); #else /* EqualSortStateExists */ printf("EqualSortState does not exist!"); return (false); #endif /* EqualSortStateExists */ } /* ---------------- * Copy function for SortState * ---------------- */ extern bool CopySortState(); bool CopySortState(from, to, alloc) SortState from; SortState *to; /* return */ char * (*alloc)(); { #ifdef CopySortStateExists return ((bool) _copySortState(from, to, alloc)); #else /* CopySortStateExists */ printf("CopySortState does not exist!"); return (false); #endif /* CopySortStateExists */ } /* ---------------- * IMakeSortState - Inherited Make creator for SortState * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern SortState IMakeSortState(); SortState IMakeSortState( sort_Flag, sort_Keys, sort_TempRelation) bool sort_Flag ; Pointer sort_Keys ; Relation sort_TempRelation ; { SortState node = New_Node(SortState); RInitSortState(node); set_sort_Flag(node, sort_Flag); set_sort_Keys(node, sort_Keys); set_sort_TempRelation(node, sort_TempRelation); return(node); } /* ---------------- * RMakeSortState - Raw Make creator for SortState * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern SortState RMakeSortState(); SortState RMakeSortState() { SortState node = New_Node(SortState); RInitSortState(node); return(node); } /* ---------------- * RInitUniqueState - Raw initializer for UniqueState * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitUniqueState(); void RInitUniqueState(p) Pointer p; { extern void OutUniqueState(); extern bool EqualUniqueState(); extern bool CopyUniqueState(); UniqueState node = (UniqueState) p; node->type = classTag(UniqueState); node->outFunc = OutUniqueState; node->equalFunc = EqualUniqueState; node->copyFunc = CopyUniqueState; return; } /* ---------------- * Make creator function for UniqueState * * 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 UniqueState MakeUniqueState(); UniqueState MakeUniqueState( sort_Flag) { UniqueState node = New_Node(UniqueState); RInitUniqueState(node); return(node); } /* ---------------- * Out function for UniqueState * ---------------- */ extern void OutUniqueState(); ; void OutUniqueState(str, node) StringInfo str; UniqueState node; { char buf[100]; #ifdef OutUniqueStateExists appendStringInfo(str, "#S("); _outUniqueState(str, node); appendStringInfo(str, ")"); #else /* OutUniqueStateExists */ sprintf(buf, "#S(UniqueState node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutUniqueStateExists */ } /* ---------------- * Equal function for UniqueState * ---------------- */ extern bool EqualUniqueState(); bool EqualUniqueState(a, b) UniqueState a, b; { #ifdef EqualUniqueStateExists return ((bool) _equalUniqueState(a, b)); #else /* EqualUniqueStateExists */ printf("EqualUniqueState does not exist!"); return (false); #endif /* EqualUniqueStateExists */ } /* ---------------- * Copy function for UniqueState * ---------------- */ extern bool CopyUniqueState(); bool CopyUniqueState(from, to, alloc) UniqueState from; UniqueState *to; /* return */ char * (*alloc)(); { #ifdef CopyUniqueStateExists return ((bool) _copyUniqueState(from, to, alloc)); #else /* CopyUniqueStateExists */ printf("CopyUniqueState does not exist!"); return (false); #endif /* CopyUniqueStateExists */ } /* ---------------- * IMakeUniqueState - Inherited Make creator for UniqueState * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern UniqueState IMakeUniqueState(); UniqueState IMakeUniqueState( ) { UniqueState node = New_Node(UniqueState); RInitUniqueState(node); return(node); } /* ---------------- * RMakeUniqueState - Raw Make creator for UniqueState * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern UniqueState RMakeUniqueState(); UniqueState RMakeUniqueState() { UniqueState node = New_Node(UniqueState); RInitUniqueState(node); return(node); } /* ---------------- * RInitHashState - Raw initializer for HashState * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitHashState(); void RInitHashState(p) Pointer p; { extern void OutHashState(); extern bool EqualHashState(); extern bool CopyHashState(); HashState node = (HashState) p; node->type = classTag(HashState); node->outFunc = OutHashState; node->equalFunc = EqualHashState; node->copyFunc = CopyHashState; return; } /* ---------------- * Make creator function for HashState * * 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 HashState MakeHashState(); HashState MakeHashState( hashBatches) FileP hashBatches; { HashState node = New_Node(HashState); RInitHashState(node); set_hashBatches(node, hashBatches); return(node); } /* ---------------- * Out function for HashState * ---------------- */ extern void OutHashState(); ; void OutHashState(str, node) StringInfo str; HashState node; { char buf[100]; #ifdef OutHashStateExists appendStringInfo(str, "#S("); _outHashState(str, node); appendStringInfo(str, ")"); #else /* OutHashStateExists */ sprintf(buf, "#S(HashState node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutHashStateExists */ } /* ---------------- * Equal function for HashState * ---------------- */ extern bool EqualHashState(); bool EqualHashState(a, b) HashState a, b; { #ifdef EqualHashStateExists return ((bool) _equalHashState(a, b)); #else /* EqualHashStateExists */ printf("EqualHashState does not exist!"); return (false); #endif /* EqualHashStateExists */ } /* ---------------- * Copy function for HashState * ---------------- */ extern bool CopyHashState(); bool CopyHashState(from, to, alloc) HashState from; HashState *to; /* return */ char * (*alloc)(); { #ifdef CopyHashStateExists return ((bool) _copyHashState(from, to, alloc)); #else /* CopyHashStateExists */ printf("CopyHashState does not exist!"); return (false); #endif /* CopyHashStateExists */ } /* ---------------- * IMakeHashState - Inherited Make creator for HashState * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern HashState IMakeHashState(); HashState IMakeHashState( hashBatches) FileP hashBatches ; { HashState node = New_Node(HashState); RInitHashState(node); set_hashBatches(node, hashBatches); return(node); } /* ---------------- * RMakeHashState - Raw Make creator for HashState * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern HashState RMakeHashState(); HashState RMakeHashState() { HashState node = New_Node(HashState); RInitHashState(node); return(node); } /* end-of-file */