/*
* Copyright 2006 The Android Open Source Project
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "SkScript.h"
#include "SkMath.h"
#include "SkParse.h"
#include "SkString.h"
#include "SkTypedArray.h"
/* things to do
? re-enable support for struct literals (e.g., for initializing points or rects)
{x:1, y:2}
? use standard XML / script notation like document.getElementById("canvas");
finish support for typed arrays
? allow indexing arrays by string
this could map to the 'name' attribute of a given child of an array
? allow multiple types in the array
remove SkDisplayType.h // from SkOperand.h
merge type and operand arrays into scriptvalue array
*/
#ifdef SK_DEBUG
static const char* errorStrings[] = {
"array index of out bounds", // kArrayIndexOutOfBounds
"could not find reference id", // kCouldNotFindReferencedID
"dot operator expects object", // kDotOperatorExpectsObject
"error in array index", // kErrorInArrrayIndex
"error in function parameters", // kErrorInFunctionParameters
"expected array", // kExpectedArray
"expected boolean expression", // kExpectedBooleanExpression
"expected field name", // kExpectedFieldName
"expected hex", // kExpectedHex
"expected int for condition operator", // kExpectedIntForConditionOperator
"expected number", // kExpectedNumber
"expected number for array index", // kExpectedNumberForArrayIndex
"expected operator", // kExpectedOperator
"expected token", // kExpectedToken
"expected token before dot operator", // kExpectedTokenBeforeDotOperator
"expected value", // kExpectedValue
"handle member failed", // kHandleMemberFailed
"handle member function failed", // kHandleMemberFunctionFailed
"handle unbox failed", // kHandleUnboxFailed
"index out of range", // kIndexOutOfRange
"mismatched array brace", // kMismatchedArrayBrace
"mismatched brackets", // kMismatchedBrackets
"no function handler found", // kNoFunctionHandlerFound
"premature end", // kPrematureEnd
"too many parameters", // kTooManyParameters
"type conversion failed", // kTypeConversionFailed
"unterminated string" // kUnterminatedString
};
#endif
const SkScriptEngine::SkOperatorAttributes SkScriptEngine::gOpAttributes[] = {
{ kNoType, kNoType, kNoBias }, // kUnassigned,
{ SkOpType(kInt | kScalar | kString), SkOpType(kInt | kScalar | kString), kTowardsString }, // kAdd
// kAddInt = kAdd,
{ kNoType, kNoType, kNoBias }, // kAddScalar,
{ kNoType, kNoType, kNoBias }, // kAddString,
{ kNoType, kNoType, kNoBias }, // kArrayOp,
{ kInt, kInt, kNoBias }, // kBitAnd
{ kNoType, kInt, kNoBias }, // kBitNot
{ kInt, kInt, kNoBias }, // kBitOr
{ SkOpType(kInt | kScalar), SkOpType(kInt | kScalar), kNoBias }, // kDivide
// kDivideInt = kDivide
{ kNoType, kNoType, kNoBias }, // kDivideScalar
{ kNoType, kNoType, kNoBias }, // kElse
{ SkOpType(kInt | kScalar | kString), SkOpType(kInt | kScalar | kString), kTowardsNumber }, // kEqual
// kEqualInt = kEqual
{ kNoType, kNoType, kNoBias }, // kEqualScalar
{ kNoType, kNoType, kNoBias }, // kEqualString
{ kInt, kNoType, kNoBias }, // kFlipOps
{ SkOpType(kInt | kScalar | kString), SkOpType(kInt | kScalar | kString), kTowardsNumber }, // kGreaterEqual
// kGreaterEqualInt = kGreaterEqual
{ kNoType, kNoType, kNoBias }, // kGreaterEqualScalar
{ kNoType, kNoType, kNoBias }, // kGreaterEqualString
{ kNoType, kNoType, kNoBias }, // kIf
{ kNoType, kInt, kNoBias }, // kLogicalAnd (really, ToBool)
{ kNoType, kInt, kNoBias }, // kLogicalNot
{ kInt, kInt, kNoBias }, // kLogicalOr
{ kNoType, SkOpType(kInt | kScalar), kNoBias }, // kMinus
// kMinusInt = kMinus
{ kNoType, kNoType, kNoBias }, // kMinusScalar
{ SkOpType(kInt | kScalar), SkOpType(kInt | kScalar), kNoBias }, // kModulo
// kModuloInt = kModulo
{ kNoType, kNoType, kNoBias }, // kModuloScalar
{ SkOpType(kInt | kScalar), SkOpType(kInt | kScalar), kNoBias }, // kMultiply
// kMultiplyInt = kMultiply
{ kNoType, kNoType, kNoBias }, // kMultiplyScalar
{ kNoType, kNoType, kNoBias }, // kParen
{ kInt, kInt, kNoBias }, // kShiftLeft
{ kInt, kInt, kNoBias }, // kShiftRight
{ SkOpType(kInt | kScalar), SkOpType(kInt | kScalar), kNoBias }, // kSubtract
// kSubtractInt = kSubtract
{ kNoType, kNoType, kNoBias }, // kSubtractScalar
{ kInt, kInt, kNoBias } // kXor
};
// Note that the real precedence for () [] is '2'
// but here, precedence means 'while an equal or smaller precedence than the current operator
// is on the stack, process it. This allows 3+5*2 to defer the add until after the multiply
// is preformed, since the add precedence is not smaller than multiply.
// But, (3*4 does not process the '(', since brackets are greater than all other precedences
#define kBracketPrecedence 16
#define kIfElsePrecedence 15
const signed char SkScriptEngine::gPrecedence[] = {
-1, // kUnassigned,
6, // kAdd,
// kAddInt = kAdd,
6, // kAddScalar,
6, // kAddString, // string concat
kBracketPrecedence, // kArrayOp,
10, // kBitAnd,
4, // kBitNot,
12, // kBitOr,
5, // kDivide,
// kDivideInt = kDivide,
5, // kDivideScalar,
kIfElsePrecedence, // kElse,
9, // kEqual,
// kEqualInt = kEqual,
9, // kEqualScalar,
9, // kEqualString,
-1, // kFlipOps,
8, // kGreaterEqual,
// kGreaterEqualInt = kGreaterEqual,
8, // kGreaterEqualScalar,
8, // kGreaterEqualString,
kIfElsePrecedence, // kIf,
13, // kLogicalAnd,
4, // kLogicalNot,
14, // kLogicalOr,
4, // kMinus,
// kMinusInt = kMinus,
4, // kMinusScalar,
5, // kModulo,
// kModuloInt = kModulo,
5, // kModuloScalar,
5, // kMultiply,
// kMultiplyInt = kMultiply,
5, // kMultiplyScalar,
kBracketPrecedence, // kParen,
7, // kShiftLeft,
7, // kShiftRight, // signed
6, // kSubtract,
// kSubtractInt = kSubtract,
6, // kSubtractScalar,
11, // kXor
};
static inline bool is_between(int c, int min, int max)
{
return (unsigned)(c - min) <= (unsigned)(max - min);
}
static inline bool is_ws(int c)
{
return is_between(c, 1, 32);
}
static int token_length(const char* start) {
char ch = start[0];
if (! is_between(ch, 'a' , 'z') && ! is_between(ch, 'A', 'Z') && ch != '_' && ch != '$')
return -1;
int length = 0;
do
ch = start[++length];
while (is_between(ch, 'a' , 'z') || is_between(ch, 'A', 'Z') || is_between(ch, '0', '9') ||
ch == '_' || ch == '$');
return length;
}
SkScriptEngine::SkScriptEngine(SkOpType returnType) :
fTokenLength(0), fReturnType(returnType), fError(kNoError)
{
SkSuppress noInitialSuppress;
noInitialSuppress.fOperator = kUnassigned;
noInitialSuppress.fOpStackDepth = 0;
noInitialSuppress.fSuppress = false;
noInitialSuppress.fElse = 0;
fSuppressStack.push(noInitialSuppress);
*fOpStack.push() = kParen;
fTrackArray.appendClear();
fTrackString.appendClear();
}
SkScriptEngine::~SkScriptEngine() {
for (SkString** stringPtr = fTrackString.begin(); stringPtr < fTrackString.end(); stringPtr++)
delete *stringPtr;
for (SkTypedArray** arrayPtr = fTrackArray.begin(); arrayPtr < fTrackArray.end(); arrayPtr++)
delete *arrayPtr;
}
int SkScriptEngine::arithmeticOp(char ch, char nextChar, bool lastPush) {
SkOp op = kUnassigned;
bool reverseOperands = false;
bool negateResult = false;
int advance = 1;
switch (ch) {
case '+':
// !!! ignoring unary plus as implemented here has the side effect of
// suppressing errors like +"hi"
if (lastPush == false) // unary plus, don't push an operator
goto returnAdv;
op = kAdd;
break;
case '-':
op = lastPush ? kSubtract : kMinus;
break;
case '*':
op = kMultiply;
break;
case '/':
op = kDivide;
break;
case '>':
if (nextChar == '>') {
op = kShiftRight;
goto twoChar;
}
op = kGreaterEqual;
if (nextChar == '=')
goto twoChar;
reverseOperands = negateResult = true;
break;
case '<':
if (nextChar == '<') {
op = kShiftLeft;
goto twoChar;
}
op = kGreaterEqual;
reverseOperands = nextChar == '=';
negateResult = ! reverseOperands;
advance += reverseOperands;
break;
case '=':
if (nextChar == '=') {
op = kEqual;
goto twoChar;
}
break;
case '!':
if (nextChar == '=') {
op = kEqual;
negateResult = true;
twoChar:
advance++;
break;
}
op = kLogicalNot;
break;
case '?':
op = kIf;
break;
case ':':
op = kElse;
break;
case '^':
op = kXor;
break;
case '(':
*fOpStack.push() = kParen; // push even if eval is suppressed
goto returnAdv;
case '&':
SkASSERT(nextChar != '&');
op = kBitAnd;
break;
case '|':
SkASSERT(nextChar != '|');
op = kBitOr;
break;
case '%':
op = kModulo;
break;
case '~':
op = kBitNot;
break;
}
if (op == kUnassigned)
return 0;
if (fSuppressStack.top().fSuppress == false) {
signed char precedence = gPrecedence[op];
do {
int idx = 0;
SkOp compare;
do {
compare = fOpStack.index(idx);
if ((compare & kArtificialOp) == 0)
break;
idx++;
} while (true);
signed char topPrecedence = gPrecedence[compare];
SkASSERT(topPrecedence != -1);
if (topPrecedence > precedence || (topPrecedence == precedence &&
gOpAttributes[op].fLeftType == kNoType)) {
break;
}
if (processOp() == false)
return 0; // error
} while (true);
if (negateResult)
*fOpStack.push() = (SkOp) (kLogicalNot | kArtificialOp);
fOpStack.push(op);
if (reverseOperands)
*fOpStack.push() = (SkOp) (kFlipOps | kArtificialOp);
}
returnAdv:
return advance;
}
void SkScriptEngine::boxCallBack(_boxCallBack func, void* userStorage) {
UserCallBack callBack;
callBack.fBoxCallBack = func;
commonCallBack(kBox, callBack, userStorage);
}
void SkScriptEngine::commonCallBack(CallBackType type, UserCallBack& callBack, void* userStorage) {
callBack.fCallBackType = type;
callBack.fUserStorage = userStorage;
*fUserCallBacks.prepend() = callBack;
}
bool SkScriptEngine::convertParams(SkTDArray<SkScriptValue>& params,
const SkFunctionParamType* paramTypes, int paramCount) {
if (params.count() > paramCount) {
fError = kTooManyParameters;
return false; // too many parameters passed
}
for (int index = 0; index < params.count(); index++) {
if (convertTo((SkDisplayTypes) paramTypes[index], ¶ms[index]) == false)
return false;
}
return true;
}
bool SkScriptEngine::convertTo(SkDisplayTypes toType, SkScriptValue* value ) {
SkDisplayTypes type = value->fType;
if (type == toType)
return true;
if (ToOpType(type) == kObject) {
#if 0 // !!! I want object->string to get string from displaystringtype, not id
if (ToOpType(toType) == kString) {
bool success = handleObjectToString(value->fOperand.fObject);
if (success == false)
return false;
SkOpType type;
fTypeStack.pop(&type);
value->fType = ToDisplayType(type);
fOperandStack.pop(&value->fOperand);
return true;
}
#endif
if (handleUnbox(value) == false) {
fError = kHandleUnboxFailed;
return false;
}
return convertTo(toType, value);
}
return ConvertTo(this, toType, value);
}
bool SkScriptEngine::evaluateDot(const char*& script, bool suppressed) {
size_t fieldLength = token_length(++script); // skip dot
if (fieldLength == 0) {
fError = kExpectedFieldName;
return false;
}
const char* field = script;
script += fieldLength;
bool success = handleProperty(suppressed);
if (success == false) {
fError = kCouldNotFindReferencedID; // note: never generated by standard animator plugins
return false;
}
return evaluateDotParam(script, suppressed, field, fieldLength);
}
bool SkScriptEngine::evaluateDotParam(const char*& script, bool suppressed,
const char* field, size_t fieldLength) {
void* object;
if (suppressed)
object = NULL;
else {
if (fTypeStack.top() != kObject) {
fError = kDotOperatorExpectsObject;
return false;
}
object = fOperandStack.top().fObject;
fTypeStack.pop();
fOperandStack.pop();
}
char ch; // see if it is a simple member or a function
while (is_ws(ch = script[0]))
script++;
bool success = true;
if (ch != '(') {
if (suppressed == false) {
if ((success = handleMember(field, fieldLength, object)) == false)
fError = kHandleMemberFailed;
}
} else {
SkTDArray<SkScriptValue> params;
*fBraceStack.push() = kFunctionBrace;
success = functionParams(&script, params);
if (success && suppressed == false &&
(success = handleMemberFunction(field, fieldLength, object, params)) == false)
fError = kHandleMemberFunctionFailed;
}
return success;
}
bool SkScriptEngine::evaluateScript(const char** scriptPtr, SkScriptValue* value) {
#ifdef SK_DEBUG
const char** original = scriptPtr;
#endif
bool success;
const char* inner;
if (strncmp(*scriptPtr, "#script:", sizeof("#script:") - 1) == 0) {
*scriptPtr += sizeof("#script:") - 1;
if (fReturnType == kNoType || fReturnType == kString) {
success = innerScript(scriptPtr, value);
if (success == false)
goto end;
inner = value->fOperand.fString->c_str();
scriptPtr = &inner;
}
}
{
success = innerScript(scriptPtr, value);
if (success == false)
goto end;
const char* script = *scriptPtr;
char ch;
while (is_ws(ch = script[0]))
script++;
if (ch != '\0') {
// error may trigger on scripts like "50,0" that were intended to be written as "[50, 0]"
fError = kPrematureEnd;
success = false;
}
}
end:
#ifdef SK_DEBUG
if (success == false) {
SkDebugf("script failed: %s", *original);
if (fError)
SkDebugf(" %s", errorStrings[fError - 1]);
SkDebugf("\n");
}
#endif
return success;
}
void SkScriptEngine::forget(SkTypedArray* array) {
if (array->getType() == SkType_String) {
for (int index = 0; index < array->count(); index++) {
SkString* string = (*array)[index].fString;
int found = fTrackString.find(string);
if (found >= 0)
fTrackString.remove(found);
}
return;
}
if (array->getType() == SkType_Array) {
for (int index = 0; index < array->count(); index++) {
SkTypedArray* child = (*array)[index].fArray;
forget(child); // forgets children of child
int found = fTrackArray.find(child);
if (found >= 0)
fTrackArray.remove(found);
}
}
}
void SkScriptEngine::functionCallBack(_functionCallBack func, void* userStorage) {
UserCallBack callBack;
callBack.fFunctionCallBack = func;
commonCallBack(kFunction, callBack, userStorage);
}
bool SkScriptEngine::functionParams(const char** scriptPtr, SkTDArray<SkScriptValue>& params) {
(*scriptPtr)++; // skip open paren
*fOpStack.push() = kParen;
*fBraceStack.push() = kFunctionBrace;
SkBool suppressed = fSuppressStack.top().fSuppress;
do {
SkScriptValue value;
bool success = innerScript(scriptPtr, suppressed ? NULL : &value);
if (success == false) {
fError = kErrorInFunctionParameters;
return false;
}
if (suppressed)
continue;
*params.append() = value;
} while ((*scriptPtr)[-1] == ',');
fBraceStack.pop();
fOpStack.pop(); // pop paren
(*scriptPtr)++; // advance beyond close paren
return true;
}
#ifdef SK_DEBUG
bool SkScriptEngine::getErrorString(SkString* str) const {
if (fError)
str->set(errorStrings[fError - 1]);
return fError != 0;
}
#endif
bool SkScriptEngine::innerScript(const char** scriptPtr, SkScriptValue* value) {
const char* script = *scriptPtr;
char ch;
bool lastPush = false;
bool success = true;
int opBalance = fOpStack.count();
int baseBrace = fBraceStack.count();
int suppressBalance = fSuppressStack.count();
while ((ch = script[0]) != '\0') {
if (is_ws(ch)) {
script++;
continue;
}
SkBool suppressed = fSuppressStack.top().fSuppress;
SkOperand operand;
const char* dotCheck;
if (fBraceStack.count() > baseBrace) {
#if 0 // disable support for struct brace
if (ch == ':') {
SkASSERT(fTokenLength > 0);
SkASSERT(fBraceStack.top() == kStructBrace);
++script;
SkASSERT(fDisplayable);
SkString token(fToken, fTokenLength);
fTokenLength = 0;
const char* tokenName = token.c_str();
const SkMemberInfo* tokenInfo SK_INIT_TO_AVOID_WARNING;
if (suppressed == false) {
SkDisplayTypes type = fInfo->getType();
tokenInfo = SkDisplayType::GetMember(type, &tokenName);
SkASSERT(tokenInfo);
}
SkScriptValue tokenValue;
success = innerScript(&script, &tokenValue); // terminate and return on comma, close brace
SkASSERT(success);
if (suppressed == false) {
if (tokenValue.fType == SkType_Displayable) {
SkASSERT(SkDisplayType::IsDisplayable(tokenInfo->getType()));
fDisplayable->setReference(tokenInfo, tokenValue.fOperand.fDisplayable);
} else {
if (tokenValue.fType != tokenInfo->getType()) {
if (convertTo(tokenInfo->getType(), &tokenValue) == false)
return false;
}
tokenInfo->writeValue(fDisplayable, NULL, 0, 0,
(void*) ((char*) fInfo->memberData(fDisplayable) + tokenInfo->fOffset + fArrayOffset),
tokenInfo->getType(), tokenValue);
}
}
lastPush = false;
continue;
} else
#endif
if (fBraceStack.top() == kArrayBrace) {
SkScriptValue tokenValue;
success = innerScript(&script, &tokenValue); // terminate and return on comma, close brace
if (success == false) {
fError = kErrorInArrrayIndex;
return false;
}
if (suppressed == false) {
#if 0 // no support for structures for now
if (tokenValue.fType == SkType_Structure) {
fArrayOffset += (int) fInfo->getSize(fDisplayable);
} else
#endif
{
SkDisplayTypes type = ToDisplayType(fReturnType);
if (fReturnType == kNoType) {
// !!! short sighted; in the future, allow each returned array component to carry
// its own type, and let caller do any needed conversions
if (value->fOperand.fArray->count() == 0)
value->fOperand.fArray->setType(type = tokenValue.fType);
else
type = value->fOperand.fArray->getType();
}
if (tokenValue.fType != type) {
if (convertTo(type, &tokenValue) == false)
return false;
}
*value->fOperand.fArray->append() = tokenValue.fOperand;
}
}
lastPush = false;
continue;
} else {
if (token_length(script) == 0) {
fError = kExpectedToken;
return false;
}
}
}
if (lastPush != false && fTokenLength > 0) {
if (ch == '(') {
*fBraceStack.push() = kFunctionBrace;
if (handleFunction(&script, SkToBool(suppressed)) == false)
return false;
lastPush = true;
continue;
} else if (ch == '[') {
if (handleProperty(SkToBool(suppressed)) == false)
return false; // note: never triggered by standard animator plugins
if (handleArrayIndexer(&script, SkToBool(suppressed)) == false)
return false;
lastPush = true;
continue;
} else if (ch != '.') {
if (handleProperty(SkToBool(suppressed)) == false)
return false; // note: never triggered by standard animator plugins
lastPush = true;
continue;
}
}
if (ch == '0' && (script[1] & ~0x20) == 'X') {
if (lastPush != false) {
fError = kExpectedOperator;
return false;
}
script += 2;
script = SkParse::FindHex(script, (uint32_t*)&operand.fS32);
if (script == NULL) {
fError = kExpectedHex;
return false;
}
goto intCommon;
}
if (lastPush == false && ch == '.')
goto scalarCommon;
if (ch >= '0' && ch <= '9') {
if (lastPush != false) {
fError = kExpectedOperator;
return false;
}
dotCheck = SkParse::FindS32(script, &operand.fS32);
if (dotCheck[0] != '.') {
script = dotCheck;
intCommon:
if (suppressed == false)
*fTypeStack.push() = kInt;
} else {
scalarCommon:
script = SkParse::FindScalar(script, &operand.fScalar);
if (suppressed == false)
*fTypeStack.push() = kScalar;
}
if (suppressed == false)
fOperandStack.push(operand);
lastPush = true;
continue;
}
int length = token_length(script);
if (length > 0) {
if (lastPush != false) {
fError = kExpectedOperator;
return false;
}
fToken = script;
fTokenLength = length;
script += length;
lastPush = true;
continue;
}
char startQuote = ch;
if (startQuote == '\'' || startQuote == '\"') {
if (lastPush != false) {
fError = kExpectedOperator;
return false;
}
operand.fString = new SkString();
track(operand.fString);
++script;
// <mrr> this is a lot of calls to append() one char at at time
// how hard to preflight script so we know how much to grow fString by?
do {
if (script[0] == '\\')
++script;
operand.fString->append(script, 1);
++script;
if (script[0] == '\0') {
fError = kUnterminatedString;
return false;
}
} while (script[0] != startQuote);
++script;
if (suppressed == false) {
*fTypeStack.push() = kString;
fOperandStack.push(operand);
}
lastPush = true;
continue;
}
;
if (ch == '.') {
if (fTokenLength == 0) {
SkScriptValue scriptValue;
SkDEBUGCODE(scriptValue.fOperand.fObject = NULL);
int tokenLength = token_length(++script);
const char* token = script;
script += tokenLength;
if (suppressed == false) {
if (fTypeStack.count() == 0) {
fError = kExpectedTokenBeforeDotOperator;
return false;
}
SkOpType topType;
fTypeStack.pop(&topType);
fOperandStack.pop(&scriptValue.fOperand);
scriptValue.fType = ToDisplayType(topType);
handleBox(&scriptValue);
}
success = evaluateDotParam(script, SkToBool(suppressed), token, tokenLength);
if (success == false)
return false;
lastPush = true;
continue;
}
// get next token, and evaluate immediately
success = evaluateDot(script, SkToBool(suppressed));
if (success == false)
return false;
lastPush = true;
continue;
}
if (ch == '[') {
if (lastPush == false) {
script++;
*fBraceStack.push() = kArrayBrace;
if (suppressed)
continue;
operand.fArray = value->fOperand.fArray = new SkTypedArray(ToDisplayType(fReturnType));
track(value->fOperand.fArray);
*fTypeStack.push() = (SkOpType) kArray;
fOperandStack.push(operand);
continue;
}
if (handleArrayIndexer(&script, SkToBool(suppressed)) == false)
return false;
lastPush = true;
continue;
}
#if 0 // structs not supported for now
if (ch == '{') {
if (lastPush == false) {
script++;
*fBraceStack.push() = kStructBrace;
if (suppressed)
continue;
operand.fS32 = 0;
*fTypeStack.push() = (SkOpType) kStruct;
fOperandStack.push(operand);
continue;
}
SkASSERT(0); // braces in other contexts aren't supported yet
}
#endif
if (ch == ')' && fBraceStack.count() > 0) {
SkBraceStyle braceStyle = fBraceStack.top();
if (braceStyle == kFunctionBrace) {
fBraceStack.pop();
break;
}
}
if (ch == ',' || ch == ']') {
if (ch != ',') {
SkBraceStyle match;
fBraceStack.pop(&match);
if (match != kArrayBrace) {
fError = kMismatchedArrayBrace;
return false;
}
}
script++;
// !!! see if brace or bracket is correct closer
break;
}
char nextChar = script[1];
int advance = logicalOp(ch, nextChar);
if (advance < 0) // error
return false;
if (advance == 0)
advance = arithmeticOp(ch, nextChar, lastPush);
if (advance == 0) // unknown token
return false;
if (advance > 0)
script += advance;
lastPush = ch == ']' || ch == ')';
}
bool suppressed = SkToBool(fSuppressStack.top().fSuppress);
if (fTokenLength > 0) {
success = handleProperty(suppressed);
if (success == false)
return false; // note: never triggered by standard animator plugins
}
while (fOpStack.count() > opBalance) { // leave open paren
if ((fError = opError()) != kNoError)
return false;
if (processOp() == false)
return false;
}
SkOpType topType = fTypeStack.count() > 0 ? fTypeStack.top() : kNoType;
if (suppressed == false && topType != fReturnType &&
topType == kString && fReturnType != kNoType) { // if result is a string, give handle property a chance to convert it to the property value
SkString* string = fOperandStack.top().fString;
fToken = string->c_str();
fTokenLength = string->size();
fOperandStack.pop();
fTypeStack.pop();
success = handleProperty(SkToBool(fSuppressStack.top().fSuppress));
if (success == false) { // if it couldn't convert, return string (error?)
SkOperand operand;
operand.fS32 = 0;
*fTypeStack.push() = kString;
operand.fString = string;
fOperandStack.push(operand);
}
}
if (value) {
if (fOperandStack.count() == 0)
return false;
SkASSERT(fOperandStack.count() >= 1);
SkASSERT(fTypeStack.count() >= 1);
fOperandStack.pop(&value->fOperand);
SkOpType type;
fTypeStack.pop(&type);
value->fType = ToDisplayType(type);
// SkASSERT(value->fType != SkType_Unknown);
if (topType != fReturnType && topType == kObject && fReturnType != kNoType) {
if (convertTo(ToDisplayType(fReturnType), value) == false)
return false;
}
}
while (fSuppressStack.count() > suppressBalance)
fSuppressStack.pop();
*scriptPtr = script;
return true; // no error
}
void SkScriptEngine::memberCallBack(_memberCallBack member , void* userStorage) {
UserCallBack callBack;
callBack.fMemberCallBack = member;
commonCallBack(kMember, callBack, userStorage);
}
void SkScriptEngine::memberFunctionCallBack(_memberFunctionCallBack func, void* userStorage) {
UserCallBack callBack;
callBack.fMemberFunctionCallBack = func;
commonCallBack(kMemberFunction, callBack, userStorage);
}
#if 0
void SkScriptEngine::objectToStringCallBack(_objectToStringCallBack func, void* userStorage) {
UserCallBack callBack;
callBack.fObjectToStringCallBack = func;
commonCallBack(kObjectToString, callBack, userStorage);
}
#endif
bool SkScriptEngine::handleArrayIndexer(const char** scriptPtr, bool suppressed) {
SkScriptValue scriptValue;
(*scriptPtr)++;
*fOpStack.push() = kParen;
*fBraceStack.push() = kArrayBrace;
SkOpType saveType = fReturnType;
fReturnType = kInt;
bool success = innerScript(scriptPtr, suppressed == false ? &scriptValue : NULL);
if (success == false)
return false;
fReturnType = saveType;
if (suppressed == false) {
if (convertTo(SkType_Int, &scriptValue) == false)
return false;
int index = scriptValue.fOperand.fS32;
SkScriptValue scriptValue;
SkOpType type;
fTypeStack.pop(&type);
fOperandStack.pop(&scriptValue.fOperand);
scriptValue.fType = ToDisplayType(type);
if (type == kObject) {
success = handleUnbox(&scriptValue);
if (success == false)
return false;
if (ToOpType(scriptValue.fType) != kArray) {
fError = kExpectedArray;
return false;
}
}
*fTypeStack.push() = scriptValue.fOperand.fArray->getOpType();
// SkASSERT(index >= 0);
if ((unsigned) index >= (unsigned) scriptValue.fOperand.fArray->count()) {
fError = kArrayIndexOutOfBounds;
return false;
}
scriptValue.fOperand = scriptValue.fOperand.fArray->begin()[index];
fOperandStack.push(scriptValue.fOperand);
}
fOpStack.pop(); // pop paren
return success;
}
bool SkScriptEngine::handleBox(SkScriptValue* scriptValue) {
bool success = true;
for (UserCallBack* callBack = fUserCallBacks.begin(); callBack < fUserCallBacks.end(); callBack++) {
if (callBack->fCallBackType != kBox)
continue;
success = (*callBack->fBoxCallBack)(callBack->fUserStorage, scriptValue);
if (success) {
fOperandStack.push(scriptValue->fOperand);
*fTypeStack.push() = ToOpType(scriptValue->fType);
goto done;
}
}
done:
return success;
}
bool SkScriptEngine::handleFunction(const char** scriptPtr, bool suppressed) {
SkScriptValue callbackResult;
SkTDArray<SkScriptValue> params;
SkString functionName(fToken, fTokenLength);
fTokenLength = 0;
bool success = functionParams(scriptPtr, params);
if (success == false)
goto done;
if (suppressed == true)
return true;
{
for (UserCallBack* callBack = fUserCallBacks.begin(); callBack < fUserCallBacks.end(); callBack++) {
if (callBack->fCallBackType != kFunction)
continue;
success = (*callBack->fFunctionCallBack)(functionName.c_str(), functionName.size(), params,
callBack->fUserStorage, &callbackResult);
if (success) {
fOperandStack.push(callbackResult.fOperand);
*fTypeStack.push() = ToOpType(callbackResult.fType);
goto done;
}
}
}
fError = kNoFunctionHandlerFound;
return false;
done:
return success;
}
bool SkScriptEngine::handleMember(const char* field, size_t len, void* object) {
SkScriptValue callbackResult;
bool success = true;
for (UserCallBack* callBack = fUserCallBacks.begin(); callBack < fUserCallBacks.end(); callBack++) {
if (callBack->fCallBackType != kMember)
continue;
success = (*callBack->fMemberCallBack)(field, len, object, callBack->fUserStorage, &callbackResult);
if (success) {
if (callbackResult.fType == SkType_String)
track(callbackResult.fOperand.fString);
fOperandStack.push(callbackResult.fOperand);
*fTypeStack.push() = ToOpType(callbackResult.fType);
goto done;
}
}
return false;
done:
return success;
}
bool SkScriptEngine::handleMemberFunction(const char* field, size_t len, void* object, SkTDArray<SkScriptValue>& params) {
SkScriptValue callbackResult;
bool success = true;
for (UserCallBack* callBack = fUserCallBacks.begin(); callBack < fUserCallBacks.end(); callBack++) {
if (callBack->fCallBackType != kMemberFunction)
continue;
success = (*callBack->fMemberFunctionCallBack)(field, len, object, params,
callBack->fUserStorage, &callbackResult);
if (success) {
if (callbackResult.fType == SkType_String)
track(callbackResult.fOperand.fString);
fOperandStack.push(callbackResult.fOperand);
*fTypeStack.push() = ToOpType(callbackResult.fType);
goto done;
}
}
return false;
done:
return success;
}
#if 0
bool SkScriptEngine::handleObjectToString(void* object) {
SkScriptValue callbackResult;
bool success = true;
for (UserCallBack* callBack = fUserCallBacks.begin(); callBack < fUserCallBacks.end(); callBack++) {
if (callBack->fCallBackType != kObjectToString)
continue;
success = (*callBack->fObjectToStringCallBack)(object,
callBack->fUserStorage, &callbackResult);
if (success) {
if (callbackResult.fType == SkType_String)
track(callbackResult.fOperand.fString);
fOperandStack.push(callbackResult.fOperand);
*fTypeStack.push() = ToOpType(callbackResult.fType);
goto done;
}
}
return false;
done:
return success;
}
#endif
bool SkScriptEngine::handleProperty(bool suppressed) {
SkScriptValue callbackResult;
bool success = true;
if (suppressed)
goto done;
success = false; // note that with standard animator-script plugins, callback never returns false
{
for (UserCallBack* callBack = fUserCallBacks.begin(); callBack < fUserCallBacks.end(); callBack++) {
if (callBack->fCallBackType != kProperty)
continue;
success = (*callBack->fPropertyCallBack)(fToken, fTokenLength,
callBack->fUserStorage, &callbackResult);
if (success) {
if (callbackResult.fType == SkType_String && callbackResult.fOperand.fString == NULL) {
callbackResult.fOperand.fString = new SkString(fToken, fTokenLength);
track(callbackResult.fOperand.fString);
}
fOperandStack.push(callbackResult.fOperand);
*fTypeStack.push() = ToOpType(callbackResult.fType);
goto done;
}
}
}
done:
fTokenLength = 0;
return success;
}
bool SkScriptEngine::handleUnbox(SkScriptValue* scriptValue) {
bool success = true;
for (UserCallBack* callBack = fUserCallBacks.begin(); callBack < fUserCallBacks.end(); callBack++) {
if (callBack->fCallBackType != kUnbox)
continue;
success = (*callBack->fUnboxCallBack)(callBack->fUserStorage, scriptValue);
if (success) {
if (scriptValue->fType == SkType_String)
track(scriptValue->fOperand.fString);
goto done;
}
}
return false;
done:
return success;
}
// note that entire expression is treated as if it were enclosed in parens
// an open paren is always the first thing in the op stack
int SkScriptEngine::logicalOp(char ch, char nextChar) {
int advance = 1;
SkOp match;
signed char precedence;
switch (ch) {
case ')':
match = kParen;
break;
case ']':
match = kArrayOp;
break;
case '?':
match = kIf;
break;
case ':':
match = kElse;
break;
case '&':
if (nextChar != '&')
goto noMatch;
match = kLogicalAnd;
advance = 2;
break;
case '|':
if (nextChar != '|')
goto noMatch;
match = kLogicalOr;
advance = 2;
break;
default:
noMatch:
return 0;
}
SkSuppress suppress;
precedence = gPrecedence[match];
if (fSuppressStack.top().fSuppress) {
if (fSuppressStack.top().fOpStackDepth < fOpStack.count()) {
SkOp topOp = fOpStack.top();
if (gPrecedence[topOp] <= precedence)
fOpStack.pop();
goto goHome;
}
bool changedPrecedence = gPrecedence[fSuppressStack.top().fOperator] < precedence;
if (changedPrecedence)
fSuppressStack.pop();
if (precedence == kIfElsePrecedence) {
if (match == kIf) {
if (changedPrecedence)
fOpStack.pop();
else
*fOpStack.push() = kIf;
} else {
if (fSuppressStack.top().fOpStackDepth == fOpStack.count()) {
goto flipSuppress;
}
fOpStack.pop();
}
}
if (changedPrecedence == false)
goto goHome;
}
while (gPrecedence[fOpStack.top() & ~kArtificialOp] < precedence) {
if (processOp() == false)
return false;
}
if (fSuppressStack.top().fOpStackDepth > fOpStack.count())
fSuppressStack.pop();
switch (match) {
case kParen:
case kArrayOp:
if (fOpStack.count() <= 1 || fOpStack.top() != match) {
fError = kMismatchedBrackets;
return -1;
}
if (match == kParen)
fOpStack.pop();
else {
SkOpType indexType;
fTypeStack.pop(&indexType);
if (indexType != kInt && indexType != kScalar) {
fError = kExpectedNumberForArrayIndex; // (although, could permit strings eventually)
return -1;
}
SkOperand indexOperand;
fOperandStack.pop(&indexOperand);
int index = indexType == kScalar ? SkScalarFloor(indexOperand.fScalar) :
indexOperand.fS32;
SkOpType arrayType;
fTypeStack.pop(&arrayType);
if ((unsigned)arrayType != (unsigned)kArray) {
fError = kExpectedArray;
return -1;
}
SkOperand arrayOperand;
fOperandStack.pop(&arrayOperand);
SkTypedArray* array = arrayOperand.fArray;
SkOperand operand;
if (array->getIndex(index, &operand) == false) {
fError = kIndexOutOfRange;
return -1;
}
SkOpType resultType = array->getOpType();
fTypeStack.push(resultType);
fOperandStack.push(operand);
}
break;
case kIf: {
SkScriptValue ifValue;
SkOpType ifType;
fTypeStack.pop(&ifType);
ifValue.fType = ToDisplayType(ifType);
fOperandStack.pop(&ifValue.fOperand);
if (convertTo(SkType_Int, &ifValue) == false)
return -1;
if (ifValue.fType != SkType_Int) {
fError = kExpectedIntForConditionOperator;
return -1;
}
suppress.fSuppress = ifValue.fOperand.fS32 == 0;
suppress.fOperator = kIf;
suppress.fOpStackDepth = fOpStack.count();
suppress.fElse = false;
fSuppressStack.push(suppress);
// if left is true, do only up to colon
// if left is false, do only after colon
} break;
case kElse:
flipSuppress:
if (fSuppressStack.top().fElse)
fSuppressStack.pop();
fSuppressStack.top().fElse = true;
fSuppressStack.top().fSuppress ^= true;
// flip last do / don't do consideration from last '?'
break;
case kLogicalAnd:
case kLogicalOr: {
if (fTypeStack.top() != kInt) {
fError = kExpectedBooleanExpression;
return -1;
}
int32_t topInt = fOperandStack.top().fS32;
if (fOpStack.top() != kLogicalAnd)
*fOpStack.push() = kLogicalAnd; // really means 'to bool', and is appropriate for 'or'
if (match == kLogicalOr ? topInt != 0 : topInt == 0) {
suppress.fSuppress = true;
suppress.fOperator = match;
suppress.fOpStackDepth = fOpStack.count();
suppress.fElse = false;
fSuppressStack.push(suppress);
} else {
fTypeStack.pop();
fOperandStack.pop();
}
} break;
default:
SkASSERT(0);
}
goHome:
return advance;
}
SkScriptEngine::Error SkScriptEngine::opError() {
int opCount = fOpStack.count();
int operandCount = fOperandStack.count();
if (opCount == 0) {
if (operandCount != 1)
return kExpectedOperator;
return kNoError;
}
SkOp op = (SkOp) (fOpStack.top() & ~kArtificialOp);
const SkOperatorAttributes* attributes = &gOpAttributes[op];
if (attributes->fLeftType != kNoType && operandCount < 2)
return kExpectedValue;
if (attributes->fLeftType == kNoType && operandCount < 1)
return kExpectedValue;
return kNoError;
}
bool SkScriptEngine::processOp() {
SkOp op;
fOpStack.pop(&op);
op = (SkOp) (op & ~kArtificialOp);
const SkOperatorAttributes* attributes = &gOpAttributes[op];
SkOpType type2;
fTypeStack.pop(&type2);
SkOpType type1 = type2;
SkOperand operand2;
fOperandStack.pop(&operand2);
SkOperand operand1 = operand2; // !!! not really needed, suppresses warning
if (attributes->fLeftType != kNoType) {
fTypeStack.pop(&type1);
fOperandStack.pop(&operand1);
if (op == kFlipOps) {
SkTSwap(type1, type2);
SkTSwap(operand1, operand2);
fOpStack.pop(&op);
op = (SkOp) (op & ~kArtificialOp);
attributes = &gOpAttributes[op];
}
if (type1 == kObject && (type1 & attributes->fLeftType) == 0) {
SkScriptValue val;
val.fType = ToDisplayType(type1);
val.fOperand = operand1;
bool success = handleUnbox(&val);
if (success == false)
return false;
type1 = ToOpType(val.fType);
operand1 = val.fOperand;
}
}
if (type2 == kObject && (type2 & attributes->fLeftType) == 0) {
SkScriptValue val;
val.fType = ToDisplayType(type2);
val.fOperand = operand2;
bool success = handleUnbox(&val);
if (success == false)
return false;
type2 = ToOpType(val.fType);
operand2 = val.fOperand;
}
if (attributes->fLeftType != kNoType) {
if (type1 != type2) {
if ((attributes->fLeftType & kString) && attributes->fBias & kTowardsString && ((type1 | type2) & kString)) {
if (type1 == kInt || type1 == kScalar) {
convertToString(operand1, type1 == kInt ? SkType_Int : SkType_Float);
type1 = kString;
}
if (type2 == kInt || type2 == kScalar) {
convertToString(operand2, type2 == kInt ? SkType_Int : SkType_Float);
type2 = kString;
}
} else if (attributes->fLeftType & kScalar && ((type1 | type2) & kScalar)) {
if (type1 == kInt) {
operand1.fScalar = IntToScalar(operand1.fS32);
type1 = kScalar;
}
if (type2 == kInt) {
operand2.fScalar = IntToScalar(operand2.fS32);
type2 = kScalar;
}
}
}
if ((type1 & attributes->fLeftType) == 0 || type1 != type2) {
if (type1 == kString) {
const char* result = SkParse::FindScalar(operand1.fString->c_str(), &operand1.fScalar);
if (result == NULL) {
fError = kExpectedNumber;
return false;
}
type1 = kScalar;
}
if (type1 == kScalar && (attributes->fLeftType == kInt || type2 == kInt)) {
operand1.fS32 = SkScalarFloor(operand1.fScalar);
type1 = kInt;
}
}
}
if ((type2 & attributes->fRightType) == 0 || type1 != type2) {
if (type2 == kString) {
const char* result = SkParse::FindScalar(operand2.fString->c_str(), &operand2.fScalar);
if (result == NULL) {
fError = kExpectedNumber;
return false;
}
type2 = kScalar;
}
if (type2 == kScalar && (attributes->fRightType == kInt || type1 == kInt)) {
operand2.fS32 = SkScalarFloor(operand2.fScalar);
type2 = kInt;
}
}
if (type2 == kScalar)
op = (SkOp) (op + 1);
else if (type2 == kString)
op = (SkOp) (op + 2);
switch(op) {
case kAddInt:
operand2.fS32 += operand1.fS32;
break;
case kAddScalar:
operand2.fScalar += operand1.fScalar;
break;
case kAddString:
if (fTrackString.find(operand1.fString) < 0) {
operand1.fString = SkNEW_ARGS(SkString, (*operand1.fString));
track(operand1.fString);
}
operand1.fString->append(*operand2.fString);
operand2 = operand1;
break;
case kBitAnd:
operand2.fS32 &= operand1.fS32;
break;
case kBitNot:
operand2.fS32 = ~operand2.fS32;
break;
case kBitOr:
operand2.fS32 |= operand1.fS32;
break;
case kDivideInt:
if (operand2.fS32 == 0) {
operand2.fS32 = operand1.fS32 == 0 ? SK_NaN32 : operand1.fS32 > 0 ? SK_MaxS32 : -SK_MaxS32;
break;
} else {
int32_t original = operand2.fS32;
operand2.fS32 = operand1.fS32 / operand2.fS32;
if (original * operand2.fS32 == operand1.fS32)
break; // integer divide was good enough
operand2.fS32 = original;
type2 = kScalar;
}
case kDivideScalar:
if (operand2.fScalar == 0)
operand2.fScalar = operand1.fScalar == 0 ? SK_ScalarNaN : operand1.fScalar > 0 ? SK_ScalarMax : -SK_ScalarMax;
else
operand2.fScalar = SkScalarDiv(operand1.fScalar, operand2.fScalar);
break;
case kEqualInt:
operand2.fS32 = operand1.fS32 == operand2.fS32;
break;
case kEqualScalar:
operand2.fS32 = operand1.fScalar == operand2.fScalar;
type2 = kInt;
break;
case kEqualString:
operand2.fS32 = *operand1.fString == *operand2.fString;
type2 = kInt;
break;
case kGreaterEqualInt:
operand2.fS32 = operand1.fS32 >= operand2.fS32;
break;
case kGreaterEqualScalar:
operand2.fS32 = operand1.fScalar >= operand2.fScalar;
type2 = kInt;
break;
case kGreaterEqualString:
operand2.fS32 = strcmp(operand1.fString->c_str(), operand2.fString->c_str()) >= 0;
type2 = kInt;
break;
case kLogicalAnd:
operand2.fS32 = !! operand2.fS32; // really, ToBool
break;
case kLogicalNot:
operand2.fS32 = ! operand2.fS32;
break;
case kLogicalOr:
SkASSERT(0); // should have already been processed
break;
case kMinusInt:
operand2.fS32 = -operand2.fS32;
break;
case kMinusScalar:
operand2.fScalar = -operand2.fScalar;
break;
case kModuloInt:
operand2.fS32 = operand1.fS32 % operand2.fS32;
break;
case kModuloScalar:
operand2.fScalar = SkScalarMod(operand1.fScalar, operand2.fScalar);
break;
case kMultiplyInt:
operand2.fS32 *= operand1.fS32;
break;
case kMultiplyScalar:
operand2.fScalar = SkScalarMul(operand1.fScalar, operand2.fScalar);
break;
case kShiftLeft:
operand2.fS32 = operand1.fS32 << operand2.fS32;
break;
case kShiftRight:
operand2.fS32 = operand1.fS32 >> operand2.fS32;
break;
case kSubtractInt:
operand2.fS32 = operand1.fS32 - operand2.fS32;
break;
case kSubtractScalar:
operand2.fScalar = operand1.fScalar - operand2.fScalar;
break;
case kXor:
operand2.fS32 ^= operand1.fS32;
break;
default:
SkASSERT(0);
}
fTypeStack.push(type2);
fOperandStack.push(operand2);
return true;
}
void SkScriptEngine::propertyCallBack(_propertyCallBack prop, void* userStorage) {
UserCallBack callBack;
callBack.fPropertyCallBack = prop;
commonCallBack(kProperty, callBack, userStorage);
}
void SkScriptEngine::track(SkTypedArray* array) {
SkASSERT(fTrackArray.find(array) < 0);
*(fTrackArray.end() - 1) = array;
fTrackArray.appendClear();
}
void SkScriptEngine::track(SkString* string) {
SkASSERT(fTrackString.find(string) < 0);
*(fTrackString.end() - 1) = string;
fTrackString.appendClear();
}
void SkScriptEngine::unboxCallBack(_unboxCallBack func, void* userStorage) {
UserCallBack callBack;
callBack.fUnboxCallBack = func;
commonCallBack(kUnbox, callBack, userStorage);
}
bool SkScriptEngine::ConvertTo(SkScriptEngine* engine, SkDisplayTypes toType, SkScriptValue* value ) {
SkASSERT(value);
if (SkDisplayType::IsEnum(NULL /* fMaker */, toType))
toType = SkType_Int;
if (toType == SkType_Point || toType == SkType_3D_Point)
toType = SkType_Float;
if (toType == SkType_Drawable)
toType = SkType_Displayable;
SkDisplayTypes type = value->fType;
if (type == toType)
return true;
SkOperand& operand = value->fOperand;
bool success = true;
switch (toType) {
case SkType_Int:
if (type == SkType_Boolean)
break;
if (type == SkType_Float)
operand.fS32 = SkScalarFloor(operand.fScalar);
else {
if (type != SkType_String) {
success = false;
break; // error
}
success = SkParse::FindS32(operand.fString->c_str(), &operand.fS32) != NULL;
}
break;
case SkType_Float:
if (type == SkType_Int) {
if (operand.fS32 == SK_NaN32)
operand.fScalar = SK_ScalarNaN;
else if (SkAbs32(operand.fS32) == SK_MaxS32)
operand.fScalar = SkSign32(operand.fS32) * SK_ScalarMax;
else
operand.fScalar = SkIntToScalar(operand.fS32);
} else {
if (type != SkType_String) {
success = false;
break; // error
}
success = SkParse::FindScalar(operand.fString->c_str(), &operand.fScalar) != NULL;
}
break;
case SkType_String: {
SkString* strPtr = new SkString();
SkASSERT(engine);
engine->track(strPtr);
if (type == SkType_Int)
strPtr->appendS32(operand.fS32);
else if (type == SkType_Displayable)
SkASSERT(0); // must call through instance version instead of static version
else {
if (type != SkType_Float) {
success = false;
break;
}
strPtr->appendScalar(operand.fScalar);
}
operand.fString = strPtr;
} break;
case SkType_Array: {
SkTypedArray* array = new SkTypedArray(type);
*array->append() = operand;
engine->track(array);
operand.fArray = array;
} break;
default:
SkASSERT(0);
}
value->fType = toType;
if (success == false)
engine->fError = kTypeConversionFailed;
return success;
}
SkScalar SkScriptEngine::IntToScalar(int32_t s32) {
SkScalar scalar;
if (s32 == SK_NaN32)
scalar = SK_ScalarNaN;
else if (SkAbs32(s32) == SK_MaxS32)
scalar = SkSign32(s32) * SK_ScalarMax;
else
scalar = SkIntToScalar(s32);
return scalar;
}
SkDisplayTypes SkScriptEngine::ToDisplayType(SkOpType type) {
int val = type;
switch (val) {
case kNoType:
return SkType_Unknown;
case kInt:
return SkType_Int;
case kScalar:
return SkType_Float;
case kString:
return SkType_String;
case kArray:
return SkType_Array;
case kObject:
return SkType_Displayable;
// case kStruct:
// return SkType_Structure;
default:
SkASSERT(0);
return SkType_Unknown;
}
}
SkScriptEngine::SkOpType SkScriptEngine::ToOpType(SkDisplayTypes type) {
if (SkDisplayType::IsDisplayable(NULL /* fMaker */, type))
return (SkOpType) kObject;
if (SkDisplayType::IsEnum(NULL /* fMaker */, type))
return kInt;
switch (type) {
case SkType_ARGB:
case SkType_MSec:
case SkType_Int:
return kInt;
case SkType_Float:
case SkType_Point:
case SkType_3D_Point:
return kScalar;
case SkType_Base64:
case SkType_DynamicString:
case SkType_String:
return kString;
case SkType_Array:
return (SkOpType) kArray;
case SkType_Unknown:
return kNoType;
default:
SkASSERT(0);
return kNoType;
}
}
bool SkScriptEngine::ValueToString(SkScriptValue value, SkString* string) {
switch (value.fType) {
case kInt:
string->reset();
string->appendS32(value.fOperand.fS32);
break;
case kScalar:
string->reset();
string->appendScalar(value.fOperand.fScalar);
break;
case kString:
string->set(*value.fOperand.fString);
break;
default:
SkASSERT(0);
return false;
}
return true; // no error
}
#ifdef SK_SUPPORT_UNITTEST
#include "SkFloatingPoint.h"
#define DEF_SCALAR_ANSWER 0
#define DEF_STRING_ANSWER NULL
#define testInt(expression) { #expression, SkType_Int, expression, DEF_SCALAR_ANSWER, DEF_STRING_ANSWER }
#ifdef SK_SCALAR_IS_FLOAT
#define testScalar(expression) { #expression, SkType_Float, 0, (float) expression, DEF_STRING_ANSWER }
#define testRemainder(exp1, exp2) { #exp1 "%" #exp2, SkType_Float, 0, sk_float_mod(exp1, exp2), DEF_STRING_ANSWER }
#else
#define testScalar(expression) { #expression, SkType_Float, 0, (int) ((expression) * 65536.0f), DEF_STRING_ANSWER }
#define testRemainder(exp1, exp2) { #exp1 "%" #exp2, SkType_Float, 0, (int) (sk_float_mod(exp1, exp2) * 65536.0f), DEF_STRING_ANSWER }
#endif
#define testTrue(expression) { #expression, SkType_Int, 1, DEF_SCALAR_ANSWER, DEF_STRING_ANSWER }
#define testFalse(expression) { #expression, SkType_Int, 0, DEF_SCALAR_ANSWER, DEF_STRING_ANSWER }
static const SkScriptNAnswer scriptTests[] = {
testInt(1>1/2),
testInt((6+7)*8),
testInt(0&&1?2:3),
testInt(3*(4+5)),
testScalar(1.0+2.0),
testScalar(1.0+5),
testScalar(3.0-1.0),
testScalar(6-1.0),
testScalar(- -5.5- -1.5),
testScalar(2.5*6.),
testScalar(0.5*4),
testScalar(4.5/.5),
testScalar(9.5/19),
testRemainder(9.5, 0.5),
testRemainder(9.,2),
testRemainder(9,2.5),
testRemainder(-9,2.5),
testTrue(-9==-9.0),
testTrue(-9.==-4.0-5),
testTrue(-9.*1==-4-5),
testFalse(-9!=-9.0),
testFalse(-9.!=-4.0-5),
testFalse(-9.*1!=-4-5),
testInt(0x123),
testInt(0XABC),
testInt(0xdeadBEEF),
{ "'123'+\"456\"", SkType_String, 0, 0, "123456" },
{ "123+\"456\"", SkType_String, 0, 0, "123456" },
{ "'123'+456", SkType_String, 0, 0, "123456" },
{ "'123'|\"456\"", SkType_Int, 123|456, DEF_SCALAR_ANSWER, DEF_STRING_ANSWER },
{ "123|\"456\"", SkType_Int, 123|456, DEF_SCALAR_ANSWER, DEF_STRING_ANSWER },
{ "'123'|456", SkType_Int, 123|456, DEF_SCALAR_ANSWER, DEF_STRING_ANSWER },
{ "'2'<11", SkType_Int, 1, DEF_SCALAR_ANSWER, DEF_STRING_ANSWER },
{ "2<'11'", SkType_Int, 1, DEF_SCALAR_ANSWER, DEF_STRING_ANSWER },
{ "'2'<'11'", SkType_Int, 0, DEF_SCALAR_ANSWER, DEF_STRING_ANSWER },
testInt(123),
testInt(-345),
testInt(+678),
testInt(1+2+3),
testInt(3*4+5),
testInt(6+7*8),
testInt(-1-2-8/4),
testInt(-9%4),
testInt(9%-4),
testInt(-9%-4),
testInt(123|978),
testInt(123&978),
testInt(123^978),
testInt(2<<4),
testInt(99>>3),
testInt(~55),
testInt(~~55),
testInt(!55),
testInt(!!55),
// both int
testInt(2<2),
testInt(2<11),
testInt(20<11),
testInt(2<=2),
testInt(2<=11),
testInt(20<=11),
testInt(2>2),
testInt(2>11),
testInt(20>11),
testInt(2>=2),
testInt(2>=11),
testInt(20>=11),
testInt(2==2),
testInt(2==11),
testInt(20==11),
testInt(2!=2),
testInt(2!=11),
testInt(20!=11),
// left int, right scalar
testInt(2<2.),
testInt(2<11.),
testInt(20<11.),
testInt(2<=2.),
testInt(2<=11.),
testInt(20<=11.),
testInt(2>2.),
testInt(2>11.),
testInt(20>11.),
testInt(2>=2.),
testInt(2>=11.),
testInt(20>=11.),
testInt(2==2.),
testInt(2==11.),
testInt(20==11.),
testInt(2!=2.),
testInt(2!=11.),
testInt(20!=11.),
// left scalar, right int
testInt(2.<2),
testInt(2.<11),
testInt(20.<11),
testInt(2.<=2),
testInt(2.<=11),
testInt(20.<=11),
testInt(2.>2),
testInt(2.>11),
testInt(20.>11),
testInt(2.>=2),
testInt(2.>=11),
testInt(20.>=11),
testInt(2.==2),
testInt(2.==11),
testInt(20.==11),
testInt(2.!=2),
testInt(2.!=11),
testInt(20.!=11),
// both scalar
testInt(2.<11.),
testInt(20.<11.),
testInt(2.<=2.),
testInt(2.<=11.),
testInt(20.<=11.),
testInt(2.>2.),
testInt(2.>11.),
testInt(20.>11.),
testInt(2.>=2.),
testInt(2.>=11.),
testInt(20.>=11.),
testInt(2.==2.),
testInt(2.==11.),
testInt(20.==11.),
testInt(2.!=2.),
testInt(2.!=11.),
testInt(20.!=11.),
// int, string (string is int)
testFalse(2<'2'),
testTrue(2<'11'),
testFalse(20<'11'),
testTrue(2<='2'),
testTrue(2<='11'),
testFalse(20<='11'),
testFalse(2>'2'),
testFalse(2>'11'),
testTrue(20>'11'),
testTrue(2>='2'),
testFalse(2>='11'),
testTrue(20>='11'),
testTrue(2=='2'),
testFalse(2=='11'),
testFalse(2!='2'),
testTrue(2!='11'),
// int, string (string is scalar)
testFalse(2<'2.'),
testTrue(2<'11.'),
testFalse(20<'11.'),
testTrue(2=='2.'),
testFalse(2=='11.'),
// scalar, string
testFalse(2.<'2.'),
testTrue(2.<'11.'),
testFalse(20.<'11.'),
testTrue(2.=='2.'),
testFalse(2.=='11.'),
// string, int
testFalse('2'<2),
testTrue('2'<11),
testFalse('20'<11),
testTrue('2'==2),
testFalse('2'==11),
// string, scalar
testFalse('2'<2.),
testTrue('2'<11.),
testFalse('20'<11.),
testTrue('2'==2.),
testFalse('2'==11.),
// string, string
testFalse('2'<'2'),
testFalse('2'<'11'),
testFalse('20'<'11'),
testTrue('2'=='2'),
testFalse('2'=='11'),
// logic
testInt(1?2:3),
testInt(0?2:3),
testInt(1&&2||3),
testInt(1&&0||3),
testInt(1&&0||0),
testInt(1||0&&3),
testInt(0||0&&3),
testInt(0||1&&3),
testInt(1?(2?3:4):5),
testInt(0?(2?3:4):5),
testInt(1?(0?3:4):5),
testInt(0?(0?3:4):5),
testInt(1?2?3:4:5),
testInt(0?2?3:4:5),
testInt(1?0?3:4:5),
testInt(0?0?3:4:5),
testInt(1?2:(3?4:5)),
testInt(0?2:(3?4:5)),
testInt(1?0:(3?4:5)),
testInt(0?0:(3?4:5)),
testInt(1?2:3?4:5),
testInt(0?2:3?4:5),
testInt(1?0:3?4:5),
testInt(0?0:3?4:5)
, { "123.5", SkType_Float, 0, SkIntToScalar(123) + SK_Scalar1/2, DEF_STRING_ANSWER }
};
#define SkScriptNAnswer_testCount SK_ARRAY_COUNT(scriptTests)
void SkScriptEngine::UnitTest() {
for (unsigned index = 0; index < SkScriptNAnswer_testCount; index++) {
SkScriptEngine engine(SkScriptEngine::ToOpType(scriptTests[index].fType));
SkScriptValue value;
const char* script = scriptTests[index].fScript;
SkASSERT(engine.evaluateScript(&script, &value) == true);
SkASSERT(value.fType == scriptTests[index].fType);
SkScalar error;
switch (value.fType) {
case SkType_Int:
SkASSERT(value.fOperand.fS32 == scriptTests[index].fIntAnswer);
break;
case SkType_Float:
error = SkScalarAbs(value.fOperand.fScalar - scriptTests[index].fScalarAnswer);
SkASSERT(error < SK_Scalar1 / 10000);
break;
case SkType_String:
SkASSERT(strcmp(value.fOperand.fString->c_str(), scriptTests[index].fStringAnswer) == 0);
break;
default:
SkASSERT(0);
}
}
}
#endif