helpers.h

Go to the documentation of this file.

// EVMC: Ethereum Client-VM Connector API.
// Copyright 2018 The EVMC Authors.
// Licensed under the Apache License, Version 2.0.
 
#pragma once
 
#include <evmc/evmc.h>
#include <stdlib.h>
#include <string.h>
 
#ifdef __cplusplus
extern "C" {
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wold-style-cast"
#endif
 
static inline bool evmc_is_abi_compatible(struct evmc_vm* vm)
{
 return vm->abi_version == EVMC_ABI_VERSION;
}
 
static inline const char* evmc_vm_name(struct evmc_vm* vm)
{
 return vm->name;
}
 
static inline const char* evmc_vm_version(struct evmc_vm* vm)
{
 return vm->version;
}
 
static inline bool evmc_vm_has_capability(struct evmc_vm* vm, enum evmc_capabilities capability)
{
 return (vm->get_capabilities(vm) & (evmc_capabilities_flagset)capability) != 0;
}
 
static inline void evmc_destroy(struct evmc_vm* vm)
{
 vm->destroy(vm);
}
 
static inline enum evmc_set_option_result evmc_set_option(struct evmc_vm* vm,
 char const* name,
 char const* value)
{
 if (vm->set_option)
 return vm->set_option(vm, name, value);
 return EVMC_SET_OPTION_INVALID_NAME;
}
 
static inline struct evmc_result evmc_execute(struct evmc_vm* vm,
 const struct evmc_host_interface* host,
 struct evmc_host_context* context,
 enum evmc_revision rev,
 const struct evmc_message* msg,
 uint8_t const* code,
 size_t code_size)
{
 return vm->execute(vm, host, context, rev, msg, code, code_size);
}
 
static void evmc_free_result_memory(const struct evmc_result* result)
{
 free((uint8_t*)result->output_data);
}
 
static inline struct evmc_result evmc_make_result(enum evmc_status_code status_code,
 int64_t gas_left,
 int64_t gas_refund,
 const uint8_t* output_data,
 size_t output_size)
{
 struct evmc_result result;
 memset(&result, 0, sizeof(result));
 
 if (output_size != 0)
 {
 uint8_t* buffer = (uint8_t*)malloc(output_size);
 
 if (!buffer)
 {
 result.status_code = EVMC_OUT_OF_MEMORY;
 return result;
 }
 
 memcpy(buffer, output_data, output_size);
 result.output_data = buffer;
 result.output_size = output_size;
 result.release = evmc_free_result_memory;
 }
 
 result.status_code = status_code;
 result.gas_left = gas_left;
 result.gas_refund = gas_refund;
 return result;
}
 
static inline void evmc_release_result(struct evmc_result* result)
{
 if (result->release)
 result->release(result);
}
 
 
union evmc_result_optional_storage
{
 uint8_t bytes[24]; 
 void* pointer; 
};
 
static inline union evmc_result_optional_storage* evmc_get_optional_storage(
 struct evmc_result* result)
{
 return (union evmc_result_optional_storage*)&result->create_address;
}
 
static inline const union evmc_result_optional_storage* evmc_get_const_optional_storage(
 const struct evmc_result* result)
{
 return (const union evmc_result_optional_storage*)&result->create_address;
}
 
static inline const char* evmc_status_code_to_string(enum evmc_status_code status_code)
{
 switch (status_code)
 {
 case EVMC_SUCCESS:
 return "success";
 case EVMC_FAILURE:
 return "failure";
 case EVMC_REVERT:
 return "revert";
 case EVMC_OUT_OF_GAS:
 return "out of gas";
 case EVMC_INVALID_INSTRUCTION:
 return "invalid instruction";
 case EVMC_UNDEFINED_INSTRUCTION:
 return "undefined instruction";
 case EVMC_STACK_OVERFLOW:
 return "stack overflow";
 case EVMC_STACK_UNDERFLOW:
 return "stack underflow";
 case EVMC_BAD_JUMP_DESTINATION:
 return "bad jump destination";
 case EVMC_INVALID_MEMORY_ACCESS:
 return "invalid memory access";
 case EVMC_CALL_DEPTH_EXCEEDED:
 return "call depth exceeded";
 case EVMC_STATIC_MODE_VIOLATION:
 return "static mode violation";
 case EVMC_PRECOMPILE_FAILURE:
 return "precompile failure";
 case EVMC_CONTRACT_VALIDATION_FAILURE:
 return "contract validation failure";
 case EVMC_ARGUMENT_OUT_OF_RANGE:
 return "argument out of range";
 case EVMC_WASM_UNREACHABLE_INSTRUCTION:
 return "wasm unreachable instruction";
 case EVMC_WASM_TRAP:
 return "wasm trap";
 case EVMC_INSUFFICIENT_BALANCE:
 return "insufficient balance";
 case EVMC_INTERNAL_ERROR:
 return "internal error";
 case EVMC_REJECTED:
 return "rejected";
 case EVMC_OUT_OF_MEMORY:
 return "out of memory";
 }
 return "<unknown>";
}
 
static inline const char* evmc_revision_to_string(enum evmc_revision rev)
{
 switch (rev)
 {
 case EVMC_FRONTIER:
 return "Frontier";
 case EVMC_HOMESTEAD:
 return "Homestead";
 case EVMC_TANGERINE_WHISTLE:
 return "Tangerine Whistle";
 case EVMC_SPURIOUS_DRAGON:
 return "Spurious Dragon";
 case EVMC_BYZANTIUM:
 return "Byzantium";
 case EVMC_CONSTANTINOPLE:
 return "Constantinople";
 case EVMC_PETERSBURG:
 return "Petersburg";
 case EVMC_ISTANBUL:
 return "Istanbul";
 case EVMC_BERLIN:
 return "Berlin";
 case EVMC_LONDON:
 return "London";
 case EVMC_PARIS:
 return "Paris";
 case EVMC_SHANGHAI:
 return "Shanghai";
 case EVMC_CANCUN:
 return "Cancun";
 }
 return "<unknown>";
}
 
#ifdef __cplusplus
#pragma GCC diagnostic pop
} // extern "C"
#endif