Gwion coverage report

GCC Code Coverage Report

Directory:	src/		Exec	Total	Coverage
File:	src/env/type.c	Lines:	134	142	94.4 %
Date:	2020-10-03 11:54:50	Branches:	85	108	78.7 %


#include "gwion_util.h"
#include "gwion_ast.h"
#include "gwion_env.h"
#include "vm.h"
#include "traverse.h"
#include "parse.h"
#include "gwion.h"
#include "clean.h"
#include "object.h"

ANN static inline m_bool freeable(const Type a) {
  return !GET_FLAG(a, nonnull) && GET_FLAG(a, template);
}

ANN static void free_type(Type a, Gwion gwion) {
  if(freeable(a)) {
    if(GET_FLAG(a, union)) {
      if(a->e->def->union_def) {
        if(!GET_FLAG(a, pure))
          free_union_def(gwion->mp, a->e->def->union_def);
        else
          free_decl_list(gwion->mp, a->e->def->list);
      }
      a->e->def->union_def = NULL;
    }
    if(a->e->def)
      class_def_cleaner(gwion, a->e->def);
  }
  if(a->nspc)
    REM_REF(a->nspc, gwion);
  if(a->e->tuple)
    free_tupleform(a->e->tuple, gwion);
  mp_free(gwion->mp, TypeInfo, a->e);
  mp_free(gwion->mp, Type, a);
}

Type new_type(MemPool p, const m_uint xid, const m_str name, const Type parent) {
  const Type type = mp_calloc(p, Type);
  type->xid    = xid;
  type->name   = name;
  type->e = mp_calloc(p, TypeInfo);
  type->e->parent = parent;
  if(parent)
    type->size = parent->size;
  type->ref = new_refcount(p, free_type);
  return type;
}

ANN Type type_copy(MemPool p, const Type type) {
  const Type a = new_type(p, type->xid, type->name, type->e->parent);
  a->nspc           = type->nspc;
  a->e->owner       = type->e->owner;
  a->e->owner_class = type->e->owner_class;
  a->size           = type->size;
  a->e->d.base_type = type->e->d.base_type;
  a->array_depth    = type->array_depth;
  a->e->gack        = type->e->gack;
  return a;
}

ANN m_bool isa(const restrict Type var, const restrict Type parent) {
  return (var->xid == parent->xid) ? 1 : var->e->parent ? isa(var->e->parent, parent) : -1;
}

ANN Type find_common_anc(const restrict Type lhs, const restrict Type rhs) {
  return isa(lhs, rhs) > 0 ? rhs : isa(rhs, lhs) > 0 ? lhs : NULL;
}

#define describe_find(name, t)                                       \
ANN t find_##name(const Type type, const Symbol xid) {               \
  if(type->nspc) {                                                   \
  const t val = nspc_lookup_##name##2(type->nspc, xid);              \
  if(val)                                                            \
    return val;                                                      \
  }                                                                  \
  return type->e->parent ? find_##name(type->e->parent, xid) : NULL; \
}
describe_find(value, Value)
//describe_find(func,  Func)

ANN Type typedef_base(Type t) {
  while(GET_FLAG(t, typedef))
    t = t->e->parent;
  return t;
}

ANN Type array_base(Type type) {
  const Type t = typedef_base(type);
  return t->array_depth ? t->e->d.base_type : t;
}

ANN static Symbol array_sym(const Env env, const Type src, const m_uint depth) {
  size_t len = strlen(src->name);
  char name[len + 2* depth + 1];
  strcpy(name, src->name);
  m_uint i = depth + 1;
  while(--i) {
    strcpy(name+len, "[]");
    len += 2;
  }
  return insert_symbol(name);
}

