Exemplo n.º 1
0
ATermList get_imports(ATermList decls)
{
  ATerm decl, mod, spec;
  ATermList mods, new_decls;
  
  new_decls = ATmakeList0();
  while(!ATisEmpty(decls)) {
    decl = ATgetFirst(decls);
    decls = ATgetNext(decls);
    if(ATmatch(decl, "Imports([<list>])", &mods)) {
	while(!ATisEmpty(mods)) {
	    mod = ATgetFirst(mods);
	    mods = ATgetNext(mods);
	    if(ATindexOf(imported, mod, 0) == -1) 
	      {
		if(!silent)
		  ATfprintf(stderr, "        importing: %t\n", mod);
		imported = ATinsert(imported, mod);
		sprintf(file_name, "%s.r", t_string(mod));
		spec = parse_file(file_name);
		new_decls = ATconcat(spec_decls(spec), new_decls);
	    }
	    else
	      {
		if(!silent)
		  ATfprintf(stderr, "        importing: %t (done)\n", mod);
	      }
	}
    } else {
	new_decls = ATinsert(new_decls, decl);
    }
  }
  return new_decls;
}
Exemplo n.º 2
0
ATermList procAbstraction(ATermList procArgs){
	ATerm procArg, newTerm, par, parSort, parName;
	ATermList newProcArgs = ATmakeList0();	
	ATermList pars = MCRLgetListOfPars();
	ATerm termSort;
		
	for (;!ATisEmpty(procArgs); 
			procArgs = ATgetNext(procArgs), pars = ATgetNext(pars)) { 
		procArg = ATgetFirst(procArgs);	
		par = ATgetFirst(pars);
		parSort = (ATerm) ATgetArgument((ATermAppl) par, 1);
		parName = (ATerm) ATgetArgument((ATermAppl) par, 0);
		newTerm = termAbstraction(procArg, parSort);	
		
		termSort = getTermSort(newTerm);
		

		if(isAbstracted(termSort) && !isAbstracted(parSort)){
			if(!isLifted(termSort)){
				newTerm = createSingTerm(newTerm, liftSort(termSort));
				termSort = liftSort(termSort);
			}
			newTerm = createGammaTerm(newTerm, termSort);
			if(-1 == ATindexOf(conflictingPars, parName , 0))
				conflictingPars = ATappend(conflictingPars, parName);
		}
					
		newProcArgs = ATappend(newProcArgs, newTerm);
	}
	return newProcArgs;	
}
Exemplo n.º 3
0
static void writeAnnotatedNode(A2PWriter writer, A2PType expected, ATermAppl node, ATermList annotations){
	A2PNodeType t = (A2PNodeType) expected->theType;
	
	AFun fun = ATgetAFun(node);
	int arity = ATgetArity(fun);
	char *name = ATgetName(fun);
	int nrOfAnnotations = ATgetLength(annotations);
	int i;
	ATerm annotationLabel;
	ATerm annotationValue;
	
	unsigned int hash = hashString(name);
	int nodeNameId = ISstore(writer->nameSharingMap, (void*) name, hash);
	if(nodeNameId == -1){
		int nameLength = dataArraySize(name);
		
		writeByteToBuffer(writer->buffer, PDB_ANNOTATED_NODE_HEADER);
		
		printInteger(writer->buffer, nameLength);
		writeDataToBuffer(writer->buffer, name, nameLength);
	}else{
		writeByteToBuffer(writer->buffer, PDB_ANNOTATED_NODE_HEADER | PDB_NAME_SHARED_FLAG);
	
		printInteger(writer->buffer, nodeNameId);
	}
	
	printInteger(writer->buffer, arity);
	
	for(i = 0; i < arity; i++){
		doSerialize(writer, A2PvalueType(), ATgetArgument(node, i));
	}
	
	/* Annotations. */
	if((nrOfAnnotations % 2) == 1){ fprintf(stderr, "Detected corrupt annotations (Unbalanced).\n"); exit(1); }
	
	printInteger(writer->buffer, nrOfAnnotations);
	
	do{
		char *label;
		int labelLength;
		A2PType annotationType;
		
		annotationLabel = ATgetFirst(annotations);
		annotations = ATgetNext(annotations);
		annotationValue = ATgetFirst(annotations);
		annotations = ATgetNext(annotations);
		
		if(ATgetType(annotationLabel) != AT_APPL){ fprintf(stderr, "Detected corrupt annotation; label term is not a 'string'.\n"); exit(1); }
		
		label = ATgetName(ATgetAFun((ATermAppl) annotationLabel));
		labelLength = dataArraySize(label);
		
		printInteger(writer->buffer, labelLength);
		writeDataToBuffer(writer->buffer, label, labelLength);
		
		annotationType = (A2PType) HTget(t->declaredAnnotations, (void*) label, hashString(label));
		doSerialize(writer, annotationType, annotationValue);
	}while(!ATisEmpty(annotations));
}
Exemplo n.º 4
0
void abstractVars(){	
	ATermList newSums, sums = MCRLgetListOfSummands();
	ATermList vars, newVars;
	ATerm proc, sum; 
	ATerm var, varSort, varName, oldVarSort;
		
	proc = MCRLgetProc();
	newSums = ATmakeList0();
	
	for(;!ATisEmpty(sums); sums= ATgetNext(sums)){
		sum = ATgetFirst(sums);	
		vars = (ATermList) ATgetArgument((ATermAppl) sum ,0);
		newVars = ATmakeList0();

		for(;!ATisEmpty(vars);  vars= ATgetNext(vars)){
			var = (ATerm) ATgetFirst(vars);
		   varName = (ATerm) ATgetArgument((ATermAppl) var, 0);
		   varSort = (ATerm) ATgetArgument((ATermAppl) var, 1);
		
			oldVarSort = ATtableGet(var_tab, varName);
			
			if(oldVarSort != NULL)
				if(varSort != getConcrete(oldVarSort)){
				PP("Variable "); ppTerm(varName);
				PP(" appears with two different types, ");
				ppTerm(varSort); PP(" and "); pTerm(oldVarSort);
				P("please modify the specification");
				exit(-1);
			}
		
		
			if(toAbstractVar(varName)){
				varSort = abstractSort(varSort);
			}
			if(toAbstractSort(varSort)){
				varSort = abstractSort(varSort);
			}
			if(!toAbstractSort(varSort) && BUT_SORT){
				varSort = getConcrete(varSort);
			}
			
			
			ATtablePut(var_tab, varName, varSort);
			
			var = (ATerm) ATsetArgument((ATermAppl) var, varSort, 1);
			newVars = ATinsert(newVars, var);		

		}
		sum = (ATerm) ATsetArgument((ATermAppl) sum, 
				(ATerm) ATreverse(newVars), 0);
		newSums = ATinsert(newSums, sum);
	}
	
	proc = (ATerm) ATsetArgument((ATermAppl) proc, 
					(ATerm)ATreverse(newSums), 2);

	MCRLsetProc(proc);
}
Exemplo n.º 5
0
static void writeAnnotatedConstructor(A2PWriter writer, A2PType expected, ATermAppl constructor, ATermList annotations){
	A2PConstructorType t = (A2PConstructorType) expected->theType;
	
	ISIndexedSet sharedTypes = writer->typeSharingMap;
	int typeHash = hashType(expected);
	int constructorTypeId = ISget(sharedTypes, (void*) expected, typeHash);
	int arity = ATgetArity(ATgetAFun(constructor));
	int nrOfAnnotations = ATgetLength(annotations);
	int i;
	ATerm annotationLabel;
	ATerm annotationValue;
	
	if(constructorTypeId == -1){
		writeByteToBuffer(writer->buffer, PDB_ANNOTATED_CONSTRUCTOR_HEADER);
		
		doWriteType(writer, expected);
		
		ISstore(sharedTypes, (void*) expected, typeHash);
	}else{
		writeByteToBuffer(writer->buffer, PDB_ANNOTATED_CONSTRUCTOR_HEADER | PDB_TYPE_SHARED_FLAG);
		
		printInteger(writer->buffer, constructorTypeId);
	}
	
	printInteger(writer->buffer, arity);
	
	for(i = 0; i < arity; i++){
		doSerialize(writer, ((A2PTupleType) t->children->theType)->fieldTypes[i], ATgetArgument(constructor, i));
	}
	
	/* Annotations. */
	if((nrOfAnnotations % 2) == 1){ fprintf(stderr, "Detected corrupt annotations (Unbalanced).\n"); exit(1); }
	
	printInteger(writer->buffer, nrOfAnnotations);
	
	do{
		char *label;
		int labelLength;
		A2PType annotationType;
		
		annotationLabel = ATgetFirst(annotations);
		annotations = ATgetNext(annotations);
		annotationValue = ATgetFirst(annotations);
		annotations = ATgetNext(annotations);
		
		if(ATgetType(annotationLabel) != AT_APPL){ fprintf(stderr, "Detected corrupt annotation; label term is not a 'string'.\n"); exit(1); }
		
		label = ATgetName(ATgetAFun((ATermAppl) annotationLabel));
		labelLength = dataArraySize(label);
		
		printInteger(writer->buffer, labelLength);
		writeDataToBuffer(writer->buffer, label, labelLength);
		
		annotationType = (A2PType) HTget(t->declaredAnnotations, (void*) label, hashString(label));
		doSerialize(writer, annotationType, annotationValue);
	}while(!ATisEmpty(annotations));
}
Exemplo n.º 6
0
ATermList ofp_coalesceTypeTable(ATermList oldTable)
{
   // Assumes:
   //  1. Contains list of terms Type(<str>,<list>) or OptType(<str>,<list>)
   //      a. <str> is type name
   //      b. <list> is [type] of length 1
   //  2. Portions of table to be coalesced are in order
   //  3. If OptType must match "(Some(<term>))"
   //
   ATerm head;
   int isOptType;

   ATermList table = (ATermList) ATmake("[]");
   ATermList types = (ATermList) ATmake("[]");
   ATermList tail  = (ATermList) ATmake("<term>", oldTable);

   if (ATisEmpty(tail)) {
      return oldTable;
   }

   head = ATgetFirst(tail);
   tail = ATgetNext(tail);

   while (1) {
      ATerm headName, headType, next, nextName, nextType;

      if (ATisEmpty(tail)) next = ATmake("Type(None,[None])");
      else                 next = ATgetFirst(tail);

      if      ( ATmatch(head, "Type(<term>,[<term>])",    &headName, &headType) ) isOptType = 0;
      else if ( ATmatch(head, "OptType(<term>,[<term>])", &headName, &headType) ) isOptType = 1;
      else assert(0); 

      assert(    ATmatch(next, "Type(<term>,[<term>])",    &nextName, &nextType)
              || ATmatch(next, "OptType(<term>,[<term>])", &nextName, &nextType)
            );

      types = ATappend(types, headType);

      // check for need to coalesce
      if (! ATisEqual(headName, nextName)) {
         if (isOptType) {
            table = ATappend((ATermList)table, ATmake("OptType(<term>,<term>)", headName, types));
         } else {
            table = ATappend((ATermList)table, ATmake(   "Type(<term>,<term>)", headName, types));
         }
         types = (ATermList) ATmake("[]");
         if (ATisEmpty(tail)) break;
      }

      head = ATgetFirst(tail);
      tail = ATgetNext(tail);
   }

   return table;
}
Exemplo n.º 7
0
SS_Table getTableSnapshot(TableEntry table)
{
  ATermList pairs = T_getAllKeyValuePairs(table.table);
  SS_Rows rows = SS_makeRowsEmpty();
 
  for( ;!ATisEmpty(pairs); pairs = ATgetNext(pairs)) {
    ATerm pair = ATgetFirst(pairs);
    ATerm key = ATgetFirst((ATermList) pair);
    ATerm value = ATgetFirst(ATgetNext((ATermList) pair));
    SS_Row row = SS_makeRowDefault(key,value);
    rows = SS_makeRowsMany(row, rows);
  }

  return SS_makeTableDefault(table.name, table.valueType, rows); 
}
Exemplo n.º 8
0
static void generateHeader(FILE *file, ATermList terms, ATermList afuns)
{
  if (opt_gen_date) {
    time_t now = time(NULL);
    fprintf(file, "/*\n * Generated at %s", ctime(&now));
    fprintf(file, " */\n\n");
  }

  fprintf(file, "#ifndef __%s_H\n", code_prefix);
  fprintf(file, "#define __%s_H\n\n", code_prefix);
  fprintf(file, "#include <aterm2.h>\n\n");
  fprintf(file, "#include <assert.h>\n\n");

  while (!ATisEmpty(afuns)) {
    ATerm afun, alias, pair = ATgetFirst(afuns);
    afuns = ATgetNext(afuns);

    if (!ATmatch(pair, "[<term>,<term>]", &alias, &afun)) {
      ATfprintf(stderr, "malformed [alias,afun] pair: %t\n", pair);
      exit(1);
    }

    checkAlias(alias);
    checkAFun(afun);

    ATfprintf(file, "extern AFun %t;\n", alias);
  }

  fprintf(file, "\n");

  while (!ATisEmpty(terms)) {
    ATerm term, alias, pair = ATgetFirst(terms);
    terms = ATgetNext(terms);

    if (!ATmatch(pair, "[<term>,<term>]", &alias, &term)) {
      ATfprintf(stderr, "malformed [alias,term] pair: %t\n", pair);
      exit(1);
    }

    checkAlias(alias);

    ATfprintf(file, "extern ATerm %t;\n", alias);
  }

  fprintf(file, "\nextern void init_%s();\n", code_prefix);

  fprintf(file, "\n#endif /* __%s_H */\n", code_prefix);
}
Exemplo n.º 9
0
static void writeRelation(A2PWriter writer, A2PType expected, ATermList relation){
	A2PRelationType relationType = (A2PRelationType) expected->theType;
	
	A2PType tupleType = relationType->tupleType;
	ISIndexedSet sharedTypes = writer->typeSharingMap;
	int tupleHash = hashType(tupleType);
	int tupleTypeId = ISget(sharedTypes, (void*) tupleType, tupleHash);
	int size = ATgetLength(relation);
	ATermList next;
	
	if(tupleTypeId == -1){
		writeByteToBuffer(writer->buffer, PDB_RELATION_HEADER);
		
		doWriteType(writer, tupleType);
		
		ISstore(sharedTypes, (void*) tupleType, tupleHash);
	}else{
		writeByteToBuffer(writer->buffer, PDB_RELATION_HEADER | PDB_TYPE_SHARED_FLAG);
		
		printInteger(writer->buffer, tupleTypeId);
	}
	
	printInteger(writer->buffer, size);
	next = relation;
	while(!ATisEmpty(next)){
		ATerm current = ATgetFirst(next);
		next = ATgetNext(next);
		
		doSerialize(writer, tupleType, current);
	}
}
//========================================================================================
// SgUntypedInitializedNameList
//----------------------------------------------------------------------------------------
ATbool traverse_SgUntypedInitializedNameList(ATerm term, SgUntypedInitializedNameList** var_SgUntypedInitializedNameList)
{
#ifdef PRINT_ATERM_TRAVERSAL
  printf("... traverse_SgUntypedInitializedNameList: %s\n", ATwriteToString(term));
#endif

  ATerm term1;
  
  *var_SgUntypedInitializedNameList = NULL;
  if (ATmatch(term, "SgUntypedInitializedNameList(<term>)", &term1)) {
     SgUntypedInitializedNameList* plist = new SgUntypedInitializedNameList();

     ATermList tail = (ATermList) ATmake("<term>", term1);
     while (! ATisEmpty(tail)) {
        SgUntypedInitializedName* arg;
        ATerm head = ATgetFirst(tail);
        tail = ATgetNext(tail);

        if (traverse_SgUntypedInitializedName(head, (SgUntypedInitializedName**) &arg)) {
           // SgUntypedInitializedName
           plist->get_name_list().push_back(arg);
           continue;
        }

        delete plist;
        return ATfalse;
     }
     *var_SgUntypedInitializedNameList = plist;
  }
  else return ATfalse;
  // turn on build functions (using BuildStmt) in sage-to-traverse.str

  return ATtrue;
}
Exemplo n.º 11
0
void specAbstraction(){	
	ATermList inits;
	ATermList newSums, sums;
	int i;
	ATerm proc, sum, var, varName, parName, par;
	ATermList vars, pars, newVars, newPars;
	
	proc = MCRLgetProc();
	
	P("Specification Abstraction");	
	
	inits = MCRLgetListOfInitValues();
	inits = initAbstraction(inits);
	proc = (ATerm) ATsetArgument((ATermAppl)proc, (ATerm) inits, 0);
	MCRLsetProc(proc);
	
	newSums = ATmakeList0();
	sums = MCRLgetListOfSummands();
	for(nSum = 1; !ATisEmpty(sums); sums= ATgetNext(sums), nSum++){ 
		sum = ATgetFirst(sums);	
	 	sum = sumAbstraction(sum);
		newSums = ATinsert(newSums, sum);
		fprintf(stderr,".");
	}
		
	proc = (ATerm) ATsetArgument((ATermAppl) proc, 
						(ATerm) newSums, 2);
	MCRLsetProc(proc);
	
	fprintf(stderr,"\n");
}
Exemplo n.º 12
0
static void writeSet(A2PWriter writer, A2PType expected, ATermList set){
	A2PSetType setType = (A2PSetType) expected->theType;
	
	A2PType elementType = setType->elementType;
	ISIndexedSet sharedTypes = writer->typeSharingMap;
	int elementHash = hashType(elementType);
	int elementTypeId = ISget(sharedTypes, (void*) elementType, elementHash);
	int size = ATgetLength(set);
	ATermList next;
	
	if(elementTypeId == -1){
		writeByteToBuffer(writer->buffer, PDB_SET_HEADER);
		
		doWriteType(writer, elementType);
		
		ISstore(sharedTypes, (void*) elementType, elementHash);
	}else{
		writeByteToBuffer(writer->buffer, PDB_SET_HEADER | PDB_TYPE_SHARED_FLAG);
		
		printInteger(writer->buffer, elementTypeId);
	}
	
	printInteger(writer->buffer, size);
	next = set;
	while(!ATisEmpty(next)){
		ATerm current = ATgetFirst(next);
		next = ATgetNext(next);
		
		doSerialize(writer, elementType, current);
	}
}
Exemplo n.º 13
0
/* For all non-terminals which are to the right of the dot in |item|, add 
 * that non-terminal's items to the set of |items| if they do not already 
 * exist. Note that only items that do not cause a priority conflict are 
 * added to the predicted items. */
