/**********************************************************************
Copyright (c) 2002 Klaus Hartlage - www.eclipseproject.de
- All rights reserved. This program and the accompanying materials
+ All rights reserved. This program and the accompanying material
are made available under the terms of the Common Public License v1.0
which accompanies this distribution, and is available at
http://www.eclipse.org/legal/cpl-v10.html
private String stringValue;
/** Contains the current expression. */
// private StringBuffer expression;
- private boolean phpMode;
+ //private boolean phpMode;
protected int modifiers;
protected int modifiersSourceStart;
protected Parser() {
// } catch (CoreException e) {
// }
// }
- public void phpParserTester(String s, int rowCount) {
- this.str = s;
- if (s == null) {
- if (phpList.size() != 0) {
- this.str = ((PHPString) phpList.get(currentPHPString++)).getPHPString();
- }
- }
- this.token = TokenNameEOF;
- // this.chIndx = 0;
- // this.rowCount = rowCount;
- // this.columnCount = 0;
- this.phpEnd = false;
- this.phpMode = true;
- scanner.setSource(s.toCharArray());
- scanner.setPHPMode(true);
- getNextToken();
- do {
- try {
- if (token != TokenNameEOF && token != TokenNameERROR) {
- statementList();
- }
- if (token != TokenNameEOF) {
- if (token == TokenNameERROR) {
- throwSyntaxError("Scanner error (Found unknown token: "
- + scanner.toStringAction(token) + ")");
- }
- if (token == TokenNameRPAREN) {
- throwSyntaxError("Too many closing ')'; end-of-file not reached.");
- }
- if (token == TokenNameRBRACE) {
- throwSyntaxError("Too many closing '}'; end-of-file not reached.");
- }
- if (token == TokenNameRBRACKET) {
- throwSyntaxError("Too many closing ']'; end-of-file not reached.");
- }
- if (token == TokenNameLPAREN) {
- throwSyntaxError("Read character '('; end-of-file not reached.");
- }
- if (token == TokenNameLBRACE) {
- throwSyntaxError("Read character '{'; end-of-file not reached.");
- }
- if (token == TokenNameLBRACKET) {
- throwSyntaxError("Read character '['; end-of-file not reached.");
- }
- throwSyntaxError("End-of-file not reached.");
- }
- return;
- } catch (SyntaxError err) {
- if (s != null) {
- throw err;
- } else {
- // setMarker(err.getMessage(), err.getLine(), ERROR);
- // setMarker(err.getMessage(),
- // scanner.getCurrentTokenStartPosition(),
- // scanner.getCurrentTokenEndPosition(), ERROR);
- }
- // if an error occured,
- // try to find keywords 'class' or 'function'
- // to parse the rest of the string
- while (token != TokenNameEOF && token != TokenNameERROR) {
- if (token == TokenNameabstract || token == TokenNamefinal
- || token == TokenNameclass || token == TokenNamefunction) {
- break;
- }
- getNextToken();
- }
- if (token == TokenNameEOF || token == TokenNameERROR) {
- return;
- }
- }
- } while (true);
- }
+// public void phpParserTester(String s, int rowCount) {
+// this.str = s;
+// if (s == null) {
+// if (phpList.size() != 0) {
+// this.str = ((PHPString) phpList.get(currentPHPString++)).getPHPString();
+// }
+// }
+// this.token = TokenNameEOF;
+// // this.chIndx = 0;
+// // this.rowCount = rowCount;
+// // this.columnCount = 0;
+// this.phpEnd = false;
+// this.phpMode = true;
+// scanner.setSource(s.toCharArray());
+// scanner.setPHPMode(true);
+// getNextToken();
+// do {
+// try {
+// if (token != TokenNameEOF && token != TokenNameERROR) {
+// statementList();
+// }
+// if (token != TokenNameEOF) {
+// if (token == TokenNameERROR) {
+// throwSyntaxError("Scanner error (Found unknown token: "
+// + scanner.toStringAction(token) + ")");
+// }
+// if (token == TokenNameRPAREN) {
+// throwSyntaxError("Too many closing ')'; end-of-file not reached.");
+// }
+// if (token == TokenNameRBRACE) {
+// throwSyntaxError("Too many closing '}'; end-of-file not reached.");
+// }
+// if (token == TokenNameRBRACKET) {
+// throwSyntaxError("Too many closing ']'; end-of-file not reached.");
+// }
+// if (token == TokenNameLPAREN) {
+// throwSyntaxError("Read character '('; end-of-file not reached.");
+// }
+// if (token == TokenNameLBRACE) {
+// throwSyntaxError("Read character '{'; end-of-file not reached.");
+// }
+// if (token == TokenNameLBRACKET) {
+// throwSyntaxError("Read character '['; end-of-file not reached.");
+// }
+// throwSyntaxError("End-of-file not reached.");
+// }
+// return;
+// } catch (SyntaxError err) {
+// if (s != null) {
+// throw err;
+// } else {
+// // setMarker(err.getMessage(), err.getLine(), ERROR);
+// // setMarker(err.getMessage(),
+// // scanner.getCurrentTokenStartPosition(),
+// // scanner.getCurrentTokenEndPosition(), ERROR);
+// }
+// // if an error occured,
+// // try to find keywords 'class' or 'function'
+// // to parse the rest of the string
+// while (token != TokenNameEOF && token != TokenNameERROR) {
+// if (token == TokenNameabstract || token == TokenNamefinal
+// || token == TokenNameclass || token == TokenNamefunction) {
+// break;
+// }
+// getNextToken();
+// }
+// if (token == TokenNameEOF || token == TokenNameERROR) {
+// return;
+// }
+// }
+// } while (true);
+// }
public void init(String s) {
this.str = s;
this.token = TokenNameEOF;
// this.rowCount = 1;
// this.columnCount = 0;
this.phpEnd = false;
- this.phpMode = false;
+// this.phpMode = false;
/* scanner initialization */
scanner.setSource(s.toCharArray());
scanner.setPHPMode(false);
// this.rowCount = 1;
// this.columnCount = 0;
this.phpEnd = false;
- this.phpMode = phpMode;
+// this.phpMode = phpMode;
scanner.setPHPMode(phpMode);
}
/**
// return outlineInfo;
// }
private boolean isVariable() {
- return token == TokenNameVariable || token == TokenNamethis;
+ return token == TokenNameVariable; // || token == TokenNamethis;
}
// private void parseDeclarations(PHPOutlineInfo outlineInfo,
// OutlineableWithChildren current, boolean goBack) {
// TokenNamenew) {
// char[] ident = scanner.getCurrentIdentifierSource();
// String keyword = new String(ident);
- if (token == TokenNameAT) {
- getNextToken();
- if (token != TokenNamerequire && token != TokenNamerequire_once
- && token != TokenNameinclude && token != TokenNameinclude_once
- && token != TokenNameIdentifier && token != TokenNameVariable
- && token != TokenNamethis && token != TokenNameStringInterpolated) {
- throwSyntaxError("identifier expected after '@'.");
- }
- }
- if (token == TokenNameinclude || token == TokenNameinclude_once) {
- getNextToken();
- if (token == TokenNameLPAREN) {
- expr();
- if (token == TokenNameSEMICOLON) {
- getNextToken();
- } else {
- if (previousToken != TokenNameAT && token != TokenNameStopPHP) {
- throwSyntaxError("';' expected after 'include' or 'include_once'.");
- }
- // getNextToken();
- }
- } else {
- concatenationExpression();
- }
- return;
- } else if (token == TokenNamerequire || token == TokenNamerequire_once) {
- getNextToken();
- //constant();
- if (token == TokenNameLPAREN) {
- expr();
- if (token == TokenNameSEMICOLON) {
- getNextToken();
- } else {
- if (previousToken != TokenNameAT && token != TokenNameStopPHP) {
- throwSyntaxError("';' expected after 'require' or 'require_once'.");
- }
- // getNextToken();
- }
- } else {
- concatenationExpression();
- }
- return;
- } else if (token == TokenNameif) {
+ // if (token == TokenNameAT) {
+ // getNextToken();
+ // if (token != TokenNamerequire && token != TokenNamerequire_once
+ // && token != TokenNameinclude && token != TokenNameinclude_once
+ // && token != TokenNameIdentifier && token != TokenNameVariable
+ // && token != TokenNameStringInterpolated) {
+ // throwSyntaxError("identifier expected after '@'.");
+ // }
+ // }
+ // if (token == TokenNameinclude || token == TokenNameinclude_once) {
+ // getNextToken();
+ // if (token == TokenNameLPAREN) {
+ // expr();
+ // if (token == TokenNameSEMICOLON) {
+ // getNextToken();
+ // } else {
+ // if (previousToken != TokenNameAT && token != TokenNameStopPHP) {
+ // throwSyntaxError("';' expected after 'include' or 'include_once'.");
+ // }
+ // // getNextToken();
+ // }
+ // } else {
+ // concatenationExpression();
+ // }
+ // return;
+ // } else if (token == TokenNamerequire || token == TokenNamerequire_once)
+ // {
+ // getNextToken();
+ // //constant();
+ // if (token == TokenNameLPAREN) {
+ // expr();
+ // if (token == TokenNameSEMICOLON) {
+ // getNextToken();
+ // } else {
+ // if (previousToken != TokenNameAT && token != TokenNameStopPHP) {
+ // throwSyntaxError("';' expected after 'require' or 'require_once'.");
+ // }
+ // // getNextToken();
+ // }
+ // } else {
+ // concatenationExpression();
+ // }
+ // return;
+ // } else
+ if (token == TokenNameif) {
getNextToken();
if (token == TokenNameLPAREN) {
getNextToken();
// getNextToken();
// }
// return;
- } else if (token == TokenNameglobal || token == TokenNamestatic) {
+ } else if (token == TokenNameglobal) {
getNextToken();
- variableList();
+ global_var_list();
if (token == TokenNameSEMICOLON) {
getNextToken();
} else {
if (token != TokenNameStopPHP) {
- throwSyntaxError("';' expected after 'global' or 'static' statement.");
+ throwSyntaxError("';' expected after 'global' statement.");
}
getNextToken();
}
return;
- } else if (token == TokenNameunset) {
+ } else if (token == TokenNamestatic) {
+ getNextToken();
+ static_var_list();
+ if (token == TokenNameSEMICOLON) {
+ getNextToken();
+ } else {
+ if (token != TokenNameStopPHP) {
+ throwSyntaxError("';' expected after 'static' statement.");
+ }
+ getNextToken();
+ }
+ return;
+ }else if (token == TokenNameunset) {
getNextToken();
if (token == TokenNameLPAREN) {
getNextToken();
}
}
}
+ private void global_var_list() {
+ // global_var_list:
+ // global_var_list ',' global_var
+ //| global_var
+ while (true) {
+ global_var();
+ if (token != TokenNameCOMMA) {
+ break;
+ }
+ getNextToken();
+ }
+ }
+ private void global_var() {
+ //global_var:
+ // T_VARIABLE
+ //| '$' r_variable
+ //| '$' '{' expr '}'
+ if (token == TokenNameVariable) {
+ getNextToken();
+ } else if (token == TokenNameDOLLAR) {
+ getNextToken();
+ if (token == TokenNameLPAREN) {
+ getNextToken();
+ expr();
+ if (token != TokenNameLPAREN) {
+ throwSyntaxError("')' expected in global variable.");
+ }
+ getNextToken();
+ } else {
+ r_variable();
+ }
+ }
+ }
+ private void static_var_list() {
+ //static_var_list:
+ // static_var_list ',' T_VARIABLE
+ //| static_var_list ',' T_VARIABLE '=' static_scalar
+ //| T_VARIABLE
+ //| T_VARIABLE '=' static_scalar
+ while (true) {
+ if (token == TokenNameVariable) {
+ getNextToken();
+ if (token == TokenNameEQUAL) {
+ getNextToken();
+ static_scalar();
+ }
+ if (token != TokenNameCOMMA) {
+ break;
+ }
+ getNextToken();
+ } else {
+ break;
+ }
+ }
+ }
private void unset_variables() {
// unset_variables:
// unset_variable
static_scalar();
}
} else {
- if (token == TokenNamethis) {
- throwSyntaxError("'$this' not allowed after keyword 'public' 'protected' 'private' 'var'.");
- }
- throwSyntaxError("Variable expected keyword 'public' 'protected' 'private' 'var'.");
+ // if (token == TokenNamethis) {
+ // throwSyntaxError("'$this' not allowed after keyword 'public'
+ // 'protected' 'private' 'var'.");
+ // }
+ throwSyntaxError("Variable expected after keyword 'public' 'protected' 'private' 'var'.");
}
if (token != TokenNameCOMMA) {
break;
}
return;
}
- if (token == TokenNamethis) {
- throwSyntaxError("Reserved word '$this' not allowed in parameter declaration.");
- }
+ // if (token == TokenNamethis) {
+ // throwSyntaxError("Reserved word '$this' not allowed in parameter
+ // declaration.");
+ // }
}
private void labeledStatementList() {
if (token != TokenNamecase && token != TokenNamedefault) {
} while (true);
}
private void expr() {
- //todo: find a better way to get the expression
- // expression = new StringBuffer();
- // for (int i = chIndx; i < str.length(); i++) {
- // if (str.charAt(i) == ';') {
- // break;
- // }
- // expression.append(str.charAt(i));
- // }
- // if (token == TokenNameSTRING_CONSTANT || token ==
- // TokenNameINTERPOLATED_STRING) {
- // getNextToken();
- // } else {
- logicalinclusiveorExpression();
- // while (token != TokenNameSEMICOLON) {
- // getNextToken();
- // // }
+ // r_variable
+ // | expr_without_variable
+ // if (token!=TokenNameEOF) {
+ if (Scanner.TRACE) {
+ System.out.println("TRACE: expr()");
+ }
+ expr_without_variable(true);
// }
}
- private void expr_without_variable() {
- // String ident;
- char[] ident;
- boolean castFlag = false;
- boolean arrayFlag = false;
+ private void expr_without_variable(boolean only_variable) {
+ // internal_functions_in_yacc
+ // | T_CLONE expr
+ // | T_PRINT expr
+ // | '(' expr ')'
+ // | '@' expr
+ // | '+' expr
+ // | '-' expr
+ // | '!' expr
+ // | '~' expr
+ // | T_INC rw_variable
+ // | T_DEC rw_variable
+ // | T_INT_CAST expr
+ // | T_DOUBLE_CAST expr
+ // | T_STRING_CAST expr
+ // | T_ARRAY_CAST expr
+ // | T_OBJECT_CAST expr
+ // | T_BOOL_CAST expr
+ // | T_UNSET_CAST expr
+ // | T_EXIT exit_expr
+ // | scalar
+ // | T_ARRAY '(' array_pair_list ')'
+ // | '`' encaps_list '`'
+ // | T_LIST '(' assignment_list ')' '=' expr
+ // | T_NEW class_name_reference ctor_arguments
+ // | variable '=' expr
+ // | variable '=' '&' variable
+ // | variable '=' '&' T_NEW class_name_reference ctor_arguments
+ // | variable T_PLUS_EQUAL expr
+ // | variable T_MINUS_EQUAL expr
+ // | variable T_MUL_EQUAL expr
+ // | variable T_DIV_EQUAL expr
+ // | variable T_CONCAT_EQUAL expr
+ // | variable T_MOD_EQUAL expr
+ // | variable T_AND_EQUAL expr
+ // | variable T_OR_EQUAL expr
+ // | variable T_XOR_EQUAL expr
+ // | variable T_SL_EQUAL expr
+ // | variable T_SR_EQUAL expr
+ // | rw_variable T_INC
+ // | rw_variable T_DEC
+ // | expr T_BOOLEAN_OR expr
+ // | expr T_BOOLEAN_AND expr
+ // | expr T_LOGICAL_OR expr
+ // | expr T_LOGICAL_AND expr
+ // | expr T_LOGICAL_XOR expr
+ // | expr '|' expr
+ // | expr '&' expr
+ // | expr '^' expr
+ // | expr '.' expr
+ // | expr '+' expr
+ // | expr '-' expr
+ // | expr '*' expr
+ // | expr '/' expr
+ // | expr '%' expr
+ // | expr T_SL expr
+ // | expr T_SR expr
+ // | expr T_IS_IDENTICAL expr
+ // | expr T_IS_NOT_IDENTICAL expr
+ // | expr T_IS_EQUAL expr
+ // | expr T_IS_NOT_EQUAL expr
+ // | expr '<' expr
+ // | expr T_IS_SMALLER_OR_EQUAL expr
+ // | expr '>' expr
+ // | expr T_IS_GREATER_OR_EQUAL expr
+ // | expr T_INSTANCEOF class_name_reference
+ // | expr '?' expr ':' expr
+ if (Scanner.TRACE) {
+ System.out.println("TRACE: expr_without_variable() PART 1");
+ }
switch (token) {
case TokenNameisset :
case TokenNameempty :
case TokenNamerequire_once :
internal_functions_in_yacc();
break;
- case TokenNamenew :
- getNextToken();
- expr();
- break;
- //
- // case TokenNamenull :
- // getNextToken();
- // break;
- // case TokenNamefalse :
- // getNextToken();
- // break;
- // case TokenNametrue :
- // getNextToken();
- // break;
- case TokenNameStringConstant :
- getNextToken();
- break;
- case TokenNameHEREDOC :
- case TokenNameStringInterpolated :
- case TokenNameStringLiteral :
- getNextToken();
- break;
+ // | '(' expr ')'
case TokenNameLPAREN :
getNextToken();
- if (token == TokenNameIdentifier) {
- // check if identifier is a type:
- // ident = identifier;
- ident = scanner.getCurrentIdentifierSource();
- String str = new String(ident).toLowerCase();
- for (int i = 0; i < PHP_TYPES.length; i++) {
- if (PHP_TYPES[i].equals(str)) {
- castFlag = true;
- if (PHP_TYPES[i].equals("array")) {
- arrayFlag = true;
- }
- break;
- }
- }
- }
- if (castFlag) {
- getNextToken();
- if (arrayFlag && token == TokenNameLPAREN) {
- getNextToken();
- if (token == TokenNameRPAREN) {
- getNextToken();
- } else {
- expr();
- if (token != TokenNameRPAREN) {
- throwSyntaxError(") expected after 'array('.");
- }
- }
- }
- if (token != TokenNameRPAREN) {
- throwSyntaxError(") expected after cast-type '" + str + "'.");
- }
+ expr();
+ if (token == TokenNameRPAREN) {
getNextToken();
- expr();
- break;
} else {
- expr();
+ throwSyntaxError("')' expected in expression.");
}
- if (token != TokenNameRPAREN) {
- throwSyntaxError(") expected in postfix-expression.");
- }
- getNextToken();
break;
- case TokenNameDoubleLiteral :
- getNextToken();
- break;
- case TokenNameIntegerLiteral :
- getNextToken();
- break;
- case TokenNameDOLLAR_LBRACE :
+ // | T_CLONE expr
+ // | T_PRINT expr
+ // | '@' expr
+ // | '+' expr
+ // | '-' expr
+ // | '!' expr
+ // | '~' expr
+ // | T_INT_CAST expr
+ // | T_DOUBLE_CAST expr
+ // | T_STRING_CAST expr
+ // | T_ARRAY_CAST expr
+ // | T_OBJECT_CAST expr
+ // | T_BOOL_CAST expr
+ // | T_UNSET_CAST expr
+ case TokenNameclone :
+ case TokenNameprint :
+ case TokenNameAT :
+ case TokenNamePLUS :
+ case TokenNameMINUS :
+ case TokenNameNOT :
+ case TokenNameTWIDDLE :
+ case TokenNameintCAST :
+ case TokenNamedoubleCAST :
+ case TokenNamestringCAST :
+ case TokenNamearrayCAST :
+ case TokenNameobjectCAST :
+ case TokenNameboolCAST :
+ case TokenNameunsetCAST :
getNextToken();
expr();
- if (token != TokenNameRBRACE) {
- throwSyntaxError("'}' expected after indirect variable token '${'.");
- }
- getNextToken();
break;
- case TokenNameVariable :
- case TokenNamethis :
- ident = scanner.getCurrentIdentifierSource();
+ case TokenNameexit :
getNextToken();
- if (token == TokenNameLBRACE) {
- getNextToken();
- expr();
- if (token != TokenNameRBRACE) {
- throwSyntaxError("'}' expected after variable '"
- + new String(ident) + "' in variable-expression.");
- }
- getNextToken();
- } else if (token == TokenNameLPAREN) {
- getNextToken();
- if (token != TokenNameRPAREN) {
- expressionList();
- if (token != TokenNameRPAREN) {
- throwSyntaxError("')' expected after variable '"
- + new String(ident) + "' in postfix-expression.");
- }
- }
- getNextToken();
- }
+ exit_expr();
break;
- case TokenNameIdentifier :
- ident = scanner.getCurrentIdentifierSource();
+ // scalar:
+ // T_STRING
+ //| T_STRING_VARNAME
+ //| class_constant
+ //| '"' encaps_list '"'
+ //| '\'' encaps_list '\''
+ //| T_START_HEREDOC encaps_list T_END_HEREDOC
+ // | '`' encaps_list '`'
+ // | common_scalar
+ case TokenNameIntegerLiteral :
+ case TokenNameDoubleLiteral :
+ case TokenNameStringLiteral :
+ case TokenNameStringConstant :
+ case TokenNameStringInterpolated :
+ case TokenNameFILE :
+ case TokenNameLINE :
+ case TokenNameCLASS_C :
+ case TokenNameMETHOD_C :
+ case TokenNameFUNC_C :
+ common_scalar();
+ break;
+ case TokenNameHEREDOC :
getNextToken();
- if (token == TokenNameLPAREN) {
- getNextToken();
- if (token != TokenNameRPAREN) {
- expressionList();
- if (token != TokenNameRPAREN) {
- throwSyntaxError("')' expected after identifier '"
- + new String(ident) + "' in postfix-expression."
- + "(Found token: " + scanner.toStringAction(token) + ")");
- }
- }
- getNextToken();
- }
break;
case TokenNamearray :
// T_ARRAY '(' array_pair_list ')'
+ "(Found token: " + scanner.toStringAction(token) + ")");
}
break;
- case TokenNameprint :
- getNextToken();
- expr();
- break;
- case TokenNameexit :
- getNextToken();
- exit_expr();
- break;
case TokenNamelist :
+ // | T_LIST '(' assignment_list ')' '=' expr
getNextToken();
if (token == TokenNameLPAREN) {
getNextToken();
- if (token == TokenNameCOMMA) {
- getNextToken();
- }
- expressionList();
+ assignment_list();
if (token != TokenNameRPAREN) {
throwSyntaxError("')' expected after 'list' keyword.");
}
getNextToken();
- // if (token == TokenNameSET) {
- // getNextToken();
- // logicalinclusiveorExpression();
- // }
+ if (token != TokenNameEQUAL) {
+ throwSyntaxError("'=' expected after 'list' keyword.");
+ }
+ getNextToken();
+ expr();
} else {
throwSyntaxError("'(' expected after 'list' keyword.");
}
break;
- // case TokenNameexit :
- // getNextToken();
- // if (token != TokenNameSEMICOLON) {
- // exitStatus();
- // }
- // if (token == TokenNameSEMICOLON) {
- // getNextToken();
- // } else {
- // if (token != TokenNameStopPHP) {
- // throwSyntaxError("';' expected after 'exit' expression.");
- // }
- // getNextToken();
- // }
- // break;
- // case TokenNamedie :
- // getNextToken();
- // if (token != TokenNameSEMICOLON) {
- // exitStatus();
- // }
- // if (token == TokenNameSEMICOLON) {
- // getNextToken();
- // } else {
- // if (token != TokenNameStopPHP) {
- // throwSyntaxError("';' expected after 'die' expression.");
- // }
- // }
- // break;
- // case TokenNamearray :
- // getNextToken();
- // if (token == TokenNameARGOPEN) {
- // getNextToken();
- // if (token == TokenNameCOMMA) {
- // getNextToken();
- // }
- // expressionList();
- // if (token != TokenNameARGCLOSE) {
- // throwSyntaxError("')' expected after 'list' keyword.");
- // }
- // getNextToken();
- // if (token == TokenNameSET) {
- // getNextToken();
- // logicalinclusiveorExpression();
- // }
- // } else {
- // throwSyntaxError("'(' expected after 'list' keyword.");
- // }
- // break;
+ case TokenNamenew :
+ // | T_NEW class_name_reference ctor_arguments
+ getNextToken();
+ class_name_reference();
+ ctor_arguments();
+ break;
+ // | T_INC rw_variable
+ // | T_DEC rw_variable
+ case TokenNamePLUS_PLUS :
+ case TokenNameMINUS_MINUS :
+ getNextToken();
+ rw_variable();
+ break;
+ // | variable '=' expr
+ // | variable '=' '&' variable
+ // | variable '=' '&' T_NEW class_name_reference ctor_arguments
+ // | variable T_PLUS_EQUAL expr
+ // | variable T_MINUS_EQUAL expr
+ // | variable T_MUL_EQUAL expr
+ // | variable T_DIV_EQUAL expr
+ // | variable T_CONCAT_EQUAL expr
+ // | variable T_MOD_EQUAL expr
+ // | variable T_AND_EQUAL expr
+ // | variable T_OR_EQUAL expr
+ // | variable T_XOR_EQUAL expr
+ // | variable T_SL_EQUAL expr
+ // | variable T_SR_EQUAL expr
+ // | rw_variable T_INC
+ // | rw_variable T_DEC
+ case TokenNameIdentifier :
+ case TokenNameVariable :
+ case TokenNameDOLLAR :
+ variable();
+ switch (token) {
+ case TokenNameEQUAL :
+ getNextToken();
+ if (token == TokenNameAND) {
+ getNextToken();
+ if (token == TokenNamenew) {
+ getNextToken();
+ throwSyntaxError("not yet implemented (= & new)");
+ // class_name_reference();
+ // ctor_arguments();
+ } else {
+ variable();
+ }
+ } else {
+ expr();
+ }
+ break;
+ case TokenNamePLUS_EQUAL :
+ case TokenNameMINUS_EQUAL :
+ case TokenNameMULTIPLY_EQUAL :
+ case TokenNameDIVIDE_EQUAL :
+ case TokenNameDOT_EQUAL :
+ case TokenNameREMAINDER_EQUAL :
+ case TokenNameAND_EQUAL :
+ case TokenNameOR_EQUAL :
+ case TokenNameXOR_EQUAL :
+ case TokenNameRIGHT_SHIFT_EQUAL :
+ case TokenNameLEFT_SHIFT_EQUAL :
+ getNextToken();
+ expr();
+ break;
+ case TokenNamePLUS_PLUS :
+ case TokenNameMINUS_MINUS :
+ getNextToken();
+ break;
+ default :
+ if (!only_variable) {
+ throwSyntaxError("Variable expression not allowed (found token '"
+ + scanner.toStringAction(token) + "').");
+ }
+ }
+ break;
+ default :
+ if (token != TokenNameStopPHP) {
+ throwSyntaxError("Error in expression (found token '"
+ + scanner.toStringAction(token) + "').");
+ }
+ return;
}
- boolean while_flag = true;
- do {
+ if (Scanner.TRACE) {
+ System.out.println("TRACE: expr_without_variable() PART 2");
+ }
+ // | expr T_BOOLEAN_OR expr
+ // | expr T_BOOLEAN_AND expr
+ // | expr T_LOGICAL_OR expr
+ // | expr T_LOGICAL_AND expr
+ // | expr T_LOGICAL_XOR expr
+ // | expr '|' expr
+ // | expr '&' expr
+ // | expr '^' expr
+ // | expr '.' expr
+ // | expr '+' expr
+ // | expr '-' expr
+ // | expr '*' expr
+ // | expr '/' expr
+ // | expr '%' expr
+ // | expr T_SL expr
+ // | expr T_SR expr
+ // | expr T_IS_IDENTICAL expr
+ // | expr T_IS_NOT_IDENTICAL expr
+ // | expr T_IS_EQUAL expr
+ // | expr T_IS_NOT_EQUAL expr
+ // | expr '<' expr
+ // | expr T_IS_SMALLER_OR_EQUAL expr
+ // | expr '>' expr
+ // | expr T_IS_GREATER_OR_EQUAL expr
+ while (true) {
switch (token) {
- case TokenNameLBRACKET :
+ case TokenNameOR_OR :
+ case TokenNameAND_AND :
+ case TokenNameand :
+ case TokenNameor :
+ case TokenNamexor :
+ case TokenNameAND :
+ case TokenNameOR :
+ case TokenNameXOR :
+ case TokenNameDOT :
+ case TokenNamePLUS :
+ case TokenNameMINUS :
+ case TokenNameMULTIPLY :
+ case TokenNameDIVIDE :
+ case TokenNameREMAINDER :
+ case TokenNameLEFT_SHIFT :
+ case TokenNameRIGHT_SHIFT :
+ case TokenNameEQUAL_EQUAL_EQUAL :
+ case TokenNameNOT_EQUAL_EQUAL :
+ case TokenNameEQUAL_EQUAL :
+ case TokenNameNOT_EQUAL :
+ case TokenNameLESS :
+ case TokenNameLESS_EQUAL :
+ case TokenNameGREATER :
+ case TokenNameGREATER_EQUAL :
getNextToken();
expr();
- if (token != TokenNameRBRACKET) {
- throwSyntaxError("] expected in postfix-expression.");
- }
+ break;
+ // | expr T_INSTANCEOF class_name_reference
+ // | expr '?' expr ':' expr
+ case TokenNameinstanceof :
getNextToken();
+ throwSyntaxError("not yet implemented (class_name_reference)");
+ // class_name_reference();
break;
- case TokenNamePAAMAYIM_NEKUDOTAYIM :
- // ::
- case TokenNameMINUS_GREATER :
- // ->
+ case TokenNameQUESTION :
getNextToken();
- if (token > TokenNameKEYWORD) {
- ident = scanner.getCurrentIdentifierSource();
- // setMarker(
- // "Avoid using keyword '"
- // + new String(ident)
- // + "' as variable name.",
- // rowCount,
- // PHPParser.INFO);
- // setMarker(
- // "Avoid using keyword '" + new String(ident) + "' as
- // variable name.",
- // scanner.getCurrentTokenStartPosition(),
- // scanner.getCurrentTokenEndPosition(),
- // INFO);
- }
- switch (token) {
- case TokenNameVariable :
- ident = scanner.getCurrentIdentifierSource();
- getNextToken();
- // if (token == TokenNameARGOPEN) {
- // getNextToken();
- // expressionList();
- // if (token != TokenNameARGCLOSE) {
- // throwSyntaxError(") expected after variable '" +
- // ident + "'.");
- // }
- // getNextToken();
- // }
- break;
- case TokenNameIdentifier :
- //ident = scanner.getCurrentIdentifierSource();
- getNextToken();
- break;
- case TokenNameLBRACE :
- getNextToken();
- expr();
- if (token != TokenNameRBRACE) {
- throwSyntaxError("} expected in postfix-expression.");
- }
- getNextToken();
- break;
- default :
- throwSyntaxError("Syntax error after '->' token.");
- }
- while (token == TokenNameLBRACKET || token == TokenNameLPAREN
- || token == TokenNameLBRACE) {
- if (token == TokenNameLBRACKET) {
- getNextToken();
- expressionList();
- if (token != TokenNameRBRACKET) {
- throwSyntaxError("] expected after '->'.");
- }
- getNextToken();
- } else if (token == TokenNameLPAREN) {
- getNextToken();
- expressionList();
- if (token != TokenNameRPAREN) {
- throwSyntaxError(") expected after '->'.");
- }
- getNextToken();
- } else if (token == TokenNameLBRACE) {
- getNextToken();
- expr();
- if (token != TokenNameRBRACE) {
- throwSyntaxError("} expected after '->'.");
- }
- getNextToken();
- }
+ expr();
+ if (token == TokenNameCOLON) {
+ getNextToken();
+ expr();
}
break;
- case TokenNamePLUS_PLUS :
+ default :
+ return;
+ }
+ }
+ }
+ private void class_name_reference() {
+ // class_name_reference:
+ // T_STRING
+ //| dynamic_class_name_reference
+ if (Scanner.TRACE) {
+ System.out.println("TRACE: class_name_reference()");
+ }
+ if (token == TokenNameIdentifier) {
+ getNextToken();
+ } else {
+ dynamic_class_name_reference();
+ }
+ }
+ private void dynamic_class_name_reference() {
+ //dynamic_class_name_reference:
+ // base_variable T_OBJECT_OPERATOR object_property
+ // dynamic_class_name_variable_properties
+ //| base_variable
+ if (Scanner.TRACE) {
+ System.out.println("TRACE: dynamic_class_name_reference()");
+ }
+ base_variable();
+ if (token == TokenNameMINUS_GREATER) {
+ getNextToken();
+ object_property();
+ dynamic_class_name_variable_properties();
+ }
+ }
+ private void dynamic_class_name_variable_properties() {
+ // dynamic_class_name_variable_properties:
+ // dynamic_class_name_variable_properties
+ // dynamic_class_name_variable_property
+ // | /* empty */
+ if (Scanner.TRACE) {
+ System.out.println("TRACE: dynamic_class_name_variable_properties()");
+ }
+ while (token == TokenNameMINUS_GREATER) {
+ dynamic_class_name_variable_property();
+ }
+ }
+ private void dynamic_class_name_variable_property() {
+ // dynamic_class_name_variable_property:
+ // T_OBJECT_OPERATOR object_property
+ if (Scanner.TRACE) {
+ System.out.println("TRACE: dynamic_class_name_variable_property()");
+ }
+ if (token == TokenNameMINUS_GREATER) {
+ getNextToken();
+ object_property();
+ }
+ }
+ private void ctor_arguments() {
+ // ctor_arguments:
+ // /* empty */
+ //| '(' function_call_parameter_list ')'
+ if (token == TokenNameLPAREN) {
+ getNextToken();
+ if (token == TokenNameRPAREN) {
+ getNextToken();
+ return;
+ }
+ non_empty_function_call_parameter_list();
+ if (token != TokenNameRPAREN) {
+ throwSyntaxError("')' expected in ctor_arguments.");
+ }
+ getNextToken();
+ }
+ }
+ private void assignment_list() {
+ // assignment_list:
+ // assignment_list ',' assignment_list_element
+ //| assignment_list_element
+ while (true) {
+ assignment_list_element();
+ if (token != TokenNameCOMMA) {
+ break;
+ }
+ getNextToken();
+ }
+ }
+ private void assignment_list_element() {
+ //assignment_list_element:
+ // variable
+ //| T_LIST '(' assignment_list ')'
+ //| /* empty */
+ if (token == TokenNameVariable || token == TokenNameDOLLAR) {
+ variable();
+ } else {
+ if (token == TokenNamelist) {
+ getNextToken();
+ if (token == TokenNameLPAREN) {
getNextToken();
- break;
- case TokenNameMINUS_MINUS :
+ assignment_list();
+ if (token != TokenNameRPAREN) {
+ throwSyntaxError("')' expected after 'list' keyword.");
+ }
getNextToken();
- break;
- default :
- while_flag = false;
+ } else {
+ throwSyntaxError("'(' expected after 'list' keyword.");
+ }
}
- } while (while_flag);
+ }
}
private void array_pair_list() {
// array_pair_list:
}
}
}
- private void unaryExpression() {
- switch (token) {
- case TokenNamePLUS_PLUS :
- getNextToken();
- unaryExpression();
- break;
- case TokenNameMINUS_MINUS :
- getNextToken();
- unaryExpression();
- break;
- // '@' '&' '*' '+' '-' '~' '!'
- case TokenNameAT :
- getNextToken();
- if (token == TokenNameinclude || token == TokenNameinclude_once
- || token == TokenNamerequire || token == TokenNamerequire_once) {
- statement(TokenNameAT);
- } else {
- expr_without_variable(); // castExpression();
- }
- break;
- case TokenNameAND :
- getNextToken();
- castExpression();
- break;
- case TokenNameMULTIPLY :
- getNextToken();
- castExpression();
- break;
- case TokenNamePLUS :
- getNextToken();
- castExpression();
- break;
- case TokenNameMINUS :
- getNextToken();
- castExpression();
- break;
- case TokenNameTWIDDLE :
- getNextToken();
- castExpression();
- break;
- case TokenNameNOT :
- getNextToken();
- castExpression();
- break;
- default :
- expr_without_variable();
+// private void variableList() {
+// do {
+// variable();
+// if (token == TokenNameCOMMA) {
+// getNextToken();
+// } else {
+// break;
+// }
+// } while (true);
+// }
+ private void variable_without_objects() {
+ // variable_without_objects:
+ // reference_variable
+ // | simple_indirect_reference reference_variable
+ if (Scanner.TRACE) {
+ System.out.println("TRACE: variable_without_objects()");
}
- }
- private void castExpression() {
- // if (token == TokenNameARGOPEN) {
- // getNextToken();
- // typeName();
- // if (token != TokenNameARGCLOSE) {
- // throwSyntaxError(") expected after cast-expression.");
- // }
- // getNextToken();
- // }
- unaryExpression();
- }
- private void assignExpression() {
- castExpression();
- if (token == TokenNameEQUAL) { // =
- getNextToken();
- logicalinclusiveorExpression();
- } else if (token == TokenNameDOT_EQUAL) { // .=
- getNextToken();
- logicalinclusiveorExpression();
- } else if (token == TokenNameEQUAL_GREATER) { // =>
- getNextToken();
- logicalinclusiveorExpression();
- } else if (token == TokenNamePLUS_EQUAL) { // +=
- getNextToken();
- logicalinclusiveorExpression();
- } else if (token == TokenNameMINUS_EQUAL) { // -=
- getNextToken();
- logicalinclusiveorExpression();
- } else if (token == TokenNameMULTIPLY_EQUAL) { // *=
- getNextToken();
- logicalinclusiveorExpression();
- } else if (token == TokenNameDIVIDE_EQUAL) { // *=
+ while (token == TokenNameDOLLAR) {
getNextToken();
- logicalinclusiveorExpression();
- } else if (token == TokenNameREMAINDER_EQUAL) { // %=
- getNextToken();
- logicalinclusiveorExpression();
- } else if (token == TokenNameAND_EQUAL) { // &=
- getNextToken();
- logicalinclusiveorExpression();
- } else if (token == TokenNameOR_EQUAL) { // |=
- getNextToken();
- logicalinclusiveorExpression();
- } else if (token == TokenNameXOR_EQUAL) { // ^=
- getNextToken();
- logicalinclusiveorExpression();
- } else if (token == TokenNameLEFT_SHIFT_EQUAL) { // <<=
- getNextToken();
- logicalinclusiveorExpression();
- } else if (token == TokenNameRIGHT_SHIFT_EQUAL) { // >>=
- getNextToken();
- logicalinclusiveorExpression();
- } else if (token == TokenNameTWIDDLE_EQUAL) { // ~=
- getNextToken();
- logicalinclusiveorExpression();
}
- }
- private void multiplicativeExpression() {
- do {
- assignExpression();
- if (token != TokenNameMULTIPLY && token != TokenNameDIVIDE
- && token != TokenNameREMAINDER) {
- return;
- }
+ reference_variable();
+ }
+ private void function_call() {
+ // function_call:
+ // T_STRING '(' function_call_parameter_list ')'
+ //| class_constant '(' function_call_parameter_list ')'
+ //| static_member '(' function_call_parameter_list ')'
+ //| variable_without_objects '(' function_call_parameter_list ')'
+ if (Scanner.TRACE) {
+ System.out.println("TRACE: function_call()");
+ }
+ if (token == TokenNameIdentifier) {
getNextToken();
- } while (true);
- }
- private void concatenationExpression() {
- do {
- multiplicativeExpression();
- if (token != TokenNameDOT) {
- return;
+ switch (token) {
+ case TokenNamePAAMAYIM_NEKUDOTAYIM :
+ // static member:
+ getNextToken();
+ if (token == TokenNameIdentifier) {
+ // class _constant
+ getNextToken();
+ } else {
+ // static member:
+ variable_without_objects();
+ }
+ break;
}
+ } else {
+ variable_without_objects();
+ }
+ if (token != TokenNameLPAREN) {
+ // TODO is this ok ?
+ return;
+ // throwSyntaxError("'(' expected in function call.");
+ }
+ getNextToken();
+ if (token == TokenNameRPAREN) {
getNextToken();
- } while (true);
+ return;
+ }
+ non_empty_function_call_parameter_list();
+ if (token != TokenNameRPAREN) {
+ throwSyntaxError("')' expected in function call.");
+ }
+ getNextToken();
}
- private void additiveExpression() {
- do {
- concatenationExpression();
- if (token != TokenNamePLUS && token != TokenNameMINUS) {
- return;
+ // private void function_call_parameter_list() {
+ // function_call_parameter_list:
+ // non_empty_function_call_parameter_list { $$ = $1; }
+ // | /* empty */
+ // }
+ private void non_empty_function_call_parameter_list() {
+ //non_empty_function_call_parameter_list:
+ // expr_without_variable
+ // | variable
+ // | '&' w_variable
+ // | non_empty_function_call_parameter_list ',' expr_without_variable
+ // | non_empty_function_call_parameter_list ',' variable
+ // | non_empty_function_call_parameter_list ',' '&' w_variable
+ if (Scanner.TRACE) {
+ System.out.println("TRACE: non_empty_function_call_parameter_list()");
+ }
+ while (true) {
+ if (token == TokenNameAND) {
+ getNextToken();
+ w_variable();
+ } else {
+// if (token == TokenNameIdentifier || token == TokenNameVariable
+// || token == TokenNameDOLLAR) {
+// variable();
+// } else {
+ expr_without_variable(true);
+// }
}
- getNextToken();
- } while (true);
- }
- private void shiftExpression() {
- do {
- additiveExpression();
- if (token != TokenNameLEFT_SHIFT && token != TokenNameRIGHT_SHIFT) {
- return;
+ if (token != TokenNameCOMMA) {
+ break;
}
getNextToken();
- } while (true);
+ }
}
- private void relationalExpression() {
- do {
- shiftExpression();
- if (token != TokenNameLESS && token != TokenNameGREATER
- && token != TokenNameLESS_EQUAL && token != TokenNameGREATER_EQUAL) {
- return;
- }
+ private void fully_qualified_class_name() {
+ if (token == TokenNameIdentifier) {
getNextToken();
- } while (true);
+ } else {
+ throwSyntaxError("Class name expected.");
+ }
}
- private void identicalExpression() {
- do {
- relationalExpression();
- if (token != TokenNameEQUAL_EQUAL_EQUAL
- && token != TokenNameNOT_EQUAL_EQUAL) {
- return;
- }
+ private void static_member() {
+ // static_member:
+ // fully_qualified_class_name T_PAAMAYIM_NEKUDOTAYIM
+ // variable_without_objects
+ if (Scanner.TRACE) {
+ System.out.println("TRACE: static_member()");
+ }
+ fully_qualified_class_name();
+ if (token != TokenNamePAAMAYIM_NEKUDOTAYIM) {
+ throwSyntaxError("'::' expected after class name (static_member).");
+ }
+ getNextToken();
+ variable_without_objects();
+ }
+ private void base_variable_with_function_calls() {
+ // base_variable_with_function_calls:
+ // base_variable
+ //| function_call
+ boolean functionCall = false;
+ if (Scanner.TRACE) {
+ System.out.println("TRACE: base_variable_with_function_calls()");
+ }
+ if (token == TokenNameIdentifier) {
+ functionCall = true;
+ } else if (token == TokenNameVariable) {
+ int tempToken = token;
+ int tempPosition = scanner.currentPosition;
getNextToken();
- } while (true);
+ if (token == TokenNameLPAREN) {
+ functionCall = true;
+ }
+ token = tempToken;
+ scanner.currentPosition = tempPosition;
+ scanner.phpMode = true;
+ }
+ if (functionCall) {
+ function_call();
+ } else {
+ base_variable();
+ }
}
- private void equalityExpression() {
- do {
- identicalExpression();
- if (token != TokenNameEQUAL_EQUAL && token != TokenNameNOT_EQUAL) {
- return;
+ private void base_variable() {
+ // base_variable:
+ // reference_variable
+ // | simple_indirect_reference reference_variable
+ // | static_member
+ if (Scanner.TRACE) {
+ System.out.println("TRACE: base_variable()");
+ }
+ if (token == TokenNameIdentifier) {
+ static_member();
+ } else {
+ while (token == TokenNameDOLLAR) {
+ getNextToken();
}
- getNextToken();
- } while (true);
+ reference_variable();
+ }
}
- private void ternaryExpression() {
- equalityExpression();
- if (token == TokenNameQUESTION) {
- getNextToken();
- expr();
- if (token == TokenNameCOLON) {
+ // private void simple_indirect_reference() {
+ // // simple_indirect_reference:
+ // // '$'
+ // //| simple_indirect_reference '$'
+ // }
+ private void reference_variable() {
+ // reference_variable:
+ // reference_variable '[' dim_offset ']'
+ // | reference_variable '{' expr '}'
+ // | compound_variable
+ if (Scanner.TRACE) {
+ System.out.println("TRACE: reference_variable()");
+ }
+ compound_variable();
+ while (true) {
+ if (token == TokenNameLBRACE) {
getNextToken();
expr();
+ if (token != TokenNameRBRACE) {
+ throwSyntaxError("'}' expected in reference variable.");
+ }
+ getNextToken();
+ } else if (token == TokenNameLBRACKET) {
+ getNextToken();
+ if (token != TokenNameRBRACKET) {
+ expr();
+ // dim_offset();
+ if (token != TokenNameRBRACKET) {
+ throwSyntaxError("']' expected in reference variable.");
+ }
+ }
+ getNextToken();
} else {
- throwSyntaxError("':' expected in ternary operator '? :'.");
+ break;
}
}
}
- private void andExpression() {
- do {
- ternaryExpression();
- if (token != TokenNameAND) {
- return;
- }
- getNextToken();
- } while (true);
- }
- private void exclusiveorExpression() {
- do {
- andExpression();
- if (token != TokenNameXOR) {
- return;
- }
- getNextToken();
- } while (true);
- }
- private void inclusiveorExpression() {
- do {
- exclusiveorExpression();
- if (token != TokenNameOR) {
- return;
- }
- getNextToken();
- } while (true);
- }
- private void booleanandExpression() {
- do {
- inclusiveorExpression();
- if (token != TokenNameAND_AND) {
- return;
- }
- getNextToken();
- } while (true);
- }
- private void booleanorExpression() {
- do {
- booleanandExpression();
- if (token != TokenNameOR_OR) {
- return;
- }
+ private void compound_variable() {
+ // compound_variable:
+ // T_VARIABLE
+ // | '$' '{' expr '}'
+ if (Scanner.TRACE) {
+ System.out.println("TRACE: compound_variable()");
+ }
+ if (token == TokenNameVariable) {
getNextToken();
- } while (true);
- }
- private void logicalandExpression() {
- do {
- booleanorExpression();
- if (token != TokenNameAND) {
- return;
+ } else {
+ // because of simple_indirect_reference
+ while (token == TokenNameDOLLAR) {
+ getNextToken();
}
- getNextToken();
- } while (true);
- }
- private void logicalexclusiveorExpression() {
- do {
- logicalandExpression();
- if (token != TokenNameXOR) {
- return;
+ if (token != TokenNameLBRACE) {
+ throwSyntaxError("'{' expected after compound variable token '$'.");
}
getNextToken();
- } while (true);
- }
- private void logicalinclusiveorExpression() {
- do {
- logicalexclusiveorExpression();
- if (token != TokenNameOR) {
- return;
+ expr();
+ if (token != TokenNameRBRACE) {
+ throwSyntaxError("'}' expected after compound variable token '$'.");
}
getNextToken();
- } while (true);
+ }
}
- // public void assignmentExpression() {
- // if (token == TokenNameVARIABLE) {
- // getNextToken();
- // if (token == TokenNameSET) {
- // getNextToken();
- // logicalinclusiveorExpression();
- // }
- // } else {
- // logicalinclusiveorExpression();
- // }
+ // private void dim_offset() {
+ // // dim_offset:
+ // // /* empty */
+ // // | expr
+ // expr();
// }
- private void variableList() {
- do {
- variable();
- if (token == TokenNameCOMMA) {
+ private void object_property() {
+ // object_property:
+ // object_dim_list
+ //| variable_without_objects
+ if (Scanner.TRACE) {
+ System.out.println("TRACE: object_property()");
+ }
+ if (token == TokenNameVariable || token == TokenNameDOLLAR) {
+ variable_without_objects();
+ } else {
+ object_dim_list();
+ }
+ }
+ private void object_dim_list() {
+ //object_dim_list:
+ // object_dim_list '[' dim_offset ']'
+ //| object_dim_list '{' expr '}'
+ //| variable_name
+ if (Scanner.TRACE) {
+ System.out.println("TRACE: object_dim_list()");
+ }
+ variable_name();
+ while (true) {
+ if (token == TokenNameLBRACE) {
+ getNextToken();
+ expr();
+ if (token != TokenNameRBRACE) {
+ throwSyntaxError("'}' expected in object_dim_list.");
+ }
+ getNextToken();
+ } else if (token == TokenNameLBRACKET) {
+ getNextToken();
+ if (token == TokenNameRBRACKET) {
+ getNextToken();
+ continue;
+ }
+ expr();
+ if (token != TokenNameRBRACKET) {
+ throwSyntaxError("']' expected in object_dim_list.");
+ }
getNextToken();
} else {
break;
}
- } while (true);
+ }
}
- private void variable() {
- if (token == TokenNameDOLLAR_LBRACE) {
+ private void variable_name() {
+ //variable_name:
+ // T_STRING
+ //| '{' expr '}'
+ if (Scanner.TRACE) {
+ System.out.println("TRACE: variable_name()");
+ }
+ if (token == TokenNameIdentifier) {
+ getNextToken();
+ } else {
+ if (token != TokenNameLBRACE) {
+ throwSyntaxError("'{' expected in variable name.");
+ }
getNextToken();
expr();
- ;
if (token != TokenNameRBRACE) {
- throwSyntaxError("'}' expected after indirect variable token '${'.");
+ throwSyntaxError("'}' expected in variable name.");
}
+ }
+ }
+ private void r_variable() {
+ variable();
+ }
+ private void w_variable() {
+ variable();
+ }
+ private void rw_variable() {
+ variable();
+ }
+ private void variable() {
+ // variable:
+ // base_variable_with_function_calls T_OBJECT_OPERATOR
+ // object_property method_or_not variable_properties
+ // | base_variable_with_function_calls
+ base_variable_with_function_calls();
+ if (token == TokenNameMINUS_GREATER) {
+ getNextToken();
+ object_property();
+ method_or_not();
+ variable_properties();
+ }
+ // if (token == TokenNameDOLLAR_LBRACE) {
+ // getNextToken();
+ // expr();
+ // ;
+ // if (token != TokenNameRBRACE) {
+ // throwSyntaxError("'}' expected after indirect variable token '${'.");
+ // }
+ // getNextToken();
+ // } else {
+ // if (token == TokenNameVariable) {
+ // getNextToken();
+ // if (token == TokenNameLBRACKET) {
+ // getNextToken();
+ // expr();
+ // if (token != TokenNameRBRACKET) {
+ // throwSyntaxError("']' expected in variable-list.");
+ // }
+ // getNextToken();
+ // } else if (token == TokenNameEQUAL) {
+ // getNextToken();
+ // static_scalar();
+ // }
+ // } else {
+ // throwSyntaxError("$-variable expected in variable-list.");
+ // }
+ // }
+ }
+ private void variable_properties() {
+ // variable_properties:
+ // variable_properties variable_property
+ // | /* empty */
+ while (token == TokenNameMINUS_GREATER) {
+ variable_property();
+ }
+ }
+ private void variable_property() {
+ // variable_property:
+ // T_OBJECT_OPERATOR object_property method_or_not
+ if (Scanner.TRACE) {
+ System.out.println("TRACE: variable_property()");
+ }
+ if (token == TokenNameMINUS_GREATER) {
getNextToken();
+ object_property();
+ method_or_not();
} else {
- if (token == TokenNameVariable) {
+ throwSyntaxError("'->' expected in variable_property.");
+ }
+ }
+ private void method_or_not() {
+ // method_or_not:
+ // '(' function_call_parameter_list ')'
+ // | /* empty */
+ if (Scanner.TRACE) {
+ System.out.println("TRACE: method_or_not()");
+ }
+ if (token == TokenNameLPAREN) {
+ getNextToken();
+ if (token == TokenNameRPAREN) {
getNextToken();
- if (token == TokenNameLBRACKET) {
- getNextToken();
- expr();
- if (token != TokenNameRBRACKET) {
- throwSyntaxError("']' expected in variable-list.");
- }
- getNextToken();
- } else if (token == TokenNameEQUAL) {
- getNextToken();
- static_scalar();
- }
- } else {
- throwSyntaxError("$-variable expected in variable-list.");
+ return;
+ }
+ non_empty_function_call_parameter_list();
+ if (token != TokenNameRPAREN) {
+ throwSyntaxError("')' expected in method_or_not.");
}
+ getNextToken();
}
}
private void exit_expr() {
}
return false;
}
+ private void scalar() {
+ // scalar:
+ // T_STRING
+ //| T_STRING_VARNAME
+ //| class_constant
+ //| common_scalar
+ //| '"' encaps_list '"'
+ //| '\'' encaps_list '\''
+ //| T_START_HEREDOC encaps_list T_END_HEREDOC
+ throwSyntaxError("Not yet implemented (scalar).");
+ }
private void static_scalar() {
// static_scalar: /* compile-time evaluated scalars */
// common_scalar
* IBM Corporation - initial API and implementation
******************************************************************************/
package net.sourceforge.phpdt.internal.formatter;
-
import java.io.BufferedReader;
import java.io.IOException;
import java.io.StringReader;
import java.util.Hashtable;
import java.util.Locale;
import java.util.Map;
-
import net.sourceforge.phpdt.core.ICodeFormatter;
import net.sourceforge.phpdt.core.compiler.CharOperation;
import net.sourceforge.phpdt.core.compiler.ITerminalSymbols;
import net.sourceforge.phpdt.internal.compiler.parser.Scanner;
import net.sourceforge.phpdt.internal.formatter.impl.FormatterOptions;
import net.sourceforge.phpdt.internal.formatter.impl.SplitLine;
-
-/** <h2>How to format a piece of code ?</h2>
- * <ul><li>Create an instance of <code>CodeFormatter</code>
- * <li>Use the method <code>void format(aString)</code>
- * on this instance to format <code>aString</code>.
- * It will return the formatted string.</ul>
-*/
+/**
+ * <h2>How to format a piece of code ?</h2>
+ * <ul>
+ * <li>Create an instance of <code>CodeFormatter</code>
+ * <li>Use the method <code>void format(aString)</code> on this instance to
+ * format <code>aString</code>. It will return the formatted string.
+ * </ul>
+ */
public class CodeFormatter implements ITerminalSymbols, ICodeFormatter {
-
public FormatterOptions options;
-
- /**
+ /**
* Represents a block in the <code>constructions</code> stack.
*/
public static final int BLOCK = ITerminalSymbols.TokenNameLBRACE;
-
- /**
- * Represents a block following a control statement in the <code>constructions</code> stack.
+ /**
+ * Represents a block following a control statement in the <code>constructions</code>
+ * stack.
*/
public static final int NONINDENT_BLOCK = -100;
-
- /**
+ /**
* Contains the formatted output.
*/
StringBuffer formattedSource;
-
- /**
- * Contains the current line.<br>
+ /**
+ * Contains the current line. <br>
* Will be dumped at the next "newline"
*/
StringBuffer currentLineBuffer;
-
- /**
+ /**
* Used during the formatting to get each token.
*/
Scanner scanner;
-
- /**
- * Contains the tokens responsible for the current indentation level
- * and the blocks not closed yet.
+ /**
+ * Contains the tokens responsible for the current indentation level and the
+ * blocks not closed yet.
*/
private int[] constructions;
-
- /**
+ /**
* Index in the <code>constructions</code> array.
*/
private int constructionsCount;
-
- /**
- * Level of indentation of the current token (number of tab char put in front of it).
+ /**
+ * Level of indentation of the current token (number of tab char put in front
+ * of it).
*/
private int indentationLevel;
-
- /**
+ /**
* Regular level of indentation of all the lines
*/
private int initialIndentationLevel;
-
- /**
+ /**
* Used to split a line.
*/
Scanner splitScanner;
-
- /**
- * To remember the offset between the beginning of the line and the
- * beginning of the comment.
+ /**
+ * To remember the offset between the beginning of the line and the beginning
+ * of the comment.
*/
int currentCommentOffset;
int currentLineIndentationLevel;
int maxLineSize = 30;
private boolean containsOpenCloseBraces;
private int indentationLevelForOpenCloseBraces;
-
/**
* Collections of positions to map
*/
private int[] positionsToMap;
-
/**
* Collections of mapped positions
*/
private int[] mappedPositions;
-
private int indexToMap;
-
private int indexInMap;
-
private int globalDelta;
-
private int lineDelta;
-
private int splitDelta;
-
private int beginningOfLineIndex;
-
private int multipleLineCommentCounter;
-
- /**
+ /**
* Creates a new instance of Code Formatter using the given settings.
*
* @deprecated backport 1.0 internal functionality
public CodeFormatter(ConfigurableOption[] settings) {
this(convertConfigurableOptions(settings));
}
-
- /**
- * Creates a new instance of Code Formatter using the FormattingOptions object
- * given as argument
+ /**
+ * Creates a new instance of Code Formatter using the FormattingOptions
+ * object given as argument
+ *
* @deprecated Use CodeFormatter(ConfigurableOption[]) instead
*/
public CodeFormatter() {
this((Map) null);
}
- /**
+ /**
* Creates a new instance of Code Formatter using the given settings.
*/
public CodeFormatter(Map settings) {
-
// initialize internal state
constructionsCount = 0;
constructions = new int[10];
currentLineIndentationLevel = indentationLevel = initialIndentationLevel;
currentCommentOffset = -1;
-
// initialize primary and secondary scanners
- scanner = new Scanner(true /*comment*/
- , true /*whitespace*/
- , false /*nls*/
- , false /*assert*/
+ scanner = new Scanner(true /* comment */
+ , true /* whitespace */
+ , false /* nls */
+ , false /* assert */
); // regular scanner for forming lines
scanner.recordLineSeparator = true;
-
// to remind of the position of the beginning of the line.
- splitScanner = new Scanner(true /*comment*/
- , true /*whitespace*/
- , false /*nls*/
- , false /*assert*/
+ splitScanner = new Scanner(true /* comment */
+ , true /* whitespace */
+ , false /* nls */
+ , false /* assert */
);
// secondary scanner to split long lines formed by primary scanning
-
// initialize current line buffer
currentLineBuffer = new StringBuffer();
this.options = new FormatterOptions(settings);
}
-
/**
* Returns true if a lineSeparator has to be inserted before <code>operator</code>
* false otherwise.
return true;
}
}
-
- /**
- * @deprecated backport 1.0 internal functionality
- */
+ /**
+ * @deprecated backport 1.0 internal functionality
+ */
private static Map convertConfigurableOptions(ConfigurableOption[] settings) {
Hashtable options = new Hashtable(10);
-
for (int i = 0; i < settings.length; i++) {
if (settings[i].getComponentName().equals(CodeFormatter.class.getName())) {
String optionName = settings[i].getOptionName();
int valueIndex = settings[i].getCurrentValueIndex();
-
if (optionName.equals("newline.openingBrace")) { //$NON-NLS-1$
- options.put("net.sourceforge.phpdt.core.formatter.newline.openingBrace", valueIndex == 0 ? "insert" : "do not insert"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-
+ options.put(
+ "net.sourceforge.phpdt.core.formatter.newline.openingBrace",
+ valueIndex == 0 ? "insert" : "do not insert"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
} else if (optionName.equals("newline.controlStatement")) { //$NON-NLS-1$
- options.put("net.sourceforge.phpdt.core.formatter.newline.controlStatement", valueIndex == 0 ? "insert" : "do not insert"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-
+ options.put(
+ "net.sourceforge.phpdt.core.formatter.newline.controlStatement",
+ valueIndex == 0 ? "insert" : "do not insert"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
} else if (optionName.equals("newline.clearAll")) { //$NON-NLS-1$
- options.put("net.sourceforge.phpdt.core.formatter.newline.clearAll", valueIndex == 0 ? "clear all" : "preserve one"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-
+ options.put("net.sourceforge.phpdt.core.formatter.newline.clearAll",
+ valueIndex == 0 ? "clear all" : "preserve one"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
} else if (optionName.equals("newline.elseIf")) { //$NON-NLS-1$
- options.put("net.sourceforge.phpdt.core.formatter.newline.elseIf", valueIndex == 0 ? "do not insert" : "insert"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-
+ options.put("net.sourceforge.phpdt.core.formatter.newline.elseIf",
+ valueIndex == 0 ? "do not insert" : "insert"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
} else if (optionName.equals("newline.emptyBlock")) { //$NON-NLS-1$
- options.put("net.sourceforge.phpdt.core.formatter.newline.emptyBlock", valueIndex == 0 ? "insert" : "do not insert"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-
+ options.put(
+ "net.sourceforge.phpdt.core.formatter.newline.emptyBlock",
+ valueIndex == 0 ? "insert" : "do not insert"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
} else if (optionName.equals("lineSplit")) { //$NON-NLS-1$
- options.put("net.sourceforge.phpdt.core.formatter.lineSplit", String.valueOf(valueIndex)); //$NON-NLS-1$ //$NON-NLS-2$
-
+ options.put("net.sourceforge.phpdt.core.formatter.lineSplit", String
+ .valueOf(valueIndex)); //$NON-NLS-1$ //$NON-NLS-2$
} else if (optionName.equals("style.assignment")) { //$NON-NLS-1$
- options.put("net.sourceforge.phpdt.core.formatter.style.assignment", valueIndex == 0 ? "compact" : "normal"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-
+ options.put("net.sourceforge.phpdt.core.formatter.style.assignment",
+ valueIndex == 0 ? "compact" : "normal"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
} else if (optionName.equals("tabulation.char")) { //$NON-NLS-1$
- options.put("net.sourceforge.phpdt.core.formatter.tabulation.char", valueIndex == 0 ? "tab" : "space"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-
+ options.put("net.sourceforge.phpdt.core.formatter.tabulation.char",
+ valueIndex == 0 ? "tab" : "space"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
} else if (optionName.equals("tabulation.size")) { //$NON-NLS-1$
- options.put("net.sourceforge.phpdt.core.formatter.tabulation.size", String.valueOf(valueIndex)); //$NON-NLS-1$ //$NON-NLS-2$
+ options.put("net.sourceforge.phpdt.core.formatter.tabulation.size",
+ String.valueOf(valueIndex)); //$NON-NLS-1$ //$NON-NLS-2$
}
}
}
-
return options;
}
-
- /**
+ /**
* Returns the end of the source code.
*/
private final String copyRemainingSource() {
}
return (bufr.toString());
}
-
/**
- * Inserts <code>tabCount</code> tab character or their equivalent number of spaces.
+ * Inserts <code>tabCount</code> tab character or their equivalent number
+ * of spaces.
*/
private void dumpTab(int tabCount) {
if (options.indentWithTab) {
}
}
}
-
/**
* Dumps <code>currentLineBuffer</code> into the formatted string.
*/
beginningOfLineIndex = formattedSource.length();
if (containsOpenCloseBraces) {
containsOpenCloseBraces = false;
- outputLine(currentString, false, indentationLevelForOpenCloseBraces, 0, -1, null, 0);
+ outputLine(currentString, false, indentationLevelForOpenCloseBraces, 0,
+ -1, null, 0);
indentationLevelForOpenCloseBraces = currentLineIndentationLevel;
} else {
- outputLine(currentString, false, currentLineIndentationLevel, 0, -1, null, 0);
+ outputLine(currentString, false, currentLineIndentationLevel, 0, -1,
+ null, 0);
}
int scannerSourceLength = scanner.source.length;
if (scannerSourceLength > 2) {
- if (scanner.source[scannerSourceLength - 1] == '\n' && scanner.source[scannerSourceLength - 2] == '\r') {
+ if (scanner.source[scannerSourceLength - 1] == '\n'
+ && scanner.source[scannerSourceLength - 2] == '\r') {
formattedSource.append(options.lineSeparatorSequence);
increaseGlobalDelta(options.lineSeparatorSequence.length - 2);
} else if (scanner.source[scannerSourceLength - 1] == '\n') {
}
updateMappedPositions(scanner.startPosition);
}
-
- /**
+ /**
* Formats the input string.
*/
private void format() {
int previousCompilableToken = 0;
int indentationOffset = 0;
int newLinesInWhitespace = 0;
-
// number of new lines in the previous whitespace token
// (used to leave blank lines before comments)
int pendingNewLines = 0;
boolean inThrowsClause = false;
boolean inClassOrInterfaceHeader = false;
int dollarBraceCount = 0;
-
- // openBracketCount is used to count the number of open brackets not closed yet.
+ // openBracketCount is used to count the number of open brackets not closed
+ // yet.
int openBracketCount = 0;
int unarySignModifier = 0;
-
- // openParenthesis[0] is used to count the parenthesis not belonging to a condition
+ // openParenthesis[0] is used to count the parenthesis not belonging to a
+ // condition
// (eg foo();). parenthesis in for (...) are count elsewhere in the array.
int openParenthesisCount = 1;
int[] openParenthesis = new int[10];
-
- // tokenBeforeColon is used to know what token goes along with the current :
+ // tokenBeforeColon is used to know what token goes along with the current
+ // :
// it can be case or ?
int tokenBeforeColonCount = 0;
int[] tokenBeforeColon = new int[10];
-
constructionsCount = 0; // initializes the constructions count.
-
// contains DO if in a DO..WHILE statement, UNITIALIZED otherwise.
int nlicsToken = 0;
-
- // fix for 1FF17XY: LFCOM:ALL - Format problem on not matching } and else
+ // fix for 1FF17XY: LFCOM:ALL - Format problem on not matching } and else
boolean specialElse = false;
-
// OPTION (IndentationLevel): initial indentation level may be non-zero.
currentLineIndentationLevel += constructionsCount;
-
- // An InvalidInputException exception might cause the termination of this loop.
+ // An InvalidInputException exception might cause the termination of this
+ // loop.
try {
while (true) {
- // Get the next token. Catch invalid input and output it
+ // Get the next token. Catch invalid input and output it
// with minimal formatting, also catch end of input and
// exit the loop.
try {
if (Scanner.DEBUG) {
int currentEndPosition = scanner.getCurrentTokenEndPosition();
int currentStartPosition = scanner.getCurrentTokenStartPosition();
-
- System.out.print(currentStartPosition + "," + currentEndPosition + ": ");
+ System.out.print(currentStartPosition + "," + currentEndPosition
+ + ": ");
System.out.println(scanner.toStringAction(token));
}
-
// Patch for line comment
// See PR http://dev.eclipse.org/bugs/show_bug.cgi?id=23096
if (token == ITerminalSymbols.TokenNameCOMMENT_LINE) {
}
if (token == Scanner.TokenNameEOF)
break;
-
- /* ## MODIFYING the indentation level before generating new lines
- and indentation in the output string
- */
-
- // Removes all the indentations made by statements not followed by a block
- // except if the current token is ELSE, CATCH or if we are in a switch/case
+ /*
+ * ## MODIFYING the indentation level before generating new lines and
+ * indentation in the output string
+ */
+ // Removes all the indentations made by statements not followed by a
+ // block
+ // except if the current token is ELSE, CATCH or if we are in a
+ // switch/case
if (clearNonBlockIndents && (token != Scanner.TokenNameWHITESPACE)) {
switch (token) {
case TokenNameelse :
- if (constructionsCount > 0 && constructions[constructionsCount - 1] == TokenNameelse) {
+ if (constructionsCount > 0
+ && constructions[constructionsCount - 1] == TokenNameelse) {
pendingNewLines = 1;
specialElse = true;
}
indentationLevel += popInclusiveUntil(TokenNameif);
break;
- // case TokenNamecatch :
- // indentationLevel += popInclusiveUntil(TokenNamecatch);
- // break;
- // case TokenNamefinally :
- // indentationLevel += popInclusiveUntil(TokenNamecatch);
- // break;
+ // case TokenNamecatch :
+ // indentationLevel += popInclusiveUntil(TokenNamecatch);
+ // break;
+ // case TokenNamefinally :
+ // indentationLevel += popInclusiveUntil(TokenNamecatch);
+ // break;
case TokenNamewhile :
if (nlicsToken == TokenNamedo) {
indentationLevel += pop(TokenNamedo);
}
default :
indentationLevel += popExclusiveUntilBlockOrCase();
- // clear until a CASE, DEFAULT or BLOCK is encountered.
- // Thus, the indentationLevel is correctly cleared either
- // in a switch/case statement or in any other situation.
+ // clear until a CASE, DEFAULT or BLOCK is encountered.
+ // Thus, the indentationLevel is correctly cleared either
+ // in a switch/case statement or in any other situation.
}
clearNonBlockIndents = false;
}
// if (token == Scanner.TokenNamethrows) {
// inThrowsClause = true;
// }
- if ((token == Scanner.TokenNameclass // || token == Scanner.TokenNameinterface
- )
- && previousToken != Scanner.TokenNameDOT) {
+ if ((token == Scanner.TokenNameclass // || token ==
+ // Scanner.TokenNameinterface
+ ) && previousToken != Scanner.TokenNameDOT) {
inClassOrInterfaceHeader = true;
}
-
- /* ## APPEND newlines and indentations to the output string
- */
- // Do not add a new line between ELSE and IF, if the option elseIfOnSameLine is true.
+ /*
+ * ## APPEND newlines and indentations to the output string
+ */
+ // Do not add a new line between ELSE and IF, if the option
+ // elseIfOnSameLine is true.
// Fix for 1ETLWPZ: IVJCOM:ALL - incorrect "else if" formatting
// if (pendingNewlineAfterParen
// && previousCompilableToken == TokenNameelse
// Add a newline & indent to the formatted source string if
// a for/if-else/while statement was scanned and there is no block
// following it.
- pendingNewlineAfterParen =
- pendingNewlineAfterParen || (previousCompilableToken == TokenNameRPAREN && token == TokenNameLBRACE);
+ pendingNewlineAfterParen = pendingNewlineAfterParen
+ || (previousCompilableToken == TokenNameRPAREN && token == TokenNameLBRACE);
if (pendingNewlineAfterParen && token != Scanner.TokenNameWHITESPACE) {
pendingNewlineAfterParen = false;
-
// Do to add a newline & indent sequence if the current token is an
- // open brace or a period or if the current token is a semi-colon and the
+ // open brace or a period or if the current token is a semi-colon and
+ // the
// previous token is a close paren.
// add a new line if a parenthesis belonging to a for() statement
// has been closed and the current token is not an opening brace
if (token != TokenNameLBRACE
- && !isComment(token) // to avoid adding new line between else and a comment
- && token != TokenNameDOT
- && !(previousCompilableToken == TokenNameRPAREN && token == TokenNameSEMICOLON)) {
+ && !isComment(token)
+ // to avoid adding new line between else and a comment
+ && token != TokenNameDOT
+ && !(previousCompilableToken == TokenNameRPAREN && token == TokenNameSEMICOLON)) {
newLine(1);
currentLineIndentationLevel = indentationLevel;
pendingNewLines = 0;
pendingSpace = false;
} else {
- if (token == TokenNameLBRACE && options.newLineBeforeOpeningBraceMode) {
+ if (token == TokenNameLBRACE
+ && options.newLineBeforeOpeningBraceMode) {
newLine(1);
if (constructionsCount > 0
- && constructions[constructionsCount - 1] != BLOCK
- && constructions[constructionsCount - 1] != NONINDENT_BLOCK) {
+ && constructions[constructionsCount - 1] != BLOCK
+ && constructions[constructionsCount - 1] != NONINDENT_BLOCK) {
currentLineIndentationLevel = indentationLevel - 1;
} else {
currentLineIndentationLevel = indentationLevel;
}
}
}
- if (token == TokenNameLBRACE
- && options.newLineBeforeOpeningBraceMode
- && constructionsCount > 0
- && constructions[constructionsCount - 1] == TokenNamedo) {
+ if (token == TokenNameLBRACE && options.newLineBeforeOpeningBraceMode
+ && constructionsCount > 0
+ && constructions[constructionsCount - 1] == TokenNamedo) {
newLine(1);
currentLineIndentationLevel = indentationLevel - 1;
pendingNewLines = 0;
// Add pending new lines to the formatted source string.
// Note: pending new lines are not added if the current token
// is a single line comment or whitespace.
- // if the comment is between parenthesis, there is no blank line preservation
+ // if the comment is between parenthesis, there is no blank line
+ // preservation
// (if it's a one-line comment, a blank line is added after it).
if (((pendingNewLines > 0 && (!isComment(token)))
- || (newLinesInWhitespace > 0 && (openParenthesisCount <= 1 && isComment(token)))
- || (previousCompilableToken == TokenNameLBRACE && token == TokenNameRBRACE))
- && token != Scanner.TokenNameWHITESPACE) {
-
+ || (newLinesInWhitespace > 0 && (openParenthesisCount <= 1 && isComment(token))) || (previousCompilableToken == TokenNameLBRACE && token == TokenNameRBRACE))
+ && token != Scanner.TokenNameWHITESPACE) {
// Do not add newline & indent between an adjoining close brace and
- // close paren. Anonymous inner classes may use this form.
- boolean closeBraceAndCloseParen = previousToken == TokenNameRBRACE && token == TokenNameRPAREN;
-
+ // close paren. Anonymous inner classes may use this form.
+ boolean closeBraceAndCloseParen = previousToken == TokenNameRBRACE
+ && token == TokenNameRPAREN;
// OPTION (NewLineInCompoundStatement): do not add newline & indent
// between close brace and else, (do) while, catch, and finally if
// newlineInCompoundStatement is true.
- boolean nlicsOption =
- previousToken == TokenNameRBRACE
+ boolean nlicsOption = previousToken == TokenNameRBRACE
&& !options.newlineInControlStatementMode
&& (token == TokenNameelse || (token == TokenNamewhile && nlicsToken == TokenNamedo));
// || token == TokenNamecatch
// || token == TokenNamefinally);
-
- // Do not add a newline & indent between a close brace and semi-colon.
- boolean semiColonAndCloseBrace = previousToken == TokenNameRBRACE && token == TokenNameSEMICOLON;
-
- // Do not add a new line & indent between a multiline comment and a opening brace
- boolean commentAndOpenBrace = previousToken == Scanner.TokenNameCOMMENT_BLOCK && token == TokenNameLBRACE;
-
- // Do not add a newline & indent between a close brace and a colon (in array assignments, for example).
- boolean commaAndCloseBrace = previousToken == TokenNameRBRACE && token == TokenNameCOMMA;
-
+ // Do not add a newline & indent between a close brace and
+ // semi-colon.
+ boolean semiColonAndCloseBrace = previousToken == TokenNameRBRACE
+ && token == TokenNameSEMICOLON;
+ // Do not add a new line & indent between a multiline comment and a
+ // opening brace
+ boolean commentAndOpenBrace = previousToken == Scanner.TokenNameCOMMENT_BLOCK
+ && token == TokenNameLBRACE;
+ // Do not add a newline & indent between a close brace and a colon
+ // (in array assignments, for example).
+ boolean commaAndCloseBrace = previousToken == TokenNameRBRACE
+ && token == TokenNameCOMMA;
// Add a newline and indent, if appropriate.
if (specialElse
- || (!commentAndOpenBrace && !closeBraceAndCloseParen && !nlicsOption && !semiColonAndCloseBrace && !commaAndCloseBrace)) {
-
+ || (!commentAndOpenBrace && !closeBraceAndCloseParen
+ && !nlicsOption && !semiColonAndCloseBrace && !commaAndCloseBrace)) {
// if clearAllBlankLinesMode=false, leaves the blank lines
// inserted by the user
// if clearAllBlankLinesMode=true, removes all of then
// and insert only blank lines required by the formatting.
if (!options.clearAllBlankLinesMode) {
// (isComment(token))
- pendingNewLines = (pendingNewLines < newLinesInWhitespace) ? newLinesInWhitespace : pendingNewLines;
+ pendingNewLines = (pendingNewLines < newLinesInWhitespace)
+ ? newLinesInWhitespace
+ : pendingNewLines;
pendingNewLines = (pendingNewLines > 2) ? 2 : pendingNewLines;
}
- if (previousCompilableToken == TokenNameLBRACE && token == TokenNameRBRACE) {
+ if (previousCompilableToken == TokenNameLBRACE
+ && token == TokenNameRBRACE) {
containsOpenCloseBraces = true;
indentationLevelForOpenCloseBraces = currentLineIndentationLevel;
if (isComment(previousToken)) {
newLine(pendingNewLines);
} else {
- /* if (!(constructionsCount > 1
- && constructions[constructionsCount-1] == NONINDENT_BLOCK
- && (constructions[constructionsCount-2] == TokenNamefor
- || constructions[constructionsCount-2] == TokenNamewhile))) {*/
+ /*
+ * if (!(constructionsCount > 1 &&
+ * constructions[constructionsCount-1] == NONINDENT_BLOCK &&
+ * (constructions[constructionsCount-2] == TokenNamefor
+ */
if (options.newLineInEmptyBlockMode) {
if (inArrayAssignment) {
newLine(1); // array assigment with an empty block
// }
}
} else {
- // see PR 1FKKC3U: LFCOM:WINNT - Format problem with a comment before the ';'
- if (!((previousToken == Scanner.TokenNameCOMMENT_BLOCK || previousToken == Scanner.TokenNameCOMMENT_PHPDOC)
- && token == TokenNameSEMICOLON)) {
+ // see PR 1FKKC3U: LFCOM:WINNT - Format problem with a comment
+ // before the ';'
+ if (!((previousToken == Scanner.TokenNameCOMMENT_BLOCK || previousToken == Scanner.TokenNameCOMMENT_PHPDOC) && token == TokenNameSEMICOLON)) {
newLine(pendingNewLines);
}
}
if (((previousCompilableToken == TokenNameSEMICOLON)
- || (previousCompilableToken == TokenNameLBRACE)
- || (previousCompilableToken == TokenNameRBRACE)
- || (isComment(previousToken)))
- && (token == TokenNameRBRACE)) {
+ || (previousCompilableToken == TokenNameLBRACE)
+ || (previousCompilableToken == TokenNameRBRACE) || (isComment(previousToken)))
+ && (token == TokenNameRBRACE)) {
indentationOffset = -1;
indentationLevel += popExclusiveUntilBlock();
}
// PR 1FI5IPO
currentLineIndentationLevel++;
} else {
- currentLineIndentationLevel = indentationLevel + indentationOffset;
+ currentLineIndentationLevel = indentationLevel
+ + indentationOffset;
}
pendingSpace = false;
indentationOffset = 0;
pendingNewLines = 0;
newLinesInWhitespace = 0;
specialElse = false;
-
if (nlicsToken == TokenNamedo && token == TokenNamewhile) {
nlicsToken = 0;
}
}
switch (token) {
- case TokenNameDOLLAR_LBRACE :
- dollarBraceCount++;
- break;
+ // case TokenNameDOLLAR :
+ // dollarBraceCount++;
+ // break;
case TokenNameelse :
// case TokenNamefinally :
expectingOpenBrace = true;
case TokenNamecase :
case TokenNamedefault :
if (tokenBeforeColonCount == tokenBeforeColon.length) {
- System.arraycopy(
- tokenBeforeColon,
- 0,
- (tokenBeforeColon = new int[tokenBeforeColonCount * 2]),
- 0,
- tokenBeforeColonCount);
+ System.arraycopy(tokenBeforeColon, 0,
+ (tokenBeforeColon = new int[tokenBeforeColonCount * 2]), 0,
+ tokenBeforeColonCount);
}
tokenBeforeColon[tokenBeforeColonCount++] = TokenNamecase;
indentationLevel += pushControlStatement(TokenNamecase);
break;
case TokenNameQUESTION :
if (tokenBeforeColonCount == tokenBeforeColon.length) {
- System.arraycopy(
- tokenBeforeColon,
- 0,
- (tokenBeforeColon = new int[tokenBeforeColonCount * 2]),
- 0,
- tokenBeforeColonCount);
+ System.arraycopy(tokenBeforeColon, 0,
+ (tokenBeforeColon = new int[tokenBeforeColonCount * 2]), 0,
+ tokenBeforeColonCount);
}
tokenBeforeColon[tokenBeforeColonCount++] = token;
break;
case TokenNameif :
case TokenNamewhile :
if (openParenthesisCount == openParenthesis.length) {
- System.arraycopy(openParenthesis, 0, (openParenthesis = new int[openParenthesisCount * 2]), 0, openParenthesisCount);
+ System.arraycopy(openParenthesis, 0,
+ (openParenthesis = new int[openParenthesisCount * 2]), 0,
+ openParenthesisCount);
}
openParenthesis[openParenthesisCount++] = 0;
expectingOpenBrace = true;
-
indentationLevel += pushControlStatement(token);
break;
- // case TokenNametry :
- // pendingNewlineAfterParen = true;
- // case TokenNamecatch :
- // // several CATCH statements can be contiguous.
- // // a CATCH is encountered pop until first CATCH (if a CATCH follows a TRY it works the same way,
- // // as CATCH and TRY are the same token in the stack).
- // expectingOpenBrace = true;
- // indentationLevel += pushControlStatement(TokenNamecatch);
- // break;
-
+ // case TokenNametry :
+ // pendingNewlineAfterParen = true;
+ // case TokenNamecatch :
+ // // several CATCH statements can be contiguous.
+ // // a CATCH is encountered pop until first CATCH (if a CATCH
+ // follows a TRY it works the same way,
+ // // as CATCH and TRY are the same token in the stack).
+ // expectingOpenBrace = true;
+ // indentationLevel += pushControlStatement(TokenNamecatch);
+ // break;
case TokenNamedo :
expectingOpenBrace = true;
indentationLevel += pushControlStatement(token);
// compliment (eg: !), semi-colon, open brace, close brace,
// super, or this.
if (previousCompilableToken != TokenNameLBRACKET
- && previousToken != TokenNameIdentifier
- && previousToken != 0
- && previousToken != TokenNameNOT
- && previousToken != TokenNameLPAREN
- && previousToken != TokenNameTWIDDLE
- && previousToken != TokenNameSEMICOLON
- && previousToken != TokenNameLBRACE
- && previousToken != TokenNameRBRACE) {
+ && previousToken != TokenNameIdentifier && previousToken != 0
+ && previousToken != TokenNameNOT
+ && previousToken != TokenNameLPAREN
+ && previousToken != TokenNameTWIDDLE
+ && previousToken != TokenNameSEMICOLON
+ && previousToken != TokenNameLBRACE
+ && previousToken != TokenNameRBRACE) {
// && previousToken != TokenNamesuper
// && previousToken != TokenNamethis) {
space();
openParenthesis[openParenthesisCount - 1]++;
else
openParenthesis[0]++;
-
pendingSpace = false;
- //S }
+ //S }
break;
case TokenNameRPAREN :
-
// Decrease the parenthesis count
// if there is no more unclosed parenthesis,
- // a new line and indent may be append (depending on the next token).
- if ((openParenthesisCount > 1) && (openParenthesis[openParenthesisCount - 1] > 0)) {
+ // a new line and indent may be append (depending on the next
+ // token).
+ if ((openParenthesisCount > 1)
+ && (openParenthesis[openParenthesisCount - 1] > 0)) {
openParenthesis[openParenthesisCount - 1]--;
if (openParenthesis[openParenthesisCount - 1] <= 0) {
pendingNewlineAfterParen = true;
pendingSpace = false;
break;
case TokenNameLBRACE :
- if ((previousCompilableToken == TokenNameRBRACKET) || (previousCompilableToken == TokenNameEQUAL)) {
+ if (previousCompilableToken == TokenNameDOLLAR) {
+ dollarBraceCount++;
+ }
+ if ((previousCompilableToken == TokenNameRBRACKET)
+ || (previousCompilableToken == TokenNameEQUAL)) {
// if (previousCompilableToken == TokenNameRBRACKET) {
inArrayAssignment = true;
inAssignment = false;
} else {
pendingNewLines = 1;
indentationLevel += popInclusiveUntilBlock();
-
if (previousCompilableToken == TokenNameRPAREN) {
- // fix for 1FGDDV6: LFCOM:WIN98 - Weird splitting on message expression
+ // fix for 1FGDDV6: LFCOM:WIN98 - Weird splitting on message
+ // expression
currentLineBuffer.append(options.lineSeparatorSequence);
increaseLineDelta(options.lineSeparatorSequence.length);
}
if (constructionsCount > 0) {
switch (constructions[constructionsCount - 1]) {
case TokenNamefor :
- //indentationLevel += popExclusiveUntilBlock();
- //break;
+ //indentationLevel += popExclusiveUntilBlock();
+ //break;
case TokenNameswitch :
case TokenNameif :
case TokenNameelse :
- // case TokenNametry :
- // case TokenNamecatch :
- // case TokenNamefinally :
+ // case TokenNametry :
+ // case TokenNamecatch :
+ // case TokenNamefinally :
case TokenNamewhile :
case TokenNamedo :
// case TokenNamesynchronized :
break;
case TokenNameRBRACKET :
openBracketCount -= (openBracketCount > 0) ? 1 : 0;
- // if there is no left bracket to close, the right bracket is ignored.
+ // if there is no left bracket to close, the right bracket is
+ // ignored.
pendingSpace = false;
break;
case TokenNameCOMMA :
pendingSpace = false;
break;
case TokenNameSEMICOLON :
-
// Do not generate line terminators in the definition of
// the for statement.
- // if not in this case, jump a line and reduce indentation after the brace
- // if the block it closes belongs to a conditional statement (if, while, do...).
+ // if not in this case, jump a line and reduce indentation after
+ // the brace
+ // if the block it closes belongs to a conditional statement (if,
+ // while, do...).
if (openParenthesisCount <= 1) {
pendingNewLines = 1;
if (expectingOpenBrace) {
break;
case TokenNamePLUS_PLUS :
case TokenNameMINUS_MINUS :
-
// Do not put a space between a post-increment/decrement
// and the identifier being modified.
- if (previousToken == TokenNameIdentifier || previousToken == TokenNameRBRACKET) {
+ if (previousToken == TokenNameIdentifier
+ || previousToken == TokenNameRBRACKET) {
pendingSpace = false;
}
break;
- case TokenNamePLUS : // previously ADDITION
+ case TokenNamePLUS :
+ // previously ADDITION
case TokenNameMINUS :
-
// Handle the unary operators plus and minus via a flag
if (!isLiteralToken(previousToken)
- && previousToken != TokenNameIdentifier
- && previousToken != TokenNameRPAREN
- && previousToken != TokenNameRBRACKET) {
+ && previousToken != TokenNameIdentifier
+ && previousToken != TokenNameRPAREN
+ && previousToken != TokenNameRBRACKET) {
unarySignModifier = 1;
}
break;
pendingNewLines = 1;
break;
case Scanner.TokenNameWHITESPACE :
-
// Count the number of line terminators in the whitespace so
// line spacing can be preserved near comments.
char[] source = scanner.source;
}
increaseLineDelta(scanner.startPosition - scanner.currentPosition);
break;
- // case TokenNameHTML :
- // // Add the next token to the formatted source string.
- // // outputCurrentToken(token);
- // int startPosition = scanner.startPosition;
- // flushBuffer();
- // for (int i = startPosition, max = scanner.currentPosition; i < max; i++) {
- // char currentCharacter = scanner.source[i];
- // updateMappedPositions(i);
- // currentLineBuffer.append(currentCharacter);
- // }
- // break;
+ // case TokenNameHTML :
+ // // Add the next token to the formatted source string.
+ // // outputCurrentToken(token);
+ // int startPosition = scanner.startPosition;
+ // flushBuffer();
+ // for (int i = startPosition, max = scanner.currentPosition; i <
+ // max; i++) {
+ // char currentCharacter = scanner.source[i];
+ // updateMappedPositions(i);
+ // currentLineBuffer.append(currentCharacter);
+ // }
+ // break;
default :
if ((token == TokenNameIdentifier) || isLiteralToken(token)) {
// || token == TokenNamesuper
// || token == TokenNamethis) {
-
// Do not put a space between a unary operator
// (eg: ++, --, +, -) and the identifier being modified.
if (previousToken == TokenNamePLUS_PLUS
- || previousToken == TokenNameMINUS_MINUS
- || (previousToken == TokenNameMINUS_GREATER &&
- options.compactDereferencingMode) // ->
- || (previousToken == TokenNamePLUS && unarySignModifier > 0)
- || (previousToken == TokenNameMINUS && unarySignModifier > 0)) {
+ || previousToken == TokenNameMINUS_MINUS
+ || (previousToken == TokenNameMINUS_GREATER && options.compactDereferencingMode) // ->
+ || (previousToken == TokenNamePLUS && unarySignModifier > 0)
+ || (previousToken == TokenNameMINUS && unarySignModifier > 0)) {
pendingSpace = false;
}
unarySignModifier = 0;
}
// Do not output whitespace tokens.
if (token != Scanner.TokenNameWHITESPACE) {
-
- /* Add pending space to the formatted source string.
- Do not output a space under the following circumstances:
- 1) this is the first pass
- 2) previous token is an open paren
- 3) previous token is a period
- 4) previous token is the logical compliment (eg: !)
- 5) previous token is the bitwise compliment (eg: ~)
- 6) previous token is the open bracket (eg: [)
- 7) in an assignment statement, if the previous token is an
- open brace or the current token is a close brace
- 8) previous token is a single line comment
- 9) current token is a '->'
- */
- if (token == TokenNameMINUS_GREATER &&
- options.compactDereferencingMode) pendingSpace = false;
-
- boolean openAndCloseBrace = previousCompilableToken == TokenNameLBRACE && token == TokenNameRBRACE;
-
+ /*
+ * Add pending space to the formatted source string. Do not output a
+ * space under the following circumstances: 1) this is the first pass 2)
+ * previous token is an open paren 3) previous token is a period 4)
+ * previous token is the logical compliment (eg: !) 5) previous token
+ * is the bitwise compliment (eg: ~) 6) previous token is the open
+ * bracket (eg: [) 7) in an assignment statement, if the previous
+ * token is an open brace or the current token is a close brace 8)
+ * previous token is a single line comment 9) current token is a '->'
+ */
+ if (token == TokenNameMINUS_GREATER
+ && options.compactDereferencingMode)
+ pendingSpace = false;
+ boolean openAndCloseBrace = previousCompilableToken == TokenNameLBRACE
+ && token == TokenNameRBRACE;
if (pendingSpace
- && insertSpaceAfter(previousToken)
- && !(inAssignment && (previousToken == TokenNameLBRACE || token == TokenNameRBRACE))
- && previousToken != Scanner.TokenNameCOMMENT_LINE) {
- if ((!(options.compactAssignmentMode && token == TokenNameEQUAL)) && !openAndCloseBrace)
+ && insertSpaceAfter(previousToken)
+ && !(inAssignment && (previousToken == TokenNameLBRACE || token == TokenNameRBRACE))
+ && previousToken != Scanner.TokenNameCOMMENT_LINE) {
+ if ((!(options.compactAssignmentMode && token == TokenNameEQUAL))
+ && !openAndCloseBrace)
space();
}
// Add the next token to the formatted source string.
outputCurrentToken(token);
- if (token == Scanner.TokenNameCOMMENT_LINE && openParenthesisCount > 1) {
+ if (token == Scanner.TokenNameCOMMENT_LINE
+ && openParenthesisCount > 1) {
pendingNewLines = 0;
currentLineBuffer.append(options.lineSeparatorSequence);
increaseLineDelta(options.lineSeparatorSequence.length);
if (token != Scanner.TokenNameWHITESPACE) {
previousToken = token;
if (token != Scanner.TokenNameCOMMENT_BLOCK
- && token != Scanner.TokenNameCOMMENT_LINE
- && token != Scanner.TokenNameCOMMENT_PHPDOC) {
+ && token != Scanner.TokenNameCOMMENT_LINE
+ && token != Scanner.TokenNameCOMMENT_PHPDOC) {
previousCompilableToken = token;
}
}
// dump the last token of the source in the formatted output.
}
}
-
- /**
- * Formats the char array <code>sourceString</code>,
- * and returns a string containing the formatted version.
+ /**
+ * Formats the char array <code>sourceString</code>, and returns a string
+ * containing the formatted version.
+ *
* @return the formatted ouput.
*/
public String formatSourceString(String sourceString) {
format();
return formattedSource.toString();
}
-
- /**
- * Formats the char array <code>sourceString</code>,
- * and returns a string containing the formatted version.
- * @param string the string to format
- * @param indentationLevel the initial indentation level
+ /**
+ * Formats the char array <code>sourceString</code>, and returns a string
+ * containing the formatted version.
+ *
+ * @param string
+ * the string to format
+ * @param indentationLevel
+ * the initial indentation level
* @return the formatted ouput.
*/
public String format(String string, int indentationLevel) {
return format(string, indentationLevel, (int[]) null);
}
-
- /**
- * Formats the char array <code>sourceString</code>,
- * and returns a string containing the formatted version.
- * The positions array is modified to contain the mapped positions.
- * @param string the string to format
- * @param indentationLevel the initial indentation level
- * @param positions the array of positions to map
+ /**
+ * Formats the char array <code>sourceString</code>, and returns a string
+ * containing the formatted version. The positions array is modified to
+ * contain the mapped positions.
+ *
+ * @param string
+ * the string to format
+ * @param indentationLevel
+ * the initial indentation level
+ * @param positions
+ * the array of positions to map
* @return the formatted ouput.
*/
public String format(String string, int indentationLevel, int[] positions) {
return this.format(string, indentationLevel, positions, null);
}
-
- public String format(String string, int indentationLevel, int[] positions, String lineSeparator) {
+ public String format(String string, int indentationLevel, int[] positions,
+ String lineSeparator) {
if (lineSeparator != null) {
this.options.setLineSeparator(lineSeparator);
}
return this.formatSourceString(string);
}
}
- /**
- * Formats the char array <code>sourceString</code>,
- * and returns a string containing the formatted version. The initial indentation level is 0.
- * @param string the string to format
+ /**
+ * Formats the char array <code>sourceString</code>, and returns a string
+ * containing the formatted version. The initial indentation level is 0.
+ *
+ * @param string
+ * the string to format
* @return the formatted ouput.
*/
public String format(String string) {
return this.format(string, 0, (int[]) null);
}
-
- /**
- * Formats a given source string, starting indenting it at a particular
- * depth and using the given options
+ /**
+ * Formats a given source string, starting indenting it at a particular depth
+ * and using the given options
*
* @deprecated backport 1.0 internal functionality
*/
- public static String format(String sourceString, int initialIndentationLevel, ConfigurableOption[] options) {
+ public static String format(String sourceString, int initialIndentationLevel,
+ ConfigurableOption[] options) {
CodeFormatter formatter = new CodeFormatter(options);
formatter.setInitialIndentationLevel(initialIndentationLevel);
return formatter.formatSourceString(sourceString);
}
-
/**
- * Returns the number of characters and tab char between the beginning of the line
- * and the beginning of the comment.
+ * Returns the number of characters and tab char between the beginning of the
+ * line and the beginning of the comment.
*/
private int getCurrentCommentOffset() {
int linePtr = scanner.linePtr;
int beginningOfLine = scanner.lineEnds[linePtr];
int currentStartPosition = scanner.startPosition;
char[] source = scanner.source;
-
// find the position of the beginning of the line containing the comment
while (beginningOfLine > currentStartPosition) {
if (linePtr > 0) {
}
return offset;
}
-
/**
- * Returns an array of descriptions for the configurable options.
- * The descriptions may be changed and passed back to a different
- * compiler.
+ * Returns an array of descriptions for the configurable options. The
+ * descriptions may be changed and passed back to a different compiler.
*
* @deprecated backport 1.0 internal functionality
*/
public static ConfigurableOption[] getDefaultOptions(Locale locale) {
String componentName = CodeFormatter.class.getName();
FormatterOptions options = new FormatterOptions();
- return new ConfigurableOption[] { new ConfigurableOption(componentName, "newline.openingBrace", locale, options.newLineBeforeOpeningBraceMode ? 0 : 1), //$NON-NLS-1$
- new ConfigurableOption(componentName, "newline.controlStatement", locale, options.newlineInControlStatementMode ? 0 : 1), //$NON-NLS-1$
- new ConfigurableOption(componentName, "newline.clearAll", locale, options.clearAllBlankLinesMode ? 0 : 1), //$NON-NLS-1$
- // new ConfigurableOption(componentName, "newline.elseIf", locale, options.compactElseIfMode ? 0 : 1), //$NON-NLS-1$
- new ConfigurableOption(componentName, "newline.emptyBlock", locale, options.newLineInEmptyBlockMode ? 0 : 1), //$NON-NLS-1$
- new ConfigurableOption(componentName, "line.split", locale, options.maxLineLength), //$NON-NLS-1$
- new ConfigurableOption(componentName, "style.compactAssignment", locale, options.compactAssignmentMode ? 0 : 1), //$NON-NLS-1$
- new ConfigurableOption(componentName, "tabulation.char", locale, options.indentWithTab ? 0 : 1), //$NON-NLS-1$
- new ConfigurableOption(componentName, "tabulation.size", locale, options.tabSize) //$NON-NLS-1$
+ return new ConfigurableOption[]{
+ new ConfigurableOption(componentName, "newline.openingBrace", locale,
+ options.newLineBeforeOpeningBraceMode ? 0 : 1),
+ //$NON-NLS-1$
+ new ConfigurableOption(componentName, "newline.controlStatement",
+ locale, options.newlineInControlStatementMode ? 0 : 1),
+ //$NON-NLS-1$
+ new ConfigurableOption(componentName, "newline.clearAll", locale,
+ options.clearAllBlankLinesMode ? 0 : 1),
+ //$NON-NLS-1$
+ // new ConfigurableOption(componentName, "newline.elseIf", locale,
+ // options.compactElseIfMode ? 0 : 1), //$NON-NLS-1$
+ new ConfigurableOption(componentName, "newline.emptyBlock", locale,
+ options.newLineInEmptyBlockMode ? 0 : 1),
+ //$NON-NLS-1$
+ new ConfigurableOption(componentName, "line.split", locale,
+ options.maxLineLength),
+ //$NON-NLS-1$
+ new ConfigurableOption(componentName, "style.compactAssignment",
+ locale, options.compactAssignmentMode ? 0 : 1),
+ //$NON-NLS-1$
+ new ConfigurableOption(componentName, "tabulation.char", locale,
+ options.indentWithTab ? 0 : 1),
+ //$NON-NLS-1$
+ new ConfigurableOption(componentName, "tabulation.size", locale,
+ options.tabSize) //$NON-NLS-1$
};
}
-
/**
- * Returns the array of mapped positions.
- * Returns null is no positions have been set.
+ * Returns the array of mapped positions. Returns null is no positions have
+ * been set.
+ *
* @return int[]
* @deprecated There is no need to retrieve the mapped positions anymore.
*/
public int[] getMappedPositions() {
return mappedPositions;
}
-
/**
- * Returns the priority of the token given as argument<br>
+ * Returns the priority of the token given as argument <br>
* The most prioritary the token is, the smallest the return value is.
+ *
* @return the priority of <code>token</code>
- * @param token the token of which the priority is requested
+ * @param token
+ * the token of which the priority is requested
*/
private static int getTokenPriority(int token) {
switch (token) {
// case TokenNameimplements :
// case TokenNamethrows :
return 10;
- case TokenNameSEMICOLON : // ;
+ case TokenNameSEMICOLON :
+ // ;
return 20;
- case TokenNameCOMMA : // ,
+ case TokenNameCOMMA :
+ // ,
return 25;
- case TokenNameEQUAL : // =
+ case TokenNameEQUAL :
+ // =
return 30;
- case TokenNameAND_AND : // &&
- case TokenNameOR_OR : // ||
+ case TokenNameAND_AND :
+ // &&
+ case TokenNameOR_OR :
+ // ||
return 40;
- case TokenNameQUESTION : // ?
- case TokenNameCOLON : // :
+ case TokenNameQUESTION :
+ // ?
+ case TokenNameCOLON :
+ // :
return 50; // it's better cutting on ?: than on ;
- case TokenNameEQUAL_EQUAL : // ==
- case TokenNameEQUAL_EQUAL_EQUAL : // ===
- case TokenNameNOT_EQUAL : // !=
- case TokenNameNOT_EQUAL_EQUAL : // !=
+ case TokenNameEQUAL_EQUAL :
+ // ==
+ case TokenNameEQUAL_EQUAL_EQUAL :
+ // ===
+ case TokenNameNOT_EQUAL :
+ // !=
+ case TokenNameNOT_EQUAL_EQUAL :
+ // !=
return 60;
- case TokenNameLESS : // <
- case TokenNameLESS_EQUAL : // <=
- case TokenNameGREATER : // >
- case TokenNameGREATER_EQUAL : // >=
+ case TokenNameLESS :
+ // <
+ case TokenNameLESS_EQUAL :
+ // <=
+ case TokenNameGREATER :
+ // >
+ case TokenNameGREATER_EQUAL :
+ // >=
// case TokenNameinstanceof : // instanceof
return 70;
- case TokenNamePLUS : // +
- case TokenNameMINUS : // -
+ case TokenNamePLUS :
+ // +
+ case TokenNameMINUS :
+ // -
return 80;
- case TokenNameMULTIPLY : // *
- case TokenNameDIVIDE : // /
- case TokenNameREMAINDER : // %
+ case TokenNameMULTIPLY :
+ // *
+ case TokenNameDIVIDE :
+ // /
+ case TokenNameREMAINDER :
+ // %
return 90;
- case TokenNameLEFT_SHIFT : // <<
- case TokenNameRIGHT_SHIFT : // >>
- // case TokenNameUNSIGNED_RIGHT_SHIFT : // >>>
+ case TokenNameLEFT_SHIFT :
+ // <<
+ case TokenNameRIGHT_SHIFT :
+ // >>
+ // case TokenNameUNSIGNED_RIGHT_SHIFT : // >>>
return 100;
- case TokenNameAND : // &
- case TokenNameOR : // |
- case TokenNameXOR : // ^
+ case TokenNameAND :
+ // &
+ case TokenNameOR :
+ // |
+ case TokenNameXOR :
+ // ^
return 110;
- case TokenNameMULTIPLY_EQUAL : // *=
- case TokenNameDIVIDE_EQUAL : // /=
- case TokenNameREMAINDER_EQUAL : // %=
- case TokenNamePLUS_EQUAL : // +=
- case TokenNameMINUS_EQUAL : // -=
- case TokenNameLEFT_SHIFT_EQUAL : // <<=
- case TokenNameRIGHT_SHIFT_EQUAL : // >>=
- // case TokenNameUNSIGNED_RIGHT_SHIFT_EQUAL : // >>>=
- case TokenNameAND_EQUAL : // &=
- case TokenNameXOR_EQUAL : // ^=
- case TokenNameOR_EQUAL : // |=
+ case TokenNameMULTIPLY_EQUAL :
+ // *=
+ case TokenNameDIVIDE_EQUAL :
+ // /=
+ case TokenNameREMAINDER_EQUAL :
+ // %=
+ case TokenNamePLUS_EQUAL :
+ // +=
+ case TokenNameMINUS_EQUAL :
+ // -=
+ case TokenNameLEFT_SHIFT_EQUAL :
+ // <<=
+ case TokenNameRIGHT_SHIFT_EQUAL :
+ // >>=
+ // case TokenNameUNSIGNED_RIGHT_SHIFT_EQUAL : // >>>=
+ case TokenNameAND_EQUAL :
+ // &=
+ case TokenNameXOR_EQUAL :
+ // ^=
+ case TokenNameOR_EQUAL :
+ // |=
return 120;
- case TokenNameDOT : // .
+ case TokenNameDOT :
+ // .
return 130;
default :
return Integer.MAX_VALUE;
}
}
-
/**
- * Handles the exception raised when an invalid token is encountered.
- * Returns true if the exception has been handled, false otherwise.
+ * Handles the exception raised when an invalid token is encountered. Returns
+ * true if the exception has been handled, false otherwise.
*/
private boolean handleInvalidToken(Exception e) {
if (e.getMessage().equals(Scanner.INVALID_CHARACTER_CONSTANT)
- || e.getMessage().equals(Scanner.INVALID_CHAR_IN_STRING)
- || e.getMessage().equals(Scanner.INVALID_ESCAPE)) {
+ || e.getMessage().equals(Scanner.INVALID_CHAR_IN_STRING)
+ || e.getMessage().equals(Scanner.INVALID_ESCAPE)) {
return true;
}
return false;
}
-
private final void increaseGlobalDelta(int offset) {
globalDelta += offset;
}
-
private final void increaseLineDelta(int offset) {
lineDelta += offset;
}
-
private final void increaseSplitDelta(int offset) {
splitDelta += offset;
}
-
/**
* Returns true if a space has to be inserted after <code>operator</code>
* false otherwise.
case TokenNameNOT :
case TokenNameTWIDDLE :
case TokenNameDOT :
- case 0 : // no token
+ case 0 :
+ // no token
case TokenNameLBRACKET :
case Scanner.TokenNameCOMMENT_LINE :
return false;
return true;
}
}
-
/**
* Returns true if a space has to be inserted before <code>operator</code>
- * false otherwise.<br>
- * Cannot be static as it uses the code formatter options
- * (to know if the compact assignment mode is on).
+ * false otherwise. <br>
+ * Cannot be static as it uses the code formatter options (to know if the
+ * compact assignment mode is on).
*/
private boolean insertSpaceBefore(int token) {
switch (token) {
return false;
}
}
-
private static boolean isComment(int token) {
- boolean result =
- token == Scanner.TokenNameCOMMENT_BLOCK || token == Scanner.TokenNameCOMMENT_LINE || token == Scanner.TokenNameCOMMENT_PHPDOC;
+ boolean result = token == Scanner.TokenNameCOMMENT_BLOCK
+ || token == Scanner.TokenNameCOMMENT_LINE
+ || token == Scanner.TokenNameCOMMENT_PHPDOC;
return result;
}
-
private static boolean isLiteralToken(int token) {
boolean result = token == TokenNameIntegerLiteral
- // || token == TokenNameLongLiteral
- // || token == TokenNameFloatingPointLiteral
- || token == TokenNameDoubleLiteral
- // || token == TokenNameCharacterLiteral
- || token == TokenNameStringLiteral;
+ // || token == TokenNameLongLiteral
+ // || token == TokenNameFloatingPointLiteral
+ || token == TokenNameDoubleLiteral
+ // || token == TokenNameCharacterLiteral
+ || token == TokenNameStringLiteral;
return result;
}
-
/**
* If the length of <code>oneLineBuffer</code> exceeds <code>maxLineLength</code>,
* it is split and the result is dumped in <code>formattedSource</code>
- * @param newLineCount the number of new lines to append
+ *
+ * @param newLineCount
+ * the number of new lines to append
*/
private void newLine(int newLineCount) {
-
// format current line
splitDelta = 0;
beginningOfLineIndex = formattedSource.length();
String currentLine = currentLineBuffer.toString();
if (containsOpenCloseBraces) {
containsOpenCloseBraces = false;
- outputLine(currentLine, false, indentationLevelForOpenCloseBraces, 0, -1, null, 0);
+ outputLine(currentLine, false, indentationLevelForOpenCloseBraces, 0, -1,
+ null, 0);
indentationLevelForOpenCloseBraces = currentLineIndentationLevel;
} else {
- outputLine(currentLine, false, currentLineIndentationLevel, 0, -1, null, 0);
+ outputLine(currentLine, false, currentLineIndentationLevel, 0, -1, null,
+ 0);
}
// dump line break(s)
for (int i = 0; i < newLineCount; i++) {
}
// reset formatter for next line
int currentLength = currentLine.length();
- currentLineBuffer = new StringBuffer(currentLength > maxLineSize ? maxLineSize = currentLength : maxLineSize);
-
+ currentLineBuffer = new StringBuffer(currentLength > maxLineSize
+ ? maxLineSize = currentLength
+ : maxLineSize);
increaseGlobalDelta(splitDelta);
increaseGlobalDelta(lineDelta);
lineDelta = 0;
currentLineIndentationLevel = initialIndentationLevel;
}
-
private String operatorString(int operator) {
switch (operator) {
case TokenNameextends :
return "extends"; //$NON-NLS-1$
-
- // case TokenNameimplements :
- // return "implements"; //$NON-NLS-1$
- //
- // case TokenNamethrows :
- // return "throws"; //$NON-NLS-1$
-
- case TokenNameSEMICOLON : // ;
+ // case TokenNameimplements :
+ // return "implements"; //$NON-NLS-1$
+ //
+ // case TokenNamethrows :
+ // return "throws"; //$NON-NLS-1$
+ case TokenNameSEMICOLON :
+ // ;
return ";"; //$NON-NLS-1$
-
- case TokenNameCOMMA : // ,
+ case TokenNameCOMMA :
+ // ,
return ","; //$NON-NLS-1$
-
- case TokenNameEQUAL : // =
+ case TokenNameEQUAL :
+ // =
return "="; //$NON-NLS-1$
-
- case TokenNameAND_AND : // && (15.22)
+ case TokenNameAND_AND :
+ // && (15.22)
return "&&"; //$NON-NLS-1$
-
- case TokenNameOR_OR : // || (15.23)
+ case TokenNameOR_OR :
+ // || (15.23)
return "||"; //$NON-NLS-1$
-
- case TokenNameQUESTION : // ? (15.24)
+ case TokenNameQUESTION :
+ // ? (15.24)
return "?"; //$NON-NLS-1$
-
- case TokenNameCOLON : // : (15.24)
+ case TokenNameCOLON :
+ // : (15.24)
return ":"; //$NON-NLS-1$
-
- case TokenNamePAAMAYIM_NEKUDOTAYIM : // : (15.24)
+ case TokenNamePAAMAYIM_NEKUDOTAYIM :
+ // : (15.24)
return "::"; //$NON-NLS-1$
-
- case TokenNameEQUAL_EQUAL : // == (15.20, 15.20.1, 15.20.2, 15.20.3)
+ case TokenNameEQUAL_EQUAL :
+ // == (15.20, 15.20.1, 15.20.2, 15.20.3)
return "=="; //$NON-NLS-1$
-
- case TokenNameEQUAL_EQUAL_EQUAL : // == (15.20, 15.20.1, 15.20.2, 15.20.3)
+ case TokenNameEQUAL_EQUAL_EQUAL :
+ // == (15.20, 15.20.1, 15.20.2, 15.20.3)
return "==="; //$NON-NLS-1$
-
- case TokenNameEQUAL_GREATER : // -= (15.25.2)
+ case TokenNameEQUAL_GREATER :
+ // -= (15.25.2)
return "=>"; //$NON-NLS-1$
-
- case TokenNameNOT_EQUAL : // != (15.20, 15.20.1, 15.20.2, 15.20.3)
+ case TokenNameNOT_EQUAL :
+ // != (15.20, 15.20.1, 15.20.2, 15.20.3)
return "!="; //$NON-NLS-1$
-
- case TokenNameNOT_EQUAL_EQUAL : // != (15.20, 15.20.1, 15.20.2, 15.20.3)
- return "!=="; //$NON-NLS-1$
-
- case TokenNameLESS : // < (15.19.1)
+ case TokenNameNOT_EQUAL_EQUAL :
+ // != (15.20, 15.20.1, 15.20.2, 15.20.3)
+ return "!=="; //$NON-NLS-1$
+ case TokenNameLESS :
+ // < (15.19.1)
return "<"; //$NON-NLS-1$
-
- case TokenNameLESS_EQUAL : // <= (15.19.1)
+ case TokenNameLESS_EQUAL :
+ // <= (15.19.1)
return "<="; //$NON-NLS-1$
-
- case TokenNameGREATER : // > (15.19.1)
+ case TokenNameGREATER :
+ // > (15.19.1)
return ">"; //$NON-NLS-1$
-
- case TokenNameGREATER_EQUAL : // >= (15.19.1)
+ case TokenNameGREATER_EQUAL :
+ // >= (15.19.1)
return ">="; //$NON-NLS-1$
-
- // case TokenNameinstanceof : // instanceof
- // return "instanceof"; //$NON-NLS-1$
-
- case TokenNamePLUS : // + (15.17, 15.17.2)
+ // case TokenNameinstanceof : // instanceof
+ // return "instanceof"; //$NON-NLS-1$
+ case TokenNamePLUS :
+ // + (15.17, 15.17.2)
return "+"; //$NON-NLS-1$
-
- case TokenNameMINUS : // - (15.17.2)
+ case TokenNameMINUS :
+ // - (15.17.2)
return "-"; //$NON-NLS-1$
-
- case TokenNameMULTIPLY : // * (15.16.1)
+ case TokenNameMULTIPLY :
+ // * (15.16.1)
return "*"; //$NON-NLS-1$
-
- case TokenNameDIVIDE : // / (15.16.2)
+ case TokenNameDIVIDE :
+ // / (15.16.2)
return "/"; //$NON-NLS-1$
-
- case TokenNameREMAINDER : // % (15.16.3)
+ case TokenNameREMAINDER :
+ // % (15.16.3)
return "%"; //$NON-NLS-1$
-
- case TokenNameLEFT_SHIFT : // << (15.18)
+ case TokenNameLEFT_SHIFT :
+ // << (15.18)
return "<<"; //$NON-NLS-1$
-
- case TokenNameRIGHT_SHIFT : // >> (15.18)
+ case TokenNameRIGHT_SHIFT :
+ // >> (15.18)
return ">>"; //$NON-NLS-1$
-
- // case TokenNameUNSIGNED_RIGHT_SHIFT : // >>> (15.18)
- // return ">>>"; //$NON-NLS-1$
-
- case TokenNameAND : // & (15.21, 15.21.1, 15.21.2)
+ // case TokenNameUNSIGNED_RIGHT_SHIFT : // >>> (15.18)
+ // return ">>>"; //$NON-NLS-1$
+ case TokenNameAND :
+ // & (15.21, 15.21.1, 15.21.2)
return "&"; //$NON-NLS-1$
-
- case TokenNameOR : // | (15.21, 15.21.1, 15.21.2)
+ case TokenNameOR :
+ // | (15.21, 15.21.1, 15.21.2)
return "|"; //$NON-NLS-1$
-
- case TokenNameXOR : // ^ (15.21, 15.21.1, 15.21.2)
+ case TokenNameXOR :
+ // ^ (15.21, 15.21.1, 15.21.2)
return "^"; //$NON-NLS-1$
-
- case TokenNameMULTIPLY_EQUAL : // *= (15.25.2)
+ case TokenNameMULTIPLY_EQUAL :
+ // *= (15.25.2)
return "*="; //$NON-NLS-1$
-
- case TokenNameDIVIDE_EQUAL : // /= (15.25.2)
+ case TokenNameDIVIDE_EQUAL :
+ // /= (15.25.2)
return "/="; //$NON-NLS-1$
-
- case TokenNameREMAINDER_EQUAL : // %= (15.25.2)
+ case TokenNameREMAINDER_EQUAL :
+ // %= (15.25.2)
return "%="; //$NON-NLS-1$
-
- case TokenNamePLUS_EQUAL : // += (15.25.2)
+ case TokenNamePLUS_EQUAL :
+ // += (15.25.2)
return "+="; //$NON-NLS-1$
-
- case TokenNameMINUS_EQUAL : // -= (15.25.2)
+ case TokenNameMINUS_EQUAL :
+ // -= (15.25.2)
return "-="; //$NON-NLS-1$
-
- case TokenNameMINUS_GREATER : // -= (15.25.2)
+ case TokenNameMINUS_GREATER :
+ // -= (15.25.2)
return "->"; //$NON-NLS-1$
-
- case TokenNameLEFT_SHIFT_EQUAL : // <<= (15.25.2)
+ case TokenNameLEFT_SHIFT_EQUAL :
+ // <<= (15.25.2)
return "<<="; //$NON-NLS-1$
-
- case TokenNameRIGHT_SHIFT_EQUAL : // >>= (15.25.2)
+ case TokenNameRIGHT_SHIFT_EQUAL :
+ // >>= (15.25.2)
return ">>="; //$NON-NLS-1$
-
- // case TokenNameUNSIGNED_RIGHT_SHIFT_EQUAL : // >>>= (15.25.2)
- // return ">>>="; //$NON-NLS-1$
-
- case TokenNameAND_EQUAL : // &= (15.25.2)
+ // case TokenNameUNSIGNED_RIGHT_SHIFT_EQUAL : // >>>= (15.25.2)
+ // return ">>>="; //$NON-NLS-1$
+ case TokenNameAND_EQUAL :
+ // &= (15.25.2)
return "&="; //$NON-NLS-1$
-
- case TokenNameXOR_EQUAL : // ^= (15.25.2)
+ case TokenNameXOR_EQUAL :
+ // ^= (15.25.2)
return "^="; //$NON-NLS-1$
-
- case TokenNameOR_EQUAL : // |= (15.25.2)
+ case TokenNameOR_EQUAL :
+ // |= (15.25.2)
return "|="; //$NON-NLS-1$
-
- case TokenNameDOT : // .
+ case TokenNameDOT :
+ // .
return "."; //$NON-NLS-1$
-
default :
return ""; //$NON-NLS-1$
}
}
-
- /**
- * Appends <code>stringToOutput</code> to the formatted output.<br>
+ /**
+ * Appends <code>stringToOutput</code> to the formatted output. <br>
* If it contains \n, append a LINE_SEPARATOR and indent after it.
*/
private void output(String stringToOutput) {
}
}
}
-
- /**
- * Appends <code>token</code> to the formatted output.<br>
- * If it contains <code>\n</code>, append a LINE_SEPARATOR and indent after it.
+ /**
+ * Appends <code>token</code> to the formatted output. <br>
+ * If it contains <code>\n</code>, append a LINE_SEPARATOR and indent
+ * after it.
*/
private void outputCurrentToken(int token) {
char[] source = scanner.source;
int startPosition = scanner.startPosition;
-
switch (token) {
case Scanner.TokenNameCOMMENT_PHPDOC :
case Scanner.TokenNameCOMMENT_BLOCK :
endOfLine = true;
}
if (endOfLine) {
- // we remove a maximum of currentCommentOffset characters (tabs are converted to space numbers).
+ // we remove a maximum of currentCommentOffset characters (tabs
+ // are converted to space numbers).
beginningOfLineSpaces += options.tabSize;
if (beginningOfLineSpaces > currentCommentOffset) {
currentLineBuffer.append(currentCharacter);
endOfLine = true;
}
if (endOfLine) {
- // we remove a maximum of currentCommentOffset characters (tabs are converted to space numbers).
+ // we remove a maximum of currentCommentOffset characters (tabs
+ // are converted to space numbers).
beginningOfLineSpaces++;
if (beginningOfLineSpaces > currentCommentOffset) {
currentLineBuffer.append(currentCharacter);
}
}
}
-
/**
* Outputs <code>currentString</code>:<br>
- * <ul><li>If its length is < maxLineLength, output
- * <li>Otherwise it is split.</ul>
- * @param currentString string to output
- * @param preIndented whether the string to output was pre-indented
- * @param depth number of indentation to put in front of <code>currentString</code>
- * @param operator value of the operator belonging to <code>currentString</code>.
+ * <ul>
+ * <li>If its length is < maxLineLength, output
+ * <li>Otherwise it is split.
+ * </ul>
+ *
+ * @param currentString
+ * string to output
+ * @param preIndented
+ * whether the string to output was pre-indented
+ * @param depth
+ * number of indentation to put in front of <code>currentString</code>
+ * @param operator
+ * value of the operator belonging to <code>currentString</code>.
*/
- private void outputLine(
- String currentString,
- boolean preIndented,
- int depth,
- int operator,
- int substringIndex,
- int[] startSubstringIndexes,
- int offsetInGlobalLine) {
-
+ private void outputLine(String currentString, boolean preIndented, int depth,
+ int operator, int substringIndex, int[] startSubstringIndexes,
+ int offsetInGlobalLine) {
boolean emptyFirstSubString = false;
String operatorString = operatorString(operator);
boolean placeOperatorBehind = !breakLineBeforeOperator(operator);
boolean placeOperatorAhead = !placeOperatorBehind;
-
// dump prefix operator?
if (placeOperatorAhead) {
if (!preIndented) {
}
formattedSource.append(operatorString);
increaseSplitDelta(operatorString.length());
-
if (insertSpaceAfter(operator) // && operator != TokenNameimplements
- && operator != TokenNameextends) {
+ && operator != TokenNameextends) {
// && operator != TokenNamethrows) {
formattedSource.append(' ');
increaseSplitDelta(1);
}
SplitLine splitLine = null;
if (options.maxLineLength == 0
- || getLength(currentString, depth) < options.maxLineLength
- || (splitLine = split(currentString, offsetInGlobalLine)) == null) {
-
- // depending on the type of operator, outputs new line before of after dumping it
+ || getLength(currentString, depth) < options.maxLineLength
+ || (splitLine = split(currentString, offsetInGlobalLine)) == null) {
+ // depending on the type of operator, outputs new line before of after
+ // dumping it
// indent before postfix operator
// indent also when the line cannot be split
if (operator == TokenNameextends) {
int max = currentString.length();
if (multipleLineCommentCounter != 0) {
try {
- BufferedReader reader = new BufferedReader(new StringReader(currentString));
+ BufferedReader reader = new BufferedReader(new StringReader(
+ currentString));
String line = reader.readLine();
while (line != null) {
- updateMappedPositionsWhileSplitting(
- beginningOfLineIndex,
- beginningOfLineIndex + line.length() + options.lineSeparatorSequence.length);
+ updateMappedPositionsWhileSplitting(beginningOfLineIndex,
+ beginningOfLineIndex + line.length()
+ + options.lineSeparatorSequence.length);
formattedSource.append(line);
beginningOfLineIndex = beginningOfLineIndex + line.length();
if ((line = reader.readLine()) != null) {
e.printStackTrace();
}
} else {
- updateMappedPositionsWhileSplitting(beginningOfLineIndex, beginningOfLineIndex + max);
+ updateMappedPositionsWhileSplitting(beginningOfLineIndex,
+ beginningOfLineIndex + max);
for (int i = 0; i < max; i++) {
char currentChar = currentString.charAt(i);
switch (currentChar) {
break;
case '\n' :
if (i != max - 1) {
- // fix for 1FFYL5C: LFCOM:ALL - Incorrect indentation when split with a comment inside a condition
+ // fix for 1FFYL5C: LFCOM:ALL - Incorrect indentation when
+ // split with a comment inside a condition
// a substring cannot end with a lineSeparatorSequence,
- // except if it has been added by format() after a one-line comment
+ // except if it has been added by format() after a one-line
+ // comment
formattedSource.append(options.lineSeparatorSequence);
-
// 1FGDDV6: LFCOM:WIN98 - Weird splitting on message expression
dumpTab(depth - 1);
}
// update positions inside the mappedPositions table
if (substringIndex != -1) {
if (multipleLineCommentCounter == 0) {
- int startPosition = beginningOfLineIndex + startSubstringIndexes[substringIndex];
- updateMappedPositionsWhileSplitting(startPosition, startPosition + max);
+ int startPosition = beginningOfLineIndex
+ + startSubstringIndexes[substringIndex];
+ updateMappedPositionsWhileSplitting(startPosition, startPosition
+ + max);
}
-
// compute the splitDelta resulting with the operator and blank removal
if (substringIndex + 1 != startSubstringIndexes.length) {
- increaseSplitDelta(startSubstringIndexes[substringIndex] + max - startSubstringIndexes[substringIndex + 1]);
+ increaseSplitDelta(startSubstringIndexes[substringIndex] + max
+ - startSubstringIndexes[substringIndex + 1]);
}
}
// dump postfix operator?
}
// fix for 1FG0BA3: LFCOM:WIN98 - Weird splitting on interfaces
// extends has to stand alone on a line when currentString has been split.
- if (options.maxLineLength != 0 && splitLine != null && (operator == TokenNameextends)) {
+ if (options.maxLineLength != 0 && splitLine != null
+ && (operator == TokenNameextends)) {
// || operator == TokenNameimplements
// || operator == TokenNamethrows)) {
formattedSource.append(options.lineSeparatorSequence);
// perform actual splitting
String result[] = splitLine.substrings;
int[] splitOperators = splitLine.operators;
-
if (result[0].length() == 0) {
// when the substring 0 is null, the substring 1 is correctly indented.
depth--;
emptyFirstSubString = true;
}
- // the operator going in front of the result[0] string is the operator parameter
+ // the operator going in front of the result[0] string is the operator
+ // parameter
for (int i = 0, max = result.length; i < max; i++) {
// the new depth is the current one if this is the first substring,
// the current one + 1 otherwise.
- // if the substring is a comment, use the current indentation Level instead of the depth
+ // if the substring is a comment, use the current indentation Level
+ // instead of the depth
// (-1 because the ouputline increases depth).
- // (fix for 1FFC72R: LFCOM:ALL - Incorrect line split in presence of line comments)
+ // (fix for 1FFC72R: LFCOM:ALL - Incorrect line split in presence of line
+ // comments)
String currentResult = result[i];
-
if (currentResult.length() != 0 || splitOperators[i] != 0) {
- int newDepth = (currentResult.startsWith("/*") //$NON-NLS-1$
- || currentResult.startsWith("//")) //$NON-NLS-1$
- ? indentationLevel - 1 : depth;
- outputLine(
- currentResult,
- i == 0 || (i == 1 && emptyFirstSubString) ? preIndented : false,
- i == 0 ? newDepth : newDepth + 1,
- splitOperators[i],
- i,
- splitLine.startSubstringsIndexes,
- currentString.indexOf(currentResult));
+ int newDepth = (currentResult.startsWith("/*") //$NON-NLS-1$
+ || currentResult.startsWith("//")) //$NON-NLS-1$
+ ? indentationLevel - 1 : depth;
+ outputLine(currentResult, i == 0 || (i == 1 && emptyFirstSubString)
+ ? preIndented
+ : false, i == 0 ? newDepth : newDepth + 1, splitOperators[i], i,
+ splitLine.startSubstringsIndexes, currentString
+ .indexOf(currentResult));
if (i != max - 1) {
formattedSource.append(options.lineSeparatorSequence);
increaseSplitDelta(options.lineSeparatorSequence.length);
String lastOperatorString = operatorString(lastOperator);
formattedSource.append(options.lineSeparatorSequence);
increaseSplitDelta(options.lineSeparatorSequence.length);
-
if (breakLineBeforeOperator(lastOperator)) {
dumpTab(depth + 1);
if (lastOperator != 0) {
}
formattedSource.append(lastOperatorString);
increaseSplitDelta(lastOperatorString.length());
-
- if (insertSpaceAfter(lastOperator) // && lastOperator != TokenNameimplements
- && lastOperator != TokenNameextends) {
+ if (insertSpaceAfter(lastOperator) // && lastOperator !=
+ // TokenNameimplements
+ && lastOperator != TokenNameextends) {
// && lastOperator != TokenNamethrows) {
formattedSource.append(' ');
increaseSplitDelta(1);
//increaseSplitDelta(operatorString.length());
}
}
-
/**
* Pops the top statement of the stack if it is <code>token</code>
*/
private int pop(int token) {
int delta = 0;
- if ((constructionsCount > 0) && (constructions[constructionsCount - 1] == token)) {
+ if ((constructionsCount > 0)
+ && (constructions[constructionsCount - 1] == token)) {
delta--;
constructionsCount--;
}
return delta;
}
-
/**
- * Pops the top statement of the stack if it is a <code>BLOCK</code> or a <code>NONINDENT_BLOCK</code>.
+ * Pops the top statement of the stack if it is a <code>BLOCK</code> or a
+ * <code>NONINDENT_BLOCK</code>.
*/
private int popBlock() {
int delta = 0;
if ((constructionsCount > 0)
- && ((constructions[constructionsCount - 1] == BLOCK) || (constructions[constructionsCount - 1] == NONINDENT_BLOCK))) {
+ && ((constructions[constructionsCount - 1] == BLOCK) || (constructions[constructionsCount - 1] == NONINDENT_BLOCK))) {
if (constructions[constructionsCount - 1] == BLOCK)
delta--;
constructionsCount--;
}
return delta;
}
-
/**
- * Pops elements until the stack is empty or the top element is <code>token</code>.<br>
+ * Pops elements until the stack is empty or the top element is <code>token</code>.
+ * <br>
* Does not remove <code>token</code> from the stack.
- * @param token the token to be left as the top of the stack
+ *
+ * @param token
+ * the token to be left as the top of the stack
*/
private int popExclusiveUntil(int token) {
int delta = 0;
}
return delta;
}
-
/**
- * Pops elements until the stack is empty or the top element is
- * a <code>BLOCK</code> or a <code>NONINDENT_BLOCK</code>.<br>
+ * Pops elements until the stack is empty or the top element is a <code>BLOCK</code>
+ * or a <code>NONINDENT_BLOCK</code>.<br>
* Does not remove it from the stack.
*/
private int popExclusiveUntilBlock() {
int startCount = constructionsCount;
int delta = 0;
- for (int i = startCount - 1; i >= 0 && constructions[i] != BLOCK && constructions[i] != NONINDENT_BLOCK; i--) {
+ for (int i = startCount - 1; i >= 0 && constructions[i] != BLOCK
+ && constructions[i] != NONINDENT_BLOCK; i--) {
constructionsCount--;
delta--;
}
return delta;
}
-
/**
- * Pops elements until the stack is empty or the top element is
- * a <code>BLOCK</code>, a <code>NONINDENT_BLOCK</code> or a <code>CASE</code>.<br>
+ * Pops elements until the stack is empty or the top element is a <code>BLOCK</code>,
+ * a <code>NONINDENT_BLOCK</code> or a <code>CASE</code>.<br>
* Does not remove it from the stack.
*/
private int popExclusiveUntilBlockOrCase() {
int startCount = constructionsCount;
int delta = 0;
- for (int i = startCount - 1;
- i >= 0 && constructions[i] != BLOCK && constructions[i] != NONINDENT_BLOCK && constructions[i] != TokenNamecase;
- i--) {
+ for (int i = startCount - 1; i >= 0 && constructions[i] != BLOCK
+ && constructions[i] != NONINDENT_BLOCK
+ && constructions[i] != TokenNamecase; i--) {
constructionsCount--;
delta--;
}
return delta;
}
-
/**
- * Pops elements until the stack is empty or the top element is <code>token</code>.<br>
+ * Pops elements until the stack is empty or the top element is <code>token</code>.
+ * <br>
* Removes <code>token</code> from the stack too.
- * @param token the token to remove from the stack
+ *
+ * @param token
+ * the token to remove from the stack
*/
private int popInclusiveUntil(int token) {
int startCount = constructionsCount;
}
return delta;
}
-
/**
- * Pops elements until the stack is empty or the top element is
- * a <code>BLOCK</code> or a <code>NONINDENT_BLOCK</code>.<br>
+ * Pops elements until the stack is empty or the top element is a <code>BLOCK</code>
+ * or a <code>NONINDENT_BLOCK</code>.<br>
* Does not remove it from the stack.
*/
private int popInclusiveUntilBlock() {
int startCount = constructionsCount;
int delta = 0;
- for (int i = startCount - 1; i >= 0 && (constructions[i] != BLOCK && constructions[i] != NONINDENT_BLOCK); i--) {
+ for (int i = startCount - 1; i >= 0
+ && (constructions[i] != BLOCK && constructions[i] != NONINDENT_BLOCK); i--) {
delta--;
constructionsCount--;
}
}
return delta;
}
-
- /**
- * Pushes a block in the stack.<br>
- * Pushes a <code>BLOCK</code> if the stack is empty or if the top element is a <code>BLOCK</code>,
- * pushes <code>NONINDENT_BLOCK</code> otherwise.
- * Creates a new bigger array if the current one is full.
+ /**
+ * Pushes a block in the stack. <br>
+ * Pushes a <code>BLOCK</code> if the stack is empty or if the top element
+ * is a <code>BLOCK</code>, pushes <code>NONINDENT_BLOCK</code>
+ * otherwise. Creates a new bigger array if the current one is full.
*/
private int pushBlock() {
int delta = 0;
if (constructionsCount == constructions.length)
- System.arraycopy(constructions, 0, (constructions = new int[constructionsCount * 2]), 0, constructionsCount);
-
+ System.arraycopy(constructions, 0,
+ (constructions = new int[constructionsCount * 2]), 0,
+ constructionsCount);
if ((constructionsCount == 0)
- || (constructions[constructionsCount - 1] == BLOCK)
- || (constructions[constructionsCount - 1] == NONINDENT_BLOCK)
- || (constructions[constructionsCount - 1] == TokenNamecase)) {
+ || (constructions[constructionsCount - 1] == BLOCK)
+ || (constructions[constructionsCount - 1] == NONINDENT_BLOCK)
+ || (constructions[constructionsCount - 1] == TokenNamecase)) {
delta++;
constructions[constructionsCount++] = BLOCK;
} else {
}
return delta;
}
-
- /**
+ /**
* Pushes <code>token</code>.<br>
* Creates a new bigger array if the current one is full.
*/
private int pushControlStatement(int token) {
if (constructionsCount == constructions.length)
- System.arraycopy(constructions, 0, (constructions = new int[constructionsCount * 2]), 0, constructionsCount);
+ System.arraycopy(constructions, 0,
+ (constructions = new int[constructionsCount * 2]), 0,
+ constructionsCount);
constructions[constructionsCount++] = token;
return 1;
}
-
private static boolean separateFirstArgumentOn(int currentToken) {
- //return (currentToken == TokenNameCOMMA || currentToken == TokenNameSEMICOLON);
- return currentToken != TokenNameif
- && currentToken != TokenNameLPAREN
- && currentToken != TokenNameNOT
- && currentToken != TokenNamewhile
- && currentToken != TokenNamefor
- && currentToken != TokenNameswitch;
+ //return (currentToken == TokenNameCOMMA || currentToken ==
+ // TokenNameSEMICOLON);
+ return currentToken != TokenNameif && currentToken != TokenNameLPAREN
+ && currentToken != TokenNameNOT && currentToken != TokenNamewhile
+ && currentToken != TokenNamefor && currentToken != TokenNameswitch;
}
-
/**
- * Set the positions to map. The mapped positions should be retrieved using the
- * getMappedPositions() method.
- * @param positions int[]
- * @deprecated Set the positions to map using the format(String, int, int[]) method.
+ * Set the positions to map. The mapped positions should be retrieved using
+ * the getMappedPositions() method.
+ *
+ * @param positions
+ * int[]
+ * @deprecated Set the positions to map using the format(String, int, int[])
+ * method.
*
* @see #getMappedPositions()
*/
globalDelta = 0;
mappedPositions = new int[positions.length];
}
-
- /**
+ /**
* Appends a space character to the current line buffer.
*/
private void space() {
currentLineBuffer.append(' ');
increaseLineDelta(1);
}
-
/**
- * Splits <code>stringToSplit</code> on the top level token<br>
- * If there are several identical token at the same level,
- * the string is cut into many pieces.
- * @return an object containing the operator and all the substrings
- * or null if the string cannot be split
+ * Splits <code>stringToSplit</code> on the top level token <br>
+ * If there are several identical token at the same level, the string is cut
+ * into many pieces.
+ *
+ * @return an object containing the operator and all the substrings or null
+ * if the string cannot be split
*/
public SplitLine split(String stringToSplit) {
return split(stringToSplit, 0);
}
-
/**
- * Splits <code>stringToSplit</code> on the top level token<br>
- * If there are several identical token at the same level,
- * the string is cut into many pieces.
- * @return an object containing the operator and all the substrings
- * or null if the string cannot be split
+ * Splits <code>stringToSplit</code> on the top level token <br>
+ * If there are several identical token at the same level, the string is cut
+ * into many pieces.
+ *
+ * @return an object containing the operator and all the substrings or null
+ * if the string cannot be split
*/
public SplitLine split(String stringToSplit, int offsetInGlobalLine) {
/*
* See http://dev.eclipse.org/bugs/show_bug.cgi?id=12540 and
- * http://dev.eclipse.org/bugs/show_bug.cgi?id=14387
+ * http://dev.eclipse.org/bugs/show_bug.cgi?id=14387
*/
if (stringToSplit.indexOf("//$NON-NLS") != -1) { //$NON-NLS-1$
return null;
int splitTokenType = 0;
int splitTokenDepth = Integer.MAX_VALUE;
int splitTokenPriority = Integer.MAX_VALUE;
-
int[] substringsStartPositions = new int[10];
// contains the start position of substrings
int[] substringsEndPositions = new int[10];
int previousToken = -1;
// to remember the previous token.
splitScanner.setSource(stringToSplit.toCharArray());
-
try {
// start the loop
while (true) {
currentToken = splitScanner.getNextToken();
if (Scanner.DEBUG) {
int currentEndPosition = splitScanner.getCurrentTokenEndPosition();
- int currentStartPosition = splitScanner.getCurrentTokenStartPosition();
-
- System.out.print(currentStartPosition + "," + currentEndPosition + ": ");
+ int currentStartPosition = splitScanner
+ .getCurrentTokenStartPosition();
+ System.out.print(currentStartPosition + "," + currentEndPosition
+ + ": ");
System.out.println(scanner.toStringAction(currentToken));
}
} catch (InvalidInputException e) {
}
if (currentToken == TokenNameEOF)
break;
-
if (firstTokenOnLine == -1) {
firstTokenOnLine = currentToken;
}
case TokenNameRBRACE :
case TokenNameRPAREN :
if (openParenthesisPositionCount > 0) {
- if (openParenthesisPositionCount == 1 && lastOpenParenthesisPosition < openParenthesisPosition[0]) {
+ if (openParenthesisPositionCount == 1
+ && lastOpenParenthesisPosition < openParenthesisPosition[0]) {
lastOpenParenthesisPosition = openParenthesisPosition[0];
- } else if (
- (splitTokenDepth == Integer.MAX_VALUE)
+ } else if ((splitTokenDepth == Integer.MAX_VALUE)
|| (splitTokenDepth > openParenthesisPositionCount && openParenthesisPositionCount == 1)) {
splitTokenType = 0;
splitTokenDepth = openParenthesisPositionCount;
splitTokenPriority = Integer.MAX_VALUE;
substringsStartPositions[0] = 0;
- // better token means the whole line until now is the first substring
+ // better token means the whole line until now is the first
+ // substring
substringsCount = 1; // resets the count of substrings
substringsEndPositions[0] = openParenthesisPosition[0];
// substring ends on operator start
position = openParenthesisPosition[0];
- // the string mustn't be cut before the closing parenthesis but after the opening one.
+ // the string mustn't be cut before the closing parenthesis but
+ // after the opening one.
splitOperatorsCount = 1; // resets the count of split operators
splitOperators[0] = 0;
}
case TokenNameLBRACE :
case TokenNameLPAREN :
if (openParenthesisPositionCount == openParenthesisPosition.length) {
- System.arraycopy(
- openParenthesisPosition,
- 0,
- (openParenthesisPosition = new int[openParenthesisPositionCount * 2]),
- 0,
- openParenthesisPositionCount);
+ System
+ .arraycopy(
+ openParenthesisPosition,
+ 0,
+ (openParenthesisPosition = new int[openParenthesisPositionCount * 2]),
+ 0, openParenthesisPositionCount);
}
openParenthesisPosition[openParenthesisPositionCount++] = splitScanner.currentPosition;
- if (currentToken == TokenNameLPAREN && previousToken == TokenNameRPAREN) {
+ if (currentToken == TokenNameLPAREN
+ && previousToken == TokenNameRPAREN) {
openParenthesisPosition[openParenthesisPositionCount - 1] = splitScanner.startPosition;
}
break;
- case TokenNameSEMICOLON : // ;
- case TokenNameCOMMA : // ,
- case TokenNameEQUAL : // =
+ case TokenNameSEMICOLON :
+ // ;
+ case TokenNameCOMMA :
+ // ,
+ case TokenNameEQUAL :
+ // =
if (openParenthesisPositionCount < splitTokenDepth
- || (openParenthesisPositionCount == splitTokenDepth && splitTokenPriority > getTokenPriority(currentToken))) {
+ || (openParenthesisPositionCount == splitTokenDepth && splitTokenPriority > getTokenPriority(currentToken))) {
// the current token is better than the one we currently have
// (in level or in priority if same level)
// reset the substringsCount
splitTokenType = currentToken;
splitTokenPriority = getTokenPriority(currentToken);
substringsStartPositions[0] = 0;
- // better token means the whole line until now is the first substring
-
- if (separateFirstArgumentOn(firstTokenOnLine) && openParenthesisPositionCount > 0) {
+ // better token means the whole line until now is the first
+ // substring
+ if (separateFirstArgumentOn(firstTokenOnLine)
+ && openParenthesisPositionCount > 0) {
substringsCount = 2; // resets the count of substrings
-
substringsEndPositions[0] = openParenthesisPosition[splitTokenDepth - 1];
substringsStartPositions[1] = openParenthesisPosition[splitTokenDepth - 1];
substringsEndPositions[1] = splitScanner.startPosition;
// next substring will start from operator end
} else {
substringsCount = 1; // resets the count of substrings
-
substringsEndPositions[0] = splitScanner.startPosition;
// substring ends on operator start
position = splitScanner.currentPosition;
}
} else {
if ((openParenthesisPositionCount == splitTokenDepth && splitTokenPriority == getTokenPriority(currentToken))
- && splitTokenType != TokenNameEQUAL
- && currentToken != TokenNameEQUAL) {
- // fix for 1FG0BCN: LFCOM:WIN98 - Missing one indentation after split
+ && splitTokenType != TokenNameEQUAL
+ && currentToken != TokenNameEQUAL) {
+ // fix for 1FG0BCN: LFCOM:WIN98 - Missing one indentation after
+ // split
// take only the 1st = into account.
// if another token with the same priority is found,
// push the start position of the substring and
// push the token into the stack.
// create a new array object if the current one is full.
if (substringsCount == substringsStartPositions.length) {
- System.arraycopy(
- substringsStartPositions,
- 0,
- (substringsStartPositions = new int[substringsCount * 2]),
- 0,
- substringsCount);
- System.arraycopy(
- substringsEndPositions,
- 0,
- (substringsEndPositions = new int[substringsCount * 2]),
- 0,
- substringsCount);
+ System
+ .arraycopy(
+ substringsStartPositions,
+ 0,
+ (substringsStartPositions = new int[substringsCount * 2]),
+ 0, substringsCount);
+ System.arraycopy(substringsEndPositions, 0,
+ (substringsEndPositions = new int[substringsCount * 2]),
+ 0, substringsCount);
}
if (splitOperatorsCount == splitOperators.length) {
- System.arraycopy(splitOperators, 0, (splitOperators = new int[splitOperatorsCount * 2]), 0, splitOperatorsCount);
+ System.arraycopy(splitOperators, 0,
+ (splitOperators = new int[splitOperatorsCount * 2]), 0,
+ splitOperatorsCount);
}
substringsStartPositions[substringsCount] = position;
substringsEndPositions[substringsCount++] = splitScanner.startPosition;
}
}
break;
-
- case TokenNameCOLON : // : (15.24)
- // see 1FK7C5R, we only split on a colon, when it is associated with a question-mark.
- // indeed it might appear also behind a case statement, and we do not to break at this point.
- if ((splitOperatorsCount == 0) || splitOperators[splitOperatorsCount - 1] != TokenNameQUESTION) {
+ case TokenNameCOLON :
+ // : (15.24)
+ // see 1FK7C5R, we only split on a colon, when it is associated
+ // with a question-mark.
+ // indeed it might appear also behind a case statement, and we do
+ // not to break at this point.
+ if ((splitOperatorsCount == 0)
+ || splitOperators[splitOperatorsCount - 1] != TokenNameQUESTION) {
break;
}
case TokenNameextends :
- // case TokenNameimplements :
- // case TokenNamethrows :
-
- case TokenNameDOT : // .
- case TokenNameMULTIPLY : // * (15.16.1)
- case TokenNameDIVIDE : // / (15.16.2)
- case TokenNameREMAINDER : // % (15.16.3)
- case TokenNamePLUS : // + (15.17, 15.17.2)
- case TokenNameMINUS : // - (15.17.2)
- case TokenNameLEFT_SHIFT : // << (15.18)
- case TokenNameRIGHT_SHIFT : // >> (15.18)
- // case TokenNameUNSIGNED_RIGHT_SHIFT : // >>> (15.18)
- case TokenNameLESS : // < (15.19.1)
- case TokenNameLESS_EQUAL : // <= (15.19.1)
- case TokenNameGREATER : // > (15.19.1)
- case TokenNameGREATER_EQUAL : // >= (15.19.1)
- // case TokenNameinstanceof : // instanceof
- case TokenNameEQUAL_EQUAL : // == (15.20, 15.20.1, 15.20.2, 15.20.3)
- case TokenNameEQUAL_EQUAL_EQUAL : // == (15.20, 15.20.1, 15.20.2, 15.20.3)
- case TokenNameNOT_EQUAL : // != (15.20, 15.20.1, 15.20.2, 15.20.3)
- case TokenNameNOT_EQUAL_EQUAL : // != (15.20, 15.20.1, 15.20.2, 15.20.3)
- case TokenNameAND : // & (15.21, 15.21.1, 15.21.2)
- case TokenNameOR : // | (15.21, 15.21.1, 15.21.2)
- case TokenNameXOR : // ^ (15.21, 15.21.1, 15.21.2)
- case TokenNameAND_AND : // && (15.22)
- case TokenNameOR_OR : // || (15.23)
- case TokenNameQUESTION : // ? (15.24)
- case TokenNameMULTIPLY_EQUAL : // *= (15.25.2)
- case TokenNameDIVIDE_EQUAL : // /= (15.25.2)
- case TokenNameREMAINDER_EQUAL : // %= (15.25.2)
- case TokenNamePLUS_EQUAL : // += (15.25.2)
- case TokenNameMINUS_EQUAL : // -= (15.25.2)
- case TokenNameLEFT_SHIFT_EQUAL : // <<= (15.25.2)
- case TokenNameRIGHT_SHIFT_EQUAL : // >>= (15.25.2)
- // case TokenNameUNSIGNED_RIGHT_SHIFT_EQUAL : // >>>= (15.25.2)
- case TokenNameAND_EQUAL : // &= (15.25.2)
- case TokenNameXOR_EQUAL : // ^= (15.25.2)
- case TokenNameOR_EQUAL : // |= (15.25.2)
-
- if ((openParenthesisPositionCount < splitTokenDepth
- || (openParenthesisPositionCount == splitTokenDepth && splitTokenPriority > getTokenPriority(currentToken)))
- && !((currentToken == TokenNamePLUS || currentToken == TokenNameMINUS)
- && (previousToken == TokenNameLBRACE || previousToken == TokenNameLBRACKET || splitScanner.startPosition == 0))) {
+ // case TokenNameimplements :
+ // case TokenNamethrows :
+ case TokenNameDOT :
+ // .
+ case TokenNameMULTIPLY :
+ // * (15.16.1)
+ case TokenNameDIVIDE :
+ // / (15.16.2)
+ case TokenNameREMAINDER :
+ // % (15.16.3)
+ case TokenNamePLUS :
+ // + (15.17, 15.17.2)
+ case TokenNameMINUS :
+ // - (15.17.2)
+ case TokenNameLEFT_SHIFT :
+ // << (15.18)
+ case TokenNameRIGHT_SHIFT :
+ // >> (15.18)
+ // case TokenNameUNSIGNED_RIGHT_SHIFT : // >>> (15.18)
+ case TokenNameLESS :
+ // < (15.19.1)
+ case TokenNameLESS_EQUAL :
+ // <= (15.19.1)
+ case TokenNameGREATER :
+ // > (15.19.1)
+ case TokenNameGREATER_EQUAL :
+ // >= (15.19.1)
+ // case TokenNameinstanceof : // instanceof
+ case TokenNameEQUAL_EQUAL :
+ // == (15.20, 15.20.1, 15.20.2, 15.20.3)
+ case TokenNameEQUAL_EQUAL_EQUAL :
+ // == (15.20, 15.20.1, 15.20.2, 15.20.3)
+ case TokenNameNOT_EQUAL :
+ // != (15.20, 15.20.1, 15.20.2, 15.20.3)
+ case TokenNameNOT_EQUAL_EQUAL :
+ // != (15.20, 15.20.1, 15.20.2, 15.20.3)
+ case TokenNameAND :
+ // & (15.21, 15.21.1, 15.21.2)
+ case TokenNameOR :
+ // | (15.21, 15.21.1, 15.21.2)
+ case TokenNameXOR :
+ // ^ (15.21, 15.21.1, 15.21.2)
+ case TokenNameAND_AND :
+ // && (15.22)
+ case TokenNameOR_OR :
+ // || (15.23)
+ case TokenNameQUESTION :
+ // ? (15.24)
+ case TokenNameMULTIPLY_EQUAL :
+ // *= (15.25.2)
+ case TokenNameDIVIDE_EQUAL :
+ // /= (15.25.2)
+ case TokenNameREMAINDER_EQUAL :
+ // %= (15.25.2)
+ case TokenNamePLUS_EQUAL :
+ // += (15.25.2)
+ case TokenNameMINUS_EQUAL :
+ // -= (15.25.2)
+ case TokenNameLEFT_SHIFT_EQUAL :
+ // <<= (15.25.2)
+ case TokenNameRIGHT_SHIFT_EQUAL :
+ // >>= (15.25.2)
+ // case TokenNameUNSIGNED_RIGHT_SHIFT_EQUAL : // >>>= (15.25.2)
+ case TokenNameAND_EQUAL :
+ // &= (15.25.2)
+ case TokenNameXOR_EQUAL :
+ // ^= (15.25.2)
+ case TokenNameOR_EQUAL :
+ // |= (15.25.2)
+ if ((openParenthesisPositionCount < splitTokenDepth || (openParenthesisPositionCount == splitTokenDepth && splitTokenPriority > getTokenPriority(currentToken)))
+ && !((currentToken == TokenNamePLUS || currentToken == TokenNameMINUS) && (previousToken == TokenNameLBRACE
+ || previousToken == TokenNameLBRACKET || splitScanner.startPosition == 0))) {
// the current token is better than the one we currently have
// (in level or in priority if same level)
// reset the substringsCount
splitTokenType = currentToken;
splitTokenPriority = getTokenPriority(currentToken);
substringsStartPositions[0] = 0;
- // better token means the whole line until now is the first substring
-
- if (separateFirstArgumentOn(firstTokenOnLine) && openParenthesisPositionCount > 0) {
+ // better token means the whole line until now is the first
+ // substring
+ if (separateFirstArgumentOn(firstTokenOnLine)
+ && openParenthesisPositionCount > 0) {
substringsCount = 2; // resets the count of substrings
-
substringsEndPositions[0] = openParenthesisPosition[splitTokenDepth - 1];
substringsStartPositions[1] = openParenthesisPosition[splitTokenDepth - 1];
substringsEndPositions[1] = splitScanner.startPosition;
// next substring will start from operator end
} else {
substringsCount = 1; // resets the count of substrings
-
substringsEndPositions[0] = splitScanner.startPosition;
// substring ends on operator start
position = splitScanner.currentPosition;
// next substring will start from operator end
splitOperatorsCount = 2; // resets the count of split operators
splitOperators[0] = 0;
- // nothing for first operand since operator will be inserted in front of the second operand
+ // nothing for first operand since operator will be inserted in
+ // front of the second operand
splitOperators[1] = currentToken;
-
}
} else {
- if (openParenthesisPositionCount == splitTokenDepth && splitTokenPriority == getTokenPriority(currentToken)) {
+ if (openParenthesisPositionCount == splitTokenDepth
+ && splitTokenPriority == getTokenPriority(currentToken)) {
// if another token with the same priority is found,
// push the start position of the substring and
// push the token into the stack.
// create a new array object if the current one is full.
if (substringsCount == substringsStartPositions.length) {
- System.arraycopy(
- substringsStartPositions,
- 0,
- (substringsStartPositions = new int[substringsCount * 2]),
- 0,
- substringsCount);
- System.arraycopy(
- substringsEndPositions,
- 0,
- (substringsEndPositions = new int[substringsCount * 2]),
- 0,
- substringsCount);
+ System
+ .arraycopy(
+ substringsStartPositions,
+ 0,
+ (substringsStartPositions = new int[substringsCount * 2]),
+ 0, substringsCount);
+ System.arraycopy(substringsEndPositions, 0,
+ (substringsEndPositions = new int[substringsCount * 2]),
+ 0, substringsCount);
}
if (splitOperatorsCount == splitOperators.length) {
- System.arraycopy(splitOperators, 0, (splitOperators = new int[splitOperatorsCount * 2]), 0, splitOperatorsCount);
+ System.arraycopy(splitOperators, 0,
+ (splitOperators = new int[splitOperatorsCount * 2]), 0,
+ splitOperatorsCount);
}
substringsStartPositions[substringsCount] = position;
substringsEndPositions[substringsCount++] = splitScanner.startPosition;
// if the string cannot be split, return null.
if (splitOperatorsCount == 0)
return null;
-
// ## SPECIAL CASES BEGIN
- if (((splitOperatorsCount == 2
- && splitOperators[1] == TokenNameDOT
- && splitTokenDepth == 0
- && lastOpenParenthesisPosition > -1)
- || (splitOperatorsCount > 2
- && splitOperators[1] == TokenNameDOT
- && splitTokenDepth == 0
- && lastOpenParenthesisPosition > -1
- && lastOpenParenthesisPosition <= options.maxLineLength)
- || (separateFirstArgumentOn(firstTokenOnLine) && splitTokenDepth > 0 && lastOpenParenthesisPosition > -1))
- && (lastOpenParenthesisPosition < splitScanner.source.length && splitScanner.source[lastOpenParenthesisPosition] != ')')) {
- // fix for 1FH4J2H: LFCOM:WINNT - Formatter - Empty parenthesis should not be broken on two lines
+ if (((splitOperatorsCount == 2 && splitOperators[1] == TokenNameDOT
+ && splitTokenDepth == 0 && lastOpenParenthesisPosition > -1)
+ || (splitOperatorsCount > 2 && splitOperators[1] == TokenNameDOT
+ && splitTokenDepth == 0 && lastOpenParenthesisPosition > -1 && lastOpenParenthesisPosition <= options.maxLineLength) || (separateFirstArgumentOn(firstTokenOnLine)
+ && splitTokenDepth > 0 && lastOpenParenthesisPosition > -1))
+ && (lastOpenParenthesisPosition < splitScanner.source.length && splitScanner.source[lastOpenParenthesisPosition] != ')')) {
+ // fix for 1FH4J2H: LFCOM:WINNT - Formatter - Empty parenthesis should
+ // not be broken on two lines
// only one split on a top level .
- // or more than one split on . and substring before open parenthesis fits one line.
+ // or more than one split on . and substring before open parenthesis fits
+ // one line.
// or split inside parenthesis and first token is not a for/while/if
- SplitLine sl = split(stringToSplit.substring(lastOpenParenthesisPosition), lastOpenParenthesisPosition);
+ SplitLine sl = split(
+ stringToSplit.substring(lastOpenParenthesisPosition),
+ lastOpenParenthesisPosition);
if (sl == null || sl.operators[0] != TokenNameCOMMA) {
- // trim() is used to remove the extra blanks at the end of the substring. See PR 1FGYPI1
- return new SplitLine(
- new int[] { 0, 0 },
- new String[] {
+ // trim() is used to remove the extra blanks at the end of the
+ // substring. See PR 1FGYPI1
+ return new SplitLine(new int[]{0, 0}, new String[]{
stringToSplit.substring(0, lastOpenParenthesisPosition).trim(),
- stringToSplit.substring(lastOpenParenthesisPosition)},
- new int[] { offsetInGlobalLine, lastOpenParenthesisPosition + offsetInGlobalLine });
+ stringToSplit.substring(lastOpenParenthesisPosition)}, new int[]{
+ offsetInGlobalLine,
+ lastOpenParenthesisPosition + offsetInGlobalLine});
} else {
// right substring can be split and is split on comma
// copy substrings and operators
int[] startIndexes = new int[subStringsLength];
int operatorsLength = sl.operators.length + 1 - startIndex;
int[] operators = new int[operatorsLength];
-
result[0] = stringToSplit.substring(0, lastOpenParenthesisPosition);
operators[0] = 0;
-
- System.arraycopy(sl.startSubstringsIndexes, startIndex, startIndexes, 1, subStringsLength - 1);
+ System.arraycopy(sl.startSubstringsIndexes, startIndex, startIndexes,
+ 1, subStringsLength - 1);
for (int i = subStringsLength - 1; i >= 0; i--) {
startIndexes[i] += offsetInGlobalLine;
}
- System.arraycopy(sl.substrings, startIndex, result, 1, subStringsLength - 1);
- System.arraycopy(sl.operators, startIndex, operators, 1, operatorsLength - 1);
-
+ System.arraycopy(sl.substrings, startIndex, result, 1,
+ subStringsLength - 1);
+ System.arraycopy(sl.operators, startIndex, operators, 1,
+ operatorsLength - 1);
return new SplitLine(operators, result, startIndexes);
}
}
- // if the last token is a comment and the substring before the comment fits on a line,
+ // if the last token is a comment and the substring before the comment fits
+ // on a line,
// split before the comment and return the result.
- if (lastCommentStartPosition > -1 && lastCommentStartPosition < options.maxLineLength && splitTokenPriority > 50) {
+ if (lastCommentStartPosition > -1
+ && lastCommentStartPosition < options.maxLineLength
+ && splitTokenPriority > 50) {
int end = lastCommentStartPosition;
int start = lastCommentStartPosition;
if (stringToSplit.charAt(end - 1) == ' ') {
if (start != end && stringToSplit.charAt(start) == ' ') {
start++;
}
- return new SplitLine(
- new int[] { 0, 0 },
- new String[] { stringToSplit.substring(0, end), stringToSplit.substring(start)},
- new int[] { 0, start });
+ return new SplitLine(new int[]{0, 0}, new String[]{
+ stringToSplit.substring(0, end), stringToSplit.substring(start)},
+ new int[]{0, start});
}
if (position != stringToSplit.length()) {
if (substringsCount == substringsStartPositions.length) {
- System.arraycopy(
- substringsStartPositions,
- 0,
- (substringsStartPositions = new int[substringsCount * 2]),
- 0,
- substringsCount);
- System.arraycopy(substringsEndPositions, 0, (substringsEndPositions = new int[substringsCount * 2]), 0, substringsCount);
+ System.arraycopy(substringsStartPositions, 0,
+ (substringsStartPositions = new int[substringsCount * 2]), 0,
+ substringsCount);
+ System.arraycopy(substringsEndPositions, 0,
+ (substringsEndPositions = new int[substringsCount * 2]), 0,
+ substringsCount);
}
// avoid empty extra substring, e.g. line terminated with a semi-colon
substringsStartPositions[substringsCount] = position;
substringsEndPositions[substringsCount++] = stringToSplit.length();
}
if (splitOperatorsCount == splitOperators.length) {
- System.arraycopy(splitOperators, 0, (splitOperators = new int[splitOperatorsCount * 2]), 0, splitOperatorsCount);
+ System.arraycopy(splitOperators, 0,
+ (splitOperators = new int[splitOperatorsCount * 2]), 0,
+ splitOperatorsCount);
}
splitOperators[splitOperatorsCount] = 0;
-
- // the last element of the stack is the position of the end of StringToSPlit
+ // the last element of the stack is the position of the end of
+ // StringToSPlit
// +1 because the substring method excludes the last character
String[] result = new String[substringsCount];
for (int i = 0; i < substringsCount; i++) {
substringsStartPositions[i] += offsetInGlobalLine;
}
if (splitOperatorsCount > substringsCount) {
- System.arraycopy(substringsStartPositions, 0, (substringsStartPositions = new int[splitOperatorsCount]), 0, substringsCount);
- System.arraycopy(substringsEndPositions, 0, (substringsEndPositions = new int[splitOperatorsCount]), 0, substringsCount);
+ System.arraycopy(substringsStartPositions, 0,
+ (substringsStartPositions = new int[splitOperatorsCount]), 0,
+ substringsCount);
+ System.arraycopy(substringsEndPositions, 0,
+ (substringsEndPositions = new int[splitOperatorsCount]), 0,
+ substringsCount);
for (int i = substringsCount; i < splitOperatorsCount; i++) {
substringsStartPositions[i] = position;
substringsEndPositions[i] = position;
}
- System.arraycopy(splitOperators, 0, (splitOperators = new int[splitOperatorsCount]), 0, splitOperatorsCount);
+ System.arraycopy(splitOperators, 0,
+ (splitOperators = new int[splitOperatorsCount]), 0,
+ splitOperatorsCount);
} else {
- System.arraycopy(substringsStartPositions, 0, (substringsStartPositions = new int[substringsCount]), 0, substringsCount);
- System.arraycopy(substringsEndPositions, 0, (substringsEndPositions = new int[substringsCount]), 0, substringsCount);
- System.arraycopy(splitOperators, 0, (splitOperators = new int[substringsCount]), 0, substringsCount);
+ System.arraycopy(substringsStartPositions, 0,
+ (substringsStartPositions = new int[substringsCount]), 0,
+ substringsCount);
+ System.arraycopy(substringsEndPositions, 0,
+ (substringsEndPositions = new int[substringsCount]), 0,
+ substringsCount);
+ System.arraycopy(splitOperators, 0,
+ (splitOperators = new int[substringsCount]), 0, substringsCount);
}
- SplitLine splitLine = new SplitLine(splitOperators, result, substringsStartPositions);
+ SplitLine splitLine = new SplitLine(splitOperators, result,
+ substringsStartPositions);
return splitLine;
}
-
private void updateMappedPositions(int startPosition) {
if (positionsToMap == null) {
return;
}
char[] source = scanner.source;
int sourceLength = source.length;
- while (indexToMap < positionsToMap.length && positionsToMap[indexToMap] <= startPosition) {
+ while (indexToMap < positionsToMap.length
+ && positionsToMap[indexToMap] <= startPosition) {
int posToMap = positionsToMap[indexToMap];
if (posToMap < 0 || posToMap >= sourceLength) {
// protection against out of bounds position
indexToMap++;
}
}
-
- private void updateMappedPositionsWhileSplitting(int startPosition, int endPosition) {
+ private void updateMappedPositionsWhileSplitting(int startPosition,
+ int endPosition) {
if (mappedPositions == null || mappedPositions.length == indexInMap)
return;
-
while (indexInMap < mappedPositions.length
- && startPosition <= mappedPositions[indexInMap]
- && mappedPositions[indexInMap] < endPosition
- && indexInMap < indexToMap) {
+ && startPosition <= mappedPositions[indexInMap]
+ && mappedPositions[indexInMap] < endPosition && indexInMap < indexToMap) {
mappedPositions[indexInMap] += splitDelta;
indexInMap++;
}
}
-
private int getLength(String s, int tabDepth) {
int length = 0;
for (int i = 0; i < tabDepth; i++) {
}
return length;
}
-
- /**
- * Sets the initial indentation level
- * @param indentationLevel new indentation level
- *
- * @deprecated
- */
+ /**
+ * Sets the initial indentation level
+ *
+ * @param indentationLevel
+ * new indentation level
+ *
+ * @deprecated
+ */
public void setInitialIndentationLevel(int newIndentationLevel) {
this.initialIndentationLevel = currentLineIndentationLevel = indentationLevel = newIndentationLevel;
}