| /* |
| * Copyright (c) 1997, 2018 Oracle and/or its affiliates. All rights reserved. |
| * |
| * This program and the accompanying materials are made available under the |
| * terms of the Eclipse Public License v. 2.0, which is available at |
| * http://www.eclipse.org/legal/epl-2.0. |
| * |
| * This Source Code may also be made available under the following Secondary |
| * Licenses when the conditions for such availability set forth in the |
| * Eclipse Public License v. 2.0 are satisfied: GNU General Public License, |
| * version 2 with the GNU Classpath Exception, which is available at |
| * https://www.gnu.org/software/classpath/license.html. |
| * |
| * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0 |
| */ |
| |
| /* |
| * Semantic.g |
| * |
| * Created on March 8, 2000 |
| */ |
| |
| header |
| { |
| package com.sun.jdo.spi.persistence.support.sqlstore.query.jqlc; |
| |
| import java.util.Locale; |
| import java.util.ResourceBundle; |
| import java.util.Collection; |
| |
| import org.glassfish.persistence.common.I18NHelper; |
| |
| import com.sun.jdo.spi.persistence.support.sqlstore.query.util.type.TypeTable; |
| import com.sun.jdo.spi.persistence.support.sqlstore.query.util.type.Type; |
| import com.sun.jdo.spi.persistence.support.sqlstore.query.util.type.ClassType; |
| import com.sun.jdo.spi.persistence.support.sqlstore.query.util.type.FieldInfo; |
| import com.sun.jdo.spi.persistence.support.sqlstore.query.util.type.NumericType; |
| import com.sun.jdo.spi.persistence.support.sqlstore.query.util.type.NumericWrapperClassType; |
| |
| import com.sun.jdo.spi.persistence.support.sqlstore.query.util.scope.SymbolTable; |
| import com.sun.jdo.spi.persistence.support.sqlstore.query.util.scope.Definition; |
| import com.sun.jdo.spi.persistence.support.sqlstore.query.util.scope.TypeName; |
| import com.sun.jdo.spi.persistence.support.sqlstore.query.util.scope.Variable; |
| import com.sun.jdo.spi.persistence.support.sqlstore.query.util.scope.Parameter; |
| import com.sun.jdo.spi.persistence.support.sqlstore.query.util.scope.Field; |
| } |
| |
| /** |
| * This class defines the semantic analysis of the JQL compiler. |
| * Input of this pass is the AST as produced by the parser, |
| * that consists of JQLAST nodes. |
| * The result is a typed JQLAST tree. |
| * |
| * @author Michael Bouschen |
| * @author Shing Wai Chan |
| * @version 0.1 |
| */ |
| class Semantic extends TreeParser; |
| |
| options |
| { |
| importVocab = JQL; |
| buildAST = true; |
| defaultErrorHandler = false; |
| ASTLabelType = "JQLAST"; //NOI18N |
| } |
| |
| { |
| /** |
| * I18N support |
| */ |
| protected final static ResourceBundle messages = |
| I18NHelper.loadBundle(Semantic.class); |
| |
| /** |
| * symbol table handling names of fields, variables and parameters |
| */ |
| protected SymbolTable symtab; |
| |
| /** |
| * symbol table handling type names (candidate class and imported names) |
| */ |
| protected SymbolTable typeNames; |
| |
| /** |
| * type table |
| */ |
| protected TypeTable typetab; |
| |
| /** |
| * query parameter table |
| */ |
| protected ParameterTable paramtab; |
| |
| /** |
| * variable table |
| */ |
| protected VariableTable vartab; |
| |
| /** |
| * |
| */ |
| protected ErrorMsg errorMsg; |
| |
| /** |
| * Result class for this query. This class is set by setClass. |
| */ |
| protected ClassType candidateClass; |
| |
| /** |
| * |
| */ |
| public void init(TypeTable typetab, ParameterTable paramtab, ErrorMsg errorMsg) |
| { |
| this.symtab = new SymbolTable(); |
| this.typeNames = new SymbolTable(); |
| this.vartab = new VariableTable(errorMsg); |
| this.typetab = typetab; |
| this.paramtab = paramtab; |
| this.errorMsg = errorMsg; |
| } |
| |
| /** |
| * |
| */ |
| public void reportError(RecognitionException ex) { |
| errorMsg.fatal("Error: " + ex); //NOI18N |
| } |
| |
| /** |
| * |
| */ |
| public void reportError(String s) { |
| errorMsg.fatal("Error: " + s); //NOI18N |
| } |
| |
| /** |
| * Combines partial ASTs into one query AST. |
| */ |
| public JQLAST createQueryAST(JQLAST candidateClass, |
| JQLAST importsAST, |
| JQLAST paramsAST, |
| JQLAST varsAST, |
| JQLAST orderingAST, |
| JQLAST resultAST, |
| JQLAST filterAST) |
| { |
| JQLAST query = new JQLAST(QUERY, "query", null); //NOI18N |
| if (candidateClass != null) |
| query.addChild(candidateClass); |
| if (importsAST != null) |
| query.addChild(importsAST); |
| if (paramsAST != null) |
| query.addChild(paramsAST); |
| if (varsAST != null) |
| query.addChild(varsAST); |
| if (orderingAST != null) |
| query.addChild(orderingAST); |
| if (resultAST != null) |
| query.addChild(resultAST); |
| if (filterAST != null) |
| query.addChild(filterAST); |
| return query; |
| } |
| |
| /** |
| * Creates the CLASS_DEF AST that represents the setClass value. |
| */ |
| public JQLAST checkCandidateClass(Class candidateClass) |
| { |
| Type type = typetab.checkType(candidateClass); |
| if (type == null) |
| { |
| errorMsg.fatal(I18NHelper.getMessage(messages, |
| "jqlc.semantic.checkcandidateclass.unknowntype", //NOI18N |
| String.valueOf(candidateClass))); |
| } |
| return new JQLAST(CLASS_DEF, "classDef", type); //NOI18N |
| } |
| |
| /** |
| * This method analyses the expression of a single ordering definition. |
| * It checks whether the expression |
| * - is valid (see checkValidOrderingExpr) |
| * - is of a orderable type |
| * @param expr the expression of an ordering definition |
| */ |
| protected void analyseOrderingExpression(JQLAST expr) |
| { |
| checkValidOrderingExpr(expr); |
| Type exprType = expr.getJQLType(); |
| if (!exprType.isOrderable()) |
| { |
| errorMsg.error(expr.getLine(), expr.getColumn(), |
| I18NHelper.getMessage(messages, "jqlc.semantic.analyseorderingexpression.notorderable", //NOI18N |
| exprType.getName())); |
| expr.setJQLType(typetab.errorType); |
| } |
| } |
| |
| /** |
| * This method checks whether the ordering expression is valid. |
| * The following expressions are valid: |
| * - field access using the this object |
| * - navigation from a field of the this object |
| * @param expr the ordering definition |
| */ |
| private void checkValidOrderingExpr(JQLAST expr) |
| { |
| switch(expr.getType()) |
| { |
| case THIS: |
| case VARIABLE: |
| //OK; |
| break; |
| case FIELD_ACCESS: |
| case NAVIGATION: |
| JQLAST child = (JQLAST)expr.getFirstChild(); |
| if (child != null) |
| { |
| // check first part of dot expr |
| checkValidOrderingExpr(child); |
| } |
| break; |
| default: |
| errorMsg.error(expr.getLine(), expr.getColumn(), |
| I18NHelper.getMessage(messages, "jqlc.semantic.checkvalidorderingexpr.invalidordering", //NOI18N |
| expr.getText())); |
| } |
| } |
| |
| /** |
| * This method checks whether the result expression is valid. |
| * The following expressions are valid: |
| * - field access using the this object |
| * - navigation from a field of the this object |
| * - variable access |
| * - distinct expression |
| * - aggreagte expression |
| * @param expr the result expression |
| */ |
| private void checkValidResultExpr(JQLAST expr) |
| { |
| switch(expr.getType()) |
| { |
| case THIS: |
| //OK; |
| break; |
| case FIELD_ACCESS: |
| case NAVIGATION: |
| JQLAST child = (JQLAST)expr.getFirstChild(); |
| if (child != null) |
| { |
| // check first part of dot expr |
| checkValidResultExpr(child); |
| } |
| break; |
| case VARIABLE: |
| // OK |
| break; |
| case DISTINCT: |
| checkValidResultExpr((JQLAST)expr.getFirstChild()); |
| break; |
| case AVG: |
| case SUM: |
| if (!typetab.isNumberType(expr.getJQLType()) || |
| typetab.isCharType(expr.getJQLType())) { |
| errorMsg.error(expr.getLine(), expr.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.semantic.checkvalidresultexpr.invalidavgsumexpr", //NOI18N |
| expr.getJQLType().getName(), expr.getText())); |
| } |
| checkValidResultExpr((JQLAST)expr.getFirstChild()); |
| break; |
| case MAX: |
| case MIN: |
| if (!expr.getJQLType().isOrderable()) { |
| errorMsg.error(expr.getLine(), expr.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.semantic.checkvalidresultexpr.invalidminmaxexpr", //NOI18N |
| expr.getJQLType().getName(), expr.getText())); |
| } |
| checkValidResultExpr((JQLAST)expr.getFirstChild()); |
| break; |
| case COUNT: |
| checkValidResultExpr((JQLAST)expr.getFirstChild()); |
| break; |
| default: |
| errorMsg.error(expr.getLine(), expr.getColumn(), |
| I18NHelper.getMessage(messages, "jqlc.semantic.checkvalidresultexpr.invalidresult", //NOI18N |
| expr.getText())); |
| } |
| } |
| |
| /** |
| * Checks that result and ordering are compatible. |
| * If the query result is a field, then it must be the same as ordering |
| * item. If the query is an object, then ordering expression must |
| * have the same navigation prefix of the result expression. |
| */ |
| private void checkResultOrdering(JQLAST result, JQLAST ordering) { |
| if (ordering == null) { |
| return; |
| } |
| |
| AST resultReturnAST = result; |
| boolean hasResultDistinct = false; |
| if (resultReturnAST == null) { // distinct THIS |
| resultReturnAST = new JQLAST(THIS, "this", candidateClass); |
| hasResultDistinct = true; |
| } |
| |
| // skip RESULT_DEF node |
| if (resultReturnAST.getType() == RESULT_DEF) { |
| resultReturnAST = resultReturnAST.getFirstChild(); |
| } |
| // skip DISTINCT node |
| if (resultReturnAST.getType() == DISTINCT) { |
| resultReturnAST = resultReturnAST.getFirstChild(); |
| hasResultDistinct = true; |
| } |
| |
| if (!hasResultDistinct) { |
| return; |
| } |
| |
| if (resultReturnAST.getType() == FIELD_ACCESS) { |
| StringBuffer buf = new StringBuffer(); |
| genPathExpression(resultReturnAST, buf); |
| String resultReturnPathExpr = buf.toString(); |
| |
| for (AST sibling = ordering; |
| sibling != null && sibling.getType() == ORDERING_DEF; |
| sibling = sibling.getNextSibling()) { |
| |
| // share buf |
| buf.setLength(0); |
| genPathExpression(sibling.getFirstChild().getNextSibling(), buf); |
| String orderingItemExpr = buf.toString(); |
| if (!orderingItemExpr.equals(resultReturnPathExpr)) { |
| errorMsg.error(ordering.getLine(), ordering.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.semantic.checkresultordering.invalidorderingfordistinctresultfield", //NOI18N |
| resultReturnPathExpr, orderingItemExpr)); |
| } |
| } |
| } else if (resultReturnAST.getType() == NAVIGATION || |
| resultReturnAST.getType() == THIS ) { |
| StringBuffer buf = new StringBuffer(); |
| genPathExpression(resultReturnAST, buf); |
| String resultReturnPathExpr = buf.toString(); |
| |
| for (AST sibling = ordering; |
| sibling != null && sibling.getType() == ORDERING_DEF; |
| sibling = sibling.getNextSibling()) { |
| |
| // share buf |
| buf.setLength(0); |
| genPathExpression(sibling.getFirstChild().getNextSibling().getFirstChild(), buf); |
| String orderingRootExpr = buf.toString(); |
| if (!orderingRootExpr.equals(resultReturnPathExpr)) { |
| buf.setLength(0); |
| genPathExpression(sibling.getFirstChild().getNextSibling(), buf); |
| errorMsg.error(ordering.getLine(), ordering.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.semantic.checkresultordering.invalidorderingfordistinctresult", //NOI18N |
| resultReturnPathExpr, buf.toString())); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Form a string representation of a dot expression and append to given |
| * StringBuffer. |
| * @param ast the AST node representing the root the of the expression |
| * @param buf the StringBuffer that will have result of path expression |
| * append |
| */ |
| private void genPathExpression(AST ast, StringBuffer buf) { |
| if (ast == null) { |
| return; |
| } |
| switch (ast.getType()) { |
| case FIELD_ACCESS: |
| case STATIC_FIELD_ACCESS: |
| case NAVIGATION: |
| AST left = ast.getFirstChild(); |
| AST right = left.getNextSibling(); |
| genPathExpression(left, buf); |
| buf.append('.'); |
| genPathExpression(right, buf); |
| break; |
| default: |
| buf.append(ast.getText()); |
| break; |
| } |
| } |
| |
| |
| /** |
| * This method analyses a dot expression of the form expr.ident or |
| * expr.ident(params) where expr itself can again be a dot expression. |
| * It checks whether the dot expression is |
| * - part of a qualified class name specification |
| * - field access, |
| * - a method call |
| * The method returns a temporary single AST node that is defined with a |
| * specific token type (field access, method call, etc.). This node also |
| * contains the type of the dot expression. |
| * @param expr the left hand side of the dot expression |
| * @param ident the right hand side of the dot expression |
| * @param args arguments (in the case of a call) |
| * @return AST node representing the specialized dot expr |
| */ |
| protected JQLAST analyseDotExpr(JQLAST dot, JQLAST expr, JQLAST ident, JQLAST args) |
| { |
| Type exprType = expr.getJQLType(); |
| String name = ident.getText(); |
| dot.setText(expr.getText() + '.' + name); |
| if (exprType instanceof ClassType) |
| { |
| // left expression is of a class type |
| ClassType classType = (ClassType)exprType; |
| if (args == null) |
| { |
| // no paranethesis specified => field access |
| FieldInfo fieldInfo = classType.getFieldInfo(name); |
| if (fieldInfo == null) |
| { |
| errorMsg.error(ident.getLine(), ident.getColumn(), |
| I18NHelper.getMessage(messages, "jqlc.semantic.generic.unknownfield", //NOI18N |
| ident.getText(), exprType.getName())); |
| dot.setJQLType(typetab.errorType); |
| ident.setJQLType(typetab.errorType); |
| return dot; |
| } |
| else if (expr.getType() == TYPENAME) |
| { |
| // access of the form: className.staticField |
| return analyseStaticFieldAccess(dot, expr, ident, classType, fieldInfo); |
| } |
| else |
| { |
| // access of the form: object.field |
| return analyseFieldAccess(dot, expr, ident, classType, fieldInfo); |
| } |
| } |
| else |
| { |
| // parenthesis specified => method call |
| if (typetab.isCollectionType(exprType)) |
| { |
| return analyseCollectionCall(dot, expr, ident, args); |
| } |
| else if (exprType.equals(typetab.stringType)) |
| { |
| return analyseStringCall(dot, expr, ident, args); |
| } |
| else if (typetab.isJavaLangMathType(exprType)) |
| { |
| return analyseMathCall(dot, expr, ident, args); |
| } |
| errorMsg.error(dot.getLine(), dot.getColumn(), |
| I18NHelper.getMessage(messages, "jqlc.semantic.generic.invalidmethodcall")); //NOI18N |
| dot.setJQLType(typetab.errorType); |
| return dot; |
| } |
| } |
| else |
| { |
| errorMsg.error(expr.getLine(), expr.getColumn(), |
| I18NHelper.getMessage(messages, "jqlc.semantic.analysedotexpr.classexprexpected", //NOI18N |
| ident.getText(), exprType.getName())); |
| dot.setJQLType(typetab.errorType); |
| return dot; |
| } |
| } |
| |
| /** |
| * |
| */ |
| protected JQLAST analyseFieldAccess(JQLAST access, JQLAST objectExpr, JQLAST ident, |
| ClassType classType, FieldInfo fieldInfo) |
| { |
| String name = ident.getText(); |
| Type fieldType = fieldInfo.getType(); |
| if (classType.isPersistenceCapable()) |
| { |
| if (!fieldInfo.isPersistent()) |
| { |
| errorMsg.error(ident.getLine(), ident.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.semantic.analysefieldaccess.nonperistentfield", name, classType.getName())); //NOI18N |
| } |
| if (typetab.isPersistenceCapableType(fieldType)) |
| { |
| access.setType(NAVIGATION); |
| } |
| else |
| { |
| access.setType(FIELD_ACCESS); |
| } |
| } |
| else |
| { |
| if (!fieldInfo.isPublic()) |
| { |
| errorMsg.error(ident.getLine(), ident.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.semantic.analysefieldaccess.nonpublicfield", name, classType.getName())); //NOI18N |
| } |
| access.setType(FIELD_ACCESS); |
| } |
| access.setText(objectExpr.getText() + '.' + name); |
| access.setJQLType(fieldType); |
| ident.setJQLType(fieldType); |
| access.setFirstChild(objectExpr); |
| objectExpr.setNextSibling(ident); |
| return access; |
| } |
| |
| /** |
| * |
| */ |
| protected JQLAST analyseStaticFieldAccess(JQLAST access, JQLAST typename, JQLAST ident, |
| ClassType classType, FieldInfo fieldInfo) |
| { |
| String name = ident.getText(); |
| Type fieldType = fieldInfo.getType(); |
| if (!fieldInfo.isStatic()) |
| { |
| errorMsg.error(ident.getLine(), ident.getColumn(), |
| I18NHelper.getMessage(messages, "jqlc.semantic.analysestaticfieldaccess.staticreference", //NOI18N |
| ident.getText(), classType.getName())); |
| } |
| if (!fieldInfo.isPublic()) |
| { |
| errorMsg.error(ident.getLine(), ident.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.semantic.analysestaticfieldaccess.nonpublicfield", name, classType.getName())); //NOI18N |
| } |
| access.setType(STATIC_FIELD_ACCESS); |
| access.setText(typename.getText() + '.' + name); |
| access.setJQLType(fieldType); |
| ident.setJQLType(fieldType); |
| access.setFirstChild(typename); |
| typename.setNextSibling(ident); |
| return access; |
| } |
| |
| /** |
| * This method analyses and identifier defined in the current scope: |
| * - a field, variable or parameter defined in the symbol table |
| * - a type define in a separate symbol table for type names |
| * @param ident the identifier AST |
| * @param def the entry in the symbol table of the type names tables |
| * @return AST node representing a defined identifier |
| */ |
| protected JQLAST analyseDefinedIdentifier(JQLAST ident, Definition def) |
| { |
| Type type = def.getType(); |
| if (def instanceof Variable) |
| { |
| ident.setType(VARIABLE); |
| } |
| else if (def instanceof Parameter) |
| { |
| ident.setType(PARAMETER); |
| } |
| else if (def instanceof Field) |
| { |
| FieldInfo fieldInfo = ((Field)def).getFieldInfo(); |
| JQLAST fieldAccessAST = ident; |
| JQLAST identAST = new JQLAST(ident); |
| if (fieldInfo.isStatic()) |
| { |
| JQLAST typeNameAST = new JQLAST(TYPENAME, candidateClass.getName(), candidateClass); |
| ident = analyseStaticFieldAccess(fieldAccessAST, typeNameAST, |
| identAST, candidateClass, fieldInfo); |
| } |
| else |
| { |
| JQLAST thisAST = new JQLAST(THIS, "this", candidateClass); //NOI18N |
| ident = analyseFieldAccess(fieldAccessAST, thisAST, |
| identAST, candidateClass, fieldInfo); |
| } |
| } |
| else if (def instanceof TypeName) |
| { |
| ident.setType(TYPENAME); |
| ident.setText(((TypeName)def).getQualifiedName()); |
| } |
| else |
| { |
| type = typetab.errorType; |
| errorMsg.fatal(I18NHelper.getMessage(messages, |
| "jqlc.semantic.analysedefinedidentifier.illegalident", //NOI18N |
| String.valueOf(def))); |
| } |
| ident.setJQLType(type); |
| return ident; |
| } |
| |
| /** |
| * Analyses a call for an object that implements Collection. |
| * Currently, contains is the only valid Collection method in a query filter. |
| */ |
| protected JQLAST analyseCollectionCall(JQLAST dot, JQLAST collection, JQLAST method, JQLAST args) |
| { |
| String methodName = method.getText(); |
| JQLAST firstArg = (JQLAST)args.getFirstChild(); |
| if (methodName.equals("contains")) //NOI18N |
| { |
| checkContainsArgs(collection, method, firstArg); |
| dot.setType(CONTAINS); |
| dot.setJQLType(typetab.booleanType); |
| dot.setFirstChild(collection); |
| collection.setNextSibling(firstArg); |
| return dot; |
| } |
| else if (methodName.equals("isEmpty")) //NOI18N |
| { |
| // isEmpty does not take parameters |
| checkNoArgs(method, firstArg); |
| dot.setType(IS_EMPTY); |
| dot.setJQLType(typetab.booleanType); |
| dot.setFirstChild(collection); |
| collection.setNextSibling(null); |
| return dot; |
| } |
| |
| errorMsg.error(dot.getLine(), dot.getColumn(), |
| I18NHelper.getMessage(messages, "jqlc.semantic.generic.invalidmethodcall")); //NOI18N |
| dot.setJQLType(typetab.errorType); |
| return dot; |
| } |
| |
| /** |
| * Analyses a call for an object of type String. |
| * Currently startsWith and endsWith are the only valid String methods in a query filter |
| */ |
| protected JQLAST analyseStringCall(JQLAST dot, JQLAST string, JQLAST method, JQLAST args) |
| { |
| String methodName = method.getText(); |
| JQLAST firstArg = (JQLAST)args.getFirstChild(); |
| if (methodName.equals("startsWith")) //NOI18N |
| { |
| dot.setType(STARTS_WITH); |
| checkOneStringArg(method, firstArg); |
| dot.setJQLType(typetab.booleanType); |
| dot.setFirstChild(string); |
| string.setNextSibling(firstArg); |
| } |
| else if (methodName.equals("endsWith")) //NOI18N |
| { |
| dot.setType(ENDS_WITH); |
| checkOneStringArg(method, firstArg); |
| dot.setJQLType(typetab.booleanType); |
| dot.setFirstChild(string); |
| string.setNextSibling(firstArg); |
| } |
| else if (methodName.equals("like")) //NOI18N |
| { |
| checkLikeArgs(method, firstArg); |
| dot.setType(LIKE); |
| dot.setJQLType(typetab.booleanType); |
| dot.setFirstChild(string); |
| string.setNextSibling(firstArg); |
| } |
| else if (methodName.equals("substring")) //NOI18N |
| { |
| checkTwoIntArgs(method, firstArg); |
| dot.setType(SUBSTRING); |
| dot.setJQLType(typetab.stringType); |
| dot.setFirstChild(string); |
| string.setNextSibling(firstArg); |
| } |
| else if (methodName.equals("indexOf")) //NOI18N |
| { |
| checkIndexOfArgs(method, firstArg); |
| dot.setType(INDEXOF); |
| dot.setJQLType(typetab.intType); |
| dot.setFirstChild(string); |
| string.setNextSibling(firstArg); |
| } |
| else if (methodName.equals("length")) //NOI18N |
| { |
| // length does not take parameters |
| checkNoArgs(method, firstArg); |
| dot.setType(LENGTH); |
| dot.setJQLType(typetab.intType); |
| dot.setFirstChild(string); |
| string.setNextSibling(null); |
| } |
| else |
| { |
| errorMsg.error(dot.getLine(), dot.getColumn(), |
| I18NHelper.getMessage(messages, "jqlc.semantic.generic.invalidmethodcall")); //NOI18N |
| dot.setJQLType(typetab.errorType); |
| } |
| return dot; |
| } |
| |
| /** |
| * Analyses a java.lang.Math call. |
| */ |
| protected JQLAST analyseMathCall(JQLAST dot, JQLAST type, JQLAST method, JQLAST args) |
| { |
| String methodName = method.getText(); |
| JQLAST firstArg = (JQLAST)args.getFirstChild(); |
| if (methodName.equals("abs")) //NOI18N |
| { |
| checkAbsArgs(method, firstArg); |
| dot.setType(ABS); |
| dot.setJQLType(firstArg.getJQLType()); |
| dot.setFirstChild(firstArg); |
| } |
| else if (methodName.equals("sqrt")) //NOI18N |
| { |
| checkSqrtArgs(method, firstArg); |
| dot.setType(SQRT); |
| dot.setJQLType(firstArg.getJQLType()); |
| dot.setFirstChild(firstArg); |
| } |
| else |
| { |
| errorMsg.error(dot.getLine(), dot.getColumn(), |
| I18NHelper.getMessage(messages, "jqlc.semantic.generic.invalidmethodcall")); //NOI18N |
| dot.setJQLType(typetab.errorType); |
| } |
| return dot; |
| } |
| |
| /** |
| * This method checks the specified node (args) representing an empty |
| * argument list. |
| */ |
| protected void checkNoArgs(JQLAST method, JQLAST firstArg) |
| { |
| if (firstArg != null) |
| { |
| errorMsg.error(firstArg.getLine(), firstArg.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.semantic.generic.arguments.numbermismatch")); //NOI18N |
| } |
| } |
| |
| /** |
| * This method checks the specified node (args) representing an argument |
| * list which consists of a single argument of type String. |
| */ |
| protected void checkOneStringArg(JQLAST method, JQLAST firstArg) |
| { |
| if (firstArg == null) |
| { |
| errorMsg.error(method.getLine(), method.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.semantic.generic.arguments.numbermismatch")); //NOI18N |
| } |
| else if (firstArg.getNextSibling() != null) |
| { |
| JQLAST nextArg = (JQLAST)firstArg.getNextSibling(); |
| errorMsg.error(nextArg.getLine(), nextArg.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.semantic.generic.arguments.numbermismatch")); //NOI18N |
| } |
| else |
| { |
| Type argType = firstArg.getJQLType(); |
| if (!argType.equals(typetab.stringType)) |
| { |
| errorMsg.error(firstArg.getLine(), firstArg.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.semantic.generic.arguments.typemismatch", //NOI18N |
| argType.getName(), typetab.stringType.getName())); |
| } |
| } |
| } |
| |
| /** |
| * This method checks the specified node (args) representing a valid contains |
| * argument list: one argument denoting a variable. |
| */ |
| protected void checkContainsArgs(JQLAST collection, JQLAST method, JQLAST firstArg) |
| { |
| if (firstArg == null) |
| { |
| errorMsg.error(method.getLine(), method.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.semantic.generic.arguments.numbermismatch")); //NOI18N |
| } |
| else if (firstArg.getNextSibling() != null) |
| { |
| JQLAST nextArg = (JQLAST)firstArg.getNextSibling(); |
| errorMsg.error(nextArg.getLine(), nextArg.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.semantic.generic.arguments.numbermismatch")); //NOI18N |
| } |
| else if (firstArg.getType() != VARIABLE) |
| { |
| errorMsg.unsupported(firstArg.getLine(), firstArg.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.semantic.analysecollectioncall.nonvariable")); //NOI18N |
| } |
| else |
| { |
| FieldInfo collectionFieldInfo = getCollectionField(collection); |
| if (collectionFieldInfo == null) |
| { |
| errorMsg.unsupported(collection.getLine(), collection.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.semantic.analysecollectioncall.unsupportedcollectionexpr", //NOI18N |
| collection.getText())); |
| } |
| else if (!collectionFieldInfo.isRelationship()) |
| { |
| // check compatibilty of collection element type and type of variable |
| errorMsg.error(collection.getLine(), collection.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.semantic.analysecollectioncall.relationshipexpected", //NOI18N |
| collectionFieldInfo.getName())); |
| } |
| Type variableType = firstArg.getJQLType(); |
| Type elementType = collectionFieldInfo.getAssociatedClass(); |
| if (!elementType.isCompatibleWith(variableType)) |
| { |
| errorMsg.error(collection.getLine(), collection.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.semantic.analysecollectioncall.typemismatch", //NOI18N |
| elementType.getName(), variableType.getName())); |
| } |
| } |
| } |
| |
| /** |
| * This method checks the specified node (args) representing a valid like |
| * argument list: a string argument plus an optional char argument. |
| */ |
| protected void checkLikeArgs(JQLAST method, JQLAST firstArg) |
| { |
| if (firstArg == null) |
| { |
| errorMsg.error(method.getLine(), method.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.semantic.generic.arguments.numbermismatch")); //NOI18N |
| } |
| else if ((firstArg.getNextSibling() != null) && |
| (firstArg.getNextSibling().getNextSibling() != null)) |
| { |
| JQLAST nextArg = (JQLAST)firstArg.getNextSibling().getNextSibling(); |
| errorMsg.error(nextArg.getLine(), nextArg.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.semantic.generic.arguments.numbermismatch")); //NOI18N |
| } |
| else |
| { |
| // check type of first arg |
| Type firstArgType = firstArg.getJQLType(); |
| if (!firstArgType.equals(typetab.stringType)) |
| { |
| errorMsg.error(firstArg.getLine(), firstArg.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.semantic.generic.arguments.typemismatch", //NOI18N |
| firstArgType.getName(), typetab.stringType.getName())); |
| } |
| // check type of second arg (if available) |
| JQLAST secondArg = (JQLAST)firstArg.getNextSibling(); |
| if (secondArg != null) |
| { |
| Type secondArgType = secondArg.getJQLType(); |
| if (!typetab.isCharType(secondArgType)) |
| { |
| errorMsg.error(secondArg.getLine(), secondArg.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.semantic.generic.arguments.typemismatch", //NOI18N |
| secondArgType.getName(), typetab.charType.getName())); |
| } |
| } |
| } |
| } |
| |
| /** |
| * This method checks the specified node (args) representing an argument |
| * list which consists of two integer arguments. |
| */ |
| protected void checkTwoIntArgs(JQLAST method, JQLAST firstArg) |
| { |
| if (firstArg == null) |
| { |
| // no args specified |
| errorMsg.error(method.getLine(), method.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.semantic.generic.arguments.numbermismatch")); //NOI18N |
| } |
| else if (firstArg.getNextSibling() == null) |
| { |
| // one arg specified |
| errorMsg.error(method.getLine(), method.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.semantic.generic.arguments.numbermismatch")); //NOI18N |
| } |
| else if (firstArg.getNextSibling().getNextSibling() != null) |
| { |
| // more than two args specified |
| JQLAST nextArg = (JQLAST)firstArg.getNextSibling().getNextSibling(); |
| errorMsg.error(nextArg.getLine(), nextArg.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.semantic.generic.arguments.numbermismatch")); //NOI18N |
| } |
| else |
| { |
| // specified two args |
| // check type of first arg |
| Type firstArgType = firstArg.getJQLType(); |
| if (!typetab.isIntType(firstArgType)) |
| { |
| errorMsg.error(firstArg.getLine(), firstArg.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.semantic.generic.arguments.typemismatch", //NOI18N |
| firstArgType.getName(), typetab.intType.getName())); |
| } |
| // check type of second arg |
| JQLAST secondArg = (JQLAST)firstArg.getNextSibling(); |
| Type secondArgType = firstArg.getJQLType(); |
| if (!typetab.isIntType(secondArgType)) |
| { |
| errorMsg.error(secondArg.getLine(), secondArg.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.semantic.generic.arguments.typemismatch", //NOI18N |
| secondArgType.getName(), typetab.intType.getName())); |
| } |
| } |
| } |
| |
| /** |
| * This method checks the specified node (args) representing a valid indexOf |
| * argument list: a string argument plus an optional char argument. |
| */ |
| protected void checkIndexOfArgs(JQLAST method, JQLAST firstArg) |
| { |
| if (firstArg == null) |
| { |
| errorMsg.error(method.getLine(), method.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.semantic.generic.arguments.numbermismatch")); //NOI18N |
| } |
| else if ((firstArg.getNextSibling() != null) && |
| (firstArg.getNextSibling().getNextSibling() != null)) |
| { |
| JQLAST nextArg = (JQLAST)firstArg.getNextSibling().getNextSibling(); |
| errorMsg.error(nextArg.getLine(), nextArg.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.semantic.generic.arguments.numbermismatch")); //NOI18N |
| } |
| else |
| { |
| // check type of first arg |
| Type firstArgType = firstArg.getJQLType(); |
| if (!firstArgType.equals(typetab.stringType)) |
| { |
| errorMsg.error(firstArg.getLine(), firstArg.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.semantic.generic.arguments.typemismatch", //NOI18N |
| firstArgType.getName(), typetab.stringType.getName())); |
| } |
| // check type of second arg (if available) |
| JQLAST secondArg = (JQLAST)firstArg.getNextSibling(); |
| if (secondArg != null) |
| { |
| Type secondArgType = secondArg.getJQLType(); |
| if (!typetab.isIntType(secondArgType)) |
| { |
| errorMsg.error(secondArg.getLine(), secondArg.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.semantic.generic.arguments.typemismatch", //NOI18N |
| secondArgType.getName(), typetab.intType.getName())); |
| } |
| } |
| } |
| } |
| |
| /** |
| * This method checks the specified node (args) representing a valid abs |
| * argument list: a single number argument. |
| */ |
| protected void checkAbsArgs(JQLAST method, JQLAST firstArg) |
| { |
| if (firstArg == null) |
| { |
| errorMsg.error(method.getLine(), method.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.semantic.generic.arguments.numbermismatch")); //NOI18N |
| } |
| else if (firstArg.getNextSibling() != null) |
| { |
| JQLAST nextArg = (JQLAST)firstArg.getNextSibling(); |
| errorMsg.error(nextArg.getLine(), nextArg.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.semantic.generic.arguments.numbermismatch")); //NOI18N |
| } |
| else |
| { |
| Type argType = firstArg.getJQLType(); |
| if (!typetab.isNumberType(argType)) |
| { |
| errorMsg.error(firstArg.getLine(), firstArg.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.semantic.generic.arguments.typemismatch", //NOI18N |
| argType.getName(), "number type")); |
| } |
| } |
| } |
| |
| /** |
| * This method checks the specified node (args) representing a valid sqrt |
| * argument list: a single argument of type double or Double. |
| */ |
| protected void checkSqrtArgs(JQLAST method, JQLAST firstArg) |
| { |
| if (firstArg == null) |
| { |
| errorMsg.error(method.getLine(), method.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.semantic.generic.arguments.numbermismatch")); //NOI18N |
| } |
| else if (firstArg.getNextSibling() != null) |
| { |
| JQLAST nextArg = (JQLAST)firstArg.getNextSibling(); |
| errorMsg.error(nextArg.getLine(), nextArg.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.semantic.generic.arguments.numbermismatch")); //NOI18N |
| } |
| else |
| { |
| Type argType = firstArg.getJQLType(); |
| if (!typetab.isDoubleType(argType)) |
| { |
| errorMsg.error(firstArg.getLine(), firstArg.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.semantic.generic.arguments.typemismatch", //NOI18N |
| argType.getName(), "double or Double")); |
| } |
| } |
| } |
| |
| /** |
| * |
| */ |
| protected FieldInfo getCollectionField(JQLAST expr) |
| { |
| JQLAST child = (JQLAST)expr.getFirstChild(); |
| switch (expr.getType()) |
| { |
| case FIELD_ACCESS: |
| case NAVIGATION: |
| if ((child != null) && (child.getNextSibling() != null)) |
| { |
| ClassType classType = (ClassType)child.getJQLType(); |
| String fieldName = child.getNextSibling().getText(); |
| return classType.getFieldInfo(fieldName); |
| } |
| errorMsg.fatal(I18NHelper.getMessage(messages, "jqlc.semantic.getcollectionfield.missingchildren")); //NOI18N |
| break; |
| case TYPECAST: |
| if ((child != null) && (child.getNextSibling() != null)) |
| { |
| return getCollectionField((JQLAST)child.getNextSibling()); |
| } |
| errorMsg.fatal(I18NHelper.getMessage(messages, "jqlc.semantic.getcollectionfield.missingchildren")); //NOI18N |
| break; |
| } |
| return null; |
| } |
| |
| /** |
| * Analyses a bitwise/logical operation (&, |, ^) |
| * @param op the bitwise/logical operator |
| * @param leftAST left operand |
| * @param rightAST right operand |
| * @return Type |
| */ |
| protected Type analyseBitwiseExpr(JQLAST op, JQLAST leftAST, JQLAST rightAST) |
| { |
| Type left = leftAST.getJQLType(); |
| Type right = rightAST.getJQLType(); |
| |
| // handle error type |
| if (left.equals(typetab.errorType) || right.equals(typetab.errorType)) |
| return typetab.errorType; |
| |
| switch(op.getType()) |
| { |
| case BAND: |
| case BOR: |
| if (typetab.isBooleanType(left) && typetab.isBooleanType(right)) |
| return typetab.booleanType; |
| else if (typetab.isIntegralType(left) || typetab.isIntegralType(right)) |
| { |
| errorMsg.unsupported(op.getLine(), op.getColumn(), |
| I18NHelper.getMessage(messages, "jqlc.semantic.analysebitwiseexpr.integerbitwiseop", //NOI18N |
| op.getText())); |
| return typetab.errorType; |
| } |
| break; |
| case BXOR: |
| if (typetab.isBooleanType(left) && typetab.isBooleanType(right)) |
| { |
| errorMsg.unsupported(op.getLine(), op.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.semantic.analysebitwiseexpr.exclusiveorop")); //NOI18N |
| return typetab.errorType; |
| } |
| else if (typetab.isIntegralType(left) || typetab.isIntegralType(right)) |
| { |
| errorMsg.unsupported(op.getLine(), op.getColumn(), |
| I18NHelper.getMessage(messages, "jqlc.semantic.analysebitwiseexpr.integerbitwiseop", //NOI18N |
| op.getText())); |
| return typetab.errorType; |
| } |
| break; |
| } |
| |
| // if this code is reached a bitwise operator was used with invalid arguments |
| errorMsg.error(op.getLine(), op.getColumn(), |
| I18NHelper.getMessage(messages, "jqlc.semantic.generic.arguments.invalid", //NOI18N |
| op.getText())); |
| return typetab.errorType; |
| } |
| |
| /** |
| * Analyses a boolean conditional operation (&&, ||) |
| * @param op the conditional operator |
| * @param leftAST left operand |
| * @param rightAST right operand |
| * @return Type |
| */ |
| protected Type analyseConditionalExpr(JQLAST op, JQLAST leftAST, JQLAST rightAST) |
| { |
| Type left = leftAST.getJQLType(); |
| Type right = rightAST.getJQLType(); |
| |
| // handle error type |
| if (left.equals(typetab.errorType) || right.equals(typetab.errorType)) |
| return typetab.errorType; |
| |
| switch(op.getType()) |
| { |
| case AND: |
| case OR: |
| if (typetab.isBooleanType(left) && typetab.isBooleanType(right)) |
| return typetab.booleanType; |
| break; |
| } |
| |
| // if this code is reached a conditional operator was used with invalid arguments |
| errorMsg.error(op.getLine(), op.getColumn(), |
| I18NHelper.getMessage(messages, "jqlc.semantic.generic.arguments.invalid", //NOI18N |
| op.getText())); |
| return typetab.errorType; |
| } |
| |
| /** |
| * Analyses a relational operation (<, <=, >, >=, ==, !=) |
| * @param op the relational operator |
| * @param leftAST left operand |
| * @param rightAST right operand |
| * @return Type |
| */ |
| protected Type analyseRelationalExpr(JQLAST op, JQLAST leftAST, JQLAST rightAST) |
| { |
| Type left = leftAST.getJQLType(); |
| Type right = rightAST.getJQLType(); |
| |
| // handle error type |
| if (left.equals(typetab.errorType) || right.equals(typetab.errorType)) |
| return typetab.errorType; |
| |
| // special check for <, <=, >, >= |
| // left and right hand types must be orderable |
| switch(op.getType()) |
| { |
| case LT: |
| case LE: |
| case GT: |
| case GE: |
| if (!left.isOrderable()) |
| { |
| errorMsg.error(op.getLine(), op.getColumn(), |
| I18NHelper.getMessage(messages, "jqlc.semantic.analyserelationalexpr.notorderable", //NOI18N |
| left.getName(), op.getText())); |
| return typetab.errorType; |
| } |
| if (!right.isOrderable()) |
| { |
| errorMsg.error(op.getLine(), op.getColumn(), |
| I18NHelper.getMessage(messages, "jqlc.semantic.analyserelationalexpr.notorderable", //NOI18N |
| right.getName(), op.getText())); |
| return typetab.errorType; |
| } |
| break; |
| case EQUAL: |
| case NOT_EQUAL: |
| if ((leftAST.getType() == CONTAINS) || (rightAST.getType() == CONTAINS)) |
| { |
| errorMsg.unsupported(op.getLine(), op.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.semantic.generic.unsupportedconstraintop", op.getText())); //NOI18N |
| return typetab.errorType; |
| } |
| break; |
| } |
| |
| // check for numeric types, numeric wrapper class types and math class types |
| if (typetab.isNumberType(left) && typetab.isNumberType(right)) |
| return typetab.booleanType; |
| |
| // check for boolean and java.lang.Boolean |
| if (typetab.isBooleanType(left) && typetab.isBooleanType(right)) |
| return typetab.booleanType; |
| |
| if (left.isCompatibleWith(right) || right.isCompatibleWith(left)) |
| return typetab.booleanType; |
| |
| // if this code is reached a conditional operator was used with invalid arguments |
| errorMsg.error(op.getLine(), op.getColumn(), |
| I18NHelper.getMessage(messages, "jqlc.semantic.generic.arguments.invalid", //NOI18N |
| op.getText())); |
| return typetab.errorType; |
| } |
| |
| /** |
| * Analyses a |
| * @param op the operator |
| * @param leftAST left operand |
| * @param rightAST right operand |
| * @return Type |
| */ |
| protected Type analyseBinaryArithmeticExpr(JQLAST op, JQLAST leftAST, JQLAST rightAST) |
| { |
| Type left = leftAST.getJQLType(); |
| Type right = rightAST.getJQLType(); |
| |
| // handle error type |
| if (left.equals(typetab.errorType) || right.equals(typetab.errorType)) |
| return typetab.errorType; |
| |
| if (typetab.isNumberType(left) && typetab.isNumberType(right)) |
| { |
| // handle java.math.BigDecimal |
| if (left.isCompatibleWith(typetab.bigDecimalType)) |
| return left; |
| if (right.isCompatibleWith(typetab.bigDecimalType)) |
| return right; |
| |
| // handle java.math.BigInteger |
| if (left.isCompatibleWith(typetab.bigIntegerType)) |
| { |
| // if right is floating point return BigDecimal, |
| // otherwise return BigInteger |
| return typetab.isFloatingPointType(right) ? |
| typetab.bigDecimalType : left; |
| } |
| if (right.isCompatibleWith(typetab.bigIntegerType)) |
| { |
| // if left is floating point return BigDecimal, |
| // otherwise return BigInteger |
| return typetab.isFloatingPointType(left) ? |
| typetab.bigDecimalType : right; |
| } |
| |
| boolean wrapper = false; |
| if (left instanceof NumericWrapperClassType) |
| { |
| left = ((NumericWrapperClassType)left).getPrimitiveType(); |
| wrapper = true; |
| } |
| if (right instanceof NumericWrapperClassType) |
| { |
| right = ((NumericWrapperClassType)right).getPrimitiveType(); |
| wrapper = true; |
| } |
| |
| // handle numeric types with arbitrary arithmetic operator |
| if ((left instanceof NumericType) && (right instanceof NumericType)) |
| { |
| Type promotedType = typetab.binaryNumericPromotion(left, right); |
| if (wrapper && (promotedType instanceof NumericType)) |
| { |
| promotedType = ((NumericType)promotedType).getWrapper(); |
| } |
| return promotedType; |
| } |
| } |
| else if (op.getType() == PLUS) |
| { |
| // handle + for strings |
| // MBO: note, this if matches char + char (which it should'nt), |
| // but this case is already handled above |
| if ((left.equals(typetab.stringType) || left.equals(typetab.charType)) && |
| (right.equals(typetab.stringType) || right.equals(typetab.charType))) |
| { |
| return typetab.stringType; |
| } |
| } |
| |
| // if this code is reached a conditional operator was used with invalid arguments |
| errorMsg.error(op.getLine(), op.getColumn(), |
| I18NHelper.getMessage(messages, "jqlc.semantic.generic.arguments.invalid", //NOI18N |
| op.getText())); |
| return typetab.errorType; |
| } |
| |
| /** |
| * Analyses a |
| * @param op the operator |
| * @param argAST right operand |
| * @return Type |
| */ |
| protected Type analyseUnaryArithmeticExpr(JQLAST op, JQLAST argAST) |
| { |
| Type arg = argAST.getJQLType(); |
| |
| // handle error type |
| if (arg.equals(typetab.errorType)) |
| return typetab.errorType; |
| |
| // handle java.math.BigDecimal and java.math.BigInteger |
| if (arg.isCompatibleWith(typetab.bigDecimalType)) |
| return arg; |
| |
| // handle java.math.BigInteger |
| if (arg.isCompatibleWith(typetab.bigIntegerType)) |
| return arg; |
| |
| boolean wrapper = false; |
| if (arg instanceof NumericWrapperClassType) |
| { |
| arg = ((NumericWrapperClassType)arg).getPrimitiveType(); |
| wrapper = true; |
| } |
| |
| if (arg instanceof NumericType) |
| { |
| Type promotedType = typetab.unaryNumericPromotion(arg); |
| if (wrapper && (promotedType instanceof NumericType)) |
| { |
| promotedType = ((NumericType)promotedType).getWrapper(); |
| } |
| return promotedType; |
| } |
| |
| // if this code is reached a conditional operator was used with invalid arguments |
| errorMsg.error(op.getLine(), op.getColumn(), |
| I18NHelper.getMessage(messages, "jqlc.semantic.generic.arguments.invalid", //NOI18N |
| op.getText())); |
| return typetab.errorType; |
| } |
| /** |
| * Analyses a |
| * @param op the operator |
| * @param argAST right operand |
| * @return Type |
| */ |
| protected Type analyseComplementExpr(JQLAST op, JQLAST argAST) |
| { |
| Type arg = argAST.getJQLType(); |
| |
| // handle error type |
| if (arg.equals(typetab.errorType)) |
| return typetab.errorType; |
| |
| switch(op.getType()) |
| { |
| case BNOT: |
| if (typetab.isIntegralType(arg)) |
| { |
| return arg; |
| } |
| break; |
| case LNOT: |
| if (typetab.isBooleanType(arg)) |
| { |
| if (argAST.getType() == CONTAINS) |
| { |
| errorMsg.unsupported(op.getLine(), op.getColumn(), |
| I18NHelper.getMessage(messages, |
| "jqlc.semantic.generic.unsupportedconstraintop", op.getText())); //NOI18N |
| return typetab.errorType; |
| } |
| return arg; |
| } |
| break; |
| } |
| |
| // if this code is reached a conditional operator was used with invalid arguments |
| errorMsg.error(op.getLine(), op.getColumn(), |
| I18NHelper.getMessage(messages, "jqlc.semantic.generic.arguments.invalid", //NOI18N |
| op.getText())); |
| return typetab.errorType; |
| } |
| |
| /** |
| * |
| */ |
| protected void checkConstraints(JQLAST ast, VariableTable tab) |
| { |
| checkConstraints(ast, null, tab); |
| } |
| |
| /** |
| * |
| */ |
| protected void checkConstraints(JQLAST ast, String dependentVariable, VariableTable tab) |
| { |
| if (ast == null) return; |
| switch (ast.getType()) |
| { |
| case VARIABLE: |
| tab.markUsed(ast, dependentVariable); |
| break; |
| case CONTAINS: |
| JQLAST expr = (JQLAST)ast.getFirstChild(); |
| JQLAST var = (JQLAST)expr.getNextSibling(); |
| checkConstraints(expr, var.getText(), tab); |
| tab.markConstraint(var, expr); |
| break; |
| case BOR: |
| case BXOR: |
| case OR: |
| JQLAST left = (JQLAST)ast.getFirstChild(); |
| JQLAST right = (JQLAST)left.getNextSibling(); |
| // prepare tab copy for right hand side and merge the right hand side copy into vartab |
| VariableTable copy = new VariableTable(tab); |
| checkConstraints(left, dependentVariable, tab); |
| checkConstraints(right, dependentVariable, copy); |
| tab.merge(copy); |
| break; |
| default: |
| for (JQLAST node = (JQLAST)ast.getFirstChild(); node != null; node = (JQLAST)node.getNextSibling()) |
| { |
| checkConstraints(node, dependentVariable, tab); |
| } |
| break; |
| } |
| } |
| |
| } |
| |
| // rules |
| |
| query |
| : #( QUERY |
| { |
| symtab.enterScope(); |
| typeNames.enterScope(); |
| } |
| candidateClass |
| imports |
| { |
| // enter new scope for variable and parameter names |
| symtab.enterScope(); |
| } |
| parameters |
| variables |
| o:ordering |
| r:result |
| filter |
| { |
| typeNames.leaveScope(); |
| // leaves variable and parameter name scope |
| symtab.leaveScope(); |
| // leaves global scope |
| symtab.leaveScope(); |
| } |
| ) |
| { |
| checkResultOrdering(#r, #o); |
| } |
| ; |
| |
| // ---------------------------------- |
| // rules: candidate class |
| // ---------------------------------- |
| |
| candidateClass |
| { |
| errorMsg.setContext("setClass"); //NOI18N |
| } |
| : c:CLASS_DEF |
| { |
| // check persistence capable |
| candidateClass = (ClassType)#c.getJQLType(); |
| String className = candidateClass.getName(); |
| if (!candidateClass.isPersistenceCapable()) |
| { |
| errorMsg.unsupported(#c.getLine(), #c.getColumn(), |
| I18NHelper.getMessage(messages, "jqlc.semantic.candidateclass.nonpc", //NOI18N |
| className)); |
| } |
| |
| // get base name |
| int index = className.lastIndexOf('.'); |
| String identName = index>0 ? className.substring(index+1) : className; |
| typeNames.declare(identName, new TypeName(candidateClass, className)); |
| |
| // init symbol table with field names of the candidate class |
| FieldInfo[] fieldInfos = candidateClass.getFieldInfos(); |
| for (int i = 0; i < fieldInfos.length; i++) |
| { |
| FieldInfo fieldInfo = fieldInfos[i]; |
| symtab.declare(fieldInfo.getName(), new Field(fieldInfo)); |
| } |
| } |
| ; |
| |
| // ---------------------------------- |
| // rules: import declaration |
| // ---------------------------------- |
| |
| imports! |
| { |
| errorMsg.setContext("declareImports"); //NOI18N |
| } |
| : ( declareImport )* |
| ; |
| |
| declareImport |
| { String name = null; } |
| : #( i:IMPORT_DEF name = qualifiedName ) |
| { |
| Type type = typetab.checkType(name); |
| if (type == null) |
| { |
| errorMsg.error(#i.getLine(), #i.getColumn(), |
| I18NHelper.getMessage(messages, "jqlc.semantic.generic.unknowntype", name)); //NOI18N |
| } |
| |
| // get base name |
| int index = name.lastIndexOf('.'); |
| String identName = index>0 ? name.substring(index+1) : name; |
| |
| Definition old = typeNames.declare(identName, new TypeName(type, name)); |
| if (old != null) |
| { |
| errorMsg.error(#i.getLine(), #i.getColumn(), |
| I18NHelper.getMessage(messages, "jqlc.semantic.generic.alreadydeclared", //NOI18N |
| identName, old.getName())); |
| } |
| } |
| ; |
| |
| // ---------------------------------- |
| // rules: parameter declaration |
| // ---------------------------------- |
| |
| parameters |
| { |
| errorMsg.setContext("declareParameters"); //NOI18N |
| } |
| : ( declareParameter )* |
| ; |
| |
| declareParameter |
| : #( PARAMETER_DEF t:type i:IDENT ) |
| { |
| String name = #i.getText(); |
| Type type = #t.getJQLType(); |
| Definition old = symtab.declare(name, new Parameter(type)); |
| if (old != null) |
| { |
| errorMsg.error(#i.getLine(), #i.getColumn(), |
| I18NHelper.getMessage(messages, "jqlc.semantic.generic.alreadydeclared", //NOI18N |
| name, old.getName())); |
| } |
| #i.setJQLType(type); |
| paramtab.add(name, type); |
| } |
| ; |
| |
| // ---------------------------------- |
| // rules: variable declaration |
| // ---------------------------------- |
| |
| variables |
| { |
| errorMsg.setContext("declareVariables"); //NOI18N |
| } |
| : ( declareVariable )* |
| ; |
| |
| declareVariable |
| : #( VARIABLE_DEF t:type i:IDENT ) |
| { |
| String name = #i.getText(); |
| Type type = #t.getJQLType(); |
| Definition old = symtab.declare(name, new Variable(type)); |
| if (old != null) |
| { |
| errorMsg.error(#i.getLine(), #i.getColumn(), |
| I18NHelper.getMessage(messages, "jqlc.semantic.generic.alreadydeclared", //NOI18N |
| name, old.getName())); |
| } |
| vartab.add(name); |
| #i.setJQLType(type); |
| } |
| ; |
| |
| // ---------------------------------- |
| // rules: ordering specification |
| // ---------------------------------- |
| |
| ordering |
| { |
| errorMsg.setContext("setOrdering"); //NOI18N |
| } |
| : ( orderSpec )* |
| ; |
| |
| orderSpec |
| : #( ORDERING_DEF (ASCENDING | DESCENDING) e:expression ) |
| { |
| analyseOrderingExpression(#e); |
| checkConstraints(#e, vartab); |
| } |
| ; |
| |
| // ---------------------------------- |
| // rules: result expression |
| // ---------------------------------- |
| |
| result |
| { |
| errorMsg.setContext("setResult"); //NOI18N |
| } |
| : #( r:RESULT_DEF e:resultExpr ) |
| { |
| checkValidResultExpr(#e); |
| #r.setJQLType(#e.getJQLType()); |
| checkConstraints(#e, vartab); |
| } |
| | // empty rule |
| ; |
| |
| resultExpr |
| : #( d:DISTINCT e0:resultExpr ) |
| { |
| #d.setJQLType(#e0.getJQLType()); |
| } |
| | #( a:AVG e1:resultExpr ) |
| { |
| #a.setJQLType(typetab.getAvgReturnType(#e1.getJQLType())); |
| } |
| | #( max:MAX e2:resultExpr ) |
| { |
| #max.setJQLType(typetab.getMinMaxReturnType(#e2.getJQLType())); |
| } |
| | #( min:MIN e3:resultExpr ) |
| { |
| #min.setJQLType(typetab.getMinMaxReturnType(#e3.getJQLType())); |
| } |
| | #( s:SUM e4:resultExpr ) |
| { |
| #s.setJQLType(typetab.getSumReturnType(#e4.getJQLType())); |
| } |
| | #( c:COUNT resultExpr ) |
| { |
| #c.setJQLType(typetab.longType); |
| } |
| | expression |
| ; |
| |
| // ---------------------------------- |
| // rules: filer expression |
| // ---------------------------------- |
| |
| filter |
| { |
| errorMsg.setContext("setFilter"); //NOI18N |
| } |
| // There is always a filter defined and it is the last node of the query tree. |
| // Otherwise all the remaining subtrees after the CLASS_DEF subtree are empty |
| // which results in a ClassCastException antlr.ASTNullType when analysis |
| // the (non existsent) subtrees |
| : #( FILTER_DEF e:expression ) |
| { |
| Type exprType = #e.getJQLType(); |
| if (!(typetab.isBooleanType(exprType) || exprType.equals(typetab.errorType))) |
| { |
| // filter expression must have the type boolean or java.lang.Boolean |
| errorMsg.error(#e.getLine(), #e.getColumn(), |
| I18NHelper.getMessage(messages, "jqlc.semantic.filter.booleanexpected", exprType)); //NOI18N |
| } |
| checkConstraints(#e, vartab); |
| vartab.checkConstraints(); |
| } |
| ; |
| |
| expression |
| { String repr; } |
| : repr = e:exprNoCheck[false] |
| { |
| if (repr != null) |
| { |
| #e.setJQLType(typetab.errorType); |
| errorMsg.error(#e.getLine(), #e.getColumn(), |
| I18NHelper.getMessage(messages, "jqlc.semantic.expression.undefined", repr)); //NOI18N |
| } |
| } |
| ; |
| |
| exprNoCheck [boolean insideDotExpr] returns [String repr] |
| { repr = null; } // repr is used to get the text of identifier |
| // inside a dot expression |
| : bitwiseExpr |
| | conditionalExpr |
| | relationalExpr |
| | binaryArithmeticExpr |
| | unaryArithmeticExpr |
| | complementExpr |
| | repr = primary[insideDotExpr] |
| ; |
| |
| bitwiseExpr |
| : #( op1:BAND left1:expression right1:expression ) |
| { |
| #op1.setJQLType(analyseBitwiseExpr(#op1, #left1, #right1)); |
| } |
| | #( op2:BOR left2:expression right2:expression ) |
| { |
| #op2.setJQLType(analyseBitwiseExpr(#op2, #left2, #right2)); |
| } |
| | #( op3:BXOR left3:expression right3:expression ) |
| { |
| #op3.setJQLType(analyseBitwiseExpr(#op3, #left3, #right3)); |
| } |
| ; |
| |
| conditionalExpr |
| : #( op1:AND left1:expression right1:expression ) |
| { |
| #op1.setJQLType(analyseConditionalExpr(#op1, #left1, #right1)); |
| } |
| | #( op2:OR left2:expression right2:expression ) |
| { |
| #op2.setJQLType(analyseConditionalExpr(#op2, #left2, #right2)); |
| } |
| ; |
| |
| relationalExpr |
| { |
| Type left = null; |
| Type right = null; |
| } |
| : #( op1:EQUAL left1:expression right1:expression ) |
| { |
| #op1.setJQLType(analyseRelationalExpr(#op1, #left1, #right1)); |
| left = #left1.getJQLType(); |
| right = #right1.getJQLType(); |
| if (typetab.isPersistenceCapableType(left) || typetab.isPersistenceCapableType(right)) |
| { |
| #op1.setType(OBJECT_EQUAL); |
| } |
| else if (typetab.isCollectionType(left) || typetab.isCollectionType(right)) |
| { |
| #op1.setType(COLLECTION_EQUAL); |
| } |
| } |
| | #( op2:NOT_EQUAL left2:expression right2:expression ) |
| { |
| #op2.setJQLType(analyseRelationalExpr(#op2, #left2, #right2)); |
| left = #left2.getJQLType(); |
| right = #right2.getJQLType(); |
| if (typetab.isPersistenceCapableType(left) || typetab.isPersistenceCapableType(right)) |
| { |
| #op2.setType(OBJECT_NOT_EQUAL); |
| } |
| else if (typetab.isCollectionType(left) || typetab.isCollectionType(right)) |
| { |
| #op2.setType(COLLECTION_NOT_EQUAL); |
| } |
| } |
| | #( op3:LT left3:expression right3:expression ) |
| { |
| #op3.setJQLType(analyseRelationalExpr(#op3, #left3, #right3)); |
| } |
| | #( op4:GT left4:expression right4:expression ) |
| { |
| #op4.setJQLType(analyseRelationalExpr(#op4, #left4, #right4)); |
| } |
| | #( op5:LE left5:expression right5:expression ) |
| { |
| #op5.setJQLType(analyseRelationalExpr(#op5, #left5, #right5)); |
| } |
| | #( op6:GE left6:expression right6:expression ) |
| { |
| #op6.setJQLType(analyseRelationalExpr(#op6, #left6, #right6)); |
| } |
| ; |
| |
| binaryArithmeticExpr |
| : #( op1:PLUS left1:expression right1:expression ) |
| { |
| #op1.setJQLType(analyseBinaryArithmeticExpr(#op1, #left1, #right1)); |
| if (#op1.getJQLType().equals(typetab.stringType)) |
| { |
| // change the operator from PLUS to CONCAT in the case of string concatenation |
| #op1.setType(CONCAT); |
| } |
| } |
| | #( op2:MINUS left2:expression right2:expression ) |
| { |
| #op2.setJQLType(analyseBinaryArithmeticExpr(#op2, #left2, #right2)); |
| } |
| | #( op3:STAR left3:expression right3:expression ) |
| { |
| #op3.setJQLType(analyseBinaryArithmeticExpr(#op3, #left3, #right3)); |
| } |
| | #( op4:DIV left4:expression right4:expression ) |
| { |
| #op4.setJQLType(analyseBinaryArithmeticExpr(#op4, #left4, #right4)); |
| } |
| | #( op5:MOD left5:expression right5:expression ) |
| { |
| #op5.setJQLType(analyseBinaryArithmeticExpr(#op5, #left5, #right5)); |
| } |
| ; |
| |
| unaryArithmeticExpr |
| : #( op1:UNARY_PLUS arg1:expression ) |
| { |
| #op1.setJQLType(analyseUnaryArithmeticExpr(#op1, #arg1)); |
| } |
| | #( op2:UNARY_MINUS arg2:expression ) |
| { |
| #op2.setJQLType(analyseUnaryArithmeticExpr(#op2, #arg2)); |
| } |
| ; |
| |
| complementExpr |
| : #( op1:BNOT arg1:expression ) |
| { |
| #op1.setJQLType(analyseComplementExpr(#op1, #arg1)); |
| } |
| | #( op2:LNOT arg2:expression ) |
| { |
| #op2.setJQLType(analyseComplementExpr(#op2, #arg2)); |
| } |
| ; |
| |
| primary [boolean insideDotExpr] returns [String repr] |
| { repr = null; } |
| : #( c:TYPECAST t:type e:expression ) |
| { |
| Type type = #t.getJQLType(); |
| Type exprType = #e.getJQLType(); |
| if (!(type.isCompatibleWith(exprType) || exprType.isCompatibleWith(type))) |
| { |
| errorMsg.error(#c.getLine(), #c.getColumn(), |
| I18NHelper.getMessage(messages, "jqlc.semantic.primary.invalidcast", //NOI18N |
| exprType.getName(), type.getName())); |
| type = typetab.errorType; |
| } |
| #c.setJQLType(type); |
| } |
| | literal |
| | i:THIS |
| { #i.setJQLType(candidateClass); } |
| | repr = dotExpr |
| | repr = identifier [insideDotExpr] |
| ; |
| |
| dotExpr returns [String repr] |
| { |
| repr = null; |
| } |
| : #( dot:DOT |
| repr = expr:exprNoCheck[true] ident:IDENT ( args:argList )? |
| ) |
| { |
| Type type = null; |
| if (repr != null) // possible package name |
| { |
| String qualifiedName = repr + '.' + #ident.getText(); |
| type = typetab.checkType(qualifiedName); |
| if (type == null) |
| { |
| // name does not define a valid class => return qualifiedName |
| repr = qualifiedName; |
| } |
| else if (#args == null) |
| { |
| // found valid class name and NO arguments specified |
| // => use of the class name |
| repr = null; |
| #dot.setType(TYPENAME); |
| #dot.setText(qualifiedName); |
| #dot.setFirstChild(null); |
| } |
| else |
| { |
| // found valid class name and arguments specified => |
| // looks like constructor call |
| repr = null; |
| errorMsg.error(dot.getLine(), dot.getColumn(), |
| I18NHelper.getMessage(messages, "jqlc.semantic.generic.invalidmethodcall")); //NOI18N |
| } |
| #dot.setJQLType(type); |
| #dot.setText(#expr.getText() + '.' + #ident.getText()); |
| } |
| else // no string repr of left hand side => expression is defined |
| { |
| #dotExpr = analyseDotExpr(#dot, #expr, #ident, #args); |
| } |
| } |
| ; |
| |
| argList |
| : #( ARG_LIST (expression)* ) |
| ; |
| |
| identifier [boolean insideDotExpr] returns [String repr] |
| { |
| repr = null; // repr is set when ident is part of a package name spec |
| } |
| : ident:IDENT ( args:argList ) ? |
| { |
| String name = #ident.getText(); |
| Definition def = symtab.getDefinition(name); |
| |
| // check args, if defined => invalid method call |
| if (#args != null) |
| { |
| #ident.setJQLType(typetab.errorType); |
| errorMsg.error(#ident.getLine(), #ident.getColumn(), |
| I18NHelper.getMessage(messages, "jqlc.semantic.generic.invalidmethodcall")); //NOI18N |
| } |
| else if (def != null) |
| { |
| #ident = analyseDefinedIdentifier(#ident, def); |
| } |
| else if (insideDotExpr) |
| { |
| Definition typedef = typeNames.getDefinition(name); |
| if (typedef != null) |
| { |
| #ident = analyseDefinedIdentifier(#ident, typedef); |
| } |
| else |
| { |
| repr = #ident.getText(); |
| } |
| } |
| else |
| { |
| #ident.setJQLType(typetab.errorType); |
| errorMsg.error(ident.getLine(), ident.getColumn(), |
| I18NHelper.getMessage(messages, "jqlc.semantic.identifier.undefined", //NOI18N |
| ident.getText())); |
| } |
| } |
| ; |
| |
| literal |
| : b1:TRUE { #b1.setJQLType(typetab.booleanType); } |
| | b2:FALSE { #b2.setJQLType(typetab.booleanType); } |
| | i:INT_LITERAL { #i.setJQLType(typetab.intType); } |
| | l:LONG_LITERAL { #l.setJQLType(typetab.longType); } |
| | f:FLOAT_LITERAL { #f.setJQLType(typetab.floatType); } |
| | d:DOUBLE_LITERAL { #d.setJQLType(typetab.doubleType); } |
| | c:CHAR_LITERAL { #c.setJQLType(typetab.charType); } |
| | s:STRING_LITERAL { #s.setJQLType(typetab.stringType); } |
| | n:NULL { #n.setJQLType(typetab.nullType); } |
| ; |
| |
| qualifiedName returns [String name] |
| { name = null; } |
| : id1:IDENT |
| { |
| name = #id1.getText(); |
| } |
| | #( d:DOT |
| name = qualifiedName |
| id2:IDENT |
| { |
| name += (#d.getText() + #id2.getText()); |
| } |
| ) |
| ; |
| |
| type |
| { String name = null; } |
| : name = qn:qualifiedName |
| { |
| Type type = null; |
| if (typeNames.isDeclared(name)) |
| { |
| Definition def = typeNames.getDefinition(name); |
| if (def instanceof TypeName) |
| { |
| type = def.getType(); |
| } |
| else |
| { |
| errorMsg.error(#qn.getLine(), #qn.getColumn(), |
| I18NHelper.getMessage(messages, "jqlc.semantic.type.notype", //NOI18N |
| name, def.getName())); |
| } |
| } |
| else |
| { |
| type = typetab.checkType(name); |
| if ((type == null) && (name.indexOf('.') == -1)) |
| { |
| // ckeck java.lang class without package name |
| type = typetab.checkType("java.lang." + name); //NOI18N |
| } |
| if (type == null) |
| { |
| errorMsg.error(#qn.getLine(), #qn.getColumn(), |
| I18NHelper.getMessage(messages, "jqlc.semantic.generic.unknowntype", name)); //NOI18N |
| } |
| } |
| // change AST to a single node that represents the full class name |
| #qn.setType(TYPENAME); |
| #qn.setText(name); |
| #qn.setFirstChild(null); |
| #qn.setJQLType(type); |
| } |
| | p:primitiveType |
| { |
| #p.setJQLType(typetab.checkType(#p.getText())); |
| #p.setType(TYPENAME); |
| } |
| ; |
| |
| primitiveType |
| : BOOLEAN |
| | BYTE |
| | CHAR |
| | SHORT |
| | INT |
| | FLOAT |
| | LONG |
| | DOUBLE |
| ; |
| |
