static void
output_init(FILE *tbl_file)
{
int state[N];
GBgetInitialState(model, state);
fprintf(tbl_file, "begin state\n");
for (int i = 0; i < N; i++) {
fprint_ltsmin_ident(tbl_file, lts_type_get_state_name(ltstype, i));
fprintf(tbl_file, ":");
fprint_ltsmin_ident(tbl_file, lts_type_get_state_type(ltstype, i));
fprintf(tbl_file, (i == (N - 1))?"\n":" ");
}
fprintf(tbl_file,"end state\n");
fprintf(tbl_file,"begin edge\n");
for(int i = 0; i < eLbls; i++) {
fprint_ltsmin_ident(tbl_file, lts_type_get_edge_label_name(ltstype, i));
fprintf(tbl_file, ":");
fprint_ltsmin_ident(tbl_file, lts_type_get_edge_label_type(ltstype, i));
fprintf(tbl_file, (i == (eLbls - 1))?"\n":" ");
}
fprintf(tbl_file, "end edge\n");
fprintf(tbl_file, "begin init\n");
for(int i = 0; i < N; i++)
fprintf(tbl_file, "%d%s", state[i], (i == (N - 1))?"\n":" ");
fprintf(tbl_file,"end init\n");
}
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 inline void
print_ti (check_ctx_t *ctx, transition_info_t *ti)
{
if (ti == NULL || ti->labels == NULL) return;
model_t model = ctx->parent;
lts_type_t ltstype = GBgetLTStype (model);
int Max = 4096;
char *tmp = RTmalloc (Max);
int l;
for (int i = 0; i < ctx->L; i++) {
char *name = lts_type_get_edge_label_name (ltstype, i);
char *type = lts_type_get_edge_label_type (ltstype, i);
int typeno = lts_type_get_edge_label_typeno (ltstype, i);
char *res = tmp;
l = snprintf (res, Max, " --> %s : %s = ", name, type);
l += print_chunk (model, res+l, Max-l, typeno, ti->labels[i]);
Printf (lerror, "%s\n", res);
}
RTfree (tmp);
}
CAESAR_TYPE_STRING CAESAR_STRING_LABEL(CAESAR_TYPE_LABEL l) {
static char *s = NULL; /* start of string */
static char *b = NULL; /*beyond*/
static char *tau = "i";
char *p = NULL; /* current insertion point */
int u, n; /* used, needed */
int i;
chunk c;
size_t clen;
p = s;
n = 5;
if (b-p < n) {
u = p-s;
s = RTrealloc(s, u+n);/* TODO: check s!=0 */
p = s+u;
b = s + u+n;
}
if (edge_labels > 0 && l->label[0]<0){
n = 6;
if (b-p < n) {
u = p-s;
s = RTrealloc(s, u+n); /* TODO: check s!=0 */
p = s+u;
b = s + u+n;
}
sprintf(p, "delta");
p+=strlen(p);
} else {
if (edge_labels > 1 || edge_encode) {
sprintf(p, "|");
p += strlen(p);
}
for(i=0; i < edge_labels; i++) {
char *name=lts_type_get_edge_label_name(ltstype,i);
c=GBchunkGet(model,lts_type_get_edge_label_typeno(ltstype,i),l->label[i]);
if (c.len==3 && strncmp(c.data, LTSMIN_EDGE_VALUE_TAU, c.len)==0)
clen=strlen(tau);
else
clen=c.len*2+6;
n = strlen(name)+ 1 + clen+1+1+1; /* for name , '=' , c, ';', '>', '\0' */
if (b-p < n) {
u = p-s;
s = RTrealloc(s, u+n); /* TODO: check s!=0 */
p = s+u;
b = s + u+n;
}
if (i>0) {
sprintf(p, "|");
p += strlen(p);
}
if (edge_labels > 1 || edge_encode ) {
sprintf(p, "%s=",name);
p += strlen(p);
}
if (c.len==3 && strncmp(c.data, LTSMIN_EDGE_VALUE_TAU, c.len)==0)
sprintf(p, "%s", tau);
else
chunk2string(c,b-p,p);
p += strlen(p);
}
}
if (edge_labels > 1 || edge_encode ) {
sprintf(p, "|");
p += strlen(p);
}
if (edge_encode){
int ofs=edge_labels;
/*
for(i=0;i<N;i++){
char*name=lts_type_get_state_name(ltstype,i);
c=GBchunkGet(model,lts_type_get_state_typeno(ltstype,i),l->label[ofs+i]);
n=strlen(name)+c.len*2+7;
if (b-p < n) {
u = p-s;
s = realloc(s, u+n); // TODO: check s!=0
p = s+u;
b = s + u+n;
}
sprintf(p, "%s=",name);
p+=strlen(p);
chunk2string(c,b-p,p);
p+=strlen(p);
sprintf(p, "|");
p +=strlen(p);
}
*/
ofs+=N;
for(i=0;i<state_labels;i++){
char*name=lts_type_get_state_label_name(ltstype,i);
c=GBchunkGet(model,lts_type_get_state_label_typeno(ltstype,i),l->label[ofs+i]);
n=strlen(name)+c.len*2+7;
if (b-p < n) {
u = p-s;
s = RTrealloc(s, u+n); /* TODO: check s!=0 */
p = s+u;
b = s + u+n;
}
sprintf(p, "%s=",name);
p+=strlen(p);
chunk2string(c,b-p,p);
p+=strlen(p);
sprintf(p, "|");
p +=strlen(p);
}
}
return s;
}
static void write_close(lts_file_t file){
//if (file->init_count!=1) Abort("missing initial state"); in some cases no initial states makes sense!
uint32_t pre_sum=0;
for(int i=0;i<file->segments;i++) pre_sum+=file->state_perseg[i];
uint32_t tmp;
for (int i=0;i<file->segments;i++){
tmp=lts_get_max_src_p1(file,i);
if (tmp>file->state_perseg[i]) file->state_perseg[i]=tmp;
tmp=lts_get_max_dst_p1(file,i);
if (tmp>file->state_perseg[i]) file->state_perseg[i]=tmp;
}
file->state_count=0;
for(int i=0;i<file->segments;i++) file->state_count+=file->state_perseg[i];
if (pre_sum && pre_sum!=file->state_count) {
Abort("edges use unwritten states");
}
uint32_t offset[file->segments];
offset[0]=0;
for(int i=1;i<file->segments;i++) offset[i]=offset[i-1]+file->state_perseg[i-1];
uint32_t seg,ofs;
for(uint32_t i=0;i<file->lts->root_count;i++){
seg=file->lts->root_list[i]%file->segments;
ofs=file->lts->root_list[i]/file->segments;
file->lts->root_list[i]=offset[seg]+ofs;
}
for(uint32_t i=0;i<file->edge_count;i++){
seg=file->lts->src[i]%file->segments;
ofs=file->lts->src[i]/file->segments;
file->lts->src[i]=offset[seg]+ofs;
seg=file->lts->dest[i]%file->segments;
ofs=file->lts->dest[i]/file->segments;
file->lts->dest[i]=offset[seg]+ofs;
}
if (file->lts->properties){
uint32_t* temp=file->lts->properties;
file->lts->properties=(uint32_t*)RTmalloc(file->state_count*sizeof(uint32_t));
for(int i=0;i<file->segments;i++){
for(uint32_t j=0;j<file->state_perseg[i];j++){
file->lts->properties[offset[i]+j]=temp[j*file->segments+i];
}
}
RTfree(temp);
}
lts_set_size(file->lts,file->init_count,file->state_count,file->edge_count);
file->lts->tau=-1;
if (lts_type_get_edge_label_count(file->lts->ltstype)==1 &&
strncmp(lts_type_get_edge_label_name(file->lts->ltstype,0),LTSMIN_EDGE_TYPE_ACTION_PREFIX,6)==0)
{
Print(infoShort,"action labeled, detecting silent step");
int tableno=lts_type_get_edge_label_typeno(file->lts->ltstype,0);
value_table_t vt=file->lts->values[tableno];
int N=VTgetCount(vt);
for(int i=0;i<N;i++){
chunk c=VTgetChunk(vt,i);
if ( (c.len==strlen(LTSMIN_EDGE_VALUE_TAU) && strcmp(c.data,LTSMIN_EDGE_VALUE_TAU)==0)
|| (c.len==1 && strcmp(c.data,"i")==0)
)
{
Print(infoShort,"invisible label is %s",c.data);
if (file->lts->tau>=0) Abort("two silent labels");
file->lts->tau=i;
}
}
if (file->lts->tau<0) {
Print(infoShort,"no silent label");
}
}
}
