/// <summary>
        /// Call point to start the processing.
        /// </summary>
        protected override void Process()
        {
            MessageLogSentInvoker("===========================================");
            MessageLogSentInvoker(" Comenzando proceso de análisis sintáctico");
            MessageLogSentInvoker("===========================================");

            SyntacticalRule startRule =
                SyntacticalRulesLibrary.Instance.StartRule;


            OnMatcherMatching(this,
                              new MatchingArgs(SyntacticalRulesLibrary.Instance.StartRule));

            TokenSequence inputTokens = new TokenSequence(startTokens);

            parsingResult = startRule.Match(ref inputTokens, out output);

            if (inputTokens.Count > 0)
            {
                // Not all tokens were matched, so the parsing process
                // was unsuccessfull.
                parsingResult = false;
            }

            ProcessFinishedInvoker();
        }
Ejemplo n.º 2
0
        private bool ProcessExpression(SymbolTable symbolTable)
        {
            // TODO: If there are performance problems, we could find a faster way to detect expressions than doing a full parse
            var tokenSequence = new TokenSequence(XValue);

            if (tokenSequence.RequiresProcessing)
            {
                if (tokenSequence.RequiresTemplateArguments)
                {
                    var templateInstance = TemplateInstance;
                    if (templateInstance == null || templateInstance.Template == null)
                    {
                        return(false);
                    }

                    XValue = tokenSequence.Process(symbolTable, templateInstance.ArgumentDictionary);
                }
                else
                {
                    XValue = tokenSequence.Process(symbolTable, null);
                }
            }

            return(true);
        }
Ejemplo n.º 3
0
        public void RepeaterTestCase()
        {
            TokenSequence sequence = new TokenSequence();

            Token t = new Token("NUMBER");

            t.Text = "200.9";
            sequence.Append(t);

            t      = new Token("ADD");
            t.Text = "+";
            sequence.Append(t);

            t      = new Token("NUMBER");
            t.Text = "14";
            sequence.Append(t);

            t      = new Token("ADD");
            t.Text = "+";
            sequence.Append(t);

            t      = new Token("NUMBER");
            t.Text = "28";
            sequence.Append(t);

            SyntacticalRule rule = new SyntacticalRule("formula");

            SyntacticalExpression exp = new SyntacticalExpression();

            exp.FormatString = "{0}{1}";

            ExpressionTokenItem eti = new ExpressionTokenItem();

            eti.TokenType = "NUMBER";
            exp.Items.Add(eti);

            ExpressionGroupItem group = new ExpressionGroupItem();

            group.Modifier = ExpressionItemModifier.RepeatingNonCompulsory;

            eti           = new ExpressionTokenItem();
            eti.TokenType = "ADD";
            group.ChildrenItems.Add(eti);

            eti           = new ExpressionTokenItem();
            eti.TokenType = "NUMBER";
            group.ChildrenItems.Add(eti);


            group.FormatString = " + {1}";
            exp.Items.Add(group);
            rule.Expressions.Add(exp);

            string output;
            bool   res = rule.Match(ref sequence, out output);

            Assert.IsTrue(res, "Matching wasn't succesfull");
            Assert.AreEqual("200.9 + 14 + 28", output, "Output isn't correct.'");
        }
Ejemplo n.º 4
0
 private void TokenCheckedInvoker(TokenSequence lastSequence, Token currentToken)
 {
     if (TokenChecked != null)
     {
         TokenChecked(this,
                      new TokenCheckedArgs(lastSequence, currentToken));
     }
 }
        private static string GenerateToken(this KernelCommand command)
        {
            var seed = command.Parent?.GetNextToken();

            var sequence = new TokenSequence(seed);

            command.Properties.Add(TokenKey, sequence);

            return(sequence.Current);
        }
		public void RepeaterTestCase()
		{
			TokenSequence sequence= new TokenSequence();
			
			Token t = new Token("NUMBER");
			t.Text="200.9";
			sequence.Append(t);
			
			t = new Token("ADD");
			t.Text="+";
			sequence.Append(t);
			
			t = new Token("NUMBER");
			t.Text="14";
			sequence.Append(t);
			
			t = new Token("ADD");
			t.Text="+";
			sequence.Append(t);
			
			t = new Token("NUMBER");
			t.Text="28";
			sequence.Append(t);
			
			SyntacticalRule rule = new SyntacticalRule("formula");
			
			SyntacticalExpression exp = new SyntacticalExpression();
			exp.FormatString="{0}{1}";
			
			ExpressionTokenItem eti = new ExpressionTokenItem();
			eti.TokenType = "NUMBER";
			exp.Items.Add(eti);
			
			ExpressionGroupItem group = new ExpressionGroupItem();
			group.Modifier = ExpressionItemModifier.RepeatingNonCompulsory;
			
			eti = new ExpressionTokenItem();
			eti.TokenType = "ADD";
			group.ChildrenItems.Add(eti);
			
			eti = new ExpressionTokenItem();
			eti.TokenType = "NUMBER";
			group.ChildrenItems.Add(eti);
			
			
			group.FormatString=" + {1}";
			exp.Items.Add(group);
			rule.Expressions.Add(exp);
			
			string output;
			bool res = rule.Match(ref sequence, out output);
			
			Assert.IsTrue(res, "Matching wasn't succesfull");
			Assert.AreEqual("200.9 + 14 + 28", output, "Output isn't correct.'");
		}
