agileRTOS (zrtos)  Version 0.8.0 (ghostbuster)
Data Structures | Macros | Typedefs | Enumerations | Functions
vm.h File Reference
#include <zrtos/types.h>
#include <zrtos/error.h>
#include <zrtos/stack.h>
#include <zrtos/mem.h>
#include <zrtos/assert.h>
#include <zrtos/vm_io.h>
#include <zrtos/vm_function_index.h>
Include dependency graph for vm.h:

Go to the source code of this file.

Data Structures

struct  _zrtos_vm_t
 
struct  _zrtos_vm_value_t
 
struct  zrtos_vm_ioop_t
 

Macros

#define ZRTOS_VM_OP_WITHOUT_FLOAT(op)
 
#define ZRTOS_VM_OP(op)
 
#define ZRTOS_VM_OP_NOT(op)
 
#define ZRTOS_VM_OP_BOOLEAN(op)
 

Typedefs

typedef struct _zrtos_vm_t zrtos_vm_t
 
typedef struct _zrtos_vm_value_t zrtos_vm_value_t
 

Enumerations

enum  zrtos_vm_op_t {
  ZRTOS_VM_OP__MIN = 0x00,
  ZRTOS_VM_OP__CAST = 0x00,
  ZRTOS_VM_OP__CAST_MIN = 0x00,
  ZRTOS_VM_OP__CAST_UINT8 = 0x00,
  ZRTOS_VM_OP__CAST_UINT16 = 0x01,
  ZRTOS_VM_OP__CAST_UINT32 = 0x03,
  ZRTOS_VM_OP__CAST_UINT64 = 0x07,
  ZRTOS_VM_OP__CAST_INT8 = 0x08,
  ZRTOS_VM_OP__CAST_INT16 = 0x09,
  ZRTOS_VM_OP__CAST_INT32 = 0x0B,
  ZRTOS_VM_OP__CAST_FLOAT = 0x0D,
  ZRTOS_VM_OP__CAST_DOUBLE = 0x0E,
  ZRTOS_VM_OP__CAST_INT64 = 0x0F,
  ZRTOS_VM_OP__CAST_MAX = 0x0F,
  ZRTOS_VM_OP__PUSH = 0x10,
  ZRTOS_VM_OP__POP = 0x11,
  ZRTOS_VM_OP__AND = 0x12,
  ZRTOS_VM_OP__OR = 0x13,
  ZRTOS_VM_OP__XOR = 0x14,
  ZRTOS_VM_OP__NEG = 0x15,
  ZRTOS_VM_OP__ADD = 0x16,
  ZRTOS_VM_OP__SUB = 0x17,
  ZRTOS_VM_OP__MUL = 0x18,
  ZRTOS_VM_OP__DIV = 0x19,
  ZRTOS_VM_OP__MOD = 0x1A,
  ZRTOS_VM_OP__NOT = 0x1B,
  ZRTOS_VM_OP__EQ = 0x1C,
  ZRTOS_VM_OP__LT = 0x1D,
  ZRTOS_VM_OP__GT = 0x1E,
  ZRTOS_VM_OP__LE = 0x1F,
  ZRTOS_VM_OP__GE = 0x20,
  ZRTOS_VM_OP__IF = 0x21,
  ZRTOS_VM_OP__ICALL = 0x22,
  ZRTOS_VM_OP__CALL = 0x23,
  ZRTOS_VM_OP__RET = 0x24,
  ZRTOS_VM_OP__SET_SP = 0x25,
  ZRTOS_VM_OP__NOP = 0x26,
  ZRTOS_VM_OP__MAX = 0xFF
}
 

Functions

 ZRTOS_ASSERT__STATIC (sizeof(zrtos_vm_op_t)==sizeof(uint8_t))
 
bool zrtos_vm__init (zrtos_vm_t *thiz, zrtos_stack_t stack, zrtos_stack_t program, zrtos_vm_function_index_t functions)
 
void zrtos_vm_value__normalize (zrtos_vm_value_t *thiz)
 
zrtos_error_t zrtos_vm__icall (zrtos_vm_t *thiz, zrtos_vm_function_id_t id)
 
zrtos_error_t zrtos_vm__run (zrtos_vm_t *thiz)
 

Macro Definition Documentation

◆ ZRTOS_VM_OP

#define ZRTOS_VM_OP (   op)
Value:
ZRTOS_VM_OP_WITHOUT_FLOAT(op)\
case ZRTOS_VM_IO_TYPE__FLOAT:\
a.value.v_f32 = a.value.v_f32 op b.value.v_f32;\
break;\
case ZRTOS_VM_IO_TYPE__DOUBLE:\
a.value.v_f64 = a.value.v_f64 op b.value.v_f64;\
break;
ZRTOS_VM_OP_WITHOUT_FLOAT
#define ZRTOS_VM_OP_WITHOUT_FLOAT(op)
Definition: vm.h:162
ZRTOS_VM_IO_TYPE__DOUBLE
Definition: vm_io.h:40
ZRTOS_VM_IO_TYPE__FLOAT
Definition: vm_io.h:39

