예제 #1
0
    def build(self):
        self._reset_nfa()
        self.regex_postfix = prepare_regex(self.regex_infix)

        sm_queue = []

        for char in self.regex_postfix:
            if char == RegexConfig.ZERO_OR_MORE:
                if len(sm_queue) < 1:
                    raise ValueError('Regex parsing error')
                sm1 = sm_queue.pop()
                sm = self._build_zero_or_more_sm(sm1)
                sm_queue.append(sm)

            elif char == RegexConfig.ONE_OR_MORE:
                if len(sm_queue) < 1:
                    raise ValueError('Regex parsing error')
                sm1 = sm_queue.pop()
                sm = self._build_one_or_more_sm(sm1)
                sm_queue.append(sm)

            elif char == RegexConfig.AND:
                if len(sm_queue) < 2:
                    raise ValueError('Regex parsing error')

                sm2 = sm_queue.pop()
                sm1 = sm_queue.pop()

                sm = self._build_and_sm(sm1, sm2)
                sm_queue.append(sm)

            elif char == RegexConfig.OR:
                if len(sm_queue) < 2:
                    raise ValueError('Regex parsing error')

                sm2 = sm_queue.pop()
                sm1 = sm_queue.pop()
                sm = self._build_or_sm(sm1, sm2)
                sm_queue.append(sm)

            # [A-Za-z0-9]
            elif char in RegexConfig.VALID_SYMBOLS:
                sm = self._build_basic_sm(char)
                sm_queue.append(sm)
            else:
                raise ValueError('Regex parsing error')

        self.nfa = sm_queue.pop()
 def test_miss_opening_bracket(self):
     with self.assertRaises(ValueError):
         prepare_regex('a|b)')
 def test_unacceptable(self):
     with self.assertRaises(ValueError):
         prepare_regex('abc123$')
 def test(self):
     result = ''.join(prepare_regex('(a|b|c)&(a|b)'))
     print(result)
 def test_concatenation(self):
     result = ''.join(prepare_regex('(a|b)*a?b?c'))
     self.assertEqual(result, 'ab|*a?&b?&c&')
 def test_correct_simple(self):
     result = ''.join(prepare_regex('(a|b)*&a?&b?&c'))
     self.assertEqual(result, 'ab|*a?&b?&c&')
 def test_spaces(self):
     result = ''.join(prepare_regex('a | b'))
     self.assertEqual(result, 'ab|')
 def test_miss_closing_bracket(self):
     with self.assertRaises(ValueError):
         prepare_regex('(a|b')