diff --git a/include/chibi/features.h b/include/chibi/features.h
index a0101875..a1c6d1cb 100644
--- a/include/chibi/features.h
+++ b/include/chibi/features.h
@@ -310,6 +310,10 @@
 #define SEXP_USE_HEADER_MAGIC 0
 #endif
 
+#ifndef SEXP_USE_SAFE_ACCESSORS
+#define SEXP_USE_SAFE_ACCESSORS 0
+#endif
+
 #ifndef SEXP_USE_GLOBAL_HEAP
 #if SEXP_USE_BOEHM || SEXP_USE_MALLOC
 #define SEXP_USE_GLOBAL_HEAP 1
diff --git a/include/chibi/sexp.h b/include/chibi/sexp.h
index 50a484e1..bd7ecaa5 100644
--- a/include/chibi/sexp.h
+++ b/include/chibi/sexp.h
@@ -98,7 +98,6 @@ enum sexp_types {
   SEXP_VECTOR,
   SEXP_FLONUM,
   SEXP_BIGNUM,
-  SEXP_CPOINTER,
   SEXP_IPORT,
   SEXP_OPORT,
   SEXP_EXCEPTION,
@@ -117,6 +116,7 @@ enum sexp_types {
   SEXP_LIT,
   SEXP_STACK,
   SEXP_CONTEXT,
+  SEXP_CPOINTER,
   SEXP_NUM_CORE_TYPES
 };
 
@@ -608,39 +608,46 @@ SEXP_API sexp sexp_make_unsigned_integer(sexp ctx, sexp_luint_t x);
 
 /*************************** field accessors **************************/
 
-#define sexp_vector_length(x) ((x)->value.vector.length)
-#define sexp_vector_data(x)   ((x)->value.vector.data)
+#if SEXP_USE_SAFE_ACCESSORS
+#define sexp_field(x, type, id, field) (*(((x) && sexp_check_tag(x, id)) ? &((x)->value.type.field) : (fprintf(stderr, "invalid field access in %s line %d: %p (%d) isn't a "#type"\n", __FILE__, __LINE__, x, sexp_pointerp(x) ? sexp_pointer_tag(x) : -1), &(((sexp)NULL)->value.type.field))))
+#define sexp_cpointer_field(x, field) (*(((x) && sexp_pointerp(x) && sexp_pointer_tag(x) >= SEXP_CPOINTER) ? &((x)->value.cpointer.field) : (fprintf(stderr, "invalid field access in %s line %d: %p (%d) isn't a cpointer\n", __FILE__, __LINE__, x, sexp_pointerp(x) ? sexp_pointer_tag(x) : -1), &(((sexp)NULL)->value.cpointer.field))))
+#else
+#define sexp_field(x, type, id, field) ((x)->value.type.field)
+#define sexp_cpointer_field(x, field) ((x)->value.cpointer.field)
+#endif
+
+#define sexp_vector_length(x) (sexp_field(x, vector, SEXP_VECTOR, length))
+#define sexp_vector_data(x)   (sexp_field(x, vector, SEXP_VECTOR, data))
 
 #define sexp_vector_ref(x,i)   (sexp_vector_data(x)[sexp_unbox_fixnum(i)])
 #define sexp_vector_set(x,i,v) (sexp_vector_data(x)[sexp_unbox_fixnum(i)]=(v))
 
-#define sexp_procedure_num_args(x) ((x)->value.procedure.num_args)
-#define sexp_procedure_flags(x) ((x)->value.procedure.flags)
+#define sexp_procedure_num_args(x)   (sexp_field(x, procedure, SEXP_PROCEDURE, num_args))
+#define sexp_procedure_flags(x)      (sexp_field(x, procedure, SEXP_PROCEDURE, flags))
 #define sexp_procedure_variadic_p(x) (sexp_unbox_fixnum(sexp_procedure_flags(x)) & 1)
-#define sexp_procedure_code(x) ((x)->value.procedure.bc)
-#define sexp_procedure_vars(x) ((x)->value.procedure.vars)
+#define sexp_procedure_code(x)       (sexp_field(x, procedure, SEXP_PROCEDURE, bc))
+#define sexp_procedure_vars(x)       (sexp_field(x, procedure, SEXP_PROCEDURE, vars))
 
-#define sexp_bytes_length(x) ((x)->value.bytes.length)
-#define sexp_bytes_data(x)   ((x)->value.bytes.data)
+#define sexp_bytes_length(x)  (sexp_field(x, bytes, SEXP_BYTES, length))
+#define sexp_bytes_data(x)    (sexp_field(x, bytes, SEXP_BYTES, data))
 
-#define sexp_string_length(x) ((x)->value.string.length)
+#define sexp_string_length(x) (sexp_field(x, string, SEXP_STRING, length))
 #if SEXP_USE_PACKED_STRINGS
-#define sexp_string_data(x)   ((x)->value.string.data)
+#define sexp_string_data(x)   (sexp_field(x, string, SEXP_STRING, data))
 #else
-#define sexp_string_bytes(x)  ((x)->value.string.bytes)
-#define sexp_string_offset(x) ((x)->value.string.offset)
+#define sexp_string_bytes(x)  (sexp_field(x, string, SEXP_STRING, bytes))
+#define sexp_string_offset(x) (sexp_field(x, string, SEXP_STRING, offset))
 #define sexp_string_data(x)   (sexp_bytes_data(sexp_string_bytes(x))+sexp_string_offset(x))
 #endif
 
-#define sexp_bytes_ref(x, i) (sexp_make_fixnum((unsigned char)sexp_bytes_data(x)[sexp_unbox_fixnum(i)]))
+#define sexp_bytes_ref(x, i)    (sexp_make_fixnum((unsigned char)sexp_bytes_data(x)[sexp_unbox_fixnum(i)]))
 #define sexp_bytes_set(x, i, v) (sexp_bytes_data(x)[sexp_unbox_fixnum(i)] = sexp_unbox_fixnum(v))
 
-#define sexp_string_ref(x, i) (sexp_make_character((unsigned char)sexp_string_data(x)[sexp_unbox_fixnum(i)]))
+#define sexp_string_ref(x, i)    (sexp_make_character((unsigned char)sexp_string_data(x)[sexp_unbox_fixnum(i)]))
 #define sexp_string_set(x, i, v) (sexp_string_data(x)[sexp_unbox_fixnum(i)] = sexp_unbox_character(v))
 
-#define sexp_symbol_data(x)    ((x)->value.symbol.data)
-#define sexp_symbol_length(x)  ((x)->value.symbol.length)
-#define sexp_symbol_string(x)  (x)
+#define sexp_symbol_data(x)    (sexp_field(x, symbol, SEXP_SYMBOL, data))
+#define sexp_symbol_length(x)  (sexp_field(x, symbol, SEXP_SYMBOL, length))
 
 #define sexp_port_stream(p)    ((p)->value.port.stream)
 #define sexp_port_name(p)      ((p)->value.port.name)
@@ -653,120 +660,120 @@ SEXP_API sexp sexp_make_unsigned_integer(sexp ctx, sexp_luint_t x);
 #define sexp_port_size(p)      ((p)->value.port.size)
 #define sexp_port_offset(p)    ((p)->value.port.offset)
 
-#define sexp_exception_kind(p)      ((p)->value.exception.kind)
-#define sexp_exception_message(p)   ((p)->value.exception.message)
-#define sexp_exception_irritants(p) ((p)->value.exception.irritants)
-#define sexp_exception_procedure(p) ((p)->value.exception.procedure)
-#define sexp_exception_source(p)    ((p)->value.exception.source)
+#define sexp_exception_kind(x)      (sexp_field(x, exception, SEXP_EXCEPTION, kind))
+#define sexp_exception_message(x)   (sexp_field(x, exception, SEXP_EXCEPTION, message))
+#define sexp_exception_irritants(x) (sexp_field(x, exception, SEXP_EXCEPTION, irritants))
+#define sexp_exception_procedure(x) (sexp_field(x, exception, SEXP_EXCEPTION, procedure))
+#define sexp_exception_source(x)    (sexp_field(x, exception, SEXP_EXCEPTION, source))
 
-#define sexp_cpointer_freep(p)      (sexp_freep(p))
-#define sexp_cpointer_length(p)     ((p)->value.cpointer.length)
-#define sexp_cpointer_body(p)       ((p)->value.cpointer.body)
-#define sexp_cpointer_parent(p)     ((p)->value.cpointer.parent)
-#define sexp_cpointer_value(p)      ((p)->value.cpointer.value)
-#define sexp_cpointer_maybe_null_value(p) (sexp_not(p) ? NULL : sexp_cpointer_value(p))
+#define sexp_cpointer_freep(x)      (sexp_freep(x))
+#define sexp_cpointer_length(x)     (sexp_cpointer_field(x, length))
+#define sexp_cpointer_body(x)       (sexp_cpointer_field(x, body))
+#define sexp_cpointer_parent(x)     (sexp_cpointer_field(x, parent))
+#define sexp_cpointer_value(x)      (sexp_cpointer_field(x, value))
+#define sexp_cpointer_maybe_null_value(x) (sexp_not(x) ? NULL : sexp_cpointer_value(x))
 
-#define sexp_bytecode_length(x)   ((x)->value.bytecode.length)
-#define sexp_bytecode_name(x)     ((x)->value.bytecode.name)
-#define sexp_bytecode_literals(x) ((x)->value.bytecode.literals)
-#define sexp_bytecode_source(x)   ((x)->value.bytecode.source)
-#define sexp_bytecode_data(x)     ((x)->value.bytecode.data)
+#define sexp_bytecode_length(x)   (sexp_field(x, bytecode, SEXP_BYTECODE, length))
+#define sexp_bytecode_name(x)     (sexp_field(x, bytecode, SEXP_BYTECODE, name))
+#define sexp_bytecode_literals(x) (sexp_field(x, bytecode, SEXP_BYTECODE, literals))
+#define sexp_bytecode_source(x)   (sexp_field(x, bytecode, SEXP_BYTECODE, source))
+#define sexp_bytecode_data(x)     (sexp_field(x, bytecode, SEXP_BYTECODE, data))
 
 #define sexp_env_syntactic_p(x)   ((x)->syntacticp)
-#define sexp_env_parent(x)        ((x)->value.env.parent)
-#define sexp_env_bindings(x)      ((x)->value.env.bindings)
+#define sexp_env_parent(x)        (sexp_field(x, env, SEXP_ENV, parent))
+#define sexp_env_bindings(x)      (sexp_field(x, env, SEXP_ENV, bindings))
 #define sexp_env_local_p(x)       (sexp_env_parent(x))
 #define sexp_env_global_p(x)      (! sexp_env_local_p(x))
-#define sexp_env_lambda(x)        ((x)->value.env.lambda)
+#define sexp_env_lambda(x)        (sexp_field(x, env, SEXP_ENV, lambda))
 
-#define sexp_macro_proc(x)        ((x)->value.macro.proc)
-#define sexp_macro_env(x)         ((x)->value.macro.env)
+#define sexp_macro_proc(x)        (sexp_field(x, macro, SEXP_MACRO, proc))
+#define sexp_macro_env(x)         (sexp_field(x, macro, SEXP_MACRO, env))
 
-#define sexp_synclo_env(x)        ((x)->value.synclo.env)
-#define sexp_synclo_free_vars(x)  ((x)->value.synclo.free_vars)
-#define sexp_synclo_expr(x)       ((x)->value.synclo.expr)
+#define sexp_synclo_env(x)        (sexp_field(x, synclo, SEXP_SYNCLO, env))
+#define sexp_synclo_free_vars(x)  (sexp_field(x, synclo, SEXP_SYNCLO, free_vars))
+#define sexp_synclo_expr(x)       (sexp_field(x, synclo, SEXP_SYNCLO, expr))
 
-#define sexp_core_code(x)         ((x)->value.core.code)
-#define sexp_core_name(x)         ((x)->value.core.name)
+#define sexp_core_code(x)         (sexp_field(x, core, SEXP_CORE, code))
+#define sexp_core_name(x)         (sexp_field(x, core, SEXP_CORE, name))
 
-#define sexp_opcode_class(x)      ((x)->value.opcode.op_class)
-#define sexp_opcode_code(x)       ((x)->value.opcode.code)
-#define sexp_opcode_num_args(x)   ((x)->value.opcode.num_args)
-#define sexp_opcode_flags(x)      ((x)->value.opcode.flags)
-#define sexp_opcode_inverse(x)    ((x)->value.opcode.inverse)
-#define sexp_opcode_name(x)       ((x)->value.opcode.name)
-#define sexp_opcode_data(x)       ((x)->value.opcode.data)
-#define sexp_opcode_data2(x)      ((x)->value.opcode.data2)
-#define sexp_opcode_proc(x)       ((x)->value.opcode.proc)
-#define sexp_opcode_return_type(x) ((x)->value.opcode.ret_type)
-#define sexp_opcode_arg1_type(x)  ((x)->value.opcode.arg1_type)
-#define sexp_opcode_arg2_type(x)  ((x)->value.opcode.arg2_type)
-#define sexp_opcode_arg3_type(x)  ((x)->value.opcode.arg3_type)
-#define sexp_opcode_func(x)       ((x)->value.opcode.func)
+#define sexp_opcode_class(x)       (sexp_field(x, opcode, SEXP_OPCODE, op_class))
+#define sexp_opcode_code(x)        (sexp_field(x, opcode, SEXP_OPCODE, code))
+#define sexp_opcode_num_args(x)    (sexp_field(x, opcode, SEXP_OPCODE, num_args))
+#define sexp_opcode_flags(x)       (sexp_field(x, opcode, SEXP_OPCODE, flags))
+#define sexp_opcode_inverse(x)     (sexp_field(x, opcode, SEXP_OPCODE, inverse))
+#define sexp_opcode_name(x)        (sexp_field(x, opcode, SEXP_OPCODE, name))
+#define sexp_opcode_data(x)        (sexp_field(x, opcode, SEXP_OPCODE, data))
+#define sexp_opcode_data2(x)       (sexp_field(x, opcode, SEXP_OPCODE, data2))
+#define sexp_opcode_proc(x)        (sexp_field(x, opcode, SEXP_OPCODE, proc))
+#define sexp_opcode_return_type(x) (sexp_field(x, opcode, SEXP_OPCODE, ret_type))
+#define sexp_opcode_arg1_type(x)   (sexp_field(x, opcode, SEXP_OPCODE, arg1_type))
+#define sexp_opcode_arg2_type(x)   (sexp_field(x, opcode, SEXP_OPCODE, arg2_type))
+#define sexp_opcode_arg3_type(x)   (sexp_field(x, opcode, SEXP_OPCODE, arg3_type))
+#define sexp_opcode_func(x)        (sexp_field(x, opcode, SEXP_OPCODE, func))
 
 #define sexp_opcode_variadic_p(x)  (sexp_opcode_flags(x) & 1)
 #define sexp_opcode_opt_param_p(x) (sexp_opcode_flags(x) & 2)
 #define sexp_opcode_ref_trans_p(x) (sexp_opcode_flags(x) & 4)
 
-#define sexp_lambda_name(x)   ((x)->value.lambda.name)
-#define sexp_lambda_params(x) ((x)->value.lambda.params)
-#define sexp_lambda_locals(x) ((x)->value.lambda.locals)
-#define sexp_lambda_defs(x)   ((x)->value.lambda.defs)
-#define sexp_lambda_flags(x)  ((x)->value.lambda.flags)
-#define sexp_lambda_body(x)   ((x)->value.lambda.body)
-#define sexp_lambda_fv(x)     ((x)->value.lambda.fv)
-#define sexp_lambda_sv(x)     ((x)->value.lambda.sv)
-#define sexp_lambda_return_type(x) ((x)->value.lambda.ret)
-#define sexp_lambda_param_types(x) ((x)->value.lambda.types)
-#define sexp_lambda_source(x) ((x)->value.lambda.source)
+#define sexp_lambda_name(x)        (sexp_field(x, lambda, SEXP_LAMBDA, name))
+#define sexp_lambda_params(x)      (sexp_field(x, lambda, SEXP_LAMBDA, params))
+#define sexp_lambda_locals(x)      (sexp_field(x, lambda, SEXP_LAMBDA, locals))
+#define sexp_lambda_defs(x)        (sexp_field(x, lambda, SEXP_LAMBDA, defs))
+#define sexp_lambda_flags(x)       (sexp_field(x, lambda, SEXP_LAMBDA, flags))
+#define sexp_lambda_body(x)        (sexp_field(x, lambda, SEXP_LAMBDA, body))
+#define sexp_lambda_fv(x)          (sexp_field(x, lambda, SEXP_LAMBDA, fv))
+#define sexp_lambda_sv(x)          (sexp_field(x, lambda, SEXP_LAMBDA, sv))
+#define sexp_lambda_return_type(x) (sexp_field(x, lambda, SEXP_LAMBDA, ret))
+#define sexp_lambda_param_types(x) (sexp_field(x, lambda, SEXP_LAMBDA, types))
+#define sexp_lambda_source(x)      (sexp_field(x, lambda, SEXP_LAMBDA, source))
 
-#define sexp_cnd_test(x)      ((x)->value.cnd.test)
-#define sexp_cnd_pass(x)      ((x)->value.cnd.pass)
-#define sexp_cnd_fail(x)      ((x)->value.cnd.fail)
-#define sexp_cnd_source(x)    ((x)->value.cnd.source)
+#define sexp_cnd_test(x)      (sexp_field(x, cnd, SEXP_CND, test))
+#define sexp_cnd_pass(x)      (sexp_field(x, cnd, SEXP_CND, pass))
+#define sexp_cnd_fail(x)      (sexp_field(x, cnd, SEXP_CND, fail))
+#define sexp_cnd_source(x)    (sexp_field(x, cnd, SEXP_CND, source))
 
-#define sexp_set_var(x)       ((x)->value.set.var)
-#define sexp_set_value(x)     ((x)->value.set.value)
-#define sexp_set_source(x)    ((x)->value.set.source)
+#define sexp_set_var(x)       (sexp_field(x, set, SEXP_SET, var))
+#define sexp_set_value(x)     (sexp_field(x, set, SEXP_SET, value))
+#define sexp_set_source(x)    (sexp_field(x, set, SEXP_SET, source))
 
-#define sexp_ref_name(x)      ((x)->value.ref.name)
+#define sexp_ref_name(x)      (sexp_field(x, ref, SEXP_REF, name))
 #define sexp_ref_cell(x)      ((x)->value.ref.cell)
 #define sexp_ref_loc(x)       (sexp_cdr(sexp_ref_cell(x)))
-#define sexp_ref_source(x)    ((x)->value.ref.source)
+#define sexp_ref_source(x)    (sexp_field(x, ref, SEXP_REF, source))
 
-#define sexp_seq_ls(x)        ((x)->value.seq.ls)
-#define sexp_seq_source(x)    ((x)->value.seq.source)
+#define sexp_seq_ls(x)        (sexp_field(x, seq, SEXP_SEQ, ls))
+#define sexp_seq_source(x)    (sexp_field(x, seq, SEXP_SEQ, source))
 
-#define sexp_lit_value(x)     ((x)->value.lit.value)
-#define sexp_lit_source(x)    ((x)->value.lit.source)
+#define sexp_lit_value(x)     (sexp_field(x, lit, SEXP_LIT, value))
+#define sexp_lit_source(x)    (sexp_field(x, lit, SEXP_LIT, source))
 
-#define sexp_stack_length(x)  ((x)->value.stack.length)
-#define sexp_stack_top(x)     ((x)->value.stack.top)
-#define sexp_stack_data(x)    ((x)->value.stack.data)
+#define sexp_stack_length(x)  (sexp_field(x, stack, SEXP_STACK, length))
+#define sexp_stack_top(x)     (sexp_field(x, stack, SEXP_STACK, top))
+#define sexp_stack_data(x)    (sexp_field(x, stack, SEXP_STACK, data))
 
-#define sexp_context_env(x)     ((x)->value.context.env)
-#define sexp_context_stack(x)   ((x)->value.context.stack)
-#define sexp_context_depth(x)   ((x)->value.context.depth)
-#define sexp_context_bc(x)      ((x)->value.context.bc)
-#define sexp_context_fv(x)      ((x)->value.context.fv)
-#define sexp_context_pos(x)     ((x)->value.context.pos)
-#define sexp_context_lambda(x)  ((x)->value.context.lambda)
-#define sexp_context_parent(x)  ((x)->value.context.parent)
-#define sexp_context_child(x)   ((x)->value.context.child)
-#define sexp_context_saves(x)   ((x)->value.context.saves)
-#define sexp_context_tailp(x)   ((x)->value.context.tailp)
-#define sexp_context_tracep(x)  ((x)->value.context.tracep)
-#define sexp_context_globals(x) ((x)->value.context.globals)
-#define sexp_context_last_fp(x) ((x)->value.context.last_fp)
-#define sexp_context_refuel(x)  ((x)->value.context.refuel)
-#define sexp_context_ip(x)      ((x)->value.context.ip)
-#define sexp_context_proc(x)    ((x)->value.context.proc)
-#define sexp_context_timeval(x) ((x)->value.context.tval)
-#define sexp_context_name(x)    ((x)->value.context.name)
-#define sexp_context_specific(x) ((x)->value.context.specific)
-#define sexp_context_event(x)    ((x)->value.context.event)
-#define sexp_context_timeoutp(x) ((x)->value.context.timeoutp)
-#define sexp_context_waitp(x)    ((x)->value.context.waitp)
+#define sexp_context_env(x)      (sexp_field(x, context, SEXP_CONTEXT, env))
+#define sexp_context_stack(x)    (sexp_field(x, context, SEXP_CONTEXT, stack))
+#define sexp_context_depth(x)    (sexp_field(x, context, SEXP_CONTEXT, depth))
+#define sexp_context_bc(x)       (sexp_field(x, context, SEXP_CONTEXT, bc))
+#define sexp_context_fv(x)       (sexp_field(x, context, SEXP_CONTEXT, fv))
+#define sexp_context_pos(x)      (sexp_field(x, context, SEXP_CONTEXT, pos))
+#define sexp_context_lambda(x)   (sexp_field(x, context, SEXP_CONTEXT, lambda))
+#define sexp_context_parent(x)   (sexp_field(x, context, SEXP_CONTEXT, parent))
+#define sexp_context_child(x)    (sexp_field(x, context, SEXP_CONTEXT, child))
+#define sexp_context_saves(x)    (sexp_field(x, context, SEXP_CONTEXT, saves))
+#define sexp_context_tailp(x)    (sexp_field(x, context, SEXP_CONTEXT, tailp))
+#define sexp_context_tracep(x)   (sexp_field(x, context, SEXP_CONTEXT, tracep))
+#define sexp_context_globals(x)  (sexp_field(x, context, SEXP_CONTEXT, globals))
+#define sexp_context_last_fp(x)  (sexp_field(x, context, SEXP_CONTEXT, last_fp))
+#define sexp_context_refuel(x)   (sexp_field(x, context, SEXP_CONTEXT, refuel))
+#define sexp_context_ip(x)       (sexp_field(x, context, SEXP_CONTEXT, ip))
+#define sexp_context_proc(x)     (sexp_field(x, context, SEXP_CONTEXT, proc))
+#define sexp_context_timeval(x)  (sexp_field(x, context, SEXP_CONTEXT, tval))
+#define sexp_context_name(x)     (sexp_field(x, context, SEXP_CONTEXT, name))
+#define sexp_context_specific(x) (sexp_field(x, context, SEXP_CONTEXT, specific))
+#define sexp_context_event(x)    (sexp_field(x, context, SEXP_CONTEXT, event))
+#define sexp_context_timeoutp(x) (sexp_field(x, context, SEXP_CONTEXT, timeoutp))
+#define sexp_context_waitp(x)    (sexp_field(x, context, SEXP_CONTEXT, waitp))
 
 #if SEXP_USE_ALIGNED_BYTECODE
 #define sexp_context_align_pos(ctx) sexp_context_pos(ctx) = sexp_word_align(sexp_context_pos(ctx))
@@ -829,29 +836,29 @@ SEXP_API struct sexp_struct *sexp_type_specs;
 
 #define sexp_context_top(x)     (sexp_stack_top(sexp_context_stack(x)))
 
-#define sexp_type_tag(x)               ((x)->value.type.tag)
-#define sexp_type_field_base(x)        ((x)->value.type.field_base)
-#define sexp_type_field_eq_len_base(x) ((x)->value.type.field_eq_len_base)
-#define sexp_type_field_len_base(x)    ((x)->value.type.field_len_base)
-#define sexp_type_field_len_off(x)     ((x)->value.type.field_len_off)
-#define sexp_type_field_len_scale(x)   ((x)->value.type.field_len_scale)
-#define sexp_type_size_base(x)         ((x)->value.type.size_base)
-#define sexp_type_size_off(x)          ((x)->value.type.size_off)
-#define sexp_type_size_scale(x)        ((x)->value.type.size_scale)
-#define sexp_type_weak_base(x)         ((x)->value.type.weak_base)
-#define sexp_type_weak_len_base(x)     ((x)->value.type.weak_len_base)
-#define sexp_type_weak_len_off(x)      ((x)->value.type.weak_len_off)
-#define sexp_type_weak_len_scale(x)    ((x)->value.type.weak_len_scale)
-#define sexp_type_weak_len_extra(x)    ((x)->value.type.weak_len_extra)
-#define sexp_type_depth(x)             ((x)->value.type.depth)
-#define sexp_type_name(x)              ((x)->value.type.name)
-#define sexp_type_cpl(x)               ((x)->value.type.cpl)
-#define sexp_type_slots(x)             ((x)->value.type.slots)
-#define sexp_type_finalize(x)          ((x)->value.type.finalize)
+#define sexp_type_tag(x)               (sexp_field(x, type, SEXP_TYPE, tag))
+#define sexp_type_field_base(x)        (sexp_field(x, type, SEXP_TYPE, field_base))
+#define sexp_type_field_eq_len_base(x) (sexp_field(x, type, SEXP_TYPE, field_eq_len_base))
+#define sexp_type_field_len_base(x)    (sexp_field(x, type, SEXP_TYPE, field_len_base))
+#define sexp_type_field_len_off(x)     (sexp_field(x, type, SEXP_TYPE, field_len_off))
+#define sexp_type_field_len_scale(x)   (sexp_field(x, type, SEXP_TYPE, field_len_scale))
+#define sexp_type_size_base(x)         (sexp_field(x, type, SEXP_TYPE, size_base))
+#define sexp_type_size_off(x)          (sexp_field(x, type, SEXP_TYPE, size_off))
+#define sexp_type_size_scale(x)        (sexp_field(x, type, SEXP_TYPE, size_scale))
+#define sexp_type_weak_base(x)         (sexp_field(x, type, SEXP_TYPE, weak_base))
+#define sexp_type_weak_len_base(x)     (sexp_field(x, type, SEXP_TYPE, weak_len_base))
+#define sexp_type_weak_len_off(x)      (sexp_field(x, type, SEXP_TYPE, weak_len_off))
+#define sexp_type_weak_len_scale(x)    (sexp_field(x, type, SEXP_TYPE, weak_len_scale))
+#define sexp_type_weak_len_extra(x)    (sexp_field(x, type, SEXP_TYPE, weak_len_extra))
+#define sexp_type_depth(x)             (sexp_field(x, type, SEXP_TYPE, depth))
+#define sexp_type_name(x)              (sexp_field(x, type, SEXP_TYPE, name))
+#define sexp_type_cpl(x)               (sexp_field(x, type, SEXP_TYPE, cpl))
+#define sexp_type_slots(x)             (sexp_field(x, type, SEXP_TYPE, slots))
+#define sexp_type_finalize(x)          (sexp_field(x, type, SEXP_TYPE, finalize))
 
-#define sexp_bignum_sign(x)            ((x)->value.bignum.sign)
-#define sexp_bignum_length(x)          ((x)->value.bignum.length)
-#define sexp_bignum_data(x)            ((x)->value.bignum.data)
+#define sexp_bignum_sign(x)            (sexp_field(x, bignum, SEXP_BIGNUM, sign))
+#define sexp_bignum_length(x)          (sexp_field(x, bignum, SEXP_BIGNUM, length))
+#define sexp_bignum_data(x)            (sexp_field(x, bignum, SEXP_BIGNUM, data))
 
 /****************************** arithmetic ****************************/
 
@@ -920,10 +927,10 @@ enum sexp_context_globals {
 #define sexp_push(ctx, ls, x)    ((ls) = sexp_cons((ctx), (x), (ls)))
 #define sexp_insert(ctx, ls, x)  ((sexp_memq(ctx, (x), (ls)) != SEXP_FALSE) ? (ls) : sexp_push((ctx), (ls), (x)))
 
-#define sexp_pair_source(x) ((x)->value.pair.source)
+#define sexp_pair_source(x) (sexp_field(x, pair, SEXP_PAIR, source))
 
-#define sexp_car(x)       ((x)->value.pair.car)
-#define sexp_cdr(x)       ((x)->value.pair.cdr)
+#define sexp_car(x)         (sexp_field(x, pair, SEXP_PAIR, car))
+#define sexp_cdr(x)         (sexp_field(x, pair, SEXP_PAIR, cdr))
 
 #define sexp_caar(x)      (sexp_car(sexp_car(x)))
 #define sexp_cadr(x)      (sexp_car(sexp_cdr(x)))
diff --git a/sexp.c b/sexp.c
index 01a20a5f..6b9a8403 100644
--- a/sexp.c
+++ b/sexp.c
@@ -94,7 +94,6 @@ static struct sexp_type_struct _sexp_type_specs[] = {
   {SEXP_VECTOR, sexp_offsetof(vector, data), 0, 0, sexp_offsetof(vector, length), 1, sexp_sizeof(vector), sexp_offsetof(vector, length), sizeof(sexp), 0, 0, 0, 0, 0, 0, "vector", SEXP_FALSE, SEXP_FALSE, NULL},
   {SEXP_FLONUM, 0, 0, 0, 0, 0, sexp_sizeof(flonum), 0, 0, 0, 0, 0, 0, 0, 0, "real", SEXP_FALSE, SEXP_FALSE, NULL},
   {SEXP_BIGNUM, 0, 0, 0, 0, 0, sexp_sizeof(bignum), sexp_offsetof(bignum, length), sizeof(sexp_uint_t), 0, 0, 0, 0, 0, 0, "bignum", SEXP_FALSE, SEXP_FALSE, NULL},
-  {SEXP_CPOINTER, sexp_offsetof(cpointer, parent), 1, 0, 0, 0, sexp_sizeof(cpointer), sexp_offsetof(cpointer, length), 1, 0, 0, 0, 0, 0, 0, "cpointer", SEXP_FALSE, SEXP_FALSE, NULL},
   {SEXP_IPORT, sexp_offsetof(port, name), 2, 2, 0, 0, sexp_sizeof(port), 0, 0, 0, 0, 0, 0, 0, 0, "input-port", SEXP_FALSE, SEXP_FALSE, SEXP_FINALIZE_PORT},
   {SEXP_OPORT, sexp_offsetof(port, name), 2, 2, 0, 0, sexp_sizeof(port), 0, 0, 0, 0, 0, 0, 0, 0, "output-port", SEXP_FALSE, SEXP_FALSE, SEXP_FINALIZE_PORT},
   {SEXP_EXCEPTION, sexp_offsetof(exception, kind), 6, 6, 0, 0, sexp_sizeof(exception), 0, 0, 0, 0, 0, 0, 0, 0, "exception", SEXP_FALSE, SEXP_FALSE, NULL},
@@ -113,6 +112,7 @@ static struct sexp_type_struct _sexp_type_specs[] = {
   {SEXP_LIT, sexp_offsetof(lit, value), 2, 2, 0, 0, sexp_sizeof(lit), 0, 0, 0, 0, 0, 0, 0, 0, "literal", SEXP_FALSE, SEXP_FALSE, NULL},
   {SEXP_STACK, sexp_offsetof(stack, data), 1, 1, sexp_offsetof(stack, top), 1, sexp_sizeof(stack), offsetof(struct sexp_struct, value.stack.length), sizeof(sexp), 0, 0, 0, 0, 0, 0, "stack", SEXP_FALSE, SEXP_FALSE, NULL},
   {SEXP_CONTEXT, sexp_offsetof(context, bc), 12, 12, 0, 0, sexp_sizeof(context), 0, 0, 0, 0, 0, 0, 0, 0, "context", SEXP_FALSE, SEXP_FALSE, NULL},
+  {SEXP_CPOINTER, sexp_offsetof(cpointer, parent), 1, 0, 0, 0, sexp_sizeof(cpointer), sexp_offsetof(cpointer, length), 1, 0, 0, 0, 0, 0, 0, "cpointer", SEXP_FALSE, SEXP_FALSE, NULL},
 };
 
 #if SEXP_USE_GLOBAL_TYPES