Changeset 3624


Ignore:
Timestamp:
Mar 30, 2008, 5:32:50 PM (13 years ago)
Author:
yura
Message:
  • Formatted representation for Expr and Result.
Location:
to-imperative/trunk/java
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • to-imperative/trunk/java/java/org/refal/plus/Expr.java

    r3422 r3624  
    2121
    2222    /*
    23      * Several variables for gathering some statistics about expression
    24      * concatenations. Do not affect Expr operation.
     23     * Several variables for gathering some statistics about expression concatenations. Do not affect Expr operation.
    2524     */
    2625    public static int no_copy = 0;
     
    2827    public static int right_copy = 0;
    2928    public static int both_copy = 0;
    30    
    31     private static final InplaceConcatenator concatenator = new InplaceConcatenator(); 
     29
     30    private static final InplaceConcatenator concatenator = new InplaceConcatenator();
    3231
    3332    private final Comparable<?>[] terms;
     
    3635
    3736    /**
    38      * Constructs expression from a subarray of an array of Comparable<?> objects.
    39      * This is private constructor because it doesn't copy the array and doesn't
    40      * check that there aren't nulls in the array.
     37     * Constructs expression from a subarray of an array of Comparable<?> objects. This is private constructor because
     38     * it doesn't copy the array and doesn't check that there aren't nulls in the array.
    4139     */
    4240    private Expr (Comparable<?>[] ts, int st, int len) {
    43         assert ts != null : "ts="+ts;
    44         //assert 0 <= st && st < ts.length && 0 <= len : "ts.length="+ts.length+", st="+st+", len="+len; 
     41        assert ts != null : "ts=" + ts;
     42        // assert 0 <= st && st < ts.length && 0 <= len : "ts.length="+ts.length+", st="+st+", len="+len;
    4543        terms = ts;
    4644        start = st;
     
    6159     */
    6260    public Expr (Comparable<?> obj) {
    63         assert obj != null : "obj="+obj;
     61        assert obj != null : "obj=" + obj;
    6462        terms = new Comparable[4];
    6563        start = 0;
     
    8987     */
    9088    public Comparable<?> at (int i) {
    91         assert 0 <= i && i < length : "length="+length+", i="+i;
     89        assert 0 <= i && i < length : "length=" + length + ", i=" + i;
    9290        return terms[(start + i) % terms.length];
    9391    }
     
    102100     */
    103101    public Expr subexpr (int i, int len) {
    104         //assert 0 <= i && 0 <= len && i <= length - len : "length="+length+", i="+i+", len="+len;
     102        // assert 0 <= i && 0 <= len && i <= length - len : "length="+length+", i="+i+", len="+len;
    105103        if (len == 0)
    106104            return Expr.empty;
     
    117115     */
    118116    public boolean isSymbolAt (int i) {
    119         assert 0 <= i && i < length : "length="+length+", i="+i;
     117        assert 0 <= i && i < length : "length=" + length + ", i=" + i;
    120118        return !(terms[(start + i) % terms.length] instanceof Expr);
    121119    }
    122    
     120
    123121    /**
    124122     * Compares this expression to the specified object.
    125123     */
    126124    public boolean equals (Object obj) {
    127         /**************************************
     125        /***************************************************************************************************************
    128126         * Check how this affects efficiency!
    129127         */
    130128        // if (this == obj) return true;
    131         /*************************************/
     129        /** ********************************** */
    132130        return (this == obj) || (obj instanceof Expr) && (length == ((Expr) obj).length) && equals((Expr) obj, 0);
    133131    }
    134    
     132
    135133    /**
    136134     * Returns a hash code for this expression.
     
    141139
    142140    /**
    143      * Checks whether this expr equals to the subexpr of another expression
    144      * `expr` starting at index `j`
     141     * Checks whether this expr equals to the subexpr of another expression `expr` starting at index `j`
    145142     *
    146143     * @param expr
     
    150147     */
    151148    public boolean equals (Expr expr, int j) {
    152         assert expr != null : "expr="+expr;
    153         assert 0 <= j && j <= expr.length - length : "length="+length+", expr.length="+expr.length+", j="+j;
     149        assert expr != null : "expr=" + expr;
     150        assert 0 <= j && j <= expr.length - length : "length=" + length + ", expr.length=" + expr.length + ", j=" + j;
    154151        Comparable<?>[] terms1 = expr.terms;
    155152        int tslen1 = terms1.length;
     
    162159            if (!terms[k].equals(terms1[k1]))
    163160                return false;
    164         /***********************************************************************
     161        /***************************************************************************************************************
    165162         * Check how this affects efficiency!
    166163         */
     
    173170
    174171    /**
    175      * Checks whether first term of this expr equals to the term of another
    176      * expression `expr` at position `j`
     172     * Checks whether first term of this expr equals to the term of another expression `expr` at position `j`
    177173     *
    178174     * @param expr
     
    182178     */
    183179    public boolean termEquals (Expr expr, int j) {
    184         assert expr != null : "expr="+expr;
    185         assert 0 < length && 0 <= j && j < expr.length : "length="+length+", expr.length="+expr.length+", j="+j;
     180        assert expr != null : "expr=" + expr;
     181        assert 0 < length && 0 <= j && j < expr.length : "length=" + length + ", expr.length=" + expr.length + ", j="
     182                + j;
    186183        return terms[start].equals(expr.terms[(expr.start + j) % expr.terms.length]);
    187184    }
    188    
     185
    189186    /**
    190187     * Compares this expression with the specified expression for order.
     
    192189    @SuppressWarnings("unchecked")
    193190    public int compareTo (Expr expr) {
    194         assert expr != null : "expr="+expr;
     191        assert expr != null : "expr=" + expr;
    195192        // if (equals(e)) // Check how this affects efficiency!
    196193        // return 0;
     
    207204        int tslen = terms.length;
    208205        int k = start;
    209         for ( ; min_len > 0; min_len--, k = (k + 1) % tslen, k1 = (k1 + 1) % tslen1) {
     206        for (; min_len > 0; min_len--, k = (k + 1) % tslen, k1 = (k1 + 1) % tslen1) {
    210207            Comparable<?> term = terms[k];
    211208            Comparable<?> term1 = terms1[k1];
    212209            int res = RefalRuntime.classCompare(term.getClass(), term1.getClass());
    213210            if (res == 0)
    214                 res = ((Comparable<Comparable<?>>) term).compareTo(term1); // May be CheckCastException 
     211                res = ((Comparable<Comparable<?>>) term).compareTo(term1); // May be CheckCastException
    215212            if (res != 0)
    216213                return res;
     
    218215        return compare_len;
    219216    }
    220    
     217
    221218    private static void arrayCopy (Comparable<?>[] src, int srcStart, Comparable<?>[] dst, int dstStart, int length) {
    222219        assert length > 0;
     
    242239     */
    243240    public static Expr concat (Expr expr1, Expr expr2) {
    244         assert expr1 != null && expr2 != null : "expr1="+expr1+", expr2="+expr2;
     241        assert expr1 != null && expr2 != null : "expr1=" + expr1 + ", expr2=" + expr2;
    245242        int len1 = expr1.length;
    246243        int len2 = expr2.length;
     
    283280     */
    284281    public static Expr concat (Comparable<?> obj1, Comparable<?> obj2) {
    285         assert obj1 != null && obj2 != null : "obj1="+obj1+", obj2="+obj2;
     282        assert obj1 != null && obj2 != null : "obj1=" + obj1 + ", obj2=" + obj2;
    286283        Comparable<?>[] terms = new Comparable[4];
    287284        terms[0] = obj1;
     
    294291     */
    295292    public static Expr concat (Expr expr, Comparable<?> obj) {
    296         assert expr != null && obj != null : "expr="+expr+", obj="+obj;
     293        assert expr != null && obj != null : "expr=" + expr + ", obj=" + obj;
    297294        if (expr.length == 0)
    298295            return new Expr(obj);
     
    301298            right_copy++;
    302299            expr.terms[k] = obj;
    303             return new Expr(expr.terms, expr.start, expr.length+1);
     300            return new Expr(expr.terms, expr.start, expr.length + 1);
    304301        }
    305302        both_copy++;
     
    311308     */
    312309    public static Expr concat (Comparable<?> obj, Expr expr) {
    313         assert obj != null && expr != null : "obj="+obj+", expr="+expr;
     310        assert obj != null && expr != null : "obj=" + obj + ", expr=" + expr;
    314311        if (expr.length == 0)
    315312            return new Expr(obj);
     
    328325     */
    329326    public static Expr fromSequence (CharSequence seq) {
    330         assert seq != null : "seq="+seq;
     327        assert seq != null : "seq=" + seq;
    331328        int len = seq.length();
    332329        Expr.Concatenator ec = concatenator.reinit(len);
     
    337334
    338335    /**
    339      * Creates expression from an array of Comparable<?> objects. Array shouldn't
    340      * contain nulls.
     336     * Creates expression from an array of Comparable<?> objects. Array shouldn't contain nulls.
    341337     */
    342338    public static Expr fromArray (Comparable<?>[] arr) {
    343         assert noNulls(arr) : "arr="+arr;
     339        assert noNulls(arr) : "arr=" + arr;
    344340        int len = arr.length;
    345341        Comparable<?>[] terms = new Comparable[len * 2];
     
    349345
    350346    /**
    351      * Auxiliary method that checks there aren't nulls in a given part of array.
    352      * For use in assertions when creating expressions from arrays.
     347     * Auxiliary method that checks there aren't nulls in a given part of array. For use in assertions when creating
     348     * expressions from arrays.
    353349     */
    354350    private static boolean noNulls (Comparable<?>[] arr) {
     
    359355                return false;
    360356        return true;
     357    }
     358
     359    /**
     360     * Returns the contents of this expr.
     361     */
     362    public Comparable<?>[] toArray () {
     363        Comparable<?>[] arr = new Comparable[length];
     364        System.arraycopy(terms, start, arr, 0, length);
     365        return arr;
    361366    }
    362367
     
    388393                }
    389394                switch (((Character) term).charValue()) {
    390                     case '\t': str.append("\\t"); continue;
    391                     case '\r': str.append("\\r"); continue;
    392                     case '\n': str.append("\\n"); continue;
    393                     case '\\': str.append("\\\\"); continue;
    394                     case '\'': str.append("\\\'"); continue;
    395                     case '\"': str.append("\\\""); continue;
    396                     default: str.append(term); continue;
     395                    case '\t':
     396                        str.append("\\t");
     397                        continue;
     398                    case '\r':
     399                        str.append("\\r");
     400                        continue;
     401                    case '\n':
     402                        str.append("\\n");
     403                        continue;
     404                    case '\\':
     405                        str.append("\\\\");
     406                        continue;
     407                    case '\'':
     408                        str.append("\\\'");
     409                        continue;
     410                    case '\"':
     411                        str.append("\\\"");
     412                        continue;
     413                    default:
     414                        str.append(term);
     415                        continue;
    397416                }
    398417            }
     
    522541        }
    523542    }
    524    
     543
    525544    public static Concatenator getConcatenator () {
    526545        return new ListConcatenator();
     
    530549        return new InplaceConcatenator(initialCapacity);
    531550    }
    532    
     551
    533552    public interface Concatenator {
    534553        public Concatenator toRight (Comparable<?> obj);
     
    546565            public final Comparable<?> object;
    547566
    548             public ParenthesesMarker(Comparable<?> obj) {
     567            public ParenthesesMarker (Comparable<?> obj) {
    549568                object = obj;
    550569            }
    551570        }
    552        
     571
    553572        public ListConcatenator () {
    554573            list = new LinkedList<Object>();
     
    572591            if (length == 0)
    573592                return Expr.empty;
    574             Comparable<?>[] terms = new Comparable[length*2];
     593            Comparable<?>[] terms = new Comparable[length * 2];
    575594            int i = 0;
    576595            for (Object obj : list)
     
    588607        private Comparable<?>[] terms;
    589608        private int length;
    590        
     609
    591610        private InplaceConcatenator reinit (int initialCapacity) {
    592611            terms = new Comparable[initialCapacity * 2 + 4];
     
    640659        }
    641660    }
    642    
     661
    643662    /**
    644663     * Unused methods
    645664     */
    646665    {
    647     ///**
    648     // * Creates zero-length expression with given initial capacity.
    649     // */
    650     //public Expr (int initialCapacity) {
    651     //    assert 0 <= initialCapacity : "initialCapacity="+initialCapacity;
    652     //    terms = new Comparable[initialCapacity * 2 + 4];
    653     //    start = 0;
    654     //    length = 0;
    655     //}
    656 
    657     ///**
    658     // * Constructs subexpression -- remove it.
    659     // *
    660     // * @param expr
    661     // *            source expression
    662     // * @param i
    663     // *            index where subexpression starts
    664     // * @param len
    665     // *            subexpression length
    666     // */
    667     //public Expr (Expr expr, int i, int len) {
    668     //    assert expr != null;
    669     //    assert 0 <= i && 0 <= len && i <= expr.length - len : expr.length + ", " + i + ", " + len;
    670     //    terms = expr.terms;
    671     //    start = (expr.start + i) % terms.length;
    672     //    length = len;
    673     //}
    674 
    675     ///**
    676     // * Concatenates all expressions from the given array.
    677     // */
    678     //public static Expr concat (Expr[] arr) {
    679     //    assert arr != null;
    680     //    int length = 0;
    681     //    for (Expr expr : arr) {
    682     //        assert expr != null;
    683     //        length += expr.length;
    684     //    }
    685     //    if (length == 0)
    686     //        return empty;
    687     //    Expr.Concatenator ec = concatenator.reinit(length);
    688     //    for (Expr expr : arr)
    689     //        ec.toRight(expr);
    690     //    return ec.yield();
    691     //}
    692 
    693     ///**
    694     // * Creates expression from Comparable object.
    695     // */
    696     //public static Expr fromComparable (Comparable<?> obj) {
    697     //    assert obj != null;
    698     //    return new Expr(obj);
    699     //}
    700 
    701     ///**
    702     // * Creates expression from Object.
    703     // */
    704     //public static Expr fromObject (Object obj) {
    705     //    assert obj != null;
    706     //    Expr e = new Expr(1, 1);
    707     //    e.terms[e.start] = new Reference(obj);
    708     //    return e;
    709     //}
    710 
    711     ///**
    712     //* Creates expression from an array of Objects.
    713     //*/
    714     //public static Expr fromObjectArray (Object[] arr) {
    715     //    return fromObjectArray(arr, 0, arr.length);
    716     //}
    717 
    718     ///**
    719     // * Creates expression from a subarray of an array of Comparable objects.
    720     // * There shouldn't be nulls in array between st and st+len.
    721     // */
    722     //public static Expr fromComparableArray (Comparable<?>[] arr, int st, int len) {
    723     //    assert noNulls(arr, st, len);
    724     //    Comparable<?>[] terms = new Comparable[len * 2 + 4];
    725     //    System.arraycopy(arr, st, terms, 0, len);
    726     //    return new Expr(terms, 0, len);
    727     //}
    728 
    729     ///**
    730     //* Creates expression from a subarray of an array of Objects.
    731     //*/
    732     //public static Expr fromObjectArray (Object[] arr, int i, int len) {
    733     //    Expr e = new Expr(len, len);
    734     //    for (int k = 0, j = e.start; k < len; k++)
    735     //        e.terms[j++] = new Reference(arr[i++]);
    736     //    return e;
    737     //}
    738 
    739     ///**
    740     //* Returns the contents of this expr.
    741     //*/
    742     //public Object[] toArray() {
    743     //    Object[] arr = new Object[length];
    744     //    System.arraycopy(terms, start, arr, 0, length);
    745     //    return arr;
    746     //}
    747 
    748     ///**
    749     // * Writes the contents of this expr to the given array.
    750     // */
    751     //public void toArray (Object[] arr, int where, int what, int len) {
    752     //    assert length - len >= what;
    753     //    System.arraycopy(terms, start + what, arr, where, len);
    754     //}
     666        // /**
     667        // * Creates zero-length expression with given initial capacity.
     668        // */
     669        // public Expr (int initialCapacity) {
     670        // assert 0 <= initialCapacity : "initialCapacity="+initialCapacity;
     671        // terms = new Comparable[initialCapacity * 2 + 4];
     672        // start = 0;
     673        // length = 0;
     674        // }
     675
     676        // /**
     677        // * Constructs subexpression -- remove it.
     678        // *
     679        // * @param expr
     680        // * source expression
     681        // * @param i
     682        // * index where subexpression starts
     683        // * @param len
     684        // * subexpression length
     685        // */
     686        // public Expr (Expr expr, int i, int len) {
     687        // assert expr != null;
     688        // assert 0 <= i && 0 <= len && i <= expr.length - len : expr.length + ", " + i + ", " + len;
     689        // terms = expr.terms;
     690        // start = (expr.start + i) % terms.length;
     691        // length = len;
     692        // }
     693
     694        // /**
     695        // * Concatenates all expressions from the given array.
     696        // */
     697        // public static Expr concat (Expr[] arr) {
     698        // assert arr != null;
     699        // int length = 0;
     700        // for (Expr expr : arr) {
     701        // assert expr != null;
     702        // length += expr.length;
     703        // }
     704        // if (length == 0)
     705        // return empty;
     706        // Expr.Concatenator ec = concatenator.reinit(length);
     707        // for (Expr expr : arr)
     708        // ec.toRight(expr);
     709        // return ec.yield();
     710        // }
     711
     712        // /**
     713        // * Creates expression from Comparable object.
     714        // */
     715        // public static Expr fromComparable (Comparable<?> obj) {
     716        // assert obj != null;
     717        // return new Expr(obj);
     718        // }
     719
     720        // /**
     721        // * Creates expression from Object.
     722        // */
     723        // public static Expr fromObject (Object obj) {
     724        // assert obj != null;
     725        // Expr e = new Expr(1, 1);
     726        // e.terms[e.start] = new Reference(obj);
     727        // return e;
     728        // }
     729
     730        // /**
     731        // * Creates expression from an array of Objects.
     732        // */
     733        // public static Expr fromObjectArray (Object[] arr) {
     734        // return fromObjectArray(arr, 0, arr.length);
     735        // }
     736
     737        // /**
     738        // * Creates expression from a subarray of an array of Comparable objects.
     739        // * There shouldn't be nulls in array between st and st+len.
     740        // */
     741        // public static Expr fromComparableArray (Comparable<?>[] arr, int st, int len) {
     742        // assert noNulls(arr, st, len);
     743        // Comparable<?>[] terms = new Comparable[len * 2 + 4];
     744        // System.arraycopy(arr, st, terms, 0, len);
     745        // return new Expr(terms, 0, len);
     746        // }
     747
     748        // /**
     749        // * Creates expression from a subarray of an array of Objects.
     750        // */
     751        // public static Expr fromObjectArray (Object[] arr, int i, int len) {
     752        // Expr e = new Expr(len, len);
     753        // for (int k = 0, j = e.start; k < len; k++)
     754        // e.terms[j++] = new Reference(arr[i++]);
     755        // return e;
     756        // }
     757
     758        // /**
     759        // * Writes the contents of this expr to the given array.
     760        // */
     761        // public void toArray (Object[] arr, int where, int what, int len) {
     762        // assert length - len >= what;
     763        // System.arraycopy(terms, start + what, arr, where, len);
     764        // }
    755765    }
    756766}
  • to-imperative/trunk/java/java/org/refal/plus/Result.java

    r3463 r3624  
    3535        return expr != null ? expr.toString() : null;
    3636    }
     37
     38    public String formattedRepresentation () {
     39        return expr != null ? expr.formattedRepresentation() : null;
     40    }
     41
     42    public Comparable<?>[] toArray () {
     43        return expr != null ? expr.toArray() : null;
     44    }
    3745}
Note: See TracChangeset for help on using the changeset viewer.