2 * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
8 package org.opendaylight.yangtools.yang.parser.impl;
10 import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.checkMissingBody;
11 import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.createActualSchemaPath;
12 import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.createListKey;
13 import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.getConfig;
14 import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.getIdentityrefBase;
15 import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.parseConstraints;
16 import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.parseDefault;
17 import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.parseRefine;
18 import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.parseSchemaNodeArgs;
19 import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.parseStatus;
20 import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.parseTypeWithBody;
21 import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.parseUnits;
22 import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.parseUnknownTypeWithBody;
23 import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.parseUserOrdered;
24 import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.parseYinValue;
25 import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.stringFromNode;
27 import com.google.common.base.Strings;
29 import java.text.DateFormat;
30 import java.text.ParseException;
31 import java.text.SimpleDateFormat;
32 import java.util.Date;
33 import java.util.List;
34 import java.util.Stack;
35 import org.antlr.v4.runtime.tree.ParseTree;
36 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser;
37 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Argument_stmtContext;
38 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Base_stmtContext;
39 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Contact_stmtContext;
40 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Container_stmtContext;
41 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Default_stmtContext;
42 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Description_stmtContext;
43 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Deviate_add_stmtContext;
44 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Deviate_delete_stmtContext;
45 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Deviate_not_supported_stmtContext;
46 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Deviate_replace_stmtContext;
47 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Import_stmtContext;
48 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Key_stmtContext;
49 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Leaf_list_stmtContext;
50 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Leaf_stmtContext;
51 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.List_stmtContext;
52 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Module_header_stmtsContext;
53 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Namespace_stmtContext;
54 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Ordered_by_stmtContext;
55 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Organization_stmtContext;
56 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Prefix_stmtContext;
57 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Presence_stmtContext;
58 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Reference_stmtContext;
59 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Revision_date_stmtContext;
60 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Revision_stmtContext;
61 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Revision_stmtsContext;
62 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Status_stmtContext;
63 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Type_body_stmtsContext;
64 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Units_stmtContext;
65 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.When_stmtContext;
66 import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Yang_version_stmtContext;
67 import org.opendaylight.yangtools.antlrv4.code.gen.YangParserBaseListener;
68 import org.opendaylight.yangtools.yang.common.QName;
69 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
70 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
71 import org.opendaylight.yangtools.yang.model.util.BaseTypes;
72 import org.opendaylight.yangtools.yang.model.util.YangTypesConverter;
73 import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
74 import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
75 import org.opendaylight.yangtools.yang.parser.builder.api.ExtensionBuilder;
76 import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
77 import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
78 import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
79 import org.opendaylight.yangtools.yang.parser.builder.impl.AnyXmlBuilder;
80 import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceBuilder;
81 import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceCaseBuilder;
82 import org.opendaylight.yangtools.yang.parser.builder.impl.ContainerSchemaNodeBuilder;
83 import org.opendaylight.yangtools.yang.parser.builder.impl.DeviationBuilder;
84 import org.opendaylight.yangtools.yang.parser.builder.impl.FeatureBuilder;
85 import org.opendaylight.yangtools.yang.parser.builder.impl.IdentitySchemaNodeBuilder;
86 import org.opendaylight.yangtools.yang.parser.builder.impl.LeafListSchemaNodeBuilder;
87 import org.opendaylight.yangtools.yang.parser.builder.impl.LeafSchemaNodeBuilder;
88 import org.opendaylight.yangtools.yang.parser.builder.impl.ListSchemaNodeBuilder;
89 import org.opendaylight.yangtools.yang.parser.builder.impl.ModuleBuilder;
90 import org.opendaylight.yangtools.yang.parser.builder.impl.NotificationBuilder;
91 import org.opendaylight.yangtools.yang.parser.builder.impl.RefineHolderImpl;
92 import org.opendaylight.yangtools.yang.parser.builder.impl.RpcDefinitionBuilder;
93 import org.opendaylight.yangtools.yang.parser.builder.impl.UnionTypeBuilder;
94 import org.opendaylight.yangtools.yang.parser.builder.impl.UnknownSchemaNodeBuilderImpl;
95 import org.slf4j.Logger;
96 import org.slf4j.LoggerFactory;
98 public final class YangParserListenerImpl extends YangParserBaseListener {
99 private static final Logger LOGGER = LoggerFactory.getLogger(YangParserListenerImpl.class);
100 private static final String AUGMENT_STR = "augment";
102 private final String sourcePath;
103 private ModuleBuilder moduleBuilder;
104 private String moduleName;
105 private URI namespace;
106 private String yangModelPrefix;
107 private Date revision = new Date(0L);
109 private final DateFormat SIMPLE_DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd");
110 private final Stack<Stack<QName>> actualPath = new Stack<>();
111 private int augmentOrder;
113 private void addNodeToPath(final QName name) {
114 actualPath.peek().push(name);
117 private QName removeNodeFromPath() {
118 return actualPath.peek().pop();
121 public YangParserListenerImpl(final String sourcePath) {
122 this.sourcePath = sourcePath;
126 public void enterModule_stmt(final YangParser.Module_stmtContext ctx) {
127 moduleName = stringFromNode(ctx);
128 LOGGER.trace("entering module " + moduleName);
129 enterLog("module", moduleName, 0);
130 actualPath.push(new Stack<QName>());
132 moduleBuilder = new ModuleBuilder(moduleName, sourcePath);
134 String description = null;
135 String reference = null;
136 for (int i = 0; i < ctx.getChildCount(); i++) {
137 ParseTree child = ctx.getChild(i);
138 if (child instanceof Description_stmtContext) {
139 description = stringFromNode(child);
140 } else if (child instanceof Reference_stmtContext) {
141 reference = stringFromNode(child);
143 if (description != null && reference != null) {
148 moduleBuilder.setDescription(description);
149 moduleBuilder.setReference(reference);
153 public void exitModule_stmt(final YangParser.Module_stmtContext ctx) {
158 @Override public void enterSubmodule_stmt(final YangParser.Submodule_stmtContext ctx) {
159 moduleName = stringFromNode(ctx);
160 LOGGER.trace("entering submodule " + moduleName);
161 enterLog("submodule", moduleName, 0);
162 actualPath.push(new Stack<QName>());
164 moduleBuilder = new ModuleBuilder(moduleName, true, sourcePath);
166 String description = null;
167 String reference = null;
168 for (int i = 0; i < ctx.getChildCount(); i++) {
169 ParseTree child = ctx.getChild(i);
170 if (child instanceof Description_stmtContext) {
171 description = stringFromNode(child);
172 } else if (child instanceof Reference_stmtContext) {
173 reference = stringFromNode(child);
175 if (description != null && reference != null) {
180 moduleBuilder.setDescription(description);
181 moduleBuilder.setReference(reference);
184 @Override public void exitSubmodule_stmt(final YangParser.Submodule_stmtContext ctx) {
185 exitLog("submodule");
189 @Override public void enterBelongs_to_stmt(final YangParser.Belongs_to_stmtContext ctx) {
190 moduleBuilder.setBelongsTo(stringFromNode(ctx));
194 public void enterModule_header_stmts(final Module_header_stmtsContext ctx) {
195 enterLog("module_header", "", ctx.getStart().getLine());
196 String yangVersion = null;
197 for (int i = 0; i < ctx.getChildCount(); ++i) {
198 final ParseTree treeNode = ctx.getChild(i);
199 if (treeNode instanceof Namespace_stmtContext) {
200 final String namespaceStr = stringFromNode(treeNode);
201 namespace = URI.create(namespaceStr);
202 moduleBuilder.setNamespace(namespace);
203 setLog("namespace", namespaceStr);
204 } else if (treeNode instanceof Prefix_stmtContext) {
205 yangModelPrefix = stringFromNode(treeNode);
206 moduleBuilder.setPrefix(yangModelPrefix);
207 setLog("prefix", yangModelPrefix);
208 } else if (treeNode instanceof Yang_version_stmtContext) {
209 yangVersion = stringFromNode(treeNode);
210 setLog("yang-version", yangVersion);
214 if (yangVersion == null) {
217 moduleBuilder.setYangVersion(yangVersion);
221 public void exitModule_header_stmts(final Module_header_stmtsContext ctx) {
222 exitLog("module_header");
226 public void enterMeta_stmts(final YangParser.Meta_stmtsContext ctx) {
227 enterLog("meta_stmt", "", ctx.getStart().getLine());
228 for (int i = 0; i < ctx.getChildCount(); i++) {
229 ParseTree child = ctx.getChild(i);
230 if (child instanceof Organization_stmtContext) {
231 final String organization = stringFromNode(child);
232 moduleBuilder.setOrganization(organization);
233 setLog("organization", organization);
234 } else if (child instanceof Contact_stmtContext) {
235 final String contact = stringFromNode(child);
236 moduleBuilder.setContact(contact);
237 setLog("contact", contact);
238 } else if (child instanceof Description_stmtContext) {
239 final String description = stringFromNode(child);
240 moduleBuilder.setDescription(description);
241 setLog("description", description);
242 } else if (child instanceof Reference_stmtContext) {
243 final String reference = stringFromNode(child);
244 moduleBuilder.setReference(reference);
245 setLog("reference", reference);
251 public void exitMeta_stmts(final YangParser.Meta_stmtsContext ctx) {
252 exitLog("meta_stmt");
256 public void enterRevision_stmts(final Revision_stmtsContext ctx) {
257 enterLog("revisions", "", ctx.getStart().getLine());
258 for (int i = 0; i < ctx.getChildCount(); ++i) {
259 final ParseTree treeNode = ctx.getChild(i);
260 if (treeNode instanceof Revision_stmtContext) {
261 updateRevisionForRevisionStatement(treeNode);
267 public void exitRevision_stmts(final Revision_stmtsContext ctx) {
268 exitLog("revisions");
271 private void updateRevisionForRevisionStatement(final ParseTree treeNode) {
272 final String revisionDateStr = stringFromNode(treeNode);
274 final Date revisionDate = SIMPLE_DATE_FORMAT.parse(revisionDateStr);
275 if ((revisionDate != null) && (this.revision.compareTo(revisionDate) < 0)) {
276 this.revision = revisionDate;
277 moduleBuilder.setRevision(this.revision);
278 setLog("revision", this.revision.toString());
279 for (int i = 0; i < treeNode.getChildCount(); ++i) {
280 ParseTree child = treeNode.getChild(i);
281 if (child instanceof Reference_stmtContext) {
282 moduleBuilder.setReference(stringFromNode(child));
286 } catch (ParseException e) {
287 final String message = "Failed to parse revision string: " + revisionDateStr;
288 LOGGER.warn(message);
293 public void enterImport_stmt(final Import_stmtContext ctx) {
294 final int line = ctx.getStart().getLine();
295 final String importName = stringFromNode(ctx);
296 enterLog("import", importName, line);
298 String importPrefix = null;
299 Date importRevision = null;
301 for (int i = 0; i < ctx.getChildCount(); ++i) {
302 final ParseTree treeNode = ctx.getChild(i);
303 if (treeNode instanceof Prefix_stmtContext) {
304 importPrefix = stringFromNode(treeNode);
306 if (treeNode instanceof Revision_date_stmtContext) {
307 String importRevisionStr = stringFromNode(treeNode);
309 importRevision = SIMPLE_DATE_FORMAT.parse(importRevisionStr);
310 } catch (ParseException e) {
311 LOGGER.warn("Failed to parse import revision-date at line " + line + ": " + importRevisionStr);
315 moduleBuilder.addModuleImport(importName, importRevision, importPrefix);
316 setLog("import", "(" + importName + "; " + importRevision + "; " + importPrefix + ")");
320 public void exitImport_stmt(final Import_stmtContext ctx) {
325 public void enterAugment_stmt(final YangParser.Augment_stmtContext ctx) {
326 final int line = ctx.getStart().getLine();
327 final String augmentPath = stringFromNode(ctx);
328 enterLog(AUGMENT_STR, augmentPath, line);
329 actualPath.push(new Stack<QName>());
331 AugmentationSchemaBuilder builder = moduleBuilder.addAugment(line, augmentPath, augmentOrder++);
333 for (int i = 0; i < ctx.getChildCount(); i++) {
334 ParseTree child = ctx.getChild(i);
335 if (child instanceof Description_stmtContext) {
336 builder.setDescription(stringFromNode(child));
337 } else if (child instanceof Reference_stmtContext) {
338 builder.setReference(stringFromNode(child));
339 } else if (child instanceof Status_stmtContext) {
340 builder.setStatus(parseStatus((Status_stmtContext) child));
341 } else if (child instanceof When_stmtContext) {
342 builder.addWhenCondition(stringFromNode(child));
346 moduleBuilder.enterNode(builder);
350 public void exitAugment_stmt(final YangParser.Augment_stmtContext ctx) {
351 moduleBuilder.exitNode();
352 exitLog(AUGMENT_STR);
357 public void enterExtension_stmt(final YangParser.Extension_stmtContext ctx) {
358 final int line = ctx.getStart().getLine();
359 final String extName = stringFromNode(ctx);
360 enterLog("extension", extName, line);
361 QName qname = new QName(namespace, revision, yangModelPrefix, extName);
362 addNodeToPath(qname);
363 SchemaPath path = createActualSchemaPath(actualPath.peek());
365 ExtensionBuilder builder = moduleBuilder.addExtension(qname, line, path);
366 parseSchemaNodeArgs(ctx, builder);
368 String argument = null;
370 for (int i = 0; i < ctx.getChildCount(); i++) {
371 ParseTree child = ctx.getChild(i);
372 if (child instanceof Argument_stmtContext) {
373 argument = stringFromNode(child);
374 yin = parseYinValue((Argument_stmtContext) child);
378 builder.setArgument(argument);
379 builder.setYinElement(yin);
381 moduleBuilder.enterNode(builder);
385 public void exitExtension_stmt(final YangParser.Extension_stmtContext ctx) {
386 moduleBuilder.exitNode();
387 exitLog("extension", removeNodeFromPath());
391 public void enterTypedef_stmt(final YangParser.Typedef_stmtContext ctx) {
392 final int line = ctx.getStart().getLine();
393 final String typedefName = stringFromNode(ctx);
394 enterLog("typedef", typedefName, line);
395 QName typedefQName = new QName(namespace, revision, yangModelPrefix, typedefName);
396 addNodeToPath(typedefQName);
397 SchemaPath path = createActualSchemaPath(actualPath.peek());
399 TypeDefinitionBuilder builder = moduleBuilder.addTypedef(line, typedefQName, path);
400 parseSchemaNodeArgs(ctx, builder);
401 builder.setUnits(parseUnits(ctx));
402 builder.setDefaultValue(parseDefault(ctx));
404 moduleBuilder.enterNode(builder);
408 public void exitTypedef_stmt(final YangParser.Typedef_stmtContext ctx) {
409 moduleBuilder.exitNode();
410 exitLog("typedef", removeNodeFromPath());
414 public void enterType_stmt(final YangParser.Type_stmtContext ctx) {
415 final int line = ctx.getStart().getLine();
416 final String typeName = stringFromNode(ctx);
417 enterLog("type", typeName, line);
419 final QName typeQName = parseQName(typeName);
421 TypeDefinition<?> type;
422 Type_body_stmtsContext typeBody = null;
423 for (int i = 0; i < ctx.getChildCount(); i++) {
424 if (ctx.getChild(i) instanceof Type_body_stmtsContext) {
425 typeBody = (Type_body_stmtsContext) ctx.getChild(i);
430 // if this is base yang type...
431 if (YangTypesConverter.isBaseYangType(typeName)) {
432 if (typeBody == null) {
433 // check for types which must have body
434 checkMissingBody(typeName, moduleName, line);
435 // if there are no constraints, just grab default base yang type
436 type = YangTypesConverter.javaTypeForBaseYangType(typeName);
437 addNodeToPath(type.getQName());
438 moduleBuilder.setType(type);
443 qname = BaseTypes.constructQName("union");
444 addNodeToPath(qname);
445 UnionTypeBuilder unionBuilder = moduleBuilder.addUnionType(line, namespace, revision);
446 Builder parent = moduleBuilder.getActualNode();
447 unionBuilder.setParent(parent);
448 moduleBuilder.enterNode(unionBuilder);
451 qname = BaseTypes.constructQName("identityref");
452 addNodeToPath(qname);
453 SchemaPath path = createActualSchemaPath(actualPath.peek());
454 moduleBuilder.addIdentityrefType(line, path, getIdentityrefBase(typeBody));
457 type = parseTypeWithBody(typeName, typeBody, actualPath.peek(), namespace, revision,
458 yangModelPrefix, moduleBuilder.getActualNode());
459 moduleBuilder.setType(type);
460 addNodeToPath(type.getQName());
464 type = parseUnknownTypeWithBody(typeQName, typeBody, actualPath.peek(), namespace, revision,
465 yangModelPrefix, moduleBuilder.getActualNode());
466 // add parent node of this type statement to dirty nodes
467 moduleBuilder.markActualNodeDirty();
468 moduleBuilder.setType(type);
469 addNodeToPath(type.getQName());
474 private QName parseQName(final String typeName) {
476 if (typeName.contains(":")) {
477 String[] splittedName = typeName.split(":");
478 String prefix = splittedName[0];
479 String name = splittedName[1];
480 if (prefix.equals(yangModelPrefix)) {
481 typeQName = new QName(namespace, revision, prefix, name);
483 typeQName = new QName(null, null, prefix, name);
486 typeQName = new QName(namespace, revision, yangModelPrefix, typeName);
492 public void exitType_stmt(final YangParser.Type_stmtContext ctx) {
493 final String typeName = stringFromNode(ctx);
494 if ("union".equals(typeName)) {
495 moduleBuilder.exitNode();
497 exitLog("type", removeNodeFromPath());
501 public void enterGrouping_stmt(final YangParser.Grouping_stmtContext ctx) {
502 final int line = ctx.getStart().getLine();
503 final String groupName = stringFromNode(ctx);
504 enterLog("grouping", groupName, line);
505 QName groupQName = new QName(namespace, revision, yangModelPrefix, groupName);
506 addNodeToPath(groupQName);
507 SchemaPath path = createActualSchemaPath(actualPath.peek());
509 GroupingBuilder builder = moduleBuilder.addGrouping(ctx.getStart().getLine(), groupQName, path);
510 parseSchemaNodeArgs(ctx, builder);
512 moduleBuilder.enterNode(builder);
516 public void exitGrouping_stmt(final YangParser.Grouping_stmtContext ctx) {
517 moduleBuilder.exitNode();
518 exitLog("grouping", removeNodeFromPath());
522 public void enterContainer_stmt(final Container_stmtContext ctx) {
523 final int line = ctx.getStart().getLine();
524 final String containerName = stringFromNode(ctx);
525 enterLog("container", containerName, line);
527 QName containerQName = new QName(namespace, revision, yangModelPrefix, containerName);
528 addNodeToPath(containerQName);
529 SchemaPath path = createActualSchemaPath(actualPath.peek());
531 ContainerSchemaNodeBuilder builder = moduleBuilder.addContainerNode(line, containerQName, path);
532 parseSchemaNodeArgs(ctx, builder);
533 parseConstraints(ctx, builder.getConstraints());
534 builder.setConfiguration(getConfig(ctx, builder, moduleName, line));
536 for (int i = 0; i < ctx.getChildCount(); ++i) {
537 final ParseTree childNode = ctx.getChild(i);
538 if (childNode instanceof Presence_stmtContext) {
539 builder.setPresence(true);
544 moduleBuilder.enterNode(builder);
548 public void exitContainer_stmt(final Container_stmtContext ctx) {
549 moduleBuilder.exitNode();
550 exitLog("container", removeNodeFromPath());
554 public void enterLeaf_stmt(final Leaf_stmtContext ctx) {
555 final int line = ctx.getStart().getLine();
556 final String leafName = stringFromNode(ctx);
557 enterLog("leaf", leafName, line);
559 QName leafQName = new QName(namespace, revision, yangModelPrefix, leafName);
560 addNodeToPath(leafQName);
561 SchemaPath path = createActualSchemaPath(actualPath.peek());
563 LeafSchemaNodeBuilder builder = moduleBuilder.addLeafNode(line, leafQName, path);
564 parseSchemaNodeArgs(ctx, builder);
565 parseConstraints(ctx, builder.getConstraints());
566 builder.setConfiguration(getConfig(ctx, builder, moduleName, line));
568 String defaultStr = null;
569 String unitsStr = null;
570 for (int i = 0; i < ctx.getChildCount(); i++) {
571 ParseTree child = ctx.getChild(i);
572 if (child instanceof Default_stmtContext) {
573 defaultStr = stringFromNode(child);
574 } else if (child instanceof Units_stmtContext) {
575 unitsStr = stringFromNode(child);
578 builder.setDefaultStr(defaultStr);
579 builder.setUnits(unitsStr);
581 moduleBuilder.enterNode(builder);
585 public void exitLeaf_stmt(final YangParser.Leaf_stmtContext ctx) {
586 moduleBuilder.exitNode();
587 exitLog("leaf", removeNodeFromPath());
591 public void enterUses_stmt(final YangParser.Uses_stmtContext ctx) {
592 final int line = ctx.getStart().getLine();
593 final String groupingPathStr = stringFromNode(ctx);
594 enterLog("uses", groupingPathStr, line);
596 UsesNodeBuilder builder = moduleBuilder.addUsesNode(line, groupingPathStr);
598 moduleBuilder.enterNode(builder);
602 public void exitUses_stmt(final YangParser.Uses_stmtContext ctx) {
603 moduleBuilder.exitNode();
608 public void enterUses_augment_stmt(final YangParser.Uses_augment_stmtContext ctx) {
609 actualPath.push(new Stack<QName>());
610 final int line = ctx.getStart().getLine();
611 final String augmentPath = stringFromNode(ctx);
612 enterLog(AUGMENT_STR, augmentPath, line);
614 AugmentationSchemaBuilder builder = moduleBuilder.addAugment(line, augmentPath, augmentOrder++);
616 for (int i = 0; i < ctx.getChildCount(); i++) {
617 ParseTree child = ctx.getChild(i);
618 if (child instanceof Description_stmtContext) {
619 builder.setDescription(stringFromNode(child));
620 } else if (child instanceof Reference_stmtContext) {
621 builder.setReference(stringFromNode(child));
622 } else if (child instanceof Status_stmtContext) {
623 builder.setStatus(parseStatus((Status_stmtContext) child));
624 } else if (child instanceof When_stmtContext) {
625 builder.addWhenCondition(stringFromNode(child));
629 moduleBuilder.enterNode(builder);
633 public void exitUses_augment_stmt(final YangParser.Uses_augment_stmtContext ctx) {
634 moduleBuilder.exitNode();
635 exitLog(AUGMENT_STR);
640 public void enterRefine_stmt(final YangParser.Refine_stmtContext ctx) {
641 final String refineString = stringFromNode(ctx);
642 enterLog("refine", refineString, ctx.getStart().getLine());
644 RefineHolderImpl refine = parseRefine(ctx, moduleName);
645 moduleBuilder.addRefine(refine);
646 moduleBuilder.enterNode(refine);
650 public void exitRefine_stmt(final YangParser.Refine_stmtContext ctx) {
651 moduleBuilder.exitNode();
656 public void enterLeaf_list_stmt(final Leaf_list_stmtContext ctx) {
657 final int line = ctx.getStart().getLine();
658 final String leafListName = stringFromNode(ctx);
659 enterLog("leaf-list", leafListName, line);
660 QName leafListQName = new QName(namespace, revision, yangModelPrefix, leafListName);
661 addNodeToPath(leafListQName);
662 SchemaPath path = createActualSchemaPath(actualPath.peek());
664 LeafListSchemaNodeBuilder builder = moduleBuilder.addLeafListNode(line, leafListQName, path);
665 moduleBuilder.enterNode(builder);
667 parseSchemaNodeArgs(ctx, builder);
668 parseConstraints(ctx, builder.getConstraints());
669 builder.setConfiguration(getConfig(ctx, builder, moduleName, ctx.getStart().getLine()));
671 for (int i = 0; i < ctx.getChildCount(); ++i) {
672 final ParseTree childNode = ctx.getChild(i);
673 if (childNode instanceof Ordered_by_stmtContext) {
674 final Ordered_by_stmtContext orderedBy = (Ordered_by_stmtContext) childNode;
675 final boolean userOrdered = parseUserOrdered(orderedBy);
676 builder.setUserOrdered(userOrdered);
683 public void exitLeaf_list_stmt(final YangParser.Leaf_list_stmtContext ctx) {
684 moduleBuilder.exitNode();
685 exitLog("leaf-list", removeNodeFromPath());
689 public void enterList_stmt(final List_stmtContext ctx) {
690 final int line = ctx.getStart().getLine();
691 final String listName = stringFromNode(ctx);
692 enterLog("list", listName, line);
694 QName listQName = new QName(namespace, revision, yangModelPrefix, listName);
695 addNodeToPath(listQName);
696 SchemaPath path = createActualSchemaPath(actualPath.peek());
698 ListSchemaNodeBuilder builder = moduleBuilder.addListNode(line, listQName, path);
699 moduleBuilder.enterNode(builder);
701 parseSchemaNodeArgs(ctx, builder);
702 parseConstraints(ctx, builder.getConstraints());
703 builder.setConfiguration(getConfig(ctx, builder, moduleName, line));
705 for (int i = 0; i < ctx.getChildCount(); ++i) {
706 ParseTree childNode = ctx.getChild(i);
707 if (childNode instanceof Ordered_by_stmtContext) {
708 final Ordered_by_stmtContext orderedBy = (Ordered_by_stmtContext) childNode;
709 final boolean userOrdered = parseUserOrdered(orderedBy);
710 builder.setUserOrdered(userOrdered);
711 } else if (childNode instanceof Key_stmtContext) {
712 List<String> key = createListKey((Key_stmtContext) childNode);
713 builder.setKeys(key);
719 public void exitList_stmt(final List_stmtContext ctx) {
720 moduleBuilder.exitNode();
721 exitLog("list", removeNodeFromPath());
725 public void enterAnyxml_stmt(final YangParser.Anyxml_stmtContext ctx) {
726 final int line = ctx.getStart().getLine();
727 final String anyXmlName = stringFromNode(ctx);
728 enterLog("anyxml", anyXmlName, line);
730 QName anyXmlQName = new QName(namespace, revision, yangModelPrefix, anyXmlName);
731 addNodeToPath(anyXmlQName);
732 SchemaPath path = createActualSchemaPath(actualPath.peek());
734 AnyXmlBuilder builder = moduleBuilder.addAnyXml(line, anyXmlQName, path);
735 moduleBuilder.enterNode(builder);
737 parseSchemaNodeArgs(ctx, builder);
738 parseConstraints(ctx, builder.getConstraints());
739 builder.setConfiguration(getConfig(ctx, builder, moduleName, line));
743 public void exitAnyxml_stmt(final YangParser.Anyxml_stmtContext ctx) {
744 moduleBuilder.exitNode();
745 exitLog("anyxml", removeNodeFromPath());
749 public void enterChoice_stmt(final YangParser.Choice_stmtContext ctx) {
750 final int line = ctx.getStart().getLine();
751 final String choiceName = stringFromNode(ctx);
752 enterLog("choice", choiceName, line);
754 QName choiceQName = new QName(namespace, revision, yangModelPrefix, choiceName);
755 addNodeToPath(choiceQName);
756 SchemaPath path = createActualSchemaPath(actualPath.peek());
758 ChoiceBuilder builder = moduleBuilder.addChoice(line, choiceQName, path);
759 moduleBuilder.enterNode(builder);
761 parseSchemaNodeArgs(ctx, builder);
762 parseConstraints(ctx, builder.getConstraints());
763 builder.setConfiguration(getConfig(ctx, builder, moduleName, line));
765 // set 'default' case
766 for (int i = 0; i < ctx.getChildCount(); i++) {
767 ParseTree child = ctx.getChild(i);
768 if (child instanceof Default_stmtContext) {
769 String defaultCase = stringFromNode(child);
770 builder.setDefaultCase(defaultCase);
777 public void exitChoice_stmt(final YangParser.Choice_stmtContext ctx) {
778 moduleBuilder.exitNode();
779 exitLog("choice", removeNodeFromPath());
783 public void enterCase_stmt(final YangParser.Case_stmtContext ctx) {
784 final int line = ctx.getStart().getLine();
785 final String caseName = stringFromNode(ctx);
786 enterLog("case", caseName, line);
788 QName caseQName = new QName(namespace, revision, yangModelPrefix, caseName);
789 addNodeToPath(caseQName);
790 SchemaPath path = createActualSchemaPath(actualPath.peek());
792 ChoiceCaseBuilder builder = moduleBuilder.addCase(line, caseQName, path);
793 moduleBuilder.enterNode(builder);
795 parseSchemaNodeArgs(ctx, builder);
796 parseConstraints(ctx, builder.getConstraints());
800 public void exitCase_stmt(final YangParser.Case_stmtContext ctx) {
801 moduleBuilder.exitNode();
802 exitLog("case", removeNodeFromPath());
806 public void enterNotification_stmt(final YangParser.Notification_stmtContext ctx) {
807 final int line = ctx.getStart().getLine();
808 final String notificationName = stringFromNode(ctx);
809 enterLog("notification", notificationName, line);
811 QName notificationQName = new QName(namespace, revision, yangModelPrefix, notificationName);
812 addNodeToPath(notificationQName);
813 SchemaPath path = createActualSchemaPath(actualPath.peek());
815 NotificationBuilder builder = moduleBuilder.addNotification(line, notificationQName, path);
816 moduleBuilder.enterNode(builder);
818 parseSchemaNodeArgs(ctx, builder);
822 public void exitNotification_stmt(final YangParser.Notification_stmtContext ctx) {
823 moduleBuilder.exitNode();
824 exitLog("notification", removeNodeFromPath());
829 public void enterIdentifier_stmt(final YangParser.Identifier_stmtContext ctx) {
830 handleUnknownNode(ctx.getStart().getLine(), ctx);
834 public void exitIdentifier_stmt(final YangParser.Identifier_stmtContext ctx) {
835 moduleBuilder.exitNode();
836 exitLog("unknown-node", removeNodeFromPath());
839 @Override public void enterUnknown_statement(final YangParser.Unknown_statementContext ctx) {
840 handleUnknownNode(ctx.getStart().getLine(), ctx);
843 @Override public void exitUnknown_statement(final YangParser.Unknown_statementContext ctx) {
844 moduleBuilder.exitNode();
845 exitLog("unknown-node", removeNodeFromPath());
848 @Override public void enterUnknown_statement2(final YangParser.Unknown_statement2Context ctx) {
849 handleUnknownNode(ctx.getStart().getLine(), ctx);
852 @Override public void exitUnknown_statement2(final YangParser.Unknown_statement2Context ctx) {
853 moduleBuilder.exitNode();
854 exitLog("unknown-node", removeNodeFromPath());
857 @Override public void enterUnknown_statement3(final YangParser.Unknown_statement3Context ctx) {
858 handleUnknownNode(ctx.getStart().getLine(), ctx);
861 @Override public void exitUnknown_statement3(final YangParser.Unknown_statement3Context ctx) {
862 moduleBuilder.exitNode();
863 exitLog("unknown-node", removeNodeFromPath());
867 public void enterRpc_stmt(final YangParser.Rpc_stmtContext ctx) {
868 final int line = ctx.getStart().getLine();
869 final String rpcName = stringFromNode(ctx);
870 enterLog("rpc", rpcName, line);
872 QName rpcQName = new QName(namespace, revision, yangModelPrefix, rpcName);
873 addNodeToPath(rpcQName);
874 SchemaPath path = createActualSchemaPath(actualPath.peek());
876 RpcDefinitionBuilder rpcBuilder = moduleBuilder.addRpc(line, rpcQName, path);
877 moduleBuilder.enterNode(rpcBuilder);
880 parseSchemaNodeArgs(ctx, rpcBuilder);
884 public void exitRpc_stmt(final YangParser.Rpc_stmtContext ctx) {
885 moduleBuilder.exitNode();
886 exitLog("rpc", removeNodeFromPath());
890 public void enterInput_stmt(final YangParser.Input_stmtContext ctx) {
891 final int line = ctx.getStart().getLine();
892 final String input = "input";
893 enterLog(input, input, line);
895 QName rpcQName = new QName(namespace, revision, yangModelPrefix, input);
896 addNodeToPath(rpcQName);
897 SchemaPath path = createActualSchemaPath(actualPath.peek());
899 ContainerSchemaNodeBuilder builder = moduleBuilder.addRpcInput(line, rpcQName, path);
900 moduleBuilder.enterNode(builder);
901 builder.setConfiguration(true);
903 parseSchemaNodeArgs(ctx, builder);
904 parseConstraints(ctx, builder.getConstraints());
908 public void exitInput_stmt(final YangParser.Input_stmtContext ctx) {
909 moduleBuilder.exitNode();
910 exitLog("input", removeNodeFromPath());
914 public void enterOutput_stmt(final YangParser.Output_stmtContext ctx) {
915 final int line = ctx.getStart().getLine();
916 final String output = "output";
917 enterLog(output, output, line);
919 QName rpcQName = new QName(namespace, revision, yangModelPrefix, output);
920 addNodeToPath(rpcQName);
921 SchemaPath path = createActualSchemaPath(actualPath.peek());
923 ContainerSchemaNodeBuilder builder = moduleBuilder.addRpcOutput(path, rpcQName, line);
924 moduleBuilder.enterNode(builder);
925 builder.setConfiguration(true);
927 parseSchemaNodeArgs(ctx, builder);
928 parseConstraints(ctx, builder.getConstraints());
932 public void exitOutput_stmt(final YangParser.Output_stmtContext ctx) {
933 moduleBuilder.exitNode();
934 exitLog("output", removeNodeFromPath());
938 public void enterFeature_stmt(final YangParser.Feature_stmtContext ctx) {
939 final int line = ctx.getStart().getLine();
940 final String featureName = stringFromNode(ctx);
941 enterLog("feature", featureName, line);
943 QName featureQName = new QName(namespace, revision, yangModelPrefix, featureName);
944 addNodeToPath(featureQName);
945 SchemaPath path = createActualSchemaPath(actualPath.peek());
947 FeatureBuilder featureBuilder = moduleBuilder.addFeature(line, featureQName, path);
948 moduleBuilder.enterNode(featureBuilder);
950 parseSchemaNodeArgs(ctx, featureBuilder);
954 public void exitFeature_stmt(final YangParser.Feature_stmtContext ctx) {
955 moduleBuilder.exitNode();
956 exitLog("feature", removeNodeFromPath());
960 public void enterDeviation_stmt(final YangParser.Deviation_stmtContext ctx) {
961 final int line = ctx.getStart().getLine();
962 final String targetPath = stringFromNode(ctx);
963 enterLog("deviation", targetPath, line);
965 String reference = null;
966 String deviate = null;
967 DeviationBuilder builder = moduleBuilder.addDeviation(line, targetPath);
968 moduleBuilder.enterNode(builder);
970 for (int i = 0; i < ctx.getChildCount(); i++) {
971 ParseTree child = ctx.getChild(i);
972 if (child instanceof Reference_stmtContext) {
973 reference = stringFromNode(child);
974 } else if (child instanceof Deviate_not_supported_stmtContext) {
975 deviate = stringFromNode(child);
976 } else if (child instanceof Deviate_add_stmtContext) {
977 deviate = stringFromNode(child);
978 } else if (child instanceof Deviate_replace_stmtContext) {
979 deviate = stringFromNode(child);
980 } else if (child instanceof Deviate_delete_stmtContext) {
981 deviate = stringFromNode(child);
984 builder.setReference(reference);
985 builder.setDeviate(deviate);
989 public void exitDeviation_stmt(final YangParser.Deviation_stmtContext ctx) {
990 moduleBuilder.exitNode();
991 exitLog("deviation");
995 public void enterIdentity_stmt(final YangParser.Identity_stmtContext ctx) {
996 final int line = ctx.getStart().getLine();
997 final String identityName = stringFromNode(ctx);
998 enterLog("identity", identityName, line);
1000 final QName identityQName = new QName(namespace, revision, yangModelPrefix, identityName);
1001 addNodeToPath(identityQName);
1002 SchemaPath path = createActualSchemaPath(actualPath.peek());
1004 IdentitySchemaNodeBuilder builder = moduleBuilder.addIdentity(identityQName, line, path);
1005 moduleBuilder.enterNode(builder);
1008 parseSchemaNodeArgs(ctx, builder);
1010 for (int i = 0; i < ctx.getChildCount(); i++) {
1011 ParseTree child = ctx.getChild(i);
1012 if (child instanceof Base_stmtContext) {
1013 String baseIdentityName = stringFromNode(child);
1014 builder.setBaseIdentityName(baseIdentityName);
1020 public void exitIdentity_stmt(final YangParser.Identity_stmtContext ctx) {
1021 moduleBuilder.exitNode();
1022 exitLog("identity", removeNodeFromPath());
1025 public ModuleBuilder getModuleBuilder() {
1026 return moduleBuilder;
1029 private void enterLog(final String p1, final String p2, final int line) {
1030 LOGGER.trace("entering {} {} ({})", p1, p2, line);
1033 private void exitLog(final String p1) {
1034 LOGGER.trace("exiting {}", p1);
1037 private void exitLog(final String p1, final QName p2) {
1038 LOGGER.trace("exiting {} {}", p1, p2.getLocalName());
1041 private void setLog(final String p1, final String p2) {
1042 LOGGER.trace("setting {} {}", p1, p2);
1045 private void handleUnknownNode(final int line, final ParseTree ctx) {
1046 final String nodeParameter = stringFromNode(ctx);
1047 enterLog("unknown-node", nodeParameter, line);
1050 final String nodeTypeStr = ctx.getChild(0).getText();
1051 final String[] splittedElement = nodeTypeStr.split(":");
1052 if (splittedElement.length == 1) {
1053 nodeType = new QName(namespace, revision, yangModelPrefix, splittedElement[0]);
1055 nodeType = new QName(namespace, revision, splittedElement[0], splittedElement[1]);
1060 if (!Strings.isNullOrEmpty(nodeParameter)) {
1061 String[] splittedName = nodeParameter.split(":");
1062 if (splittedName.length == 2) {
1063 qname = new QName(null, null, splittedName[0], splittedName[1]);
1065 qname = new QName(namespace, revision, yangModelPrefix, splittedName[0]);
1070 } catch (IllegalArgumentException e) {
1074 addNodeToPath(qname);
1075 SchemaPath path = createActualSchemaPath(actualPath.peek());
1077 UnknownSchemaNodeBuilderImpl builder = moduleBuilder.addUnknownSchemaNode(line, qname, path);
1078 builder.setNodeType(nodeType);
1079 builder.setNodeParameter(nodeParameter);
1082 parseSchemaNodeArgs(ctx, builder);
1083 moduleBuilder.enterNode(builder);