Definition at line 188 of file vm.h.

◆ ZRTOS_VM_OP_BOOLEAN

#define ZRTOS_VM_OP_BOOLEAN (   op)
Value:
case ZRTOS_VM_IO_TYPE__INT8:\
case ZRTOS_VM_IO_TYPE__INT16:\
case ZRTOS_VM_IO_TYPE__INT32:\
case ZRTOS_VM_IO_TYPE__INT64:\
a.value.v_u8 = a.value.v_s64 op b.value.v_s64;\
break;\
case ZRTOS_VM_IO_TYPE__UINT8:\
case ZRTOS_VM_IO_TYPE__UINT16:\
case ZRTOS_VM_IO_TYPE__UINT32:\
case ZRTOS_VM_IO_TYPE__UINT64:\
a.value.v_u8 = a.value.v_u64 op b.value.v_u64;\
break;\
case ZRTOS_VM_IO_TYPE__FLOAT:\
a.value.v_u8 = a.value.v_f32 op b.value.v_f32;\
break;\
case ZRTOS_VM_IO_TYPE__DOUBLE:\
a.value.v_u8 = a.value.v_f64 op b.value.v_f64;\
break;
ZRTOS_VM_IO_TYPE__INT8
Definition: vm_io.h:35
ZRTOS_VM_IO_TYPE__INT32
Definition: vm_io.h:37
ZRTOS_VM_IO_TYPE__UINT16
Definition: vm_io.h:31
ZRTOS_VM_IO_TYPE__DOUBLE
Definition: vm_io.h:40
ZRTOS_VM_IO_TYPE__INT16
Definition: vm_io.h:36
ZRTOS_VM_IO_TYPE__UINT8
Definition: vm_io.h:30
ZRTOS_VM_IO_TYPE__UINT64
Definition: vm_io.h:33
ZRTOS_VM_IO_TYPE__INT64
Definition: vm_io.h:42
ZRTOS_VM_IO_TYPE__UINT32
Definition: vm_io.h:32
ZRTOS_VM_IO_TYPE__FLOAT
Definition: vm_io.h:39

Definition at line 215 of file vm.h.

◆ ZRTOS_VM_OP_NOT

#define ZRTOS_VM_OP_NOT (   op)
Value:
case ZRTOS_VM_IO_TYPE__FLOAT:\
a.value.v_f32 = op a.value.v_f32;\
break;\
case ZRTOS_VM_IO_TYPE__DOUBLE:\
a.value.v_f64 = op a.value.v_f64;\
break;\
case ZRTOS_VM_IO_TYPE__INT8:\
case ZRTOS_VM_IO_TYPE__INT16:\
case ZRTOS_VM_IO_TYPE__INT32:\
case ZRTOS_VM_IO_TYPE__INT64:\
case ZRTOS_VM_IO_TYPE__UINT8:\
case ZRTOS_VM_IO_TYPE__UINT16:\
case ZRTOS_VM_IO_TYPE__UINT32:\
case ZRTOS_VM_IO_TYPE__UINT64:\
a.value.v_u64 = op a.value.v_u64;\
break;
ZRTOS_VM_IO_TYPE__INT8
Definition: vm_io.h:35
ZRTOS_VM_IO_TYPE__INT32
Definition: vm_io.h:37
ZRTOS_VM_IO_TYPE__UINT16
Definition: vm_io.h:31
ZRTOS_VM_IO_TYPE__DOUBLE
Definition: vm_io.h:40
ZRTOS_VM_IO_TYPE__INT16
Definition: vm_io.h:36
ZRTOS_VM_IO_TYPE__UINT8
Definition: vm_io.h:30
ZRTOS_VM_IO_TYPE__UINT64
Definition: vm_io.h:33
ZRTOS_VM_IO_TYPE__INT64
Definition: vm_io.h:42
ZRTOS_VM_IO_TYPE__UINT32
Definition: vm_io.h:32
ZRTOS_VM_IO_TYPE__FLOAT
Definition: vm_io.h:39

Definition at line 197 of file vm.h.

◆ ZRTOS_VM_OP_WITHOUT_FLOAT

