Changeset 3422


Ignore:
Timestamp:
Feb 22, 2008, 8:06:21 PM (13 years ago)
Author:
yura
Message:
  • Suppress warnings: using Comparable<?> instead of Comparable.
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • devel-tools/trunk/eclipse/org.refal.plus.rfpdt/src/org/refal/plus/rfpdt/core/builder/RefalASGenerator.java

    r3403 r3422  
    100100        items.toRight(makeName(modName + "." + astConstBinding.name.identifier));
    101101        astConstBinding.exp.accept(this, items);
    102         e.toRight((Comparable<Expr>) items.yield());
     102        e.toRight((Comparable<?>) items.yield());
    103103    }
    104104
     
    118118        Expr.Concatenator inFormat = Expr.getConcatenator();
    119119        astFuncDecl.inFormat.accept(this, inFormat);
    120         items.toRight((Comparable<Expr>) inFormat.yield());
     120        items.toRight((Comparable<?>) inFormat.yield());
    121121        Expr.Concatenator outFormat = Expr.getConcatenator();
    122122        astFuncDecl.outFormat.accept(this, outFormat);
    123         items.toRight((Comparable<Expr>) outFormat.yield());
     123        items.toRight((Comparable<?>) outFormat.yield());
    124124        if (astFuncDecl.funcDef instanceof AstNative)
    125125            items.toRight(((AstNative) astFuncDecl.funcDef).right.identifier);
     
    128128            body.toRight(BRANCH);
    129129            ((AstFuncDef) astFuncDecl.funcDef).body.accept(this, body);
    130             items.toRight((Comparable<Expr>) body.yield());
     130            items.toRight((Comparable<?>) body.yield());
    131131        }
    132         e.toRight((Comparable<Expr>) items.yield());
     132        e.toRight((Comparable<?>) items.yield());
    133133    }
    134134
     
    160160        Expr.Concatenator inFormat = Expr.getConcatenator();
    161161        astFuncDecl.inFormat.accept(this, inFormat);
    162         items.toRight((Comparable<Expr>) inFormat.yield());
     162        items.toRight((Comparable<?>) inFormat.yield());
    163163        Expr.Concatenator outFormat = Expr.getConcatenator();
    164164        astFuncDecl.outFormat.accept(this, outFormat);
    165         items.toRight((Comparable<Expr>) outFormat.yield());
     165        items.toRight((Comparable<?>) outFormat.yield());
    166166        items.toRight(astNative.left.identifier);
    167         e.toRight((Comparable<Expr>) items.yield());
     167        e.toRight((Comparable<?>) items.yield());
    168168    }
    169169
     
    179179        String modName = astObjDecl.module != null ? astObjDecl.module : moduleName;
    180180        items.toRight(makeName(modName + "." + astObjDecl.name.identifier));
    181         e.toRight((Comparable<Expr>) items.yield());
     181        e.toRight((Comparable<?>) items.yield());
    182182    }
    183183
     
    198198            sentence.toRight(BRANCH);
    199199            astSentence.accept(this, sentence);
    200             items.toRight((Comparable<Expr>) sentence.yield());
     200            items.toRight((Comparable<?>) sentence.yield());
    201201        }
    202         e.toRight((Comparable<Expr>) items.yield());
     202        e.toRight((Comparable<?>) items.yield());
    203203    }
    204204
    205205    public void visit (AstCut astCut, Expr.Concatenator e) {
    206         e.toRight((Comparable<Expr>) new Expr(CUT));
     206        e.toRight((Comparable<?>) new Expr(CUT));
    207207    }
    208208
    209209    public void visit (AstCutAll astCutAll, Expr.Concatenator e) {
    210         e.toRight((Comparable<Expr>) new Expr(CUTALL));
     210        e.toRight((Comparable<?>) new Expr(CUTALL));
    211211    }
    212212
     
    215215        error.toRight(ERROR);
    216216        astError.sentence.accept(this, error);
    217         e.toRight((Comparable<Expr>) error.yield());
     217        e.toRight((Comparable<?>) error.yield());
    218218    }
    219219
    220220    public void visit (AstFail astFail, Expr.Concatenator e) {
    221         e.toRight((Comparable<Expr>) new Expr(FAIL));
     221        e.toRight((Comparable<?>) new Expr(FAIL));
    222222    }
    223223
    224224    public void visit (AstFence astFence, Expr.Concatenator e) {
    225         e.toRight((Comparable<Expr>) new Expr(FENCE));
     225        e.toRight((Comparable<?>) new Expr(FENCE));
    226226    }
    227227
     
    230230        format.toRight(FORMAT);
    231231        astFormat.exp.accept(this, format);
    232         e.toRight((Comparable<Expr>) format.yield());
     232        e.toRight((Comparable<?>) format.yield());
    233233    }
    234234
     
    239239        source.toRight(BRANCH);
    240240        astIter.sentence.accept(this, source);
    241         iter.toRight((Comparable<Expr>) source.yield());
     241        iter.toRight((Comparable<?>) source.yield());
    242242        Expr.Concatenator format = Expr.getConcatenator();
    243243        format.toRight(FORMAT);
    244244        astIter.target.accept(this, format);
    245         iter.toRight((Comparable<Expr>) format.yield());
    246         e.toRight((Comparable<Expr>) iter.yield());
     245        iter.toRight((Comparable<?>) format.yield());
     246        e.toRight((Comparable<?>) iter.yield());
    247247    }
    248248
     
    251251        source.toRight(BRANCH);
    252252        astNot.sentence.accept(this, source);
    253         e.toRight((Comparable<Expr>) Expr.concat(NOT, (Comparable<Expr>) source.yield()));
     253        e.toRight((Comparable<?>) Expr.concat(NOT, (Comparable<?>) source.yield()));
    254254    }
    255255
     
    258258        items.toRight(astPattern.dir.select(LEFT, RIGHT));
    259259        astPattern.exp.accept(this, items);
    260         e.toRight((Comparable<Expr>) items.yield());
     260        e.toRight((Comparable<?>) items.yield());
    261261    }
    262262
     
    265265        items.toRight(RESULT);
    266266        astResult.exp.accept(this, items);
    267         e.toRight((Comparable<Expr>) items.yield());
     267        e.toRight((Comparable<?>) items.yield());
    268268    }
    269269
     
    279279        trap.toRight(BRANCH);
    280280        astTrap.trySentence.accept(this, trap);
    281         items.toRight((Comparable<Expr>) trap.yield());
     281        items.toRight((Comparable<?>) trap.yield());
    282282        Expr.Concatenator with = Expr.getConcatenator();
    283283        with.toRight(BRANCH);
    284284        astTrap.catchSentence.accept(this, with);
    285         items.toRight((Comparable<Expr>) with.yield());
    286         e.toRight((Comparable<Expr>) items.yield());
     285        items.toRight((Comparable<?>) with.yield());
     286        e.toRight((Comparable<?>) items.yield());
    287287    }
    288288
     
    297297        items.toRight(makeName(modName + "." + astCall.funcDecl.name.identifier));
    298298        astCall.arg.accept(this, items);
    299         e.toRight((Comparable<Expr>) items.yield());
     299        e.toRight((Comparable<?>) items.yield());
    300300    }
    301301
     
    317317        items.toRight(PAREN);
    318318        astParen.exp.accept(this, items);
    319         e.toRight((Comparable<Expr>) items.yield());
     319        e.toRight((Comparable<?>) items.yield());
    320320    }
    321321
     
    327327            modName = moduleName;
    328328        items.toRight(makeName(modName + "." + astRef.decl.name.identifier));
    329         e.toRight((Comparable<Expr>) items.yield());
     329        e.toRight((Comparable<?>) items.yield());
    330330    }
    331331
    332332    public void visit (AstVar astVar, Expr.Concatenator e) {
    333333        String varType = astVar.type.name().toUpperCase() + "VAR"; // FIXME
    334         Comparable<Expr> varName;
     334        Comparable<?> varName;
    335335        if (astVar.name != null && astVar.name.identifier.length() > 0)
    336336            varName = new Expr(astVar.name.identifier); // FIXME
    337337        else
    338338            varName = new Expr("$tmp-" + astVar.pos.charStart); // FIXME
    339         e.toRight((Comparable<Expr>) Expr.concat(varType, varName));
     339        e.toRight((Comparable<?>) Expr.concat(varType, varName));
    340340    }
    341341
  • to-imperative/trunk/compiler/rfp_asail_java.rf

    r3413 r3422  
    295295  /*empty*/ = 'Expr.empty';
    296296  (PAREN e.expr) =
    297     'new Expr ((Comparable) '<Expr_Ref_To_Java e.expr>')';
     297    'new Expr ((Comparable<?>) '<Expr_Ref_To_Java e.expr>')';
    298298  term =
    299299    <Term_Ref_To_Java term> :: (e.term),
     
    309309Term_Ref_To_Java term = term : {
    310310  (PAREN e.expr) =
    311     ('(Comparable) '<Expr_Ref_To_Java e.expr>);
     311    ('(Comparable<?>) '<Expr_Ref_To_Java e.expr>);
    312312  (DEREF e.expr (e.pos)) =
    313313    ('(Expr) '<Expr_Ref_To_Java e.expr>'.at ('<Expr_Int_To_Java e.pos>')');
     
    392392      (e1) = {
    393393        e1 : \{
    394           '(Comparable)' e;
     394          '(Comparable<?>)' e;
    395395          'new Func' e;
    396396          'Symbol.new' e;
     
    412412  e.expr : t.item e.rest, t.item : {
    413413    (PAREN e.paren_expr) =
    414       ('(Comparable) '<Const_Expr_To_Java e.paren_expr>);
     414      ('(Comparable<?>) '<Const_Expr_To_Java e.paren_expr>);
    415415    (REF t.name) =
    416416      (<Name_To_Java t.name>);
  • to-imperative/trunk/java/runtime/org/refal/plus/Expr.java

    r3419 r3422  
    1717 */
    1818
    19 public final class Expr implements Comparable<Expr>, Iterable<Comparable>, RandomAccess {
     19public final class Expr implements Comparable<Expr>, Iterable<Comparable<?>>, RandomAccess {
    2020    public static final Expr empty = new Expr(new Comparable[1], 0, 0);
    2121
     
    3131    private static final InplaceConcatenator concatenator = new InplaceConcatenator();
    3232
    33     private final Comparable[] terms;
     33    private final Comparable<?>[] terms;
    3434    private final int start;
    3535    private final int length;
    3636
    3737    /**
    38      * Constructs expression from a subarray of an array of Comparable objects.
     38     * Constructs expression from a subarray of an array of Comparable<?> objects.
    3939     * This is private constructor because it doesn't copy the array and doesn't
    4040     * check that there aren't nulls in the array.
    4141     */
    42     private Expr (Comparable[] ts, int st, int len) {
     42    private Expr (Comparable<?>[] ts, int st, int len) {
    4343        assert ts != null : "ts="+ts;
    4444        //assert 0 <= st && st < ts.length && 0 <= len : "ts.length="+ts.length+", st="+st+", len="+len; 
     
    5858
    5959    /**
    60      * Constructor from Comparable object
    61      */
    62     public Expr (Comparable obj) {
     60     * Constructor from Comparable<?> object
     61     */
     62    public Expr (Comparable<?> obj) {
    6363        assert obj != null : "obj="+obj;
    6464        terms = new Comparable[4];
     
    8888     *            position of the term
    8989     */
    90     public Comparable at (int i) {
     90    public Comparable<?> at (int i) {
    9191        assert 0 <= i && i < length : "length="+length+", i="+i;
    9292        return terms[(start + i) % terms.length];
     
    152152        assert expr != null : "expr="+expr;
    153153        assert 0 <= j && j <= expr.length - length : "length="+length+", expr.length="+expr.length+", j="+j;
    154         Comparable[] terms1 = expr.terms;
     154        Comparable<?>[] terms1 = expr.terms;
    155155        int tslen1 = terms1.length;
    156156        int k1 = (expr.start + j) % tslen1;
     
    190190     * Compares this expression with the specified expression for order.
    191191     */
     192    @SuppressWarnings("unchecked")
    192193    public int compareTo (Expr expr) {
    193194        assert expr != null : "expr="+expr;
     
    201202        } else if (length == expr.length)
    202203            compare_len = 0;
    203         Comparable[] terms1 = expr.terms;
     204        Comparable<?>[] terms1 = expr.terms;
    204205        int tslen1 = terms1.length;
    205206        int k1 = expr.start;
     
    207208        int k = start;
    208209        for ( ; min_len > 0; min_len--, k = (k + 1) % tslen, k1 = (k1 + 1) % tslen1) {
    209             Comparable term = terms[k];
    210             Comparable term1 = terms1[k1];
     210            Comparable<?> term = terms[k];
     211            Comparable<?> term1 = terms1[k1];
    211212            int res = RefalRuntime.classCompare(term.getClass(), term1.getClass());
    212213            if (res == 0)
    213                 res = term.compareTo(term1);
     214                res = ((Comparable<Comparable<?>>) term).compareTo(term1); // May be CheckCastException
    214215            if (res != 0)
    215216                return res;
     
    218219    }
    219220   
    220     private static void arrayCopy (Comparable[] src, int srcStart, Comparable[] dst, int dstStart, int length) {
     221    private static void arrayCopy (Comparable<?>[] src, int srcStart, Comparable<?>[] dst, int dstStart, int length) {
    221222        assert length > 0;
    222223        int srcLen = src.length;
     
    255256            return expr1;
    256257        }
    257         Comparable[] ts1 = expr1.terms;
    258         Comparable[] ts2 = expr2.terms;
     258        Comparable<?>[] ts1 = expr1.terms;
     259        Comparable<?>[] ts2 = expr2.terms;
    259260        int e1_end = (expr1.start + len1) % ts1.length;
    260261        if (ts1 == ts2 && e1_end == expr2.start) {
     
    281282     * Concatenates two terms.
    282283     */
    283     public static Expr concat (Comparable obj1, Comparable obj2) {
     284    public static Expr concat (Comparable<?> obj1, Comparable<?> obj2) {
    284285        assert obj1 != null && obj2 != null : "obj1="+obj1+", obj2="+obj2;
    285         Comparable[] terms = new Comparable[4];
     286        Comparable<?>[] terms = new Comparable[4];
    286287        terms[0] = obj1;
    287288        terms[1] = obj2;
     
    292293     * Concatenates expression and term.
    293294     */
    294     public static Expr concat (Expr expr, Comparable obj) {
     295    public static Expr concat (Expr expr, Comparable<?> obj) {
    295296        assert expr != null && obj != null : "expr="+expr+", obj="+obj;
    296297        if (expr.length == 0)
     
    309310     * Concatenates term and expression.
    310311     */
    311     public static Expr concat (Comparable obj, Expr expr) {
     312    public static Expr concat (Comparable<?> obj, Expr expr) {
    312313        assert obj != null && expr != null : "obj="+obj+", expr="+expr;
    313314        if (expr.length == 0)
     
    336337
    337338    /**
    338      * Creates expression from an array of Comparable objects. Array shouldn't
     339     * Creates expression from an array of Comparable<?> objects. Array shouldn't
    339340     * contain nulls.
    340341     */
    341     public static Expr fromArray (Comparable[] arr) {
     342    public static Expr fromArray (Comparable<?>[] arr) {
    342343        assert noNulls(arr) : "arr="+arr;
    343344        int len = arr.length;
    344         Comparable[] terms = new Comparable[len * 2];
     345        Comparable<?>[] terms = new Comparable[len * 2];
    345346        System.arraycopy(arr, 0, terms, 0, len);
    346347        return new Expr(terms, 0, len);
     
    351352     * For use in assertions when creating expressions from arrays.
    352353     */
    353     private static boolean noNulls (Comparable[] arr) {
     354    private static boolean noNulls (Comparable<?>[] arr) {
    354355        if (arr == null)
    355356            return false;
    356         for (Comparable obj : arr)
     357        for (Comparable<?> obj : arr)
    357358            if (obj == null)
    358359                return false;
     
    366367    public StringBuffer toStringBuffer () {
    367368        StringBuffer str = new StringBuffer(length);
    368         for (Comparable term : this)
     369        for (Comparable<?> term : this)
    369370            if (term instanceof Expr)
    370371                str.append('(').append(((Expr) term).toStringBuffer()).append(')');
     
    379380        StringBuffer str = new StringBuffer(2 * length);
    380381        boolean chars = false;
    381         for (Comparable term : this) {
     382        for (Comparable<?> term : this) {
    382383            if (term instanceof Character) {
    383384                if (!chars) {
     
    473474    }
    474475
    475     public class Iterator implements ListIterator<Comparable> {
     476    public class Iterator implements ListIterator<Comparable<?>> {
    476477        int idx;
    477478
     
    488489        }
    489490
    490         public Comparable next () {
     491        public Comparable<?> next () {
    491492            if (idx < 0 || length <= idx)
    492493                throw new NoSuchElementException();
     
    498499        }
    499500
    500         public Comparable previous () {
     501        public Comparable<?> previous () {
    501502            idx--;
    502503            if (idx < 0 || length <= idx)
     
    509510        }
    510511
    511         public void add (Comparable obj) {
     512        public void add (Comparable<?> obj) {
    512513            throw new UnsupportedOperationException();
    513514        }
     
    517518        }
    518519
    519         public void set (Comparable obj) {
     520        public void set (Comparable<?> obj) {
    520521            throw new UnsupportedOperationException();
    521522        }
     
    531532   
    532533    public interface Concatenator {
    533         public Concatenator toRight (Comparable obj);
     534        public Concatenator toRight (Comparable<?> obj);
    534535
    535536        public Concatenator toRight (Expr expr);
     
    543544
    544545        private static final class ParenthesesMarker {
    545             public final Comparable object;
    546 
    547             public ParenthesesMarker(Comparable obj) {
     546            public final Comparable<?> object;
     547
     548            public ParenthesesMarker(Comparable<?> obj) {
    548549                object = obj;
    549550            }
     
    554555        }
    555556
    556         public ListConcatenator toRight (Comparable obj) {
     557        public ListConcatenator toRight (Comparable<?> obj) {
    557558            list.add(new ParenthesesMarker(obj));
    558559            length++;
     
    571572            if (length == 0)
    572573                return Expr.empty;
    573             Comparable[] terms = new Comparable[length*2];
     574            Comparable<?>[] terms = new Comparable[length*2];
    574575            int i = 0;
    575576            for (Object obj : list)
     
    585586
    586587    private static final class InplaceConcatenator implements Concatenator {
    587         private Comparable[] terms;
     588        private Comparable<?>[] terms;
    588589        private int length;
    589590       
     
    605606        }
    606607
    607         public InplaceConcatenator toRight (Comparable obj) {
     608        public InplaceConcatenator toRight (Comparable<?> obj) {
    608609            assert obj != null;
    609610            if (terms.length <= length) {
    610                 Comparable[] ts = new Comparable[length * 2];
     611                Comparable<?>[] ts = new Comparable[length * 2];
    611612                System.arraycopy(terms, 0, ts, 0, length);
    612613                terms = ts;
     
    622623            int newLength = length + expr.length;
    623624            if (terms.length < newLength) {
    624                 Comparable[] ts = new Comparable[newLength * 2];
     625                Comparable<?>[] ts = new Comparable[newLength * 2];
    625626                System.arraycopy(terms, 0, ts, 0, length);
    626627                terms = ts;
     
    693694    // * Creates expression from Comparable object.
    694695    // */
    695     //public static Expr fromComparable (Comparable obj) {
     696    //public static Expr fromComparable (Comparable<?> obj) {
    696697    //    assert obj != null;
    697698    //    return new Expr(obj);
     
    719720    // * There shouldn't be nulls in array between st and st+len.
    720721    // */
    721     //public static Expr fromComparableArray (Comparable[] arr, int st, int len) {
     722    //public static Expr fromComparableArray (Comparable<?>[] arr, int st, int len) {
    722723    //    assert noNulls(arr, st, len);
    723     //    Comparable[] terms = new Comparable[len * 2 + 4];
     724    //    Comparable<?>[] terms = new Comparable[len * 2 + 4];
    724725    //    System.arraycopy(arr, st, terms, 0, len);
    725726    //    return new Expr(terms, 0, len);
  • to-imperative/trunk/java/runtime/org/refal/plus/RefalRuntime.java

    r3419 r3422  
    2222    public static void setArgs (String arg0, String[] _args) {
    2323        Expr.Concatenator c = Expr.getConcatenator(_args.length + 1);
    24         c.toRight((Comparable<Expr>) Expr.fromSequence(arg0));
     24        c.toRight((Comparable<?>) Expr.fromSequence(arg0));
    2525        for (String arg : _args)
    26             c.toRight((Comparable<Expr>) Expr.fromSequence(arg));
     26            c.toRight((Comparable<?>) Expr.fromSequence(arg));
    2727        args = c.yield();
    2828    }
  • to-imperative/trunk/java/runtime/org/refal/plus/Result.java

    r3419 r3422  
    2424    }
    2525
    26     //public void assign (Comparable[] arr) {
     26    //public void assign (Comparable<?>[] arr) {
    2727    //    expr = Expr.fromComparableArray(arr);
    2828    //}
  • to-imperative/trunk/java/runtime/refal/plus/Table.java

    r3418 r3422  
    8585            Expr.Concatenator concat = Expr.getConcatenator(c.size());
    8686            for (Expr expr : c)
    87                 concat.toRight((Comparable<Expr>) expr);
     87                concat.toRight((Comparable<?>) expr);
    8888            res.assign(concat.yield());
    8989        } catch (ClassCastException _) {
     
    100100            Expr.Concatenator concat = Expr.getConcatenator(c.size());
    101101            for (Expr expr : c)
    102                 concat.toRight((Comparable<Expr>) expr);
     102                concat.toRight((Comparable<?>) expr);
    103103            res.assign(concat.yield());
    104104        } catch (ClassCastException _) {
     
    115115            Expr.Concatenator concat = Expr.getConcatenator(map.size());
    116116            for (Map.Entry<Expr, Expr> pair : map.entrySet())
    117                 concat.toRight((Comparable<Expr>) Expr.concat((Comparable<Expr>) pair.getKey(), (Comparable<Expr>) pair.getValue()));
     117                concat.toRight((Comparable<?>) Expr.concat((Comparable<?>) pair.getKey(), (Comparable<?>) pair.getValue()));
    118118            res.assign(concat.yield());
    119119        } catch (ClassCastException _) {
Note: See TracChangeset for help on using the changeset viewer.