1 /*
2 * Copyright (c) 2015, 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 package java.lang;
26
27 import java.lang.StackWalker.Option;
28 import java.util.EnumSet;
29 import java.util.Set;
30
31 import static java.lang.StackWalker.ExtendedOption.*;
32
33 final class LiveStackFrameInfo extends StackFrameInfo implements LiveStackFrame {
34 private static Object[] EMPTY_ARRAY = new Object[0];
35
36 LiveStackFrameInfo(StackWalker walker) {
37 super(walker);
38 }
39
40 // These fields are initialized by the VM if ExtendedOption.LOCALS_AND_OPERANDS is set
41 private Object[] monitors = EMPTY_ARRAY;
42 private Object[] locals = EMPTY_ARRAY;
43 private Object[] operands = EMPTY_ARRAY;
44
45 @Override
46 public Object[] getMonitors() {
47 return monitors;
48 }
49
50 @Override
51 public Object[] getLocals() {
52 return locals;
53 }
54
55 @Override
56 public Object[] getStack() {
57 return operands;
58 }
59
60 /*
61 * Convert primitive value to {@code Primitive} object to represent
62 * a local variable or an element on the operand stack of primitive type.
63 */
64 static PrimitiveValue asPrimitive(boolean value) {
65 return new BooleanPrimitive(value);
66 }
67
68 static PrimitiveValue asPrimitive(int value) {
69 return new IntPrimitive(value);
70 }
71
72 static PrimitiveValue asPrimitive(short value) {
73 return new ShortPrimitive(value);
74 }
75
76 static PrimitiveValue asPrimitive(char value) {
77 System.out.println("CharPrimitive " + value);
78 return new CharPrimitive(value);
79 }
80
81 static PrimitiveValue asPrimitive(byte value) {
82 return new BytePrimitive(value);
83 }
84
85 static PrimitiveValue asPrimitive(long value) {
86 return new LongPrimitive(value);
87 }
88
89 static PrimitiveValue asPrimitive(float value) {
90 return new FloatPrimitive(value);
91 }
92
93 static PrimitiveValue asPrimitive(double value) {
94 return new DoublePrimitive(value);
95 }
96
97 private static class IntPrimitive implements PrimitiveValue {
98 final int value;
99 IntPrimitive(int value) {
100 this.value = value;
101 }
102
103 @Override
104 public char type() {
105 return 'I';
106 }
107
108 @Override
109 public int intValue() {
110 return value;
111 }
112
113 @Override
114 public String toString() {
115 return String.valueOf(value);
116 }
117 }
118
119 private static class ShortPrimitive implements PrimitiveValue {
120 final short value;
121 ShortPrimitive(short value) {
122 this.value = value;
123 }
124
125 @Override
126 public char type() {
127 return 'S';
128 }
129
130 @Override
131 public short shortValue() {
132 return value;
133 }
134
135 @Override
136 public String toString() {
137 return String.valueOf(value);
138 }
139 }
140
141 private static class BooleanPrimitive implements PrimitiveValue {
142 final boolean value;
143 BooleanPrimitive(boolean value) {
144 this.value = value;
145 }
146
147 @Override
148 public char type() {
149 return 'Z';
150 }
151
152 @Override
153 public boolean booleanValue() {
154 return value;
155 }
156
157 @Override
158 public String toString() {
159 return String.valueOf(value);
160 }
161 }
162
163 private static class CharPrimitive implements PrimitiveValue {
164 final char value;
165 CharPrimitive(char value) {
166 this.value = value;
167 }
168
169 @Override
170 public char type() {
171 return 'C';
172 }
173
174 @Override
175 public char charValue() {
176 return value;
177 }
178
179 @Override
180 public String toString() {
181 return String.valueOf(value);
182 }
183 }
184
185 private static class BytePrimitive implements PrimitiveValue {
186 final byte value;
187 BytePrimitive(byte value) {
188 this.value = value;
189 }
190
191 @Override
192 public char type() {
193 return 'B';
194 }
195
196 @Override
197 public byte byteValue() {
198 return value;
199 }
200
201 @Override
202 public String toString() {
203 return String.valueOf(value);
204 }
205 }
206
207 private static class LongPrimitive implements PrimitiveValue {
208 final long value;
209 LongPrimitive(long value) {
210 this.value = value;
211 }
212
213 @Override
214 public char type() {
215 return 'J';
216 }
217
218 @Override
219 public long longValue() {
220 return value;
221 }
222
223 @Override
224 public String toString() {
225 return String.valueOf(value);
226 }
227 }
228
229 private static class FloatPrimitive implements PrimitiveValue {
230 final float value;
231 FloatPrimitive(float value) {
232 this.value = value;
233 }
234
235 @Override
236 public char type() {
237 return 'F';
238 }
239
240 @Override
241 public float floatValue() {
242 return value;
243 }
244
245 @Override
246 public String toString() {
247 return String.valueOf(value);
248 }
249 }
250
251 private static class DoublePrimitive implements PrimitiveValue {
252 final double value;
253 DoublePrimitive(double value) {
254 this.value = value;
255 }
256
257 @Override
258 public char type() {
259 return 'D';
260 }
261
262 @Override
263 public double doubleValue() {
264 return value;
265 }
266
267 @Override
268 public String toString() {
269 return String.valueOf(value);
270 }
271 }
272 }