Ejemplo n.º 7
0
        private static bool BindExpression(ParserContext context, XObject xmlObject, string xmlValue, PropertyInfo boundProperty)
        {
            var tokenSequence = new TokenSequence(xmlValue);

            if (tokenSequence.RequiresProcessing)
            {
                DelayedBind(context, xmlObject, xmlValue, boundProperty);
                return(true);
            }

            return(false);
        }
		private Token TestToken(string text, LexicalRule rule)
		{
			TokenSequence tokens = new TokenSequence();
			foreach (char c in  text)
			{
				tokens.Append(new Token(c.ToString(), 0,0, new FloatBitmap(2,2)));
			}
			
			Token res;
			if(!rule.Match(tokens, out res))
				return null;
			
			return res;
		}
Ejemplo n.º 9
0
        private Token TestToken(string text, LexicalRule rule)
        {
            TokenSequence tokens = new TokenSequence();

            foreach (char c in  text)
            {
                tokens.Append(new Token(c.ToString(), 0, 0, new FloatBitmap(2, 2)));
            }

            Token res;

            if (!rule.Match(tokens, out res))
            {
                return(null);
            }

            return(res);
        }
		/// <summary>
		/// Retrives the related items for a token from the remaining items list.
		/// </summary>
		/// <param name="matched">
		/// The <see cref="Token"/> the items we are looking for are related to.
		/// </param>
		/// <param name="remainingItems">
		/// A <see cref="TokenSequence"/> containing the yet to be matched items.
		/// </param>
		/// <param name="position">
		/// A <see cref="ExpressionItemPosition"/> the position of the related item.
		/// </param>
		/// <returns>
		/// A <see cref="TokenSequence"/> containing the items related to the
		/// matched item found in the given position.
		/// </returns>
		protected TokenSequence GetRelatedItems(Token matched,
		                                        TokenSequence remainingItems, 
		                                        ExpressionItemPosition position)
		{
			TokenSequence sequence = new TokenSequence();
			
			string remainingItemsString = remainingItems.ToString();
			
			int i= 0;
			while (i < remainingItems.Count)
			{
				Token checkedItem = remainingItems[i];
				
				if(CheckTokenInRelatedSequence(matched, checkedItem, position))
				{
					sequence.Append(checkedItem);
					remainingItems.RemoveAt(i);
				}
				else if(!SpecialPosition(matched, checkedItem))
				{
					LogSentInvoker("Encontrado {0}, cancelando la creación de la secuencia de items «{1}» {2}",
					               checkedItem.Text,
					               position,
					               matched.Type);
					break;
				}
				else
				{
					i++;
				}
			}
			
			LogSentInvoker("Extraida la secuencia ({0}) en posicion «{1}» de entre los elementos de ({2})",
			               sequence,
			               position,
			               remainingItemsString);
			
			return sequence;
		}
		/// <summary>
		/// Handles the start of processing of a new node.
		/// </summary>
		/// <param name="sender">
		/// A <see cref="System.Object"/>
		/// </param>
		/// <param name="args">
		/// A <see cref="EventArgs"/>
		/// </param>
		private void OnControllerTokenChecked(object sender, 
		                                            TokenCheckedArgs args)
		{
			Application.Invoke(sender, args,
			                   delegate(object resender, EventArgs _args)
			{
				TokenCheckedArgs a = _args as TokenCheckedArgs;
			
				if(!sequencingFinished)
				{
					currentToken = a.CurrentToken;
					
				
					FloatBitmap sequenceImage;
					
					if(a.LastSequence!= null)
					{
						TokenSequence joinSeq = 
							new TokenSequence(a.LastSequence);
						lastToken = joinSeq.Last;	
						joinSeq.Append(currentToken);
						Token joinedToken =Token.Join(joinSeq, "");
						
						sequenceImage = joinedToken.Image;
						
					}
					else
					{
						sequenceImage = currentToken.Image;					
						lastToken = null;
					}
					
					// We add a border to the orginal image.
					
					Gdk.Pixbuf sequencePixbuf = sequenceImage.CreatePixbuf();
					
					Gdk.Pixbuf drawnImage = 
						new Gdk.Pixbuf(sequencePixbuf.Colorspace,false, 8, 
						               sequencePixbuf.Width+10, 
						               sequencePixbuf.Height+10);
					
					drawnImage.Fill(0xFFFFFFFF);
					
					sequencePixbuf.CopyArea(0, 0, 
				                        sequencePixbuf.Width, 
				                        sequencePixbuf.Height,
				                        drawnImage,
				                        5,5);
					
					if(lastToken!=null)
					{
						uint color;
						if(currentToken.CloseFollows(lastToken))
						{
							color = 0x00FF00;
							sequencingStepResultLbl.Markup = 
								String.Format("<b>Sí, el símbolo «{0}» se añadirá a la secuencia actual</b>",
								              currentToken.Text);
							
						}
						else
						{
							color = 0xFF0000;
							sequencingStepResultLbl.Markup = 
								String.Format("<b>No, «{0}» no puede ser considerado parte de la secuencia ({1})</b>",
								              currentToken.Text,
								              a.LastSequence.ToString());
						}
						
						
						Gdk.Pixbuf markedImage = drawnImage.Copy();
						
						// We paint the image of the color
						markedImage = 
							markedImage.CompositeColorSimple(markedImage.Width, 
							                                 markedImage.Height,
							                                 Gdk.InterpType.Nearest,
							                                 100, 1, color, color);
						
						// We are going to mark the image of the to symbols being considered
						// with their baselines.
						int min = int.MaxValue;
						foreach (Token t in a.LastSequence ) 
						{
							if(t.Top < min)
								min =t.Top;
						}
						
						int offset = Math.Min(min, currentToken.Top);
						int lastBaseline = lastToken.Baseline - offset;
						int currentBaseline = currentToken.Baseline - offset;
						
						markedImage.CopyArea(0, lastBaseline, 
						                     markedImage.Width, 5,
						                     drawnImage, 
						                     0,lastBaseline);
						
						markedImage.CopyArea(0, currentBaseline, 
						                     markedImage.Width,5, 
						                     drawnImage, 
						                     0,currentBaseline);
					}
					
							
					baselineImageArea.Image = drawnImage;
				}
				
				if(controller.StepMode == ControllerStepMode.StepByStep)
					tokenizingNextButtonsAlign.Sensitive = true;
			});
		}
		protected override bool MatchSequence(ref TokenSequence sequence, 
		                                      out string output)
		{
			
			output="";
			List<string> res = new List<string>();
			foreach (ExpressionItem item in childrenItems) 
			{
				string auxOutput;
				if(item.Match(ref sequence, out auxOutput))
				{
					res.Add(auxOutput);
				}
				else
				{
					
					return false;
				}	
				
			}
			output = String.Format(FormatString, res.ToArray());
			
			return true;
		}
		protected override bool MatchSequence (ref TokenSequence sequence, out string output)
		{
			// The actual matching is done by the rule.
			SyntacticalRule ruleCalled = 
				SyntacticalRulesLibrary.Instance[ruleName];
			
			bool res =  ruleCalled.Match(ref sequence, out output);
			if(res)
			{
				output = String.Format(formatString, output);
			}
			
			return res;
		}
		public override bool Match(ref TokenSequence sequence, out string output)
		{		

			string sequenceOriginal = sequence.ToString();
			MatchingInvoker();
			List<string> outputList = new List<string>();
			
			bool res;
			
			
			foreach (ExpressionItem item in items) 
			{
				string expressionString;
				res = item.Match(ref sequence,out expressionString);
				if(!res)
				{
					output="";				
					
					LogSentInvoker("La expresión «"
				               +this.Label
				               +"» falló el reconocimiento, restaurando la secuencia ("
				               +sequenceOriginal
				               +")");
					
					MatchingFinishedInvoker(output);
					return false;
				}
				
				outputList.Add(expressionString);
			}
			
			output = String.Format(formatString, outputList.ToArray());
			
		
			LogSentInvoker("La expresion «"
					       +this.Label
			               +"» tuvo exito al reconocer, se produjo la salida «"
			               +output
			               +"»");
			
			MatchingFinishedInvoker(output);
			
			return true;
		}
