Flee

2025-10-08 09:49:37 +08:00
commit 284e764345
99 changed files with 21742 additions and 0 deletions
--- a/Parsing/ProductionPattern.cs
+++ b/Parsing/ProductionPattern.cs
@@ -0,0 +1,213 @@
+using System.Collections;
+using System.Text;
+
+
+namespace Flee.Parsing
+{
+
+    /**
+     * A production pattern. This class represents a set of production
+     * alternatives that together forms a single production. A
+     * production pattern is identified by an integer id and a name,
+     * both provided upon creation. The pattern id is used for
+     * referencing the production pattern from production pattern
+     * elements.
+     */
+    internal class ProductionPattern
+    {
+
+        private readonly int _id;
+        private readonly string _name;
+        private bool _synthetic;
+        private readonly ArrayList _alternatives;
+        private int _defaultAlt;
+        private LookAheadSet _lookAhead;
+
+        public ProductionPattern(int id, string name)
+        {
+            this._id = id;
+            this._name = name;
+            this._synthetic = false;
+            this._alternatives = new ArrayList();
+            this._defaultAlt = -1;
+            this._lookAhead = null;
+        }
+        public int Id => _id;
+
+        public int GetId()
+        {
+            return Id;
+        }
+
+        public string Name => _name;
+
+        public string GetName()
+        {
+            return Name;
+        }
+
+        public bool Synthetic
+        {
+            get
+            {
+                return _synthetic;
+            }
+            set
+            {
+                _synthetic = value;
+            }
+        }
+
+        public bool IsSyntetic()
+        {
+            return Synthetic;
+        }
+
+        public void SetSyntetic(bool synthetic)
+        {
+            Synthetic = synthetic;
+        }
+
+        internal LookAheadSet LookAhead
+        {
+            get
+            {
+                return _lookAhead;
+            }
+            set
+            {
+                _lookAhead = value;
+            }
+        }
+
+        internal ProductionPatternAlternative DefaultAlternative
+        {
+            get
+            {
+                if (_defaultAlt >= 0)
+                {
+                    object obj = _alternatives[_defaultAlt];
+                    return (ProductionPatternAlternative)obj;
+                }
+                else
+                {
+                    return null;
+                }
+            }
+            set
+            {
+                _defaultAlt = 0;
+                for (int i = 0; i < _alternatives.Count; i++)
+                {
+                    if (_alternatives[i] == value)
+                    {
+                        _defaultAlt = i;
+                    }
+                }
+            }
+        }
+
+        public int Count => _alternatives.Count;
+
+        public int GetAlternativeCount()
+        {
+            return Count;
+        }
+
+        public ProductionPatternAlternative this[int index] => (ProductionPatternAlternative)_alternatives[index];
+
+        public ProductionPatternAlternative GetAlternative(int pos)
+        {
+            return this[pos];
+        }
+
+        public bool IsLeftRecursive()
+        {
+            ProductionPatternAlternative alt;
+
+            for (int i = 0; i < _alternatives.Count; i++)
+            {
+                alt = (ProductionPatternAlternative)_alternatives[i];
+                if (alt.IsLeftRecursive())
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        public bool IsRightRecursive()
+        {
+            ProductionPatternAlternative alt;
+
+            for (int i = 0; i < _alternatives.Count; i++)
+            {
+                alt = (ProductionPatternAlternative)_alternatives[i];
+                if (alt.IsRightRecursive())
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        public bool IsMatchingEmpty()
+        {
+            ProductionPatternAlternative alt;
+
+            for (int i = 0; i < _alternatives.Count; i++)
+            {
+                alt = (ProductionPatternAlternative)_alternatives[i];
+                if (alt.IsMatchingEmpty())
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        public void AddAlternative(ProductionPatternAlternative alt)
+        {
+            if (_alternatives.Contains(alt))
+            {
+                throw new ParserCreationException(
+                    ParserCreationException.ErrorType.INVALID_PRODUCTION,
+                    _name,
+                    "two identical alternatives exist");
+            }
+            alt.SetPattern(this);
+            _alternatives.Add(alt);
+        }
+
+        public override string ToString()
+        {
+            StringBuilder buffer = new StringBuilder();
+            StringBuilder indent = new StringBuilder();
+            int i;
+
+            buffer.Append(_name);
+            buffer.Append("(");
+            buffer.Append(_id);
+            buffer.Append(") ");
+            for (i = 0; i < buffer.Length; i++)
+            {
+                indent.Append(" ");
+            }
+            for (i = 0; i < _alternatives.Count; i++)
+            {
+                if (i == 0)
+                {
+                    buffer.Append("= ");
+                }
+                else
+                {
+                    buffer.Append("\n");
+                    buffer.Append(indent);
+                    buffer.Append("| ");
+                }
+                buffer.Append(_alternatives[i]);
+            }
+            return buffer.ToString();
+        }
+    }
+}