Refine search
@Override public Object visit(ASTTriggerTimingPointSection node, Object data) { LOGGER.entering(CLASS_PATH, "visit(ASTTriggerTimingPointSection)"); if (LOGGER.isLoggable(Level.FINEST)) { LOGGER.finest("visit(ASTTriggerTimingPointSection): " + node.getClass().getCanonicalName() + " @ line " + node.getBeginLine() + ", column " + node.getBeginColumn() + " --- " + new Throwable().getStackTrace()); } sbf.buildDataFlowFor(node); vav.compute(node); LOGGER.exiting(CLASS_PATH, "visit(ASTProgramUnit)"); return data; }
public void endDocument() throws SAXException { if (logger.isLoggable(Level.FINER)) logger.exiting(className, "endDocument()"); endJSON(); if (logger.isLoggable(Level.FINER)) logger.exiting(className, "endDocument()"); }
@Override public Object visit(ASTProgramUnit node, Object data) { LOGGER.entering(CLASS_PATH, "visit(ASTProgramUnit)"); if (LOGGER.isLoggable(Level.FINEST)) { LOGGER.finest( "visit(ASTProgramUnit): " + node.getClass().getCanonicalName() + " @ line " + node.getBeginLine() + ", column " + node.getBeginColumn() + " --- " + new Throwable().getStackTrace()); } sbf.buildDataFlowFor(node); vav.compute(node); LOGGER.exiting(CLASS_PATH, "visit(ASTProgramUnit)"); return data; }
public void exiting(final Object result) { if (!this.logger.isLoggable(METHOD_CALL_LEVEL_VALUE)) { return; } logger.exiting(componentClassName, getCallerMethodName(), result); }
@Override public Object visit(ASTTypeMethod node, Object data) { LOGGER.entering(CLASS_PATH, "visit(ASTTypeMethod)"); if (LOGGER.isLoggable(Level.FINEST)) { LOGGER.finest( "visit(ASTTypeMethod): " + node.getClass().getCanonicalName() + " @ line " + node.getBeginLine() + ", column " + node.getBeginColumn() + " --- " + new Throwable().getStackTrace()); } sbf.buildDataFlowFor(node); vav.compute(node); LOGGER.exiting(CLASS_PATH, "visit(ASTTypeMethod)"); return data; } }
@Override protected void visit(Rule rule, Node node, RuleContext ctx) { LOGGER.entering(CLASS_NAME, "visit"); // Rule better either be a PLSQLParserVisitor, or a XPathRule# if (LOGGER.isLoggable(Level.FINE)) { LOGGER.fine("Rule=" + rule); LOGGER.fine("Node=" + node); LOGGER.fine("RuleContext=" + ctx); LOGGER.fine("Rule Classname=" + rule.getClass().getCanonicalName()); LOGGER.fine("Rule Name=" + rule.getName()); } if (rule instanceof XPathRule) { ((XPathRule) rule).evaluate(node, ctx); } else { ((PLSQLNode) node).jjtAccept((PLSQLParserVisitor) rule, ctx); } LOGGER.exiting(CLASS_NAME, "visit"); } }
@Override public Object visit(ASTMethodDeclaration node, Object data) { LOGGER.entering(CLASS_PATH, "visit(ASTMethodDeclaration)"); if (LOGGER.isLoggable(Level.FINEST)) { LOGGER.finest("visit(ASTMethodDeclaration): " + node.getClass().getCanonicalName() + " @ line " + node.getBeginLine() + ", column " + node.getBeginColumn() + " --- " + new Throwable().getStackTrace()); } super.visit(node, data); sbf.buildDataFlowFor(node); vav.compute(node); LOGGER.exiting(CLASS_PATH, "visit(ASTMethodDeclaration)"); return data; }
@Override protected void indexNodes(List<Node> nodes, RuleContext ctx) { LOGGER.entering(CLASS_NAME, "indexNodes"); PLSQLParserVisitor plsqlParserVistor = new PLSQLParserVisitorAdapter() { // Perform a visitation of the AST to index nodes which need // visiting by type @Override public Object visit(PLSQLNode node, Object data) { indexNode(node); return super.visit(node, data); } }; for (int i = 0; i < nodes.size(); i++) { plsqlParserVistor.visit((ASTInput) nodes.get(i), ctx); } LOGGER.exiting(CLASS_NAME, "indexNodes"); }
@Override public Object visit(ASTElseClause node, Object data) { LOGGER.entering(CLASS_NAME, "visit(ASTElseClause)"); // (npath of if + npath of else (or 1) + bool_comp of if) * npath of // next int complexity = 0; List<PLSQLNode> statementChildren = new ArrayList<>(); for (int i = 0; i < node.jjtGetNumChildren(); i++) { if (node.jjtGetChild(i).getClass() == ASTStatement.class) { statementChildren.add((PLSQLNode) node.jjtGetChild(i)); } } if (LOGGER.isLoggable(Level.FINEST)) { LOGGER.finest(statementChildren.size() + " statementChildren found for ELSE clause statement " + node.getBeginLine() + ", column " + node.getBeginColumn()); } for (PLSQLNode element : statementChildren) { complexity += (Integer) element.jjtAccept(this, data); } LOGGER.exiting(CLASS_NAME, "visit(ASTElseClause)", complexity); return Integer.valueOf(complexity); }
@Override public Object visit(ASTTriggerUnit node, Object data) { LOGGER.entering(CLASS_PATH, "visit(ASTTriggerUnit)"); if (LOGGER.isLoggable(Level.FINEST)) { LOGGER.finest( "visit(ASTTriggerUnit): " + node.getClass().getCanonicalName() + " @ line " + node.getBeginLine() + ", column " + node.getBeginColumn() + " --- " + new Throwable().getStackTrace()); } if (node.hasDescendantOfType(ASTCompoundTriggerBlock.class)) { if (LOGGER.isLoggable(Level.FINEST)) { LOGGER.finest("visit(ASTTriggerUnit): treating ASTTriggerUnit like a PackageBody " + node.getClass().getCanonicalName() + " @ line " + node.getBeginLine() + ", column " + node.getBeginColumn() + " --- " + new Throwable().getStackTrace()); } // Pass super.visit(node, data); } { if (LOGGER.isLoggable(Level.FINEST)) { LOGGER.finest("visit(ASTTriggerUnit): treating ASTTriggerUnit as standalone " + node.getClass().getCanonicalName() + " @ line " + node.getBeginLine() + ", column " + node.getBeginColumn() + " --- " + new Throwable().getStackTrace()); } sbf.buildDataFlowFor(node); vav.compute(node); } LOGGER.exiting(CLASS_PATH, "visit(ASTTriggerUnit)"); return data; }
@Override public Object visit(ASTTriggerUnit node, Object data) { LOGGER.entering(CLASS_NAME, "visit(ASTTriggerUnit)"); entryStack.push(new Entry(node)); super.visit(node, data); Entry classEntry = entryStack.pop(); if (LOGGER.isLoggable(Level.FINEST)) { LOGGER.finest("ASTTriggerUnit: ComplexityAverage==" + classEntry.getComplexityAverage() + ", highestDecisionPoint=" + classEntry.highestDecisionPoints); } if (showClassesComplexity) { if (classEntry.getComplexityAverage() >= reportLevel || classEntry.highestDecisionPoints >= reportLevel) { addViolation(data, node, new String[] { "class", node.getImage(), classEntry.getComplexityAverage() + " (Highest = " + classEntry.highestDecisionPoints + ')', }); } } LOGGER.exiting(CLASS_NAME, "visit(ASTTriggerUnit)"); return data; }
public Result createOutput(String namespaceUri, String suggestedFileName) throws IOException { logger.entering(getClass().getName(),"createOutput",new Object[]{namespaceUri,suggestedFileName}); Result r = resolver.createOutput(namespaceUri,suggestedFileName); if(r!=null) { String sysId = r.getSystemId(); logger.finer("system ID = "+sysId); if(sysId!=null) { // TODO: make sure that the system Id is absolute // don't use java.net.URI, because it doesn't allow some characters (like SP) // which can legally used as file names. // but don't use java.net.URL either, because it doesn't allow a made-up URI // like kohsuke://foo/bar/zot } else throw new AssertionError("system ID cannot be null"); } logger.exiting(getClass().getName(),"createOutput",r); return r; } }
private void computeSwitch(int firstIndex, int lastIndex) { LOGGER.entering(CLASS_NAME, "computeSwitch"); int diff = lastIndex - firstIndex; boolean defaultStatement = false; DataFlowNode sStart = this.braceStack.get(firstIndex).getDataFlowNode(); DataFlowNode sEnd = this.braceStack.get(lastIndex).getDataFlowNode(); DataFlowNode end = sEnd.getChildren().get(0); if (LOGGER.isLoggable(Level.FINE)) { LOGGER.fine("Stack(sStart)=>" + sStart + ",Stack(sEnd)=>" + sEnd + ",end=>" + end); } for (int i = 0; i < diff - 2; i++) { StackObject so = this.braceStack.get(firstIndex + 2 + i); DataFlowNode node = so.getDataFlowNode(); if (LOGGER.isLoggable(Level.FINE)) { LOGGER.fine("so(" + (firstIndex + 2 + i) + ")=>" + so + " has dfn=>" + node + " with first child =>" + node.getChildren().get(0)); } sStart.addPathToChild(node.getChildren().get(0)); if (so.getType() == NodeType.SWITCH_LAST_DEFAULT_STATEMENT) { defaultStatement = true; } } if (!defaultStatement) { sStart.addPathToChild(end); } LOGGER.exiting(CLASS_NAME, "computeSwitch"); }
private int complexityMultipleOf(PLSQLNode node, int npathStart, Object data) { LOGGER.entering(CLASS_NAME, "complexityMultipleOf(SimpleNode)"); int npath = npathStart; PLSQLNode n; for (int i = 0; i < node.jjtGetNumChildren(); i++) { n = (PLSQLNode) node.jjtGetChild(i); npath *= (Integer) n.jjtAccept(this, data); } LOGGER.exiting(CLASS_NAME, "complexityMultipleOf(SimpleNode)", npath); return npath; }