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.api.TypeDefinitionBuilder;
62 import org.opendaylight.controller.yang.parser.builder.api.UsesNodeBuilder;
63 import org.opendaylight.controller.yang.parser.builder.impl.AnyXmlBuilder;
64 import org.opendaylight.controller.yang.parser.builder.impl.ChoiceBuilder;
65 import org.opendaylight.controller.yang.parser.builder.impl.ChoiceCaseBuilder;
66 import org.opendaylight.controller.yang.parser.builder.impl.ContainerSchemaNodeBuilder;
67 import org.opendaylight.controller.yang.parser.builder.impl.DeviationBuilder;
68 import org.opendaylight.controller.yang.parser.builder.impl.ExtensionBuilder;
69 import org.opendaylight.controller.yang.parser.builder.impl.FeatureBuilder;
70 import org.opendaylight.controller.yang.parser.builder.impl.IdentitySchemaNodeBuilder;
71 import org.opendaylight.controller.yang.parser.builder.impl.LeafListSchemaNodeBuilder;
72 import org.opendaylight.controller.yang.parser.builder.impl.LeafSchemaNodeBuilder;
73 import org.opendaylight.controller.yang.parser.builder.impl.ListSchemaNodeBuilder;
74 import org.opendaylight.controller.yang.parser.builder.impl.ModuleBuilder;
75 import org.opendaylight.controller.yang.parser.builder.impl.NotificationBuilder;
76 import org.opendaylight.controller.yang.parser.builder.impl.RpcDefinitionBuilder;
77 import org.opendaylight.controller.yang.parser.builder.impl.UnionTypeBuilder;
78 import org.opendaylight.controller.yang.parser.builder.impl.UnknownSchemaNodeBuilder;
79 import org.opendaylight.controller.yang.parser.util.RefineHolder;
80 import org.slf4j.Logger;
81 import org.slf4j.LoggerFactory;
83 public final class YangParserListenerImpl extends YangParserBaseListener {
84 private static final Logger logger = LoggerFactory.getLogger(YangParserListenerImpl.class);
86 private ModuleBuilder moduleBuilder;
87 private String moduleName;
88 private URI namespace;
89 private String yangModelPrefix;
90 private Date revision = new Date(0L);
92 public final static DateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
93 private final Stack<String> actualPath = new Stack<String>();
96 public void enterModule_stmt(YangParser.Module_stmtContext ctx) {
97 moduleName = stringFromNode(ctx);
98 actualPath.push(moduleName);
99 moduleBuilder = new ModuleBuilder(moduleName);
101 String description = null;
102 String reference = null;
104 for (int i = 0; i < ctx.getChildCount(); i++) {
105 ParseTree child = ctx.getChild(i);
106 if (child instanceof Description_stmtContext) {
107 description = stringFromNode(child);
108 } else if (child instanceof Reference_stmtContext) {
109 reference = stringFromNode(child);
111 if (description != null && reference != null) {
116 moduleBuilder.setDescription(description);
117 moduleBuilder.setReference(reference);
121 public void exitModule_stmt(YangParser.Module_stmtContext ctx) {
122 final String moduleName = actualPath.pop();
123 logger.debug("Exiting module " + moduleName);
127 public void enterModule_header_stmts(final Module_header_stmtsContext ctx) {
128 super.enterModule_header_stmts(ctx);
130 String yangVersion = null;
131 for (int i = 0; i < ctx.getChildCount(); ++i) {
132 final ParseTree treeNode = ctx.getChild(i);
133 if (treeNode instanceof Namespace_stmtContext) {
134 final String namespaceStr = stringFromNode(treeNode);
135 namespace = URI.create(namespaceStr);
136 moduleBuilder.setNamespace(namespace);
137 } else if (treeNode instanceof Prefix_stmtContext) {
138 yangModelPrefix = stringFromNode(treeNode);
139 moduleBuilder.setPrefix(yangModelPrefix);
140 } else if (treeNode instanceof Yang_version_stmtContext) {
141 yangVersion = stringFromNode(treeNode);
145 if (yangVersion == null) {
148 moduleBuilder.setYangVersion(yangVersion);
152 public void enterMeta_stmts(YangParser.Meta_stmtsContext ctx) {
153 for (int i = 0; i < ctx.getChildCount(); i++) {
154 ParseTree child = ctx.getChild(i);
155 if (child instanceof Organization_stmtContext) {
156 final String organization = stringFromNode(child);
157 moduleBuilder.setOrganization(organization);
158 } else if (child instanceof Contact_stmtContext) {
159 final String contact = stringFromNode(child);
160 moduleBuilder.setContact(contact);
161 } else if (child instanceof Description_stmtContext) {
162 final String description = stringFromNode(child);
163 moduleBuilder.setDescription(description);
164 } else if (child instanceof Reference_stmtContext) {
165 final String reference = stringFromNode(child);
166 moduleBuilder.setReference(reference);
172 public void exitSubmodule_header_stmts(YangParser.Submodule_header_stmtsContext ctx) {
173 final String submodule = actualPath.pop();
174 logger.debug("exiting submodule " + submodule);
178 public void enterRevision_stmts(Revision_stmtsContext ctx) {
180 for (int i = 0; i < ctx.getChildCount(); ++i) {
181 final ParseTree treeNode = ctx.getChild(i);
182 if (treeNode instanceof Revision_stmtContext) {
183 updateRevisionForRevisionStatement(treeNode);
189 private void updateRevisionForRevisionStatement(final ParseTree treeNode) {
190 final String revisionDateStr = stringFromNode(treeNode);
192 final Date revision = simpleDateFormat.parse(revisionDateStr);
193 if ((revision != null) && (this.revision.compareTo(revision) < 0)) {
194 this.revision = revision;
195 moduleBuilder.setRevision(this.revision);
196 for (int i = 0; i < treeNode.getChildCount(); ++i) {
197 ParseTree child = treeNode.getChild(i);
198 if (child instanceof Reference_stmtContext) {
199 moduleBuilder.setReference(stringFromNode(child));
203 } catch (ParseException e) {
204 final String message = "Failed to parse revision string: " + revisionDateStr;
205 logger.warn(message);
210 public void enterImport_stmt(Import_stmtContext ctx) {
211 final String importName = stringFromNode(ctx);
212 String importPrefix = null;
213 Date importRevision = null;
215 for (int i = 0; i < ctx.getChildCount(); ++i) {
216 final ParseTree treeNode = ctx.getChild(i);
217 if (treeNode instanceof Prefix_stmtContext) {
218 importPrefix = stringFromNode(treeNode);
220 if (treeNode instanceof Revision_date_stmtContext) {
221 String importRevisionStr = stringFromNode(treeNode);
223 importRevision = simpleDateFormat.parse(importRevisionStr);
224 } catch (ParseException e) {
225 logger.warn("Failed to parse import revision-date: " + importRevisionStr);
229 moduleBuilder.addModuleImport(importName, importRevision, importPrefix);
233 public void enterAugment_stmt(YangParser.Augment_stmtContext ctx) {
234 final String augmentPath = stringFromNode(ctx);
235 AugmentationSchemaBuilder builder = moduleBuilder.addAugment(augmentPath, actualPath, ctx.getStart().getLine());
236 moduleBuilder.enterNode(builder);
237 updatePath(augmentPath);
239 for (int i = 0; i < ctx.getChildCount(); i++) {
240 ParseTree child = ctx.getChild(i);
241 if (child instanceof Description_stmtContext) {
242 String desc = stringFromNode(child);
243 builder.setDescription(desc);
244 } else if (child instanceof Reference_stmtContext) {
245 String ref = stringFromNode(child);
246 builder.setReference(ref);
247 } else if (child instanceof Status_stmtContext) {
248 Status status = parseStatus((Status_stmtContext) child);
249 builder.setStatus(status);
250 } else if (child instanceof When_stmtContext) {
251 String when = stringFromNode(child);
252 builder.addWhenCondition(when);
258 public void exitAugment_stmt(YangParser.Augment_stmtContext ctx) {
259 final String augment = actualPath.pop();
260 logger.debug("exiting augment " + augment);
261 moduleBuilder.exitNode();
265 public void enterExtension_stmt(YangParser.Extension_stmtContext ctx) {
266 final String extName = stringFromNode(ctx);
267 QName qname = new QName(namespace, revision, yangModelPrefix, extName);
268 ExtensionBuilder builder = moduleBuilder.addExtension(qname, ctx.getStart().getLine());
269 parseSchemaNodeArgs(ctx, builder);
271 String argument = null;
273 for (int i = 0; i < ctx.getChildCount(); i++) {
274 ParseTree child = ctx.getChild(i);
275 if (child instanceof Argument_stmtContext) {
276 argument = stringFromNode(child);
277 yin = parseYinValue((Argument_stmtContext) child);
281 builder.setArgument(argument);
282 builder.setYinElement(yin);
286 public void enterTypedef_stmt(YangParser.Typedef_stmtContext ctx) {
287 final String typedefName = stringFromNode(ctx);
288 QName typedefQName = new QName(namespace, revision, yangModelPrefix, typedefName);
289 TypeDefinitionBuilder builder = moduleBuilder.addTypedef(typedefQName, actualPath, ctx.getStart().getLine());
290 moduleBuilder.enterNode(builder);
291 updatePath(typedefName);
293 builder.setPath(createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix));
294 parseSchemaNodeArgs(ctx, builder);
295 builder.setUnits(parseUnits(ctx));
299 public void exitTypedef_stmt(YangParser.Typedef_stmtContext ctx) {
300 final String actContainer = actualPath.pop();
301 logger.debug("exiting " + actContainer);
302 moduleBuilder.exitNode();
306 public void enterType_stmt(YangParser.Type_stmtContext ctx) {
307 final String typeName = stringFromNode(ctx);
308 final int line = ctx.getStart().getLine();
309 final QName typeQName = parseQName(typeName);
311 TypeDefinition<?> type = null;
312 Type_body_stmtsContext typeBody = null;
313 for (int i = 0; i < ctx.getChildCount(); i++) {
314 if (ctx.getChild(i) instanceof Type_body_stmtsContext) {
315 typeBody = (Type_body_stmtsContext) ctx.getChild(i);
320 // if this is base yang type...
321 if (YangTypesConverter.isBaseYangType(typeName)) {
322 if (typeBody == null) {
323 // check for types which must have body
324 checkMissingBody(typeName, moduleName, line);
325 // if there are no constraints, just grab default base yang type
326 type = YangTypesConverter.javaTypeForBaseYangType(actualPath, namespace, revision, typeName);
327 moduleBuilder.setType(type, actualPath);
329 if ("union".equals(typeName)) {
330 List<String> typePath = new ArrayList<String>(actualPath);
331 typePath.add(typeName);
332 SchemaPath p = createActualSchemaPath(typePath, namespace, revision, yangModelPrefix);
333 UnionTypeBuilder unionBuilder = moduleBuilder.addUnionType(actualPath, namespace, revision, line);
334 moduleBuilder.enterNode(unionBuilder);
335 unionBuilder.setPath(p);
336 } else if ("identityref".equals(typeName)) {
337 SchemaPath path = createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix);
338 moduleBuilder.addIdentityrefType(getIdentityrefBase(typeBody), actualPath, path, line);
340 type = parseTypeBody(moduleName, typeName, typeBody, actualPath, namespace, revision,
341 yangModelPrefix, moduleBuilder.getActualNode());
342 moduleBuilder.setType(type, actualPath);
346 type = parseUnknownTypeBody(typeQName, typeBody, actualPath, namespace, revision, yangModelPrefix,
347 moduleBuilder.getActualNode(), moduleBuilder);
348 // mark parent node of this type statement as dirty
349 moduleBuilder.addDirtyNode(actualPath);
350 moduleBuilder.setType(type, actualPath);
353 updatePath(typeName);
356 private QName parseQName(String typeName) {
358 if (typeName.contains(":")) {
359 String[] splittedName = typeName.split(":");
360 String prefix = splittedName[0];
361 String name = splittedName[1];
362 if (prefix.equals(yangModelPrefix)) {
363 typeQName = new QName(namespace, revision, prefix, name);
365 typeQName = new QName(null, null, prefix, name);
368 typeQName = new QName(namespace, revision, yangModelPrefix, typeName);
374 public void exitType_stmt(YangParser.Type_stmtContext ctx) {
375 final String actContainer = actualPath.pop();
376 logger.debug("exiting " + actContainer);
378 final String typeName = stringFromNode(ctx);
379 if ("union".equals(typeName)) {
380 moduleBuilder.exitNode();
385 public void enterGrouping_stmt(YangParser.Grouping_stmtContext ctx) {
386 final String groupName = stringFromNode(ctx);
387 QName groupQName = new QName(namespace, revision, yangModelPrefix, groupName);
388 GroupingBuilder builder = moduleBuilder.addGrouping(groupQName, actualPath, ctx.getStart().getLine());
389 moduleBuilder.enterNode(builder);
390 updatePath(groupName);
391 builder.setPath(createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix));
392 parseSchemaNodeArgs(ctx, builder);
396 public void exitGrouping_stmt(YangParser.Grouping_stmtContext ctx) {
397 String actContainer = actualPath.pop();
398 logger.debug("exiting " + actContainer);
399 moduleBuilder.exitNode();
403 public void enterContainer_stmt(Container_stmtContext ctx) {
404 final String containerName = stringFromNode(ctx);
405 QName containerQName = new QName(namespace, revision, yangModelPrefix, containerName);
406 ContainerSchemaNodeBuilder builder = moduleBuilder.addContainerNode(containerQName, actualPath, ctx.getStart()
408 moduleBuilder.enterNode(builder);
409 updatePath(containerName);
411 builder.setPath(createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix));
412 parseSchemaNodeArgs(ctx, builder);
413 parseConstraints(ctx, builder.getConstraints());
415 for (int i = 0; i < ctx.getChildCount(); ++i) {
416 final ParseTree childNode = ctx.getChild(i);
417 if (childNode instanceof Presence_stmtContext) {
418 builder.setPresence(true);
425 public void exitContainer_stmt(Container_stmtContext ctx) {
426 final String actContainer = actualPath.pop();
427 logger.debug("exiting " + actContainer);
428 moduleBuilder.exitNode();
432 public void enterLeaf_stmt(Leaf_stmtContext ctx) {
433 final String leafName = stringFromNode(ctx);
434 QName leafQName = new QName(namespace, revision, yangModelPrefix, leafName);
435 LeafSchemaNodeBuilder builder = moduleBuilder.addLeafNode(leafQName, actualPath, ctx.getStart().getLine());
436 moduleBuilder.enterNode(builder);
437 updatePath(leafName);
439 builder.setPath(createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix));
440 parseSchemaNodeArgs(ctx, builder);
441 parseConstraints(ctx, builder.getConstraints());
443 String defaultStr = null;
444 String unitsStr = null;
445 for (int i = 0; i < ctx.getChildCount(); i++) {
446 ParseTree child = ctx.getChild(i);
447 if (child instanceof Default_stmtContext) {
448 defaultStr = stringFromNode(child);
449 } else if (child instanceof Units_stmtContext) {
450 unitsStr = stringFromNode(child);
453 builder.setDefaultStr(defaultStr);
454 builder.setUnits(unitsStr);
458 public void exitLeaf_stmt(YangParser.Leaf_stmtContext ctx) {
459 final String actLeaf = actualPath.pop();
460 logger.debug("exiting " + actLeaf);
461 moduleBuilder.exitNode();
465 public void enterUses_stmt(YangParser.Uses_stmtContext ctx) {
466 final String groupingPathStr = stringFromNode(ctx);
467 UsesNodeBuilder builder = moduleBuilder.addUsesNode(groupingPathStr, actualPath, ctx.getStart().getLine());
469 moduleBuilder.enterNode(builder);
470 updatePath(groupingPathStr);
471 builder.setPath(createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix));
475 public void exitUses_stmt(YangParser.Uses_stmtContext ctx) {
476 final String actContainer = actualPath.pop();
477 logger.debug("exiting " + actContainer);
478 moduleBuilder.exitNode();
482 public void enterRefine_stmt(YangParser.Refine_stmtContext ctx) {
483 String refineString = stringFromNode(ctx);
484 RefineHolder refine = parseRefine(ctx);
485 moduleBuilder.addRefine(refine, actualPath);
486 moduleBuilder.enterNode(refine);
487 updatePath(refineString);
491 public void exitRefine_stmt(YangParser.Refine_stmtContext ctx) {
492 final String actContainer = actualPath.pop();
493 logger.debug("exiting " + actContainer);
494 moduleBuilder.exitNode();
498 public void enterLeaf_list_stmt(Leaf_list_stmtContext ctx) {
499 final String leafListName = stringFromNode(ctx);
500 QName leafListQName = new QName(namespace, revision, yangModelPrefix, leafListName);
501 LeafListSchemaNodeBuilder builder = moduleBuilder.addLeafListNode(leafListQName, actualPath, ctx.getStart()
503 moduleBuilder.enterNode(builder);
504 updatePath(leafListName);
506 builder.setPath(createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix));
507 parseSchemaNodeArgs(ctx, builder);
508 parseConstraints(ctx, builder.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 builder.setUserOrdered(userOrdered);
522 public void exitLeaf_list_stmt(YangParser.Leaf_list_stmtContext ctx) {
523 final String actContainer = actualPath.pop();
524 logger.debug("exiting " + actContainer);
525 moduleBuilder.exitNode();
529 public void enterList_stmt(List_stmtContext ctx) {
530 final String containerName = stringFromNode(ctx);
531 QName containerQName = new QName(namespace, revision, yangModelPrefix, containerName);
532 ListSchemaNodeBuilder builder = moduleBuilder.addListNode(containerQName, actualPath, ctx.getStart().getLine());
533 moduleBuilder.enterNode(builder);
534 updatePath(containerName);
536 builder.setPath(createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix));
537 parseSchemaNodeArgs(ctx, builder);
538 parseConstraints(ctx, builder.getConstraints());
540 String keyDefinition = "";
541 for (int i = 0; i < ctx.getChildCount(); ++i) {
542 ParseTree childNode = ctx.getChild(i);
543 if (childNode instanceof Ordered_by_stmtContext) {
544 final Ordered_by_stmtContext orderedBy = (Ordered_by_stmtContext) childNode;
545 final boolean userOrdered = parseUserOrdered(orderedBy);
546 builder.setUserOrdered(userOrdered);
547 } else if (childNode instanceof Key_stmtContext) {
548 keyDefinition = stringFromNode(childNode);
549 List<QName> key = createListKey(keyDefinition, namespace, revision, yangModelPrefix);
550 builder.setKeyDefinition(key);
556 public void exitList_stmt(List_stmtContext ctx) {
557 final String actContainer = actualPath.pop();
558 logger.debug("exiting " + actContainer);
559 moduleBuilder.exitNode();
563 public void enterAnyxml_stmt(YangParser.Anyxml_stmtContext ctx) {
564 final String anyXmlName = stringFromNode(ctx);
565 QName anyXmlQName = new QName(namespace, revision, yangModelPrefix, anyXmlName);
566 AnyXmlBuilder builder = moduleBuilder.addAnyXml(anyXmlQName, actualPath, ctx.getStart().getLine());
567 moduleBuilder.enterNode(builder);
568 updatePath(anyXmlName);
570 builder.setPath(createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix));
571 parseSchemaNodeArgs(ctx, builder);
572 parseConstraints(ctx, builder.getConstraints());
576 public void exitAnyxml_stmt(YangParser.Anyxml_stmtContext ctx) {
577 final String actContainer = actualPath.pop();
578 logger.debug("exiting " + actContainer);
579 moduleBuilder.exitNode();
583 public void enterChoice_stmt(YangParser.Choice_stmtContext ctx) {
584 final String choiceName = stringFromNode(ctx);
585 QName choiceQName = new QName(namespace, revision, yangModelPrefix, choiceName);
586 ChoiceBuilder builder = moduleBuilder.addChoice(choiceQName, actualPath, ctx.getStart().getLine());
587 moduleBuilder.enterNode(builder);
589 updatePath(choiceName);
590 builder.setPath(createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix));
591 parseSchemaNodeArgs(ctx, builder);
592 parseConstraints(ctx, builder.getConstraints());
594 // set 'default' case
595 for (int i = 0; i < ctx.getChildCount(); i++) {
596 ParseTree child = ctx.getChild(i);
597 if (child instanceof Default_stmtContext) {
598 String defaultCase = stringFromNode(child);
599 builder.setDefaultCase(defaultCase);
606 public void exitChoice_stmt(YangParser.Choice_stmtContext ctx) {
607 final String actContainer = actualPath.pop();
608 logger.debug("exiting " + actContainer);
609 moduleBuilder.exitNode();
613 public void enterCase_stmt(YangParser.Case_stmtContext ctx) {
614 final String caseName = stringFromNode(ctx);
615 QName choiceQName = new QName(namespace, revision, yangModelPrefix, caseName);
616 ChoiceCaseBuilder builder = moduleBuilder.addCase(choiceQName, actualPath, ctx.getStart().getLine());
617 moduleBuilder.enterNode(builder);
619 updatePath(caseName);
620 builder.setPath(createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix));
621 parseSchemaNodeArgs(ctx, builder);
622 parseConstraints(ctx, builder.getConstraints());
626 public void exitCase_stmt(YangParser.Case_stmtContext ctx) {
627 final String actContainer = actualPath.pop();
628 logger.debug("exiting " + actContainer);
629 moduleBuilder.exitNode();
633 public void enterNotification_stmt(YangParser.Notification_stmtContext ctx) {
634 final String notificationName = stringFromNode(ctx);
635 QName notificationQName = new QName(namespace, revision, yangModelPrefix, notificationName);
636 NotificationBuilder builder = moduleBuilder.addNotification(notificationQName, actualPath, ctx.getStart()
638 moduleBuilder.enterNode(builder);
639 updatePath(notificationName);
641 builder.setPath(createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix));
642 parseSchemaNodeArgs(ctx, builder);
646 public void exitNotification_stmt(YangParser.Notification_stmtContext ctx) {
647 final String actContainer = actualPath.pop();
648 logger.debug("exiting " + actContainer);
649 moduleBuilder.exitNode();
654 public void enterIdentifier_stmt(YangParser.Identifier_stmtContext ctx) {
655 final String nodeParameter = stringFromNode(ctx);
656 QName nodeType = null;
658 final String nodeTypeStr = ctx.getChild(0).getText();
659 final String[] splittedElement = nodeTypeStr.split(":");
660 if (splittedElement.length == 1) {
661 nodeType = new QName(null, null, yangModelPrefix, splittedElement[0]);
663 nodeType = new QName(null, null, splittedElement[0], splittedElement[1]);
667 if (nodeParameter != null) {
668 String[] splittedName = nodeParameter.split(":");
669 if (splittedName.length == 2) {
670 qname = new QName(null, null, splittedName[0], splittedName[1]);
672 qname = new QName(namespace, revision, yangModelPrefix, splittedName[0]);
675 qname = new QName(namespace, revision, yangModelPrefix, nodeParameter);
678 UnknownSchemaNodeBuilder builder = moduleBuilder.addUnknownSchemaNode(qname, actualPath, ctx.getStart()
680 builder.setNodeType(nodeType);
681 builder.setNodeParameter(nodeParameter);
682 updatePath(nodeParameter);
683 builder.setPath(createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix));
684 parseSchemaNodeArgs(ctx, builder);
685 moduleBuilder.enterNode(builder);
689 public void exitIdentifier_stmt(YangParser.Identifier_stmtContext ctx) {
690 final String actContainer = actualPath.pop();
691 logger.debug("exiting " + actContainer);
692 moduleBuilder.exitNode();
696 public void enterRpc_stmt(YangParser.Rpc_stmtContext ctx) {
697 final String rpcName = stringFromNode(ctx);
698 QName rpcQName = new QName(namespace, revision, yangModelPrefix, rpcName);
699 RpcDefinitionBuilder rpcBuilder = moduleBuilder.addRpc(rpcQName, actualPath, ctx.getStart().getLine());
700 moduleBuilder.enterNode(rpcBuilder);
703 rpcBuilder.setPath(createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix));
704 parseSchemaNodeArgs(ctx, rpcBuilder);
708 public void exitRpc_stmt(YangParser.Rpc_stmtContext ctx) {
709 final String actContainer = actualPath.pop();
710 logger.debug("exiting " + actContainer);
711 moduleBuilder.exitNode();
715 public void enterInput_stmt(YangParser.Input_stmtContext ctx) {
716 final String input = "input";
717 QName rpcQName = new QName(namespace, revision, yangModelPrefix, input);
718 ContainerSchemaNodeBuilder builder = moduleBuilder.addRpcInput(rpcQName, ctx.getStart().getLine());
719 moduleBuilder.enterNode(builder);
722 builder.setPath(createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix));
723 parseSchemaNodeArgs(ctx, builder);
724 parseConstraints(ctx, builder.getConstraints());
728 public void exitInput_stmt(YangParser.Input_stmtContext ctx) {
729 final String actContainer = actualPath.pop();
730 logger.debug("exiting " + actContainer);
731 moduleBuilder.exitNode();
735 public void enterOutput_stmt(YangParser.Output_stmtContext ctx) {
736 final String output = "output";
737 QName rpcQName = new QName(namespace, revision, yangModelPrefix, output);
738 ContainerSchemaNodeBuilder builder = moduleBuilder.addRpcOutput(rpcQName, ctx.getStart().getLine());
739 moduleBuilder.enterNode(builder);
742 builder.setPath(createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix));
743 parseSchemaNodeArgs(ctx, builder);
744 parseConstraints(ctx, builder.getConstraints());
748 public void exitOutput_stmt(YangParser.Output_stmtContext ctx) {
749 final String actContainer = actualPath.pop();
750 logger.debug("exiting " + actContainer);
751 moduleBuilder.exitNode();
755 public void enterFeature_stmt(YangParser.Feature_stmtContext ctx) {
756 final String featureName = stringFromNode(ctx);
757 QName featureQName = new QName(namespace, revision, yangModelPrefix, featureName);
758 FeatureBuilder featureBuilder = moduleBuilder.addFeature(featureQName, actualPath, ctx.getStart().getLine());
759 moduleBuilder.enterNode(featureBuilder);
760 updatePath(featureName);
762 featureBuilder.setPath(createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix));
763 parseSchemaNodeArgs(ctx, featureBuilder);
767 public void exitFeature_stmt(YangParser.Feature_stmtContext ctx) {
768 final String actContainer = actualPath.pop();
769 logger.debug("exiting " + actContainer);
770 moduleBuilder.exitNode();
774 public void enterDeviation_stmt(YangParser.Deviation_stmtContext ctx) {
775 final String targetPath = stringFromNode(ctx);
776 String reference = null;
777 String deviate = null;
778 DeviationBuilder builder = moduleBuilder.addDeviation(targetPath, actualPath, ctx.getStart().getLine());
779 moduleBuilder.enterNode(builder);
780 updatePath(targetPath);
782 for (int i = 0; i < ctx.getChildCount(); i++) {
783 ParseTree child = ctx.getChild(i);
784 if (child instanceof Reference_stmtContext) {
785 reference = stringFromNode(child);
786 } else if (child instanceof Deviate_not_supported_stmtContext) {
787 deviate = stringFromNode(child);
788 } else if (child instanceof Deviate_add_stmtContext) {
789 deviate = stringFromNode(child);
790 } else if (child instanceof Deviate_replace_stmtContext) {
791 deviate = stringFromNode(child);
792 } else if (child instanceof Deviate_delete_stmtContext) {
793 deviate = stringFromNode(child);
796 builder.setReference(reference);
797 builder.setDeviate(deviate);
801 public void exitDeviation_stmt(YangParser.Deviation_stmtContext ctx) {
802 final String actContainer = actualPath.pop();
803 logger.debug("exiting " + actContainer);
804 moduleBuilder.exitNode();
808 public void enterConfig_stmt(YangParser.Config_stmtContext ctx) {
809 boolean configuration = parseConfig(ctx);
810 moduleBuilder.addConfiguration(configuration, actualPath, ctx.getStart().getLine());
814 public void enterIdentity_stmt(YangParser.Identity_stmtContext ctx) {
815 final String identityName = stringFromNode(ctx);
816 final QName identityQName = new QName(namespace, revision, yangModelPrefix, identityName);
817 IdentitySchemaNodeBuilder builder = moduleBuilder.addIdentity(identityQName, actualPath, ctx.getStart()
819 moduleBuilder.enterNode(builder);
820 updatePath(identityName);
822 builder.setPath(createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix));
823 parseSchemaNodeArgs(ctx, builder);
825 for (int i = 0; i < ctx.getChildCount(); i++) {
826 ParseTree child = ctx.getChild(i);
827 if (child instanceof Base_stmtContext) {
828 String baseIdentityName = stringFromNode(child);
829 builder.setBaseIdentityName(baseIdentityName);
835 public void exitIdentity_stmt(YangParser.Identity_stmtContext ctx) {
836 final String actContainer = actualPath.pop();
837 logger.debug("exiting " + actContainer);
838 moduleBuilder.exitNode();
841 public ModuleBuilder getModuleBuilder() {
842 return moduleBuilder;
845 private void updatePath(String containerName) {
846 actualPath.push(containerName);