6410578713

Committed 04 Oct 2023 07:25PM UTC coverage: 91.225% (-0.01%) from 91.235%

Build # 6410578713

Build Type

push

github

Committed by

nickg

Commit Message

Implement LCS2016-032 changes to instance/path name

Run Details

94 of 94 new or added lines in 3 files covered. (100.0%)

48796 of 53490 relevant lines covered (91.22%)

629861.45 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

97.84

/src/vlog/vlog-node.c

//
//  Copyright (C) 2022  Nick Gasson
//
//  This program is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
//

#include "util.h"
#include "vlog/vlog-node.h"
#include "vlog/vlog-number.h"
#include "common.h"
#include "object.h"

#include <string.h>
#include <inttypes.h>
#include <stdlib.h>

static const imask_t has_map[V_LAST_NODE_KIND] = {
   // V_MODULE
   (I_IDENT | I_PORTS | I_STMTS | I_DECLS | I_IDENT2),

   // V_PORT_DECL
   (I_IDENT | I_SUBKIND | I_IDENT2 | I_RANGES),

   // V_REF
   (I_IDENT | I_REF),

   // V_ALWAYS
   (I_IDENT | I_STMTS),

   // V_TIMING
   (I_VALUE | I_STMTS),

   // V_NBASSIGN
   (I_TARGET | I_VALUE),

   // V_EVENT
   (I_SUBKIND | I_VALUE),

   // V_INITIAL
   (I_IDENT | I_STMTS),

   // V_SEQ_BLOCK
   (I_IDENT | I_STMTS),

   // V_SYSTASK
   (I_IDENT | I_SUBKIND | I_PARAMS),

   // V_STRING
   (I_TEXT),

   // V_NUMBER
   (I_NUMBER),

   // V_NET_DECL
   (I_IDENT | I_SUBKIND | I_RANGES | I_DATATYPE),

   // V_ASSIGN
   (I_TARGET | I_VALUE),

   // V_ROOT
   (I_IDENT | I_STMTS | I_DECLS),

   // V_DIMENSION
   (I_SUBKIND | I_LEFT | I_RIGHT),

   // V_IF
   (I_CONDS),

   // V_COND
   (I_VALUE | I_STMTS),

   // V_VAR_DECL
   (I_IDENT | I_RANGES),

   // V_DELAY_CONTROL
   (I_VALUE),

   // V_BINARY
   (I_LEFT | I_RIGHT | I_SUBKIND),
};

static const char *kind_text_map[V_LAST_NODE_KIND] = {
   "V_MODULE",    "V_PORT_DECL",   "V_REF",      "V_ALWAYS",
   "V_TIMING",    "V_NBASSIGN",    "V_EVENT",    "V_INITIAL",
   "V_SEQ_BLOCK", "V_SYSTASK",     "V_STRING",   "V_NUMBER",
   "V_NET_DECL",  "V_ASSIGN",      "V_ROOT",     "V_DIMENSION",
   "V_IF",        "V_COND",        "V_VAR_DECL", "V_DELAY_CONTROL",
   "V_BINARY",
};

static const change_allowed_t change_allowed[] = {
   { -1, -1 }
};

object_class_t vlog_object = {
   .name           = "vlog",
   .change_allowed = change_allowed,
   .has_map        = has_map,
   .kind_text_map  = kind_text_map,
   .tag            = OBJECT_TAG_VLOG,
   .last_kind      = V_LAST_NODE_KIND,
   .has_loc        = true,
   .gc_roots       = { V_MODULE },
   .gc_num_roots   = 1
};

struct _vlog_node {
   object_t object;
};

static inline vlog_node_t vlog_array_nth(item_t *item, unsigned n)
{
   object_t *o = obj_array_nth(item->obj_array, n);
   return container_of(o, struct _vlog_node, object);
}

static inline void vlog_array_add(item_t *item, vlog_node_t v)
{
   obj_array_add(&(item->obj_array), &(v->object));
}

