Class ProtoParser

java.lang.Object

org.mvel2.util.ProtoParser

public class ProtoParser
extends Object

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
private static interface	ProtoParser.DeferredTypeResolve

Field Summary

Fields

Modifier and Type	Field	Description
private int	cursor
private static ThreadLocal<Queue<ProtoParser.DeferredTypeResolve>>	deferred
private String	deferredName
private int	endOffset
private char[]	expr
private boolean	interpreted
private String	name
private ParserContext	pCtx
private String	protoName
private ExecutionStack	splitAccumulator
(package private) String	tk1
(package private) String	tk2
private Class	type

Constructor Summary

Constructors

Constructor	Description
ProtoParser(char[] expr, int offset, int offsetEnd, String protoName, ParserContext pCtx, int fields, ExecutionStack splitAccumulator)

Method Summary

Modifier and Type	Method	Description
private void	calculateDecl()
static void	checkForPossibleUnresolvedViolations(char[] expr, int cursor, ParserContext pCtx)	This is such a horrible hack, but it's more performant than any other horrible hack I can think of right now.
private void	enqueueReceiverForLateResolution(String name, Proto.Receiver receiver, String initializer)
int	getCursor()
static String	getNextUnresolvedWaiting()
static boolean	isUnresolvedWaiting()
static void	notifyForLateResolution(Proto proto)
Proto	parse()

Methods inherited from class Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Details

expr

private char[] expr

pCtx

private ParserContext pCtx

endOffset

private int endOffset

cursor

private int cursor

protoName

private String protoName

tk1

String tk1

tk2

String tk2

type

private Class type

name

private String name

deferredName

private String deferredName

interpreted

private boolean interpreted

splitAccumulator

private ExecutionStack splitAccumulator

deferred

private static ThreadLocal<Queue<ProtoParser.DeferredTypeResolve>> deferred

Constructor Details

ProtoParser

public ProtoParser(char[] expr,
 int offset,
 int offsetEnd,
 String protoName,
 ParserContext pCtx,
 int fields,
 ExecutionStack splitAccumulator)

Method Details

parse

public Proto parse()

calculateDecl

private void calculateDecl()

enqueueReceiverForLateResolution

private void enqueueReceiverForLateResolution(String name,
 Proto.Receiver receiver,
 String initializer)

notifyForLateResolution

public static void notifyForLateResolution(Proto proto)

getCursor

public int getCursor()

checkForPossibleUnresolvedViolations

public static void checkForPossibleUnresolvedViolations(char[] expr,
 int cursor,
 ParserContext pCtx)

This is such a horrible hack, but it's more performant than any other horrible hack I can think of right now.

Parameters:

expr - expr

cursor - cursor

pCtx - pCtx

isUnresolvedWaiting

public static boolean isUnresolvedWaiting()

getNextUnresolvedWaiting

public static String getNextUnresolvedWaiting()