private FSM <int> ParseSet()
        {
            List <int> charset = new List <int>();
            bool       negate  = false;

            if (this.Pattern[_parseIndex] == '^')
            {
                negate = true;
                _parseIndex++;
            }

            while (this.Pattern[_parseIndex] != ']')
            {
                switch (this.Pattern[_parseIndex])
                {
                case '\\':
                    _parseIndex++;
                    charset.Add(this.Pattern[_parseIndex++]);
                    break;

                case '-':
                    _parseIndex++;
                    int start = charset.Last();
                    charset.RemoveAt(charset.Count - 1);
                    for (int c = start; c <= this.Pattern[_parseIndex]; c++)
                    {
                        charset.Add(c);
                    }
                    _parseIndex++;
                    break;

                default:
                    charset.Add(this.Pattern[_parseIndex++]);
                    break;
                }
            }

            //consume closing set
            _parseIndex++;

            FSM <int> result = new NFSM <int>(-1);

            for (int i = 0; i < 256; i++)
            {
                if (i != (int)'\\')
                {
                    if ((!negate && charset.Contains(i)) || (negate && !charset.Contains(i)))
                    {
                        result = result.Or(i);
                    }
                }
            }

            return(result);
        }
Beispiel #2
0
        private FSM <int> AnyChar()
        {
            FSM <int> result = new NFSM <int>(-1);

            for (int i = 0; i < 256; i++)
            {
                result = result.Or(i);
            }

            return(result);
        }
        public override FSM <T> And(T symbol)
        {
            FSM <T> andvar = new NFSM <T>(this.Epsilon, symbol);

            foreach (string label in this.AcceptingLabels)
            {
                andvar.AcceptingStates.Last().Value.Add(label);
            }

            return(this.And(andvar));
        }
        public override FSM <T> Or(FSM <T> fsm)
        {
            NFSM <T> result = (NFSM <T>) this.Clone();

            if (this._transitions[0].Count == 0)
            {
                return(fsm);
            }

            int offset = result._transitions.Keys.OrderBy(x => x).Last();

            foreach (int state in fsm._transitions.Keys)
            {
                foreach (T symbol in fsm._transitions[state].Keys)
                {
                    int startstate = (state != 0) ? state + offset : 0;
                    if (!result._transitions.ContainsKey(startstate))
                    {
                        result._transitions[startstate] = new Dictionary <T, List <int> >();
                    }
                    if (!result._transitions[startstate].ContainsKey(symbol))
                    {
                        result._transitions[startstate][symbol] = new List <int>();
                    }
                    foreach (int target in fsm._transitions[state][symbol])
                    {
                        int endstate = target + offset;

                        if (fsm.AcceptingStates.ContainsKey(target))
                        {
                            endstate = result.AcceptingStates.Keys.Last();
                        }

                        result._transitions[startstate][symbol].Add(endstate);
                        if (!result._transitions.ContainsKey(endstate))
                        {
                            result._transitions[endstate] = new Dictionary <T, List <int> >();
                        }

                        if (fsm.AcceptingStates.ContainsKey(target))
                        {
                            if (!result.AcceptingStates.ContainsKey(endstate))
                            {
                                result.AcceptingStates[endstate] = new List <string>();
                            }
                            result.AcceptingStates[endstate].AddRange(fsm.AcceptingStates[target].Except(result.AcceptingStates[endstate]));
                        }
                    }
                }
            }

            return(result);
        }
        public override FSM <T> And(FSM <T> fsm)
        {
            NFSM <T> result = (NFSM <T>) this.Clone();

            result.AcceptingStates.Clear();

            if (this._transitions[0].Count == 0)
            {
                return(fsm);
            }

            for (int i = 0; i < this.AcceptingStates.Count; i++)
            {
                int offset = result.States.Last();

                foreach (int state in fsm._transitions.Keys)
                {
                    foreach (T symbol in fsm._transitions[state].Keys)
                    {
                        int startstate = state + offset;
                        if (state == 0)
                        {
                            startstate = this.AcceptingStates.Keys.ToArray()[i];
                        }
                        if (!result._transitions.ContainsKey(startstate))
                        {
                            result._transitions[startstate] = new Dictionary <T, List <int> >();
                        }
                        result._transitions[startstate][symbol] = new List <int>();
                        foreach (int target in fsm._transitions[state][symbol])
                        {
                            int endstate = target + offset;
                            if (target == 0)
                            {
                                endstate = this.AcceptingStates.Keys.ToArray()[i];
                            }
                            result._transitions[startstate][symbol].Add(endstate);
                            if (!result._transitions.ContainsKey(endstate))
                            {
                                result._transitions[endstate] = new Dictionary <T, List <int> >();
                            }

                            if (fsm.AcceptingStates.ContainsKey(target))
                            {
                                result.AcceptingStates[endstate] = new List <string>(fsm.AcceptingStates[target]);
                            }
                        }
                    }
                }
            }

            return(result);
        }
        public NFSM(NFSM <T> nfsm) : this(nfsm.Epsilon)
        {
            foreach (int state in nfsm._transitions.Keys)
            {
                this._transitions[state] = new Dictionary <T, List <int> >();
                foreach (T symbol in nfsm._transitions[state].Keys)
                {
                    this._transitions[state][symbol] = new List <int>(nfsm._transitions[state][symbol]);
                }
            }

            this.AcceptingStates = new Dictionary <int, List <string> >();
            foreach (KeyValuePair <int, List <string> > acc in nfsm.AcceptingStates)
            {
                this.AcceptingStates[acc.Key] = new List <string>(acc.Value);
            }
        }
        public object Clone()
        {
            NFSM <T> result = new NFSM <T>(this.Epsilon);

            foreach (KeyValuePair <int, Dictionary <T, List <int> > > i in this._transitions)
            {
                result._transitions[i.Key] = new Dictionary <T, List <int> >();
                foreach (KeyValuePair <T, List <int> > j in i.Value)
                {
                    result._transitions[i.Key][j.Key] = new List <int>(this._transitions[i.Key][j.Key]);
                }
            }

            foreach (KeyValuePair <int, List <string> > i in this.AcceptingStates)
            {
                result.AcceptingStates[i.Key] = new List <string>(this.AcceptingStates[i.Key]);
            }

            return(result);
        }
        public override FSM <T> Kleene()
        {
            NFSM <T> result = (NFSM <T>) this.Clone();
            NFSM <T> eps    = new NFSM <T>(this.Epsilon, this.Epsilon);

            eps.AcceptingStates.Clear();
            eps.AcceptingStates[1] = new List <string>(this.AcceptingLabels);
            result = (NFSM <T>)eps.And(result).And(eps).Or(eps);

            foreach (int acc in result.AcceptingStates.Keys)
            {
                if (!result._transitions[acc].ContainsKey(this.Epsilon))
                {
                    result._transitions[acc][this.Epsilon] = new List <int>();
                }

                result._transitions[acc][this.Epsilon].Add(1);
            }

            return(result);
        }
Beispiel #9
0
        private FSM <int> ConcatRegex()
        {
            FSM <int>         result = new NFSM <int>(-1);
            List <FSM <int> > temp   = new List <FSM <int> >();

            while (_parseIndex < this.Pattern.Length)
            {
                switch (this.Pattern[_parseIndex])
                {
                case '|':
                case ')':
                    return(temp.Aggregate(new NFSM <int>(-1), (a, b) => (NFSM <int>)a.And(b)));

                case '*':
                    _parseIndex++;
                    temp[temp.Count - 1] = temp[temp.Count - 1].Kleene();
                    break;

                case '+':
                    _parseIndex++;
                    temp[temp.Count - 1] = temp[temp.Count - 1].And(temp[temp.Count - 1].Kleene());
                    break;

                case '?':
                    _parseIndex++;
                    FSM <int> next = new NFSM <int>(-1, -1);
                    temp[temp.Count - 1] = temp[temp.Count - 1].Or(next);
                    break;

                default:
                    temp.Add(BasicRegex());
                    break;
                }
            }

            return(temp.Aggregate(new NFSM <int>(-1), (a, b) => (NFSM <int>)a.And(b)));
        }