private static void CoerceString(ref object value, LiteralType type)
{
if (type != LiteralType.String)
{
value = value.ToString();
}
}
public Literal BuildLiteral(LiteralType type)
{
switch (type)
{
case LiteralType.Integer:
return new IntegerLiteral();
case LiteralType.Real:
return new RealLiteral();
case LiteralType.Money:
return new MoneyLiteral();
case LiteralType.Binary:
return new BinaryLiteral();
case LiteralType.String:
return new StringLiteral();
case LiteralType.Null:
return new NullLiteral();
case LiteralType.Default:
return new DefaultLiteral();
case LiteralType.Max:
return new MaxLiteral();
case LiteralType.Odbc:
return new OdbcLiteral();
case LiteralType.Identifier:
return new IdentifierLiteral();
case LiteralType.Numeric:
return new NumericLiteral();
}
throw new ArgumentException("Unknown literal type");
}
private IType TypeFromLiteralType(LiteralType type)
{
switch (type)
{
case LiteralType.String: return(NHibernateUtil.String);
case LiteralType.Boolean: return(NHibernateUtil.Boolean);
case LiteralType.Single: return(NHibernateUtil.Single);
case LiteralType.Double: return(NHibernateUtil.Double);
case LiteralType.Decimal: return(NHibernateUtil.Decimal);
case LiteralType.Int: return(NHibernateUtil.Int32);
case LiteralType.Long: return(NHibernateUtil.Int64);
case LiteralType.Binary: return(NHibernateUtil.Binary);
case LiteralType.DateTime: return(NHibernateUtil.DateTime);
case LiteralType.Guid: return(NHibernateUtil.Guid);
case LiteralType.Duration: return(NHibernateUtil.TimeSpan);
default: throw new NotSupportedException();
}
}
List <Literal> CoerceLiteralsToSingleType(List <Runtime.Object> parametersIn)
{
LiteralType litType = LiteralType.Int;
// Find out what the output type is
// "higher level" types infect both so that binary operations
// use the same type on both sides. e.g. binary operation of
// int and float causes the int to be casted to a float.
foreach (var obj in parametersIn)
{
var literal = (Literal)obj;
if (literal.literalType > litType)
{
litType = literal.literalType;
}
}
// Coerce to this chosen type
var parametersOut = new List <Literal> ();
foreach (Literal literal in parametersIn)
{
var castedLiteral = literal.Cast(litType);
parametersOut.Add(castedLiteral);
}
return(parametersOut);
}
static void _ldtoken()
{
var type = Instruction.TypeOperand;
var literalType = new LiteralType(type);
emitPush <LiteralType>(literalType);
}
public override Literal Cast(LiteralType newType)
{
if (newType == literalType)
{
return(this);
}
if (newType == LiteralType.Int)
{
int parsedInt;
if (int.TryParse(value, out parsedInt))
{
return(new LiteralInt(parsedInt));
}
else
{
return(null);
}
}
if (newType == LiteralType.Float)
{
float parsedFloat;
if (float.TryParse(value, out parsedFloat))
{
return(new LiteralFloat(parsedFloat));
}
else
{
return(null);
}
}
throw new System.Exception("Unexpected type cast of Literal to new LiteralType");
}
private static ScalarExpression GetColumnValue(string value, LiteralType type)
{
switch (type)
{
case LiteralType.Integer:
return new IntegerLiteral {Value = value};
case LiteralType.Real:
return new RealLiteral {Value = value};
case LiteralType.Money:
return new MoneyLiteral {Value = value};
case LiteralType.Binary:
return new BinaryLiteral {Value = value};
case LiteralType.String:
return new StringLiteral {Value = value.Replace("'", "''")};
case LiteralType.Null:
return new NullLiteral {Value = value};
case LiteralType.Default:
return new DefaultLiteral {Value = value};
case LiteralType.Max:
return new MaxLiteral {Value = value};
case LiteralType.Odbc:
return new OdbcLiteral {Value = value};
case LiteralType.Identifier:
return new IdentifierLiteral {Value = value};
;
case LiteralType.Numeric:
return new NumericLiteral {Value = value};
;
default:
throw new ArgumentOutOfRangeException();
}
}
public Literal(string value, LiteralType type)
{
var rawValue = TryGetObjectValue(value, type);
Value = rawValue;
Type = type;
}
private static void CoerceDecimal(ref object value, LiteralType type)
{
switch (type)
{
case LiteralType.Long:
value = (decimal)(long)value;
break;
case LiteralType.Int:
value = (decimal)(int)value;
break;
case LiteralType.Single:
value = (decimal)(float)value;
break;
case LiteralType.Double:
value = (decimal)(double)value;
break;
case LiteralType.Decimal:
break;
default:
throw new NotSupportedException();
}
}
private slice <byte> LiteralType(LiteralType lit)
{
var result = lit.Token.Text.AsByteSlice();
switch (lit.Token.Type)
{
case TokenType.HEREDOC:
// Clear the trailing newline from heredocs
if (result[result.Length - 1] == '\n')
{
result = result.Slice(upper: result.Length - 1);
}
// Poison lines 2+ so that we don't indent them
result = this.HeredocIndent(result);
break;
case TokenType.STRING:
// If this is a multiline string, poison lines 2+ so we don't
// indent them.
if (result.IndexOf((byte)'\n') >= 0)
{
result = this.HeredocIndent(result);
}
break;
}
return(result);
}
public LiteralToken(object value, LiteralType literalType)
: base(TokenType.Literal)
{
Value = value;
LiteralType = literalType;
Debug.Assert(literalType == LiteralUtil.GetLiteralType(value));
}
public LiteralToken(object value, LiteralType literalType)
: base(TokenType.Literal)
{
Value = value;
LiteralType = literalType;
Debug.Assert(literalType == LiteralUtil.GetLiteralType(value));
}
public bool Equals(LiteralExpression compareNode)
{
return
(compareNode != null &&
LiteralType?.Equals(compareNode.LiteralType) != false &&
SemanticType?.Equals(compareNode.SemanticType) != false &&
base.Equals(compareNode));
}
public static Int32 GetCloserOfPositionOfLiteral(String Code, Int32 SearchOffset, LiteralType Type)
{
Regex Expression = (Type == LiteralType.String)
? (new Regex("[^\\\\]?\""))
: (new Regex("[^\\\\]?'"));
Match CloserMatch = Expression.Match(Code, SearchOffset);
return (CloserMatch.Success) ? (CloserMatch.Index + CloserMatch.Length - 1) : IndexNotFound;
}
void AddOpFuncForType(LiteralType litType, object op)
{
if (_operationFuncs == null)
{
_operationFuncs = new Dictionary <LiteralType, object> ();
}
_operationFuncs [litType] = op;
}
public override Literal Cast(LiteralType newType)
{
if (newType == literalType)
{
return(this);
}
throw new System.Exception("Unexpected type cast of Literal to new LiteralType");
}
private void DoGetHashCodeTest(object obj, LiteralType type)
{
// Arrange
Literal sut = new Literal(obj, type);
// Act
int result = sut.GetHashCode();
// Assert
}
IsolateNumericLiteral(
ScanStream ScanStream,
TextTraits Traits,
int Bx)
{
// for now, all numeric literals are simple integers.
// have to expand to determine if a float, decimal, what the sign is,
// what the precision is.
LiteralType litType = LiteralType.Integer;
string litText = null;
PatternScanResults nonWord = null;
// step from char to char. Look for a char that is not part of the
// numeric literal.
int ix = Bx;
int litEx = Bx;
while (true)
{
if (ix >= ScanStream.Stream.Length)
{
break;
}
char ch1 = ScanStream.Stream[ix];
if (Char.IsDigit(ch1) == false)
{
break;
}
litEx = ix;
ix += 1;
}
// isolate the numeric literal.
int lx = litEx - Bx + 1;
litText = ScanStream.Substring(Bx, lx);
// isolate the delim that follows that numeric literal.
int bx = litEx + 1;
if (bx < ScanStream.Stream.Length)
{
nonWord = Scanner.ScanEqualAny(ScanStream.Stream, bx, Traits.DelimPatterns);
// foundPat = rv.Item1;
// foundIx = rv.Item2;
// foundLx = rv.Item3;
// nonWord = rv.Item3;
}
return(new Tuple <LiteralType, string, PatternScanResults>(
litType, litText, nonWord));
}
private bool ResolveEquals(object left, object right, LiteralType type)
{
if (type == LiteralType.Binary)
{
return(LiteralUtil.ByteArrayEquals((byte[])left, (byte[])right));
}
else
{
return(Equals(left, right));
}
}
private void DoEqualsTest(object a, LiteralType aType, object b, LiteralType bType, bool expected)
{
// Arrange
Literal aa = new Literal(a, aType);
Literal bb = new Literal(b, bType);
// Act
bool result = aa.Equals(bb);
// Assert
Assert.AreEqual(expected, result);
}
static void AddOpToNativeFunc(string name, int args, LiteralType litType, object op)
{
NativeFunctionCall nativeFunc = null;
if (!_nativeFunctions.TryGetValue(name, out nativeFunc))
{
nativeFunc = new NativeFunctionCall(name, args);
_nativeFunctions [name] = nativeFunc;
}
nativeFunc.AddOpFuncForType(litType, op);
}
public AtomText(
ScanAtomCode AtomCode,
string LitText, LiteralType LiteralType,
TextLocation StartLoc, TextLocation EndLoc)
{
this.AtomCode = AtomCode;
this.ScanText = LitText;
this.ReplacementText = null;
this.LiteralType = LiteralType;
this.StartLoc = StartLoc;
this.EndLoc = EndLoc;
this.UserCode = null;
}
public static bool IsQuoted(this LiteralType LitType)
{
if ((LitType == LiteralType.String) ||
(LitType == LiteralType.VerbatimString) ||
(LitType == LiteralType.Char))
{
return(true);
}
else
{
return(false);
}
}
public byte ReadByteValue()
{
byte result = 0;
LiteralType literalType = LiteralType.Decimal;
string sval = "";
if (Peek() == '0')
{
if (char.ToLower(Peek(1)) == 'x')
{
CurrentNdx += 2;
literalType = LiteralType.Hexidecimal;
}
else if (char.ToLower(Peek(1)) == 'b')
{
CurrentNdx += 2;
literalType = LiteralType.Binary;
}
else if (char.ToLower(Peek(1)) == 'd')
{
CurrentNdx += 2;
literalType = LiteralType.Decimal;
}
}
while (char.IsLetterOrDigit(Peek()))
{
sval += Get();
}
switch (literalType)
{
case LiteralType.Binary:
result = Convert.ToByte(sval, 2);
break;
case LiteralType.Hexidecimal:
result = Convert.ToByte(sval, 16);
break;
case LiteralType.Decimal:
result = byte.Parse(sval);
break;
default:
result = 0;
break;
}
return(result);
}
IsolateQuotedWord(
ScanStream ScanStream,
TextTraits Traits,
int Bx)
{
LiteralType litType = LiteralType.none;
string litText = null;
char ch1 = ScanStream.Stream[Bx];
ScanPattern foundPat = null;
int foundIx = -1;
int quoteEx = -1;
// is start of a verbatim string literal
if ((Traits.VerbatimLiteralPattern != null) &&
(Traits.VerbatimLiteralPattern.Match(ScanStream.Stream, Bx)))
{
var rv = VerbatimLiteral.ScanCloseQuote(
ScanStream.Stream, Traits.VerbatimLiteralPattern, Bx);
quoteEx = rv.Item1;
litText = rv.Item2;
litType = LiteralType.VerbatimString;
}
// is a quoted literal
else if (Traits.IsQuoteChar(ch1) == true)
{
quoteEx = Scanner.ScanCloseQuote(ScanStream.Stream, Bx, Traits.QuoteEncapsulation);
if (quoteEx != -1)
{
int lx = quoteEx - Bx + 1;
litText = ScanStream.Substring(Bx, lx);
// correct the following at some point. Should be either string or
// char lit.
litType = LiteralType.String;
}
}
// isolate the delim that follows that quoted word.
{
int bx = quoteEx + 1;
var rv = Scanner.ScanEqualAny(ScanStream.Stream, bx, Traits.DelimPatterns);
foundPat = rv.Item1;
foundIx = rv.Item2;
}
return(new Tuple <LiteralType, string, ScanPattern, int>(
litType, litText, foundPat, foundIx));
}
public static bool IsNumeric(this LiteralType LitType)
{
if ((LitType == LiteralType.Decimal) ||
(LitType == LiteralType.Float) ||
(LitType == LiteralType.Integer) ||
(LitType == LiteralType.Long))
{
return(true);
}
else
{
return(false);
}
}
private static void CoerceLong(ref object value, LiteralType type)
{
switch (type)
{
case LiteralType.Long:
break;
case LiteralType.Int:
value = (long)(int)value;
break;
default:
throw new NotSupportedException();
}
}
private static object TryGetObjectValue(string value, LiteralType type)
{
switch (type)
{
case LiteralType.String: return(value);
case LiteralType.Int: return(int.Parse(value));
case LiteralType.Bool: return(bool.Parse(value));
case LiteralType.Double: return(double.Parse(value));
}
throw new InvalidOperationException($"Cannot get literal value of type {type}.");
}
Literal Call <T>(List <Literal> parametersOfSingleType)
{
Literal param1 = (Literal)parametersOfSingleType [0];
LiteralType litType = param1.literalType;
var val1 = (Literal <T>)param1;
int paramCount = parametersOfSingleType.Count;
if (paramCount == 2 || paramCount == 1)
{
object opForTypeObj = null;
if (!_operationFuncs.TryGetValue(litType, out opForTypeObj))
{
throw new StoryException("Can not perform operation '" + this.name + "' on " + litType);
}
// Binary
if (paramCount == 2)
{
Literal param2 = (Literal)parametersOfSingleType [1];
var val2 = (Literal <T>)param2;
var opForType = (BinaryOp <T>)opForTypeObj;
// Return value unknown until it's evaluated
object resultVal = opForType(val1.value, val2.value);
return(Literal.Create(resultVal));
}
// Unary
else
{
var opForType = (UnaryOp <T>)opForTypeObj;
var resultVal = opForType(val1.value);
return(Literal.Create(resultVal));
}
}
else
{
throw new System.Exception("Unexpected number of parameters to NativeFunctionCall: " + parametersOfSingleType.Count);
}
}
public LiteralNode(LiteralType t, object val) : base(NodeType.LiteralNode)
{
this.type = t;
this.Value = val;
children = new List <BaseNode>();
if (t == LiteralType.String)
{
string v = (string)val;
Value = v.Substring(5);
}
if (t == LiteralType.Func)
{
children.Add((FuncLiteral)Value);
}
initReturnType();
}
public static LiteralType CoerceLiteralValues(ref object left, LiteralType leftType, ref object right, LiteralType rightType)
{
if (leftType == rightType)
{
return(leftType);
}
if (leftType != LiteralType.Null && rightType != LiteralType.Null)
{
if (leftType == LiteralType.String || rightType == LiteralType.String)
{
CoerceString(ref left, leftType);
CoerceString(ref right, rightType);
return(LiteralType.String);
}
else if (IsInteger(leftType) && IsInteger(rightType))
{
CoerceLong(ref left, leftType);
CoerceLong(ref right, rightType);
return(LiteralType.Long);
}
else if (IsFloatingOrInteger(leftType) && IsFloatingOrInteger(rightType))
{
if (leftType == LiteralType.Decimal || rightType == LiteralType.Decimal)
{
CoerceDecimal(ref left, leftType);
CoerceDecimal(ref right, rightType);
return(LiteralType.Decimal);
}
else
{
CoerceDouble(ref left, leftType);
CoerceDouble(ref right, rightType);
return(LiteralType.Double);
}
}
}
throw new ODataException(String.Format(
ErrorMessages.LiteralUtil_IncompatibleTypes,
leftType, rightType
));
}
private object ResolveMod(object left, object right, LiteralType type)
{
switch (type)
{
case LiteralType.Decimal: return((decimal)left % (decimal)right);
case LiteralType.Double: return((double)left % (double)right);
case LiteralType.Int: return((int)left % (int)right);
case LiteralType.Long: return((long)left % (long)right);
case LiteralType.Single: return((float)left % (float)right);
default: return(null);
}
}
/// <summary>
/// Sets the entity to be a literal of the type specified.
/// </summary>
/// <param name="token">One of "CDATA", "SDATA" or "PI".</param>
public void SetLiteralType(string token)
{
switch (token)
{
case "CDATA":
this.m_literalType = LiteralType.CDATA;
break;
case "SDATA":
this.m_literalType = LiteralType.SDATA;
break;
case "PI":
this.m_literalType = LiteralType.PI;
break;
}
}
private object ResolveSub(object left, object right, LiteralType type)
{
switch (type)
{
case LiteralType.Decimal: return((decimal)left - (decimal)right);
case LiteralType.Double: return((double)left - (double)right);
// case LiteralType.Duration: return (XmlTimeSpan)left - (XmlTimeSpan)right;
case LiteralType.Int: return((int)left - (int)right);
case LiteralType.Long: return((long)left - (long)right);
case LiteralType.Single: return((float)left - (float)right);
default: return(null);
}
}
void CheckSoapBindingExtensions (ConformanceCheckContext ctx, Binding value, LiteralType type)
{
bool violationNS = false;
bool violation2717 = false;
bool violation2720 = false;
bool violation2721 = false;
foreach (OperationBinding op in value.Operations) {
SoapBodyBinding sbb = op.Extensions.Find (typeof (SoapBodyBinding)) as SoapBodyBinding;
if (sbb != null) {
if (type == LiteralType.Document && sbb.Namespace != null)
violationNS = true;
if (type == LiteralType.Rpc && sbb.Namespace == null)
violation2717 = true;
}
SoapHeaderBinding shb = op.Extensions.Find (typeof (SoapHeaderBinding)) as SoapHeaderBinding;
if (shb != null) {
violationNS |= shb.Namespace != null;
violation2720 |= !IsValidPart (shb.Part);
}
SoapHeaderFaultBinding sfhb = op.Extensions.Find (typeof (SoapHeaderFaultBinding)) as SoapHeaderFaultBinding;
if (sfhb != null) {
violationNS |= sfhb.Namespace != null;
violation2720 |= !IsValidPart (sfhb.Part);
}
SoapFaultBinding sfb = op.Extensions.Find (typeof (SoapFaultBinding)) as SoapFaultBinding;
if (sfb != null) {
violation2721 |= sfb.Name == null;
violationNS |= sfb.Namespace != null;
}
}
if (violationNS)
ctx.ReportRuleViolation (value,
type == LiteralType.Document ?
BasicProfileRules.R2716 :
BasicProfileRules.R2726);
if (violation2717)
ctx.ReportRuleViolation (value, BasicProfileRules.R2717);
if (violation2720)
ctx.ReportRuleViolation (value, BasicProfileRules.R2720);
if (violation2721)
ctx.ReportRuleViolation (value, BasicProfileRules.R2721);
}
public void SetLiteralType(string token) {
switch (token) {
case "CDATA":
LiteralType = LiteralType.CDATA;
break;
case "SDATA":
LiteralType = LiteralType.SDATA;
break;
case "PI":
LiteralType = LiteralType.PI;
break;
}
}
private Token ScanLiteral(LiteralType literalType)
{
Debug.Assert(_chars[_curPos] == '"' || _chars[_curPos] == '\'');
char quoteChar = _chars[_curPos];
char replaceChar = (literalType == LiteralType.AttributeValue) ? (char)0x20 : (char)0xA;
int startQuoteEntityId = _currentEntityId;
_literalLineInfo.Set(LineNo, LinePos);
_curPos++;
_tokenStartPos = _curPos;
#if SILVERLIGHT
stringBuilder.Clear();
#else
_stringBuilder.Length = 0;
#endif
for (;;)
{
while (_xmlCharType.IsAttributeValueChar(_chars[_curPos]) && _chars[_curPos] != '%')
{
_curPos++;
}
if (_chars[_curPos] == quoteChar && _currentEntityId == startQuoteEntityId)
{
if (_stringBuilder.Length > 0)
{
_stringBuilder.Append(_chars, _tokenStartPos, _curPos - _tokenStartPos);
}
_curPos++;
_literalQuoteChar = quoteChar;
return Token.Literal;
}
int tmp1 = _curPos - _tokenStartPos;
if (tmp1 > 0)
{
_stringBuilder.Append(_chars, _tokenStartPos, tmp1);
_tokenStartPos = _curPos;
}
switch (_chars[_curPos])
{
case '"':
case '\'':
case '>':
_curPos++;
continue;
// eol
case (char)0xA:
_curPos++;
if (Normalize)
{
_stringBuilder.Append(replaceChar); // For attributes: CDATA normalization of 0xA
_tokenStartPos = _curPos;
}
_readerAdapter.OnNewLine(_curPos);
continue;
case (char)0xD:
if (_chars[_curPos + 1] == (char)0xA)
{
if (Normalize)
{
if (literalType == LiteralType.AttributeValue)
{
_stringBuilder.Append(_readerAdapter.IsEntityEolNormalized ? "\u0020\u0020" : "\u0020"); // CDATA normalization of 0xD 0xA
}
else
{
_stringBuilder.Append(_readerAdapter.IsEntityEolNormalized ? "\u000D\u000A" : "\u000A"); // EOL normalization of 0xD 0xA
}
_tokenStartPos = _curPos + 2;
SaveParsingBuffer(); // EOL normalization of 0xD 0xA in internal subset value
_readerAdapter.CurrentPosition++;
}
_curPos += 2;
}
else if (_curPos + 1 == _charsUsed)
{
goto ReadData;
}
else
{
_curPos++;
if (Normalize)
{
_stringBuilder.Append(replaceChar); // For attributes: CDATA normalization of 0xD and 0xD 0xA
_tokenStartPos = _curPos; // For entities: EOL normalization of 0xD and 0xD 0xA
}
}
_readerAdapter.OnNewLine(_curPos);
continue;
// tab
case (char)0x9:
if (literalType == LiteralType.AttributeValue && Normalize)
{
_stringBuilder.Append((char)0x20); // For attributes: CDATA normalization of 0x9
_tokenStartPos++;
}
_curPos++;
continue;
// attribute values cannot contain '<'
case '<':
if (literalType == LiteralType.AttributeValue)
{
Throw(_curPos, SR.Xml_BadAttributeChar, XmlException.BuildCharExceptionArgs('<', '\0'));
}
_curPos++;
continue;
// parameter entity reference
case '%':
if (literalType != LiteralType.EntityReplText)
{
_curPos++;
continue;
}
HandleEntityReference(true, true, literalType == LiteralType.AttributeValue);
_tokenStartPos = _curPos;
continue;
// general entity reference
case '&':
if (literalType == LiteralType.SystemOrPublicID)
{
_curPos++;
continue;
}
if (_curPos + 1 == _charsUsed)
{
goto ReadData;
}
// numeric characters reference
if (_chars[_curPos + 1] == '#')
{
SaveParsingBuffer();
int endPos = _readerAdapter.ParseNumericCharRef(SaveInternalSubsetValue ? _internalSubsetValueSb : null);
LoadParsingBuffer();
_stringBuilder.Append(_chars, _curPos, endPos - _curPos);
_readerAdapter.CurrentPosition = endPos;
_tokenStartPos = endPos;
_curPos = endPos;
continue;
}
else
{
// general entity reference
SaveParsingBuffer();
if (literalType == LiteralType.AttributeValue)
{
int endPos = _readerAdapter.ParseNamedCharRef(true, SaveInternalSubsetValue ? _internalSubsetValueSb : null);
LoadParsingBuffer();
if (endPos >= 0)
{
_stringBuilder.Append(_chars, _curPos, endPos - _curPos);
_readerAdapter.CurrentPosition = endPos;
_tokenStartPos = endPos;
_curPos = endPos;
continue;
}
else
{
HandleEntityReference(false, true, true);
_tokenStartPos = _curPos;
}
continue;
}
else
{
int endPos = _readerAdapter.ParseNamedCharRef(false, null);
LoadParsingBuffer();
if (endPos >= 0)
{
_tokenStartPos = _curPos;
_curPos = endPos;
continue;
}
else
{
_stringBuilder.Append('&');
_curPos++;
_tokenStartPos = _curPos;
// Bypass general entities in entity values
XmlQualifiedName entityName = ScanEntityName();
VerifyEntityReference(entityName, false, false, false);
}
continue;
}
}
default:
// end of buffer
if (_curPos == _charsUsed)
{
goto ReadData;
}
// surrogate chars
else
{
char ch = _chars[_curPos];
if (XmlCharType.IsHighSurrogate(ch))
{
if (_curPos + 1 == _charsUsed)
{
goto ReadData;
}
_curPos++;
if (XmlCharType.IsLowSurrogate(_chars[_curPos]))
{
_curPos++;
continue;
}
}
ThrowInvalidChar(_chars, _charsUsed, _curPos);
return Token.None;
}
}
ReadData:
Debug.Assert(_curPos - _tokenStartPos == 0);
// read new characters into the buffer
if (_readerAdapter.IsEof || ReadData() == 0)
{
if (literalType == LiteralType.SystemOrPublicID || !HandleEntityEnd(true))
{
Throw(_curPos, SR.Xml_UnclosedQuote);
}
}
_tokenStartPos = _curPos;
}
}
private static void CoerceString(ref object value, LiteralType type)
{
if (type != LiteralType.String)
value = value.ToString();
}
/// <summary>
/// Sets the entity to be a literal of the type specified.
/// </summary>
/// <param name="token">One of "CData", "SData" or "PI".</param>
public void SetLiteralType(string token)
{
switch (token)
{
case "CDATA":
_literalType = LiteralType.CData;
break;
case "SDATA":
_literalType = LiteralType.SData;
break;
case "PI":
_literalType = LiteralType.ProcessingInstruction;
break;
default:
throw Error.InvalidLiteralTypeValue(token);
}
}
private Token ScanLiteral( LiteralType literalType ) {
Debug.Assert( chars[curPos] == '"' || chars[curPos] == '\'' );
char quoteChar = chars[curPos];
char replaceChar = ( literalType == LiteralType.AttributeValue ) ? (char)0x20 : (char)0xA;
int startQuoteEntityId = currentEntityId;
literalLineInfo.Set( LineNo, LinePos );
curPos++;
tokenStartPos = curPos;
stringBuilder.Length = 0;
for (;;) {
unsafe {
while ( ( xmlCharType.charProperties[chars[curPos]] & XmlCharType.fAttrValue ) != 0 && chars[curPos] != '%' ) {
curPos++;
}
}
if ( chars[curPos] == quoteChar && currentEntityId == startQuoteEntityId ) {
if ( stringBuilder.Length > 0 ) {
stringBuilder.Append( chars, tokenStartPos, curPos - tokenStartPos );
}
curPos++;
literalQuoteChar = quoteChar;
return Token.Literal;
}
int tmp1 = curPos - tokenStartPos;
if ( tmp1 > 0 ) {
stringBuilder.Append( chars, tokenStartPos, tmp1 );
tokenStartPos = curPos;
}
switch ( chars[curPos] ) {
case '"':
case '\'':
case '>':
curPos++;
continue;
// eol
case (char)0xA:
curPos++;
if ( normalize ) {
stringBuilder.Append( replaceChar ); // For attributes: CDATA normalization of 0xA
tokenStartPos = curPos;
}
readerAdapter.OnNewLine( curPos );
continue;
case (char)0xD:
if ( chars[curPos+1] == (char)0xA ) {
if ( normalize ) {
if ( literalType == LiteralType.AttributeValue ) {
stringBuilder.Append( readerAdapter.IsEntityEolNormalized ? "\u0020\u0020" : "\u0020" ); // CDATA normalization of 0xD 0xA
}
else {
stringBuilder.Append( readerAdapter.IsEntityEolNormalized ? "\u000D\u000A" : "\u000A" ); // EOL normalization of 0xD 0xA
}
tokenStartPos = curPos + 2;
SaveParsingBuffer(); // EOL normalization of 0xD 0xA in internal subset value
readerAdapter.CurrentPosition++;
}
curPos += 2;
}
else if ( curPos+1 == charsUsed ) {
goto ReadData;
}
else {
curPos++;
if ( normalize ) {
stringBuilder.Append( replaceChar ); // For attributes: CDATA normalization of 0xD and 0xD 0xA
tokenStartPos = curPos; // For entities: EOL normalization of 0xD and 0xD 0xA
}
}
readerAdapter.OnNewLine( curPos );
continue;
// tab
case (char)0x9:
if ( literalType == LiteralType.AttributeValue && normalize ) {
stringBuilder.Append( (char)0x20 ); // For attributes: CDATA normalization of 0x9
tokenStartPos++;
}
curPos++;
continue;
// attribute values cannot contain '<'
case '<':
if ( literalType == LiteralType.AttributeValue ) {
Throw( curPos, Res.Xml_BadAttributeChar, XmlException.BuildCharExceptionStr( '<' ) );
}
curPos++;
continue;
// parameter entity reference
case '%':
if ( literalType != LiteralType.EntityReplText ) {
curPos++;
continue;
}
HandleEntityReference( true, true, literalType == LiteralType.AttributeValue );
tokenStartPos = curPos;
continue;
// general entity reference
case '&':
if ( literalType == LiteralType.SystemOrPublicID ) {
curPos++;
continue;
}
if ( curPos + 1 == charsUsed ) {
goto ReadData;
}
// numeric characters reference
if ( chars[curPos + 1] == '#' ) {
SaveParsingBuffer();
int endPos = readerAdapter.ParseNumericCharRef( SaveInternalSubsetValue ? internalSubsetValueSb : null );
LoadParsingBuffer();
stringBuilder.Append( chars, curPos, endPos - curPos );
readerAdapter.CurrentPosition = endPos;
tokenStartPos = endPos;
curPos = endPos;
continue;
}
else {
// general entity reference
SaveParsingBuffer();
if ( literalType == LiteralType.AttributeValue ) {
int endPos = readerAdapter.ParseNamedCharRef( true, SaveInternalSubsetValue ? internalSubsetValueSb : null );
LoadParsingBuffer();
if ( endPos >= 0 ) {
stringBuilder.Append( chars, curPos, endPos - curPos );
readerAdapter.CurrentPosition = endPos;
tokenStartPos = endPos;
curPos = endPos;
continue;
}
else {
HandleEntityReference( false, true, true );
tokenStartPos = curPos;
}
continue;
}
else {
int endPos = readerAdapter.ParseNamedCharRef( false, null );
LoadParsingBuffer();
if ( endPos >= 0 ) {
tokenStartPos = curPos;
curPos = endPos;
continue;
}
else {
stringBuilder.Append( '&' );
curPos++;
tokenStartPos = curPos;
// Bypass general entities in entity values
XmlQualifiedName entityName = ScanEntityName();
VerifyEntityReference( entityName, false, false, false );
}
continue;
}
}
default:
// end of buffer
if ( curPos == charsUsed ) {
goto ReadData;
}
// surrogate chars
else {
char ch = chars[curPos];
if ( ch >= 0xd800 && ch <=0xdbff ) {
if ( curPos + 1 == charsUsed ) {
goto ReadData;
}
curPos++;
if ( chars[curPos] >= 0xdc00 && chars[curPos] <= 0xdfff) {
curPos++;
continue;
}
}
ThrowInvalidChar( curPos, ch );
return Token.None;
}
}
ReadData:
Debug.Assert( curPos - tokenStartPos == 0 );
// read new characters into the buffer
if ( readerAdapter.IsEof || ReadData() == 0 ) {
if ( literalType == LiteralType.SystemOrPublicID || !HandleEntityEnd( true ) ) {
Throw( curPos, Res.Xml_UnclosedQuote );
}
}
tokenStartPos = curPos;
}
}
/// <summary>
/// Конструтор
/// </summary>
/// <param name="value">тектовое представление литерала</param>
/// <param name="literalType">тип литерала</param>
public Literal(string value, LiteralType literalType)
{
Value = value;
LiteralType = literalType;
}
private static void CoerceDouble(ref object value, LiteralType type)
{
switch (type)
{
case LiteralType.Long:
value = (double)(long)value;
break;
case LiteralType.Int:
value = (double)(int)value;
break;
case LiteralType.Single:
value = (double)(float)value;
break;
case LiteralType.Double:
break;
default:
throw new NotSupportedException();
}
}
public static LiteralType CoerceLiteralValues(ref object left, LiteralType leftType, ref object right, LiteralType rightType)
{
if (leftType == rightType)
return leftType;
if (leftType != LiteralType.Null && rightType != LiteralType.Null)
{
if (leftType == LiteralType.String || rightType == LiteralType.String)
{
CoerceString(ref left, leftType);
CoerceString(ref right, rightType);
return LiteralType.String;
}
else if (IsInteger(leftType) && IsInteger(rightType))
{
CoerceLong(ref left, leftType);
CoerceLong(ref right, rightType);
return LiteralType.Long;
}
else if (IsFloatingOrInteger(leftType) && IsFloatingOrInteger(rightType))
{
if (leftType == LiteralType.Decimal || rightType == LiteralType.Decimal)
{
CoerceDecimal(ref left, leftType);
CoerceDecimal(ref right, rightType);
return LiteralType.Decimal;
}
else
{
CoerceDouble(ref left, leftType);
CoerceDouble(ref right, rightType);
return LiteralType.Double;
}
}
}
throw new ODataException(String.Format(
ErrorMessages.LiteralUtil_IncompatibleTypes,
leftType, rightType
));
}
private static void CoerceLong(ref object value, LiteralType type)
{
switch (type)
{
case LiteralType.Long:
break;
case LiteralType.Int:
value = (long)(int)value;
break;
default:
throw new NotSupportedException();
}
}
private static bool IsFloatingOrInteger(LiteralType type)
{
return IsFloating(type) || IsInteger(type);
}
private static bool IsFloating(LiteralType type)
{
return type == LiteralType.Single || type == LiteralType.Double || type == LiteralType.Decimal;
}
private static bool IsInteger(LiteralType type)
{
return type == LiteralType.Long || type == LiteralType.Int;
}
public LiteralColumnMapping(string literal, LiteralType literalType, DBColumn destinationColumn, ColumnUse columnUse)
: base(destinationColumn, columnUse)
{
this.literal = literal;
this.literalType = literalType;
}
public Literal(string desc, LiteralType t, int depth)
{
this.description = desc;
this.type = t;
this.depth = depth;
}
