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); }