rubyang 0.1.2.1 → 0.1.3

data/lib/rubyang/model/parser/parser.y

@@ -9,6 +9,7 @@ rule
 
 	"module-stmt"			:	"module-keyword" "identifier-arg-str"
 						"{"
+							"stmtsep"
 							"module-header-stmts"
 							"linkage-stmts"
 							"meta-stmts"
@@ -22,6 +23,7 @@ rule
 
 	"submodule-stmt"		:	"submodule-keyword" "identifier-arg-str"
 						"{"
+							"stmtsep"
 							"submodule-header-stmts"
 							"linkage-stmts"
 							"meta-stmts"
@@ -37,9 +39,9 @@ rule
 							{
 								result = []
 							}
-					|	"module-header-stmts" "module-header-stmt"
+					|	"module-header-stmts" "module-header-stmt" "stmtsep"
 							{
-								result = val[0] + [val[1]]
+								result = val[0] + [val[1]] + val[2]
 							}
 
 	"module-header-stmt"		:	"yang-version-stmt"
@@ -50,9 +52,9 @@ rule
 							{
 								result = []
 							}
-					|	"submodule-header-stmts" "submodule-header-stmt"
+					|	"submodule-header-stmts" "submodule-header-stmt" "stmtsep"
 							{
-								result = val[0] + [val[1]]
+								result = val[0] + [val[1]] + val[2]
 							}
 
 	"submodule-header-stmt"		:	"yang-version-stmt"
@@ -62,9 +64,9 @@ rule
 							{
 								result = []
 							}
-					|	"meta-stmts" "meta-stmt"
+					|	"meta-stmts" "meta-stmt" "stmtsep"
 							{
-								result = val[0] + [val[1]]
+								result = val[0] + [val[1]] + val[2]
 							}
 
 	"meta-stmt"			:	"organization-stmt"
@@ -76,9 +78,9 @@ rule
 							{
 								result = []
 							}
-					|	"linkage-stmts" "linkage-stmt"
+					|	"linkage-stmts" "linkage-stmt" "stmtsep"
 							{
-								result = val[0] + [val[1]]
+								result = val[0] + [val[1]] + val[2]
 							}
 
 	"linkage-stmt"			:	"import-stmt"
@@ -88,18 +90,18 @@ rule
 							{
 								result = []
 							}
-					|	"revision-stmts" "revision-stmt"
+					|	"revision-stmts" "revision-stmt" "stmtsep"
 							{
-								result = val[0] + [val[1]]
+								result = val[0] + [val[1]] + val[2]
 							}
 
 	"body-stmts"			:	/*  */
 							{
 								result = []
 							}
-					|	"body-stmts" "body-stmt"
+					|	"body-stmts" "body-stmt" "stmtsep"
 							{
-								result = val[0] + [val[1]]
+								result = val[0] + [val[1]] + val[2]
 							}
 
 	"body-stmt"			:	"extension-stmt"
@@ -123,7 +125,7 @@ rule
 
 	"yang-version-stmt"		:	"yang-version-keyword" "yang-version-arg-str" "stmtend"
 							{
-								result = Rubyang::Model::YangVersion.new( val[1] )
+								result = Rubyang::Model::YangVersion.new( val[1], val[2] )
 							}
 
 	"yang-version-arg-str"		:	"string"
@@ -134,9 +136,13 @@ rule
 								result = val[0]
 							}
 
-	"import-stmt"			:	"import-keyword" "identifier-arg-str" "{" "inner-import-stmts" "}"
+	"import-stmt"			:	"import-keyword" "identifier-arg-str"
+						"{"
+							"stmtsep"
+							"inner-import-stmts"
+						"}"
 							{
-								substmts = val[3]
+								substmts = val[3] + val[4]
 								result = Rubyang::Model::Import.new( val[1], substmts )
 							}
 
@@ -144,9 +150,9 @@ rule
 							{
 								result = []
 							}
-					|	"inner-import-stmts" "inner-import-stmt"
+					|	"inner-import-stmts" "inner-import-stmt" "stmtsep"
 							{
-								result = val[0] + [val[1]]
+								result = val[0] + [val[1]] + val[2]
 							}
 
 	"inner-import-stmt"		:	"prefix-stmt"
@@ -156,9 +162,13 @@ rule
 							{
 								result = Rubyang::Model::Include.new( val[1] )
 							}
-					|	"include-keyword" "identifier-arg-str" "{" "inner-include-stmts" "}"
+					|	"include-keyword" "identifier-arg-str"
+						"{"
+							"stmtsep"
+							"inner-include-stmts"
+						"}"
 							{
-								substmts = val[3]
+								substmts = val[3] + val[4]
 								result = Rubyang::Model::Include.new( val[1], substmts )
 							}
 
@@ -166,16 +176,16 @@ rule
 							{
 								result = []
 							}
-					|	"inner-include-stmts" "inner-include-stmt"
+					|	"inner-include-stmts" "inner-include-stmt" "stmtsep"
 							{
-								result = val[0] + [val[1]]
+								result = val[0] + [val[1]] + val[2]
 							}
 
 	"inner-include-stmt"		:	"revision-date-stmt"
 
 	"namespace-stmt"		:	"namespace-keyword" "uri-str" "stmtend"
 							{
-								result = Rubyang::Model::Namespace.new( val[1] )
+								result = Rubyang::Model::Namespace.new( val[1], val[2] )
 							}
 
 	"uri-str"			:	"string"
@@ -188,47 +198,55 @@ rule
 
 	"prefix-stmt"			:	"prefix-keyword" "prefix-arg-str" "stmtend"
 							{
-								result = Rubyang::Model::Prefix.new( val[1] )
+								result = Rubyang::Model::Prefix.new( val[1], val[2] )
 							}
 
