--- a/c/regexParser/bitVector.h	Wed Dec 09 19:57:22 2015 +0900
+++ b/c/regexParser/bitVector.h	Fri Dec 11 13:12:42 2015 +0900
@@ -8,3 +8,4 @@
 BitVectorPtr createBitVector(NodePtr n);
 const BitVectorPtr allocateBitVector();
 void bitSet(BitVectorPtr bi, int bitSetPosition);
+void bitPrint(BitVectorPtr bi);

--- a/c/regexParser/main.cc	Wed Dec 09 19:57:22 2015 +0900
+++ b/c/regexParser/main.cc	Fri Dec 11 13:12:42 2015 +0900
@@ -9,7 +9,6 @@
 int main(int argc, char **argv)
 {
     RegexInfoPtr ri = (RegexInfoPtr)malloc(sizeof(RegexInfo));
-    TransitionGeneratorPtr tg = (TransitionGeneratorPtr)malloc(sizeof(TransitionGenerator));
     ri->nodeNumber = 1;
     ri->orNum = 0;
     ri->asterFlag = false;
@@ -23,5 +22,6 @@
     printf("regex : %s\n",ri->ptr);
     NodePtr n = regex(ri);
     printTree(n);
+    TransitionGeneratorPtr tg = generateTransitionList(n);
     return 0;
 }

--- a/c/regexParser/subsetConstraction.cc	Wed Dec 09 19:57:22 2015 +0900
+++ b/c/regexParser/subsetConstraction.cc	Fri Dec 11 13:12:42 2015 +0900
@@ -3,21 +3,62 @@
 #include <ctype.h>
 #include "subsetConstraction.h"
 
+void printTransition(TransitionPtr ts) {
+    for (;;) {
+        printf("Input Condition : %c\n",ts->condition->cond->w->word);
+        printf("Next  State     : "); bitPrint(ts->nextState); printf("\n");
+        if (ts->next == NULL) break;
+        ts = ts->next;
+    }
+}
+
 TGValuePtr generateTransition(NodePtr n,TransitionGeneratorPtr tg) {
-    TGValuePtr t = NULL;
+    TGValuePtr tgv0 = NULL;
+    TGValuePtr tgv1 = NULL;
+
+    if (n->tokenType == '+') {
+        tgv0 = generateTransition(n->left,tg);
+        tgv1 = generateTransition(n->right,tg);
+    } else if (n->tokenType == '|') {
+        tgv0 = generateTransition(n->left,tg);
+        tgv1 = generateTransition(n->right,tg);
+        tg->state->transition = appendTransition(tgv0->ts,tgv1->ts);
+    } else if (n->tokenType == '*') {
+        tgv0 = generateTransition(n->left,tg);
+        tgv0->asterisk = true;
+    } else {
+        tgv0 = (TGValuePtr)malloc(sizeof(TGValue));
+        BitVectorPtr bi = createBitVector(n);
+        tgv0->ts = createTransition(n->cc,bi);
+        tgv0->asterisk = false;
+    }
+
+    return tgv0;
+}
+
+StatePtr createStateList(NodePtr n) {
+    StatePtr s0 = NULL;
     if (n->left != NULL) {
-        t = generateTransition(n->left, tg);
+        s0 = createStateList(n->left);
     }
+
     if (n->tokenType == 'a') {
-
-    } else if (n->tokenType == 'c') {
-        t = generateTransition(n,tg);
-    } else {
-
+        BitVectorPtr bi = createBitVector(n);
+        StatePtr s1 = createState(bi,0,0);
+    } else if (n->tokenType == '+' || n->tokenType == '|') {
+        
     }
 
     if (n->right != NULL) {
-        t = generateTransition(n->right, tg);
+        s0 = createStateList(n->right);
     }
-    return t;
+    return s0;
 }
+
+TransitionGeneratorPtr generateTransitionList(NodePtr n) {
+    TransitionGeneratorPtr tg = (TransitionGeneratorPtr)malloc(sizeof(TransitionGenerator));
+    int d = 0;
+    tg->state = createStateList(n);
+    generateTransition(n,tg);
+    return tg;
+}

--- a/c/regexParser/subsetConstraction.h	Wed Dec 09 19:57:22 2015 +0900
+++ b/c/regexParser/subsetConstraction.h	Fri Dec 11 13:12:42 2015 +0900
@@ -2,7 +2,7 @@
 
 typedef struct transitionGenerator {
     TransitionPtr ts;
-    BitVectorPtr state;
+    StatePtr state;
     long stateMax;
 } TransitionGenerator, *TransitionGeneratorPtr;
 
@@ -11,4 +11,7 @@
     bool asterisk;
 } TGValue, *TGValuePtr;
 
-extern TGValuePtr generateTransition(NodePtr n,TransitionGeneratorPtr tg);
+void printTransition(TransitionPtr ts);
+TGValuePtr generateTransition(NodePtr n,TransitionGeneratorPtr tg);
+StatePtr createStateList(NodePtr n);
+TransitionGeneratorPtr generateTransitionList(NodePtr n);

--- a/c/regexParser/transition.cc	Wed Dec 09 19:57:22 2015 +0900
+++ b/c/regexParser/transition.cc	Fri Dec 11 13:12:42 2015 +0900
@@ -1,6 +1,34 @@
 #include <stdlib.h>
 #include "transition.h"
 
+StatePtr createState(BitVectorPtr bi, TransitionPtr ts, StatePtr next) {
+    StatePtr s = (StatePtr)malloc(sizeof(State));
+    s->bitState = bi;
+    s->transition = ts;
+    s->next = next;
+    return s;
+}
+
+StatePtr appendState(StatePtr x, StatePtr y) {
+    if (x == NULL) {
+        x = createState(y->bitState,y->transition,y->next);
+        return x;
+    }
+
+    StatePtr x0 = createState(x->bitState, x->transition, x->next);
+    StatePtr x1 = x0;
+    for(;;) {
+        if (x->next == NULL) {
+            x1->next = y;
+            return x0;
+        }
+        x = x->next;
+        x1->next = createState(x->bitState, x->transition, x->next);
+        x1 = x1->next;
+    }
+    return x0;
+}
+
 TransitionPtr createTransition(CharClassPtr cc, BitVectorPtr state) {
     TransitionPtr transition = (TransitionPtr)malloc(sizeof(Transition));
     transition->condition = cc;

--- a/c/regexParser/transition.h	Wed Dec 09 19:57:22 2015 +0900
+++ b/c/regexParser/transition.h	Fri Dec 11 13:12:42 2015 +0900
@@ -7,10 +7,13 @@
 } Transition, *TransitionPtr;
 
 typedef struct state {
+    BitVectorPtr bitState;
     TransitionPtr transition;
     struct state *next;
 } State, *StatePtr;
 
+StatePtr createState(BitVectorPtr bi, TransitionPtr ts, StatePtr next);
+StatePtr appendState(StatePtr x, StatePtr y);
 TransitionPtr createTransition(CharClassPtr cc ,BitVectorPtr state);
 TransitionPtr appendTransition0(TransitionPtr curr,TransitionPtr next);
 TransitionPtr appendTransition(TransitionPtr curr,TransitionPtr next);