2 * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
8 package org.opendaylight.yangtools.yang.parser.impl;
10 import static org.opendaylight.yangtools.yang.parser.util.ParserListenerUtils.*;
16 import org.antlr.v4.runtime.tree.ParseTree;
17 import org.opendaylight.yangtools.antlrv4.code.gen.*;
18 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Argument_stmtContext;
19 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Base_stmtContext;
20 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Contact_stmtContext;
21 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Container_stmtContext;
22 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Default_stmtContext;
23 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Description_stmtContext;
24 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Deviate_add_stmtContext;
25 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Deviate_delete_stmtContext;
26 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Deviate_not_supported_stmtContext;
27 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Deviate_replace_stmtContext;
28 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Import_stmtContext;
29 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Key_stmtContext;
30 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Leaf_list_stmtContext;
31 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Leaf_stmtContext;
32 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.List_stmtContext;
33 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Module_header_stmtsContext;
34 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Namespace_stmtContext;
35 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Ordered_by_stmtContext;
36 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Organization_stmtContext;
37 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Prefix_stmtContext;
38 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Presence_stmtContext;
39 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Reference_stmtContext;
40 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Revision_date_stmtContext;
41 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Revision_stmtContext;
42 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Revision_stmtsContext;
43 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Status_stmtContext;
44 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Type_body_stmtsContext;
45 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Units_stmtContext;
46 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.When_stmtContext;
47 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Yang_version_stmtContext;
48 import org.opendaylight.yangtools.yang.common.QName;
49 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
50 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
51 import org.opendaylight.yangtools.yang.model.util.BaseTypes;
52 import org.opendaylight.yangtools.yang.model.util.YangTypesConverter;
53 import org.opendaylight.yangtools.yang.parser.builder.api.*;
54 import org.opendaylight.yangtools.yang.parser.builder.impl.*;
55 import org.opendaylight.yangtools.yang.parser.util.RefineHolder;
56 import org.slf4j.Logger;
57 import org.slf4j.LoggerFactory;
59 import com.google.common.base.Strings;
61 public final class YangParserListenerImpl extends YangParserBaseListener {
62 private static final Logger LOGGER = LoggerFactory.getLogger(YangParserListenerImpl.class);
63 private static final String AUGMENT_STR = "augment";
65 private final String sourcePath;
66 private ModuleBuilder moduleBuilder;
67 private String moduleName;
68 private URI namespace;
69 private String yangModelPrefix;
70 private Date revision = new Date(0L);
72 private final DateFormat SIMPLE_DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd");
73 private final Stack<Stack<QName>> actualPath = new Stack<>();
75 private void addNodeToPath(QName name) {
76 actualPath.peek().push(name);
79 private QName removeNodeFromPath() {
80 return actualPath.peek().pop();
83 public YangParserListenerImpl(String sourcePath) {
84 this.sourcePath = sourcePath;
88 public void enterModule_stmt(YangParser.Module_stmtContext ctx) {
89 moduleName = stringFromNode(ctx);
90 LOGGER.debug("entering module " + moduleName);
91 enterLog("module", moduleName, 0);
92 actualPath.push(new Stack<QName>());
94 moduleBuilder = new ModuleBuilder(moduleName, sourcePath);
96 String description = null;
97 String reference = null;
98 for (int i = 0; i < ctx.getChildCount(); i++) {
99 ParseTree child = ctx.getChild(i);
100 if (child instanceof Description_stmtContext) {
101 description = stringFromNode(child);
102 } else if (child instanceof Reference_stmtContext) {
103 reference = stringFromNode(child);
105 if (description != null && reference != null) {
110 moduleBuilder.setDescription(description);
111 moduleBuilder.setReference(reference);
115 public void exitModule_stmt(YangParser.Module_stmtContext ctx) {
116 exitLog("module", "");
120 @Override public void enterSubmodule_stmt(YangParser.Submodule_stmtContext ctx) {
121 moduleName = stringFromNode(ctx);
122 LOGGER.debug("entering submodule " + moduleName);
123 enterLog("submodule", moduleName, 0);
124 actualPath.push(new Stack<QName>());
126 moduleBuilder = new ModuleBuilder(moduleName, true, sourcePath);
128 String description = null;
129 String reference = null;
130 for (int i = 0; i < ctx.getChildCount(); i++) {
131 ParseTree child = ctx.getChild(i);
132 if (child instanceof Description_stmtContext) {
133 description = stringFromNode(child);
134 } else if (child instanceof Reference_stmtContext) {
135 reference = stringFromNode(child);
137 if (description != null && reference != null) {
142 moduleBuilder.setDescription(description);
143 moduleBuilder.setReference(reference);
146 @Override public void exitSubmodule_stmt(YangParser.Submodule_stmtContext ctx) {
147 exitLog("submodule", "");
151 @Override public void enterBelongs_to_stmt(YangParser.Belongs_to_stmtContext ctx) {
152 moduleBuilder.setBelongsTo(stringFromNode(ctx));
156 public void enterModule_header_stmts(Module_header_stmtsContext ctx) {
157 enterLog("module_header", "", ctx.getStart().getLine());
158 String yangVersion = null;
159 for (int i = 0; i < ctx.getChildCount(); ++i) {
160 final ParseTree treeNode = ctx.getChild(i);
161 if (treeNode instanceof Namespace_stmtContext) {
162 final String namespaceStr = stringFromNode(treeNode);
163 namespace = URI.create(namespaceStr);
164 moduleBuilder.setNamespace(namespace);
165 setLog("namespace", namespaceStr);
166 } else if (treeNode instanceof Prefix_stmtContext) {
167 yangModelPrefix = stringFromNode(treeNode);
168 moduleBuilder.setPrefix(yangModelPrefix);
169 setLog("prefix", yangModelPrefix);
170 } else if (treeNode instanceof Yang_version_stmtContext) {
171 yangVersion = stringFromNode(treeNode);
172 setLog("yang-version", yangVersion);
176 if (yangVersion == null) {
179 moduleBuilder.setYangVersion(yangVersion);
183 public void exitModule_header_stmts(Module_header_stmtsContext ctx) {
184 exitLog("module_header", "");
188 public void enterMeta_stmts(YangParser.Meta_stmtsContext ctx) {
189 enterLog("meta_stmt", "", ctx.getStart().getLine());
190 for (int i = 0; i < ctx.getChildCount(); i++) {
191 ParseTree child = ctx.getChild(i);
192 if (child instanceof Organization_stmtContext) {
193 final String organization = stringFromNode(child);
194 moduleBuilder.setOrganization(organization);
195 setLog("organization", organization);
196 } else if (child instanceof Contact_stmtContext) {
197 final String contact = stringFromNode(child);
198 moduleBuilder.setContact(contact);
199 setLog("contact", contact);
200 } else if (child instanceof Description_stmtContext) {
201 final String description = stringFromNode(child);
202 moduleBuilder.setDescription(description);
203 setLog("description", description);
204 } else if (child instanceof Reference_stmtContext) {
205 final String reference = stringFromNode(child);
206 moduleBuilder.setReference(reference);
207 setLog("reference", reference);
213 public void exitMeta_stmts(YangParser.Meta_stmtsContext ctx) {
214 exitLog("meta_stmt", "");
218 public void enterRevision_stmts(Revision_stmtsContext ctx) {
219 enterLog("revisions", "", ctx.getStart().getLine());
220 for (int i = 0; i < ctx.getChildCount(); ++i) {
221 final ParseTree treeNode = ctx.getChild(i);
222 if (treeNode instanceof Revision_stmtContext) {
223 updateRevisionForRevisionStatement(treeNode);
229 public void exitRevision_stmts(Revision_stmtsContext ctx) {
230 exitLog("revisions", "");
233 private void updateRevisionForRevisionStatement(final ParseTree treeNode) {
234 final String revisionDateStr = stringFromNode(treeNode);
236 final Date revisionDate = SIMPLE_DATE_FORMAT.parse(revisionDateStr);
237 if ((revisionDate != null) && (this.revision.compareTo(revisionDate) < 0)) {
238 this.revision = revisionDate;
239 moduleBuilder.setRevision(this.revision);
240 setLog("revision", this.revision.toString());
241 for (int i = 0; i < treeNode.getChildCount(); ++i) {
242 ParseTree child = treeNode.getChild(i);
243 if (child instanceof Reference_stmtContext) {
244 moduleBuilder.setReference(stringFromNode(child));
248 } catch (ParseException e) {
249 final String message = "Failed to parse revision string: " + revisionDateStr;
250 LOGGER.warn(message);
255 public void enterImport_stmt(Import_stmtContext ctx) {
256 final int line = ctx.getStart().getLine();
257 final String importName = stringFromNode(ctx);
258 enterLog("import", importName, line);
260 String importPrefix = null;
261 Date importRevision = null;
263 for (int i = 0; i < ctx.getChildCount(); ++i) {
264 final ParseTree treeNode = ctx.getChild(i);
265 if (treeNode instanceof Prefix_stmtContext) {
266 importPrefix = stringFromNode(treeNode);
268 if (treeNode instanceof Revision_date_stmtContext) {
269 String importRevisionStr = stringFromNode(treeNode);
271 importRevision = SIMPLE_DATE_FORMAT.parse(importRevisionStr);
272 } catch (ParseException e) {
273 LOGGER.warn("Failed to parse import revision-date at line " + line + ": " + importRevisionStr);
277 moduleBuilder.addModuleImport(importName, importRevision, importPrefix);
278 setLog("import", "(" + importName + "; " + importRevision + "; " + importPrefix + ")");
282 public void exitImport_stmt(Import_stmtContext ctx) {
283 exitLog("import", "");
287 public void enterAugment_stmt(YangParser.Augment_stmtContext ctx) {
288 final int line = ctx.getStart().getLine();
289 final String augmentPath = stringFromNode(ctx);
290 enterLog(AUGMENT_STR, augmentPath, line);
291 actualPath.push(new Stack<QName>());
293 AugmentationSchemaBuilder builder = moduleBuilder.addAugment(line, augmentPath);
295 for (int i = 0; i < ctx.getChildCount(); i++) {
296 ParseTree child = ctx.getChild(i);
297 if (child instanceof Description_stmtContext) {
298 builder.setDescription(stringFromNode(child));
299 } else if (child instanceof Reference_stmtContext) {
300 builder.setReference(stringFromNode(child));
301 } else if (child instanceof Status_stmtContext) {
302 builder.setStatus(parseStatus((Status_stmtContext) child));
303 } else if (child instanceof When_stmtContext) {
304 builder.addWhenCondition(stringFromNode(child));
308 moduleBuilder.enterNode(builder);
312 public void exitAugment_stmt(YangParser.Augment_stmtContext ctx) {
313 moduleBuilder.exitNode();
314 exitLog(AUGMENT_STR, "");
319 public void enterExtension_stmt(YangParser.Extension_stmtContext ctx) {
320 final int line = ctx.getStart().getLine();
321 final String extName = stringFromNode(ctx);
322 enterLog("extension", extName, line);
323 QName qname = new QName(namespace, revision, yangModelPrefix, extName);
324 addNodeToPath(qname);
325 SchemaPath path = createActualSchemaPath(actualPath.peek());
327 ExtensionBuilder builder = moduleBuilder.addExtension(qname, line, path);
328 parseSchemaNodeArgs(ctx, builder);
330 String argument = null;
332 for (int i = 0; i < ctx.getChildCount(); i++) {
333 ParseTree child = ctx.getChild(i);
334 if (child instanceof Argument_stmtContext) {
335 argument = stringFromNode(child);
336 yin = parseYinValue((Argument_stmtContext) child);
340 builder.setArgument(argument);
341 builder.setYinElement(yin);
343 moduleBuilder.enterNode(builder);
347 public void exitExtension_stmt(YangParser.Extension_stmtContext ctx) {
348 moduleBuilder.exitNode();
349 exitLog("extension", removeNodeFromPath());
353 public void enterTypedef_stmt(YangParser.Typedef_stmtContext ctx) {
354 final int line = ctx.getStart().getLine();
355 final String typedefName = stringFromNode(ctx);
356 enterLog("typedef", typedefName, line);
357 QName typedefQName = new QName(namespace, revision, yangModelPrefix, typedefName);
358 addNodeToPath(typedefQName);
359 SchemaPath path = createActualSchemaPath(actualPath.peek());
361 TypeDefinitionBuilder builder = moduleBuilder.addTypedef(line, typedefQName, path);
362 parseSchemaNodeArgs(ctx, builder);
363 builder.setUnits(parseUnits(ctx));
364 builder.setDefaultValue(parseDefault(ctx));
366 moduleBuilder.enterNode(builder);
370 public void exitTypedef_stmt(YangParser.Typedef_stmtContext ctx) {
371 moduleBuilder.exitNode();
372 exitLog("typedef", removeNodeFromPath());
376 public void enterType_stmt(YangParser.Type_stmtContext ctx) {
377 final int line = ctx.getStart().getLine();
378 final String typeName = stringFromNode(ctx);
379 enterLog("type", typeName, line);
381 final QName typeQName = parseQName(typeName);
383 TypeDefinition<?> type = null;
384 Type_body_stmtsContext typeBody = null;
385 for (int i = 0; i < ctx.getChildCount(); i++) {
386 if (ctx.getChild(i) instanceof Type_body_stmtsContext) {
387 typeBody = (Type_body_stmtsContext) ctx.getChild(i);
392 // if this is base yang type...
393 if (YangTypesConverter.isBaseYangType(typeName)) {
394 if (typeBody == null) {
395 // check for types which must have body
396 checkMissingBody(typeName, moduleName, line);
397 // if there are no constraints, just grab default base yang type
398 type = YangTypesConverter.javaTypeForBaseYangType(typeName);
399 addNodeToPath(type.getQName());
400 moduleBuilder.setType(type);
405 qname = BaseTypes.constructQName("union");
406 addNodeToPath(qname);
407 UnionTypeBuilder unionBuilder = moduleBuilder.addUnionType(line, namespace, revision);
408 Builder parent = moduleBuilder.getActualNode();
409 unionBuilder.setParent(parent);
410 moduleBuilder.enterNode(unionBuilder);
413 qname = BaseTypes.constructQName("identityref");
414 addNodeToPath(qname);
415 SchemaPath path = createActualSchemaPath(actualPath.peek());
416 moduleBuilder.addIdentityrefType(line, path, getIdentityrefBase(typeBody));
419 type = parseTypeWithBody(typeName, typeBody, actualPath.peek(), namespace, revision,
420 yangModelPrefix, moduleBuilder.getActualNode());
421 moduleBuilder.setType(type);
422 addNodeToPath(type.getQName());
426 type = parseUnknownTypeWithBody(typeQName, typeBody, actualPath.peek(), namespace, revision,
427 yangModelPrefix, moduleBuilder.getActualNode());
428 // add parent node of this type statement to dirty nodes
429 moduleBuilder.markActualNodeDirty();
430 moduleBuilder.setType(type);
431 addNodeToPath(type.getQName());
436 private QName parseQName(String typeName) {
438 if (typeName.contains(":")) {
439 String[] splittedName = typeName.split(":");
440 String prefix = splittedName[0];
441 String name = splittedName[1];
442 if (prefix.equals(yangModelPrefix)) {
443 typeQName = new QName(namespace, revision, prefix, name);
445 typeQName = new QName(null, null, prefix, name);
448 typeQName = new QName(namespace, revision, yangModelPrefix, typeName);
454 public void exitType_stmt(YangParser.Type_stmtContext ctx) {
455 final String typeName = stringFromNode(ctx);
456 if ("union".equals(typeName)) {
457 moduleBuilder.exitNode();
459 exitLog("type", removeNodeFromPath());
463 public void enterGrouping_stmt(YangParser.Grouping_stmtContext ctx) {
464 final int line = ctx.getStart().getLine();
465 final String groupName = stringFromNode(ctx);
466 enterLog("grouping", groupName, line);
467 QName groupQName = new QName(namespace, revision, yangModelPrefix, groupName);
468 addNodeToPath(groupQName);
469 SchemaPath path = createActualSchemaPath(actualPath.peek());
471 GroupingBuilder builder = moduleBuilder.addGrouping(ctx.getStart().getLine(), groupQName, path);
472 parseSchemaNodeArgs(ctx, builder);
474 moduleBuilder.enterNode(builder);
478 public void exitGrouping_stmt(YangParser.Grouping_stmtContext ctx) {
479 moduleBuilder.exitNode();
480 exitLog("grouping", removeNodeFromPath());
484 public void enterContainer_stmt(Container_stmtContext ctx) {
485 final int line = ctx.getStart().getLine();
486 final String containerName = stringFromNode(ctx);
487 enterLog("container", containerName, line);
489 QName containerQName = new QName(namespace, revision, yangModelPrefix, containerName);
490 addNodeToPath(containerQName);
491 SchemaPath path = createActualSchemaPath(actualPath.peek());
493 ContainerSchemaNodeBuilder builder = moduleBuilder.addContainerNode(line, containerQName, path);
494 parseSchemaNodeArgs(ctx, builder);
495 parseConstraints(ctx, builder.getConstraints());
496 builder.setConfiguration(getConfig(ctx, moduleBuilder.getActualParent(), moduleName, line));
498 for (int i = 0; i < ctx.getChildCount(); ++i) {
499 final ParseTree childNode = ctx.getChild(i);
500 if (childNode instanceof Presence_stmtContext) {
501 builder.setPresence(true);
506 moduleBuilder.enterNode(builder);
510 public void exitContainer_stmt(Container_stmtContext ctx) {
511 moduleBuilder.exitNode();
512 exitLog("container", removeNodeFromPath());
516 public void enterLeaf_stmt(Leaf_stmtContext ctx) {
517 final int line = ctx.getStart().getLine();
518 final String leafName = stringFromNode(ctx);
519 enterLog("leaf", leafName, line);
521 QName leafQName = new QName(namespace, revision, yangModelPrefix, leafName);
522 addNodeToPath(leafQName);
523 SchemaPath path = createActualSchemaPath(actualPath.peek());
525 LeafSchemaNodeBuilder builder = moduleBuilder.addLeafNode(line, leafQName, path);
526 parseSchemaNodeArgs(ctx, builder);
527 parseConstraints(ctx, builder.getConstraints());
528 builder.setConfiguration(getConfig(ctx, moduleBuilder.getActualParent(), moduleName, line));
530 String defaultStr = null;
531 String unitsStr = null;
532 for (int i = 0; i < ctx.getChildCount(); i++) {
533 ParseTree child = ctx.getChild(i);
534 if (child instanceof Default_stmtContext) {
535 defaultStr = stringFromNode(child);
536 } else if (child instanceof Units_stmtContext) {
537 unitsStr = stringFromNode(child);
540 builder.setDefaultStr(defaultStr);
541 builder.setUnits(unitsStr);
543 moduleBuilder.enterNode(builder);
547 public void exitLeaf_stmt(YangParser.Leaf_stmtContext ctx) {
548 moduleBuilder.exitNode();
549 exitLog("leaf", removeNodeFromPath());
553 public void enterUses_stmt(YangParser.Uses_stmtContext ctx) {
554 final int line = ctx.getStart().getLine();
555 final String groupingPathStr = stringFromNode(ctx);
556 enterLog("uses", groupingPathStr, line);
558 UsesNodeBuilder builder = moduleBuilder.addUsesNode(line, groupingPathStr);
560 moduleBuilder.enterNode(builder);
564 public void exitUses_stmt(YangParser.Uses_stmtContext ctx) {
565 moduleBuilder.exitNode();
570 public void enterUses_augment_stmt(YangParser.Uses_augment_stmtContext ctx) {
571 actualPath.push(new Stack<QName>());
572 final int line = ctx.getStart().getLine();
573 final String augmentPath = stringFromNode(ctx);
574 enterLog(AUGMENT_STR, augmentPath, line);
576 AugmentationSchemaBuilder builder = moduleBuilder.addAugment(line, augmentPath);
578 for (int i = 0; i < ctx.getChildCount(); i++) {
579 ParseTree child = ctx.getChild(i);
580 if (child instanceof Description_stmtContext) {
581 builder.setDescription(stringFromNode(child));
582 } else if (child instanceof Reference_stmtContext) {
583 builder.setReference(stringFromNode(child));
584 } else if (child instanceof Status_stmtContext) {
585 builder.setStatus(parseStatus((Status_stmtContext) child));
586 } else if (child instanceof When_stmtContext) {
587 builder.addWhenCondition(stringFromNode(child));
591 moduleBuilder.enterNode(builder);
595 public void exitUses_augment_stmt(YangParser.Uses_augment_stmtContext ctx) {
596 moduleBuilder.exitNode();
597 exitLog(AUGMENT_STR, "");
602 public void enterRefine_stmt(YangParser.Refine_stmtContext ctx) {
603 final String refineString = stringFromNode(ctx);
604 enterLog("refine", refineString, ctx.getStart().getLine());
606 RefineHolder refine = parseRefine(ctx, moduleName);
607 moduleBuilder.addRefine(refine);
608 moduleBuilder.enterNode(refine);
612 public void exitRefine_stmt(YangParser.Refine_stmtContext ctx) {
613 moduleBuilder.exitNode();
614 exitLog("refine", "");
618 public void enterLeaf_list_stmt(Leaf_list_stmtContext ctx) {
619 final int line = ctx.getStart().getLine();
620 final String leafListName = stringFromNode(ctx);
621 enterLog("leaf-list", leafListName, line);
622 QName leafListQName = new QName(namespace, revision, yangModelPrefix, leafListName);
623 addNodeToPath(leafListQName);
624 SchemaPath path = createActualSchemaPath(actualPath.peek());
626 LeafListSchemaNodeBuilder builder = moduleBuilder.addLeafListNode(line, leafListQName, path);
627 moduleBuilder.enterNode(builder);
629 parseSchemaNodeArgs(ctx, builder);
630 parseConstraints(ctx, builder.getConstraints());
631 builder.setConfiguration(getConfig(ctx, moduleBuilder.getActualParent(), moduleName, ctx.getStart().getLine()));
633 for (int i = 0; i < ctx.getChildCount(); ++i) {
634 final ParseTree childNode = ctx.getChild(i);
635 if (childNode instanceof Ordered_by_stmtContext) {
636 final Ordered_by_stmtContext orderedBy = (Ordered_by_stmtContext) childNode;
637 final boolean userOrdered = parseUserOrdered(orderedBy);
638 builder.setUserOrdered(userOrdered);
645 public void exitLeaf_list_stmt(YangParser.Leaf_list_stmtContext ctx) {
646 moduleBuilder.exitNode();
647 exitLog("leaf-list", removeNodeFromPath());
651 public void enterList_stmt(List_stmtContext ctx) {
652 final int line = ctx.getStart().getLine();
653 final String listName = stringFromNode(ctx);
654 enterLog("list", listName, line);
656 QName listQName = new QName(namespace, revision, yangModelPrefix, listName);
657 addNodeToPath(listQName);
658 SchemaPath path = createActualSchemaPath(actualPath.peek());
660 ListSchemaNodeBuilder builder = moduleBuilder.addListNode(line, listQName, path);
661 moduleBuilder.enterNode(builder);
663 parseSchemaNodeArgs(ctx, builder);
664 parseConstraints(ctx, builder.getConstraints());
665 builder.setConfiguration(getConfig(ctx, moduleBuilder.getActualParent(), moduleName, line));
667 for (int i = 0; i < ctx.getChildCount(); ++i) {
668 ParseTree childNode = ctx.getChild(i);
669 if (childNode instanceof Ordered_by_stmtContext) {
670 final Ordered_by_stmtContext orderedBy = (Ordered_by_stmtContext) childNode;
671 final boolean userOrdered = parseUserOrdered(orderedBy);
672 builder.setUserOrdered(userOrdered);
673 } else if (childNode instanceof Key_stmtContext) {
674 List<String> key = createListKey((Key_stmtContext) childNode);
675 builder.setKeys(key);
681 public void exitList_stmt(List_stmtContext ctx) {
682 moduleBuilder.exitNode();
683 exitLog("list", removeNodeFromPath());
687 public void enterAnyxml_stmt(YangParser.Anyxml_stmtContext ctx) {
688 final int line = ctx.getStart().getLine();
689 final String anyXmlName = stringFromNode(ctx);
690 enterLog("anyxml", anyXmlName, line);
692 QName anyXmlQName = new QName(namespace, revision, yangModelPrefix, anyXmlName);
693 addNodeToPath(anyXmlQName);
694 SchemaPath path = createActualSchemaPath(actualPath.peek());
696 AnyXmlBuilder builder = moduleBuilder.addAnyXml(line, anyXmlQName, path);
697 moduleBuilder.enterNode(builder);
699 parseSchemaNodeArgs(ctx, builder);
700 parseConstraints(ctx, builder.getConstraints());
701 builder.setConfiguration(getConfig(ctx, moduleBuilder.getActualParent(), moduleName, line));
705 public void exitAnyxml_stmt(YangParser.Anyxml_stmtContext ctx) {
706 moduleBuilder.exitNode();
707 exitLog("anyxml", removeNodeFromPath());
711 public void enterChoice_stmt(YangParser.Choice_stmtContext ctx) {
712 final int line = ctx.getStart().getLine();
713 final String choiceName = stringFromNode(ctx);
714 enterLog("choice", choiceName, line);
716 QName choiceQName = new QName(namespace, revision, yangModelPrefix, choiceName);
717 addNodeToPath(choiceQName);
718 SchemaPath path = createActualSchemaPath(actualPath.peek());
720 ChoiceBuilder builder = moduleBuilder.addChoice(line, choiceQName, path);
721 moduleBuilder.enterNode(builder);
723 parseSchemaNodeArgs(ctx, builder);
724 parseConstraints(ctx, builder.getConstraints());
725 builder.setConfiguration(getConfig(ctx, moduleBuilder.getActualParent(), moduleName, line));
727 // set 'default' case
728 for (int i = 0; i < ctx.getChildCount(); i++) {
729 ParseTree child = ctx.getChild(i);
730 if (child instanceof Default_stmtContext) {
731 String defaultCase = stringFromNode(child);
732 builder.setDefaultCase(defaultCase);
739 public void exitChoice_stmt(YangParser.Choice_stmtContext ctx) {
740 moduleBuilder.exitNode();
741 exitLog("choice", removeNodeFromPath());
745 public void enterCase_stmt(YangParser.Case_stmtContext ctx) {
746 final int line = ctx.getStart().getLine();
747 final String caseName = stringFromNode(ctx);
748 enterLog("case", caseName, line);
750 QName caseQName = new QName(namespace, revision, yangModelPrefix, caseName);
751 addNodeToPath(caseQName);
752 SchemaPath path = createActualSchemaPath(actualPath.peek());
754 ChoiceCaseBuilder builder = moduleBuilder.addCase(line, caseQName, path);
755 moduleBuilder.enterNode(builder);
757 parseSchemaNodeArgs(ctx, builder);
758 parseConstraints(ctx, builder.getConstraints());
762 public void exitCase_stmt(YangParser.Case_stmtContext ctx) {
763 moduleBuilder.exitNode();
764 exitLog("case", removeNodeFromPath());
768 public void enterNotification_stmt(YangParser.Notification_stmtContext ctx) {
769 final int line = ctx.getStart().getLine();
770 final String notificationName = stringFromNode(ctx);
771 enterLog("notification", notificationName, line);
773 QName notificationQName = new QName(namespace, revision, yangModelPrefix, notificationName);
774 addNodeToPath(notificationQName);
775 SchemaPath path = createActualSchemaPath(actualPath.peek());
777 NotificationBuilder builder = moduleBuilder.addNotification(line, notificationQName, path);
778 moduleBuilder.enterNode(builder);
780 parseSchemaNodeArgs(ctx, builder);
784 public void exitNotification_stmt(YangParser.Notification_stmtContext ctx) {
785 moduleBuilder.exitNode();
786 exitLog("notification", removeNodeFromPath());
791 public void enterIdentifier_stmt(YangParser.Identifier_stmtContext ctx) {
792 final int line = ctx.getStart().getLine();
793 final String nodeParameter = stringFromNode(ctx);
794 enterLog("unknown-node", nodeParameter, line);
797 final String nodeTypeStr = ctx.getChild(0).getText();
798 final String[] splittedElement = nodeTypeStr.split(":");
799 if (splittedElement.length == 1) {
800 nodeType = new QName(namespace, revision, yangModelPrefix, splittedElement[0]);
802 nodeType = new QName(namespace, revision, splittedElement[0], splittedElement[1]);
806 if (!Strings.isNullOrEmpty(nodeParameter)) {
807 String[] splittedName = nodeParameter.split(":");
808 if (splittedName.length == 2) {
809 qname = new QName(null, null, splittedName[0], splittedName[1]);
811 qname = new QName(namespace, revision, yangModelPrefix, splittedName[0]);
816 addNodeToPath(qname);
817 SchemaPath path = createActualSchemaPath(actualPath.peek());
819 UnknownSchemaNodeBuilder builder = moduleBuilder.addUnknownSchemaNode(line, qname, path);
820 builder.setNodeType(nodeType);
821 builder.setNodeParameter(nodeParameter);
824 parseSchemaNodeArgs(ctx, builder);
825 moduleBuilder.enterNode(builder);
829 public void exitIdentifier_stmt(YangParser.Identifier_stmtContext ctx) {
830 moduleBuilder.exitNode();
831 exitLog("unknown-node", removeNodeFromPath());
835 public void enterRpc_stmt(YangParser.Rpc_stmtContext ctx) {
836 final int line = ctx.getStart().getLine();
837 final String rpcName = stringFromNode(ctx);
838 enterLog("rpc", rpcName, line);
840 QName rpcQName = new QName(namespace, revision, yangModelPrefix, rpcName);
841 addNodeToPath(rpcQName);
842 SchemaPath path = createActualSchemaPath(actualPath.peek());
844 RpcDefinitionBuilder rpcBuilder = moduleBuilder.addRpc(line, rpcQName, path);
845 moduleBuilder.enterNode(rpcBuilder);
848 parseSchemaNodeArgs(ctx, rpcBuilder);
852 public void exitRpc_stmt(YangParser.Rpc_stmtContext ctx) {
853 moduleBuilder.exitNode();
854 exitLog("rpc", removeNodeFromPath());
858 public void enterInput_stmt(YangParser.Input_stmtContext ctx) {
859 final int line = ctx.getStart().getLine();
860 final String input = "input";
861 enterLog(input, input, line);
863 QName rpcQName = new QName(namespace, revision, yangModelPrefix, input);
864 addNodeToPath(rpcQName);
865 SchemaPath path = createActualSchemaPath(actualPath.peek());
867 ContainerSchemaNodeBuilder builder = moduleBuilder.addRpcInput(line, rpcQName, path);
868 moduleBuilder.enterNode(builder);
870 parseSchemaNodeArgs(ctx, builder);
871 parseConstraints(ctx, builder.getConstraints());
875 public void exitInput_stmt(YangParser.Input_stmtContext ctx) {
876 moduleBuilder.exitNode();
877 exitLog("input", removeNodeFromPath());
881 public void enterOutput_stmt(YangParser.Output_stmtContext ctx) {
882 final int line = ctx.getStart().getLine();
883 final String output = "output";
884 enterLog(output, output, line);
886 QName rpcQName = new QName(namespace, revision, yangModelPrefix, output);
887 addNodeToPath(rpcQName);
888 SchemaPath path = createActualSchemaPath(actualPath.peek());
890 ContainerSchemaNodeBuilder builder = moduleBuilder.addRpcOutput(path, rpcQName, line);
891 moduleBuilder.enterNode(builder);
893 parseSchemaNodeArgs(ctx, builder);
894 parseConstraints(ctx, builder.getConstraints());
898 public void exitOutput_stmt(YangParser.Output_stmtContext ctx) {
899 moduleBuilder.exitNode();
900 exitLog("output", removeNodeFromPath());
904 public void enterFeature_stmt(YangParser.Feature_stmtContext ctx) {
905 final int line = ctx.getStart().getLine();
906 final String featureName = stringFromNode(ctx);
907 enterLog("feature", featureName, line);
909 QName featureQName = new QName(namespace, revision, yangModelPrefix, featureName);
910 addNodeToPath(featureQName);
911 SchemaPath path = createActualSchemaPath(actualPath.peek());
913 FeatureBuilder featureBuilder = moduleBuilder.addFeature(line, featureQName, path);
914 moduleBuilder.enterNode(featureBuilder);
916 parseSchemaNodeArgs(ctx, featureBuilder);
920 public void exitFeature_stmt(YangParser.Feature_stmtContext ctx) {
921 moduleBuilder.exitNode();
922 exitLog("feature", removeNodeFromPath());
926 public void enterDeviation_stmt(YangParser.Deviation_stmtContext ctx) {
927 final int line = ctx.getStart().getLine();
928 final String targetPath = stringFromNode(ctx);
929 enterLog("deviation", targetPath, line);
931 String reference = null;
932 String deviate = null;
933 DeviationBuilder builder = moduleBuilder.addDeviation(line, targetPath);
934 moduleBuilder.enterNode(builder);
936 for (int i = 0; i < ctx.getChildCount(); i++) {
937 ParseTree child = ctx.getChild(i);
938 if (child instanceof Reference_stmtContext) {
939 reference = stringFromNode(child);
940 } else if (child instanceof Deviate_not_supported_stmtContext) {
941 deviate = stringFromNode(child);
942 } else if (child instanceof Deviate_add_stmtContext) {
943 deviate = stringFromNode(child);
944 } else if (child instanceof Deviate_replace_stmtContext) {
945 deviate = stringFromNode(child);
946 } else if (child instanceof Deviate_delete_stmtContext) {
947 deviate = stringFromNode(child);
950 builder.setReference(reference);
951 builder.setDeviate(deviate);
955 public void exitDeviation_stmt(YangParser.Deviation_stmtContext ctx) {
956 moduleBuilder.exitNode();
957 exitLog("deviation", "");
961 public void enterIdentity_stmt(YangParser.Identity_stmtContext ctx) {
962 final int line = ctx.getStart().getLine();
963 final String identityName = stringFromNode(ctx);
964 enterLog("identity", identityName, line);
966 final QName identityQName = new QName(namespace, revision, yangModelPrefix, identityName);
967 addNodeToPath(identityQName);
968 SchemaPath path = createActualSchemaPath(actualPath.peek());
970 IdentitySchemaNodeBuilder builder = moduleBuilder.addIdentity(identityQName, line, path);
971 moduleBuilder.enterNode(builder);
974 parseSchemaNodeArgs(ctx, builder);
976 for (int i = 0; i < ctx.getChildCount(); i++) {
977 ParseTree child = ctx.getChild(i);
978 if (child instanceof Base_stmtContext) {
979 String baseIdentityName = stringFromNode(child);
980 builder.setBaseIdentityName(baseIdentityName);
986 public void exitIdentity_stmt(YangParser.Identity_stmtContext ctx) {
987 moduleBuilder.exitNode();
988 exitLog("identity", removeNodeFromPath());
991 public ModuleBuilder getModuleBuilder() {
992 return moduleBuilder;
995 private void enterLog(String p1, String p2, int line) {
996 LOGGER.trace("entering {} {} ({})", p1, p2, line);
999 private void exitLog(String p1, String p2) {
1000 LOGGER.trace("exiting {} {}", p1, p2);
1003 private void exitLog(String p1, QName p2) {
1004 LOGGER.trace("exiting {} {}", p1, p2.getLocalName());
1007 private void setLog(String p1, String p2) {
1008 LOGGER.trace("setting {} {}", p1, p2);