void CAESAR_ITERATE_STATE(CAESAR_TYPE_STATE s1,
CAESAR_TYPE_LABEL l,
CAESAR_TYPE_STATE s2,
void (*callback)
(CAESAR_TYPE_STATE, CAESAR_TYPE_LABEL, CAESAR_TYPE_STATE)) {
int i,c;
if (edge_encode && s1->state[0]<0) return;
if (edge_encode){
int labels[state_labels];
GBgetStateLabelsAll(model,s1->state,labels);
{
callback_struct_t context = { s1, l, s2, labels, callback };
c=GBgetTransitionsAll(model,s1->state,iterate_transition,&context);
if (c==0){
int ofs=edge_labels;
for(i=0;i<edge_labels;i++) l->label[i]=-1;
for(i=0;i<N;i++) {
l->label[ofs+i] = s1->state[i];
/* for dummy deadlock
s2->state[i] = - 1;
*/
/* for selfloop deadlock */
s2->state[i]=s1->state[i];
}
ofs+=N;
for(i=0;i<state_labels;i++) l->label[ofs+i] = labels[i];
callback(s1,l,s2);
}
}
} else {
callback_struct_t context = { s1, l, s2, NULL, callback };
c=GBgetTransitionsAll(model,s1->state,iterate_transition,&context);
}
}
static void explore_state_index(void*context,int idx,int*src){
model_t model=(model_t)context;
int labels[state_labels];
if (state_labels){
GBgetStateLabelsAll(model,src,labels);
}
if(write_lts){
if(write_state){
enum_vec(output_handle,src,labels);
} else {
enum_seg(output_handle,0,idx,labels);
}
}
switch(call_mode){
case UseBlackBox:
GBgetTransitionsAll(model,src,index_next,&idx);
break;
case UseGreyBox:
for(int i=0;i<K;i++){
GBgetTransitionsLong(model,i,src,index_next,&idx);
}
break;
}
explored++;
if (explored%1000==0 && RTverbosity>=2)
Warning(info,"explored %d visited %d trans %d",explored,visited,trans);
}
static void
write_trace_step (write_trace_step_t *ctx, int *src)
{
Warning (debug,"finding edge for state %d", ctx->src_no);
ctx->found = 0;
GBgetTransitionsAll (ctx->env->model, src, write_trace_next, ctx);
if (ctx->found==0) Abort("no matching transition found for %u", ctx->dst_no);
}
static int torx_handle_request(torx_struct_t *context, char *req)
{
while(isspace((int)*req))
req++;
switch(req[0]) {
case 'r': { /* reset */
fprintf(stdout, "R 0\t1\n");
fflush(stdout);
break;
}
case 'e': { /*explore */
int n, res;
req++;
while(isspace((int)*req))
req++;
if ((res = sscanf(req, "%u", &n)) != 1) {
int l = strlen(req);
if (req[l - 1] == '\n')
req[l - 1] = '\0';
fprintf(stdout, "E0 Missing event number (%s; sscanf found #%d)\n", req, res);
} else if (n >= TreeCount(dbs)) {
fprintf(stdout, "E0 Unknown event number\n");
fflush(stdout);
} else {
int src[N], c;
TreeUnfold(dbs,n,src);
fprintf(stdout, "EB\n");
c=GBgetTransitionsAll(context->model,src,torx_transition,context);
fprintf(stdout, "EE\n");
fflush(stdout);
}
break;
}
case 'q': {
fprintf(stdout, "Q\n");
fflush(stdout);
return 1;
break;
}
default: /* unknown command */
fprintf(stdout, "A_ERROR UnknownCommand: %s\n", req);
fflush(stdout);
}
return 0;
}
int
permute_trans (permute_t *perm, state_info_t *state, perm_cb_f cb, void *ctx)
{
perm->call_ctx = ctx;
perm->real_cb = cb;
perm->state = state;
perm->nstored = perm->start_group_index = 0;
int count = 0;
state_data_t data = state_info_pins_state (state);
if (inhibit) {
int N = dm_nrows (perm->inhibit_matrix);
int class_count[N];
for (int i = 0; i < N; i++) {
class_count[i] = 0;
if (is_inhibited(perm, class_count, i)) continue;
if (perm->class_label >= 0) {
class_count[i] = GBgetTransitionsMatching (perm->model, perm->class_label, i, data, permute_one, perm);
} else if (perm->class_matrix != NULL) {
class_count[i] = GBgetTransitionsMarked (perm->model, perm->class_matrix, i, data, permute_one, perm);
} else {
Abort ("inhibit set, but no known classification found.");
}
count += class_count[i];
}
} else {
count = GBgetTransitionsAll (perm->model, data, permute_one, perm);
}
switch (perm->permutation) {
case Perm_Otf:
randperm (perm->pad, perm->nstored, state->ref + perm->shiftorder);
for (size_t i = 0; i < perm->nstored; i++)
perm_do (perm, perm->pad[i]);
break;
case Perm_Random:
for (size_t i = 0; i < perm->nstored; i++)
perm_do (perm, perm->rand[perm->nstored][i]);
break;
case Perm_Dynamic:
sort_r (perm->tosort, perm->nstored, sizeof(int), dyn_cmp, perm);
perm_do_all (perm);
break;
case Perm_RR:
sort_r (perm->tosort, perm->nstored, sizeof(int), rr_cmp, perm);
perm_do_all (perm);
break;
case Perm_SR:
sort_r (perm->tosort, perm->nstored, sizeof(int), rand_cmp, perm);
perm_do_all (perm);
break;
case Perm_Sort:
sort_r (perm->tosort, perm->nstored, sizeof(int), sort_cmp, perm);
perm_do_all (perm);
break;
case Perm_Shift:
perm_do_all (perm);
break;
case Perm_Shift_All:
for (size_t i = 0; i < perm->nstored; i++) {
size_t j = (perm->start_group_index + i);
j = j < perm->nstored ? j : 0;
perm_do (perm, j);
}
break;
case Perm_None:
break;
default:
Abort ("Unknown permutation!");
}
return count;
}
