1/*
2 * Copyright (c) 1994, 2014, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.  Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26package sun.tools.tree;
27
28import sun.tools.java.*;
29import sun.tools.asm.Assembler;
30import java.io.PrintStream;
31import java.util.Hashtable;
32
33/**
34 * WARNING: The contents of this source file are not part of any
35 * supported API.  Code that depends on them does so at its own risk:
36 * they are subject to change or removal without notice.
37 */
38public
39class ConvertExpression extends UnaryExpression {
40    /**
41     * Constructor
42     */
43    public ConvertExpression(long where, Type type, Expression right) {
44        super(CONVERT, where, type, right);
45    }
46
47    /**
48     * Check the value
49     */
50    public Vset checkValue(Environment env, Context ctx, Vset vset, Hashtable<Object, Object> exp) {
51        return right.checkValue(env, ctx, vset, exp);
52    }
53
54    /**
55     * Simplify
56     */
57    Expression simplify() {
58        switch (right.op) {
59          case BYTEVAL:
60          case CHARVAL:
61          case SHORTVAL:
62          case INTVAL: {
63            int value = ((IntegerExpression)right).value;
64            switch (type.getTypeCode()) {
65              case TC_BYTE:     return new ByteExpression(right.where, (byte)value);
66              case TC_CHAR:     return new CharExpression(right.where, (char)value);
67              case TC_SHORT:    return new ShortExpression(right.where, (short)value);
68              case TC_INT:      return new IntExpression(right.where, value);
69              case TC_LONG:     return new LongExpression(right.where, (long)value);
70              case TC_FLOAT:    return new FloatExpression(right.where, (float)value);
71              case TC_DOUBLE:   return new DoubleExpression(right.where, (double)value);
72            }
73            break;
74          }
75          case LONGVAL: {
76            long value = ((LongExpression)right).value;
77            switch (type.getTypeCode()) {
78              case TC_BYTE:     return new ByteExpression(right.where, (byte)value);
79              case TC_CHAR:     return new CharExpression(right.where, (char)value);
80              case TC_SHORT:    return new ShortExpression(right.where, (short)value);
81              case TC_INT:      return new IntExpression(right.where, (int)value);
82              case TC_FLOAT:    return new FloatExpression(right.where, (float)value);
83              case TC_DOUBLE:   return new DoubleExpression(right.where, (double)value);
84            }
85            break;
86          }
87          case FLOATVAL: {
88            float value = ((FloatExpression)right).value;
89            switch (type.getTypeCode()) {
90              case TC_BYTE:     return new ByteExpression(right.where, (byte)value);
91              case TC_CHAR:     return new CharExpression(right.where, (char)value);
92              case TC_SHORT:    return new ShortExpression(right.where, (short)value);
93              case TC_INT:      return new IntExpression(right.where, (int)value);
94              case TC_LONG:     return new LongExpression(right.where, (long)value);
95              case TC_DOUBLE:   return new DoubleExpression(right.where, (double)value);
96            }
97            break;
98          }
99          case DOUBLEVAL: {
100            double value = ((DoubleExpression)right).value;
101            switch (type.getTypeCode()) {
102              case TC_BYTE:     return new ByteExpression(right.where, (byte)value);
103              case TC_CHAR:     return new CharExpression(right.where, (char)value);
104              case TC_SHORT:    return new ShortExpression(right.where, (short)value);
105              case TC_INT:      return new IntExpression(right.where, (int)value);
106              case TC_LONG:     return new LongExpression(right.where, (long)value);
107              case TC_FLOAT:    return new FloatExpression(right.where, (float)value);
108            }
109            break;
110          }
111        }
112        return this;
113    }
114
115    /**
116     * Check if the expression is equal to a value
117     */
118    public boolean equals(int i) {
119        return right.equals(i);
120    }
121    public boolean equals(boolean b) {
122        return right.equals(b);
123    }
124
125    /**
126     * Inline
127     */
128    public Expression inline(Environment env, Context ctx) {
129        // super.inline throws away the op.
130        // This is sometimes incorrect, since casts can have side effects.
131        if (right.type.inMask(TM_REFERENCE) && type.inMask(TM_REFERENCE)) {
132            try {
133                if (!env.implicitCast(right.type, type))
134                    return inlineValue(env, ctx);
135            } catch (ClassNotFound e) {
136                throw new CompilerError(e);
137            }
138        }
139        return super.inline(env, ctx);
140    }
141
142    /**
143     * Code
144     */
145    public void codeValue(Environment env, Context ctx, Assembler asm) {
146        right.codeValue(env, ctx, asm);
147        codeConversion(env, ctx, asm, right.type, type);
148    }
149
150    /**
151     * Print
152     */
153    public void print(PrintStream out) {
154        out.print("(" + opNames[op] + " " + type.toString() + " ");
155        right.print(out);
156        out.print(")");
157    }
158}
159