| /******************************************************************************* |
| * 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: 4 mai 2011 |
| * |
| * Contributors: |
| * Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr |
| * - Initial API and implementation |
| ******************************************************************************/ |
| |
| #include "AvmcodeUfiCastExpressionCompiler.h" |
| |
| #include <fml/executable/BaseInstanceForm.h> |
| #include <fml/executable/ExecutableSystem.h> |
| #include <fml/executable/InstanceOfData.h> |
| #include <fml/executable/InstanceOfMachine.h> |
| |
| #include <fml/expression/AvmCode.h> |
| #include <fml/expression/ExpressionConstructor.h> |
| #include <fml/expression/ExpressionTypeChecker.h> |
| |
| #include <fml/lib/AvmOperationFactory.h> |
| |
| #include <fml/symbol/TableOfSymbol.h> |
| |
| #include <fml/operator/OperatorManager.h> |
| |
| #include <fml/type/BaseTypeSpecifier.h> |
| #include <fml/type/BaseSymbolTypeSpecifier.h> |
| #include <fml/type/ContainerTypeSpecifier.h> |
| #include <fml/type/EnumTypeSpecifier.h> |
| |
| #include <fml/workflow/UniFormIdentifier.h> |
| |
| #include <sew/Configuration.h> |
| |
| |
| namespace sep |
| { |
| |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // AVMCODE UFI EXPRESSION COMPILATION |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| BF AvmcodeUfiExpressionCompiler::compileUfiExpression( |
| COMPILE_CONTEXT * aCTX, const UniFormIdentifier & theUFI) |
| { |
| BF bfInstance; |
| |
| if( theUFI.isAbsoluteFullFields() ) |
| { |
| bfInstance = getSymbolTable().searchSymbolByUFI(aCTX, theUFI); |
| if( bfInstance.valid() ) |
| { |
| return( bfInstance ); |
| } |
| |
| else |
| { |
| std::string strUFI = theUFI.str(); |
| |
| //StringTools::replace(strUFI, "spec::", "inst::"); |
| StringTools::eraseAll(strUFI, "&"); |
| |
| bfInstance = getSymbolTable().searchSymbol(aCTX, strUFI); |
| if( bfInstance.valid() ) |
| { |
| return( bfInstance ); |
| } |
| } |
| } |
| else if( theUFI.isFullOffset() ) |
| { |
| bfInstance = getSymbolTable().searchSymbolByQualifiedNameID( |
| aCTX, theUFI.str()); |
| if( bfInstance.valid() ) |
| { |
| return( bfInstance ); |
| } |
| } |
| |
| UniFormIdentifier::const_iterator it = theUFI.begin(); |
| UniFormIdentifier::const_iterator itEnd = theUFI.end(); |
| |
| std::ostringstream ossUFI; |
| |
| const ObjectElement * TheMainObjectElement = NULL; |
| |
| // CHECKING FIRST ELEMENT |
| if( (*it).is< ObjectElement >() ) |
| { |
| TheMainObjectElement = (*it).to_ptr< ObjectElement >(); |
| } |
| else |
| { |
| if( theUFI.hasLocator() ) |
| { |
| ossUFI << theUFI.toStringLocator() |
| << FQN_ID_ROOT_SEPARATOR << (*it).str(); |
| } |
| ossUFI << (*it).str(); |
| |
| TheMainObjectElement = AVMCODE_COMPILER.getConfiguration(). |
| getExecutableSystem().getSystemInstance().getAstElement(); |
| } |
| |
| if( TheMainObjectElement == NULL ) |
| { |
| bfInstance = getSymbolTable().searchDataInstance(aCTX, theUFI.str()); |
| if( bfInstance.valid() ) |
| { |
| return( bfInstance ); |
| } |
| else |
| { |
| bfInstance = getSymbolTable().searchSymbolByNameID(aCTX, (*it).str()); |
| if( bfInstance.valid() ) |
| { |
| TheMainObjectElement = bfInstance.to_ptr< |
| BaseInstanceForm >()->getAstElement(); |
| } |
| } |
| } |
| |
| |
| if( TheMainObjectElement != NULL ) |
| { |
| ObjectElement * objElement = NULL; |
| |
| ossUFI.str(""); |
| ossUFI << TheMainObjectElement->getFullyQualifiedNameID(); |
| |
| // CHECKING MAIN FORM |
| for( ++it ; it != itEnd ; ++it ) |
| { |
| if( (*it).is< ObjectElement >() ) |
| { |
| objElement = (*it).to_ptr< ObjectElement >(); |
| |
| if( objElement->getContainer() == TheMainObjectElement ) |
| { |
| TheMainObjectElement = objElement; |
| |
| ossUFI.str(""); |
| ossUFI << TheMainObjectElement->getFullyQualifiedNameID(); |
| } |
| else |
| { |
| break; |
| } |
| } |
| else if( (*it).isIdentifier() ) |
| { |
| ossUFI << '.' << (*it).str(); |
| } |
| else |
| { |
| break; |
| } |
| |
| if( objElement != NULL ) |
| { |
| TheMainObjectElement = objElement; |
| |
| //!![MIGRATION] i.e. isArrayType() isContainerType() isClassType() |
| AVM_OS_FATAL_ERROR_EXIT |
| << "!!! DataTypeFactory::isCompositeType !!!" |
| << SEND_EXIT; |
| break; |
| } |
| else |
| { |
| break; |
| } |
| } |
| } |
| else if( (*it).isFieldInvokable() ) |
| { |
| Operator * opExpr = AvmOperationFactory::get( (*it).str() ); |
| if( opExpr != NULL ) |
| { |
| BFCode anInvokeExpression( opExpr ); |
| |
| BF arg; |
| for( ++it ; it != itEnd ; ++it ) |
| { |
| if( (*it).isFieldParameter() ) |
| { |
| arg = compileArgRvalue(aCTX, *it); |
| |
| if( arg.valid() ) |
| { |
| anInvokeExpression->append( arg ); |
| } |
| else |
| { |
| getCompilerTable().incrErrorCount(); |
| aCTX->errorContext( AVM_OS_WARN ) |
| << "AvmCode< statement > compilation error << " |
| << (*it).str() << " >>" |
| << std::endl << std::endl; |
| |
| anInvokeExpression->append( *it ); |
| } |
| } |
| else |
| { |
| break; |
| } |
| } |
| |
| if( it != itEnd ) |
| { |
| getCompilerTable().incrErrorCount(); |
| aCTX->errorContext( AVM_OS_WARN ) |
| << "AvmCode< statement > compilation error" |
| " << (: " << anInvokeExpression.str() |
| << " " << (*it).str() << " ...) >> for " |
| << theUFI.str() << std::endl << std::endl; |
| } |
| |
| return( anInvokeExpression ); |
| } |
| else |
| { |
| getCompilerTable().incrErrorCount(); |
| AVM_OS_WARN << "Unfound the operation < " << (*it).str() |
| << " > in the UFI < " << theUFI.str() << " >" |
| << std::endl; |
| |
| return( BF::REF_NULL ); |
| } |
| } |
| |
| else |
| { |
| getCompilerTable().incrErrorCount(); |
| AVM_OS_WARN << "Unfound the invokable field < " << ossUFI.str() |
| << " > of UFI < " << theUFI.str() << " > in the system << " |
| << AVMCODE_COMPILER.getConfiguration(). |
| getExecutableSystem().rawSystemInstance()-> |
| getAstElement()->getFullyQualifiedNameID() |
| << " >>" << std::endl; |
| |
| return( BF::REF_NULL ); |
| } |
| |
| |
| // CHECKING FIRST INSTANCE |
| if( TheMainObjectElement != NULL ) |
| { |
| bfInstance = getSymbolTable().searchInstance(aCTX, TheMainObjectElement); |
| } |
| else |
| { |
| getCompilerTable().incrErrorCount(); |
| AVM_OS_WARN << "Unfound the main object element < " << ossUFI.str() |
| << " > of UFI < " << theUFI.str() << " > in the system << " |
| << AVMCODE_COMPILER.getConfiguration(). |
| getExecutableSystem().rawSystemInstance()-> |
| getAstElement()->getFullyQualifiedNameID() |
| << " >>" << std::endl; |
| |
| return( BF::REF_NULL ); |
| } |
| |
| |
| if( bfInstance.valid() ) |
| { |
| if( it == itEnd ) |
| { |
| return( bfInstance ); |
| } |
| |
| // CASE FIRST INSTANCE is a MACHINE |
| if( bfInstance.is< InstanceOfMachine >() ) |
| { |
| InstanceOfMachine * theInstanceMachine = |
| bfInstance.to_ptr< InstanceOfMachine >(); |
| |
| InstanceOfMachine * ptrInstance = NULL; |
| |
| // CHECKING FOR MAIN MACHINE |
| for( ; it != itEnd ; ++it ) |
| { |
| if( (*it).isIdentifier() ) |
| { |
| ossUFI.str(""); |
| ossUFI << theInstanceMachine->getExecutable()-> |
| getAstFullyQualifiedNameID() << '.' << (*it).str(); |
| bfInstance = getSymbolTable().searchInstance( |
| aCTX->newCTX(theInstanceMachine->getExecutable()), |
| ossUFI.str() ); |
| if( bfInstance.valid() ) |
| { |
| if( bfInstance.is< InstanceOfMachine >() ) |
| { |
| ptrInstance = bfInstance.to_ptr< InstanceOfMachine >(); |
| |
| if( ptrInstance->getContainer() == |
| theInstanceMachine->getExecutable() ) |
| { |
| theInstanceMachine = ptrInstance; |
| } |
| else |
| { |
| getCompilerTable().incrErrorCount(); |
| AVM_OS_WARN << "Unexpected a non child machine " |
| "instance < " << ptrInstance->getFullyQualifiedNameID() |
| << " of the machine instance < " |
| << theInstanceMachine->getFullyQualifiedNameID() |
| << " > > in the UFI < " << theUFI.str() |
| << " >" << std::endl; |
| |
| return( BF::REF_NULL ); |
| } |
| } |
| else if( bfInstance.is< InstanceOfData >() ) |
| { |
| ++it; |
| |
| break; |
| } |
| } |
| else |
| { |
| getCompilerTable().incrErrorCount(); |
| AVM_OS_WARN << "Unfound machine attribute < " |
| << (*it).str() << " > of the UFI < " |
| << theUFI.str() << " >" << std::endl; |
| |
| return( BF::REF_NULL ); |
| } |
| } |
| else |
| { |
| getCompilerTable().incrErrorCount(); |
| AVM_OS_WARN << "Unexpected class attribute kind < " |
| << (*it).str() << " > of the UFI < " |
| << theUFI.str() << " >" << std::endl; |
| |
| return( BF::REF_NULL ); |
| } |
| } |
| |
| if( it == itEnd ) |
| { |
| bfInstance = getSymbolTable().createAliasIfNotAccessible( |
| aCTX, theInstanceMachine, bfInstance); |
| |
| // ERROR REPORTING |
| if( getSymbolTable().hasError() ) |
| { |
| getCompilerTable().incrErrorCount(); |
| AVM_OS_WARN << theUFI.errorLocation( |
| aCTX->mCompileCtx->getAstElement() ) |
| << getSymbolTable().getErrorMessage() |
| << std::endl << std::endl; |
| } |
| |
| return( bfInstance ); |
| } |
| } |
| |
| |
| // CASE FIRST INSTANCE is a DATA |
| if( bfInstance.is< InstanceOfData >() ) |
| { |
| bfInstance = getSymbolTable(). |
| createAliasIfNotAccessible(aCTX, bfInstance); |
| // ERROR REPORTING |
| if( getSymbolTable().hasError() ) |
| { |
| getCompilerTable().incrErrorCount(); |
| AVM_OS_WARN << theUFI.errorLocation( |
| aCTX->mCompileCtx->getAstElement() ) |
| << getSymbolTable().getErrorMessage() |
| << std::endl << std::endl; |
| } |
| |
| Symbol symbolData( bfInstance ); |
| |
| InstanceOfData * ptrInstance = bfInstance.to_ptr< InstanceOfData >(); |
| |
| BaseTypeSpecifier * aTypeSpecifier = ptrInstance->getTypeSpecifier(); |
| |
| if( aTypeSpecifier->hasTypeStructureOrChoiceOrUnion() || |
| aTypeSpecifier->hasTypeArrayVector() ) |
| { |
| BaseSymbolTypeSpecifier * aStructTypeSpecifier = NULL; |
| |
| bool isArrayIndex = false; |
| // bool isNotArray = true; |
| |
| TableOfSymbol aRelativeDataPath; |
| std::ostringstream ossID; |
| |
| ossUFI.str( "" ); |
| ossUFI << ptrInstance->getFullyQualifiedNameID(); |
| |
| ossID << ptrInstance->getNameID(); |
| |
| |
| for( ; it != itEnd ; ++it ) |
| { |
| if( (*it).isFieldIndex() ) |
| { |
| if( not aTypeSpecifier->hasTypeArrayVector() ) |
| { |
| getCompilerTable().incrErrorCount(); |
| aCTX->errorContext( AVM_OS_WARN ) |
| << "Unexpected a non Array field kind < " |
| << ossUFI.str() << " > of the UFI < " |
| << theUFI.str() << " >" << std::endl; |
| |
| return( BF::REF_NULL ); |
| } |
| |
| aTypeSpecifier = aTypeSpecifier-> |
| as< ContainerTypeSpecifier >()-> |
| getContentsTypeSpecifier(); |
| |
| BF index = compileArgRvalue(aCTX, (*it)); |
| if( index.valid() ) |
| { |
| // isNotArray = false; |
| if( index.isInteger() ) |
| { |
| symbolData = new InstanceOfData( |
| IPointerDataNature:: |
| POINTER_FIELD_ARRAY_OFFSET_NATURE, |
| aCTX->mCompileCtx, |
| aTypeSpecifier->getAstElement(), |
| aTypeSpecifier, 0 ); |
| symbolData.setOffset( index.toInteger() ); |
| } |
| else |
| { |
| isArrayIndex = true; |
| symbolData = new InstanceOfData( |
| IPointerDataNature:: |
| POINTER_FIELD_ARRAY_INDEX_NATURE, |
| aCTX->mCompileCtx, |
| aTypeSpecifier->getAstElement(), |
| aTypeSpecifier, 0 ); |
| symbolData.setValue( index ); |
| } |
| |
| aRelativeDataPath.append( symbolData ); |
| |
| ossUFI << "[" << index.str() << "]"; |
| ossID << "[" << ( index.is< BaseInstanceForm >() ? |
| index.to_ptr< BaseInstanceForm >()->getNameID() : |
| index.str() ) << "]"; |
| } |
| else |
| { |
| getCompilerTable().incrErrorCount(); |
| AVM_OS_WARN << "Unfound array index < " |
| << (*it).str() << " > of the UFI element < " |
| << theUFI.str() << " >" << std::endl; |
| |
| return( BF::REF_NULL ); |
| } |
| } |
| |
| else if( aTypeSpecifier->hasTypeStructureOrChoiceOrUnion() ) |
| { |
| // AVM_OS_ASSERT_FATAL_NULL_POINTER_EXIT( aTypeSpecifier->isTypedClass() ) |
| // << "Unexpected a non Class/Struct type !!!" |
| // << SEND_EXIT; |
| |
| aStructTypeSpecifier = |
| aTypeSpecifier->to< BaseSymbolTypeSpecifier >(); |
| if( (*it).isIdentifier() ) |
| { |
| ossUFI << '.' << (*it).str(); |
| ossID << '.' << (*it).str(); |
| |
| symbolData = symbolData.getAttributeByNameID( ossID.str() ); |
| if( symbolData.invalid() ) |
| { |
| symbolData = aStructTypeSpecifier-> |
| getDataByNameID( (*it).str() ); |
| } |
| |
| //!! NO ELSE here |
| if( symbolData.valid() ) |
| { |
| if( aTypeSpecifier->isTypedUnion() ) |
| { |
| // Not insertion in Data path |
| } |
| else |
| { |
| aRelativeDataPath.append( symbolData ); |
| } |
| |
| aTypeSpecifier = symbolData.getTypeSpecifier(); |
| } |
| else |
| { |
| getCompilerTable().incrErrorCount(); |
| AVM_OS_WARN << "Unfound structure attribute < " |
| << (*it).str() << " > of the UFI < " |
| << theUFI.str() << " >" << std::endl; |
| |
| return( BF::REF_NULL ); |
| } |
| } |
| else |
| { |
| getCompilerTable().incrErrorCount(); |
| AVM_OS_WARN << "Unexpected structure attribute kind < " |
| << (*it).str() << " > of the UFI < " |
| << theUFI.str() << " >" << std::endl; |
| |
| return( BF::REF_NULL ); |
| } |
| } |
| else |
| { |
| break; |
| } |
| |
| // else |
| // { |
| // getCompilerTable().incrErrorCount(); |
| // AVM_OS_WARN << "Unexpected type < " |
| // << aTypeSpecifier->getFullyQualifiedNameID() |
| // << " > for the element < " << (*it).str() |
| // << " > of the instance of data < " << theUFI.str() |
| // << " >" << std::endl; |
| // return( BF::REF_NULL ); |
| // } |
| } |
| |
| IPointerDataNature::POINTER_DATA_NATURE aPointerNature = |
| IPointerDataNature::POINTER_UNDEFINED_NATURE; |
| if( isArrayIndex ) |
| { |
| aPointerNature = IPointerDataNature::POINTER_UFI_MIXED_NATURE; |
| } |
| else |
| { |
| aPointerNature = IPointerDataNature::POINTER_UFI_OFFSET_NATURE; |
| } |
| |
| |
| if( aRelativeDataPath.nonempty() ) |
| { |
| aRelativeDataPath.pop_last_to( symbolData ); |
| |
| symbolData = new InstanceOfData(aPointerNature, |
| ptrInstance->getContainer(), ptrInstance, |
| aRelativeDataPath, symbolData); |
| } |
| else |
| { |
| VectorOfInstanceOfMachine aRelativeMachinePath; |
| |
| symbolData = new InstanceOfData(ptrInstance->getContainer(), |
| symbolData.rawData(), aRelativeMachinePath); |
| } |
| |
| symbolData.updateFullyQualifiedNameID( ossUFI.str() , ossID.str() ); |
| |
| // if( isNotArray ) |
| { |
| aCTX->mCompileCtx->getExecutable()-> |
| appendDataAlias( symbolData ); |
| // ptrInstance->getContainer()->appendDataAlias( symbolData ); |
| } |
| |
| if( it == itEnd ) |
| { |
| return( symbolData ); |
| } |
| |
| else if( (*it).isFieldInvokable() ) |
| { |
| AVM_OS_ASSERT_FATAL_ERROR_EXIT( (*it).isIdentifier() ) |
| << "Unexpected a non-Identifier << " |
| << (*it).str() << " >> as Invocable !!!" |
| << SEND_EXIT; |
| |
| Operator * op = AvmOperationFactory::get( |
| symbolData, (*it).toIdentifier()); |
| if( op != NULL ) |
| { |
| BFCode newCode(op, symbolData); |
| BF arg; |
| for( ++it ; it != itEnd ; ++it ) |
| { |
| if( (*it).isFieldParameter() ) |
| { |
| arg = compileArgRvalue(aCTX, *it); |
| |
| if( arg.valid() ) |
| { |
| newCode->append( arg ); |
| } |
| else |
| { |
| getCompilerTable().incrErrorCount(); |
| aCTX->errorContext( AVM_OS_WARN ) |
| << "AvmCode< statement > " |
| "compilation error << " |
| << (*it).str() << " >>" |
| << std::endl << std::endl; |
| |
| newCode->append( *it ); |
| } |
| } |
| else |
| { |
| break; |
| } |
| } |
| if( it == itEnd ) |
| { |
| return( newCode ); |
| } |
| |
| else |
| { |
| getCompilerTable().incrErrorCount(); |
| aCTX->errorContext( AVM_OS_WARN ) |
| << "AvmCode< statement > " |
| "compilation error << (: " |
| << symbolData.str() << " " |
| << (*it).str() << " ...) >> for " |
| << theUFI.str() |
| << std::endl << std::endl; |
| |
| return( symbolData ); |
| } |
| } |
| else |
| { |
| getCompilerTable().incrErrorCount(); |
| aCTX->errorContext( AVM_OS_WARN ) |
| << "AvmCode< statement > " |
| "compilation error << (: " |
| << symbolData.str() << " " |
| << (*it).str() << " ...) >> for " |
| << theUFI.str() |
| << std::endl << std::endl; |
| |
| return( symbolData ); |
| } |
| } |
| else |
| { |
| getCompilerTable().incrErrorCount(); |
| aCTX->errorContext( AVM_OS_WARN ) |
| << "UFI compilation error << " |
| << symbolData.str() << " >> for " |
| << theUFI.str() |
| << std::endl << std::endl; |
| |
| return( symbolData ); |
| } |
| } |
| |
| else if( aTypeSpecifier->isTypedLambda() /*&& (*(it-1)).isFieldInvokable()*/ ) |
| { |
| BFCode invokeCode(OperatorManager::OPERATOR_INVOKE_LAMBDA_APPLY, |
| symbolData); |
| // (theInstanceData->getModifier().hasFeatureFinal() && theInstanceData->hasValue()) ? |
| // theInstanceData->getValue() : theInstanceData); |
| |
| BF param; |
| for( ; it != itEnd ; ++it ) |
| { |
| param = compileArgRvalue(aCTX, (*it)); |
| |
| if( param.invalid() ) |
| { |
| getCompilerTable().incrErrorCount(); |
| AVM_OS_WARN << "Compilation Error of the parameter < " |
| << (*it).str() << " > of the invokable < " |
| << ptrInstance->getFullyQualifiedNameID() << " > in the UFI < " |
| << theUFI.str() << " >" << std::endl; |
| |
| continue; |
| } |
| |
| invokeCode->append( param ); |
| } |
| |
| return( invokeCode ); |
| } |
| |
| else if( aTypeSpecifier->isTypedMachine() ) |
| { |
| |
| } |
| |
| else |
| { |
| getCompilerTable().incrErrorCount(); |
| AVM_OS_WARN << "Unexpected type < " << aTypeSpecifier->str() |
| << " > for instance of data < " << ptrInstance->getFullyQualifiedNameID() |
| << " > int the UFI < " << theUFI.str() << " >" |
| << std::endl; |
| |
| return( BF::REF_NULL ); |
| } |
| } |
| |
| // CASE FIRST INSTANCE is a PORT |
| else if( bfInstance.is< InstanceOfPort >() ) |
| { |
| getCompilerTable().incrErrorCount(); |
| AVM_OS_WARN << "Unexpected a port instance < " |
| << bfInstance.to_ptr< InstanceOfPort >()->getFullyQualifiedNameID() |
| << " > int the UFI < " << theUFI.str() << " >" << std::endl; |
| |
| return( BF::REF_NULL ); |
| } |
| |
| else |
| { |
| getCompilerTable().incrErrorCount(); |
| AVM_OS_WARN << "Unexpected a base instance < " |
| << bfInstance.to_ptr< BaseInstanceForm >()->getFullyQualifiedNameID() |
| << " > int the UFI < " << theUFI.str() << " >" << std::endl; |
| |
| return( BF::REF_NULL ); |
| } |
| } |
| |
| else |
| { |
| const BF & tmpTransition = |
| getSymbolTable().searchTransition(aCTX, TheMainObjectElement); |
| if( tmpTransition.valid() && (it == itEnd) ) |
| { |
| return( tmpTransition ); |
| } |
| |
| const BF & tmpProgram = |
| getSymbolTable().searchProgram(aCTX, TheMainObjectElement); |
| if( tmpProgram.valid() && (it == itEnd) ) |
| { |
| return( tmpProgram ); |
| } |
| |
| |
| const BF & aType = SymbolTable::searchTypeSpecifier( |
| AVMCODE_COMPILER.getConfiguration().getExecutableSystem(), |
| aCTX, TheMainObjectElement); |
| if( aType.valid() ) |
| { |
| if( it == itEnd ) |
| { |
| return( aType ); |
| } |
| else |
| { |
| EnumTypeSpecifier * anEnumTS; |
| |
| for( ; it != itEnd ; ++it ) |
| { |
| if( aType.is< EnumTypeSpecifier >() ) |
| { |
| anEnumTS = aType.to_ptr< EnumTypeSpecifier >(); |
| |
| if( (*it).isIdentifier() ) |
| { |
| ossUFI.str(""); |
| ossUFI << anEnumTS->getFullyQualifiedNameID() << '.' << (*it).str(); |
| |
| bfInstance = anEnumTS->getSymbolData(ossUFI.str()); |
| |
| break; |
| } |
| } |
| } |
| |
| if( bfInstance.valid() && (it == itEnd) ) |
| { |
| return( bfInstance ); |
| } |
| } |
| } |
| |
| getCompilerTable().incrErrorCount(); |
| AVM_OS_WARN << "Unfound a runtime symbol for the form < " |
| << TheMainObjectElement->getFullyQualifiedNameID() |
| << " > in the UFI < " << theUFI.str() << " >" |
| << std::endl; |
| |
| return( BF::REF_NULL ); |
| } |
| |
| return( BF::REF_NULL ); |
| } |
| |
| |
| |
| |
| |
| BF AvmcodeUfiExpressionCompiler::compileExpression( |
| COMPILE_CONTEXT * aCTX, const BFCode & aCode) |
| { |
| UniFormIdentifier * runtimeUFI = new UniFormIdentifier(false); |
| BF bfRuntimeUFI( runtimeUFI ); |
| |
| BF arg; |
| |
| COMPILE_CONTEXT * containerCTX = aCTX->clone(); |
| |
| AvmCode::iterator itArg = aCode->begin(); |
| AvmCode::iterator itEndArg = aCode->end(); |
| |
| for( ; itArg != itEndArg ; ++itArg ) |
| { |
| arg = compileArgRvalue(containerCTX, *itArg); |
| |
| if( arg.invalid() ) |
| { |
| getCompilerTable().incrErrorCount(); |
| AVM_OS_WARN << "Compilation Error of < " << (*itArg).str() |
| << " > in the UFI < " << aCode->str() << " >" << std::endl; |
| |
| continue; |
| } |
| |
| runtimeUFI->appendUndef(arg); |
| |
| containerCTX->mCompileCtx = aCTX->mCompileCtx; |
| |
| if( ExpressionTypeChecker::isCtor(arg) && (itArg != itEndArg) ) |
| { |
| const BF & aCastType = arg.to_ptr< AvmCode >()->first(); |
| if( aCastType.is< BaseAvmProgram >() ) |
| { |
| containerCTX->mCompileCtx = aCastType.to_ptr< BaseAvmProgram >(); |
| } |
| } |
| } |
| |
| return( bfRuntimeUFI ); |
| |
| } |
| |
| BFCode AvmcodeUfiExpressionCompiler::compileStatement( |
| COMPILE_CONTEXT * aCTX, const BFCode & aCode) |
| { |
| AVM_OS_FATAL_ERROR_EXIT |
| << "Unexpected UFI EXPRESSION as statement !!!" |
| << SEND_EXIT; |
| |
| return( aCode ); |
| } |
| |
| |
| |
| } |