Ejemplo n.º 15
0
        public void SumAndMultTestCase()
        {
            TokenSequence sequence = new TokenSequence();

            Token t = new Token("NUMBER");

            t.Text = "200.9";
            sequence.Append(t);

            t      = new Token("ADD");
            t.Text = "+";
            sequence.Append(t);

            t      = new Token("NUMBER");
            t.Text = "28";
            sequence.Append(t);

            t      = new Token("MULT");
            t.Text = "x";
            sequence.Append(t);

            t      = new Token("NUMBER");
            t.Text = "14";
            sequence.Append(t);

            SyntacticalRulesLibrary.Instance.ClearRules();

            SyntacticalRule rule = new SyntacticalRule("multiplicacion");

            SyntacticalRulesLibrary.Instance.AddRule(rule);

            SyntacticalExpression exp = new SyntacticalExpression();

            exp.FormatString = "{0}{1}";

            ExpressionTokenItem eti = new ExpressionTokenItem();

            eti.TokenType = "NUMBER";
            exp.Items.Add(eti);

            ExpressionGroupItem group = new ExpressionGroupItem();

            group.Modifier = ExpressionItemModifier.RepeatingNonCompulsory;

            eti           = new ExpressionTokenItem();
            eti.TokenType = "MULT";
            group.ChildrenItems.Add(eti);

            eti           = new ExpressionTokenItem();
            eti.TokenType = "NUMBER";
            group.ChildrenItems.Add(eti);

            group.FormatString = " x {1}";
            exp.Items.Add(group);
            rule.Expressions.Add(exp);

            rule = new SyntacticalRule("formula");
            SyntacticalRulesLibrary.Instance.AddRule(rule);

            exp = new SyntacticalExpression();
            exp.FormatString = "{0}{1}";

            ExpressionRuleCallItem esi = new ExpressionRuleCallItem();

            esi.RuleName = "multiplicacion";
            exp.Items.Add(esi);

            group          = new ExpressionGroupItem();
            group.Modifier = ExpressionItemModifier.RepeatingNonCompulsory;

            eti           = new ExpressionTokenItem();
            eti.TokenType = "ADD";
            group.ChildrenItems.Add(eti);

            esi          = new ExpressionRuleCallItem();
            esi.RuleName = "multiplicacion";
            group.ChildrenItems.Add(esi);


            group.FormatString = " + {1}";
            exp.Items.Add(group);
            rule.Expressions.Add(exp);



            string output;
            bool   res = rule.Match(ref sequence, out output);

            Assert.IsTrue(res, "Matching wasn't succesfull");
            Assert.AreEqual("200.9 + 28 x 14", output, "Output isn't correct.'");
        }
		/// <summary>
		/// Matches a given token sequence into one or more Tokens.
		/// </summary>
		/// <param name="sequence">
		/// The token sequence (possibly) containing tokens.
		/// </param>
		private void MatchTokens(SequenceNode node)
		{			
			
			TokenSequence discarded = new TokenSequence();
			
			TokenSequence accepted = new TokenSequence();
			SequenceNode acceptedNode = new SequenceNode(accepted, view);
			SequenceNode discardedNode = new SequenceNode(discarded, view);
			TokenSequence sequence = node.Sequence;
			
			node.AddChildSequence(acceptedNode);
			
			foreach (Token t in sequence) 
			{
				accepted.Append(t);
			}
			
			NodeBeingProcessedInvoker(node);
			SuspendByStep();
			
			bool found = false;
			Token foundToken = null;		
			
			bool discardedNodeAdded = false;
			
			MessageLogSentInvoker("===== Tratando la secuencia {0} =====", 
			                      node.NodeName);
			
			while(accepted.Count > 0 && !found)
			{
				
				
				foreach (LexicalRule rule in lexicalRules) 
				{
					found = rule.Match(accepted, out foundToken);
				
					MessageLogSentInvoker("¿La regla «{0}» acepta la secuencia ({1})?: {2}", 
					                      rule.Name,
					                      accepted.ToString(),
					                      found?"Sí":"No");
					
					SequenceBeingMatchedInvoker(foundToken, rule, found);
					SuspendByStep();
					
					if(found)
					{
						// We search no more.
						break;
					}				
					Thread.Sleep(50);
				}
				
				// We check if a token was found
				if(!found)
				{
					// We remove the token from the input sequence and add it
					// at the beggining of the discarded set.
					int lastIndex = accepted.Count -1;
					if(!discardedNodeAdded)
					{
						// If we haven't done so, we add the discarded sequence.
						node.AddChildSequence(discardedNode);
						discardedNodeAdded = true;
					}
					
					this.MatchingFailedInvoker();
					
					MessageLogSentInvoker("Se elimina el último símbolo de la secuencia {0} para seguir probando.",
					                      accepted.ToString());
						
					discarded.Prepend(accepted[lastIndex]);
					
					accepted.RemoveAt(lastIndex);				
					
				}
				else
				{
					// We found a token, so we stop searching and add
					// the token to the result.
					acceptedNode.FoundToken = foundToken;
				}
			}
			
		
			
			if(found && discarded.Count > 0)
			{
				MessageLogSentInvoker("Se tratará la secuencia de símbolos descartados.");
				// We follow the recursive path.
				MatchTokens(discardedNode);
			}
			else if(found && discarded.Count ==0)
			{
				// Only one token was found, we assimilate the acceptedNode
				// with its parent.
				node.FoundToken = foundToken;
				node.RemoveSequenceChildren();
			}
			else
			{
				// If nothing was found, we remove the children.
				node.RemoveSequenceChildren();
				
				MessageLogSentInvoker("No se pudo reconocer la secuencia {0}.",
					                   node.Sequence.ToString());
			}
			
			StepDoneInvoker();
			SuspendByNode();
		}
		/// <summary>
		/// Processes the tokens given as an input to the controller.
		/// </summary>
		/// <returns>
		/// The list of sequences of contiguous tokens.
		/// </returns>
		private List<SequenceNode> GetTokenSequences()
		{
			List<SequenceNode> tokenSequences = new List<SequenceNode>();
		
			SequenceNode node = null;
			Token lastToken = null;
			Token currentToken = null;
			// All the tokens must be in one sequence.
			while(this.tokens.Count > 0)
			{	
				TokenSequence foundSequence = null;
				
				currentToken = tokens[0];
				
				NodeBeingProcessedInvoker(null);					
				
				if(tokenSequences.Count ==0)
					TokenCheckedInvoker(null, currentToken);
				
				foreach (SequenceNode storedNode in tokenSequences) 
				{					
					// We search the stored sequences so we may find one that
					// has the same baseline as the one being checked.
					storedNode.Select();
					
					this.MessageLogSentInvoker("Comprobando si «{0}» puede formar parte de la secuencia {1}",
					                           currentToken.Text,
					                           storedNode.NodeName);
					
					lastToken = storedNode.Sequence.Last;
					
					TokenCheckedInvoker(new TokenSequence(storedNode.Sequence),
					                    currentToken);
					if(tokenSequences.Count>1)
						SuspendByStep();
					
					if(currentToken.CloseFollows(lastToken))
					{
						foundSequence = storedNode.Sequence;
						break;
					}
					
					Thread.Sleep(50);
					
				}
				
				
				
				if(foundSequence == null)
				{
					// If the symbols aren't contiguous, a new sequence has
					// commenced.
					foundSequence = new TokenSequence();	
					node = new SequenceNode(foundSequence, view);
					tokenSequences.Add(node);
					node.NodeName = tokenSequences.Count.ToString();
					SequenceAddedInvoker(node);
					MessageLogSentInvoker("===== Secuencia {0} añadida =====", 
					                      node.NodeName);
				}
				
				
				
				// We add the token to the current sequence, and remove it
				// from the inital token list.
				foundSequence.Append(currentToken);
				MessageLogSentInvoker("Símbolo «{0}» añadido a la secuencia {1}", 
				                      currentToken.Text,
				                      node.NodeName);	
				
				StepDoneInvoker();				
				SuspendByNode();
				
				
				tokens.RemoveAt(0);
			}
			
			return tokenSequences;
			
		}
