/// <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;
}
}
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 LiteralExpressionSharpnode(LiteralExpressionSyntax literalExpressionSyntax, bool literalValue) : base(literalExpressionSyntax)
{
this.booleanValue = literalValue;
this.kind = LiteralKind.Boolean;
}
