Skip mechanism added

Author: promicsw

FexSampleSet/Program.cs

@@ -96,14 +96,17 @@ void QuickStart() {
      */
 
     var fex = new FlowExpression<FexScanner>();  // Flow Expression using FexScanner.
+        fex.DefSkip(c => c.SkipSp());            // Define the Skip operation to skip spaces.
+
     string dcode = "", acode = "", number = "";  // Will record values in here.
 
+
     // Build the flow expression with 'Axiom' tnumber:
     var tnumber = fex.Seq(s => s
         .Ch('(').OnFail("( expected")
         .Rep(3, -1, r => r.Digit(v => dcode += v)).OnFail("3+ digit dialing code expected")
         .Ch(')').OnFail(") expected")
-        .Sp()
+        .Skip() // Perform the previously defined skip operation
         .Rep(3, r => r.Digit(v => acode += v)).OnFail("3 digit area code expected")
         .AnyCh("- ").OnFail("- or space expected")
         .Rep(4, r => r.Digit(v => number += v)).OnFail("4 digit number expected")

Psw.FlowExpressions/FexBuildState.cs

@@ -17,6 +17,7 @@ public class FexBuildState<T>
         public FexElement<T>? HostFex;
         public FexElement<T>? LastFex;
         public FexOpr<T>? LastOpr;
+        public Action<T>? SkipOp;
         public FexPreOp<T> PreOp = new FexPreOp<T>(null);  // Will be added to every Op - use for e.g to skip spaces
         public Dictionary<string, FexRef<T>> RefSet = new Dictionary<string, FexRef<T>>();
 

Psw.FlowExpressions/FexBuilder.cs

@@ -23,7 +23,7 @@ public class FexPreOp<T>
 
         public FexPreOp(Action<T> preOp) => _preOp = preOp;
 
-        public void SetAction(Action<T> preOp) => _preOp = preOp;
+        public void SetAction(Action<T>? preOp) => _preOp = preOp;
 
         public void Run(T ctx) {
             if (!_hasRun) _preOp?.Invoke(ctx);
@@ -115,7 +115,7 @@ public FexBuilder<T> Assert(Func<T, bool> assert, Action<T> failAction = null) {
         /// <summary>
         /// Perform an Action on the Context-T (does no affect the validity of a sequence).
         /// </summary>
-        public FexBuilder<T> Act(Action<T> action) => AddFex(new FexAct<T>(action));
+        public FexBuilder<T> Act(Action<T>? action) => AddFex(new FexAct<T>(action));
 
         /// <summary>
         /// Perform a repeated Action on the Context-T (does no affect the validity of a sequence):<br/>
@@ -246,17 +246,34 @@ public FexBuilder<T> ActValue<V>(Action<V> valueAction) {
             return this;
         }
 
+        /// <summary>
+        /// Perform the previously defined (via FlowExpression.DefSkip(...)) skip operation:<br/>
+        /// - Typically used to skip spaces etc.<br/>
+        /// - Runs if defined and does no affect the validity of a sequence.
+        /// </summary>
+        /// <returns></returns>
+        public FexBuilder<T> Skip() => Act(_buildState.SkipOp);
+
+
         /// <summary>
         /// Binds a pre-operator to all subsequent operators:<br/>
         /// - A pre-operator executes before an operator as an action on the context:<br/>
         /// - Typically used to skip spaces etc. before tokens when parsing.<br/>
         /// - Pre-operators are efficient an only execute once while trying several lookahead operations.
         /// </summary>
-        public FexBuilder<T> GlobalPreOp(Action<T> preOp) {
+        public FexBuilder<T> GlobalPreOp(Action<T>? preOp) {
             _buildState.PreOp.SetAction(preOp);
             return this;
         }
 
+        /// <summary>
+        /// Binds the previously defined (via FlowExpression.DefSkip(...)) skip operation as pre-operator to all subsequent operators:<br/>
+        /// - A pre-operator executes before an operator as an action on the context:<br/>
+        /// - Typically used to skip spaces etc. before tokens when parsing.<br/>
+        /// - Pre-operators are efficient an only execute once while trying several lookahead operations.
+        /// </summary>
+        public FexBuilder<T> SkipGlobalPreOp() => GlobalPreOp(_buildState.SkipOp);
+
 
         /// <summary>
         /// Bind a pre-operator to the preceding operator:<br/>

Psw.FlowExpressions/FexElements.cs

@@ -61,10 +61,10 @@ public override FexCheckResult CheckRun(T ctx) {
     /// </summary>
     public class FexAct<T> : FexElement<T>
     {
-        private readonly Action<T> _action;
+        private readonly Action<T>? _action;
         private readonly FexCheckResult _checkRunReturn;
 
-        public FexAct(Action<T> action, FexCheckResult checkRunReturn = FexCheckResult.FailFirst) {
+        public FexAct(Action<T>? action, FexCheckResult checkRunReturn = FexCheckResult.FailFirst) {
             _action = action;
             _checkRunReturn = checkRunReturn;
             IsOpt = true;
@@ -174,6 +174,7 @@ private bool _Run(T ctx, bool checkMode) {
         public override FexCheckResult CheckRun(T ctx) => _Run(ctx, true) ? FexCheckResult.Passed : FexCheckResult.FailFirst;
     }
 
+
     /// <summary>
     /// Construct, Run and Manage a Sequence of steps (FexElements)
     /// </summary>

Psw.FlowExpressions/FlowExpression.cs

@@ -35,6 +35,15 @@ public FlowExpression(IFexTracer tracer = null)
         protected FexElement<T> _Prod(FexElement<T> prod, Action<FexBuilder<T>> build) 
             => _fexBuildState.Production(_fexBuilder, prod, build);
 
+        /// <summary>
+        /// Define the Skip action to perform for the Skip element:<br/>
+        /// - Typically used to skip spaces etc.
+        /// </summary>
+        public FlowExpression<T> DefSkip(Action<T> skipAction) {
+            _fexBuildState.SkipOp = skipAction;
+            return this;
+        }
+
         /// <summary>
         /// Define a Sequence (of steps) that must complete in full to pass:<br/>
         /// - A step is any FexElement.