private static IEnumerable<IProduction> ZeroOrOne(INonTerminal identifier, ITerminal[] terminals)
 {
     // NonTerminal -> Terminal | <null>
     return new[]{
             new Production(identifier, terminals),
             new Production(identifier) };
 }

 public Shell(ITerminal Term)
 {
     timer = timerReset;
     term = Term;
     allPrograms = new List<Program>();
     editMode = false;
 }

 public override void SubscriptionToTerminalEvents(ITerminal terminal)
 {
     terminal.OutgoingRequest += (sender, info) =>
     {
         Console.ForegroundColor = ConsoleColor.Yellow;
         Console.WriteLine(info.ToString());
         Console.ForegroundColor = ConsoleColor.Gray;
     };
     terminal.IncomingRequest += (sender, info) =>
     {
         Console.ForegroundColor = ConsoleColor.Yellow;
         Console.WriteLine(info.ToString());
         Console.ForegroundColor = ConsoleColor.Gray;
     };
     terminal.StateChanged += (sender, state) => { Console.WriteLine(sender.ToString() + " - " + state); };
     terminal.AnsweredTheCall += (sender, args) =>
     {
         Console.ForegroundColor = ConsoleColor.Blue;
         Console.WriteLine(sender.ToString() + " answered the call");
         Console.ForegroundColor = ConsoleColor.Gray;
     };
     terminal.DroppedTheCall += (sender, args) =>
     {
         Console.ForegroundColor = ConsoleColor.Blue;
             Console.WriteLine(sender.ToString() + " dropped the call");
         Console.ForegroundColor = ConsoleColor.Gray;
     };
 }

        public void AddTerminal(ITerminal terminal)
        {
            if (terminal == null) throw new ArgumentNullException(nameof(terminal));

            RegisterTerminal(terminal);
            _terminals.Add(terminal);
        }

		private void DisplayTcpServerInfo(TcpServer server, ITerminal output)
		{
			this.DisplayListenerInfo(server, output);

			if(!server.IsListening)
				return;

			output.WriteLine();
			output.Write(TerminalColor.DarkMagenta, "ID\t");
			output.Write(TerminalColor.DarkMagenta, ResourceUtility.GetString("${LastReceivedTime}") + "\t\t");
			output.Write(TerminalColor.DarkMagenta, ResourceUtility.GetString("${LastSendTime}") + "\t\t");
			output.Write(TerminalColor.DarkMagenta, ResourceUtility.GetString("${LocalEndPoint}") + "\t\t");
			output.WriteLine(TerminalColor.DarkMagenta, ResourceUtility.GetString("${RemoteEndPoint}") + "\t");

			var channels = server.ChannelManager.GetActivedChannels();

			foreach(TcpServerChannel channel in channels)
			{
				if(channel == this.Channel)
					output.Write(TerminalColor.Magenta, "* ");

				output.WriteLine(
					"{0}\t{1:yyyy-MM-dd HH:mm:ss}\t{2:yyyy-MM-dd HH:mm:ss}\t{3}\t\t{4}",
					channel.ChannelId,
					channel.LastReceivedTime,
					channel.LastSendTime,
					channel.LocalEndPoint,
					channel.RemoteEndPoint);
			}

			output.WriteLine();
		}

		public Deployer(ITerminal terminal)
		{
			if(terminal == null)
				throw new ArgumentNullException("terminal");

			_terminal = terminal;
		}

        protected CommandBase(
            ICommandProcessor ParentCommandProcessor,
            ITerminal  Terminal)
        {
            _CommandProcessor = ParentCommandProcessor;

            _Terminal = Terminal;
        }

		public TerminalCommandExecutor(ITerminal terminal, ICommandLineParser parser)
		{
			if(terminal == null)
				throw new ArgumentNullException("terminal");

			_terminal = terminal;
			this.Parser = parser;
		}

 /// <summary>
 /// Constructor for BlackJack game
 /// </summary>
 /// <param name="terminal"></param>
 public BlackJack(ITerminal terminal)
     : base(terminal)
 {
     _terminal = terminal;
     user = new Player(100);
     dealer = new Player(9999999);
     _cardGame = new CardGame(terminal);
 }

 public override void Initialize(IHostContext hostContext)
 {
     base.Initialize(hostContext);
     Trace.Verbose("Creating _store");
     _store = hostContext.GetService<IConfigurationStore>();
     Trace.Verbose("store created");
     _term = hostContext.GetService<ITerminal>();
 }

		public static void WritePluginNode(ITerminal terminal, PluginTreeNode node, ObtainMode obtainMode, int maxDepth)
		{
			if(node == null)
				return;

			terminal.Write(TerminalColor.DarkYellow, "[{0}]", node.NodeType);
			terminal.WriteLine(node.FullPath);
			terminal.Write(TerminalColor.DarkYellow, "Plugin File: ");

			if(node.Plugin == null)
				terminal.WriteLine(TerminalColor.Red, "N/A");
			else
				terminal.WriteLine(node.Plugin.FilePath);

			terminal.Write(TerminalColor.DarkYellow, "Node Properties: ");
			terminal.WriteLine(node.Properties.Count);

			if(node.Properties.Count > 0)
			{
				terminal.WriteLine(TerminalColor.Gray, "{");

				foreach(PluginExtendedProperty property in node.Properties)
				{
					terminal.Write(TerminalColor.DarkYellow, "\t" + property.Name);
					terminal.Write(" = ");
					terminal.Write(property.RawValue);

					if(property.Value != null)
					{
						terminal.Write(TerminalColor.DarkGray, " [");
						terminal.Write(TerminalColor.Blue, property.Value.GetType().FullName);
						terminal.Write(TerminalColor.DarkGray, "]");
					}

					terminal.WriteLine();
				}

				terminal.WriteLine(TerminalColor.Gray, "}");
			}

			terminal.WriteLine(TerminalColor.DarkYellow, "Children: {0}", node.Children.Count);
			if(node.Children.Count > 0)
			{
				terminal.WriteLine();

				foreach(var child in node.Children)
				{
					terminal.WriteLine(child);
				}
			}

			object value = node.UnwrapValue(obtainMode, null);
			if(value != null)
			{
				terminal.WriteLine();
				Zongsoft.Runtime.Serialization.Serializer.Text.Serialize(terminal.OutputStream, value);
			}
		}

 public bool PayBill(ITerminal terminal)
 {
     foreach (var c in this.CallHistory.Where(x => x.source.Number == terminal.Number)) {
       if (c.Paid == false) {
           c.Paid = true;
       }
       }
       return true;
 }

 public Shell(ITerminal Term)
 {
     //timer = timerReset;
     term = Term;
     allPrograms = new List<Program>();
     editMode = false;
     programLog = new StringBuilder();
     sinceLastRun = TimeSpan.Zero;
 }

        public RedirectedProcess( ITerminal ClientTerminal, ICommandClient CommandClient )
        {
            _InputHandler = new InputHandler();

            _TerminalClient = ClientTerminal;

            _ProcessExit = new ManualResetEvent( false );

            _CommandClient = CommandClient;
        }

        private static IEnumerable<IProduction> ZeroOrMany(INonTerminal identifier, ITerminal[] terminals)
        {
            var recursiveProductionSymbols = new List<ISymbol>();
            recursiveProductionSymbols.Add(identifier);
            recursiveProductionSymbols.AddRange(terminals);

            // NonTerminal -> NonTerminal Terminal | <null>
            return new[]{
                new Production(identifier, recursiveProductionSymbols.ToArray()),
                new Production(identifier)};
        }

 public OperatingContext(ITerminal Terminal, RegexSurfer Surfer, UsbConnectionFactory Usb, IProgressControllerFactory ProgressControllerFactory,
                         int BlockSize)
 {
     this.BlockSize = BlockSize;
     this.ProgressControllerFactory = ProgressControllerFactory;
     this.Usb = Usb;
     this.Terminal = Terminal;
     this.Surfer = Surfer;
     State = ProgrammingContextState.Unknown;
     NandSize = ulong.MaxValue;
 }

 public void InitTerminal(ITerminal terminal)
 {
     switch (terminal.Type)
     {
         case TerminalType.AlorTrade:
             InitAlorTerminal(terminal as AlorTerminal, -1);
             break;
         case TerminalType.Oec:
             InitOecTerminal(terminal as OecTerminal);
             break;
     }
 }

        public string Parse(  
            ITerminal Terminal,
            string    Command,
            ref    string[]  Arguments)
        {
            string commandName = null;

            ParsedCommandLine Parsed = new ParsedCommandLine( Command );

            bool bParsed = Parsed.Parse();

            if ( ! bParsed )
            {
                Terminal.WriteTo( new StringBuilder( "Failed to parse\n" ), ConsoleProcessRedirection.OutputType.StandardError );
            }
            else
            {
                Parsed.Print( Terminal );
            }

            Command = Command.TrimStart(' ','\t');

            Command = Command.TrimEnd(' ','\t');

            if ( Command.Length > 0 )
            {
                Arguments = Command.Split( new char[] {' ','\t'} );

                if ( Arguments[0].ToLower().StartsWith("cd\\") )
                {
                    string[] NewArguments = new string[ Arguments.Length + 1 ];

                    NewArguments[0] = Arguments[0].Substring( 0, 2 );
                    NewArguments[1] = Arguments[0].Substring( 2, Arguments[0].Length - 2 );

                    if ( Arguments.Length > 1 )
                    {
                        NewArguments[1] += Arguments[1];

                        for ( int Argument = 1; Argument < Arguments.Length; Argument++ )
                        {
                            NewArguments[ Argument + 1 ] = Arguments[ Argument ];
                        }
                    }

                    Arguments = NewArguments;
                }

                commandName = Arguments[0].ToLower();
            }

            return commandName;
        }

 public void RegisterEventsForTerminal(ITerminal terminal)
 {
     terminal.Plugging += (sender, args) => { this.State = PortState.Free; };
     terminal.UnPlugging += (sender, args) => { this.State = PortState.Off; };
     terminal.OutConnection += (sender, request) =>
     {
         if (request.Code == Request.OutcomingCall && this.State == PortState.Free)
         {
             this.State = PortState.Busy;
         }
     };
 }

        public Prompt(
            ITerminal Terminal,
            string    DefaultPrompt
            )
        {
            _Terminal = Terminal;

            if ( null != DefaultPrompt )
            {
                _DefaultPrompt = DefaultPrompt;
            }
        }