libfst 0.1.0

data/ext/libfst_rb.c

@@ -0,0 +1,2525 @@
+/* Copyright (C) 2024 Théotime Bollengier <theotime.bollengier@ensta-bretagne.fr>
+ *
+ * This file is part of libfst.rb <https://gitlab.ensta-bretagne.fr/bollenth/libfst.rb>
+ *
+ * libfst.rb is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published
+ * by the Free Software Foundation, either version 3 of the License,
+ * or (at your option) any later version.
+ *
+ * libfst.rb is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with libfst.rb. If not, see <https://www.gnu.org/licenses/>. 
+ */
+
+#include <ruby.h>
+#include "fstapi.h"
+#include "ruby/internal/arithmetic/size_t.h"
+
+
+VALUE m_LibFST;
+VALUE c_Reader;
+VALUE c_RScope;
+VALUE c_RVariable;
+VALUE c_RAttribute;
+VALUE c_RTrace;
+VALUE c_Writer;
+VALUE c_WVariable;
+
+
+ID id_at_alias_of;
+ID id_at_direction;
+ID id_at_filename;
+ID id_at_handle;
+ID id_at_is_float;
+ID id_at_length;
+ID id_at_name;
+ID id_at_sup_data_type;
+ID id_at_sup_type_str;
+ID id_at_sup_var_type;
+ID id_at_trace;
+ID id_at_traces;
+ID id_at_type;
+ID id_at_value;
+ID id_at_variables;
+ID id_at_writer;
+ID id_to_s;
+ID id_to_f;
+ID id_to_i;
+ID id_rjust;
+ID id_compress_hier;
+ID id_delete;
+ID id_name;
+ID id_component;
+ID id_symbol_plus;
+ID id_symbol_star;
+ID id_symbol_more;
+ID id_expand_path;
+ID id_start_time;
+ID id_end_time;
+ID id_verilog;
+ID id_vhdl;
+ID id_verilog_or_vhdl;
+ID id_vcd_module;
+ID id_vcd_task;
+ID id_vcd_function;
+ID id_vcd_begin;
+ID id_vcd_fork;
+ID id_vcd_generate;
+ID id_vcd_struct;
+ID id_vcd_union;
+ID id_vcd_class;
+ID id_vcd_interface;
+ID id_vcd_package;
+ID id_vcd_program;
+ID id_vhdl_architecture;
+ID id_vhdl_procedure;
+ID id_vhdl_function;
+ID id_vhdl_record;
+ID id_vhdl_process;
+ID id_vhdl_block;
+ID id_vhdl_for_generate;
+ID id_vhdl_if_generate;
+ID id_vhdl_generate;
+ID id_vhdl_package;
+ID id_vcd_event;
+ID id_vcd_integer;
+ID id_vcd_parameter;
+ID id_vcd_real;
+ID id_vcd_real_parameter;
+ID id_vcd_reg;
+ID id_vcd_supply0;
+ID id_vcd_supply1;
+ID id_vcd_time;
+ID id_vcd_tri;
+ID id_vcd_triand;
+ID id_vcd_trior;
+ID id_vcd_trireg;
+ID id_vcd_tri0;
+ID id_vcd_tri1;
+ID id_vcd_wand;
+ID id_vcd_wire;
+ID id_vcd_wor;
+ID id_vcd_port;
+ID id_vcd_sparray;
+ID id_vcd_realtime;
+ID id_gen_string;
+ID id_sv_bit;
+ID id_sv_logic;
+ID id_sv_int;
+ID id_sv_shortint;
+ID id_sv_longint;
+ID id_sv_byte;
+ID id_sv_enum;
+ID id_sv_shortreal;
+ID id_implicit;
+ID id_input;
+ID id_output;
+ID id_inout;
+ID id_buffer;
+ID id_linkage;
+ID id_misc;
+ID id_array;
+ID id_enum;
+ID id_pack;
+ID id_comment;
+ID id_envvar;
+ID id_supvar;
+ID id_pathname;
+ID id_sourcestem;
+ID id_sourceistem;
+ID id_valuelist;
+ID id_enumtable;
+ID id_unknown;
+ID id_none;
+ID id_unpacked;
+ID id_packed;
+ID id_sparse;
+ID id_integer;
+ID id_bit;
+ID id_logic;
+ID id_int;
+ID id_shortint;
+ID id_longint;
+ID id_byte;
+ID id_unsigned_integer;
+ID id_unsigned_bit;
+ID id_unsigned_logic;
+ID id_unsigned_int;
+ID id_unsigned_shortint;
+ID id_unsigned_longint;
+ID id_unsigned_byte;
+ID id_reg;
+ID id_time;
+ID id_tagged_packed;
+ID id_upscope;
+ID id_attrend;
+ID id_zlib;
+ID id_fastlz;
+ID id_lz4;
+ID id_s;
+ID id_ms;
+ID id_us;
+ID id_ns;
+ID id_ps;
+ID id_fs;
+ID id_type;
+ID id_subtype;
+ID id_arg;
+ID id_use_realpath;
+ID id_vhdl_signal;
+ID id_vhdl_variable;
+ID id_vhdl_constant;
+ID id_vhdl_file;
+ID id_vhdl_memory;
+ID id_vhdl_boolean;
+ID id_vhdl_bit;
+ID id_vhdl_bit_vector;
+ID id_vhdl_std_ulogic;
+ID id_vhdl_std_ulogic_vector;
+ID id_vhdl_std_logic;
+ID id_vhdl_std_logic_vector;
+ID id_vhdl_unsigned;
+ID id_vhdl_signed;
+ID id_vhdl_integer;
+ID id_vhdl_real;
+ID id_vhdl_natural;
+ID id_vhdl_positive;
+ID id_vhdl_time;
+ID id_vhdl_character;
+ID id_vhdl_string;
+ID id_direction;
+ID id_length;
+ID id_alias_of;
+ID id_sup_type_str;
+ID id_sup_var_type;
+ID id_sup_data_type;
+
+
+static uint64_t rb_to_uint64t(VALUE num)
+{
+	uint64_t r = (uint64_t)NUM2ULL(num);
+	VALUE zero = INT2NUM(0);
+	if (rb_funcallv(zero, id_symbol_more, 1, &num) == Qtrue)
+		rb_raise(rb_eRuntimeError, "number must be positive");
+	return r;
+}
+
+
+static int rb_to_boolean(VALUE enable)
+{
+	int r;
+	if (enable == Qtrue)
+		r = 1;
+	else if (enable == Qfalse)
+		r = 0;
+	else
+		rb_raise(rb_eTypeError, "expecting true or false, not a %s", rb_obj_classname(enable));
+	return r;
+}
+
+
+static unsigned int rb_to_unsigned_int(VALUE num)
+{
+	unsigned int r = (unsigned int)NUM2ULONG(num);
+	VALUE zero = INT2NUM(0);
+	if (rb_funcallv(zero, id_symbol_more, 1, &num) == Qtrue)
+		rb_raise(rb_eRuntimeError, "number must be positive");
+	return r;
+	
+}
+
+
+typedef struct {
+	void *ctx;
+} fstreaderctx_t;
+
+
+static void libfst_reader_free(void *p)
+{
+	fstreaderctx_t *rctx = (fstreaderctx_t*)p;
+
+	if (rctx) {
+		fstReaderClose(rctx->ctx);
+		free(rctx);
+	}
+}
+
+
+static size_t libfst_reader_size(const void *p)
+{
+	(void)p;
+	return sizeof(fstreaderctx_t);
+}
+
+
+const rb_data_type_t libfst_reader_type = {
+	.wrap_struct_name = "LibFST::Reader",
+	.function = {
+		.dmark = NULL,
+		.dfree = libfst_reader_free,
+		.dsize = libfst_reader_size,
+	},
+	.parent = NULL,
+	.data = NULL,
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+
+inline void* libfst_reader_from_rbobj(VALUE obj) {
+	fstreaderctx_t *rctx;
+	TypedData_Get_Struct(obj, fstreaderctx_t, &libfst_reader_type, rctx);
+	return rctx->ctx;
+}
+
+
+static VALUE libfst_reader_alloc(VALUE klass)
+{
+	fstreaderctx_t *rctx = malloc(sizeof(fstreaderctx_t));
+	rctx->ctx = NULL;
+	return TypedData_Wrap_Struct(klass, &libfst_reader_type, rctx);
+}
+
+
+/* @param filename [String] Path of the FST file to open.
+ * @return [self]
+ */
+static VALUE libfst_reader_open(VALUE self, VALUE filename)
+{
+	if (!rb_obj_is_kind_of(filename, rb_cString))
+		rb_raise(rb_eRuntimeError, "Expecting a String, not a %s", rb_obj_classname(filename));
+	const char *fname = rb_string_value_cstr(&filename);
+
+	fstreaderctx_t *rctx;
+	TypedData_Get_Struct(self, fstreaderctx_t, &libfst_reader_type, rctx);
+	rctx->ctx = fstReaderOpen(fname);
+
+	if (!rctx->ctx)
+		rb_raise(rb_eRuntimeError, "cannot read file \"%s\"", fname);
+
+	fstReaderIterBlocksSetNativeDoublesOnCallback(rctx->ctx, 1);
+
+	return self;
+}
+
+
+/* Returns the number of variables which point to the same trace.
+ * @return [Integer]
+ */
+static VALUE libfst_reader_alias_count(VALUE self)
+{
+	void *ctx = libfst_reader_from_rbobj(self);
+	uint64_t alias_count = fstReaderGetAliasCount(ctx);
+	return RB_ULL2NUM(alias_count);
+}
+
+
+/* @return [Integer]
+ */
+static VALUE libfst_reader_current_scope_length(VALUE self)
+{
+	return RB_INT2NUM(fstReaderGetCurrentScopeLen(libfst_reader_from_rbobj(self)));
+}
+
+
+/* @return [String]
+ */
+static VALUE libfst_reader_current_flat_scope(VALUE self)
+{
+	void *ctx = libfst_reader_from_rbobj(self);
+	const char* str = fstReaderGetCurrentFlatScope(ctx);
+	return rb_utf8_str_new_cstr(str);
+}
+
+
+/* Date string produced by the writer of the FST file
+ * @return [String]
+ */
+static VALUE libfst_reader_date_string(VALUE self)
+{
+	void *ctx = libfst_reader_from_rbobj(self);
+	const char* str = fstReaderGetDateString(ctx);
+	return rb_utf8_str_new_cstr(str);
+}
+
+
+/* Version string produced by the writer of the FST file
+ * @return [String]
+ */
+static VALUE libfst_reader_version_string(VALUE self)
+{
+	void *ctx = libfst_reader_from_rbobj(self);
+	const char* str = fstReaderGetVersionString(ctx);
+	return rb_utf8_str_new_cstr(str);
+}
+
+
+/* Returns the number of variables.
+ * @return [Integer]
+ */
+static VALUE libfst_reader_var_count(VALUE self)
+{
+	void *ctx = libfst_reader_from_rbobj(self);
+	uint64_t i = fstReaderGetVarCount(ctx);
+	return RB_ULL2NUM(i);
+}
+
+
+/* @return [Integer]
+ */
+static VALUE libfst_reader_start_time(VALUE self)
+{
+	void *ctx = libfst_reader_from_rbobj(self);
+	uint64_t i = fstReaderGetStartTime(ctx);
+	return RB_ULL2NUM(i);
+}
+
+
+/* @return [Integer]
+ */
+static VALUE libfst_reader_end_time(VALUE self)
+{
+	void *ctx = libfst_reader_from_rbobj(self);
+	uint64_t i = fstReaderGetEndTime(ctx);
+	return RB_ULL2NUM(i);
+}
+
+
+/* @return [Integer]
+ */
+static VALUE libfst_reader_time_zero(VALUE self)
+{
+	void *ctx = libfst_reader_from_rbobj(self);
+	uint64_t i = fstReaderGetTimezero(ctx);
+	return RB_ULL2NUM(i);
+}
+
+
+/* @return [Symbol] Either `:verilog`, `:vhdl` or `:verilog_or_vhdl`.
+ */
+static VALUE libfst_reader_file_type(VALUE self)
+{
+	void *ctx = libfst_reader_from_rbobj(self);
+	int ft = fstReaderGetFileType(ctx);
+	ID id;
+	switch (ft) {
+		case FST_FT_VERILOG:
+			id = id_verilog;
+			break;
+		case FST_FT_VHDL:
+			id = id_vhdl;
+			break;
+		case FST_FT_VERILOG_VHDL:
+			id = id_verilog_or_vhdl;
+			break;
+		default:
+			rb_raise(rb_eRuntimeError, "Unknown file type %d", ft);
+	}
+	return rb_id2sym(id);
+}
+
+
+/* @return [Integer]
+ */
+static VALUE libfst_reader_memory_used_by_writer(VALUE self)
+{
+	void *ctx = libfst_reader_from_rbobj(self);
+	uint64_t i = fstReaderGetMemoryUsedByWriter(ctx);
+	return RB_ULL2NUM(i);
+}
+
+
+/* @return [Integer]
+ */
+static VALUE libfst_reader_scope_count(VALUE self)
+{
+	void *ctx = libfst_reader_from_rbobj(self);
+	uint64_t i = fstReaderGetScopeCount(ctx);
+	return RB_ULL2NUM(i);
+}
+
+
+/* @return [Integer]
+ */
+static VALUE libfst_reader_value_change_section_count(VALUE self)
+{
+	void *ctx = libfst_reader_from_rbobj(self);
+	uint64_t i = fstReaderGetValueChangeSectionCount(ctx);
+	return RB_ULL2NUM(i);
+}
+
+
+/* @return [Integer]
+ */
+static VALUE libfst_reader_number_dump_activity_changes(VALUE self)
+{
+	void *ctx = libfst_reader_from_rbobj(self);
+	uint32_t i = fstReaderGetNumberDumpActivityChanges(ctx);
+	return RB_ULL2NUM(i);
+}
+
+
+/* @return [Boolean]
+ */
+static VALUE libfst_reader_fseek_failed(VALUE self)
+{
+	void *ctx = libfst_reader_from_rbobj(self);
+	return (fstReaderGetFseekFailed(ctx) ? Qtrue : Qfalse);
+}
+
+
+/* @return [Boolean]
+ */
+static VALUE libfst_reader_double_endian_match_state(VALUE self)
+{
+	void *ctx = libfst_reader_from_rbobj(self);
+	return (fstReaderGetDoubleEndianMatchState(ctx) ? Qtrue : Qfalse);
+}
+
+
+/* Returns the time scale exponent.
+ *
+ * Real time is `integer_time * 10^time_scale_exponent`.
+ * @return [Integer]
+ */
+static VALUE libfst_reader_time_scale_exponent(VALUE self)
+{
+	return INT2NUM((int)fstReaderGetTimescale(libfst_reader_from_rbobj(self)));
+}
+
+
+/* @return [Float]
+ */
+static VALUE libfst_reader_time_scale(VALUE self)
+{
+	void *ctx = libfst_reader_from_rbobj(self);
+	signed char s = fstReaderGetTimescale(ctx);
+	double d = 1.0;
+	switch (s) {
+		case   2: d = 100.0;   break;
+		case   1: d =  10.0;   break;
+		case   0: d =   1.0;   break;
+		case  -1: d = 100e-3;  break;
+		case  -2: d =  10e-3;  break;
+		case  -3: d =   1e-3;  break;
+		case  -4: d = 100e-6;  break;
+		case  -5: d =  10e-6;  break;
+		case  -6: d =   1e-6;  break;
+		case  -7: d = 100e-9;  break;
+		case  -8: d =  10e-9;  break;
+		case  -9: d =   1e-9;  break;
+		case -10: d = 100e-12; break;
+		case -11: d =  10e-12; break;
+		case -12: d =   1e-12; break;
+		case -13: d = 100e-15; break;
+		case -14: d =  10e-15; break;
+		case -15: d =   1e-15; break;
+		default:
+			d = pow(10.0, (double)s);
+	}
+	return DBL2NUM(d);
+}
+
+
+/* @return [String, nil]
+ */
+static VALUE libfst_reader_pop_scope(VALUE self)
+{
+	void *ctx = libfst_reader_from_rbobj(self);
+	const char* str = fstReaderPopScope(ctx);
+	if (!str) return Qnil;
+	return rb_utf8_str_new_cstr(str);
+}
+
+
+/* @return [self]
+ */
+static VALUE libfst_reader_reset_scope(VALUE self)
+{
+	void *ctx = libfst_reader_from_rbobj(self);
+	fstReaderResetScope(ctx);
+	return self;
+}
+
+
+/* @return [String, nil]
+ * @overload push_scope(name=nil)
+ *  @param name [String,nil]
+ */
+static VALUE libfst_reader_push_scope(int argc, VALUE *argv, VALUE self)
+{
+	void *ctx = libfst_reader_from_rbobj(self);
+	VALUE name_rb = Qnil;
+	const char *name_c = "";
+	rb_scan_args(argc, argv, "01", &name_rb);
+	if (!NIL_P(name_rb)) {
+		if (!rb_obj_is_kind_of(name_rb, rb_cString))
+			rb_raise(rb_eTypeError, "expecting a string, not a %s\n", rb_obj_classname(name_rb));
+		name_c = rb_string_value_cstr(&name_rb);
+	}
+	const char *str = fstReaderPushScope(ctx, name_c, NULL);
+	if (!str) return Qnil;
+	return rb_utf8_str_new_cstr(str);
+}
+
+
+/* @return [Integer]
+ */
+static VALUE libfst_reader_iterate_hier_rewind(VALUE self)
+{
+	void *ctx = libfst_reader_from_rbobj(self);
+	int r = fstReaderIterateHierRewind(ctx);
+	return INT2NUM(r);
+}
+
+
+static VALUE fstScopeType_to_symbol(enum fstScopeType t)
+{
+	ID id;
+	switch (t) {
+		case FST_ST_VCD_MODULE:         id = id_vcd_module; break;
+	 	case FST_ST_VCD_TASK:           id = id_vcd_task; break;
+	 	case FST_ST_VCD_FUNCTION:       id = id_vcd_function; break;
+	 	case FST_ST_VCD_BEGIN:          id = id_vcd_begin; break;
+	 	case FST_ST_VCD_FORK:           id = id_vcd_fork; break;
+	 	case FST_ST_VCD_GENERATE:       id = id_vcd_generate; break;
+	 	case FST_ST_VCD_STRUCT:         id = id_vcd_struct; break;
+	 	case FST_ST_VCD_UNION:          id = id_vcd_union; break;
+	 	case FST_ST_VCD_CLASS:          id = id_vcd_class; break;
+	 	case FST_ST_VCD_INTERFACE:      id = id_vcd_interface; break;
+	 	case FST_ST_VCD_PACKAGE:        id = id_vcd_package; break;
+	 	case FST_ST_VCD_PROGRAM:        id = id_vcd_program; break;
+	 	case FST_ST_VHDL_ARCHITECTURE:  id = id_vhdl_architecture; break;
+	 	case FST_ST_VHDL_PROCEDURE:     id = id_vhdl_procedure; break;
+	 	case FST_ST_VHDL_FUNCTION:      id = id_vhdl_function; break;
+	 	case FST_ST_VHDL_RECORD:        id = id_vhdl_record; break;
+	 	case FST_ST_VHDL_PROCESS:       id = id_vhdl_process; break;
+	 	case FST_ST_VHDL_BLOCK:         id = id_vhdl_block; break;
+	 	case FST_ST_VHDL_FOR_GENERATE:  id = id_vhdl_for_generate; break;
+	 	case FST_ST_VHDL_IF_GENERATE:   id = id_vhdl_if_generate; break;
+	 	case FST_ST_VHDL_GENERATE:      id = id_vhdl_generate; break;
+	 	case FST_ST_VHDL_PACKAGE:       id = id_vhdl_package; break;
+		default: return Qnil;
+	}
+	return rb_id2sym(id);
+}
+
+
+static VALUE libfst_readerscope_from_struct(const struct fstHier *scop_hier)
+{
+	VALUE args[3];
+	args[0] = fstScopeType_to_symbol(scop_hier->u.scope.typ);
+	args[1] = rb_utf8_str_new(scop_hier->u.scope.name, scop_hier->u.scope.name_length);
+	if (scop_hier->u.scope.component_length)
+		args[2] = rb_utf8_str_new(scop_hier->u.scope.component, scop_hier->u.scope.component_length);
+	else
+		args[2] = Qnil;
+	return rb_class_new_instance(3, args, c_RScope);
+}
+
+
+static VALUE fstVarType_to_symbol(enum fstVarType t)
+{
+	ID id;
+	switch (t) {
+		case FST_VT_VCD_EVENT:          id = id_vcd_event; break;
+		case FST_VT_VCD_INTEGER:        id = id_vcd_integer; break;
+		case FST_VT_VCD_PARAMETER:      id = id_vcd_parameter; break;
+		case FST_VT_VCD_REAL:           id = id_vcd_real; break;
+		case FST_VT_VCD_REAL_PARAMETER: id = id_vcd_real_parameter; break;
+		case FST_VT_VCD_REG:            id = id_vcd_reg; break;
+		case FST_VT_VCD_SUPPLY0:        id = id_vcd_supply0; break;
+		case FST_VT_VCD_SUPPLY1:        id = id_vcd_supply1; break;
+		case FST_VT_VCD_TIME:           id = id_vcd_time; break;
+		case FST_VT_VCD_TRI:            id = id_vcd_tri; break;
+		case FST_VT_VCD_TRIAND:         id = id_vcd_triand; break;
+		case FST_VT_VCD_TRIOR:          id = id_vcd_trior; break;
+		case FST_VT_VCD_TRIREG:         id = id_vcd_trireg; break;
+		case FST_VT_VCD_TRI0:           id = id_vcd_tri0; break;
+		case FST_VT_VCD_TRI1:           id = id_vcd_tri1; break;
+		case FST_VT_VCD_WAND:           id = id_vcd_wand; break;
+		case FST_VT_VCD_WIRE:           id = id_vcd_wire; break;
+		case FST_VT_VCD_WOR:            id = id_vcd_wor; break;
+		case FST_VT_VCD_PORT:           id = id_vcd_port; break;
+		case FST_VT_VCD_SPARRAY:        id = id_vcd_sparray; break;
+		case FST_VT_VCD_REALTIME:       id = id_vcd_realtime; break;
+		case FST_VT_GEN_STRING:         id = id_gen_string; break;
+		case FST_VT_SV_BIT:             id = id_sv_bit; break;
+		case FST_VT_SV_LOGIC:           id = id_sv_logic; break;
+		case FST_VT_SV_INT:             id = id_sv_int; break;
+		case FST_VT_SV_SHORTINT:        id = id_sv_shortint; break;
+		case FST_VT_SV_LONGINT:         id = id_sv_longint; break;
+		case FST_VT_SV_BYTE:            id = id_sv_byte; break;
+		case FST_VT_SV_ENUM:            id = id_sv_enum; break;
+		case FST_VT_SV_SHORTREAL:       id = id_sv_shortreal; break;
+		default: return Qnil;
+	}
+	return rb_id2sym(id);
+}
+
+
+static VALUE fstVarDir_to_symbol(enum fstVarDir d)
+{
+	ID id;
+	switch (d) {
+		case FST_VD_IMPLICIT: id = id_implicit; break;
+		case FST_VD_INPUT:    id = id_input; break;
+		case FST_VD_OUTPUT:   id = id_output; break;
+		case FST_VD_INOUT:    id = id_inout; break;
+		case FST_VD_BUFFER:   id = id_buffer; break;
+		case FST_VD_LINKAGE:  id = id_linkage; break;
+		default: return Qnil;
+	}
+	return rb_id2sym(id);
+}
+
+
+static VALUE libfst_readervar_from_struct(const struct fstHier *var_hier)
+{
+	VALUE args[6];
+	args[0] = fstVarType_to_symbol(var_hier->u.var.typ);
+	args[1] = fstVarDir_to_symbol(var_hier->u.var.direction);
+	args[2] = rb_utf8_str_new(var_hier->u.var.name, var_hier->u.var.name_length);
+	args[3] = ULONG2NUM(var_hier->u.var.length);
+	args[4] = ULONG2NUM(var_hier->u.var.handle);
+	args[5] = var_hier->u.var.is_alias ? Qtrue : Qfalse;
+	return rb_class_new_instance(6, args, c_RVariable);
+}
+
+
+static void fstAttrType_to_symbol(enum fstAttrType t, unsigned char sbtp, VALUE *type, VALUE *subtype)
+{
+	switch (t) {
+		case FST_AT_MISC:
+			*type = rb_id2sym(id_misc);
+			switch (sbtp) {
+				case FST_MT_COMMENT:     *subtype = rb_id2sym(id_comment); break;
+				case FST_MT_ENVVAR:      *subtype = rb_id2sym(id_envvar); break;
+				case FST_MT_SUPVAR:      *subtype = rb_id2sym(id_supvar); break;
+				case FST_MT_PATHNAME:    *subtype = rb_id2sym(id_pathname); break;
+				case FST_MT_SOURCESTEM:  *subtype = rb_id2sym(id_sourcestem); break;
+				case FST_MT_SOURCEISTEM: *subtype = rb_id2sym(id_sourceistem); break;
+				case FST_MT_VALUELIST:   *subtype = rb_id2sym(id_valuelist); break;
+				case FST_MT_ENUMTABLE:   *subtype = rb_id2sym(id_enumtable); break;
+				case FST_MT_UNKNOWN:     *subtype = rb_id2sym(id_unknown); break;
+				default: *subtype = Qnil;
+			}
+			break;
+		case FST_AT_ARRAY:
+			*type = rb_id2sym(id_array);
+			switch (sbtp) {
+				case FST_AR_NONE:        *subtype = rb_id2sym(id_none); break;
+				case FST_AR_UNPACKED:    *subtype = rb_id2sym(id_unpacked); break;
+				case FST_AR_PACKED:      *subtype = rb_id2sym(id_packed); break;
+				case FST_AR_SPARSE:      *subtype = rb_id2sym(id_sparse); break;
+				default: *subtype = Qnil;
+			}
+			break;
+		case FST_AT_ENUM:
+			*type = rb_id2sym(id_enum);
+			switch (sbtp) {
+				case FST_EV_SV_INTEGER:           *subtype = rb_id2sym(id_integer); break;
+				case FST_EV_SV_BIT:               *subtype = rb_id2sym(id_bit); break;
+				case FST_EV_SV_LOGIC:             *subtype = rb_id2sym(id_logic); break;
+				case FST_EV_SV_INT:               *subtype = rb_id2sym(id_int); break;
+				case FST_EV_SV_SHORTINT:          *subtype = rb_id2sym(id_shortint); break;
+				case FST_EV_SV_LONGINT:           *subtype = rb_id2sym(id_longint); break;
+				case FST_EV_SV_BYTE:              *subtype = rb_id2sym(id_byte); break;
+				case FST_EV_SV_UNSIGNED_INTEGER:  *subtype = rb_id2sym(id_unsigned_integer); break;
+				case FST_EV_SV_UNSIGNED_BIT:      *subtype = rb_id2sym(id_unsigned_bit); break;
+				case FST_EV_SV_UNSIGNED_LOGIC:    *subtype = rb_id2sym(id_unsigned_logic); break;
+				case FST_EV_SV_UNSIGNED_INT:      *subtype = rb_id2sym(id_unsigned_int); break;
+				case FST_EV_SV_UNSIGNED_SHORTINT: *subtype = rb_id2sym(id_unsigned_shortint); break;
+				case FST_EV_SV_UNSIGNED_LONGINT:  *subtype = rb_id2sym(id_unsigned_longint); break;
+				case FST_EV_SV_UNSIGNED_BYTE:     *subtype = rb_id2sym(id_unsigned_byte); break;
+				case FST_EV_REG:                  *subtype = rb_id2sym(id_reg); break;
+				case FST_EV_TIME:                 *subtype = rb_id2sym(id_time); break;
+				default: *subtype = Qnil;
+			}
+			break;
+		case FST_AT_PACK:
+			*type = rb_id2sym(id_pack);
+			switch (sbtp) {
+				case FST_PT_NONE:          *subtype = rb_id2sym(id_none); break;
+				case FST_PT_UNPACKED:      *subtype = rb_id2sym(id_unpacked); break;
+				case FST_PT_PACKED:        *subtype = rb_id2sym(id_packed); break;
+				case FST_PT_TAGGED_PACKED: *subtype = rb_id2sym(id_tagged_packed); break;
+				default: *subtype = Qnil;
+			}
+			break;
+		default:
+			*type = Qnil;
+			*subtype = Qnil;
+	}
+}
+
+
+static VALUE libfst_readerattr_from_struct(const struct fstHier *attr_hier)
+{
+	VALUE args[5];
+	fstAttrType_to_symbol(attr_hier->u.attr.typ, attr_hier->u.attr.subtype, &args[0], &args[1]);
+	args[2] = rb_utf8_str_new(attr_hier->u.attr.name, attr_hier->u.attr.name_length);
+	args[3] = ULL2NUM(attr_hier->u.attr.arg);
+	args[4] = ULL2NUM(attr_hier->u.attr.arg_from_name);
+	return rb_class_new_instance(5, args, c_RAttribute);
+}
+
+
+/* Iterate through the hierarchy.
+ * Successively call this method until it returns `nil`.
+ * @return [Scope,Variable,Attribute,Symbol,nil] This method can return a {Scope}, a {Variable}, an {Attribute} or the symbol `:upscope` or `:attrend`
+ */
+static VALUE libfst_reader_iterate_hier(VALUE self)
+{
+	void *ctx = libfst_reader_from_rbobj(self);
+	struct fstHier *hier = fstReaderIterateHier(ctx);
+	if (!hier) return Qnil;
+	VALUE r = Qnil;
+	switch (hier->htyp) {
+		case FST_HT_SCOPE:      r = libfst_readerscope_from_struct(hier); break;
+		case FST_HT_UPSCOPE:    r = rb_id2sym(id_upscope); break;
+		case FST_HT_VAR:        r = libfst_readervar_from_struct(hier); break;
+		case FST_HT_ATTRBEGIN:  r = libfst_readerattr_from_struct(hier); break;
+		case FST_HT_ATTREND:    r = rb_id2sym(id_attrend); break;
+	}
+	return r;
+}
+
+
+/* Variable handles are integers from 1 to `max_handle` inclusive.
+ * @return [Integer]
+ */
+static VALUE libfst_reader_max_handle(VALUE self)
+{
+	void *ctx = libfst_reader_from_rbobj(self);
+	return ULONG2NUM(fstReaderGetMaxHandle(ctx));
+}
+
+
+/* @return [Integer]
+ */
+static VALUE libfst_reader_dump_activity_change_time(VALUE self, VALUE idx)
+{
+	void *ctx = libfst_reader_from_rbobj(self);
+	uint32_t x = NUM2ULONG(idx);
+	uint64_t t = fstReaderGetDumpActivityChangeTime(ctx, x);
+	return ULL2NUM(t);
+}
+
+
+/* @return [Integer]
+ */
+static VALUE libfst_reader_dump_activity_change_value(VALUE self, VALUE idx)
+{
+	void *ctx = libfst_reader_from_rbobj(self);
+	uint32_t x = NUM2ULONG(idx);
+	int t = fstReaderGetDumpActivityChangeValue(ctx, x);
+	return INT2NUM(t);
+}
+
+
+typedef struct {
+	VALUE reader;
+	VALUE proc;
+	uint64_t start_time;
+	uint64_t end_time;
+	int limit_time;
+} libfst_reader_value_change_callback_arg_t;
+
+
+static void libfst_reader_value_change_callback_varlen(void *userdata, uint64_t time, fstHandle facidx, const unsigned char *value, uint32_t len)
+{
+	libfst_reader_value_change_callback_arg_t *arg = userdata;
+	if (arg->limit_time && (time < arg->start_time || time > arg->end_time))
+		return;
+	VALUE time_rb = ULL2NUM(time);
+	VALUE trace = rb_ary_entry(rb_ivar_get(arg->reader, id_at_traces), (int)facidx - 1);
+	VALUE value_rb;
+	if (rb_ivar_get(trace, id_at_is_float) == Qtrue) {
+		value_rb = DBL2NUM(*(double*)value);
+	} else if (len > 0) {
+		value_rb = rb_str_new((const char*)value, len);
+	} else {
+		value_rb = rb_str_new_cstr((const char*)value);
+	}
+	VALUE args = rb_ary_new_from_args(4, trace, time_rb, value_rb, arg->reader);
+	rb_proc_call(arg->proc, args);
+}
+
+
+static void libfst_reader_value_change_callback(void *userdata, uint64_t time, fstHandle facidx, const unsigned char *value)
+{
+	libfst_reader_value_change_callback_varlen(userdata, time, facidx, value, 0);
+}
+
+
+/* Read the value changes of the traces.
+ *
+ * The provided block is called for each value change found in the file.
+ *
+ * If signals are specified, the block will be called only for thoses signals.
+ *
+ * If a start time and/or an end time are specified, only value changes in this time window will be searched.
+ *
+ * @return [Integer]
+ * @overload read(*signals, start_time: nil, end_time: nil)
+ *  @param signals [Trace,Variable,Scope,Integer] List of signals to be read. Either a trace, its handle, a variable or a scope. If no signal is specified, all signals are read.
+ *  @param sart_time [Integer, Float, nil] Start time, either as an integer (in magnitude of {time_scale}) or real time as a float.
+ *  @param end_time [Integer, Float, nil] End time, either as an integer (in magnitude of {time_scale}) or real time as a float. 
+ *  @yieldparam trace  [Trace]
+ *  @yieldparam time   [Integer]
+ *  @yieldparam value  [String,Float]
+ *  @yieldparam reader [self]
+ */
+static VALUE libfst_reader_read(int argc, VALUE *argv, VALUE self)
+{
+	void *ctx = libfst_reader_from_rbobj(self);
+	VALUE blk;
+	VALUE splat;
+	VALUE kw;
+	const ID kwkeys[2] = {id_start_time, id_end_time};
+	VALUE kwvalues[2] = {Qundef, Qundef};
+	uint64_t start_time, end_time;
+	libfst_reader_value_change_callback_arg_t cbarg;
+
+
+	rb_scan_args(argc, argv, "*:&", &splat, &kw, &blk);
+
+	if (NIL_P(blk))
+		rb_raise(rb_eRuntimeError, "read expects a block");
+
+	if (!NIL_P(kw)) {
+		rb_get_kwargs(kw, kwkeys, 0, 2, kwvalues);
+
+		if (kwvalues[0] == Qundef || NIL_P(kwvalues[0]))
+			start_time = 0;
+		else if (rb_obj_is_kind_of(kwvalues[0], rb_cInteger))
+			start_time = NUM2ULL(kwvalues[0]);
+		else if (rb_obj_is_kind_of(kwvalues[0], rb_cFloat))
+			start_time = (uint64_t)floor(NUM2DBL(kwvalues[0]) / NUM2DBL(libfst_reader_time_scale(self)));
+		else
+			rb_raise(rb_eTypeError, "expecting an Integer or a Float as start time, not a %s", rb_obj_classname(kwvalues[0]));
+
+		if (kwvalues[1] == Qundef || NIL_P(kwvalues[1]))
+			end_time = fstReaderGetEndTime(ctx) + 1;
+		else if (rb_obj_is_kind_of(kwvalues[1], rb_cInteger))
+			end_time = NUM2ULL(kwvalues[1]);
+		else if (rb_obj_is_kind_of(kwvalues[1], rb_cFloat))
+			end_time = (uint64_t)floor(NUM2DBL(kwvalues[1]) / NUM2DBL(libfst_reader_time_scale(self)));
+		else
+			rb_raise(rb_eTypeError, "expecting an Integer or a Float as end time, not a %s", rb_obj_classname(kwvalues[1]));
+
+		if (end_time < start_time)
+			rb_raise(rb_eRuntimeError, "start_time must be less than end_time (%lu, %lu)", start_time, end_time);
+
+		fstReaderSetLimitTimeRange(ctx, start_time, end_time);
+		cbarg.limit_time = 1;
+		cbarg.start_time = start_time;
+		cbarg.end_time = end_time;
+	} else {
+		fstReaderSetUnlimitedTimeRange(ctx);
+		cbarg.limit_time = 0;
+	}
+
+	long splatlen = rb_array_len(splat);
+	if (splatlen < 1) {
+		fstReaderSetFacProcessMaskAll(ctx);
+	} else {
+		fstReaderClrFacProcessMaskAll(ctx);
+		long i;
+		fstHandle mh = fstReaderGetMaxHandle(ctx);
+		for (i = 0; i < splatlen; i++) {
+			VALUE t = rb_ary_entry(splat, i);
+			fstHandle facidx;
+			if (rb_obj_is_kind_of(t, rb_cInteger)) {
+				facidx = NUM2ULONG(t);
+				if (facidx < 1 || facidx > mh) rb_raise(rb_eRuntimeError, "bad signal handle");
+				fstReaderSetFacProcessMask(ctx, facidx);
+			} else if (rb_obj_is_kind_of(t, c_RTrace)) {
+				facidx = NUM2ULONG(rb_ivar_get(t, id_at_handle));
+				if (facidx < 1 || facidx > mh) rb_raise(rb_eRuntimeError, "bad signal handle");
+				fstReaderSetFacProcessMask(ctx, facidx);
+			} else if (rb_obj_is_kind_of(t, c_RVariable)) {
+				facidx = NUM2ULONG(rb_ivar_get(rb_ivar_get(t, id_at_trace), id_at_handle));
+				if (facidx < 1 || facidx > mh) rb_raise(rb_eRuntimeError, "bad signal handle");
+				fstReaderSetFacProcessMask(ctx, facidx);
+			} else if (rb_obj_is_kind_of(t, c_RScope)) {
+				VALUE variables = rb_ivar_get(t, id_at_variables);
+				long varlen = rb_array_len(variables);
+				long j;
+				for (j = 0; j < varlen; j++) {
+					facidx = NUM2ULONG(rb_ivar_get(rb_ivar_get(rb_ary_entry(variables, j), id_at_trace), id_at_handle));
+					if (facidx < 1 || facidx > mh) rb_raise(rb_eRuntimeError, "bad signal handle");
+					fstReaderSetFacProcessMask(ctx, facidx);
+				}
+			} else {
+				rb_raise(rb_eTypeError, "signals can be specified either by a handle (Integer), a %"PRIsVALUE", a %"PRIsVALUE" or a %"PRIsVALUE", not a %s",
+						c_RTrace, c_RVariable, c_RScope, rb_obj_classname(t));
+			}
+		}
+	}
+
+	cbarg.reader = self;
+	cbarg.proc = blk;
+	int r = fstReaderIterBlocks2(ctx, libfst_reader_value_change_callback, libfst_reader_value_change_callback_varlen, &cbarg, NULL);
+	RB_GC_GUARD(cbarg.reader);
+	RB_GC_GUARD(cbarg.proc);
+	return INT2NUM(r);
+}
+
+
+/******************************************************************************/
+
+
+typedef struct {
+	void *ctx;
+} fstwriterctx_t;
+
+
+static void libfst_writer_free(void *p)
+{
+	fstwriterctx_t *wctx = p;
+
+	if (wctx) {
+		if (wctx->ctx) 
+			fstWriterClose(wctx->ctx);
+		free(wctx);
+	}
+}
+
+
+static size_t libfst_writer_size(const void *p)
+{
+	(void)p;
+	return sizeof(fstwriterctx_t);
+}
+
+
+const rb_data_type_t libfst_writer_type = {
+	.wrap_struct_name = "LibFST::Writer",
+	.function = {
+		.dmark = NULL,
+		.dfree = libfst_writer_free,
+		.dsize = libfst_writer_size,
+	},
+	.parent = NULL,
+	.data = NULL,
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+
+inline void* libfst_writer_from_rbobj(VALUE obj) {
+	fstwriterctx_t *wctx;
+	TypedData_Get_Struct(obj, fstwriterctx_t, &libfst_writer_type, wctx);
+	if (!wctx->ctx)
+		rb_raise(rb_eRuntimeError, "%s object is not valid", rb_obj_classname(obj));
+	return wctx->ctx;
+}
+
+
+static VALUE libfst_writer_alloc(VALUE klass)
+{
+	fstwriterctx_t *wctx = malloc(sizeof(fstwriterctx_t));
+	wctx->ctx = NULL;
+	return TypedData_Wrap_Struct(klass, &libfst_writer_type, wctx);
+}
+
+
+/* @overload initialize(out_file_name, compress_hier: true)
+ *  @param out_file_name [String] path of the file to create
+ *  @param compress_hier [Boolean]
+ */
+static VALUE libfst_writer_initialize(int argc, VALUE *argv, VALUE self)
+{
+	VALUE fname;
+	VALUE kw;
+	const ID kwkeys[1] = {id_compress_hier};
+	VALUE kwvalues[1] = {Qundef};
+	rb_scan_args(argc, argv, "1:", &fname, &kw);
+	fname = rb_funcallv(rb_cFile, id_expand_path, 1, &fname);
+	const char *cfname = rb_string_value_cstr(&fname);
+	rb_ivar_set(self, id_at_filename, fname);
+	int ccomphier = 1;
+	if (!NIL_P(kw)) {
+		rb_get_kwargs(kw, kwkeys, 0, 1, kwvalues);
+		if (kwvalues[0] != Qundef) {
+			if (kwvalues[0] == Qnil || kwvalues[0] == Qfalse)
+				ccomphier = 0;
+			else
+				ccomphier = 1;
+		}
+	}
+
+	fstwriterctx_t *wctx;
+	TypedData_Get_Struct(self, fstwriterctx_t, &libfst_writer_type, wctx);
+	wctx->ctx = fstWriterCreate(cfname, ccomphier);
+	if (!wctx->ctx)
+		rb_raise(rb_eRuntimeError, "cannot create FST file \"%"PRIsVALUE"\"", fname);
+
+	rb_ivar_set(self, id_at_variables, rb_ary_new());
+
+	return self;
+}
+
+
+static VALUE delete_temp_hier_file(VALUE writer)
+{
+	VALUE base = rb_ivar_get(writer, id_at_filename);
+	VALUE sufix = rb_sprintf(".hier");
+	VALUE hierfname = rb_funcallv(base, id_symbol_plus, 1, &sufix);
+	rb_funcallv(rb_cFile, id_delete, 1, &hierfname);
+	return writer;
+}
+
+
+/* Finalize the output file then close it.
+ * After this method has been called, the object is not valid anymore.
+ */
+static VALUE libfst_writer_close(VALUE self)
+{
+	fstwriterctx_t *wctx;
+	TypedData_Get_Struct(self, fstwriterctx_t, &libfst_writer_type, wctx);
+	if (!wctx->ctx)
+		rb_raise(rb_eRuntimeError, "%s object is not valid", rb_obj_classname(self));
+	fstWriterClose(wctx->ctx);
+	wctx->ctx = NULL;
+
+	int state = 0;
+	rb_protect(delete_temp_hier_file, self, &state);
+	if (state)
+		rb_set_errinfo(Qnil);
+
+	return self;
+}
+
+
+/* Set the date string to be written in the output file
+ * @param date [String]
+ * @return [self]
+ */
+static VALUE libfst_writer_set_date_string(VALUE self, VALUE date)
+{
+	void *ctx = libfst_writer_from_rbobj(self);
+	const char *str = rb_string_value_cstr(&date);
+	fstWriterSetDate(ctx, str);
+	return self;
+}
+
+
+/* Set the version string to be written to the output file.
+ * @param version [String]
+ * @return [self]
+ */
+static VALUE libfst_writer_set_version_string(VALUE self, VALUE version)
+{
+	void *ctx = libfst_writer_from_rbobj(self);
+	const char *str = rb_string_value_cstr(&version);
+	fstWriterSetVersion(ctx, str);
+	return self;
+}
+
+
+/* @return [Boolean]
+ */
+static VALUE libfst_writer_fseek_failed(VALUE self)
+{
+	void *ctx = libfst_writer_from_rbobj(self);
+	return (fstWriterGetFseekFailed(ctx) ? Qtrue : Qfalse);
+}
+
+
+/* @return [Boolean]
+ */
+static VALUE libfst_writer_dump_size_limit_reached(VALUE self)
+{
+	void *ctx = libfst_writer_from_rbobj(self);
+	return (fstWriterGetDumpSizeLimitReached(ctx) ? Qtrue : Qfalse);
+}
+
+
+/* @param numbytes [Integer]
+ * @return [self]
+ */
+static VALUE libfst_writer_set_dump_size_limit(VALUE self, VALUE numbytes)
+{
+	void *ctx = libfst_writer_from_rbobj(self);
+	uint64_t limit = rb_to_uint64t(numbytes);
+	fstWriterSetDumpSizeLimit(ctx, limit);
+	return self;
+}
+
+
+/* @return [self]
+ */
+static VALUE libfst_writer_flush_context(VALUE self)
+{
+	void *ctx = libfst_writer_from_rbobj(self);
+	fstWriterFlushContext(ctx);
+	return self;
+}
+
+
+/* Set time zero.
+ * @param time [Integer]
+ * @return [self]
+ */
+static VALUE libfst_writer_set_time_zero(VALUE self, VALUE time)
+{
+	void *ctx = libfst_writer_from_rbobj(self);
+	fstWriterSetTimezero(ctx, NUM2LL(time));
+	return self;
+}
+
+
+/* Set the comment to be written to the output file.
+ * @param comment [String]
+ * @return [self]
+ */
+static VALUE libfst_writer_set_comment(VALUE self, VALUE comment)
+{
+	void *ctx = libfst_writer_from_rbobj(self);
+	const char *str = rb_string_value_cstr(&comment);
+	fstWriterSetComment(ctx, str);
+	return self;
+}
+
+
+/* Set whether to use parallel write mode or not (multithreaded)
+ * @param enable [Boolean]
+ * @return [self]
+ */
+static VALUE libfst_writer_set_use_parallel_mode(VALUE self, VALUE enable)
+{
+	void *ctx = libfst_writer_from_rbobj(self);
+	int en = rb_to_boolean(enable);
+	fstWriterSetParallelMode(ctx, en);
+	return self;
+}
+
+
+/* @param enable [Boolean]
+ * @return [self]
+ */
+static VALUE libfst_writer_set_repack_on_close(VALUE self, VALUE enable)
+{
+	void *ctx = libfst_writer_from_rbobj(self);
+	int en = rb_to_boolean(enable);
+	fstWriterSetRepackOnClose(ctx, en);
+	return self;
+}
+
+
+static enum fstFileType symbol_to_fstFileType(VALUE sym)
+{
+	ID id = rb_sym2id(sym);
+	enum fstFileType t;
+	if (id == id_verilog)
+		t = FST_FT_VERILOG;
+	else if (id == id_vhdl)
+		t = FST_FT_VHDL;
+	else if (id == id_verilog_or_vhdl)
+		t = FST_FT_VERILOG_VHDL;
+	else
+		rb_raise(rb_eTypeError, "invalid file type (%"PRIsVALUE"), valid values are :verilog, :vhdl or verilog_or_vhdl", sym);
+
+	return t;
+}
+
+
+/* Indicate the file type.
+ * @param type [Symbol] either `:verilog`, `:vhdl` or `:verilog_or_vhdl`
+ * @return [self]
+ */
+static VALUE libfst_writer_set_file_type(VALUE self, VALUE type)
+{
+	void *ctx = libfst_writer_from_rbobj(self);
+	fstWriterSetFileType(ctx, symbol_to_fstFileType(type));
+	return self;
+}
+
+
+static enum fstWriterPackType symbol_to_fstWriterPackType(VALUE sym)
+{
+	ID id = rb_sym2id(sym);
+	enum fstWriterPackType pt;
+	if (id == id_zlib)
+		pt = FST_WR_PT_ZLIB;
+	else if (id == id_fastlz)
+		pt = FST_WR_PT_FASTLZ;
+	else if (id == id_lz4)
+		pt = FST_WR_PT_LZ4;
+	else
+		rb_raise(rb_eTypeError, "invalid pack type (%"PRIsVALUE"), valid values are :zlib, :fastlz or :lz4", sym);
+	return pt;
+}
+
+
+/* Set the packing type.
+ * @param type [Symbol] Either `:zlib`, `:fastlz` or `:lz4`
+ * @return [self]
+ */
+static VALUE libfst_writer_set_pack_type(VALUE self, VALUE type)
+{
+	void *ctx = libfst_writer_from_rbobj(self);
+	fstWriterSetPackType(ctx, symbol_to_fstWriterPackType(type));
+	return self;
+}
+
+
+/* @param envvar [String]
+ * @return [self]
+ */
+static VALUE libfst_writer_set_envvar(VALUE self, VALUE envvar)
+{
+	void *ctx = libfst_writer_from_rbobj(self);
+	const char *str = rb_string_value_cstr(&envvar);
+	fstWriterSetEnvVar(ctx, str);
+	return self;
+}
+
+
+/* @param valuelist [String]
+ * @return [self]
+ */
+static VALUE libfst_writer_set_value_list(VALUE self, VALUE valuelist)
+{
+	void *ctx = libfst_writer_from_rbobj(self);
+	const char *str = rb_string_value_cstr(&valuelist);
+	fstWriterSetValueList(ctx, str);
+	return self;
+}
+
+
+/* @return [self]
+ */
+static VALUE libfst_writer_set_upscope(VALUE self)
+{
+	void *ctx = libfst_writer_from_rbobj(self);
+	fstWriterSetUpscope(ctx);
+	return self;
+}
+
+
+/* Set time scale, as a power of 10.
+ * @param timescale [Integer,Symbol,Float] Either 0 for `:s`, -3 for `:ms`, -6 fo `:us`, -9 for `:ns`, -12 for `:ps` or -15 for `:fs`. If a Float is given, it must be a power of 10, such as 10e-9
+ * @return [Integer]
+ */
+static VALUE libfst_writer_set_time_scale(VALUE self, VALUE timescale)
+{
+	int ts = 0;
+	if (rb_obj_is_kind_of(timescale, rb_cInteger)) {
+		ts = NUM2INT(timescale);
+		if (ts > 0 || ts < -15)
+			rb_raise(rb_eRangeError, "valid integer timescale values are between 0 and -15");
+	} else if (rb_obj_is_kind_of(timescale, rb_cSymbol)) {
+		ID id = rb_sym2id(timescale);
+		if (id == id_s)
+			ts = 0;
+		else if (id == id_ms)
+			ts = -3;
+		else if (id == id_us)
+			ts = -6;
+		else if (id == id_ns)
+			ts = -9;
+		else if (id == id_ps)
+			ts = -12;
+		else if (id == id_fs)
+			ts = -15;
+		else
+			rb_raise(rb_eRuntimeError, "valid timescale symbols are :s, :ms, :us, :ns, :ps and :fs");
+	} else if (rb_obj_is_kind_of(timescale, rb_cFloat)) {
+		double d = NUM2DBL(timescale);
+		if (d <= 1e-21 || d > 1.0)
+			rb_raise(rb_eRangeError, "valid float timescale values are between 1e-21 and 1.0");
+		double l = log10(d);
+		ts = (int)l;
+		if (l != (double)ts)
+			rb_raise(rb_eRangeError, "valid float timescale values must be powers of 10, such as 10e-3");
+	}
+	void *ctx = libfst_writer_from_rbobj(self);
+	fstWriterSetTimescale(ctx, ts);
+	return INT2NUM(ts);
+}
+
+
+/* @return [self]
+ */
+static VALUE libfst_writer_set_attribute_end(VALUE self)
+{
+	void *ctx = libfst_writer_from_rbobj(self);
+	fstWriterSetAttrEnd(ctx);
+	return self;
+}
+
+
+static enum fstAttrType symbol_to_fstAttrType(VALUE sym)
+{
+	ID id = rb_sym2id(sym);
+	enum fstAttrType t;
+	if (id == id_misc)
+		t = FST_AT_MISC;
+	else if (id == id_array)
+		t = FST_AT_ARRAY;
+	else if (id == id_enum)
+		t = FST_AT_ENUM;
+	else if (id == id_pack)
+		t = FST_AT_PACK;
+	else
+		rb_raise(rb_eTypeError, "invalid attribute type (%"PRIsVALUE"), valid values are :misc, :array, :enum or :pack", sym);
+	return t;
+}
+
+
+static int symbol_to_subtype(VALUE sym, enum fstAttrType type)
+{
+	int subtype = 0;
+	ID id;
+
+	switch (type) {
+		case FST_AT_MISC:
+			if (NIL_P(sym)) {
+				subtype = FST_MT_UNKNOWN;
+				break;
+			}
+			id = rb_sym2id(sym);
+			if (id == id_comment)
+				subtype = FST_MT_COMMENT;
+			else if (id == id_envvar)
+				subtype = FST_MT_ENVVAR;
+			else if (id == id_supvar)
+				subtype = FST_MT_SUPVAR;
+			else if (id == id_pathname)
+				subtype = FST_MT_PATHNAME;
+			else if (id == id_sourcestem)
+				subtype = FST_MT_SOURCESTEM;
+			else if (id == id_sourceistem)
+				subtype = FST_MT_SOURCEISTEM;
+			else if (id == id_valuelist)
+				subtype = FST_MT_VALUELIST;
+			else if (id == id_enumtable)
+				subtype = FST_MT_ENUMTABLE;
+			else if (id == id_unknown)
+				subtype = FST_MT_UNKNOWN;
+			else
+				rb_raise(rb_eArgError, "invalid subtype (%"PRIsVALUE"), with type :misc, valid subtypes are :comment, :envvar, :supvar, :pathname, :sourcestem, :sourceistem, :valuelist, :enumtable and :unknown", sym);
+			break;
+
+		case FST_AT_ARRAY:
+			if (NIL_P(sym)) {
+				subtype = FST_AR_NONE;
+				break;
+			}
+			id = rb_sym2id(sym);
+			if (id == id_none)
+				subtype = FST_AR_NONE;
+			else if (id == id_unpacked)
+				subtype = FST_AR_UNPACKED;
+			else if (id == id_packed)
+				subtype = FST_AR_PACKED;
+			else if (id == id_sparse)
+				subtype = FST_AR_SPARSE;
+			else
+				rb_raise(rb_eArgError, "invalid subtype (%"PRIsVALUE"), with type :array, valid subtypes are :none, :unpacked, :packed and :sparse", sym);
+			break;
+
+		case FST_AT_ENUM:
+			if (NIL_P(sym)) {
+				subtype = FST_EV_SV_INTEGER;
+				break;
+			}
+			id = rb_sym2id(sym);
+			if (id == id_integer)
+				subtype = FST_EV_SV_INTEGER;
+			else if (id == id_bit)
+				subtype = FST_EV_SV_BIT;
+			else if (id == id_logic)
+				subtype = FST_EV_SV_LOGIC;
+			else if (id == id_int)
+				subtype = FST_EV_SV_INT;
+			else if (id == id_shortint)
+				subtype = FST_EV_SV_SHORTINT;
+			else if (id == id_longint)
+				subtype = FST_EV_SV_LONGINT;
+			else if (id == id_byte)
+				subtype = FST_EV_SV_BYTE;
+			else if (id == id_unsigned_integer)
+				subtype = FST_EV_SV_UNSIGNED_INTEGER;
+			else if (id == id_unsigned_bit)
+				subtype = FST_EV_SV_UNSIGNED_BIT;
+			else if (id == id_unsigned_logic)
+				subtype = FST_EV_SV_UNSIGNED_LOGIC;
+			else if (id == id_unsigned_int)
+				subtype = FST_EV_SV_UNSIGNED_INT;
+			else if (id == id_unsigned_shortint)
+				subtype = FST_EV_SV_UNSIGNED_SHORTINT;
+			else if (id == id_unsigned_longint)
+				subtype = FST_EV_SV_UNSIGNED_LONGINT;
+			else if (id == id_unsigned_byte)
+				subtype = FST_EV_SV_UNSIGNED_BYTE;
+			else if (id == id_reg)
+				subtype = FST_EV_REG;
+			else if (id == id_time)
+				subtype = FST_EV_TIME;
+			else
+				rb_raise(rb_eArgError, "invalid subtype (%"PRIsVALUE"), with type :enum, valid subtypes are :integer, :bit, :logic, :int, :shortint, :longint, :byte, :unsigned_integer, :unsigned_bit, :unsigned_logic, :unsigned_int, :unsigned_shortint, :unsigned_longint, :unsigned_byte, :reg and :time", sym);
+			break;
+
+		case FST_AT_PACK:
+			if (NIL_P(sym)) {
+				subtype = FST_PT_NONE;
+				break;
+			}
+			id = rb_sym2id(sym);
+			if (id == id_none)
+				subtype = FST_PT_NONE;
+			else if (id == id_unpacked)
+				subtype = FST_PT_UNPACKED;
+			else if (id == id_packed)
+				subtype = FST_PT_PACKED;
+			else if (id == id_tagged_packed)
+				subtype = FST_PT_TAGGED_PACKED;
+			else
+				rb_raise(rb_eArgError, "invalid subtype (%"PRIsVALUE"), with type :pack, valid subtypes are :none, :unpacked, :packed or :tagged_packed", sym);
+			break;
+
+		default:
+			rb_raise(rb_eRuntimeError, "bad type");
+	}
+
+	return subtype;
+}
+
+
+/* Attributes of type `:misc` do not need a closing {Writer#set_attribute_end}, others do.
+ * @return [self]
+ * @overload set_attribute_begin(name, type:, subtype: nil, arg: 0)
+ *  @param name [String]
+ *  @param type [Symbol] either `:misc`, `:array`, `:enum` or `:pack`
+ *  @param subtype [Symbol,nil]
+ *    When `type` is
+ *    - __:misc__:  `:comment`, `:envvar`, `:supvar`, `:pathname`, `:sourcestem`, `:sourceistem`, `:valuelist`, `:enumtable`, `:unknown`
+ *    - __:array__: `:none`, `:unpacked`, `:packed` or `:sparse`
+ *    - __:enum__:  `:integer`, `:bit`, `:logic`, `:int`, `:shortint`, `:longint`, `:byte`, `:unsigned_integer`, `:unsigned_bit`, `:unsigned_logic`, `:unsigned_int`, `:unsigned_shortint`, `:unsigned_longint`, `:unsigned_byte`, `:reg` or `:time`
+ *    - __:pack__:  `:none`, `:unpacked`, `:packed` or `:tagged_packed`
+ *  @param arg [Integer]
+ */
+static VALUE libfst_writer_set_attribute_begin(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rbname;
+	VALUE kw;
+	const ID kwkeys[3] = {id_type, id_subtype, id_arg};
+	VALUE kwvalues[3] = {Qundef, Qundef, Qundef};
+
+	rb_scan_args(argc, argv, "1:", &rbname, &kw);
+	const char *attrname = rb_string_value_cstr(&rbname);
+	rb_get_kwargs(kw, kwkeys, 1, 2, kwvalues);
+	enum fstAttrType type = symbol_to_fstAttrType(kwvalues[0]);
+	uint64_t arg = 0;
+	if (kwvalues[2] != Qundef && kwvalues[2] != Qnil)
+		arg = rb_to_uint64t(kwvalues[2]);
+	if (kwvalues[1] == Qundef)
+		kwvalues[1] = Qnil;
+	int subtype = symbol_to_subtype(kwvalues[1], type);
+
+	void *ctx = libfst_writer_from_rbobj(self);
+	fstWriterSetAttrBegin(ctx, type, subtype, attrname, arg);
+	return self;
+}
+
+
+/* @return [self]
+ * @overload set_source_stem(path, line, use_realpath: false)
+ *  @param path [String]
+ *  @param line [Integer]
+ *  @param use_realpath [Boolean]
+ */
+static VALUE libfst_writer_set_source_stem(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rbpath, rbline, kw;
+	const ID kwkeys[1] = {id_use_realpath};
+	VALUE kwvalues[1] = {Qundef};
+
+	rb_scan_args(argc, argv, "2:", &rbpath, &rbline, &kw);
+	rb_get_kwargs(kw, kwkeys, 0, 1, kwvalues);
+
+	const char *path = rb_string_value_cstr(&rbpath);
+	unsigned int line = rb_to_unsigned_int(rbline);
+	int use_realpath = 0;
+	if (kwvalues[0] != Qundef)
+		use_realpath = rb_to_boolean(kwvalues[0]);
+
+	void *ctx = libfst_writer_from_rbobj(self);
+	fstWriterSetSourceStem(ctx, path, line, use_realpath);
+
+	return self;
+}
+
+
+/* @return [self]
+ * @overload set_source_instantiation_stem(path, line, use_realpath: false)
+ *  @param path [String]
+ *  @param line [Integer]
+ *  @param use_realpath [Boolean]
+ */
+static VALUE libfst_writer_set_source_instantiation_stem(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rbpath, rbline, kw;
+	const ID kwkeys[1] = {id_use_realpath};
+	VALUE kwvalues[1] = {Qundef};
+
+	rb_scan_args(argc, argv, "2:", &rbpath, &rbline, &kw);
+	rb_get_kwargs(kw, kwkeys, 0, 1, kwvalues);
+
+	const char *path = rb_string_value_cstr(&rbpath);
+	unsigned int line = rb_to_unsigned_int(rbline);
+	int use_realpath = 0;
+	if (kwvalues[0] != Qundef)
+		use_realpath = rb_to_boolean(kwvalues[0]);
+
+	void *ctx = libfst_writer_from_rbobj(self);
+	fstWriterSetSourceInstantiationStem(ctx, path, line, use_realpath);
+
+	return self;
+}
+
+
+static enum fstScopeType symbol_to_fstScopeType(VALUE sym)
+{
+	ID id = rb_sym2id(sym);
+	enum fstScopeType t;
+	if (id == id_vcd_module)
+		t = FST_ST_VCD_MODULE;
+	else if (id == id_vcd_task)
+		t = FST_ST_VCD_TASK;
+	else if (id == id_vcd_function)
+		t = FST_ST_VCD_FUNCTION;
+	else if (id == id_vcd_begin)
+		t = FST_ST_VCD_BEGIN;
+	else if (id == id_vcd_fork)
+		t = FST_ST_VCD_FORK;
+	else if (id == id_vcd_generate)
+		t = FST_ST_VCD_GENERATE;
+	else if (id == id_vcd_struct)
+		t = FST_ST_VCD_STRUCT;
+	else if (id == id_vcd_union)
+		t = FST_ST_VCD_UNION;
+	else if (id == id_vcd_class)
+		t = FST_ST_VCD_CLASS;
+	else if (id == id_vcd_interface)
+		t = FST_ST_VCD_INTERFACE;
+	else if (id == id_vcd_package)
+		t = FST_ST_VCD_PACKAGE;
+	else if (id == id_vcd_program)
+		t = FST_ST_VCD_PROGRAM;
+	else if (id == id_vhdl_architecture)
+		t = FST_ST_VHDL_ARCHITECTURE;
+	else if (id == id_vhdl_procedure)
+		t = FST_ST_VHDL_PROCEDURE;
+	else if (id == id_vhdl_function)
+		t = FST_ST_VHDL_FUNCTION;
+	else if (id == id_vhdl_record)
+		t = FST_ST_VHDL_RECORD;
+	else if (id == id_vhdl_process)
+		t = FST_ST_VHDL_PROCESS;
+	else if (id == id_vhdl_block)
+		t = FST_ST_VHDL_BLOCK;
+	else if (id == id_vhdl_for_generate)
+		t = FST_ST_VHDL_FOR_GENERATE;
+	else if (id == id_vhdl_if_generate)
+		t = FST_ST_VHDL_IF_GENERATE;
+	else if (id == id_vhdl_generate)
+		t = FST_ST_VHDL_GENERATE;
+	else if (id == id_vhdl_package)
+		t = FST_ST_VHDL_PACKAGE;
+	else
+		rb_raise(rb_eTypeError, "invalid scope type (%"PRIsVALUE"), valid values are :vcd_module, :vcd_task, :vcd_function, :vcd_begin, :vcd_fork, :vcd_generate, :vcd_struct, :vcd_union, :vcd_class, :vcd_interface, :vcd_package, :vcd_program, :vhdl_architecture, :vhdl_procedure, :vhdl_function, :vhdl_record, :vhdl_process, :vhdl_block, :vhdl_for_generate, :vhdl_if_generate, :vhdl_generate and :vhdl_package", sym);
+	return t;
+}
+
+
+/* @return [self]
+ * @overload set_scope(type, name: nil, component: nil)
+ *  @param type [Symbol] either `:vcd_module`, `:vcd_task`, `:vcd_function`, `:vcd_begin`, `:vcd_fork`, `:vcd_generate`, `:vcd_struct`, `:vcd_union`, `:vcd_class`, `:vcd_interface`, `:vcd_package`, `:vcd_program`, `:vhdl_architecture`, `:vhdl_procedure`, `:vhdl_function`, `:vhdl_record`, `:vhdl_process`, `:vhdl_block`, `:vhdl_for_generate`, `:vhdl_if_generate`, `:vhdl_generate` or `:vhdl_package`
+ *  @param name [String,nil]
+ *  @param component [String,nil]
+ */
+static VALUE libfst_writer_set_scope(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rbtype;
+	VALUE kw;
+	const ID kwkeys[2] = {id_name, id_component};
+	VALUE kwvalues[2] = {Qundef, Qundef};
+	rb_scan_args(argc, argv, "1:", &rbtype, &kw);
+	enum fstScopeType scopetype = symbol_to_fstScopeType(rbtype);
+	const char *scopename = NULL;
+	const char *scopecomp = NULL;
+	if (!NIL_P(kw)) {
+		rb_get_kwargs(kw, kwkeys, 0, 2, kwvalues);
+		if (kwvalues[0] != Qundef && !NIL_P(kwvalues[0]))
+			scopename = rb_string_value_cstr(&kwvalues[0]);
+		if (kwvalues[1] != Qundef && !NIL_P(kwvalues[1]))
+			scopecomp = rb_string_value_cstr(&kwvalues[1]);
+	}
+
+	void *ctx = libfst_writer_from_rbobj(self);
+	fstWriterSetScope(ctx, scopetype, scopename, scopecomp);
+
+	return self;
+}
+
+
+/* Advance the time cursor.
+ * @param time [Integer]
+ * @return [self]
+ */
+static VALUE libfst_writer_emit_time_change(VALUE self, VALUE time)
+{
+	uint64_t t = rb_to_uint64t(time);
+	void *ctx = libfst_writer_from_rbobj(self);
+	fstWriterEmitTimeChange(ctx, t);
+	return self;
+}
+
+
+/* Create a new blackout chain block.
+ * @param enable [Boolean]
+ * @return [self]
+ */
+static VALUE libfst_writer_emit_dump_active(VALUE self, VALUE enable)
+{
+	int en = rb_to_boolean(enable);
+	void *ctx = libfst_writer_from_rbobj(self);
+	fstWriterEmitDumpActive(ctx, en);
+	return self;
+}
+
+
+static enum fstVarType symbol_to_fstVarType(VALUE sym)
+{
+	ID id = rb_sym2id(sym);
+	enum fstVarType t;
+	if (id == id_vcd_event)
+		t = FST_VT_VCD_EVENT;
+	else if (id == id_vcd_integer)
+		t = FST_VT_VCD_INTEGER;
+	else if (id == id_vcd_parameter)
+		t = FST_VT_VCD_PARAMETER;
+	else if (id == id_vcd_real)
+		t = FST_VT_VCD_REAL;
+	else if (id == id_vcd_real_parameter)
+		t = FST_VT_VCD_REAL_PARAMETER;
+	else if (id == id_vcd_reg)
+		t = FST_VT_VCD_REG;
+	else if (id == id_vcd_supply0)
+		t = FST_VT_VCD_SUPPLY0;
+	else if (id == id_vcd_supply1)
+		t = FST_VT_VCD_SUPPLY1;
+	else if (id == id_vcd_time)
+		t = FST_VT_VCD_TIME;
+	else if (id == id_vcd_tri)
+		t = FST_VT_VCD_TRI;
+	else if (id == id_vcd_triand)
+		t = FST_VT_VCD_TRIAND;
+	else if (id == id_vcd_trior)
+		t = FST_VT_VCD_TRIOR;
+	else if (id == id_vcd_trireg)
+		t = FST_VT_VCD_TRIREG;
+	else if (id == id_vcd_tri0)
+		t = FST_VT_VCD_TRI0;
+	else if (id == id_vcd_tri1)
+		t = FST_VT_VCD_TRI1;
+	else if (id == id_vcd_wand)
+		t = FST_VT_VCD_WAND;
+	else if (id == id_vcd_wire)
+		t = FST_VT_VCD_WIRE;
+	else if (id == id_vcd_wor)
+		t = FST_VT_VCD_WOR;
+	else if (id == id_vcd_port)
+		t = FST_VT_VCD_PORT;
+	else if (id == id_vcd_sparray)
+		t = FST_VT_VCD_SPARRAY;
+	else if (id == id_vcd_realtime)
+		t = FST_VT_VCD_REALTIME;
+	else if (id == id_gen_string)
+		t = FST_VT_GEN_STRING;
+	else if (id == id_sv_bit)
+		t = FST_VT_SV_BIT;
+	else if (id == id_sv_logic)
+		t = FST_VT_SV_LOGIC;
+	else if (id == id_sv_int)
+		t = FST_VT_SV_INT;
+	else if (id == id_sv_shortint)
+		t = FST_VT_SV_SHORTINT;
+	else if (id == id_sv_longint)
+		t = FST_VT_SV_LONGINT;
+	else if (id == id_sv_byte)
+		t = FST_VT_SV_BYTE;
+	else if (id == id_sv_enum)
+		t = FST_VT_SV_ENUM;
+	else if (id == id_sv_shortreal)
+		t = FST_VT_SV_SHORTREAL;
+	else 
+		rb_raise(rb_eArgError, "invalid variable type (%"PRIsVALUE"), valid variable types are :vcd_event, :vcd_integer, :vcd_parameter, :vcd_real, :vcd_real_parameter, :vcd_reg, :vcd_supply0, :vcd_supply1, :vcd_time, :vcd_tri, :vcd_triand, :vcd_trior, :vcd_trireg, :vcd_tri0, :vcd_tri1, :vcd_wand, :vcd_wire, :vcd_wor, :vcd_port, :vcd_sparray, :vcd_realtime, :gen_string, :sv_bit, :sv_logic, :sv_int, :sv_shortint, :sv_longint, :sv_byte, :sv_enum and :sv_shortreal", sym);
+
+	return t;
+}
+
+
+static enum fstVarDir symbol_to_fstVarDir(VALUE sym)
+{
+	ID id = rb_sym2id(sym);
+	enum fstVarDir d;
+	if (id == id_implicit)
+		d = FST_VD_IMPLICIT;
+	else if (id == id_input)
+		d = FST_VD_INPUT;
+	else if (id == id_output)
+		d = FST_VD_OUTPUT;
+	else if (id == id_inout)
+		d = FST_VD_INOUT;
+	else if (id == id_buffer)
+		d = FST_VD_BUFFER;
+	else if (id == id_linkage)
+		d = FST_VD_LINKAGE;
+	else
+		rb_raise(rb_eArgError, "invalid variable direction (%"PRIsVALUE"), valid values are :implicit, :input, :output, :inout, :buffer or :linkage", sym);
+	return d;
+}
+
+
+static enum fstSupplementalVarType symbol_to_fstSupplementalVarType(VALUE sym)
+{
+	ID id = rb_sym2id(sym);
+	enum fstSupplementalVarType t;
+	if (id == id_none)
+		t = FST_SVT_NONE;
+	else if (id == id_vhdl_signal)
+		t = FST_SVT_VHDL_SIGNAL;
+	else if (id == id_vhdl_variable)
+		t = FST_SVT_VHDL_VARIABLE;
+	else if (id == id_vhdl_constant)
+		t = FST_SVT_VHDL_CONSTANT;
+	else if (id == id_vhdl_file)
+		t = FST_SVT_VHDL_FILE;
+	else if (id == id_vhdl_memory)
+		t = FST_SVT_VHDL_MEMORY;
+	else
+		rb_raise(rb_eTypeError, "invalid supplemental variable type (%"PRIsVALUE"), valid values are :none, :vhdl_signal, :vhdl_variable, :vhdl_constant, :vhdl_file, :vhdl_memory", sym);
+
+	return t;
+}
+
+
+static enum fstSupplementalDataType symbol_to_fstSupplementalDataType(VALUE sym)
+{
+	ID id = rb_sym2id(sym);
+	enum fstSupplementalDataType t;
+	if (id == id_none)
+		t = FST_SDT_NONE;
+	else if (id == id_vhdl_boolean)
+		t = FST_SDT_VHDL_BOOLEAN;
+	else if (id == id_vhdl_bit)
+		t = FST_SDT_VHDL_BIT;
+	else if (id == id_vhdl_bit_vector)
+		t = FST_SDT_VHDL_BIT_VECTOR;
+	else if (id == id_vhdl_std_ulogic)
+		t = FST_SDT_VHDL_STD_ULOGIC;
+	else if (id == id_vhdl_std_ulogic_vector)
+		t = FST_SDT_VHDL_STD_ULOGIC_VECTOR;
+	else if (id == id_vhdl_std_logic)
+		t = FST_SDT_VHDL_STD_LOGIC;
+	else if (id == id_vhdl_std_logic_vector)
+		t = FST_SDT_VHDL_STD_LOGIC_VECTOR;
+	else if (id == id_vhdl_unsigned)
+		t = FST_SDT_VHDL_UNSIGNED;
+	else if (id == id_vhdl_signed)
+		t = FST_SDT_VHDL_SIGNED;
+	else if (id == id_vhdl_integer)
+		t = FST_SDT_VHDL_INTEGER;
+	else if (id == id_vhdl_real)
+		t = FST_SDT_VHDL_REAL;
+	else if (id == id_vhdl_natural)
+		t = FST_SDT_VHDL_NATURAL;
+	else if (id == id_vhdl_positive)
+		t = FST_SDT_VHDL_POSITIVE;
+	else if (id == id_vhdl_time)
+		t = FST_SDT_VHDL_TIME;
+	else if (id == id_vhdl_character)
+		t = FST_SDT_VHDL_CHARACTER;
+	else if (id == id_vhdl_string)
+		t = FST_SDT_VHDL_STRING;
+	else
+		rb_raise(rb_eTypeError, "invalid supplemental data type (%"PRIsVALUE"), valid values are :none, :vhdl_boolean, :vhdl_bit, :vhdl_bit_vector, :vhdl_std_ulogic, :vhdl_std_ulogic_vector, :vhdl_std_logic, :vhdl_std_logic_vector, :vhdl_unsigned, :vhdl_signed, :vhdl_integer, :vhdl_real, :vhdl_natural, :vhdl_positive, :vhdl_time, :vhdl_character or :vhdl_string", sym);
+	return t;
+}
+
+
+/* @return [Variable]
+ * @overload create_variable(name, type:, direction: :implicit, length: 0, alias_of: nil, sup_type_str: nil, sup_var_type: nil, sup_data_type: nil)
+ *  @param name [String]
+ *  @param type [Symbol] either `:vcd_event`, `:vcd_integer`, `:vcd_parameter`, `:vcd_real`, `:vcd_real_parameter`, `:vcd_reg`, `:vcd_supply0`, `:vcd_supply1`, `:vcd_time`, `:vcd_tri`, `:vcd_triand`, `:vcd_trior`, `:vcd_trireg`, `:vcd_tri0`, `:vcd_tri1`, `:vcd_wand`, `:vcd_wire`, `:vcd_wor`, `:vcd_port`, `:vcd_sparray`, `:vcd_realtime`, `:gen_string`, `:sv_bit`, `:sv_logic`, `:sv_int`, `:sv_shortint`, `:sv_longint`, `:sv_byte`, `:sv_enum` or `:sv_shortreal`.
+ *  @param direction [Symbol] either `:implicit`, `:input`, `:output`, `:inout`, `:buffer` or `:linkage`.
+ *  @param length [Integer]
+ *  @param alias_of [Variable,nil]
+ *  @param sup_type_str [String,nil] supplemental type string
+ *  @param sup_var_type [Symbol,nil] supplemental variable type, either `:none`, `:vhdl_signal`, `:vhdl_variable`, `:vhdl_constant`, `:vhdl_file` or `:vhdl_memory`.
+ *  @param sup_data_type [Symbol,nil] supplemental data type, either `:none`, `:vhdl_boolean`, `:vhdl_bit`, `:vhdl_bit_vector`, `:vhdl_std_ulogic`, `:vhdl_std_ulogic_vector`, `:vhdl_std_logic`, `:vhdl_std_logic_vector`, `:vhdl_unsigned`, `:vhdl_signed`, `:vhdl_integer`, `:vhdl_real`, `:vhdl_natural`, `:vhdl_positive`, `:vhdl_time`, `:vhdl_character` or `:vhdl_string`.
+ */
+static VALUE libfst_writer_create_variable(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rbname;
+	VALUE kw;
+	const ID kwkeys[7] = {id_type, id_direction, id_length, id_alias_of, id_sup_type_str, id_sup_var_type, id_sup_data_type};
+	VALUE kwvalues[7] = {Qundef, Qundef, Qundef, Qundef, Qundef, Qundef, Qundef};
+
+	const char *name = NULL;
+	enum fstVarType vt;
+	enum fstVarDir vd = FST_VD_IMPLICIT;
+	uint32_t len = 0;
+	fstHandle aliasHandle = 0;
+	const char *type = NULL;
+	enum fstSupplementalVarType svt = FST_SVT_NONE;
+	enum fstSupplementalDataType sdt = FST_SDT_NONE;
+	VALUE alias_variable = Qnil;
+
+	rb_scan_args(argc, argv, "01:", &rbname, &kw);
+	rb_get_kwargs(kw, kwkeys, 0, 7, kwvalues);
+
+	if (kwvalues[3] != Qundef && !NIL_P(kwvalues[3])) {
+		if (rb_obj_is_kind_of(kwvalues[3], c_WVariable)) {
+			alias_variable = kwvalues[3];
+			aliasHandle = rb_to_unsigned_int(rb_ivar_get(alias_variable, id_at_handle));
+		} else {
+			rb_raise(rb_eTypeError, "invalid alias, expecting a %"PRIsVALUE", not a %s", c_WVariable, rb_obj_classname(kwvalues[3]));
+		}
+		if (!NIL_P(rb_ivar_get(alias_variable, id_at_alias_of)))
+			rb_raise(rb_eRuntimeError, "do not alias a %"PRIsVALUE" which already is an alias for another %"PRIsVALUE, c_WVariable, c_WVariable); 
+		if (rb_ivar_get(alias_variable, id_at_writer) != self)
+			rb_raise(rb_eRuntimeError, "cannot alias a variable of another %s", rb_obj_classname(self));
+	}
+
+	if (!NIL_P(rbname)) {
+		name = rb_string_value_cstr(&rbname);
+	} else if (!NIL_P(alias_variable)) {
+		rbname = rb_ivar_get(alias_variable, id_at_name);
+		name = rb_string_value_cstr(&rbname);
+	} else {
+		rb_raise(rb_eArgError, "wrong number of arguments (given 0, expected 1)");
+	}
+
+
+	if (kwvalues[0] != Qundef && !NIL_P(kwvalues[0]))
+		vt = symbol_to_fstVarType(kwvalues[0]);
+	else if (!NIL_P(alias_variable))
+		vt = symbol_to_fstVarType(rb_ivar_get(alias_variable, id_at_type));
+	else
+		rb_raise(rb_eArgError, "missing keyword: :type");
+
+	if (kwvalues[1] != Qundef && !NIL_P(kwvalues[1]))
+		vd = symbol_to_fstVarDir(kwvalues[1]);
+	else if (alias_variable != Qnil)
+		vd = symbol_to_fstVarDir(rb_ivar_get(alias_variable, id_at_direction));
+
+	if (kwvalues[2] != Qundef && !NIL_P(kwvalues[2]))
+		len = rb_to_unsigned_int(kwvalues[2]);
+	else if (alias_variable != Qnil)
+		len = rb_to_unsigned_int(rb_ivar_get(alias_variable, id_at_length));
+
+	if (kwvalues[4] != Qundef && !NIL_P(kwvalues[4])) {
+		type = rb_string_value_cstr(&kwvalues[4]);
+	} else if (alias_variable != Qnil && rb_ivar_get(alias_variable, id_at_sup_type_str) != Qnil) {
+		kwvalues[4] = rb_ivar_get(alias_variable, id_at_sup_type_str);
+		type = rb_string_value_cstr(&kwvalues[4]);
+	}
+
+	if (kwvalues[5] != Qundef && !NIL_P(kwvalues[5])) {
+		svt = symbol_to_fstSupplementalVarType(kwvalues[5]);
+	} else if (alias_variable != Qnil && rb_ivar_get(alias_variable, id_at_sup_var_type) != Qnil) {
+		kwvalues[5] = rb_ivar_get(alias_variable, id_at_sup_var_type);
+		svt = symbol_to_fstSupplementalVarType(kwvalues[5]);
+	}
+
+	if (kwvalues[6] != Qundef && !NIL_P(kwvalues[6])) {
+		sdt = symbol_to_fstSupplementalDataType(kwvalues[6]);
+	} else if (alias_variable != Qnil && rb_ivar_get(alias_variable, id_at_sup_data_type) != Qnil) {
+		kwvalues[6] = rb_ivar_get(alias_variable, id_at_sup_data_type);
+		sdt = symbol_to_fstSupplementalDataType(kwvalues[6]);
+	}
+
+	switch (vt) {
+		case FST_VT_SV_INT:       /* declare as size = 32 */
+			len = 32;
+			break;
+		case FST_VT_SV_SHORTINT:  /* declare as size = 16 */
+			len = 16;
+			break;
+		case FST_VT_SV_LONGINT:   /* declare as size = 64 */
+			len = 64;
+			break;
+		case FST_VT_SV_BYTE:      /* declare as size = 8  */
+			len = 8;
+			break;
+		case FST_VT_GEN_STRING:   /* generic string type   (max len is defined dynamically via fstWriterEmitVariableLengthValueChange) */
+			len = 0;
+			break;
+		case FST_VT_VCD_EVENT:
+			len = 1;
+			break;
+
+		case FST_VT_VCD_INTEGER:
+		case FST_VT_VCD_PARAMETER:
+			if (len == 0)
+				len = 32;
+			break;
+
+		case FST_VT_VCD_SUPPLY0:
+		case FST_VT_VCD_SUPPLY1:
+		case FST_VT_VCD_TIME:
+		case FST_VT_VCD_TRI:
+		case FST_VT_VCD_TRIAND:
+		case FST_VT_VCD_TRIOR:
+		case FST_VT_VCD_TRIREG:
+		case FST_VT_VCD_TRI0:
+		case FST_VT_VCD_TRI1:
+		case FST_VT_VCD_WAND:
+		case FST_VT_VCD_WOR:
+		case FST_VT_VCD_PORT:
+		case FST_VT_VCD_SPARRAY:
+
+		case FST_VT_VCD_WIRE:
+		case FST_VT_VCD_REG:
+		case FST_VT_SV_BIT:
+		case FST_VT_SV_LOGIC:
+			if (len == 0)
+				len = 1;
+			break;
+
+
+		case FST_VT_VCD_REAL:
+		case FST_VT_VCD_REAL_PARAMETER:
+		case FST_VT_VCD_REALTIME:
+		case FST_VT_SV_SHORTREAL: /* declare and emit same as FST_VT_VCD_REAL (needs to be emitted as double, not a float) */
+			len = 8; /* recast number of bytes to that of what a double is */
+			break;
+
+//		case FST_VT_SV_ENUM:      /* declare as appropriate type range */
+
+		default:
+			break;
+	}
+
+
+	fstHandle var = 0;
+	void *ctx = libfst_writer_from_rbobj(self);
+	if (type == NULL && svt == FST_SVT_NONE && sdt == FST_SDT_NONE)
+		var = fstWriterCreateVar(ctx, vt, vd, len, name, aliasHandle);
+	else
+		var = fstWriterCreateVar2(ctx, vt, vd, len, name, aliasHandle, type, svt, sdt);
+
+	VALUE args[10];
+	args[0] = ULONG2NUM(var);           // handle
+	args[1] = self;                     // writer
+	args[2] = rbname;                   // name
+	args[3] = fstVarType_to_symbol(vt); // type
+	args[4] = fstVarDir_to_symbol(vd);  // direction
+	args[5] = ULONG2NUM(len);           // length
+	args[6] = alias_variable;           // alias
+	args[7] = (kwvalues[4] != Qundef ? kwvalues[4] : Qnil); // sup_type_str
+	args[8] = (kwvalues[5] != Qundef ? kwvalues[5] : Qnil); // sup_var_type
+	args[9] = (kwvalues[6] != Qundef ? kwvalues[6] : Qnil); // sup_data_type
+	VALUE variable = rb_class_new_instance(10, args, c_WVariable);
+	rb_ary_push(rb_ivar_get(self, id_at_variables), variable);
+
+	return variable;
+}
+
+
+/* Use this method to emit a value change of a variable of known size (`length` different from 0 in {#create_variable}).
+ *
+ * `data.bytesize` must match the `length` parameter of the variable creation.
+ * @param handle [Integer] handle of a variable
+ * @param data [String]
+ * @return [self]
+ */
+static VALUE libfst_writer_emit_value_change(VALUE self, VALUE handle, VALUE data)
+{
+	fstHandle hndl = rb_to_unsigned_int(handle);
+	const char *dt = rb_string_value_ptr(&data);
+	void *ctx = libfst_writer_from_rbobj(self);
+	fstWriterEmitValueChange(ctx, hndl, dt);
+	return self;
+}
+
+
+/* @!visibility private
+ */
+static VALUE libfst_writervariable_initialize(VALUE self, VALUE handle, VALUE writer, VALUE name, VALUE type, VALUE direction, VALUE length, VALUE alias, VALUE sup_type_str, VALUE sup_var_type, VALUE sup_data_type)
+{
+	rb_ivar_set(self, id_at_handle,    handle);
+	rb_ivar_set(self, id_at_writer,    writer);
+	rb_ivar_set(self, id_at_name,      name);
+	rb_ivar_set(self, id_at_type,      type);
+	rb_ivar_set(self, id_at_direction, direction);
+	rb_ivar_set(self, id_at_length,    length);
+	if (!NIL_P(alias))
+		rb_ivar_set(self, id_at_alias_of, alias);
+	if (!NIL_P(sup_type_str))
+		rb_ivar_set(self, id_at_sup_type_str, sup_type_str);
+	if (!NIL_P(sup_var_type))
+		rb_ivar_set(self, id_at_sup_var_type, sup_var_type);
+	if (!NIL_P(sup_data_type))
+		rb_ivar_set(self, id_at_sup_data_type, sup_data_type);
+	return self;
+}
+
+
+static void libfst_writer_emit_string(VALUE variable, VALUE str)
+{
+	void *ctx = libfst_writer_from_rbobj(rb_ivar_get(variable, id_at_writer));
+	fstHandle handle = NUM2ULONG(rb_ivar_get(variable, id_at_handle));
+	if (!RB_TYPE_P(str, T_STRING))
+		str = rb_funcallv(str, id_to_s, 0, NULL);
+	const char *ptr = rb_string_value_ptr(&str);
+	long len = RSTRING_LEN(str);
+	fstWriterEmitVariableLengthValueChange(ctx, handle, ptr, len);
+}
+
+
+static void libfst_writer_emit_event(VALUE variable)
+{
+	void *ctx = libfst_writer_from_rbobj(rb_ivar_get(variable, id_at_writer));
+	char buf[] = "1";
+	fstHandle handle = NUM2ULONG(rb_ivar_get(variable, id_at_handle));
+	fstWriterEmitValueChange(ctx, handle, buf);
+}
+
+
+static void libfst_writer_emit_float(VALUE variable, VALUE flt)
+{
+	void *ctx = libfst_writer_from_rbobj(rb_ivar_get(variable, id_at_writer));
+	fstHandle handle = NUM2ULONG(rb_ivar_get(variable, id_at_handle));
+	if (!RB_FLOAT_TYPE_P(flt))
+		flt = rb_funcallv(flt, id_to_f, 0, NULL);
+	double d = NUM2DBL(flt);
+	fstWriterEmitValueChange(ctx, handle, &d);
+}
+
+
+static void libfst_writer_emit_integer(VALUE variable, VALUE intg)
+{
+	void *ctx = libfst_writer_from_rbobj(rb_ivar_get(variable, id_at_writer));
+	fstHandle handle = NUM2ULONG(rb_ivar_get(variable, id_at_handle));
+	int len = NUM2INT(rb_ivar_get(variable, id_at_length));
+	if (len < 1 || len > 65536)
+		rb_raise(rb_eRuntimeError, "Variable's length is strange: %d", len);
+	if (!RB_INTEGER_TYPE_P(intg))
+		intg = rb_funcallv(intg, id_to_i, 1, &intg);
+
+	if (len <= 32) {
+		int64_t l = NUM2LL(intg);
+		fstWriterEmitValueChange32(ctx, handle, len, l);
+	} else if (len <= 63) {
+		uint64_t l = NUM2LL(intg);
+		fstWriterEmitValueChange64(ctx, handle, len, l);
+	} else {
+		/* s = intg.to_s(2).rjust(len, '0')
+		 */
+		VALUE args[3];
+		args[0] = INT2NUM(2);
+		args[1] = INT2NUM(len);
+		args[2] = rb_sprintf("0");
+		VALUE s = rb_funcallv(intg, id_to_s, 1, args);
+		VALUE t = rb_funcallv(s, id_rjust, 2, &args[1]);
+		const char *ptr = rb_string_value_ptr(&t);
+		fstWriterEmitValueChange(ctx, handle, ptr);
+	}
+}
+
+
+static void libfst_writer_emit_logic(VALUE variable, VALUE logic)
+{
+	void *ctx = libfst_writer_from_rbobj(rb_ivar_get(variable, id_at_writer));
+	fstHandle handle = NUM2ULONG(rb_ivar_get(variable, id_at_handle));
+	if (RB_INTEGER_TYPE_P(logic)) {
+		libfst_writer_emit_integer(variable, logic);
+	} else if (NIL_P(logic)) {
+		VALUE u = rb_sprintf("u");
+		VALUE f = rb_ivar_get(variable, id_at_length);
+		VALUE s = rb_funcallv(u, id_symbol_star, 1, &f);
+		const char *ptr = rb_string_value_ptr(&s);
+		fstWriterEmitValueChange(ctx, handle, ptr);
+	} else {
+		VALUE s = rb_funcallv(logic, id_to_s, 0, NULL);
+		VALUE len = rb_ivar_get(variable, id_at_length);
+		int vlength = NUM2INT(len);
+		int slength = RSTRING_LEN(s);
+		if (slength < vlength) {
+			VALUE args[2];
+			args[0] = len;
+			args[1] = rb_sprintf("u");
+			s = rb_funcallv(s, id_rjust, 2, args);
+		} else if (slength > vlength) {
+			s = rb_str_substr(s, -vlength, vlength);
+		}
+		const char *ptr = rb_string_value_ptr(&s);
+		fstWriterEmitValueChange(ctx, handle, ptr);
+	}
+}
+
+
+/* Emit the given value.
+ * @param value [String,Integer,Float,nil]
+ * @return [Object] value
+ */
+static VALUE libfst_writervariable_emit_value(VALUE self, VALUE value)
+{
+	VALUE rbtype = rb_ivar_get(self, id_at_type);
+	enum fstVarType type = symbol_to_fstVarType(rbtype);
+	switch (type) {
+		case FST_VT_VCD_REG:
+		case FST_VT_VCD_SUPPLY0:
+		case FST_VT_VCD_SUPPLY1:
+		case FST_VT_VCD_TRI:
+		case FST_VT_VCD_TRIAND:
+		case FST_VT_VCD_TRIOR:
+		case FST_VT_VCD_TRIREG:
+		case FST_VT_VCD_TRI0:
+		case FST_VT_VCD_TRI1:
+		case FST_VT_VCD_WAND:
+		case FST_VT_VCD_WIRE:
+		case FST_VT_VCD_WOR:
+		case FST_VT_VCD_PORT:
+		case FST_VT_VCD_SPARRAY:
+		case FST_VT_SV_BIT:
+		case FST_VT_SV_LOGIC:
+			libfst_writer_emit_logic(self, value);
+			break;
+
+		case FST_VT_VCD_REAL:
+		case FST_VT_VCD_REAL_PARAMETER:
+		case FST_VT_VCD_REALTIME:
+		case FST_VT_SV_SHORTREAL:
+			libfst_writer_emit_float(self, value);
+			break;
+
+		case FST_VT_VCD_INTEGER:
+		case FST_VT_VCD_PARAMETER:
+		case FST_VT_SV_INT:
+		case FST_VT_SV_SHORTINT:
+		case FST_VT_SV_LONGINT:
+		case FST_VT_SV_BYTE:
+		case FST_VT_VCD_TIME:
+			libfst_writer_emit_integer(self, value);
+			break;
+
+		case FST_VT_GEN_STRING:
+			libfst_writer_emit_string(self, value);
+			break;
+
+		case FST_VT_VCD_EVENT:
+			libfst_writer_emit_event(self);
+			break;
+
+		case FST_VT_SV_ENUM:
+			rb_raise(rb_eRuntimeError, "Sorry, I dont know how to handle enums =(");
+			break;
+
+		default:
+			rb_raise(rb_eRuntimeError, "%s has invalid @type (%"PRIsVALUE")", rb_obj_classname(self), rbtype);
+	}
+	rb_ivar_set(self, id_at_value, value);
+	return value;
+}
+
+
+/* Return the last set value.
+ * @return [Object]
+ */
+static VALUE libfst_writervariable_get_value(VALUE self)
+{
+	return rb_ivar_get(self, id_at_value);
+}
+
+
+#ifdef TARZAN_LA_BANANE
+fstEnumHandle fstWriterCreateEnumTable(void *ctx, const char *name, uint32_t elem_count, unsigned int min_valbits, const char **literal_arr, const char **val_arr);
+void fstWriterEmitEnumTableRef(void *ctx, fstEnumHandle handle);
+
+void fstWriterEmitValueChange32(void *ctx, fstHandle handle, uint32_t bits, uint32_t val);
+void fstWriterEmitValueChange64(void *ctx, fstHandle handle, uint32_t bits, uint64_t val);
+void fstWriterEmitValueChangeVec32(void *ctx, fstHandle handle, uint32_t bits, const uint32_t *val);
+void fstWriterEmitValueChangeVec64(void *ctx, fstHandle handle, uint32_t bits, const uint64_t *val);
+#endif
+
+
+void Init_libfst(void)
+{
+	id_at_alias_of            = rb_intern("@alias_of");
+	id_at_direction           = rb_intern("@direction");
+	id_at_filename            = rb_intern("@filename");
+	id_at_handle              = rb_intern("@handle");
+	id_at_is_float            = rb_intern("@is_float");
+	id_at_length              = rb_intern("@length");
+	id_at_name                = rb_intern("@name");
+	id_at_sup_data_type       = rb_intern("@sup_data_type");
+	id_at_sup_type_str        = rb_intern("@sup_type_str");
+	id_at_sup_var_type        = rb_intern("@sup_var_type");
+	id_at_trace               = rb_intern("@trace");
+	id_at_traces              = rb_intern("@traces");
+	id_at_type                = rb_intern("@type");
+	id_at_value               = rb_intern("@value");
+	id_at_variables           = rb_intern("@variables");
+	id_at_writer              = rb_intern("@writer");
+	id_to_s                   = rb_intern("to_s");
+	id_to_f                   = rb_intern("to_f");
+	id_to_i                   = rb_intern("to_i");
+	id_rjust                  = rb_intern("rjust");
+	id_compress_hier          = rb_intern("compress_hier");
+	id_delete                 = rb_intern("delete");
+	id_name                   = rb_intern("name");
+	id_component              = rb_intern("component");
+	id_symbol_plus            = rb_intern("+");
+	id_symbol_star            = rb_intern("*");
+	id_symbol_more            = rb_intern(">");
+	id_expand_path            = rb_intern("expand_path");
+	id_start_time             = rb_intern("start_time");
+	id_end_time               = rb_intern("end_time");
+	id_verilog                = rb_intern("verilog");
+	id_vhdl                   = rb_intern("vhdl");
+	id_verilog_or_vhdl        = rb_intern("verilog_or_vhdl");
+	id_vcd_module             = rb_intern("vcd_module");
+	id_vcd_task               = rb_intern("vcd_task");
+	id_vcd_function           = rb_intern("vcd_function");
+	id_vcd_begin              = rb_intern("vcd_begin");
+	id_vcd_fork               = rb_intern("vcd_fork");
+	id_vcd_generate           = rb_intern("vcd_generate");
+	id_vcd_struct             = rb_intern("vcd_struct");
+	id_vcd_union              = rb_intern("vcd_union");
+	id_vcd_class              = rb_intern("vcd_class");
+	id_vcd_interface          = rb_intern("vcd_interface");
+	id_vcd_package            = rb_intern("vcd_package");
+	id_vcd_program            = rb_intern("vcd_program");
+	id_vhdl_architecture      = rb_intern("vhdl_architecture");
+	id_vhdl_procedure         = rb_intern("vhdl_procedure");
+	id_vhdl_function          = rb_intern("vhdl_function");
+	id_vhdl_record            = rb_intern("vhdl_record");
+	id_vhdl_process           = rb_intern("vhdl_process");
+	id_vhdl_block             = rb_intern("vhdl_block");
+	id_vhdl_for_generate      = rb_intern("vhdl_for_generate");
+	id_vhdl_if_generate       = rb_intern("vhdl_if_generate");
+	id_vhdl_generate          = rb_intern("vhdl_generate");
+	id_vhdl_package           = rb_intern("vhdl_package");
+	id_vcd_event              = rb_intern("vcd_event");
+	id_vcd_integer            = rb_intern("vcd_integer");
+	id_vcd_parameter          = rb_intern("vcd_parameter");
+	id_vcd_real               = rb_intern("vcd_real");
+	id_vcd_real_parameter     = rb_intern("vcd_real_parameter");
+	id_vcd_reg                = rb_intern("vcd_reg");
+	id_vcd_supply0            = rb_intern("vcd_supply0");
+	id_vcd_supply1            = rb_intern("vcd_supply1");
+	id_vcd_time               = rb_intern("vcd_time");
+	id_vcd_tri                = rb_intern("vcd_tri");
+	id_vcd_triand             = rb_intern("vcd_triand");
+	id_vcd_trior              = rb_intern("vcd_trior");
+	id_vcd_trireg             = rb_intern("vcd_trireg");
+	id_vcd_tri0               = rb_intern("vcd_tri0");
+	id_vcd_tri1               = rb_intern("vcd_tri1");
+	id_vcd_wand               = rb_intern("vcd_wand");
+	id_vcd_wire               = rb_intern("vcd_wire");
+	id_vcd_wor                = rb_intern("vcd_wor");
+	id_vcd_port               = rb_intern("vcd_port");
+	id_vcd_sparray            = rb_intern("vcd_sparray");
+	id_vcd_realtime           = rb_intern("vcd_realtime");
+	id_gen_string             = rb_intern("gen_string");
+	id_sv_bit                 = rb_intern("sv_bit");
+	id_sv_logic               = rb_intern("sv_logic");
+	id_sv_int                 = rb_intern("sv_int");
+	id_sv_shortint            = rb_intern("sv_shortint");
+	id_sv_longint             = rb_intern("sv_longint");
+	id_sv_byte                = rb_intern("sv_byte");
+	id_sv_enum                = rb_intern("sv_enum");
+	id_sv_shortreal           = rb_intern("sv_shortreal");
+	id_implicit               = rb_intern("implicit");
+	id_input                  = rb_intern("input");
+	id_output                 = rb_intern("output");
+	id_inout                  = rb_intern("inout");
+	id_buffer                 = rb_intern("buffer");
+	id_linkage                = rb_intern("linkage");
+	id_misc                   = rb_intern("misc");
+	id_array                  = rb_intern("array");
+	id_enum                   = rb_intern("enum");
+	id_pack                   = rb_intern("pack");
+	id_comment                = rb_intern("comment");
+	id_envvar                 = rb_intern("envvar");
+	id_supvar                 = rb_intern("supvar");
+	id_pathname               = rb_intern("pathname");
+	id_sourcestem             = rb_intern("sourcestem");
+	id_sourceistem            = rb_intern("sourceistem");
+	id_valuelist              = rb_intern("valuelist");
+	id_enumtable              = rb_intern("enumtable");
+	id_unknown                = rb_intern("unknown");
+	id_unpacked               = rb_intern("unpacked");
+	id_packed                 = rb_intern("packed");
+	id_sparse                 = rb_intern("sparse");
+	id_integer                = rb_intern("integer");
+	id_bit                    = rb_intern("bit");
+	id_logic                  = rb_intern("logic");
+	id_int                    = rb_intern("int");
+	id_shortint               = rb_intern("shortint");
+	id_longint                = rb_intern("longint");
+	id_byte                   = rb_intern("byte");
+	id_unsigned_integer       = rb_intern("unsigned_integer");
+	id_unsigned_bit           = rb_intern("unsigned_bit");
+	id_unsigned_logic         = rb_intern("unsigned_logic");
+	id_unsigned_int           = rb_intern("unsigned_int");
+	id_unsigned_shortint      = rb_intern("unsigned_shortint");
+	id_unsigned_longint       = rb_intern("unsigned_longint");
+	id_unsigned_byte          = rb_intern("unsigned_byte");
+	id_reg                    = rb_intern("reg");
+	id_time                   = rb_intern("time");
+	id_none                   = rb_intern("none");
+	id_tagged_packed          = rb_intern("tagged_packed");
+	id_upscope                = rb_intern("upscope");
+	id_attrend                = rb_intern("attrend");
+	id_zlib                   = rb_intern("zlib");
+	id_fastlz                 = rb_intern("fastlz");
+	id_lz4                    = rb_intern("lz4");
+	id_s                      = rb_intern("s");
+	id_ms                     = rb_intern("ms");
+	id_us                     = rb_intern("us");
+	id_ns                     = rb_intern("ns");
+	id_ps                     = rb_intern("ps");
+	id_fs                     = rb_intern("fs");
+	id_type                   = rb_intern("type");
+	id_subtype                = rb_intern("subtype");
+	id_arg                    = rb_intern("arg");
+	id_use_realpath           = rb_intern("use_realpath");
+	id_vhdl_signal            = rb_intern("vhdl_signal");
+	id_vhdl_variable          = rb_intern("vhdl_variable");
+	id_vhdl_constant          = rb_intern("vhdl_constant");
+	id_vhdl_file              = rb_intern("vhdl_file");
+	id_vhdl_memory            = rb_intern("vhdl_memory");
+	id_vhdl_boolean           = rb_intern("vhdl_boolean");
+	id_vhdl_bit               = rb_intern("vhdl_bit");
+	id_vhdl_bit_vector        = rb_intern("vhdl_bit_vector");
+	id_vhdl_std_ulogic        = rb_intern("vhdl_std_ulogic");
+	id_vhdl_std_ulogic_vector = rb_intern("vhdl_std_ulogic_vector");
+	id_vhdl_std_logic         = rb_intern("vhdl_std_logic");
+	id_vhdl_std_logic_vector  = rb_intern("vhdl_std_logic_vector");
+	id_vhdl_unsigned          = rb_intern("vhdl_unsigned");
+	id_vhdl_signed            = rb_intern("vhdl_signed");
+	id_vhdl_integer           = rb_intern("vhdl_integer");
+	id_vhdl_real              = rb_intern("vhdl_real");
+	id_vhdl_natural           = rb_intern("vhdl_natural");
+	id_vhdl_positive          = rb_intern("vhdl_positive");
+	id_vhdl_time              = rb_intern("vhdl_time");
+	id_vhdl_character         = rb_intern("vhdl_character");
+	id_vhdl_string            = rb_intern("vhdl_string");
+	id_direction              = rb_intern("direction");
+	id_length                 = rb_intern("length");
+	id_alias_of               = rb_intern("alias_of");
+	id_sup_type_str           = rb_intern("sup_type_str");
+	id_sup_var_type           = rb_intern("sup_var_type");
+	id_sup_data_type          = rb_intern("sup_data_type");
+
+
+	m_LibFST = rb_define_module("LibFST");
+
+	c_Reader = rb_define_class_under(m_LibFST, "Reader", rb_cObject);
+	rb_define_alloc_func(c_Reader, libfst_reader_alloc);
+	rb_undef_method(rb_class_of(c_Reader), "allocate");
+	rb_define_protected_method(c_Reader, "open",               libfst_reader_open,                         1);
+	rb_define_method(c_Reader, "iterate_hier",                 libfst_reader_iterate_hier,                 0);
+	rb_define_method(c_Reader, "iterate_hier_rewind",          libfst_reader_iterate_hier_rewind,          0);
+	rb_define_method(c_Reader, "current_scope_length",         libfst_reader_current_scope_length,         0);
+	rb_define_method(c_Reader, "current_flat_scope",           libfst_reader_current_flat_scope,           0);
+	rb_define_method(c_Reader, "pop_scope",                    libfst_reader_pop_scope,                    0);
+	rb_define_method(c_Reader, "reset_scope",                  libfst_reader_reset_scope,                  0);
+	rb_define_method(c_Reader, "push_scope",                   libfst_reader_push_scope,                  -1);
+	rb_define_method(c_Reader, "fseek_failed?",                libfst_reader_fseek_failed,                 0);
+	rb_define_method(c_Reader, "date_string",                  libfst_reader_date_string,                  0);
+	rb_define_method(c_Reader, "version_string",               libfst_reader_version_string,               0);
+	rb_define_method(c_Reader, "file_type",                    libfst_reader_file_type,                    0);
+	rb_define_method(c_Reader, "time_scale",                   libfst_reader_time_scale,                   0);
+	rb_define_method(c_Reader, "time_scale_exponent",          libfst_reader_time_scale_exponent,          0);
+	rb_define_method(c_Reader, "start_time",                   libfst_reader_start_time,                   0);
+	rb_define_method(c_Reader, "end_time",                     libfst_reader_end_time,                     0);
+	rb_define_method(c_Reader, "time_zero",                    libfst_reader_time_zero,                    0);
+	rb_define_method(c_Reader, "var_count",                    libfst_reader_var_count,                    0);
+	rb_define_method(c_Reader, "scope_count",                  libfst_reader_scope_count,                  0);
+	rb_define_method(c_Reader, "alias_count",                  libfst_reader_alias_count,                  0);
+	rb_define_method(c_Reader, "max_handle",                   libfst_reader_max_handle,                   0);
+	rb_define_method(c_Reader, "value_change_section_count",   libfst_reader_value_change_section_count,   0);
+	rb_define_method(c_Reader, "memory_used_by_writer",        libfst_reader_memory_used_by_writer,        0);
+	rb_define_method(c_Reader, "double_endian_match_state?",   libfst_reader_double_endian_match_state,    0);
+	rb_define_method(c_Reader, "number_dump_activity_changes", libfst_reader_number_dump_activity_changes, 0);
+	rb_define_method(c_Reader, "dump_activity_change_time",    libfst_reader_dump_activity_change_time,    1);
+	rb_define_method(c_Reader, "dump_activity_change_value",   libfst_reader_dump_activity_change_value,   1);
+	rb_define_method(c_Reader, "read",                         libfst_reader_read,                        -1);
+
+	c_RScope     = rb_define_class_under(c_Reader, "Scope",     rb_cObject);
+	c_RVariable  = rb_define_class_under(c_Reader, "Variable",  rb_cObject);
+	c_RAttribute = rb_define_class_under(c_Reader, "Attribute", rb_cObject);
+	c_RTrace     = rb_define_class_under(c_Reader, "Trace",     rb_cObject); 
+
+	rb_undef_method(rb_class_of(c_RVariable),  "new");
+	rb_undef_method(rb_class_of(c_RAttribute), "new");
+
+
+	c_Writer = rb_define_class_under(m_LibFST, "Writer", rb_cObject);
+	rb_define_alloc_func(c_Writer, libfst_writer_alloc);
+	rb_undef_method(rb_class_of(c_Writer), "allocate");
+	rb_define_method(c_Writer, "initialize", libfst_writer_initialize, -1);
+	rb_define_method(c_Writer, "close",      libfst_writer_close,       0);
+	rb_define_attr(c_Writer,   "filename",  1, 0); // @return [String]
+	rb_define_attr(c_Writer,   "variables", 1, 0); // @return [Array<Variable>]
+	rb_define_method(c_Writer, "set_date_string",     libfst_writer_set_date_string,      1);
+	rb_define_method(c_Writer, "set_version_string",  libfst_writer_set_version_string,   1);
+	rb_define_method(c_Writer, "set_time_zero",       libfst_writer_set_time_zero,        1);
+	rb_define_method(c_Writer, "set_time_scale",      libfst_writer_set_time_scale,       1);
+	rb_define_method(c_Writer, "set_file_type",       libfst_writer_set_file_type,        1);
+	rb_define_method(c_Writer, "set_pack_type",       libfst_writer_set_pack_type,        1);
+	rb_define_method(c_Writer, "set_comment",         libfst_writer_set_comment,          1);
+	rb_define_method(c_Writer, "set_envvar",          libfst_writer_set_envvar,           1);
+	rb_define_method(c_Writer, "set_value_list",      libfst_writer_set_value_list,       1);
+	rb_define_method(c_Writer, "set_attribute_begin", libfst_writer_set_attribute_begin, -1);
+	rb_define_method(c_Writer, "set_attribute_end",   libfst_writer_set_attribute_end,    0);
+	rb_define_method(c_Writer, "set_scope",           libfst_writer_set_scope,           -1);
+	rb_define_method(c_Writer, "set_upscope",         libfst_writer_set_upscope,          0);
+	rb_define_method(c_Writer, "set_source_stem",     libfst_writer_set_source_stem,     -1);
+	rb_define_method(c_Writer, "set_source_instantiation_stem", libfst_writer_set_source_instantiation_stem, -1);
+	rb_define_method(c_Writer, "create_variable",     libfst_writer_create_variable,     -1);
+	rb_define_method(c_Writer, "emit_time_change",    libfst_writer_emit_time_change,     1);
+	rb_define_method(c_Writer, "emit_value_change",   libfst_writer_emit_value_change,    2);
+
+	rb_define_method(c_Writer, "emit_dump_active",    libfst_writer_emit_dump_active,     1);
+	rb_define_method(c_Writer, "fseek_failed?",            libfst_writer_fseek_failed,            0);
+	rb_define_method(c_Writer, "dump_size_limit_reached?", libfst_writer_dump_size_limit_reached, 0);
+	rb_define_method(c_Writer, "set_dump_size_limit",      libfst_writer_set_dump_size_limit,     1);
+	rb_define_method(c_Writer, "set_use_parallel_mode",    libfst_writer_set_use_parallel_mode,   1);
+	rb_define_method(c_Writer, "set_repack_on_close",      libfst_writer_set_repack_on_close,     1);
+	rb_define_method(c_Writer, "flush_context",            libfst_writer_flush_context,           0);
+
+	c_WVariable = rb_define_class_under(c_Writer, "Variable", rb_cObject);
+	rb_undef_method(rb_class_of(c_WVariable), "new");
+	rb_define_method(c_WVariable, "initialize", libfst_writervariable_initialize, 10);
+	rb_define_method(c_WVariable, "value=",     libfst_writervariable_emit_value,  1);
+	rb_define_method(c_WVariable, "value",      libfst_writervariable_get_value,   0);
+	rb_define_attr(c_WVariable, "handle",        1, 0); // @return [Integer]
+	rb_define_attr(c_WVariable, "writer",        1, 0); // @return [Writer]
+	rb_define_attr(c_WVariable, "name",          1, 0); // @return [String]
+	rb_define_attr(c_WVariable, "type",          1, 0); // @return [Symbol] either `:vcd_event`, `:vcd_integer`, `:vcd_parameter`, `:vcd_real`, `:vcd_real_parameter`, `:vcd_reg`, `:vcd_supply0`, `:vcd_supply1`, `:vcd_time`, `:vcd_tri`, `:vcd_triand`, `:vcd_trior`, `:vcd_trireg`, `:vcd_tri0`, `:vcd_tri1`, `:vcd_wand`, `:vcd_wire`, `:vcd_wor`, `:vcd_port`, `:vcd_sparray`, `:vcd_realtime`, `:gen_string`, `:sv_bit`, `:sv_logic`, `:sv_int`, `:sv_shortint`, `:sv_longint`, `:sv_byte`, `:sv_enum` or `:sv_shortreal`
+	rb_define_attr(c_WVariable, "direction",     1, 0); // @return [Symbol] either `:implicit`, `:input`, `:output`, `:inout`, `:buffer` or `:linkage`
+	rb_define_attr(c_WVariable, "length",        1, 0); // @return [Integer]
+	rb_define_attr(c_WVariable, "alias_of",      1, 0); // @return [Variable,nil]
+	rb_define_attr(c_WVariable, "sup_type_str",  1, 0); // @return [String,nil] supplemental type string
+	rb_define_attr(c_WVariable, "sup_var_type",  1, 0); // @return [Symbol,nil] supplemental variable type, either `:none`, `:vhdl_signal`, `:vhdl_variable`, `:vhdl_constant`, `:vhdl_file` or `:vhdl_memory`
+	rb_define_attr(c_WVariable, "sup_data_type", 1, 0); // @return [Symbol,nil] supplemental data type, either `:none`, `:vhdl_boolean`, `:vhdl_bit`, `:vhdl_bit_vector`, `:vhdl_std_ulogic`, `:vhdl_std_ulogic_vector`, `:vhdl_std_logic`, `:vhdl_std_logic_vector`, `:vhdl_unsigned`, `:vhdl_signed`, `:vhdl_integer`, `:vhdl_real`, `:vhdl_natural`, `:vhdl_positive`, `:vhdl_time`, `:vhdl_character` or `:vhdl_string`
+
+}
+
+