Changeset 224:165033f2ef94 in livinglogic.java.ul4

Show
Ignore:
Timestamp:
07/27/09 19:17:15 (9 years ago)
Author:
Walter Doerwald <walter@…>
Branch:
default
Tags:
exp-13
Message:

Update to use Java 1.5/1.6 features.

Location:
library/src/com/livinglogic/ul4
Files:
8 modified

Legend:

Unmodified
Added
Removed
  • library/src/com/livinglogic/ul4/Color.java

    r187 r224  
    302302    public static Color fromdump(String value) 
    303303    { 
    304         int r = Integer.valueOf(value.substring(0, 2), 16).intValue(); 
    305         int g = Integer.valueOf(value.substring(2, 4), 16).intValue(); 
    306         int b = Integer.valueOf(value.substring(4, 6), 16).intValue(); 
    307         int a = Integer.valueOf(value.substring(6, 8), 16).intValue(); 
     304        int r = Integer.valueOf(value.substring(0, 2), 16); 
     305        int g = Integer.valueOf(value.substring(2, 4), 16); 
     306        int b = Integer.valueOf(value.substring(4, 6), 16); 
     307        int a = Integer.valueOf(value.substring(6, 8), 16); 
    308308        return new Color(r, g, b, a); 
    309309    } 
     
    480480        if (o == null || !(o instanceof Integer)) 
    481481            return false; 
    482         int ov = ((Integer)o).intValue(); 
     482        int ov = ((Integer)o); 
    483483 
    484484        return ((r == ov) || (g == ov) || (b == ov) || (a == ov)); 
     
    487487    public boolean containsAll(Collection c) 
    488488    { 
    489         for (Iterator iterator = c.iterator(); iterator.hasNext();) 
    490         { 
    491             Object o = iterator.next(); 
     489        for (Object o : c) 
     490        { 
    492491            if (!contains(o)) 
    493492                return false; 
     
    533532            { 
    534533                case 0: 
    535                     return new Integer(r); 
     534                    return r; 
    536535                case 1: 
    537                     return new Integer(g); 
     536                    return g; 
    538537                case 2: 
    539                     return new Integer(b); 
     538                    return b; 
    540539                case 3: 
    541                     return new Integer(a); 
     540                    return a; 
    542541                default: 
    543542                    throw new NoSuchElementException("No more components available!"); 
     
    589588        return 4; 
    590589    } 
    591  
    592590} 
  • library/src/com/livinglogic/ul4/Compiler.java

    r223 r224  
    2828    public static InterpretedTemplate compile(String source, String startdelim, String enddelim) 
    2929    { 
    30         List tags = InterpretedTemplate.tokenizeTags(source, startdelim, enddelim); 
     30        List<Location> tags = InterpretedTemplate.tokenizeTags(source, startdelim, enddelim); 
    3131        return compiler.compile(source, tags, startdelim, enddelim); 
    3232    } 
  • library/src/com/livinglogic/ul4/InterpretedTemplate.java

    r223 r224  
    132132     * The list of opcodes. 
    133133     */  
    134     public List opcodes; 
     134    public List<Opcode> opcodes; 
    135135     
    136136    /** 
     
    150150    { 
    151151        this.source = null; 
    152         this.opcodes = new LinkedList(); 
     152        this.opcodes = new LinkedList<Opcode>(); 
    153153        this.defaultLocale = Locale.GERMANY; 
    154154    } 
     
    157157     * Creates an template object for a source string and a list of opcodes. 
    158158     */ 
    159     public InterpretedTemplate(String source, List opcodes, String startdelim, String enddelim, int startindex, int endindex) 
     159    public InterpretedTemplate(String source, List<Opcode> opcodes, String startdelim, String enddelim, int startindex, int endindex) 
    160160    { 
    161161        this.source = source; 
     
    169169     * Creates an template object for a source string and a list of opcodes. 
    170170     */ 
    171     public InterpretedTemplate(String source, List opcodes, String startdelim, String enddelim) 
     171    public InterpretedTemplate(String source, List<Opcode> opcodes, String startdelim, String enddelim) 
    172172    { 
    173173        this.source = source; 
     
    609609        writer.write("\n"); 
    610610        Location lastLocation = null; 
    611         for (int i = 0; i < opcodes.size(); ++i) 
    612         { 
    613             Opcode opcode = (Opcode)opcodes.get(i); 
     611        int size = opcodes.size(); 
     612        for (int i = 0; i < size; ++i) 
     613        { 
     614            Opcode opcode = opcodes.get(i); 
    614615            writespec(writer, opcode.r1); 
    615616            writespec(writer, opcode.r2); 
     
    675676        if (!annotated) 
    676677        { 
    677             for (int i = 0; i < opcodes.size(); ++i) 
     678            int size = opcodes.size(); 
     679            for (int i = 0; i < size; ++i) 
    678680            { 
    679                 Opcode opcode = (Opcode)opcodes.get(i); 
     681                Opcode opcode = opcodes.get(i); 
    680682                switch (opcode.name) 
    681683                { 
     
    710712    { 
    711713        int jump = ifStart; 
    712         for (int i = ifStart+1; i < opcodes.size(); ++i) 
    713         { 
    714             Opcode opcode = (Opcode)opcodes.get(i); 
     714        int size = opcodes.size(); 
     715        for (int i = ifStart+1; i < size; ++i) 
     716        { 
     717            Opcode opcode = opcodes.get(i); 
    715718            switch (opcode.name) 
    716719            { 
     
    725728                    break; 
    726729                case Opcode.OC_ELSE: 
    727                     ((Opcode)opcodes.get(jump)).jump = i; 
     730                    opcodes.get(jump).jump = i; 
    728731                    jump = i; 
    729732                    break; 
    730733                case Opcode.OC_ENDIF: 
    731                     ((Opcode)opcodes.get(jump)).jump = i; 
     734                    opcodes.get(jump).jump = i; 
    732735                    return i; 
    733736                case Opcode.OC_BREAK: 
     
    751754    { 
    752755        int jump = defStart; 
    753         for (int i = defStart+1; i < opcodes.size(); ++i) 
    754         { 
    755             Opcode opcode = (Opcode)opcodes.get(i); 
     756        int size = opcodes.size(); 
     757        for (int i = defStart+1; i < size; ++i) 
     758        { 
     759            Opcode opcode = opcodes.get(i); 
    756760            switch (opcode.name) 
    757761            { 
     
    776780                    throw new BlockException("endfor in def"); 
    777781                case Opcode.OC_ENDDEF: 
    778                     ((Opcode)opcodes.get(defStart)).jump = i; 
     782                    opcodes.get(defStart).jump = i; 
    779783                    return i; 
    780784            } 
     
    786790    { 
    787791        ++forDepth; 
    788         LinkedList breaks = new LinkedList(); 
    789         LinkedList continues = new LinkedList(); 
    790  
    791         for (int i = loopStart+1; i < opcodes.size(); ++i) 
    792         { 
    793             Opcode opcode = (Opcode)opcodes.get(i); 
     792        LinkedList<Integer> breaks = new LinkedList<Integer>(); 
     793        LinkedList<Integer> continues = new LinkedList<Integer>(); 
     794 
     795        int size = opcodes.size(); 
     796        for (int i = loopStart+1; i < size; ++i) 
     797        { 
     798            Opcode opcode = opcodes.get(i); 
    794799            switch (opcode.name) 
    795800            { 
     
    808813                    throw new BlockException("endif in for loop"); 
    809814                case Opcode.OC_BREAK: 
    810                     breaks.add(new Integer(i)); 
     815                    breaks.add(i); 
    811816                    break; 
    812817                case Opcode.OC_CONTINUE: 
    813                     continues.add(new Integer(i)); 
     818                    continues.add(i); 
    814819                    break; 
    815820                case Opcode.OC_ENDFOR: 
     
    818823                    for (j = 0; j < breaks.size(); ++j) 
    819824                    { 
    820                         jump = ((Integer)breaks.get(j)).intValue(); 
    821                         ((Opcode)opcodes.get(jump)).jump = i; 
     825                        jump = breaks.get(j); 
     826                        opcodes.get(jump).jump = i; 
    822827                    } 
    823828                    for (j = 0; j < continues.size(); ++j) 
    824829                    { 
    825                         jump = ((Integer)continues.get(j)).intValue(); 
    826                         ((Opcode)opcodes.get(jump)).jump = i; 
     830                        jump = continues.get(j); 
     831                        opcodes.get(jump).jump = i; 
    827832                    } 
    828                     ((Opcode)opcodes.get(loopStart)).jump = i; 
     833                    opcodes.get(loopStart).jump = i; 
    829834                    return i; 
    830835                case Opcode.OC_ENDDEF: 
     
    835840    } 
    836841 
    837     public Iterator render() 
     842    public Iterator<String> render() 
    838843    { 
    839844        return new Renderer(null); 
     
    846851     * @return An iterator that returns the string output piece by piece. 
    847852     */ 
    848     public Iterator render(Map variables) 
     853    public Iterator<String> render(Map variables) 
    849854    { 
    850855        return new Renderer(variables); 
     
    862867     * @return The render output as a string. 
    863868     */ 
    864     public String renders(Map variables) 
     869    public String renders(Map<String, Object> variables) 
    865870    { 
    866871        StringBuffer output = new StringBuffer(); 
    867872 
    868         for (Iterator iterator = render(variables); iterator.hasNext();) 
    869         { 
    870             output.append((String)iterator.next()); 
     873        for (Iterator<String> iterator = render(variables); iterator.hasNext();) 
     874        { 
     875            output.append(iterator.next()); 
    871876        } 
    872877        return output.toString(); 
    873878    } 
    874879 
    875     class Renderer implements Iterator 
     880    class Renderer implements Iterator<String> 
    876881    { 
    877882        /** 
     
    890895         * <code>&lt;?code>&gt;</code> tag will be stored here 
    891896         */ 
    892         private Map variables; 
     897        private Map<String, Object> variables; 
    893898 
    894899        /** 
    895900         * The stack of active for loops 
    896901         */ 
    897         private LinkedList iterators = new LinkedList(); 
     902        private LinkedList<IteratorStackEntry> iterators = new LinkedList<IteratorStackEntry>(); 
    898903 
    899904        /** 
     
    902907         * active part iterator for the subtemplate. 
    903908         */ 
    904         private Iterator subTemplateIterator = null; 
     909        private Iterator<String> subTemplateIterator = null; 
    905910 
    906911        /** 
     
    915920        private String nextChunk = null; 
    916921 
    917         public Renderer(Map variables) 
     922        public Renderer(Map<String, Object> variables) 
    918923        { 
    919924            annotate(); 
    920925            if (variables == null) 
    921                 variables = new HashMap(); 
     926                variables = new HashMap<String, Object>(); 
    922927            this.variables = variables; 
    923928            getNextChunk(); 
     
    934939        } 
    935940 
    936         public Object next() 
     941        public String next() 
    937942        { 
    938943            String result = nextChunk; 
     
    950955                if (subTemplateIterator.hasNext()) 
    951956                { 
    952                     nextChunk = (String)subTemplateIterator.next(); 
     957                    nextChunk = subTemplateIterator.next(); 
    953958                    return; 
    954959                } 
     
    960965            while (pc < opcodes.size()) 
    961966            { 
    962                 Opcode code = (Opcode)opcodes.get(pc); 
     967                Opcode code = opcodes.get(pc); 
    963968 
    964969                try 
     
    991996                            break; 
    992997                        case Opcode.OC_LOADINT: 
    993                             reg[code.r1] = new Integer(Integer.parseInt(code.arg)); 
     998                            reg[code.r1] = Integer.parseInt(code.arg); 
    994999                            break; 
    9951000                        case Opcode.OC_LOADFLOAT: 
    996                             reg[code.r1] = new Double(Double.parseDouble(code.arg)); 
     1001                            reg[code.r1] = Double.parseDouble(code.arg); 
    9971002                            break; 
    9981003                        case Opcode.OC_LOADDATE: 
     
    10591064                        case Opcode.OC_BREAK: 
    10601065                        { 
    1061                             IteratorStackEntry entry = (IteratorStackEntry)iterators.getLast(); 
     1066                            IteratorStackEntry entry = iterators.getLast(); 
    10621067                            pc = entry.pcEndFor; 
    10631068                            iterators.removeLast(); 
     
    10661071                        case Opcode.OC_CONTINUE: 
    10671072                        { 
    1068                             IteratorStackEntry entry = (IteratorStackEntry)iterators.getLast(); 
     1073                            IteratorStackEntry entry = iterators.getLast(); 
    10691074                            pc = entry.pcEndFor; 
    10701075                            // Fall through 
     
    10721077                        case Opcode.OC_ENDFOR: 
    10731078                        { 
    1074                             IteratorStackEntry entry = (IteratorStackEntry)iterators.getLast(); 
     1079                            IteratorStackEntry entry = iterators.getLast(); 
    10751080                            if (entry.iterator.hasNext()) 
    10761081                            { 
     
    14561461                                nextChunk = ((Template)reg[code.r1]).renders((Map)reg[code.r2]); 
    14571462                        case Opcode.OC_DEF: 
    1458                             variables.put(code.arg, new InterpretedTemplate(source.substring(code.location.endtag, ((Opcode)opcodes.get(code.jump)).location.starttag), opcodes, startdelim, enddelim, pc+1, code.jump)); 
     1463                            variables.put(code.arg, new InterpretedTemplate(source.substring(code.location.endtag, opcodes.get(code.jump).location.starttag), opcodes, startdelim, enddelim, pc+1, code.jump)); 
    14591464                            pc = code.jump+1; 
    14601465                            continue; 
     
    14771482    } 
    14781483 
    1479     public static List tokenizeTags(String source, String startdelim, String enddelim) 
     1484    public static List<Location> tokenizeTags(String source, String startdelim, String enddelim) 
    14801485    { 
    14811486        Pattern tagPattern = Pattern.compile(escapeREchars(startdelim) + "(printx|print|code|for|if|elif|else|end|break|continue|render|def|note)(\\s*((.|\\n)*?)\\s*)?" + escapeREchars(enddelim)); 
    1482         LinkedList tags = new LinkedList(); 
     1487        LinkedList<Location> tags = new LinkedList<Location>(); 
    14831488        if (source != null) 
    14841489        { 
     
    15861591                    len = color8Matcher.end(); 
    15871592                    String value = color8Matcher.group(); 
    1588                     int r = Integer.valueOf(value.substring(1, 3), 16).intValue(); 
    1589                     int g = Integer.valueOf(value.substring(3, 5), 16).intValue(); 
    1590                     int b = Integer.valueOf(value.substring(5, 7), 16).intValue(); 
    1591                     int a = Integer.valueOf(value.substring(7, 9), 16).intValue(); 
     1593                    int r = Integer.valueOf(value.substring(1, 3), 16); 
     1594                    int g = Integer.valueOf(value.substring(3, 5), 16); 
     1595                    int b = Integer.valueOf(value.substring(5, 7), 16); 
     1596                    int a = Integer.valueOf(value.substring(7, 9), 16); 
    15921597                    tokens.add(new LoadColor(pos, pos+len, new Color(r, g, b, a))); 
    15931598                } 
     
    15961601                    len = color6Matcher.end(); 
    15971602                    String value = color6Matcher.group(); 
    1598                     int r = Integer.valueOf(value.substring(1, 3), 16).intValue(); 
    1599                     int g = Integer.valueOf(value.substring(3, 5), 16).intValue(); 
    1600                     int b = Integer.valueOf(value.substring(5, 7), 16).intValue(); 
     1603                    int r = Integer.valueOf(value.substring(1, 3), 16); 
     1604                    int g = Integer.valueOf(value.substring(3, 5), 16); 
     1605                    int b = Integer.valueOf(value.substring(5, 7), 16); 
    16011606                    tokens.add(new LoadColor(pos, pos+len, new Color(r, g, b))); 
    16021607                } 
     
    16051610                    len = color4Matcher.end(); 
    16061611                    String value = color4Matcher.group(); 
    1607                     int r = 17*Integer.valueOf(value.substring(1, 2), 16).intValue(); 
    1608                     int g = 17*Integer.valueOf(value.substring(2, 3), 16).intValue(); 
    1609                     int b = 17*Integer.valueOf(value.substring(3, 4), 16).intValue(); 
    1610                     int a = 17*Integer.valueOf(value.substring(4, 5), 16).intValue(); 
     1612                    int r = 17*Integer.valueOf(value.substring(1, 2), 16); 
     1613                    int g = 17*Integer.valueOf(value.substring(2, 3), 16); 
     1614                    int b = 17*Integer.valueOf(value.substring(3, 4), 16); 
     1615                    int a = 17*Integer.valueOf(value.substring(4, 5), 16); 
    16111616                    tokens.add(new LoadColor(pos, pos+len, new Color(r, g, b, a))); 
    16121617                } 
     
    16151620                    len = color3Matcher.end(); 
    16161621                    String value = color3Matcher.group(); 
    1617                     int r = 17*Integer.valueOf(value.substring(1, 2), 16).intValue(); 
    1618                     int g = 17*Integer.valueOf(value.substring(2, 3), 16).intValue(); 
    1619                     int b = 17*Integer.valueOf(value.substring(3, 4), 16).intValue(); 
     1622                    int r = 17*Integer.valueOf(value.substring(1, 2), 16); 
     1623                    int g = 17*Integer.valueOf(value.substring(2, 3), 16); 
     1624                    int b = 17*Integer.valueOf(value.substring(3, 4), 16); 
    16201625                    tokens.add(new LoadColor(pos, pos+len, new Color(r, g, b))); 
    16211626                } 
     
    17751780        for (int i = 0; i < size; ++i) 
    17761781        { 
    1777             Opcode code = (Opcode)opcodes.get(i); 
     1782            Opcode code = opcodes.get(i); 
    17781783 
    17791784            if (code.name == Opcode.OC_ELSE || code.name == Opcode.OC_ENDIF || code.name == Opcode.OC_ENDFOR) 
     
    18291834        for (int i = 0; i < size; ++i) 
    18301835        { 
    1831             Opcode opcode = (Opcode)opcodes.get(i); 
     1836            Opcode opcode = opcodes.get(i); 
    18321837             
    18331838            if (lastLocation != opcode.location) 
     
    18671872        for (int i = 0; i < size; ++i) 
    18681873        { 
    1869             Opcode opcode = (Opcode)opcodes.get(i); 
     1874            Opcode opcode = opcodes.get(i); 
    18701875         
    18711876            switch (opcode.name) 
     
    23072312    public void renderjsp(JspWriter out, Map variables) throws java.io.IOException 
    23082313    { 
    2309         for (Iterator iterator = render(variables); iterator.hasNext();) 
    2310         { 
    2311             out.write((String)iterator.next()); 
     2314        for (Iterator<String> iterator = render(variables); iterator.hasNext();) 
     2315        { 
     2316            out.write(iterator.next()); 
    23122317        } 
    23132318    } 
  • library/src/com/livinglogic/ul4/JSPTemplate.java

    r208 r224  
    2424public abstract class JSPTemplate implements Template 
    2525{ 
    26     public String renders(Map variables) 
     26    public String renders(Map<String, Object> variables) 
    2727    { 
    2828        StringWriter out = new StringWriter(); 
     
    4040    } 
    4141 
    42     public void renderjsp(JspWriter out, Map variables) throws java.io.IOException 
     42    public void renderjsp(JspWriter out, Map<String, Object> variables) throws java.io.IOException 
    4343    { 
    4444        execute(out, variables); 
    4545    } 
    4646 
    47     public abstract void execute(Writer out, Map variables) throws java.io.IOException; 
     47    public abstract void execute(Writer out, Map<String, Object> variables) throws java.io.IOException; 
    4848} 
  • library/src/com/livinglogic/ul4/Main.java

    r221 r224  
    1010    { 
    1111        Long c = new Long(42); 
    12         Template tmpl = Compiler.compile("<?def x?><?def y?><?print arg?><?end?><?render y(arg=arg)?><?end def?><?render x(arg='gurk')?>"); 
     12        Template tmpl = Compiler.compile("<?print repr({'a': 1, 'b': 2})?><?print rgb(1,2,3,4)?>"); 
    1313        System.out.println(tmpl); 
    1414        long start = System.currentTimeMillis(); 
    15         Map vars = new HashMap(); 
     15        Map vars = new HashMap<String, Object>(); 
    1616        vars.put("t", "123"); 
    1717        String output = tmpl.renders(vars); 
  • library/src/com/livinglogic/ul4/Registers.java

    r116 r224  
    33import java.util.Vector; 
    44 
    5 public class Registers extends Vector 
     5public class Registers extends Vector<Integer> 
    66{ 
    77    public Registers() 
     
    99        super(10); 
    1010        for (int i = 0; i < 10; ++i) 
    11             add(new Integer(i)); 
     11            add(i); 
    1212    } 
    1313 
     
    1616        try 
    1717        { 
    18             return ((Integer)remove(0)).intValue(); 
     18            return remove(0); 
    1919        } 
    2020        catch (ArrayIndexOutOfBoundsException ex) 
     
    2626    public void free(int r) 
    2727    { 
    28         add(0, new Integer(r)); 
     28        add(0, r); 
    2929    } 
    3030} 
  • library/src/com/livinglogic/ul4/Template.java

    r221 r224  
    2121public interface Template 
    2222{ 
    23     public String renders(Map variables); 
     23    public String renders(Map<String, Object> variables); 
    2424 
    25     public void renderjsp(JspWriter out, Map variables) throws java.io.IOException; 
     25    public void renderjsp(JspWriter out, Map<String, Object> variables) throws java.io.IOException; 
    2626} 
  • library/src/com/livinglogic/ul4/Utils.java

    r216 r224  
    1111import java.util.Map; 
    1212import java.util.Vector; 
     13import java.util.Set; 
    1314import java.util.Date; 
    1415import java.text.SimpleDateFormat; 
     
    5152            throw new IndexOutOfBoundsException("Invalid index: " + index); 
    5253        } 
    53         return new Integer(start + index * step); 
     54        return start + index * step; 
    5455    } 
    5556 
     
    7172} 
    7273 
    73 class StringIterator implements Iterator 
     74class StringIterator implements Iterator<String> 
    7475{ 
    7576    String string; 
     
    9192    } 
    9293 
    93     public Object next() 
     94    public String next() 
    9495    { 
    9596        if (index >= stringSize) 
     
    106107} 
    107108 
    108 class StringReversedIterator implements Iterator 
     109class StringReversedIterator implements Iterator<String> 
    109110{ 
    110111    String string; 
     
    126127    } 
    127128 
    128     public Object next() 
     129    public String next() 
    129130    { 
    130131        if (index < 0) 
     
    176177} 
    177178 
    178 class MapItemIterator implements Iterator 
     179class MapItemIterator implements Iterator<Vector> 
    179180{ 
    180181    Iterator iterator; 
     
    190191    } 
    191192 
    192     public Object next() 
     193    public Vector next() 
    193194    { 
    194195        Vector retVal = new Vector(2); 
     
    205206} 
    206207 
    207 class ZipIterator implements Iterator 
     208class ZipIterator implements Iterator<Vector> 
    208209{ 
    209210    Iterator iterator1; 
     
    230231    } 
    231232 
    232     public Object next() 
     233    public Vector next() 
    233234    { 
    234235        Vector retVal = new Vector(iterator3 != null ? 3 : 2); 
     
    249250} 
    250251 
    251 class SequenceEnumerator implements Iterator 
     252class SequenceEnumerator implements Iterator<Vector> 
    252253{ 
    253254    Iterator sequenceIterator; 
     
    265266    } 
    266267 
    267     public Object next() 
     268    public Vector next() 
    268269    { 
    269270        Vector retVal = new Vector(2); 
     
    306307    public static Object add(Integer arg1, Integer arg2) 
    307308    { 
    308         return new Integer(arg1.intValue() + arg2.intValue()); 
     309        return arg1.intValue() + arg2.intValue(); 
    309310    } 
    310311 
    311312    public static Object add(Number arg1, Number arg2) 
    312313    { 
    313         return new Double(arg1.doubleValue() + arg2.doubleValue()); 
     314        return arg1.doubleValue() + arg2.doubleValue(); 
    314315    } 
    315316 
     
    332333    public static Object sub(Integer arg1, Integer arg2) 
    333334    { 
    334         return new Integer(arg1.intValue() - arg2.intValue()); 
     335        return arg1.intValue() - arg2.intValue(); 
    335336    } 
    336337 
    337338    public static Object sub(Number arg1, Number arg2) 
    338339    { 
    339         return new Double(arg1.doubleValue() - arg2.doubleValue()); 
     340        return arg1.doubleValue() - arg2.doubleValue(); 
    340341    } 
    341342 
     
    363364    public static Object mul(Integer arg1, Integer arg2) 
    364365    { 
    365         return new Integer(arg1.intValue() * arg2.intValue()); 
     366        return arg1.intValue() * arg2.intValue(); 
    366367    } 
    367368 
    368369    public static Object mul(Number arg1, Number arg2) 
    369370    { 
    370         return new Double(arg1.doubleValue() * arg2.doubleValue()); 
     371        return arg1.doubleValue() * arg2.doubleValue(); 
    371372    } 
    372373 
     
    386387    public static Object truediv(Number arg1, Number arg2) 
    387388    { 
    388         return new Double(arg1.doubleValue() / arg2.doubleValue()); 
     389        return arg1.doubleValue() / arg2.doubleValue(); 
    389390    } 
    390391 
     
    396397    public static Object floordiv(Integer arg1, Integer arg2) 
    397398    { 
    398         return new Integer(arg1.intValue() / arg2.intValue()); 
     399        return arg1.intValue() / arg2.intValue(); 
    399400    } 
    400401 
    401402    public static Object floordiv(Number arg1, Number arg2) 
    402403    { 
    403         return new Double((int)(arg1.doubleValue() / arg2.doubleValue())); 
     404        return (double)((int)(arg1.doubleValue() / arg2.doubleValue())); 
    404405    } 
    405406 
     
    411412    public static Object mod(Integer arg1, Integer arg2) 
    412413    { 
    413         return new Integer(arg1.intValue() % arg2.intValue()); 
     414        return arg1.intValue() % arg2.intValue(); 
    414415    } 
    415416 
     
    449450        { 
    450451            case 0: 
    451                 return new Integer(arg1.getR()); 
     452                return arg1.getR(); 
    452453            case 1: 
    453                 return new Integer(arg1.getG()); 
     454                return arg1.getG(); 
    454455            case 2: 
    455                 return new Integer(arg1.getB()); 
     456                return arg1.getB(); 
    456457            case 3: 
    457                 return new Integer(arg1.getA()); 
     458                return arg1.getA(); 
    458459            default: 
    459460                throw new ArrayIndexOutOfBoundsException(); 
     
    518519        else 
    519520        { 
    520             retVal = virtualPos.intValue(); 
     521            retVal = virtualPos; 
    521522            if (0 > retVal) 
    522523            { 
     
    798799    public static Object toFloat(Integer obj) 
    799800    { 
    800         return new Float(obj.intValue()); 
     801        return (double)(obj.intValue()); 
    801802    } 
    802803 
    803804    public static Object toFloat(Long obj) 
    804805    { 
    805         return new Float(obj.longValue()); 
     806        return (double)(obj.longValue()); 
    806807    } 
    807808 
    808809    public static Object toFloat(Float obj) 
    809810    { 
    810         return obj; 
     811        return (double)obj; 
    811812    } 
    812813 
    813814    public static Object toFloat(Boolean obj) 
    814815    { 
    815         return new Float(obj.booleanValue() ? 1.0 : 0.0); 
     816        return obj.booleanValue() ? 1.0d : 0.0d; 
    816817    } 
    817818 
     
    858859            sb.append("["); 
    859860            boolean first = true; 
    860             for (Iterator iter = ((Collection)obj).iterator(); iter.hasNext();) 
     861            for (Object o : ((Collection)obj)) 
    861862            { 
    862863                if (first) 
     
    864865                else 
    865866                    sb.append(", "); 
    866                 sb.append(repr(iter.next())); 
     867                sb.append(repr(o)); 
    867868            } 
    868869            sb.append("]"); 
     
    874875            sb.append("{"); 
    875876            boolean first = true; 
    876             for (Iterator iter = ((Map)obj).entrySet().iterator(); iter.hasNext();) 
     877 
     878            Set<Map.Entry> entrySet = ((Map)obj).entrySet(); 
     879            for (Map.Entry entry : entrySet) 
    877880            { 
    878881                if (first) 
     
    880883                else 
    881884                    sb.append(", "); 
    882                 Map.Entry entry = (Map.Entry)iter.next(); 
    883885                sb.append(repr(entry.getKey())); 
    884886                sb.append(": "); 
     
    916918            sb.append("["); 
    917919            boolean first = true; 
    918             for (Iterator iter = ((Collection)obj).iterator(); iter.hasNext();) 
     920            for (Object o : (Collection)obj) 
    919921            { 
    920922                if (first) 
     
    922924                else 
    923925                    sb.append(", "); 
    924                 sb.append(json(iter.next())); 
     926                sb.append(json(o)); 
    925927            } 
    926928            sb.append("]"); 
     
    932934            sb.append("{"); 
    933935            boolean first = true; 
    934             for (Iterator iter = ((Map)obj).entrySet().iterator(); iter.hasNext();) 
     936            Set<Map.Entry> entrySet = ((Map)obj).entrySet(); 
     937            for (Map.Entry entry : entrySet) 
    935938            { 
    936939                if (first) 
     
    938941                else 
    939942                    sb.append(", "); 
    940                 Map.Entry entry = (Map.Entry)iter.next(); 
    941943                sb.append(json(entry.getKey())); 
    942944                sb.append(": "); 
     
    960962    public static Object length(String obj) 
    961963    { 
    962         return new Integer(obj.length()); 
     964        return obj.length(); 
    963965    } 
    964966 
    965967    public static Object length(Collection obj) 
    966968    { 
    967         return new Integer(obj.size()); 
     969        return obj.size(); 
    968970    } 
    969971 
    970972    public static Object length(Map obj) 
    971973    { 
    972         return new Integer(obj.size()); 
     974        return obj.size(); 
    973975    } 
    974976 
     
    10411043            throw new IllegalArgumentException("String " + obj + " contains more than one unicode character!"); 
    10421044        } 
    1043         return new Integer((int)obj.charAt(0)); 
     1045        return (int)obj.charAt(0); 
    10441046    } 
    10451047 
     
    10531055    public static Object hex(Integer obj) 
    10541056    { 
    1055         return "0x" + Integer.toHexString(obj.intValue()); 
     1057        return "0x" + Integer.toHexString(obj); 
    10561058    } 
    10571059 
     
    10651067    public static Object oct(Integer obj) 
    10661068    { 
    1067         return "0o" + Integer.toOctalString(obj.intValue()); 
     1069        return "0o" + Integer.toOctalString(obj); 
    10681070    } 
    10691071 
     
    10771079    public static Object bin(Integer obj) 
    10781080    { 
    1079         return "0b" + Integer.toBinaryString(obj.intValue()); 
     1081        return "0b" + Integer.toBinaryString(obj); 
    10801082    } 
    10811083 
     
    11271129    public static Object range(Integer obj) 
    11281130    { 
    1129         return new Range(0, obj.intValue(), 1); 
     1131        return new Range(0, obj, 1); 
    11301132    } 
    11311133 
     
    11391141    public static Object range(Integer obj1, Integer obj2) 
    11401142    { 
    1141         return new Range(obj1.intValue(), obj2.intValue(), 1); 
     1143        return new Range(obj1, obj2, 1); 
    11421144    } 
    11431145 
     
    11511153    public static Object range(Integer obj1, Integer obj2, Integer obj3) 
    11521154    { 
    1153         return new Range(obj1.intValue(), obj2.intValue(), obj3.intValue()); 
     1155        return new Range(obj1, obj2, obj3); 
    11541156    } 
    11551157 
     
    11731175    public static Object split(String obj1, String obj2) 
    11741176    { 
    1175         LinkedList retVal = new LinkedList(); 
     1177        LinkedList<String> retVal = new LinkedList<String>(); 
    11761178        int length = obj1.length(); 
    11771179        int delimLength = obj2.length(); 
     
    14351437    { 
    14361438        if (obj instanceof String && arg1 instanceof String) 
    1437             return new Integer(((String)obj).indexOf((String)arg1)); 
     1439            return ((String)obj).indexOf((String)arg1); 
    14381440        throw new UnsupportedOperationException("Can't call find on instance of " + obj.getClass() + "!"); 
    14391441    } 
     
    14421444    { 
    14431445        if (obj instanceof String && arg1 instanceof String) 
    1444             return new Integer(((String)obj).lastIndexOf((String)arg1)); 
     1446            return ((String)obj).lastIndexOf((String)arg1); 
    14451447        throw new UnsupportedOperationException("Can't call rfind on instance of " + obj.getClass() + "!"); 
    14461448    }