Пример #1
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);
}
Пример #2
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);
}
Пример #3
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;	
}
Пример #4
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");
}
Пример #5
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;
}
Пример #6
0
int main(int argc, char *argv[])
{
  ATerm tree;

  ATinit(argc, argv, &tree);
  ATprotect((ATerm*)&imported);
  ATprotect(&parse_tree);
  ATprotect((ATerm*)&includes);

  process_options(argc, argv);

  imported = ATmakeList0();
  yydebug = 0; 
  open_dependencies(input_file);
  tree = parse_file(input_file);
  /* Open output file */
  if (output_file == NULL)
    outfile = stdout;
  else
    outfile = fopen(output_file, "w"); 
  if(binary_output)
    ATwriteToBinaryFile(tree, outfile);
  else
    ATwriteToTextFile(tree, outfile);
  /* print_dependencies(input_file, imported); */
  exit(0);
}
Пример #7
0
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);      
    }
Пример #8
0
ATerm addVar(ATerm sum, ATerm varName, ATerm varSort){
	ATermList vars = ATmakeList0();
	ATerm var;
	AFun vTag  = ATmakeSymbol("v",2, ATfalse); 
	
	vars = (ATermList) ATgetArgument((ATermAppl) sum ,0);
	vars = ATinsert(vars,(ATerm)ATmakeAppl2(vTag,varName,varSort));
	
	return (ATerm) ATsetArgument((ATermAppl) sum, (ATerm) vars, 0);
}
Пример #9
0
ATermList generate_numbers(int max)
{
  int i;
  ATermList numbers = ATmakeList0();

  for(i=max; i>0; i--)
    numbers = ATinsert(numbers, (ATerm) ATmakeInt(i));

  return numbers;
}
Пример #10
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);
}
Пример #11
0
ACB new_acb(ACData agent, ACData action) {
	ACCACB acb = (ACCACB)malloc(sizeof(struct accacb));
	INIT_EXCEPTION_STACK(acb->exception_stack);
	INIT_DATA_STACK(acb->result);
	INIT_DATA_STACK(acb->data);
	acb->data = ATmakeList0();
	acb->scope = ATmakeList0();
	acb->saved_data = ATmakeList0();
	acb->saved_scope = ATmakeList0();
	ATprotect(&(acb->result));
	ATprotect(&(acb->data));
	ATprotect(&(acb->scope));
	ATprotect(&(acb->saved_data));
	ATprotect(&(acb->saved_scope));
	acb->tagged_buffer = ATtableCreate(100, 80);
	acb->agent = agent;
	acb->action = action;
	ATprotect(&(acb->agent));
	ATprotect(&(acb->action));
	acb->return_stack.top = NULL;
	acb->exit_status = NORMAL_OUTCOME;
	acb->prev = NULL;
	return acb;
}
Пример #12
0
ATermList actAbstraction (ATermList actArgs){
	ATerm actArg, actArgSort, newTerm;
	ATermList newActArgs = ATmakeList0();
	
	for(;!ATisEmpty(actArgs); actArgs = ATgetNext(actArgs)) {
		actArg = ATgetFirst(actArgs);
		actArgSort = getTermSort(actArg);				
		if(toAbstractSort(actArgSort)){
			actArgSort = liftSort(abstractSort(getUnLifted(actArgSort)));
		}
		newTerm = termAbstraction(actArg, actArgSort);
		newActArgs = ATappend(newActArgs, newTerm);
	 }
	return newActArgs;
}
Пример #13
0
void initAbsInt(){
	ATbool ok;
	AFun memberTag;	

	initTables();	
	
	conflictingPars = ATmakeList0();

	ATprotect((ATerm *)&conflictingPars);
	
	memberTag = createNewFuncSym(memberSym, 
			ATmakeList2(MCRLterm_bool, liftSort(MCRLterm_bool)));
	
	MCRLputMap((ATerm)ATmakeAppl2(memberTag, 
				MCRLterm_bool, liftSort(MCRLterm_bool)), 
			MCRLterm_bool, &ok);	
}
Пример #14
0
ATerm SSL_write_term_to_shared_string(ATerm term) {
    int i;
    int length;
    char* result = ATwriteToSharedString(term, &length);
    ATermList result_term = ATmakeList0();;

    if(result == NULL) {
        perror("SRTS/write_term_to_shared_string");
        _fail(term);
    }

    for(i = length - 1; i >= 0; i--) {
        ATerm next = (ATerm) ATmakeInt(result[i]);
        result_term = ATinsert(result_term, next);
    }

    return (ATerm) result_term;
}
Пример #15
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);
}   
Пример #16
0
ATermList filter_non_primes(ATermList numbers)
{
  ATermList primes = ATmakeList0();

  /* Skip 1, we dont want to filter that! */
  numbers = ATgetNext(numbers);

  while(!ATisEmpty(numbers)) {
    /* The first number must be prime. remove it from numbers. */
    ATerm prime = ATgetFirst(numbers);

    /* Remove all multiples of n, because they cannot be prime! */
    numbers = filter_multiples(ATgetInt((ATermInt)prime), numbers);
    /*ATprintf("%d numbers.\n", ATgetLength(numbers));*/

    /* Now add n to the list of primes */
    primes = ATappend(primes, prime);
  }

  return (ATermList)ATmake("[1,<list>]", primes);
}
Пример #17
0
void abstractSummands(){	
	ATermList mayMustSums, newSums, sums = MCRLgetListOfSummands();
	ATerm proc, sum;
	
	proc = MCRLgetProc();
	newSums = ATmakeList0();
	
	P("Generating Abstract Summands");
	sums = ATreverse(sums);
	for(nSum = 1; !ATisEmpty(sums); sums= ATgetNext(sums), nSum++){
		sum = ATgetFirst(sums);	
		mayMustSums = generateNewSums(sum);
		newSums = ATconcat(newSums, mayMustSums);
		fprintf(stderr,".");
	}
	
	proc = (ATerm) ATsetArgument((ATermAppl) proc, 
					(ATerm)newSums, 2);

	MCRLsetProc(proc);	
	fprintf(stderr,"\n");
}
Пример #18
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;
}
Пример #19
0
ATermList generateNewSums(ATerm sum){
	ATerm maySum, mustSum;
	ATermList procArgs, newProcArgs;
	ATerm  proc, procArg, procArgSort;
	ATermList actArgs;
	ATermList newActArgs;
   ATerm actArg, actArgSort;
	ATermList vars;
	ATerm var, varName, varSort;
	ATerm cond, auxMayCondition, auxMustCondition;
	int i;
	char auxVarName[NAME_LENGTH];
	
	proc = (ATerm) ATgetArgument(sum, 3);
	procArgs = (ATermList)ATgetArgument(proc, 0);
	newProcArgs = ATmakeList0();
	
	auxMayCondition = NULL;
	auxMustCondition = NULL;
	maySum = sum;	
	mustSum = sum;					
	if(HOMOMORPHISM){
		for(i=0;!ATisEmpty(procArgs); procArgs= ATgetNext(procArgs)) {
			procArg = ATgetFirst(procArgs);	
			
			procArgSort = getTermSort(procArg);
			
			if(isLifted(procArgSort)){
				sprintf(auxVarName, "%s%d", auxVarPrefix, i);
				i++;
				varName = (ATerm)ATmakeAppl0(ATmakeAFun(auxVarName, 0, ATtrue));
				varSort = getUnLifted(procArgSort);
				maySum = addVar(maySum, varName, varSort);
				newProcArgs = ATappend(newProcArgs, 
						createSingleton(varName, varSort));
				auxMayCondition = createMemberAuxCondition(auxMayCondition, 
							varName, procArg, varSort);
				auxMustCondition = createSingletonAuxCondition(auxMustCondition, 
						procArg, procArgSort);
			}
			else{
				newProcArgs = ATappend(newProcArgs, procArg);	
			}
		}
		proc = (ATerm)ATsetArgument((ATermAppl)
					proc, (ATerm) newProcArgs, 0);
		maySum = (ATerm)ATsetArgument((ATermAppl)maySum, proc, 3);
	
		mustSum = sum;					
		actArgs = (ATermList)ATgetArgument(sum,2);
		newActArgs = ATmakeList0();
				
		for(;!ATisEmpty(actArgs); actArgs= ATgetNext(actArgs),i++) {
			actArg = ATgetFirst(actArgs);	
			actArgSort = getTermSort(actArg);
			if(isLifted(actArgSort)){
				sprintf(auxVarName, "%s%d", auxVarPrefix, i);
				i++;
				varName = (ATerm)ATmakeAppl0(ATmakeAFun(auxVarName, 0, ATtrue));
				varSort = getUnLifted(actArgSort);
				maySum = addVar(maySum, varName, varSort);
				mustSum = addVar(mustSum, varName, varSort);
				newActArgs = ATappend(newActArgs, varName);
				auxMayCondition = createMemberAuxCondition(auxMayCondition, 
							varName, actArg, varSort);
				auxMustCondition = createMemberAuxCondition(auxMustCondition, 
							varName, actArg, varSort);
				auxMustCondition = createSingletonAuxCondition(auxMustCondition, 
						actArg, actArgSort);	
			}
			else{
				newActArgs = ATappend(newActArgs, actArg);	
			}
			maySum = (ATerm)ATsetArgument((ATermAppl)maySum,
				(ATerm)newActArgs, 2);
		}
	}
		maySum = (ATerm)createMaySum(maySum);
		mustSum = (ATerm)createMustSum(mustSum);

	if(HOMOMORPHISM){	
		cond = ATgetArgument(maySum, 4);
		cond = createAuxCondition2(auxMayCondition, cond);	
		maySum = (ATerm)ATsetArgument((ATermAppl)maySum, cond, 4);
	
		cond = ATgetArgument(mustSum, 4);
		cond = createAuxCondition2(auxMustCondition, cond);	
		mustSum = (ATerm)ATsetArgument((ATermAppl)mustSum, cond, 4);
	}
	
	if(MAY && MUST)
		return ATmakeList2(maySum, mustSum);
	else if(MAY)
		return ATmakeList1(maySum);
	else if(MUST)
		return ATmakeList1(mustSum);
}