Add type_reference and module_reference parsers

Rename title_case_identifier to type_reference.
Add module_reference.

Author: Rawk

rasn-compiler/src/lexer/choice.rs

@@ -51,7 +51,7 @@ pub fn selection_type_choice(input: Input<'_>) -> ParserResult<'_, ASN1Type> {
         into(separated_pair(
             skip_ws_and_comments(value_reference),
             skip_ws_and_comments(char(LEFT_CHEVRON)),
-            skip_ws_and_comments(title_case_identifier),
+            skip_ws_and_comments(type_reference),
         )),
         ASN1Type::ChoiceSelectionType,
     )

rasn-compiler/src/lexer/common.rs

@@ -58,6 +58,34 @@ pub fn block_comment(input: Input<'_>) -> ParserResult<'_, &str> {
     .parse(input)
 }
 
+/// Parses a typereference lexical item.
+///
+/// #### X.680 12.2  Type references
+/// _A "typereference" shall consist of an arbitrary number (one or more) of letters, digits, and
+/// hyphens. The initial character shall be an upper-case letter. A hyphen shall not be the last
+/// character. A hyphen shall not be immediately followed by another hyphen. NOTE – The rules
+/// concerning hyphen are designed to avoid ambiguity with (possibly following) comment. 12.2.2A
+/// "typereference" shall not be one of the reserved character sequences listed in 12.38._
+pub fn type_reference(input: Input<'_>) -> ParserResult<'_, &'_ str> {
+    map_res(
+        recognize(pair(
+            one_of("ABCDEFGHIJKLMNOPQRSTUVWXYZ"),
+            many0(alt((
+                preceded(char('-'), into_inner(alphanumeric1)),
+                into_inner(alphanumeric1),
+            ))),
+        )),
+        |identifier| {
+            if ASN1_KEYWORDS.contains(&identifier.inner()) {
+                Err(MiscError("Identifier is ASN.1 keyword."))
+            } else {
+                Ok(identifier.into_inner())
+            }
+        },
+    )
+    .parse(input.clone())
+}
+
 /// Parses an ASN1 identifier.
 ///
 /// * `input` [Input]-wrapped string slice reference used as an input for the lexer
@@ -97,33 +125,23 @@ pub fn value_reference(input: Input<'_>) -> ParserResult<'_, &'_ str> {
     .parse(input)
 }
 
+/// Parses a modulereference lexical item.
+///
+/// #### X.680 12.5 Module references
+/// _A "modulereference" shall consist of the sequence of characters specified for a
+/// "typereference" in 12.2. In analyzing an instance of use of this notation, a "modulereference"
+/// is distinguished from a "typereference" by the context in which it appears._
+pub fn module_reference(input: Input<'_>) -> ParserResult<'_, &'_ str> {
+    type_reference(input)
+}
+
 pub fn into_inner<'a, F>(parser: F) -> impl Parser<Input<'a>, Output = &'a str, Error = F::Error>
 where
     F: Parser<Input<'a>, Output = Input<'a>>,
 {
     map(parser, Input::into_inner)
 }
 
-pub fn title_case_identifier(input: Input<'_>) -> ParserResult<'_, &str> {
-    map_res(
-        recognize(pair(
-            one_of("ABCDEFGHIJKLMNOPQRSTUVWXYZ"),
-            many0(alt((
-                preceded(char('-'), into_inner(alphanumeric1)),
-                into_inner(alphanumeric1),
-            ))),
-        )),
-        |identifier| {
-            if ASN1_KEYWORDS.contains(&identifier.inner()) {
-                Err(MiscError("Identifier is ASN.1 keyword."))
-            } else {
-                Ok(identifier.into_inner())
-            }
-        },
-    )
-    .parse(input.clone())
-}
-
 pub fn skip_ws<'a, F>(inner: F) -> impl Parser<Input<'a>, Output = F::Output, Error = F::Error>
 where
     F: Parser<Input<'a>>,

rasn-compiler/src/lexer/macros.rs

@@ -12,7 +12,7 @@ use crate::intermediate::{
     GREATER_THAN, LESS_THAN, MACRO, PIPE,
 };
 use crate::lexer::common::{
-    in_parentheses, skip_ws_and_comments, title_case_identifier, uppercase_identifier,
+    in_parentheses, module_reference, skip_ws_and_comments, type_reference, uppercase_identifier,
     value_reference,
 };
 use crate::lexer::error::{MiscError, ParserResult};
@@ -188,7 +188,7 @@ fn supporting_productions(input: Input<'_>) -> ParserResult<'_, Vec<Production>>
 /// ```
 fn external_macro_reference(input: Input<'_>) -> ParserResult<'_, (&'_ str, &'_ str)> {
     separated_pair(
-        title_case_identifier,
+        module_reference,
         skip_ws_and_comments(char(DOT)),
         skip_ws_and_comments(macro_reference),
     )
@@ -502,8 +502,12 @@ fn macro_reference(input: Input<'_>) -> ParserResult<'_, &'_ str> {
 }
 
 /// Parse a production reference.
+///
+/// #### X.680 1994 J.2.2 Productionreference
+/// _A "productionreference" shall consist of the sequence of characters specified for a
+/// "typereference" in 9.2._
 fn production_reference(input: Input<'_>) -> ParserResult<'_, &'_ str> {
-    map_res(title_case_identifier, |v| {
+    map_res(type_reference, |v| {
         if ADDITIONAL_KEYWORDS.contains(&v) {
             Err(MiscError(
                 "Production reference can not be a keyword when used in ASN.1 MACRO.",
@@ -516,8 +520,13 @@ fn production_reference(input: Input<'_>) -> ParserResult<'_, &'_ str> {
 }
 
 /// Parse a local type reference.
+///
+/// #### X.680 1994 J.2.3 Localtypereference
+/// _A "localtypereference" shall consist of the sequence of characters specified for a
+/// "typereference" in 9.2. A "localtypereference" is used as an identifier for types which are
+/// recognized during syntax analysis of an instance of the new type or value notation._
 fn local_type_reference(input: Input<'_>) -> ParserResult<'_, &'_ str> {
-    map_res(title_case_identifier, |v| {
+    map_res(type_reference, |v| {
         if ADDITIONAL_KEYWORDS.contains(&v) {
             Err(MiscError(
                 "Type reference can not be a keyword when used in ASN.1 MACRO.",

rasn-compiler/src/lexer/mod.rs

@@ -127,7 +127,7 @@ fn end(input: Input<'_>) -> ParserResult<'_, &str> {
 pub fn top_level_type_declaration(input: Input<'_>) -> ParserResult<'_, ToplevelTypeDefinition> {
     into((
         skip_ws(many0(comment)),
-        skip_ws(title_case_identifier),
+        skip_ws(type_reference),
         opt(parameterization),
         preceded(assignment, pair(opt(asn_tag), asn1_type)),
     ))
@@ -220,7 +220,7 @@ pub fn elsewhere_declared_type(input: Input<'_>) -> ParserResult<'_, ASN1Type> {
                 identifier,
                 tag(".&"),
             ))))),
-            skip_ws_and_comments(title_case_identifier),
+            skip_ws_and_comments(type_reference),
             opt(skip_ws_and_comments(constraint)),
         ),
         |(parent, id, constraints)| {

rasn-compiler/src/lexer/sequence.rs

@@ -116,7 +116,7 @@ pub fn sequence_component(input: Input<'_>) -> ParserResult<'_, SequenceComponen
                 tag(COMPONENTS_OF),
                 skip_ws_and_comments(alt((
                     into_inner(recognize(separated_list1(tag(".&"), identifier))),
-                    title_case_identifier,
+                    type_reference,
                 ))),
             ),
             |id| SequenceComponent::ComponentsOf(id.into()),