yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/impl/YangParserListenerImpl.java

   1 /*
   2  * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   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
   7  */
   8 package org.opendaylight.yangtools.yang.parser.impl;
   9
  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;
  26
  27 import com.google.common.base.Strings;
  28 import java.net.URI;
  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;
  97
  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";
 101
 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);
 108
 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;
 112
 113     private void addNodeToPath(final QName name) {
 114         actualPath.peek().push(name);
 115     }
 116
 117     private QName removeNodeFromPath() {
 118         return actualPath.peek().pop();
 119     }
 120
 121     public YangParserListenerImpl(final String sourcePath) {
 122         this.sourcePath = sourcePath;
 123     }
 124
 125     @Override
 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>());
 131
 132         moduleBuilder = new ModuleBuilder(moduleName, sourcePath);
 133
 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);
 142             } else {
 143                 if (description != null && reference != null) {
 144                     break;
 145                 }
 146             }
 147         }
 148         moduleBuilder.setDescription(description);
 149         moduleBuilder.setReference(reference);
 150     }
 151
 152     @Override
 153     public void exitModule_stmt(final YangParser.Module_stmtContext ctx) {
 154         exitLog("module");
 155         actualPath.pop();
 156     }
 157
 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>());
 163
 164         moduleBuilder = new ModuleBuilder(moduleName, true, sourcePath);
 165
 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);
 174             } else {
 175                 if (description != null && reference != null) {
 176                     break;
 177                 }
 178             }
 179         }
 180         moduleBuilder.setDescription(description);
 181         moduleBuilder.setReference(reference);
 182     }
 183
 184     @Override public void exitSubmodule_stmt(final YangParser.Submodule_stmtContext ctx) {
 185         exitLog("submodule");
 186         actualPath.pop();
 187     }
 188
 189     @Override public void enterBelongs_to_stmt(final YangParser.Belongs_to_stmtContext ctx) {
 190         moduleBuilder.setBelongsTo(stringFromNode(ctx));
 191     }
 192
 193     @Override
 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);
 211             }
 212         }
 213
 214         if (yangVersion == null) {
 215             yangVersion = "1";
 216         }
 217         moduleBuilder.setYangVersion(yangVersion);
 218     }
 219
 220     @Override
 221     public void exitModule_header_stmts(final Module_header_stmtsContext ctx) {
 222         exitLog("module_header");
 223     }
 224
 225     @Override
 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);
 246             }
 247         }
 248     }
 249
 250     @Override
 251     public void exitMeta_stmts(final YangParser.Meta_stmtsContext ctx) {
 252         exitLog("meta_stmt");
 253     }
 254
 255     @Override
 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);
 262             }
 263         }
 264     }
 265
 266     @Override
 267     public void exitRevision_stmts(final Revision_stmtsContext ctx) {
 268         exitLog("revisions");
 269     }
 270
 271     private void updateRevisionForRevisionStatement(final ParseTree treeNode) {
 272         final String revisionDateStr = stringFromNode(treeNode);
 273         try {
 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));
 283                     }
 284                 }
 285             }
 286         } catch (ParseException e) {
 287             final String message = "Failed to parse revision string: " + revisionDateStr;
 288             LOGGER.warn(message);
 289         }
 290     }
 291
 292     @Override
 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);
 297
 298         String importPrefix = null;
 299         Date importRevision = null;
 300
 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);
 305             }
 306             if (treeNode instanceof Revision_date_stmtContext) {
 307                 String importRevisionStr = stringFromNode(treeNode);
 308                 try {
 309                     importRevision = SIMPLE_DATE_FORMAT.parse(importRevisionStr);
 310                 } catch (ParseException e) {
 311                     LOGGER.warn("Failed to parse import revision-date at line " + line + ": " + importRevisionStr);
 312                 }
 313             }
 314         }
 315         moduleBuilder.addModuleImport(importName, importRevision, importPrefix);
 316         setLog("import", "(" + importName + "; " + importRevision + "; " + importPrefix + ")");
 317     }
 318
 319     @Override
 320     public void exitImport_stmt(final Import_stmtContext ctx) {
 321         exitLog("import");
 322     }
 323
 324     @Override
 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>());
 330
 331         AugmentationSchemaBuilder builder = moduleBuilder.addAugment(line, augmentPath, augmentOrder++);
 332
 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));
 343             }
 344         }
 345
 346         moduleBuilder.enterNode(builder);
 347     }
 348
 349     @Override
 350     public void exitAugment_stmt(final YangParser.Augment_stmtContext ctx) {
 351         moduleBuilder.exitNode();
 352         exitLog(AUGMENT_STR);
 353         actualPath.pop();
 354     }
 355
 356     @Override
 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());
 364
 365         ExtensionBuilder builder = moduleBuilder.addExtension(qname, line, path);
 366         parseSchemaNodeArgs(ctx, builder);
 367
 368         String argument = null;
 369         boolean yin = false;
 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);
 375                 break;
 376             }
 377         }
 378         builder.setArgument(argument);
 379         builder.setYinElement(yin);
 380
 381         moduleBuilder.enterNode(builder);
 382     }
 383
 384     @Override
 385     public void exitExtension_stmt(final YangParser.Extension_stmtContext ctx) {
 386         moduleBuilder.exitNode();
 387         exitLog("extension", removeNodeFromPath());
 388     }
 389
 390     @Override
 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());
 398
 399         TypeDefinitionBuilder builder = moduleBuilder.addTypedef(line, typedefQName, path);
 400         parseSchemaNodeArgs(ctx, builder);
 401         builder.setUnits(parseUnits(ctx));
 402         builder.setDefaultValue(parseDefault(ctx));
 403
 404         moduleBuilder.enterNode(builder);
 405     }
 406
 407     @Override
 408     public void exitTypedef_stmt(final YangParser.Typedef_stmtContext ctx) {
 409         moduleBuilder.exitNode();
 410         exitLog("typedef", removeNodeFromPath());
 411     }
 412
 413     @Override
 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);
 418
 419         final QName typeQName = parseQName(typeName);
 420
 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);
 426                 break;
 427             }
 428         }
 429
 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);
 439             } else {
 440                 QName qname;
 441                 switch (typeName) {
 442                     case "union":
 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);
 449                         break;
 450                     case "identityref":
 451                         qname = BaseTypes.constructQName("identityref");
 452                         addNodeToPath(qname);
 453                         SchemaPath path = createActualSchemaPath(actualPath.peek());
 454                         moduleBuilder.addIdentityrefType(line, path, getIdentityrefBase(typeBody));
 455                         break;
 456                     default:
 457                         type = parseTypeWithBody(typeName, typeBody, actualPath.peek(), namespace, revision,
 458                                 yangModelPrefix, moduleBuilder.getActualNode());
 459                         moduleBuilder.setType(type);
 460                         addNodeToPath(type.getQName());
 461                 }
 462             }
 463         } else {
 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());
 470         }
 471
 472     }
 473
 474     private QName parseQName(final String typeName) {
 475         QName typeQName;
 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);
 482             } else {
 483                 typeQName = new QName(null, null, prefix, name);
 484             }
 485         } else {
 486             typeQName = new QName(namespace, revision, yangModelPrefix, typeName);
 487         }
 488         return typeQName;
 489     }
 490
 491     @Override
 492     public void exitType_stmt(final YangParser.Type_stmtContext ctx) {
 493         final String typeName = stringFromNode(ctx);
 494         if ("union".equals(typeName)) {
 495             moduleBuilder.exitNode();
 496         }
 497         exitLog("type", removeNodeFromPath());
 498     }
 499
 500     @Override
 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());
 508
 509         GroupingBuilder builder = moduleBuilder.addGrouping(ctx.getStart().getLine(), groupQName, path);
 510         parseSchemaNodeArgs(ctx, builder);
 511
 512         moduleBuilder.enterNode(builder);
 513     }
 514
 515     @Override
 516     public void exitGrouping_stmt(final YangParser.Grouping_stmtContext ctx) {
 517         moduleBuilder.exitNode();
 518         exitLog("grouping", removeNodeFromPath());
 519     }
 520
 521     @Override
 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);
 526
 527         QName containerQName = new QName(namespace, revision, yangModelPrefix, containerName);
 528         addNodeToPath(containerQName);
 529         SchemaPath path = createActualSchemaPath(actualPath.peek());
 530
 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));
 535
 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);
 540                 break;
 541             }
 542         }
 543
 544         moduleBuilder.enterNode(builder);
 545     }
 546
 547     @Override
 548     public void exitContainer_stmt(final Container_stmtContext ctx) {
 549         moduleBuilder.exitNode();
 550         exitLog("container", removeNodeFromPath());
 551     }
 552
 553     @Override
 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);
 558
 559         QName leafQName = new QName(namespace, revision, yangModelPrefix, leafName);
 560         addNodeToPath(leafQName);
 561         SchemaPath path = createActualSchemaPath(actualPath.peek());
 562
 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));
 567
 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);
 576             }
 577         }
 578         builder.setDefaultStr(defaultStr);
 579         builder.setUnits(unitsStr);
 580
 581         moduleBuilder.enterNode(builder);
 582     }
 583
 584     @Override
 585     public void exitLeaf_stmt(final YangParser.Leaf_stmtContext ctx) {
 586         moduleBuilder.exitNode();
 587         exitLog("leaf", removeNodeFromPath());
 588     }
 589
 590     @Override
 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);
 595
 596         UsesNodeBuilder builder = moduleBuilder.addUsesNode(line, groupingPathStr);
 597
 598         moduleBuilder.enterNode(builder);
 599     }
 600
 601     @Override
 602     public void exitUses_stmt(final YangParser.Uses_stmtContext ctx) {
 603         moduleBuilder.exitNode();
 604         exitLog("uses");
 605     }
 606
 607     @Override
 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);
 613
 614         AugmentationSchemaBuilder builder = moduleBuilder.addAugment(line, augmentPath, augmentOrder++);
 615
 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));
 626             }
 627         }
 628
 629         moduleBuilder.enterNode(builder);
 630     }
 631
 632     @Override
 633     public void exitUses_augment_stmt(final YangParser.Uses_augment_stmtContext ctx) {
 634         moduleBuilder.exitNode();
 635         exitLog(AUGMENT_STR);
 636         actualPath.pop();
 637     }
 638
 639     @Override
 640     public void enterRefine_stmt(final YangParser.Refine_stmtContext ctx) {
 641         final String refineString = stringFromNode(ctx);
 642         enterLog("refine", refineString, ctx.getStart().getLine());
 643
 644         RefineHolderImpl refine = parseRefine(ctx, moduleName);
 645         moduleBuilder.addRefine(refine);
 646         moduleBuilder.enterNode(refine);
 647     }
 648
 649     @Override
 650     public void exitRefine_stmt(final YangParser.Refine_stmtContext ctx) {
 651         moduleBuilder.exitNode();
 652         exitLog("refine");
 653     }
 654
 655     @Override
 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());
 663
 664         LeafListSchemaNodeBuilder builder = moduleBuilder.addLeafListNode(line, leafListQName, path);
 665         moduleBuilder.enterNode(builder);
 666
 667         parseSchemaNodeArgs(ctx, builder);
 668         parseConstraints(ctx, builder.getConstraints());
 669         builder.setConfiguration(getConfig(ctx, builder, moduleName, ctx.getStart().getLine()));
 670
 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);
 677                 break;
 678             }
 679         }
 680     }
 681
 682     @Override
 683     public void exitLeaf_list_stmt(final YangParser.Leaf_list_stmtContext ctx) {
 684         moduleBuilder.exitNode();
 685         exitLog("leaf-list", removeNodeFromPath());
 686     }
 687
 688     @Override
 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);
 693
 694         QName listQName = new QName(namespace, revision, yangModelPrefix, listName);
 695         addNodeToPath(listQName);
 696         SchemaPath path = createActualSchemaPath(actualPath.peek());
 697
 698         ListSchemaNodeBuilder builder = moduleBuilder.addListNode(line, listQName, path);
 699         moduleBuilder.enterNode(builder);
 700
 701         parseSchemaNodeArgs(ctx, builder);
 702         parseConstraints(ctx, builder.getConstraints());
 703         builder.setConfiguration(getConfig(ctx, builder, moduleName, line));
 704
 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);
 714             }
 715         }
 716     }
 717
 718     @Override
 719     public void exitList_stmt(final List_stmtContext ctx) {
 720         moduleBuilder.exitNode();
 721         exitLog("list", removeNodeFromPath());
 722     }
 723
 724     @Override
 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);
 729
 730         QName anyXmlQName = new QName(namespace, revision, yangModelPrefix, anyXmlName);
 731         addNodeToPath(anyXmlQName);
 732         SchemaPath path = createActualSchemaPath(actualPath.peek());
 733
 734         AnyXmlBuilder builder = moduleBuilder.addAnyXml(line, anyXmlQName, path);
 735         moduleBuilder.enterNode(builder);
 736
 737         parseSchemaNodeArgs(ctx, builder);
 738         parseConstraints(ctx, builder.getConstraints());
 739         builder.setConfiguration(getConfig(ctx, builder, moduleName, line));
 740     }
 741
 742     @Override
 743     public void exitAnyxml_stmt(final YangParser.Anyxml_stmtContext ctx) {
 744         moduleBuilder.exitNode();
 745         exitLog("anyxml", removeNodeFromPath());
 746     }
 747
 748     @Override
 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);
 753
 754         QName choiceQName = new QName(namespace, revision, yangModelPrefix, choiceName);
 755         addNodeToPath(choiceQName);
 756         SchemaPath path = createActualSchemaPath(actualPath.peek());
 757
 758         ChoiceBuilder builder = moduleBuilder.addChoice(line, choiceQName, path);
 759         moduleBuilder.enterNode(builder);
 760
 761         parseSchemaNodeArgs(ctx, builder);
 762         parseConstraints(ctx, builder.getConstraints());
 763         builder.setConfiguration(getConfig(ctx, builder, moduleName, line));
 764
 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);
 771                 break;
 772             }
 773         }
 774     }
 775
 776     @Override
 777     public void exitChoice_stmt(final YangParser.Choice_stmtContext ctx) {
 778         moduleBuilder.exitNode();
 779         exitLog("choice", removeNodeFromPath());
 780     }
 781
 782     @Override
 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);
 787
 788         QName caseQName = new QName(namespace, revision, yangModelPrefix, caseName);
 789         addNodeToPath(caseQName);
 790         SchemaPath path = createActualSchemaPath(actualPath.peek());
 791
 792         ChoiceCaseBuilder builder = moduleBuilder.addCase(line, caseQName, path);
 793         moduleBuilder.enterNode(builder);
 794
 795         parseSchemaNodeArgs(ctx, builder);
 796         parseConstraints(ctx, builder.getConstraints());
 797     }
 798
 799     @Override
 800     public void exitCase_stmt(final YangParser.Case_stmtContext ctx) {
 801         moduleBuilder.exitNode();
 802         exitLog("case", removeNodeFromPath());
 803     }
 804
 805     @Override
 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);
 810
 811         QName notificationQName = new QName(namespace, revision, yangModelPrefix, notificationName);
 812         addNodeToPath(notificationQName);
 813         SchemaPath path = createActualSchemaPath(actualPath.peek());
 814
 815         NotificationBuilder builder = moduleBuilder.addNotification(line, notificationQName, path);
 816         moduleBuilder.enterNode(builder);
 817
 818         parseSchemaNodeArgs(ctx, builder);
 819     }
 820
 821     @Override
 822     public void exitNotification_stmt(final YangParser.Notification_stmtContext ctx) {
 823         moduleBuilder.exitNode();
 824         exitLog("notification", removeNodeFromPath());
 825     }
 826
 827     // Unknown nodes
 828     @Override
 829     public void enterIdentifier_stmt(final YangParser.Identifier_stmtContext ctx) {
 830         handleUnknownNode(ctx.getStart().getLine(), ctx);
 831     }
 832
 833     @Override
 834     public void exitIdentifier_stmt(final YangParser.Identifier_stmtContext ctx) {
 835         moduleBuilder.exitNode();
 836         exitLog("unknown-node", removeNodeFromPath());
 837     }
 838
 839     @Override public void enterUnknown_statement(final YangParser.Unknown_statementContext ctx) {
 840         handleUnknownNode(ctx.getStart().getLine(), ctx);
 841     }
 842
 843     @Override public void exitUnknown_statement(final YangParser.Unknown_statementContext ctx) {
 844         moduleBuilder.exitNode();
 845         exitLog("unknown-node", removeNodeFromPath());
 846     }
 847
 848     @Override public void enterUnknown_statement2(final YangParser.Unknown_statement2Context ctx) {
 849         handleUnknownNode(ctx.getStart().getLine(), ctx);
 850     }
 851
 852     @Override public void exitUnknown_statement2(final YangParser.Unknown_statement2Context ctx) {
 853         moduleBuilder.exitNode();
 854         exitLog("unknown-node", removeNodeFromPath());
 855     }
 856
 857     @Override public void enterUnknown_statement3(final YangParser.Unknown_statement3Context ctx) {
 858         handleUnknownNode(ctx.getStart().getLine(), ctx);
 859     }
 860
 861     @Override public void exitUnknown_statement3(final YangParser.Unknown_statement3Context ctx) {
 862         moduleBuilder.exitNode();
 863         exitLog("unknown-node", removeNodeFromPath());
 864     }
 865
 866     @Override
 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);
 871
 872         QName rpcQName = new QName(namespace, revision, yangModelPrefix, rpcName);
 873         addNodeToPath(rpcQName);
 874         SchemaPath path = createActualSchemaPath(actualPath.peek());
 875
 876         RpcDefinitionBuilder rpcBuilder = moduleBuilder.addRpc(line, rpcQName, path);
 877         moduleBuilder.enterNode(rpcBuilder);
 878
 879
 880         parseSchemaNodeArgs(ctx, rpcBuilder);
 881     }
 882
 883     @Override
 884     public void exitRpc_stmt(final YangParser.Rpc_stmtContext ctx) {
 885         moduleBuilder.exitNode();
 886         exitLog("rpc", removeNodeFromPath());
 887     }
 888
 889     @Override
 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);
 894
 895         QName rpcQName = new QName(namespace, revision, yangModelPrefix, input);
 896         addNodeToPath(rpcQName);
 897         SchemaPath path = createActualSchemaPath(actualPath.peek());
 898
 899         ContainerSchemaNodeBuilder builder = moduleBuilder.addRpcInput(line, rpcQName, path);
 900         moduleBuilder.enterNode(builder);
 901         builder.setConfiguration(true);
 902
 903         parseSchemaNodeArgs(ctx, builder);
 904         parseConstraints(ctx, builder.getConstraints());
 905     }
 906
 907     @Override
 908     public void exitInput_stmt(final YangParser.Input_stmtContext ctx) {
 909         moduleBuilder.exitNode();
 910         exitLog("input", removeNodeFromPath());
 911     }
 912
 913     @Override
 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);
 918
 919         QName rpcQName = new QName(namespace, revision, yangModelPrefix, output);
 920         addNodeToPath(rpcQName);
 921         SchemaPath path = createActualSchemaPath(actualPath.peek());
 922
 923         ContainerSchemaNodeBuilder builder = moduleBuilder.addRpcOutput(path, rpcQName, line);
 924         moduleBuilder.enterNode(builder);
 925         builder.setConfiguration(true);
 926
 927         parseSchemaNodeArgs(ctx, builder);
 928         parseConstraints(ctx, builder.getConstraints());
 929     }
 930
 931     @Override
 932     public void exitOutput_stmt(final YangParser.Output_stmtContext ctx) {
 933         moduleBuilder.exitNode();
 934         exitLog("output", removeNodeFromPath());
 935     }
 936
 937     @Override
 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);
 942
 943         QName featureQName = new QName(namespace, revision, yangModelPrefix, featureName);
 944         addNodeToPath(featureQName);
 945         SchemaPath path = createActualSchemaPath(actualPath.peek());
 946
 947         FeatureBuilder featureBuilder = moduleBuilder.addFeature(line, featureQName, path);
 948         moduleBuilder.enterNode(featureBuilder);
 949
 950         parseSchemaNodeArgs(ctx, featureBuilder);
 951     }
 952
 953     @Override
 954     public void exitFeature_stmt(final YangParser.Feature_stmtContext ctx) {
 955         moduleBuilder.exitNode();
 956         exitLog("feature", removeNodeFromPath());
 957     }
 958
 959     @Override
 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);
 964
 965         String reference = null;
 966         String deviate = null;
 967         DeviationBuilder builder = moduleBuilder.addDeviation(line, targetPath);
 968         moduleBuilder.enterNode(builder);
 969
 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);
 982             }
 983         }
 984         builder.setReference(reference);
 985         builder.setDeviate(deviate);
 986     }
 987
 988     @Override
 989     public void exitDeviation_stmt(final YangParser.Deviation_stmtContext ctx) {
 990         moduleBuilder.exitNode();
 991         exitLog("deviation");
 992     }
 993
 994     @Override
 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);
 999