ANN Type array_type(const Env env, const Type src, const m_uint depth) {
  const Symbol sym = array_sym(env, src, depth);
  const Type type = nspc_lookup_type1(src->e->owner, sym);
  if(type)
    return type;
  const Type t = new_type(env->gwion->mp, env->gwion->type[et_array]->xid,
      s_name(sym), env->gwion->type[et_array]);
  t->array_depth = depth + src->array_depth;
  t->e->d.base_type = array_base(src) ?: src;
  t->e->owner = src->e->owner;
  if(depth > 1 || isa(src, env->gwion->type[et_compound]) > 0) {
    t->nspc = new_nspc(env->gwion->mp, s_name(sym));
    inherit(t);
    t->nspc->info->class_data_size = SZ_INT;
    nspc_allocdata(env->gwion->mp, t->nspc);
    *(f_release**)(t->nspc->info->class_data) = (depth > 1 || !GET_FLAG(src, struct)) ?
      object_release : struct_release;
  } else
  ADD_REF((t->nspc = env->gwion->type[et_array]->nspc))
  SET_FLAG(t, valid);
  mk_class(env, t);
  nspc_add_type_front(src->e->owner, sym, t);
  return t;
}

ANN m_bool type_ref(Type t) {
  do {
    if(GET_FLAG(t, empty))
      return GW_OK;
    if(GET_FLAG(t, typedef) && t->e->def)
      if(t->e->def->base.ext && t->e->def->base.ext->array) {
        if(!t->e->def->base.ext->array->exp)
          return GW_OK;
        else {
          const Type type = t->e->parent->e->d.base_type;
          if(SAFE_FLAG(type, empty))
            return GW_OK;
        }
      }
  } while((t = t->e->parent));
  return 0;
}


ANN m_str get_type_name(const Env env, const Type t, const m_uint index) {
  if(!index)
    return NULL;
  m_str name = strchr(t->name, ':');
  if(!name)
    return NULL;
  name += 2;
  const size_t slen = strlen(name);
  m_uint lvl = 0;
  m_uint n = 1;
  char c, buf[slen + 1], *tmp = buf;
  while((c = *name)) {
    if(c == ':')
      ++lvl;
    else if(c == ']') {
      if(!lvl-- && n == index)
        break;
    } else if(c == ',') {
      if(!lvl && n++ == index)
        break;
      if(!lvl)
        ++name;
    }
    if(n == index)
      *tmp++ = *name;
    ++name;
  }
  *tmp = '\0';
  return tmp - buf ? s_name(insert_symbol(buf)) : NULL;
}

ANN m_uint get_depth(const Type type) {
  m_uint depth = 0;
  Type t = type;
  do {
    if(t->array_depth) {
      depth += t->array_depth;
      t = t->e->d.base_type;
    } else
      t = t->e->parent;
  } while(t);
  return depth;
}

ANN m_bool is_fptr(const struct Gwion_* gwion, const Type t) {
  return isa(actual_type(gwion, t), gwion->type[et_fptr]) > 0;
}
ANN inline m_bool is_class(const struct Gwion_* gwion, const Type t) {
  return isa(t, gwion->type[et_class]) > 0;
}

ANN Type actual_type(const struct Gwion_* gwion, const Type t) {
  return is_class(gwion, t) ? t->e->d.base_type : t;
}

ANN void inherit(const Type t) {
  const Nspc nspc = t->nspc, parent = t->e->parent->nspc;
  if(!nspc || !parent)
    return;
  nspc->info->offset = parent->info->offset;
  if(parent->info->vtable.ptr)
    vector_copy2(&parent->info->vtable, &nspc->info->vtable);
}


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			#include "gwion_util.h"
2			#include "gwion_ast.h"
3			#include "gwion_env.h"
4			#include "vm.h"
5			#include "traverse.h"
6			#include "parse.h"
7			#include "gwion.h"
8			#include "clean.h"
9			#include "object.h"
10
11		36776	ANN static inline m_bool freeable(const Type a) {
12	✓✓✓✓	36776	return !GET_FLAG(a, nonnull) && GET_FLAG(a, template);
13			}
14
15		36776	ANN static void free_type(Type a, Gwion gwion) {
16	✓✓	36776	if(freeable(a)) {
17	✓✓	1522	if(GET_FLAG(a, union)) {
18	✓✗	8	if(a->e->def->union_def) {
19	✓✓	8	if(!GET_FLAG(a, pure))
20		3	free_union_def(gwion->mp, a->e->def->union_def);
21			else
22		5	free_decl_list(gwion->mp, a->e->def->list);
23			}
24		8	a->e->def->union_def = NULL;
25			}
26	✓✓	1522	if(a->e->def)
27		1496	class_def_cleaner(gwion, a->e->def);
28			}
29	✓✓	36776	if(a->nspc)
30		17638	REM_REF(a->nspc, gwion);
31	✓✓	36776	if(a->e->tuple)
32		13162	free_tupleform(a->e->tuple, gwion);
33		36776	mp_free(gwion->mp, TypeInfo, a->e);
34		36776	mp_free(gwion->mp, Type, a);
35		36776	}
36
37		106477	Type new_type(MemPool p, const m_uint xid, const m_str name, const Type parent) {
38		106477	const Type type = mp_calloc(p, Type);
39		106477	type->xid = xid;
40		106477	type->name = name;
41		106477	type->e = mp_calloc(p, TypeInfo);
42		106477	type->e->parent = parent;
43	✓✓	106477	if(parent)
44		21988	type->size = parent->size;
45		106477	type->ref = new_refcount(p, free_type);
46		106477	return type;
47			}
48
49		80299	ANN Type type_copy(MemPool p, const Type type) {
50		80299	const Type a = new_type(p, type->xid, type->name, type->e->parent);
51		80299	a->nspc = type->nspc;
52		80299	a->e->owner = type->e->owner;
53		80299	a->e->owner_class = type->e->owner_class;
54		80299	a->size = type->size;
55		80299	a->e->d.base_type = type->e->d.base_type;
56		80299	a->array_depth = type->array_depth;
57		80299	a->e->gack = type->e->gack;
58		80299	return a;
59			}
60
61		915542	ANN m_bool isa(const restrict Type var, const restrict Type parent) {
62	✓✓✓✓	915542	return (var->xid == parent->xid) ? 1 : var->e->parent ? isa(var->e->parent, parent) : -1;
63			}
64
65		75	ANN Type find_common_anc(const restrict Type lhs, const restrict Type rhs) {
66	✓✓✗✓	75	return isa(lhs, rhs) > 0 ? rhs : isa(rhs, lhs) > 0 ? lhs : NULL;
67			}
68
69			#define describe_find(name, t) \
70			ANN t find_##name(const Type type, const Symbol xid) { \
71			if(type->nspc) { \
72			const t val = nspc_lookup_##name##2(type->nspc, xid); \
73			if(val) \
74			return val; \
75			} \
76			return type->e->parent ? find_##name(type->e->parent, xid) : NULL; \
77			}
78	✓✓✓✓ ✓✓	208893	describe_find(value, Value)
79			//describe_find(func, Func)
80
81		2866	ANN Type typedef_base(Type t) {
82	✓✓	5733	while(GET_FLAG(t, typedef))
83		1	t = t->e->parent;
84		2866	return t;
85			}
86
87		2816	ANN Type array_base(Type type) {
88		2816	const Type t = typedef_base(type);
89	✓✓	2816	return t->array_depth ? t->e->d.base_type : t;
90			}
91
92		171	ANN static Symbol array_sym(const Env env, const Type src, const m_uint depth) {
93		171	size_t len = strlen(src->name);
94		171	char name[len + 2* depth + 1];
95		171	strcpy(name, src->name);
96		171	m_uint i = depth + 1;
97	✓✓	538	while(--i) {
98		196	strcpy(name+len, "[]");
99		196	len += 2;
100			}
101		171	return insert_symbol(name);
102			}
103
104		171	ANN Type array_type(const Env env, const Type src, const m_uint depth) {
105		171	const Symbol sym = array_sym(env, src, depth);
106		171	const Type type = nspc_lookup_type1(src->e->owner, sym);
107	✓✓	171	if(type)
108		75	return type;
109		96	const Type t = new_type(env->gwion->mp, env->gwion->type[et_array]->xid,
110		96	s_name(sym), env->gwion->type[et_array]);
111		96	t->array_depth = depth + src->array_depth;
112	✓✗	96	t->e->d.base_type = array_base(src) ?: src;
113		96	t->e->owner = src->e->owner;
114	✓✓✓✓	96	if(depth > 1 \|\| isa(src, env->gwion->type[et_compound]) > 0) {
115		38	t->nspc = new_nspc(env->gwion->mp, s_name(sym));
116		38	inherit(t);
117		38	t->nspc->info->class_data_size = SZ_INT;
118		38	nspc_allocdata(env->gwion->mp, t->nspc);
119	✓✓✓✗	38	(f_release*)(t->nspc->info->class_data) = (depth > 1 \|\| !GET_FLAG(src, struct)) ?
120			object_release : struct_release;
121			} else
122		58	ADD_REF((t->nspc = env->gwion->type[et_array]->nspc))
123		96	SET_FLAG(t, valid);
124		96	mk_class(env, t);
125		96	nspc_add_type_front(src->e->owner, sym, t);
126		96	return t;
127			}
128
129		1505	ANN m_bool type_ref(Type t) {
130			do {
131	✓✓	1505	if(GET_FLAG(t, empty))
132		2	return GW_OK;
133	✓✓✓✓	1503	if(GET_FLAG(t, typedef) && t->e->def)
134	✓✗✓✓	11	if(t->e->def->base.ext && t->e->def->base.ext->array) {
135	✗✓	9	if(!t->e->def->base.ext->array->exp)
136			return GW_OK;
137			else {
138		9	const Type type = t->e->parent->e->d.base_type;
139	✓✗✗✓	9	if(SAFE_FLAG(type, empty))
140			return GW_OK;
141			}
142			}
143	✓✓	1503	} while((t = t->e->parent));
144		674	return 0;
145			}
146
147
148		34	ANN m_str get_type_name(const Env env, const Type t, const m_uint index) {
149	✗✓	34	if(!index)
150			return NULL;
151		34	m_str name = strchr(t->name, ':');
152	✓✓	34	if(!name)
153		15	return NULL;
154		19	name += 2;
155		19	const size_t slen = strlen(name);
156		19	m_uint lvl = 0;
157		19	m_uint n = 1;
158		19	char c, buf[slen + 1], *tmp = buf;
159	✓✗	91	while((c = *name)) {
160	✗✓	72	if(c == ':')
161			++lvl;
162	✓✓	72	else if(c == ']') {
163	✓✗✓✗	19	if(!lvl-- && n == index)
164		19	break;
165	✗✓	53	} else if(c == ',') {
166			if(!lvl && n++ == index)
167			break;
168			if(!lvl)
169			++name;
170			}
171	✓✗	53	if(n == index)
172		53	tmp++ = name;
173		53	++name;
174			}
175		19	*tmp = '\0';
176	✓✗	19	return tmp - buf ? s_name(insert_symbol(buf)) : NULL;
177			}
178
179		10	ANN m_uint get_depth(const Type type) {
180		10	m_uint depth = 0;
181		10	Type t = type;
182			do {
183	✓✓	20	if(t->array_depth) {
184		6	depth += t->array_depth;
185		6	t = t->e->d.base_type;
186			} else
187		14	t = t->e->parent;
188	✓✓	20	} while(t);
189		10	return depth;
190			}
191
192		31819	ANN m_bool is_fptr(const struct Gwion_* gwion, const Type t) {
193		31819	return isa(actual_type(gwion, t), gwion->type[et_fptr]) > 0;
194			}
195		140916	ANN inline m_bool is_class(const struct Gwion_* gwion, const Type t) {
196		140916	return isa(t, gwion->type[et_class]) > 0;
197			}
198
199		41885	ANN Type actual_type(const struct Gwion_* gwion, const Type t) {
200	✓✓	41885	return is_class(gwion, t) ? t->e->d.base_type : t;
201			}
202
203		13128	ANN void inherit(const Type t) {
204		13128	const Nspc nspc = t->nspc, parent = t->e->parent->nspc;
205	✓✗✓✓	13128	if(!nspc \|\| !parent)
206		5892	return;
207		7236	nspc->info->offset = parent->info->offset;
208	✓✓	7236	if(parent->info->vtable.ptr)
209		6492	vector_copy2(&parent->info->vtable, &nspc->info->vtable);
210			}