@Nullable
private PsiBuilder.Marker parseLambdaExpression(
final PsiBuilder builder, final boolean typed, @Nullable final PsiBuilder.Marker typeList) {
final PsiBuilder.Marker start = typeList != null ? typeList.precede() : builder.mark();
myParser.getDeclarationParser().parseLambdaParameterList(builder, typed);
if (!expect(builder, JavaTokenType.ARROW)) {
start.rollbackTo();
return null;
}
final PsiBuilder.Marker body;
if (builder.getTokenType() == JavaTokenType.LBRACE) {
body = myParser.getStatementParser().parseCodeBlock(builder);
} else {
body = parse(builder);
}
if (body == null) {
builder.error(JavaErrorMessages.message("expected.lbrace"));
}
start.done(JavaElementType.LAMBDA_EXPRESSION);
return start;
}
@Test
public void testarAnaliseCorretas() throws Throwable {
assertEquals("E T F T2 E2 T F T2 E2", parser1.run("d + d"));
assertEquals("E T F T2 F T2 E2", parser1.run("d * d"));
assertEquals(
"E T F E T F T2 E2 T F T2 E2 T2 F E T F E T F T2 E2 T2 E2 T2 E2",
parser1.run("( d + d ) * ( ( d ) )"));
}
public static void main(String argv[]) {
/* Avatar u=new Avatar();
// Unicorn u=new Unicorn();
JooFrame jf=new JooFrame(u);
jf.show(); */
for (int i = 0; i < argv.length; i++) {
String filename = argv[i];
JavaParser jw = new JavaParser(filename);
jw.read();
// ((Class)jw.classes.get(0)).jooify();
jw.jooify();
jw.write();
}
}
public static void main(java.lang.String[] args) throws RecognitionException {
CharStream cs =
new ANTLRStringStream(
"package gw.internal.gosu.parser.java;\n"
+ "import java.util.List;\n"
+ "public class Foo {\n"
+ "int a = 1_2_3;\n"
+ " public static void main(String[] args) {}\n"
+ "}");
JavaLexer lexer = new JavaLexer(cs);
TokenRewriteStream tokens = new TokenRewriteStream(lexer);
JavaParser parser = new JavaParser(tokens);
TreeBuilder treeBuilder = new TreeBuilder();
parser.setTreeBuilder(treeBuilder);
parser.compilationUnit();
dumpJavaAST(treeBuilder.getTree());
}
@Nullable
private PsiBuilder.Marker parseUnary(final PsiBuilder builder) {
final IElementType tokenType = builder.getTokenType();
if (PREFIX_OPS.contains(tokenType)) {
final PsiBuilder.Marker unary = builder.mark();
builder.advanceLexer();
final PsiBuilder.Marker operand = parseUnary(builder);
if (operand == null) {
error(builder, JavaErrorMessages.message("expected.expression"));
}
unary.done(JavaElementType.PREFIX_EXPRESSION);
return unary;
} else if (tokenType == JavaTokenType.LPARENTH) {
final PsiBuilder.Marker typeCast = builder.mark();
builder.advanceLexer();
ReferenceParser.TypeInfo typeInfo =
myParser
.getReferenceParser()
.parseTypeInfo(
builder,
ReferenceParser.EAT_LAST_DOT
| ReferenceParser.WILDCARD
| ReferenceParser.CONJUNCTIONS
| ReferenceParser.INCOMPLETE_ANNO);
if (typeInfo == null || !expect(builder, JavaTokenType.RPARENTH)) {
typeCast.rollbackTo();
return parsePostfix(builder);
}
if (PREF_ARITHMETIC_OPS.contains(builder.getTokenType()) && !typeInfo.isPrimitive) {
typeCast.rollbackTo();
return parsePostfix(builder);
}
final PsiBuilder.Marker expr = parseUnary(builder);
if (expr == null) {
if (!typeInfo
.isParameterized) { // cannot parse correct parenthesized expression after correct
// parameterized type
typeCast.rollbackTo();
return parsePostfix(builder);
} else {
error(builder, JavaErrorMessages.message("expected.expression"));
}
}
typeCast.done(JavaElementType.TYPE_CAST_EXPRESSION);
return typeCast;
} else {
return parsePostfix(builder);
}
}
/** Listen to matches of methodDeclaration */
@Override
public void enterMethodDeclaration(JavaParser.MethodDeclarationContext ctx) {
// need parser to get tokens
TokenStream tokens = parser.getTokenStream();
String type = "void";
if (ctx.type() != null) {
type = tokens.getText(ctx.type());
}
String args = tokens.getText(ctx.formalParameters());
System.out.println("\t" + type + " " + ctx.Identifier() + args + ";");
}
@NotNull
private PsiBuilder.Marker parseMethodReference(
final PsiBuilder builder, final PsiBuilder.Marker start) {
builder.advanceLexer();
myParser.getReferenceParser().parseReferenceParameterList(builder, false, false);
if (!expect(builder, JavaTokenType.IDENTIFIER) && !expect(builder, JavaTokenType.NEW_KEYWORD)) {
error(builder, JavaErrorMessages.message("expected.identifier"));
}
start.done(JavaElementType.METHOD_REF_EXPRESSION);
return start;
}
@Nullable
private PsiBuilder.Marker parseClassAccessOrMethodReference(final PsiBuilder builder) {
final PsiBuilder.Marker expr = builder.mark();
final boolean primitive = ElementType.PRIMITIVE_TYPE_BIT_SET.contains(builder.getTokenType());
if (myParser.getReferenceParser().parseType(builder, 0) == null) {
expr.drop();
return null;
}
final PsiBuilder.Marker result = continueClassAccessOrMethodReference(builder, expr, primitive);
if (result == null) expr.rollbackTo();
return result;
}
@Override
public Object run() throws Exception {
JavaParser parser = new JavaParser();
parser.setContent(this.getContent());
parser.create();
String packageName = parser.getPackageName();
String className =
this.getResourceNode()
.getName()
.substring(0, this.getResourceNode().getName().indexOf("."));
String fullClassName = "";
if (packageName != null) fullClassName += packageName + ".";
fullClassName += className;
ClassLoader prerCl = Thread.currentThread().getContextClassLoader();
CodiClassLoader cl =
CodiClassLoader.createClassLoader(
this.getResourceNode().getProjectId(), session.getEmployee().getGlobalCom(), false);
Thread.currentThread().setContextClassLoader(cl);
Object o =
Thread.currentThread()
.getContextClassLoader()
.loadClass(fullClassName)
.newInstance(); // cl.loadClass(getPackageName() + "." + getClassName()).newInstance();
if (o instanceof ITool) ((ITool) o).onLoad();
Thread.currentThread().setContextClassLoader(prerCl);
return new FormPreview(o);
}
@Nullable
private PsiBuilder.Marker parseExpression(final PsiBuilder builder, final ExprType type) {
switch (type) {
case CONDITIONAL_OR:
return parseBinary(builder, ExprType.CONDITIONAL_AND, CONDITIONAL_OR_OPS);
case CONDITIONAL_AND:
return parseBinary(builder, ExprType.OR, CONDITIONAL_AND_OPS);
case OR:
return parseBinary(builder, ExprType.XOR, OR_OPS);
case XOR:
return parseBinary(builder, ExprType.AND, XOR_OPS);
case AND:
return parseBinary(builder, ExprType.EQUALITY, AND_OPS);
case EQUALITY:
return parseBinary(builder, ExprType.RELATIONAL, EQUALITY_OPS);
case RELATIONAL:
return parseRelational(builder);
case SHIFT:
return parseBinary(builder, ExprType.ADDITIVE, SHIFT_OPS);
case ADDITIVE:
return parseBinary(builder, ExprType.MULTIPLICATIVE, ADDITIVE_OPS);
case MULTIPLICATIVE:
return parseBinary(builder, ExprType.UNARY, MULTIPLICATIVE_OPS);
case UNARY:
return parseUnary(builder);
case TYPE:
return myParser
.getReferenceParser()
.parseType(builder, ReferenceParser.EAT_LAST_DOT | ReferenceParser.WILDCARD);
default:
assert false : "Unexpected type: " + type;
return null;
}
}
public ArrayList<String> findThisClass() {
ArrayList<String> classInfo = new ArrayList<String>();
JavaParser parser = new JavaParser();
parser.setContent(this.getContent());
parser.create();
if (parser.getFields() != null) {
for (JavaField field : parser.getFields()) {
if (field.isStatics()) continue;
String upperCasefieldName = CodiStringUtil.firstUpperCase(field.getName());
String getterName = "get" + upperCasefieldName;
String setterName = "set" + upperCasefieldName;
if (parser.getMethods().contains(new JavaMethod(getterName)))
classInfo.add(getterName + "()" + "/" + "this" + "/method/");
if (parser.getMethods().contains(new JavaMethod(setterName)))
classInfo.add(setterName + "()" + "/" + "this" + "/method/");
classInfo.add(field.getName() + "/" + "this" + "/field/");
}
}
// TODO: live code
/*
ArrayList<ClassField> classFields = classModeler.getClassFields();
if(classFields!=null) {
for (ClassField field : classFields) {
classInfo.add(field.getId() + "/" + "this" + "/field/");
}
}
ArrayList<ClassMethod> classMethods = classModeler.getClassMethods();
if(classMethods!=null) {
for (ClassMethod classMethod : classMethods) {
classInfo.add(classMethod.getMethodName() + "/" + "this" + "/method/");
}
}
*/
return classInfo;
}
@Nullable
private PsiBuilder.Marker parsePrimaryExpressionStart(final PsiBuilder builder) {
IElementType tokenType = builder.getTokenType();
if (LITERALS.contains(tokenType)) {
final PsiBuilder.Marker literal = builder.mark();
builder.advanceLexer();
literal.done(JavaElementType.LITERAL_EXPRESSION);
return literal;
}
if (tokenType == JavaTokenType.LBRACE) {
return parseArrayInitializer(builder);
}
if (tokenType == JavaTokenType.NEW_KEYWORD) {
return parseNew(builder, null);
}
if (tokenType == JavaTokenType.LPARENTH) {
final PsiBuilder.Marker lambda = parseLambdaAfterParenth(builder, null);
if (lambda != null) {
return lambda;
}
final PsiBuilder.Marker parenth = builder.mark();
builder.advanceLexer();
final PsiBuilder.Marker inner = parse(builder);
if (inner == null) {
error(builder, JavaErrorMessages.message("expected.expression"));
}
if (!expect(builder, JavaTokenType.RPARENTH)) {
if (inner != null) {
error(builder, JavaErrorMessages.message("expected.rparen"));
}
}
parenth.done(JavaElementType.PARENTH_EXPRESSION);
return parenth;
}
if (TYPE_START.contains(tokenType)) {
final PsiBuilder.Marker mark = builder.mark();
final ReferenceParser.TypeInfo typeInfo =
myParser.getReferenceParser().parseTypeInfo(builder, 0);
if (typeInfo != null) {
boolean optionalClassKeyword = typeInfo.isPrimitive || typeInfo.isArray;
if (optionalClassKeyword || !typeInfo.hasErrors && typeInfo.isParameterized) {
final PsiBuilder.Marker result =
continueClassAccessOrMethodReference(builder, mark, optionalClassKeyword);
if (result != null) {
return result;
}
}
}
mark.rollbackTo();
}
PsiBuilder.Marker annotation = null;
if (tokenType == JavaTokenType.AT) {
annotation = myParser.getDeclarationParser().parseAnnotations(builder);
tokenType = builder.getTokenType();
}
if (tokenType == JavaTokenType.IDENTIFIER) {
if (builder.lookAhead(1) == JavaTokenType.ARROW) {
return parseLambdaExpression(builder, false, null);
}
final PsiBuilder.Marker refExpr;
if (annotation != null) {
final PsiBuilder.Marker refParam = annotation.precede();
refParam.doneBefore(JavaElementType.REFERENCE_PARAMETER_LIST, annotation);
refExpr = refParam.precede();
} else {
refExpr = builder.mark();
builder.mark().done(JavaElementType.REFERENCE_PARAMETER_LIST);
}
builder.advanceLexer();
refExpr.done(JavaElementType.REFERENCE_EXPRESSION);
return refExpr;
}
if (annotation != null) {
annotation.rollbackTo();
tokenType = builder.getTokenType();
}
PsiBuilder.Marker expr = null;
if (tokenType == JavaTokenType.LT) {
expr = builder.mark();
if (!myParser.getReferenceParser().parseReferenceParameterList(builder, false, false)) {
expr.rollbackTo();
return null;
}
tokenType = builder.getTokenType();
if (!THIS_OR_SUPER.contains(tokenType)) {
expr.rollbackTo();
return null;
}
}
if (THIS_OR_SUPER.contains(tokenType)) {
if (expr == null) {
expr = builder.mark();
builder.mark().done(JavaElementType.REFERENCE_PARAMETER_LIST);
}
builder.advanceLexer();
expr.done(
builder.getTokenType() == JavaTokenType.LPARENTH
? JavaElementType.REFERENCE_EXPRESSION
: tokenType == JavaTokenType.THIS_KEYWORD
? JavaElementType.THIS_EXPRESSION
: JavaElementType.SUPER_EXPRESSION);
return expr;
}
return null;
}
// todo[r.sh] make 'this', 'super' and 'class' reference expressions
@Nullable
private PsiBuilder.Marker parsePrimary(
final PsiBuilder builder, @Nullable final BreakPoint breakPoint, final int breakOffset) {
PsiBuilder.Marker startMarker = builder.mark();
PsiBuilder.Marker expr = parsePrimaryExpressionStart(builder);
if (expr == null) {
startMarker.drop();
return null;
}
while (true) {
final IElementType tokenType = builder.getTokenType();
if (tokenType == JavaTokenType.DOT) {
final PsiBuilder.Marker dotPos = builder.mark();
final int dotOffset = builder.getCurrentOffset();
builder.advanceLexer();
IElementType dotTokenType = builder.getTokenType();
if (dotTokenType == JavaTokenType.AT) {
myParser.getDeclarationParser().parseAnnotations(builder);
dotTokenType = builder.getTokenType();
}
if (dotTokenType == JavaTokenType.CLASS_KEYWORD
&& exprType(expr) == JavaElementType.REFERENCE_EXPRESSION) {
if (breakPoint == BreakPoint.P1 && builder.getCurrentOffset() == breakOffset) {
error(builder, JavaErrorMessages.message("expected.identifier"));
PsiBuilderUtil.drop(startMarker, dotPos);
return expr;
}
final PsiBuilder.Marker copy = startMarker.precede();
final int offset = builder.getCurrentOffset();
startMarker.rollbackTo();
final PsiBuilder.Marker classObjAccess = parseClassAccessOrMethodReference(builder);
if (classObjAccess == null || builder.getCurrentOffset() < offset) {
copy.rollbackTo();
return parsePrimary(builder, BreakPoint.P1, offset);
}
startMarker = copy;
expr = classObjAccess;
} else if (dotTokenType == JavaTokenType.NEW_KEYWORD) {
dotPos.drop();
expr = parseNew(builder, expr);
} else if (THIS_OR_SUPER.contains(dotTokenType)
&& exprType(expr) == JavaElementType.REFERENCE_EXPRESSION) {
if (breakPoint == BreakPoint.P2 && builder.getCurrentOffset() == breakOffset) {
dotPos.rollbackTo();
startMarker.drop();
return expr;
}
final PsiBuilder.Marker copy = startMarker.precede();
final int offset = builder.getCurrentOffset();
startMarker.rollbackTo();
final PsiBuilder.Marker ref =
myParser
.getReferenceParser()
.parseJavaCodeReference(builder, false, true, false, false);
if (ref == null
|| builder.getTokenType() != JavaTokenType.DOT
|| builder.getCurrentOffset() != dotOffset) {
copy.rollbackTo();
return parsePrimary(builder, BreakPoint.P2, offset);
}
builder.advanceLexer();
if (builder.getTokenType() != dotTokenType) {
copy.rollbackTo();
return parsePrimary(builder, BreakPoint.P2, offset);
}
builder.advanceLexer();
startMarker = copy;
expr = ref.precede();
expr.done(
dotTokenType == JavaTokenType.THIS_KEYWORD
? JavaElementType.THIS_EXPRESSION
: JavaElementType.SUPER_EXPRESSION);
} else if (dotTokenType == JavaTokenType.SUPER_KEYWORD) {
dotPos.drop();
final PsiBuilder.Marker refExpr = expr.precede();
builder.advanceLexer();
refExpr.done(JavaElementType.REFERENCE_EXPRESSION);
expr = refExpr;
} else {
dotPos.drop();
final PsiBuilder.Marker refExpr = expr.precede();
myParser.getReferenceParser().parseReferenceParameterList(builder, false, false);
if (!expectOrError(builder, ID_OR_SUPER, "expected.identifier")) {
refExpr.done(JavaElementType.REFERENCE_EXPRESSION);
startMarker.drop();
return refExpr;
}
refExpr.done(JavaElementType.REFERENCE_EXPRESSION);
expr = refExpr;
}
} else if (tokenType == JavaTokenType.LPARENTH) {
if (exprType(expr) != JavaElementType.REFERENCE_EXPRESSION) {
if (exprType(expr) == JavaElementType.SUPER_EXPRESSION) {
if (breakPoint == BreakPoint.P3) {
startMarker.drop();
return expr;
}
final PsiBuilder.Marker copy = startMarker.precede();
startMarker.rollbackTo();
final PsiBuilder.Marker qualifier = parsePrimaryExpressionStart(builder);
if (qualifier != null) {
final PsiBuilder.Marker refExpr = qualifier.precede();
if (builder.getTokenType() == JavaTokenType.DOT) {
builder.advanceLexer();
if (builder.getTokenType() == JavaTokenType.SUPER_KEYWORD) {
builder.advanceLexer();
refExpr.done(JavaElementType.REFERENCE_EXPRESSION);
expr = refExpr;
startMarker = copy;
continue;
}
}
}
copy.rollbackTo();
return parsePrimary(builder, BreakPoint.P3, -1);
} else {
startMarker.drop();
return expr;
}
}
final PsiBuilder.Marker callExpr = expr.precede();
parseArgumentList(builder);
callExpr.done(JavaElementType.METHOD_CALL_EXPRESSION);
expr = callExpr;
} else if (tokenType == JavaTokenType.LBRACKET) {
if (breakPoint == BreakPoint.P4) {
startMarker.drop();
return expr;
}
builder.advanceLexer();
if (builder.getTokenType() == JavaTokenType.RBRACKET
&& exprType(expr) == JavaElementType.REFERENCE_EXPRESSION) {
final int pos = builder.getCurrentOffset();
final PsiBuilder.Marker copy = startMarker.precede();
startMarker.rollbackTo();
final PsiBuilder.Marker classObjAccess = parseClassAccessOrMethodReference(builder);
if (classObjAccess == null || builder.getCurrentOffset() <= pos) {
copy.rollbackTo();
return parsePrimary(builder, BreakPoint.P4, -1);
}
startMarker = copy;
expr = classObjAccess;
} else {
final PsiBuilder.Marker arrayAccess = expr.precede();
final PsiBuilder.Marker index = parse(builder);
if (index == null) {
error(builder, JavaErrorMessages.message("expected.expression"));
arrayAccess.done(JavaElementType.ARRAY_ACCESS_EXPRESSION);
startMarker.drop();
return arrayAccess;
}
if (builder.getTokenType() != JavaTokenType.RBRACKET) {
error(builder, JavaErrorMessages.message("expected.rbracket"));
arrayAccess.done(JavaElementType.ARRAY_ACCESS_EXPRESSION);
startMarker.drop();
return arrayAccess;
}
builder.advanceLexer();
arrayAccess.done(JavaElementType.ARRAY_ACCESS_EXPRESSION);
expr = arrayAccess;
}
} else if (tokenType == JavaTokenType.DOUBLE_COLON) {
return parseMethodReference(builder, startMarker);
} else {
startMarker.drop();
return expr;
}
}
}
@Test
public void testarAnaliseIncorretaParser3() throws Throwable {
Assert.assertContains(parser3.run("id = ="));
Assert.assertContains(parser3.run("= id"));
}
@Test
public void testarAnaliseIncorretaParser4() throws Throwable {
Assert.assertContains(parser4.run("a"));
Assert.assertContains(parser4.run("b"));
}
@Test
public void testarAnaliseIncorretaParser1() throws Throwable {
Assert.assertContains(parser1.run(""));
Assert.assertContains(parser1.run("( * )"));
}
@SuppressWarnings({"ConstantConditions"})
protected void run(String[] args) {
System.out.println("parboiled Java parser, performance test");
System.out.println("---------------------------------------");
System.out.print("Creating parser... :");
long start = System.currentTimeMillis();
Parboiled.createParser(JavaParser.class);
time(start);
System.out.print("Creating 100 more parser instances... :");
JavaParser parser = null;
start = System.currentTimeMillis();
for (int i = 0; i < 100; i++) {
parser = Parboiled.createParser(JavaParser.class);
}
time(start);
System.out.print("Creating 100 more parser instances using BaseParser.newInstance() ... :");
start = System.currentTimeMillis();
for (int i = 0; i < 100; i++) {
parser = parser.newInstance();
}
time(start);
start = System.currentTimeMillis();
File baseDir = args.length == 1 ? new File(args[0]) : null;
if (baseDir == null || !baseDir.exists()) baseDir = new File(".");
System.out.printf("Retrieving file list from '%s'", baseDir);
List<File> sources = recursiveGetAllJavaSources(baseDir, new ArrayList<File>());
time(start);
System.out.printf("Parsing all %s given java sources", sources.size());
Rule rootRule =
parser.CompilationUnit().suppressNode(); // we want to see the parse-tree-less performance
start = System.currentTimeMillis();
long lines = 0, characters = 0;
for (File sourceFile : sources) {
long dontCountStart = System.currentTimeMillis();
String sourceText = readAllText(sourceFile);
start +=
System.currentTimeMillis()
- dontCountStart; // do not count the time for reading the text file
ParsingResult<?> result = null;
try {
result = run(rootRule, sourceText);
} catch (Exception e) {
System.out.printf("\nException while parsing file '%s':\n%s", sourceFile, e);
System.exit(1);
}
if (!result.matched) {
System.out.printf(
"\nParse error(s) in file '%s':\n%s", sourceFile, printParseErrors(result));
System.exit(1);
} else {
System.out.print('.');
}
lines += result.inputBuffer.getLineCount();
characters += sourceText.length();
}
long time = time(start);
System.out.println("Parsing performance:");
System.out.printf(
" %6d Files -> %6.2f Files/sec\n", sources.size(), sources.size() * 1000.0 / time);
System.out.printf(" %6d Lines -> %6d Lines/sec\n", lines, lines * 1000 / time);
System.out.printf(" %6d Chars -> %6d Chars/sec\n", characters, characters * 1000 / time);
}
@Test
public void testarAnaliseIncorretaParser5() throws Throwable {
Assert.assertContains(parser5.run("begin , id end"));
Assert.assertContains(parser5.run("beging [ E ] end"));
}
@NotNull
private PsiBuilder.Marker parseNew(PsiBuilder builder, @Nullable PsiBuilder.Marker start) {
PsiBuilder.Marker newExpr = (start != null ? start.precede() : builder.mark());
builder.advanceLexer();
myParser.getReferenceParser().parseReferenceParameterList(builder, false, true);
PsiBuilder.Marker refOrType;
PsiBuilder.Marker anno = myParser.getDeclarationParser().parseAnnotations(builder);
IElementType tokenType = builder.getTokenType();
if (tokenType == JavaTokenType.IDENTIFIER) {
if (anno != null) {
anno.rollbackTo();
}
refOrType =
myParser.getReferenceParser().parseJavaCodeReference(builder, true, true, true, true);
if (refOrType == null) {
error(builder, JavaErrorMessages.message("expected.identifier"));
newExpr.done(JavaElementType.NEW_EXPRESSION);
return newExpr;
}
} else if (ElementType.PRIMITIVE_TYPE_BIT_SET.contains(tokenType)) {
refOrType = null;
builder.advanceLexer();
} else {
error(builder, JavaErrorMessages.message("expected.identifier"));
newExpr.done(JavaElementType.NEW_EXPRESSION);
return newExpr;
}
if (refOrType != null && builder.getTokenType() == JavaTokenType.LPARENTH) {
parseArgumentList(builder);
if (builder.getTokenType() == JavaTokenType.LBRACE) {
final PsiBuilder.Marker classElement = refOrType.precede();
myParser.getDeclarationParser().parseClassBodyWithBraces(builder, false, false);
classElement.done(JavaElementType.ANONYMOUS_CLASS);
}
newExpr.done(JavaElementType.NEW_EXPRESSION);
return newExpr;
}
myParser.getDeclarationParser().parseAnnotations(builder);
if (builder.getTokenType() != JavaTokenType.LBRACKET) {
error(
builder,
refOrType == null
? JavaErrorMessages.message("expected.lbracket")
: JavaErrorMessages.message("expected.lparen.or.lbracket"));
newExpr.done(JavaElementType.NEW_EXPRESSION);
return newExpr;
}
int bracketCount = 0;
int dimCount = 0;
while (true) {
myParser.getDeclarationParser().parseAnnotations(builder);
if (builder.getTokenType() != JavaTokenType.LBRACKET) break;
builder.advanceLexer();
if (bracketCount == dimCount) {
final PsiBuilder.Marker dimExpr = parse(builder);
if (dimExpr != null) {
dimCount++;
}
}
bracketCount++;
if (!expectOrError(builder, JavaTokenType.RBRACKET, "expected.rbracket")) {
newExpr.done(JavaElementType.NEW_EXPRESSION);
return newExpr;
}
}
if (dimCount == 0) {
if (builder.getTokenType() == JavaTokenType.LBRACE) {
parseArrayInitializer(builder);
} else {
error(builder, JavaErrorMessages.message("expected.array.initializer"));
}
}
newExpr.done(JavaElementType.NEW_EXPRESSION);
return newExpr;
}
@Test
public void testarAnaliseCorretasDeParser3() throws Throwable {
assertEquals("S L L1 L L", parser3.run("id = * id"));
assertEquals("S L L1", parser3.run("id"));
}
@Test
public void testarAnaliseCorretasDeParser2() throws Throwable {
assertEquals("A B C", parser2.run("b c"));
assertEquals("A B C", parser2.run("c"));
}
@Test
public void testarAnaliseIncorretaParser6() throws Throwable {
Assert.assertContains(parser6.run("e e"));
Assert.assertContains(parser6.run("; ; e com com"));
}
@Test
public void testarAnaliseCorretasDeParser5() throws Throwable {
assertEquals("P D C", parser5.run("begin com end"));
assertEquals("P D I I I C", parser5.run("begin int , id , id com end"));
}
@Test
public void testarAnaliseCorretasDeParser6() throws Throwable {
assertEquals("P B K K V V C P1", parser6.run("c v"));
}
@Test
public void testarAnaliseCorretasDeParser4() throws Throwable {
assertEquals("S A A", parser4.run("a b"));
assertEquals("S B B", parser4.run("b a"));
}
public void test() throws IOException {
// g++ -o test test.cpp
// chmod +x test
// ./test
// TODO initialize fields
// include files:
// /usr/include/c++/4.2.1/tr1/stdio.h
// /usr/include/stdio.h
// inttypes.h
// not supported yet:
// exceptions
// HexadecimalFloatingPointLiteral
// int x()[] { return null; }
// import static
// import *
// initializer blocks
// access to static fields with instance variable
// final variables (within blocks, parameter list)
// Identifier : (labels)
// ClassOrInterfaceDeclaration within blocks (or any other nested classes)
// assert
assertEquals("\\\\" + "u0000", JavaParser.replaceUnicode("\\\\" + "u0000"));
assertEquals("\u0000", JavaParser.replaceUnicode("\\" + "u0000"));
assertEquals("\u0000", JavaParser.replaceUnicode("\\" + "uu0000"));
assertEquals("\\\\" + "\u0000", JavaParser.replaceUnicode("\\\\\\" + "u0000"));
assertEquals("0", JavaParser.readNumber("0a"));
assertEquals("0l", JavaParser.readNumber("0l"));
assertEquals("0xFFL", JavaParser.readNumber("0xFFLx"));
assertEquals("0xDadaCafe", JavaParser.readNumber("0xDadaCafex"));
assertEquals("1.40e-45f", JavaParser.readNumber("1.40e-45fx"));
assertEquals("1e1f", JavaParser.readNumber("1e1fx"));
assertEquals("2.f", JavaParser.readNumber("2.fx"));
assertEquals(".3d", JavaParser.readNumber(".3dx"));
assertEquals("6.022137e+23f", JavaParser.readNumber("6.022137e+23f+1"));
JavaParser parser = new JavaParser();
parser.parse("src/tools/org/h2", "java.lang.Object");
parser.parse("src/tools/org/h2", "java.lang.String");
parser.parse("src/tools/org/h2", "java.lang.Math");
parser.parse("src/tools/org/h2", "java.lang.Integer");
parser.parse("src/tools/org/h2", "java.lang.Long");
parser.parse("src/tools/org/h2", "java.lang.StringBuilder");
parser.parse("src/tools/org/h2", "java.io.PrintStream");
parser.parse("src/tools/org/h2", "java.lang.System");
parser.parse("src/tools/org/h2", "java.util.Arrays");
parser.parse("src/tools", "org.h2.java.TestApp");
PrintWriter w = new PrintWriter(System.out);
parser.writeHeader(w);
parser.writeSource(w);
w.flush();
w = new PrintWriter(new FileWriter("bin/test.cpp"));
parser.writeHeader(w);
parser.writeSource(w);
w.close();
}
