Develop and Download Open Source Software

NPL - NandemoProgrammingLanguage

Browse Subversion Repository

/[npl]/trunk/npl/vm.c

Diff of /trunk/npl/vm.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

trunk/npl/sm.c revision 111 by tamiya25, Fri Oct 13 23:48:21 2017 UTC trunk/npl/vm.c revision 113 by tamiya25, Fri Nov 3 05:48:52 2017 UTC
# Line 1  Line 1 
1  #include "npl.h"  #include "npl.h"
2    
3  int npl_sm_init(npl_sm_t *sm)  #define SIZE(x) (x & 0x03)
4    #define SIGNE(x) (x & 0x04)
5    #define REG(x) ((x & 0x08) >> 3)
6    
7    static void* _var(npl_vm_t *vm, size_t sp)
8  {  {
9          NPL_assert(sm);          unsigned char *p = vm->var;
10    
11          return 0;          p = p + sp;
12            return p;
13    }
14    
15    static void _setp(npl_vm_t *vm)
16    {
17            npl_u8_t code = npl_vmi_u8(&vm->vmi);
18            npl_u16_t sp = npl_vmi_u16(&vm->vmi);
19            void *p = _var(vm, sp);
20    
21            vm->ptr[REG(code)] = p;
22    }
23    
24    static void _addp(npl_vm_t *vm)
25    {
26            npl_u8_t code = npl_vmi_u8(&vm->vmi);
27            npl_u16_t sp = npl_vmi_u16(&vm->vmi);
28            unsigned char *p;
29    
30            p = (unsigned char*)vm->ptr[REG(code)];
31            p = p + sp;
32            vm->ptr[REG(code)] = p;
33    }
34    
35    static void _store(npl_vm_t *vm)
36    {
37            npl_u8_t code = npl_vmi_u8(&vm->vmi);
38            npl_u16_t sp = npl_vmi_u16(&vm->vmi);
39            void *src = vm->ptr[REG(code)];
40            void *dst = _var(vm, sp);
41    
42            switch (SIZE(code)) {
43            case 0:
44                    *((npl_u8_t*)dst) = *((npl_u8_t*)src);
45                    break;
46            case 1:
47                    *((npl_u16_t*)dst) = *((npl_u16_t*)src);
48                    break;
49            case 2:
50                    *((npl_u32_t*)dst) = *((npl_u32_t*)src);
51                    break;
52            case 3:
53                    *((npl_u64_t*)dst) = *((npl_u64_t*)src);
54                    break;
55            }
56    }
57    
58    static void _load(npl_vm_t *vm)
59    {
60            npl_u8_t code = npl_vmi_u8(&vm->vmi);
61            npl_u16_t sp = npl_vmi_u16(&vm->vmi);
62            void *src = _var(vm, sp);
63            void *dst = vm->ptr[REG(code)];
64    
65            switch (SIZE(code)) {
66            case 0:
67                    *((npl_u8_t*)dst) = *((npl_u8_t*)src);
68                    break;
69            case 1:
70                    *((npl_u16_t*)dst) = *((npl_u16_t*)src);
71                    break;
72            case 2:
73                    *((npl_u32_t*)dst) = *((npl_u32_t*)src);
74                    break;
75            case 3:
76                    *((npl_u64_t*)dst) = *((npl_u64_t*)src);
77                    break;
78            }
79    }
80    
81    static void _set(npl_vm_t *vm)
82    {
83            npl_u8_t code = npl_vmi_u8(&vm->vmi);
84            void *dst = vm->ptr[REG(code)];
85    
86            switch (SIZE(code)) {
87            case 0:
88                    *((npl_u8_t*)dst) = npl_vmi_u8(&vm->vmi);
89                    break;
90            case 1:
91                    *((npl_u16_t*)dst) = npl_vmi_u16(&vm->vmi);
92                    break;
93            case 2:
94                    *((npl_u32_t*)dst) = npl_vmi_u32(&vm->vmi);
95                    break;
96            case 3:
97                    *((npl_u64_t*)dst) = npl_vmi_u64(&vm->vmi);
98                    break;
99            }
100  }  }
101    
102  npl_sm_t* npl_sm_new(void)  static int _push(npl_vm_t *vm)
103  {  {
104          npl_sm_t *sm;          npl_u16_t bytes = npl_vmi_u16(&vm->vmi);
105            size_t new_sp;
106    
107          sm = NPL_SM(npl_object_alloc(npl_sm_type));          if (npl_add(vm->sp, bytes, &new_sp))
108          if (sm == NULL)                  return 1;  // error
109                  return NULL;          if (new_sp >= npl_buf_size(&vm->stack)) {
110          if (npl_sm_init(sm)) {                  if (bytes < 4096)
111                  npl_object_destroy(NPL_OBJECT(sm));                          bytes = 4096;
112                  return NULL;                  if (npl_buf_expand(&vm->stack, bytes))
113                            return 1;  // error
114          }          }
115    
116          return sm;          vm->sp = new_sp;
117    
118            return 0;
119    }
120    
121    static void _pop(npl_vm_t *vm)
122    {
123            npl_u16_t bytes = npl_vmi_u16(&vm->vmi);
124    
125            if (vm->sp < bytes)
126                    NPL_abort();
127            vm->sp -= bytes;
128    }
129    
130    int npl_vm_init(npl_vm_t *vm)
131    {
132            NPL_assert(vm);
133    
134            if (npl_buf_init(&vm->stack, 4096))
135                    return 1;  // error
136            vm->sp = 0;
137            vm->var = npl_buf_get_buffer(&vm->stack, 0);
138    
139            return 0;
140    }
141    
142    void npl_vm_final(npl_vm_t *vm)
143    {
144            NPL_assert(vm);
145    
146            npl_buf_final(&vm->stack);
147    }
148    
149    void npl_vm_clear(npl_vm_t *vm)
150    {
151            NPL_assert(vm);
152    
153            vm->sp = 0;
154  }  }
155    
156  // sm クラスの型情報  npl_u8_t npl_vm_exec(npl_vm_t *vm)
157  npl_type_t _npl_sm_type = {  {
158          .ctype = NPL_CT_OBJECT,          npl_u8_t code;
159          .name = L"sm",  
160          .parent = &_npl_object_type,          NPL_assert(vm);
161          .size = sizeof(npl_sm_t),  
162  };          while (1) {
163                    code = npl_vmi_u8(&vm->vmi);
164                    switch (code) {
165                    case NPL_OP_NOP:
166                            break;
167                    case NPL_OP_END:
168                    case NPL_OP_BREAK:
169                            return code;
170                    case NPL_OP_SETP:
171                            _setp(vm);
172                            break;
173                    case NPL_OP_ADDP:
174                            _addp(vm);
175                            break;
176                    case NPL_OP_STORE:
177                            _store(vm);
178                            break;
179                    case NPL_OP_LOAD:
180                            _load(vm);
181                            break;
182                    case NPL_OP_SET:
183                            _set(vm);
184                            break;
185                    case NPL_OP_PUSH:
186                            if (_push(vm))
187                                    goto ERROR;
188                            break;
189                    case NPL_OP_POP:
190                            _pop(vm);
191                            break;
192                    default:
193                            // 不正なオペコードを検出
194                            NPL_abort();
195                            break;
196                    }
197            }
198    
199  npl_type_t *npl_sm_type = &_npl_sm_type;  ERROR:
200            return 0;
201    }
202    
Legend:
Removed from v.111  
changed lines
  Added in v.113
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
About OSDN
Find Software
Develop Software
Help