Ignore:
Timestamp:
11/04/10 11:24:11 (14 years ago)
Author:
zeiss
Message:
 
Location:
trunk/de.ugoe.cs.swe.bnftools.ebnf.ui/src/de/ugoe/cs/swe/bnftools/ui/formatter
Files:
1 added
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/de.ugoe.cs.swe.bnftools.ebnf.ui/src/de/ugoe/cs/swe/bnftools/ui/formatter/EbnfFormatterVisitor.java

    r34 r37  
    6969        } 
    7070 
    71         private boolean isCommentNode(LeafNode node) { 
     71        protected boolean isCommentNode(LeafNode node) { 
    7272                if ((node.getText().trim().startsWith("//") || node.getText().trim().startsWith("/*")) && (node.isHidden())) 
    7373                        return true; 
     
    7575        } 
    7676         
    77         private void collectAllComments(CompositeNode node) { 
     77        protected void collectAllComments(CompositeNode node) { 
    7878                for (int i=0; i < node.getChildren().size(); i++) { 
    7979                        AbstractNode currentNode = node.getChildren().get(i); 
     
    9191        } 
    9292 
    93         private boolean isSingleLineComment(String str) { 
     93        protected boolean isSingleLineComment(String str) { 
    9494                if (str.startsWith("//")) 
    9595                        return true; 
     
    9797        } 
    9898         
    99         private boolean isMultiLineComment(String str) { 
     99        protected boolean isMultiLineComment(String str) { 
    100100                if (str.startsWith("/*")) 
    101101                        return true; 
     
    103103        } 
    104104 
    105         private boolean isWhitespace(char ch) { 
     105        protected boolean isWhitespace(char ch) { 
    106106                if ((ch==' ') || (ch == '\t') || (ch == '\n') || (ch == '\r')) 
    107107                        return true; 
     
    109109        } 
    110110         
    111         private void skipWhitespacesOriginalText() { 
     111        protected void skipWhitespacesOriginalText() { 
    112112                while (bufferPositionOriginalText < originalText.length() && isWhitespace(originalText.charAt(bufferPositionOriginalText))) { 
    113113                        bufferPositionOriginalText++; 
     
    115115        } 
    116116 
    117         private void skipWhitespacesFormattedText(StringBuffer result) { 
     117        protected void skipWhitespacesFormattedText(StringBuffer result) { 
    118118                while (bufferPositionFormattedText < formattedText.length() && isWhitespace(formattedText.charAt(bufferPositionFormattedText))) { 
    119119                        result.append(formattedText.substring(bufferPositionFormattedText, bufferPositionFormattedText+1)); 
     
    122122        } 
    123123 
    124         private boolean isSingleLineCommentNext(String str, int position) { 
     124        protected boolean isSingleLineCommentNext(String str, int position) { 
    125125                if ((str.charAt(position) == '/') && (str.charAt(position) == '/')) 
    126126                        return true; 
     
    128128        } 
    129129         
    130         private boolean isMultiLineCommentNext(String str, int position) { 
     130        protected boolean isMultiLineCommentNext(String str, int position) { 
    131131                if ((str.charAt(position) == '/') && (str.charAt(position) == '*')) 
    132132                        return true; 
     
    134134        } 
    135135                 
    136         private boolean isCommentNext(String str, int position) { 
     136        protected boolean isCommentNext(String str, int position) { 
    137137                if (isSingleLineCommentNext(str, position) || isMultiLineCommentNext(str, position)) 
    138138                        return true; 
     
    141141        } 
    142142         
    143         private String scanBackWhitespaces(String str, int position) { 
     143        protected String scanBackWhitespaces(String str, int position) { 
    144144                StringBuffer whiteSpaces = new StringBuffer(); 
    145145                int currentPosition = position; 
     
    151151        } 
    152152         
    153         private String stripEndingNewline(String str) { 
     153        protected String stripEndingNewline(String str) { 
    154154                int position = str.length() - 1; 
    155155                while ((str.charAt(position) == '\n') || (str.charAt(position) == '\r')) { 
     
    159159        } 
    160160         
    161         private int scanBackNewlinesCount(String str, int position) { 
     161        protected int scanBackNewlinesCount(String str, int position) { 
    162162                int newLinesCount = 0; 
    163163                int currentPosition = position; 
     
    179179        } 
    180180         
    181         private void weaveComments() { 
     181        protected void weaveComments() { 
    182182                bufferPositionOriginalText = 0; 
    183183                bufferPositionFormattedTextNoWhitespaces = 0; 
     
    255255        } 
    256256 
    257         private void newLine() { 
     257        protected void newLine() { 
    258258                buf.append("\n"); 
    259259                if ((ruleSpacingStack != null) && (!ruleSpacingStack.empty())) { 
     
    264264        } 
    265265         
    266         private void text(String str) { 
     266        protected void text(String str) { 
    267267                buf.append(str); 
    268268                newLineOffsetCounter += str.length(); 
    269269        } 
    270270 
    271         private void space() { 
     271        protected void space() { 
    272272                buf.append(" "); 
    273273                newLineOffsetCounter++; 
    274274        } 
    275275         
    276         private void spaces(int count) { 
     276        protected void spaces(int count) { 
    277277                for (int i=0; i < count; i++) { 
    278278                        buf.append(" "); 
     
    280280        } 
    281281 
    282         private boolean lastIsClosingParentheses() { 
     282        protected boolean lastIsClosingParentheses() { 
    283283                char ch = buf.toString().charAt(buf.toString().length()-1); 
    284284                if ((ch == ')') || (ch == ']') || (ch == '}')) 
     
    287287        } 
    288288 
    289         private void wrap() { 
     289        protected void wrap() { 
    290290                if ((config.isWrapAfterThreshold()) && (newLineOffsetCounter > config.getWrapThreshold())) { 
    291291                        char last = buf.toString().charAt(buf.toString().length()-1); 
  • trunk/de.ugoe.cs.swe.bnftools.ebnf.ui/src/de/ugoe/cs/swe/bnftools/ui/formatter/EbnfHtmlFormatterVisitor.java

    r34 r37  
    11package de.ugoe.cs.swe.bnftools.ui.formatter; 
    22 
     3import java.util.ArrayList; 
     4import java.util.Iterator; 
     5 
    36import org.eclipse.emf.ecore.EObject; 
     7import org.eclipse.xtext.parsetree.LeafNode; 
     8 
     9import de.ugoe.cs.swe.bnftools.ebnf.EtsiBnf; 
     10import de.ugoe.cs.swe.bnftools.ebnf.SectionHeading; 
    411 
    512public class EbnfHtmlFormatterVisitor extends EbnfFormatterVisitor { 
    613 
     14        private ArrayList<MetaTextEntry> metaTexts = new ArrayList<MetaTextEntry>(); 
     15         
    716        public EbnfHtmlFormatterVisitor(EObject rootNode, FormatterConfig config) { 
    817                super(rootNode, config); 
     
    1120        } 
    1221 
     22        protected void weaveComments() { 
     23                bufferPositionOriginalText = 0; 
     24                bufferPositionFormattedTextNoWhitespaces = 0; 
     25                bufferPositionFormattedText = 0; 
     26                 
     27                StringBuffer result = new StringBuffer(); 
     28                formattedTextNoWhitespaces = buf.toString().replaceAll("[ \t\n\r]", ""); 
     29                formattedText = buf.toString(); 
    1330 
     31                MetaTextEntry currentMetaText = null; 
     32                if (metaTexts.iterator().hasNext()) 
     33                        currentMetaText = metaTexts.iterator().next(); 
     34 
     35                while (bufferPositionFormattedTextNoWhitespaces <= formattedTextNoWhitespaces.length()) { 
     36                        skipWhitespacesOriginalText(); 
     37                        skipWhitespacesFormattedText(result); 
     38                         
     39                        if (!(bufferPositionOriginalText < originalText.length())) 
     40                                break; 
     41                         
     42                        char formattedPositionNoWhitespaces; 
     43                        if (bufferPositionFormattedTextNoWhitespaces == formattedTextNoWhitespaces.length()) { 
     44                                formattedPositionNoWhitespaces = ' '; 
     45                        } else { 
     46                                formattedPositionNoWhitespaces = formattedTextNoWhitespaces.charAt(bufferPositionFormattedTextNoWhitespaces); 
     47                        } 
     48                        char originalPosition = originalText.charAt(bufferPositionOriginalText); 
     49                         
     50                        if (formattedPositionNoWhitespaces != originalPosition) { 
     51                                if (formattedPositionNoWhitespaces == ';') { // formatted text always outputs the optional semicolon, skip it if necessary 
     52                                        bufferPositionFormattedTextNoWhitespaces++; 
     53                                        bufferPositionFormattedText++; 
     54                                } else if (isCommentNext(originalText, bufferPositionOriginalText)) { 
     55                                        LeafNode currentComment = allComments.get(allCommentsPosition);  
     56                                        if (currentComment.getTotalOffset() == bufferPositionOriginalText) { 
     57                                                if (isMultiLineComment(currentComment.getText())) { 
     58                                                        int newLinesCount = scanBackNewlinesCount(originalText, bufferPositionOriginalText-1); 
     59                                                        if (newLinesCount > 0) { 
     60                                                                if (scanBackNewlinesCount(result.toString(), result.toString().length()-1) == 0) { 
     61                                                                        result.append("\n\n"); 
     62                                                                } 
     63                                                                 
     64                                                                result.append(currentComment.getText()); 
     65                                                                result.append("\n"); 
     66                                                        } else { 
     67                                                                String lastWhiteSpaces = scanBackWhitespaces(result.toString(), result.toString().length()-1); 
     68                                                                result.delete(result.toString().length() - lastWhiteSpaces.length(), result.toString().length()); 
     69                                                                result.append(" " + stripEndingNewline(currentComment.getText())); 
     70                                                                result.append(lastWhiteSpaces); 
     71                                                        } 
     72                                                } else if (isSingleLineComment(currentComment.getText())) { 
     73                                                        int newLinesCount = scanBackNewlinesCount(originalText, bufferPositionOriginalText-1); 
     74                                                        String lastWhiteSpaces = scanBackWhitespaces(result.toString(), result.toString().length()-1); 
     75                                                        result.delete(result.toString().length() - lastWhiteSpaces.length(), result.toString().length()); 
     76                                                        if (newLinesCount > 0) { 
     77                                                                result.append("\n\n" + stripEndingNewline(currentComment.getText())); 
     78                                                        } else { 
     79                                                                result.append(" " + stripEndingNewline(currentComment.getText())); 
     80                                                        } 
     81                                                        result.append(lastWhiteSpaces); 
     82                                                } 
     83                                                bufferPositionOriginalText+=currentComment.getLength(); 
     84                                                allCommentsPosition++; 
     85                                        } 
     86                                } else { // disaster handling: return original unformatted text! 
     87                                        System.err.println("Disaster Recovery: returning original text!!"); 
     88                                        buf = new StringBuffer(); 
     89                                        buf.append(originalText); 
     90                                        return; 
     91                                } 
     92                        } else { 
     93                                if ((currentMetaText != null) && (bufferPositionFormattedText >= currentMetaText.getOffset())) { 
     94                                        result.append(currentMetaText.getText()); 
     95                                        metaTexts.remove(currentMetaText); 
     96                                        if (metaTexts.iterator().hasNext()) 
     97                                                currentMetaText = metaTexts.iterator().next(); 
     98                                        else 
     99                                                currentMetaText = null; 
     100                                } 
     101                                 
     102                                result.append(formattedText.substring(bufferPositionFormattedText, bufferPositionFormattedText+1)); 
     103                                bufferPositionOriginalText++; 
     104                                bufferPositionFormattedText++; 
     105                                bufferPositionFormattedTextNoWhitespaces++; 
     106                                 
     107                                if ((currentMetaText != null) && (bufferPositionFormattedText >= currentMetaText.getOffset())) { 
     108                                        result.append(currentMetaText.getText()); 
     109                                        metaTexts.remove(currentMetaText); 
     110                                        if (metaTexts.iterator().hasNext()) 
     111                                                currentMetaText = metaTexts.iterator().next(); 
     112                                        else 
     113                                                currentMetaText = null; 
     114                                } 
     115                        } 
     116                } 
     117                buf = result; 
     118        } 
     119         
     120        protected void metaText(String str) { 
     121                MetaTextEntry metaTextEntry = new MetaTextEntry(str, buf.length()); 
     122                metaTexts.add(metaTextEntry); 
     123        } 
     124 
     125        // ----------------------------------------------------------------------------- 
     126         
     127        protected void visitBefore(SectionHeading node) { 
     128                if (!lastWasSectionHeading && !buf.substring(buf.length()-2).equals("\n\n")) 
     129                        newLine(); 
     130                 
     131                lastWasSectionHeading=true; 
     132                 
     133                metaText("<h1>"); 
     134                text(node.getSectionHeader().replaceAll("[\n\r]", "")); 
     135                metaText("</h1>"); 
     136        } 
     137 
     138        protected void visitAfter(SectionHeading node) { 
     139        } 
     140 
     141        protected void visitAfter(EtsiBnf node) { 
     142                weaveComments(); 
     143        } 
    14144} 
Note: See TracChangeset for help on using the changeset viewer.