Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.jruby.ast.util;
  
  import java.io.File;
  import java.util.List;
  import java.util.Locale;
  
 
 public class SexpMaker {
     private interface Builder {
         public Builder append(String str);
         public Builder append(char ch);
         public Builder append(int i);
         public Builder append(Object o);
         public Builder append(boolean b);
         public Builder append(long l);
         public Builder append(double d);
     }
 
     private static class StringBuilder implements Builder {
         final java.lang.StringBuilder b;
 
         StringBuilder(int size) {
              = new java.lang.StringBuilder(size);
         }
 
         @Override
         public Builder append(Object o) {
             append(o.toString());
             return this;
         }
 
         @Override
         public Builder append(String str) {
             .append(str);
             return this;
         }
 
         @Override
         public Builder append(boolean bool) {
             .append(bool);
             return this;
         }
 
         @Override
         public Builder append(char ch) {
             .append(ch);
             return this;
         }
 
         @Override
         public Builder append(int i) {
             .append(i);
             return this;
         }
 
        @Override
        public Builder append(long l) {
            .append(l);
            return this;
        }
        @Override
        public Builder append(double d) {
            .append(d);
            return this;
        }
    }
    private static class DigestBuilder implements Builder {
        MessageDigest d;
        DigestBuilder(MessageDigest digest) {
            this. = digest;
        }
        @Override
        public Builder append(Object o) {
            append(o.toString());
            return this;
        }
        @Override
        public Builder append(String str) {
            .update(str.getBytes());
            return this;
        }
        @Override
        public Builder append(boolean b) {
            append((byte) (b ? 1 : 0));
            return this;
        }
        @Override
        public Builder append(char ch) {
            .update((byte)(ch >> 8));
            .update((byte)(ch));
            return this;
        }
        @Override
        public Builder append(int i) {
            append((char) (i >> 16));
            append((chari);
            return this;
        }
        @Override
        public Builder append(long l) {
            append((int) (l >> 32));
            append((intl);
            return this;
        }
        @Override
        public Builder append(double d) {
            append(Double.doubleToLongBits(d));
            return this;
        }
    }
    
    public static String create(Node node) {
        Builder sb = new StringBuilder(100);
        process(sbnode);
        return sb.toString();
    }
    public static String create(String methodNameNode argsNodeNode body) {
        Builder sb = new StringBuilder(100);
        processMethod(sbmethodNameargsNodebody);
        return sb.toString();
    }
    public static String sha1(String methodNameNode argsNodeNode body) {
        MessageDigest sha1;
        try {
            sha1 = MessageDigest.getInstance("SHA1");
        } catch (NoSuchAlgorithmException nsae) {
            throw new RuntimeException(nsae);
        }
        DigestBuilder db = new DigestBuilder(sha1);
        processMethod(dbmethodNameargsNodebody);
        byte[] digest = db.d.digest();
        return new String(ConvertBytes.twosComplementToHexBytes(digestfalse));
    }
    private static void processMethod(Builder sbString methodNameNode argsNodeNode body) {
        sb.append("(method ").append(methodName).append(' ');
        // JRUBY-4301, include filename and line in sexp
        sb.append("(file ").append(new File(body.getPosition().getFile()).getName()).append(") ");
        sb.append("(line ").append(body.getPosition().getStartLine()).append(") ");
        process(sbargsNode);
        sb.append(' ');
        process(sbbody);
        sb.append(')');
    }

    
process each node by printing out '(' name data child* ')'

Parameters:
node
    private static void process(Builder sbNode node) {
        if (node == null) {
            sb.append("null");
            return;
        }
        sb.append('(');
        shortName(sbnode);
        leafInfo(sbnode);
        List<Nodenodes = node.childNodes();
        for (int i = 0; i < nodes.size(); i++) {
            Node child = nodes.get(i);
            sb.append(' ');
            process(sbchild);
        }
        sb.append(')');
    }
    private static void shortName(Builder sbNode node) {
        sb.append(node.getNodeType().simpleName());
    }

    
Extra information that is not child nodes, but actual leaf data.

Parameters:
node
    private static void leafInfo(Builder sbNode node) {
        switch (node.getNodeType()) {
            case aliasNode(sb, (AliasNodenode); break;
            case argumentNode(sb, (ArgumentNodenode); break;
            case attrAssignNode(sb, (AttrAssignNodenode); break;
            case backRefNode(sb, (BackRefNodenode); break;
            case bignumNode(sb, (BignumNodenode); break;
            case blockArgNode(sb, (BlockArgNodenode); break;
            case callNode(sb, (CallNodenode); break;
            case classVarAsgnNode(sb, (ClassVarAsgnNodenode); break;
            case classVarDeclNode(sb, (ClassVarDeclNodenode); break;
            case classVarNode(sb, (ClassVarNodenode); break;
            case colon2Node(sb, (Colon2Nodenode); break;
            case colon3Node(sb, (Colon3Nodenode); break;
            case constDeclNode(sb, (ConstDeclNodenode); break;
            case constNode(sb, (ConstNodenode); break;
            case dAsgnNode(sb, (DAsgnNodenode); break;
            case dotNode(sb, (DotNodenode); break;
            case dRegexpNode(sb, (DRegexpNodenode); break;
            case dVarNode(sb, (DVarNodenode); break;
            case fCallNode(sb, (FCallNodenode); break;
            case fixnumNode(sb, (FixnumNodenode); break;
            case flipNode(sb, (FlipNodenode); break;
            case floatNode(sb, (FloatNodenode); break;
            case globalAsgnNode(sb, (GlobalAsgnNodenode); break;
            case globalVarNode(sb, (GlobalVarNodenode); break;
            case instAsgnNode(sb, (InstAsgnNodenode); break;
            case instVarNode(sb, (InstVarNodenode); break;
            case localAsgnNode(sb, (LocalAsgnNodenode); break;
            case localVarNode(sb, (LocalVarNodenode); break;
            case nthRefNode(sb, (NthRefNodenode); break;
            case opAsgnNode(sb, (OpAsgnNodenode); break;
            case opElementAsgnNode(sb, (OpElementAsgnNodenode); break;
            case regexpNode(sb, (RegexpNodenode); break;
            case strNode(sb, (StrNodenode); break;
            case symbolNode(sb, (SymbolNodenode); break;
            case undefNode(sb, (UndefNodenode); break;
            case valiasNode(sb, (VAliasNodenode); break;
            case vcallNode(sb, (VCallNodenode); break;
            case xStrNode(sb, (XStrNodenode); break;
            /* these do nothing
            case ANDNODE:
            case ARGSCATNODE:
            case ARGSPUSHNODE:
            case ARRAYNODE:
            case BEGINNODE:
            case BLOCKNODE:
            case BLOCKPASSNODE:
            case BREAKNODE:
            case CASENODE:
            case CLASSNODE:
            case DEFINEDNODE:
            case DEFNNODE:
            case DEFSNODE:
            case DSTRNODE:
            case DSYMBOLNODE:
            case DXSTRNODE:
            case ENSURENODE:
            case EVSTRNODE:
            case FALSENODE:
            case FORNODE:
            case HASHNODE:
            case IFNODE:
            case ITERNODE:
            case MATCH2NODE:
            case MATCH3NODE:
            case MATCHNODE:
            case MODULENODE:
            case MULTIPLEASGNNODE:
            case NEWLINENODE:
            case NEXTNODE:
            case NILNODE:
            case NOTNODE:
            case OPASGNORNODE:
            case OPASGNANDNODE:
            case ORNODE:
            case PREEXENODE:
            case POSTEXENODE:
            case REDONODE:
            case RESCUEBODYNODE:
            case RESCUENODE:
            case RETRYNODE:
            case RETURNNODE:
            case ROOTNODE:
            case SCLASSNODE:
            case SELFNODE:
            case SPLATNODE:
            case SUPERNODE:
            case SVALUENODE:
            case TOARYNODE:
            case TRUENODE:
            case UNTILNODE:
            case WHENNODE:
            case WHILENODE:
            case YIELDNODE:
            case ZARRAYNODE:
            case ZSUPERNODE:
                noDataContents(node);
                break;
            */
            default:
        }
    }
    private static void xStrNode(Builder sbXStrNode node) {
        sb.append(" '").append(node.getValue()).append('\'');
    }
    private static void vcallNode(Builder sbVCallNode node) {
        sb.append(' ').append(node.getName());
    }
    private static void valiasNode(Builder sbVAliasNode node) {
        sb.append(' ').append(node.getOldName()).append(node.getNewName());
    }
    private static void undefNode(Builder sbUndefNode node) {
        sb.append(' ').append(node.getName());
    }
    private static void strNode(Builder sbStrNode node) {
        if (node instanceof FileNode) {
            // don't put the filename in, since it can vary based on filesystem
            // layout and does not change behavior directly
            sb.append(" __FILE__");
        } else {
            sb.append(" '").append(node.getValue()).append('\'');
        }
    }
    private static void regexpNode(Builder sbRegexpNode node) {
        sb.append(' ').append(node.getValue()).append(' ').append(node.getOptions());
    }
    private static void opElementAsgnNode(Builder sbOpElementAsgnNode node) {
        sb.append(' ').append(node.getOperatorName());
    }
    private static void nthRefNode(Builder sbNthRefNode node) {
        sb.append(' ').append(node.getMatchNumber());
    }
    private static void localAsgnNode(Builder sbLocalAsgnNode node) {
        sb.append(' ').append(node.getName());
    }
    private static void instVarNode(Builder sbInstVarNode node) {
        sb.append(' ').append(node.getName());
    }
    private static void instAsgnNode(Builder sbInstAsgnNode node) {
        sb.append(' ').append(node.getName());
    }
    private static void globalVarNode(Builder sbGlobalVarNode node) {
        sb.append(' ').append(node.getName());
    }
    private static void globalAsgnNode(Builder sbGlobalAsgnNode node) {
        sb.append(' ').append(node.getName());
    }
    private static void floatNode(Builder sbFloatNode node) {
        sb.append(' ').append(node.getValue());
    }
    private static void flipNode(Builder sbFlipNode node) {
        sb.append(' ').append(node.isExclusive());
    }
    private static void fixnumNode(Builder sbFixnumNode node) {
        sb.append(' ').append(node.getValue());
    }
    private static void fCallNode(Builder sbFCallNode node) {
        sb.append(' ').append(node.getName());
    }
    private static void dVarNode(Builder sbDVarNode node) {
        sb.append(' ').append(node.getName());
    }
    private static void blockArgNode(Builder sbBlockArgNode node) {
        sb.append(' ').append(node.getName());
    }
    private static void backRefNode(Builder sbBackRefNode node) {
        sb.append(' ').append(node.getType());
    }
    private static void symbolNode(Builder sbSymbolNode node) {
        sb.append(' ').append(node.getName());
    }
    private static void localVarNode(Builder sbLocalVarNode node) {
        sb.append(' ').append(node.getName());
    }
    private static void argumentNode(Builder sbArgumentNode node) {
        sb.append(' ').append(node.getName());
    }
    private static void dRegexpNode(Builder sbDRegexpNode node) {
        sb.append(' ').append(node.getOnce()).append(' ').append(node.getOptions());
    }
    private static void dotNode(Builder sbDotNode node) {
        sb.append(' ').append(node.isExclusive()).append(' ').append(node.isLiteral());
    }
    private static void dAsgnNode(Builder sbDAsgnNode node) {
        sb.append(' ').append(node.getName());
    }
    private static void constNode(Builder sbConstNode node) {
        sb.append(' ').append(node.getName());
    }
    private static void constDeclNode(Builder sbConstDeclNode node) {
        sb.append(' ').append(node.getName());
    }
    private static void colon3Node(Builder sbColon3Node node) {
        sb.append(' ').append(node.getName());
    }
    private static void colon2Node(Builder sbColon2Node node) {
        sb.append(' ').append(node.getName());
    }
    private static void classVarNode(Builder sbClassVarNode node) {
        sb.append(' ').append(node.getName());
    }
    private static void classVarDeclNode(Builder sbClassVarDeclNode node) {
        sb.append(' ').append(node.getName());
    }
    private static void classVarAsgnNode(Builder sbClassVarAsgnNode node) {
        sb.append(' ').append(node.getName());
    }
    private static void callNode(Builder sbCallNode node) {
        sb.append(' ').append(node.getName());
    }
    private static void bignumNode(Builder sbBignumNode node) {
        sb.append(' ').append(node.getValue());
    }
    private static void attrAssignNode(Builder sbAttrAssignNode node) {
        sb.append(' ').append(node.getName());
    }
    private static void aliasNode(Builder sbAliasNode node) {
        sb.append(' ').append(node.getOldName()).append(node.getNewName());
    }
    private static void opAsgnNode(Builder sbOpAsgnNode node) {
        sb.append(" '").append(node.getOperatorName()).append('\'');
    }
        
New to GrepCode? Check out our FAQ X