Software Toolchain for Large-Scale RE-NFA Construction on FPGA

Algorithm 1

Modified McNaughton-Yamada construction (MMY) converting a regular expression parse-tree to an RE-NFA with a modular and uniform structure.

Notations:

𝑛 [value] Content value of node 𝑛.

𝑛 [left∣ right∣ child] Left, right, or only child of node 𝑛.

𝑠 [next]     Set of next-state transitions of state 𝑠.

𝑠[char]      Set of matching characters of state 𝑠.

Macros:

𝑠←CREATE_STATE (𝑇):

            Create a new state 𝑠 in the state transition table

            𝑇.

𝑝←CREATE_PSEAUDO():

       Create a special pseudo-state 𝑝 for later use.

ADD_PSEUDO_NEXT (𝑝,𝑆):

       For every state 𝑠∈𝑆, add the state set 𝑝 [next]

       to 𝑠 [next]. Pseudo-state 𝑝 is deleted afterward.

PROCEDURE 𝑆_out⇐RE2NFA (𝑛_root, 𝑆_pre, 𝑇_NFA)

  𝑛_root Root node of the parse (sub-)tree.

  𝑆_pre   Set of immediate previous states.

  𝑆_out   Set of states transitioning directly outside of 𝑛_root.

  𝑇_NFA The resulting state transition table.

BEGIN

   𝑛_cur←𝑛_root;

   while 𝑛_cur≠𝑛𝑢𝑙𝑙

     if 𝑛_cur [value] = OP_CONCAT

      𝑆_pre← RE2NFA (𝑛_cur [left], 𝑆_pre,𝑇_NFA);

      𝑛_cur←𝑛_cur [right];

     else if 𝑛_cur [value] = OP_UNION

      𝑆_𝐿← RE2NFA (𝑛_cur [left], 𝑆_pre,𝑇_NFA);

      𝑆_𝑅← RE2NFA (𝑛_cur [right], 𝑆_pre,𝑇_NFA);

    return 𝑆_𝐿∪𝑆_𝑅;

     else if 𝑛_cur [value] = OP_CLOSURE

      𝑝←CREATE_PSEUO();

      𝑆_𝑡𝑚𝑝←𝑆_pre∪𝑝;

      𝑆_𝐶← RE2NFA (𝑛_cur [child], 𝑆_𝑡𝑚𝑝,𝑇_NFA);

      ADD_PSEUDO_NEXT(𝑝,𝑆_𝐶);

      return   𝑆_𝐶∪𝑆_pre;

     else // 𝑛_cur=leafnode

      𝑠_new←CREATE_STATE (𝑇_NFA);

      𝑠_new [char]←𝑛_cur [value];

      foreach 𝑠   in 𝑆_pre

       // add 𝜖-transitions

        𝑠 [next]←𝑠 [next]∪𝑠_new;

      end foreach

       return 𝑠_new;

     end if

   end while

   // error: 𝑛_cur [right] cannot be 𝑛𝑢𝑙𝑙

END