public GroupConcat(bool distinct,
IList<IExpression> exprList,
IExpression orderBy,
bool isDesc,
IList<IExpression> appendedColumnNames,
string separator)
: base("GROUP_CONCAT", exprList)
{
IsDistinct = distinct;
OrderBy = orderBy;
IsDesc = isDesc;
if (appendedColumnNames == null || appendedColumnNames.IsEmpty())
{
AppendedColumnNames = new List<IExpression>(0);
}
else if (appendedColumnNames is List<IExpression>)
{
AppendedColumnNames = appendedColumnNames;
}
else
{
AppendedColumnNames = new List<IExpression>(
appendedColumnNames);
}
Separator = separator ?? ",";
}
public override bool Parse(ParseContext context, IAstNode parent) {
TokenStream<RToken> tokens = context.Tokens;
Debug.Assert(context.Tokens.CurrentToken.TokenType == RTokenType.Identifier ||
context.Tokens.CurrentToken.TokenType == RTokenType.String);
this.Identifier = RParser.ParseToken(context, this);
this.EqualsSign = RParser.ParseToken(context, this);
if (context.Tokens.CurrentToken.TokenType != RTokenType.Comma && context.Tokens.CurrentToken.TokenType != RTokenType.CloseBrace) {
Expression exp = new Expression(inGroup: true);
if (exp.Parse(context, this)) {
this.DefaultValue = exp;
}
} else {
this.DefaultValue = new NullExpression();
if (context.Tokens.IsEndOfStream()) {
context.AddError(new ParseError(ParseErrorType.ExpressionExpected, ErrorLocation.Token, context.Tokens.CurrentToken));
} else {
context.AddError(new ParseError(ParseErrorType.ExpressionExpected, ErrorLocation.Token, EqualsSign));
}
}
return base.Parse(context, parent);
}
public DotExpression(IExpression expression, string name, ICollection<IExpression> arguments)
{
this.expression = expression;
this.name = name;
this.arguments = arguments;
this.type = AsType(this.expression);
}
public ForEachCommand(string name, IExpression expression, ICommand command, bool localvar)
{
this.name = name;
this.expression = expression;
this.command = command;
this.localvar = localvar;
}
/// <summary> Ctor.</summary>
/// <param name="selector">Selector.
/// </param>
/// <param name="root">Root expression of the parsed selector.
/// </param>
/// <param name="identifiers">Identifiers used by the selector. The key
/// into the <tt>Map</tt> is name of the identifier and the value is an
/// instance of <tt>Identifier</tt>.
/// </param>
private Selector(System.String selector, IExpression root, System.Collections.IDictionary identifiers)
{
selector_ = selector;
root_ = root;
//UPGRADE_ISSUE: Method 'java.util.Collections.unmodifiableMap' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javautilCollectionsunmodifiableMap_javautilMap"'
identifiers_ = identifiers;
}
protected override IExpression GetExpression(CSharpElementFactory factory, IExpression contractExpression)
{
var expression = isDictionary
? factory.CreateExpression(
string.Format("$0.{0}(pair => pair.{1} != null)", nameof(Enumerable.All), nameof(KeyValuePair<int, int>.Value)),
contractExpression)
: factory.CreateExpression(string.Format("$0.{0}(item => item != null)", nameof(Enumerable.All)), contractExpression);
var invokedExpression = (IReferenceExpression)((IInvocationExpression)expression).InvokedExpression;
Debug.Assert(invokedExpression != null);
var allMethodReference = invokedExpression.Reference;
var enumerableType = new DeclaredTypeFromCLRName(ClrTypeNames.Enumerable, Provider.PsiModule).GetTypeElement();
Debug.Assert(enumerableType != null);
var allMethod = enumerableType.Methods.First(method => method.AssertNotNull().ShortName == nameof(Enumerable.All));
Debug.Assert(allMethod != null);
allMethodReference.BindTo(allMethod);
return expression;
}
private bool FieldIsNotSource(IFieldDefinition fieldDefinition, IExpression source)
{
var bound = source as BoundExpression;
var field = bound == null? null : bound.Definition as IFieldReference;
bool ret = bound == null || field == null || field.ResolvedField != fieldDefinition;
return ret;
}
public RepeationByExpression(int count1, int count2, IExpression value, IExpression by)
{
this.count1 = count1;
this.count2 = count2;
this.value = value;
this.by = by;
}
public ExpressionPrinter(IExpression resolvedNode)
{
if (resolvedNode == null)
throw new ArgumentNullException("resolvedNode");
PrintNode(resolvedNode, 0);
}
private void PrintNode(IExpression node, int indent)
{
if (node == null)
return;
AppendLine(indent, "{" + node.GetType().Name + "}");
if (node is BinaryExpression)
PrintResolvedBinaryExpression((BinaryExpression)node, indent + 1);
else if (node is Cast)
PrintResolvedCast((Cast)node, indent + 1);
else if (node is Constant)
PrintResolvedConstant((Constant)node, indent + 1);
else if (node is FieldAccess)
PrintResolvedFieldAccess((FieldAccess)node, indent + 1);
else if (node is Index)
PrintResolvedIndex((Index)node, indent + 1);
else if (node is MethodCall)
PrintResolvedMethodCall((MethodCall)node, indent + 1);
else if (node is UnaryExpression)
PrintResolvedUnaryExpression((UnaryExpression)node, indent + 1);
else if (node is VariableAccess)
PrintResolvedVariableAccess((VariableAccess)node, indent + 1);
else if (node is TypeAccess)
PrintResolvedTypeAccess((TypeAccess)node, indent + 1);
else
throw new NotSupportedException();
}
public NumberOperation(IExpression ex)
{
Double op;
if (ex.StringExpression.IndexOf('+') <= 0 && ex.StringExpression.IndexOf('-') <= 0 && Double.TryParse(ex.StringExpression, NumberStyles.Any, CultureInfo.InvariantCulture, out op))
Value = op;
else throw new NotSupportedException(ex.StringExpression);
}
public IIfStatementOptions True(IExpression condition)
{
var ifStatement = new ConditionalStatement();
ifStatement.Condition = condition;
return new IfStatementOptions(ifStatement);
}
/// <summary>
/// Simplifies the <paramref name="expression"/>.
/// </summary>
/// <param name="expression">A expression to simplify.</param>
/// <returns>A simplified expression.</returns>
public IExpression Simplify(IExpression expression)
{
IExpression exp = _Simplify(expression);
exp.Parent = null;
return exp;
}
public CompareExpression(ComparisonOperator operation, IExpression left, IExpression right)
: base(left, right)
{
this.operation = operation;
switch (operation)
{
case ComparisonOperator.NonStrictEqual:
this.function = NonStrictEqual;
break;
case ComparisonOperator.NonStrictNotEqual:
this.function = NonStrictNotEqual;
break;
case ComparisonOperator.Equal:
this.function = Operators.CompareObjectEqual;
break;
case ComparisonOperator.NotEqual:
this.function = Operators.CompareObjectNotEqual;
break;
case ComparisonOperator.Less:
this.function = Operators.CompareObjectLess;
break;
case ComparisonOperator.LessEqual:
this.function = Operators.CompareObjectLessEqual;
break;
case ComparisonOperator.Greater:
this.function = Operators.CompareObjectGreater;
break;
case ComparisonOperator.GreaterEqual:
this.function = Operators.CompareObjectGreaterEqual;
break;
default:
throw new ArgumentException("Invalid operator");
}
}
/// <summary>
/// Initializes a new instance of the <see cref="UnaryExpression"/> class.
/// </summary>
/// <param name="expression">The expression.</param>
/// <exception cref="System.ArgumentNullException">expression</exception>
protected UnaryExpression(IExpression expression)
{
if (expression == null)
throw new ArgumentNullException("expression");
this.Expression = expression;
this.Type = expression.Type;
}
/// <summary>
/// Creates a query plan using a logic expression
/// </summary>
/// <param name="myExpression">The logic expression</param>
/// <param name="myIsLongRunning">Determines whether it is anticipated that the request could take longer</param>
/// <param name="myTransaction">The current transaction token</param>
/// <param name="mySecurity">The current security token</param>
/// <returns>A query plan</returns>
public IQueryPlan CreateQueryPlan(IExpression myExpression,
Boolean myIsLongRunning,
Int64 myTransaction,
SecurityToken mySecurity)
{
IQueryPlan result;
switch (myExpression.TypeOfExpression)
{
case TypeOfExpression.Binary:
result = GenerateFromBinaryExpression((BinaryExpression) myExpression, myIsLongRunning, myTransaction, mySecurity);
break;
case TypeOfExpression.Unary:
result = GenerateFromUnaryExpression((UnaryExpression)myExpression, myTransaction, mySecurity);
break;
case TypeOfExpression.Property:
result = GenerateFromPropertyExpression((PropertyExpression)myExpression, myTransaction, mySecurity);
break;
default:
throw new ArgumentOutOfRangeException();
}
return result;
}
/// <summary>
/// Initializes a new instance of the <see cref="UserFunction"/> class.
/// </summary>
/// <param name="function">The name of function.</param>
/// <param name="args">Arguments.</param>
/// <param name="countOfParams">The count of parameters.</param>
public UserFunction(string function, IExpression[] args, int countOfParams)
: base(args, countOfParams)
{
this.function = function;
this.m_arguments = args;
this.countOfParams = countOfParams;
}
/// <summary>Optimizations: X||t->t, f||X->X, X||X->X, X||!X->t</summary>
public virtual IExpression Or(IExpression left, IExpression right)
{
if (left.Equals(BoolConstExpression.True) || right.Equals(BoolConstExpression.True
))
{
return BoolConstExpression.True;
}
if (left.Equals(BoolConstExpression.False))
{
return right;
}
if (right.Equals(BoolConstExpression.False))
{
return left;
}
if (left.Equals(right))
{
return left;
}
if (Negatives(left, right))
{
return BoolConstExpression.True;
}
return new OrExpression(left, right);
}
public IExpression Parse(Parser parser, IExpression left, Token<TokenType> token)
{
var innerToken = parser.PeekToken();
IExpression right = null;
switch (innerToken.Identifier)
{
default:
return new ArithmeticExpression(left, right, token);
case TokenType.Plus:
right = parser.TakeExpression(Predecence.Plus);
break;
case TokenType.Minus:
right = parser.TakeExpression(Predecence.Minus);
break;
case TokenType.Multiply:
right = parser.TakeExpression(Predecence.Multiply);
break;
case TokenType.Divide:
right = parser.TakeExpression(Predecence.Divide);
break;
case TokenType.Exponent:
right = parser.TakeExpression(Predecence.PowerOf);
break;
}
return Parse(parser, right, innerToken);
}
public ArithmeticBinaryExpression(ArithmeticOperator operation, IExpression left, IExpression right)
: base(left, right)
{
this.operation = operation;
switch (operation)
{
case ArithmeticOperator.Add:
this.function = AddOrConcatenateObjects;
break;
case ArithmeticOperator.Subtract:
this.function = Operators.SubtractObject;
break;
case ArithmeticOperator.Multiply:
this.function = Operators.MultiplyObject;
break;
case ArithmeticOperator.Divide:
this.function = Operators.DivideObject;
break;
case ArithmeticOperator.IntegerDivide:
this.function = Operators.IntDivideObject;
break;
case ArithmeticOperator.Modulo:
this.function = Operators.ModObject;
break;
default:
throw new ArgumentException("Invalid operator");
}
}
/// <exception cref="System.SqlSyntaxErrorException" />
public DmlSelectStatement(SelectOption option,
IList<Pair<IExpression, string>> selectExprList,
TableReferences tables,
IExpression where,
GroupBy group,
IExpression having,
OrderBy order,
Limit limit)
{
if (option == null)
{
throw new ArgumentException("argument 'option' is null");
}
Option = option;
if (selectExprList == null || selectExprList.IsEmpty())
{
this.selectExprList = new List<Pair<IExpression, string>>(0);
}
else
{
this.selectExprList = EnsureListType(selectExprList);
}
Tables = tables;
Where = where;
Group = group;
Having = having;
Order = order;
Limit = limit;
}
/// <summary>Optimizations: !(Bool)->(!Bool), !!X->X, !(X==Bool)->(X==!Bool)
/// </summary>
public virtual IExpression Not(IExpression expr)
{
if (expr.Equals(BoolConstExpression.True))
{
return BoolConstExpression.False;
}
if (expr.Equals(BoolConstExpression.False))
{
return BoolConstExpression.True;
}
if (expr is NotExpression)
{
return ((NotExpression)expr).Expr();
}
if (expr is ComparisonExpression)
{
ComparisonExpression cmpExpr = (ComparisonExpression)expr;
if (cmpExpr.Right() is ConstValue)
{
ConstValue rightConst = (ConstValue)cmpExpr.Right();
if (rightConst.Value() is bool)
{
bool boolVal = (bool)rightConst.Value();
// new Boolean() instead of Boolean.valueOf() for .NET conversion
return new ComparisonExpression(cmpExpr.Left(), new ConstValue(!boolVal), cmpExpr
.Op());
}
}
}
return new NotExpression(expr);
}
protected override object Evaluate(IExpression left, IExpression right, ExecutionState state)
{
object b = TokenParser.VerifyUnderlyingType(right.Evaluate(state, token));
object a = TokenParser.VerifyUnderlyingType(left.Evaluate(state, token));
decimal x, y;
//typeof(decimal).IsAssignableFrom(typeof(a))
if (a is decimal)
x = (decimal)a;
else
{
//if(a is int || a is long || a is double || a is float || a is short
TypeConverter tc = TypeDescriptor.GetConverter(a);
if (!tc.CanConvertTo(typeof(decimal)))
return string.Concat(a, b);
x = (decimal)tc.ConvertTo(a, typeof(decimal));
}
if (b is decimal)
y = (decimal)b;
else
{
TypeConverter tc = TypeDescriptor.GetConverter(b);
if (!tc.CanConvertTo(typeof(decimal)))
return string.Concat(a, b);
y = (decimal)tc.ConvertTo(b, typeof(decimal));
}
return x + y;
}
public AdditionNonterminalExpression(
IExpression expr1,
IExpression expr2)
{
_expr1 = expr1;
_expr2 = expr2;
}
protected void Init(
IExpression fx,
IExpression fy,
IExpression fz,
double uMin,
double uMax,
double vMin,
double vMax
)
{
_fx = fx.Simplify();
_fy = fy.Simplify();
_fz = fz.Simplify();
_fxDu = _fx.Differentiate("u").Simplify();
_fxDv = _fx.Differentiate("v").Simplify();
_fyDu = _fy.Differentiate("u").Simplify();
_fyDv = _fy.Differentiate("v").Simplify();
_fzDu = _fz.Differentiate("u").Simplify();
_fzDv = _fz.Differentiate("v").Simplify();
UMin = uMin;
UMax = uMax;
VMin = vMin;
VMax = vMax;
}
public CompareExpression(ComparisonOperator operation, IExpression left, IExpression right)
: base(left, right)
{
this.operation = operation;
switch (operation)
{
case ComparisonOperator.Equal:
this.function = Operators.CompareObjectEqual;
break;
case ComparisonOperator.NotEqual:
this.function = Operators.CompareObjectNotEqual;
break;
case ComparisonOperator.Less:
this.function = Operators.CompareObjectLess;
break;
case ComparisonOperator.LessEqual:
this.function = Operators.CompareObjectLessEqual;
break;
case ComparisonOperator.Greater:
this.function = Operators.CompareObjectGreater;
break;
case ComparisonOperator.GreaterEqual:
this.function = Operators.CompareObjectGreaterEqual;
break;
}
}
private void WriteToDisk(IExpression expression, Resolver resolver)
{
var name = "Output.exe";
var assemblyName = new AssemblyName(name);
var assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(
assemblyName,
AssemblyBuilderAccess.RunAndSave
);
var moduleBuilder = assemblyBuilder.DefineDynamicModule(name);
var programClass = moduleBuilder.DefineType("Program", TypeAttributes.Public);
var mainMethod = programClass.DefineMethod("Main", MethodAttributes.Public | MethodAttributes.Static, null, new[] { typeof(string[]) });
var il = mainMethod.GetILGenerator();
new Compiler(il, resolver).Compile(expression);
programClass.CreateType();
assemblyBuilder.SetEntryPoint(programClass.GetMethod("Main"));
assemblyBuilder.Save(name);
}
public void Compile(IExpression expression)
{
Require.NotNull(expression, "expression");
expression.Accept(new Visitor(this));
if (
(expression.Type.IsValueType || _resolver.Options.ResultType.IsValueType) &&
expression.Type != _resolver.Options.ResultType
) {
try
{
ExtendedConvertToType(expression.Type, _resolver.Options.ResultType, true);
}
catch (Exception ex)
{
throw new ExpressionsException("Cannot convert expression result to expected result type", ExpressionsExceptionType.InvalidExplicitCast, ex);
}
_il.Emit(OpCodes.Box, _resolver.Options.ResultType);
}
else if (expression.Type.IsValueType)
{
_il.Emit(OpCodes.Box, expression.Type);
}
else if (!_resolver.Options.ResultType.IsAssignableFrom(expression.Type))
{
throw new ExpressionsException("Cannot convert expression result to expected result type", ExpressionsExceptionType.TypeMismatch);
}
_il.Emit(OpCodes.Ret);
}
public InstanceCreationExpression(string type, int row, int col, IExpression arraySize = null)
: base(row, col)
{
CreatedTypeName = type;
ArraySize = arraySize;
IsArrayCreation = arraySize != null;
}
public void ExpressionTest(int row, int column)
{
var expressions = new IExpression[]
{
new ConstantExpression(0),
new CellRefereceExpression(new CellAddress(1, 1)),
new BinaryExpression(new ConstantExpression(1), OperatorManager.Default.Operators['*'],
new ConstantExpression(2)),
new UnaryExpression(OperatorManager.Default.Operators['-'], new ConstantExpression(9)),
new ConstantExpression(91),
new ConstantExpression("text"),
};
var cells = expressions.Select((e, i) => new Cell(new CellAddress(i / column, i % column), e)).ToArray();
var spreadsheet = ReadSpreadsheet($"{row} {column}", expressions);
Assert.AreEqual(row, spreadsheet.RowCount, "Wrong row count");
Assert.AreEqual(column, spreadsheet.ColumnCount, "Wrong column count");
var array = spreadsheet.ToArray();
Assert.AreEqual(row * column, array.Length, "Wrong container size");
CollectionAssert.AreEqual(cells.Take(array.Length),
array,
new GenericComparer<Cell>((x,y) => string.Compare(x.ToString(), y.ToString(), StringComparison.Ordinal)));
}
public IExpression GreaterThan([NotNull] IExpression expression) => GetOperator(BinaryOpType.GreaterThan, CBDebug.MustNotBeNull(WriteLog.To.Query, Tag, nameof(expression), expression));
public IExpression Match([NotNull] IExpression expression) => GetOperator(BinaryOpType.Matches, CBDebug.MustNotBeNull(WriteLog.To.Query, Tag, nameof(expression), expression));
/// <summary>
/// Initializes a new instance of the <see cref="Tan"/> class.
/// </summary>
/// <param name="expression">The argument of function.</param>
public Tan(IExpression expression) : base(expression)
{
}
public ObjectLiteralExpression(IExpression definitions)
{
Definitions = definitions;
}
public static bool IsLeftHandSideExpression(IExpression node)
{
return(IsLeftHandSideExpressionKind(SkipPartiallyEmittedExpressions(node).Kind));
}
/// <summary>
/// 获取数据源
/// </summary>
/// <returns></returns>
protected virtual object GetDataSource()
{
ConnectionStringSettings setting = ConfigurationManager.ConnectionStrings[this.Connection.GetTextValue()];
if (setting == null)
{
return(null);
}
DbProviderFactory dbFactory = Utility.CreateDbProviderFactory(setting.ProviderName);
if (dbFactory == null)
{
return(null);
}
object result = null;
using (DbConnection dbConnection = dbFactory.CreateConnection())
{
dbConnection.ConnectionString = setting.ConnectionString;
using (DbCommand dbCommand = dbConnection.CreateCommand())
{
dbCommand.CommandType = this.CommandType == null ? System.Data.CommandType.Text : (System.Data.CommandType)Utility.ConvertTo(this.CommandType.GetTextValue(), typeof(System.Data.CommandType));
dbCommand.CommandText = this.CommandText.GetTextValue();
if (this.Parameters.Count > 0)
{
string format = this.ParameterFormat == null ? "@p{0}" : this.ParameterFormat.GetTextValue();
List <object> expParams = new List <object>();
for (int i = 0; i < this.Parameters.Count; i++)
{
IExpression exp = this.Parameters[i];
DbParameter dbParameter = dbFactory.CreateParameter();
object value = exp.GetValue();
dbParameter.ParameterName = string.IsNullOrEmpty(format) ? "?" : string.Format(format, i);
dbParameter.DbType = Utility.GetObjectDbType(value);
dbParameter.Value = value;
dbCommand.Parameters.Add(dbParameter);
}
}
using (DbDataAdapter dbAdapter = dbFactory.CreateDataAdapter())
{
dbAdapter.SelectCommand = dbCommand;
DataTable table = new DataTable();
dbAdapter.Fill(table);
if (this.RowIndex != null)
{
//只获取其中的某行数据
int row = Utility.ConverToInt32(this.RowIndex.GetTextValue());
if (table.Rows.Count > row)
{
result = table.Rows[row];
}
}
else
{
result = table;
}
}
}
}
return(result);
}
protected void AddToInvertedIndex(GroupKey key, IExpression expr, ICollection <object> declsInBinding)
{
Dictionary <object, List <GroupKey> > dict;
if (!invertedIndex.TryGetValue(expr, out dict))
{
dict = new Dictionary <object, List <GroupKey> >();
invertedIndex[expr] = dict;
}
// the GroupKey must appear somewhere in the inverted index, so if there are no
// variables in the binding we put the GroupKey under a dummy variable
if (declsInBinding.Count == 0)
{
declsInBinding = new List <object>()
{
tempDecl
}
}
;
foreach (var ivd in declsInBinding)
{
List <GroupKey> keys;
if (!dict.TryGetValue(ivd, out keys))
{
keys = new List <GroupKey>();
dict[ivd] = keys;
keys.Add(key);
}
else
{
// simplify the existing keys
// The GroupKeys in the inverted index must be the same objects as the keys in the groups dictionary.
// We ensure this by adding the existing keys first, then the new key if it is not a duplicate.
Set <GroupKey> set = new Set <GroupKey>();
set.AddRange(keys);
set.Add(key);
keys.Clear();
keys.AddRange(set);
}
}
}
/// <summary>
/// Build an inverted index to the groups dictionary
/// </summary>
/// <param name="loopVars"></param>
void BuildInvertedIndex(ICollection <IVariableDeclaration> loopVars)
{
invertedIndex = new Dictionary <IExpression, Dictionary <object, List <GroupKey> > >();
foreach (var key in groups.Keys)
{
foreach (var eb in key)
{
AddToInvertedIndex(key, eb.Expression, GetVariablesAndParameters(eb.Binding, loopVars));
}
}
}
/// <summary>
/// Get all non-loop variables or parameters in bindings
/// </summary>
/// <param name="bindings"></param>
/// <param name="loopVars"></param>
/// <returns></returns>
Set <object> GetVariablesAndParameters(IEnumerable <ConditionBinding> bindings, ICollection <IVariableDeclaration> loopVars)
{
return(Set <object> .FromEnumerable(bindings.Select(binding =>
Recognizer.GetVariablesAndParameters(binding.GetExpression())
.Where(decl => !(decl is IVariableDeclaration) || !loopVars.Contains((IVariableDeclaration)decl))
)));
}
public SubtractExpression(IExpression leftExpression, IExpression rightExpression)
{
_leftExpression = leftExpression;
_rightExpression = rightExpression;
}
public IExpression Or([NotNull] IExpression expression) =>
new QueryCompoundExpression("OR", this, CBDebug.MustNotBeNull(WriteLog.To.Query, Tag, nameof(expression), expression));
public IExpression Regex([NotNull] IExpression expression) => GetOperator(BinaryOpType.RegexLike, CBDebug.MustNotBeNull(WriteLog.To.Query, Tag, nameof(expression), expression));
internal DeleteStatement(IExpression target)
{
this.deleteTarget = target;
}
public IExpression NotEqualTo([NotNull] IExpression expression) => GetOperator(BinaryOpType.NotEqualTo, CBDebug.MustNotBeNull(WriteLog.To.Query, Tag, nameof(expression), expression));
static void AssignTo(IExpression target, Dictionary <ILocalSymbol, HashSet <INamedTypeSymbol> > localsSourceTypes, Dictionary <IFieldSymbol, HashSet <INamedTypeSymbol> > fieldsSourceTypes, IExpression sourceValue)
{
AssignTo(target, localsSourceTypes, fieldsSourceTypes, OriginalType(sourceValue));
}
/// <summary>
/// Creates a new instance of the <see cref="RequiredValidator"/> class.
/// </summary>
/// <param name="test">The expression to validate.</param>
/// <param name="when">The expression that determines if this validator should be evaluated.</param>
public RequiredValidator(IExpression test, IExpression when) : base(test, when)
{
AssertUtils.ArgumentNotNull(test, "test");
}
public object RunExpressionCustomScope(IExpression exp, ValueContainer scope)
{
return(Evaluate(scope, exp));
}
public IndexedExpression(IExpression targetExpression, IExpression sliceExpression)
{
this.targetExpression = targetExpression;
this.sliceExpression = sliceExpression;
}
public virtual IContentQuery <T> Create(IExpression expression)
{
return(new ContentQuery <T>(this.Repository, expression));
}
private object Evaluate(ValueContainer context, IExpression command)
{
return(Evaluate(context, new List <IExpression> {
command
}));
}
/// <summary>
/// Initializes a new instance of the <see cref="Abs"/> class.
/// </summary>
/// <param name="expression">The argument of function.</param>
/// <seealso cref="IExpression"/>
public Abs(IExpression expression) : base(expression)
{
}
public DoStatement(IExpression condition, IBlockStatement body)
{
_condition = condition;
_body = body;
}
public Sin(IExpression e)
{
u = e; name = "sin";
}
public ContentQuery(Repository repository, IExpression expression)
{
this.Repository = repository;
this.Expression = expression;
}
public Exp(IExpression e)
{
u = e; name = "exp";
}
public Cos(IExpression e)
{
u = e; name = "cos";
}
public Tan(IExpression e)
{
u = e; name = "tan";
}
public Ln(IExpression e)
{
u = e; name = "ln";
}
public GreaterEqualNode(IExpression left, IExpression right) : base(left, right)
{
}
public Int(IExpression e)
{
u = e; name = "int";
}
public CallExpression(IExpression function, List <IExpression> args)
{
_function = function;
_args = args;
}
static void AssignTo <SymbolType>(SymbolType target, ITypeSymbol targetType, Dictionary <SymbolType, HashSet <INamedTypeSymbol> > sourceTypes, IExpression sourceValue)
{
AssignTo(target, targetType, sourceTypes, OriginalType(sourceValue));
}