static ATermList predict(Item item, ATermList items) {
  int prodnr;
  PT_Symbol dotsymbol;
  ATermList prods;

  if (IT_isValidItem(item)) {
    dotsymbol = (PT_Symbol)IT_getDotSymbol(item);
    if (!PT_isSymbolEmpty(dotsymbol)) {
      prods = PGEN_getProductionNumbersOfRhsNonTerminal(dotsymbol);
      if (prods) {
        while (!ATisEmpty(prods)) {
          /*ATwarning("prods = %t\n", prods);*/
          prodnr = ATgetInt((ATermInt)ATgetFirst(prods));
          prods = ATgetNext(prods);
          if (!PGEN_isPriorityConflict(item, prodnr)) {
            Item newitem = IT_createItem(prodnr);
            items = ATinsert(items, IT_ItemToTerm(newitem));
          }
        }
      }
    }
  }

  return items;
}
Exemplo n.º 14
0
PT_Symbols PT_foreachSymbolInSymbols(PT_Symbols symbols, PT_SymbolVisitor visitor,
                                     PT_SymbolVisitorData data)
{
  ATermList store;
  PT_Symbols newSymbols = PT_makeSymbolsEmpty();

  /* apply func to each element */
  store = ATempty;
  while (PT_hasSymbolsHead(symbols)) {
    store = ATinsert(store,
                     PT_SymbolToTerm(
                     visitor(PT_getSymbolsHead(symbols), data)));
    if (PT_hasSymbolsTail(symbols)) {
      symbols = PT_getSymbolsTail(symbols);
    }
    else {
      break;
    }
  }

  /* create new list */
  for (; !ATisEmpty(store); store = ATgetNext(store)) {
    PT_Symbol newSymbol = PT_SymbolFromTerm(ATgetFirst(store));
    newSymbols = PT_makeSymbolsList(newSymbol,newSymbols);
  }

  return newSymbols;
}
Exemplo n.º 15
0
void abstractPars(){
	 ATermList pars = MCRLgetListOfPars();
	 ATermList newPars = ATmakeList0();
	 ATerm proc = MCRLgetProc();
	 ATerm par, parName, parSort;
	 
	 for(;!ATisEmpty(pars); pars= ATgetNext(pars)){
		par = (ATerm) ATgetFirst(pars);
		parName = (ATerm) ATgetArgument((ATermAppl) par, 0);
		parSort = (ATerm) ATgetArgument((ATermAppl) par, 1);
		if(toAbstractPar(parName)){
			parSort = liftSort(abstractSort(parSort));
		}
		if(toAbstractSort(parSort)){
			parSort = liftSort(abstractSort(parSort));
		}
		if(!toAbstractSort(parSort) && BUT_SORT){
			parSort = getConcrete(getUnLifted(parSort));
		}
				
		par = (ATerm) ATsetArgument((ATermAppl) par, parSort, 1);
		newPars = ATappend(newPars, par);
		ATtablePut(par_tab, parName, parSort);
	 }
	 proc = (ATerm) ATsetArgument((ATermAppl)proc,(ATerm) newPars, 1);
	 MCRLsetProc(proc);
}
Exemplo n.º 16
0
static void prettyPrint(ATerm t, FILE *fp)
{
  ATermList ambs;
  int count;
  int i;

  if (ATmatch(t, "ambiguities(<int>,[<list>])",&count,&ambs)) {
    if (count == 0) {
      ATfprintf(fp,"No ambiguities\n");
    }
    else {
      ATfprintf(fp, "%d ambiguity cluster%s:\n\n",count,count > 1 ? "s" : "");
      
      for(i = 1;!ATisEmpty(ambs); ambs = ATgetNext(ambs), i++) {
	ATerm amb = ATgetFirst(ambs);
	ATermList productions;
	ATerm line, col, offset;

	if(ATmatch(amb,"ambiguity("
		       "  position(character(0),"
		       "           line(<term>),"
		       "           col(<term>),"
		       "           char(<term>)),"
		       "  productions([<list>]))",
		   &line, 
		   &col, 
		   &offset, 
		   &productions)) {
	  ATfprintf(fp,"[%d/%d] at (%t:%t):\n", i, count, line, col);
	  for(;!ATisEmpty(productions); productions = ATgetNext(productions)) {
	    char *str = deslash(ATgetFirst(productions));
	    ATfprintf(fp,"  %s\n", str);
	    free(str);
	  }

	  ATfprintf(fp,"\n");
	} else {
	  ATerror("%s: Unexpected term: %t\n",myname,t);
	}
      }
    }
  } else {
    ATerror("%s: Unexpected term: %t\n", myname,t);
    return;
  }
}
Exemplo n.º 17
0
Arquivo: rw.c Projeto: jkeiren/muCRL
static ATermList CaseRewriteList(ATermList ts) {
    ATermList r = ATempty;
    for (; !ATisEmpty(ts); ts=ATgetNext(ts)) {
        ATerm t = ATgetFirst(ts);
        r = ATinsert(r, CaseRewrite(t));
    }
    return ATreverse(r);
}
Exemplo n.º 18
0
void CAESAR_DELTA_STATE(CAESAR_TYPE_FILE fp,CAESAR_TYPE_STATE s1,CAESAR_TYPE_STATE s2) {
    ATermList pars = (ATermList)MCRLgetListOfPars();
    ATermList l1 = (ATermList)LTSgetState(s1->state);
    ATermList l2 = (ATermList)LTSgetState(s2->state);
    while (!ATisEmpty(pars)) {
        ATerm x1 = ATgetFirst(l1);
        ATerm x2 = ATgetFirst(l2);
        if (x1 != x2)
            ATfprintf(fp,"%t := %t; ",
                      MCRLprint(ATgetArgument(ATgetFirst(pars),0)),
                      MCRLprint(x2));
        l1 = ATgetNext(l1);
        l2 = ATgetNext(l2);
        pars = ATgetNext(pars);
    }
    //  fprintf(fp,"Diff: %d - %d",s1->state,s2->state);
}
ATbool ofp_traverse_Constructors(ATerm term, pOFP_Traverse Constructors)
{
#ifdef DEBUG_PRINT
   printf("\nConstructors: %s\n", ATwriteToString(term));
#endif

   OFP_Traverse OpDecl_list;
   if (ATmatch(term, "Constructors(<term>)", &OpDecl_list.term) ) {
      gTypeProductions = (ATermList) ATmake("[]");

      /* First build the type aliase table.  It is needed when matching productions.
       */
      ATermList OpDeclInj_tail = (ATermList) ATmake("<term>", OpDecl_list.term);
      while (! ATisEmpty(OpDeclInj_tail)) {
         OFP_Traverse OpDeclInj;
         OpDeclInj.term = ATgetFirst(OpDeclInj_tail);
         OpDeclInj_tail = ATgetNext(OpDeclInj_tail);

         if (ofp_traverse_OpDeclInj(OpDeclInj.term, &OpDeclInj)) {
            // MATCHED OpDeclInj
            gTypeProductions = ATappend(gTypeProductions, OpDeclInj.term);
         }
      }

      /* Coalesce the type table so there is one name per list of types
       */
      gTypeProductions = ofp_coalesceAliasTable(gTypeProductions);

      ATermList OpDecl_tail = (ATermList) ATmake("<term>", OpDecl_list.term);
      while (! ATisEmpty(OpDecl_tail)) {
         OFP_Traverse OpDecl;
         OpDecl.term = ATgetFirst(OpDecl_tail);
         OpDecl_tail = ATgetNext(OpDecl_tail);

         if (ofp_traverse_OpDecl(OpDecl.term, &OpDecl)) {
            // MATCHED OpDecl
         }
      }

      printf("\nPRODUCTIONS: %s\n", ATwriteToString((ATerm) gTypeProductions));

      return ATtrue;
   }

   return ATfalse;
}
Exemplo n.º 20
0
static ATermList mapInsertX(ATerm x, ATermList xs) {
  ATermList result = ATempty;
  while (!ATisEmpty(xs)) {
    result = ATinsert(result, (ATerm)ATinsert((ATermList)ATgetFirst(xs), x));
    xs = ATgetNext(xs);
  }
  return result;
}
Exemplo n.º 21
0
Arquivo: rewr.c Projeto: jkeiren/muCRL
static ATbool Reduce(void) {
    ATerm proc = MCRLgetProc();
    ATermList sums = MCRLgetListOfSummands(),
    pars = MCRLgetListOfPars();
    ATermList newsums = ATmakeList0();
     
    if (proverFlag) { 
       Declare_vars(pars);
       if (invariant) MCRLparseInvariants(invariant);
       } 
    else
       RWdeclareVariables(pars);
    for (cnt=0,newcnt = 0;!ATisEmpty(sums);sums=ATgetNext(sums),cnt++) {
         ATerm sum = ATgetFirst(sums), newsum = NULL;
         ATermList vars = (ATermList) ATgetArgument((ATermAppl) sum,0);
         ATerm actname = ATgetArgument((ATermAppl) sum, 1);
         ATermList actargs = (ATermList) ATgetArgument((ATermAppl) sum,2);
         ATerm procarg = ATgetArgument((ATermAppl) sum, 3);
         ATerm cond = ATgetArgument((ATermAppl) sum,4);
         ATbool invariantUsed = ATfalse;
         if (proverFlag) {
            if (!ATisEmpty(vars)) Declare_vars(vars); 
            cond = Prove(cond);
            if (invariant) {
              ATerm cond1 = ProveCondition(cond);
              if (!ATisEqual(cond1, cond)) {
                   invariantUsed = ATtrue;
                   cond = cond1;
                   }
              /* ATwarning("QQQ cond = %t", cond); */
              }
            cond = RWrewrite(cond);
            }
         else {
            if (!ATisEmpty(vars)) RWdeclareVariables(vars);
            cond = RWrewrite(cond);
            }
   /* if (monitor) ATwarning("Condition of summand %d is rewritten", cnt+1); */
         if (ATisEqual(cond, MCRLterm_false)) continue;
         newcnt++;
         actargs = RWrewriteList(actargs);
         if (!ATisEqual(procarg, MCRLterm_terminated)) {
              ATermList states = (ATermList) ATgetArgument((ATermAppl) procarg, 0);
              states = proverFlag?ProveList(states):RWrewriteList(states);
              procarg = (ATerm) ATmakeAppl1(MCRLsym_i, (ATerm) states);
              }
         newsum = ATmake("smd(<term>,<term>,<term>,<term>,<term>)",vars, actname,
              actargs,procarg, cond);
         newsums = ATinsert(newsums, newsum);
         if (monitor && !ATisEqual(sum, newsum)) 
               ATwarning("Summand %d is rewritten %s", cnt+1,
               invariantUsed?"(invariant is used)":""); 
         }
    MCRLsetProc(ATmake("initprocspec(<term>,<term>,<term>)",
    (ATerm) RWrewriteList((ATermList) MCRLgetListOfInitValues()), 
          pars, (ATerm) ATreverse(newsums)));
    return !ATisEqual(MCRLgetProc(), proc);      
    }
