public GpfProgram(ProgramSet set)
{
RuleProgram = set.GetRuleProgram();
FilterProgram = set.GetFilterProgram();
ProgramMemory = MemoryCoordinator.GetProgramMemory();
DataStart = set.RecordStartByte;
DataLength = set.RecordLengthByte + slackBytes;
DataLength += (DataLength % 4 != 0 ? (4 - DataStart % 4) : 0);
LayerCount = set.RuleProgram.Count;
Root = ProtocolLibrary.GetRoot().Identifier;
//update root start / end
//ensure records are multiples of 4 bytes
if (DataLength < 16)
{
DataLength = 16;
}
if (DataLength % 4 != 0)
{
DataLength += 4 - (DataLength % 4);
}
FilterNames = set.Filters.Select(f => f.ID).ToList();
IntegerNames = set.Reads.Select(f => f.ID).ToList();
}
public int StoreAsRule()
{
if (RuleIndex == -1)
{
RuleIndex = MemoryCoordinator.GetBoolRuleIndex();
}
return(RuleIndex);
}
public int StoreAsResult()
{
if (ResultIndex == -1)
{
ResultIndex = MemoryCoordinator.GetIntResultIndex();
}
return(ResultIndex);
}
public static void Clear()
{
MemoryCoordinator.Reset();
GpfProgramCompiler.Clear();
Protocols.Clear();
Kernels.Clear();
head = null;
}
public int StoreAsRule()
{
if (RuleIndex != -1)
{
return(RuleIndex);
}
//get a new bool rule index
//get the fields referenced in the parents switch statements, store them, and then set
//their relevant filter(s) to the rule index generagted above
//get a lis of parent protocols -> those protocols that have a switch statement connecting them to this protocol
var parents = ProtocolLibrary.Protocols.Values.Where(p => p.Switch != null && p.Switch.Cases.Exists(s => s.Protocol == Name)).ToList();
//var test = new List<int>();
////check parents to ensure a rule id doesnt already exit (by accidentally or intentionally referencing the full path to the protocol
////from a field filter of the previous protocol (unlikely, but possible);
////if single alternative exists, use that value. otherwise write new value if 0 or many defined.
//foreach (var parent in parents)
//{
// var cases = parent.Switch.Cases.Where(f => f.Protocol == Name).ToList();
// foreach (var c in cases)
// {
// var filters = parent.Switch.Target.Filters.FindAll(f => f.ID == c.Filter).Select(i => i.RuleIndex);
// test.AddRange(filters);
// }
//}
// //.Select(f => f.RuleIndex);
//test.Remove(-1);
RuleIndex = MemoryCoordinator.GetBoolRuleIndex();
//for each of these parent protocols, set the field targeted by the switch statement to a rule field
foreach (var tmp in parents.Select(parent => parent.Switch))
{
RuleFields.Add(tmp.Target);
//get the name(s) of the relevant filter(s)
var filterIds = new HashSet <string>(tmp.Cases.FindAll(f => f.Protocol == Name).Select(s => s.Filter));
//get a list of the relevant filters from their string ids
var filters = tmp.Target.Filters.FindAll(f => filterIds.Contains(f.ID));
//for each of these filters, set their result index to the result index of the protocol
filters.ForEach(f => f.StoreAsProtocolResult(RuleIndex));
}
return(RuleIndex);
}
public PredicateTransactionSet(Predicate predicate)
{
this.Transactions = new List <PredicateTransaction>();
if (predicate.Layer > 0)
{
predicate.Subpredicates.Sort();
foreach (var s in predicate.Subpredicates)
{
s.WriteIndex = MemoryCoordinator.GetBoolRuleIndex();
Transactions.Add(s.WriteTransaction(PredOutLoc.BoolRuleMemory));
}
}
predicate.WriteIndex = MemoryCoordinator.GetBoolResultIndex();
Transactions.Add(predicate.WriteTransaction(PredOutLoc.BoolResultMemory));
}
public FilterRecord(FieldFilter filter)
{
Name = filter.ID;
Comparison = filter.Comparison;
LookupIndex = MemoryCoordinator.RegisterStaticInteger(filter.Value);
RuleIndex = filter.RuleIndex;
SwitchValue = 0;
var protocolSwitch = filter.Parent.Parent.Switch;
if (protocolSwitch == null)
{
return;
}
//need to check for empty protocols, and give these a switch of 0
if (protocolSwitch.Cases.Select(c => c.Filter).ToList().Contains(Name))
{
SwitchValue = ProtocolLibrary.GetProtocol(protocolSwitch.Cases.Find(switchCase => switchCase.Filter == Name).Protocol).Identifier;
}
}
public MultTransaction(MultiplicationString input)
{
this.Transactions = new List <ExpressionReadTransaction>();
foreach (var a in input.List)
{
if (a.List.Count == 1)
{
ExpressionAtom atom = a.List[0];
ExpressionReadTransaction tmp;
switch (atom.AtomType)
{
case ExpressionAtomType.Static:
var stat = (StaticAtom)atom;
tmp = new ExpressionReadTransaction(ExprInLoc.Lookup, MemoryCoordinator.RegisterStaticInteger(stat.Value));
break;
case ExpressionAtomType.Register:
var sysreg = (RegisterAtom)atom;
tmp = new ExpressionReadTransaction(ExprInLoc.SystemReg, sysreg.RegisterValue);
break;
case ExpressionAtomType.SubExpression:
var sub = (SubExpressionAtom)atom;
tmp = new ExpressionReadTransaction(ExprInLoc.RegisterBank, sub.Expression.RegisterIndex);
break;
default:
throw new ArgumentOutOfRangeException();
}
Transactions.Add(tmp);
}
else
{
throw new Exception("AddTransaction Error: Subtraction not supported in simple strings");
}
}
}