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
149
150
151
152
153
|
#+feature dynamic-literals
package server
import "base:runtime"
import "core:fmt"
import "core:odin/ast"
import "core:strconv"
import "src:common"
When_Expr :: union {
int, //Integers types
bool, //Boolean types
string, //Enum types - those are the hardcoded options from i.e. ODIN_OS
^ast.Expr,
}
//Because we use configuration with os names that match the files instead of the enum, i.e. my_file_windows.odin, we have to convert back and fourth.
@(private = "file")
convert_os_string: map[string]string = {
"windows" = "Windows",
"darwin" = "Darwin",
"linux" = "Linux",
"essence" = "Essence",
"freebsd" = "FreeBSD",
"wasi" = "WASI",
"js" = "JS",
"freestanding" = "Freestanding",
"haiku" = "Haiku",
"openbsd" = "OpenBSD",
"netbsd" = "NetBSD",
"orca" = "Orca",
}
resolve_when_ident :: proc(when_expr_map: map[string]When_Expr, ident: string) -> (When_Expr, bool) {
switch ident {
case "ODIN_OS":
if common.config.profile.os != "" {
os, ok := convert_os_string[common.config.profile.os]
if ok {
return os, true
} else {
return fmt.tprint(ODIN_OS), true
}
} else {
return fmt.tprint(ODIN_OS), true
}
case "ODIN_ARCH":
if common.config.profile.arch != "" {
return common.config.profile.arch, true
} else {
return fmt.tprint(ODIN_ARCH), true
}
}
if ident in when_expr_map {
value := when_expr_map[ident]
return value, true
}
if v, ok := strconv.parse_int(ident); ok {
return v, true
} else if v, ok := strconv.parse_bool(ident); ok {
return v, true
}
//If nothing is found we return it as false boolean
return false, true
}
resolve_when_expr :: proc(
when_expr_map: map[string]When_Expr,
when_expr: When_Expr,
) -> (
_when_expr: When_Expr,
ok: bool,
) {
switch expr in when_expr {
case int:
return expr, true
case bool:
return expr, true
case string:
return expr, true
case ^ast.Expr:
#partial switch odin_expr in expr.derived {
case ^ast.Paren_Expr:
return resolve_when_expr(when_expr_map, odin_expr.expr)
case ^ast.Ident:
return resolve_when_ident(when_expr_map, odin_expr.name)
case ^ast.Basic_Lit:
return resolve_when_ident(when_expr_map, odin_expr.tok.text)
case ^ast.Implicit_Selector_Expr:
return odin_expr.field.name, true
case ^ast.Unary_Expr:
if odin_expr.op.kind == .Not {
expr := resolve_when_expr(when_expr_map, odin_expr.expr) or_return
b := expr.(bool) or_return
return !b, true
}
case ^ast.Binary_Expr:
lhs := resolve_when_expr(when_expr_map, odin_expr.left) or_return
rhs := resolve_when_expr(when_expr_map, odin_expr.right) or_return
lhs_bool, lhs_is_bool := lhs.(bool)
rhs_bool, rhs_is_bool := rhs.(bool)
lhs_int, lhs_is_int := lhs.(int)
rhs_int, rhs_is_int := rhs.(int)
lhs_string, lhs_is_string := lhs.(string)
rhs_string, rhs_is_string := rhs.(string)
if lhs_is_string && rhs_is_string {
#partial switch odin_expr.op.kind {
case .Cmp_Eq:
return lhs_string == rhs_string, true
case .Not_Eq:
return lhs_string != rhs_string, true
}
} else if lhs_is_bool && rhs_is_bool {
#partial switch odin_expr.op.kind {
case .Cmp_And:
return lhs_bool && rhs_bool, true
case .Cmp_Or:
return lhs_bool || rhs_bool, true
}
}
return {}, false
}
}
return {}, false
}
resolve_when_condition :: proc(condition: ^ast.Expr) -> bool {
when_expr_map := make(map[string]When_Expr, context.temp_allocator)
for key, value in common.config.profile.defines {
when_expr_map[key] = resolve_when_ident(when_expr_map, value) or_continue
}
if when_expr, ok := resolve_when_expr(when_expr_map, condition); ok {
b, is_bool := when_expr.(bool)
return is_bool && b
}
return false
}
|
