--- a/c/regexParser/regexParser.cc	Tue Dec 01 00:09:09 2015 +0900
+++ b/c/regexParser/regexParser.cc	Tue Dec 01 21:11:27 2015 +0900
@@ -23,63 +23,73 @@
 static
 NodePtr allocateNode() {
     NodePtr n = (NodePtr)malloc(sizeof(node));
-    n->cc = (CharClassPtr)malloc(sizeof(CharClass));
-    n->cc->cond = (ConditionList)malloc(sizeof(Condition));
+    n->cc = NULL;
+    n->left = NULL;
+    n->right = NULL;
     return n;
 }
 
 static
-NodePtr createNode(RegexInfoPtr ri,unsigned char *character, NodePtr left, NodePtr right) {
+CharClassPtr createChaClassWord(RegexInfoPtr ri) {
+    CharClassPtr cc = NEW(CharClass);
+    cc->type = 'a';
+    cc->cond = NEW(Condition);
+    cc->cond->w = NEW(Word);
+    cc->cond->w->word = ri->tokenValue;
+    cc->cond->w->length = ri->ptr - ri->tokenValue;
+}
+
+static
+NodePtr createNode(RegexInfoPtr ri,unsigned char type, NodePtr left, NodePtr right) {
     NodePtr n = allocateNode();
-    if (n == NULL) {
-        mallocFailedMessage();
-    }
 
-    n->tokenType = ri->tokenType;
+    n->tokenType = type;
     n->left = left;
     n->right = right;
     n->nodeNumber = ri->nodeNumber;
     ri->nodeNumber++;
 
-    if (ri->tokenType == 'a') {
-        ri->tokenType = 0;
-        n->cc->cond->w = getWord(ri->tokenValue);
-    } else {
-        WordPtr w = (WordPtr)malloc(sizeof(Word));
-        w->word = character;
-        w->length = 1;
-        n->cc->cond->w = w;
+    if (type == 'a') {
+        n->cc = createCharClassWord(ri);
     }
+
     return n;
 }
 
+
 // <charClass> ::= '['<literal>'-'<literal>']'
 static
 NodePtr charClass(RegexInfoPtr ri) {
     NodePtr n = allocateNode();
-    if (n == NULL) {
-        mallocFailedMessage();
-    }
 
-    n->tokenType = ri->tokenType;
+    n->tokenType = 'c';
     n->nodeNumber = ri->nodeNumber;
     ri->nodeNumber++;
-    n->cc->cond->w = (WordPtr)malloc(sizeof(Word));
+
+    CharClassPtr cc = NEW(CharClass);
+    cc->cond = NEW(Condition);
+    cc->cond->type = 'r';
+    cc->cond->rangeList = NEW(struct utf8Range);
+    cc->cond->rangeList->begin = ri->ptr;
+    cc->cond->rangeList->end = ri->ptr + 1;
+    cc->cond->rangeList->next = NULL;
 
     int i = 0;
 
+    struct utf8Range *rangeList= cc->cond->rangeList;
+  
     while (ri->ptr[i] != ']') {
-        if (ri->ptr[i] == '-') {
-            n->cc->begin = ri->ptr[i-1];
-            n->cc->end = ri->ptr[i+1];
-        }
+        if (ri->ptr[i] == '-') i++;
+
+        rangeList->end = ri->ptr + i;
+        rangeList->next = NEW(struct utf8Range);
+        rangeList = rangeList->next;
+        rangeList->begin = ri->ptr+i+1;
+        rangeList->next = NULL;
         i++;
     }
 
-    n->cc->cond->w->word = (unsigned char*)malloc(sizeof(unsigned char)*(i+1));
-    strncpy((char*)n->cc->cond->w->word, (char*)ri->ptr,i+1);
-    n->cc->cond->w->word[i] = '\0';
-    ri->ptr += i+1;
+    rangeList->end = ri->ptr[i-1];
 
     return n;
 }
@@ -165,27 +175,21 @@
     return n;
 }
 
-// <regex> ::= <regexAtom> | <regexAtom><regex>'*' | <regexAtom>'*' | <regexAtom>'|'<regex> | <regexAtom><regex> | '(' regex ')'
+// <regex> ::= <regexAtom> | <regexAtom>'*' | <regexAtom>'|'<regex> | <regexAtom><regex> | '(' regex ')'
 NodePtr regex(RegexInfoPtr ri) {
     NodePtr n = regexAtom(ri);
     while (ri->ptr[0]) {
         token(ri);
         if (ri->tokenType == '*') {
-            unsigned char *syntax = (unsigned char*)malloc(sizeof(unsigned char));
-            syntax[0] = '*';
-            n = createNode(ri,syntax,n,0);
+            n = createNode(ri,'*',n,0);
         } else if (ri->tokenType == '|') {
             NodePtr n1 = regex(ri);
-            unsigned char *syntax = (unsigned char*)malloc(sizeof(unsigned char));
-            syntax[0] = '|';
-            n = createNode(ri,syntax,n,n1);
+            n = createNode(ri,'|',n,n1);
         } else if (ri->tokenType == ')') {
             return n;
         } else {
             NodePtr n1 = regex(ri);
-            unsigned char *syntax = (unsigned char*)malloc(sizeof(unsigned char));
-            syntax[0] = '+';
-            n = createNode(ri,syntax,n,n1);
+            n = createNode(ri,'a',n,n1);
         }
     } return n;
 }