-	"belongs-to-stmt"		:	"belongs-to-keyword" "identifier-arg-str" "{" "prefix-stmt" "}"
+	"belongs-to-stmt"		:	"belongs-to-keyword" "identifier-arg-str"
+						"{"
+							"stmtsep"
+							"prefix-stmt" "stmtsep"
+						"}"
 							{
-								substmts = [val[3]]
+								substmts = val[3] + [val[4]] + val[5]
 								result = Rubyang::Model::BelongsTo.new( val[1], substmts )
 							}
 
 	"organization-stmt"		:	"organization-keyword" "string" "stmtend"
 							{
-								result = Rubyang::Model::Organization.new( val[1] )
+								result = Rubyang::Model::Organization.new( val[1], val[2] )
 							}
 
 	"contact-stmt"			:	"contact-keyword" "string" "stmtend"
 							{
-								result = Rubyang::Model::Contact.new( val[1] )
+								result = Rubyang::Model::Contact.new( val[1], val[2] )
 							}
 
 	"description-stmt"		:	"description-keyword" "string" "stmtend"
 							{
-								result = Rubyang::Model::Description.new( val[1] )
+								result = Rubyang::Model::Description.new( val[1], val[2] )
 							}
 
 	"reference-stmt"		:	"reference-keyword" "string" "stmtend"
 							{
-								result = Rubyang::Model::Reference.new( val[1] )
+								result = Rubyang::Model::Reference.new( val[1], val[2] )
 							}
 
 	"units-stmt"			:	"units-keyword" "string" "stmtend"
 							{
-								result = Rubyang::Model::Units.new( val[1] )
+								result = Rubyang::Model::Units.new( val[1], val[2] )
 							}
 
 	"revision-stmt"			:	"revision-keyword" "revision-date" ";"
 							{
 								result = Rubyang::Model::Revision.new( val[1] )
 							}
-					|	"revision-keyword" "revision-date" "{" "inner-revision-stmts" "}"
+					|	"revision-keyword" "revision-date"
+						"{"
+							"stmtsep"
+							"inner-revision-stmts"
+						"}"
 							{
-								substmts = val[3]
+								substmts = val[3] + val[4]
 								result = Rubyang::Model::Revision.new( val[1], substmts )
 							}
 
@@ -236,9 +254,9 @@ rule
 							{
 								result = []
 							}
-					|	"inner-revision-stmts" "inner-revision-stmt"
+					|	"inner-revision-stmts" "inner-revision-stmt" "stmtsep"
 							{
-								result = val[0] + [val[1]]
+								result = val[0] + [val[1]] + val[2]
 							}
 
 	"inner-revision-stmt"		:	"description-stmt"
@@ -248,16 +266,20 @@ rule
 
 	"revision-date-stmt"		:	"revision-date-keyword" "revision-date" "stmtend"
 							{
-								result = Rubyang::Model::RevisionDate.new( val[1] )
+								result = Rubyang::Model::RevisionDate.new( val[1], val[2] )
 							}
 
 	"extension-stmt"		:	"extension-keyword" "identifier-arg-str" ";"
 							{
 								result = Rubyang::Model::Extension.new( val[1] )
 							}
-					|	"extension-keyword" "identifier-arg-str" "{" "inner-extension-stmts" "}"
+					|	"extension-keyword" "identifier-arg-str"
+						"{"
+							"stmtsep"
+							"inner-extension-stmts"
+						"}"
 							{
-								substmts = val[3]
+								substmts = val[3] + val[4]
 								result = Rubyang::Model::Extension.new( val[1], substmts )
 							}
 
@@ -265,9 +287,9 @@ rule
 							{
 								result = []
 							}
-					|	"inner-extension-stmts" "inner-extension-stmt"
+					|	"inner-extension-stmts" "inner-extension-stmt" "stmtsep"
 							{
-								result = val[0] + [val[1]]
+								result = val[0] + [val[1]] + val[2]
 							}
 
 	"inner-extension-stmt"		:	"argument-stmt"
@@ -279,9 +301,13 @@ rule
 							{
 								result = Rubyang::Model::Argument.new( val[1] )
 							}
-					|	"argument-keyword" "identifier-arg-str" "{" "inner-argument-stmts" "}"
+					|	"argument-keyword" "identifier-arg-str"
+						"{"
+							"stmtsep"
+							"inner-argument-stmts"
+						"}"
 							{
-								substmts = val[3]
+								substmts = val[3] + val[4]
 								result = Rubyang::Model::Argument.new( val[1], substmts )
 							}
 
@@ -289,16 +315,16 @@ rule
 							{
 								result = []
 							}
-					|	"inner-argument-stmts" "inner-argument-stmt"
+					|	"inner-argument-stmts" "inner-argument-stmt" "stmtsep"
 							{
-								result = val[0] + [val[1]]
+								result = val[0] + [val[1]] + val[2]
 							}
 
 	"inner-argument-stmt"		:	"yin-element-stmt"
 
-	"yin-element-stmt"		:	"yin-element-keyword" "yin-element-arg-str" ";"
+	"yin-element-stmt"		:	"yin-element-keyword" "yin-element-arg-str" "stmtend"
 							{
-								result = Rubyang::Model::YinElement.new( val[1] )
+								result = Rubyang::Model::YinElement.new( val[1], val[2] )
 							}
 
 	"yin-element-arg-str"		:	"string"
@@ -313,9 +339,13 @@ rule
 							{
 								result = Rubyang::Model::Identity.new( val[1] )
 							}
-					|	"identity-keyword" "identifier-arg-str" "{" "inner-identity-stmts" "}"
+					|	"identity-keyword" "identifier-arg-str"
+						"{"
+							"stmtsep"
+							"inner-identity-stmts"
+						"}"
 							{
-								substmts = val[3]
+								substmts = val[3] + val[4]
 								result = Rubyang::Model::Identity.new( val[1], substmts )
 							}
 
@@ -323,9 +353,9 @@ rule
 							{
 								result = []
 							}
-					|	"inner-identity-stmts" "inner-identity-stmt"
+					|	"inner-identity-stmts" "inner-identity-stmt" "stmtsep"
 							{
-								result = val[0] + [val[1]]
+								result = val[0] + [val[1]] + val[2]
 							}
 
 	"inner-identity-stmt"		:	"base-stmt"
@@ -333,18 +363,22 @@ rule
 					|	"description-stmt"
 					|	"reference-stmt"
 
-	"base-stmt"			:	"base-keyword" "identifier-ref-arg-str" ";"
+	"base-stmt"			:	"base-keyword" "identifier-ref-arg-str" "stmtend"
 							{
-								result = Rubyang::Model::Base.new( val[1] )
+								result = Rubyang::Model::Base.new( val[1], val[2] )
 							}
 
 	"feature-stmt"			:	"feature-keyword" "identifier-arg-str" ";"
 							{
 								result = Rubyang::Model::Feature.new( val[1] )
 							}
