lts_file_t aut_file_create(const char* name,lts_type_t ltstype,int segments,lts_file_t settings){
if (lts_type_get_state_length(ltstype)) {
//Abort("cannot write state to AUT file");
Print(infoShort,"Ignoring state vector");
}
if (lts_type_get_state_label_count(ltstype)) {
Abort("cannot write state labels to AUT file");
}
if (lts_type_get_edge_label_count(ltstype)!=1) {
Abort("AUT files contain precisely one edge label");
}
if (segments!=1) Abort("AUT files contain precisely 1 segment");
lts_file_t file=lts_file_bare(name,ltstype,1,settings,sizeof(struct lts_file_s));
file->f=fopen(name,"w");
if(file->f==NULL){
AbortCall("while opening %s",name);
}
file->root--; // set to -1 denoting undefined.
file->states++; // set to 1, denoting one state.
file->type_no=lts_type_get_edge_label_typeno(ltstype,0);
lts_file_set_write_init(file,aut_write_init);
lts_file_set_write_state(file,write_state);
lts_file_set_write_edge(file,aut_write_edge);
lts_file_set_close(file,aut_write_close);
fprintf(file->f,"des(?,?,?) \n");
lts_file_complete(file);
return file;
}
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));
}
}
trc_env_t *
trc_create (model_t model, trc_get_state_f get, void *arg)
{
trc_env_t *trace = RTmalloc(sizeof(trc_env_t));
lts_type_t ltstype = GBgetLTStype (model);
trace->N = lts_type_get_state_length (ltstype);
trace->state_labels = lts_type_get_state_label_count (ltstype);
trace->get_state = get;
trace->get_state_arg = arg;
trace->model = model;
return trace;
}
static void default_push(lts_file_t src,lts_file_t dst){
if (SYSTEM(src)->ctx != SYSTEM(dst)->ctx) Abort("cannot copy between different contexts");
int me=HREme(SYSTEM(src)->ctx);
lts_type_t ltstype=lts_file_get_type(src);
int N1=lts_type_get_state_length(ltstype);
int N2=lts_type_get_state_label_count(ltstype);
int K=lts_type_get_edge_label_count(ltstype);
int do_state;
if (N1){
Print(infoLong,"vector length is %d",N1);
do_state=1;
} else {
do_state=N2?1:0;
N1=1;
}
int src_seg;
uint32_t src_state[N1];
int dst_seg;
uint32_t dst_state[N1];
uint32_t edge_labels[K];
if (me==0) {
Print(infoLong,"copying initial states");
int count=0;
while(lts_read_init(src,&src_seg,src_state)){
count++;
lts_write_init(dst,src_seg,src_state);
}
Print(infoLong,"%d initial state(s)",count);
}
for(int i=0;i<lts_file_owned_count(src);i++){
src_seg=lts_file_owned(src,i);
dst_seg=lts_file_owned(src,i);
if (do_state) {
Print(infoLong,"copying states of segment %d",src_seg);
uint32_t state_labels[N2];
while(lts_read_state(src,&src_seg,src_state,state_labels)){
lts_write_state(dst,src_seg,src_state,state_labels);
}
}
Print(infoLong,"copying edges of segment %d",src_seg);
while(lts_read_edge(src,&src_seg,src_state,&dst_seg,dst_state,edge_labels)){
lts_write_edge(dst,src_seg,src_state,dst_seg,dst_state,edge_labels);
}
}
Print(infoLong,"done");
}
void
mark_predicate (model_t m, ltsmin_expr_t e, int *dep, ltsmin_parse_env_t env)
{
if (!e) return;
switch(e->node_type) {
case BINARY_OP:
mark_predicate(m,e->arg1,dep,env);
mark_predicate(m,e->arg2,dep,env);
break;
case UNARY_OP:
mark_predicate(m,e->arg1,dep,env);
break;
default:
switch(e->token) {
case PRED_TRUE:
case PRED_FALSE:
case PRED_NUM:
case PRED_VAR:
case PRED_CHUNK:
break;
case PRED_EQ:
mark_predicate(m,e->arg1, dep,env);
mark_predicate(m,e->arg2, dep,env);
break;
case PRED_SVAR: {
lts_type_t ltstype = GBgetLTStype(m);
int N = lts_type_get_state_length (ltstype);
if (e->idx < N) { // state variable
dep[e->idx] = 1;
} else { // state label
HREassert (e->idx < N + lts_type_get_state_label_count(ltstype));
matrix_t *sl = GBgetStateLabelInfo (m);
HREassert (N == dm_ncols(sl));
for (int i = 0; i < N; i++) {
if (dm_is_set(sl, e->idx - N, i)) dep[i] = 1;
}
}
break;
}
default:
LTSminLogExpr (error, "Unhandled predicate expression: ", e, env);
HREabort (LTSMIN_EXIT_FAILURE);
}
break;
}
}
void lts_write(char *name,lts_t lts,string_set_t filter,int segments){
int format=lts_guess_format(name);
lts_type_t ltstype=lts->ltstype;
switch(format){
case LTS_IMCA:
lts_write_imca(name,lts);
break;
case LTS_TRA:
lts_write_tra(name,lts);
break;
case LTS_PG:
lts_write_pg(name,lts);
break;
case LTS_DIR:
if (lts_type_get_state_length(ltstype)==0
&& lts_type_get_state_label_count(ltstype)==0
&& lts_type_get_edge_label_count(ltstype)==1
){
archive_t archive=arch_dir_create(name,65536,DELETE_ALL);
lts_write_dir(archive,NULL,lts,segments);
arch_close(&archive);
break;
} else // fall through
default: {
lts_file_t src=lts_reader(lts,segments,NULL);
lts_file_t dst;
if (filter==NULL){
dst=lts_file_create(name,lts->ltstype,segments,src);
} else {
dst=lts_file_create_filter(name,lts->ltstype,filter,segments,src);
}
int T=lts_type_get_type_count(lts->ltstype);
for(int i=0;i<T;i++){
if (lts->values[i]) lts_file_set_table(dst,i,lts->values[i]);
}
lts_file_copy(src,dst);
lts_file_close(src);
lts_file_close(dst);
break;
}
}
}
static void
output_lbls(FILE *tbl_file, vset_t visited)
{
matrix_t *sl_info = GBgetStateLabelInfo(model);
nGuards = dm_nrows(sl_info);
if (dm_nrows(sl_info) != lts_type_get_state_label_count(ltstype))
Warning(error, "State label count mismatch!");
for (int i = 0; i < nGuards; i++){
int len = dm_ones_in_row(sl_info, i);
int used[len];
// get projection
for (int pi = 0, pk = 0; pi < dm_ncols (sl_info); pi++) {
if (dm_is_set (sl_info, i, pi))
used[pk++] = pi;
}
vset_t patterns = vset_create(domain, len, used);
map_context ctx;
vset_project(patterns, visited);
ctx.tbl_file = tbl_file;
ctx.mapno = i;
ctx.len = len;
ctx.used = used;
fprintf(tbl_file, "begin map ");
fprint_ltsmin_ident(tbl_file, lts_type_get_state_label_name(ltstype,i));
fprintf(tbl_file, ":");
fprint_ltsmin_ident(tbl_file, lts_type_get_state_label_type(ltstype,i));
fprintf(tbl_file,"\n");
vset_enum(patterns, enum_map, &ctx);
fprintf(tbl_file, "end map\n");
vset_destroy(patterns);
}
}
int main(int argc, char *argv[]){
char* files[2];
HREinitBegin(argv[0]);
HREaddOptions(options,"Tool for transforming labeled transition systems\n\nOptions");
lts_lib_setup();
HREinitStart(&argc,&argv,1,2,files,"<input> [<output>]");
int me=HREme(HREglobal());
int peers=HREpeers(HREglobal());
if (peers>1) Abort("parallelizing this tool is future work");(void)me;
string_set_t label_set=NULL;
if (label_filter!=NULL){
label_set=SSMcreateSWPset(label_filter);
}
switch(task){
case Undefined:
Abort("task unspecified");
case LTScopy:
if (files[1]==NULL) Abort("second argument required for copy.");
Print(infoShort,"streaming copy from %s to %s",files[0],files[1]);
lts_file_t in=lts_file_open(files[0]);
lts_type_t ltstype=lts_file_get_type(in);
rd_seg=lts_file_get_segments(in);
if (wr_seg==0) {
wr_seg=rd_seg;
} else {
Abort("on-the-fly changing the number of segments is future work");
}
lts_file_t out;
if (label_set==NULL){
out=lts_file_create(files[1],ltstype,wr_seg,in);
} else {
out=lts_file_create_filter(files[1],ltstype,label_set,wr_seg,in);
}
int N=lts_type_get_type_count(ltstype);
for(int i=0;i<N;i++){
char*name=lts_type_get_type(ltstype,i);
switch(lts_type_get_format(ltstype,i)){
case LTStypeDirect:
case LTStypeRange:
Debug("integer type %s does not use tables",name);
break;
case LTStypeChunk:
case LTStypeEnum:
Debug("creating table for type %s",name);
value_table_t tmp=chunk_table_create(NULL,name);
Debug("set in %s",name);
lts_file_set_table(in,i,tmp);
Debug("set out %s",name);
lts_file_set_table(out,i,tmp);
break;
}
}
lts_file_copy(in,out);
lts_file_close(out);
lts_file_close(in);
break;
case LTSrdwr:
if (files[1]==NULL) Abort("second argument required for rdwr.");
Print(infoShort,"loading from %s",files[0]);
lts_t lts=lts_create();
lts_read(files[0],lts);
if (encode) {
Print(infoShort,"single edge label encoding");
lts=lts_encode_edge(lts);
}
if (bfs_reorder) {
Print(infoShort,"reindexing LTS in BFS order");
lts_bfs_reorder(lts);
}
Print(infoShort,"storing in %s",files[1]);
if(wr_seg==0) wr_seg=1;
lts_write(files[1],lts,label_set,wr_seg);
break;
case LTSindex:{
if (peers>1) Abort("parallelizing this tool is future work");
if (files[1]==NULL) Abort("second argument required for index.");
Print(infoShort,"opening %s",files[0]);
lts_file_t in=lts_file_open(files[0]);
lts_type_t ltstype=lts_file_get_type(in);
int segments=lts_file_get_segments(in);
lts_file_t settings=lts_get_template(in);
if (lts_file_get_edge_owner(settings)!=SourceOwned) Abort("bad edge owner");
lts_file_set_dest_mode(settings,Index);
lts_file_set_init_mode(settings,Index);
Print(infoShort,"creating %s",files[1]);
lts_file_t out=lts_file_create(files[1],ltstype,segments,settings);
int N=lts_type_get_type_count(ltstype);
for(int i=0;i<N;i++){
char*name=lts_type_get_type(ltstype,i);
switch(lts_type_get_format(ltstype,i)){
case LTStypeDirect:
case LTStypeRange:
Debug("integer type %s does not use tables",name);
break;
case LTStypeChunk:
case LTStypeEnum:
Debug("creating table for type %s",name);
value_table_t tmp=chunk_table_create(NULL,name);
Debug("set in %s",name);
lts_file_set_table(in,i,tmp);
Debug("set out %s",name);
lts_file_set_table(out,i,tmp);
break;
}
}
treedbs_t db[segments];
int SV=lts_type_get_state_length(ltstype);
int SL=lts_type_get_state_label_count(ltstype);
int K=lts_type_get_edge_label_count(ltstype);
for(int i=0;i<segments;i++){
Print(info,"loading and copying states of segment %d",i);
uint32_t state[SV];
uint32_t label[SL];
db[i]=TreeDBScreate(SV);
int idx=0;
while(lts_read_state(in,&i,state,label)){
int tmp=TreeFold(db[i],(int*)state);
if (idx!=tmp){
Abort("unexpected index %u != %u",tmp,idx);
}
idx++;
lts_write_state(out,i,(int*)state,label);
}
}
Print(info,"converting initial states");
{
uint32_t seg;
uint32_t state[SV];
while(lts_read_init(in,(int*)&seg,state)){
int idx=TreeFold(db[seg],(int*)state);
lts_write_init(out,seg,&idx);
}
}
for(int i=0;i<segments;i++){
Print(info,"converting edges of segment %d",i);
uint32_t src_state[1];
uint32_t dst_seg;
uint32_t dst_state[SV];
uint32_t label[K];
while(lts_read_edge(in,&i,src_state,(int*)&dst_seg,dst_state,label)){
int idx=TreeFold(db[dst_seg],(int*)dst_state);
lts_write_edge(out,i,src_state,dst_seg,&idx,label);
}
}
lts_file_close(out);
lts_file_close(in);
}
}
Print(infoShort,"done");
HREexit(LTSMIN_EXIT_SUCCESS);
}
int main(int argc, char *argv[]){
char *files[2];
RTinitPopt(&argc,&argv,options,1,2,files,NULL,"<model> [<lts>]",
"Perform an enumerative reachability analysis of <model>\n"
"Run the TorX remote procedure call protocol on <model> (--torx).\n\n"
"Options");
if (files[1]) {
Warning(info,"Writing output to %s",files[1]);
write_lts=1;
} else {
Warning(info,"No output, just counting the number of states");
write_lts=0;
}
if (application==RunTorX && write_lts) Fatal(1,error,"A TorX server does not write to a file");
Warning(info,"loading model from %s",files[0]);
model_t model=GBcreateBase();
GBsetChunkMethods(model,new_string_index,NULL,
(int2chunk_t)SIgetC,(chunk2int_t)SIputC,(get_count_t)SIgetCount);
GBloadFile(model,files[0],&model);
if (RTverbosity >=2) {
fprintf(stderr,"Dependency Matrix:\n");
GBprintDependencyMatrix(stderr,model);
}
if (matrix) {
GBprintDependencyMatrix(stdout,model);
exit(0);
}
lts_type_t ltstype=GBgetLTStype(model);
N=lts_type_get_state_length(ltstype);
edge_info_t e_info=GBgetEdgeInfo(model);
K=e_info->groups;
Warning(info,"length is %d, there are %d groups",N,K);
state_labels=lts_type_get_state_label_count(ltstype);
edge_labels=lts_type_get_edge_label_count(ltstype);
Warning(info,"There are %d state labels and %d edge labels",state_labels,edge_labels);
if (state_labels&&write_lts&&!write_state) {
Fatal(1,error,"Writing state labels, but not state vectors unsupported. "
"Writing of state vector is enabled with the option --write-state");
}
int src[N];
GBgetInitialState(model,src);
Warning(info,"got initial state");
int level=0;
switch(application){
case ReachVset:
domain=vdom_create_default(N);
visited_set=vset_create(domain,0,NULL);
next_set=vset_create(domain,0,NULL);
if (write_lts){
output=lts_output_open(files[1],model,1,0,1,"viv",NULL);
lts_output_set_root_vec(output,(uint32_t*)src);
lts_output_set_root_idx(output,0,0);
output_handle=lts_output_begin(output,0,0,0);
}
vset_add(visited_set,src);
vset_add(next_set,src);
vset_t current_set=vset_create(domain,0,NULL);
while (!vset_is_empty(next_set)){
if (RTverbosity >= 1)
Warning(info,"level %d has %d states, explored %d states %d trans",
level,(visited-explored),explored,trans);
level++;
vset_copy(current_set,next_set);
vset_clear(next_set);
vset_enum(current_set,explore_state_vector,model);
}
long long size;
long nodes;
vset_count(visited_set,&nodes,&size);
Warning(info,"%lld reachable states represented symbolically with %ld nodes",size,nodes);
break;
case ReachTreeDBS:
dbs=TreeDBScreate(N);
if(TreeFold(dbs,src)!=0){
Fatal(1,error,"expected 0");
}
if (write_lts){
output=lts_output_open(files[1],model,1,0,1,write_state?"vsi":"-ii",NULL);
if (write_state) lts_output_set_root_vec(output,(uint32_t*)src);
lts_output_set_root_idx(output,0,0);
output_handle=lts_output_begin(output,0,0,0);
}
int limit=visited;
while(explored<visited){
if (limit==explored){
if (RTverbosity >= 1)
Warning(info,"level %d has %d states, explored %d states %d trans",
level,(visited-explored),explored,trans);
limit=visited;
level++;
}
TreeUnfold(dbs,explored,src);
explore_state_index(model,explored,src);
}
break;
case RunTorX:
{
torx_struct_t context = { model, ltstype };
torx_ui(&context);
return 0;
}
}
if (write_lts){
lts_output_end(output,output_handle);
Warning(info,"finishing the writing");
lts_output_close(&output);
Warning(info,"state space has %d levels %d states %d transitions",level,visited,trans);
} else {
printf("state space has %d levels %d states %d transitions\n",level,visited,trans);
}
return 0;
}
void CAESAR_INIT_GRAPH(void) {
char *opencaesar_args, *opencaesar_prog,*ltsmin_options;
int argc;
char **argv;
opencaesar_prog = getenv ("OPEN_CAESAR_PROG");
if (opencaesar_prog == NULL)
CAESAR_ERROR ("undefined environment variable $OPEN_CAESAR_PROG");
opencaesar_args = getenv ("OPEN_CAESAR_FILE");
if (opencaesar_args == NULL)
CAESAR_ERROR ("undefined environment variable $OPEN_CAESAR_FILE");
ltsmin_options = getenv ("LTSMIN_OPTIONS");
if (ltsmin_options == NULL)
CAESAR_ERROR ("undefined environment variable $LTSMIN_OPTIONS");
int len=strlen(opencaesar_prog)+strlen(ltsmin_options)+strlen(opencaesar_args);
char cmdline[len+6];
sprintf(cmdline,"%s %s %s",opencaesar_prog,ltsmin_options,opencaesar_args);
int res=poptParseArgvString(cmdline,&argc,(void*)(&argv));
if (res){
Abort("could not parse %s: %s",opencaesar_args,poptStrerror(res));
}
char *files[2];
HREinitBegin(argv[0]);
HREaddOptions(options,"Options");
HREinitStart(&argc,&argv,1,1,(char**)files,"<model>");
Warning(info,"loading model from %s",files[0]);
model=GBcreateBase();
GBsetChunkMethods(model,new_string_index,NULL,
(int2chunk_t)SIgetC,
(chunk2int_t)SIputC,
(chunkatint_t)SIputCAt,
(get_count_t)SIgetCount);
GBloadFile(model,files[0],&model);
ltstype=GBgetLTStype(model);
N = lts_type_get_state_length(ltstype);
K = dm_nrows(GBgetDMInfo(model));
Warning(info,"length is %d, there are %d groups",N,K);
state_labels=lts_type_get_state_label_count(ltstype);
edge_labels=lts_type_get_edge_label_count(ltstype);
Warning(info,"There are %d state labels and %d edge labels",state_labels,edge_labels);
if (edge_encode){
edge_size=edge_labels+N+state_labels;
Warning(info,"encoding state information on edges");
} else {
edge_size=edge_labels;
Warning(info,"state information is hidden");
}
CAESAR_HINT_SIZE_STATE = N*sizeof(int);
CAESAR_HINT_HASH_SIZE_STATE = CAESAR_HINT_SIZE_STATE;
CAESAR_HINT_SIZE_LABEL = edge_size*sizeof(int);
CAESAR_HINT_HASH_SIZE_LABEL = CAESAR_HINT_SIZE_LABEL;
Warning(info,"CAESAR_HINT_SIZE_STATE=%lu CAESAR_HINT_SIZE_LABEL=%lu",
(unsigned long)CAESAR_HINT_SIZE_STATE,(unsigned long)CAESAR_HINT_SIZE_LABEL);
}
int SLTSsegmentNumber(seg_lts_t lts){
return lts->seg_no;
}
hre_task_queue_t SLTSgetQueue(seg_lts_t lts){
return lts->task_queue;
}
seg_lts_t SLTScreate(lts_type_t signature,hre_task_queue_t task_queue,seg_lts_layout_t layout){
seg_lts_t lts=RT_NEW(struct seg_lts_s);
lts->sig=signature;
lts->task_queue=task_queue;
lts->seg_no=HREme(TQcontext(task_queue));
lts->seg_count=HREpeers(TQcontext(task_queue));
lts->state_length=lts_type_get_state_length(signature);
lts->state_labels=lts_type_get_state_label_count(signature);
lts->edge_labels=lts_type_get_edge_label_count(signature);
lts->layout=layout;
lts->vt_count=lts_type_get_type_count(signature);
lts->vt=RTmalloc(lts->vt_count*sizeof(value_table_t));
for(int i=0;i<lts->vt_count;i++) {
char *type_name=lts_type_get_type(signature,i);
lts->vt[i]=HREcreateTable(TQcontext(task_queue),type_name);
}
return lts;
}
int SLTSstateCount(seg_lts_t lts){
return lts->state_count;
}
void lts_write_pg (const char*name, lts_t lts) {
Print(infoShort,"writing %s",name);
FILE* f=fopen(name,"w");
if (f == NULL) {
AbortCall("Could not open %s for writing",name);
}
lts_set_type(lts,LTS_BLOCK);
//int N=lts_type_get_state_length(lts->ltstype);
int L=lts_type_get_state_label_count(lts->ltstype);
//int K=lts_type_get_edge_label_count(lts->ltstype);
if (L != 2){
Abort("Number of state labels is %d, needs to be 2 for parity games.",L);
}
Warning(info,"Number of states: %d", lts->states);
Warning(info,"First pass...");
// compute max priority
// determine if there are nodes without successors
int max_priority = 0;
int labels[L];
bool first_edge = true;
bool write_true = false;
bool write_false = false;
for(uint32_t src_idx=0; src_idx<lts->states; src_idx++){
TreeUnfold(lts->prop_idx, lts->properties[src_idx], labels);
int priority = labels[PG_PRIORITY];
if (priority > max_priority) {
max_priority = priority;
}
int player = labels[PG_PLAYER];
if (lts->begin[src_idx] >= lts->begin[src_idx+1]){
// no edges
if (player==PG_AND) {
write_true = true;
} else if (player==PG_OR) {
write_false = true;
}
//Warning(info, "State %d has no successors.",src_idx);
}
}
if (max_priority%2!=0)
{
// when converting from min to max-priority game,
// the maximum priority should be even.
max_priority++;
}
Warning(info,"Second pass...");
bool min_game = false;
int max_id = lts->states;
int offset = 0;
int true_idx = 0;
int false_idx = 0;
if (write_true) {
true_idx = max_id;
max_id++;
}
if (write_false) {
false_idx = max_id;
max_id++;
}
// write header.
fprintf(f,"parity %d;\n",max_id-1);
// write states and edges
for(uint32_t src_idx=0; src_idx<lts->states; src_idx++){
if (src_idx > 0){
fprintf(f,";\n");
}
TreeUnfold(lts->prop_idx, lts->properties[src_idx], labels);
int priority = min_game ? labels[PG_PRIORITY] : max_priority-labels[PG_PRIORITY];
int player = labels[1];
fprintf(f, "%d %d %d ", src_idx+offset, priority /* priority */, player /* player */);
first_edge = true;
for(uint32_t edge_idx=lts->begin[src_idx]; edge_idx<lts->begin[src_idx+1]; edge_idx++){
if (!first_edge){
fprintf(f, ",");
}
fprintf(f,"%d",lts->dest[edge_idx]+offset);
first_edge = false;
}
if (first_edge)
{
//Warning(info,"State %d has no successors.",src_idx);
// add transition to true/false node
fprintf(f,"%d",((player==PG_AND) ? true_idx : false_idx));
}
}
fprintf(f,";\n");
// write true and false
if (write_true)
{
fprintf(f, "%d %d %d ", true_idx, min_game ? 0 : max_priority /* priority */, PG_AND /* player */);
fprintf(f,"%d;\n",true_idx);
}
if (write_false)
{
fprintf(f, "%d %d %d ", false_idx, min_game ? 1 : max_priority-1 /* priority */, PG_OR /* player */);
fprintf(f,"%d;\n",false_idx);
}
fclose(f);
}
