/// <summary>
/// Instantiate a new instance of the EvalNodeCondLogicOp node.
/// </summary>
/// <param name="operation">Specifies the binary compare to represent.</param>
/// <param name="child1">Specifies the first child node.</param>
/// <param name="child2">Specifies the second child node.</param>
public EvalNodeCondLogicOp(CompareOp operation,
EvalNode child1,
EvalNode child2)
{
_operation = operation;
Append(child1);
Append(child2);
}
/// <summary>
/// Instantiate a new instance of the EvalNodeCondLogicOp node.
/// </summary>
/// <param name="operation">Specifies the binary compare to represent.</param>
/// <param name="child">Specifies the first child node.</param>
/// <param name="language">Language used for evaluation.</param>
public EvalNodeCondLogicOp(CompareOp operation,
EvalNode child,
Language language)
{
_language = language;
_operation = operation;
Append(child);
}
/// <summary>
/// Initializes a new instance of the <see cref="CompareFilter"/> class.
/// </summary>
/// <param name="compareOp">The compare op.</param>
/// <param name="comparator">The comparator.</param>
protected CompareFilter(CompareOp compareOp, ByteArrayComparable comparator)
{
if (!Enum.IsDefined(typeof(CompareOp), compareOp))
{
throw new InvalidEnumArgumentException("compareOp", (int)compareOp, typeof(CompareOp));
}
comparator.ArgumentNotNull("comparator");
CompareOperation = compareOp;
Comparator = comparator;
}
/// <summary>
/// Initializes a new instance of the <see cref="DependentColumnFilter" /> class.
/// </summary>
/// <param name="family">The name of the column family.</param>
/// <param name="qualifier">The name of the column qualifier.</param>
/// <param name="dropDependentColumn">Specifies whether or not the dependent column should be dropped.</param>
/// <param name="valueCompareOp">The operator.</param>
/// <param name="valueComparator">The value comparator.</param>
public DependentColumnFilter(
byte[] family,
byte[] qualifier,
bool dropDependentColumn,
CompareOp valueCompareOp,
ByteArrayComparable valueComparator) : base(valueCompareOp, valueComparator)
{
family.ArgumentNotNull("family");
qualifier.ArgumentNotNull("qualifier");
_family = (byte[])family.Clone();
_qualifier = (byte[])qualifier.Clone();
DropDependentColumn = dropDependentColumn;
}
public static void Sort(object [] sortArray, CompareOp gtMethod)
{
for (int i=0 ; i<sortArray.Length ; i++)
{
for (int j=i+1 ; j<sortArray.Length ; j++)
{
if (gtMethod(sortArray[j], sortArray[i]))
{
object temp = sortArray[i];
sortArray[i] = sortArray[j];
sortArray[j] = temp;
}
}
}
}
static void Main()
{
Employee [] employees =
{
new Employee("Karli Watson", 20000),
new Employee("Bill Gates", 10000),
new Employee("Simon Robinson", 25000),
new Employee("Mortimer", (decimal)1000000.38),
new Employee("Arabel Jones", 23000),
new Employee("Avon from 'Blake's 7'", 50000)};
CompareOp employeeCompareOp = new CompareOp(Employee.RhsIsGreater);
BubbleSorter.Sort(employees, employeeCompareOp);
for (int i=0 ; i<employees.Length ; i++)
Console.WriteLine(employees[i].ToString());
Console.ReadLine();
}
public SamplerCreateInfo
(
StructureType sType = StructureType.SamplerCreateInfo,
void *pNext = default,
SamplerCreateFlags flags = default,
Filter magFilter = default,
Filter minFilter = default,
SamplerMipmapMode mipmapMode = default,
SamplerAddressMode addressModeU = default,
SamplerAddressMode addressModeV = default,
SamplerAddressMode addressModeW = default,
float mipLodBias = default,
Bool32 anisotropyEnable = default,
float maxAnisotropy = default,
Bool32 compareEnable = default,
CompareOp compareOp = default,
float minLod = default,
float maxLod = default,
BorderColor borderColor = default,
Bool32 unnormalizedCoordinates = default
)
{
SType = sType;
PNext = pNext;
Flags = flags;
MagFilter = magFilter;
MinFilter = minFilter;
MipmapMode = mipmapMode;
AddressModeU = addressModeU;
AddressModeV = addressModeV;
AddressModeW = addressModeW;
MipLodBias = mipLodBias;
AnisotropyEnable = anisotropyEnable;
MaxAnisotropy = maxAnisotropy;
CompareEnable = compareEnable;
CompareOp = compareOp;
MinLod = minLod;
MaxLod = maxLod;
BorderColor = borderColor;
UnnormalizedCoordinates = unnormalizedCoordinates;
}
public static Bool Compare(CompareOp op, double d1, double d2)
{
if (!Undefined.IsDefined(d1) || !Undefined.IsDefined(d2))
{
return(Bool.Undefined);
}
Bool result;
switch (op)
{
case CompareOp.Eq:
result = (Bool)(d1.CompareTo(d2) == 0);
break;
case CompareOp.Ne:
result = (Bool)(d1.CompareTo(d2) != 0);
break;
case CompareOp.Lt:
result = (Bool)(d1.CompareTo(d2) < 0);
break;
case CompareOp.Le:
result = (Bool)(d1.CompareTo(d2) <= 0);
break;
case CompareOp.Gt:
result = (Bool)(d1.CompareTo(d2) > 0);
break;
case CompareOp.Ge:
result = (Bool)(d1.CompareTo(d2) >= 0);
break;
default:
throw new ArgumentOutOfRangeException(nameof(op), op, null);
}
return(result);
}
public static Bool Compare(CompareOp op, QueryValue v1, QueryValue v2)
{
if (!Undefined.IsDefined(v1) || !Undefined.IsDefined(v2) || v1 == null || v2 == null)
{
return(Bool.Undefined);
}
Bool result;
switch (op)
{
case CompareOp.Eq:
result = (Bool)(v1.CompareTo(v2) == 0);
break;
case CompareOp.Ne:
result = (Bool)(v1.CompareTo(v2) != 0);
break;
case CompareOp.Lt:
result = (Bool)(v1.CompareTo(v2) < 0);
break;
case CompareOp.Le:
result = (Bool)(v1.CompareTo(v2) <= 0);
break;
case CompareOp.Gt:
result = (Bool)(v1.CompareTo(v2) > 0);
break;
case CompareOp.Ge:
result = (Bool)(v1.CompareTo(v2) >= 0);
break;
default:
throw new ArgumentOutOfRangeException(nameof(op), op, null);
}
return(result);
}
public static Bool Compare(CompareOp op, string s1, string s2)
{
if (!Undefined.IsDefined(s1) || !Undefined.IsDefined(s2) || s1 == null || s2 == null)
{
return(Bool.Undefined);
}
Bool result;
switch (op)
{
case CompareOp.Eq:
result = (Bool)(string.Compare(s1, s2, StringComparison.Ordinal) == 0);
break;
case CompareOp.Ne:
result = (Bool)(string.Compare(s1, s2, StringComparison.Ordinal) != 0);
break;
case CompareOp.Lt:
result = (Bool)(string.Compare(s1, s2, StringComparison.Ordinal) < 0);
break;
case CompareOp.Le:
result = (Bool)(string.Compare(s1, s2, StringComparison.Ordinal) <= 0);
break;
case CompareOp.Gt:
result = (Bool)(string.Compare(s1, s2, StringComparison.Ordinal) > 0);
break;
case CompareOp.Ge:
result = (Bool)(string.Compare(s1, s2, StringComparison.Ordinal) >= 0);
break;
default:
throw new ArgumentOutOfRangeException(nameof(op), op, null);
}
return(result);
}
public static All Convert(this CompareOp op)
{
switch (op)
{
case CompareOp.Never:
case CompareOp.NeverGl:
return(All.Never);
case CompareOp.Less:
case CompareOp.LessGl:
return(All.Less);
case CompareOp.Equal:
case CompareOp.EqualGl:
return(All.Equal);
case CompareOp.LessOrEqual:
case CompareOp.LessOrEqualGl:
return(All.Lequal);
case CompareOp.Greater:
case CompareOp.GreaterGl:
return(All.Greater);
case CompareOp.NotEqual:
case CompareOp.NotEqualGl:
return(All.Notequal);
case CompareOp.GreaterOrEqual:
case CompareOp.GreaterOrEqualGl:
return(All.Gequal);
case CompareOp.Always:
case CompareOp.AlwaysGl:
return(All.Always);
}
Logger.PrintDebug(LogClass.Gpu, $"Invalid {nameof(CompareOp)} enum value: {op}.");
return(All.Never);
}
private void PropertyTestImpl(
string propNameOrValueKey,
string keyOrTypeName,
string keyOrValue,
string stepText,
bool isValue,
string propName2 = null,
string keyOrTypeName2 = null)
{
string compareText = GetCompareText(stepText);
CompareOp compareOp = ToCompareOp(compareText);
//Console.WriteLine($"***** PropertyTest: propName: <{propNameOrValueKey}>, keyOrTypeName: <{keyOrTypeName}>, keyOrValue: <{keyOrValue}>, compare: <{compareOp}>, propName2: <{propName2}>, keyOrTypeName2: <{keyOrTypeName2}>");
GetPropertyOrFieldData(propNameOrValueKey, keyOrTypeName, out object instance, out PropertyInfo prop, out FieldInfo field);
GetPropertyOrFieldData(propName2, keyOrTypeName2, out object instance2, out PropertyInfo prop2, out FieldInfo field2);
ITypeProcessor actual = GetProcessorFor(propNameOrValueKey, instance, prop, field);
ITypeProcessor expected = null;
if (!IsSingleCompareOp(compareOp))
{
if (isValue)
{
expected = actual.Clone();
expected.SetValue(keyOrValue);
}
else
{
expected = GetProcessorFor(keyOrValue, instance2, prop2, field2);
}
}
if (expected == null)
{
expected = new ObjectProcessor(_scenario);
expected.PostCurrentValue();
}
DoCompare(actual, expected, compareOp);
}
public static Bool Compare(CompareOp op, Undefined u1, Undefined u2)
{
Bool result;
switch (op)
{
case CompareOp.Eq:
case CompareOp.Ne:
case CompareOp.Lt:
case CompareOp.Le:
case CompareOp.Gt:
case CompareOp.Ge:
result = Bool.Undefined;
break;
default:
throw new ArgumentOutOfRangeException(nameof(op), op, null);
}
return(result);
}
static void Main()
{
Employee[] employees =
{
new Employee("B", 20000),
new Employee("E", 10000),
new Employee("D", 25000),
new Employee("W", (decimal)1000000.38),
new Employee("F", 23000),
new Employee("R'", 50000)
};
CompareOp employeeCompareOp = new CompareOp(Employee.RhsIsGreater);
BubbleSorter.Sort(employees, employeeCompareOp);
for (int i = 0; i < employees.Length; i++)
{
Console.WriteLine(employees[i].ToString());
}
Console.ReadLine();
}
static void Main()
{
Employee [] employees =
{
new Employee("Karli Watson", 20000),
new Employee("Bill Gates", 10000),
new Employee("Simon Robinson", 25000),
new Employee("Mortimer", (decimal)1000000.38),
new Employee("Arabel Jones", 23000),
new Employee("Avon from 'Blake's 7'", 50000)
};
CompareOp employeeCompareOp = new CompareOp(Employee.RhsIsGreater);
BubbleSorter.Sort(employees, employeeCompareOp);
for (int i = 0; i < employees.Length; i++)
{
Console.WriteLine(employees[i].ToString());
}
Console.ReadLine();
}
/// <summary>
/// Creates a new instance of the cached sampler.
/// </summary>
/// <param name="context">The GPU context the sampler belongs to</param>
/// <param name="descriptor">The Maxwell sampler descriptor</param>
public Sampler(GpuContext context, SamplerDescriptor descriptor)
{
MinFilter minFilter = descriptor.UnpackMinFilter();
MagFilter magFilter = descriptor.UnpackMagFilter();
AddressMode addressU = descriptor.UnpackAddressU();
AddressMode addressV = descriptor.UnpackAddressV();
AddressMode addressP = descriptor.UnpackAddressP();
CompareMode compareMode = descriptor.UnpackCompareMode();
CompareOp compareOp = descriptor.UnpackCompareOp();
ColorF color = new ColorF(
descriptor.BorderColorR,
descriptor.BorderColorG,
descriptor.BorderColorB,
descriptor.BorderColorA);
float minLod = descriptor.UnpackMinLod();
float maxLod = descriptor.UnpackMaxLod();
float mipLodBias = descriptor.UnpackMipLodBias();
float maxAnisotropy = descriptor.UnpackMaxAnisotropy();
HostSampler = context.Renderer.CreateSampler(new SamplerCreateInfo(
minFilter,
magFilter,
addressU,
addressV,
addressP,
compareMode,
compareOp,
color,
minLod,
maxLod,
mipLodBias,
maxAnisotropy));
}
void PropertyInfoTree_CellValueChanged(object sender, CellValueChangedEventArgs e)
{
if (e.Column.FieldName == "值" || e.Column.FieldName == "算符")
{
string currproperty = e.Node["id"].ToString();
string pv = ((e.Node["值"] == null) || (string.IsNullOrEmpty(e.Node["值"].ToString())))
? string.Empty : e.Node["值"].ToString();
CompareOp op = (e.Node["算符"] == null) ? CompareOp.None : (CompareOp)e.Node["算符"];
QCParam qcp = new QCParam(currproperty, op, pv);
if (_qcParams.Settings.ContainsKey(currproperty))
{
// if (!string.IsNullOrEmpty(pv))
_qcParams.Settings[currproperty] = qcp;
//else
// _qcParams.Settings.Remove(currproperty);
}
else if (!string.IsNullOrEmpty(pv))
{
_qcParams.Settings.Add(currproperty, qcp);
}
}
}
public static Bool Compare(CompareOp op, Null n1, Null n2)
{
Bool result;
switch (op)
{
case CompareOp.Eq:
case CompareOp.Le:
case CompareOp.Ge:
result = Bool.True;
break;
case CompareOp.Ne:
case CompareOp.Lt:
case CompareOp.Gt:
result = Bool.False;
break;
default:
throw new ArgumentOutOfRangeException(nameof(op), op, null);
}
return(result);
}
public CompareNode(Token tok, CompareOp op, ListNode operands)
: base(tok)
{
Contracts.AssertValue(operands);
Contracts.Assert(operands.Items.Length >= 2);
Contracts.AssertValue(operands.Delimiters);
Contracts.Assert(operands.Delimiters.Length == operands.Items.Length - 1);
Op = op;
Operands = operands;
switch (op)
{
default:
Contracts.Assert(false);
goto case CompareOp.Equal;
case CompareOp.Equal:
TidLax = TokKind.Equ;
TidStrict = TokKind.EquEqu;
break;
case CompareOp.NotEqual:
TidLax = TokKind.LssGrt;
TidStrict = TokKind.BngEqu;
break;
case CompareOp.IncrChain:
TidLax = TokKind.LssEqu;
TidStrict = TokKind.Lss;
break;
case CompareOp.DecrChain:
TidLax = TokKind.GrtEqu;
TidStrict = TokKind.Grt;
break;
}
}
private void TestCollectionCore(string collectionKind, string resultName, string typeName, string value, string stepText)
{
string compareText = GetCompareText(stepText);
CompareOp compareOp = ToCompareOp(compareText);
//Console.WriteLine($"***** Testing Collection: collection kind: <{collectionKind}>, result name: <{resultName}>, type name: <{typeName}>, compare: <{compareOp}>, value: <{value}>");
ITypeProcessor actual = _manager.GetCollectionProcessorForExistingName(resultName);
ITypeProcessor expected = null;
if (!IsSingleCompareOp(compareOp))
{
expected = _manager.GetCollectionProcessorFor(collectionKind, typeName, value);
}
else if (compareOp == CompareOp.Null || compareOp == CompareOp.NotNull)
{
if (actual == null)
{
actual = _manager.GetCollectionProcessorFor(collectionKind, typeName, null);
actual?.ReadFromContext();
}
}
DoCompare(actual, expected, compareOp);
}
/// <summary>
/// 字符串至时限设置参数
/// </summary>
/// <param name="qcpstring"></param>
/// <returns></returns>
public static QCParam String2QCParam(string qcpstring)
{
string[] oneparam = new string[0];
CompareOp op = CompareOp.None;
if (qcpstring.Contains(CompareOp2String(CompareOp.Equal)))
{
op = CompareOp.Equal;
oneparam = qcpstring.Split(new string[] { CompareOp2String(CompareOp.Equal) }, StringSplitOptions.RemoveEmptyEntries);
}
if (qcpstring.Contains(CompareOp2String(CompareOp.Like)))
{
op = CompareOp.Like;
oneparam = qcpstring.Split(new string[] { CompareOp2String(CompareOp.Like) }, StringSplitOptions.RemoveEmptyEntries);
}
if (oneparam.Length == 2)
{
return(new QCParam(oneparam[0], op, oneparam[1]));
}
else
{
return(new QCParam());
}
}
public static BoolExpression operator<=(IntExpression lhs, IntExpression rhs)
{
return(CompareOp.CreateLessThanOrEqual(lhs, rhs));
}
public static BoolExpression operator!=(IntExpression lhs, IntExpression rhs)
{
return(CompareOp.CreateNotEqual(lhs, rhs));
}
/// <summary>
/// Initializes a new instance of the <see cref="FamilyFilter"/> class.
/// </summary>
/// <param name="familyCompareOp">The family compare op.</param>
/// <param name="familyComparator">The family comparator.</param>
/// <exception cref="System.ComponentModel.InvalidEnumArgumentException">familyCompareOp</exception>
public FamilyFilter(CompareOp familyCompareOp, ByteArrayComparable familyComparator) : base(familyCompareOp, familyComparator)
{
}
public void Set(bool enable, float reference, CompareOp op)
{
_enable = enable;
_reference = reference;
_op = op;
}
/// <summary>
/// Creates a new instance of the cached sampler.
/// </summary>
/// <param name="context">The GPU context the sampler belongs to</param>
/// <param name="descriptor">The Maxwell sampler descriptor</param>
public Sampler(GpuContext context, SamplerDescriptor descriptor)
{
MinFilter minFilter = descriptor.UnpackMinFilter();
MagFilter magFilter = descriptor.UnpackMagFilter();
bool seamlessCubemap = descriptor.UnpackSeamlessCubemap();
AddressMode addressU = descriptor.UnpackAddressU();
AddressMode addressV = descriptor.UnpackAddressV();
AddressMode addressP = descriptor.UnpackAddressP();
CompareMode compareMode = descriptor.UnpackCompareMode();
CompareOp compareOp = descriptor.UnpackCompareOp();
ColorF color = new ColorF(
descriptor.BorderColorR,
descriptor.BorderColorG,
descriptor.BorderColorB,
descriptor.BorderColorA);
float minLod = descriptor.UnpackMinLod();
float maxLod = descriptor.UnpackMaxLod();
float mipLodBias = descriptor.UnpackMipLodBias();
float maxRequestedAnisotropy = descriptor.UnpackMaxAnisotropy();
float maxSupportedAnisotropy = context.Capabilities.MaximumSupportedAnisotropy;
_hostSampler = context.Renderer.CreateSampler(new SamplerCreateInfo(
minFilter,
magFilter,
seamlessCubemap,
addressU,
addressV,
addressP,
compareMode,
compareOp,
color,
minLod,
maxLod,
mipLodBias,
Math.Min(maxRequestedAnisotropy, maxSupportedAnisotropy)));
if (GraphicsConfig.MaxAnisotropy >= 0 && GraphicsConfig.MaxAnisotropy <= 16 && (minFilter == MinFilter.LinearMipmapNearest || minFilter == MinFilter.LinearMipmapLinear))
{
maxRequestedAnisotropy = GraphicsConfig.MaxAnisotropy;
_anisoSampler = context.Renderer.CreateSampler(new SamplerCreateInfo(
minFilter,
magFilter,
seamlessCubemap,
addressU,
addressV,
addressP,
compareMode,
compareOp,
color,
minLod,
maxLod,
mipLodBias,
Math.Min(maxRequestedAnisotropy, maxSupportedAnisotropy)));
}
}
/// <param name="MagFilter">Filter mode for magnification</param>
/// <param name="MinFilter">Filter mode for minifiation</param>
/// <param name="MipmapMode">Mipmap selection mode</param>
public SamplerCreateInfo(Filter MagFilter, Filter MinFilter, SamplerMipmapMode MipmapMode, SamplerAddressMode AddressModeU, SamplerAddressMode AddressModeV, SamplerAddressMode AddressModeW, Single MipLodBias, Bool32 AnisotropyEnable, Single MaxAnisotropy, Bool32 CompareEnable, CompareOp CompareOp, Single MinLod, Single MaxLod, BorderColor BorderColor, Bool32 UnnormalizedCoordinates) : this()
{
this.MagFilter = MagFilter;
this.MinFilter = MinFilter;
this.MipmapMode = MipmapMode;
this.AddressModeU = AddressModeU;
this.AddressModeV = AddressModeV;
this.AddressModeW = AddressModeW;
this.MipLodBias = MipLodBias;
this.AnisotropyEnable = AnisotropyEnable;
this.MaxAnisotropy = MaxAnisotropy;
this.CompareEnable = CompareEnable;
this.CompareOp = CompareOp;
this.MinLod = MinLod;
this.MaxLod = MaxLod;
this.BorderColor = BorderColor;
this.UnnormalizedCoordinates = UnnormalizedCoordinates;
}
public void SetAlphaTest(bool enable, float reference, CompareOp op)
{
_renderer.New <SetAlphaTestCommand>().Set(enable, reference, op);
_renderer.QueueCommand();
}
public DbQueryItem(string propName, CompareOp op, object value)
{
this.PropertyName = propName ?? throw new ArgumentNullException("PropertyName");
this.Op = op;
this.Value = value;
}
/// <summary>
/// Initializes a new instance of the <see cref="ValueFilter"/> class.
/// </summary>
/// <param name="valueCompareOp">The value compare op.</param>
/// <param name="valueComparator">The value comparator.</param>
public ValueFilter(CompareOp valueCompareOp, ByteArrayComparable valueComparator) : base(valueCompareOp, valueComparator)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="RowFilter"/> class.
/// </summary>
/// <param name="rowCompareOp">The row compare op.</param>
/// <param name="rowComparator">The row comparator.</param>
public RowFilter(CompareOp rowCompareOp, ByteArrayComparable rowComparator)
: base(rowCompareOp, rowComparator)
{
}
public CompareValidatorAttribute(CompareOp op, IComparable compareTo)
{
Op = op;
CompareTo = compareTo;
}
private static extern int PyObject_RichCompareBool(IntPtr a, IntPtr b, CompareOp op);
public static BoolExpression operator>(IntExpression lhs, IntExpression rhs)
{
return(CompareOp.CreateLessThan(rhs, lhs)); //(a>b) is the same as (b<a)
}
protected static bool IsSingleCompareOp(CompareOp compareOp) => compareOp == CompareOp.Null || compareOp == CompareOp.NotNull;
public static BoolExpression operator>=(IntExpression lhs, IntExpression rhs)
{
return(CompareOp.CreateLessThanOrEqual(rhs, lhs)); //(a>=b) is the same as (b<=a)
}
static void Main()
{
Employee[] employees = {
new Employee("Bugs Bunny", 2000),
new Employee("Elmer Fudd", 3000),
new Employee("Eason Wu", 1000),
new Employee("Jim Paul", 4000),
new Employee("Gary Deng", 5000),
new Employee("RoadRunner", 50000),
new Employee("Foghorn Leghorn", 23000)
};
CompareOp employeeCompareOp = new CompareOp(Employee.RhsIsGreater);
BubbleSorter.Sort(employees, employeeCompareOp);
for (int i = 0; i < employees.Length; i++)
{
Console.WriteLine(employees[i].ToString());
}
Console.ReadKey();
}
protected static void DoCompare(ITypeProcessor actual, ITypeProcessor expected, CompareOp compareOp)
{
if (actual == null)
{
if (expected != null)
{
actual = expected.Clone();
actual.ReadFromContext();
}
}
Console.WriteLine($"***** Actual: {(actual != null ? actual.ToString() : "NULL")}");
Console.WriteLine($"***** Expected: {(expected != null ? expected.ToString() : "NULL")}");
if (actual == null || (expected == null && !IsSingleCompareOp(compareOp)))
{
throw new Exception($"Unable to parse test step.");
}
actual.CompareTo(expected, compareOp);
}
static ASTNode ParseNode(ScriptParseContext ctx)
{
var lexer = ctx.lexer;
string head = _Expect(lexer, TK_ID, TK_COLON, TK_AT, TK_QUESTION, TK_EXCLAIM);
object headToken = lexer.Token;
if (headToken == TK_ID) // Control node
{
var nodeName = head;
var node = ASTControlNode.Create(nodeName, lexer.LineNumber);
_Expect(lexer, TK_LEFT_BRACE);
while (true) // parse child nodes
{
ASTNode n = ParseNode(ctx);
node.children.Add(n);
// Peek next lexeme
_Expect(lexer, TK_ID, TK_COLON, TK_AT, TK_QUESTION, TK_RIGHT_BRACE, TK_EXCLAIM);
if (lexer.Token == TK_RIGHT_BRACE)
{
break;
}
lexer.PushCurrent(); // Save last token for subsequent parsing
}
return(node);
}
else if (headToken == TK_COLON) // Decorator node
{
string nodeName = _Expect(lexer, TK_ID);
var node = ASTDecoratorNode.Create(nodeName, lexer.LineNumber);
_Expect(lexer, TK_LEFT_PAREN, TK_ID, TK_AT, TK_QUESTION, TK_COLON, TK_EXCLAIM);
if (lexer.Token == TK_LEFT_PAREN)
{
while (true)
{
var look2 = _Expect(lexer, TK_RIGHT_PAREN, TK_INT, TK_FLOAT, TK_STR);
if (lexer.Token == TK_RIGHT_PAREN)
{
break;
}
else
{
object arg;
if (lexer.Token == TK_INT)
{
arg = int.Parse(look2);
}
else if (lexer.Token == TK_FLOAT)
{
arg = float.Parse(look2);
}
else // TK_STR
{
arg = look2.Substring(1, look2.Length - 2);
}
node.args.Add(new SerializableArg(arg));
_Expect(lexer, TK_COMMA, TK_RIGHT_PAREN);
if (lexer.Token == TK_RIGHT_PAREN)
{
lexer.PushCurrent();
}
}
}
}
else
{
lexer.PushCurrent();
}
node.target = ParseNode(ctx);
return(node);
}
else if (headToken == TK_AT) // Action node
{
string actionName = _Expect(lexer, TK_ID);
var node = ASTActionNode.Create(actionName, lexer.LineNumber);
_Expect(lexer, TK_LEFT_PAREN, TK_SEMI);
if (lexer.Token == TK_SEMI)
{
return(node);
}
else
{
while (true)
{
string look1 = _Expect(lexer, TK_RIGHT_PAREN, TK_ID);
if (lexer.Token == TK_RIGHT_PAREN)
{
break;
}
else
{
string argName = look1;
_Expect(lexer, TK_ASSIGN);
object arg = ParseArg(lexer);
var wrapped = new SerializableArgPair {
name = argName,
arg = new SerializableArg(arg)
};
node.args.Add(wrapped);
_Expect(lexer, TK_COMMA, TK_RIGHT_PAREN);
if (lexer.Token == TK_RIGHT_PAREN)
{
lexer.PushCurrent();
}
}
}
_Expect(lexer, TK_SEMI);
return(node);
}
}
else if (headToken == TK_EXCLAIM)
{
string argName = _Expect(lexer, TK_ID);
_Expect(lexer, TK_ASSIGN);
object arg = ParseArg(lexer);
_Expect(lexer, TK_SEMI);
var node = ASTSetConditionNode.Create(lexer.LineNumber);
node.condName = argName;
node.arg = new SerializableArg(arg);
return(node);
}
else // TK_QUESTION, Condition node
{
Debug.Assert(headToken == TK_QUESTION);
string tk = _Expect(lexer, TK_EXCLAIM, TK_ID);
string condName;
if (lexer.Token != TK_EXCLAIM)
{
condName = tk;
_Expect(lexer, TK_SEMI, TK_LTEQ, TK_LT, TK_GTEQ, TK_GT, TK_EQ, TK_NEQ);
if (lexer.Token == TK_SEMI) // boolean condition node
{
var node = ASTConditionNode.Create(lexer.LineNumber);
node.condName = condName;
node.arg.objValue = true;
return(node);
}
else // value condition node
{
CompareOp op = GetCompareOp(lexer.Token as TokenType);
string val = _Expect(lexer, TK_FLOAT, TK_INT);
var floatVal = float.Parse(val);
var node = ASTConditionNode.Create(lexer.LineNumber);
node.condName = condName;
node.arg.objValue = floatVal;
node.op = op;
_Expect(lexer, TK_SEMI);
return(node);
}
}
else
{
condName = _Expect(lexer, TK_ID);
if (lexer.Token == TK_ID)
{
var conditionNode = ASTConditionNode.Create(lexer.LineNumber);
conditionNode.condName = condName;
conditionNode.arg.type = ConditionType.Bool;
conditionNode.op = CompareOp.NotEq;
_Expect(lexer, TK_SEMI);
return(conditionNode);
}
else
{
throw _Error(lexer, "only bool varible can be place after '? !'");
}
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="FamilyFilter"/> class.
/// </summary>
/// <param name="familyCompareOp">The family compare op.</param>
/// <param name="familyComparator">The family comparator.</param>
/// <exception cref="System.ComponentModel.InvalidEnumArgumentException">familyCompareOp</exception>
public FamilyFilter(CompareOp familyCompareOp, ByteArrayComparable familyComparator) : base(familyCompareOp, familyComparator)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="QualifierFilter"/> class.
/// </summary>
/// <param name="op">The op.</param>
/// <param name="qualifierComparator">The qualifier comparator.</param>
public QualifierFilter(CompareOp op, ByteArrayComparable qualifierComparator) : base(op, qualifierComparator)
{
}