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