Merge branch 'feature/comments' into feature/jastadd-extension

src/main/jastadd/RelAst.relast

@@ -5,7 +5,8 @@ Program ::= GrammarFile *;
 abstract Grammar ::= Declaration*;
 GrammarFile : Grammar ::= <FileName> ;
 
-abstract Declaration;
+abstract Declaration ::= Comment*;
+EmptyDeclaration : Declaration;
 
 TypeDecl:Declaration ::= <Name> <Abstract:boolean>  Component*;
 
@@ -46,4 +47,8 @@ UnnamedRole : Role ;
 rel Role.Type <-> TypeDecl.Role*;
 
 // comments
-Comment : Declaration ::= <Text>;
+abstract Comment ::= <Text>;
+WhitespaceComment : Comment;
+SingleLineComment : Comment;
+MultiLineComment : Comment;
+DocComment : Comment;

src/main/jastadd/backend/AbstractGrammar.jadd

@@ -29,10 +29,14 @@ aspect BackendAbstractGrammar {
     }
   }
 
-  abstract public void Declaration.generateAbstractGrammar(StringBuilder b);
+  public void Declaration.generateAbstractGrammar(StringBuilder b) {
+    for (Comment comment : getCommentList()) {
+      comment.generateAbstractGrammar(b);
+    }
+  }
 