Ejemplo n.º 18
0
		public SequenceSetArgs(TokenSequence newSequence)
		{
			this.newSequence = newSequence;
		}
Ejemplo n.º 19
0
		private void SequenceRestoredInvoker(TokenSequence backupSequence)
		{
			if(SequenceRestored != null)
			{
				SequenceRestored(this, 
				                 new SequenceSetArgs(backupSequence));
			}
		}
Ejemplo n.º 20
0
		/// <summary>
		/// Tries to math a <see cref="TokenSequence"/> with the rule's 
		/// expressions.
		/// </summary>
		/// <param name="sequence">
		/// The <see cref="TokenSequence"/> we want to match.
		/// </param>
		/// <param name="text">
		/// The <see cref="System.String"/> output text produced by the
		/// expression that matched the input sequence.
		/// </param>
		/// <returns>
		/// <c>true</c> it the sequence was matched correctly, <c>false</c>
		/// if there were errors.
		/// </returns>
		public override bool Match(ref TokenSequence sequence, out string text)
		{
			
			TokenSequence backupSequence = new TokenSequence(sequence);
			
			this.LogSentInvoker("Se intentará aplicar la regla «{0}»",
			                    this.Label);

			foreach (SyntacticalExpression expression in expressions)  
			{
				this.LogSentInvoker("Se intentará aplicar la expresión «"
				                    +expression.Label
				                    +"»");
				string expressionRes;
				
				if(expression.Match(ref sequence, out expressionRes))
				{
					// If the matching is successful, we consider 
					// the output valid.
					text = expressionRes;
					
					return true;
				}
				else
				{
					sequence = new TokenSequence(backupSequence);						
					SequenceRestoredInvoker(sequence);
				}
			}
			
			text ="";
			return false;
		}
		private void RelatedSequenceSetInvoker(TokenSequence relatedSequence)
		{
			if(RelatedSequenceSet != null)
			{
				RelatedSequenceSet(this, 
				                   new SequenceSetArgs(relatedSequence));
			}
		}
		private void TokenCheckedInvoker(TokenSequence lastSequence, Token currentToken)
		{
			if(TokenChecked !=null)
			{
				TokenChecked(this, 
				             new TokenCheckedArgs(lastSequence, currentToken));
			}
		}
		public abstract bool Match(ref TokenSequence sequence, out string text);
		public void SumAndMultTestCase()
		{
			TokenSequence sequence= new TokenSequence();
			
			Token t = new Token("NUMBER");
			t.Text="200.9";
			sequence.Append(t);
			
			t = new Token("ADD");
			t.Text="+";
			sequence.Append(t);
			
			t = new Token("NUMBER");
			t.Text="28";
			sequence.Append(t);
			
			t = new Token("MULT");
			t.Text="x";
			sequence.Append(t);
			
			t = new Token("NUMBER");
			t.Text="14";
			sequence.Append(t);			
			
			SyntacticalRulesLibrary.Instance.ClearRules();
			
			SyntacticalRule rule = new SyntacticalRule("multiplicacion");
			SyntacticalRulesLibrary.Instance.AddRule(rule);
			
			SyntacticalExpression exp = new SyntacticalExpression();
			exp.FormatString="{0}{1}";
			
			ExpressionTokenItem eti = new ExpressionTokenItem();
			eti.TokenType = "NUMBER";
			exp.Items.Add(eti);
			
			ExpressionGroupItem group = new ExpressionGroupItem();
			group.Modifier = ExpressionItemModifier.RepeatingNonCompulsory;
			
			eti = new ExpressionTokenItem();
			eti.TokenType = "MULT";
			group.ChildrenItems.Add(eti);
			
			eti = new ExpressionTokenItem();
			eti.TokenType = "NUMBER";
			group.ChildrenItems.Add(eti);
			
			group.FormatString=" x {1}";
			exp.Items.Add(group);
			rule.Expressions.Add(exp);
			
			rule = new SyntacticalRule("formula");
			SyntacticalRulesLibrary.Instance.AddRule(rule);
			
			exp = new SyntacticalExpression();
			exp.FormatString="{0}{1}";
			
			ExpressionRuleCallItem esi = new ExpressionRuleCallItem();
			esi.RuleName = "multiplicacion";
			exp.Items.Add(esi);
			
			group = new ExpressionGroupItem();
			group.Modifier = ExpressionItemModifier.RepeatingNonCompulsory;
			
			eti = new ExpressionTokenItem();
			eti.TokenType = "ADD";
			group.ChildrenItems.Add(eti);
			
			esi = new ExpressionRuleCallItem();
			esi.RuleName = "multiplicacion";
			group.ChildrenItems.Add(esi);
			
			
			group.FormatString=" + {1}";
			exp.Items.Add(group);
			rule.Expressions.Add(exp);
			
			
			
			string output;
			bool res = rule.Match(ref sequence, out output);
			
			Assert.IsTrue(res, "Matching wasn't succesfull");
			Assert.AreEqual("200.9 + 28 x 14", output, "Output isn't correct.'");
		}
