[Pydev-cvs] org.python.pydev.parser/src/org/python/pydev/parser/visitors ParsingUtils.java,NONE,1.1 NodeUtils.java,NONE,1.1

[Fabio Z. <fa...@us...>]

Update of /cvsroot/pydev/org.python.pydev.parser/src/org/python/pydev/parser/visitors
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv6819/src/org/python/pydev/parser/visitors

Added Files:
	ParsingUtils.java NodeUtils.java 
Log Message:


--- NEW FILE: NodeUtils.java ---
/*
 * Created on 13/07/2005
 */
package org.python.pydev.parser.visitors;

import java.lang.reflect.Field;

import org.python.parser.SimpleNode;
import org.python.parser.ast.Attribute;
import org.python.parser.ast.Call;
import org.python.parser.ast.Expr;
import org.python.parser.ast.FunctionDef;
import org.python.parser.ast.ListComp;
import org.python.parser.ast.Num;
import org.python.parser.ast.Str;
import org.python.parser.ast.stmtType;
import org.python.pydev.core.REF;
import org.python.pydev.core.log.Log;

public class NodeUtils {

    /**
     * @param node
     * @return
     */
    public static String getNodeArgs(SimpleNode node) {
        if(node instanceof FunctionDef){
            FunctionDef f = (FunctionDef)node;
            
            String startPar = "( ";
            StringBuffer buffer = new StringBuffer(startPar);
            
            for (int i = 0; i < f.args.args.length; i++) {
                if(buffer.length() > startPar.length()){
                    buffer.append(", ");
                }
                buffer.append( getRepresentationString(f.args.args[i]) );
            }
            buffer.append(" )");
            return buffer.toString();
        }
        return "";
    }

    /**
     * @param node
     * @return
     */
    public static String getRepresentationString(SimpleNode node) {
            
        if (REF.hasAttr(node, "name")) {
            return REF.getAttrObj(node, "name").toString();
            
        }else if (REF.hasAttr(node, "id")) {
            return REF.getAttrObj(node, "id").toString();
    
        }else if (REF.hasAttr(node, "attr")) {
            return REF.getAttrObj(node, "attr").toString();
    
        }else if (REF.hasAttr(node, "arg")) {
            return REF.getAttrObj(node, "arg").toString();
            
        }else if (node instanceof Call){
            Call call = ((Call)node);
            return getRepresentationString(call.func);
            
        }else if (node instanceof org.python.parser.ast.List || node instanceof ListComp){
            return "[]";
    
        }else if (node instanceof Str){
            return "'"+((Str)node).s+"'";
            
        }else if (node instanceof Num){
            return ((Num)node).n.toString();
            
        }
        
        return null;
    }

    /**
     * @param node
     * @param t
     */
    public static String getNodeDocString(SimpleNode node) {
        //and check if it has a docstring.
        if (REF.hasAttr(node, "body")) {
    
            Field field = REF.getAttr(node, "body");
            try {
                Object obj = field.get(node);
                if (obj instanceof stmtType[]) {
                    stmtType body[] = (stmtType[]) obj;
                    if (body.length > 0) {
                        if (body[0] instanceof Expr) {
                            Expr e = (Expr) body[0];
                            if (e.value instanceof Str) {
                                Str s = (Str) e.value;
                                return s.s;
                            }
                        }
                    }
                }
            } catch (Exception e) {
                Log.log(e);
            }
        }
        return null;
    }

    public static String getFullRepresentationString(SimpleNode node) {
        if(node instanceof Call){
            Call c = (Call) node;
            node = c.func;
            if (REF.hasAttr(node, "value") && REF.hasAttr(node, "attr")) {
                return getRepresentationString((SimpleNode) REF.getAttrObj(node, "value")) + "." +REF.getAttrObj(node, "attr").toString();
            }
        }
        
        
        if (node instanceof Attribute){
            Attribute a = (Attribute)node;
            return getRepresentationString(a.value) + "."+ a.attr;
        } 
        
        return getRepresentationString(node);
    }

}

--- NEW FILE: ParsingUtils.java ---
/*
 * Created on 13/07/2005
 */
package org.python.pydev.parser.visitors;



public class ParsingUtils {

    /**
     * @param cs the char array we are parsing
     * @param buf used to add the comments contents (out)
     * @param i the # position
     * @return the end of the comments position (end of document or new line char)
     */
    public static int eatComments(char[] cs, StringBuffer buf, int i) {
        while(i < cs.length && cs[i] != '\n' && cs[i] != '\r'){
            buf.append(cs[i]);
            i++;
        }
        if(i < cs.length)
            buf.append(cs[i]);
    
        return i;
    }
    
    /**
     * @param cs the char array we are parsing
     * @param buf used to add the token contents (out)
     * @param i the start of the token
     * @return the end of the token position (end of document or new line char or whitespace)
     */
    public static int eatToken(char[] cs, StringBuffer buf, int i) {
        while(i < cs.length && Character.isSpace(cs[i])){
            buf.append(cs[i]);
            i++;
        }
        if(i < cs.length)
            buf.append(cs[i]);
        
        return i;
    }

    /**
     * @param cs the char array we are parsing
     * @param buf used to add the literal contents (out)
     * @param i the ' or " position
     * @return the end of the literal position (or end of document)
     */
    public static int eatLiterals(char[] cs, StringBuffer buf, int i) {
        //ok, current pos is ' or "
        //check if we're starting a single or multiline comment...
        char curr = cs[i];
        
        if(curr != '"' && curr != '\''){
            throw new RuntimeException("Wrong location to eat literals. Expecting ' or \" ");
        }
        
        boolean multi = isMultiLiteral(cs, i, curr);
        
        int j;
        if(multi){
            j = findNextMulti(cs, i+3, curr);
        }else{
            j = findNextSingle(cs, i+1, curr);
        }
        
        for (int k = i; k < cs.length && k <= j; k++) {
            buf.append(cs[k]);
        }
        return j;
        
    }

    /**
     * @param cs the char array we are parsing
     * @param buf used to add the comments contents (out)
     * @param i the ' or " position
     * @return the end of the literal position (or end of document)
     */
    public static int eatPar(char[] cs, int i, StringBuffer buf) {
        char c = ' ';
        StringBuffer locBuf = new StringBuffer();
        
        int j = i+1;
        while(j < cs.length && (c = cs[j]) != ')'){
            
            j++;
            
            if(c == '\'' || c == '"'){ //ignore comments or multiline comments...
                j = ParsingUtils.eatLiterals( cs, locBuf, j-1)+1;
                
            }else if(c == '#'){
                j = ParsingUtils.eatComments(cs, locBuf, j-1)+1;
                
            }else if( c == '('){ //open another par.
                j = eatPar(cs, j-1, locBuf)+1;
            
            }else{

                locBuf.append(c);
            }
        }
        return j;
    }

    
    /**
     * @param cs
     * @param i
     */
    public static int findNextSingle(char[] cs, int i, char curr) {
        while(i < cs.length && cs[i] != curr){
            i++;
        }
        return i;
    }

    /**
     * @param cs
     * @param i
     */
    public static int findNextMulti(char[] cs, int i, char curr) {
        while(i+2 < cs.length){
            if (cs[i] == curr && cs[i+1] == curr && cs[i+2] == curr){
                break;
            }
            i++;
        }
        if(cs.length < i+2){
            return cs.length;
        }
        return i+2;
    }

    public static boolean isMultiLiteral(char cs[], int i, char curr){
        if(cs.length <= i + 2){
            return false;
        }
        if(cs[i+1] == curr && cs[i+2] == curr){
            return true;
        }
        return false;
    }

}