| /******************************************************************************* |
| * Copyright (c) 2016 CEA LIST. |
| * |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Created on: 10 juil. 2009 |
| * |
| * Contributors: |
| * Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr |
| * - Initial API and implementation |
| ******************************************************************************/ |
| |
| #ifndef BF_H_ |
| #define BF_H_ |
| |
| #include <base/ClassKindInfo.h> |
| #include <base/SmartPointer.h> |
| #include <common/Element.h> |
| |
| #include <util/avm_assert.h> |
| #include <util/avm_string.h> |
| |
| |
| #define AVM_DEBUG_BF_POINTER true |
| #undef AVM_DEBUG_BF_POINTER |
| |
| #if defined(AVM_DEBUG_BF_POINTER) |
| |
| #define AVM_DECLARE_DEBUG_BF_PTR public: std::string dbgPTR; |
| |
| |
| #define AVM_STR_BF_PTR( ptr ) ( (ptr != NULL) ? ptr->str() : "BF<null>" ) |
| |
| #define AVM_INIT_DEBUG_BF_PTR_NULL , dbgPTR( "BF<null>" ) |
| |
| #define AVM_INIT_DEBUG_BF_PTR( ptr ) , dbgPTR( AVM_STR_BF_PTR(ptr) ) |
| |
| #define AVM_COPY_DEBUG_BF_PTR( bf ) , dbgPTR( bf.dbgPTR ) |
| |
| #define AVM_ASSIGN_DEBUG_BF_PTR( ptr ) dbgPTR = AVM_STR_BF_PTR(ptr); |
| |
| #else |
| |
| #define AVM_INIT_DEBUG_BF_PTR_NULL |
| |
| #define AVM_DECLARE_DEBUG_BF_PTR |
| |
| #define AVM_INIT_DEBUG_BF_PTR( ptr ) |
| |
| #define AVM_COPY_DEBUG_BF_PTR( ptr ) |
| |
| #define AVM_ASSIGN_DEBUG_BF_PTR( ptr ) |
| |
| #endif |
| |
| |
| namespace sep |
| { |
| |
| |
| class BFCode; |
| |
| class Operator; |
| |
| class RuntimeID; |
| |
| //class Symbol; |
| //class Type; |
| |
| |
| |
| class BF : |
| public SmartPointer< Element , DestroyElementPolicy >, |
| AVM_INJECT_INSTANCE_COUNTER_CLASS( BF ) |
| { |
| |
| |
| private: |
| /** |
| * TYPEDEF |
| */ |
| typedef SmartPointer< Element , DestroyElementPolicy > base_this_type; |
| |
| AVM_DECLARE_DEBUG_BF_PTR |
| |
| public: |
| /** |
| * CONSTRUCTOR |
| * Default |
| */ |
| BF() throw() |
| : base_this_type() |
| AVM_INIT_DEBUG_BF_PTR_NULL |
| { |
| //!! NOTHING |
| } |
| |
| explicit BF(Element * anElement) |
| : base_this_type( anElement ) |
| AVM_INIT_DEBUG_BF_PTR( anElement ) |
| { |
| //!! NOTHING |
| } |
| |
| |
| /** |
| * CONSTRUCTOR |
| * Copy |
| */ |
| BF(const BF & anElement) |
| : base_this_type( anElement ) |
| AVM_COPY_DEBUG_BF_PTR( anElement ) |
| { |
| //!! NOTHING |
| } |
| |
| |
| static avm_uint64_t INSTANCE_COUNTER_ASP; |
| |
| template< class U > |
| BF(const SmartPointer< U , DestroyElementPolicy > & other) |
| : base_this_type( other ) |
| { |
| //!! NOTHING |
| ++INSTANCE_COUNTER_ASP; |
| } |
| |
| |
| /** |
| * DESTRUCTOR |
| */ |
| virtual ~BF() |
| { |
| //!! NOTHING |
| } |
| |
| |
| void finalize(); |
| |
| |
| /** |
| * NUMERIC or SIMPLE TYPE TEST & CAST |
| */ |
| virtual bool isBoolean() const; |
| virtual bool toBoolean() const; |
| |
| /** |
| * COMPARISON |
| * with TRUE & FALSE |
| */ |
| virtual bool isEqualFalse() const; |
| virtual bool isNotEqualFalse() const; |
| |
| virtual bool isEqualTrue() const; |
| virtual bool isNotEqualTrue()const; |
| |
| |
| virtual bool isEqualZero() const; |
| virtual bool isEqualOne() const; |
| |
| virtual bool isNumber() const; |
| virtual bool isNumeric() const; |
| |
| virtual bool isExpression() const; |
| |
| |
| virtual bool isInt32() const; |
| virtual avm_int32_t toInt32() const; |
| |
| virtual bool isInt64() const; |
| virtual avm_int64_t toInt64() const; |
| |
| |
| virtual bool isInteger() const; |
| virtual avm_integer_t toInteger() const; |
| |
| virtual bool isWeakInteger() const |
| { |
| return( isInteger() ); |
| } |
| |
| virtual bool isPosInteger() const; |
| |
| virtual bool isUInteger() const; |
| virtual avm_uinteger_t toUInteger() const; |
| |
| |
| virtual bool isRational() const; |
| virtual avm_integer_t toDenominator() const; |
| virtual avm_integer_t toNumerator() const; |
| |
| virtual bool isWeakRational() const |
| { |
| return( isRational() || isWeakInteger() ); |
| } |
| |
| |
| virtual bool isFloat() const; |
| virtual avm_float_t toFloat() const; |
| |
| virtual bool isWeakFloat() const |
| { |
| return( isFloat() || isWeakRational() ); |
| } |
| |
| |
| virtual bool isReal() const; |
| virtual avm_real_t toReal() const; |
| |
| inline virtual bool isWeakReal() const |
| { |
| return( isReal() || isWeakFloat() ); |
| } |
| |
| |
| |
| virtual bool isCharacter() const; |
| virtual char toCharacter() const; |
| |
| virtual bool isBuiltinString() const; |
| virtual std::string toBuiltinString() const; |
| |
| |
| virtual bool isIdentifier() const; |
| virtual std::string toIdentifier() const; |
| |
| virtual bool isUfi() const; |
| virtual std::string toUfi() const; |
| |
| virtual bool isUfid() const |
| { |
| return( isUfi() || isIdentifier() ); |
| } |
| virtual std::string toUfid() const; |
| |
| virtual bool isEnumSymbol() const; |
| virtual std::string strEnumSymbol() const; |
| |
| virtual bool isUFID() const; |
| |
| bool isBuiltinValue() const; |
| |
| virtual bool isConstValue() const; |
| |
| |
| |
| /** |
| * REFERENCE |
| * CAST |
| */ |
| BFCode & bfCode() ; |
| |
| const BFCode & bfCode() const; |
| |
| const RuntimeID & bfRID() const; |
| |
| |
| |
| /** |
| * MEMORY MANAGEMENT |
| */ |
| |
| void incrRefCount() const |
| { |
| if( mPTR != NULL ) |
| { |
| mPTR->incrRefCount(); |
| } |
| } |
| |
| |
| /** |
| * GETTER |
| * ClassKindInfo |
| */ |
| inline class_kind_t classKind() const |
| { |
| AVM_OS_ASSERT_FATAL_NULL_POINTER_EXIT( mPTR ) |
| << "raw_pointer in BF::classKind() !!!" |
| << SEND_EXIT; |
| |
| return( mPTR->classKind() ); |
| } |
| |
| inline const std::string & classKindName() const |
| { |
| AVM_OS_ASSERT_FATAL_NULL_POINTER_EXIT( mPTR ) |
| << "raw_pointer in BF::classKindName() !!!" |
| << SEND_EXIT; |
| |
| return( mPTR->classKindName() ); |
| } |
| |
| inline std::string classKindInfo() const |
| { |
| AVM_OS_ASSERT_FATAL_NULL_POINTER_EXIT( mPTR ) |
| << "raw_pointer in BF::classKindInfo() !!!" |
| << SEND_EXIT; |
| |
| return( mPTR->classKindInfo() ); |
| } |
| |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // TYPE CHECKER |
| //////////////////////////////////////////////////////////////////////////// |
| |
| // Check if BF is a handle to a T, including base classes. |
| template<class T > |
| inline bool is() const |
| { |
| // AVM_OS_ASSERT_FATAL_NULL_POINTER_EXIT( mPTR ) |
| // << "raw_pointer in BF::is< T >() !!!" |
| // << SEND_EXIT; |
| |
| return( (mPTR != NULL) && mPTR->is< T >() ); |
| } |
| |
| template<class T > |
| inline bool isnot() const |
| { |
| return(( mPTR == NULL) || mPTR->isnot< T >() ); |
| } |
| |
| // Check if BF is a handle to a T, not including base classes. |
| template< class T > |
| inline bool is_weakly() const |
| { |
| return( (mPTR == NULL) || mPTR->is< T >() ); |
| } |
| |
| // Check if BF is a handle to a T, not including base classes. |
| template< class T > |
| inline bool is_exactly() const |
| { |
| // AVM_OS_ASSERT_FATAL_NULL_POINTER_EXIT( mPTR ) |
| // << "raw_pointer in BF::is_exactly< T >() !!!" |
| // << SEND_EXIT; |
| |
| return( (mPTR != NULL) && mPTR->is_exactly< T >() ); |
| } |
| |
| template< class T > |
| inline bool isnot_exactly() const |
| { |
| return( (mPTR == NULL) || mPTR->isnot_exactly< T >() ); |
| } |
| |
| // Check if BF is a handle to a T, not including specific classes. |
| template< class T > |
| inline bool is_strictly() const |
| { |
| // AVM_OS_ASSERT_FATAL_NULL_POINTER_EXIT( mPTR ) |
| // << "raw_pointer in BF::is_strictly< T >() !!!" |
| // << SEND_EXIT; |
| |
| return( (mPTR != NULL) && mPTR->is_strictly< T >() ); |
| } |
| |
| template< class T > |
| inline bool isnot_strictly() const |
| { |
| return( (mPTR == NULL) || mPTR->isnot_strictly< T >() ); |
| } |
| |
| |
| // cast BF as specified pointer |
| template< class T > |
| inline T * as_ptr() const |
| { |
| // previous:> AVM_OS_ASSERT_WARNING_ALERT |
| AVM_OS_ASSERT_FATAL_NULL_POINTER_EXIT( mPTR ) |
| << "raw_pointer in BF::as_ptr< T >() !!!" |
| << SEND_EXIT; |
| |
| return( (mPTR != NULL) ? mPTR->as< T >() : NULL ); |
| } |
| |
| template< class T > |
| inline T * to_ptr() const |
| { |
| return( mPTR->to< T >() ); |
| } |
| |
| |
| // cast BF as specified reference |
| template< class T > |
| inline T & as_ref() |
| { |
| AVM_OS_ASSERT_FATAL_NULL_POINTER_EXIT( mPTR ) |
| << "raw_pointer in BF::as_ref< T >() !!!" |
| << SEND_EXIT; |
| |
| return( *( mPTR->as< T >() ) ); |
| } |
| |
| template< class T > |
| inline const T & as_ref() const |
| { |
| AVM_OS_ASSERT_FATAL_NULL_POINTER_EXIT( mPTR ) |
| << "raw_pointer in BF::as< T >() !!!" |
| << SEND_EXIT; |
| |
| return( *( mPTR->as< T >() ) ); |
| } |
| |
| template< class T > |
| inline const T & to_ref() const |
| { |
| return( *( mPTR->as< T >() ) ); |
| } |
| |
| |
| // cast BF as derived BF |
| // template< class T > |
| // inline T & as_bf() |
| // { |
| // return( static_cast< T & >( *this ) ); |
| // } |
| |
| template< class T > |
| inline const T & as_bf() const |
| { |
| return( static_cast< const T & >( *this ) ); |
| } |
| |
| |
| |
| /** |
| * CAST |
| */ |
| // inline operator Element * () const |
| // { |
| // return( mPTR ); |
| // } |
| |
| // Desactive call of << delete >> using compiler ambiguous mecanism |
| // inline operator void * () const |
| // { |
| // return( mPTR ); |
| // } |
| |
| |
| // template< class T > |
| // inline operator T * () |
| // { |
| // return( static_cast< T * >( mPTR ) ); |
| // } |
| // |
| // /** |
| // * OPERATORS |
| // */ |
| // template< class T > |
| // inline T * operator-> () |
| // { |
| // AVM_OS_ASSERT_FATAL_NULL_POINTER_EXIT( mPTR ) |
| // << "raw_pointer in BF::operator->< T >() !!!" |
| // << SEND_EXIT; |
| // |
| // return( static_cast< T * >( mPTR ) ); |
| // } |
| |
| |
| /** |
| * GETTER - SETTER |
| * for container of BF |
| */ |
| // Generally with range check |
| inline const BF & at(avm_size_t offset) const |
| { |
| return( mPTR->at(offset) ); |
| } |
| |
| inline BF & at(avm_size_t offset) |
| { |
| return( mPTR->at(offset) ); |
| } |
| |
| // move to contained element at position < offset > |
| inline void moveAt(avm_size_t offset) |
| { |
| mPTR->decrRefCount(); |
| |
| mPTR = mPTR->at( offset ).mPTR; |
| |
| mPTR->incrRefCount(); |
| } |
| |
| |
| // Generally without range check |
| inline BF & operator[](avm_size_t offset) |
| { |
| return( mPTR->operator[](offset) ); |
| } |
| |
| // Generally without range check |
| inline const BF & operator[](avm_size_t offset) const |
| { |
| return( mPTR->operator[](offset) ); |
| } |
| |
| |
| inline BF & getWritable() |
| { |
| base_this_type::makeWritable(); |
| return( *this ); |
| } |
| |
| inline BF & getWritable(avm_size_t offset) |
| { |
| return( mPTR->getWritable(offset) ); |
| } |
| |
| inline void makeWritable() |
| { |
| base_this_type::makeWritable(); |
| } |
| |
| inline void makeWritable(avm_size_t offset) |
| { |
| mPTR->makeWritable( offset ); |
| } |
| |
| // move to writable contained element at position < offset > |
| inline void moveAtWritable(avm_size_t offset) |
| { |
| mPTR->decrRefCount(); |
| |
| mPTR = mPTR->getWritable( offset ).mPTR; |
| |
| mPTR->incrRefCount(); |
| } |
| |
| |
| inline void set(const BF & bf) |
| { |
| base_this_type::release_acquire( bf.mPTR ); |
| } |
| |
| inline void set(avm_size_t offset, const BF & bf) |
| { |
| mPTR->set(offset, bf); |
| } |
| |
| // inline void mw_set(avm_size_t offset, const BF & bf) |
| // { |
| // base_this_type::makeWritable(); |
| // mPTR->set(offset, bf); |
| // } |
| |
| |
| inline avm_size_t size() const |
| { |
| return( mPTR->size() ); |
| } |
| |
| |
| /** |
| * ASSIGNMENT |
| */ |
| // template< class U > |
| // inline BF & operator=( |
| // const SmartPointer< U , DestroyElementPolicy > & other) |
| // { |
| // if( mPTR != other.raw_pointer() ) |
| // { |
| // AVM_ASSIGN_DEBUG_BF_PTR( other.raw_pointer() ) |
| // |
| // release_acquire( other.raw_pointer() ); |
| // } |
| // return( *this ); |
| // } |
| // |
| // // Symbol |
| // BF & operator=(const Symbol & aSymbol); |
| // |
| // // Type |
| // BF & operator=(const Type & aType); |
| |
| inline BF & operator=(pointer aPtr) |
| { |
| if( mPTR != aPtr ) |
| { |
| AVM_ASSIGN_DEBUG_BF_PTR( aPtr ) |
| |
| release( aPtr ); |
| } |
| return( *this ); |
| } |
| |
| |
| inline void renew(pointer aPtr) |
| { |
| if( mPTR != aPtr ) |
| { |
| release( aPtr ); |
| } |
| } |
| |
| inline void newincr(pointer aPtr) |
| { |
| if( mPTR != aPtr ) |
| { |
| release_acquire( aPtr ); |
| } |
| } |
| |
| /** |
| * COMPARISON |
| * OPERATOR |
| */ |
| |
| inline bool operator==(const BF & other) const |
| { |
| return( (mPTR == other.mPTR) || isEQ(other) ); |
| } |
| |
| inline bool operator==(const Element & aPtr) const |
| { |
| return( (mPTR == &aPtr) || mPTR->isEQ(aPtr) ); |
| } |
| |
| inline bool operator==(const Element * aPtr) const |
| { |
| return( (mPTR == aPtr) || |
| ((aPtr != NULL) && (mPTR != NULL) && mPTR->isEQ(*aPtr)) ); |
| } |
| |
| |
| inline bool operator!=(const BF & other) const |
| { |
| return( (mPTR != other.mPTR) || isNEQ(other) ); |
| } |
| |
| inline bool operator!=(const Element & aPtr) const |
| { |
| return( (mPTR != &aPtr) && mPTR->isNEQ(aPtr) ); |
| } |
| |
| inline bool operator!=(const Element * aPtr) const |
| { |
| return( (mPTR != aPtr) && |
| ((mPTR == NULL) || (aPtr == NULL) || mPTR->isNEQ(*aPtr)) ); |
| } |
| |
| |
| /** |
| * POINTER TRIVIALLY EQUAL COMPARISON |
| */ |
| inline bool isTEQ(const Element * bf) const |
| { |
| return( mPTR == bf ); |
| } |
| |
| inline bool isTEQ(const BF & other) const |
| { |
| return( mPTR == other.mPTR ); |
| } |
| |
| |
| inline bool isNTEQ(const Element * bf) const |
| { |
| return( mPTR != bf ); |
| } |
| |
| inline bool isNTEQ(const BF & other) const |
| { |
| return( mPTR != other.mPTR ); |
| } |
| |
| |
| /** |
| * COMPARISON |
| */ |
| int compare(const BF & other) const; |
| |
| int compare_share(BF & other); |
| |
| |
| bool isEQ(const BF & other) const; |
| |
| inline bool isNEQ(const BF & other) const |
| { |
| return( not isEQ(other) ); |
| } |
| |
| |
| bool strEQ(const BF & other) const |
| { |
| return( (mPTR == other.mPTR) |
| || ((mPTR != NULL) && (other.mPTR != NULL) |
| && (mPTR->str() == other.mPTR->str())) ); |
| } |
| |
| bool strNEQ(const BF & other) const |
| { |
| return( (mPTR != other.mPTR) |
| && ((mPTR == NULL) || (other.mPTR == NULL) |
| || (mPTR->str() != other.mPTR->str())) ); |
| } |
| |
| |
| |
| /** |
| * BUILD NEW EXPRESSION |
| */ |
| BF & opExpr(Operator * anOperator, const BF & arg); |
| |
| BF & eqExpr(const BF & arg); |
| BF & neqExpr(const BF & arg); |
| |
| BF & ltExpr(const BF & arg); |
| BF & lteExpr(const BF & arg); |
| |
| BF & gtExpr(const BF & arg); |
| BF & gteExpr(const BF & arg); |
| |
| |
| BF & andExpr(const BF & arg); |
| BF & orExpr(const BF & arg); |
| BF & notExpr(); |
| |
| BF & addExpr(const BF & arg); |
| BF & incrExpr(avm_uinteger_t val = 1); |
| |
| BF & minusExpr(const BF & arg); |
| BF & uminusExpr(); |
| BF & decrExpr(avm_uinteger_t val = 1); |
| |
| BF & multExpr(const BF & arg); |
| BF & powExpr(const BF & arg); |
| BF & divExpr(const BF & arg); |
| BF & invExpr(); |
| |
| |
| |
| /** |
| * DEFAULT NULL |
| */ |
| static BF REF_NULL; |
| |
| |
| /** |
| * Serialization |
| */ |
| virtual void toStream(OutStream & os) const |
| { |
| if( mPTR != NULL ) |
| { |
| mPTR->toStream( os ); |
| } |
| else |
| { |
| os << TAB << "BF<null>" << EOL_FLUSH; |
| } |
| } |
| |
| virtual void toStream(PairOutStream & os) const |
| { |
| if( mPTR != NULL ) |
| { |
| mPTR->toStream( os.OS1 ); |
| mPTR->toStream( os.OS2 ); |
| } |
| else |
| { |
| os << TAB << "BF<null>" << EOL_FLUSH; |
| } |
| } |
| |
| virtual void toStream(TripleOutStream & os) const |
| { |
| if( mPTR != NULL ) |
| { |
| mPTR->toStream( os.OS1 ); |
| mPTR->toStream( os.OS2 ); |
| mPTR->toStream( os.OS3 ); |
| } |
| else |
| { |
| os << TAB << "BF<null>" << EOL_FLUSH; |
| } |
| } |
| |
| |
| inline virtual std::string toString( |
| const AvmIndent & indent = AVM_TAB_INDENT) const |
| { |
| StringOutStream oss(indent); |
| |
| toStream( oss ); |
| |
| return( oss.str() ); |
| } |
| |
| inline virtual std::string wrapString( |
| const WrapData & wrapData = DEFAULT_WRAP_DATA, |
| const AvmIndent & indent = AVM_TAB_INDENT) const |
| { |
| StringOutStream woss(wrapData, indent); |
| |
| toStream( woss ); |
| |
| return( woss.str() ); |
| } |
| |
| |
| /** |
| * strHeader |
| */ |
| virtual std::string strHeader() const |
| { |
| StringOutStream oss; |
| |
| strHeader( oss ); |
| |
| return( oss.str() ); |
| } |
| |
| virtual void strHeader(OutStream & os) const; |
| |
| virtual void strHeader(PairOutStream & os) const |
| { |
| strHeader( os.OS1 ); |
| strHeader( os.OS2 ); |
| } |
| |
| virtual void strHeader(TripleOutStream & os) const |
| { |
| toStream( os.OS1 ); |
| toStream( os.OS2 ); |
| toStream( os.OS3 ); |
| } |
| |
| |
| inline virtual std::string str() const |
| { |
| return( ( mPTR != NULL ) ? mPTR->str() : ("BF<null>") ); |
| } |
| |
| inline virtual std::string wrapStr( |
| const WrapData & wrapData = DEFAULT_WRAP_DATA) const |
| { |
| StringOutStream woss(DEFAULT_WRAP_DATA, AVM_STR_INDENT); |
| |
| toStream( woss << IGNORE_FIRST_TAB ); |
| |
| return( woss.str() ); |
| } |
| |
| |
| // LEFT TRIM the result |
| inline virtual std::string _str() const |
| { |
| if( mPTR != NULL ) |
| { |
| std::string strTmp = mPTR->str(); |
| |
| return( StringTools::ltrim(strTmp) ); |
| |
| } |
| |
| return( "BF<null>" ); |
| } |
| |
| // RIGTH TRIM the result |
| inline virtual std::string str_() const |
| { |
| if( mPTR != NULL ) |
| { |
| std::string strTmp = mPTR->str(); |
| |
| return( StringTools::rtrim(strTmp) ); |
| |
| } |
| |
| return( "BF<null>" ); |
| } |
| |
| // LEFT & RIGTH TRIM the result |
| inline virtual std::string _str_() const |
| { |
| if( mPTR != NULL ) |
| { |
| std::string strTmp = mPTR->str(); |
| |
| return( StringTools::trim(strTmp) ); |
| |
| } |
| |
| return( "BF<null>" ); |
| } |
| |
| |
| inline virtual std::string strNum( |
| uint8_t precision = AVM_MUMERIC_PRECISION) const |
| { |
| return( ( mPTR != NULL ) ? mPTR->strNum(precision) : "BF<null>" ); |
| } |
| |
| |
| inline virtual void AVM_DEBUG_REF_COUNTER(OutStream & os) const |
| { |
| if( mPTR != NULL ) |
| { |
| mPTR->AVM_DEBUG_REF_COUNTER(os); |
| } |
| else |
| { |
| os << "BF<null, ref:0>" << std::flush; |
| } |
| } |
| |
| inline virtual std::string AVM_DEBUG_REF_COUNTER() const |
| { |
| return( ( mPTR != NULL ) ? |
| mPTR->AVM_DEBUG_REF_COUNTER() : "BF<null, ref:0>" ); |
| } |
| |
| |
| private: |
| |
| /** Share equal objects between expressions. |
| */ |
| inline void share(BF & other) |
| { |
| if( getRefCount() <= other.getRefCount() ) |
| { |
| acquirePointer( other.mPTR ); |
| } |
| else |
| { |
| other.acquirePointer( mPTR ); |
| } |
| } |
| |
| }; |
| |
| |
| /** |
| * operator<< |
| */ |
| AVM_OS_STREAM( BF ) |
| |
| |
| } |
| |
| #endif /* BF_H_ */ |