Ejemplo n.º 25
0
        /// <summary>
        /// Matches a given token sequence into one or more Tokens.
        /// </summary>
        /// <param name="sequence">
        /// The token sequence (possibly) containing tokens.
        /// </param>
        private void MatchTokens(SequenceNode node)
        {
            TokenSequence discarded = new TokenSequence();

            TokenSequence accepted      = new TokenSequence();
            SequenceNode  acceptedNode  = new SequenceNode(accepted, view);
            SequenceNode  discardedNode = new SequenceNode(discarded, view);
            TokenSequence sequence      = node.Sequence;

            node.AddChildSequence(acceptedNode);

            foreach (Token t in sequence)
            {
                accepted.Append(t);
            }

            NodeBeingProcessedInvoker(node);
            SuspendByStep();

            bool  found      = false;
            Token foundToken = null;

            bool discardedNodeAdded = false;

            MessageLogSentInvoker("===== Tratando la secuencia {0} =====",
                                  node.NodeName);

            while (accepted.Count > 0 && !found)
            {
                foreach (LexicalRule rule in lexicalRules)
                {
                    found = rule.Match(accepted, out foundToken);

                    MessageLogSentInvoker("¿La regla «{0}» acepta la secuencia ({1})?: {2}",
                                          rule.Name,
                                          accepted.ToString(),
                                          found?"Sí":"No");

                    SequenceBeingMatchedInvoker(foundToken, rule, found);
                    SuspendByStep();

                    if (found)
                    {
                        // We search no more.
                        break;
                    }
                    Thread.Sleep(50);
                }

                // We check if a token was found
                if (!found)
                {
                    // We remove the token from the input sequence and add it
                    // at the beggining of the discarded set.
                    int lastIndex = accepted.Count - 1;
                    if (!discardedNodeAdded)
                    {
                        // If we haven't done so, we add the discarded sequence.
                        node.AddChildSequence(discardedNode);
                        discardedNodeAdded = true;
                    }

                    this.MatchingFailedInvoker();

                    MessageLogSentInvoker("Se elimina el último símbolo de la secuencia {0} para seguir probando.",
                                          accepted.ToString());

                    discarded.Prepend(accepted[lastIndex]);

                    accepted.RemoveAt(lastIndex);
                }
                else
                {
                    // We found a token, so we stop searching and add
                    // the token to the result.
                    acceptedNode.FoundToken = foundToken;
                }
            }



            if (found && discarded.Count > 0)
            {
                MessageLogSentInvoker("Se tratará la secuencia de símbolos descartados.");
                // We follow the recursive path.
                MatchTokens(discardedNode);
            }
            else if (found && discarded.Count == 0)
            {
                // Only one token was found, we assimilate the acceptedNode
                // with its parent.
                node.FoundToken = foundToken;
                node.RemoveSequenceChildren();
            }
            else
            {
                // If nothing was found, we remove the children.
                node.RemoveSequenceChildren();

                MessageLogSentInvoker("No se pudo reconocer la secuencia {0}.",
                                      node.Sequence.ToString());
            }

            StepDoneInvoker();
            SuspendByNode();
        }
		/// <summary>
		/// Call point to start the processing.
		/// </summary>
		protected override void Process ()
		{
			MessageLogSentInvoker("===========================================");
			MessageLogSentInvoker(" Comenzando proceso de análisis sintáctico");
			MessageLogSentInvoker("===========================================");
			
			SyntacticalRule startRule = 
				SyntacticalRulesLibrary.Instance.StartRule;
		
					
			OnMatcherMatching(this,
			                  new MatchingArgs(SyntacticalRulesLibrary.Instance.StartRule));
				
			TokenSequence inputTokens = new TokenSequence(startTokens);
			parsingResult = startRule.Match(ref inputTokens, out output);
			
			if(inputTokens.Count > 0)
			{
				// Not all tokens were matched, so the parsing process
				// was unsuccessfull.
				parsingResult = false;
			}
			
			ProcessFinishedInvoker();
		}