-					|	"feature-keyword" "identifier-arg-str" "{" "inner-feature-stmts" "}"
+					|	"feature-keyword" "identifier-arg-str"
+						"{"
+							"stmtsep"
+							"inner-feature-stmts"
+						"}"
 							{
-								substmts = val[3]
+								substmts = val[3] + val[4]
 								result = Rubyang::Model::Feature.new( val[1], substmts )
 							}
 
@@ -352,9 +386,9 @@ rule
 							{
 								result = []
 							}
-					|	"inner-feature-stmts" "inner-feature-stmt"
+					|	"inner-feature-stmts" "inner-feature-stmt" "stmtsep"
 							{
-								result = val[0] + [val[1]]
+								result = val[0] + [val[1]] + val[2]
 							}
 
 	"inner-feature-stmt"		:	"if-feature-stmt"
@@ -364,12 +398,16 @@ rule
 
 	"if-feature-stmt"		:	"if-feature-keyword" "identifier-ref-arg-str" "stmtend"
 							{
-								result = Rubyang::Model::IfFeature.new( val[1] )
+								result = Rubyang::Model::IfFeature.new( val[1], val[2] )
 							}
 
-	"typedef-stmt"			:	"typedef-keyword" "identifier-arg-str" "{" "inner-typedef-stmts" "}"
+	"typedef-stmt"			:	"typedef-keyword" "identifier-arg-str"
+						"{"
+							"stmtsep"
+							"inner-typedef-stmts"
+						"}"
 							{
-								substmts = val[3]
+								substmts = val[3] + val[4]
 								result = Rubyang::Model::Typedef.new( val[1], substmts )
 							}
 
@@ -377,9 +415,9 @@ rule
 							{
 								result = []
 							}
-					|	"inner-typedef-stmts" "inner-typedef-stmt"
+					|	"inner-typedef-stmts" "inner-typedef-stmt" "stmtsep"
 							{
-								result = val[0] + [val[1]]
+								result = val[0] + [val[1]] + val[2]
 							}
 
 	"inner-typedef-stmt"		:	"type-stmt"
@@ -393,9 +431,13 @@ rule
 							{
 								result = Rubyang::Model::Type.new( val[1] )
 							}
-					|	"type-keyword" "identifier-ref-arg-str" "{" "type-body-stmts" "}"
+					|	"type-keyword" "identifier-ref-arg-str"
+						"{"
+							"stmtsep"
+							"type-body-stmts"
+						"}"
 							{
-								substmts = val[3]
+								substmts = val[3] + val[4]
 								result = Rubyang::Model::Type.new( val[1], substmts )
 							}
 
@@ -409,18 +451,22 @@ rule
 					|	"bits-specification"
 					|	"union-specification"
 
-	"numerical-restrictions"	:	"range-stmt"
+	"numerical-restrictions"	:	"range-stmt" "stmtsep"
 							{
-								result = [val[0]]
+								result = [val[0]] + val[1]
 							}
 
 	"range-stmt"			:	"range-keyword" "range-arg-str" ";"
 							{
 								result = Rubyang::Model::Range.new( val[1] )
 							}
-					|	"range-keyword" "range-arg-str" "{" "inner-range-stmts" "}"
+					|	"range-keyword" "range-arg-str"
+						"{"
+							"stmtsep"
+							"inner-range-stmts"
+						"}"
 							{
-								substmts = val[3]
+								substmts = val[3] + val[4]
 								result = Rubyang::Model::Range.new( val[1], substmts )
 							}
 
@@ -428,9 +474,9 @@ rule
 							{
 								result = []
 							}
-					|	"inner-range-stmts" "inner-range-stmt"
+					|	"inner-range-stmts" "inner-range-stmt" "stmtsep"
 							{
-								result = val[0] + [val[1]]
+								result = val[0] + [val[1]] + val[2]
 							}
 
 	"inner-range-stmt"		:	"error-message-stmt"
@@ -438,22 +484,24 @@ rule
 					|	"description-stmt"
 					|	"reference-stmt"
 
-	"decimal64-specification"	:	"fraction-digits-stmt"
+	"decimal64-specification"	:	"fraction-digits-stmt" "stmtsep"
 							{
-								result = [val[0]]
+								result = [val[0]] + val[1]
 							}
-					|	"fraction-digits-stmt" "range-stmt"
+					|	"fraction-digits-stmt" "stmtsep"
+						"range-stmt" "stmtsep"
 							{
-								result = [val[0], val[1]]
+								result = [val[0]] + val[1] + [val[2]] + val[3]
 							}
-					|	"range-stmt" "fraction-digits-stmt"
+					|	"range-stmt" "stmtsep"
+						"fraction-digits-stmt" "stmtsep"
 							{
-								result = [val[1], val[0]]
+								result = [val[0]] + val[1] + [val[2]] + val[3]
 							}
 
 	"fraction-digits-stmt"		:	"fraction-digits-keyword" "fraction-digits-arg-str" "stmtend"
 							{
-								result = Rubyang::Model::FractionDigits.new( val[1] )
+								result = Rubyang::Model::FractionDigits.new( val[1], val[2] )
 							}
 
 	"fraction-digits-arg-str"	:	"string"
@@ -468,9 +516,9 @@ rule
 							{
 								result = []
 							}
-					|	"string-restrictions" "string-restriction"
+					|	"string-restrictions" "string-restriction" "stmtsep"
 							{
-								result = val[0] + [val[1]]
+								result = val[0] + [val[1]] + val[2]
 							}
 
 	"string-restriction"		:	"length-stmt"
@@ -480,9 +528,13 @@ rule
 							{
 								result = Rubyang::Model::Length.new( val[1] )
 							}
-					|	"length-keyword" "length-arg-str" "{" "inner-length-stmts" "}"
+					|	"length-keyword" "length-arg-str"
+						"{"
+							"stmtsep"
+							"inner-length-stmts"
+						"}"
 							{
-								substmts = val[3]
+								substmts = val[3] + val[4]
 								result = Rubyang::Model::Length.new( val[1], substmts )
 							}
 
