# HG changeset patch
# User Masataka Kohagura <kohagura@cr.ie.u-ryukyu.ac.jp>
# Date 1451025052 -32400
# Node ID 3e8e5780ad4a3d3bca266b977601ffeb0e4fd33e
# Parent  fccf7941ecc2c0d19f418e1321355d20aff8484e
change node::State to State

diff -r fccf7941ecc2 -r 3e8e5780ad4a regexParser/main.cc
--- a/regexParser/main.cc	Fri Dec 25 14:42:31 2015 +0900
+++ b/regexParser/main.cc	Fri Dec 25 15:30:52 2015 +0900
@@ -2,10 +2,9 @@
 #include <stdlib.h>
 #include <string.h>
 #include "regexParser.h"
+#include "subsetConstraction.h"
+#include "node.h"
 
-extern NodePtr regex(RegexInfoPtr);
-extern void printTree(NodePtr);
-extern TransitionGeneratorPtr generateTransitionList(NodePtr n);
 int main(int argc, char **argv)
 {
     RegexInfo ri;
@@ -19,5 +18,6 @@
     NodePtr n = regex(&ri);
     printTree(n);
     TransitionGeneratorPtr tg = generateTransitionList(n);
+    printState(tg);
     return 0;
 }
diff -r fccf7941ecc2 -r 3e8e5780ad4a regexParser/node.cc
--- a/regexParser/node.cc	Fri Dec 25 14:42:31 2015 +0900
+++ b/regexParser/node.cc	Fri Dec 25 15:30:52 2015 +0900
@@ -1,7 +1,8 @@
 #include <stdio.h>
+#include "regexParser.h"
 #include "node.h"
 
