Application: gvSIG desktop

package org.gvsig.expressionevaluator.impl;

import java.util.ArrayList;

import java.util.List;

import org.apache.commons.lang3.ArrayUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.Code.Caller;

import org.gvsig.expressionevaluator.Codes;

import org.gvsig.expressionevaluator.ExpressionSyntaxException;

import org.gvsig.expressionevaluator.LexicalAnalyzer.Token;

import org.gvsig.expressionevaluator.Statement;

import org.gvsig.expressionevaluator.Statement.CompoundRule;

import org.gvsig.expressionevaluator.Statement.ConditionalRule;

import org.gvsig.expressionevaluator.Statement.Rule;

import org.gvsig.expressionevaluator.Statement.StatementContext;

import org.gvsig.expressionevaluator.impl.function.programming.CodeBlockFunction;

import org.gvsig.expressionevaluator.impl.DefaultCodeBuilder.BaseCodes;

import org.gvsig.expressionevaluator.impl.function.programming.ListFunction;

/**

 *

 * @author jjdelcerro

 */

public class DefaultStatement implements Statement {

    private final List<Rule> rules;

    private String codeId;

    private ArgsBuilder argsBuilder;

    private final String name;

    public interface RepeatRule extends CompoundRule {

        public String getClassifier();

    }

    public class RuleRequireAnyToken implements Rule {

        private final String[] required_token;

        public RuleRequireAnyToken(String... required_token) {

            this.required_token = required_token;

        }

        public void parse(StatementContext context) {

            Token token = context.look_token();

            if (!token.is(this.required_token)) {

                throw new ExpressionSyntaxException(

                        I18N.A_XTokenX_was_expected_and_XliteralX_was_found(

                                StringUtils.join(this.required_token),

                                token.getLiteral()

                        ),

                        context.getLexicalAnalyzer()

                );

            }

            context.next_token();

        }

        private boolean isApplicable(StatementContext context) {

            Token token = context.look_token();

            return token.is(this.required_token);

        }

        @Override

        public String toString() {

            return "require_token(" + StringUtils.join(this.required_token) + ")";

        }

    }

    public class RuleRequireIdentifier implements Rule {

        private final String id;

        public RuleRequireIdentifier(String id) {

            this.id = id;

        }

        public void parse(StatementContext context) {

            Token token = context.look_token();

            if (token.getType() != Token.IDENTIFIER) {

                throw new ExpressionSyntaxException(

                        I18N.An_identifier_was_expected_and_XliteralX_was_found(token.getLiteral()),

                        context.getLexicalAnalyzer()

                );

            }

            String identifier = (String) token.getLiteral();

            Code code = context.getCodeBuilder().constant(identifier);

            context.setCode(id, code);

            context.next_token();

        }

        @Override

        public String toString() {

            return "require_identifier('" + this.id + "')";

        }

    }

    public class RuleRequireExpression implements Rule {

        private final String id;

        public RuleRequireExpression(String id) {

            this.id = id;

        }

        public void parse(StatementContext context) {

            Code code = context.parse_expression();

            if (code == null) {

                throw new ExpressionSyntaxException(context.getLexicalAnalyzer());

            }

            context.setCode(id, code);

        }

        @Override

        public String toString() {

            return "require_expression('" + this.id + "')";

        }

    }

    public class RuleRequiereExpressions implements Rule {

        private final String id;

        private final String separator;

        public RuleRequiereExpressions(String id, String separator) {

            this.id = id;

            this.separator = separator;

        }

        public void parse(StatementContext context) {

            Codes codes = context.parse_expressions(this.separator);

            if (codes == null) {

                throw new ExpressionSyntaxException(context.getLexicalAnalyzer());

            }

            Code code = context.getCodeBuilder().function(CodeBlockFunction.NAME, codes);

            context.setCode(id, code);

        }

        @Override

        public String toString() {

            return "require_expressions('" + this.id + "', '" + this.separator + "')";

        }

    }

    public class RuleOptionalAnyToken implements ConditionalRule {

        private final String[] optional_token;

        private final List<Rule> onTrueRules;

        private final List<Rule> onFalseRules;

        public RuleOptionalAnyToken(String... optional_token) {

            this.optional_token = optional_token;

            this.onTrueRules = new ArrayList<>();

            this.onFalseRules = new ArrayList<>();

        }

        public void parse(StatementContext context) {

            Token token = context.look_token();

            if (token.is(this.optional_token)) {

                context.next_token();

                for (Rule rule : this.onTrueRules) {

                    rule.parse(context);

                }

            } else {

                for (Rule rule : this.onFalseRules) {

                    rule.parse(context);

                }

            }

        }

        public RuleOptionalAnyToken addRuleOnTrue(Rule rule) {

            this.onTrueRules.add(rule);

            return this;

        }

        public RuleOptionalAnyToken addRuleOnFalse(Rule rule) {

            this.onFalseRules.add(rule);

            return this;

        }

        @Override

        public String toString() {

            return "optional_token(" + StringUtils.join(this.optional_token) + ") rules:" + StringUtils.join(onTrueRules, ",");

        }

    }

    public class RuleRepeatUntilAnyTokens implements RepeatRule {

        private final String[] exit_tokens;

        private final List<Rule> rules;

        private int counter;

        public RuleRepeatUntilAnyTokens(String[] exit_tokens) {

            this.exit_tokens = exit_tokens;

            this.rules = new ArrayList<>();

        }

