Changeset b32f7a496c511e07158f0d0752addedc2b378328 for org.axdt.as3.test/src/org/axdt/as3/imp/parser/BasicParserTest.java

Timestamp:

06/28/09 23:36:50 (15 months ago)

Author:

mb0 <mb0@…>

Children:

2aa064d78a2c1162da70e2413b7c386278a1473d

Parents:

1567fcce2711ee19e98902f8ef734f1a7dd9731f

git-author:

mb0 <mb0@…> (06/14/09 23:10:19)

git-committer:

mb0 <mb0@…> (06/28/09 23:36:50)

Message:

reworked lexer. lexer helper methods moved to as3 lex helper.
virtual semi insertion should now work reliable. the last lexer update was fubar. i forgot that the probe parser must be called for every token to work.
non-attribute soft keyword terminals are parsed more reliable.
the whole _abbrev and _full rule paths are not needed. we use simple semi insertion on '}' and EOF.
as alternate to _nosif there is now _sif. this change condenses the grammar and ast.
used copied lexer template that is not using deprecated methods.
regex and xml ast now have a common parent.

Files:

• org.axdt.as3.test/src/org/axdt/as3/imp/parser/BasicParserTest.java (modified) (10 diffs)

org.axdt.as3.test/src/org/axdt/as3/imp/parser/BasicParserTest.java

@@ -1 +1 @@
 package org.axdt.as3.imp.parser;
+
+import java.util.ArrayList;
 
 import junit.framework.TestCase;
@@ -10 +12 @@
 import org.axdt.as3.imp.parser.Ast.FunctionExpression;
 import org.axdt.as3.imp.parser.Ast.IDirective;
-import org.axdt.as3.imp.parser.Ast.ImportDirectiveList;
+import org.axdt.as3.imp.parser.Ast.ImportDirectives;
 import org.axdt.as3.imp.parser.Ast.InterfaceDefinition;
 import org.axdt.as3.imp.parser.Ast.Name;
@@ -19 +21 @@
 
 public class BasicParserTest extends TestCase {
+        private AS3Parser parser;
         private Program parse(String content) {
-                return ParseUtil.parse(content);
-        }
-
+                parser = ParseUtil.parser(content);
+                return ParseUtil.parse(parser,0);
+        }
+        private <T extends IDirective> T assertFirstDirective(String string, Class<T> clazz) {
+                parser = ParseUtil.parser(string);
+                Program result = ParseUtil.parse(parser,0);
+                return assertFirstDirective(result, clazz);
+        }
+        @SuppressWarnings("unchecked")
+        private <T extends IDirective> T assertFirstDirective(Program prog, Class<T> clazz) {
+                IDirective directive = null;
+                if (prog != null) {
+                        directive = prog.getDirectives().getDirectiveAt(0);
+                } else {
+                        // TODO gather some info
+                        ArrayList tokens = parser.getIPrsStream().getTokens();
+                        assertNotNull("parser error "+ tokens.toString(),prog);
+                }
+                assertNotNull(directive);
+                assertEquals(clazz, directive.getClass());
+                return (T) directive;
+        }
         public void testPackage() throws Exception {
                 Program prog;
@@ -54 +76 @@
                 prog = parse("package P{} f();");
                 assertEquals(1, prog.getPackages().size());
-                assertEquals(1, prog.getDirectives().size());
+                assertFirstDirective(prog,ExpressionStatement.class);
 
                 // bom works just as expected
@@ -67 +89 @@
                 prog = parse("package P{} package Q{} function f(){}");
                 assertEquals(2, prog.getPackages().size());
-                assertEquals(1, prog.getDirectives().size());
+                assertFirstDirective(prog,FunctionDefinition.class);
                 
                 System.out.print("expected");
@@ -75 +97 @@
 
         public void testNamespace() throws Exception {
-                Program prog;
                 NamespaceDefinition dir;
                 
-                prog = parse("namespace NS1");
-                assertEquals(true, prog.getDirectives().getDirectiveAt(0) instanceof NamespaceDefinition);
-                dir = (NamespaceDefinition) prog.getDirectives().getDirectiveAt(0);
+                dir = assertFirstDirective("namespace NS1",NamespaceDefinition.class);
                 assertEquals("NS1", dir.getName().toString());
                 
-                prog = parse("namespace NS2 = NS1");
-                assertEquals(true, prog.getDirectives().getDirectiveAt(0) instanceof NamespaceDefinition);
-                dir = (NamespaceDefinition) prog.getDirectives().getDirectiveAt(0);
+                dir = assertFirstDirective("namespace NS2 = NS1",NamespaceDefinition.class);
                 assertEquals("NS2", dir.getName().toString());
                 assertEquals("NS1", dir.getAssignment().toString());
                 
-                prog = parse("namespace NS3 = \"http://www.macromedia.com/flash/2005\"");
-                assertEquals(true, prog.getDirectives().getDirectiveAt(0) instanceof NamespaceDefinition);
-                dir = (NamespaceDefinition) prog.getDirectives().getDirectiveAt(0);
+                dir = assertFirstDirective("namespace NS3 = \"http://www.macromedia.com/flash/2005\"",NamespaceDefinition.class);
                 assertEquals("NS3", dir.getName().toString());
                 assertEquals(StringLiteral.class, dir.getAssignment().getClass());
@@ -98 +113 @@
 
         public void testImport() throws Exception {
-                Program prog; ImportDirectiveList list;
-                prog = parse("import A;");
-                assertEquals(ImportDirectiveList.class, prog.getDirectives().getDirectiveAt(0).getClass());
-                prog = parse("import A; import a.b.C; import abc.*;");
-                list = (ImportDirectiveList) prog.getDirectives().getDirectiveAt(0);
+                ImportDirectives list;
+                list = assertFirstDirective("import A;",ImportDirectives.class);
+                assertEquals(1, list.size());
+                list = assertFirstDirective("import A; import a.b.C; import abc.*;",ImportDirectives.class);
                 assertEquals(3, list.size());
                 assertEquals("A", list.getImportDirectiveAt(0).getName().toString());
@@ -112 +126 @@
 
         public void testInterface() throws Exception {
-                Program prog; InterfaceDefinition type;
-                
-                prog = parse("interface A {}");
-                assertEquals(InterfaceDefinition.class, prog.getDirectives().getDirectiveAt(0).getClass());
-                type = (InterfaceDefinition) prog.getDirectives().getDirectiveAt(0);
+                InterfaceDefinition type;
+                
+                type = assertFirstDirective("interface A {}",InterfaceDefinition.class);
                 assertEquals(Name.class, type.getName().getClass());
                 assertEquals(null, type.getBody().getDirectives());
                 
-                prog = parse("interface a.b.C {}");
-                assertEquals(InterfaceDefinition.class, prog.getDirectives().getDirectiveAt(0).getClass());
-                type = (InterfaceDefinition) prog.getDirectives().getDirectiveAt(0);
+                type = assertFirstDirective("interface a.b.C {}",InterfaceDefinition.class);
                 assertEquals(Name.class, type.getName().getClass());
                 assertEquals(null, type.getBody().getDirectives());
                 
-                prog = parse("interface A { function f():A;function g():B;}");
-                assertEquals(InterfaceDefinition.class, prog.getDirectives().getDirectiveAt(0).getClass());
-                type = (InterfaceDefinition) prog.getDirectives().getDirectiveAt(0);
+                type = assertFirstDirective("interface A { function f():A;function g():B;}",InterfaceDefinition.class);
                 assertEquals(2, type.getBody().getDirectives().size());
                 
-                prog = parse("internal interface A {} public interface B{}");
-                assertEquals(AnnotatedDirective.class, prog.getDirectives().getDirectiveAt(0).getClass());
-                assertEquals(AnnotatedDirective.class, prog.getDirectives().getDirectiveAt(1).getClass());
+                assertFirstDirective("internal interface A {}",AnnotatedDirective.class);
+                assertFirstDirective("public interface A {}",AnnotatedDirective.class);
         }
 
         public void testVariable() throws Exception {
-                Program prog; IDirective directive; 
-                
-                prog = parse("var a;");
-                directive = prog.getDirectives().getDirectiveAt(0);
-                assertEquals(VariableDefinition.class, directive.getClass());
-                
-                assertEquals(AnnotatedDirective.class, parse("static var a;").getDirectives().getDirectiveAt(0).getClass());
-                assertEquals(AnnotatedDirective.class, parse("prototype var a;").getDirectives().getDirectiveAt(0).getClass());
-                assertEquals(AnnotatedDirective.class, parse("private var a;").getDirectives().getDirectiveAt(0).getClass());
-                assertEquals(AnnotatedDirective.class, parse("public var a;").getDirectives().getDirectiveAt(0).getClass());
-                assertEquals(AnnotatedDirective.class, parse("protected var a;").getDirectives().getDirectiveAt(0).getClass());
-                assertEquals(AnnotatedDirective.class, parse("internal var a;").getDirectives().getDirectiveAt(0).getClass());
+                assertFirstDirective("var a;",VariableDefinition.class);
+                assertFirstDirective("static var a;",AnnotatedDirective.class);
+                assertFirstDirective("prototype var a;",AnnotatedDirective.class);
+                assertFirstDirective("private var a;",AnnotatedDirective.class);
+                assertFirstDirective("public var a;",AnnotatedDirective.class);
+                assertFirstDirective("protected var a;",AnnotatedDirective.class);
+                assertFirstDirective("internal var a;",AnnotatedDirective.class);
         }
         
         public void testFunction() throws Exception {
-                Program prog; IDirective directive; FunctionDefinition def;
-                prog = parse("function f():void{}");
-                directive = prog.getDirectives().getDirectiveAt(0);
-                assertEquals(FunctionDefinition.class, directive.getClass());
-
-                prog = parse("function f(b:B){a = b;a.c();}");
-                directive = prog.getDirectives().getDirectiveAt(0);
-                def = (FunctionDefinition) directive;
+                IDirective directive; FunctionDefinition def;
+                def = assertFirstDirective("function f():void{}",FunctionDefinition.class);
+
+                def = assertFirstDirective("function f(b:B){a = b;a.c();}",FunctionDefinition.class);
                 assertEquals("f", def.getName().toString());
                 assertEquals(2, def.getBlock().getDirectives().size());
@@ -165 +163 @@
                 assertEquals(null, common.getResultType());
 
-                assertEquals(FunctionDefinition.class, parse("function f(){}").getDirectives().getDirectiveAt(0).getClass());
-                assertEquals(FunctionDefinition.class, parse("function f(...){}").getDirectives().getDirectiveAt(0).getClass());
-                assertEquals(FunctionDefinition.class, parse("function f(...b){}").getDirectives().getDirectiveAt(0).getClass());
-                assertEquals(FunctionDefinition.class, parse("function f(...b:B){}").getDirectives().getDirectiveAt(0).getClass());
-                assertEquals(FunctionDefinition.class, parse("function f(a:A,...b:B){}").getDirectives().getDirectiveAt(0).getClass());
-                
-                assertEquals(AnnotatedDirective.class, parse("static function a(){}").getDirectives().getDirectiveAt(0).getClass());
-                assertEquals(AnnotatedDirective.class, parse("override function a(){}").getDirectives().getDirectiveAt(0).getClass());
-                assertEquals(AnnotatedDirective.class, parse("final function a(){}").getDirectives().getDirectiveAt(0).getClass());
-                assertEquals(AnnotatedDirective.class, parse("private function a(){}").getDirectives().getDirectiveAt(0).getClass());
-                assertEquals(AnnotatedDirective.class, parse("public function a(){}").getDirectives().getDirectiveAt(0).getClass());
-                assertEquals(AnnotatedDirective.class, parse("protected function a(){}").getDirectives().getDirectiveAt(0).getClass());
-                assertEquals(AnnotatedDirective.class, parse("internal function a(){}").getDirectives().getDirectiveAt(0).getClass());
-                assertEquals(AnnotatedDirective.class, parse("prototype function a(){}").getDirectives().getDirectiveAt(0).getClass());
-                assertEquals(AnnotatedDirective.class, parse("native function a(){}").getDirectives().getDirectiveAt(0).getClass());
-                
-                prog = parse("function(b:B){a = b;};");
-                directive = prog.getDirectives().getDirectiveAt(0);
-                assertEquals(ExpressionStatement.class, directive.getClass());
+                def = assertFirstDirective("function f(){}",FunctionDefinition.class);
+                def = assertFirstDirective("function f(...){}",FunctionDefinition.class);
+                def = assertFirstDirective("function f(...b){}",FunctionDefinition.class);
+                def = assertFirstDirective("function f(...b:B){}",FunctionDefinition.class);
+                def = assertFirstDirective("function f(a:A,...b:B){}",FunctionDefinition.class);
+                def = assertFirstDirective("function get f(){}",FunctionDefinition.class);
+                def = assertFirstDirective("function get f(i){}",FunctionDefinition.class);
+                def = assertFirstDirective("function get f(a:A,b:B){}",FunctionDefinition.class);
+                // TODO fix parameter declaration
+                def = assertFirstDirective("function set(){}",FunctionDefinition.class);
+                def = assertFirstDirective("function get(a,b){}",FunctionDefinition.class);
+                def = assertFirstDirective("function get(a:A,b){}",FunctionDefinition.class);
+                def = assertFirstDirective("function get(a:A,b:*){}",FunctionDefinition.class);
+                def = assertFirstDirective("function get(a:A,b:*):C{}",FunctionDefinition.class);
+                def = assertFirstDirective("function get(){}",FunctionDefinition.class);
+                def = assertFirstDirective("function get(a:A){}",FunctionDefinition.class);
+                def = assertFirstDirective("function get(a:A,b:B,c:C):D {}",FunctionDefinition.class);
+                
+                assertFirstDirective("static function a(){}", AnnotatedDirective.class);
+                assertFirstDirective("override function a(){}", AnnotatedDirective.class);
+                assertFirstDirective("final function a(){}", AnnotatedDirective.class);
+                assertFirstDirective("private function a(){}", AnnotatedDirective.class);
+                assertFirstDirective("public function a(){}", AnnotatedDirective.class);
+                assertFirstDirective("protected function a(){}", AnnotatedDirective.class);
+                assertFirstDirective("internal function a(){}", AnnotatedDirective.class);
+                assertFirstDirective("prototype function a(){}", AnnotatedDirective.class);
+                assertFirstDirective("native function a(){}", AnnotatedDirective.class);
+
+                directive = assertFirstDirective("function(b:B){a = b;};", ExpressionStatement.class);
                 assertEquals(FunctionExpression.class, ((ExpressionStatement)directive).getExpression().getClass());
         }
 
         public void testClass() throws Exception {
-                Program prog; ClassDefinition def;
-                prog = parse("class T{}");
-                assertEquals(ClassDefinition.class, prog.getDirectives().getDirectiveAt(0).getClass());
-                prog = parse("class T{function T(){}function S(){}}");
-                def = (ClassDefinition) prog.getDirectives().getDirectiveAt(0);
+                ClassDefinition def;
+                assertFirstDirective("class T{}", ClassDefinition.class);
+                def = assertFirstDirective("class T{function T(){}function S(){}}", ClassDefinition.class);
                 assertEquals("T", def.getName().toString());
                 assertEquals(2, def.getBody().getDirectives().size());
@@ -198 +204 @@
                 assertEquals(FunctionDefinition.class, def.getBody().getDirectives().getDirectiveAt(1).getClass());
                 
-                prog = parse("internal class A {} public class B{} final class C{} dynamic class D{}");
-                assertEquals(AnnotatedDirective.class, prog.getDirectives().getDirectiveAt(0).getClass());
-                assertEquals(AnnotatedDirective.class, prog.getDirectives().getDirectiveAt(1).getClass());
-                assertEquals(AnnotatedDirective.class, prog.getDirectives().getDirectiveAt(2).getClass());
-                assertEquals(AnnotatedDirective.class, prog.getDirectives().getDirectiveAt(3).getClass());
+                assertFirstDirective("internal class A {}", AnnotatedDirective.class);
+                assertFirstDirective("public class A {}", AnnotatedDirective.class);
+                assertFirstDirective("dynamic class A {}", AnnotatedDirective.class);
+                assertFirstDirective("final class A {}", AnnotatedDirective.class);
         }