Exemplo n.º 22
0
void liftPars(){
	 ATermList sums, newSums;
	 ATerm sum;
	 ATerm procSpec, procArg;
	 ATermList procArgs;
	 
	 ATermList pars, newPars;
	 ATerm proc = MCRLgetProc();	
	 ATerm par, parName, parSort;
	 ATbool repeat;
	 
	 do{
	 	repeat = ATfalse;
		sums = MCRLgetListOfSummands();
		for(;!ATisEmpty(sums); sums= ATgetNext(sums)){
			sum = ATgetFirst(sums);	
			procSpec = ATgetArgument(sum, 3);
			procArgs = (ATermList)ATgetArgument((ATermAppl) procSpec,0);
			pars = MCRLgetListOfPars();
			newPars = ATmakeList0();
		
			for(;!ATisEmpty(procArgs); 
					procArgs = ATgetNext(procArgs), pars = ATgetNext(pars)) { 
				procArg = ATgetFirst(procArgs);
				par = ATgetFirst(pars);
				parSort = (ATerm) ATgetArgument((ATermAppl) par, 1);
				parName = (ATerm) ATgetArgument((ATermAppl) par, 0);
				if(!isLifted(parSort)){
					if(toLiftTerm(procArg)){
						repeat = ATtrue;
						parSort = liftSort(parSort);
					}
				}		
				par = (ATerm) ATsetArgument((ATermAppl) par, parSort, 1);
				newPars = ATappend(newPars, par);
				ATtablePut(par_tab, parName, parSort);
			}
			proc = (ATerm) ATsetArgument((ATermAppl)proc,(ATerm) newPars, 1);
			MCRLsetProc(proc);
			if(repeat) break;
			fprintf(stderr,".");
	 	}
	}while(repeat);
}   
Exemplo n.º 23
0
Arquivo: rewr.c Projeto: jkeiren/muCRL
static ATermList ProveList(ATermList args) {
     ATermList r = ATempty;
     AFun bool = ATgetAFun(MCRLterm_bool);
     for (;!ATisEmpty(args);args=ATgetNext(args)) {
         ATerm arg = ATgetFirst(args);
         r = ATinsert(r, MCRLgetSort(arg)==bool?
             RWrewrite(Prove(arg)):RWrewrite(arg));
         }
     return ATreverse(r);
     }
