1 2 /* 3 * Copyright 2011 Google Inc. 4 * 5 * Use of this source code is governed by a BSD-style license that can be 6 * found in the LICENSE file. 7 */ 8 #include "SkScriptRuntime.h" 9 #include "SkScript2.h" 10 #include "SkMath.h" 11 #include "SkParse.h" 12 #include "SkScriptCallBack.h" 13 #include "SkString.h" 14 #include "SkOpArray.h" 15 16 // script tokenizer 17 18 // turn text into token string 19 // turn number literals into inline UTF8-style values 20 // process operators to turn standard notation into stack notation 21 22 // defer processing until the tokens can all be resolved 23 // then, turn token strings into indices into the appropriate tables / dictionaries 24 25 // consider: const evaluation? 26 27 // replace script string with script tokens preceeded by special value 28 29 // need second version of script plugins that return private index of found value? 30 // then would need in script index of plugin, private index 31 32 // encode brace stack push/pop as opcodes 33 34 // should token script enocde type where possible? 35 36 // current flow: 37 // strip whitespace 38 // if in array brace [ recurse, continue 39 // if token, handle function, or array, or property (continue) 40 // parse number, continue 41 // parse token, continue 42 // parse string literal, continue 43 // if dot operator, handle dot, continue 44 // if [ , handle array literal or accessor, continue 45 // if ), pop (if function, break) 46 // if ], pop ; if ',' break 47 // handle logical ops 48 // or, handle arithmetic ops 49 // loop 50 51 // !!! things to do 52 // add separate processing loop to advance while suppressed 53 // or, include jump offset to skip suppressed code? 54 55 SkScriptRuntime::~SkScriptRuntime() { 56 for (SkString** stringPtr = fTrackString.begin(); stringPtr < fTrackString.end(); stringPtr++) 57 delete *stringPtr; 58 for (SkOpArray** arrayPtr = fTrackArray.begin(); arrayPtr < fTrackArray.end(); arrayPtr++) 59 delete *arrayPtr; 60 } 61 62 bool SkScriptRuntime::executeTokens(unsigned char* opCode) { 63 SkOperand2 operand[2]; // 1=accumulator and 2=operand 64 SkScriptEngine2::TypeOp op; 65 size_t ref; 66 int index, size; 67 int registerLoad; 68 SkScriptCallBack* callBack SK_INIT_TO_AVOID_WARNING; 69 do { 70 switch ((op = (SkScriptEngine2::TypeOp) *opCode++)) { 71 case SkScriptEngine2::kArrayToken: // create an array 72 operand[0].fArray = new SkOpArray(SkOperand2::kNoType /*fReturnType*/); 73 break; 74 case SkScriptEngine2::kArrayIndex: // array accessor 75 index = operand[1].fS32; 76 if (index >= operand[0].fArray->count()) { 77 fError = kArrayIndexOutOfBounds; 78 return false; 79 } 80 operand[0] = operand[0].fArray->begin()[index]; 81 break; 82 case SkScriptEngine2::kArrayParam: // array initializer, or function param 83 *operand[0].fArray->append() = operand[1]; 84 break; 85 case SkScriptEngine2::kCallback: 86 memcpy(&index, opCode, sizeof(index)); 87 opCode += sizeof(index); 88 callBack = fCallBackArray[index]; 89 break; 90 case SkScriptEngine2::kFunctionCall: { 91 memcpy(&ref, opCode, sizeof(ref)); 92 opCode += sizeof(ref); 93 SkScriptCallBackFunction* callBackFunction = (SkScriptCallBackFunction*) callBack; 94 if (callBackFunction->invoke(ref, operand[0].fArray, /* params */ 95 &operand[0] /* result */) == false) { 96 fError = kFunctionCallFailed; 97 return false; 98 } 99 } break; 100 case SkScriptEngine2::kMemberOp: { 101 memcpy(&ref, opCode, sizeof(ref)); 102 opCode += sizeof(ref); 103 SkScriptCallBackMember* callBackMember = (SkScriptCallBackMember*) callBack; 104 if (callBackMember->invoke(ref, operand[0].fObject, &operand[0]) == false) { 105 fError = kMemberOpFailed; 106 return false; 107 } 108 } break; 109 case SkScriptEngine2::kPropertyOp: { 110 memcpy(&ref, opCode, sizeof(ref)); 111 opCode += sizeof(ref); 112 SkScriptCallBackProperty* callBackProperty = (SkScriptCallBackProperty*) callBack; 113 if (callBackProperty->getResult(ref, &operand[0])== false) { 114 fError = kPropertyOpFailed; 115 return false; 116 } 117 } break; 118 case SkScriptEngine2::kAccumulatorPop: 119 fRunStack.pop(&operand[0]); 120 break; 121 case SkScriptEngine2::kAccumulatorPush: 122 *fRunStack.push() = operand[0]; 123 break; 124 case SkScriptEngine2::kIntegerAccumulator: 125 case SkScriptEngine2::kIntegerOperand: 126 registerLoad = op - SkScriptEngine2::kIntegerAccumulator; 127 memcpy(&operand[registerLoad].fS32, opCode, sizeof(int32_t)); 128 opCode += sizeof(int32_t); 129 break; 130 case SkScriptEngine2::kScalarAccumulator: 131 case SkScriptEngine2::kScalarOperand: 132 registerLoad = op - SkScriptEngine2::kScalarAccumulator; 133 memcpy(&operand[registerLoad].fScalar, opCode, sizeof(SkScalar)); 134 opCode += sizeof(SkScalar); 135 break; 136 case SkScriptEngine2::kStringAccumulator: 137 case SkScriptEngine2::kStringOperand: { 138 SkString* strPtr = new SkString(); 139 track(strPtr); 140 registerLoad = op - SkScriptEngine2::kStringAccumulator; 141 memcpy(&size, opCode, sizeof(size)); 142 opCode += sizeof(size); 143 strPtr->set((char*) opCode, size); 144 opCode += size; 145 operand[registerLoad].fString = strPtr; 146 } break; 147 case SkScriptEngine2::kStringTrack: // call after kObjectToValue 148 track(operand[0].fString); 149 break; 150 case SkScriptEngine2::kBoxToken: { 151 SkOperand2::OpType type; 152 memcpy(&type, opCode, sizeof(type)); 153 opCode += sizeof(type); 154 SkScriptCallBackConvert* callBackBox = (SkScriptCallBackConvert*) callBack; 155 if (callBackBox->convert(type, &operand[0]) == false) 156 return false; 157 } break; 158 case SkScriptEngine2::kUnboxToken: 159 case SkScriptEngine2::kUnboxToken2: { 160 SkScriptCallBackConvert* callBackUnbox = (SkScriptCallBackConvert*) callBack; 161 if (callBackUnbox->convert(SkOperand2::kObject, &operand[0]) == false) 162 return false; 163 } break; 164 case SkScriptEngine2::kIfOp: 165 case SkScriptEngine2::kLogicalAndInt: 166 memcpy(&size, opCode, sizeof(size)); 167 opCode += sizeof(size); 168 if (operand[0].fS32 == 0) 169 opCode += size; // skip to else (or end of if predicate) 170 break; 171 case SkScriptEngine2::kElseOp: 172 memcpy(&size, opCode, sizeof(size)); 173 opCode += sizeof(size); 174 opCode += size; // if true: after predicate, always skip to end of else 175 break; 176 case SkScriptEngine2::kLogicalOrInt: 177 memcpy(&size, opCode, sizeof(size)); 178 opCode += sizeof(size); 179 if (operand[0].fS32 != 0) 180 opCode += size; // skip to kToBool opcode after || predicate 181 break; 182 // arithmetic conversion ops 183 case SkScriptEngine2::kFlipOpsOp: 184 SkTSwap(operand[0], operand[1]); 185 break; 186 case SkScriptEngine2::kIntToString: 187 case SkScriptEngine2::kIntToString2: 188 case SkScriptEngine2::kScalarToString: 189 case SkScriptEngine2::kScalarToString2:{ 190 SkString* strPtr = new SkString(); 191 track(strPtr); 192 if (op == SkScriptEngine2::kIntToString || op == SkScriptEngine2::kIntToString2) 193 strPtr->appendS32(operand[op - SkScriptEngine2::kIntToString].fS32); 194 else 195 strPtr->appendScalar(operand[op - SkScriptEngine2::kScalarToString].fScalar); 196 operand[0].fString = strPtr; 197 } break; 198 case SkScriptEngine2::kIntToScalar: 199 case SkScriptEngine2::kIntToScalar2: 200 operand[0].fScalar = SkScriptEngine2::IntToScalar(operand[op - SkScriptEngine2::kIntToScalar].fS32); 201 break; 202 case SkScriptEngine2::kStringToInt: 203 if (SkParse::FindS32(operand[0].fString->c_str(), &operand[0].fS32) == nullptr) 204 return false; 205 break; 206 case SkScriptEngine2::kStringToScalar: 207 case SkScriptEngine2::kStringToScalar2: 208 if (SkParse::FindScalar(operand[0].fString->c_str(), 209 &operand[op - SkScriptEngine2::kStringToScalar].fScalar) == nullptr) 210 return false; 211 break; 212 case SkScriptEngine2::kScalarToInt: 213 operand[0].fS32 = SkScalarFloorToInt(operand[0].fScalar); 214 break; 215 // arithmetic ops 216 case SkScriptEngine2::kAddInt: 217 operand[0].fS32 += operand[1].fS32; 218 break; 219 case SkScriptEngine2::kAddScalar: 220 operand[0].fScalar += operand[1].fScalar; 221 break; 222 case SkScriptEngine2::kAddString: 223 // if (fTrackString.find(operand[1].fString) < 0) { 224 // operand[1].fString = new SkString (*operand[1].fString); 225 // track(operand[1].fString); 226 // } 227 operand[0].fString->append(*operand[1].fString); 228 break; 229 case SkScriptEngine2::kBitAndInt: 230 operand[0].fS32 &= operand[1].fS32; 231 break; 232 case SkScriptEngine2::kBitNotInt: 233 operand[0].fS32 = ~operand[0].fS32; 234 break; 235 case SkScriptEngine2::kBitOrInt: 236 operand[0].fS32 |= operand[1].fS32; 237 break; 238 case SkScriptEngine2::kDivideInt: 239 SkASSERT(operand[1].fS32 != 0); 240 if (operand[1].fS32 == 0) 241 operand[0].fS32 = operand[0].fS32 == 0 ? SK_NaN32 : 242 operand[0].fS32 > 0 ? SK_MaxS32 : -SK_MaxS32; 243 else 244 if (operand[1].fS32 != 0) // throw error on divide by zero? 245 operand[0].fS32 /= operand[1].fS32; 246 break; 247 case SkScriptEngine2::kDivideScalar: 248 if (operand[1].fScalar == 0) 249 operand[0].fScalar = operand[0].fScalar == 0 ? SK_ScalarNaN : 250 operand[0].fScalar > 0 ? SK_ScalarMax : -SK_ScalarMax; 251 else 252 operand[0].fScalar = operand[0].fScalar / operand[1].fScalar; 253 break; 254 case SkScriptEngine2::kEqualInt: 255 operand[0].fS32 = operand[0].fS32 == operand[1].fS32; 256 break; 257 case SkScriptEngine2::kEqualScalar: 258 operand[0].fS32 = operand[0].fScalar == operand[1].fScalar; 259 break; 260 case SkScriptEngine2::kEqualString: 261 operand[0].fS32 = *operand[0].fString == *operand[1].fString; 262 break; 263 case SkScriptEngine2::kGreaterEqualInt: 264 operand[0].fS32 = operand[0].fS32 >= operand[1].fS32; 265 break; 266 case SkScriptEngine2::kGreaterEqualScalar: 267 operand[0].fS32 = operand[0].fScalar >= operand[1].fScalar; 268 break; 269 case SkScriptEngine2::kGreaterEqualString: 270 operand[0].fS32 = strcmp(operand[0].fString->c_str(), operand[1].fString->c_str()) >= 0; 271 break; 272 case SkScriptEngine2::kToBool: 273 operand[0].fS32 = !! operand[0].fS32; 274 break; 275 case SkScriptEngine2::kLogicalNotInt: 276 operand[0].fS32 = ! operand[0].fS32; 277 break; 278 case SkScriptEngine2::kMinusInt: 279 operand[0].fS32 = -operand[0].fS32; 280 break; 281 case SkScriptEngine2::kMinusScalar: 282 operand[0].fScalar = -operand[0].fScalar; 283 break; 284 case SkScriptEngine2::kModuloInt: 285 operand[0].fS32 %= operand[1].fS32; 286 break; 287 case SkScriptEngine2::kModuloScalar: 288 operand[0].fScalar = SkScalarMod(operand[0].fScalar, operand[1].fScalar); 289 break; 290 case SkScriptEngine2::kMultiplyInt: 291 operand[0].fS32 *= operand[1].fS32; 292 break; 293 case SkScriptEngine2::kMultiplyScalar: 294 operand[0].fScalar = SkScalarMul(operand[0].fScalar, operand[1].fScalar); 295 break; 296 case SkScriptEngine2::kShiftLeftInt: 297 operand[0].fS32 <<= operand[1].fS32; 298 break; 299 case SkScriptEngine2::kShiftRightInt: 300 operand[0].fS32 >>= operand[1].fS32; 301 break; 302 case SkScriptEngine2::kSubtractInt: 303 operand[0].fS32 -= operand[1].fS32; 304 break; 305 case SkScriptEngine2::kSubtractScalar: 306 operand[0].fScalar -= operand[1].fScalar; 307 break; 308 case SkScriptEngine2::kXorInt: 309 operand[0].fS32 ^= operand[1].fS32; 310 break; 311 case SkScriptEngine2::kEnd: 312 goto done; 313 case SkScriptEngine2::kNop: 314 SkASSERT(0); 315 default: 316 break; 317 } 318 } while (true); 319 done: 320 fRunStack.push(operand[0]); 321 return true; 322 } 323 324 bool SkScriptRuntime::getResult(SkOperand2* result) { 325 if (fRunStack.count() == 0) 326 return false; 327 fRunStack.pop(result); 328 return true; 329 } 330 331 void SkScriptRuntime::track(SkOpArray* array) { 332 SkASSERT(fTrackArray.find(array) < 0); 333 *fTrackArray.append() = array; 334 } 335 336 void SkScriptRuntime::track(SkString* string) { 337 SkASSERT(fTrackString.find(string) < 0); 338 *fTrackString.append() = string; 339 } 340 341 void SkScriptRuntime::untrack(SkOpArray* array) { 342 int index = fTrackArray.find(array); 343 SkASSERT(index >= 0); 344 fTrackArray.begin()[index] = nullptr; 345 } 346 347 void SkScriptRuntime::untrack(SkString* string) { 348 int index = fTrackString.find(string); 349 SkASSERT(index >= 0); 350 fTrackString.begin()[index] = nullptr; 351 } 352
