public TypedValue[] ActualValues(CellProcessor processor, object theActualRow)
 {
     var actuals = (object[]) theActualRow;
     var result = new TypedValue[actuals.Length];
     for (int i = 0; i < actuals.Length; i++) result[i] = new TypedValue(actuals[i]);
     return result;
 }

 public static void Evaluate(this Tree<Cell> row, CellProcessor processor)
 {
     var interpreter = processor.CallStack.DomainAdapter.GetValueAs<FlowInterpreter>();
     if (!row.InvokeSpecialAction(processor, interpreter).IsValid) {
         row.ExecuteMethod(processor, interpreter);
     }
 }

 public TypedValue[] ActualValues(CellProcessor processor, object theActualRow)
 {
     if (myColumnsUsed == null) myColumnsUsed = new bool[myHeaderRow.Parts.Size];
     var result = new TypedValue[myHeaderRow.Parts.Size];
     int column = 0;
     foreach (Parse headerCell in new CellRange(myHeaderRow.Parts).Cells) {
         TypedValue memberResult = new CellOperationImpl(processor).TryInvoke(theActualRow, headerCell);
         if (memberResult.IsValid) {
             result[column] = memberResult;
             myColumnsUsed[column] = true;
         }
         else {
             TypedValue itemResult = new CellOperationImpl(processor).TryInvoke(theActualRow,
                                                          new StringCellLeaf("getitem"),
                                                          new CellRange(headerCell, 1));
             if (itemResult.IsValid) {
                 result[column] = itemResult;
                 myColumnsUsed[column] = true;
             }
             else {
                 result[column] = TypedValue.Void;
             }
         }
         column++;
     }
     return result;
 }

 public static void DoTable(Tree<Cell> table, Interpreter activeFixture, CellProcessor processor, bool inFlow)
 {
     var activeFlowFixture = activeFixture as FlowInterpreter;
     if (activeFlowFixture != null) activeFlowFixture.DoSetUp(processor, table);
     activeFixture.Interpret(processor, table);
     if (activeFlowFixture != null && !inFlow) activeFlowFixture.DoTearDown(table);
 }

        static Interpreter GetNamedFixture(CellProcessor processor, string theName) {
            if (!processor.Get<Symbols>().HasValue(theName)) return null;

            var result =  processor.Operate<WrapOperator>(new TypedValue(processor.Get<Symbols>().GetValue(theName)));
            result.AsNot<Interpreter>(() => { throw new FitFailureException("Result is not a Fixture."); });
            return result.GetValueAs<Interpreter>();
        }

 public void Interpret(CellProcessor processor, Tree<Cell> table)
 {
     new Traverse<Cell>()
         .Rows.First(row => selectValue = new ValuePhrase(row).Evaluate(processor))
         .Rows.All(row => SelectRow(processor, row))
         .VisitTable(table);
 }

 public SocketServer(FitSocket socket, CellProcessor service, ProgressReporter reporter, bool suiteSetUpIsAnonymous)
 {
     this.service = service;
     this.reporter = reporter;
     this.socket = socket;
     IMaybeProcessingSuiteSetup = suiteSetUpIsAnonymous;
 }

 public void Interpret(CellProcessor processor, Tree<Cell> table)
 {
     new Traverse<Cell>()
         .Rows.Header(row => headerRow = row)
         .Rows.Rest(row => ComputeRow(processor, row))
         .VisitTable(table);
 }

        public object Evaluate(DomainAdapter theFixture, CellProcessor processor) {
            cells.ValueAt(0).SetAttribute(CellAttribute.Syntax, CellAttributeValue.SyntaxKeyword);

            var cellCount = cells.Branches.Count;
            if (cellCount < 2) throw MakeException("missing cells");
            var identifier = cells.ValueAt(1).Text;
            if (newIdentifier.Equals(identifier)) {
                cells.ValueAt(1).SetAttribute(CellAttribute.Syntax, CellAttributeValue.SyntaxKeyword);
                return new MethodPhrase(cells.Skip(1)).EvaluateNew(processor);
            }
            if (typeIdentifier.Equals(identifier)) {
                cells.ValueAt(1).SetAttribute(CellAttribute.Syntax, CellAttributeValue.SyntaxKeyword);
                if (cellCount < 3) throw MakeException("missing cells");
                cells.ValueAt(2).SetAttribute(CellAttribute.Syntax, CellAttributeValue.SyntaxSUT);
                return processor.ParseTree(typeof (Type), cells.Branches[2]).Value;
            }
            if (currentIdentifier.Equals(identifier)) {
                cells.ValueAt(1).SetAttribute(CellAttribute.Syntax, CellAttributeValue.SyntaxKeyword);
                return theFixture.SystemUnderTest;
            }
            var fixture = theFixture as FlowInterpreter;
            if (fixture == null) throw MakeException("flow fixture required");

            return processor.Get<Symbols>().HasValue(identifier)
                ? processor.Get<Symbols>().GetValue(identifier)
                : fixture.ExecuteFlowRowMethod(processor, cells);
        }

 public object EvaluateNew(CellProcessor processor)
 {
     if (cells.Branches.Count < 2) throw MakeException("missing cells");
     return processor.Create(
             cells.ValueAt(1).Text,
             cells.Skip(2))
         .Value;
 }

 public InvokeOperation(CellProcessor processor, TypedValue target, Tree<Cell> member, Tree<Cell> parameters, Tree<Cell> cells)
 {
     this.processor = processor;
     Target = target;
     Member = member;
     Parameters = parameters;
     Cells = cells;
 }

 public static TypedValue ExecuteMethod(this Tree<Cell> row, CellProcessor processor, MethodRowSelector selector,
                                        object target)
 {
     return processor.Execute(target,
                 selector.SelectMethodCells(row),
                 selector.SelectParameterCells(row),
                 row.ValueAt(0));
 }

 static void Execute(CellProcessor processor, object facility, Tree<Cell> currentRow) {
     var selector = new DoRowSelector();
     var result = processor.ExecuteWithThrow(facility, selector.SelectMethodCells(currentRow),
                                             selector.SelectParameterCells(currentRow),
                                             currentRow.ValueAt(0));
     if (result.IsVoid) return;
     currentRow.ValueAt(0).SetAttribute(CellAttribute.Folded, result.ValueString);
 }

 private void RunTest(CellProcessor service, string tables) {
     var socket = new TestSocket();
     socket.PutByteString(Protocol.FormatInteger(tables.Length));
     socket.PutByteString(tables);
     socket.PutByteString(Protocol.FormatInteger(0));
     var server = new SocketServer(new FitSocket(socket, new NullReporter()), service, new NullReporter(), false);
     server.ProcessTestDocuments(new StoryTestStringWriter(service).ForTables(s => resultTables += s));
     Assert.IsFalse(socket.isOpen);
 }

 public TypedValue DoInvoke(CellProcessor processor)
 {
     var targetInstance = new TypedValue(target);
     var targetObjectProvider = target as TargetObjectProvider;
     var name = GetMemberName(processor);
     return processor.Invoke(
             targetObjectProvider != null ? new TypedValue(targetObjectProvider.GetTargetObject()) : targetInstance,
             name, parameters);
 }

 public void Interpret(CellProcessor processor, Tree<Cell> table) {
     var action = new IncludeAction(processor);
     var currentRow = table.Branches[0].Skip(1);
     var selector = new SequenceRowSelector();
     processor.ExecuteWithThrow(action, selector.SelectMethodCells(currentRow),
                                                             selector.SelectParameterCells(currentRow),
                                                             currentRow.ValueAt(0));
     table.ValueAt(0, 0).SetAttribute(CellAttribute.Folded, action.Result);
 }

 void SelectRow(CellProcessor processor, Tree<Cell> row)
 {
     if (processor.Compare(new TypedValue(selectValue), row.Branches[0])) {
         var interpreter = processor.CallStack.DomainAdapter.GetValueAs<FlowInterpreter>();
         new FlowRow(new CellTree(row.Branches.Skip(1))).Evaluate(processor, interpreter);
     }
     else {
         row.Value.SetAttribute(CellAttribute.Status, TestStatus.Ignore);
     }
 }

        public void Interpret(CellProcessor processor, Tree<Cell> table) {
            var firstRow = table.Branches[0];
            if (firstRow.Branches.Count < 2) throw new TableStructureException("Missing cells for use.");

            var fixtureName = firstRow.ValueAt(1).Text;
            var targetFixture = GetNamedFixture(processor, fixtureName)
                ?? MakeNewFixture(processor, firstRow);

            targetFixture.Interpret(processor, table);
        }

 public void Interpret(CellProcessor processor, Tree<Cell> table)
 {
     processor.TestStatus.TableCount--;
     TypedValue result = processor.Invoke(
         new TypedValue(processor.Configuration.GetItem(table.Branches[0].Branches[1].Value.Text)),
         table.Branches[0].Branches[2].Value.Text,
         new CellTree());
     result.ThrowExceptionIfNotValid();
     if (result.IsVoid) return;
     table.Branches[0].Branches[2].Value.SetAttribute(CellAttribute.Folded, result.ValueString);
 }

 public static object ExecuteFlowRowMethod(this FlowInterpreter interpreter, CellProcessor processor, Tree<Cell> row)
 {
     try {
         var cells = row.Skip(1);
         return cells.ExecuteMethod(processor, interpreter).ThrowExceptionIfNotValid().Value;
     }
     catch (ParseException<Cell> e) {
         processor.TestStatus.MarkException(e.Subject, e.InnerException);
         throw new IgnoredException();
     }
 }