Changeset 21 in default

Timestamp:

11/01/10 17:17:05 (14 years ago)

Author:

zeiss

Message:

 

File:

• trunk/de.ugoe.cs.swe.bnftools.ebnf.ui/src/de/ugoe/cs/swe/bnftools/ui/formatter/EbnfFormatterVisitor.java (modified) (6 diffs)

trunk/de.ugoe.cs.swe.bnftools.ebnf.ui/src/de/ugoe/cs/swe/bnftools/ui/formatter/EbnfFormatterVisitor.java

@@ -1 +1 @@
 package de.ugoe.cs.swe.bnftools.ui.formatter;
+
+import java.util.ArrayList;
 
 import org.eclipse.emf.common.util.EList;
 import org.eclipse.emf.ecore.EObject;
+import org.eclipse.xtext.parsetree.AbstractNode;
+import org.eclipse.xtext.parsetree.CompositeNode;
+import org.eclipse.xtext.parsetree.LeafNode;
+import org.eclipse.xtext.parsetree.NodeAdapter;
+import org.eclipse.xtext.parsetree.NodeUtil;
 
 import de.ugoe.cs.swe.bnftools.ebnf.Atom;
@@ -31 +38 @@
         private StringBuffer buf;
         private FormatterConfig config;
-
+        private int bufferPosition = 0;
+        private int bufferPositionOriginalText = 0;
+        private int commentPosition = 0;
+        private int allCommentsPosition = 0;
+        private ArrayList<LeafNode> allComments = new ArrayList<LeafNode>();
+        private ArrayList<String> collectedComments = new ArrayList<String>();
+        
         private boolean lastWasSectionHeading=false;
+        private CompositeNode parserEtsiBnfNode;
+        private String originalText;
+        private String originalTextNoWhitespaces;
+        private int bufferPositionFormattedText;
+        private String formattedText;
+        private String bufNoWhitespaces;
         
         public EbnfFormatterVisitor(EObject rootNode, FormatterConfig config) {
@@ -49 +68 @@
         }
 
