private Object debug(ProceedingJoinPoint pjp, MethodTimeDebugger timeDebugger) throws Throwable { if (!timeDebugger.value()) { return pjp.proceed(); } String type = timeDebugger.type(); StringBuffer msg = new StringBuffer(); msg.append(type + "[") .append(pjp.getTarget().getClass().getName()) .append(".") .append(getMethod(pjp.getSignature()).getName()) .append("(..)"); ExecutionStack.push(msg.toString()); Object result = pjp.proceed(); ExecutionStack.pop(msg.toString()); return result; }
public Function parse() { int start = cursor; int startCond = 0; int endCond = 0; int blockStart; int blockEnd; int end = cursor + length; cursor = ParseTools.captureToNextTokenJunction(expr, cursor, end, pCtx); if (expr[cursor = ParseTools.nextNonBlank(expr, cursor)] == '(') { /** * If we discover an opening bracket after the function name, we check to see if this function * accepts parameters. */ endCond = cursor = balancedCaptureWithLineAccounting(expr, startCond = cursor, end, '(', pCtx); startCond++; cursor++; cursor = ParseTools.skipWhitespace(expr, cursor, pCtx); if (cursor >= end) { throw new CompileException("incomplete statement", expr, cursor); } else if (expr[cursor] == '{') { blockEnd = cursor = balancedCaptureWithLineAccounting(expr, blockStart = cursor, end, '{', pCtx); } else { blockStart = cursor - 1; cursor = ParseTools.captureToEOS(expr, cursor, end, pCtx); blockEnd = cursor; } } else { /** This function has not parameters. */ if (expr[cursor] == '{') { /** This function is bracketed. We capture the entire range in the brackets. */ blockEnd = cursor = balancedCaptureWithLineAccounting(expr, blockStart = cursor, end, '{', pCtx); } else { /** This is a single statement function declaration. We only capture the statement. */ blockStart = cursor - 1; cursor = ParseTools.captureToEOS(expr, cursor, end, pCtx); blockEnd = cursor; } } /** Trim any whitespace from the captured block range. */ blockStart = ParseTools.trimRight(expr, start, blockStart + 1); blockEnd = ParseTools.trimLeft(expr, start, blockEnd); cursor++; /** Check if the function is manually terminated. */ if (splitAccumulator != null && ParseTools.isStatementNotManuallyTerminated(expr, cursor)) { /** Add an EndOfStatement to the split accumulator in the parser. */ splitAccumulator.add(new EndOfStatement()); } /** Produce the funciton node. */ return new Function( name, expr, startCond, endCond - startCond, blockStart, blockEnd - blockStart, fields, pCtx == null ? pCtx = AbstractParser.getCurrentThreadParserContext() : pCtx); }