1000         final QName identityQName = new QName(namespace, revision, yangModelPrefix, identityName);
1001         addNodeToPath(identityQName);
1002         SchemaPath path = createActualSchemaPath(actualPath.peek());
1003
1004         IdentitySchemaNodeBuilder builder = moduleBuilder.addIdentity(identityQName, line, path);
1005         moduleBuilder.enterNode(builder);
1006
1007
1008         parseSchemaNodeArgs(ctx, builder);
1009
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);
1015             }
1016         }
1017     }
1018
1019     @Override
1020     public void exitIdentity_stmt(final YangParser.Identity_stmtContext ctx) {
1021         moduleBuilder.exitNode();
1022         exitLog("identity", removeNodeFromPath());
1023     }
1024
1025     public ModuleBuilder getModuleBuilder() {
1026         return moduleBuilder;
1027     }
1028
1029     private void enterLog(final String p1, final String p2, final int line) {
1030         LOGGER.trace("entering {} {} ({})", p1, p2, line);
1031     }
1032
1033     private void exitLog(final String p1) {
1034         LOGGER.trace("exiting {}", p1);
1035     }
1036
1037     private void exitLog(final String p1, final QName p2) {
1038         LOGGER.trace("exiting {} {}", p1, p2.getLocalName());
1039     }
1040
1041     private void setLog(final String p1, final String p2) {
1042         LOGGER.trace("setting {} {}", p1, p2);
1043     }
1044
1045     private void handleUnknownNode(final int line, final ParseTree ctx) {
1046         final String nodeParameter = stringFromNode(ctx);
1047         enterLog("unknown-node", nodeParameter, line);
1048
1049         QName nodeType;
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]);
1054         } else {
1055             nodeType = new QName(namespace, revision, splittedElement[0], splittedElement[1]);
1056         }
1057
1058         QName qname;
1059         try {
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]);
1064                 } else {
1065                     qname = new QName(namespace, revision, yangModelPrefix, splittedName[0]);
1066                 }
1067             } else {
1068                 qname = nodeType;
1069             }
1070         } catch (IllegalArgumentException e) {
1071             qname = nodeType;
1072
1073         }
1074         addNodeToPath(qname);
1075         SchemaPath path = createActualSchemaPath(actualPath.peek());
1076
1077         UnknownSchemaNodeBuilderImpl builder = moduleBuilder.addUnknownSchemaNode(line, qname, path);
1078         builder.setNodeType(nodeType);
1079         builder.setNodeParameter(nodeParameter);
1080
1081
1082         parseSchemaNodeArgs(ctx, builder);
1083         moduleBuilder.enterNode(builder);
1084     }
1085
1086 }