kc3-lang/kc3

Browse

Commit c248a75e851162b44efef120ddfc398853d73c8a

Thomas de Grivel 2023-12-29T02:53:48

(void *) generic functions 

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
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296

diff --git a/libc3/buf_inspect.c b/libc3/buf_inspect.c
index c6acf13..c749aaa 100644
--- a/libc3/buf_inspect.c
+++ b/libc3/buf_inspect.c
@@ -1108,7 +1108,7 @@ sw buf_inspect_integer_size (const s_integer *x)
   return size - 1;
 }
 
-sw buf_inspect_list (s_buf *buf, const s_list **x)
+sw buf_inspect_list (s_buf *buf, const s_list * const *x)
 {
   const s_list *i;
   sw r;
diff --git a/libc3/buf_inspect.h b/libc3/buf_inspect.h
index 3c0eff1..ddc6cc5 100644
--- a/libc3/buf_inspect.h
+++ b/libc3/buf_inspect.h
@@ -93,7 +93,7 @@ sw buf_inspect_ident_reserved_size (const s_ident *ident);
 sw buf_inspect_ident_size (const s_ident *ident);
 sw buf_inspect_integer (s_buf *buf, const s_integer *x);
 sw buf_inspect_integer_size (const s_integer *x);
-sw buf_inspect_list (s_buf *buf, const s_list **list);
+sw buf_inspect_list (s_buf *buf, const s_list * const *list);
 sw buf_inspect_list_paren (s_buf *buf, const s_list * const *list);
 sw buf_inspect_list_size (const s_list * const *list);
 sw buf_inspect_list_tag (s_buf *buf, const s_tag *tag);
diff --git a/libc3/void.c b/libc3/void.c
index 7abd6ef..2bd3ca6 100644
--- a/libc3/void.c
+++ b/libc3/void.c
@@ -12,6 +12,174 @@
  */
 #include "c3.h"
 
+sw void_buf_inspect (const s_sym *type, s_buf *buf, const void *v)
+{
+  sw r;
+  if (type == sym_1("Array"))
+    return buf_inspect_array(buf, v);
+  if (type == sym_1("Bool"))
+    return buf_inspect_bool(buf, v);
+  if (type == sym_1("Call"))
+    return buf_inspect_call(buf, v);
+  if (type == sym_1("Cfn"))
+    return buf_inspect_cfn(buf, v);
+  if (type == sym_1("Character"))
+    return buf_inspect_character(buf, v);
+  if (type == sym_1("F32"))
+    return buf_inspect_f32(buf, v);
+  if (type == sym_1("F64"))
+    return buf_inspect_f64(buf, v);
+  if (type == sym_1("Fact"))
+    return buf_inspect_fact(buf, v);
+  if (type == sym_1("Fn"))
+    return buf_inspect_fn(buf, v);
+  if (type == sym_1("Ident"))
+    return buf_inspect_ident(buf, v);
+  if (type == sym_1("Integer"))
+    return buf_inspect_integer(buf, v);
+  if (type == sym_1("List"))
+    return buf_inspect_list(buf, v);
+  if (type == sym_1("Ptag"))
+    return buf_inspect_ptag(buf, v);
+  if (type == sym_1("Ptr"))
+    return buf_inspect_ptr(buf, v);
+  if (type == sym_1("PtrFree"))
+    return buf_inspect_ptr_free(buf, v);
+  if (type == sym_1("Quote"))
+    return buf_inspect_quote(buf, v);
+  if (type == sym_1("S8"))
+    return buf_inspect_s8(buf, v);
+  if (type == sym_1("S16"))
+    return buf_inspect_s16(buf, v);
+  if (type == sym_1("S32"))
+    return buf_inspect_s32(buf, v);
+  if (type == sym_1("S64"))
+    return buf_inspect_s64(buf, v);
+  if (type == sym_1("Str"))
+    return buf_inspect_str(buf, v);
+  if (type == sym_1("Struct"))
+    return buf_inspect_struct(buf, v);
+  if (type == sym_1("Sw"))
+    return buf_inspect_sw(buf, v);
+  if (type == sym_1("Sym"))
+    return buf_inspect_sym(buf, v);
+  if (type == sym_1("Tuple"))
+    return buf_inspect_tuple(buf, v);
+  if (type == sym_1("U8"))
+    return buf_inspect_u8(buf, v);
+  if (type == sym_1("U16"))
+    return buf_inspect_u16(buf, v);
+  if (type == sym_1("U32"))
+    return buf_inspect_u32(buf, v);
+  if (type == sym_1("U64"))
+    return buf_inspect_u64(buf, v);
+  if (type == sym_1("Uw"))
+    return buf_inspect_uw(buf, v);
+  if (type == sym_1("Var"))
+    return buf_inspect_var(buf, v);
+  if (type == sym_1("Void"))
+    return buf_inspect_void(buf, v);
+  /*
+  if (sym_is_array_type(type)) {
+  */
+  if (struct_type_exists(type)) {
+    s_struct s = {0};
+    struct_init_with_data(&s, type, false, (void *) v);
+    r = buf_inspect_struct(buf, &s);
+    struct_type_clean(&s.type);
+    return r;
+  }
+  err_write_1("void_buf_inspect: unknown type: ");
+  err_inspect_sym(&type);
+  err_write_1("\n");
+  assert(! "void_buf_inspect: unknown type");
+  return -1;
+}
+
+sw void_buf_inspect_size (const s_sym *type, const void *v)
+{
+  sw r;
+  if (type == sym_1("Array"))
+    return buf_inspect_array_size(v);
+  if (type == sym_1("Bool"))
+    return buf_inspect_bool_size(v);
+  if (type == sym_1("Call"))
+    return buf_inspect_call_size(v);
+  if (type == sym_1("Cfn"))
+    return buf_inspect_cfn_size(v);
+  if (type == sym_1("Character"))
+    return buf_inspect_character_size(v);
+  if (type == sym_1("F32"))
+    return buf_inspect_f32_size(v);
+  if (type == sym_1("F64"))
+    return buf_inspect_f64_size(v);
+  if (type == sym_1("Fact"))
+    return buf_inspect_fact_size(v);
+  if (type == sym_1("Fn"))
+    return buf_inspect_fn_size(v);
+  if (type == sym_1("Ident"))
+    return buf_inspect_ident_size(v);
+  if (type == sym_1("Integer"))
+    return buf_inspect_integer_size(v);
+  if (type == sym_1("List"))
+    return buf_inspect_list_size(v);
+  if (type == sym_1("Ptag"))
+    return buf_inspect_ptag_size(v);
+  if (type == sym_1("Ptr"))
+    return buf_inspect_ptr_size(v);
+  if (type == sym_1("PtrFree"))
+    return buf_inspect_ptr_free_size(v);
+  if (type == sym_1("Quote"))
+    return buf_inspect_quote_size(v);
+  if (type == sym_1("S8"))
+    return buf_inspect_s8_size(v);
+  if (type == sym_1("S16"))
+    return buf_inspect_s16_size(v);
+  if (type == sym_1("S32"))
+    return buf_inspect_s32_size(v);
+  if (type == sym_1("S64"))
+    return buf_inspect_s64_size(v);
+  if (type == sym_1("Str"))
+    return buf_inspect_str_size(v);
+  if (type == sym_1("Struct"))
+    return buf_inspect_struct_size(v);
+  if (type == sym_1("Sw"))
+    return buf_inspect_sw_size(v);
+  if (type == sym_1("Sym"))
+    return buf_inspect_sym_size(v);
+  if (type == sym_1("Tuple"))
+    return buf_inspect_tuple_size(v);
+  if (type == sym_1("U8"))
+    return buf_inspect_u8_size(v);
+  if (type == sym_1("U16"))
+    return buf_inspect_u16_size(v);
+  if (type == sym_1("U32"))
+    return buf_inspect_u32_size(v);
+  if (type == sym_1("U64"))
+    return buf_inspect_u64_size(v);
+  if (type == sym_1("Uw"))
+    return buf_inspect_uw_size(v);
+  if (type == sym_1("Var"))
+    return buf_inspect_var_size(v);
+  if (type == sym_1("Void"))
+    return buf_inspect_void_size(v);
+  /*
+  if (sym_is_array_type(type)) {
+  */
+  if (struct_type_exists(type)) {
+    s_struct s = {0};
+    struct_init_with_data(&s, type, false, (void *) v);
+    r = buf_inspect_struct_size(&s);
+    struct_type_clean(&s.type);
+    return r;
+  }
+  err_write_1("void_buf_inspect_size: unknown type: ");
+  err_inspect_sym(&type);
+  err_write_1("\n");
+  assert(! "void_buf_inspect_size: unknown type");
+  return -1;
+}
+
 bool void_clean (const s_sym *type, void *data)
 {
   assert(type);
@@ -142,6 +310,90 @@ bool void_clean (const s_sym *type, void *data)
   return false;
 }
 
+void * void_init_cast (const s_sym *type, void *v, const s_tag *tag)
+{
+  void *r;
+  if (type == sym_1("Array"))
+    return array_init_cast(v, tag);
+  if (type == sym_1("Bool"))
+    return bool_init_cast(v, tag);
+  if (type == sym_1("Call"))
+    return call_init_cast(v, tag);
+  if (type == sym_1("Cfn"))
+    return cfn_init_cast(v, tag);
+  if (type == sym_1("Character"))
+    return character_init_cast(v, tag);
+  if (type == sym_1("F32"))
+    return f32_init_cast(v, tag);
+  if (type == sym_1("F64"))
+    return f64_init_cast(v, tag);
+  if (type == sym_1("Fact"))
+    return fact_init_cast(v, tag);
+  if (type == sym_1("Fn"))
+    return fn_init_cast(v, tag);
+  if (type == sym_1("Ident"))
+    return ident_init_cast(v, tag);
+  if (type == sym_1("Integer"))
+    return integer_init_cast(v, tag);
+  if (type == sym_1("List"))
+    return list_init_cast(v, tag);
+  if (type == sym_1("Ptag"))
+    return ptag_init_cast(v, tag);
+  if (type == sym_1("Ptr"))
+    return ptr_init_cast(v, tag);
+  if (type == sym_1("PtrFree"))
+    return ptr_free_init_cast(v, tag);
+  if (type == sym_1("Quote"))
+    return quote_init_cast(v, tag);
+  if (type == sym_1("S8"))
+    return s8_init_cast(v, tag);
+  if (type == sym_1("S16"))
+    return s16_init_cast(v, tag);
+  if (type == sym_1("S32"))
+    return s32_init_cast(v, tag);
+  if (type == sym_1("S64"))
+    return s64_init_cast(v, tag);
+  if (type == sym_1("Str"))
+    return str_init_cast(v, tag);
+  if (type == sym_1("Struct"))
+    return struct_init_cast(v, tag);
+  if (type == sym_1("Sw"))
+    return sw_init_cast(v, tag);
+  if (type == sym_1("Sym"))
+    return sym_init_cast(v, tag);
+  if (type == sym_1("Tuple"))
+    return tuple_init_cast(v, tag);
+  if (type == sym_1("U8"))
+    return u8_init_cast(v, tag);
+  if (type == sym_1("U16"))
+    return u16_init_cast(v, tag);
+  if (type == sym_1("U32"))
+    return u32_init_cast(v, tag);
+  if (type == sym_1("U64"))
+    return u64_init_cast(v, tag);
+  if (type == sym_1("Uw"))
+    return uw_init_cast(v, tag);
+  if (type == sym_1("Var"))
+    return v;
+  if (type == sym_1("Void"))
+    return v;
+  /*
+  if (sym_is_array_type(type)) {
+  */
+  if (struct_type_exists(type)) {
+    s_struct s = {0};
+    struct_init_with_data(&s, type, false, v);
+    r = struct_init_cast(&s, tag);
+    struct_type_clean(&s.type);
+    return r;
+  }
+  err_write_1("void_init_cast: unknown type: ");
+  err_inspect_sym(&type);
+  err_write_1("\n");
+  assert(! "void_init_cast: unknown type");
+  return NULL;
+}
+
 void * void_init_copy (const s_sym *type, void *v, const void *src)
 {
   void *r;
kmx.io     mail     discord kmxgit v0.4.0