X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=yang%2Fyang-parser-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fyangtools%2Fyang%2Fparser%2Fimpl%2FYangParserListenerImpl.java;h=a536c1cbf85a2abaf518006afb048bd21107f314;hb=05dfab2193e196c6e227aa814dbce33ee1671939;hp=cd9f2f49fb94257066cf7324bf45f619ba1c66d9;hpb=1bdc29c20e850029a42dd64ece95f0a4330db611;p=yangtools.git diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/impl/YangParserListenerImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/impl/YangParserListenerImpl.java index cd9f2f49fb..a536c1cbf8 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/impl/YangParserListenerImpl.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/impl/YangParserListenerImpl.java @@ -7,18 +7,36 @@ */ package org.opendaylight.yangtools.yang.parser.impl; -import static org.opendaylight.yangtools.yang.parser.util.ParserListenerUtils.*; +import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.checkMissingBody; +import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.createListKey; +import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.getConfig; +import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.getIdentityrefBase; +import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.parseConstraints; +import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.parseDefault; +import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.parseRefine; +import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.parseSchemaNodeArgs; +import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.parseStatus; +import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.parseTypeWithBody; +import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.parseUnits; +import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.parseUnknownTypeWithBody; +import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.parseUserOrdered; +import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.parseYinValue; +import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.stringFromNode; + +import com.google.common.base.Splitter; +import com.google.common.base.Strings; +import com.google.common.collect.Iterables; import java.net.URI; import java.text.DateFormat; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; +import java.util.Iterator; import java.util.List; -import java.util.Stack; import org.antlr.v4.runtime.tree.ParseTree; -import org.opendaylight.yangtools.antlrv4.code.gen.*; +import org.opendaylight.yangtools.antlrv4.code.gen.YangParser; import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Argument_stmtContext; import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Base_stmtContext; import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Contact_stmtContext; @@ -49,13 +67,15 @@ import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Type_body_stmtsCon import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Units_stmtContext; import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.When_stmtContext; import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Yang_version_stmtContext; +import org.opendaylight.yangtools.antlrv4.code.gen.YangParserBaseListener; import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.common.QNameModule; import org.opendaylight.yangtools.yang.model.api.SchemaPath; import org.opendaylight.yangtools.yang.model.api.TypeDefinition; import org.opendaylight.yangtools.yang.model.util.BaseTypes; -import org.opendaylight.yangtools.yang.model.util.YangTypesConverter; import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder; import org.opendaylight.yangtools.yang.parser.builder.api.Builder; +import org.opendaylight.yangtools.yang.parser.builder.api.ExtensionBuilder; import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder; import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder; import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder; @@ -64,7 +84,6 @@ import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceBuilder; import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceCaseBuilder; import org.opendaylight.yangtools.yang.parser.builder.impl.ContainerSchemaNodeBuilder; import org.opendaylight.yangtools.yang.parser.builder.impl.DeviationBuilder; -import org.opendaylight.yangtools.yang.parser.builder.impl.ExtensionBuilder; import org.opendaylight.yangtools.yang.parser.builder.impl.FeatureBuilder; import org.opendaylight.yangtools.yang.parser.builder.impl.IdentitySchemaNodeBuilder; import org.opendaylight.yangtools.yang.parser.builder.impl.LeafListSchemaNodeBuilder; @@ -72,41 +91,71 @@ import org.opendaylight.yangtools.yang.parser.builder.impl.LeafSchemaNodeBuilder import org.opendaylight.yangtools.yang.parser.builder.impl.ListSchemaNodeBuilder; import org.opendaylight.yangtools.yang.parser.builder.impl.ModuleBuilder; import org.opendaylight.yangtools.yang.parser.builder.impl.NotificationBuilder; +import org.opendaylight.yangtools.yang.parser.builder.impl.RefineHolderImpl; import org.opendaylight.yangtools.yang.parser.builder.impl.RpcDefinitionBuilder; import org.opendaylight.yangtools.yang.parser.builder.impl.UnionTypeBuilder; -import org.opendaylight.yangtools.yang.parser.builder.impl.UnknownSchemaNodeBuilder; -import org.opendaylight.yangtools.yang.parser.util.RefineHolder; +import org.opendaylight.yangtools.yang.parser.builder.impl.UnknownSchemaNodeBuilderImpl; import org.slf4j.Logger; import org.slf4j.LoggerFactory; public final class YangParserListenerImpl extends YangParserBaseListener { - private static final Logger logger = LoggerFactory.getLogger(YangParserListenerImpl.class); - + private static final Logger LOG = LoggerFactory.getLogger(YangParserListenerImpl.class); + private static final Splitter COLON_SPLITTER = Splitter.on(':'); + private static final String AUGMENT_STR = "augment"; + + private final DateFormat SIMPLE_DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd"); + private final SchemaPathStack stack = new SchemaPathStack(); + private final String sourcePath; + private QName moduleQName = new QName(null, new Date(0L), null, "dummy"); private ModuleBuilder moduleBuilder; private String moduleName; - private URI namespace; - private String yangModelPrefix; - private Date revision = new Date(0L); + private int augmentOrder; + + public YangParserListenerImpl(final String sourcePath) { + this.sourcePath = sourcePath; + } - public final static DateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd"); - private final Stack> actualPath = new Stack<>(); + @Override + public void enterModule_stmt(final YangParser.Module_stmtContext ctx) { + moduleName = stringFromNode(ctx); + LOG.trace("entering module {}", moduleName); + enterLog("module", moduleName, 0); + stack.push(); - private void addNodeToPath(QName name) { - actualPath.peek().push(name); + moduleBuilder = new ModuleBuilder(moduleName, sourcePath); + + String description = null; + String reference = null; + for (int i = 0; i < ctx.getChildCount(); i++) { + ParseTree child = ctx.getChild(i); + if (child instanceof Description_stmtContext) { + description = stringFromNode(child); + } else if (child instanceof Reference_stmtContext) { + reference = stringFromNode(child); + } else { + if (description != null && reference != null) { + break; + } + } + } + moduleBuilder.setDescription(description); + moduleBuilder.setReference(reference); } - private QName removeNodeFromPath() { - return actualPath.peek().pop(); + @Override + public void exitModule_stmt(final YangParser.Module_stmtContext ctx) { + exitLog("module"); + stack.pop(); } @Override - public void enterModule_stmt(YangParser.Module_stmtContext ctx) { + public void enterSubmodule_stmt(final YangParser.Submodule_stmtContext ctx) { moduleName = stringFromNode(ctx); - logger.debug("entering module " + moduleName); - enterLog("module", moduleName, 0); - actualPath.push(new Stack()); + LOG.trace("entering submodule {}", moduleName); + enterLog("submodule", moduleName, 0); + stack.push(); - moduleBuilder = new ModuleBuilder(moduleName); + moduleBuilder = new ModuleBuilder(moduleName, true, sourcePath); String description = null; String reference = null; @@ -127,24 +176,31 @@ public final class YangParserListenerImpl extends YangParserBaseListener { } @Override - public void exitModule_stmt(YangParser.Module_stmtContext ctx) { - exitLog("module", ""); - actualPath.pop(); + public void exitSubmodule_stmt(final YangParser.Submodule_stmtContext ctx) { + exitLog("submodule"); + stack.pop(); + } + + @Override + public void enterBelongs_to_stmt(final YangParser.Belongs_to_stmtContext ctx) { + moduleBuilder.setBelongsTo(stringFromNode(ctx)); } @Override - public void enterModule_header_stmts(Module_header_stmtsContext ctx) { + public void enterModule_header_stmts(final Module_header_stmtsContext ctx) { enterLog("module_header", "", ctx.getStart().getLine()); String yangVersion = null; for (int i = 0; i < ctx.getChildCount(); ++i) { final ParseTree treeNode = ctx.getChild(i); if (treeNode instanceof Namespace_stmtContext) { final String namespaceStr = stringFromNode(treeNode); - namespace = URI.create(namespaceStr); - moduleBuilder.setNamespace(namespace); + final URI namespace = URI.create(namespaceStr); + this.moduleQName = new QName(namespace, moduleQName.getRevision(), moduleQName.getPrefix(), moduleQName.getLocalName()); + moduleBuilder.setQNameModule(moduleQName.getModule()); setLog("namespace", namespaceStr); } else if (treeNode instanceof Prefix_stmtContext) { - yangModelPrefix = stringFromNode(treeNode); + final String yangModelPrefix = stringFromNode(treeNode); + this.moduleQName = QName.create(moduleQName.getModule(), yangModelPrefix, moduleQName.getLocalName()); moduleBuilder.setPrefix(yangModelPrefix); setLog("prefix", yangModelPrefix); } else if (treeNode instanceof Yang_version_stmtContext) { @@ -160,12 +216,12 @@ public final class YangParserListenerImpl extends YangParserBaseListener { } @Override - public void exitModule_header_stmts(Module_header_stmtsContext ctx) { - exitLog("module_header", ""); + public void exitModule_header_stmts(final Module_header_stmtsContext ctx) { + exitLog("module_header"); } @Override - public void enterMeta_stmts(YangParser.Meta_stmtsContext ctx) { + public void enterMeta_stmts(final YangParser.Meta_stmtsContext ctx) { enterLog("meta_stmt", "", ctx.getStart().getLine()); for (int i = 0; i < ctx.getChildCount(); i++) { ParseTree child = ctx.getChild(i); @@ -190,12 +246,12 @@ public final class YangParserListenerImpl extends YangParserBaseListener { } @Override - public void exitMeta_stmts(YangParser.Meta_stmtsContext ctx) { - exitLog("meta_stmt", ""); + public void exitMeta_stmts(final YangParser.Meta_stmtsContext ctx) { + exitLog("meta_stmt"); } @Override - public void enterRevision_stmts(Revision_stmtsContext ctx) { + public void enterRevision_stmts(final Revision_stmtsContext ctx) { enterLog("revisions", "", ctx.getStart().getLine()); for (int i = 0; i < ctx.getChildCount(); ++i) { final ParseTree treeNode = ctx.getChild(i); @@ -206,18 +262,18 @@ public final class YangParserListenerImpl extends YangParserBaseListener { } @Override - public void exitRevision_stmts(Revision_stmtsContext ctx) { - exitLog("revisions", ""); + public void exitRevision_stmts(final Revision_stmtsContext ctx) { + exitLog("revisions"); } private void updateRevisionForRevisionStatement(final ParseTree treeNode) { final String revisionDateStr = stringFromNode(treeNode); try { - final Date revision = simpleDateFormat.parse(revisionDateStr); - if ((revision != null) && (this.revision.compareTo(revision) < 0)) { - this.revision = revision; - moduleBuilder.setRevision(this.revision); - setLog("revision", this.revision.toString()); + final Date revisionDate = SIMPLE_DATE_FORMAT.parse(revisionDateStr); + if ((revisionDate != null) && (this.moduleQName.getRevision().compareTo(revisionDate) < 0)) { + this.moduleQName = new QName(moduleQName.getNamespace(), revisionDate, moduleQName.getPrefix(), moduleQName.getLocalName()); + moduleBuilder.setQNameModule(moduleQName.getModule()); + setLog("revision", revisionDate.toString()); for (int i = 0; i < treeNode.getChildCount(); ++i) { ParseTree child = treeNode.getChild(i); if (child instanceof Reference_stmtContext) { @@ -226,13 +282,12 @@ public final class YangParserListenerImpl extends YangParserBaseListener { } } } catch (ParseException e) { - final String message = "Failed to parse revision string: " + revisionDateStr; - logger.warn(message); + LOG.warn("Failed to parse revision string: {}", revisionDateStr, e); } } @Override - public void enterImport_stmt(Import_stmtContext ctx) { + public void enterImport_stmt(final Import_stmtContext ctx) { final int line = ctx.getStart().getLine(); final String importName = stringFromNode(ctx); enterLog("import", importName, line); @@ -248,29 +303,29 @@ public final class YangParserListenerImpl extends YangParserBaseListener { if (treeNode instanceof Revision_date_stmtContext) { String importRevisionStr = stringFromNode(treeNode); try { - importRevision = simpleDateFormat.parse(importRevisionStr); + importRevision = SIMPLE_DATE_FORMAT.parse(importRevisionStr); } catch (ParseException e) { - logger.warn("Failed to parse import revision-date at line " + line + ": " + importRevisionStr); + LOG.warn("Failed to parse import revision-date at line {}: {}", line, importRevisionStr, e); } } } moduleBuilder.addModuleImport(importName, importRevision, importPrefix); - setLog("import", "(" + importName + "; " + importRevision + "; " + importPrefix + ")"); + LOG.trace("setting import ({}; {}; {})", importName, importRevision, importPrefix); } @Override - public void exitImport_stmt(Import_stmtContext ctx) { - exitLog("import", ""); + public void exitImport_stmt(final Import_stmtContext ctx) { + exitLog("import"); } @Override - public void enterAugment_stmt(YangParser.Augment_stmtContext ctx) { + public void enterAugment_stmt(final YangParser.Augment_stmtContext ctx) { final int line = ctx.getStart().getLine(); final String augmentPath = stringFromNode(ctx); - enterLog("augment", augmentPath, line); - actualPath.push(new Stack()); + enterLog(AUGMENT_STR, augmentPath, line); + stack.push(); - AugmentationSchemaBuilder builder = moduleBuilder.addAugment(line, augmentPath); + AugmentationSchemaBuilder builder = moduleBuilder.addAugment(line, augmentPath, augmentOrder++); for (int i = 0; i < ctx.getChildCount(); i++) { ParseTree child = ctx.getChild(i); @@ -289,23 +344,21 @@ public final class YangParserListenerImpl extends YangParserBaseListener { } @Override - public void exitAugment_stmt(YangParser.Augment_stmtContext ctx) { + public void exitAugment_stmt(final YangParser.Augment_stmtContext ctx) { moduleBuilder.exitNode(); - exitLog("augment", ""); - actualPath.pop(); + exitLog(AUGMENT_STR); + stack.pop(); } @Override - public void enterExtension_stmt(YangParser.Extension_stmtContext ctx) { + public void enterExtension_stmt(final YangParser.Extension_stmtContext ctx) { final int line = ctx.getStart().getLine(); final String extName = stringFromNode(ctx); enterLog("extension", extName, line); - QName qname = new QName(namespace, revision, yangModelPrefix, extName); - addNodeToPath(qname); - SchemaPath path = createActualSchemaPath(actualPath.peek()); + QName qname = QName.create(moduleQName, extName); + SchemaPath path = stack.addNodeToPath(qname); - ExtensionBuilder builder = moduleBuilder.addExtension(qname, line); - builder.setPath(path); + ExtensionBuilder builder = moduleBuilder.addExtension(qname, line, path); parseSchemaNodeArgs(ctx, builder); String argument = null; @@ -325,22 +378,20 @@ public final class YangParserListenerImpl extends YangParserBaseListener { } @Override - public void exitExtension_stmt(YangParser.Extension_stmtContext ctx) { + public void exitExtension_stmt(final YangParser.Extension_stmtContext ctx) { moduleBuilder.exitNode(); - exitLog("extension", removeNodeFromPath()); + exitLog("extension", stack.removeNodeFromPath()); } @Override - public void enterTypedef_stmt(YangParser.Typedef_stmtContext ctx) { + public void enterTypedef_stmt(final YangParser.Typedef_stmtContext ctx) { final int line = ctx.getStart().getLine(); final String typedefName = stringFromNode(ctx); enterLog("typedef", typedefName, line); - QName typedefQName = new QName(namespace, revision, yangModelPrefix, typedefName); - addNodeToPath(typedefQName); - SchemaPath path = createActualSchemaPath(actualPath.peek()); + QName typedefQName = QName.create(moduleQName, typedefName); + SchemaPath path = stack.addNodeToPath(typedefQName); - TypeDefinitionBuilder builder = moduleBuilder.addTypedef(line, typedefQName); - builder.setPath(path); + TypeDefinitionBuilder builder = moduleBuilder.addTypedef(line, typedefQName, path); parseSchemaNodeArgs(ctx, builder); builder.setUnits(parseUnits(ctx)); builder.setDefaultValue(parseDefault(ctx)); @@ -349,20 +400,20 @@ public final class YangParserListenerImpl extends YangParserBaseListener { } @Override - public void exitTypedef_stmt(YangParser.Typedef_stmtContext ctx) { + public void exitTypedef_stmt(final YangParser.Typedef_stmtContext ctx) { moduleBuilder.exitNode(); - exitLog("typedef", removeNodeFromPath()); + exitLog("typedef", stack.removeNodeFromPath()); } @Override - public void enterType_stmt(YangParser.Type_stmtContext ctx) { + public void enterType_stmt(final YangParser.Type_stmtContext ctx) { final int line = ctx.getStart().getLine(); final String typeName = stringFromNode(ctx); enterLog("type", typeName, line); final QName typeQName = parseQName(typeName); - TypeDefinition type = null; + TypeDefinition type; Type_body_stmtsContext typeBody = null; for (int i = 0; i < ctx.getChildCount(); i++) { if (ctx.getChild(i) instanceof Type_body_stmtsContext) { @@ -372,106 +423,105 @@ public final class YangParserListenerImpl extends YangParserBaseListener { } // if this is base yang type... - if (YangTypesConverter.isBaseYangType(typeName)) { + if (BaseTypes.isYangBuildInType(typeName)) { if (typeBody == null) { // check for types which must have body checkMissingBody(typeName, moduleName, line); // if there are no constraints, just grab default base yang type - type = YangTypesConverter.javaTypeForBaseYangType(typeName); - addNodeToPath(type.getQName()); + type = BaseTypes.defaultBaseTypeFor(typeName).orNull(); + stack.addNodeToPath(type.getQName()); moduleBuilder.setType(type); } else { - if ("union".equals(typeName)) { - QName qname = BaseTypes.constructQName("union"); - addNodeToPath(qname); - UnionTypeBuilder unionBuilder = moduleBuilder.addUnionType(line, namespace, revision); + QName qname; + switch (typeName) { + case "union": + qname = BaseTypes.UNION_QNAME; + stack.addNodeToPath(qname); + UnionTypeBuilder unionBuilder = moduleBuilder.addUnionType(line, moduleQName.getModule()); Builder parent = moduleBuilder.getActualNode(); unionBuilder.setParent(parent); moduleBuilder.enterNode(unionBuilder); - } else if ("identityref".equals(typeName)) { - QName qname = BaseTypes.constructQName("identityref"); - addNodeToPath(qname); - SchemaPath path = createActualSchemaPath(actualPath.peek()); + break; + case "identityref": + qname = BaseTypes.IDENTITYREF_QNAME; + SchemaPath path = stack.addNodeToPath(qname); moduleBuilder.addIdentityrefType(line, path, getIdentityrefBase(typeBody)); - } else { - type = parseTypeWithBody(typeName, typeBody, actualPath.peek(), namespace, revision, yangModelPrefix, moduleBuilder.getActualNode()); + break; + default: + type = parseTypeWithBody(typeName, typeBody, stack.currentSchemaPath(), moduleQName, moduleBuilder.getActualNode()); moduleBuilder.setType(type); - addNodeToPath(type.getQName()); + stack.addNodeToPath(type.getQName()); } } } else { - type = parseUnknownTypeWithBody(typeQName, typeBody, actualPath.peek(), namespace, revision, yangModelPrefix, - moduleBuilder.getActualNode()); + type = parseUnknownTypeWithBody(typeQName, typeBody, stack.currentSchemaPath(), moduleQName, moduleBuilder.getActualNode()); // add parent node of this type statement to dirty nodes moduleBuilder.markActualNodeDirty(); moduleBuilder.setType(type); - addNodeToPath(type.getQName()); + stack.addNodeToPath(type.getQName()); } } - private QName parseQName(String typeName) { - QName typeQName; - if (typeName.contains(":")) { - String[] splittedName = typeName.split(":"); - String prefix = splittedName[0]; - String name = splittedName[1]; - if (prefix.equals(yangModelPrefix)) { - typeQName = new QName(namespace, revision, prefix, name); + private QName parseQName(final String typeName) { + final QName typeQName; + if (typeName.indexOf(':') != -1) { + final Iterator split = COLON_SPLITTER.split(typeName).iterator(); + final String prefix = split.next(); + final String name = split.next(); + if (prefix.equals(moduleQName.getPrefix())) { + typeQName = QName.create(moduleQName, name); } else { - typeQName = new QName(null, null, prefix, name); + typeQName = QName.create(QNameModule.create(null, null), prefix, name); } } else { - typeQName = new QName(namespace, revision, yangModelPrefix, typeName); + typeQName = QName.create(moduleQName, typeName); } return typeQName; } @Override - public void exitType_stmt(YangParser.Type_stmtContext ctx) { + public void exitType_stmt(final YangParser.Type_stmtContext ctx) { final String typeName = stringFromNode(ctx); if ("union".equals(typeName)) { moduleBuilder.exitNode(); } - exitLog("type", removeNodeFromPath()); + exitLog("type", stack.removeNodeFromPath()); } @Override - public void enterGrouping_stmt(YangParser.Grouping_stmtContext ctx) { + public void enterGrouping_stmt(final YangParser.Grouping_stmtContext ctx) { final int line = ctx.getStart().getLine(); final String groupName = stringFromNode(ctx); enterLog("grouping", groupName, line); - QName groupQName = new QName(namespace, revision, yangModelPrefix, groupName); - addNodeToPath(groupQName); - SchemaPath path = createActualSchemaPath(actualPath.peek()); + QName groupQName = QName.create(moduleQName, groupName); + SchemaPath path = stack.addNodeToPath(groupQName); - GroupingBuilder builder = moduleBuilder.addGrouping(ctx.getStart().getLine(), groupQName); - builder.setPath(path); + GroupingBuilder builder = moduleBuilder.addGrouping(ctx.getStart().getLine(), groupQName, path); parseSchemaNodeArgs(ctx, builder); moduleBuilder.enterNode(builder); } @Override - public void exitGrouping_stmt(YangParser.Grouping_stmtContext ctx) { + public void exitGrouping_stmt(final YangParser.Grouping_stmtContext ctx) { moduleBuilder.exitNode(); - exitLog("grouping", removeNodeFromPath()); + exitLog("grouping", stack.removeNodeFromPath()); } @Override - public void enterContainer_stmt(Container_stmtContext ctx) { + public void enterContainer_stmt(final Container_stmtContext ctx) { final int line = ctx.getStart().getLine(); final String containerName = stringFromNode(ctx); enterLog("container", containerName, line); - QName containerQName = new QName(namespace, revision, yangModelPrefix, containerName); - addNodeToPath(containerQName); - SchemaPath path = createActualSchemaPath(actualPath.peek()); + QName containerQName = QName.create(moduleQName, containerName); + SchemaPath path = stack.addNodeToPath(containerQName); ContainerSchemaNodeBuilder builder = moduleBuilder.addContainerNode(line, containerQName, path); parseSchemaNodeArgs(ctx, builder); parseConstraints(ctx, builder.getConstraints()); - builder.setConfiguration(getConfig(ctx, moduleBuilder.getActualParent(), moduleName, line)); + builder.setConfiguration(getConfig(ctx, builder, moduleName, line)); for (int i = 0; i < ctx.getChildCount(); ++i) { final ParseTree childNode = ctx.getChild(i); @@ -485,25 +535,24 @@ public final class YangParserListenerImpl extends YangParserBaseListener { } @Override - public void exitContainer_stmt(Container_stmtContext ctx) { + public void exitContainer_stmt(final Container_stmtContext ctx) { moduleBuilder.exitNode(); - exitLog("container", removeNodeFromPath()); + exitLog("container", stack.removeNodeFromPath()); } @Override - public void enterLeaf_stmt(Leaf_stmtContext ctx) { + public void enterLeaf_stmt(final Leaf_stmtContext ctx) { final int line = ctx.getStart().getLine(); final String leafName = stringFromNode(ctx); enterLog("leaf", leafName, line); - QName leafQName = new QName(namespace, revision, yangModelPrefix, leafName); - addNodeToPath(leafQName); - SchemaPath path = createActualSchemaPath(actualPath.peek()); + QName leafQName = QName.create(moduleQName, leafName); + SchemaPath path = stack.addNodeToPath(leafQName); LeafSchemaNodeBuilder builder = moduleBuilder.addLeafNode(line, leafQName, path); parseSchemaNodeArgs(ctx, builder); parseConstraints(ctx, builder.getConstraints()); - builder.setConfiguration(getConfig(ctx, moduleBuilder.getActualParent(), moduleName, line)); + builder.setConfiguration(getConfig(ctx, builder, moduleName, line)); String defaultStr = null; String unitsStr = null; @@ -522,13 +571,13 @@ public final class YangParserListenerImpl extends YangParserBaseListener { } @Override - public void exitLeaf_stmt(YangParser.Leaf_stmtContext ctx) { + public void exitLeaf_stmt(final YangParser.Leaf_stmtContext ctx) { moduleBuilder.exitNode(); - exitLog("leaf", removeNodeFromPath()); + exitLog("leaf", stack.removeNodeFromPath()); } @Override - public void enterUses_stmt(YangParser.Uses_stmtContext ctx) { + public void enterUses_stmt(final YangParser.Uses_stmtContext ctx) { final int line = ctx.getStart().getLine(); final String groupingPathStr = stringFromNode(ctx); enterLog("uses", groupingPathStr, line); @@ -539,19 +588,19 @@ public final class YangParserListenerImpl extends YangParserBaseListener { } @Override - public void exitUses_stmt(YangParser.Uses_stmtContext ctx) { + public void exitUses_stmt(final YangParser.Uses_stmtContext ctx) { moduleBuilder.exitNode(); - exitLog("uses", ""); + exitLog("uses"); } @Override - public void enterUses_augment_stmt(YangParser.Uses_augment_stmtContext ctx) { - actualPath.push(new Stack()); + public void enterUses_augment_stmt(final YangParser.Uses_augment_stmtContext ctx) { final int line = ctx.getStart().getLine(); final String augmentPath = stringFromNode(ctx); - enterLog("augment", augmentPath, line); + enterLog(AUGMENT_STR, augmentPath, line); + stack.push(); - AugmentationSchemaBuilder builder = moduleBuilder.addAugment(line, augmentPath); + AugmentationSchemaBuilder builder = moduleBuilder.addAugment(line, augmentPath, augmentOrder++); for (int i = 0; i < ctx.getChildCount(); i++) { ParseTree child = ctx.getChild(i); @@ -570,43 +619,42 @@ public final class YangParserListenerImpl extends YangParserBaseListener { } @Override - public void exitUses_augment_stmt(YangParser.Uses_augment_stmtContext ctx) { + public void exitUses_augment_stmt(final YangParser.Uses_augment_stmtContext ctx) { moduleBuilder.exitNode(); - exitLog("augment", ""); - actualPath.pop(); + exitLog(AUGMENT_STR); + stack.pop(); } @Override - public void enterRefine_stmt(YangParser.Refine_stmtContext ctx) { + public void enterRefine_stmt(final YangParser.Refine_stmtContext ctx) { final String refineString = stringFromNode(ctx); enterLog("refine", refineString, ctx.getStart().getLine()); - RefineHolder refine = parseRefine(ctx, moduleName); + RefineHolderImpl refine = parseRefine(ctx, moduleName); moduleBuilder.addRefine(refine); moduleBuilder.enterNode(refine); } @Override - public void exitRefine_stmt(YangParser.Refine_stmtContext ctx) { + public void exitRefine_stmt(final YangParser.Refine_stmtContext ctx) { moduleBuilder.exitNode(); - exitLog("refine", ""); + exitLog("refine"); } @Override - public void enterLeaf_list_stmt(Leaf_list_stmtContext ctx) { + public void enterLeaf_list_stmt(final Leaf_list_stmtContext ctx) { final int line = ctx.getStart().getLine(); final String leafListName = stringFromNode(ctx); enterLog("leaf-list", leafListName, line); - QName leafListQName = new QName(namespace, revision, yangModelPrefix, leafListName); - addNodeToPath(leafListQName); - SchemaPath path = createActualSchemaPath(actualPath.peek()); + QName leafListQName = QName.create(moduleQName, leafListName); + SchemaPath path = stack.addNodeToPath(leafListQName); LeafListSchemaNodeBuilder builder = moduleBuilder.addLeafListNode(line, leafListQName, path); moduleBuilder.enterNode(builder); parseSchemaNodeArgs(ctx, builder); parseConstraints(ctx, builder.getConstraints()); - builder.setConfiguration(getConfig(ctx, moduleBuilder.getActualParent(), moduleName, ctx.getStart().getLine())); + builder.setConfiguration(getConfig(ctx, builder, moduleName, ctx.getStart().getLine())); for (int i = 0; i < ctx.getChildCount(); ++i) { final ParseTree childNode = ctx.getChild(i); @@ -620,29 +668,27 @@ public final class YangParserListenerImpl extends YangParserBaseListener { } @Override - public void exitLeaf_list_stmt(YangParser.Leaf_list_stmtContext ctx) { + public void exitLeaf_list_stmt(final YangParser.Leaf_list_stmtContext ctx) { moduleBuilder.exitNode(); - exitLog("leaf-list", removeNodeFromPath()); + exitLog("leaf-list", stack.removeNodeFromPath()); } @Override - public void enterList_stmt(List_stmtContext ctx) { + public void enterList_stmt(final List_stmtContext ctx) { final int line = ctx.getStart().getLine(); final String listName = stringFromNode(ctx); enterLog("list", listName, line); - QName listQName = new QName(namespace, revision, yangModelPrefix, listName); - addNodeToPath(listQName); - SchemaPath path = createActualSchemaPath(actualPath.peek()); + QName listQName = QName.create(moduleQName, listName); + SchemaPath path = stack.addNodeToPath(listQName); ListSchemaNodeBuilder builder = moduleBuilder.addListNode(line, listQName, path); moduleBuilder.enterNode(builder); parseSchemaNodeArgs(ctx, builder); parseConstraints(ctx, builder.getConstraints()); - builder.setConfiguration(getConfig(ctx, moduleBuilder.getActualParent(), moduleName, line)); + builder.setConfiguration(getConfig(ctx, builder, moduleName, line)); - String keyDefinition = ""; for (int i = 0; i < ctx.getChildCount(); ++i) { ParseTree childNode = ctx.getChild(i); if (childNode instanceof Ordered_by_stmtContext) { @@ -650,60 +696,56 @@ public final class YangParserListenerImpl extends YangParserBaseListener { final boolean userOrdered = parseUserOrdered(orderedBy); builder.setUserOrdered(userOrdered); } else if (childNode instanceof Key_stmtContext) { - keyDefinition = stringFromNode(childNode); - List key = createListKey(keyDefinition, namespace, revision, yangModelPrefix); - builder.setKeyDefinition(key); + List key = createListKey((Key_stmtContext) childNode); + builder.setKeys(key); } } } @Override - public void exitList_stmt(List_stmtContext ctx) { + public void exitList_stmt(final List_stmtContext ctx) { moduleBuilder.exitNode(); - exitLog("list", removeNodeFromPath()); + exitLog("list", stack.removeNodeFromPath()); } @Override - public void enterAnyxml_stmt(YangParser.Anyxml_stmtContext ctx) { + public void enterAnyxml_stmt(final YangParser.Anyxml_stmtContext ctx) { final int line = ctx.getStart().getLine(); final String anyXmlName = stringFromNode(ctx); enterLog("anyxml", anyXmlName, line); - QName anyXmlQName = new QName(namespace, revision, yangModelPrefix, anyXmlName); - addNodeToPath(anyXmlQName); - SchemaPath path = createActualSchemaPath(actualPath.peek()); + QName anyXmlQName = QName.create(moduleQName, anyXmlName); + SchemaPath path = stack.addNodeToPath(anyXmlQName); AnyXmlBuilder builder = moduleBuilder.addAnyXml(line, anyXmlQName, path); moduleBuilder.enterNode(builder); parseSchemaNodeArgs(ctx, builder); parseConstraints(ctx, builder.getConstraints()); - builder.setConfiguration(getConfig(ctx, moduleBuilder.getActualParent(), moduleName, line)); + builder.setConfiguration(getConfig(ctx, builder, moduleName, line)); } @Override - public void exitAnyxml_stmt(YangParser.Anyxml_stmtContext ctx) { + public void exitAnyxml_stmt(final YangParser.Anyxml_stmtContext ctx) { moduleBuilder.exitNode(); - exitLog("anyxml", removeNodeFromPath()); + exitLog("anyxml", stack.removeNodeFromPath()); } @Override - public void enterChoice_stmt(YangParser.Choice_stmtContext ctx) { + public void enterChoice_stmt(final YangParser.Choice_stmtContext ctx) { final int line = ctx.getStart().getLine(); final String choiceName = stringFromNode(ctx); enterLog("choice", choiceName, line); - QName choiceQName = new QName(namespace, revision, yangModelPrefix, choiceName); - addNodeToPath(choiceQName); - SchemaPath path = createActualSchemaPath(actualPath.peek()); + QName choiceQName = QName.create(moduleQName, choiceName); + SchemaPath path = stack.addNodeToPath(choiceQName); - ChoiceBuilder builder = moduleBuilder.addChoice(line, choiceQName); - builder.setPath(path); + ChoiceBuilder builder = moduleBuilder.addChoice(line, choiceQName, path); moduleBuilder.enterNode(builder); parseSchemaNodeArgs(ctx, builder); parseConstraints(ctx, builder.getConstraints()); - builder.setConfiguration(getConfig(ctx, moduleBuilder.getActualParent(), moduleName, line)); + builder.setConfiguration(getConfig(ctx, builder, moduleName, line)); // set 'default' case for (int i = 0; i < ctx.getChildCount(); i++) { @@ -717,23 +759,21 @@ public final class YangParserListenerImpl extends YangParserBaseListener { } @Override - public void exitChoice_stmt(YangParser.Choice_stmtContext ctx) { + public void exitChoice_stmt(final YangParser.Choice_stmtContext ctx) { moduleBuilder.exitNode(); - exitLog("choice", removeNodeFromPath()); + exitLog("choice", stack.removeNodeFromPath()); } @Override - public void enterCase_stmt(YangParser.Case_stmtContext ctx) { + public void enterCase_stmt(final YangParser.Case_stmtContext ctx) { final int line = ctx.getStart().getLine(); final String caseName = stringFromNode(ctx); enterLog("case", caseName, line); - QName caseQName = new QName(namespace, revision, yangModelPrefix, caseName); - addNodeToPath(caseQName); - SchemaPath path = createActualSchemaPath(actualPath.peek()); + QName caseQName = QName.create(moduleQName, caseName); + SchemaPath path = stack.addNodeToPath(caseQName); - ChoiceCaseBuilder builder = moduleBuilder.addCase(line, caseQName); - builder.setPath(path); + ChoiceCaseBuilder builder = moduleBuilder.addCase(line, caseQName, path); moduleBuilder.enterNode(builder); parseSchemaNodeArgs(ctx, builder); @@ -741,174 +781,162 @@ public final class YangParserListenerImpl extends YangParserBaseListener { } @Override - public void exitCase_stmt(YangParser.Case_stmtContext ctx) { + public void exitCase_stmt(final YangParser.Case_stmtContext ctx) { moduleBuilder.exitNode(); - exitLog("case", removeNodeFromPath()); + exitLog("case", stack.removeNodeFromPath()); } @Override - public void enterNotification_stmt(YangParser.Notification_stmtContext ctx) { + public void enterNotification_stmt(final YangParser.Notification_stmtContext ctx) { final int line = ctx.getStart().getLine(); final String notificationName = stringFromNode(ctx); enterLog("notification", notificationName, line); - QName notificationQName = new QName(namespace, revision, yangModelPrefix, notificationName); - addNodeToPath(notificationQName); - SchemaPath path = createActualSchemaPath(actualPath.peek()); + QName notificationQName = QName.create(moduleQName, notificationName); + SchemaPath path = stack.addNodeToPath(notificationQName); - NotificationBuilder builder = moduleBuilder.addNotification(line, notificationQName); - builder.setPath(path); + NotificationBuilder builder = moduleBuilder.addNotification(line, notificationQName, path); moduleBuilder.enterNode(builder); parseSchemaNodeArgs(ctx, builder); } @Override - public void exitNotification_stmt(YangParser.Notification_stmtContext ctx) { + public void exitNotification_stmt(final YangParser.Notification_stmtContext ctx) { moduleBuilder.exitNode(); - exitLog("notification", removeNodeFromPath()); + exitLog("notification", stack.removeNodeFromPath()); } // Unknown nodes @Override - public void enterIdentifier_stmt(YangParser.Identifier_stmtContext ctx) { - final int line = ctx.getStart().getLine(); - final String nodeParameter = stringFromNode(ctx); - enterLog("unknown-node", nodeParameter, line); + public void enterIdentifier_stmt(final YangParser.Identifier_stmtContext ctx) { + handleUnknownNode(ctx.getStart().getLine(), ctx); + } - QName nodeType = null; + @Override + public void exitIdentifier_stmt(final YangParser.Identifier_stmtContext ctx) { + moduleBuilder.exitNode(); + exitLog("unknown-node", stack.removeNodeFromPath()); + } - final String nodeTypeStr = ctx.getChild(0).getText(); - final String[] splittedElement = nodeTypeStr.split(":"); - if (splittedElement.length == 1) { - nodeType = new QName(namespace, revision, yangModelPrefix, splittedElement[0]); - } else { - nodeType = new QName(namespace, revision, splittedElement[0], splittedElement[1]); - } + @Override public void enterUnknown_statement(final YangParser.Unknown_statementContext ctx) { + handleUnknownNode(ctx.getStart().getLine(), ctx); + } - QName qname; - if (nodeParameter != null) { - String[] splittedName = nodeParameter.split(":"); - if (splittedName.length == 2) { - qname = new QName(null, null, splittedName[0], splittedName[1]); - } else { - qname = new QName(namespace, revision, yangModelPrefix, splittedName[0]); - } - } else { - qname = new QName(namespace, revision, yangModelPrefix, nodeParameter); - } + @Override public void exitUnknown_statement(final YangParser.Unknown_statementContext ctx) { + moduleBuilder.exitNode(); + exitLog("unknown-node", stack.removeNodeFromPath()); + } - UnknownSchemaNodeBuilder builder = moduleBuilder.addUnknownSchemaNode(line, qname); - builder.setNodeType(nodeType); - builder.setNodeParameter(nodeParameter); - addNodeToPath(new QName(namespace, revision, yangModelPrefix, nodeParameter)); + @Override public void enterUnknown_statement2(final YangParser.Unknown_statement2Context ctx) { + handleUnknownNode(ctx.getStart().getLine(), ctx); + } - SchemaPath path = createActualSchemaPath(actualPath.peek()); - builder.setPath(path); + @Override public void exitUnknown_statement2(final YangParser.Unknown_statement2Context ctx) { + moduleBuilder.exitNode(); + exitLog("unknown-node", stack.removeNodeFromPath()); + } - parseSchemaNodeArgs(ctx, builder); - moduleBuilder.enterNode(builder); + @Override public void enterUnknown_statement3(final YangParser.Unknown_statement3Context ctx) { + handleUnknownNode(ctx.getStart().getLine(), ctx); } - @Override - public void exitIdentifier_stmt(YangParser.Identifier_stmtContext ctx) { + @Override public void exitUnknown_statement3(final YangParser.Unknown_statement3Context ctx) { moduleBuilder.exitNode(); - exitLog("unknown-node", removeNodeFromPath()); + exitLog("unknown-node", stack.removeNodeFromPath()); } @Override - public void enterRpc_stmt(YangParser.Rpc_stmtContext ctx) { + public void enterRpc_stmt(final YangParser.Rpc_stmtContext ctx) { final int line = ctx.getStart().getLine(); final String rpcName = stringFromNode(ctx); enterLog("rpc", rpcName, line); - QName rpcQName = new QName(namespace, revision, yangModelPrefix, rpcName); - RpcDefinitionBuilder rpcBuilder = moduleBuilder.addRpc(line, rpcQName); + QName rpcQName = QName.create(moduleQName, rpcName); + SchemaPath path = stack.addNodeToPath(rpcQName); + + RpcDefinitionBuilder rpcBuilder = moduleBuilder.addRpc(line, rpcQName, path); moduleBuilder.enterNode(rpcBuilder); - addNodeToPath(rpcQName); - SchemaPath path = createActualSchemaPath(actualPath.peek()); - rpcBuilder.setPath(path); parseSchemaNodeArgs(ctx, rpcBuilder); } @Override - public void exitRpc_stmt(YangParser.Rpc_stmtContext ctx) { + public void exitRpc_stmt(final YangParser.Rpc_stmtContext ctx) { moduleBuilder.exitNode(); - exitLog("rpc", removeNodeFromPath()); + exitLog("rpc", stack.removeNodeFromPath()); } @Override - public void enterInput_stmt(YangParser.Input_stmtContext ctx) { + public void enterInput_stmt(final YangParser.Input_stmtContext ctx) { final int line = ctx.getStart().getLine(); final String input = "input"; enterLog(input, input, line); - QName rpcQName = new QName(namespace, revision, yangModelPrefix, input); - addNodeToPath(rpcQName); - SchemaPath path = createActualSchemaPath(actualPath.peek()); + QName rpcQName = QName.create(moduleQName, input); + SchemaPath path = stack.addNodeToPath(rpcQName); ContainerSchemaNodeBuilder builder = moduleBuilder.addRpcInput(line, rpcQName, path); moduleBuilder.enterNode(builder); + builder.setConfiguration(true); parseSchemaNodeArgs(ctx, builder); parseConstraints(ctx, builder.getConstraints()); } @Override - public void exitInput_stmt(YangParser.Input_stmtContext ctx) { + public void exitInput_stmt(final YangParser.Input_stmtContext ctx) { moduleBuilder.exitNode(); - exitLog("input", removeNodeFromPath()); + exitLog("input", stack.removeNodeFromPath()); } @Override - public void enterOutput_stmt(YangParser.Output_stmtContext ctx) { + public void enterOutput_stmt(final YangParser.Output_stmtContext ctx) { final int line = ctx.getStart().getLine(); final String output = "output"; enterLog(output, output, line); - QName rpcQName = new QName(namespace, revision, yangModelPrefix, output); - addNodeToPath(rpcQName); - SchemaPath path = createActualSchemaPath(actualPath.peek()); + QName rpcQName = QName.create(moduleQName, output); + SchemaPath path = stack.addNodeToPath(rpcQName); ContainerSchemaNodeBuilder builder = moduleBuilder.addRpcOutput(path, rpcQName, line); moduleBuilder.enterNode(builder); + builder.setConfiguration(true); parseSchemaNodeArgs(ctx, builder); parseConstraints(ctx, builder.getConstraints()); } @Override - public void exitOutput_stmt(YangParser.Output_stmtContext ctx) { + public void exitOutput_stmt(final YangParser.Output_stmtContext ctx) { moduleBuilder.exitNode(); - exitLog("output", removeNodeFromPath()); + exitLog("output", stack.removeNodeFromPath()); } @Override - public void enterFeature_stmt(YangParser.Feature_stmtContext ctx) { + public void enterFeature_stmt(final YangParser.Feature_stmtContext ctx) { final int line = ctx.getStart().getLine(); final String featureName = stringFromNode(ctx); enterLog("feature", featureName, line); - QName featureQName = new QName(namespace, revision, yangModelPrefix, featureName); - FeatureBuilder featureBuilder = moduleBuilder.addFeature(line, featureQName); + QName featureQName = QName.create(moduleQName, featureName); + SchemaPath path = stack.addNodeToPath(featureQName); + + FeatureBuilder featureBuilder = moduleBuilder.addFeature(line, featureQName, path); moduleBuilder.enterNode(featureBuilder); - addNodeToPath(featureQName); - SchemaPath path = createActualSchemaPath(actualPath.peek()); - featureBuilder.setPath(path); parseSchemaNodeArgs(ctx, featureBuilder); } @Override - public void exitFeature_stmt(YangParser.Feature_stmtContext ctx) { + public void exitFeature_stmt(final YangParser.Feature_stmtContext ctx) { moduleBuilder.exitNode(); - exitLog("feature", removeNodeFromPath()); + exitLog("feature", stack.removeNodeFromPath()); } @Override - public void enterDeviation_stmt(YangParser.Deviation_stmtContext ctx) { + public void enterDeviation_stmt(final YangParser.Deviation_stmtContext ctx) { final int line = ctx.getStart().getLine(); final String targetPath = stringFromNode(ctx); enterLog("deviation", targetPath, line); @@ -937,24 +965,22 @@ public final class YangParserListenerImpl extends YangParserBaseListener { } @Override - public void exitDeviation_stmt(YangParser.Deviation_stmtContext ctx) { + public void exitDeviation_stmt(final YangParser.Deviation_stmtContext ctx) { moduleBuilder.exitNode(); - exitLog("deviation", ""); + exitLog("deviation"); } @Override - public void enterIdentity_stmt(YangParser.Identity_stmtContext ctx) { + public void enterIdentity_stmt(final YangParser.Identity_stmtContext ctx) { final int line = ctx.getStart().getLine(); final String identityName = stringFromNode(ctx); enterLog("identity", identityName, line); - final QName identityQName = new QName(namespace, revision, yangModelPrefix, identityName); - IdentitySchemaNodeBuilder builder = moduleBuilder.addIdentity(identityQName, line); - moduleBuilder.enterNode(builder); - addNodeToPath(identityQName); + final QName identityQName = QName.create(moduleQName, identityName); + SchemaPath path = stack.addNodeToPath(identityQName); - SchemaPath path = createActualSchemaPath(actualPath.peek()); - builder.setPath(path); + IdentitySchemaNodeBuilder builder = moduleBuilder.addIdentity(identityQName, line, path); + moduleBuilder.enterNode(builder); parseSchemaNodeArgs(ctx, builder); @@ -968,29 +994,71 @@ public final class YangParserListenerImpl extends YangParserBaseListener { } @Override - public void exitIdentity_stmt(YangParser.Identity_stmtContext ctx) { + public void exitIdentity_stmt(final YangParser.Identity_stmtContext ctx) { moduleBuilder.exitNode(); - exitLog("identity", removeNodeFromPath()); + exitLog("identity", stack.removeNodeFromPath()); } public ModuleBuilder getModuleBuilder() { return moduleBuilder; } - private void enterLog(String p1, String p2, int line) { - logger.trace("entering {} {} ({})", p1, p2, line); + private static void enterLog(final String p1, final String p2, final int line) { + LOG.trace("entering {} {} ({})", p1, p2, line); } - private void exitLog(String p1, String p2) { - logger.trace("exiting {} {}", p1, p2); + private static void exitLog(final String p1) { + LOG.trace("exiting {}", p1); } - private void exitLog(String p1, QName p2) { - logger.trace("exiting {} {}", p1, p2.getLocalName()); + private static void exitLog(final String p1, final QName p2) { + LOG.trace("exiting {} {}", p1, p2.getLocalName()); } - private void setLog(String p1, String p2) { - logger.trace("setting {} {}", p1, p2); + private static void setLog(final String p1, final String p2) { + LOG.trace("setting {} {}", p1, p2); + } + + private void handleUnknownNode(final int line, final ParseTree ctx) { + final String nodeParameter = stringFromNode(ctx); + enterLog("unknown-node", nodeParameter, line); + + final String nodeTypeStr = ctx.getChild(0).getText(); + final Iterator splittedElement = COLON_SPLITTER.split(nodeTypeStr).iterator(); + final String e0 = splittedElement.next(); + final QName nodeType; + if (splittedElement.hasNext()) { + nodeType = QName.create(moduleQName.getModule(), e0, splittedElement.next()); + } else { + nodeType = QName.create(moduleQName, e0); + } + + QName qname; + try { + if (!Strings.isNullOrEmpty(nodeParameter)) { + final Iterable splittedName = COLON_SPLITTER.split(nodeParameter); + final Iterator it = splittedName.iterator(); + + if (Iterables.size(splittedName) == 2) { + qname = QName.create(QNameModule.create(null, null), it.next(), it.next()); + } else { + qname = QName.create(moduleQName, it.next()); + } + } else { + qname = nodeType; + } + } catch (IllegalArgumentException e) { + qname = nodeType; + } + SchemaPath path = stack.addNodeToPath(qname); + + UnknownSchemaNodeBuilderImpl builder = moduleBuilder.addUnknownSchemaNode(line, qname, path); + builder.setNodeType(nodeType); + builder.setNodeParameter(nodeParameter); + + + parseSchemaNodeArgs(ctx, builder); + moduleBuilder.enterNode(builder); } }