コード例 #1
0
        public virtual string toStringNonTerminalNode(NonTerminalNode node)
        {
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final StringBuilder sb = new StringBuilder();
            StringBuilder sb = new StringBuilder();

            sb.Append(node.ToString().Trim());
            sb.Append('\n');
            IEnumerator <Edge.Edge> ie = ((Node.Node)node).OutgoingEdgeIterator;

            while (ie.MoveNext())
            {
                Edge.Edge e = ie.Current;
                if (e.Target is TokenNode)
                {
                    sb.Append("   T");
                    sb.Append(e.Target.Index);
                }
                if (e.Target is NonTerminalNode)
                {
                    sb.Append("   N");
                    sb.Append(e.Target.Index);
                }
                sb.Append('\t');
                sb.Append(e.ToString());
                sb.Append('\n');
            }
            return(sb.ToString());
        }
コード例 #2
0
        public static NonTerminalNode CreateNode(Rule rule)
        {
            Debug.Assert(rule != null);

            NonTerminalNode node = _implTypes.ContainsKey(rule.Index) ? _implTypes.CreateInstance(rule.Index) : new NonTerminalNode();

            node.Rule = rule;
            return(node);
        }
コード例 #3
0
 private Node ApplyDistributiveProperty(Node current)
 {
     if ((current == null) || (current is TerminalNode))
     {
         return(current);
     }
     else if (!(current is And))
     {
         NonTerminalNode nt = (NonTerminalNode)current;
         nt.left  = ApplyDistributiveProperty(nt.left);
         nt.right = ApplyDistributiveProperty(nt.right);
         return(nt);
     }
     else
     {
         And and = (And)current;
         // Check for an OR child
         Or   childOr    = (and.left as Or);
         Node otherChild = and.right;
         if (childOr == null)
         {
             childOr    = (and.right as Or);
             otherChild = and.left;
         }
         // If neither child is an OR simply recurse
         if (childOr == null)
         {
             and.left  = ApplyDistributiveProperty(and.left);
             and.right = ApplyDistributiveProperty(and.right);
             return(and);
         }
         // If either child is an OR
         // convert (child.left OR child.right) AND otherChild into
         // (child.left AND otherChild) OR (child.right AND otherChild)
         else
         {
             // Create new operator nodes
             Or  or    = new Or(new OrOperator());
             And left  = new And(new AndOperator());
             And right = new And(new AndOperator());
             // Populate new terms
             left.left   = childOr.left;
             left.right  = otherChild;
             right.left  = childOr.right;
             right.right = otherChild;
             // Recursively apply distributive rule to new terms
             or.left  = ApplyDistributiveProperty(left);
             or.right = ApplyDistributiveProperty(right);
             return(or);
         }
     }
 }
コード例 #4
0
ファイル: PrioList.cs プロジェクト: Sojaner/NMaltParser
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public org.maltparser.core.syntaxgraph.node.PhraseStructureNode getHeadChild(org.maltparser.core.syntaxgraph.node.NonTerminalNode nt) throws org.maltparser.core.exception.MaltChainedException
        public virtual PhraseStructureNode getHeadChild(NonTerminalNode nt)
        {
            PhraseStructureNode headChild = null;

            for (int i = 0, n = Count; i < n; i++)
            {
                headChild = this[i].getHeadChild(nt, direction);
                if (headChild != null)
                {
                    break;
                }
            }
            return(headChild);
        }
コード例 #5
0
ファイル: PrioSet.cs プロジェクト: Sojaner/NMaltParser
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public org.maltparser.core.syntaxgraph.node.PhraseStructureNode getHeadChild(org.maltparser.core.syntaxgraph.node.NonTerminalNode nt, Direction direction) throws org.maltparser.core.exception.MaltChainedException
        public virtual PhraseStructureNode getHeadChild(NonTerminalNode nt, Direction direction)
        {
            bool match = false;

            if (direction == Direction.LEFT)
            {
                foreach (PhraseStructureNode child in nt.Children)
                {
                    for (int j = 0; j < Count; j++)
                    {
                        match = matchHeadChild(child, this[j]);
                        if (match == true)
                        {
                            if (j + 1 >= Count)
                            {
                                return(child);
                            }
                            else if (this[j].RelationToPrevMember != RelationToPrevMember.CONJUNCTION)
                            {
                                return(child);
                            }
                        }
                    }
                }
            }
            else if (direction == Direction.RIGHT)
            {
                for (int i = nt.nChildren() - 1; i >= 0; i--)
                {
                    PhraseStructureNode child = nt.getChild(i);
                    for (int j = 0; j < Count; j++)
                    {
                        match = matchHeadChild(child, this[j]);
                        if (match == true)
                        {
                            if (j + 1 >= Count)
                            {
                                return(child);
                            }
                            else if (this[j].RelationToPrevMember != RelationToPrevMember.CONJUNCTION)
                            {
                                return(child);
                            }
                        }
                    }
                }
            }
            return(null);
        }
