public JexlExpressionParser() 
{
        this(System.getProperties());
}

 public JexlExpressionParser(Map vars) 
{
        if (vars == null) {
            throw new IllegalArgumentException("vars");
        }
        context = JexlHelper.createContext();
        context.setVars(vars);
        log.trace("Using variables: {}", context.getVars());
}

 public  void addVariables(Map map) 
{
        if (map == null) {
            throw new IllegalArgumentException("map");
        }
        getVariables().putAll(map);
}

 protected Expression createExpression(String expression) throws Exception 
{
        // assert expression != null;
        Expression expr = ExpressionFactory.createExpression(expression);
        expr.addPreResolver(resolver);
        return expr;
}

 public Object evaluate(String expression) throws Exception 
{
        if (expression == null) {
            throw new IllegalArgumentException("expression");
        }
        log.trace("Evaluating expression: {}", expression);
        Expression expr = createExpression(expression);
        Object obj = expr.evaluate(context);
        log.trace("Result: {}", obj);
        return obj;
}

 public Object getVariable(Object name) 
{
        if (name == null) {
            throw new IllegalArgumentException("name");
        }
        return getVariables().get(name);
}

 public Map getVariables() 
{
        return context.getVars();
}

 public String parse(String input) 
{
        if (input == null) {
            throw new IllegalArgumentException("input");
        }
        log.trace("Parsing input: {}", input);
        StringBuilder buff = new StringBuilder();
        int cur = 0;
        int prefixLoc;
        int suffixLoc;
        while (cur <  input.length()) {
            prefixLoc = input.indexOf("${", cur);
            if (prefixLoc <  0) {
                break;
            }
            suffixLoc = findBlockEnd(prefixLoc + 2, input);
            if (suffixLoc <  0) {
                throw new RuntimeException("Missing '}': " + input);
            }
            String expr = input.substring(prefixLoc + 2, suffixLoc);
            buff.append(input.substring(cur, prefixLoc));
            try {
                buff.append(evaluate(expr));
            }
            catch (Exception e) {
                throw new RuntimeException("Failed to evaluate: " + expr, e);
            }
            cur = suffixLoc + 1;
        }
        buff.append(input.substring(cur));
        log.trace("Parsed result: {}", buff);
        return buff.toString();
}

 public String parse(String input,
    boolean trim) 
{
        String output = parse(input);
        if (trim && output != null) {
            output = output.trim();
        }
        return output;
}

 public Object setVariable(Object name,
    Object value) 
{
        if (name == null) {
            throw new IllegalArgumentException("name");
        }
        return getVariables().put(name, value);
}

 public  void setVariables(Map map) 
{
        if (map == null) {
            throw new IllegalArgumentException("map");
        }
        context.setVars(map);
}

 public Object unsetVariable(Object name) 
{
        if (name == null) {
            throw new IllegalArgumentException("name");
        }
        return getVariables().remove(name);
}