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()
 413                         .getLine());
 414         updatePath(containerName);
 415
 416         containerBuilder.setPath(createActualSchemaPath(actualPath, namespace,
 417                 revision, yangModelPrefix));
 418         parseSchemaNodeArgs(ctx, containerBuilder);
 419         parseConstraints(ctx, containerBuilder.getConstraints());
 420
 421         for (int i = 0; i < ctx.getChildCount(); ++i) {
 422             final ParseTree childNode = ctx.getChild(i);
 423             if (childNode instanceof Presence_stmtContext) {
 424                 containerBuilder.setPresence(true);
 425                 break;
 426             }
 427         }
 428     }
 429
 430     @Override
 431     public void exitContainer_stmt(Container_stmtContext ctx) {
 432         final String actContainer = actualPath.pop();
 433         logger.debug("exiting " + actContainer);
 434     }
 435
 436     @Override
 437     public void enterLeaf_stmt(Leaf_stmtContext ctx) {
 438         final String leafName = stringFromNode(ctx);
 439         QName leafQName = new QName(namespace, revision, yangModelPrefix,
 440                 leafName);
 441         LeafSchemaNodeBuilder leafBuilder = moduleBuilder.addLeafNode(
 442                 leafQName, actualPath, ctx.getStart().getLine());
 443         updatePath(leafName);
 444
 445         leafBuilder.setPath(createActualSchemaPath(actualPath, namespace,
 446                 revision, yangModelPrefix));
 447         parseSchemaNodeArgs(ctx, leafBuilder);
 448         parseConstraints(ctx, leafBuilder.getConstraints());
 449
 450         String defaultStr = null;
 451         String unitsStr = null;
 452         for (int i = 0; i < ctx.getChildCount(); i++) {
 453             ParseTree child = ctx.getChild(i);
 454             if (child instanceof Default_stmtContext) {
 455                 defaultStr = stringFromNode(child);
 456             } else if (child instanceof Units_stmtContext) {
 457                 unitsStr = stringFromNode(child);
 458             }
 459         }
 460         leafBuilder.setDefaultStr(defaultStr);
 461         leafBuilder.setUnits(unitsStr);
 462     }
 463
 464     @Override
 465     public void exitLeaf_stmt(YangParser.Leaf_stmtContext ctx) {
 466         final String actLeaf = actualPath.pop();
 467         logger.debug("exiting " + actLeaf);
 468     }
 469
 470     @Override
 471     public void enterUses_stmt(YangParser.Uses_stmtContext ctx) {
 472         final String groupingPathStr = stringFromNode(ctx);
 473         moduleBuilder.addUsesNode(groupingPathStr, actualPath, ctx.getStart()
 474                 .getLine());
 475         updatePath(groupingPathStr);
 476     }
 477
 478     @Override
 479     public void exitUses_stmt(YangParser.Uses_stmtContext ctx) {
 480         final String actContainer = actualPath.pop();
 481         logger.debug("exiting " + actContainer);
 482     }
 483
 484     @Override
 485     public void enterRefine_stmt(YangParser.Refine_stmtContext ctx) {
 486         String refineString = stringFromNode(ctx);
 487         RefineHolder refine = parseRefine(ctx);
 488         moduleBuilder.addRefine(refine, actualPath);
 489         updatePath(refineString);
 490     }
 491
 492     @Override
 493     public void exitRefine_stmt(YangParser.Refine_stmtContext ctx) {
 494         final String actContainer = actualPath.pop();
 495         logger.debug("exiting " + actContainer);
 496     }
 497
 498     @Override
 499     public void enterLeaf_list_stmt(Leaf_list_stmtContext ctx) {
 500         final String leafListName = stringFromNode(ctx);
 501         QName leafListQName = new QName(namespace, revision, yangModelPrefix,
 502                 leafListName);
 503         LeafListSchemaNodeBuilder leafListBuilder = moduleBuilder
 504                 .addLeafListNode(leafListQName, actualPath, ctx.getStart()
 505                         .getLine());
 506         updatePath(leafListName);
 507
 508         parseSchemaNodeArgs(ctx, leafListBuilder);
 509         parseConstraints(ctx, leafListBuilder.getConstraints());
 510
 511         for (int i = 0; i < ctx.getChildCount(); ++i) {
 512             final ParseTree childNode = ctx.getChild(i);
 513             if (childNode instanceof Ordered_by_stmtContext) {
 514                 final Ordered_by_stmtContext orderedBy = (Ordered_by_stmtContext) childNode;
 515                 final boolean userOrdered = parseUserOrdered(orderedBy);
 516                 leafListBuilder.setUserOrdered(userOrdered);
 517                 break;
 518             }
 519         }
 520     }
 521
 522     @Override
 523     public void exitLeaf_list_stmt(YangParser.Leaf_list_stmtContext ctx) {
 524         final String actContainer = actualPath.pop();
 525         logger.debug("exiting " + actContainer);
 526     }
 527
 528     @Override
 529     public void enterList_stmt(List_stmtContext ctx) {
 530         final String containerName = stringFromNode(ctx);
 531         QName containerQName = new QName(namespace, revision, yangModelPrefix,
 532                 containerName);
 533         ListSchemaNodeBuilder listBuilder = moduleBuilder.addListNode(
 534                 containerQName, actualPath, ctx.getStart().getLine());
 535         updatePath(containerName);
 536
 537         listBuilder.setPath(createActualSchemaPath(actualPath, namespace,
 538                 revision, yangModelPrefix));
 539         parseSchemaNodeArgs(ctx, listBuilder);
 540         parseConstraints(ctx, listBuilder.getConstraints());
 541
 542         String keyDefinition = "";
 543         for (int i = 0; i < ctx.getChildCount(); ++i) {
 544             ParseTree childNode = ctx.getChild(i);
 545             if (childNode instanceof Ordered_by_stmtContext) {
 546                 final Ordered_by_stmtContext orderedBy = (Ordered_by_stmtContext) childNode;
 547                 final boolean userOrdered = parseUserOrdered(orderedBy);
 548                 listBuilder.setUserOrdered(userOrdered);
 549             } else if (childNode instanceof Key_stmtContext) {
 550                 keyDefinition = stringFromNode(childNode);
 551                 List<QName> key = createListKey(keyDefinition, namespace,
 552                         revision, yangModelPrefix);
 553                 listBuilder.setKeyDefinition(key);
 554             }
 555         }
 556     }
 557
 558     @Override
 559     public void exitList_stmt(List_stmtContext ctx) {
 560         final String actContainer = actualPath.pop();
 561         logger.debug("exiting " + actContainer);
 562     }
 563
 564     @Override
 565     public void enterAnyxml_stmt(YangParser.Anyxml_stmtContext ctx) {
 566         final String anyXmlName = stringFromNode(ctx);
 567         QName anyXmlQName = new QName(namespace, revision, yangModelPrefix,
 568                 anyXmlName);
 569         AnyXmlBuilder anyXmlBuilder = moduleBuilder.addAnyXml(anyXmlQName,
 570                 actualPath, ctx.getStart().getLine());
 571         updatePath(anyXmlName);
 572
 573         anyXmlBuilder.setPath(createActualSchemaPath(actualPath, namespace,
 574                 revision, yangModelPrefix));
 575         parseSchemaNodeArgs(ctx, anyXmlBuilder);
 576         parseConstraints(ctx, anyXmlBuilder.getConstraints());
 577     }
 578
 579     @Override
 580     public void exitAnyxml_stmt(YangParser.Anyxml_stmtContext ctx) {
 581         final String actContainer = actualPath.pop();
 582         logger.debug("exiting " + actContainer);
 583     }
 584
 585     @Override
 586     public void enterChoice_stmt(YangParser.Choice_stmtContext ctx) {
 587         final String choiceName = stringFromNode(ctx);
 588         QName choiceQName = new QName(namespace, revision, yangModelPrefix,
 589                 choiceName);
 590         ChoiceBuilder choiceBuilder = moduleBuilder.addChoice(choiceQName,
 591                 actualPath, ctx.getStart().getLine());
 592
 593         updatePath(choiceName);
 594         choiceBuilder.setPath(createActualSchemaPath(actualPath, namespace,
 595                 revision, yangModelPrefix));
 596         parseSchemaNodeArgs(ctx, choiceBuilder);
 597         parseConstraints(ctx, choiceBuilder.getConstraints());
 598
 599         // set 'default' case
 600         for (int i = 0; i < ctx.getChildCount(); i++) {
 601             ParseTree child = ctx.getChild(i);
 602             if (child instanceof Default_stmtContext) {
 603                 String defaultCase = stringFromNode(child);
 604                 choiceBuilder.setDefaultCase(defaultCase);
 605                 break;
 606             }
 607         }
 608     }
 609
 610     @Override
 611     public void exitChoice_stmt(YangParser.Choice_stmtContext ctx) {
 612         final String actContainer = actualPath.pop();
 613         logger.debug("exiting " + actContainer);
 614     }
 615
 616     @Override
 617     public void enterCase_stmt(YangParser.Case_stmtContext ctx) {
 618         final String caseName = stringFromNode(ctx);
 619         QName choiceQName = new QName(namespace, revision, yangModelPrefix,
 620                 caseName);
 621         ChoiceCaseBuilder caseBuilder = moduleBuilder.addCase(choiceQName,
 622                 actualPath, ctx.getStart().getLine());
 623
 624         updatePath(caseName);
 625         caseBuilder.setPath(createActualSchemaPath(actualPath, namespace,
 626                 revision, yangModelPrefix));
 627         parseSchemaNodeArgs(ctx, caseBuilder);
 628         parseConstraints(ctx, caseBuilder.getConstraints());
 629     }
 630
 631     @Override
 632     public void exitCase_stmt(YangParser.Case_stmtContext ctx) {
 633         final String actContainer = actualPath.pop();
 634         logger.debug("exiting " + actContainer);
 635     }
 636
 637     @Override
 638     public void enterNotification_stmt(YangParser.Notification_stmtContext ctx) {
 639         final String notificationName = stringFromNode(ctx);
 640         QName notificationQName = new QName(namespace, revision,
 641                 yangModelPrefix, notificationName);
 642         NotificationBuilder notificationBuilder = moduleBuilder
 643                 .addNotification(notificationQName, actualPath, ctx.getStart()
 644                         .getLine());
 645         updatePath(notificationName);
 646
 647         notificationBuilder.setPath(createActualSchemaPath(actualPath,
 648                 namespace, revision, yangModelPrefix));
 649         parseSchemaNodeArgs(ctx, notificationBuilder);
 650     }
 651
 652     @Override
 653     public void exitNotification_stmt(YangParser.Notification_stmtContext ctx) {
 654         final String actContainer = actualPath.pop();
 655         logger.debug("exiting " + actContainer);
 656     }
 657
 658     // Unknown types
 659     @Override
 660     public void enterIdentifier_stmt(YangParser.Identifier_stmtContext ctx) {
 661         final String nodeParameter = stringFromNode(ctx);
 662         QName nodeType = null;
 663
 664         final String nodeTypeStr = ctx.getChild(0).getText();
 665         final String[] splittedElement = nodeTypeStr.split(":");
 666         if (splittedElement.length == 1) {
 667             nodeType = new QName(null, null, yangModelPrefix,
 668                     splittedElement[0]);
 669         } else {
 670             nodeType = new QName(null, null, splittedElement[0],
 671                     splittedElement[1]);
 672         }
 673
 674         QName qname;
 675         if (nodeParameter != null) {
 676             String[] splittedName = nodeParameter.split(":");
 677             if (splittedName.length == 2) {
 678                 qname = new QName(null, null, splittedName[0], splittedName[1]);
 679             } else {
 680                 qname = new QName(namespace, revision, yangModelPrefix,
 681                         splittedName[0]);
 682             }
 683         } else {
 684             qname = new QName(namespace, revision, yangModelPrefix,
 685                     nodeParameter);
 686         }
 687
 688         UnknownSchemaNodeBuilder builder = moduleBuilder.addUnknownSchemaNode(
 689                 qname, actualPath, ctx.getStart().getLine());
 690         builder.setNodeType(nodeType);
 691         builder.setNodeParameter(nodeParameter);
 692         updatePath(nodeParameter);
 693         builder.setPath(createActualSchemaPath(actualPath, namespace, revision,
 694                 yangModelPrefix));
 695         parseSchemaNodeArgs(ctx, builder);
 696     }
 697
 698     @Override
 699     public void exitIdentifier_stmt(YangParser.Identifier_stmtContext ctx) {
 700         final String actContainer = actualPath.pop();
 701         logger.debug("exiting " + actContainer);
 702     }
 703
 704     @Override
 705     public void enterRpc_stmt(YangParser.Rpc_stmtContext ctx) {
 706         final String rpcName = stringFromNode(ctx);
 707         QName rpcQName = new QName(namespace, revision, yangModelPrefix,
 708                 rpcName);
 709         RpcDefinitionBuilder rpcBuilder = moduleBuilder.addRpc(rpcQName,
 710                 actualPath, ctx.getStart().getLine());
 711         updatePath(rpcName);
 712
 713         rpcBuilder.setPath(createActualSchemaPath(actualPath, namespace,
 714                 revision, yangModelPrefix));
 715         parseSchemaNodeArgs(ctx, rpcBuilder);
 716     }
 717
 718     @Override
 719     public void exitRpc_stmt(YangParser.Rpc_stmtContext ctx) {
 720         final String actContainer = actualPath.pop();
 721         logger.debug("exiting " + actContainer);
 722     }
 723
 724     @Override
 725     public void enterInput_stmt(YangParser.Input_stmtContext ctx) {
 726         updatePath("input");
 727     }
 728
 729     @Override
 730     public void exitInput_stmt(YangParser.Input_stmtContext ctx) {
 731         final String actContainer = actualPath.pop();
 732         logger.debug("exiting " + actContainer);
 733     }
 734
 735     @Override
 736     public void enterOutput_stmt(YangParser.Output_stmtContext ctx) {
 737         updatePath("output");
 738     }
 739
 740     @Override
 741     public void exitOutput_stmt(YangParser.Output_stmtContext ctx) {
 742         final String actContainer = actualPath.pop();
 743         logger.debug("exiting " + actContainer);
 744     }
 745
 746     @Override
 747     public void enterFeature_stmt(YangParser.Feature_stmtContext ctx) {
 748         final String featureName = stringFromNode(ctx);
 749         QName featureQName = new QName(namespace, revision, yangModelPrefix,
 750                 featureName);
 751         FeatureBuilder featureBuilder = moduleBuilder.addFeature(featureQName,
 752                 actualPath, ctx.getStart().getLine());
 753         updatePath(featureName);
 754
 755         featureBuilder.setPath(createActualSchemaPath(actualPath, namespace,
 756                 revision, yangModelPrefix));
 757         parseSchemaNodeArgs(ctx, featureBuilder);
 758     }
 759
 760     @Override
 761     public void exitFeature_stmt(YangParser.Feature_stmtContext ctx) {
 762         final String actContainer = actualPath.pop();
 763         logger.debug("exiting " + actContainer);
 764     }
 765
 766     @Override
 767     public void enterDeviation_stmt(YangParser.Deviation_stmtContext ctx) {
 768         final String targetPath = stringFromNode(ctx);
 769         String reference = null;
 770         String deviate = null;
 771         DeviationBuilder builder = moduleBuilder.addDeviation(targetPath,
 772                 actualPath, ctx.getStart().getLine());
 773         updatePath(targetPath);
 774
 775         for (int i = 0; i < ctx.getChildCount(); i++) {
 776             ParseTree child = ctx.getChild(i);
 777             if (child instanceof Reference_stmtContext) {
 778                 reference = stringFromNode(child);
 779             } else if (child instanceof Deviate_not_supported_stmtContext) {
 780                 deviate = stringFromNode(child);
 781             } else if (child instanceof Deviate_add_stmtContext) {
 782                 deviate = stringFromNode(child);
 783             } else if (child instanceof Deviate_replace_stmtContext) {
 784                 deviate = stringFromNode(child);
 785             } else if (child instanceof Deviate_delete_stmtContext) {
 786                 deviate = stringFromNode(child);
 787             }
 788         }
 789         builder.setReference(reference);
 790         builder.setDeviate(deviate);
 791     }
 792
 793     @Override
 794     public void exitDeviation_stmt(YangParser.Deviation_stmtContext ctx) {
 795         final String actContainer = actualPath.pop();
 796         logger.debug("exiting " + actContainer);
 797     }
 798
 799     @Override
 800     public void enterConfig_stmt(YangParser.Config_stmtContext ctx) {
 801         boolean configuration = parseConfig(ctx);
 802         moduleBuilder.addConfiguration(configuration, actualPath);
 803     }
 804
 805     @Override
 806     public void enterIdentity_stmt(YangParser.Identity_stmtContext ctx) {
 807         final String identityName = stringFromNode(ctx);
 808         final QName identityQName = new QName(namespace, revision,
 809                 yangModelPrefix, identityName);
 810         IdentitySchemaNodeBuilder builder = moduleBuilder.addIdentity(
 811                 identityQName, actualPath, ctx.getStart().getLine());
 812         updatePath(identityName);
 813
 814         builder.setPath(createActualSchemaPath(actualPath, namespace, revision,
 815                 yangModelPrefix));
 816         parseSchemaNodeArgs(ctx, builder);
 817
 818         for (int i = 0; i < ctx.getChildCount(); i++) {
 819             ParseTree child = ctx.getChild(i);
 820             if (child instanceof Base_stmtContext) {
 821                 String baseIdentityName = stringFromNode(child);
 822                 builder.setBaseIdentityName(baseIdentityName);
 823             }
 824         }
 825     }
 826
 827     @Override
 828     public void exitIdentity_stmt(YangParser.Identity_stmtContext ctx) {
 829         final String actContainer = actualPath.pop();
 830         logger.debug("exiting " + actContainer);
 831     }
 832
 833     public ModuleBuilder getModuleBuilder() {
 834         return moduleBuilder;
 835     }
 836
 837     private void updatePath(String containerName) {
 838         actualPath.push(containerName);
 839     }
 840
 841 }