opendaylight/sal/yang-prototype/code-generator/yang-model-parser-impl/src/main/java/org/opendaylight/controller/yang/model/parser/impl/YangModelParserListenerImpl.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.model.parser.impl;
   9
  10 import static org.opendaylight.controller.yang.model.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.Status;
  56 import org.opendaylight.controller.yang.model.api.TypeDefinition;
  57 import org.opendaylight.controller.yang.model.parser.builder.api.AugmentationSchemaBuilder;
  58 import org.opendaylight.controller.yang.model.parser.builder.api.GroupingBuilder;
  59 import org.opendaylight.controller.yang.model.parser.builder.api.UsesNodeBuilder;
  60 import org.opendaylight.controller.yang.model.parser.builder.impl.AnyXmlBuilder;
  61 import org.opendaylight.controller.yang.model.parser.builder.impl.ChoiceBuilder;
  62 import org.opendaylight.controller.yang.model.parser.builder.impl.ChoiceCaseBuilder;
  63 import org.opendaylight.controller.yang.model.parser.builder.impl.ContainerSchemaNodeBuilder;
  64 import org.opendaylight.controller.yang.model.parser.builder.impl.DeviationBuilder;
  65 import org.opendaylight.controller.yang.model.parser.builder.impl.ExtensionBuilder;
  66 import org.opendaylight.controller.yang.model.parser.builder.impl.FeatureBuilder;
  67 import org.opendaylight.controller.yang.model.parser.builder.impl.IdentitySchemaNodeBuilder;
  68 import org.opendaylight.controller.yang.model.parser.builder.impl.LeafListSchemaNodeBuilder;
  69 import org.opendaylight.controller.yang.model.parser.builder.impl.LeafSchemaNodeBuilder;
  70 import org.opendaylight.controller.yang.model.parser.builder.impl.ListSchemaNodeBuilder;
  71 import org.opendaylight.controller.yang.model.parser.builder.impl.ModuleBuilder;
  72 import org.opendaylight.controller.yang.model.parser.builder.impl.NotificationBuilder;
  73 import org.opendaylight.controller.yang.model.parser.builder.impl.RpcDefinitionBuilder;
  74 import org.opendaylight.controller.yang.model.parser.builder.impl.TypedefBuilder;
  75 import org.opendaylight.controller.yang.model.parser.builder.impl.UnknownSchemaNodeBuilder;
  76 import org.opendaylight.controller.yang.model.parser.util.RefineHolder;
  77 import org.opendaylight.controller.yang.model.util.YangTypesConverter;
  78 import org.slf4j.Logger;
  79 import org.slf4j.LoggerFactory;
  80
  81 final class YangModelParserListenerImpl extends YangParserBaseListener {
  82
  83     private static final Logger logger = LoggerFactory
  84             .getLogger(YangModelParserListenerImpl.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     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);
 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);
 273         parseSchemaNodeArgs(ctx, builder);
 274
 275         String argument = null;
 276         boolean yin = false;
 277         for (int i = 0; i < ctx.getChildCount(); i++) {
 278             ParseTree child = ctx.getChild(i);
 279             if (child instanceof Argument_stmtContext) {
 280                 argument = stringFromNode(child);
 281                 yin = parseYinValue((Argument_stmtContext) child);
 282                 break;
 283             }
 284         }
 285         builder.setArgument(argument);
 286         builder.setYinElement(yin);
 287     }
 288
 289     @Override
 290     public void enterTypedef_stmt(YangParser.Typedef_stmtContext ctx) {
 291         final String typedefName = stringFromNode(ctx);
 292         QName typedefQName = new QName(namespace, revision, yangModelPrefix,
 293                 typedefName);
 294         TypedefBuilder builder = moduleBuilder.addTypedef(typedefQName,
 295                 actualPath);
 296         updatePath(typedefName);
 297
 298         builder.setPath(createActualSchemaPath(actualPath, namespace, revision,
 299                 yangModelPrefix));
 300         parseSchemaNodeArgs(ctx, builder);
 301         builder.setUnits(parseUnits(ctx));
 302     }
 303
 304     @Override
 305     public void exitTypedef_stmt(YangParser.Typedef_stmtContext ctx) {
 306         final String actContainer = actualPath.pop();
 307         logger.debug("exiting " + actContainer);
 308     }
 309
 310     @Override
 311     public void enterType_stmt(YangParser.Type_stmtContext ctx) {
 312         final String typeName = stringFromNode(ctx);
 313         QName typeQName = parseQName(typeName);
 314
 315         TypeDefinition<?> type = null;
 316         Type_body_stmtsContext typeBody = null;
 317         for (int i = 0; i < ctx.getChildCount(); i++) {
 318             if (ctx.getChild(i) instanceof Type_body_stmtsContext) {
 319                 typeBody = (Type_body_stmtsContext) ctx.getChild(i);
 320                 break;
 321             }
 322         }
 323
 324         // if this is base yang type...
 325         if (YangTypesConverter.isBaseYangType(typeName)) {
 326             if (typeBody == null) {
 327                 // if there are no constraints, just grab default base yang type
 328                 type = YangTypesConverter.javaTypeForBaseYangType(typeName);
 329                 moduleBuilder.setType(type, actualPath);
 330             } else {
 331                 if ("union".equals(typeName)) {
 332                     moduleBuilder.addUnionType(actualPath);
 333                 } else if("identityref".equals(typeName)) {
 334                     moduleBuilder.addIdentityrefType(getIdentityrefBase(typeBody), actualPath);
 335                 } else {
 336                     List<String> typePath = new ArrayList<String>(actualPath);
 337                     typePath.remove(0);
 338                     type = parseTypeBody(typeName, typeBody, typePath,
 339                             namespace, revision, yangModelPrefix);
 340                     moduleBuilder.setType(type, actualPath);
 341                 }
 342             }
 343         } else {
 344             type = parseUnknownTypeBody(typeQName, typeBody);
 345             // mark parent node of this type statement as dirty
 346             moduleBuilder.addDirtyNode(actualPath);
 347             moduleBuilder.setType(type, actualPath);
 348         }
 349
 350         updatePath(typeName);
 351     }
 352
 353     private QName parseQName(String typeName) {
 354         QName typeQName;
 355         if (typeName.contains(":")) {
 356             String[] splittedName = typeName.split(":");
 357             String prefix = splittedName[0];
 358             String name = splittedName[1];
 359             if (prefix.equals(yangModelPrefix)) {
 360                 typeQName = new QName(namespace, revision, prefix, name);
 361             } else {
 362                 typeQName = new QName(null, null, prefix, name);
 363             }
 364         } else {
 365             typeQName = new QName(namespace, revision, yangModelPrefix,
 366                     typeName);
 367         }
 368         return typeQName;
 369     }
 370
 371     @Override
 372     public void exitType_stmt(YangParser.Type_stmtContext ctx) {
 373         final String actContainer = actualPath.pop();
 374         logger.debug("exiting " + actContainer);
 375     }
 376
 377     @Override
 378     public void enterGrouping_stmt(YangParser.Grouping_stmtContext ctx) {
 379         final String groupName = stringFromNode(ctx);
 380         QName groupQName = new QName(namespace, revision, yangModelPrefix,
 381                 groupName);
 382         GroupingBuilder groupBuilder = moduleBuilder.addGrouping(groupQName,
 383                 actualPath);
 384         updatePath("grouping");
 385         updatePath(groupName);
 386         parseSchemaNodeArgs(ctx, groupBuilder);
 387     }
 388
 389     @Override
 390     public void exitGrouping_stmt(YangParser.Grouping_stmtContext ctx) {
 391         String actContainer = actualPath.pop();
 392         actContainer += "-" + actualPath.pop();
 393         logger.debug("exiting " + actContainer);
 394     }
 395
 396     @Override
 397     public void enterContainer_stmt(Container_stmtContext ctx) {
 398         final String containerName = stringFromNode(ctx);
 399         QName containerQName = new QName(namespace, revision, yangModelPrefix,
 400                 containerName);
 401         ContainerSchemaNodeBuilder containerBuilder = moduleBuilder
 402                 .addContainerNode(containerQName, actualPath);
 403         updatePath(containerName);
 404
 405         containerBuilder.setPath(createActualSchemaPath(actualPath, namespace,
 406                 revision, yangModelPrefix));
 407         parseSchemaNodeArgs(ctx, containerBuilder);
 408         parseConstraints(ctx, containerBuilder.getConstraints());
 409
 410         for (int i = 0; i < ctx.getChildCount(); ++i) {
 411             final ParseTree childNode = ctx.getChild(i);
 412             if (childNode instanceof Presence_stmtContext) {
 413                 containerBuilder.setPresence(true);
 414                 break;
 415             }
 416         }
 417     }
 418
 419     @Override
 420     public void exitContainer_stmt(Container_stmtContext ctx) {
 421         final String actContainer = actualPath.pop();
 422         logger.debug("exiting " + actContainer);
 423     }
 424
 425     @Override
 426     public void enterLeaf_stmt(Leaf_stmtContext ctx) {
 427         final String leafName = stringFromNode(ctx);
 428         QName leafQName = new QName(namespace, revision, yangModelPrefix,
 429                 leafName);
 430         LeafSchemaNodeBuilder leafBuilder = moduleBuilder.addLeafNode(
 431                 leafQName, actualPath);
 432         updatePath(leafName);
 433
 434         leafBuilder.setPath(createActualSchemaPath(actualPath, namespace,
 435                 revision, yangModelPrefix));
 436         parseSchemaNodeArgs(ctx, leafBuilder);
 437         parseConstraints(ctx, leafBuilder.getConstraints());
 438
 439         String defaultStr = null;
 440         String unitsStr = null;
 441         for (int i = 0; i < ctx.getChildCount(); i++) {
 442             ParseTree child = ctx.getChild(i);
 443             if (child instanceof Default_stmtContext) {
 444                 defaultStr = stringFromNode(child);
 445             } else if (child instanceof Units_stmtContext) {
 446                 unitsStr = stringFromNode(child);
 447             }
 448         }
 449         leafBuilder.setDefaultStr(defaultStr);
 450         leafBuilder.setUnits(unitsStr);
 451     }
 452
 453     @Override
 454     public void exitLeaf_stmt(YangParser.Leaf_stmtContext ctx) {
 455         final String actLeaf = actualPath.pop();
 456         logger.debug("exiting " + actLeaf);
 457     }
 458
 459     @Override
 460     public void enterUses_stmt(YangParser.Uses_stmtContext ctx) {
 461         final String groupingPathStr = stringFromNode(ctx);
 462         UsesNodeBuilder builder = moduleBuilder.addUsesNode(groupingPathStr,
 463                 actualPath);
 464         updatePath(groupingPathStr);
 465
 466         final List<RefineHolder> refines = parseRefines(ctx);
 467         builder.setRefines(refines);
 468     }
 469
 470     @Override
 471     public void exitUses_stmt(YangParser.Uses_stmtContext ctx) {
 472         final String actContainer = actualPath.pop();
 473         logger.debug("exiting " + actContainer);
 474     }
 475
 476     @Override
 477     public void enterLeaf_list_stmt(Leaf_list_stmtContext ctx) {
 478         final String leafListName = stringFromNode(ctx);
 479         QName leafListQName = new QName(namespace, revision, yangModelPrefix,
 480                 leafListName);
 481         LeafListSchemaNodeBuilder leafListBuilder = moduleBuilder
 482                 .addLeafListNode(leafListQName, actualPath);
 483         updatePath(leafListName);
 484
 485         parseSchemaNodeArgs(ctx, leafListBuilder);
 486         parseConstraints(ctx, leafListBuilder.getConstraints());
 487
 488         for (int i = 0; i < ctx.getChildCount(); ++i) {
 489             final ParseTree childNode = ctx.getChild(i);
 490             if (childNode instanceof Ordered_by_stmtContext) {
 491                 final Ordered_by_stmtContext orderedBy = (Ordered_by_stmtContext) childNode;
 492                 final boolean userOrdered = parseUserOrdered(orderedBy);
 493                 leafListBuilder.setUserOrdered(userOrdered);
 494                 break;
 495             }
 496         }
 497     }
 498
 499     @Override
 500     public void exitLeaf_list_stmt(YangParser.Leaf_list_stmtContext ctx) {
 501         final String actContainer = actualPath.pop();
 502         logger.debug("exiting " + actContainer);
 503     }
 504
 505     @Override
 506     public void enterList_stmt(List_stmtContext ctx) {
 507         final String containerName = stringFromNode(ctx);
 508         QName containerQName = new QName(namespace, revision, yangModelPrefix,
 509                 containerName);
 510         ListSchemaNodeBuilder listBuilder = moduleBuilder.addListNode(
 511                 containerQName, actualPath);
 512         updatePath(containerName);
 513
 514         listBuilder.setPath(createActualSchemaPath(actualPath, namespace,
 515                 revision, yangModelPrefix));
 516         parseSchemaNodeArgs(ctx, listBuilder);
 517         parseConstraints(ctx, listBuilder.getConstraints());
 518
 519         String keyDefinition = "";
 520         for (int i = 0; i < ctx.getChildCount(); ++i) {
 521             ParseTree childNode = ctx.getChild(i);
 522             if (childNode instanceof Ordered_by_stmtContext) {
 523                 final Ordered_by_stmtContext orderedBy = (Ordered_by_stmtContext) childNode;
 524                 final boolean userOrdered = parseUserOrdered(orderedBy);
 525                 listBuilder.setUserOrdered(userOrdered);
 526             } else if (childNode instanceof Key_stmtContext) {
 527                 keyDefinition = stringFromNode(childNode);
 528                 List<QName> key = createListKey(keyDefinition, namespace,
 529                         revision, yangModelPrefix);
 530                 listBuilder.setKeyDefinition(key);
 531             }
 532         }
 533     }
 534
 535     @Override
 536     public void exitList_stmt(List_stmtContext ctx) {
 537         final String actContainer = actualPath.pop();
 538         logger.debug("exiting " + actContainer);
 539     }
 540
 541     @Override
 542     public void enterAnyxml_stmt(YangParser.Anyxml_stmtContext ctx) {
 543         final String anyXmlName = stringFromNode(ctx);
 544         QName anyXmlQName = new QName(namespace, revision, yangModelPrefix,
 545                 anyXmlName);
 546         AnyXmlBuilder anyXmlBuilder = moduleBuilder.addAnyXml(anyXmlQName,
 547                 actualPath);
 548         updatePath(anyXmlName);
 549
 550         anyXmlBuilder.setPath(createActualSchemaPath(actualPath, namespace,
 551                 revision, yangModelPrefix));
 552         parseSchemaNodeArgs(ctx, anyXmlBuilder);
 553         parseConstraints(ctx, anyXmlBuilder.getConstraints());
 554     }
 555
 556     @Override
 557     public void exitAnyxml_stmt(YangParser.Anyxml_stmtContext ctx) {
 558         final String actContainer = actualPath.pop();
 559         logger.debug("exiting " + actContainer);
 560     }
 561
 562     @Override
 563     public void enterChoice_stmt(YangParser.Choice_stmtContext ctx) {
 564         final String choiceName = stringFromNode(ctx);
 565         QName choiceQName = new QName(namespace, revision, yangModelPrefix,
 566                 choiceName);
 567         ChoiceBuilder choiceBuilder = moduleBuilder.addChoice(choiceQName,
 568                 actualPath);
 569
 570         updatePath(choiceName);
 571         choiceBuilder.setPath(createActualSchemaPath(actualPath, namespace,
 572                 revision, yangModelPrefix));
 573         parseSchemaNodeArgs(ctx, choiceBuilder);
 574         parseConstraints(ctx, choiceBuilder.getConstraints());
 575
 576         // set 'default' case
 577         for (int i = 0; i < ctx.getChildCount(); i++) {
 578             ParseTree child = ctx.getChild(i);
 579             if (child instanceof Default_stmtContext) {
 580                 String defaultCase = stringFromNode(child);
 581                 choiceBuilder.setDefaultCase(defaultCase);
 582                 break;
 583             }
 584         }
 585     }
 586
 587     @Override
 588     public void exitChoice_stmt(YangParser.Choice_stmtContext ctx) {
 589         final String actContainer = actualPath.pop();
 590         logger.debug("exiting " + actContainer);
 591     }
 592
 593     @Override
 594     public void enterCase_stmt(YangParser.Case_stmtContext ctx) {
 595         final String caseName = stringFromNode(ctx);
 596         QName choiceQName = new QName(namespace, revision, yangModelPrefix,
 597                 caseName);
 598         ChoiceCaseBuilder caseBuilder = moduleBuilder.addCase(choiceQName,
 599                 actualPath);
 600
 601         updatePath(caseName);
 602         caseBuilder.setPath(createActualSchemaPath(actualPath, namespace,
 603                 revision, yangModelPrefix));
 604         parseSchemaNodeArgs(ctx, caseBuilder);
 605         parseConstraints(ctx, caseBuilder.getConstraints());
 606     }
 607
 608     @Override
 609     public void exitCase_stmt(YangParser.Case_stmtContext ctx) {
 610         final String actContainer = actualPath.pop();
 611         logger.debug("exiting " + actContainer);
 612     }
 613
 614     @Override
 615     public void enterNotification_stmt(YangParser.Notification_stmtContext ctx) {
 616         final String notificationName = stringFromNode(ctx);
 617         QName notificationQName = new QName(namespace, revision,
 618                 yangModelPrefix, notificationName);
 619         NotificationBuilder notificationBuilder = moduleBuilder
 620                 .addNotification(notificationQName, actualPath);
 621         updatePath(notificationName);
 622
 623         notificationBuilder.setPath(createActualSchemaPath(actualPath,
 624                 namespace, revision, yangModelPrefix));
 625         parseSchemaNodeArgs(ctx, notificationBuilder);
 626     }
 627
 628     @Override
 629     public void exitNotification_stmt(YangParser.Notification_stmtContext ctx) {
 630         final String actContainer = actualPath.pop();
 631         logger.debug("exiting " + actContainer);
 632     }
 633
 634     // Unknown types
 635     @Override
 636     public void enterIdentifier_stmt(YangParser.Identifier_stmtContext ctx) {
 637         final String name = stringFromNode(ctx);
 638
 639         QName qname;
 640         if (name != null) {
 641             String[] splittedName = name.split(":");
 642             if (splittedName.length == 2) {
 643                 qname = new QName(null, null, splittedName[0], splittedName[1]);
 644             } else {
 645                 qname = new QName(namespace, revision, yangModelPrefix,
 646                         splittedName[0]);
 647             }
 648         } else {
 649             qname = new QName(namespace, revision, yangModelPrefix, name);
 650         }
 651
 652         UnknownSchemaNodeBuilder builder = moduleBuilder.addUnknownSchemaNode(
 653                 qname, actualPath);
 654         updatePath(name);
 655         builder.setPath(createActualSchemaPath(actualPath, namespace, revision,
 656                 yangModelPrefix));
 657         parseSchemaNodeArgs(ctx, builder);
 658     }
 659
 660     @Override
 661     public void exitIdentifier_stmt(YangParser.Identifier_stmtContext ctx) {
 662         final String actContainer = actualPath.pop();
 663         logger.debug("exiting " + actContainer);
 664     }
 665
 666     @Override
 667     public void enterRpc_stmt(YangParser.Rpc_stmtContext ctx) {
 668         final String rpcName = stringFromNode(ctx);
 669         QName rpcQName = new QName(namespace, revision, yangModelPrefix,
 670                 rpcName);
 671         RpcDefinitionBuilder rpcBuilder = moduleBuilder.addRpc(rpcQName,
 672                 actualPath);
 673         updatePath(rpcName);
 674
 675         rpcBuilder.setPath(createActualSchemaPath(actualPath, namespace,
 676                 revision, yangModelPrefix));
 677         parseSchemaNodeArgs(ctx, rpcBuilder);
 678     }
 679
 680     @Override
 681     public void exitRpc_stmt(YangParser.Rpc_stmtContext ctx) {
 682         final String actContainer = actualPath.pop();
 683         logger.debug("exiting " + actContainer);
 684     }
 685
 686     @Override
 687     public void enterInput_stmt(YangParser.Input_stmtContext ctx) {
 688         updatePath("input");
 689     }
 690
 691     @Override
 692     public void exitInput_stmt(YangParser.Input_stmtContext ctx) {
 693         final String actContainer = actualPath.pop();
 694         logger.debug("exiting " + actContainer);
 695     }
 696
 697     @Override
 698     public void enterOutput_stmt(YangParser.Output_stmtContext ctx) {
 699         updatePath("output");
 700     }
 701
 702     @Override
 703     public void exitOutput_stmt(YangParser.Output_stmtContext ctx) {
 704         final String actContainer = actualPath.pop();
 705         logger.debug("exiting " + actContainer);
 706     }
 707
 708     @Override
 709     public void enterFeature_stmt(YangParser.Feature_stmtContext ctx) {
 710         final String featureName = stringFromNode(ctx);
 711         QName featureQName = new QName(namespace, revision, yangModelPrefix,
 712                 featureName);
 713         FeatureBuilder featureBuilder = moduleBuilder.addFeature(featureQName,
 714                 actualPath);
 715         updatePath(featureName);
 716
 717         featureBuilder.setPath(createActualSchemaPath(actualPath, namespace,
 718                 revision, yangModelPrefix));
 719         parseSchemaNodeArgs(ctx, featureBuilder);
 720     }
 721
 722     @Override
 723     public void exitFeature_stmt(YangParser.Feature_stmtContext ctx) {
 724         final String actContainer = actualPath.pop();
 725         logger.debug("exiting " + actContainer);
 726     }
 727
 728     @Override
 729     public void enterDeviation_stmt(YangParser.Deviation_stmtContext ctx) {
 730         final String targetPath = stringFromNode(ctx);
 731         String reference = null;
 732         String deviate = null;
 733         DeviationBuilder builder = moduleBuilder.addDeviation(targetPath,
 734                 actualPath);
 735         updatePath(targetPath);
 736
 737         for (int i = 0; i < ctx.getChildCount(); i++) {
 738             ParseTree child = ctx.getChild(i);
 739             if (child instanceof Reference_stmtContext) {
 740                 reference = stringFromNode(child);
 741             } else if (child instanceof Deviate_not_supported_stmtContext) {
 742                 deviate = stringFromNode(child);
 743             } else if (child instanceof Deviate_add_stmtContext) {
 744                 deviate = stringFromNode(child);
 745             } else if (child instanceof Deviate_replace_stmtContext) {
 746                 deviate = stringFromNode(child);
 747             } else if (child instanceof Deviate_delete_stmtContext) {
 748                 deviate = stringFromNode(child);
 749             }
 750         }
 751         builder.setReference(reference);
 752         builder.setDeviate(deviate);
 753     }
 754
 755     @Override
 756     public void exitDeviation_stmt(YangParser.Deviation_stmtContext ctx) {
 757         final String actContainer = actualPath.pop();
 758         logger.debug("exiting " + actContainer);
 759     }
 760
 761     @Override
 762     public void enterConfig_stmt(YangParser.Config_stmtContext ctx) {
 763         boolean configuration = parseConfig(ctx);
 764         moduleBuilder.addConfiguration(configuration, actualPath);
 765     }
 766
 767     @Override
 768     public void enterIdentity_stmt(YangParser.Identity_stmtContext ctx) {
 769         final String identityName = stringFromNode(ctx);
 770         final QName identityQName = new QName(namespace, revision,
 771                 yangModelPrefix, identityName);
 772         IdentitySchemaNodeBuilder builder = moduleBuilder
 773                 .addIdentity(identityQName);
 774         updatePath(identityName);
 775
 776         builder.setPath(createActualSchemaPath(actualPath, namespace, revision,
 777                 yangModelPrefix));
 778         parseSchemaNodeArgs(ctx, builder);
 779
 780         for (int i = 0; i < ctx.getChildCount(); i++) {
 781             ParseTree child = ctx.getChild(i);
 782             if (child instanceof Base_stmtContext) {
 783                 String baseIdentityName = stringFromNode(child);
 784                 builder.setBaseIdentityName(baseIdentityName);
 785             }
 786         }
 787     }
 788
 789     @Override
 790     public void exitIdentity_stmt(YangParser.Identity_stmtContext ctx) {
 791         final String actContainer = actualPath.pop();
 792         logger.debug("exiting " + actContainer);
 793     }
 794
 795     public ModuleBuilder getModuleBuilder() {
 796         return moduleBuilder;
 797     }
 798
 799     private void updatePath(String containerName) {
 800         actualPath.push(containerName);
 801     }
 802
 803 }