source: default/trunk/de.ugoe.cs.swe.bnftools.ebnf.ui/src/de/ugoe/cs/swe/bnftools/ui/formatter/EbnfFormatterVisitor.java @ 10

package de.ugoe.cs.swe.bnftools.ui.formatter;

import org.eclipse.emf.ecore.EObject;

import com.sun.xml.internal.bind.v2.schemagen.xmlschema.Import;

import de.ugoe.cs.swe.bnftools.ebnf.Atom;
import de.ugoe.cs.swe.bnftools.ebnf.DefinitionList;
import de.ugoe.cs.swe.bnftools.ebnf.EtsiBnf;
import de.ugoe.cs.swe.bnftools.ebnf.ExtRule;
import de.ugoe.cs.swe.bnftools.ebnf.GlobalCombinator;
import de.ugoe.cs.swe.bnftools.ebnf.GroupedSequence;
import de.ugoe.cs.swe.bnftools.ebnf.HookCombinator;
import de.ugoe.cs.swe.bnftools.ebnf.MergeRule;
import de.ugoe.cs.swe.bnftools.ebnf.OptionalSequence;
import de.ugoe.cs.swe.bnftools.ebnf.RepeatedSequence;
import de.ugoe.cs.swe.bnftools.ebnf.Rule;
import de.ugoe.cs.swe.bnftools.ebnf.RuleCombinator;
import de.ugoe.cs.swe.bnftools.ebnf.RuleReference;
import de.ugoe.cs.swe.bnftools.ebnf.SectionHeading;
import de.ugoe.cs.swe.bnftools.ebnf.SingleDefinition;
import de.ugoe.cs.swe.bnftools.ebnf.StringRule;
import de.ugoe.cs.swe.bnftools.ebnf.Term;
import de.ugoe.cs.swe.bnftools.visitor.EbnfVisitor;

public class EbnfFormatterVisitor extends EbnfVisitor {
        private StringBuffer buf;
        private FormatterConfig config;

        public EbnfFormatterVisitor(EObject rootNode, FormatterConfig config) {
                super(rootNode);
                this.config = config;
                buf = new StringBuffer();
        }

        public EbnfFormatterVisitor(FormatterConfig config) {
                this.config = config;
                buf = new StringBuffer();
        }

        public StringBuffer getBuf() {
                return buf;
        }

        // -----------------------------------------------------------------------------

        protected void visit(EtsiBnf node) {
                buf.append("grammar " + node.getName());
                if (node.getType() != null)
                        buf.append(node.getType());
                buf.append(";");
        }

        protected void visit(Atom node) {
        }

        protected void visit(DefinitionList node) {
        }

        protected void visit(ExtRule node) {
        }

        protected void visit(GlobalCombinator node) {
        }

        protected void visit(GroupedSequence node) {
        }

        protected void visit(HookCombinator node) {
        }

        protected void visit(Import node) {
        }

        protected void visit(MergeRule node) {
        }

        protected void visit(OptionalSequence node) {
        }

        protected void visit(RepeatedSequence node) {
        }

        protected void visit(Rule node) {
        }

        protected void visit(RuleCombinator node) {
        }

        protected void visit(RuleReference node) {
        }

        protected void visit(SectionHeading node) {
        }

        protected void visit(SingleDefinition node) {
        }

        protected void visit(StringRule node) {
        }

        protected void visit(Term node) {
        }

}