public ExprJsResolvedMethod(Ctx ctx, TypeReference returnType, Expr obj, string methodName, IEnumerable<Expr> args)
: base(ctx) {
this.returnType = returnType;
this.Obj = obj;
this.MethodName = methodName;
this.Args = args;
}
public ExprAlloc(string type, string name, Expr expr, bool isEqualSign)
{
this.Type = type;
this.Name = new List<string> { name };
this.ExprList = new List<Expr> { expr };
this.IsEqualSign = isEqualSign;
}
private void InternalValidate(Expr expr,object obj,out object output)
{
output = null;
var eqGoal = obj as EqGoal;
var query = obj as Query;
var equation = obj as Equation;
var shape = obj as ShapeSymbol;
if (eqGoal != null)
{
InternalValidate(expr, eqGoal, out output);
return;
}
if (query != null)
{
InternalValidate(expr, query, out output);
return;
}
if (equation != null)
{
InternalValidate(expr, equation, out output);
return;
}
if (shape != null)
{
InternalValidate(expr, shape, out output);
}
}
/*
** 2001 September 15
**
** The author disclaims copyright to this source code. In place of
** a legal notice, here is a blessing:
**
** May you do good and not evil.
** May you find forgiveness for yourself and forgive others.
** May you share freely, never taking more than you give.
**
*************************************************************************
** This file contains routines used for analyzing expressions and
** for generating VDBE code that evaluates expressions in SQLite.
*************************************************************************
** Included in SQLite3 port to C#-SQLite; 2008 Noah B Hart
** C#-SQLite is an independent reimplementation of the SQLite software library
**
** SQLITE_SOURCE_ID: 2011-06-23 19:49:22 4374b7e83ea0a3fbc3691f9c0c936272862f32f2
**
*************************************************************************
*/
//#include "sqliteInt.h"
/*
** Return the 'affinity' of the expression pExpr if any.
**
** If pExpr is a column, a reference to a column via an 'AS' alias,
** or a sub-select with a column as the return value, then the
** affinity of that column is returned. Otherwise, 0x00 is returned,
** indicating no affinity for the expression.
**
** i.e. the WHERE clause expresssions in the following statements all
** have an affinity:
**
** CREATE TABLE t1(a);
** SELECT * FROM t1 WHERE a;
** SELECT a AS b FROM t1 WHERE b;
** SELECT * FROM t1 WHERE (select a from t1);
*/
static char sqlite3ExprAffinity( Expr pExpr )
{
int op = pExpr.op;
if ( op == TK_SELECT )
{
Debug.Assert( ( pExpr.flags & EP_xIsSelect ) != 0 );
return sqlite3ExprAffinity( pExpr.x.pSelect.pEList.a[0].pExpr );
}
#if !SQLITE_OMIT_CAST
if ( op == TK_CAST )
{
Debug.Assert( !ExprHasProperty( pExpr, EP_IntValue ) );
return sqlite3AffinityType( pExpr.u.zToken );
}
#endif
if ( ( op == TK_AGG_COLUMN || op == TK_COLUMN || op == TK_REGISTER )
&& pExpr.pTab != null
)
{
/* op==TK_REGISTER && pExpr.pTab!=0 happens when pExpr was originally
** a TK_COLUMN but was previously evaluated and cached in a register */
int j = pExpr.iColumn;
if ( j < 0 )
return SQLITE_AFF_INTEGER;
Debug.Assert( pExpr.pTab != null && j < pExpr.pTab.nCol );
return pExpr.pTab.aCol[j].affinity;
}
return pExpr.affinity;
}
/// <summary>
/// Initialize
/// </summary>
/// <param name="start">start expression</param>
/// <param name="condition">condition for loop</param>
/// <param name="inc">increment expression</param>
public ForExpr(Expr start, Expr condition, Expr inc)
: base(condition)
{
this.Nodetype = NodeTypes.SysFor;
InitBoundary(true, "}");
Init(start, condition, inc);
}
public ExprArgAddress(Ctx ctx, Expr arg, TypeReference type)
: base(ctx) {
//this.Index = index;
this.Arg = arg;
this.ElementType = type;
this.type = type.MakePointer();
}
void PredicateCmd(Expr p, Expr pDom, List<Block> blocks, Block block, Cmd cmd, out Block nextBlock) {
var cCmd = cmd as CallCmd;
if (cCmd != null && !useProcedurePredicates(cCmd.Proc)) {
if (p == null) {
block.Cmds.Add(cmd);
nextBlock = block;
return;
}
var trueBlock = new Block();
blocks.Add(trueBlock);
trueBlock.Label = block.Label + ".call.true";
trueBlock.Cmds.Add(new AssumeCmd(Token.NoToken, p));
trueBlock.Cmds.Add(cmd);
var falseBlock = new Block();
blocks.Add(falseBlock);
falseBlock.Label = block.Label + ".call.false";
falseBlock.Cmds.Add(new AssumeCmd(Token.NoToken, Expr.Not(p)));
var contBlock = new Block();
blocks.Add(contBlock);
contBlock.Label = block.Label + ".call.cont";
block.TransferCmd =
new GotoCmd(Token.NoToken, new List<Block> { trueBlock, falseBlock });
trueBlock.TransferCmd = falseBlock.TransferCmd =
new GotoCmd(Token.NoToken, new List<Block> { contBlock });
nextBlock = contBlock;
} else {
PredicateCmd(p, pDom, block.Cmds, cmd);
nextBlock = block;
}
}
/// <summary>
/// Sets a value on a member of a basic type.
/// </summary>
/// <param name="ctx">The context of the runtime</param>
/// <param name="varExp">The expression representing the index of the instance to set</param>
/// <param name="valExp">The expression representing the value to set</param>
/// <param name="node">The assignment ast node</param>
public static void SetIndexValue(Context ctx, IAstVisitor visitor, AstNode node, Expr varExp, Expr valExp)
{
// 1. Get the value that is being assigned.
var val = valExp.Evaluate(visitor) as LObject;
// 2. Check the limit if string.
ctx.Limits.CheckStringLength(node, val);
// 3. Evaluate expression to get index info.
var indexExp = varExp.Evaluate(visitor) as IndexAccess;
if (indexExp == null)
throw ComLib.Lang.Helpers.ExceptionHelper.BuildRunTimeException(node, "Value to assign is null");
// 4. Get the target of the index access and the name / number to set.
var target = indexExp.Instance;
var memberNameOrIndex = indexExp.MemberName;
// Get methods associated with type.
var methods = ctx.Methods.Get(target.Type);
// Case 1: users[0] = 'kishore'
if (target.Type == LTypes.Array)
{
var index = Convert.ToInt32(((LNumber)memberNameOrIndex).Value);
methods.SetByNumericIndex(target, index, val);
}
// Case 2: users['total'] = 20
else if (target.Type == LTypes.Map)
{
var name = ((LString)memberNameOrIndex).Value;
methods.SetByStringMember(target, name, val);
}
}
/// <summary>
/// Initialize
/// </summary>
/// <param name="isDeclaration">Whether or not the variable is being declared in addition to assignment.</param>
/// <param name="varExp">Expression representing the variable name to set</param>
/// <param name="valueExp">Expression representing the value to set variable to.</param>
public AssignExpr(bool isDeclaration, Expr varExp, Expr valueExp)
{
this.Nodetype = NodeTypes.SysAssign;
this.IsDeclaration = isDeclaration;
this.VarExp = varExp;
this.ValueExp = valueExp;
}
public ExprTernary(Ctx ctx, Expr condition, Expr ifTrue, Expr ifFalse)
: base(ctx) {
this.Condition = condition;
this.IfTrue = ifTrue;
this.IfFalse = ifFalse;
this.type = TypeCombiner.Combine(ctx, ifTrue, ifFalse);
}
/// <summary>
/// Initialize
/// </summary>
/// <param name="aggregateType">sum avg min max count total</param>
/// <param name="source"></param>
public AggregateExpr(string aggregateType, Expr source)
{
this.Nodetype = "FSExtAggregate";
this.InitBoundary(true, ")");
this._aggregateType = aggregateType;
this._source = source;
}
/// <summary>
/// Called by the framework after the parse method is called
/// </summary>
/// <param name="node">The node returned by this implementations Parse method</param>
public void OnParseAssignComplete(Expr expr)
{
var stmt = expr as AssignMultiExpr;
if (stmt.Assignments == null || stmt.Assignments.Count == 0)
return;
foreach (var assignment in stmt.Assignments)
{
var exp = assignment.VarExp;
if (exp.IsNodeType(NodeTypes.SysVariable))
{
var varExp = exp as VariableExpr;
var valExp = assignment.ValueExp;
var name = varExp.Name;
var registeredTypeVar = false;
var ctx = this._parser.Context;
if (valExp != null && valExp.IsNodeType(NodeTypes.SysNew))
{
var newExp = valExp as NewExpr;
if (ctx.Types.Contains(newExp.TypeName))
{
var type = ctx.Types.Get(newExp.TypeName);
var ltype = LangTypeHelper.ConvertToLangTypeClass(type);
ctx.Symbols.DefineVariable(name, ltype);
registeredTypeVar = true;
}
}
if (!registeredTypeVar)
ctx.Symbols.DefineVariable(name, LTypes.Object);
}
}
}
/// <summary>
/// Sets a value on a member of a basic type.
/// </summary>
/// <param name="ctx">The context of the runtime</param>
/// <param name="node">The assignment ast node</param>
/// <param name="isDeclaration">Whether or not this is a declaration</param>
/// <param name="varExp">The expression representing the index of the instance to set</param>
/// <param name="valExp">The expression representing the value to set</param>
public static void SetVariableValue(Context ctx, IAstVisitor visitor, AstNode node, bool isDeclaration, Expr varExp, Expr valExp)
{
string varname = ((VariableExpr)varExp).Name;
// Case 1: var result;
if (valExp == null)
{
ctx.Memory.SetValue(varname, LObjects.Null, isDeclaration);
}
// Case 2: var result = <expression>;
else
{
var result = valExp.Evaluate(visitor);
// Check for type: e.g. LFunction ? when using Lambda?
if (result != null && result != LObjects.Null)
{
var lobj = result as LObject;
if (lobj != null && lobj.Type.TypeVal == TypeConstants.Function)
{
// 1. Define the function in global symbol scope
SymbolHelper.ResetSymbolAsFunction(varExp.SymScope, varname, lobj);
}
}
// CHECK_LIMIT:
ctx.Limits.CheckStringLength(node, result);
ctx.Memory.SetValue(varname, result, isDeclaration);
}
// LIMIT CHECK
ctx.Limits.CheckScopeCount(varExp);
ctx.Limits.CheckScopeStringLength(varExp);
}
private Expr Convert(Expr e, TypeReference toType) {
if (e == null) {
return null;
}
var eType = e.Type.FullResolve(e.Ctx);
if (eType.IsPointer) {
// HACK: ?? This is probably a hack, not quite sure yet
eType = ((PointerType)eType).ElementType;
}
if (eType.IsAssignableTo(toType)) {
return e;
}
if (e.ExprType == Expr.NodeType.Literal) {
var eLit = (ExprLiteral)e;
if (toType.IsChar()) {
if (eType.IsInt32()) {
return new ExprLiteral(e.Ctx, (char)(int)eLit.Value, e.Ctx.Char);
}
}
if (toType.IsBoolean()) {
if (eType.IsInt32()) {
return new ExprLiteral(e.Ctx, ((int)eLit.Value) != 0, e.Ctx.Boolean);
}
}
}
return e;
}
public ExprVariableAddress(Ctx ctx, Expr variable, TypeReference type)
: base(ctx) {
//this.Index = index;
this.Variable = variable;
this.ElementType = type;
this.type = type.MakePointer();
}
public ExprAlloc(SugarType type, string name, Expr expr, AllocType style)
{
this.Type = type;
this.Name = new List<string> { name };
this.ExprList = new List<Expr> { expr };
this.Style = style;
}
/// <summary>
/// Ctor
/// </summary>
/// <param name="expr"></param>
/// <param name="stmt"></param>
public If(Expr expr, Stmt stmt)
{
this.Expr = expr;
this.Stmt = stmt;
if(this.Expr.Type != Type.Bool)
this.Expr.Error("boolean required in if");
}
/*
** 2008 August 18
**
** The author disclaims copyright to this source code. In place of
** a legal notice, here is a blessing:
**
** May you do good and not evil.
** May you find forgiveness for yourself and forgive others.
** May you share freely, never taking more than you give.
**
*************************************************************************
**
** This file contains routines used for walking the parser tree and
** resolve all identifiers by associating them with a particular
** table and column.
*************************************************************************
** Included in SQLite3 port to C#-SQLite; 2008 Noah B Hart
** C#-SQLite is an independent reimplementation of the SQLite software library
**
** SQLITE_SOURCE_ID: 2010-01-05 15:30:36 28d0d7710761114a44a1a3a425a6883c661f06e7
**
** $Header$
*************************************************************************
*/
//#include "sqliteInt.h"
//#include <stdlib.h>
//#include <string.h>
/*
** Turn the pExpr expression into an alias for the iCol-th column of the
** result set in pEList.
**
** If the result set column is a simple column reference, then this routine
** makes an exact copy. But for any other kind of expression, this
** routine make a copy of the result set column as the argument to the
** TK_AS operator. The TK_AS operator causes the expression to be
** evaluated just once and then reused for each alias.
**
** The reason for suppressing the TK_AS term when the expression is a simple
** column reference is so that the column reference will be recognized as
** usable by indices within the WHERE clause processing logic.
**
** Hack: The TK_AS operator is inhibited if zType[0]=='G'. This means
** that in a GROUP BY clause, the expression is evaluated twice. Hence:
**
** SELECT random()%5 AS x, count(*) FROM tab GROUP BY x
**
** Is equivalent to:
**
** SELECT random()%5 AS x, count(*) FROM tab GROUP BY random()%5
**
** The result of random()%5 in the GROUP BY clause is probably different
** from the result in the result-set. We might fix this someday. Or
** then again, we might not...
*/
static void resolveAlias(
Parse pParse, /* Parsing context */
ExprList pEList, /* A result set */
int iCol, /* A column in the result set. 0..pEList.nExpr-1 */
Expr pExpr, /* Transform this into an alias to the result set */
string zType /* "GROUP" or "ORDER" or "" */
)
{
Expr pOrig; /* The iCol-th column of the result set */
Expr pDup; /* Copy of pOrig */
sqlite3 db; /* The database connection */
Debug.Assert( iCol >= 0 && iCol < pEList.nExpr );
pOrig = pEList.a[iCol].pExpr;
Debug.Assert( pOrig != null );
Debug.Assert( ( pOrig.flags & EP_Resolved ) != 0 );
db = pParse.db;
if ( pOrig.op != TK_COLUMN && ( zType.Length == 0 || zType[0] != 'G' ) )
{
pDup = sqlite3ExprDup( db, pOrig, 0 );
pDup = sqlite3PExpr( pParse, TK_AS, pDup, null, null );
if ( pDup == null ) return;
if ( pEList.a[iCol].iAlias == 0 )
{
pEList.a[iCol].iAlias = (u16)( ++pParse.nAlias );
}
pDup.iTable = pEList.a[iCol].iAlias;
}
else if ( ExprHasProperty( pOrig, EP_IntValue ) || pOrig.u.zToken == null )
{
pDup = sqlite3ExprDup( db, pOrig, 0 );
if ( pDup == null ) return;
}
else
{
string zToken = pOrig.u.zToken;
Debug.Assert( zToken != null );
pOrig.u.zToken = null;
pDup = sqlite3ExprDup( db, pOrig, 0 );
pOrig.u.zToken = zToken;
if ( pDup == null ) return;
Debug.Assert( ( pDup.flags & ( EP_Reduced | EP_TokenOnly ) ) == 0 );
pDup.flags2 |= EP2_MallocedToken;
pDup.u.zToken = zToken;// sqlite3DbStrDup( db, zToken );
}
if ( ( pExpr.flags & EP_ExpCollate ) != 0 )
{
pDup.pColl = pExpr.pColl;
pDup.flags |= EP_ExpCollate;
}
/* Before calling sqlite3ExprDelete(), set the EP_Static flag. This
** prevents ExprDelete() from deleting the Expr structure itself,
** allowing it to be repopulated by the memcpy() on the following line.
*/
ExprSetProperty( pExpr, EP_Static );
sqlite3ExprDelete( db, ref pExpr );
pExpr.CopyFrom( pDup ); //memcpy(pExpr, pDup, sizeof(*pExpr));
sqlite3DbFree( db, ref pDup );
}
public AssertCmd(IToken/*!*/ tok, Expr/*!*/ expr, QKeyValue kv)
: base(tok, expr, kv)
{
Contract.Requires(tok != null);
Contract.Requires(expr != null);
errorDataEnhanced = GenerateBoundVarMiningStrategy(expr);
}
static Expr InverseFunctionConvolution(IContext context, Expr arg)
{
return arg
.ConvertAs<FunctionExpr>()
.If(x => context.GetFunction(x.FunctionName) is ExpFunction)
.Return(x => x.Args.First(), () => null);
}
/// <summary>
/// Adds an expression to be interpolated.
/// </summary>
/// <param name="exp"></param>
public void Add(Expr exp)
{
if (_expressions == null)
_expressions = new List<Expr>();
_expressions.Add(exp);
}
public ExprBinary(Ctx ctx, BinaryOp op, TypeReference type, Expr left, Expr right)
: base(ctx) {
this.Op = op;
this.type = type;
this.Left = left;
this.Right = right;
}
protected override ICode VisitExpr(Expr e) {
Expr r;
if (this.replace.TryGetValue(e, out r)) {
return r;
}
return base.VisitExpr(e);
}
/*
** 2008 August 16
**
** The author disclaims copyright to this source code. In place of
** a legal notice, here is a blessing:
**
** May you do good and not evil.
** May you find forgiveness for yourself and forgive others.
** May you share freely, never taking more than you give.
**
*************************************************************************
** This file contains routines used for walking the parser tree for
** an SQL statement.
*************************************************************************
** Included in SQLite3 port to C#-SQLite; 2008 Noah B Hart
** C#-SQLite is an independent reimplementation of the SQLite software library
**
** SQLITE_SOURCE_ID: 2010-08-23 18:52:01 42537b60566f288167f1b5864a5435986838e3a3
**
*************************************************************************
*/
//#include "sqliteInt.h"
//#include <stdlib.h>
//#include <string.h>
/*
** Walk an expression tree. Invoke the callback once for each node
** of the expression, while decending. (In other words, the callback
** is invoked before visiting children.)
**
** The return value from the callback should be one of the WRC_*
** constants to specify how to proceed with the walk.
**
** WRC_Continue Continue descending down the tree.
**
** WRC_Prune Do not descend into child nodes. But allow
** the walk to continue with sibling nodes.
**
** WRC_Abort Do no more callbacks. Unwind the stack and
** return the top-level walk call.
**
** The return value from this routine is WRC_Abort to abandon the tree walk
** and WRC_Continue to continue.
*/
static int sqlite3WalkExpr( Walker pWalker, ref Expr pExpr )
{
int rc;
if ( pExpr == null )
return WRC_Continue;
testcase( ExprHasProperty( pExpr, EP_TokenOnly ) );
testcase( ExprHasProperty( pExpr, EP_Reduced ) );
rc = pWalker.xExprCallback( pWalker, ref pExpr );
if ( rc == WRC_Continue
&& !ExprHasAnyProperty( pExpr, EP_TokenOnly ) )
{
if ( sqlite3WalkExpr( pWalker, ref pExpr.pLeft ) != 0 )
return WRC_Abort;
if ( sqlite3WalkExpr( pWalker, ref pExpr.pRight ) != 0 )
return WRC_Abort;
if ( ExprHasProperty( pExpr, EP_xIsSelect ) )
{
if ( sqlite3WalkSelect( pWalker, pExpr.x.pSelect ) != 0 )
return WRC_Abort;
}
else
{
if ( sqlite3WalkExprList( pWalker, pExpr.x.pList ) != 0 )
return WRC_Abort;
}
}
return rc & WRC_Abort;
}
static void ResolveAlias(Parse parse, ExprList list, int colId, Expr expr, string type, int subqueries)
{
Debug.Assert(colId >= 0 && colId < list.Exprs);
Expr orig = list.Ids[colId].Expr; // The iCol-th column of the result set
Debug.Assert(orig != null);
Debug.Assert((orig.Flags & EP.Resolved) != 0);
Context ctx = parse.Ctx; // The database connection
Expr dup = Expr.Dup(ctx, orig, 0); // Copy of pOrig
if (orig.OP != TK.COLUMN && (type.Length == 0 || type[0] != 'G'))
{
IncrAggFunctionDepth(dup, subqueries);
dup = Expr.PExpr_(parse, TK.AS, dup, null, null);
if (dup == null) return;
if (list.Ids[colId].Alias == 0)
list.Ids[colId].Alias = (ushort)(++parse.Alias.length);
dup.TableId = list.Ids[colId].Alias;
}
if (expr.OP == TK.COLLATE)
dup = Expr.AddCollateString(parse, dup, expr.u.Token);
// Before calling sqlite3ExprDelete(), set the EP_Static flag. This prevents ExprDelete() from deleting the Expr structure itself,
// allowing it to be repopulated by the memcpy() on the following line.
E.ExprSetProperty(expr, EP.Static);
Expr.Delete(ctx, ref expr);
expr.memcpy(dup);
if (!E.ExprHasProperty(expr, EP.IntValue) && expr.u.Token != null)
{
Debug.Assert((dup.Flags & (EP.Reduced | EP.TokenOnly)) == 0);
dup.u.Token = expr.u.Token;
dup.Flags2 |= EP2.MallocedToken;
}
C._tagfree(ctx, ref dup);
}
public ExprFieldAddress(Ctx ctx, Expr obj, FieldReference field)
: base(ctx) {
this.Obj = obj;
this.Field = field;
this.ElementType = field.FieldType.FullResolve(field);
this.type = this.ElementType.MakePointer();
}
public ForItemDownTo(string var, Expr from, Expr to, Expr by)
{
this.Var = var;
this.From = from;
this.To = to;
this.By = by;
}
/*
** The first parameter (pDef) is a function implementation. The
** second parameter (pExpr) is the first argument to this function.
** If pExpr is a column in a virtual table, then let the virtual
** table implementation have an opportunity to overload the function.
**
** This routine is used to allow virtual table implementations to
** overload MATCH, LIKE, GLOB, and REGEXP operators.
**
** Return either the pDef argument (indicating no change) or a
** new FuncDef structure that is marked as ephemeral using the
** SQLITE_FUNC_EPHEM flag.
*/
FuncDef *sqlite3VtabOverloadFunction(
sqlite3 *db, /* Database connection for reporting malloc problems */
FuncDef *pDef, /* Function to possibly overload */
int nArg, /* Number of arguments to the function */
Expr *pExpr /* First argument to the function */
)
{
Table *pTab;
sqlite3_vtab *pVtab;
sqlite3_module *pMod;
void (*xFunc)(sqlite3_context*,int,sqlite3_value**) = 0;
void *pArg = 0;
FuncDef *pNew;
int rc = 0;
char *zLowerName;
unsigned char *z;
/* Check to see the left operand is a column in a virtual table */
if( NEVER(pExpr==0) ) return pDef;
if( pExpr->op!=TK_COLUMN ) return pDef;
pTab = pExpr->pTab;
if( NEVER(pTab==0) ) return pDef;
if( (pTab->tabFlags & TF_Virtual)==0 ) return pDef;
pVtab = sqlite3GetVTable(db, pTab)->pVtab;
assert( pVtab!=0 );
assert( pVtab->pModule!=0 );
pMod = (sqlite3_module *)pVtab->pModule;
if( pMod->xFindFunction==0 ) return pDef;
/* Call the xFindFunction method on the virtual table implementation
** to see if the implementation wants to overload this function
*/
zLowerName = sqlite3DbStrDup(db, pDef->zName);
if( zLowerName ){
for(z=(unsigned char*)zLowerName; *z; z++){
*z = sqlite3UpperToLower[*z];
}
rc = pMod->xFindFunction(pVtab, nArg, zLowerName, &xFunc, &pArg);
sqlite3DbFree(db, zLowerName);
}
if( rc==0 ){
return pDef;
}
/* Create a new ephemeral function definition for the overloaded
** function */
pNew = sqlite3DbMallocZero(db, sizeof(*pNew)
+ sqlite3Strlen30(pDef->zName) + 1);
if( pNew==0 ){
return pDef;
}
*pNew = *pDef;
pNew->zName = (char *)&pNew[1];
memcpy(pNew->zName, pDef->zName, sqlite3Strlen30(pDef->zName)+1);
pNew->xFunc = xFunc;
pNew->pUserData = pArg;
pNew->flags |= SQLITE_FUNC_EPHEM;
return pNew;
}
/// <summary>
/// Initialize using values.
/// </summary>
/// <param name="varName">The name of the variable representing each item in the source</param>
/// <param name="source">The data source being queried</param>
/// <param name="filter">The filter to apply on the datasource</param>
/// <param name="sorts">The sorting to apply after filtering.</param>
public LinqExpr(string varName, Expr source, Expr filter, List<Expr> sorts)
{
this.Nodetype = "FSExtLinq";
_varName = varName;
_sorts = sorts;
_source = source;
_filter = filter;
}
/// <summary>
/// Initializes a new runtime error.
/// </summary>
/// <param name="culprit">The expression. Can not be null.</param>
/// <param name="thrownValue">The error value. Can not be null.</param>
public RuntimeError( Expr culprit, RuntimeObj thrownValue )
: base(culprit)
{
if( thrownValue == null ) throw new ArgumentNullException();
if( thrownValue is RefRuntimeObj ) throw new ArgumentException();
Message = "Runtime error.";
ThrownValue = thrownValue;
}
/// <summary>
/// Constructor for QuantifiedExpr.
/// </summary>
/// <param name="type">
/// Type (0 for SOME, 1 for ALL). </param>
/// <param name="varexp">
/// Expressions. </param>
/// <param name="ret">
/// Returned expression. </param>
public QuantifiedExpr(int type, ICollection <VarExprPair> varexp, Expr ret)
{
_type = type;
_var_expr_pairs = varexp;
_return = ret;
}
/// <summary>
/// Set next expression.
/// </summary>
/// <param name="e">
/// Expression. </param>
public virtual void set_expr(Expr e)
{
_return = e;
}
public string EvaluateToOutputForm(Expr exprObject, int pageWidth = 0)
{
CacheMisses++;
return(KernelLink.EvaluateToOutputForm(exprObject, pageWidth));
}
public void Should_properly_map_parameters()
{
Func <int, char, string, long, bool, string> formatMethod = Format;
var func = CreateFunc <int, char, string, long, bool, string>(Expr.Return(Expr.Call(
formatMethod.Method,
Expr.Parameter(0, typeof(int)),
Expr.Parameter(1, typeof(char)),
Expr.Parameter(2, typeof(string)),
Expr.Parameter(3, typeof(long)),
Expr.Parameter(4, typeof(bool)))));
Assert.That(func(1, 'a', "text", -23, false), Is.EqualTo("1_a_text_-23_False"));
}
public void Should_not_allow_parameter_type_not_matching_to_method_signature()
{
var ex = Assert.Throws <InvalidOperationException>(() => CreateFunc <object, int>(Expr.Return(Expr.Parameter(0, typeof(int)))));
Assert.That(ex.Message, Is.StringContaining("Parameter index 0 is of System.Int32 type, while type System.Object is expected"));
}
public abstract void Set(string nvar, Expr e);
public ContractRequiresInfo(Expr originalExpr, Expr rewrittenExpr)
{
this.OriginalExpr = originalExpr;
this.RewrittenExpr = rewrittenExpr;
}
private MathematicaPattern(MathematicaInterface parentCas, Expr mathExpr)
: base(parentCas, mathExpr)
{
}
// Parse a leaf node
// (For the moment this is just a number)
Expr ParseLeaf()
{
// Is it a number?
if (_tokenizer.Current.Token == Token.Number)
{
var node = Expr.Number(_tokenizer.Current.Number);
_tokenizer.MoveNext();
return(node);
}
// Bracket?
if (_tokenizer.Current.Token == Token.OpenBracket)
{
// array
// Skip '['
_tokenizer.MoveNext();
var elements = new List <Expr>();
while (true)
{
// Parse argument and add to list
elements.Add(ParseAddSubtract());
// Is there another argument?
if (_tokenizer.Current.Token == Token.Comma)
{
_tokenizer.MoveNext();
continue;
}
// Get out
break;
}
// Check and skip ')'
if (_tokenizer.Current.Token != Token.CloseBracket)
{
throw new SyntaxException("Missing close bracket");
}
_tokenizer.MoveNext();
return(Expr.FromArray(elements));
}
// Parenthesis?
if (_tokenizer.Current.Token == Token.OpenParens)
{
// Skip '('
_tokenizer.MoveNext();
// Parse a top-level expression
var node = ParseAddSubtract();
// Check and skip ')'
if (_tokenizer.Current.Token != Token.CloseParens)
{
throw new SyntaxException("Missing close parenthesis");
}
_tokenizer.MoveNext();
// Return
return(node);
}
// Variable
if (_tokenizer.Current.Token == Token.Identifier)
{
// Capture the name and skip it
var name = _tokenizer.Current.Identifier;
_tokenizer.MoveNext();
// Parens indicate a function call, otherwise just a variable
if (_tokenizer.Current.Token != Token.OpenParens)
{
return(Expr.VariableOrConst(name));
}
else
{
// Function call
// Skip parens
_tokenizer.MoveNext();
// Parse arguments
var arguments = new List <Expr>();
while (true)
{
// Parse argument and add to list
arguments.Add(ParseAddSubtract());
// Is there another argument?
if (_tokenizer.Current.Token == Token.Comma)
{
_tokenizer.MoveNext();
continue;
}
// Get out
break;
}
// Check and skip ')'
if (_tokenizer.Current.Token != Token.CloseParens)
{
throw new SyntaxException("Missing close parenthesis");
}
_tokenizer.MoveNext();
// Create the function call node
switch (arguments.Count)
{
case 1:
if (FindOperation(name, out UnaryOp uop))
{
return(Expr.Unary(uop, arguments[0]));
}
throw new ArgumentException($"Invalid unary function {name}");
case 2:
if (FindOperation(name, out BinaryOp bop))
{
return(Expr.Binary(bop, arguments[0], arguments[1]));
}
throw new ArgumentException($"Invalid binary function {name}");
default:
throw new SyntaxException("Invalid number of arguments");
}
}
}
// Don't Understand
throw new SyntaxException($"Unexpected token: {_tokenizer.Current.Token}");
}
public override object GetValor(Entorno e, LinkedList <Salida> log, LinkedList <Error> errores)
{
object valExpr = Expr.GetValor(e, log, errores);
if (valExpr != null)
{
if (valExpr is Throw)
{
return(valExpr);
}
if (InExpr == null)
{
Tipo = Expr.Tipo;
return(valExpr);
}
else
{
Tipo = new Tipo(Type.BOOLEAN);
foreach (Expresion exprActual in InExpr)
{
object valExprActual = exprActual.GetValor(e, log, errores);
if (valExprActual != null)
{
if (valExprActual is Throw)
{
return(valExprActual);
}
if (exprActual.Tipo.IsCollection())
{
Collection collection = (Collection)valExprActual;
if (Expr.Tipo.Equals(collection.Tipo.Valor))
{
foreach (CollectionValue value in collection.Valores)
{
if (valExpr.Equals(value.Valor))
{
return(true);
}
}
}
}
else
{
if (Expr.Tipo.Equals(exprActual.Tipo))
{
if (valExpr.Equals(valExprActual))
{
return(true);
}
}
}
}
}
return(false);
}
}
return(null);
}
public void ExpressionTypeTest()
{
Assert.That(Expr.Parameter(0, typeof(byte)).ExpressionType, Is.EqualTo(typeof(byte)));
}
public void Should_not_allow_parameter_index_being_outside_of_bounds()
{
var ex = Assert.Throws <InvalidOperationException>(() => CreateFunc <int, int>(Expr.Return(Expr.Parameter(1, typeof(int)))));
Assert.That(ex.Message, Is.StringContaining("Parameter index 1 is outside of bounds. Expected parameters: [System.Int32]"));
}
private void ParseWhere()
{
_tokenIt.ExpectIdText("where");
_filter = _parser.ParseExpression(_terminators, enablePlugins: true, passNewLine: false);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public void pushVariables(ExprAbstractEvaluationContext paramExprAbstractEvaluationContext, org.boris.expr.Expr[] paramArrayOfExpr) throws org.boris.expr.ExprException
public virtual void pushVariables(ExprAbstractEvaluationContext paramExprAbstractEvaluationContext, Expr[] paramArrayOfExpr)
{
bool @bool = false;
if (this.jsLanguage && this.engine == null)
{
@bool = true;
}
this.previousArgs.Clear();
sbyte b = 0;
foreach (FunctionArgumentTable functionArgumentTable in this.inputArguments)
{
if (paramExprAbstractEvaluationContext.hasAdditionalVariable(this.fTable.Name.ToUpper()))
{
this.previousArgs[functionArgumentTable.Name] = paramExprAbstractEvaluationContext.getAdditionalVariableValue(functionArgumentTable.Name);
}
paramExprAbstractEvaluationContext.addAdditionalVariable(functionArgumentTable.Name.ToUpper(), paramArrayOfExpr[b]);
if (this.jsLanguage)
{
if (paramArrayOfExpr[b] is ExprDouble)
{
Engine.put(functionArgumentTable.Name, Convert.ToDouble(((ExprDouble)paramArrayOfExpr[b]).doubleValue()));
}
else if (paramArrayOfExpr[b] is ExprInteger)
{
Engine.put(functionArgumentTable.Name, Convert.ToInt32(((ExprInteger)paramArrayOfExpr[b]).intValue()));
}
else if (paramArrayOfExpr[b] is ExprBoolean)
{
Engine.put(functionArgumentTable.Name, Convert.ToBoolean(((ExprBoolean)paramArrayOfExpr[b]).booleanValue()));
}
else if (paramArrayOfExpr[b] is ExprArray)
{
Engine.put(functionArgumentTable.Name, ExprArrayUtil.toObjectArray((ExprArray)paramArrayOfExpr[b]));
}
else
{
Engine.put(functionArgumentTable.Name, ((ExprString)paramArrayOfExpr[b]).str);
}
}
b++;
}
foreach (FunctionArgumentTable functionArgumentTable in this.constArguments)
{
if (paramExprAbstractEvaluationContext.hasAdditionalVariable(this.fTable.Name.ToUpper()))
{
this.previousArgs[functionArgumentTable.Name] = paramExprAbstractEvaluationContext.getAdditionalVariableValue(functionArgumentTable.Name);
}
Expr expr = evaluateConstant(paramExprAbstractEvaluationContext, functionArgumentTable);
paramExprAbstractEvaluationContext.addAdditionalVariable(functionArgumentTable.Name.ToUpper(), expr);
if (this.jsLanguage)
{
if (expr is ExprDouble)
{
Engine.put(functionArgumentTable.Name, Convert.ToDouble(((ExprDouble)expr).doubleValue()));
continue;
}
if (expr is ExprInteger)
{
Engine.put(functionArgumentTable.Name, Convert.ToInt32(((ExprInteger)expr).intValue()));
continue;
}
if (expr is ExprBoolean)
{
Engine.put(functionArgumentTable.Name, Convert.ToInt32(((ExprBoolean)expr).intValue()));
continue;
}
if (paramArrayOfExpr[b] is ExprArray)
{
Engine.put(functionArgumentTable.Name, ExprArrayUtil.toObjectArray((ExprArray)paramArrayOfExpr[b]));
continue;
}
Engine.put(functionArgumentTable.Name, ((ExprString)expr).str);
}
}
if (@bool)
{
string str = "function " + this.fTable.Name + "() {" + this.fTable.Implementation + "\n}";
try
{
Engine.eval(str);
}
catch (ScriptException scriptException)
{
string str1 = scriptException.Message;
if (scriptException.InnerException != null)
{
str1 = scriptException.InnerException.Message;
}
if (str1.IndexOf(":", StringComparison.Ordinal) != -1)
{
str1 = str1.Substring(str1.LastIndexOf(":", StringComparison.Ordinal));
}
throw new ExprException(str1);
}
catch (Exception exception)
{
throw new ExprException(exception.Message);
}
}
}
protected override void InitializeTargetObject()
{
base.InitializeTargetObject();
if (ContextID == null)
{
GoToMissingRecordPage();
}
Search s = new Search(msInvoice.CLASS_NAME);
s.AddCriteria(Expr.Equals("ID", ContextID));
s.AddOutputColumn("LocalID");
s.AddOutputColumn("Date");
s.AddOutputColumn("Total");
s.AddOutputColumn("BalanceDue");
s.AddOutputColumn("AmountPaid");
s.AddOutputColumn("Order");
s.AddOutputColumn("Order.Name");
s.AddOutputColumn("BillTo.Name");
s.AddOutputColumn("BillTo");
s.AddOutputColumn("BillingAddress");
s.AddOutputColumn("PurchaseOrderNumber");
var sr = APIExtensions.GetSearchResult(s, 0, 1);
if (sr.TotalRowCount == 0)
{
GoToMissingRecordPage();
}
targetInvoice = sr.Table.Rows[0];
if (string.IsNullOrWhiteSpace(LeaderOfId))
{
return;
}
var leaderOf = APIExtensions.LoadObjectFromAPI(LeaderOfId);
switch (leaderOf.ClassType)
{
case msChapter.CLASS_NAME:
targetChapter = leaderOf.ConvertTo <msChapter>();
break;
case msSection.CLASS_NAME:
targetSection = leaderOf.ConvertTo <msSection>();
break;
case msOrganizationalLayer.CLASS_NAME:
targetOrganizationalLayer = leaderOf.ConvertTo <msOrganizationalLayer>();
break;
default:
QueueBannerError(string.Format("Invalid leader object type specified '{0}'",
leaderOf.ClassType));
GoHome();
return;
}
}
[ContractVerification(false)] // F: Clousot ForAll decompilation gets confused below. Setting verification off until I fixed the bug
internal Quantifier(Context ctx, bool isForall, Sort[] sorts, Symbol[] names, Expr body, uint weight = 1, Pattern[] patterns = null, Expr[] noPatterns = null, Symbol quantifierID = null, Symbol skolemID = null)
: base(ctx, IntPtr.Zero)
{
Contract.Requires(ctx != null);
Contract.Requires(sorts != null);
Contract.Requires(names != null);
Contract.Requires(body != null);
Contract.Requires(sorts.Length == names.Length);
Contract.Requires(Contract.ForAll(sorts, s => s != null));
Contract.Requires(Contract.ForAll(names, n => n != null));
Contract.Requires(patterns == null || Contract.ForAll(patterns, p => p != null));
Contract.Requires(noPatterns == null || Contract.ForAll(noPatterns, np => np != null));
Context.CheckContextMatch <Pattern>(patterns);
Context.CheckContextMatch <Expr>(noPatterns);
Context.CheckContextMatch <Sort>(sorts);
Context.CheckContextMatch <Symbol>(names);
Context.CheckContextMatch(body);
if (sorts.Length != names.Length)
{
throw new Z3Exception("Number of sorts does not match number of names");
}
if (noPatterns == null && quantifierID == null && skolemID == null)
{
NativeObject = Native.Z3_mk_quantifier(ctx.nCtx, (isForall) ? 1 : 0, weight,
AST.ArrayLength(patterns), AST.ArrayToNative(patterns),
AST.ArrayLength(sorts), AST.ArrayToNative(sorts),
Symbol.ArrayToNative(names),
body.NativeObject);
}
else
{
NativeObject = Native.Z3_mk_quantifier_ex(ctx.nCtx, (isForall) ? 1 : 0, weight,
AST.GetNativeObject(quantifierID), AST.GetNativeObject(skolemID),
AST.ArrayLength(patterns), AST.ArrayToNative(patterns),
AST.ArrayLength(noPatterns), AST.ArrayToNative(noPatterns),
AST.ArrayLength(sorts), AST.ArrayToNative(sorts),
Symbol.ArrayToNative(names),
body.NativeObject);
}
}
public void Should_properly_map_parameters_with_this()
{
MethodInfo mi = typeof(DerivedType).GetMethod("Call");
var func = CreateFunc <DerivedType, int, DerivedType>(Expr.Return(Expr.Call(Expr.Parameter(0, typeof(DerivedType)), mi, Expr.Parameter(1, typeof(int)))));
var obj = func(new DerivedType(), 32);
Assert.That(obj.X, Is.EqualTo(32));
}
public Image EvaluateToImage(Expr exprObject, int width = 0, int height = 0)
{
CacheMisses++;
return(KernelLink.EvaluateToImage(exprObject, width, height));
}
public void Should_not_allow_parameter_type_be_implicitly_boxed()
{
var ex = Assert.Throws <InvalidOperationException>(() => CreateFunc <int, int>(Expr.Return(Expr.Convert(Expr.Parameter(0, typeof(object)), typeof(int)))));
Assert.That(ex.Message, Is.StringContaining("Parameter index 0 is of System.Object type, while type System.Int32 is expected"));
}
public Image EvaluateToTypeset(Expr exprObject, int width = 0)
{
CacheMisses++;
return(KernelLink.EvaluateToTypeset(exprObject, width));
}
public void Should_not_allow_null_type()
{
Assert.Throws <ArgumentNullException>(() => Expr.Parameter(0, null));
}
public TrafficNetworkModel
(int numberOfNodes,
int source_idx,
int sink_idx,
int[] arc_i,
int[] arc_j,
double[] arcSensitivity,
double[] arcCapacity,
double[] arcBaseTravelTime,
double T) : base("Traffic Network")
{
bool finished = false;
try
{
int n = numberOfNodes;
int narcs = arc_j.Length;
double[] n_ones = new double[narcs]; for (int i = 0; i < narcs; ++i)
{
n_ones[i] = 1.0;
}
Set NxN = Set.Make(n, n);
Matrix sens =
Matrix.Sparse(n, n, arc_i, arc_j, arcSensitivity);
Matrix cap =
Matrix.Sparse(n, n, arc_i, arc_j, arcCapacity);
Matrix basetime =
Matrix.Sparse(n, n, arc_i, arc_j, arcBaseTravelTime);
Matrix e =
Matrix.Sparse(n, n, arc_i, arc_j, n_ones);
Matrix e_e =
Matrix.Sparse(n, n,
new int[] { sink_idx }, new int[] { source_idx },
new double[] { 1.0 });
double[] cs_inv = new double[narcs];
double[] s_inv = new double[narcs];
for (int i = 0; i < narcs; ++i)
{
cs_inv[i] = 1.0 / (arcSensitivity[i] * arcCapacity[i]);
}
for (int i = 0; i < narcs; ++i)
{
s_inv[i] = 1.0 / arcSensitivity[i];
}
Matrix cs_inv_matrix = Matrix.Sparse(n, n, arc_i, arc_j, cs_inv);
Matrix s_inv_matrix = Matrix.Sparse(n, n, arc_i, arc_j, s_inv);
flow = Variable("traffic_flow", NxN, Domain.GreaterThan(0.0));
Variable x = flow;
Variable t = Variable("travel_time", NxN, Domain.GreaterThan(0.0));
Variable d = Variable("d", NxN, Domain.GreaterThan(0.0));
Variable z = Variable("z", NxN, Domain.GreaterThan(0.0));
// Set the objective:
Objective("Average travel time", ObjectiveSense.Minimize,
Expr.Mul(1.0 / T, Expr.Add(Expr.Dot(basetime, x), Expr.Dot(e, d))));
// Set up constraints
// Constraint (1a)
{
Variable[][] v = new Variable[narcs][];
for (int i = 0; i < narcs; ++i)
{
v[i] = new Variable[3] {
d.Index(arc_i[i], arc_j[i]),
z.Index(arc_i[i], arc_j[i]),
x.Index(arc_i[i], arc_j[i])
};
}
Constraint("(1a)", mosek.fusion.Var.Stack(v), Domain.InRotatedQCone(narcs, 3));
}
// Constraint (1b)
//
Constraint("(1b)",
Expr.Sub(Expr.Add(Expr.MulElm(z, e),
Expr.MulElm(x, cs_inv_matrix)),
s_inv_matrix),
Domain.EqualsTo(0.0));
// Constraint (2)
Constraint("(2)", Expr.Sub(Expr.Add(Expr.MulDiag(x, e.Transpose()),
Expr.MulDiag(x, e_e.Transpose())),
Expr.Add(Expr.MulDiag(x.Transpose(), e),
Expr.MulDiag(x.Transpose(), e_e))),
Domain.EqualsTo(0.0));
// Constraint (3)
Constraint("(3)", x.Index(sink_idx, source_idx), Domain.EqualsTo(T));
finished = true;
}
finally
{
if (!finished)
{
Dispose();
}
}
}
protected MathematicaExpression(MathematicaInterface parentCas, Expr mathExpr)
{
CasInterface = parentCas;
ExpressionId = GetNewExprId();
Expression = mathExpr;
}
public CalcPosts(PostHandler handler, Expr amountExpr, bool calcRunningTotal = false)
: base(handler)
{
AmountExpr = amountExpr;
CalcRunningTotal = calcRunningTotal;
}
public static MathematicaExpression Create(MathematicaInterface parentCas, Expr mathExpr)
{
return(new MathematicaExpression(parentCas, mathExpr));
}
private Stmt ParseStmt()
{
Stmt resultado;
if (this.indice == this.tokens.Count)
{
throw new System.Exception("se esperaban sentencias, se llego al final del archivo");
}
// <stmt> := print <expr>
// <expr> := <string>
// | <int>
// | <arith_expr>
// | <ident>
if (this.tokens[this.indice].Equals("print"))
{
this.indice++;
Print print = new Print();
print.Expr = this.ParseExpr();
resultado = print;
}
else if (this.tokens[this.indice].Equals("var"))
{
this.indice++;
DeclareVar declareVar = new DeclareVar();
if (this.indice < this.tokens.Count &&
this.tokens[this.indice] is string)
{
declareVar.Ident = (string)this.tokens[this.indice];
}
else
{
throw new System.Exception("Se esperaba nombre de variable despues de 'var'");
}
this.indice++;
if (this.indice == this.tokens.Count ||
this.tokens[this.indice] != Scanner.Igual)
{
throw new System.Exception("se esperaba = despues de 'var ident'");
}
this.indice++;
declareVar.Expr = this.ParseExpr();
resultado = declareVar;
}
else if (this.tokens[this.indice].Equals("read_int"))
{
this.indice++;
ReadInt readInt = new ReadInt();
if (this.indice < this.tokens.Count &&
this.tokens[this.indice] is string)
{
readInt.Ident = (string)this.tokens[this.indice++];
resultado = readInt;
}
else
{
throw new System.Exception("Se esperaba el nombre de la variable 'read_int'");
}
}
//*******************
else if (this.tokens[this.indice].Equals("if"))
{
this.indice++;
mcIf mcif = new mcIf();
Expr temp = ParseExpr();
if (this.tokens[this.indice] == Scanner.Eq || this.tokens[this.indice] == Scanner.Neq ||
this.tokens[this.indice] == Scanner.Gt || this.tokens[this.indice] == Scanner.Gte ||
this.tokens[this.indice] == Scanner.Lt || this.tokens[this.indice] == Scanner.Lte)
{
CompExpr compExpr = new CompExpr();
compExpr.Left = temp;
object op = this.tokens[this.indice++];
if (op == Scanner.Eq)
{
compExpr.Op = CompOp.Eq;
}
else if (op == Scanner.Neq)
{
compExpr.Op = CompOp.Neq;
}
else if (op == Scanner.Gt)
{
compExpr.Op = CompOp.Gt;
}
else if (op == Scanner.Gte)
{
compExpr.Op = CompOp.Gte;
}
else if (op == Scanner.Lt)
{
compExpr.Op = CompOp.Lt;
}
else if (op == Scanner.Lte)
{
compExpr.Op = CompOp.Lte;
}
compExpr.Rigth = ParseExpr();
temp = compExpr;
}
mcif.compExpr = temp;
if (this.indice == this.tokens.Count || !this.tokens[this.indice].Equals("then"))
{
throw new System.Exception("Se esperaba el identificador 'then' despues de 'if'");
}
this.indice++;
mcif.Then = ParseStmt();
if (this.tokens[this.indice].Equals("else"))
{
this.indice++;
mcif.Else = ParseStmt();
}
resultado = mcif;
if (this.indice == this.tokens.Count ||
!this.tokens[this.indice].Equals("end"))
{
throw new System.Exception("Sentencia if inconclusa");
}
this.indice++;
}
else if (this.tokens[this.indice].Equals("while"))
{
this.indice++;
WhileLoop whileLoop = new WhileLoop();
Expr temp = ParseExpr();
if (this.tokens[this.indice] == Scanner.Eq || this.tokens[this.indice] == Scanner.Neq ||
this.tokens[this.indice] == Scanner.Gt || this.tokens[this.indice] == Scanner.Gte ||
this.tokens[this.indice] == Scanner.Lt || this.tokens[this.indice] == Scanner.Lte)
{
CompExpr compExpr = new CompExpr();
compExpr.Left = temp;
object op = this.tokens[this.indice++];
if (op == Scanner.Eq)
{
compExpr.Op = CompOp.Eq;
}
else if (op == Scanner.Neq)
{
compExpr.Op = CompOp.Neq;
}
else if (op == Scanner.Gt)
{
compExpr.Op = CompOp.Gt;
}
else if (op == Scanner.Gte)
{
compExpr.Op = CompOp.Gte;
}
else if (op == Scanner.Lt)
{
compExpr.Op = CompOp.Lt;
}
else if (op == Scanner.Lte)
{
compExpr.Op = CompOp.Lte;
}
compExpr.Rigth = ParseExpr();
temp = compExpr;
}
whileLoop.Cond = temp;
if (this.indice == this.tokens.Count || !this.tokens[this.indice].Equals("do"))
{
throw new System.Exception("Se esperaba el identificador 'do' despues de 'while'");
}
this.indice++;
whileLoop.Body = ParseStmt();
resultado = whileLoop;
if (this.indice == this.tokens.Count ||
!this.tokens[this.indice].Equals("end"))
{
throw new System.Exception("sentencia while inconclusa");
}
this.indice++;
}
//*******************
else if (this.tokens[this.indice].Equals("for"))
{
this.indice++;
ForLoop forLoop = new ForLoop();
if (this.indice < this.tokens.Count &&
this.tokens[this.indice] is string)
{
forLoop.Ident = (string)this.tokens[this.indice];
}
else
{
throw new System.Exception("se esperaba un indentificador despues de 'for'");
}
this.indice++;
if (this.indice == this.tokens.Count ||
this.tokens[this.indice] != Scanner.Igual)
{
throw new System.Exception("no se encontro en la sentencia for '='");
}
this.indice++;
forLoop.From = this.ParseExpr();
if (this.indice == this.tokens.Count ||
!this.tokens[this.indice].Equals("to"))
{
throw new System.Exception("se epsaraba 'to' despues de for");
}
this.indice++;
forLoop.To = this.ParseExpr();
if (this.indice == this.tokens.Count ||
!this.tokens[this.indice].Equals("do"))
{
throw new System.Exception("se esperaba 'do' despues de la expresion en el ciclo for");
}
this.indice++;
forLoop.Body = this.ParseStmt();
resultado = forLoop;
if (this.indice == this.tokens.Count ||
!this.tokens[this.indice].Equals("end"))
{
throw new System.Exception("setencia for inconclusa");
}
this.indice++;
}
else if (this.tokens[this.indice] is string)
{
// assignment
Assign assign = new Assign();
assign.Ident = (string)this.tokens[this.indice++];
if (this.indice == this.tokens.Count ||
this.tokens[this.indice] != Scanner.Igual)
{
throw new System.Exception("se esperaba '='");
}
this.indice++;
assign.Expr = this.ParseExpr();
resultado = assign;
}
else
{
throw new System.Exception("Error en el token " + this.indice + ": " + this.tokens[this.indice]);
}
if (this.indice < this.tokens.Count && this.tokens[this.indice] == Scanner.PyC)
{
this.indice++;
if (this.indice < this.tokens.Count &&
!this.tokens[this.indice].Equals("end") && !this.tokens[this.indice].Equals("else"))
{
Sequence sequence = new Sequence();
sequence.First = resultado;
sequence.Second = this.ParseStmt();
resultado = sequence;
}
}
return(resultado);
}
private ExprResult FinishCall(Expr expr) => from args in Arguments().ToList().ToResult() from rParen in Consume(TokenType.RightParen, "Expected ')'.") select new CallExpr(expr, rParen, args) as Expr;
private List <Block> CreateAssertsBlocks(Implementation queryImplementation, Implementation targetImplementation, List <Tuple <Variable, Expr, Expr> > assumeVars)
{
var exprs = CreateAssertsExprs(queryImplementation, targetImplementation);
var assertsCmds = CreateAsserts(exprs);
queryImplementation.InParams.Iter(iq =>
{
targetImplementation.InParams.Iter(it =>
{
if (Equals(iq.TypedIdent.Type, it.TypedIdent.Type))
{
var eqVar = new LocalVariable(Token.NoToken, new TypedIdent(Token.NoToken, AssumeVarPrefix + "_" + _eqVarsCounter++, BType.Bool));
assumeVars.Add(new Tuple <Variable, Expr, Expr>(eqVar, Expr.Ident(iq), Expr.Ident(it)));
queryImplementation.Blocks[0].Cmds.Insert(0, Utils.BoogieUtils.CreateAssignCmd(new List <IdentifierExpr>()
{
Expr.Ident(eqVar)
}, new List <Expr>()
{
Expr.Eq(Expr.Ident(iq), Expr.Ident(it))
}));
}
});
});
// The equality vars are grouped according to lhs. This means that expressions like eq_0 = `rax == v2.rcx` and eq_13 = `rax == v2.p0` will be
// grouped together, to make the assumes choosing algorithm more efficient (we won't select eq_0 and eq_13 for the same section)
var eqVarsGroups = new Dictionary <string, List <Tuple <Variable, Expr, Expr> > >();
assumeVars.Iter(t =>
{
var lhs = t.Item2.ToString();
if (!eqVarsGroups.ContainsKey(lhs))
{
eqVarsGroups[lhs] = new List <Tuple <Variable, Expr, Expr> >();
}
eqVarsGroups[lhs].Add(t);
});
assumeVars.Iter(t => queryImplementation.LocVars.Add(t.Item1));
return(CreateAssertsWithAssumes(eqVarsGroups.Values.ToList(), assertsCmds));
}
public static List <string> GetEntitiesEligibleForGroupRegistration(msEvent targetEvent, msEntity currentEntity, IConciergeAPIService api)
{
if (targetEvent == null)
{
throw new ArgumentNullException("targetEvent");
}
if (api == null)
{
throw new ArgumentNullException("api");
}
List <string> applicableRelationshipTypes = targetEvent.SafeGetValue <List <string> >("GroupRegistrationRelationshipTypes");
if (applicableRelationshipTypes == null || applicableRelationshipTypes.Count == 0)
{
return(null); // there are no registration types enabled
}
if (currentEntity == null)
{
return(null);
}
List <string> entities = new List <string>();
if (currentEntity.ClassType == msOrganization.CLASS_NAME) // an organization can always manage themselves
{
entities.Add(currentEntity.ID);
return(entities);
}
// OK, let's see if this person is linked to any companies
Search s = new Search("RelationshipsForARecord");
s.Context = currentEntity.ID;
s.AddCriteria(Expr.Equals("IsLeftSide", false)); // the right side of the relationship is the individual
// MSIV-5 Indivdiuals with expired relationships should not be eligible for Event Group Registration
var sog1 = new SearchOperationGroup {
GroupType = SearchOperationGroupType.Or
};
sog1.Criteria.Add(Expr.Equals(msRelationship.FIELDS.StartDate, null));
sog1.Criteria.Add(Expr.IsLessThanOrEqual(msRelationship.FIELDS.StartDate, DateTime.Today.Date));
s.AddCriteria(sog1);
var sog2 = new SearchOperationGroup {
GroupType = SearchOperationGroupType.Or
};
sog2.Criteria.Add(Expr.Equals(msRelationship.FIELDS.EndDate, null));
sog2.Criteria.Add(Expr.IsGreaterThan(msRelationship.FIELDS.EndDate, DateTime.Today.Date));
s.AddCriteria(sog2);
// now, we do an is one of the follow for relationship types
IsOneOfTheFollowing isTypes = new IsOneOfTheFollowing {
FieldName = "Type_ID"
};
isTypes.ValuesToOperateOn = new List <object>(applicableRelationshipTypes);
s.AddCriteria(isTypes);
s.AddOutputColumn("Target_ID");
var values = api.GetSearchResult(s, 0, null).Table;
foreach (DataRow dr in values.Rows)
{
entities.Add(Convert.ToString(dr["Target_ID"]));
}
// keep in mind we may have orphaned relationships, so we have to make sure each org ID exists!
return(entities.Distinct().ToList());
}
public TupleLiteralElement Clone(CloneContext clonectx)
{
return(new TupleLiteralElement(Name, Expr.Clone(clonectx), Location));
}