vlog_node_t vlog_new(vlog_kind_t kind)
{
   object_t *o = object_new(NULL, &vlog_object, kind);
   return container_of(o, struct _vlog_node, object);
}

vlog_kind_t vlog_kind(vlog_node_t v)
{
   return v->object.kind;
}

const char *vlog_kind_str(vlog_kind_t kind)
{
   return kind_text_map[kind];
}

ident_t vlog_ident(vlog_node_t v)
{
   item_t *item = lookup_item(&vlog_object, v, I_IDENT);
   assert(item->ident != NULL);
   return item->ident;
}

void vlog_set_ident(vlog_node_t v, ident_t i)
{
   lookup_item(&vlog_object, v, I_IDENT)->ident = i;
}

ident_t vlog_ident2(vlog_node_t v)
{
   item_t *item = lookup_item(&vlog_object, v, I_IDENT2);
   assert(item->ident != NULL);
   return item->ident;
}

void vlog_set_ident2(vlog_node_t v, ident_t i)
{
   lookup_item(&vlog_object, v, I_IDENT2)->ident = i;
}

const loc_t *vlog_loc(vlog_node_t v)
{
   assert(v != NULL);
   return &(v->object.loc);
}

void vlog_set_loc(vlog_node_t v, const loc_t *loc)
{
   assert(v != NULL);
   assert(loc != NULL);
   v->object.loc = *loc;
}

vlog_node_t vlog_ref(vlog_node_t v)
{
   item_t *item = lookup_item(&vlog_object, v, I_REF);
   assert(item->object != NULL);
   return container_of(item->object, struct _vlog_node, object);
}

bool vlog_has_ref(vlog_node_t v)
{
   return lookup_item(&vlog_object, v, I_REF)->object != NULL;
}

void vlog_set_ref(vlog_node_t v, vlog_node_t d)
{
   lookup_item(&vlog_object, v, I_REF)->object = &(d->object);
   object_write_barrier(&(v->object), &(d->object));
}

unsigned vlog_stmts(vlog_node_t v)
{
   item_t *item = lookup_item(&vlog_object, v, I_STMTS);
   return obj_array_count(item->obj_array);
}

vlog_node_t vlog_stmt(vlog_node_t v, unsigned n)
{
   item_t *item = lookup_item(&vlog_object, v, I_STMTS);
   return vlog_array_nth(item, n);
}

void vlog_add_stmt(vlog_node_t v, vlog_node_t s)
{
   assert(s != NULL);
   vlog_array_add(lookup_item(&vlog_object, v, I_STMTS), s);
   object_write_barrier(&(v->object), &(s->object));
}

unsigned vlog_ports(vlog_node_t v)
{
   item_t *item = lookup_item(&vlog_object, v, I_PORTS);
   return obj_array_count(item->obj_array);
}

vlog_node_t vlog_port(vlog_node_t v, unsigned n)
{
   item_t *item = lookup_item(&vlog_object, v, I_PORTS);
   return vlog_array_nth(item, n);
}

void vlog_add_port(vlog_node_t v, vlog_node_t p)
{
   assert(p != NULL);
   assert(p->object.kind == V_REF);
   vlog_array_add(lookup_item(&vlog_object, v, I_PORTS), p);
   object_write_barrier(&(v->object), &(p->object));
}

unsigned vlog_params(vlog_node_t v)
{
   item_t *item = lookup_item(&vlog_object, v, I_PARAMS);
   return obj_array_count(item->obj_array);
}

vlog_node_t vlog_param(vlog_node_t v, unsigned n)
{
   item_t *item = lookup_item(&vlog_object, v, I_PARAMS);
   return vlog_array_nth(item, n);
}

void vlog_add_param(vlog_node_t v, vlog_node_t p)
{
   assert(p != NULL);
   vlog_array_add(lookup_item(&vlog_object, v, I_PARAMS), p);
   object_write_barrier(&(v->object), &(p->object));
}

unsigned vlog_ranges(vlog_node_t v)
{
   item_t *item = lookup_item(&vlog_object, v, I_RANGES);
   return obj_array_count(item->obj_array);
}

