package bluej.parser.nodes;

import java.io.Reader;

import bluej.editor.moe.MoeSyntaxDocument;
import bluej.editor.moe.MoeSyntaxDocument.Element;
import bluej.editor.moe.Token;
import bluej.editor.moe.Token.TokenType;
import bluej.parser.ExpressionTypeInfo;
import bluej.parser.DocumentReader;
import bluej.parser.lexer.JavaLexer;
import bluej.parser.lexer.JavaTokenTypes;
import bluej.parser.lexer.LocatableToken;




| A node type for representing comments in the code.
|
| @author Davin McCall
|
public class CommentNode
extends ParsedNode{    
   private static enum Type
   {
      SL_NORMAL(true, TokenType.COMMENT_NORMAL),
      SL_SPECIAL(true, TokenType.COMMENT_SPECIAL),
      ML_NORMAL(false, TokenType.COMMENT_NORMAL),
      ML_JAVADOC(false, TokenType.COMMENT_JAVADOC),
      ML_SPECIAL(false, TokenType.COMMENT_SPECIAL);

       
      private final boolean singleLine;
       
      private final TokenType tokenType;

       
      private Type(boolean singleLine, TokenType tokenType)
       {            
         this.singleLine = singleLine;
           
         this.tokenType = tokenType;         
         }     
      };
   private Type type;
    
   
   public CommentNode(ParsedNode parentNode, LocatableToken token)
   {
      super(parentNode);
      type = getCommentType(token);     
      }
    
   
   


| Determine the comment type from the token.
|
private static Type getCommentType(LocatableToken token)
   {
      String text = token.getText();
      if (token.getType() == JavaTokenTypes.ML_COMMENT) {
         if (text.startsWith("/*#")) {                
            return Type.ML_SPECIAL;             
            }
         if (text.startsWith("/**#")) {                
            return Type.ML_SPECIAL;             
            }
         if (text.startsWith("/**")) {                
            return Type.ML_JAVADOC;             
            }
           
         return Type.ML_NORMAL;         
         }
        
       
      
      if (text.startsWith("//#")) {            
         return Type.SL_SPECIAL;         
         }
        
       
      return Type.SL_NORMAL;     
      }
    
   
   public boolean isJavadocComment()
   {        
      return type == Type.ML_JAVADOC;     
      }
    
    
   
   @Override
   
   public int getNodeType()
   {        
      return NODETYPE_COMMENT;     
      }
    
   

| (non-Javadoc)
| @see bluej.parser.nodes.ParsedNode#getMarkTokensFor(int, int, int, javax.swing.text.Document)
|
public Token getMarkTokensFor(int pos, int length, int nodePos,
           
   MoeSyntaxDocument document)
   {        
      Token tok = new Token(length, type.tokenType);
       
      tok.next = new Token(0, TokenType.END);
       
      return tok;     
      }

   
   @Override
   
   protected boolean marksOwnEnd()
   {        
      return true;     
      }
    
   
   @Override
   
   public int textInserted(MoeSyntaxDocument document, int nodePos, int insPos, int length,
           
   NodeStructureListener listener)
   {        
      
      int newSize = getSize() + length;
      resize(newSize);
      document.scheduleReparse(insPos, length);
       
      return ALL_OK;     
      }

   
   @Override
   
   public int textRemoved(MoeSyntaxDocument document, int nodePos, int delPos, int length,
           
   NodeStructureListener listener)
   {        
      
      int newSize = getSize() - length;
      resize(newSize);
      document.scheduleReparse(delPos, 0);
       
      return ALL_OK;     
      }

   
   @Override
   
   protected int reparseNode(MoeSyntaxDocument document, int nodePos, int offset, int maxParse,
           
   NodeStructureListener listener)
   {        
      
      int pline = document.getDefaultRootElement().getElementIndex(nodePos) + 1;
      int pcol = nodePos - document.getDefaultRootElement().getElement(pline - 1).getStartOffset() + 1;
       
      Reader r = new DocumentReader(document, nodePos, nodePos + getSize());
       
      JavaLexer lexer = new JavaLexer(r, pline, pcol, nodePos);

      LocatableToken commentToken = lexer.nextToken();
      if (commentToken.getType() != JavaTokenTypes.SL_COMMENT &&
      commentToken.getType() != JavaTokenTypes.ML_COMMENT) {            
         return REMOVE_NODE;         
         }
        
      Type newType = getCommentType(commentToken);
      if (type.singleLine && !newType.singleLine) {            
         
         return REMOVE_NODE;         
         }

      else if (!type.singleLine && newType.singleLine) {            
         
         if (getOffsetFromParent() == 0 && getParentNode().isCommentAttached()) {                
            return REMOVE_NODE;             
            }         
         }
        
       
      type = newType;
        
      int newEnd = lineColToPos(document, commentToken.getEndLine(),
      commentToken.getEndColumn());
       
      int newSize = newEnd - nodePos;
      ((MoeSyntaxDocument)document).markSectionParsed(nodePos, newSize);
      if (getSize() != newSize) {
         setSize(newSize);
           
         return NODE_SHRUNK;         
         }
        
       
      return ALL_OK;     
      }
    
    
   
   private static int lineColToPos(MoeSyntaxDocument document, int line, int col)
   {
      Element map = document.getDefaultRootElement();
      Element lineEl = map.getElement(line - 1);
      return lineEl.getStartOffset() + col - 1;     
      }
    
   
   @Override
   
   public ExpressionTypeInfo getExpressionType(int pos, MoeSyntaxDocument document)
   {        
      return null;     
      } 
   }