package bluej.parser.nodes;

import bluej.debugger.gentype.Reflective;
import bluej.editor.moe.MoeSyntaxDocument;
import bluej.parser.ImportsCollection;
import bluej.parser.entity.EntityResolver;
import bluej.parser.entity.JavaEntity;
import bluej.parser.entity.PackageOrClass;
import bluej.parser.entity.TypeEntity;
import bluej.parser.nodes.NodeTree.NodeAndPosition;
import bluej.utility.JavaNames;

import java.util.List;




| A parsed compilation unit node.
|
| @author Davin McCall
|
public class ParsedCUNode
extends IncrementalParsingNode{    
   private EntityResolver parentResolver;
   
   private ImportsCollection imports = new ImportsCollection();

   
   private int size = 0;
    
   
   


| Construct a parsed node for as yet unknown source.
|
public ParsedCUNode()
   {
      super(null);     
      }
    
   
   


| Construct a parsed node for the given document. The node will
| assume its size is 0; the text from the document (if any) should
| be explicitly inserted.
|
public ParsedCUNode(MoeSyntaxDocument document)
   {
      super(null);
       
      size = 0;     
      }
    
   
   


| Set the entity resolver used to resolve symbols.
|
public void setParentResolver(EntityResolver parentResolver)
   {        
      this.parentResolver = parentResolver;     
      }

   
   public ImportsCollection getImports()
   {        
      return imports;     
      }
    
   
   public EntityResolver getParentResolver()
   {        
      return parentResolver;     
      }
    
   
   


| Overridden getSize() which returns the document size.
|
| @see bluej.parser.nodes.ParsedNode#getSize()
|
public int getSize()
   {        
      return size;     
      }

   
   @Override
   
   public void resize(int newSize)
   {        
      size = newSize;     
      }
    
   
   @Override
   
   public void setSize(int newSize)
   {        
      size = newSize;     
      }
    
   
   @Override
   
   protected int doPartialParse(ParseParams params, int state)
   {
      last = params.tokenStream.LA(1);
       
      if (checkBoundary(params, last)) {            
         return PP_PULL_UP_CHILD;         
         }
        
      params.parser.parseCUpart(state);
       
      return PP_OK;     
      };
   @Override
   
   protected boolean isDelimitingNode(NodeAndPosition<ParsedNode> nap)
   {
      
      
      int nt = nap.getNode().getNodeType();
       
      return nt != ParsedNode.NODETYPE_COMMENT;     
      }
    
   
   @Override
   
   protected boolean isNodeEndMarker(int tokenType)
   {        
      return false;     
      }
    
   
   @Override
   
   protected boolean marksOwnEnd()
   {        
      return true;     
      }
    
   
   @Override
   
   public PackageOrClass resolvePackageOrClass(String name, Reflective querySource)
   {
      PackageOrClass poc = super.resolvePackageOrClass(name, querySource);
      if (poc == null) {
         poc = imports.getTypeImport(name);         
         }
      if (poc == null && parentResolver != null && querySource != null) {
         String prefix = JavaNames.getPrefix(querySource.getName());
         String fqName = JavaNames.combineNames(prefix, name);
         poc = parentResolver.resolveQualifiedClass(fqName);         
         }
      if (poc == null) {
         poc = imports.getTypeImportWC(name);         
         }
      if (poc == null && parentResolver != null) {            
         
         poc = parentResolver.resolveQualifiedClass("java.lang." + name);         
         }
      if (poc == null && parentResolver != null) {
         return parentResolver.resolvePackageOrClass(name, querySource);         
         }
       
      return poc;     
      }
    
   
   @Override
   
   public JavaEntity getValueEntity(String name, Reflective querySource)
   {        
      
        
      List<JavaEntity> simports = imports.getStaticImports(name);
       
      for (JavaEntity importType : simports) {
         importType = importType.resolveAsType();
         if (importType == null) {                
            continue;             
            }
         JavaEntity subEnt = importType.getSubentity(name, querySource);
         if (subEnt != null) {
            JavaEntity value = subEnt.resolveAsValue();
            if (value != null) {                    
               return value;                 
               }             
            }         
         }
        
      simports = imports.getStaticWildcardImports();
       
      for (JavaEntity importType : simports) {
         importType = importType.resolveAsType();
         if (importType == null) {                
            continue;             
            }
         JavaEntity subEnt = importType.getSubentity(name, querySource);
         if (subEnt != null) {
            JavaEntity value = subEnt.resolveAsValue();
            if (value != null) {                    
               return value;                 
               }             
            }         
         }
        
      return resolvePackageOrClass(name, querySource);     
      }
    
   
   @Override
   
   public TypeEntity resolveQualifiedClass(String name)
   {
      if (parentResolver != null) {
         return parentResolver.resolveQualifiedClass(name);         
         }
       
      return null;     
      }
    
   
   
   
   
   
   
   
    
   }