コード例 #6
0
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: private void calculateIndices(org.maltparser.core.syntaxgraph.PhraseStructure phraseStructure) throws org.maltparser.core.exception.MaltChainedException
        private void calculateIndices(PhraseStructure phraseStructure)
        {
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.SortedMap<int,int> heights = new java.util.TreeMap<int,int>();
            SortedDictionary <int, int> heights = new SortedDictionary <int, int>();

            foreach (int index in phraseStructure.NonTerminalIndices)
            {
                heights[index] = ((NonTerminalNode)phraseStructure.getNonTerminalNode(index)).Height;
            }

            bool done = false;
            int  h    = 1;
            int  ntid = START_ID_OF_NONTERMINALS;

            nonTerminalIndexMap.clear();
            while (!done)
            {
                done = true;
                foreach (int index in phraseStructure.NonTerminalIndices)
                {
                    if (heights[index] == h)
                    {
                        NonTerminalNode nt = (NonTerminalNode)phraseStructure.getNonTerminalNode(index);
                        nonTerminalIndexMap.put(nt.Index, ntid++);
                        //					nonTerminalIndexMap.put(nt.getIndex(), nt.getIndex()+START_ID_OF_NONTERMINALS-1);
                        done = false;
                    }
                }
                h++;
            }

            //		boolean done = false;
            //		int h = 1;
            ////		int ntid = START_ID_OF_NONTERMINALS;
            ////		nonTerminalIndexMap.clear();
            //		while (!done) {
            //			done = true;
            //			for (int index : phraseStructure.getNonTerminalIndices()) {
            //				if (heights.get(index) == h) {
            //					NonTerminalNode nt = (NonTerminalNode)phraseStructure.getNonTerminalNode(index);
            ////					nonTerminalIndexMap.put(nt.getIndex(), ntid++);
            //					nonTerminalIndexMap.put(nt.getIndex(), nt.getIndex()+START_ID_OF_NONTERMINALS-1);
            //					done = false;
            //				}
            //			}
            //			h++;
            //		}
        }
コード例 #7
0
        public void ShoulEnumerateTerminals()
        {
            NonTerminalNode <char> parent, child;

            child = new NonTerminalNode <char>();
            child.Nodes.Add(new TerminalNode <char>(new MockedTerminalInput('b')));
            child.Nodes.Add(new TerminalNode <char>(new MockedTerminalInput('c')));
            child.Nodes.Add(new TerminalNode <char>(new MockedTerminalInput('d')));

            parent = new NonTerminalNode <char>();
            parent.Nodes.Add(new TerminalNode <char>(new MockedTerminalInput('a')));
            parent.Nodes.Add(child);
            parent.Nodes.Add(new TerminalNode <char>(new MockedTerminalInput('e')));

            Assert.AreEqual("abcde", new string( parent.EnumerateInputs().OfType <MockedTerminalInput>().Select(item => item.Value).ToArray()));
        }
コード例 #8
0
        public static NonTerminalNode CreateNode(Rule rule)
        {
            Debug.Assert(rule != null);

            NonTerminalNode node = null;

            if (_nodeImplTypeMap.ContainsKey(rule.Index))
            {
                node = _nodeImplTypeMap.CreateInstance(rule.Index);
            }
            else
            {
                node = new NonTerminalNode();// if no type is bound to the rule then just create a base non-terminal node
            }
            node.Rule = rule;
            return(node);
        }
コード例 #9
0
 private Node SearchForNot(Node current)
 {
     if ((current == null) || (current is TerminalNode))
     {
         return(current);
     }
     else if (!(current is Not))
     {
         NonTerminalNode nt = (NonTerminalNode)current;
         nt.left  = SearchForNot(nt.left);
         nt.right = SearchForNot(nt.right);
         return(nt);
     }
     else
     {
         return(ApplyDeMorgan((current as Not).left));
     }
 }
