public Operation(OpType type, int row, int column, QuadValue direction = QuadValue.Left | QuadValue.Right | QuadValue.Up | QuadValue.Down)
{
_type = type;
_row = row;
_column = column;
_direction = direction;
}
// <summary>
// Is the given op one of the ConstantBaseOp-s
// </summary>
internal static bool IsConstantBaseOp(OpType opType)
{
return opType == OpType.Constant ||
opType == OpType.InternalConstant ||
opType == OpType.Null ||
opType == OpType.NullSentinel;
}
// should form a binary tree, can't have more than 2 children
public MathNode(UberNode parent, string scriptInput, OpType opType)
: base(parent, scriptInput)
{
Children.Add(null);
Children.Add(null);
OpTypeVal = opType;
}
protected override void OnCreate(Bundle bundle)
{
base.OnCreate (bundle);
rssUtil.bgndWorker.RunWorkerCompleted += (sender, e) =>
{
//todo clear list
listViewRSS.Adapter = new ArrayAdapter<string> (this, Android.Resource.Layout.SimpleListItem1,
rssUtil.RssFeeds.Select(x=>x.Title).ToArray());
SetProgressBarIndeterminateVisibility (false);
opType = OpType.Feeds;
};
RequestWindowFeature (WindowFeatures.ActionBar);
RequestWindowFeature (WindowFeatures.Progress);
RequestWindowFeature (WindowFeatures.IndeterminateProgress);
SetProgressBarIndeterminate (true);
SetProgressBarIndeterminateVisibility (true);
ActionBar.NavigationMode = ActionBarNavigationMode.Tabs;
ActionBar.Title = "Eyegregator";
ActionBar.SetDisplayShowTitleEnabled (true);
CreateDB ();
SetContentView (Resource.Layout.Main);
listViewRSS = (ListView)FindViewById (Resource.Id.listView);
listViewRSS.Clickable = true;
}
protected static void Assert(bool condition, string format, OpType op, object arg1, object arg2)
{
if (!condition)
{
Debug.Assert(false, String.Format(CultureInfo.InvariantCulture, format, Dump.AutoString.ToString(op), arg1, arg2));
}
}
internal SetOp(OpType opType, VarVec outputs, VarMap left, VarMap right)
: this(opType)
{
m_varMap = new VarMap[2];
m_varMap[0] = left;
m_varMap[1] = right;
m_outputVars = outputs;
}
private readonly List<RelProperty> m_relProperties; // list of relationship properties for which we have values
#endregion
#region constructors
internal NewEntityBaseOp(OpType opType, TypeUsage type, bool scoped, EntitySet entitySet, List<RelProperty> relProperties)
: base(opType, type)
{
Debug.Assert(scoped || entitySet == null, "entitySet cann't be set of constructor isn't scoped");
DebugCheck.NotNull(relProperties);
m_scoped = scoped;
m_entitySet = entitySet;
m_relProperties = relProperties;
}
/// <summary>
/// Basic constructor
/// </summary>
/// <param name="opType">The OpType we're interested in processing</param>
/// <param name="nodeProcessDelegate">The callback to invoke</param>
protected Rule(OpType opType, ProcessNodeDelegate nodeProcessDelegate)
{
Debug.Assert(nodeProcessDelegate != null, "null process delegate");
Debug.Assert(opType != OpType.NotValid, "bad OpType");
Debug.Assert(opType != OpType.Leaf, "bad OpType - Leaf");
m_opType = opType;
m_nodeDelegate = nodeProcessDelegate;
}
internal NestBaseOp(
OpType opType, List<SortKey> prefixSortKeys,
VarVec outputVars,
List<CollectionInfo> collectionInfoList)
: base(opType)
{
m_outputs = outputVars;
m_collectionInfoList = collectionInfoList;
m_prefixSortKeys = prefixSortKeys;
}
public ScreenEdit(t_Screen t_Scr, OpType moptype)
{
InitializeComponent();
Scree = t_Scr;
if (moptype == OpType.Alert)
{
txtName.Text = t_Scr.ScreenName;
txtImage.Text = t_Scr.ImageURL;
}
optype = moptype;
BindSite();
}
public TP_ButtonSetPropertyEdit(TP_ButtonSetProperty _BaseWindow,OpType mopType)
{
InitializeComponent();
_OpType = mopType;
_ContentX = _BaseWindow;
InitProperty();
if (mopType == OpType.Alert)
{
OpItem = (ScreenAddShowName)_ContentX.gvList.SelectedItem;
txtShowName.Text = OpItem.ScreenShowName;
cbScreenList.SelectedItem = OpItem.Screen;
}
}
public List<Polygon> Clip(Polygon p1, Polygon p2, OpType operation)
{
List<IntPoint> pol1 = new List<IntPoint>();
List<IntPoint> pol2 = new List<IntPoint>();
List<List<IntPoint>> res = new List<List<IntPoint>>();
foreach (Point point in p1.Points) {
pol1.Add(new IntPoint(point.X, point.Y));
}
foreach (Point point in p2.Points) {
pol2.Add(new IntPoint(point.X, point.Y));
}
Clipper clipper = new Clipper();
clipper.AddPolygon(pol1, PolyType.ptSubject);
clipper.AddPolygon(pol2, PolyType.ptClip);
switch (operation) {
case OpType.Difference:
clipper.Execute(ClipType.ctDifference, res);
break;
case OpType.Intersection:
clipper.Execute(ClipType.ctIntersection, res);
break;
case OpType.Union:
clipper.Execute(ClipType.ctUnion, res);
break;
case OpType.Xor:
clipper.Execute(ClipType.ctXor, res);
break;
}
List<Polygon> ret = new List<Polygon>();
foreach (var poly in res) {
Polygon pol = new Polygon() { Points = new List<Point>() };
foreach (var poi in poly) {
pol.Points.Add(new Point() { X = poi.X, Y = poi.Y });
}
ret.Add(pol);
}
return ret;
}
//ScreenEdit _mw)
public ScreenViewModel(t_Screen _mScreen, OpType mType, ScreenEdit mWindow)
{
OperationType = mType;
if (mType == OpType.Add)
{
_ParentScreen = _mScreen;
ScreenObj = new t_Screen();
_ScreenObj = new t_Screen();
}
else
{
ScreenObj = new t_Screen();
ScreenObj.Clone(_mScreen);
_ScreenObj = _mScreen;
}
_Window = mWindow;
//UpdatetxtSource(_Window.gridContent);
Init();
}
public bool leftasso = true; //is the operator left associative? most are, so save some lines w/ default value
public OpToken(OpType type)
{
this.type = type;
switch (type)
{
case OpType.ADD:
precedence = 0;
break;
case OpType.SUB:
precedence = 0;
break;
case OpType.MUL:
precedence = 1;
break;
case OpType.DIV:
precedence = 1;
break;
case OpType.MOD:
precedence = 1;
break;
case OpType.LP:
precedence = -999999; //these will be handled specially
break;
case OpType.RP:
precedence = -999999; //these will be handled specially
break;
case OpType.EXP:
precedence = 2;
leftasso = false;
break;
case OpType.LSHIFT:
precedence = -1;
length = 2;
break;
case OpType.RSHIFT:
precedence = -1;
length = 2;
break;
}
}
public static string GetName (OpType ot)
{
return names [(int) ot] [0];
}
/// <summary>
/// Basic constructor.
/// </summary>
/// <param name="opType">kind of Op</param>
internal RelOp(OpType opType) : base(opType)
{
}
private static bool CheckEntry(OpType opType, PlanCompilerPhase phase)
{
var hash = ComputeHash(opType, phase);
return(s_ValidOpTypes.IsSet(hash));
}
protected ConstantBaseOp(OpType opType, TypeUsage type, object value)
: base(opType, type)
{
m_value = value;
}
/// <summary>
/// Default constructor
/// </summary>
/// <param name="opType">kind of Op</param>
internal RulePatternOp(OpType opType) : base(opType)
{
}
internal static OpInfo parseOperand(string val, OpType allowedTypesFlag, int paramNo, Log log)
{
//lets try and resolve any aliases
OpInfo opInfo;
if (ISA_DATA.sRegAliases.TryGetValue(val, out opInfo))
{
if (!allowedTypesFlag.HasFlag(opInfo.flags))
{
log.Error("The dataType '{0}' is not allowed for param #{1}.", paramNo, opInfo.flags, paramNo);
}
return(opInfo);
}
Match m = Regex.Match(val, RegexRecognizers.Operand);
if (!m.Groups[2].Success)
{
log.Error("param {0}: unable to recognize operand '{1}'", paramNo, val);
return(opInfo);
}
char opType = m.Groups[1].Value[0];
string opVal = m.Groups[2].Value;
if (opVal == "")
{
log.Error("param {0}: compiler error 4359 '{1}'", paramNo, val);
}
switch (opType)
{
case 's': //scalier register
opInfo.reg = opInfo.value = UInt32.Parse(opVal);
opInfo.flags = ISA_DATA.GetFlagsFromRegNum(opInfo.value, log);
if (opInfo.reg > 255)
{
log.Error("param {0}: unable to use scalier greater then 255.", paramNo);
}
break;
case 'v': //vector register
//uint v_offset = allowedTypesFlag.HasFlag(OpType.SCALAR_DST) ? (uint)256 : 0;
opInfo.reg = opInfo.value = 256 + UInt32.Parse(opVal);
opInfo.flags = OpType.VGPR;
if (opInfo.reg > (256 + 255))
{
log.Error("param {0}: unable to use vector greater then 255.", paramNo);
}
break;
case 'x': //hex value
case 'o': //hex value
case 'b': //hex value
uint hexVal = Convert.ToUInt32(opVal, (opType == 'x') ? 16 : (opType == 'o') ? 8 : 2);
opInfo.value = hexVal;
opInfo.reg = ConvertIntToRegNum((int)hexVal);
if (opInfo.reg == 255) // LITERAL
{
opInfo.flags = OpType.LITERAL;
}
else if (hexVal > 0)
{
opInfo.flags = OpType.INLINE_INT_POS;
}
else if (hexVal == 0)
{
opInfo.flags = OpType.ZERO;
}
else // (val < 0)
{
opInfo.flags = OpType.INLINE_INT_NEG;
}
opInfo.dataDisc = DataDesc.HEX_FORMAT;
break;
case '0':
case '1':
case '2':
case '3':
case '4': //simple number or exponent
case '5':
case '6':
case '7':
case '8':
case '9':
int decVal = 0;
if (!Int32.TryParse(opVal, NumberStyles.AllowLeadingSign | NumberStyles.AllowExponent, CultureInfo.CurrentCulture, out decVal))
{
log.Error("param {0}: unable to convert {1} to an int. It could be out of range.", paramNo, opVal);
decVal = 0;
break;
}
opInfo.reg = ConvertIntToRegNum(decVal);
if (opInfo.reg == 255) // LITERAL
{
opInfo.flags = OpType.LITERAL;
opInfo.dataDisc = (decVal > 0) ? DataDesc.POS_INT : DataDesc.NEG_INT;
opInfo.value = BitConverter.ToUInt32(BitConverter.GetBytes(decVal), 0);
}
else if (decVal > 0)
{
opInfo.dataDisc = DataDesc.POS_INT;
opInfo.flags = OpType.INLINE_INT_POS;
}
else if (decVal == 0)
{
opInfo.dataDisc = DataDesc.ZERO_INT;
opInfo.flags = OpType.ZERO;
}
else // (lit < 0)
{
opInfo.dataDisc = DataDesc.NEG_INT;
opInfo.flags = OpType.INLINE_INT_NEG;
}
break;
case '.': //float value - The below should only be hit if not found in sRegAliases... like 0.000 or -.5
float temp = float.Parse(opVal, NumberStyles.Float);
if (temp == 0.0)
{
opInfo.reg = 240; opInfo.flags = OpType.ZERO; opInfo.dataDisc = DataDesc.ZERO_FLOAT;
}
else if (temp == 0.5)
{
opInfo.reg = 240; opInfo.flags = OpType.INLINE_FLOAT_POS; opInfo.dataDisc = DataDesc.POS_FLOAT;
}
else if (temp == -0.5)
{
opInfo.reg = 241; opInfo.flags = OpType.INLINE_FLOAT_NEG; opInfo.dataDisc = DataDesc.NEG_FLOAT;
}
else if (temp == 1.0)
{
opInfo.reg = 242; opInfo.flags = OpType.INLINE_FLOAT_POS; opInfo.dataDisc = DataDesc.POS_FLOAT;
}
else if (temp == -1.0)
{
opInfo.reg = 243; opInfo.flags = OpType.INLINE_FLOAT_NEG; opInfo.dataDisc = DataDesc.NEG_FLOAT;
}
else if (temp == 2.0)
{
opInfo.reg = 244; opInfo.flags = OpType.INLINE_FLOAT_POS; opInfo.dataDisc = DataDesc.POS_FLOAT;
}
else if (temp == -2.0)
{
opInfo.reg = 245; opInfo.flags = OpType.INLINE_FLOAT_NEG; opInfo.dataDisc = DataDesc.NEG_FLOAT;
}
else if (temp == 4.0)
{
opInfo.reg = 246; opInfo.flags = OpType.INLINE_FLOAT_POS; opInfo.dataDisc = DataDesc.POS_FLOAT;
}
else if (temp == -4.0)
{
opInfo.reg = 247; opInfo.flags = OpType.INLINE_FLOAT_NEG; opInfo.dataDisc = DataDesc.NEG_FLOAT;
}
else
{
opInfo.reg = 255;
opInfo.flags = OpType.LITERAL;
opInfo.dataDisc = (opVal[0] == '-') ? DataDesc.NEG_FLOAT : DataDesc.POS_FLOAT;
opInfo.value = BitConverter.ToUInt32(BitConverter.GetBytes(temp), 0);
}
break;
//case '@': // label //removed: we replace labels with literals before parsing. Depends on the distance I guess.
// labels[opVal].AddOccurrence(line);
// opInfo.dataDisc = DataDesc.LABEL_NAME;
// break;
default: log.Error("param {0}: unable to decode operand '{1}'", paramNo, val); break;
}
if (!allowedTypesFlag.HasFlag(opInfo.flags))
{
log.Error("param {0}: '{1}' is not in the allowed list of '{2}'", paramNo, opInfo.flags, allowedTypesFlag);
}
return(opInfo);
}
public Op(OpType type, int ind = -1)
{
this.type = type;
this.ind = ind;
}
public override void PreWrite(OpType operation)
{
if (key)
{
switch (operation)
{
case OpType.OpKey:
key = false;
Current(operation);
needComma = false;
break;
case OpType.ObjEnd:
ReturnToPrevious(operation);
break;
default:
InvalidState(operation);
break;
}
}
else
{
switch (operation)
{
case OpType.OpValue:
key = true;
needComma = true;
break;
case OpType.OpCast:
// nothing to do
break;
default:
base.PreWrite(operation);
// wrote a value, look for a key again
key = true;
needComma = true;
break;
}
}
}
private static int ComputeHash(OpType opType, PlanCompilerPhase phase)
{
var hash = ((int)opType * (int)PlanCompilerPhase.MaxMarker) + (int)phase;
return hash;
}
private double PerformOp(double lastValue, OpType currentOp, double currentValue)
{
throw new NotImplementedException();
}
private int CompareOpPrecedence(OpType newOp, OpType currentOp)
{
throw new NotImplementedException();
}
public BinOpNode(ExprNode left, ExprNode right, OpType op)
{
Op = op;
ExprChildren.Add(left);
ExprChildren.Add(right);
}
// <summary>
// Determines whether an applyNode can be rewritten into a projection with a scalar subquery.
// It can be done if all of the following conditions hold:
// 1. The right child or the apply has only one output
// 2. The right child of the apply produces at most one row
// 3. The right child of the apply produces at least one row, or the Apply operator in question is an OuterApply
// </summary>
private static bool CanRewriteApply(Node rightChild, ExtendedNodeInfo applyRightChildNodeInfo, OpType applyKind)
{
//Check whether it produces only one definition
if (applyRightChildNodeInfo.Definitions.Count != 1)
{
return(false);
}
//Check whether it produces at most one row
if (applyRightChildNodeInfo.MaxRows
!= RowCount.One)
{
return(false);
}
//For cross apply it must also return exactly one row
if (applyKind == OpType.CrossApply &&
(applyRightChildNodeInfo.MinRows != RowCount.One))
{
return(false);
}
//Dev10 #488632: Make sure the right child not only declares to produce only one definition,
// but has exactly one output. For example, ScanTableOp really outputs all the columns from the table,
// but in its ExtendedNodeInfo.Definitions only these that are referenced are shown.
// This is to allow for projection pruning of the unreferenced columns.
if (OutputCountVisitor.CountOutputs(rightChild) != 1)
{
return(false);
}
return(true);
}
public void Schedule(OpType opType, ActorInfo currentActor = null)
{
if (currentActor == null)
{
currentActor = GetCurrentActorInfo();
}
if (CheckTerminated(opType))
{
return;
}
currentActor.currentOp = opType;
ActorInfo nextActor = scheduler.GetNext(actorList, currentActor);
if (nextActor == null)
{
foreach (
var waiter in
actorList.Where(info => info.waitingForDeadlock))
{
waiter.waitingForDeadlock = false;
waiter.enabled = true;
}
nextActor = scheduler.GetNext(actorList, currentActor);
}
if (nextActor == null)
{
// Deadlock
terminated = true;
ActivateAllActors();
CheckTerminated(opType);
return;
}
if (nextActor == currentActor)
{
return;
}
Safety.Assert(currentActor.active);
currentActor.active = false;
lock (nextActor.mutex)
{
Safety.Assert(nextActor.enabled);
Safety.Assert(!nextActor.active);
nextActor.active = true;
Monitor.PulseAll(nextActor.mutex);
}
lock (currentActor.mutex)
{
if (currentActor.terminated && opType == OpType.END)
{
return;
}
while (!currentActor.active)
{
Monitor.Wait(currentActor.mutex);
}
if (CheckTerminated(opType))
{
return;
}
Safety.Assert(currentActor.enabled);
Safety.Assert(currentActor.active);
}
}
protected ScalarOp(OpType opType) : base(opType)
{
}
private static void AddEntry(BitVec opVector, OpType opType, params PlanCompilerPhase[] phases)
{
foreach (var phase in phases)
{
AddSingleEntry(opVector, opType, phase);
}
}
/// <summary>
/// Constructs a Flag Data operation with a letter operand.
/// </summary>
/// <param name="type">The type of the operation.</param>
/// <param name="index">The index of the letter to mutate.</param>
/// <param name="letter">The operand value to use with the operation type.</param>
///
/// <exception cref="ArgumentException">
/// <paramref name="type"/> is an invalid enum value.
/// </exception>
/// <exception cref="ArgumentOutOfRangeException">
/// <paramref name="index"/> is less than 0 or greater than or equal to <see cref="PasswordFlagData.Length"/>.
/// </exception>
public FlagOperation(OpType type, int index, Letter letter)
{
ValidateOpType(type, nameof(type));
Type = type;
Flags = new[] { new FlagLetter(index, letter) };
}
private static bool CheckEntry(OpType opType, PlanCompilerPhase phase)
{
var hash = ComputeHash(opType, phase);
return s_ValidOpTypes.IsSet(hash);
}
internal OpEntry(OpType type, String value)
{
Type = type;
Value = value;
}
internal SortBaseOp(OpType opType, List<SortKey> sortKeys)
: this(opType)
{
m_keys = sortKeys;
}
/// <summary>
/// Constructor overload for rules
/// </summary>
protected ConstantBaseOp(OpType opType)
: base(opType)
{
}
private static int ComputeHash(OpType opType, PlanCompilerPhase phase)
{
var hash = ((int)opType * (int)PlanCompilerPhase.MaxMarker) + (int)phase;
return(hash);
}
protected static void AssertOpType(Op op, OpType opType)
{
Assert(op.OpType == opType, "OpType Mismatch: Expected {0}; found {1}", op.OpType, Dump.AutoString.ToString(opType));
}
public void ReadOut(BinaryReader reader)
{
_type = (OpType)reader.ReadInt32();
}
/// <summary>
/// Default constructor
/// </summary>
/// <param name="opType">kind of Op</param>
internal AncillaryOp(OpType opType) : base(opType)
{
}
// <summary>
// Default constructor
// </summary>
// <param name="opType"> the op type </param>
internal PhysicalOp(OpType opType)
: base(opType)
{
}
protected SetOp(OpType opType) : base(opType)
{
}
private static void AddSingleEntry(BitVec opVector, OpType opType, PlanCompilerPhase phase)
{
var hash = ComputeHash(opType, phase);
opVector.Set(hash);
}
public override void PreWrite(OpType operation)
{
InvalidState(operation);
}
internal JoinBaseOp(OpType opType) : base(opType)
{
}
private static void AddSingleEntry(BitVec opVector, OpType opType, PlanCompilerPhase phase)
{
var hash = ComputeHash(opType, phase);
opVector.Set(hash);
}
protected ScanTableBaseOp(OpType opType, Table table)
: base(opType)
{
m_table = table;
}
private static void AddAllEntry(BitVec opVector, OpType opType)
{
foreach (var phase in _planCompilerPhases)
{
AddSingleEntry(opVector, opType, phase);
}
}
protected ScanTableBaseOp(OpType opType)
: base(opType)
{
}
// Pattern constructor
internal SortBaseOp(OpType opType)
: base(opType)
{
Debug.Assert(opType == OpType.Sort || opType == OpType.ConstrainedSort, "SortBaseOp OpType must be Sort or ConstrainedSort");
}
internal ApplyBaseOp(OpType opType) : base(opType)
{
}
protected static void AssertOpType(Op op, OpType opType)
{
Assert(op.OpType == opType, "OpType Mismatch: Expected {0}; found {1}", op.OpType, Dump.AutoString.ToString(opType));
}
// Pattern constructor
internal SortBaseOp(OpType opType)
: base(opType)
{
Debug.Assert(opType == OpType.Sort || opType == OpType.ConstrainedSort, "SortBaseOp OpType must be Sort or ConstrainedSort");
}
public Operation(OpType type)
{
_type = type;
}
internal SortBaseOp(OpType opType, List <SortKey> sortKeys)
: this(opType)
{
m_keys = sortKeys;
}
/// <summary>
/// Is the op not safe for null sentinel value change
/// </summary>
/// <param name="optype"> </param>
/// <returns> </returns>
internal static bool IsOpNotSafeForNullSentinelValueChange(OpType optype)
{
return optype == OpType.Distinct ||
optype == OpType.GroupBy ||
optype == OpType.Intersect ||
optype == OpType.Except;
}
protected GroupByBaseOp(OpType opType) : base(opType)
{
Debug.Assert(opType == OpType.GroupBy || opType == OpType.GroupByInto, "GroupByBaseOp OpType must be GroupBy or GroupByInto");
}
public Operator (TypeDefinition parent, OpType type, FullNamedExpression ret_type, Modifiers mod_flags, ParametersCompiled parameters,
ToplevelBlock block, Attributes attrs, Location loc)
: base (parent, ret_type, mod_flags, AllowedModifiers, new MemberName (GetMetadataName (type), loc), attrs, parameters)
{
OperatorType = type;
Block = block;
}
internal GroupByBaseOp(OpType opType, VarVec keys, VarVec outputs)
: this(opType)
{
m_keys = keys;
m_outputs = outputs;
}
public static string GetMetadataName (OpType ot)
{
return names [(int) ot] [1];
}
internal override void EmitGet(ILGenerator ilg)
{
EmitUnaryOperator(ilg, this, OpType.TypeSymbol()); // TODO nkok: handle checked/unchecked
}
