/* ---------------------------------------------------------------- * node file generated from /usr/local/src/postgres/src/backend/nodes/plannodes.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/plannodes.h" #ifdef NO_NODE_CHECKING #define NODEAssertArg(x) #else #define NODEAssertArg(x) AssertArg(x) #endif NO_NODE_CHECKING /* ---------------- * RInitPlan - Raw initializer for Plan * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitPlan(); void RInitPlan(p) Pointer p; { extern void OutPlan(); extern bool EqualPlan(); extern bool CopyPlan(); Plan node = (Plan) p; node->type = classTag(Plan); node->outFunc = OutPlan; node->equalFunc = EqualPlan; node->copyFunc = CopyPlan; return; } /* ---------------- * Make creator function for Plan * * 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 Plan MakePlan(); Plan MakePlan( cost, plan_size, plan_width, plan_tupperpage, fragment, parallel, state, qptargetlist, qpqual, lefttree, righttree) Cost cost ; Count plan_size ; Count plan_width ; Count plan_tupperpage ; int fragment ; int parallel ; EStatePtr state ; List qptargetlist ; List qpqual ; PlanPtr lefttree ; PlanPtr righttree; { Plan node = New_Node(Plan); RInitPlan(node); set_cost(node, cost); set_plan_size(node, plan_size); set_plan_width(node, plan_width); set_plan_tupperpage(node, plan_tupperpage); set_fragment(node, fragment); set_parallel(node, parallel); set_state(node, state); set_qptargetlist(node, qptargetlist); set_qpqual(node, qpqual); set_lefttree(node, lefttree); set_righttree(node, righttree); return(node); } /* ---------------- * Out function for Plan * ---------------- */ extern void OutPlan(); ; void OutPlan(str, node) StringInfo str; Plan node; { char buf[100]; #ifdef OutPlanExists appendStringInfo(str, "#S("); _outPlan(str, node); appendStringInfo(str, ")"); #else /* OutPlanExists */ sprintf(buf, "#S(Plan node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutPlanExists */ } /* ---------------- * Equal function for Plan * ---------------- */ extern bool EqualPlan(); bool EqualPlan(a, b) Plan a, b; { #ifdef EqualPlanExists return ((bool) _equalPlan(a, b)); #else /* EqualPlanExists */ printf("EqualPlan does not exist!"); return (false); #endif /* EqualPlanExists */ } /* ---------------- * Copy function for Plan * ---------------- */ extern bool CopyPlan(); bool CopyPlan(from, to, alloc) Plan from; Plan *to; /* return */ char * (*alloc)(); { #ifdef CopyPlanExists return ((bool) _copyPlan(from, to, alloc)); #else /* CopyPlanExists */ printf("CopyPlan does not exist!"); return (false); #endif /* CopyPlanExists */ } /* ---------------- * IMakePlan - Inherited Make creator for Plan * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern Plan IMakePlan(); Plan IMakePlan( cost, plan_size, plan_width, plan_tupperpage, fragment, parallel, state, qptargetlist, qpqual, lefttree, righttree) Cost cost ; Count plan_size ; Count plan_width ; Count plan_tupperpage ; int fragment ; int parallel ; EStatePtr state ; List qptargetlist ; List qpqual ; PlanPtr lefttree ; PlanPtr righttree ; { Plan node = New_Node(Plan); RInitPlan(node); set_cost(node, cost); set_plan_size(node, plan_size); set_plan_width(node, plan_width); set_plan_tupperpage(node, plan_tupperpage); set_fragment(node, fragment); set_parallel(node, parallel); set_state(node, state); set_qptargetlist(node, qptargetlist); set_qpqual(node, qpqual); set_lefttree(node, lefttree); set_righttree(node, righttree); return(node); } /* ---------------- * RMakePlan - Raw Make creator for Plan * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern Plan RMakePlan(); Plan RMakePlan() { Plan node = New_Node(Plan); RInitPlan(node); return(node); } /* ---------------- * RInitFragment - Raw initializer for Fragment * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitFragment(); void RInitFragment(p) Pointer p; { extern void OutFragment(); extern bool EqualFragment(); extern bool CopyFragment(); Fragment node = (Fragment) p; node->type = classTag(Fragment); node->outFunc = OutFragment; node->equalFunc = EqualFragment; node->copyFunc = CopyFragment; return; } /* ---------------- * Make creator function for Fragment * * 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 Fragment MakeFragment(); Fragment MakeFragment( frag_root, frag_parent_op, frag_parallel, frag_subtrees, frag_parent_frag, frag_parsetree, frag_is_inprocess, frag_iorate) Plan frag_root ; Plan frag_parent_op ; int frag_parallel ; List frag_subtrees ; FragmentPtr frag_parent_frag ; List frag_parsetree ; bool frag_is_inprocess ; float frag_iorate; { Fragment node = New_Node(Fragment); RInitFragment(node); set_frag_root(node, frag_root); set_frag_parent_op(node, frag_parent_op); set_frag_parallel(node, frag_parallel); set_frag_subtrees(node, frag_subtrees); set_frag_parent_frag(node, frag_parent_frag); set_frag_parsetree(node, frag_parsetree); set_frag_is_inprocess(node, frag_is_inprocess); set_frag_iorate(node, frag_iorate); return(node); } /* ---------------- * Out function for Fragment * ---------------- */ extern void OutFragment(); ; void OutFragment(str, node) StringInfo str; Fragment node; { char buf[100]; #ifdef OutFragmentExists appendStringInfo(str, "#S("); _outFragment(str, node); appendStringInfo(str, ")"); #else /* OutFragmentExists */ sprintf(buf, "#S(Fragment node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutFragmentExists */ } /* ---------------- * Equal function for Fragment * ---------------- */ extern bool EqualFragment(); bool EqualFragment(a, b) Fragment a, b; { #ifdef EqualFragmentExists return ((bool) _equalFragment(a, b)); #else /* EqualFragmentExists */ printf("EqualFragment does not exist!"); return (false); #endif /* EqualFragmentExists */ } /* ---------------- * Copy function for Fragment * ---------------- */ extern bool CopyFragment(); bool CopyFragment(from, to, alloc) Fragment from; Fragment *to; /* return */ char * (*alloc)(); { #ifdef CopyFragmentExists return ((bool) _copyFragment(from, to, alloc)); #else /* CopyFragmentExists */ printf("CopyFragment does not exist!"); return (false); #endif /* CopyFragmentExists */ } /* ---------------- * IMakeFragment - Inherited Make creator for Fragment * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern Fragment IMakeFragment(); Fragment IMakeFragment( frag_root, frag_parent_op, frag_parallel, frag_subtrees, frag_parent_frag, frag_parsetree, frag_is_inprocess, frag_iorate) Plan frag_root ; Plan frag_parent_op ; int frag_parallel ; List frag_subtrees ; FragmentPtr frag_parent_frag ; List frag_parsetree ; bool frag_is_inprocess ; float frag_iorate ; { Fragment node = New_Node(Fragment); RInitFragment(node); set_frag_root(node, frag_root); set_frag_parent_op(node, frag_parent_op); set_frag_parallel(node, frag_parallel); set_frag_subtrees(node, frag_subtrees); set_frag_parent_frag(node, frag_parent_frag); set_frag_parsetree(node, frag_parsetree); set_frag_is_inprocess(node, frag_is_inprocess); set_frag_iorate(node, frag_iorate); return(node); } /* ---------------- * RMakeFragment - Raw Make creator for Fragment * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern Fragment RMakeFragment(); Fragment RMakeFragment() { Fragment node = New_Node(Fragment); RInitFragment(node); return(node); } /* ---------------- * RInitExistential - Raw initializer for Existential * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitExistential(); void RInitExistential(p) Pointer p; { extern void OutExistential(); extern bool EqualExistential(); extern bool CopyExistential(); Existential node = (Existential) p; node->type = classTag(Existential); node->outFunc = OutExistential; node->equalFunc = EqualExistential; node->copyFunc = CopyExistential; return; } /* ---------------- * Make creator function for Existential * * 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 Existential MakeExistential(); Existential MakeExistential( frag_root) { Existential node = New_Node(Existential); RInitExistential(node); return(node); } /* ---------------- * Out function for Existential * ---------------- */ extern void OutExistential(); ; void OutExistential(str, node) StringInfo str; Existential node; { char buf[100]; #ifdef OutExistentialExists appendStringInfo(str, "#S("); _outExistential(str, node); appendStringInfo(str, ")"); #else /* OutExistentialExists */ sprintf(buf, "#S(Existential node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutExistentialExists */ } /* ---------------- * Equal function for Existential * ---------------- */ extern bool EqualExistential(); bool EqualExistential(a, b) Existential a, b; { #ifdef EqualExistentialExists return ((bool) _equalExistential(a, b)); #else /* EqualExistentialExists */ printf("EqualExistential does not exist!"); return (false); #endif /* EqualExistentialExists */ } /* ---------------- * Copy function for Existential * ---------------- */ extern bool CopyExistential(); bool CopyExistential(from, to, alloc) Existential from; Existential *to; /* return */ char * (*alloc)(); { #ifdef CopyExistentialExists return ((bool) _copyExistential(from, to, alloc)); #else /* CopyExistentialExists */ printf("CopyExistential does not exist!"); return (false); #endif /* CopyExistentialExists */ } /* ---------------- * IMakeExistential - Inherited Make creator for Existential * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern Existential IMakeExistential(); Existential IMakeExistential( ) { Existential node = New_Node(Existential); RInitExistential(node); return(node); } /* ---------------- * RMakeExistential - Raw Make creator for Existential * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern Existential RMakeExistential(); Existential RMakeExistential() { Existential node = New_Node(Existential); RInitExistential(node); return(node); } /* ---------------- * RInitResult - Raw initializer for Result * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitResult(); void RInitResult(p) Pointer p; { extern void OutResult(); extern bool EqualResult(); extern bool CopyResult(); Result node = (Result) p; node->type = classTag(Result); node->outFunc = OutResult; node->equalFunc = EqualResult; node->copyFunc = CopyResult; return; } /* ---------------- * Make creator function for Result * * 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 Result MakeResult(); Result MakeResult( resrellevelqual, resconstantqual, resstate) List resrellevelqual; List resconstantqual; ResultState resstate; { Result node = New_Node(Result); RInitResult(node); set_resrellevelqual(node, resrellevelqual); set_resconstantqual(node, resconstantqual); set_resstate(node, resstate); return(node); } /* ---------------- * Out function for Result * ---------------- */ extern void OutResult(); ; void OutResult(str, node) StringInfo str; Result node; { char buf[100]; #ifdef OutResultExists appendStringInfo(str, "#S("); _outResult(str, node); appendStringInfo(str, ")"); #else /* OutResultExists */ sprintf(buf, "#S(Result node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutResultExists */ } /* ---------------- * Equal function for Result * ---------------- */ extern bool EqualResult(); bool EqualResult(a, b) Result a, b; { #ifdef EqualResultExists return ((bool) _equalResult(a, b)); #else /* EqualResultExists */ printf("EqualResult does not exist!"); return (false); #endif /* EqualResultExists */ } /* ---------------- * Copy function for Result * ---------------- */ extern bool CopyResult(); bool CopyResult(from, to, alloc) Result from; Result *to; /* return */ char * (*alloc)(); { #ifdef CopyResultExists return ((bool) _copyResult(from, to, alloc)); #else /* CopyResultExists */ printf("CopyResult does not exist!"); return (false); #endif /* CopyResultExists */ } /* ---------------- * IMakeResult - Inherited Make creator for Result * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern Result IMakeResult(); Result IMakeResult( resrellevelqual, resconstantqual, resstate) List resrellevelqual ; List resconstantqual ; ResultState resstate ; { Result node = New_Node(Result); RInitResult(node); set_resrellevelqual(node, resrellevelqual); set_resconstantqual(node, resconstantqual); set_resstate(node, resstate); return(node); } /* ---------------- * RMakeResult - Raw Make creator for Result * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern Result RMakeResult(); Result RMakeResult() { Result node = New_Node(Result); RInitResult(node); return(node); } /* ---------------- * RInitAppend - Raw initializer for Append * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitAppend(); void RInitAppend(p) Pointer p; { extern void OutAppend(); extern bool EqualAppend(); extern bool CopyAppend(); Append node = (Append) p; node->type = classTag(Append); node->outFunc = OutAppend; node->equalFunc = EqualAppend; node->copyFunc = CopyAppend; return; } /* ---------------- * Make creator function for Append * * 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 Append MakeAppend(); Append MakeAppend( unionplans, unionrelid, unionrtentries, unionstate) List unionplans; Index unionrelid; List unionrtentries; AppendState unionstate; { Append node = New_Node(Append); RInitAppend(node); set_unionplans(node, unionplans); set_unionrelid(node, unionrelid); set_unionrtentries(node, unionrtentries); set_unionstate(node, unionstate); return(node); } /* ---------------- * Out function for Append * ---------------- */ extern void OutAppend(); ; void OutAppend(str, node) StringInfo str; Append node; { char buf[100]; #ifdef OutAppendExists appendStringInfo(str, "#S("); _outAppend(str, node); appendStringInfo(str, ")"); #else /* OutAppendExists */ sprintf(buf, "#S(Append node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutAppendExists */ } /* ---------------- * Equal function for Append * ---------------- */ extern bool EqualAppend(); bool EqualAppend(a, b) Append a, b; { #ifdef EqualAppendExists return ((bool) _equalAppend(a, b)); #else /* EqualAppendExists */ printf("EqualAppend does not exist!"); return (false); #endif /* EqualAppendExists */ } /* ---------------- * Copy function for Append * ---------------- */ extern bool CopyAppend(); bool CopyAppend(from, to, alloc) Append from; Append *to; /* return */ char * (*alloc)(); { #ifdef CopyAppendExists return ((bool) _copyAppend(from, to, alloc)); #else /* CopyAppendExists */ printf("CopyAppend does not exist!"); return (false); #endif /* CopyAppendExists */ } /* ---------------- * IMakeAppend - Inherited Make creator for Append * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern Append IMakeAppend(); Append IMakeAppend( unionplans, unionrelid, unionrtentries, unionstate) List unionplans ; Index unionrelid ; List unionrtentries ; AppendState unionstate ; { Append node = New_Node(Append); RInitAppend(node); set_unionplans(node, unionplans); set_unionrelid(node, unionrelid); set_unionrtentries(node, unionrtentries); set_unionstate(node, unionstate); return(node); } /* ---------------- * RMakeAppend - Raw Make creator for Append * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern Append RMakeAppend(); Append RMakeAppend() { Append node = New_Node(Append); RInitAppend(node); return(node); } /* ---------------- * RInitScan - Raw initializer for Scan * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitScan(); void RInitScan(p) Pointer p; { extern void OutScan(); extern bool EqualScan(); extern bool CopyScan(); Scan node = (Scan) p; node->type = classTag(Scan); node->outFunc = OutScan; node->equalFunc = EqualScan; node->copyFunc = CopyScan; return; } /* ---------------- * Make creator function for Scan * * 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 Scan MakeScan(); Scan MakeScan( scanrelid, scanstate) Index scanrelid ; ScanState scanstate; { Scan node = New_Node(Scan); RInitScan(node); set_scanrelid(node, scanrelid); set_scanstate(node, scanstate); return(node); } /* ---------------- * Out function for Scan * ---------------- */ extern void OutScan(); ; void OutScan(str, node) StringInfo str; Scan node; { char buf[100]; #ifdef OutScanExists appendStringInfo(str, "#S("); _outScan(str, node); appendStringInfo(str, ")"); #else /* OutScanExists */ sprintf(buf, "#S(Scan node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutScanExists */ } /* ---------------- * Equal function for Scan * ---------------- */ extern bool EqualScan(); bool EqualScan(a, b) Scan a, b; { #ifdef EqualScanExists return ((bool) _equalScan(a, b)); #else /* EqualScanExists */ printf("EqualScan does not exist!"); return (false); #endif /* EqualScanExists */ } /* ---------------- * Copy function for Scan * ---------------- */ extern bool CopyScan(); bool CopyScan(from, to, alloc) Scan from; Scan *to; /* return */ char * (*alloc)(); { #ifdef CopyScanExists return ((bool) _copyScan(from, to, alloc)); #else /* CopyScanExists */ printf("CopyScan does not exist!"); return (false); #endif /* CopyScanExists */ } /* ---------------- * IMakeScan - Inherited Make creator for Scan * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern Scan IMakeScan(); Scan IMakeScan( scanrelid, scanstate) Index scanrelid ; ScanState scanstate ; { Scan node = New_Node(Scan); RInitScan(node); set_scanrelid(node, scanrelid); set_scanstate(node, scanstate); return(node); } /* ---------------- * RMakeScan - Raw Make creator for Scan * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern Scan RMakeScan(); Scan RMakeScan() { Scan node = New_Node(Scan); RInitScan(node); return(node); } /* ---------------- * RInitSeqScan - Raw initializer for SeqScan * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitSeqScan(); void RInitSeqScan(p) Pointer p; { extern void OutSeqScan(); extern bool EqualSeqScan(); extern bool CopySeqScan(); SeqScan node = (SeqScan) p; node->type = classTag(SeqScan); node->outFunc = OutSeqScan; node->equalFunc = EqualSeqScan; node->copyFunc = CopySeqScan; return; } /* ---------------- * Make creator function for SeqScan * * 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 SeqScan MakeSeqScan(); SeqScan MakeSeqScan( scanrelid) { SeqScan node = New_Node(SeqScan); RInitSeqScan(node); return(node); } /* ---------------- * Out function for SeqScan * ---------------- */ extern void OutSeqScan(); ; void OutSeqScan(str, node) StringInfo str; SeqScan node; { char buf[100]; #ifdef OutSeqScanExists appendStringInfo(str, "#S("); _outSeqScan(str, node); appendStringInfo(str, ")"); #else /* OutSeqScanExists */ sprintf(buf, "#S(SeqScan node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutSeqScanExists */ } /* ---------------- * Equal function for SeqScan * ---------------- */ extern bool EqualSeqScan(); bool EqualSeqScan(a, b) SeqScan a, b; { #ifdef EqualSeqScanExists return ((bool) _equalSeqScan(a, b)); #else /* EqualSeqScanExists */ printf("EqualSeqScan does not exist!"); return (false); #endif /* EqualSeqScanExists */ } /* ---------------- * Copy function for SeqScan * ---------------- */ extern bool CopySeqScan(); bool CopySeqScan(from, to, alloc) SeqScan from; SeqScan *to; /* return */ char * (*alloc)(); { #ifdef CopySeqScanExists return ((bool) _copySeqScan(from, to, alloc)); #else /* CopySeqScanExists */ printf("CopySeqScan does not exist!"); return (false); #endif /* CopySeqScanExists */ } /* ---------------- * IMakeSeqScan - Inherited Make creator for SeqScan * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern SeqScan IMakeSeqScan(); SeqScan IMakeSeqScan( ) { SeqScan node = New_Node(SeqScan); RInitSeqScan(node); return(node); } /* ---------------- * RMakeSeqScan - Raw Make creator for SeqScan * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern SeqScan RMakeSeqScan(); SeqScan RMakeSeqScan() { SeqScan node = New_Node(SeqScan); RInitSeqScan(node); return(node); } /* ---------------- * RInitScanTemps - Raw initializer for ScanTemps * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitScanTemps(); void RInitScanTemps(p) Pointer p; { extern void OutScanTemps(); extern bool EqualScanTemps(); extern bool CopyScanTemps(); ScanTemps node = (ScanTemps) p; node->type = classTag(ScanTemps); node->outFunc = OutScanTemps; node->equalFunc = EqualScanTemps; node->copyFunc = CopyScanTemps; return; } /* ---------------- * Make creator function for ScanTemps * * 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 ScanTemps MakeScanTemps(); ScanTemps MakeScanTemps( temprelDescs, scantempState) List temprelDescs ; ScanTempState scantempState; { ScanTemps node = New_Node(ScanTemps); RInitScanTemps(node); set_temprelDescs(node, temprelDescs); set_scantempState(node, scantempState); return(node); } /* ---------------- * Out function for ScanTemps * ---------------- */ extern void OutScanTemps(); ; void OutScanTemps(str, node) StringInfo str; ScanTemps node; { char buf[100]; #ifdef OutScanTempsExists appendStringInfo(str, "#S("); _outScanTemps(str, node); appendStringInfo(str, ")"); #else /* OutScanTempsExists */ sprintf(buf, "#S(ScanTemps node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutScanTempsExists */ } /* ---------------- * Equal function for ScanTemps * ---------------- */ extern bool EqualScanTemps(); bool EqualScanTemps(a, b) ScanTemps a, b; { #ifdef EqualScanTempsExists return ((bool) _equalScanTemps(a, b)); #else /* EqualScanTempsExists */ printf("EqualScanTemps does not exist!"); return (false); #endif /* EqualScanTempsExists */ } /* ---------------- * Copy function for ScanTemps * ---------------- */ extern bool CopyScanTemps(); bool CopyScanTemps(from, to, alloc) ScanTemps from; ScanTemps *to; /* return */ char * (*alloc)(); { #ifdef CopyScanTempsExists return ((bool) _copyScanTemps(from, to, alloc)); #else /* CopyScanTempsExists */ printf("CopyScanTemps does not exist!"); return (false); #endif /* CopyScanTempsExists */ } /* ---------------- * IMakeScanTemps - Inherited Make creator for ScanTemps * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern ScanTemps IMakeScanTemps(); ScanTemps IMakeScanTemps( temprelDescs, scantempState) List temprelDescs ; ScanTempState scantempState ; { ScanTemps node = New_Node(ScanTemps); RInitScanTemps(node); set_temprelDescs(node, temprelDescs); set_scantempState(node, scantempState); return(node); } /* ---------------- * RMakeScanTemps - Raw Make creator for ScanTemps * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern ScanTemps RMakeScanTemps(); ScanTemps RMakeScanTemps() { ScanTemps node = New_Node(ScanTemps); RInitScanTemps(node); return(node); } /* ---------------- * RInitIndexScan - Raw initializer for IndexScan * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitIndexScan(); void RInitIndexScan(p) Pointer p; { extern void OutIndexScan(); extern bool EqualIndexScan(); extern bool CopyIndexScan(); IndexScan node = (IndexScan) p; node->type = classTag(IndexScan); node->outFunc = OutIndexScan; node->equalFunc = EqualIndexScan; node->copyFunc = CopyIndexScan; return; } /* ---------------- * Make creator function for IndexScan * * 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 IndexScan MakeIndexScan(); IndexScan MakeIndexScan( indxid, indxqual, indxstate) List indxid; List indxqual; IndexScanState indxstate; { IndexScan node = New_Node(IndexScan); RInitIndexScan(node); set_indxid(node, indxid); set_indxqual(node, indxqual); set_indxstate(node, indxstate); return(node); } /* ---------------- * Out function for IndexScan * ---------------- */ extern void OutIndexScan(); ; void OutIndexScan(str, node) StringInfo str; IndexScan node; { char buf[100]; #ifdef OutIndexScanExists appendStringInfo(str, "#S("); _outIndexScan(str, node); appendStringInfo(str, ")"); #else /* OutIndexScanExists */ sprintf(buf, "#S(IndexScan node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutIndexScanExists */ } /* ---------------- * Equal function for IndexScan * ---------------- */ extern bool EqualIndexScan(); bool EqualIndexScan(a, b) IndexScan a, b; { #ifdef EqualIndexScanExists return ((bool) _equalIndexScan(a, b)); #else /* EqualIndexScanExists */ printf("EqualIndexScan does not exist!"); return (false); #endif /* EqualIndexScanExists */ } /* ---------------- * Copy function for IndexScan * ---------------- */ extern bool CopyIndexScan(); bool CopyIndexScan(from, to, alloc) IndexScan from; IndexScan *to; /* return */ char * (*alloc)(); { #ifdef CopyIndexScanExists return ((bool) _copyIndexScan(from, to, alloc)); #else /* CopyIndexScanExists */ printf("CopyIndexScan does not exist!"); return (false); #endif /* CopyIndexScanExists */ } /* ---------------- * IMakeIndexScan - Inherited Make creator for IndexScan * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern IndexScan IMakeIndexScan(); IndexScan IMakeIndexScan( indxid, indxqual, indxstate) List indxid ; List indxqual ; IndexScanState indxstate ; { IndexScan node = New_Node(IndexScan); RInitIndexScan(node); set_indxid(node, indxid); set_indxqual(node, indxqual); set_indxstate(node, indxstate); return(node); } /* ---------------- * RMakeIndexScan - Raw Make creator for IndexScan * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern IndexScan RMakeIndexScan(); IndexScan RMakeIndexScan() { IndexScan node = New_Node(IndexScan); RInitIndexScan(node); return(node); } /* ---------------- * RInitJoinRuleInfo - Raw initializer for JoinRuleInfo * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitJoinRuleInfo(); void RInitJoinRuleInfo(p) Pointer p; { extern void OutJoinRuleInfo(); extern bool EqualJoinRuleInfo(); extern bool CopyJoinRuleInfo(); JoinRuleInfo node = (JoinRuleInfo) p; node->type = classTag(JoinRuleInfo); node->outFunc = OutJoinRuleInfo; node->equalFunc = EqualJoinRuleInfo; node->copyFunc = CopyJoinRuleInfo; return; } /* ---------------- * Make creator function for JoinRuleInfo * * 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 JoinRuleInfo MakeJoinRuleInfo(); JoinRuleInfo MakeJoinRuleInfo( jri_operator, jri_inattrno, jri_outattrno, jri_lock, jri_ruleid, jri_stubid, jri_stub, jri_stats) ObjectId jri_operator; AttributeNumber jri_inattrno; AttributeNumber jri_outattrno; RuleLock jri_lock; ObjectId jri_ruleid; Prs2StubId jri_stubid; Prs2OneStub jri_stub; Prs2StubStats jri_stats; { JoinRuleInfo node = New_Node(JoinRuleInfo); RInitJoinRuleInfo(node); set_jri_operator(node, jri_operator); set_jri_inattrno(node, jri_inattrno); set_jri_outattrno(node, jri_outattrno); set_jri_lock(node, jri_lock); set_jri_ruleid(node, jri_ruleid); set_jri_stubid(node, jri_stubid); set_jri_stub(node, jri_stub); set_jri_stats(node, jri_stats); return(node); } /* ---------------- * Out function for JoinRuleInfo * ---------------- */ extern void OutJoinRuleInfo(); ; void OutJoinRuleInfo(str, node) StringInfo str; JoinRuleInfo node; { char buf[100]; #ifdef OutJoinRuleInfoExists appendStringInfo(str, "#S("); _outJoinRuleInfo(str, node); appendStringInfo(str, ")"); #else /* OutJoinRuleInfoExists */ sprintf(buf, "#S(JoinRuleInfo node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutJoinRuleInfoExists */ } /* ---------------- * Equal function for JoinRuleInfo * ---------------- */ extern bool EqualJoinRuleInfo(); bool EqualJoinRuleInfo(a, b) JoinRuleInfo a, b; { #ifdef EqualJoinRuleInfoExists return ((bool) _equalJoinRuleInfo(a, b)); #else /* EqualJoinRuleInfoExists */ printf("EqualJoinRuleInfo does not exist!"); return (false); #endif /* EqualJoinRuleInfoExists */ } /* ---------------- * Copy function for JoinRuleInfo * ---------------- */ extern bool CopyJoinRuleInfo(); bool CopyJoinRuleInfo(from, to, alloc) JoinRuleInfo from; JoinRuleInfo *to; /* return */ char * (*alloc)(); { #ifdef CopyJoinRuleInfoExists return ((bool) _copyJoinRuleInfo(from, to, alloc)); #else /* CopyJoinRuleInfoExists */ printf("CopyJoinRuleInfo does not exist!"); return (false); #endif /* CopyJoinRuleInfoExists */ } /* ---------------- * IMakeJoinRuleInfo - Inherited Make creator for JoinRuleInfo * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern JoinRuleInfo IMakeJoinRuleInfo(); JoinRuleInfo IMakeJoinRuleInfo( jri_operator, jri_inattrno, jri_outattrno, jri_lock, jri_ruleid, jri_stubid, jri_stub, jri_stats) ObjectId jri_operator ; AttributeNumber jri_inattrno ; AttributeNumber jri_outattrno ; RuleLock jri_lock ; ObjectId jri_ruleid ; Prs2StubId jri_stubid ; Prs2OneStub jri_stub ; Prs2StubStats jri_stats ; { JoinRuleInfo node = New_Node(JoinRuleInfo); RInitJoinRuleInfo(node); set_jri_operator(node, jri_operator); set_jri_inattrno(node, jri_inattrno); set_jri_outattrno(node, jri_outattrno); set_jri_lock(node, jri_lock); set_jri_ruleid(node, jri_ruleid); set_jri_stubid(node, jri_stubid); set_jri_stub(node, jri_stub); set_jri_stats(node, jri_stats); return(node); } /* ---------------- * RMakeJoinRuleInfo - Raw Make creator for JoinRuleInfo * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern JoinRuleInfo RMakeJoinRuleInfo(); JoinRuleInfo RMakeJoinRuleInfo() { JoinRuleInfo node = New_Node(JoinRuleInfo); RInitJoinRuleInfo(node); return(node); } /* ---------------- * RInitJoin - Raw initializer for Join * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitJoin(); void RInitJoin(p) Pointer p; { extern void OutJoin(); extern bool EqualJoin(); extern bool CopyJoin(); Join node = (Join) p; node->type = classTag(Join); node->outFunc = OutJoin; node->equalFunc = EqualJoin; node->copyFunc = CopyJoin; return; } /* ---------------- * Make creator function for Join * * 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 Join MakeJoin(); Join MakeJoin( ruleinfo) JoinRuleInfoPtr ruleinfo; { Join node = New_Node(Join); RInitJoin(node); set_ruleinfo(node, ruleinfo); return(node); } /* ---------------- * Out function for Join * ---------------- */ extern void OutJoin(); ; void OutJoin(str, node) StringInfo str; Join node; { char buf[100]; #ifdef OutJoinExists appendStringInfo(str, "#S("); _outJoin(str, node); appendStringInfo(str, ")"); #else /* OutJoinExists */ sprintf(buf, "#S(Join node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutJoinExists */ } /* ---------------- * Equal function for Join * ---------------- */ extern bool EqualJoin(); bool EqualJoin(a, b) Join a, b; { #ifdef EqualJoinExists return ((bool) _equalJoin(a, b)); #else /* EqualJoinExists */ printf("EqualJoin does not exist!"); return (false); #endif /* EqualJoinExists */ } /* ---------------- * Copy function for Join * ---------------- */ extern bool CopyJoin(); bool CopyJoin(from, to, alloc) Join from; Join *to; /* return */ char * (*alloc)(); { #ifdef CopyJoinExists return ((bool) _copyJoin(from, to, alloc)); #else /* CopyJoinExists */ printf("CopyJoin does not exist!"); return (false); #endif /* CopyJoinExists */ } /* ---------------- * IMakeJoin - Inherited Make creator for Join * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern Join IMakeJoin(); Join IMakeJoin( ruleinfo) JoinRuleInfoPtr ruleinfo ; { Join node = New_Node(Join); RInitJoin(node); set_ruleinfo(node, ruleinfo); return(node); } /* ---------------- * RMakeJoin - Raw Make creator for Join * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern Join RMakeJoin(); Join RMakeJoin() { Join node = New_Node(Join); RInitJoin(node); return(node); } /* ---------------- * RInitNestLoop - Raw initializer for NestLoop * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitNestLoop(); void RInitNestLoop(p) Pointer p; { extern void OutNestLoop(); extern bool EqualNestLoop(); extern bool CopyNestLoop(); NestLoop node = (NestLoop) p; node->type = classTag(NestLoop); node->outFunc = OutNestLoop; node->equalFunc = EqualNestLoop; node->copyFunc = CopyNestLoop; return; } /* ---------------- * Make creator function for NestLoop * * 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 NestLoop MakeNestLoop(); NestLoop MakeNestLoop( nlstate, nlRuleInfo) NestLoopState nlstate; JoinRuleInfo nlRuleInfo; { NestLoop node = New_Node(NestLoop); RInitNestLoop(node); set_nlstate(node, nlstate); set_nlRuleInfo(node, nlRuleInfo); return(node); } /* ---------------- * Out function for NestLoop * ---------------- */ extern void OutNestLoop(); ; void OutNestLoop(str, node) StringInfo str; NestLoop node; { char buf[100]; #ifdef OutNestLoopExists appendStringInfo(str, "#S("); _outNestLoop(str, node); appendStringInfo(str, ")"); #else /* OutNestLoopExists */ sprintf(buf, "#S(NestLoop node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutNestLoopExists */ } /* ---------------- * Equal function for NestLoop * ---------------- */ extern bool EqualNestLoop(); bool EqualNestLoop(a, b) NestLoop a, b; { #ifdef EqualNestLoopExists return ((bool) _equalNestLoop(a, b)); #else /* EqualNestLoopExists */ printf("EqualNestLoop does not exist!"); return (false); #endif /* EqualNestLoopExists */ } /* ---------------- * Copy function for NestLoop * ---------------- */ extern bool CopyNestLoop(); bool CopyNestLoop(from, to, alloc) NestLoop from; NestLoop *to; /* return */ char * (*alloc)(); { #ifdef CopyNestLoopExists return ((bool) _copyNestLoop(from, to, alloc)); #else /* CopyNestLoopExists */ printf("CopyNestLoop does not exist!"); return (false); #endif /* CopyNestLoopExists */ } /* ---------------- * IMakeNestLoop - Inherited Make creator for NestLoop * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern NestLoop IMakeNestLoop(); NestLoop IMakeNestLoop( nlstate, nlRuleInfo) NestLoopState nlstate ; JoinRuleInfo nlRuleInfo ; { NestLoop node = New_Node(NestLoop); RInitNestLoop(node); set_nlstate(node, nlstate); set_nlRuleInfo(node, nlRuleInfo); return(node); } /* ---------------- * RMakeNestLoop - Raw Make creator for NestLoop * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern NestLoop RMakeNestLoop(); NestLoop RMakeNestLoop() { NestLoop node = New_Node(NestLoop); RInitNestLoop(node); return(node); } /* ---------------- * RInitMergeJoin - Raw initializer for MergeJoin * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitMergeJoin(); void RInitMergeJoin(p) Pointer p; { extern void OutMergeJoin(); extern bool EqualMergeJoin(); extern bool CopyMergeJoin(); MergeJoin node = (MergeJoin) p; node->type = classTag(MergeJoin); node->outFunc = OutMergeJoin; node->equalFunc = EqualMergeJoin; node->copyFunc = CopyMergeJoin; return; } /* ---------------- * Make creator function for MergeJoin * * 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 MergeJoin MakeMergeJoin(); MergeJoin MakeMergeJoin( mergeclauses, mergesortop, mergerightorder, mergeleftorder, mergestate) List mergeclauses; ObjectId mergesortop; List mergerightorder; List mergeleftorder; MergeJoinState mergestate; { MergeJoin node = New_Node(MergeJoin); RInitMergeJoin(node); set_mergeclauses(node, mergeclauses); set_mergesortop(node, mergesortop); set_mergerightorder(node, mergerightorder); set_mergeleftorder(node, mergeleftorder); set_mergestate(node, mergestate); return(node); } /* ---------------- * Out function for MergeJoin * ---------------- */ extern void OutMergeJoin(); ; void OutMergeJoin(str, node) StringInfo str; MergeJoin node; { char buf[100]; #ifdef OutMergeJoinExists appendStringInfo(str, "#S("); _outMergeJoin(str, node); appendStringInfo(str, ")"); #else /* OutMergeJoinExists */ sprintf(buf, "#S(MergeJoin node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutMergeJoinExists */ } /* ---------------- * Equal function for MergeJoin * ---------------- */ extern bool EqualMergeJoin(); bool EqualMergeJoin(a, b) MergeJoin a, b; { #ifdef EqualMergeJoinExists return ((bool) _equalMergeJoin(a, b)); #else /* EqualMergeJoinExists */ printf("EqualMergeJoin does not exist!"); return (false); #endif /* EqualMergeJoinExists */ } /* ---------------- * Copy function for MergeJoin * ---------------- */ extern bool CopyMergeJoin(); bool CopyMergeJoin(from, to, alloc) MergeJoin from; MergeJoin *to; /* return */ char * (*alloc)(); { #ifdef CopyMergeJoinExists return ((bool) _copyMergeJoin(from, to, alloc)); #else /* CopyMergeJoinExists */ printf("CopyMergeJoin does not exist!"); return (false); #endif /* CopyMergeJoinExists */ } /* ---------------- * IMakeMergeJoin - Inherited Make creator for MergeJoin * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern MergeJoin IMakeMergeJoin(); MergeJoin IMakeMergeJoin( mergeclauses, mergesortop, mergerightorder, mergeleftorder, mergestate) List mergeclauses ; ObjectId mergesortop ; List mergerightorder ; List mergeleftorder ; MergeJoinState mergestate ; { MergeJoin node = New_Node(MergeJoin); RInitMergeJoin(node); set_mergeclauses(node, mergeclauses); set_mergesortop(node, mergesortop); set_mergerightorder(node, mergerightorder); set_mergeleftorder(node, mergeleftorder); set_mergestate(node, mergestate); return(node); } /* ---------------- * RMakeMergeJoin - Raw Make creator for MergeJoin * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern MergeJoin RMakeMergeJoin(); MergeJoin RMakeMergeJoin() { MergeJoin node = New_Node(MergeJoin); RInitMergeJoin(node); return(node); } /* ---------------- * RInitHashJoin - Raw initializer for HashJoin * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitHashJoin(); void RInitHashJoin(p) Pointer p; { extern void OutHashJoin(); extern bool EqualHashJoin(); extern bool CopyHashJoin(); HashJoin node = (HashJoin) p; node->type = classTag(HashJoin); node->outFunc = OutHashJoin; node->equalFunc = EqualHashJoin; node->copyFunc = CopyHashJoin; return; } /* ---------------- * Make creator function for HashJoin * * 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 HashJoin MakeHashJoin(); HashJoin MakeHashJoin( hashclauses, hashjoinop, hashjoinstate, hashjointable, hashjointablekey, hashjointablesize, hashdone) List hashclauses; ObjectId hashjoinop; HashJoinState hashjoinstate; HashJoinTable hashjointable; IpcMemoryKey hashjointablekey; int hashjointablesize; bool hashdone; { HashJoin node = New_Node(HashJoin); RInitHashJoin(node); set_hashclauses(node, hashclauses); set_hashjoinop(node, hashjoinop); set_hashjoinstate(node, hashjoinstate); set_hashjointable(node, hashjointable); set_hashjointablekey(node, hashjointablekey); set_hashjointablesize(node, hashjointablesize); set_hashdone(node, hashdone); return(node); } /* ---------------- * Out function for HashJoin * ---------------- */ extern void OutHashJoin(); ; void OutHashJoin(str, node) StringInfo str; HashJoin node; { char buf[100]; #ifdef OutHashJoinExists appendStringInfo(str, "#S("); _outHashJoin(str, node); appendStringInfo(str, ")"); #else /* OutHashJoinExists */ sprintf(buf, "#S(HashJoin node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutHashJoinExists */ } /* ---------------- * Equal function for HashJoin * ---------------- */ extern bool EqualHashJoin(); bool EqualHashJoin(a, b) HashJoin a, b; { #ifdef EqualHashJoinExists return ((bool) _equalHashJoin(a, b)); #else /* EqualHashJoinExists */ printf("EqualHashJoin does not exist!"); return (false); #endif /* EqualHashJoinExists */ } /* ---------------- * Copy function for HashJoin * ---------------- */ extern bool CopyHashJoin(); bool CopyHashJoin(from, to, alloc) HashJoin from; HashJoin *to; /* return */ char * (*alloc)(); { #ifdef CopyHashJoinExists return ((bool) _copyHashJoin(from, to, alloc)); #else /* CopyHashJoinExists */ printf("CopyHashJoin does not exist!"); return (false); #endif /* CopyHashJoinExists */ } /* ---------------- * IMakeHashJoin - Inherited Make creator for HashJoin * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern HashJoin IMakeHashJoin(); HashJoin IMakeHashJoin( hashclauses, hashjoinop, hashjoinstate, hashjointable, hashjointablekey, hashjointablesize, hashdone) List hashclauses ; ObjectId hashjoinop ; HashJoinState hashjoinstate ; HashJoinTable hashjointable ; IpcMemoryKey hashjointablekey ; int hashjointablesize ; bool hashdone ; { HashJoin node = New_Node(HashJoin); RInitHashJoin(node); set_hashclauses(node, hashclauses); set_hashjoinop(node, hashjoinop); set_hashjoinstate(node, hashjoinstate); set_hashjointable(node, hashjointable); set_hashjointablekey(node, hashjointablekey); set_hashjointablesize(node, hashjointablesize); set_hashdone(node, hashdone); return(node); } /* ---------------- * RMakeHashJoin - Raw Make creator for HashJoin * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern HashJoin RMakeHashJoin(); HashJoin RMakeHashJoin() { HashJoin node = New_Node(HashJoin); RInitHashJoin(node); return(node); } /* ---------------- * RInitTemp - Raw initializer for Temp * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitTemp(); void RInitTemp(p) Pointer p; { extern void OutTemp(); extern bool EqualTemp(); extern bool CopyTemp(); Temp node = (Temp) p; node->type = classTag(Temp); node->outFunc = OutTemp; node->equalFunc = EqualTemp; node->copyFunc = CopyTemp; return; } /* ---------------- * Make creator function for Temp * * 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 Temp MakeTemp(); Temp MakeTemp( tempid, keycount) ObjectId tempid ; Count keycount; { Temp node = New_Node(Temp); RInitTemp(node); set_tempid(node, tempid); set_keycount(node, keycount); return(node); } /* ---------------- * Out function for Temp * ---------------- */ extern void OutTemp(); ; void OutTemp(str, node) StringInfo str; Temp node; { char buf[100]; #ifdef OutTempExists appendStringInfo(str, "#S("); _outTemp(str, node); appendStringInfo(str, ")"); #else /* OutTempExists */ sprintf(buf, "#S(Temp node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutTempExists */ } /* ---------------- * Equal function for Temp * ---------------- */ extern bool EqualTemp(); bool EqualTemp(a, b) Temp a, b; { #ifdef EqualTempExists return ((bool) _equalTemp(a, b)); #else /* EqualTempExists */ printf("EqualTemp does not exist!"); return (false); #endif /* EqualTempExists */ } /* ---------------- * Copy function for Temp * ---------------- */ extern bool CopyTemp(); bool CopyTemp(from, to, alloc) Temp from; Temp *to; /* return */ char * (*alloc)(); { #ifdef CopyTempExists return ((bool) _copyTemp(from, to, alloc)); #else /* CopyTempExists */ printf("CopyTemp does not exist!"); return (false); #endif /* CopyTempExists */ } /* ---------------- * IMakeTemp - Inherited Make creator for Temp * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern Temp IMakeTemp(); Temp IMakeTemp( tempid, keycount) ObjectId tempid ; Count keycount ; { Temp node = New_Node(Temp); RInitTemp(node); set_tempid(node, tempid); set_keycount(node, keycount); return(node); } /* ---------------- * RMakeTemp - Raw Make creator for Temp * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern Temp RMakeTemp(); Temp RMakeTemp() { Temp node = New_Node(Temp); RInitTemp(node); return(node); } /* ---------------- * RInitMaterial - Raw initializer for Material * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitMaterial(); void RInitMaterial(p) Pointer p; { extern void OutMaterial(); extern bool EqualMaterial(); extern bool CopyMaterial(); Material node = (Material) p; node->type = classTag(Material); node->outFunc = OutMaterial; node->equalFunc = EqualMaterial; node->copyFunc = CopyMaterial; return; } /* ---------------- * Make creator function for Material * * 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 Material MakeMaterial(); Material MakeMaterial( matstate) MaterialState matstate; { Material node = New_Node(Material); RInitMaterial(node); set_matstate(node, matstate); return(node); } /* ---------------- * Out function for Material * ---------------- */ extern void OutMaterial(); ; void OutMaterial(str, node) StringInfo str; Material node; { char buf[100]; #ifdef OutMaterialExists appendStringInfo(str, "#S("); _outMaterial(str, node); appendStringInfo(str, ")"); #else /* OutMaterialExists */ sprintf(buf, "#S(Material node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutMaterialExists */ } /* ---------------- * Equal function for Material * ---------------- */ extern bool EqualMaterial(); bool EqualMaterial(a, b) Material a, b; { #ifdef EqualMaterialExists return ((bool) _equalMaterial(a, b)); #else /* EqualMaterialExists */ printf("EqualMaterial does not exist!"); return (false); #endif /* EqualMaterialExists */ } /* ---------------- * Copy function for Material * ---------------- */ extern bool CopyMaterial(); bool CopyMaterial(from, to, alloc) Material from; Material *to; /* return */ char * (*alloc)(); { #ifdef CopyMaterialExists return ((bool) _copyMaterial(from, to, alloc)); #else /* CopyMaterialExists */ printf("CopyMaterial does not exist!"); return (false); #endif /* CopyMaterialExists */ } /* ---------------- * IMakeMaterial - Inherited Make creator for Material * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern Material IMakeMaterial(); Material IMakeMaterial( matstate) MaterialState matstate ; { Material node = New_Node(Material); RInitMaterial(node); set_matstate(node, matstate); return(node); } /* ---------------- * RMakeMaterial - Raw Make creator for Material * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern Material RMakeMaterial(); Material RMakeMaterial() { Material node = New_Node(Material); RInitMaterial(node); return(node); } /* ---------------- * RInitSort - Raw initializer for Sort * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitSort(); void RInitSort(p) Pointer p; { extern void OutSort(); extern bool EqualSort(); extern bool CopySort(); Sort node = (Sort) p; node->type = classTag(Sort); node->outFunc = OutSort; node->equalFunc = EqualSort; node->copyFunc = CopySort; return; } /* ---------------- * Make creator function for Sort * * 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 Sort MakeSort(); Sort MakeSort( sortstate) SortState sortstate; { Sort node = New_Node(Sort); RInitSort(node); set_sortstate(node, sortstate); return(node); } /* ---------------- * Out function for Sort * ---------------- */ extern void OutSort(); ; void OutSort(str, node) StringInfo str; Sort node; { char buf[100]; #ifdef OutSortExists appendStringInfo(str, "#S("); _outSort(str, node); appendStringInfo(str, ")"); #else /* OutSortExists */ sprintf(buf, "#S(Sort node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutSortExists */ } /* ---------------- * Equal function for Sort * ---------------- */ extern bool EqualSort(); bool EqualSort(a, b) Sort a, b; { #ifdef EqualSortExists return ((bool) _equalSort(a, b)); #else /* EqualSortExists */ printf("EqualSort does not exist!"); return (false); #endif /* EqualSortExists */ } /* ---------------- * Copy function for Sort * ---------------- */ extern bool CopySort(); bool CopySort(from, to, alloc) Sort from; Sort *to; /* return */ char * (*alloc)(); { #ifdef CopySortExists return ((bool) _copySort(from, to, alloc)); #else /* CopySortExists */ printf("CopySort does not exist!"); return (false); #endif /* CopySortExists */ } /* ---------------- * IMakeSort - Inherited Make creator for Sort * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern Sort IMakeSort(); Sort IMakeSort( sortstate) SortState sortstate ; { Sort node = New_Node(Sort); RInitSort(node); set_sortstate(node, sortstate); return(node); } /* ---------------- * RMakeSort - Raw Make creator for Sort * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern Sort RMakeSort(); Sort RMakeSort() { Sort node = New_Node(Sort); RInitSort(node); return(node); } /* ---------------- * RInitAgg - Raw initializer for Agg * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitAgg(); void RInitAgg(p) Pointer p; { extern void OutAgg(); extern bool EqualAgg(); extern bool CopyAgg(); Agg node = (Agg) p; node->type = classTag(Agg); node->outFunc = OutAgg; node->equalFunc = EqualAgg; node->copyFunc = CopyAgg; return; } /* ---------------- * Make creator function for Agg * * 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 Agg MakeAgg(); Agg MakeAgg( aggname, aggstate) String aggname ; AggState aggstate; { Agg node = New_Node(Agg); RInitAgg(node); set_aggname(node, aggname); set_aggstate(node, aggstate); return(node); } /* ---------------- * Out function for Agg * ---------------- */ extern void OutAgg(); ; void OutAgg(str, node) StringInfo str; Agg node; { char buf[100]; #ifdef OutAggExists appendStringInfo(str, "#S("); _outAgg(str, node); appendStringInfo(str, ")"); #else /* OutAggExists */ sprintf(buf, "#S(Agg node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutAggExists */ } /* ---------------- * Equal function for Agg * ---------------- */ extern bool EqualAgg(); bool EqualAgg(a, b) Agg a, b; { #ifdef EqualAggExists return ((bool) _equalAgg(a, b)); #else /* EqualAggExists */ printf("EqualAgg does not exist!"); return (false); #endif /* EqualAggExists */ } /* ---------------- * Copy function for Agg * ---------------- */ extern bool CopyAgg(); bool CopyAgg(from, to, alloc) Agg from; Agg *to; /* return */ char * (*alloc)(); { #ifdef CopyAggExists return ((bool) _copyAgg(from, to, alloc)); #else /* CopyAggExists */ printf("CopyAgg does not exist!"); return (false); #endif /* CopyAggExists */ } /* ---------------- * IMakeAgg - Inherited Make creator for Agg * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern Agg IMakeAgg(); Agg IMakeAgg( aggname, aggstate) String aggname ; AggState aggstate ; { Agg node = New_Node(Agg); RInitAgg(node); set_aggname(node, aggname); set_aggstate(node, aggstate); return(node); } /* ---------------- * RMakeAgg - Raw Make creator for Agg * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern Agg RMakeAgg(); Agg RMakeAgg() { Agg node = New_Node(Agg); RInitAgg(node); return(node); } /* ---------------- * RInitUnique - Raw initializer for Unique * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitUnique(); void RInitUnique(p) Pointer p; { extern void OutUnique(); extern bool EqualUnique(); extern bool CopyUnique(); Unique node = (Unique) p; node->type = classTag(Unique); node->outFunc = OutUnique; node->equalFunc = EqualUnique; node->copyFunc = CopyUnique; return; } /* ---------------- * Make creator function for Unique * * 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 Unique MakeUnique(); Unique MakeUnique( uniquestate) UniqueState uniquestate; { Unique node = New_Node(Unique); RInitUnique(node); set_uniquestate(node, uniquestate); return(node); } /* ---------------- * Out function for Unique * ---------------- */ extern void OutUnique(); ; void OutUnique(str, node) StringInfo str; Unique node; { char buf[100]; #ifdef OutUniqueExists appendStringInfo(str, "#S("); _outUnique(str, node); appendStringInfo(str, ")"); #else /* OutUniqueExists */ sprintf(buf, "#S(Unique node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutUniqueExists */ } /* ---------------- * Equal function for Unique * ---------------- */ extern bool EqualUnique(); bool EqualUnique(a, b) Unique a, b; { #ifdef EqualUniqueExists return ((bool) _equalUnique(a, b)); #else /* EqualUniqueExists */ printf("EqualUnique does not exist!"); return (false); #endif /* EqualUniqueExists */ } /* ---------------- * Copy function for Unique * ---------------- */ extern bool CopyUnique(); bool CopyUnique(from, to, alloc) Unique from; Unique *to; /* return */ char * (*alloc)(); { #ifdef CopyUniqueExists return ((bool) _copyUnique(from, to, alloc)); #else /* CopyUniqueExists */ printf("CopyUnique does not exist!"); return (false); #endif /* CopyUniqueExists */ } /* ---------------- * IMakeUnique - Inherited Make creator for Unique * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern Unique IMakeUnique(); Unique IMakeUnique( uniquestate) UniqueState uniquestate ; { Unique node = New_Node(Unique); RInitUnique(node); set_uniquestate(node, uniquestate); return(node); } /* ---------------- * RMakeUnique - Raw Make creator for Unique * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern Unique RMakeUnique(); Unique RMakeUnique() { Unique node = New_Node(Unique); RInitUnique(node); return(node); } /* ---------------- * RInitHash - Raw initializer for Hash * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitHash(); void RInitHash(p) Pointer p; { extern void OutHash(); extern bool EqualHash(); extern bool CopyHash(); Hash node = (Hash) p; node->type = classTag(Hash); node->outFunc = OutHash; node->equalFunc = EqualHash; node->copyFunc = CopyHash; return; } /* ---------------- * Make creator function for Hash * * 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 Hash MakeHash(); Hash MakeHash( hashkey, hashstate, hashtable, hashtablekey, hashtablesize) Var hashkey ; HashState hashstate ; HashJoinTable hashtable ; IpcMemoryKey hashtablekey ; int hashtablesize; { Hash node = New_Node(Hash); RInitHash(node); set_hashkey(node, hashkey); set_hashstate(node, hashstate); set_hashtable(node, hashtable); set_hashtablekey(node, hashtablekey); set_hashtablesize(node, hashtablesize); return(node); } /* ---------------- * Out function for Hash * ---------------- */ extern void OutHash(); ; void OutHash(str, node) StringInfo str; Hash node; { char buf[100]; #ifdef OutHashExists appendStringInfo(str, "#S("); _outHash(str, node); appendStringInfo(str, ")"); #else /* OutHashExists */ sprintf(buf, "#S(Hash node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutHashExists */ } /* ---------------- * Equal function for Hash * ---------------- */ extern bool EqualHash(); bool EqualHash(a, b) Hash a, b; { #ifdef EqualHashExists return ((bool) _equalHash(a, b)); #else /* EqualHashExists */ printf("EqualHash does not exist!"); return (false); #endif /* EqualHashExists */ } /* ---------------- * Copy function for Hash * ---------------- */ extern bool CopyHash(); bool CopyHash(from, to, alloc) Hash from; Hash *to; /* return */ char * (*alloc)(); { #ifdef CopyHashExists return ((bool) _copyHash(from, to, alloc)); #else /* CopyHashExists */ printf("CopyHash does not exist!"); return (false); #endif /* CopyHashExists */ } /* ---------------- * IMakeHash - Inherited Make creator for Hash * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern Hash IMakeHash(); Hash IMakeHash( hashkey, hashstate, hashtable, hashtablekey, hashtablesize) Var hashkey ; HashState hashstate ; HashJoinTable hashtable ; IpcMemoryKey hashtablekey ; int hashtablesize ; { Hash node = New_Node(Hash); RInitHash(node); set_hashkey(node, hashkey); set_hashstate(node, hashstate); set_hashtable(node, hashtable); set_hashtablekey(node, hashtablekey); set_hashtablesize(node, hashtablesize); return(node); } /* ---------------- * RMakeHash - Raw Make creator for Hash * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern Hash RMakeHash(); Hash RMakeHash() { Hash node = New_Node(Hash); RInitHash(node); return(node); } /* ---------------- * RInitChoose - Raw initializer for Choose * * This function just initializes the internal * information in a node. * ---------------- */ extern void RInitChoose(); void RInitChoose(p) Pointer p; { extern void OutChoose(); extern bool EqualChoose(); extern bool CopyChoose(); Choose node = (Choose) p; node->type = classTag(Choose); node->outFunc = OutChoose; node->equalFunc = EqualChoose; node->copyFunc = CopyChoose; return; } /* ---------------- * Make creator function for Choose * * 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 Choose MakeChoose(); Choose MakeChoose( chooseplanlist) List chooseplanlist; { Choose node = New_Node(Choose); RInitChoose(node); set_chooseplanlist(node, chooseplanlist); return(node); } /* ---------------- * Out function for Choose * ---------------- */ extern void OutChoose(); ; void OutChoose(str, node) StringInfo str; Choose node; { char buf[100]; #ifdef OutChooseExists appendStringInfo(str, "#S("); _outChoose(str, node); appendStringInfo(str, ")"); #else /* OutChooseExists */ sprintf(buf, "#S(Choose node at 0x%lx)", node); appendStringInfo(str, buf); #endif /* OutChooseExists */ } /* ---------------- * Equal function for Choose * ---------------- */ extern bool EqualChoose(); bool EqualChoose(a, b) Choose a, b; { #ifdef EqualChooseExists return ((bool) _equalChoose(a, b)); #else /* EqualChooseExists */ printf("EqualChoose does not exist!"); return (false); #endif /* EqualChooseExists */ } /* ---------------- * Copy function for Choose * ---------------- */ extern bool CopyChoose(); bool CopyChoose(from, to, alloc) Choose from; Choose *to; /* return */ char * (*alloc)(); { #ifdef CopyChooseExists return ((bool) _copyChoose(from, to, alloc)); #else /* CopyChooseExists */ printf("CopyChoose does not exist!"); return (false); #endif /* CopyChooseExists */ } /* ---------------- * IMakeChoose - Inherited Make creator for Choose * * This creator function takes a parameter * for each slot in this class and each slot * in all inherited classes. * ---------------- */ extern Choose IMakeChoose(); Choose IMakeChoose( chooseplanlist) List chooseplanlist ; { Choose node = New_Node(Choose); RInitChoose(node); set_chooseplanlist(node, chooseplanlist); return(node); } /* ---------------- * RMakeChoose - Raw Make creator for Choose * * This creator function does not initialize * any of its slots.. This is left up to the * calling routine. * ---------------- */ extern Choose RMakeChoose(); Choose RMakeChoose() { Choose node = New_Node(Choose); RInitChoose(node); return(node); } /* end-of-file */