コード例 #10
0
ファイル: HeadRules.cs プロジェクト: Sojaner/NMaltParser
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public Direction getDefaultDirection(org.maltparser.core.syntaxgraph.node.NonTerminalNode nt) throws org.maltparser.core.exception.MaltChainedException
        public virtual Direction getDefaultDirection(NonTerminalNode nt)
        {
            HeadRule rule = null;

            if (nt.hasLabel(nonTerminalSymbolTable))
            {
                rule = this[nonTerminalSymbolTable.Name + ":" + nt.getLabelSymbol(nonTerminalSymbolTable)];
            }
            if (rule == null && nt.hasParentEdgeLabel(edgelabelSymbolTable))
            {
                rule = this[edgelabelSymbolTable.Name + ":" + nt.getParentEdgeLabelSymbol(edgelabelSymbolTable)];
            }

            if (rule != null)
            {
                return(rule.DefaultDirection);
            }
            return(Direction.LEFT);
        }
コード例 #11
0
ファイル: HeadRules.cs プロジェクト: Sojaner/NMaltParser
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public org.maltparser.core.syntaxgraph.node.PhraseStructureNode getHeadChild(org.maltparser.core.syntaxgraph.node.NonTerminalNode nt) throws org.maltparser.core.exception.MaltChainedException
        public virtual PhraseStructureNode getHeadChild(NonTerminalNode nt)
        {
            HeadRule rule = null;

            if (nt.hasLabel(nonTerminalSymbolTable))
            {
                rule = this[nonTerminalSymbolTable.Name + ":" + nt.getLabelSymbol(nonTerminalSymbolTable)];
            }
            if (rule == null && nt.hasParentEdgeLabel(edgelabelSymbolTable))
            {
                rule = this[edgelabelSymbolTable.Name + ":" + nt.getParentEdgeLabelSymbol(edgelabelSymbolTable)];
            }

            if (rule != null)
            {
                return(rule.getHeadChild(nt));
            }
            return(null);
        }
コード例 #12
0
ファイル: TigerXMLWriter.cs プロジェクト: Sojaner/NMaltParser
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void writeNonTerminals(org.maltparser.core.syntaxgraph.PhraseStructure phraseStructure) throws org.maltparser.core.exception.MaltChainedException
        public virtual void writeNonTerminals(PhraseStructure phraseStructure)
        {
            try
            {
                SortedDictionary <int, int> heights = new SortedDictionary <int, int>();
                foreach (int index in phraseStructure.NonTerminalIndices)
                {
                    heights[index] = ((NonTerminalNode)phraseStructure.getNonTerminalNode(index)).Height;
                }
                writer.Write("        <nonterminals>\n");
                bool done = false;
                int  h    = 1;
                while (!done)
                {
                    done = true;
                    foreach (int index in phraseStructure.NonTerminalIndices)
                    {
                        if (heights[index] == h)
                        {
                            NonTerminalNode nt = (NonTerminalNode)phraseStructure.getNonTerminalNode(index);
                            tmpID.Length = 0;
                            tmpID.Append(sentenceID);
                            tmpID.Append('_');
                            tmpID.Append(Convert.ToString(nt.Index + START_ID_OF_NONTERMINALS - 1));
                            writeNonTerminal(phraseStructure.SymbolTables, nt, tmpID.ToString());
                            done = false;
                        }
                    }
                    h++;
                }

                writeNonTerminal(phraseStructure.SymbolTables, (NonTerminalNode)phraseStructure.PhraseStructureRoot, rootID.ToString());
                writer.Write("        </nonterminals>\n");
            }
            catch (IOException e)
            {
                throw new DataFormatException("The TigerXML writer is not able to write. ", e);
            }
        }
