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 public final class YangParserListenerImpl extends YangParserBaseListener {
60 private static final Logger LOGGER = LoggerFactory.getLogger(YangParserListenerImpl.class);
61 private static final String AUGMENT_STR = "augment";
63 private ModuleBuilder moduleBuilder;
64 private String moduleName;
65 private URI namespace;
66 private String yangModelPrefix;
67 private Date revision = new Date(0L);
69 private final DateFormat SIMPLE_DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd");
70 private final Stack<Stack<QName>> actualPath = new Stack<>();
72 private void addNodeToPath(QName name) {
73 actualPath.peek().push(name);
76 private QName removeNodeFromPath() {
77 return actualPath.peek().pop();
81 public void enterModule_stmt(YangParser.Module_stmtContext ctx) {
82 moduleName = stringFromNode(ctx);
83 LOGGER.debug("entering module " + moduleName);
84 enterLog("module", moduleName, 0);
85 actualPath.push(new Stack<QName>());
87 moduleBuilder = new ModuleBuilder(moduleName);
89 String description = null;
90 String reference = null;
91 for (int i = 0; i < ctx.getChildCount(); i++) {
92 ParseTree child = ctx.getChild(i);
93 if (child instanceof Description_stmtContext) {
94 description = stringFromNode(child);
95 } else if (child instanceof Reference_stmtContext) {
96 reference = stringFromNode(child);
98 if (description != null && reference != null) {
103 moduleBuilder.setDescription(description);
104 moduleBuilder.setReference(reference);
108 public void exitModule_stmt(YangParser.Module_stmtContext ctx) {
109 exitLog("module", "");
114 public void enterModule_header_stmts(Module_header_stmtsContext ctx) {
115 enterLog("module_header", "", ctx.getStart().getLine());
116 String yangVersion = null;
117 for (int i = 0; i < ctx.getChildCount(); ++i) {
118 final ParseTree treeNode = ctx.getChild(i);
119 if (treeNode instanceof Namespace_stmtContext) {
120 final String namespaceStr = stringFromNode(treeNode);
121 namespace = URI.create(namespaceStr);
122 moduleBuilder.setNamespace(namespace);
123 setLog("namespace", namespaceStr);
124 } else if (treeNode instanceof Prefix_stmtContext) {
125 yangModelPrefix = stringFromNode(treeNode);
126 moduleBuilder.setPrefix(yangModelPrefix);
127 setLog("prefix", yangModelPrefix);
128 } else if (treeNode instanceof Yang_version_stmtContext) {
129 yangVersion = stringFromNode(treeNode);
130 setLog("yang-version", yangVersion);
134 if (yangVersion == null) {
137 moduleBuilder.setYangVersion(yangVersion);
141 public void exitModule_header_stmts(Module_header_stmtsContext ctx) {
142 exitLog("module_header", "");
146 public void enterMeta_stmts(YangParser.Meta_stmtsContext ctx) {
147 enterLog("meta_stmt", "", ctx.getStart().getLine());
148 for (int i = 0; i < ctx.getChildCount(); i++) {
149 ParseTree child = ctx.getChild(i);
150 if (child instanceof Organization_stmtContext) {
151 final String organization = stringFromNode(child);
152 moduleBuilder.setOrganization(organization);
153 setLog("organization", organization);
154 } else if (child instanceof Contact_stmtContext) {
155 final String contact = stringFromNode(child);
156 moduleBuilder.setContact(contact);
157 setLog("contact", contact);
158 } else if (child instanceof Description_stmtContext) {
159 final String description = stringFromNode(child);
160 moduleBuilder.setDescription(description);
161 setLog("description", description);
162 } else if (child instanceof Reference_stmtContext) {
163 final String reference = stringFromNode(child);
164 moduleBuilder.setReference(reference);
165 setLog("reference", reference);
171 public void exitMeta_stmts(YangParser.Meta_stmtsContext ctx) {
172 exitLog("meta_stmt", "");
176 public void enterRevision_stmts(Revision_stmtsContext ctx) {
177 enterLog("revisions", "", ctx.getStart().getLine());
178 for (int i = 0; i < ctx.getChildCount(); ++i) {
179 final ParseTree treeNode = ctx.getChild(i);
180 if (treeNode instanceof Revision_stmtContext) {
181 updateRevisionForRevisionStatement(treeNode);
187 public void exitRevision_stmts(Revision_stmtsContext ctx) {
188 exitLog("revisions", "");
191 private void updateRevisionForRevisionStatement(final ParseTree treeNode) {
192 final String revisionDateStr = stringFromNode(treeNode);
194 final Date revisionDate = SIMPLE_DATE_FORMAT.parse(revisionDateStr);
195 if ((revisionDate != null) && (this.revision.compareTo(revisionDate) < 0)) {
196 this.revision = revisionDate;
197 moduleBuilder.setRevision(this.revision);
198 setLog("revision", this.revision.toString());
199 for (int i = 0; i < treeNode.getChildCount(); ++i) {
200 ParseTree child = treeNode.getChild(i);
201 if (child instanceof Reference_stmtContext) {
202 moduleBuilder.setReference(stringFromNode(child));
206 } catch (ParseException e) {
207 final String message = "Failed to parse revision string: " + revisionDateStr;
208 LOGGER.warn(message);
213 public void enterImport_stmt(Import_stmtContext ctx) {
214 final int line = ctx.getStart().getLine();
215 final String importName = stringFromNode(ctx);
216 enterLog("import", importName, line);
218 String importPrefix = null;
219 Date importRevision = null;
221 for (int i = 0; i < ctx.getChildCount(); ++i) {
222 final ParseTree treeNode = ctx.getChild(i);
223 if (treeNode instanceof Prefix_stmtContext) {
224 importPrefix = stringFromNode(treeNode);
226 if (treeNode instanceof Revision_date_stmtContext) {
227 String importRevisionStr = stringFromNode(treeNode);
229 importRevision = SIMPLE_DATE_FORMAT.parse(importRevisionStr);
230 } catch (ParseException e) {
231 LOGGER.warn("Failed to parse import revision-date at line " + line + ": " + importRevisionStr);
235 moduleBuilder.addModuleImport(importName, importRevision, importPrefix);
236 setLog("import", "(" + importName + "; " + importRevision + "; " + importPrefix + ")");
240 public void exitImport_stmt(Import_stmtContext ctx) {
241 exitLog("import", "");
245 public void enterAugment_stmt(YangParser.Augment_stmtContext ctx) {
246 final int line = ctx.getStart().getLine();
247 final String augmentPath = stringFromNode(ctx);
248 enterLog(AUGMENT_STR, augmentPath, line);
249 actualPath.push(new Stack<QName>());
251 AugmentationSchemaBuilder builder = moduleBuilder.addAugment(line, augmentPath);
253 for (int i = 0; i < ctx.getChildCount(); i++) {
254 ParseTree child = ctx.getChild(i);
255 if (child instanceof Description_stmtContext) {
256 builder.setDescription(stringFromNode(child));
257 } else if (child instanceof Reference_stmtContext) {
258 builder.setReference(stringFromNode(child));
259 } else if (child instanceof Status_stmtContext) {
260 builder.setStatus(parseStatus((Status_stmtContext) child));
261 } else if (child instanceof When_stmtContext) {
262 builder.addWhenCondition(stringFromNode(child));
266 moduleBuilder.enterNode(builder);
270 public void exitAugment_stmt(YangParser.Augment_stmtContext ctx) {
271 moduleBuilder.exitNode();
272 exitLog(AUGMENT_STR, "");
277 public void enterExtension_stmt(YangParser.Extension_stmtContext ctx) {
278 final int line = ctx.getStart().getLine();
279 final String extName = stringFromNode(ctx);
280 enterLog("extension", extName, line);
281 QName qname = new QName(namespace, revision, yangModelPrefix, extName);
282 addNodeToPath(qname);
283 SchemaPath path = createActualSchemaPath(actualPath.peek());
285 ExtensionBuilder builder = moduleBuilder.addExtension(qname, line, path);
286 parseSchemaNodeArgs(ctx, builder);
288 String argument = null;
290 for (int i = 0; i < ctx.getChildCount(); i++) {
291 ParseTree child = ctx.getChild(i);
292 if (child instanceof Argument_stmtContext) {
293 argument = stringFromNode(child);
294 yin = parseYinValue((Argument_stmtContext) child);
298 builder.setArgument(argument);
299 builder.setYinElement(yin);
301 moduleBuilder.enterNode(builder);
305 public void exitExtension_stmt(YangParser.Extension_stmtContext ctx) {
306 moduleBuilder.exitNode();
307 exitLog("extension", removeNodeFromPath());
311 public void enterTypedef_stmt(YangParser.Typedef_stmtContext ctx) {
312 final int line = ctx.getStart().getLine();
313 final String typedefName = stringFromNode(ctx);
314 enterLog("typedef", typedefName, line);
315 QName typedefQName = new QName(namespace, revision, yangModelPrefix, typedefName);
316 addNodeToPath(typedefQName);
317 SchemaPath path = createActualSchemaPath(actualPath.peek());
319 TypeDefinitionBuilder builder = moduleBuilder.addTypedef(line, typedefQName, path);
320 parseSchemaNodeArgs(ctx, builder);
321 builder.setUnits(parseUnits(ctx));
322 builder.setDefaultValue(parseDefault(ctx));
324 moduleBuilder.enterNode(builder);
328 public void exitTypedef_stmt(YangParser.Typedef_stmtContext ctx) {
329 moduleBuilder.exitNode();
330 exitLog("typedef", removeNodeFromPath());
334 public void enterType_stmt(YangParser.Type_stmtContext ctx) {
335 final int line = ctx.getStart().getLine();
336 final String typeName = stringFromNode(ctx);
337 enterLog("type", typeName, line);
339 final QName typeQName = parseQName(typeName);
341 TypeDefinition<?> type = null;
342 Type_body_stmtsContext typeBody = null;
343 for (int i = 0; i < ctx.getChildCount(); i++) {
344 if (ctx.getChild(i) instanceof Type_body_stmtsContext) {
345 typeBody = (Type_body_stmtsContext) ctx.getChild(i);
350 // if this is base yang type...
351 if (YangTypesConverter.isBaseYangType(typeName)) {
352 if (typeBody == null) {
353 // check for types which must have body
354 checkMissingBody(typeName, moduleName, line);
355 // if there are no constraints, just grab default base yang type
356 type = YangTypesConverter.javaTypeForBaseYangType(typeName);
357 addNodeToPath(type.getQName());
358 moduleBuilder.setType(type);
363 qname = BaseTypes.constructQName("union");
364 addNodeToPath(qname);
365 UnionTypeBuilder unionBuilder = moduleBuilder.addUnionType(line, namespace, revision);
366 Builder parent = moduleBuilder.getActualNode();
367 unionBuilder.setParent(parent);
368 moduleBuilder.enterNode(unionBuilder);
371 qname = BaseTypes.constructQName("identityref");
372 addNodeToPath(qname);
373 SchemaPath path = createActualSchemaPath(actualPath.peek());
374 moduleBuilder.addIdentityrefType(line, path, getIdentityrefBase(typeBody));
377 type = parseTypeWithBody(typeName, typeBody, actualPath.peek(), namespace, revision,
378 yangModelPrefix, moduleBuilder.getActualNode());
379 moduleBuilder.setType(type);
380 addNodeToPath(type.getQName());
384 type = parseUnknownTypeWithBody(typeQName, typeBody, actualPath.peek(), namespace, revision,
385 yangModelPrefix, moduleBuilder.getActualNode());
386 // add parent node of this type statement to dirty nodes
387 moduleBuilder.markActualNodeDirty();
388 moduleBuilder.setType(type);
389 addNodeToPath(type.getQName());
394 private QName parseQName(String typeName) {
396 if (typeName.contains(":")) {
397 String[] splittedName = typeName.split(":");
398 String prefix = splittedName[0];
399 String name = splittedName[1];
400 if (prefix.equals(yangModelPrefix)) {
401 typeQName = new QName(namespace, revision, prefix, name);
403 typeQName = new QName(null, null, prefix, name);
406 typeQName = new QName(namespace, revision, yangModelPrefix, typeName);
412 public void exitType_stmt(YangParser.Type_stmtContext ctx) {
413 final String typeName = stringFromNode(ctx);
414 if ("union".equals(typeName)) {
415 moduleBuilder.exitNode();
417 exitLog("type", removeNodeFromPath());
421 public void enterGrouping_stmt(YangParser.Grouping_stmtContext ctx) {
422 final int line = ctx.getStart().getLine();
423 final String groupName = stringFromNode(ctx);
424 enterLog("grouping", groupName, line);
425 QName groupQName = new QName(namespace, revision, yangModelPrefix, groupName);
426 addNodeToPath(groupQName);
427 SchemaPath path = createActualSchemaPath(actualPath.peek());
429 GroupingBuilder builder = moduleBuilder.addGrouping(ctx.getStart().getLine(), groupQName, path);
430 parseSchemaNodeArgs(ctx, builder);
432 moduleBuilder.enterNode(builder);
436 public void exitGrouping_stmt(YangParser.Grouping_stmtContext ctx) {
437 moduleBuilder.exitNode();
438 exitLog("grouping", removeNodeFromPath());
442 public void enterContainer_stmt(Container_stmtContext ctx) {
443 final int line = ctx.getStart().getLine();
444 final String containerName = stringFromNode(ctx);
445 enterLog("container", containerName, line);
447 QName containerQName = new QName(namespace, revision, yangModelPrefix, containerName);
448 addNodeToPath(containerQName);
449 SchemaPath path = createActualSchemaPath(actualPath.peek());
451 ContainerSchemaNodeBuilder builder = moduleBuilder.addContainerNode(line, containerQName, path);
452 parseSchemaNodeArgs(ctx, builder);
453 parseConstraints(ctx, builder.getConstraints());
454 builder.setConfiguration(getConfig(ctx, moduleBuilder.getActualParent(), moduleName, line));
456 for (int i = 0; i < ctx.getChildCount(); ++i) {
457 final ParseTree childNode = ctx.getChild(i);
458 if (childNode instanceof Presence_stmtContext) {
459 builder.setPresence(true);
464 moduleBuilder.enterNode(builder);
468 public void exitContainer_stmt(Container_stmtContext ctx) {
469 moduleBuilder.exitNode();
470 exitLog("container", removeNodeFromPath());
474 public void enterLeaf_stmt(Leaf_stmtContext ctx) {
475 final int line = ctx.getStart().getLine();
476 final String leafName = stringFromNode(ctx);
477 enterLog("leaf", leafName, line);
479 QName leafQName = new QName(namespace, revision, yangModelPrefix, leafName);
480 addNodeToPath(leafQName);
481 SchemaPath path = createActualSchemaPath(actualPath.peek());
483 LeafSchemaNodeBuilder builder = moduleBuilder.addLeafNode(line, leafQName, path);
484 parseSchemaNodeArgs(ctx, builder);
485 parseConstraints(ctx, builder.getConstraints());
486 builder.setConfiguration(getConfig(ctx, moduleBuilder.getActualParent(), moduleName, line));
488 String defaultStr = null;
489 String unitsStr = null;
490 for (int i = 0; i < ctx.getChildCount(); i++) {
491 ParseTree child = ctx.getChild(i);
492 if (child instanceof Default_stmtContext) {
493 defaultStr = stringFromNode(child);
494 } else if (child instanceof Units_stmtContext) {
495 unitsStr = stringFromNode(child);
498 builder.setDefaultStr(defaultStr);
499 builder.setUnits(unitsStr);
501 moduleBuilder.enterNode(builder);
505 public void exitLeaf_stmt(YangParser.Leaf_stmtContext ctx) {
506 moduleBuilder.exitNode();
507 exitLog("leaf", removeNodeFromPath());
511 public void enterUses_stmt(YangParser.Uses_stmtContext ctx) {
512 final int line = ctx.getStart().getLine();
513 final String groupingPathStr = stringFromNode(ctx);
514 enterLog("uses", groupingPathStr, line);
516 UsesNodeBuilder builder = moduleBuilder.addUsesNode(line, groupingPathStr);
518 moduleBuilder.enterNode(builder);
522 public void exitUses_stmt(YangParser.Uses_stmtContext ctx) {
523 moduleBuilder.exitNode();
528 public void enterUses_augment_stmt(YangParser.Uses_augment_stmtContext ctx) {
529 actualPath.push(new Stack<QName>());
530 final int line = ctx.getStart().getLine();
531 final String augmentPath = stringFromNode(ctx);
532 enterLog(AUGMENT_STR, augmentPath, line);
534 AugmentationSchemaBuilder builder = moduleBuilder.addAugment(line, augmentPath);
536 for (int i = 0; i < ctx.getChildCount(); i++) {
537 ParseTree child = ctx.getChild(i);
538 if (child instanceof Description_stmtContext) {
539 builder.setDescription(stringFromNode(child));
540 } else if (child instanceof Reference_stmtContext) {
541 builder.setReference(stringFromNode(child));
542 } else if (child instanceof Status_stmtContext) {
543 builder.setStatus(parseStatus((Status_stmtContext) child));
544 } else if (child instanceof When_stmtContext) {
545 builder.addWhenCondition(stringFromNode(child));
549 moduleBuilder.enterNode(builder);
553 public void exitUses_augment_stmt(YangParser.Uses_augment_stmtContext ctx) {
554 moduleBuilder.exitNode();
555 exitLog(AUGMENT_STR, "");
560 public void enterRefine_stmt(YangParser.Refine_stmtContext ctx) {
561 final String refineString = stringFromNode(ctx);
562 enterLog("refine", refineString, ctx.getStart().getLine());
564 RefineHolder refine = parseRefine(ctx, moduleName);
565 moduleBuilder.addRefine(refine);
566 moduleBuilder.enterNode(refine);
570 public void exitRefine_stmt(YangParser.Refine_stmtContext ctx) {
571 moduleBuilder.exitNode();
572 exitLog("refine", "");
576 public void enterLeaf_list_stmt(Leaf_list_stmtContext ctx) {
577 final int line = ctx.getStart().getLine();
578 final String leafListName = stringFromNode(ctx);
579 enterLog("leaf-list", leafListName, line);
580 QName leafListQName = new QName(namespace, revision, yangModelPrefix, leafListName);
581 addNodeToPath(leafListQName);
582 SchemaPath path = createActualSchemaPath(actualPath.peek());
584 LeafListSchemaNodeBuilder builder = moduleBuilder.addLeafListNode(line, leafListQName, path);
585 moduleBuilder.enterNode(builder);
587 parseSchemaNodeArgs(ctx, builder);
588 parseConstraints(ctx, builder.getConstraints());
589 builder.setConfiguration(getConfig(ctx, moduleBuilder.getActualParent(), moduleName, ctx.getStart().getLine()));
591 for (int i = 0; i < ctx.getChildCount(); ++i) {
592 final ParseTree childNode = ctx.getChild(i);
593 if (childNode instanceof Ordered_by_stmtContext) {
594 final Ordered_by_stmtContext orderedBy = (Ordered_by_stmtContext) childNode;
595 final boolean userOrdered = parseUserOrdered(orderedBy);
596 builder.setUserOrdered(userOrdered);
603 public void exitLeaf_list_stmt(YangParser.Leaf_list_stmtContext ctx) {
604 moduleBuilder.exitNode();
605 exitLog("leaf-list", removeNodeFromPath());
609 public void enterList_stmt(List_stmtContext ctx) {
610 final int line = ctx.getStart().getLine();
611 final String listName = stringFromNode(ctx);
612 enterLog("list", listName, line);
614 QName listQName = new QName(namespace, revision, yangModelPrefix, listName);
615 addNodeToPath(listQName);
616 SchemaPath path = createActualSchemaPath(actualPath.peek());
618 ListSchemaNodeBuilder builder = moduleBuilder.addListNode(line, listQName, path);
619 moduleBuilder.enterNode(builder);
621 parseSchemaNodeArgs(ctx, builder);
622 parseConstraints(ctx, builder.getConstraints());
623 builder.setConfiguration(getConfig(ctx, moduleBuilder.getActualParent(), moduleName, line));
625 String keyDefinition = "";
626 for (int i = 0; i < ctx.getChildCount(); ++i) {
627 ParseTree childNode = ctx.getChild(i);
628 if (childNode instanceof Ordered_by_stmtContext) {
629 final Ordered_by_stmtContext orderedBy = (Ordered_by_stmtContext) childNode;
630 final boolean userOrdered = parseUserOrdered(orderedBy);
631 builder.setUserOrdered(userOrdered);
632 } else if (childNode instanceof Key_stmtContext) {
633 keyDefinition = stringFromNode(childNode);
634 List<QName> key = createListKey(keyDefinition, namespace, revision, yangModelPrefix);
635 builder.setKeyDefinition(key);
641 public void exitList_stmt(List_stmtContext ctx) {
642 moduleBuilder.exitNode();
643 exitLog("list", removeNodeFromPath());
647 public void enterAnyxml_stmt(YangParser.Anyxml_stmtContext ctx) {
648 final int line = ctx.getStart().getLine();
649 final String anyXmlName = stringFromNode(ctx);
650 enterLog("anyxml", anyXmlName, line);
652 QName anyXmlQName = new QName(namespace, revision, yangModelPrefix, anyXmlName);
653 addNodeToPath(anyXmlQName);
654 SchemaPath path = createActualSchemaPath(actualPath.peek());
656 AnyXmlBuilder builder = moduleBuilder.addAnyXml(line, anyXmlQName, path);
657 moduleBuilder.enterNode(builder);
659 parseSchemaNodeArgs(ctx, builder);
660 parseConstraints(ctx, builder.getConstraints());
661 builder.setConfiguration(getConfig(ctx, moduleBuilder.getActualParent(), moduleName, line));
665 public void exitAnyxml_stmt(YangParser.Anyxml_stmtContext ctx) {
666 moduleBuilder.exitNode();
667 exitLog("anyxml", removeNodeFromPath());
671 public void enterChoice_stmt(YangParser.Choice_stmtContext ctx) {
672 final int line = ctx.getStart().getLine();
673 final String choiceName = stringFromNode(ctx);
674 enterLog("choice", choiceName, line);
676 QName choiceQName = new QName(namespace, revision, yangModelPrefix, choiceName);
677 addNodeToPath(choiceQName);
678 SchemaPath path = createActualSchemaPath(actualPath.peek());
680 ChoiceBuilder builder = moduleBuilder.addChoice(line, choiceQName, path);
681 moduleBuilder.enterNode(builder);
683 parseSchemaNodeArgs(ctx, builder);
684 parseConstraints(ctx, builder.getConstraints());
685 builder.setConfiguration(getConfig(ctx, moduleBuilder.getActualParent(), moduleName, line));
687 // set 'default' case
688 for (int i = 0; i < ctx.getChildCount(); i++) {
689 ParseTree child = ctx.getChild(i);
690 if (child instanceof Default_stmtContext) {
691 String defaultCase = stringFromNode(child);
692 builder.setDefaultCase(defaultCase);
699 public void exitChoice_stmt(YangParser.Choice_stmtContext ctx) {
700 moduleBuilder.exitNode();
701 exitLog("choice", removeNodeFromPath());
705 public void enterCase_stmt(YangParser.Case_stmtContext ctx) {
706 final int line = ctx.getStart().getLine();
707 final String caseName = stringFromNode(ctx);
708 enterLog("case", caseName, line);
710 QName caseQName = new QName(namespace, revision, yangModelPrefix, caseName);
711 addNodeToPath(caseQName);
712 SchemaPath path = createActualSchemaPath(actualPath.peek());
714 ChoiceCaseBuilder builder = moduleBuilder.addCase(line, caseQName, path);
715 moduleBuilder.enterNode(builder);
717 parseSchemaNodeArgs(ctx, builder);
718 parseConstraints(ctx, builder.getConstraints());
722 public void exitCase_stmt(YangParser.Case_stmtContext ctx) {
723 moduleBuilder.exitNode();
724 exitLog("case", removeNodeFromPath());
728 public void enterNotification_stmt(YangParser.Notification_stmtContext ctx) {
729 final int line = ctx.getStart().getLine();
730 final String notificationName = stringFromNode(ctx);
731 enterLog("notification", notificationName, line);
733 QName notificationQName = new QName(namespace, revision, yangModelPrefix, notificationName);
734 addNodeToPath(notificationQName);
735 SchemaPath path = createActualSchemaPath(actualPath.peek());
737 NotificationBuilder builder = moduleBuilder.addNotification(line, notificationQName, path);
738 moduleBuilder.enterNode(builder);
740 parseSchemaNodeArgs(ctx, builder);
744 public void exitNotification_stmt(YangParser.Notification_stmtContext ctx) {
745 moduleBuilder.exitNode();
746 exitLog("notification", removeNodeFromPath());
751 public void enterIdentifier_stmt(YangParser.Identifier_stmtContext ctx) {
752 final int line = ctx.getStart().getLine();
753 final String nodeParameter = stringFromNode(ctx);
754 enterLog("unknown-node", nodeParameter, line);
757 final String nodeTypeStr = ctx.getChild(0).getText();
758 final String[] splittedElement = nodeTypeStr.split(":");
759 if (splittedElement.length == 1) {
760 nodeType = new QName(namespace, revision, yangModelPrefix, splittedElement[0]);
762 nodeType = new QName(namespace, revision, splittedElement[0], splittedElement[1]);
766 if (nodeParameter != null) {
767 String[] splittedName = nodeParameter.split(":");
768 if (splittedName.length == 2) {
769 qname = new QName(null, null, splittedName[0], splittedName[1]);
771 qname = new QName(namespace, revision, yangModelPrefix, splittedName[0]);
774 qname = new QName(namespace, revision, yangModelPrefix, nodeParameter);
777 addNodeToPath(new QName(namespace, revision, yangModelPrefix, nodeParameter));
778 SchemaPath path = createActualSchemaPath(actualPath.peek());
780 UnknownSchemaNodeBuilder builder = moduleBuilder.addUnknownSchemaNode(line, qname, path);
781 builder.setNodeType(nodeType);
782 builder.setNodeParameter(nodeParameter);
785 parseSchemaNodeArgs(ctx, builder);
786 moduleBuilder.enterNode(builder);
790 public void exitIdentifier_stmt(YangParser.Identifier_stmtContext ctx) {
791 moduleBuilder.exitNode();
792 exitLog("unknown-node", removeNodeFromPath());
796 public void enterRpc_stmt(YangParser.Rpc_stmtContext ctx) {
797 final int line = ctx.getStart().getLine();
798 final String rpcName = stringFromNode(ctx);
799 enterLog("rpc", rpcName, line);
801 QName rpcQName = new QName(namespace, revision, yangModelPrefix, rpcName);
802 addNodeToPath(rpcQName);
803 SchemaPath path = createActualSchemaPath(actualPath.peek());
805 RpcDefinitionBuilder rpcBuilder = moduleBuilder.addRpc(line, rpcQName, path);
806 moduleBuilder.enterNode(rpcBuilder);
809 parseSchemaNodeArgs(ctx, rpcBuilder);
813 public void exitRpc_stmt(YangParser.Rpc_stmtContext ctx) {
814 moduleBuilder.exitNode();
815 exitLog("rpc", removeNodeFromPath());
819 public void enterInput_stmt(YangParser.Input_stmtContext ctx) {
820 final int line = ctx.getStart().getLine();
821 final String input = "input";
822 enterLog(input, input, line);
824 QName rpcQName = new QName(namespace, revision, yangModelPrefix, input);
825 addNodeToPath(rpcQName);
826 SchemaPath path = createActualSchemaPath(actualPath.peek());
828 ContainerSchemaNodeBuilder builder = moduleBuilder.addRpcInput(line, rpcQName, path);
829 moduleBuilder.enterNode(builder);
831 parseSchemaNodeArgs(ctx, builder);
832 parseConstraints(ctx, builder.getConstraints());
836 public void exitInput_stmt(YangParser.Input_stmtContext ctx) {
837 moduleBuilder.exitNode();
838 exitLog("input", removeNodeFromPath());
842 public void enterOutput_stmt(YangParser.Output_stmtContext ctx) {
843 final int line = ctx.getStart().getLine();
844 final String output = "output";
845 enterLog(output, output, line);
847 QName rpcQName = new QName(namespace, revision, yangModelPrefix, output);
848 addNodeToPath(rpcQName);
849 SchemaPath path = createActualSchemaPath(actualPath.peek());
851 ContainerSchemaNodeBuilder builder = moduleBuilder.addRpcOutput(path, rpcQName, line);
852 moduleBuilder.enterNode(builder);
854 parseSchemaNodeArgs(ctx, builder);
855 parseConstraints(ctx, builder.getConstraints());
859 public void exitOutput_stmt(YangParser.Output_stmtContext ctx) {
860 moduleBuilder.exitNode();
861 exitLog("output", removeNodeFromPath());
865 public void enterFeature_stmt(YangParser.Feature_stmtContext ctx) {
866 final int line = ctx.getStart().getLine();
867 final String featureName = stringFromNode(ctx);
868 enterLog("feature", featureName, line);
870 QName featureQName = new QName(namespace, revision, yangModelPrefix, featureName);
871 addNodeToPath(featureQName);
872 SchemaPath path = createActualSchemaPath(actualPath.peek());
874 FeatureBuilder featureBuilder = moduleBuilder.addFeature(line, featureQName, path);
875 moduleBuilder.enterNode(featureBuilder);
877 parseSchemaNodeArgs(ctx, featureBuilder);
881 public void exitFeature_stmt(YangParser.Feature_stmtContext ctx) {
882 moduleBuilder.exitNode();
883 exitLog("feature", removeNodeFromPath());
887 public void enterDeviation_stmt(YangParser.Deviation_stmtContext ctx) {
888 final int line = ctx.getStart().getLine();
889 final String targetPath = stringFromNode(ctx);
890 enterLog("deviation", targetPath, line);
892 String reference = null;
893 String deviate = null;
894 DeviationBuilder builder = moduleBuilder.addDeviation(line, targetPath);
895 moduleBuilder.enterNode(builder);
897 for (int i = 0; i < ctx.getChildCount(); i++) {
898 ParseTree child = ctx.getChild(i);
899 if (child instanceof Reference_stmtContext) {
900 reference = stringFromNode(child);
901 } else if (child instanceof Deviate_not_supported_stmtContext) {
902 deviate = stringFromNode(child);
903 } else if (child instanceof Deviate_add_stmtContext) {
904 deviate = stringFromNode(child);
905 } else if (child instanceof Deviate_replace_stmtContext) {
906 deviate = stringFromNode(child);
907 } else if (child instanceof Deviate_delete_stmtContext) {
908 deviate = stringFromNode(child);
911 builder.setReference(reference);
912 builder.setDeviate(deviate);
916 public void exitDeviation_stmt(YangParser.Deviation_stmtContext ctx) {
917 moduleBuilder.exitNode();
918 exitLog("deviation", "");
922 public void enterIdentity_stmt(YangParser.Identity_stmtContext ctx) {
923 final int line = ctx.getStart().getLine();
924 final String identityName = stringFromNode(ctx);
925 enterLog("identity", identityName, line);
927 final QName identityQName = new QName(namespace, revision, yangModelPrefix, identityName);
928 addNodeToPath(identityQName);
929 SchemaPath path = createActualSchemaPath(actualPath.peek());
931 IdentitySchemaNodeBuilder builder = moduleBuilder.addIdentity(identityQName, line, path);
932 moduleBuilder.enterNode(builder);
935 parseSchemaNodeArgs(ctx, builder);
937 for (int i = 0; i < ctx.getChildCount(); i++) {
938 ParseTree child = ctx.getChild(i);
939 if (child instanceof Base_stmtContext) {
940 String baseIdentityName = stringFromNode(child);
941 builder.setBaseIdentityName(baseIdentityName);
947 public void exitIdentity_stmt(YangParser.Identity_stmtContext ctx) {
948 moduleBuilder.exitNode();
949 exitLog("identity", removeNodeFromPath());
952 public ModuleBuilder getModuleBuilder() {
953 return moduleBuilder;
956 private void enterLog(String p1, String p2, int line) {
957 LOGGER.trace("entering {} {} ({})", p1, p2, line);
960 private void exitLog(String p1, String p2) {
961 LOGGER.trace("exiting {} {}", p1, p2);
964 private void exitLog(String p1, QName p2) {
965 LOGGER.trace("exiting {} {}", p1, p2.getLocalName());
968 private void setLog(String p1, String p2) {
969 LOGGER.trace("setting {} {}", p1, p2);