opendaylight/sal/yang-prototype/code-generator/yang-model-parser-impl/src/main/java/org/opendaylight/controller/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.controller.yang.parser.impl;
   9
  10 import static org.opendaylight.controller.yang.parser.util.YangModelBuilderUtil.*;
  11
  12 import java.net.URI;
  13 import java.text.DateFormat;
  14 import java.text.ParseException;
  15 import java.text.SimpleDateFormat;
  16 import java.util.ArrayList;
  17 import java.util.Date;
  18 import java.util.List;
  19 import java.util.Stack;
  20
  21 import org.antlr.v4.runtime.tree.ParseTree;
  22 import org.opendaylight.controller.antlrv4.code.gen.YangParser;
  23 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Argument_stmtContext;
  24 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Base_stmtContext;
  25 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Contact_stmtContext;
  26 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Container_stmtContext;
  27 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Default_stmtContext;
  28 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Description_stmtContext;
  29 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Deviate_add_stmtContext;
  30 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Deviate_delete_stmtContext;
  31 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Deviate_not_supported_stmtContext;
  32 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Deviate_replace_stmtContext;
  33 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Import_stmtContext;
  34 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Key_stmtContext;
  35 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Leaf_list_stmtContext;
  36 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Leaf_stmtContext;
  37 import org.opendaylight.controller.antlrv4.code.gen.YangParser.List_stmtContext;
  38 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Module_header_stmtsContext;
  39 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Namespace_stmtContext;
  40 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Ordered_by_stmtContext;
  41 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Organization_stmtContext;
  42 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Prefix_stmtContext;
  43 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Presence_stmtContext;
  44 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Reference_stmtContext;
  45 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Revision_date_stmtContext;
  46 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Revision_stmtContext;
  47 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Revision_stmtsContext;
  48 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Status_stmtContext;
  49 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Type_body_stmtsContext;
  50 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Units_stmtContext;
  51 import org.opendaylight.controller.antlrv4.code.gen.YangParser.When_stmtContext;
  52 import org.opendaylight.controller.antlrv4.code.gen.YangParser.Yang_version_stmtContext;
  53 import org.opendaylight.controller.antlrv4.code.gen.YangParserBaseListener;
  54 import org.opendaylight.controller.yang.common.QName;
  55 import org.opendaylight.controller.yang.model.api.SchemaPath;
  56 import org.opendaylight.controller.yang.model.api.Status;
  57 import org.opendaylight.controller.yang.model.api.TypeDefinition;
  58 import org.opendaylight.controller.yang.model.util.YangTypesConverter;
  59 import org.opendaylight.controller.yang.parser.builder.api.AugmentationSchemaBuilder;
  60 import org.opendaylight.controller.yang.parser.builder.api.GroupingBuilder;
  61 import org.opendaylight.controller.yang.parser.builder.impl.AnyXmlBuilder;
  62 import org.opendaylight.controller.yang.parser.builder.impl.ChoiceBuilder;
  63 import org.opendaylight.controller.yang.parser.builder.impl.ChoiceCaseBuilder;
  64 import org.opendaylight.controller.yang.parser.builder.impl.ContainerSchemaNodeBuilder;
  65 import org.opendaylight.controller.yang.parser.builder.impl.DeviationBuilder;
  66 import org.opendaylight.controller.yang.parser.builder.impl.ExtensionBuilder;
  67 import org.opendaylight.controller.yang.parser.builder.impl.FeatureBuilder;
  68 import org.opendaylight.controller.yang.parser.builder.impl.IdentitySchemaNodeBuilder;
  69 import org.opendaylight.controller.yang.parser.builder.impl.LeafListSchemaNodeBuilder;
  70 import org.opendaylight.controller.yang.parser.builder.impl.LeafSchemaNodeBuilder;
  71 import org.opendaylight.controller.yang.parser.builder.impl.ListSchemaNodeBuilder;
  72 import org.opendaylight.controller.yang.parser.builder.impl.ModuleBuilder;
  73 import org.opendaylight.controller.yang.parser.builder.impl.NotificationBuilder;
  74 import org.opendaylight.controller.yang.parser.builder.impl.RpcDefinitionBuilder;
  75 import org.opendaylight.controller.yang.parser.builder.impl.TypedefBuilder;
  76 import org.opendaylight.controller.yang.parser.builder.impl.UnknownSchemaNodeBuilder;
  77 import org.opendaylight.controller.yang.parser.util.RefineHolder;
  78 import org.slf4j.Logger;
  79 import org.slf4j.LoggerFactory;
  80
  81 public final class YangParserListenerImpl extends YangParserBaseListener {
  82
  83     private static final Logger logger = LoggerFactory
  84             .getLogger(YangParserListenerImpl.class);
  85
  86     private ModuleBuilder moduleBuilder;
  87
  88     private String moduleName;
  89     private URI namespace;
  90     private String yangModelPrefix;
  91     private Date revision = new Date(0L);
  92
  93     public final static DateFormat simpleDateFormat = new SimpleDateFormat(
  94             "yyyy-MM-dd");
  95     private final Stack<String> actualPath = new Stack<String>();
  96
  97     @Override
  98     public void enterModule_stmt(YangParser.Module_stmtContext ctx) {
  99         moduleName = stringFromNode(ctx);
 100         actualPath.push(moduleName);
 101         moduleBuilder = new ModuleBuilder(moduleName);
 102
 103         String description = null;
 104         String reference = null;
 105
 106         for (int i = 0; i < ctx.getChildCount(); i++) {
 107             ParseTree child = ctx.getChild(i);
 108             if (child instanceof Description_stmtContext) {
 109                 description = stringFromNode(child);
 110             } else if (child instanceof Reference_stmtContext) {
 111                 reference = stringFromNode(child);
 112             } else {
 113                 if (description != null && reference != null) {
 114                     break;
 115                 }
 116             }
 117         }
 118         moduleBuilder.setDescription(description);
 119         moduleBuilder.setReference(reference);
 120     }
 121
 122     @Override
 123     public void exitModule_stmt(YangParser.Module_stmtContext ctx) {
 124         final String moduleName = actualPath.pop();
 125         logger.debug("Exiting module " + moduleName);
 126     }
 127
 128     @Override
 129     public void enterModule_header_stmts(final Module_header_stmtsContext ctx) {
 130         super.enterModule_header_stmts(ctx);
 131
 132         String yangVersion = null;
 133         for (int i = 0; i < ctx.getChildCount(); ++i) {
 134             final ParseTree treeNode = ctx.getChild(i);
 135             if (treeNode instanceof Namespace_stmtContext) {
 136                 final String namespaceStr = stringFromNode(treeNode);
 137                 namespace = URI.create(namespaceStr);
 138                 moduleBuilder.setNamespace(namespace);
 139             } else if (treeNode instanceof Prefix_stmtContext) {
 140                 yangModelPrefix = stringFromNode(treeNode);
 141                 moduleBuilder.setPrefix(yangModelPrefix);
 142             } else if (treeNode instanceof Yang_version_stmtContext) {
 143                 yangVersion = stringFromNode(treeNode);
 144             }
 145         }
 146
 147         if (yangVersion == null) {
 148             yangVersion = "1";
 149         }
 150         moduleBuilder.setYangVersion(yangVersion);
 151     }
 152
 153     @Override
 154     public void enterMeta_stmts(YangParser.Meta_stmtsContext ctx) {
 155         for (int i = 0; i < ctx.getChildCount(); i++) {
 156             ParseTree child = ctx.getChild(i);
 157             if (child instanceof Organization_stmtContext) {
 158                 final String organization = stringFromNode(child);
 159                 moduleBuilder.setOrganization(organization);
 160             } else if (child instanceof Contact_stmtContext) {
 161                 final String contact = stringFromNode(child);
 162                 moduleBuilder.setContact(contact);
 163             } else if (child instanceof Description_stmtContext) {
 164                 final String description = stringFromNode(child);
 165                 moduleBuilder.setDescription(description);
 166             } else if (child instanceof Reference_stmtContext) {
 167                 final String reference = stringFromNode(child);
 168                 moduleBuilder.setReference(reference);
 169             }
 170         }
 171     }
 172
 173     @Override
 174     public void exitSubmodule_header_stmts(
 175             YangParser.Submodule_header_stmtsContext ctx) {
 176         final String submodule = actualPath.pop();
 177         logger.debug("exiting submodule " + submodule);
 178     }
 179
 180     @Override
 181     public void enterRevision_stmts(Revision_stmtsContext ctx) {
 182         if (ctx != null) {
 183             for (int i = 0; i < ctx.getChildCount(); ++i) {
 184                 final ParseTree treeNode = ctx.getChild(i);
 185                 if (treeNode instanceof Revision_stmtContext) {
 186                     updateRevisionForRevisionStatement(treeNode);
 187                 }
 188             }
 189         }
 190     }
 191
 192     private void updateRevisionForRevisionStatement(final ParseTree treeNode) {
 193         final String revisionDateStr = stringFromNode(treeNode);
 194         try {
 195             final Date revision = simpleDateFormat.parse(revisionDateStr);
 196             if ((revision != null) && (this.revision.compareTo(revision) < 0)) {
 197                 this.revision = revision;
 198                 moduleBuilder.setRevision(this.revision);
 199                 for (int i = 0; i < treeNode.getChildCount(); ++i) {
 200                     ParseTree child = treeNode.getChild(i);
 201                     if (child instanceof Reference_stmtContext) {
 202                         moduleBuilder.setReference(stringFromNode(child));
 203                     }
 204                 }
 205             }
 206         } catch (ParseException e) {
 207             final String message = "Failed to parse revision string: "
 208                     + revisionDateStr;
 209             logger.warn(message);
 210         }
 211     }
 212
 213     @Override
 214     public void enterImport_stmt(Import_stmtContext ctx) {
 215         final String importName = stringFromNode(ctx);
 216         String importPrefix = null;
 217         Date importRevision = null;
 218
 219         for (int i = 0; i < ctx.getChildCount(); ++i) {
 220             final ParseTree treeNode = ctx.getChild(i);
 221             if (treeNode instanceof Prefix_stmtContext) {
 222                 importPrefix = stringFromNode(treeNode);
 223             }
 224             if (treeNode instanceof Revision_date_stmtContext) {
 225                 String importRevisionStr = stringFromNode(treeNode);
 226                 try {
 227                     importRevision = simpleDateFormat.parse(importRevisionStr);
 228                 } catch (ParseException e) {
 229                     logger.warn("Failed to parse import revision-date: "
 230                             + importRevisionStr);
 231                 }
 232             }
 233         }
 234         moduleBuilder.addModuleImport(importName, importRevision, importPrefix);
 235     }
 236
 237     @Override
 238     public void enterAugment_stmt(YangParser.Augment_stmtContext ctx) {
 239         final String augmentPath = stringFromNode(ctx);
 240         AugmentationSchemaBuilder builder = moduleBuilder.addAugment(
 241                 augmentPath, actualPath, ctx.getStart().getLine());
 242         updatePath(augmentPath);
 243
 244         for (int i = 0; i < ctx.getChildCount(); i++) {
 245             ParseTree child = ctx.getChild(i);
 246             if (child instanceof Description_stmtContext) {
 247                 String desc = stringFromNode(child);
 248                 builder.setDescription(desc);
 249             } else if (child instanceof Reference_stmtContext) {
 250                 String ref = stringFromNode(child);
 251                 builder.setReference(ref);
 252             } else if (child instanceof Status_stmtContext) {
 253                 Status status = parseStatus((Status_stmtContext) child);
 254                 builder.setStatus(status);
 255             } else if (child instanceof When_stmtContext) {
 256                 String when = stringFromNode(child);
 257                 builder.addWhenCondition(when);
 258             }
 259         }
 260     }
 261
 262     @Override
 263     public void exitAugment_stmt(YangParser.Augment_stmtContext ctx) {
 264         final String augment = actualPath.pop();
 265         logger.debug("exiting augment " + augment);
 266     }
 267
 268     @Override
 269     public void enterExtension_stmt(YangParser.Extension_stmtContext ctx) {
 270         final String extName = stringFromNode(ctx);
 271         QName qname = new QName(namespace, revision, yangModelPrefix, extName);
 272         ExtensionBuilder builder = moduleBuilder.addExtension(qname, ctx
 273                 .getStart().getLine());
 274         parseSchemaNodeArgs(ctx, builder);
 275
 276         String argument = null;
 277         boolean yin = false;
 278         for (int i = 0; i < ctx.getChildCount(); i++) {
 279             ParseTree child = ctx.getChild(i);
 280             if (child instanceof Argument_stmtContext) {
 281                 argument = stringFromNode(child);
 282                 yin = parseYinValue((Argument_stmtContext) child);
 283                 break;
 284             }
 285         }
 286         builder.setArgument(argument);
 287         builder.setYinElement(yin);
 288     }
 289
 290     @Override
 291     public void enterTypedef_stmt(YangParser.Typedef_stmtContext ctx) {
 292         final String typedefName = stringFromNode(ctx);
 293         QName typedefQName = new QName(namespace, revision, yangModelPrefix,
 294                 typedefName);
 295         TypedefBuilder builder = moduleBuilder.addTypedef(typedefQName,
 296                 actualPath, ctx.getStart().getLine());
 297         updatePath(typedefName);
 298
 299         builder.setPath(createActualSchemaPath(actualPath, namespace, revision,
 300                 yangModelPrefix));
 301         parseSchemaNodeArgs(ctx, builder);
 302         builder.setUnits(parseUnits(ctx));
 303     }
 304
 305     @Override
 306     public void exitTypedef_stmt(YangParser.Typedef_stmtContext ctx) {
 307         final String actContainer = actualPath.pop();
 308         logger.debug("exiting " + actContainer);
 309     }
 310
 311     @Override
 312     public void enterType_stmt(YangParser.Type_stmtContext ctx) {
 313         final String typeName = stringFromNode(ctx);
 314         final int line = ctx.getStart().getLine();
 315         final QName typeQName = parseQName(typeName);
 316
 317         TypeDefinition<?> type = null;
 318         Type_body_stmtsContext typeBody = null;
 319         for (int i = 0; i < ctx.getChildCount(); i++) {
 320             if (ctx.getChild(i) instanceof Type_body_stmtsContext) {
 321                 typeBody = (Type_body_stmtsContext) ctx.getChild(i);
 322                 break;
 323             }
 324         }
 325
 326         // if this is base yang type...
 327         if (YangTypesConverter.isBaseYangType(typeName)) {
 328             if (typeBody == null) {
 329                 // check for types which must have body
 330                 checkMissingBody(typeName, moduleName, line);
 331                 // if there are no constraints, just grab default base yang type
 332                 type = YangTypesConverter.javaTypeForBaseYangType(actualPath,
 333                         namespace, revision, typeName);
 334                 moduleBuilder.setType(type, actualPath);
 335             } else {
 336                 if ("union".equals(typeName)) {
 337                     moduleBuilder.addUnionType(actualPath, namespace, revision,
 338                             line);
 339                 } else if ("identityref".equals(typeName)) {
 340                     SchemaPath path = createActualSchemaPath(actualPath,
 341                             namespace, revision, yangModelPrefix);
 342                     moduleBuilder.addIdentityrefType(
 343                             getIdentityrefBase(typeBody), actualPath, path,
 344                             line);
 345                 } else {
 346                     List<String> typePath = new ArrayList<String>(actualPath);
 347                     typePath.remove(0);
 348                     type = parseTypeBody(typeName, typeBody, typePath,
 349                             namespace, revision, yangModelPrefix);
 350                     moduleBuilder.setType(type, actualPath);
 351                 }
 352             }
 353         } else {
 354             type = parseUnknownTypeBody(typeQName, typeBody);
 355             // mark parent node of this type statement as dirty
 356             moduleBuilder.addDirtyNode(actualPath);
 357             moduleBuilder.setType(type, actualPath);
 358         }
 359
 360         updatePath(typeName);
 361     }
 362
 363     private QName parseQName(String typeName) {
 364         QName typeQName;
 365         if (typeName.contains(":")) {
 366             String[] splittedName = typeName.split(":");
 367             String prefix = splittedName[0];
 368             String name = splittedName[1];
 369             if (prefix.equals(yangModelPrefix)) {
 370                 typeQName = new QName(namespace, revision, prefix, name);
 371             } else {
 372                 typeQName = new QName(null, null, prefix, name);
 373             }
 374         } else {
 375             typeQName = new QName(namespace, revision, yangModelPrefix,
 376                     typeName);
 377         }
 378         return typeQName;
 379     }
 380
 381     @Override
 382     public void exitType_stmt(YangParser.Type_stmtContext ctx) {
 383         final String actContainer = actualPath.pop();
 384         logger.debug("exiting " + actContainer);
 385     }
 386
 387     @Override
 388     public void enterGrouping_stmt(YangParser.Grouping_stmtContext ctx) {
 389         final String groupName = stringFromNode(ctx);
 390         QName groupQName = new QName(namespace, revision, yangModelPrefix,
 391                 groupName);
 392         GroupingBuilder groupBuilder = moduleBuilder.addGrouping(groupQName,
 393                 actualPath, ctx.getStart().getLine());
 394         updatePath("grouping");
 395         updatePath(groupName);
 396         parseSchemaNodeArgs(ctx, groupBuilder);
 397     }
 398
 399     @Override
 400     public void exitGrouping_stmt(YangParser.Grouping_stmtContext ctx) {
 401         String actContainer = actualPath.pop();
 402         actContainer += "-" + actualPath.pop();
 403         logger.debug("exiting " + actContainer);
 404     }
 405
 406     @Override
 407     public void enterContainer_stmt(Container_stmtContext ctx) {
 408         final String containerName = stringFromNode(ctx);
 409         QName containerQName = new QName(namespace, revision, yangModelPrefix,
 410                 containerName);
 411         ContainerSchemaNodeBuilder containerBuilder = moduleBuilder
 412                 .addContainerNode(containerQName, actualPath, ctx.getStart().getLine());
 413         updatePath(containerName);
 414
 415         containerBuilder.setPath(createActualSchemaPath(actualPath, namespace,
 416                 revision, yangModelPrefix));
 417         parseSchemaNodeArgs(ctx, containerBuilder);
 418         parseConstraints(ctx, containerBuilder.getConstraints());
 419
 420         for (int i = 0; i < ctx.getChildCount(); ++i) {
 421             final ParseTree childNode = ctx.getChild(i);
 422             if (childNode instanceof Presence_stmtContext) {
 423                 containerBuilder.setPresence(true);
 424                 break;
 425             }
 426         }
 427     }
 428
 429     @Override
 430     public void exitContainer_stmt(Container_stmtContext ctx) {
 431         final String actContainer = actualPath.pop();
 432         logger.debug("exiting " + actContainer);
 433     }
 434
 435     @Override
 436     public void enterLeaf_stmt(Leaf_stmtContext ctx) {
 437         final String leafName = stringFromNode(ctx);
 438         QName leafQName = new QName(namespace, revision, yangModelPrefix,
 439                 leafName);
 440         LeafSchemaNodeBuilder leafBuilder = moduleBuilder.addLeafNode(
 441                 leafQName, actualPath, ctx.getStart().getLine());
 442         updatePath(leafName);
 443
 444         leafBuilder.setPath(createActualSchemaPath(actualPath, namespace,
 445                 revision, yangModelPrefix));
 446         parseSchemaNodeArgs(ctx, leafBuilder);
 447         parseConstraints(ctx, leafBuilder.getConstraints());
 448
 449         String defaultStr = null;
 450         String unitsStr = null;
 451         for (int i = 0; i < ctx.getChildCount(); i++) {
 452             ParseTree child = ctx.getChild(i);
 453             if (child instanceof Default_stmtContext) {
 454                 defaultStr = stringFromNode(child);
 455             } else if (child instanceof Units_stmtContext) {
 456                 unitsStr = stringFromNode(child);
 457             }
 458         }
 459         leafBuilder.setDefaultStr(defaultStr);
 460         leafBuilder.setUnits(unitsStr);
 461     }
 462
 463     @Override
 464     public void exitLeaf_stmt(YangParser.Leaf_stmtContext ctx) {
 465         final String actLeaf = actualPath.pop();
 466         logger.debug("exiting " + actLeaf);
 467     }
 468
 469     @Override
 470     public void enterUses_stmt(YangParser.Uses_stmtContext ctx) {
 471         final String groupingPathStr = stringFromNode(ctx);
 472         moduleBuilder.addUsesNode(groupingPathStr, actualPath, ctx.getStart()
 473                 .getLine());
 474         updatePath(groupingPathStr);
 475     }
 476
 477     @Override
 478     public void exitUses_stmt(YangParser.Uses_stmtContext ctx) {
 479         final String actContainer = actualPath.pop();
 480         logger.debug("exiting " + actContainer);
 481     }
 482
 483     @Override
 484     public void enterRefine_stmt(YangParser.Refine_stmtContext ctx) {
 485         String refineString = stringFromNode(ctx);
 486         RefineHolder refine = parseRefine(ctx);
 487         moduleBuilder.addRefine(refine, actualPath);
 488         updatePath(refineString);
 489     }
 490
 491     @Override
 492     public void exitRefine_stmt(YangParser.Refine_stmtContext ctx) {
 493         final String actContainer = actualPath.pop();
 494         logger.debug("exiting " + actContainer);
 495     }
 496
 497     @Override
 498     public void enterLeaf_list_stmt(Leaf_list_stmtContext ctx) {
 499         final String leafListName = stringFromNode(ctx);
 500         QName leafListQName = new QName(namespace, revision, yangModelPrefix,
 501                 leafListName);
 502         LeafListSchemaNodeBuilder leafListBuilder = moduleBuilder
 503                 .addLeafListNode(leafListQName, actualPath, ctx.getStart()
 504                         .getLine());
 505         updatePath(leafListName);
 506
 507         parseSchemaNodeArgs(ctx, leafListBuilder);
 508         parseConstraints(ctx, leafListBuilder.getConstraints());
 509
 510         for (int i = 0; i < ctx.getChildCount(); ++i) {
 511             final ParseTree childNode = ctx.getChild(i);
 512             if (childNode instanceof Ordered_by_stmtContext) {
 513                 final Ordered_by_stmtContext orderedBy = (Ordered_by_stmtContext) childNode;
 514                 final boolean userOrdered = parseUserOrdered(orderedBy);
 515                 leafListBuilder.setUserOrdered(userOrdered);
 516                 break;
 517             }
 518         }
 519     }
 520
 521     @Override
 522     public void exitLeaf_list_stmt(YangParser.Leaf_list_stmtContext ctx) {
 523         final String actContainer = actualPath.pop();
 524         logger.debug("exiting " + actContainer);
 525     }
 526
 527     @Override
 528     public void enterList_stmt(List_stmtContext ctx) {
 529         final String containerName = stringFromNode(ctx);
 530         QName containerQName = new QName(namespace, revision, yangModelPrefix,
 531                 containerName);
 532         ListSchemaNodeBuilder listBuilder = moduleBuilder.addListNode(
 533                 containerQName, actualPath, ctx.getStart().getLine());
 534         updatePath(containerName);
 535
 536         listBuilder.setPath(createActualSchemaPath(actualPath, namespace,
 537                 revision, yangModelPrefix));
 538         parseSchemaNodeArgs(ctx, listBuilder);
 539         parseConstraints(ctx, listBuilder.getConstraints());
 540
 541         String keyDefinition = "";
 542         for (int i = 0; i < ctx.getChildCount(); ++i) {
 543             ParseTree childNode = ctx.getChild(i);
 544             if (childNode instanceof Ordered_by_stmtContext) {
 545                 final Ordered_by_stmtContext orderedBy = (Ordered_by_stmtContext) childNode;
 546                 final boolean userOrdered = parseUserOrdered(orderedBy);
 547                 listBuilder.setUserOrdered(userOrdered);
 548             } else if (childNode instanceof Key_stmtContext) {
 549                 keyDefinition = stringFromNode(childNode);
 550                 List<QName> key = createListKey(keyDefinition, namespace,
 551                         revision, yangModelPrefix);
 552                 listBuilder.setKeyDefinition(key);
 553             }
 554         }
 555     }
 556
 557     @Override
 558     public void exitList_stmt(List_stmtContext ctx) {
 559         final String actContainer = actualPath.pop();
 560         logger.debug("exiting " + actContainer);
 561     }
 562
 563     @Override
 564     public void enterAnyxml_stmt(YangParser.Anyxml_stmtContext ctx) {
 565         final String anyXmlName = stringFromNode(ctx);
 566         QName anyXmlQName = new QName(namespace, revision, yangModelPrefix,
 567                 anyXmlName);
 568         AnyXmlBuilder anyXmlBuilder = moduleBuilder.addAnyXml(anyXmlQName,
 569                 actualPath, ctx.getStart().getLine());
 570         updatePath(anyXmlName);
 571
 572         anyXmlBuilder.setPath(createActualSchemaPath(actualPath, namespace,
 573                 revision, yangModelPrefix));
 574         parseSchemaNodeArgs(ctx, anyXmlBuilder);
 575         parseConstraints(ctx, anyXmlBuilder.getConstraints());
 576     }
 577
 578     @Override
 579     public void exitAnyxml_stmt(YangParser.Anyxml_stmtContext ctx) {
 580         final String actContainer = actualPath.pop();
 581         logger.debug("exiting " + actContainer);
 582     }
 583
 584     @Override
 585     public void enterChoice_stmt(YangParser.Choice_stmtContext ctx) {
 586         final String choiceName = stringFromNode(ctx);
 587         QName choiceQName = new QName(namespace, revision, yangModelPrefix,
 588                 choiceName);
 589         ChoiceBuilder choiceBuilder = moduleBuilder.addChoice(choiceQName,
 590                 actualPath, ctx.getStart().getLine());
 591
 592         updatePath(choiceName);
 593         choiceBuilder.setPath(createActualSchemaPath(actualPath, namespace,
 594                 revision, yangModelPrefix));
 595         parseSchemaNodeArgs(ctx, choiceBuilder);
 596         parseConstraints(ctx, choiceBuilder.getConstraints());
 597
 598         // set 'default' case
 599         for (int i = 0; i < ctx.getChildCount(); i++) {
 600             ParseTree child = ctx.getChild(i);
 601             if (child instanceof Default_stmtContext) {
 602                 String defaultCase = stringFromNode(child);
 603                 choiceBuilder.setDefaultCase(defaultCase);
 604                 break;
 605             }
 606         }
 607     }
 608
 609     @Override
 610     public void exitChoice_stmt(YangParser.Choice_stmtContext ctx) {
 611         final String actContainer = actualPath.pop();
 612         logger.debug("exiting " + actContainer);
 613     }
 614
 615     @Override
 616     public void enterCase_stmt(YangParser.Case_stmtContext ctx) {
 617         final String caseName = stringFromNode(ctx);
 618         QName choiceQName = new QName(namespace, revision, yangModelPrefix,
 619                 caseName);
 620         ChoiceCaseBuilder caseBuilder = moduleBuilder.addCase(choiceQName,
 621                 actualPath, ctx.getStart().getLine());
 622
 623         updatePath(caseName);
 624         caseBuilder.setPath(createActualSchemaPath(actualPath, namespace,
 625                 revision, yangModelPrefix));
 626         parseSchemaNodeArgs(ctx, caseBuilder);
 627         parseConstraints(ctx, caseBuilder.getConstraints());
 628     }
 629
 630     @Override
 631     public void exitCase_stmt(YangParser.Case_stmtContext ctx) {
 632         final String actContainer = actualPath.pop();
 633         logger.debug("exiting " + actContainer);
 634     }
 635
 636     @Override
 637     public void enterNotification_stmt(YangParser.Notification_stmtContext ctx) {
 638         final String notificationName = stringFromNode(ctx);
 639         QName notificationQName = new QName(namespace, revision,
 640                 yangModelPrefix, notificationName);
 641         NotificationBuilder notificationBuilder = moduleBuilder
 642                 .addNotification(notificationQName, actualPath, ctx.getStart()
 643                         .getLine());
 644         updatePath(notificationName);
 645
 646         notificationBuilder.setPath(createActualSchemaPath(actualPath,
 647                 namespace, revision, yangModelPrefix));
 648         parseSchemaNodeArgs(ctx, notificationBuilder);
 649     }
 650
 651     @Override
 652     public void exitNotification_stmt(YangParser.Notification_stmtContext ctx) {
 653         final String actContainer = actualPath.pop();
 654         logger.debug("exiting " + actContainer);
 655     }
 656
 657     // Unknown types
 658     @Override
 659     public void enterIdentifier_stmt(YangParser.Identifier_stmtContext ctx) {
 660         final String nodeParameter = stringFromNode(ctx);
 661         QName nodeType = null;
 662
 663         final String nodeTypeStr = ctx.getChild(0).getText();
 664         final String[] splittedElement = nodeTypeStr.split(":");
 665         if (splittedElement.length == 1) {
 666             nodeType = new QName(null, null, yangModelPrefix,
 667                     splittedElement[0]);
 668         } else {
 669             nodeType = new QName(null, null, splittedElement[0],
 670                     splittedElement[1]);
 671         }
 672
 673         QName qname;
 674         if (nodeParameter != null) {
 675             String[] splittedName = nodeParameter.split(":");
 676             if (splittedName.length == 2) {
 677                 qname = new QName(null, null, splittedName[0], splittedName[1]);
 678             } else {
 679                 qname = new QName(namespace, revision, yangModelPrefix,
 680                         splittedName[0]);
 681             }
 682         } else {
 683             qname = new QName(namespace, revision, yangModelPrefix,
 684                     nodeParameter);
 685         }
 686
 687         UnknownSchemaNodeBuilder builder = moduleBuilder.addUnknownSchemaNode(
 688                 qname, actualPath, ctx.getStart().getLine());
 689         builder.setNodeType(nodeType);
 690         builder.setNodeParameter(nodeParameter);
 691         updatePath(nodeParameter);
 692         builder.setPath(createActualSchemaPath(actualPath, namespace, revision,
 693                 yangModelPrefix));
 694         parseSchemaNodeArgs(ctx, builder);
 695     }
 696
 697     @Override
 698     public void exitIdentifier_stmt(YangParser.Identifier_stmtContext ctx) {
 699         final String actContainer = actualPath.pop();
 700         logger.debug("exiting " + actContainer);
 701     }
 702
 703     @Override
 704     public void enterRpc_stmt(YangParser.Rpc_stmtContext ctx) {
 705         final String rpcName = stringFromNode(ctx);
 706         QName rpcQName = new QName(namespace, revision, yangModelPrefix,
 707                 rpcName);
 708         RpcDefinitionBuilder rpcBuilder = moduleBuilder.addRpc(rpcQName,
 709                 actualPath, ctx.getStart().getLine());
 710         updatePath(rpcName);
 711
 712         rpcBuilder.setPath(createActualSchemaPath(actualPath, namespace,
 713                 revision, yangModelPrefix));
 714         parseSchemaNodeArgs(ctx, rpcBuilder);
 715     }
 716
 717     @Override
 718     public void exitRpc_stmt(YangParser.Rpc_stmtContext ctx) {
 719         final String actContainer = actualPath.pop();
 720         logger.debug("exiting " + actContainer);
 721     }
 722
 723     @Override
 724     public void enterInput_stmt(YangParser.Input_stmtContext ctx) {
 725         updatePath("input");
 726     }
 727
 728     @Override
 729     public void exitInput_stmt(YangParser.Input_stmtContext ctx) {
 730         final String actContainer = actualPath.pop();
 731         logger.debug("exiting " + actContainer);
 732     }
 733
 734     @Override
 735     public void enterOutput_stmt(YangParser.Output_stmtContext ctx) {
 736         updatePath("output");
 737     }
 738
 739     @Override
 740     public void exitOutput_stmt(YangParser.Output_stmtContext ctx) {
 741         final String actContainer = actualPath.pop();
 742         logger.debug("exiting " + actContainer);
 743     }
 744
 745     @Override
 746     public void enterFeature_stmt(YangParser.Feature_stmtContext ctx) {
 747         final String featureName = stringFromNode(ctx);
 748         QName featureQName = new QName(namespace, revision, yangModelPrefix,
 749                 featureName);
 750         FeatureBuilder featureBuilder = moduleBuilder.addFeature(featureQName,
 751                 actualPath, ctx.getStart().getLine());
 752         updatePath(featureName);
 753
 754         featureBuilder.setPath(createActualSchemaPath(actualPath, namespace,
 755                 revision, yangModelPrefix));
 756         parseSchemaNodeArgs(ctx, featureBuilder);
 757     }
 758
 759     @Override
 760     public void exitFeature_stmt(YangParser.Feature_stmtContext ctx) {
 761         final String actContainer = actualPath.pop();
 762         logger.debug("exiting " + actContainer);
 763     }
 764
 765     @Override
 766     public void enterDeviation_stmt(YangParser.Deviation_stmtContext ctx) {
 767         final String targetPath = stringFromNode(ctx);
 768         String reference = null;
 769         String deviate = null;
 770         DeviationBuilder builder = moduleBuilder.addDeviation(targetPath,
 771                 actualPath, ctx.getStart().getLine());
 772         updatePath(targetPath);
 773
 774         for (int i = 0; i < ctx.getChildCount(); i++) {
 775             ParseTree child = ctx.getChild(i);
 776             if (child instanceof Reference_stmtContext) {
 777                 reference = stringFromNode(child);
 778             } else if (child instanceof Deviate_not_supported_stmtContext) {
 779                 deviate = stringFromNode(child);
 780             } else if (child instanceof Deviate_add_stmtContext) {
 781                 deviate = stringFromNode(child);
 782             } else if (child instanceof Deviate_replace_stmtContext) {
 783                 deviate = stringFromNode(child);
 784             } else if (child instanceof Deviate_delete_stmtContext) {
 785                 deviate = stringFromNode(child);
 786             }
 787         }
 788         builder.setReference(reference);
 789         builder.setDeviate(deviate);
 790     }
 791
 792     @Override
 793     public void exitDeviation_stmt(YangParser.Deviation_stmtContext ctx) {
 794         final String actContainer = actualPath.pop();
 795         logger.debug("exiting " + actContainer);
 796     }
 797
 798     @Override
 799     public void enterConfig_stmt(YangParser.Config_stmtContext ctx) {
 800         boolean configuration = parseConfig(ctx);
 801         moduleBuilder.addConfiguration(configuration, actualPath);
 802     }
 803
 804     @Override
 805     public void enterIdentity_stmt(YangParser.Identity_stmtContext ctx) {
 806         final String identityName = stringFromNode(ctx);
 807         final QName identityQName = new QName(namespace, revision,
 808                 yangModelPrefix, identityName);
 809         IdentitySchemaNodeBuilder builder = moduleBuilder.addIdentity(
 810                 identityQName, actualPath, ctx.getStart().getLine());
 811         updatePath(identityName);
 812
 813         builder.setPath(createActualSchemaPath(actualPath, namespace, revision,
 814                 yangModelPrefix));
 815         parseSchemaNodeArgs(ctx, builder);
 816
 817         for (int i = 0; i < ctx.getChildCount(); i++) {
 818             ParseTree child = ctx.getChild(i);
 819             if (child instanceof Base_stmtContext) {
 820                 String baseIdentityName = stringFromNode(child);
 821                 builder.setBaseIdentityName(baseIdentityName);
 822             }
 823         }
 824     }
 825
 826     @Override
 827     public void exitIdentity_stmt(YangParser.Identity_stmtContext ctx) {
 828         final String actContainer = actualPath.pop();
 829         logger.debug("exiting " + actContainer);
 830     }
 831
 832     public ModuleBuilder getModuleBuilder() {
 833         return moduleBuilder;
 834     }
 835
 836     private void updatePath(String containerName) {
 837         actualPath.push(containerName);
 838     }
 839
 840 }