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