Exemple #1
0
// This function evaluates the parse tree given by expr within the given environment.
Value* eval(Value *expr, Environment *env){
  Value* operator;
  Value* args;
  //printf("Here is expression:  ");
  //printValue(expr);
  //printf("\n");
  
  if (!expr){
    return NULL;
  }
  
  switch (expr->type) 
    {
    case symbolType:
      //printf("unknown identifier");
      args = envLookup(expr->symbolValue, env);
      if (args){
	//printf("going here\n");
	//printValue(expr);
	//printf("\nending here\n");
	return args;
      }
      else{
	printf("syntax error: unknown identifier");
	return NULL;
      }
      break;
    case cellType:
      if (expr->cons->car->type == nullType) {
	return expr->cons->car;
      }
      //printf("Here is expression:  ");
      //printValue(getFirst(expr));
      //printf("\n");
      
      if (getFirst(expr) != NULL && getFirst(expr)->type == openType) {
	operator = car(expr);

	if (!operator){
	  printf("syntax error, missing components here");
	  return NULL;
	}
	if (operator->type == cellType){
	  operator = eval(operator, env);
	}
	
	if (operator->type == symbolType){
	  args = getTail(getTail(expr));
	  //printf("checking args?: ");
	  //printValue(args);
	  //printf("\n"); //if (args  == NULL){
	  //return eval(operator,env); //	  }else 
	  if (strcmp(operator->symbolValue,"define")==0){
	    return evalDefine(args, env);
	  }else if (strcmp(operator->symbolValue,"lambda")==0){
	    /*eval lambda goes here*/
	    return evalLambda(args, env);
	  }else if (strcmp(operator->symbolValue,"if")== 0){
	    return evalIf(args, env);
	    /*eval if goes here*/
	  }else if (strcmp(operator->symbolValue,"quote")==0){
	    /*eval quote goes here*/
	    return evalQuote(args);
	  }else if (strcmp(operator->symbolValue,"let")==0){
	    /*eval let goes here*/
	    return evalLet(args, env);
	  }else{
	    //printf("validation result is shown: %d\n",validateArgs(args, env));
	    if (validateArgs(args, env)==-1){
	      printf("Syntax error! Invalid arguments for the procedure: ");
	      printValue(operator);
	      printf("\n");
	      return NULL;
	    } 
	    Value *evaledOperator = eval(operator, env);
	    Value *evaledArgs = evalEach(args, env);
	    if (!evaledOperator){
	      printf("Unknown procedure: ");
	      printValue(operator);
	      printf("\n");
	    }
	    //printValue(evaledArgs);
	    //printf("\n");
	    return apply(evaledOperator, evaledArgs);
	  }
	}else if (typeCheck(operator)==1){
	  printf("A literal ");
	  printValue(operator);
	  printf(" cannot be a procedure.\n");
	  return NULL; 
	}
      } else if (typeCheck(getFirst(expr))==1){
	//printValue(expr);
	//printf("\n");
	return evalEach(expr,env);
      }else if (getFirst(expr) && getFirst(expr)->type ==cellType && getFirst(getTail(expr)) && getFirst(getTail(expr))->type==closeType){
	return eval(getFirst(expr),env);
      }else if (getFirst(expr) && getFirst(expr)->type == symbolType){
	operator = getFirst(expr);
	Value *returnValue = envLookup(operator->symbolValue, env);
	
	if (returnValue){
	  return returnValue;
	}else{
	  if (strcmp(operator->symbolValue,"define")==0){
	    printf("define: bad syntax in ");
	    printValue(expr);
	    printf("\n");
	  }else if (strcmp(operator->symbolValue,"lambda")==0){
	    printf("lambda: bad syntax in ");
	    printValue(expr);
	    printf("\n");
	  }else if (strcmp(operator->symbolValue,"if")==0){
	    printf("if: bad syntax in ");
	    printValue(expr);
	    printf("\n");
	  }else if (strcmp(operator->symbolValue,"quote")==0){
	    printf("quote: bad syntax in ");
	     printValue(expr);
	     printf("\n");
	  }else if (strcmp(operator->symbolValue,"let")==0){
	     printf("let: bad syntax in ");
	     printValue(expr);
	     printf("\n");
	  }else{
	     
	    printf("Unknown identifier %s.\n",operator->symbolValue);
	   }
	  
	   return NULL;
	 }
       }
       
    case closeType:
      //printValue(expr);
      //printf("\n");
      return NULL;
      break;
    default:
      //printValue(expr);
      //printf("\n");
      if (getTail(expr)){
	assert(getFirst(getTail(expr))!=NULL);
	assert(getFirst(getTail(expr))->type==closeType);
	Value *toRemove = getTail(expr);
	free(toRemove->cons->car);
	free(toRemove->cons);
	free(toRemove);
	expr->cons->cdr = NULL;
	//assert(1==2);
      }
      return expr;      
    }
}
// Evaluates the expression. In the frame that it is given
Value eval(Value expr, Frame *env) {
    Value toRet;
    switch (expr.type){
       case (booleanType): 
       case (integerType):
       case (realType):
       case (stringType):
        case (quotedConsType):
        case (quotedSymbolType):
        case (closureType):
        case (primitiveType):
            toRet = expr;
            break;
        case (symbolType):
            toRet = resolveVar(expr, env);
            break;
       case (consType): 
         if( !expr.consValue ){
                return evaluationError("empty expression");
            }else if(expr.consValue->car.type == consType){
                toRet = evalApply(expr, env);
                if(toRet.type == openType){
                    return evaluationError("first argument in an expression did not evaluate to a proceedure");
                }
                break;
            }else if(expr.consValue->car.type == symbolType){
                char *keyword = expr.consValue->car.symbolValue;

                if (strcmp(keyword, "if") == 0) {
                    toRet = evalIf(expr.consValue->cdr, env);

                } else if (strcmp(keyword, "quote") == 0){
                    toRet = evalQuote(expr.consValue->cdr, env);

                } else if (strcmp(keyword, "let") == 0){
                    toRet = evalLet(expr.consValue->cdr, env);

                } else if (strcmp(keyword, "define") == 0){
                    toRet = evalDefine(expr.consValue->cdr, env);

                } else if (strcmp(keyword, "lambda") == 0){
                    toRet = evalLambda(expr.consValue->cdr, env);

                } else if (strcmp(keyword, "let*") == 0){
                    toRet = evalLetStar(expr.consValue->cdr, env);

                } else if (strcmp(keyword, "letrec") == 0){
                    toRet = evalLetRec(expr.consValue->cdr, env);

                } else if (strcmp(keyword, "begin") == 0){
                    toRet = evalBegin(expr.consValue->cdr, env);

                } else if (strcmp(keyword, "cond") == 0){
                    toRet = evalCond(expr.consValue->cdr, env);
                } 
                else { 
                    /* not a recognized special form - must be user defined function */
                    toRet = evalApply(expr, env);
                }
                break;
            }else{
                return evaluationError("first argument in an expression was neither a symbol or expression");
            }
        case (voidType):
            toRet = evaluationError("cannot evaluate void type");
        default:
            toRet = evaluationError(NULL);
    }
    return toRet;
}