-  public void Comment.generateAbstractGrammar(StringBuilder b) {
-    b.append(getText()).append("\n");
+  public void EmptyDeclaration.generateAbstractGrammar(StringBuilder b) {
+    super.generateAbstractGrammar(b);
   }
 
   public void TypeDecl.generateAbstractGrammar(StringBuilder b) {
@@ -48,7 +52,8 @@ aspect BackendAbstractGrammar {
       b.append(" ");
       component.generateAbstractGrammar(b);
     }
-    b.append(";\n");
+    b.append(";");
+    super.generateAbstractGrammar(b);
   }
 
   public abstract void Component.generateAbstractGrammar(StringBuilder b);
@@ -130,14 +135,17 @@ aspect BackendAbstractGrammar {
     b.append(">");
   }
 
-  abstract public void Relation.generateAbstractGrammar(StringBuilder b);
+  public void Relation.generateAbstractGrammar(StringBuilder b) {
+    super.generateAbstractGrammar(b);
+  }
 
   public void DirectedRelation.generateAbstractGrammar(StringBuilder b) {
     b.append("rel ");
     getSource().generateAbstractGrammar(b);
     b.append(" -> ");
     getTarget().generateAbstractGrammar(b);
-    b.append(";\n");
+    b.append(";");
+    super.generateAbstractGrammar(b);
   }
 
   public void BidirectionalRelation.generateAbstractGrammar(StringBuilder b) {
@@ -145,7 +153,8 @@ aspect BackendAbstractGrammar {
     getLeft().generateAbstractGrammar(b);
     b.append(" <-> ");
     getRight().generateAbstractGrammar(b);
-    b.append(";\n");
+    b.append(";");
+    super.generateAbstractGrammar(b);
   }
 
   abstract public void Role.generateAbstractGrammar(StringBuilder b);
@@ -166,5 +175,22 @@ aspect BackendAbstractGrammar {
     b.append(getType().getName());
   }
 
+  abstract public void Comment.generateAbstractGrammar(StringBuilder b);
+
+  public void WhitespaceComment.generateAbstractGrammar(StringBuilder b) {
+    b.append(getText());
+  }
+
+  public void SingleLineComment.generateAbstractGrammar(StringBuilder b) {
+    b.append("//").append(getText()).append("\n");
+  }
+
+  public void MultiLineComment.generateAbstractGrammar(StringBuilder b) {
+    b.append("/*").append(getText()).append("*/");
+  }
+
+  public void DocComment.generateAbstractGrammar(StringBuilder b) {
+    b.append("/**").append(getText()).append("*/");
+  }
 
 }

src/main/jastadd/parser/RelAst.parser

 GrammarFile goal
-  = declaration.d goal.p     {: p.getDeclarationList().insertChild(d, 0); return p; :}
+  = comment_list.c       {: return new EmptyDeclaration(c); :}
+  | grammar_file
+;
+
+GrammarFile grammar_file
+  = declaration.d grammar_file.f {: f.getDeclarationList().insertChild(d, 0); return f; :}
   |                              {: return new GrammarFile(); :}
 ;
 
 Declaration declaration
-  = type_decl
-  | relation
-  | comment
+  = type_decl.d comment_list.c {: d.setCommentList(c); return d; :}
+  | relation.r  comment_list.c {: r.setCommentList(c); return r; :}
+;
+
+// this method would be create by the JAstAddParser from a usage of
+// 'comment+' in a rule, but only for the standard list class 'List'.
+JastAddList comment_list
+  = comment.n {: return new JastAddList().add(n); :}
+  | comment_list.l comment.n {: return l.add(n); :}
 ;
 
 Comment comment
-  = COMMENT  {: return new Comment(COMMENT); :};
+  = WHITESPACE.c        {: return new WhitespaceComment(c); :}
+  | MULTILINECOMMENT.c  {: return new MultiLineComment(c.substring(2,c.length()-2));  :}
+  | DOCCOMMENT.c        {: return new DocComment(c.substring(3,c.length()-2));        :}
+  | SINGLELINECOMMENT.c {: return new SingleLineComment(c.substring(2)); :}
+;
 
 TypeDecl type_decl
   = ID components_opt.c SCOL

src/main/jastadd/scanner/Header.flex

@@ -13,5 +13,8 @@ import org.jastadd.relast.parser.RelAstParser.Terminals;
 %yylexthrow beaver.Scanner.Exception
 %scanerror RelAstScanner.ScannerError
 
+%x COMMENT
+%s DECLARATION
+
 %line
 %column

src/main/jastadd/scanner/Keywords.flex

-"abstract"   { return sym(Terminals.ABSTRACT); }
-"rel"        { return sym(Terminals.RELATION); }
+<YYINITIAL,DECLARATION> {
+  "abstract"            { yybegin(DECLARATION); return sym(Terminals.ABSTRACT); }
+  "rel"                 { yybegin(DECLARATION); return sym(Terminals.RELATION); }
+}

src/main/jastadd/scanner/Macros.flex

 WhiteSpace        = [ ] | \t | \f | \n | \r | \r\n
 ID                = [a-zA-Z$_][a-zA-Z0-9$_]*
-TraditionalComment   = [/][*][^*]*[*]+([^*/][^*]*[*]+)*[/]
-EndOfLineComment = "//" [^\n\r]*
-Comment = {TraditionalComment} | {EndOfLineComment}
+MultiLineComment  = [/][*][^*]+[*]+([^*/][^*]*[*]+)*[/]
+DocComment        = [/][*][*][^*]*[*]+([^*/][^*]*[*]+)*[/]
+SingleLineComment = [/][/] [^\n\r]* (\n | \r | \r\n)

src/main/jastadd/scanner/RulesPostamble.flex

-{ID}         { return sym(Terminals.ID); }
-<<EOF>>      { return sym(Terminals.EOF); }
-
+<YYINITIAL,DECLARATION> {
+  {ID}                  { yybegin(DECLARATION); return sym(Terminals.ID); }
   [^]                   { throw new ScannerError((yyline+1) +"," + (yycolumn+1) + ": Illegal character <"+yytext()+">"); }
+}
+<YYINITIAL,DECLARATION,COMMENT> {
+  <<EOF>>               { return sym(Terminals.EOF); }
+}

src/main/jastadd/scanner/RulesPreamble.flex

 
 %%
 
+<DECLARATION> {
   {WhiteSpace}          { /* ignore */ }
-{Comment}    { return sym(Terminals.COMMENT); }
+  {MultiLineComment}    { /* ignore */ }
+  {DocComment}          { /* ignore */ }
+  {SingleLineComment}   { /* ignore */ }
+}
+
+<YYINITIAL,COMMENT> {
+  {WhiteSpace}+         { yybegin(YYINITIAL); return sym(Terminals.WHITESPACE); }
+  {MultiLineComment}    { yybegin(YYINITIAL); return sym(Terminals.MULTILINECOMMENT); }
+  {DocComment}          { yybegin(YYINITIAL); return sym(Terminals.DOCCOMMENT); }
+  {SingleLineComment}   { yybegin(YYINITIAL); return sym(Terminals.SINGLELINECOMMENT); }
+}

src/main/jastadd/scanner/Symbols.flex

-";"          { return sym(Terminals.SCOL); }
-":"          { return sym(Terminals.COL); }
-"::="        { return sym(Terminals.ASSIGN); }
-"*"          { return sym(Terminals.STAR); }
-"."          { return sym(Terminals.DOT); }
-","          { return sym(Terminals.COMMA); }
-"<"          { return sym(Terminals.LT); }
-">"          { return sym(Terminals.GT); }
-"["          { return sym(Terminals.LBRACKET); }
-"]"          { return sym(Terminals.RBRACKET); }
-"/"          { return sym(Terminals.SLASH); }
-"?"          { return sym(Terminals.QUESTION_MARK); }
-"->"         { return sym(Terminals.RIGHT); }
-"<-"         { return sym(Terminals.LEFT); }
-"<->"        { return sym(Terminals.BIDIRECTIONAL); }
+<YYINITIAL,DECLARATION> {
+  ";"                   { yybegin(COMMENT);     return sym(Terminals.SCOL); }
+  ":"                   { yybegin(DECLARATION); return sym(Terminals.COL); }
+  "::="                 { yybegin(DECLARATION); return sym(Terminals.ASSIGN); }
+  "*"                   { yybegin(DECLARATION); return sym(Terminals.STAR); }
+  "."                   { yybegin(DECLARATION); return sym(Terminals.DOT); }
+  ","                   { yybegin(DECLARATION); return sym(Terminals.COMMA); }
+  "<"                   { yybegin(DECLARATION); return sym(Terminals.LT); }
+  ">"                   { yybegin(DECLARATION); return sym(Terminals.GT); }
+  "["                   { yybegin(DECLARATION); return sym(Terminals.LBRACKET); }
+  "]"                   { yybegin(DECLARATION); return sym(Terminals.RBRACKET); }
+  "/"                   { yybegin(DECLARATION); return sym(Terminals.SLASH); }
+  "?"                   { yybegin(DECLARATION); return sym(Terminals.QUESTION_MARK); }
+  "->"                  { yybegin(DECLARATION); return sym(Terminals.RIGHT); }
+  "<-"                  { yybegin(DECLARATION); return sym(Terminals.LEFT); }
+  "<->"                 { yybegin(DECLARATION); return sym(Terminals.BIDIRECTIONAL); }
+}