+        private boolean isCommentNode(LeafNode node) {
+                if ((node.getText().trim().startsWith("//") || node.getText().trim().startsWith("/*")) && (node.isHidden()))
+                        return true;
+                return false;
+        }
+        
+        private void collectAllComments(CompositeNode node) {
+                for (int i=0; i < node.getChildren().size(); i++) {
+                        AbstractNode currentNode = node.getChildren().get(i);
+                        if (currentNode instanceof LeafNode) {
+                                LeafNode leafNode = (LeafNode) currentNode;
+                                if (isCommentNode(leafNode)) {
+                                        allComments.add(leafNode);
+                                } 
+                        }
+                        
+                        if (currentNode instanceof CompositeNode) {
+                                collectAllComments((CompositeNode) currentNode);
+                        }
+                }
+        }
+
+//      private ArrayList<String> collectComments(CompositeNode node) {
+//              collectedComments.clear();
+////            System.out.println(node);
+////            System.out.println(node.serialize());
+////            searchSubTree(node);
+//              return collectedComments;
+//      }
+        
+        private boolean isSingleLineComment(String str) {
+                if (str.startsWith("//"))
+                        return true;
+                return false;
+        }
+        
+        private boolean isMultiLineComment(String str) {
+                if (str.startsWith("/*"))
+                        return true;
+                return false;
+        }
+
+        private boolean isWhitespace(char ch) {
+                if ((ch==' ') || (ch == '\t') || (ch == '\n') || (ch == '\r'))
+                        return true;
+                return false;
+        }
+        
+        private void skipWhitespacesOriginalText() {
+                while (isWhitespace(originalText.charAt(bufferPositionOriginalText))) {
+                        bufferPositionOriginalText++;
+                }
+        }
+
+        private void skipWhitespacesFormattedText(StringBuffer result) {
+                while (isWhitespace(formattedText.charAt(bufferPositionFormattedText))) {
+                        result.append(formattedText.substring(bufferPositionFormattedText, bufferPositionFormattedText+1));
+                        bufferPositionFormattedText++;
+                }
+        }
+
+        private boolean isSingleLineCommentNext(String str, int position) {
+                if ((str.charAt(position) == '/') && (str.charAt(position) == '/'))
+                        return true;
+                return false;
+        }
+        
+        private boolean isMultiLineCommentNext(String str, int position) {
+                if ((str.charAt(position) == '/') && (str.charAt(position) == '*'))
+                        return true;
+                return false;
+        }
+                
+        private boolean isCommentNext(String str, int position) {
+                if (isSingleLineCommentNext(str, position) || isMultiLineCommentNext(str, position))
+                        return true;
+                else
+                        return false;
+        }
+        
+        private void weaveComments() {
+                bufferPosition = 0;
+                bufferPositionOriginalText = 0;
+                bufferPositionFormattedText = 0;
+                
+                StringBuffer result = new StringBuffer();
+                bufNoWhitespaces = buf.toString().replaceAll("[ \t\n\r]", "");
+                formattedText = buf.toString();
+                
+                while (bufferPosition < bufNoWhitespaces.length()) {
+                        skipWhitespacesOriginalText();
+                        skipWhitespacesFormattedText(result);
+
+                        if (bufNoWhitespaces.charAt(bufferPosition) != originalText.charAt(bufferPositionOriginalText)) {
+                                if (isCommentNext(originalText, bufferPositionOriginalText)) {
+                                        LeafNode currentComment = allComments.get(allCommentsPosition); 
+                                        if (currentComment.getTotalOffset() == bufferPositionOriginalText) {
+                                                result.append(currentComment.getText());
+                                                
+                                                if (isMultiLineComment(currentComment.getText())) {
+                                                        result.append("\n");
+                                                } 
+                                                bufferPositionOriginalText+=currentComment.getLength();
+                                                allCommentsPosition++;
+                                        }
+                                }
+                                
+                        } else {
+                                result.append(formattedText.substring(bufferPositionFormattedText, bufferPositionFormattedText+1));
+
+                                bufferPositionOriginalText++;
+                                bufferPositionFormattedText++;
+                                bufferPosition++;
+                        }
+                }
+                buf = result;
+                
+        }
+        
+        private void appendComments(EObject node) {
+//              String currentBuf = buf.toString().replaceAll("[ \t\n\r]", "");
+//              while (bufferPosition < currentBuf.length()) {
+//                      skipWhitespacesOriginalText();
+//                      System.out.print(currentBuf.charAt(bufferPosition));
+//                      System.out.print(originalText.charAt(bufferPositionOriginalText));
+//                      bufferPositionOriginalText++;
+//                      bufferPosition++;
+//              }
+                
+//
+//              ArrayList<String> comments = collectComments(parseTreeNode);
+//              for (int i=0; i < comments.size(); i++) {
+//                      if (isSingleLineComment(comments.get(i))) {
+//                              buf.append(" ");
+//                              buf.append(comments.get(i).trim());
+//                              if (i+1 < comments.size())
+//                                      buf.append("\n");
+//                      } else if (isMultiLineComment(comments.get(i))) {
+//                              buf.append("\n");
+//                              buf.append(comments.get(i));
+//                              if (i+1 < comments.size())
+//                                      buf.append("\n");
+//                      }
+//              }
+                
+        }
+        
         // -----------------------------------------------------------------------------
 
         protected void visitBefore(EtsiBnf node) {
+                parserEtsiBnfNode = NodeUtil.getNodeAdapter(node).getParserNode();
+                collectAllComments(parserEtsiBnfNode);
+                originalText = NodeUtil.getNodeAdapter(node).getParserNode().serialize();
+                originalTextNoWhitespaces = originalText.replaceAll("[ \t\n\r]", "");
+                
+                //System.out.println(allComments.toString());
                 buf.append("grammar " + node.getName());
                 if (node.getType() != null)
                         buf.append(node.getType());
                 buf.append(";");
-                buf.append("\n");
+
+                appendComments(node);
+                
+                buf.append("\n\n");
         }
 
         protected void visitAfter(EtsiBnf node) {
+                weaveComments();
         }
 
         protected void visitBefore(ImportSection node) {
-                buf.append("\n");
         }
 
@@ -135 +310 @@
 
         protected void visitBefore(Import node) {
-                buf.append("import \"" + node.getImportURI() + "\";\n");
+                buf.append("import \"" + node.getImportURI() + "\";");
+                appendComments(node);
+                buf.append("\n");
+                
         }
 
@@ -178 +356 @@
 
         protected void visitAfter(Rule node) {
-                buf.append(";\n");
+                buf.append(";");
+//              appendComments(node);
+                buf.append("\n");
         }
 
@@ -204 +384 @@
                 
                 buf.append(node.getSectionHeader());
+                
+                appendComments(node);
         }