Eliza key.
Eliza key. A key has the key itself, a rank, and a list of decompositon rules.
示例#1
0
		public virtual void Copy(Key k)
		{
			key = k.GetKey();
			rank = k.Rank();
			decomp = k.Decomp();
		}
示例#2
0
		/// <summary>Decompose a string according to the given key.</summary>
		/// <remarks>
		/// Decompose a string according to the given key. Try each decomposition
		/// rule in order. If it matches, assemble a reply and return it. If assembly
		/// fails, try another decomposition rule. If assembly is a goto rule, return
		/// null and give the key. If assembly succeeds, return the reply;
		/// </remarks>
		private string Decompose(Key key, string s, Key gotoKey)
		{
			string[] reply = new string[10];
			for (int i = 0; i < key.Decomp().Count; i++)
			{
				Decomp d = (Decomp)key.Decomp()[i];
				string pat = d.Pattern();
				if (syns.MatchDecomp(s, pat, reply))
				{
					string rep = Assemble(d, reply, gotoKey);
					if (rep != null)
					{
						return rep;
					}
					if (gotoKey.GetKey() != null)
					{
						return null;
					}
				}
			}
			return null;
		}
示例#3
0
		/// <summary>Assembly a reply from a decomp rule and the input.</summary>
		/// <remarks>
		/// Assembly a reply from a decomp rule and the input. If the reassembly rule
		/// is goto, return null and give the gotoKey to use. Otherwise return the
		/// response.
		/// </remarks>
		private string Assemble(Decomp d, string[] reply, Key gotoKey)
		{
			string[] lines = new string[3];
			d.StepRule();
			string rule = d.NextRule();
			if (EString.Match(rule, "goto *", lines))
			{
				// goto rule -- set gotoKey and return false.
				gotoKey.Copy(keys.GetKey(lines[0]));
				if (gotoKey.GetKey() != null)
				{
					return null;
				}
				ConsoleSurrogate.WriteLine("Goto rule did not match key: " + lines[0]);
				return null;
			}
			string work = string.Empty;
			while (EString.Match(rule, "* (#)*", lines))
			{
				// reassembly rule with number substitution
				rule = lines[2];
				// there might be more
				int n = 0;
				try
				{
					n = int.Parse(lines[1]) - 1;
				}
				catch (FormatException)
				{
					ConsoleSurrogate.WriteLine("Number is wrong in reassembly rule " + lines[1]);
				}
				if (n < 0 || n >= reply.Length)
				{
					ConsoleSurrogate.WriteLine("Substitution number is bad " + lines[1]);
					return null;
				}
				reply[n] = post.Translate(reply[n]);
				work += lines[0] + " " + reply[n];
			}
			work += rule;
			if (d.Mem())
			{
				mem.Save(work);
				return null;
			}
			return work;
		}
示例#4
0
		/// <summary>Process a sentence.</summary>
		/// <remarks>
		/// Process a sentence. (1) Make pre transformations. (2) Check for quit
		/// word. (3) Scan sentence for keys, build key stack. (4) Try decompositions
		/// for each key.
		/// </remarks>
		private string Sentence(string s)
		{
			s = pre.Translate(s);
			s = EString.Pad(s);
			if (quit.Find(s))
			{
				finished = true;
				return finl;
			}
			keys.BuildKeyStack(keyStack, s);
			for (int i = 0; i < keyStack.KeyTop(); i++)
			{
				Key gotoKey = new Key();
				string reply = Decompose(keyStack.Key(i), s, gotoKey);
				if (reply != null)
				{
					return reply;
				}
				// If decomposition returned gotoKey, try it
				while (gotoKey.GetKey() != null)
				{
					reply = Decompose(gotoKey, s, gotoKey);
					if (reply != null)
					{
						return reply;
					}
				}
			}
			return null;
		}