vlog_node_t vlog_range(vlog_node_t v, unsigned n)
{
   item_t *item = lookup_item(&vlog_object, v, I_RANGES);
   return vlog_array_nth(item, n);
}

void vlog_add_range(vlog_node_t v, vlog_node_t r)
{
   assert(r != NULL);
   assert(r->object.kind == V_DIMENSION);
   vlog_array_add(lookup_item(&vlog_object, v, I_RANGES), r);
   object_write_barrier(&(v->object), &(r->object));
}

unsigned vlog_decls(vlog_node_t v)
{
   item_t *item = lookup_item(&vlog_object, v, I_DECLS);
   return obj_array_count(item->obj_array);
}

vlog_node_t vlog_decl(vlog_node_t v, unsigned n)
{
   item_t *item = lookup_item(&vlog_object, v, I_DECLS);
   return vlog_array_nth(item, n);
}

void vlog_add_decl(vlog_node_t v, vlog_node_t d)
{
   assert(d != NULL);
   vlog_array_add(lookup_item(&vlog_object, v, I_DECLS), d);
   object_write_barrier(&(v->object), &(d->object));
}

unsigned vlog_conds(vlog_node_t v)
{
   item_t *item = lookup_item(&vlog_object, v, I_CONDS);
   return obj_array_count(item->obj_array);
}

vlog_node_t vlog_cond(vlog_node_t v, unsigned n)
{
   item_t *item = lookup_item(&vlog_object, v, I_CONDS);
   return vlog_array_nth(item, n);
}

void vlog_add_cond(vlog_node_t v, vlog_node_t c)
{
   assert(c != NULL && c->object.kind == V_COND);
   vlog_array_add(lookup_item(&vlog_object, v, I_CONDS), c);
   object_write_barrier(&(v->object), &(c->object));
}

unsigned vlog_subkind(vlog_node_t v)
{
   return lookup_item(&vlog_object, v, I_SUBKIND)->ival;
}

void vlog_set_subkind(vlog_node_t v, unsigned sub)
{
   lookup_item(&vlog_object, v, I_SUBKIND)->ival = sub;
}

vlog_node_t vlog_value(vlog_node_t v)
{
   item_t *item = lookup_item(&vlog_object, v, I_VALUE);
   assert(item->object != NULL);
   return container_of(item->object, struct _vlog_node, object);
}

bool vlog_has_value(vlog_node_t v)
{
   return lookup_item(&vlog_object, v, I_VALUE)->object != NULL;
}

void vlog_set_value(vlog_node_t v, vlog_node_t e)
{
   lookup_item(&vlog_object, v, I_VALUE)->object = &(e->object);
   object_write_barrier(&(v->object), &(e->object));
}

vlog_node_t vlog_target(vlog_node_t v)
{
   item_t *item = lookup_item(&vlog_object, v, I_TARGET);
   assert(item->object != NULL);
   return container_of(item->object, struct _vlog_node, object);
}

void vlog_set_target(vlog_node_t v, vlog_node_t e)
{
   lookup_item(&vlog_object, v, I_TARGET)->object = &(e->object);
   object_write_barrier(&(v->object), &(e->object));
}

const char *vlog_text(vlog_node_t v)
{
   item_t *item = lookup_item(&vlog_object, v, I_TEXT);
   assert(item->text != NULL);
   return item->text;
}

void vlog_set_text(vlog_node_t v, const char *text)
{
   lookup_item(&vlog_object, v, I_TEXT)->text = xstrdup(text);
}

number_t vlog_number(vlog_node_t v)
{
   return lookup_item(&vlog_object, v, I_NUMBER)->number;
}

void vlog_set_number(vlog_node_t v, number_t n)
{
   lookup_item(&vlog_object, v, I_NUMBER)->number = n;
}

data_type_t vlog_datatype(vlog_node_t v)
{
   return lookup_item(&vlog_object, v, I_DATATYPE)->ival;
}

void vlog_set_datatype(vlog_node_t v, data_type_t dt)
{
   lookup_item(&vlog_object, v, I_DATATYPE)->ival = dt;
}

