* Copyright (c) 2009-2013 CWI

* All rights reserved. This program and the accompanying materials

* are made available under the terms of the Eclipse Public License v1.0

* which accompanies this distribution, and is available at

* http://www.eclipse.org/legal/epl-v10.html

*

* Contributors:

*   * Jurgen J. Vinju - Jurgen.Vinju@cwi.nl - CWI

*   * Bas Basten - Bas.Basten@cwi.nl (CWI)

*   * Mark Hills - Mark.Hills@cwi.nl (CWI)

*   * Arnold Lankamp - Arnold.Lankamp@cwi.nl

*   * Anastasia Izmaylova - A.Izmaylova@cwi.nl - CWI

*   * Michael Steindorfer - Michael.Steindorfer@cwi.nl - CWI

*   * Paul Klint - Paul.Klint@cwi.nl - CWI

*******************************************************************************/

  private static final Name IT = ASTBuilder.makeLex("Name", null, "<it>");

 

  static public class Addition extends org.rascalmpl.ast.Expression.Addition {

    public Addition(IConstructor __param1, org.rascalmpl.ast.Expression __param2,

        org.rascalmpl.ast.Expression __param3) {

      super(__param1, __param2, __param3);

    }

    @Override

    public IBooleanResult buildBacktracker(IEvaluatorContext __eval) {

      throw new UnexpectedType(TF.boolType(), this

          .interpret(__eval.getEvaluator()).getType(),

          this);

    }

 

    @Override

    public Result<IValue> interpret(IEvaluator<Result<IValue>> __eval) {

     

      __eval.setCurrentAST(this);

      __eval.notifyAboutSuspension(this);     

     

      Result<IValue> left = this.getLhs().interpret(__eval);

      Result<IValue> right = this.getRhs().interpret(__eval);

      return left.add(right);

    }

  }

  static public class All extends org.rascalmpl.ast.Expression.All {

    public All(IConstructor __param1,

        java.util.List<org.rascalmpl.ast.Expression> __param2) {

      super(__param1, __param2);

    }

    @Override

    public IBooleanResult buildBacktracker(IEvaluatorContext __eval) {

      return new BasicBooleanResult(__eval, this);

    }

    @SuppressWarnings({ "unchecked", "rawtypes" })

    @Override

    public Result interpret(IEvaluator<Result<IValue>> __eval) {

      __eval.setCurrentAST(this);

      __eval.notifyAboutSuspension(this); 

     

      java.util.List<org.rascalmpl.ast.Expression> producers = this

          .getGenerators();

      int size = producers.size();

      IBooleanResult[] gens = new IBooleanResult[size];

      Environment[] olds = new Environment[size];

      Environment old = __eval.getCurrentEnvt();

      int i = 0;

      try {

        olds[0] = __eval.getCurrentEnvt();

        __eval.pushEnv();

        gens[0] = producers.get(0).getBacktracker(__eval);

        gens[0].init();

        while (i >= 0 && i < size) {

          if (__eval.isInterrupted()) {

            throw new InterruptException(__eval.getStackTrace(), __eval.getCurrentAST().getLocation());

          }

          if (gens[i].hasNext()) {

            if (!gens[i].next()) {

              return new BoolResult(TF.boolType(), __eval

                  .__getVf().bool(false), __eval);

            }

            if (i == size - 1) {

              __eval.unwind(olds[i]);

              __eval.pushEnv();

            } else {

              i++;

              gens[i] = producers.get(i).getBacktracker(__eval);

              gens[i].init();

              olds[i] = __eval.getCurrentEnvt();

              __eval.pushEnv();

            }

          } else {

            __eval.unwind(olds[i]);

            i--;

          }

        }

      } finally {

        __eval.unwind(old);

      }

      return new BoolResult(TF.boolType(), __eval.__getVf().bool(true),

          __eval);

    }

  }

  static public class And extends org.rascalmpl.ast.Expression.And {

    public And(IConstructor __param1, org.rascalmpl.ast.Expression __param2,

        org.rascalmpl.ast.Expression __param3) {

      super(__param1, __param2, __param3);

    }

    @Override

    public IBooleanResult buildBacktracker(IEvaluatorContext __eval) {

      return new AndResult(__eval, this.getLhs().buildBacktracker(__eval), this.getRhs().buildBacktracker(__eval));

    }

    @Override

    public Result<IValue> interpret(IEvaluator<Result<IValue>> __eval) {

      __eval.setCurrentAST(this);

      __eval.notifyAboutSuspension(this);     

     

      return evalBooleanExpression(this, __eval);

    }

  }

  static public class Anti extends org.rascalmpl.ast.Expression.Anti {

    public Anti(IConstructor __param1, org.rascalmpl.ast.Expression __param2) {

      super(__param1, __param2);

    }

    @Override

    public IMatchingResult buildMatcher(IEvaluatorContext __eval) {

      IMatchingResult absPat = getPattern().buildMatcher(__eval);

      return new AntiPattern(__eval, this, absPat);

    }

    @Override

    public Type typeOf(Environment env, boolean instantiateTypeParameters, IEvaluator<Result<IValue>> eval) {

      return TypeFactory.getInstance().voidType();

    }

  }

  static public class Any extends org.rascalmpl.ast.Expression.Any {

    public Any(IConstructor __param1,

        java.util.List<org.rascalmpl.ast.Expression> __param2) {

      super(__param1, __param2);

    }

    @Override

    public IBooleanResult buildBacktracker(IEvaluatorContext __eval) {

      return new BasicBooleanResult(__eval, this);

    }

    @SuppressWarnings({ "unchecked", "rawtypes" })

    @Override

    public Result interpret(IEvaluator<Result<IValue>> __eval) {

      __eval.setCurrentAST(this);

      __eval.notifyAboutSuspension(this);     

     

      java.util.List<org.rascalmpl.ast.Expression> generators = this

          .getGenerators();

      int size = generators.size();

      IBooleanResult[] gens = new IBooleanResult[size];

      int i = 0;

      gens[0] = generators.get(0).getBacktracker(__eval);

      gens[0].init();

      while (i >= 0 && i < size) {

        if (__eval.isInterrupted()) {

          throw new InterruptException(__eval.getStackTrace(), __eval.getCurrentAST().getLocation());

        }

        if (gens[i].hasNext() && gens[i].next()) {

          if (i == size - 1) {

            return new BoolResult(TF.boolType(), __eval.__getVf()

                .bool(true), __eval);

          }

          i++;

          gens[i] = generators.get(i).getBacktracker(__eval);

          gens[i].init();

        } else {

          i--;

        }

      }

      return new BoolResult(TF.boolType(), __eval.__getVf().bool(false),

          __eval);

    }

  }

  static public class Bracket extends org.rascalmpl.ast.Expression.Bracket {

    public Bracket(IConstructor __param1, org.rascalmpl.ast.Expression __param2) {

      super(__param1, __param2);

    }

    @Override

    public IBooleanResult buildBacktracker(IEvaluatorContext __eval) {

      return this.getExpression().buildBacktracker(__eval);

    }

    @Override

    public IMatchingResult buildMatcher(IEvaluatorContext __eval) {

      return this.getExpression().buildMatcher(__eval);

    }

    @Override

    public Result<IValue> interpret(IEvaluator<Result<IValue>> __eval) {

     

      __eval.setCurrentAST(this);

      __eval.notifyAboutSuspension(this);     

      return this.getExpression().interpret(__eval);

    }

  }

  static public class CallOrTree extends

      org.rascalmpl.ast.Expression.CallOrTree {

    private Result<IValue> cachedPrefix = null;

    private boolean registeredCacheHandler = false;

    private Type cachedConstructorType = null;

    private boolean registeredTypeCacheHandler = false;

    public CallOrTree(IConstructor __param1,

        org.rascalmpl.ast.Expression __param2,

        java.util.List<org.rascalmpl.ast.Expression> __param3, KeywordArguments_Expression __param4) {

      super(__param1, __param2, __param3, __param4);

    }

    @Override

    public IBooleanResult buildBacktracker(IEvaluatorContext __eval) {

      return new BasicBooleanResult(__eval, this);

    }

    @Override

    public IMatchingResult buildMatcher(IEvaluatorContext eval) {

      org.rascalmpl.ast.Expression nameExpr = getExpression();

   

      if (nameExpr.isQualifiedName()) {

        if (cachedConstructorType == null) {

          registerTypeCacheHandler(eval);

          cachedConstructorType  = computeConstructorType(eval, nameExpr);

        }

        

        return new NodePattern(eval, this, null, nameExpr.getQualifiedName(), cachedConstructorType, visitArguments(eval), visitKeywordArguments(eval));

      }

      return new NodePattern(eval, this, nameExpr.buildMatcher(eval), null, TF.nodeType(), visitArguments(eval), visitKeywordArguments(eval));

    }

    private java.util.Map<String, IMatchingResult> visitKeywordArguments(IEvaluatorContext eval) {

      java.util.Map<String,IMatchingResult> result = new HashMap<>();

      KeywordArguments_Expression keywordArgs;

      if (hasKeywordArguments() && (keywordArgs = getKeywordArguments()).isDefault()) {

        for (KeywordArgument_Expression kwa : keywordArgs.getKeywordArgumentList()) {

          result.put(Names.name(kwa.getName()), kwa.getExpression().buildMatcher(eval));

        }

      }

      return result;

    }

    private Type computeConstructorType(IEvaluatorContext eval,

        org.rascalmpl.ast.Expression nameExpr) {

      java.util.List<AbstractFunction> functions = new LinkedList<AbstractFunction>();

      String cons = Names.consName(nameExpr.getQualifiedName());

      Type adt = eval.getCurrentEnvt().lookupAbstractDataType(Names.moduleName(nameExpr.getQualifiedName()));

      if (adt != null) {

        eval.getCurrentEnvt().getAllFunctions(adt, cons, functions);

      }

      else {

        eval.getCurrentEnvt().getAllFunctions(cons, functions);

      }

     

      if (functions.isEmpty()) {

        return null;

      }

     

      Type signature = getArgumentTypes(eval);

      Type constructorType = TF.nodeType();

     

      for (AbstractFunction candidate : functions) {

        if (candidate.getReturnType().isAbstractData() && !candidate.getReturnType().isBottom() && candidate.match(signature)) {

          Type decl = eval.getCurrentEnvt().getConstructor(candidate.getReturnType(), cons, signature);

          if (decl != null) {

            constructorType = decl;

          }

        }

      }

      return constructorType;

    }

    private Type getArgumentTypes(IEvaluatorContext eval) {

      java.util.List<IMatchingResult> args = visitArguments(eval);

      Type[] argTypes = new Type[args.size()];

      for (int i = 0; i < argTypes.length; i++) {

        argTypes[i] = args.get(i).getType(eval.getCurrentEnvt(), null);

      }

      Type signature = TF.tupleType(argTypes);

      return signature;

    }

    private void registerCacheHandler(IEvaluatorContext eval) {

      if (!registeredCacheHandler) {

        eval.getEvaluator().registerConstructorDeclaredListener(

            new IConstructorDeclared() {

              public void handleConstructorDeclaredEvent() {

                cachedPrefix = null;

                registeredCacheHandler = false;

              }

            });

        registeredCacheHandler = true;

      }

    }

   

    private void registerTypeCacheHandler(IEvaluatorContext eval) {

      if (!registeredTypeCacheHandler) {

        eval.getEvaluator().registerConstructorDeclaredListener(

            new IConstructorDeclared() {

              public void handleConstructorDeclaredEvent() {

                cachedConstructorType = null;

                registeredTypeCacheHandler = false;

              }

            });

        registeredTypeCacheHandler = true;

      }

    }

   

    private java.util.List<IMatchingResult> visitArguments(IEvaluatorContext eval) {

      return buildMatchers(getArguments(), eval);

    }

    @Override

    public Result<IValue> interpret(IEvaluator<Result<IValue>> eval) {

      eval.setCurrentAST(this);

      eval.notifyAboutSuspension(this);     

      try {

        if (eval.isInterrupted()) {

          throw new InterruptException(eval.getStackTrace(), eval.getCurrentAST().getLocation());

        }

        eval.setCurrentAST(this);

        Result<IValue> function = this.cachedPrefix;

        // If the name expression is just a name, enable caching of the name lookup result.

        // Also, if we have not yet registered a handler when we cache the result, do so now.

        if (function == null) {

          function = this.getExpression().interpret(eval);

         

          if (this.getExpression().isQualifiedName() && function instanceof ICallableValue && ((ICallableValue) function).isStatic()) {

            org.rascalmpl.ast.QualifiedName qname = this.getExpression().getQualifiedName();

           

            if (eval.getCurrentEnvt().isNameFinal(qname)) {

              this.cachedPrefix = function;

              registerCacheHandler(eval);

            }

          }

          else {

            cachedPrefix = null;

          }

        }

        java.util.List<org.rascalmpl.ast.Expression> args = this.getArguments();

        IValue[] actuals = new IValue[args.size()];

        Type[] types = new Type[args.size()];

        for (int i = 0; i < args.size(); i++) {

          Result<IValue> resultElem = args.get(i).interpret(eval);

          types[i] = resultElem.getType();

          if (types[i].isBottom()) {

            throw new UninitializedPatternMatch("The argument is of the type 'void'", args.get(i));

          }

          actuals[i] = resultElem.getValue();

        }

       

        java.util.Map<String,IValue> kwActuals = Collections.<String,IValue>emptyMap();

       

        if (hasKeywordArguments()) {

          KeywordArguments_Expression keywordArgs = this.getKeywordArguments();

          Type kwFormals = function.getKeywordArgumentTypes();

       

          if (keywordArgs.isDefault()){

            kwActuals = new HashMap<String,IValue>();

            for (KeywordArgument_Expression kwa : keywordArgs.getKeywordArgumentList()){

              Result<IValue> val = kwa.getExpression().interpret(eval);

              String name = Names.name(kwa.getName());

              if (kwFormals != null) {

                if (kwFormals.hasField(name)) {

                  if (!val.getType().isSubtypeOf(kwFormals.getFieldType(name))) {

                    throw new UnexpectedType(kwFormals.getFieldType(name), val.getType(), this);

                  }

                }

                else {

                  eval.getMonitor().warning("calling function with extra unknown keyword argument: " +  name, getLocation());

                }

              }

              kwActuals.put(name, val.getValue());

            }

          }

        }

        Result<IValue> res = null;

        try {

          res = function.call(types, actuals, kwActuals);

        }

        catch (MatchFailed e) {

          throw new ArgumentsMismatch(function, types, this);

        }

        return res;

      }

      catch (StackOverflowError e) {

        throw RuntimeExceptionFactory.stackOverflow(this, eval.getStackTrace());

      }

    }

    @Override

    public Type typeOf(Environment env, boolean instantiateTypeParameters, IEvaluator<Result<IValue>> eval) {

      Type lambda = getExpression().typeOf(env, instantiateTypeParameters, eval);

      if (lambda.isString()) {