-static void printCharacterClass(CharClassPtr cc, long nodeNumber,int d) {
+void printCharacterClass(CharClassPtr cc, long nodeNumber,int d) {
     if (cc->type == 'r') {
         if (cc->left) {
             printCharacterClass(cc->left,nodeNumber,d+1);
@@ -22,7 +23,7 @@
     }
 }
 
-static void descendTree(NodePtr n, int d) {
+void descendTree(NodePtr n, int d) {
     if (n->left != NULL) {
         descendTree(n->left, d+1);
     }
diff -r fccf7941ecc2 -r 3e8e5780ad4a regexParser/node.h
--- a/regexParser/node.h	Fri Dec 25 14:42:31 2015 +0900
+++ b/regexParser/node.h	Fri Dec 25 15:30:52 2015 +0900
@@ -1,4 +1,3 @@
-#include "regexParser.h"
-
-static void descendTree(NodePtr,int);
-void printTree(NodePtr);
+extern void descendTree(NodePtr,int);
+extern void printTree(NodePtr);
+extern void printCharacterClass(CharClassPtr cc, long nodeNumber,int d);
diff -r fccf7941ecc2 -r 3e8e5780ad4a regexParser/regexParser.cc
--- a/regexParser/regexParser.cc	Fri Dec 25 14:42:31 2015 +0900
+++ b/regexParser/regexParser.cc	Fri Dec 25 15:30:52 2015 +0900
@@ -7,7 +7,6 @@
 static NodePtr charClass(RegexInfoPtr);
 static void token(RegexInfoPtr);
 static NodePtr regexAtom(RegexInfoPtr);
-NodePtr regex(RegexInfoPtr);
 
 /**
  * Create a node of regex parse tree.
diff -r fccf7941ecc2 -r 3e8e5780ad4a regexParser/regexParser.h
--- a/regexParser/regexParser.h	Fri Dec 25 14:42:31 2015 +0900
+++ b/regexParser/regexParser.h	Fri Dec 25 15:30:52 2015 +0900
@@ -32,17 +32,20 @@
     BitVector nextState;
 } CharClass, *CharClassPtr;
 
+struct node;
+
+typedef struct state {
+    BitVector bitState;
+    CharClassPtr cc;
+    struct node *node;
+    struct state *next;
+} State, *StatePtr;
+
 typedef struct node {
     unsigned char tokenType;
     CharClassPtr cc;
     int stateNum;
     int nextStateNum;
-    typedef struct state {
-        BitVector bitState;
-        CharClassPtr cc;
-        struct node *node;
-        struct state *next;
-    } State, *StatePtr;
     StatePtr state;
     struct node *left;
     struct node *right;
@@ -56,11 +59,11 @@
 typedef struct transitionGenerator {
     long stateMax;
     StateStackPtr stack;
-    node::StatePtr state;
-    node::StatePtr stateArray;
-    node::StatePtr currentState;
-    node::StatePtr startState;
-    node::StatePtr endState;
+    StatePtr state;
+    StatePtr stateArray;
+    StatePtr currentState;
+    StatePtr startState;
+    StatePtr endState;
 } TransitionGenerator, *TransitionGeneratorPtr;
 
 typedef struct tgValue {
@@ -68,7 +71,7 @@
     int stateNum;
     int stateBegin;
     int stateEnd;
-    node::StatePtr tgState;
+    StatePtr tgState;
     TransitionGeneratorPtr tg;
 } TGValue, *TGValuePtr;
 
@@ -97,5 +100,7 @@
     int stateNumber;
 } RegexInfo, *RegexInfoPtr;
 #endif
-NodePtr createNode(RegexInfoPtr ri,unsigned char type,CharClassPtr cc, NodePtr left, NodePtr right);
+
+extern NodePtr createNode(RegexInfoPtr ri,unsigned char type,CharClassPtr cc, NodePtr left, NodePtr right);
 extern CharClassPtr createCharClassRange(unsigned long begin, unsigned long end,unsigned long state, CharClassPtr left, CharClassPtr right);
+extern NodePtr regex(RegexInfoPtr);
diff -r fccf7941ecc2 -r 3e8e5780ad4a regexParser/subsetConstraction.cc
--- a/regexParser/subsetConstraction.cc	Fri Dec 25 14:42:31 2015 +0900
+++ b/regexParser/subsetConstraction.cc	Fri Dec 25 15:30:52 2015 +0900
@@ -2,6 +2,7 @@
 #include <stdlib.h>
 #include <ctype.h>
 #include "subsetConstraction.h"
+#include "node.h"
 
 CharClassPtr createCharClassWord(unsigned char *w, CharClassPtr cc1, CharClassPtr cc2) {
     CharClassPtr cc = NEW(CharClass);
@@ -186,7 +187,7 @@
     }
 }
 
-CharClassPtr mergeTransition(node::StatePtr x,CharClassPtr y) {
+CharClassPtr mergeTransition(StatePtr x,CharClassPtr y) {
     if (x->cc == NULL) {
         return y;
     }
@@ -208,8 +209,8 @@
     bitvector を index とした配列に BitVectorPtr を格納
     state に対応する NodePtr を
  */
-node::StatePtr createState(TGValue tg,NodePtr n) {
-    node::StatePtr s = NEW(node::State);
+StatePtr createState(TGValue tg,NodePtr n) {
+    StatePtr s = NEW(State);
     s->next = tg.tg->currentState;
     tg.tg->currentState = s;
     s->node = n;
@@ -273,7 +274,7 @@
             tgRight.asterisk = true;
             return tgRight;
         }
-        node::StatePtr left = tg.tgState;
+        StatePtr left = tg.tgState;
         tg.tgState = n->left->state;
         // tg.tg->stateArray[tg.tgState->bitState.bitContainer] = tg.tgState;
         TGValue tgLeft = generateTransition(n->left,tg);
@@ -304,7 +305,7 @@
     TransitionGeneratorPtr tg = NEW(TransitionGenerator);
     tg->stateMax = 0;
     tg->stack = NULL;
-    tg->state = NEW(node::State);
+    tg->state = NEW(State);
     tg->stateArray = NULL;
     tg->currentState = NULL;
     return tg;
@@ -322,7 +323,26 @@
     tgv.stateEnd = 1;
     stateAllocate(n,tgv);
     tgv.tg->stateMax = tg->stateMax;
-    tgv.tg->stateArray = (node::StatePtr)calloc(tg->stateMax,sizeof(node::StatePtr));
+    BitVector bi = createBitVector(tg->stateMax);
+    tgv.tg->stateArray = (StatePtr)calloc(bi.bitContainer*2,sizeof(StatePtr));
     generateTransition(n,tgv);
     return tg;
 }
+
+void printState(StatePtr state) {
+    printf("state : %lx\n",state->bitState.bitContainer);
+    long nodeNumber = 0;
+    if (state->node) {
+        printf("node : %c %d -> %d\n",state->node->tokenType,state->node->stateNum,state->node->nextStateNum);
+        nodeNumber = state->node->stateNum;
+    }
+    printCharacterClass(state->cc,nodeNumber,4);
+}
+
+void printState(TransitionGeneratorPtr tg) {
+    StatePtr state = tg->currentState;
+    for (;state;state = state->next) {
+        printState(state);
+        putchar('\n');
+    }
+}
diff -r fccf7941ecc2 -r 3e8e5780ad4a regexParser/subsetConstraction.h
--- a/regexParser/subsetConstraction.h	Fri Dec 25 14:42:31 2015 +0900
+++ b/regexParser/subsetConstraction.h	Fri Dec 25 15:30:52 2015 +0900
@@ -1,3 +1,5 @@
 #include "transition.h"
 #include "bitVector.h"
-CharClassPtr charClassMerge(CharClassPtr cc,unsigned long begin, unsigned long end, BitVector nextState);
+extern CharClassPtr charClassMerge(CharClassPtr cc,unsigned long begin, unsigned long end, BitVector nextState);
+extern TransitionGeneratorPtr generateTransitionList(NodePtr n);
+extern void printState(TransitionGeneratorPtr tg);
diff -r fccf7941ecc2 -r 3e8e5780ad4a regexParser/transition.cc
--- a/regexParser/transition.cc	Fri Dec 25 14:42:31 2015 +0900
+++ b/regexParser/transition.cc	Fri Dec 25 15:30:52 2015 +0900
@@ -1,13 +1,13 @@
 #include <stdlib.h>
 #include "transition.h"
 
-node::StatePtr searchState(node::StatePtr stateArray, node::StatePtr state) {
+StatePtr searchState(StatePtr stateArray, StatePtr state) {
     while(stateArray) {
         if (stateArray->bitState.bitContainer == state->bitState.bitContainer) {
             return stateArray;
         }
         if (stateArray->next == NULL) {
-            node::StatePtr s = createState(state->bitState);
+            StatePtr s = createState(state->bitState);
             stateArray = appendState(stateArray,s);
             return stateArray;
         }
@@ -16,16 +16,16 @@
     return stateArray;
 }
 
-node::StatePtr createState(BitVector bi) {
-    node::StatePtr state = NEW(node::State);
+StatePtr createState(BitVector bi) {
+    StatePtr state = NEW(State);
     state->bitState = bi;
     state->node = NEW(Node);
     return state;
 }
 
-node::StatePtr appendState(node::StatePtr x,node::StatePtr y) {
-    node::StatePtr x0 = createState(x->bitState);
-    node::StatePtr x1 = x0;
+StatePtr appendState(StatePtr x,StatePtr y) {
+    StatePtr x0 = createState(x->bitState);
+    StatePtr x1 = x0;
     for(;;) {
         if (x->next == NULL) {
             x1->next = y;
diff -r fccf7941ecc2 -r 3e8e5780ad4a regexParser/transition.h
--- a/regexParser/transition.h	Fri Dec 25 14:42:31 2015 +0900
+++ b/regexParser/transition.h	Fri Dec 25 15:30:52 2015 +0900
@@ -1,6 +1,6 @@
 #include "bitVector.h"
-node::StatePtr createState(BitVector bi);
-node::StatePtr appendState(node::StatePtr x,node::StatePtr y);
+StatePtr createState(BitVector bi);
+StatePtr appendState(StatePtr x,StatePtr y);
 /*
   正規表現木を辿って transition のList をつくる
   CharClass のかさなりを判定して重なりのない新しいCharClassをつくる