const char* csConditionEvaluator::ResolveExpValue (const csExpressionToken& value,
CondOperand& operand)
{
if (value.type == tokenNumber)
{
csString number;
number.Append (value.tokenStart, value.tokenLen);
bool isFloat = (strpbrk (number, ".eE") != 0);
if (isFloat)
{
char dummy;
if (csScanStr (number, "%f%c", &operand.floatVal, &dummy) != 1)
{
return SetLastError ("Malformed float value: %s",
CS::Quote::Single (number.GetData()));
}
operand.type = operandFloat;
}
else
{
char dummy;
if (sscanf (number, "%d%c", &operand.intVal, &dummy) != 1)
{
return SetLastError ("Malformed int value: %s",
CS::Quote::Single (number.GetData()));
}
operand.type = operandInt;
}
return 0;
}
else if (value.type == tokenIdentifier)
{
if (TokenEquals (value.tokenStart, value.tokenLen, "true"))
{
operand.type = operandBoolean;
operand.boolVal = true;
return 0;
}
else if (TokenEquals (value.tokenStart, value.tokenLen, "false"))
{
operand.type = operandBoolean;
operand.boolVal = false;
return 0;
}
else
{
return SetLastError ("Unknown identifier %s",
CS::Quote::Single (csExpressionToken::Extractor (value).Get ()));
}
}
else
{
return SetLastError ("Value of %s of type %s",
CS::Quote::Single (csExpressionToken::Extractor (value).Get ()),
CS::Quote::Single (csExpressionToken::TypeDescription (value.type)));
}
CS_ASSERT (false);
return 0;
}
const char* csConditionEvaluator::ResolveOperand (csExpression* expression,
CondOperand& operand)
{
const char* err;
if (expression->type == csExpression::Value)
{
err = ResolveExpValue (expression->valueValue, operand);
if (err)
{
return SetLastError ("Can't resolve value %s: %s",
CS::Quote::Single (csExpressionToken::Extractor (expression->valueValue).Get ()),
err);
}
return 0;
}
const csExpressionToken& t = expression->expressionValue.op;
if (TokenEquals (t.tokenStart, t.tokenLen, "."))
{
CS_ASSERT (expression->expressionValue.left->type
== csExpression::Value);
const csExpressionToken& left =
expression->expressionValue.left->valueValue;
if (TokenEquals (left.tokenStart, left.tokenLen, "vars"))
{
err = ResolveSVIdentifier (expression->expressionValue.right,
operand);
if (err)
return err;
return 0;
}
else if (TokenEquals (left.tokenStart, left.tokenLen, "consts"))
{
err = ResolveConst (expression->expressionValue.right,
operand);
if (err)
return err;
return 0;
}
else
{
return SetLastError ("Unknown identifier %s",
CS::Quote::Single (csExpressionToken::Extractor (left).Get ()));
}
}
else
{
operand.type = operandOperation;
err = ProcessExpressionInternal (expression, operand.operation);
if (err)
return err;
return 0;
}
CS_ASSERT (false);
return 0;
}
void CapstoneTokenizer::TokenToRichText(const InstructionToken & instr, QList<RichTextPainter::CustomRichText_t> & richTextList, const SingleToken* highlightToken)
{
QColor highlightColor = ConfigColor("InstructionHighlightColor");
for(const auto & token : instr.tokens)
{
RichTextPainter::CustomRichText_t richText;
richText.highlight = TokenEquals(&token, highlightToken);
richText.highlightColor = highlightColor;
richText.flags = RichTextPainter::FlagNone;
richText.text = token.text;
auto found = colorNamesMap.find(token.type);
if(found != colorNamesMap.end())
{
auto tokenColor = found->second;
richText.flags = tokenColor.flags;
richText.textColor = tokenColor.color;
richText.textBackground = tokenColor.backgroundColor;
}
richTextList.append(richText);
}
}
internal bool
KwmParseRule(std::string RuleSym, window_rule *Rule)
{
tokenizer Tokenizer = {};
Tokenizer.At = const_cast<char*>(RuleSym.c_str());
bool Result = true;
bool Parsing = true;
while(Parsing)
{
token Token = GetToken(&Tokenizer);
switch(Token.Type)
{
case Token_EndOfStream:
{
Parsing = false;
} break;
case Token_Unknown:
{
} break;
case Token_Identifier:
{
if(TokenEquals(Token, "owner"))
Result = Result && ParseIdentifier(&Tokenizer, &Rule->Owner);
else if(TokenEquals(Token, "name"))
Result = Result && ParseIdentifier(&Tokenizer, &Rule->Name);
else if(TokenEquals(Token, "role"))
Result = Result && ParseIdentifier(&Tokenizer, &Rule->Role);
else if(TokenEquals(Token, "crole"))
Result = Result && ParseIdentifier(&Tokenizer, &Rule->CustomRole);
else if(TokenEquals(Token, "properties"))
Result = Result && ParseProperties(&Tokenizer, &Rule->Properties);
else if(TokenEquals(Token, "except"))
Result = Result && ParseIdentifier(&Tokenizer, &Rule->Except);
} break;
default: { } break;
}
}
return Result;
}
internal bool
ParseProperties(tokenizer *Tokenizer, window_properties *Properties)
{
if(RequireToken(Tokenizer, Token_Equals))
{
if(RequireToken(Tokenizer, Token_OpenBrace))
{
Properties->Scratchpad = -1;
Properties->Display = -1;
Properties->Space = -1;
Properties->Float = -1;
bool ValidState = true;
while(ValidState)
{
token Token = GetToken(Tokenizer);
switch(Token.Type)
{
case Token_SemiColon: { continue; } break;
case Token_CloseBrace: { ValidState = false; } break;
case Token_Identifier:
{
if(TokenEquals(Token, "float"))
{
std::string Value;
if(ParseIdentifier(Tokenizer, &Value))
{
if(Value == "true")
Properties->Float = 1;
else if(Value == "false")
Properties->Float = 0;
}
}
else if(TokenEquals(Token, "display"))
{
std::string Value;
if(ParseIdentifier(Tokenizer, &Value))
Properties->Display = ConvertStringToInt(Value);
}
else if(TokenEquals(Token, "space"))
{
std::string Value;
if(ParseIdentifier(Tokenizer, &Value))
Properties->Space = ConvertStringToInt(Value);
}
else if(TokenEquals(Token, "scratchpad"))
{
std::string Value;
if(ParseIdentifier(Tokenizer, &Value))
{
if(Value == "visible")
Properties->Scratchpad = 1;
else if(Value == "hidden")
Properties->Scratchpad = 0;
}
}
else if(TokenEquals(Token, "role"))
{
std::string Value;
if(ParseIdentifier(Tokenizer, &Value))
Properties->Role = Value;
}
} break;
default: { ReportInvalidRule("Expected token of type Token_Identifier: '" + std::string(Token.Text, Token.TextLength) + "'"); } break;
}
}
return true;
}
else
{
ReportInvalidRule("Expected token '{'");
}
}
else
{
ReportInvalidRule("Expected token '='");
}
return false;
}
const char* csConditionEvaluator::ProcessExpressionInternal (csExpression* expression,
CondOperation& operation)
{
const char* err;
CondOperation newOp;
if (expression->type == csExpression::Value)
{
newOp.operation = opEqual;
err = ResolveExpValue (expression->valueValue, newOp.left);
if (err)
{
return SetLastError ("Can't resolve value '%s': %s",
csExpressionToken::Extractor (expression->valueValue).Get (), err);
}
newOp.right.type = operandBoolean;
newOp.right.boolVal = true;
if (!OpTypesCompatible (newOp.left.type, newOp.right.type))
{
return SetLastError ("Type of '%s' is '%s', not compatible to '%s'",
csExpressionToken::Extractor (expression->valueValue).Get (), OperandTypeDescription (newOp.left.type),
OperandTypeDescription (newOp.right.type));
}
}
else
{
const csExpressionToken& t = expression->expressionValue.op;
if (TokenEquals (t.tokenStart, t.tokenLen, "."))
{
newOp.operation = opEqual;
err = ResolveOperand (expression, newOp.left);
if (err != 0) return err;
newOp.right.Clear();
newOp.right.type = operandBoolean;
newOp.right.boolVal = true;
}
else if (TokenEquals (t.tokenStart, t.tokenLen, "!"))
{
newOp.operation = opEqual;
err = ResolveOperand (expression->expressionValue.right, newOp.left);
if (err)
return err;
if (!OpTypesCompatible (newOp.left.type, operandBoolean))
{
return SetLastError ("Type of '%s' is '%s', not compatible to '%s'",
csExpressionToken::Extractor (t).Get (), OperandTypeDescription (newOp.left.type),
OperandTypeDescription (operandBoolean));
}
newOp.right.Clear();
newOp.right.type = operandBoolean;
newOp.right.boolVal = false;
}
else if (TokenEquals (t.tokenStart, t.tokenLen, "=="))
{
newOp.operation = opEqual;
err = ResolveOperand (expression->expressionValue.left, newOp.left);
if (err)
return err;
err = ResolveOperand (expression->expressionValue.right, newOp.right);
if (err)
return err;
if (!OpTypesCompatible (newOp.left.type, newOp.right.type))
{
return SetLastError ("Type of '%s' is '%s', not compatible to '%s'",
csExpressionToken::Extractor (t).Get (), OperandTypeDescription (newOp.left.type),
OperandTypeDescription (newOp.right.type));
}
}
else if (TokenEquals (t.tokenStart, t.tokenLen, "!="))
{
newOp.operation = opNEqual;
err = ResolveOperand (expression->expressionValue.left, newOp.left);
if (err)
return err;
err = ResolveOperand (expression->expressionValue.right, newOp.right);
if (err)
return err;
if (!OpTypesCompatible (newOp.left.type, newOp.right.type))
{
return SetLastError ("Type of '%s' is '%s', not compatible to '%s'",
csExpressionToken::Extractor (t).Get (), OperandTypeDescription (newOp.left.type),
OperandTypeDescription (newOp.right.type));
}
}
else if (TokenEquals (t.tokenStart, t.tokenLen, "<"))
{
newOp.operation = opLesser;
err = ResolveOperand (expression->expressionValue.left, newOp.left);
if (err)
return err;
err = ResolveOperand (expression->expressionValue.right, newOp.right);
if (err)
return err;
if (!OpTypesCompatible (newOp.left.type, newOp.right.type))
{
return SetLastError ("Type of '%s' is '%s', not compatible to '%s'",
csExpressionToken::Extractor (t).Get (), OperandTypeDescription (newOp.left.type),
OperandTypeDescription (newOp.right.type));
}
}
else if (TokenEquals (t.tokenStart, t.tokenLen, "<="))
{
newOp.operation = opLesserEq;
err = ResolveOperand (expression->expressionValue.left, newOp.left);
if (err)
return err;
err = ResolveOperand (expression->expressionValue.right, newOp.right);
if (err)
return err;
if (!OpTypesCompatible (newOp.left.type, newOp.right.type))
{
return SetLastError ("Type of '%s' is '%s', not compatible to '%s'",
csExpressionToken::Extractor (t).Get (), OperandTypeDescription (newOp.left.type),
OperandTypeDescription (newOp.right.type));
}
}
else if (TokenEquals (t.tokenStart, t.tokenLen, ">="))
{
newOp.operation = opLesserEq;
err = ResolveOperand (expression->expressionValue.left, newOp.right);
if (err)
return err;
err = ResolveOperand (expression->expressionValue.right, newOp.left);
if (err)
return err;
if (!OpTypesCompatible (newOp.left.type, newOp.right.type))
{
return SetLastError ("Type of '%s' is '%s', not compatible to '%s'",
csExpressionToken::Extractor (t).Get (), OperandTypeDescription (newOp.left.type),
OperandTypeDescription (newOp.right.type));
}
}
else if (TokenEquals (t.tokenStart, t.tokenLen, ">"))
{
newOp.operation = opLesser;
err = ResolveOperand (expression->expressionValue.left, newOp.right);
if (err)
return err;
err = ResolveOperand (expression->expressionValue.right, newOp.left);
if (err)
return err;
if (!OpTypesCompatible (newOp.left.type, newOp.right.type))
{
return SetLastError ("Type of '%s' is '%s', not compatible to '%s'",
csExpressionToken::Extractor (t).Get (), OperandTypeDescription (newOp.left.type),
OperandTypeDescription (newOp.right.type));
}
}
else if (TokenEquals (t.tokenStart, t.tokenLen, "&&"))
{
newOp.operation = opAnd;
err = ResolveOperand (expression->expressionValue.left, newOp.left);
if (err)
return err;
if (!OpTypesCompatible (newOp.left.type, operandBoolean))
{
return SetLastError ("Type of '%s' is '%s', not compatible to '%s'",
csExpressionToken::Extractor (t).Get (), OperandTypeDescription (newOp.left.type),
OperandTypeDescription (operandBoolean));
}
if (newOp.left.type != operandOperation)
{
/* Convert to "(left eq true) and (right eq true)" to make the possible
* value determination simpler. */
CondOperation newOpL;
newOpL.operation = opEqual;
newOpL.left = newOp.left;
newOpL.right.type = operandBoolean;
newOpL.right.boolVal = true;
newOp.left.Clear();
newOp.left.type = operandOperation;
newOp.left.operation = FindOptimizedConditionInternal (newOpL);
}
err = ResolveOperand (expression->expressionValue.right, newOp.right);
if (err)
return err;
if (!OpTypesCompatible (newOp.right.type, operandBoolean))
{
return SetLastError ("Type of '%s' is '%s', not compatible to '%s'",
csExpressionToken::Extractor (t).Get (), OperandTypeDescription (newOp.right.type),
OperandTypeDescription (operandBoolean));
}
if (newOp.right.type != operandOperation)
{
/* Convert to "(left eq true) and (right eq true)" to make the possible
* value determination simpler. */
CondOperation newOpR;
newOpR.operation = opEqual;
newOpR.left = newOp.right;
newOpR.right.type = operandBoolean;
newOpR.right.boolVal = true;
newOp.right.Clear();
newOp.right.type = operandOperation;
newOp.right.operation = FindOptimizedConditionInternal (newOpR);
}
}
else if (TokenEquals (t.tokenStart, t.tokenLen, "||"))
{
newOp.operation = opOr;
err = ResolveOperand (expression->expressionValue.left, newOp.left);
if (err)
return err;
if (!OpTypesCompatible (newOp.left.type, operandBoolean))
{
return SetLastError ("Type of '%s' is '%s', not compatible to '%s'",
csExpressionToken::Extractor (t).Get (), OperandTypeDescription (newOp.left.type),
OperandTypeDescription (operandBoolean));
}
if (newOp.left.type != operandOperation)
{
/* Convert to "(left eq true) or (right eq true)" to make the possible
* value determination simpler. */
CondOperation newOpL;
newOpL.operation = opEqual;
newOpL.left = newOp.left;
newOpL.right.type = operandBoolean;
newOpL.right.boolVal = true;
newOp.left.Clear();
newOp.left.type = operandOperation;
newOp.left.operation = FindOptimizedConditionInternal (newOpL);
}
err = ResolveOperand (expression->expressionValue.right, newOp.right);
if (err)
return err;
if (!OpTypesCompatible (newOp.right.type, operandBoolean))
{
return SetLastError ("Type of '%s' is '%s', not compatible to '%s'",
csExpressionToken::Extractor (t).Get (), OperandTypeDescription (newOp.right.type),
OperandTypeDescription (operandBoolean));
}
if (newOp.right.type != operandOperation)
{
/* Convert to "(left eq true) or (right eq true)" to make the possible
* value determination simpler. */
CondOperation newOpR;
newOpR.operation = opEqual;
newOpR.left = newOp.right;
newOpR.right.type = operandBoolean;
newOpR.right.boolVal = true;
newOp.right.Clear();
newOp.right.type = operandOperation;
newOp.right.operation = FindOptimizedConditionInternal (newOpR);
}
}
else
{
return SetLastError ("Unknown operator '%s'",
csExpressionToken::Extractor (t).Get ());
}
}
operation = newOp;
return 0;
}
const char* csConditionEvaluator::ResolveSVIdentifier (
csExpression* expression, CondOperand& operand)
{
if (expression->type == csExpression::Value)
{
csExpressionToken::Extractor svIdentifier (expression->valueValue);
CS::Graphics::ShaderVarNameParser svParser (svIdentifier.Get());
operand.type = operandSV;
operand.svLocation.svName = strings->Request (svParser.GetShaderVarName());
operand.svLocation.indices = AllocSVIndicesInternal (svParser);
return 0;
}
else
{
const csExpressionToken& t = expression->expressionValue.op;
if (!TokenEquals (t.tokenStart, t.tokenLen, "."))
{
return SetLastError ("Unexpected operator '%s'",
csExpressionToken::Extractor (t).Get ());
}
if (expression->expressionValue.left->type != csExpression::Value)
{
CS_ASSERT_MSG ("It should not happen that the 'left' subexpression "
"is not a value", false);
return "Left subexpression is not of type 'value'";
}
if (expression->expressionValue.right->type != csExpression::Value)
{
/* @@@ Happens for stuff like vars.foo.bar.baz, where bar.baz
* will incarnate here as a right expression of type Expression.
* Clearer error msg?
*/
return "Right subexpression is not of type 'value'";
}
{
csExpressionToken::Extractor svIdentifier (expression->expressionValue.left->valueValue);
CS::Graphics::ShaderVarNameParser svParser (svIdentifier.Get());
operand.type = operandSV;
operand.svLocation.svName = strings->Request (svParser.GetShaderVarName());
operand.svLocation.indices = AllocSVIndicesInternal (svParser);
operand.svLocation.bufferName = csRenderBuffer::GetBufferNameFromDescr (
svParser.GetShaderVarName());
}
const csExpressionToken& right =
expression->expressionValue.right->valueValue;
if (TokenEquals (right.tokenStart, right.tokenLen, "int"))
{
operand.type = operandSVValueInt;
}
else if (TokenEquals (right.tokenStart, right.tokenLen, "float"))
{
operand.type = operandSVValueFloat;
}
else if (TokenEquals (right.tokenStart, right.tokenLen, "x"))
{
operand.type = operandSVValueX;
}
else if (TokenEquals (right.tokenStart, right.tokenLen, "y"))
{
operand.type = operandSVValueY;
}
else if (TokenEquals (right.tokenStart, right.tokenLen, "z"))
{
operand.type = operandSVValueZ;
}
else if (TokenEquals (right.tokenStart, right.tokenLen, "w"))
{
operand.type = operandSVValueW;
}
else if (TokenEquals (right.tokenStart, right.tokenLen, "buffer"))
{
operand.type = operandSVValueBuffer;
}
else if (TokenEquals (right.tokenStart, right.tokenLen, "texture"))
{
operand.type = operandSVValueTexture;
}
else
{
return SetLastError ("Unknown shader variable specializer '%s'",
csExpressionToken::Extractor (right).Get ());
}
return 0;
}
CS_ASSERT (false);
return 0;
}