コード例 #13
0
        public bool Parse(TextReader sourceReader)
        {
            Debug.Assert(sourceReader != null);

            m_parser = ParserFactory.CreateParser(sourceReader);
            m_parser.TrimReductions = true;

            while (true)
            {
                switch (m_parser.Parse())
                {
                case ParseMessage.LexicalError:
                    ErrorString = string.Format("Lexical Error. Line {0}. Token {1} was not expected.", m_parser.LineNumber, m_parser.TokenText);
                    return(false);

                case ParseMessage.SyntaxError:
                    StringBuilder text = new StringBuilder();
                    foreach (Symbol tokenSymbol in m_parser.GetExpectedTokens())
                    {
                        text.AppendFormat(" {0}", tokenSymbol);
                    }

                    ErrorString = string.Format("Syntax Error. Line {0}. Expecting: {1}.", m_parser.LineNumber, text);

                    return(false);

                case ParseMessage.Reduction:
                    NonTerminalNode nonTerminal = SyntaxRuleFactory.CreateNode(m_parser.ReductionRule);
                    m_parser.TokenSyntaxNode = nonTerminal;

                    for (int i = 0; i < m_parser.ReductionCount; i++)
                    {
                        nonTerminal.AppendChildNode(m_parser.GetReductionSyntaxNode(i) as SyntaxNode);
                    }

                    // post parsing syntax check (used to segregate the difference between HAVING and WHERE
                    // expressions in terms of the validtity of aggregate expressions)
                    nonTerminal.CheckSyntax();

                    break;

                case ParseMessage.TokenRead:
                    m_parser.TokenSyntaxNode = new TerminalNode(m_parser);
                    break;

                case ParseMessage.Accept:
                    SyntaxTree  = m_parser.TokenSyntaxNode as NonTerminalNode;
                    ErrorString = null;
                    return(true);

                case ParseMessage.InternalError:
                    ErrorString = "Internal Error. Something is horribly wrong.";
                    return(false);

                case ParseMessage.NotLoadedError:
                    ErrorString = "Grammar Table is not loaded.";
                    return(false);

                case ParseMessage.CommentError:
                    ErrorString = "Comment Error. Unexpected end of input.";
                    return(false);

                case ParseMessage.CommentBlockRead:
                case ParseMessage.CommentLineRead:
                    // don't do anything
                    break;
                }
            }
        }
コード例 #14
0
ファイル: TigerXMLWriter.cs プロジェクト: Sojaner/NMaltParser
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void writeNonTerminal(org.maltparser.core.symbol.SymbolTableHandler symbolTables, org.maltparser.core.syntaxgraph.node.NonTerminalNode nt, String id) throws org.maltparser.core.exception.MaltChainedException
        public virtual void writeNonTerminal(SymbolTableHandler symbolTables, NonTerminalNode nt, string id)
        {
            try
            {
                writer.Write("          <nt");
                writer.Write(" id=\"");
                writer.Write(id);
                writer.Write("\" ");
                foreach (ColumnDescription column in dataFormatInstance.PhraseStructureNodeLabelColumnDescriptionSet)
                {
                    if (nt.hasLabel(symbolTables.getSymbolTable(column.Name)))
                    {
                        writer.Write(column.Name.ToLower());
                        writer.Write("=");
                        writer.Write("\"");
                        writer.Write(Util.xmlEscape(nt.getLabelSymbol(symbolTables.getSymbolTable(column.Name))));
                        writer.Write("\" ");
                    }
                }
                writer.Write(">\n");

                for (int i = 0, n = nt.nChildren(); i < n; i++)
                {
                    PhraseStructureNode child = nt.getChild(i);
                    writer.Write("            <edge ");

                    foreach (ColumnDescription column in dataFormatInstance.PhraseStructureEdgeLabelColumnDescriptionSet)
                    {
                        if (child.hasParentEdgeLabel(symbolTables.getSymbolTable(column.Name)))
                        {
                            writer.Write(column.Name.ToLower());
                            writer.Write("=\"");
                            writer.Write(Util.xmlEscape(child.getParentEdgeLabelSymbol(symbolTables.getSymbolTable(column.Name))));
                            writer.Write("\" ");
                        }
                    }
                    if (child is TokenNode)
                    {
                        if (!labeledTerminalID)
                        {
                            tmpID.Length = 0;
                            tmpID.Append(sentenceID);
                            tmpID.Append('_');
                            tmpID.Append(Convert.ToString(child.Index));
                            writer.Write(" idref=\"");
                            writer.Write(tmpID.ToString());
                            writer.Write("\"");
                        }
                        else
                        {
                            writer.Write(" idref=\"");
                            writer.Write(child.getLabelSymbol(symbolTables.getSymbolTable("ID")));
                            writer.Write("\"");
                        }
                    }
                    else
                    {
                        tmpID.Length = 0;
                        tmpID.Append(sentenceID);
                        tmpID.Append('_');
                        tmpID.Append(Convert.ToString(child.Index + START_ID_OF_NONTERMINALS - 1));
                        writer.Write(" idref=\"");
                        writer.Write(tmpID.ToString());
                        writer.Write("\"");
                    }
                    writer.Write(" />\n");
                }
                writer.Write("          </nt>\n");
            }
            catch (IOException e)
            {
                throw new DataFormatException("The TigerXML writer is not able to write. ", e);
            }
        }