vlog_node_t vlog_left(vlog_node_t v)
{
   item_t *item = lookup_item(&vlog_object, v, I_LEFT);
   assert(item->object != NULL);
   return container_of(item->object, struct _vlog_node, object);
}

void vlog_set_left(vlog_node_t v, vlog_node_t e)
{
   lookup_item(&vlog_object, v, I_LEFT)->object = &(e->object);
   object_write_barrier(&(v->object), &(e->object));
}

vlog_node_t vlog_right(vlog_node_t v)
{
   item_t *item = lookup_item(&vlog_object, v, I_RIGHT);
   assert(item->object != NULL);
   return container_of(item->object, struct _vlog_node, object);
}

void vlog_set_right(vlog_node_t v, vlog_node_t e)
{
   lookup_item(&vlog_object, v, I_RIGHT)->object = &(e->object);
   object_write_barrier(&(v->object), &(e->object));
}

void vlog_visit(vlog_node_t v, vlog_visit_fn_t fn, void *context)
{
   vlog_visit_only(v, fn, context, V_LAST_NODE_KIND);
}

void vlog_visit_only(vlog_node_t v, vlog_visit_fn_t fn, void *context,
                     vlog_kind_t kind)
{
   assert(v != NULL);

   object_visit_ctx_t ctx = {
      .count      = 0,
      .postorder  = (object_visit_fn_t)fn,
      .preorder   = NULL,
      .context    = context,
      .kind       = kind,
      .tag        = OBJECT_TAG_VLOG,
      .generation = object_next_generation(),
      .deep       = false
   };

   object_visit(&(v->object), &ctx);
}

object_t *vlog_to_object(vlog_node_t v)
{
   return &(v->object);
}

vlog_node_t vlog_from_object(object_t *obj)
{
   if (obj != NULL && obj->tag == OBJECT_TAG_VLOG)
      return container_of(obj, struct _vlog_node, object);
   else
      return NULL;
}

void vlog_locus(vlog_node_t v, ident_t *unit, ptrdiff_t *offset)
{
   assert(v != NULL);
   object_locus(&(v->object), unit, offset);
}

