| /******************************************************************************* |
| * 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: 1 mars 2013 |
| * |
| * Contributors: |
| * Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr |
| * - Initial API and implementation |
| ******************************************************************************/ |
| |
| #include "AvmBytecode.h" |
| |
| #include <common/BF.h> |
| |
| #include <fml/executable/ExecutableLib.h> |
| #include <fml/executable/InstanceOfData.h> |
| |
| #include <fml/type/BaseTypeSpecifier.h> |
| #include <fml/type/TypeManager.h> |
| |
| |
| namespace sep |
| { |
| |
| |
| AvmBytecode AvmBytecode::ARG_UNDEFINED_CODE( |
| /*context */ AVM_ARG_UNDEFINED_CONTEXT, |
| /*processor*/ AVM_ARG_UNDEFINED_PROCESSOR, |
| /*operation*/ AVM_ARG_UNDEFINED_OPERATION, |
| /*operand */ AVM_ARG_UNDEFINED_OPERAND, |
| /*dtype */ NULL); |
| |
| |
| AvmBytecode AvmBytecode::ARG_NOPS_CODE(AVM_ARG_NOPS); |
| |
| AvmBytecode AvmBytecode::ARG_SEVAL_CODE(AVM_ARG_SEVAL); |
| |
| AvmBytecode AvmBytecode::ARG_MEVAL_CODE(AVM_ARG_MEVAL); |
| |
| |
| /** |
| * CONSTRUCTOR |
| * Default |
| */ |
| AvmBytecode::AvmBytecode( |
| avm_arg_context_t aContext, avm_arg_processor_t aProcessor, |
| avm_arg_operation_t anOperation, avm_arg_operand_t anOperand, |
| BaseTypeSpecifier * aType) |
| : context( aContext ), |
| processor( aProcessor ), |
| numeric( false ), |
| operation( anOperation ), |
| operand( anOperand ), |
| offset( AVM_NUMERIC_MAX_SIZE_T ), |
| dtype( aType ), |
| |
| routine_decode_eval( NULL ), |
| routine_eval( NULL ), |
| routine_decode_run( NULL ), |
| routine_run( NULL ) |
| { |
| //!! NOTHING |
| } |
| |
| AvmBytecode::AvmBytecode( |
| avm_arg_context_t aContext, avm_arg_processor_t aProcessor, |
| avm_arg_operation_t anOperation, avm_arg_operand_t anOperand) |
| : context( aContext ), |
| processor( aProcessor ), |
| numeric( false ), |
| operation( anOperation ), |
| operand( anOperand ), |
| offset( AVM_NUMERIC_MAX_SIZE_T ), |
| dtype( TypeManager::UNIVERSAL ), |
| |
| routine_decode_eval( NULL ), |
| routine_eval( NULL ), |
| routine_decode_run( NULL ), |
| routine_run( NULL ) |
| { |
| //!! NOTHING |
| } |
| |
| AvmBytecode::AvmBytecode( avm_arg_context_t aContext, |
| avm_arg_operation_t anOperation, avm_arg_operand_t anOperand) |
| : context( aContext ), |
| processor( AVM_ARG_UNDEFINED_PROCESSOR ), |
| numeric( false ), |
| operation( anOperation ), |
| operand( anOperand ), |
| offset( AVM_NUMERIC_MAX_SIZE_T ), |
| dtype( TypeManager::UNIVERSAL ), |
| |
| routine_decode_eval( NULL ), |
| routine_eval( NULL ), |
| routine_decode_run( NULL ), |
| routine_run( NULL ) |
| { |
| //!! NOTHING |
| } |
| |
| AvmBytecode::AvmBytecode( |
| avm_arg_operation_t anOperation, avm_arg_operand_t anOperand) |
| : context( AVM_ARG_STANDARD_CTX ), |
| processor( AVM_ARG_UNDEFINED_PROCESSOR ), |
| numeric( false ), |
| operation( anOperation ), |
| operand( anOperand ), |
| offset( AVM_NUMERIC_MAX_SIZE_T ), |
| dtype( TypeManager::UNIVERSAL ), |
| |
| routine_decode_eval( NULL ), |
| routine_eval( NULL ), |
| routine_decode_run( NULL ), |
| routine_run( NULL ) |
| { |
| //!! NOTHING |
| } |
| |
| |
| /** |
| * dtype |
| */ |
| bool AvmBytecode::hasType() const |
| { |
| return( (dtype != NULL) && (dtype != TypeManager::UNIVERSAL) ); |
| } |
| |
| |
| /** |
| * Serialization |
| */ |
| std::string AvmBytecode::strContext(avm_arg_context_t context) |
| { |
| switch( context ) |
| { |
| case AVM_ARG_STANDARD_CTX: |
| { |
| return( "std" ); |
| } |
| |
| case AVM_ARG_ARGUMENT_CTX: |
| { |
| return( "arg" ); |
| } |
| |
| case AVM_ARG_PARAMETER_CTX: |
| { |
| return( "param" ); |
| } |
| |
| case AVM_ARG_RETURN_CTX: |
| { |
| return( "ret" ); |
| } |
| |
| case AVM_ARG_UNDEFINED_CONTEXT: |
| default: |
| { |
| return( "?ctx" ); |
| } |
| } |
| } |
| |
| |
| std::string AvmBytecode::strProcessor(avm_arg_processor_t processor) |
| { |
| switch( processor ) |
| { |
| case AVM_ARG_NOP_CPU: |
| { |
| return( "nop" ); |
| } |
| case AVM_ARG_NOPS_CPU: |
| { |
| return( "nops" ); |
| } |
| |
| case AVM_ARG_MEMORY_LVALUE_CPU: |
| { |
| return( "dma:lv" ); |
| } |
| case AVM_ARG_MEMORY_WVALUE_CPU: |
| { |
| return( "dma:wv" ); |
| } |
| case AVM_ARG_MEMORY_RVALUE_CPU: |
| { |
| return( "dma:rv" ); |
| } |
| case AVM_ARG_MEMORY_MACHINE_CPU: |
| { |
| return( "dma:rid" ); |
| } |
| |
| case AVM_ARG_ARITHMETIC_LOGIC_CPU: |
| { |
| return( "alu" ); |
| } |
| |
| case AVM_ARG_CHARACTER_CPU: |
| { |
| return( "char" ); |
| } |
| case AVM_ARG_STRING_CPU: |
| { |
| return( "string" ); |
| } |
| |
| case AVM_ARG_ARRAY_LVALUE_CPU: |
| { |
| return( "array:lv" ); |
| } |
| case AVM_ARG_ARRAY_RVALUE_CPU: |
| { |
| return( "array:rv" ); |
| } |
| |
| case AVM_ARG_VECTOR_CPU: |
| { |
| return( "vector" ); |
| } |
| |
| case AVM_ARG_QUEUE_CPU: |
| { |
| return( "queue" ); |
| } |
| case AVM_ARG_LIST_CPU: |
| { |
| return( "list" ); |
| } |
| case AVM_ARG_COLLECTION_CPU: |
| { |
| return( "collection" ); |
| } |
| |
| case AVM_ARG_BUFFER_CPU: |
| { |
| return( "buffer" ); |
| } |
| |
| case AVM_ARG_STATEMENT_CPU: |
| { |
| return( "stm" ); |
| } |
| |
| case AVM_ARG_UNDEFINED_PROCESSOR: |
| default: |
| { |
| return( "?processor" ); |
| } |
| } |
| } |
| |
| |
| std::string AvmBytecode::strNopCode(avm_arg_operation_t operation) |
| { |
| switch( operation & AVM_ARG_OPERATION_NOP_MASK ) |
| { |
| case AVM_ARG_NOP: |
| { |
| return( "nop" ); |
| } |
| case AVM_ARG_NOPS: |
| { |
| return( "nops" ); |
| } |
| |
| default: |
| { |
| return( "" ); |
| } |
| } |
| } |
| |
| std::string AvmBytecode::strEvalCode(avm_arg_operation_t operation) |
| { |
| switch( operation & AVM_ARG_OPERATION_EVAL_MASK ) |
| { |
| case AVM_ARG_SEVAL: |
| { |
| return( "seval" ); |
| } |
| |
| case AVM_ARG_MEVAL: |
| { |
| return( "meval" ); |
| } |
| |
| default: |
| { |
| return( "" ); |
| } |
| } |
| } |
| |
| |
| std::string AvmBytecode::strValueCode(avm_arg_operation_t operation) |
| { |
| switch( operation & AVM_ARG_OPERATION_VALUE_MASK ) |
| { |
| case AVM_ARG_RVALUE: |
| { |
| return( "rvalue" ); |
| } |
| case AVM_ARG_LVALUE: |
| { |
| return( "lvalue" ); |
| } |
| case AVM_ARG_WVALUE: |
| { |
| return( "wvalue" ); |
| } |
| |
| case AVM_ARG_VALUE: |
| { |
| return( "value" ); |
| } |
| |
| default: |
| { |
| return( "?value" ); |
| } |
| } |
| } |
| |
| |
| std::string AvmBytecode::strOperand(avm_arg_operand_t operand) |
| { |
| switch( operand ) |
| { |
| case AVM_ARG_DATA_KIND: |
| { |
| return( "data" ); |
| } |
| case AVM_ARG_DATA_CST_KIND: |
| { |
| return( "const" ); |
| } |
| case AVM_ARG_DATA_REF_KIND: |
| { |
| return( "ref" ); |
| } |
| case AVM_ARG_DATA_MACRO_KIND: |
| { |
| return( "macro" ); |
| } |
| case AVM_ARG_DATA_UFI_KIND: |
| { |
| return( "ufi" ); |
| } |
| |
| case AVM_ARG_PORT_KIND: |
| { |
| return( "port" ); |
| } |
| case AVM_ARG_BUFFER_KIND: |
| { |
| return( "buffer" ); |
| } |
| case AVM_ARG_CONNECTOR_KIND: |
| { |
| return( "connector" ); |
| } |
| |
| case AVM_ARG_BUILTIN_KIND: |
| { |
| return( "builtin" ); |
| } |
| case AVM_ARG_BUILTIN_ARRAY_KIND: |
| { |
| return( "built#array" ); |
| } |
| case AVM_ARG_BUILTIN_CONTAINER_KIND: |
| { |
| return( "built#collection" ); |
| } |
| |
| case AVM_ARG_BOOLEAN_KIND: |
| { |
| return( "boolean" ); |
| } |
| case AVM_ARG_INTEGER_KIND: |
| { |
| return( "integer" ); |
| } |
| case AVM_ARG_RATIONAL_KIND: |
| { |
| return( "rational" ); |
| } |
| case AVM_ARG_FLOAT_KIND: |
| { |
| return( "float" ); |
| } |
| case AVM_ARG_CHARACTER_KIND: |
| { |
| return( "char" ); |
| } |
| case AVM_ARG_STRING_KIND: |
| { |
| return( "string" ); |
| } |
| |
| case AVM_ARG_OPERATOR_KIND: |
| { |
| return( "operator" ); |
| } |
| |
| case AVM_ARG_EXPRESSION_KIND: |
| { |
| return( "expression" ); |
| } |
| case AVM_ARG_ARRAY_KIND: |
| { |
| return( "array" ); |
| } |
| case AVM_ARG_COLLECTION_KIND: |
| { |
| return( "collection" ); |
| } |
| |
| case AVM_ARG_STATEMENT_KIND: |
| { |
| return( "statement" ); |
| } |
| |
| case AVM_ARG_CTOR_TYPE_KIND: |
| { |
| return( "ctor#type" ); |
| } |
| |
| |
| case AVM_ARG_MACHINE_RID: |
| { |
| return( "machine#rid" ); |
| } |
| |
| case AVM_ARG_EXPRESSION_RID: |
| { |
| return( "expr#rid" ); |
| } |
| |
| case AVM_ARG_SELF_RID: |
| { |
| return( "self#rid" ); |
| } |
| case AVM_ARG_PARENT_RID: |
| { |
| return( "parent#rid" ); |
| } |
| case AVM_ARG_COMMUNICATOR_RID: |
| { |
| return( "com#rid" ); |
| } |
| case AVM_ARG_SYSTEM_RID: |
| { |
| return( "system#rid" ); |
| } |
| case AVM_ARG_ENVIRONMENT_RID: |
| { |
| return( "env#rid" ); |
| } |
| case AVM_ARG_COMPONENT_SELF_RID: |
| { |
| return( "component#self#rid" ); |
| } |
| case AVM_ARG_COMPONENT_PARENT_RID: |
| { |
| return( "component#parent#rid" ); |
| } |
| case AVM_ARG_COMPONENT_COMMUNICATOR_RID: |
| { |
| return( "component#com#rid" ); |
| } |
| |
| default: |
| { |
| return( "?expression" ); |
| } |
| } |
| } |
| |
| |
| std::string AvmBytecode::strType() const |
| { |
| return( (dtype != NULL) ? dtype->strT() : "null<dtype>" ); |
| } |
| |
| |
| |
| } /* namespace sep */ |
