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