| /******************************************************************************* | |
| * 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: 18 sept. 2009 | |
| * | |
| * Contributors: | |
| * Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr | |
| * - Initial API and implementation | |
| ******************************************************************************/ | |
| #include "ExpressionTypeChecker.h" | |
| #include <fml/executable/InstanceOfMachine.h> | |
| #include <fml/expression/BuiltinArray.h> | |
| #include <fml/builtin/Identifier.h> | |
| #include <fml/builtin/QualifiedIdentifier.h> | |
| #include <fml/type/BaseTypeSpecifier.h> | |
| #include <fml/type/ClassTypeSpecifier.h> | |
| #include <fml/type/ContainerTypeSpecifier.h> | |
| #include <fml/type/EnumTypeSpecifier.h> | |
| #include <fml/type/IntervalTypeSpecifier.h> | |
| #include <fml/type/TypeAliasSpecifier.h> | |
| #include <fml/type/TypeManager.h> | |
| namespace sep | |
| { | |
| bool ExpressionTypeChecker::isFinalSymbolicBasicSymbol(const BF & anElement) | |
| { | |
| if( anElement.is< Identifier >() || anElement.is< QualifiedIdentifier >() ) | |
| { | |
| return( false ); | |
| } | |
| else if( anElement.is< BuiltinForm >() ) | |
| { | |
| return( true ); | |
| } | |
| else if( anElement.is< InstanceOfData >() ) | |
| { | |
| InstanceOfData * anInstance = anElement.to_ptr< InstanceOfData >(); | |
| if( anInstance->isTypedEnum() ) | |
| { | |
| return( anInstance->isEnumSymbolPointer() ); | |
| } | |
| else if( anInstance->isTypedMachine() ) | |
| { | |
| return( true ); | |
| } | |
| // else if( anInstance->getModifier().hasModifierPublicFinalStatic() ) | |
| // { | |
| // return( true ); | |
| // } | |
| } | |
| else if( anElement.is< InstanceOfMachine >() | |
| && anElement.to_ptr< InstanceOfMachine >()-> | |
| getModifier().hasModifierPublicFinalStatic() ) | |
| { | |
| return( true ); | |
| } | |
| else if( anElement.is< BaseInstanceForm >() | |
| && anElement.to_ptr< BaseInstanceForm >()-> | |
| getModifier().hasModifierPublicFinalStatic() ) | |
| { | |
| return( true ); | |
| } | |
| else if( anElement.is_strictly< BuiltinArray >() ) | |
| { | |
| return( true ); | |
| } | |
| return( false ); | |
| } | |
| bool ExpressionTypeChecker::isFinalSymbolicCompositeSymbol(const BF & anElement) | |
| { | |
| if( anElement.is< BuiltinArray >() ) | |
| { | |
| return( isFinalSymbolicCompositeSymbol(anElement.to_ptr< BuiltinArray >()) ); | |
| } | |
| else | |
| { | |
| return( false ); | |
| } | |
| } | |
| bool ExpressionTypeChecker::isFinalSymbolicCompositeSymbol( | |
| BuiltinArray * arrayForm) | |
| { | |
| if( arrayForm->is_strictly< ArrayBF >() ) | |
| { | |
| return( true ); | |
| } | |
| if( arrayForm->is< ArrayBF >() ) | |
| { | |
| ArrayBF * bfArray = arrayForm->to< ArrayBF >(); | |
| for( avm_size_t idx = 0 ; idx < bfArray->size() ; ++idx ) | |
| { | |
| if( not isFinalSymbolicSymbol( bfArray->at(idx) ) ) | |
| { | |
| return( false ); | |
| } | |
| } | |
| } | |
| return( false ); | |
| } | |
| bool ExpressionTypeChecker::isMachine(const BF & anExpr) | |
| { | |
| if( (anExpr.is< BaseInstanceForm >() && | |
| anExpr.to_ptr< BaseInstanceForm >()->isTypedMachine()) || | |
| anExpr.is< RuntimeID >() ) | |
| { | |
| return( true ); | |
| } | |
| else | |
| { | |
| return( StatementTypeChecker::isMachine( anExpr ) ); | |
| } | |
| } | |
| bool ExpressionTypeChecker::isArray( | |
| ContainerTypeSpecifier * refTypeSpecifier, const BF & anExpr) | |
| { | |
| if( anExpr.is< ArrayBF >() ) | |
| { | |
| ArrayBF * bArray = anExpr.to_ptr< ArrayBF >(); | |
| for( avm_size_t idx = 1 ; idx < bArray->size() ; ++idx ) | |
| { | |
| if( not isTyped(refTypeSpecifier->getContentsTypeSpecifier(), | |
| bArray->at(idx)) ) | |
| { | |
| return( false ); | |
| } | |
| } | |
| return( true ); | |
| } | |
| else if( anExpr.is< BuiltinArray >() ) | |
| { | |
| BuiltinArray * bArray = anExpr.to_ptr< BuiltinArray >(); | |
| if( refTypeSpecifier == bArray->getTypeSpecifier() ) | |
| { | |
| return( true ); | |
| } | |
| else if( bArray->getTypeSpecifier()->isTypedArray() && | |
| (refTypeSpecifier->getContentsTypeSpecifier() == bArray-> | |
| getTypeSpecifier()->as< ContainerTypeSpecifier >()-> | |
| getContentsTypeSpecifier()) ) | |
| { | |
| return( true ); | |
| } | |
| else | |
| { | |
| AVM_OS_WARN << "ExpressionTypeChecker::isArray :> ref< @ " | |
| << refTypeSpecifier << "->" << refTypeSpecifier->strT() | |
| << " > =/= dtype< @ " | |
| << bArray->getTypeSpecifier() | |
| << "-> " << bArray->getTypeSpecifier()->strT() | |
| << " >" << std::endl; | |
| // bArray->getTypeSpecifier()->toStream(AVM_OS_WARN); | |
| } | |
| return( ExpressionTypeChecker::weaklyTyped( | |
| refTypeSpecifier->getContentsTypeSpecifier(), | |
| bArray->getTypeSpecifier()) ); | |
| } | |
| else if( anExpr.is< BaseInstanceForm >() ) | |
| { | |
| return( ExpressionTypeChecker::weaklyTyped( | |
| refTypeSpecifier->getContentsTypeSpecifier(), | |
| anExpr.to_ptr< BaseInstanceForm >()->getTypeSpecifier()) ); | |
| } | |
| else return( false ); | |
| } | |
| bool ExpressionTypeChecker::isClass( | |
| ClassTypeSpecifier * refTypeSpecifier, const BF & anExpr) | |
| { | |
| if( anExpr.is< BuiltinArray >() ) | |
| { | |
| BuiltinArray * bArray = anExpr.to_ptr< BuiltinArray >(); | |
| if( refTypeSpecifier == bArray->getTypeSpecifier() ) | |
| { | |
| return( true ); | |
| } | |
| else if( refTypeSpecifier->size() != bArray->size() ) | |
| { | |
| return( false ); | |
| } | |
| else if( bArray->hasTypeSpecifier() && | |
| anExpr.is_strictly< BuiltinArray >() && | |
| bArray->getTypeSpecifier()->hasTypeContainer() ) | |
| { | |
| BaseTypeSpecifier * eltTS = bArray->getTypeSpecifier()-> | |
| as< ContainerTypeSpecifier >()->getContentsTypeSpecifier(); | |
| TableOfSymbol::const_iterator it = | |
| refTypeSpecifier->getSymbolData().begin(); | |
| TableOfSymbol::const_iterator endIt = | |
| refTypeSpecifier->getSymbolData().end(); | |
| for( ; it != endIt ; ++it ) | |
| { | |
| if( not ExpressionTypeChecker::isTyped( | |
| (*it).getTypeSpecifier(), eltTS) ) | |
| { | |
| AVM_OS_WARN << "ExpressionTypeChecker::isClass :> ref< " | |
| << (*it).getTypeSpecifier()->strT() | |
| << " > =/= dtype< " << eltTS->strT() << " >" | |
| << std::endl; | |
| return( false ); | |
| } | |
| } | |
| return( true ); | |
| } | |
| else if( bArray->is< ArrayBF >() ) | |
| { | |
| ArrayBF * bfArray = bArray->to< ArrayBF >(); | |
| TableOfSymbol::const_iterator it = | |
| refTypeSpecifier->getSymbolData().begin(); | |
| TableOfSymbol::const_iterator endIt = | |
| refTypeSpecifier->getSymbolData().end(); | |
| for( avm_size_t offset = 0; it != endIt ; ++it , ++offset ) | |
| { | |
| if( not ExpressionTypeChecker::isTyped( | |
| (*it).getTypeSpecifier(), bfArray->at(offset)) ) | |
| { | |
| AVM_OS_WARN << "ExpressionTypeChecker::isClass :> ref< " | |
| << (*it).getTypeSpecifier()->strT() << " > =/= arg<" | |
| << str_indent( bfArray->at(offset) ) << " >" | |
| << std::endl; | |
| return( false ); | |
| } | |
| } | |
| return( true ); | |
| } | |
| } | |
| else if( anExpr.is< BaseInstanceForm >() ) | |
| { | |
| return( ExpressionTypeChecker::isTyped(refTypeSpecifier, | |
| anExpr.to_ptr< BaseInstanceForm >()->getTypeSpecifier()) ); | |
| } | |
| else if( anExpr.is< ArrayBF >() ) | |
| { | |
| ArrayBF * bfArray = anExpr.to_ptr< ArrayBF >(); | |
| if( refTypeSpecifier->getSymbolData().size() != bfArray->size() ) | |
| { | |
| return( false ); | |
| } | |
| TableOfSymbol::const_iterator it = | |
| refTypeSpecifier->getSymbolData().begin(); | |
| TableOfSymbol::const_iterator endIt = | |
| refTypeSpecifier->getSymbolData().end(); | |
| for( avm_size_t offset = 0; it != endIt ; ++it , ++offset ) | |
| { | |
| if( not ExpressionTypeChecker::isTyped( | |
| (*it).getTypeSpecifier(), bfArray->get(offset)) ) | |
| { | |
| AVM_OS_WARN << "ExpressionTypeChecker::isClass :> ref< " | |
| << (*it).getTypeSpecifier()->strT() | |
| << " > =/= dtype< " << bfArray->get(offset).str() | |
| << " >" << std::endl; | |
| return( false ); | |
| } | |
| } | |
| return( true ); | |
| } | |
| return( false ); | |
| } | |
| bool ExpressionTypeChecker::isCollection( | |
| ContainerTypeSpecifier * refTypeSpecifier, const BF & anExpr) | |
| { | |
| if( anExpr.is< ArrayBF >() ) | |
| { | |
| ArrayBF * bArray = anExpr.to_ptr< ArrayBF >(); | |
| for( avm_size_t idx = 1 ; idx < bArray->size() ; ++idx ) | |
| { | |
| if( not isTyped(refTypeSpecifier->getContentsTypeSpecifier(), | |
| bArray->at(idx)) ) | |
| { | |
| return( false ); | |
| } | |
| } | |
| return( true ); | |
| } | |
| else if( anExpr.is< BuiltinContainer >() ) | |
| { | |
| BuiltinContainer * bArray = anExpr.to_ptr< BuiltinContainer >(); | |
| for( avm_size_t idx = 1 ; idx < bArray->size() ; ++idx ) | |
| { | |
| if( not isTyped(refTypeSpecifier->getContentsTypeSpecifier(), | |
| bArray->at(idx)) ) | |
| { | |
| return( false ); | |
| } | |
| } | |
| return( true ); | |
| } | |
| else if( anExpr.is< BuiltinArray >() ) | |
| { | |
| BuiltinArray * bArray = anExpr.to_ptr< BuiltinArray >(); | |
| if( refTypeSpecifier == bArray->getTypeSpecifier() ) | |
| { | |
| return( true ); | |
| } | |
| else if( bArray->getTypeSpecifier()->isTypedArray() && | |
| (refTypeSpecifier->getContentsTypeSpecifier() == bArray-> | |
| getTypeSpecifier()->as< ContainerTypeSpecifier >()-> | |
| getContentsTypeSpecifier()) ) | |
| { | |
| return( true ); | |
| } | |
| else | |
| { | |
| AVM_OS_WARN << "ExpressionTypeChecker::isCollection :> ref< @ " | |
| << refTypeSpecifier << "->" << refTypeSpecifier->strT() | |
| << " > =/= dtype< @ " | |
| << bArray->getTypeSpecifier() | |
| << "-> " << bArray->getTypeSpecifier()->strT() | |
| << " >" << std::endl; | |
| // bArray->getTypeSpecifier()->toStream(AVM_OS_WARN); | |
| } | |
| return( ExpressionTypeChecker::weaklyTyped( | |
| refTypeSpecifier->getContentsTypeSpecifier(), | |
| bArray->getTypeSpecifier()) ); | |
| } | |
| else if( anExpr.is< BaseInstanceForm >() ) | |
| { | |
| return( ExpressionTypeChecker::weaklyTyped( | |
| refTypeSpecifier->getContentsTypeSpecifier(), | |
| anExpr.to_ptr< BaseInstanceForm >()->getTypeSpecifier()) ); | |
| } | |
| else if( anExpr.is< AvmCode >() ) | |
| { | |
| AvmCode * aCode = anExpr.to_ptr< AvmCode >(); | |
| if( OperatorManager::isContainerOperation(aCode->getOperator()) ) | |
| { | |
| return( ExpressionTypeChecker::isTyped( | |
| refTypeSpecifier, aCode->first()) ); | |
| } | |
| if( OperatorManager::isContainerElementAccess(aCode->getOperator()) ) | |
| { | |
| if( aCode->first().is< BaseInstanceForm >() ) | |
| { | |
| BaseTypeSpecifier * bts = aCode->first(). | |
| to_ptr< BaseInstanceForm >()->getTypeSpecifier(); | |
| return( bts->hasTypeContainer() && | |
| ExpressionTypeChecker::isTyped(refTypeSpecifier, | |
| bts->as< ContainerTypeSpecifier >()-> | |
| getContentsTypeSpecifier()) ); | |
| } | |
| else | |
| { | |
| return( false ); | |
| } | |
| } | |
| else return( false ); | |
| } | |
| else return( false ); | |
| } | |
| bool ExpressionTypeChecker::isVector(const BF & anExpr) | |
| { | |
| if( anExpr.is< BuiltinVector >() ) | |
| { | |
| return( true ); | |
| } | |
| else if( anExpr.is< BaseInstanceForm >() ) | |
| { | |
| return( anExpr.to_ptr< BaseInstanceForm >()-> | |
| getTypeSpecifier()->hasTypeVector() ); | |
| } | |
| else if( anExpr.is< AvmCode >() ) | |
| { | |
| AvmCode * aCode = anExpr.to_ptr< AvmCode >(); | |
| if( OperatorManager::isContainerOperation(aCode->getOperator()) ) | |
| { | |
| return( ExpressionTypeChecker::isVector( aCode->first() ) ); | |
| } | |
| else if( OperatorManager::isCtor( aCode->getOperator() ) ) | |
| { | |
| return( aCode->first().is< BaseTypeSpecifier >() && | |
| aCode->first().to_ptr< | |
| BaseTypeSpecifier >()->hasTypeVector() ); | |
| } | |
| else return( false ); | |
| } | |
| else return( false ); | |
| } | |
| bool ExpressionTypeChecker::isEnum( | |
| EnumTypeSpecifier * refTypeSpecifier, const BF & anExpr) | |
| { | |
| if( anExpr.is< InstanceOfData >() ) | |
| { | |
| if( refTypeSpecifier == anExpr.to_ptr< InstanceOfData >()->getTypeSpecifier() ) | |
| { | |
| return( true ); | |
| } | |
| else | |
| { | |
| AVM_OS_WARN << "ExpressionTypeChecker::isEnum :> ref< @ " | |
| << refTypeSpecifier->strT() << " > =/= dtype< @ " | |
| << anExpr.to_ptr< InstanceOfData >()->getTypeSpecifier()->strT() | |
| << " >" << std::endl; | |
| return( false); | |
| } | |
| } | |
| else if( anExpr.is< BaseInstanceForm >() ) | |
| { | |
| return( ExpressionTypeChecker::isTyped(refTypeSpecifier, | |
| anExpr.to_ptr< BaseInstanceForm >()->getTypeSpecifier()) ); | |
| } | |
| else if( anExpr.isNumeric() ) | |
| { | |
| return( refTypeSpecifier->hasSymbolDataWithValue(anExpr) ); | |
| } | |
| else if( anExpr.is< AvmCode >() ) | |
| { | |
| AvmCode * aCode = anExpr.to_ptr< AvmCode >(); | |
| if( OperatorManager::isContainerElementAccess(aCode->getOperator()) ) | |
| { | |
| if( aCode->first().is< BaseInstanceForm >() ) | |
| { | |
| BaseTypeSpecifier * bts = aCode->first(). | |
| to_ptr< BaseInstanceForm >()->getTypeSpecifier(); | |
| return( bts->hasTypeContainer() && | |
| ExpressionTypeChecker::isTyped(refTypeSpecifier, | |
| bts->as< ContainerTypeSpecifier >()-> | |
| getContentsTypeSpecifier()) ); | |
| } | |
| } | |
| } | |
| return( false ); | |
| } | |
| bool ExpressionTypeChecker::isEnum(const BF & anExpr) | |
| { | |
| if( anExpr.is< BaseInstanceForm >() ) | |
| { | |
| return( anExpr.to_ptr< BaseInstanceForm >()->isTypedEnum() ); | |
| } | |
| else return( false ); | |
| } | |
| bool ExpressionTypeChecker::isCharacter(const BF & anExpr) | |
| { | |
| if( anExpr.isCharacter() ) | |
| { | |
| return( true ); | |
| } | |
| else if( anExpr.is< BaseInstanceForm >() ) | |
| { | |
| return( anExpr.to_ptr< BaseInstanceForm >()->isTypedCharacter() ); | |
| } | |
| else if( anExpr.is< AvmCode >() ) | |
| { | |
| AvmCode * aCode = anExpr.to_ptr< AvmCode >(); | |
| if( aCode->hasInstruction() && (aCode->getInstruction()-> | |
| getMainProcessor() == AVM_ARG_CHARACTER_CPU) ) | |
| { | |
| return( true ); | |
| } | |
| else if( OperatorManager::isCtor( aCode->getOperator() ) ) | |
| { | |
| return( aCode->first().is< BaseTypeSpecifier >() && | |
| aCode->first().to_ptr< BaseTypeSpecifier >()-> | |
| isTypedCharacter() ); | |
| } | |
| else if( OperatorManager::isAssign( aCode->getOperator() ) ) | |
| { | |
| if( aCode->first().is< BaseInstanceForm >() ) | |
| { | |
| return( aCode->first().to_ptr< BaseInstanceForm >() | |
| ->isTypedCharacter() ); | |
| } | |
| else if( OperatorManager::isAssignBinary( aCode->getOperator() ) ) | |
| { | |
| return( ExpressionTypeChecker::isCharacter(aCode->second()) ); | |
| } | |
| return( false ); | |
| } | |
| else if( OperatorManager::isCharacter( aCode->getOperator() ) ) | |
| { | |
| for(AvmCode::iterator it = aCode->begin() ; it != aCode->end() ; ++it) | |
| { | |
| if( not ExpressionTypeChecker::isCharacter( *it ) ) | |
| { | |
| return( false ); | |
| } | |
| } | |
| return( true ); | |
| } | |
| else if( OperatorManager::isContainerElementAccess( | |
| aCode->getOperator() ) ) | |
| { | |
| if( aCode->first().is< BaseInstanceForm >() ) | |
| { | |
| BaseTypeSpecifier * bts = aCode->first(). | |
| to_ptr< BaseInstanceForm >()->getTypeSpecifier(); | |
| return( bts->hasTypeContainer() && | |
| bts->as< ContainerTypeSpecifier >()-> | |
| getContentsTypeSpecifier().isTypedCharacter() ); | |
| } | |
| else | |
| { | |
| return( false ); | |
| } | |
| } | |
| else return( false ); | |
| } | |
| else return( false ); | |
| } | |
| bool ExpressionTypeChecker::isString(const BF & anExpr) | |
| { | |
| if( anExpr.isBuiltinString() ) | |
| { | |
| return( true ); | |
| } | |
| else if( anExpr.is< BaseInstanceForm >() ) | |
| { | |
| return( anExpr.to_ptr< BaseInstanceForm >()->isTypedString() ); | |
| } | |
| else if( anExpr.is< AvmCode >() ) | |
| { | |
| AvmCode * aCode = anExpr.to_ptr< AvmCode >(); | |
| if( aCode->hasInstruction() && (aCode->getInstruction()-> | |
| getMainProcessor() == AVM_ARG_STRING_CPU) ) | |
| { | |
| return( true ); | |
| } | |
| else if( OperatorManager::isCtor( aCode->getOperator() ) ) | |
| { | |
| return( aCode->first().is< BaseTypeSpecifier >() && | |
| aCode->first().to_ptr< BaseTypeSpecifier >()->isTypedString() ); | |
| } | |
| else if( OperatorManager::isAssign( aCode->getOperator() ) ) | |
| { | |
| if( aCode->first().is< BaseInstanceForm >() ) | |
| { | |
| return( aCode->first().to_ptr< BaseInstanceForm >() | |
| ->isTypedString() ); | |
| } | |
| else if( OperatorManager::isAssignBinary( aCode->getOperator() ) ) | |
| { | |
| return( ExpressionTypeChecker::isString(aCode->second()) ); | |
| } | |
| return( false ); | |
| } | |
| else if( OperatorManager::isString( aCode->getOperator() ) ) | |
| { | |
| for(AvmCode::iterator it = aCode->begin() ; it != aCode->end() ; ++it) | |
| { | |
| if( not ExpressionTypeChecker::isString( *it ) ) | |
| { | |
| return( false ); | |
| } | |
| } | |
| return( true ); | |
| } | |
| else if( OperatorManager::isContainerElementAccess( | |
| aCode->getOperator() ) ) | |
| { | |
| if( aCode->first().is< BaseInstanceForm >() ) | |
| { | |
| BaseTypeSpecifier * bts = aCode->first(). | |
| to_ptr< BaseInstanceForm >()->getTypeSpecifier(); | |
| return( bts->hasTypeContainer() && | |
| bts->as< ContainerTypeSpecifier >()-> | |
| getContentsTypeSpecifier().isTypedString() ); | |
| } | |
| else | |
| { | |
| return( false ); | |
| } | |
| } | |
| else return( false ); | |
| } | |
| else return( false ); | |
| } | |
| bool ExpressionTypeChecker::isBoolean(const BF & anExpr, bool stronglyTypedFlag) | |
| { | |
| if( anExpr.isBoolean() ) | |
| { | |
| return( true ); | |
| } | |
| else if( anExpr.is< BaseInstanceForm >() ) | |
| { | |
| return( anExpr.to_ptr< BaseInstanceForm >()->isTypedBoolean() ); | |
| } | |
| else if( anExpr.is< AvmCode >() ) | |
| { | |
| AvmCode * aCode = anExpr.to_ptr< AvmCode >(); | |
| if( OperatorManager::isCtor( aCode->getOperator() ) ) | |
| { | |
| return( aCode->first().is< BaseTypeSpecifier >() && | |
| aCode->first().to_ptr< BaseTypeSpecifier >()-> | |
| isTypedBoolean() ); | |
| } | |
| else if( OperatorManager::isAssign( aCode->getOperator() ) ) | |
| { | |
| if( aCode->first().is< BaseInstanceForm >() ) | |
| { | |
| return(aCode->first().to_ptr< BaseInstanceForm >() | |
| ->isTypedBoolean() ); | |
| } | |
| else if( OperatorManager::isAssignBinary( aCode->getOperator() ) ) | |
| { | |
| return( ExpressionTypeChecker::isBoolean(aCode->second(), | |
| stronglyTypedFlag) ); | |
| } | |
| return( false ); | |
| } | |
| else if( OperatorManager::isRelational( aCode->getOperator() ) ) | |
| { | |
| return( true ); | |
| } | |
| else if( OperatorManager::isPropositional( aCode->getOperator() ) ) | |
| { | |
| if( stronglyTypedFlag ) | |
| { | |
| for(AvmCode::iterator it = aCode->begin() ; it != aCode->end() ; ++it) | |
| { | |
| if( not ExpressionTypeChecker::isBoolean( *it ) ) | |
| { | |
| return( false ); | |
| } | |
| } | |
| } | |
| return( true ); | |
| } | |
| else if( OperatorManager::isContainerElementAccess( | |
| aCode->getOperator() ) ) | |
| { | |
| if( aCode->first().is< BaseInstanceForm >() ) | |
| { | |
| BaseTypeSpecifier * bts = aCode->first(). | |
| to_ptr< BaseInstanceForm >()->getTypeSpecifier(); | |
| return( bts->hasTypeContainer() && | |
| bts->as< ContainerTypeSpecifier >()-> | |
| getContentsTypeSpecifier().isTypedBoolean() ); | |
| } | |
| else | |
| { | |
| return( false ); | |
| } | |
| } | |
| else return( false ); | |
| } | |
| else return( false ); | |
| } | |
| bool ExpressionTypeChecker::isInteger(const BF & anExpr) | |
| { | |
| if( anExpr.isWeakInteger() ) | |
| { | |
| return( true ); | |
| } | |
| else if( anExpr.is< BaseInstanceForm >() ) | |
| { | |
| return( anExpr.to_ptr< BaseInstanceForm >()->weaklyTypedInteger() ); | |
| } | |
| else if( anExpr.is< AvmCode >() ) | |
| { | |
| AvmCode * aCode = anExpr.to_ptr< AvmCode >(); | |
| if( OperatorManager::isCtor( aCode->getOperator() ) ) | |
| { | |
| return( aCode->first().is< BaseTypeSpecifier >() && | |
| aCode->first().to_ptr< BaseTypeSpecifier >()-> | |
| weaklyTypedInteger() ); | |
| } | |
| else if( OperatorManager::isAssign( aCode->getOperator() ) ) | |
| { | |
| if( aCode->first().is< BaseInstanceForm >() ) | |
| { | |
| return( aCode->first().to_ptr< BaseInstanceForm >() | |
| ->weaklyTypedInteger() ); | |
| } | |
| else if( OperatorManager::isAssignBinary( aCode->getOperator() ) ) | |
| { | |
| return( ExpressionTypeChecker::isInteger(aCode->second()) ); | |
| } | |
| return( false ); | |
| } | |
| else if( OperatorManager::isArithmetic( aCode->getOperator() ) ) | |
| { | |
| for(AvmCode::iterator it = aCode->begin() ; it != aCode->end() ; ++it) | |
| { | |
| if( not ExpressionTypeChecker::isInteger( *it ) ) | |
| { | |
| return( false ); | |
| } | |
| } | |
| return( true ); | |
| } | |
| else if( OperatorManager::isCodomainInteger( aCode->getOperator() ) ) | |
| { | |
| return( true ); | |
| } | |
| else if( OperatorManager::isContainerElementAccess( | |
| aCode->getOperator() ) ) | |
| { | |
| if( aCode->first().is< BaseInstanceForm >() ) | |
| { | |
| BaseTypeSpecifier * bts = aCode->first(). | |
| to_ptr< BaseInstanceForm >()->getTypeSpecifier(); | |
| return( bts->hasTypeContainer() && | |
| bts->as< ContainerTypeSpecifier >()-> | |
| getContentsTypeSpecifier().weaklyTypedInteger() ); | |
| } | |
| else | |
| { | |
| return( false ); | |
| } | |
| } | |
| else return( false ); | |
| } | |
| else return( false ); | |
| } | |
| bool ExpressionTypeChecker::isRational(const BF & anExpr) | |
| { | |
| if( anExpr.isWeakRational() ) | |
| { | |
| return( true ); | |
| } | |
| else if( anExpr.is< BaseInstanceForm >() ) | |
| { | |
| return( anExpr.to_ptr< BaseInstanceForm >()->weaklyTypedRational() ); | |
| } | |
| else if( anExpr.is< AvmCode >() ) | |
| { | |
| AvmCode * aCode = anExpr.to_ptr< AvmCode >(); | |
| if( OperatorManager::isCtor( aCode->getOperator() ) ) | |
| { | |
| return( aCode->first().is< BaseTypeSpecifier >() && | |
| aCode->first().to_ptr< BaseTypeSpecifier >()-> | |
| weaklyTypedRational() ); | |
| } | |
| else if( OperatorManager::isAssign( aCode->getOperator() ) ) | |
| { | |
| if( aCode->first().is< BaseInstanceForm >() ) | |
| { | |
| return( aCode->first().to_ptr< BaseInstanceForm >() | |
| ->weaklyTypedRational() ); | |
| } | |
| else if( OperatorManager::isAssignBinary( aCode->getOperator() ) ) | |
| { | |
| return( ExpressionTypeChecker::isRational(aCode->second()) ); | |
| } | |
| return( false ); | |
| } | |
| else if( OperatorManager::isArithmetic( aCode->getOperator() ) ) | |
| { | |
| for(AvmCode::iterator it = aCode->begin() ; it != aCode->end() ; ++it) | |
| { | |
| if( not ExpressionTypeChecker::isRational( *it ) ) | |
| { | |
| return( false ); | |
| } | |
| } | |
| return( true ); | |
| } | |
| else if( OperatorManager::isCodomainRational( aCode->getOperator() ) ) | |
| { | |
| return( true ); | |
| } | |
| else if( OperatorManager::isContainerElementAccess( | |
| aCode->getOperator() ) ) | |
| { | |
| if( aCode->first().is< BaseInstanceForm >() ) | |
| { | |
| BaseTypeSpecifier * bts = aCode->first(). | |
| to_ptr< BaseInstanceForm >()->getTypeSpecifier(); | |
| return( bts->hasTypeContainer() && | |
| bts->as< ContainerTypeSpecifier >()-> | |
| getContentsTypeSpecifier().weaklyTypedRational() ); | |
| } | |
| else | |
| { | |
| return( false ); | |
| } | |
| } | |
| else return( false ); | |
| } | |
| else return( false ); | |
| } | |
| bool ExpressionTypeChecker::isFloat(const BF & anExpr) | |
| { | |
| if( anExpr.isWeakFloat() ) | |
| { | |
| return( true ); | |
| } | |
| else if( anExpr.is< BaseInstanceForm >() ) | |
| { | |
| return( anExpr.to_ptr< BaseInstanceForm >()->weaklyTypedFloat() ); | |
| } | |
| else if( anExpr.is< AvmCode >() ) | |
| { | |
| AvmCode * aCode = anExpr.to_ptr< AvmCode >(); | |
| if( OperatorManager::isCtor( aCode->getOperator() ) ) | |
| { | |
| return( aCode->first().is< BaseTypeSpecifier >() && | |
| aCode->first().to_ptr< BaseTypeSpecifier >()-> | |
| weaklyTypedFloat() ); | |
| } | |
| else if( OperatorManager::isAssign( aCode->getOperator() ) ) | |
| { | |
| if( aCode->first().is< BaseInstanceForm >() ) | |
| { | |
| return( aCode->first().to_ptr< BaseInstanceForm >() | |
| ->weaklyTypedFloat() ); | |
| } | |
| else if( OperatorManager::isAssignBinary( aCode->getOperator() ) ) | |
| { | |
| return( ExpressionTypeChecker::isFloat(aCode->second()) ); | |
| } | |
| return( false ); | |
| } | |
| else if( OperatorManager::isArithmetic( aCode->getOperator() ) ) | |
| { | |
| for(AvmCode::iterator it = aCode->begin() ; it != aCode->end() ; ++it) | |
| { | |
| if( not ExpressionTypeChecker::isFloat( *it ) ) | |
| { | |
| return( false ); | |
| } | |
| } | |
| return( true ); | |
| } | |
| else if( OperatorManager::isCodomainFloat( aCode->getOperator() ) ) | |
| { | |
| return( true ); | |
| } | |
| else if( OperatorManager::isContainerElementAccess( | |
| aCode->getOperator() ) ) | |
| { | |
| if( aCode->first().is< BaseInstanceForm >() ) | |
| { | |
| BaseTypeSpecifier * bts = aCode->first(). | |
| to_ptr< BaseInstanceForm >()->getTypeSpecifier(); | |
| return( bts->hasTypeContainer() && | |
| bts->as< ContainerTypeSpecifier >()-> | |
| getContentsTypeSpecifier().weaklyTypedFloat() ); | |
| } | |
| else | |
| { | |
| return( false ); | |
| } | |
| } | |
| else return( false ); | |
| } | |
| else return( false ); | |
| } | |
| bool ExpressionTypeChecker::isReal(const BF & anExpr) | |
| { | |
| if( anExpr.isWeakReal() ) | |
| { | |
| return( true ); | |
| } | |
| else if( anExpr.is< BaseInstanceForm >() ) | |
| { | |
| return( anExpr.to_ptr< BaseInstanceForm >()->weaklyTypedReal() ); | |
| } | |
| else if( anExpr.is< AvmCode >() ) | |
| { | |
| AvmCode * aCode = anExpr.to_ptr< AvmCode >(); | |
| if( OperatorManager::isCtor( aCode->getOperator() ) ) | |
| { | |
| return( aCode->first().is< BaseTypeSpecifier >() && | |
| aCode->first().to_ptr< BaseTypeSpecifier >()-> | |
| weaklyTypedReal() ); | |
| } | |
| else if( OperatorManager::isAssign( aCode->getOperator() ) ) | |
| { | |
| if( aCode->first().is< BaseInstanceForm >() ) | |
| { | |
| return( aCode->first().to_ptr< | |
| BaseInstanceForm >()->weaklyTypedReal() ); | |
| } | |
| else if( OperatorManager::isAssignBinary( aCode->getOperator() ) ) | |
| { | |
| return( ExpressionTypeChecker::isReal(aCode->second()) ); | |
| } | |
| return( false ); | |
| } | |
| else if( OperatorManager::isArithmetic( aCode->getOperator() ) ) | |
| { | |
| for(AvmCode::iterator it = aCode->begin() ; it != aCode->end() ; ++it) | |
| { | |
| if( not ExpressionTypeChecker::isReal( *it ) ) | |
| { | |
| return( false ); | |
| } | |
| } | |
| return( true ); | |
| } | |
| else if( OperatorManager::isCodomainReal( aCode->getOperator() ) ) | |
| { | |
| return( true ); | |
| } | |
| else if( OperatorManager::isContainerElementAccess( | |
| aCode->getOperator() ) ) | |
| { | |
| if( aCode->first().is< BaseInstanceForm >() ) | |
| { | |
| BaseTypeSpecifier * bts = aCode->first(). | |
| to_ptr< BaseInstanceForm >()->getTypeSpecifier(); | |
| return( bts->hasTypeContainer() && | |
| bts->as< ContainerTypeSpecifier >()-> | |
| getContentsTypeSpecifier().weaklyTypedReal() ); | |
| } | |
| else | |
| { | |
| return( false ); | |
| } | |
| } | |
| else return( false ); | |
| } | |
| else return( false ); | |
| } | |
| bool ExpressionTypeChecker::isOperator(const BF & anExpr) | |
| { | |
| if( anExpr.is< Operator >() ) | |
| { | |
| return( true ); | |
| } | |
| else if( anExpr.is< BaseInstanceForm >() ) | |
| { | |
| return( ExpressionTypeChecker::weaklyTyped(TypeManager::OPERATOR, | |
| anExpr.to_ptr< BaseInstanceForm >()->getTypeSpecifier()) ); | |
| } | |
| else return( false ); | |
| } | |
| bool ExpressionTypeChecker::isAvmCode(const BF & anExpr) | |
| { | |
| if( anExpr.is< AvmCode >() ) | |
| { | |
| return( true ); | |
| } | |
| else if( anExpr.is< BaseInstanceForm >() ) | |
| { | |
| return( ExpressionTypeChecker::weaklyTyped(TypeManager::AVMCODE, | |
| anExpr.to_ptr< BaseInstanceForm >()->getTypeSpecifier()) ); | |
| } | |
| else return( false ); | |
| } | |
| bool ExpressionTypeChecker::isCtor( | |
| BaseTypeSpecifier * refTypeSpecifier, AvmCode * aCode) | |
| { | |
| AVM_OS_ASSERT_FATAL_ERROR_EXIT( | |
| OperatorManager::isCtor( aCode->getOperator() ) ) | |
| << "Unexpected ctor< ? >( ? ) expression :> " | |
| << IGNORE_FIRST_TAB << aCode | |
| << SEND_EXIT; | |
| return( aCode->first().is< BaseTypeSpecifier >() && | |
| ExpressionTypeChecker::weaklyTyped(refTypeSpecifier, | |
| aCode->first().to_ptr< BaseTypeSpecifier >()) ); | |
| } | |
| bool ExpressionTypeChecker::isNewfresh( | |
| BaseTypeSpecifier * refTypeSpecifier, AvmCode * aCode) | |
| { | |
| AVM_OS_ASSERT_FATAL_ERROR_EXIT( | |
| OperatorManager::isNewfresh( aCode->getOperator() ) ) | |
| << "Unexpected newfresh( ? ) expression :> " | |
| << IGNORE_FIRST_TAB << aCode | |
| << SEND_EXIT; | |
| return( aCode->first().is< BaseInstanceForm >() && | |
| ExpressionTypeChecker::weaklyTyped(refTypeSpecifier, | |
| aCode->first().to_ptr< BaseInstanceForm >()->getTypeSpecifier()) ); | |
| } | |
| bool ExpressionTypeChecker::isTyped(BaseTypeSpecifier * refTypeSpecifier, | |
| BaseTypeSpecifier * aTypeSpecifier) | |
| { | |
| if( refTypeSpecifier == aTypeSpecifier ) | |
| { | |
| return( true ); | |
| } | |
| while( true ) | |
| { | |
| if( refTypeSpecifier->is< TypeAliasSpecifier >() ) | |
| { | |
| refTypeSpecifier = refTypeSpecifier-> | |
| to< TypeAliasSpecifier >()->targetTypeSpecifier(); | |
| } | |
| else if( refTypeSpecifier->is< IntervalTypeSpecifier >() ) | |
| { | |
| refTypeSpecifier = refTypeSpecifier-> | |
| to< IntervalTypeSpecifier >()->getSupportTypeSpecifier(); | |
| } | |
| else | |
| { | |
| break; | |
| } | |
| } | |
| while( true ) | |
| { | |
| if( aTypeSpecifier->is< TypeAliasSpecifier >() ) | |
| { | |
| aTypeSpecifier = aTypeSpecifier-> | |
| to< TypeAliasSpecifier >()->targetTypeSpecifier(); | |
| } | |
| else if( aTypeSpecifier->is< IntervalTypeSpecifier >() ) | |
| { | |
| aTypeSpecifier = aTypeSpecifier-> | |
| to< IntervalTypeSpecifier >()->getSupportTypeSpecifier(); | |
| } | |
| else | |
| { | |
| break; | |
| } | |
| } | |
| if( refTypeSpecifier == aTypeSpecifier ) | |
| { | |
| return( true ); | |
| } | |
| // else if( refTypeSpecifier->isTypeSpecifierKind( aTypeSpecifier ) ) | |
| // { | |
| // return( true ); | |
| // } | |
| return( false ); | |
| } | |
| bool ExpressionTypeChecker::isTyped( | |
| BaseTypeSpecifier * refTypeSpecifier, const BF & arg) | |
| { | |
| while( true ) | |
| { | |
| if( refTypeSpecifier->is< TypeAliasSpecifier >() ) | |
| { | |
| refTypeSpecifier = refTypeSpecifier-> | |
| to< TypeAliasSpecifier >()->targetTypeSpecifier(); | |
| } | |
| else if( refTypeSpecifier->is< IntervalTypeSpecifier >() ) | |
| { | |
| refTypeSpecifier = refTypeSpecifier-> | |
| to< IntervalTypeSpecifier >()->getSupportTypeSpecifier(); | |
| } | |
| else | |
| { | |
| break; | |
| } | |
| } | |
| if( refTypeSpecifier->hasTypedClockTime() ) | |
| { | |
| if( refTypeSpecifier->is< ContainerTypeSpecifier >() ) | |
| { | |
| refTypeSpecifier = refTypeSpecifier-> | |
| to< ContainerTypeSpecifier >()->getContentsTypeSpecifier(); | |
| } | |
| } | |
| if( arg.is< BaseInstanceForm >() ) | |
| { | |
| return( ExpressionTypeChecker::weaklyTyped(refTypeSpecifier, | |
| arg.to_ptr< BaseInstanceForm >()->getTypeSpecifier()) ); | |
| } | |
| else if( ExpressionTypeChecker::isCtor(arg) ) | |
| { | |
| return( ExpressionTypeChecker::isCtor( | |
| refTypeSpecifier, arg.to_ptr< AvmCode >() ) ); | |
| } | |
| else if( ExpressionTypeChecker::isNewfresh(arg) ) | |
| { | |
| return( ExpressionTypeChecker::isNewfresh( | |
| refTypeSpecifier, arg.to_ptr< AvmCode >() ) ); | |
| } | |
| switch( refTypeSpecifier->getTypeSpecifierKind() ) | |
| { | |
| case TYPE_BOOLEAN_SPECIFIER: | |
| { | |
| return( ExpressionTypeChecker::isBoolean(arg) ); | |
| } | |
| case TYPE_CHARACTER_SPECIFIER: | |
| { | |
| return( ExpressionTypeChecker::isCharacter(arg) ); | |
| } | |
| case TYPE_STRING_SPECIFIER: | |
| { | |
| return( ExpressionTypeChecker::isString(arg) ); | |
| } | |
| case TYPE_INTEGER_SPECIFIER: | |
| case TYPE_UINTEGER_SPECIFIER: | |
| case TYPE_POS_INTEGER_SPECIFIER: | |
| { | |
| return( ExpressionTypeChecker::isInteger(arg) ); | |
| } | |
| case TYPE_RATIONAL_SPECIFIER: | |
| case TYPE_URATIONAL_SPECIFIER: | |
| { | |
| return( ExpressionTypeChecker::isRational(arg) ); | |
| } | |
| case TYPE_FLOAT_SPECIFIER: | |
| case TYPE_UFLOAT_SPECIFIER: | |
| { | |
| return( ExpressionTypeChecker::isFloat(arg) ); | |
| } | |
| case TYPE_REAL_SPECIFIER: | |
| case TYPE_UREAL_SPECIFIER: | |
| { | |
| return( ExpressionTypeChecker::isReal(arg) ); | |
| } | |
| case TYPE_INTERVAL_SPECIFIER: | |
| { | |
| return( ExpressionTypeChecker::isTyped( refTypeSpecifier->to< | |
| IntervalTypeSpecifier >()->getSupportTypeSpecifier(), arg) ); | |
| } | |
| case TYPE_CLOCK_SPECIFIER: | |
| { | |
| return( ExpressionTypeChecker::isClock(arg) ); | |
| } | |
| case TYPE_TIME_SPECIFIER: | |
| { | |
| return( ExpressionTypeChecker::isTime(arg) ); | |
| } | |
| case TYPE_CONTINUOUS_TIME_SPECIFIER: | |
| { | |
| return( ExpressionTypeChecker::isCTime(arg) ); | |
| } | |
| case TYPE_DISCRETE_TIME_SPECIFIER: | |
| { | |
| return( ExpressionTypeChecker::isDTime(arg) ); | |
| } | |
| case TYPE_MACHINE_SPECIFIER: | |
| { | |
| return( ExpressionTypeChecker::isMachine(arg) ); | |
| } | |
| case TYPE_PORT_SPECIFIER: | |
| { | |
| return( ExpressionTypeChecker::isPort(arg) ); | |
| } | |
| case TYPE_BUFFER_SPECIFIER: | |
| { | |
| return( ExpressionTypeChecker::isBuffer(arg) ); | |
| } | |
| case TYPE_MESSAGE_SPECIFIER: | |
| { | |
| return( ExpressionTypeChecker::isMessage(arg) ); | |
| } | |
| case TYPE_OPERATOR_SPECIFIER: | |
| { | |
| return( ExpressionTypeChecker::isOperator(arg) ); | |
| } | |
| case TYPE_AVMCODE_SPECIFIER: | |
| { | |
| return( ExpressionTypeChecker::isAvmCode(arg) ); | |
| } | |
| case TYPE_ENUM_SPECIFIER: | |
| { | |
| return( ExpressionTypeChecker::isEnum( | |
| refTypeSpecifier->to< EnumTypeSpecifier >(), arg) ); | |
| } | |
| case TYPE_ARRAY_SPECIFIER: | |
| { | |
| return( ExpressionTypeChecker::isArray( | |
| refTypeSpecifier->to< ContainerTypeSpecifier >(), arg) ); | |
| } | |
| case TYPE_CLASS_SPECIFIER: | |
| { | |
| return( ExpressionTypeChecker::isClass( | |
| refTypeSpecifier->to< ClassTypeSpecifier >(), arg) ); | |
| } | |
| case TYPE_UNIVERSAL_SPECIFIER: | |
| { | |
| return( true ); | |
| } | |
| default: | |
| { | |
| if( refTypeSpecifier->hasTypeCollection() ) | |
| { | |
| return( ExpressionTypeChecker::isCollection( | |
| refTypeSpecifier->to< ContainerTypeSpecifier >(), arg) ); | |
| } | |
| else if( arg.is< AvmCode >() ) | |
| { | |
| } | |
| return( false ); | |
| } | |
| } | |
| return( true ); | |
| } | |
| } |