@@ -490,9 +542,9 @@ rule
 							{
 								result = []
 							}
-					|	"inner-length-stmts" "inner-length-stmt"
+					|	"inner-length-stmts" "inner-length-stmt" "stmtsep"
 							{
-								result = val[0] + [val[1]]
+								result = val[0] + [val[1]] + val[2]
 							}
 
 	"inner-length-stmt"		:	"error-message-stmt"
@@ -504,9 +556,13 @@ rule
 							{
 								result = Rubyang::Model::Pattern.new( val[1] )
 							}
-					|	"pattern-keyword" "string" "{" "inner-pattern-stmts" "}"
+					|	"pattern-keyword" "string"
+						"{"
+							"stmtsep"
+							"inner-pattern-stmts"
+						"}"
 							{
-								substmts = val[3]
+								substmts = val[3] + val[4]
 								result = Rubyang::Model::Pattern.new( val[1], substmts )
 							}
 
@@ -514,9 +570,9 @@ rule
 							{
 								result = []
 							}
-					|	"inner-pattern-stmts" "inner-pattern-stmt"
+					|	"inner-pattern-stmts" "inner-pattern-stmt" "stmtsep"
 							{
-								result = val[0] + [val[1]]
+								result = val[0] + [val[1]] + val[2]
 							}
 
 	"inner-pattern-stmt"		:	"error-message-stmt"
@@ -526,25 +582,29 @@ rule
 
 	"default-stmt"			:	"default-keyword" "string" "stmtend"
 							{
-								result = Rubyang::Model::Default.new( val[1] )
+								result = Rubyang::Model::Default.new( val[1], val[2] )
 							}
 
-	"enum-specification"		:	"enum-stmt"
+	"enum-specification"		:	"enum-stmt" "stmtsep"
 							{
-								result = [val[0]]
+								result = [val[0]] + val[1]
 							}
-					|	"enum-specification" "enum-stmt"
+					|	"enum-specification" "enum-stmt" "stmtsep"
 							{
-								result = val[0] + [val[1]]
+								result = val[0] + [val[1]] + val[2]
 							}
 
 	"enum-stmt"			:	"enum-keyword" "string" ";"
 							{
 								result = Rubyang::Model::Enum.new( val[1] )
 							}
-					|	"enum-keyword" "string" "{" "inner-enum-stmts" "}"
+					|	"enum-keyword" "string"
+						"{"
+							"stmtsep"
+							"inner-enum-stmts"
+						"}"
 							{
-								substmts = val[3]
+								substmts = val[3] + val[4]
 								result = Rubyang::Model::Enum.new( val[1], substmts )
 							}
 
@@ -552,9 +612,9 @@ rule
 							{
 								result = []
 							}
-					|	"inner-enum-stmts" "inner-enum-stmt"
+					|	"inner-enum-stmts" "inner-enum-stmt" "stmtsep"
 							{
-								result = val[0] + [val[1]]
+								result = val[0] + [val[1]] + val[2]
 							}
 
 	"inner-enum-stmt"		:	"value-stmt"
@@ -562,27 +622,29 @@ rule
 					|	"description-stmt"
 					|	"reference-stmt"
 
-	"leafref-specification"		:	"path-stmt"
+	"leafref-specification"		:	"path-stmt" "stmtsep"
 							{
 								result = [val[0]]
 							}
-					|	"path-stmt" "require-instance-stmt"
+					|	"path-stmt" "stmtsep"
+						"require-instance-stmt" "stmtsep"
 							{
-								result = [val[0]] + [val[1]]
+								result = [val[0]] + val[1] + [val[2]] + val[3]
 							}
-					|	"require-instance-stmt" "path-stmt"
+					|	"require-instance-stmt" "stmtsep"
+						"path-stmt" "stmtsep"
 							{
-								result = [val[0]] + [val[1]]
+								result = [val[0]] + val[1] + [val[2]] + val[3]
 							}
 
 	"path-stmt"			:	"path-keyword" "path-arg-str" "stmtend"
 							{
-								result = Rubyang::Model::Path.new( val[1] )
+								result = Rubyang::Model::Path.new( val[1], val[2] )
 							}
 
 	"require-instance-stmt"		:	"require-instance-keyword" "require-instance-arg-str" "stmtend"
 							{
-								result = Rubyang::Model::RequireInstance.new( val[1] )
+								result = Rubyang::Model::RequireInstance.new( val[1], val[2] )
 							}
 
 	"require-instance-arg-str"	:	"string"
@@ -593,41 +655,45 @@ rule
 								result = val[0]
 							}
 
-	"instance-identifier-specification"	:	"require-instance-stmt"
+	"instance-identifier-specification"	:	"require-instance-stmt" "stmtsep"
 							{
-								result = [val[0]]
+								result = [val[0]] + val[1]
 							}
 
-	"identityref-specification"	:	"base-stmt"
+	"identityref-specification"	:	"base-stmt" "stmtsep"
 							{
-								result = [val[0]]
+								result = [val[0]] + val[1]
 							}
 
-	"union-specification"		:	"type-stmt"
+	"union-specification"		:	"type-stmt" "stmtsep"
 							{
-								result = [val[0]]
+								result = [val[0]] + val[1]
 							}
-					|	"union-specification" "type-stmt"
+					|	"union-specification" "type-stmt" "stmtsep"
 							{
-								result = val[0] + [val[1]]
+								result = val[0] + [val[1]] + val[2]
 							}
 
-	"bits-specification"		:	"bit-stmt"
+	"bits-specification"		:	"bit-stmt" "stmtsep"
 							{
-								result = [val[0]]
+								result = [val[0]] + val[1]
 							}
-					|	"bits-specification" "bit-stmt"
+					|	"bits-specification" "bit-stmt" "stmtsep"
 							{
-								result = val[0] + [val[1]]
+								result = val[0] + [val[1]] + val[2]
 							}
 
 	"bit-stmt"			:	"bit-keyword" "identifier-arg-str" ";"
 							{
 								result = Rubyang::Model::Bit.new( val[1] )
 							}
-					|	"bit-keyword" "identifier-arg-str" "{" "inner-bit-stmts" "}"
+					|	"bit-keyword" "identifier-arg-str"
+						"{"
+							"stmtsep"
+							"inner-bit-stmts"
+						"}"
 							{
-								substmts = val[3]
+								substmts = val[3] + val[4]
 								result = Rubyang::Model::Bit.new( val[1], substmts )
 							}
 