コード例 #15
0
        public bool Parse(TextReader sourceReader)
        {
            Debug.Assert(sourceReader != null);

            m_parser = ParserFactory.CreateParser(sourceReader);
            m_parser.TrimReductions = true;

            while (true)
            {
                switch (m_parser.Parse())
                {
                    case ParseMessage.LexicalError:
                        ErrorString = string.Format("Lexical Error. Line {0}. Token {1} was not expected.", m_parser.LineNumber, m_parser.TokenText);
                        return false;

                    case ParseMessage.SyntaxError:
                        StringBuilder text = new StringBuilder();
                        foreach (Symbol tokenSymbol in m_parser.GetExpectedTokens())
                            text.AppendFormat(" {0}", tokenSymbol);

                        ErrorString = string.Format("Syntax Error. Line {0}. Expecting: {1}.", m_parser.LineNumber, text);

                        return false;

                    case ParseMessage.Reduction:
                        NonTerminalNode nonTerminal = SyntaxRuleFactory.CreateNode(m_parser.ReductionRule);
                        m_parser.TokenSyntaxNode = nonTerminal;

                        for (int i = 0; i < m_parser.ReductionCount; i++)
                            nonTerminal.AppendChildNode(m_parser.GetReductionSyntaxNode(i) as SyntaxNode);

                        // post parsing syntax check (used to do things like segregate the difference between HAVING and WHERE
                        // expressions in terms of the validtity of aggregate expressions)
                        nonTerminal.CheckSyntax();

                        break;

                    case ParseMessage.TokenRead:
                        m_parser.TokenSyntaxNode = new TerminalNode(m_parser);
                        break;

                    case ParseMessage.Accept:
                        SyntaxTree = m_parser.TokenSyntaxNode as NonTerminalNode;
                        ErrorString = null;
                        return true;

                    case ParseMessage.InternalError:
                        ErrorString = "Internal Error. Something is horribly wrong.";
                        return false;

                    case ParseMessage.NotLoadedError:
                        ErrorString = "Grammar Table is not loaded.";
                        return false;

                    case ParseMessage.CommentError:
                        ErrorString = "Comment Error. Unexpected end of input.";
                        return false;

                    case ParseMessage.CommentBlockRead:
                    case ParseMessage.CommentLineRead:
                        // don't do anything
                        break;
                }
            }
        }
コード例 #16
0
ファイル: BracketWriter.cs プロジェクト: Sojaner/NMaltParser
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: private void writeElement(org.maltparser.core.symbol.SymbolTableHandler symbolTables, org.maltparser.core.syntaxgraph.node.PhraseStructureNode element, int depth) throws org.maltparser.core.exception.MaltChainedException
        private void writeElement(SymbolTableHandler symbolTables, PhraseStructureNode element, int depth)
        {
            try
            {
                if (element is TokenNode)
                {
                    PhraseStructureNode t     = (PhraseStructureNode)element;
                    SymbolTable         table = null;
                    writer.Write("\n" + getIndentation(depth) + STARTING_BRACKET);
                    int i = 0;
                    foreach (string inputColumn in inputColumns.Keys)
                    {
                        if (i != 0)
                        {
                            writer.BaseStream.WriteByte(INPUT_SEPARATOR);
                        }
                        table = symbolTables.getSymbolTable(inputColumns[inputColumn].Name);
                        if (t.hasLabel(table))
                        {
                            writer.Write(encodeString(t.getLabelSymbol(table)));
                        }
                        if (i == 0)
                        {
                            foreach (string edgeLabelColumn in edgeLabelColumns.Keys)
                            {
                                table = symbolTables.getSymbolTable(edgeLabelColumns[edgeLabelColumn].Name);
                                if (t.hasParentEdgeLabel(table) && !t.Parent.Root && !t.getParentEdgeLabelSymbol(table).Equals(EMPTY_EDGELABEL))
                                {
                                    writer.BaseStream.WriteByte(EDGELABEL_SEPARATOR);
                                    writer.Write(t.getParentEdgeLabelSymbol(table));
                                }
                            }
                        }
                        i++;
                    }
                    writer.BaseStream.WriteByte(CLOSING_BRACKET);
                }
                else
                {
                    NonTerminalNode nt = (NonTerminalNode)element;
                    writer.Write("\n" + getIndentation(depth) + STARTING_BRACKET);
                    SymbolTable table = null;
                    int         i     = 0;
                    foreach (string phraseLabelColumn in phraseLabelColumns.Keys)
                    {
                        if (i != 0)
                        {
                            writer.BaseStream.WriteByte(INPUT_SEPARATOR);
                        }
                        table = symbolTables.getSymbolTable(phraseLabelColumns[phraseLabelColumn].Name);
                        if (nt.hasLabel(table))
                        {
                            writer.BaseStream.WriteByte(nt.getLabelSymbol(table));
                        }
                        if (i == 0)
                        {
                            foreach (string edgeLabelColumn in edgeLabelColumns.Keys)
                            {
                                table = symbolTables.getSymbolTable(edgeLabelColumns[edgeLabelColumn].Name);
                                if (nt.hasParentEdgeLabel(table) && !nt.Parent.Root && !nt.getParentEdgeLabelSymbol(table).Equals(EMPTY_EDGELABEL))
                                {
                                    writer.BaseStream.WriteByte(EDGELABEL_SEPARATOR);
                                    writer.Write(nt.getParentEdgeLabelSymbol(table));
                                }
                            }
                        }
                        i++;
                    }
                    foreach (PhraseStructureNode node in ((NonTerminalNode)element).Children)
                    {
                        writeElement(symbolTables, node, depth + 1);
                    }
                    writer.Write("\n" + getIndentation(depth) + CLOSING_BRACKET);
                }
            }
            catch (IOException e)
            {
                throw new DataFormatException("Could not write to the output file. ", e);
            }
        }
