Class ParseTools

java.lang.Object
org.mvel2.util.ParseTools

public class ParseTools extends Object
  • Field Details

  • Constructor Details

    • ParseTools

      public ParseTools()
  • Method Details

    • parseMethodOrConstructor

      public static List<char[]> parseMethodOrConstructor(char[] parm)
    • parseParameterDefList

      public static String[] parseParameterDefList(char[] parm, int offset, int length)
    • parseParameterList

      public static List<char[]> parseParameterList(char[] parm, int offset, int length)
    • getBestCandidate

      public static Method getBestCandidate(Object[] arguments, String method, Class decl, Method[] methods, boolean requireExact)
    • getBestCandidate

      public static Method getBestCandidate(Class[] arguments, String method, Class decl, Method[] methods, boolean requireExact)
    • getBestCandidate

      public static Method getBestCandidate(Class[] arguments, String method, Class decl, Method[] methods, boolean requireExact, boolean classTarget)
    • isArgsNumberNotCompatible

      private static boolean isArgsNumberNotCompatible(Class[] arguments, Class<?>[] parmTypes, boolean isVarArgs)
    • isMoreSpecialized

      private static boolean isMoreSpecialized(Method newCandidate, Method oldCandidate)
    • isMorePreciseForBigDecimal

      private static boolean isMorePreciseForBigDecimal(Executable newCandidate, Executable oldCandidate, Class[] arguments)
    • comparePrecision

      private static int comparePrecision(Class<?> numeric1, Class<?> numeric2)
    • getMethodScore

      private static int getMethodScore(Class[] arguments, boolean requireExact, Class<?>[] parmTypes, boolean varArgs)
    • scoreInterface

      public static int scoreInterface(Class<?> parm, Class<?> arg)
    • getExactMatch

      public static Method getExactMatch(String name, Class[] args, Class returnType, Class cls)
    • getWidenedTarget

      public static Method getWidenedTarget(Method method)
    • getWidenedTarget

      public static Method getWidenedTarget(Class cls, Method method)
    • getConstructors

      private static Class[] getConstructors(Constructor cns)
    • getBestConstructorCandidate

      public static Constructor getBestConstructorCandidate(Object[] args, Class cls, boolean requireExact)
    • getBestConstructorCandidate

      public static Constructor getBestConstructorCandidate(Class[] arguments, Class cls, boolean requireExact)
    • createClass

      public static Class createClass(String className, ParserContext pCtx) throws ClassNotFoundException
      Throws:
      ClassNotFoundException
    • getConstructors

      public static Constructor[] getConstructors(Class cls)
    • captureContructorAndResidual

      public static String[] captureContructorAndResidual(char[] cs, int start, int offset)
    • boxPrimitive

      public static Class<?> boxPrimitive(Class cls)
    • unboxPrimitive

      public static Class unboxPrimitive(Class cls)
    • containsCheck

      public static boolean containsCheck(Object compareTo, Object compareTest)
    • containsCheckOnPrimitveArray

      private static boolean containsCheckOnPrimitveArray(Object primitiveArray, Object compareTest)
    • containsCheckOnBooleanArray

      private static boolean containsCheckOnBooleanArray(boolean[] array, Boolean compareTest)
    • containsCheckOnIntArray

      private static boolean containsCheckOnIntArray(int[] array, Integer compareTest)
    • containsCheckOnLongArray

      private static boolean containsCheckOnLongArray(long[] array, Long compareTest)
    • containsCheckOnDoubleArray

      private static boolean containsCheckOnDoubleArray(double[] array, Double compareTest)
    • containsCheckOnFloatArray

      private static boolean containsCheckOnFloatArray(float[] array, Float compareTest)
    • containsCheckOnCharArray

      private static boolean containsCheckOnCharArray(char[] array, Character compareTest)
    • containsCheckOnShortArray

      private static boolean containsCheckOnShortArray(short[] array, Short compareTest)
    • containsCheckOnByteArray

      private static boolean containsCheckOnByteArray(byte[] array, Byte compareTest)
    • handleEscapeSequence

      public static int handleEscapeSequence(char[] escapeStr, int pos)
      Replace escape sequences and return trim required.
      Parameters:
      escapeStr - -
      pos - -
      Returns:
      -
    • createShortFormOperativeAssignment

      public static char[] createShortFormOperativeAssignment(String name, char[] statement, int start, int offset, int operation)
    • findClassImportResolverFactory

      public static ClassImportResolverFactory findClassImportResolverFactory(VariableResolverFactory factory, ParserContext pCtx)
    • findClass

      public static Class findClass(VariableResolverFactory factory, String name, ParserContext pCtx) throws ClassNotFoundException
      Throws:
      ClassNotFoundException
    • subsetTrimmed

      public static char[] subsetTrimmed(char[] array, int start, int length)
    • subset

      public static char[] subset(char[] array, int start, int length)
    • subset

      public static char[] subset(char[] array, int start)
    • resolveType

      public static int resolveType(Object o)
    • __resolveType

      public static int __resolveType(Class cls)
    • isPrimitiveSubtype

      private static boolean isPrimitiveSubtype(Class argument, Class<?> actualParamType)
    • isNumericallyCoercible

      public static boolean isNumericallyCoercible(Class target, Class parm)
    • narrowType

      public static Object narrowType(BigDecimal result, int returnTarget)
    • determineActualTargetMethod

      public static Method determineActualTargetMethod(Method method)
    • determineActualTargetMethod

      private static Method determineActualTargetMethod(Class clazz, Method method)
    • captureToNextTokenJunction

      public static int captureToNextTokenJunction(char[] expr, int cursor, int end, ParserContext pCtx)
    • nextNonBlank

      public static int nextNonBlank(char[] expr, int cursor)
    • skipWhitespace

      public static int skipWhitespace(char[] expr, int cursor)
    • isStatementNotManuallyTerminated

      public static boolean isStatementNotManuallyTerminated(char[] expr, int cursor)
    • captureToEOS

      public static int captureToEOS(char[] expr, int cursor, int end, ParserContext pCtx)
    • trimLeft

      public static int trimLeft(char[] expr, int start, int pos)
      From the specified cursor position, trim out any whitespace between the current position and the end of the last non-whitespace character.
      Parameters:
      expr - -
      start - -
      pos - - current position
      Returns:
      new position.
    • trimRight

      public static int trimRight(char[] expr, int pos)
      From the specified cursor position, trim out any whitespace between the current position and beginning of the first non-whitespace character.
      Parameters:
      expr - -
      pos - -
      Returns:
      -
    • subArray

      public static char[] subArray(char[] expr, int start, int end)
    • balancedCapture

      public static int balancedCapture(char[] chars, int start, char type)
      This is an important aspect of the core parser tools. This method is used throughout the core parser and sub-lexical parsers to capture a balanced capture between opening and terminating tokens such as: ( [ { ' "

      For example: ((foo + bar + (bar - foo)) * 20;

      If a balanced capture is performed from position 2, we get "(foo + bar + (bar - foo))" back.
      If a balanced capture is performed from position 15, we get "(bar - foo)" back.
      Etc.
      Parameters:
      chars - -
      start - -
      type - -
      Returns:
      -
    • balancedCapture

      public static int balancedCapture(char[] chars, int start, int end, char type)
    • balancedCaptureWithLineAccounting

      public static int balancedCaptureWithLineAccounting(char[] chars, int start, int end, char type, ParserContext pCtx)
    • handleStringEscapes

      public static String handleStringEscapes(char[] input)
    • captureStringLiteral

      public static int captureStringLiteral(char type, char[] expr, int cursor, int end)
    • parseWithExpressions

      public static void parseWithExpressions(String nestParm, char[] block, int start, int offset, Object ctx, VariableResolverFactory factory)
    • handleNumericConversion

      public static Object handleNumericConversion(char[] val, int start, int offset)
    • isNumeric

      public static boolean isNumeric(Object val)
    • numericTest

      public static int numericTest(char[] val, int start, int offset)
    • isNumber

      public static boolean isNumber(Object val)
    • isNumber

      public static boolean isNumber(String val)
    • isNumber

      public static boolean isNumber(char[] val, int start, int offset)
    • find

      public static int find(char[] c, int start, int offset, char find)
    • findLast

      public static int findLast(char[] c, int start, int offset, char find)
    • createStringTrimmed

      public static String createStringTrimmed(char[] s)
    • createStringTrimmed

      public static String createStringTrimmed(char[] s, int start, int length)
    • endsWith

      public static boolean endsWith(char[] c, int start, int offset, char[] test)
    • isIdentifierPart

      public static boolean isIdentifierPart(int c)
    • isDigit

      public static boolean isDigit(int c)
    • similarity

      public static float similarity(String s1, String s2)
    • findAbsoluteLast

      public static int findAbsoluteLast(char[] array)
    • getBaseComponentType

      public static Class getBaseComponentType(Class cls)
    • getSubComponentType

      public static Class getSubComponentType(Class cls)
    • isJunct

      public static boolean isJunct(char c)
    • opLookup

      public static int opLookup(char c)
    • isReservedWord

      public static boolean isReservedWord(String name)
      Check if the specified string is a reserved word in the parser.
      Parameters:
      name - -
      Returns:
      -
    • isNotValidNameorLabel

      public static boolean isNotValidNameorLabel(String name)
      Check if the specfied string represents a valid name of label.
      Parameters:
      name - -
      Returns:
      -
    • isPropertyOnly

      public static boolean isPropertyOnly(char[] array, int start, int end)
    • isArrayType

      public static boolean isArrayType(char[] array, int start, int end)
    • checkNameSafety

      public static void checkNameSafety(String name)
    • getDebugFileWriter

      public static FileWriter getDebugFileWriter() throws IOException
      Throws:
      IOException
    • isPrimitiveWrapper

      public static boolean isPrimitiveWrapper(Class clazz)
    • subCompileExpression

      public static Serializable subCompileExpression(char[] expression)
    • subCompileExpression

      public static Serializable subCompileExpression(char[] expression, ParserContext ctx)
    • subCompileExpression

      public static Serializable subCompileExpression(char[] expression, int start, int offset, ParserContext ctx)
    • subCompileExpression

      public static Serializable subCompileExpression(String expression, ParserContext ctx)
    • optimizeTree

      public static Serializable optimizeTree(CompiledExpression compiled)
    • _optimizeTree

      private static Serializable _optimizeTree(CompiledExpression compiled)
    • isWhitespace

      public static boolean isWhitespace(char c)
    • repeatChar

      public static String repeatChar(char c, int times)
    • loadFromFile

      public static char[] loadFromFile(File file) throws IOException
      Throws:
      IOException
    • loadFromFile

      public static char[] loadFromFile(File file, String encoding) throws IOException
      Throws:
      IOException
    • readIn

      public static char[] readIn(InputStream inStream, String encoding) throws IOException
      Throws:
      IOException
    • forNameWithInner

      public static Class forNameWithInner(String className, ClassLoader classLoader) throws ClassNotFoundException
      Throws:
      ClassNotFoundException
    • findInnerClass

      public static Class findInnerClass(String className, ClassLoader classLoader, ClassNotFoundException cnfe) throws ClassNotFoundException
      Throws:
      ClassNotFoundException
    • skipStringEscape

      private static int skipStringEscape(int cur)