/// <summary> /// Read the XML attributes from the current <paramref name="reader"/> position /// </summary> /// <param name="reader">The XML reader</param> protected override void ReadXmlAttributes(XmlReader reader) { string attribute = reader.GetAttribute(XmlKindName); if(!String.IsNullOrEmpty(attribute)) { Kind = LiteralKindExtensions.FromKeyword(attribute); } attribute = reader.GetAttribute(XmlTextName); if(!String.IsNullOrEmpty(attribute)) { Text = attribute; } base.ReadXmlAttributes(reader); }
public static SyntaxKind SyntaxKindFromLiteralKind(LiteralKind literalKind, object value) { if (literalKind == LiteralKind.Boolean) { if ((bool)value) { return SyntaxKind.TrueLiteralExpression; } return SyntaxKind.FalseLiteralExpression; } foreach (var tuple in LiteralKindMap) { if (tuple.Item3 == literalKind) { return tuple.Item2; } } throw new InvalidOperationException(); }
private bool TryIdentifierExpression(MemberAccessExpressionSyntax identifierExpression, IDom newItem, SemanticModel model, ref object value, ref LiteralKind literalKind, ref string constantIdentifier) { if (identifierExpression == null) { return(false); } literalKind = LiteralKind.Identifier; constantIdentifier = identifierExpression.ToFullString(); value = identifierExpression.ToFullString(); return(true); }
/// <summary> /// Read the XML attributes from the current <paramref name="reader"/> position /// </summary> /// <param name="reader">The XML reader</param> protected override void ReadXmlAttributes(XmlReader reader) { string attribute = reader.GetAttribute(XmlKindName); if (!String.IsNullOrEmpty(attribute)) { Kind = LiteralKindExtensions.FromKeyword(attribute); } attribute = reader.GetAttribute(XmlTextName); if (!String.IsNullOrEmpty(attribute)) { Text = attribute; } base.ReadXmlAttributes(reader); }
protected object ExpectLiteral(List <Token> tokens, ref int index, out LiteralKind kind) { if (index >= tokens.Count) { throw new ParserException(tokens.Last(), ParserException.Kind.EndOfStream); } var token = tokens[index]; index++; switch (token.kind) { case Token.Kind.Integer: { kind = LiteralKind.Integer; var val = BigInteger.Parse(token.text); return(val); } case Token.Kind.Float: { kind = LiteralKind.Float; var val = decimal.Parse(token.text); return(val); } case Token.Kind.Boolean: { kind = LiteralKind.Integer; var val = token.text.ToLower() == "true"; return(val); } case Token.Kind.String: { kind = LiteralKind.String; return(token.text); } default: { throw new ParserException(token, ParserException.Kind.ExpectedLiteral); } } }
private bool TryTyepofExpression(TypeOfExpressionSyntax typeOfExpression, IDom newItem, SemanticModel model, ref object value, ref LiteralKind literalKind, ref string constantIdentifier) { if (typeOfExpression == null) { return(false); } literalKind = LiteralKind.Type; value = Corporation .Create(typeOfExpression.Type, newItem, model) .FirstOrDefault() as IReferencedType; return(true); }
internal static SyntaxToken GetTokenFromKind(LiteralKind kind, object value) { switch (kind) { case LiteralKind.MemberAccess: case LiteralKind.String: case LiteralKind.Unknown: return(SyntaxFactory.Literal(value.ToString())); case LiteralKind.Numeric: if (GeneralUtilities.IsInteger(value)) { return(SyntaxFactory.Literal(Convert.ToInt32(value))); } if (GeneralUtilities.IsFloatingPint(value)) { return(SyntaxFactory.Literal(Convert.ToDouble(value))); } if (value is uint) { return(SyntaxFactory.Literal(Convert.ToUInt32(value))); } if (value is long) { return(SyntaxFactory.Literal(Convert.ToInt64(value))); } if (value is ulong) { return(SyntaxFactory.Literal(Convert.ToUInt64(value))); } else { return(SyntaxFactory.Literal(Convert.ToDecimal(value))); } case LiteralKind.Boolean: case LiteralKind.Type: case LiteralKind.Default: // Need to create an expression so handled separately and should not call this default: break; } throw new NotImplementedException(); }
private RDomParameter(string name, object defaultValue, LiteralKind defaultValueType, string defaultConstantIdentifier, int ordinal = 0, bool isOut = false, bool isRef = false, bool isParamArray = false) : base() { _name = name; _ordinal = ordinal; _isOut = isOut; _isRef = isRef; _isParamArray = isParamArray; _isOptional = defaultValueType != LiteralKind.Unknown; if (IsOptional) { _defaultValue = defaultValue; _defaultValueType = defaultValueType; _defaultConstantIdentifier = defaultConstantIdentifier; } }
public static SyntaxKind SyntaxKindFromLiteralKind(LiteralKind literalKind, object value) { if (literalKind == LiteralKind.Boolean) { if ((bool)value) { return(SyntaxKind.TrueLiteralExpression); } return(SyntaxKind.FalseLiteralExpression); } foreach (var tuple in LiteralKindMap) { if (tuple.Item3 == literalKind) { return(tuple.Item2); } } throw new InvalidOperationException(); }
/// <summary> Returns a keyword string for this LiteralKind. </summary> public static string ToKeyword(this LiteralKind lk) { switch (lk) { case LiteralKind.String: return("String"); case LiteralKind.Boolean: return("Boolean"); case LiteralKind.Character: return("Character"); case LiteralKind.Number: return("Number"); case LiteralKind.Null: return("Null"); default: return(string.Empty); } }
public static LingoLiteral Read(ref ShockwaveReader input, LiteralKind entryKind, int entryOffset) { if (entryKind != LiteralKind.Integer) { input.Position = entryOffset; int length = input.ReadInt32(); object value = entryKind switch { LiteralKind.String => input.ReadString(length), LiteralKind.FloatingPoint => input.ReadDouble(), LiteralKind.CompiledJavascript => input.ReadBytes(length).ToArray(), _ => throw new ArgumentException(nameof(Kind)) }; return(new LingoLiteral(entryKind, value)); } else { return(new LingoLiteral(LiteralKind.Integer, entryOffset)); } }
// <summary> // Creates literal token // </summary> // <param name="literal"> literal </param> // <param name="literalKind"> literal kind </param> // <returns> Literal Token </returns> internal Token NewLiteralToken(string literal, LiteralKind literalKind) { DebugCheck.NotEmpty(literal); Debug.Assert(literalKind != LiteralKind.Null, "literalKind must not be LiteralKind.Null"); var literalValue = literal; switch (literalKind) { case LiteralKind.Binary: literalValue = GetLiteralSingleQuotePayload(literal); if (!IsValidBinaryValue(literalValue)) { var errorMessage = Strings.InvalidLiteralFormat("binary", literalValue); throw EntitySqlException.Create(_query, errorMessage, _iPos, null, false, null); } break; case LiteralKind.String: if ('N' == literal[0]) { literalKind = LiteralKind.UnicodeString; } break; case LiteralKind.DateTime: literalValue = GetLiteralSingleQuotePayload(literal); if (!IsValidDateTimeValue(literalValue)) { var errorMessage = Strings.InvalidLiteralFormat("datetime", literalValue); throw EntitySqlException.Create(_query, errorMessage, _iPos, null, false, null); } break; case LiteralKind.Time: literalValue = GetLiteralSingleQuotePayload(literal); if (!IsValidTimeValue(literalValue)) { var errorMessage = Strings.InvalidLiteralFormat("time", literalValue); throw EntitySqlException.Create(_query, errorMessage, _iPos, null, false, null); } break; case LiteralKind.DateTimeOffset: literalValue = GetLiteralSingleQuotePayload(literal); if (!IsValidDateTimeOffsetValue(literalValue)) { var errorMessage = Strings.InvalidLiteralFormat("datetimeoffset", literalValue); throw EntitySqlException.Create(_query, errorMessage, _iPos, null, false, null); } break; case LiteralKind.Guid: literalValue = GetLiteralSingleQuotePayload(literal); if (!IsValidGuidValue(literalValue)) { var errorMessage = Strings.InvalidLiteralFormat("guid", literalValue); throw EntitySqlException.Create(_query, errorMessage, _iPos, null, false, null); } break; } return(NewToken(CqlParser.LITERAL, new Literal(literalValue, literalKind, _query, _iPos))); }
protected Literal(LiteralKind kind) { Kind = kind; }
/// <summary> /// Initializes a literal ast node. /// </summary> /// <param name="originalValue">literal value in cql string representation</param> /// <param name="kind">literal value class</param> /// <param name="query">query</param> /// <param name="inputPos">input position</param> internal Literal(string originalValue, LiteralKind kind, string query, int inputPos) : base(query, inputPos) { _originalValue = originalValue; _literalKind = kind; }
/// <summary> /// Gets the type of the literal element /// </summary> /// <param name="kind">The literal kind</param> /// <param name="literalValue">The value</param> /// <returns>The name of this type</returns> public virtual string GetTypeForLiteralValue(LiteralKind kind, string literalValue) { switch(kind) { case LiteralKind.Boolean: return GetTypeForBooleanLiteral(literalValue); case LiteralKind.Character: return GetTypeForCharacterLiteral(literalValue); case LiteralKind.Number: return GetTypeForNumberLiteral(literalValue); case LiteralKind.String: return GetTypeForStringLiteral(literalValue); } return String.Empty; }
public LiteralExpressionSharpnode(LiteralExpressionSyntax literalExpressionSyntax, int literalValue) : base(literalExpressionSyntax) { this.integerValue = literalValue; this.kind = LiteralKind.Int32; }
/// <summary> /// Initializes a literal ast node. /// </summary> /// <param name="originalValue"> literal value in cql string representation </param> /// <param name="kind"> literal value class </param> /// <param name="query"> query </param> /// <param name="inputPos"> input position </param> internal Literal(string originalValue, LiteralKind kind, string query, int inputPos) : base(query, inputPos) { _originalValue = originalValue; _literalKind = kind; }
// Read the next token from the input stream // (Mostly inline for performance) public void NextToken() { while (true) { // Skip whitespace and handle line numbers while (true) { if (_currentChar == '\r') { if (NextChar() == '\n') { NextChar(); } _currentCharPos.Line++; _currentCharPos.Offset = 0; } else if (_currentChar == '\n') { if (NextChar() == '\r') { NextChar(); } _currentCharPos.Line++; _currentCharPos.Offset = 0; } else if (_currentChar == ' ') { NextChar(); } else if (_currentChar == '\t') { NextChar(); } else { break; } } // Remember position of token CurrentTokenPosition = _currentCharPos; // Handle common characters first switch (_currentChar) { case '/': // Comments not support in strict mode if ((_options & JsonOptions.StrictParser) != 0) { throw new InvalidDataException(string.Format("syntax error, unexpected character '{0}'", _currentChar)); } // Process comment NextChar(); switch (_currentChar) { case '/': NextChar(); while (_currentChar != '\0' && _currentChar != '\r' && _currentChar != '\n') { NextChar(); } break; case '*': bool endFound = false; while (!endFound && _currentChar != '\0') { if (_currentChar == '*') { NextChar(); if (_currentChar == '/') { endFound = true; } } NextChar(); } break; default: throw new InvalidDataException("syntax error, unexpected character after slash"); } continue; case '\"': case '\'': { _sb.Length = 0; var quoteKind = _currentChar; NextChar(); while (_currentChar != '\0') { if (_currentChar == '\\') { NextChar(); var escape = _currentChar; switch (escape) { case '\"': _sb.Append('\"'); break; case '\\': _sb.Append('\\'); break; case '/': _sb.Append('/'); break; case 'b': _sb.Append('\b'); break; case 'f': _sb.Append('\f'); break; case 'n': _sb.Append('\n'); break; case 'r': _sb.Append('\r'); break; case 't': _sb.Append('\t'); break; case 'u': var sbHex = new StringBuilder(); for (int i = 0; i < 4; i++) { NextChar(); sbHex.Append(_currentChar); } _sb.Append((char)Convert.ToUInt16(sbHex.ToString(), 16)); break; default: throw new InvalidDataException(string.Format("Invalid escape sequence in string literal: '\\{0}'", _currentChar)); } } else if (_currentChar == quoteKind) { String = _sb.ToString(); CurrentToken = Token.Literal; LiteralKind = LiteralKind.String; NextChar(); return; } else { _sb.Append(_currentChar); } NextChar(); } throw new InvalidDataException("syntax error, unterminated string literal"); } case '{': CurrentToken = Token.OpenBrace; NextChar(); return; case '}': CurrentToken = Token.CloseBrace; NextChar(); return; case '[': CurrentToken = Token.OpenSquare; NextChar(); return; case ']': CurrentToken = Token.CloseSquare; NextChar(); return; case '=': CurrentToken = Token.Equal; NextChar(); return; case ':': CurrentToken = Token.Colon; NextChar(); return; case ';': CurrentToken = Token.SemiColon; NextChar(); return; case ',': CurrentToken = Token.Comma; NextChar(); return; case '\0': CurrentToken = Token.EOF; return; } // Number? if (char.IsDigit(_currentChar) || _currentChar == '-') { TokenizeNumber(); return; } // Identifier? (checked for after everything else as identifiers are actually quite rare in valid json) if (Char.IsLetter(_currentChar) || _currentChar == '_' || _currentChar == '$') { // Find end of identifier _sb.Length = 0; while (Char.IsLetterOrDigit(_currentChar) || _currentChar == '_' || _currentChar == '$') { _sb.Append(_currentChar); NextChar(); } String = _sb.ToString(); // Handle special identifiers switch (String) { case "true": LiteralKind = LiteralKind.True; CurrentToken = Token.Literal; return; case "false": LiteralKind = LiteralKind.False; CurrentToken = Token.Literal; return; case "null": LiteralKind = LiteralKind.Null; CurrentToken = Token.Literal; return; } CurrentToken = Token.Identifier; return; } // What the? throw new InvalidDataException(string.Format("syntax error, unexpected character '{0}'", _currentChar)); } }
protected LiteralInteger(LiteralKind kind) : base(kind) { }
public static ExpressionSyntax BuildArgValueExpression(object value, string declaredConst, LiteralKind valueType) { var kind = Mappings.SyntaxKindFromLiteralKind(valueType, value); ExpressionSyntax expr = null; if (valueType == LiteralKind.Boolean) { expr = SyntaxFactory.LiteralExpression(kind); } else if (valueType == LiteralKind.Null) { expr = SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression); } else if (valueType == LiteralKind.Type) { var type = value as RDomReferencedType; if (type == null) { throw new InvalidOperationException(); } var typeSyntax = (TypeSyntax)RDom.CSharp.GetSyntaxGroup(type).First(); expr = SyntaxFactory.TypeOfExpression(typeSyntax); } else if (valueType == LiteralKind.Default) { var type = value as RDomReferencedType; if (type == null) { throw new InvalidOperationException(); } var typeSyntax = (TypeSyntax)RDom.CSharp.GetSyntaxGroup(type).First(); expr = SyntaxFactory.DefaultExpression(typeSyntax); } else if (valueType == LiteralKind.MemberAccess) { var leftExpr = SyntaxFactory.IdentifierName(declaredConst.SubstringBeforeLast(".")); var name = SyntaxFactory.IdentifierName(declaredConst.SubstringAfterLast(".")); expr = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, leftExpr, name); } else { var token = BuildSyntaxHelpers.GetTokenFromKind(valueType, value); expr = SyntaxFactory.LiteralExpression((SyntaxKind)kind, token); } return(expr); }
public LiteralUnresolved(LiteralKind kind, String value) : base(kind) { Value = value; }
public LingoLiteral(LiteralKind kind, object value) { Kind = kind; Value = value; }
private void VerifyAttributeValue(IAttributeValue attributeValue, string name, object value, LiteralKind kind) { Assert.AreEqual(name, attributeValue.Name); Assert.AreEqual(value, attributeValue.Value); Assert.AreEqual(kind, attributeValue.ValueType); }
public RDomAttributeValue(IDom parent, string name, AttributeValueStyle style = AttributeValueStyle.Positional, object value = null, string valueConstantIdentifier = null, LiteralKind valueType = LiteralKind.Unknown) : base(parent) { _name = name; _style = style; _value = value; _valueConstantIdentifier = valueConstantIdentifier; _valueType = valueType; }
private LiteralExpressionNode createLiteralExpression(LiteralKind literalKind) { var result = new LiteralExpressionNode { EndPosition = scanner.EndPosition }; setScannerState(result); result.LiteralKind = literalKind; result.ValueOffset = scanner.StartPosition; result.ValueLength = getLexicalUnitLength(); return result; }
/// <summary> /// Creates literal token /// </summary> /// <param name="literal">literal</param> /// <param name="literalKind">literal kind</param> /// <returns>Literal Token</returns> internal Token NewLiteralToken(string literal, LiteralKind literalKind) { Debug.Assert(!String.IsNullOrEmpty(literal), "literal must not be null or empty"); Debug.Assert(literalKind != LiteralKind.Null, "literalKind must not be LiteralKind.Null"); var literalValue = literal; switch (literalKind) { case LiteralKind.Binary: literalValue = GetLiteralSingleQuotePayload(literal); if (!IsValidBinaryValue(literalValue)) { var errorMessage = Strings.InvalidLiteralFormat("binary", literalValue); throw EntitySqlException.Create(_query, errorMessage, _iPos, null, false, null); } break; case LiteralKind.String: if ('N' == literal[0]) { literalKind = LiteralKind.UnicodeString; } break; case LiteralKind.DateTime: literalValue = GetLiteralSingleQuotePayload(literal); if (!IsValidDateTimeValue(literalValue)) { var errorMessage = Strings.InvalidLiteralFormat("datetime", literalValue); throw EntitySqlException.Create(_query, errorMessage, _iPos, null, false, null); } break; case LiteralKind.Time: literalValue = GetLiteralSingleQuotePayload(literal); if (!IsValidTimeValue(literalValue)) { var errorMessage = Strings.InvalidLiteralFormat("time", literalValue); throw EntitySqlException.Create(_query, errorMessage, _iPos, null, false, null); } break; case LiteralKind.DateTimeOffset: literalValue = GetLiteralSingleQuotePayload(literal); if (!IsValidDateTimeOffsetValue(literalValue)) { var errorMessage = Strings.InvalidLiteralFormat("datetimeoffset", literalValue); throw EntitySqlException.Create(_query, errorMessage, _iPos, null, false, null); } break; case LiteralKind.Guid: literalValue = GetLiteralSingleQuotePayload(literal); if (!IsValidGuidValue(literalValue)) { var errorMessage = Strings.InvalidLiteralFormat("guid", literalValue); throw EntitySqlException.Create(_query, errorMessage, _iPos, null, false, null); } break; } return NewToken(CqlParser.LITERAL, new Literal(literalValue, literalKind, _query, _iPos)); }
// Parse a sequence of characters that could make up a valid number // For performance, we don't actually parse it into a number yet. When using Topten.JsonKitEmit we parse // later, directly into a value type to avoid boxing private void TokenizeNumber() { _sb.Length = 0; // Leading negative sign bool signed = false; if (_currentChar == '-') { signed = true; _sb.Append(_currentChar); NextChar(); } // Hex prefix? bool hex = false; if (_currentChar == '0' && (_options & JsonOptions.StrictParser) == 0) { _sb.Append(_currentChar); NextChar(); if (_currentChar == 'x' || _currentChar == 'X') { _sb.Append(_currentChar); NextChar(); hex = true; } } // Process characters, but vaguely figure out what type it is bool cont = true; bool fp = false; while (cont) { switch (_currentChar) { case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': _sb.Append(_currentChar); NextChar(); break; case 'A': case 'a': case 'B': case 'b': case 'C': case 'c': case 'D': case 'd': case 'F': case 'f': if (!hex) { cont = false; } else { _sb.Append(_currentChar); NextChar(); } break; case '.': if (hex) { cont = false; } else { fp = true; _sb.Append(_currentChar); NextChar(); } break; case 'E': case 'e': if (!hex) { fp = true; _sb.Append(_currentChar); NextChar(); if (_currentChar == '+' || _currentChar == '-') { _sb.Append(_currentChar); NextChar(); } } break; default: cont = false; break; } } if (char.IsLetter(_currentChar)) { throw new InvalidDataException(string.Format("syntax error, invalid character following number '{0}'", _sb.ToString())); } // Setup token String = _sb.ToString(); CurrentToken = Token.Literal; // Setup literal kind if (fp) { LiteralKind = LiteralKind.FloatingPoint; } else if (signed) { LiteralKind = LiteralKind.SignedInteger; } else { LiteralKind = LiteralKind.UnsignedInteger; } }
public LiteralExpressionSharpnode(LiteralExpressionSyntax literalExpressionSyntax, bool literalValue) : base(literalExpressionSyntax) { this.booleanValue = literalValue; this.kind = LiteralKind.Boolean; }