@@ -635,9 +701,9 @@ rule
 							{
 								result = []
 							}
-					|	"inner-bit-stmts" "inner-bit-stmt"
+					|	"inner-bit-stmts" "inner-bit-stmt" "stmtsep"
 							{
-								result = val[0] + [val[1]]
+								result = val[0] + [val[1]] + val[2]
 							}
 
 	"inner-bit-stmt"		:	"position-stmt"
@@ -647,7 +713,7 @@ rule
 
 	"position-stmt"			:	"position-keyword" "position-value-arg-str" "stmtend"
 							{
-								result = Rubyang::Model::Position.new( val[1] )
+								result = Rubyang::Model::Position.new( val[1], val[2] )
 							}
 
 	"position-value-arg-str"	:	"string"
@@ -660,7 +726,7 @@ rule
 
 	"status-stmt"			:	"status-keyword" "status-arg-str" "stmtend"
 							{
-								result = Rubyang::Model::Status.new( val[1] )
+								result = Rubyang::Model::Status.new( val[1], val[2] )
 							}
 
 	"status-arg-str"		:	"string"
@@ -673,7 +739,7 @@ rule
 
 	"config-stmt"			:	"config-keyword" "config-arg-str" "stmtend"
 							{
-								result = Rubyang::Model::Config.new( val[1] )
+								result = Rubyang::Model::Config.new( val[1], val[2] )
 							}
 
 	"config-arg-str"		:	"string"
@@ -686,7 +752,7 @@ rule
 
 	"mandatory-stmt"		:	"mandatory-keyword" "mandatory-arg-str" "stmtend"
 							{
-								result = Rubyang::Model::Mandatory.new( val[1] )
+								result = Rubyang::Model::Mandatory.new( val[1], val[2] )
 							}
 
 	"mandatory-arg-str"		:	"string"
@@ -699,12 +765,12 @@ rule
 
 	"presence-stmt"			:	"presence-keyword" "string" "stmtend"
 							{
-								result = Rubyang::Model::Presence.new( val[1] )
+								result = Rubyang::Model::Presence.new( val[1], val[2] )
 							}
 
 	"ordered-by-stmt"		:	"ordered-by-keyword" "ordered-by-arg-str" "stmtend"
 							{
-								result = Rubyang::Model::OrderedBy.new( val[1] )
+								result = Rubyang::Model::OrderedBy.new( val[1], val[2] )
 							}
 
 	"ordered-by-arg-str"		:	"string"
@@ -719,9 +785,13 @@ rule
 							{
 								result = Rubyang::Model::Must.new( val[1] )
 							}
-					|	"must-keyword" "string" "{" "inner-must-stmts" "}"
+					|	"must-keyword" "string"
+						"{"
+							"stmtsep"
+							"inner-must-stmts"
+						"}"
 							{
-								substmts = val[3]
+								substmts = val[3] + val[4]
 								result = Rubyang::Model::Must.new( val[1], substmts )
 							}
 
@@ -729,9 +799,9 @@ rule
 							{
 								result = []
 							}
-					|	"inner-must-stmts" "inner-must-stmt"
+					|	"inner-must-stmts" "inner-must-stmt" "stmtsep"
 							{
-								result = val[0] + [val[1]]
+								result = val[0] + [val[1]] + val[2]
 							}
 
 	"inner-must-stmt"		:	"error-message-stmt"
@@ -741,17 +811,17 @@ rule
 
 	"error-message-stmt"		:	"error-message-keyword" "string" "stmtend"
 							{
-								result = Rubyang::Model::ErrorMessage.new( val[1] )
+								result = Rubyang::Model::ErrorMessage.new( val[1], val[2] )
 							}
 
 	"error-app-tag-stmt"		:	"error-app-tag-keyword" "string" "stmtend"
 							{
-								result = Rubyang::Model::ErrorAppTag.new( val[1] )
+								result = Rubyang::Model::ErrorAppTag.new( val[1], val[2] )
 							}
 
 	"min-elements-stmt"		:	"min-elements-keyword" "min-value-arg-str" "stmtend"
 							{
-								result = Rubyang::Model::MinElements.new( val[1] )
+								result = Rubyang::Model::MinElements.new( val[1], val[2] )
 							}
 
 	"min-value-arg-str"		:	"string"
@@ -764,7 +834,7 @@ rule
 
 	"max-elements-stmt"		:	"max-elements-keyword" "max-value-arg-str" "stmtend"
 							{
-								result = Rubyang::Model::MaxElements.new( val[1] )
+								result = Rubyang::Model::MaxElements.new( val[1], val[2] )
 							}
 
 	"max-value-arg-str"		:	"string"
@@ -777,16 +847,20 @@ rule
 
 	"value-stmt"			:	"value-keyword" "integer-value" "stmtend"
 							{
-								result = Rubyang::Model::Value.new( val[1] )
+								result = Rubyang::Model::Value.new( val[1], val[2] )
 							}
 
 	"grouping-stmt"			:	"grouping-keyword" "identifier-arg-str" ";"
 							{
 								result = Rubyang::Model::Grouping.new( val[1] )
 							}
-					|	"grouping-keyword" "identifier-arg-str" "{" "inner-grouping-stmts" "}"
+					|	"grouping-keyword" "identifier-arg-str"
+						"{"
+							"stmtsep"
+							"inner-grouping-stmts"
+						"}"
 							{
-								substmts = val[3]
+								substmts = val[3] + val[4]
 								result = Rubyang::Model::Grouping.new( val[1], substmts )
 							}
 
@@ -794,9 +868,9 @@ rule
 							{
 								result = []
 							}
-					|	"inner-grouping-stmts" "inner-grouping-stmt"
+					|	"inner-grouping-stmts" "inner-grouping-stmt" "stmtsep"
 							{
-								result = val[0] + [val[1]]
+								result = val[0] + [val[1]] + val[2]
 							}
 
 	"inner-grouping-stmt"		:	"status-stmt"
@@ -810,9 +884,13 @@ rule
 							{
 								result = Rubyang::Model::Container.new( val[1] )
 							}