1	//
2	// Copyright (C) 2022 Nick Gasson
3	//
4	// This program is free software: you can redistribute it and/or modify
5	// it under the terms of the GNU General Public License as published by
6	// the Free Software Foundation, either version 3 of the License, or
7	// (at your option) any later version.
8	//
9	// This program is distributed in the hope that it will be useful,
10	// but WITHOUT ANY WARRANTY; without even the implied warranty of
11	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12	// GNU General Public License for more details.
13	//
14	// You should have received a copy of the GNU General Public License
15	// along with this program. If not, see <http://www.gnu.org/licenses/>.
16	//
17
18	#include "util.h"
19	#include "vlog/vlog-node.h"
20	#include "vlog/vlog-number.h"
21	#include "common.h"
22	#include "object.h"
23
24	#include <string.h>
25	#include <inttypes.h>
26	#include <stdlib.h>
27
28	static const imask_t has_map[V_LAST_NODE_KIND] = {
29	// V_MODULE
30	(I_IDENT \| I_PORTS \| I_STMTS \| I_DECLS \| I_IDENT2),
31
32	// V_PORT_DECL
33	(I_IDENT \| I_SUBKIND \| I_IDENT2 \| I_RANGES),
34
35	// V_REF
36	(I_IDENT \| I_REF),
37
38	// V_ALWAYS
39	(I_IDENT \| I_STMTS),
40
41	// V_TIMING
42	(I_VALUE \| I_STMTS),
43
44	// V_NBASSIGN
45	(I_TARGET \| I_VALUE),
46
47	// V_EVENT
48	(I_SUBKIND \| I_VALUE),
49
50	// V_INITIAL
51	(I_IDENT \| I_STMTS),
52
53	// V_SEQ_BLOCK
54	(I_IDENT \| I_STMTS),
55
56	// V_SYSTASK
57	(I_IDENT \| I_SUBKIND \| I_PARAMS),
58
59	// V_STRING
60	(I_TEXT),
61
62	// V_NUMBER
63	(I_NUMBER),
64
65	// V_NET_DECL
66	(I_IDENT \| I_SUBKIND \| I_RANGES \| I_DATATYPE),
67
68	// V_ASSIGN
69	(I_TARGET \| I_VALUE),
70
71	// V_ROOT
72	(I_IDENT \| I_STMTS \| I_DECLS),
73
74	// V_DIMENSION
75	(I_SUBKIND \| I_LEFT \| I_RIGHT),
76
77	// V_IF
78	(I_CONDS),
79
80	// V_COND
81	(I_VALUE \| I_STMTS),
82
83	// V_VAR_DECL
84	(I_IDENT \| I_RANGES),
85
86	// V_DELAY_CONTROL
87	(I_VALUE),
88
89	// V_BINARY
90	(I_LEFT \| I_RIGHT \| I_SUBKIND),
91	};
92
93	static const char *kind_text_map[V_LAST_NODE_KIND] = {
94	"V_MODULE", "V_PORT_DECL", "V_REF", "V_ALWAYS",
95	"V_TIMING", "V_NBASSIGN", "V_EVENT", "V_INITIAL",
96	"V_SEQ_BLOCK", "V_SYSTASK", "V_STRING", "V_NUMBER",
97	"V_NET_DECL", "V_ASSIGN", "V_ROOT", "V_DIMENSION",
98	"V_IF", "V_COND", "V_VAR_DECL", "V_DELAY_CONTROL",
99	"V_BINARY",
100	};
101
102	static const change_allowed_t change_allowed[] = {
103	{ -1, -1 }
104	};
105
106	object_class_t vlog_object = {
107	.name = "vlog",
108	.change_allowed = change_allowed,
109	.has_map = has_map,
110	.kind_text_map = kind_text_map,
111	.tag = OBJECT_TAG_VLOG,
112	.last_kind = V_LAST_NODE_KIND,
113	.has_loc = true,
114	.gc_roots = { V_MODULE },
115	.gc_num_roots = 1
116	};
117
118	struct _vlog_node {
119	object_t object;
120	};
121
122	static inline vlog_node_t vlog_array_nth(item_t *item, unsigned n)
123	{
124	object_t *o = obj_array_nth(item->obj_array, n);
125	return container_of(o, struct _vlog_node, object);
126	}
127
128	static inline void vlog_array_add(item_t *item, vlog_node_t v)	393✔
129	{
130	obj_array_add(&(item->obj_array), &(v->object));	393✔
131	}	393✔
132
133	vlog_node_t vlog_new(vlog_kind_t kind)	515✔
134	{
135	object_t *o = object_new(NULL, &vlog_object, kind);	515✔
136	return container_of(o, struct _vlog_node, object);	515✔
137	}
138
139	vlog_kind_t vlog_kind(vlog_node_t v)	1,270✔
140	{
141	return v->object.kind;	1,270✔
142	}
143
144	const char *vlog_kind_str(vlog_kind_t kind)	×
145	{
146	return kind_text_map[kind];	×
147	}
148
149	ident_t vlog_ident(vlog_node_t v)	344✔
150	{
151	item_t *item = lookup_item(&vlog_object, v, I_IDENT);	344✔
152	assert(item->ident != NULL);	344✔
153	return item->ident;	344✔
154	}
155
156	void vlog_set_ident(vlog_node_t v, ident_t i)	289✔
157	{
158	lookup_item(&vlog_object, v, I_IDENT)->ident = i;	289✔
159	}	289✔
160
161	ident_t vlog_ident2(vlog_node_t v)	53✔
162	{
163	item_t *item = lookup_item(&vlog_object, v, I_IDENT2);	53✔
164	assert(item->ident != NULL);	53✔
165	return item->ident;	53✔
166	}
167
168	void vlog_set_ident2(vlog_node_t v, ident_t i)	64✔
169	{
170	lookup_item(&vlog_object, v, I_IDENT2)->ident = i;	64✔
171	}	64✔
172
173	const loc_t *vlog_loc(vlog_node_t v)	191✔
174	{
175	assert(v != NULL);	191✔
176	return &(v->object.loc);	191✔
177	}
178
179	void vlog_set_loc(vlog_node_t v, const loc_t *loc)	515✔
180	{
181	assert(v != NULL);	515✔
182	assert(loc != NULL);	515✔
183	v->object.loc = *loc;	515✔
184	}	515✔
185
186	vlog_node_t vlog_ref(vlog_node_t v)	88✔
187	{
188	item_t *item = lookup_item(&vlog_object, v, I_REF);	88✔
189	assert(item->object != NULL);	88✔
190	return container_of(item->object, struct _vlog_node, object);	88✔
191	}
192
193	bool vlog_has_ref(vlog_node_t v)	20✔
194	{
195	return lookup_item(&vlog_object, v, I_REF)->object != NULL;	20✔
196	}
197
198	void vlog_set_ref(vlog_node_t v, vlog_node_t d)	123✔
199	{
200	lookup_item(&vlog_object, v, I_REF)->object = &(d->object);	123✔
201	object_write_barrier(&(v->object), &(d->object));	123✔
202	}	123✔
203
204	unsigned vlog_stmts(vlog_node_t v)	179✔
205	{
206	item_t *item = lookup_item(&vlog_object, v, I_STMTS);	179✔
207	return obj_array_count(item->obj_array);	179✔
208	}
209
210	vlog_node_t vlog_stmt(vlog_node_t v, unsigned n)	273✔
211	{
212	item_t *item = lookup_item(&vlog_object, v, I_STMTS);	273✔
213	return vlog_array_nth(item, n);	273✔
214	}
215
216	void vlog_add_stmt(vlog_node_t v, vlog_node_t s)	158✔
217	{
218	assert(s != NULL);	158✔
219	vlog_array_add(lookup_item(&vlog_object, v, I_STMTS), s);	158✔
220	object_write_barrier(&(v->object), &(s->object));	158✔
221	}	158✔
222
223	unsigned vlog_ports(vlog_node_t v)	23✔
224	{
225	item_t *item = lookup_item(&vlog_object, v, I_PORTS);	23✔
226	return obj_array_count(item->obj_array);	23✔
227	}
228
229	vlog_node_t vlog_port(vlog_node_t v, unsigned n)	41✔
230	{
231	item_t *item = lookup_item(&vlog_object, v, I_PORTS);	41✔
232	return vlog_array_nth(item, n);	41✔
233	}
234
235	void vlog_add_port(vlog_node_t v, vlog_node_t p)	42✔
236	{
237	assert(p != NULL);	42✔
238	assert(p->object.kind == V_REF);	42✔
239	vlog_array_add(lookup_item(&vlog_object, v, I_PORTS), p);	42✔
240	object_write_barrier(&(v->object), &(p->object));	42✔
241	}	42✔
242
243	unsigned vlog_params(vlog_node_t v)	93✔
244	{
245	item_t *item = lookup_item(&vlog_object, v, I_PARAMS);	93✔
246	return obj_array_count(item->obj_array);	93✔
247	}
248
249	vlog_node_t vlog_param(vlog_node_t v, unsigned n)	158✔
250	{
251	item_t *item = lookup_item(&vlog_object, v, I_PARAMS);	158✔
252	return vlog_array_nth(item, n);	158✔
253	}
254
255	void vlog_add_param(vlog_node_t v, vlog_node_t p)	82✔
256	{
257	assert(p != NULL);	82✔
258	vlog_array_add(lookup_item(&vlog_object, v, I_PARAMS), p);	82✔
259	object_write_barrier(&(v->object), &(p->object));	82✔
260	}	82✔
261
262	unsigned vlog_ranges(vlog_node_t v)	33✔
263	{
264	item_t *item = lookup_item(&vlog_object, v, I_RANGES);	33✔
265	return obj_array_count(item->obj_array);	33✔
266	}
267
268	vlog_node_t vlog_range(vlog_node_t v, unsigned n)	5✔
269	{
270	item_t *item = lookup_item(&vlog_object, v, I_RANGES);	5✔
271	return vlog_array_nth(item, n);	5✔
272	}
273
274	void vlog_add_range(vlog_node_t v, vlog_node_t r)	8✔
275	{
276	assert(r != NULL);	8✔
277	assert(r->object.kind == V_DIMENSION);	8✔
278	vlog_array_add(lookup_item(&vlog_object, v, I_RANGES), r);	8✔
279	object_write_barrier(&(v->object), &(r->object));	8✔
280	}	8✔
281
282	unsigned vlog_decls(vlog_node_t v)	62✔
283	{
284	item_t *item = lookup_item(&vlog_object, v, I_DECLS);	62✔
285	return obj_array_count(item->obj_array);	62✔
286	}
287
288	vlog_node_t vlog_decl(vlog_node_t v, unsigned n)	154✔
289	{
290	item_t *item = lookup_item(&vlog_object, v, I_DECLS);	154✔
291	return vlog_array_nth(item, n);	154✔
292	}
293
294	void vlog_add_decl(vlog_node_t v, vlog_node_t d)	84✔
295	{
296	assert(d != NULL);	84✔
297	vlog_array_add(lookup_item(&vlog_object, v, I_DECLS), d);	84✔
298	object_write_barrier(&(v->object), &(d->object));	84✔
299	}	84✔
300
301	unsigned vlog_conds(vlog_node_t v)	16✔
302	{
303	item_t *item = lookup_item(&vlog_object, v, I_CONDS);	16✔
304	return obj_array_count(item->obj_array);	16✔
305	}
306
307	vlog_node_t vlog_cond(vlog_node_t v, unsigned n)	25✔
308	{
309	item_t *item = lookup_item(&vlog_object, v, I_CONDS);	25✔
310	return vlog_array_nth(item, n);	25✔
311	}
312
313	void vlog_add_cond(vlog_node_t v, vlog_node_t c)	19✔
314	{
315	assert(c != NULL && c->object.kind == V_COND);	19✔
316	vlog_array_add(lookup_item(&vlog_object, v, I_CONDS), c);	19✔
317	object_write_barrier(&(v->object), &(c->object));	19✔
318	}	19✔
319
320	unsigned vlog_subkind(vlog_node_t v)	109✔
321	{
322	return lookup_item(&vlog_object, v, I_SUBKIND)->ival;	109✔
323	}
324
325	void vlog_set_subkind(vlog_node_t v, unsigned sub)	105✔
326	{
327	lookup_item(&vlog_object, v, I_SUBKIND)->ival = sub;	105✔
328	}	105✔
329
330	vlog_node_t vlog_value(vlog_node_t v)	143✔
331	{
332	item_t *item = lookup_item(&vlog_object, v, I_VALUE);	143✔
333	assert(item->object != NULL);	143✔
334	return container_of(item->object, struct _vlog_node, object);	143✔
335	}
336
337	bool vlog_has_value(vlog_node_t v)	19✔
338	{
339	return lookup_item(&vlog_object, v, I_VALUE)->object != NULL;	19✔
340	}
341
342	void vlog_set_value(vlog_node_t v, vlog_node_t e)	84✔
343	{
344	lookup_item(&vlog_object, v, I_VALUE)->object = &(e->object);	84✔
345	object_write_barrier(&(v->object), &(e->object));	84✔
346	}	84✔
347
348	vlog_node_t vlog_target(vlog_node_t v)	54✔
349	{
350	item_t *item = lookup_item(&vlog_object, v, I_TARGET);	54✔
351	assert(item->object != NULL);	54✔
352	return container_of(item->object, struct _vlog_node, object);	54✔
353	}
354
355	void vlog_set_target(vlog_node_t v, vlog_node_t e)	27✔
356	{
357	lookup_item(&vlog_object, v, I_TARGET)->object = &(e->object);	27✔
358	object_write_barrier(&(v->object), &(e->object));	27✔
359	}	27✔
360
361	const char *vlog_text(vlog_node_t v)	50✔
362	{
363	item_t *item = lookup_item(&vlog_object, v, I_TEXT);	50✔
364	assert(item->text != NULL);	50✔
365	return item->text;	50✔
366	}
367
368	void vlog_set_text(vlog_node_t v, const char *text)	52✔
369	{
370	lookup_item(&vlog_object, v, I_TEXT)->text = xstrdup(text);	52✔
371	}	52✔
372
373	number_t vlog_number(vlog_node_t v)	46✔
374	{
375	return lookup_item(&vlog_object, v, I_NUMBER)->number;	46✔
376	}
377
378	void vlog_set_number(vlog_node_t v, number_t n)	53✔
379	{
380	lookup_item(&vlog_object, v, I_NUMBER)->number = n;	53✔
381	}	53✔
382
383	data_type_t vlog_datatype(vlog_node_t v)	×
384	{
385	return lookup_item(&vlog_object, v, I_DATATYPE)->ival;	×
386	}
387
388	void vlog_set_datatype(vlog_node_t v, data_type_t dt)	5✔
389	{
390	lookup_item(&vlog_object, v, I_DATATYPE)->ival = dt;	5✔
391	}	5✔
392
393	vlog_node_t vlog_left(vlog_node_t v)	5✔
394	{
395	item_t *item = lookup_item(&vlog_object, v, I_LEFT);	5✔
396	assert(item->object != NULL);	5✔
397	return container_of(item->object, struct _vlog_node, object);	5✔
398	}
399
400	void vlog_set_left(vlog_node_t v, vlog_node_t e)	8✔
401	{
402	lookup_item(&vlog_object, v, I_LEFT)->object = &(e->object);	8✔
403	object_write_barrier(&(v->object), &(e->object));	8✔
404	}	8✔
405
406	vlog_node_t vlog_right(vlog_node_t v)	5✔
407	{
408	item_t *item = lookup_item(&vlog_object, v, I_RIGHT);	5✔
409	assert(item->object != NULL);	5✔
410	return container_of(item->object, struct _vlog_node, object);	5✔
411	}
412
413	void vlog_set_right(vlog_node_t v, vlog_node_t e)	8✔
414	{
415	lookup_item(&vlog_object, v, I_RIGHT)->object = &(e->object);	8✔
416	object_write_barrier(&(v->object), &(e->object));	8✔
417	}	8✔
418
419	void vlog_visit(vlog_node_t v, vlog_visit_fn_t fn, void *context)	12✔
420	{
421	vlog_visit_only(v, fn, context, V_LAST_NODE_KIND);	12✔
422	}	12✔
423
424	void vlog_visit_only(vlog_node_t v, vlog_visit_fn_t fn, void *context,	12✔
425	vlog_kind_t kind)
426	{
427	assert(v != NULL);	12✔
428
429	object_visit_ctx_t ctx = {	12✔
430	.count = 0,
431	.postorder = (object_visit_fn_t)fn,
432	.preorder = NULL,
433	.context = context,
434	.kind = kind,
435	.tag = OBJECT_TAG_VLOG,
436	.generation = object_next_generation(),	12✔
437	.deep = false
438	};
439
440	object_visit(&(v->object), &ctx);	12✔
441	}	12✔
442
443	object_t *vlog_to_object(vlog_node_t v)	25✔
444	{
445	return &(v->object);	25✔
446	}
447
448	vlog_node_t vlog_from_object(object_t *obj)	613✔
449	{
450	if (obj != NULL && obj->tag == OBJECT_TAG_VLOG)	613✔
451	return container_of(obj, struct _vlog_node, object);	613✔
452	else
453	return NULL;	584✔
454	}
455
456	void vlog_locus(vlog_node_t v, ident_t unit, ptrdiff_t offset)	30✔
457	{
458	assert(v != NULL);	30✔
459	object_locus(&(v->object), unit, offset);	30✔
460	}	30✔

nickg / nvc / 6410578713

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous