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