Ejemplo n.º 27
0
        /// <summary>
        /// Processes the tokens given as an input to the controller.
        /// </summary>
        /// <returns>
        /// The list of sequences of contiguous tokens.
        /// </returns>
        private List <SequenceNode> GetTokenSequences()
        {
            List <SequenceNode> tokenSequences = new List <SequenceNode>();

            SequenceNode node         = null;
            Token        lastToken    = null;
            Token        currentToken = null;

            // All the tokens must be in one sequence.
            while (this.tokens.Count > 0)
            {
                TokenSequence foundSequence = null;

                currentToken = tokens[0];

                NodeBeingProcessedInvoker(null);

                if (tokenSequences.Count == 0)
                {
                    TokenCheckedInvoker(null, currentToken);
                }

                foreach (SequenceNode storedNode in tokenSequences)
                {
                    // We search the stored sequences so we may find one that
                    // has the same baseline as the one being checked.
                    storedNode.Select();

                    this.MessageLogSentInvoker("Comprobando si «{0}» puede formar parte de la secuencia {1}",
                                               currentToken.Text,
                                               storedNode.NodeName);

                    lastToken = storedNode.Sequence.Last;

                    TokenCheckedInvoker(new TokenSequence(storedNode.Sequence),
                                        currentToken);
                    if (tokenSequences.Count > 1)
                    {
                        SuspendByStep();
                    }

                    if (currentToken.CloseFollows(lastToken))
                    {
                        foundSequence = storedNode.Sequence;
                        break;
                    }

                    Thread.Sleep(50);
                }



                if (foundSequence == null)
                {
                    // If the symbols aren't contiguous, a new sequence has
                    // commenced.
                    foundSequence = new TokenSequence();
                    node          = new SequenceNode(foundSequence, view);
                    tokenSequences.Add(node);
                    node.NodeName = tokenSequences.Count.ToString();
                    SequenceAddedInvoker(node);
                    MessageLogSentInvoker("===== Secuencia {0} añadida =====",
                                          node.NodeName);
                }



                // We add the token to the current sequence, and remove it
                // from the inital token list.
                foundSequence.Append(currentToken);
                MessageLogSentInvoker("Símbolo «{0}» añadido a la secuencia {1}",
                                      currentToken.Text,
                                      node.NodeName);

                StepDoneInvoker();
                SuspendByNode();


                tokens.RemoveAt(0);
            }

            return(tokenSequences);
        }
