Changeset 3975 for to-imperative


Ignore:
Timestamp:
Oct 17, 2008, 5:12:09 PM (12 years ago)
Author:
orlov
Message:
  • Branch java_expr_without_holes: merged all changes from the trunk up to the HEAD revision (r3953).
File:
1 edited

Legend:

Unmodified
Added
Removed
  • to-imperative/branches/java_expr_without_holes/Expr.java

    r2889 r3975  
    1818 */
    1919
    20 public final class Expr implements Comparable<Expr>, Iterable<Comparable>, RandomAccess {
     20public final class Expr implements Comparable<Expr>, Iterable<Comparable<?>>, RandomAccess {
    2121    public static final Expr empty = new Expr(new Comparable[0], 0, 0);
    2222
     
    3030    public static int both_copy = 0;
    3131   
    32     private static Comparable[] terms_pool = new Comparable[128];
     32    private static Comparable<?>[] terms_pool = new Comparable[8];
    3333    private static int pool_index = 0;
    3434
    35     private final Comparable[] terms;
     35    private final Comparable<?>[] terms;
    3636    private final int start;
    3737    private final int length;
    3838
    3939    /**
    40      * Constructs expression from a subarray of an array of Comparable objects.
     40     * Constructs expression from a subarray of an array of Comparable<?> objects.
    4141     * This is private constructor because it doesn't copy the array and doesn't
    4242     * check that there aren't nulls in the array.
    4343     */
    44     private Expr (Comparable[] ts, int st, int len) {
     44    private Expr (Comparable<?>[] ts, int st, int len) {
    4545        assert ts != null : "ts="+ts;
    4646        assert 0 <= st && 0 <= len && st <= ts.length - len : "ts.length="+ts.length+", st="+st+", len="+len; 
     
    5151
    5252    /**
    53      * Constructs empty expression.
    54      */
    55     public Expr () {
    56         terms = empty.terms;
    57         start = 0;
    58         length = 0;
    59     }
    60 
    61     /**
    62      * Constructor from Comparable object
    63      */
    64     public Expr (Comparable obj) {
    65         assert obj != null : "obj="+obj;
    66         if (pool_index >= terms_pool.length) {
    67             terms_pool = new Comparable[8];
    68             pool_index = 0;
    69         }
    70         terms = terms_pool;
    71         start = pool_index;
    72         length = 1;
    73         terms_pool[pool_index++] = obj;
    74     }
    75 
    76     /**
    7753     * Tests if this expression is empty.
    7854     */
     
    9470     *            position of the term
    9571     */
    96     public Comparable at (int i) {
     72    public Comparable<?> at (int i) {
    9773        assert 0 <= i && i < length : "length="+length+", i="+i;
    9874        return terms[start + i];
     
    158134        assert expr != null : "expr="+expr;
    159135        assert 0 <= j && j <= expr.length - length : "length="+length+", expr.length="+expr.length+", j="+j;
    160         Comparable[] terms1 = expr.terms;
     136        Comparable<?>[] terms1 = expr.terms;
    161137        int k1 = expr.start + j;
    162138        int tslen = terms.length;
     
    206182        } else if (length == expr.length)
    207183            compare_len = 0;
    208         Comparable[] terms1 = expr.terms;
     184        Comparable<?>[] terms1 = expr.terms;
    209185        int tslen1 = terms1.length;
    210186        int k1 = expr.start;
     
    212188        int k = start;
    213189        for ( ; min_len > 0; min_len--, k++, k1++) {
    214             Comparable term = terms[k];
    215             Comparable term1 = terms1[k1];
    216             int res = RefalRuntime.compare(term.getClass(), term1.getClass());
     190            Comparable<?> term = terms[k];
     191            Comparable<?> term1 = terms1[k1];
     192            int res = RefalRuntime.classCompare(term.getClass(), term1.getClass());
    217193            if (res == 0)
    218                 res = term.compareTo(term1);
     194                res = ((Comparable<Comparable<?>>) term).compareTo(term1); // May be CheckCastException
    219195            if (res != 0)
    220196                return res;
     
    241217            return expr1;
    242218        }
    243         Comparable[] ts1 = expr1.terms;
    244         Comparable[] ts2 = expr2.terms;
     219        Comparable<?>[] ts1 = expr1.terms;
     220        Comparable<?>[] ts2 = expr2.terms;
    245221        if (ts1 == ts2 && expr1.start + len1 == expr2.start) {
    246222            no_copy++;
     
    248224        }
    249225        both_copy++;
    250         Comparable[] terms = new Comparable[len];
     226        Comparable<?>[] terms = new Comparable[len];
    251227        System.arraycopy(expr1.terms, expr1.start, terms, 0, len1);
    252228        System.arraycopy(expr2.terms, expr2.start, terms, len1, len2);
     
    257233     * Concatenates two terms.
    258234     */
    259     public static Expr concat (Comparable obj1, Comparable obj2) {
     235    public static Expr concat (Comparable<?> obj1, Comparable<?> obj2) {
    260236        assert obj1 != null && obj2 != null : "obj1="+obj1+", obj2="+obj2;
    261237        if (pool_index >= terms_pool.length - 1) {
     
    271247     * Concatenates expression and term.
    272248     */
    273     public static Expr concat (Expr expr, Comparable obj) {
     249    public static Expr concat (Expr expr, Comparable<?> obj) {
    274250        assert expr != null && obj != null : "expr="+expr+", obj="+obj;
    275251        if (expr.length == 0)
    276             return new Expr(obj);
     252            return create(obj);
     253        int len = expr.length + 1;
     254        if (expr.start + expr.length < expr.terms.length && expr.terms[expr.start + expr.length] == obj) {
     255            no_copy++;
     256            return new Expr(expr.terms, expr.start, len);
     257        }
    277258        both_copy++;
    278         int len = expr.length + 1;
    279         Comparable[] terms = new Comparable[len];
     259        Comparable<?>[] terms = new Comparable[len];
    280260        System.arraycopy(expr.terms, expr.start, terms, 0, expr.length);
    281261        terms[expr.length] = obj;
     
    286266     * Concatenates term and expression.
    287267     */
    288     public static Expr concat (Comparable obj, Expr expr) {
     268    public static Expr concat (Comparable<?> obj, Expr expr) {
    289269        assert obj != null && expr != null : "obj="+obj+", expr="+expr;
    290270        if (expr.length == 0)
    291             return new Expr(obj);
     271            return create(obj);
     272        int len = expr.length + 1;
     273        if (expr.start > 0 && expr.terms[expr.start - 1] == obj) {
     274            no_copy++;
     275            return new Expr(expr.terms, expr.start - 1, len);
     276        }
    292277        both_copy++;
    293         int len = expr.length + 1;
    294         Comparable[] terms = new Comparable[len];
     278        Comparable<?>[] terms = new Comparable[len];
    295279        terms[0] = obj;
    296280        System.arraycopy(expr.terms, expr.start, terms, 1, expr.length);
     
    299283
    300284    /**
     285     * Creates expression with one term.
     286     */
     287    public static Expr create (Comparable<?> term) {
     288        assert term != null : "term=" + term;
     289        if (pool_index >= terms_pool.length) {
     290            terms_pool = new Comparable[8];
     291            pool_index = 0;
     292        }
     293        terms_pool[pool_index] = term;
     294        return new Expr(terms_pool, pool_index++, 1);
     295    }
     296
     297    /**
    301298     * Creates expression from a sequence of chars.
    302299     */
     
    304301        assert seq != null : "seq="+seq;
    305302        int len = seq.length();
    306         Comparable[] terms = new Comparable[len];
     303        Comparable<?>[] terms = new Comparable[len];
    307304        for (int i = 0; i < len; i++)
    308             terms[i] = new Character(seq.charAt(i));
     305            terms[i] = seq.charAt(i);
    309306        return new Expr(terms, 0, len);
    310307    }
    311308
    312309    /**
    313      * Creates expression from an array of Comparable objects.
    314      * Array shouldn't contain nulls.
    315      */
    316     public static Expr fromArray (Comparable[] arr) {
    317         assert noNulls(arr) : "arr="+arr;
    318         int len = arr.length;
    319         Comparable[] terms = new Comparable[len];
    320         System.arraycopy(arr, 0, terms, 0, len);
    321         return new Expr(terms, 0, len);
    322     }
    323 
    324     /**
    325      * Auxiliary method that checks there aren't nulls in a given part of array.
    326      * For use in assertions when creating expressions from arrays.
    327      */
    328     private static boolean noNulls (Comparable[] arr) {
    329         if (arr == null)
    330             return false;
    331         for (Comparable obj : arr)
    332             if (obj == null)
    333                 return false;
    334         return true;
     310     * Returns the contents of this expr.
     311     */
     312    public Object[] toArray () {
     313        Comparable<?>[] arr = new Comparable[length];
     314        System.arraycopy(terms, start, arr, 0, length);
     315        return arr;
    335316    }
    336317
    337318    public String toString () {
    338         return new String(toStringBuffer());
    339     }
    340 
    341     public StringBuffer toStringBuffer () {
    342         StringBuffer str = new StringBuffer(length);
    343         for (Comparable term : this)
    344             if (term instanceof Expr)
    345                 str.append('(').append(((Expr) term).toStringBuffer()).append(')');
    346             else
    347                 str.append(term.toString());
    348         return str;
    349     }
    350 
    351     public String formattedRepresentation () {
    352         if (length == 0)
    353             return "";
    354         StringBuffer str = new StringBuffer(2 * length);
     319        StringBuffer strBuf = new StringBuffer();
     320        toString(strBuf);
     321        return strBuf.toString();
     322    }
     323
     324    private void toString (StringBuffer strBuf) {
    355325        boolean chars = false;
    356         for (Comparable term : this) {
     326        boolean isNotFirst = false;
     327        for (Comparable<?> term : this) {
    357328            if (term instanceof Character) {
    358329                if (!chars) {
     330                    if (isNotFirst)
     331                        strBuf.append(' ');
     332                    strBuf.append('\'');
    359333                    chars = true;
    360                     str.append(' ');
    361                     str.append('\'');
    362334                }
    363335                switch (((Character) term).charValue()) {
    364                     case '\t': str.append("\\t"); continue;
    365                     case '\r': str.append("\\r"); continue;
    366                     case '\n': str.append("\\n"); continue;
    367                     case '\\': str.append("\\\\"); continue;
    368                     case '\'': str.append("\\\'"); continue;
    369                     case '\"': str.append("\\\""); continue;
    370                     default: str.append(term); continue;
     336                    case '\t': strBuf.append("\\t"); continue;
     337                    case '\r': strBuf.append("\\r"); continue;
     338                    case '\n': strBuf.append("\\n"); continue;
     339                    case '\\': strBuf.append("\\\\"); continue;
     340                    case '\'': strBuf.append("\\\'"); continue;
     341                    case '\"': strBuf.append("\\\""); continue;
     342                    default: strBuf.append(term); continue;
    371343                }
    372344            }
    373345            if (chars) {
    374346                chars = false;
    375                 str.append('\'');
     347                strBuf.append('\'');
    376348            }
    377             str.append(' ');
    378             if (term instanceof Expr)
    379                 str.append('(').append(((Expr) term).formattedRepresentation()).append(')');
    380             else if (term instanceof String) {
     349            if (isNotFirst)
     350                strBuf.append(' ');
     351            if (term instanceof Expr) {
     352                strBuf.append('(');
     353                ((Expr) term).toString(strBuf);
     354                strBuf.append(')');
     355            } else if (term instanceof String) {
    381356                String w = (String) term;
    382357                if (isIdentifier(w))
    383                     str.append(w);
     358                    strBuf.append(w);
    384359                else
    385                     str.append('"').append(w).append('"');
     360                    strBuf.append('"').append(w).append('"');
    386361            } else
    387                 str.append(term);
     362                strBuf.append(term.toString());
     363            isNotFirst = true;
    388364        }
    389365        if (chars)
    390             str.append('\'');
    391         return str.substring(1);
     366            strBuf.append('\'');
     367    }
     368
     369    public String toChars () {
     370        StringBuffer strBuf = new StringBuffer();
     371        toChars(strBuf);
     372        return strBuf.toString();
     373    }
     374
     375    private void toChars (StringBuffer strBuf) {
     376        for (Comparable<?> term : this)
     377            if (term instanceof Expr) {
     378                strBuf.append('(');
     379                ((Expr) term).toChars(strBuf);
     380                strBuf.append(')');
     381            } else if (term instanceof Reference && ((Reference) term).object instanceof org.refal.plus.objects.String)
     382                ((org.refal.plus.objects.String) ((Reference) term).object).toExpr().toChars(strBuf);
     383            else
     384                strBuf.append(term.toString());
    392385    }
    393386
     
    400393        for (int i = 1; i < str.length(); i++) {
    401394            c = str.charAt(i);
    402             if (!Character.isLetterOrDigit(c) && c != '_')
     395            if (!Character.isLetterOrDigit(c) && c != '_' && c != '.')
    403396                return false;
    404397        }
     
    448441    }
    449442
    450     public class Iterator implements ListIterator<Comparable> {
     443    public class Iterator implements ListIterator<Comparable<?>> {
    451444        int idx;
    452445
     
    463456        }
    464457
    465         public Comparable next () {
     458        public Comparable<?> next () {
    466459            if (idx < 0 || length <= idx)
    467460                throw new NoSuchElementException();
     
    473466        }
    474467
    475         public Comparable previous () {
     468        public Comparable<?> previous () {
    476469            idx--;
    477470            if (idx < 0 || length <= idx)
     
    484477        }
    485478
    486         public void add (Comparable obj) {
     479        public void add (Comparable<?> obj) {
    487480            throw new UnsupportedOperationException();
    488481        }
     
    492485        }
    493486
    494         public void set (Comparable obj) {
     487        public void set (Comparable<?> obj) {
    495488            throw new UnsupportedOperationException();
    496489        }
     
    506499   
    507500    public interface Concatenator {
    508         public Concatenator toRight (Comparable obj);
     501        public Concatenator toRight (Comparable<?> obj);
    509502
    510503        public Concatenator toRight (Expr expr);
     
    518511
    519512        private static final class ParenthesesMarker {
    520             public final Comparable object;
    521 
    522             public ParenthesesMarker(Comparable obj) {
     513            public final Comparable<?> object;
     514
     515            public ParenthesesMarker (Comparable<?> obj) {
    523516                object = obj;
    524517            }
     
    529522        }
    530523
    531         public ListConcatenator toRight (Comparable obj) {
     524        public ListConcatenator toRight (Comparable<?> obj) {
    532525            list.add(new ParenthesesMarker(obj));
    533526            length++;
     
    536529
    537530        public ListConcatenator toRight (Expr expr) {
     531            if (expr.length == 0)
     532                return this;
    538533            list.add(expr);
    539534            length += expr.length;
     
    544539            if (length == 0)
    545540                return Expr.empty;
    546             Comparable[] terms = new Comparable[length];
     541            Comparable<?>[] terms = new Comparable[length];
    547542            int i = 0;
    548543            for (Object obj : list)
     
    558553
    559554    private static final class InplaceConcatenator implements Concatenator {
    560         private Comparable[] terms;
     555        private Comparable<?>[] terms;
    561556        private int length;
    562557       
     
    578573        }
    579574
    580         public InplaceConcatenator toRight (Comparable obj) {
     575        public InplaceConcatenator toRight (Comparable<?> obj) {
    581576            assert obj != null;
    582577            if (terms.length <= length) {
    583                 Comparable[] ts = new Comparable[length * 2];
     578                Comparable<?>[] ts = new Comparable[length * 2];
    584579                System.arraycopy(terms, 0, ts, 0, length);
    585580                terms = ts;
     
    591586        public InplaceConcatenator toRight (Expr expr) {
    592587            assert expr != null;
     588            if (expr.length == 0)
     589                return this;
    593590            int newLength = length + expr.length;
    594591            if (terms.length < newLength) {
    595                 Comparable[] ts = new Comparable[newLength * 2];
     592                Comparable<?>[] ts = new Comparable[newLength * 2];
    596593                System.arraycopy(terms, 0, ts, 0, length);
    597594                terms = ts;
     
    610607        }
    611608    }
    612 
    613     /**
    614      * Unused methods
    615      */
    616     {
    617     ///**
    618     // * Creates zero-length expression with given initial capacity.
    619     // */
    620     //public Expr (int initialCapacity) {
    621     //    assert 0 <= initialCapacity : "initialCapacity="+initialCapacity;
    622     //    terms = new Comparable[initialCapacity * 2 + 4];
    623     //    start = 0;
    624     //    length = 0;
    625     //}
    626 
    627     ///**
    628     // * Constructs subexpression -- remove it.
    629     // *
    630     // * @param expr
    631     // *            source expression
    632     // * @param i
    633     // *            index where subexpression starts
    634     // * @param len
    635     // *            subexpression length
    636     // */
    637     //public Expr (Expr expr, int i, int len) {
    638     //    assert expr != null;
    639     //    assert 0 <= i && 0 <= len && i <= expr.length - len : expr.length + ", " + i + ", " + len;
    640     //    terms = expr.terms;
    641     //    start = (expr.start + i) % terms.length;
    642     //    length = len;
    643     //}
    644 
    645     ///**
    646     // * Concatenates all expressions from the given array.
    647     // */
    648     //public static Expr concat (Expr[] arr) {
    649     //    assert arr != null;
    650     //    int length = 0;
    651     //    for (Expr expr : arr) {
    652     //        assert expr != null;
    653     //        length += expr.length;
    654     //    }
    655     //    if (length == 0)
    656     //        return empty;
    657     //    Expr.Concatenator ec = concatenator.reinit(length);
    658     //    for (Expr expr : arr)
    659     //        ec.toRight(expr);
    660     //    return ec.yield();
    661     //}
    662 
    663     ///**
    664     // * Creates expression from Comparable object.
    665     // */
    666     //public static Expr fromComparable (Comparable obj) {
    667     //    assert obj != null;
    668     //    return new Expr(obj);
    669     //}
    670 
    671     ///**
    672     // * Creates expression from Object.
    673     // */
    674     //public static Expr fromObject (Object obj) {
    675     //    assert obj != null;
    676     //    Expr e = new Expr(1, 1);
    677     //    e.terms[e.start] = new Reference(obj);
    678     //    return e;
    679     //}
    680 
    681     ///**
    682     //* Creates expression from an array of Objects.
    683     //*/
    684     //public static Expr fromObjectArray (Object[] arr) {
    685     //    return fromObjectArray(arr, 0, arr.length);
    686     //}
    687 
    688     ///**
    689     // * Creates expression from a subarray of an array of Comparable objects.
    690     // * There shouldn't be nulls in array between st and st+len.
    691     // */
    692     //public static Expr fromComparableArray (Comparable[] arr, int st, int len) {
    693     //    assert noNulls(arr, st, len);
    694     //    Comparable[] terms = new Comparable[len * 2 + 4];
    695     //    System.arraycopy(arr, st, terms, 0, len);
    696     //    return new Expr(terms, 0, len);
    697     //}
    698 
    699     ///**
    700     //* Creates expression from a subarray of an array of Objects.
    701     //*/
    702     //public static Expr fromObjectArray (Object[] arr, int i, int len) {
    703     //    Expr e = new Expr(len, len);
    704     //    for (int k = 0, j = e.start; k < len; k++)
    705     //        e.terms[j++] = new Reference(arr[i++]);
    706     //    return e;
    707     //}
    708 
    709     ///**
    710     //* Returns the contents of this expr.
    711     //*/
    712     //public Object[] toArray() {
    713     //    Object[] arr = new Object[length];
    714     //    System.arraycopy(terms, start, arr, 0, length);
    715     //    return arr;
    716     //}
    717 
    718     ///**
    719     // * Writes the contents of this expr to the given array.
    720     // */
    721     //public void toArray (Object[] arr, int where, int what, int len) {
    722     //    assert length - len >= what;
    723     //    System.arraycopy(terms, start + what, arr, where, len);
    724     //}
    725     }
    726609}
Note: See TracChangeset for help on using the changeset viewer.