Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2003-2007 the original author or authors.
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package org.codehaus.groovy.ast;
 
 import  org.objectweb.asm.Opcodes;
 
 import java.io.File;
 import java.util.*;

Represents a module, which consists typically of a class declaration but could include some imports, some statements and multiple classes intermixed with statements like scripts in Python or Ruby

Author(s):
Jochen Theodorou
James Strachan
Version:
$Revision: 14020 $
 
 public class ModuleNode extends ASTNode implements Opcodes {
 
     private BlockStatement statementBlock = new BlockStatement();
     List classes = new LinkedList();
     private List methods = new ArrayList();
     private List imports = new ArrayList();
     private List importPackages = new ArrayList();
     private Map importIndex = new HashMap();
     private Map staticImportAliases = new HashMap();
     private Map staticImportFields = new LinkedHashMap();
     private Map staticImportClasses = new LinkedHashMap();
     private CompileUnit unit;
     private String packageName;
     private String description;
     private boolean createClassForStatements = true;
     private transient SourceUnit context;
     private boolean importsResolved = false;
     private static final String[] EMPTY_STRING_ARRAY = new String[] { /* class names, not qualified */ };
 
 
     public ModuleNode (SourceUnit context ) {
         this. = context;
     }
 
     public ModuleNode (CompileUnit unit) {
         this. = unit;
     }
 
     public BlockStatement getStatementBlock() {
         return ;
     }
 
     public List getMethods() {
         return ;
     }
 
     public List getClasses() {
         if ( && (!.isEmpty() || !.isEmpty())) {
             ClassNode mainClass = createStatementsClass();
              = false;
             .add(0, mainClass);
             mainClass.setModule(this);
             addToCompileUnit(mainClass);
         }
         return ;
     }
 
     public List getImports() {
         return ;
     }
 
     public List getImportPackages() {
         return ;
     }

    

Returns:
the class name for the given alias or null if none is available
 
    public ClassNode getImport(String alias) {
        return (ClassNode.get(alias);
    }
    public void addImport(String aliasClassNode type) {
        .add(new ImportNode(typealias));
        .put(aliastype);
    }
    public String[]  addImportPackage(String packageName) {
        .add(packageName);
        return ;
    }
    public void addStatement(Statement node) {
        .addStatement(node);
    }
    public void addClass(ClassNode node) {
        .add(node);
        node.setModule(this);
        addToCompileUnit(node);
    }

    

Parameters:
node
    private void addToCompileUnit(ClassNode node) {
        // register the new class with the compile unit
        if ( != null) {
            .addClass(node);
        }
    }
    public void addMethod(MethodNode node) {
        .add(node);
    }
    public void visit(GroovyCodeVisitor visitor) {
    }
    public String getPackageName() {
        return ;
    }
    public void setPackageName(String packageName) {
        this. = packageName;
    }
    
    public boolean hasPackageName(){
        return this. != null;
    }
    public SourceUnit getContext() {
        return ;
    }

    

Returns:
the underlying character stream description
    public String getDescription() {
        if != null )
        {
            return .getName();
        }
        else
        {
            return this.;
        }
    }
    public void setDescription(String description) {
        // DEPRECATED -- context.getName() is now sufficient
        this. = description;
    }
    public CompileUnit getUnit() {
        return ;
    }
    void setUnit(CompileUnit unit) {
        this. = unit;
    }
    protected ClassNode createStatementsClass() {
        String name = getPackageName();
        if (name == null) {
            name = "";
        }
        // now lets use the file name to determine the class name
        if (getDescription() == null) {
            throw new RuntimeException("Cannot generate main(String[]) class for statements when we have no file description");
        }
        name += extractClassFromFileDescription();
        String baseClassName = null;
        if ( != nullbaseClassName = .getConfig().getScriptBaseClass();
        ClassNode baseClass = null;
        if (baseClassName!=null) {
            baseClass = ClassHelper.make(baseClassName);
        }
        if (baseClass == null) {
            baseClass = .;
        }
        ClassNode classNode = new ClassNode(name, ACC_PUBLIC, baseClass);
        classNode.setScript(true);
        classNode.setScriptBody(true);
        // return new Foo(new ShellContext(args)).run()
        classNode.addMethod(
            new MethodNode(
                "main",
                ACC_PUBLIC | ACC_STATIC,
                .,
                new Parameter[] { new Parameter(..makeArray(), "args")},
                .,
                new ExpressionStatement(
                    new MethodCallExpression(
                        new ClassExpression(ClassHelper.make(InvokerHelper.class)),
                        "runScript",
                        new ArgumentListExpression(
                                new ClassExpression(classNode),
                                new VariableExpression("args"))))));
        classNode.addMethod(
            new MethodNode("run", ACC_PUBLIC, ...));
        classNode.addConstructor(ACC_PUBLIC, ..new BlockStatement());
        Statement stmt = new ExpressionStatement(
                        new MethodCallExpression(
                            new VariableExpression("super"),
            				"setBinding",
            				new ArgumentListExpression(
                                        new VariableExpression("context"))));
        classNode.addConstructor(
            ACC_PUBLIC,
            new Parameter[] { new Parameter(ClassHelper.make(Binding.class), "context")},
            stmt);
        for (Iterator iter = .iterator(); iter.hasNext();) {
            MethodNode node = (MethodNodeiter.next();
            int modifiers = node.getModifiers();
            if ((modifiers & ACC_ABSTRACT) != 0) {
                throw new RuntimeException(
                    "Cannot use abstract methods in a script, they are only available inside classes. Method: "
                        + node.getName());
            }
            // br: the old logic seems to add static to all def f().... in a script, which makes enclosing
            // inner classes (including closures) in a def function difficult. Comment it out.
            node.setModifiers(modifiers /*| ACC_STATIC*/);
            classNode.addMethod(node);
        }
        return classNode;
    }
        // let's strip off everything after the last '.'
        String answer = getDescription();
        int slashIdx = answer.lastIndexOf('/');
        int separatorIdx = answer.lastIndexOf(.);
        int dotIdx = answer.lastIndexOf('.');
        if (dotIdx > 0 && dotIdx > Math.max(slashIdxseparatorIdx)) {
            answer = answer.substring(0, dotIdx);
        }
        // new let's strip everything up to and including the path separators
        if (slashIdx >= 0) {
            answer = answer.substring(slashIdx + 1);
        }
        // recalculate in case we have already done some stripping
        separatorIdx = answer.lastIndexOf(.);
        if (separatorIdx >= 0) {
            answer = answer.substring(separatorIdx + 1);
        }
        return answer;
    }
    public boolean isEmpty() {
        return .isEmpty() && .getStatements().isEmpty();
    }
    
    public void sortClasses(){
    	if (isEmpty()) return;
    	List classes = getClasses();
    	LinkedList sorted = new LinkedList();
    	int level=1;
    	while (!classes.isEmpty()) {
	    	for (Iterator cni = classes.iterator(); cni.hasNext();) {
				ClassNode cn = (ClassNodecni.next();
				ClassNode sn = cn;
				for (int i=0; sn!=null && i<leveli++) sn = sn.getSuperClass();
				if (sn!=null && sn.isPrimaryClassNode()) continue;
				cni.remove();
				sorted.addLast(cn);
			}
	    	level++;
    	}
    	this. = sorted;
    }
    public boolean hasImportsResolved() {
        return ;
    }
    public void setImportsResolved(boolean importsResolved) {
        this. = importsResolved;
    }
    public Map getStaticImportAliases() {
        return ;
    }
    public Map getStaticImportClasses() {
        return ;
    }
    public Map getStaticImportFields() {
        return ;
    }
    public void addStaticMethodOrField(ClassNode typeString fieldNameString alias) {
        .put(aliastype);
        .put(aliasfieldName);
    }
    public void addStaticImportClass(String nameClassNode type) {
        .put(nametype);
    }
New to GrepCode? Check out our FAQ X