Ejemplo n.º 28
0
        /// <summary>
        /// Handles the start of processing of a new node.
        /// </summary>
        /// <param name="sender">
        /// A <see cref="System.Object"/>
        /// </param>
        /// <param name="args">
        /// A <see cref="EventArgs"/>
        /// </param>
        private void OnControllerTokenChecked(object sender,
                                              TokenCheckedArgs args)
        {
            Application.Invoke(sender, args,
                               delegate(object resender, EventArgs _args)
            {
                TokenCheckedArgs a = _args as TokenCheckedArgs;

                if (!sequencingFinished)
                {
                    currentToken = a.CurrentToken;


                    FloatBitmap sequenceImage;

                    if (a.LastSequence != null)
                    {
                        TokenSequence joinSeq =
                            new TokenSequence(a.LastSequence);
                        lastToken = joinSeq.Last;
                        joinSeq.Append(currentToken);
                        Token joinedToken = Token.Join(joinSeq, "");

                        sequenceImage = joinedToken.Image;
                    }
                    else
                    {
                        sequenceImage = currentToken.Image;
                        lastToken     = null;
                    }

                    // We add a border to the orginal image.

                    Gdk.Pixbuf sequencePixbuf = sequenceImage.CreatePixbuf();

                    Gdk.Pixbuf drawnImage =
                        new Gdk.Pixbuf(sequencePixbuf.Colorspace, false, 8,
                                       sequencePixbuf.Width + 10,
                                       sequencePixbuf.Height + 10);

                    drawnImage.Fill(0xFFFFFFFF);

                    sequencePixbuf.CopyArea(0, 0,
                                            sequencePixbuf.Width,
                                            sequencePixbuf.Height,
                                            drawnImage,
                                            5, 5);

                    if (lastToken != null)
                    {
                        uint color;
                        if (currentToken.CloseFollows(lastToken))
                        {
                            color = 0x00FF00;
                            sequencingStepResultLbl.Markup =
                                String.Format("<b>Sí, el símbolo «{0}» se añadirá a la secuencia actual</b>",
                                              currentToken.Text);
                        }
                        else
                        {
                            color = 0xFF0000;
                            sequencingStepResultLbl.Markup =
                                String.Format("<b>No, «{0}» no puede ser considerado parte de la secuencia ({1})</b>",
                                              currentToken.Text,
                                              a.LastSequence.ToString());
                        }


                        Gdk.Pixbuf markedImage = drawnImage.Copy();

                        // We paint the image of the color
                        markedImage =
                            markedImage.CompositeColorSimple(markedImage.Width,
                                                             markedImage.Height,
                                                             Gdk.InterpType.Nearest,
                                                             100, 1, color, color);

                        // We are going to mark the image of the to symbols being considered
                        // with their baselines.
                        int min = int.MaxValue;
                        foreach (Token t in a.LastSequence)
                        {
                            if (t.Top < min)
                            {
                                min = t.Top;
                            }
                        }

                        int offset          = Math.Min(min, currentToken.Top);
                        int lastBaseline    = lastToken.Baseline - offset;
                        int currentBaseline = currentToken.Baseline - offset;

                        markedImage.CopyArea(0, lastBaseline,
                                             markedImage.Width, 5,
                                             drawnImage,
                                             0, lastBaseline);

                        markedImage.CopyArea(0, currentBaseline,
                                             markedImage.Width, 5,
                                             drawnImage,
                                             0, currentBaseline);
                    }


                    baselineImageArea.Image = drawnImage;
                }

                if (controller.StepMode == ControllerStepMode.StepByStep)
                {
                    tokenizingNextButtonsAlign.Sensitive = true;
                }
            });
        }
Ejemplo n.º 29
0
		public SequenceNode(TokenSequence sequence, NodeView widget)
		{
			this.sequence = sequence;			
			this.sequence.Changed += new EventHandler(OnSequenceChanged);	
			this.widget = widget;
		}
		/// <summary>
		/// Tries to match the expetect token with one from the given sequence.
		/// </summary>
		/// <param name="sequence">
		/// A <see cref="TokenSequence"/> containing the items not yet matched.
		/// </param>
		/// <param name="output">
		/// The output in a <see cref="System.String"/>.
		/// </param>
		/// <returns>
		/// A <see cref="System.Boolean"/> that tells if the matching process
		/// was successful.
		/// </returns>
		protected override bool MatchSequence (ref TokenSequence sequence, 
		                                       out string output)
		{
			
			output ="";
			int idx = 0;
			
			// We tell the controller we are trying to match this token.			
			TokenMatchingInvoker(this.TokenType);
			
			if(forceTokenSearch)
			{
				idx = sequence.SearchToken(this.tokenType);
				LogSentInvoker("Forzada búsqueda de {0}, posición {1}",
				               this.tokenType,
				               idx);
			}		
			
			
			// By default, we say we had a success
			bool res = true;
			Token matched = null;
			
			
			
			if(idx==-1)
			{
				LogSentInvoker("El item esperado {0} no fue encontrado.", this.tokenType);
				res = !IsCompulsory;
			}			
			else
			{
				bool different;
			
				// If the token type is a literal, we compare with the text
				// instead of the type.
				if(this.tokenType.StartsWith("'")
				   && this.tokenType.EndsWith("'"))
				{
					string expectedText = tokenType.Substring(1,
					                                          this.tokenType.Length -2) ;
					different =expectedText != sequence[idx].Text;
				}
				else
				{
					different = tokenType != sequence[idx].Type;
				}
				
				if(different)
				{
					LogSentInvoker("El item esperado {0} no fue encontrado.", this.tokenType);
					res = !IsCompulsory;
				}
				else
				{
					matched = sequence.RemoveAt(idx);				
					if(this.relatedItems.Count ==0)
					{
						output= String.Format(formatString, matched.Text);
					}
					else
					{
						res = MatchRelatedItems(matched, ref sequence, out output);
						if(!res)
						{
							matched = null;
						}
						
						RelatedSequenceSetInvoker(sequence);
					}
				}
				
				
				
			}
			
			
						
			// We tell the controller we finished matching the token.
			TokenMatchingFinishedInvoker(matched, this.tokenType);
			
			return res;
			
		}