-					|	"container-keyword" "identifier-arg-str" "{" "inner-container-stmts" "}"
+					|	"container-keyword" "identifier-arg-str"
+						"{"
+							"stmtsep"
+							"inner-container-stmts"
+						"}"
 							{
-								substmts = val[3]
+								substmts = val[3] + val[4]
 								result = Rubyang::Model::Container.new( val[1], substmts )
 							}
 
@@ -820,9 +898,9 @@ rule
 							{
 								result = []
 							}
-					|	"inner-container-stmts" "inner-container-stmt"
+					|	"inner-container-stmts" "inner-container-stmt" "stmtsep"
 							{
-								result = val[0] + [val[1]]
+								result = val[0] + [val[1]] + val[2]
 							}
 
 	"inner-container-stmt"		:	"when-stmt"
@@ -837,9 +915,13 @@ rule
 					|	"grouping-stmt"
 					|	"data-def-stmt"
 
-	"leaf-stmt"			:	"leaf-keyword" "identifier-arg-str" "{" "inner-leaf-stmts" "}"
+	"leaf-stmt"			:	"leaf-keyword" "identifier-arg-str"
+						"{"
+							"stmtsep"
+							"inner-leaf-stmts"
+						"}"
 							{
-								substmts = val[3]
+								substmts = val[3] + val[4]
 								result = Rubyang::Model::Leaf.new( val[1], substmts )
 							}
 	
@@ -847,9 +929,9 @@ rule
 							{
 								result = []
 							}
-					|	"inner-leaf-stmts" "inner-leaf-stmt"
+					|	"inner-leaf-stmts" "inner-leaf-stmt" "stmtsep"
 							{
-								result = val[0] + [val[1]]
+								result = val[0] + [val[1]] + val[2]
 							}
 	
 	"inner-leaf-stmt"		:	"when-stmt"
@@ -864,9 +946,13 @@ rule
 					|	"description-stmt"
 					|	"reference-stmt"
 
-	"leaf-list-stmt"		:	"leaf-list-keyword" "identifier-arg-str" "{" "inner-leaf-list-stmts" "}"
+	"leaf-list-stmt"		:	"leaf-list-keyword" "identifier-arg-str"
+						"{"
+							"stmtsep"
+							"inner-leaf-list-stmts"
+						"}"
 							{
-								substmts = val[3]
+								substmts = val[3] + val[4]
 								result = Rubyang::Model::LeafList.new( val[1], substmts )
 							}
 	
@@ -874,9 +960,9 @@ rule
 							{
 								result = []
 							}
-					|	"inner-leaf-list-stmts" "inner-leaf-list-stmt"
+					|	"inner-leaf-list-stmts" "inner-leaf-list-stmt" "stmtsep"
 							{
-								result = val[0] + [val[1]]
+								result = val[0] + [val[1]] + val[2]
 							}
 	
 	"inner-leaf-list-stmt"		:	"when-stmt"
@@ -892,9 +978,13 @@ rule
 					|	"description-stmt"
 					|	"reference-stmt"
 
-	"list-stmt"			:	"list-keyword" "identifier-arg-str" "{" "inner-list-stmts" "}"
+	"list-stmt"			:	"list-keyword" "identifier-arg-str"
+						"{"
+							"stmtsep"
+							"inner-list-stmts"
+						"}"
 							{
-								substmts = val[3]
+								substmts = val[3] + val[4]
 								result = Rubyang::Model::List.new( val[1], substmts )
 							}
 	
@@ -902,9 +992,9 @@ rule
 							{
 								result = []
 							}
-					|	"inner-list-stmts" "inner-list-stmt"
+					|	"inner-list-stmts" "inner-list-stmt" "stmtsep"
 							{
-								result = val[0] + [val[1]]
+								result = val[0] + [val[1]] + val[2]
 							}
 	
 	"inner-list-stmt"		:	"when-stmt"
@@ -925,7 +1015,7 @@ rule
 
 	"key-stmt"			:	"key-keyword" "key-arg-str" "stmtend"
 							{
-								result = Rubyang::Model::Key.new( val[1] )
+								result = Rubyang::Model::Key.new( val[1], val[2] )
 							}
 
 	"key-arg-str"			:	"string"
@@ -938,7 +1028,7 @@ rule
 
 	"unique-stmt"			:	"unique-keyword" "unique-arg-str" "stmtend"
 							{
-								result = Rubyang::Model::Unique.new( val[1] )
+								result = Rubyang::Model::Unique.new( val[1], val[2] )
 							}
 
 	"unique-arg-str"		:	"unique-arg"
@@ -953,9 +1043,13 @@ rule
 							{
 								result = Rubyang::Model::Choice.new( val[1] )
 							}
-					|	"choice-keyword" "identifier-arg-str" "{" "inner-choice-stmts" "}"
+					|	"choice-keyword" "identifier-arg-str"
+						"{"
+							"stmtsep"
+							"inner-choice-stmts"
+						"}"
 							{
-								substmts = val[3]
+								substmts = val[3] + val[4]
 								result = Rubyang::Model::Choice.new( val[1], substmts )
 							}
 
@@ -963,9 +1057,9 @@ rule
 							{
 								result = []
 							}
-					|	"inner-choice-stmts" "inner-choice-stmt"
+					|	"inner-choice-stmts" "inner-choice-stmt" "stmtsep"
 							{
-								result = val[0] + [val[1]]
+								result = val[0] + [val[1]] + val[2]
 							}
 
 	"inner-choice-stmt"		:	"when-stmt"
@@ -989,9 +1083,13 @@ rule
 							{
 								result = Rubyang::Model::Case.new( val[1] )
 							}
-					|	"case-keyword" "identifier-arg-str" "{" "inner-case-stmts" "}"
+					|	"case-keyword" "identifier-arg-str"
+						"{"
+							"stmtsep"
+							"inner-case-stmts"
+						"}"
 							{
-								substmts = val[3]
+								substmts = val[3] + val[4]
 								result = Rubyang::Model::Case.new( val[1], substmts )
 							}
 	
@@ -999,9 +1097,9 @@ rule
 							{
 								result = []
 							}
-					|	"inner-case-stmts" "inner-case-stmt"
+					|	"inner-case-stmts" "inner-case-stmt" "stmtsep"
 							{
-								result = val[0] + [val[1]]
+								result = val[0] + [val[1]] + val[2]
 							}
 	
 	"inner-case-stmt"		:	"when-stmt"
