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