Exemplo n.º 24
0
static ATermList powerList0(ATermList list) {
  if (ATisEmpty(list)) {
    return ATinsert(ATempty, (ATerm)ATempty);
  }
  else {
    ATerm x = ATgetFirst(list);
    ATermList xs = ATgetNext(list);
    ATermList xss = powerList0(xs);
    return ATconcat(xss, mapInsertX(x, xss));
  }
}
Exemplo n.º 25
0
void printResults(){
	ATermList pars;
	ATermList vars;
	ATermList abstracted, lifted;
	ATerm par, parSort;
	ATerm var, varSort;
	
	abstracted = ATmakeList0();
	lifted = ATmakeList0();
	
	pars = ATtableKeys(par_tab);
	for(;!ATisEmpty(pars); pars = ATgetNext(pars)){
		par = ATgetFirst(pars);
		parSort = ATtableGet(par_tab, par);
		if(isAbstracted(parSort)){
			abstracted = ATinsert(abstracted, par);
		}
		else if (isLifted(parSort)){
			lifted = ATinsert(lifted, par);
		}
	}
	fprintf(stderr, "%d Parameters Abstracted:\n", ATgetLength(abstracted));
	pTerm((ATerm) abstracted);
	fprintf(stderr, "%d Parameters Lifted:\n", ATgetLength(lifted)); 
	pTerm((ATerm) lifted);
	fprintf(stderr, "%d Conflicting Parameters:\n", 
			ATgetLength(conflictingPars)); 
	pTerm((ATerm) conflictingPars);
	
	abstracted = ATmakeList0();
	vars = ATtableKeys(var_tab);
	for(;!ATisEmpty(vars); vars = ATgetNext(vars)){
		var = ATgetFirst(vars);
		varSort = ATtableGet(var_tab, var);
		if(isAbstracted(varSort)){
			abstracted = ATinsert(abstracted, var);
		}
	}
	fprintf(stderr, "%d Variables Abstracted:\n", ATgetLength(abstracted));
	pTerm((ATerm) abstracted);
}
Exemplo n.º 26
0
void CAESAR_PRINT_STATE(CAESAR_TYPE_FILE f,CAESAR_TYPE_STATE s) {
    //  fprintf(f,"PRINT_STATE %d",s->state);
    ATermList values = (ATermList)LTSgetState(s->state);
    ATermList names = MCRLgetListOfPars();
    if (state_format>=1)
        fprintf(f,"\n(");
    else
        fprintf(f,"(");
    while (!ATisEmpty(values)) {
        if (state_format>=1)
            ATfprintf(f,"%t = ",MCRLprint(ATgetArgument(ATgetFirst(names),0)));
        ATfprintf(f,"%t",MCRLprint(ATgetFirst(values)));
        values=ATgetNext(values);
        names=ATgetNext(names);
        if (!ATisEmpty(values))
            if (state_format>=1)
                fprintf(f,",\n");
            else
                fprintf(f,",");
    }
    fprintf(f,")");
}
Exemplo n.º 27
0
static void args2buf(ATermList args)
{
    while(!ATisEmpty(args)) {
        ATerm arg = ATgetFirst(args);
        args = ATgetNext(args);
        if(ATgetType(arg) != AT_LIST)
            char2buf('{');
        term2buf(arg);
        if(ATgetType(arg) != AT_LIST)
            char2buf('}');
        char2buf(' ');
    }
}
Exemplo n.º 28
0
ATermList initAbstraction(ATermList inits){
	ATermList pars = MCRLgetListOfPars();
	ATermList newInits = ATmakeList0();
	ATerm init, par, parSort, newTerm, initSort;
		
	for (;!ATisEmpty(inits); inits= ATgetNext(inits), pars = ATgetNext(pars)){
		init = ATgetFirst(inits);
		par = ATgetFirst(pars);
		parSort = (ATerm) ATgetArgument((ATermAppl) par, 1);
		newTerm = init;
		initSort = getConcrete(getUnLifted(parSort));
		if(isLifted(parSort)){
			initSort = liftSort(initSort);
			newTerm = createSingTerm(newTerm, initSort);
		}		
		if(isAbstracted(parSort)){
			newTerm = createAlphaTerm(newTerm, initSort);
		}
		newInits = ATappend(newInits, newTerm);
		
	}
	return newInits;
}
Exemplo n.º 29
0
ATSet ATR_fromList(ATermList list) {
  ATSet set = ATR_empty();
  while (!ATisEmpty(list)) {
    ATerm first = ATgetFirst(list);
    if (ATgetType(first) == AT_LIST) {
      set = ATR_insert(set, ATR_fromList((ATermList)first));
    }
    else {
      set = ATR_insert(set, first);
    }
    list = ATgetNext(list);
  }
  return set;
}
Exemplo n.º 30
0
ATermList T_getAllKeyValuePairs(Table table)
{
  ATermList keys = T_getAllKeys(table);
  ATermList pairs;

  for (pairs = ATempty; !ATisEmpty(keys); keys = ATgetNext(keys)) {
    ATerm key = ATgetFirst(keys);
    ATerm value = T_getValue(table, key);
    ATermList pair = ATmakeList2(key, value);

    pairs = ATinsert(pairs, (ATerm) pair);
  }

  return pairs;
}