@@ -1015,9 +1113,13 @@ rule
 							{
 								result = Rubyang::Model::Anyxml.new( val[1] )
 							}
-					|	"anyxml-keyword" "identifier-arg-str" "{" "inner-anyxml-stmts" "}"
+					|	"anyxml-keyword" "identifier-arg-str"
+						"{"
+							"stmtsep"
+							"inner-anyxml-stmts"
+						"}"
 							{
-								substmts = val[3]
+								substmts = val[3] + val[4]
 								result = Rubyang::Model::Anyxml.new( val[1], substmts )
 							}
 	
@@ -1025,9 +1127,9 @@ rule
 							{
 								result = []
 							}
-					|	"inner-anyxml-stmts" "inner-anyxml-stmt"
+					|	"inner-anyxml-stmts" "inner-anyxml-stmt" "stmtsep"
 							{
-								result = val[0] + [val[1]]
+								result = val[0] + [val[1]] + val[2]
 							}
 	
 	"inner-anyxml-stmt"		:	"when-stmt"
@@ -1043,9 +1145,13 @@ rule
 							{
 								result = Rubyang::Model::Uses.new( val[1] )
 							}
-					|	"uses-keyword" "identifier-ref-arg-str" "{" "inner-uses-stmts" "}"
+					|	"uses-keyword" "identifier-ref-arg-str"
+						"{"
+							"stmtsep"
+							"inner-uses-stmts"
+						"}"
 							{
-								substmts = val[3]
+								substmts = val[3] + val[4]
 								result = Rubyang::Model::Uses.new( val[1], substmts )
 							}
 
@@ -1053,9 +1159,9 @@ rule
 							{
 								result = []
 							}
-					|	"inner-uses-stmts" "inner-uses-stmt"
+					|	"inner-uses-stmts" "inner-uses-stmt" "stmtsep"
 							{
-								result = val[0] + [val[1]]
+								result = val[0] + [val[1]] + val[2]
 							}
 
 	"inner-uses-stmt"		:	"when-stmt"
@@ -1070,9 +1176,13 @@ rule
 							{
 								result = Rubyang::Model::Refine.new( val[1] )
 							}
-					|	"refine-keyword" "refine-arg-str" "{" "inner-refine-stmts" "}"
+					|	"refine-keyword" "refine-arg-str"
+						"{"
+							"stmtsep"
+							"inner-refine-stmts"
+						"}"
 							{
-								substmts = val[3]
+								substmts = val[3] + val[4]
 								result = Rubyang::Model::Refine.new( val[1], substmts )
 							}
 
@@ -1099,9 +1209,13 @@ rule
 
 	"refine-arg"			:	"descendant-schema-nodeid"
 
-	"uses-augment-stmt"		:	"augment-keyword" "uses-augment-arg-str" "{" "inner-uses-augment-stmts" "}"
+	"uses-augment-stmt"		:	"augment-keyword" "uses-augment-arg-str"
+						"{"
+							"stmtsep"
+							"inner-uses-augment-stmts"
+						"}"
 							{
-								substmts = val[3]
+								substmts = val[3] + val[4]
 								result = Rubyang::Model::Augment.new( val[1], substmts )
 							}
 	
@@ -1109,9 +1223,9 @@ rule
 							{
 								result = []
 							}
-					|	"inner-uses-augment-stmts" "inner-uses-augment-stmt"
+					|	"inner-uses-augment-stmts" "inner-uses-augment-stmt" "stmtsep"
 							{
-								result = val[0] + [val[1]]
+								result = val[0] + [val[1]] + val[2]
 							}
 	
 	"inner-uses-augment-stmt"	:	"when-stmt"
@@ -1126,9 +1240,13 @@ rule
 
 	"uses-augment-arg"		:	"descendant-schema-nodeid"
 
-	"augment-stmt"			:	"augment-keyword" "augment-arg-str" "{" "inner-augment-stmts" "}"
+	"augment-stmt"			:	"augment-keyword" "augment-arg-str"
+						"{"
+							"stmtsep"
+							"inner-augment-stmts"
+						"}"
 							{
-								substmts = val[3]
+								substmts = val[3] + val[4]
 								result = Rubyang::Model::Augment.new( val[1], substmts )
 							}
 	
@@ -1136,9 +1254,9 @@ rule
 							{
 								result = []
 							}
-					|	"inner-augment-stmts" "inner-augment-stmt"
+					|	"inner-augment-stmts" "inner-augment-stmt" "stmtsep"
 							{
-								result = val[0] + [val[1]]
+								result = val[0] + [val[1]] + val[2]
 							}
 	
 	"inner-augment-stmt"		:	"when-stmt"
@@ -1153,25 +1271,61 @@ rule
 
 	"augment-arg"			:	"absolute-schema-nodeid"
 
-	"unknown-statement"		:	"prefixed-node-identifier" "unknown-string" ";"
-					|	"prefixed-node-identifier" "unknown-string" "{" "unknown-statements2" "}"
+	"unknown-stmts"			:	/*  */
+							{
+								result = []
+							}
+					|	"unknown-stmts" "unknown-stmt"
+							{
+								result = val[0] + [val[1]]
+							}
+
+	"unknown-stmt"			:	"prefixed-node-identifier" "unknown-arg-str" ";"
+							{
+								result = Rubyang::Model::Unknown.new( val[0], val[1] )
+							}
+					|	"prefixed-node-identifier" "unknown-arg-str" "{" "unknown-stmts2" "}"
+							{
+								substmts = val[3]
+								result = Rubyang::Model::Unknown.new( val[0], val[1], substmts )
+							}
+
+	"unknown-stmts2"		:	/*  */
+							{
+								result = []
+							}
+					|	"unknown-stmts2" "unknown-stmt2"
+							{
+								result = val[0] + [val[1]]
+							}
 
-	"unknown-statement2"		:	"node-identifier" "unknown-string" ";"
-					|	"node-identifier" "unknown-string" "{" "unknown-statements2" "}"
+	"unknown-stmt2"			:	"node-identifier" "unknown-arg-str" ";"
+							{
+								result = Rubyang::Model::Unknown.new( val[0], val[1] )
+							}
+					|	"node-identifier" "unknown-arg-str" "{" "unknown-stmts2" "}"
+							{
+								substmts = val[3]
+								result = Rubyang::Model::Unknown.new( val[0], val[1], substmts )
+							}
 
