001: ////////////////////////////////////////////////////////////////////////////////
002: // checkstyle: Checks Java source code for adherence to a set of rules.
003: // Copyright (C) 2001-2007 Oliver Burn
004: //
005: // This library is free software; you can redistribute it and/or
006: // modify it under the terms of the GNU Lesser General Public
007: // License as published by the Free Software Foundation; either
008: // version 2.1 of the License, or (at your option) any later version.
009: //
010: // This library is distributed in the hope that it will be useful,
011: // but WITHOUT ANY WARRANTY; without even the implied warranty of
012: // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
013: // Lesser General Public License for more details.
014: //
015: // You should have received a copy of the GNU Lesser General Public
016: // License along with this library; if not, write to the Free Software
017: // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
018: ////////////////////////////////////////////////////////////////////////////////
019: package com.puppycrawl.tools.checkstyle.checks.indentation;
020:
021: import com.puppycrawl.tools.checkstyle.api.DetailAST;
022: import com.puppycrawl.tools.checkstyle.api.TokenTypes;
023:
024: /**
025: * Handler for a list of statements.
026: *
027: * @author jrichard
028: */
029: public class SlistHandler extends BlockParentHandler {
030: /**
031: * Construct an instance of this handler with the given indentation check,
032: * abstract syntax tree, and parent handler.
033: *
034: * @param aIndentCheck the indentation check
035: * @param aAst the abstract syntax tree
036: * @param aParent the parent handler
037: */
038: public SlistHandler(IndentationCheck aIndentCheck, DetailAST aAst,
039: ExpressionHandler aParent) {
040: super (aIndentCheck, "block", aAst, aParent);
041: }
042:
043: /**
044: * Indentation level suggested for a child element. Children don't have
045: * to respect this, but most do.
046: *
047: * @param aChild child AST (so suggestion level can differ based on child
048: * type)
049: *
050: * @return suggested indentation for child
051: */
052: public IndentLevel suggestedChildLevel(ExpressionHandler aChild) {
053: // this is:
054: // switch (var) {
055: // case 3: {
056: // break;
057: // }
058: // }
059: // ... the case SLIST is followed by a user-created SLIST and
060: // preceded by a switch
061:
062: // if our parent is a block handler we want to be transparent
063: if (((getParent() instanceof BlockParentHandler) && !(getParent() instanceof SlistHandler))
064: || ((getParent() instanceof CaseHandler) && (aChild instanceof SlistHandler))) {
065: return getParent().suggestedChildLevel(aChild);
066: }
067: return super .suggestedChildLevel(aChild);
068: }
069:
070: /**
071: * Get the child element that is not a list of statements.
072: *
073: * @return the non-list child element
074: */
075: protected DetailAST getNonlistChild() {
076: // blocks always have either block children or they are transparent
077: // and aren't checking children at all. In the later case, the
078: // superclass will want to check single children, so when it
079: // does tell it we have none.
080: return null;
081: }
082:
083: /**
084: * Get the child element representing the list of statements.
085: *
086: * @return the statement list child
087: */
088: protected DetailAST getListChild() {
089: return getMainAst();
090: }
091:
092: /**
093: * Get the left curly brace portion of the expression we are handling.
094: *
095: * @return the left curly brace expression
096: */
097: protected DetailAST getLCurly() {
098: return getMainAst();
099: }
100:
101: /**
102: * Get the right curly brace portion of the expression we are handling.
103: *
104: * @return the right curly brace expression
105: */
106: protected DetailAST getRCurly() {
107: return getMainAst().findFirstToken(TokenTypes.RCURLY);
108: }
109:
110: /**
111: * There is no top level expression for this handler.
112: *
113: * @return null
114: */
115: protected DetailAST getToplevelAST() {
116: return null;
117: }
118:
119: /**
120: * Determine if the expression we are handling has a block parent.
121: *
122: * @return true if it does, false otherwise
123: */
124: private boolean hasBlockParent() {
125: final int parentType = getMainAst().getParent().getType();
126: return (parentType == TokenTypes.LITERAL_IF)
127: || (parentType == TokenTypes.LITERAL_FOR)
128: || (parentType == TokenTypes.LITERAL_WHILE)
129: || (parentType == TokenTypes.LITERAL_DO)
130: || (parentType == TokenTypes.LITERAL_ELSE)
131: || (parentType == TokenTypes.LITERAL_TRY)
132: || (parentType == TokenTypes.LITERAL_CATCH)
133: || (parentType == TokenTypes.LITERAL_FINALLY)
134: || (parentType == TokenTypes.CTOR_DEF)
135: || (parentType == TokenTypes.METHOD_DEF)
136: || (parentType == TokenTypes.STATIC_INIT);
137: }
138:
139: /**
140: * Check the indentation of the expression we are handling.
141: */
142: public void checkIndentation() {
143: // only need to check this if parent is not
144: // an if, else, while, do, ctor, method
145: if (hasBlockParent()) {
146: return;
147: }
148: super.checkIndentation();
149: }
150: }
|