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.controller.yang.parser.impl;
10 import static org.opendaylight.controller.yang.parser.util.YangModelBuilderUtil.*;
13 import java.text.DateFormat;
14 import java.text.ParseException;
15 import java.text.SimpleDateFormat;
16 import java.util.ArrayList;
17 import java.util.Date;
18 import java.util.List;
19 import java.util.Stack;
21 import org.antlr.v4.runtime.tree.ParseTree;
22 import org.opendaylight.controller.antlrv4.code.gen.YangParser;
23 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Argument_stmtContext;
24 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Base_stmtContext;
25 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Contact_stmtContext;
26 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Container_stmtContext;
27 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Default_stmtContext;
28 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Description_stmtContext;
29 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Deviate_add_stmtContext;
30 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Deviate_delete_stmtContext;
31 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Deviate_not_supported_stmtContext;
32 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Deviate_replace_stmtContext;
33 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Import_stmtContext;
34 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Key_stmtContext;
35 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Leaf_list_stmtContext;
36 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Leaf_stmtContext;
37 import org.opendaylight.controller.antlrv4.code.gen.YangParser.List_stmtContext;
38 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Module_header_stmtsContext;
39 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Namespace_stmtContext;
40 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Ordered_by_stmtContext;
41 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Organization_stmtContext;
42 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Prefix_stmtContext;
43 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Presence_stmtContext;
44 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Reference_stmtContext;
45 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Revision_date_stmtContext;
46 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Revision_stmtContext;
47 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Revision_stmtsContext;
48 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Status_stmtContext;
49 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Type_body_stmtsContext;
50 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Units_stmtContext;
51 import org.opendaylight.controller.antlrv4.code.gen.YangParser.When_stmtContext;
52 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Yang_version_stmtContext;
53 import org.opendaylight.controller.antlrv4.code.gen.YangParserBaseListener;
54 import org.opendaylight.controller.yang.common.QName;
55 import org.opendaylight.controller.yang.model.api.SchemaPath;
56 import org.opendaylight.controller.yang.model.api.Status;
57 import org.opendaylight.controller.yang.model.api.TypeDefinition;
58 import org.opendaylight.controller.yang.model.util.YangTypesConverter;
59 import org.opendaylight.controller.yang.parser.builder.api.AugmentationSchemaBuilder;
60 import org.opendaylight.controller.yang.parser.builder.api.GroupingBuilder;
61 import org.opendaylight.controller.yang.parser.builder.impl.AnyXmlBuilder;
62 import org.opendaylight.controller.yang.parser.builder.impl.ChoiceBuilder;
63 import org.opendaylight.controller.yang.parser.builder.impl.ChoiceCaseBuilder;
64 import org.opendaylight.controller.yang.parser.builder.impl.ContainerSchemaNodeBuilder;
65 import org.opendaylight.controller.yang.parser.builder.impl.DeviationBuilder;
66 import org.opendaylight.controller.yang.parser.builder.impl.ExtensionBuilder;
67 import org.opendaylight.controller.yang.parser.builder.impl.FeatureBuilder;
68 import org.opendaylight.controller.yang.parser.builder.impl.IdentitySchemaNodeBuilder;
69 import org.opendaylight.controller.yang.parser.builder.impl.LeafListSchemaNodeBuilder;
70 import org.opendaylight.controller.yang.parser.builder.impl.LeafSchemaNodeBuilder;
71 import org.opendaylight.controller.yang.parser.builder.impl.ListSchemaNodeBuilder;
72 import org.opendaylight.controller.yang.parser.builder.impl.ModuleBuilder;
73 import org.opendaylight.controller.yang.parser.builder.impl.NotificationBuilder;
74 import org.opendaylight.controller.yang.parser.builder.impl.RpcDefinitionBuilder;
75 import org.opendaylight.controller.yang.parser.builder.impl.TypedefBuilder;
76 import org.opendaylight.controller.yang.parser.builder.impl.UnknownSchemaNodeBuilder;
77 import org.opendaylight.controller.yang.parser.util.RefineHolder;
78 import org.slf4j.Logger;
79 import org.slf4j.LoggerFactory;
81 public final class YangParserListenerImpl extends YangParserBaseListener {
83 private static final Logger logger = LoggerFactory
84 .getLogger(YangParserListenerImpl.class);
86 private ModuleBuilder moduleBuilder;
88 private String moduleName;
89 private URI namespace;
90 private String yangModelPrefix;
91 private Date revision = new Date(0L);
93 public final static DateFormat simpleDateFormat = new SimpleDateFormat(
95 private final Stack<String> actualPath = new Stack<String>();
98 public void enterModule_stmt(YangParser.Module_stmtContext ctx) {
99 moduleName = stringFromNode(ctx);
100 actualPath.push(moduleName);
101 moduleBuilder = new ModuleBuilder(moduleName);
103 String description = null;
104 String reference = null;
106 for (int i = 0; i < ctx.getChildCount(); i++) {
107 ParseTree child = ctx.getChild(i);
108 if (child instanceof Description_stmtContext) {
109 description = stringFromNode(child);
110 } else if (child instanceof Reference_stmtContext) {
111 reference = stringFromNode(child);
113 if (description != null && reference != null) {
118 moduleBuilder.setDescription(description);
119 moduleBuilder.setReference(reference);
123 public void exitModule_stmt(YangParser.Module_stmtContext ctx) {
124 final String moduleName = actualPath.pop();
125 logger.debug("Exiting module " + moduleName);
129 public void enterModule_header_stmts(final Module_header_stmtsContext ctx) {
130 super.enterModule_header_stmts(ctx);
132 String yangVersion = null;
133 for (int i = 0; i < ctx.getChildCount(); ++i) {
134 final ParseTree treeNode = ctx.getChild(i);
135 if (treeNode instanceof Namespace_stmtContext) {
136 final String namespaceStr = stringFromNode(treeNode);
137 namespace = URI.create(namespaceStr);
138 moduleBuilder.setNamespace(namespace);
139 } else if (treeNode instanceof Prefix_stmtContext) {
140 yangModelPrefix = stringFromNode(treeNode);
141 moduleBuilder.setPrefix(yangModelPrefix);
142 } else if (treeNode instanceof Yang_version_stmtContext) {
143 yangVersion = stringFromNode(treeNode);
147 if (yangVersion == null) {
150 moduleBuilder.setYangVersion(yangVersion);
154 public void enterMeta_stmts(YangParser.Meta_stmtsContext ctx) {
155 for (int i = 0; i < ctx.getChildCount(); i++) {
156 ParseTree child = ctx.getChild(i);
157 if (child instanceof Organization_stmtContext) {
158 final String organization = stringFromNode(child);
159 moduleBuilder.setOrganization(organization);
160 } else if (child instanceof Contact_stmtContext) {
161 final String contact = stringFromNode(child);
162 moduleBuilder.setContact(contact);
163 } else if (child instanceof Description_stmtContext) {
164 final String description = stringFromNode(child);
165 moduleBuilder.setDescription(description);
166 } else if (child instanceof Reference_stmtContext) {
167 final String reference = stringFromNode(child);
168 moduleBuilder.setReference(reference);
174 public void exitSubmodule_header_stmts(
175 YangParser.Submodule_header_stmtsContext ctx) {
176 final String submodule = actualPath.pop();
177 logger.debug("exiting submodule " + submodule);
181 public void enterRevision_stmts(Revision_stmtsContext ctx) {
183 for (int i = 0; i < ctx.getChildCount(); ++i) {
184 final ParseTree treeNode = ctx.getChild(i);
185 if (treeNode instanceof Revision_stmtContext) {
186 updateRevisionForRevisionStatement(treeNode);
192 private void updateRevisionForRevisionStatement(final ParseTree treeNode) {
193 final String revisionDateStr = stringFromNode(treeNode);
195 final Date revision = simpleDateFormat.parse(revisionDateStr);
196 if ((revision != null) && (this.revision.compareTo(revision) < 0)) {
197 this.revision = revision;
198 moduleBuilder.setRevision(this.revision);
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: "
209 logger.warn(message);
214 public void enterImport_stmt(Import_stmtContext ctx) {
215 final String importName = stringFromNode(ctx);
216 String importPrefix = null;
217 Date importRevision = null;
219 for (int i = 0; i < ctx.getChildCount(); ++i) {
220 final ParseTree treeNode = ctx.getChild(i);
221 if (treeNode instanceof Prefix_stmtContext) {
222 importPrefix = stringFromNode(treeNode);
224 if (treeNode instanceof Revision_date_stmtContext) {
225 String importRevisionStr = stringFromNode(treeNode);
227 importRevision = simpleDateFormat.parse(importRevisionStr);
228 } catch (ParseException e) {
229 logger.warn("Failed to parse import revision-date: "
230 + importRevisionStr);
234 moduleBuilder.addModuleImport(importName, importRevision, importPrefix);
238 public void enterAugment_stmt(YangParser.Augment_stmtContext ctx) {
239 final String augmentPath = stringFromNode(ctx);
240 AugmentationSchemaBuilder builder = moduleBuilder.addAugment(
241 augmentPath, actualPath, ctx.getStart().getLine());
242 updatePath(augmentPath);
244 for (int i = 0; i < ctx.getChildCount(); i++) {
245 ParseTree child = ctx.getChild(i);
246 if (child instanceof Description_stmtContext) {
247 String desc = stringFromNode(child);
248 builder.setDescription(desc);
249 } else if (child instanceof Reference_stmtContext) {
250 String ref = stringFromNode(child);
251 builder.setReference(ref);
252 } else if (child instanceof Status_stmtContext) {
253 Status status = parseStatus((Status_stmtContext) child);
254 builder.setStatus(status);
255 } else if (child instanceof When_stmtContext) {
256 String when = stringFromNode(child);
257 builder.addWhenCondition(when);
263 public void exitAugment_stmt(YangParser.Augment_stmtContext ctx) {
264 final String augment = actualPath.pop();
265 logger.debug("exiting augment " + augment);
269 public void enterExtension_stmt(YangParser.Extension_stmtContext ctx) {
270 final String extName = stringFromNode(ctx);
271 QName qname = new QName(namespace, revision, yangModelPrefix, extName);
272 ExtensionBuilder builder = moduleBuilder.addExtension(qname, ctx
273 .getStart().getLine());
274 parseSchemaNodeArgs(ctx, builder);
276 String argument = null;
278 for (int i = 0; i < ctx.getChildCount(); i++) {
279 ParseTree child = ctx.getChild(i);
280 if (child instanceof Argument_stmtContext) {
281 argument = stringFromNode(child);
282 yin = parseYinValue((Argument_stmtContext) child);
286 builder.setArgument(argument);
287 builder.setYinElement(yin);
291 public void enterTypedef_stmt(YangParser.Typedef_stmtContext ctx) {
292 final String typedefName = stringFromNode(ctx);
293 QName typedefQName = new QName(namespace, revision, yangModelPrefix,
295 TypedefBuilder builder = moduleBuilder.addTypedef(typedefQName,
296 actualPath, ctx.getStart().getLine());
297 updatePath(typedefName);
299 builder.setPath(createActualSchemaPath(actualPath, namespace, revision,
301 parseSchemaNodeArgs(ctx, builder);
302 builder.setUnits(parseUnits(ctx));
306 public void exitTypedef_stmt(YangParser.Typedef_stmtContext ctx) {
307 final String actContainer = actualPath.pop();
308 logger.debug("exiting " + actContainer);
312 public void enterType_stmt(YangParser.Type_stmtContext ctx) {
313 final String typeName = stringFromNode(ctx);
314 final int line = ctx.getStart().getLine();
315 final QName typeQName = parseQName(typeName);
317 TypeDefinition<?> type = null;
318 Type_body_stmtsContext typeBody = null;
319 for (int i = 0; i < ctx.getChildCount(); i++) {
320 if (ctx.getChild(i) instanceof Type_body_stmtsContext) {
321 typeBody = (Type_body_stmtsContext) ctx.getChild(i);
326 // if this is base yang type...
327 if (YangTypesConverter.isBaseYangType(typeName)) {
328 if (typeBody == null) {
329 // check for types which must have body
330 checkMissingBody(typeName, moduleName, line);
331 // if there are no constraints, just grab default base yang type
332 type = YangTypesConverter.javaTypeForBaseYangType(actualPath,
333 namespace, revision, typeName);
334 moduleBuilder.setType(type, actualPath);
336 if ("union".equals(typeName)) {
337 moduleBuilder.addUnionType(actualPath, namespace, revision,
339 } else if ("identityref".equals(typeName)) {
340 SchemaPath path = createActualSchemaPath(actualPath,
341 namespace, revision, yangModelPrefix);
342 moduleBuilder.addIdentityrefType(
343 getIdentityrefBase(typeBody), actualPath, path,
346 List<String> typePath = new ArrayList<String>(actualPath);
348 type = parseTypeBody(typeName, typeBody, typePath,
349 namespace, revision, yangModelPrefix);
350 moduleBuilder.setType(type, actualPath);
354 type = parseUnknownTypeBody(typeQName, typeBody);
355 // mark parent node of this type statement as dirty
356 moduleBuilder.addDirtyNode(actualPath);
357 moduleBuilder.setType(type, actualPath);
360 updatePath(typeName);
363 private QName parseQName(String typeName) {
365 if (typeName.contains(":")) {
366 String[] splittedName = typeName.split(":");
367 String prefix = splittedName[0];
368 String name = splittedName[1];
369 if (prefix.equals(yangModelPrefix)) {
370 typeQName = new QName(namespace, revision, prefix, name);
372 typeQName = new QName(null, null, prefix, name);
375 typeQName = new QName(namespace, revision, yangModelPrefix,
382 public void exitType_stmt(YangParser.Type_stmtContext ctx) {
383 final String actContainer = actualPath.pop();
384 logger.debug("exiting " + actContainer);
388 public void enterGrouping_stmt(YangParser.Grouping_stmtContext ctx) {
389 final String groupName = stringFromNode(ctx);
390 QName groupQName = new QName(namespace, revision, yangModelPrefix,
392 GroupingBuilder groupBuilder = moduleBuilder.addGrouping(groupQName,
393 actualPath, ctx.getStart().getLine());
394 updatePath("grouping");
395 updatePath(groupName);
396 parseSchemaNodeArgs(ctx, groupBuilder);
400 public void exitGrouping_stmt(YangParser.Grouping_stmtContext ctx) {
401 String actContainer = actualPath.pop();
402 actContainer += "-" + actualPath.pop();
403 logger.debug("exiting " + actContainer);
407 public void enterContainer_stmt(Container_stmtContext ctx) {
408 final String containerName = stringFromNode(ctx);
409 QName containerQName = new QName(namespace, revision, yangModelPrefix,
411 ContainerSchemaNodeBuilder containerBuilder = moduleBuilder
412 .addContainerNode(containerQName, actualPath, ctx.getStart().getLine());
413 updatePath(containerName);
415 containerBuilder.setPath(createActualSchemaPath(actualPath, namespace,
416 revision, yangModelPrefix));
417 parseSchemaNodeArgs(ctx, containerBuilder);
418 parseConstraints(ctx, containerBuilder.getConstraints());
420 for (int i = 0; i < ctx.getChildCount(); ++i) {
421 final ParseTree childNode = ctx.getChild(i);
422 if (childNode instanceof Presence_stmtContext) {
423 containerBuilder.setPresence(true);
430 public void exitContainer_stmt(Container_stmtContext ctx) {
431 final String actContainer = actualPath.pop();
432 logger.debug("exiting " + actContainer);
436 public void enterLeaf_stmt(Leaf_stmtContext ctx) {
437 final String leafName = stringFromNode(ctx);
438 QName leafQName = new QName(namespace, revision, yangModelPrefix,
440 LeafSchemaNodeBuilder leafBuilder = moduleBuilder.addLeafNode(
441 leafQName, actualPath, ctx.getStart().getLine());
442 updatePath(leafName);
444 leafBuilder.setPath(createActualSchemaPath(actualPath, namespace,
445 revision, yangModelPrefix));
446 parseSchemaNodeArgs(ctx, leafBuilder);
447 parseConstraints(ctx, leafBuilder.getConstraints());
449 String defaultStr = null;
450 String unitsStr = null;
451 for (int i = 0; i < ctx.getChildCount(); i++) {
452 ParseTree child = ctx.getChild(i);
453 if (child instanceof Default_stmtContext) {
454 defaultStr = stringFromNode(child);
455 } else if (child instanceof Units_stmtContext) {
456 unitsStr = stringFromNode(child);
459 leafBuilder.setDefaultStr(defaultStr);
460 leafBuilder.setUnits(unitsStr);
464 public void exitLeaf_stmt(YangParser.Leaf_stmtContext ctx) {
465 final String actLeaf = actualPath.pop();
466 logger.debug("exiting " + actLeaf);
470 public void enterUses_stmt(YangParser.Uses_stmtContext ctx) {
471 final String groupingPathStr = stringFromNode(ctx);
472 moduleBuilder.addUsesNode(groupingPathStr, actualPath, ctx.getStart()
474 updatePath(groupingPathStr);
478 public void exitUses_stmt(YangParser.Uses_stmtContext ctx) {
479 final String actContainer = actualPath.pop();
480 logger.debug("exiting " + actContainer);
484 public void enterRefine_stmt(YangParser.Refine_stmtContext ctx) {
485 String refineString = stringFromNode(ctx);
486 RefineHolder refine = parseRefine(ctx);
487 moduleBuilder.addRefine(refine, actualPath);
488 updatePath(refineString);
492 public void exitRefine_stmt(YangParser.Refine_stmtContext ctx) {
493 final String actContainer = actualPath.pop();
494 logger.debug("exiting " + actContainer);
498 public void enterLeaf_list_stmt(Leaf_list_stmtContext ctx) {
499 final String leafListName = stringFromNode(ctx);
500 QName leafListQName = new QName(namespace, revision, yangModelPrefix,
502 LeafListSchemaNodeBuilder leafListBuilder = moduleBuilder
503 .addLeafListNode(leafListQName, actualPath, ctx.getStart()
505 updatePath(leafListName);
507 parseSchemaNodeArgs(ctx, leafListBuilder);
508 parseConstraints(ctx, leafListBuilder.getConstraints());
510 for (int i = 0; i < ctx.getChildCount(); ++i) {
511 final ParseTree childNode = ctx.getChild(i);
512 if (childNode instanceof Ordered_by_stmtContext) {
513 final Ordered_by_stmtContext orderedBy = (Ordered_by_stmtContext) childNode;
514 final boolean userOrdered = parseUserOrdered(orderedBy);
515 leafListBuilder.setUserOrdered(userOrdered);
522 public void exitLeaf_list_stmt(YangParser.Leaf_list_stmtContext ctx) {
523 final String actContainer = actualPath.pop();
524 logger.debug("exiting " + actContainer);
528 public void enterList_stmt(List_stmtContext ctx) {
529 final String containerName = stringFromNode(ctx);
530 QName containerQName = new QName(namespace, revision, yangModelPrefix,
532 ListSchemaNodeBuilder listBuilder = moduleBuilder.addListNode(
533 containerQName, actualPath, ctx.getStart().getLine());
534 updatePath(containerName);
536 listBuilder.setPath(createActualSchemaPath(actualPath, namespace,
537 revision, yangModelPrefix));
538 parseSchemaNodeArgs(ctx, listBuilder);
539 parseConstraints(ctx, listBuilder.getConstraints());
541 String keyDefinition = "";
542 for (int i = 0; i < ctx.getChildCount(); ++i) {
543 ParseTree childNode = ctx.getChild(i);
544 if (childNode instanceof Ordered_by_stmtContext) {
545 final Ordered_by_stmtContext orderedBy = (Ordered_by_stmtContext) childNode;
546 final boolean userOrdered = parseUserOrdered(orderedBy);
547 listBuilder.setUserOrdered(userOrdered);
548 } else if (childNode instanceof Key_stmtContext) {
549 keyDefinition = stringFromNode(childNode);
550 List<QName> key = createListKey(keyDefinition, namespace,
551 revision, yangModelPrefix);
552 listBuilder.setKeyDefinition(key);
558 public void exitList_stmt(List_stmtContext ctx) {
559 final String actContainer = actualPath.pop();
560 logger.debug("exiting " + actContainer);
564 public void enterAnyxml_stmt(YangParser.Anyxml_stmtContext ctx) {
565 final String anyXmlName = stringFromNode(ctx);
566 QName anyXmlQName = new QName(namespace, revision, yangModelPrefix,
568 AnyXmlBuilder anyXmlBuilder = moduleBuilder.addAnyXml(anyXmlQName,
569 actualPath, ctx.getStart().getLine());
570 updatePath(anyXmlName);
572 anyXmlBuilder.setPath(createActualSchemaPath(actualPath, namespace,
573 revision, yangModelPrefix));
574 parseSchemaNodeArgs(ctx, anyXmlBuilder);
575 parseConstraints(ctx, anyXmlBuilder.getConstraints());
579 public void exitAnyxml_stmt(YangParser.Anyxml_stmtContext ctx) {
580 final String actContainer = actualPath.pop();
581 logger.debug("exiting " + actContainer);
585 public void enterChoice_stmt(YangParser.Choice_stmtContext ctx) {
586 final String choiceName = stringFromNode(ctx);
587 QName choiceQName = new QName(namespace, revision, yangModelPrefix,
589 ChoiceBuilder choiceBuilder = moduleBuilder.addChoice(choiceQName,
590 actualPath, ctx.getStart().getLine());
592 updatePath(choiceName);
593 choiceBuilder.setPath(createActualSchemaPath(actualPath, namespace,
594 revision, yangModelPrefix));
595 parseSchemaNodeArgs(ctx, choiceBuilder);
596 parseConstraints(ctx, choiceBuilder.getConstraints());
598 // set 'default' case
599 for (int i = 0; i < ctx.getChildCount(); i++) {
600 ParseTree child = ctx.getChild(i);
601 if (child instanceof Default_stmtContext) {
602 String defaultCase = stringFromNode(child);
603 choiceBuilder.setDefaultCase(defaultCase);
610 public void exitChoice_stmt(YangParser.Choice_stmtContext ctx) {
611 final String actContainer = actualPath.pop();
612 logger.debug("exiting " + actContainer);
616 public void enterCase_stmt(YangParser.Case_stmtContext ctx) {
617 final String caseName = stringFromNode(ctx);
618 QName choiceQName = new QName(namespace, revision, yangModelPrefix,
620 ChoiceCaseBuilder caseBuilder = moduleBuilder.addCase(choiceQName,
621 actualPath, ctx.getStart().getLine());
623 updatePath(caseName);
624 caseBuilder.setPath(createActualSchemaPath(actualPath, namespace,
625 revision, yangModelPrefix));
626 parseSchemaNodeArgs(ctx, caseBuilder);
627 parseConstraints(ctx, caseBuilder.getConstraints());
631 public void exitCase_stmt(YangParser.Case_stmtContext ctx) {
632 final String actContainer = actualPath.pop();
633 logger.debug("exiting " + actContainer);
637 public void enterNotification_stmt(YangParser.Notification_stmtContext ctx) {
638 final String notificationName = stringFromNode(ctx);
639 QName notificationQName = new QName(namespace, revision,
640 yangModelPrefix, notificationName);
641 NotificationBuilder notificationBuilder = moduleBuilder
642 .addNotification(notificationQName, actualPath, ctx.getStart()
644 updatePath(notificationName);
646 notificationBuilder.setPath(createActualSchemaPath(actualPath,
647 namespace, revision, yangModelPrefix));
648 parseSchemaNodeArgs(ctx, notificationBuilder);
652 public void exitNotification_stmt(YangParser.Notification_stmtContext ctx) {
653 final String actContainer = actualPath.pop();
654 logger.debug("exiting " + actContainer);
659 public void enterIdentifier_stmt(YangParser.Identifier_stmtContext ctx) {
660 final String nodeParameter = stringFromNode(ctx);
661 QName nodeType = null;
663 final String nodeTypeStr = ctx.getChild(0).getText();
664 final String[] splittedElement = nodeTypeStr.split(":");
665 if (splittedElement.length == 1) {
666 nodeType = new QName(null, null, yangModelPrefix,
669 nodeType = new QName(null, null, splittedElement[0],
674 if (nodeParameter != null) {
675 String[] splittedName = nodeParameter.split(":");
676 if (splittedName.length == 2) {
677 qname = new QName(null, null, splittedName[0], splittedName[1]);
679 qname = new QName(namespace, revision, yangModelPrefix,
683 qname = new QName(namespace, revision, yangModelPrefix,
687 UnknownSchemaNodeBuilder builder = moduleBuilder.addUnknownSchemaNode(
688 qname, actualPath, ctx.getStart().getLine());
689 builder.setNodeType(nodeType);
690 builder.setNodeParameter(nodeParameter);
691 updatePath(nodeParameter);
692 builder.setPath(createActualSchemaPath(actualPath, namespace, revision,
694 parseSchemaNodeArgs(ctx, builder);
698 public void exitIdentifier_stmt(YangParser.Identifier_stmtContext ctx) {
699 final String actContainer = actualPath.pop();
700 logger.debug("exiting " + actContainer);
704 public void enterRpc_stmt(YangParser.Rpc_stmtContext ctx) {
705 final String rpcName = stringFromNode(ctx);
706 QName rpcQName = new QName(namespace, revision, yangModelPrefix,
708 RpcDefinitionBuilder rpcBuilder = moduleBuilder.addRpc(rpcQName,
709 actualPath, ctx.getStart().getLine());
712 rpcBuilder.setPath(createActualSchemaPath(actualPath, namespace,
713 revision, yangModelPrefix));
714 parseSchemaNodeArgs(ctx, rpcBuilder);
718 public void exitRpc_stmt(YangParser.Rpc_stmtContext ctx) {
719 final String actContainer = actualPath.pop();
720 logger.debug("exiting " + actContainer);
724 public void enterInput_stmt(YangParser.Input_stmtContext ctx) {
729 public void exitInput_stmt(YangParser.Input_stmtContext ctx) {
730 final String actContainer = actualPath.pop();
731 logger.debug("exiting " + actContainer);
735 public void enterOutput_stmt(YangParser.Output_stmtContext ctx) {
736 updatePath("output");
740 public void exitOutput_stmt(YangParser.Output_stmtContext ctx) {
741 final String actContainer = actualPath.pop();
742 logger.debug("exiting " + actContainer);
746 public void enterFeature_stmt(YangParser.Feature_stmtContext ctx) {
747 final String featureName = stringFromNode(ctx);
748 QName featureQName = new QName(namespace, revision, yangModelPrefix,
750 FeatureBuilder featureBuilder = moduleBuilder.addFeature(featureQName,
751 actualPath, ctx.getStart().getLine());
752 updatePath(featureName);
754 featureBuilder.setPath(createActualSchemaPath(actualPath, namespace,
755 revision, yangModelPrefix));
756 parseSchemaNodeArgs(ctx, featureBuilder);
760 public void exitFeature_stmt(YangParser.Feature_stmtContext ctx) {
761 final String actContainer = actualPath.pop();
762 logger.debug("exiting " + actContainer);
766 public void enterDeviation_stmt(YangParser.Deviation_stmtContext ctx) {
767 final String targetPath = stringFromNode(ctx);
768 String reference = null;
769 String deviate = null;
770 DeviationBuilder builder = moduleBuilder.addDeviation(targetPath,
771 actualPath, ctx.getStart().getLine());
772 updatePath(targetPath);
774 for (int i = 0; i < ctx.getChildCount(); i++) {
775 ParseTree child = ctx.getChild(i);
776 if (child instanceof Reference_stmtContext) {
777 reference = stringFromNode(child);
778 } else if (child instanceof Deviate_not_supported_stmtContext) {
779 deviate = stringFromNode(child);
780 } else if (child instanceof Deviate_add_stmtContext) {
781 deviate = stringFromNode(child);
782 } else if (child instanceof Deviate_replace_stmtContext) {
783 deviate = stringFromNode(child);
784 } else if (child instanceof Deviate_delete_stmtContext) {
785 deviate = stringFromNode(child);
788 builder.setReference(reference);
789 builder.setDeviate(deviate);
793 public void exitDeviation_stmt(YangParser.Deviation_stmtContext ctx) {
794 final String actContainer = actualPath.pop();
795 logger.debug("exiting " + actContainer);
799 public void enterConfig_stmt(YangParser.Config_stmtContext ctx) {
800 boolean configuration = parseConfig(ctx);
801 moduleBuilder.addConfiguration(configuration, actualPath);
805 public void enterIdentity_stmt(YangParser.Identity_stmtContext ctx) {
806 final String identityName = stringFromNode(ctx);
807 final QName identityQName = new QName(namespace, revision,
808 yangModelPrefix, identityName);
809 IdentitySchemaNodeBuilder builder = moduleBuilder.addIdentity(
810 identityQName, actualPath, ctx.getStart().getLine());
811 updatePath(identityName);
813 builder.setPath(createActualSchemaPath(actualPath, namespace, revision,
815 parseSchemaNodeArgs(ctx, builder);
817 for (int i = 0; i < ctx.getChildCount(); i++) {
818 ParseTree child = ctx.getChild(i);
819 if (child instanceof Base_stmtContext) {
820 String baseIdentityName = stringFromNode(child);
821 builder.setBaseIdentityName(baseIdentityName);
827 public void exitIdentity_stmt(YangParser.Identity_stmtContext ctx) {
828 final String actContainer = actualPath.pop();
829 logger.debug("exiting " + actContainer);
832 public ModuleBuilder getModuleBuilder() {
833 return moduleBuilder;
836 private void updatePath(String containerName) {
837 actualPath.push(containerName);