diff options
| -rw-r--r-- | ffi.c | 49 | ||||
| -rw-r--r-- | txr.1 | 42 |
2 files changed, 80 insertions, 11 deletions
@@ -2811,7 +2811,7 @@ static val ffi_memb_compile(val syntax, int last, int *pflexp, val self) val type = cadr(syntax); val comp_type = ffi_type_compile(type); struct txr_ffi_type *ctft = ffi_type_struct(comp_type); - if (cddr(syntax)) + if (consp(cddr(syntax)) && cdddr(syntax)) uw_throwf(error_s, lit("~a: excess elements in type-member pair ~s"), self, syntax, nao); if (ctft->flexible || (ctft->incomplete && ctft->kind == FFI_KIND_ARRAY)) { @@ -3287,6 +3287,18 @@ static val ffi_type_lookup(val sym) return gethash(ffi_typedef_hash, sym); } +static val ffi_struct_init(val slot_init, val strct) +{ + val stype = struct_type(strct); + for (; slot_init; slot_init = us_cdr(slot_init)) { + us_cons_bind(slot, initval, us_car(slot_init)); + if (!static_slot_p(stype, slot)) + slotset(strct, slot, initval); + } + + return nil; +} + val ffi_type_compile(val syntax) { val self = lit("ffi-type-compile"); @@ -3312,14 +3324,33 @@ val ffi_type_compile(val syntax) } } else { uses_or2; - val slots = mapcar(car_f, membs); - val stype = or2(if2(name, find_struct_type(sname)), - make_struct_type(sname, nil, nil, - remq(nil, slots, nil), - nil, nil, nil, nil)); - val xsyntax = cons(struct_s, - cons(sname, membs)); - return make_ffi_type_struct(xsyntax, stype, existing_type, self); + val iter; + list_collect_decl (slots, ptslots); + list_collect_decl (slot_inits, ptinits); + + for (iter = membs; iter; iter = cdr(iter)) { + val spec = car(iter); + val slot = car(spec); + val init = caddr(spec); + if (!slot && init) + uw_warningf(lit("~a: padding slot struct ~s specifies init-form"), + self, name, nao); + if (slot) + ptslots = list_collect(ptslots, slot); + if (slot && init) + ptinits = list_collect(ptinits, cons(slot, ffi_eval_expr(init, nil, nil))); + } + + { + val stype = or2(if2(name, find_struct_type(sname)), + make_struct_type(sname, nil, nil, + slots, nil, + if2(slot_inits, func_f1(slot_inits, ffi_struct_init)), + nil, nil)); + val xsyntax = cons(struct_s, + cons(sname, membs)); + return make_ffi_type_struct(xsyntax, stype, existing_type, self); + } } } else if (sym == union_s) { val name = cadr(syntax); @@ -64261,7 +64261,7 @@ through the enumeration is is attempted at run time. .coNP FFI type @ struct .synb -.mets (struct < name >> {( slot << type )}*) +.mets (struct < name >> {( slot << type <> [ init-form ])}*) .syne .desc The FFI @@ -64361,11 +64361,49 @@ to exist, if such a type doesn't already exist. If such a type is created, instance slots are defined for it which correspond to the member definitions in the FFI .code struct -definition. Those members whose +definition. + +For any +.meta slot +which specifies an +.meta init-form +expression, that expression is evaluated during the processing of the type syntax, +in the global environment. The resulting value then becomes the initial value for +the slot. The semantics of this value is similar to that of a quoted object +appearing as an +.meta init-form +in the +.code defstruct +macro's +.meta slot-specifier +syntax. For example, if the type expression +.codn "(struct s (a int expr))" , +which specifies a slot +.code a +initialized by +.codn expr , +generates a Lisp struct type, the manner in which that type is generated +will resemble that of +.code "(defstruct s nil (a (quote [value-of-expr])))" +where +.code [value-of-expr] +denotes the substitution of the value of +.code expr +which had been obtained by evaluation in the global environment. +Note: if more flexible initialization semantics is required, the application must +define the Lisp struct type first with the desired characteristics, before +processing the FFI struct type. The FFI struct type will then related to the +existing Lisp struct type. + +Those members whose .meta slot name is specified as .code nil is ignored; no instance slots are created in the Lisp type. +If a +.meta init-form +is specified for such a slot, there exists is no situation in which that +form will be evaluated. When a Lisp object is converted to a struct, it must, firstly, be of the struct type specified by |