Changeset 6882


Ignore:
Timestamp:
12/29/15 21:10:23 (9 years ago)
Author:
Oliver Schonefeld
Message:
  • add FCS-QL expression tree classes
  • modify FCSQueryParser to use expression tree
Location:
FCSSimpleEndpoint/trunk/src/main/java/eu/clarin/sru/server/fcs
Files:
22 added
1 edited

Legend:

Unmodified
Added
Removed
  • FCSSimpleEndpoint/trunk/src/main/java/eu/clarin/sru/server/fcs/FCSQueryParser.java

    r6858 r6882  
    11package eu.clarin.sru.server.fcs;
    22
    3 import java.util.ArrayList;
    43import java.util.Arrays;
    54import java.util.Collections;
     
    76import java.util.Map;
    87
    9 import org.antlr.v4.runtime.ANTLRInputStream;
    10 import org.antlr.v4.runtime.BaseErrorListener;
    11 import org.antlr.v4.runtime.CommonTokenStream;
    12 import org.antlr.v4.runtime.RecognitionException;
    13 import org.antlr.v4.runtime.Recognizer;
    14 import org.antlr.v4.runtime.tree.ParseTree;
    15 import eu.clarin.sru.fcs.qlparser.FCSLexer;
    16 import eu.clarin.sru.fcs.qlparser.FCSParser;
    178import eu.clarin.sru.server.SRUConstants;
    189import eu.clarin.sru.server.SRUDiagnosticList;
     
    2112import eu.clarin.sru.server.SRUQueryParser;
    2213import eu.clarin.sru.server.SRUVersion;
     14import eu.clarin.sru.server.fcs.parser.QueryNode;
     15import eu.clarin.sru.server.fcs.parser.QueryParser;
     16import eu.clarin.sru.server.fcs.parser.QueryParserException;
    2317
    24 public class FCSQueryParser implements SRUQueryParser<ParseTree> {
     18public class FCSQueryParser implements SRUQueryParser<QueryNode> {
    2519    private static final String PARAM_QUERY = "query";
    2620    private static final List<String> QUERY_PARAMETER_NAMES =
    2721            Collections.unmodifiableList(Arrays.asList(PARAM_QUERY));
     22    private final QueryParser parser = new QueryParser();
     23
    2824
    2925    @Override
     
    5854
    5955    @Override
    60     public SRUQuery<ParseTree> parseQuery(SRUVersion version,
     56    public SRUQuery<QueryNode> parseQuery(SRUVersion version,
    6157            Map<String, String> parameters, SRUDiagnosticList diagnostics) {
    6258        FCSQuery result = null;
     
    6965        }
    7066
    71         ParseErrorListener errorListener = new ParseErrorListener();
    7267        try {
    73             ANTLRInputStream input = new ANTLRInputStream(rawQuery);
    74             FCSLexer lexer = new FCSLexer(input);
    75             CommonTokenStream tokens = new CommonTokenStream(lexer);
    76             FCSParser parser = new FCSParser(tokens);
    77             /*
    78              * clear (possible) default error listeners and set our own!
    79              */
    80             lexer.removeErrorListeners();
    81             lexer.addErrorListener(errorListener);
    82             parser.removeErrorListeners();
    83             parser.addErrorListener(errorListener);
    84 
    85             /*
    86              * other Lexer/Parser configuration ...
    87              */
    88             parser.setTrimParseTree(true);
    89 
    90             /*
    91              * commence parsing ...
    92              */
    93             ParseTree tree = parser.query();
    94 
    95             if (!errorListener.hasErrors() &&
    96                     (parser.getNumberOfSyntaxErrors() == 0)) {
    97                 result = new FCSQuery(rawQuery, parser, tree);
    98             } else {
    99                 if (errorListener.hasErrors()) {
    100                     for (String error : errorListener.getErrors()) {
    101                         diagnostics.addDiagnostic(
    102                                 Constants.FCS_DIAGNOSTIC_GENERAL_QUERY_SYNTAX_ERROR,
    103                                 null, error);
    104                     }
    105                 } else {
    106                     diagnostics.addDiagnostic(
    107                             Constants.FCS_DIAGNOSTIC_GENERAL_QUERY_SYNTAX_ERROR,
    108                             null, "Query could not be parsed.");
    109                 }
    110             }
     68            QueryNode parsedQuery = parser.parse(rawQuery);
     69            result = new FCSQuery(rawQuery, parsedQuery);
     70        } catch (QueryParserException e) {
     71            diagnostics.addDiagnostic(Constants.FCS_DIAGNOSTIC_GENERAL_QUERY_SYNTAX_ERROR,
     72                    null, e.getMessage());
    11173        } catch (Exception e) {
    11274            diagnostics.addDiagnostic(SRUConstants.SRU_GENERAL_SYSTEM_ERROR,
     
    11779
    11880
    119     public static final class FCSQuery extends SRUQueryBase<ParseTree> {
    120         private final FCSParser parser;
     81    public static final class FCSQuery extends SRUQueryBase<QueryNode> {
    12182
    122         private FCSQuery(String rawQuery,
    123                 FCSParser parser,
    124                 ParseTree parsedQuery) {
     83        private FCSQuery(String rawQuery, QueryNode parsedQuery) {
    12584            super(rawQuery, parsedQuery);
    126             this.parser = parser;
    12785        }
    12886
     
    13290            return Constants.FCS_QUERY_TYPE_FCS;
    13391        }
    134 
    135 
    136         /**
    137          * EXPERIMENTAL API: Get the parser that was used to parse the query.
    138          * Useful for outputting the parse tree.
    139          *
    140          * @return the parser that was used to parse the query.
    141          */
    142         public FCSParser getFCSParser() {
    143             return parser;
    144         }
    145     }
    146 
    147 
    148     private static final class ParseErrorListener extends BaseErrorListener {
    149         private List<String> errors = null;
    150 
    151 
    152         @Override
    153         public void syntaxError(Recognizer<?, ?> recognizer,
    154                 Object offendingSymbol, int line, int charPositionInLine,
    155                 String msg, RecognitionException e) {
    156             if (errors == null) {
    157                 errors = new ArrayList<String>();
    158             }
    159             errors.add(msg);
    160         }
    161 
    162 
    163         public boolean hasErrors() {
    164             return (errors != null) && !errors.isEmpty();
    165         }
    166 
    167 
    168         public List<String> getErrors() {
    169             return errors;
    170         }
    17192    }
    17293
Note: See TracChangeset for help on using the changeset viewer.