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