/
vars.go
148 lines (141 loc) · 3.12 KB
/
vars.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
// Copyright 2019 Alexey Krivonogov. All rights reserved.
// Use of this source code is governed by a MIT license
// that can be found in the LICENSE file.
package vm
import (
"fmt"
"github.com/gentee/gentee/core"
)
// Fn is used for custom func types
type Fn struct {
Func int32 // id of function
}
// CopyVar copies one object to another one
func CopyVar(rt *Runtime, ptr *interface{}, value interface{}) {
switch vItem := value.(type) {
case *Fn:
var pfn *Fn
if ptr == nil || *ptr == nil {
pfn = &Fn{}
} else {
pfn = (*ptr).(*Fn)
}
pfn.Func = vItem.Func
*ptr = pfn
case *Struct:
var pstruct *Struct
if ptr == nil || *ptr == nil {
pstruct = NewStruct(rt, vItem.Type)
} else {
pstruct = (*ptr).(*Struct)
}
pstruct.Values = make([]interface{}, len(vItem.Values))
for i, v := range vItem.Values {
CopyVar(rt, &pstruct.Values[i], v)
}
*ptr = pstruct
case *core.Set:
var pset *core.Set
if ptr == nil || *ptr == nil {
pset = core.NewSet()
} else {
pset = (*ptr).(*core.Set)
}
pset.Data = make([]uint64, len(vItem.Data))
copy(pset.Data, vItem.Data)
*ptr = pset
case *core.Buffer:
var pbuf *core.Buffer
if ptr == nil || *ptr == nil {
pbuf = core.NewBuffer()
} else {
pbuf = (*ptr).(*core.Buffer)
}
pbuf.Data = make([]byte, len(vItem.Data))
copy(pbuf.Data, vItem.Data)
*ptr = pbuf
case *core.Array:
var parr *core.Array
if ptr == nil || *ptr == nil {
parr = core.NewArray()
} else {
parr = (*ptr).(*core.Array)
}
parr.Data = make([]interface{}, len(vItem.Data))
for i, v := range vItem.Data {
CopyVar(rt, &parr.Data[i], v)
}
*ptr = parr
case *core.Map:
var pmap *core.Map
if ptr == nil || *ptr == nil {
pmap = core.NewMap()
} else {
pmap = (*ptr).(*core.Map)
}
pmap.Keys = make([]string, len(vItem.Keys))
var mapPtr interface{}
for i, v := range vItem.Keys {
mapPtr = pmap.Data[v]
pmap.Keys[i] = v
CopyVar(rt, &mapPtr, vItem.Data[v])
pmap.Data[v] = mapPtr
}
*ptr = pmap
case *core.Obj:
var pobj *core.Obj
if ptr == nil || *ptr == nil {
pobj = core.NewObj()
} else {
pobj = (*ptr).(*core.Obj)
}
if vItem.Data == nil {
pobj.Data = nil
} else {
switch v := vItem.Data.(type) {
case bool, int64, float64, string:
pobj.Data = vItem.Data
case *core.Array:
CopyVar(rt, &pobj.Data, v)
case *core.Map:
CopyVar(rt, &pobj.Data, v)
}
}
*ptr = pobj
default:
*ptr = value
}
}
func newValue(rt *Runtime, vtype int) interface{} {
switch vtype {
case core.TYPEINT, core.TYPEBOOL:
return int64(0)
case core.TYPECHAR:
return int64(' ')
case core.TYPESTR:
return ``
case core.TYPEFLOAT:
return float64(0.0)
case core.TYPEARR:
return core.NewArray()
case core.TYPEMAP:
return core.NewMap()
case core.TYPEBUF:
return core.NewBuffer()
case core.TYPEFUNC:
return &Fn{}
case core.TYPEERROR:
return &RuntimeError{}
case core.TYPESET:
return core.NewSet()
case core.TYPEOBJ:
return core.NewObj()
default:
if vtype >= core.TYPESTRUCT {
return NewStruct(rt, &rt.Owner.Exec.Structs[(vtype-core.TYPESTRUCT)>>8])
} else {
fmt.Println(`NEW VALUE`, vtype)
}
}
return nil
}