Added expr_ws_keyword_p and demand_expr_ws_keyword_p

Author: ngeor

rusty_parser/src/built_ins/field.rs

@@ -1,7 +1,7 @@
 use rusty_common::*;
 use rusty_pc::*;
 
-use crate::expr::expr_pos_ws_p;
+use crate::expr::expr_ws_keyword_p;
 use crate::expr::file_handle::file_handle_p;
 use crate::input::StringView;
 use crate::pc_specific::*;
@@ -23,12 +23,9 @@ pub fn parse() -> impl Parser<StringView, Output = Statement, Error = ParserErro
 
 fn field_item_p() -> impl Parser<StringView, Output = (ExpressionPos, NamePos), Error = ParserError>
 {
-    seq3(
-        expr_pos_ws_p(),
-        keyword_ws_p(Keyword::As),
+    expr_ws_keyword_p(Keyword::As).and_tuple(demand_lead_ws(
         name_p().with_pos().or_expected("variable name"),
-        |width, _, name| (width, name),
-    )
+    ))
 }
 
 fn build_args(

rusty_parser/src/core/for_loop.rs

@@ -2,7 +2,9 @@ use rusty_pc::*;
 
 use crate::core::statements::zero_or_more_statements;
 use crate::error::ParserError;
-use crate::expr::{expr_pos_ws_p, opt_second_expression_after_keyword, property, ws_expr_pos_p};
+use crate::expr::{
+    demand_expr_ws_keyword_p, opt_second_expression_after_keyword, property, ws_expr_pos_p
+};
 use crate::input::StringView;
 use crate::pc_specific::*;
 use crate::tokens::equal_sign_ws;
@@ -52,14 +54,13 @@ fn parse_for_step_p() -> impl Parser<
 fn parse_for_p()
 -> impl Parser<StringView, Output = (ExpressionPos, ExpressionPos, ExpressionPos), Error = ParserError>
 {
-    seq6(
-        keyword_ws_p(Keyword::For),
-        property::parser().or_expected("name after FOR"),
+    seq5(
+        keyword_ignoring(Keyword::For),
+        demand_lead_ws(property::parser().or_expected("name after FOR")),
         equal_sign_ws(),
-        expr_pos_ws_p().or_expected("lower bound of FOR loop"),
-        keyword(Keyword::To),
+        demand_expr_ws_keyword_p("lower bound of FOR loop", Keyword::To),
         ws_expr_pos_p().or_expected("upper bound of FOR loop"),
-        |_, name, _, lower_bound, _, upper_bound| (name, lower_bound, upper_bound),
+        |_, name, _, lower_bound, upper_bound| (name, lower_bound, upper_bound),
     )
 }
 

rusty_parser/src/expr/opt_second_expression.rs

@@ -13,6 +13,7 @@ use crate::{ExpressionPos, Keyword};
 /// If the keyword is present, the second expression is mandatory.
 ///
 /// Example: `FOR I = 1 TO 100 [STEP 5]`
+#[deprecated]
 pub fn opt_second_expression_after_keyword<P, F>(
     first_parser: P,
     keyword: Keyword,

rusty_parser/src/expr/parsers.rs

@@ -5,7 +5,7 @@ use crate::expr::opt_second_expression::conditionally_opt_whitespace;
 use crate::input::StringView;
 use crate::pc_specific::*;
 use crate::tokens::comma_ws;
-use crate::{ExpressionPos, ExpressionTrait, Expressions, ParserError};
+use crate::{ExpressionPos, ExpressionTrait, Expressions, Keyword, ParserError};
 
 /// `( expr [, expr]* )`
 pub fn in_parenthesis_csv_expressions_non_opt(
@@ -51,22 +51,6 @@ pub fn ws_expr_pos_p() -> impl Parser<StringView, Output = ExpressionPos, Error
     super::parenthesis::parser().or(lead_ws(expression_pos_p()))
 }
 
-/// Parses an expression that is either followed by whitespace
-/// or is a parenthesis expression.
-///
-/// The whitespace is mandatory after a non-parenthesis
-/// expression.
-///
-/// ```text
-/// <expr-not-in-parenthesis> <ws> |
-/// <expr-in-parenthesis> <ws> |
-/// <expr-in-parenthesis>
-/// ```
-#[deprecated]
-pub fn expr_pos_ws_p() -> impl Parser<StringView, Output = ExpressionPos, Error = ParserError> {
-    followed_by_ws(expression_pos_p())
-}
-
 /// Parses an expression that is either surrounded by whitespace
 /// or is a parenthesis expression.
 ///
@@ -78,6 +62,7 @@ pub fn expr_pos_ws_p() -> impl Parser<StringView, Output = ExpressionPos, Error
 /// <ws> <expr-in-parenthesis> <ws> |
 /// <expr-in-parenthesis>
 /// ```
+#[deprecated]
 pub fn ws_expr_pos_ws_p() -> impl Parser<StringView, Output = ExpressionPos, Error = ParserError> {
     followed_by_ws(ws_expr_pos_p())
 }
@@ -97,3 +82,41 @@ fn eager_expression_pos_p() -> impl Parser<StringView, Output = ExpressionPos, E
 {
     super::binary_expression::parser()
 }
+
+/// Parses an expression,
+/// then demands whitespace, unless the expression is a parenthesis.
+/// Finally it demands the given keyword.
+pub fn expr_ws_keyword_p(
+    keyword: Keyword,
+) -> impl Parser<StringView, Output = ExpressionPos, Error = ParserError> {
+    expr_ws_followed_by(expression_pos_p(), keyword_ignoring(keyword))
+}
+
+/// Parses an expression, failing fatally with the given expectation message if it can't be parsed.
+/// Then it demands whitespace, unless the expression is a parenthesis.
+/// Finally it demands the given keyword.
+pub fn demand_expr_ws_keyword_p(
+    expectation: &str,
+    keyword: Keyword,
+) -> impl Parser<StringView, Output = ExpressionPos, Error = ParserError> {
+    expr_ws_followed_by(
+        expression_pos_p().or_expected(expectation),
+        keyword_ignoring(keyword),
+    )
+}
+
+/// Parses the expression using the given parser,
+/// then demands whitespace, unless the expression is a parenthesis.
+/// Finally it demands the second parser.
+pub fn expr_ws_followed_by(
+    expr_parser: impl Parser<StringView, Output = ExpressionPos, Error = ParserError>,
+    other_parser: impl Parser<StringView, Error = ParserError>,
+) -> impl Parser<StringView, Output = ExpressionPos, Error = ParserError> {
+    expr_parser.then_with_in_context(
+        conditionally_opt_whitespace()
+            .to_fatal()
+            .and_keep_right(other_parser.to_fatal().no_context()),
+        |e| e.is_parenthesis(),
+        KeepLeftCombiner,
+    )
+}