private Item(Production production, int index, State parent, Item prevItem)
{
if (production == null || parent == null)
{
throw new ArgumentNullException();
}
if (index < 0 || index > production.Symbols.Count)
{
throw new ArgumentOutOfRangeException();
}
if (index == 0 && prevItem != null)
{
throw new ArgumentException();
}
if (index > 0 && prevItem == null)
{
throw new ArgumentNullException();
}
this.production = production;
this.index = index;
this.parent = parent;
this.prevItem = prevItem;
this.derivations = index == 0 ? null : new List<object>();
}
public void Add()
{
Nonterminal nt = new Nonterminal();
Production p = new Production();
nt.Add(p);
Assert.IsTrue(nt.Contains(p));
}
public void UpdateDisplay(ProductionShift shift, Production production, IEnumerable<ProductionStop> allStops)
{
productionStart = production.ProductionStart.ToString("g", System.Globalization.CultureInfo.CurrentUICulture);
productionShiftStartDate = shift.ProductionStart.ToShortDateString();
ClearDisplay();
ClearChart(chartShift);
ClearChart(chartProduction);
if (production == null ||
shift == null)
return;
team = shift.Team.Name;
DisplayOrder(production.Order);
DisplayProduct(production.Product);
DisplayProductionStart(shift.ProductionStart, production.ProductionStart);
DisplayProductionTime(shift.Duration, production.Duration);
DisplayProducedItems(shift.ProducedItems, production.ProducedItems, production.ProducedItemsPerHour);
DisplayDiscardedItems(shift.DiscardedItems, production.DiscardedItems);
DisplayFactors(new FactorCalculator(shift), new FactorCalculator(production));
DisplayStopRegistrationsOnChart(chartShift, shift.ProductionStopRegistrations, allStops, production.ValidatedStartTime);
DisplayStopRegistrationsOnChart(chartProduction, production.ProductionStopRegistrations, allStops, production.ValidatedStartTime);
}
/// <summary>
/// </summary>
/// <param name="targetclasses"></param>
/// <returns></returns>
protected override IEnumerable<Production> InternalGenerate(IBSharpClass[] targetclasses){
var genfactory = new Production{
FileName = "Adapters/Model.cs",
GetContent = () => new BaseModelWriter(Model).ToString()
};
yield return genfactory;
}
public PrecedenceBasedParserAction(BnfTerm shiftTerm, ParserState newShiftState, Production reduceProduction)
{
_reduceAction = new ReduceParserAction(reduceProduction);
var reduceEntry = new ConditionalEntry(CheckMustReduce, _reduceAction, "(Precedence comparison)");
ConditionalEntries.Add(reduceEntry);
DefaultAction = _shiftAction = new ShiftParserAction(shiftTerm, newShiftState);
}
internal IntermediateNode(Item item, int startPosition, int endPosition) : base(startPosition, endPosition) {
Item = item;
// these two are used just for figuring out equality
_production = item.Production;
_currentPosition = item.CurrentPosition;
}
/**
* <summary>Called when adding a child to a parse tree
* node.</summary>
*
* <param name='node'>the parent node</param>
* <param name='child'>the child node, or null</param>
*
* <exception cref='ParseException'>if the node analysis
* discovered errors</exception>
*/
public override void Child(Production node, Node child)
{
switch (node.Id) {
case (int) LogicalConstants.FORMULE:
ChildFormule(node, child);
break;
case (int) LogicalConstants.FORMULE_PRED:
ChildFormulePred(node, child);
break;
case (int) LogicalConstants.FORMULE_BIN:
ChildFormuleBin(node, child);
break;
case (int) LogicalConstants.ATOM:
ChildAtom(node, child);
break;
case (int) LogicalConstants.PREDICAT:
ChildPredicat(node, child);
break;
case (int) LogicalConstants.PRED1:
ChildPred1(node, child);
break;
case (int) LogicalConstants.PRED2:
ChildPred2(node, child);
break;
case (int) LogicalConstants.PRED3:
ChildPred3(node, child);
break;
}
}
public void Create()
{
Production p1 = new Production();
Production p2 = new Production();
Nonterminal nt = new Nonterminal(p1, p2);
Assert.AreEqual(2, nt.Count);
Assert.IsTrue(nt.Contains(p1) && nt.Contains(p2));
}
public Production PostSave(Production production)
{
if (production.Id > 0)
DatabaseContext.Database.Update(production);
else
DatabaseContext.Database.Save(production);
return production;
}
public Grammar(
Production startProduction,
Production[] productionList,
Token[] tokenList)
{
_startProduction = startProduction;
_productionList = productionList;
_tokenList = tokenList;
}
public TransitionAction(ParserAction action, Production reduceByProduction)
: this(action)
{
if (action != ParserAction.Reduce)
throw new Exception("Can only define the production to reduce by for the reduce action.");
if (reduceByProduction == null)
throw new ArgumentNullException("reduceByProduction");
ReduceByProduction = reduceByProduction;
}
public Form1()
{
InitializeComponent();
Production m = new Production("AMC", "01");
cbProductions.Items.Add(m);
m = new Production("Showtime", "02");
cbProductions.Items.Add(m);
m = new Production("HBO", "03");
cbProductions.Items.Add(m);
}
/**
* <summary>Called when adding a child to a parse tree
* node.</summary>
*
* <param name='node'>the parent node</param>
* <param name='child'>the child node, or null</param>
*
* <exception cref='ParseException'>if the node analysis
* discovered errors</exception>
*/
public override void Child(Production node, Node child)
{
switch (node.Id) {
case (int) GrammarConstants.DOCUMENT:
ChildDocument(node, child);
break;
case (int) GrammarConstants.TEXT:
ChildText(node, child);
break;
}
}
internal void AddChild(int i, Production production) {
if (i >= _families.Count) {
throw new Exception();
}
if (_families[i].Production != null) {
if (production != _families[i].Production) {
throw new Exception();
}
}
_families[i].Production = production;
}
public void AddTwoProductionsWithSameOrder()
{
Production production1 = new Production("Machine A", product1, order1, 1000, 100);
Production production2 = new Production("Machine A", product1, order1, 1000, 100);
using (IEntityRepository<Production> repository = factory.CreateEntityRepository<Production>())
{
repository.Save(production1);
repository.Save(production2);
}
}
public override void Add(Production item)
{
if (Productions.Count == 0)
{
var initialProduction = new Production(new NonTerminal(INITAL_SYMBOL_NAME), item.Symbol, null)
{ID = INITAL_SYMBOL_ID};
Productions.Add(initialProduction);
}
base.Add(item);
}
public void AddDuplicate()
{
State state = new State();
Production p = new Production(new Terminal('x', 'y'));
Item itemA = new Item(p, state);
itemA.Add('x');
state.Add(itemA);
Item itemB = new Item(p, state);
itemB.Add('y');
state.Add(itemB);
}
protected string GetClassName(Production prod)
{
var sb = new StringBuilder();
sb.Append('_');
sb.Append(prod.Head.Name);
foreach (var v in prod.Tail)
{
sb.Append('_');
sb.Append(v.Name);
}
return sb.ToString();
}
private void btnAdd_Click(object sender, EventArgs e)
{
if (!ValidateChildren())
{
return;
}
Production = new Production();
Production.Name = tbName.Text;
Production.Code = mtbCode.Text;
this.DialogResult = System.Windows.Forms.DialogResult.OK;
this.Close();
}
public void AddShift()
{
Production production = new Production("Machine A", new ProductNumber("11232"), new OrderNumber("1234"), 1000, 124);
ProductionTeam team = new ProductionTeam("Team 1");
DateTime start = new DateTime(2008, 10, 12, 8, 30, 0);
ProductionShift shift = production.AddProductionShift(team, start);
CollectionAssert.AreEquivalent(new [] { shift }, new List<ProductionShift>(production.Shifts));
}
public void AddNewProductions()
{
Production production1 = new Production("Machine A", product1, order1, 1000, 100);
Production production2 = new Production("Machine A", product1, order2, 500, 25);
using (IEntityRepository<Production> repository = factory.CreateEntityRepository<Production>())
{
repository.Save(production1);
repository.Save(production2);
}
Assert.AreNotEqual(production1.Id, production2.Id);
}
public StartShiftForm(Production p, DateTime date)
: this()
{
if (p != null)
{
Machine = p.Machine;
Product = p.Product;
ExpectedItems = p.ExpectedItems;
ProducedItemsPerHour = p.ProducedItemsPerHour;
ValidatedSetupTime = p.ValidatedStartTime;
production = p;
}
this.date = date;
}
public void CreateProductionLeg()
{
Production production = new Production("Machine A", new ProductNumber("11232"), new OrderNumber("1234"), 1000, 124);
ProductionTeam team = new ProductionTeam("Team");
DateTime start = new DateTime(2008, 10, 12, 8, 30, 0);
ProductionShift shift = production.AddProductionShift(team, start.Date);
long counterStart = 9956;
ProductionLeg leg = shift.AddProductionLeg(start, counterStart);
Assert.AreEqual<DateTime>(start, leg.ProductionStart);
Assert.AreEqual<long>(counterStart, leg.CounterStart);
}
public void AddShiftsOnDifferentDaysWithSameTeam()
{
Production production = new Production("Machine A", new ProductNumber("11232"), new OrderNumber("1234"), 1000, 124);
ProductionTeam team = new ProductionTeam("Team 1");
DateTime start1 = new DateTime(2008, 10, 12, 8, 30, 0);
DateTime start2 = new DateTime(2008, 11, 12, 8, 30, 0);
ProductionShift shift1 = production.AddProductionShift(team, start1);
ProductionShift shift2 = production.AddProductionShift(team, start2);
CollectionAssert.AreEquivalent(new [] { shift1, shift2 }, new List<ProductionShift>(production.Shifts));
}
public void AddNewProduction()
{
Production production = new Production("Machine A", product1, order1, 1000, 100);
Assert.AreEqual(0, production.Id);
Assert.AreEqual(0, production.Version);
using (IEntityRepository<Production> repository = factory.CreateEntityRepository<Production>())
{
repository.Save(production);
}
Assert.AreNotEqual(0, production.Id);
Assert.AreNotEqual(0, production.Version);
}
/// <summary>Factory method for creating a proper type of reduce parser action. </summary>
/// <param name="production">A Production to reduce.</param>
/// <returns>Reduce action.</returns>
public static ReduceParserAction Create(Production production)
{
var nonTerm = production.LValue;
//List builder (non-empty production for list non-terminal) is a special case
var isList = nonTerm.Flags.IsSet(TermFlags.IsList);
var isListBuilderProduction = isList && production.RValues.Count > 0 &&
production.RValues[0] == production.LValue;
if (isListBuilderProduction)
return new ReduceListBuilderParserAction(production);
if (nonTerm.Flags.IsSet(TermFlags.IsListContainer))
return new ReduceListContainerParserAction(production);
if (nonTerm.Flags.IsSet(TermFlags.IsTransient))
return new ReduceTransientParserAction(production);
return new ReduceParserAction(production);
}
public void Equals()
{
Production p = new Production(Terminal.Eof);
State s = new State();
Item item = new Item(p, s);
Assert.IsFalse(item.Equals(null));
Assert.IsFalse(item.Equals(new object()));
Assert.IsTrue(item.Equals(item), "Identity");
Assert.IsTrue(item.Equals(new Item(p, s)), "Value equality");
Assert.IsFalse(item.Equals(new Item(p, new State())), "Vary by state");
Assert.IsFalse(item.Equals(new Item(new Production(), s)), "Vary by production");
Assert.IsFalse(item.Equals(item.NextItem), "Vary by index");
Item another = new Item(p, s);
Assert.IsFalse(item.NextItem.Equals(another.NextItem), "Vary by previous item");
}
public void AddStopsToProductionLeg()
{
Production production = new Production("Machine A", new ProductNumber("11232"), new OrderNumber("1234"), 1000, 124);
ProductionShift shift = production.AddProductionShift(new ProductionTeam("T"), DateTime.Now.Date);
ProductionLeg leg = shift.AddProductionLeg(DateTime.Now, 0);
CollectionAssert.AreEquivalent(new ProductionStopRegistration[] { }, new List<ProductionStopRegistration>(leg.ProductionStopRegistrations));
leg.AddProductionStopRegistration(new ProductionStopRegistration(stop1, new TimeSpan(0, 10, 0)));
CollectionAssert.AreEquivalent(new [] { new ProductionStopRegistration(stop1, new TimeSpan(0, 10, 0)) }, new List<ProductionStopRegistration>(leg.ProductionStopRegistrations));
leg.AddProductionStopRegistration(new ProductionStopRegistration(stop3, new TimeSpan(0, 35, 0)));
CollectionAssert.AreEquivalent(new [] { new ProductionStopRegistration(stop1, new TimeSpan(0, 10, 0)), new ProductionStopRegistration(stop3, new TimeSpan(0, 35, 0)) }, new List<ProductionStopRegistration>(leg.ProductionStopRegistrations));
leg.AddProductionStopRegistration(new ProductionStopRegistration(stop1, new TimeSpan(0, 12, 0)));
CollectionAssert.AreEquivalent(new [] { new ProductionStopRegistration(stop1, new TimeSpan(0, 10, 0)), new ProductionStopRegistration(stop1, new TimeSpan(0, 12, 0)), new ProductionStopRegistration(stop3, new TimeSpan(0, 35, 0)) }, new List<ProductionStopRegistration>(leg.ProductionStopRegistrations));
}
public void CollectionTest()
{
CustomerFactory factory = new CustomerFactory(new ObjectContext(CreateDataStore()));
Customer customer = factory.FindFirst("Name = {0}", "Joe Blow");
IList<WME> factlist = customer.GenerateFactsForRootObject();
Assert.IsTrue(factlist.Count == 11, "Wrong count.");
Agenda agenda = new Agenda();
agenda.LoadRulesFromAssemblies = false;
Variable customer_var = new Variable("Customer");
Variable orders = new Variable("Orders");
Variable order = new Variable("Order");
Variable orderItems = new Variable("OrderItems");
Variable orderItem = new Variable("OrderItem");
Variable product = new Variable("Product");
//Variable comment = new Variable("Comment");
Variable description = new Variable("Description");
Production mostSimple = new Production("CollectionTest");
mostSimple.AddConditionToLHS(new PositiveCondition(customer_var, "$Customer.Orders", orders));
mostSimple.AddConditionToLHS(new PositiveCondition(orders, "$Customer.Orders.Order", order));
mostSimple.AddConditionToLHS(new PositiveCondition(order, "$Customer.Orders.Order.OrderItems", orderItems));
mostSimple.AddConditionToLHS(new PositiveCondition(orderItems, "$Customer.Orders.Order.OrderItems.OrderItem", orderItem));
mostSimple.AddConditionToLHS(new PositiveCondition(orderItem, "$Customer.Orders.Order.OrderItems.OrderItem.Product", product));
mostSimple.AddConditionToLHS(new PositiveCondition(product, "$Customer.Orders.Order.OrderItems.OrderItem.Product.Description", description));
mostSimple.AddConditionToLHS(new FunctionCondition(description, new FuncTerm("funcEquals", new funcEquals()), "Troll Food"));
mostSimple.AddConditionToRHS(new InvokeCondition("shout", customer_var, "Shout", "Yipee"));
mostSimple.AddConditionToRHS(new AssertCondition("Wow", customer_var, "eats", description));
agenda.AddProduction(mostSimple);
agenda.AddFacts(factlist);
agenda.Run();
agenda.VisualizeNetworkToFile(@"C:\Temp\CollectionTest.log", false);
Assert.IsTrue(agenda.TotalFacts == 11, "Bad");
Assert.IsTrue(agenda.ActionsTaken.Count == 1, "Bad");
Assert.IsTrue(agenda.ActionsSkipped.Count == 0, "Bad");
Assert.IsTrue(agenda.ActivatedRuleCount == 1, "Bad");
Assert.IsTrue(customer.Result != null && customer.Result.StartsWith("Shout"), "Did not invoke method.");
}
/**
* <summary>Called when adding a child to a parse tree
* node.</summary>
*
* <param name='node'>the parent node</param>
* <param name='child'>the child node, or null</param>
*
* <exception cref='ParseException'>if the node analysis
* discovered errors</exception>
*/
public override void Child(Production node, Node child)
{
switch (node.Id) {
case (int) DokiScriptConstants.DOKI:
ChildDoki(node, child);
break;
case (int) DokiScriptConstants.PART:
ChildPart(node, child);
break;
case (int) DokiScriptConstants.BLOCK:
ChildBlock(node, child);
break;
case (int) DokiScriptConstants.ACTION:
ChildAction(node, child);
break;
case (int) DokiScriptConstants.VOICE_ACTION:
ChildVoiceAction(node, child);
break;
case (int) DokiScriptConstants.OTHER_ACTION:
ChildOtherAction(node, child);
break;
case (int) DokiScriptConstants.TAG:
ChildTag(node, child);
break;
case (int) DokiScriptConstants.KEY:
ChildKey(node, child);
break;
case (int) DokiScriptConstants.VALUE:
ChildValue(node, child);
break;
case (int) DokiScriptConstants.FLAG:
ChildFlag(node, child);
break;
case (int) DokiScriptConstants.OPTION:
ChildOption(node, child);
break;
case (int) DokiScriptConstants.JUMP:
ChildJump(node, child);
break;
}
}
public override Node ExitProdStatements(Production node)
{
return(node);
}
public override Node ExitProdOutputStatement(Production node)
{
return(node);
}
public override void EnterProdFunctions(Production node)
{
}
public override Node ExitProdSizeTail(Production node)
{
return(node);
}
public override Node ExitProdObjectVarTail(Production node)
{
return(node);
}
public override void ChildProdObjectVarTail(Production node, Node child)
{
node.AddChild(child);
}
public override Node ExitProdTask(Production node)
{
return(node);
}
public override Node ExitProdIoStatement(Production node)
{
if (!runtime_error)
{
Node isRead = node.GetChildAt(0);
if (isRead.GetName() == "READ")
{
Node id = node.GetChildAt(1);
int idcol = id.GetStartColumn();
int idline = id.GetStartLine();
Tokens token = GetTokens(idline, idcol);
foreach (var item in identifiers)
{
if (item.getId() == token.getLexemes())
{
var input = Console.ReadLine();
string dtype = item.getDtype();
bool isneg = false;
switch (dtype)
{
case "Int":
int input_int = 0;
if (input.Contains("~"))
{
isneg = true;
input = input.Remove(0, 1);
}
if (Int32.TryParse(input, out input_int))
{
if (isneg)
{
input_int *= -1;
}
item.setValue(input_int.ToString());
}
else
{
runtime_error = true;
Console.WriteLine("");
Console.WriteLine("Runtime error: Type mismatch!");
}
break;
case "Double":
double input_double = 0;
if (input.Contains("~"))
{
isneg = true;
input = input.Remove(0, 1);
}
if (Double.TryParse(input, out input_double))
{
if (isneg)
{
input_double *= -1;
}
item.setValue(input_double.ToString());
}
else
{
runtime_error = true;
Console.WriteLine("");
Console.WriteLine("Runtime error: Type mismatch!");
}
break;
case "Char":
if (input.Count() < 2)
{
item.setValue(input);
}
else
{
runtime_error = true;
Console.WriteLine("");
Console.WriteLine("Runtime error: invalid character input.");
}
break;
case "String":
item.setValue(input);
break;
case "Boolean":
if (input == "Yes" || input == "No")
{
item.setValue(input);
}
else
{
runtime_error = true;
Console.WriteLine("");
Console.WriteLine("Runtime error: invalid boolean input.");
}
break;
default:
break;
}
}
}
}
}
return(node);
}
public override void EnterProdObjectVarTail(Production node)
{
}
public override void EnterProdPreIncdec(Production node)
{
}
public override void ChildProdIoStatement(Production node, Node child)
{
node.AddChild(child);
}
public override void ChildProdConcat(Production node, Node child)
{
node.AddChild(child);
}
public override Node ExitProdConcat(Production node)
{
return(node);
}
public override void EnterProdConcat(Production node)
{
}
public override void EnterProdStatements(Production node)
{
}
public override void EnterProdParamTail(Production node)
{
}
public override Node ExitProdReturnType(Production node)
{
return(node);
}
public override void EnterProdParameters(Production node)
{
}
public override void EnterProdReturnType(Production node)
{
}
public override void ChildProdReturnType(Production node, Node child)
{
node.AddChild(child);
}
public override void EnterProdTask(Production node)
{
}
public override void ChildProdFunctions(Production node, Node child)
{
node.AddChild(child);
}
public override void EnterProdSizeTail(Production node)
{
}
public override Node ExitProdFunctions(Production node)
{
return(node);
}
public override void ChildProdArray(Production node, Node child)
{
node.AddChild(child);
}
public override Node ExitProdParamTail(Production node)
{
return(node);
}
public override void EnterProdObjectElem(Production node)
{
}
public override Node ExitProdObjectElem(Production node)
{
return(node);
}
public override void EnterProdOutputStatement(Production node)
{
}
public override void ChildProdParamTail(Production node, Node child)
{
node.AddChild(child);
}
