void lts_type_serialize(lts_type_t t,stream_t ds){
DSwriteS(ds,"lts signature 1.1");
uint32_t N=lts_type_get_state_length(t);
Warning(debug,"state length is %d",N);
DSwriteU32(ds,N);
for(uint32_t i=0;i<N;i++){
char*x=lts_type_get_state_name(t,i);
if (x) DSwriteS(ds,x); else DSwriteS(ds,"");
DSwriteU32(ds,lts_type_get_state_typeno(t,i));
}
N=lts_type_get_state_label_count(t);
Warning(debug,"%d state labels",N);
DSwriteU32(ds,N);
for(uint32_t i=0;i<N;i++){
char*x=lts_type_get_state_label_name(t,i);
if (x) DSwriteS(ds,x); else DSwriteS(ds,"");
DSwriteU32(ds,lts_type_get_state_label_typeno(t,i));
}
N=lts_type_get_edge_label_count(t);
Warning(debug,"%d edge labels",N);
DSwriteU32(ds,N);
for(uint32_t i=0;i<N;i++){
char*x=lts_type_get_edge_label_name(t,i);
if (x) DSwriteS(ds,x); else DSwriteS(ds,"");
DSwriteU32(ds,lts_type_get_edge_label_typeno(t,i));
Warning(debug,"edge label %d is %s : %s",i,x,lts_type_get_edge_label_type(t,i));
}
N=lts_type_get_type_count(t);
Warning(debug,"%d types",N);
DSwriteU32(ds,N);
for(uint32_t i=0;i<N;i++){
DSwriteS(ds,lts_type_get_type(t,i));
DSwriteS(ds,(char*)data_format_string(t,i));
}
}
static int
type_max (check_ctx_t *ctx, int idx)
{
model_t model = ctx->parent;
lts_type_t ltstype = GBgetLTStype (model);
int typeno = lts_type_get_state_typeno (ltstype, idx);
int c;
switch (lts_type_get_format (ltstype, typeno))
{
case LTStypeDirect:
GBgetInitialState (model, ctx->src2);
c = ctx->src2[idx];
return c == 0 ? 1 : c;
case LTStypeRange:
return lts_type_get_min (ltstype, typeno);
case LTStypeEnum:
c = pins_chunk_count (model, typeno);
HREassert (c > 0, "Empty enum table for slot: %d -- %s", idx, str_slot(ctx, NULL, idx));
return c;
case LTStypeChunk:
c = pins_chunk_count (model, typeno);
return c == 0 ? 1 : c;
case LTStypeBool:
return 1;
case LTStypeTrilean:
return 2;
case LTStypeSInt32:
return (1ULL<<31) - 1;
default: {
HREassert(false);
return -1;
}
}
}
/*
* Returns a state name identifier. Uses the symbolic name if it exists,
* otherwise it will return the value with an "s" in front.
*/
char * etf_state_value(etf_model_t model, int state, int value) {
if (sanitized_types==NULL)
sanitize_types(model);
int type_no = lts_type_get_state_typeno(etf_type(model), state);
int v_count = etf_get_value_count(model, type_no);
if (v_count > value) {
return sanitized_types[type_no][value];
} else {
return get_state_name(value);
}
}
static void
dbg_found_read_dep_error (check_ctx_t *ctx, int *dst, int *dst2, int idx)
{
char *res = RTmalloc (1024);
lts_type_t ltstype = GBgetLTStype (ctx->parent);
int typeno = lts_type_get_state_typeno (ltstype, idx);
print_chunk (ctx->parent, res, 1024, typeno, dst[idx]);
Print1 (lerror, "Found missing read dependency in group %d (diff slot: %d -- %s != %s).\\"
"Identifying culprit read slot...",
ctx->group, idx, str_slot(ctx, dst2, idx), res);
RTfree (res);
}
static char *
str_slot (check_ctx_t *ctx, int *s, int i)
{
model_t model = ctx->parent;
lts_type_t ltstype = GBgetLTStype (model);
char *name = lts_type_get_state_name (ltstype, i);
char *type = lts_type_get_state_type (ltstype, i);
int typeno = lts_type_get_state_typeno (ltstype, i);
int max = 4096;
char *res = RTmalloc (max);
int l = snprintf (res, max, "%s : %s = ", name, type);
if (s != NULL) {
print_chunk (model, res+l, max-l, typeno, s[i]);
} else {
res[l-2] = '\0';
}
return res;
}
static int
type_min (check_ctx_t *ctx, int idx)
{
model_t model = ctx->parent;
lts_type_t ltstype = GBgetLTStype (model);
int typeno = lts_type_get_state_typeno (ltstype, idx);
switch (lts_type_get_format (ltstype, typeno))
{
case LTStypeRange:
return lts_type_get_min (ltstype, typeno);
case LTStypeDirect:
case LTStypeEnum:
case LTStypeChunk:
case LTStypeBool:
case LTStypeTrilean:
case LTStypeSInt32:
return 0;
default: {
HREassert(false);
return -1;
}
}
}
/* avoid rebuilding the whole tree, by storing extra info for the chunks */
static int
ltsmin_expr_lookup_values(ltsmin_expr_t ltl,ltsmin_parse_env_t env,model_t model)
{ //return type(SVAR) idx or -1
if (!ltl) return -1;
int left, right;
switch(ltl->node_type) {
case BINARY_OP:
left = ltsmin_expr_lookup_values(ltl->arg1, env, model);
right = ltsmin_expr_lookup_values(ltl->arg2, env, model);
switch(ltl->token) {
case PRED_EQ:
if (left >= 0) { // type(SVAR)
ltsmin_expr_lookup_value (ltl, ltl->arg2, left, env, model);
} else if (right >= 0) { // type(SVAR)
ltsmin_expr_lookup_value (ltl, ltl->arg1, right, env, model);
}
}
return -1;
case UNARY_OP:
ltsmin_expr_lookup_values(ltl->arg1, env, model);
return -1;
default:
switch(ltl->token) {
case SVAR: {
lts_type_t ltstype = GBgetLTStype (model);
int N = lts_type_get_state_length (ltstype);
if (ltl->idx < N)
return lts_type_get_state_typeno (ltstype, ltl->idx);
else
return lts_type_get_state_label_typeno (ltstype, ltl->idx - N);
}
default:
return -1;
}
}
}
/**
* \brief Initialises the data structures for generating symbolic parity games.
*/
void
init_spg(model_t model)
{
lts_type_t type = GBgetLTStype(model);
var_pos = 0;
var_type_no = 0;
for(int i=0; i<N; i++)
{
//Printf(infoLong, "%d: %s (%d [%s])\n", i, lts_type_get_state_name(type, i), lts_type_get_state_typeno(type, i), lts_type_get_state_type(type, i));
#ifdef LTSMIN_PBES
char* str1 = "string"; // for the PBES language module
#else
char* str1 = "mu"; // for the mu-calculus PINS layer
#endif
size_t strlen1 = strlen(str1);
char* str2 = lts_type_get_state_type(type, i);
size_t strlen2 = strlen(str2);
if (strlen1==strlen2 && strncmp(str1, str2, strlen1)==0)
{
var_pos = i;
var_type_no = lts_type_get_state_typeno(type, i);
if (GBhaveMucalc()) {
true_index = 0; // enforced by mucalc parser (mucalc-grammar.lemon / mucalc-syntax.c)
false_index = 1;
} else { // required for the PBES language module.
true_index = pins_chunk_put (model, var_type_no, chunk_str("true"));
false_index = pins_chunk_put (model, var_type_no, chunk_str("false"));
}
}
}
int p_len = 1;
int proj[1] = {var_pos}; // position 0 encodes the variable
variable_projection = vproj_create(domain, p_len, proj);
num_vars = pins_chunk_count (model, var_type_no); // number of propositional variables
if (GBhaveMucalc()) {
num_vars = GBgetMucalcNodeCount(); // number of mu-calculus subformulae
}
Print(infoLong, "init_spg: var_type_no=%d, num_vars=%zu", var_type_no, num_vars);
priority = RTmalloc(num_vars * sizeof(int)); // priority of variables
player = RTmalloc(num_vars * sizeof(int)); // player of variables
for(size_t i=0; i<num_vars; i++)
{
lts_type_t type = GBgetLTStype(model);
int state_length = lts_type_get_state_length(type);
// create dummy state with variable i:
int state[state_length];
for(int j=0; j < state_length; j++)
{
state[j] = 0;
}
state[var_pos] = i;
int label = GBgetStateLabelLong(model, PG_PRIORITY, state); // priority
priority[i] = label;
if (label < min_priority) {
min_priority = label;
}
if (label > max_priority) {
max_priority = label;
}
//Print(infoLong, " label %d (priority): %d", 0, label);
label = GBgetStateLabelLong(model, PG_PLAYER, state); // player
player[i] = label;
//Print(infoLong, " label %d (player): %d", 1, label);
}
true_states = vset_create(domain, -1, NULL);
false_states = vset_create(domain, -1, NULL);
}