#define ZRTOS_VM_OP_WITHOUT_FLOAT (   op)
Value:
case ZRTOS_VM_IO_TYPE__INT8:\
a.value.v_s8 = a.value.v_s8 op b.value.v_s8;\
break;\
case ZRTOS_VM_IO_TYPE__INT16:\
a.value.v_s16 = a.value.v_s16 op b.value.v_s16;\
break;\
case ZRTOS_VM_IO_TYPE__INT32:\
a.value.v_s32 = a.value.v_s32 op b.value.v_s32;\
break;\
case ZRTOS_VM_IO_TYPE__INT64:\
a.value.v_s64 = a.value.v_s64 op b.value.v_s64;\
break;\
case ZRTOS_VM_IO_TYPE__UINT8:\
a.value.v_u8 = a.value.v_u8 op b.value.v_u8;\
break;\
case ZRTOS_VM_IO_TYPE__UINT16:\
a.value.v_u16 = a.value.v_u16 op b.value.v_u16;\
break;\
case ZRTOS_VM_IO_TYPE__UINT32:\
a.value.v_u32 = a.value.v_u32 op b.value.v_u32;\
break;\
case ZRTOS_VM_IO_TYPE__UINT64:\
a.value.v_u64 = a.value.v_u64 op b.value.v_u64;\
break;
ZRTOS_VM_IO_TYPE__INT8
Definition: vm_io.h:35
ZRTOS_VM_IO_TYPE__INT32
Definition: vm_io.h:37
ZRTOS_VM_IO_TYPE__UINT16
Definition: vm_io.h:31
ZRTOS_VM_IO_TYPE__INT16
Definition: vm_io.h:36
ZRTOS_VM_IO_TYPE__UINT8
Definition: vm_io.h:30
ZRTOS_VM_IO_TYPE__UINT64
Definition: vm_io.h:33
ZRTOS_VM_IO_TYPE__INT64
Definition: vm_io.h:42
ZRTOS_VM_IO_TYPE__UINT32
Definition: vm_io.h:32

Definition at line 162 of file vm.h.

Typedef Documentation

◆ zrtos_vm_t

typedef struct _zrtos_vm_t zrtos_vm_t

◆ zrtos_vm_value_t

typedef struct _zrtos_vm_value_t zrtos_vm_value_t

Enumeration Type Documentation

◆ zrtos_vm_op_t

enum zrtos_vm_op_t
Enumerator
ZRTOS_VM_OP__MIN 
ZRTOS_VM_OP__CAST 
ZRTOS_VM_OP__CAST_MIN 
ZRTOS_VM_OP__CAST_UINT8 
ZRTOS_VM_OP__CAST_UINT16 
ZRTOS_VM_OP__CAST_UINT32 
ZRTOS_VM_OP__CAST_UINT64 
ZRTOS_VM_OP__CAST_INT8 
ZRTOS_VM_OP__CAST_INT16 
ZRTOS_VM_OP__CAST_INT32 
ZRTOS_VM_OP__CAST_FLOAT 
ZRTOS_VM_OP__CAST_DOUBLE 
ZRTOS_VM_OP__CAST_INT64 
ZRTOS_VM_OP__CAST_MAX 
ZRTOS_VM_OP__PUSH 
ZRTOS_VM_OP__POP 
ZRTOS_VM_OP__AND 
ZRTOS_VM_OP__OR 
ZRTOS_VM_OP__XOR 
ZRTOS_VM_OP__NEG 
ZRTOS_VM_OP__ADD 
ZRTOS_VM_OP__SUB 
ZRTOS_VM_OP__MUL 
ZRTOS_VM_OP__DIV 
ZRTOS_VM_OP__MOD 
ZRTOS_VM_OP__NOT 
ZRTOS_VM_OP__EQ 
ZRTOS_VM_OP__LT 
ZRTOS_VM_OP__GT 
ZRTOS_VM_OP__LE 
ZRTOS_VM_OP__GE 
ZRTOS_VM_OP__IF 
ZRTOS_VM_OP__ICALL 
ZRTOS_VM_OP__CALL 
ZRTOS_VM_OP__RET 
ZRTOS_VM_OP__SET_SP 
ZRTOS_VM_OP__NOP 
ZRTOS_VM_OP__MAX 

Definition at line 26 of file vm.h.

26  {
27  ZRTOS_VM_OP__MIN = 0x00
28 
29  ,ZRTOS_VM_OP__CAST = 0x00
30  ,ZRTOS_VM_OP__CAST_MIN = 0x00
31  ,ZRTOS_VM_OP__CAST_UINT8 = 0x00
32  ,ZRTOS_VM_OP__CAST_UINT16 = 0x01
33  ,ZRTOS_VM_OP__CAST_UINT32 = 0x03
34  ,ZRTOS_VM_OP__CAST_UINT64 = 0x07
35  ,ZRTOS_VM_OP__CAST_INT8 = 0x08
36  ,ZRTOS_VM_OP__CAST_INT16 = 0x09
37  ,ZRTOS_VM_OP__CAST_INT32 = 0x0B
38  ,ZRTOS_VM_OP__CAST_FLOAT = 0x0D
39  ,ZRTOS_VM_OP__CAST_DOUBLE = 0x0E
40  ,ZRTOS_VM_OP__CAST_INT64 = 0x0F
41  ,ZRTOS_VM_OP__CAST_MAX = 0x0F
42 
43  ,ZRTOS_VM_OP__PUSH = 0x10
44  ,ZRTOS_VM_OP__POP = 0x11
45 
46  ,ZRTOS_VM_OP__AND = 0x12
47  ,ZRTOS_VM_OP__OR = 0x13
48  ,ZRTOS_VM_OP__XOR = 0x14
49  ,ZRTOS_VM_OP__NEG = 0x15
50 
51  ,ZRTOS_VM_OP__ADD = 0x16
52  ,ZRTOS_VM_OP__SUB = 0x17
53  ,ZRTOS_VM_OP__MUL = 0x18
54  ,ZRTOS_VM_OP__DIV = 0x19
55  ,ZRTOS_VM_OP__MOD = 0x1A
56 
57  ,ZRTOS_VM_OP__NOT = 0x1B
58  ,ZRTOS_VM_OP__EQ = 0x1C
59  ,ZRTOS_VM_OP__LT = 0x1D
60  ,ZRTOS_VM_OP__GT = 0x1E
61  ,ZRTOS_VM_OP__LE = 0x1F
62  ,ZRTOS_VM_OP__GE = 0x20
63 
64  ,ZRTOS_VM_OP__IF = 0x21
65 
66  ,ZRTOS_VM_OP__ICALL = 0x22
67  ,ZRTOS_VM_OP__CALL = 0x23
68  ,ZRTOS_VM_OP__RET = 0x24
69 
70  ,ZRTOS_VM_OP__SET_SP = 0x25
71 
72  ,ZRTOS_VM_OP__NOP = 0x26
73 
74  ,ZRTOS_VM_OP__MAX = 0xFF
75 }zrtos_vm_op_t;
zrtos_vm_op_t
zrtos_vm_op_t
Definition: vm.h:26

Function Documentation

◆ ZRTOS_ASSERT__STATIC()

ZRTOS_ASSERT__STATIC ( sizeof(zrtos_vm_op_t)  = =sizeof(uint8_t))

◆ zrtos_vm__icall()

zrtos_error_t zrtos_vm__icall ( zrtos_vm_t *  thiz,
zrtos_vm_function_id_t  id 
)

Definition at line 146 of file vm.h.

146  {
147  zrtos_error_t ret = ZRTOS_ERROR__INVAL;
148  zrtos_vm_function_t *fn = zrtos_vm_function_index__get_function(
149  &thiz->functions
150  ,id
151  );
152  if(fn){
153  ret = zrtos_vm_function__get_callback(fn)(
154  thiz
155  ,fn
156  );
157  }
158  return ret;
159 }
_zrtos_vm_t::functions
zrtos_vm_function_index_t functions
Definition: vm.h:82
zrtos_vm_function__get_callback
zrtos_vm_function_callback_t zrtos_vm_function__get_callback(zrtos_vm_function_t *thiz)
Definition: vm_function.h:44
_zrtos_vm_function_t
Definition: vm_function.h:25
ZRTOS_ERROR__INVAL
Invalid argument.
Definition: error.h:46
zrtos_vm_function_index__get_function
zrtos_vm_function_t * zrtos_vm_function_index__get_function(zrtos_vm_function_index_t *thiz, zrtos_vm_function_id_t id)
Definition: vm_function_index.h:41
zrtos_error_t
zrtos_error_t
Definition: error.h:20
Here is the call graph for this function:
Here is the caller graph for this function:

◆ zrtos_vm__init()

bool zrtos_vm__init ( zrtos_vm_t *  thiz,
zrtos_stack_t  stack,
zrtos_stack_t  program,
zrtos_vm_function_index_t  functions 
)

Definition at line 86 of file vm.h.

91  {
92  thiz->stack = stack;
93  thiz->program = program;
94  thiz->functions = functions;
95  thiz->is_interrupted = false;
96 
97  return true;
98 }
_zrtos_vm_t::functions
zrtos_vm_function_index_t functions
Definition: vm.h:82
_zrtos_vm_t::is_interrupted
bool is_interrupted
Definition: vm.h:83
_zrtos_vm_t::stack
zrtos_stack_t stack
Definition: vm.h:80
_zrtos_vm_t::program
zrtos_stack_t program
Definition: vm.h:81

◆ zrtos_vm__run()

zrtos_error_t zrtos_vm__run ( zrtos_vm_t *  thiz)
Todo:
shift left

Definition at line 236 of file vm.h.

