From: fennecdjay Date: Sun, 7 Jul 2019 23:33:44 +0000 (+0200) Subject: :white_check_mark: Yet more tests. Yet again X-Git-Tag: nightly~2348^2~25 X-Git-Url: http://10.10.0.4:5575/?a=commitdiff_plain;h=refs%2Fpull%2F143%2Fhead;p=gwion.git :white_check_mark: Yet more tests. Yet again --- diff --git a/examples/implicit_ptr.gw b/examples/implicit_ptr.gw new file mode 100644 index 00000000..139cc991 --- /dev/null +++ b/examples/implicit_ptr.gw @@ -0,0 +1,4 @@ +fun void test(<~int~>Ptr pi) { + <<< *pi >>>; +} +int i => test; diff --git a/examples/int.gw b/examples/int.gw index 82d8f3a5..e9d4db81 100644 --- a/examples/int.gw +++ b/examples/int.gw @@ -2,12 +2,6 @@ int a; -#!testing operator for int and int -{ - int variable1; - int variable2; -<<< variable1=variable2 >>>; -} #!testing operator for int and int { int variable1; diff --git a/examples/ptr_assign.gw b/examples/ptr_assign.gw new file mode 100644 index 00000000..c111c467 --- /dev/null +++ b/examples/ptr_assign.gw @@ -0,0 +1,6 @@ +class C { +} +class D extends C { +} +D d; +d :=> <~C~>Ptr pd; diff --git a/examples/ptr_cast.gw b/examples/ptr_cast.gw new file mode 100644 index 00000000..27c17a32 --- /dev/null +++ b/examples/ptr_cast.gw @@ -0,0 +1,2 @@ +12 => int i; +<<Ptr >>>; diff --git a/examples/ptr_deref.gw b/examples/ptr_deref.gw new file mode 100644 index 00000000..e79165e6 --- /dev/null +++ b/examples/ptr_deref.gw @@ -0,0 +1,3 @@ +int i; +i :=> <~int~>Ptr pi; +<<<12 => *pi, " ", *pi>>>; diff --git a/examples/trig.gw b/examples/trig.gw index e3d1dac0..17485386 100644 --- a/examples/trig.gw +++ b/examples/trig.gw @@ -1,3 +1,3 @@ -SinOsc s ]=> Dtrig dtrig => blackhole; +SinOsc s :=> Dtrig dtrig => blackhole; second => now; s ]=< dtrig; diff --git a/examples/vec3.gw b/examples/vec3.gw index 97582e62..a1c1a201 100644 --- a/examples/vec3.gw +++ b/examples/vec3.gw @@ -1,5 +1,11 @@ Vec3 v, w; +<<< v + w >>>; +<<< v - w >>>; +<<< v * w >>>; +<<< v / w >>>; + + <<< v.x >>>; <<< v.y >>>; <<< v.z >>>; diff --git a/examples/vec4.gw b/examples/vec4.gw index 064361cb..5e1862b8 100644 --- a/examples/vec4.gw +++ b/examples/vec4.gw @@ -1,6 +1,16 @@ Vec4 v, w; <<< v >>>; +<<< v + w>>>; +<<< v - w>>>; +<<< v * w>>>; +<<< v / w>>>; + +<<< 1.3 + w>>>; +<<< 1.4 - w>>>; +<<< 1.4 * w>>>; +<<< 1.5 / w>>>; + <<< v.x >>>; <<< v.y >>>; <<< v.z >>>; diff --git a/src/emit/memoize.c b/src/emit/memoize.c index c9fe04d9..538af2b0 100644 --- a/src/emit/memoize.c +++ b/src/emit/memoize.c @@ -48,6 +48,7 @@ Memoize memoize_ini(const Emitter emit, const Func f, const enum Kind kind) { Memoize m = mp_calloc(emit->gwion->mp, Memoize); vector_init(&m->v); m->ret_sz = f->def->base->ret_type->size; +// a void pure function is suspicious at least. check that m->kind = kind; if(!GET_FLAG(f, member)) m->arg_sz = f->def->stack_depth; diff --git a/src/lib/ptr.c b/src/lib/ptr.c index ffe626ed..6a5152e3 100644 --- a/src/lib/ptr.c +++ b/src/lib/ptr.c @@ -13,6 +13,7 @@ #include "operator.h" #include "import.h" #include "emit.h" +#include "traverse.h" static OP_CHECK(opck_ptr_assign) { const Exp_Binary* bin = (Exp_Binary*)data; @@ -37,6 +38,20 @@ static OP_CHECK(opck_ptr_deref) { return exp_self(unary)->type = nspc_lookup_type1(unary->exp->type->e->owner, insert_symbol(env->gwion->st, get_type_name(env, unary->exp->type->name, 1))); } +static OP_CHECK(opck_ptr_cast) { + const Exp_Cast* cast = (Exp_Cast*)data; + const Type t = type_decl_resolve(env, cast->td); + if(!GET_FLAG(t, check)) { + assert(t->e->def); + CHECK_BO(traverse_class_def(env, t->e->def)) + } +// TODO check types. +// const Type ptr = nspc_ +// if(t && isa(cast->exp->type, get_type(env, t, 1)) > 0) + return t; +// ERR_N(exp_self(cast)->pos, "invalid pointer cast") +} + static OP_CHECK(opck_implicit_ptr) { const struct Implicit* imp = (struct Implicit*)data; const Exp e = (Exp)imp->e; @@ -60,6 +75,19 @@ static INSTR(instr_ptr_deref) { } } +static INSTR(Cast2Ptr) { + const M_Object o = new_object(shred->info->mp, shred, t_ptr); + *(m_uint**)o->data = *(m_uint**)REG(-SZ_INT); + *(M_Object*)REG(-SZ_INT) = o; +} +/* +static OP_EMIT(opem_ptr_cast) { + const Exp_Cast* cast = (Exp_Cast*)data; + const Instr instr = emit_add_instr(emit, Cast2Ptr); + instr->m_val = (m_uint)exp_self(cast)->type; + return GW_OK; +} +*/ static OP_EMIT(opem_ptr_deref) { const Exp_Unary* unary = (Exp_Unary*)data; const Instr instr = emit_add_instr(emit, instr_ptr_deref); @@ -68,12 +96,6 @@ static OP_EMIT(opem_ptr_deref) { return GW_OK; } -static INSTR(Cast2Ptr) { - const M_Object o = new_object(shred->info->mp, shred, t_ptr); - *(m_uint**)o->data = *(m_uint**)REG(-SZ_INT); - *(M_Object*)REG(-SZ_INT) = o; -} - GWION_IMPORT(ptr) { const m_str list[] = { "A" }; CHECK_OB((t_ptr = gwi_mk_type(gwi, "Ptr", SZ_INT, t_object))) @@ -83,11 +105,15 @@ GWION_IMPORT(ptr) { CHECK_BB(gwi_item_ini(gwi, "int", "@val")) CHECK_BB(gwi_item_end(gwi, 0, NULL)) CHECK_BB(gwi_class_end(gwi)) + t_ptr->nspc->info->offset = SZ_INT; CHECK_BB(gwi_oper_ini(gwi, (m_str)OP_ANY_TYPE, "Ptr", NULL)) CHECK_BB(gwi_oper_add(gwi, opck_ptr_assign)) - CHECK_BB(gwi_oper_end(gwi, "]=>", instr_ptr_assign)) + CHECK_BB(gwi_oper_end(gwi, ":=>", instr_ptr_assign)) CHECK_BB(gwi_oper_add(gwi, opck_implicit_ptr)) CHECK_BB(gwi_oper_end(gwi, "@implicit", Cast2Ptr)) + CHECK_BB(gwi_oper_ini(gwi, (m_str)OP_ANY_TYPE, "Ptr", NULL)) + CHECK_BB(gwi_oper_add(gwi, opck_ptr_cast)) + CHECK_BB(gwi_oper_end(gwi, "$", Cast2Ptr)) CHECK_BB(gwi_oper_ini(gwi, NULL, "Ptr", NULL)) CHECK_BB(gwi_oper_add(gwi, opck_ptr_deref)) CHECK_BB(gwi_oper_emi(gwi, opem_ptr_deref)) diff --git a/src/lib/ugen.c b/src/lib/ugen.c index 582670f1..b947182c 100644 --- a/src/lib/ugen.c +++ b/src/lib/ugen.c @@ -357,7 +357,7 @@ GWION_IMPORT(ugen) { CHECK_BB(gwi_oper_ini(gwi, "UGen", "UGen", "UGen")) _CHECK_OP("=>", chuck_ugen, UgenConnect) _CHECK_OP("=<", chuck_ugen, UgenDisconnect) - _CHECK_OP("]=>", chuck_ugen, TrigConnect) + _CHECK_OP(":=>", chuck_ugen, TrigConnect) _CHECK_OP("}=<", chuck_ugen, TrigDisconnect) return import_global_ugens(gwi); } diff --git a/tests/error/ptr_assign_const.gw b/tests/error/ptr_assign_const.gw new file mode 100644 index 00000000..b0da376b --- /dev/null +++ b/tests/error/ptr_assign_const.gw @@ -0,0 +1 @@ +1 :=> <~int~>Ptr pd; diff --git a/tests/error/ptr_assign_invalid.gw b/tests/error/ptr_assign_invalid.gw new file mode 100644 index 00000000..9ac24209 --- /dev/null +++ b/tests/error/ptr_assign_invalid.gw @@ -0,0 +1,6 @@ +class C {} + +class D extends C {} + +D d; +d :=> <~int~>Ptr pd; diff --git a/tests/error/swicth_no_cases.gw b/tests/error/swicth_no_cases.gw new file mode 100644 index 00000000..2ba94443 --- /dev/null +++ b/tests/error/swicth_no_cases.gw @@ -0,0 +1,4 @@ +#! [contains] switch statement with no cases +switch(1) { + <<<__func__>>>; +} diff --git a/tests/import/module.c b/tests/import/module.c new file mode 100644 index 00000000..1040609a --- /dev/null +++ b/tests/import/module.c @@ -0,0 +1,20 @@ +#include +#include +#include "gwion_util.h" +#include "gwion_ast.h" +#include "oo.h" +#include "env.h" +#include "vm.h" +#include "driver.h" +#include "gwion.h" +#include "plug.h" + +GWMODSTR(dummy2); + +GWMODINI(dummy2) { + puts(__func__); + return NULL; +} +GWMODEND(dummy2) { + puts(__func__); +} diff --git a/tests/import/test.log b/tests/import/test.log new file mode 100644 index 00000000..51b9b3e6 --- /dev/null +++ b/tests/import/test.log @@ -0,0 +1,4332 @@ +/dev/null ==11180== Memcheck, a memory error detector +==11180== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==11180== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==11180== Command: ./../../gwion -p. -d dummy /dev/null +==11180== Parent PID: 11154 +==11180== +==11180== +==11180== HEAP SUMMARY: +==11180== in use at exit: 928 bytes in 10 blocks +==11180== total heap usage: 997 allocs, 987 frees, 7,604,988 bytes allocated +==11180== +==11180== LEAK SUMMARY: +==11180== definitely lost: 928 bytes in 10 blocks +==11180== indirectly lost: 0 bytes in 0 blocks +==11180== possibly lost: 0 bytes in 0 blocks +==11180== still reachable: 0 bytes in 0 blocks +==11180== suppressed: 0 bytes in 0 blocks +==11180== Rerun with --leak-check=full to see details of leaked memory +==11180== +==11180== For counts of detected and suppressed errors, rerun with: -v +==11180== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0) +/dev/null ==11278== Memcheck, a memory error detector +==11278== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==11278== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==11278== Command: ./../../gwion -p. -d dummy /dev/null +==11278== Parent PID: 11154 +==11278== +==11278== Invalid read of size 4 +==11278== at 0x130C28: env_err (gwion.c:110) +==11278== by 0x15255E: gwi_class_ini (import.c:220) +==11278== by 0x48481A0: import (begin_class.c:18) +==11278== by 0x14AC48: type_engine_init (engine.c:107) +==11278== by 0x1308C5: gwion_engine (gwion.c:39) +==11278== by 0x1308C5: gwion_ini (gwion.c:78) +==11278== by 0x12F87D: main (main.c:23) +==11278== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==11278== +==11278== +==11278== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==11278== Access not within mapped region at address 0x28 +==11278== at 0x130C28: env_err (gwion.c:110) +==11278== by 0x15255E: gwi_class_ini (import.c:220) +==11278== by 0x48481A0: import (begin_class.c:18) +==11278== by 0x14AC48: type_engine_init (engine.c:107) +==11278== by 0x1308C5: gwion_engine (gwion.c:39) +==11278== by 0x1308C5: gwion_ini (gwion.c:78) +==11278== by 0x12F87D: main (main.c:23) +==11278== If you believe this happened as a result of a stack +==11278== overflow in your program's main thread (unlikely but +==11278== possible), you can try to increase the size of the +==11278== main thread stack using the --main-stacksize= flag. +==11278== The main thread stack size used in this run was 8388608. +==11278== +==11278== HEAP SUMMARY: +==11278== in use at exit: 2,171,350 bytes in 383 blocks +==11278== total heap usage: 809 allocs, 426 frees, 2,265,539 bytes allocated +==11278== +==11278== LEAK SUMMARY: +==11278== definitely lost: 0 bytes in 0 blocks +==11278== indirectly lost: 0 bytes in 0 blocks +==11278== possibly lost: 0 bytes in 0 blocks +==11278== still reachable: 2,171,350 bytes in 383 blocks +==11278== suppressed: 0 bytes in 0 blocks +==11278== Rerun with --leak-check=full to see details of leaked memory +==11278== +==11278== For counts of detected and suppressed errors, rerun with: -v +==11278== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==11509== Memcheck, a memory error detector +==11509== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==11509== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==11509== Command: ./../../gwion -p. -d dummy /dev/null +==11509== Parent PID: 11154 +==11509== +==11509== Invalid read of size 4 +==11509== at 0x130C28: env_err (gwion.c:110) +==11509== by 0x154233: gwi_union_end (import.c:601) +==11509== by 0x4848152: import (empty_union.c:15) +==11509== by 0x14AC48: type_engine_init (engine.c:107) +==11509== by 0x1308C5: gwion_engine (gwion.c:39) +==11509== by 0x1308C5: gwion_ini (gwion.c:78) +==11509== by 0x12F87D: main (main.c:23) +==11509== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==11509== +==11509== +==11509== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==11509== Access not within mapped region at address 0x28 +==11509== at 0x130C28: env_err (gwion.c:110) +==11509== by 0x154233: gwi_union_end (import.c:601) +==11509== by 0x4848152: import (empty_union.c:15) +==11509== by 0x14AC48: type_engine_init (engine.c:107) +==11509== by 0x1308C5: gwion_engine (gwion.c:39) +==11509== by 0x1308C5: gwion_ini (gwion.c:78) +==11509== by 0x12F87D: main (main.c:23) +==11509== If you believe this happened as a result of a stack +==11509== overflow in your program's main thread (unlikely but +==11509== possible), you can try to increase the size of the +==11509== main thread stack using the --main-stacksize= flag. +==11509== The main thread stack size used in this run was 8388608. +==11509== +==11509== HEAP SUMMARY: +==11509== in use at exit: 2,170,710 bytes in 374 blocks +==11509== total heap usage: 798 allocs, 424 frees, 2,264,835 bytes allocated +==11509== +==11509== LEAK SUMMARY: +==11509== definitely lost: 0 bytes in 0 blocks +==11509== indirectly lost: 0 bytes in 0 blocks +==11509== possibly lost: 0 bytes in 0 blocks +==11509== still reachable: 2,170,710 bytes in 374 blocks +==11509== suppressed: 0 bytes in 0 blocks +==11509== Rerun with --leak-check=full to see details of leaked memory +==11509== +==11509== For counts of detected and suppressed errors, rerun with: -v +==11509== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==11555== Memcheck, a memory error detector +==11555== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==11555== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==11555== Command: ./../../gwion -p. -d dummy /dev/null +==11555== Parent PID: 11154 +==11555== +==11555== Invalid read of size 4 +==11555== at 0x130C28: env_err (gwion.c:110) +==11555== by 0x152ADD: gwi_class_end (import.c:268) +==11555== by 0x4848133: import (end_class.c:15) +==11555== by 0x14AC48: type_engine_init (engine.c:107) +==11555== by 0x1308C5: gwion_engine (gwion.c:39) +==11555== by 0x1308C5: gwion_ini (gwion.c:78) +==11555== by 0x12F87D: main (main.c:23) +==11555== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==11555== +==11555== +==11555== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==11555== Access not within mapped region at address 0x28 +==11555== at 0x130C28: env_err (gwion.c:110) +==11555== by 0x152ADD: gwi_class_end (import.c:268) +==11555== by 0x4848133: import (end_class.c:15) +==11555== by 0x14AC48: type_engine_init (engine.c:107) +==11555== by 0x1308C5: gwion_engine (gwion.c:39) +==11555== by 0x1308C5: gwion_ini (gwion.c:78) +==11555== by 0x12F87D: main (main.c:23) +==11555== If you believe this happened as a result of a stack +==11555== overflow in your program's main thread (unlikely but +==11555== possible), you can try to increase the size of the +==11555== main thread stack using the --main-stacksize= flag. +==11555== The main thread stack size used in this run was 8388608. +==11555== +==11555== HEAP SUMMARY: +==11555== in use at exit: 2,170,704 bytes in 374 blocks +==11555== total heap usage: 798 allocs, 424 frees, 2,264,821 bytes allocated +==11555== +==11555== LEAK SUMMARY: +==11555== definitely lost: 0 bytes in 0 blocks +==11555== indirectly lost: 0 bytes in 0 blocks +==11555== possibly lost: 0 bytes in 0 blocks +==11555== still reachable: 2,170,704 bytes in 374 blocks +==11555== suppressed: 0 bytes in 0 blocks +==11555== Rerun with --leak-check=full to see details of leaked memory +==11555== +==11555== For counts of detected and suppressed errors, rerun with: -v +==11555== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==11874== Memcheck, a memory error detector +==11874== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==11874== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==11874== Command: ./../../gwion -p. -d dummy /dev/null +==11874== Parent PID: 11154 +==11874== +==11874== Invalid read of size 4 +==11874== at 0x130C28: env_err (gwion.c:110) +==11874== by 0x1514A7: path_valid (import.c:145) +==11874== by 0x151E06: str2list (import.c:167) +==11874== by 0x152F24: str2decl (import.c:366) +==11874== by 0x15334E: make_dll_arg_list (import.c:395) +==11874== by 0x153882: make_dll_as_fun (import.c:440) +==11874== by 0x1539D1: gwi_func_end (import.c:449) +==11874== by 0x4848225: import (invalid_arg.c:21) +==11874== by 0x14AC48: type_engine_init (engine.c:107) +==11874== by 0x1308C5: gwion_engine (gwion.c:39) +==11874== by 0x1308C5: gwion_ini (gwion.c:78) +==11874== by 0x12F87D: main (main.c:23) +==11874== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==11874== +==11874== +==11874== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==11874== Access not within mapped region at address 0x28 +==11874== at 0x130C28: env_err (gwion.c:110) +==11874== by 0x1514A7: path_valid (import.c:145) +==11874== by 0x151E06: str2list (import.c:167) +==11874== by 0x152F24: str2decl (import.c:366) +==11874== by 0x15334E: make_dll_arg_list (import.c:395) +==11874== by 0x153882: make_dll_as_fun (import.c:440) +==11874== by 0x1539D1: gwi_func_end (import.c:449) +==11874== by 0x4848225: import (invalid_arg.c:21) +==11874== by 0x14AC48: type_engine_init (engine.c:107) +==11874== by 0x1308C5: gwion_engine (gwion.c:39) +==11874== by 0x1308C5: gwion_ini (gwion.c:78) +==11874== by 0x12F87D: main (main.c:23) +==11874== If you believe this happened as a result of a stack +==11874== overflow in your program's main thread (unlikely but +==11874== possible), you can try to increase the size of the +==11874== main thread stack using the --main-stacksize= flag. +==11874== The main thread stack size used in this run was 8388608. +==11874== +==11874== HEAP SUMMARY: +==11874== in use at exit: 2,171,862 bytes in 384 blocks +==11874== total heap usage: 810 allocs, 426 frees, 2,266,051 bytes allocated +==11874== +==11874== LEAK SUMMARY: +==11874== definitely lost: 0 bytes in 0 blocks +==11874== indirectly lost: 0 bytes in 0 blocks +==11874== possibly lost: 0 bytes in 0 blocks +==11874== still reachable: 2,171,862 bytes in 384 blocks +==11874== suppressed: 0 bytes in 0 blocks +==11874== Rerun with --leak-check=full to see details of leaked memory +==11874== +==11874== For counts of detected and suppressed errors, rerun with: -v +==11874== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==11920== Memcheck, a memory error detector +==11920== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==11920== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==11920== Command: ./../../gwion -p. -d dummy /dev/null +==11920== Parent PID: 11154 +==11920== +==11920== Invalid read of size 4 +==11920== at 0x130C28: env_err (gwion.c:110) +==11920== by 0x153425: make_dll_arg_list (import.c:406) +==11920== by 0x153882: make_dll_as_fun (import.c:440) +==11920== by 0x1539D1: gwi_func_end (import.c:449) +==11920== by 0x48482A6: import (invalid_array.c:24) +==11920== by 0x14AC48: type_engine_init (engine.c:107) +==11920== by 0x1308C5: gwion_engine (gwion.c:39) +==11920== by 0x1308C5: gwion_ini (gwion.c:78) +==11920== by 0x12F87D: main (main.c:23) +==11920== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==11920== +==11920== +==11920== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==11920== Access not within mapped region at address 0x28 +==11920== at 0x130C28: env_err (gwion.c:110) +==11920== by 0x153425: make_dll_arg_list (import.c:406) +==11920== by 0x153882: make_dll_as_fun (import.c:440) +==11920== by 0x1539D1: gwi_func_end (import.c:449) +==11920== by 0x48482A6: import (invalid_array.c:24) +==11920== by 0x14AC48: type_engine_init (engine.c:107) +==11920== by 0x1308C5: gwion_engine (gwion.c:39) +==11920== by 0x1308C5: gwion_ini (gwion.c:78) +==11920== by 0x12F87D: main (main.c:23) +==11920== If you believe this happened as a result of a stack +==11920== overflow in your program's main thread (unlikely but +==11920== possible), you can try to increase the size of the +==11920== main thread stack using the --main-stacksize= flag. +==11920== The main thread stack size used in this run was 8388608. +==11920== +==11920== HEAP SUMMARY: +==11920== in use at exit: 2,173,020 bytes in 385 blocks +==11920== total heap usage: 812 allocs, 427 frees, 2,267,345 bytes allocated +==11920== +==11920== LEAK SUMMARY: +==11920== definitely lost: 0 bytes in 0 blocks +==11920== indirectly lost: 0 bytes in 0 blocks +==11920== possibly lost: 0 bytes in 0 blocks +==11920== still reachable: 2,173,020 bytes in 385 blocks +==11920== suppressed: 0 bytes in 0 blocks +==11920== Rerun with --leak-check=full to see details of leaked memory +==11920== +==11920== For counts of detected and suppressed errors, rerun with: -v +==11920== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==11968== Memcheck, a memory error detector +==11968== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==11968== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==11968== Command: ./../../gwion -p. -d dummy /dev/null +==11968== Parent PID: 11154 +==11968== +==11968== Invalid read of size 4 +==11968== at 0x130C28: env_err (gwion.c:110) +==11968== by 0x1514A7: path_valid (import.c:145) +==11968== by 0x151E06: str2list (import.c:167) +==11968== by 0x1536C5: import_td (import.c:418) +==11968== by 0x153856: make_dll_as_fun (import.c:436) +==11968== by 0x1539D1: gwi_func_end (import.c:449) +==11968== by 0x48481EC: import (invalid_func.c:20) +==11968== by 0x14AC48: type_engine_init (engine.c:107) +==11968== by 0x1308C5: gwion_engine (gwion.c:39) +==11968== by 0x1308C5: gwion_ini (gwion.c:78) +==11968== by 0x12F87D: main (main.c:23) +==11968== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==11968== +==11968== +==11968== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==11968== Access not within mapped region at address 0x28 +==11968== at 0x130C28: env_err (gwion.c:110) +==11968== by 0x1514A7: path_valid (import.c:145) +==11968== by 0x151E06: str2list (import.c:167) +==11968== by 0x1536C5: import_td (import.c:418) +==11968== by 0x153856: make_dll_as_fun (import.c:436) +==11968== by 0x1539D1: gwi_func_end (import.c:449) +==11968== by 0x48481EC: import (invalid_func.c:20) +==11968== by 0x14AC48: type_engine_init (engine.c:107) +==11968== by 0x1308C5: gwion_engine (gwion.c:39) +==11968== by 0x1308C5: gwion_ini (gwion.c:78) +==11968== by 0x12F87D: main (main.c:23) +==11968== If you believe this happened as a result of a stack +==11968== overflow in your program's main thread (unlikely but +==11968== possible), you can try to increase the size of the +==11968== main thread stack using the --main-stacksize= flag. +==11968== The main thread stack size used in this run was 8388608. +==11968== +==11968== HEAP SUMMARY: +==11968== in use at exit: 2,171,353 bytes in 383 blocks +==11968== total heap usage: 809 allocs, 426 frees, 2,265,546 bytes allocated +==11968== +==11968== LEAK SUMMARY: +==11968== definitely lost: 0 bytes in 0 blocks +==11968== indirectly lost: 0 bytes in 0 blocks +==11968== possibly lost: 0 bytes in 0 blocks +==11968== still reachable: 2,171,353 bytes in 383 blocks +==11968== suppressed: 0 bytes in 0 blocks +==11968== Rerun with --leak-check=full to see details of leaked memory +==11968== +==11968== For counts of detected and suppressed errors, rerun with: -v +==11968== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==12015== Memcheck, a memory error detector +==12015== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==12015== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==12015== Command: ./../../gwion -p. -d dummy /dev/null +==12015== Parent PID: 11154 +==12015== +==12015== Invalid read of size 4 +==12015== at 0x130C28: env_err (gwion.c:110) +==12015== by 0x15132D: path_valid (import.c:135) +==12015== by 0x151E06: str2list (import.c:167) +==12015== by 0x152B6E: gwi_item_ini (import.c:302) +==12015== by 0x48481B5: import (invalid_type1.c:18) +==12015== by 0x14AC48: type_engine_init (engine.c:107) +==12015== by 0x1308C5: gwion_engine (gwion.c:39) +==12015== by 0x1308C5: gwion_ini (gwion.c:78) +==12015== by 0x12F87D: main (main.c:23) +==12015== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==12015== +==12015== +==12015== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==12015== Access not within mapped region at address 0x28 +==12015== at 0x130C28: env_err (gwion.c:110) +==12015== by 0x15132D: path_valid (import.c:135) +==12015== by 0x151E06: str2list (import.c:167) +==12015== by 0x152B6E: gwi_item_ini (import.c:302) +==12015== by 0x48481B5: import (invalid_type1.c:18) +==12015== by 0x14AC48: type_engine_init (engine.c:107) +==12015== by 0x1308C5: gwion_engine (gwion.c:39) +==12015== by 0x1308C5: gwion_ini (gwion.c:78) +==12015== by 0x12F87D: main (main.c:23) +==12015== If you believe this happened as a result of a stack +==12015== overflow in your program's main thread (unlikely but +==12015== possible), you can try to increase the size of the +==12015== main thread stack using the --main-stacksize= flag. +==12015== The main thread stack size used in this run was 8388608. +==12015== +==12015== HEAP SUMMARY: +==12015== in use at exit: 2,171,356 bytes in 383 blocks +==12015== total heap usage: 809 allocs, 426 frees, 2,265,553 bytes allocated +==12015== +==12015== LEAK SUMMARY: +==12015== definitely lost: 0 bytes in 0 blocks +==12015== indirectly lost: 0 bytes in 0 blocks +==12015== possibly lost: 0 bytes in 0 blocks +==12015== still reachable: 2,171,356 bytes in 383 blocks +==12015== suppressed: 0 bytes in 0 blocks +==12015== Rerun with --leak-check=full to see details of leaked memory +==12015== +==12015== For counts of detected and suppressed errors, rerun with: -v +==12015== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==12062== Memcheck, a memory error detector +==12062== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==12062== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==12062== Command: ./../../gwion -p. -d dummy /dev/null +==12062== Parent PID: 11154 +==12062== +==12062== Invalid read of size 4 +==12062== at 0x130C28: env_err (gwion.c:110) +==12062== by 0x1514A7: path_valid (import.c:145) +==12062== by 0x151E06: str2list (import.c:167) +==12062== by 0x152B6E: gwi_item_ini (import.c:302) +==12062== by 0x48481B5: import (invalid_type2.c:18) +==12062== by 0x14AC48: type_engine_init (engine.c:107) +==12062== by 0x1308C5: gwion_engine (gwion.c:39) +==12062== by 0x1308C5: gwion_ini (gwion.c:78) +==12062== by 0x12F87D: main (main.c:23) +==12062== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==12062== +==12062== +==12062== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==12062== Access not within mapped region at address 0x28 +==12062== at 0x130C28: env_err (gwion.c:110) +==12062== by 0x1514A7: path_valid (import.c:145) +==12062== by 0x151E06: str2list (import.c:167) +==12062== by 0x152B6E: gwi_item_ini (import.c:302) +==12062== by 0x48481B5: import (invalid_type2.c:18) +==12062== by 0x14AC48: type_engine_init (engine.c:107) +==12062== by 0x1308C5: gwion_engine (gwion.c:39) +==12062== by 0x1308C5: gwion_ini (gwion.c:78) +==12062== by 0x12F87D: main (main.c:23) +==12062== If you believe this happened as a result of a stack +==12062== overflow in your program's main thread (unlikely but +==12062== possible), you can try to increase the size of the +==12062== main thread stack using the --main-stacksize= flag. +==12062== The main thread stack size used in this run was 8388608. +==12062== +==12062== HEAP SUMMARY: +==12062== in use at exit: 2,171,356 bytes in 383 blocks +==12062== total heap usage: 809 allocs, 426 frees, 2,265,553 bytes allocated +==12062== +==12062== LEAK SUMMARY: +==12062== definitely lost: 0 bytes in 0 blocks +==12062== indirectly lost: 0 bytes in 0 blocks +==12062== possibly lost: 0 bytes in 0 blocks +==12062== still reachable: 2,171,356 bytes in 383 blocks +==12062== suppressed: 0 bytes in 0 blocks +==12062== Rerun with --leak-check=full to see details of leaked memory +==12062== +==12062== For counts of detected and suppressed errors, rerun with: -v +==12062== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==12109== Memcheck, a memory error detector +==12109== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==12109== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==12109== Command: ./../../gwion -p. -d dummy /dev/null +==12109== Parent PID: 11154 +==12109== +==12109== Invalid read of size 4 +==12109== at 0x130C28: env_err (gwion.c:110) +==12109== by 0x151192: name_valid (import.c:116) +==12109== by 0x152417: gwi_add_type (import.c:195) +==12109== by 0x1524DD: gwi_class_ini (import.c:229) +==12109== by 0x484818F: import (invalid_type3.c:18) +==12109== by 0x14AC48: type_engine_init (engine.c:107) +==12109== by 0x1308C5: gwion_engine (gwion.c:39) +==12109== by 0x1308C5: gwion_ini (gwion.c:78) +==12109== by 0x12F87D: main (main.c:23) +==12109== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==12109== +==12109== +==12109== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==12109== Access not within mapped region at address 0x28 +==12109== at 0x130C28: env_err (gwion.c:110) +==12109== by 0x151192: name_valid (import.c:116) +==12109== by 0x152417: gwi_add_type (import.c:195) +==12109== by 0x1524DD: gwi_class_ini (import.c:229) +==12109== by 0x484818F: import (invalid_type3.c:18) +==12109== by 0x14AC48: type_engine_init (engine.c:107) +==12109== by 0x1308C5: gwion_engine (gwion.c:39) +==12109== by 0x1308C5: gwion_ini (gwion.c:78) +==12109== by 0x12F87D: main (main.c:23) +==12109== If you believe this happened as a result of a stack +==12109== overflow in your program's main thread (unlikely but +==12109== possible), you can try to increase the size of the +==12109== main thread stack using the --main-stacksize= flag. +==12109== The main thread stack size used in this run was 8388608. +==12109== +==12109== HEAP SUMMARY: +==12109== in use at exit: 2,170,716 bytes in 374 blocks +==12109== total heap usage: 798 allocs, 424 frees, 2,264,849 bytes allocated +==12109== +==12109== LEAK SUMMARY: +==12109== definitely lost: 0 bytes in 0 blocks +==12109== indirectly lost: 0 bytes in 0 blocks +==12109== possibly lost: 0 bytes in 0 blocks +==12109== still reachable: 2,170,716 bytes in 374 blocks +==12109== suppressed: 0 bytes in 0 blocks +==12109== Rerun with --leak-check=full to see details of leaked memory +==12109== +==12109== For counts of detected and suppressed errors, rerun with: -v +==12109== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==12292== Memcheck, a memory error detector +==12292== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==12292== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==12292== Command: ./../../gwion -p. -d dummy /dev/null +==12292== Parent PID: 11154 +==12292== +==12292== Invalid read of size 4 +==12292== at 0x130C28: env_err (gwion.c:110) +==12292== by 0x1531A6: make_dll_arg_list (import.c:398) +==12292== by 0x153882: make_dll_as_fun (import.c:440) +==12292== by 0x1539D1: gwi_func_end (import.c:449) +==12292== by 0x4848225: import (template_arg.c:21) +==12292== by 0x14AC48: type_engine_init (engine.c:107) +==12292== by 0x1308C5: gwion_engine (gwion.c:39) +==12292== by 0x1308C5: gwion_ini (gwion.c:78) +==12292== by 0x12F87D: main (main.c:23) +==12292== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==12292== +==12292== +==12292== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==12292== Access not within mapped region at address 0x28 +==12292== at 0x130C28: env_err (gwion.c:110) +==12292== by 0x1531A6: make_dll_arg_list (import.c:398) +==12292== by 0x153882: make_dll_as_fun (import.c:440) +==12292== by 0x1539D1: gwi_func_end (import.c:449) +==12292== by 0x4848225: import (template_arg.c:21) +==12292== by 0x14AC48: type_engine_init (engine.c:107) +==12292== by 0x1308C5: gwion_engine (gwion.c:39) +==12292== by 0x1308C5: gwion_ini (gwion.c:78) +==12292== by 0x12F87D: main (main.c:23) +==12292== If you believe this happened as a result of a stack +==12292== overflow in your program's main thread (unlikely but +==12292== possible), you can try to increase the size of the +==12292== main thread stack using the --main-stacksize= flag. +==12292== The main thread stack size used in this run was 8388608. +==12292== +==12292== HEAP SUMMARY: +==12292== in use at exit: 2,177,657 bytes in 395 blocks +==12292== total heap usage: 829 allocs, 434 frees, 2,272,394 bytes allocated +==12292== +==12292== LEAK SUMMARY: +==12292== definitely lost: 0 bytes in 0 blocks +==12292== indirectly lost: 0 bytes in 0 blocks +==12292== possibly lost: 0 bytes in 0 blocks +==12292== still reachable: 2,177,657 bytes in 395 blocks +==12292== suppressed: 0 bytes in 0 blocks +==12292== Rerun with --leak-check=full to see details of leaked memory +==12292== +==12292== For counts of detected and suppressed errors, rerun with: -v +==12292== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==13240== Memcheck, a memory error detector +==13240== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==13240== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==13240== Command: ./../../gwion -p. -d dummy /dev/null +==13240== Parent PID: 13214 +==13240== +==13240== +==13240== HEAP SUMMARY: +==13240== in use at exit: 928 bytes in 10 blocks +==13240== total heap usage: 997 allocs, 987 frees, 7,604,988 bytes allocated +==13240== +==13240== LEAK SUMMARY: +==13240== definitely lost: 928 bytes in 10 blocks +==13240== indirectly lost: 0 bytes in 0 blocks +==13240== possibly lost: 0 bytes in 0 blocks +==13240== still reachable: 0 bytes in 0 blocks +==13240== suppressed: 0 bytes in 0 blocks +==13240== Rerun with --leak-check=full to see details of leaked memory +==13240== +==13240== For counts of detected and suppressed errors, rerun with: -v +==13240== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0) +/dev/null ==13338== Memcheck, a memory error detector +==13338== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==13338== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==13338== Command: ./../../gwion -p. -d dummy /dev/null +==13338== Parent PID: 13214 +==13338== +==13338== Invalid read of size 4 +==13338== at 0x130C28: env_err (gwion.c:110) +==13338== by 0x15255E: gwi_class_ini (import.c:220) +==13338== by 0x48481A0: import (begin_class.c:18) +==13338== by 0x14AC48: type_engine_init (engine.c:107) +==13338== by 0x1308C5: gwion_engine (gwion.c:39) +==13338== by 0x1308C5: gwion_ini (gwion.c:78) +==13338== by 0x12F87D: main (main.c:23) +==13338== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==13338== +==13338== +==13338== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==13338== Access not within mapped region at address 0x28 +==13338== at 0x130C28: env_err (gwion.c:110) +==13338== by 0x15255E: gwi_class_ini (import.c:220) +==13338== by 0x48481A0: import (begin_class.c:18) +==13338== by 0x14AC48: type_engine_init (engine.c:107) +==13338== by 0x1308C5: gwion_engine (gwion.c:39) +==13338== by 0x1308C5: gwion_ini (gwion.c:78) +==13338== by 0x12F87D: main (main.c:23) +==13338== If you believe this happened as a result of a stack +==13338== overflow in your program's main thread (unlikely but +==13338== possible), you can try to increase the size of the +==13338== main thread stack using the --main-stacksize= flag. +==13338== The main thread stack size used in this run was 8388608. +==13338== +==13338== HEAP SUMMARY: +==13338== in use at exit: 2,171,350 bytes in 383 blocks +==13338== total heap usage: 809 allocs, 426 frees, 2,265,539 bytes allocated +==13338== +==13338== LEAK SUMMARY: +==13338== definitely lost: 0 bytes in 0 blocks +==13338== indirectly lost: 0 bytes in 0 blocks +==13338== possibly lost: 0 bytes in 0 blocks +==13338== still reachable: 2,171,350 bytes in 383 blocks +==13338== suppressed: 0 bytes in 0 blocks +==13338== Rerun with --leak-check=full to see details of leaked memory +==13338== +==13338== For counts of detected and suppressed errors, rerun with: -v +==13338== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==13567== Memcheck, a memory error detector +==13567== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==13567== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==13567== Command: ./../../gwion -p. -d dummy /dev/null +==13567== Parent PID: 13214 +==13567== +==13567== Invalid read of size 4 +==13567== at 0x130C28: env_err (gwion.c:110) +==13567== by 0x154233: gwi_union_end (import.c:601) +==13567== by 0x4848152: import (empty_union.c:15) +==13567== by 0x14AC48: type_engine_init (engine.c:107) +==13567== by 0x1308C5: gwion_engine (gwion.c:39) +==13567== by 0x1308C5: gwion_ini (gwion.c:78) +==13567== by 0x12F87D: main (main.c:23) +==13567== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==13567== +==13567== +==13567== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==13567== Access not within mapped region at address 0x28 +==13567== at 0x130C28: env_err (gwion.c:110) +==13567== by 0x154233: gwi_union_end (import.c:601) +==13567== by 0x4848152: import (empty_union.c:15) +==13567== by 0x14AC48: type_engine_init (engine.c:107) +==13567== by 0x1308C5: gwion_engine (gwion.c:39) +==13567== by 0x1308C5: gwion_ini (gwion.c:78) +==13567== by 0x12F87D: main (main.c:23) +==13567== If you believe this happened as a result of a stack +==13567== overflow in your program's main thread (unlikely but +==13567== possible), you can try to increase the size of the +==13567== main thread stack using the --main-stacksize= flag. +==13567== The main thread stack size used in this run was 8388608. +==13567== +==13567== HEAP SUMMARY: +==13567== in use at exit: 2,170,710 bytes in 374 blocks +==13567== total heap usage: 798 allocs, 424 frees, 2,264,835 bytes allocated +==13567== +==13567== LEAK SUMMARY: +==13567== definitely lost: 0 bytes in 0 blocks +==13567== indirectly lost: 0 bytes in 0 blocks +==13567== possibly lost: 0 bytes in 0 blocks +==13567== still reachable: 2,170,710 bytes in 374 blocks +==13567== suppressed: 0 bytes in 0 blocks +==13567== Rerun with --leak-check=full to see details of leaked memory +==13567== +==13567== For counts of detected and suppressed errors, rerun with: -v +==13567== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==13613== Memcheck, a memory error detector +==13613== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==13613== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==13613== Command: ./../../gwion -p. -d dummy /dev/null +==13613== Parent PID: 13214 +==13613== +==13613== Invalid read of size 4 +==13613== at 0x130C28: env_err (gwion.c:110) +==13613== by 0x152ADD: gwi_class_end (import.c:268) +==13613== by 0x4848133: import (end_class.c:15) +==13613== by 0x14AC48: type_engine_init (engine.c:107) +==13613== by 0x1308C5: gwion_engine (gwion.c:39) +==13613== by 0x1308C5: gwion_ini (gwion.c:78) +==13613== by 0x12F87D: main (main.c:23) +==13613== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==13613== +==13613== +==13613== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==13613== Access not within mapped region at address 0x28 +==13613== at 0x130C28: env_err (gwion.c:110) +==13613== by 0x152ADD: gwi_class_end (import.c:268) +==13613== by 0x4848133: import (end_class.c:15) +==13613== by 0x14AC48: type_engine_init (engine.c:107) +==13613== by 0x1308C5: gwion_engine (gwion.c:39) +==13613== by 0x1308C5: gwion_ini (gwion.c:78) +==13613== by 0x12F87D: main (main.c:23) +==13613== If you believe this happened as a result of a stack +==13613== overflow in your program's main thread (unlikely but +==13613== possible), you can try to increase the size of the +==13613== main thread stack using the --main-stacksize= flag. +==13613== The main thread stack size used in this run was 8388608. +==13613== +==13613== HEAP SUMMARY: +==13613== in use at exit: 2,170,704 bytes in 374 blocks +==13613== total heap usage: 798 allocs, 424 frees, 2,264,821 bytes allocated +==13613== +==13613== LEAK SUMMARY: +==13613== definitely lost: 0 bytes in 0 blocks +==13613== indirectly lost: 0 bytes in 0 blocks +==13613== possibly lost: 0 bytes in 0 blocks +==13613== still reachable: 2,170,704 bytes in 374 blocks +==13613== suppressed: 0 bytes in 0 blocks +==13613== Rerun with --leak-check=full to see details of leaked memory +==13613== +==13613== For counts of detected and suppressed errors, rerun with: -v +==13613== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==14049== Memcheck, a memory error detector +==14049== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==14049== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==14049== Command: ./../../gwion -p. -d dummy /dev/null +==14049== Parent PID: 13214 +==14049== +==14049== Invalid read of size 4 +==14049== at 0x130C28: env_err (gwion.c:110) +==14049== by 0x1514A7: path_valid (import.c:145) +==14049== by 0x151E06: str2list (import.c:167) +==14049== by 0x152F24: str2decl (import.c:366) +==14049== by 0x15334E: make_dll_arg_list (import.c:395) +==14049== by 0x153882: make_dll_as_fun (import.c:440) +==14049== by 0x1539D1: gwi_func_end (import.c:449) +==14049== by 0x4848225: import (invalid_arg.c:21) +==14049== by 0x14AC48: type_engine_init (engine.c:107) +==14049== by 0x1308C5: gwion_engine (gwion.c:39) +==14049== by 0x1308C5: gwion_ini (gwion.c:78) +==14049== by 0x12F87D: main (main.c:23) +==14049== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==14049== +==14049== +==14049== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==14049== Access not within mapped region at address 0x28 +==14049== at 0x130C28: env_err (gwion.c:110) +==14049== by 0x1514A7: path_valid (import.c:145) +==14049== by 0x151E06: str2list (import.c:167) +==14049== by 0x152F24: str2decl (import.c:366) +==14049== by 0x15334E: make_dll_arg_list (import.c:395) +==14049== by 0x153882: make_dll_as_fun (import.c:440) +==14049== by 0x1539D1: gwi_func_end (import.c:449) +==14049== by 0x4848225: import (invalid_arg.c:21) +==14049== by 0x14AC48: type_engine_init (engine.c:107) +==14049== by 0x1308C5: gwion_engine (gwion.c:39) +==14049== by 0x1308C5: gwion_ini (gwion.c:78) +==14049== by 0x12F87D: main (main.c:23) +==14049== If you believe this happened as a result of a stack +==14049== overflow in your program's main thread (unlikely but +==14049== possible), you can try to increase the size of the +==14049== main thread stack using the --main-stacksize= flag. +==14049== The main thread stack size used in this run was 8388608. +==14049== +==14049== HEAP SUMMARY: +==14049== in use at exit: 2,171,862 bytes in 384 blocks +==14049== total heap usage: 810 allocs, 426 frees, 2,266,051 bytes allocated +==14049== +==14049== LEAK SUMMARY: +==14049== definitely lost: 0 bytes in 0 blocks +==14049== indirectly lost: 0 bytes in 0 blocks +==14049== possibly lost: 0 bytes in 0 blocks +==14049== still reachable: 2,171,862 bytes in 384 blocks +==14049== suppressed: 0 bytes in 0 blocks +==14049== Rerun with --leak-check=full to see details of leaked memory +==14049== +==14049== For counts of detected and suppressed errors, rerun with: -v +==14049== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==14095== Memcheck, a memory error detector +==14095== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==14095== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==14095== Command: ./../../gwion -p. -d dummy /dev/null +==14095== Parent PID: 13214 +==14095== +==14095== Invalid read of size 4 +==14095== at 0x130C28: env_err (gwion.c:110) +==14095== by 0x153425: make_dll_arg_list (import.c:406) +==14095== by 0x153882: make_dll_as_fun (import.c:440) +==14095== by 0x1539D1: gwi_func_end (import.c:449) +==14095== by 0x48482A6: import (invalid_array.c:24) +==14095== by 0x14AC48: type_engine_init (engine.c:107) +==14095== by 0x1308C5: gwion_engine (gwion.c:39) +==14095== by 0x1308C5: gwion_ini (gwion.c:78) +==14095== by 0x12F87D: main (main.c:23) +==14095== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==14095== +==14095== +==14095== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==14095== Access not within mapped region at address 0x28 +==14095== at 0x130C28: env_err (gwion.c:110) +==14095== by 0x153425: make_dll_arg_list (import.c:406) +==14095== by 0x153882: make_dll_as_fun (import.c:440) +==14095== by 0x1539D1: gwi_func_end (import.c:449) +==14095== by 0x48482A6: import (invalid_array.c:24) +==14095== by 0x14AC48: type_engine_init (engine.c:107) +==14095== by 0x1308C5: gwion_engine (gwion.c:39) +==14095== by 0x1308C5: gwion_ini (gwion.c:78) +==14095== by 0x12F87D: main (main.c:23) +==14095== If you believe this happened as a result of a stack +==14095== overflow in your program's main thread (unlikely but +==14095== possible), you can try to increase the size of the +==14095== main thread stack using the --main-stacksize= flag. +==14095== The main thread stack size used in this run was 8388608. +==14095== +==14095== HEAP SUMMARY: +==14095== in use at exit: 2,173,020 bytes in 385 blocks +==14095== total heap usage: 812 allocs, 427 frees, 2,267,345 bytes allocated +==14095== +==14095== LEAK SUMMARY: +==14095== definitely lost: 0 bytes in 0 blocks +==14095== indirectly lost: 0 bytes in 0 blocks +==14095== possibly lost: 0 bytes in 0 blocks +==14095== still reachable: 2,173,020 bytes in 385 blocks +==14095== suppressed: 0 bytes in 0 blocks +==14095== Rerun with --leak-check=full to see details of leaked memory +==14095== +==14095== For counts of detected and suppressed errors, rerun with: -v +==14095== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==14141== Memcheck, a memory error detector +==14141== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==14141== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==14141== Command: ./../../gwion -p. -d dummy /dev/null +==14141== Parent PID: 13214 +==14141== +==14141== Invalid read of size 4 +==14141== at 0x130C28: env_err (gwion.c:110) +==14141== by 0x1514A7: path_valid (import.c:145) +==14141== by 0x151E06: str2list (import.c:167) +==14141== by 0x1536C5: import_td (import.c:418) +==14141== by 0x153856: make_dll_as_fun (import.c:436) +==14141== by 0x1539D1: gwi_func_end (import.c:449) +==14141== by 0x48481EC: import (invalid_func.c:20) +==14141== by 0x14AC48: type_engine_init (engine.c:107) +==14141== by 0x1308C5: gwion_engine (gwion.c:39) +==14141== by 0x1308C5: gwion_ini (gwion.c:78) +==14141== by 0x12F87D: main (main.c:23) +==14141== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==14141== +==14141== +==14141== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==14141== Access not within mapped region at address 0x28 +==14141== at 0x130C28: env_err (gwion.c:110) +==14141== by 0x1514A7: path_valid (import.c:145) +==14141== by 0x151E06: str2list (import.c:167) +==14141== by 0x1536C5: import_td (import.c:418) +==14141== by 0x153856: make_dll_as_fun (import.c:436) +==14141== by 0x1539D1: gwi_func_end (import.c:449) +==14141== by 0x48481EC: import (invalid_func.c:20) +==14141== by 0x14AC48: type_engine_init (engine.c:107) +==14141== by 0x1308C5: gwion_engine (gwion.c:39) +==14141== by 0x1308C5: gwion_ini (gwion.c:78) +==14141== by 0x12F87D: main (main.c:23) +==14141== If you believe this happened as a result of a stack +==14141== overflow in your program's main thread (unlikely but +==14141== possible), you can try to increase the size of the +==14141== main thread stack using the --main-stacksize= flag. +==14141== The main thread stack size used in this run was 8388608. +==14141== +==14141== HEAP SUMMARY: +==14141== in use at exit: 2,171,353 bytes in 383 blocks +==14141== total heap usage: 809 allocs, 426 frees, 2,265,546 bytes allocated +==14141== +==14141== LEAK SUMMARY: +==14141== definitely lost: 0 bytes in 0 blocks +==14141== indirectly lost: 0 bytes in 0 blocks +==14141== possibly lost: 0 bytes in 0 blocks +==14141== still reachable: 2,171,353 bytes in 383 blocks +==14141== suppressed: 0 bytes in 0 blocks +==14141== Rerun with --leak-check=full to see details of leaked memory +==14141== +==14141== For counts of detected and suppressed errors, rerun with: -v +==14141== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==14187== Memcheck, a memory error detector +==14187== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==14187== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==14187== Command: ./../../gwion -p. -d dummy /dev/null +==14187== Parent PID: 13214 +==14187== +==14187== Invalid read of size 4 +==14187== at 0x130C28: env_err (gwion.c:110) +==14187== by 0x15132D: path_valid (import.c:135) +==14187== by 0x151E06: str2list (import.c:167) +==14187== by 0x152B6E: gwi_item_ini (import.c:302) +==14187== by 0x48481B5: import (invalid_type1.c:18) +==14187== by 0x14AC48: type_engine_init (engine.c:107) +==14187== by 0x1308C5: gwion_engine (gwion.c:39) +==14187== by 0x1308C5: gwion_ini (gwion.c:78) +==14187== by 0x12F87D: main (main.c:23) +==14187== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==14187== +==14187== +==14187== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==14187== Access not within mapped region at address 0x28 +==14187== at 0x130C28: env_err (gwion.c:110) +==14187== by 0x15132D: path_valid (import.c:135) +==14187== by 0x151E06: str2list (import.c:167) +==14187== by 0x152B6E: gwi_item_ini (import.c:302) +==14187== by 0x48481B5: import (invalid_type1.c:18) +==14187== by 0x14AC48: type_engine_init (engine.c:107) +==14187== by 0x1308C5: gwion_engine (gwion.c:39) +==14187== by 0x1308C5: gwion_ini (gwion.c:78) +==14187== by 0x12F87D: main (main.c:23) +==14187== If you believe this happened as a result of a stack +==14187== overflow in your program's main thread (unlikely but +==14187== possible), you can try to increase the size of the +==14187== main thread stack using the --main-stacksize= flag. +==14187== The main thread stack size used in this run was 8388608. +==14187== +==14187== HEAP SUMMARY: +==14187== in use at exit: 2,171,356 bytes in 383 blocks +==14187== total heap usage: 809 allocs, 426 frees, 2,265,553 bytes allocated +==14187== +==14187== LEAK SUMMARY: +==14187== definitely lost: 0 bytes in 0 blocks +==14187== indirectly lost: 0 bytes in 0 blocks +==14187== possibly lost: 0 bytes in 0 blocks +==14187== still reachable: 2,171,356 bytes in 383 blocks +==14187== suppressed: 0 bytes in 0 blocks +==14187== Rerun with --leak-check=full to see details of leaked memory +==14187== +==14187== For counts of detected and suppressed errors, rerun with: -v +==14187== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==14233== Memcheck, a memory error detector +==14233== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==14233== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==14233== Command: ./../../gwion -p. -d dummy /dev/null +==14233== Parent PID: 13214 +==14233== +==14233== Invalid read of size 4 +==14233== at 0x130C28: env_err (gwion.c:110) +==14233== by 0x1514A7: path_valid (import.c:145) +==14233== by 0x151E06: str2list (import.c:167) +==14233== by 0x152B6E: gwi_item_ini (import.c:302) +==14233== by 0x48481B5: import (invalid_type2.c:18) +==14233== by 0x14AC48: type_engine_init (engine.c:107) +==14233== by 0x1308C5: gwion_engine (gwion.c:39) +==14233== by 0x1308C5: gwion_ini (gwion.c:78) +==14233== by 0x12F87D: main (main.c:23) +==14233== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==14233== +==14233== +==14233== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==14233== Access not within mapped region at address 0x28 +==14233== at 0x130C28: env_err (gwion.c:110) +==14233== by 0x1514A7: path_valid (import.c:145) +==14233== by 0x151E06: str2list (import.c:167) +==14233== by 0x152B6E: gwi_item_ini (import.c:302) +==14233== by 0x48481B5: import (invalid_type2.c:18) +==14233== by 0x14AC48: type_engine_init (engine.c:107) +==14233== by 0x1308C5: gwion_engine (gwion.c:39) +==14233== by 0x1308C5: gwion_ini (gwion.c:78) +==14233== by 0x12F87D: main (main.c:23) +==14233== If you believe this happened as a result of a stack +==14233== overflow in your program's main thread (unlikely but +==14233== possible), you can try to increase the size of the +==14233== main thread stack using the --main-stacksize= flag. +==14233== The main thread stack size used in this run was 8388608. +==14233== +==14233== HEAP SUMMARY: +==14233== in use at exit: 2,171,356 bytes in 383 blocks +==14233== total heap usage: 809 allocs, 426 frees, 2,265,553 bytes allocated +==14233== +==14233== LEAK SUMMARY: +==14233== definitely lost: 0 bytes in 0 blocks +==14233== indirectly lost: 0 bytes in 0 blocks +==14233== possibly lost: 0 bytes in 0 blocks +==14233== still reachable: 2,171,356 bytes in 383 blocks +==14233== suppressed: 0 bytes in 0 blocks +==14233== Rerun with --leak-check=full to see details of leaked memory +==14233== +==14233== For counts of detected and suppressed errors, rerun with: -v +==14233== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==14279== Memcheck, a memory error detector +==14279== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==14279== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==14279== Command: ./../../gwion -p. -d dummy /dev/null +==14279== Parent PID: 13214 +==14279== +==14279== Invalid read of size 4 +==14279== at 0x130C28: env_err (gwion.c:110) +==14279== by 0x151192: name_valid (import.c:116) +==14279== by 0x152417: gwi_add_type (import.c:195) +==14279== by 0x1524DD: gwi_class_ini (import.c:229) +==14279== by 0x484818F: import (invalid_type3.c:18) +==14279== by 0x14AC48: type_engine_init (engine.c:107) +==14279== by 0x1308C5: gwion_engine (gwion.c:39) +==14279== by 0x1308C5: gwion_ini (gwion.c:78) +==14279== by 0x12F87D: main (main.c:23) +==14279== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==14279== +==14279== +==14279== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==14279== Access not within mapped region at address 0x28 +==14279== at 0x130C28: env_err (gwion.c:110) +==14279== by 0x151192: name_valid (import.c:116) +==14279== by 0x152417: gwi_add_type (import.c:195) +==14279== by 0x1524DD: gwi_class_ini (import.c:229) +==14279== by 0x484818F: import (invalid_type3.c:18) +==14279== by 0x14AC48: type_engine_init (engine.c:107) +==14279== by 0x1308C5: gwion_engine (gwion.c:39) +==14279== by 0x1308C5: gwion_ini (gwion.c:78) +==14279== by 0x12F87D: main (main.c:23) +==14279== If you believe this happened as a result of a stack +==14279== overflow in your program's main thread (unlikely but +==14279== possible), you can try to increase the size of the +==14279== main thread stack using the --main-stacksize= flag. +==14279== The main thread stack size used in this run was 8388608. +==14279== +==14279== HEAP SUMMARY: +==14279== in use at exit: 2,170,716 bytes in 374 blocks +==14279== total heap usage: 798 allocs, 424 frees, 2,264,849 bytes allocated +==14279== +==14279== LEAK SUMMARY: +==14279== definitely lost: 0 bytes in 0 blocks +==14279== indirectly lost: 0 bytes in 0 blocks +==14279== possibly lost: 0 bytes in 0 blocks +==14279== still reachable: 2,170,716 bytes in 374 blocks +==14279== suppressed: 0 bytes in 0 blocks +==14279== Rerun with --leak-check=full to see details of leaked memory +==14279== +==14279== For counts of detected and suppressed errors, rerun with: -v +==14279== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==14460== Memcheck, a memory error detector +==14460== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==14460== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==14460== Command: ./../../gwion -p. -d dummy /dev/null +==14460== Parent PID: 13214 +==14460== +==14460== Invalid read of size 4 +==14460== at 0x130C28: env_err (gwion.c:110) +==14460== by 0x1531A6: make_dll_arg_list (import.c:398) +==14460== by 0x153882: make_dll_as_fun (import.c:440) +==14460== by 0x1539D1: gwi_func_end (import.c:449) +==14460== by 0x4848225: import (template_arg.c:21) +==14460== by 0x14AC48: type_engine_init (engine.c:107) +==14460== by 0x1308C5: gwion_engine (gwion.c:39) +==14460== by 0x1308C5: gwion_ini (gwion.c:78) +==14460== by 0x12F87D: main (main.c:23) +==14460== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==14460== +==14460== +==14460== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==14460== Access not within mapped region at address 0x28 +==14460== at 0x130C28: env_err (gwion.c:110) +==14460== by 0x1531A6: make_dll_arg_list (import.c:398) +==14460== by 0x153882: make_dll_as_fun (import.c:440) +==14460== by 0x1539D1: gwi_func_end (import.c:449) +==14460== by 0x4848225: import (template_arg.c:21) +==14460== by 0x14AC48: type_engine_init (engine.c:107) +==14460== by 0x1308C5: gwion_engine (gwion.c:39) +==14460== by 0x1308C5: gwion_ini (gwion.c:78) +==14460== by 0x12F87D: main (main.c:23) +==14460== If you believe this happened as a result of a stack +==14460== overflow in your program's main thread (unlikely but +==14460== possible), you can try to increase the size of the +==14460== main thread stack using the --main-stacksize= flag. +==14460== The main thread stack size used in this run was 8388608. +==14460== +==14460== HEAP SUMMARY: +==14460== in use at exit: 2,177,657 bytes in 395 blocks +==14460== total heap usage: 829 allocs, 434 frees, 2,272,394 bytes allocated +==14460== +==14460== LEAK SUMMARY: +==14460== definitely lost: 0 bytes in 0 blocks +==14460== indirectly lost: 0 bytes in 0 blocks +==14460== possibly lost: 0 bytes in 0 blocks +==14460== still reachable: 2,177,657 bytes in 395 blocks +==14460== suppressed: 0 bytes in 0 blocks +==14460== Rerun with --leak-check=full to see details of leaked memory +==14460== +==14460== For counts of detected and suppressed errors, rerun with: -v +==14460== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==14807== Memcheck, a memory error detector +==14807== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==14807== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==14807== Command: ./../../gwion -p. -d dummy /dev/null +==14807== Parent PID: 14781 +==14807== +==14807== +==14807== HEAP SUMMARY: +==14807== in use at exit: 928 bytes in 10 blocks +==14807== total heap usage: 997 allocs, 987 frees, 7,604,988 bytes allocated +==14807== +==14807== LEAK SUMMARY: +==14807== definitely lost: 928 bytes in 10 blocks +==14807== indirectly lost: 0 bytes in 0 blocks +==14807== possibly lost: 0 bytes in 0 blocks +==14807== still reachable: 0 bytes in 0 blocks +==14807== suppressed: 0 bytes in 0 blocks +==14807== Rerun with --leak-check=full to see details of leaked memory +==14807== +==14807== For counts of detected and suppressed errors, rerun with: -v +==14807== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0) +/dev/null ==14905== Memcheck, a memory error detector +==14905== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==14905== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==14905== Command: ./../../gwion -p. -d dummy /dev/null +==14905== Parent PID: 14781 +==14905== +==14905== Invalid read of size 4 +==14905== at 0x130C28: env_err (gwion.c:110) +==14905== by 0x15255E: gwi_class_ini (import.c:220) +==14905== by 0x48481A0: import (begin_class.c:18) +==14905== by 0x14AC48: type_engine_init (engine.c:107) +==14905== by 0x1308C5: gwion_engine (gwion.c:39) +==14905== by 0x1308C5: gwion_ini (gwion.c:78) +==14905== by 0x12F87D: main (main.c:23) +==14905== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==14905== +==14905== +==14905== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==14905== Access not within mapped region at address 0x28 +==14905== at 0x130C28: env_err (gwion.c:110) +==14905== by 0x15255E: gwi_class_ini (import.c:220) +==14905== by 0x48481A0: import (begin_class.c:18) +==14905== by 0x14AC48: type_engine_init (engine.c:107) +==14905== by 0x1308C5: gwion_engine (gwion.c:39) +==14905== by 0x1308C5: gwion_ini (gwion.c:78) +==14905== by 0x12F87D: main (main.c:23) +==14905== If you believe this happened as a result of a stack +==14905== overflow in your program's main thread (unlikely but +==14905== possible), you can try to increase the size of the +==14905== main thread stack using the --main-stacksize= flag. +==14905== The main thread stack size used in this run was 8388608. +==14905== +==14905== HEAP SUMMARY: +==14905== in use at exit: 2,171,350 bytes in 383 blocks +==14905== total heap usage: 809 allocs, 426 frees, 2,265,539 bytes allocated +==14905== +==14905== LEAK SUMMARY: +==14905== definitely lost: 0 bytes in 0 blocks +==14905== indirectly lost: 0 bytes in 0 blocks +==14905== possibly lost: 0 bytes in 0 blocks +==14905== still reachable: 2,171,350 bytes in 383 blocks +==14905== suppressed: 0 bytes in 0 blocks +==14905== Rerun with --leak-check=full to see details of leaked memory +==14905== +==14905== For counts of detected and suppressed errors, rerun with: -v +==14905== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==15131== Memcheck, a memory error detector +==15131== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==15131== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==15131== Command: ./../../gwion -p. -d dummy /dev/null +==15131== Parent PID: 14781 +==15131== +==15131== Invalid read of size 4 +==15131== at 0x130C28: env_err (gwion.c:110) +==15131== by 0x154233: gwi_union_end (import.c:601) +==15131== by 0x4848152: import (empty_union.c:15) +==15131== by 0x14AC48: type_engine_init (engine.c:107) +==15131== by 0x1308C5: gwion_engine (gwion.c:39) +==15131== by 0x1308C5: gwion_ini (gwion.c:78) +==15131== by 0x12F87D: main (main.c:23) +==15131== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==15131== +==15131== +==15131== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==15131== Access not within mapped region at address 0x28 +==15131== at 0x130C28: env_err (gwion.c:110) +==15131== by 0x154233: gwi_union_end (import.c:601) +==15131== by 0x4848152: import (empty_union.c:15) +==15131== by 0x14AC48: type_engine_init (engine.c:107) +==15131== by 0x1308C5: gwion_engine (gwion.c:39) +==15131== by 0x1308C5: gwion_ini (gwion.c:78) +==15131== by 0x12F87D: main (main.c:23) +==15131== If you believe this happened as a result of a stack +==15131== overflow in your program's main thread (unlikely but +==15131== possible), you can try to increase the size of the +==15131== main thread stack using the --main-stacksize= flag. +==15131== The main thread stack size used in this run was 8388608. +==15131== +==15131== HEAP SUMMARY: +==15131== in use at exit: 2,170,710 bytes in 374 blocks +==15131== total heap usage: 798 allocs, 424 frees, 2,264,835 bytes allocated +==15131== +==15131== LEAK SUMMARY: +==15131== definitely lost: 0 bytes in 0 blocks +==15131== indirectly lost: 0 bytes in 0 blocks +==15131== possibly lost: 0 bytes in 0 blocks +==15131== still reachable: 2,170,710 bytes in 374 blocks +==15131== suppressed: 0 bytes in 0 blocks +==15131== Rerun with --leak-check=full to see details of leaked memory +==15131== +==15131== For counts of detected and suppressed errors, rerun with: -v +==15131== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==15177== Memcheck, a memory error detector +==15177== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==15177== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==15177== Command: ./../../gwion -p. -d dummy /dev/null +==15177== Parent PID: 14781 +==15177== +==15177== Invalid read of size 4 +==15177== at 0x130C28: env_err (gwion.c:110) +==15177== by 0x152ADD: gwi_class_end (import.c:268) +==15177== by 0x4848133: import (end_class.c:15) +==15177== by 0x14AC48: type_engine_init (engine.c:107) +==15177== by 0x1308C5: gwion_engine (gwion.c:39) +==15177== by 0x1308C5: gwion_ini (gwion.c:78) +==15177== by 0x12F87D: main (main.c:23) +==15177== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==15177== +==15177== +==15177== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==15177== Access not within mapped region at address 0x28 +==15177== at 0x130C28: env_err (gwion.c:110) +==15177== by 0x152ADD: gwi_class_end (import.c:268) +==15177== by 0x4848133: import (end_class.c:15) +==15177== by 0x14AC48: type_engine_init (engine.c:107) +==15177== by 0x1308C5: gwion_engine (gwion.c:39) +==15177== by 0x1308C5: gwion_ini (gwion.c:78) +==15177== by 0x12F87D: main (main.c:23) +==15177== If you believe this happened as a result of a stack +==15177== overflow in your program's main thread (unlikely but +==15177== possible), you can try to increase the size of the +==15177== main thread stack using the --main-stacksize= flag. +==15177== The main thread stack size used in this run was 8388608. +==15177== +==15177== HEAP SUMMARY: +==15177== in use at exit: 2,170,704 bytes in 374 blocks +==15177== total heap usage: 798 allocs, 424 frees, 2,264,821 bytes allocated +==15177== +==15177== LEAK SUMMARY: +==15177== definitely lost: 0 bytes in 0 blocks +==15177== indirectly lost: 0 bytes in 0 blocks +==15177== possibly lost: 0 bytes in 0 blocks +==15177== still reachable: 2,170,704 bytes in 374 blocks +==15177== suppressed: 0 bytes in 0 blocks +==15177== Rerun with --leak-check=full to see details of leaked memory +==15177== +==15177== For counts of detected and suppressed errors, rerun with: -v +==15177== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +enum.gw ==15223== Memcheck, a memory error detector +==15223== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==15223== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==15223== Command: ./../../gwion -p. -d dummy enum.gw +==15223== Parent PID: 14781 +==15223== +==15223== +==15223== HEAP SUMMARY: +==15223== in use at exit: 2,145,665 bytes in 284 blocks +==15223== total heap usage: 696 allocs, 412 frees, 2,274,327 bytes allocated +==15223== +==15223== LEAK SUMMARY: +==15223== definitely lost: 256 bytes in 4 blocks +==15223== indirectly lost: 19 bytes in 1 blocks +==15223== possibly lost: 2,143,840 bytes in 274 blocks +==15223== still reachable: 1,550 bytes in 5 blocks +==15223== suppressed: 0 bytes in 0 blocks +==15223== Rerun with --leak-check=full to see details of leaked memory +==15223== +==15223== For counts of detected and suppressed errors, rerun with: -v +==15223== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0) +/dev/null ==15575== Memcheck, a memory error detector +==15575== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==15575== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==15575== Command: ./../../gwion -p. -d dummy /dev/null +==15575== Parent PID: 15549 +==15575== +==15575== +==15575== HEAP SUMMARY: +==15575== in use at exit: 928 bytes in 10 blocks +==15575== total heap usage: 1,028 allocs, 1,018 frees, 7,608,142 bytes allocated +==15575== +==15575== LEAK SUMMARY: +==15575== definitely lost: 928 bytes in 10 blocks +==15575== indirectly lost: 0 bytes in 0 blocks +==15575== possibly lost: 0 bytes in 0 blocks +==15575== still reachable: 0 bytes in 0 blocks +==15575== suppressed: 0 bytes in 0 blocks +==15575== Rerun with --leak-check=full to see details of leaked memory +==15575== +==15575== For counts of detected and suppressed errors, rerun with: -v +==15575== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0) +/dev/null ==15673== Memcheck, a memory error detector +==15673== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==15673== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==15673== Command: ./../../gwion -p. -d dummy /dev/null +==15673== Parent PID: 15549 +==15673== +==15673== Invalid read of size 4 +==15673== at 0x130C28: env_err (gwion.c:110) +==15673== by 0x15255E: gwi_class_ini (import.c:220) +==15673== by 0x48481A0: import (begin_class.c:18) +==15673== by 0x14AC48: type_engine_init (engine.c:107) +==15673== by 0x1308C5: gwion_engine (gwion.c:39) +==15673== by 0x1308C5: gwion_ini (gwion.c:78) +==15673== by 0x12F87D: main (main.c:23) +==15673== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==15673== +==15673== +==15673== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==15673== Access not within mapped region at address 0x28 +==15673== at 0x130C28: env_err (gwion.c:110) +==15673== by 0x15255E: gwi_class_ini (import.c:220) +==15673== by 0x48481A0: import (begin_class.c:18) +==15673== by 0x14AC48: type_engine_init (engine.c:107) +==15673== by 0x1308C5: gwion_engine (gwion.c:39) +==15673== by 0x1308C5: gwion_ini (gwion.c:78) +==15673== by 0x12F87D: main (main.c:23) +==15673== If you believe this happened as a result of a stack +==15673== overflow in your program's main thread (unlikely but +==15673== possible), you can try to increase the size of the +==15673== main thread stack using the --main-stacksize= flag. +==15673== The main thread stack size used in this run was 8388608. +==15673== +==15673== HEAP SUMMARY: +==15673== in use at exit: 2,172,780 bytes in 387 blocks +==15673== total heap usage: 818 allocs, 431 frees, 2,267,157 bytes allocated +==15673== +==15673== LEAK SUMMARY: +==15673== definitely lost: 0 bytes in 0 blocks +==15673== indirectly lost: 0 bytes in 0 blocks +==15673== possibly lost: 0 bytes in 0 blocks +==15673== still reachable: 2,172,780 bytes in 387 blocks +==15673== suppressed: 0 bytes in 0 blocks +==15673== Rerun with --leak-check=full to see details of leaked memory +==15673== +==15673== For counts of detected and suppressed errors, rerun with: -v +==15673== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==15899== Memcheck, a memory error detector +==15899== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==15899== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==15899== Command: ./../../gwion -p. -d dummy /dev/null +==15899== Parent PID: 15549 +==15899== +==15899== Invalid read of size 4 +==15899== at 0x130C28: env_err (gwion.c:110) +==15899== by 0x154233: gwi_union_end (import.c:601) +==15899== by 0x4848152: import (empty_union.c:15) +==15899== by 0x14AC48: type_engine_init (engine.c:107) +==15899== by 0x1308C5: gwion_engine (gwion.c:39) +==15899== by 0x1308C5: gwion_ini (gwion.c:78) +==15899== by 0x12F87D: main (main.c:23) +==15899== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==15899== +==15899== +==15899== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==15899== Access not within mapped region at address 0x28 +==15899== at 0x130C28: env_err (gwion.c:110) +==15899== by 0x154233: gwi_union_end (import.c:601) +==15899== by 0x4848152: import (empty_union.c:15) +==15899== by 0x14AC48: type_engine_init (engine.c:107) +==15899== by 0x1308C5: gwion_engine (gwion.c:39) +==15899== by 0x1308C5: gwion_ini (gwion.c:78) +==15899== by 0x12F87D: main (main.c:23) +==15899== If you believe this happened as a result of a stack +==15899== overflow in your program's main thread (unlikely but +==15899== possible), you can try to increase the size of the +==15899== main thread stack using the --main-stacksize= flag. +==15899== The main thread stack size used in this run was 8388608. +==15899== +==15899== HEAP SUMMARY: +==15899== in use at exit: 2,172,140 bytes in 378 blocks +==15899== total heap usage: 807 allocs, 429 frees, 2,266,453 bytes allocated +==15899== +==15899== LEAK SUMMARY: +==15899== definitely lost: 0 bytes in 0 blocks +==15899== indirectly lost: 0 bytes in 0 blocks +==15899== possibly lost: 0 bytes in 0 blocks +==15899== still reachable: 2,172,140 bytes in 378 blocks +==15899== suppressed: 0 bytes in 0 blocks +==15899== Rerun with --leak-check=full to see details of leaked memory +==15899== +==15899== For counts of detected and suppressed errors, rerun with: -v +==15899== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==15945== Memcheck, a memory error detector +==15945== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==15945== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==15945== Command: ./../../gwion -p. -d dummy /dev/null +==15945== Parent PID: 15549 +==15945== +==15945== Invalid read of size 4 +==15945== at 0x130C28: env_err (gwion.c:110) +==15945== by 0x152ADD: gwi_class_end (import.c:268) +==15945== by 0x4848133: import (end_class.c:15) +==15945== by 0x14AC48: type_engine_init (engine.c:107) +==15945== by 0x1308C5: gwion_engine (gwion.c:39) +==15945== by 0x1308C5: gwion_ini (gwion.c:78) +==15945== by 0x12F87D: main (main.c:23) +==15945== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==15945== +==15945== +==15945== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==15945== Access not within mapped region at address 0x28 +==15945== at 0x130C28: env_err (gwion.c:110) +==15945== by 0x152ADD: gwi_class_end (import.c:268) +==15945== by 0x4848133: import (end_class.c:15) +==15945== by 0x14AC48: type_engine_init (engine.c:107) +==15945== by 0x1308C5: gwion_engine (gwion.c:39) +==15945== by 0x1308C5: gwion_ini (gwion.c:78) +==15945== by 0x12F87D: main (main.c:23) +==15945== If you believe this happened as a result of a stack +==15945== overflow in your program's main thread (unlikely but +==15945== possible), you can try to increase the size of the +==15945== main thread stack using the --main-stacksize= flag. +==15945== The main thread stack size used in this run was 8388608. +==15945== +==15945== HEAP SUMMARY: +==15945== in use at exit: 2,172,134 bytes in 378 blocks +==15945== total heap usage: 807 allocs, 429 frees, 2,266,439 bytes allocated +==15945== +==15945== LEAK SUMMARY: +==15945== definitely lost: 0 bytes in 0 blocks +==15945== indirectly lost: 0 bytes in 0 blocks +==15945== possibly lost: 0 bytes in 0 blocks +==15945== still reachable: 2,172,134 bytes in 378 blocks +==15945== suppressed: 0 bytes in 0 blocks +==15945== Rerun with --leak-check=full to see details of leaked memory +==15945== +==15945== For counts of detected and suppressed errors, rerun with: -v +==15945== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==16255== Memcheck, a memory error detector +==16255== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==16255== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==16255== Command: ./../../gwion -p. -d dummy /dev/null +==16255== Parent PID: 15549 +==16255== +==16255== Invalid read of size 4 +==16255== at 0x130C28: env_err (gwion.c:110) +==16255== by 0x1514A7: path_valid (import.c:145) +==16255== by 0x151E06: str2list (import.c:167) +==16255== by 0x152F24: str2decl (import.c:366) +==16255== by 0x15334E: make_dll_arg_list (import.c:395) +==16255== by 0x153882: make_dll_as_fun (import.c:440) +==16255== by 0x1539D1: gwi_func_end (import.c:449) +==16255== by 0x4848225: import (invalid_arg.c:21) +==16255== by 0x14AC48: type_engine_init (engine.c:107) +==16255== by 0x1308C5: gwion_engine (gwion.c:39) +==16255== by 0x1308C5: gwion_ini (gwion.c:78) +==16255== by 0x12F87D: main (main.c:23) +==16255== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==16255== +==16255== +==16255== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==16255== Access not within mapped region at address 0x28 +==16255== at 0x130C28: env_err (gwion.c:110) +==16255== by 0x1514A7: path_valid (import.c:145) +==16255== by 0x151E06: str2list (import.c:167) +==16255== by 0x152F24: str2decl (import.c:366) +==16255== by 0x15334E: make_dll_arg_list (import.c:395) +==16255== by 0x153882: make_dll_as_fun (import.c:440) +==16255== by 0x1539D1: gwi_func_end (import.c:449) +==16255== by 0x4848225: import (invalid_arg.c:21) +==16255== by 0x14AC48: type_engine_init (engine.c:107) +==16255== by 0x1308C5: gwion_engine (gwion.c:39) +==16255== by 0x1308C5: gwion_ini (gwion.c:78) +==16255== by 0x12F87D: main (main.c:23) +==16255== If you believe this happened as a result of a stack +==16255== overflow in your program's main thread (unlikely but +==16255== possible), you can try to increase the size of the +==16255== main thread stack using the --main-stacksize= flag. +==16255== The main thread stack size used in this run was 8388608. +==16255== +==16255== HEAP SUMMARY: +==16255== in use at exit: 2,171,862 bytes in 384 blocks +==16255== total heap usage: 810 allocs, 426 frees, 2,266,051 bytes allocated +==16255== +==16255== LEAK SUMMARY: +==16255== definitely lost: 0 bytes in 0 blocks +==16255== indirectly lost: 0 bytes in 0 blocks +==16255== possibly lost: 0 bytes in 0 blocks +==16255== still reachable: 2,171,862 bytes in 384 blocks +==16255== suppressed: 0 bytes in 0 blocks +==16255== Rerun with --leak-check=full to see details of leaked memory +==16255== +==16255== For counts of detected and suppressed errors, rerun with: -v +==16255== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==16301== Memcheck, a memory error detector +==16301== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==16301== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==16301== Command: ./../../gwion -p. -d dummy /dev/null +==16301== Parent PID: 15549 +==16301== +==16301== Invalid read of size 4 +==16301== at 0x130C28: env_err (gwion.c:110) +==16301== by 0x153425: make_dll_arg_list (import.c:406) +==16301== by 0x153882: make_dll_as_fun (import.c:440) +==16301== by 0x1539D1: gwi_func_end (import.c:449) +==16301== by 0x48482A6: import (invalid_array.c:24) +==16301== by 0x14AC48: type_engine_init (engine.c:107) +==16301== by 0x1308C5: gwion_engine (gwion.c:39) +==16301== by 0x1308C5: gwion_ini (gwion.c:78) +==16301== by 0x12F87D: main (main.c:23) +==16301== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==16301== +==16301== +==16301== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==16301== Access not within mapped region at address 0x28 +==16301== at 0x130C28: env_err (gwion.c:110) +==16301== by 0x153425: make_dll_arg_list (import.c:406) +==16301== by 0x153882: make_dll_as_fun (import.c:440) +==16301== by 0x1539D1: gwi_func_end (import.c:449) +==16301== by 0x48482A6: import (invalid_array.c:24) +==16301== by 0x14AC48: type_engine_init (engine.c:107) +==16301== by 0x1308C5: gwion_engine (gwion.c:39) +==16301== by 0x1308C5: gwion_ini (gwion.c:78) +==16301== by 0x12F87D: main (main.c:23) +==16301== If you believe this happened as a result of a stack +==16301== overflow in your program's main thread (unlikely but +==16301== possible), you can try to increase the size of the +==16301== main thread stack using the --main-stacksize= flag. +==16301== The main thread stack size used in this run was 8388608. +==16301== +==16301== HEAP SUMMARY: +==16301== in use at exit: 2,173,020 bytes in 385 blocks +==16301== total heap usage: 812 allocs, 427 frees, 2,267,345 bytes allocated +==16301== +==16301== LEAK SUMMARY: +==16301== definitely lost: 0 bytes in 0 blocks +==16301== indirectly lost: 0 bytes in 0 blocks +==16301== possibly lost: 0 bytes in 0 blocks +==16301== still reachable: 2,173,020 bytes in 385 blocks +==16301== suppressed: 0 bytes in 0 blocks +==16301== Rerun with --leak-check=full to see details of leaked memory +==16301== +==16301== For counts of detected and suppressed errors, rerun with: -v +==16301== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==16347== Memcheck, a memory error detector +==16347== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==16347== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==16347== Command: ./../../gwion -p. -d dummy /dev/null +==16347== Parent PID: 15549 +==16347== +==16347== Invalid read of size 4 +==16347== at 0x130C28: env_err (gwion.c:110) +==16347== by 0x1514A7: path_valid (import.c:145) +==16347== by 0x151E06: str2list (import.c:167) +==16347== by 0x1536C5: import_td (import.c:418) +==16347== by 0x153856: make_dll_as_fun (import.c:436) +==16347== by 0x1539D1: gwi_func_end (import.c:449) +==16347== by 0x48481EC: import (invalid_func.c:20) +==16347== by 0x14AC48: type_engine_init (engine.c:107) +==16347== by 0x1308C5: gwion_engine (gwion.c:39) +==16347== by 0x1308C5: gwion_ini (gwion.c:78) +==16347== by 0x12F87D: main (main.c:23) +==16347== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==16347== +==16347== +==16347== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==16347== Access not within mapped region at address 0x28 +==16347== at 0x130C28: env_err (gwion.c:110) +==16347== by 0x1514A7: path_valid (import.c:145) +==16347== by 0x151E06: str2list (import.c:167) +==16347== by 0x1536C5: import_td (import.c:418) +==16347== by 0x153856: make_dll_as_fun (import.c:436) +==16347== by 0x1539D1: gwi_func_end (import.c:449) +==16347== by 0x48481EC: import (invalid_func.c:20) +==16347== by 0x14AC48: type_engine_init (engine.c:107) +==16347== by 0x1308C5: gwion_engine (gwion.c:39) +==16347== by 0x1308C5: gwion_ini (gwion.c:78) +==16347== by 0x12F87D: main (main.c:23) +==16347== If you believe this happened as a result of a stack +==16347== overflow in your program's main thread (unlikely but +==16347== possible), you can try to increase the size of the +==16347== main thread stack using the --main-stacksize= flag. +==16347== The main thread stack size used in this run was 8388608. +==16347== +==16347== HEAP SUMMARY: +==16347== in use at exit: 2,171,353 bytes in 383 blocks +==16347== total heap usage: 809 allocs, 426 frees, 2,265,546 bytes allocated +==16347== +==16347== LEAK SUMMARY: +==16347== definitely lost: 0 bytes in 0 blocks +==16347== indirectly lost: 0 bytes in 0 blocks +==16347== possibly lost: 0 bytes in 0 blocks +==16347== still reachable: 2,171,353 bytes in 383 blocks +==16347== suppressed: 0 bytes in 0 blocks +==16347== Rerun with --leak-check=full to see details of leaked memory +==16347== +==16347== For counts of detected and suppressed errors, rerun with: -v +==16347== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==16393== Memcheck, a memory error detector +==16393== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==16393== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==16393== Command: ./../../gwion -p. -d dummy /dev/null +==16393== Parent PID: 15549 +==16393== +==16393== Invalid read of size 4 +==16393== at 0x130C28: env_err (gwion.c:110) +==16393== by 0x15132D: path_valid (import.c:135) +==16393== by 0x151E06: str2list (import.c:167) +==16393== by 0x152B6E: gwi_item_ini (import.c:302) +==16393== by 0x48481B5: import (invalid_type1.c:18) +==16393== by 0x14AC48: type_engine_init (engine.c:107) +==16393== by 0x1308C5: gwion_engine (gwion.c:39) +==16393== by 0x1308C5: gwion_ini (gwion.c:78) +==16393== by 0x12F87D: main (main.c:23) +==16393== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==16393== +==16393== +==16393== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==16393== Access not within mapped region at address 0x28 +==16393== at 0x130C28: env_err (gwion.c:110) +==16393== by 0x15132D: path_valid (import.c:135) +==16393== by 0x151E06: str2list (import.c:167) +==16393== by 0x152B6E: gwi_item_ini (import.c:302) +==16393== by 0x48481B5: import (invalid_type1.c:18) +==16393== by 0x14AC48: type_engine_init (engine.c:107) +==16393== by 0x1308C5: gwion_engine (gwion.c:39) +==16393== by 0x1308C5: gwion_ini (gwion.c:78) +==16393== by 0x12F87D: main (main.c:23) +==16393== If you believe this happened as a result of a stack +==16393== overflow in your program's main thread (unlikely but +==16393== possible), you can try to increase the size of the +==16393== main thread stack using the --main-stacksize= flag. +==16393== The main thread stack size used in this run was 8388608. +==16393== +==16393== HEAP SUMMARY: +==16393== in use at exit: 2,171,356 bytes in 383 blocks +==16393== total heap usage: 809 allocs, 426 frees, 2,265,553 bytes allocated +==16393== +==16393== LEAK SUMMARY: +==16393== definitely lost: 0 bytes in 0 blocks +==16393== indirectly lost: 0 bytes in 0 blocks +==16393== possibly lost: 0 bytes in 0 blocks +==16393== still reachable: 2,171,356 bytes in 383 blocks +==16393== suppressed: 0 bytes in 0 blocks +==16393== Rerun with --leak-check=full to see details of leaked memory +==16393== +==16393== For counts of detected and suppressed errors, rerun with: -v +==16393== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==16439== Memcheck, a memory error detector +==16439== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==16439== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==16439== Command: ./../../gwion -p. -d dummy /dev/null +==16439== Parent PID: 15549 +==16439== +==16439== Invalid read of size 4 +==16439== at 0x130C28: env_err (gwion.c:110) +==16439== by 0x1514A7: path_valid (import.c:145) +==16439== by 0x151E06: str2list (import.c:167) +==16439== by 0x152B6E: gwi_item_ini (import.c:302) +==16439== by 0x48481B5: import (invalid_type2.c:18) +==16439== by 0x14AC48: type_engine_init (engine.c:107) +==16439== by 0x1308C5: gwion_engine (gwion.c:39) +==16439== by 0x1308C5: gwion_ini (gwion.c:78) +==16439== by 0x12F87D: main (main.c:23) +==16439== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==16439== +==16439== +==16439== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==16439== Access not within mapped region at address 0x28 +==16439== at 0x130C28: env_err (gwion.c:110) +==16439== by 0x1514A7: path_valid (import.c:145) +==16439== by 0x151E06: str2list (import.c:167) +==16439== by 0x152B6E: gwi_item_ini (import.c:302) +==16439== by 0x48481B5: import (invalid_type2.c:18) +==16439== by 0x14AC48: type_engine_init (engine.c:107) +==16439== by 0x1308C5: gwion_engine (gwion.c:39) +==16439== by 0x1308C5: gwion_ini (gwion.c:78) +==16439== by 0x12F87D: main (main.c:23) +==16439== If you believe this happened as a result of a stack +==16439== overflow in your program's main thread (unlikely but +==16439== possible), you can try to increase the size of the +==16439== main thread stack using the --main-stacksize= flag. +==16439== The main thread stack size used in this run was 8388608. +==16439== +==16439== HEAP SUMMARY: +==16439== in use at exit: 2,171,356 bytes in 383 blocks +==16439== total heap usage: 809 allocs, 426 frees, 2,265,553 bytes allocated +==16439== +==16439== LEAK SUMMARY: +==16439== definitely lost: 0 bytes in 0 blocks +==16439== indirectly lost: 0 bytes in 0 blocks +==16439== possibly lost: 0 bytes in 0 blocks +==16439== still reachable: 2,171,356 bytes in 383 blocks +==16439== suppressed: 0 bytes in 0 blocks +==16439== Rerun with --leak-check=full to see details of leaked memory +==16439== +==16439== For counts of detected and suppressed errors, rerun with: -v +==16439== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==16485== Memcheck, a memory error detector +==16485== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==16485== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==16485== Command: ./../../gwion -p. -d dummy /dev/null +==16485== Parent PID: 15549 +==16485== +==16485== Invalid read of size 4 +==16485== at 0x130C28: env_err (gwion.c:110) +==16485== by 0x151192: name_valid (import.c:116) +==16485== by 0x152417: gwi_add_type (import.c:195) +==16485== by 0x1524DD: gwi_class_ini (import.c:229) +==16485== by 0x484818F: import (invalid_type3.c:18) +==16485== by 0x14AC48: type_engine_init (engine.c:107) +==16485== by 0x1308C5: gwion_engine (gwion.c:39) +==16485== by 0x1308C5: gwion_ini (gwion.c:78) +==16485== by 0x12F87D: main (main.c:23) +==16485== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==16485== +==16485== +==16485== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==16485== Access not within mapped region at address 0x28 +==16485== at 0x130C28: env_err (gwion.c:110) +==16485== by 0x151192: name_valid (import.c:116) +==16485== by 0x152417: gwi_add_type (import.c:195) +==16485== by 0x1524DD: gwi_class_ini (import.c:229) +==16485== by 0x484818F: import (invalid_type3.c:18) +==16485== by 0x14AC48: type_engine_init (engine.c:107) +==16485== by 0x1308C5: gwion_engine (gwion.c:39) +==16485== by 0x1308C5: gwion_ini (gwion.c:78) +==16485== by 0x12F87D: main (main.c:23) +==16485== If you believe this happened as a result of a stack +==16485== overflow in your program's main thread (unlikely but +==16485== possible), you can try to increase the size of the +==16485== main thread stack using the --main-stacksize= flag. +==16485== The main thread stack size used in this run was 8388608. +==16485== +==16485== HEAP SUMMARY: +==16485== in use at exit: 2,170,716 bytes in 374 blocks +==16485== total heap usage: 798 allocs, 424 frees, 2,264,849 bytes allocated +==16485== +==16485== LEAK SUMMARY: +==16485== definitely lost: 0 bytes in 0 blocks +==16485== indirectly lost: 0 bytes in 0 blocks +==16485== possibly lost: 0 bytes in 0 blocks +==16485== still reachable: 2,170,716 bytes in 374 blocks +==16485== suppressed: 0 bytes in 0 blocks +==16485== Rerun with --leak-check=full to see details of leaked memory +==16485== +==16485== For counts of detected and suppressed errors, rerun with: -v +==16485== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==16666== Memcheck, a memory error detector +==16666== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==16666== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==16666== Command: ./../../gwion -p. -d dummy /dev/null +==16666== Parent PID: 15549 +==16666== +==16666== Invalid read of size 4 +==16666== at 0x130C28: env_err (gwion.c:110) +==16666== by 0x1531A6: make_dll_arg_list (import.c:398) +==16666== by 0x153882: make_dll_as_fun (import.c:440) +==16666== by 0x1539D1: gwi_func_end (import.c:449) +==16666== by 0x4848225: import (template_arg.c:21) +==16666== by 0x14AC48: type_engine_init (engine.c:107) +==16666== by 0x1308C5: gwion_engine (gwion.c:39) +==16666== by 0x1308C5: gwion_ini (gwion.c:78) +==16666== by 0x12F87D: main (main.c:23) +==16666== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==16666== +==16666== +==16666== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==16666== Access not within mapped region at address 0x28 +==16666== at 0x130C28: env_err (gwion.c:110) +==16666== by 0x1531A6: make_dll_arg_list (import.c:398) +==16666== by 0x153882: make_dll_as_fun (import.c:440) +==16666== by 0x1539D1: gwi_func_end (import.c:449) +==16666== by 0x4848225: import (template_arg.c:21) +==16666== by 0x14AC48: type_engine_init (engine.c:107) +==16666== by 0x1308C5: gwion_engine (gwion.c:39) +==16666== by 0x1308C5: gwion_ini (gwion.c:78) +==16666== by 0x12F87D: main (main.c:23) +==16666== If you believe this happened as a result of a stack +==16666== overflow in your program's main thread (unlikely but +==16666== possible), you can try to increase the size of the +==16666== main thread stack using the --main-stacksize= flag. +==16666== The main thread stack size used in this run was 8388608. +==16666== +==16666== HEAP SUMMARY: +==16666== in use at exit: 2,177,657 bytes in 395 blocks +==16666== total heap usage: 829 allocs, 434 frees, 2,272,394 bytes allocated +==16666== +==16666== LEAK SUMMARY: +==16666== definitely lost: 0 bytes in 0 blocks +==16666== indirectly lost: 0 bytes in 0 blocks +==16666== possibly lost: 0 bytes in 0 blocks +==16666== still reachable: 2,177,657 bytes in 395 blocks +==16666== suppressed: 0 bytes in 0 blocks +==16666== Rerun with --leak-check=full to see details of leaked memory +==16666== +==16666== For counts of detected and suppressed errors, rerun with: -v +==16666== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==18107== Memcheck, a memory error detector +==18107== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==18107== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==18107== Command: ./../../gwion -p. -d dummy /dev/null +==18107== Parent PID: 18081 +==18107== +==18107== +==18107== HEAP SUMMARY: +==18107== in use at exit: 928 bytes in 10 blocks +==18107== total heap usage: 997 allocs, 987 frees, 7,604,988 bytes allocated +==18107== +==18107== LEAK SUMMARY: +==18107== definitely lost: 928 bytes in 10 blocks +==18107== indirectly lost: 0 bytes in 0 blocks +==18107== possibly lost: 0 bytes in 0 blocks +==18107== still reachable: 0 bytes in 0 blocks +==18107== suppressed: 0 bytes in 0 blocks +==18107== Rerun with --leak-check=full to see details of leaked memory +==18107== +==18107== For counts of detected and suppressed errors, rerun with: -v +==18107== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0) +/dev/null ==18205== Memcheck, a memory error detector +==18205== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==18205== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==18205== Command: ./../../gwion -p. -d dummy /dev/null +==18205== Parent PID: 18081 +==18205== +==18205== Invalid read of size 4 +==18205== at 0x130C08: env_err (gwion.c:110) +==18205== by 0x1524AC: gwi_class_ini (import.c:220) +==18205== by 0x48481A0: import (begin_class.c:18) +==18205== by 0x14AC28: type_engine_init (engine.c:107) +==18205== by 0x1308A5: gwion_engine (gwion.c:39) +==18205== by 0x1308A5: gwion_ini (gwion.c:78) +==18205== by 0x12F85D: main (main.c:23) +==18205== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==18205== +==18205== +==18205== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==18205== Access not within mapped region at address 0x28 +==18205== at 0x130C08: env_err (gwion.c:110) +==18205== by 0x1524AC: gwi_class_ini (import.c:220) +==18205== by 0x48481A0: import (begin_class.c:18) +==18205== by 0x14AC28: type_engine_init (engine.c:107) +==18205== by 0x1308A5: gwion_engine (gwion.c:39) +==18205== by 0x1308A5: gwion_ini (gwion.c:78) +==18205== by 0x12F85D: main (main.c:23) +==18205== If you believe this happened as a result of a stack +==18205== overflow in your program's main thread (unlikely but +==18205== possible), you can try to increase the size of the +==18205== main thread stack using the --main-stacksize= flag. +==18205== The main thread stack size used in this run was 8388608. +==18205== +==18205== HEAP SUMMARY: +==18205== in use at exit: 2,171,350 bytes in 383 blocks +==18205== total heap usage: 809 allocs, 426 frees, 2,265,539 bytes allocated +==18205== +==18205== LEAK SUMMARY: +==18205== definitely lost: 0 bytes in 0 blocks +==18205== indirectly lost: 0 bytes in 0 blocks +==18205== possibly lost: 0 bytes in 0 blocks +==18205== still reachable: 2,171,350 bytes in 383 blocks +==18205== suppressed: 0 bytes in 0 blocks +==18205== Rerun with --leak-check=full to see details of leaked memory +==18205== +==18205== For counts of detected and suppressed errors, rerun with: -v +==18205== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==18432== Memcheck, a memory error detector +==18432== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==18432== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==18432== Command: ./../../gwion -p. -d dummy /dev/null +==18432== Parent PID: 18081 +==18432== +==18432== Invalid read of size 4 +==18432== at 0x130C08: env_err (gwion.c:110) +==18432== by 0x154181: gwi_union_end (import.c:601) +==18432== by 0x4848152: import (empty_union.c:15) +==18432== by 0x14AC28: type_engine_init (engine.c:107) +==18432== by 0x1308A5: gwion_engine (gwion.c:39) +==18432== by 0x1308A5: gwion_ini (gwion.c:78) +==18432== by 0x12F85D: main (main.c:23) +==18432== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==18432== +==18432== +==18432== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==18432== Access not within mapped region at address 0x28 +==18432== at 0x130C08: env_err (gwion.c:110) +==18432== by 0x154181: gwi_union_end (import.c:601) +==18432== by 0x4848152: import (empty_union.c:15) +==18432== by 0x14AC28: type_engine_init (engine.c:107) +==18432== by 0x1308A5: gwion_engine (gwion.c:39) +==18432== by 0x1308A5: gwion_ini (gwion.c:78) +==18432== by 0x12F85D: main (main.c:23) +==18432== If you believe this happened as a result of a stack +==18432== overflow in your program's main thread (unlikely but +==18432== possible), you can try to increase the size of the +==18432== main thread stack using the --main-stacksize= flag. +==18432== The main thread stack size used in this run was 8388608. +==18432== +==18432== HEAP SUMMARY: +==18432== in use at exit: 2,170,710 bytes in 374 blocks +==18432== total heap usage: 798 allocs, 424 frees, 2,264,835 bytes allocated +==18432== +==18432== LEAK SUMMARY: +==18432== definitely lost: 0 bytes in 0 blocks +==18432== indirectly lost: 0 bytes in 0 blocks +==18432== possibly lost: 0 bytes in 0 blocks +==18432== still reachable: 2,170,710 bytes in 374 blocks +==18432== suppressed: 0 bytes in 0 blocks +==18432== Rerun with --leak-check=full to see details of leaked memory +==18432== +==18432== For counts of detected and suppressed errors, rerun with: -v +==18432== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==18478== Memcheck, a memory error detector +==18478== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==18478== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==18478== Command: ./../../gwion -p. -d dummy /dev/null +==18478== Parent PID: 18081 +==18478== +==18478== Invalid read of size 4 +==18478== at 0x130C08: env_err (gwion.c:110) +==18478== by 0x152A2B: gwi_class_end (import.c:268) +==18478== by 0x4848133: import (end_class.c:15) +==18478== by 0x14AC28: type_engine_init (engine.c:107) +==18478== by 0x1308A5: gwion_engine (gwion.c:39) +==18478== by 0x1308A5: gwion_ini (gwion.c:78) +==18478== by 0x12F85D: main (main.c:23) +==18478== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==18478== +==18478== +==18478== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==18478== Access not within mapped region at address 0x28 +==18478== at 0x130C08: env_err (gwion.c:110) +==18478== by 0x152A2B: gwi_class_end (import.c:268) +==18478== by 0x4848133: import (end_class.c:15) +==18478== by 0x14AC28: type_engine_init (engine.c:107) +==18478== by 0x1308A5: gwion_engine (gwion.c:39) +==18478== by 0x1308A5: gwion_ini (gwion.c:78) +==18478== by 0x12F85D: main (main.c:23) +==18478== If you believe this happened as a result of a stack +==18478== overflow in your program's main thread (unlikely but +==18478== possible), you can try to increase the size of the +==18478== main thread stack using the --main-stacksize= flag. +==18478== The main thread stack size used in this run was 8388608. +==18478== +==18478== HEAP SUMMARY: +==18478== in use at exit: 2,170,704 bytes in 374 blocks +==18478== total heap usage: 798 allocs, 424 frees, 2,264,821 bytes allocated +==18478== +==18478== LEAK SUMMARY: +==18478== definitely lost: 0 bytes in 0 blocks +==18478== indirectly lost: 0 bytes in 0 blocks +==18478== possibly lost: 0 bytes in 0 blocks +==18478== still reachable: 2,170,704 bytes in 374 blocks +==18478== suppressed: 0 bytes in 0 blocks +==18478== Rerun with --leak-check=full to see details of leaked memory +==18478== +==18478== For counts of detected and suppressed errors, rerun with: -v +==18478== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==18796== Memcheck, a memory error detector +==18796== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==18796== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==18796== Command: ./../../gwion -p. -d dummy /dev/null +==18796== Parent PID: 18081 +==18796== +==18796== Invalid read of size 4 +==18796== at 0x130C08: env_err (gwion.c:110) +==18796== by 0x1513F5: path_valid (import.c:145) +==18796== by 0x151D54: str2list (import.c:167) +==18796== by 0x152E72: str2decl (import.c:366) +==18796== by 0x15329C: make_dll_arg_list (import.c:395) +==18796== by 0x1537D0: make_dll_as_fun (import.c:440) +==18796== by 0x15391F: gwi_func_end (import.c:449) +==18796== by 0x4848225: import (invalid_arg.c:21) +==18796== by 0x14AC28: type_engine_init (engine.c:107) +==18796== by 0x1308A5: gwion_engine (gwion.c:39) +==18796== by 0x1308A5: gwion_ini (gwion.c:78) +==18796== by 0x12F85D: main (main.c:23) +==18796== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==18796== +==18796== +==18796== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==18796== Access not within mapped region at address 0x28 +==18796== at 0x130C08: env_err (gwion.c:110) +==18796== by 0x1513F5: path_valid (import.c:145) +==18796== by 0x151D54: str2list (import.c:167) +==18796== by 0x152E72: str2decl (import.c:366) +==18796== by 0x15329C: make_dll_arg_list (import.c:395) +==18796== by 0x1537D0: make_dll_as_fun (import.c:440) +==18796== by 0x15391F: gwi_func_end (import.c:449) +==18796== by 0x4848225: import (invalid_arg.c:21) +==18796== by 0x14AC28: type_engine_init (engine.c:107) +==18796== by 0x1308A5: gwion_engine (gwion.c:39) +==18796== by 0x1308A5: gwion_ini (gwion.c:78) +==18796== by 0x12F85D: main (main.c:23) +==18796== If you believe this happened as a result of a stack +==18796== overflow in your program's main thread (unlikely but +==18796== possible), you can try to increase the size of the +==18796== main thread stack using the --main-stacksize= flag. +==18796== The main thread stack size used in this run was 8388608. +==18796== +==18796== HEAP SUMMARY: +==18796== in use at exit: 2,171,862 bytes in 384 blocks +==18796== total heap usage: 810 allocs, 426 frees, 2,266,051 bytes allocated +==18796== +==18796== LEAK SUMMARY: +==18796== definitely lost: 0 bytes in 0 blocks +==18796== indirectly lost: 0 bytes in 0 blocks +==18796== possibly lost: 0 bytes in 0 blocks +==18796== still reachable: 2,171,862 bytes in 384 blocks +==18796== suppressed: 0 bytes in 0 blocks +==18796== Rerun with --leak-check=full to see details of leaked memory +==18796== +==18796== For counts of detected and suppressed errors, rerun with: -v +==18796== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==18842== Memcheck, a memory error detector +==18842== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==18842== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==18842== Command: ./../../gwion -p. -d dummy /dev/null +==18842== Parent PID: 18081 +==18842== +==18842== Invalid read of size 4 +==18842== at 0x130C08: env_err (gwion.c:110) +==18842== by 0x153373: make_dll_arg_list (import.c:406) +==18842== by 0x1537D0: make_dll_as_fun (import.c:440) +==18842== by 0x15391F: gwi_func_end (import.c:449) +==18842== by 0x48482A6: import (invalid_array.c:24) +==18842== by 0x14AC28: type_engine_init (engine.c:107) +==18842== by 0x1308A5: gwion_engine (gwion.c:39) +==18842== by 0x1308A5: gwion_ini (gwion.c:78) +==18842== by 0x12F85D: main (main.c:23) +==18842== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==18842== +==18842== +==18842== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==18842== Access not within mapped region at address 0x28 +==18842== at 0x130C08: env_err (gwion.c:110) +==18842== by 0x153373: make_dll_arg_list (import.c:406) +==18842== by 0x1537D0: make_dll_as_fun (import.c:440) +==18842== by 0x15391F: gwi_func_end (import.c:449) +==18842== by 0x48482A6: import (invalid_array.c:24) +==18842== by 0x14AC28: type_engine_init (engine.c:107) +==18842== by 0x1308A5: gwion_engine (gwion.c:39) +==18842== by 0x1308A5: gwion_ini (gwion.c:78) +==18842== by 0x12F85D: main (main.c:23) +==18842== If you believe this happened as a result of a stack +==18842== overflow in your program's main thread (unlikely but +==18842== possible), you can try to increase the size of the +==18842== main thread stack using the --main-stacksize= flag. +==18842== The main thread stack size used in this run was 8388608. +==18842== +==18842== HEAP SUMMARY: +==18842== in use at exit: 2,173,020 bytes in 385 blocks +==18842== total heap usage: 812 allocs, 427 frees, 2,267,345 bytes allocated +==18842== +==18842== LEAK SUMMARY: +==18842== definitely lost: 0 bytes in 0 blocks +==18842== indirectly lost: 0 bytes in 0 blocks +==18842== possibly lost: 0 bytes in 0 blocks +==18842== still reachable: 2,173,020 bytes in 385 blocks +==18842== suppressed: 0 bytes in 0 blocks +==18842== Rerun with --leak-check=full to see details of leaked memory +==18842== +==18842== For counts of detected and suppressed errors, rerun with: -v +==18842== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==18888== Memcheck, a memory error detector +==18888== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==18888== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==18888== Command: ./../../gwion -p. -d dummy /dev/null +==18888== Parent PID: 18081 +==18888== +==18888== Invalid read of size 4 +==18888== at 0x130C08: env_err (gwion.c:110) +==18888== by 0x1513F5: path_valid (import.c:145) +==18888== by 0x151D54: str2list (import.c:167) +==18888== by 0x153613: import_td (import.c:418) +==18888== by 0x1537A4: make_dll_as_fun (import.c:436) +==18888== by 0x15391F: gwi_func_end (import.c:449) +==18888== by 0x48481EC: import (invalid_func.c:20) +==18888== by 0x14AC28: type_engine_init (engine.c:107) +==18888== by 0x1308A5: gwion_engine (gwion.c:39) +==18888== by 0x1308A5: gwion_ini (gwion.c:78) +==18888== by 0x12F85D: main (main.c:23) +==18888== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==18888== +==18888== +==18888== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==18888== Access not within mapped region at address 0x28 +==18888== at 0x130C08: env_err (gwion.c:110) +==18888== by 0x1513F5: path_valid (import.c:145) +==18888== by 0x151D54: str2list (import.c:167) +==18888== by 0x153613: import_td (import.c:418) +==18888== by 0x1537A4: make_dll_as_fun (import.c:436) +==18888== by 0x15391F: gwi_func_end (import.c:449) +==18888== by 0x48481EC: import (invalid_func.c:20) +==18888== by 0x14AC28: type_engine_init (engine.c:107) +==18888== by 0x1308A5: gwion_engine (gwion.c:39) +==18888== by 0x1308A5: gwion_ini (gwion.c:78) +==18888== by 0x12F85D: main (main.c:23) +==18888== If you believe this happened as a result of a stack +==18888== overflow in your program's main thread (unlikely but +==18888== possible), you can try to increase the size of the +==18888== main thread stack using the --main-stacksize= flag. +==18888== The main thread stack size used in this run was 8388608. +==18888== +==18888== HEAP SUMMARY: +==18888== in use at exit: 2,171,353 bytes in 383 blocks +==18888== total heap usage: 809 allocs, 426 frees, 2,265,546 bytes allocated +==18888== +==18888== LEAK SUMMARY: +==18888== definitely lost: 0 bytes in 0 blocks +==18888== indirectly lost: 0 bytes in 0 blocks +==18888== possibly lost: 0 bytes in 0 blocks +==18888== still reachable: 2,171,353 bytes in 383 blocks +==18888== suppressed: 0 bytes in 0 blocks +==18888== Rerun with --leak-check=full to see details of leaked memory +==18888== +==18888== For counts of detected and suppressed errors, rerun with: -v +==18888== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==18934== Memcheck, a memory error detector +==18934== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==18934== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==18934== Command: ./../../gwion -p. -d dummy /dev/null +==18934== Parent PID: 18081 +==18934== +==18934== Invalid read of size 4 +==18934== at 0x130C08: env_err (gwion.c:110) +==18934== by 0x15127B: path_valid (import.c:135) +==18934== by 0x151D54: str2list (import.c:167) +==18934== by 0x152ABC: gwi_item_ini (import.c:302) +==18934== by 0x48481B5: import (invalid_type1.c:18) +==18934== by 0x14AC28: type_engine_init (engine.c:107) +==18934== by 0x1308A5: gwion_engine (gwion.c:39) +==18934== by 0x1308A5: gwion_ini (gwion.c:78) +==18934== by 0x12F85D: main (main.c:23) +==18934== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==18934== +==18934== +==18934== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==18934== Access not within mapped region at address 0x28 +==18934== at 0x130C08: env_err (gwion.c:110) +==18934== by 0x15127B: path_valid (import.c:135) +==18934== by 0x151D54: str2list (import.c:167) +==18934== by 0x152ABC: gwi_item_ini (import.c:302) +==18934== by 0x48481B5: import (invalid_type1.c:18) +==18934== by 0x14AC28: type_engine_init (engine.c:107) +==18934== by 0x1308A5: gwion_engine (gwion.c:39) +==18934== by 0x1308A5: gwion_ini (gwion.c:78) +==18934== by 0x12F85D: main (main.c:23) +==18934== If you believe this happened as a result of a stack +==18934== overflow in your program's main thread (unlikely but +==18934== possible), you can try to increase the size of the +==18934== main thread stack using the --main-stacksize= flag. +==18934== The main thread stack size used in this run was 8388608. +==18934== +==18934== HEAP SUMMARY: +==18934== in use at exit: 2,171,356 bytes in 383 blocks +==18934== total heap usage: 809 allocs, 426 frees, 2,265,553 bytes allocated +==18934== +==18934== LEAK SUMMARY: +==18934== definitely lost: 0 bytes in 0 blocks +==18934== indirectly lost: 0 bytes in 0 blocks +==18934== possibly lost: 0 bytes in 0 blocks +==18934== still reachable: 2,171,356 bytes in 383 blocks +==18934== suppressed: 0 bytes in 0 blocks +==18934== Rerun with --leak-check=full to see details of leaked memory +==18934== +==18934== For counts of detected and suppressed errors, rerun with: -v +==18934== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==18982== Memcheck, a memory error detector +==18982== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==18982== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==18982== Command: ./../../gwion -p. -d dummy /dev/null +==18982== Parent PID: 18081 +==18982== +==18982== Invalid read of size 4 +==18982== at 0x130C08: env_err (gwion.c:110) +==18982== by 0x1513F5: path_valid (import.c:145) +==18982== by 0x151D54: str2list (import.c:167) +==18982== by 0x152ABC: gwi_item_ini (import.c:302) +==18982== by 0x48481B5: import (invalid_type2.c:18) +==18982== by 0x14AC28: type_engine_init (engine.c:107) +==18982== by 0x1308A5: gwion_engine (gwion.c:39) +==18982== by 0x1308A5: gwion_ini (gwion.c:78) +==18982== by 0x12F85D: main (main.c:23) +==18982== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==18982== +==18982== +==18982== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==18982== Access not within mapped region at address 0x28 +==18982== at 0x130C08: env_err (gwion.c:110) +==18982== by 0x1513F5: path_valid (import.c:145) +==18982== by 0x151D54: str2list (import.c:167) +==18982== by 0x152ABC: gwi_item_ini (import.c:302) +==18982== by 0x48481B5: import (invalid_type2.c:18) +==18982== by 0x14AC28: type_engine_init (engine.c:107) +==18982== by 0x1308A5: gwion_engine (gwion.c:39) +==18982== by 0x1308A5: gwion_ini (gwion.c:78) +==18982== by 0x12F85D: main (main.c:23) +==18982== If you believe this happened as a result of a stack +==18982== overflow in your program's main thread (unlikely but +==18982== possible), you can try to increase the size of the +==18982== main thread stack using the --main-stacksize= flag. +==18982== The main thread stack size used in this run was 8388608. +==18982== +==18982== HEAP SUMMARY: +==18982== in use at exit: 2,171,356 bytes in 383 blocks +==18982== total heap usage: 809 allocs, 426 frees, 2,265,553 bytes allocated +==18982== +==18982== LEAK SUMMARY: +==18982== definitely lost: 0 bytes in 0 blocks +==18982== indirectly lost: 0 bytes in 0 blocks +==18982== possibly lost: 0 bytes in 0 blocks +==18982== still reachable: 2,171,356 bytes in 383 blocks +==18982== suppressed: 0 bytes in 0 blocks +==18982== Rerun with --leak-check=full to see details of leaked memory +==18982== +==18982== For counts of detected and suppressed errors, rerun with: -v +==18982== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==19028== Memcheck, a memory error detector +==19028== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==19028== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==19028== Command: ./../../gwion -p. -d dummy /dev/null +==19028== Parent PID: 18081 +==19028== +==19028== Invalid read of size 4 +==19028== at 0x130C08: env_err (gwion.c:110) +==19028== by 0x1510E0: name_valid (import.c:116) +==19028== by 0x152365: gwi_add_type (import.c:195) +==19028== by 0x15242B: gwi_class_ini (import.c:229) +==19028== by 0x484818F: import (invalid_type3.c:18) +==19028== by 0x14AC28: type_engine_init (engine.c:107) +==19028== by 0x1308A5: gwion_engine (gwion.c:39) +==19028== by 0x1308A5: gwion_ini (gwion.c:78) +==19028== by 0x12F85D: main (main.c:23) +==19028== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==19028== +==19028== +==19028== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==19028== Access not within mapped region at address 0x28 +==19028== at 0x130C08: env_err (gwion.c:110) +==19028== by 0x1510E0: name_valid (import.c:116) +==19028== by 0x152365: gwi_add_type (import.c:195) +==19028== by 0x15242B: gwi_class_ini (import.c:229) +==19028== by 0x484818F: import (invalid_type3.c:18) +==19028== by 0x14AC28: type_engine_init (engine.c:107) +==19028== by 0x1308A5: gwion_engine (gwion.c:39) +==19028== by 0x1308A5: gwion_ini (gwion.c:78) +==19028== by 0x12F85D: main (main.c:23) +==19028== If you believe this happened as a result of a stack +==19028== overflow in your program's main thread (unlikely but +==19028== possible), you can try to increase the size of the +==19028== main thread stack using the --main-stacksize= flag. +==19028== The main thread stack size used in this run was 8388608. +==19028== +==19028== HEAP SUMMARY: +==19028== in use at exit: 2,170,716 bytes in 374 blocks +==19028== total heap usage: 798 allocs, 424 frees, 2,264,849 bytes allocated +==19028== +==19028== LEAK SUMMARY: +==19028== definitely lost: 0 bytes in 0 blocks +==19028== indirectly lost: 0 bytes in 0 blocks +==19028== possibly lost: 0 bytes in 0 blocks +==19028== still reachable: 2,170,716 bytes in 374 blocks +==19028== suppressed: 0 bytes in 0 blocks +==19028== Rerun with --leak-check=full to see details of leaked memory +==19028== +==19028== For counts of detected and suppressed errors, rerun with: -v +==19028== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==19209== Memcheck, a memory error detector +==19209== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==19209== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==19209== Command: ./../../gwion -p. -d dummy /dev/null +==19209== Parent PID: 18081 +==19209== +==19209== Invalid read of size 4 +==19209== at 0x130C08: env_err (gwion.c:110) +==19209== by 0x1530F4: make_dll_arg_list (import.c:398) +==19209== by 0x1537D0: make_dll_as_fun (import.c:440) +==19209== by 0x15391F: gwi_func_end (import.c:449) +==19209== by 0x4848225: import (template_arg.c:21) +==19209== by 0x14AC28: type_engine_init (engine.c:107) +==19209== by 0x1308A5: gwion_engine (gwion.c:39) +==19209== by 0x1308A5: gwion_ini (gwion.c:78) +==19209== by 0x12F85D: main (main.c:23) +==19209== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==19209== +==19209== +==19209== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==19209== Access not within mapped region at address 0x28 +==19209== at 0x130C08: env_err (gwion.c:110) +==19209== by 0x1530F4: make_dll_arg_list (import.c:398) +==19209== by 0x1537D0: make_dll_as_fun (import.c:440) +==19209== by 0x15391F: gwi_func_end (import.c:449) +==19209== by 0x4848225: import (template_arg.c:21) +==19209== by 0x14AC28: type_engine_init (engine.c:107) +==19209== by 0x1308A5: gwion_engine (gwion.c:39) +==19209== by 0x1308A5: gwion_ini (gwion.c:78) +==19209== by 0x12F85D: main (main.c:23) +==19209== If you believe this happened as a result of a stack +==19209== overflow in your program's main thread (unlikely but +==19209== possible), you can try to increase the size of the +==19209== main thread stack using the --main-stacksize= flag. +==19209== The main thread stack size used in this run was 8388608. +==19209== +==19209== HEAP SUMMARY: +==19209== in use at exit: 2,177,657 bytes in 395 blocks +==19209== total heap usage: 829 allocs, 434 frees, 2,272,394 bytes allocated +==19209== +==19209== LEAK SUMMARY: +==19209== definitely lost: 0 bytes in 0 blocks +==19209== indirectly lost: 0 bytes in 0 blocks +==19209== possibly lost: 0 bytes in 0 blocks +==19209== still reachable: 2,177,657 bytes in 395 blocks +==19209== suppressed: 0 bytes in 0 blocks +==19209== Rerun with --leak-check=full to see details of leaked memory +==19209== +==19209== For counts of detected and suppressed errors, rerun with: -v +==19209== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==5710== Memcheck, a memory error detector +==5710== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==5710== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==5710== Command: ./../../gwion -p. -d dummy /dev/null +==5710== Parent PID: 5684 +==5710== +==5710== +==5710== HEAP SUMMARY: +==5710== in use at exit: 928 bytes in 10 blocks +==5710== total heap usage: 997 allocs, 987 frees, 7,604,988 bytes allocated +==5710== +==5710== LEAK SUMMARY: +==5710== definitely lost: 928 bytes in 10 blocks +==5710== indirectly lost: 0 bytes in 0 blocks +==5710== possibly lost: 0 bytes in 0 blocks +==5710== still reachable: 0 bytes in 0 blocks +==5710== suppressed: 0 bytes in 0 blocks +==5710== Rerun with --leak-check=full to see details of leaked memory +==5710== +==5710== For counts of detected and suppressed errors, rerun with: -v +==5710== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0) +/dev/null ==5809== Memcheck, a memory error detector +==5809== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==5809== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==5809== Command: ./../../gwion -p. -d dummy /dev/null +==5809== Parent PID: 5684 +==5809== +==5809== Invalid read of size 4 +==5809== at 0x130C08: env_err (gwion.c:110) +==5809== by 0x1524AC: gwi_class_ini (import.c:220) +==5809== by 0x48481A0: import (begin_class.c:18) +==5809== by 0x14AC28: type_engine_init (engine.c:107) +==5809== by 0x1308A5: gwion_engine (gwion.c:39) +==5809== by 0x1308A5: gwion_ini (gwion.c:78) +==5809== by 0x12F85D: main (main.c:23) +==5809== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==5809== +==5809== +==5809== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==5809== Access not within mapped region at address 0x28 +==5809== at 0x130C08: env_err (gwion.c:110) +==5809== by 0x1524AC: gwi_class_ini (import.c:220) +==5809== by 0x48481A0: import (begin_class.c:18) +==5809== by 0x14AC28: type_engine_init (engine.c:107) +==5809== by 0x1308A5: gwion_engine (gwion.c:39) +==5809== by 0x1308A5: gwion_ini (gwion.c:78) +==5809== by 0x12F85D: main (main.c:23) +==5809== If you believe this happened as a result of a stack +==5809== overflow in your program's main thread (unlikely but +==5809== possible), you can try to increase the size of the +==5809== main thread stack using the --main-stacksize= flag. +==5809== The main thread stack size used in this run was 8388608. +==5809== +==5809== HEAP SUMMARY: +==5809== in use at exit: 2,171,350 bytes in 383 blocks +==5809== total heap usage: 809 allocs, 426 frees, 2,265,539 bytes allocated +==5809== +==5809== LEAK SUMMARY: +==5809== definitely lost: 0 bytes in 0 blocks +==5809== indirectly lost: 0 bytes in 0 blocks +==5809== possibly lost: 0 bytes in 0 blocks +==5809== still reachable: 2,171,350 bytes in 383 blocks +==5809== suppressed: 0 bytes in 0 blocks +==5809== Rerun with --leak-check=full to see details of leaked memory +==5809== +==5809== For counts of detected and suppressed errors, rerun with: -v +==5809== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==6040== Memcheck, a memory error detector +==6040== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==6040== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==6040== Command: ./../../gwion -p. -d dummy /dev/null +==6040== Parent PID: 5684 +==6040== +==6040== Invalid read of size 4 +==6040== at 0x130C08: env_err (gwion.c:110) +==6040== by 0x154181: gwi_union_end (import.c:601) +==6040== by 0x4848152: import (empty_union.c:15) +==6040== by 0x14AC28: type_engine_init (engine.c:107) +==6040== by 0x1308A5: gwion_engine (gwion.c:39) +==6040== by 0x1308A5: gwion_ini (gwion.c:78) +==6040== by 0x12F85D: main (main.c:23) +==6040== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==6040== +==6040== +==6040== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==6040== Access not within mapped region at address 0x28 +==6040== at 0x130C08: env_err (gwion.c:110) +==6040== by 0x154181: gwi_union_end (import.c:601) +==6040== by 0x4848152: import (empty_union.c:15) +==6040== by 0x14AC28: type_engine_init (engine.c:107) +==6040== by 0x1308A5: gwion_engine (gwion.c:39) +==6040== by 0x1308A5: gwion_ini (gwion.c:78) +==6040== by 0x12F85D: main (main.c:23) +==6040== If you believe this happened as a result of a stack +==6040== overflow in your program's main thread (unlikely but +==6040== possible), you can try to increase the size of the +==6040== main thread stack using the --main-stacksize= flag. +==6040== The main thread stack size used in this run was 8388608. +==6040== +==6040== HEAP SUMMARY: +==6040== in use at exit: 2,170,710 bytes in 374 blocks +==6040== total heap usage: 798 allocs, 424 frees, 2,264,835 bytes allocated +==6040== +==6040== LEAK SUMMARY: +==6040== definitely lost: 0 bytes in 0 blocks +==6040== indirectly lost: 0 bytes in 0 blocks +==6040== possibly lost: 0 bytes in 0 blocks +==6040== still reachable: 2,170,710 bytes in 374 blocks +==6040== suppressed: 0 bytes in 0 blocks +==6040== Rerun with --leak-check=full to see details of leaked memory +==6040== +==6040== For counts of detected and suppressed errors, rerun with: -v +==6040== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==6087== Memcheck, a memory error detector +==6087== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==6087== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==6087== Command: ./../../gwion -p. -d dummy /dev/null +==6087== Parent PID: 5684 +==6087== +==6087== Invalid read of size 4 +==6087== at 0x130C08: env_err (gwion.c:110) +==6087== by 0x152A2B: gwi_class_end (import.c:268) +==6087== by 0x4848133: import (end_class.c:15) +==6087== by 0x14AC28: type_engine_init (engine.c:107) +==6087== by 0x1308A5: gwion_engine (gwion.c:39) +==6087== by 0x1308A5: gwion_ini (gwion.c:78) +==6087== by 0x12F85D: main (main.c:23) +==6087== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==6087== +==6087== +==6087== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==6087== Access not within mapped region at address 0x28 +==6087== at 0x130C08: env_err (gwion.c:110) +==6087== by 0x152A2B: gwi_class_end (import.c:268) +==6087== by 0x4848133: import (end_class.c:15) +==6087== by 0x14AC28: type_engine_init (engine.c:107) +==6087== by 0x1308A5: gwion_engine (gwion.c:39) +==6087== by 0x1308A5: gwion_ini (gwion.c:78) +==6087== by 0x12F85D: main (main.c:23) +==6087== If you believe this happened as a result of a stack +==6087== overflow in your program's main thread (unlikely but +==6087== possible), you can try to increase the size of the +==6087== main thread stack using the --main-stacksize= flag. +==6087== The main thread stack size used in this run was 8388608. +==6087== +==6087== HEAP SUMMARY: +==6087== in use at exit: 2,170,704 bytes in 374 blocks +==6087== total heap usage: 798 allocs, 424 frees, 2,264,821 bytes allocated +==6087== +==6087== LEAK SUMMARY: +==6087== definitely lost: 0 bytes in 0 blocks +==6087== indirectly lost: 0 bytes in 0 blocks +==6087== possibly lost: 0 bytes in 0 blocks +==6087== still reachable: 2,170,704 bytes in 374 blocks +==6087== suppressed: 0 bytes in 0 blocks +==6087== Rerun with --leak-check=full to see details of leaked memory +==6087== +==6087== For counts of detected and suppressed errors, rerun with: -v +==6087== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==6406== Memcheck, a memory error detector +==6406== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==6406== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==6406== Command: ./../../gwion -p. -d dummy /dev/null +==6406== Parent PID: 5684 +==6406== +==6406== Invalid read of size 4 +==6406== at 0x130C08: env_err (gwion.c:110) +==6406== by 0x1513F5: path_valid (import.c:145) +==6406== by 0x151D54: str2list (import.c:167) +==6406== by 0x152E72: str2decl (import.c:366) +==6406== by 0x15329C: make_dll_arg_list (import.c:395) +==6406== by 0x1537D0: make_dll_as_fun (import.c:440) +==6406== by 0x15391F: gwi_func_end (import.c:449) +==6406== by 0x4848225: import (invalid_arg.c:21) +==6406== by 0x14AC28: type_engine_init (engine.c:107) +==6406== by 0x1308A5: gwion_engine (gwion.c:39) +==6406== by 0x1308A5: gwion_ini (gwion.c:78) +==6406== by 0x12F85D: main (main.c:23) +==6406== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==6406== +==6406== +==6406== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==6406== Access not within mapped region at address 0x28 +==6406== at 0x130C08: env_err (gwion.c:110) +==6406== by 0x1513F5: path_valid (import.c:145) +==6406== by 0x151D54: str2list (import.c:167) +==6406== by 0x152E72: str2decl (import.c:366) +==6406== by 0x15329C: make_dll_arg_list (import.c:395) +==6406== by 0x1537D0: make_dll_as_fun (import.c:440) +==6406== by 0x15391F: gwi_func_end (import.c:449) +==6406== by 0x4848225: import (invalid_arg.c:21) +==6406== by 0x14AC28: type_engine_init (engine.c:107) +==6406== by 0x1308A5: gwion_engine (gwion.c:39) +==6406== by 0x1308A5: gwion_ini (gwion.c:78) +==6406== by 0x12F85D: main (main.c:23) +==6406== If you believe this happened as a result of a stack +==6406== overflow in your program's main thread (unlikely but +==6406== possible), you can try to increase the size of the +==6406== main thread stack using the --main-stacksize= flag. +==6406== The main thread stack size used in this run was 8388608. +==6406== +==6406== HEAP SUMMARY: +==6406== in use at exit: 2,171,862 bytes in 384 blocks +==6406== total heap usage: 810 allocs, 426 frees, 2,266,051 bytes allocated +==6406== +==6406== LEAK SUMMARY: +==6406== definitely lost: 0 bytes in 0 blocks +==6406== indirectly lost: 0 bytes in 0 blocks +==6406== possibly lost: 0 bytes in 0 blocks +==6406== still reachable: 2,171,862 bytes in 384 blocks +==6406== suppressed: 0 bytes in 0 blocks +==6406== Rerun with --leak-check=full to see details of leaked memory +==6406== +==6406== For counts of detected and suppressed errors, rerun with: -v +==6406== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==6452== Memcheck, a memory error detector +==6452== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==6452== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==6452== Command: ./../../gwion -p. -d dummy /dev/null +==6452== Parent PID: 5684 +==6452== +==6452== Invalid read of size 4 +==6452== at 0x130C08: env_err (gwion.c:110) +==6452== by 0x153373: make_dll_arg_list (import.c:406) +==6452== by 0x1537D0: make_dll_as_fun (import.c:440) +==6452== by 0x15391F: gwi_func_end (import.c:449) +==6452== by 0x48482A6: import (invalid_array.c:24) +==6452== by 0x14AC28: type_engine_init (engine.c:107) +==6452== by 0x1308A5: gwion_engine (gwion.c:39) +==6452== by 0x1308A5: gwion_ini (gwion.c:78) +==6452== by 0x12F85D: main (main.c:23) +==6452== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==6452== +==6452== +==6452== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==6452== Access not within mapped region at address 0x28 +==6452== at 0x130C08: env_err (gwion.c:110) +==6452== by 0x153373: make_dll_arg_list (import.c:406) +==6452== by 0x1537D0: make_dll_as_fun (import.c:440) +==6452== by 0x15391F: gwi_func_end (import.c:449) +==6452== by 0x48482A6: import (invalid_array.c:24) +==6452== by 0x14AC28: type_engine_init (engine.c:107) +==6452== by 0x1308A5: gwion_engine (gwion.c:39) +==6452== by 0x1308A5: gwion_ini (gwion.c:78) +==6452== by 0x12F85D: main (main.c:23) +==6452== If you believe this happened as a result of a stack +==6452== overflow in your program's main thread (unlikely but +==6452== possible), you can try to increase the size of the +==6452== main thread stack using the --main-stacksize= flag. +==6452== The main thread stack size used in this run was 8388608. +==6452== +==6452== HEAP SUMMARY: +==6452== in use at exit: 2,173,020 bytes in 385 blocks +==6452== total heap usage: 812 allocs, 427 frees, 2,267,345 bytes allocated +==6452== +==6452== LEAK SUMMARY: +==6452== definitely lost: 0 bytes in 0 blocks +==6452== indirectly lost: 0 bytes in 0 blocks +==6452== possibly lost: 0 bytes in 0 blocks +==6452== still reachable: 2,173,020 bytes in 385 blocks +==6452== suppressed: 0 bytes in 0 blocks +==6452== Rerun with --leak-check=full to see details of leaked memory +==6452== +==6452== For counts of detected and suppressed errors, rerun with: -v +==6452== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==6499== Memcheck, a memory error detector +==6499== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==6499== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==6499== Command: ./../../gwion -p. -d dummy /dev/null +==6499== Parent PID: 5684 +==6499== +==6499== Invalid read of size 4 +==6499== at 0x130C08: env_err (gwion.c:110) +==6499== by 0x1513F5: path_valid (import.c:145) +==6499== by 0x151D54: str2list (import.c:167) +==6499== by 0x153613: import_td (import.c:418) +==6499== by 0x1537A4: make_dll_as_fun (import.c:436) +==6499== by 0x15391F: gwi_func_end (import.c:449) +==6499== by 0x48481EC: import (invalid_func.c:20) +==6499== by 0x14AC28: type_engine_init (engine.c:107) +==6499== by 0x1308A5: gwion_engine (gwion.c:39) +==6499== by 0x1308A5: gwion_ini (gwion.c:78) +==6499== by 0x12F85D: main (main.c:23) +==6499== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==6499== +==6499== +==6499== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==6499== Access not within mapped region at address 0x28 +==6499== at 0x130C08: env_err (gwion.c:110) +==6499== by 0x1513F5: path_valid (import.c:145) +==6499== by 0x151D54: str2list (import.c:167) +==6499== by 0x153613: import_td (import.c:418) +==6499== by 0x1537A4: make_dll_as_fun (import.c:436) +==6499== by 0x15391F: gwi_func_end (import.c:449) +==6499== by 0x48481EC: import (invalid_func.c:20) +==6499== by 0x14AC28: type_engine_init (engine.c:107) +==6499== by 0x1308A5: gwion_engine (gwion.c:39) +==6499== by 0x1308A5: gwion_ini (gwion.c:78) +==6499== by 0x12F85D: main (main.c:23) +==6499== If you believe this happened as a result of a stack +==6499== overflow in your program's main thread (unlikely but +==6499== possible), you can try to increase the size of the +==6499== main thread stack using the --main-stacksize= flag. +==6499== The main thread stack size used in this run was 8388608. +==6499== +==6499== HEAP SUMMARY: +==6499== in use at exit: 2,171,353 bytes in 383 blocks +==6499== total heap usage: 809 allocs, 426 frees, 2,265,546 bytes allocated +==6499== +==6499== LEAK SUMMARY: +==6499== definitely lost: 0 bytes in 0 blocks +==6499== indirectly lost: 0 bytes in 0 blocks +==6499== possibly lost: 0 bytes in 0 blocks +==6499== still reachable: 2,171,353 bytes in 383 blocks +==6499== suppressed: 0 bytes in 0 blocks +==6499== Rerun with --leak-check=full to see details of leaked memory +==6499== +==6499== For counts of detected and suppressed errors, rerun with: -v +==6499== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==6545== Memcheck, a memory error detector +==6545== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==6545== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==6545== Command: ./../../gwion -p. -d dummy /dev/null +==6545== Parent PID: 5684 +==6545== +==6545== Invalid read of size 4 +==6545== at 0x130C08: env_err (gwion.c:110) +==6545== by 0x15127B: path_valid (import.c:135) +==6545== by 0x151D54: str2list (import.c:167) +==6545== by 0x152ABC: gwi_item_ini (import.c:302) +==6545== by 0x48481B5: import (invalid_type1.c:18) +==6545== by 0x14AC28: type_engine_init (engine.c:107) +==6545== by 0x1308A5: gwion_engine (gwion.c:39) +==6545== by 0x1308A5: gwion_ini (gwion.c:78) +==6545== by 0x12F85D: main (main.c:23) +==6545== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==6545== +==6545== +==6545== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==6545== Access not within mapped region at address 0x28 +==6545== at 0x130C08: env_err (gwion.c:110) +==6545== by 0x15127B: path_valid (import.c:135) +==6545== by 0x151D54: str2list (import.c:167) +==6545== by 0x152ABC: gwi_item_ini (import.c:302) +==6545== by 0x48481B5: import (invalid_type1.c:18) +==6545== by 0x14AC28: type_engine_init (engine.c:107) +==6545== by 0x1308A5: gwion_engine (gwion.c:39) +==6545== by 0x1308A5: gwion_ini (gwion.c:78) +==6545== by 0x12F85D: main (main.c:23) +==6545== If you believe this happened as a result of a stack +==6545== overflow in your program's main thread (unlikely but +==6545== possible), you can try to increase the size of the +==6545== main thread stack using the --main-stacksize= flag. +==6545== The main thread stack size used in this run was 8388608. +==6545== +==6545== HEAP SUMMARY: +==6545== in use at exit: 2,171,356 bytes in 383 blocks +==6545== total heap usage: 809 allocs, 426 frees, 2,265,553 bytes allocated +==6545== +==6545== LEAK SUMMARY: +==6545== definitely lost: 0 bytes in 0 blocks +==6545== indirectly lost: 0 bytes in 0 blocks +==6545== possibly lost: 0 bytes in 0 blocks +==6545== still reachable: 2,171,356 bytes in 383 blocks +==6545== suppressed: 0 bytes in 0 blocks +==6545== Rerun with --leak-check=full to see details of leaked memory +==6545== +==6545== For counts of detected and suppressed errors, rerun with: -v +==6545== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==6591== Memcheck, a memory error detector +==6591== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==6591== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==6591== Command: ./../../gwion -p. -d dummy /dev/null +==6591== Parent PID: 5684 +==6591== +==6591== Invalid read of size 4 +==6591== at 0x130C08: env_err (gwion.c:110) +==6591== by 0x1513F5: path_valid (import.c:145) +==6591== by 0x151D54: str2list (import.c:167) +==6591== by 0x152ABC: gwi_item_ini (import.c:302) +==6591== by 0x48481B5: import (invalid_type2.c:18) +==6591== by 0x14AC28: type_engine_init (engine.c:107) +==6591== by 0x1308A5: gwion_engine (gwion.c:39) +==6591== by 0x1308A5: gwion_ini (gwion.c:78) +==6591== by 0x12F85D: main (main.c:23) +==6591== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==6591== +==6591== +==6591== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==6591== Access not within mapped region at address 0x28 +==6591== at 0x130C08: env_err (gwion.c:110) +==6591== by 0x1513F5: path_valid (import.c:145) +==6591== by 0x151D54: str2list (import.c:167) +==6591== by 0x152ABC: gwi_item_ini (import.c:302) +==6591== by 0x48481B5: import (invalid_type2.c:18) +==6591== by 0x14AC28: type_engine_init (engine.c:107) +==6591== by 0x1308A5: gwion_engine (gwion.c:39) +==6591== by 0x1308A5: gwion_ini (gwion.c:78) +==6591== by 0x12F85D: main (main.c:23) +==6591== If you believe this happened as a result of a stack +==6591== overflow in your program's main thread (unlikely but +==6591== possible), you can try to increase the size of the +==6591== main thread stack using the --main-stacksize= flag. +==6591== The main thread stack size used in this run was 8388608. +==6591== +==6591== HEAP SUMMARY: +==6591== in use at exit: 2,171,356 bytes in 383 blocks +==6591== total heap usage: 809 allocs, 426 frees, 2,265,553 bytes allocated +==6591== +==6591== LEAK SUMMARY: +==6591== definitely lost: 0 bytes in 0 blocks +==6591== indirectly lost: 0 bytes in 0 blocks +==6591== possibly lost: 0 bytes in 0 blocks +==6591== still reachable: 2,171,356 bytes in 383 blocks +==6591== suppressed: 0 bytes in 0 blocks +==6591== Rerun with --leak-check=full to see details of leaked memory +==6591== +==6591== For counts of detected and suppressed errors, rerun with: -v +==6591== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==6637== Memcheck, a memory error detector +==6637== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==6637== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==6637== Command: ./../../gwion -p. -d dummy /dev/null +==6637== Parent PID: 5684 +==6637== +==6637== Invalid read of size 4 +==6637== at 0x130C08: env_err (gwion.c:110) +==6637== by 0x1510E0: name_valid (import.c:116) +==6637== by 0x152365: gwi_add_type (import.c:195) +==6637== by 0x15242B: gwi_class_ini (import.c:229) +==6637== by 0x484818F: import (invalid_type3.c:18) +==6637== by 0x14AC28: type_engine_init (engine.c:107) +==6637== by 0x1308A5: gwion_engine (gwion.c:39) +==6637== by 0x1308A5: gwion_ini (gwion.c:78) +==6637== by 0x12F85D: main (main.c:23) +==6637== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==6637== +==6637== +==6637== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==6637== Access not within mapped region at address 0x28 +==6637== at 0x130C08: env_err (gwion.c:110) +==6637== by 0x1510E0: name_valid (import.c:116) +==6637== by 0x152365: gwi_add_type (import.c:195) +==6637== by 0x15242B: gwi_class_ini (import.c:229) +==6637== by 0x484818F: import (invalid_type3.c:18) +==6637== by 0x14AC28: type_engine_init (engine.c:107) +==6637== by 0x1308A5: gwion_engine (gwion.c:39) +==6637== by 0x1308A5: gwion_ini (gwion.c:78) +==6637== by 0x12F85D: main (main.c:23) +==6637== If you believe this happened as a result of a stack +==6637== overflow in your program's main thread (unlikely but +==6637== possible), you can try to increase the size of the +==6637== main thread stack using the --main-stacksize= flag. +==6637== The main thread stack size used in this run was 8388608. +==6637== +==6637== HEAP SUMMARY: +==6637== in use at exit: 2,170,716 bytes in 374 blocks +==6637== total heap usage: 798 allocs, 424 frees, 2,264,849 bytes allocated +==6637== +==6637== LEAK SUMMARY: +==6637== definitely lost: 0 bytes in 0 blocks +==6637== indirectly lost: 0 bytes in 0 blocks +==6637== possibly lost: 0 bytes in 0 blocks +==6637== still reachable: 2,170,716 bytes in 374 blocks +==6637== suppressed: 0 bytes in 0 blocks +==6637== Rerun with --leak-check=full to see details of leaked memory +==6637== +==6637== For counts of detected and suppressed errors, rerun with: -v +==6637== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==6819== Memcheck, a memory error detector +==6819== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==6819== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==6819== Command: ./../../gwion -p. -d dummy /dev/null +==6819== Parent PID: 5684 +==6819== +==6819== Invalid read of size 4 +==6819== at 0x130C08: env_err (gwion.c:110) +==6819== by 0x1530F4: make_dll_arg_list (import.c:398) +==6819== by 0x1537D0: make_dll_as_fun (import.c:440) +==6819== by 0x15391F: gwi_func_end (import.c:449) +==6819== by 0x4848225: import (template_arg.c:21) +==6819== by 0x14AC28: type_engine_init (engine.c:107) +==6819== by 0x1308A5: gwion_engine (gwion.c:39) +==6819== by 0x1308A5: gwion_ini (gwion.c:78) +==6819== by 0x12F85D: main (main.c:23) +==6819== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==6819== +==6819== +==6819== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==6819== Access not within mapped region at address 0x28 +==6819== at 0x130C08: env_err (gwion.c:110) +==6819== by 0x1530F4: make_dll_arg_list (import.c:398) +==6819== by 0x1537D0: make_dll_as_fun (import.c:440) +==6819== by 0x15391F: gwi_func_end (import.c:449) +==6819== by 0x4848225: import (template_arg.c:21) +==6819== by 0x14AC28: type_engine_init (engine.c:107) +==6819== by 0x1308A5: gwion_engine (gwion.c:39) +==6819== by 0x1308A5: gwion_ini (gwion.c:78) +==6819== by 0x12F85D: main (main.c:23) +==6819== If you believe this happened as a result of a stack +==6819== overflow in your program's main thread (unlikely but +==6819== possible), you can try to increase the size of the +==6819== main thread stack using the --main-stacksize= flag. +==6819== The main thread stack size used in this run was 8388608. +==6819== +==6819== HEAP SUMMARY: +==6819== in use at exit: 2,177,657 bytes in 395 blocks +==6819== total heap usage: 829 allocs, 434 frees, 2,272,394 bytes allocated +==6819== +==6819== LEAK SUMMARY: +==6819== definitely lost: 0 bytes in 0 blocks +==6819== indirectly lost: 0 bytes in 0 blocks +==6819== possibly lost: 0 bytes in 0 blocks +==6819== still reachable: 2,177,657 bytes in 395 blocks +==6819== suppressed: 0 bytes in 0 blocks +==6819== Rerun with --leak-check=full to see details of leaked memory +==6819== +==6819== For counts of detected and suppressed errors, rerun with: -v +==6819== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==25955== Memcheck, a memory error detector +==25955== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==25955== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==25955== Command: ./../../gwion -p. -d dummy /dev/null +==25955== Parent PID: 25929 +==25955== +==25955== +==25955== HEAP SUMMARY: +==25955== in use at exit: 928 bytes in 10 blocks +==25955== total heap usage: 997 allocs, 987 frees, 7,604,988 bytes allocated +==25955== +==25955== LEAK SUMMARY: +==25955== definitely lost: 928 bytes in 10 blocks +==25955== indirectly lost: 0 bytes in 0 blocks +==25955== possibly lost: 0 bytes in 0 blocks +==25955== still reachable: 0 bytes in 0 blocks +==25955== suppressed: 0 bytes in 0 blocks +==25955== Rerun with --leak-check=full to see details of leaked memory +==25955== +==25955== For counts of detected and suppressed errors, rerun with: -v +==25955== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0) +/dev/null ==26053== Memcheck, a memory error detector +==26053== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==26053== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==26053== Command: ./../../gwion -p. -d dummy /dev/null +==26053== Parent PID: 25929 +==26053== +==26053== Invalid read of size 4 +==26053== at 0x130C08: env_err (gwion.c:110) +==26053== by 0x1524AC: gwi_class_ini (import.c:220) +==26053== by 0x48481A0: import (begin_class.c:18) +==26053== by 0x14AC28: type_engine_init (engine.c:107) +==26053== by 0x1308A5: gwion_engine (gwion.c:39) +==26053== by 0x1308A5: gwion_ini (gwion.c:78) +==26053== by 0x12F85D: main (main.c:23) +==26053== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==26053== +==26053== +==26053== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==26053== Access not within mapped region at address 0x28 +==26053== at 0x130C08: env_err (gwion.c:110) +==26053== by 0x1524AC: gwi_class_ini (import.c:220) +==26053== by 0x48481A0: import (begin_class.c:18) +==26053== by 0x14AC28: type_engine_init (engine.c:107) +==26053== by 0x1308A5: gwion_engine (gwion.c:39) +==26053== by 0x1308A5: gwion_ini (gwion.c:78) +==26053== by 0x12F85D: main (main.c:23) +==26053== If you believe this happened as a result of a stack +==26053== overflow in your program's main thread (unlikely but +==26053== possible), you can try to increase the size of the +==26053== main thread stack using the --main-stacksize= flag. +==26053== The main thread stack size used in this run was 8388608. +==26053== +==26053== HEAP SUMMARY: +==26053== in use at exit: 2,171,350 bytes in 383 blocks +==26053== total heap usage: 809 allocs, 426 frees, 2,265,539 bytes allocated +==26053== +==26053== LEAK SUMMARY: +==26053== definitely lost: 0 bytes in 0 blocks +==26053== indirectly lost: 0 bytes in 0 blocks +==26053== possibly lost: 0 bytes in 0 blocks +==26053== still reachable: 2,171,350 bytes in 383 blocks +==26053== suppressed: 0 bytes in 0 blocks +==26053== Rerun with --leak-check=full to see details of leaked memory +==26053== +==26053== For counts of detected and suppressed errors, rerun with: -v +==26053== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==26283== Memcheck, a memory error detector +==26283== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==26283== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==26283== Command: ./../../gwion -p. -d dummy /dev/null +==26283== Parent PID: 25929 +==26283== +==26283== Invalid read of size 4 +==26283== at 0x130C08: env_err (gwion.c:110) +==26283== by 0x154181: gwi_union_end (import.c:601) +==26283== by 0x4848152: import (empty_union.c:15) +==26283== by 0x14AC28: type_engine_init (engine.c:107) +==26283== by 0x1308A5: gwion_engine (gwion.c:39) +==26283== by 0x1308A5: gwion_ini (gwion.c:78) +==26283== by 0x12F85D: main (main.c:23) +==26283== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==26283== +==26283== +==26283== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==26283== Access not within mapped region at address 0x28 +==26283== at 0x130C08: env_err (gwion.c:110) +==26283== by 0x154181: gwi_union_end (import.c:601) +==26283== by 0x4848152: import (empty_union.c:15) +==26283== by 0x14AC28: type_engine_init (engine.c:107) +==26283== by 0x1308A5: gwion_engine (gwion.c:39) +==26283== by 0x1308A5: gwion_ini (gwion.c:78) +==26283== by 0x12F85D: main (main.c:23) +==26283== If you believe this happened as a result of a stack +==26283== overflow in your program's main thread (unlikely but +==26283== possible), you can try to increase the size of the +==26283== main thread stack using the --main-stacksize= flag. +==26283== The main thread stack size used in this run was 8388608. +==26283== +==26283== HEAP SUMMARY: +==26283== in use at exit: 2,170,710 bytes in 374 blocks +==26283== total heap usage: 798 allocs, 424 frees, 2,264,835 bytes allocated +==26283== +==26283== LEAK SUMMARY: +==26283== definitely lost: 0 bytes in 0 blocks +==26283== indirectly lost: 0 bytes in 0 blocks +==26283== possibly lost: 0 bytes in 0 blocks +==26283== still reachable: 2,170,710 bytes in 374 blocks +==26283== suppressed: 0 bytes in 0 blocks +==26283== Rerun with --leak-check=full to see details of leaked memory +==26283== +==26283== For counts of detected and suppressed errors, rerun with: -v +==26283== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==26330== Memcheck, a memory error detector +==26330== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==26330== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==26330== Command: ./../../gwion -p. -d dummy /dev/null +==26330== Parent PID: 25929 +==26330== +==26330== Invalid read of size 4 +==26330== at 0x130C08: env_err (gwion.c:110) +==26330== by 0x152A2B: gwi_class_end (import.c:268) +==26330== by 0x4848133: import (end_class.c:15) +==26330== by 0x14AC28: type_engine_init (engine.c:107) +==26330== by 0x1308A5: gwion_engine (gwion.c:39) +==26330== by 0x1308A5: gwion_ini (gwion.c:78) +==26330== by 0x12F85D: main (main.c:23) +==26330== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==26330== +==26330== +==26330== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==26330== Access not within mapped region at address 0x28 +==26330== at 0x130C08: env_err (gwion.c:110) +==26330== by 0x152A2B: gwi_class_end (import.c:268) +==26330== by 0x4848133: import (end_class.c:15) +==26330== by 0x14AC28: type_engine_init (engine.c:107) +==26330== by 0x1308A5: gwion_engine (gwion.c:39) +==26330== by 0x1308A5: gwion_ini (gwion.c:78) +==26330== by 0x12F85D: main (main.c:23) +==26330== If you believe this happened as a result of a stack +==26330== overflow in your program's main thread (unlikely but +==26330== possible), you can try to increase the size of the +==26330== main thread stack using the --main-stacksize= flag. +==26330== The main thread stack size used in this run was 8388608. +==26330== +==26330== HEAP SUMMARY: +==26330== in use at exit: 2,170,704 bytes in 374 blocks +==26330== total heap usage: 798 allocs, 424 frees, 2,264,821 bytes allocated +==26330== +==26330== LEAK SUMMARY: +==26330== definitely lost: 0 bytes in 0 blocks +==26330== indirectly lost: 0 bytes in 0 blocks +==26330== possibly lost: 0 bytes in 0 blocks +==26330== still reachable: 2,170,704 bytes in 374 blocks +==26330== suppressed: 0 bytes in 0 blocks +==26330== Rerun with --leak-check=full to see details of leaked memory +==26330== +==26330== For counts of detected and suppressed errors, rerun with: -v +==26330== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==26660== Memcheck, a memory error detector +==26660== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==26660== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==26660== Command: ./../../gwion -p. -d dummy /dev/null +==26660== Parent PID: 25929 +==26660== +==26660== Invalid read of size 4 +==26660== at 0x130C08: env_err (gwion.c:110) +==26660== by 0x1513F5: path_valid (import.c:145) +==26660== by 0x151D54: str2list (import.c:167) +==26660== by 0x152E72: str2decl (import.c:366) +==26660== by 0x15329C: make_dll_arg_list (import.c:395) +==26660== by 0x1537D0: make_dll_as_fun (import.c:440) +==26660== by 0x15391F: gwi_func_end (import.c:449) +==26660== by 0x4848225: import (invalid_arg.c:21) +==26660== by 0x14AC28: type_engine_init (engine.c:107) +==26660== by 0x1308A5: gwion_engine (gwion.c:39) +==26660== by 0x1308A5: gwion_ini (gwion.c:78) +==26660== by 0x12F85D: main (main.c:23) +==26660== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==26660== +==26660== +==26660== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==26660== Access not within mapped region at address 0x28 +==26660== at 0x130C08: env_err (gwion.c:110) +==26660== by 0x1513F5: path_valid (import.c:145) +==26660== by 0x151D54: str2list (import.c:167) +==26660== by 0x152E72: str2decl (import.c:366) +==26660== by 0x15329C: make_dll_arg_list (import.c:395) +==26660== by 0x1537D0: make_dll_as_fun (import.c:440) +==26660== by 0x15391F: gwi_func_end (import.c:449) +==26660== by 0x4848225: import (invalid_arg.c:21) +==26660== by 0x14AC28: type_engine_init (engine.c:107) +==26660== by 0x1308A5: gwion_engine (gwion.c:39) +==26660== by 0x1308A5: gwion_ini (gwion.c:78) +==26660== by 0x12F85D: main (main.c:23) +==26660== If you believe this happened as a result of a stack +==26660== overflow in your program's main thread (unlikely but +==26660== possible), you can try to increase the size of the +==26660== main thread stack using the --main-stacksize= flag. +==26660== The main thread stack size used in this run was 8388608. +==26660== +==26660== HEAP SUMMARY: +==26660== in use at exit: 2,171,862 bytes in 384 blocks +==26660== total heap usage: 810 allocs, 426 frees, 2,266,051 bytes allocated +==26660== +==26660== LEAK SUMMARY: +==26660== definitely lost: 0 bytes in 0 blocks +==26660== indirectly lost: 0 bytes in 0 blocks +==26660== possibly lost: 0 bytes in 0 blocks +==26660== still reachable: 2,171,862 bytes in 384 blocks +==26660== suppressed: 0 bytes in 0 blocks +==26660== Rerun with --leak-check=full to see details of leaked memory +==26660== +==26660== For counts of detected and suppressed errors, rerun with: -v +==26660== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==26706== Memcheck, a memory error detector +==26706== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==26706== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==26706== Command: ./../../gwion -p. -d dummy /dev/null +==26706== Parent PID: 25929 +==26706== +==26706== Invalid read of size 4 +==26706== at 0x130C08: env_err (gwion.c:110) +==26706== by 0x153373: make_dll_arg_list (import.c:406) +==26706== by 0x1537D0: make_dll_as_fun (import.c:440) +==26706== by 0x15391F: gwi_func_end (import.c:449) +==26706== by 0x48482A6: import (invalid_array.c:24) +==26706== by 0x14AC28: type_engine_init (engine.c:107) +==26706== by 0x1308A5: gwion_engine (gwion.c:39) +==26706== by 0x1308A5: gwion_ini (gwion.c:78) +==26706== by 0x12F85D: main (main.c:23) +==26706== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==26706== +==26706== +==26706== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==26706== Access not within mapped region at address 0x28 +==26706== at 0x130C08: env_err (gwion.c:110) +==26706== by 0x153373: make_dll_arg_list (import.c:406) +==26706== by 0x1537D0: make_dll_as_fun (import.c:440) +==26706== by 0x15391F: gwi_func_end (import.c:449) +==26706== by 0x48482A6: import (invalid_array.c:24) +==26706== by 0x14AC28: type_engine_init (engine.c:107) +==26706== by 0x1308A5: gwion_engine (gwion.c:39) +==26706== by 0x1308A5: gwion_ini (gwion.c:78) +==26706== by 0x12F85D: main (main.c:23) +==26706== If you believe this happened as a result of a stack +==26706== overflow in your program's main thread (unlikely but +==26706== possible), you can try to increase the size of the +==26706== main thread stack using the --main-stacksize= flag. +==26706== The main thread stack size used in this run was 8388608. +==26706== +==26706== HEAP SUMMARY: +==26706== in use at exit: 2,173,020 bytes in 385 blocks +==26706== total heap usage: 812 allocs, 427 frees, 2,267,345 bytes allocated +==26706== +==26706== LEAK SUMMARY: +==26706== definitely lost: 0 bytes in 0 blocks +==26706== indirectly lost: 0 bytes in 0 blocks +==26706== possibly lost: 0 bytes in 0 blocks +==26706== still reachable: 2,173,020 bytes in 385 blocks +==26706== suppressed: 0 bytes in 0 blocks +==26706== Rerun with --leak-check=full to see details of leaked memory +==26706== +==26706== For counts of detected and suppressed errors, rerun with: -v +==26706== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==26752== Memcheck, a memory error detector +==26752== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==26752== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==26752== Command: ./../../gwion -p. -d dummy /dev/null +==26752== Parent PID: 25929 +==26752== +==26752== Invalid read of size 4 +==26752== at 0x130C08: env_err (gwion.c:110) +==26752== by 0x1513F5: path_valid (import.c:145) +==26752== by 0x151D54: str2list (import.c:167) +==26752== by 0x153613: import_td (import.c:418) +==26752== by 0x1537A4: make_dll_as_fun (import.c:436) +==26752== by 0x15391F: gwi_func_end (import.c:449) +==26752== by 0x48481EC: import (invalid_func.c:20) +==26752== by 0x14AC28: type_engine_init (engine.c:107) +==26752== by 0x1308A5: gwion_engine (gwion.c:39) +==26752== by 0x1308A5: gwion_ini (gwion.c:78) +==26752== by 0x12F85D: main (main.c:23) +==26752== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==26752== +==26752== +==26752== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==26752== Access not within mapped region at address 0x28 +==26752== at 0x130C08: env_err (gwion.c:110) +==26752== by 0x1513F5: path_valid (import.c:145) +==26752== by 0x151D54: str2list (import.c:167) +==26752== by 0x153613: import_td (import.c:418) +==26752== by 0x1537A4: make_dll_as_fun (import.c:436) +==26752== by 0x15391F: gwi_func_end (import.c:449) +==26752== by 0x48481EC: import (invalid_func.c:20) +==26752== by 0x14AC28: type_engine_init (engine.c:107) +==26752== by 0x1308A5: gwion_engine (gwion.c:39) +==26752== by 0x1308A5: gwion_ini (gwion.c:78) +==26752== by 0x12F85D: main (main.c:23) +==26752== If you believe this happened as a result of a stack +==26752== overflow in your program's main thread (unlikely but +==26752== possible), you can try to increase the size of the +==26752== main thread stack using the --main-stacksize= flag. +==26752== The main thread stack size used in this run was 8388608. +==26752== +==26752== HEAP SUMMARY: +==26752== in use at exit: 2,171,353 bytes in 383 blocks +==26752== total heap usage: 809 allocs, 426 frees, 2,265,546 bytes allocated +==26752== +==26752== LEAK SUMMARY: +==26752== definitely lost: 0 bytes in 0 blocks +==26752== indirectly lost: 0 bytes in 0 blocks +==26752== possibly lost: 0 bytes in 0 blocks +==26752== still reachable: 2,171,353 bytes in 383 blocks +==26752== suppressed: 0 bytes in 0 blocks +==26752== Rerun with --leak-check=full to see details of leaked memory +==26752== +==26752== For counts of detected and suppressed errors, rerun with: -v +==26752== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==26799== Memcheck, a memory error detector +==26799== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==26799== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==26799== Command: ./../../gwion -p. -d dummy /dev/null +==26799== Parent PID: 25929 +==26799== +==26799== Invalid read of size 4 +==26799== at 0x130C08: env_err (gwion.c:110) +==26799== by 0x15127B: path_valid (import.c:135) +==26799== by 0x151D54: str2list (import.c:167) +==26799== by 0x152ABC: gwi_item_ini (import.c:302) +==26799== by 0x48481B5: import (invalid_type1.c:18) +==26799== by 0x14AC28: type_engine_init (engine.c:107) +==26799== by 0x1308A5: gwion_engine (gwion.c:39) +==26799== by 0x1308A5: gwion_ini (gwion.c:78) +==26799== by 0x12F85D: main (main.c:23) +==26799== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==26799== +==26799== +==26799== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==26799== Access not within mapped region at address 0x28 +==26799== at 0x130C08: env_err (gwion.c:110) +==26799== by 0x15127B: path_valid (import.c:135) +==26799== by 0x151D54: str2list (import.c:167) +==26799== by 0x152ABC: gwi_item_ini (import.c:302) +==26799== by 0x48481B5: import (invalid_type1.c:18) +==26799== by 0x14AC28: type_engine_init (engine.c:107) +==26799== by 0x1308A5: gwion_engine (gwion.c:39) +==26799== by 0x1308A5: gwion_ini (gwion.c:78) +==26799== by 0x12F85D: main (main.c:23) +==26799== If you believe this happened as a result of a stack +==26799== overflow in your program's main thread (unlikely but +==26799== possible), you can try to increase the size of the +==26799== main thread stack using the --main-stacksize= flag. +==26799== The main thread stack size used in this run was 8388608. +==26799== +==26799== HEAP SUMMARY: +==26799== in use at exit: 2,171,356 bytes in 383 blocks +==26799== total heap usage: 809 allocs, 426 frees, 2,265,553 bytes allocated +==26799== +==26799== LEAK SUMMARY: +==26799== definitely lost: 0 bytes in 0 blocks +==26799== indirectly lost: 0 bytes in 0 blocks +==26799== possibly lost: 0 bytes in 0 blocks +==26799== still reachable: 2,171,356 bytes in 383 blocks +==26799== suppressed: 0 bytes in 0 blocks +==26799== Rerun with --leak-check=full to see details of leaked memory +==26799== +==26799== For counts of detected and suppressed errors, rerun with: -v +==26799== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==26846== Memcheck, a memory error detector +==26846== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==26846== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==26846== Command: ./../../gwion -p. -d dummy /dev/null +==26846== Parent PID: 25929 +==26846== +==26846== Invalid read of size 4 +==26846== at 0x130C08: env_err (gwion.c:110) +==26846== by 0x1513F5: path_valid (import.c:145) +==26846== by 0x151D54: str2list (import.c:167) +==26846== by 0x152ABC: gwi_item_ini (import.c:302) +==26846== by 0x48481B5: import (invalid_type2.c:18) +==26846== by 0x14AC28: type_engine_init (engine.c:107) +==26846== by 0x1308A5: gwion_engine (gwion.c:39) +==26846== by 0x1308A5: gwion_ini (gwion.c:78) +==26846== by 0x12F85D: main (main.c:23) +==26846== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==26846== +==26846== +==26846== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==26846== Access not within mapped region at address 0x28 +==26846== at 0x130C08: env_err (gwion.c:110) +==26846== by 0x1513F5: path_valid (import.c:145) +==26846== by 0x151D54: str2list (import.c:167) +==26846== by 0x152ABC: gwi_item_ini (import.c:302) +==26846== by 0x48481B5: import (invalid_type2.c:18) +==26846== by 0x14AC28: type_engine_init (engine.c:107) +==26846== by 0x1308A5: gwion_engine (gwion.c:39) +==26846== by 0x1308A5: gwion_ini (gwion.c:78) +==26846== by 0x12F85D: main (main.c:23) +==26846== If you believe this happened as a result of a stack +==26846== overflow in your program's main thread (unlikely but +==26846== possible), you can try to increase the size of the +==26846== main thread stack using the --main-stacksize= flag. +==26846== The main thread stack size used in this run was 8388608. +==26846== +==26846== HEAP SUMMARY: +==26846== in use at exit: 2,171,356 bytes in 383 blocks +==26846== total heap usage: 809 allocs, 426 frees, 2,265,553 bytes allocated +==26846== +==26846== LEAK SUMMARY: +==26846== definitely lost: 0 bytes in 0 blocks +==26846== indirectly lost: 0 bytes in 0 blocks +==26846== possibly lost: 0 bytes in 0 blocks +==26846== still reachable: 2,171,356 bytes in 383 blocks +==26846== suppressed: 0 bytes in 0 blocks +==26846== Rerun with --leak-check=full to see details of leaked memory +==26846== +==26846== For counts of detected and suppressed errors, rerun with: -v +==26846== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==26892== Memcheck, a memory error detector +==26892== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==26892== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==26892== Command: ./../../gwion -p. -d dummy /dev/null +==26892== Parent PID: 25929 +==26892== +==26892== Invalid read of size 4 +==26892== at 0x130C08: env_err (gwion.c:110) +==26892== by 0x1510E0: name_valid (import.c:116) +==26892== by 0x152365: gwi_add_type (import.c:195) +==26892== by 0x15242B: gwi_class_ini (import.c:229) +==26892== by 0x484818F: import (invalid_type3.c:18) +==26892== by 0x14AC28: type_engine_init (engine.c:107) +==26892== by 0x1308A5: gwion_engine (gwion.c:39) +==26892== by 0x1308A5: gwion_ini (gwion.c:78) +==26892== by 0x12F85D: main (main.c:23) +==26892== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==26892== +==26892== +==26892== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==26892== Access not within mapped region at address 0x28 +==26892== at 0x130C08: env_err (gwion.c:110) +==26892== by 0x1510E0: name_valid (import.c:116) +==26892== by 0x152365: gwi_add_type (import.c:195) +==26892== by 0x15242B: gwi_class_ini (import.c:229) +==26892== by 0x484818F: import (invalid_type3.c:18) +==26892== by 0x14AC28: type_engine_init (engine.c:107) +==26892== by 0x1308A5: gwion_engine (gwion.c:39) +==26892== by 0x1308A5: gwion_ini (gwion.c:78) +==26892== by 0x12F85D: main (main.c:23) +==26892== If you believe this happened as a result of a stack +==26892== overflow in your program's main thread (unlikely but +==26892== possible), you can try to increase the size of the +==26892== main thread stack using the --main-stacksize= flag. +==26892== The main thread stack size used in this run was 8388608. +==26892== +==26892== HEAP SUMMARY: +==26892== in use at exit: 2,170,716 bytes in 374 blocks +==26892== total heap usage: 798 allocs, 424 frees, 2,264,849 bytes allocated +==26892== +==26892== LEAK SUMMARY: +==26892== definitely lost: 0 bytes in 0 blocks +==26892== indirectly lost: 0 bytes in 0 blocks +==26892== possibly lost: 0 bytes in 0 blocks +==26892== still reachable: 2,170,716 bytes in 374 blocks +==26892== suppressed: 0 bytes in 0 blocks +==26892== Rerun with --leak-check=full to see details of leaked memory +==26892== +==26892== For counts of detected and suppressed errors, rerun with: -v +==26892== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==27078== Memcheck, a memory error detector +==27078== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==27078== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==27078== Command: ./../../gwion -p. -d dummy /dev/null +==27078== Parent PID: 25929 +==27078== +==27078== Invalid read of size 4 +==27078== at 0x130C08: env_err (gwion.c:110) +==27078== by 0x1530F4: make_dll_arg_list (import.c:398) +==27078== by 0x1537D0: make_dll_as_fun (import.c:440) +==27078== by 0x15391F: gwi_func_end (import.c:449) +==27078== by 0x4848225: import (template_arg.c:21) +==27078== by 0x14AC28: type_engine_init (engine.c:107) +==27078== by 0x1308A5: gwion_engine (gwion.c:39) +==27078== by 0x1308A5: gwion_ini (gwion.c:78) +==27078== by 0x12F85D: main (main.c:23) +==27078== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==27078== +==27078== +==27078== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==27078== Access not within mapped region at address 0x28 +==27078== at 0x130C08: env_err (gwion.c:110) +==27078== by 0x1530F4: make_dll_arg_list (import.c:398) +==27078== by 0x1537D0: make_dll_as_fun (import.c:440) +==27078== by 0x15391F: gwi_func_end (import.c:449) +==27078== by 0x4848225: import (template_arg.c:21) +==27078== by 0x14AC28: type_engine_init (engine.c:107) +==27078== by 0x1308A5: gwion_engine (gwion.c:39) +==27078== by 0x1308A5: gwion_ini (gwion.c:78) +==27078== by 0x12F85D: main (main.c:23) +==27078== If you believe this happened as a result of a stack +==27078== overflow in your program's main thread (unlikely but +==27078== possible), you can try to increase the size of the +==27078== main thread stack using the --main-stacksize= flag. +==27078== The main thread stack size used in this run was 8388608. +==27078== +==27078== HEAP SUMMARY: +==27078== in use at exit: 2,177,657 bytes in 395 blocks +==27078== total heap usage: 829 allocs, 434 frees, 2,272,394 bytes allocated +==27078== +==27078== LEAK SUMMARY: +==27078== definitely lost: 0 bytes in 0 blocks +==27078== indirectly lost: 0 bytes in 0 blocks +==27078== possibly lost: 0 bytes in 0 blocks +==27078== still reachable: 2,177,657 bytes in 395 blocks +==27078== suppressed: 0 bytes in 0 blocks +==27078== Rerun with --leak-check=full to see details of leaked memory +==27078== +==27078== For counts of detected and suppressed errors, rerun with: -v +==27078== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==25955== Memcheck, a memory error detector +==25955== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==25955== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==25955== Command: ./../../gwion -p. -d dummy /dev/null +==25955== Parent PID: 25929 +==25955== +==25955== +==25955== HEAP SUMMARY: +==25955== in use at exit: 928 bytes in 10 blocks +==25955== total heap usage: 997 allocs, 987 frees, 7,604,988 bytes allocated +==25955== +==25955== LEAK SUMMARY: +==25955== definitely lost: 928 bytes in 10 blocks +==25955== indirectly lost: 0 bytes in 0 blocks +==25955== possibly lost: 0 bytes in 0 blocks +==25955== still reachable: 0 bytes in 0 blocks +==25955== suppressed: 0 bytes in 0 blocks +==25955== Rerun with --leak-check=full to see details of leaked memory +==25955== +==25955== For counts of detected and suppressed errors, rerun with: -v +==25955== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0) +/dev/null ==26053== Memcheck, a memory error detector +==26053== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==26053== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==26053== Command: ./../../gwion -p. -d dummy /dev/null +==26053== Parent PID: 25929 +==26053== +==26053== Invalid read of size 4 +==26053== at 0x130C08: env_err (gwion.c:110) +==26053== by 0x1524AC: gwi_class_ini (import.c:220) +==26053== by 0x48481A0: import (begin_class.c:18) +==26053== by 0x14AC28: type_engine_init (engine.c:107) +==26053== by 0x1308A5: gwion_engine (gwion.c:39) +==26053== by 0x1308A5: gwion_ini (gwion.c:78) +==26053== by 0x12F85D: main (main.c:23) +==26053== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==26053== +==26053== +==26053== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==26053== Access not within mapped region at address 0x28 +==26053== at 0x130C08: env_err (gwion.c:110) +==26053== by 0x1524AC: gwi_class_ini (import.c:220) +==26053== by 0x48481A0: import (begin_class.c:18) +==26053== by 0x14AC28: type_engine_init (engine.c:107) +==26053== by 0x1308A5: gwion_engine (gwion.c:39) +==26053== by 0x1308A5: gwion_ini (gwion.c:78) +==26053== by 0x12F85D: main (main.c:23) +==26053== If you believe this happened as a result of a stack +==26053== overflow in your program's main thread (unlikely but +==26053== possible), you can try to increase the size of the +==26053== main thread stack using the --main-stacksize= flag. +==26053== The main thread stack size used in this run was 8388608. +==26053== +==26053== HEAP SUMMARY: +==26053== in use at exit: 2,171,350 bytes in 383 blocks +==26053== total heap usage: 809 allocs, 426 frees, 2,265,539 bytes allocated +==26053== +==26053== LEAK SUMMARY: +==26053== definitely lost: 0 bytes in 0 blocks +==26053== indirectly lost: 0 bytes in 0 blocks +==26053== possibly lost: 0 bytes in 0 blocks +==26053== still reachable: 2,171,350 bytes in 383 blocks +==26053== suppressed: 0 bytes in 0 blocks +==26053== Rerun with --leak-check=full to see details of leaked memory +==26053== +==26053== For counts of detected and suppressed errors, rerun with: -v +==26053== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==26283== Memcheck, a memory error detector +==26283== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==26283== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==26283== Command: ./../../gwion -p. -d dummy /dev/null +==26283== Parent PID: 25929 +==26283== +==26283== Invalid read of size 4 +==26283== at 0x130C08: env_err (gwion.c:110) +==26283== by 0x154181: gwi_union_end (import.c:601) +==26283== by 0x4848152: import (empty_union.c:15) +==26283== by 0x14AC28: type_engine_init (engine.c:107) +==26283== by 0x1308A5: gwion_engine (gwion.c:39) +==26283== by 0x1308A5: gwion_ini (gwion.c:78) +==26283== by 0x12F85D: main (main.c:23) +==26283== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==26283== +==26283== +==26283== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==26283== Access not within mapped region at address 0x28 +==26283== at 0x130C08: env_err (gwion.c:110) +==26283== by 0x154181: gwi_union_end (import.c:601) +==26283== by 0x4848152: import (empty_union.c:15) +==26283== by 0x14AC28: type_engine_init (engine.c:107) +==26283== by 0x1308A5: gwion_engine (gwion.c:39) +==26283== by 0x1308A5: gwion_ini (gwion.c:78) +==26283== by 0x12F85D: main (main.c:23) +==26283== If you believe this happened as a result of a stack +==26283== overflow in your program's main thread (unlikely but +==26283== possible), you can try to increase the size of the +==26283== main thread stack using the --main-stacksize= flag. +==26283== The main thread stack size used in this run was 8388608. +==26283== +==26283== HEAP SUMMARY: +==26283== in use at exit: 2,170,710 bytes in 374 blocks +==26283== total heap usage: 798 allocs, 424 frees, 2,264,835 bytes allocated +==26283== +==26283== LEAK SUMMARY: +==26283== definitely lost: 0 bytes in 0 blocks +==26283== indirectly lost: 0 bytes in 0 blocks +==26283== possibly lost: 0 bytes in 0 blocks +==26283== still reachable: 2,170,710 bytes in 374 blocks +==26283== suppressed: 0 bytes in 0 blocks +==26283== Rerun with --leak-check=full to see details of leaked memory +==26283== +==26283== For counts of detected and suppressed errors, rerun with: -v +==26283== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==26330== Memcheck, a memory error detector +==26330== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==26330== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==26330== Command: ./../../gwion -p. -d dummy /dev/null +==26330== Parent PID: 25929 +==26330== +==26330== Invalid read of size 4 +==26330== at 0x130C08: env_err (gwion.c:110) +==26330== by 0x152A2B: gwi_class_end (import.c:268) +==26330== by 0x4848133: import (end_class.c:15) +==26330== by 0x14AC28: type_engine_init (engine.c:107) +==26330== by 0x1308A5: gwion_engine (gwion.c:39) +==26330== by 0x1308A5: gwion_ini (gwion.c:78) +==26330== by 0x12F85D: main (main.c:23) +==26330== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==26330== +==26330== +==26330== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==26330== Access not within mapped region at address 0x28 +==26330== at 0x130C08: env_err (gwion.c:110) +==26330== by 0x152A2B: gwi_class_end (import.c:268) +==26330== by 0x4848133: import (end_class.c:15) +==26330== by 0x14AC28: type_engine_init (engine.c:107) +==26330== by 0x1308A5: gwion_engine (gwion.c:39) +==26330== by 0x1308A5: gwion_ini (gwion.c:78) +==26330== by 0x12F85D: main (main.c:23) +==26330== If you believe this happened as a result of a stack +==26330== overflow in your program's main thread (unlikely but +==26330== possible), you can try to increase the size of the +==26330== main thread stack using the --main-stacksize= flag. +==26330== The main thread stack size used in this run was 8388608. +==26330== +==26330== HEAP SUMMARY: +==26330== in use at exit: 2,170,704 bytes in 374 blocks +==26330== total heap usage: 798 allocs, 424 frees, 2,264,821 bytes allocated +==26330== +==26330== LEAK SUMMARY: +==26330== definitely lost: 0 bytes in 0 blocks +==26330== indirectly lost: 0 bytes in 0 blocks +==26330== possibly lost: 0 bytes in 0 blocks +==26330== still reachable: 2,170,704 bytes in 374 blocks +==26330== suppressed: 0 bytes in 0 blocks +==26330== Rerun with --leak-check=full to see details of leaked memory +==26330== +==26330== For counts of detected and suppressed errors, rerun with: -v +==26330== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==26660== Memcheck, a memory error detector +==26660== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==26660== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==26660== Command: ./../../gwion -p. -d dummy /dev/null +==26660== Parent PID: 25929 +==26660== +==26660== Invalid read of size 4 +==26660== at 0x130C08: env_err (gwion.c:110) +==26660== by 0x1513F5: path_valid (import.c:145) +==26660== by 0x151D54: str2list (import.c:167) +==26660== by 0x152E72: str2decl (import.c:366) +==26660== by 0x15329C: make_dll_arg_list (import.c:395) +==26660== by 0x1537D0: make_dll_as_fun (import.c:440) +==26660== by 0x15391F: gwi_func_end (import.c:449) +==26660== by 0x4848225: import (invalid_arg.c:21) +==26660== by 0x14AC28: type_engine_init (engine.c:107) +==26660== by 0x1308A5: gwion_engine (gwion.c:39) +==26660== by 0x1308A5: gwion_ini (gwion.c:78) +==26660== by 0x12F85D: main (main.c:23) +==26660== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==26660== +==26660== +==26660== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==26660== Access not within mapped region at address 0x28 +==26660== at 0x130C08: env_err (gwion.c:110) +==26660== by 0x1513F5: path_valid (import.c:145) +==26660== by 0x151D54: str2list (import.c:167) +==26660== by 0x152E72: str2decl (import.c:366) +==26660== by 0x15329C: make_dll_arg_list (import.c:395) +==26660== by 0x1537D0: make_dll_as_fun (import.c:440) +==26660== by 0x15391F: gwi_func_end (import.c:449) +==26660== by 0x4848225: import (invalid_arg.c:21) +==26660== by 0x14AC28: type_engine_init (engine.c:107) +==26660== by 0x1308A5: gwion_engine (gwion.c:39) +==26660== by 0x1308A5: gwion_ini (gwion.c:78) +==26660== by 0x12F85D: main (main.c:23) +==26660== If you believe this happened as a result of a stack +==26660== overflow in your program's main thread (unlikely but +==26660== possible), you can try to increase the size of the +==26660== main thread stack using the --main-stacksize= flag. +==26660== The main thread stack size used in this run was 8388608. +==26660== +==26660== HEAP SUMMARY: +==26660== in use at exit: 2,171,862 bytes in 384 blocks +==26660== total heap usage: 810 allocs, 426 frees, 2,266,051 bytes allocated +==26660== +==26660== LEAK SUMMARY: +==26660== definitely lost: 0 bytes in 0 blocks +==26660== indirectly lost: 0 bytes in 0 blocks +==26660== possibly lost: 0 bytes in 0 blocks +==26660== still reachable: 2,171,862 bytes in 384 blocks +==26660== suppressed: 0 bytes in 0 blocks +==26660== Rerun with --leak-check=full to see details of leaked memory +==26660== +==26660== For counts of detected and suppressed errors, rerun with: -v +==26660== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==26706== Memcheck, a memory error detector +==26706== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==26706== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==26706== Command: ./../../gwion -p. -d dummy /dev/null +==26706== Parent PID: 25929 +==26706== +==26706== Invalid read of size 4 +==26706== at 0x130C08: env_err (gwion.c:110) +==26706== by 0x153373: make_dll_arg_list (import.c:406) +==26706== by 0x1537D0: make_dll_as_fun (import.c:440) +==26706== by 0x15391F: gwi_func_end (import.c:449) +==26706== by 0x48482A6: import (invalid_array.c:24) +==26706== by 0x14AC28: type_engine_init (engine.c:107) +==26706== by 0x1308A5: gwion_engine (gwion.c:39) +==26706== by 0x1308A5: gwion_ini (gwion.c:78) +==26706== by 0x12F85D: main (main.c:23) +==26706== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==26706== +==26706== +==26706== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==26706== Access not within mapped region at address 0x28 +==26706== at 0x130C08: env_err (gwion.c:110) +==26706== by 0x153373: make_dll_arg_list (import.c:406) +==26706== by 0x1537D0: make_dll_as_fun (import.c:440) +==26706== by 0x15391F: gwi_func_end (import.c:449) +==26706== by 0x48482A6: import (invalid_array.c:24) +==26706== by 0x14AC28: type_engine_init (engine.c:107) +==26706== by 0x1308A5: gwion_engine (gwion.c:39) +==26706== by 0x1308A5: gwion_ini (gwion.c:78) +==26706== by 0x12F85D: main (main.c:23) +==26706== If you believe this happened as a result of a stack +==26706== overflow in your program's main thread (unlikely but +==26706== possible), you can try to increase the size of the +==26706== main thread stack using the --main-stacksize= flag. +==26706== The main thread stack size used in this run was 8388608. +==26706== +==26706== HEAP SUMMARY: +==26706== in use at exit: 2,173,020 bytes in 385 blocks +==26706== total heap usage: 812 allocs, 427 frees, 2,267,345 bytes allocated +==26706== +==26706== LEAK SUMMARY: +==26706== definitely lost: 0 bytes in 0 blocks +==26706== indirectly lost: 0 bytes in 0 blocks +==26706== possibly lost: 0 bytes in 0 blocks +==26706== still reachable: 2,173,020 bytes in 385 blocks +==26706== suppressed: 0 bytes in 0 blocks +==26706== Rerun with --leak-check=full to see details of leaked memory +==26706== +==26706== For counts of detected and suppressed errors, rerun with: -v +==26706== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==26752== Memcheck, a memory error detector +==26752== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==26752== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==26752== Command: ./../../gwion -p. -d dummy /dev/null +==26752== Parent PID: 25929 +==26752== +==26752== Invalid read of size 4 +==26752== at 0x130C08: env_err (gwion.c:110) +==26752== by 0x1513F5: path_valid (import.c:145) +==26752== by 0x151D54: str2list (import.c:167) +==26752== by 0x153613: import_td (import.c:418) +==26752== by 0x1537A4: make_dll_as_fun (import.c:436) +==26752== by 0x15391F: gwi_func_end (import.c:449) +==26752== by 0x48481EC: import (invalid_func.c:20) +==26752== by 0x14AC28: type_engine_init (engine.c:107) +==26752== by 0x1308A5: gwion_engine (gwion.c:39) +==26752== by 0x1308A5: gwion_ini (gwion.c:78) +==26752== by 0x12F85D: main (main.c:23) +==26752== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==26752== +==26752== +==26752== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==26752== Access not within mapped region at address 0x28 +==26752== at 0x130C08: env_err (gwion.c:110) +==26752== by 0x1513F5: path_valid (import.c:145) +==26752== by 0x151D54: str2list (import.c:167) +==26752== by 0x153613: import_td (import.c:418) +==26752== by 0x1537A4: make_dll_as_fun (import.c:436) +==26752== by 0x15391F: gwi_func_end (import.c:449) +==26752== by 0x48481EC: import (invalid_func.c:20) +==26752== by 0x14AC28: type_engine_init (engine.c:107) +==26752== by 0x1308A5: gwion_engine (gwion.c:39) +==26752== by 0x1308A5: gwion_ini (gwion.c:78) +==26752== by 0x12F85D: main (main.c:23) +==26752== If you believe this happened as a result of a stack +==26752== overflow in your program's main thread (unlikely but +==26752== possible), you can try to increase the size of the +==26752== main thread stack using the --main-stacksize= flag. +==26752== The main thread stack size used in this run was 8388608. +==26752== +==26752== HEAP SUMMARY: +==26752== in use at exit: 2,171,353 bytes in 383 blocks +==26752== total heap usage: 809 allocs, 426 frees, 2,265,546 bytes allocated +==26752== +==26752== LEAK SUMMARY: +==26752== definitely lost: 0 bytes in 0 blocks +==26752== indirectly lost: 0 bytes in 0 blocks +==26752== possibly lost: 0 bytes in 0 blocks +==26752== still reachable: 2,171,353 bytes in 383 blocks +==26752== suppressed: 0 bytes in 0 blocks +==26752== Rerun with --leak-check=full to see details of leaked memory +==26752== +==26752== For counts of detected and suppressed errors, rerun with: -v +==26752== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==26799== Memcheck, a memory error detector +==26799== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==26799== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==26799== Command: ./../../gwion -p. -d dummy /dev/null +==26799== Parent PID: 25929 +==26799== +==26799== Invalid read of size 4 +==26799== at 0x130C08: env_err (gwion.c:110) +==26799== by 0x15127B: path_valid (import.c:135) +==26799== by 0x151D54: str2list (import.c:167) +==26799== by 0x152ABC: gwi_item_ini (import.c:302) +==26799== by 0x48481B5: import (invalid_type1.c:18) +==26799== by 0x14AC28: type_engine_init (engine.c:107) +==26799== by 0x1308A5: gwion_engine (gwion.c:39) +==26799== by 0x1308A5: gwion_ini (gwion.c:78) +==26799== by 0x12F85D: main (main.c:23) +==26799== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==26799== +==26799== +==26799== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==26799== Access not within mapped region at address 0x28 +==26799== at 0x130C08: env_err (gwion.c:110) +==26799== by 0x15127B: path_valid (import.c:135) +==26799== by 0x151D54: str2list (import.c:167) +==26799== by 0x152ABC: gwi_item_ini (import.c:302) +==26799== by 0x48481B5: import (invalid_type1.c:18) +==26799== by 0x14AC28: type_engine_init (engine.c:107) +==26799== by 0x1308A5: gwion_engine (gwion.c:39) +==26799== by 0x1308A5: gwion_ini (gwion.c:78) +==26799== by 0x12F85D: main (main.c:23) +==26799== If you believe this happened as a result of a stack +==26799== overflow in your program's main thread (unlikely but +==26799== possible), you can try to increase the size of the +==26799== main thread stack using the --main-stacksize= flag. +==26799== The main thread stack size used in this run was 8388608. +==26799== +==26799== HEAP SUMMARY: +==26799== in use at exit: 2,171,356 bytes in 383 blocks +==26799== total heap usage: 809 allocs, 426 frees, 2,265,553 bytes allocated +==26799== +==26799== LEAK SUMMARY: +==26799== definitely lost: 0 bytes in 0 blocks +==26799== indirectly lost: 0 bytes in 0 blocks +==26799== possibly lost: 0 bytes in 0 blocks +==26799== still reachable: 2,171,356 bytes in 383 blocks +==26799== suppressed: 0 bytes in 0 blocks +==26799== Rerun with --leak-check=full to see details of leaked memory +==26799== +==26799== For counts of detected and suppressed errors, rerun with: -v +==26799== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==26846== Memcheck, a memory error detector +==26846== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==26846== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==26846== Command: ./../../gwion -p. -d dummy /dev/null +==26846== Parent PID: 25929 +==26846== +==26846== Invalid read of size 4 +==26846== at 0x130C08: env_err (gwion.c:110) +==26846== by 0x1513F5: path_valid (import.c:145) +==26846== by 0x151D54: str2list (import.c:167) +==26846== by 0x152ABC: gwi_item_ini (import.c:302) +==26846== by 0x48481B5: import (invalid_type2.c:18) +==26846== by 0x14AC28: type_engine_init (engine.c:107) +==26846== by 0x1308A5: gwion_engine (gwion.c:39) +==26846== by 0x1308A5: gwion_ini (gwion.c:78) +==26846== by 0x12F85D: main (main.c:23) +==26846== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==26846== +==26846== +==26846== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==26846== Access not within mapped region at address 0x28 +==26846== at 0x130C08: env_err (gwion.c:110) +==26846== by 0x1513F5: path_valid (import.c:145) +==26846== by 0x151D54: str2list (import.c:167) +==26846== by 0x152ABC: gwi_item_ini (import.c:302) +==26846== by 0x48481B5: import (invalid_type2.c:18) +==26846== by 0x14AC28: type_engine_init (engine.c:107) +==26846== by 0x1308A5: gwion_engine (gwion.c:39) +==26846== by 0x1308A5: gwion_ini (gwion.c:78) +==26846== by 0x12F85D: main (main.c:23) +==26846== If you believe this happened as a result of a stack +==26846== overflow in your program's main thread (unlikely but +==26846== possible), you can try to increase the size of the +==26846== main thread stack using the --main-stacksize= flag. +==26846== The main thread stack size used in this run was 8388608. +==26846== +==26846== HEAP SUMMARY: +==26846== in use at exit: 2,171,356 bytes in 383 blocks +==26846== total heap usage: 809 allocs, 426 frees, 2,265,553 bytes allocated +==26846== +==26846== LEAK SUMMARY: +==26846== definitely lost: 0 bytes in 0 blocks +==26846== indirectly lost: 0 bytes in 0 blocks +==26846== possibly lost: 0 bytes in 0 blocks +==26846== still reachable: 2,171,356 bytes in 383 blocks +==26846== suppressed: 0 bytes in 0 blocks +==26846== Rerun with --leak-check=full to see details of leaked memory +==26846== +==26846== For counts of detected and suppressed errors, rerun with: -v +==26846== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==26892== Memcheck, a memory error detector +==26892== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==26892== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==26892== Command: ./../../gwion -p. -d dummy /dev/null +==26892== Parent PID: 25929 +==26892== +==26892== Invalid read of size 4 +==26892== at 0x130C08: env_err (gwion.c:110) +==26892== by 0x1510E0: name_valid (import.c:116) +==26892== by 0x152365: gwi_add_type (import.c:195) +==26892== by 0x15242B: gwi_class_ini (import.c:229) +==26892== by 0x484818F: import (invalid_type3.c:18) +==26892== by 0x14AC28: type_engine_init (engine.c:107) +==26892== by 0x1308A5: gwion_engine (gwion.c:39) +==26892== by 0x1308A5: gwion_ini (gwion.c:78) +==26892== by 0x12F85D: main (main.c:23) +==26892== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==26892== +==26892== +==26892== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==26892== Access not within mapped region at address 0x28 +==26892== at 0x130C08: env_err (gwion.c:110) +==26892== by 0x1510E0: name_valid (import.c:116) +==26892== by 0x152365: gwi_add_type (import.c:195) +==26892== by 0x15242B: gwi_class_ini (import.c:229) +==26892== by 0x484818F: import (invalid_type3.c:18) +==26892== by 0x14AC28: type_engine_init (engine.c:107) +==26892== by 0x1308A5: gwion_engine (gwion.c:39) +==26892== by 0x1308A5: gwion_ini (gwion.c:78) +==26892== by 0x12F85D: main (main.c:23) +==26892== If you believe this happened as a result of a stack +==26892== overflow in your program's main thread (unlikely but +==26892== possible), you can try to increase the size of the +==26892== main thread stack using the --main-stacksize= flag. +==26892== The main thread stack size used in this run was 8388608. +==26892== +==26892== HEAP SUMMARY: +==26892== in use at exit: 2,170,716 bytes in 374 blocks +==26892== total heap usage: 798 allocs, 424 frees, 2,264,849 bytes allocated +==26892== +==26892== LEAK SUMMARY: +==26892== definitely lost: 0 bytes in 0 blocks +==26892== indirectly lost: 0 bytes in 0 blocks +==26892== possibly lost: 0 bytes in 0 blocks +==26892== still reachable: 2,170,716 bytes in 374 blocks +==26892== suppressed: 0 bytes in 0 blocks +==26892== Rerun with --leak-check=full to see details of leaked memory +==26892== +==26892== For counts of detected and suppressed errors, rerun with: -v +==26892== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==27078== Memcheck, a memory error detector +==27078== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==27078== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==27078== Command: ./../../gwion -p. -d dummy /dev/null +==27078== Parent PID: 25929 +==27078== +==27078== Invalid read of size 4 +==27078== at 0x130C08: env_err (gwion.c:110) +==27078== by 0x1530F4: make_dll_arg_list (import.c:398) +==27078== by 0x1537D0: make_dll_as_fun (import.c:440) +==27078== by 0x15391F: gwi_func_end (import.c:449) +==27078== by 0x4848225: import (template_arg.c:21) +==27078== by 0x14AC28: type_engine_init (engine.c:107) +==27078== by 0x1308A5: gwion_engine (gwion.c:39) +==27078== by 0x1308A5: gwion_ini (gwion.c:78) +==27078== by 0x12F85D: main (main.c:23) +==27078== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==27078== +==27078== +==27078== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==27078== Access not within mapped region at address 0x28 +==27078== at 0x130C08: env_err (gwion.c:110) +==27078== by 0x1530F4: make_dll_arg_list (import.c:398) +==27078== by 0x1537D0: make_dll_as_fun (import.c:440) +==27078== by 0x15391F: gwi_func_end (import.c:449) +==27078== by 0x4848225: import (template_arg.c:21) +==27078== by 0x14AC28: type_engine_init (engine.c:107) +==27078== by 0x1308A5: gwion_engine (gwion.c:39) +==27078== by 0x1308A5: gwion_ini (gwion.c:78) +==27078== by 0x12F85D: main (main.c:23) +==27078== If you believe this happened as a result of a stack +==27078== overflow in your program's main thread (unlikely but +==27078== possible), you can try to increase the size of the +==27078== main thread stack using the --main-stacksize= flag. +==27078== The main thread stack size used in this run was 8388608. +==27078== +==27078== HEAP SUMMARY: +==27078== in use at exit: 2,177,657 bytes in 395 blocks +==27078== total heap usage: 829 allocs, 434 frees, 2,272,394 bytes allocated +==27078== +==27078== LEAK SUMMARY: +==27078== definitely lost: 0 bytes in 0 blocks +==27078== indirectly lost: 0 bytes in 0 blocks +==27078== possibly lost: 0 bytes in 0 blocks +==27078== still reachable: 2,177,657 bytes in 395 blocks +==27078== suppressed: 0 bytes in 0 blocks +==27078== Rerun with --leak-check=full to see details of leaked memory +==27078== +==27078== For counts of detected and suppressed errors, rerun with: -v +==27078== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==22243== Memcheck, a memory error detector +==22243== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==22243== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==22243== Command: ./../../gwion -p. -d dummy /dev/null +==22243== Parent PID: 22217 +==22243== +==22243== +==22243== HEAP SUMMARY: +==22243== in use at exit: 928 bytes in 10 blocks +==22243== total heap usage: 997 allocs, 987 frees, 7,604,988 bytes allocated +==22243== +==22243== LEAK SUMMARY: +==22243== definitely lost: 928 bytes in 10 blocks +==22243== indirectly lost: 0 bytes in 0 blocks +==22243== possibly lost: 0 bytes in 0 blocks +==22243== still reachable: 0 bytes in 0 blocks +==22243== suppressed: 0 bytes in 0 blocks +==22243== Rerun with --leak-check=full to see details of leaked memory +==22243== +==22243== For counts of detected and suppressed errors, rerun with: -v +==22243== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0) +/dev/null ==22341== Memcheck, a memory error detector +==22341== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==22341== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==22341== Command: ./../../gwion -p. -d dummy /dev/null +==22341== Parent PID: 22217 +==22341== +==22341== Invalid read of size 4 +==22341== at 0x130C08: env_err (gwion.c:110) +==22341== by 0x1524AC: gwi_class_ini (import.c:220) +==22341== by 0x48481A0: import (begin_class.c:18) +==22341== by 0x14AC28: type_engine_init (engine.c:107) +==22341== by 0x1308A5: gwion_engine (gwion.c:39) +==22341== by 0x1308A5: gwion_ini (gwion.c:78) +==22341== by 0x12F85D: main (main.c:23) +==22341== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==22341== +==22341== +==22341== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==22341== Access not within mapped region at address 0x28 +==22341== at 0x130C08: env_err (gwion.c:110) +==22341== by 0x1524AC: gwi_class_ini (import.c:220) +==22341== by 0x48481A0: import (begin_class.c:18) +==22341== by 0x14AC28: type_engine_init (engine.c:107) +==22341== by 0x1308A5: gwion_engine (gwion.c:39) +==22341== by 0x1308A5: gwion_ini (gwion.c:78) +==22341== by 0x12F85D: main (main.c:23) +==22341== If you believe this happened as a result of a stack +==22341== overflow in your program's main thread (unlikely but +==22341== possible), you can try to increase the size of the +==22341== main thread stack using the --main-stacksize= flag. +==22341== The main thread stack size used in this run was 8388608. +==22341== +==22341== HEAP SUMMARY: +==22341== in use at exit: 2,171,350 bytes in 383 blocks +==22341== total heap usage: 809 allocs, 426 frees, 2,265,539 bytes allocated +==22341== +==22341== LEAK SUMMARY: +==22341== definitely lost: 0 bytes in 0 blocks +==22341== indirectly lost: 0 bytes in 0 blocks +==22341== possibly lost: 0 bytes in 0 blocks +==22341== still reachable: 2,171,350 bytes in 383 blocks +==22341== suppressed: 0 bytes in 0 blocks +==22341== Rerun with --leak-check=full to see details of leaked memory +==22341== +==22341== For counts of detected and suppressed errors, rerun with: -v +==22341== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==22570== Memcheck, a memory error detector +==22570== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==22570== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==22570== Command: ./../../gwion -p. -d dummy /dev/null +==22570== Parent PID: 22217 +==22570== +==22570== Invalid read of size 4 +==22570== at 0x130C08: env_err (gwion.c:110) +==22570== by 0x154181: gwi_union_end (import.c:601) +==22570== by 0x4848152: import (empty_union.c:15) +==22570== by 0x14AC28: type_engine_init (engine.c:107) +==22570== by 0x1308A5: gwion_engine (gwion.c:39) +==22570== by 0x1308A5: gwion_ini (gwion.c:78) +==22570== by 0x12F85D: main (main.c:23) +==22570== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==22570== +==22570== +==22570== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==22570== Access not within mapped region at address 0x28 +==22570== at 0x130C08: env_err (gwion.c:110) +==22570== by 0x154181: gwi_union_end (import.c:601) +==22570== by 0x4848152: import (empty_union.c:15) +==22570== by 0x14AC28: type_engine_init (engine.c:107) +==22570== by 0x1308A5: gwion_engine (gwion.c:39) +==22570== by 0x1308A5: gwion_ini (gwion.c:78) +==22570== by 0x12F85D: main (main.c:23) +==22570== If you believe this happened as a result of a stack +==22570== overflow in your program's main thread (unlikely but +==22570== possible), you can try to increase the size of the +==22570== main thread stack using the --main-stacksize= flag. +==22570== The main thread stack size used in this run was 8388608. +==22570== +==22570== HEAP SUMMARY: +==22570== in use at exit: 2,170,710 bytes in 374 blocks +==22570== total heap usage: 798 allocs, 424 frees, 2,264,835 bytes allocated +==22570== +==22570== LEAK SUMMARY: +==22570== definitely lost: 0 bytes in 0 blocks +==22570== indirectly lost: 0 bytes in 0 blocks +==22570== possibly lost: 0 bytes in 0 blocks +==22570== still reachable: 2,170,710 bytes in 374 blocks +==22570== suppressed: 0 bytes in 0 blocks +==22570== Rerun with --leak-check=full to see details of leaked memory +==22570== +==22570== For counts of detected and suppressed errors, rerun with: -v +==22570== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==22617== Memcheck, a memory error detector +==22617== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==22617== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==22617== Command: ./../../gwion -p. -d dummy /dev/null +==22617== Parent PID: 22217 +==22617== +==22617== Invalid read of size 4 +==22617== at 0x130C08: env_err (gwion.c:110) +==22617== by 0x152A2B: gwi_class_end (import.c:268) +==22617== by 0x4848133: import (end_class.c:15) +==22617== by 0x14AC28: type_engine_init (engine.c:107) +==22617== by 0x1308A5: gwion_engine (gwion.c:39) +==22617== by 0x1308A5: gwion_ini (gwion.c:78) +==22617== by 0x12F85D: main (main.c:23) +==22617== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==22617== +==22617== +==22617== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==22617== Access not within mapped region at address 0x28 +==22617== at 0x130C08: env_err (gwion.c:110) +==22617== by 0x152A2B: gwi_class_end (import.c:268) +==22617== by 0x4848133: import (end_class.c:15) +==22617== by 0x14AC28: type_engine_init (engine.c:107) +==22617== by 0x1308A5: gwion_engine (gwion.c:39) +==22617== by 0x1308A5: gwion_ini (gwion.c:78) +==22617== by 0x12F85D: main (main.c:23) +==22617== If you believe this happened as a result of a stack +==22617== overflow in your program's main thread (unlikely but +==22617== possible), you can try to increase the size of the +==22617== main thread stack using the --main-stacksize= flag. +==22617== The main thread stack size used in this run was 8388608. +==22617== +==22617== HEAP SUMMARY: +==22617== in use at exit: 2,170,704 bytes in 374 blocks +==22617== total heap usage: 798 allocs, 424 frees, 2,264,821 bytes allocated +==22617== +==22617== LEAK SUMMARY: +==22617== definitely lost: 0 bytes in 0 blocks +==22617== indirectly lost: 0 bytes in 0 blocks +==22617== possibly lost: 0 bytes in 0 blocks +==22617== still reachable: 2,170,704 bytes in 374 blocks +==22617== suppressed: 0 bytes in 0 blocks +==22617== Rerun with --leak-check=full to see details of leaked memory +==22617== +==22617== For counts of detected and suppressed errors, rerun with: -v +==22617== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==22936== Memcheck, a memory error detector +==22936== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==22936== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==22936== Command: ./../../gwion -p. -d dummy /dev/null +==22936== Parent PID: 22217 +==22936== +==22936== Invalid read of size 4 +==22936== at 0x130C08: env_err (gwion.c:110) +==22936== by 0x1513F5: path_valid (import.c:145) +==22936== by 0x151D54: str2list (import.c:167) +==22936== by 0x152E72: str2decl (import.c:366) +==22936== by 0x15329C: make_dll_arg_list (import.c:395) +==22936== by 0x1537D0: make_dll_as_fun (import.c:440) +==22936== by 0x15391F: gwi_func_end (import.c:449) +==22936== by 0x4848225: import (invalid_arg.c:21) +==22936== by 0x14AC28: type_engine_init (engine.c:107) +==22936== by 0x1308A5: gwion_engine (gwion.c:39) +==22936== by 0x1308A5: gwion_ini (gwion.c:78) +==22936== by 0x12F85D: main (main.c:23) +==22936== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==22936== +==22936== +==22936== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==22936== Access not within mapped region at address 0x28 +==22936== at 0x130C08: env_err (gwion.c:110) +==22936== by 0x1513F5: path_valid (import.c:145) +==22936== by 0x151D54: str2list (import.c:167) +==22936== by 0x152E72: str2decl (import.c:366) +==22936== by 0x15329C: make_dll_arg_list (import.c:395) +==22936== by 0x1537D0: make_dll_as_fun (import.c:440) +==22936== by 0x15391F: gwi_func_end (import.c:449) +==22936== by 0x4848225: import (invalid_arg.c:21) +==22936== by 0x14AC28: type_engine_init (engine.c:107) +==22936== by 0x1308A5: gwion_engine (gwion.c:39) +==22936== by 0x1308A5: gwion_ini (gwion.c:78) +==22936== by 0x12F85D: main (main.c:23) +==22936== If you believe this happened as a result of a stack +==22936== overflow in your program's main thread (unlikely but +==22936== possible), you can try to increase the size of the +==22936== main thread stack using the --main-stacksize= flag. +==22936== The main thread stack size used in this run was 8388608. +==22936== +==22936== HEAP SUMMARY: +==22936== in use at exit: 2,171,862 bytes in 384 blocks +==22936== total heap usage: 810 allocs, 426 frees, 2,266,051 bytes allocated +==22936== +==22936== LEAK SUMMARY: +==22936== definitely lost: 0 bytes in 0 blocks +==22936== indirectly lost: 0 bytes in 0 blocks +==22936== possibly lost: 0 bytes in 0 blocks +==22936== still reachable: 2,171,862 bytes in 384 blocks +==22936== suppressed: 0 bytes in 0 blocks +==22936== Rerun with --leak-check=full to see details of leaked memory +==22936== +==22936== For counts of detected and suppressed errors, rerun with: -v +==22936== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==22982== Memcheck, a memory error detector +==22982== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==22982== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==22982== Command: ./../../gwion -p. -d dummy /dev/null +==22982== Parent PID: 22217 +==22982== +==22982== Invalid read of size 4 +==22982== at 0x130C08: env_err (gwion.c:110) +==22982== by 0x153373: make_dll_arg_list (import.c:406) +==22982== by 0x1537D0: make_dll_as_fun (import.c:440) +==22982== by 0x15391F: gwi_func_end (import.c:449) +==22982== by 0x48482A6: import (invalid_array.c:24) +==22982== by 0x14AC28: type_engine_init (engine.c:107) +==22982== by 0x1308A5: gwion_engine (gwion.c:39) +==22982== by 0x1308A5: gwion_ini (gwion.c:78) +==22982== by 0x12F85D: main (main.c:23) +==22982== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==22982== +==22982== +==22982== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==22982== Access not within mapped region at address 0x28 +==22982== at 0x130C08: env_err (gwion.c:110) +==22982== by 0x153373: make_dll_arg_list (import.c:406) +==22982== by 0x1537D0: make_dll_as_fun (import.c:440) +==22982== by 0x15391F: gwi_func_end (import.c:449) +==22982== by 0x48482A6: import (invalid_array.c:24) +==22982== by 0x14AC28: type_engine_init (engine.c:107) +==22982== by 0x1308A5: gwion_engine (gwion.c:39) +==22982== by 0x1308A5: gwion_ini (gwion.c:78) +==22982== by 0x12F85D: main (main.c:23) +==22982== If you believe this happened as a result of a stack +==22982== overflow in your program's main thread (unlikely but +==22982== possible), you can try to increase the size of the +==22982== main thread stack using the --main-stacksize= flag. +==22982== The main thread stack size used in this run was 8388608. +==22982== +==22982== HEAP SUMMARY: +==22982== in use at exit: 2,173,020 bytes in 385 blocks +==22982== total heap usage: 812 allocs, 427 frees, 2,267,345 bytes allocated +==22982== +==22982== LEAK SUMMARY: +==22982== definitely lost: 0 bytes in 0 blocks +==22982== indirectly lost: 0 bytes in 0 blocks +==22982== possibly lost: 0 bytes in 0 blocks +==22982== still reachable: 2,173,020 bytes in 385 blocks +==22982== suppressed: 0 bytes in 0 blocks +==22982== Rerun with --leak-check=full to see details of leaked memory +==22982== +==22982== For counts of detected and suppressed errors, rerun with: -v +==22982== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==23029== Memcheck, a memory error detector +==23029== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==23029== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==23029== Command: ./../../gwion -p. -d dummy /dev/null +==23029== Parent PID: 22217 +==23029== +==23029== Invalid read of size 4 +==23029== at 0x130C08: env_err (gwion.c:110) +==23029== by 0x1513F5: path_valid (import.c:145) +==23029== by 0x151D54: str2list (import.c:167) +==23029== by 0x153613: import_td (import.c:418) +==23029== by 0x1537A4: make_dll_as_fun (import.c:436) +==23029== by 0x15391F: gwi_func_end (import.c:449) +==23029== by 0x48481EC: import (invalid_func.c:20) +==23029== by 0x14AC28: type_engine_init (engine.c:107) +==23029== by 0x1308A5: gwion_engine (gwion.c:39) +==23029== by 0x1308A5: gwion_ini (gwion.c:78) +==23029== by 0x12F85D: main (main.c:23) +==23029== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==23029== +==23029== +==23029== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==23029== Access not within mapped region at address 0x28 +==23029== at 0x130C08: env_err (gwion.c:110) +==23029== by 0x1513F5: path_valid (import.c:145) +==23029== by 0x151D54: str2list (import.c:167) +==23029== by 0x153613: import_td (import.c:418) +==23029== by 0x1537A4: make_dll_as_fun (import.c:436) +==23029== by 0x15391F: gwi_func_end (import.c:449) +==23029== by 0x48481EC: import (invalid_func.c:20) +==23029== by 0x14AC28: type_engine_init (engine.c:107) +==23029== by 0x1308A5: gwion_engine (gwion.c:39) +==23029== by 0x1308A5: gwion_ini (gwion.c:78) +==23029== by 0x12F85D: main (main.c:23) +==23029== If you believe this happened as a result of a stack +==23029== overflow in your program's main thread (unlikely but +==23029== possible), you can try to increase the size of the +==23029== main thread stack using the --main-stacksize= flag. +==23029== The main thread stack size used in this run was 8388608. +==23029== +==23029== HEAP SUMMARY: +==23029== in use at exit: 2,171,353 bytes in 383 blocks +==23029== total heap usage: 809 allocs, 426 frees, 2,265,546 bytes allocated +==23029== +==23029== LEAK SUMMARY: +==23029== definitely lost: 0 bytes in 0 blocks +==23029== indirectly lost: 0 bytes in 0 blocks +==23029== possibly lost: 0 bytes in 0 blocks +==23029== still reachable: 2,171,353 bytes in 383 blocks +==23029== suppressed: 0 bytes in 0 blocks +==23029== Rerun with --leak-check=full to see details of leaked memory +==23029== +==23029== For counts of detected and suppressed errors, rerun with: -v +==23029== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==23077== Memcheck, a memory error detector +==23077== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==23077== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==23077== Command: ./../../gwion -p. -d dummy /dev/null +==23077== Parent PID: 22217 +==23077== +==23077== Invalid read of size 4 +==23077== at 0x130C08: env_err (gwion.c:110) +==23077== by 0x15127B: path_valid (import.c:135) +==23077== by 0x151D54: str2list (import.c:167) +==23077== by 0x152ABC: gwi_item_ini (import.c:302) +==23077== by 0x48481B5: import (invalid_type1.c:18) +==23077== by 0x14AC28: type_engine_init (engine.c:107) +==23077== by 0x1308A5: gwion_engine (gwion.c:39) +==23077== by 0x1308A5: gwion_ini (gwion.c:78) +==23077== by 0x12F85D: main (main.c:23) +==23077== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==23077== +==23077== +==23077== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==23077== Access not within mapped region at address 0x28 +==23077== at 0x130C08: env_err (gwion.c:110) +==23077== by 0x15127B: path_valid (import.c:135) +==23077== by 0x151D54: str2list (import.c:167) +==23077== by 0x152ABC: gwi_item_ini (import.c:302) +==23077== by 0x48481B5: import (invalid_type1.c:18) +==23077== by 0x14AC28: type_engine_init (engine.c:107) +==23077== by 0x1308A5: gwion_engine (gwion.c:39) +==23077== by 0x1308A5: gwion_ini (gwion.c:78) +==23077== by 0x12F85D: main (main.c:23) +==23077== If you believe this happened as a result of a stack +==23077== overflow in your program's main thread (unlikely but +==23077== possible), you can try to increase the size of the +==23077== main thread stack using the --main-stacksize= flag. +==23077== The main thread stack size used in this run was 8388608. +==23077== +==23077== HEAP SUMMARY: +==23077== in use at exit: 2,171,356 bytes in 383 blocks +==23077== total heap usage: 809 allocs, 426 frees, 2,265,553 bytes allocated +==23077== +==23077== LEAK SUMMARY: +==23077== definitely lost: 0 bytes in 0 blocks +==23077== indirectly lost: 0 bytes in 0 blocks +==23077== possibly lost: 0 bytes in 0 blocks +==23077== still reachable: 2,171,356 bytes in 383 blocks +==23077== suppressed: 0 bytes in 0 blocks +==23077== Rerun with --leak-check=full to see details of leaked memory +==23077== +==23077== For counts of detected and suppressed errors, rerun with: -v +==23077== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==23124== Memcheck, a memory error detector +==23124== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==23124== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==23124== Command: ./../../gwion -p. -d dummy /dev/null +==23124== Parent PID: 22217 +==23124== +==23124== Invalid read of size 4 +==23124== at 0x130C08: env_err (gwion.c:110) +==23124== by 0x1513F5: path_valid (import.c:145) +==23124== by 0x151D54: str2list (import.c:167) +==23124== by 0x152ABC: gwi_item_ini (import.c:302) +==23124== by 0x48481B5: import (invalid_type2.c:18) +==23124== by 0x14AC28: type_engine_init (engine.c:107) +==23124== by 0x1308A5: gwion_engine (gwion.c:39) +==23124== by 0x1308A5: gwion_ini (gwion.c:78) +==23124== by 0x12F85D: main (main.c:23) +==23124== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==23124== +==23124== +==23124== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==23124== Access not within mapped region at address 0x28 +==23124== at 0x130C08: env_err (gwion.c:110) +==23124== by 0x1513F5: path_valid (import.c:145) +==23124== by 0x151D54: str2list (import.c:167) +==23124== by 0x152ABC: gwi_item_ini (import.c:302) +==23124== by 0x48481B5: import (invalid_type2.c:18) +==23124== by 0x14AC28: type_engine_init (engine.c:107) +==23124== by 0x1308A5: gwion_engine (gwion.c:39) +==23124== by 0x1308A5: gwion_ini (gwion.c:78) +==23124== by 0x12F85D: main (main.c:23) +==23124== If you believe this happened as a result of a stack +==23124== overflow in your program's main thread (unlikely but +==23124== possible), you can try to increase the size of the +==23124== main thread stack using the --main-stacksize= flag. +==23124== The main thread stack size used in this run was 8388608. +==23124== +==23124== HEAP SUMMARY: +==23124== in use at exit: 2,171,356 bytes in 383 blocks +==23124== total heap usage: 809 allocs, 426 frees, 2,265,553 bytes allocated +==23124== +==23124== LEAK SUMMARY: +==23124== definitely lost: 0 bytes in 0 blocks +==23124== indirectly lost: 0 bytes in 0 blocks +==23124== possibly lost: 0 bytes in 0 blocks +==23124== still reachable: 2,171,356 bytes in 383 blocks +==23124== suppressed: 0 bytes in 0 blocks +==23124== Rerun with --leak-check=full to see details of leaked memory +==23124== +==23124== For counts of detected and suppressed errors, rerun with: -v +==23124== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==23171== Memcheck, a memory error detector +==23171== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==23171== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==23171== Command: ./../../gwion -p. -d dummy /dev/null +==23171== Parent PID: 22217 +==23171== +==23171== Invalid read of size 4 +==23171== at 0x130C08: env_err (gwion.c:110) +==23171== by 0x1510E0: name_valid (import.c:116) +==23171== by 0x152365: gwi_add_type (import.c:195) +==23171== by 0x15242B: gwi_class_ini (import.c:229) +==23171== by 0x484818F: import (invalid_type3.c:18) +==23171== by 0x14AC28: type_engine_init (engine.c:107) +==23171== by 0x1308A5: gwion_engine (gwion.c:39) +==23171== by 0x1308A5: gwion_ini (gwion.c:78) +==23171== by 0x12F85D: main (main.c:23) +==23171== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==23171== +==23171== +==23171== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==23171== Access not within mapped region at address 0x28 +==23171== at 0x130C08: env_err (gwion.c:110) +==23171== by 0x1510E0: name_valid (import.c:116) +==23171== by 0x152365: gwi_add_type (import.c:195) +==23171== by 0x15242B: gwi_class_ini (import.c:229) +==23171== by 0x484818F: import (invalid_type3.c:18) +==23171== by 0x14AC28: type_engine_init (engine.c:107) +==23171== by 0x1308A5: gwion_engine (gwion.c:39) +==23171== by 0x1308A5: gwion_ini (gwion.c:78) +==23171== by 0x12F85D: main (main.c:23) +==23171== If you believe this happened as a result of a stack +==23171== overflow in your program's main thread (unlikely but +==23171== possible), you can try to increase the size of the +==23171== main thread stack using the --main-stacksize= flag. +==23171== The main thread stack size used in this run was 8388608. +==23171== +==23171== HEAP SUMMARY: +==23171== in use at exit: 2,170,716 bytes in 374 blocks +==23171== total heap usage: 798 allocs, 424 frees, 2,264,849 bytes allocated +==23171== +==23171== LEAK SUMMARY: +==23171== definitely lost: 0 bytes in 0 blocks +==23171== indirectly lost: 0 bytes in 0 blocks +==23171== possibly lost: 0 bytes in 0 blocks +==23171== still reachable: 2,170,716 bytes in 374 blocks +==23171== suppressed: 0 bytes in 0 blocks +==23171== Rerun with --leak-check=full to see details of leaked memory +==23171== +==23171== For counts of detected and suppressed errors, rerun with: -v +==23171== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) +/dev/null ==23354== Memcheck, a memory error detector +==23354== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. +==23354== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info +==23354== Command: ./../../gwion -p. -d dummy /dev/null +==23354== Parent PID: 22217 +==23354== +==23354== Invalid read of size 4 +==23354== at 0x130C08: env_err (gwion.c:110) +==23354== by 0x1530F4: make_dll_arg_list (import.c:398) +==23354== by 0x1537D0: make_dll_as_fun (import.c:440) +==23354== by 0x15391F: gwi_func_end (import.c:449) +==23354== by 0x4848225: import (template_arg.c:21) +==23354== by 0x14AC28: type_engine_init (engine.c:107) +==23354== by 0x1308A5: gwion_engine (gwion.c:39) +==23354== by 0x1308A5: gwion_ini (gwion.c:78) +==23354== by 0x12F85D: main (main.c:23) +==23354== Address 0x28 is not stack'd, malloc'd or (recently) free'd +==23354== +==23354== +==23354== Process terminating with default action of signal 11 (SIGSEGV): dumping core +==23354== Access not within mapped region at address 0x28 +==23354== at 0x130C08: env_err (gwion.c:110) +==23354== by 0x1530F4: make_dll_arg_list (import.c:398) +==23354== by 0x1537D0: make_dll_as_fun (import.c:440) +==23354== by 0x15391F: gwi_func_end (import.c:449) +==23354== by 0x4848225: import (template_arg.c:21) +==23354== by 0x14AC28: type_engine_init (engine.c:107) +==23354== by 0x1308A5: gwion_engine (gwion.c:39) +==23354== by 0x1308A5: gwion_ini (gwion.c:78) +==23354== by 0x12F85D: main (main.c:23) +==23354== If you believe this happened as a result of a stack +==23354== overflow in your program's main thread (unlikely but +==23354== possible), you can try to increase the size of the +==23354== main thread stack using the --main-stacksize= flag. +==23354== The main thread stack size used in this run was 8388608. +==23354== +==23354== HEAP SUMMARY: +==23354== in use at exit: 2,177,657 bytes in 395 blocks +==23354== total heap usage: 829 allocs, 434 frees, 2,272,394 bytes allocated +==23354== +==23354== LEAK SUMMARY: +==23354== definitely lost: 0 bytes in 0 blocks +==23354== indirectly lost: 0 bytes in 0 blocks +==23354== possibly lost: 0 bytes in 0 blocks +==23354== still reachable: 2,177,657 bytes in 395 blocks +==23354== suppressed: 0 bytes in 0 blocks +==23354== Rerun with --leak-check=full to see details of leaked memory +==23354== +==23354== For counts of detected and suppressed errors, rerun with: -v +==23354== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) diff --git a/tests/new/pure.gw b/tests/new/pure.gw index cd6b8efd..ff4379ac 100644 --- a/tests/new/pure.gw +++ b/tests/new/pure.gw @@ -1,3 +1,7 @@ -fun int pure(int i) { return i; } -2 => pure; -2 => pure; +fun A pure<~A~>(A i) { return i; } +<<< 2 => pure >>>; +<<< 2 => pure >>>; +<<< 3 => pure >>>; +<<< 4 => pure >>>; +<<< 2.2 => pure >>>; +<<< @(2.3) => pure >>>; diff --git a/tests/new/pure2.gw b/tests/new/pure2.gw new file mode 100644 index 00000000..be5a1f04 --- /dev/null +++ b/tests/new/pure2.gw @@ -0,0 +1,3 @@ +fun void test(int i) { i; } +2 => test; + diff --git a/tests/new/pure_member.gw b/tests/new/pure_member.gw new file mode 100644 index 00000000..2fe91f9f --- /dev/null +++ b/tests/new/pure_member.gw @@ -0,0 +1,10 @@ +class C { +fun A pure<~A~>(A i) { return i; } +<<< 2 => pure >>>; +<<< 2 => pure >>>; +<<< 3 => pure >>>; +<<< 4 => pure >>>; +<<< 2.2 => pure >>>; +<<< @(2.3) => pure >>>; +} +C c; diff --git a/tests/sh/common.sh b/tests/sh/common.sh index 74cef102..68b45243 100644 --- a/tests/sh/common.sh +++ b/tests/sh/common.sh @@ -2,15 +2,14 @@ # [test] #0 set -m -: "${OPT:=}" -: "${UDP:=}" +: "${GWOPT:=}" : "${DRIVER:=dummy}" run() { local good n ok good="All heap blocks were freed -- no leaks are possible" n=$(printf "% 4i" "$1") - eval valgrind ./gwion "$OPT" "$UDP" -d "$DRIVER" "$3" &> "$4" + eval valgrind ./gwion "$GWOPT" -d "$DRIVER" "$3" &> "$4" if [ -f "$4" ] then grep "$good" "$4" > /dev/null && ok=1 else ok=1 diff --git a/tests/sh/opt.sh b/tests/sh/opt.sh index 0bffa993..4bcda1d4 100644 --- a/tests/sh/opt.sh +++ b/tests/sh/opt.sh @@ -45,7 +45,7 @@ run "$n" "samplerate (short)" "-s 44100" "file" # wrong file n=$((n+1)) -run "$n" "wrong file" "non_existant_file" "file" +run "$n" "wrong file" "non_existant_file:with_args" "file" # plug_dir n=$((n+1)) @@ -53,19 +53,20 @@ run "$n" "plugin directory" "-p non_existant_dir" "file" # config n=$((n+1)) -cat << EOF >> tmp_gwionrc +RC=tmp_gwionrc +cat << EOF >> "$RC" -p. -l0 EOF -run "$n" "config" "-c tmp_gwionrc" "file" - +run "$n" "config" "-c $RC" "file" +rm "$RC" # loop n=$((n+1)) run "$n" "loop" "-l0" "file" # memoization n=$((n+1)) -run "$n" "memoize" "-z2 tests/new/pure/.gw" "file" +run "$n" "memoize" "-z2 tests/new/pure.gw" "file" # (fake) module arg n=$((n+1)) diff --git a/tests/sh/plugin.sh b/tests/sh/plugin.sh index 8d46d6e3..02c9156c 100644 --- a/tests/sh/plugin.sh +++ b/tests/sh/plugin.sh @@ -1,12 +1,11 @@ #!/bin/bash -# [test] #28 +# [test] #29 n=0 [ "$1" ] && n="$1" [ "$n" -eq 0 ] && n=1 source tests/sh/common.sh source tests/sh/test.sh -#source help/test.sh : "${GWION_ADD_DIR=/usr/lib/Gwion/add}" @@ -15,6 +14,7 @@ export GWION_ADD_DIR test_plugin() { export NAME=$"$1" export PRG=$"../../gwion" + export SUPP=$"../../help/supp" make if [ -f "$NAME.gw" ] then GWOPT=-p. test_gw "$NAME.gw" "$n" diff --git a/tests/sh/test.sh b/tests/sh/test.sh index 7e1fa70b..93ded7d5 100644 --- a/tests/sh/test.sh +++ b/tests/sh/test.sh @@ -14,6 +14,7 @@ : "${ANSI_BOLD:=\033[33;1m}" : "${DRIVER:=dummy}" +: "${SUPP:=help/supp}" : "${ASYNC:=4}" : "${async:=$ASYNC}" @@ -184,7 +185,7 @@ test_gw(){ if [ "$VALGRIND" == "NO_VALGRIND" ] then LANG=C ./"$PRG" "$GWOPT" -d "$DRIVER" "$file" > "$slog" 2>"$elog" |: else - LANG=C "$VALGRIND" --suppressions=help/supp --log-file="$vlog" \ + LANG=C "$VALGRIND" --suppressions="$SUPP" --log-file="$vlog" \ ./"$PRG" "$GWOPT" -d "$DRIVER" "$file" > "$slog" 2>"$elog" |: fi ret=$?