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.ParserListenerUtils.*;
13 import java.text.DateFormat;
14 import java.text.ParseException;
15 import java.text.SimpleDateFormat;
16 import java.util.Date;
17 import java.util.List;
18 import java.util.Stack;
20 import org.antlr.v4.runtime.tree.ParseTree;
21 import org.opendaylight.controller.antlrv4.code.gen.*;
22 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Argument_stmtContext;
23 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Base_stmtContext;
24 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Contact_stmtContext;
25 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Container_stmtContext;
26 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Default_stmtContext;
27 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Description_stmtContext;
28 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Deviate_add_stmtContext;
29 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Deviate_delete_stmtContext;
30 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Deviate_not_supported_stmtContext;
31 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Deviate_replace_stmtContext;
32 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Import_stmtContext;
33 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Key_stmtContext;
34 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Leaf_list_stmtContext;
35 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Leaf_stmtContext;
36 import org.opendaylight.controller.antlrv4.code.gen.YangParser.List_stmtContext;
37 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Module_header_stmtsContext;
38 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Namespace_stmtContext;
39 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Ordered_by_stmtContext;
40 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Organization_stmtContext;
41 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Prefix_stmtContext;
42 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Presence_stmtContext;
43 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Reference_stmtContext;
44 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Revision_date_stmtContext;
45 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Revision_stmtContext;
46 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Revision_stmtsContext;
47 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Status_stmtContext;
48 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Type_body_stmtsContext;
49 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Units_stmtContext;
50 import org.opendaylight.controller.antlrv4.code.gen.YangParser.When_stmtContext;
51 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Yang_version_stmtContext;
52 import org.opendaylight.controller.yang.common.QName;
53 import org.opendaylight.controller.yang.model.api.SchemaPath;
54 import org.opendaylight.controller.yang.model.api.TypeDefinition;
55 import org.opendaylight.controller.yang.model.util.YangTypesConverter;
56 import org.opendaylight.controller.yang.parser.builder.api.AugmentationSchemaBuilder;
57 import org.opendaylight.controller.yang.parser.builder.api.GroupingBuilder;
58 import org.opendaylight.controller.yang.parser.builder.api.TypeDefinitionBuilder;
59 import org.opendaylight.controller.yang.parser.builder.api.UsesNodeBuilder;
60 import org.opendaylight.controller.yang.parser.builder.impl.AnyXmlBuilder;
61 import org.opendaylight.controller.yang.parser.builder.impl.ChoiceBuilder;
62 import org.opendaylight.controller.yang.parser.builder.impl.ChoiceCaseBuilder;
63 import org.opendaylight.controller.yang.parser.builder.impl.ContainerSchemaNodeBuilder;
64 import org.opendaylight.controller.yang.parser.builder.impl.DeviationBuilder;
65 import org.opendaylight.controller.yang.parser.builder.impl.ExtensionBuilder;
66 import org.opendaylight.controller.yang.parser.builder.impl.FeatureBuilder;
67 import org.opendaylight.controller.yang.parser.builder.impl.IdentitySchemaNodeBuilder;
68 import org.opendaylight.controller.yang.parser.builder.impl.LeafListSchemaNodeBuilder;
69 import org.opendaylight.controller.yang.parser.builder.impl.LeafSchemaNodeBuilder;
70 import org.opendaylight.controller.yang.parser.builder.impl.ListSchemaNodeBuilder;
71 import org.opendaylight.controller.yang.parser.builder.impl.ModuleBuilder;
72 import org.opendaylight.controller.yang.parser.builder.impl.NotificationBuilder;
73 import org.opendaylight.controller.yang.parser.builder.impl.RpcDefinitionBuilder;
74 import org.opendaylight.controller.yang.parser.builder.impl.UnionTypeBuilder;
75 import org.opendaylight.controller.yang.parser.builder.impl.UnknownSchemaNodeBuilder;
76 import org.opendaylight.controller.yang.parser.util.RefineHolder;
77 import org.slf4j.Logger;
78 import org.slf4j.LoggerFactory;
80 public final class YangParserListenerImpl extends YangParserBaseListener {
81 private static final Logger logger = LoggerFactory.getLogger(YangParserListenerImpl.class);
83 private ModuleBuilder moduleBuilder;
84 private String moduleName;
85 private URI namespace;
86 private String yangModelPrefix;
87 private Date revision = new Date(0L);
89 public final static DateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
90 private final Stack<String> actualPath = new Stack<String>();
93 public void enterModule_stmt(YangParser.Module_stmtContext ctx) {
94 moduleName = stringFromNode(ctx);
95 logger.debug("enter module " + moduleName);
96 actualPath.push(moduleName);
97 moduleBuilder = new ModuleBuilder(moduleName);
99 String description = null;
100 String reference = null;
102 for (int i = 0; i < ctx.getChildCount(); i++) {
103 ParseTree child = ctx.getChild(i);
104 if (child instanceof Description_stmtContext) {
105 description = stringFromNode(child);
106 } else if (child instanceof Reference_stmtContext) {
107 reference = stringFromNode(child);
109 if (description != null && reference != null) {
114 moduleBuilder.setDescription(description);
115 moduleBuilder.setReference(reference);
119 public void exitModule_stmt(YangParser.Module_stmtContext ctx) {
120 exitLog("module", actualPath.pop());
124 public void enterModule_header_stmts(Module_header_stmtsContext ctx) {
125 enterLog("module_header", "", ctx.getStart().getLine());
126 String yangVersion = null;
127 for (int i = 0; i < ctx.getChildCount(); ++i) {
128 final ParseTree treeNode = ctx.getChild(i);
129 if (treeNode instanceof Namespace_stmtContext) {
130 final String namespaceStr = stringFromNode(treeNode);
131 namespace = URI.create(namespaceStr);
132 moduleBuilder.setNamespace(namespace);
133 setLog("namespace", namespaceStr);
134 } else if (treeNode instanceof Prefix_stmtContext) {
135 yangModelPrefix = stringFromNode(treeNode);
136 moduleBuilder.setPrefix(yangModelPrefix);
137 setLog("prefix", yangModelPrefix);
138 } else if (treeNode instanceof Yang_version_stmtContext) {
139 yangVersion = stringFromNode(treeNode);
140 setLog("yang-version", yangVersion);
144 if (yangVersion == null) {
147 moduleBuilder.setYangVersion(yangVersion);
151 public void exitModule_header_stmts(Module_header_stmtsContext ctx) {
152 exitLog("module_header", "");
156 public void enterMeta_stmts(YangParser.Meta_stmtsContext ctx) {
157 enterLog("meta_stmt", "", ctx.getStart().getLine());
158 for (int i = 0; i < ctx.getChildCount(); i++) {
159 ParseTree child = ctx.getChild(i);
160 if (child instanceof Organization_stmtContext) {
161 final String organization = stringFromNode(child);
162 moduleBuilder.setOrganization(organization);
163 setLog("organization", organization);
164 } else if (child instanceof Contact_stmtContext) {
165 final String contact = stringFromNode(child);
166 moduleBuilder.setContact(contact);
167 setLog("contact", contact);
168 } else if (child instanceof Description_stmtContext) {
169 final String description = stringFromNode(child);
170 moduleBuilder.setDescription(description);
171 setLog("description", description);
172 } else if (child instanceof Reference_stmtContext) {
173 final String reference = stringFromNode(child);
174 moduleBuilder.setReference(reference);
175 setLog("reference", reference);
181 public void exitMeta_stmts(YangParser.Meta_stmtsContext ctx) {
182 exitLog("meta_stmt", "");
186 public void enterRevision_stmts(Revision_stmtsContext ctx) {
187 enterLog("revisions", "", ctx.getStart().getLine());
188 for (int i = 0; i < ctx.getChildCount(); ++i) {
189 final ParseTree treeNode = ctx.getChild(i);
190 if (treeNode instanceof Revision_stmtContext) {
191 updateRevisionForRevisionStatement(treeNode);
197 public void exitRevision_stmts(Revision_stmtsContext ctx) {
198 exitLog("revisions", "");
201 private void updateRevisionForRevisionStatement(final ParseTree treeNode) {
202 final String revisionDateStr = stringFromNode(treeNode);
204 final Date revision = simpleDateFormat.parse(revisionDateStr);
205 if ((revision != null) && (this.revision.compareTo(revision) < 0)) {
206 this.revision = revision;
207 moduleBuilder.setRevision(this.revision);
208 setLog("revision", this.revision.toString());
209 for (int i = 0; i < treeNode.getChildCount(); ++i) {
210 ParseTree child = treeNode.getChild(i);
211 if (child instanceof Reference_stmtContext) {
212 moduleBuilder.setReference(stringFromNode(child));
216 } catch (ParseException e) {
217 final String message = "Failed to parse revision string: " + revisionDateStr;
218 logger.warn(message);
223 public void enterImport_stmt(Import_stmtContext ctx) {
224 final int line = ctx.getStart().getLine();
225 final String importName = stringFromNode(ctx);
226 enterLog("import", importName, line);
228 String importPrefix = null;
229 Date importRevision = null;
231 for (int i = 0; i < ctx.getChildCount(); ++i) {
232 final ParseTree treeNode = ctx.getChild(i);
233 if (treeNode instanceof Prefix_stmtContext) {
234 importPrefix = stringFromNode(treeNode);
236 if (treeNode instanceof Revision_date_stmtContext) {
237 String importRevisionStr = stringFromNode(treeNode);
239 importRevision = simpleDateFormat.parse(importRevisionStr);
240 } catch (ParseException e) {
241 logger.warn("Failed to parse import revision-date at line " + line + ": " + importRevisionStr);
245 moduleBuilder.addModuleImport(importName, importRevision, importPrefix);
246 setLog("import", "(" + importName + "; " + importRevision + "; " + importPrefix + ")");
250 public void exitImport_stmt(Import_stmtContext ctx) {
251 exitLog("import", "");
255 public void enterAugment_stmt(YangParser.Augment_stmtContext ctx) {
256 final int line = ctx.getStart().getLine();
257 final String augmentPath = stringFromNode(ctx);
258 enterLog("augment", augmentPath, line);
260 AugmentationSchemaBuilder builder = moduleBuilder.addAugment(line, augmentPath);
262 for (int i = 0; i < ctx.getChildCount(); i++) {
263 ParseTree child = ctx.getChild(i);
264 if (child instanceof Description_stmtContext) {
265 builder.setDescription(stringFromNode(child));
266 } else if (child instanceof Reference_stmtContext) {
267 builder.setReference(stringFromNode(child));
268 } else if (child instanceof Status_stmtContext) {
269 builder.setStatus(parseStatus((Status_stmtContext) child));
270 } else if (child instanceof When_stmtContext) {
271 builder.addWhenCondition(stringFromNode(child));
275 moduleBuilder.enterNode(builder);
276 actualPath.push(augmentPath);
280 public void exitAugment_stmt(YangParser.Augment_stmtContext ctx) {
281 moduleBuilder.exitNode();
282 exitLog("augment", actualPath.pop());
286 public void enterExtension_stmt(YangParser.Extension_stmtContext ctx) {
287 final int line = ctx.getStart().getLine();
288 final String extName = stringFromNode(ctx);
289 enterLog("extension", extName, line);
291 QName qname = new QName(namespace, revision, yangModelPrefix, extName);
292 ExtensionBuilder builder = moduleBuilder.addExtension(qname, line);
293 parseSchemaNodeArgs(ctx, builder);
295 String argument = null;
297 for (int i = 0; i < ctx.getChildCount(); i++) {
298 ParseTree child = ctx.getChild(i);
299 if (child instanceof Argument_stmtContext) {
300 argument = stringFromNode(child);
301 yin = parseYinValue((Argument_stmtContext) child);
305 builder.setArgument(argument);
306 builder.setYinElement(yin);
308 moduleBuilder.enterNode(builder);
309 actualPath.push(extName);
313 public void exitExtension_stmt(YangParser.Extension_stmtContext ctx) {
314 moduleBuilder.exitNode();
315 exitLog("extension", actualPath.pop());
319 public void enterTypedef_stmt(YangParser.Typedef_stmtContext ctx) {
320 final int line = ctx.getStart().getLine();
321 final String typedefName = stringFromNode(ctx);
322 enterLog("typedef", typedefName, line);
324 QName typedefQName = new QName(namespace, revision, yangModelPrefix, typedefName);
325 TypeDefinitionBuilder builder = moduleBuilder.addTypedef(line, typedefQName);
326 moduleBuilder.enterNode(builder);
327 actualPath.push(typedefName);
329 builder.setPath(createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix));
330 parseSchemaNodeArgs(ctx, builder);
331 builder.setUnits(parseUnits(ctx));
332 builder.setDefaultValue(parseDefault(ctx));
336 public void exitTypedef_stmt(YangParser.Typedef_stmtContext ctx) {
337 moduleBuilder.exitNode();
338 exitLog("typedef", actualPath.pop());
342 public void enterType_stmt(YangParser.Type_stmtContext ctx) {
343 final int line = ctx.getStart().getLine();
344 final String typeName = stringFromNode(ctx);
345 enterLog("type", typeName, line);
347 final QName typeQName = parseQName(typeName);
349 TypeDefinition<?> type = null;
350 Type_body_stmtsContext typeBody = null;
351 for (int i = 0; i < ctx.getChildCount(); i++) {
352 if (ctx.getChild(i) instanceof Type_body_stmtsContext) {
353 typeBody = (Type_body_stmtsContext) ctx.getChild(i);
358 // if this is base yang type...
359 if (YangTypesConverter.isBaseYangType(typeName)) {
360 if (typeBody == null) {
361 // check for types which must have body
362 checkMissingBody(typeName, moduleName, line);
363 // if there are no constraints, just grab default base yang type
364 type = YangTypesConverter.javaTypeForBaseYangType(actualPath, namespace, revision, typeName);
365 moduleBuilder.setType(type);
367 if ("union".equals(typeName)) {
368 SchemaPath p = createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix, typeName);
369 UnionTypeBuilder unionBuilder = moduleBuilder.addUnionType(line, namespace, revision);
370 moduleBuilder.enterNode(unionBuilder);
371 unionBuilder.setPath(p);
372 } else if ("identityref".equals(typeName)) {
373 SchemaPath path = createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix, typeName);
374 moduleBuilder.addIdentityrefType(line, path, getIdentityrefBase(typeBody));
376 type = parseTypeWithBody(typeName, typeBody, actualPath, namespace, revision, yangModelPrefix,
377 moduleBuilder.getActualNode());
378 moduleBuilder.setType(type);
382 type = parseUnknownTypeWithBody(typeQName, typeBody, actualPath, namespace, revision, yangModelPrefix,
383 moduleBuilder.getActualNode());
384 // add parent node of this type statement to dirty nodes
385 moduleBuilder.markActualNodeDirty();
386 moduleBuilder.setType(type);
389 actualPath.push(typeName);
392 private QName parseQName(String typeName) {
394 if (typeName.contains(":")) {
395 String[] splittedName = typeName.split(":");
396 String prefix = splittedName[0];
397 String name = splittedName[1];
398 if (prefix.equals(yangModelPrefix)) {
399 typeQName = new QName(namespace, revision, prefix, name);
401 typeQName = new QName(null, null, prefix, name);
404 typeQName = new QName(namespace, revision, yangModelPrefix, typeName);
410 public void exitType_stmt(YangParser.Type_stmtContext ctx) {
411 final String typeName = stringFromNode(ctx);
412 if ("union".equals(typeName)) {
413 moduleBuilder.exitNode();
415 exitLog("type", actualPath.pop());
419 public void enterGrouping_stmt(YangParser.Grouping_stmtContext ctx) {
420 final int line = ctx.getStart().getLine();
421 final String groupName = stringFromNode(ctx);
422 enterLog("grouping", groupName, line);
424 QName groupQName = new QName(namespace, revision, yangModelPrefix, groupName);
425 GroupingBuilder builder = moduleBuilder.addGrouping(ctx.getStart().getLine(), groupQName);
426 moduleBuilder.enterNode(builder);
427 actualPath.push(groupName);
429 builder.setPath(createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix));
430 parseSchemaNodeArgs(ctx, builder);
434 public void exitGrouping_stmt(YangParser.Grouping_stmtContext ctx) {
435 moduleBuilder.exitNode();
436 exitLog("grouping", actualPath.pop());
440 public void enterContainer_stmt(Container_stmtContext ctx) {
441 final int line = ctx.getStart().getLine();
442 final String containerName = stringFromNode(ctx);
443 enterLog("container", containerName, line);
445 QName containerQName = new QName(namespace, revision, yangModelPrefix, containerName);
446 SchemaPath path = createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix, containerName);
448 ContainerSchemaNodeBuilder builder = moduleBuilder.addContainerNode(line, containerQName, path);
449 moduleBuilder.enterNode(builder);
450 actualPath.push(containerName);
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);
466 public void exitContainer_stmt(Container_stmtContext ctx) {
467 moduleBuilder.exitNode();
468 exitLog("container", actualPath.pop());
472 public void enterLeaf_stmt(Leaf_stmtContext ctx) {
473 final int line = ctx.getStart().getLine();
474 final String leafName = stringFromNode(ctx);
475 enterLog("leaf", leafName, line);
477 QName leafQName = new QName(namespace, revision, yangModelPrefix, leafName);
478 SchemaPath schemaPath = createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix, leafName);
480 LeafSchemaNodeBuilder builder = moduleBuilder.addLeafNode(line, leafQName, schemaPath);
481 moduleBuilder.enterNode(builder);
482 actualPath.push(leafName);
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);
503 public void exitLeaf_stmt(YangParser.Leaf_stmtContext ctx) {
504 moduleBuilder.exitNode();
505 exitLog("leaf", actualPath.pop());
509 public void enterUses_stmt(YangParser.Uses_stmtContext ctx) {
510 final int line = ctx.getStart().getLine();
511 final String groupingPathStr = stringFromNode(ctx);
512 enterLog("uses", groupingPathStr, line);
514 UsesNodeBuilder builder = moduleBuilder.addUsesNode(line, groupingPathStr);
516 moduleBuilder.enterNode(builder);
517 actualPath.push(groupingPathStr);
521 public void exitUses_stmt(YangParser.Uses_stmtContext ctx) {
522 moduleBuilder.exitNode();
523 exitLog("uses", actualPath.pop());
526 @Override public void enterUses_augment_stmt(YangParser.Uses_augment_stmtContext ctx) {
527 final int line = ctx.getStart().getLine();
528 final String augmentPath = stringFromNode(ctx);
529 enterLog("augment", augmentPath, line);
531 AugmentationSchemaBuilder builder = moduleBuilder.addAugment(line, augmentPath);
533 for (int i = 0; i < ctx.getChildCount(); i++) {
534 ParseTree child = ctx.getChild(i);
535 if (child instanceof Description_stmtContext) {
536 builder.setDescription(stringFromNode(child));
537 } else if (child instanceof Reference_stmtContext) {
538 builder.setReference(stringFromNode(child));
539 } else if (child instanceof Status_stmtContext) {
540 builder.setStatus(parseStatus((Status_stmtContext) child));
541 } else if (child instanceof When_stmtContext) {
542 builder.addWhenCondition(stringFromNode(child));
546 moduleBuilder.enterNode(builder);
547 actualPath.push(augmentPath);
550 @Override public void exitUses_augment_stmt(YangParser.Uses_augment_stmtContext ctx) {
551 moduleBuilder.exitNode();
552 exitLog("augment", actualPath.pop());
556 public void enterRefine_stmt(YangParser.Refine_stmtContext ctx) {
557 final String refineString = stringFromNode(ctx);
558 enterLog("refine", refineString, ctx.getStart().getLine());
560 RefineHolder refine = parseRefine(ctx, moduleName);
561 moduleBuilder.addRefine(refine);
562 moduleBuilder.enterNode(refine);
563 actualPath.push(refineString);
567 public void exitRefine_stmt(YangParser.Refine_stmtContext ctx) {
568 moduleBuilder.exitNode();
569 exitLog("refine", actualPath.pop());
573 public void enterLeaf_list_stmt(Leaf_list_stmtContext ctx) {
574 final int line = ctx.getStart().getLine();
575 final String leafListName = stringFromNode(ctx);
576 enterLog("leaf-list", leafListName, line);
578 QName leafListQName = new QName(namespace, revision, yangModelPrefix, leafListName);
579 SchemaPath schemaPath = createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix, leafListName);
581 LeafListSchemaNodeBuilder builder = moduleBuilder.addLeafListNode(line, leafListQName, schemaPath);
582 moduleBuilder.enterNode(builder);
583 actualPath.push(leafListName);
585 parseSchemaNodeArgs(ctx, builder);
586 parseConstraints(ctx, builder.getConstraints());
587 builder.setConfiguration(getConfig(ctx, moduleBuilder.getActualParent(), moduleName, ctx.getStart().getLine()));
589 for (int i = 0; i < ctx.getChildCount(); ++i) {
590 final ParseTree childNode = ctx.getChild(i);
591 if (childNode instanceof Ordered_by_stmtContext) {
592 final Ordered_by_stmtContext orderedBy = (Ordered_by_stmtContext) childNode;
593 final boolean userOrdered = parseUserOrdered(orderedBy);
594 builder.setUserOrdered(userOrdered);
601 public void exitLeaf_list_stmt(YangParser.Leaf_list_stmtContext ctx) {
602 moduleBuilder.exitNode();
603 exitLog("leaf-list", actualPath.pop());
607 public void enterList_stmt(List_stmtContext ctx) {
608 final int line = ctx.getStart().getLine();
609 final String listName = stringFromNode(ctx);
610 enterLog("list", listName, line);
612 QName listQName = new QName(namespace, revision, yangModelPrefix, listName);
613 SchemaPath schemaPath = createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix, listName);
615 ListSchemaNodeBuilder builder = moduleBuilder.addListNode(line, listQName, schemaPath);
616 moduleBuilder.enterNode(builder);
617 actualPath.push(listName);
619 parseSchemaNodeArgs(ctx, builder);
620 parseConstraints(ctx, builder.getConstraints());
621 builder.setConfiguration(getConfig(ctx, moduleBuilder.getActualParent(), moduleName, line));
623 String keyDefinition = "";
624 for (int i = 0; i < ctx.getChildCount(); ++i) {
625 ParseTree childNode = ctx.getChild(i);
626 if (childNode instanceof Ordered_by_stmtContext) {
627 final Ordered_by_stmtContext orderedBy = (Ordered_by_stmtContext) childNode;
628 final boolean userOrdered = parseUserOrdered(orderedBy);
629 builder.setUserOrdered(userOrdered);
630 } else if (childNode instanceof Key_stmtContext) {
631 keyDefinition = stringFromNode(childNode);
632 List<QName> key = createListKey(keyDefinition, namespace, revision, yangModelPrefix);
633 builder.setKeyDefinition(key);
639 public void exitList_stmt(List_stmtContext ctx) {
640 moduleBuilder.exitNode();
641 exitLog("list", actualPath.pop());
645 public void enterAnyxml_stmt(YangParser.Anyxml_stmtContext ctx) {
646 final int line = ctx.getStart().getLine();
647 final String anyXmlName = stringFromNode(ctx);
648 enterLog("anyxml", anyXmlName, line);
650 QName anyXmlQName = new QName(namespace, revision, yangModelPrefix, anyXmlName);
651 SchemaPath schemaPath = createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix, anyXmlName);
653 AnyXmlBuilder builder = moduleBuilder.addAnyXml(line, anyXmlQName, schemaPath);
654 moduleBuilder.enterNode(builder);
655 actualPath.push(anyXmlName);
657 parseSchemaNodeArgs(ctx, builder);
658 parseConstraints(ctx, builder.getConstraints());
659 builder.setConfiguration(getConfig(ctx, moduleBuilder.getActualParent(), moduleName, line));
663 public void exitAnyxml_stmt(YangParser.Anyxml_stmtContext ctx) {
664 moduleBuilder.exitNode();
665 exitLog("anyxml", actualPath.pop());
669 public void enterChoice_stmt(YangParser.Choice_stmtContext ctx) {
670 final int line = ctx.getStart().getLine();
671 final String choiceName = stringFromNode(ctx);
672 enterLog("choice", choiceName, line);
674 QName choiceQName = new QName(namespace, revision, yangModelPrefix, choiceName);
676 ChoiceBuilder builder = moduleBuilder.addChoice(line, choiceQName);
677 moduleBuilder.enterNode(builder);
678 actualPath.push(choiceName);
680 builder.setPath(createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix));
681 parseSchemaNodeArgs(ctx, builder);
682 parseConstraints(ctx, builder.getConstraints());
683 builder.setConfiguration(getConfig(ctx, moduleBuilder.getActualParent(), moduleName, line));
685 // set 'default' case
686 for (int i = 0; i < ctx.getChildCount(); i++) {
687 ParseTree child = ctx.getChild(i);
688 if (child instanceof Default_stmtContext) {
689 String defaultCase = stringFromNode(child);
690 builder.setDefaultCase(defaultCase);
697 public void exitChoice_stmt(YangParser.Choice_stmtContext ctx) {
698 moduleBuilder.exitNode();
699 exitLog("choice", actualPath.pop());
703 public void enterCase_stmt(YangParser.Case_stmtContext ctx) {
704 final int line = ctx.getStart().getLine();
705 final String caseName = stringFromNode(ctx);
706 enterLog("case", caseName, line);
708 QName caseQName = new QName(namespace, revision, yangModelPrefix, caseName);
709 ChoiceCaseBuilder builder = moduleBuilder.addCase(line, caseQName);
710 moduleBuilder.enterNode(builder);
711 actualPath.push(caseName);
713 builder.setPath(createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix));
714 parseSchemaNodeArgs(ctx, builder);
715 parseConstraints(ctx, builder.getConstraints());
719 public void exitCase_stmt(YangParser.Case_stmtContext ctx) {
720 moduleBuilder.exitNode();
721 exitLog("case", actualPath.pop());
725 public void enterNotification_stmt(YangParser.Notification_stmtContext ctx) {
726 final int line = ctx.getStart().getLine();
727 final String notificationName = stringFromNode(ctx);
728 enterLog("notification", notificationName, line);
730 QName notificationQName = new QName(namespace, revision, yangModelPrefix, notificationName);
731 NotificationBuilder builder = moduleBuilder.addNotification(line, notificationQName);
732 moduleBuilder.enterNode(builder);
733 actualPath.push(notificationName);
735 builder.setPath(createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix));
736 parseSchemaNodeArgs(ctx, builder);
740 public void exitNotification_stmt(YangParser.Notification_stmtContext ctx) {
741 moduleBuilder.exitNode();
742 exitLog("notification", actualPath.pop());
747 public void enterIdentifier_stmt(YangParser.Identifier_stmtContext ctx) {
748 final int line = ctx.getStart().getLine();
749 final String nodeParameter = stringFromNode(ctx);
750 enterLog("unknown-node", nodeParameter, line);
752 QName nodeType = null;
754 final String nodeTypeStr = ctx.getChild(0).getText();
755 final String[] splittedElement = nodeTypeStr.split(":");
756 if (splittedElement.length == 1) {
757 nodeType = new QName(null, null, yangModelPrefix, splittedElement[0]);
759 nodeType = new QName(null, null, splittedElement[0], splittedElement[1]);
763 if (nodeParameter != null) {
764 String[] splittedName = nodeParameter.split(":");
765 if (splittedName.length == 2) {
766 qname = new QName(null, null, splittedName[0], splittedName[1]);
768 qname = new QName(namespace, revision, yangModelPrefix, splittedName[0]);
771 qname = new QName(namespace, revision, yangModelPrefix, nodeParameter);
774 UnknownSchemaNodeBuilder builder = moduleBuilder.addUnknownSchemaNode(line, qname);
775 builder.setNodeType(nodeType);
776 builder.setNodeParameter(nodeParameter);
777 actualPath.push(nodeParameter);
778 builder.setPath(createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix));
779 parseSchemaNodeArgs(ctx, builder);
780 moduleBuilder.enterNode(builder);
784 public void exitIdentifier_stmt(YangParser.Identifier_stmtContext ctx) {
785 moduleBuilder.exitNode();
786 exitLog("unknown-node", actualPath.pop());
790 public void enterRpc_stmt(YangParser.Rpc_stmtContext ctx) {
791 final int line = ctx.getStart().getLine();
792 final String rpcName = stringFromNode(ctx);
793 enterLog("rpc", rpcName, line);
795 QName rpcQName = new QName(namespace, revision, yangModelPrefix, rpcName);
796 RpcDefinitionBuilder rpcBuilder = moduleBuilder.addRpc(line, rpcQName);
797 moduleBuilder.enterNode(rpcBuilder);
798 actualPath.push(rpcName);
800 rpcBuilder.setPath(createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix));
801 parseSchemaNodeArgs(ctx, rpcBuilder);
805 public void exitRpc_stmt(YangParser.Rpc_stmtContext ctx) {
806 moduleBuilder.exitNode();
807 exitLog("rpc", actualPath.pop());
811 public void enterInput_stmt(YangParser.Input_stmtContext ctx) {
812 final int line = ctx.getStart().getLine();
813 final String input = "input";
814 enterLog(input, input, line);
816 QName rpcQName = new QName(namespace, revision, yangModelPrefix, input);
817 SchemaPath path = createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix, input);
819 ContainerSchemaNodeBuilder builder = moduleBuilder.addRpcInput(line, rpcQName, path);
820 moduleBuilder.enterNode(builder);
821 actualPath.push(input);
823 parseSchemaNodeArgs(ctx, builder);
824 parseConstraints(ctx, builder.getConstraints());
828 public void exitInput_stmt(YangParser.Input_stmtContext ctx) {
829 moduleBuilder.exitNode();
830 exitLog("input", actualPath.pop());
834 public void enterOutput_stmt(YangParser.Output_stmtContext ctx) {
835 final int line = ctx.getStart().getLine();
836 final String output = "output";
837 enterLog(output, output, line);
839 QName rpcQName = new QName(namespace, revision, yangModelPrefix, output);
840 SchemaPath path = createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix, output);
842 ContainerSchemaNodeBuilder builder = moduleBuilder.addRpcOutput(path, rpcQName, line);
843 moduleBuilder.enterNode(builder);
844 actualPath.push(output);
846 parseSchemaNodeArgs(ctx, builder);
847 parseConstraints(ctx, builder.getConstraints());
851 public void exitOutput_stmt(YangParser.Output_stmtContext ctx) {
852 moduleBuilder.exitNode();
853 exitLog("output", actualPath.pop());
857 public void enterFeature_stmt(YangParser.Feature_stmtContext ctx) {
858 final int line = ctx.getStart().getLine();
859 final String featureName = stringFromNode(ctx);
860 enterLog("feature", featureName, line);
862 QName featureQName = new QName(namespace, revision, yangModelPrefix, featureName);
863 FeatureBuilder featureBuilder = moduleBuilder.addFeature(line, featureQName);
864 moduleBuilder.enterNode(featureBuilder);
865 actualPath.push(featureName);
867 featureBuilder.setPath(createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix));
868 parseSchemaNodeArgs(ctx, featureBuilder);
872 public void exitFeature_stmt(YangParser.Feature_stmtContext ctx) {
873 moduleBuilder.exitNode();
874 exitLog("feature", actualPath.pop());
878 public void enterDeviation_stmt(YangParser.Deviation_stmtContext ctx) {
879 final int line = ctx.getStart().getLine();
880 final String targetPath = stringFromNode(ctx);
881 enterLog("deviation", targetPath, line);
883 String reference = null;
884 String deviate = null;
885 DeviationBuilder builder = moduleBuilder.addDeviation(line, targetPath);
886 moduleBuilder.enterNode(builder);
887 actualPath.push(targetPath);
889 for (int i = 0; i < ctx.getChildCount(); i++) {
890 ParseTree child = ctx.getChild(i);
891 if (child instanceof Reference_stmtContext) {
892 reference = stringFromNode(child);
893 } else if (child instanceof Deviate_not_supported_stmtContext) {
894 deviate = stringFromNode(child);
895 } else if (child instanceof Deviate_add_stmtContext) {
896 deviate = stringFromNode(child);
897 } else if (child instanceof Deviate_replace_stmtContext) {
898 deviate = stringFromNode(child);
899 } else if (child instanceof Deviate_delete_stmtContext) {
900 deviate = stringFromNode(child);
903 builder.setReference(reference);
904 builder.setDeviate(deviate);
908 public void exitDeviation_stmt(YangParser.Deviation_stmtContext ctx) {
909 moduleBuilder.exitNode();
910 exitLog("deviation", actualPath.pop());
914 public void enterIdentity_stmt(YangParser.Identity_stmtContext ctx) {
915 final int line = ctx.getStart().getLine();
916 final String identityName = stringFromNode(ctx);
917 enterLog("identity", identityName, line);
919 final QName identityQName = new QName(namespace, revision, yangModelPrefix, identityName);
920 IdentitySchemaNodeBuilder builder = moduleBuilder.addIdentity(identityQName, actualPath, line);
921 moduleBuilder.enterNode(builder);
922 actualPath.push(identityName);
924 builder.setPath(createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix));
925 parseSchemaNodeArgs(ctx, builder);
927 for (int i = 0; i < ctx.getChildCount(); i++) {
928 ParseTree child = ctx.getChild(i);
929 if (child instanceof Base_stmtContext) {
930 String baseIdentityName = stringFromNode(child);
931 builder.setBaseIdentityName(baseIdentityName);
937 public void exitIdentity_stmt(YangParser.Identity_stmtContext ctx) {
938 moduleBuilder.exitNode();
939 exitLog("identity", actualPath.pop());
942 public ModuleBuilder getModuleBuilder() {
943 return moduleBuilder;
946 private void enterLog(String p1, String p2, int line) {
947 logger.debug("entering " + p1 + " " + p2 + " (" + line + ")");
950 private void exitLog(String p1, String p2) {
951 logger.debug("exiting " + p1 + " " + p2);
954 private void setLog(String p1, String p2) {
955 logger.debug("setting " + p1 + " " + p2);