SchemaNodeStatement:
	DatadefStatement |
	ExtensionStatement |
	GroupingStatement |
	IdentityStatement |
	NotificationStatement |
	TypedefStatement
;

AugmentStatement:
	'augment' path=SchemaNodeIdentifier (';' | '{' 
		(augmentsubstatements+= AugmentSubStatement)*
		'}'
	)
;

SchemaNodeIdentifier returns SchemaNodeIdentifier:
	RootSchemaNodeIdentifier ({SchemaNodeIdentifier.target=current} '/' schemaNode=[SchemaNodeStatement])
	
;

RootSchemaNodeIdentifier returns SchemaNodeIdentifier:
	isAbsolute?= '/' schemaNode = [SchemaNodeStatement]
;

class YangDefinitionRuntimeModule extends AbstractYangDefinitionRuntimeModule {
	
	override bindIQualifiedNameProvider() {
		YangDefinitionQualifiedNameProvider
	}
	
	

  revision 2017-02-24 {
    description
     "Revision: v1.0";
  }

  container node {
	  container v1 {
		  uses nmos:version-1;
	  }
  }
  
  augment node /v1 /self                           //(Error)
  {
	  uses rc:restconf;
  }
  
  augment / node / v1 / self / mdp3020:restconf / data                   //(Error)
  {
	  uses mdp3020-from-snmp:MEDIALINKS-MDP3020;
  }  

  revision 2017-02-24 {
    description
     "Revision: v1.0";
  }

  container node {
	  container v1 {
		  uses nmos:version-1;
	  }
  }
  
  augment "/node/v1/self"                 //(correct output)
  {
	  uses rc:restconf;
  }
  
  augment "/node/v1/self/mdp3020:restconf/data"      //(correct output)
{
	  uses mdp3020-from-snmp:MEDIALINKS-MDP3020;
  }  

ContainerStatement:
	'container' name=STRINGARG  (';' | '{'
		(containersubstatements+= ContainerSubStatement)*
	'}')
;

ContainerSubStatement:
	ConfigStatement | 
	ContainerStatement |
	LeafStatement |
	ListStatement |
	LeafListStatement |
	DescriptionStatement |
	UsesStatement |
	UnknownStatement

AugmentStatement:
	'augment' path= SchemaNodeIdentifier 
	(';' | '{' 
		(augmentsubstatements+= AugmentSubStatement)*
		'}'
	)
;

AugmentSubStatement:
	DescriptionStatement |
	LeafStatement |
	LeafListStatement |
	UsesStatement |
	StatusStatement |
	UnknownStatement
;


 SchemaNodeIdentifier returns SchemaNodeIdentifier:
	'"' RootSchemaNodeIdentifier ({SchemaNodeIdentifier.target=current}'/'schemaNode=[ContainerStatement|QName])* '"'
;

RootSchemaNodeIdentifier returns SchemaNodeIdentifier:
	isAbsolute?='/'? schemaNode=[ContainerStatement|QName]
;

ContainerSubStatement:
	ConfigStatement | 
	ContainerStatement |
	LeafStatement |
	ListStatement |
	LeafListStatement |
	DescriptionStatement |
	UsesStatement |
	UnknownStatement
	
;

ConfigStatement:
	'config' boolarg=STRINGARG (';' | '{'
		(configunknownstatements+= UnknownStatement)*
		'}'
	)
;

UsesStatement:
	'uses' (pre=STRINGARG ':')? statement=[GroupingStatement] (';' | '{'
		(usessubstatements+= UsesSubStatement)*
		'}'
	);

UsesSubStatement:
	DescriptionStatement |
	ReferenceStatement |
	UnknownStatement
;

LeafStatement:
	'leaf' name=STRINGARG33 (';' | '{'
		(leafsubstatements+= LeafSubStatement)*
		'}'
	);
	
LeafSubStatement:
	TypeStatement |
	ConfigStatement | 
	DescriptionStatement |
	MandatoryStatement |
	StatusStatement |
	ReferenceStatement |
	UnknownStatement
;

TypeStatement:
	'type' (btype=BuiltInType | (prefix=STRINGARG ':') ? importtype=[TypedefStatement])
		(';' | '{'
		(typesubstatements+= TypeSubStatement)*
		'}'
	);
	
TypeSubStatement:
	LengthStatement |
	TypeStatement |
	PatternStatement |
	EnumStatement |
	RangeStatement|
	PathStatement |
	UnknownStatement
	;
	
PathStatement:
	'path' path=STRINGARG (';' | '{'
		(pathunknownstatements+= UnknownStatement)*
		'}'
	)
;

ListStatement:
	'list' name= (STRINGARG | KEY_IDENTIFIER) (';' | '{'
		(listsubstatements+= ListSubStatement)*
		'}'
	)
;

ListSubStatement:
	KeyStatement |
	DescriptionStatement |
	LeafStatement | 
	LeafListStatement |
	ConfigStatement |
	ContainerStatement |
	UsesStatement |
	ReferenceStatement |
	ChoiceStatement |
	UnknownStatement
;

LeafListStatement:
	'leaf-list' name=STRINGARG (';' | '{'
		(leafliststatements+= LeafListSubStatement)*
		'}'
	)
;

LeafListSubStatement:
	TypeStatement |
	ConfigStatement |
	DescriptionStatement |
	UnknownStatement
;

KeyStatement:
	'key' arg=(STRINGARG | STRINGARG2) (';' | '{' 
		(keyunknownstatements+= UnknownStatement)*
		'}'
	)
;

AugmentStatement:
	'augment' path= SchemaNodeIdentifier 
	(';' | '{' 
		(augmentsubstatements+= AugmentSubStatement)*
		'}'
	)
;

AugmentSubStatement:
	DescriptionStatement |
	LeafStatement |
	LeafListStatement |
	UsesStatement |
	StatusStatement |
	UnknownStatement
;


 SchemaNodeIdentifier returns SchemaNodeIdentifier:
	'"' RootSchemaNodeIdentifier ({SchemaNodeIdentifier.target=current}'/'schemaNode=[ContainerStatement|QName])* '"'
;

RootSchemaNodeIdentifier returns SchemaNodeIdentifier:
	isAbsolute?='/'? schemaNode=[ContainerStatement|QName]
;

AugmentStatement:
	'augment' path= SchemaNodeIdentifier 
	(';' | '{' 
		(augmentsubstatements+= AugmentSubStatement)*
		'}'
	)
;

AugmentSubStatement:
	DescriptionStatement |
	LeafStatement |
	LeafListStatement |
	UsesStatement |
	StatusStatement |
	UnknownStatement
;

SchemaNodeIdentifier returns SchemaNodeIdentifier:
	 RootSchemaNodeIdentifier ({SchemaNodeIdentifier.target=current}'/'(schemaNode=[ContainerStatement|QName]))*
;

RootSchemaNodeIdentifier returns SchemaNodeIdentifier:
	isAbsolute?='/'? schemaNode=[ContainerStatement|QName]
;

grammar org.xtext.yang.yangdefinition.YangDefinition with org.eclipse.xtext.common.Terminals

generate yangDefinition "http://www.xtext.org/yang/yangdefinition/YangDefinition"

import "http://www.eclipse.org/emf/2002/Ecore" as ecore

YangFile:
	Module | SubModule
;

Module:
	'module' name=STRINGARG
	'{'
	(statements+=ModuleStatement)*
	'}'
;

ModuleStatement:
	YangVersionStatement |
	NamespaceStatement | 
	PrefixStatement |
	ImportStatement |
	OragnizationStatement|
	ContactStatement |
	DescriptionStatement |
	RevisionStatement |
	DatadefStatement|
	TypedefStatement |
	IdentityStatement|
	ExtensionStatement |
	GroupingStatement |
	NotificationStatement |
	AugmentStatement |
	IncludeStatement |
	UnknownStatement
	
;

SubModule:
	'submodule' name = STRINGARG
	'{'
		(statements+= SubModuleStatement)*
	'}'
;

SubModuleStatement:
	YangVersionStatement |
	ImportStatement |
	OragnizationStatement |
	ContactStatement |
	DescriptionStatement |
	RevisionStatement |
	DatadefStatement |
	TypedefStatement |
	IdentityStatement |
	ExtensionStatement |
	GroupingStatement |
	NotificationStatement |
	AugmentStatement |
	IncludeStatement|
	BelongsToStatement |
	UnknownStatement
;


DatadefStatement:
	ContainerStatement |
	LeafStatement |
	ListStatement |
	LeafListStatement
;

YangVersionStatement:
	'yang-version' version = STRINGARG
	(';' | '{'
		(yangversionunknownstatement+= UnknownStatement)*
		'}'
	)
;

NamespaceStatement:
	'namespace' uri= (STRINGARG4 | STRINGARG)
	(';' | '{'
		(namespaceunknownstatement+= UnknownStatement)*
		'}'
	);
	
PrefixStatement:
	'prefix' pre=STRINGARG 
	( ';' | '{'
		(prefixunknownstatement += UnknownStatement)*
		'}'	
	);
	
ImportStatement:
	'import' ImportURI=[YangFile | STRINGARG] 
	(';' | '{'
	(importsubstatements+= ImportSubStatement)*
	'}');
	
ImportSubStatement:
	PrefixStatement |
	RevisionStatement |
	TypeStatement|
	UnknownStatement
;

//identifier-arg-str	
IncludeStatement:
	'include' importURI=[YangFile | STRINGARG]
	(';' 
	|'{' (includesubstatements+=IncludeSubstatements)* '}');
IncludeSubstatements:
	(RevisionStatement |
	RevisionDateStatement |
	TypeStatement |
	UnknownStatement)
	;

	
RevisionDateStatement:
	'revision-date' date=(STRINGARG | DATE) (';' | '{'
		(revisiondateunknownstatements+= UnknownStatement)
		'}'
	)
;

OragnizationStatement:
	'organization' name=STRINGARG (';' | '{'
			(organizationunknownstatements+= UnknownStatement)*
		'}'
	);
	
ContactStatement:
	'contact' name=STRINGARG (';' | '{'
			(contactunknownstatements+= UnknownStatement)*
		'}'
	);
	
DescriptionStatement:
	'description' name=STRINGARG (';' | '{'
			(descriptionunknownstatements+= UnknownStatement)*
		'}'
	);

RevisionStatement:
	'revision' date=(STRINGARG | DATE) (';' | '{'
			(revisionsubstatements+= RevisionSubStatement)*
		'}'
	);

RevisionSubStatement:
	DescriptionStatement |
	ReferenceStatement|
	UnknownStatement
;

ReferenceStatement:
	'reference' (name=STRINGARG) (';' | '{'
		(referenceunknownstatements+=UnknownStatement)*
		'}'
	)
;

BelongsToStatement:
	'belongs-to' name=[ Module | STRINGARG] (';' | '{'
		(belongstosubstatements+= BelongsToSubStatement)*
		'}'
	)
;

BelongsToSubStatement:
	PrefixStatement |
	UnknownStatement
;

IdentityStatement:
	'identity' name=STRINGARG (';' | '{'
		(identitysubstatements+=IdentitySubstatement)*
		'}'
	);
	
IdentitySubstatement:
	DescriptionStatement |
	UnknownStatement
;

ExtensionStatement:
	'extension' name=(STRINGARG | KEY_IDENTIFIER) (';' | '{'
		(extensionsubstatements+=ExtensionSubStatement)*
		'}'
	)
;

ExtensionSubStatement:
ArgumentStatement |
DescriptionStatement|
ReferenceStatement |
StatusStatement |
UnknownStatement
;

ArgumentStatement:
	'argument' arg= STRINGARG33 
	(';' | '{'
		(argumentsubstatement += ArgumentSubStatement)*
		'}'
	)
;

ArgumentSubStatement:
	YinElement |
	UnknownStatement
;

YinElement:
	'yin-element' boolarg=STRINGARG (';' | '{'
		(yinunknownstatements+= UnknownStatement)*
		'}'
	)
	;

ContainerStatement:
	'container' name=STRINGARG33 (';' | '{'
		(containersubstatements+= ContainerSubStatement)*
	'}')
;

ContainerSubStatement:
	ConfigStatement | 
	ContainerStatement |
	LeafStatement |
	ListStatement |
	LeafListStatement |
	DescriptionStatement |
	UsesStatement |
	UnknownStatement
	
;

ConfigStatement:
	'config' boolarg=STRINGARG (';' | '{'
		(configunknownstatements+= UnknownStatement)*
		'}'
	)
;

UsesStatement:
	'uses' (pre=STRINGARG ':')? statement=[GroupingStatement] (';' | '{'
		(usessubstatements+= UsesSubStatement)*
		'}'
	);

UsesSubStatement:
	DescriptionStatement |
	ReferenceStatement |
	UnknownStatement
;

LeafStatement:
	'leaf' name=STRINGARG33 (';' | '{'
		(leafsubstatements+= LeafSubStatement)*
		'}'
	);
	
LeafSubStatement:
	TypeStatement |
	ConfigStatement | 
	DescriptionStatement |
	MandatoryStatement |
	StatusStatement |
	ReferenceStatement |
	UnknownStatement
;

TypeStatement:
	'type' (btype=BuiltInType | (prefix=STRINGARG ':') ? importtype=[TypedefStatement])
		(';' | '{'
		(typesubstatements+= TypeSubStatement)*
		'}'
	);
	
TypeSubStatement:
	LengthStatement |
	TypeStatement |
	PatternStatement |
	EnumStatement |
	RangeStatement|
	PathStatement |
	UnknownStatement
	;
	
PathStatement:
	'path' path=STRINGARG (';' | '{'
		(pathunknownstatements+= UnknownStatement)*
		'}'
	)
;
	
StatusStatement:
	'status' status=STRINGARG (';' | '{'
		(statusunknownstatements+= UnknownStatement)*
		'}'
	)
;

MandatoryStatement:
	'mandatory' boolarg = STRINGARG (';' | '{'
		(mandatoryunknownstatements+= UnknownStatement)*
		'}'
	)
;

LengthStatement:
	'length' length = STRINGARG (';' | '{'
		(lengthunknownstatements+= UnknownStatement)*
		'}'
	);
	
PatternStatement:
	'pattern' arg=STRINGARG (';' | '{'
		(patternunknownstatements+= UnknownStatement)*
		'}'
	);

EnumStatement:
	'enum' name=(STRINGARG | KEY_IDENTIFIER) (';' | '{' 
		(enumsubstatements+= EnumSubStatement)*
		'}'
	);

RangeStatement:
	'range' range=STRINGARG  (';' | '{'
		(rangeunknownstatements+=UnknownStatement)*
		'}'
	)
;	
	
EnumSubStatement:
	ValueStatement |
	DescriptionStatement |
	UnknownStatement
;

ValueStatement:
	'value' intarg= STRINGARG (';' | '{'
		(valueunknownstatements+= UnknownStatement)*
		'}'
	) 
;

TypedefStatement:
	'typedef' name=(STRINGARG | KEY_IDENTIFIER) (';' | '{'
		(typedefsubstatemenents+=TypedefSubStatement)*
		'}'
	);
	
TypedefSubStatement:
	TypeStatement |
	DescriptionStatement|
	ReferenceStatement |
	DefaultStatement |
	StatusStatement |
	UnknownStatement
;

DefaultStatement:
	'default' arg=STRINGARG (';' | '{'
		(defaultunknownstatements+=UnknownStatement)*
		'}'
	) 
;

ListStatement:
	'list' name= (STRINGARG | KEY_IDENTIFIER) (';' | '{'
		(listsubstatements+= ListSubStatement)*
		'}'
	)
;

ListSubStatement:
	KeyStatement |
	DescriptionStatement |
	LeafStatement | 
	LeafListStatement |
	ConfigStatement |
	ContainerStatement |
	UsesStatement |
	ReferenceStatement |
	ChoiceStatement |
	UnknownStatement
;

LeafListStatement:
	'leaf-list' name=STRINGARG (';' | '{'
		(leafliststatements+= LeafListSubStatement)*
		'}'
	)
;

LeafListSubStatement:
	TypeStatement |
	ConfigStatement |
	DescriptionStatement |
	UnknownStatement
;

KeyStatement:
	'key' arg=(STRINGARG | STRINGARG2) (';' | '{' 
		(keyunknownstatements+= UnknownStatement)*
		'}'
	)
;

ChoiceStatement:
	'choice' name=STRINGARG (';' | '{'
		(choicesubstatements+=ChoiceSubStatement)*
		'}'
	)
;

ChoiceSubStatement:
	DescriptionStatement |
	CaseStatement |
	UnknownStatement
;

CaseStatement:
	'case' name=STRINGARG33 (';' | '{'
		(casesubstatements+= CaseSubStatement)*
		'}'
	)
;

CaseSubStatement:
	LeafStatement |
	UnknownStatement
;

GroupingStatement:
	'grouping' name=STRINGARG33 (';' | '{'
		(groupingsubstatements+= GroupingSubStatement)*
		'}'
	)
;

GroupingSubStatement:
	LeafStatement |
	LeafListStatement |
	ListStatement |
	TypeStatement |
	UsesStatement |
	ContainerStatement |
	DescriptionStatement
;

NotificationStatement:
	'notification' name = STRINGARG (';' | '{'
		(notificationsubstatements+= NotificationSubStatement)*
		'}'
	);
	
NotificationSubStatement:
	DescriptionStatement |
	ContainerStatement |
	UnknownStatement
;

AugmentStatement:
	'augment' path= SchemaNodeIdentifier 
	(';' | '{' 
		(augmentsubstatements+= AugmentSubStatement)*
		'}'
	)
;

AugmentSubStatement:
	DescriptionStatement |
	LeafStatement |
	LeafListStatement |
	UsesStatement |
	StatusStatement |
	UnknownStatement
;


SchemaNodeIdentifier returns SchemaNodeIdentifier:
	 RootSchemaNodeIdentifier ({SchemaNodeIdentifier.target=current}'/'(schemaNode=[ContainerStatement|QName]))*
;

RootSchemaNodeIdentifier returns SchemaNodeIdentifier:
	isAbsolute?='/'? schemaNode=[ContainerStatement|QName]
;

UnknownStatement:
	((pre=STRINGARG ':')? (extension=[ExtensionStatement]) (arg=STRINGARG)?)
	(';'
		| '{'
			(unknownsubstatements+= UnknownSubStatement)*
		'}'
	);
	
	
UnknownSubStatement:
	DescriptionStatement |
	TypeStatement|
	StatusStatement |
	DefaultStatement |
	UnspecifiedStatement
;

UnspecifiedStatement:
	((pre=STRINGARG ':')? (statement=[ExtensionStatement]) (arg=STRINGARG)?)
	(';' | '{'
		(unknownsubstatements+= UnknownSubStatement)* '}'	
	);

BuiltInType:
	(btype = (
	  'binary'
	| 'bits'
	| 'boolean'
	| 'decimal64'
	| 'empty' 
    | 'enumeration'
    | 'identityref'
    | 'instance-identifier'
    | 'int8'
    | 'int16'
    | 'int32'
    | 'int64'
    | 'leafref'
    | 'string'
    | 'uint8'
    | 'uint16'
    | 'uint32'
    | 'uint64'
    | 'union'
    ))
    ;

KEY_IDENTIFIER:
	=>'value' | =>'status' | =>'namespace' | =>'notification' |=> 'path' |=> 'description' |
	=> 'string' | =>'error-message' |=>'config' |=>'range' | =>'revision' | =>'type' | 
	=>'boolean' | =>'prefix' | =>'range' | => 'key' | =>'fraction-digits';

//Lexer Rules

QName:
	(STRINGARG ':')? STRINGARG
;

STRINGARG:
	ID | 'default' | INT | CUSTOMSTRING ;
	
STRINGARG33:
	KEY_IDENTIFIER | STRINGARG;
	
STRINGARG2:
	ID ':' ID ;

STRINGARG4:
	((ID+':'+ID)+(':'+ID) * | (':'KEY_IDENTIFIER)*);
	
CUSTOMSTRING:
	(STRING ('+' STRING)*);

terminal ID: 
    ('^')?('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'-'|'/'|'.'|'\"'|'0'..'9')*;
    
terminal DATE:
	INT'-'INT'-'INT;

package org.xtext.yang.yangdefinition;

import javax.inject.Inject;

import org.eclipse.xtext.naming.DefaultDeclarativeQualifiedNameProvider;
import org.eclipse.xtext.naming.IQualifiedNameConverter;
import org.eclipse.xtext.naming.QualifiedName;
import org.xtext.yang.yangdefinition.yangDefinition.ContainerStatement;
import org.xtext.yang.yangdefinition.yangDefinition.ExtensionStatement;
import org.xtext.yang.yangdefinition.yangDefinition.GroupingStatement;
import org.xtext.yang.yangdefinition.yangDefinition.TypedefStatement;

public class YangDefinitionQualifiedNameProvider extends DefaultDeclarativeQualifiedNameProvider {

	@Inject
	private IQualifiedNameConverter qnc;
	
	public QualifiedName qualifiedName(TypedefStatement s) {
		return qnc.toQualifiedName(s.getName());
	}
	
	public QualifiedName qualifiedName(GroupingStatement g) {
		return qnc.toQualifiedName(g.getName());
	}
	
	public QualifiedName qualifiedName(ExtensionStatement e) {
		return qnc.toQualifiedName(e.getName());
	}
	
	public QualifiedName qualifiedName(ContainerStatement c) {
		return qnc.toQualifiedName(c.getName());
	}
	

}

  augment "/node/v1/self"
  {
	  uses rc:restconf;
  }
  
  augment "/node/v1/self/mdp3020:restconf/data"
  {
	  uses mdp3020-from-snmp:MEDIALINKS-MDP3020;
  }  

grouping restconf{

container restconf{
                          ...
container data {
                           ...
    }
  }
}

grouping restconf {
        
description "Added to pass pyang --ietf validation";    	
      
container restconf {
       
 description
          "Conceptual container representing the
         application/yang.api resource type.";
        
container data {
          
description
            "Container representing the application/yang.datastore
           resource type. Represents the conceptual root of all
           operational data and configuration data supported by
           the server.  The child nodes of this container can be
           any data resource (application/yang.data), which are
           defined as top-level data nodes from the YANG modules
           advertised by the server in the ietf-restconf-monitoring
           module.";
        }  // container data

SchemaNodeIdentifier returns SchemaNodeIdentifier:
	 RootSchemaNodeIdentifier ({SchemaNodeIdentifier.target=current}'/'((prefix=STRINGARG':')? schemaNode=[ContainerStatement]))*
;

RootSchemaNodeIdentifier returns SchemaNodeIdentifier:
	isAbsolute?='/'? ((prefix=STRINGARG':')?schemaNode=[ContainerStatement])
;

package org.xtext.yang.yangdefinition;

import javax.inject.Inject;

import org.eclipse.xtext.naming.DefaultDeclarativeQualifiedNameProvider;
import org.eclipse.xtext.naming.IQualifiedNameConverter;
import org.eclipse.xtext.naming.QualifiedName;
import org.xtext.yang.yangdefinition.yangDefinition.ContainerStatement;
import org.xtext.yang.yangdefinition.yangDefinition.ExtensionStatement;
import org.xtext.yang.yangdefinition.yangDefinition.GroupingStatement;
import org.xtext.yang.yangdefinition.yangDefinition.TypedefStatement;

public class YangDefinitionQualifiedNameProvider extends DefaultDeclarativeQualifiedNameProvider {

	@Inject
	private IQualifiedNameConverter qnc;
	
	public QualifiedName qualifiedName(TypedefStatement s) {
		return qnc.toQualifiedName(s.getName());
	}
	
	public QualifiedName qualifiedName(GroupingStatement g) {
		return qnc.toQualifiedName(g.getName());
	}
	
	public QualifiedName qualifiedName(ExtensionStatement e) {
		return qnc.toQualifiedName(e.getName());
	}
	
	public QualifiedName qualifiedName(ContainerStatement c) {
		return qnc.toQualifiedName(c.getName());
	}
	

}

/*
 * generated by Xtext 2.10.0
 */
package org.xtext.yang.yangdefinition



/**
 * Use this class to register components to be used at runtime / without the Equinox extension registry.
 */
class YangDefinitionRuntimeModule extends AbstractYangDefinitionRuntimeModule {
	
	override bindIQualifiedNameProvider() {
		YangDefinitionQualifiedNameProvider
	}
	
	
}