コード例 #17
0
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: private void writeNonTerminals(org.maltparser.core.syntaxgraph.PhraseStructure phraseStructure) throws org.maltparser.core.exception.MaltChainedException
        private void writeNonTerminals(PhraseStructure phraseStructure)
        {
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.maltparser.core.symbol.SymbolTableHandler symbolTables = phraseStructure.getSymbolTables();
            SymbolTableHandler symbolTables = phraseStructure.SymbolTables;

            foreach (int index in nonTerminalIndexMap.Keys)
            {
                //		for (int index : phraseStructure.getNonTerminalIndices()) {
                NonTerminalNode nonTerminal = (NonTerminalNode)phraseStructure.getNonTerminalNode(index);

                if (nonTerminal == null || nonTerminal.Root)
                {
                    return;
                }
                try
                {
                    writer.BaseStream.WriteByte('#');
                    //				writer.write(Integer.toString(index+START_ID_OF_NONTERMINALS-1));
                    writer.Write(Convert.ToString(nonTerminalIndexMap.get(index)));
                    writer.Write("\t\t\t--\t\t\t");
                    if (nonTerminal.hasLabel(symbolTables.getSymbolTable("CAT")))
                    {
                        writer.BaseStream.WriteByte(nonTerminal.getLabelSymbol(symbolTables.getSymbolTable("CAT")));
                    }
                    else
                    {
                        writer.Write("--");
                    }
                    writer.Write("\t--\t\t");
                    if (nonTerminal.hasParentEdgeLabel(symbolTables.getSymbolTable("LABEL")))
                    {
                        writer.Write(nonTerminal.getParentEdgeLabelSymbol(symbolTables.getSymbolTable("LABEL")));
                    }
                    else
                    {
                        writer.Write("--");
                    }
                    writer.BaseStream.WriteByte('\t');
                    if (nonTerminal.Parent == null || nonTerminal.Parent.Root)
                    {
                        writer.BaseStream.WriteByte('0');
                    }
                    else
                    {
                        //					writer.write(Integer.toString(nonTerminal.getParent().getIndex()+START_ID_OF_NONTERMINALS-1));
                        writer.Write(Convert.ToString(nonTerminalIndexMap.get(nonTerminal.Parent.Index)));
                    }
                    foreach (Edge.Edge e in nonTerminal.IncomingSecondaryEdges)
                    {
                        if (e.hasLabel(symbolTables.getSymbolTable("SECEDGELABEL")))
                        {
                            writer.BaseStream.WriteByte('\t');
                            writer.Write(e.getLabelSymbol(symbolTables.getSymbolTable("SECEDGELABEL")));
                            writer.BaseStream.WriteByte('\t');
                            if (e.Source is NonTerminalNode)
                            {
                                //							writer.write(Integer.toString(e.getSource().getIndex()+START_ID_OF_NONTERMINALS-1));
                                writer.Write(Convert.ToString(nonTerminalIndexMap.get(e.Source.Index)));
                            }
                            else
                            {
                                writer.Write(Convert.ToString(e.Source.Index));
                            }
                        }
                    }
                    writer.Write("\n");
                }
                catch (IOException e)
                {
                    throw new DataFormatException("The Negra writer is not able to write the non-terminals. ", e);
                }
            }
        }