        public void parse(StatementContext context) {

            String save = context.getCodeClassifier();

            try {

                this.counter = 1;

                while (true) {

                    Token token = context.look_token();

                    if (token.is(this.exit_tokens)) {

                        break;

                    }

                    context.setCodeClassifier(String.valueOf(counter).trim());

                    for (Rule rule : rules) {

                        rule.parse(context);

                    }

                    this.counter = this.counter + 1;

                }

            } finally {

                context.setCodeClassifier(save);

            }

        }

        public RuleRepeatUntilAnyTokens addRule(Rule rule) {

            this.rules.add(rule);

            return this;

        }

        @Override

        public String getClassifier() {

            String s = String.valueOf(counter).trim();

            return s;

        }

        @Override

        public String toString() {

            return "repeat_until_tokens('" + ArrayUtils.toString(this.exit_tokens) + "') rules:" + StringUtils.join(rules, ",");

        }

    }

    public class RuleOptionalIdentifiers implements Rule {

        private final String id;

        private final String separator;

        public RuleOptionalIdentifiers(String id, String separator) {

            this.id = id;

            this.separator = separator;

        }

        public void parse(StatementContext context) {

            BaseCodes args = (BaseCodes) context.getCodeBuilder().args();

            Token token = context.look_token();

            while (token.getType() == Token.IDENTIFIER) {

                String identifier = (String) token.getLiteral();

                Code code = context.getCodeBuilder().constant(identifier);

                args.add(code);

                context.next_token();

                token = context.look_token();

                if (!token.is(this.separator)) {

                    break;

                }

                context.next_token();

                token = context.look_token();

            }

            Code code = null;

            if (args.size() != 0) {

                code = context.getCodeBuilder().function(ListFunction.NAME, args);

            }

            context.setCode(id, code);

        }

        @Override

        public String toString() {

            return "optional_identifiers('" + id + "', '" + this.separator + "')";

        }

    }

    private static class ArgsBuilderFromNames implements ArgsBuilder {

        private final String[] argNames;

        public ArgsBuilderFromNames(String[] argNames) {

            this.argNames = argNames;

        }

        public Codes build(StatementContext context) {

            BaseCodes args = (BaseCodes) context.getCodeBuilder().args();

            for (String argName : argNames) {

                if (argName.contains("#")) {

                    int n = 1;

                    while (true) {

                        String argNameX = StringUtils.replace(argName, "#", String.valueOf(n).trim(), 1);

                        Code code = context.getCode(argNameX);

                        if (code == null) {

                            break;

                        }

                        args.add(code);

                        n++;

                    }

                } else {

                    Code code = context.getCode(argName);

                    args.add(code);

                }

            }

            return args;

        }

    }

    private static class ArgsBuilderExpand extends ArgsBuilderFromNames {

        public ArgsBuilderExpand(String[] argNames) {

            super(argNames);

        }

        public Codes build(StatementContext context) {

            BaseCodes args = (BaseCodes) context.getCodeBuilder().args();

            Codes base_args = super.build(context);

            for (Code arg : base_args) {

                if( arg.code() == Code.CALLER &&

                    ((Caller)arg).name().equals(CodeBlockFunction.NAME) ) {

                    Codes block_args = ((Caller)arg).parameters();

                    for (Code block_arg : block_args) {

                        args.add(block_arg);

                    }

                } else {

                    args.add(arg);

                }

            }

            return args;

        }

    }

    public DefaultStatement(String name) {

        this.rules = new ArrayList<>();

        this.codeId = null;

        this.argsBuilder = null;

        this.name = name;

    }

    public String getName() {

        return name;

    }

    @Override

    public Rule require_any_token(String... token) {

        return new RuleRequireAnyToken(token);

    }

    @Override

    public Rule require_identifier(String id) {

        return new RuleRequireIdentifier(id);

    }

    @Override

    public Rule require_expression(String id) {

        return new RuleRequireExpression(id);

    }

    @Override

    public Rule require_expressions(String id, String separator) {

        return new RuleRequiereExpressions(id, separator);

    }

    @Override

    public ConditionalRule optional_any_token(String... id) {

        return new RuleOptionalAnyToken(id);

    }

    @Override

    public Rule optional_identifiers(String id, String separator) {

        return new RuleOptionalIdentifiers(id, separator);

    }

    @Override

    public CompoundRule repeat_until_any_tokens(String... tokens) {

        return new RuleRepeatUntilAnyTokens(tokens);

    }

    @Override

    public Statement addRule(Rule rule) {

        this.rules.add(rule);

        return this;

    }

    @Override

    public boolean isApplicable(StatementContext context) {

        if (this.rules.isEmpty()) {

            return false;

        }

        Rule rule = this.rules.get(0);

        if (!(rule instanceof RuleRequireAnyToken)) {

            return false;

        }

        return ((RuleRequireAnyToken) rule).isApplicable(context);

    }

    @Override

    public ArgsBuilder args_names(String... args) {

        ArgsBuilder x = new ArgsBuilderFromNames(args);

        return x;

    }

    @Override

    public ArgsBuilder args_expand(String... args) {

        ArgsBuilder x = new ArgsBuilderExpand(args);

        return x;

    }

    @Override

    public void code(String id, ArgsBuilder argsBuilder) {

        this.codeId = id;

        this.argsBuilder = argsBuilder;

    }

    @Override

    public Code parse(StatementContext context) {

        for (Rule rule : rules) {

            rule.parse(context);

        }

        Codes args = this.argsBuilder.build(context);

        Code code;

        if (codeId == null) {

            code = args.get(0);

        } else {

            if (args.size() == 0) {

                code = context.getCodeBuilder().function(codeId, null);

            } else {

                code = context.getCodeBuilder().function(codeId, args);

            }

        }

        return code;

    }

    @Override

    public String toString() {

        return this.getName() + " " + StringUtils.join(this.rules, ";");

    }

}