package org.opendaylight.yangtools.yang.parser.impl;
import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.checkMissingBody;
-import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.createActualSchemaPath;
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.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.YangParser;
import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Argument_stmtContext;
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;
public final class YangParserListenerImpl extends YangParserBaseListener {
private static final Logger LOGGER = 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 Stack<Stack<QName>> actualPath = new Stack<>();
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 final DateFormat SIMPLE_DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd");
- private final Stack<Stack<QName>> actualPath = new Stack<>();
private int augmentOrder;
private void addNodeToPath(final QName name) {
return actualPath.peek().pop();
}
+ private SchemaPath currentSchemaPath() {
+ return SchemaPath.create(actualPath.peek(), true);
+ }
+
public YangParserListenerImpl(final String sourcePath) {
this.sourcePath = sourcePath;
}
@Override
public void enterModule_stmt(final YangParser.Module_stmtContext ctx) {
moduleName = stringFromNode(ctx);
- LOGGER.trace("entering module " + moduleName);
+ LOGGER.trace("entering module {}", moduleName);
enterLog("module", moduleName, 0);
actualPath.push(new Stack<QName>());
actualPath.pop();
}
- @Override public void enterSubmodule_stmt(final YangParser.Submodule_stmtContext ctx) {
+ @Override
+ public void enterSubmodule_stmt(final YangParser.Submodule_stmtContext ctx) {
moduleName = stringFromNode(ctx);
- LOGGER.trace("entering submodule " + moduleName);
+ LOGGER.trace("entering submodule {}", moduleName);
enterLog("submodule", moduleName, 0);
actualPath.push(new Stack<QName>());
moduleBuilder.setReference(reference);
}
- @Override public void exitSubmodule_stmt(final YangParser.Submodule_stmtContext ctx) {
+ @Override
+ public void exitSubmodule_stmt(final YangParser.Submodule_stmtContext ctx) {
exitLog("submodule");
actualPath.pop();
}
- @Override public void enterBelongs_to_stmt(final YangParser.Belongs_to_stmtContext ctx) {
+ @Override
+ public void enterBelongs_to_stmt(final YangParser.Belongs_to_stmtContext ctx) {
moduleBuilder.setBelongsTo(stringFromNode(ctx));
}
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 = new QName(moduleQName.getNamespace(), moduleQName.getRevision(), yangModelPrefix, moduleQName.getLocalName());
moduleBuilder.setPrefix(yangModelPrefix);
setLog("prefix", yangModelPrefix);
} else if (treeNode instanceof Yang_version_stmtContext) {
final String revisionDateStr = stringFromNode(treeNode);
try {
final Date revisionDate = SIMPLE_DATE_FORMAT.parse(revisionDateStr);
- if ((revisionDate != null) && (this.revision.compareTo(revisionDate) < 0)) {
- this.revision = revisionDate;
- moduleBuilder.setRevision(this.revision);
- setLog("revision", this.revision.toString());
+ 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) {
final int line = ctx.getStart().getLine();
final String extName = stringFromNode(ctx);
enterLog("extension", extName, line);
- QName qname = new QName(namespace, revision, yangModelPrefix, extName);
+ QName qname = QName.create(moduleQName, extName);
addNodeToPath(qname);
- SchemaPath path = createActualSchemaPath(actualPath.peek());
+ SchemaPath path = currentSchemaPath();
ExtensionBuilder builder = moduleBuilder.addExtension(qname, line, path);
parseSchemaNodeArgs(ctx, builder);
final int line = ctx.getStart().getLine();
final String typedefName = stringFromNode(ctx);
enterLog("typedef", typedefName, line);
- QName typedefQName = new QName(namespace, revision, yangModelPrefix, typedefName);
+ QName typedefQName = QName.create(moduleQName, typedefName);
addNodeToPath(typedefQName);
- SchemaPath path = createActualSchemaPath(actualPath.peek());
+ SchemaPath path = currentSchemaPath();
TypeDefinitionBuilder builder = moduleBuilder.addTypedef(line, typedefQName, path);
parseSchemaNodeArgs(ctx, builder);
}
// 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);
+ type = BaseTypes.defaultBaseTypeFor(typeName).orNull();
addNodeToPath(type.getQName());
moduleBuilder.setType(type);
} else {
QName qname;
switch (typeName) {
- case "union":
- qname = BaseTypes.constructQName("union");
- addNodeToPath(qname);
- UnionTypeBuilder unionBuilder = moduleBuilder.addUnionType(line, namespace, revision);
- Builder parent = moduleBuilder.getActualNode();
- unionBuilder.setParent(parent);
- moduleBuilder.enterNode(unionBuilder);
- break;
- case "identityref":
- qname = BaseTypes.constructQName("identityref");
- addNodeToPath(qname);
- SchemaPath path = createActualSchemaPath(actualPath.peek());
- moduleBuilder.addIdentityrefType(line, path, getIdentityrefBase(typeBody));
- break;
- default:
- type = parseTypeWithBody(typeName, typeBody, actualPath.peek(), namespace, revision,
- yangModelPrefix, moduleBuilder.getActualNode());
- moduleBuilder.setType(type);
- addNodeToPath(type.getQName());
+ case "union":
+ qname = BaseTypes.UNION_QNAME;
+ addNodeToPath(qname);
+ UnionTypeBuilder unionBuilder = moduleBuilder.addUnionType(line, moduleQName.getModule());
+ Builder parent = moduleBuilder.getActualNode();
+ unionBuilder.setParent(parent);
+ moduleBuilder.enterNode(unionBuilder);
+ break;
+ case "identityref":
+ qname = BaseTypes.IDENTITYREF_QNAME;
+ addNodeToPath(qname);
+ SchemaPath path = currentSchemaPath();
+ moduleBuilder.addIdentityrefType(line, path, getIdentityrefBase(typeBody));
+ break;
+ default:
+ type = parseTypeWithBody(typeName, typeBody, currentSchemaPath(), moduleQName, moduleBuilder.getActualNode());
+ moduleBuilder.setType(type);
+ addNodeToPath(type.getQName());
}
}
} else {
- type = parseUnknownTypeWithBody(typeQName, typeBody, actualPath.peek(), namespace, revision,
- yangModelPrefix, moduleBuilder.getActualNode());
+ type = parseUnknownTypeWithBody(typeQName, typeBody, currentSchemaPath(), moduleQName, moduleBuilder.getActualNode());
// add parent node of this type statement to dirty nodes
moduleBuilder.markActualNodeDirty();
moduleBuilder.setType(type);
}
private QName parseQName(final 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);
+ final QName typeQName;
+ if (typeName.indexOf(':') != -1) {
+ final Iterator<String> 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);
}
} else {
- typeQName = new QName(namespace, revision, yangModelPrefix, typeName);
+ typeQName = QName.create(moduleQName, typeName);
}
return typeQName;
}
final int line = ctx.getStart().getLine();
final String groupName = stringFromNode(ctx);
enterLog("grouping", groupName, line);
- QName groupQName = new QName(namespace, revision, yangModelPrefix, groupName);
+ QName groupQName = QName.create(moduleQName, groupName);
addNodeToPath(groupQName);
- SchemaPath path = createActualSchemaPath(actualPath.peek());
+ SchemaPath path = currentSchemaPath();
GroupingBuilder builder = moduleBuilder.addGrouping(ctx.getStart().getLine(), groupQName, path);
parseSchemaNodeArgs(ctx, builder);
final String containerName = stringFromNode(ctx);
enterLog("container", containerName, line);
- QName containerQName = new QName(namespace, revision, yangModelPrefix, containerName);
+ QName containerQName = QName.create(moduleQName, containerName);
addNodeToPath(containerQName);
- SchemaPath path = createActualSchemaPath(actualPath.peek());
+ SchemaPath path = currentSchemaPath();
ContainerSchemaNodeBuilder builder = moduleBuilder.addContainerNode(line, containerQName, path);
parseSchemaNodeArgs(ctx, builder);
final String leafName = stringFromNode(ctx);
enterLog("leaf", leafName, line);
- QName leafQName = new QName(namespace, revision, yangModelPrefix, leafName);
+ QName leafQName = QName.create(moduleQName, leafName);
addNodeToPath(leafQName);
- SchemaPath path = createActualSchemaPath(actualPath.peek());
+ SchemaPath path = currentSchemaPath();
LeafSchemaNodeBuilder builder = moduleBuilder.addLeafNode(line, leafQName, path);
parseSchemaNodeArgs(ctx, builder);
final int line = ctx.getStart().getLine();
final String leafListName = stringFromNode(ctx);
enterLog("leaf-list", leafListName, line);
- QName leafListQName = new QName(namespace, revision, yangModelPrefix, leafListName);
+ QName leafListQName = QName.create(moduleQName, leafListName);
addNodeToPath(leafListQName);
- SchemaPath path = createActualSchemaPath(actualPath.peek());
+ SchemaPath path = currentSchemaPath();
LeafListSchemaNodeBuilder builder = moduleBuilder.addLeafListNode(line, leafListQName, path);
moduleBuilder.enterNode(builder);
final String listName = stringFromNode(ctx);
enterLog("list", listName, line);
- QName listQName = new QName(namespace, revision, yangModelPrefix, listName);
+ QName listQName = QName.create(moduleQName, listName);
addNodeToPath(listQName);
- SchemaPath path = createActualSchemaPath(actualPath.peek());
+ SchemaPath path = currentSchemaPath();
ListSchemaNodeBuilder builder = moduleBuilder.addListNode(line, listQName, path);
moduleBuilder.enterNode(builder);
final String anyXmlName = stringFromNode(ctx);
enterLog("anyxml", anyXmlName, line);
- QName anyXmlQName = new QName(namespace, revision, yangModelPrefix, anyXmlName);
+ QName anyXmlQName = QName.create(moduleQName, anyXmlName);
addNodeToPath(anyXmlQName);
- SchemaPath path = createActualSchemaPath(actualPath.peek());
+ SchemaPath path = currentSchemaPath();
AnyXmlBuilder builder = moduleBuilder.addAnyXml(line, anyXmlQName, path);
moduleBuilder.enterNode(builder);
final String choiceName = stringFromNode(ctx);
enterLog("choice", choiceName, line);
- QName choiceQName = new QName(namespace, revision, yangModelPrefix, choiceName);
+ QName choiceQName = QName.create(moduleQName, choiceName);
addNodeToPath(choiceQName);
- SchemaPath path = createActualSchemaPath(actualPath.peek());
+ SchemaPath path = currentSchemaPath();
ChoiceBuilder builder = moduleBuilder.addChoice(line, choiceQName, path);
moduleBuilder.enterNode(builder);
final String caseName = stringFromNode(ctx);
enterLog("case", caseName, line);
- QName caseQName = new QName(namespace, revision, yangModelPrefix, caseName);
+ QName caseQName = QName.create(moduleQName, caseName);
addNodeToPath(caseQName);
- SchemaPath path = createActualSchemaPath(actualPath.peek());
+ SchemaPath path = currentSchemaPath();
ChoiceCaseBuilder builder = moduleBuilder.addCase(line, caseQName, path);
moduleBuilder.enterNode(builder);
final String notificationName = stringFromNode(ctx);
enterLog("notification", notificationName, line);
- QName notificationQName = new QName(namespace, revision, yangModelPrefix, notificationName);
+ QName notificationQName = QName.create(moduleQName, notificationName);
addNodeToPath(notificationQName);
- SchemaPath path = createActualSchemaPath(actualPath.peek());
+ SchemaPath path = currentSchemaPath();
NotificationBuilder builder = moduleBuilder.addNotification(line, notificationQName, path);
moduleBuilder.enterNode(builder);
final String rpcName = stringFromNode(ctx);
enterLog("rpc", rpcName, line);
- QName rpcQName = new QName(namespace, revision, yangModelPrefix, rpcName);
+ QName rpcQName = QName.create(moduleQName, rpcName);
addNodeToPath(rpcQName);
- SchemaPath path = createActualSchemaPath(actualPath.peek());
+ SchemaPath path = currentSchemaPath();
RpcDefinitionBuilder rpcBuilder = moduleBuilder.addRpc(line, rpcQName, path);
moduleBuilder.enterNode(rpcBuilder);
final String input = "input";
enterLog(input, input, line);
- QName rpcQName = new QName(namespace, revision, yangModelPrefix, input);
+ QName rpcQName = QName.create(moduleQName, input);
addNodeToPath(rpcQName);
- SchemaPath path = createActualSchemaPath(actualPath.peek());
+ SchemaPath path = currentSchemaPath();
ContainerSchemaNodeBuilder builder = moduleBuilder.addRpcInput(line, rpcQName, path);
moduleBuilder.enterNode(builder);
final String output = "output";
enterLog(output, output, line);
- QName rpcQName = new QName(namespace, revision, yangModelPrefix, output);
+ QName rpcQName = QName.create(moduleQName, output);
addNodeToPath(rpcQName);
- SchemaPath path = createActualSchemaPath(actualPath.peek());
+ SchemaPath path = currentSchemaPath();
ContainerSchemaNodeBuilder builder = moduleBuilder.addRpcOutput(path, rpcQName, line);
moduleBuilder.enterNode(builder);
final String featureName = stringFromNode(ctx);
enterLog("feature", featureName, line);
- QName featureQName = new QName(namespace, revision, yangModelPrefix, featureName);
+ QName featureQName = QName.create(moduleQName, featureName);
addNodeToPath(featureQName);
- SchemaPath path = createActualSchemaPath(actualPath.peek());
+ SchemaPath path = currentSchemaPath();
FeatureBuilder featureBuilder = moduleBuilder.addFeature(line, featureQName, path);
moduleBuilder.enterNode(featureBuilder);
final String identityName = stringFromNode(ctx);
enterLog("identity", identityName, line);
- final QName identityQName = new QName(namespace, revision, yangModelPrefix, identityName);
+ final QName identityQName = QName.create(moduleQName, identityName);
addNodeToPath(identityQName);
- SchemaPath path = createActualSchemaPath(actualPath.peek());
+ SchemaPath path = currentSchemaPath();
IdentitySchemaNodeBuilder builder = moduleBuilder.addIdentity(identityQName, line, path);
moduleBuilder.enterNode(builder);
-
parseSchemaNodeArgs(ctx, builder);
for (int i = 0; i < ctx.getChildCount(); i++) {
final String nodeParameter = stringFromNode(ctx);
enterLog("unknown-node", nodeParameter, line);
- QName nodeType;
final String nodeTypeStr = ctx.getChild(0).getText();
- final String[] splittedElement = nodeTypeStr.split(":");
- if (splittedElement.length == 1) {
- nodeType = new QName(namespace, revision, yangModelPrefix, splittedElement[0]);
+ final Iterator<String> splittedElement = COLON_SPLITTER.split(nodeTypeStr).iterator();
+ final String e0 = splittedElement.next();
+ final QName nodeType;
+ if (splittedElement.hasNext()) {
+ nodeType = new QName(moduleQName.getNamespace(), moduleQName.getRevision(), e0, splittedElement.next());
} else {
- nodeType = new QName(namespace, revision, splittedElement[0], splittedElement[1]);
+ nodeType = QName.create(moduleQName, e0);
}
QName qname;
try {
if (!Strings.isNullOrEmpty(nodeParameter)) {
- String[] splittedName = nodeParameter.split(":");
- if (splittedName.length == 2) {
- qname = new QName(null, null, splittedName[0], splittedName[1]);
+ final Iterable<String> splittedName = COLON_SPLITTER.split(nodeParameter);
+ final Iterator<String> it = splittedName.iterator();
+
+ if (Iterables.size(splittedName) == 2) {
+ qname = new QName(null, null, it.next(), it.next());
} else {
- qname = new QName(namespace, revision, yangModelPrefix, splittedName[0]);
+ qname = QName.create(moduleQName, it.next());
}
} else {
qname = nodeType;
}
} catch (IllegalArgumentException e) {
qname = nodeType;
-
}
addNodeToPath(qname);
- SchemaPath path = createActualSchemaPath(actualPath.peek());
+ SchemaPath path = currentSchemaPath();
UnknownSchemaNodeBuilderImpl builder = moduleBuilder.addUnknownSchemaNode(line, qname, path);
builder.setNodeType(nodeType);
Code Review / yangtools.git / blobdiff