236  {
237  zrtos_stack_t *stack = &thiz->stack;
238  zrtos_stack_t *program = &thiz->program;
239  zrtos_stack_t *set_offset_stack;
240  zrtos_error_t ret = ZRTOS_ERROR__SUCCESS;
241  zrtos_vm_value_t a;
242  zrtos_vm_value_t b;
243  zrtos_vm_io_type_t io_type;
244  zrtos_vm_io_source_t io_src;
245  size_t length;
246  zrtos_vm_ioop_t ioop;
247  zrtos_vm_value_t *dest;
248 
249  while(!thiz->is_interrupted
250  && zrtos_stack__shift(program,&ioop,2)
251  ){
252  io_type = (ioop.io & ZRTOS_VM_IO_TYPE__MASK);
253  io_src = (ioop.io & ZRTOS_VM_IO_SOURCE__MASK);
254  length = zrtos_vm_io_type__get_length(io_type);
255 
256  zrtos_mem__zero(&a.value,sizeof(a.value));
257  zrtos_mem__zero(&b.value,sizeof(b.value));
258 
259  a.type = b.type = io_type;
260 
261  //input
262  dest = &a;
263  while((io_src & ZRTOS_VM_IO_SOURCE__MASK)){
264  if((io_src & ZRTOS_VM_IO_SOURCE__A_PROGRAM) > 0){
265  if(!zrtos_stack__shift(program,&dest->value,length)){
266  goto L_RETURN__EFAULT;
267  }
268  }else if((io_src & ZRTOS_VM_IO_SOURCE__A_STACK) > 0){
269  if(!zrtos_stack__pop(stack,&dest->value,length)){
270  goto L_RETURN__EFAULT;
271  }
272  }else if((io_src & ZRTOS_VM_IO_SOURCE__A_ADDRESS) > 0){
273  zrtos_mem__zero(
274  &dest->address.address
275  ,sizeof(dest->address.address)
276  );
277  if(zrtos_stack__shift(program,&dest->address.type,1)
278  && zrtos_stack__shift(
279  program
280  ,&dest->address.address
281  ,zrtos_vm_io_address__get_length(&dest->address)
282  )
283  && zrtos_stack__read_ex(
284  ( zrtos_vm_io_address__is_source_program(&dest->address)
285  ? program
286  : stack)
287  ,&dest->value
288  ,length
289  ,zrtos_vm_io_address__get_address(&dest->address)
290  ,zrtos_vm_io_address__is_relative(&dest->address)
291  ,zrtos_vm_io_address__is_negative(&dest->address)
292  )){
293  goto L_INPUT_NORMALIZE;
294  }
295  goto L_RETURN__EFAULT;
296  }else{
297  goto L_INPUT__NEXT;
298  }
299 
300 
301 
302 L_INPUT_NORMALIZE:
303  zrtos_vm_value__normalize(dest);
304 L_INPUT__NEXT:
305  dest = &b;
306  ///@todo shift left
307  io_src >>= 2;
308  }
309 
310  //process
311  switch(ioop.op){
312  case ZRTOS_VM_OP__CAST_INT8:
313  case ZRTOS_VM_OP__CAST_INT16:
314  case ZRTOS_VM_OP__CAST_INT32:
315  case ZRTOS_VM_OP__CAST_INT64:
316  if(zrtos_vm_io_type__is_uint(a.type)){
317  a.value.v_s64 = (int64_t)a.value.v_u64;
318  }else if(zrtos_vm_io_type__is_float(a.type)){
319  a.value.v_s64 = (int64_t)a.value.v_f32;
320  }else if(zrtos_vm_io_type__is_double(a.type)){
321  a.value.v_s64 = (int64_t)a.value.v_f64;
322  }else{//} if(zrtos_vm_io_type__is_int(a.type)){
323 
324  }
325  goto L_OUTPUT__CAST;
326  case ZRTOS_VM_OP__CAST_UINT8:
327  case ZRTOS_VM_OP__CAST_UINT16:
328  case ZRTOS_VM_OP__CAST_UINT32:
329  case ZRTOS_VM_OP__CAST_UINT64:
330  if(zrtos_vm_io_type__is_uint(a.type)){
331 
332  }else if(zrtos_vm_io_type__is_float(a.type)){
333  a.value.v_u64 = (uint64_t)a.value.v_f32;
334  }else if(zrtos_vm_io_type__is_double(a.type)){
335  a.value.v_u64 = (uint64_t)a.value.v_f64;
336  }else{//} if(zrtos_vm_io_type__is_int(a.type)){
337  a.value.v_u64 = (uint64_t)a.value.v_s64;
338  }
339  goto L_OUTPUT__CAST;
340  case ZRTOS_VM_OP__CAST_FLOAT:
341  if(zrtos_vm_io_type__is_uint(a.type)){
342  a.value.v_f32 = (float)a.value.v_u64;
343  }else if(zrtos_vm_io_type__is_float(a.type)){
344 
345  }else if(zrtos_vm_io_type__is_double(a.type)){
346  a.value.v_f32 = (float)a.value.v_f64;
347  }else{//} if(zrtos_vm_io_type__is_int(a.type)){
348  a.value.v_f32 = (float)a.value.v_s64;
349  }
350  goto L_OUTPUT__CAST;
351  case ZRTOS_VM_OP__CAST_DOUBLE:
352  if(zrtos_vm_io_type__is_uint(a.type)){
353  a.value.v_f64 = (double)a.value.v_u64;
354  }else if(zrtos_vm_io_type__is_float(a.type)){
355  a.value.v_f64 = (double)a.value.v_f32;
356  }else if(zrtos_vm_io_type__is_double(a.type)){
357 
358  }else{//} if(zrtos_vm_io_type__is_int(a.type)){
359  a.value.v_f64 = (double)a.value.v_s64;
360  }
361  goto L_OUTPUT__CAST;
362 
363  case ZRTOS_VM_OP__PUSH:
364  goto L_OUTPUT__PUSH_TYPE;
365  case ZRTOS_VM_OP__POP:
366  goto L_OUTPUT__END;
367 
368 
369 
370  case ZRTOS_VM_OP__AND:
371  a.value.v_u64 &= b.value.v_u64;
372  goto L_OUTPUT__PUSH_TYPE;
373  case ZRTOS_VM_OP__OR:
374  a.value.v_u64 |= b.value.v_u64;
375  goto L_OUTPUT__PUSH_TYPE;
376  case ZRTOS_VM_OP__XOR:
377  a.value.v_u64 ^= b.value.v_u64;
378  goto L_OUTPUT__PUSH_TYPE;
379  case ZRTOS_VM_OP__NEG:
380  a.value.v_u64 = ~a.value.v_u64;
381  goto L_OUTPUT__PUSH_TYPE;
382 
383  case ZRTOS_VM_OP__ADD:
384  switch(io_type){
385  ZRTOS_VM_OP(+)
386  }
387  goto L_OUTPUT__PUSH_TYPE;
388  case ZRTOS_VM_OP__SUB:
389  switch(io_type){
390  ZRTOS_VM_OP(-)
391  }
392  goto L_OUTPUT__PUSH_TYPE;
393  case ZRTOS_VM_OP__MUL:
394  switch(io_type){
395  ZRTOS_VM_OP(*)
396  }
397  goto L_OUTPUT__PUSH_TYPE;
398  case ZRTOS_VM_OP__DIV:
399  switch(io_type){
400  ZRTOS_VM_OP(/)
401  }
402  goto L_OUTPUT__PUSH_TYPE;
403  case ZRTOS_VM_OP__MOD:
404  switch(io_type){
405  ZRTOS_VM_OP_WITHOUT_FLOAT(%)
406  case ZRTOS_VM_IO_TYPE__FLOAT:
407  case ZRTOS_VM_IO_TYPE__DOUBLE:
408  goto L_RETURN__EINVAL;
409  }
410  goto L_OUTPUT__PUSH_TYPE;
411 
412  case ZRTOS_VM_OP__NOT:
413  switch(io_type){
414  ZRTOS_VM_OP_NOT(!)
415  }
416  goto L_OUTPUT__PUSH_BOOL;
417  case ZRTOS_VM_OP__EQ:
418  switch(io_type){
419  ZRTOS_VM_OP_BOOLEAN(==)
420  }
421  goto L_OUTPUT__PUSH_BOOL;
422  case ZRTOS_VM_OP__LT:
423  switch(io_type){
424  ZRTOS_VM_OP_BOOLEAN(<)
425  }
426  goto L_OUTPUT__PUSH_BOOL;
427  case ZRTOS_VM_OP__GT:
428  switch(io_type){
429  ZRTOS_VM_OP_BOOLEAN(>)
430  }
431  goto L_OUTPUT__PUSH_BOOL;
432  case ZRTOS_VM_OP__LE:
433  switch(io_type){
434  ZRTOS_VM_OP_BOOLEAN(<=)
435  }
436  goto L_OUTPUT__PUSH_BOOL;
437  case ZRTOS_VM_OP__GE:
438  switch(io_type){
439  ZRTOS_VM_OP_BOOLEAN(>=)
440  }
441  goto L_OUTPUT__PUSH_BOOL;
442 
443 
444  case ZRTOS_VM_OP__IF:
445  if(b.value.v_u8 == 0){
446  goto L_OUTPUT__SET_PROGRAM_OFFSET;
447  }
448  goto L_OUTPUT__END;
449 
450  case ZRTOS_VM_OP__ICALL:
451  ret = zrtos_vm__icall(thiz,a.value.v_u64);
452  if(ret != 0){
453  goto L_RETURN__END;
454  }
455  goto L_OUTPUT__END;
456 
457  case ZRTOS_VM_OP__CALL:
458  case ZRTOS_VM_OP__RET:
459  goto L_OUTPUT__SET_PROGRAM_OFFSET;
460 
461  case ZRTOS_VM_OP__SET_SP:
462  goto L_OUTPUT__SET_STACK_OFFSET;
463 
464  case ZRTOS_VM_OP__NOP:
465  goto L_OUTPUT__END;
466  }
467 
468  goto L_OUTPUT__END;
469 
470  //output
471 L_OUTPUT__CAST:
472  a.type = ioop.op - ZRTOS_VM_OP__CAST;
473  goto L_OUTPUT__PUSH_TYPE;
474 L_OUTPUT__PUSH_BOOL:
475  a.type = ZRTOS_VM_IO_TYPE__UINT8;
476 L_OUTPUT__PUSH_TYPE:
477  if((io_src & ZRTOS_VM_IO_SOURCE__A_ADDRESS) > 0){
478  if(zrtos_stack__write_ex(
479  stack
480  ,&a.value
481  ,zrtos_vm_io_type__get_length(a.type)
482  ,zrtos_vm_io_address__get_address(&a.address)
483  ,zrtos_vm_io_address__is_relative(&a.address)
484  ,zrtos_vm_io_address__is_negative(&a.address)
485  )){
486  goto L_OUTPUT__END;
487  }
488  }else if(zrtos_stack__push(
489  stack
490  ,&a.value
491  ,zrtos_vm_io_type__get_length(a.type)
492  )){
493  goto L_OUTPUT__END;
494  }
495  goto L_RETURN__EFAULT;
496 L_OUTPUT__SET_PROGRAM_OFFSET:
497  set_offset_stack = program;
498  goto L_OUTPUT__SET_OFFSET;
499 L_OUTPUT__SET_STACK_OFFSET:
500  set_offset_stack = stack;
501 L_OUTPUT__SET_OFFSET:
502  if(!zrtos_stack__set_offset_ex(
503  set_offset_stack
504  ,a.value.v_u64 >> 2
505  ,(a.value.v_u64 & 0x1) > 0
506  ,(a.value.v_u64 & 0x2) > 0
507  )){
508  goto L_RETURN__EFAULT;
509  }
510  goto L_OUTPUT__END;
511 L_OUTPUT__END:
512  continue;
513  }
514 
515 L_RETURN__EINVAL:
516  ret = ZRTOS_ERROR__INVAL;
517  goto L_RETURN__END;
518 L_RETURN__EFAULT:
519  ret = ZRTOS_ERROR__FAULT;
520  goto L_RETURN__END;
521 L_RETURN__END:
522  return ret;
523 }
zrtos_vm_ioop_t::op
zrtos_vm_op_t op
Definition: vm.h:143
_zrtos_vm_value_t::v_s64
int64_t v_s64
Definition: vm.h:110
zrtos_vm_value__normalize
void zrtos_vm_value__normalize(zrtos_vm_value_t *thiz)
Definition: vm.h:119
zrtos_vm_io_address__get_address
size_t zrtos_vm_io_address__get_address(zrtos_vm_io_address_t *thiz)
Definition: vm_io.h:106
_zrtos_vm_value_t
Definition: vm.h:100
ZRTOS_VM_IO_SOURCE__A_STACK
Definition: vm_io.h:19
zrtos_vm_io_address__is_negative
bool zrtos_vm_io_address__is_negative(zrtos_vm_io_address_t *thiz)
Definition: vm_io.h:110
_zrtos_vm_value_t::address
zrtos_vm_io_address_t address
Definition: vm.h:116
ZRTOS_VM_OP
#define ZRTOS_VM_OP(op)
Definition: vm.h:188
_zrtos_vm_t::is_interrupted
bool is_interrupted
Definition: vm.h:83
zrtos_vm__icall
zrtos_error_t zrtos_vm__icall(zrtos_vm_t *thiz, zrtos_vm_function_id_t id)
Definition: vm.h:146
zrtos_mem__zero
void zrtos_mem__zero(void *dest, size_t len)
Definition: mem.h:144
ZRTOS_VM_IO_SOURCE__MASK
Definition: vm_io.h:26
ZRTOS_VM_IO_SOURCE__A_ADDRESS
Definition: vm_io.h:21
zrtos_vm_io_type__is_double
bool zrtos_vm_io_type__is_double(zrtos_vm_io_type_t type)
Definition: vm_io.h:64
ZRTOS_VM_IO_SOURCE__A_PROGRAM
Definition: vm_io.h:20
ZRTOS_VM_OP_WITHOUT_FLOAT
#define ZRTOS_VM_OP_WITHOUT_FLOAT(op)
Definition: vm.h:162
ZRTOS_VM_IO_TYPE__DOUBLE
Definition: vm_io.h:40
ZRTOS_VM_OP_NOT
#define ZRTOS_VM_OP_NOT(op)
Definition: vm.h:197
zrtos_stack__push
bool zrtos_stack__push(zrtos_stack_t *thiz, void *data, size_t length)
Definition: stack.h:179
zrtos_vm_io_type__get_length
size_t zrtos_vm_io_type__get_length(zrtos_vm_io_type_t type)
Definition: vm_io.h:68
_zrtos_vm_value_t::v_f32
float v_f32
Definition: vm.h:112
_zrtos_vm_value_t::type
zrtos_vm_io_type_t type
Definition: vm.h:115
ZRTOS_VM_IO_TYPE__UINT8
Definition: vm_io.h:30
zrtos_vm_ioop_t::io
uint8_t io
Definition: vm.h:142
_zrtos_vm_io_source_address_t::type
zrtos_vm_io_address_type_t type
Definition: vm_io.h:101
_zrtos_vm_value_t::v_f64
double v_f64
Definition: vm.h:113
zrtos_stack__read_ex
bool zrtos_stack__read_ex(zrtos_stack_t *thiz, void *data, size_t length, size_t offset, bool is_relative, bool is_negative)
Definition: stack.h:115
_zrtos_vm_value_t::v_u64
uint64_t v_u64
Definition: vm.h:105
zrtos_vm_io_type__is_uint
bool zrtos_vm_io_type__is_uint(zrtos_vm_io_type_t type)
Definition: vm_io.h:47
zrtos_stack__pop
bool zrtos_stack__pop(zrtos_stack_t *thiz, void *data, size_t length)
Definition: stack.h:201
_zrtos_vm_value_t::value
union _zrtos_vm_value_t::@0 value
_zrtos_stack_t
Definition: stack.h:19
ZRTOS_ERROR__SUCCESS
Successful program execution status.
Definition: error.h:22
ZRTOS_ERROR__FAULT
Bad address.
Definition: error.h:38
ZRTOS_ERROR__INVAL
Invalid argument.
Definition: error.h:46
_zrtos_vm_t::stack
zrtos_stack_t stack
Definition: vm.h:80
_zrtos_vm_value_t::v_u8
uint8_t v_u8
Definition: vm.h:102
ZRTOS_VM_IO_TYPE__FLOAT
Definition: vm_io.h:39
_zrtos_vm_t::program
zrtos_stack_t program
Definition: vm.h:81
ZRTOS_VM_OP_BOOLEAN
#define ZRTOS_VM_OP_BOOLEAN(op)
Definition: vm.h:215
_zrtos_vm_io_source_address_t::address
size_t address
Definition: vm_io.h:100
zrtos_stack__shift
bool zrtos_stack__shift(zrtos_stack_t *thiz, void *data, size_t length)
Definition: stack.h:222
zrtos_vm_ioop_t
Definition: vm.h:141
ZRTOS_VM_IO_TYPE__MASK
Definition: vm_io.h:44
zrtos_vm_io_address__is_relative
bool zrtos_vm_io_address__is_relative(zrtos_vm_io_address_t *thiz)
Definition: vm_io.h:114
zrtos_vm_io_source_t
zrtos_vm_io_source_t
Definition: vm_io.h:17
zrtos_vm_io_address__is_source_program
bool zrtos_vm_io_address__is_source_program(zrtos_vm_io_address_t *thiz)
Definition: vm_io.h:122
zrtos_error_t
zrtos_error_t
Definition: error.h:20
zrtos_vm_io_address__get_length
size_t zrtos_vm_io_address__get_length(zrtos_vm_io_address_t *thiz)
Definition: vm_io.h:118
zrtos_stack__set_offset_ex
bool zrtos_stack__set_offset_ex(zrtos_stack_t *thiz, size_t offset, bool is_relative, bool is_negative)
Definition: stack.h:82
zrtos_vm_io_type__is_float
bool zrtos_vm_io_type__is_float(zrtos_vm_io_type_t type)
Definition: vm_io.h:60
zrtos_stack__write_ex
bool zrtos_stack__write_ex(zrtos_stack_t *thiz, void *data, size_t length, size_t offset, bool is_relative, bool is_negative)
Definition: stack.h:156
zrtos_vm_io_type_t
zrtos_vm_io_type_t
Definition: vm_io.h:29
Here is the call graph for this function:

◆ zrtos_vm_value__normalize()

void zrtos_vm_value__normalize ( zrtos_vm_value_t *  thiz)

Definition at line 119 of file vm.h.

119  {
120  switch(thiz->type){
121  case ZRTOS_VM_IO_TYPE__INT8:
122  thiz->value.v_s64 = (int64_t)thiz->value.v_s8;
123  break;
124  case ZRTOS_VM_IO_TYPE__INT16:
125  thiz->value.v_s64 = (int64_t)thiz->value.v_s16;
126  break;
127  case ZRTOS_VM_IO_TYPE__INT32:
128  thiz->value.v_s64 = (int64_t)thiz->value.v_s32;
129  break;
130  case ZRTOS_VM_IO_TYPE__INT64:
131  case ZRTOS_VM_IO_TYPE__UINT8:
132  case ZRTOS_VM_IO_TYPE__UINT16:
133  case ZRTOS_VM_IO_TYPE__UINT32:
134  case ZRTOS_VM_IO_TYPE__UINT64:
135  case ZRTOS_VM_IO_TYPE__FLOAT:
136  case ZRTOS_VM_IO_TYPE__DOUBLE:
137  break;
138  }
139 }
_zrtos_vm_value_t::v_s64
int64_t v_s64
Definition: vm.h:110
ZRTOS_VM_IO_TYPE__INT8
Definition: vm_io.h:35
_zrtos_vm_value_t::v_s16
int16_t v_s16
Definition: vm.h:108
ZRTOS_VM_IO_TYPE__INT32
Definition: vm_io.h:37
_zrtos_vm_value_t::v_s32
int32_t v_s32
Definition: vm.h:109
ZRTOS_VM_IO_TYPE__UINT16
Definition: vm_io.h:31
ZRTOS_VM_IO_TYPE__DOUBLE
Definition: vm_io.h:40
_zrtos_vm_value_t::v_s8
int8_t v_s8
Definition: vm.h:107
ZRTOS_VM_IO_TYPE__INT16
Definition: vm_io.h:36
_zrtos_vm_value_t::type
zrtos_vm_io_type_t type
Definition: vm.h:115
ZRTOS_VM_IO_TYPE__UINT8
Definition: vm_io.h:30
ZRTOS_VM_IO_TYPE__UINT64
Definition: vm_io.h:33
_zrtos_vm_value_t::value
union _zrtos_vm_value_t::@0 value
ZRTOS_VM_IO_TYPE__INT64
Definition: vm_io.h:42
ZRTOS_VM_IO_TYPE__UINT32
Definition: vm_io.h:32
ZRTOS_VM_IO_TYPE__FLOAT
Definition: vm_io.h:39
Here is the caller graph for this function: