# HG changeset patch
# User Masataka Kohagura <kohagura@cr.ie.u-ryukyu.ac.jp>
# Date 1450964330 -32400
# Node ID ef798db705e97577ff4a3cdb3500b195a8a75336
# Parent  3e8aae8beba95764c51389bdf0105dd31c3dbe9b
remove some warnings and errors(not working)

diff -r 3e8aae8beba9 -r ef798db705e9 regexParser/bitVector.cc
--- a/regexParser/bitVector.cc	Thu Dec 24 20:37:29 2015 +0900
+++ b/regexParser/bitVector.cc	Thu Dec 24 22:38:50 2015 +0900
@@ -4,14 +4,14 @@
 #include "bitVector.h"
 
 BitVector createBitvector(int state) {
-    unsigned long tmp = 1 << bitSetPosition;
-    BitVector bi1 = (struct BitVector){.bitContainer = tmp};
+    unsigned long tmp = 1 << state;
+    BitVector bi1 = (BitVector){.bitContainer = tmp};
     return bi1;
 }
 
 BitVector bitSet(BitVector bi, int bitSetPosition) {
     unsigned long tmp = 1 << bitSetPosition;
-    BitVector bi1 = (struct BitVector){.bitContainer = bi.bitContainer | tmp};
+    BitVector bi1 = (BitVector){.bitContainer = bi.bitContainer | tmp};
     return bi1;
 }
 
diff -r 3e8aae8beba9 -r ef798db705e9 regexParser/bitVector.h
--- a/regexParser/bitVector.h	Thu Dec 24 20:37:29 2015 +0900
+++ b/regexParser/bitVector.h	Thu Dec 24 22:38:50 2015 +0900
@@ -1,7 +1,7 @@
 #include "regexParser.h"
 #define BITBLOCK 64
 
-BitVectorPtr createBitVector(NodePtr n);
+BitVector createBitVector(int state);
 const BitVectorPtr allocateBitVector();
 void bitSet(BitVectorPtr bi, int bitSetPosition);
 void bitPrint(BitVectorPtr bi);
diff -r 3e8aae8beba9 -r ef798db705e9 regexParser/main.cc
--- a/regexParser/main.cc	Thu Dec 24 20:37:29 2015 +0900
+++ b/regexParser/main.cc	Thu Dec 24 22:38:50 2015 +0900
@@ -1,7 +1,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include "subsetConstraction.h"
+#include "regexParser.h"
 
 extern NodePtr regex(RegexInfoPtr);
 extern void printTree(NodePtr);
diff -r 3e8aae8beba9 -r ef798db705e9 regexParser/node.cc
--- a/regexParser/node.cc	Thu Dec 24 20:37:29 2015 +0900
+++ b/regexParser/node.cc	Thu Dec 24 22:38:50 2015 +0900
@@ -15,7 +15,7 @@
                 break;
            }
         }
-        printf("(%lu)\n",nodeNumber);
+        printf("(%ld)\n",nodeNumber);
         if (cc->right) {
             printCharacterClass(cc->right,nodeNumber,d+1);
         }
@@ -31,11 +31,11 @@
         for (int i = 0; i < n->cc->cond.w.length; i++) {
             putchar(n->cc->cond.w.word[i]);
         }
-        printf("(%lu)\n",n->nodeNumber);
+        printf("(%d)\n",n->stateNum);
     } else if (n->tokenType == 'c') {
-        printCharacterClass(n->cc,n->nodeNumber,d);
+        printCharacterClass(n->cc,n->stateNum,d);
     } else if (n->tokenType == 'a') {
-        printf("%*c%c(%lu)\n",d*4, ' ',n->tokenType,n->nodeNumber);
+        printf("%*c%c(%d)\n",d*4, ' ',n->tokenType,n->stateNum);
     } else {
         printf("%*c%c\n",d*4, ' ',n->tokenType);
     }
diff -r 3e8aae8beba9 -r ef798db705e9 regexParser/regexParser.cc
--- a/regexParser/regexParser.cc	Thu Dec 24 20:37:29 2015 +0900
+++ b/regexParser/regexParser.cc	Thu Dec 24 22:38:50 2015 +0900
@@ -25,8 +25,7 @@
     return n;
 }
 
-static
-NodePtr createNode(unsigned char type,CharClassPtr cc, NodePtr left, NodePtr right) {
+NodePtr createNode(RegexInfoPtr ri,unsigned char type,CharClassPtr cc, NodePtr left, NodePtr right) {
     NodePtr n = allocateNode();
     n->tokenType = type;
     n->cc = cc;
diff -r 3e8aae8beba9 -r ef798db705e9 regexParser/regexParser.h
--- a/regexParser/regexParser.h	Thu Dec 24 20:37:29 2015 +0900
+++ b/regexParser/regexParser.h	Thu Dec 24 22:38:50 2015 +0900
@@ -7,43 +7,6 @@
     unsigned long bitContainer;
 }BitVector,*BitVectorPtr;
 
-typedef struct stateStack {
-    BitVector state;
-    struct stateStack *next;
-} StateStack, *StateStackPtr;
-
-typedef struct transitionGenerator {
-    long stateMax;
-    StateStack stack;
-    StatePtr state;
-    StatePtr stateArray;
-    StatePtr currentState;
-} TransitionGenerator, *TransitionGeneratorPtr;
-
-typedef struct tgValue {
-    bool asterisk;
-    int stateBegin;
-    int stateEnd;
-    TransitionGeneratorPtr tg;
-} TGValue, *TGValuePtr;
-
-enum charClassStackState {
-    LEFT,
-    SELF,
-    RIGHT
-};
-
-typedef struct charClassStack {
-    charClassStackState turn;
-    CharClassPtr cc;
-    struct charClassStack *next;
-} CharClassStack, *CharClassStackPtr;
-
-typedef struct charClassWalker {
-    CharClassStackPtr stack;
-    CharClassPtr next;
-} CharClassWalker, *CharClassWalkerPtr;
-
 typedef struct word {
     unsigned char *word;
     int length;
@@ -70,21 +33,59 @@
 
 typedef struct node {
     unsigned char tokenType;
-    unsigned long nodeNumber;
     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;
 } Node, *NodePtr;
 
-typedef struct state {
-    BitVector bitState;
+typedef struct stateStack {
+    BitVector state;
+    struct stateStack *next;
+} StateStack, *StateStackPtr;
+
+typedef struct transitionGenerator {
+    long stateMax;
+    StateStackPtr stack;
+    node::StatePtr state;
+    node::StatePtr stateArray;
+    node::StatePtr currentState;
+} TransitionGenerator, *TransitionGeneratorPtr;
+
+typedef struct tgValue {
+    bool asterisk;
+    int stateNum;
+    int stateBegin;
+    int stateEnd;
+    node::StatePtr tgState;
+    TransitionGeneratorPtr tg;
+} TGValue, *TGValuePtr;
+
+enum charClassStackState {
+    LEFT,
+    SELF,
+    RIGHT
+};
+
+typedef struct charClassStack {
+    charClassStackState turn;
     CharClassPtr cc;
-    NodePtr node;
-    struct state *next;
-} State, *StatePtr;
+    struct charClassStack *next;
+} CharClassStack, *CharClassStackPtr;
+
+typedef struct charClassWalker {
+    CharClassStackPtr stack;
+    CharClassPtr next;
+} CharClassWalker, *CharClassWalkerPtr;
+
 
 typedef struct regexInfo {
     unsigned char *ptr;
@@ -93,4 +94,5 @@
     int stateNumber;
 } RegexInfo, *RegexInfoPtr;
 
+NodePtr createNode(RegexInfoPtr ri,unsigned char type,CharClassPtr cc, NodePtr left, NodePtr right);
 CharClassPtr createCharClassRange(unsigned long begin, unsigned long end, CharClassPtr left, CharClassPtr right);
diff -r 3e8aae8beba9 -r ef798db705e9 regexParser/subsetConstraction.cc
--- a/regexParser/subsetConstraction.cc	Thu Dec 24 20:37:29 2015 +0900
+++ b/regexParser/subsetConstraction.cc	Thu Dec 24 22:38:50 2015 +0900
@@ -186,7 +186,7 @@
     }
 }
 
-CharClassPtr mergeTransition(StatePtr x,CharClassPtr y) {
+CharClassPtr mergeTransition(node::StatePtr x,CharClassPtr y) {
     if (x->cc == NULL) {
         return y;
     }
@@ -208,14 +208,15 @@
     bitvector を index とした配列に BitVectorPtr を格納
     state に対応する NodePtr を
  */
-TGValue createState(TGValue tg,NodePtr n) {
-    StatePtr s = NEW(State);
+node::StatePtr createState(TGValue tg,NodePtr n) {
+    node::StatePtr s = NEW(node::State);
     s->next = tg.tg->currentState;
     tg.tg->currentState = s;
     s->node = n;
-    BitVector bi = createBitVector(tg.stateBegin);
+    BitVector bi = createBitVector(n->stateNum);
     s->bitState = bi;
     s->cc = NULL;
+    return s;
 }
 
 /**
@@ -273,11 +274,11 @@
             tgRight.asterisk = true;
             return tgRight;
         }
-        StatePtr left = tg.state;
-        tg.state = n->left->state;
-        tg.tg.stateArray[tg.state->bitState.bitContainer] = tg.state;
+        node::StatePtr left = tg.tgState;
+        tg.tgState = n->left->state;
+        // tg.tg->stateArray[tg.tgState->bitState.bitContainer] = tg.tgState;
         TGValue tgLeft = generateTransition(n->left,tg);
-        tg.state = left;
+        tg.tgState = left;
         TGValue tgv1 = generateTransition(n->right,tgLeft);
         return tgv1;
     } else if (n->tokenType == '|') {
@@ -285,7 +286,7 @@
         TGValue tgv1 = generateTransition(n->right,tgv);
         return tgv1;
     } else if (n->tokenType == '*') {
-        tgAstah = generateTransition(n->left,tgAstah);
+        TGValue tgAstah = generateTransition(n->left,tg);
         tgAstah.asterisk = true;
         return tgAstah;
     } else if (n->tokenType == 'c' || n->tokenType == 'a'){
@@ -293,43 +294,36 @@
         tgv.asterisk = false;
         BitVector bi = createBitVector(n->nextStateNum);
         setState(n->cc,bi);
-        tgv.state->cc = mergeTransition(tgv.state,n->cc);
+        tgv.tgState->cc = mergeTransition(tgv.tgState,n->cc);
         return tgv;
     } else {
         return tg;
     }
 }
 
-void printTransitionList(TransitionPtr ts) {
-    for (;ts;ts = ts->next) {
-        printf("\n");
-    }
-}
-
 TransitionGeneratorPtr createTransitionGenerator() {
     TransitionGeneratorPtr tg = NEW(TransitionGenerator);
     tg->stateMax = 0;
     tg->stack = NULL;
-    tg->state = NEW(State);
+    tg->state = NEW(node::State);
     tg->stateArray = NULL;
     tg->currentState = NULL;
     return tg;
 }
 
-TransitionGenerator generateTransitionList(NodePtr n) {
+TransitionGeneratorPtr generateTransitionList(NodePtr n) {
     TransitionGeneratorPtr tg = createTransitionGenerator();
     TGValue tgv;
     tgv.asterisk = false;
     tgv.tg = tg;
-    StatePtr start = createState(tgv,n);
+    node::StatePtr start = createState(tgv,n);
     NodePtr eof = createNode(NULL,'e',NULL,NULL,NULL);
-    StatePtr end = createState(tgv,eof);
+    node::StatePtr end = createState(tgv,eof);
     tgv.stateBegin = 0;
     tgv.stateEnd = 1;
     stateAllocate(n,tgv);
-    tgv.tg->stateMax = tg.stateNum;
-    tgv.tg.stateArray = (StatePtr)calloc(tg.stateNum,sizeof(StatePtr));
+    tgv.tg->stateMax = tg->stateMax;
+    tgv.tg->stateArray = (node::StatePtr)calloc(tg->stateMax,sizeof(node::StatePtr));
     generateTransition(n,tgv);
-    printTransitionList(tg.ts);
     return tg;
 }
diff -r 3e8aae8beba9 -r ef798db705e9 regexParser/transition.cc
--- a/regexParser/transition.cc	Thu Dec 24 20:37:29 2015 +0900
+++ b/regexParser/transition.cc	Thu Dec 24 22:38:50 2015 +0900
@@ -1,13 +1,13 @@
 #include <stdlib.h>
 #include "transition.h"
 
-StatePtr searchState(StatePtr stateArray, StatePtr state) {
+node::StatePtr searchState(node::StatePtr stateArray, node::StatePtr state) {
     while(stateArray) {
         if (stateArray->bitState.bitContainer == state->bitState.bitContainer) {
             return stateArray;
         }
         if (stateArray->next == NULL) {
-            StatePtr s = createState(state->bitState);
+            node::StatePtr s = createState(state->bitState);
             stateArray = appendState(stateArray,s);
             return stateArray;
         }
@@ -16,17 +16,16 @@
     return stateArray;
 }
 
-StatePtr createState(BitVector bi) {
-    StatePtr state = NEW(State);
+node::StatePtr createState(BitVector bi) {
+    node::StatePtr state = NEW(node::State);
     state->bitState = bi;
-    state->transition = NEW(Transition);
-    state->nextNode = NEW(Node);
+    state->node = NEW(Node);
     return state;
 }
 
-StatePtr appendState(StatePtr x,StatePtr y) {
-    StatePtr x0 = createState(x->bitState);
-    StatePtr x1 = x0;
+node::StatePtr appendState(node::StatePtr x,node::StatePtr y) {
+    node::StatePtr x0 = createState(x->bitState);
+    node::StatePtr x1 = x0;
     for(;;) {
         if (x->next == NULL) {
             x1->next = y;
diff -r 3e8aae8beba9 -r ef798db705e9 regexParser/transition.h
--- a/regexParser/transition.h	Thu Dec 24 20:37:29 2015 +0900
+++ b/regexParser/transition.h	Thu Dec 24 22:38:50 2015 +0900
@@ -1,7 +1,6 @@
 #include "bitVector.h"
-
-StatePtr createState(BitVector bi);
-StatePtr appendState(StatePtr x,StatePtr y);
+node::StatePtr createState(BitVector bi);
+node::StatePtr appendState(node::StatePtr x,node::StatePtr y);
 /*
   正規表現木を辿って transition のList をつくる
   CharClass のかさなりを判定して重なりのない新しいCharClassをつくる