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; }