-	"unknown-string"		:	/*  */
+	"unknown-arg-str"		:	/*  */
+							{
+								result = ''
+							}
 					|	"string"
 
-	"unknown-statements2"		:	/*  */
-					|	"unknown-statements2" "unknown-statement2"
-
 	"when-stmt"			:	"when-keyword" "string" ";"
 							{
 								result = Rubyang::Model::When.new( val[1] )
 							}
-					|	"when-keyword" "string" "{" "inner-when-stmts" "}"
+					|	"when-keyword" "string"
+						"{"
+							"stmtsep"
+							"inner-when-stmts"
+						"}"
 							{
-								substmts = val[3]
+								substmts = val[3] + val[4]
 								result = Rubyang::Model::When.new( val[1], substmts )
 							}
 	
@@ -1179,9 +1333,9 @@ rule
 							{
 								result = []
 							}
-					|	"inner-when-stmts" "inner-when-stmt"
+					|	"inner-when-stmts" "inner-when-stmt" "stmtsep"
 							{
-								result = val[0] + [val[1]]
+								result = val[0] + [val[1]] + val[2]
 							}
 	
 	"inner-when-stmt"		:	"description-stmt"
@@ -1191,9 +1345,13 @@ rule
 							{
 								result = Rubyang::Model::Rpc.new( val[1] )
 							}
-					|	"rpc-keyword" "identifier-arg-str" "{" "inner-rpc-stmts" "}"
+					|	"rpc-keyword" "identifier-arg-str"
+						"{"
+							"stmtsep"
+							"inner-rpc-stmts"
+						"}"
 							{
-								substmts = val[3]
+								substmts = val[3] + val[4]
 								result = Rubyang::Model::Rpc.new( val[1], substmts )
 							}
 	
@@ -1215,9 +1373,13 @@ rule
 					|	"input-stmt"
 					|	"output-stmt"
 
-	"input-stmt"			:	"input-keyword" "{" "inner-input-stmts" "}"
+	"input-stmt"			:	"input-keyword"
+						"{"
+							"stmtsep"
+							"inner-input-stmts"
+						"}"
 							{
-								substmts = val[2]
+								substmts = val[2] + val[3]
 								result = Rubyang::Model::Input.new( substmts )
 							}
 	
@@ -1225,18 +1387,22 @@ rule
 							{
 								result = []
 							}
-					|	"inner-input-stmts" "inner-input-stmt"
+					|	"inner-input-stmts" "inner-input-stmt" "stmtsep"
 							{
-								result = val[0] + [val[1]]
+								result = val[0] + [val[1]] + val[2]
 							}
 	
 	"inner-input-stmt"		:	"typedef-stmt"
 					|	"grouping-stmt"
 					|	"data-def-stmt"
 
-	"output-stmt"			:	"output-keyword" "{" "inner-output-stmts" "}"
+	"output-stmt"			:	"output-keyword"
+						"{"
+							"stmtsep"
+							"inner-output-stmts"
+						"}"
 							{
-								substmts = val[2]
+								substmts = val[2] + val[3]
 								result = Rubyang::Model::Output.new( substmts )
 							}
 	
@@ -1244,9 +1410,9 @@ rule
 							{
 								result = []
 							}
-					|	"inner-output-stmts" "inner-output-stmt"
+					|	"inner-output-stmts" "inner-output-stmt" "stmtsep"
 							{
-								result = val[0] + [val[1]]
+								result = val[0] + [val[1]] + val[2]
 							}
 	
 	"inner-output-stmt"		:	"typedef-stmt"
@@ -1257,9 +1423,13 @@ rule
 							{
 								result = Rubyang::Model::Notification.new( val[1] )
 							}
-					|	"notification-keyword" "identifier-arg-str" "{" "inner-notification-stmts" "}"
+					|	"notification-keyword" "identifier-arg-str"
+						"{"
+							"stmtsep"
+							"inner-notification-stmts"
+						"}"
 							{
-								substmts = val[3]
+								substmts = val[3] + val[4]
 								result = Rubyang::Model::Notification.new( val[1], substmts )
 							}
 	
@@ -1267,9 +1437,9 @@ rule
 							{
 								result = []
 							}
-					|	"inner-notification-stmts" "inner-notification-stmt"
+					|	"inner-notification-stmts" "inner-notification-stmt" "stmtsep"
 							{
-								result = val[0] + [val[1]]
+								result = val[0] + [val[1]] + val[2]
 							}
 	
 	"inner-notification-stmt"	:	"if-feature-stmt"
@@ -1284,9 +1454,13 @@ rule
 							{
 								result = Rubyang::Model::Deviation.new( val[1] )
 							}
-					|	"deviation-keyword" "deviation-arg-str" "{" "inner-deviation-stmts" "}"
+					|	"deviation-keyword" "deviation-arg-str"
+						"{"
+							"stmtsep"
+							"inner-deviation-stmts"
+						"}"
 							{
-								substmts = val[3]
+								substmts = val[3] + val[4]
 								result = Rubyang::Model::Deviation.new( val[1], substmts )
 							}
 	
@@ -1294,9 +1468,9 @@ rule
 							{
 								result = []
 							}
-					|	"inner-deviation-stmts" "inner-deviation-stmt"
+					|	"inner-deviation-stmts" "inner-deviation-stmt" "stmtsep"
 							{
-								result = val[0] + [val[1]]
+								result = val[0] + [val[1]] + val[2]
 							}
 	
 	"inner-deviation-stmt"		:	"description-stmt"
@@ -1453,10 +1627,14 @@ rule
 								result = val[0] + val[2]
 							}
 
-	"stmtend"			:	";"
-					|	"{" "unknown-statements" "}"
+	"stmtsep"			:	"unknown-stmts"
 
-	"unknown-statements"		:	/*  */
-					|	"unknown-statements" "unknown-statement"
+	"stmtend"			:	";"
+							{
+								result = []
+							}
+					|	"{" "unknown-stmts" "}"
+							{
+								result = val[1]
+							}
 end
-