Polaris: Assertion.cc Source File

Assertion.cc Go to the documentation of this file. /// #ifdef POLARIS_GNU_PRAGMAS #pragma implementation "Assertion.h" #pragma implementation "ExpressionAssertion.h" #pragma implementation "ARDAssertion.h" #pragma implementation "StringAssertion.h" #pragma implementation "AssertionList.h" #pragma implementation "AssertComment.h" #pragma implementation "AssertCritical.h" #pragma implementation "AssertEpilogue.h" #pragma implementation "AssertInduction.h" #pragma implementation "AssertLastValue.h" #pragma implementation "AssertParallel.h" #pragma implementation "AssertPrivate.h" #pragma implementation "AssertPrologue.h" #pragma implementation "AssertReduction.h" #pragma implementation "AssertRelation.h" #pragma implementation "AssertSerial.h" #pragma implementation "AssertSubst.h" #pragma implementation "AssertLoopLabel.h" #pragma implementation "AssertMayMod.h" #pragma implementation "AssertNoMod.h" //Begin OpenMP Modification #pragma implementation "AssertNoWait.h" //End OpenMP Modification #pragma implementation "AssertShared.h" #pragma implementation "AssertFirstValue.h" #pragma implementation "AssertPrivateRefs.h" #pragma implementation "AssertReadOnlyRefs.h" #pragma implementation "AssertSharedRefs.h" #pragma implementation "AssertRTShadow.h" #pragma implementation "AssertDepIO.h" #pragma implementation "AssertInline.h" #pragma implementation "AssertRecursiveInline.h" #pragma implementation "AssertNoInline.h" #pragma implementation "AssertRunTimeTest.h" #pragma implementation "AssertNoPutGet.h" #pragma implementation "AssertSchedule.h" #pragma implementation "AssertDynLastValue.h" #pragma implementation "AssertRangeWritten.h" #pragma implementation "AssertNoDependence.h" #pragma implementation "AssertSideEffectFree.h" #pragma implementation "AssertPreamble.h" #pragma implementation "AssertPostamble.h" #pragma implementation "AssertParallelCondition.h" #pragma implementation "AssertSafeCondition.h" #pragma implementation "AssertOverlap.h" #pragma implementation "AssertOverlapSort.h" #pragma implementation "AssertPrivateDescr.h" #pragma implementation "AssertTestMonotone.h" #pragma implementation "AssertReductDescr.h" #pragma implementation "AssertDepOverlap.h" #pragma implementation "AssertDepROvsRW.h" #pragma implementation "AssertDepRWvsWF.h" #pragma implementation "AssertDepWFvsRO.h" #pragma implementation "AssertInstrument.h" #pragma implementation "AssertUnknownShared.h" #pragma implementation "AssertForward.h" //Guobin #pragma implementation "AssertPartialReduction.h" #pragma implementation "AssertPartialFirstValue.h" #endif /// #include "Assertion.h" #include "ARDAssertion.h" #include "ExpressionAssertion.h" #include "StringAssertion.h" #include "AssertionList.h" #include "AssertComment.h" #include "AssertCritical.h" #include "AssertEpilogue.h" #include "AssertInduction.h" #include "AssertLastValue.h" #include "AssertParallel.h" #include "AssertPrivate.h" #include "AssertPrologue.h" #include "AssertReduction.h" #include "AssertRelation.h" #include "AssertNoPutGet.h" #include "AssertSerial.h" #include "AssertSubst.h" #include "AssertLoopLabel.h" #include "AssertMayMod.h" #include "AssertNoMod.h" //Begin OpenMP Modification #include "AssertNoWait.h" //End OpenMP Modification #include "AssertShared.h" #include "AssertFirstValue.h" #include "AssertPrivateRefs.h" #include "AssertReadOnlyRefs.h" #include "AssertSharedRefs.h" #include "AssertRTShadow.h" #include "AssertDepIO.h" #include "AssertInline.h" #include "AssertRecursiveInline.h" #include "AssertNoInline.h" #include "AssertRunTimeTest.h" #include "AssertSchedule.h" #include "AssertDynLastValue.h" #include "AssertRangeWritten.h" #include "AssertNoDependence.h" #include "AssertSideEffectFree.h" #include "AssertPreamble.h" #include "AssertPostamble.h" #include "AssertParallelCondition.h" #include "AssertSafeCondition.h" #include "AssertOverlap.h" #include "AssertOverlapSort.h" #include "AssertPrivateDescr.h" #include "AssertTestMonotone.h" #include "AssertReductDescr.h" #include "AssertDepOverlap.h" #include "AssertDepROvsRW.h" #include "AssertDepRWvsWF.h" #include "AssertDepWFvsRO.h" #include "AssertInstrument.h" #include "AssertUnknownShared.h" #include "AssertForward.h" //Guobin #include "AssertPartialReduction.h" #include "AssertPartialFirstValue.h" #include "../Collection/Iterator.h" #include "../Collection/Mutator.h" #include "../Collection/RefSet.h" #include "../macros.h" #include "../p-assert.h" template class TypedCollection<Assertion>; template class List<Assertion>; template ostream & operator << (ostream &, const List<Assertion> &); template class RefList<Assertion>; template ostream & operator << (ostream &, const RefList<Assertion> &); template class RefSet<Assertion>; template ostream & operator << (ostream &, const RefSet<Assertion> &); template class Assign<Assertion>; template class Iterator<Assertion>; template class Mutator<Assertion>; Assertion::Assertion() { _type = AS_NONE; _assertion_list.clear(); } Assertion::Assertion(const Assertion & a) { _type = a._type; _assertion_list.clear(); _assertion_list = a._assertion_list; } AssertionType Assertion::type() const { return _type; } const List<Expression> & Assertion::arg_list_guarded() const { p_abort( "Assertion::arg_list_guarded: can't get arg_list." ); return *((const List<Expression> *) 0); } List<Expression> & Assertion::arg_list_guarded() { p_abort( "Assertion::arg_list_guarded: can't get arg_list." ); return *((List<Expression> *) 0); } Boolean Assertion::arg_list_valid() const { return False; } const List<StringElem> & Assertion::string_arg_list_guarded() const { p_abort( "Assertion::string_arg_list_guarded: can't get arg_list." ); return *((const List<StringElem> *) 0); } List<StringElem> & Assertion::string_arg_list_guarded() { p_abort( "Assertion::string_arg_list_guarded: can't get arg_list." ); return *((List<StringElem> *) 0); } Boolean Assertion::string_arg_list_valid() const { return False; } RefList<Assertion> & Assertion::assertion_list() const { return CASTAWAY(RefList<Assertion> &) _assertion_list; } Assertion::~Assertion() { _assertion_list.clear(); } void Assertion::print(ostream & NOTUSED(o)) const { p_abort( "Assertion::print: can't print assertion." ); } Assertion & Assertion::operator = (const Assertion &a) { if (&a != this) { _type = a._type; _assertion_list.clear(); _assertion_list = a._assertion_list; } return (*this); } Assertion * Assertion::clone() const { return new Assertion(*this); } Listable * Assertion::listable_clone() const { p_abort( "Assertion::listable_clone: can't clone assertion." ); return 0; } StringAssertion::StringAssertion() { _type = AS_NONE; } StringAssertion::StringAssertion(const StringAssertion & a) { Assertion::operator = ( a ); _string_arg_list = a._string_arg_list; } StringAssertion & StringAssertion::operator = (const StringAssertion &a) { if (&a != this) { Assertion::operator = ( a ); _string_arg_list.clear(); _string_arg_list = a._string_arg_list; } return (*this); } const List<StringElem> & StringAssertion::string_arg_list_guarded() const { return _string_arg_list; } List<StringElem> & StringAssertion::string_arg_list_guarded() { return _string_arg_list; } Boolean StringAssertion::string_arg_list_valid() const { return True; } Assertion * StringAssertion::clone() const { return new StringAssertion(*this); } StringAssertion::~StringAssertion() { /// ... nothing to do } ExpressionAssertion::ExpressionAssertion() { _type = AS_NONE; } ExpressionAssertion::ExpressionAssertion(const ExpressionAssertion & a) { Assertion::operator = ( a ); _arg_list = a._arg_list; } ExpressionAssertion & ExpressionAssertion::operator = (const ExpressionAssertion &a) { if (&a != this) { Assertion::operator = ( a ); _arg_list.clear(); _arg_list = a._arg_list; } return (*this); } const List<Expression> & ExpressionAssertion::arg_list_guarded() const { return _arg_list; } List<Expression> & ExpressionAssertion::arg_list_guarded() { return _arg_list; } Boolean ExpressionAssertion::arg_list_valid() const { return True; } Assertion * ExpressionAssertion::clone() const { return new ExpressionAssertion(*this); } ExpressionAssertion::~ExpressionAssertion() { /// ... nothing to do } ARDAssertion::ARDAssertion() { _type = AS_NONE; } ARDAssertion::ARDAssertion(const ARDAssertion & a) { Assertion::operator = ( a ); _descr_list = a._descr_list; } ARDAssertion & ARDAssertion::operator = (const ARDAssertion &a) { if (&a != this) { Assertion::operator = ( a ); _descr_list.clear(); _descr_list = a._descr_list; } return (*this); } const List<AbstractAccess> & ARDAssertion::descr_list_guarded() const { return _descr_list; } List<AbstractAccess> & ARDAssertion::descr_list_guarded() { return _descr_list; } Boolean ARDAssertion::descr_list_valid() const { return True; } void ARDAssertion::relink_aptrs( ProgramUnit &p ) { for (Iterator<AbstractAccess> aa_iter = _descr_list; aa_iter.valid(); ++aa_iter) if (aa_iter.current_valid()) aa_iter.current().relink_eptrs( p ); } Assertion * ARDAssertion::clone() const { return new ARDAssertion(*this); } ARDAssertion::~ARDAssertion() { /// ... nothing to do } AssertionList::AssertionList() { /// ... nothing to do } AssertionList::AssertionList(Assertion *ap) { ins_first( ap ); } AssertionList::AssertionList(const AssertionList & a) { clear(); List<Assertion>::operator = ( a ); } AssertionList::~AssertionList() { /// ... nothing to do } void AssertionList::print(ostream &o) const { for (Iterator<Assertion> iter = (*this); iter.valid(); ++iter) iter.current().print(o); } void AssertionList::absorb(AssertionList *ap) { for (Mutator<Assertion> iter = (*ap); iter.valid(); ++iter) ins_last( iter.grab() ); delete ap; } AssertionList & AssertionList::operator = (const AssertionList &a) { clear(); List<Assertion>::operator = ( a ); return (*this); } AssertPrivate::AssertPrivate() { _type = AS_PRIVATE; } AssertPrivate::AssertPrivate(const AssertPrivate & a) { ExpressionAssertion::operator = ( a ); } AssertPrivate::~AssertPrivate() { /// ... nothing to do } void AssertPrivate::print(ostream & o) const { o << "{ AS_PRIVATE "; Iterator<Expression> iter = arg_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) o << ", " << iter.current(); } o << " } "; } AssertPrivate & AssertPrivate::operator = (const AssertPrivate &a) { if (&a != this) ExpressionAssertion::operator = ( a ); return (*this); } Listable * AssertPrivate::listable_clone() const { return (Listable *) new AssertPrivate( *this ); } Assertion * AssertPrivate::clone() const { return new AssertPrivate( *this ); } AssertShared::AssertShared() { _type = AS_SHARED; } AssertShared::AssertShared(const AssertShared & a) { ExpressionAssertion::operator = ( a ); } AssertShared::~AssertShared() { /// ... nothing to do } void AssertShared::print(ostream & o) const { o << "{ AS_SHARED "; Iterator<Expression> iter = arg_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) o << ", " << iter.current(); } o << " } "; } AssertShared & AssertShared::operator = (const AssertShared &a) { if (&a != this) ExpressionAssertion::operator = ( a ); return (*this); } Listable * AssertShared::listable_clone() const { return (Listable *) new AssertShared( *this ); } Assertion * AssertShared::clone() const { return new AssertShared( *this ); } AssertLoopLabel::AssertLoopLabel() { _type = AS_LOOPLABEL; } AssertLoopLabel::AssertLoopLabel(const AssertLoopLabel & a) { StringAssertion::operator = ( a ); } AssertLoopLabel::~AssertLoopLabel() { /// ... nothing to do } void AssertLoopLabel::print(ostream & o) const { o << "{ AS_LOOPLABEL "; Iterator<StringElem> iter = string_arg_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) o << ", " << iter.current(); } o << " } "; } AssertLoopLabel & AssertLoopLabel::operator = (const AssertLoopLabel &a) { if (&a != this) StringAssertion::operator = ( a ); return (*this); } Listable * AssertLoopLabel::listable_clone() const { return (Listable *) new AssertLoopLabel( *this ); } Assertion * AssertLoopLabel::clone() const { return new AssertLoopLabel( *this ); } AssertSchedule::AssertSchedule() { _type = AS_SCHEDULE; } AssertSchedule::AssertSchedule(const AssertSchedule & a) { StringAssertion::operator = ( a ); } AssertSchedule::~AssertSchedule() { /// ... nothing to do } void AssertSchedule::print(ostream & o) const { o << "{ AS_SCHEDULE "; Iterator<StringElem> iter = string_arg_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) o << ", " << iter.current(); } o << " } "; } AssertSchedule & AssertSchedule::operator = (const AssertSchedule &a) { if (&a != this) StringAssertion::operator = ( a ); return (*this); } Listable * AssertSchedule::listable_clone() const { return (Listable *) new AssertSchedule( *this ); } Assertion * AssertSchedule::clone() const { return new AssertSchedule( *this ); } AssertSubst::AssertSubst() { _type = AS_SUBST; } AssertSubst::AssertSubst(const AssertSubst & a) { ExpressionAssertion::operator = ( a ); } AssertSubst::~AssertSubst() { /// ... nothing to do } void AssertSubst::print(ostream & o) const { o << "{ AS_SUBST "; Iterator<Expression> iter = arg_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) o << ", " << iter.current(); } o << "} "; } AssertSubst & AssertSubst::operator = (const AssertSubst &a) { if (&a != this) ExpressionAssertion::operator = ( a ); return (*this); } Listable * AssertSubst::listable_clone() const { return (Listable *) new AssertSubst( *this ); } Assertion * AssertSubst::clone() const { return new AssertSubst( *this ); } AssertLastValue::AssertLastValue() { _type = AS_LASTVALUE; } AssertLastValue::AssertLastValue(const AssertLastValue & a) { ExpressionAssertion::operator = ( a ); } AssertLastValue::~AssertLastValue() { /// ... nothing to do } void AssertLastValue::print(ostream & o) const { o << "{ AS_LASTVALUE "; Iterator<Expression> iter = arg_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) o << ", " << iter.current(); } o << "} "; } AssertLastValue & AssertLastValue::operator = (const AssertLastValue &a) { if (&a != this) ExpressionAssertion::operator = ( a ); return (*this); } Listable * AssertLastValue::listable_clone() const { return (Listable *) new AssertLastValue( *this ); } Assertion * AssertLastValue::clone() const { return new AssertLastValue( *this ); } AssertDynLastValue::AssertDynLastValue() { _type = AS_DYNLASTVALUE; } AssertDynLastValue::AssertDynLastValue(const AssertDynLastValue & a) { ExpressionAssertion::operator = ( a ); } AssertDynLastValue::~AssertDynLastValue() { /// ... nothing to do } void AssertDynLastValue::print(ostream & o) const { o << "{ AS_DYNLASTVALUE "; Iterator<Expression> iter = arg_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) o << ", " << iter.current(); } o << "} "; } AssertDynLastValue & AssertDynLastValue::operator = (const AssertDynLastValue &a) { if (&a != this) ExpressionAssertion::operator = ( a ); return (*this); } Listable * AssertDynLastValue::listable_clone() const { return (Listable *) new AssertDynLastValue( *this ); } Assertion * AssertDynLastValue::clone() const { return new AssertDynLastValue( *this ); } AssertParallel::AssertParallel() { _type = AS_PARALLEL; } AssertParallel::AssertParallel(const AssertParallel & a) { ExpressionAssertion::operator = ( a ); } AssertParallel::~AssertParallel() { /// ... nothing to do } void AssertParallel::print(ostream & o) const { o << "{ AS_PARALLEL ("; Iterator<Expression> iter = arg_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) o << ", " << iter.current(); } o << ") } "; } AssertParallel & AssertParallel::operator = (const AssertParallel &a) { if (&a != this) ExpressionAssertion::operator = ( a ); return (*this); } Listable * AssertParallel::listable_clone() const { return (Listable *) new AssertParallel( *this ); } Assertion * AssertParallel::clone() const { return new AssertParallel( *this ); } AssertPrologue::AssertPrologue() { _type = AS_PROLOGUE; } AssertPrologue::AssertPrologue(const AssertPrologue & a) { ExpressionAssertion::operator = ( a ); } AssertPrologue::~AssertPrologue() { /// ... nothing to do } void AssertPrologue::print(ostream & o) const { o << "{ AS_PROLOGUE ("; Iterator<Expression> iter = arg_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) o << ", " << iter.current(); } o << ") } "; } AssertPrologue & AssertPrologue::operator = (const AssertPrologue &a) { if (&a != this) ExpressionAssertion::operator = ( a ); return (*this); } Listable * AssertPrologue::listable_clone() const { return (Listable *) new AssertPrologue( *this ); } Assertion * AssertPrologue::clone() const { return new AssertPrologue( *this ); } AssertEpilogue::AssertEpilogue() { _type = AS_EPILOGUE; } AssertEpilogue::AssertEpilogue(const AssertEpilogue & a) { ExpressionAssertion::operator = ( a ); } AssertEpilogue::~AssertEpilogue() { /// ... nothing to do } void AssertEpilogue::print(ostream & o) const { o << "{ AS_EPILOGUE ("; Iterator<Expression> iter = arg_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) o << ", " << iter.current(); } o << ") } "; } AssertEpilogue & AssertEpilogue::operator = (const AssertEpilogue &a) { if (&a != this) ExpressionAssertion::operator = ( a ); return (*this); } Listable * AssertEpilogue::listable_clone() const { return (Listable *) new AssertEpilogue( *this ); } Assertion * AssertEpilogue::clone() const { return new AssertEpilogue( *this ); } AssertReduction::AssertReduction() { _type = AS_REDUCTION; } AssertReduction::AssertReduction(const AssertReduction & a) { ExpressionAssertion::operator = ( a ); } AssertReduction::~AssertReduction() { /// ... nothing to do } void AssertReduction::print(ostream & o) const { o << "{ AS_REDUCTION "; Iterator<Expression> iter = arg_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) o << ", " << iter.current(); } o << "} "; } AssertReduction & AssertReduction::operator = (const AssertReduction &a) { if (&a != this) ExpressionAssertion::operator = ( a ); return (*this); } Listable * AssertReduction::listable_clone() const { return (Listable *) new AssertReduction( *this ); } Assertion * AssertReduction::clone() const { return new AssertReduction( *this ); } //Guobin: AssertPartialReduction Definition AssertPartialReduction::AssertPartialReduction() { _type = AS_PARTIAL_REDUCTION; } AssertPartialReduction::AssertPartialReduction(const AssertPartialReduction & a) { ExpressionAssertion::operator = ( a ); } AssertPartialReduction::AssertPartialReduction(IDExpr& a, IDExpr& b, IntConstExpr& c) { _arg_list.ins_last((Expression*)&a); _arg_list.ins_last((Expression*)&b); _arg_list.ins_last((Expression*)&c); _type = AS_PARTIAL_REDUCTION; } AssertPartialReduction::~AssertPartialReduction() { /// ... nothing to do } void AssertPartialReduction::print(ostream & o) const { o << "{ AS_PARTIAL_REDUCTION "; Iterator<Expression> iter = arg_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) o << ", " << iter.current(); } o << "} "; } AssertPartialReduction & AssertPartialReduction::operator = (const AssertPartialReduction &a) { if (&a != this) ExpressionAssertion::operator = ( a ); return (*this); } Boolean AssertPartialReduction::arg_list_valid() { if(_arg_list.entries()!=3) return false; Expression& array_expr=_arg_list[0]; Expression& rt_lmad_expr=_arg_list[1]; Expression& case_expr=_arg_list[2]; if(array_expr.op()!=ID_OP) return false; if(rt_lmad_expr.op()!=ID_OP) return false; if(case_expr.op()!=INTEGER_CONSTANT_OP) return false; return true; } Listable * AssertPartialReduction::listable_clone() const { return (Listable *) new AssertPartialReduction( *this ); } Assertion * AssertPartialReduction::clone() const { return new AssertPartialReduction( *this ); } //Guobin: AssertPartialFirstValue Definition, same as AssertPartialReduction AssertPartialFirstValue::AssertPartialFirstValue() { _type = AS_PARTIAL_REDUCTION; } AssertPartialFirstValue::AssertPartialFirstValue(const AssertPartialFirstValue & a) { ExpressionAssertion::operator = ( a ); } AssertPartialFirstValue::AssertPartialFirstValue(IDExpr& a, IDExpr& b, IntConstExpr& c) { _arg_list.ins_last((Expression*)&a); _arg_list.ins_last((Expression*)&b); _arg_list.ins_last((Expression*)&c); _type = AS_PARTIAL_REDUCTION; } AssertPartialFirstValue::~AssertPartialFirstValue() { /// ... nothing to do } void AssertPartialFirstValue::print(ostream & o) const { o << "{ AS_PARTIAL_REDUCTION "; Iterator<Expression> iter = arg_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) o << ", " << iter.current(); } o << "} "; } AssertPartialFirstValue & AssertPartialFirstValue::operator = (const AssertPartialFirstValue &a) { if (&a != this) ExpressionAssertion::operator = ( a ); return (*this); } Boolean AssertPartialFirstValue::arg_list_valid() { if(_arg_list.entries()!=3) return false; Expression& array_expr=_arg_list[0]; Expression& rt_lmad_expr=_arg_list[1]; Expression& case_expr=_arg_list[2]; if(array_expr.op()!=ID_OP) return false; if(rt_lmad_expr.op()!=ID_OP) return false; if(case_expr.op()!=INTEGER_CONSTANT_OP) return false; return true; } Listable * AssertPartialFirstValue::listable_clone() const { return (Listable *) new AssertPartialFirstValue( *this ); } Assertion * AssertPartialFirstValue::clone() const { return new AssertPartialFirstValue( *this ); } AssertComment::AssertComment() { _type = AS_COMMENT; } AssertComment::AssertComment(const AssertComment & a) { StringAssertion::operator = ( a ); } AssertComment::~AssertComment() { /// ... nothing to do } void AssertComment::print(ostream & o) const { o << "{ AS_COMMENT "; Iterator<StringElem> iter = string_arg_list_guarded(); const char *quote = "\""; if (iter.valid()) { o << quote << iter.current() << quote ; for (++iter; iter.valid(); ++iter) o << ", " << quote << iter.current() << quote; } o << "} "; } AssertComment & AssertComment::operator = (const AssertComment &a) { if (&a != this) StringAssertion::operator = ( a ); return (*this); } Listable * AssertComment::listable_clone() const { return (Listable *) new AssertComment( *this ); } Assertion * AssertComment::clone() const { return new AssertComment( *this ); } void Assertion::relink_aptrs( ProgramUnit & NOTUSED(p) ) { /// ... Nothing to do } void ExpressionAssertion::relink_aptrs( ProgramUnit &p ) { for (Iterator<Expression> e_iter = _arg_list; e_iter.valid(); ++e_iter) if (e_iter.current_valid()) e_iter.current().relink_eptrs( p ); } AssertSerial::AssertSerial() { _type = AS_SERIAL; } AssertSerial::AssertSerial(const AssertSerial & a) { ExpressionAssertion::operator = ( a ); } AssertSerial::~AssertSerial() { /// ... nothing to do } void AssertSerial::print(ostream & o) const { o << "{ AS_SERIAL ("; Iterator<Expression> iter = arg_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) o << ", " << iter.current(); } o << ") } "; } AssertSerial & AssertSerial::operator = (const AssertSerial &a) { if (&a != this) ExpressionAssertion::operator = ( a ); return (*this); } Listable * AssertSerial::listable_clone() const { return (Listable *) new AssertSerial( *this ); } Assertion * AssertSerial::clone() const { return new AssertSerial( *this ); } AssertCritical::AssertCritical() { _type = AS_CRITICAL; } AssertCritical::AssertCritical(const AssertCritical & a) { ExpressionAssertion::operator = ( a ); } AssertCritical::~AssertCritical() { /// ... nothing to do } void AssertCritical::print(ostream & o) const { o << "{ AS_CRITICAL ("; Iterator<Expression> iter = arg_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) o << ", " << iter.current(); } o << ") } "; } AssertCritical & AssertCritical::operator = (const AssertCritical &a) { if (&a != this) ExpressionAssertion::operator = ( a ); return (*this); } Listable * AssertCritical::listable_clone() const { return (Listable *) new AssertCritical( *this ); } Assertion * AssertCritical::clone() const { return new AssertCritical( *this ); } AssertRelation::AssertRelation() { _type = AS_RELATION; } AssertRelation::AssertRelation(const AssertRelation & a) { ExpressionAssertion::operator = ( a ); } AssertRelation::~AssertRelation() { /// ... nothing to do } void AssertRelation::print(ostream & o) const { o << "{ AS_RELATION ("; Iterator<Expression> iter = arg_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) o << ", " << iter.current(); } o << ") } "; } AssertRelation & AssertRelation::operator = (const AssertRelation &a) { if (&a != this) ExpressionAssertion::operator = ( a ); return (*this); } Listable * AssertRelation::listable_clone() const { return (Listable *) new AssertRelation( *this ); } Assertion * AssertRelation::clone() const { return new AssertRelation( *this ); } AssertSafeCondition::AssertSafeCondition() { _type = AS_SAFE_CONDITION; } AssertSafeCondition::AssertSafeCondition(const AssertSafeCondition & a) { ExpressionAssertion::operator = ( a ); } AssertSafeCondition::~AssertSafeCondition() { /// ... nothing to do } void AssertSafeCondition::print(ostream & o) const { o << "{ AS_SAFE_CONDITION ("; Iterator<Expression> iter = arg_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) o << ", " << iter.current(); } o << ") } "; } AssertSafeCondition & AssertSafeCondition::operator = (const AssertSafeCondition &a) { if (&a != this) ExpressionAssertion::operator = ( a ); return (*this); } Listable * AssertSafeCondition::listable_clone() const { return (Listable *) new AssertSafeCondition( *this ); } Assertion * AssertSafeCondition::clone() const { return new AssertSafeCondition( *this ); } AssertOverlap::AssertOverlap() { _type = AS_OVERLAP; } AssertOverlap::AssertOverlap(const AssertOverlap & a) { ARDAssertion::operator = ( a ); } AssertOverlap::~AssertOverlap() { /// ... nothing to do } void AssertOverlap::print(ostream & o) const { o << "{ AS_OVERLAP ("; Iterator<AbstractAccess> iter = descr_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) o << ", " << iter.current(); } o << ") } "; } AssertOverlap & AssertOverlap::operator = (const AssertOverlap &a) { if (&a != this) ARDAssertion::operator = ( a ); return (*this); } Listable * AssertOverlap::listable_clone() const { return (Listable *) new AssertOverlap( *this ); } Assertion * AssertOverlap::clone() const { return new AssertOverlap( *this ); } AssertOverlapSort::AssertOverlapSort() { _type = AS_OVERLAP_SORT; } AssertOverlapSort::AssertOverlapSort(const AssertOverlapSort & a) { ARDAssertion::operator = ( a ); } AssertOverlapSort::~AssertOverlapSort() { /// ... nothing to do } void AssertOverlapSort::print(ostream & o) const { o << "{ AS_OVERLAP_SORT ("; Iterator<AbstractAccess> iter = descr_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) o << ", " << iter.current(); } o << ") } "; } AssertOverlapSort & AssertOverlapSort::operator = (const AssertOverlapSort &a) { if (&a != this) ARDAssertion::operator = ( a ); return (*this); } Listable * AssertOverlapSort::listable_clone() const { return (Listable *) new AssertOverlapSort( *this ); } Assertion * AssertOverlapSort::clone() const { return new AssertOverlapSort( *this ); } AssertPrivateDescr::AssertPrivateDescr() { _type = AS_PRIVATE_DESCR; } AssertPrivateDescr::AssertPrivateDescr(const AssertPrivateDescr & a) { ARDAssertion::operator = ( a ); } AssertPrivateDescr::~AssertPrivateDescr() { /// ... nothing to do } void AssertPrivateDescr::print(ostream & o) const { o << "{ AS_PRIVATE_DESCR ("; Iterator<AbstractAccess> iter = descr_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) o << ", " << iter.current(); } o << ") } "; } AssertPrivateDescr & AssertPrivateDescr::operator = (const AssertPrivateDescr &a) { if (&a != this) ARDAssertion::operator = ( a ); return (*this); } Listable * AssertPrivateDescr::listable_clone() const { return (Listable *) new AssertPrivateDescr( *this ); } Assertion * AssertPrivateDescr::clone() const { return new AssertPrivateDescr( *this ); } AssertTestMonotone::AssertTestMonotone() { _type = AS_TEST_MONOTONE; } AssertTestMonotone::AssertTestMonotone(const AssertTestMonotone & a) { ARDAssertion::operator = ( a ); } AssertTestMonotone::~AssertTestMonotone() { /// ... nothing to do } void AssertTestMonotone::print(ostream & o) const { o << "{ AS_TEST_MONOTONE ("; Iterator<AbstractAccess> iter = descr_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) o << ", " << iter.current(); } o << ") } "; } AssertTestMonotone & AssertTestMonotone::operator = (const AssertTestMonotone &a) { if (&a != this) ARDAssertion::operator = ( a ); return (*this); } Listable * AssertTestMonotone::listable_clone() const { return (Listable *) new AssertTestMonotone( *this ); } Assertion * AssertTestMonotone::clone() const { return new AssertTestMonotone( *this ); } AssertReductDescr::AssertReductDescr() { _type = AS_REDUCT_DESCR; } AssertReductDescr::AssertReductDescr(const AssertReductDescr & a) { ARDAssertion::operator = ( a ); } AssertReductDescr::~AssertReductDescr() { /// ... nothing to do } void AssertReductDescr::print(ostream & o) const { o << "{ AS_REDUCT_DESCR ("; Iterator<AbstractAccess> iter = descr_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) o << ", " << iter.current(); } o << ") } "; } AssertReductDescr & AssertReductDescr::operator = (const AssertReductDescr &a) { if (&a != this) ARDAssertion::operator = ( a ); return (*this); } Listable * AssertReductDescr::listable_clone() const { return (Listable *) new AssertReductDescr( *this ); } Assertion * AssertReductDescr::clone() const { return new AssertReductDescr( *this ); } AssertDepROvsRW::AssertDepROvsRW() { _type = AS_DEP_RO_RW; } AssertDepROvsRW::AssertDepROvsRW(const AssertDepROvsRW & a) { ARDAssertion::operator = ( a ); } AssertDepROvsRW::~AssertDepROvsRW() { /// ... nothing to do } void AssertDepROvsRW::print(ostream & o) const { o << "{ AS_DEP_RO_RW ("; Iterator<AbstractAccess> iter = descr_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) o << ", " << iter.current(); } o << ") } "; } AssertDepROvsRW & AssertDepROvsRW::operator = (const AssertDepROvsRW &a) { if (&a != this) ARDAssertion::operator = ( a ); return (*this); } Listable * AssertDepROvsRW::listable_clone() const { return (Listable *) new AssertDepROvsRW( *this ); } Assertion * AssertDepROvsRW::clone() const { return new AssertDepROvsRW( *this ); } AssertDepRWvsWF::AssertDepRWvsWF() { _type = AS_DEP_RW_WF; } AssertDepRWvsWF::AssertDepRWvsWF(const AssertDepRWvsWF & a) { ARDAssertion::operator = ( a ); } AssertDepRWvsWF::~AssertDepRWvsWF() { /// ... nothing to do } void AssertDepRWvsWF::print(ostream & o) const { o << "{ AS_DEP_RW_WF ("; Iterator<AbstractAccess> iter = descr_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) o << ", " << iter.current(); } o << ") } "; } AssertDepRWvsWF & AssertDepRWvsWF::operator = (const AssertDepRWvsWF &a) { if (&a != this) ARDAssertion::operator = ( a ); return (*this); } Listable * AssertDepRWvsWF::listable_clone() const { return (Listable *) new AssertDepRWvsWF( *this ); } Assertion * AssertDepRWvsWF::clone() const { return new AssertDepRWvsWF( *this ); } AssertDepWFvsRO::AssertDepWFvsRO() { _type = AS_DEP_WF_RO; } AssertDepWFvsRO::AssertDepWFvsRO(const AssertDepWFvsRO & a) { ARDAssertion::operator = ( a ); } AssertDepWFvsRO::~AssertDepWFvsRO() { /// ... nothing to do } void AssertDepWFvsRO::print(ostream & o) const { o << "{ AS_DEP_WF_RO ("; Iterator<AbstractAccess> iter = descr_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) o << ", " << iter.current(); } o << ") } "; } AssertDepWFvsRO & AssertDepWFvsRO::operator = (const AssertDepWFvsRO &a) { if (&a != this) ARDAssertion::operator = ( a ); return (*this); } Listable * AssertDepWFvsRO::listable_clone() const { return (Listable *) new AssertDepWFvsRO( *this ); } Assertion * AssertDepWFvsRO::clone() const { return new AssertDepWFvsRO( *this ); } AssertDepOverlap::AssertDepOverlap() { _type = AS_DEP_OVERLAP; } AssertDepOverlap::AssertDepOverlap(const AssertDepOverlap & a) { ARDAssertion::operator = ( a ); } AssertDepOverlap::~AssertDepOverlap() { /// ... nothing to do } void AssertDepOverlap::print(ostream & o) const { o << "{ AS_DEP_OVERLAP ("; Iterator<AbstractAccess> iter = descr_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) o << ", " << iter.current(); } o << ") } "; } AssertDepOverlap & AssertDepOverlap::operator = (const AssertDepOverlap &a) { if (&a != this) ARDAssertion::operator = ( a ); return (*this); } Listable * AssertDepOverlap::listable_clone() const { return (Listable *) new AssertDepOverlap( *this ); } Assertion * AssertDepOverlap::clone() const { return new AssertDepOverlap( *this ); } AssertInstrument::AssertInstrument() { _type = AS_INSTRUMENT; } AssertInstrument::AssertInstrument(const AssertInstrument & a) { ExpressionAssertion::operator = ( a ); } AssertInstrument::~AssertInstrument() { /// ... nothing to do } void AssertInstrument::print(ostream & o) const { o << "{ AS_INSTRUMENT "; Iterator<Expression> iter = arg_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) o << ", " << iter.current(); } o << " } "; } AssertInstrument & AssertInstrument::operator = (const AssertInstrument &a) { if (&a != this) ExpressionAssertion::operator = ( a ); return (*this); } Listable * AssertInstrument::listable_clone() const { return (Listable *) new AssertInstrument( *this ); } Assertion * AssertInstrument::clone() const { return new AssertInstrument( *this ); } AssertFirstValue::AssertFirstValue() { _type = AS_FIRSTVALUE; } AssertFirstValue::AssertFirstValue(const AssertFirstValue & a) { ExpressionAssertion::operator = ( a ); } AssertFirstValue::~AssertFirstValue() { /// ... nothing to do } void AssertFirstValue::print(ostream & o) const { o << "{ AS_FIRSTVALUE "; Iterator<Expression> iter = arg_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) o << ", " << iter.current(); } o << "} "; } AssertFirstValue & AssertFirstValue::operator = (const AssertFirstValue &a) { if (&a != this) ExpressionAssertion::operator = ( a ); return (*this); } Listable * AssertFirstValue::listable_clone() const { return (Listable *) new AssertFirstValue( *this ); } Assertion * AssertFirstValue::clone() const { return new AssertFirstValue( *this ); } AssertRangeWritten::AssertRangeWritten() { _type = AS_RANGEWRITTEN; } AssertRangeWritten::AssertRangeWritten(const AssertRangeWritten & a) { ExpressionAssertion::operator = ( a ); } AssertRangeWritten::~AssertRangeWritten() { /// ... nothing to do } void AssertRangeWritten::print(ostream & o) const { o << "{ AS_RANGEWRITTEN "; Iterator<Expression> iter = arg_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) o << ", " << iter.current(); } o << "} "; } AssertRangeWritten & AssertRangeWritten::operator = (const AssertRangeWritten &a) { if (&a != this) ExpressionAssertion::operator = ( a ); return (*this); } Listable * AssertRangeWritten::listable_clone() const { return (Listable *) new AssertRangeWritten( *this ); } Assertion * AssertRangeWritten::clone() const { return new AssertRangeWritten( *this ); } AssertPrivateRefs::AssertPrivateRefs() { _type = AS_PRIVATEREFS; } AssertPrivateRefs::AssertPrivateRefs(const AssertPrivateRefs & a) { ExpressionAssertion::operator = ( a ); } AssertPrivateRefs::~AssertPrivateRefs() { /// ... nothing to do } void AssertPrivateRefs::print(ostream & o) const { o << "{ AS_PRIVATEREFS "; Iterator<Expression> iter = arg_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) { o << ", " << iter.current(); } } o << " } "; } AssertPrivateRefs & AssertPrivateRefs::operator = (const AssertPrivateRefs &a) { if (&a != this) ExpressionAssertion::operator = ( a ); return (*this); } Listable * AssertPrivateRefs::listable_clone() const { return (Listable *) new AssertPrivateRefs( *this ); } Assertion * AssertPrivateRefs::clone() const { return new AssertPrivateRefs( *this ); } AssertReadOnlyRefs::AssertReadOnlyRefs() { _type = AS_READONLYREFS; } AssertReadOnlyRefs::AssertReadOnlyRefs(const AssertReadOnlyRefs & a) { ExpressionAssertion::operator = ( a ); } AssertReadOnlyRefs::~AssertReadOnlyRefs() { /// ... nothing to do } void AssertReadOnlyRefs::print(ostream & o) const { o << "{ AS_READONLYREFS "; Iterator<Expression> iter = arg_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) { o << ", " << iter.current(); } } o << " } "; } AssertReadOnlyRefs & AssertReadOnlyRefs::operator = (const AssertReadOnlyRefs &a) { if (&a != this) ExpressionAssertion::operator = ( a ); return (*this); } Listable * AssertReadOnlyRefs::listable_clone() const { return (Listable *) new AssertReadOnlyRefs( *this ); } Assertion * AssertReadOnlyRefs::clone() const { return new AssertReadOnlyRefs( *this ); } AssertSharedRefs::AssertSharedRefs() { _type = AS_SHAREDREFS; } AssertSharedRefs::AssertSharedRefs(const AssertSharedRefs & a) { ExpressionAssertion::operator = ( a ); } AssertSharedRefs::~AssertSharedRefs() { /// ... nothing to do } void AssertSharedRefs::print(ostream & o) const { o << "{ AS_SHAREDREFS "; Iterator<Expression> iter = arg_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) { o << ", " << iter.current(); } } o << " } "; } AssertSharedRefs & AssertSharedRefs::operator = (const AssertSharedRefs &a) { if (&a != this) ExpressionAssertion::operator = ( a ); return (*this); } Listable * AssertSharedRefs::listable_clone() const { return (Listable *) new AssertSharedRefs( *this ); } Assertion * AssertSharedRefs::clone() const { return new AssertSharedRefs( *this ); } AssertRTShadow::AssertRTShadow() { _type = AS_RTSHADOW; } AssertRTShadow::AssertRTShadow(const AssertRTShadow & a) { ExpressionAssertion::operator = ( a ); } AssertRTShadow::~AssertRTShadow() { /// ... nothing to do } void AssertRTShadow::print(ostream & o) const { o << "{ AS_RTSHADOW "; Iterator<Expression> iter = arg_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) o << ", " << iter.current(); } o << " } "; } AssertRTShadow & AssertRTShadow::operator = (const AssertRTShadow &a) { if (&a != this) ExpressionAssertion::operator = ( a ); return (*this); } Listable * AssertRTShadow::listable_clone() const { return (Listable *) new AssertRTShadow( *this ); } Assertion * AssertRTShadow::clone() const { return new AssertRTShadow( *this ); } AssertDepIO::AssertDepIO() { _type = AS_DEP_IO; } AssertDepIO::AssertDepIO(const AssertDepIO & a) { ExpressionAssertion::operator = ( a ); } AssertDepIO::~AssertDepIO() { /// ... nothing to do } void AssertDepIO::print(ostream & o) const { o << "{ AS_DEP_IO "; Iterator<Expression> iter = arg_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) o << ", " << iter.current(); } o << " } "; } AssertDepIO & AssertDepIO::operator = (const AssertDepIO &a) { if (&a != this) ExpressionAssertion::operator = ( a ); return (*this); } Listable * AssertDepIO::listable_clone() const { return (Listable *) new AssertDepIO( *this ); } Assertion * AssertDepIO::clone() const { return new AssertDepIO( *this ); } AssertInline::AssertInline() { _type = AS_INLINE; } AssertInline::AssertInline(const AssertInline & a) { ExpressionAssertion::operator = ( a ); } AssertInline::~AssertInline() { /// ... nothing to do } void AssertInline::print(ostream & o) const { o << "{ AS_INLINE "; Iterator<Expression> iter = arg_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) o << ", " << iter.current(); } o << " } "; } AssertInline & AssertInline::operator = (const AssertInline &a) { if (&a != this) ExpressionAssertion::operator = ( a ); return (*this); } Listable * AssertInline::listable_clone() const { return (Listable *) new AssertInline( *this ); } Assertion * AssertInline::clone() const { return new AssertInline( *this ); } AssertRecursiveInline::AssertRecursiveInline() { _type = AS_RECURSIVEINLINE; } AssertRecursiveInline::AssertRecursiveInline(const AssertRecursiveInline & a) { ExpressionAssertion::operator = ( a ); } AssertRecursiveInline::~AssertRecursiveInline() { /// ... nothing to do } void AssertRecursiveInline::print(ostream & o) const { o << "{ AS_RECURSIVEINLINE "; Iterator<Expression> iter = arg_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) o << ", " << iter.current(); } o << " } "; } AssertRecursiveInline & AssertRecursiveInline::operator = (const AssertRecursiveInline &a) { if (&a != this) ExpressionAssertion::operator = ( a ); return (*this); } Listable * AssertRecursiveInline::listable_clone() const { return (Listable *) new AssertRecursiveInline( *this ); } Assertion * AssertRecursiveInline::clone() const { return new AssertRecursiveInline( *this ); } AssertNoInline::AssertNoInline() { _type = AS_NOINLINE; } AssertNoInline::AssertNoInline(const AssertNoInline & a) { ExpressionAssertion::operator = ( a ); } AssertNoInline::~AssertNoInline() { /// ... nothing to do } void AssertNoInline::print(ostream & o) const { o << "{ AS_NOINLINE "; Iterator<Expression> iter = arg_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) o << ", " << iter.current(); } o << " } "; } AssertNoInline & AssertNoInline::operator = (const AssertNoInline &a) { if (&a != this) ExpressionAssertion::operator = ( a ); return (*this); } Listable * AssertNoInline::listable_clone() const { return (Listable *) new AssertNoInline( *this ); } Assertion * AssertNoInline::clone() const { return new AssertNoInline( *this ); } AssertNoPutGet::AssertNoPutGet() { _type = AS_NOPUTGET; } AssertNoPutGet::AssertNoPutGet(const AssertNoPutGet & a) { ExpressionAssertion::operator = ( a ); } AssertNoPutGet::~AssertNoPutGet() { /// ... nothing to do } void AssertNoPutGet::print(ostream & o) const { o << "{ AS_NOPUTGET "; Iterator<Expression> iter = arg_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) o << ", " << iter.current(); } o << " } "; } AssertNoPutGet & AssertNoPutGet::operator = (const AssertNoPutGet &a) { if (&a != this) ExpressionAssertion::operator = ( a ); return (*this); } Listable * AssertNoPutGet::listable_clone() const { return (Listable *) new AssertNoPutGet( *this ); } Assertion * AssertNoPutGet::clone() const { return new AssertNoPutGet( *this ); } AssertRunTimeTest::AssertRunTimeTest() { _type = AS_RUNTIMETEST; } AssertRunTimeTest::AssertRunTimeTest(const AssertRunTimeTest & a) { ExpressionAssertion::operator = ( a ); } AssertRunTimeTest::~AssertRunTimeTest() { /// ... nothing to do } void AssertRunTimeTest::print(ostream & o) const { o << "{ AS_RUNTIMETEST "; Iterator<Expression> iter = arg_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) o << ", " << iter.current(); } o << " } "; } AssertRunTimeTest & AssertRunTimeTest::operator = (const AssertRunTimeTest &a) { if (&a != this) ExpressionAssertion::operator = ( a ); return (*this); } Listable * AssertRunTimeTest::listable_clone() const { return (Listable *) new AssertRunTimeTest( *this ); } Assertion * AssertRunTimeTest::clone() const { return new AssertRunTimeTest( *this ); } AssertSideEffectFree::AssertSideEffectFree() { _type = AS_SIDE_EFFECT_FREE; } AssertSideEffectFree::AssertSideEffectFree(const AssertSideEffectFree & a) { ExpressionAssertion::operator = ( a ); } AssertSideEffectFree::~AssertSideEffectFree() { /// ... nothing to do } void AssertSideEffectFree::print(ostream & o) const { o << "{ AS_SIDE_EFFECT_FREE "; Iterator<Expression> iter = arg_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) o << ", " << iter.current(); } o << " } "; } AssertSideEffectFree & AssertSideEffectFree::operator = (const AssertSideEffectFree &a) { if (&a != this) ExpressionAssertion::operator = ( a ); return (*this); } Listable * AssertSideEffectFree::listable_clone() const { return (Listable *) new AssertSideEffectFree( *this ); } Assertion * AssertSideEffectFree::clone() const { return new AssertSideEffectFree( *this ); } AssertNoDependence::AssertNoDependence() { _type = AS_NODEPENDENCE; } AssertNoDependence::AssertNoDependence(const AssertNoDependence & a) { ExpressionAssertion::operator = ( a ); } AssertNoDependence::~AssertNoDependence() { /// ... nothing to do } void AssertNoDependence::print(ostream & o) const { o << "{ AS_NODEPENDENCE "; Iterator<Expression> iter = arg_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) o << ", " << iter.current(); } o << " } "; } AssertNoDependence & AssertNoDependence::operator = (const AssertNoDependence &a) { if (&a != this) ExpressionAssertion::operator = ( a ); return (*this); } Listable * AssertNoDependence::listable_clone() const { return (Listable *) new AssertNoDependence( *this ); } Assertion * AssertNoDependence::clone() const { return new AssertNoDependence( *this ); } AssertPreamble::AssertPreamble() { _type = AS_PREAMBLE; } AssertPreamble::AssertPreamble(const AssertPreamble & a) { ExpressionAssertion::operator = ( a ); } AssertPreamble::~AssertPreamble() { /// ... nothing to do } void AssertPreamble::print(ostream & o) const { o << "{ AS_PREAMBLE "; Iterator<Expression> iter = arg_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) o << ", " << iter.current(); } o << "} "; } AssertPreamble & AssertPreamble::operator = (const AssertPreamble &a) { if (&a != this) ExpressionAssertion::operator = ( a ); return (*this); } Listable * AssertPreamble::listable_clone() const { return (Listable *) new AssertPreamble( *this ); } Assertion * AssertPreamble::clone() const { return new AssertPreamble( *this ); } AssertPostamble::AssertPostamble() { _type = AS_POSTAMBLE; } AssertPostamble::AssertPostamble(const AssertPostamble & a) { ExpressionAssertion::operator = ( a ); } AssertPostamble::~AssertPostamble() { /// ... nothing to do } void AssertPostamble::print(ostream & o) const { o << "{ AS_POSTAMBLE "; Iterator<Expression> iter = arg_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) o << ", " << iter.current(); } o << "} "; } AssertPostamble & AssertPostamble::operator = (const AssertPostamble &a) { if (&a != this) ExpressionAssertion::operator = ( a ); return (*this); } Listable * AssertPostamble::listable_clone() const { return (Listable *) new AssertPostamble( *this ); } Assertion * AssertPostamble::clone() const { return new AssertPostamble( *this ); } AssertInduction::AssertInduction() { _type = AS_INDUCTION; } AssertInduction::AssertInduction(const AssertInduction & a) { ExpressionAssertion::operator = ( a ); } AssertInduction::~AssertInduction() { /// ... nothing to do } void AssertInduction::print(ostream & o) const { o << "{ AS_INDUCTION "; Iterator<Expression> iter = arg_list_guarded(); if (iter.valid()) { o << "IV:" << iter.current(); ++iter; } if (iter.valid()) { o << ", TYPE:" << iter.current(); ++iter; } if (iter.valid()) { o << ", LO:" << iter.current(); ++iter; } if (iter.valid()) { o << ", HI:" << iter.current(); ++iter; } if (iter.valid()) { o << ", HDR:" << iter.current(); ++iter; } if (iter.valid()) { o << ", EXPR:" << iter.current(); ++iter; } o << " } "; } AssertInduction & AssertInduction::operator = (const AssertInduction &a) { if (&a != this) ExpressionAssertion::operator = ( a ); return (*this); } Listable * AssertInduction::listable_clone() const { return (Listable *) new AssertInduction( *this ); } Assertion * AssertInduction::clone() const { return new AssertInduction( *this ); } AssertParallelCondition::AssertParallelCondition() { _type = AS_PARCONDITION; } AssertParallelCondition::AssertParallelCondition(const AssertParallelCondition & a) { ExpressionAssertion::operator = ( a ); } AssertParallelCondition::~AssertParallelCondition() { /// ... nothing to do } void AssertParallelCondition::print(ostream & o) const { o << "{ AS_PARCONDITION "; Iterator<Expression> iter = arg_list_guarded(); if (iter.valid()) { o << "Boolean Expression:" << iter.current(); } o << " } "; } AssertParallelCondition & AssertParallelCondition::operator = (const AssertParallelCondition &a) { if (&a != this) ExpressionAssertion::operator = ( a ); return (*this); } Listable * AssertParallelCondition::listable_clone() const { return (Listable *) new AssertParallelCondition( *this ); } Assertion * AssertParallelCondition::clone() const { return new AssertParallelCondition( *this ); } AssertMayMod::AssertMayMod() { _type = AS_MAYMOD; } AssertMayMod::AssertMayMod(const AssertMayMod & a) { ExpressionAssertion::operator = ( a ); } AssertMayMod::~AssertMayMod() { /// ... nothing to do } void AssertMayMod::print(ostream & o) const { o << "{ AS_MAYMOD "; Iterator<Expression> iter = arg_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) { o << ", " << iter.current(); } } o << " } "; } AssertMayMod & AssertMayMod::operator = (const AssertMayMod &a) { if (&a != this) ExpressionAssertion::operator = ( a ); return (*this); } Listable * AssertMayMod::listable_clone() const { return (Listable *) new AssertMayMod( *this ); } Assertion * AssertMayMod::clone() const { return new AssertMayMod( *this ); } AssertNoMod::AssertNoMod() { _type = AS_NOMOD; } AssertNoMod::AssertNoMod(const AssertNoMod & a) { ExpressionAssertion::operator = ( a ); } AssertNoMod::~AssertNoMod() { /// ... nothing to do } void AssertNoMod::print(ostream & o) const { o << "{ AS_NOMOD "; Iterator<Expression> iter = arg_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) { o << ", " << iter.current(); } } o << " } "; } AssertNoMod & AssertNoMod::operator = (const AssertNoMod &a) { if (&a != this) ExpressionAssertion::operator = ( a ); return (*this); } Listable * AssertNoMod::listable_clone() const { return (Listable *) new AssertNoMod( *this ); } Assertion * AssertNoMod::clone() const { return new AssertNoMod( *this ); } AssertUnknownShared::AssertUnknownShared() { _type = AS_UNKNOWN_SHARED; } AssertUnknownShared::AssertUnknownShared(const AssertUnknownShared & a) { ExpressionAssertion::operator = ( a ); } AssertUnknownShared::~AssertUnknownShared() { /// ... nothing to do } void AssertUnknownShared::print(ostream & o) const { o << "{ AS_UNKNOWN_SHARED "; Iterator<Expression> iter = arg_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) o << ", " << iter.current(); } o << " } "; } AssertUnknownShared & AssertUnknownShared::operator = (const AssertUnknownShared &a) { if (&a != this) ExpressionAssertion::operator = ( a ); return (*this); } Listable * AssertUnknownShared::listable_clone() const { return (Listable *) new AssertUnknownShared( *this ); } Assertion * AssertUnknownShared::clone() const { return new AssertUnknownShared( *this ); } AssertForward::AssertForward() { _type = AS_FORWARD; } AssertForward::AssertForward(const AssertForward & a) { ExpressionAssertion::operator = ( a ); } AssertForward::~AssertForward() { /// ... nothing to do } void AssertForward::print(ostream & o) const { o << "{ AS_FORWARD "; Iterator<Expression> iter = arg_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) o << ", " << iter.current(); } o << "} "; } AssertForward & AssertForward::operator = (const AssertForward &a) { if (&a != this) ExpressionAssertion::operator = ( a ); return (*this); } Listable * AssertForward::listable_clone() const { return (Listable *) new AssertForward( *this ); } Assertion * AssertForward::clone() const { return new AssertForward( *this ); } /// Begin OpenMP Modification AssertNoWait::AssertNoWait() { _type = AS_NOWAIT; } AssertNoWait::AssertNoWait(const AssertNoWait & a) { ExpressionAssertion::operator = ( a ); } AssertNoWait::~AssertNoWait() { /// nothing to do } void AssertNoWait::print(ostream & o) const { o << "{ AS_NOWAIT ("; Iterator<Expression> iter = arg_list_guarded(); if (iter.valid()) { o << iter.current(); for (++iter; iter.valid(); ++iter) o << ", " << iter.current(); } o << ") } "; } AssertNoWait & AssertNoWait::operator = (const AssertNoWait &a) { if (&a != this) ExpressionAssertion::operator = ( a ); return (*this); } Listable * AssertNoWait::listable_clone() const { return (Listable *) new AssertNoWait( *this ); } Assertion * AssertNoWait::clone() const { return new AssertNoWait( *this ); } /// End OpenMP Modification

© 1995-2005 University of Illinois, Urbana-Champaign. All rights reserved.  Fri Mar 25 23:05:39 2005