1/* Automatically generated by genvm, do not edit! */ 2#define SEND_TO_SUPER(sendSelector, sendArgs, methodClass) \ 3 _gst_send_message_internal(sendSelector, sendArgs, _gst_self, methodClass) 4 5#if REG_AVAILABILITY >= 2 && defined(LOCAL_REGS) 6#define RECEIVER_VARIABLE(index) INSTANCE_VARIABLE (self_cache, index) 7#define METHOD_TEMPORARY(index) temp_cache[index] 8#define METHOD_LITERAL(index) lit_cache[index] 9#define STORE_RECEIVER_VARIABLE(index, oop) STORE_INSTANCE_VARIABLE (self_cache, index, oop) 10#define STORE_METHOD_TEMPORARY(index, oop) temp_cache[index] = (oop) 11#define STORE_METHOD_LITERAL(index, oop) lit_cache[index] = (oop) 12#else 13#define RECEIVER_VARIABLE(index) INSTANCE_VARIABLE (_gst_self, index) 14#define METHOD_TEMPORARY(index) _gst_temporaries[index] 15#define METHOD_LITERAL(index) _gst_literals[index] 16#define STORE_RECEIVER_VARIABLE(index, oop) STORE_INSTANCE_VARIABLE (_gst_self, index, oop) 17#define STORE_METHOD_TEMPORARY(index, oop) _gst_temporaries[index] = (oop) 18#define STORE_METHOD_LITERAL(index, oop) _gst_literals[index] = (oop) 19#endif 20 21#ifndef OPEN_CODE_MATH 22 23#define RAW_INT_OP(op, op1, op2, iop) 24#define RAW_FLOATD_OP(op, op1, op2, fop) 25#define INTERP_BASIC_OP(op, op1, op2, iop, fop) 26#define INTERP_BASIC_BOOL(op, op1, op2, operator) 27 28#else 29 30#define RAW_INT_OP(op, op1, op2, iop) \ 31{ \ 32 mst_Boolean overflow; \ 33 OOP result = iop; \ 34 if(COMMON (!overflow)) { \ 35 op = result; \ 36 break; \ 37 } \ 38} 39 40#define RAW_FLOATD_OP(op, op1, op2, fop) \ 41{ \ 42 double farg1, farg2; \ 43 farg1 = IS_INT (op1) ? TO_INT (op1) : FLOATD_OOP_VALUE(op1); \ 44 farg2 = IS_INT (op2) ? TO_INT (op2) : FLOATD_OOP_VALUE(op2); \ 45 EXPORT_REGS(); \ 46 op = floatd_new(fop); \ 47 IMPORT_REGS(); \ 48 break; \ 49} 50 51#define INTERP_BASIC_OP(op, op1, op2, iop, fop) { \ 52 if COMMON (ARE_INTS(op1, op2)) { \ 53 RAW_INT_OP(op, op1, op2, iop); \ 54 } else if COMMON ((IS_INT (op1) || OOP_CLASS(op1) == _gst_floatd_class) \ 55 && (IS_INT (op2) || OOP_CLASS(op2) == _gst_floatd_class)) \ 56 RAW_FLOATD_OP(op, op1, op2, fop); \ 57} 58 59#define INTERP_BASIC_BOOL(op, op1, op2, operator) { \ 60 if COMMON (ARE_INTS(op1, op2)) { \ 61 POP_N_OOPS (2); \ 62 if (((intptr_t) op1) operator ((intptr_t) op2)) \ 63 DISPATCH(true_byte_codes); \ 64 else \ 65 DISPATCH(false_byte_codes); \ 66 } else if COMMON ((IS_INT (op1) || OOP_CLASS(op1) == _gst_floatd_class) \ 67 && (IS_INT (op2) || OOP_CLASS(op2) == _gst_floatd_class)) { \ 68 double farg1 = IS_INT (op1) ? TO_INT (op1) : FLOATD_OOP_VALUE(op1); \ 69 double farg2 = IS_INT (op2) ? TO_INT (op2) : FLOATD_OOP_VALUE(op2); \ 70 POP_N_OOPS (2); \ 71 if (farg1 operator farg2) \ 72 DISPATCH(true_byte_codes); \ 73 else \ 74 DISPATCH(false_byte_codes); \ 75 } \ 76} 77#endif 78 79#ifdef PIPELINING 80#define FETCH goto *(t = dispatch_vec[*ip], b2 = ip[2], b4 = ip[4], \ 81 arg = ip[1], arg2 = ip[3], t2 = dispatch_vec[b2], t) 82#define FETCH_VEC(v) goto *(t = (v)[*ip], b2 = ip[2], b4 = ip[4], \ 83 arg = ip[1], arg2 = ip[3], t2 = dispatch_vec[b2], t) 84 85#define PREFETCH (t = t2, t2 = dispatch_vec[b4], \ 86 arg2 = ip[3], b2 = b4, b4 = ip[6], \ 87 ip += 2) 88#define PREFETCH_VEC(v) (t = (v)[b2], t2 = dispatch_vec[b4], \ 89 arg2 = ip[3], b2 = b4, b4 = ip[6], \ 90 ip += 2) 91 92#define NEXT_BC goto *(arg = GET_ARG, t) 93#define NEXT_BC_VEC(v) goto *(arg = GET_ARG, t) 94#define NEXT_BC_NO_ARG(v) goto *t 95#define GET_ARG arg2 96 97#elif REG_AVAILABILITY >= 1 98#define FETCH goto *(arg = GET_ARG, dispatch_vec[*ip]) 99#define FETCH_VEC(v) goto *(arg = GET_ARG, (v)[*ip]) 100#define PREFETCH (ip += 2, prefetch = dispatch_vec[*ip]) 101#define PREFETCH_VEC(v) (ip += 2, prefetch = (v)[*ip]) 102#define NEXT_BC goto *(arg = GET_ARG, prefetch) 103#define NEXT_BC_VEC(v) goto *(arg = GET_ARG, prefetch) 104#define NEXT_BC_NO_ARG(v) goto *prefetch 105#define GET_ARG (ip[1]) 106 107#else 108#define FETCH NEXT_BC 109#define FETCH_VEC(v) NEXT_BC_VEC(v) 110#define PREFETCH (ip += 2) 111#define PREFETCH_VEC(v) (ip += 2) 112#define NEXT_BC goto *(arg = GET_ARG, dispatch_vec[*ip]) 113#define NEXT_BC_VEC(v) goto *(arg = GET_ARG, (v)[*ip]) 114#define NEXT_BC_NO_ARG(v) goto *(v)[*ip] 115#define GET_ARG (ip[1]) 116#endif 117 118#define DISPATCH(v) goto *(arg = GET_ARG, (v)[*ip]) 119 120 static void *monitored_byte_codes[256] = { 121 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 0 */ 122 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 4 */ 123 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 8 */ 124 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 12 */ 125 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 16 */ 126 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 20 */ 127 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 24 */ 128 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 28 */ 129 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 32 */ 130 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 36 */ 131 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 40 */ 132 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 44 */ 133 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 48 */ 134 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 52 */ 135 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 56 */ 136 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 60 */ 137 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 64 */ 138 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 68 */ 139 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 72 */ 140 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 76 */ 141 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 80 */ 142 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 84 */ 143 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 88 */ 144 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 92 */ 145 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 96 */ 146 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 100 */ 147 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 104 */ 148 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 108 */ 149 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 112 */ 150 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 116 */ 151 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 120 */ 152 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 124 */ 153 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 128 */ 154 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 132 */ 155 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 136 */ 156 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 140 */ 157 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 144 */ 158 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 148 */ 159 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 152 */ 160 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 156 */ 161 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 160 */ 162 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 164 */ 163 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 168 */ 164 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 172 */ 165 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 176 */ 166 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 180 */ 167 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 184 */ 168 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 188 */ 169 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 192 */ 170 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 196 */ 171 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 200 */ 172 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 204 */ 173 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 208 */ 174 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 212 */ 175 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 216 */ 176 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 220 */ 177 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 224 */ 178 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 228 */ 179 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 232 */ 180 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 236 */ 181 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 240 */ 182 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 244 */ 183 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, /* 248 */ 184 &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes, &&monitor_byte_codes /* 252 */ 185 }; 186 187 static void *true_byte_codes[256] = { 188 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 0 */ 189 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 4 */ 190 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 8 */ 191 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 12 */ 192 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 16 */ 193 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 20 */ 194 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 24 */ 195 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 28 */ 196 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 32 */ 197 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 36 */ 198 &&lookahead_failed_true, &&lookahead_failed_true, &&bc41, &&bc54, /* 40 */ 199 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 44 */ 200 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 48 */ 201 &&lookahead_dup_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 52 */ 202 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 56 */ 203 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 60 */ 204 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 64 */ 205 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 68 */ 206 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 72 */ 207 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 76 */ 208 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 80 */ 209 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 84 */ 210 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 88 */ 211 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 92 */ 212 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 96 */ 213 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 100 */ 214 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 104 */ 215 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 108 */ 216 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 112 */ 217 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 116 */ 218 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 120 */ 219 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 124 */ 220 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 128 */ 221 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 132 */ 222 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 136 */ 223 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 140 */ 224 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 144 */ 225 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 148 */ 226 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 152 */ 227 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 156 */ 228 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 160 */ 229 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 164 */ 230 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 168 */ 231 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 172 */ 232 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 176 */ 233 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 180 */ 234 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 184 */ 235 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 188 */ 236 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 192 */ 237 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 196 */ 238 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 200 */ 239 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 204 */ 240 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 208 */ 241 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 212 */ 242 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 216 */ 243 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 220 */ 244 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 224 */ 245 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 228 */ 246 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 232 */ 247 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 236 */ 248 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 240 */ 249 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 244 */ 250 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, /* 248 */ 251 &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true, &&lookahead_failed_true /* 252 */ 252 }; 253 254 static void *false_byte_codes[256] = { 255 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 0 */ 256 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 4 */ 257 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 8 */ 258 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 12 */ 259 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 16 */ 260 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 20 */ 261 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 24 */ 262 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 28 */ 263 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 32 */ 264 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 36 */ 265 &&lookahead_failed_false, &&lookahead_failed_false, &&bc54, &&bc41, /* 40 */ 266 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 44 */ 267 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 48 */ 268 &&lookahead_dup_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 52 */ 269 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 56 */ 270 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 60 */ 271 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 64 */ 272 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 68 */ 273 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 72 */ 274 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 76 */ 275 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 80 */ 276 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 84 */ 277 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 88 */ 278 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 92 */ 279 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 96 */ 280 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 100 */ 281 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 104 */ 282 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 108 */ 283 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 112 */ 284 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 116 */ 285 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 120 */ 286 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 124 */ 287 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 128 */ 288 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 132 */ 289 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 136 */ 290 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 140 */ 291 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 144 */ 292 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 148 */ 293 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 152 */ 294 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 156 */ 295 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 160 */ 296 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 164 */ 297 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 168 */ 298 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 172 */ 299 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 176 */ 300 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 180 */ 301 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 184 */ 302 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 188 */ 303 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 192 */ 304 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 196 */ 305 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 200 */ 306 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 204 */ 307 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 208 */ 308 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 212 */ 309 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 216 */ 310 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 220 */ 311 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 224 */ 312 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 228 */ 313 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 232 */ 314 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 236 */ 315 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 240 */ 316 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 244 */ 317 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, /* 248 */ 318 &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false, &&lookahead_failed_false /* 252 */ 319 }; 320 321 static void *normal_byte_codes[256] = { 322 &&bc0, &&bc1, &&bc2, &&bc3, /* 0 */ 323 &&bc4, &&bc5, &&bc6, &&bc7, /* 4 */ 324 &&bc8, &&bc9, &&bc10, &&bc11, /* 8 */ 325 &&bc12, &&bc13, &&bc14, &&bc15, /* 12 */ 326 &&bc16, &&bc17, &&bc18, &&bc19, /* 16 */ 327 &&bc20, &&bc21, &&bc22, &&bc23, /* 20 */ 328 &&bc24, &&bc25, &&bc26, &&bc27, /* 24 */ 329 &&bc28, &&bc29, &&bc30, &&bc31, /* 28 */ 330 &&bc32, &&bc33, &&bc34, &&bc35, /* 32 */ 331 &&bc36, &&bc37, &&bc38, &&bc39, /* 36 */ 332 &&bc40, &&bc41, &&bc42, &&bc43, /* 40 */ 333 &&bc44, &&bc45, &&bc46, &&bc47, /* 44 */ 334 &&bc48, &&bc49, &&bc50, &&bc51, /* 48 */ 335 &&bc52, &&bc53, &&bc54, &&bc55, /* 52 */ 336 &&bc56, &&bc57, &&bc58, &&bc59, /* 56 */ 337 &&bc60, &&bc61, &&bc62, &&bc63, /* 60 */ 338 &&bc64, &&bc65, &&bc66, &&bc67, /* 64 */ 339 &&bc68, &&bc69, &&bc70, &&bc71, /* 68 */ 340 &&bc72, &&bc73, &&bc74, &&bc75, /* 72 */ 341 &&bc76, &&bc77, &&bc78, &&bc79, /* 76 */ 342 &&bc80, &&bc81, &&bc82, &&bc83, /* 80 */ 343 &&bc84, &&bc85, &&bc86, &&bc87, /* 84 */ 344 &&bc88, &&bc89, &&bc90, &&bc91, /* 88 */ 345 &&bc92, &&bc93, &&bc94, &&bc95, /* 92 */ 346 &&bc96, &&bc97, &&bc98, &&bc99, /* 96 */ 347 &&bc100, &&bc101, &&bc102, &&bc103, /* 100 */ 348 &&bc104, &&bc105, &&bc106, &&bc107, /* 104 */ 349 &&bc108, &&bc109, &&bc110, &&bc111, /* 108 */ 350 &&bc112, &&bc113, &&bc114, &&bc115, /* 112 */ 351 &&bc116, &&bc117, &&bc118, &&bc119, /* 116 */ 352 &&bc120, &&bc121, &&bc122, &&bc123, /* 120 */ 353 &&bc124, &&bc125, &&bc126, &&bc127, /* 124 */ 354 &&bc128, &&bc129, &&bc130, &&bc131, /* 128 */ 355 &&bc132, &&bc133, &&bc134, &&bc135, /* 132 */ 356 &&bc136, &&bc137, &&bc138, &&bc139, /* 136 */ 357 &&bc140, &&bc141, &&bc142, &&bc143, /* 140 */ 358 &&bc144, &&bc145, &&bc146, &&bc147, /* 144 */ 359 &&bc148, &&bc149, &&bc150, &&bc151, /* 148 */ 360 &&bc152, &&bc153, &&bc154, &&bc155, /* 152 */ 361 &&bc156, &&bc157, &&bc158, &&bc159, /* 156 */ 362 &&bc160, &&bc161, &&bc162, &&bc163, /* 160 */ 363 &&bc164, &&bc165, &&bc166, &&bc167, /* 164 */ 364 &&bc168, &&bc169, &&bc170, &&bc171, /* 168 */ 365 &&bc172, &&bc173, &&bc174, &&bc175, /* 172 */ 366 &&bc176, &&bc177, &&bc178, &&bc179, /* 176 */ 367 &&bc180, &&bc181, &&bc182, &&bc183, /* 180 */ 368 &&bc184, &&bc185, &&bc186, &&bc187, /* 184 */ 369 &&bc188, &&bc189, &&bc190, &&bc191, /* 188 */ 370 &&bc192, &&bc193, &&bc194, &&bc195, /* 192 */ 371 &&bc196, &&bc197, &&bc198, &&bc199, /* 196 */ 372 &&bc200, &&bc201, &&bc202, &&bc203, /* 200 */ 373 &&bc204, &&bc205, &&bc206, &&bc207, /* 204 */ 374 &&bc208, &&bc209, &&bc210, &&bc211, /* 208 */ 375 &&bc212, &&bc213, &&bc214, &&bc215, /* 212 */ 376 &&bc216, &&bc217, &&bc218, &&bc219, /* 216 */ 377 &&bc220, &&bc221, &&bc222, &&bc223, /* 220 */ 378 &&bc224, &&bc225, &&bc226, &&bc227, /* 224 */ 379 &&bc228, &&bc229, &&bc230, &&bc231, /* 228 */ 380 &&bc232, &&bc233, &&bc234, &&bc235, /* 232 */ 381 &&bc236, &&bc237, &&bc238, &&bc239, /* 236 */ 382 &&bc240, &&bc241, &&bc242, &&bc243, /* 240 */ 383 &&bc244, &&bc245, &&bc246, &&bc247, /* 244 */ 384 &&bc248, &&bc249, &&bc250, &&bc251, /* 248 */ 385 &&bc252, &&bc253, &&bc254, &&bc255 /* 252 */ 386 }; 387 388 goto jump_around; 389bc0: 390 { 391 OOP _stack0, _stack1; 392 _stack1 = STACK_AT (1); 393 _stack0 = STACK_AT (0); 394 /* PREFETCH ( -- ) */ 395 do 396 { 397#line 207 "vm.def" 398 PREFETCH; 399 LOCAL_COUNTER++; 400 401#line 402 "vm.inl" 402 } 403 while (0); 404 /* PLUS_SPECIAL ( op1 op2 -- op ) */ 405 do 406 { 407#define PREPARE_STACK() do { \ 408 } while (0) 409#define op1 _stack1 410#define op2 _stack0 411#define op _stack1 412#line 230 "vm.def" 413 INTERP_BASIC_OP (op, op1, op2, 414 add_with_check (op1, op2, &overflow), 415 farg1 + farg2); 416 PREPARE_STACK (); 417 EXPORT_REGS (); 418 SEND_MESSAGE (_gst_builtin_selectors[PLUS_SPECIAL].symbol, 1); 419 IMPORT_REGS (); 420 FETCH; 421 422#line 423 "vm.inl" 423#undef PREPARE_STACK 424#undef op1 425#undef op2 426#undef op 427 } 428 while (0); 429 STACK_AT (1) = _stack1; 430 POP_N_OOPS (1); 431 } 432 NEXT_BC; 433bc1: 434 { 435 OOP _stack0, _stack1; 436 _stack1 = STACK_AT (1); 437 _stack0 = STACK_AT (0); 438 /* PREFETCH ( -- ) */ 439 do 440 { 441#line 207 "vm.def" 442 PREFETCH; 443 LOCAL_COUNTER++; 444 445#line 446 "vm.inl" 446 } 447 while (0); 448 /* MINUS_SPECIAL ( op1 op2 -- op ) */ 449 do 450 { 451#define PREPARE_STACK() do { \ 452 } while (0) 453#define op1 _stack1 454#define op2 _stack0 455#define op _stack1 456#line 241 "vm.def" 457 INTERP_BASIC_OP (op, op1, op2, 458 sub_with_check (op1, op2, &overflow), 459 farg1 - farg2); 460 PREPARE_STACK (); 461 EXPORT_REGS (); 462 SEND_MESSAGE (_gst_builtin_selectors[MINUS_SPECIAL].symbol, 1); 463 IMPORT_REGS (); 464 FETCH; 465 466#line 467 "vm.inl" 467#undef PREPARE_STACK 468#undef op1 469#undef op2 470#undef op 471 } 472 while (0); 473 STACK_AT (1) = _stack1; 474 POP_N_OOPS (1); 475 } 476 NEXT_BC; 477bc2: 478 { 479 OOP _stack0, _stack1; 480 _stack1 = STACK_AT (1); 481 _stack0 = STACK_AT (0); 482 /* PREFETCH ( -- ) */ 483 do 484 { 485#line 207 "vm.def" 486 PREFETCH; 487 LOCAL_COUNTER++; 488 489#line 490 "vm.inl" 490 } 491 while (0); 492 /* LESS_THAN_SPECIAL ( op1 op2 -- op ) */ 493 do 494 { 495#define PREPARE_STACK() do { \ 496 } while (0) 497#define op1 _stack1 498#define op2 _stack0 499#define op _stack1 500#line 252 "vm.def" 501 PREPARE_STACK (); 502 INTERP_BASIC_BOOL (op, op1, op2, <); 503 EXPORT_REGS (); 504 SEND_MESSAGE (_gst_builtin_selectors[LESS_THAN_SPECIAL].symbol, 1); 505 IMPORT_REGS (); 506 FETCH; 507 508#line 509 "vm.inl" 509#undef PREPARE_STACK 510#undef op1 511#undef op2 512#undef op 513 } 514 while (0); 515 STACK_AT (1) = _stack1; 516 POP_N_OOPS (1); 517 } 518 NEXT_BC; 519bc3: 520 { 521 OOP _stack0, _stack1; 522 _stack1 = STACK_AT (1); 523 _stack0 = STACK_AT (0); 524 /* PREFETCH ( -- ) */ 525 do 526 { 527#line 207 "vm.def" 528 PREFETCH; 529 LOCAL_COUNTER++; 530 531#line 532 "vm.inl" 532 } 533 while (0); 534 /* GREATER_THAN_SPECIAL ( op1 op2 -- op ) */ 535 do 536 { 537#define PREPARE_STACK() do { \ 538 } while (0) 539#define op1 _stack1 540#define op2 _stack0 541#define op _stack1 542#line 261 "vm.def" 543 PREPARE_STACK (); 544 INTERP_BASIC_BOOL (op, op1, op2, >); 545 EXPORT_REGS (); 546 SEND_MESSAGE (_gst_builtin_selectors[GREATER_THAN_SPECIAL].symbol, 1); 547 IMPORT_REGS (); 548 FETCH; 549 550#line 551 "vm.inl" 551#undef PREPARE_STACK 552#undef op1 553#undef op2 554#undef op 555 } 556 while (0); 557 STACK_AT (1) = _stack1; 558 POP_N_OOPS (1); 559 } 560 NEXT_BC; 561bc4: 562 { 563 OOP _stack0, _stack1; 564 _stack1 = STACK_AT (1); 565 _stack0 = STACK_AT (0); 566 /* PREFETCH ( -- ) */ 567 do 568 { 569#line 207 "vm.def" 570 PREFETCH; 571 LOCAL_COUNTER++; 572 573#line 574 "vm.inl" 574 } 575 while (0); 576 /* LESS_EQUAL_SPECIAL ( op1 op2 -- op ) */ 577 do 578 { 579#define PREPARE_STACK() do { \ 580 } while (0) 581#define op1 _stack1 582#define op2 _stack0 583#define op _stack1 584#line 270 "vm.def" 585 PREPARE_STACK (); 586 INTERP_BASIC_BOOL (op, op1, op2, <=); 587 EXPORT_REGS (); 588 SEND_MESSAGE (_gst_builtin_selectors[LESS_EQUAL_SPECIAL].symbol, 1); 589 IMPORT_REGS (); 590 FETCH; 591 592#line 593 "vm.inl" 593#undef PREPARE_STACK 594#undef op1 595#undef op2 596#undef op 597 } 598 while (0); 599 STACK_AT (1) = _stack1; 600 POP_N_OOPS (1); 601 } 602 NEXT_BC; 603bc5: 604 { 605 OOP _stack0, _stack1; 606 _stack1 = STACK_AT (1); 607 _stack0 = STACK_AT (0); 608 /* PREFETCH ( -- ) */ 609 do 610 { 611#line 207 "vm.def" 612 PREFETCH; 613 LOCAL_COUNTER++; 614 615#line 616 "vm.inl" 616 } 617 while (0); 618 /* GREATER_EQUAL_SPECIAL ( op1 op2 -- op ) */ 619 do 620 { 621#define PREPARE_STACK() do { \ 622 } while (0) 623#define op1 _stack1 624#define op2 _stack0 625#define op _stack1 626#line 279 "vm.def" 627 PREPARE_STACK (); 628 INTERP_BASIC_BOOL (op, op1, op2, >=); 629 EXPORT_REGS (); 630 SEND_MESSAGE (_gst_builtin_selectors[GREATER_EQUAL_SPECIAL].symbol, 1); 631 IMPORT_REGS (); 632 FETCH; 633 634#line 635 "vm.inl" 635#undef PREPARE_STACK 636#undef op1 637#undef op2 638#undef op 639 } 640 while (0); 641 STACK_AT (1) = _stack1; 642 POP_N_OOPS (1); 643 } 644 NEXT_BC; 645bc6: 646 { 647 OOP _stack0, _stack1; 648 _stack1 = STACK_AT (1); 649 _stack0 = STACK_AT (0); 650 /* PREFETCH ( -- ) */ 651 do 652 { 653#line 207 "vm.def" 654 PREFETCH; 655 LOCAL_COUNTER++; 656 657#line 658 "vm.inl" 658 } 659 while (0); 660 /* EQUAL_SPECIAL ( op1 op2 -- op ) */ 661 do 662 { 663#define PREPARE_STACK() do { \ 664 } while (0) 665#define op1 _stack1 666#define op2 _stack0 667#define op _stack1 668#line 288 "vm.def" 669 PREPARE_STACK (); 670 INTERP_BASIC_BOOL (op, op1, op2, ==); 671 EXPORT_REGS (); 672 SEND_MESSAGE (_gst_builtin_selectors[EQUAL_SPECIAL].symbol, 1); 673 IMPORT_REGS (); 674 FETCH; 675 676#line 677 "vm.inl" 677#undef PREPARE_STACK 678#undef op1 679#undef op2 680#undef op 681 } 682 while (0); 683 STACK_AT (1) = _stack1; 684 POP_N_OOPS (1); 685 } 686 NEXT_BC; 687bc7: 688 { 689 OOP _stack0, _stack1; 690 _stack1 = STACK_AT (1); 691 _stack0 = STACK_AT (0); 692 /* PREFETCH ( -- ) */ 693 do 694 { 695#line 207 "vm.def" 696 PREFETCH; 697 LOCAL_COUNTER++; 698 699#line 700 "vm.inl" 700 } 701 while (0); 702 /* NOT_EQUAL_SPECIAL ( op1 op2 -- op ) */ 703 do 704 { 705#define PREPARE_STACK() do { \ 706 } while (0) 707#define op1 _stack1 708#define op2 _stack0 709#define op _stack1 710#line 297 "vm.def" 711 PREPARE_STACK (); 712 INTERP_BASIC_BOOL (op, op1, op2, !=); 713 EXPORT_REGS (); 714 SEND_MESSAGE (_gst_builtin_selectors[NOT_EQUAL_SPECIAL].symbol, 1); 715 IMPORT_REGS (); 716 FETCH; 717 718#line 719 "vm.inl" 719#undef PREPARE_STACK 720#undef op1 721#undef op2 722#undef op 723 } 724 while (0); 725 STACK_AT (1) = _stack1; 726 POP_N_OOPS (1); 727 } 728 NEXT_BC; 729bc8: 730 { 731 OOP _stack0, _stack1; 732 _stack1 = STACK_AT (1); 733 _stack0 = STACK_AT (0); 734 /* PREFETCH ( -- ) */ 735 do 736 { 737#line 207 "vm.def" 738 PREFETCH; 739 LOCAL_COUNTER++; 740 741#line 742 "vm.inl" 742 } 743 while (0); 744 /* TIMES_SPECIAL ( op1 op2 -- op ) */ 745 do 746 { 747#define PREPARE_STACK() do { \ 748 } while (0) 749#define op1 _stack1 750#define op2 _stack0 751#define op _stack1 752#line 306 "vm.def" 753 INTERP_BASIC_OP (op, op1, op2, 754 mul_with_check (op1, op2, &overflow), 755 farg1 * farg2); 756 PREPARE_STACK (); 757 EXPORT_REGS (); 758 SEND_MESSAGE (_gst_builtin_selectors[TIMES_SPECIAL].symbol, 1); 759 IMPORT_REGS (); 760 FETCH; 761 762#line 763 "vm.inl" 763#undef PREPARE_STACK 764#undef op1 765#undef op2 766#undef op 767 } 768 while (0); 769 STACK_AT (1) = _stack1; 770 POP_N_OOPS (1); 771 } 772 NEXT_BC; 773bc9: 774 { 775 OOP _stack0, _stack1; 776 _stack1 = STACK_AT (1); 777 _stack0 = STACK_AT (0); 778 /* PREFETCH ( -- ) */ 779 do 780 { 781#line 207 "vm.def" 782 PREFETCH; 783 LOCAL_COUNTER++; 784 785#line 786 "vm.inl" 786 } 787 while (0); 788 /* DIVIDE_SPECIAL ( op1 op2 -- op ) */ 789 do 790 { 791#define PREPARE_STACK() do { \ 792 } while (0) 793#define op1 _stack1 794#define op2 _stack0 795#define op _stack1 796#line 317 "vm.def" 797 if COMMON (!ARE_INTS (op1, op2) 798 && (IS_INT (op1) || OOP_CLASS(op1) == _gst_floatd_class) 799 && (IS_INT (op2) || OOP_CLASS(op2) == _gst_floatd_class)) 800 { 801 RAW_FLOATD_OP(op, op1, op2, farg1 / farg2); 802 } 803 804 PREPARE_STACK (); 805 EXPORT_REGS(); 806 if (COMMON (ARE_INTS (op1, op2))) 807 { 808 if (!VMpr_SmallInteger_divide (10, 1)) 809 { 810 IMPORT_REGS (); 811 NEXT_BC; 812 } 813 } 814 815 SEND_MESSAGE (_gst_builtin_selectors[DIVIDE_SPECIAL].symbol, 1); 816 IMPORT_REGS (); 817 FETCH; 818 819#line 820 "vm.inl" 820#undef PREPARE_STACK 821#undef op1 822#undef op2 823#undef op 824 } 825 while (0); 826 STACK_AT (1) = _stack1; 827 POP_N_OOPS (1); 828 } 829 NEXT_BC; 830bc10: 831 { 832 OOP _stack0, _stack1; 833 _stack1 = STACK_AT (1); 834 _stack0 = STACK_AT (0); 835 /* PREFETCH ( -- ) */ 836 do 837 { 838#line 207 "vm.def" 839 PREFETCH; 840 LOCAL_COUNTER++; 841 842#line 843 "vm.inl" 843 } 844 while (0); 845 /* REMAINDER_SPECIAL ( op1 op2 -- op ) */ 846 do 847 { 848#define PREPARE_STACK() do { \ 849 } while (0) 850#define op1 _stack1 851#define op2 _stack0 852#define op _stack1 853#line 341 "vm.def" 854 PREPARE_STACK (); 855 EXPORT_REGS(); 856 if (IS_INT (op1) && IS_INT (op2) 857 && !VMpr_SmallInteger_modulo (11, 1)) 858 { 859 IMPORT_REGS (); 860 NEXT_BC; 861 } 862 863 SEND_MESSAGE (_gst_builtin_selectors[REMAINDER_SPECIAL].symbol, 1); 864 IMPORT_REGS (); 865 FETCH; 866 867#line 868 "vm.inl" 868#undef PREPARE_STACK 869#undef op1 870#undef op2 871#undef op 872 } 873 while (0); 874 STACK_AT (1) = _stack1; 875 POP_N_OOPS (1); 876 } 877 NEXT_BC; 878bc11: 879 { 880 OOP _stack0, _stack1; 881 _stack1 = STACK_AT (1); 882 _stack0 = STACK_AT (0); 883 /* PREFETCH ( -- ) */ 884 do 885 { 886#line 207 "vm.def" 887 PREFETCH; 888 LOCAL_COUNTER++; 889 890#line 891 "vm.inl" 891 } 892 while (0); 893 /* BIT_XOR_SPECIAL ( op1 op2 -- op ) */ 894 do 895 { 896#define PREPARE_STACK() do { \ 897 } while (0) 898#define op1 _stack1 899#define op2 _stack0 900#define op _stack1 901#line 356 "vm.def" 902 if COMMON (ARE_INTS (op1, op2)) 903 { 904 op = tagged_xor (op1, op2); 905 break; 906 } 907 908 PREPARE_STACK (); 909 EXPORT_REGS (); 910 SEND_MESSAGE (_gst_builtin_selectors[BIT_XOR_SPECIAL].symbol, 1); 911 IMPORT_REGS (); 912 FETCH; 913 914#line 915 "vm.inl" 915#undef PREPARE_STACK 916#undef op1 917#undef op2 918#undef op 919 } 920 while (0); 921 STACK_AT (1) = _stack1; 922 POP_N_OOPS (1); 923 } 924 NEXT_BC; 925bc12: 926 { 927 OOP _stack0, _stack1; 928 _stack1 = STACK_AT (1); 929 _stack0 = STACK_AT (0); 930 /* PREFETCH ( -- ) */ 931 do 932 { 933#line 207 "vm.def" 934 PREFETCH; 935 LOCAL_COUNTER++; 936 937#line 938 "vm.inl" 938 } 939 while (0); 940 /* BIT_SHIFT_SPECIAL ( op1 op2 -- op ) */ 941 do 942 { 943#define PREPARE_STACK() do { \ 944 } while (0) 945#define op1 _stack1 946#define op2 _stack0 947#define op _stack1 948#line 370 "vm.def" 949 if COMMON (IS_INT (op2) && IS_INT (op1)) 950 { 951 intptr_t iarg1, iarg2; 952 iarg1 = TO_INT (op1); 953 iarg2 = TO_INT (op2); 954 if (iarg2 < 0) 955 { 956 if COMMON (iarg2 >= -ST_INT_SIZE) 957 op = FROM_INT (iarg1 >> -iarg2); 958 else 959 op = FROM_INT (iarg1 >> ST_INT_SIZE); 960 961 break; 962 } 963 else if COMMON (iarg2 < ST_INT_SIZE) 964 { 965 intptr_t result = iarg1 << iarg2; 966 if COMMON ((result >> iarg2) == iarg1 && !INT_OVERFLOW(result)) 967 { 968 op = FROM_INT (result); 969 break; 970 } 971 } 972 } 973 974 PREPARE_STACK (); 975 EXPORT_REGS (); 976 SEND_MESSAGE (_gst_builtin_selectors[BIT_SHIFT_SPECIAL].symbol, 1); 977 IMPORT_REGS (); 978 FETCH; 979 980#line 981 "vm.inl" 981#undef PREPARE_STACK 982#undef op1 983#undef op2 984#undef op 985 } 986 while (0); 987 STACK_AT (1) = _stack1; 988 POP_N_OOPS (1); 989 } 990 NEXT_BC; 991bc13: 992 { 993 OOP _stack0, _stack1; 994 _stack1 = STACK_AT (1); 995 _stack0 = STACK_AT (0); 996 /* PREFETCH ( -- ) */ 997 do 998 { 999#line 207 "vm.def" 1000 PREFETCH; 1001 LOCAL_COUNTER++; 1002 1003#line 1004 "vm.inl" 1004 } 1005 while (0); 1006 /* INTEGER_DIVIDE_SPECIAL ( op1 op2 | -- op1 op2 | ) */ 1007 do 1008 { 1009#define PREPARE_STACK() do { \ 1010 } while (0) 1011#define op1 _stack1 1012#define op2 _stack0 1013#line 403 "vm.def" 1014 PREPARE_STACK (); 1015 EXPORT_REGS(); 1016 if (IS_INT (op1) && IS_INT (op2) 1017 && !VMpr_SmallInteger_intDiv (12, 1)) 1018 { 1019 IMPORT_REGS (); 1020 NEXT_BC; 1021 } 1022 1023 SEND_MESSAGE (_gst_builtin_selectors[INTEGER_DIVIDE_SPECIAL].symbol, 1); 1024 IMPORT_REGS (); 1025 FETCH; 1026 1027#line 1028 "vm.inl" 1028#undef PREPARE_STACK 1029#undef op1 1030#undef op2 1031 } 1032 while (0); 1033 } 1034 NEXT_BC; 1035bc14: 1036 { 1037 OOP _stack0, _stack1; 1038 _stack1 = STACK_AT (1); 1039 _stack0 = STACK_AT (0); 1040 /* PREFETCH ( -- ) */ 1041 do 1042 { 1043#line 207 "vm.def" 1044 PREFETCH; 1045 LOCAL_COUNTER++; 1046 1047#line 1048 "vm.inl" 1048 } 1049 while (0); 1050 /* BIT_AND_SPECIAL ( op1 op2 -- op ) */ 1051 do 1052 { 1053#define PREPARE_STACK() do { \ 1054 } while (0) 1055#define op1 _stack1 1056#define op2 _stack0 1057#define op _stack1 1058#line 418 "vm.def" 1059 op = tagged_and (op1, op2); 1060 if COMMON (IS_INT (op)) 1061 break; 1062 1063 PREPARE_STACK (); 1064 EXPORT_REGS (); 1065 SEND_MESSAGE (_gst_builtin_selectors[BIT_AND_SPECIAL].symbol, 1); 1066 IMPORT_REGS (); 1067 FETCH; 1068 1069#line 1070 "vm.inl" 1070#undef PREPARE_STACK 1071#undef op1 1072#undef op2 1073#undef op 1074 } 1075 while (0); 1076 STACK_AT (1) = _stack1; 1077 POP_N_OOPS (1); 1078 } 1079 NEXT_BC; 1080bc15: 1081 { 1082 OOP _stack0, _stack1; 1083 _stack1 = STACK_AT (1); 1084 _stack0 = STACK_AT (0); 1085 /* PREFETCH ( -- ) */ 1086 do 1087 { 1088#line 207 "vm.def" 1089 PREFETCH; 1090 LOCAL_COUNTER++; 1091 1092#line 1093 "vm.inl" 1093 } 1094 while (0); 1095 /* BIT_OR_SPECIAL ( op1 op2 -- op ) */ 1096 do 1097 { 1098#define PREPARE_STACK() do { \ 1099 } while (0) 1100#define op1 _stack1 1101#define op2 _stack0 1102#define op _stack1 1103#line 430 "vm.def" 1104 if COMMON (ARE_INTS (op1, op2)) 1105 { 1106 op = tagged_or (op1, op2); 1107 break; 1108 } 1109 1110 PREPARE_STACK (); 1111 EXPORT_REGS (); 1112 SEND_MESSAGE (_gst_builtin_selectors[BIT_OR_SPECIAL].symbol, 1); 1113 IMPORT_REGS (); 1114 FETCH; 1115 1116#line 1117 "vm.inl" 1117#undef PREPARE_STACK 1118#undef op1 1119#undef op2 1120#undef op 1121 } 1122 while (0); 1123 STACK_AT (1) = _stack1; 1124 POP_N_OOPS (1); 1125 } 1126 NEXT_BC; 1127bc16: 1128 { 1129 OOP _stack0, _stack1; 1130 _stack1 = STACK_AT (1); 1131 _stack0 = STACK_AT (0); 1132 /* PREFETCH ( -- ) */ 1133 do 1134 { 1135#line 207 "vm.def" 1136 PREFETCH; 1137 LOCAL_COUNTER++; 1138 1139#line 1140 "vm.inl" 1140 } 1141 while (0); 1142 /* AT_SPECIAL ( rec idx -- val ) */ 1143 do 1144 { 1145#define PREPARE_STACK() do { \ 1146 } while (0) 1147#define rec _stack1 1148#define idx _stack0 1149#define val _stack1 1150#line 444 "vm.def" 1151 OOP classOOP; 1152 PREPARE_STACK (); 1153 EXPORT_REGS (); 1154 if UNCOMMON (IS_INT (rec)) 1155 { 1156 SEND_MESSAGE (_gst_builtin_selectors[AT_SPECIAL].symbol, 1); 1157 IMPORT_REGS (); 1158 FETCH; 1159 } 1160 1161 if COMMON (at_cache_class == (classOOP = OOP_CLASS (rec)) 1162 && !cached_index_oop_primitive (rec, idx, at_cache_spec)) 1163 { 1164 IMPORT_REGS (); 1165 NEXT_BC; 1166 } 1167 1168 /* Not the same class that is in the cache, or the primitive failed -- 1169 send the message, and modify the cache if the send is resolved to 1170 a primitive. */ 1171 last_primitive = 0; 1172 SEND_MESSAGE (_gst_builtin_selectors[AT_SPECIAL].symbol, 1); 1173 IMPORT_REGS (); 1174 if (_gst_primitive_table[last_primitive].id == 60) 1175 { 1176 at_cache_spec = CLASS_INSTANCE_SPEC (classOOP); 1177 at_cache_class = classOOP; 1178 NEXT_BC; 1179 } 1180 FETCH; 1181 1182#line 1183 "vm.inl" 1183#undef PREPARE_STACK 1184#undef rec 1185#undef idx 1186#undef val 1187 } 1188 while (0); 1189 STACK_AT (1) = _stack1; 1190 POP_N_OOPS (1); 1191 } 1192 NEXT_BC; 1193bc17: 1194 { 1195 OOP _stack0, _stack1, _stack2; 1196 _stack2 = STACK_AT (2); 1197 _stack1 = STACK_AT (1); 1198 _stack0 = STACK_AT (0); 1199 /* PREFETCH ( -- ) */ 1200 do 1201 { 1202#line 207 "vm.def" 1203 PREFETCH; 1204 LOCAL_COUNTER++; 1205 1206#line 1207 "vm.inl" 1207 } 1208 while (0); 1209 /* AT_PUT_SPECIAL ( rec idx val -- res ) */ 1210 do 1211 { 1212#define PREPARE_STACK() do { \ 1213 } while (0) 1214#define rec _stack2 1215#define idx _stack1 1216#define val _stack0 1217#define res _stack2 1218#line 477 "vm.def" 1219 OOP classOOP; 1220 PREPARE_STACK (); 1221 EXPORT_REGS (); 1222 if UNCOMMON (IS_INT (rec)) 1223 { 1224 SEND_MESSAGE (_gst_builtin_selectors[AT_PUT_SPECIAL].symbol, 2); 1225 IMPORT_REGS (); 1226 FETCH; 1227 } 1228 1229 if COMMON (at_put_cache_class == (classOOP = OOP_CLASS (rec)) 1230 && !cached_index_oop_put_primitive (rec, idx, val, at_put_cache_spec)) 1231 { 1232 IMPORT_REGS (); 1233 NEXT_BC; 1234 } 1235 1236 /* Not the same class that is in the cache, or the primitive failed -- 1237 send the message, and modify the cache if the send is resolved to 1238 a primitive. */ 1239 last_primitive = 0; 1240 SEND_MESSAGE (_gst_builtin_selectors[AT_PUT_SPECIAL].symbol, 2); 1241 IMPORT_REGS (); 1242 if (_gst_primitive_table[last_primitive].id == 61) 1243 { 1244 at_put_cache_spec = CLASS_INSTANCE_SPEC (classOOP); 1245 at_put_cache_class = classOOP; 1246 NEXT_BC; 1247 } 1248 FETCH; 1249 1250#line 1251 "vm.inl" 1251#undef PREPARE_STACK 1252#undef rec 1253#undef idx 1254#undef val 1255#undef res 1256 } 1257 while (0); 1258 STACK_AT (2) = _stack2; 1259 POP_N_OOPS (2); 1260 } 1261 NEXT_BC; 1262bc18: 1263 { 1264 OOP _stack0; 1265 _stack0 = STACK_AT (0); 1266 /* PREFETCH ( -- ) */ 1267 do 1268 { 1269#line 207 "vm.def" 1270 PREFETCH; 1271 LOCAL_COUNTER++; 1272 1273#line 1274 "vm.inl" 1274 } 1275 while (0); 1276 /* SIZE_SPECIAL ( rec -- val ) */ 1277 do 1278 { 1279#define PREPARE_STACK() do { \ 1280 } while (0) 1281#define rec _stack0 1282#define val _stack0 1283#line 510 "vm.def" 1284 OOP classOOP; 1285 PREPARE_STACK (); 1286 EXPORT_REGS (); 1287 if UNCOMMON (IS_INT (rec)) 1288 { 1289 SEND_MESSAGE (_gst_builtin_selectors[SIZE_SPECIAL].symbol, 0); 1290 IMPORT_REGS (); 1291 FETCH; 1292 } 1293 1294 if COMMON (size_cache_class == (classOOP = OOP_CLASS (rec)) 1295 && !execute_primitive_operation (size_cache_prim, 0)) 1296 { 1297 IMPORT_REGS (); 1298 NEXT_BC; 1299 } 1300 1301 /* Not the same class that is in the cache, or the primitive failed -- 1302 send the message, and modify the cache if the send is resolved to 1303 a primitive. */ 1304 last_primitive = 0; 1305 SEND_MESSAGE (_gst_builtin_selectors[SIZE_SPECIAL].symbol, 0); 1306 IMPORT_REGS (); 1307 if COMMON (last_primitive) 1308 { 1309 size_cache_prim = last_primitive; 1310 size_cache_class = classOOP; 1311 NEXT_BC; 1312 } 1313 FETCH; 1314 1315#line 1316 "vm.inl" 1316#undef PREPARE_STACK 1317#undef rec 1318#undef val 1319 } 1320 while (0); 1321 STACK_AT (0) = _stack0; 1322 } 1323 NEXT_BC; 1324bc19: 1325 { 1326 OOP _stack0; 1327 _stack0 = STACK_AT (0); 1328 /* PREFETCH ( -- ) */ 1329 do 1330 { 1331#line 207 "vm.def" 1332 PREFETCH; 1333 LOCAL_COUNTER++; 1334 1335#line 1336 "vm.inl" 1336 } 1337 while (0); 1338 /* CLASS_SPECIAL ( rec -- val ) */ 1339 do 1340 { 1341#define PREPARE_STACK() do { \ 1342 } while (0) 1343#define rec _stack0 1344#define val _stack0 1345#line 543 "vm.def" 1346 OOP classOOP; 1347 PREPARE_STACK (); 1348 EXPORT_REGS (); 1349 if UNCOMMON (IS_INT (rec)) 1350 { 1351 SEND_MESSAGE (_gst_builtin_selectors[CLASS_SPECIAL].symbol, 0); 1352 IMPORT_REGS (); 1353 FETCH; 1354 } 1355 1356 if COMMON (class_cache_class == (classOOP = OOP_CLASS (rec)) 1357 && !execute_primitive_operation (class_cache_prim, 1)) 1358 { 1359 IMPORT_REGS (); 1360 NEXT_BC; 1361 } 1362 1363 /* Not the same class that is in the cache, or the primitive failed -- 1364 send the message, and modify the cache if the send is resolved to 1365 a primitive. */ 1366 last_primitive = 0; 1367 SEND_MESSAGE (_gst_builtin_selectors[CLASS_SPECIAL].symbol, 0); 1368 IMPORT_REGS (); 1369 if COMMON (last_primitive) 1370 { 1371 class_cache_prim = last_primitive; 1372 class_cache_class = classOOP; 1373 NEXT_BC; 1374 } 1375 FETCH; 1376 1377#line 1378 "vm.inl" 1378#undef PREPARE_STACK 1379#undef rec 1380#undef val 1381 } 1382 while (0); 1383 STACK_AT (0) = _stack0; 1384 } 1385 NEXT_BC; 1386bc20: 1387 { 1388 OOP _stack0; 1389 _stack0 = STACK_AT (0); 1390 /* PREFETCH ( -- ) */ 1391 do 1392 { 1393#line 207 "vm.def" 1394 PREFETCH; 1395 LOCAL_COUNTER++; 1396 1397#line 1398 "vm.inl" 1398 } 1399 while (0); 1400 /* IS_NIL_SPECIAL ( rec -- val ) */ 1401 do 1402 { 1403#define rec _stack0 1404#define val _stack0 1405#line 576 "vm.def" 1406 /* DO_JUMP_LOOKAHEAD (rec == _gst_nil_oop); */ 1407 val = rec == _gst_nil_oop ? _gst_true_oop : _gst_false_oop; 1408 1409#line 1410 "vm.inl" 1410#undef rec 1411#undef val 1412 } 1413 while (0); 1414 STACK_AT (0) = _stack0; 1415 } 1416 NEXT_BC; 1417bc21: 1418 { 1419 OOP _stack0; 1420 _stack0 = STACK_AT (0); 1421 /* PREFETCH ( -- ) */ 1422 do 1423 { 1424#line 207 "vm.def" 1425 PREFETCH; 1426 LOCAL_COUNTER++; 1427 1428#line 1429 "vm.inl" 1429 } 1430 while (0); 1431 /* NOT_NIL_SPECIAL ( rec -- val ) */ 1432 do 1433 { 1434#define rec _stack0 1435#define val _stack0 1436#line 581 "vm.def" 1437 /* DO_JUMP_LOOKAHEAD (rec != _gst_nil_oop); */ 1438 val = rec != _gst_nil_oop ? _gst_true_oop : _gst_false_oop; 1439 1440#line 1441 "vm.inl" 1441#undef rec 1442#undef val 1443 } 1444 while (0); 1445 STACK_AT (0) = _stack0; 1446 } 1447 NEXT_BC; 1448bc22: 1449 { 1450 OOP _stack0; 1451 _stack0 = STACK_AT (0); 1452 /* PREFETCH ( -- ) */ 1453 do 1454 { 1455#line 207 "vm.def" 1456 PREFETCH; 1457 LOCAL_COUNTER++; 1458 1459#line 1460 "vm.inl" 1460 } 1461 while (0); 1462 /* VALUE_SPECIAL ( rec | -- rec | ) */ 1463 do 1464 { 1465#define PREPARE_STACK() do { \ 1466 } while (0) 1467#define rec _stack0 1468#line 586 "vm.def" 1469 PREPARE_STACK (); 1470 EXPORT_REGS (); 1471 if (UNCOMMON (IS_INT (rec)) 1472 || UNCOMMON (OOP_CLASS (rec) != _gst_block_closure_class) 1473 || UNCOMMON (send_block_value (0, 0))) 1474 SEND_MESSAGE (_gst_builtin_selectors[VALUE_SPECIAL].symbol, 0); 1475 1476 IMPORT_REGS (); 1477 FETCH; 1478 1479#line 1480 "vm.inl" 1480#undef PREPARE_STACK 1481#undef rec 1482 } 1483 while (0); 1484 } 1485 NEXT_BC; 1486bc23: 1487 { 1488 OOP _stack0, _stack1; 1489 _stack1 = STACK_AT (1); 1490 _stack0 = STACK_AT (0); 1491 /* PREFETCH ( -- ) */ 1492 do 1493 { 1494#line 207 "vm.def" 1495 PREFETCH; 1496 LOCAL_COUNTER++; 1497 1498#line 1499 "vm.inl" 1499 } 1500 while (0); 1501 /* VALUE_COLON_SPECIAL ( rec blk_arg | -- rec blk_arg | ) */ 1502 do 1503 { 1504#define PREPARE_STACK() do { \ 1505 } while (0) 1506#define rec _stack1 1507#define blk_arg _stack0 1508#line 598 "vm.def" 1509 PREPARE_STACK (); 1510 EXPORT_REGS (); 1511 if (UNCOMMON (IS_INT (rec)) 1512 || UNCOMMON (OOP_CLASS (rec) != _gst_block_closure_class) 1513 || UNCOMMON (send_block_value (1, 0))) 1514 SEND_MESSAGE (_gst_builtin_selectors[VALUE_COLON_SPECIAL].symbol, 1); 1515 1516 IMPORT_REGS (); 1517 FETCH; 1518 1519#line 1520 "vm.inl" 1520#undef PREPARE_STACK 1521#undef rec 1522#undef blk_arg 1523 } 1524 while (0); 1525 } 1526 NEXT_BC; 1527bc24: 1528 { 1529 OOP _stack0, _stack1; 1530 _stack1 = STACK_AT (1); 1531 _stack0 = STACK_AT (0); 1532 /* PREFETCH ( -- ) */ 1533 do 1534 { 1535#line 207 "vm.def" 1536 PREFETCH; 1537 LOCAL_COUNTER++; 1538 1539#line 1540 "vm.inl" 1540 } 1541 while (0); 1542 /* SAME_OBJECT_SPECIAL ( op1 op2 -- op ) */ 1543 do 1544 { 1545#define op1 _stack1 1546#define op2 _stack0 1547#define op _stack1 1548#line 610 "vm.def" 1549 /* DO_JUMP_LOOKAHEAD (op1 == op2); */ 1550 op = (op1 == op2) ? _gst_true_oop : _gst_false_oop; 1551 1552#line 1553 "vm.inl" 1553#undef op1 1554#undef op2 1555#undef op 1556 } 1557 while (0); 1558 STACK_AT (1) = _stack1; 1559 POP_N_OOPS (1); 1560 } 1561 NEXT_BC; 1562bc25: 1563 { 1564 OOP _stack0; 1565 _stack0 = STACK_AT (0); 1566 /* PREFETCH ( -- ) */ 1567 do 1568 { 1569#line 207 "vm.def" 1570 PREFETCH; 1571 LOCAL_COUNTER++; 1572 1573#line 1574 "vm.inl" 1574 } 1575 while (0); 1576 /* JAVA_AS_INT_SPECIAL ( rec -- val ) */ 1577 do 1578 { 1579#define PREPARE_STACK() do { \ 1580 } while (0) 1581#define rec _stack0 1582#define val _stack0 1583#line 615 "vm.def" 1584 if COMMON (IS_INT (rec) || is_c_int_32 (rec)) 1585 { 1586 val = rec; 1587 break; 1588 } 1589 1590 PREPARE_STACK (); 1591 EXPORT_REGS (); 1592 SEND_MESSAGE (_gst_builtin_selectors[JAVA_AS_INT_SPECIAL].symbol, 0); 1593 IMPORT_REGS (); 1594 FETCH; 1595 1596#line 1597 "vm.inl" 1597#undef PREPARE_STACK 1598#undef rec 1599#undef val 1600 } 1601 while (0); 1602 STACK_AT (0) = _stack0; 1603 } 1604 NEXT_BC; 1605bc26: 1606 { 1607 OOP _stack0; 1608 _stack0 = STACK_AT (0); 1609 /* PREFETCH ( -- ) */ 1610 do 1611 { 1612#line 207 "vm.def" 1613 PREFETCH; 1614 LOCAL_COUNTER++; 1615 1616#line 1617 "vm.inl" 1617 } 1618 while (0); 1619 /* JAVA_AS_LONG_SPECIAL ( rec -- val ) */ 1620 do 1621 { 1622#define PREPARE_STACK() do { \ 1623 } while (0) 1624#define rec _stack0 1625#define val _stack0 1626#line 629 "vm.def" 1627 if COMMON (IS_INT (rec) || is_c_int_64 (rec)) 1628 { 1629 val = rec; 1630 break; 1631 } 1632 1633 PREPARE_STACK (); 1634 EXPORT_REGS (); 1635 SEND_MESSAGE (_gst_builtin_selectors[JAVA_AS_LONG_SPECIAL].symbol, 0); 1636 IMPORT_REGS (); 1637 FETCH; 1638 1639#line 1640 "vm.inl" 1640#undef PREPARE_STACK 1641#undef rec 1642#undef val 1643 } 1644 while (0); 1645 STACK_AT (0) = _stack0; 1646 } 1647 NEXT_BC; 1648bc27: 1649 { 1650 /* PREFETCH ( -- ) */ 1651 do 1652 { 1653#line 207 "vm.def" 1654 PREFETCH; 1655 LOCAL_COUNTER++; 1656 1657#line 1658 "vm.inl" 1658 } 1659 while (0); 1660 /* INVALID ( -- ) */ 1661 do 1662 { 1663 int arg = arg; 1664#line 226 "vm.def" 1665 _gst_errorf ("Invalid bytecode %d(%d) found!", ip[-1], arg); 1666 1667#line 1668 "vm.inl" 1668 } 1669 while (0); 1670 } 1671 NEXT_BC; 1672bc28: 1673 { 1674 /* PREFETCH ( -- ) */ 1675 do 1676 { 1677#line 207 "vm.def" 1678 PREFETCH; 1679 LOCAL_COUNTER++; 1680 1681#line 1682 "vm.inl" 1682 } 1683 while (0); 1684 /* SEND ( -- ) */ 1685 do 1686 { 1687 int sel = arg >> 8; 1688 int n = arg & 255; 1689#define PREPARE_STACK() do { \ 1690 } while (0) 1691#line 643 "vm.def" 1692 PREPARE_STACK (); 1693 EXPORT_REGS (); 1694 SEND_MESSAGE (METHOD_LITERAL (sel), n); 1695 IMPORT_REGS (); 1696 FETCH; 1697 1698#line 1699 "vm.inl" 1699#undef PREPARE_STACK 1700 } 1701 while (0); 1702 } 1703 NEXT_BC; 1704bc29: 1705 { 1706 /* PREFETCH ( -- ) */ 1707 do 1708 { 1709#line 207 "vm.def" 1710 PREFETCH; 1711 LOCAL_COUNTER++; 1712 1713#line 1714 "vm.inl" 1714 } 1715 while (0); 1716 /* SEND_SUPER ( -- ) */ 1717 do 1718 { 1719 int sel = arg >> 8; 1720 int n = arg & 255; 1721#define PREPARE_STACK() do { \ 1722 } while (0) 1723#line 651 "vm.def" 1724 OOP classOOP; 1725 PREPARE_STACK (); 1726 classOOP = POP_OOP (); 1727 1728 EXPORT_REGS (); 1729 SEND_TO_SUPER (METHOD_LITERAL (sel), n, classOOP); 1730 IMPORT_REGS (); 1731 FETCH; 1732 1733#line 1734 "vm.inl" 1734#undef PREPARE_STACK 1735 } 1736 while (0); 1737 } 1738 NEXT_BC; 1739bc30: 1740 { 1741 /* PREFETCH ( -- ) */ 1742 do 1743 { 1744#line 207 "vm.def" 1745 PREFETCH; 1746 LOCAL_COUNTER++; 1747 1748#line 1749 "vm.inl" 1749 } 1750 while (0); 1751 /* SEND_IMMEDIATE ( -- ) */ 1752 do 1753 { 1754 int n = arg; 1755#define PREPARE_STACK() do { \ 1756 } while (0) 1757#line 662 "vm.def" 1758 const struct builtin_selector *bs = &_gst_builtin_selectors[n]; 1759 PREPARE_STACK (); 1760 EXPORT_REGS (); 1761 SEND_MESSAGE (bs->symbol, bs->numArgs); 1762 IMPORT_REGS (); 1763 FETCH; 1764 1765#line 1766 "vm.inl" 1766#undef PREPARE_STACK 1767 } 1768 while (0); 1769 } 1770 NEXT_BC; 1771bc31: 1772 { 1773 /* PREFETCH ( -- ) */ 1774 do 1775 { 1776#line 207 "vm.def" 1777 PREFETCH; 1778 LOCAL_COUNTER++; 1779 1780#line 1781 "vm.inl" 1781 } 1782 while (0); 1783 /* SEND_SUPER_IMMEDIATE ( -- ) */ 1784 do 1785 { 1786 int n = arg; 1787#define PREPARE_STACK() do { \ 1788 } while (0) 1789#line 671 "vm.def" 1790 OOP classOOP; 1791 const struct builtin_selector *bs = &_gst_builtin_selectors[n]; 1792 PREPARE_STACK (); 1793 classOOP = POP_OOP (); 1794 1795 EXPORT_REGS (); 1796 SEND_TO_SUPER (bs->symbol, bs->numArgs, classOOP); 1797 IMPORT_REGS (); 1798 FETCH; 1799 1800#line 1801 "vm.inl" 1801#undef PREPARE_STACK 1802 } 1803 while (0); 1804 } 1805 NEXT_BC; 1806bc32: 1807 { 1808 OOP _extra1; 1809 /* PREFETCH ( -- ) */ 1810 do 1811 { 1812#line 207 "vm.def" 1813 PREFETCH; 1814 LOCAL_COUNTER++; 1815 1816#line 1817 "vm.inl" 1817 } 1818 while (0); 1819 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 1820 do 1821 { 1822 int n = arg; 1823#define tos _extra1 1824#line 683 "vm.def" 1825 tos = METHOD_TEMPORARY (n); 1826 1827#line 1828 "vm.inl" 1828#undef tos 1829 } 1830 while (0); 1831 PUSH_OOP (_extra1); 1832 } 1833 NEXT_BC; 1834bc33: 1835 { 1836 OOP _extra1; 1837 /* PREFETCH ( -- ) */ 1838 do 1839 { 1840#line 207 "vm.def" 1841 PREFETCH; 1842 LOCAL_COUNTER++; 1843 1844#line 1845 "vm.inl" 1845 } 1846 while (0); 1847 /* PUSH_OUTER_TEMP ( -- tos ) */ 1848 do 1849 { 1850 int n = arg >> 8; 1851 int scopes = arg & 255; 1852#define tos _extra1 1853#line 687 "vm.def" 1854 OOP contextOOP; 1855 gst_block_context context; 1856 1857 context = (gst_block_context) OOP_TO_OBJ (_gst_this_context_oop); 1858 do 1859 { 1860 contextOOP = context->outerContext; 1861 context = (gst_block_context) OOP_TO_OBJ (contextOOP); 1862 } 1863 while (--scopes); 1864 1865 tos = context->contextStack[n]; 1866 1867#line 1868 "vm.inl" 1868#undef tos 1869 } 1870 while (0); 1871 PUSH_OOP (_extra1); 1872 } 1873 NEXT_BC; 1874bc34: 1875 { 1876 OOP _extra1; 1877 /* PREFETCH ( -- ) */ 1878 do 1879 { 1880#line 207 "vm.def" 1881 PREFETCH; 1882 LOCAL_COUNTER++; 1883 1884#line 1885 "vm.inl" 1885 } 1886 while (0); 1887 /* PUSH_LIT_VARIABLE ( -- tos ) */ 1888 do 1889 { 1890 int n = arg; 1891#define PREPARE_STACK() do { \ 1892 } while (0) 1893#define tos _extra1 1894#line 702 "vm.def" 1895 tos = METHOD_LITERAL (n); 1896 if (UNCOMMON (IS_INT (tos)) 1897 || UNCOMMON (!is_a_kind_of (OOP_CLASS (tos), _gst_association_class))) 1898 { 1899 PREPARE_STACK (); 1900 PUSH_OOP (tos); 1901 EXPORT_REGS (); 1902 SEND_MESSAGE (_gst_builtin_selectors[VALUE_SPECIAL].symbol, 0); 1903 IMPORT_REGS (); 1904 FETCH; 1905 } 1906 else 1907 tos = ASSOCIATION_VALUE (tos); 1908 1909#line 1910 "vm.inl" 1910#undef PREPARE_STACK 1911#undef tos 1912 } 1913 while (0); 1914 PUSH_OOP (_extra1); 1915 } 1916 NEXT_BC; 1917bc35: 1918 { 1919 OOP _extra1; 1920 /* PREFETCH ( -- ) */ 1921 do 1922 { 1923#line 207 "vm.def" 1924 PREFETCH; 1925 LOCAL_COUNTER++; 1926 1927#line 1928 "vm.inl" 1928 } 1929 while (0); 1930 /* PUSH_RECEIVER_VARIABLE ( -- tos ) */ 1931 do 1932 { 1933 int n = arg; 1934#define tos _extra1 1935#line 718 "vm.def" 1936 tos = RECEIVER_VARIABLE (n); 1937 1938#line 1939 "vm.inl" 1939#undef tos 1940 } 1941 while (0); 1942 PUSH_OOP (_extra1); 1943 } 1944 NEXT_BC; 1945bc36: 1946 { 1947 OOP _stack0; 1948 _stack0 = STACK_AT (0); 1949 /* PREFETCH ( -- ) */ 1950 do 1951 { 1952#line 207 "vm.def" 1953 PREFETCH; 1954 LOCAL_COUNTER++; 1955 1956#line 1957 "vm.inl" 1957 } 1958 while (0); 1959 /* STORE_TEMPORARY_VARIABLE ( tos | -- tos | ) */ 1960 do 1961 { 1962 int n = arg; 1963#define tos _stack0 1964#line 722 "vm.def" 1965 STORE_METHOD_TEMPORARY (n, tos); 1966 1967#line 1968 "vm.inl" 1968#undef tos 1969 } 1970 while (0); 1971 } 1972 NEXT_BC; 1973bc37: 1974 { 1975 OOP _stack0; 1976 _stack0 = STACK_AT (0); 1977 /* PREFETCH ( -- ) */ 1978 do 1979 { 1980#line 207 "vm.def" 1981 PREFETCH; 1982 LOCAL_COUNTER++; 1983 1984#line 1985 "vm.inl" 1985 } 1986 while (0); 1987 /* STORE_OUTER_TEMP ( tos | -- tos | ) */ 1988 do 1989 { 1990 int n = arg >> 8; 1991 int scopes = arg & 255; 1992#define tos _stack0 1993#line 726 "vm.def" 1994 OOP contextOOP; 1995 gst_block_context context; 1996 1997 context = (gst_block_context) OOP_TO_OBJ (_gst_this_context_oop); 1998 do 1999 { 2000 contextOOP = context->outerContext; 2001 context = (gst_block_context) OOP_TO_OBJ (contextOOP); 2002 } 2003 while (--scopes); 2004 2005 context->contextStack[n] = tos; 2006 2007#line 2008 "vm.inl" 2008#undef tos 2009 } 2010 while (0); 2011 } 2012 NEXT_BC; 2013bc38: 2014 { 2015 OOP _stack0; 2016 _stack0 = STACK_AT (0); 2017 /* PREFETCH ( -- ) */ 2018 do 2019 { 2020#line 207 "vm.def" 2021 PREFETCH; 2022 LOCAL_COUNTER++; 2023 2024#line 2025 "vm.inl" 2025 } 2026 while (0); 2027 /* STORE_LIT_VARIABLE ( tos | -- tos | ) */ 2028 do 2029 { 2030 int n = arg; 2031#define PREPARE_STACK() do { \ 2032 } while (0) 2033#define tos _stack0 2034#line 741 "vm.def" 2035 OOP var = METHOD_LITERAL (n), value = tos; 2036 if (UNCOMMON (IS_INT (var)) 2037 || UNCOMMON (!is_a_kind_of (OOP_CLASS (var), _gst_association_class))) 2038 { 2039 PREPARE_STACK (); 2040 SET_STACKTOP (var); 2041 PUSH_OOP (value); 2042 EXPORT_REGS (); 2043 SEND_MESSAGE (_gst_builtin_selectors[VALUE_COLON_SPECIAL].symbol, 1); 2044 IMPORT_REGS (); 2045 FETCH; 2046 } 2047 else 2048 SET_ASSOCIATION_VALUE (var, value); 2049 2050#line 2051 "vm.inl" 2051#undef PREPARE_STACK 2052#undef tos 2053 } 2054 while (0); 2055 } 2056 NEXT_BC; 2057bc39: 2058 { 2059 OOP _stack0; 2060 _stack0 = STACK_AT (0); 2061 /* PREFETCH ( -- ) */ 2062 do 2063 { 2064#line 207 "vm.def" 2065 PREFETCH; 2066 LOCAL_COUNTER++; 2067 2068#line 2069 "vm.inl" 2069 } 2070 while (0); 2071 /* STORE_RECEIVER_VARIABLE ( tos | -- tos | ) */ 2072 do 2073 { 2074 int n = arg; 2075#define tos _stack0 2076#line 758 "vm.def" 2077 STORE_RECEIVER_VARIABLE (n, tos); 2078 2079#line 2080 "vm.inl" 2080#undef tos 2081 } 2082 while (0); 2083 } 2084 NEXT_BC; 2085bc40: 2086 { 2087 /* ADVANCE ( -- ) */ 2088 do 2089 { 2090#line 212 "vm.def" 2091 ip += 2; 2092 LOCAL_COUNTER++; 2093 2094#line 2095 "vm.inl" 2095 } 2096 while (0); 2097 /* JUMP_BACK ( -- ) */ 2098 do 2099 { 2100 int n = arg; 2101#define PREPARE_STACK() do { \ 2102 } while (0) 2103#line 762 "vm.def" 2104 PREPARE_STACK (); 2105 ip -= n; 2106 FETCH; 2107 2108#line 2109 "vm.inl" 2109#undef PREPARE_STACK 2110 } 2111 while (0); 2112 } 2113 NEXT_BC; 2114bc41: 2115 { 2116 /* ADVANCE ( -- ) */ 2117 do 2118 { 2119#line 212 "vm.def" 2120 ip += 2; 2121 LOCAL_COUNTER++; 2122 2123#line 2124 "vm.inl" 2124 } 2125 while (0); 2126 /* JUMP ( -- ) */ 2127 do 2128 { 2129 int n = arg; 2130#define PREPARE_STACK() do { \ 2131 } while (0) 2132#line 768 "vm.def" 2133 PREPARE_STACK (); 2134 ip += n; 2135 FETCH; 2136 2137#line 2138 "vm.inl" 2138#undef PREPARE_STACK 2139 } 2140 while (0); 2141 } 2142 NEXT_BC; 2143bc42: 2144 { 2145 OOP _stack0; 2146 _stack0 = STACK_AT (0); 2147 /* PREFETCH ( -- ) */ 2148 do 2149 { 2150#line 207 "vm.def" 2151 PREFETCH; 2152 LOCAL_COUNTER++; 2153 2154#line 2155 "vm.inl" 2155 } 2156 while (0); 2157 /* POP_JUMP_TRUE ( tos -- ) */ 2158 do 2159 { 2160 int n = arg; 2161#define PREPARE_STACK() do { \ 2162 } while (0) 2163#define tos _stack0 2164#line 793 "vm.def" 2165 if UNCOMMON (tos == _gst_true_oop) 2166 { 2167 PREPARE_STACK (); 2168 POP_N_OOPS(1); 2169 ip += n; 2170 FETCH; 2171 } 2172 else if UNCOMMON (tos != _gst_false_oop) 2173 { 2174 ip += n; 2175 PREPARE_STACK (); 2176 EXPORT_REGS(); 2177 SEND_MESSAGE(_gst_must_be_boolean_symbol, 0); 2178 IMPORT_REGS(); 2179 FETCH; 2180 } 2181 2182#line 2183 "vm.inl" 2183#undef PREPARE_STACK 2184#undef tos 2185 } 2186 while (0); 2187 POP_N_OOPS (1); 2188 } 2189 NEXT_BC; 2190bc43: 2191 { 2192 OOP _stack0; 2193 _stack0 = STACK_AT (0); 2194 /* PREFETCH ( -- ) */ 2195 do 2196 { 2197#line 207 "vm.def" 2198 PREFETCH; 2199 LOCAL_COUNTER++; 2200 2201#line 2202 "vm.inl" 2202 } 2203 while (0); 2204 /* POP_JUMP_FALSE ( tos -- ) */ 2205 do 2206 { 2207 int n = arg; 2208#define PREPARE_STACK() do { \ 2209 } while (0) 2210#define tos _stack0 2211#line 774 "vm.def" 2212 if UNCOMMON (tos == _gst_false_oop) 2213 { 2214 PREPARE_STACK (); 2215 POP_N_OOPS(1); 2216 ip += n; 2217 FETCH; 2218 } 2219 else if UNCOMMON (tos != _gst_true_oop) 2220 { 2221 ip += n; 2222 PREPARE_STACK (); 2223 EXPORT_REGS(); 2224 SEND_MESSAGE(_gst_must_be_boolean_symbol, 0); 2225 IMPORT_REGS(); 2226 FETCH; 2227 } 2228 2229#line 2230 "vm.inl" 2230#undef PREPARE_STACK 2231#undef tos 2232 } 2233 while (0); 2234 POP_N_OOPS (1); 2235 } 2236 NEXT_BC; 2237bc44: 2238 { 2239 OOP _extra1; 2240 /* PREFETCH ( -- ) */ 2241 do 2242 { 2243#line 207 "vm.def" 2244 PREFETCH; 2245 LOCAL_COUNTER++; 2246 2247#line 2248 "vm.inl" 2248 } 2249 while (0); 2250 /* PUSH_INTEGER ( -- tos ) */ 2251 do 2252 { 2253 int n = arg; 2254#define tos _extra1 2255#line 812 "vm.def" 2256 tos = FROM_INT (n); 2257 2258#line 2259 "vm.inl" 2259#undef tos 2260 } 2261 while (0); 2262 PUSH_OOP (_extra1); 2263 } 2264 NEXT_BC; 2265bc45: 2266 { 2267 OOP _extra1; 2268 /* PREFETCH ( -- ) */ 2269 do 2270 { 2271#line 207 "vm.def" 2272 PREFETCH; 2273 LOCAL_COUNTER++; 2274 2275#line 2276 "vm.inl" 2276 } 2277 while (0); 2278 /* PUSH_SPECIAL ( -- tos ) */ 2279 do 2280 { 2281 int n = arg; 2282#define tos _extra1 2283#line 816 "vm.def" 2284 tos = _gst_nil_oop + (n - NIL_INDEX); 2285 2286#line 2287 "vm.inl" 2287#undef tos 2288 } 2289 while (0); 2290 PUSH_OOP (_extra1); 2291 } 2292 NEXT_BC; 2293bc46: 2294 { 2295 OOP _extra1; 2296 /* PREFETCH ( -- ) */ 2297 do 2298 { 2299#line 207 "vm.def" 2300 PREFETCH; 2301 LOCAL_COUNTER++; 2302 2303#line 2304 "vm.inl" 2304 } 2305 while (0); 2306 /* PUSH_LIT_CONSTANT ( -- tos ) */ 2307 do 2308 { 2309 int n = arg; 2310#define tos _extra1 2311#line 820 "vm.def" 2312 tos = METHOD_LITERAL (n); 2313 2314#line 2315 "vm.inl" 2315#undef tos 2316 } 2317 while (0); 2318 PUSH_OOP (_extra1); 2319 } 2320 NEXT_BC; 2321bc47: 2322 { 2323 OOP _stack0, _stack1; 2324 _stack1 = STACK_AT (1); 2325 _stack0 = STACK_AT (0); 2326 /* PREFETCH ( -- ) */ 2327 do 2328 { 2329#line 207 "vm.def" 2330 PREFETCH; 2331 LOCAL_COUNTER++; 2332 2333#line 2334 "vm.inl" 2334 } 2335 while (0); 2336 /* POP_INTO_NEW_STACKTOP ( obj | val -- obj | ) */ 2337 do 2338 { 2339 int n = arg; 2340#define obj _stack1 2341#define val _stack0 2342#line 824 "vm.def" 2343 STORE_INSTANCE_VARIABLE (obj, n, val); 2344 2345#line 2346 "vm.inl" 2346#undef obj 2347#undef val 2348 } 2349 while (0); 2350 POP_N_OOPS (1); 2351 } 2352 NEXT_BC; 2353bc48: 2354 { 2355 OOP _stack0; 2356 _stack0 = STACK_AT (0); 2357 /* PREFETCH ( -- ) */ 2358 do 2359 { 2360#line 207 "vm.def" 2361 PREFETCH; 2362 LOCAL_COUNTER++; 2363 2364#line 2365 "vm.inl" 2365 } 2366 while (0); 2367 /* POP_STACK_TOP ( tos -- ) */ 2368 do 2369 { 2370#define tos _stack0 2371#line 828 "vm.def" 2372 2373#line 2374 "vm.inl" 2374#undef tos 2375 } 2376 while (0); 2377 POP_N_OOPS (1); 2378 } 2379 NEXT_BC; 2380bc49: 2381 { 2382 OOP _stack0; 2383 _stack0 = STACK_AT (0); 2384 /* PREFETCH ( -- ) */ 2385 do 2386 { 2387#line 207 "vm.def" 2388 PREFETCH; 2389 LOCAL_COUNTER++; 2390 2391#line 2392 "vm.inl" 2392 } 2393 while (0); 2394 /* MAKE_DIRTY_BLOCK ( block -- closure ) */ 2395 do 2396 { 2397#define block _stack0 2398#define closure _stack0 2399#line 831 "vm.def" 2400 EXPORT_REGS (); 2401 closure = _gst_make_block_closure (block); 2402 IMPORT_REGS(); 2403 2404#line 2405 "vm.inl" 2405#undef block 2406#undef closure 2407 } 2408 while (0); 2409 STACK_AT (0) = _stack0; 2410 } 2411 NEXT_BC; 2412bc50: 2413 { 2414 OOP _stack0; 2415 _stack0 = STACK_AT (0); 2416 /* PREFETCH ( -- ) */ 2417 do 2418 { 2419#line 207 "vm.def" 2420 PREFETCH; 2421 LOCAL_COUNTER++; 2422 2423#line 2424 "vm.inl" 2424 } 2425 while (0); 2426 /* RETURN_METHOD_STACK_TOP ( val | -- val | ) */ 2427 do 2428 { 2429#define val _stack0 2430#line 837 "vm.def" 2431 EXPORT_REGS (); 2432 if UNCOMMON (!unwind_method ()) 2433 { 2434 SEND_MESSAGE (_gst_bad_return_error_symbol, 0); 2435 IMPORT_REGS (); 2436 } 2437 else 2438 { 2439 IMPORT_REGS (); 2440 SET_STACKTOP (val); 2441 } 2442 FETCH; 2443 2444#line 2445 "vm.inl" 2445#undef val 2446 } 2447 while (0); 2448 } 2449 NEXT_BC; 2450bc51: 2451 { 2452 OOP _stack0; 2453 _stack0 = STACK_AT (0); 2454 /* PREFETCH ( -- ) */ 2455 do 2456 { 2457#line 207 "vm.def" 2458 PREFETCH; 2459 LOCAL_COUNTER++; 2460 2461#line 2462 "vm.inl" 2462 } 2463 while (0); 2464 /* RETURN_CONTEXT_STACK_TOP ( val | -- val | ) */ 2465 do 2466 { 2467#define val _stack0 2468#line 852 "vm.def" 2469 EXPORT_REGS (); 2470 unwind_context (); 2471 IMPORT_REGS (); 2472 SET_STACKTOP (val); 2473 FETCH; 2474 2475#line 2476 "vm.inl" 2476#undef val 2477 } 2478 while (0); 2479 } 2480 NEXT_BC; 2481bc52: 2482 { 2483 OOP _stack0; 2484 OOP _extra1; 2485 _stack0 = STACK_AT (0); 2486 /* PREFETCH ( -- ) */ 2487 do 2488 { 2489#line 207 "vm.def" 2490 PREFETCH; 2491 LOCAL_COUNTER++; 2492 2493#line 2494 "vm.inl" 2494 } 2495 while (0); 2496 /* DUP_STACK_TOP ( tos | -- tos | tos2 ) */ 2497 do 2498 { 2499#define tos _stack0 2500#define tos2 _extra1 2501#line 860 "vm.def" 2502 tos2 = tos; 2503 2504#line 2505 "vm.inl" 2505#undef tos 2506#undef tos2 2507 } 2508 while (0); 2509 PUSH_OOP (_extra1); 2510 } 2511 NEXT_BC; 2512bc53: 2513 { 2514 OOP _stack0; 2515 _stack0 = STACK_AT (0); 2516 /* PREFETCH ( -- ) */ 2517 do 2518 { 2519#line 207 "vm.def" 2520 PREFETCH; 2521 LOCAL_COUNTER++; 2522 2523#line 2524 "vm.inl" 2524 } 2525 while (0); 2526 /* EXIT_INTERPRETER ( val | -- val | ) */ 2527 do 2528 { 2529#define val _stack0 2530#line 864 "vm.def" 2531 /* This fixes a very rare condition, but it can happen: GC can 2532 happen because send_message_internal allocates a context 2533 while the interpreter is checking last_primitive to fill 2534 the special cache for #at:, #at:put: and #size. If there 2535 are finalizable objects, the finalization callins might 2536 change last_primitive to a bogus value. To fix the 2537 problem, we invalidate last_primitive every time the 2538 interpreter exits. */ 2539 last_primitive = 0; 2540 2541 { 2542 OOP activeProcessOOP = get_scheduled_process (); 2543 gst_callin_process process = (gst_callin_process) OOP_TO_OBJ (activeProcessOOP); 2544 if (IS_NIL (activeProcessOOP)) 2545 abort (); 2546 2547 if (process->objClass == _gst_callin_process_class) 2548 process->returnedValue = val; 2549 _gst_terminate_process (activeProcessOOP); 2550 if (processOOP == activeProcessOOP) 2551 SET_EXCEPT_FLAG (true); 2552 } 2553 FETCH; 2554 2555#line 2556 "vm.inl" 2556#undef val 2557 } 2558 while (0); 2559 } 2560 NEXT_BC; 2561bc54: 2562 { 2563 /* PREFETCH ( -- ) */ 2564 do 2565 { 2566#line 207 "vm.def" 2567 PREFETCH; 2568 LOCAL_COUNTER++; 2569 2570#line 2571 "vm.inl" 2571 } 2572 while (0); 2573 /* LINE_NUMBER_BYTECODE ( -- ) */ 2574 do 2575 { 2576#line 890 "vm.def" 2577 2578#line 2579 "vm.inl" 2579 } 2580 while (0); 2581 } 2582 NEXT_BC; 2583bc55: 2584 { 2585 /* EXT_BYTE ( -- ) */ 2586 do 2587 { 2588#line 220 "vm.def" 2589 PREFETCH_VEC (normal_byte_codes); 2590 arg = (arg << 8) | GET_ARG; 2591 NEXT_BC_NO_ARG (normal_byte_codes); 2592 2593#line 2594 "vm.inl" 2594 } 2595 while (0); 2596 } 2597 NEXT_BC; 2598bc56: 2599 { 2600 OOP _extra1; 2601 /* PREFETCH ( -- ) */ 2602 do 2603 { 2604#line 207 "vm.def" 2605 PREFETCH; 2606 LOCAL_COUNTER++; 2607 2608#line 2609 "vm.inl" 2609 } 2610 while (0); 2611 /* PUSH_SELF ( -- tos ) */ 2612 do 2613 { 2614#define tos _extra1 2615#line 893 "vm.def" 2616 tos = _gst_self; 2617 2618#line 2619 "vm.inl" 2619#undef tos 2620 } 2621 while (0); 2622 PUSH_OOP (_extra1); 2623 } 2624 NEXT_BC; 2625bc57: 2626 { 2627 /* PREFETCH ( -- ) */ 2628 do 2629 { 2630#line 207 "vm.def" 2631 PREFETCH; 2632 LOCAL_COUNTER++; 2633 2634#line 2635 "vm.inl" 2635 } 2636 while (0); 2637 /* INVALID ( -- ) */ 2638 do 2639 { 2640 int arg = arg; 2641#line 226 "vm.def" 2642 _gst_errorf ("Invalid bytecode %d(%d) found!", ip[-1], arg); 2643 2644#line 2645 "vm.inl" 2645 } 2646 while (0); 2647 } 2648 NEXT_BC; 2649bc58: 2650 { 2651 /* PREFETCH ( -- ) */ 2652 do 2653 { 2654#line 207 "vm.def" 2655 PREFETCH; 2656 LOCAL_COUNTER++; 2657 2658#line 2659 "vm.inl" 2659 } 2660 while (0); 2661 /* INVALID ( -- ) */ 2662 do 2663 { 2664 int arg = arg; 2665#line 226 "vm.def" 2666 _gst_errorf ("Invalid bytecode %d(%d) found!", ip[-1], arg); 2667 2668#line 2669 "vm.inl" 2669 } 2670 while (0); 2671 } 2672 NEXT_BC; 2673bc59: 2674 { 2675 /* PREFETCH ( -- ) */ 2676 do 2677 { 2678#line 207 "vm.def" 2679 PREFETCH; 2680 LOCAL_COUNTER++; 2681 2682#line 2683 "vm.inl" 2683 } 2684 while (0); 2685 /* INVALID ( -- ) */ 2686 do 2687 { 2688 int arg = arg; 2689#line 226 "vm.def" 2690 _gst_errorf ("Invalid bytecode %d(%d) found!", ip[-1], arg); 2691 2692#line 2693 "vm.inl" 2693 } 2694 while (0); 2695 } 2696 NEXT_BC; 2697bc60: 2698 { 2699 /* PREFETCH ( -- ) */ 2700 do 2701 { 2702#line 207 "vm.def" 2703 PREFETCH; 2704 LOCAL_COUNTER++; 2705 2706#line 2707 "vm.inl" 2707 } 2708 while (0); 2709 /* INVALID ( -- ) */ 2710 do 2711 { 2712 int arg = arg; 2713#line 226 "vm.def" 2714 _gst_errorf ("Invalid bytecode %d(%d) found!", ip[-1], arg); 2715 2716#line 2717 "vm.inl" 2717 } 2718 while (0); 2719 } 2720 NEXT_BC; 2721bc61: 2722 { 2723 /* PREFETCH ( -- ) */ 2724 do 2725 { 2726#line 207 "vm.def" 2727 PREFETCH; 2728 LOCAL_COUNTER++; 2729 2730#line 2731 "vm.inl" 2731 } 2732 while (0); 2733 /* INVALID ( -- ) */ 2734 do 2735 { 2736 int arg = arg; 2737#line 226 "vm.def" 2738 _gst_errorf ("Invalid bytecode %d(%d) found!", ip[-1], arg); 2739 2740#line 2741 "vm.inl" 2741 } 2742 while (0); 2743 } 2744 NEXT_BC; 2745bc62: 2746 { 2747 /* PREFETCH ( -- ) */ 2748 do 2749 { 2750#line 207 "vm.def" 2751 PREFETCH; 2752 LOCAL_COUNTER++; 2753 2754#line 2755 "vm.inl" 2755 } 2756 while (0); 2757 /* INVALID ( -- ) */ 2758 do 2759 { 2760 int arg = arg; 2761#line 226 "vm.def" 2762 _gst_errorf ("Invalid bytecode %d(%d) found!", ip[-1], arg); 2763 2764#line 2765 "vm.inl" 2765 } 2766 while (0); 2767 } 2768 NEXT_BC; 2769bc63: 2770 { 2771 /* PREFETCH ( -- ) */ 2772 do 2773 { 2774#line 207 "vm.def" 2775 PREFETCH; 2776 LOCAL_COUNTER++; 2777 2778#line 2779 "vm.inl" 2779 } 2780 while (0); 2781 /* INVALID ( -- ) */ 2782 do 2783 { 2784 int arg = arg; 2785#line 226 "vm.def" 2786 _gst_errorf ("Invalid bytecode %d(%d) found!", ip[-1], arg); 2787 2788#line 2789 "vm.inl" 2789 } 2790 while (0); 2791 } 2792 NEXT_BC; 2793bc64: 2794 { 2795 /* PREFETCH ( -- ) */ 2796 do 2797 { 2798#line 207 "vm.def" 2799 PREFETCH; 2800 LOCAL_COUNTER++; 2801 2802#line 2803 "vm.inl" 2803 } 2804 while (0); 2805 /* SEND ( -- ) */ 2806 do 2807 { 2808 int sel = arg; 2809 int n = 1; 2810#define PREPARE_STACK() do { \ 2811 } while (0) 2812#line 643 "vm.def" 2813 PREPARE_STACK (); 2814 EXPORT_REGS (); 2815 SEND_MESSAGE (METHOD_LITERAL (sel), n); 2816 IMPORT_REGS (); 2817 FETCH; 2818 2819#line 2820 "vm.inl" 2820#undef PREPARE_STACK 2821 } 2822 while (0); 2823 } 2824 NEXT_BC; 2825bc65: 2826 { 2827 /* PREFETCH ( -- ) */ 2828 do 2829 { 2830#line 207 "vm.def" 2831 PREFETCH; 2832 LOCAL_COUNTER++; 2833 2834#line 2835 "vm.inl" 2835 } 2836 while (0); 2837 /* SEND ( -- ) */ 2838 do 2839 { 2840 int sel = arg; 2841 int n = 0; 2842#define PREPARE_STACK() do { \ 2843 } while (0) 2844#line 643 "vm.def" 2845 PREPARE_STACK (); 2846 EXPORT_REGS (); 2847 SEND_MESSAGE (METHOD_LITERAL (sel), n); 2848 IMPORT_REGS (); 2849 FETCH; 2850 2851#line 2852 "vm.inl" 2852#undef PREPARE_STACK 2853 } 2854 while (0); 2855 } 2856 NEXT_BC; 2857bc66: 2858 { 2859 OOP _extra1; 2860 /* PREFETCH ( -- ) */ 2861 do 2862 { 2863#line 207 "vm.def" 2864 PREFETCH; 2865 LOCAL_COUNTER++; 2866 2867#line 2868 "vm.inl" 2868 } 2869 while (0); 2870 /* PUSH_SELF ( -- tos ) */ 2871 do 2872 { 2873#define tos _extra1 2874#line 893 "vm.def" 2875 tos = _gst_self; 2876 2877#line 2878 "vm.inl" 2878#undef tos 2879 } 2880 while (0); 2881 /* RETURN_CONTEXT_STACK_TOP ( val | -- val | ) */ 2882 do 2883 { 2884#define val _extra1 2885#line 852 "vm.def" 2886 EXPORT_REGS (); 2887 unwind_context (); 2888 IMPORT_REGS (); 2889 SET_STACKTOP (val); 2890 FETCH; 2891 2892#line 2893 "vm.inl" 2893#undef val 2894 } 2895 while (0); 2896 PUSH_OOP (_extra1); 2897 } 2898 NEXT_BC; 2899bc67: 2900 { 2901 OOP _extra1; 2902 /* PREFETCH ( -- ) */ 2903 do 2904 { 2905#line 207 "vm.def" 2906 PREFETCH; 2907 LOCAL_COUNTER++; 2908 2909#line 2910 "vm.inl" 2910 } 2911 while (0); 2912 /* LINE_NUMBER_BYTECODE ( -- ) */ 2913 do 2914 { 2915#line 890 "vm.def" 2916 2917#line 2918 "vm.inl" 2918 } 2919 while (0); 2920 /* PUSH_SELF ( -- tos ) */ 2921 do 2922 { 2923#define tos _extra1 2924#line 893 "vm.def" 2925 tos = _gst_self; 2926 2927#line 2928 "vm.inl" 2928#undef tos 2929 } 2930 while (0); 2931 PUSH_OOP (_extra1); 2932 } 2933 NEXT_BC; 2934bc68: 2935 { 2936 OOP _stack0; 2937 _stack0 = STACK_AT (0); 2938 /* PREFETCH ( -- ) */ 2939 do 2940 { 2941#line 207 "vm.def" 2942 PREFETCH; 2943 LOCAL_COUNTER++; 2944 2945#line 2946 "vm.inl" 2946 } 2947 while (0); 2948 /* LINE_NUMBER_BYTECODE ( -- ) */ 2949 do 2950 { 2951#line 890 "vm.def" 2952 2953#line 2954 "vm.inl" 2954 } 2955 while (0); 2956 /* POP_STACK_TOP ( tos -- ) */ 2957 do 2958 { 2959#define tos _stack0 2960#line 828 "vm.def" 2961 2962#line 2963 "vm.inl" 2963#undef tos 2964 } 2965 while (0); 2966 POP_N_OOPS (1); 2967 } 2968 NEXT_BC; 2969bc69: 2970 { 2971 OOP _extra1; 2972 /* PREFETCH ( -- ) */ 2973 do 2974 { 2975#line 207 "vm.def" 2976 PREFETCH; 2977 LOCAL_COUNTER++; 2978 2979#line 2980 "vm.inl" 2980 } 2981 while (0); 2982 /* LINE_NUMBER_BYTECODE ( -- ) */ 2983 do 2984 { 2985#line 890 "vm.def" 2986 2987#line 2988 "vm.inl" 2988 } 2989 while (0); 2990 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 2991 do 2992 { 2993 int n = 0; 2994#define tos _extra1 2995#line 683 "vm.def" 2996 tos = METHOD_TEMPORARY (n); 2997 2998#line 2999 "vm.inl" 2999#undef tos 3000 } 3001 while (0); 3002 PUSH_OOP (_extra1); 3003 } 3004 NEXT_BC; 3005bc70: 3006 { 3007 OOP _extra1; 3008 /* PREFETCH ( -- ) */ 3009 do 3010 { 3011#line 207 "vm.def" 3012 PREFETCH; 3013 LOCAL_COUNTER++; 3014 3015#line 3016 "vm.inl" 3016 } 3017 while (0); 3018 /* PUSH_LIT_CONSTANT ( -- tos ) */ 3019 do 3020 { 3021 int n = arg; 3022#define tos _extra1 3023#line 820 "vm.def" 3024 tos = METHOD_LITERAL (n); 3025 3026#line 3027 "vm.inl" 3027#undef tos 3028 } 3029 while (0); 3030 /* MAKE_DIRTY_BLOCK ( block -- closure ) */ 3031 do 3032 { 3033#define block _extra1 3034#define closure _extra1 3035#line 831 "vm.def" 3036 EXPORT_REGS (); 3037 closure = _gst_make_block_closure (block); 3038 IMPORT_REGS(); 3039 3040#line 3041 "vm.inl" 3041#undef block 3042#undef closure 3043 } 3044 while (0); 3045 PUSH_OOP (_extra1); 3046 } 3047 NEXT_BC; 3048bc71: 3049 { 3050 /* PREFETCH ( -- ) */ 3051 do 3052 { 3053#line 207 "vm.def" 3054 PREFETCH; 3055 LOCAL_COUNTER++; 3056 3057#line 3058 "vm.inl" 3058 } 3059 while (0); 3060 /* SEND ( -- ) */ 3061 do 3062 { 3063 int sel = arg; 3064 int n = 2; 3065#define PREPARE_STACK() do { \ 3066 } while (0) 3067#line 643 "vm.def" 3068 PREPARE_STACK (); 3069 EXPORT_REGS (); 3070 SEND_MESSAGE (METHOD_LITERAL (sel), n); 3071 IMPORT_REGS (); 3072 FETCH; 3073 3074#line 3075 "vm.inl" 3075#undef PREPARE_STACK 3076 } 3077 while (0); 3078 } 3079 NEXT_BC; 3080bc72: 3081 { 3082 OOP _stack0, _stack1; 3083 _stack1 = STACK_AT (1); 3084 _stack0 = STACK_AT (0); 3085 /* PREFETCH ( -- ) */ 3086 do 3087 { 3088#line 207 "vm.def" 3089 PREFETCH; 3090 LOCAL_COUNTER++; 3091 3092#line 3093 "vm.inl" 3093 } 3094 while (0); 3095 /* POP_STACK_TOP ( tos -- ) */ 3096 do 3097 { 3098#define tos _stack0 3099#line 828 "vm.def" 3100 3101#line 3102 "vm.inl" 3102#undef tos 3103 } 3104 while (0); 3105 /* DUP_STACK_TOP ( tos | -- tos | tos2 ) */ 3106 do 3107 { 3108#define tos _stack1 3109#define tos2 _stack0 3110#line 860 "vm.def" 3111 tos2 = tos; 3112 3113#line 3114 "vm.inl" 3114#undef tos 3115#undef tos2 3116 } 3117 while (0); 3118 STACK_AT (0) = _stack0; 3119 } 3120 NEXT_BC; 3121bc73: 3122 { 3123 OOP _extra1; 3124 /* PREFETCH ( -- ) */ 3125 do 3126 { 3127#line 207 "vm.def" 3128 PREFETCH; 3129 LOCAL_COUNTER++; 3130 3131#line 3132 "vm.inl" 3132 } 3133 while (0); 3134 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 3135 do 3136 { 3137 int n = 0; 3138#define tos _extra1 3139#line 683 "vm.def" 3140 tos = METHOD_TEMPORARY (n); 3141 3142#line 3143 "vm.inl" 3143#undef tos 3144 } 3145 while (0); 3146 /* SEND_IMMEDIATE ( -- ) */ 3147 do 3148 { 3149 int n = arg; 3150#define PREPARE_STACK() do { \ 3151 PUSH_OOP (_extra1); \ 3152 } while (0) 3153#line 662 "vm.def" 3154 const struct builtin_selector *bs = &_gst_builtin_selectors[n]; 3155 PREPARE_STACK (); 3156 EXPORT_REGS (); 3157 SEND_MESSAGE (bs->symbol, bs->numArgs); 3158 IMPORT_REGS (); 3159 FETCH; 3160 3161#line 3162 "vm.inl" 3162#undef PREPARE_STACK 3163 } 3164 while (0); 3165 PUSH_OOP (_extra1); 3166 } 3167 NEXT_BC; 3168bc74: 3169 { 3170 OOP _extra1; 3171 /* PREFETCH ( -- ) */ 3172 do 3173 { 3174#line 207 "vm.def" 3175 PREFETCH; 3176 LOCAL_COUNTER++; 3177 3178#line 3179 "vm.inl" 3179 } 3180 while (0); 3181 /* PUSH_SELF ( -- tos ) */ 3182 do 3183 { 3184#define tos _extra1 3185#line 893 "vm.def" 3186 tos = _gst_self; 3187 3188#line 3189 "vm.inl" 3189#undef tos 3190 } 3191 while (0); 3192 /* SEND ( -- ) */ 3193 do 3194 { 3195 int sel = arg; 3196 int n = 0; 3197#define PREPARE_STACK() do { \ 3198 PUSH_OOP (_extra1); \ 3199 } while (0) 3200#line 643 "vm.def" 3201 PREPARE_STACK (); 3202 EXPORT_REGS (); 3203 SEND_MESSAGE (METHOD_LITERAL (sel), n); 3204 IMPORT_REGS (); 3205 FETCH; 3206 3207#line 3208 "vm.inl" 3208#undef PREPARE_STACK 3209 } 3210 while (0); 3211 PUSH_OOP (_extra1); 3212 } 3213 NEXT_BC; 3214bc75: 3215 { 3216 OOP _extra1; 3217 /* PREFETCH ( -- ) */ 3218 do 3219 { 3220#line 207 "vm.def" 3221 PREFETCH; 3222 LOCAL_COUNTER++; 3223 3224#line 3225 "vm.inl" 3225 } 3226 while (0); 3227 /* PUSH_SPECIAL ( -- tos ) */ 3228 do 3229 { 3230 int n = arg; 3231#define tos _extra1 3232#line 816 "vm.def" 3233 tos = _gst_nil_oop + (n - NIL_INDEX); 3234 3235#line 3236 "vm.inl" 3236#undef tos 3237 } 3238 while (0); 3239 /* RETURN_CONTEXT_STACK_TOP ( val | -- val | ) */ 3240 do 3241 { 3242#define val _extra1 3243#line 852 "vm.def" 3244 EXPORT_REGS (); 3245 unwind_context (); 3246 IMPORT_REGS (); 3247 SET_STACKTOP (val); 3248 FETCH; 3249 3250#line 3251 "vm.inl" 3251#undef val 3252 } 3253 while (0); 3254 PUSH_OOP (_extra1); 3255 } 3256 NEXT_BC; 3257bc76: 3258 { 3259 OOP _extra1; 3260 /* PREFETCH ( -- ) */ 3261 do 3262 { 3263#line 207 "vm.def" 3264 PREFETCH; 3265 LOCAL_COUNTER++; 3266 3267#line 3268 "vm.inl" 3268 } 3269 while (0); 3270 /* PUSH_SELF ( -- tos ) */ 3271 do 3272 { 3273#define tos _extra1 3274#line 893 "vm.def" 3275 tos = _gst_self; 3276 3277#line 3278 "vm.inl" 3278#undef tos 3279 } 3280 while (0); 3281 /* SEND_IMMEDIATE ( -- ) */ 3282 do 3283 { 3284 int n = arg; 3285#define PREPARE_STACK() do { \ 3286 PUSH_OOP (_extra1); \ 3287 } while (0) 3288#line 662 "vm.def" 3289 const struct builtin_selector *bs = &_gst_builtin_selectors[n]; 3290 PREPARE_STACK (); 3291 EXPORT_REGS (); 3292 SEND_MESSAGE (bs->symbol, bs->numArgs); 3293 IMPORT_REGS (); 3294 FETCH; 3295 3296#line 3297 "vm.inl" 3297#undef PREPARE_STACK 3298 } 3299 while (0); 3300 PUSH_OOP (_extra1); 3301 } 3302 NEXT_BC; 3303bc77: 3304 { 3305 OOP _extra1; 3306 /* PREFETCH ( -- ) */ 3307 do 3308 { 3309#line 207 "vm.def" 3310 PREFETCH; 3311 LOCAL_COUNTER++; 3312 3313#line 3314 "vm.inl" 3314 } 3315 while (0); 3316 /* PUSH_OUTER_TEMP ( -- tos ) */ 3317 do 3318 { 3319 int n = arg; 3320 int scopes = 1; 3321#define tos _extra1 3322#line 687 "vm.def" 3323 OOP contextOOP; 3324 gst_block_context context; 3325 3326 context = (gst_block_context) OOP_TO_OBJ (_gst_this_context_oop); 3327 do 3328 { 3329 contextOOP = context->outerContext; 3330 context = (gst_block_context) OOP_TO_OBJ (contextOOP); 3331 } 3332 while (--scopes); 3333 3334 tos = context->contextStack[n]; 3335 3336#line 3337 "vm.inl" 3337#undef tos 3338 } 3339 while (0); 3340 PUSH_OOP (_extra1); 3341 } 3342 NEXT_BC; 3343bc78: 3344 { 3345 OOP _stack0; 3346 _stack0 = STACK_AT (0); 3347 /* PREFETCH ( -- ) */ 3348 do 3349 { 3350#line 207 "vm.def" 3351 PREFETCH; 3352 LOCAL_COUNTER++; 3353 3354#line 3355 "vm.inl" 3355 } 3356 while (0); 3357 /* STORE_TEMPORARY_VARIABLE ( tos | -- tos | ) */ 3358 do 3359 { 3360 int n = arg; 3361#define tos _stack0 3362#line 722 "vm.def" 3363 STORE_METHOD_TEMPORARY (n, tos); 3364 3365#line 3366 "vm.inl" 3366#undef tos 3367 } 3368 while (0); 3369 /* POP_STACK_TOP ( tos -- ) */ 3370 do 3371 { 3372#define tos _stack0 3373#line 828 "vm.def" 3374 3375#line 3376 "vm.inl" 3376#undef tos 3377 } 3378 while (0); 3379 POP_N_OOPS (1); 3380 } 3381 NEXT_BC; 3382bc79: 3383 { 3384 OOP _extra1, _extra2; 3385 /* PREFETCH ( -- ) */ 3386 do 3387 { 3388#line 207 "vm.def" 3389 PREFETCH; 3390 LOCAL_COUNTER++; 3391 3392#line 3393 "vm.inl" 3393 } 3394 while (0); 3395 /* PUSH_SELF ( -- tos ) */ 3396 do 3397 { 3398#define tos _extra1 3399#line 893 "vm.def" 3400 tos = _gst_self; 3401 3402#line 3403 "vm.inl" 3403#undef tos 3404 } 3405 while (0); 3406 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 3407 do 3408 { 3409 int n = arg; 3410#define tos _extra2 3411#line 683 "vm.def" 3412 tos = METHOD_TEMPORARY (n); 3413 3414#line 3415 "vm.inl" 3415#undef tos 3416 } 3417 while (0); 3418 PUSH_OOP (_extra1); 3419 PUSH_OOP (_extra2); 3420 } 3421 NEXT_BC; 3422bc80: 3423 { 3424 OOP _stack0; 3425 OOP _extra1; 3426 _stack0 = STACK_AT (0); 3427 /* PREFETCH ( -- ) */ 3428 do 3429 { 3430#line 207 "vm.def" 3431 PREFETCH; 3432 LOCAL_COUNTER++; 3433 3434#line 3435 "vm.inl" 3435 } 3436 while (0); 3437 /* STORE_RECEIVER_VARIABLE ( tos | -- tos | ) */ 3438 do 3439 { 3440 int n = arg; 3441#define tos _stack0 3442#line 758 "vm.def" 3443 STORE_RECEIVER_VARIABLE (n, tos); 3444 3445#line 3446 "vm.inl" 3446#undef tos 3447 } 3448 while (0); 3449 /* PUSH_SELF ( -- tos ) */ 3450 do 3451 { 3452#define tos _extra1 3453#line 893 "vm.def" 3454 tos = _gst_self; 3455 3456#line 3457 "vm.inl" 3457#undef tos 3458 } 3459 while (0); 3460 /* RETURN_CONTEXT_STACK_TOP ( val | -- val | ) */ 3461 do 3462 { 3463#define val _extra1 3464#line 852 "vm.def" 3465 EXPORT_REGS (); 3466 unwind_context (); 3467 IMPORT_REGS (); 3468 SET_STACKTOP (val); 3469 FETCH; 3470 3471#line 3472 "vm.inl" 3472#undef val 3473 } 3474 while (0); 3475 PUSH_OOP (_extra1); 3476 } 3477 NEXT_BC; 3478bc81: 3479 { 3480 OOP _stack0; 3481 OOP _extra1; 3482 _stack0 = STACK_AT (0); 3483 /* PREFETCH ( -- ) */ 3484 do 3485 { 3486#line 207 "vm.def" 3487 PREFETCH; 3488 LOCAL_COUNTER++; 3489 3490#line 3491 "vm.inl" 3491 } 3492 while (0); 3493 /* PUSH_INTEGER ( -- tos ) */ 3494 do 3495 { 3496 int n = arg; 3497#define tos _extra1 3498#line 812 "vm.def" 3499 tos = FROM_INT (n); 3500 3501#line 3502 "vm.inl" 3502#undef tos 3503 } 3504 while (0); 3505 /* PLUS_SPECIAL ( op1 op2 -- op ) */ 3506 do 3507 { 3508#define PREPARE_STACK() do { \ 3509 PUSH_OOP (_extra1); \ 3510 } while (0) 3511#define op1 _stack0 3512#define op2 _extra1 3513#define op _stack0 3514#line 230 "vm.def" 3515 INTERP_BASIC_OP (op, op1, op2, 3516 add_with_check (op1, op2, &overflow), 3517 farg1 + farg2); 3518 PREPARE_STACK (); 3519 EXPORT_REGS (); 3520 SEND_MESSAGE (_gst_builtin_selectors[PLUS_SPECIAL].symbol, 1); 3521 IMPORT_REGS (); 3522 FETCH; 3523 3524#line 3525 "vm.inl" 3525#undef PREPARE_STACK 3526#undef op1 3527#undef op2 3528#undef op 3529 } 3530 while (0); 3531 STACK_AT (0) = _stack0; 3532 } 3533 NEXT_BC; 3534bc82: 3535 { 3536 OOP _extra1; 3537 /* PREFETCH ( -- ) */ 3538 do 3539 { 3540#line 207 "vm.def" 3541 PREFETCH; 3542 LOCAL_COUNTER++; 3543 3544#line 3545 "vm.inl" 3545 } 3546 while (0); 3547 /* LINE_NUMBER_BYTECODE ( -- ) */ 3548 do 3549 { 3550#line 890 "vm.def" 3551 3552#line 3553 "vm.inl" 3553 } 3554 while (0); 3555 /* PUSH_LIT_VARIABLE ( -- tos ) */ 3556 do 3557 { 3558 int n = 0; 3559#define PREPARE_STACK() do { \ 3560 } while (0) 3561#define tos _extra1 3562#line 702 "vm.def" 3563 tos = METHOD_LITERAL (n); 3564 if (UNCOMMON (IS_INT (tos)) 3565 || UNCOMMON (!is_a_kind_of (OOP_CLASS (tos), _gst_association_class))) 3566 { 3567 PREPARE_STACK (); 3568 PUSH_OOP (tos); 3569 EXPORT_REGS (); 3570 SEND_MESSAGE (_gst_builtin_selectors[VALUE_SPECIAL].symbol, 0); 3571 IMPORT_REGS (); 3572 FETCH; 3573 } 3574 else 3575 tos = ASSOCIATION_VALUE (tos); 3576 3577#line 3578 "vm.inl" 3578#undef PREPARE_STACK 3579#undef tos 3580 } 3581 while (0); 3582 PUSH_OOP (_extra1); 3583 } 3584 NEXT_BC; 3585bc83: 3586 { 3587 OOP _extra1, _extra2; 3588 /* PREFETCH ( -- ) */ 3589 do 3590 { 3591#line 207 "vm.def" 3592 PREFETCH; 3593 LOCAL_COUNTER++; 3594 3595#line 3596 "vm.inl" 3596 } 3597 while (0); 3598 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 3599 do 3600 { 3601 int n = 0; 3602#define tos _extra1 3603#line 683 "vm.def" 3604 tos = METHOD_TEMPORARY (n); 3605 3606#line 3607 "vm.inl" 3607#undef tos 3608 } 3609 while (0); 3610 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 3611 do 3612 { 3613 int n = arg; 3614#define tos _extra2 3615#line 683 "vm.def" 3616 tos = METHOD_TEMPORARY (n); 3617 3618#line 3619 "vm.inl" 3619#undef tos 3620 } 3621 while (0); 3622 PUSH_OOP (_extra1); 3623 PUSH_OOP (_extra2); 3624 } 3625 NEXT_BC; 3626bc84: 3627 { 3628 OOP _extra1; 3629 /* PREFETCH ( -- ) */ 3630 do 3631 { 3632#line 207 "vm.def" 3633 PREFETCH; 3634 LOCAL_COUNTER++; 3635 3636#line 3637 "vm.inl" 3637 } 3638 while (0); 3639 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 3640 do 3641 { 3642 int n = 0; 3643#define tos _extra1 3644#line 683 "vm.def" 3645 tos = METHOD_TEMPORARY (n); 3646 3647#line 3648 "vm.inl" 3648#undef tos 3649 } 3650 while (0); 3651 /* SEND ( -- ) */ 3652 do 3653 { 3654 int sel = arg >> 8; 3655 int n = arg & 255; 3656#define PREPARE_STACK() do { \ 3657 PUSH_OOP (_extra1); \ 3658 } while (0) 3659#line 643 "vm.def" 3660 PREPARE_STACK (); 3661 EXPORT_REGS (); 3662 SEND_MESSAGE (METHOD_LITERAL (sel), n); 3663 IMPORT_REGS (); 3664 FETCH; 3665 3666#line 3667 "vm.inl" 3667#undef PREPARE_STACK 3668 } 3669 while (0); 3670 PUSH_OOP (_extra1); 3671 } 3672 NEXT_BC; 3673bc85: 3674 { 3675 OOP _extra1; 3676 /* PREFETCH ( -- ) */ 3677 do 3678 { 3679#line 207 "vm.def" 3680 PREFETCH; 3681 LOCAL_COUNTER++; 3682 3683#line 3684 "vm.inl" 3684 } 3685 while (0); 3686 /* LINE_NUMBER_BYTECODE ( -- ) */ 3687 do 3688 { 3689#line 890 "vm.def" 3690 3691#line 3692 "vm.inl" 3692 } 3693 while (0); 3694 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 3695 do 3696 { 3697 int n = 1; 3698#define tos _extra1 3699#line 683 "vm.def" 3700 tos = METHOD_TEMPORARY (n); 3701 3702#line 3703 "vm.inl" 3703#undef tos 3704 } 3705 while (0); 3706 PUSH_OOP (_extra1); 3707 } 3708 NEXT_BC; 3709bc86: 3710 { 3711 OOP _stack0; 3712 _stack0 = STACK_AT (0); 3713 /* PREFETCH ( -- ) */ 3714 do 3715 { 3716#line 207 "vm.def" 3717 PREFETCH; 3718 LOCAL_COUNTER++; 3719 3720#line 3721 "vm.inl" 3721 } 3722 while (0); 3723 /* IS_NIL_SPECIAL ( rec -- val ) */ 3724 do 3725 { 3726#define rec _stack0 3727#define val _stack0 3728#line 576 "vm.def" 3729 /* DO_JUMP_LOOKAHEAD (rec == _gst_nil_oop); */ 3730 val = rec == _gst_nil_oop ? _gst_true_oop : _gst_false_oop; 3731 3732#line 3733 "vm.inl" 3733#undef rec 3734#undef val 3735 } 3736 while (0); 3737 /* POP_JUMP_FALSE ( tos -- ) */ 3738 do 3739 { 3740 int n = arg; 3741#define PREPARE_STACK() do { \ 3742 STACK_AT (0) = _stack0; \ 3743 } while (0) 3744#define tos _stack0 3745#line 774 "vm.def" 3746 if UNCOMMON (tos == _gst_false_oop) 3747 { 3748 PREPARE_STACK (); 3749 POP_N_OOPS(1); 3750 ip += n; 3751 FETCH; 3752 } 3753 else if UNCOMMON (tos != _gst_true_oop) 3754 { 3755 ip += n; 3756 PREPARE_STACK (); 3757 EXPORT_REGS(); 3758 SEND_MESSAGE(_gst_must_be_boolean_symbol, 0); 3759 IMPORT_REGS(); 3760 FETCH; 3761 } 3762 3763#line 3764 "vm.inl" 3764#undef PREPARE_STACK 3765#undef tos 3766 } 3767 while (0); 3768 POP_N_OOPS (1); 3769 } 3770 NEXT_BC; 3771bc87: 3772 { 3773 OOP _stack0; 3774 OOP _extra1; 3775 _stack0 = STACK_AT (0); 3776 /* PREFETCH ( -- ) */ 3777 do 3778 { 3779#line 207 "vm.def" 3780 PREFETCH; 3781 LOCAL_COUNTER++; 3782 3783#line 3784 "vm.inl" 3784 } 3785 while (0); 3786 /* PUSH_INTEGER ( -- tos ) */ 3787 do 3788 { 3789 int n = arg; 3790#define tos _extra1 3791#line 812 "vm.def" 3792 tos = FROM_INT (n); 3793 3794#line 3795 "vm.inl" 3795#undef tos 3796 } 3797 while (0); 3798 /* EQUAL_SPECIAL ( op1 op2 -- op ) */ 3799 do 3800 { 3801#define PREPARE_STACK() do { \ 3802 PUSH_OOP (_extra1); \ 3803 } while (0) 3804#define op1 _stack0 3805#define op2 _extra1 3806#define op _stack0 3807#line 288 "vm.def" 3808 PREPARE_STACK (); 3809 INTERP_BASIC_BOOL (op, op1, op2, ==); 3810 EXPORT_REGS (); 3811 SEND_MESSAGE (_gst_builtin_selectors[EQUAL_SPECIAL].symbol, 1); 3812 IMPORT_REGS (); 3813 FETCH; 3814 3815#line 3816 "vm.inl" 3816#undef PREPARE_STACK 3817#undef op1 3818#undef op2 3819#undef op 3820 } 3821 while (0); 3822 STACK_AT (0) = _stack0; 3823 } 3824 NEXT_BC; 3825bc88: 3826 { 3827 /* PREFETCH ( -- ) */ 3828 do 3829 { 3830#line 207 "vm.def" 3831 PREFETCH; 3832 LOCAL_COUNTER++; 3833 3834#line 3835 "vm.inl" 3835 } 3836 while (0); 3837 /* SEND ( -- ) */ 3838 do 3839 { 3840 int sel = arg; 3841 int n = 3; 3842#define PREPARE_STACK() do { \ 3843 } while (0) 3844#line 643 "vm.def" 3845 PREPARE_STACK (); 3846 EXPORT_REGS (); 3847 SEND_MESSAGE (METHOD_LITERAL (sel), n); 3848 IMPORT_REGS (); 3849 FETCH; 3850 3851#line 3852 "vm.inl" 3852#undef PREPARE_STACK 3853 } 3854 while (0); 3855 } 3856 NEXT_BC; 3857bc89: 3858 { 3859 OOP _extra1; 3860 /* PREFETCH ( -- ) */ 3861 do 3862 { 3863#line 207 "vm.def" 3864 PREFETCH; 3865 LOCAL_COUNTER++; 3866 3867#line 3868 "vm.inl" 3868 } 3869 while (0); 3870 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 3871 do 3872 { 3873 int n = 0; 3874#define tos _extra1 3875#line 683 "vm.def" 3876 tos = METHOD_TEMPORARY (n); 3877 3878#line 3879 "vm.inl" 3879#undef tos 3880 } 3881 while (0); 3882 /* SEND ( -- ) */ 3883 do 3884 { 3885 int sel = arg; 3886 int n = 1; 3887#define PREPARE_STACK() do { \ 3888 PUSH_OOP (_extra1); \ 3889 } while (0) 3890#line 643 "vm.def" 3891 PREPARE_STACK (); 3892 EXPORT_REGS (); 3893 SEND_MESSAGE (METHOD_LITERAL (sel), n); 3894 IMPORT_REGS (); 3895 FETCH; 3896 3897#line 3898 "vm.inl" 3898#undef PREPARE_STACK 3899 } 3900 while (0); 3901 PUSH_OOP (_extra1); 3902 } 3903 NEXT_BC; 3904bc90: 3905 { 3906 OOP _extra1; 3907 /* PREFETCH ( -- ) */ 3908 do 3909 { 3910#line 207 "vm.def" 3911 PREFETCH; 3912 LOCAL_COUNTER++; 3913 3914#line 3915 "vm.inl" 3915 } 3916 while (0); 3917 /* LINE_NUMBER_BYTECODE ( -- ) */ 3918 do 3919 { 3920#line 890 "vm.def" 3921 3922#line 3923 "vm.inl" 3923 } 3924 while (0); 3925 /* PUSH_SELF ( -- tos ) */ 3926 do 3927 { 3928#define tos _extra1 3929#line 893 "vm.def" 3930 tos = _gst_self; 3931 3932#line 3933 "vm.inl" 3933#undef tos 3934 } 3935 while (0); 3936 /* SEND ( -- ) */ 3937 do 3938 { 3939 int sel = 0; 3940 int n = 0; 3941#define PREPARE_STACK() do { \ 3942 PUSH_OOP (_extra1); \ 3943 } while (0) 3944#line 643 "vm.def" 3945 PREPARE_STACK (); 3946 EXPORT_REGS (); 3947 SEND_MESSAGE (METHOD_LITERAL (sel), n); 3948 IMPORT_REGS (); 3949 FETCH; 3950 3951#line 3952 "vm.inl" 3952#undef PREPARE_STACK 3953 } 3954 while (0); 3955 PUSH_OOP (_extra1); 3956 } 3957 NEXT_BC; 3958bc91: 3959 { 3960 OOP _extra1; 3961 /* PREFETCH ( -- ) */ 3962 do 3963 { 3964#line 207 "vm.def" 3965 PREFETCH; 3966 LOCAL_COUNTER++; 3967 3968#line 3969 "vm.inl" 3969 } 3970 while (0); 3971 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 3972 do 3973 { 3974 int n = arg; 3975#define tos _extra1 3976#line 683 "vm.def" 3977 tos = METHOD_TEMPORARY (n); 3978 3979#line 3980 "vm.inl" 3980#undef tos 3981 } 3982 while (0); 3983 /* RETURN_CONTEXT_STACK_TOP ( val | -- val | ) */ 3984 do 3985 { 3986#define val _extra1 3987#line 852 "vm.def" 3988 EXPORT_REGS (); 3989 unwind_context (); 3990 IMPORT_REGS (); 3991 SET_STACKTOP (val); 3992 FETCH; 3993 3994#line 3995 "vm.inl" 3995#undef val 3996 } 3997 while (0); 3998 PUSH_OOP (_extra1); 3999 } 4000 NEXT_BC; 4001bc92: 4002 { 4003 OOP _extra1; 4004 /* PREFETCH ( -- ) */ 4005 do 4006 { 4007#line 207 "vm.def" 4008 PREFETCH; 4009 LOCAL_COUNTER++; 4010 4011#line 4012 "vm.inl" 4012 } 4013 while (0); 4014 /* PUSH_LIT_CONSTANT ( -- tos ) */ 4015 do 4016 { 4017 int n = arg; 4018#define tos _extra1 4019#line 820 "vm.def" 4020 tos = METHOD_LITERAL (n); 4021 4022#line 4023 "vm.inl" 4023#undef tos 4024 } 4025 while (0); 4026 /* SEND_IMMEDIATE ( -- ) */ 4027 do 4028 { 4029 int n = 36; 4030#define PREPARE_STACK() do { \ 4031 PUSH_OOP (_extra1); \ 4032 } while (0) 4033#line 662 "vm.def" 4034 const struct builtin_selector *bs = &_gst_builtin_selectors[n]; 4035 PREPARE_STACK (); 4036 EXPORT_REGS (); 4037 SEND_MESSAGE (bs->symbol, bs->numArgs); 4038 IMPORT_REGS (); 4039 FETCH; 4040 4041#line 4042 "vm.inl" 4042#undef PREPARE_STACK 4043 } 4044 while (0); 4045 PUSH_OOP (_extra1); 4046 } 4047 NEXT_BC; 4048bc93: 4049 { 4050 OOP _stack0, _stack1; 4051 _stack1 = STACK_AT (1); 4052 _stack0 = STACK_AT (0); 4053 /* PREFETCH ( -- ) */ 4054 do 4055 { 4056#line 207 "vm.def" 4057 PREFETCH; 4058 LOCAL_COUNTER++; 4059 4060#line 4061 "vm.inl" 4061 } 4062 while (0); 4063 /* SAME_OBJECT_SPECIAL ( op1 op2 -- op ) */ 4064 do 4065 { 4066#define op1 _stack1 4067#define op2 _stack0 4068#define op _stack1 4069#line 610 "vm.def" 4070 /* DO_JUMP_LOOKAHEAD (op1 == op2); */ 4071 op = (op1 == op2) ? _gst_true_oop : _gst_false_oop; 4072 4073#line 4074 "vm.inl" 4074#undef op1 4075#undef op2 4076#undef op 4077 } 4078 while (0); 4079 /* POP_JUMP_FALSE ( tos -- ) */ 4080 do 4081 { 4082 int n = arg; 4083#define PREPARE_STACK() do { \ 4084 STACK_AT (1) = _stack1; \ 4085 POP_N_OOPS (1); \ 4086 } while (0) 4087#define tos _stack1 4088#line 774 "vm.def" 4089 if UNCOMMON (tos == _gst_false_oop) 4090 { 4091 PREPARE_STACK (); 4092 POP_N_OOPS(1); 4093 ip += n; 4094 FETCH; 4095 } 4096 else if UNCOMMON (tos != _gst_true_oop) 4097 { 4098 ip += n; 4099 PREPARE_STACK (); 4100 EXPORT_REGS(); 4101 SEND_MESSAGE(_gst_must_be_boolean_symbol, 0); 4102 IMPORT_REGS(); 4103 FETCH; 4104 } 4105 4106#line 4107 "vm.inl" 4107#undef PREPARE_STACK 4108#undef tos 4109 } 4110 while (0); 4111 POP_N_OOPS (2); 4112 } 4113 NEXT_BC; 4114bc94: 4115 { 4116 OOP _extra1; 4117 /* PREFETCH ( -- ) */ 4118 do 4119 { 4120#line 207 "vm.def" 4121 PREFETCH; 4122 LOCAL_COUNTER++; 4123 4124#line 4125 "vm.inl" 4125 } 4126 while (0); 4127 /* PUSH_LIT_CONSTANT ( -- tos ) */ 4128 do 4129 { 4130 int n = arg; 4131#define tos _extra1 4132#line 820 "vm.def" 4133 tos = METHOD_LITERAL (n); 4134 4135#line 4136 "vm.inl" 4136#undef tos 4137 } 4138 while (0); 4139 /* SEND ( -- ) */ 4140 do 4141 { 4142 int sel = 1; 4143 int n = 1; 4144#define PREPARE_STACK() do { \ 4145 PUSH_OOP (_extra1); \ 4146 } while (0) 4147#line 643 "vm.def" 4148 PREPARE_STACK (); 4149 EXPORT_REGS (); 4150 SEND_MESSAGE (METHOD_LITERAL (sel), n); 4151 IMPORT_REGS (); 4152 FETCH; 4153 4154#line 4155 "vm.inl" 4155#undef PREPARE_STACK 4156 } 4157 while (0); 4158 PUSH_OOP (_extra1); 4159 } 4160 NEXT_BC; 4161bc95: 4162 { 4163 OOP _stack0; 4164 _stack0 = STACK_AT (0); 4165 /* PREFETCH ( -- ) */ 4166 do 4167 { 4168#line 207 "vm.def" 4169 PREFETCH; 4170 LOCAL_COUNTER++; 4171 4172#line 4173 "vm.inl" 4173 } 4174 while (0); 4175 /* LINE_NUMBER_BYTECODE ( -- ) */ 4176 do 4177 { 4178#line 890 "vm.def" 4179 4180#line 4181 "vm.inl" 4181 } 4182 while (0); 4183 /* POP_STACK_TOP ( tos -- ) */ 4184 do 4185 { 4186#define tos _stack0 4187#line 828 "vm.def" 4188 4189#line 4190 "vm.inl" 4190#undef tos 4191 } 4192 while (0); 4193 /* PUSH_SELF ( -- tos ) */ 4194 do 4195 { 4196#define tos _stack0 4197#line 893 "vm.def" 4198 tos = _gst_self; 4199 4200#line 4201 "vm.inl" 4201#undef tos 4202 } 4203 while (0); 4204 STACK_AT (0) = _stack0; 4205 } 4206 NEXT_BC; 4207bc96: 4208 { 4209 OOP _stack0, _stack1; 4210 _stack1 = STACK_AT (1); 4211 _stack0 = STACK_AT (0); 4212 /* PREFETCH ( -- ) */ 4213 do 4214 { 4215#line 207 "vm.def" 4216 PREFETCH; 4217 LOCAL_COUNTER++; 4218 4219#line 4220 "vm.inl" 4220 } 4221 while (0); 4222 /* POP_STACK_TOP ( tos -- ) */ 4223 do 4224 { 4225#define tos _stack0 4226#line 828 "vm.def" 4227 4228#line 4229 "vm.inl" 4229#undef tos 4230 } 4231 while (0); 4232 /* DUP_STACK_TOP ( tos | -- tos | tos2 ) */ 4233 do 4234 { 4235#define tos _stack1 4236#define tos2 _stack0 4237#line 860 "vm.def" 4238 tos2 = tos; 4239 4240#line 4241 "vm.inl" 4241#undef tos 4242#undef tos2 4243 } 4244 while (0); 4245 /* LINE_NUMBER_BYTECODE ( -- ) */ 4246 do 4247 { 4248#line 890 "vm.def" 4249 4250#line 4251 "vm.inl" 4251 } 4252 while (0); 4253 STACK_AT (0) = _stack0; 4254 } 4255 NEXT_BC; 4256bc97: 4257 { 4258 OOP _extra1; 4259 /* PREFETCH ( -- ) */ 4260 do 4261 { 4262#line 207 "vm.def" 4263 PREFETCH; 4264 LOCAL_COUNTER++; 4265 4266#line 4267 "vm.inl" 4267 } 4268 while (0); 4269 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 4270 do 4271 { 4272 int n = 0; 4273#define tos _extra1 4274#line 683 "vm.def" 4275 tos = METHOD_TEMPORARY (n); 4276 4277#line 4278 "vm.inl" 4278#undef tos 4279 } 4280 while (0); 4281 /* SEND ( -- ) */ 4282 do 4283 { 4284 int sel = arg; 4285 int n = 0; 4286#define PREPARE_STACK() do { \ 4287 PUSH_OOP (_extra1); \ 4288 } while (0) 4289#line 643 "vm.def" 4290 PREPARE_STACK (); 4291 EXPORT_REGS (); 4292 SEND_MESSAGE (METHOD_LITERAL (sel), n); 4293 IMPORT_REGS (); 4294 FETCH; 4295 4296#line 4297 "vm.inl" 4297#undef PREPARE_STACK 4298 } 4299 while (0); 4300 PUSH_OOP (_extra1); 4301 } 4302 NEXT_BC; 4303bc98: 4304 { 4305 OOP _extra1; 4306 /* PREFETCH ( -- ) */ 4307 do 4308 { 4309#line 207 "vm.def" 4310 PREFETCH; 4311 LOCAL_COUNTER++; 4312 4313#line 4314 "vm.inl" 4314 } 4315 while (0); 4316 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 4317 do 4318 { 4319 int n = 1; 4320#define tos _extra1 4321#line 683 "vm.def" 4322 tos = METHOD_TEMPORARY (n); 4323 4324#line 4325 "vm.inl" 4325#undef tos 4326 } 4327 while (0); 4328 /* SEND_IMMEDIATE ( -- ) */ 4329 do 4330 { 4331 int n = arg; 4332#define PREPARE_STACK() do { \ 4333 PUSH_OOP (_extra1); \ 4334 } while (0) 4335#line 662 "vm.def" 4336 const struct builtin_selector *bs = &_gst_builtin_selectors[n]; 4337 PREPARE_STACK (); 4338 EXPORT_REGS (); 4339 SEND_MESSAGE (bs->symbol, bs->numArgs); 4340 IMPORT_REGS (); 4341 FETCH; 4342 4343#line 4344 "vm.inl" 4344#undef PREPARE_STACK 4345 } 4346 while (0); 4347 PUSH_OOP (_extra1); 4348 } 4349 NEXT_BC; 4350bc99: 4351 { 4352 OOP _stack0; 4353 OOP _extra1; 4354 _stack0 = STACK_AT (0); 4355 /* PREFETCH ( -- ) */ 4356 do 4357 { 4358#line 207 "vm.def" 4359 PREFETCH; 4360 LOCAL_COUNTER++; 4361 4362#line 4363 "vm.inl" 4363 } 4364 while (0); 4365 /* PUSH_LIT_CONSTANT ( -- tos ) */ 4366 do 4367 { 4368 int n = arg; 4369#define tos _extra1 4370#line 820 "vm.def" 4371 tos = METHOD_LITERAL (n); 4372 4373#line 4374 "vm.inl" 4374#undef tos 4375 } 4376 while (0); 4377 /* EQUAL_SPECIAL ( op1 op2 -- op ) */ 4378 do 4379 { 4380#define PREPARE_STACK() do { \ 4381 PUSH_OOP (_extra1); \ 4382 } while (0) 4383#define op1 _stack0 4384#define op2 _extra1 4385#define op _stack0 4386#line 288 "vm.def" 4387 PREPARE_STACK (); 4388 INTERP_BASIC_BOOL (op, op1, op2, ==); 4389 EXPORT_REGS (); 4390 SEND_MESSAGE (_gst_builtin_selectors[EQUAL_SPECIAL].symbol, 1); 4391 IMPORT_REGS (); 4392 FETCH; 4393 4394#line 4395 "vm.inl" 4395#undef PREPARE_STACK 4396#undef op1 4397#undef op2 4398#undef op 4399 } 4400 while (0); 4401 STACK_AT (0) = _stack0; 4402 } 4403 NEXT_BC; 4404bc100: 4405 { 4406 OOP _stack0; 4407 OOP _extra1; 4408 _stack0 = STACK_AT (0); 4409 /* PREFETCH ( -- ) */ 4410 do 4411 { 4412#line 207 "vm.def" 4413 PREFETCH; 4414 LOCAL_COUNTER++; 4415 4416#line 4417 "vm.inl" 4417 } 4418 while (0); 4419 /* PUSH_INTEGER ( -- tos ) */ 4420 do 4421 { 4422 int n = arg; 4423#define tos _extra1 4424#line 812 "vm.def" 4425 tos = FROM_INT (n); 4426 4427#line 4428 "vm.inl" 4428#undef tos 4429 } 4430 while (0); 4431 /* MINUS_SPECIAL ( op1 op2 -- op ) */ 4432 do 4433 { 4434#define PREPARE_STACK() do { \ 4435 PUSH_OOP (_extra1); \ 4436 } while (0) 4437#define op1 _stack0 4438#define op2 _extra1 4439#define op _stack0 4440#line 241 "vm.def" 4441 INTERP_BASIC_OP (op, op1, op2, 4442 sub_with_check (op1, op2, &overflow), 4443 farg1 - farg2); 4444 PREPARE_STACK (); 4445 EXPORT_REGS (); 4446 SEND_MESSAGE (_gst_builtin_selectors[MINUS_SPECIAL].symbol, 1); 4447 IMPORT_REGS (); 4448 FETCH; 4449 4450#line 4451 "vm.inl" 4451#undef PREPARE_STACK 4452#undef op1 4453#undef op2 4454#undef op 4455 } 4456 while (0); 4457 STACK_AT (0) = _stack0; 4458 } 4459 NEXT_BC; 4460bc101: 4461 { 4462 OOP _stack0; 4463 OOP _extra1; 4464 _stack0 = STACK_AT (0); 4465 /* PREFETCH ( -- ) */ 4466 do 4467 { 4468#line 207 "vm.def" 4469 PREFETCH; 4470 LOCAL_COUNTER++; 4471 4472#line 4473 "vm.inl" 4473 } 4474 while (0); 4475 /* DUP_STACK_TOP ( tos | -- tos | tos2 ) */ 4476 do 4477 { 4478#define tos _stack0 4479#define tos2 _extra1 4480#line 860 "vm.def" 4481 tos2 = tos; 4482 4483#line 4484 "vm.inl" 4484#undef tos 4485#undef tos2 4486 } 4487 while (0); 4488 /* POP_JUMP_FALSE ( tos -- ) */ 4489 do 4490 { 4491 int n = arg; 4492#define PREPARE_STACK() do { \ 4493 PUSH_OOP (_extra1); \ 4494 } while (0) 4495#define tos _extra1 4496#line 774 "vm.def" 4497 if UNCOMMON (tos == _gst_false_oop) 4498 { 4499 PREPARE_STACK (); 4500 POP_N_OOPS(1); 4501 ip += n; 4502 FETCH; 4503 } 4504 else if UNCOMMON (tos != _gst_true_oop) 4505 { 4506 ip += n; 4507 PREPARE_STACK (); 4508 EXPORT_REGS(); 4509 SEND_MESSAGE(_gst_must_be_boolean_symbol, 0); 4510 IMPORT_REGS(); 4511 FETCH; 4512 } 4513 4514#line 4515 "vm.inl" 4515#undef PREPARE_STACK 4516#undef tos 4517 } 4518 while (0); 4519 } 4520 NEXT_BC; 4521bc102: 4522 { 4523 OOP _stack0; 4524 _stack0 = STACK_AT (0); 4525 /* PREFETCH ( -- ) */ 4526 do 4527 { 4528#line 207 "vm.def" 4529 PREFETCH; 4530 LOCAL_COUNTER++; 4531 4532#line 4533 "vm.inl" 4533 } 4534 while (0); 4535 /* POP_STACK_TOP ( tos -- ) */ 4536 do 4537 { 4538#define tos _stack0 4539#line 828 "vm.def" 4540 4541#line 4542 "vm.inl" 4542#undef tos 4543 } 4544 while (0); 4545 /* LINE_NUMBER_BYTECODE ( -- ) */ 4546 do 4547 { 4548#line 890 "vm.def" 4549 4550#line 4551 "vm.inl" 4551 } 4552 while (0); 4553 POP_N_OOPS (1); 4554 } 4555 NEXT_BC; 4556bc103: 4557 { 4558 OOP _extra1; 4559 /* PREFETCH ( -- ) */ 4560 do 4561 { 4562#line 207 "vm.def" 4563 PREFETCH; 4564 LOCAL_COUNTER++; 4565 4566#line 4567 "vm.inl" 4567 } 4568 while (0); 4569 /* PUSH_INTEGER ( -- tos ) */ 4570 do 4571 { 4572 int n = arg; 4573#define tos _extra1 4574#line 812 "vm.def" 4575 tos = FROM_INT (n); 4576 4577#line 4578 "vm.inl" 4578#undef tos 4579 } 4580 while (0); 4581 /* SEND_IMMEDIATE ( -- ) */ 4582 do 4583 { 4584 int n = 32; 4585#define PREPARE_STACK() do { \ 4586 PUSH_OOP (_extra1); \ 4587 } while (0) 4588#line 662 "vm.def" 4589 const struct builtin_selector *bs = &_gst_builtin_selectors[n]; 4590 PREPARE_STACK (); 4591 EXPORT_REGS (); 4592 SEND_MESSAGE (bs->symbol, bs->numArgs); 4593 IMPORT_REGS (); 4594 FETCH; 4595 4596#line 4597 "vm.inl" 4597#undef PREPARE_STACK 4598 } 4599 while (0); 4600 PUSH_OOP (_extra1); 4601 } 4602 NEXT_BC; 4603bc104: 4604 { 4605 OOP _extra1; 4606 /* PREFETCH ( -- ) */ 4607 do 4608 { 4609#line 207 "vm.def" 4610 PREFETCH; 4611 LOCAL_COUNTER++; 4612 4613#line 4614 "vm.inl" 4614 } 4615 while (0); 4616 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 4617 do 4618 { 4619 int n = arg; 4620#define tos _extra1 4621#line 683 "vm.def" 4622 tos = METHOD_TEMPORARY (n); 4623 4624#line 4625 "vm.inl" 4625#undef tos 4626 } 4627 while (0); 4628 /* SIZE_SPECIAL ( rec -- val ) */ 4629 do 4630 { 4631#define PREPARE_STACK() do { \ 4632 PUSH_OOP (_extra1); \ 4633 } while (0) 4634#define rec _extra1 4635#define val _extra1 4636#line 510 "vm.def" 4637 OOP classOOP; 4638 PREPARE_STACK (); 4639 EXPORT_REGS (); 4640 if UNCOMMON (IS_INT (rec)) 4641 { 4642 SEND_MESSAGE (_gst_builtin_selectors[SIZE_SPECIAL].symbol, 0); 4643 IMPORT_REGS (); 4644 FETCH; 4645 } 4646 4647 if COMMON (size_cache_class == (classOOP = OOP_CLASS (rec)) 4648 && !execute_primitive_operation (size_cache_prim, 0)) 4649 { 4650 IMPORT_REGS (); 4651 NEXT_BC; 4652 } 4653 4654 /* Not the same class that is in the cache, or the primitive failed -- 4655 send the message, and modify the cache if the send is resolved to 4656 a primitive. */ 4657 last_primitive = 0; 4658 SEND_MESSAGE (_gst_builtin_selectors[SIZE_SPECIAL].symbol, 0); 4659 IMPORT_REGS (); 4660 if COMMON (last_primitive) 4661 { 4662 size_cache_prim = last_primitive; 4663 size_cache_class = classOOP; 4664 NEXT_BC; 4665 } 4666 FETCH; 4667 4668#line 4669 "vm.inl" 4669#undef PREPARE_STACK 4670#undef rec 4671#undef val 4672 } 4673 while (0); 4674 PUSH_OOP (_extra1); 4675 } 4676 NEXT_BC; 4677bc105: 4678 { 4679 OOP _extra1; 4680 /* PREFETCH ( -- ) */ 4681 do 4682 { 4683#line 207 "vm.def" 4684 PREFETCH; 4685 LOCAL_COUNTER++; 4686 4687#line 4688 "vm.inl" 4688 } 4689 while (0); 4690 /* PUSH_SELF ( -- tos ) */ 4691 do 4692 { 4693#define tos _extra1 4694#line 893 "vm.def" 4695 tos = _gst_self; 4696 4697#line 4698 "vm.inl" 4698#undef tos 4699 } 4700 while (0); 4701 /* SEND ( -- ) */ 4702 do 4703 { 4704 int sel = arg >> 8; 4705 int n = arg & 255; 4706#define PREPARE_STACK() do { \ 4707 PUSH_OOP (_extra1); \ 4708 } while (0) 4709#line 643 "vm.def" 4710 PREPARE_STACK (); 4711 EXPORT_REGS (); 4712 SEND_MESSAGE (METHOD_LITERAL (sel), n); 4713 IMPORT_REGS (); 4714 FETCH; 4715 4716#line 4717 "vm.inl" 4717#undef PREPARE_STACK 4718 } 4719 while (0); 4720 PUSH_OOP (_extra1); 4721 } 4722 NEXT_BC; 4723bc106: 4724 { 4725 OOP _extra1; 4726 /* PREFETCH ( -- ) */ 4727 do 4728 { 4729#line 207 "vm.def" 4730 PREFETCH; 4731 LOCAL_COUNTER++; 4732 4733#line 4734 "vm.inl" 4734 } 4735 while (0); 4736 /* LINE_NUMBER_BYTECODE ( -- ) */ 4737 do 4738 { 4739#line 890 "vm.def" 4740 4741#line 4742 "vm.inl" 4742 } 4743 while (0); 4744 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 4745 do 4746 { 4747 int n = 2; 4748#define tos _extra1 4749#line 683 "vm.def" 4750 tos = METHOD_TEMPORARY (n); 4751 4752#line 4753 "vm.inl" 4753#undef tos 4754 } 4755 while (0); 4756 PUSH_OOP (_extra1); 4757 } 4758 NEXT_BC; 4759bc107: 4760 { 4761 OOP _stack0; 4762 _stack0 = STACK_AT (0); 4763 /* PREFETCH ( -- ) */ 4764 do 4765 { 4766#line 207 "vm.def" 4767 PREFETCH; 4768 LOCAL_COUNTER++; 4769 4770#line 4771 "vm.inl" 4771 } 4772 while (0); 4773 /* POP_STACK_TOP ( tos -- ) */ 4774 do 4775 { 4776#define tos _stack0 4777#line 828 "vm.def" 4778 4779#line 4780 "vm.inl" 4780#undef tos 4781 } 4782 while (0); 4783 /* SEND_IMMEDIATE ( -- ) */ 4784 do 4785 { 4786 int n = arg; 4787#define PREPARE_STACK() do { \ 4788 POP_N_OOPS (1); \ 4789 } while (0) 4790#line 662 "vm.def" 4791 const struct builtin_selector *bs = &_gst_builtin_selectors[n]; 4792 PREPARE_STACK (); 4793 EXPORT_REGS (); 4794 SEND_MESSAGE (bs->symbol, bs->numArgs); 4795 IMPORT_REGS (); 4796 FETCH; 4797 4798#line 4799 "vm.inl" 4799#undef PREPARE_STACK 4800 } 4801 while (0); 4802 POP_N_OOPS (1); 4803 } 4804 NEXT_BC; 4805bc108: 4806 { 4807 OOP _extra1, _extra2; 4808 /* PREFETCH ( -- ) */ 4809 do 4810 { 4811#line 207 "vm.def" 4812 PREFETCH; 4813 LOCAL_COUNTER++; 4814 4815#line 4816 "vm.inl" 4816 } 4817 while (0); 4818 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 4819 do 4820 { 4821 int n = arg; 4822#define tos _extra1 4823#line 683 "vm.def" 4824 tos = METHOD_TEMPORARY (n); 4825 4826#line 4827 "vm.inl" 4827#undef tos 4828 } 4829 while (0); 4830 /* PUSH_INTEGER ( -- tos ) */ 4831 do 4832 { 4833 int n = 1; 4834#define tos _extra2 4835#line 812 "vm.def" 4836 tos = FROM_INT (n); 4837 4838#line 4839 "vm.inl" 4839#undef tos 4840 } 4841 while (0); 4842 /* PLUS_SPECIAL ( op1 op2 -- op ) */ 4843 do 4844 { 4845#define PREPARE_STACK() do { \ 4846 PUSH_OOP (_extra1); \ 4847 PUSH_OOP (_extra2); \ 4848 } while (0) 4849#define op1 _extra1 4850#define op2 _extra2 4851#define op _extra1 4852#line 230 "vm.def" 4853 INTERP_BASIC_OP (op, op1, op2, 4854 add_with_check (op1, op2, &overflow), 4855 farg1 + farg2); 4856 PREPARE_STACK (); 4857 EXPORT_REGS (); 4858 SEND_MESSAGE (_gst_builtin_selectors[PLUS_SPECIAL].symbol, 1); 4859 IMPORT_REGS (); 4860 FETCH; 4861 4862#line 4863 "vm.inl" 4863#undef PREPARE_STACK 4864#undef op1 4865#undef op2 4866#undef op 4867 } 4868 while (0); 4869 PUSH_OOP (_extra1); 4870 } 4871 NEXT_BC; 4872bc109: 4873 { 4874 OOP _extra1; 4875 /* PREFETCH ( -- ) */ 4876 do 4877 { 4878#line 207 "vm.def" 4879 PREFETCH; 4880 LOCAL_COUNTER++; 4881 4882#line 4883 "vm.inl" 4883 } 4884 while (0); 4885 /* LINE_NUMBER_BYTECODE ( -- ) */ 4886 do 4887 { 4888#line 890 "vm.def" 4889 4890#line 4891 "vm.inl" 4891 } 4892 while (0); 4893 /* PUSH_RECEIVER_VARIABLE ( -- tos ) */ 4894 do 4895 { 4896 int n = 0; 4897#define tos _extra1 4898#line 718 "vm.def" 4899 tos = RECEIVER_VARIABLE (n); 4900 4901#line 4902 "vm.inl" 4902#undef tos 4903 } 4904 while (0); 4905 PUSH_OOP (_extra1); 4906 } 4907 NEXT_BC; 4908bc110: 4909 { 4910 OOP _extra1; 4911 /* PREFETCH ( -- ) */ 4912 do 4913 { 4914#line 207 "vm.def" 4915 PREFETCH; 4916 LOCAL_COUNTER++; 4917 4918#line 4919 "vm.inl" 4919 } 4920 while (0); 4921 /* PUSH_LIT_CONSTANT ( -- tos ) */ 4922 do 4923 { 4924 int n = arg; 4925#define tos _extra1 4926#line 820 "vm.def" 4927 tos = METHOD_LITERAL (n); 4928 4929#line 4930 "vm.inl" 4930#undef tos 4931 } 4932 while (0); 4933 /* SEND_IMMEDIATE ( -- ) */ 4934 do 4935 { 4936 int n = 38; 4937#define PREPARE_STACK() do { \ 4938 PUSH_OOP (_extra1); \ 4939 } while (0) 4940#line 662 "vm.def" 4941 const struct builtin_selector *bs = &_gst_builtin_selectors[n]; 4942 PREPARE_STACK (); 4943 EXPORT_REGS (); 4944 SEND_MESSAGE (bs->symbol, bs->numArgs); 4945 IMPORT_REGS (); 4946 FETCH; 4947 4948#line 4949 "vm.inl" 4949#undef PREPARE_STACK 4950 } 4951 while (0); 4952 PUSH_OOP (_extra1); 4953 } 4954 NEXT_BC; 4955bc111: 4956 { 4957 OOP _stack0; 4958 OOP _extra1; 4959 _stack0 = STACK_AT (0); 4960 /* PREFETCH ( -- ) */ 4961 do 4962 { 4963#line 207 "vm.def" 4964 PREFETCH; 4965 LOCAL_COUNTER++; 4966 4967#line 4968 "vm.inl" 4968 } 4969 while (0); 4970 /* PUSH_INTEGER ( -- tos ) */ 4971 do 4972 { 4973 int n = arg; 4974#define tos _extra1 4975#line 812 "vm.def" 4976 tos = FROM_INT (n); 4977 4978#line 4979 "vm.inl" 4979#undef tos 4980 } 4981 while (0); 4982 /* AT_SPECIAL ( rec idx -- val ) */ 4983 do 4984 { 4985#define PREPARE_STACK() do { \ 4986 PUSH_OOP (_extra1); \ 4987 } while (0) 4988#define rec _stack0 4989#define idx _extra1 4990#define val _stack0 4991#line 444 "vm.def" 4992 OOP classOOP; 4993 PREPARE_STACK (); 4994 EXPORT_REGS (); 4995 if UNCOMMON (IS_INT (rec)) 4996 { 4997 SEND_MESSAGE (_gst_builtin_selectors[AT_SPECIAL].symbol, 1); 4998 IMPORT_REGS (); 4999 FETCH; 5000 } 5001 5002 if COMMON (at_cache_class == (classOOP = OOP_CLASS (rec)) 5003 && !cached_index_oop_primitive (rec, idx, at_cache_spec)) 5004 { 5005 IMPORT_REGS (); 5006 NEXT_BC; 5007 } 5008 5009 /* Not the same class that is in the cache, or the primitive failed -- 5010 send the message, and modify the cache if the send is resolved to 5011 a primitive. */ 5012 last_primitive = 0; 5013 SEND_MESSAGE (_gst_builtin_selectors[AT_SPECIAL].symbol, 1); 5014 IMPORT_REGS (); 5015 if (_gst_primitive_table[last_primitive].id == 60) 5016 { 5017 at_cache_spec = CLASS_INSTANCE_SPEC (classOOP); 5018 at_cache_class = classOOP; 5019 NEXT_BC; 5020 } 5021 FETCH; 5022 5023#line 5024 "vm.inl" 5024#undef PREPARE_STACK 5025#undef rec 5026#undef idx 5027#undef val 5028 } 5029 while (0); 5030 STACK_AT (0) = _stack0; 5031 } 5032 NEXT_BC; 5033bc112: 5034 { 5035 OOP _extra1; 5036 /* PREFETCH ( -- ) */ 5037 do 5038 { 5039#line 207 "vm.def" 5040 PREFETCH; 5041 LOCAL_COUNTER++; 5042 5043#line 5044 "vm.inl" 5044 } 5045 while (0); 5046 /* LINE_NUMBER_BYTECODE ( -- ) */ 5047 do 5048 { 5049#line 890 "vm.def" 5050 5051#line 5052 "vm.inl" 5052 } 5053 while (0); 5054 /* PUSH_RECEIVER_VARIABLE ( -- tos ) */ 5055 do 5056 { 5057 int n = 1; 5058#define tos _extra1 5059#line 718 "vm.def" 5060 tos = RECEIVER_VARIABLE (n); 5061 5062#line 5063 "vm.inl" 5063#undef tos 5064 } 5065 while (0); 5066 PUSH_OOP (_extra1); 5067 } 5068 NEXT_BC; 5069bc113: 5070 { 5071 OOP _extra1, _extra2; 5072 /* PREFETCH ( -- ) */ 5073 do 5074 { 5075#line 207 "vm.def" 5076 PREFETCH; 5077 LOCAL_COUNTER++; 5078 5079#line 5080 "vm.inl" 5080 } 5081 while (0); 5082 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 5083 do 5084 { 5085 int n = 0; 5086#define tos _extra1 5087#line 683 "vm.def" 5088 tos = METHOD_TEMPORARY (n); 5089 5090#line 5091 "vm.inl" 5091#undef tos 5092 } 5093 while (0); 5094 /* PUSH_LIT_CONSTANT ( -- tos ) */ 5095 do 5096 { 5097 int n = arg; 5098#define tos _extra2 5099#line 820 "vm.def" 5100 tos = METHOD_LITERAL (n); 5101 5102#line 5103 "vm.inl" 5103#undef tos 5104 } 5105 while (0); 5106 PUSH_OOP (_extra1); 5107 PUSH_OOP (_extra2); 5108 } 5109 NEXT_BC; 5110bc114: 5111 { 5112 OOP _stack0; 5113 OOP _extra1; 5114 _stack0 = STACK_AT (0); 5115 /* PREFETCH ( -- ) */ 5116 do 5117 { 5118#line 207 "vm.def" 5119 PREFETCH; 5120 LOCAL_COUNTER++; 5121 5122#line 5123 "vm.inl" 5123 } 5124 while (0); 5125 /* DUP_STACK_TOP ( tos | -- tos | tos2 ) */ 5126 do 5127 { 5128#define tos _stack0 5129#define tos2 _extra1 5130#line 860 "vm.def" 5131 tos2 = tos; 5132 5133#line 5134 "vm.inl" 5134#undef tos 5135#undef tos2 5136 } 5137 while (0); 5138 /* POP_JUMP_TRUE ( tos -- ) */ 5139 do 5140 { 5141 int n = arg; 5142#define PREPARE_STACK() do { \ 5143 PUSH_OOP (_extra1); \ 5144 } while (0) 5145#define tos _extra1 5146#line 793 "vm.def" 5147 if UNCOMMON (tos == _gst_true_oop) 5148 { 5149 PREPARE_STACK (); 5150 POP_N_OOPS(1); 5151 ip += n; 5152 FETCH; 5153 } 5154 else if UNCOMMON (tos != _gst_false_oop) 5155 { 5156 ip += n; 5157 PREPARE_STACK (); 5158 EXPORT_REGS(); 5159 SEND_MESSAGE(_gst_must_be_boolean_symbol, 0); 5160 IMPORT_REGS(); 5161 FETCH; 5162 } 5163 5164#line 5165 "vm.inl" 5165#undef PREPARE_STACK 5166#undef tos 5167 } 5168 while (0); 5169 } 5170 NEXT_BC; 5171bc115: 5172 { 5173 OOP _stack0; 5174 OOP _extra1; 5175 _stack0 = STACK_AT (0); 5176 /* PREFETCH ( -- ) */ 5177 do 5178 { 5179#line 207 "vm.def" 5180 PREFETCH; 5181 LOCAL_COUNTER++; 5182 5183#line 5184 "vm.inl" 5184 } 5185 while (0); 5186 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 5187 do 5188 { 5189 int n = arg; 5190#define tos _extra1 5191#line 683 "vm.def" 5192 tos = METHOD_TEMPORARY (n); 5193 5194#line 5195 "vm.inl" 5195#undef tos 5196 } 5197 while (0); 5198 /* AT_SPECIAL ( rec idx -- val ) */ 5199 do 5200 { 5201#define PREPARE_STACK() do { \ 5202 PUSH_OOP (_extra1); \ 5203 } while (0) 5204#define rec _stack0 5205#define idx _extra1 5206#define val _stack0 5207#line 444 "vm.def" 5208 OOP classOOP; 5209 PREPARE_STACK (); 5210 EXPORT_REGS (); 5211 if UNCOMMON (IS_INT (rec)) 5212 { 5213 SEND_MESSAGE (_gst_builtin_selectors[AT_SPECIAL].symbol, 1); 5214 IMPORT_REGS (); 5215 FETCH; 5216 } 5217 5218 if COMMON (at_cache_class == (classOOP = OOP_CLASS (rec)) 5219 && !cached_index_oop_primitive (rec, idx, at_cache_spec)) 5220 { 5221 IMPORT_REGS (); 5222 NEXT_BC; 5223 } 5224 5225 /* Not the same class that is in the cache, or the primitive failed -- 5226 send the message, and modify the cache if the send is resolved to 5227 a primitive. */ 5228 last_primitive = 0; 5229 SEND_MESSAGE (_gst_builtin_selectors[AT_SPECIAL].symbol, 1); 5230 IMPORT_REGS (); 5231 if (_gst_primitive_table[last_primitive].id == 60) 5232 { 5233 at_cache_spec = CLASS_INSTANCE_SPEC (classOOP); 5234 at_cache_class = classOOP; 5235 NEXT_BC; 5236 } 5237 FETCH; 5238 5239#line 5240 "vm.inl" 5240#undef PREPARE_STACK 5241#undef rec 5242#undef idx 5243#undef val 5244 } 5245 while (0); 5246 STACK_AT (0) = _stack0; 5247 } 5248 NEXT_BC; 5249bc116: 5250 { 5251 OOP _extra1; 5252 /* PREFETCH ( -- ) */ 5253 do 5254 { 5255#line 207 "vm.def" 5256 PREFETCH; 5257 LOCAL_COUNTER++; 5258 5259#line 5260 "vm.inl" 5260 } 5261 while (0); 5262 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 5263 do 5264 { 5265 int n = 2; 5266#define tos _extra1 5267#line 683 "vm.def" 5268 tos = METHOD_TEMPORARY (n); 5269 5270#line 5271 "vm.inl" 5271#undef tos 5272 } 5273 while (0); 5274 /* SEND_IMMEDIATE ( -- ) */ 5275 do 5276 { 5277 int n = arg; 5278#define PREPARE_STACK() do { \ 5279 PUSH_OOP (_extra1); \ 5280 } while (0) 5281#line 662 "vm.def" 5282 const struct builtin_selector *bs = &_gst_builtin_selectors[n]; 5283 PREPARE_STACK (); 5284 EXPORT_REGS (); 5285 SEND_MESSAGE (bs->symbol, bs->numArgs); 5286 IMPORT_REGS (); 5287 FETCH; 5288 5289#line 5290 "vm.inl" 5290#undef PREPARE_STACK 5291 } 5292 while (0); 5293 PUSH_OOP (_extra1); 5294 } 5295 NEXT_BC; 5296bc117: 5297 { 5298 OOP _extra1; 5299 /* PREFETCH ( -- ) */ 5300 do 5301 { 5302#line 207 "vm.def" 5303 PREFETCH; 5304 LOCAL_COUNTER++; 5305 5306#line 5307 "vm.inl" 5307 } 5308 while (0); 5309 /* PUSH_LIT_CONSTANT ( -- tos ) */ 5310 do 5311 { 5312 int n = arg; 5313#define tos _extra1 5314#line 820 "vm.def" 5315 tos = METHOD_LITERAL (n); 5316 5317#line 5318 "vm.inl" 5318#undef tos 5319 } 5320 while (0); 5321 /* SEND_IMMEDIATE ( -- ) */ 5322 do 5323 { 5324 int n = 49; 5325#define PREPARE_STACK() do { \ 5326 PUSH_OOP (_extra1); \ 5327 } while (0) 5328#line 662 "vm.def" 5329 const struct builtin_selector *bs = &_gst_builtin_selectors[n]; 5330 PREPARE_STACK (); 5331 EXPORT_REGS (); 5332 SEND_MESSAGE (bs->symbol, bs->numArgs); 5333 IMPORT_REGS (); 5334 FETCH; 5335 5336#line 5337 "vm.inl" 5337#undef PREPARE_STACK 5338 } 5339 while (0); 5340 PUSH_OOP (_extra1); 5341 } 5342 NEXT_BC; 5343bc118: 5344 { 5345 OOP _stack0; 5346 _stack0 = STACK_AT (0); 5347 /* PREFETCH ( -- ) */ 5348 do 5349 { 5350#line 207 "vm.def" 5351 PREFETCH; 5352 LOCAL_COUNTER++; 5353 5354#line 5355 "vm.inl" 5355 } 5356 while (0); 5357 /* STORE_TEMPORARY_VARIABLE ( tos | -- tos | ) */ 5358 do 5359 { 5360 int n = 1; 5361#define tos _stack0 5362#line 722 "vm.def" 5363 STORE_METHOD_TEMPORARY (n, tos); 5364 5365#line 5366 "vm.inl" 5366#undef tos 5367 } 5368 while (0); 5369 /* LINE_NUMBER_BYTECODE ( -- ) */ 5370 do 5371 { 5372#line 890 "vm.def" 5373 5374#line 5375 "vm.inl" 5375 } 5376 while (0); 5377 /* POP_STACK_TOP ( tos -- ) */ 5378 do 5379 { 5380#define tos _stack0 5381#line 828 "vm.def" 5382 5383#line 5384 "vm.inl" 5384#undef tos 5385 } 5386 while (0); 5387 POP_N_OOPS (1); 5388 } 5389 NEXT_BC; 5390bc119: 5391 { 5392 OOP _extra1; 5393 /* PREFETCH ( -- ) */ 5394 do 5395 { 5396#line 207 "vm.def" 5397 PREFETCH; 5398 LOCAL_COUNTER++; 5399 5400#line 5401 "vm.inl" 5401 } 5402 while (0); 5403 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 5404 do 5405 { 5406 int n = 1; 5407#define tos _extra1 5408#line 683 "vm.def" 5409 tos = METHOD_TEMPORARY (n); 5410 5411#line 5412 "vm.inl" 5412#undef tos 5413 } 5414 while (0); 5415 /* SEND ( -- ) */ 5416 do 5417 { 5418 int sel = arg; 5419 int n = 1; 5420#define PREPARE_STACK() do { \ 5421 PUSH_OOP (_extra1); \ 5422 } while (0) 5423#line 643 "vm.def" 5424 PREPARE_STACK (); 5425 EXPORT_REGS (); 5426 SEND_MESSAGE (METHOD_LITERAL (sel), n); 5427 IMPORT_REGS (); 5428 FETCH; 5429 5430#line 5431 "vm.inl" 5431#undef PREPARE_STACK 5432 } 5433 while (0); 5434 PUSH_OOP (_extra1); 5435 } 5436 NEXT_BC; 5437bc120: 5438 { 5439 OOP _stack0; 5440 _stack0 = STACK_AT (0); 5441 /* PREFETCH ( -- ) */ 5442 do 5443 { 5444#line 207 "vm.def" 5445 PREFETCH; 5446 LOCAL_COUNTER++; 5447 5448#line 5449 "vm.inl" 5449 } 5450 while (0); 5451 /* STORE_RECEIVER_VARIABLE ( tos | -- tos | ) */ 5452 do 5453 { 5454 int n = arg; 5455#define tos _stack0 5456#line 758 "vm.def" 5457 STORE_RECEIVER_VARIABLE (n, tos); 5458 5459#line 5460 "vm.inl" 5460#undef tos 5461 } 5462 while (0); 5463 /* POP_STACK_TOP ( tos -- ) */ 5464 do 5465 { 5466#define tos _stack0 5467#line 828 "vm.def" 5468 5469#line 5470 "vm.inl" 5470#undef tos 5471 } 5472 while (0); 5473 POP_N_OOPS (1); 5474 } 5475 NEXT_BC; 5476bc121: 5477 { 5478 OOP _stack0; 5479 _stack0 = STACK_AT (0); 5480 /* PREFETCH ( -- ) */ 5481 do 5482 { 5483#line 207 "vm.def" 5484 PREFETCH; 5485 LOCAL_COUNTER++; 5486 5487#line 5488 "vm.inl" 5488 } 5489 while (0); 5490 /* STORE_OUTER_TEMP ( tos | -- tos | ) */ 5491 do 5492 { 5493 int n = arg; 5494 int scopes = 1; 5495#define tos _stack0 5496#line 726 "vm.def" 5497 OOP contextOOP; 5498 gst_block_context context; 5499 5500 context = (gst_block_context) OOP_TO_OBJ (_gst_this_context_oop); 5501 do 5502 { 5503 contextOOP = context->outerContext; 5504 context = (gst_block_context) OOP_TO_OBJ (contextOOP); 5505 } 5506 while (--scopes); 5507 5508 context->contextStack[n] = tos; 5509 5510#line 5511 "vm.inl" 5511#undef tos 5512 } 5513 while (0); 5514 } 5515 NEXT_BC; 5516bc122: 5517 { 5518 OOP _extra1; 5519 /* PREFETCH ( -- ) */ 5520 do 5521 { 5522#line 207 "vm.def" 5523 PREFETCH; 5524 LOCAL_COUNTER++; 5525 5526#line 5527 "vm.inl" 5527 } 5528 while (0); 5529 /* PUSH_INTEGER ( -- tos ) */ 5530 do 5531 { 5532 int n = arg; 5533#define tos _extra1 5534#line 812 "vm.def" 5535 tos = FROM_INT (n); 5536 5537#line 5538 "vm.inl" 5538#undef tos 5539 } 5540 while (0); 5541 /* SEND_IMMEDIATE ( -- ) */ 5542 do 5543 { 5544 int n = 96; 5545#define PREPARE_STACK() do { \ 5546 PUSH_OOP (_extra1); \ 5547 } while (0) 5548#line 662 "vm.def" 5549 const struct builtin_selector *bs = &_gst_builtin_selectors[n]; 5550 PREPARE_STACK (); 5551 EXPORT_REGS (); 5552 SEND_MESSAGE (bs->symbol, bs->numArgs); 5553 IMPORT_REGS (); 5554 FETCH; 5555 5556#line 5557 "vm.inl" 5557#undef PREPARE_STACK 5558 } 5559 while (0); 5560 PUSH_OOP (_extra1); 5561 } 5562 NEXT_BC; 5563bc123: 5564 { 5565 OOP _stack0; 5566 _stack0 = STACK_AT (0); 5567 /* PREFETCH ( -- ) */ 5568 do 5569 { 5570#line 207 "vm.def" 5571 PREFETCH; 5572 LOCAL_COUNTER++; 5573 5574#line 5575 "vm.inl" 5575 } 5576 while (0); 5577 /* POP_STACK_TOP ( tos -- ) */ 5578 do 5579 { 5580#define tos _stack0 5581#line 828 "vm.def" 5582 5583#line 5584 "vm.inl" 5584#undef tos 5585 } 5586 while (0); 5587 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 5588 do 5589 { 5590 int n = arg; 5591#define tos _stack0 5592#line 683 "vm.def" 5593 tos = METHOD_TEMPORARY (n); 5594 5595#line 5596 "vm.inl" 5596#undef tos 5597 } 5598 while (0); 5599 STACK_AT (0) = _stack0; 5600 } 5601 NEXT_BC; 5602bc124: 5603 { 5604 OOP _extra1; 5605 /* PREFETCH ( -- ) */ 5606 do 5607 { 5608#line 207 "vm.def" 5609 PREFETCH; 5610 LOCAL_COUNTER++; 5611 5612#line 5613 "vm.inl" 5613 } 5614 while (0); 5615 /* PUSH_RECEIVER_VARIABLE ( -- tos ) */ 5616 do 5617 { 5618 int n = arg; 5619#define tos _extra1 5620#line 718 "vm.def" 5621 tos = RECEIVER_VARIABLE (n); 5622 5623#line 5624 "vm.inl" 5624#undef tos 5625 } 5626 while (0); 5627 /* RETURN_CONTEXT_STACK_TOP ( val | -- val | ) */ 5628 do 5629 { 5630#define val _extra1 5631#line 852 "vm.def" 5632 EXPORT_REGS (); 5633 unwind_context (); 5634 IMPORT_REGS (); 5635 SET_STACKTOP (val); 5636 FETCH; 5637 5638#line 5639 "vm.inl" 5639#undef val 5640 } 5641 while (0); 5642 PUSH_OOP (_extra1); 5643 } 5644 NEXT_BC; 5645bc125: 5646 { 5647 OOP _stack0; 5648 _stack0 = STACK_AT (0); 5649 /* PREFETCH ( -- ) */ 5650 do 5651 { 5652#line 207 "vm.def" 5653 PREFETCH; 5654 LOCAL_COUNTER++; 5655 5656#line 5657 "vm.inl" 5657 } 5658 while (0); 5659 /* LINE_NUMBER_BYTECODE ( -- ) */ 5660 do 5661 { 5662#line 890 "vm.def" 5663 5664#line 5665 "vm.inl" 5665 } 5666 while (0); 5667 /* POP_STACK_TOP ( tos -- ) */ 5668 do 5669 { 5670#define tos _stack0 5671#line 828 "vm.def" 5672 5673#line 5674 "vm.inl" 5674#undef tos 5675 } 5676 while (0); 5677 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 5678 do 5679 { 5680 int n = 1; 5681#define tos _stack0 5682#line 683 "vm.def" 5683 tos = METHOD_TEMPORARY (n); 5684 5685#line 5686 "vm.inl" 5686#undef tos 5687 } 5688 while (0); 5689 STACK_AT (0) = _stack0; 5690 } 5691 NEXT_BC; 5692bc126: 5693 { 5694 OOP _stack0; 5695 _stack0 = STACK_AT (0); 5696 /* PREFETCH ( -- ) */ 5697 do 5698 { 5699#line 207 "vm.def" 5700 PREFETCH; 5701 LOCAL_COUNTER++; 5702 5703#line 5704 "vm.inl" 5704 } 5705 while (0); 5706 /* LINE_NUMBER_BYTECODE ( -- ) */ 5707 do 5708 { 5709#line 890 "vm.def" 5710 5711#line 5712 "vm.inl" 5712 } 5713 while (0); 5714 /* POP_STACK_TOP ( tos -- ) */ 5715 do 5716 { 5717#define tos _stack0 5718#line 828 "vm.def" 5719 5720#line 5721 "vm.inl" 5721#undef tos 5722 } 5723 while (0); 5724 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 5725 do 5726 { 5727 int n = 0; 5728#define tos _stack0 5729#line 683 "vm.def" 5730 tos = METHOD_TEMPORARY (n); 5731 5732#line 5733 "vm.inl" 5733#undef tos 5734 } 5735 while (0); 5736 STACK_AT (0) = _stack0; 5737 } 5738 NEXT_BC; 5739bc127: 5740 { 5741 OOP _extra1, _extra2; 5742 /* PREFETCH ( -- ) */ 5743 do 5744 { 5745#line 207 "vm.def" 5746 PREFETCH; 5747 LOCAL_COUNTER++; 5748 5749#line 5750 "vm.inl" 5750 } 5751 while (0); 5752 /* LINE_NUMBER_BYTECODE ( -- ) */ 5753 do 5754 { 5755#line 890 "vm.def" 5756 5757#line 5758 "vm.inl" 5758 } 5759 while (0); 5760 /* PUSH_SELF ( -- tos ) */ 5761 do 5762 { 5763#define tos _extra1 5764#line 893 "vm.def" 5765 tos = _gst_self; 5766 5767#line 5768 "vm.inl" 5768#undef tos 5769 } 5770 while (0); 5771 /* PUSH_LIT_CONSTANT ( -- tos ) */ 5772 do 5773 { 5774 int n = 0; 5775#define tos _extra2 5776#line 820 "vm.def" 5777 tos = METHOD_LITERAL (n); 5778 5779#line 5780 "vm.inl" 5780#undef tos 5781 } 5782 while (0); 5783 PUSH_OOP (_extra1); 5784 PUSH_OOP (_extra2); 5785 } 5786 NEXT_BC; 5787bc128: 5788 { 5789 OOP _extra1; 5790 /* PREFETCH ( -- ) */ 5791 do 5792 { 5793#line 207 "vm.def" 5794 PREFETCH; 5795 LOCAL_COUNTER++; 5796 5797#line 5798 "vm.inl" 5798 } 5799 while (0); 5800 /* PUSH_LIT_CONSTANT ( -- tos ) */ 5801 do 5802 { 5803 int n = arg; 5804#define tos _extra1 5805#line 820 "vm.def" 5806 tos = METHOD_LITERAL (n); 5807 5808#line 5809 "vm.inl" 5809#undef tos 5810 } 5811 while (0); 5812 /* RETURN_CONTEXT_STACK_TOP ( val | -- val | ) */ 5813 do 5814 { 5815#define val _extra1 5816#line 852 "vm.def" 5817 EXPORT_REGS (); 5818 unwind_context (); 5819 IMPORT_REGS (); 5820 SET_STACKTOP (val); 5821 FETCH; 5822 5823#line 5824 "vm.inl" 5824#undef val 5825 } 5826 while (0); 5827 PUSH_OOP (_extra1); 5828 } 5829 NEXT_BC; 5830bc129: 5831 { 5832 OOP _extra1; 5833 /* PREFETCH ( -- ) */ 5834 do 5835 { 5836#line 207 "vm.def" 5837 PREFETCH; 5838 LOCAL_COUNTER++; 5839 5840#line 5841 "vm.inl" 5841 } 5842 while (0); 5843 /* PUSH_SELF ( -- tos ) */ 5844 do 5845 { 5846#define tos _extra1 5847#line 893 "vm.def" 5848 tos = _gst_self; 5849 5850#line 5851 "vm.inl" 5851#undef tos 5852 } 5853 while (0); 5854 /* SIZE_SPECIAL ( rec -- val ) */ 5855 do 5856 { 5857#define PREPARE_STACK() do { \ 5858 PUSH_OOP (_extra1); \ 5859 } while (0) 5860#define rec _extra1 5861#define val _extra1 5862#line 510 "vm.def" 5863 OOP classOOP; 5864 PREPARE_STACK (); 5865 EXPORT_REGS (); 5866 if UNCOMMON (IS_INT (rec)) 5867 { 5868 SEND_MESSAGE (_gst_builtin_selectors[SIZE_SPECIAL].symbol, 0); 5869 IMPORT_REGS (); 5870 FETCH; 5871 } 5872 5873 if COMMON (size_cache_class == (classOOP = OOP_CLASS (rec)) 5874 && !execute_primitive_operation (size_cache_prim, 0)) 5875 { 5876 IMPORT_REGS (); 5877 NEXT_BC; 5878 } 5879 5880 /* Not the same class that is in the cache, or the primitive failed -- 5881 send the message, and modify the cache if the send is resolved to 5882 a primitive. */ 5883 last_primitive = 0; 5884 SEND_MESSAGE (_gst_builtin_selectors[SIZE_SPECIAL].symbol, 0); 5885 IMPORT_REGS (); 5886 if COMMON (last_primitive) 5887 { 5888 size_cache_prim = last_primitive; 5889 size_cache_class = classOOP; 5890 NEXT_BC; 5891 } 5892 FETCH; 5893 5894#line 5895 "vm.inl" 5895#undef PREPARE_STACK 5896#undef rec 5897#undef val 5898 } 5899 while (0); 5900 PUSH_OOP (_extra1); 5901 } 5902 NEXT_BC; 5903bc130: 5904 { 5905 OOP _stack0; 5906 _stack0 = STACK_AT (0); 5907 /* PREFETCH ( -- ) */ 5908 do 5909 { 5910#line 207 "vm.def" 5911 PREFETCH; 5912 LOCAL_COUNTER++; 5913 5914#line 5915 "vm.inl" 5915 } 5916 while (0); 5917 /* IS_NIL_SPECIAL ( rec -- val ) */ 5918 do 5919 { 5920#define rec _stack0 5921#define val _stack0 5922#line 576 "vm.def" 5923 /* DO_JUMP_LOOKAHEAD (rec == _gst_nil_oop); */ 5924 val = rec == _gst_nil_oop ? _gst_true_oop : _gst_false_oop; 5925 5926#line 5927 "vm.inl" 5927#undef rec 5928#undef val 5929 } 5930 while (0); 5931 /* POP_JUMP_TRUE ( tos -- ) */ 5932 do 5933 { 5934 int n = arg; 5935#define PREPARE_STACK() do { \ 5936 STACK_AT (0) = _stack0; \ 5937 } while (0) 5938#define tos _stack0 5939#line 793 "vm.def" 5940 if UNCOMMON (tos == _gst_true_oop) 5941 { 5942 PREPARE_STACK (); 5943 POP_N_OOPS(1); 5944 ip += n; 5945 FETCH; 5946 } 5947 else if UNCOMMON (tos != _gst_false_oop) 5948 { 5949 ip += n; 5950 PREPARE_STACK (); 5951 EXPORT_REGS(); 5952 SEND_MESSAGE(_gst_must_be_boolean_symbol, 0); 5953 IMPORT_REGS(); 5954 FETCH; 5955 } 5956 5957#line 5958 "vm.inl" 5958#undef PREPARE_STACK 5959#undef tos 5960 } 5961 while (0); 5962 POP_N_OOPS (1); 5963 } 5964 NEXT_BC; 5965bc131: 5966 { 5967 OOP _stack0, _stack1; 5968 OOP _extra1; 5969 _stack1 = STACK_AT (1); 5970 _stack0 = STACK_AT (0); 5971 /* PREFETCH ( -- ) */ 5972 do 5973 { 5974#line 207 "vm.def" 5975 PREFETCH; 5976 LOCAL_COUNTER++; 5977 5978#line 5979 "vm.inl" 5979 } 5980 while (0); 5981 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 5982 do 5983 { 5984 int n = arg; 5985#define tos _extra1 5986#line 683 "vm.def" 5987 tos = METHOD_TEMPORARY (n); 5988 5989#line 5990 "vm.inl" 5990#undef tos 5991 } 5992 while (0); 5993 /* AT_PUT_SPECIAL ( rec idx val -- res ) */ 5994 do 5995 { 5996#define PREPARE_STACK() do { \ 5997 PUSH_OOP (_extra1); \ 5998 } while (0) 5999#define rec _stack1 6000#define idx _stack0 6001#define val _extra1 6002#define res _stack1 6003#line 477 "vm.def" 6004 OOP classOOP; 6005 PREPARE_STACK (); 6006 EXPORT_REGS (); 6007 if UNCOMMON (IS_INT (rec)) 6008 { 6009 SEND_MESSAGE (_gst_builtin_selectors[AT_PUT_SPECIAL].symbol, 2); 6010 IMPORT_REGS (); 6011 FETCH; 6012 } 6013 6014 if COMMON (at_put_cache_class == (classOOP = OOP_CLASS (rec)) 6015 && !cached_index_oop_put_primitive (rec, idx, val, at_put_cache_spec)) 6016 { 6017 IMPORT_REGS (); 6018 NEXT_BC; 6019 } 6020 6021 /* Not the same class that is in the cache, or the primitive failed -- 6022 send the message, and modify the cache if the send is resolved to 6023 a primitive. */ 6024 last_primitive = 0; 6025 SEND_MESSAGE (_gst_builtin_selectors[AT_PUT_SPECIAL].symbol, 2); 6026 IMPORT_REGS (); 6027 if (_gst_primitive_table[last_primitive].id == 61) 6028 { 6029 at_put_cache_spec = CLASS_INSTANCE_SPEC (classOOP); 6030 at_put_cache_class = classOOP; 6031 NEXT_BC; 6032 } 6033 FETCH; 6034 6035#line 6036 "vm.inl" 6036#undef PREPARE_STACK 6037#undef rec 6038#undef idx 6039#undef val 6040#undef res 6041 } 6042 while (0); 6043 STACK_AT (1) = _stack1; 6044 POP_N_OOPS (1); 6045 } 6046 NEXT_BC; 6047bc132: 6048 { 6049 OOP _extra1; 6050 /* PREFETCH ( -- ) */ 6051 do 6052 { 6053#line 207 "vm.def" 6054 PREFETCH; 6055 LOCAL_COUNTER++; 6056 6057#line 6058 "vm.inl" 6058 } 6059 while (0); 6060 /* LINE_NUMBER_BYTECODE ( -- ) */ 6061 do 6062 { 6063#line 890 "vm.def" 6064 6065#line 6066 "vm.inl" 6066 } 6067 while (0); 6068 /* PUSH_LIT_VARIABLE ( -- tos ) */ 6069 do 6070 { 6071 int n = 1; 6072#define PREPARE_STACK() do { \ 6073 } while (0) 6074#define tos _extra1 6075#line 702 "vm.def" 6076 tos = METHOD_LITERAL (n); 6077 if (UNCOMMON (IS_INT (tos)) 6078 || UNCOMMON (!is_a_kind_of (OOP_CLASS (tos), _gst_association_class))) 6079 { 6080 PREPARE_STACK (); 6081 PUSH_OOP (tos); 6082 EXPORT_REGS (); 6083 SEND_MESSAGE (_gst_builtin_selectors[VALUE_SPECIAL].symbol, 0); 6084 IMPORT_REGS (); 6085 FETCH; 6086 } 6087 else 6088 tos = ASSOCIATION_VALUE (tos); 6089 6090#line 6091 "vm.inl" 6091#undef PREPARE_STACK 6092#undef tos 6093 } 6094 while (0); 6095 PUSH_OOP (_extra1); 6096 } 6097 NEXT_BC; 6098bc133: 6099 { 6100 OOP _stack0; 6101 OOP _extra1; 6102 _stack0 = STACK_AT (0); 6103 /* PREFETCH ( -- ) */ 6104 do 6105 { 6106#line 207 "vm.def" 6107 PREFETCH; 6108 LOCAL_COUNTER++; 6109 6110#line 6111 "vm.inl" 6111 } 6112 while (0); 6113 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 6114 do 6115 { 6116 int n = arg; 6117#define tos _extra1 6118#line 683 "vm.def" 6119 tos = METHOD_TEMPORARY (n); 6120 6121#line 6122 "vm.inl" 6122#undef tos 6123 } 6124 while (0); 6125 /* PLUS_SPECIAL ( op1 op2 -- op ) */ 6126 do 6127 { 6128#define PREPARE_STACK() do { \ 6129 PUSH_OOP (_extra1); \ 6130 } while (0) 6131#define op1 _stack0 6132#define op2 _extra1 6133#define op _stack0 6134#line 230 "vm.def" 6135 INTERP_BASIC_OP (op, op1, op2, 6136 add_with_check (op1, op2, &overflow), 6137 farg1 + farg2); 6138 PREPARE_STACK (); 6139 EXPORT_REGS (); 6140 SEND_MESSAGE (_gst_builtin_selectors[PLUS_SPECIAL].symbol, 1); 6141 IMPORT_REGS (); 6142 FETCH; 6143 6144#line 6145 "vm.inl" 6145#undef PREPARE_STACK 6146#undef op1 6147#undef op2 6148#undef op 6149 } 6150 while (0); 6151 STACK_AT (0) = _stack0; 6152 } 6153 NEXT_BC; 6154bc134: 6155 { 6156 OOP _stack0; 6157 _stack0 = STACK_AT (0); 6158 /* ADVANCE ( -- ) */ 6159 do 6160 { 6161#line 212 "vm.def" 6162 ip += 2; 6163 LOCAL_COUNTER++; 6164 6165#line 6166 "vm.inl" 6166 } 6167 while (0); 6168 /* POP_STACK_TOP ( tos -- ) */ 6169 do 6170 { 6171#define tos _stack0 6172#line 828 "vm.def" 6173 6174#line 6175 "vm.inl" 6175#undef tos 6176 } 6177 while (0); 6178 /* JUMP_BACK ( -- ) */ 6179 do 6180 { 6181 int n = arg; 6182#define PREPARE_STACK() do { \ 6183 POP_N_OOPS (1); \ 6184 } while (0) 6185#line 762 "vm.def" 6186 PREPARE_STACK (); 6187 ip -= n; 6188 FETCH; 6189 6190#line 6191 "vm.inl" 6191#undef PREPARE_STACK 6192 } 6193 while (0); 6194 POP_N_OOPS (1); 6195 } 6196 NEXT_BC; 6197bc135: 6198 { 6199 OOP _stack0; 6200 _stack0 = STACK_AT (0); 6201 /* PREFETCH ( -- ) */ 6202 do 6203 { 6204#line 207 "vm.def" 6205 PREFETCH; 6206 LOCAL_COUNTER++; 6207 6208#line 6209 "vm.inl" 6209 } 6210 while (0); 6211 /* POP_STACK_TOP ( tos -- ) */ 6212 do 6213 { 6214#define tos _stack0 6215#line 828 "vm.def" 6216 6217#line 6218 "vm.inl" 6218#undef tos 6219 } 6220 while (0); 6221 /* PUSH_LIT_VARIABLE ( -- tos ) */ 6222 do 6223 { 6224 int n = arg; 6225#define PREPARE_STACK() do { \ 6226 POP_N_OOPS (1); \ 6227 } while (0) 6228#define tos _stack0 6229#line 702 "vm.def" 6230 tos = METHOD_LITERAL (n); 6231 if (UNCOMMON (IS_INT (tos)) 6232 || UNCOMMON (!is_a_kind_of (OOP_CLASS (tos), _gst_association_class))) 6233 { 6234 PREPARE_STACK (); 6235 PUSH_OOP (tos); 6236 EXPORT_REGS (); 6237 SEND_MESSAGE (_gst_builtin_selectors[VALUE_SPECIAL].symbol, 0); 6238 IMPORT_REGS (); 6239 FETCH; 6240 } 6241 else 6242 tos = ASSOCIATION_VALUE (tos); 6243 6244#line 6245 "vm.inl" 6245#undef PREPARE_STACK 6246#undef tos 6247 } 6248 while (0); 6249 STACK_AT (0) = _stack0; 6250 } 6251 NEXT_BC; 6252bc136: 6253 { 6254 OOP _extra1; 6255 /* PREFETCH ( -- ) */ 6256 do 6257 { 6258#line 207 "vm.def" 6259 PREFETCH; 6260 LOCAL_COUNTER++; 6261 6262#line 6263 "vm.inl" 6263 } 6264 while (0); 6265 /* PUSH_INTEGER ( -- tos ) */ 6266 do 6267 { 6268 int n = 1; 6269#define tos _extra1 6270#line 812 "vm.def" 6271 tos = FROM_INT (n); 6272 6273#line 6274 "vm.inl" 6274#undef tos 6275 } 6276 while (0); 6277 /* STORE_TEMPORARY_VARIABLE ( tos | -- tos | ) */ 6278 do 6279 { 6280 int n = arg; 6281#define tos _extra1 6282#line 722 "vm.def" 6283 STORE_METHOD_TEMPORARY (n, tos); 6284 6285#line 6286 "vm.inl" 6286#undef tos 6287 } 6288 while (0); 6289 PUSH_OOP (_extra1); 6290 } 6291 NEXT_BC; 6292bc137: 6293 { 6294 OOP _extra1; 6295 /* PREFETCH ( -- ) */ 6296 do 6297 { 6298#line 207 "vm.def" 6299 PREFETCH; 6300 LOCAL_COUNTER++; 6301 6302#line 6303 "vm.inl" 6303 } 6304 while (0); 6305 /* PUSH_LIT_CONSTANT ( -- tos ) */ 6306 do 6307 { 6308 int n = arg; 6309#define tos _extra1 6310#line 820 "vm.def" 6311 tos = METHOD_LITERAL (n); 6312 6313#line 6314 "vm.inl" 6314#undef tos 6315 } 6316 while (0); 6317 /* SEND ( -- ) */ 6318 do 6319 { 6320 int sel = 2; 6321 int n = 1; 6322#define PREPARE_STACK() do { \ 6323 PUSH_OOP (_extra1); \ 6324 } while (0) 6325#line 643 "vm.def" 6326 PREPARE_STACK (); 6327 EXPORT_REGS (); 6328 SEND_MESSAGE (METHOD_LITERAL (sel), n); 6329 IMPORT_REGS (); 6330 FETCH; 6331 6332#line 6333 "vm.inl" 6333#undef PREPARE_STACK 6334 } 6335 while (0); 6336 PUSH_OOP (_extra1); 6337 } 6338 NEXT_BC; 6339bc138: 6340 { 6341 OOP _extra1; 6342 /* PREFETCH ( -- ) */ 6343 do 6344 { 6345#line 207 "vm.def" 6346 PREFETCH; 6347 LOCAL_COUNTER++; 6348 6349#line 6350 "vm.inl" 6350 } 6351 while (0); 6352 /* LINE_NUMBER_BYTECODE ( -- ) */ 6353 do 6354 { 6355#line 890 "vm.def" 6356 6357#line 6358 "vm.inl" 6358 } 6359 while (0); 6360 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 6361 do 6362 { 6363 int n = 3; 6364#define tos _extra1 6365#line 683 "vm.def" 6366 tos = METHOD_TEMPORARY (n); 6367 6368#line 6369 "vm.inl" 6369#undef tos 6370 } 6371 while (0); 6372 PUSH_OOP (_extra1); 6373 } 6374 NEXT_BC; 6375bc139: 6376 { 6377 OOP _extra1; 6378 /* PREFETCH ( -- ) */ 6379 do 6380 { 6381#line 207 "vm.def" 6382 PREFETCH; 6383 LOCAL_COUNTER++; 6384 6385#line 6386 "vm.inl" 6386 } 6387 while (0); 6388 /* LINE_NUMBER_BYTECODE ( -- ) */ 6389 do 6390 { 6391#line 890 "vm.def" 6392 6393#line 6394 "vm.inl" 6394 } 6395 while (0); 6396 /* PUSH_OUTER_TEMP ( -- tos ) */ 6397 do 6398 { 6399 int n = 0; 6400 int scopes = 1; 6401#define tos _extra1 6402#line 687 "vm.def" 6403 OOP contextOOP; 6404 gst_block_context context; 6405 6406 context = (gst_block_context) OOP_TO_OBJ (_gst_this_context_oop); 6407 do 6408 { 6409 contextOOP = context->outerContext; 6410 context = (gst_block_context) OOP_TO_OBJ (contextOOP); 6411 } 6412 while (--scopes); 6413 6414 tos = context->contextStack[n]; 6415 6416#line 6417 "vm.inl" 6417#undef tos 6418 } 6419 while (0); 6420 PUSH_OOP (_extra1); 6421 } 6422 NEXT_BC; 6423bc140: 6424 { 6425 OOP _extra1; 6426 /* PREFETCH ( -- ) */ 6427 do 6428 { 6429#line 207 "vm.def" 6430 PREFETCH; 6431 LOCAL_COUNTER++; 6432 6433#line 6434 "vm.inl" 6434 } 6435 while (0); 6436 /* PUSH_RECEIVER_VARIABLE ( -- tos ) */ 6437 do 6438 { 6439 int n = arg; 6440#define tos _extra1 6441#line 718 "vm.def" 6442 tos = RECEIVER_VARIABLE (n); 6443 6444#line 6445 "vm.inl" 6445#undef tos 6446 } 6447 while (0); 6448 /* SEND ( -- ) */ 6449 do 6450 { 6451 int sel = 0; 6452 int n = 0; 6453#define PREPARE_STACK() do { \ 6454 PUSH_OOP (_extra1); \ 6455 } while (0) 6456#line 643 "vm.def" 6457 PREPARE_STACK (); 6458 EXPORT_REGS (); 6459 SEND_MESSAGE (METHOD_LITERAL (sel), n); 6460 IMPORT_REGS (); 6461 FETCH; 6462 6463#line 6464 "vm.inl" 6464#undef PREPARE_STACK 6465 } 6466 while (0); 6467 PUSH_OOP (_extra1); 6468 } 6469 NEXT_BC; 6470bc141: 6471 { 6472 OOP _stack0; 6473 OOP _extra1; 6474 _stack0 = STACK_AT (0); 6475 /* PREFETCH ( -- ) */ 6476 do 6477 { 6478#line 207 "vm.def" 6479 PREFETCH; 6480 LOCAL_COUNTER++; 6481 6482#line 6483 "vm.inl" 6483 } 6484 while (0); 6485 /* PUSH_INTEGER ( -- tos ) */ 6486 do 6487 { 6488 int n = arg; 6489#define tos _extra1 6490#line 812 "vm.def" 6491 tos = FROM_INT (n); 6492 6493#line 6494 "vm.inl" 6494#undef tos 6495 } 6496 while (0); 6497 /* GREATER_THAN_SPECIAL ( op1 op2 -- op ) */ 6498 do 6499 { 6500#define PREPARE_STACK() do { \ 6501 PUSH_OOP (_extra1); \ 6502 } while (0) 6503#define op1 _stack0 6504#define op2 _extra1 6505#define op _stack0 6506#line 261 "vm.def" 6507 PREPARE_STACK (); 6508 INTERP_BASIC_BOOL (op, op1, op2, >); 6509 EXPORT_REGS (); 6510 SEND_MESSAGE (_gst_builtin_selectors[GREATER_THAN_SPECIAL].symbol, 1); 6511 IMPORT_REGS (); 6512 FETCH; 6513 6514#line 6515 "vm.inl" 6515#undef PREPARE_STACK 6516#undef op1 6517#undef op2 6518#undef op 6519 } 6520 while (0); 6521 STACK_AT (0) = _stack0; 6522 } 6523 NEXT_BC; 6524bc142: 6525 { 6526 OOP _extra1; 6527 /* PREFETCH ( -- ) */ 6528 do 6529 { 6530#line 207 "vm.def" 6531 PREFETCH; 6532 LOCAL_COUNTER++; 6533 6534#line 6535 "vm.inl" 6535 } 6536 while (0); 6537 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 6538 do 6539 { 6540 int n = arg; 6541#define tos _extra1 6542#line 683 "vm.def" 6543 tos = METHOD_TEMPORARY (n); 6544 6545#line 6546 "vm.inl" 6546#undef tos 6547 } 6548 while (0); 6549 /* VALUE_SPECIAL ( rec | -- rec | ) */ 6550 do 6551 { 6552#define PREPARE_STACK() do { \ 6553 PUSH_OOP (_extra1); \ 6554 } while (0) 6555#define rec _extra1 6556#line 586 "vm.def" 6557 PREPARE_STACK (); 6558 EXPORT_REGS (); 6559 if (UNCOMMON (IS_INT (rec)) 6560 || UNCOMMON (OOP_CLASS (rec) != _gst_block_closure_class) 6561 || UNCOMMON (send_block_value (0, 0))) 6562 SEND_MESSAGE (_gst_builtin_selectors[VALUE_SPECIAL].symbol, 0); 6563 6564 IMPORT_REGS (); 6565 FETCH; 6566 6567#line 6568 "vm.inl" 6568#undef PREPARE_STACK 6569#undef rec 6570 } 6571 while (0); 6572 PUSH_OOP (_extra1); 6573 } 6574 NEXT_BC; 6575bc143: 6576 { 6577 OOP _stack0; 6578 OOP _extra1; 6579 _stack0 = STACK_AT (0); 6580 /* PREFETCH ( -- ) */ 6581 do 6582 { 6583#line 207 "vm.def" 6584 PREFETCH; 6585 LOCAL_COUNTER++; 6586 6587#line 6588 "vm.inl" 6588 } 6589 while (0); 6590 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 6591 do 6592 { 6593 int n = arg; 6594#define tos _extra1 6595#line 683 "vm.def" 6596 tos = METHOD_TEMPORARY (n); 6597 6598#line 6599 "vm.inl" 6599#undef tos 6600 } 6601 while (0); 6602 /* MINUS_SPECIAL ( op1 op2 -- op ) */ 6603 do 6604 { 6605#define PREPARE_STACK() do { \ 6606 PUSH_OOP (_extra1); \ 6607 } while (0) 6608#define op1 _stack0 6609#define op2 _extra1 6610#define op _stack0 6611#line 241 "vm.def" 6612 INTERP_BASIC_OP (op, op1, op2, 6613 sub_with_check (op1, op2, &overflow), 6614 farg1 - farg2); 6615 PREPARE_STACK (); 6616 EXPORT_REGS (); 6617 SEND_MESSAGE (_gst_builtin_selectors[MINUS_SPECIAL].symbol, 1); 6618 IMPORT_REGS (); 6619 FETCH; 6620 6621#line 6622 "vm.inl" 6622#undef PREPARE_STACK 6623#undef op1 6624#undef op2 6625#undef op 6626 } 6627 while (0); 6628 STACK_AT (0) = _stack0; 6629 } 6630 NEXT_BC; 6631bc144: 6632 { 6633 OOP _extra1; 6634 /* PREFETCH ( -- ) */ 6635 do 6636 { 6637#line 207 "vm.def" 6638 PREFETCH; 6639 LOCAL_COUNTER++; 6640 6641#line 6642 "vm.inl" 6642 } 6643 while (0); 6644 /* PUSH_LIT_CONSTANT ( -- tos ) */ 6645 do 6646 { 6647 int n = arg; 6648#define tos _extra1 6649#line 820 "vm.def" 6650 tos = METHOD_LITERAL (n); 6651 6652#line 6653 "vm.inl" 6653#undef tos 6654 } 6655 while (0); 6656 /* SEND ( -- ) */ 6657 do 6658 { 6659 int sel = 3; 6660 int n = 1; 6661#define PREPARE_STACK() do { \ 6662 PUSH_OOP (_extra1); \ 6663 } while (0) 6664#line 643 "vm.def" 6665 PREPARE_STACK (); 6666 EXPORT_REGS (); 6667 SEND_MESSAGE (METHOD_LITERAL (sel), n); 6668 IMPORT_REGS (); 6669 FETCH; 6670 6671#line 6672 "vm.inl" 6672#undef PREPARE_STACK 6673 } 6674 while (0); 6675 PUSH_OOP (_extra1); 6676 } 6677 NEXT_BC; 6678bc145: 6679 { 6680 OOP _stack0; 6681 OOP _extra1; 6682 _stack0 = STACK_AT (0); 6683 /* PREFETCH ( -- ) */ 6684 do 6685 { 6686#line 207 "vm.def" 6687 PREFETCH; 6688 LOCAL_COUNTER++; 6689 6690#line 6691 "vm.inl" 6691 } 6692 while (0); 6693 /* PUSH_SPECIAL ( -- tos ) */ 6694 do 6695 { 6696 int n = 0; 6697#define tos _extra1 6698#line 816 "vm.def" 6699 tos = _gst_nil_oop + (n - NIL_INDEX); 6700 6701#line 6702 "vm.inl" 6702#undef tos 6703 } 6704 while (0); 6705 /* SAME_OBJECT_SPECIAL ( op1 op2 -- op ) */ 6706 do 6707 { 6708#define op1 _stack0 6709#define op2 _extra1 6710#define op _stack0 6711#line 610 "vm.def" 6712 /* DO_JUMP_LOOKAHEAD (op1 == op2); */ 6713 op = (op1 == op2) ? _gst_true_oop : _gst_false_oop; 6714 6715#line 6716 "vm.inl" 6716#undef op1 6717#undef op2 6718#undef op 6719 } 6720 while (0); 6721 /* POP_JUMP_FALSE ( tos -- ) */ 6722 do 6723 { 6724 int n = arg; 6725#define PREPARE_STACK() do { \ 6726 STACK_AT (0) = _stack0; \ 6727 } while (0) 6728#define tos _stack0 6729#line 774 "vm.def" 6730 if UNCOMMON (tos == _gst_false_oop) 6731 { 6732 PREPARE_STACK (); 6733 POP_N_OOPS(1); 6734 ip += n; 6735 FETCH; 6736 } 6737 else if UNCOMMON (tos != _gst_true_oop) 6738 { 6739 ip += n; 6740 PREPARE_STACK (); 6741 EXPORT_REGS(); 6742 SEND_MESSAGE(_gst_must_be_boolean_symbol, 0); 6743 IMPORT_REGS(); 6744 FETCH; 6745 } 6746 6747#line 6748 "vm.inl" 6748#undef PREPARE_STACK 6749#undef tos 6750 } 6751 while (0); 6752 POP_N_OOPS (1); 6753 } 6754 NEXT_BC; 6755bc146: 6756 { 6757 OOP _stack0; 6758 _stack0 = STACK_AT (0); 6759 /* PREFETCH ( -- ) */ 6760 do 6761 { 6762#line 207 "vm.def" 6763 PREFETCH; 6764 LOCAL_COUNTER++; 6765 6766#line 6767 "vm.inl" 6767 } 6768 while (0); 6769 /* STORE_TEMPORARY_VARIABLE ( tos | -- tos | ) */ 6770 do 6771 { 6772 int n = 2; 6773#define tos _stack0 6774#line 722 "vm.def" 6775 STORE_METHOD_TEMPORARY (n, tos); 6776 6777#line 6778 "vm.inl" 6778#undef tos 6779 } 6780 while (0); 6781 /* LINE_NUMBER_BYTECODE ( -- ) */ 6782 do 6783 { 6784#line 890 "vm.def" 6785 6786#line 6787 "vm.inl" 6787 } 6788 while (0); 6789 /* POP_STACK_TOP ( tos -- ) */ 6790 do 6791 { 6792#define tos _stack0 6793#line 828 "vm.def" 6794 6795#line 6796 "vm.inl" 6796#undef tos 6797 } 6798 while (0); 6799 POP_N_OOPS (1); 6800 } 6801 NEXT_BC; 6802bc147: 6803 { 6804 OOP _stack0, _stack1; 6805 _stack1 = STACK_AT (1); 6806 _stack0 = STACK_AT (0); 6807 /* PREFETCH ( -- ) */ 6808 do 6809 { 6810#line 207 "vm.def" 6811 PREFETCH; 6812 LOCAL_COUNTER++; 6813 6814#line 6815 "vm.inl" 6815 } 6816 while (0); 6817 /* SAME_OBJECT_SPECIAL ( op1 op2 -- op ) */ 6818 do 6819 { 6820#define op1 _stack1 6821#define op2 _stack0 6822#define op _stack1 6823#line 610 "vm.def" 6824 /* DO_JUMP_LOOKAHEAD (op1 == op2); */ 6825 op = (op1 == op2) ? _gst_true_oop : _gst_false_oop; 6826 6827#line 6828 "vm.inl" 6828#undef op1 6829#undef op2 6830#undef op 6831 } 6832 while (0); 6833 /* POP_JUMP_TRUE ( tos -- ) */ 6834 do 6835 { 6836 int n = arg; 6837#define PREPARE_STACK() do { \ 6838 STACK_AT (1) = _stack1; \ 6839 POP_N_OOPS (1); \ 6840 } while (0) 6841#define tos _stack1 6842#line 793 "vm.def" 6843 if UNCOMMON (tos == _gst_true_oop) 6844 { 6845 PREPARE_STACK (); 6846 POP_N_OOPS(1); 6847 ip += n; 6848 FETCH; 6849 } 6850 else if UNCOMMON (tos != _gst_false_oop) 6851 { 6852 ip += n; 6853 PREPARE_STACK (); 6854 EXPORT_REGS(); 6855 SEND_MESSAGE(_gst_must_be_boolean_symbol, 0); 6856 IMPORT_REGS(); 6857 FETCH; 6858 } 6859 6860#line 6861 "vm.inl" 6861#undef PREPARE_STACK 6862#undef tos 6863 } 6864 while (0); 6865 POP_N_OOPS (2); 6866 } 6867 NEXT_BC; 6868bc148: 6869 { 6870 OOP _stack0; 6871 OOP _extra1; 6872 _stack0 = STACK_AT (0); 6873 /* PREFETCH ( -- ) */ 6874 do 6875 { 6876#line 207 "vm.def" 6877 PREFETCH; 6878 LOCAL_COUNTER++; 6879 6880#line 6881 "vm.inl" 6881 } 6882 while (0); 6883 /* PUSH_INTEGER ( -- tos ) */ 6884 do 6885 { 6886 int n = arg; 6887#define tos _extra1 6888#line 812 "vm.def" 6889 tos = FROM_INT (n); 6890 6891#line 6892 "vm.inl" 6892#undef tos 6893 } 6894 while (0); 6895 /* TIMES_SPECIAL ( op1 op2 -- op ) */ 6896 do 6897 { 6898#define PREPARE_STACK() do { \ 6899 PUSH_OOP (_extra1); \ 6900 } while (0) 6901#define op1 _stack0 6902#define op2 _extra1 6903#define op _stack0 6904#line 306 "vm.def" 6905 INTERP_BASIC_OP (op, op1, op2, 6906 mul_with_check (op1, op2, &overflow), 6907 farg1 * farg2); 6908 PREPARE_STACK (); 6909 EXPORT_REGS (); 6910 SEND_MESSAGE (_gst_builtin_selectors[TIMES_SPECIAL].symbol, 1); 6911 IMPORT_REGS (); 6912 FETCH; 6913 6914#line 6915 "vm.inl" 6915#undef PREPARE_STACK 6916#undef op1 6917#undef op2 6918#undef op 6919 } 6920 while (0); 6921 STACK_AT (0) = _stack0; 6922 } 6923 NEXT_BC; 6924bc149: 6925 { 6926 OOP _extra1; 6927 /* PREFETCH ( -- ) */ 6928 do 6929 { 6930#line 207 "vm.def" 6931 PREFETCH; 6932 LOCAL_COUNTER++; 6933 6934#line 6935 "vm.inl" 6935 } 6936 while (0); 6937 /* LINE_NUMBER_BYTECODE ( -- ) */ 6938 do 6939 { 6940#line 890 "vm.def" 6941 6942#line 6943 "vm.inl" 6943 } 6944 while (0); 6945 /* PUSH_RECEIVER_VARIABLE ( -- tos ) */ 6946 do 6947 { 6948 int n = 2; 6949#define tos _extra1 6950#line 718 "vm.def" 6951 tos = RECEIVER_VARIABLE (n); 6952 6953#line 6954 "vm.inl" 6954#undef tos 6955 } 6956 while (0); 6957 PUSH_OOP (_extra1); 6958 } 6959 NEXT_BC; 6960bc150: 6961 { 6962 OOP _stack0; 6963 OOP _extra1; 6964 _stack0 = STACK_AT (0); 6965 /* PREFETCH ( -- ) */ 6966 do 6967 { 6968#line 207 "vm.def" 6969 PREFETCH; 6970 LOCAL_COUNTER++; 6971 6972#line 6973 "vm.inl" 6973 } 6974 while (0); 6975 /* PUSH_INTEGER ( -- tos ) */ 6976 do 6977 { 6978 int n = arg; 6979#define tos _extra1 6980#line 812 "vm.def" 6981 tos = FROM_INT (n); 6982 6983#line 6984 "vm.inl" 6984#undef tos 6985 } 6986 while (0); 6987 /* LESS_THAN_SPECIAL ( op1 op2 -- op ) */ 6988 do 6989 { 6990#define PREPARE_STACK() do { \ 6991 PUSH_OOP (_extra1); \ 6992 } while (0) 6993#define op1 _stack0 6994#define op2 _extra1 6995#define op _stack0 6996#line 252 "vm.def" 6997 PREPARE_STACK (); 6998 INTERP_BASIC_BOOL (op, op1, op2, <); 6999 EXPORT_REGS (); 7000 SEND_MESSAGE (_gst_builtin_selectors[LESS_THAN_SPECIAL].symbol, 1); 7001 IMPORT_REGS (); 7002 FETCH; 7003 7004#line 7005 "vm.inl" 7005#undef PREPARE_STACK 7006#undef op1 7007#undef op2 7008#undef op 7009 } 7010 while (0); 7011 STACK_AT (0) = _stack0; 7012 } 7013 NEXT_BC; 7014bc151: 7015 { 7016 OOP _stack0, _stack1; 7017 OOP _extra1; 7018 _stack1 = STACK_AT (1); 7019 _stack0 = STACK_AT (0); 7020 /* PREFETCH ( -- ) */ 7021 do 7022 { 7023#line 207 "vm.def" 7024 PREFETCH; 7025 LOCAL_COUNTER++; 7026 7027#line 7028 "vm.inl" 7028 } 7029 while (0); 7030 /* PUSH_LIT_CONSTANT ( -- tos ) */ 7031 do 7032 { 7033 int n = arg; 7034#define tos _extra1 7035#line 820 "vm.def" 7036 tos = METHOD_LITERAL (n); 7037 7038#line 7039 "vm.inl" 7039#undef tos 7040 } 7041 while (0); 7042 /* AT_PUT_SPECIAL ( rec idx val -- res ) */ 7043 do 7044 { 7045#define PREPARE_STACK() do { \ 7046 PUSH_OOP (_extra1); \ 7047 } while (0) 7048#define rec _stack1 7049#define idx _stack0 7050#define val _extra1 7051#define res _stack1 7052#line 477 "vm.def" 7053 OOP classOOP; 7054 PREPARE_STACK (); 7055 EXPORT_REGS (); 7056 if UNCOMMON (IS_INT (rec)) 7057 { 7058 SEND_MESSAGE (_gst_builtin_selectors[AT_PUT_SPECIAL].symbol, 2); 7059 IMPORT_REGS (); 7060 FETCH; 7061 } 7062 7063 if COMMON (at_put_cache_class == (classOOP = OOP_CLASS (rec)) 7064 && !cached_index_oop_put_primitive (rec, idx, val, at_put_cache_spec)) 7065 { 7066 IMPORT_REGS (); 7067 NEXT_BC; 7068 } 7069 7070 /* Not the same class that is in the cache, or the primitive failed -- 7071 send the message, and modify the cache if the send is resolved to 7072 a primitive. */ 7073 last_primitive = 0; 7074 SEND_MESSAGE (_gst_builtin_selectors[AT_PUT_SPECIAL].symbol, 2); 7075 IMPORT_REGS (); 7076 if (_gst_primitive_table[last_primitive].id == 61) 7077 { 7078 at_put_cache_spec = CLASS_INSTANCE_SPEC (classOOP); 7079 at_put_cache_class = classOOP; 7080 NEXT_BC; 7081 } 7082 FETCH; 7083 7084#line 7085 "vm.inl" 7085#undef PREPARE_STACK 7086#undef rec 7087#undef idx 7088#undef val 7089#undef res 7090 } 7091 while (0); 7092 STACK_AT (1) = _stack1; 7093 POP_N_OOPS (1); 7094 } 7095 NEXT_BC; 7096bc152: 7097 { 7098 OOP _extra1; 7099 /* PREFETCH ( -- ) */ 7100 do 7101 { 7102#line 207 "vm.def" 7103 PREFETCH; 7104 LOCAL_COUNTER++; 7105 7106#line 7107 "vm.inl" 7107 } 7108 while (0); 7109 /* PUSH_OUTER_TEMP ( -- tos ) */ 7110 do 7111 { 7112 int n = arg; 7113 int scopes = 2; 7114#define tos _extra1 7115#line 687 "vm.def" 7116 OOP contextOOP; 7117 gst_block_context context; 7118 7119 context = (gst_block_context) OOP_TO_OBJ (_gst_this_context_oop); 7120 do 7121 { 7122 contextOOP = context->outerContext; 7123 context = (gst_block_context) OOP_TO_OBJ (contextOOP); 7124 } 7125 while (--scopes); 7126 7127 tos = context->contextStack[n]; 7128 7129#line 7130 "vm.inl" 7130#undef tos 7131 } 7132 while (0); 7133 PUSH_OOP (_extra1); 7134 } 7135 NEXT_BC; 7136bc153: 7137 { 7138 OOP _extra1, _extra2; 7139 /* PREFETCH ( -- ) */ 7140 do 7141 { 7142#line 207 "vm.def" 7143 PREFETCH; 7144 LOCAL_COUNTER++; 7145 7146#line 7147 "vm.inl" 7147 } 7148 while (0); 7149 /* LINE_NUMBER_BYTECODE ( -- ) */ 7150 do 7151 { 7152#line 890 "vm.def" 7153 7154#line 7155 "vm.inl" 7155 } 7156 while (0); 7157 /* PUSH_SELF ( -- tos ) */ 7158 do 7159 { 7160#define tos _extra1 7161#line 893 "vm.def" 7162 tos = _gst_self; 7163 7164#line 7165 "vm.inl" 7165#undef tos 7166 } 7167 while (0); 7168 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 7169 do 7170 { 7171 int n = 0; 7172#define tos _extra2 7173#line 683 "vm.def" 7174 tos = METHOD_TEMPORARY (n); 7175 7176#line 7177 "vm.inl" 7177#undef tos 7178 } 7179 while (0); 7180 /* SEND ( -- ) */ 7181 do 7182 { 7183 int sel = 0; 7184 int n = 1; 7185#define PREPARE_STACK() do { \ 7186 PUSH_OOP (_extra1); \ 7187 PUSH_OOP (_extra2); \ 7188 } while (0) 7189#line 643 "vm.def" 7190 PREPARE_STACK (); 7191 EXPORT_REGS (); 7192 SEND_MESSAGE (METHOD_LITERAL (sel), n); 7193 IMPORT_REGS (); 7194 FETCH; 7195 7196#line 7197 "vm.inl" 7197#undef PREPARE_STACK 7198 } 7199 while (0); 7200 PUSH_OOP (_extra1); 7201 PUSH_OOP (_extra2); 7202 } 7203 NEXT_BC; 7204bc154: 7205 { 7206 OOP _extra1, _extra2; 7207 /* PREFETCH ( -- ) */ 7208 do 7209 { 7210#line 207 "vm.def" 7211 PREFETCH; 7212 LOCAL_COUNTER++; 7213 7214#line 7215 "vm.inl" 7215 } 7216 while (0); 7217 /* PUSH_SELF ( -- tos ) */ 7218 do 7219 { 7220#define tos _extra1 7221#line 893 "vm.def" 7222 tos = _gst_self; 7223 7224#line 7225 "vm.inl" 7225#undef tos 7226 } 7227 while (0); 7228 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 7229 do 7230 { 7231 int n = 0; 7232#define tos _extra2 7233#line 683 "vm.def" 7234 tos = METHOD_TEMPORARY (n); 7235 7236#line 7237 "vm.inl" 7237#undef tos 7238 } 7239 while (0); 7240 /* SEND ( -- ) */ 7241 do 7242 { 7243 int sel = arg; 7244 int n = 1; 7245#define PREPARE_STACK() do { \ 7246 PUSH_OOP (_extra1); \ 7247 PUSH_OOP (_extra2); \ 7248 } while (0) 7249#line 643 "vm.def" 7250 PREPARE_STACK (); 7251 EXPORT_REGS (); 7252 SEND_MESSAGE (METHOD_LITERAL (sel), n); 7253 IMPORT_REGS (); 7254 FETCH; 7255 7256#line 7257 "vm.inl" 7257#undef PREPARE_STACK 7258 } 7259 while (0); 7260 PUSH_OOP (_extra1); 7261 PUSH_OOP (_extra2); 7262 } 7263 NEXT_BC; 7264bc155: 7265 { 7266 OOP _extra1; 7267 /* PREFETCH ( -- ) */ 7268 do 7269 { 7270#line 207 "vm.def" 7271 PREFETCH; 7272 LOCAL_COUNTER++; 7273 7274#line 7275 "vm.inl" 7275 } 7276 while (0); 7277 /* LINE_NUMBER_BYTECODE ( -- ) */ 7278 do 7279 { 7280#line 890 "vm.def" 7281 7282#line 7283 "vm.inl" 7283 } 7284 while (0); 7285 /* PUSH_SELF ( -- tos ) */ 7286 do 7287 { 7288#define tos _extra1 7289#line 893 "vm.def" 7290 tos = _gst_self; 7291 7292#line 7293 "vm.inl" 7293#undef tos 7294 } 7295 while (0); 7296 /* SEND_IMMEDIATE ( -- ) */ 7297 do 7298 { 7299 int n = 40; 7300#define PREPARE_STACK() do { \ 7301 PUSH_OOP (_extra1); \ 7302 } while (0) 7303#line 662 "vm.def" 7304 const struct builtin_selector *bs = &_gst_builtin_selectors[n]; 7305 PREPARE_STACK (); 7306 EXPORT_REGS (); 7307 SEND_MESSAGE (bs->symbol, bs->numArgs); 7308 IMPORT_REGS (); 7309 FETCH; 7310 7311#line 7312 "vm.inl" 7312#undef PREPARE_STACK 7313 } 7314 while (0); 7315 PUSH_OOP (_extra1); 7316 } 7317 NEXT_BC; 7318bc156: 7319 { 7320 OOP _extra1, _extra2; 7321 /* PREFETCH ( -- ) */ 7322 do 7323 { 7324#line 207 "vm.def" 7325 PREFETCH; 7326 LOCAL_COUNTER++; 7327 7328#line 7329 "vm.inl" 7329 } 7330 while (0); 7331 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 7332 do 7333 { 7334 int n = arg; 7335#define tos _extra1 7336#line 683 "vm.def" 7337 tos = METHOD_TEMPORARY (n); 7338 7339#line 7340 "vm.inl" 7340#undef tos 7341 } 7342 while (0); 7343 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 7344 do 7345 { 7346 int n = 3; 7347#define tos _extra2 7348#line 683 "vm.def" 7349 tos = METHOD_TEMPORARY (n); 7350 7351#line 7352 "vm.inl" 7352#undef tos 7353 } 7354 while (0); 7355 PUSH_OOP (_extra1); 7356 PUSH_OOP (_extra2); 7357 } 7358 NEXT_BC; 7359bc157: 7360 { 7361 OOP _stack0; 7362 _stack0 = STACK_AT (0); 7363 /* PREFETCH ( -- ) */ 7364 do 7365 { 7366#line 207 "vm.def" 7367 PREFETCH; 7368 LOCAL_COUNTER++; 7369 7370#line 7371 "vm.inl" 7371 } 7372 while (0); 7373 /* STORE_TEMPORARY_VARIABLE ( tos | -- tos | ) */ 7374 do 7375 { 7376 int n = 1; 7377#define tos _stack0 7378#line 722 "vm.def" 7379 STORE_METHOD_TEMPORARY (n, tos); 7380 7381#line 7382 "vm.inl" 7382#undef tos 7383 } 7384 while (0); 7385 /* LINE_NUMBER_BYTECODE ( -- ) */ 7386 do 7387 { 7388#line 890 "vm.def" 7389 7390#line 7391 "vm.inl" 7391 } 7392 while (0); 7393 } 7394 NEXT_BC; 7395bc158: 7396 { 7397 OOP _extra1; 7398 /* PREFETCH ( -- ) */ 7399 do 7400 { 7401#line 207 "vm.def" 7402 PREFETCH; 7403 LOCAL_COUNTER++; 7404 7405#line 7406 "vm.inl" 7406 } 7407 while (0); 7408 /* LINE_NUMBER_BYTECODE ( -- ) */ 7409 do 7410 { 7411#line 890 "vm.def" 7412 7413#line 7414 "vm.inl" 7414 } 7415 while (0); 7416 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 7417 do 7418 { 7419 int n = 0; 7420#define tos _extra1 7421#line 683 "vm.def" 7422 tos = METHOD_TEMPORARY (n); 7423 7424#line 7425 "vm.inl" 7425#undef tos 7426 } 7427 while (0); 7428 /* SEND ( -- ) */ 7429 do 7430 { 7431 int sel = 0; 7432 int n = 0; 7433#define PREPARE_STACK() do { \ 7434 PUSH_OOP (_extra1); \ 7435 } while (0) 7436#line 643 "vm.def" 7437 PREPARE_STACK (); 7438 EXPORT_REGS (); 7439 SEND_MESSAGE (METHOD_LITERAL (sel), n); 7440 IMPORT_REGS (); 7441 FETCH; 7442 7443#line 7444 "vm.inl" 7444#undef PREPARE_STACK 7445 } 7446 while (0); 7447 PUSH_OOP (_extra1); 7448 } 7449 NEXT_BC; 7450bc159: 7451 { 7452 OOP _stack0; 7453 OOP _extra1; 7454 _stack0 = STACK_AT (0); 7455 /* PREFETCH ( -- ) */ 7456 do 7457 { 7458#line 207 "vm.def" 7459 PREFETCH; 7460 LOCAL_COUNTER++; 7461 7462#line 7463 "vm.inl" 7463 } 7464 while (0); 7465 /* PUSH_INTEGER ( -- tos ) */ 7466 do 7467 { 7468 int n = arg; 7469#define tos _extra1 7470#line 812 "vm.def" 7471 tos = FROM_INT (n); 7472 7473#line 7474 "vm.inl" 7474#undef tos 7475 } 7476 while (0); 7477 /* BIT_AND_SPECIAL ( op1 op2 -- op ) */ 7478 do 7479 { 7480#define PREPARE_STACK() do { \ 7481 PUSH_OOP (_extra1); \ 7482 } while (0) 7483#define op1 _stack0 7484#define op2 _extra1 7485#define op _stack0 7486#line 418 "vm.def" 7487 op = tagged_and (op1, op2); 7488 if COMMON (IS_INT (op)) 7489 break; 7490 7491 PREPARE_STACK (); 7492 EXPORT_REGS (); 7493 SEND_MESSAGE (_gst_builtin_selectors[BIT_AND_SPECIAL].symbol, 1); 7494 IMPORT_REGS (); 7495 FETCH; 7496 7497#line 7498 "vm.inl" 7498#undef PREPARE_STACK 7499#undef op1 7500#undef op2 7501#undef op 7502 } 7503 while (0); 7504 STACK_AT (0) = _stack0; 7505 } 7506 NEXT_BC; 7507bc160: 7508 { 7509 OOP _extra1; 7510 /* PREFETCH ( -- ) */ 7511 do 7512 { 7513#line 207 "vm.def" 7514 PREFETCH; 7515 LOCAL_COUNTER++; 7516 7517#line 7518 "vm.inl" 7518 } 7519 while (0); 7520 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 7521 do 7522 { 7523 int n = 2; 7524#define tos _extra1 7525#line 683 "vm.def" 7526 tos = METHOD_TEMPORARY (n); 7527 7528#line 7529 "vm.inl" 7529#undef tos 7530 } 7531 while (0); 7532 /* SEND ( -- ) */ 7533 do 7534 { 7535 int sel = arg; 7536 int n = 0; 7537#define PREPARE_STACK() do { \ 7538 PUSH_OOP (_extra1); \ 7539 } while (0) 7540#line 643 "vm.def" 7541 PREPARE_STACK (); 7542 EXPORT_REGS (); 7543 SEND_MESSAGE (METHOD_LITERAL (sel), n); 7544 IMPORT_REGS (); 7545 FETCH; 7546 7547#line 7548 "vm.inl" 7548#undef PREPARE_STACK 7549 } 7550 while (0); 7551 PUSH_OOP (_extra1); 7552 } 7553 NEXT_BC; 7554bc161: 7555 { 7556 OOP _extra1, _extra2; 7557 /* PREFETCH ( -- ) */ 7558 do 7559 { 7560#line 207 "vm.def" 7561 PREFETCH; 7562 LOCAL_COUNTER++; 7563 7564#line 7565 "vm.inl" 7565 } 7566 while (0); 7567 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 7568 do 7569 { 7570 int n = 0; 7571#define tos _extra1 7572#line 683 "vm.def" 7573 tos = METHOD_TEMPORARY (n); 7574 7575#line 7576 "vm.inl" 7576#undef tos 7577 } 7578 while (0); 7579 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 7580 do 7581 { 7582 int n = 1; 7583#define tos _extra2 7584#line 683 "vm.def" 7585 tos = METHOD_TEMPORARY (n); 7586 7587#line 7588 "vm.inl" 7588#undef tos 7589 } 7590 while (0); 7591 /* SEND ( -- ) */ 7592 do 7593 { 7594 int sel = arg >> 8; 7595 int n = arg & 255; 7596#define PREPARE_STACK() do { \ 7597 PUSH_OOP (_extra1); \ 7598 PUSH_OOP (_extra2); \ 7599 } while (0) 7600#line 643 "vm.def" 7601 PREPARE_STACK (); 7602 EXPORT_REGS (); 7603 SEND_MESSAGE (METHOD_LITERAL (sel), n); 7604 IMPORT_REGS (); 7605 FETCH; 7606 7607#line 7608 "vm.inl" 7608#undef PREPARE_STACK 7609 } 7610 while (0); 7611 PUSH_OOP (_extra1); 7612 PUSH_OOP (_extra2); 7613 } 7614 NEXT_BC; 7615bc162: 7616 { 7617 OOP _extra1, _extra2; 7618 /* PREFETCH ( -- ) */ 7619 do 7620 { 7621#line 207 "vm.def" 7622 PREFETCH; 7623 LOCAL_COUNTER++; 7624 7625#line 7626 "vm.inl" 7626 } 7627 while (0); 7628 /* LINE_NUMBER_BYTECODE ( -- ) */ 7629 do 7630 { 7631#line 890 "vm.def" 7632 7633#line 7634 "vm.inl" 7634 } 7635 while (0); 7636 /* PUSH_SELF ( -- tos ) */ 7637 do 7638 { 7639#define tos _extra1 7640#line 893 "vm.def" 7641 tos = _gst_self; 7642 7643#line 7644 "vm.inl" 7644#undef tos 7645 } 7646 while (0); 7647 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 7648 do 7649 { 7650 int n = 0; 7651#define tos _extra2 7652#line 683 "vm.def" 7653 tos = METHOD_TEMPORARY (n); 7654 7655#line 7656 "vm.inl" 7656#undef tos 7657 } 7658 while (0); 7659 PUSH_OOP (_extra1); 7660 PUSH_OOP (_extra2); 7661 } 7662 NEXT_BC; 7663bc163: 7664 { 7665 OOP _extra1; 7666 /* PREFETCH ( -- ) */ 7667 do 7668 { 7669#line 207 "vm.def" 7670 PREFETCH; 7671 LOCAL_COUNTER++; 7672 7673#line 7674 "vm.inl" 7674 } 7675 while (0); 7676 /* LINE_NUMBER_BYTECODE ( -- ) */ 7677 do 7678 { 7679#line 890 "vm.def" 7680 7681#line 7682 "vm.inl" 7682 } 7683 while (0); 7684 /* PUSH_RECEIVER_VARIABLE ( -- tos ) */ 7685 do 7686 { 7687 int n = 3; 7688#define tos _extra1 7689#line 718 "vm.def" 7690 tos = RECEIVER_VARIABLE (n); 7691 7692#line 7693 "vm.inl" 7693#undef tos 7694 } 7695 while (0); 7696 PUSH_OOP (_extra1); 7697 } 7698 NEXT_BC; 7699bc164: 7700 { 7701 OOP _extra1; 7702 /* PREFETCH ( -- ) */ 7703 do 7704 { 7705#line 207 "vm.def" 7706 PREFETCH; 7707 LOCAL_COUNTER++; 7708 7709#line 7710 "vm.inl" 7710 } 7711 while (0); 7712 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 7713 do 7714 { 7715 int n = 2; 7716#define tos _extra1 7717#line 683 "vm.def" 7718 tos = METHOD_TEMPORARY (n); 7719 7720#line 7721 "vm.inl" 7721#undef tos 7722 } 7723 while (0); 7724 /* SEND ( -- ) */ 7725 do 7726 { 7727 int sel = arg; 7728 int n = 1; 7729#define PREPARE_STACK() do { \ 7730 PUSH_OOP (_extra1); \ 7731 } while (0) 7732#line 643 "vm.def" 7733 PREPARE_STACK (); 7734 EXPORT_REGS (); 7735 SEND_MESSAGE (METHOD_LITERAL (sel), n); 7736 IMPORT_REGS (); 7737 FETCH; 7738 7739#line 7740 "vm.inl" 7740#undef PREPARE_STACK 7741 } 7742 while (0); 7743 PUSH_OOP (_extra1); 7744 } 7745 NEXT_BC; 7746bc165: 7747 { 7748 OOP _stack0; 7749 _stack0 = STACK_AT (0); 7750 /* PREFETCH ( -- ) */ 7751 do 7752 { 7753#line 207 "vm.def" 7754 PREFETCH; 7755 LOCAL_COUNTER++; 7756 7757#line 7758 "vm.inl" 7758 } 7759 while (0); 7760 /* NOT_NIL_SPECIAL ( rec -- val ) */ 7761 do 7762 { 7763#define rec _stack0 7764#define val _stack0 7765#line 581 "vm.def" 7766 /* DO_JUMP_LOOKAHEAD (rec != _gst_nil_oop); */ 7767 val = rec != _gst_nil_oop ? _gst_true_oop : _gst_false_oop; 7768 7769#line 7770 "vm.inl" 7770#undef rec 7771#undef val 7772 } 7773 while (0); 7774 /* POP_JUMP_FALSE ( tos -- ) */ 7775 do 7776 { 7777 int n = arg; 7778#define PREPARE_STACK() do { \ 7779 STACK_AT (0) = _stack0; \ 7780 } while (0) 7781#define tos _stack0 7782#line 774 "vm.def" 7783 if UNCOMMON (tos == _gst_false_oop) 7784 { 7785 PREPARE_STACK (); 7786 POP_N_OOPS(1); 7787 ip += n; 7788 FETCH; 7789 } 7790 else if UNCOMMON (tos != _gst_true_oop) 7791 { 7792 ip += n; 7793 PREPARE_STACK (); 7794 EXPORT_REGS(); 7795 SEND_MESSAGE(_gst_must_be_boolean_symbol, 0); 7796 IMPORT_REGS(); 7797 FETCH; 7798 } 7799 7800#line 7801 "vm.inl" 7801#undef PREPARE_STACK 7802#undef tos 7803 } 7804 while (0); 7805 POP_N_OOPS (1); 7806 } 7807 NEXT_BC; 7808bc166: 7809 { 7810 OOP _stack0; 7811 _stack0 = STACK_AT (0); 7812 /* PREFETCH ( -- ) */ 7813 do 7814 { 7815#line 207 "vm.def" 7816 PREFETCH; 7817 LOCAL_COUNTER++; 7818 7819#line 7820 "vm.inl" 7820 } 7821 while (0); 7822 /* STORE_TEMPORARY_VARIABLE ( tos | -- tos | ) */ 7823 do 7824 { 7825 int n = 2; 7826#define tos _stack0 7827#line 722 "vm.def" 7828 STORE_METHOD_TEMPORARY (n, tos); 7829 7830#line 7831 "vm.inl" 7831#undef tos 7832 } 7833 while (0); 7834 /* LINE_NUMBER_BYTECODE ( -- ) */ 7835 do 7836 { 7837#line 890 "vm.def" 7838 7839#line 7840 "vm.inl" 7840 } 7841 while (0); 7842 } 7843 NEXT_BC; 7844bc167: 7845 { 7846 OOP _stack0; 7847 _stack0 = STACK_AT (0); 7848 /* PREFETCH ( -- ) */ 7849 do 7850 { 7851#line 207 "vm.def" 7852 PREFETCH; 7853 LOCAL_COUNTER++; 7854 7855#line 7856 "vm.inl" 7856 } 7857 while (0); 7858 /* STORE_TEMPORARY_VARIABLE ( tos | -- tos | ) */ 7859 do 7860 { 7861 int n = 3; 7862#define tos _stack0 7863#line 722 "vm.def" 7864 STORE_METHOD_TEMPORARY (n, tos); 7865 7866#line 7867 "vm.inl" 7867#undef tos 7868 } 7869 while (0); 7870 /* LINE_NUMBER_BYTECODE ( -- ) */ 7871 do 7872 { 7873#line 890 "vm.def" 7874 7875#line 7876 "vm.inl" 7876 } 7877 while (0); 7878 /* POP_STACK_TOP ( tos -- ) */ 7879 do 7880 { 7881#define tos _stack0 7882#line 828 "vm.def" 7883 7884#line 7885 "vm.inl" 7885#undef tos 7886 } 7887 while (0); 7888 POP_N_OOPS (1); 7889 } 7890 NEXT_BC; 7891bc168: 7892 { 7893 OOP _extra1; 7894 /* PREFETCH ( -- ) */ 7895 do 7896 { 7897#line 207 "vm.def" 7898 PREFETCH; 7899 LOCAL_COUNTER++; 7900 7901#line 7902 "vm.inl" 7902 } 7903 while (0); 7904 /* PUSH_LIT_CONSTANT ( -- tos ) */ 7905 do 7906 { 7907 int n = 1; 7908#define tos _extra1 7909#line 820 "vm.def" 7910 tos = METHOD_LITERAL (n); 7911 7912#line 7913 "vm.inl" 7913#undef tos 7914 } 7915 while (0); 7916 /* SEND_IMMEDIATE ( -- ) */ 7917 do 7918 { 7919 int n = arg; 7920#define PREPARE_STACK() do { \ 7921 PUSH_OOP (_extra1); \ 7922 } while (0) 7923#line 662 "vm.def" 7924 const struct builtin_selector *bs = &_gst_builtin_selectors[n]; 7925 PREPARE_STACK (); 7926 EXPORT_REGS (); 7927 SEND_MESSAGE (bs->symbol, bs->numArgs); 7928 IMPORT_REGS (); 7929 FETCH; 7930 7931#line 7932 "vm.inl" 7932#undef PREPARE_STACK 7933 } 7934 while (0); 7935 PUSH_OOP (_extra1); 7936 } 7937 NEXT_BC; 7938bc169: 7939 { 7940 OOP _stack0; 7941 OOP _extra1; 7942 _stack0 = STACK_AT (0); 7943 /* PREFETCH ( -- ) */ 7944 do 7945 { 7946#line 207 "vm.def" 7947 PREFETCH; 7948 LOCAL_COUNTER++; 7949 7950#line 7951 "vm.inl" 7951 } 7952 while (0); 7953 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 7954 do 7955 { 7956 int n = arg; 7957#define tos _extra1 7958#line 683 "vm.def" 7959 tos = METHOD_TEMPORARY (n); 7960 7961#line 7962 "vm.inl" 7962#undef tos 7963 } 7964 while (0); 7965 /* EQUAL_SPECIAL ( op1 op2 -- op ) */ 7966 do 7967 { 7968#define PREPARE_STACK() do { \ 7969 PUSH_OOP (_extra1); \ 7970 } while (0) 7971#define op1 _stack0 7972#define op2 _extra1 7973#define op _stack0 7974#line 288 "vm.def" 7975 PREPARE_STACK (); 7976 INTERP_BASIC_BOOL (op, op1, op2, ==); 7977 EXPORT_REGS (); 7978 SEND_MESSAGE (_gst_builtin_selectors[EQUAL_SPECIAL].symbol, 1); 7979 IMPORT_REGS (); 7980 FETCH; 7981 7982#line 7983 "vm.inl" 7983#undef PREPARE_STACK 7984#undef op1 7985#undef op2 7986#undef op 7987 } 7988 while (0); 7989 STACK_AT (0) = _stack0; 7990 } 7991 NEXT_BC; 7992bc170: 7993 { 7994 OOP _stack0, _stack1; 7995 OOP _extra1, _extra2; 7996 _stack1 = STACK_AT (1); 7997 _stack0 = STACK_AT (0); 7998 /* PREFETCH ( -- ) */ 7999 do 8000 { 8001#line 207 "vm.def" 8002 PREFETCH; 8003 LOCAL_COUNTER++; 8004 8005#line 8006 "vm.inl" 8006 } 8007 while (0); 8008 /* POP_STACK_TOP ( tos -- ) */ 8009 do 8010 { 8011#define tos _stack0 8012#line 828 "vm.def" 8013 8014#line 8015 "vm.inl" 8015#undef tos 8016 } 8017 while (0); 8018 /* DUP_STACK_TOP ( tos | -- tos | tos2 ) */ 8019 do 8020 { 8021#define tos _stack1 8022#define tos2 _stack0 8023#line 860 "vm.def" 8024 tos2 = tos; 8025 8026#line 8027 "vm.inl" 8027#undef tos 8028#undef tos2 8029 } 8030 while (0); 8031 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 8032 do 8033 { 8034 int n = arg; 8035#define tos _extra1 8036#line 683 "vm.def" 8037 tos = METHOD_TEMPORARY (n); 8038 8039#line 8040 "vm.inl" 8040#undef tos 8041 } 8042 while (0); 8043 /* PUSH_INTEGER ( -- tos ) */ 8044 do 8045 { 8046 int n = 1; 8047#define tos _extra2 8048#line 812 "vm.def" 8049 tos = FROM_INT (n); 8050 8051#line 8052 "vm.inl" 8052#undef tos 8053 } 8054 while (0); 8055 /* PLUS_SPECIAL ( op1 op2 -- op ) */ 8056 do 8057 { 8058#define PREPARE_STACK() do { \ 8059 STACK_AT (0) = _stack0; \ 8060 PUSH_OOP (_extra1); \ 8061 PUSH_OOP (_extra2); \ 8062 } while (0) 8063#define op1 _extra1 8064#define op2 _extra2 8065#define op _extra1 8066#line 230 "vm.def" 8067 INTERP_BASIC_OP (op, op1, op2, 8068 add_with_check (op1, op2, &overflow), 8069 farg1 + farg2); 8070 PREPARE_STACK (); 8071 EXPORT_REGS (); 8072 SEND_MESSAGE (_gst_builtin_selectors[PLUS_SPECIAL].symbol, 1); 8073 IMPORT_REGS (); 8074 FETCH; 8075 8076#line 8077 "vm.inl" 8077#undef PREPARE_STACK 8078#undef op1 8079#undef op2 8080#undef op 8081 } 8082 while (0); 8083 STACK_AT (0) = _stack0; 8084 PUSH_OOP (_extra1); 8085 } 8086 NEXT_BC; 8087bc171: 8088 { 8089 OOP _extra1; 8090 /* PREFETCH ( -- ) */ 8091 do 8092 { 8093#line 207 "vm.def" 8094 PREFETCH; 8095 LOCAL_COUNTER++; 8096 8097#line 8098 "vm.inl" 8098 } 8099 while (0); 8100 /* PUSH_SELF ( -- tos ) */ 8101 do 8102 { 8103#define tos _extra1 8104#line 893 "vm.def" 8105 tos = _gst_self; 8106 8107#line 8108 "vm.inl" 8108#undef tos 8109 } 8110 while (0); 8111 /* SEND ( -- ) */ 8112 do 8113 { 8114 int sel = arg; 8115 int n = 1; 8116#define PREPARE_STACK() do { \ 8117 PUSH_OOP (_extra1); \ 8118 } while (0) 8119#line 643 "vm.def" 8120 PREPARE_STACK (); 8121 EXPORT_REGS (); 8122 SEND_MESSAGE (METHOD_LITERAL (sel), n); 8123 IMPORT_REGS (); 8124 FETCH; 8125 8126#line 8127 "vm.inl" 8127#undef PREPARE_STACK 8128 } 8129 while (0); 8130 PUSH_OOP (_extra1); 8131 } 8132 NEXT_BC; 8133bc172: 8134 { 8135 OOP _stack0; 8136 _stack0 = STACK_AT (0); 8137 /* PREFETCH ( -- ) */ 8138 do 8139 { 8140#line 207 "vm.def" 8141 PREFETCH; 8142 LOCAL_COUNTER++; 8143 8144#line 8145 "vm.inl" 8145 } 8146 while (0); 8147 /* STORE_TEMPORARY_VARIABLE ( tos | -- tos | ) */ 8148 do 8149 { 8150 int n = 0; 8151#define tos _stack0 8152#line 722 "vm.def" 8153 STORE_METHOD_TEMPORARY (n, tos); 8154 8155#line 8156 "vm.inl" 8156#undef tos 8157 } 8158 while (0); 8159 /* LINE_NUMBER_BYTECODE ( -- ) */ 8160 do 8161 { 8162#line 890 "vm.def" 8163 8164#line 8165 "vm.inl" 8165 } 8166 while (0); 8167 /* POP_STACK_TOP ( tos -- ) */ 8168 do 8169 { 8170#define tos _stack0 8171#line 828 "vm.def" 8172 8173#line 8174 "vm.inl" 8174#undef tos 8175 } 8176 while (0); 8177 POP_N_OOPS (1); 8178 } 8179 NEXT_BC; 8180bc173: 8181 { 8182 OOP _stack0; 8183 OOP _extra1; 8184 _stack0 = STACK_AT (0); 8185 /* PREFETCH ( -- ) */ 8186 do 8187 { 8188#line 207 "vm.def" 8189 PREFETCH; 8190 LOCAL_COUNTER++; 8191 8192#line 8193 "vm.inl" 8193 } 8194 while (0); 8195 /* DUP_STACK_TOP ( tos | -- tos | tos2 ) */ 8196 do 8197 { 8198#define tos _stack0 8199#define tos2 _extra1 8200#line 860 "vm.def" 8201 tos2 = tos; 8202 8203#line 8204 "vm.inl" 8204#undef tos 8205#undef tos2 8206 } 8207 while (0); 8208 /* LINE_NUMBER_BYTECODE ( -- ) */ 8209 do 8210 { 8211#line 890 "vm.def" 8212 8213#line 8214 "vm.inl" 8214 } 8215 while (0); 8216 PUSH_OOP (_extra1); 8217 } 8218 NEXT_BC; 8219bc174: 8220 { 8221 OOP _extra1, _extra2; 8222 /* PREFETCH ( -- ) */ 8223 do 8224 { 8225#line 207 "vm.def" 8226 PREFETCH; 8227 LOCAL_COUNTER++; 8228 8229#line 8230 "vm.inl" 8230 } 8231 while (0); 8232 /* PUSH_SELF ( -- tos ) */ 8233 do 8234 { 8235#define tos _extra1 8236#line 893 "vm.def" 8237 tos = _gst_self; 8238 8239#line 8240 "vm.inl" 8240#undef tos 8241 } 8242 while (0); 8243 /* PUSH_LIT_CONSTANT ( -- tos ) */ 8244 do 8245 { 8246 int n = arg; 8247#define tos _extra2 8248#line 820 "vm.def" 8249 tos = METHOD_LITERAL (n); 8250 8251#line 8252 "vm.inl" 8252#undef tos 8253 } 8254 while (0); 8255 /* SEND_IMMEDIATE ( -- ) */ 8256 do 8257 { 8258 int n = 49; 8259#define PREPARE_STACK() do { \ 8260 PUSH_OOP (_extra1); \ 8261 PUSH_OOP (_extra2); \ 8262 } while (0) 8263#line 662 "vm.def" 8264 const struct builtin_selector *bs = &_gst_builtin_selectors[n]; 8265 PREPARE_STACK (); 8266 EXPORT_REGS (); 8267 SEND_MESSAGE (bs->symbol, bs->numArgs); 8268 IMPORT_REGS (); 8269 FETCH; 8270 8271#line 8272 "vm.inl" 8272#undef PREPARE_STACK 8273 } 8274 while (0); 8275 PUSH_OOP (_extra1); 8276 PUSH_OOP (_extra2); 8277 } 8278 NEXT_BC; 8279bc175: 8280 { 8281 OOP _stack0; 8282 _stack0 = STACK_AT (0); 8283 /* PREFETCH ( -- ) */ 8284 do 8285 { 8286#line 207 "vm.def" 8287 PREFETCH; 8288 LOCAL_COUNTER++; 8289 8290#line 8291 "vm.inl" 8291 } 8292 while (0); 8293 /* POP_STACK_TOP ( tos -- ) */ 8294 do 8295 { 8296#define tos _stack0 8297#line 828 "vm.def" 8298 8299#line 8300 "vm.inl" 8300#undef tos 8301 } 8302 while (0); 8303 /* PUSH_RECEIVER_VARIABLE ( -- tos ) */ 8304 do 8305 { 8306 int n = arg; 8307#define tos _stack0 8308#line 718 "vm.def" 8309 tos = RECEIVER_VARIABLE (n); 8310 8311#line 8312 "vm.inl" 8312#undef tos 8313 } 8314 while (0); 8315 STACK_AT (0) = _stack0; 8316 } 8317 NEXT_BC; 8318bc176: 8319 { 8320 OOP _extra1; 8321 /* PREFETCH ( -- ) */ 8322 do 8323 { 8324#line 207 "vm.def" 8325 PREFETCH; 8326 LOCAL_COUNTER++; 8327 8328#line 8329 "vm.inl" 8329 } 8330 while (0); 8331 /* LINE_NUMBER_BYTECODE ( -- ) */ 8332 do 8333 { 8334#line 890 "vm.def" 8335 8336#line 8337 "vm.inl" 8337 } 8338 while (0); 8339 /* PUSH_SELF ( -- tos ) */ 8340 do 8341 { 8342#define tos _extra1 8343#line 893 "vm.def" 8344 tos = _gst_self; 8345 8346#line 8347 "vm.inl" 8347#undef tos 8348 } 8349 while (0); 8350 /* SEND_IMMEDIATE ( -- ) */ 8351 do 8352 { 8353 int n = 84; 8354#define PREPARE_STACK() do { \ 8355 PUSH_OOP (_extra1); \ 8356 } while (0) 8357#line 662 "vm.def" 8358 const struct builtin_selector *bs = &_gst_builtin_selectors[n]; 8359 PREPARE_STACK (); 8360 EXPORT_REGS (); 8361 SEND_MESSAGE (bs->symbol, bs->numArgs); 8362 IMPORT_REGS (); 8363 FETCH; 8364 8365#line 8366 "vm.inl" 8366#undef PREPARE_STACK 8367 } 8368 while (0); 8369 PUSH_OOP (_extra1); 8370 } 8371 NEXT_BC; 8372bc177: 8373 { 8374 OOP _extra1; 8375 /* PREFETCH ( -- ) */ 8376 do 8377 { 8378#line 207 "vm.def" 8379 PREFETCH; 8380 LOCAL_COUNTER++; 8381 8382#line 8383 "vm.inl" 8383 } 8384 while (0); 8385 /* LINE_NUMBER_BYTECODE ( -- ) */ 8386 do 8387 { 8388#line 890 "vm.def" 8389 8390#line 8391 "vm.inl" 8391 } 8392 while (0); 8393 /* PUSH_LIT_VARIABLE ( -- tos ) */ 8394 do 8395 { 8396 int n = 2; 8397#define PREPARE_STACK() do { \ 8398 } while (0) 8399#define tos _extra1 8400#line 702 "vm.def" 8401 tos = METHOD_LITERAL (n); 8402 if (UNCOMMON (IS_INT (tos)) 8403 || UNCOMMON (!is_a_kind_of (OOP_CLASS (tos), _gst_association_class))) 8404 { 8405 PREPARE_STACK (); 8406 PUSH_OOP (tos); 8407 EXPORT_REGS (); 8408 SEND_MESSAGE (_gst_builtin_selectors[VALUE_SPECIAL].symbol, 0); 8409 IMPORT_REGS (); 8410 FETCH; 8411 } 8412 else 8413 tos = ASSOCIATION_VALUE (tos); 8414 8415#line 8416 "vm.inl" 8416#undef PREPARE_STACK 8417#undef tos 8418 } 8419 while (0); 8420 PUSH_OOP (_extra1); 8421 } 8422 NEXT_BC; 8423bc178: 8424 { 8425 OOP _extra1; 8426 /* PREFETCH ( -- ) */ 8427 do 8428 { 8429#line 207 "vm.def" 8430 PREFETCH; 8431 LOCAL_COUNTER++; 8432 8433#line 8434 "vm.inl" 8434 } 8435 while (0); 8436 /* PUSH_LIT_CONSTANT ( -- tos ) */ 8437 do 8438 { 8439 int n = arg; 8440#define tos _extra1 8441#line 820 "vm.def" 8442 tos = METHOD_LITERAL (n); 8443 8444#line 8445 "vm.inl" 8445#undef tos 8446 } 8447 while (0); 8448 /* MAKE_DIRTY_BLOCK ( block -- closure ) */ 8449 do 8450 { 8451#define block _extra1 8452#define closure _extra1 8453#line 831 "vm.def" 8454 EXPORT_REGS (); 8455 closure = _gst_make_block_closure (block); 8456 IMPORT_REGS(); 8457 8458#line 8459 "vm.inl" 8459#undef block 8460#undef closure 8461 } 8462 while (0); 8463 /* SEND ( -- ) */ 8464 do 8465 { 8466 int sel = 3; 8467 int n = 1; 8468#define PREPARE_STACK() do { \ 8469 PUSH_OOP (_extra1); \ 8470 } while (0) 8471#line 643 "vm.def" 8472 PREPARE_STACK (); 8473 EXPORT_REGS (); 8474 SEND_MESSAGE (METHOD_LITERAL (sel), n); 8475 IMPORT_REGS (); 8476 FETCH; 8477 8478#line 8479 "vm.inl" 8479#undef PREPARE_STACK 8480 } 8481 while (0); 8482 PUSH_OOP (_extra1); 8483 } 8484 NEXT_BC; 8485bc179: 8486 { 8487 OOP _extra1; 8488 /* PREFETCH ( -- ) */ 8489 do 8490 { 8491#line 207 "vm.def" 8492 PREFETCH; 8493 LOCAL_COUNTER++; 8494 8495#line 8496 "vm.inl" 8496 } 8497 while (0); 8498 /* LINE_NUMBER_BYTECODE ( -- ) */ 8499 do 8500 { 8501#line 890 "vm.def" 8502 8503#line 8504 "vm.inl" 8504 } 8505 while (0); 8506 /* PUSH_LIT_CONSTANT ( -- tos ) */ 8507 do 8508 { 8509 int n = 0; 8510#define tos _extra1 8511#line 820 "vm.def" 8512 tos = METHOD_LITERAL (n); 8513 8514#line 8515 "vm.inl" 8515#undef tos 8516 } 8517 while (0); 8518 PUSH_OOP (_extra1); 8519 } 8520 NEXT_BC; 8521bc180: 8522 { 8523 OOP _stack0; 8524 OOP _extra1, _extra2; 8525 _stack0 = STACK_AT (0); 8526 /* PREFETCH ( -- ) */ 8527 do 8528 { 8529#line 207 "vm.def" 8530 PREFETCH; 8531 LOCAL_COUNTER++; 8532 8533#line 8534 "vm.inl" 8534 } 8535 while (0); 8536 /* DUP_STACK_TOP ( tos | -- tos | tos2 ) */ 8537 do 8538 { 8539#define tos _stack0 8540#define tos2 _extra1 8541#line 860 "vm.def" 8542 tos2 = tos; 8543 8544#line 8545 "vm.inl" 8545#undef tos 8546#undef tos2 8547 } 8548 while (0); 8549 /* PUSH_LIT_CONSTANT ( -- tos ) */ 8550 do 8551 { 8552 int n = arg; 8553#define tos _extra2 8554#line 820 "vm.def" 8555 tos = METHOD_LITERAL (n); 8556 8557#line 8558 "vm.inl" 8558#undef tos 8559 } 8560 while (0); 8561 /* SEND_IMMEDIATE ( -- ) */ 8562 do 8563 { 8564 int n = 36; 8565#define PREPARE_STACK() do { \ 8566 PUSH_OOP (_extra1); \ 8567 PUSH_OOP (_extra2); \ 8568 } while (0) 8569#line 662 "vm.def" 8570 const struct builtin_selector *bs = &_gst_builtin_selectors[n]; 8571 PREPARE_STACK (); 8572 EXPORT_REGS (); 8573 SEND_MESSAGE (bs->symbol, bs->numArgs); 8574 IMPORT_REGS (); 8575 FETCH; 8576 8577#line 8578 "vm.inl" 8578#undef PREPARE_STACK 8579 } 8580 while (0); 8581 PUSH_OOP (_extra1); 8582 PUSH_OOP (_extra2); 8583 } 8584 NEXT_BC; 8585bc181: 8586 { 8587 OOP _extra1; 8588 /* PREFETCH ( -- ) */ 8589 do 8590 { 8591#line 207 "vm.def" 8592 PREFETCH; 8593 LOCAL_COUNTER++; 8594 8595#line 8596 "vm.inl" 8596 } 8597 while (0); 8598 /* LINE_NUMBER_BYTECODE ( -- ) */ 8599 do 8600 { 8601#line 890 "vm.def" 8602 8603#line 8604 "vm.inl" 8604 } 8605 while (0); 8606 /* PUSH_OUTER_TEMP ( -- tos ) */ 8607 do 8608 { 8609 int n = 1; 8610 int scopes = 1; 8611#define tos _extra1 8612#line 687 "vm.def" 8613 OOP contextOOP; 8614 gst_block_context context; 8615 8616 context = (gst_block_context) OOP_TO_OBJ (_gst_this_context_oop); 8617 do 8618 { 8619 contextOOP = context->outerContext; 8620 context = (gst_block_context) OOP_TO_OBJ (contextOOP); 8621 } 8622 while (--scopes); 8623 8624 tos = context->contextStack[n]; 8625 8626#line 8627 "vm.inl" 8627#undef tos 8628 } 8629 while (0); 8630 PUSH_OOP (_extra1); 8631 } 8632 NEXT_BC; 8633bc182: 8634 { 8635 OOP _stack0; 8636 OOP _extra1; 8637 _stack0 = STACK_AT (0); 8638 /* PREFETCH ( -- ) */ 8639 do 8640 { 8641#line 207 "vm.def" 8642 PREFETCH; 8643 LOCAL_COUNTER++; 8644 8645#line 8646 "vm.inl" 8646 } 8647 while (0); 8648 /* PUSH_INTEGER ( -- tos ) */ 8649 do 8650 { 8651 int n = arg; 8652#define tos _extra1 8653#line 812 "vm.def" 8654 tos = FROM_INT (n); 8655 8656#line 8657 "vm.inl" 8657#undef tos 8658 } 8659 while (0); 8660 /* INTEGER_DIVIDE_SPECIAL ( op1 op2 | -- op1 op2 | ) */ 8661 do 8662 { 8663#define PREPARE_STACK() do { \ 8664 PUSH_OOP (_extra1); \ 8665 } while (0) 8666#define op1 _stack0 8667#define op2 _extra1 8668#line 403 "vm.def" 8669 PREPARE_STACK (); 8670 EXPORT_REGS(); 8671 if (IS_INT (op1) && IS_INT (op2) 8672 && !VMpr_SmallInteger_intDiv (12, 1)) 8673 { 8674 IMPORT_REGS (); 8675 NEXT_BC; 8676 } 8677 8678 SEND_MESSAGE (_gst_builtin_selectors[INTEGER_DIVIDE_SPECIAL].symbol, 1); 8679 IMPORT_REGS (); 8680 FETCH; 8681 8682#line 8683 "vm.inl" 8683#undef PREPARE_STACK 8684#undef op1 8685#undef op2 8686 } 8687 while (0); 8688 PUSH_OOP (_extra1); 8689 } 8690 NEXT_BC; 8691bc183: 8692 { 8693 OOP _extra1; 8694 /* PREFETCH ( -- ) */ 8695 do 8696 { 8697#line 207 "vm.def" 8698 PREFETCH; 8699 LOCAL_COUNTER++; 8700 8701#line 8702 "vm.inl" 8702 } 8703 while (0); 8704 /* PUSH_LIT_CONSTANT ( -- tos ) */ 8705 do 8706 { 8707 int n = 1; 8708#define tos _extra1 8709#line 820 "vm.def" 8710 tos = METHOD_LITERAL (n); 8711 8712#line 8713 "vm.inl" 8713#undef tos 8714 } 8715 while (0); 8716 /* MAKE_DIRTY_BLOCK ( block -- closure ) */ 8717 do 8718 { 8719#define block _extra1 8720#define closure _extra1 8721#line 831 "vm.def" 8722 EXPORT_REGS (); 8723 closure = _gst_make_block_closure (block); 8724 IMPORT_REGS(); 8725 8726#line 8727 "vm.inl" 8727#undef block 8728#undef closure 8729 } 8730 while (0); 8731 /* SEND_IMMEDIATE ( -- ) */ 8732 do 8733 { 8734 int n = arg; 8735#define PREPARE_STACK() do { \ 8736 PUSH_OOP (_extra1); \ 8737 } while (0) 8738#line 662 "vm.def" 8739 const struct builtin_selector *bs = &_gst_builtin_selectors[n]; 8740 PREPARE_STACK (); 8741 EXPORT_REGS (); 8742 SEND_MESSAGE (bs->symbol, bs->numArgs); 8743 IMPORT_REGS (); 8744 FETCH; 8745 8746#line 8747 "vm.inl" 8747#undef PREPARE_STACK 8748 } 8749 while (0); 8750 PUSH_OOP (_extra1); 8751 } 8752 NEXT_BC; 8753bc184: 8754 { 8755 OOP _extra1; 8756 /* PREFETCH ( -- ) */ 8757 do 8758 { 8759#line 207 "vm.def" 8760 PREFETCH; 8761 LOCAL_COUNTER++; 8762 8763#line 8764 "vm.inl" 8764 } 8765 while (0); 8766 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 8767 do 8768 { 8769 int n = 3; 8770#define tos _extra1 8771#line 683 "vm.def" 8772 tos = METHOD_TEMPORARY (n); 8773 8774#line 8775 "vm.inl" 8775#undef tos 8776 } 8777 while (0); 8778 /* SEND_IMMEDIATE ( -- ) */ 8779 do 8780 { 8781 int n = arg; 8782#define PREPARE_STACK() do { \ 8783 PUSH_OOP (_extra1); \ 8784 } while (0) 8785#line 662 "vm.def" 8786 const struct builtin_selector *bs = &_gst_builtin_selectors[n]; 8787 PREPARE_STACK (); 8788 EXPORT_REGS (); 8789 SEND_MESSAGE (bs->symbol, bs->numArgs); 8790 IMPORT_REGS (); 8791 FETCH; 8792 8793#line 8794 "vm.inl" 8794#undef PREPARE_STACK 8795 } 8796 while (0); 8797 PUSH_OOP (_extra1); 8798 } 8799 NEXT_BC; 8800bc185: 8801 { 8802 OOP _extra1; 8803 /* PREFETCH ( -- ) */ 8804 do 8805 { 8806#line 207 "vm.def" 8807 PREFETCH; 8808 LOCAL_COUNTER++; 8809 8810#line 8811 "vm.inl" 8811 } 8812 while (0); 8813 /* LINE_NUMBER_BYTECODE ( -- ) */ 8814 do 8815 { 8816#line 890 "vm.def" 8817 8818#line 8819 "vm.inl" 8819 } 8820 while (0); 8821 /* PUSH_SPECIAL ( -- tos ) */ 8822 do 8823 { 8824 int n = 0; 8825#define tos _extra1 8826#line 816 "vm.def" 8827 tos = _gst_nil_oop + (n - NIL_INDEX); 8828 8829#line 8830 "vm.inl" 8830#undef tos 8831 } 8832 while (0); 8833 /* RETURN_CONTEXT_STACK_TOP ( val | -- val | ) */ 8834 do 8835 { 8836#define val _extra1 8837#line 852 "vm.def" 8838 EXPORT_REGS (); 8839 unwind_context (); 8840 IMPORT_REGS (); 8841 SET_STACKTOP (val); 8842 FETCH; 8843 8844#line 8845 "vm.inl" 8845#undef val 8846 } 8847 while (0); 8848 PUSH_OOP (_extra1); 8849 } 8850 NEXT_BC; 8851bc186: 8852 { 8853 OOP _extra1; 8854 /* PREFETCH ( -- ) */ 8855 do 8856 { 8857#line 207 "vm.def" 8858 PREFETCH; 8859 LOCAL_COUNTER++; 8860 8861#line 8862 "vm.inl" 8862 } 8863 while (0); 8864 /* LINE_NUMBER_BYTECODE ( -- ) */ 8865 do 8866 { 8867#line 890 "vm.def" 8868 8869#line 8870 "vm.inl" 8870 } 8871 while (0); 8872 /* PUSH_RECEIVER_VARIABLE ( -- tos ) */ 8873 do 8874 { 8875 int n = 5; 8876#define tos _extra1 8877#line 718 "vm.def" 8878 tos = RECEIVER_VARIABLE (n); 8879 8880#line 8881 "vm.inl" 8881#undef tos 8882 } 8883 while (0); 8884 PUSH_OOP (_extra1); 8885 } 8886 NEXT_BC; 8887bc187: 8888 { 8889 OOP _extra1; 8890 /* PREFETCH ( -- ) */ 8891 do 8892 { 8893#line 207 "vm.def" 8894 PREFETCH; 8895 LOCAL_COUNTER++; 8896 8897#line 8898 "vm.inl" 8898 } 8899 while (0); 8900 /* PUSH_LIT_CONSTANT ( -- tos ) */ 8901 do 8902 { 8903 int n = arg; 8904#define tos _extra1 8905#line 820 "vm.def" 8906 tos = METHOD_LITERAL (n); 8907 8908#line 8909 "vm.inl" 8909#undef tos 8910 } 8911 while (0); 8912 /* MAKE_DIRTY_BLOCK ( block -- closure ) */ 8913 do 8914 { 8915#define block _extra1 8916#define closure _extra1 8917#line 831 "vm.def" 8918 EXPORT_REGS (); 8919 closure = _gst_make_block_closure (block); 8920 IMPORT_REGS(); 8921 8922#line 8923 "vm.inl" 8923#undef block 8924#undef closure 8925 } 8926 while (0); 8927 /* SEND ( -- ) */ 8928 do 8929 { 8930 int sel = 2; 8931 int n = 1; 8932#define PREPARE_STACK() do { \ 8933 PUSH_OOP (_extra1); \ 8934 } while (0) 8935#line 643 "vm.def" 8936 PREPARE_STACK (); 8937 EXPORT_REGS (); 8938 SEND_MESSAGE (METHOD_LITERAL (sel), n); 8939 IMPORT_REGS (); 8940 FETCH; 8941 8942#line 8943 "vm.inl" 8943#undef PREPARE_STACK 8944 } 8945 while (0); 8946 PUSH_OOP (_extra1); 8947 } 8948 NEXT_BC; 8949bc188: 8950 { 8951 OOP _stack0; 8952 OOP _extra1; 8953 _stack0 = STACK_AT (0); 8954 /* PREFETCH ( -- ) */ 8955 do 8956 { 8957#line 207 "vm.def" 8958 PREFETCH; 8959 LOCAL_COUNTER++; 8960 8961#line 8962 "vm.inl" 8962 } 8963 while (0); 8964 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 8965 do 8966 { 8967 int n = arg; 8968#define tos _extra1 8969#line 683 "vm.def" 8970 tos = METHOD_TEMPORARY (n); 8971 8972#line 8973 "vm.inl" 8973#undef tos 8974 } 8975 while (0); 8976 /* VALUE_COLON_SPECIAL ( rec blk_arg | -- rec blk_arg | ) */ 8977 do 8978 { 8979#define PREPARE_STACK() do { \ 8980 PUSH_OOP (_extra1); \ 8981 } while (0) 8982#define rec _stack0 8983#define blk_arg _extra1 8984#line 598 "vm.def" 8985 PREPARE_STACK (); 8986 EXPORT_REGS (); 8987 if (UNCOMMON (IS_INT (rec)) 8988 || UNCOMMON (OOP_CLASS (rec) != _gst_block_closure_class) 8989 || UNCOMMON (send_block_value (1, 0))) 8990 SEND_MESSAGE (_gst_builtin_selectors[VALUE_COLON_SPECIAL].symbol, 1); 8991 8992 IMPORT_REGS (); 8993 FETCH; 8994 8995#line 8996 "vm.inl" 8996#undef PREPARE_STACK 8997#undef rec 8998#undef blk_arg 8999 } 9000 while (0); 9001 PUSH_OOP (_extra1); 9002 } 9003 NEXT_BC; 9004bc189: 9005 { 9006 OOP _extra1; 9007 /* PREFETCH ( -- ) */ 9008 do 9009 { 9010#line 207 "vm.def" 9011 PREFETCH; 9012 LOCAL_COUNTER++; 9013 9014#line 9015 "vm.inl" 9015 } 9016 while (0); 9017 /* PUSH_INTEGER ( -- tos ) */ 9018 do 9019 { 9020 int n = arg; 9021#define tos _extra1 9022#line 812 "vm.def" 9023 tos = FROM_INT (n); 9024 9025#line 9026 "vm.inl" 9026#undef tos 9027 } 9028 while (0); 9029 /* RETURN_CONTEXT_STACK_TOP ( val | -- val | ) */ 9030 do 9031 { 9032#define val _extra1 9033#line 852 "vm.def" 9034 EXPORT_REGS (); 9035 unwind_context (); 9036 IMPORT_REGS (); 9037 SET_STACKTOP (val); 9038 FETCH; 9039 9040#line 9041 "vm.inl" 9041#undef val 9042 } 9043 while (0); 9044 PUSH_OOP (_extra1); 9045 } 9046 NEXT_BC; 9047bc190: 9048 { 9049 OOP _extra1; 9050 /* PREFETCH ( -- ) */ 9051 do 9052 { 9053#line 207 "vm.def" 9054 PREFETCH; 9055 LOCAL_COUNTER++; 9056 9057#line 9058 "vm.inl" 9058 } 9059 while (0); 9060 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 9061 do 9062 { 9063 int n = 0; 9064#define tos _extra1 9065#line 683 "vm.def" 9066 tos = METHOD_TEMPORARY (n); 9067 9068#line 9069 "vm.inl" 9069#undef tos 9070 } 9071 while (0); 9072 /* SEND ( -- ) */ 9073 do 9074 { 9075 int sel = arg; 9076 int n = 2; 9077#define PREPARE_STACK() do { \ 9078 PUSH_OOP (_extra1); \ 9079 } while (0) 9080#line 643 "vm.def" 9081 PREPARE_STACK (); 9082 EXPORT_REGS (); 9083 SEND_MESSAGE (METHOD_LITERAL (sel), n); 9084 IMPORT_REGS (); 9085 FETCH; 9086 9087#line 9088 "vm.inl" 9088#undef PREPARE_STACK 9089 } 9090 while (0); 9091 PUSH_OOP (_extra1); 9092 } 9093 NEXT_BC; 9094bc191: 9095 { 9096 OOP _extra1, _extra2; 9097 /* PREFETCH ( -- ) */ 9098 do 9099 { 9100#line 207 "vm.def" 9101 PREFETCH; 9102 LOCAL_COUNTER++; 9103 9104#line 9105 "vm.inl" 9105 } 9106 while (0); 9107 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 9108 do 9109 { 9110 int n = arg; 9111#define tos _extra1 9112#line 683 "vm.def" 9113 tos = METHOD_TEMPORARY (n); 9114 9115#line 9116 "vm.inl" 9116#undef tos 9117 } 9118 while (0); 9119 /* PUSH_INTEGER ( -- tos ) */ 9120 do 9121 { 9122 int n = 1; 9123#define tos _extra2 9124#line 812 "vm.def" 9125 tos = FROM_INT (n); 9126 9127#line 9128 "vm.inl" 9128#undef tos 9129 } 9130 while (0); 9131 /* MINUS_SPECIAL ( op1 op2 -- op ) */ 9132 do 9133 { 9134#define PREPARE_STACK() do { \ 9135 PUSH_OOP (_extra1); \ 9136 PUSH_OOP (_extra2); \ 9137 } while (0) 9138#define op1 _extra1 9139#define op2 _extra2 9140#define op _extra1 9141#line 241 "vm.def" 9142 INTERP_BASIC_OP (op, op1, op2, 9143 sub_with_check (op1, op2, &overflow), 9144 farg1 - farg2); 9145 PREPARE_STACK (); 9146 EXPORT_REGS (); 9147 SEND_MESSAGE (_gst_builtin_selectors[MINUS_SPECIAL].symbol, 1); 9148 IMPORT_REGS (); 9149 FETCH; 9150 9151#line 9152 "vm.inl" 9152#undef PREPARE_STACK 9153#undef op1 9154#undef op2 9155#undef op 9156 } 9157 while (0); 9158 PUSH_OOP (_extra1); 9159 } 9160 NEXT_BC; 9161bc192: 9162 { 9163 OOP _extra1, _extra2; 9164 /* PREFETCH ( -- ) */ 9165 do 9166 { 9167#line 207 "vm.def" 9168 PREFETCH; 9169 LOCAL_COUNTER++; 9170 9171#line 9172 "vm.inl" 9172 } 9173 while (0); 9174 /* PUSH_SELF ( -- tos ) */ 9175 do 9176 { 9177#define tos _extra1 9178#line 893 "vm.def" 9179 tos = _gst_self; 9180 9181#line 9182 "vm.inl" 9182#undef tos 9183 } 9184 while (0); 9185 /* PUSH_LIT_CONSTANT ( -- tos ) */ 9186 do 9187 { 9188 int n = arg; 9189#define tos _extra2 9190#line 820 "vm.def" 9191 tos = METHOD_LITERAL (n); 9192 9193#line 9194 "vm.inl" 9194#undef tos 9195 } 9196 while (0); 9197 PUSH_OOP (_extra1); 9198 PUSH_OOP (_extra2); 9199 } 9200 NEXT_BC; 9201bc193: 9202 { 9203 OOP _extra1; 9204 /* PREFETCH ( -- ) */ 9205 do 9206 { 9207#line 207 "vm.def" 9208 PREFETCH; 9209 LOCAL_COUNTER++; 9210 9211#line 9212 "vm.inl" 9212 } 9213 while (0); 9214 /* LINE_NUMBER_BYTECODE ( -- ) */ 9215 do 9216 { 9217#line 890 "vm.def" 9218 9219#line 9220 "vm.inl" 9220 } 9221 while (0); 9222 /* PUSH_RECEIVER_VARIABLE ( -- tos ) */ 9223 do 9224 { 9225 int n = 4; 9226#define tos _extra1 9227#line 718 "vm.def" 9228 tos = RECEIVER_VARIABLE (n); 9229 9230#line 9231 "vm.inl" 9231#undef tos 9232 } 9233 while (0); 9234 PUSH_OOP (_extra1); 9235 } 9236 NEXT_BC; 9237bc194: 9238 { 9239 OOP _extra1; 9240 /* PREFETCH ( -- ) */ 9241 do 9242 { 9243#line 207 "vm.def" 9244 PREFETCH; 9245 LOCAL_COUNTER++; 9246 9247#line 9248 "vm.inl" 9248 } 9249 while (0); 9250 /* PUSH_OUTER_TEMP ( -- tos ) */ 9251 do 9252 { 9253 int n = 0; 9254 int scopes = 1; 9255#define tos _extra1 9256#line 687 "vm.def" 9257 OOP contextOOP; 9258 gst_block_context context; 9259 9260 context = (gst_block_context) OOP_TO_OBJ (_gst_this_context_oop); 9261 do 9262 { 9263 contextOOP = context->outerContext; 9264 context = (gst_block_context) OOP_TO_OBJ (contextOOP); 9265 } 9266 while (--scopes); 9267 9268 tos = context->contextStack[n]; 9269 9270#line 9271 "vm.inl" 9271#undef tos 9272 } 9273 while (0); 9274 /* SEND_IMMEDIATE ( -- ) */ 9275 do 9276 { 9277 int n = arg; 9278#define PREPARE_STACK() do { \ 9279 PUSH_OOP (_extra1); \ 9280 } while (0) 9281#line 662 "vm.def" 9282 const struct builtin_selector *bs = &_gst_builtin_selectors[n]; 9283 PREPARE_STACK (); 9284 EXPORT_REGS (); 9285 SEND_MESSAGE (bs->symbol, bs->numArgs); 9286 IMPORT_REGS (); 9287 FETCH; 9288 9289#line 9290 "vm.inl" 9290#undef PREPARE_STACK 9291 } 9292 while (0); 9293 PUSH_OOP (_extra1); 9294 } 9295 NEXT_BC; 9296bc195: 9297 { 9298 OOP _extra1; 9299 /* PREFETCH ( -- ) */ 9300 do 9301 { 9302#line 207 "vm.def" 9303 PREFETCH; 9304 LOCAL_COUNTER++; 9305 9306#line 9307 "vm.inl" 9307 } 9308 while (0); 9309 /* LINE_NUMBER_BYTECODE ( -- ) */ 9310 do 9311 { 9312#line 890 "vm.def" 9313 9314#line 9315 "vm.inl" 9315 } 9316 while (0); 9317 /* PUSH_SELF ( -- tos ) */ 9318 do 9319 { 9320#define tos _extra1 9321#line 893 "vm.def" 9322 tos = _gst_self; 9323 9324#line 9325 "vm.inl" 9325#undef tos 9326 } 9327 while (0); 9328 /* SEND ( -- ) */ 9329 do 9330 { 9331 int sel = 1; 9332 int n = 0; 9333#define PREPARE_STACK() do { \ 9334 PUSH_OOP (_extra1); \ 9335 } while (0) 9336#line 643 "vm.def" 9337 PREPARE_STACK (); 9338 EXPORT_REGS (); 9339 SEND_MESSAGE (METHOD_LITERAL (sel), n); 9340 IMPORT_REGS (); 9341 FETCH; 9342 9343#line 9344 "vm.inl" 9344#undef PREPARE_STACK 9345 } 9346 while (0); 9347 PUSH_OOP (_extra1); 9348 } 9349 NEXT_BC; 9350bc196: 9351 { 9352 OOP _extra1; 9353 /* PREFETCH ( -- ) */ 9354 do 9355 { 9356#line 207 "vm.def" 9357 PREFETCH; 9358 LOCAL_COUNTER++; 9359 9360#line 9361 "vm.inl" 9361 } 9362 while (0); 9363 /* PUSH_OUTER_TEMP ( -- tos ) */ 9364 do 9365 { 9366 int n = 0; 9367 int scopes = 1; 9368#define tos _extra1 9369#line 687 "vm.def" 9370 OOP contextOOP; 9371 gst_block_context context; 9372 9373 context = (gst_block_context) OOP_TO_OBJ (_gst_this_context_oop); 9374 do 9375 { 9376 contextOOP = context->outerContext; 9377 context = (gst_block_context) OOP_TO_OBJ (contextOOP); 9378 } 9379 while (--scopes); 9380 9381 tos = context->contextStack[n]; 9382 9383#line 9384 "vm.inl" 9384#undef tos 9385 } 9386 while (0); 9387 /* SEND ( -- ) */ 9388 do 9389 { 9390 int sel = arg; 9391 int n = 1; 9392#define PREPARE_STACK() do { \ 9393 PUSH_OOP (_extra1); \ 9394 } while (0) 9395#line 643 "vm.def" 9396 PREPARE_STACK (); 9397 EXPORT_REGS (); 9398 SEND_MESSAGE (METHOD_LITERAL (sel), n); 9399 IMPORT_REGS (); 9400 FETCH; 9401 9402#line 9403 "vm.inl" 9403#undef PREPARE_STACK 9404 } 9405 while (0); 9406 PUSH_OOP (_extra1); 9407 } 9408 NEXT_BC; 9409bc197: 9410 { 9411 OOP _extra1; 9412 /* PREFETCH ( -- ) */ 9413 do 9414 { 9415#line 207 "vm.def" 9416 PREFETCH; 9417 LOCAL_COUNTER++; 9418 9419#line 9420 "vm.inl" 9420 } 9421 while (0); 9422 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 9423 do 9424 { 9425 int n = 4; 9426#define tos _extra1 9427#line 683 "vm.def" 9428 tos = METHOD_TEMPORARY (n); 9429 9430#line 9431 "vm.inl" 9431#undef tos 9432 } 9433 while (0); 9434 /* SEND_IMMEDIATE ( -- ) */ 9435 do 9436 { 9437 int n = arg; 9438#define PREPARE_STACK() do { \ 9439 PUSH_OOP (_extra1); \ 9440 } while (0) 9441#line 662 "vm.def" 9442 const struct builtin_selector *bs = &_gst_builtin_selectors[n]; 9443 PREPARE_STACK (); 9444 EXPORT_REGS (); 9445 SEND_MESSAGE (bs->symbol, bs->numArgs); 9446 IMPORT_REGS (); 9447 FETCH; 9448 9449#line 9450 "vm.inl" 9450#undef PREPARE_STACK 9451 } 9452 while (0); 9453 PUSH_OOP (_extra1); 9454 } 9455 NEXT_BC; 9456bc198: 9457 { 9458 OOP _extra1; 9459 /* PREFETCH ( -- ) */ 9460 do 9461 { 9462#line 207 "vm.def" 9463 PREFETCH; 9464 LOCAL_COUNTER++; 9465 9466#line 9467 "vm.inl" 9467 } 9468 while (0); 9469 /* PUSH_INTEGER ( -- tos ) */ 9470 do 9471 { 9472 int n = arg; 9473#define tos _extra1 9474#line 812 "vm.def" 9475 tos = FROM_INT (n); 9476 9477#line 9478 "vm.inl" 9478#undef tos 9479 } 9480 while (0); 9481 /* SEND_IMMEDIATE ( -- ) */ 9482 do 9483 { 9484 int n = 41; 9485#define PREPARE_STACK() do { \ 9486 PUSH_OOP (_extra1); \ 9487 } while (0) 9488#line 662 "vm.def" 9489 const struct builtin_selector *bs = &_gst_builtin_selectors[n]; 9490 PREPARE_STACK (); 9491 EXPORT_REGS (); 9492 SEND_MESSAGE (bs->symbol, bs->numArgs); 9493 IMPORT_REGS (); 9494 FETCH; 9495 9496#line 9497 "vm.inl" 9497#undef PREPARE_STACK 9498 } 9499 while (0); 9500 PUSH_OOP (_extra1); 9501 } 9502 NEXT_BC; 9503bc199: 9504 { 9505 /* PREFETCH ( -- ) */ 9506 do 9507 { 9508#line 207 "vm.def" 9509 PREFETCH; 9510 LOCAL_COUNTER++; 9511 9512#line 9513 "vm.inl" 9513 } 9514 while (0); 9515 /* SEND ( -- ) */ 9516 do 9517 { 9518 int sel = arg; 9519 int n = 4; 9520#define PREPARE_STACK() do { \ 9521 } while (0) 9522#line 643 "vm.def" 9523 PREPARE_STACK (); 9524 EXPORT_REGS (); 9525 SEND_MESSAGE (METHOD_LITERAL (sel), n); 9526 IMPORT_REGS (); 9527 FETCH; 9528 9529#line 9530 "vm.inl" 9530#undef PREPARE_STACK 9531 } 9532 while (0); 9533 } 9534 NEXT_BC; 9535bc200: 9536 { 9537 OOP _extra1, _extra2; 9538 /* PREFETCH ( -- ) */ 9539 do 9540 { 9541#line 207 "vm.def" 9542 PREFETCH; 9543 LOCAL_COUNTER++; 9544 9545#line 9546 "vm.inl" 9546 } 9547 while (0); 9548 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 9549 do 9550 { 9551 int n = arg; 9552#define tos _extra1 9553#line 683 "vm.def" 9554 tos = METHOD_TEMPORARY (n); 9555 9556#line 9557 "vm.inl" 9557#undef tos 9558 } 9559 while (0); 9560 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 9561 do 9562 { 9563 int n = 2; 9564#define tos _extra2 9565#line 683 "vm.def" 9566 tos = METHOD_TEMPORARY (n); 9567 9568#line 9569 "vm.inl" 9569#undef tos 9570 } 9571 while (0); 9572 PUSH_OOP (_extra1); 9573 PUSH_OOP (_extra2); 9574 } 9575 NEXT_BC; 9576bc201: 9577 { 9578 OOP _extra1; 9579 /* PREFETCH ( -- ) */ 9580 do 9581 { 9582#line 207 "vm.def" 9583 PREFETCH; 9584 LOCAL_COUNTER++; 9585 9586#line 9587 "vm.inl" 9587 } 9588 while (0); 9589 /* PUSH_SELF ( -- tos ) */ 9590 do 9591 { 9592#define tos _extra1 9593#line 893 "vm.def" 9594 tos = _gst_self; 9595 9596#line 9597 "vm.inl" 9597#undef tos 9598 } 9599 while (0); 9600 /* CLASS_SPECIAL ( rec -- val ) */ 9601 do 9602 { 9603#define PREPARE_STACK() do { \ 9604 PUSH_OOP (_extra1); \ 9605 } while (0) 9606#define rec _extra1 9607#define val _extra1 9608#line 543 "vm.def" 9609 OOP classOOP; 9610 PREPARE_STACK (); 9611 EXPORT_REGS (); 9612 if UNCOMMON (IS_INT (rec)) 9613 { 9614 SEND_MESSAGE (_gst_builtin_selectors[CLASS_SPECIAL].symbol, 0); 9615 IMPORT_REGS (); 9616 FETCH; 9617 } 9618 9619 if COMMON (class_cache_class == (classOOP = OOP_CLASS (rec)) 9620 && !execute_primitive_operation (class_cache_prim, 1)) 9621 { 9622 IMPORT_REGS (); 9623 NEXT_BC; 9624 } 9625 9626 /* Not the same class that is in the cache, or the primitive failed -- 9627 send the message, and modify the cache if the send is resolved to 9628 a primitive. */ 9629 last_primitive = 0; 9630 SEND_MESSAGE (_gst_builtin_selectors[CLASS_SPECIAL].symbol, 0); 9631 IMPORT_REGS (); 9632 if COMMON (last_primitive) 9633 { 9634 class_cache_prim = last_primitive; 9635 class_cache_class = classOOP; 9636 NEXT_BC; 9637 } 9638 FETCH; 9639 9640#line 9641 "vm.inl" 9641#undef PREPARE_STACK 9642#undef rec 9643#undef val 9644 } 9645 while (0); 9646 PUSH_OOP (_extra1); 9647 } 9648 NEXT_BC; 9649bc202: 9650 { 9651 OOP _extra1; 9652 /* PREFETCH ( -- ) */ 9653 do 9654 { 9655#line 207 "vm.def" 9656 PREFETCH; 9657 LOCAL_COUNTER++; 9658 9659#line 9660 "vm.inl" 9660 } 9661 while (0); 9662 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 9663 do 9664 { 9665 int n = 1; 9666#define tos _extra1 9667#line 683 "vm.def" 9668 tos = METHOD_TEMPORARY (n); 9669 9670#line 9671 "vm.inl" 9671#undef tos 9672 } 9673 while (0); 9674 /* SEND ( -- ) */ 9675 do 9676 { 9677 int sel = arg >> 8; 9678 int n = arg & 255; 9679#define PREPARE_STACK() do { \ 9680 PUSH_OOP (_extra1); \ 9681 } while (0) 9682#line 643 "vm.def" 9683 PREPARE_STACK (); 9684 EXPORT_REGS (); 9685 SEND_MESSAGE (METHOD_LITERAL (sel), n); 9686 IMPORT_REGS (); 9687 FETCH; 9688 9689#line 9690 "vm.inl" 9690#undef PREPARE_STACK 9691 } 9692 while (0); 9693 PUSH_OOP (_extra1); 9694 } 9695 NEXT_BC; 9696bc203: 9697 { 9698 OOP _extra1, _extra2; 9699 /* PREFETCH ( -- ) */ 9700 do 9701 { 9702#line 207 "vm.def" 9703 PREFETCH; 9704 LOCAL_COUNTER++; 9705 9706#line 9707 "vm.inl" 9707 } 9708 while (0); 9709 /* PUSH_SELF ( -- tos ) */ 9710 do 9711 { 9712#define tos _extra1 9713#line 893 "vm.def" 9714 tos = _gst_self; 9715 9716#line 9717 "vm.inl" 9717#undef tos 9718 } 9719 while (0); 9720 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 9721 do 9722 { 9723 int n = 1; 9724#define tos _extra2 9725#line 683 "vm.def" 9726 tos = METHOD_TEMPORARY (n); 9727 9728#line 9729 "vm.inl" 9729#undef tos 9730 } 9731 while (0); 9732 /* SEND ( -- ) */ 9733 do 9734 { 9735 int sel = arg; 9736 int n = 1; 9737#define PREPARE_STACK() do { \ 9738 PUSH_OOP (_extra1); \ 9739 PUSH_OOP (_extra2); \ 9740 } while (0) 9741#line 643 "vm.def" 9742 PREPARE_STACK (); 9743 EXPORT_REGS (); 9744 SEND_MESSAGE (METHOD_LITERAL (sel), n); 9745 IMPORT_REGS (); 9746 FETCH; 9747 9748#line 9749 "vm.inl" 9749#undef PREPARE_STACK 9750 } 9751 while (0); 9752 PUSH_OOP (_extra1); 9753 PUSH_OOP (_extra2); 9754 } 9755 NEXT_BC; 9756bc204: 9757 { 9758 OOP _extra1; 9759 /* PREFETCH ( -- ) */ 9760 do 9761 { 9762#line 207 "vm.def" 9763 PREFETCH; 9764 LOCAL_COUNTER++; 9765 9766#line 9767 "vm.inl" 9767 } 9768 while (0); 9769 /* PUSH_LIT_CONSTANT ( -- tos ) */ 9770 do 9771 { 9772 int n = arg; 9773#define tos _extra1 9774#line 820 "vm.def" 9775 tos = METHOD_LITERAL (n); 9776 9777#line 9778 "vm.inl" 9778#undef tos 9779 } 9780 while (0); 9781 /* SEND ( -- ) */ 9782 do 9783 { 9784 int sel = 4; 9785 int n = 1; 9786#define PREPARE_STACK() do { \ 9787 PUSH_OOP (_extra1); \ 9788 } while (0) 9789#line 643 "vm.def" 9790 PREPARE_STACK (); 9791 EXPORT_REGS (); 9792 SEND_MESSAGE (METHOD_LITERAL (sel), n); 9793 IMPORT_REGS (); 9794 FETCH; 9795 9796#line 9797 "vm.inl" 9797#undef PREPARE_STACK 9798 } 9799 while (0); 9800 PUSH_OOP (_extra1); 9801 } 9802 NEXT_BC; 9803bc205: 9804 { 9805 OOP _extra1; 9806 /* PREFETCH ( -- ) */ 9807 do 9808 { 9809#line 207 "vm.def" 9810 PREFETCH; 9811 LOCAL_COUNTER++; 9812 9813#line 9814 "vm.inl" 9814 } 9815 while (0); 9816 /* PUSH_INTEGER ( -- tos ) */ 9817 do 9818 { 9819 int n = arg; 9820#define tos _extra1 9821#line 812 "vm.def" 9822 tos = FROM_INT (n); 9823 9824#line 9825 "vm.inl" 9825#undef tos 9826 } 9827 while (0); 9828 /* SEND ( -- ) */ 9829 do 9830 { 9831 int sel = 0; 9832 int n = 1; 9833#define PREPARE_STACK() do { \ 9834 PUSH_OOP (_extra1); \ 9835 } while (0) 9836#line 643 "vm.def" 9837 PREPARE_STACK (); 9838 EXPORT_REGS (); 9839 SEND_MESSAGE (METHOD_LITERAL (sel), n); 9840 IMPORT_REGS (); 9841 FETCH; 9842 9843#line 9844 "vm.inl" 9844#undef PREPARE_STACK 9845 } 9846 while (0); 9847 PUSH_OOP (_extra1); 9848 } 9849 NEXT_BC; 9850bc206: 9851 { 9852 OOP _extra1; 9853 /* PREFETCH ( -- ) */ 9854 do 9855 { 9856#line 207 "vm.def" 9857 PREFETCH; 9858 LOCAL_COUNTER++; 9859 9860#line 9861 "vm.inl" 9861 } 9862 while (0); 9863 /* PUSH_RECEIVER_VARIABLE ( -- tos ) */ 9864 do 9865 { 9866 int n = arg; 9867#define tos _extra1 9868#line 718 "vm.def" 9869 tos = RECEIVER_VARIABLE (n); 9870 9871#line 9872 "vm.inl" 9872#undef tos 9873 } 9874 while (0); 9875 /* SIZE_SPECIAL ( rec -- val ) */ 9876 do 9877 { 9878#define PREPARE_STACK() do { \ 9879 PUSH_OOP (_extra1); \ 9880 } while (0) 9881#define rec _extra1 9882#define val _extra1 9883#line 510 "vm.def" 9884 OOP classOOP; 9885 PREPARE_STACK (); 9886 EXPORT_REGS (); 9887 if UNCOMMON (IS_INT (rec)) 9888 { 9889 SEND_MESSAGE (_gst_builtin_selectors[SIZE_SPECIAL].symbol, 0); 9890 IMPORT_REGS (); 9891 FETCH; 9892 } 9893 9894 if COMMON (size_cache_class == (classOOP = OOP_CLASS (rec)) 9895 && !execute_primitive_operation (size_cache_prim, 0)) 9896 { 9897 IMPORT_REGS (); 9898 NEXT_BC; 9899 } 9900 9901 /* Not the same class that is in the cache, or the primitive failed -- 9902 send the message, and modify the cache if the send is resolved to 9903 a primitive. */ 9904 last_primitive = 0; 9905 SEND_MESSAGE (_gst_builtin_selectors[SIZE_SPECIAL].symbol, 0); 9906 IMPORT_REGS (); 9907 if COMMON (last_primitive) 9908 { 9909 size_cache_prim = last_primitive; 9910 size_cache_class = classOOP; 9911 NEXT_BC; 9912 } 9913 FETCH; 9914 9915#line 9916 "vm.inl" 9916#undef PREPARE_STACK 9917#undef rec 9918#undef val 9919 } 9920 while (0); 9921 PUSH_OOP (_extra1); 9922 } 9923 NEXT_BC; 9924bc207: 9925 { 9926 OOP _extra1; 9927 /* PREFETCH ( -- ) */ 9928 do 9929 { 9930#line 207 "vm.def" 9931 PREFETCH; 9932 LOCAL_COUNTER++; 9933 9934#line 9935 "vm.inl" 9935 } 9936 while (0); 9937 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 9938 do 9939 { 9940 int n = 1; 9941#define tos _extra1 9942#line 683 "vm.def" 9943 tos = METHOD_TEMPORARY (n); 9944 9945#line 9946 "vm.inl" 9946#undef tos 9947 } 9948 while (0); 9949 /* SEND ( -- ) */ 9950 do 9951 { 9952 int sel = arg; 9953 int n = 2; 9954#define PREPARE_STACK() do { \ 9955 PUSH_OOP (_extra1); \ 9956 } while (0) 9957#line 643 "vm.def" 9958 PREPARE_STACK (); 9959 EXPORT_REGS (); 9960 SEND_MESSAGE (METHOD_LITERAL (sel), n); 9961 IMPORT_REGS (); 9962 FETCH; 9963 9964#line 9965 "vm.inl" 9965#undef PREPARE_STACK 9966 } 9967 while (0); 9968 PUSH_OOP (_extra1); 9969 } 9970 NEXT_BC; 9971bc208: 9972 { 9973 OOP _extra1, _extra2; 9974 /* PREFETCH ( -- ) */ 9975 do 9976 { 9977#line 207 "vm.def" 9978 PREFETCH; 9979 LOCAL_COUNTER++; 9980 9981#line 9982 "vm.inl" 9982 } 9983 while (0); 9984 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 9985 do 9986 { 9987 int n = 0; 9988#define tos _extra1 9989#line 683 "vm.def" 9990 tos = METHOD_TEMPORARY (n); 9991 9992#line 9993 "vm.inl" 9993#undef tos 9994 } 9995 while (0); 9996 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 9997 do 9998 { 9999 int n = 1; 10000#define tos _extra2 10001#line 683 "vm.def" 10002 tos = METHOD_TEMPORARY (n); 10003 10004#line 10005 "vm.inl" 10005#undef tos 10006 } 10007 while (0); 10008 /* SEND ( -- ) */ 10009 do 10010 { 10011 int sel = arg; 10012 int n = 2; 10013#define PREPARE_STACK() do { \ 10014 PUSH_OOP (_extra1); \ 10015 PUSH_OOP (_extra2); \ 10016 } while (0) 10017#line 643 "vm.def" 10018 PREPARE_STACK (); 10019 EXPORT_REGS (); 10020 SEND_MESSAGE (METHOD_LITERAL (sel), n); 10021 IMPORT_REGS (); 10022 FETCH; 10023 10024#line 10025 "vm.inl" 10025#undef PREPARE_STACK 10026 } 10027 while (0); 10028 PUSH_OOP (_extra1); 10029 PUSH_OOP (_extra2); 10030 } 10031 NEXT_BC; 10032bc209: 10033 { 10034 OOP _stack0; 10035 OOP _extra1; 10036 _stack0 = STACK_AT (0); 10037 /* PREFETCH ( -- ) */ 10038 do 10039 { 10040#line 207 "vm.def" 10041 PREFETCH; 10042 LOCAL_COUNTER++; 10043 10044#line 10045 "vm.inl" 10045 } 10046 while (0); 10047 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 10048 do 10049 { 10050 int n = arg; 10051#define tos _extra1 10052#line 683 "vm.def" 10053 tos = METHOD_TEMPORARY (n); 10054 10055#line 10056 "vm.inl" 10056#undef tos 10057 } 10058 while (0); 10059 /* POP_INTO_NEW_STACKTOP ( obj | val -- obj | ) */ 10060 do 10061 { 10062 int n = 0; 10063#define obj _stack0 10064#define val _extra1 10065#line 824 "vm.def" 10066 STORE_INSTANCE_VARIABLE (obj, n, val); 10067 10068#line 10069 "vm.inl" 10069#undef obj 10070#undef val 10071 } 10072 while (0); 10073 } 10074 NEXT_BC; 10075bc210: 10076 { 10077 OOP _extra1; 10078 /* PREFETCH ( -- ) */ 10079 do 10080 { 10081#line 207 "vm.def" 10082 PREFETCH; 10083 LOCAL_COUNTER++; 10084 10085#line 10086 "vm.inl" 10086 } 10087 while (0); 10088 /* PUSH_LIT_CONSTANT ( -- tos ) */ 10089 do 10090 { 10091 int n = arg; 10092#define tos _extra1 10093#line 820 "vm.def" 10094 tos = METHOD_LITERAL (n); 10095 10096#line 10097 "vm.inl" 10097#undef tos 10098 } 10099 while (0); 10100 /* MAKE_DIRTY_BLOCK ( block -- closure ) */ 10101 do 10102 { 10103#define block _extra1 10104#define closure _extra1 10105#line 831 "vm.def" 10106 EXPORT_REGS (); 10107 closure = _gst_make_block_closure (block); 10108 IMPORT_REGS(); 10109 10110#line 10111 "vm.inl" 10111#undef block 10112#undef closure 10113 } 10114 while (0); 10115 /* SEND ( -- ) */ 10116 do 10117 { 10118 int sel = 5; 10119 int n = 1; 10120#define PREPARE_STACK() do { \ 10121 PUSH_OOP (_extra1); \ 10122 } while (0) 10123#line 643 "vm.def" 10124 PREPARE_STACK (); 10125 EXPORT_REGS (); 10126 SEND_MESSAGE (METHOD_LITERAL (sel), n); 10127 IMPORT_REGS (); 10128 FETCH; 10129 10130#line 10131 "vm.inl" 10131#undef PREPARE_STACK 10132 } 10133 while (0); 10134 PUSH_OOP (_extra1); 10135 } 10136 NEXT_BC; 10137bc211: 10138 { 10139 /* PREFETCH ( -- ) */ 10140 do 10141 { 10142#line 207 "vm.def" 10143 PREFETCH; 10144 LOCAL_COUNTER++; 10145 10146#line 10147 "vm.inl" 10147 } 10148 while (0); 10149 /* SEND_SUPER ( -- ) */ 10150 do 10151 { 10152 int sel = arg; 10153 int n = 1; 10154#define PREPARE_STACK() do { \ 10155 } while (0) 10156#line 651 "vm.def" 10157 OOP classOOP; 10158 PREPARE_STACK (); 10159 classOOP = POP_OOP (); 10160 10161 EXPORT_REGS (); 10162 SEND_TO_SUPER (METHOD_LITERAL (sel), n, classOOP); 10163 IMPORT_REGS (); 10164 FETCH; 10165 10166#line 10167 "vm.inl" 10167#undef PREPARE_STACK 10168 } 10169 while (0); 10170 } 10171 NEXT_BC; 10172bc212: 10173 { 10174 OOP _extra1; 10175 /* PREFETCH ( -- ) */ 10176 do 10177 { 10178#line 207 "vm.def" 10179 PREFETCH; 10180 LOCAL_COUNTER++; 10181 10182#line 10183 "vm.inl" 10183 } 10184 while (0); 10185 /* PUSH_LIT_CONSTANT ( -- tos ) */ 10186 do 10187 { 10188 int n = arg; 10189#define tos _extra1 10190#line 820 "vm.def" 10191 tos = METHOD_LITERAL (n); 10192 10193#line 10194 "vm.inl" 10194#undef tos 10195 } 10196 while (0); 10197 /* MAKE_DIRTY_BLOCK ( block -- closure ) */ 10198 do 10199 { 10200#define block _extra1 10201#define closure _extra1 10202#line 831 "vm.def" 10203 EXPORT_REGS (); 10204 closure = _gst_make_block_closure (block); 10205 IMPORT_REGS(); 10206 10207#line 10208 "vm.inl" 10208#undef block 10209#undef closure 10210 } 10211 while (0); 10212 /* SEND ( -- ) */ 10213 do 10214 { 10215 int sel = 4; 10216 int n = 1; 10217#define PREPARE_STACK() do { \ 10218 PUSH_OOP (_extra1); \ 10219 } while (0) 10220#line 643 "vm.def" 10221 PREPARE_STACK (); 10222 EXPORT_REGS (); 10223 SEND_MESSAGE (METHOD_LITERAL (sel), n); 10224 IMPORT_REGS (); 10225 FETCH; 10226 10227#line 10228 "vm.inl" 10228#undef PREPARE_STACK 10229 } 10230 while (0); 10231 PUSH_OOP (_extra1); 10232 } 10233 NEXT_BC; 10234bc213: 10235 { 10236 OOP _extra1; 10237 /* PREFETCH ( -- ) */ 10238 do 10239 { 10240#line 207 "vm.def" 10241 PREFETCH; 10242 LOCAL_COUNTER++; 10243 10244#line 10245 "vm.inl" 10245 } 10246 while (0); 10247 /* PUSH_RECEIVER_VARIABLE ( -- tos ) */ 10248 do 10249 { 10250 int n = 1; 10251#define tos _extra1 10252#line 718 "vm.def" 10253 tos = RECEIVER_VARIABLE (n); 10254 10255#line 10256 "vm.inl" 10256#undef tos 10257 } 10258 while (0); 10259 /* SEND_IMMEDIATE ( -- ) */ 10260 do 10261 { 10262 int n = arg; 10263#define PREPARE_STACK() do { \ 10264 PUSH_OOP (_extra1); \ 10265 } while (0) 10266#line 662 "vm.def" 10267 const struct builtin_selector *bs = &_gst_builtin_selectors[n]; 10268 PREPARE_STACK (); 10269 EXPORT_REGS (); 10270 SEND_MESSAGE (bs->symbol, bs->numArgs); 10271 IMPORT_REGS (); 10272 FETCH; 10273 10274#line 10275 "vm.inl" 10275#undef PREPARE_STACK 10276 } 10277 while (0); 10278 PUSH_OOP (_extra1); 10279 } 10280 NEXT_BC; 10281bc214: 10282 { 10283 OOP _stack0; 10284 _stack0 = STACK_AT (0); 10285 /* PREFETCH ( -- ) */ 10286 do 10287 { 10288#line 207 "vm.def" 10289 PREFETCH; 10290 LOCAL_COUNTER++; 10291 10292#line 10293 "vm.inl" 10293 } 10294 while (0); 10295 /* STORE_OUTER_TEMP ( tos | -- tos | ) */ 10296 do 10297 { 10298 int n = arg; 10299 int scopes = 1; 10300#define tos _stack0 10301#line 726 "vm.def" 10302 OOP contextOOP; 10303 gst_block_context context; 10304 10305 context = (gst_block_context) OOP_TO_OBJ (_gst_this_context_oop); 10306 do 10307 { 10308 contextOOP = context->outerContext; 10309 context = (gst_block_context) OOP_TO_OBJ (contextOOP); 10310 } 10311 while (--scopes); 10312 10313 context->contextStack[n] = tos; 10314 10315#line 10316 "vm.inl" 10316#undef tos 10317 } 10318 while (0); 10319 /* RETURN_CONTEXT_STACK_TOP ( val | -- val | ) */ 10320 do 10321 { 10322#define val _stack0 10323#line 852 "vm.def" 10324 EXPORT_REGS (); 10325 unwind_context (); 10326 IMPORT_REGS (); 10327 SET_STACKTOP (val); 10328 FETCH; 10329 10330#line 10331 "vm.inl" 10331#undef val 10332 } 10333 while (0); 10334 } 10335 NEXT_BC; 10336bc215: 10337 { 10338 OOP _stack0; 10339 _stack0 = STACK_AT (0); 10340 /* PREFETCH ( -- ) */ 10341 do 10342 { 10343#line 207 "vm.def" 10344 PREFETCH; 10345 LOCAL_COUNTER++; 10346 10347#line 10348 "vm.inl" 10348 } 10349 while (0); 10350 /* POP_STACK_TOP ( tos -- ) */ 10351 do 10352 { 10353#define tos _stack0 10354#line 828 "vm.def" 10355 10356#line 10357 "vm.inl" 10357#undef tos 10358 } 10359 while (0); 10360 /* LINE_NUMBER_BYTECODE ( -- ) */ 10361 do 10362 { 10363#line 890 "vm.def" 10364 10365#line 10366 "vm.inl" 10366 } 10367 while (0); 10368 /* SEND_IMMEDIATE ( -- ) */ 10369 do 10370 { 10371 int n = 37; 10372#define PREPARE_STACK() do { \ 10373 POP_N_OOPS (1); \ 10374 } while (0) 10375#line 662 "vm.def" 10376 const struct builtin_selector *bs = &_gst_builtin_selectors[n]; 10377 PREPARE_STACK (); 10378 EXPORT_REGS (); 10379 SEND_MESSAGE (bs->symbol, bs->numArgs); 10380 IMPORT_REGS (); 10381 FETCH; 10382 10383#line 10384 "vm.inl" 10384#undef PREPARE_STACK 10385 } 10386 while (0); 10387 POP_N_OOPS (1); 10388 } 10389 NEXT_BC; 10390bc216: 10391 { 10392 OOP _extra1; 10393 /* PREFETCH ( -- ) */ 10394 do 10395 { 10396#line 207 "vm.def" 10397 PREFETCH; 10398 LOCAL_COUNTER++; 10399 10400#line 10401 "vm.inl" 10401 } 10402 while (0); 10403 /* LINE_NUMBER_BYTECODE ( -- ) */ 10404 do 10405 { 10406#line 890 "vm.def" 10407 10408#line 10409 "vm.inl" 10409 } 10410 while (0); 10411 /* PUSH_SELF ( -- tos ) */ 10412 do 10413 { 10414#define tos _extra1 10415#line 893 "vm.def" 10416 tos = _gst_self; 10417 10418#line 10419 "vm.inl" 10419#undef tos 10420 } 10421 while (0); 10422 /* CLASS_SPECIAL ( rec -- val ) */ 10423 do 10424 { 10425#define PREPARE_STACK() do { \ 10426 PUSH_OOP (_extra1); \ 10427 } while (0) 10428#define rec _extra1 10429#define val _extra1 10430#line 543 "vm.def" 10431 OOP classOOP; 10432 PREPARE_STACK (); 10433 EXPORT_REGS (); 10434 if UNCOMMON (IS_INT (rec)) 10435 { 10436 SEND_MESSAGE (_gst_builtin_selectors[CLASS_SPECIAL].symbol, 0); 10437 IMPORT_REGS (); 10438 FETCH; 10439 } 10440 10441 if COMMON (class_cache_class == (classOOP = OOP_CLASS (rec)) 10442 && !execute_primitive_operation (class_cache_prim, 1)) 10443 { 10444 IMPORT_REGS (); 10445 NEXT_BC; 10446 } 10447 10448 /* Not the same class that is in the cache, or the primitive failed -- 10449 send the message, and modify the cache if the send is resolved to 10450 a primitive. */ 10451 last_primitive = 0; 10452 SEND_MESSAGE (_gst_builtin_selectors[CLASS_SPECIAL].symbol, 0); 10453 IMPORT_REGS (); 10454 if COMMON (last_primitive) 10455 { 10456 class_cache_prim = last_primitive; 10457 class_cache_class = classOOP; 10458 NEXT_BC; 10459 } 10460 FETCH; 10461 10462#line 10463 "vm.inl" 10463#undef PREPARE_STACK 10464#undef rec 10465#undef val 10466 } 10467 while (0); 10468 PUSH_OOP (_extra1); 10469 } 10470 NEXT_BC; 10471bc217: 10472 { 10473 OOP _extra1; 10474 /* PREFETCH ( -- ) */ 10475 do 10476 { 10477#line 207 "vm.def" 10478 PREFETCH; 10479 LOCAL_COUNTER++; 10480 10481#line 10482 "vm.inl" 10482 } 10483 while (0); 10484 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 10485 do 10486 { 10487 int n = 1; 10488#define tos _extra1 10489#line 683 "vm.def" 10490 tos = METHOD_TEMPORARY (n); 10491 10492#line 10493 "vm.inl" 10493#undef tos 10494 } 10495 while (0); 10496 /* SEND ( -- ) */ 10497 do 10498 { 10499 int sel = arg; 10500 int n = 0; 10501#define PREPARE_STACK() do { \ 10502 PUSH_OOP (_extra1); \ 10503 } while (0) 10504#line 643 "vm.def" 10505 PREPARE_STACK (); 10506 EXPORT_REGS (); 10507 SEND_MESSAGE (METHOD_LITERAL (sel), n); 10508 IMPORT_REGS (); 10509 FETCH; 10510 10511#line 10512 "vm.inl" 10512#undef PREPARE_STACK 10513 } 10514 while (0); 10515 PUSH_OOP (_extra1); 10516 } 10517 NEXT_BC; 10518bc218: 10519 { 10520 OOP _extra1; 10521 /* PREFETCH ( -- ) */ 10522 do 10523 { 10524#line 207 "vm.def" 10525 PREFETCH; 10526 LOCAL_COUNTER++; 10527 10528#line 10529 "vm.inl" 10529 } 10530 while (0); 10531 /* LINE_NUMBER_BYTECODE ( -- ) */ 10532 do 10533 { 10534#line 890 "vm.def" 10535 10536#line 10537 "vm.inl" 10537 } 10538 while (0); 10539 /* PUSH_SELF ( -- tos ) */ 10540 do 10541 { 10542#define tos _extra1 10543#line 893 "vm.def" 10544 tos = _gst_self; 10545 10546#line 10547 "vm.inl" 10547#undef tos 10548 } 10549 while (0); 10550 /* SEND_IMMEDIATE ( -- ) */ 10551 do 10552 { 10553 int n = 130; 10554#define PREPARE_STACK() do { \ 10555 PUSH_OOP (_extra1); \ 10556 } while (0) 10557#line 662 "vm.def" 10558 const struct builtin_selector *bs = &_gst_builtin_selectors[n]; 10559 PREPARE_STACK (); 10560 EXPORT_REGS (); 10561 SEND_MESSAGE (bs->symbol, bs->numArgs); 10562 IMPORT_REGS (); 10563 FETCH; 10564 10565#line 10566 "vm.inl" 10566#undef PREPARE_STACK 10567 } 10568 while (0); 10569 PUSH_OOP (_extra1); 10570 } 10571 NEXT_BC; 10572bc219: 10573 { 10574 OOP _extra1; 10575 /* PREFETCH ( -- ) */ 10576 do 10577 { 10578#line 207 "vm.def" 10579 PREFETCH; 10580 LOCAL_COUNTER++; 10581 10582#line 10583 "vm.inl" 10583 } 10584 while (0); 10585 /* PUSH_RECEIVER_VARIABLE ( -- tos ) */ 10586 do 10587 { 10588 int n = 0; 10589#define tos _extra1 10590#line 718 "vm.def" 10591 tos = RECEIVER_VARIABLE (n); 10592 10593#line 10594 "vm.inl" 10594#undef tos 10595 } 10596 while (0); 10597 /* SEND_IMMEDIATE ( -- ) */ 10598 do 10599 { 10600 int n = arg; 10601#define PREPARE_STACK() do { \ 10602 PUSH_OOP (_extra1); \ 10603 } while (0) 10604#line 662 "vm.def" 10605 const struct builtin_selector *bs = &_gst_builtin_selectors[n]; 10606 PREPARE_STACK (); 10607 EXPORT_REGS (); 10608 SEND_MESSAGE (bs->symbol, bs->numArgs); 10609 IMPORT_REGS (); 10610 FETCH; 10611 10612#line 10613 "vm.inl" 10613#undef PREPARE_STACK 10614 } 10615 while (0); 10616 PUSH_OOP (_extra1); 10617 } 10618 NEXT_BC; 10619bc220: 10620 { 10621 OOP _extra1, _extra2; 10622 /* PREFETCH ( -- ) */ 10623 do 10624 { 10625#line 207 "vm.def" 10626 PREFETCH; 10627 LOCAL_COUNTER++; 10628 10629#line 10630 "vm.inl" 10630 } 10631 while (0); 10632 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 10633 do 10634 { 10635 int n = 0; 10636#define tos _extra1 10637#line 683 "vm.def" 10638 tos = METHOD_TEMPORARY (n); 10639 10640#line 10641 "vm.inl" 10641#undef tos 10642 } 10643 while (0); 10644 /* PUSH_LIT_VARIABLE ( -- tos ) */ 10645 do 10646 { 10647 int n = arg; 10648#define PREPARE_STACK() do { \ 10649 PUSH_OOP (_extra1); \ 10650 } while (0) 10651#define tos _extra2 10652#line 702 "vm.def" 10653 tos = METHOD_LITERAL (n); 10654 if (UNCOMMON (IS_INT (tos)) 10655 || UNCOMMON (!is_a_kind_of (OOP_CLASS (tos), _gst_association_class))) 10656 { 10657 PREPARE_STACK (); 10658 PUSH_OOP (tos); 10659 EXPORT_REGS (); 10660 SEND_MESSAGE (_gst_builtin_selectors[VALUE_SPECIAL].symbol, 0); 10661 IMPORT_REGS (); 10662 FETCH; 10663 } 10664 else 10665 tos = ASSOCIATION_VALUE (tos); 10666 10667#line 10668 "vm.inl" 10668#undef PREPARE_STACK 10669#undef tos 10670 } 10671 while (0); 10672 PUSH_OOP (_extra1); 10673 PUSH_OOP (_extra2); 10674 } 10675 NEXT_BC; 10676bc221: 10677 { 10678 OOP _stack0; 10679 _stack0 = STACK_AT (0); 10680 /* PREFETCH ( -- ) */ 10681 do 10682 { 10683#line 207 "vm.def" 10684 PREFETCH; 10685 LOCAL_COUNTER++; 10686 10687#line 10688 "vm.inl" 10688 } 10689 while (0); 10690 /* STORE_TEMPORARY_VARIABLE ( tos | -- tos | ) */ 10691 do 10692 { 10693 int n = 0; 10694#define tos _stack0 10695#line 722 "vm.def" 10696 STORE_METHOD_TEMPORARY (n, tos); 10697 10698#line 10699 "vm.inl" 10699#undef tos 10700 } 10701 while (0); 10702 /* LINE_NUMBER_BYTECODE ( -- ) */ 10703 do 10704 { 10705#line 890 "vm.def" 10706 10707#line 10708 "vm.inl" 10708 } 10709 while (0); 10710 } 10711 NEXT_BC; 10712bc222: 10713 { 10714 OOP _extra1; 10715 /* PREFETCH ( -- ) */ 10716 do 10717 { 10718#line 207 "vm.def" 10719 PREFETCH; 10720 LOCAL_COUNTER++; 10721 10722#line 10723 "vm.inl" 10723 } 10724 while (0); 10725 /* PUSH_RECEIVER_VARIABLE ( -- tos ) */ 10726 do 10727 { 10728 int n = 2; 10729#define tos _extra1 10730#line 718 "vm.def" 10731 tos = RECEIVER_VARIABLE (n); 10732 10733#line 10734 "vm.inl" 10734#undef tos 10735 } 10736 while (0); 10737 /* SEND_IMMEDIATE ( -- ) */ 10738 do 10739 { 10740 int n = arg; 10741#define PREPARE_STACK() do { \ 10742 PUSH_OOP (_extra1); \ 10743 } while (0) 10744#line 662 "vm.def" 10745 const struct builtin_selector *bs = &_gst_builtin_selectors[n]; 10746 PREPARE_STACK (); 10747 EXPORT_REGS (); 10748 SEND_MESSAGE (bs->symbol, bs->numArgs); 10749 IMPORT_REGS (); 10750 FETCH; 10751 10752#line 10753 "vm.inl" 10753#undef PREPARE_STACK 10754 } 10755 while (0); 10756 PUSH_OOP (_extra1); 10757 } 10758 NEXT_BC; 10759bc223: 10760 { 10761 OOP _extra1; 10762 /* PREFETCH ( -- ) */ 10763 do 10764 { 10765#line 207 "vm.def" 10766 PREFETCH; 10767 LOCAL_COUNTER++; 10768 10769#line 10770 "vm.inl" 10770 } 10771 while (0); 10772 /* LINE_NUMBER_BYTECODE ( -- ) */ 10773 do 10774 { 10775#line 890 "vm.def" 10776 10777#line 10778 "vm.inl" 10778 } 10779 while (0); 10780 /* PUSH_SELF ( -- tos ) */ 10781 do 10782 { 10783#define tos _extra1 10784#line 893 "vm.def" 10785 tos = _gst_self; 10786 10787#line 10788 "vm.inl" 10788#undef tos 10789 } 10790 while (0); 10791 /* SEND ( -- ) */ 10792 do 10793 { 10794 int sel = 2; 10795 int n = 0; 10796#define PREPARE_STACK() do { \ 10797 PUSH_OOP (_extra1); \ 10798 } while (0) 10799#line 643 "vm.def" 10800 PREPARE_STACK (); 10801 EXPORT_REGS (); 10802 SEND_MESSAGE (METHOD_LITERAL (sel), n); 10803 IMPORT_REGS (); 10804 FETCH; 10805 10806#line 10807 "vm.inl" 10807#undef PREPARE_STACK 10808 } 10809 while (0); 10810 PUSH_OOP (_extra1); 10811 } 10812 NEXT_BC; 10813bc224: 10814 { 10815 OOP _stack0; 10816 _stack0 = STACK_AT (0); 10817 /* PREFETCH ( -- ) */ 10818 do 10819 { 10820#line 207 "vm.def" 10821 PREFETCH; 10822 LOCAL_COUNTER++; 10823 10824#line 10825 "vm.inl" 10825 } 10826 while (0); 10827 /* LINE_NUMBER_BYTECODE ( -- ) */ 10828 do 10829 { 10830#line 890 "vm.def" 10831 10832#line 10833 "vm.inl" 10833 } 10834 while (0); 10835 /* POP_STACK_TOP ( tos -- ) */ 10836 do 10837 { 10838#define tos _stack0 10839#line 828 "vm.def" 10840 10841#line 10842 "vm.inl" 10842#undef tos 10843 } 10844 while (0); 10845 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 10846 do 10847 { 10848 int n = 2; 10849#define tos _stack0 10850#line 683 "vm.def" 10851 tos = METHOD_TEMPORARY (n); 10852 10853#line 10854 "vm.inl" 10854#undef tos 10855 } 10856 while (0); 10857 STACK_AT (0) = _stack0; 10858 } 10859 NEXT_BC; 10860bc225: 10861 { 10862 OOP _extra1; 10863 /* PREFETCH ( -- ) */ 10864 do 10865 { 10866#line 207 "vm.def" 10867 PREFETCH; 10868 LOCAL_COUNTER++; 10869 10870#line 10871 "vm.inl" 10871 } 10872 while (0); 10873 /* PUSH_LIT_CONSTANT ( -- tos ) */ 10874 do 10875 { 10876 int n = arg; 10877#define tos _extra1 10878#line 820 "vm.def" 10879 tos = METHOD_LITERAL (n); 10880 10881#line 10882 "vm.inl" 10882#undef tos 10883 } 10884 while (0); 10885 /* MAKE_DIRTY_BLOCK ( block -- closure ) */ 10886 do 10887 { 10888#define block _extra1 10889#define closure _extra1 10890#line 831 "vm.def" 10891 EXPORT_REGS (); 10892 closure = _gst_make_block_closure (block); 10893 IMPORT_REGS(); 10894 10895#line 10896 "vm.inl" 10896#undef block 10897#undef closure 10898 } 10899 while (0); 10900 /* SEND ( -- ) */ 10901 do 10902 { 10903 int sel = 6; 10904 int n = 1; 10905#define PREPARE_STACK() do { \ 10906 PUSH_OOP (_extra1); \ 10907 } while (0) 10908#line 643 "vm.def" 10909 PREPARE_STACK (); 10910 EXPORT_REGS (); 10911 SEND_MESSAGE (METHOD_LITERAL (sel), n); 10912 IMPORT_REGS (); 10913 FETCH; 10914 10915#line 10916 "vm.inl" 10916#undef PREPARE_STACK 10917 } 10918 while (0); 10919 PUSH_OOP (_extra1); 10920 } 10921 NEXT_BC; 10922bc226: 10923 { 10924 OOP _extra1; 10925 /* PREFETCH ( -- ) */ 10926 do 10927 { 10928#line 207 "vm.def" 10929 PREFETCH; 10930 LOCAL_COUNTER++; 10931 10932#line 10933 "vm.inl" 10933 } 10934 while (0); 10935 /* PUSH_SPECIAL ( -- tos ) */ 10936 do 10937 { 10938 int n = arg; 10939#define tos _extra1 10940#line 816 "vm.def" 10941 tos = _gst_nil_oop + (n - NIL_INDEX); 10942 10943#line 10944 "vm.inl" 10944#undef tos 10945 } 10946 while (0); 10947 /* RETURN_METHOD_STACK_TOP ( val | -- val | ) */ 10948 do 10949 { 10950#define val _extra1 10951#line 837 "vm.def" 10952 EXPORT_REGS (); 10953 if UNCOMMON (!unwind_method ()) 10954 { 10955 SEND_MESSAGE (_gst_bad_return_error_symbol, 0); 10956 IMPORT_REGS (); 10957 } 10958 else 10959 { 10960 IMPORT_REGS (); 10961 SET_STACKTOP (val); 10962 } 10963 FETCH; 10964 10965#line 10966 "vm.inl" 10966#undef val 10967 } 10968 while (0); 10969 PUSH_OOP (_extra1); 10970 } 10971 NEXT_BC; 10972bc227: 10973 { 10974 OOP _stack0; 10975 OOP _extra1; 10976 _stack0 = STACK_AT (0); 10977 /* PREFETCH ( -- ) */ 10978 do 10979 { 10980#line 207 "vm.def" 10981 PREFETCH; 10982 LOCAL_COUNTER++; 10983 10984#line 10985 "vm.inl" 10985 } 10986 while (0); 10987 /* PUSH_INTEGER ( -- tos ) */ 10988 do 10989 { 10990 int n = arg; 10991#define tos _extra1 10992#line 812 "vm.def" 10993 tos = FROM_INT (n); 10994 10995#line 10996 "vm.inl" 10996#undef tos 10997 } 10998 while (0); 10999 /* GREATER_EQUAL_SPECIAL ( op1 op2 -- op ) */ 11000 do 11001 { 11002#define PREPARE_STACK() do { \ 11003 PUSH_OOP (_extra1); \ 11004 } while (0) 11005#define op1 _stack0 11006#define op2 _extra1 11007#define op _stack0 11008#line 279 "vm.def" 11009 PREPARE_STACK (); 11010 INTERP_BASIC_BOOL (op, op1, op2, >=); 11011 EXPORT_REGS (); 11012 SEND_MESSAGE (_gst_builtin_selectors[GREATER_EQUAL_SPECIAL].symbol, 1); 11013 IMPORT_REGS (); 11014 FETCH; 11015 11016#line 11017 "vm.inl" 11017#undef PREPARE_STACK 11018#undef op1 11019#undef op2 11020#undef op 11021 } 11022 while (0); 11023 STACK_AT (0) = _stack0; 11024 } 11025 NEXT_BC; 11026bc228: 11027 { 11028 OOP _stack0; 11029 _stack0 = STACK_AT (0); 11030 /* PREFETCH ( -- ) */ 11031 do 11032 { 11033#line 207 "vm.def" 11034 PREFETCH; 11035 LOCAL_COUNTER++; 11036 11037#line 11038 "vm.inl" 11038 } 11039 while (0); 11040 /* LINE_NUMBER_BYTECODE ( -- ) */ 11041 do 11042 { 11043#line 890 "vm.def" 11044 11045#line 11046 "vm.inl" 11046 } 11047 while (0); 11048 /* POP_STACK_TOP ( tos -- ) */ 11049 do 11050 { 11051#define tos _stack0 11052#line 828 "vm.def" 11053 11054#line 11055 "vm.inl" 11055#undef tos 11056 } 11057 while (0); 11058 /* PUSH_RECEIVER_VARIABLE ( -- tos ) */ 11059 do 11060 { 11061 int n = 1; 11062#define tos _stack0 11063#line 718 "vm.def" 11064 tos = RECEIVER_VARIABLE (n); 11065 11066#line 11067 "vm.inl" 11067#undef tos 11068 } 11069 while (0); 11070 STACK_AT (0) = _stack0; 11071 } 11072 NEXT_BC; 11073bc229: 11074 { 11075 OOP _extra1; 11076 /* PREFETCH ( -- ) */ 11077 do 11078 { 11079#line 207 "vm.def" 11080 PREFETCH; 11081 LOCAL_COUNTER++; 11082 11083#line 11084 "vm.inl" 11084 } 11085 while (0); 11086 /* LINE_NUMBER_BYTECODE ( -- ) */ 11087 do 11088 { 11089#line 890 "vm.def" 11090 11091#line 11092 "vm.inl" 11092 } 11093 while (0); 11094 /* PUSH_LIT_VARIABLE ( -- tos ) */ 11095 do 11096 { 11097 int n = 3; 11098#define PREPARE_STACK() do { \ 11099 } while (0) 11100#define tos _extra1 11101#line 702 "vm.def" 11102 tos = METHOD_LITERAL (n); 11103 if (UNCOMMON (IS_INT (tos)) 11104 || UNCOMMON (!is_a_kind_of (OOP_CLASS (tos), _gst_association_class))) 11105 { 11106 PREPARE_STACK (); 11107 PUSH_OOP (tos); 11108 EXPORT_REGS (); 11109 SEND_MESSAGE (_gst_builtin_selectors[VALUE_SPECIAL].symbol, 0); 11110 IMPORT_REGS (); 11111 FETCH; 11112 } 11113 else 11114 tos = ASSOCIATION_VALUE (tos); 11115 11116#line 11117 "vm.inl" 11117#undef PREPARE_STACK 11118#undef tos 11119 } 11120 while (0); 11121 PUSH_OOP (_extra1); 11122 } 11123 NEXT_BC; 11124bc230: 11125 { 11126 OOP _extra1; 11127 /* PREFETCH ( -- ) */ 11128 do 11129 { 11130#line 207 "vm.def" 11131 PREFETCH; 11132 LOCAL_COUNTER++; 11133 11134#line 11135 "vm.inl" 11135 } 11136 while (0); 11137 /* PUSH_LIT_CONSTANT ( -- tos ) */ 11138 do 11139 { 11140 int n = 2; 11141#define tos _extra1 11142#line 820 "vm.def" 11143 tos = METHOD_LITERAL (n); 11144 11145#line 11146 "vm.inl" 11146#undef tos 11147 } 11148 while (0); 11149 /* SEND_IMMEDIATE ( -- ) */ 11150 do 11151 { 11152 int n = arg; 11153#define PREPARE_STACK() do { \ 11154 PUSH_OOP (_extra1); \ 11155 } while (0) 11156#line 662 "vm.def" 11157 const struct builtin_selector *bs = &_gst_builtin_selectors[n]; 11158 PREPARE_STACK (); 11159 EXPORT_REGS (); 11160 SEND_MESSAGE (bs->symbol, bs->numArgs); 11161 IMPORT_REGS (); 11162 FETCH; 11163 11164#line 11165 "vm.inl" 11165#undef PREPARE_STACK 11166 } 11167 while (0); 11168 PUSH_OOP (_extra1); 11169 } 11170 NEXT_BC; 11171bc231: 11172 { 11173 /* PREFETCH ( -- ) */ 11174 do 11175 { 11176#line 207 "vm.def" 11177 PREFETCH; 11178 LOCAL_COUNTER++; 11179 11180#line 11181 "vm.inl" 11181 } 11182 while (0); 11183 /* SEND_SUPER ( -- ) */ 11184 do 11185 { 11186 int sel = arg; 11187 int n = 0; 11188#define PREPARE_STACK() do { \ 11189 } while (0) 11190#line 651 "vm.def" 11191 OOP classOOP; 11192 PREPARE_STACK (); 11193 classOOP = POP_OOP (); 11194 11195 EXPORT_REGS (); 11196 SEND_TO_SUPER (METHOD_LITERAL (sel), n, classOOP); 11197 IMPORT_REGS (); 11198 FETCH; 11199 11200#line 11201 "vm.inl" 11201#undef PREPARE_STACK 11202 } 11203 while (0); 11204 } 11205 NEXT_BC; 11206bc232: 11207 { 11208 OOP _extra1; 11209 /* PREFETCH ( -- ) */ 11210 do 11211 { 11212#line 207 "vm.def" 11213 PREFETCH; 11214 LOCAL_COUNTER++; 11215 11216#line 11217 "vm.inl" 11217 } 11218 while (0); 11219 /* PUSH_SPECIAL ( -- tos ) */ 11220 do 11221 { 11222 int n = 0; 11223#define tos _extra1 11224#line 816 "vm.def" 11225 tos = _gst_nil_oop + (n - NIL_INDEX); 11226 11227#line 11228 "vm.inl" 11228#undef tos 11229 } 11230 while (0); 11231 /* STORE_RECEIVER_VARIABLE ( tos | -- tos | ) */ 11232 do 11233 { 11234 int n = arg; 11235#define tos _extra1 11236#line 758 "vm.def" 11237 STORE_RECEIVER_VARIABLE (n, tos); 11238 11239#line 11240 "vm.inl" 11240#undef tos 11241 } 11242 while (0); 11243 PUSH_OOP (_extra1); 11244 } 11245 NEXT_BC; 11246bc233: 11247 { 11248 OOP _extra1, _extra2; 11249 /* PREFETCH ( -- ) */ 11250 do 11251 { 11252#line 207 "vm.def" 11253 PREFETCH; 11254 LOCAL_COUNTER++; 11255 11256#line 11257 "vm.inl" 11257 } 11258 while (0); 11259 /* PUSH_SELF ( -- tos ) */ 11260 do 11261 { 11262#define tos _extra1 11263#line 893 "vm.def" 11264 tos = _gst_self; 11265 11266#line 11267 "vm.inl" 11267#undef tos 11268 } 11269 while (0); 11270 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 11271 do 11272 { 11273 int n = arg; 11274#define tos _extra2 11275#line 683 "vm.def" 11276 tos = METHOD_TEMPORARY (n); 11277 11278#line 11279 "vm.inl" 11279#undef tos 11280 } 11281 while (0); 11282 /* SEND ( -- ) */ 11283 do 11284 { 11285 int sel = 0; 11286 int n = 1; 11287#define PREPARE_STACK() do { \ 11288 PUSH_OOP (_extra1); \ 11289 PUSH_OOP (_extra2); \ 11290 } while (0) 11291#line 643 "vm.def" 11292 PREPARE_STACK (); 11293 EXPORT_REGS (); 11294 SEND_MESSAGE (METHOD_LITERAL (sel), n); 11295 IMPORT_REGS (); 11296 FETCH; 11297 11298#line 11299 "vm.inl" 11299#undef PREPARE_STACK 11300 } 11301 while (0); 11302 PUSH_OOP (_extra1); 11303 PUSH_OOP (_extra2); 11304 } 11305 NEXT_BC; 11306bc234: 11307 { 11308 OOP _stack0; 11309 _stack0 = STACK_AT (0); 11310 /* PREFETCH ( -- ) */ 11311 do 11312 { 11313#line 207 "vm.def" 11314 PREFETCH; 11315 LOCAL_COUNTER++; 11316 11317#line 11318 "vm.inl" 11318 } 11319 while (0); 11320 /* LINE_NUMBER_BYTECODE ( -- ) */ 11321 do 11322 { 11323#line 890 "vm.def" 11324 11325#line 11326 "vm.inl" 11326 } 11327 while (0); 11328 /* POP_STACK_TOP ( tos -- ) */ 11329 do 11330 { 11331#define tos _stack0 11332#line 828 "vm.def" 11333 11334#line 11335 "vm.inl" 11335#undef tos 11336 } 11337 while (0); 11338 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 11339 do 11340 { 11341 int n = 0; 11342#define tos _stack0 11343#line 683 "vm.def" 11344 tos = METHOD_TEMPORARY (n); 11345 11346#line 11347 "vm.inl" 11347#undef tos 11348 } 11349 while (0); 11350 /* RETURN_CONTEXT_STACK_TOP ( val | -- val | ) */ 11351 do 11352 { 11353#define val _stack0 11354#line 852 "vm.def" 11355 EXPORT_REGS (); 11356 unwind_context (); 11357 IMPORT_REGS (); 11358 SET_STACKTOP (val); 11359 FETCH; 11360 11361#line 11362 "vm.inl" 11362#undef val 11363 } 11364 while (0); 11365 STACK_AT (0) = _stack0; 11366 } 11367 NEXT_BC; 11368bc235: 11369 { 11370 OOP _stack0; 11371 OOP _extra1; 11372 _stack0 = STACK_AT (0); 11373 /* PREFETCH ( -- ) */ 11374 do 11375 { 11376#line 207 "vm.def" 11377 PREFETCH; 11378 LOCAL_COUNTER++; 11379 11380#line 11381 "vm.inl" 11381 } 11382 while (0); 11383 /* PUSH_LIT_CONSTANT ( -- tos ) */ 11384 do 11385 { 11386 int n = arg; 11387#define tos _extra1 11388#line 820 "vm.def" 11389 tos = METHOD_LITERAL (n); 11390 11391#line 11392 "vm.inl" 11392#undef tos 11393 } 11394 while (0); 11395 /* SAME_OBJECT_SPECIAL ( op1 op2 -- op ) */ 11396 do 11397 { 11398#define op1 _stack0 11399#define op2 _extra1 11400#define op _stack0 11401#line 610 "vm.def" 11402 /* DO_JUMP_LOOKAHEAD (op1 == op2); */ 11403 op = (op1 == op2) ? _gst_true_oop : _gst_false_oop; 11404 11405#line 11406 "vm.inl" 11406#undef op1 11407#undef op2 11408#undef op 11409 } 11410 while (0); 11411 STACK_AT (0) = _stack0; 11412 } 11413 NEXT_BC; 11414bc236: 11415 { 11416 OOP _extra1; 11417 /* PREFETCH ( -- ) */ 11418 do 11419 { 11420#line 207 "vm.def" 11421 PREFETCH; 11422 LOCAL_COUNTER++; 11423 11424#line 11425 "vm.inl" 11425 } 11426 while (0); 11427 /* PUSH_LIT_CONSTANT ( -- tos ) */ 11428 do 11429 { 11430 int n = arg; 11431#define tos _extra1 11432#line 820 "vm.def" 11433 tos = METHOD_LITERAL (n); 11434 11435#line 11436 "vm.inl" 11436#undef tos 11437 } 11438 while (0); 11439 /* MAKE_DIRTY_BLOCK ( block -- closure ) */ 11440 do 11441 { 11442#define block _extra1 11443#define closure _extra1 11444#line 831 "vm.def" 11445 EXPORT_REGS (); 11446 closure = _gst_make_block_closure (block); 11447 IMPORT_REGS(); 11448 11449#line 11450 "vm.inl" 11450#undef block 11451#undef closure 11452 } 11453 while (0); 11454 /* SEND ( -- ) */ 11455 do 11456 { 11457 int sel = 1; 11458 int n = 1; 11459#define PREPARE_STACK() do { \ 11460 PUSH_OOP (_extra1); \ 11461 } while (0) 11462#line 643 "vm.def" 11463 PREPARE_STACK (); 11464 EXPORT_REGS (); 11465 SEND_MESSAGE (METHOD_LITERAL (sel), n); 11466 IMPORT_REGS (); 11467 FETCH; 11468 11469#line 11470 "vm.inl" 11470#undef PREPARE_STACK 11471 } 11472 while (0); 11473 PUSH_OOP (_extra1); 11474 } 11475 NEXT_BC; 11476bc237: 11477 { 11478 OOP _stack0; 11479 _stack0 = STACK_AT (0); 11480 /* PREFETCH ( -- ) */ 11481 do 11482 { 11483#line 207 "vm.def" 11484 PREFETCH; 11485 LOCAL_COUNTER++; 11486 11487#line 11488 "vm.inl" 11488 } 11489 while (0); 11490 /* LINE_NUMBER_BYTECODE ( -- ) */ 11491 do 11492 { 11493#line 890 "vm.def" 11494 11495#line 11496 "vm.inl" 11496 } 11497 while (0); 11498 /* POP_STACK_TOP ( tos -- ) */ 11499 do 11500 { 11501#define tos _stack0 11502#line 828 "vm.def" 11503 11504#line 11505 "vm.inl" 11505#undef tos 11506 } 11507 while (0); 11508 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 11509 do 11510 { 11511 int n = 3; 11512#define tos _stack0 11513#line 683 "vm.def" 11514 tos = METHOD_TEMPORARY (n); 11515 11516#line 11517 "vm.inl" 11517#undef tos 11518 } 11519 while (0); 11520 STACK_AT (0) = _stack0; 11521 } 11522 NEXT_BC; 11523bc238: 11524 { 11525 OOP _stack0, _stack1; 11526 _stack1 = STACK_AT (1); 11527 _stack0 = STACK_AT (0); 11528 /* PREFETCH ( -- ) */ 11529 do 11530 { 11531#line 207 "vm.def" 11532 PREFETCH; 11533 LOCAL_COUNTER++; 11534 11535#line 11536 "vm.inl" 11536 } 11537 while (0); 11538 /* POP_STACK_TOP ( tos -- ) */ 11539 do 11540 { 11541#define tos _stack0 11542#line 828 "vm.def" 11543 11544#line 11545 "vm.inl" 11545#undef tos 11546 } 11547 while (0); 11548 /* DUP_STACK_TOP ( tos | -- tos | tos2 ) */ 11549 do 11550 { 11551#define tos _stack1 11552#define tos2 _stack0 11553#line 860 "vm.def" 11554 tos2 = tos; 11555 11556#line 11557 "vm.inl" 11557#undef tos 11558#undef tos2 11559 } 11560 while (0); 11561 /* SEND_IMMEDIATE ( -- ) */ 11562 do 11563 { 11564 int n = arg; 11565#define PREPARE_STACK() do { \ 11566 STACK_AT (0) = _stack0; \ 11567 } while (0) 11568#line 662 "vm.def" 11569 const struct builtin_selector *bs = &_gst_builtin_selectors[n]; 11570 PREPARE_STACK (); 11571 EXPORT_REGS (); 11572 SEND_MESSAGE (bs->symbol, bs->numArgs); 11573 IMPORT_REGS (); 11574 FETCH; 11575 11576#line 11577 "vm.inl" 11577#undef PREPARE_STACK 11578 } 11579 while (0); 11580 STACK_AT (0) = _stack0; 11581 } 11582 NEXT_BC; 11583bc239: 11584 { 11585 OOP _stack0; 11586 OOP _extra1, _extra2; 11587 _stack0 = STACK_AT (0); 11588 /* PREFETCH ( -- ) */ 11589 do 11590 { 11591#line 207 "vm.def" 11592 PREFETCH; 11593 LOCAL_COUNTER++; 11594 11595#line 11596 "vm.inl" 11596 } 11597 while (0); 11598 /* PUSH_LIT_CONSTANT ( -- tos ) */ 11599 do 11600 { 11601 int n = arg; 11602#define tos _extra1 11603#line 820 "vm.def" 11604 tos = METHOD_LITERAL (n); 11605 11606#line 11607 "vm.inl" 11607#undef tos 11608 } 11609 while (0); 11610 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 11611 do 11612 { 11613 int n = 0; 11614#define tos _extra2 11615#line 683 "vm.def" 11616 tos = METHOD_TEMPORARY (n); 11617 11618#line 11619 "vm.inl" 11619#undef tos 11620 } 11621 while (0); 11622 /* AT_PUT_SPECIAL ( rec idx val -- res ) */ 11623 do 11624 { 11625#define PREPARE_STACK() do { \ 11626 PUSH_OOP (_extra1); \ 11627 PUSH_OOP (_extra2); \ 11628 } while (0) 11629#define rec _stack0 11630#define idx _extra1 11631#define val _extra2 11632#define res _stack0 11633#line 477 "vm.def" 11634 OOP classOOP; 11635 PREPARE_STACK (); 11636 EXPORT_REGS (); 11637 if UNCOMMON (IS_INT (rec)) 11638 { 11639 SEND_MESSAGE (_gst_builtin_selectors[AT_PUT_SPECIAL].symbol, 2); 11640 IMPORT_REGS (); 11641 FETCH; 11642 } 11643 11644 if COMMON (at_put_cache_class == (classOOP = OOP_CLASS (rec)) 11645 && !cached_index_oop_put_primitive (rec, idx, val, at_put_cache_spec)) 11646 { 11647 IMPORT_REGS (); 11648 NEXT_BC; 11649 } 11650 11651 /* Not the same class that is in the cache, or the primitive failed -- 11652 send the message, and modify the cache if the send is resolved to 11653 a primitive. */ 11654 last_primitive = 0; 11655 SEND_MESSAGE (_gst_builtin_selectors[AT_PUT_SPECIAL].symbol, 2); 11656 IMPORT_REGS (); 11657 if (_gst_primitive_table[last_primitive].id == 61) 11658 { 11659 at_put_cache_spec = CLASS_INSTANCE_SPEC (classOOP); 11660 at_put_cache_class = classOOP; 11661 NEXT_BC; 11662 } 11663 FETCH; 11664 11665#line 11666 "vm.inl" 11666#undef PREPARE_STACK 11667#undef rec 11668#undef idx 11669#undef val 11670#undef res 11671 } 11672 while (0); 11673 STACK_AT (0) = _stack0; 11674 } 11675 NEXT_BC; 11676bc240: 11677 { 11678 OOP _stack0; 11679 OOP _extra1, _extra2, _extra3; 11680 _stack0 = STACK_AT (0); 11681 /* PREFETCH ( -- ) */ 11682 do 11683 { 11684#line 207 "vm.def" 11685 PREFETCH; 11686 LOCAL_COUNTER++; 11687 11688#line 11689 "vm.inl" 11689 } 11690 while (0); 11691 /* DUP_STACK_TOP ( tos | -- tos | tos2 ) */ 11692 do 11693 { 11694#define tos _stack0 11695#define tos2 _extra1 11696#line 860 "vm.def" 11697 tos2 = tos; 11698 11699#line 11700 "vm.inl" 11700#undef tos 11701#undef tos2 11702 } 11703 while (0); 11704 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 11705 do 11706 { 11707 int n = arg; 11708#define tos _extra2 11709#line 683 "vm.def" 11710 tos = METHOD_TEMPORARY (n); 11711 11712#line 11713 "vm.inl" 11713#undef tos 11714 } 11715 while (0); 11716 /* PUSH_INTEGER ( -- tos ) */ 11717 do 11718 { 11719 int n = 1; 11720#define tos _extra3 11721#line 812 "vm.def" 11722 tos = FROM_INT (n); 11723 11724#line 11725 "vm.inl" 11725#undef tos 11726 } 11727 while (0); 11728 /* PLUS_SPECIAL ( op1 op2 -- op ) */ 11729 do 11730 { 11731#define PREPARE_STACK() do { \ 11732 PUSH_OOP (_extra1); \ 11733 PUSH_OOP (_extra2); \ 11734 PUSH_OOP (_extra3); \ 11735 } while (0) 11736#define op1 _extra2 11737#define op2 _extra3 11738#define op _extra2 11739#line 230 "vm.def" 11740 INTERP_BASIC_OP (op, op1, op2, 11741 add_with_check (op1, op2, &overflow), 11742 farg1 + farg2); 11743 PREPARE_STACK (); 11744 EXPORT_REGS (); 11745 SEND_MESSAGE (_gst_builtin_selectors[PLUS_SPECIAL].symbol, 1); 11746 IMPORT_REGS (); 11747 FETCH; 11748 11749#line 11750 "vm.inl" 11750#undef PREPARE_STACK 11751#undef op1 11752#undef op2 11753#undef op 11754 } 11755 while (0); 11756 PUSH_OOP (_extra1); 11757 PUSH_OOP (_extra2); 11758 } 11759 NEXT_BC; 11760bc241: 11761 { 11762 OOP _extra1; 11763 /* PREFETCH ( -- ) */ 11764 do 11765 { 11766#line 207 "vm.def" 11767 PREFETCH; 11768 LOCAL_COUNTER++; 11769 11770#line 11771 "vm.inl" 11771 } 11772 while (0); 11773 /* LINE_NUMBER_BYTECODE ( -- ) */ 11774 do 11775 { 11776#line 890 "vm.def" 11777 11778#line 11779 "vm.inl" 11779 } 11780 while (0); 11781 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 11782 do 11783 { 11784 int n = 4; 11785#define tos _extra1 11786#line 683 "vm.def" 11787 tos = METHOD_TEMPORARY (n); 11788 11789#line 11790 "vm.inl" 11790#undef tos 11791 } 11792 while (0); 11793 PUSH_OOP (_extra1); 11794 } 11795 NEXT_BC; 11796bc242: 11797 { 11798 OOP _stack0; 11799 _stack0 = STACK_AT (0); 11800 /* PREFETCH ( -- ) */ 11801 do 11802 { 11803#line 207 "vm.def" 11804 PREFETCH; 11805 LOCAL_COUNTER++; 11806 11807#line 11808 "vm.inl" 11808 } 11809 while (0); 11810 /* POP_STACK_TOP ( tos -- ) */ 11811 do 11812 { 11813#define tos _stack0 11814#line 828 "vm.def" 11815 11816#line 11817 "vm.inl" 11817#undef tos 11818 } 11819 while (0); 11820 /* LINE_NUMBER_BYTECODE ( -- ) */ 11821 do 11822 { 11823#line 890 "vm.def" 11824 11825#line 11826 "vm.inl" 11826 } 11827 while (0); 11828 /* PUSH_LIT_VARIABLE ( -- tos ) */ 11829 do 11830 { 11831 int n = 1; 11832#define PREPARE_STACK() do { \ 11833 POP_N_OOPS (1); \ 11834 } while (0) 11835#define tos _stack0 11836#line 702 "vm.def" 11837 tos = METHOD_LITERAL (n); 11838 if (UNCOMMON (IS_INT (tos)) 11839 || UNCOMMON (!is_a_kind_of (OOP_CLASS (tos), _gst_association_class))) 11840 { 11841 PREPARE_STACK (); 11842 PUSH_OOP (tos); 11843 EXPORT_REGS (); 11844 SEND_MESSAGE (_gst_builtin_selectors[VALUE_SPECIAL].symbol, 0); 11845 IMPORT_REGS (); 11846 FETCH; 11847 } 11848 else 11849 tos = ASSOCIATION_VALUE (tos); 11850 11851#line 11852 "vm.inl" 11852#undef PREPARE_STACK 11853#undef tos 11854 } 11855 while (0); 11856 STACK_AT (0) = _stack0; 11857 } 11858 NEXT_BC; 11859bc243: 11860 { 11861 OOP _stack0; 11862 OOP _extra1, _extra2; 11863 _stack0 = STACK_AT (0); 11864 /* PREFETCH ( -- ) */ 11865 do 11866 { 11867#line 207 "vm.def" 11868 PREFETCH; 11869 LOCAL_COUNTER++; 11870 11871#line 11872 "vm.inl" 11872 } 11873 while (0); 11874 /* DUP_STACK_TOP ( tos | -- tos | tos2 ) */ 11875 do 11876 { 11877#define tos _stack0 11878#define tos2 _extra1 11879#line 860 "vm.def" 11880 tos2 = tos; 11881 11882#line 11883 "vm.inl" 11883#undef tos 11884#undef tos2 11885 } 11886 while (0); 11887 /* PUSH_LIT_CONSTANT ( -- tos ) */ 11888 do 11889 { 11890 int n = arg; 11891#define tos _extra2 11892#line 820 "vm.def" 11893 tos = METHOD_LITERAL (n); 11894 11895#line 11896 "vm.inl" 11896#undef tos 11897 } 11898 while (0); 11899 /* SEND ( -- ) */ 11900 do 11901 { 11902 int sel = 1; 11903 int n = 1; 11904#define PREPARE_STACK() do { \ 11905 PUSH_OOP (_extra1); \ 11906 PUSH_OOP (_extra2); \ 11907 } while (0) 11908#line 643 "vm.def" 11909 PREPARE_STACK (); 11910 EXPORT_REGS (); 11911 SEND_MESSAGE (METHOD_LITERAL (sel), n); 11912 IMPORT_REGS (); 11913 FETCH; 11914 11915#line 11916 "vm.inl" 11916#undef PREPARE_STACK 11917 } 11918 while (0); 11919 PUSH_OOP (_extra1); 11920 PUSH_OOP (_extra2); 11921 } 11922 NEXT_BC; 11923bc244: 11924 { 11925 OOP _stack0, _stack1; 11926 _stack1 = STACK_AT (1); 11927 _stack0 = STACK_AT (0); 11928 /* PREFETCH ( -- ) */ 11929 do 11930 { 11931#line 207 "vm.def" 11932 PREFETCH; 11933 LOCAL_COUNTER++; 11934 11935#line 11936 "vm.inl" 11936 } 11937 while (0); 11938 /* POP_INTO_NEW_STACKTOP ( obj | val -- obj | ) */ 11939 do 11940 { 11941 int n = 1; 11942#define obj _stack1 11943#define val _stack0 11944#line 824 "vm.def" 11945 STORE_INSTANCE_VARIABLE (obj, n, val); 11946 11947#line 11948 "vm.inl" 11948#undef obj 11949#undef val 11950 } 11951 while (0); 11952 /* SEND ( -- ) */ 11953 do 11954 { 11955 int sel = arg; 11956 int n = 1; 11957#define PREPARE_STACK() do { \ 11958 POP_N_OOPS (1); \ 11959 } while (0) 11960#line 643 "vm.def" 11961 PREPARE_STACK (); 11962 EXPORT_REGS (); 11963 SEND_MESSAGE (METHOD_LITERAL (sel), n); 11964 IMPORT_REGS (); 11965 FETCH; 11966 11967#line 11968 "vm.inl" 11968#undef PREPARE_STACK 11969 } 11970 while (0); 11971 POP_N_OOPS (1); 11972 } 11973 NEXT_BC; 11974bc245: 11975 { 11976 OOP _stack0; 11977 _stack0 = STACK_AT (0); 11978 /* PREFETCH ( -- ) */ 11979 do 11980 { 11981#line 207 "vm.def" 11982 PREFETCH; 11983 LOCAL_COUNTER++; 11984 11985#line 11986 "vm.inl" 11986 } 11987 while (0); 11988 /* LINE_NUMBER_BYTECODE ( -- ) */ 11989 do 11990 { 11991#line 890 "vm.def" 11992 11993#line 11994 "vm.inl" 11994 } 11995 while (0); 11996 /* POP_STACK_TOP ( tos -- ) */ 11997 do 11998 { 11999#define tos _stack0 12000#line 828 "vm.def" 12001 12002#line 12003 "vm.inl" 12003#undef tos 12004 } 12005 while (0); 12006 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 12007 do 12008 { 12009 int n = 1; 12010#define tos _stack0 12011#line 683 "vm.def" 12012 tos = METHOD_TEMPORARY (n); 12013 12014#line 12015 "vm.inl" 12015#undef tos 12016 } 12017 while (0); 12018 /* RETURN_CONTEXT_STACK_TOP ( val | -- val | ) */ 12019 do 12020 { 12021#define val _stack0 12022#line 852 "vm.def" 12023 EXPORT_REGS (); 12024 unwind_context (); 12025 IMPORT_REGS (); 12026 SET_STACKTOP (val); 12027 FETCH; 12028 12029#line 12030 "vm.inl" 12030#undef val 12031 } 12032 while (0); 12033 STACK_AT (0) = _stack0; 12034 } 12035 NEXT_BC; 12036bc246: 12037 { 12038 OOP _stack0; 12039 _stack0 = STACK_AT (0); 12040 /* PREFETCH ( -- ) */ 12041 do 12042 { 12043#line 207 "vm.def" 12044 PREFETCH; 12045 LOCAL_COUNTER++; 12046 12047#line 12048 "vm.inl" 12048 } 12049 while (0); 12050 /* STORE_TEMPORARY_VARIABLE ( tos | -- tos | ) */ 12051 do 12052 { 12053 int n = 3; 12054#define tos _stack0 12055#line 722 "vm.def" 12056 STORE_METHOD_TEMPORARY (n, tos); 12057 12058#line 12059 "vm.inl" 12059#undef tos 12060 } 12061 while (0); 12062 /* LINE_NUMBER_BYTECODE ( -- ) */ 12063 do 12064 { 12065#line 890 "vm.def" 12066 12067#line 12068 "vm.inl" 12068 } 12069 while (0); 12070 } 12071 NEXT_BC; 12072bc247: 12073 { 12074 OOP _stack0; 12075 OOP _extra1; 12076 _stack0 = STACK_AT (0); 12077 /* PREFETCH ( -- ) */ 12078 do 12079 { 12080#line 207 "vm.def" 12081 PREFETCH; 12082 LOCAL_COUNTER++; 12083 12084#line 12085 "vm.inl" 12085 } 12086 while (0); 12087 /* DUP_STACK_TOP ( tos | -- tos | tos2 ) */ 12088 do 12089 { 12090#define tos _stack0 12091#define tos2 _extra1 12092#line 860 "vm.def" 12093 tos2 = tos; 12094 12095#line 12096 "vm.inl" 12096#undef tos 12097#undef tos2 12098 } 12099 while (0); 12100 /* SEND ( -- ) */ 12101 do 12102 { 12103 int sel = arg; 12104 int n = 0; 12105#define PREPARE_STACK() do { \ 12106 PUSH_OOP (_extra1); \ 12107 } while (0) 12108#line 643 "vm.def" 12109 PREPARE_STACK (); 12110 EXPORT_REGS (); 12111 SEND_MESSAGE (METHOD_LITERAL (sel), n); 12112 IMPORT_REGS (); 12113 FETCH; 12114 12115#line 12116 "vm.inl" 12116#undef PREPARE_STACK 12117 } 12118 while (0); 12119 PUSH_OOP (_extra1); 12120 } 12121 NEXT_BC; 12122bc248: 12123 { 12124 OOP _stack0; 12125 _stack0 = STACK_AT (0); 12126 /* PREFETCH ( -- ) */ 12127 do 12128 { 12129#line 207 "vm.def" 12130 PREFETCH; 12131 LOCAL_COUNTER++; 12132 12133#line 12134 "vm.inl" 12134 } 12135 while (0); 12136 /* STORE_RECEIVER_VARIABLE ( tos | -- tos | ) */ 12137 do 12138 { 12139 int n = arg; 12140#define tos _stack0 12141#line 758 "vm.def" 12142 STORE_RECEIVER_VARIABLE (n, tos); 12143 12144#line 12145 "vm.inl" 12145#undef tos 12146 } 12147 while (0); 12148 /* RETURN_CONTEXT_STACK_TOP ( val | -- val | ) */ 12149 do 12150 { 12151#define val _stack0 12152#line 852 "vm.def" 12153 EXPORT_REGS (); 12154 unwind_context (); 12155 IMPORT_REGS (); 12156 SET_STACKTOP (val); 12157 FETCH; 12158 12159#line 12160 "vm.inl" 12160#undef val 12161 } 12162 while (0); 12163 } 12164 NEXT_BC; 12165bc249: 12166 { 12167 OOP _extra1; 12168 /* PREFETCH ( -- ) */ 12169 do 12170 { 12171#line 207 "vm.def" 12172 PREFETCH; 12173 LOCAL_COUNTER++; 12174 12175#line 12176 "vm.inl" 12176 } 12177 while (0); 12178 /* LINE_NUMBER_BYTECODE ( -- ) */ 12179 do 12180 { 12181#line 890 "vm.def" 12182 12183#line 12184 "vm.inl" 12184 } 12185 while (0); 12186 /* PUSH_SELF ( -- tos ) */ 12187 do 12188 { 12189#define tos _extra1 12190#line 893 "vm.def" 12191 tos = _gst_self; 12192 12193#line 12194 "vm.inl" 12194#undef tos 12195 } 12196 while (0); 12197 /* SEND ( -- ) */ 12198 do 12199 { 12200 int sel = 3; 12201 int n = 0; 12202#define PREPARE_STACK() do { \ 12203 PUSH_OOP (_extra1); \ 12204 } while (0) 12205#line 643 "vm.def" 12206 PREPARE_STACK (); 12207 EXPORT_REGS (); 12208 SEND_MESSAGE (METHOD_LITERAL (sel), n); 12209 IMPORT_REGS (); 12210 FETCH; 12211 12212#line 12213 "vm.inl" 12213#undef PREPARE_STACK 12214 } 12215 while (0); 12216 PUSH_OOP (_extra1); 12217 } 12218 NEXT_BC; 12219bc250: 12220 { 12221 OOP _stack0; 12222 OOP _extra1; 12223 _stack0 = STACK_AT (0); 12224 /* PREFETCH ( -- ) */ 12225 do 12226 { 12227#line 207 "vm.def" 12228 PREFETCH; 12229 LOCAL_COUNTER++; 12230 12231#line 12232 "vm.inl" 12232 } 12233 while (0); 12234 /* NOT_NIL_SPECIAL ( rec -- val ) */ 12235 do 12236 { 12237#define rec _stack0 12238#define val _stack0 12239#line 581 "vm.def" 12240 /* DO_JUMP_LOOKAHEAD (rec != _gst_nil_oop); */ 12241 val = rec != _gst_nil_oop ? _gst_true_oop : _gst_false_oop; 12242 12243#line 12244 "vm.inl" 12244#undef rec 12245#undef val 12246 } 12247 while (0); 12248 /* DUP_STACK_TOP ( tos | -- tos | tos2 ) */ 12249 do 12250 { 12251#define tos _stack0 12252#define tos2 _extra1 12253#line 860 "vm.def" 12254 tos2 = tos; 12255 12256#line 12257 "vm.inl" 12257#undef tos 12258#undef tos2 12259 } 12260 while (0); 12261 /* POP_JUMP_FALSE ( tos -- ) */ 12262 do 12263 { 12264 int n = arg; 12265#define PREPARE_STACK() do { \ 12266 STACK_AT (0) = _stack0; \ 12267 PUSH_OOP (_extra1); \ 12268 } while (0) 12269#define tos _extra1 12270#line 774 "vm.def" 12271 if UNCOMMON (tos == _gst_false_oop) 12272 { 12273 PREPARE_STACK (); 12274 POP_N_OOPS(1); 12275 ip += n; 12276 FETCH; 12277 } 12278 else if UNCOMMON (tos != _gst_true_oop) 12279 { 12280 ip += n; 12281 PREPARE_STACK (); 12282 EXPORT_REGS(); 12283 SEND_MESSAGE(_gst_must_be_boolean_symbol, 0); 12284 IMPORT_REGS(); 12285 FETCH; 12286 } 12287 12288#line 12289 "vm.inl" 12289#undef PREPARE_STACK 12290#undef tos 12291 } 12292 while (0); 12293 STACK_AT (0) = _stack0; 12294 } 12295 NEXT_BC; 12296bc251: 12297 { 12298 OOP _stack0; 12299 OOP _extra1, _extra2; 12300 _stack0 = STACK_AT (0); 12301 /* PREFETCH ( -- ) */ 12302 do 12303 { 12304#line 207 "vm.def" 12305 PREFETCH; 12306 LOCAL_COUNTER++; 12307 12308#line 12309 "vm.inl" 12309 } 12310 while (0); 12311 /* DUP_STACK_TOP ( tos | -- tos | tos2 ) */ 12312 do 12313 { 12314#define tos _stack0 12315#define tos2 _extra1 12316#line 860 "vm.def" 12317 tos2 = tos; 12318 12319#line 12320 "vm.inl" 12320#undef tos 12321#undef tos2 12322 } 12323 while (0); 12324 /* PUSH_LIT_CONSTANT ( -- tos ) */ 12325 do 12326 { 12327 int n = arg; 12328#define tos _extra2 12329#line 820 "vm.def" 12330 tos = METHOD_LITERAL (n); 12331 12332#line 12333 "vm.inl" 12333#undef tos 12334 } 12335 while (0); 12336 PUSH_OOP (_extra1); 12337 PUSH_OOP (_extra2); 12338 } 12339 NEXT_BC; 12340bc252: 12341 { 12342 OOP _extra1; 12343 /* PREFETCH ( -- ) */ 12344 do 12345 { 12346#line 207 "vm.def" 12347 PREFETCH; 12348 LOCAL_COUNTER++; 12349 12350#line 12351 "vm.inl" 12351 } 12352 while (0); 12353 /* LINE_NUMBER_BYTECODE ( -- ) */ 12354 do 12355 { 12356#line 890 "vm.def" 12357 12358#line 12359 "vm.inl" 12359 } 12360 while (0); 12361 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 12362 do 12363 { 12364 int n = 0; 12365#define tos _extra1 12366#line 683 "vm.def" 12367 tos = METHOD_TEMPORARY (n); 12368 12369#line 12370 "vm.inl" 12370#undef tos 12371 } 12372 while (0); 12373 /* RETURN_CONTEXT_STACK_TOP ( val | -- val | ) */ 12374 do 12375 { 12376#define val _extra1 12377#line 852 "vm.def" 12378 EXPORT_REGS (); 12379 unwind_context (); 12380 IMPORT_REGS (); 12381 SET_STACKTOP (val); 12382 FETCH; 12383 12384#line 12385 "vm.inl" 12385#undef val 12386 } 12387 while (0); 12388 PUSH_OOP (_extra1); 12389 } 12390 NEXT_BC; 12391bc253: 12392 { 12393 OOP _stack0, _stack1; 12394 OOP _extra1; 12395 _stack1 = STACK_AT (1); 12396 _stack0 = STACK_AT (0); 12397 /* PREFETCH ( -- ) */ 12398 do 12399 { 12400#line 207 "vm.def" 12401 PREFETCH; 12402 LOCAL_COUNTER++; 12403 12404#line 12405 "vm.inl" 12405 } 12406 while (0); 12407 /* PUSH_INTEGER ( -- tos ) */ 12408 do 12409 { 12410 int n = arg; 12411#define tos _extra1 12412#line 812 "vm.def" 12413 tos = FROM_INT (n); 12414 12415#line 12416 "vm.inl" 12416#undef tos 12417 } 12418 while (0); 12419 /* AT_PUT_SPECIAL ( rec idx val -- res ) */ 12420 do 12421 { 12422#define PREPARE_STACK() do { \ 12423 PUSH_OOP (_extra1); \ 12424 } while (0) 12425#define rec _stack1 12426#define idx _stack0 12427#define val _extra1 12428#define res _stack1 12429#line 477 "vm.def" 12430 OOP classOOP; 12431 PREPARE_STACK (); 12432 EXPORT_REGS (); 12433 if UNCOMMON (IS_INT (rec)) 12434 { 12435 SEND_MESSAGE (_gst_builtin_selectors[AT_PUT_SPECIAL].symbol, 2); 12436 IMPORT_REGS (); 12437 FETCH; 12438 } 12439 12440 if COMMON (at_put_cache_class == (classOOP = OOP_CLASS (rec)) 12441 && !cached_index_oop_put_primitive (rec, idx, val, at_put_cache_spec)) 12442 { 12443 IMPORT_REGS (); 12444 NEXT_BC; 12445 } 12446 12447 /* Not the same class that is in the cache, or the primitive failed -- 12448 send the message, and modify the cache if the send is resolved to 12449 a primitive. */ 12450 last_primitive = 0; 12451 SEND_MESSAGE (_gst_builtin_selectors[AT_PUT_SPECIAL].symbol, 2); 12452 IMPORT_REGS (); 12453 if (_gst_primitive_table[last_primitive].id == 61) 12454 { 12455 at_put_cache_spec = CLASS_INSTANCE_SPEC (classOOP); 12456 at_put_cache_class = classOOP; 12457 NEXT_BC; 12458 } 12459 FETCH; 12460 12461#line 12462 "vm.inl" 12462#undef PREPARE_STACK 12463#undef rec 12464#undef idx 12465#undef val 12466#undef res 12467 } 12468 while (0); 12469 STACK_AT (1) = _stack1; 12470 POP_N_OOPS (1); 12471 } 12472 NEXT_BC; 12473bc254: 12474 { 12475 OOP _extra1; 12476 /* PREFETCH ( -- ) */ 12477 do 12478 { 12479#line 207 "vm.def" 12480 PREFETCH; 12481 LOCAL_COUNTER++; 12482 12483#line 12484 "vm.inl" 12484 } 12485 while (0); 12486 /* PUSH_TEMPORARY_VARIABLE ( -- tos ) */ 12487 do 12488 { 12489 int n = arg; 12490#define tos _extra1 12491#line 683 "vm.def" 12492 tos = METHOD_TEMPORARY (n); 12493 12494#line 12495 "vm.inl" 12495#undef tos 12496 } 12497 while (0); 12498 /* CLASS_SPECIAL ( rec -- val ) */ 12499 do 12500 { 12501#define PREPARE_STACK() do { \ 12502 PUSH_OOP (_extra1); \ 12503 } while (0) 12504#define rec _extra1 12505#define val _extra1 12506#line 543 "vm.def" 12507 OOP classOOP; 12508 PREPARE_STACK (); 12509 EXPORT_REGS (); 12510 if UNCOMMON (IS_INT (rec)) 12511 { 12512 SEND_MESSAGE (_gst_builtin_selectors[CLASS_SPECIAL].symbol, 0); 12513 IMPORT_REGS (); 12514 FETCH; 12515 } 12516 12517 if COMMON (class_cache_class == (classOOP = OOP_CLASS (rec)) 12518 && !execute_primitive_operation (class_cache_prim, 1)) 12519 { 12520 IMPORT_REGS (); 12521 NEXT_BC; 12522 } 12523 12524 /* Not the same class that is in the cache, or the primitive failed -- 12525 send the message, and modify the cache if the send is resolved to 12526 a primitive. */ 12527 last_primitive = 0; 12528 SEND_MESSAGE (_gst_builtin_selectors[CLASS_SPECIAL].symbol, 0); 12529 IMPORT_REGS (); 12530 if COMMON (last_primitive) 12531 { 12532 class_cache_prim = last_primitive; 12533 class_cache_class = classOOP; 12534 NEXT_BC; 12535 } 12536 FETCH; 12537 12538#line 12539 "vm.inl" 12539#undef PREPARE_STACK 12540#undef rec 12541#undef val 12542 } 12543 while (0); 12544 PUSH_OOP (_extra1); 12545 } 12546 NEXT_BC; 12547bc255: 12548 { 12549 OOP _extra1; 12550 /* PREFETCH ( -- ) */ 12551 do 12552 { 12553#line 207 "vm.def" 12554 PREFETCH; 12555 LOCAL_COUNTER++; 12556 12557#line 12558 "vm.inl" 12558 } 12559 while (0); 12560 /* LINE_NUMBER_BYTECODE ( -- ) */ 12561 do 12562 { 12563#line 890 "vm.def" 12564 12565#line 12566 "vm.inl" 12566 } 12567 while (0); 12568 /* PUSH_OUTER_TEMP ( -- tos ) */ 12569 do 12570 { 12571 int n = 2; 12572 int scopes = 1; 12573#define tos _extra1 12574#line 687 "vm.def" 12575 OOP contextOOP; 12576 gst_block_context context; 12577 12578 context = (gst_block_context) OOP_TO_OBJ (_gst_this_context_oop); 12579 do 12580 { 12581 contextOOP = context->outerContext; 12582 context = (gst_block_context) OOP_TO_OBJ (contextOOP); 12583 } 12584 while (--scopes); 12585 12586 tos = context->contextStack[n]; 12587 12588#line 12589 "vm.inl" 12589#undef tos 12590 } 12591 while (0); 12592 PUSH_OOP (_extra1); 12593 } 12594 NEXT_BC; 12595jump_around: 12596 ; 12597