Ejemplo n.º 31
0
 public SequenceSetArgs(TokenSequence newSequence)
 {
     this.newSequence = newSequence;
 }
		/// <summary>
		/// Tries to match the token's related items.
		/// </summary>
		/// <param name="matched">
		/// The <see cref="Token"/> matched token.  
		/// </param>
		/// <param name="sequence">
		/// The remaining tokens.
		/// </param>
		/// <param name="output">
		/// A <see cref="System.String"/> containing the output.
		/// </param>
		/// <returns>
		/// A <see cref="System.Boolean"/> indicating if the matching was 
		/// successfull.
		/// </returns>
		private bool MatchRelatedItems(Token matched, 
		                               ref TokenSequence sequence, 
		                               out string output)
		{
			output = "";
			
			// We return true unless we found a matching error in one of the
			// related items.
			bool res = true;
			
			// We have to create a list of outputs, so we can apply the 
			// output format string later.
			List<string> outputs = new List<string>();
			
			// We add the matched token own text as the first element
			outputs.Add(matched.Text); 
			
			foreach(ExpressionItem relatedItem in this.relatedItems)
			{
				
				TokenSequence backupSequence = new TokenSequence(sequence);
				string relatedItemOutput;
				TokenSequence relatedRemnant = 
					GetRelatedItems(matched,sequence,relatedItem.Position);
				
				

				LogSentInvoker("Reconociendo los items relacionados ({0}) de {1} con el elemento «{2}»",
				               relatedRemnant,
				               matched.Type,
				               relatedItem.ToString());
				
				RelatedSequenceSetInvoker(relatedRemnant);
				
				bool matchRes =
					relatedItem.Match(ref relatedRemnant, out relatedItemOutput);
				if(matchRes)
				{
					outputs.Add(relatedItemOutput);
					
					if(relatedRemnant.Count > 0)
					{
						// We weren't unable to match all the tokens,
						// so we have to restore partially.
						
						sequence = backupSequence;
						int i =0;
						while(i<sequence.Count)
						{
							if(!relatedRemnant.Sequence.Contains(sequence[i]))
							{
								sequence.Sequence.Remove(sequence[i]);
							}
							else
							{
								i++;
							}
						}
						
					}
				}
				else if(!relatedItem.IsCompulsory)
				{
					// We can fail, because then we may be removing tokens useful
					// to later rules;
					outputs.Add("");
					sequence = backupSequence;
				}
				else
				{
					res = false;
					break;
				}
			}				
			
			if(res)
			{
				output = String.Format(this.formatString, outputs.ToArray());
			}
			
			return res;
		}
		public TokenCheckedArgs (TokenSequence lastSequence, Token currentToken)
			: base ()
		{
			this.lastSequence = lastSequence;
			this.currentToken= currentToken;
		}
Ejemplo n.º 34
0
		/// <summary>
		/// Tries to match a given token sequence with this rule.
		/// </summary>
		/// <param name="tokens">
		/// The tokens we try to group.
		/// </param>		
		/// <param name="foundToken">
		/// The token result of joining the sequence, has a meaning or not.
		/// </param>
		/// <returns>
		/// If a valid token was found.
		/// </returns>
		public bool Match(TokenSequence tokens, out Token foundToken)
		{
			// We form the expression to be matched.
			string text = "";
			foreach(Token t in tokens)
			{
				if(!String.IsNullOrEmpty(t.Type))
				{
					text += String.Format("%%{0}%%", t.Type);
				}
				else
				{
					text += t.Text;
				}
			}
			
			if(regularExpressions == null)
			{				
				// We have to load the expressions.
				regularExpressions = new List<Regex>();
				foreach(string pattern in lexicalExpressions)
				{
					// We add the modifiers to apply the regex to all the 
					// text.
					Regex regex = new Regex(String.Format("^{0}$",pattern),
					                        RegexOptions.Compiled 
					                        |RegexOptions.Singleline);
					
					regularExpressions.Add(regex);
				}
			}
			
			bool found = false;
			
			// Now we try to match a rule with the text.
			foreach(Regex expression in regularExpressions)
			{
				Match match = expression.Match(text);
				if(match.Success)
				{
					found = true;
					break;
				}
			}			
			
			foundToken = Token.Join(tokens, this.ruleName);
			
			return found;
		}
Ejemplo n.º 35
0
 public TokenCheckedArgs(TokenSequence lastSequence, Token currentToken)
     : base()
 {
     this.lastSequence = lastSequence;
     this.currentToken = currentToken;
 }
Ejemplo n.º 36
0
 public SequenceNode(TokenSequence sequence, NodeView widget)
 {
     this.sequence          = sequence;
     this.sequence.Changed += new EventHandler(OnSequenceChanged);
     this.widget            = widget;
 }