
        // make a environment variable
        // Ķѿ
        case kExport: {
            int i;
            BOOL chomp = TRUE;
            BOOL print = FALSE;
            BOOL line_field = FALSE;
            enum eLineField lf = gLineField;
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv,i));
                // when binding, bind the no chomp data
                // ХɤȤԤ줿ǡХɤ
                if(strcmp(arg, "-nc") == 0) {
                    chomp = FALSE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // take a STDIN pipe
                // ɸϤ
                else if(strcmp(arg, "-I") == 0) {
                    input = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // when output the variant content, add LF at tail
                // ϤȤԤä
                else if(strcmp(arg, "-L") == 0) {
                    line_field = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // When binding, output the pipe data too
                // ХɤȤ˽Ϥ⤹
                else if(strcmp(arg, "-p") == 0) {
                    print = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as CRLF
                // ԥɤCRLFȤư
                else if(strcmp(arg, "-Lw") == 0) {
                    lf = kCRLF;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as CR
                // ԥɤCRȤư
                else if(strcmp(arg, "-Lm") == 0) {
                    lf = kCR;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as LF
                // ԥɤLFȤư
                else if(strcmp(arg, "-Lu") == 0) {
                    lf = kLF;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as Bel
                // ԥɤBelȤư
                else if(strcmp(arg, "-La") == 0) {
                    lf = kBel;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            /// 
            if(input) {
                int k;
                for(k=1; k<vector_size(argv); k++) {
                    char* item = string_c_str(vector_item(argv, k));

                    string_obj* str = STRING_NEW("");
                    int result = statment_tree_internal_commands_read_nextin_oneline(nextin, str, lf);
                    if(result == 1) {
                        string_delete(str);
                        setenv(item, "", 1);
                        *rcode = 1;
                        continue;
                    }
                    else if(result == -1) {
                        err_msg("interrupt", sname, sline);
                        string_delete(str);
                        return FALSE;
                    }

                    if(chomp) string_chomp2(str, lf);

                    setenv(item, string_c_str(str), 1);
                    *rcode = 0;

                    if(print) {
                        if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(str)))
                        {
                            string_delete(str);
                            err_msg("signal interrupt", sname, sline);
                            return FALSE;
                        }
                        string_delete(str);
                        if(chomp) {
                            if(!statment_tree_internal_commands_write_lf(nextout,  lf))
                            {
                                err_msg("singal interrupt", sname, sline);
                                return FALSE;
                            }
                        }
                    }
                    else {
                        string_delete(str);
                    }
                }
            }

            /// 
            else {
                for(i=1; i<vector_size(argv); i++) {
                    char* name = string_c_str(vector_item(argv, i));

                    char* var = getenv(name);
                    if(var) {
                        if(!statment_tree_internal_commands_write_nextout(nextout, var))
                        {
                            err_msg("signal interrupt", sname, sline);
                            return FALSE;
                        }
                        if(line_field || i != vector_size(argv) -1) {
                            if(!statment_tree_internal_commands_write_lf(nextout,  lf))
                            {
                                err_msg("singal interrupt", sname, sline);
                                return FALSE;
                            }
                        }
                        *rcode = 0;
                    }
                }
            }
            }
            break;

        // make an array
        // 
        case kAry: {
            int i;
            BOOL chomp = TRUE;
            BOOL print = FALSE;
            BOOL size = FALSE;
            BOOL global = FALSE;
            BOOL local = FALSE;
            BOOL mem = FALSE;
            BOOL new_ = FALSE;
            BOOL line_field = FALSE;
            enum eLineField lf = gLineField;
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv, i));
                // output the size 
                // Ϥ
                if(strcmp(arg, "-size") == 0) 
                {
                    size = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // when binding, bind the no chomp data
                // ХɤȤԤ줿ǡХɤ
                else if(strcmp(arg, "-nc") == 0) 
                {
                    chomp = FALSE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // Although in class context, access global name space
                // 饹ƥȤǤ⥰Х֤̾Υ֥Ȥ˥
                else if(strcmp(arg, "-g") == 0) 
                {
                    global = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat as local variant
                // ѿȤư
                else if(strcmp(arg, "-l") == 0) 
                {
                    local = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // when output the variant content, add LF at tail
                // ϤȤԤä
                else if(strcmp(arg, "-L") == 0) 
                {
                    line_field = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // take a STDIN pipe
                // ɸϤ
                else if(strcmp(arg, "-I") == 0) 
                {
                    input = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // When binding, output the pipe data too
                // ХɤȤ˽Ϥ⤹
                else if(strcmp(arg, "-p") == 0) 
                {
                    print = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as CRLF
                // ԥɤCRLFȤư
                else if(strcmp(arg, "-Lw") == 0) {
                    lf = kCRLF;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as CR
                // ԥɤCRȤư
                else if(strcmp(arg, "-Lm") == 0) {
                    lf = kCR;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as LF
                // ԥɤLFȤư
                else if(strcmp(arg, "-Lu") == 0) {
                    lf = kLF;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as Bel
                // ԥɤBelȤư
                else if(strcmp(arg, "-La") == 0) {
                    lf = kBel;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // output adress of this object
                // ɥ쥹
                else if(strcmp(arg, "-mem") == 0) {
                    mem = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // create a new object and output the address
                // ֥Ȥƥɥ쥹
                else if(strcmp(arg, "-new") == 0) {
                    new_ = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            /// -mem
            if(mem) {
                int i;
                for(i=1; i<vector_size(argv); i++) {
                    char* name = string_c_str(vector_item(argv, i));

                    sAry* array = saphire_get_array(name, runinfo->object, global, local);
                    
                    if(array) {
                        char buf[1024];
#if defined(__SUNOS__)
                        snprintf(buf, 1024, "%#x\n", array);
#else
                        snprintf(buf, 1024, "%p\n", array);
#endif
                        if(!statment_tree_internal_commands_write_nextout(nextout, buf))
                        {
                            err_msg("signal interrupt", sname, sline);
                            return FALSE;
                        }
                        *rcode = 0;
                    }
                }
            }

            /// -size
            else if(size) {
                int i;
                for(i=1; i<vector_size(argv); i++) {
                    char* name = string_c_str(vector_item(argv, i));
                    sAry* ary = saphire_get_array(name, runinfo->object, global, local);

                    if(ary) {
                        char buf[1024];
                        snprintf(buf, 1024, "%d", vector_size(ary));
                        if(!statment_tree_internal_commands_write_nextout(nextout,  buf))
                        {
                            err_msg("signal interrupt", sname, sline);
                            return FALSE;
                        }
                        if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                        {
                            err_msg("singal interrupt", sname, sline);
                            return FALSE;
                        }

                        *rcode = 0;
                    }
                }
            }

            /// -new
            else if(new_) {
                if(input) {
                    sAry* array = sAry_new(50, 0);

                    while(1) {
                        string_obj* line = STRING_NEW("");
                        int ret = statment_tree_internal_commands_read_nextin_oneline(nextin, line, lf);
                        if(ret == -1) {
                            err_msg("interrupt", sname, sline);
                            string_delete(line);
                            return FALSE;
                        }
                        else if(ret == 1) {
                            string_delete(line);
                            break;
                        }
                        if(chomp) string_chomp2(line, lf);

                        saphire_push_back_array_element(array, line);
                    }

                    char buf[1024];
#if defined(__SUNOS__)
                    snprintf(buf, 1024, "%#x\n", array);
#else
                    snprintf(buf, 1024, "%p\n", array);
#endif
                    if(!statment_tree_internal_commands_write_nextout(nextout, buf))
                    {
                        err_msg("signal interrupt", sname, sline);
                        return FALSE;
                    }
                    *rcode = 0;
                }
                else {
                    sAry* array = sAry_new(50, 0);

                    char buf[1024];
#if defined(__SUNOS__)
                    snprintf(buf, 1024, "%#x\n", array);
#else
                    snprintf(buf, 1024, "%p\n", array);
#endif
                    if(!statment_tree_internal_commands_write_nextout(nextout, buf))
                    {
                        err_msg("signal interrupt", sname, sline);
                        return FALSE;
                    }
                    *rcode = 0;
                }
            }

            /// 
            else if(input) {
                if(vector_size(argv) != 2) {
                    err_msg("require one argument", sname, sline);

                    return FALSE;
                }

                char* key = string_c_str(vector_item(argv, 1));

                sAry* v = saphire_get_array(key, runinfo->object, global, local);
                if(v) {
                    saphire_clear_array_element(v);
                }
                else {
                    if(strlen(key) > 1 && key[0] == '`') {
                        err_msg("invalid refference", sname, sline);
                        return FALSE;
                    }
                    else if(strlen(key) > 2 && key[0] == '0' && key[1] =='x') {
                        err_msg("invalid refference", sname, sline);
                        return FALSE;
                    }
                    else if(local) {
                        hash_obj* top_stack
                             = vector_item(gStackFrameArrays, vector_size(gStackFrameArrays)-1);
                        v = sAry_new(50, 1);
                        hash_put(top_stack, key, v);
                    }
                    else if(runinfo->object && !global) {
                        v = sAry_new(50,1 );
                        hash_put(runinfo->object->mArrays, key, v);
                    } else {
                        v = sAry_new(50, 1);
                        hash_put(gArrays, key, v);
                    }
                }

                if(v) {
                    while(1) {
                        string_obj* line = STRING_NEW("");
                        int ret = statment_tree_internal_commands_read_nextin_oneline(nextin, line, lf);
                        if(ret == -1) {
                            err_msg("interrupt", sname, sline);
                            string_delete(line);
                            return FALSE;
                        }
                        else if(ret == 1) {
                            string_delete(line);
                            break;
                        }
                        if(chomp) string_chomp2(line, lf);

                        saphire_push_back_array_element(v, line);

                        if(print) {
                            if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(line)))
                            {
                                err_msg("signal interrupt", sname, sline);
                                return FALSE;
                            }
                            if(!statment_tree_internal_commands_write_lf(nextout,  lf))
                            {
                                err_msg("singal interrupt", sname, sline);
                                return FALSE;
                            }
                        }
                    }
                
                    *rcode = 0;
                }
            }

            /// 
            else {
                if(vector_size(argv) == 2) {
                    char* name = string_c_str(vector_item(argv, 1));
                    sAry* array = saphire_get_array(name, runinfo->object, global, local);
                    
                    if(array) {
                        int k;
                        for(k=0; k<vector_size(array); k++) {
                            string_obj* str = vector_item(array, k);

                            if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(str)))
                            {
                                err_msg("signal interrupt", sname, sline);
                                return FALSE;
                            }
                            if(!statment_tree_internal_commands_write_lf(nextout,  lf))
                            {
                                err_msg("singal interrupt", sname, sline);
                                return FALSE;
                            }
                        }

                        *rcode = 0;
                    }
                }
                else if(vector_size(argv) >= 3) {
                    char* name = string_c_str(vector_item(argv, 1));

                    sAry* array = saphire_get_array(name, runinfo->object, global, local);

                    if(array) {
                        for(i=2; i<vector_size(argv); i++) {
                            int index = atoi(string_c_str(vector_item(argv, i)));
                            if(index < 0) {
                                index += vector_size(array);
                            }
                            if(index >= 0 && index < vector_size(array)) 
                            {
                                string_obj* str = vector_item(array, index);
                                if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(str)))
                                {
                                    err_msg("signal interrupt", sname, sline);
                                    return FALSE;
                                }

                                if(line_field || i != vector_size(argv) -1) {
                                    if(!statment_tree_internal_commands_write_lf(nextout,  lf))
                                    {
                                        err_msg("singal interrupt", sname, sline);
                                        return FALSE;
                                    }
                                }
                                *rcode = 0;
                            }
                        }
                    }
                }
                else {
                    err_msg("invalid argument number on ary", sname, sline);
                    return FALSE;
                }
            }
            }
            break;

        // add text lines to an array
        // ˥ƥȤɲä
        case kAryAdd: {
            int i;
            BOOL flg_n = FALSE;
            BOOL chomp = TRUE;
            BOOL print = FALSE;
            BOOL line_field = FALSE;
            BOOL local = FALSE;
            BOOL global = FALSE;
            enum eLineField lf = gLineField;
            int n;
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv, i));
                // inset pipe data into N line
                // Nܤ˥ǡ
                if(strcmp(arg, "-n") == 0 
                        && i+1 < vector_size(argv)) 
                {
                    flg_n = TRUE;
                    n = atoi(string_c_str(vector_item(argv, i+1)));
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // Although in class context, access global name space
                // 饹ƥȤǤ⥰Х֤̾Υ֥Ȥ˥
                else if(strcmp(arg, "-g") == 0) 
                {
                    global = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat as local variant
                // ѿȤư
                else if(strcmp(arg, "-l") == 0) 
                {
                    local = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // when binding, bind the no chomp data
                // ХɤȤԤ줿ǡХɤ
                else if(strcmp(arg, "-nc") == 0) 
                {
                    chomp = FALSE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // take a STDIN pipe
                // ɸϤ
                else if(strcmp(arg, "-I") == 0) {
                    input = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // when output the variant content, add LF at tail
                // ϤȤԤä
                else if(strcmp(arg, "-L") == 0) {
                    line_field = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // When binding, output the pipe data too
                // ХɤȤ˽Ϥ⤹
                else if(strcmp(arg, "-p") == 0) {
                    print = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as CRLF
                // ԥɤCRLFȤư
                else if(strcmp(arg, "-Lw") == 0) {
                    lf = kCRLF;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as CR
                // ԥɤCRȤư
                else if(strcmp(arg, "-Lm") == 0) {
                    lf = kCR;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as LF
                // ԥɤLFȤư
                else if(strcmp(arg, "-Lu") == 0) {
                    lf = kLF;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as Bel
                // ԥɤBelȤư
                else if(strcmp(arg, "-La") == 0) {
                    lf = kBel;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            /// 
            if(input) {
                /// ɸϤ顢
                if(vector_size(argv) != 2) {
                    err_msg("ary_add: invalid option number", sname, sline);
                    return FALSE;
                }

                char* key = string_c_str(vector_item(argv, 1));

                sAry* v = saphire_get_array(key, runinfo->object, global, local);
                if(v == NULL) {
                    if(strlen(key) > 1 && key[0] == '`') {
                        err_msg("invalid refference", sname, sline);
                        return FALSE;
                    }
                    else if(strlen(key) > 2 && key[0] == '0' && key[1] =='x') {
                        err_msg("invalid refference", sname, sline);
                        return FALSE;
                    }
                    else if(local) {
                        hash_obj* top_stack
                             = vector_item(gStackFrameArrays, vector_size(gStackFrameArrays)-1);
                        v = sAry_new(50, 1);
                        hash_put(top_stack, key, v);
                    }
                    else if(runinfo->object && !global) {
                        v = sAry_new(50,1 );
                        hash_put(runinfo->object->mArrays, key, v);
                    } else {
                        v = sAry_new(50, 1);
                        hash_put(gArrays, key, v);
                    }
                }

                int i=0;
                while(1) {
                    string_obj* line = STRING_NEW("");
                    int ret = statment_tree_internal_commands_read_nextin_oneline(nextin, line, lf);

                    if(ret == -1) {
                        err_msg("intterrupt", sname, sline);
                        string_delete(line);
                        return FALSE;
                    }
                    else if(ret == 1) {      // EOF
                        string_delete(line);
                        break;
                    }

                    if(chomp) string_chomp2(line, lf);

                    if(flg_n) {
                        if(n < 0) {
                            n = n + vector_size(v) + 1;
                        }

                        if(n < 0 || n+i > vector_size(v)) {
                            *rcode = 1;
                            string_delete(line);
                            return TRUE;
                        }

                        if(n+i < vector_size(v)) {
                            saphire_insert_array_element(v, n+1, line);
                        }
                        else {
                            saphire_push_back_array_element(v, line);
                        }
                    }
                    else {
                        saphire_push_back_array_element(v, line);
                    }

                    if(print) {
                        if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(line)))
                        {
                            err_msg("signal interrupt", sname, sline);
                            return FALSE;
                        }

                        if(!statment_tree_internal_commands_write_lf(nextout,  lf))
                        {
                            err_msg("singal interrupt", sname, sline);
                            return FALSE;
                        }
                    }
                    
                    *rcode = 0;
                    i++;
                }
            }

            }
            break;

        // erase an array element
        // Ǥ
        case kAryErase: {
            int i;
            BOOL global = FALSE;
            BOOL local = FALSE;
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv, i));
                // Although in class context, access global name space
                // 饹ƥȤǤ⥰Х֤̾Υ֥Ȥ˥
                if(strcmp(arg, "-g") == 0) 
                {
                    global = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat as local variant
                // ѿȤư
                else if(strcmp(arg, "-l") == 0) 
                {
                    local = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            if(vector_size(argv) == 3) {
                char* key = string_c_str(vector_item(argv, 1));
                char* number = string_c_str(vector_item(argv, 2));
                int n = atoi(number);

                sAry* v = saphire_get_array(key, runinfo->object, global, local);

                if(v) {
                    if(n < 0) {
                        n+=vector_size(v);
                    }

                    if(n >= 0 && n < vector_size(v)) {
                        saphire_erase_array_element(v, n);
                        *rcode = 0;
                    }
                }
            }
            }
            break;

        // make a hash
        // ϥå
        case kHash: {
            BOOL chomp = TRUE;
            BOOL global = FALSE;
            BOOL local = FALSE;
            BOOL print = FALSE;
            BOOL new_ = FALSE;
            BOOL line_field = FALSE;
            BOOL mem = FALSE;
            enum eLineField lf = gLineField;
            int i;
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv, i));
                // when binding, bind the no chomp data
                // ХɤȤԤ줿ǡХɤ
                if(strcmp(arg, "-nc") == 0) 
                {
                    chomp = FALSE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // when output the variant content, add LF at tail
                // ϤȤԤä
                else if(strcmp(arg, "-L") == 0) 
                {
                    line_field = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // take a STDIN pipe
                // ɸϤ
                else if(strcmp(arg, "-I") == 0) {
                    input = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat as local variant
                // ѿȤư
                else if(strcmp(arg, "-l") == 0) {
                    local = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // When binding, output the pipe data too
                // ХɤȤ˽Ϥ⤹
                else if(strcmp(arg, "-p") == 0) {
                    print = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // Although in class context, access global name space
                // 饹ƥȤǤ⥰Х֤̾Υ֥Ȥ˥
                else if(strcmp(arg, "-g") == 0) {
                    global = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as CRLF
                // ԥɤCRLFȤư
                else if(strcmp(arg, "-Lw") == 0) {
                    lf = kCRLF;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as CR
                // ԥɤCRȤư
                else if(strcmp(arg, "-Lm") == 0) {
                    lf = kCR;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as LF
                // ԥɤLFȤư
                else if(strcmp(arg, "-Lu") == 0) {
                    lf = kLF;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as Bel
                // ԥɤBelȤư
                else if(strcmp(arg, "-La") == 0) {
                    lf = kBel;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // output adress of this object
                // ɥ쥹
                else if(strcmp(arg, "-mem") == 0) {
                    mem = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // create a new object and output the address
                // ֥Ȥƥɥ쥹
                else if(strcmp(arg, "-new") == 0) {
                    new_ = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            /// -mem
            if(mem) {
                int i;
                for(i=1; i<vector_size(argv); i++) {
                    char* name = string_c_str(vector_item(argv, i));

                    sHash* hash = saphire_get_hash(name, runinfo->object, global, local);
                    
                    if(hash) {
                        char buf[1024];
#if defined(__SUNOS__)
                        snprintf(buf, 1024, "%#x\n", hash);
#else
                        snprintf(buf, 1024, "%p\n", hash);
#endif
                        if(!statment_tree_internal_commands_write_nextout(nextout, buf))
                        {
                            err_msg("signal interrupt", sname, sline);
                            return FALSE;
                        }
                        *rcode = 0;
                    }
                }
            }
            /// -new
            else if(new_) {
                sHash* hash = sHash_new(50, 0);

                if(input) {
                    BOOL key = TRUE;
                    string_obj* key_str = STRING_NEW("");

                    while(1) {
                        if(gKitutukiSigInt) {
                            err_msg("intterrupt", sname, sline);
                            string_delete(key_str);
                            sHash_delete(hash);
                            return FALSE;
                        }
                        string_obj* line = STRING_NEW("");
                        int ret = statment_tree_internal_commands_read_nextin_oneline(nextin, line, lf);

                        if(ret == -1) {
                            err_msg("intterrupt", sname, sline);
                            string_delete(key_str);
                            string_delete(line);
                            sHash_delete(hash);
                            return FALSE;
                        }
                        else if(ret == 1) {      // EOF
                            string_delete(line);
                            break;
                        }

                        if(chomp || key) string_chomp2(line, lf);

                        if(key) {
                            string_put(key_str, string_c_str(line));
                            string_delete(line);
                        }
                        else {
                            saphire_put_hash_item(hash, string_c_str(key_str), line);
                        }

                        key = !key;
                    }

                    string_delete(key_str);
                }

                char buf[1024];
#if defined(__SUNOS__)
                snprintf(buf, 1024, "%#x\n", hash);
#else
                snprintf(buf, 1024, "%p\n", hash);
#endif
                if(!statment_tree_internal_commands_write_nextout(nextout, buf))
                {
                    err_msg("signal interrupt", sname, sline);
                    return FALSE;
                }
                *rcode = 0;
            }
            /// 
            else if(input) {
                if(vector_size(argv) != 2) {
                    err_msg("invalid argument on hash",sname,sline);
                    return FALSE;
                }

                char* name = string_c_str(vector_item(argv, 1));

                sHash* hash = saphire_get_hash(name, runinfo->object, global, local);
                if(hash) {
                    saphire_clear_hash_element(hash);
                }
                else {
                    if(strlen(name) > 1 && name[0] == '`') {
                        err_msg("invalid refference", sname, sline);
                        return FALSE;
                    }
                    else if(strlen(name) > 2 && name[0] == '0' && name[1] =='x') {
                        err_msg("invalid refference", sname, sline);
                        return FALSE;
                    }
                    else if(local) {
                        hash_obj* top_stack
                             = vector_item(gStackFrameHashs, vector_size(gStackFrameHashs)-1);
                        hash = sHash_new(50, 1);
                        hash_put(top_stack, name, hash);
                    }
                    else if(runinfo->object && !global) {
                        hash = sHash_new(50,1 );
                        hash_put(runinfo->object->mHashs, name, hash);
                    } else {
                        hash = sHash_new(50, 1);
                        hash_put(gHashs, name, hash);
                    }
                }

                BOOL key = TRUE;
                string_obj* key_str = STRING_NEW("");

                while(1) {
                    if(gKitutukiSigInt) {
                        err_msg("intterrupt", sname, sline);
                        string_delete(key_str);
                        return FALSE;
                    }
                    string_obj* line = STRING_NEW("");
                    int ret = statment_tree_internal_commands_read_nextin_oneline(nextin, line, lf);

                    if(ret == -1) {
                        err_msg("intterrupt", sname, sline);
                        string_delete(key_str);
                        string_delete(line);
                        return FALSE;
                    }
                    else if(ret == 1) {      // EOF
                        string_delete(line);
                        break;
                    }

                    if(chomp || key) string_chomp2(line, lf);

                    if(key) {
                        string_put(key_str, string_c_str(line));
                        string_delete(line);
                    }
                    else {
                        saphire_put_hash_item(hash, string_c_str(key_str), line);
                    }

                    key = !key;
                }

                string_delete(key_str);

                if(print) {
                    hash_it* it = hash_loop_begin((hash_obj*)hash);
                    while(it != NULL) {
                        string_obj* str = hash_loop_item(it);
                        char* key = hash_loop_key(it);

                        if(!statment_tree_internal_commands_write_nextout(nextout, key))
                        {
                            err_msg("signal interrupt", sname, sline);
                            return FALSE;
                        }
                        if(!statment_tree_internal_commands_write_lf(nextout,  lf))
                        {
                            err_msg("singal interrupt", sname, sline);
                            return FALSE;
                        }

                        if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(str)))
                        {
                            err_msg("signal interrupt", sname, sline);
                            return FALSE;
                        }
                        if(!statment_tree_internal_commands_write_lf(nextout,  lf))
                        {
                            err_msg("singal interrupt", sname, sline);
                            return FALSE;
                        }

                        it = hash_loop_next(it);
                    }
                }

                *rcode = 0;
            }
            /// 
            else {
                if(vector_size(argv) == 2) {
                    char* name = string_c_str(vector_item(argv, 1));
                    sHash* hash = saphire_get_hash(name, runinfo->object, global, local);

                    if(hash) {
                        hash_it* it = hash_loop_begin((hash_obj*)hash);
                        int k = 0;
                        while(it != NULL) {
                            string_obj* str = hash_loop_item(it);
                            char* key = hash_loop_key(it);

                            if(!statment_tree_internal_commands_write_nextout(nextout, key))
                            {
                                err_msg("signal interrupt", sname, sline);
                                return FALSE;
                            }
                            if(!statment_tree_internal_commands_write_lf(nextout,  lf))
                            {
                                err_msg("singal interrupt", sname, sline);
                                return FALSE;
                            }

                            if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(str)))
                            {
                                err_msg("signal interrupt", sname, sline);
                                return FALSE;
                            }
                            if(!statment_tree_internal_commands_write_lf(nextout,  lf))
                            {
                                err_msg("singal interrupt", sname, sline);
                                return FALSE;
                            }

                            it = hash_loop_next(it);
                            k++;
                        }
                        *rcode = 0;
                    }
                }
                else if(vector_size(argv) >= 3) {
                    char* name = string_c_str(vector_item(argv, 1));
                    sHash* hash = saphire_get_hash(name, runinfo->object, global, local);
                    if(hash) {
                        int i;
                        for(i=2; i<vector_size(argv); i++) {
                            char* index = string_c_str(vector_item(argv, i));
                            string_obj* str = saphire_get_hash_item(hash, index);

                            if(str) {
                                if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(str)))
                                {
                                    err_msg("signal interrupt", sname, sline);
                                    return FALSE;
                                }

                                if(line_field || i != vector_size(argv) -1) {
                                    if(!statment_tree_internal_commands_write_lf(nextout,  lf))
                                    {
                                        err_msg("singal interrupt", sname, sline);
                                        return FALSE;
                                    }
                                }
                                *rcode = 0;
                            }
                        }
                    }
                }
            }
            }
            break;

        // add text lines to a hash
        // ϥå˥ƥȤɲä
        case kHashAdd: {
            BOOL chomp = TRUE;
            BOOL global = FALSE;
            BOOL local = FALSE;
            BOOL print = FALSE;
            enum eLineField lf = gLineField;
            int i;
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv, i));
                // when binding, bind the no chomp data
                // ХɤȤԤ줿ǡХɤ
                if(strcmp(arg, "-nc") == 0) 
                {
                    chomp = FALSE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // take a STDIN pipe
                // ɸϤ
                else if(strcmp(arg, "-I") == 0) {
                    input = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // When binding, output the pipe data too
                // ХɤȤ˽Ϥ⤹
                else if(strcmp(arg, "-p") == 0) {
                    print = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // Although in class context, access global name space
                // 饹ƥȤǤ⥰Х֤̾Υ֥Ȥ˥
                else if(strcmp(arg, "-g") == 0) {
                    global = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat as local variant
                // ѿȤư
                else if(strcmp(arg, "-l") == 0) {
                    local = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as CR
                // ԥɤCRȤư
                else if(strcmp(arg, "-Lm") == 0) {
                    lf = kCR;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as LF
                // ԥɤLFȤư
                else if(strcmp(arg, "-Lu") == 0) {
                    lf = kLF;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as Bel
                // ԥɤBelȤư
                else if(strcmp(arg, "-La") == 0) {
                    lf = kBel;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as CRLF
                // ԥɤCRLFȤư
                else if(strcmp(arg, "-Lw") == 0) {
                    lf = kCRLF;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            if(input && vector_size(argv) == 2) {
                char* name = string_c_str(vector_item(argv, 1));
                sHash* hash = saphire_get_hash(name, runinfo->object, global, local);
                if(hash == NULL) {
                    if(strlen(name) > 1 && name[0] == '`') {
                        err_msg("invalid refference", sname, sline);
                        return FALSE;
                    }
                    else if(strlen(name) > 2 && name[0] == '0' && name[1] =='x') {
                        err_msg("invalid refference", sname, sline);
                        return FALSE;
                    }
                    else if(local) {
                        hash_obj* top_stack
                             = vector_item(gStackFrameHashs, vector_size(gStackFrameHashs)-1);
                        hash = sHash_new(100, 1);
                        hash_put(top_stack, name, hash);
                    }
                    else if(runinfo->object && !global) {
                        hash = sHash_new(100, 1);
                        hash_put(runinfo->object->mHashs, name , hash);
                    }
                    else {
                        hash = sHash_new(100, 1);
                        hash_put(gHashs, name, hash);
                    }
                }

                BOOL key = TRUE;
                string_obj* key_str = STRING_NEW("");
                vector_obj* v = VECTOR_NEW(10);

                while(1) {
                    if(gKitutukiSigInt) {
                        err_msg("innterrupt", sname, sline);
                        string_delete(key_str);
                        int i;
                        for(i=0; i<vector_size(v) ;i++) {
                            string_delete(vector_item(v, i));
                        }
                        vector_delete(v);
                        return FALSE;
                    }
                    string_obj* line = STRING_NEW("");
                    int ret = statment_tree_internal_commands_read_nextin_oneline(nextin, line, lf);

                    if(ret == -1) {
                        err_msg("intterrupt", sname, sline);
                        string_delete(key_str);
                        string_delete(line);
                        int i;
                        for(i=0; i<vector_size(v) ;i++) {
                            string_delete(vector_item(v, i));
                        }
                        vector_delete(v);
                        return FALSE;
                    }
                    else if(ret == 1) {      // EOF
                        string_delete(line);
                        break;
                    }

                    if(chomp || key) string_chomp2(line, lf);

                    if(key) {
                        string_put(key_str, string_c_str(line));
                        string_delete(line);
                    }
                    else {
                        vector_add(v, STRING_NEW(string_c_str(key_str)));
                        vector_add(v, STRING_NEW(string_c_str(line)));

                        saphire_put_hash_item(hash, string_c_str(key_str), line);
                        *rcode = 0;
                    }

                    key = !key;
                }

                string_delete(key_str);

                if(print) {
                    int i;
                    for(i=0; i<vector_size(v); i++) {
                        string_obj* str = vector_item(v, i);

                        if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(str)))
                        {
                            err_msg("signal interrupt", sname, sline);
                            int i;
                            for(i=0; i<vector_size(v) ;i++) {
                                string_delete(vector_item(v, i));
                            }
                            vector_delete(v);
                            return FALSE;
                        }
                        if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                        {
                            err_msg("singal interrupt", sname, sline);
                            int i;
                            for(i=0; i<vector_size(v) ;i++) {
                                string_delete(vector_item(v, i));
                            }
                            vector_delete(v);
                            return FALSE;
                        }
                    }
                }

                int i;
                for(i=0; i<vector_size(v) ;i++) {
                    string_delete(vector_item(v, i));
                }
                vector_delete(v);
            }
            }
            break;

        // erase hash elements
        // ϥåǤ
        case kHashErase: {
            BOOL global = FALSE;
            BOOL local = FALSE;
            int i;
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv, i));
                // Although in class context, access global name space
                // 饹ƥȤǤ⥰Х֤̾Υ֥Ȥ˥
                if(strcmp(arg, "-g") == 0) {
                    global = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat as local variant
                // ѿȤư
                else if(strcmp(arg, "-l") == 0) {
                    local = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            if(vector_size(argv) == 3) {
                char* var_name = string_c_str(vector_item(argv, 1));
                char* key = string_c_str(vector_item(argv, 2));

                sHash* hash = saphire_get_hash(var_name, runinfo->object, global, local);

                if(hash) {
                    saphire_erase_hash_element(hash, key);
                    *rcode = 0;
                }
            }
            }
            break;

        // define a function
        // ؿ
        case kDef: {
            BOOL print = FALSE;
            char* arg_name = NULL;
            enum eLineField lf = gLineField;
            BOOL global = FALSE;
            BOOL print_arg_name = FALSE;
            BOOL mem = FALSE;
            BOOL override = FALSE;
            BOOL new_ = FALSE;

            int l;
            for(l=0; l<vector_size(argv); l++) {
                char* arg = string_c_str(vector_item(argv, l));

                // When binding, output the pipe data too
                // ХɤȤ˽Ϥ⤹
                if(strcmp(arg, "-p") == 0) {
                    print = TRUE;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // output the argument
                // Ϥ
                else if(strcmp(arg, "-A") == 0) {
                    print_arg_name = TRUE;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // Although in class context, access global name space
                // 饹ƥȤǤ⥰Х֤̾Υ֥Ȥ˥
                else if(strcmp(arg, "-g") == 0) {
                    global = TRUE;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // set on argument
                // ꤹ
                else if(strcmp(arg, "-a") == 0 && l+1 < vector_size(argv)) {
                    arg_name = STRDUP(string_c_str((vector_item(argv, l+1))));
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // take a STDIN pipe
                // ɸϤ
                else if(strcmp(arg, "-I") == 0) {
                    input = TRUE;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // treat line field as CRLF
                // ԥɤCRLFȤư
                else if(strcmp(arg, "-Lw") == 0) {
                    lf = kCRLF;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // treat line field as CR
                // ԥɤCRȤư
                else if(strcmp(arg, "-Lm") == 0) {
                    lf = kCR;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // treat line field as LF
                // ԥɤLFȤư
                else if(strcmp(arg, "-Lu") == 0) {
                    lf = kLF;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // treat line field as Bel
                // ԥɤBelȤư
                else if(strcmp(arg, "-La") == 0) {
                    lf = kBel;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // output adress of this object
                // ɥ쥹
                else if(strcmp(arg, "-mem") == 0) {
                    mem = TRUE;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // disipate to inherit
                // inheritػߤ
                else if(strcmp(arg, "-override") == 0) {
                    override = TRUE;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // create a new object and output the address
                // ֥Ȥƥɥ쥹
                else if(strcmp(arg, "-new") == 0) {
                    new_ = TRUE;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
            }

            /// -new
            if(new_) {
                if(vector_size(blocks) >= 1) {
                    sBlock* block = vector_item(blocks, 0);
                    sStatments* statments = block->mStatments;

                    sFunction* fun = sFunction_new("refference", statments, arg_name, NULL, 0);

                    char buf[1024];
#if defined(__SUNOS__)
                    snprintf(buf, 1024, "%#x\n", fun);
#else
                    snprintf(buf, 1024, "%p\n", fun);
#endif
                    if(!statment_tree_internal_commands_write_nextout(nextout, buf))
                    {
                        err_msg("signal interrupt", sname, sline);
                        if(arg_name) FREE(arg_name);
                        return FALSE;
                    }
                    *rcode = 0;
                }
                else {
                    if(input) {
                        string_obj* str = STRING_NEW("");
                        int ret = statment_tree_internal_commands_read_nextin(nextin, str) ;
                        if(ret == 1) {
                            string_delete(str);
                            *rcode = 1;
                            break;
                        }
                        else if(ret < 0)
                        {
                            *rcode = 2;
                            err_msg("interrupt", sname, sline);
                            string_delete(str);
                            if(arg_name) FREE(arg_name);
                            return FALSE;
                        }
                        
                        sStatments* statments = STATMENTS_NEW();
                        int sline2 = 1;
                        if(!parse(string_c_str(str), "def", &sline2, statments)) 
                        {
                            string_delete(str);
                            sStatments_delete(statments);
                            if(arg_name) FREE(arg_name);
                            return FALSE;
                        }

                        string_delete(str);

                        sFunction* fun = sFunction_new("refference", statments, arg_name, NULL, 0);

                        char buf[1024];
#if defined(__SUNOS__)
                        snprintf(buf, 1024, "%#x\n", fun);
#else
                        snprintf(buf, 1024, "%p\n", fun);
#endif
                        if(!statment_tree_internal_commands_write_nextout(nextout, buf))
                        {
                            err_msg("signal interrupt", sname, sline);
                            if(arg_name) FREE(arg_name);
                            sStatments_delete(statments);
                            return FALSE;
                        }

                        sStatments_delete(statments);

                        *rcode = 0;
                    }
                    else {
                        sStatments* statments = STATMENTS_NEW();
                        sFunction* fun = sFunction_new("refference", statments, arg_name, NULL,0);

                        char buf[1024];
#if defined(__SUNOS__)
                        snprintf(buf, 1024, "%#x\n", fun);
#else
                        snprintf(buf, 1024, "%p\n", fun);
#endif
                        if(!statment_tree_internal_commands_write_nextout(nextout, buf))
                        {
                            err_msg("signal interrupt", sname, sline);
                            if(arg_name) FREE(arg_name);
                            sStatments_delete(statments);
                            return FALSE;
                        }
                        *rcode = 0;

                        sStatments_delete(statments);
                    }
                }
            }
            /// -mem
            else if(mem) {
                int i;
                for(i=1; i<vector_size(argv); i++) {
                    char* name = string_c_str(vector_item(argv, i));
                    sFunction* fun = saphire_get_fun(name, runinfo->object, global);

                    if(fun) {
                        char buf[1024];
#if defined(__SUNOS__)
                        snprintf(buf, 1024, "%#x\n", fun);
#else
                        snprintf(buf, 1024, "%p\n", fun);
#endif
                        if(!statment_tree_internal_commands_write_nextout(nextout, buf))
                        {
                            err_msg("signal interrupt", sname, sline);
                            if(arg_name) FREE(arg_name);
                            return FALSE;
                        }
                        *rcode = 0;
                    }
                }
            }
            /// -A
            else if(print_arg_name) {
                int i;
                for(i=1; i<vector_size(argv); i++) {
                    char* name = string_c_str(vector_item(argv, i));

                    if(input) {
                        string_obj* arg_name2 = STRING_NEW("");
                        int result = statment_tree_internal_commands_read_nextin(nextin, arg_name2);
                        if(result == 1) {
                            string_delete(arg_name2);
                            *rcode = 1;
                            break;
                        }
                        else if(result == -1) {
                            *rcode = 2;
                            err_msg("interrupt", sname, sline);
                            if(arg_name) FREE(arg_name);
                            string_delete(arg_name2);
                            return FALSE;
                        }

                        if(runinfo->object && !global) {
                            sFunction* fun = hash_item(runinfo->object->mMethods, name);
                            if(fun == NULL) {
                                err_msg("not exist function", sname, sline);
                                if(arg_name) FREE(arg_name);
                                string_delete(arg_name2);
                                return FALSE;
                            }
                            string_put(fun->arg_name, string_c_str(arg_name2));

                            if(print) { 
                                if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(fun->arg_name))) 
                                {
                                    err_msg("signal interrupt", sname, sline);
                                    if(arg_name) FREE(arg_name);
                                    string_delete(arg_name2);
                                    return FALSE;
                                }
                            }
                        }
                        else {
                            sFunction* fun = hash_item(gFuncs, name);
                            if(fun == NULL) {
                                err_msg("not exist function", sname, sline);
                                if(arg_name) FREE(arg_name);
                                string_delete(arg_name2);
                                return FALSE;
                            }
                            string_put(fun->arg_name, string_c_str(arg_name2));
                            if(print) { 
                                if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(fun->arg_name))) 
                                {
                                    err_msg("signal interrupt", sname, sline);
                                    if(arg_name) FREE(arg_name);
                                    string_delete(arg_name2);
                                    return FALSE;
                                }
                            }
                        }

                        string_delete(arg_name2);
                    }
                    else {
                        sFunction* fun = saphire_get_fun(name, runinfo->object, global);

                        if(fun) {
                            if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(fun->arg_name))) 
                            {
                                err_msg("signal interrupt", sname, sline);
                                if(arg_name) FREE(arg_name);
                                return FALSE;
                            }
                            if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                            {
                                err_msg("singal interrupt", sname, sline);
                                if(arg_name) FREE(arg_name);
                                return FALSE;
                            }
                        }
                    }

                    *rcode = 0;
                }
            }
            else {
                int i;
                for(i=1; i<vector_size(argv); i++) {
                    char* name = string_c_str(vector_item(argv, i));
                    sFunction* fun = saphire_get_fun(name, runinfo->object, global);

                    if(vector_size(blocks) >= 1) {
                        sBlock* block = vector_item(blocks, 0);
                        sStatments* statments = block->mStatments;


                        if(strlen(name) > 1 && name[0] == '`' || strlen(name) > 2 && name[0] == '0' && name[1] == 'x')
                        {
                            if(override) {
                                if(fun) {
                                    if(fun->statments) sStatments_delete(fun->statments);
                                    fun->statments = STATMENTS_NEW2(statments);
                                    *rcode = 0;
                                }
                                else {
                                    err_msg("not exist function", sname, sline);
                                    if(arg_name) FREE(arg_name);
                                    return FALSE;
                                }
                            }
                            else {
                                err_msg("require -override option on input def of refference", sname, sline);
                                if(arg_name) FREE(arg_name);
                                return FALSE;
                            }
                        }
                        else if(runinfo->object && !global) {
                            if(override) {
                                if(fun) {
                                    if(fun->statments) sStatments_delete(fun->statments);
                                    fun->statments = STATMENTS_NEW2(statments);
                                    *rcode = 0;
                                }
                                else {
                                    err_msg("not exist function", sname, sline);
                                    if(arg_name) FREE(arg_name);
                                    return FALSE;
                                }
                            }
                            else {
                                sFunction* new_fun = sFunction_new(name, statments, arg_name, fun, 1);

                                hash_put(runinfo->object->mMethods, name, new_fun);
                                *rcode =0;
                            }
                        }
                        else {
                            if(override) {
                                if(fun) {
                                    if(fun->statments) sStatments_delete(fun->statments);
                                    fun->statments = STATMENTS_NEW2(statments);
                                    *rcode = 0;
                                }
                                else {
                                    err_msg("not exist function", sname, sline);
                                    if(arg_name) FREE(arg_name);
                                    return FALSE;
                                }
                            }
                            else {
                                sFunction* new_fun = sFunction_new(name, statments, arg_name, fun, 1);
                                hash_put(gFuncs, name, new_fun);
                                *rcode = 0;
                            }
                        }
                    }
                    else {
                        if(input) {
                            string_obj* str = STRING_NEW("");
                            int ret = statment_tree_internal_commands_read_nextin(nextin, str) ;
                            if(ret == 1) {
                                string_delete(str);
                                *rcode = 1;
                                break;
                            }
                            else if(ret < 0)
                            {
                                *rcode = 2;
                                err_msg("interrupt", sname, sline);
                                string_delete(str);
                                if(arg_name) FREE(arg_name);
                                return FALSE;
                            }
                            
                            sStatments* statments = STATMENTS_NEW();
                            int sline2 = 1;
                            if(!parse(string_c_str(str), "def", &sline2, statments)) 
                            {
                                sStatments_delete(statments);
                                string_delete(str);
                                if(arg_name) FREE(arg_name);
                                return FALSE;
                            }

                            if(strlen(name) > 1 && name[0] == '`' || strlen(name) > 2 && name[0] == '0' && name[1] == 'x')
                            {
                                if(override) {
                                    if(fun) {
                                        if(fun->statments) sStatments_delete(fun->statments);
                                        fun->statments = STATMENTS_NEW2(statments);
                                    }
                                    else {
                                        err_msg("invalid refference", sname, sline);
                                        if(arg_name) FREE(arg_name);
                                        string_delete(str);
                                        sStatments_delete(statments);
                                        return FALSE;
                                    }
                                }
                                else {
                                    err_msg("require -override option on input def of refference", sname, sline);
                                    if(arg_name) FREE(arg_name);
                                    string_delete(str);
                                    sStatments_delete(statments);
                                    return FALSE;
                                }

                                *rcode = 0;
                            }
                            else if(runinfo->object && !global) {
                                if(override) {
                                    if(fun) {
                                        if(fun->statments) sStatments_delete(fun->statments);
                                        fun->statments = STATMENTS_NEW2(statments);
                                    }
                                    else {
                                        err_msg("not exist function", sname, sline);
                                        if(arg_name) FREE(arg_name);
                                        string_delete(str);
                                        sStatments_delete(statments);
                                        return FALSE;
                                    }
                                }
                                else {
                                    sFunction* new_fun = sFunction_new(name, statments, arg_name, fun, 1);

                                    hash_put(runinfo->object->mMethods, name, new_fun);
                                }
                            }
                            else {
                                if(override) {
                                    if(fun) {
                                        if(fun->statments) sStatments_delete(fun->statments);
                                        fun->statments = STATMENTS_NEW2(statments);
                                    }
                                    else {
                                        err_msg("not exist function", sname, sline);
                                        if(arg_name) FREE(arg_name);
                                        string_delete(str);
                                        sStatments_delete(statments);
                                        return FALSE;
                                    }
                                }
                                else {
                                    sFunction* new_fun = sFunction_new(name, statments, arg_name, fun, 1);

                                    hash_put(gFuncs, name, new_fun);
                                }
                            }

                            if(print) { 
                                if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(str))) 
                                {
                                    err_msg("signal interrupt", sname, sline);
                                    string_delete(str);
                                    if(arg_name) FREE(arg_name);
                                    sStatments_delete(statments);
                                    return FALSE;
                                }
                            }

                            *rcode = 0;

                            string_delete(str);
                            sStatments_delete(statments);
                        }
                        else {
                            if(strlen(name) > 1 && name[0] == '`' || strlen(name) > 2 && name[0] == '0' && name[1] == 'x')
                            {
                                if(fun) {
                                    if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(fun->statments->mSource))) 
                                    {
                                        err_msg("signal interrupt", sname, sline);
                                        if(arg_name) FREE(arg_name);
                                        return FALSE;
                                    }
                                    *rcode = 0;
                                }
                                else {
                                    err_msg("invalid refference", sname, sline);
                                    if(arg_name) FREE(arg_name);
                                    return FALSE;
                                }
                            }
                            else if(runinfo->object && !global) {
                                if(fun) {
                                    if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(fun->statments->mSource))) 
                                    {
                                        err_msg("signal interrupt", sname, sline);
                                        if(arg_name) FREE(arg_name);
                                        return FALSE;
                                    }
                                    *rcode = 0;
                                }
                            }
                            else {
                                if(fun) {
                                    if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(fun->statments->mSource))) 
                                    {
                                        err_msg("signal interrupt", sname, sline);
                                        if(arg_name) FREE(arg_name);
                                        return FALSE;
                                    }
                                    *rcode = 0;
                                }
                            }
                        }
                    }
                }
            }

            if(arg_name) FREE(arg_name);

            }
            break;

        // define a class
        // 饹
        case kClass: {
            BOOL print = FALSE;
            BOOL global = FALSE;
            BOOL mem = FALSE;
            BOOL override = FALSE;
            BOOL new_ = FALSE;

            int l;
            for(l=0; l<vector_size(argv); l++) {
                char* arg = string_c_str(vector_item(argv, l));

                // When binding, output the pipe data too
                // ХɤȤ˽Ϥ⤹
                if(strcmp(arg, "-p") == 0) {
                    print = TRUE;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // Although in class context, access global name space
                // 饹ƥȤǤ⥰Х֤̾Υ֥Ȥ˥
                else if(strcmp(arg, "-g") == 0) {
                    global = TRUE;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // take a STDIN pipe
                // ɸϤ
                else if(strcmp(arg, "-I") == 0) {
                    input = TRUE;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // output adress of this object
                // ɥ쥹
                else if(strcmp(arg, "-mem") == 0) {
                    mem = TRUE;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // disipate to inherit
                // inheritػߤ
                else if(strcmp(arg, "-override") == 0) {
                    override = TRUE;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // create a new object and output the address
                // ֥Ȥƥɥ쥹
                else if(strcmp(arg, "-new") == 0) {
                    new_ = TRUE;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
            }

            if(new_) {
                if(vector_size(blocks) >= 1) {
                    sBlock* block = vector_item(blocks, 0);
                    sStatments* statments = block->mStatments;

                    sClass* klass = sClass_new("refference", statments, NULL, 0);

                    char buf[1024];
#if defined(__SUNOS__)
                    snprintf(buf, 1024, "%#x\n", klass);
#else
                    snprintf(buf, 1024, "%p\n", klass);
#endif
                    if(!statment_tree_internal_commands_write_nextout(nextout, buf))
                    {
                        err_msg("signal interrupt", sname, sline);
                        return FALSE;
                    }
                    *rcode = 0;
                }
                else {
                    if(input) {
                        string_obj* str = STRING_NEW("");
                        int ret = statment_tree_internal_commands_read_nextin(nextin, str) ;
                        if(ret == 1) {
                            string_delete(str);
                            *rcode = 1;
                            break;
                        }
                        else if(ret < 0)
                        {
                            *rcode = 2;
                            string_delete(str);
                            err_msg("interrupt", sname, sline);
                            return FALSE;
                        }
                        
                        sStatments* statments = STATMENTS_NEW();
                        int sline2 = 1;
                        if(!parse(string_c_str(str), "def", &sline2, statments)) 
                        {
                            sStatments_delete(statments);
                            string_delete(str);
                            return FALSE;
                        }

                        string_delete(str);

                        sClass* klass = sClass_new("refference", statments, NULL, 0);

                        char buf[1024];
#if defined(__SUNOS__)
                        snprintf(buf, 1024, "%#x\n", klass);
#else
                        snprintf(buf, 1024, "%p\n", klass);
#endif
                        if(!statment_tree_internal_commands_write_nextout(nextout, buf))
                        {
                            err_msg("signal interrupt", sname, sline);
                            sStatments_delete(statments);
                            return FALSE;
                        }

                        *rcode = 0;

                        sStatments_delete(statments);
                    }
                    else {
                        sClass* klass = sClass_new("refference", NULL, NULL, 0);

                        char buf[1024];
#if defined(__SUNOS__)
                        snprintf(buf, 1024, "%#x\n", klass);
#else
                        snprintf(buf, 1024, "%p\n", klass);
#endif
                        if(!statment_tree_internal_commands_write_nextout(nextout, buf))
                        {
                            err_msg("signal interrupt", sname, sline);
                            return FALSE;
                        }
                        *rcode = 0;
                    }
                }
            }
            else if(mem) {
                int i;
                for(i=1; i<vector_size(argv); i++) {
                    char* name = string_c_str(vector_item(argv, i));
                    sClass* klass = saphire_get_class(name, runinfo->object, global);
                    if(klass) {
                        char buf[1024];
#if defined(__SUNOS__)
                        snprintf(buf, 1024, "%#x\n", klass);
#else
                        snprintf(buf, 1024, "%p\n", klass);
#endif
                        if(!statment_tree_internal_commands_write_nextout(nextout, buf))
                        {
                            err_msg("signal interrupt", sname, sline);
                            return FALSE;
                        }
                        *rcode = 0;
                    }
                }
            }
            else if(vector_size(argv) >= 2) {
                char* name = string_c_str(vector_item(argv, 1));

                if(vector_size(blocks) == 0) {
                    if(input) {
                        string_obj* str = STRING_NEW("");
                        int ret = statment_tree_internal_commands_read_nextin(nextin, str) ;
                        if(ret == 1) {
                            string_delete(str);
                            *rcode = 1;
                            break;
                        }
                        else if(ret < 0)
                        {
                            *rcode = 2;
                            string_delete(str);
                            err_msg("interrupt", sname, sline);
                            return FALSE;
                        }
                        
                        sStatments* statments = STATMENTS_NEW();
                        int sline2 = 1;
                        if(!parse(string_c_str(str), "class", &sline2, statments)) 
                        {
                            sStatments_delete(statments);
                            string_delete(str);
                            return FALSE;
                        }

                        sClass* klass = saphire_get_class(name, runinfo->object, global);

                        if(klass) {
                            if(override) {
                                if(klass->statments) sStatments_delete(klass->statments);
                                klass->statments = STATMENTS_NEW2(statments);
                            }
                            else {
                                if(strlen(name) > 1 && name[0] == '`' || strlen(name) > 2 && name[0] == '0' && name[1] == 'x')
                                {
                                    err_msg("need -override option on the refference of a class", sname, sline);
                                    return FALSE;
                                }
                                else if(runinfo->object && !global) {
                                    klass = sClass_new(name, statments, klass, 1);

                                    hash_put(runinfo->object->mClasses, name, klass);
                                }
                                else {
                                    klass = sClass_new(name, statments, klass, 1);

                                    hash_put(gClasses, name, klass);
                                }
                            }
                        }
                        else {
                            if(strlen(name) > 1 && name[0] == '`' || strlen(name) > 2 && name[0] == '0' && name[1] == 'x')
                            {
                                err_msg("need class name", sname, sline);
                                return FALSE;
                            }
                            else if(runinfo->object && !global) {
                                klass = sClass_new(name, statments, NULL, 1);

                                hash_put(runinfo->object->mClasses, name, klass);
                            }
                            else {
                                klass = sClass_new(name, statments, NULL, 1);

                                hash_put(gClasses, name, klass);
                            }
                        }

                        *rcode = 0;

                        if(print) { 
                            if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(str))) 
                            {
                                err_msg("signal interrupt", sname, sline);
                                string_delete(str);
                                sStatments_delete(statments);
                                return FALSE;
                            }
                        }

                        string_delete(str);

                        sStatments_delete(statments);
                    }
                    else {
                        sClass* klass = saphire_get_class(name, runinfo->object, global);

                        if(klass) {
                            if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(klass->statments->mSource))) 
                            {
                                err_msg("signal interrupt", sname, sline);
                                return FALSE;
                            }
                            *rcode = 0;
                        }
                    }
                }
                else {
                    sBlock* block = vector_item(blocks, 0);
                    sStatments* statments = block->mStatments;

                    sClass* klass = saphire_get_class(name, runinfo->object, global);

                    if(klass) {
                        if(override) {
                            if(klass->statments) sStatments_delete(klass->statments);
                            klass->statments = STATMENTS_NEW2(statments);
                        }
                        else {
                            if(strlen(name) > 1 && name[0] == '`' || strlen(name) > 2 && name[0] == '0' && name[1] == 'x')
                            {
                                err_msg("need -override option on the refference of a class", sname, sline);
                                return FALSE;
                            }
                            else if(runinfo->object && !global) {
                                sClass* new_klass = sClass_new(name, statments, klass, 1);

                                hash_put(runinfo->object->mClasses, name, new_klass);
                            }
                            else {
                                sClass* new_klass = sClass_new(name, statments, klass, 1);

                                hash_put(gClasses, name, new_klass);
                            }
                        }

                        *rcode = 0;
                    }
                    else {
                        if(strlen(name) > 1 && name[0] == '`' || strlen(name) > 2 && name[0] == '0' && name[1] == 'x')
                        {
                            err_msg("need class name", sname, sline);
                            return FALSE;
                        }
                        else if(runinfo->object && !global) {
                            sClass* new_klass = sClass_new(name, statments, NULL, 1);

                            hash_put(runinfo->object->mClasses, name, new_klass);
                        }
                        else {
                            sClass* new_klass = sClass_new(name, statments, NULL, 1);

                            hash_put(gClasses, name, new_klass);
                        }
                    }

                    *rcode = 0;
                }
            }

            }
            break;

        case kSelf: {
            if(runinfo->object) {
                char buf[1024];
#if defined(__SUNOS__)
                snprintf(buf, 1024, "%#x\n", runinfo->object);
#else
                snprintf(buf, 1024, "%p\n", runinfo->object);
#endif
                if(!statment_tree_internal_commands_write_nextout(nextout, buf))
                {
                    err_msg("signal interrupt", sname, sline);
                    return FALSE;
                }
                *rcode = 0;
            }
            }
            break;

        case kInherit: {
            if(runinfo->running_fun) {
                char* arg0 = string_c_str(runinfo->running_fun->name);
                sInnerCommand* inner_fun = hash_item(gInnerCommands, arg0);

                if(runinfo->running_fun->parent) {
                    sFunction* fun = runinfo->running_fun->parent; 

                    /// ̾ꤵƤʤХåե졼䤹 ///
                    sAry* fun_argv_before;
                    sAry* fun_argv;
                    if(strcmp(string_c_str(fun->arg_name), "") == 0) {
                        // å򷡤
                        int k;
                        sAry* argv2 = sAry_new(30, 1);
                        for(k=1; k<vector_size(argv); k++) {
                            char* value = string_c_str(vector_item(argv, k));
                            saphire_push_back_array_element(argv2, STRING_NEW(value));
                        }
                        dig_stack_frame(sname, sline, &fun_argv_before, argv2);
                        fun_argv = NULL;
                    }
                    /// ̾ꤵƤʤХåե졼䤵ʤ
                    else {
                        /// ΰ¸ ///
                        fun_argv_before = hash_item(gArrays
                                                , string_c_str(fun->arg_name));

                        /// Ϥ ///
                        int k;
                        fun_argv = sAry_new(30, 1);
                        for(k=1; k<vector_size(argv); k++) {
                            char* value = string_c_str(vector_item(argv, k));
                            saphire_push_back_array_element(fun_argv, STRING_NEW(value));
                        }
                        
                        hash_put(gArrays, string_c_str(fun->arg_name), fun_argv);

                        /// åե졼εϿդ
                        vector_add(gStackTraceFName, STRING_NEW(sname));
                        vector_add(gStackTraceLineNum, (void*)sline);
                    }

                    /// ¹ ///
                    BOOL enable_return = runinfo->enable_return;
                    runinfo->enable_return = TRUE;
                    BOOL enable_break = runinfo->enable_break;
                    runinfo->enable_break = FALSE;
                    vector_obj* blocks2 = runinfo->parent_blocks;
                    runinfo->parent_blocks = blocks;
                    sFunction* fun2 = runinfo->running_fun;
                    runinfo->running_fun = fun;

                    *rcode = run(runinfo, fun->statments, title, nextout, nextin, nexterr, FALSE);
                    *runinfo->return_ = FALSE; // 桼ؿreturn
                    *runinfo->break_ = FALSE;

                    runinfo->enable_return = enable_return;
                    runinfo->enable_break = enable_break;
                    runinfo->parent_blocks = blocks2;
                    runinfo->running_fun = fun2;

                    string_obj* sname_strace;
                    int line_strace;
                    if(fun_argv == NULL) {
                        burry_stack_frame(fun_argv_before, &sname_strace, &line_strace);
                    }
                    else {
                        int k;
                        sAry_delete(fun_argv);
                        
                        if(fun_argv_before) {
                            hash_put(gArrays, string_c_str(fun->arg_name) , fun_argv_before);
                        }
                        else {
                            hash_erase(gArrays, string_c_str(fun->arg_name));
                        }

                        /// åե졼εϿä
                        sname_strace = vector_pop_back(gStackTraceFName);
                        line_strace = (int)vector_pop_back(gStackTraceLineNum);
                    }

                    if(*rcode < 0) {
                        string_push_back(gErrMsg, string_c_str(sname_strace));
                        string_delete(sname_strace);
                        char tmp[1024];
                        snprintf(tmp, 1024, ":%d\n", line_strace);
                        string_push_back(gErrMsg, tmp);
                        
                        return FALSE;
                    }
                    else {
                        string_delete(sname_strace);
                    }
                }
                else if(runinfo->object == NULL && (inner_fun || get_command_kind(arg0))) {
                    if(inner_fun) {
                        sAry* argv2 = sAry_new(30, 1);
                        int k;
                        saphire_push_back_array_element(argv2, STRING_NEW(arg0));
                        for(k=1; k<vector_size(argv); k++) {
                            char* value = string_c_str(vector_item(argv, k));
                            saphire_push_back_array_element(argv2, STRING_NEW(value));
                        }
                        sAry* fun_argv_before;
                        dig_stack_frame(sname, sline, &fun_argv_before, argv2);

                        BOOL r = inner_fun->mFun(rcode, (vector_obj*)argv2
                                    , blocks, runinfo->parent_blocks
                                    , nextout, nextin, nexterr
                                    , title, input, sname, sline);
                        *runinfo->return_ = FALSE; // 桼ؿreturn
                        *runinfo->break_ = FALSE;

                        // å
                        string_obj* sname_strace;
                        int line_strace;
                        burry_stack_frame(fun_argv_before, &sname_strace, &line_strace);

                        if(*rcode < 0) {
                            string_push_back(gErrMsg, string_c_str(sname_strace));
                            string_delete(sname_strace);
                            char tmp[1024];
                            snprintf(tmp, 1024, ":%d\n", line_strace);
                            string_push_back(gErrMsg, tmp);
                            
                            return FALSE;
                        }
                        else {
                            string_delete(sname_strace);
                        }
                    }
                    else {
                        command->mKind = get_command_kind(arg0);

                        if(command->mKind == kCommand) {
                            err_msg("can't inherit external command or can't find the parent.", sname, sline);
                            return FALSE;
                        }

                        /// Ϥ ///
                        int k;
                        sAry* argv2 = sAry_new(30, 1);
                        saphire_push_back_array_element(argv2, STRING_NEW(arg0));
                        for(k=1; k<vector_size(argv); k++) {
                            char* value = string_c_str(vector_item(argv, k));
                            saphire_push_back_array_element(argv2, STRING_NEW(value));
                        }
                        sAry* fun_argv_before;
                        dig_stack_frame(sname, sline, &fun_argv_before, argv2);

                        BOOL r = statment_tree_internal_commands(runinfo,
                              command, rcode
                            , (vector_obj*)argv2, blocks, nextout
                            , nextin, nexterr, j, title, input
                            , sname, sline);
                        *runinfo->return_ = FALSE; // 桼ؿreturn
                        *runinfo->break_ = FALSE;

                        // å
                        string_obj* sname_strace;
                        int line_strace;
                        burry_stack_frame(fun_argv_before, &sname_strace, &line_strace);

                        if(!r) {
                            string_push_back(gErrMsg, string_c_str(sname_strace));
                            string_delete(sname_strace);
                            char tmp[1024];
                            snprintf(tmp, 1024, ":%d\n", line_strace);
                            string_push_back(gErrMsg, tmp);

                            return FALSE;
                        }
                        else {
                            string_delete(sname_strace);
                        }
                    }
                }
                else {
                    err_msg("parent function do not exists", sname, sline);
                    return FALSE;
                }
            }
            else if(runinfo->running_class && runinfo->running_class->parent) {
                sClass* klass = runinfo->running_class->parent;

                /// Ϥ ///
                int k;
                sAry* argv2 = sAry_new(30, 1);
                for(k=1; k<vector_size(argv); k++) {
                    char* value = string_c_str(vector_item(argv, k));
                    saphire_push_back_array_element(argv2, STRING_NEW(value));
                }
                sAry* fun_argv_before;
                dig_stack_frame(sname, sline, &fun_argv_before, argv2);

                BOOL enable_return = runinfo->enable_return;
                runinfo->enable_return = TRUE;
                BOOL enable_break = runinfo->enable_break;
                runinfo->enable_break = FALSE;
                sFunction* fun = runinfo->running_fun;
                runinfo->running_fun = NULL;
                sClass* klass2 = runinfo->running_class;
                runinfo->running_class = klass;

                *rcode = run(runinfo, klass->statments, title, nextout, nextin, nexterr, FALSE);
                *runinfo->return_ = FALSE; // 桼ؿreturn
                *runinfo->break_ = FALSE;

                runinfo->enable_return = enable_return;
                runinfo->enable_break = enable_break;
                runinfo->running_fun = fun;
                runinfo->running_class = klass2;

                // å
                string_obj* sname_strace;
                int line_strace;
                burry_stack_frame(fun_argv_before, &sname_strace, &line_strace);

                if(*rcode < 0) {
                    string_push_back(gErrMsg, string_c_str(sname_strace));
                    string_delete(sname_strace);
                    char tmp[1024];
                    snprintf(tmp, 1024, ":%d\n", line_strace);
                    string_push_back(gErrMsg, tmp);

                    return FALSE;
                }
                else {
                    string_delete(sname_strace);
                }
            }
            else {
                err_msg("parent function or class do not exists", sname, sline);
                return FALSE;
            }
            }
            break;

        case kStackFrame: {
            *rcode = 0;
            int i;
            if(!statment_tree_internal_commands_write_nextout(nextout, "+++ Vars +++"))
            {
                err_msg("signal interrupt", sname, sline);
                return FALSE;
            }
            if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
            {
                err_msg("singal interrupt", sname, sline);
                return FALSE;
            }
            for(i=0; i<vector_size(gStackFrame); i++) {
                char buf[256];
                snprintf(buf, 256, "+++ %d +++", i);
                if(!statment_tree_internal_commands_write_nextout(nextout, buf))
                {
                    err_msg("signal interrupt", sname, sline);
                    return FALSE;
                }
                if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                {
                    err_msg("singal interrupt", sname, sline);
                    return FALSE;
                }
                hash_obj* hash = vector_item(gStackFrame, i);
                hash_it* it = hash_loop_begin(hash);
                while(it) {
                    char* key = hash_loop_key(it);
                    if(!statment_tree_internal_commands_write_nextout(nextout, key))
                    {
                        err_msg("signal interrupt", sname, sline);
                        return FALSE;
                    }
                    if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                    {
                        err_msg("singal interrupt", sname, sline);
                        return FALSE;
                    }

                    it = hash_loop_next(it);
                }
            }
            if(!statment_tree_internal_commands_write_nextout(nextout, "+++ Hashs +++"))
            {
                err_msg("signal interrupt", sname, sline);
                return FALSE;
            }
            if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
            {
                err_msg("singal interrupt", sname, sline);
                return FALSE;
            }
            for(i=0; i<vector_size(gStackFrameHashs); i++) {
                char buf[256];
                snprintf(buf, 256, "+++ %d +++", i);
                if(!statment_tree_internal_commands_write_nextout(nextout, buf))
                {
                    err_msg("signal interrupt", sname, sline);
                    return FALSE;
                }
                if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                {
                    err_msg("singal interrupt", sname, sline);
                    return FALSE;
                }
                hash_obj* hash = vector_item(gStackFrameHashs, i);
                hash_it* it = hash_loop_begin(hash);
                while(it) {
                    char* key = hash_loop_key(it);
                    if(!statment_tree_internal_commands_write_nextout(nextout, key))
                    {
                        err_msg("signal interrupt", sname, sline);
                        return FALSE;
                    }
                    if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                    {
                        err_msg("singal interrupt", sname, sline);
                        return FALSE;
                    }

                    it = hash_loop_next(it);
                }
            }
            if(!statment_tree_internal_commands_write_nextout(nextout, "+++ Arrays +++"))
            {
                err_msg("signal interrupt", sname, sline);
                return FALSE;
            }
            if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
            {
                err_msg("singal interrupt", sname, sline);
                return FALSE;
            }
            for(i=0; i<vector_size(gStackFrameArrays); i++) {
                char buf[256];
                snprintf(buf, 256, "+++ %d +++", i);
                if(!statment_tree_internal_commands_write_nextout(nextout, buf))
                {
                    err_msg("signal interrupt", sname, sline);
                    return FALSE;
                }
                if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                {
                    err_msg("singal interrupt", sname, sline);
                    return FALSE;
                }
                hash_obj* hash = vector_item(gStackFrameArrays, i);
                hash_it* it = hash_loop_begin(hash);
                while(it) {
                    char* key = hash_loop_key(it);
                    if(!statment_tree_internal_commands_write_nextout(nextout, key))
                    {
                        err_msg("signal interrupt", sname, sline);
                        return FALSE;
                    }
                    if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                    {
                        err_msg("singal interrupt", sname, sline);
                        return FALSE;
                    }

                    it = hash_loop_next(it);
                }
            }
            if(!statment_tree_internal_commands_write_nextout(nextout, "+++ Objects +++"))
            {
                err_msg("signal interrupt", sname, sline);
                return FALSE;
            }
            if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
            {
                err_msg("singal interrupt", sname, sline);
                return FALSE;
            }
            for(i=0; i<vector_size(gStackFrameObjects); i++) {
                char buf[256];
                snprintf(buf, 256, "+++ %d +++", i);
                if(!statment_tree_internal_commands_write_nextout(nextout, buf))
                {
                    err_msg("signal interrupt", sname, sline);
                    return FALSE;
                }
                if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                {
                    err_msg("singal interrupt", sname, sline);
                    return FALSE;
                }
                hash_obj* hash = vector_item(gStackFrameObjects, i);
                hash_it* it = hash_loop_begin(hash);
                while(it) {
                    char* key = hash_loop_key(it);
                    if(!statment_tree_internal_commands_write_nextout(nextout, key))
                    {
                        err_msg("signal interrupt", sname, sline);
                        return FALSE;
                    }
                    if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                    {
                        err_msg("singal interrupt", sname, sline);
                        return FALSE;
                    }

                    it = hash_loop_next(it);
                }
            }
            if(!statment_tree_internal_commands_write_nextout(nextout, "+++ Refs +++"))
            {
                err_msg("signal interrupt", sname, sline);
                return FALSE;
            }
            if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
            {
                err_msg("singal interrupt", sname, sline);
                return FALSE;
            }
            for(i=0; i<vector_size(gStackFrameRefs); i++) {
                char buf[256];
                snprintf(buf, 256, "+++ %d +++", i);
                if(!statment_tree_internal_commands_write_nextout(nextout, buf))
                {
                    err_msg("signal interrupt", sname, sline);
                    return FALSE;
                }
                if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                {
                    err_msg("singal interrupt", sname, sline);
                    return FALSE;
                }
                hash_obj* hash = vector_item(gStackFrameRefs, i);
                hash_it* it = hash_loop_begin(hash);
                while(it) {
                    char* key = hash_loop_key(it);
                    if(!statment_tree_internal_commands_write_nextout(nextout, key))
                    {
                        err_msg("signal interrupt", sname, sline);
                        return FALSE;
                    }
                    if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                    {
                        err_msg("singal interrupt", sname, sline);
                        return FALSE;
                    }

                    it = hash_loop_next(it);
                }
            }
            }
            break;

        case kShow: {
            int i;
            BOOL verbose = FALSE;
            BOOL global = FALSE;
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv,i));
                // vervose
                // ܤ
                if(strcmp(arg, "-v") == 0) {
                    verbose = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // Although in class context, access global name space
                // 饹ƥȤǤ⥰Х֤̾Υ֥Ȥ˥
                else if(strcmp(arg, "-g") == 0) {
                    global = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }
            if(!global && runinfo->object) {
                if(!statment_tree_internal_commands_write_nextout(nextout, "++++++ Object Attributes ++++++\n"))
                {
                    err_msg("interrupt", sname, sline);
                    return FALSE;
                }
            }
            else {
                if(!statment_tree_internal_commands_write_nextout(nextout, "++++++ Global Space Variables ++++++\n"))
                {
                    err_msg("interrupt", sname, sline);
                    return FALSE;
                }
            }

            if(!statment_tree_internal_commands_write_nextout(nextout, "+++ Globals +++\n"))
            {
                err_msg("interrupt", sname, sline);
                return FALSE;
            }

            hash_it* it;
            if(!global && runinfo->object) {
                it = hash_loop_begin(runinfo->object->mGlobals);
            }
            else {
                it = hash_loop_begin(gGlobals);
            }

            while(it != NULL) {
                if(!statment_tree_internal_commands_write_nextout(nextout,  hash_loop_key(it))) 
                {
                    err_msg("interrupt", sname, sline);
                    return FALSE;
                }
                if(verbose) {
                    if(!statment_tree_internal_commands_write_nextout(nextout,   ":")) 
                    {
                        err_msg("interrupt", sname, sline);
                        return FALSE;
                    }
                    if(!statment_tree_internal_commands_write_nextout(nextout,   string_c_str(hash_loop_item(it)))) 
                    {
                        err_msg("interrupt", sname, sline);
                        return FALSE;
                    }
                }
                if(!statment_tree_internal_commands_write_nextout(nextout,  "\n")) 
                {
                    err_msg("interrupt", sname, sline);
                    return FALSE;
                }

                it = hash_loop_next(it);
            }

            if(!statment_tree_internal_commands_write_nextout(nextout, "+++ Arrays +++\n"))
            {
                err_msg("interrupt", sname, sline);
                return FALSE;
            }

            if(!global && runinfo->object) {
                it = hash_loop_begin(runinfo->object->mArrays);
            }
            else {
                it = hash_loop_begin(gArrays);
            }

            while(it != NULL) {
                if(!statment_tree_internal_commands_write_nextout(nextout,  hash_loop_key(it))) 
                {
                    err_msg("interrupt", sname, sline);
                    return FALSE;
                }
                if(!statment_tree_internal_commands_write_nextout(nextout,  "\n")) 
                {
                    err_msg("interrupt", sname, sline);
                    return FALSE;
                }

                it = hash_loop_next(it);
            }

            if(!statment_tree_internal_commands_write_nextout(nextout, "+++ Hashs +++\n"))
            {
                err_msg("interrupt", sname, sline);
                return FALSE;
            }

            if(!global && runinfo->object) {
                it = hash_loop_begin(runinfo->object->mHashs);
            }
            else {
                it = hash_loop_begin(gHashs);
            }

            while(it != NULL) {
                if(!statment_tree_internal_commands_write_nextout(nextout,  hash_loop_key(it))) 
                {
                    err_msg("interrupt", sname, sline);
                    return FALSE;
                }
                if(!statment_tree_internal_commands_write_nextout(nextout,  "\n")) 
                {
                    err_msg("interrupt", sname, sline);
                    return FALSE;
                }

                it = hash_loop_next(it);
            }

            if(!statment_tree_internal_commands_write_nextout(nextout, "+++ Refferences +++\n"))
            {
                err_msg("interrupt", sname, sline);
                return FALSE;
            }

            if(!global && runinfo->object) {
                it = hash_loop_begin(runinfo->object->mRefs);
            }
            else {
                it = hash_loop_begin(gRefs);
            }
            while(it != NULL) {
                if(!statment_tree_internal_commands_write_nextout(nextout,  hash_loop_key(it))) 
                {
                    err_msg("interrupt", sname, sline);
                    return FALSE;
                }
                if(!statment_tree_internal_commands_write_nextout(nextout,  "\n")) 
                {
                    err_msg("interrupt", sname, sline);
                    return FALSE;
                }

                it = hash_loop_next(it);
            }

            if(!statment_tree_internal_commands_write_nextout(nextout, "+++ Objects +++\n"))
            {
                err_msg("interrupt", sname, sline);
                return FALSE;
            }

            if(!global && runinfo->object) {
                it = hash_loop_begin(runinfo->object->mObjects);
            }
            else {
                it = hash_loop_begin(gObjects);
            }
            while(it != NULL) {
                if(!statment_tree_internal_commands_write_nextout(nextout,  hash_loop_key(it))) 
                {
                    err_msg("interrupt", sname, sline);
                    return FALSE;
                }
                if(!statment_tree_internal_commands_write_nextout(nextout,  "\n")) 
                {
                    err_msg("interrupt", sname, sline);
                    return FALSE;
                }

                it = hash_loop_next(it);
            }

            if(!statment_tree_internal_commands_write_nextout(nextout, "+++ Funcs +++\n"))
            {
                err_msg("interrupt", sname, sline);
                return FALSE;
            }

            if(!global && runinfo->object) {
                it = hash_loop_begin(runinfo->object->mMethods);
            }
            else {
                it = hash_loop_begin(gFuncs);
            }
            while(it != NULL) {
                if(!statment_tree_internal_commands_write_nextout(nextout,  hash_loop_key(it))) 
                {
                    err_msg("interrupt", sname, sline);
                    return FALSE;
                }
                if(!statment_tree_internal_commands_write_nextout(nextout,  "\n")) 
                {
                    err_msg("interrupt", sname, sline);
                    return FALSE;
                }

                it = hash_loop_next(it);
            }

            if(!statment_tree_internal_commands_write_nextout(nextout, "+++ Classes +++\n"))
            {
                err_msg("interrupt", sname, sline);
                return FALSE;
            }

            if(!global && runinfo->object) {
                it = hash_loop_begin(runinfo->object->mClasses);
            }
            else {
                it = hash_loop_begin(gClasses);
            }
            while(it != NULL) {
                if(!statment_tree_internal_commands_write_nextout(nextout,  hash_loop_key(it))) 
                {
                    err_msg("interrupt", sname, sline);
                    return FALSE;
                }
                if(!statment_tree_internal_commands_write_nextout(nextout,  "\n")) 
                {
                    err_msg("interrupt", sname, sline);
                    return FALSE;
                }

                it = hash_loop_next(it);
            }
            
            *rcode = 0;
            }
            break;

        case kSweep: {
            int i;
            BOOL funcs = FALSE;
            BOOL classes = FALSE;
            BOOL regs = FALSE;
            BOOL global_pipes = FALSE;
            BOOL global = FALSE;
            BOOL gc = FALSE;
            BOOL all = FALSE;
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv,i));
                // sweep all functions
                // Ƥδؿä
                if(strcmp(arg, "-f") == 0) {
                    funcs = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // sweep all definitions
                // Ƥä
                else if(strcmp(arg, "-all") == 0) {
                    all = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // run gabage collection
                // ١쥯ư
                else if(strcmp(arg, "-gc") == 0) {
                    gc = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // sweep all classes
                // ƤΥ饹ä
                else if(strcmp(arg, "-c") == 0) {
                    classes = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // sweep regex caches
                // ɽΥåƾä
                else if(strcmp(arg, "-reg") == 0) {
                    regs = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // sweep all global pipes
                // ƤΥХѥפä
                else if(strcmp(arg, "-gp") == 0) {
                    global_pipes = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // Although in class context, access global name space
                // 饹ƥȤǤ⥰Х֤̾Υ֥Ȥ˥
                else if(strcmp(arg, "-g") == 0) {
                    global = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            if(gc) {
                int count = saphire_gc_sweep(nextout);

                if(count < 0) {
                    return FALSE;
                }

                char buf[BUFSIZ];
                snprintf(buf, BUFSIZ, "%d objects deleted\n", count);
                if(!statment_tree_internal_commands_write_nextout(nextout, buf))
                {
                    return FALSE;
                }

                *rcode = 0;
            }
            else if(funcs) {
                if(!global && runinfo->object) {
                    hash_it* it = hash_loop_begin(runinfo->object->mMethods);
                    while(it) {
                        sFunction_delete(hash_loop_item(it));
                        it = hash_loop_next(it);
                    }
                    
                    hash_clear(runinfo->object->mMethods);
                    *rcode = 0;
                }
                else {
                    hash_it* it = hash_loop_begin(gFuncs);
                    while(it) {
                        sFunction_delete(hash_loop_item(it));
                        it = hash_loop_next(it);
                    }
                    hash_clear(gFuncs);
                    *rcode = 0;
                }
            }
            else if(classes) {
                if(!global && runinfo->object) {
                    hash_it* it = hash_loop_begin(runinfo->object->mClasses);
                    while(it) {
                        sClass_delete(hash_loop_item(it));
                        it = hash_loop_next(it);
                    }
                    
                    hash_clear(runinfo->object->mClasses);
                    *rcode = 0;
                }
                else {
                    hash_it* it = hash_loop_begin(gClasses);
                    while(it) {
                        sClass_delete(hash_loop_item(it));
                        it = hash_loop_next(it);
                    }
                    
                    hash_clear(gClasses);
                    *rcode = 0;
                }
            }
            else if(regs) {
                hash_it* it = hash_loop_begin(gRegexs);
                while(it != NULL) {
                    onig_free(hash_loop_item(it));
                    it = hash_loop_next(it);
                }
                hash_clear(gRegexs);

                it = hash_loop_begin(gRegexsI);
                while(it != NULL) {
                    onig_free(hash_loop_item(it));
                    it = hash_loop_next(it);
                }
                hash_clear(gRegexsI);

                it = hash_loop_begin(gRegexsM);
                while(it != NULL) {
                    onig_free(hash_loop_item(it));
                    it = hash_loop_next(it);
                }
                hash_clear(gRegexsM);

                it = hash_loop_begin(gRegexsIM);
                while(it != NULL) {
                    onig_free(hash_loop_item(it));
                    it = hash_loop_next(it);
                }
                hash_clear(gRegexsIM);

                it = hash_loop_begin(gRegexsUtf8);
                while(it != NULL) {
                    onig_free(hash_loop_item(it));
                    it = hash_loop_next(it);
                }
                hash_clear(gRegexsUtf8);

                it = hash_loop_begin(gRegexsIUtf8);
                while(it != NULL) {
                    onig_free(hash_loop_item(it));
                    it = hash_loop_next(it);
                }
                hash_clear(gRegexsIUtf8);

                it = hash_loop_begin(gRegexsMUtf8);
                while(it != NULL) {
                    onig_free(hash_loop_item(it));
                    it = hash_loop_next(it);
                }
                hash_clear(gRegexsMUtf8);

                it = hash_loop_begin(gRegexsIMUtf8);
                while(it != NULL) {
                    onig_free(hash_loop_item(it));
                    it = hash_loop_next(it);
                }
                hash_clear(gRegexsIMUtf8);
                
                it = hash_loop_begin(gRegexsEucjp);
                while(it != NULL) {
                    onig_free(hash_loop_item(it));
                    it = hash_loop_next(it);
                }
                hash_clear(gRegexsEucjp);

                it = hash_loop_begin(gRegexsIEucjp);
                while(it != NULL) {
                    onig_free(hash_loop_item(it));
                    it = hash_loop_next(it);
                }
                hash_clear(gRegexsIEucjp);

                it = hash_loop_begin(gRegexsMEucjp);
                while(it != NULL) {
                    onig_free(hash_loop_item(it));
                    it = hash_loop_next(it);
                }
                hash_clear(gRegexsMEucjp);

                it = hash_loop_begin(gRegexsIMEucjp);
                while(it != NULL) {
                    onig_free(hash_loop_item(it));
                    it = hash_loop_next(it);
                }
                hash_clear(gRegexsIMEucjp);

                it = hash_loop_begin(gRegexsSjis);
                while(it != NULL) {
                    onig_free(hash_loop_item(it));
                    it = hash_loop_next(it);
                }
                hash_clear(gRegexsSjis);

                it = hash_loop_begin(gRegexsISjis);
                while(it != NULL) {
                    onig_free(hash_loop_item(it));
                    it = hash_loop_next(it);
                }
                hash_clear(gRegexsISjis);

                it = hash_loop_begin(gRegexsMSjis);
                while(it != NULL) {
                    onig_free(hash_loop_item(it));
                    it = hash_loop_next(it);
                }
                hash_clear(gRegexsMSjis);

                it = hash_loop_begin(gRegexsIMSjis);
                while(it != NULL) {
                    onig_free(hash_loop_item(it));
                    it = hash_loop_next(it);
                }
                hash_clear(gRegexsIMSjis);

                *rcode = 0;
            }
            else if(global_pipes) {
                string_put(gGlobalPipe, "");

                for(i=0; i<10; i++) {
                    string_put(gGlobalPipeNum[i], "");
                }
                *rcode = 0;
            }
            else if(all) {
                if(!global && runinfo->object) {
                    hash_it* it = hash_loop_begin(runinfo->object->mGlobals);
                    while(it) {
                        sGlobal_delete(hash_loop_item(it));
                        it = hash_loop_next(it);
                    }
                    hash_clear(runinfo->object->mGlobals);
                    it = hash_loop_begin(runinfo->object->mArrays);
                    while(it) {
                        sAry_delete(hash_loop_item(it));
                        it = hash_loop_next(it);
                    }
                    hash_clear(runinfo->object->mArrays);
                    it = hash_loop_begin(runinfo->object->mHashs);
                    while(it) {
                        sHash_delete(hash_loop_item(it));

                        it = hash_loop_next(it);
                    }
                    hash_clear(runinfo->object->mHashs);
                    it = hash_loop_begin(runinfo->object->mObjects);
                    while(it) {
                        sObject_delete(hash_loop_item(it));
                        it = hash_loop_next(it);
                    }
                    hash_clear(runinfo->object->mObjects);
                    it = hash_loop_begin(runinfo->object->mRefs);
                    while(it) {
                        sRef* ref = hash_loop_item(it);
                        sRef_delete(ref);
                        it = hash_loop_next(it);
                    }
                    hash_clear(runinfo->object->mRefs);
                }
                else {
                    hash_it* it = hash_loop_begin(gGlobals);
                    while(it) {
                        sGlobal_delete(hash_loop_item(it));
                        it = hash_loop_next(it);
                    }
                    hash_clear(gGlobals);
                    it = hash_loop_begin(gArrays);
                    while(it) {
                        sAry_delete(hash_loop_item(it));
                        it = hash_loop_next(it);
                    }
                    hash_clear(gArrays);
                    it = hash_loop_begin(gHashs);
                    while(it) {
                        sHash_delete(hash_loop_item(it));

                        it = hash_loop_next(it);
                    }
                    hash_clear(gHashs);
                    it = hash_loop_begin(gObjects);
                    while(it) {
                        sObject_delete(hash_loop_item(it));
                        it = hash_loop_next(it);
                    }
                    hash_clear(gObjects);
                    it = hash_loop_begin(gRefs);
                    while(it) {
                        sRef* ref = hash_loop_item(it);
                        sRef_delete(ref);
                        it = hash_loop_next(it);
                    }
                    hash_clear(gRefs);
                }
                *rcode = 0;
            }
            else if(vector_size(argv) >= 2) {
                if(!global && runinfo->object) {
                    int i;
                    for(i=1; i<vector_size(argv); i++) {
                        char* arg = string_c_str(vector_item(argv, i));

                        sGlobal* g = hash_item(runinfo->object->mGlobals, arg);
                        if(g) {
                            sGlobal_delete(g);
                            hash_erase(runinfo->object->mGlobals, arg);
                            *rcode = 0;
                        }

                        sAry* v = hash_item(runinfo->object->mArrays, arg);
                        if(v) {
                            sAry_delete(v);
                            hash_erase(runinfo->object->mArrays, arg);
                            *rcode = 0;
                        }

                        sHash* h = hash_item(runinfo->object->mHashs, arg);
                        if(h) {
                            sHash_delete(h);
                            hash_erase(runinfo->object->mHashs, arg);
                            *rcode = 0;
                        }

                        sObject* o = hash_item(runinfo->object->mObjects, arg);
                        if(o) {
                            sObject_delete(o);
                            hash_erase(runinfo->object->mObjects, arg);
                            *rcode = 0;
                        }

                        sRef* r = hash_item(runinfo->object->mRefs, arg);
                        if(r) {
                            sRef_delete(r);
                            hash_erase(runinfo->object->mRefs, arg);
                            *rcode = 0;
                        }

                        sFunction* f = hash_item(runinfo->object->mMethods, arg);
                        if(f) {
                            sFunction_delete(f);
                            hash_erase(runinfo->object->mMethods, arg);
                            *rcode = 0;
                        }
                        sClass* c = hash_item(runinfo->object->mClasses, arg);
                        if(c) {
                            sClass_delete(c);
                            hash_erase(runinfo->object->mClasses, arg);
                            *rcode = 0;
                        }
                    }
                }
                else {
                    int i;
                    for(i=1; i<vector_size(argv); i++) {
                        char* arg = string_c_str(vector_item(argv, i));

                        sGlobal* str = hash_item(gGlobals, arg);
                        if(str) {
                            sGlobal_delete(str);
                            hash_erase(gGlobals, arg);
                            *rcode = 0;
                        }

                        sAry* v = hash_item(gArrays, arg);
                        if(v) {
                            sAry_delete(v);
                            hash_erase(gArrays, arg);
                            *rcode = 0;
                        }

                        sHash* h = hash_item(gHashs, arg);
                        if(h) {
                            sHash_delete(h);
                            hash_erase(gHashs, arg);
                            *rcode = 0;
                        }

                        sObject* o = hash_item(gObjects, arg);
                        if(o) {
                            sObject_delete(o);
                            hash_erase(gObjects, arg);
                            *rcode = 0;
                        }

                        sRef* r = hash_item(gRefs, arg);
                        if(r) {
                            sRef_delete(r);
                            hash_erase(gRefs, arg);
                            *rcode = 0;
                        }

                        sFunction* f = hash_item(gFuncs, arg);
                        if(f) {
                            sFunction_delete(f);
                            hash_erase(gFuncs, arg);
                            *rcode = 0;
                        }

                        sClass* c = hash_item(gClasses, arg);
                        if(c) {
                            sClass_delete(c);
                            hash_erase(gClasses, arg);
                            *rcode = 0;
                        }
                    }
                }
            }

            }
            break;

        case kSubshell: {
            if(command->mExtra) {
                sSubshell* s = (sSubshell*) command->mExtra;
                *rcode = run(runinfo, s->contents, title, nextout , nextin, nexterr, FALSE);

                if(runinfo->enable_break && *runinfo->break_) {
                    return TRUE;
                }
                else if(runinfo->enable_return && *runinfo->return_) {
                    return TRUE;
                }
                else if(*rcode < 0) {
                    return FALSE;
                }
            }
            }
            break;

        case kMSleep: {
            if(vector_size(argv) == 2) {
                ///  ///
                char c [] = {'.', 'o', 'O'};
                int n = atoi(string_c_str(vector_item(argv, 1)));
                int i;
                for(i=0; i < n*5; i++) {
                    *rcode = 0;

                    char buf[32];
                    snprintf(buf, 32, "%c\033[D", c[i % 3]);

                    if(!statment_tree_internal_commands_write_nextout(nextout, buf)) 
                    {
                        err_msg("signal interrupt", sname, sline);
                        return FALSE;
                    }
                    if(!sWFd_flash(nextout)) {
                        err_msg("signal interrupt", sname, sline);
                        return FALSE;
                    }

                    if(gKitutukiSigInt) {
                        err_msg("interrupt", sname, sline);
                        gKitutukiSigInt = FALSE;
                        return FALSE;
                    }

                    usleep(200000);
                }
            }
            }
            break;

        case kTrue: 
            *rcode = 0;
            break;

        case kFalse:
            break;

        case kTest: {
            int i;
            enum eKanjiCode code = gKanjiCode;
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv, i));

                // take a STDIN pipe
                // ɸϤ
                if(strcmp(arg, "-I") == 0) {
                    input = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // assume data as Shift JIS
                // ǡSjis󥳡ɤȤư
                else if(strcmp(arg, "-s") == 0) {
                    code = kSjis;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // assume data as Eucjp
                // ǡEucjp󥳡ɤȤư
                else if(strcmp(arg, "-e") == 0) {
                    code = kEucjp;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // assume data as Utf-8
                // ǡUtf-8󥳡ɤȤư
                else if(strcmp(arg, "-w") == 0) {
                    code = kUtf8;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // assume data as ASCII code
                // ǡASCIIǡȤư
                else if(strcmp(arg, "-b") == 0) {
                    code = kByte;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            string_obj* str;

            /// ɸϤǼ1 ///
            if(input) {
                str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str) ;
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    break;
                }
                else if(ret < 0)
                {
                    *rcode = 2;
                    string_delete(str);
                    err_msg("interrupt", sname, sline);
                    return FALSE;
                }
            }
            /// 㤦str = NULL
            else {
                str = NULL;
            }

            if(!statment_tree_internal_commands_test(rcode, argv, str, sname, sline, code)) {
                if(str)string_delete(str);
                return FALSE;
            }

            if(str)string_delete(str);
            }
            break;

        case kIndex: {
            BOOL quiet = FALSE;
            BOOL new_line = TRUE;
            BOOL flg_n = FALSE;
            int n;
            BOOL flg_c = FALSE;
            int c;
            enum eKanjiCode code = gKanjiCode;
            BOOL terminal = FALSE;
            BOOL ignore_case = FALSE;

            int l;
            for(l=0; l<vector_size(argv); l++) {
                char* arg = string_c_str(vector_item(argv, l));

                // not output only to use return code
                // Ϥʤ꥿󥳡ɤΤ߸˻Ȥ
                if(strcmp(arg, "-q") == 0) {
                    quiet = TRUE;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // ignore case
                // ѻʸʸ̵뤹
                else if(strcmp(arg, "-i") == 0) {
                    ignore_case = TRUE;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // when output the variant content, don't add LF at tail
                // ϤȤԤäʤ
                else if(strcmp(arg, "-nl") == 0) {
                    new_line = FALSE;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // take a STDIN pipe
                // ɸϤ
                else if(strcmp(arg, "-I") == 0) {
                    input = TRUE;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // count with terminal character size
                // üǤʸ礭ǿ
                else if(strcmp(arg, "-t") == 0) {
                    terminal = TRUE;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // assume data as ASCII code
                // ǡASCIIǡȤư
                else if(strcmp(arg, "-b") == 0) {
                    code = kByte;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // search N times
                // n󥵡
                else if(strcmp(arg, "-c") == 0 && l+1 < vector_size(argv)) {
                    flg_c = TRUE;
                    c = atoi(string_c_str(vector_item(argv, l+1)));
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // search at Nth character
                // nʸܤ饵
                else if(strcmp(arg, "-n") == 0 && l+1 < vector_size(argv)) {
                    flg_n = TRUE;
                    n = atoi(string_c_str(vector_item(argv, l+1)));
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
            }

            char* word;
            char* target;
            int start;
            int match_count;
            string_obj* str = STRING_NEW("");

            if(input) {
                if(vector_size(argv) != 2) {
                    err_msg("index -I string", sname, sline);
                    string_delete(str);
                    return FALSE;
                }

                /// ʸ ///
                int ret = statment_tree_internal_commands_read_nextin(nextin, str);
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    break;
                }
                else if(ret < 0)
                {
                    err_msg("interrupt", sname, sline);
                    string_delete(str);
                    return FALSE;
                }
                target = string_c_str(str);

                /// ʸ ///
                word = string_c_str(vector_item(argv, 1));

                /// ʸ󳫻ϰ ///
                if(flg_n) {
                    start = n;

                    int len = str_kanjilen_cancelable(code, target);
                    if(len < 0) {
                        string_delete(str);
                        return FALSE;
                    }

                    if(start < 0) {
                        start = len + start;
                    }

                    if(start < 0 || start >= len)
                    {
                        string_delete(str);
                        break;
                    }
                }
                else {
                    start = 0;
                }

                /// ʸθ ///
                if(flg_c) {
                    match_count = c;
                    if(match_count <= 0) {
                        err_msg("index -> invalid -c range", sname, sline);
                        string_delete(str);
                        return FALSE;
                    }
                }
                else {
                    match_count = 1;
                }
            }
            else {
                if(vector_size(argv) != 3) {
                    err_msg("index -> invalid option number", sname, sline);
                    string_delete(str);
                    return FALSE;
                }

                /// ʸ ///
                word = string_c_str(vector_item(argv, 2));

                /// ʸ ///
                target = string_c_str(vector_item(argv, 1));

                /// ʸ󳫻ϰ ///
                if(flg_n) {
                    start = n;

                    int len = str_kanjilen_cancelable(code, target);
                    if(len < 0) {
                        string_delete(str);
                        return FALSE;
                    }

                    if(start < 0) {
                        start = len + start;
                    }

                    if(start < 0 || start >= len)
                    {
                        string_delete(str);
                        break;
                    }
                }
                else {
                    start = 0;
                }

                /// ʸθ ///
                if(flg_c) {
                    match_count = c;
                    if(match_count <= 0) {
                        err_msg("index -> invalid -c range", sname, sline);
                        string_delete(str);
                        return FALSE;
                    }
                }
                else {
                    match_count = 1;
                }
            }

            char* start_byte = str_kanjipos2pointer(code, target, start);
            int count = match_count;
            char* p = start_byte;
            char* result = NULL;
            if(ignore_case) {
                while(p < start_byte + strlen(start_byte)) {
                    if(gKitutukiSigInt) {
                        err_msg("interrupt", sname, sline);
                        string_delete(str);
                        return FALSE;
                    }
                    result = (char*)strcasestr((const char*) p, (const char*)word);
                    if(result) {
                        count--;
                        if(count == 0) {
                            break;
                        }
                        p = result+strlen(word);
                    }
                    else {
                        break;
                    }
                }
            }
            else {
                while(p < start_byte + strlen(start_byte)) {
                    if(gKitutukiSigInt) {
                        err_msg("interrupt", sname, sline);
                        string_delete(str);
                        return FALSE;
                    }
                    result = strstr(p, word);
                    if(result) {
                        count--;
                        if(count == 0) {
                            break;
                        }
                        p = result+strlen(word);
                    }
                    else {
                        break;
                    }
                }
            }

            char msg[64];
            if(result == NULL || count !=0) {
                snprintf(msg, 64, "-1");
            }
            else {
                int c;
                if(terminal) {
                    int pos = str_pointer2kanjipos(code, target, result);
                    c = str_termlen2(code, target, pos);
                }
                else {
                    c = str_pointer2kanjipos(code, target, result);
                }
                snprintf(msg, 64, "%d", c);
                *rcode = 0;
            }

            ///  ///
            if(quiet == FALSE) {
                if(!statment_tree_internal_commands_write_nextout(nextout, msg))
                {
                    err_msg("signal interrupt", sname, sline);
                    string_delete(str);
                    return FALSE;
                }

                if(new_line) {
                    if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                    {
                        err_msg("singal interrupt", sname, sline);
                        string_delete(str);
                        return FALSE;
                    }
                }
            }

            string_delete(str);
            }
            break;

        case kRIndex: {
            BOOL quiet = FALSE;
            BOOL new_line = TRUE;
            BOOL flg_n = FALSE;
            int n;
            BOOL flg_c = FALSE;
            BOOL terminal = FALSE;
            int c;
            enum eKanjiCode code = gKanjiCode;
            BOOL ignore_case = FALSE;

            int l;
            for(l=0; l<vector_size(argv); l++) {
                char* arg = string_c_str(vector_item(argv, l));

                // not output only to use return code
                // Ϥʤ꥿󥳡ɤΤ߸˻Ȥ
                if(strcmp(arg, "-q") == 0) {
                    quiet = TRUE;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // ignore case
                // ѻʸʸ̵뤹
                else if(strcmp(arg, "-i") == 0) {
                    ignore_case = TRUE;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // when output the variant content, don't add LF at tail
                // ϤȤԤäʤ
                else if(strcmp(arg, "-nl") == 0) {
                    new_line = FALSE;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // count with terminal character size
                // üǤʸ礭ǿ
                else if(strcmp(arg, "-t") == 0) {
                    terminal = TRUE;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // assume data as ASCII code
                // ǡASCIIǡȤư
                else if(strcmp(arg, "-b") == 0) {
                    code = kByte;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // take a STDIN pipe
                // ɸϤ
                else if(strcmp(arg, "-I") == 0) {
                    input = TRUE;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // search N times
                // n󥵡
                else if(strcmp(arg, "-c") == 0 && l+1 < vector_size(argv)) {
                    flg_c = TRUE;
                    c = atoi(string_c_str(vector_item(argv, l+1)));
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // search at Nth character
                // nʸܤ饵
                else if(strcmp(arg, "-n") == 0 && l+1 < vector_size(argv)) {
                    flg_n = TRUE;
                    n = atoi(string_c_str(vector_item(argv, l+1)));
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
            }

            char* word;
            char* target;
            int start;
            int match_count;
            string_obj* str = STRING_NEW("");

            if(input) {
                if(vector_size(argv) != 2) {
                    err_msg("index -I string", sname, sline);
                    string_delete(str);
                    return FALSE;
                }

                /// ʸ ///
                int ret = statment_tree_internal_commands_read_nextin(nextin, str);
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    break;
                }
                else if(ret < 0)
                {
                    err_msg("intterrupt", sname, sline);
                    string_delete(str);
                    return FALSE;
                }
                target = string_c_str(str);

                /// ʸ ///
                word = string_c_str(vector_item(argv, 1));

                /// ʸ󳫻ϰ ///
                int len = str_kanjilen_cancelable(code, target);
                if(len < 0) {
                    string_delete(str);
                    return FALSE;
                }
                if(flg_n) {
                    start = n;

                    if(start < 0) {
                        start = len + start;
                    }

                    if(start < 0 || start >= len)
                    {
                        string_delete(str);
                        break;
                    }
                }
                else {
                    start = len -1;
                }

                /// ʸθ ///
                if(flg_c) {
                    match_count = c;
                    if(match_count <= 0) {
                        err_msg("index -> invalid -c range", sname, sline);
                        string_delete(str);
                        return FALSE;
                    }
                }
                else {
                    match_count = 1;
                }
            }
            else {
                if(vector_size(argv) != 3) {
                    err_msg("index -> invalid option number", sname, sline);
                    string_delete(str);
                    return FALSE;
                }

                /// ʸ ///
                word = string_c_str(vector_item(argv, 2));

                /// ʸ ///
                target = string_c_str(vector_item(argv, 1));

                /// ʸ󳫻ϰ ///
                int len = str_kanjilen_cancelable(code, target);
                if(len < 0) {
                    string_delete(str);
                    return FALSE;
                }
                if(flg_n) {
                    start = n;

                    if(start < 0) {
                        start = len + start;
                    }

                    if(start < 0 || start >= len)
                    {
                        string_delete(str);
                        break;
                    }
                }
                else {
                    start = len -1;
                }

                /// ʸθ ///
                if(flg_c) {
                    match_count = c;
                    if(match_count <= 0) {
                        err_msg("index -> invalid -c range", sname, sline);
                        string_delete(str);
                        return FALSE;
                    }
                }
                else {
                    match_count = 1;
                }
            }
            
            int count = match_count;

            char* start_byte = str_kanjipos2pointer(code
                    , target, start+1);
            char* p = start_byte;
            char* result = NULL;
            if(ignore_case) {
                while(p>=target) {
                    result = strcasestr_back(p, target, word, sname, sline);

                    if(gKitutukiSigInt) {
                        err_msg("interrupt", sname, sline);
                        *rcode = 1;
                        string_delete(str);
                        return FALSE;
                    }

                    if(result != NULL) {
                        count--;
                        if(count == 0) {
                            break;
                        }
                        p = result - 1;
                    }
                    else {
                        break;
                    }
                }
            }
            else {
                while(p>=target) {
                    result = strstr_back(p, target, word, sname, sline);

                    if(gKitutukiSigInt) {
                        err_msg("interrupt", sname, sline);
                        *rcode = 1;
                        string_delete(str);
                        return FALSE;
                    }

                    if(result != NULL) {
                        count--;
                        if(count == 0) {
                            break;
                        }
                        p = result - 1;
                    }
                    else {
                        break;
                    }
                }
            }

            char msg[64];
            if(result == NULL || count !=0) {
                snprintf(msg, 64, "-1");
            }
            else {
                int c;
                if(terminal) {
                    int pos = str_pointer2kanjipos(code, target, result);
                    c = str_termlen2(code, target, pos);
                }
                else {
                    c = str_pointer2kanjipos(code, target, result);
                }
                snprintf(msg, 64, "%d", c);
                *rcode = 0;
            }

            if(quiet == FALSE) {
                if(!statment_tree_internal_commands_write_nextout(nextout, msg))
                {
                    err_msg("signal interrupt", sname, sline);
                    string_delete(str);
                    return FALSE;
                }
                if(new_line) {
                    if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                    {
                        err_msg("singal interrupt", sname, sline);
                        string_delete(str);
                        return FALSE;
                    }
                }
            }

            string_delete(str);
            }
            break;

        case kLength: {
            int i;
            BOOL line_field = TRUE;
            enum eKanjiCode code = gKanjiCode;
            BOOL terminal = FALSE;
            BOOL line_field_count = FALSE;
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv,i));
                // take a STDIN pipe
                // ɸϤ
                if(strcmp(arg, "-I") == 0) {
                    input = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // when output the variant content, don't add LF at tail
                // ϤȤԤäʤ
                else if(strcmp(arg, "-nl") == 0) {
                    line_field = FALSE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // assume data as Shift JIS
                // ǡSjis󥳡ɤȤư
                else if(strcmp(arg, "-s") == 0) {
                    code = kSjis;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // assume data as Eucjp
                // ǡEucjp󥳡ɤȤư
                else if(strcmp(arg, "-e") == 0) {
                    code = kEucjp;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // assume data as Utf-8
                // ǡUtf-8󥳡ɤȤư
                else if(strcmp(arg, "-w") == 0) {
                    code = kUtf8;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // assume data as ASCII code
                // ǡASCIIǡȤư
                else if(strcmp(arg, "-b") == 0) {
                    code = kByte;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // terminal size length
                // üʸ礭ǲʸ
                else if(strcmp(arg, "-t") == 0) {
                    terminal = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // linefield count
                // ԤĤ뤫
                else if(strcmp(arg, "-L") == 0) {
                    line_field_count = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            if(input) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(
                            nextin, str);

                /// EOF
                if(ret == 1) {
                    string_delete(str);
                    *rcode = 1;
                    break;
                }
                else if(ret < 0)
                {
                    err_msg("interrupt", sname, sline);
                    string_delete(str);
                    return FALSE;
                }
                else {
                    int len;
                    if(terminal)
                        len = str_termlen(code, string_c_str(str));
                    else if(line_field_count)
                        len = str_lflen(gLineField, string_c_str(str));
                    else {
                        len = str_kanjilen_cancelable(code, string_c_str(str));
                        if(len < 0) {
                            string_delete(str);
                            return FALSE;
                        }
                    }

                    char buf[128];
                    if(line_field)
                        snprintf(buf, 128, "%d\n", len);
                    else
                        snprintf(buf, 128, "%d", len);

                    if(!statment_tree_internal_commands_write_nextout(nextout,  buf))
                    {
                        err_msg("signal interrupt", sname, sline);
                        string_delete(str);
                        return FALSE;
                    }

                    *rcode = 0;
                }

                string_delete(str);
            }
            else {
                if(vector_size(argv) == 2) {
                    int len;
                    if(terminal)
                        len = str_termlen(code, string_c_str(vector_item(argv, 1)));
                    else if(line_field_count)
                        len = str_lflen(gLineField, string_c_str(vector_item(argv, 1)));
                    else {
                        len = str_kanjilen_cancelable(code, string_c_str(vector_item(argv, 1)));
                        if(len < 0) {
                            return FALSE;
                        }
                    }
                    char buf[128];

                    if(line_field)
                        snprintf(buf, 128, "%d\n", len);
                    else
                        snprintf(buf, 128, "%d", len);

                    if(!statment_tree_internal_commands_write_nextout(nextout, buf)) 
                    {
                        err_msg("signal interrupt", sname, sline);
                        return FALSE;
                    }
                    *rcode = 0;
                }
            }
            }
            break;

        case kUc: {
            int i;
            BOOL line_field = FALSE;
            enum eKanjiCode code = gKanjiCode;

            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv,i));
                // take a STDIN pipe
                // ɸϤ
                if(strcmp(arg, "-I") == 0) {
                    input = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // when output the variant content, add LF at tail
                // ϤȤԤä
                else if(strcmp(arg, "-L") == 0) {
                    line_field = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // assume data as Shift JIS
                // ǡSjis󥳡ɤȤư
                else if(strcmp(arg, "-s") == 0) {
                    code = kSjis;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // assume data as Eucjp
                // ǡEucjp󥳡ɤȤư
                else if(strcmp(arg, "-e") == 0) {
                    code = kEucjp;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // assume data as Utf-8
                // ǡUtf-8󥳡ɤȤư
                else if(strcmp(arg, "-w") == 0) {
                    code = kUtf8;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // assume data as ASCII code
                // ǡASCIIǡȤư
                else if(strcmp(arg, "-b") == 0) {
                    code = kByte;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            if(input) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(
                                nextin, str);

                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    break;
                }
                else if(ret < 0)
                {
                    err_msg("interrupt", sname, sline);
                    string_delete(str);
                    return FALSE;
                }
                else {
                    string_toupper(str, code);

                    ///  ///
                    if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(str))) 
                    {
                        err_msg("signal interrupt", sname, sline);
                        string_delete(str);
                        return FALSE;
                    }

                    if(line_field) {
                        if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                        {
                            err_msg("singal interrupt", sname, sline);
                            string_delete(str);
                            return FALSE;
                        }
                    }

                    *rcode = 0;
                }

                string_delete(str);
            }
            else {
                if(vector_size(argv) == 2) {
                    string_obj* str = STRING_NEW(
                        string_c_str(vector_item(argv, 1)));

                    string_toupper(str, code);

                    if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(str))) 
                    {
                        err_msg("signal interrupt", sname, sline);
                        string_delete(str);
                        return FALSE;
                    }

                    if(line_field) {
                        if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                        {
                            err_msg("singal interrupt", sname, sline);
                            string_delete(str);
                            return FALSE;
                        }
                    }

                    *rcode = 0;

                    string_delete(str);
                }
            }
            }
            break;

        case kLc: {
            int i;
            BOOL line_field = FALSE;
            enum eKanjiCode code = gKanjiCode;
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv,i));
                // take a STDIN pipe
                // ɸϤ
                if(strcmp(arg, "-I") == 0) {
                    input = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // when output the variant content, add LF at tail
                // ϤȤԤä
                else if(strcmp(arg, "-L") == 0) {
                    line_field = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // assume data as Shift JIS
                // ǡSjis󥳡ɤȤư
                else if(strcmp(arg, "-s") == 0) {
                    code = kSjis;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // assume data as Eucjp
                // ǡEucjp󥳡ɤȤư
                else if(strcmp(arg, "-e") == 0) {
                    code = kEucjp;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // assume data as Utf-8
                // ǡUtf-8󥳡ɤȤư
                else if(strcmp(arg, "-w") == 0) {
                    code = kUtf8;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // assume data as ASCII code
                // ǡASCIIǡȤư
                else if(strcmp(arg, "-b") == 0) {
                    code = kByte;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            if(input) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(
                    nextin, str);

                if(ret == 1) {
                    string_delete(str);
                    *rcode = 1;
                    break;
                }
                else if(ret < 0)
                {
                    err_msg("interrupt", sname, sline);
                    string_delete(str);
                    return FALSE;
                }
                else {
                    string_tolower(str, code);

                    if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(str)))
                    {
                        err_msg("signal interrupt", sname, sline);
                        string_delete(str);
                        return FALSE;
                    }

                    if(line_field) {
                        if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                        {
                            err_msg("singal interrupt", sname, sline);
                            string_delete(str);
                            return FALSE;
                        }
                    }

                    *rcode = 0;
                }

                string_delete(str);
            }
            else {
                if(vector_size(argv) == 2) {
                    string_obj* str = STRING_NEW(
                        string_c_str(vector_item(argv, 1)));

                    string_tolower(str, code);

                    if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(str)))
                    {
                        err_msg("signal interrupt", sname, sline);
                        string_delete(str);
                        return FALSE;
                    }

                    if(line_field) {
                        if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                        {
                            err_msg("singal interrupt", sname, sline);
                            string_delete(str);
                            return FALSE;
                        }
                    }

                    *rcode = 0;

                    string_delete(str);
                }
            }
            }
            break;

        case kChomp: {
            int i;
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv,i));
                // take a STDIN pipe
                // ɸϤ
                if(strcmp(arg, "-I") == 0) {
                    input = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            if(input) {
                string_obj* str = STRING_NEW("");
    //puts("read_nextin start");
                int ret = statment_tree_internal_commands_read_nextin(
                        nextin, str);

                if(ret == 1) {
                    string_delete(str);
                    *rcode = 1;
                    break;
                }
                else if(ret < 0)
                {
                    err_msg("interrupt", sname, sline);
                    string_delete(str);
                    return FALSE;
                }
                else {
                    string_chomp(str);
                    *rcode = 0;

                    if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(str)))
                    {
                        err_msg("signal interrupt", sname, sline);
                        string_delete(str);
                        return FALSE;
                    }
                }

                string_delete(str);
            }
            else if(vector_size(argv) >= 2) {
                string_obj* str = vector_item(argv, 1);
                if(string_chomp(str)) {
                    *rcode = 0;
                }

                if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(str)))
                {
                    err_msg("signal interrupt", sname, sline);
                    return FALSE;
                }
            }
            }
            break;

        case kEval: {
            int i;
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv,i));
                // take a STDIN pipe
                // ɸϤ
                if(strcmp(arg, "-I") == 0) {
                    input = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            if(input) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(
                        nextin, str) ;
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    break;
                }
                else if(ret < 0) 
                {
                    err_msg("interrupt", sname, sline);
                    string_delete(str);
                    return FALSE;
                }

                char* fname = MALLOC(strlen(sname) + 32);
                snprintf(fname, strlen(sname) + 32, "%s %d: eval", sname, sline);
                
                *rcode = saphire_shell4(string_c_str(str), fname
                                , nextout, nextin, nexterr, runinfo->object);

                FREE(fname);

                if(*rcode < 0) {
                    string_delete(str);
                    return FALSE;
                }

                if(*rcode < 0) {
                    string_delete(str);
                    return FALSE;
                }

                string_delete(str);
            }
            else if(vector_size(blocks) == 1) {
                sBlock* block = vector_item(blocks, 0);
                sStatments* statments = block->mStatments;

                char* fname = MALLOC(strlen(sname) + 32);
                snprintf(fname, strlen(sname) + 32, "%s %d: eval", sname, sline);
                
                *rcode = run(runinfo, statments, fname, nextout , nextin, nexterr , FALSE);
                FREE(fname);

                if(runinfo->enable_break && *runinfo->break_) {
                    return TRUE;
                }
                else if(runinfo->enable_return && *runinfo->return_) {
                    return TRUE;
                }
                else if(*rcode < 0) {
                    return FALSE;
                }
            }
            }
            break;

        case kFg:
            if(gAppType != kATOptC && gJobControl) {
                if(vector_size(argv) >= 2) {
                    int num 
                       = atoi(string_c_str((string_obj*)vector_item(argv, 1)));
                    if(!forground_job(num-1)) {
                        return FALSE;
                    }

                    *rcode = 0;
                }
                else {
                    if(!forground_job(0)) {
                        return FALSE;
                    }
                    *rcode = 0;
                }
            }
            break;

        case kBg:
            if(gAppType != kATOptC && gJobControl) {
                if(vector_size(argv) >= 2) {
                    char* argv2 = string_c_str((string_obj*)vector_item(argv, 1));
                    if(argv2[0] >= '1' && argv2[0] <= '9') {
                        int num = argv2[0] - '0';
                        background_job(num-1);
                    }

                    *rcode = 0;
                }
                else {
                    background_job(0);
                    *rcode = 0;
                }
            }
            break;


        case kJobs:
            {
            int i;
            if(!statment_tree_internal_commands_write_nextout(nextout, "number name pgroup\n")) 
            {
                err_msg("signal interrupt", sname, sline);
                return FALSE;
            }
            for(i=0; i<vector_size(gJobs); i++) {
                sJob* job = vector_item(gJobs, i);
                char* str = MALLOC(string_length(job->mName) + 16);
                snprintf(str, string_length(job->mName) + 16, "%d. %s %d\n", i+1, string_c_str(job->mName), job->mPGroup);
                if(!statment_tree_internal_commands_write_nextout(nextout, str)) 
                {
                    FREE(str);
                    return FALSE;
                }
                
                FREE(str);
            }
            *rcode = 0;
            }
            break;

        case kRehash:
            saphire_rehash();
            *rcode = 0;
            break;

        case kKanjiCode: {
            int l;
            BOOL quiet = FALSE;
            for(l=0; l<vector_size(argv); l++) {
                char* arg = string_c_str(vector_item(argv, l));

                // assume data as Shift JIS
                // ǡSjis󥳡ɤȤư
                if(strcmp(arg, "-s") == 0) {
                    *rcode = 0;
                    gKanjiCode = kSjis;

                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // assume data as ASCII code
                // ǡASCIIǡȤư
                else if(strcmp(arg, "-b") == 0) {
                    *rcode = 0;
                    gKanjiCode = kByte;

                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // assume data as Eucjp
                // ǡEucjp󥳡ɤȤư
                else if(strcmp(arg, "-e") == 0) {
                    *rcode = 0;
                    gKanjiCode = kEucjp;
                    
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // assume data as Utf-8
                // ǡUtf-8󥳡ɤȤư
                else if(strcmp(arg, "-w") == 0) {
                    *rcode = 0;
                    gKanjiCode = kUtf8;
                    
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // no output
                // ȥץåȤʤ
                else if(strcmp(arg, "-q") == 0) {
                    quiet = TRUE;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
            }

            if(!quiet) {
                if(gKanjiCode == kSjis) {
                    if(!statment_tree_internal_commands_write_nextout(nextout, "sjis\n"))
                    {
                        err_msg("signal interrupt", sname, sline);
                        return FALSE;
                    }
                }
                else if(gKanjiCode == kEucjp) {
                    if(!statment_tree_internal_commands_write_nextout(nextout, "eucjp\n")) 
                    {
                        err_msg("signal interrupt", sname, sline);
                        return FALSE;
                    }
                }
                else if(gKanjiCode == kByte) {
                    if(!statment_tree_internal_commands_write_nextout(nextout, "byte\n")) 
                    {
                        err_msg("signal interrupt", sname, sline);
                        return FALSE;
                    }
                }
                else {
                    if(!statment_tree_internal_commands_write_nextout(nextout, "utf8\n"))
                    {
                        err_msg("signal interrupt", sname, sline);
                        return FALSE;
                    }
                }
                *rcode = 0;
            }

            }
            break;

        case kLineField: {
            int l;
            BOOL quiet = FALSE;
            for(l=0; l<vector_size(argv); l++) {
                char* arg = string_c_str(vector_item(argv, l));

                // treat line field as CRLF
                // ԥɤCRLFȤư
                if(strcmp(arg, "-Lw") == 0) {
                    *rcode = 0;
                    gLineField = kCRLF;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // treat line field as CR
                // ԥɤCRȤư
                else if(strcmp(arg, "-Lm") == 0) {
                    *rcode = 0;
                    gLineField = kCR;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // treat line field as LF
                // ԥɤLFȤư
                else if(strcmp(arg, "-Lu") == 0) {
                    *rcode = 0;
                    gLineField = kLF;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // treat line field as Bel
                // ԥɤBelȤư
                else if(strcmp(arg, "-La") == 0) {
                    *rcode = 0;
                    gLineField = kBel;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // no output
                // ȥץåȤʤ
                else if(strcmp(arg, "-q") == 0) {
                    quiet = TRUE;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
            }

            ///  ///
            if(!quiet) {
                if(gLineField == kLF) {
                    if(!statment_tree_internal_commands_write_nextout(nextout, "LF\n"))
                    {
                        err_msg("signal interrupt", sname, sline);
                        return FALSE;
                    }
                }
                else if(gLineField == kBel) {
                    if(!statment_tree_internal_commands_write_nextout(nextout, "BEL\n"))
                    {
                        err_msg("signal interrupt", sname, sline);
                        return FALSE;
                    }
                }
                else if(gLineField == kCRLF) {
                    if(!statment_tree_internal_commands_write_nextout(nextout, "CRLF\n"))
                    {
                        err_msg("signal interrupt", sname, sline);
                        return FALSE;
                    }
                }
                else {
                    if(!statment_tree_internal_commands_write_nextout(nextout, "CR\n"))
                    {
                        err_msg("signal interrupt", sname, sline);
                        return FALSE;
                    }
                }
                *rcode = 0;
            }
            }
            break;

        case kPrint:
        case kPuts: 
            {
            int i;

            BOOL line_field;
            string_obj* field = STRING_NEW(" ");
            if(command->mKind == kPrint) {
                line_field= FALSE;
            }
            else {
                line_field = TRUE;
            }
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv,i));
                // when output the variant content, add LF at tail
                // ϤȤԤä
                if(strcmp(arg, "-L") == 0) {
                    line_field = !line_field;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // take a STDIN pipe
                // ɸϤ
                else if(strcmp(arg, "-I") == 0) {
                    input = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // set on field character
                // ʸδ֤ʸ
                else if(strcmp(arg, "-f") == 0 && i+1 < vector_size(argv)) 
                {
                    string_put(field 
                         , string_c_str(vector_item(argv, i+1)));
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            if(input) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(
                                    nextin, str);
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    string_delete(field);
                    break;
                }
                else if(ret < 0)
                {
                    err_msg("interrupt a", sname, sline);
                    string_delete(str);
                    string_delete(field);
                    return FALSE;
                }

                *rcode = 0;
                if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(str)) )
                {
                    err_msg("signal interrupt", sname, sline);
                    string_delete(field);
                    string_delete(str);
                    return FALSE;
                }

                string_delete(str);
            }
            else if(vector_size(argv) > 1) {
                int k;
                for(k=1; k<vector_size(argv); k++) {
                    char* arg = string_c_str((string_obj*)
                                        vector_item(argv, k));
                    if(!statment_tree_internal_commands_write_nextout(nextout,  arg))
                    {
                        err_msg("signal interrupt", sname, sline);
                        string_delete(field);
                        return FALSE;
                    }

                    if(k<vector_size(argv)-1) {
                        if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(field)))
                        {
                            err_msg("signal interrupt", sname, sline);
                            string_delete(field);
                            return FALSE;
                        }
                    }
                }
                if(line_field) {
                    if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                    {
                        err_msg("singal interrupt", sname, sline);
                        string_delete(field);
                        return FALSE;
                    }
                }
                *rcode = 0;
            }
            string_delete(field);
            }
            break;

        case kCompile: 
            if(vector_size(argv) == 2) {
                char* fname = string_c_str(vector_item(argv, 1));
                char out_fname[PATH_MAX];

                noextname(out_fname, PATH_MAX, fname);
                xstrncat(out_fname, ".sao", PATH_MAX-1);

                if(!statment_tree_internal_commands_write_nextout(nextout, out_fname))
                {
                    err_msg("signal interrupt", sname, sline);
                    return FALSE;
                }

                if(!statment_tree_internal_commands_write_nextout(nextout, "\n"))
                {
                    err_msg("signal interrupt", sname, sline);
                    return FALSE;
                }

                if(!saphire_compile(fname, out_fname)) {
                    return FALSE;
                }

                *rcode = 0;
            }
            break;

        case kRaise: 
            if(vector_size(argv) == 2) {
                char* msg = string_c_str(vector_item(argv, 1));

                err_msg(msg, sname, sline);
                *rcode = 0;

                return FALSE;
            }
            break;

        case kLoad: {
            BOOL compiled = FALSE;

            int i;
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv,i));
                // load compiled file
                // ѥ뤵줿եɤ߹
                if(strcmp(arg, "-sao") == 0) {
                    compiled = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            if(vector_size(argv) >= 2) {
                char* fname = string_c_str(vector_item(argv, 1));
                if(access(fname, R_OK) != 0) {
                    err_msg("can't load file", sname, sline);
                    return FALSE;
                }

                // å򷡤
                int k;
                sAry* argv2 = sAry_new(30, 1);
                for(k=2; k<vector_size(argv); k++) {
                    char* value = string_c_str(vector_item(argv, k));
                    saphire_push_back_array_element(argv2, STRING_NEW(value));
                }
                sAry* fun_argv_before;
                dig_stack_frame(sname, sline, &fun_argv_before, argv2);

                if(compiled) {
                    *rcode = saphire_load_obj(
                        string_c_str(vector_item(argv, 1))
                        , nextout, nextin, nexterr, blocks);
                }
                else {
                    *rcode = saphire_load(
                            string_c_str(vector_item(argv, 1))
                            , nextout, nextin, nexterr);
                }
                gKitutukiExit = -1; // exitƤ̵뤷

                // å
                string_obj* sname_strace;
                int line_strace;
                burry_stack_frame(fun_argv_before, &sname_strace, &line_strace);

                if(*rcode < 0) {
                    string_push_back(gErrMsg, string_c_str(sname_strace));
                    string_delete(sname_strace);
                    char tmp[1024];
                    snprintf(tmp, 1024, ":%d\n", line_strace);
                    string_push_back(gErrMsg, tmp);

                    return FALSE;
                }
                else {
                    string_delete(sname_strace);
                }
            }

            }
            break;


        case kWhile: {
            sWhile* w = (sWhile*)command->mExtra;

            *rcode = 0;

            while(1) {
                int rcode2 = run(runinfo, w->joukensiki, title, nextout, nextin, nexterr , FALSE);

                if(runinfo->enable_break && *runinfo->break_) {
                    *rcode = rcode2;
                    return TRUE;
                }
                else if(runinfo->enable_return && *runinfo->return_) {
                    *rcode = rcode2;
                    return TRUE;
                }
                else if(rcode2 < 0) {
                    *rcode = rcode2;
                    return FALSE;
                }
                else if(rcode2 == SIGINT) {
                    *rcode = 0;
                    break;
                }
                else if(rcode2 != 0) {
                    *rcode = 0;
                    break;
                }

                BOOL enable_break = runinfo->enable_break;
                runinfo->enable_break = TRUE;
                *rcode = run(runinfo, w->contents, "while command", nextout, nextin, nexterr, FALSE);
                runinfo->enable_break = enable_break;

                if(*runinfo->break_) {
                    *runinfo->break_ = FALSE;
                    break;
                }
                else if(runinfo->enable_return && *runinfo->return_) {
                    return TRUE;
                }
                else if(*rcode < 0) {
                    return FALSE;
                }
                else if(*rcode == SIGINT) {
                    break;
                }
            }
            }
            break;

        case kBreak:
            if(vector_size(argv) == 1) {
                *runinfo->break_ = TRUE;
                *rcode = 0;
                return TRUE;
            }
            else if(vector_size(argv) > 1) {
                *runinfo->break_ = TRUE;
                *rcode = atoi(string_c_str(vector_item(argv, 1)));
                return TRUE;
            }
            break;

        case kTry: {
            if(vector_size(blocks) == 2 && vector_size(argv) >= 1) {
                sBlock* loop_block = vector_item(blocks, 0);
                sStatments* loop = loop_block->mStatments;

                int rcode2 = run(runinfo, loop, title, nextout, nextin, nexterr, TRUE);

                if(runinfo->enable_break && *runinfo->break_) {
                    *rcode = rcode2;
                    return TRUE;
                }
                else if(runinfo->enable_return && *runinfo->return_) {
                    *rcode = rcode2;
                    return TRUE;
                }
                else if(rcode2 == 0) {
                    *rcode = 0;
                }
                else {
                    sBlock* loop2_block = vector_item(blocks, 1);
                    sStatments* loop2 = loop2_block->mStatments;

                    *rcode = run(runinfo, loop2, "try command", nextout , nextin, nexterr, FALSE);

                    if(runinfo->enable_break && *runinfo->break_) {
                        return TRUE;
                    }
                    else if(runinfo->enable_return && *runinfo->return_) {
                        return TRUE;
                    }
                    else if(*rcode < 0) {
                        return FALSE;
                    }
                    else if(*rcode == SIGINT) {
                        break;
                    }
                }
            }
            }
            break;

        case kEnvSpace: {
            if(vector_size(blocks) == 1) {
                int i;
                for(i=1; i<vector_size(argv); i++) {
                    char* p = string_c_str(vector_item(argv, i));

                    if(strstr(p, "=")) {
                        string_obj* name = STRING_NEW("");
                        while(*p != '=') {
                            string_push_back2(name, *p);
                            p++;
                        }
                        p++;
                        string_obj* value = STRING_NEW(p);

                        vector_add(runinfo->envs, name);
                        vector_add(runinfo->envs, value);
                    }
                }

                sBlock* block = vector_item(blocks, 0);
                sStatments* statments = block->mStatments;
                char* fname = MALLOC(strlen(sname) + 32);
                snprintf(fname, strlen(sname) + 32, "%s %d: env", sname, sline);
                *rcode = run(runinfo, statments, fname, nextout , nextin, nexterr ,FALSE);

                FREE(fname);

                if(runinfo->enable_break && *runinfo->break_) {
                    return TRUE;
                }
                else if(runinfo->enable_return && *runinfo->return_) {
                    return TRUE;
                }
                else if(*rcode < 0) {
                    return FALSE;
                }
            }
            }
            break;

        case kExit: {
            BOOL force = FALSE;
            int i;
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv, i));
                // exit although jobs exist
                // ֤ĤäƤƤ⽪λ
                if(strcmp(arg, "-f") == 0)
                {
                    force = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }
            if(force) {
                saphire_kill_all_jobs();
                if(vector_size(argv) == 2) {
                    gKitutukiExit = atoi(string_c_str(vector_item(argv, 1)));
                }
                else {
                    gKitutukiExit = 0;
                }

                err_msg("exited", sname, sline);
                *rcode = 0;

                return FALSE;
            }
            else {
                if(vector_size(gJobs) > 0) {
                    err_msg("jobs exist", sname, sline);
                    return FALSE;
                }
                if(vector_size(argv) == 2) {
                    gKitutukiExit = atoi(string_c_str(vector_item(argv, 1)));
                }
                else {
                    gKitutukiExit = 0;
                }

                err_msg("exited", sname, sline);
                *rcode = 0;

                return FALSE;
            }
            }
            break;

        case kIf: {
            *rcode = 0;

            sIf* if_ = (sIf*)command->mExtra;

            /// if, elif ///
            int k;
            for(k=0; k<vector_size(if_->joukensiki_list); k++) {
                sStatments* joukensiki 
                        = vector_item(if_->joukensiki_list, k);
                int rcode2 = run(runinfo, joukensiki, title , nextout, nextin, nexterr, FALSE);

                if(runinfo->enable_break && *runinfo->break_) {
                    *rcode = rcode2;
                    return TRUE;
                }
                else if(runinfo->enable_return && *runinfo->return_) {
                    *rcode = rcode2;
                    return TRUE;
                }
                else if(rcode2 == 0) {
                    sStatments* contents 
                            = vector_item(if_->contents_list, k);
                    *rcode = run(runinfo, contents, title, nextout, nextin , nexterr,  FALSE);
                    if(runinfo->enable_break && *runinfo->break_) {
                        return TRUE;
                    }
                    else if(runinfo->enable_return && *runinfo->return_) {
                        return TRUE;
                    }
                    else if(*rcode < 0) {
                        return FALSE;
                    }
                    goto if_end;
                }
                else if(rcode2 < 0) {
                    *rcode = rcode2;
                    return FALSE;
                }
            }

            /// else ///
            if(vector_size(if_->contents_list) 
                    > vector_size(if_->joukensiki_list)) 
            {
                sStatments* contents = vector_item(if_->contents_list, k);
                *rcode = run(runinfo, contents, title, nextout, nextin , nexterr, FALSE);
                if(runinfo->enable_break && *runinfo->break_) {
                    return TRUE;
                }
                else if(runinfo->enable_return && *runinfo->return_) {
                    return TRUE;
                }
                else if(*rcode < 0) {
                    return FALSE;
                }
            }
if_end:
            null_fun();
            }
            break;

        case kSplit: {
            BOOL ignore_case = FALSE;
            BOOL multiline = FALSE;
            enum eKanjiCode code = gKanjiCode;
            enum eLineField lf = gLineField;
            string_obj* field2 = STRING_NEW("\t");
            int i;
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv, i));
                // ignore case
                // ѻʸʸ̵뤹
                if(strcmp(arg, "-i") == 0)
                {
                    ignore_case = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // set on field character
                // ʸδ֤ʸ
                else if(strcmp(arg, "-f") == 0 
                    && i+1 < vector_size(argv)) 
                {
                    string_put(field2 
                         , string_c_str(vector_item(argv, i+1)));
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // multiline
                // ʣԤˤޤɽ
                else if(strcmp(arg, "-m") == 0)
                {
                    multiline = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // take a STDIN pipe
                // ɸϤ
                else if(strcmp(arg, "-I") == 0) {
                    input = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // assume data as Shift JIS
                // ǡSjis󥳡ɤȤư
                else if(strcmp(arg, "-s") == 0) {
                    code = kSjis;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // assume data as Eucjp
                // ǡEucjp󥳡ɤȤư
                else if(strcmp(arg, "-e") == 0) {
                    code = kEucjp;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // assume data as Utf-8
                // ǡUtf-8󥳡ɤȤư
                else if(strcmp(arg, "-w") == 0) {
                    code = kUtf8;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // assume data as ASCII code
                // ǡASCIIǡȤư
                else if(strcmp(arg, "-b") == 0) {
                    code = kByte;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as CRLF
                // ԥɤCRLFȤư
                else if(strcmp(arg, "-Lw") == 0) {
                    lf = kCRLF;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as CR
                // ԥɤCRȤư
                else if(strcmp(arg, "-Lm") == 0) {
                    lf = kCR;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as LF
                // ԥɤLFȤư
                else if(strcmp(arg, "-Lu") == 0) {
                    lf = kLF;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as Bel
                // ԥɤBelȤư
                else if(strcmp(arg, "-La") == 0) {
                    lf = kBel;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            string_obj* field;
            if(lf == kCRLF) {
                field = STRING_NEW("\r\n");
            } 
            else if(lf == kLF) {
                field = STRING_NEW("\n");
            }
            else if(lf == kCR) {
                field = STRING_NEW("\r");
            }
            else {
                field = STRING_NEW("\a");
            }

            if(!statment_tree_internal_commands_split(nextout, field, multiline, ignore_case, sname, sline, code, lf, input, argv, nextin, rcode, field2)) {
                string_delete(field);
                string_delete(field2);
                return FALSE;
            }

            string_delete(field);
            string_delete(field2);

            }
            break;

        case kAdd: {
            BOOL flg_n = FALSE;
            int n;
            BOOL flg_l = FALSE;
            int l;
            enum eKanjiCode code = gKanjiCode;
            enum eLineField lf = gLineField;

            int k;
            for(k=0; k<vector_size(argv); k++) {
                char* arg = string_c_str(vector_item(argv, k));

                // add at Nth character
                // nʸܤ
                if(strcmp(arg, "-n") == 0 && k+1 < vector_size(argv)) {
                    flg_n = TRUE;
                    n = atoi(string_c_str(vector_item(argv, k+1)));
                    string_delete(vector_item(argv, k));
                    vector_erase(argv, k);
                    string_delete(vector_item(argv, k));
                    vector_erase(argv, k);
                    k--;
                    continue;
                }
                // add at Nth line
                // NԤ˲ä
                else if(strcmp(arg, "-L") == 0 && k+1 < vector_size(argv)) {
                    flg_l = TRUE;
                    l = atoi(string_c_str(vector_item(argv, k+1)));
                    string_delete(vector_item(argv, k));
                    vector_erase(argv, k);
                    string_delete(vector_item(argv, k));
                    vector_erase(argv, k);
                    k--;
                    continue;
                }
                // assume data as ASCII code
                // ǡASCIIǡȤư
                else if(strcmp(arg, "-b") == 0) {
                    code = kByte;
                    string_delete(vector_item(argv, k));
                    vector_erase(argv, k);
                    k--;
                    continue;
                }
                // assume data as Shift JIS
                // ǡSjis󥳡ɤȤư
                else if(strcmp(arg, "-s") == 0) {
                    code = kSjis;
                    string_delete(vector_item(argv, k));
                    vector_erase(argv, k);
                    k--;
                    continue;
                }
                // assume data as Eucjp
                // ǡEucjp󥳡ɤȤư
                else if(strcmp(arg, "-e") == 0) {
                    code = kEucjp;
                    string_delete(vector_item(argv, k));
                    vector_erase(argv, k);
                    k--;
                    continue;
                }
                // assume data as Utf-8
                // ǡUtf-8󥳡ɤȤư
                else if(strcmp(arg, "-w") == 0) {
                    code = kUtf8;
                    string_delete(vector_item(argv, k));
                    vector_erase(argv, k);
                    k--;
                    continue;
                }
                // treat line field as CR
                // ԥɤCRȤư
                else if(strcmp(arg, "-Lm") == 0) {
                    lf = kCR;
                    string_delete(vector_item(argv, k));
                    vector_erase(argv, k);
                    k--;
                    continue;
                }
                // treat line field as LF
                // ԥɤLFȤư
                else if(strcmp(arg, "-Lu") == 0) {
                    lf = kLF;
                    string_delete(vector_item(argv, k));
                    vector_erase(argv, k);
                    k--;
                    continue;
                }
                // treat line field as Bel
                // ԥɤBelȤư
                else if(strcmp(arg, "-La") == 0) {
                    lf = kBel;
                    string_delete(vector_item(argv, k));
                    vector_erase(argv, k);
                    k--;
                    continue;
                }
                // treat line field as CRLF
                // ԥɤCRLFȤư
                else if(strcmp(arg, "-Lw") == 0) {
                    lf = kCRLF;
                    string_delete(vector_item(argv, k));
                    vector_erase(argv, k);
                    k--;
                    continue;
                }
            }

            string_obj* str_ = STRING_NEW("");
            if(vector_size(blocks) >= 1) {
                int j;
                for(j=0; j<vector_size(blocks); j++) {
                    sWFd* nextout2 = WFD_NEW(-1);
                    sBlock* block = vector_item(blocks, j);
                    sStatments* statments = block->mStatments;
                    char* fname = MALLOC(strlen(sname) + 32);
                    snprintf(fname, strlen(sname) + 32, "%s %d: add", sname, sline);
                    *rcode = run(runinfo, statments, fname, nextout2 , nextin, nexterr, FALSE);
                    FREE(fname);

                    if(!string_push_back_cancelable(str_, nextout2->mBuffer))
                    {
                        sWFd_delete(nextout2);
                        string_delete(str_);
                        return FALSE;
                    }

                    sWFd_delete(nextout2);

                    if(runinfo->enable_break && *runinfo->break_) {
                        string_delete(str_);
                        return TRUE;
                    }
                    else if(runinfo->enable_return && *runinfo->return_) {
                        string_delete(str_);
                        return TRUE;
                    }
                    else if(*rcode < 0) {
                        string_delete(str_);
                        return FALSE;
                    }
                }
            }
            else if(vector_size(argv) >= 2) {
                int j;
                for(j=1; j<vector_size(argv); j++) {
                    string_push_back(str_, string_c_str(vector_item(argv, j)));
                }
            }
            else {
                string_delete(str_);
                return TRUE;
            }

            if(flg_l) {
                vector_obj* v = VECTOR_NEW(100);

                while(1) {
                    if(gKitutukiSigInt) {
                        gKitutukiSigInt = FALSE;
                        err_msg("interrupt c", sname, sline);
                        *rcode = 1;
                        string_delete(str_);
                        int i;
                        for(i=0; i<vector_size(v); i++) {
                            string_delete(vector_item(v, i));
                        }
                        vector_delete(v);
                        return FALSE;
                    }
                    string_obj* line = STRING_NEW("");
                    int ret = statment_tree_internal_commands_read_nextin_oneline(nextin, line, lf);
                    if(ret == -1) {
                        err_msg("interrupt d", sname, sline);
                        string_delete(line);
                        string_delete(str_);
                        int i;
                        for(i=0; i<vector_size(v); i++) {
                            string_delete(vector_item(v, i));
                        }
                        vector_delete(v);
                        return FALSE;
                    }
                    else if(ret == 1) {
                        string_delete(line);
                        break;
                    }

                    vector_add(v, line);
                }

                if(l < 0) {
                    l+=vector_size(v)+1;
                }
                if(l < 0) {
                    l = 0;
                }
                if(l > vector_size(v)) {
                    l = vector_size(v);
                }

                if(l < vector_size(v)) {
                    int k;
                    for(k=0; k<l; k++) {
                        char* str = string_c_str(vector_item(v, k));

                        if(!statment_tree_internal_commands_write_nextout(nextout, str))
                        {
                            err_msg("singal interrupt", sname, sline);
                            string_delete(str_);
                            int i;
                            for(i=0; i<vector_size(v); i++) {
                                string_delete(vector_item(v, i));
                            }
                            vector_delete(v);
                            return FALSE;
                        }
                    }

                    if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(str_)))
                    {
                        err_msg("singal interrupt", sname, sline);
                        string_delete(str_);
                        int i;
                        for(i=0; i<vector_size(v); i++) {
                            string_delete(vector_item(v, i));
                        }
                        vector_delete(v);
                        return FALSE;
                    }

                    for(k=l; k<vector_size(v); k++) {
                        char* str = string_c_str(vector_item(v, k));

                        if(!statment_tree_internal_commands_write_nextout(nextout, str))
                        {
                            err_msg("singal interrupt", sname, sline);
                            string_delete(str_);
                            int i;
                            for(i=0; i<vector_size(v); i++) {
                                string_delete(vector_item(v, i));
                            }
                            vector_delete(v);
                            return FALSE;
                        }
                    }

                    *rcode = 0;
                }
                else {
                    int k;
                    for(k=0; k<vector_size(v); k++) {
                        char* str = string_c_str(vector_item(v, k));

                        if(!statment_tree_internal_commands_write_nextout(nextout, str))
                        {
                            err_msg("singal interrupt", sname, sline);
                            string_delete(str_);
                            int i;
                            for(i=0; i<vector_size(v); i++) {
                                string_delete(vector_item(v, i));
                            }
                            vector_delete(v);
                            return FALSE;
                        }
                    }
                    if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(str_)))
                    {
                        err_msg("singal interrupt", sname, sline);
                        string_delete(str_);
                        int i;
                        for(i=0; i<vector_size(v); i++) {
                            string_delete(vector_item(v, i));
                        }
                        vector_delete(v);
                        return FALSE;
                    }

                    *rcode = 0;
                }

                int i;
                for(i=0; i<vector_size(v); i++) {
                    string_delete(vector_item(v, i));
                }
                vector_delete(v);
            }
            else if(flg_n) {
                string_obj* str = STRING_NEW("");

                int ret = statment_tree_internal_commands_read_nextin(nextin, str);
                if(ret < 0) 
                {
                    err_msg("interrupt", sname, sline);
                    string_delete(str);
                    string_delete(str_);
                    return FALSE;
                }
                else if(ret == 1) {
                    *rcode = 1;
                    string_delete(str_);
                    string_delete(str);
                    break;
                }
                else
                {
                    char* str2 = string_c_str(str_);
                    if(n < 0) {
                        n = str_kanjilen(code, string_c_str(str)) + n + 1;
                    }

                    if(n < 0 || n > str_kanjilen(code, string_c_str(str))) 
                    {
                        *rcode = 1;
                        string_delete(str_);
                        string_delete(str);
                        break;
                    }

                    int m = str_kanjipos2pointer(code, string_c_str(str), n) - string_c_str(str);
                    string_insert(str, m, str2);

                    if(!statment_tree_internal_commands_write_nextout(nextout,  string_c_str(str)))
                    {
                        err_msg("singal interrupt", sname, sline);
                        string_delete(str_);
                        string_delete(str);
                        return FALSE;
                    }
                    *rcode = 0;
                }

                string_delete(str);
            }
            else {
                string_obj* str = STRING_NEW("");

                int ret = statment_tree_internal_commands_read_nextin(nextin, str);
                if(ret < 0)
                {
                    err_msg("interrupt", sname, sline);
                    string_delete(str);
                    string_delete(str_);
                    return FALSE;
                }
                else if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    string_delete(str_);
                    break;
                }
                else {
                    char* str2 = string_c_str(str_);

                    if(!string_push_back_cancelable(str, str2))
                    {
                        err_msg("signal interrupt", sname, sline);
                        string_delete(str);
                        string_delete(str_);
                        return FALSE;
                    }

                    if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(str)))
                    {
                        err_msg("signal interrupt", sname, sline);
                        string_delete(str);
                        string_delete(str_);
                        return FALSE;
                    }

                    *rcode = 0;
                }

                string_delete(str);
            }

            string_delete(str_);
            }
            break;

        case kDel: {
            BOOL flg_n = FALSE;
            int n;
            enum eKanjiCode code = gKanjiCode;
            BOOL flg_l = FALSE;
            int L;
            enum eLineField lf = gLineField;

            int l;
            for(l=0; l<vector_size(argv); l++) {
                char* arg = string_c_str(vector_item(argv, l));

                // add at Nth character
                // nʸܤ
                if(strcmp(arg, "-n") == 0 && l+1 < vector_size(argv)) {
                    flg_n = TRUE;
                    n = atoi(string_c_str(vector_item(argv, l+1)));
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // del Nth line
                // NԤ
                else if(strcmp(arg, "-L") == 0 && l+1 < vector_size(argv)) {
                    flg_l = TRUE;
                    L = atoi(string_c_str(vector_item(argv, l+1)));
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // assume data as ASCII code
                // ǡASCIIǡȤư
                else if(strcmp(arg, "-b") == 0) {
                    code = kByte;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // assume data as Shift JIS
                // ǡSjis󥳡ɤȤư
                else if(strcmp(arg, "-s") == 0) {
                    code = kSjis;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // assume data as Eucjp
                // ǡEucjp󥳡ɤȤư
                else if(strcmp(arg, "-e") == 0) {
                    code = kEucjp;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // assume data as Utf-8
                // ǡUtf-8󥳡ɤȤư
                else if(strcmp(arg, "-w") == 0) {
                    code = kUtf8;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // treat line field as CRLF
                // ԥɤCRLFȤư
                else if(strcmp(arg, "-Lw") == 0) {
                    lf = kCRLF;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // treat line field as CR
                // ԥɤCRȤư
                else if(strcmp(arg, "-Lm") == 0) {
                    lf = kCR;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // treat line field as LF
                // ԥɤLFȤư
                else if(strcmp(arg, "-Lu") == 0) {
                    lf = kLF;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // treat line field as Bel
                // ԥɤBelȤư
                else if(strcmp(arg, "-La") == 0) {
                    lf = kBel;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
            }

            if(flg_l) {
                int N;
                if(vector_size(argv) >= 2) {
                    N = atoi(string_c_str(vector_item(argv, 1)));
                    if(N < 1) {
                        N = 1;
                    }
                }
                else {
                    N = 1;
                }
                vector_obj* v = VECTOR_NEW(100);

                while(1) {
                    if(gKitutukiSigInt) {
                        gKitutukiSigInt = FALSE;
                        err_msg("interrupt", sname, sline);
                        *rcode = 1;
                        int i;
                        for(i=0; i<vector_size(v); i++) {
                            string_delete(vector_item(v, i));
                        }
                        vector_delete(v);
                        return FALSE;
                    }
                    string_obj* line = STRING_NEW("");
                    int ret = statment_tree_internal_commands_read_nextin_oneline(nextin, line, lf);
                    if(ret == -1) {
                        err_msg("interrupt", sname, sline);
                        int i;
                        for(i=0; i<vector_size(v); i++) {
                            string_delete(vector_item(v, i));
                        }
                        vector_delete(v);
                        return FALSE;
                    }
                    else if(ret == 1) { // EOF
                        string_delete(line);
                        break;
                    }

                    vector_add(v, line);
                }

                if(L < 0) {
                    L+=vector_size(v);
                }
                if(L < 0 || L >= vector_size(v)) {
                    *rcode = 1;

                    int k;
                    for(k=0; k<vector_size(v); k++) {
                        char* str = string_c_str(vector_item(v, k));

                        if(!statment_tree_internal_commands_write_nextout(nextout, str))
                        {
                            err_msg("singal interrupt", sname, sline);
                            int i;
                            for(i=0; i<vector_size(v); i++) {
                                string_delete(vector_item(v, i));
                            }
                            vector_delete(v);
                            return FALSE;
                        }
                    }

                    int i;
                    for(i=0; i<vector_size(v); i++) {
                        string_delete(vector_item(v, i));
                    }
                    vector_delete(v);
                    break;
                }

                if(L < vector_size(v)) {
                    int k;
                    for(k=0; k<L; k++) {
                        char* str = string_c_str(vector_item(v, k));

                        if(!statment_tree_internal_commands_write_nextout(nextout, str))
                        {
                            err_msg("singal interrupt", sname, sline);
                            int i;
                            for(i=0; i<vector_size(v); i++) {
                                string_delete(vector_item(v, i));
                            }
                            vector_delete(v);
                            return FALSE;
                        }
                    }

                    for(k=L + N; k<vector_size(v); k++) {
                        char* str = string_c_str(vector_item(v, k));

                        if(!statment_tree_internal_commands_write_nextout(nextout, str))
                        {
                            err_msg("singal interrupt", sname, sline);
                            int i;
                            for(i=0; i<vector_size(v); i++) {
                                string_delete(vector_item(v, i));
                            }
                            vector_delete(v);
                            return FALSE;
                        }
                    }

                    *rcode = 0;
                }

                int i;
                for(i=0; i<vector_size(v); i++) {
                    string_delete(vector_item(v, i));
                }
                vector_delete(v);
            }
            else if(flg_n) {
                string_obj* str = STRING_NEW("");

                int ret = statment_tree_internal_commands_read_nextin(nextin, str);
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    break;
                }
                else if(ret == -1)
                {
                    err_msg("interrupt", sname, sline);
                    string_delete(str);
                    return FALSE;
                }
                else {
                    int num;
                    if(vector_size(argv) >= 2) {
                        char* arg1 = string_c_str(vector_item(argv, 1));
                        num = atoi(arg1);
                    }
                    else {
                        num = 1;
                    }

                    if(n < 0) {
                        n = str_kanjilen(code, string_c_str(str)) + n;
                    }

                    if(n < 0 || n > str_kanjilen(code, string_c_str(str))) {
                        *rcode = 1;
                        string_delete(str);
                        break;
                    }

                    int m = str_kanjipos2pointer(code, string_c_str(str), n) - string_c_str(str);
                    int l = str_kanjipos2pointer(code, string_c_str(str), n+num) - string_c_str(str);
                    string_erase(str, m, l-m);

                    if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(str)))
                    {
                        err_msg("signal interrupt", sname, sline);
                        string_delete(str);
                        return FALSE;
                    }
                    *rcode = 0;
                }

                string_delete(str);
            }
            else {
                string_obj* str = STRING_NEW("");

                int ret = statment_tree_internal_commands_read_nextin(nextin, str);
                if(ret == 1)
                {
                    *rcode = 1;
                    string_delete(str);
                    break;
                }
                else if(ret < 0)
                {
                    err_msg("interrupt", sname, sline);
                    string_delete(str);
                    return FALSE;
                }
                else {
                    int num;
                    if(vector_size(argv) >= 2) {
                        char* arg1 = string_c_str(vector_item(argv, 1));
                        num = atoi(arg1);
                    }
                    else {
                        num = 1;
                    }

                    int m = str_kanjipos2pointer(code, string_c_str(str), str_kanjilen(code, string_c_str(str))-num) - string_c_str(str);
                    
                    string_trunc(str, m);

                    if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(str)))
                    {
                        err_msg("signal interrupt", sname, sline);
                        string_delete(str);
                        return FALSE;
                    }

                    *rcode = 0;
                }

                string_delete(str);
            }
            }
            break;

        case kX: {
            int i;
            BOOL line_field = FALSE;
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv,i));
                // when output the variant content, add LF at tail
                // ϤȤԤä
                if(strcmp(arg, "-L") == 0) {
                    line_field = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // take a STDIN pipe
                // ɸϤ
                else if(strcmp(arg, "-I") == 0) 
                {
                    input = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            int count;
            string_obj* str;
            if(vector_size(argv) == 3) {
                str = STRING_NEW(string_c_str(vector_item(argv, 1)));
                count = atoi(string_c_str(vector_item(argv, 2)));
            }
            else if(vector_size(argv) == 2 && input) {
                count = atoi(string_c_str(vector_item(argv, 1)));
                str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str);
                if(ret == 1) {
                    string_delete(str);
                    break;
                }
                else if(ret < 0)
                {
                    err_msg("interrupt", sname, sline);
                    string_delete(str);
                    return FALSE;
                }
            }
            else {
                err_msg("invalid argument with x", sname, sline);
                return FALSE;
            }

            for(i=0; i<count; i++) {
                if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(str)))
                {
                    err_msg("signal interrupt2", sname, sline);
                    string_delete(str);
                    return FALSE;
                }
            }

            if(line_field) {
                if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                {
                    err_msg("singal interrupt", sname, sline);
                    string_delete(str);
                    return FALSE;
                }
            }

            *rcode = 0;

            string_delete(str);
            }
            break;

        case kJoin: {
            int i;
            BOOL bash_quote = FALSE;
            BOOL saphire_quote = FALSE;
            enum eLineField lf = gLineField;
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv, i));
                // take a STDIN pipe
                // ɸϤ
                if(strcmp(arg, "-I") == 0) {
                    input = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // quote character with used by saphire
                // saphireǻȤʸǥȤ
                else if(strcmp(arg, "-q") == 0) {
                    saphire_quote = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // quote character with used by bash
                // bashǻȤʸǥȤ
                else if(strcmp(arg, "-Q") == 0) {
                    bash_quote = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as CR
                // ԥɤCRȤư
                else if(strcmp(arg, "-Lm") == 0) {
                    lf = kCR;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as LF
                // ԥɤLFȤư
                else if(strcmp(arg, "-Lu") == 0) {
                    lf = kLF;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as Bel
                // ԥɤBelȤư
                else if(strcmp(arg, "-La") == 0) {
                    lf = kBel;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as CRLF
                // ԥɤCRLFȤư
                else if(strcmp(arg, "-Lw") == 0) {
                    lf = kCRLF;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            if(input) {
                char* field;
                if(vector_size(argv) == 2) {
                    field = string_c_str(vector_item(argv, 1));
                }
                else {
                    field = " ";
                }

                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str);
                if(ret == 1) {
                    string_delete(str);
                    *rcode = 1;
                    break;
                }
                else if(ret < 0)
                {
                    err_msg("interrupt", sname, sline);
                    string_delete(str);
                    return FALSE;
                }
                else {
                    string_chomp2(str, lf);
                    char* p = string_c_str(str);
                    string_obj* buf = STRING_NEW("");
                    while(*p) {
                        if(gKitutukiSigInt) {
                            err_msg("interrupt", sname, sline);
                            string_delete(buf);
                            string_delete(str);
                            return FALSE;
                        }
                        if(is_line_field2(lf, p)) {
                            if(bash_quote) {
                                string_obj* quoted = STRING_NEW("");
                                bash_get_quoted_fname(string_c_str(buf), quoted);
                                string_put(buf, string_c_str(quoted));
                                string_delete(quoted);
                            }
                            else if(saphire_quote) {
                                string_obj* quoted = STRING_NEW("");
                                saphire_get_quoted_fname(string_c_str(buf), quoted);
                                string_put(buf, string_c_str(quoted));
                                string_delete(quoted);
                            }

                            if(lf == kCRLF) {
                                p+=2;
                            }
                            else {
                                p++;
                            }
                            string_push_back(buf, field);

                            if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(buf)))
                            {
                                err_msg("signal interrupt", sname, sline);
                                string_delete(str);
                                string_delete(buf);
                                return FALSE;
                            }

                            string_put(buf, "");
                        }
                        else {
                            string_push_back2(buf, *p++);
                        }
                    }

                    if(strcmp(string_c_str(buf), "") != 0) {
                        if(bash_quote) {
                            string_obj* quoted = STRING_NEW("");
                            bash_get_quoted_fname(string_c_str(buf), quoted);
                            string_put(buf, string_c_str(quoted));

                            string_delete(quoted);
                        }
                        else if(saphire_quote) {
                            string_obj* quoted = STRING_NEW("");
                            saphire_get_quoted_fname(string_c_str(buf), quoted);
                            string_put(buf, string_c_str(quoted));
                            string_delete(quoted);
                        }

                        if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(buf)))
                        {
                            err_msg("signal interrupt", sname, sline);
                            string_delete(str);
                            string_delete(buf);
                            return FALSE;
                        }
                    }

                    if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                    {
                        err_msg("singal interrupt", sname, sline);
                        string_delete(str);
                        string_delete(buf);
                        return FALSE;
                    }

                    *rcode = 0;

                    string_delete(buf);
                }

                string_delete(str);
            }
            else if(vector_size(argv) > 1) {
                char* field;
                if(vector_size(argv) == 2) {
                    field = " ";
                }
                else {
                    field = string_c_str(vector_item(argv, 2));
                }

                char* p = string_c_str(vector_item(argv, 1));
                string_obj* buf = STRING_NEW("");
                while(*p) {
                    if(gKitutukiSigInt) {
                        err_msg("interrupt", sname, sline);
                        string_delete(buf);
                        return FALSE;
                    }
                    if(is_line_field2(lf, p)) {
                        if(lf == kCRLF) {
                            p+=2;
                        }
                        else {
                            p++;
                        }
                        if(bash_quote) {
                            string_obj* quoted = STRING_NEW("");
                            bash_get_quoted_fname(string_c_str(buf), quoted);
                            string_put(buf, string_c_str(quoted));

                            string_delete(quoted);
                        }
                        else if(saphire_quote) {
                            string_obj* quoted = STRING_NEW("");
                            saphire_get_quoted_fname(string_c_str(buf), quoted);
                            string_put(buf, string_c_str(quoted));
                            string_delete(quoted);
                        }
                        string_push_back(buf, field);

                        if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(buf)))
                        {
                            err_msg("signal interrupt", sname, sline);
                            string_delete(buf);
                            return FALSE;
                        }

                        string_put(buf, "");
                    }
                    else {
                        string_push_back2(buf, *p++);
                    }
                }

                if(strcmp(string_c_str(buf), "") != 0) {
                    if(bash_quote) {
                        string_obj* quoted = STRING_NEW("");
                        bash_get_quoted_fname(string_c_str(buf), quoted);
                        string_put(buf, string_c_str(quoted));
                        string_delete(quoted);
                    }
                    else if(saphire_quote) {
                        string_obj* quoted = STRING_NEW("");
                        saphire_get_quoted_fname(string_c_str(buf), quoted);
                        string_put(buf, string_c_str(quoted));
                        string_delete(quoted);
                    }
                    if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(buf)))
                    {
                        err_msg("signal interrupt", sname, sline);
                        string_delete(buf);
                        return FALSE;
                    }
                }

                if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                {
                    err_msg("singal interrupt", sname, sline);
                    string_delete(buf);
                    return FALSE;
                }

                *rcode = 0;

                string_delete(buf);
            }
            }
            break;

        case kRows: {
            int i;

            sLinesArg* larg = MALLOC(sizeof(sLinesArg)*vector_size(argv));
            enum eKanjiCode code = gKanjiCode;
            int larg_num = 0;
            BOOL terminal = FALSE;
            BOOL reverse = FALSE;
            int block_num = 0;

            for(i=1; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv, i));
                string_obj* next_arg;
                if(i+1 < vector_size(argv)) {
                    next_arg = vector_item(argv, i+1);
                }
                else {
                    next_arg = NULL;
                }

                // count with terminal size
                // üʸ礭ǿ
                if(strcmp(arg, "-t") == 0) {
                    terminal = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // assume data as ASCII code
                // ǡASCIIǡȤư
                else if(strcmp(arg, "-b") == 0) {
                    code = kByte;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // assume data as Shift JIS
                // ǡSjis󥳡ɤȤư
                else if(strcmp(arg, "-s") == 0) {
                    code = kSjis;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // assume data as Eucjp
                // ǡEucjp󥳡ɤȤư
                else if(strcmp(arg, "-e") == 0) {
                    code = kEucjp;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // assume data as Utf-8
                // ǡUtf-8󥳡ɤȤư
                else if(strcmp(arg, "-w") == 0) {
                    code = kUtf8;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // take a STDIN pipe
                // ɸϤ
                else if(strcmp(arg, "-I") == 0) {
                    input = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // reverse character
                // ս
                else if(strcmp(arg, "-r") == 0) {
                    reverse = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // multiple
                // ܿ
                else if(arg[0] == 'x') {
                    char* p = arg + 1;
                    char* start = MALLOC(sizeof(arg) + 1);
                    char* n = MALLOC(sizeof(arg) + 1);

                    char* p2 = n;
                    if(*p == '-' || *p >= '0' && *p <= '9') {
                        *p2++ = *p++;
                    }
                    while(*p >= '0' && *p <= '9') {
                        *p2++ = *p++;
                    }
                    *p2 = 0;

                    if(*p == 0) {
                        strcpy(start, "0");
                    }
                    else if(*p == '+') {
                        p++;

                        p2 = start;
                        if(*p == '-' || *p >= '0' && *p <= '9') {
                            *p2++ = *p++;
                        }
                        while(*p >= '0' && *p <= '9') {
                            *p2++ = *p++;
                        }
                        *p2 = 0;
                    }
                    else if(*p == 'b') {
                    }
                    else {
                        err_msg("invalid lines argument", sname, sline);
                        FREE(start);
                        FREE(n);
                        FREE(larg);
                        return FALSE;
                    }

                    /// ΰ֥åʤ ///
                    BOOL found = FALSE;
                    int j;
                    for(j=0; j<vector_size(blocks); j++) {
                        sBlock* block = vector_item(blocks, j);
                        if(block->mCount == i) {
                            found = TRUE;
                            if(*p == 'b') {
                                larg[larg_num].kind = 3;
                            }
                            else {
                                larg[larg_num].kind = 4;
                            }
                            larg[larg_num].statments = block->mStatments;
                            break;
                        }
                    }
                    
                    if(found == FALSE) {
                        larg[larg_num].kind = 3;
                        larg[larg_num].statments = NULL;
                    }

                    larg[larg_num].num1 = atoi(n);

                    if(larg[larg_num].num1 == 0) {
                        err_msg("invalid N number. N is zero", sname, sline);

                        FREE(start);
                        FREE(n);
                        FREE(larg);
                        return FALSE;
                    }
                    larg[larg_num].num2 = atoi(start);
                    larg_num++;

                    FREE(start);
                    FREE(n);
                }
                // multiple
                // ܿ
                else if(arg[0] == '*') {
                    char* p = arg + 1;
                    char* start = MALLOC(sizeof(arg) + 1);
                    char* n = MALLOC(sizeof(arg) + 1);

                    char* p2 = n;
                    if(*p == '-' || *p >= '0' && *p <= '9') {
                        *p2++ = *p++;
                    }
                    while(*p >= '0' && *p <= '9') {
                        *p2++ = *p++;
                    }
                    *p2 = 0;

                    if(*p == 0) {
                        strcpy(start, "0");
                    }
                    else if(*p == '+') {
                        p++;

                        p2 = start;
                        if(*p == '-' || *p >= '0' && *p <= '9') {
                            *p2++ = *p++;
                        }
                        while(*p >= '0' && *p <= '9') {
                            *p2++ = *p++;
                        }
                        *p2 = 0;
                    }
                    else if(*p == 'b') {
                    }
                    else {
                        err_msg("invalid lines argument", sname, sline);
                        FREE(larg);
                        FREE(start);
                        FREE(n);
                        return FALSE;
                    }

                    /// ΰ֥åʤ ///
                    BOOL found = FALSE;
                    int j;
                    for(j=0; j<vector_size(blocks); j++) {
                        sBlock* block = vector_item(blocks, j);
                        if(block->mCount == i) {
                            found = TRUE;
                            if(*p == 'b') {
                                larg[larg_num].kind = 5;
                            }
                            else {
                                larg[larg_num].kind = 6;
                            }
                            larg[larg_num].statments = block->mStatments;
                            break;
                        }
                    }
                    
                    if(found == FALSE) {
                        larg[larg_num].kind = 6;
                        larg[larg_num].statments = NULL;
                    }

                    larg[larg_num].num1 = atoi(n);
                    larg[larg_num].num2 = atoi(start);
                    larg_num++;

                    FREE(start);
                    FREE(n);
                }
                // range
                // ϰ
                else if(strstr(arg, "..")) {
                    char* first = MALLOC(sizeof(arg) + 1);
                    char* last = MALLOC(sizeof(arg) + 1);
                    char* p = arg;

                    char* p2 = first;

                    if(*p == '-'  || *p >= '0' && *p <= '9') {
                        *p2++ = *p++;
                    }

                    while(*p >= '0' && *p <= '9') {
                        *p2++ = *p++;
                    }

                    *p2 = 0;

                    if(*p != '.' || *(p+1) != '.') {
                        err_msg("invalid lines argument", sname, sline);
                        FREE(larg);
                        FREE(first);
                        FREE(last);
                        return FALSE;
                    }
                    p+=2;

                    p2 = last;

                    if(*p == '-'  || *p >= '0' && *p <= '9') {
                        *p2++ = *p++;
                    }

                    while(*p >= '0' && *p <= '9') {
                        *p2++ = *p++;
                    }

                    *p2 = 0;

                    /// ΰ֥åʤ ///
                    BOOL found = FALSE;
                    int j;
                    for(j=0; j<vector_size(blocks); j++) {
                        sBlock* block = vector_item(blocks, j);
                        if(block->mCount == i) {
                            found = TRUE;
                            if(*p == 'b') {
                                larg[larg_num].kind = 2;
                            }
                            else {
                                larg[larg_num].kind = 1;
                            }
                            larg[larg_num].statments = block->mStatments;
                            break;
                        }
                    }
                    
                    if(found == FALSE) {
                        larg[larg_num].kind = 1;
                        larg[larg_num].statments = NULL;
                    }

                    larg[larg_num].num1 = atoi(first);
                    larg[larg_num].num2 = atoi(last);
                    larg_num++;

                    FREE(first);
                    FREE(last);
                }
                else if(arg[0] == '-' || arg[0] >= '0' && arg[0] <= '9') {
                    larg[larg_num].kind = 0;
                    larg[larg_num].num1 = atoi(arg);

                    /// ΰ֥åʤ ///
                    BOOL found = FALSE;
                    int j;
                    for(j=0; j<vector_size(blocks); j++) {
                        sBlock* block = vector_item(blocks, j);
                        if(block->mCount == i) {
                            found = TRUE;
                            larg[larg_num].statments = block->mStatments;
                            break;
                        }
                    }
                    
                    if(found == FALSE) {
                        larg[larg_num].statments = NULL;
                    }
                    larg_num++;
                }
                /// ʸ
                else {
                    larg[larg_num].kind = 7;

                    /// ΰ֥åʤ ///
                    BOOL found = FALSE;
                    int j;
                    for(j=0; j<vector_size(blocks); j++) {
                        sBlock* block = vector_item(blocks, j);
                        if(block->mCount == i) {
                            found = TRUE;
                            larg[larg_num].statments = block->mStatments;
                            break;
                        }
                    }
                    
                    if(found == FALSE) {
                        larg[larg_num].statments = NULL;
                    }
                    larg_num++;
                }
            }

            string_obj* line = STRING_NEW("");

            int ret = statment_tree_internal_commands_read_nextin(nextin, line);
            if(ret == 1) {
                *rcode = 1;
                string_delete(line);
                FREE(larg);
                return TRUE;
            }
            else if(ret == -1) {
                err_msg("interrupt", sname, sline);
                string_delete(line);
                FREE(larg);
                return FALSE;
            }

            if(reverse) {
                if(code == kByte) {
                    char* str2 = string_c_str(line);
                    int len = strlen(str2);
                    char* p = str2 + len -1;

                    char* str3 = MALLOC(len+1);
                    char* p2 = str3;

                    while(p >= str2) {
                        *p2++ = *p--;
                        if(gKitutukiSigInt) {
                            err_msg("interrupt", sname, sline);
                            FREE(str3);
                            return FALSE;
                        }
                    }
                    *p2 = 0;
                    

                    if(!statment_tree_internal_commands_write_nextout(nextout, str3))
                    {
                        err_msg("interrupt", sname, sline);
                        FREE(str3);
                        return FALSE;
                    }

                    *rcode = 0;

                    FREE(str3);
                }
                else if(code == kUtf8) {
                    char* p = string_c_str(line);
                    int len = strlen(p);
                    wchar_t* wcs = MALLOC((len+1)*MB_CUR_MAX);
                    if(mbstowcs(wcs, p, (len+1)*MB_CUR_MAX) < 0) {
                        err_msg("mbstowcs err", sname, sline);
                        string_delete(line);
                        FREE(wcs);
                        FREE(larg);
                        return FALSE;
                    }
                    wchar_t* wcs2 = MALLOC(len*MB_CUR_MAX+1);
                    int i;
                    int j;
                    for(i=wcslen(wcs)-1, j=0; i>=0; i--, j++) {
                        wcs2[j] = wcs[i];
                    }
                    wcs2[j] = 0;

                    char* mbs = MALLOC(len*MB_CUR_MAX+1);
                    if(wcstombs(mbs, wcs2, len*MB_CUR_MAX+1) < 0) {
                        err_msg("wcstombs err", sname, sline);
                        string_delete(line);
                        FREE(larg);
                        FREE(wcs);
                        FREE(wcs2);
                        FREE(mbs);
                        return FALSE;
                    }

                    if(!statment_tree_internal_commands_write_nextout(nextout, mbs))
                    {
                        err_msg("interrupt", sname, sline);
                        string_delete(line);
                        FREE(wcs);
                        FREE(wcs2);
                        FREE(larg);
                        FREE(mbs);
                        return FALSE;
                    }

                    *rcode = 0;

                    FREE(wcs);
                    FREE(wcs2);
                    FREE(mbs);
                }
                else {
                    char* p = string_c_str(line);
                    int len = strlen(p);
                    char* str = MALLOC(len+1);
                    char* p2 = str + len;
                    *p2=0;
                    p2--;

                    while(*p) {
                        if(is_kanji(code, *p)) {
                            *(p2-1) = *p++;
                            *p2 = *p++;
                            p2-=2;
                        }
                        else {
                            *p2-- = *p++;
                        }
                    }

                    if(!statment_tree_internal_commands_write_nextout(nextout, str))
                    {
                        err_msg("interrupt", sname, sline);
                        string_delete(line);
                        FREE(larg);
                        FREE(str);
                        return FALSE;
                    }

                    *rcode = 0;

                    FREE(str);
                }
            }
            else {
                for(i=0; i<larg_num; i++) {
                    switch(larg[i].kind) {
                        case 0: {
                            int n = larg[i].num1;
                            char buf[MB_CUR_MAX + 1];

                            if(n < 0) {
                                n += str_kanjilen(code, string_c_str(line));
                            }

                            if(n < 0) {
                                n = 0;
                            }
                            if(n >= str_kanjilen(code, string_c_str(line))) 
                            {
                                n = str_kanjilen(code, string_c_str(line)) -1;
                            }

                            char* c = str_kanjipos2pointer(code, string_c_str(line), n);
                            char* d = str_kanjipos2pointer(code, string_c_str(line), n+1);
                            memcpy(buf, c, d-c);
                            buf[d-c] = 0;

                            /// ֥åʤ ///
                            if(larg[i].statments) {
                                sRFd* nextin2 = RFD_NEW2(-1, buf);

                                char* fname = MALLOC(strlen(sname) + 32);
                                snprintf(fname, strlen(sname) + 32, "%s %d: eval", sname, sline);
                                *rcode = run(runinfo, larg[i].statments , fname, nextout , nextin2, nexterr, FALSE);
                                FREE(fname);
                                sRFd_delete(nextin2);
                                if(runinfo->enable_break && *runinfo->break_) {
                                    string_delete(line);
                                    FREE(larg);
                                    return TRUE;
                                }
                                else if(runinfo->enable_return && *runinfo->return_) {
                                    string_delete(line);
                                    FREE(larg);
                                    return TRUE;
                                }
                                else if(*rcode < 0) {
                                    string_delete(line);
                                    FREE(larg);
                                    return FALSE;
                                }
                            }
                            else {
                                if(!statment_tree_internal_commands_write_nextout(nextout, buf))
                                {
                                    string_delete(line);
                                    FREE(larg);
                                    return FALSE;
                                }
                                *rcode = 0;
                            }
                            }
                            break;

                        case 1: {
                            int n1 = larg[i].num1;
                            int n2 = larg[i].num2;

                            if(n1 < 0) {
                                n1 += str_kanjilen(code, string_c_str(line));
                            }

                            if(n1 < 0) {
                                n1 = 0;
                            }
                            if(n1 >= str_kanjilen(code, string_c_str(line)))
                            {
                                n1 = str_kanjilen(code, string_c_str(line)) -1;
                            }

                            if(n2 < 0) {
                                n2 += str_kanjilen(code, string_c_str(line));
                            }

                            if(n2 < 0) {
                                n2 = 0;
                            }
                            if(n2 >= str_kanjilen(code, string_c_str(line))) 
                            {
                                n2 = str_kanjilen(code, string_c_str(line)) -1;
                            }

                            if(n1 > n2) {
                                err_msg("invalid range", sname, sline);

                                string_delete(line);
                                FREE(larg);
                                return FALSE;
                            }

                            char buf[MB_CUR_MAX * (n2-n1+1) + 1];

                            char* c = str_kanjipos2pointer(code, string_c_str(line), n1);
                            char* d = str_kanjipos2pointer(code, string_c_str(line), n2+1);
                            memcpy(buf, c, d-c);
                            buf[d-c] = 0;

                            if(larg[i].statments) {
                                char* fname = MALLOC(strlen(sname) + 32);
                                snprintf(fname, strlen(sname) + 32, "%s %d: eval", sname, sline);

                                sRFd* nextin2 = RFD_NEW2(-1, buf);

                                *rcode = run(runinfo, larg[i].statments , fname, nextout , nextin2, nexterr, FALSE);
                                sRFd_delete(nextin2);
                                FREE(fname);
                                if(runinfo->enable_break && *runinfo->break_) {
                                    string_delete(line);
                                    FREE(larg);
                                    return TRUE;
                                }
                                else if(runinfo->enable_return && *runinfo->return_) {
                                    string_delete(line);
                                    FREE(larg);
                                    return TRUE;
                                }
                                else if(*rcode < 0) {
                                    string_delete(line);
                                    FREE(larg);
                                    return FALSE;
                                }

                            }
                            else {
                                if(!statment_tree_internal_commands_write_nextout(nextout, buf))
                                {
                                    string_delete(line);
                                    FREE(larg);
                                    return FALSE;
                                }
                                *rcode = 0;
                            }
                            }
                            break;

                        case 2: {
                            int n1 = larg[i].num1;
                            int n2 = larg[i].num2;

                            if(n1 < 0) {
                                n1 += str_kanjilen(code, string_c_str(line));
                            }

                            if(n2 < 0) {
                                n2 += str_kanjilen(code, string_c_str(line));
                            }

                            if(n1 < 0) {
                                n1 = 0;
                            }
                            if(n1 >= str_kanjilen(code, string_c_str(line)))
                            {
                                n1 = str_kanjilen(code, string_c_str(line)) -1;
                            }

                            if(n2 < 0) {
                                n2 += str_kanjilen(code, string_c_str(line));
                            }

                            if(n2 < 0) {
                                n2 = 0;
                            }
                            if(n2 >= str_kanjilen(code, string_c_str(line))) 
                            {
                                n2 = str_kanjilen(code, string_c_str(line)) -1;
                            }

                            if(n1 > n2) {
                                err_msg("invalid range", sname, sline);

                                string_delete(line);
                                FREE(larg);
                                return FALSE;
                            }

                            if(larg[i].statments) {
                                char* fname = MALLOC(strlen(sname) + 32);
                                snprintf(fname, strlen(sname) + 32, "%s %d: eval", sname, sline);

                                int j;
                                for(j=n1; j<=n2; j++) {
                                    char buf[MB_CUR_MAX * (n2-n1+1) + 1];

                                    char* c = str_kanjipos2pointer(code, string_c_str(line), j);
                                    char* d = str_kanjipos2pointer(code, string_c_str(line), j+1);
                                    memcpy(buf, c, d-c);
                                    buf[d-c] = 0;

                                    sRFd* nextin2 = RFD_NEW2(-1, buf);

                                    *rcode = run(runinfo, larg[i].statments , fname, nextout , nextin2, nexterr, FALSE);

                                    sRFd_delete(nextin2);
                                    if(runinfo->enable_break && *runinfo->break_) {
                                        string_delete(line);
                                        FREE(larg);
                                        return TRUE;
                                    }
                                    else if(runinfo->enable_return && *runinfo->return_) {
                                        string_delete(line);
                                        FREE(larg);
                                        return TRUE;
                                    }
                                    else if(*rcode < 0) {
                                        string_delete(line);
                                        FREE(larg);
                                        return FALSE;
                                    }
                                }

                                FREE(fname);

                            }
                            else {
                                char buf[MB_CUR_MAX * (n2-n1+1) + 1];

                                char* c = str_kanjipos2pointer(code, string_c_str(line), n1);
                                char* d = str_kanjipos2pointer(code, string_c_str(line), n2+1);
                                memcpy(buf, c, d-c);
                                buf[d-c] = 0;

                                if(!statment_tree_internal_commands_write_nextout(nextout, buf))
                                {
                                    string_delete(line);
                                    FREE(larg);
                                    return FALSE;
                                }
                                *rcode = 0;
                            }
                            }
                            break;

                        case 3: {
                            int baisuu = larg[i].num1;
                            int start = larg[i].num2;

                            if(larg[i].statments) {
                                int j;
                                int max = str_kanjilen(code, string_c_str(line));
                                char* fname = MALLOC(strlen(sname) + 32);
                                snprintf(fname, strlen(sname) + 32, "%s %d: eval", sname, sline);

                                for(j=start; j<max; j++) {
                                    char buf[MB_CUR_MAX * 1 + 1];

                                    char* c = str_kanjipos2pointer(code, string_c_str(line), j);
                                    char* d = str_kanjipos2pointer(code, string_c_str(line), j+1);
                                    memcpy(buf, c, d-c);
                                    buf[d-c] = 0;

                                    sRFd* nextin2 = RFD_NEW2(-1, buf);

                                    *rcode = run(runinfo, larg[i].statments , fname, nextout , nextin2, nexterr, FALSE);

                                    sRFd_delete(nextin2);
                                    if(runinfo->enable_break && *runinfo->break_) {
                                        string_delete(line);
                                        FREE(larg);
                                        return TRUE;
                                    }
                                    else if(runinfo->enable_return && *runinfo->return_) {
                                        string_delete(line);
                                        FREE(larg);
                                        return TRUE;
                                    }
                                    else if(*rcode < 0) {
                                        string_delete(line);
                                        FREE(larg);
                                        return FALSE;
                                    }
                                }

                                FREE(fname);
                            }
                            else {
                                if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(line)))
                                {
                                    string_delete(line);
                                    FREE(larg);
                                    return FALSE;
                                }
                                *rcode = 0;
                            }
                            }
                            break;

                        case 4: {
                            int baisuu = larg[i].num1;
                            int start = larg[i].num2;

                            if(larg[i].statments) {
                                int j;
                                int max = str_kanjilen(code, string_c_str(line));
                                char* fname = MALLOC(strlen(sname) + 32);
                                snprintf(fname, strlen(sname) + 32, "%s %d: eval", sname, sline);

                                for(j=start; j<max; j+=baisuu) {
                                    char buf[MB_CUR_MAX * baisuu + 1];

                                    char* c = str_kanjipos2pointer(code, string_c_str(line), j);
                                    char* d = str_kanjipos2pointer(code, string_c_str(line), j+baisuu);
                                    memcpy(buf, c, d-c);
                                    buf[d-c] = 0;

                                    sRFd* nextin2 = RFD_NEW2(-1, buf);

                                    *rcode = run(runinfo, larg[i].statments , fname, nextout , nextin2, nexterr, FALSE);
                                    sRFd_delete(nextin2);

                                    if(runinfo->enable_break && *runinfo->break_) {
                                        string_delete(line);
                                        FREE(larg);
                                        return TRUE;
                                    }
                                    else if(runinfo->enable_return && *runinfo->return_) {
                                        string_delete(line);
                                        FREE(larg);
                                        return TRUE;
                                    }
                                    else if(*rcode < 0) {
                                        string_delete(line);
                                        FREE(larg);
                                        return FALSE;
                                    }
                                }

                                FREE(fname);
                            }
                            else {
                                if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(line)))
                                {
                                    string_delete(line);
                                    return FALSE;
                                }
                                *rcode = 0;
                            }
                            }
                            break;

                        case 5: {
                            int baisuu = larg[i].num1;
                            int start = larg[i].num2;

                            if(larg[i].statments) {
                                int j;
                                int max = str_kanjilen(code, string_c_str(line));
                                char* fname = MALLOC(strlen(sname) + 32);
                                snprintf(fname, strlen(sname) + 32, "%s %d: eval", sname, sline);

                                for(j=start; j<max; j+=baisuu) {
                                    char buf[MB_CUR_MAX * 1 + 1];

                                    char* c = str_kanjipos2pointer(code, string_c_str(line), j);
                                    char* d = str_kanjipos2pointer(code, string_c_str(line), j+1);
                                    memcpy(buf, c, d-c);
                                    buf[d-c] = 0;

                                    sRFd* nextin2 = RFD_NEW2(-1, buf);

                                    *rcode = run(runinfo, larg[i].statments , fname, nextout , nextin2, nexterr, FALSE);

                                    sRFd_delete(nextin2);

                                    if(runinfo->enable_break && *runinfo->break_) {
                                        string_delete(line);
                                        FREE(larg);
                                        return TRUE;
                                    }
                                    else if(runinfo->enable_return && *runinfo->return_) {
                                        string_delete(line);
                                        FREE(larg);
                                        return TRUE;
                                    }
                                    else if(*rcode < 0) {
                                        string_delete(line);
                                        FREE(larg);
                                        return FALSE;
                                    }
                                }

                                FREE(fname);
                            }
                            else {
                                int j;
                                int max = str_kanjilen(code, string_c_str(line));
                                for(j=start; j<max; j+=baisuu) {
                                    char buf[MB_CUR_MAX * 1 + 1];

                                    char* c = str_kanjipos2pointer(code, string_c_str(line), j);
                                    char* d = str_kanjipos2pointer(code, string_c_str(line), j+1);
                                    memcpy(buf, c, d-c);
                                    buf[d-c] = 0;

                                    if(!statment_tree_internal_commands_write_nextout(nextout, buf))
                                    {
                                        string_delete(line);
                                        FREE(larg);
                                        return FALSE;
                                    }
                                }

                                *rcode = 0;
                            }
                            }
                            break;

                        case 6: {
                            int baisuu = larg[i].num1;
                            int start = larg[i].num2;

                            if(larg[i].statments) {
                                int j;
                                int max = str_kanjilen(code, string_c_str(line));
                                string_obj* str = STRING_NEW("");
                                for(j=start; j<max; j+=baisuu) {
                                    char buf[MB_CUR_MAX * 1 + 1];

                                    char* c = str_kanjipos2pointer(code, string_c_str(line), j);
                                    char* d = str_kanjipos2pointer(code, string_c_str(line), j+1);
                                    memcpy(buf, c, d-c);
                                    buf[d-c] = 0;

                                    string_push_back(str, buf);
                                }

                                char* fname = MALLOC(strlen(sname) + 32);
                                snprintf(fname, strlen(sname) + 32, "%s %d: eval", sname, sline);

                                sRFd* nextin2 = RFD_NEW2(-1, string_c_str(str));
                                string_delete(str);

                                *rcode = run(runinfo, larg[i].statments , fname, nextout , nextin2, nexterr, FALSE);

                                sRFd_delete(nextin2);
                                FREE(fname);

                                if(runinfo->enable_break && *runinfo->break_) {
                                    string_delete(line);
                                    FREE(larg);
                                    return TRUE;
                                }
                                else if(runinfo->enable_return && *runinfo->return_) {
                                    FREE(larg);
                                    string_delete(line);
                                    return TRUE;
                                }
                                else if(*rcode < 0) {
                                    string_delete(line);
                                    FREE(larg);
                                    return FALSE;
                                }

                            }
                            else {
                                int j;
                                int max = str_kanjilen(code, string_c_str(line));
                                for(j=start; j<max; j+=baisuu) {
                                    char buf[MB_CUR_MAX * 1 + 1];

                                    char* c = str_kanjipos2pointer(code, string_c_str(line), j);
                                    char* d = str_kanjipos2pointer(code, string_c_str(line), j+1);
                                    memcpy(buf, c, d-c);
                                    buf[d-c] = 0;

                                    if(!statment_tree_internal_commands_write_nextout(nextout, buf))
                                    {
                                        string_delete(line);
                                        FREE(larg);
                                        return FALSE;
                                    }
                                }

                                *rcode = 0;
                            }
                            }
                            break;

                        case 7: {
                            /// ֥åʤ ///
                            if(larg[i].statments) {
                                char* fname = MALLOC(strlen(sname) + 32);
                                snprintf(fname, strlen(sname) + 32, "%s %d: eval", sname, sline);
                                *rcode = run(runinfo, larg[i].statments , fname, nextout , nextin, nexterr, FALSE);
                                FREE(fname);
                                if(runinfo->enable_break && *runinfo->break_) {
                                    string_delete(line);
                                    FREE(larg);
                                    return TRUE;
                                }
                                else if(runinfo->enable_return && *runinfo->return_) {
                                    string_delete(line);
                                    FREE(larg);
                                    return TRUE;
                                }
                                else if(*rcode < 0) {
                                    string_delete(line);
                                    FREE(larg);
                                    return FALSE;
                                }
                            }
                            }
                            break;

                    }
                }
            }

            string_delete(line);

            FREE(larg);

            }
            break;

        case kSelect: {
            int i;
            enum eLineField lf = gLineField;
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv,i));
                // treat line field as CR
                // ԥɤCRȤư
                if(strcmp(arg, "-Lm") == 0) {
                    lf = kCR;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as LF
                // ԥɤLFȤư
                else if(strcmp(arg, "-Lu") == 0) {
                    lf = kLF;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as Bel
                // ԥɤBelȤư
                else if(strcmp(arg, "-La") == 0) {
                    lf = kBel;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as CRLF
                // ԥɤCRLFȤư
                else if(strcmp(arg, "-Lw") == 0) {
                    lf = kCRLF;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            if(vector_size(blocks) >= 1) {
                char* fname = MALLOC(strlen(sname) + 32);
                snprintf(fname, strlen(sname) + 32, "%s %d: each", sname, sline);
                sBlock* block = vector_item(blocks, 0);
                sStatments* statments = block->mStatments;

                string_obj* arg;
                if(vector_size(block->mArgs) >= 1) {
                    arg = vector_item(block->mArgs, 0);
                }
                else {
                    arg = NULL;
                }

                int i = 0;
                while(1) {
                    if(gKitutukiSigInt)  {
                        err_msg("intterrupt", sname, sline);
                        FREE(fname);
                        return FALSE;
                    }
                    string_obj* str = STRING_NEW("");
                    int result = statment_tree_internal_commands_read_nextin_oneline(nextin, str, lf);

                    if(result == -1) {  // CTRL_C
                        err_msg("interrupt", sname, sline);
                        string_delete(str);

                        FREE(fname);
                        return FALSE;
                    }
                    else if(result == 1) { // EOF
                        string_delete(str);
                        break;
                    }

                    if(arg) {
                        char buf[1024];
                        snprintf(buf, 1024, "%d", i);
                        (void)saphire_set_local_var(string_c_str(arg), buf, NULL);
                    }

                    sRFd* nextin2 = RFD_NEW2(-1, string_c_str(str));
                    int rcode2 = run(runinfo, statments , fname, nextout , nextin2, nexterr, FALSE);

                    sRFd_delete(nextin2);

                    if(runinfo->enable_break && *runinfo->break_) {
                        string_delete(str);
                        *rcode = rcode2;
                        FREE(fname);
                        return TRUE;
                    }
                    else if(runinfo->enable_return && *runinfo->return_) {
                        string_delete(str);
                        *rcode = rcode2;
                        FREE(fname);
                        return TRUE;
                    }
                    else if(rcode2 < 0) {
                        string_delete(str);
                        *rcode = rcode2;
                        FREE(fname);
                        return FALSE;
                    }

                    if(rcode2 == 0) {
                        if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(str)))
                        {
                            FREE(fname);
                            string_delete(str);
                            return FALSE;
                        }
                    }
                    string_delete(str);

                    i++;
                }

                FREE(fname);

                *rcode = 0;
            }
            }
            break;

        case kLines: {
            int i;
            BOOL reverse = FALSE;
            enum eLineField lf = gLineField;

            sLinesArg* larg = MALLOC(sizeof(sLinesArg)*vector_size(argv));
            int larg_num = 0;
            int block_num = 0;

            for(i=1; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv, i));
                string_obj* next_arg;
                if(i+1 < vector_size(argv)) {
                    next_arg = vector_item(argv, i+1);
                }
                else {
                    next_arg = NULL;
                }

                // treat line field as CR
                // ԥɤCRȤư
                if(strcmp(arg, "-Lm") == 0) {
                    lf = kCR;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as LF
                // ԥɤLFȤư
                else if(strcmp(arg, "-Lu") == 0) {
                    lf = kLF;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as Bel
                // ԥɤBelȤư
                else if(strcmp(arg, "-La") == 0) {
                    lf = kBel;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as CRLF
                // ԥɤCRLFȤư
                else if(strcmp(arg, "-Lw") == 0) {
                    lf = kCRLF;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // reverse lines
                // ս
                else if(strcmp(arg, "-r") == 0) {
                    reverse = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // multiple
                // ܿ
                else if(arg[0] == 'x') {
                    char* p = arg + 1;
                    char* start = MALLOC(sizeof(arg) + 1);
                    char* n = MALLOC(sizeof(arg) + 1);

                    char* p2 = n;
                    if(*p == '-' || *p >= '0' && *p <= '9') {
                        *p2++ = *p++;
                    }
                    while(*p >= '0' && *p <= '9') {
                        *p2++ = *p++;
                    }
                    *p2 = 0;

                    if(*p == '+') {
                        p++;

                        p2 = start;
                        if(*p == '-' || *p >= '0' && *p <= '9') {
                            *p2++ = *p++;
                        }
                        while(*p >= '0' && *p <= '9') {
                            *p2++ = *p++;
                        }
                        *p2 = 0;
                    }
                    else if(*p == 0) {
                        strcpy(start, "0");
                    }
                    else if(*p == 'b') {
                    }
                    else {
                        err_msg("invalid lines argument", sname, sline);
                        FREE(larg);
                        FREE(start);
                        FREE(n);
                        return FALSE;
                    }

                    /// ΰ֥åʤ ///
                    BOOL found = FALSE;
                    int j;
                    for(j=0; j<vector_size(blocks); j++) {
                        sBlock* block = vector_item(blocks, j);
                        if(block->mCount == i) {
                            found = TRUE;
                            if(*p == 'b') {
                                larg[larg_num].kind = 6;
                            }
                            else {
                                larg[larg_num].kind = 7;
                            }

                            larg[larg_num].statments = block->mStatments;
                            break;
                        }
                    }
                    
                    if(found == FALSE) {
                        larg[larg_num].kind = 8;
                        larg[larg_num].statments = NULL;
                    }

                    larg[larg_num].num1 = atoi(n);
                    larg[larg_num].num2 = atoi(start);
                    larg_num++;

                    FREE(start);
                    FREE(n);
                }
                /// ܿ ///
                else if(arg[0] == '*') {
                    char* p = arg + 1;
                    char* start = MALLOC(sizeof(arg) + 1);
                    char* n = MALLOC(sizeof(arg) + 1);

                    char* p2 = n;
                    if(*p == '-' || *p >= '0' && *p <= '9') {
                        *p2++ = *p++;
                    }
                    while(*p >= '0' && *p <= '9') {
                        *p2++ = *p++;
                    }
                    *p2 = 0;

                    if(*p == '+') {
                        p++;

                        p2 = start;
                        if(*p == '-' || *p >= '0' && *p <= '9') {
                            *p2++ = *p++;
                        }
                        while(*p >= '0' && *p <= '9') {
                            *p2++ = *p++;
                        }
                        *p2 = 0;
                    }
                    else if(*p == 0) {
                        strcpy(start, "0");
                    }
                    else if(*p == 'b') {
                    }
                    else {
                        err_msg("invalid lines argument", sname, sline);
                        FREE(larg);
                        FREE(start);
                        FREE(n);
                        return FALSE;
                    }

                    /// ΰ֥åʤ ///
                    BOOL found = FALSE;
                    int j;
                    for(j=0; j<vector_size(blocks); j++) {
                        sBlock* block = vector_item(blocks, j);
                        if(block->mCount == i) {
                            found = TRUE;
                            
                            if(*p == 'b') {
                                larg[larg_num].kind = 2;
                            }
                            else {
                                larg[larg_num].kind = 5;
                            }
                            larg[larg_num].statments = block->mStatments;
                            break;
                        }
                    }
                    
                    if(found == FALSE) {
                        larg[larg_num].kind = 2;
                        larg[larg_num].statments = NULL;
                    }

                    larg[larg_num].num1 = atoi(n);
                    larg[larg_num].num2 = atoi(start);
                    larg_num++;

                    FREE(start);
                    FREE(n);
                }
                // range
                // ϰ
                else if(strstr(arg, "..")) {
                    char* first = MALLOC(sizeof(arg) + 1);
                    char* last = MALLOC(sizeof(arg) + 1);
                    char* p = arg;
                    char* p2 = first;

                    if(*p == '-'  || *p >= '0' && *p <= '9') {
                        *p2++ = *p++;
                    }

                    while(*p >= '0' && *p <= '9') {
                        *p2++ = *p++;
                    }

                    *p2 = 0;

                    if(*p != '.' || *(p+1) != '.') {
                        err_msg("invalid lines argument", sname, sline);
                        FREE(larg);
                        FREE(first);
                        FREE(last);
                        return FALSE;
                    }
                    p+=2;

                    p2 = last;

                    if(*p == '-'  || *p >= '0' && *p <= '9') {
                        *p2++ = *p++;
                    }

                    while(*p >= '0' && *p <= '9') {
                        *p2++ = *p++;
                    }

                    *p2 = 0;

                    /// ΰ֥åʤ ///
                    BOOL found = FALSE;
                    int j;
                    for(j=0; j<vector_size(blocks); j++) {
                        sBlock* block = vector_item(blocks, j);
                        if(block->mCount == i) {
                            found = TRUE;
                            if(*p == 'b') {
                                larg[larg_num].kind = 1;
                            }
                            else {
                                larg[larg_num].kind = 4;
                            }
                            larg[larg_num].statments = block->mStatments;
                            break;
                        }
                    }
                    
                    if(found == FALSE) {
                        larg[larg_num].kind = 1;
                        larg[larg_num].statments = NULL;
                    }
                    larg[larg_num].num1 = atoi(first);
                    larg[larg_num].num2 = atoi(last);
                    larg_num++;

                    FREE(first);
                    FREE(last);
                }
                /// ͣ
                else if(arg[0] == '-' || arg[0] >= '0' && arg[0] <= '9') {
                    larg[larg_num].kind = 0;
                    larg[larg_num].num1 = atoi(arg);

                    /// ΰ֥åʤ ///
                    BOOL found = FALSE;
                    int j;
                    for(j=0; j<vector_size(blocks); j++) {
                        sBlock* block = vector_item(blocks, j);
                        if(block->mCount == i) {
                            found = TRUE;
                            larg[larg_num].statments = block->mStatments;
                            break;
                        }
                    }
                    
                    if(found == FALSE) {
                        larg[larg_num].statments = NULL;
                    }
                    larg_num++;
                }
                /// ʸ ///
                else {
                    larg[larg_num].kind = 9;

                    /// ΰ֥åʤ ///
                    BOOL found = FALSE;
                    int j;
                    for(j=0; j<vector_size(blocks); j++) {
                        sBlock* block = vector_item(blocks, j);
                        if(block->mCount == i) {
                            found = TRUE;
                            larg[larg_num].statments = block->mStatments;
                            break;
                        }
                    }
                    
                    if(found == FALSE) {
                        larg[larg_num].statments = NULL;
                    }
                    larg_num++;
                }
            }

            vector_obj* v = VECTOR_NEW(100);

            while(1) {
                if(gKitutukiSigInt) {
                    err_msg("interrupt", sname, sline);
                    *rcode = 1;
                    int i;
                    for(i=0; i<vector_size(v); i++) {
                        string_delete(vector_item(v, i));
                    }
                    vector_delete(v);
                    FREE(larg);
                    return FALSE;
                }
                string_obj* line = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin_oneline(nextin, line, lf);
                //string_chomp(line);
                if(ret == -1) {
                    err_msg("interrupt", sname, sline);
                    string_delete(line);
                    int i;
                    for(i=0; i<vector_size(v); i++) {
                        string_delete(vector_item(v, i));
                    }
                    vector_delete(v);
                    FREE(larg);
                    return FALSE;
                }
                else if(ret == 1) {
                    string_delete(line);
                    break;
                }

                vector_add(v, line);
            }

            if(vector_size(v) > 0) {
                /// ȿž ///
                if(reverse) {
                    const int size = vector_size(v);
                    for(i=0; i<size; i++) {
                        char* str = string_c_str(vector_item(v, size-i-1));
                        string_obj* str2 = STRING_NEW(str);
                        string_chomp2(str2, lf);

                        if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(str2)))
                        {
                            string_delete(str2);
                            int i;
                            for(i=0; i<vector_size(v); i++) {
                                string_delete(vector_item(v, i));
                            }
                            FREE(larg);
                            vector_delete(v);
                            return FALSE;
                        }
                        if(!statment_tree_internal_commands_write_lf(nextout,  lf))
                        {
                            err_msg("singal interrupt", sname, sline);
                            string_delete(str2);
                            int i;
                            for(i=0; i<vector_size(v); i++) {
                                string_delete(vector_item(v, i));
                            }
                            vector_delete(v);
                            FREE(larg);
                            return FALSE;
                        }

                        string_delete(str2);
                    }

                    *rcode = 0;
                }
                else {
                    for(i=0; i<larg_num; i++) {

                        switch(larg[i].kind) {
                            case 0: {
                                int n = larg[i].num1;

                                if(n < 0) {
                                    n += vector_size(v);
                                }
                                if(n < 0) {
                                    n = 0;
                                }
                                if(n >= vector_size(v)) {
                                    n = vector_size(v)-1;
                                }

                                string_obj* str = vector_item(v, n);

                                /// ֥åʤ ///
                                if(larg[i].statments) {
                                    char* fname = MALLOC(strlen(sname) + 32);
                                    snprintf(fname, strlen(sname) + 32, "%s %d: eval", sname, sline);
                                    sRFd* nextin2 = RFD_NEW2(-1, string_c_str(str));
                                    *rcode = run(runinfo, larg[i].statments , fname, nextout , nextin2, nexterr, FALSE);

                                    FREE(fname);
                                    sRFd_delete(nextin2);

                                    if(runinfo->enable_break && *runinfo->break_) {
                                        int i;
                                        for(i=0; i<vector_size(v); i++) {
                                            string_delete(vector_item(v, i));
                                        }
                                        vector_delete(v);
                                        FREE(larg);
                                        return TRUE;
                                    }
                                    else if(runinfo->enable_return && *runinfo->return_) {
                                        int i;
                                        for(i=0; i<vector_size(v); i++) {
                                            string_delete(vector_item(v, i));
                                        }
                                        vector_delete(v);
                                        FREE(larg);
                                        return TRUE;
                                    }
                                    else if(*rcode < 0) {
                                        int i;
                                        for(i=0; i<vector_size(v); i++) {
                                            string_delete(vector_item(v, i));
                                        }
                                        vector_delete(v);
                                        FREE(larg);
                                        return FALSE;
                                    }
                                    //gGPipeStat = save_value;
                                }
                                else {
                                    string_obj* str2 = STRING_NEW(string_c_str(str));
                                    string_chomp2(str2, lf);
                                    if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(str2)))
                                    {
                                        string_delete(str2);
                                        int i;
                                        for(i=0; i<vector_size(v); i++) {
                                            string_delete(vector_item(v, i));
                                        }
                                        vector_delete(v);
                                        FREE(larg);
                                        return FALSE;
                                    }
                                    if(!statment_tree_internal_commands_write_lf(nextout,  lf))
                                    {
                                        err_msg("singal interrupt", sname, sline);
                                        string_delete(str2);
                                        int i;
                                        for(i=0; i<vector_size(v); i++) {
                                            string_delete(vector_item(v, i));
                                        }
                                        vector_delete(v);
                                        FREE(larg);
                                        return FALSE;
                                    }

                                    *rcode = 0;
                                    string_delete(str2);
                                }
                                }
                                break;

                            case 1: {
                                int n1 = larg[i].num1;
                                int n2 = larg[i].num2;

                                if(n1 < 0) {
                                    n1+=vector_size(v);
                                }
                                if(n1 < 0) {
                                    n1 = 0;
                                }
                                if(n2 < 0) {
                                    n2+=vector_size(v);
                                }
                                if(n2 < 0) {
                                    n2 = 0;
                                }
                                if(n1 >= vector_size(v)) {
                                    n1 = vector_size(v)-1;
                                }
                                if(n2 >= vector_size(v)) {
                                    n2 = vector_size(v)-1;
                                }

                                if(larg[i].statments) {
                                    char* fname = MALLOC(strlen(sname) + 32);
                                    snprintf(fname, strlen(sname) + 32, "%s %d: eval", sname, sline);

                                    if(n1 < n2) {
                                        int k;
                                        for(k=n1; k<=n2; k++) {
                                            string_obj* str = vector_item(v, k);
                                            sRFd* nextin2 = RFD_NEW2(-1, string_c_str(str));

                                            *rcode = run(runinfo, larg[i].statments , fname, nextout , nextin2, nexterr, FALSE);

                                            sRFd_delete(nextin2);
                                            if(runinfo->enable_break && *runinfo->break_) {
                                                int i;
                                                for(i=0; i<vector_size(v); i++) {
                                                    string_delete(vector_item(v, i));
                                                }
                                                vector_delete(v);
                                                FREE(larg);
                                                return TRUE;
                                            }
                                            else if(runinfo->enable_return && *runinfo->return_) {
                                                int i;
                                                for(i=0; i<vector_size(v); i++) {
                                                    string_delete(vector_item(v, i));
                                                }
                                                vector_delete(v);
                                                FREE(larg);
                                                return TRUE;
                                            }
                                            else if(*rcode < 0) {
                                                int i;
                                                for(i=0; i<vector_size(v); i++) {
                                                    string_delete(vector_item(v, i));
                                                }
                                                vector_delete(v);
                                                FREE(larg);
                                                return FALSE;
                                            }
                                        }
                                    }
                                    else {
                                        int k;
                                        for(k=n1; k>=n2; k--) {
                                            string_obj* str = vector_item(v, k);
                                            sRFd* nextin2 = RFD_NEW2(-1, string_c_str(str));
                                            *rcode = run(runinfo, larg[i].statments , fname, nextout, nextin2, nexterr, FALSE);
                                            if(runinfo->enable_break && *runinfo->break_) {
                                                int i;
                                                for(i=0; i<vector_size(v); i++) {
                                                    string_delete(vector_item(v, i));
                                                }
                                                vector_delete(v);
                                                FREE(larg);
                                                return TRUE;
                                            }
                                            else if(runinfo->enable_return && *runinfo->return_) {
                                                int i;
                                                for(i=0; i<vector_size(v); i++) {
                                                    string_delete(vector_item(v, i));
                                                }
                                                vector_delete(v);
                                                FREE(larg);
                                                return TRUE;
                                            }
                                            else if(*rcode < 0) {
                                                int i;
                                                for(i=0; i<vector_size(v); i++) {
                                                    string_delete(vector_item(v, i));
                                                }
                                                vector_delete(v);
                                                FREE(larg);
                                                return FALSE;
                                            }
                                        }
                                    }

                                    FREE(fname);
                                }
                                else {
                                    if(n1 < n2) {
                                        int k;
                                        for(k=n1; k<=n2; k++) {
                                            string_obj* str = vector_item(v, k);
                                            string_obj* str2 = STRING_NEW(string_c_str(str));
                                            string_chomp2(str2, lf);
                                            if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(str2)))
                                            {
                                                string_delete(str2);
                                                int i;
                                                for(i=0; i<vector_size(v); i++) {
                                                    string_delete(vector_item(v, i));
                                                }
                                                vector_delete(v);
                                                FREE(larg);
                                                return FALSE;
                                            }
                                            if(!statment_tree_internal_commands_write_lf(nextout,  lf))
                                            {
                                                err_msg("singal interrupt", sname, sline);
                                                string_delete(str2);
                                                int i;
                                                for(i=0; i<vector_size(v); i++) {
                                                    string_delete(vector_item(v, i));
                                                }
                                                vector_delete(v);
                                                FREE(larg);
                                                return FALSE;
                                            }

                                            string_delete(str2);
                                        }
                                    }
                                    else {
                                        int k;
                                        for(k=n1; k>=n2; k--) {
                                            string_obj* str = vector_item(v, k);
                                            string_obj* str2 = STRING_NEW(string_c_str(str));
                                            string_chomp2(str2, lf);
                                            if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(str2)))
                                            {
                                                string_delete(str2);
                                                int i;
                                                for(i=0; i<vector_size(v); i++) {
                                                    string_delete(vector_item(v, i));
                                                }
                                                vector_delete(v);

                                                FREE(larg);
                                                return FALSE;
                                            }
                                            if(!statment_tree_internal_commands_write_lf(nextout,  lf))
                                            {
                                                err_msg("singal interrupt", sname, sline);
                                                string_delete(str2);
                                                int i;
                                                for(i=0; i<vector_size(v); i++) {
                                                    string_delete(vector_item(v, i));
                                                }
                                                vector_delete(v);
                                                FREE(larg);
                                                return FALSE;
                                            }

                                            string_delete(str2);
                                        }
                                    }

                                    *rcode = 0;
                                }
                                }
                                break;

                            case 2: {
                                int baisuu = larg[i].num1;
                                int start = larg[i].num2;

                                /// ֥åʤ ///
                                if(larg[i].statments) {
                                    char* fname = MALLOC(strlen(sname) + 32);
                                    snprintf(fname, strlen(sname) + 32, "%s %d: eval", sname, sline);

                                    int k = 0;
                                    while(1) {
                                        int x = k * baisuu + start;

                                        if(x < 0 || x >= vector_size(v)) {
                                            break;
                                        }

                                        string_obj* str = vector_item(v, x);

                                        sRFd* nextin2 = RFD_NEW2(-1, string_c_str(str));

                                        *rcode = run(runinfo, larg[i].statments , fname, nextout , nextin2, nexterr, FALSE);

                                        sRFd_delete(nextin2);

                                        if(runinfo->enable_break && *runinfo->break_) {
                                            int i;
                                            for(i=0; i<vector_size(v); i++) {
                                                string_delete(vector_item(v, i));
                                            }
                                            vector_delete(v);
                                            FREE(larg);
                                            return TRUE;
                                        }
                                        else if(runinfo->enable_return && *runinfo->return_) {
                                            int i;
                                            for(i=0; i<vector_size(v); i++) {
                                                string_delete(vector_item(v, i));
                                            }
                                            vector_delete(v);
                                            FREE(larg);
                                            return TRUE;
                                        }
                                        else if(*rcode < 0) {
                                            int i;
                                            for(i=0; i<vector_size(v); i++) {
                                                string_delete(vector_item(v, i));
                                            }
                                            vector_delete(v);
                                            FREE(larg);
                                            return FALSE;
                                        }


                                        k++;
                                    }

                                    FREE(fname);
                                }
                                else {
                                    int k = 0;
                                    while(1) {
                                        int x = k * baisuu + start;

                                        if(x < 0 || x >= vector_size(v)) {
                                            break;
                                        }

                                        string_obj* str = vector_item(v, x);
                                        string_obj* str2 = STRING_NEW(string_c_str(str));
                                        string_chomp2(str2, lf);

                                        if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(str2)))
                                        {
                                            string_delete(str2);
                                            int i;
                                            for(i=0; i<vector_size(v); i++) {
                                                string_delete(vector_item(v, i));
                                            }
                                            vector_delete(v);
                                            FREE(larg);

                                            return FALSE;
                                        }
                                        if(!statment_tree_internal_commands_write_lf(nextout,  lf))
                                        {
                                            string_delete(str2);
                                            err_msg("singal interrupt", sname, sline);
                                            int i;
                                            for(i=0; i<vector_size(v); i++) {
                                                string_delete(vector_item(v, i));
                                            }
                                            vector_delete(v);
                                            FREE(larg);
                                            return FALSE;
                                        }

                                        k++;

                                        string_delete(str2);
                                    }

                                    *rcode = 0;
                                }
                                }
                                break;

                            case 4: {
                                int n1 = larg[i].num1;
                                int n2 = larg[i].num2;

                                if(n1 < 0) {
                                    n1+=vector_size(v);
                                }
                                if(n1 < 0) {
                                    n1=0;
                                }
                                if(n1 >= vector_size(v)) {
                                    n1=vector_size(v)-1;
                                }
                                if(n2 < 0) {
                                    n2+=vector_size(v);
                                }
                                if(n2 < 0) {
                                    n2=0;
                                }
                                if(n2 >= vector_size(v)) {
                                    n2=vector_size(v)-1;
                                }

                                if(larg[i].statments) {
                                    char* fname = MALLOC(strlen(sname) + 32);
                                    snprintf(fname, strlen(sname) + 32, "%s %d: eval", sname, sline);

                                    if(n1 < n2) {
                                        string_obj* str = STRING_NEW("");
                                        int k;
                                        for(k=n1; k<=n2; k++) {
                                            if(gKitutukiSigInt) {
                                                err_msg("interrupt", sname, sline);
                                                string_delete(str);
                                                FREE(larg);
                                                return FALSE;
                                            }
                                            string_obj* str2 = vector_item(v, k);
                                            string_push_back(str, string_c_str(str2));
                                        }

                                        sRFd* nextin2 = RFD_NEW2(-1, string_c_str(str));
                                        string_delete(str);
                                        *rcode = run(runinfo, larg[i].statments , fname, nextout , nextin2, nexterr, FALSE);

                                        sRFd_delete(nextin2);

                                        if(runinfo->enable_break && *runinfo->break_) {
                                            int i;
                                            for(i=0; i<vector_size(v); i++) {
                                                string_delete(vector_item(v, i));
                                            }
                                            vector_delete(v);
                                            FREE(larg);
                                            return TRUE;
                                        }
                                        else if(runinfo->enable_return && *runinfo->return_) {
                                            int i;
                                            for(i=0; i<vector_size(v); i++) {
                                                string_delete(vector_item(v, i));
                                            }
                                            vector_delete(v);
                                            FREE(larg);
                                            return TRUE;
                                        }
                                        else if(*rcode < 0) {
                                            int i;
                                            for(i=0; i<vector_size(v); i++) {
                                                string_delete(vector_item(v, i));
                                            }
                                            vector_delete(v);
                                            FREE(larg);
                                            return FALSE;
                                        }
                                    }
                                    else {
                                        string_obj* str = STRING_NEW("");

                                        int k;
                                        for(k=n1; k>=n2; k--) {
                                            if(gKitutukiSigInt) {
                                                err_msg("interrupt", sname, sline);
                                                string_delete(str);
                                                int i;
                                                for(i=0; i<vector_size(v); i++) {
                                                    string_delete(vector_item(v, i));
                                                }
                                                vector_delete(v);
                                                FREE(larg);
                                                return FALSE;
                                            }

                                            string_obj* str2 = vector_item(v, k);
                                            string_push_back(str, string_c_str(str2));
                                        }

                                        sRFd* nextin2 = RFD_NEW2(-1, string_c_str(str));
                                        string_delete(str);

                                        *rcode = run(runinfo, larg[i].statments , fname, nextout , nextin2, nexterr, FALSE);

                                        sRFd_delete(nextin2);

                                        if(runinfo->enable_break && *runinfo->break_) {
                                            int i;
                                            for(i=0; i<vector_size(v); i++) {
                                                string_delete(vector_item(v, i));
                                            }
                                            vector_delete(v);
                                            FREE(larg);
                                            return TRUE;
                                        }
                                        else if(runinfo->enable_return && *runinfo->return_) {
                                            int i;
                                            for(i=0; i<vector_size(v); i++) {
                                                string_delete(vector_item(v, i));
                                            }
                                            vector_delete(v);
                                            FREE(larg);
                                            return TRUE;
                                        }
                                        else if(*rcode < 0) {
                                            int i;
                                            for(i=0; i<vector_size(v); i++) {
                                                string_delete(vector_item(v, i));
                                            }
                                            vector_delete(v);
                                            FREE(larg);
                                            return FALSE;
                                        }
                                    }

                                    FREE(fname);
                                }
                                else {
                                    if(n1 < n2) {
                                        int k;
                                        for(k=n1; k<=n2; k++) {
                                            string_obj* str = vector_item(v, k);
                                            string_obj* str2 = STRING_NEW(string_c_str(str));
                                            string_chomp2(str2, lf);
                                            if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(str2)))
                                            {
                                                string_delete(str2);
                                                int i;
                                                for(i=0; i<vector_size(v); i++) {
                                                    string_delete(vector_item(v, i));
                                                }
                                                vector_delete(v);
                                                FREE(larg);

                                                return FALSE;
                                            }
                                            if(!statment_tree_internal_commands_write_lf(nextout,  lf))
                                            {
                                                err_msg("singal interrupt", sname, sline);
                                                string_delete(str2);
                                                int i;
                                                for(i=0; i<vector_size(v); i++) {
                                                    string_delete(vector_item(v, i));
                                                }
                                                vector_delete(v);
                                                FREE(larg);
                                                return FALSE;
                                            }

                                            string_delete(str2);
                                        }
                                    }
                                    else {
                                        int k;
                                        for(k=n1; k>=n2; k--) {
                                            string_obj* str = vector_item(v, k);
                                            string_obj* str2 = STRING_NEW(string_c_str(str));
                                            string_chomp2(str2, lf);
                                            if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(str2)))
                                            {
                                                string_delete(str2);

                                                int i;
                                                for(i=0; i<vector_size(v); i++) {
                                                    string_delete(vector_item(v, i));
                                                }
                                                vector_delete(v);
                                                FREE(larg);
                                                return FALSE;
                                            }
                                            if(!statment_tree_internal_commands_write_lf(nextout,  lf))
                                            {
                                                err_msg("singal interrupt", sname, sline);
                                                string_delete(str2);
                                                int i;
                                                for(i=0; i<vector_size(v); i++) {
                                                    string_delete(vector_item(v, i));
                                                }
                                                vector_delete(v);
                                                FREE(larg);
                                                return FALSE;
                                            }

                                            string_delete(str2);
                                        }
                                    }

                                    *rcode = 0;
                                }
                                }
                                break;

                            case 5: {
                                int baisuu = larg[i].num1;
                                int start = larg[i].num2;

                                /// ֥åʤ ///
                                if(larg[i].statments) {
                                    char* fname = MALLOC(strlen(sname) + 32);
                                    snprintf(fname, strlen(sname) + 32, "%s %d: eval", sname, sline);

                                    string_obj* str = STRING_NEW("");
                                    int k = 0;
                                    while(1) {
                                        int x = k * baisuu + start;

                                        if(x < 0 || x >= vector_size(v)) {
                                            break;
                                        }

                                        string_push_back(str, string_c_str(vector_item(v, x)));


                                        k++;
                                    }

                                    sRFd* nextin2 = RFD_NEW2(-1, string_c_str(str));

                                    string_delete(str);

                                    *rcode = run(runinfo, larg[i].statments , fname, nextout , nextin2, nexterr, FALSE);

                                    sRFd_delete(nextin2);

                                    if(runinfo->enable_break && *runinfo->break_) {
                                        int i;
                                        for(i=0; i<vector_size(v); i++) {
                                            string_delete(vector_item(v, i));
                                        }
                                        vector_delete(v);
                                        FREE(larg);
                                        return TRUE;
                                    }
                                    else if(runinfo->enable_return && *runinfo->return_) {
                                        int i;
                                        for(i=0; i<vector_size(v); i++) {
                                            string_delete(vector_item(v, i));
                                        }
                                        vector_delete(v);
                                        FREE(larg);
                                        return TRUE;
                                    }
                                    else if(*rcode < 0) {
                                        int i;
                                        for(i=0; i<vector_size(v); i++) {
                                            string_delete(vector_item(v, i));
                                        }
                                        vector_delete(v);

                                        FREE(larg);
                                        return FALSE;
                                    }

                                    FREE(fname);
                                }
                                else {
                                    int k = 0;
                                    while(1) {
                                        int x = k * baisuu + start;

                                        if(x < 0 || x >= vector_size(v)) {
                                            break;
                                        }

                                        string_obj* str = vector_item(v, x);
                                        string_obj* str2 = STRING_NEW(string_c_str(str));
                                        string_chomp2(str2, lf);

                                        if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(str2)))
                                        {
                                            string_delete(str2);
                                            int i;
                                            for(i=0; i<vector_size(v); i++) {
                                                string_delete(vector_item(v, i));
                                            }
                                            vector_delete(v);
                                            FREE(larg);

                                            return FALSE;
                                        }
                                        if(!statment_tree_internal_commands_write_lf(nextout,  lf))
                                        {
                                            err_msg("singal interrupt", sname, sline);
                                            string_delete(str2);
                                            int i;
                                            for(i=0; i<vector_size(v); i++) {
                                                string_delete(vector_item(v, i));
                                            }
                                            vector_delete(v);
                                            FREE(larg);
                                            return FALSE;
                                        }

                                        string_delete(str2);

                                        k++;
                                    }

                                    *rcode = 0;
                                }
                                }
                                break;

                            case 6: {
                                int baisuu = larg[i].num1;
                                int start = larg[i].num2;

                                /// ֥åʤ ///
                                if(larg[i].statments) {
                                    char* fname = MALLOC(strlen(sname) + 32);
                                    snprintf(fname, strlen(sname) + 32, "%s %d: eval", sname, sline);

                                    int k = start;
                                    while(k < vector_size(v)) {
                                        string_obj* str = vector_item(v, k);

                                        sRFd* nextin2 = RFD_NEW2(-1, string_c_str(str));

                                        *rcode = run(runinfo, larg[i].statments , fname, nextout , nextin2, nexterr, FALSE);

                                        sRFd_delete(nextin2);

                                        if(runinfo->enable_break && *runinfo->break_) {
                                            int i;
                                            for(i=0; i<vector_size(v); i++) {
                                                string_delete(vector_item(v, i));
                                            }
                                            vector_delete(v);
                                            FREE(larg);
                                            return TRUE;
                                        }
                                        else if(runinfo->enable_return && *runinfo->return_) {
                                            int i;
                                            for(i=0; i<vector_size(v); i++) {
                                                string_delete(vector_item(v, i));
                                            }
                                            vector_delete(v);
                                            FREE(larg);
                                            return TRUE;
                                        }
                                        else if(*rcode < 0) {
                                            int i;
                                            for(i=0; i<vector_size(v); i++) {
                                                string_delete(vector_item(v, i));
                                            }
                                            vector_delete(v);
                                            FREE(larg);

                                            return FALSE;
                                        }

                                        k++;
                                    }

                                    FREE(fname);
                                }
                                else {
                                    int k = start;
                                    while(k < vector_size(v)) {
                                        string_obj* str = vector_item(v, k);
                                        string_obj* str2 = STRING_NEW(string_c_str(str));
                                        string_chomp2(str2, lf);

                                        if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(str2)))
                                        {
                                            string_delete(str2);
                                            int i;
                                            for(i=0; i<vector_size(v); i++) {
                                                string_delete(vector_item(v, i));
                                            }
                                            vector_delete(v);
                                            FREE(larg);

                                            return FALSE;
                                        }
                                        if(!statment_tree_internal_commands_write_lf(nextout,  lf))
                                        {
                                            err_msg("singal interrupt", sname, sline);
                                            string_delete(str2);
                                            int i;
                                            for(i=0; i<vector_size(v); i++) {
                                                string_delete(vector_item(v, i));
                                            }
                                            vector_delete(v);
                                            FREE(larg);
                                            return FALSE;
                                        }

                                        string_delete(str2);

                                        k++;
                                    }

                                    *rcode = 0;
                                }
                                }
                                break;

                            case 7: {
                                int baisuu = larg[i].num1;
                                int start = larg[i].num2;

                                /// ֥åʤ ///
                                if(larg[i].statments) {
                                    char* fname = MALLOC(strlen(sname) + 32);
                                    snprintf(fname, strlen(sname) + 32, "%s %d: eval", sname, sline);

                                    int k = start;
                                    while(k < vector_size(v)) {
                                        string_obj* str = STRING_NEW("");
                                        int l;
                                        for(l=k; l<k+baisuu && l<vector_size(v); l++) {
                                            string_push_back(str, string_c_str(vector_item(v, l)));
                                        }

                                        sRFd* nextin2 = RFD_NEW2(-1, string_c_str(str));

                                        *rcode = run(runinfo, larg[i].statments , fname, nextout , nextin2, nexterr, FALSE);

                                        sRFd_delete(nextin2);

                                        if(runinfo->enable_break && *runinfo->break_) {
                                            string_delete(str);
                                            int i;
                                            for(i=0; i<vector_size(v); i++) {
                                                string_delete(vector_item(v, i));
                                            }
                                            vector_delete(v);
                                            FREE(larg);
                                            return TRUE;
                                        }
                                        else if(runinfo->enable_return && *runinfo->return_) {
                                            string_delete(str);
                                            int i;
                                            for(i=0; i<vector_size(v); i++) {
                                                string_delete(vector_item(v, i));
                                            }
                                            vector_delete(v);
                                            FREE(larg);
                                            return TRUE;
                                        }
                                        else if(*rcode < 0) {
                                            string_delete(str);
                                            int i;
                                            for(i=0; i<vector_size(v); i++) {
                                                string_delete(vector_item(v, i));
                                            }
                                            vector_delete(v);
                                            FREE(larg);

                                            return FALSE;
                                        }

                                        k+=baisuu;

                                        string_delete(str);
                                    }

                                    FREE(fname);
                                }
                                else {
                                    int k = start;
                                    while(k < vector_size(v)) {
                                        string_obj* str = STRING_NEW("");
                                        int l;
                                        for(l=k; l<k+baisuu && l<vector_size(v); l++) {
                                            string_push_back(str, string_c_str(vector_item(v, l)));
                                        }
                                        string_chomp2(str, lf);

                                        if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(str)))
                                        {
                                            string_delete(str);
                                            int i;
                                            for(i=0; i<vector_size(v); i++) {
                                                string_delete(vector_item(v, i));
                                            }
                                            vector_delete(v);
                                            FREE(larg);

                                            return FALSE;
                                        }
                                        if(!statment_tree_internal_commands_write_lf(nextout,  lf))
                                        {
                                            err_msg("singal interrupt", sname, sline);
                                            string_delete(str);
                                            int i;
                                            for(i=0; i<vector_size(v); i++) {
                                                string_delete(vector_item(v, i));
                                            }
                                            vector_delete(v);
                                            FREE(larg);
                                            return FALSE;
                                        }

                                        k+=baisuu;

                                        string_delete(str);
                                    }

                                    *rcode = 0;
                                }
                                }
                                break;

                            case 8: {
                                int start = larg[i].num2;
                                int k = start;
                                while(k < vector_size(v)) {
                                    string_obj* str = vector_item(v, k);
                                    string_obj* str2 = STRING_NEW(string_c_str(str));
                                    string_chomp2(str2, lf);

                                    if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(str2)))
                                    {
                                        string_delete(str2);
                                        int i;
                                        for(i=0; i<vector_size(v); i++) {
                                            string_delete(vector_item(v, i));
                                        }
                                        vector_delete(v);
                                        FREE(larg);

                                        return FALSE;
                                    }
                                    if(!statment_tree_internal_commands_write_lf(nextout,  lf))
                                    {
                                        err_msg("singal interrupt", sname, sline);
                                        string_delete(str2);
                                        int i;
                                        for(i=0; i<vector_size(v); i++) {
                                            string_delete(vector_item(v, i));
                                        }
                                        vector_delete(v);
                                        FREE(larg);
                                        return FALSE;
                                    }

                                    k++;

                                    string_delete(str2);
                                }

                                *rcode = 0;
                                }
                                break;

                            case 9: {
                                /// ֥åʤ ///
                                if(larg[i].statments) {
                                    char* fname = MALLOC(strlen(sname) + 32);
                                    snprintf(fname, strlen(sname) + 32, "%s %d: eval", sname, sline);
                                    *rcode = run(runinfo, larg[i].statments , fname, nextout , nextin, nexterr, FALSE);
                                    if(runinfo->enable_break && *runinfo->break_) {
                                        int i;
                                        for(i=0; i<vector_size(v); i++) {
                                            string_delete(vector_item(v, i));
                                        }
                                        vector_delete(v);
                                        FREE(larg);
                                        return TRUE;
                                    }
                                    else if(runinfo->enable_return && *runinfo->return_) {
                                        int i;
                                        for(i=0; i<vector_size(v); i++) {
                                            string_delete(vector_item(v, i));
                                        }
                                        vector_delete(v);
                                        FREE(larg);
                                        return TRUE;
                                    }
                                    else if(*rcode < 0) {
                                        int i;
                                        for(i=0; i<vector_size(v); i++) {
                                            string_delete(vector_item(v, i));
                                        }
                                        vector_delete(v);
                                        FREE(larg);
                                        return FALSE;
                                    }
                                    //gGPipeStat = save_value;
                                }
                                }
                                break;

                        }
                    }
                }
            }

            for(i=0;i<vector_size(v); i++) {
                string_delete(vector_item(v, i));
            }
            vector_delete(v);

            FREE(larg);

            }
            break;


        case kScan: {
            BOOL ignore_case = FALSE;
            BOOL multiline = FALSE;
            string_obj* field = STRING_NEW("\t");
            BOOL quiet = FALSE;
            enum eKanjiCode code = gKanjiCode;
            enum eLineField lf = gLineField;

            int i;
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv, i));
                // ignore case
                // ѻʸʸ̵뤹
                if(strcmp(arg, "-i") == 0)
                {
                    ignore_case = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // no output
                // ȥץåȤʤ
                else if(strcmp(arg, "-q") == 0)
                {
                    quiet = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // multiline
                // ʣԤˤޤɽ
                else if(strcmp(arg, "-m") == 0)
                {
                    multiline = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // take a STDIN pipe
                // ɸϤ
                else if(strcmp(arg, "-I") == 0)
                {
                    input = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // set on field character
                // ʸδ֤ʸ
                else if(strcmp(arg, "-f") == 0 
                    && i+1 < vector_size(argv)) 
                {
                    string_put(field 
                         , string_c_str(vector_item(argv, i+1)));
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // assume data as Shift JIS
                // ǡSjis󥳡ɤȤư
                else if(strcmp(arg, "-s") == 0) {
                    code = kSjis;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // assume data as Eucjp
                // ǡEucjp󥳡ɤȤư
                else if(strcmp(arg, "-e") == 0) {
                    code = kEucjp;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // assume data as Utf-8
                // ǡUtf-8󥳡ɤȤư
                else if(strcmp(arg, "-w") == 0) {
                    code = kUtf8;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // assume data as ASCII code
                // ǡASCIIǡȤư
                else if(strcmp(arg, "-b") == 0) {
                    code = kByte;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as CRLF
                // ԥɤCRLFȤư
                else if(strcmp(arg, "-Lw") == 0) {
                    lf = kCRLF;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as CR
                // ԥɤCRȤư
                else if(strcmp(arg, "-Lm") == 0) {
                    lf = kCR;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as LF
                // ԥɤLFȤư
                else if(strcmp(arg, "-Lu") == 0) {
                    lf = kLF;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as Bel
                // ԥɤBelȤư
                else if(strcmp(arg, "-La") == 0) {
                    lf = kBel;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            if(multiline) {
                if(!statment_tree_internal_commands_scan(runinfo, argv, field, input, nextout, nextin, rcode, ignore_case, multiline, sname, sline, blocks, nexterr, code, lf)) {
                    string_delete(field);
                    return FALSE;
                }
            }
            else {
                if(!statment_tree_internal_commands_scan_oneline(runinfo, argv, field, input, nextout, nextin, rcode, ignore_case, multiline, sname, sline, blocks, nexterr, code, lf)) {
                    string_delete(field);
                    return FALSE;
                }
            }
            
            if(runinfo->enable_break && *runinfo->break_) {
                string_delete(field);
                return TRUE;
            }
            else if(runinfo->enable_return && *runinfo->return_) {
                string_delete(field);
                return TRUE;
            }

            string_delete(field);
            }
            break;


        case kMatch: {
            BOOL quiet = FALSE;
            BOOL line_field = TRUE;
            BOOL line_num = FALSE;
            BOOL global = FALSE;
            BOOL line_oriented = FALSE;
            BOOL ignore_case = FALSE;
            BOOL multiline = FALSE;
            enum eKanjiCode code = gKanjiCode;
            string_obj* field = STRING_NEW("\t");
            enum eLineField lf = gLineField;
            int i;
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv, i));
                // no output
                // ȥץåȤʤ
                if(strcmp(arg, "-q") == 0)
                {
                    quiet = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // line oriented like grep
                // grepΤ褦˿
                else if(strcmp(arg, "-L") == 0)
                {
                    line_oriented = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // ignore case
                // ѻʸʸ̵뤹
                else if(strcmp(arg, "-i") == 0)
                {
                    ignore_case = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // multiline
                // ʣԤˤޤɽ
                else if(strcmp(arg, "-m") == 0)
                {
                    multiline = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // global
                // global
                else if(strcmp(arg, "-g") == 0)
                {
                    global = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // when output the variant content, don't add LF at tail
                // ϤȤԤäʤ
                else if(strcmp(arg, "-nl") == 0)
                {
                    line_field = FALSE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // output line numbrs
                // ֹɽ
                else if(strcmp(arg, "-n") == 0)
                {
                    line_num = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // take a STDIN pipe
                // ɸϤ
                else if(strcmp(arg, "-I") == 0)
                {
                    input = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // set on field character
                // ʸδ֤ʸ
                else if(strcmp(arg, "-f") == 0 
                    && i+1 < vector_size(argv)) 
                {
                    string_put(field 
                         , string_c_str(vector_item(argv, i+1)));
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // assume data as Shift JIS
                // ǡSjis󥳡ɤȤư
                else if(strcmp(arg, "-s") == 0) {
                    code = kSjis;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // assume data as Eucjp
                // ǡEucjp󥳡ɤȤư
                else if(strcmp(arg, "-e") == 0) {
                    code = kEucjp;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // assume data as Utf-8
                // ǡUtf-8󥳡ɤȤư
                else if(strcmp(arg, "-w") == 0) {
                    code = kUtf8;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // assume data as ASCII code
                // ǡASCIIǡȤư
                else if(strcmp(arg, "-b") == 0) {
                    code = kByte;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as CRLF
                // ԥɤCRLFȤư
                else if(strcmp(arg, "-Lw") == 0) {
                    lf = kCRLF;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as CR
                // ԥɤCRȤư
                else if(strcmp(arg, "-Lm") == 0) {
                    lf = kCR;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as LF
                // ԥɤLFȤư
                else if(strcmp(arg, "-Lu") == 0) {
                    lf = kLF;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as Bel
                // ԥɤBelȤư
                else if(strcmp(arg, "-La") == 0) {
                    lf = kBel;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            if(global) {
                if(multiline) {
                    if(!statment_tree_internal_commands_scan(runinfo, argv, field, input, nextout, nextin, rcode, ignore_case, multiline, sname, sline, blocks, nexterr, code, lf)) {
                        string_delete(field);
                        return FALSE;
                    }
                    
                    if(runinfo->enable_break && *runinfo->break_) {
                        string_delete(field);
                        return TRUE;
                    }
                    else if(runinfo->enable_return && *runinfo->return_) {
                        string_delete(field);
                        return TRUE;
                    }
                }
                else {
                    if(!statment_tree_internal_commands_scan_oneline(runinfo, argv, field, input, nextout, nextin, rcode, ignore_case, multiline, sname, sline, blocks, nexterr, code, lf)) {
                        string_delete(field);
                        return FALSE;
                    }
                    
                    if(runinfo->enable_break && *runinfo->break_) {
                        string_delete(field);
                        return TRUE;
                    }
                    else if(runinfo->enable_return && *runinfo->return_) {
                        string_delete(field);
                        return TRUE;
                    }
                }
            }
            else if(input) {
                int match_count = 0;

                if(vector_size(argv) >= 2) {
                    if(line_oriented) {
                        char* regex = string_c_str(vector_item(argv, 1));
                        char* regex2 = regex;

                        int n = 1;
                        for(;;) {
                            string_obj* str = STRING_NEW("");
                            int ret = statment_tree_internal_commands_read_nextin_oneline(nextin, str, lf);
                            if(ret == -1) {
                                err_msg("interrupt", sname, sline);
                                string_delete(field);
                                string_delete(str);
                                return FALSE;
                            }
                            else if(ret == 1) 
                            {
                                string_delete(str);
                                break;
                            }

                            string_chomp2(str, lf);
                            
                            if(!statment_tree_internal_commands_match(
                                string_c_str(str), regex2, rcode, nextout
                                , !quiet, line_field, line_num, n, field
                                , line_oriented, &match_count
                                , ignore_case
                                , multiline
                                , sname
                                , sline
                                , code
                                , lf
                                ))
                            {
                                string_delete(str);
                                string_delete(field);
                                return FALSE;
                            }

                            n++;

                            string_delete(str);
                        }
                    }
                    else {
                        char* regex = string_c_str(vector_item(argv, 1));
                        char* regex2 = regex;

                        int n = 0;
                        string_obj* str = STRING_NEW("");
                        BOOL ret = statment_tree_internal_commands_read_nextin(nextin, str);
                        if(ret == 1) {
                            string_delete(str);
                            *rcode = 1;
                            break;
                        }
                        else if(ret < 0) {
                            err_msg("interrupt", sname, sline);
                            string_delete(field);
                            string_delete(str);
                            return FALSE;
                        }
                        
                        if(!statment_tree_internal_commands_match(
                            string_c_str(str), regex2, rcode, nextout
                            , !quiet, line_field, line_num, n, field
                            , line_oriented, &match_count, ignore_case
                            , multiline
                            , sname
                            , sline
                            , code
                            , lf
                            ))
                        {
                            string_delete(str);
                            string_delete(field);
                            return FALSE;
                        }

                        string_delete(str);
                    }
                }

                char buf[256];
                snprintf(buf, 256, "%d", match_count);
                (void)saphire_set_local_var("MATCH_COUNT", buf, NULL);
            }
            else {
                int match_count = 0;

                string_obj* str;
                if(vector_size(argv) == 3) {
                    str = STRING_NEW(string_c_str(vector_item(argv, 1)));
                }
                else {
                    break;
                }

                char* str2 = string_c_str(str);

                char* regex = string_c_str(vector_item(argv, 2));
                char* regex2 = regex;

                if(!statment_tree_internal_commands_match(
                    str2, regex2, rcode, nextout, !quiet, line_field
                    , line_num, 1, field, line_oriented, &match_count
                    , ignore_case
                    , multiline
                    , sname
                    , sline
                    , code
                    , lf
                    ))
                {
                    string_delete(field);
                    string_delete(str);
                    return FALSE;
                }


                char buf[256];
                snprintf(buf, 256, "%d", match_count);
                (void)saphire_set_local_var("MATCH_COUNT", buf, NULL);

                string_delete(str);
            }

            string_delete(field);

            }
            break;

        case kSub: {
            BOOL global = FALSE;
            BOOL quiet = FALSE;
            BOOL multiline = FALSE;
            BOOL check = FALSE;
            BOOL ignore_case = FALSE;
            enum eKanjiCode code = gKanjiCode;
            enum eLineField lf = gLineField;
            int i;
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv, i));
                // global
                // global
                if(strcmp(arg, "-g") == 0) {
                    global = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // take a STDIN pipe
                // ɸϤ
                else if(strcmp(arg, "-I") == 0) {
                    input = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // ignore case
                // ѻʸʸ̵뤹
                else if(strcmp(arg, "-i") == 0) {
                    ignore_case = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // multiline
                // ʣԤˤޤɽ
                else if(strcmp(arg, "-m") == 0) {
                    multiline = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // no output
                // ȥץåȤʤ
                else if(strcmp(arg, "-q") == 0) {
                    quiet = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // check with user select
                // å
                else if(strcmp(arg, "-c") == 0) {
                    check = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // assume data as ASCII code
                // ǡASCIIǡȤư
                else if(strcmp(arg, "-b") == 0) {
                    code = kByte;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // assume data as Shift JIS
                // ǡSjis󥳡ɤȤư
                else if(strcmp(arg, "-s") == 0) {
                    code = kSjis;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // assume data as Eucjp
                // ǡEucjp󥳡ɤȤư
                else if(strcmp(arg, "-e") == 0) {
                    code = kEucjp;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // assume data as Utf-8
                // ǡUtf-8󥳡ɤȤư
                else if(strcmp(arg, "-w") == 0) {
                    code = kUtf8;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as CRLF
                // ԥɤCRLFȤư
                else if(strcmp(arg, "-Lw") == 0) {
                    lf = kCRLF;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as CR
                // ԥɤCRȤư
                else if(strcmp(arg, "-Lm") == 0) {
                    lf = kCR;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as LF
                // ԥɤLFȤư
                else if(strcmp(arg, "-Lu") == 0) {
                    lf = kLF;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as Bel
                // ԥɤBelȤư
                else if(strcmp(arg, "-La") == 0) {
                    lf = kBel;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }
            if(multiline || !global) {
                if(!statment_tree_internal_commands_sub(runinfo, global, blocks, quiet, multiline, check, ignore_case, rcode, nextout, sname, sline, nextin, nexterr, code, input, argv))
                {
                    return FALSE;
                }
            }
            else {
                if(!statment_tree_internal_commands_sub_oneline(runinfo, global, blocks, quiet, multiline, check, ignore_case, rcode, nextout, sname, sline, nextin, nexterr, code, input, argv, lf))
                {
                    return FALSE;
                }
            }
            if(runinfo->enable_break && *runinfo->break_) {
                return TRUE;
            }
            else if(runinfo->enable_return && *runinfo->return_) {
                return TRUE;
            }

            }
            break;

        case kGSub: {
            BOOL global = TRUE;
            BOOL quiet = FALSE;
            BOOL multiline = FALSE;
            BOOL check = FALSE;
            BOOL ignore_case = FALSE;
            enum eKanjiCode code = gKanjiCode;
            enum eLineField lf = gLineField;
            int i;
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv, i));
                // take a STDIN pipe
                // ɸϤ
                if(strcmp(arg, "-I") == 0) {
                    input = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // ignore case
                // ѻʸʸ̵뤹
                else if(strcmp(arg, "-i") == 0) {
                    ignore_case = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // multiline
                // ʣԤˤޤɽ
                else if(strcmp(arg, "-m") == 0) {
                    multiline = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // no output
                // ȥץåȤʤ
                else if(strcmp(arg, "-q") == 0) {
                    quiet = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // check with user select
                // å
                else if(strcmp(arg, "-c") == 0) {
                    check = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // assume data as ASCII code
                // ǡASCIIǡȤư
                else if(strcmp(arg, "-b") == 0) {
                    code = kByte;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // assume data as Shift JIS
                // ǡSjis󥳡ɤȤư
                else if(strcmp(arg, "-s") == 0) {
                    code = kSjis;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // assume data as Eucjp
                // ǡEucjp󥳡ɤȤư
                else if(strcmp(arg, "-e") == 0) {
                    code = kEucjp;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // assume data as Utf-8
                // ǡUtf-8󥳡ɤȤư
                else if(strcmp(arg, "-w") == 0) {
                    code = kUtf8;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as CRLF
                // ԥɤCRLFȤư
                else if(strcmp(arg, "-Lw") == 0) {
                    lf = kCRLF;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as CR
                // ԥɤCRȤư
                else if(strcmp(arg, "-Lm") == 0) {
                    lf = kCR;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as LF
                // ԥɤLFȤư
                else if(strcmp(arg, "-Lu") == 0) {
                    lf = kLF;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as Bel
                // ԥɤBelȤư
                else if(strcmp(arg, "-La") == 0) {
                    lf = kBel;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            if(multiline) {
                if(!statment_tree_internal_commands_sub(runinfo, global, blocks, quiet, multiline, check, ignore_case, rcode, nextout, sname, sline, nextin, nexterr, code, input, argv))
                {
                    return FALSE;
                }
            }
            else {
                if(!statment_tree_internal_commands_sub_oneline(runinfo, global, blocks, quiet, multiline, check, ignore_case, rcode, nextout, sname, sline, nextin, nexterr, code, input, argv, lf))
                {
                    return FALSE;
                }
            }
            if(runinfo->enable_break && *runinfo->break_) {
                return TRUE;
            }
            else if(runinfo->enable_return && *runinfo->return_) {
                return TRUE;
            }

            }
            break;

        case kRead: {
            BOOL flg_n = FALSE;
            int n;
            BOOL flg_c = FALSE;
            int c;
            BOOL all = FALSE;
            BOOL preserve = FALSE;
            enum eLineField lf = gLineField;

            int l;
            for(l=0; l<vector_size(argv); l++) {
                char* arg = string_c_str(vector_item(argv, l));

                // read N lines
                // Nɤ߹
                if(strcmp(arg, "-n") == 0 && l+1 < vector_size(argv)) {
                    flg_n = TRUE;
                    n = atoi(string_c_str(vector_item(argv, l+1)));
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // read N characters
                // Nʸɤ߹
                else if(strcmp(arg, "-c") == 0 && l+1 < vector_size(argv)) {
                    flg_c = TRUE;
                    c = atoi(string_c_str(vector_item(argv, l+1)));
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // read all lines
                // ٤Ƥιɤ߹
                else if(strcmp(arg, "-a") == 0) {
                    all = TRUE;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // read but don't move  position
                // ɤ߹ब־Ϲʤ
                else if(strcmp(arg, "-p") == 0) {
                    preserve = TRUE;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // treat line field as CRLF
                // ԥɤCRLFȤư
                else if(strcmp(arg, "-Lw") == 0) {
                    lf = kCRLF;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // treat line field as CR
                // ԥɤCRȤư
                else if(strcmp(arg, "-Lm") == 0) {
                    lf = kCR;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // treat line field as LF
                // ԥɤLFȤư
                else if(strcmp(arg, "-Lu") == 0) {
                    lf = kLF;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
                // treat line field as Bel
                // ԥɤBelȤư
                else if(strcmp(arg, "-La") == 0) {
                    lf = kBel;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
            }

            if(vector_size(argv) == 1) {
                if(all) {
                    string_obj* str = STRING_NEW("");
                    int ret;
                    if(preserve) {
                        ret = statment_tree_internal_commands_read_nextin_preserve(nextin, str);
                    }
                    else {
                        ret = statment_tree_internal_commands_read_nextin(nextin, str);
                    }

                    if(ret == 1) {
                        string_delete(str);
                        *rcode = 1;
                        break;
                    }
                    else if(ret < 0)
                    {
                        err_msg("interrupt", sname, sline);
                        string_delete(str);
                        return FALSE;
                    }
                    else {
                        if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(str)))
                        {
                            err_msg("signal interrupt", sname, sline);
                            string_delete(str);
                            return FALSE;
                        }

                        *rcode = 0;
                    }

                    string_delete(str);
                }
                else if(flg_c) {
                    if(preserve) {
                        string_obj* out = STRING_NEW("");

                        int result = statment_tree_internal_commands_read_nextin_onechar_preserve_num(nextin, out, c);

                        if(result == -1) {
                            err_msg("interrupt", sname, sline);

                            string_delete(out);
                            return FALSE;
                        }
                        else if(result == 1) {
                            string_delete(out);
                            break;
                        }

                        if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(out)))
                        {
                            err_msg("signal interrupt", sname, sline);
                            string_delete(out);

                            return FALSE;
                        }
                        *rcode = 0;

                        string_delete(out);
                    }
                    else {
                        string_obj* out = STRING_NEW("");

                        int result = statment_tree_internal_commands_read_nextin_onechar_num(nextin, out, c);

                        if(result == -1) {
                            err_msg("interrupt", sname, sline);

                            string_delete(out);
                            return FALSE;
                        }
                        else if(result == 1) {
                            string_delete(out);
                            break;
                        }

                        if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(out)))
                        {
                            err_msg("signal interrupt", sname, sline);
                            string_delete(out);

                            return FALSE;
                        }
                        *rcode = 0;

                        string_delete(out);
                    }
                }
                else if(flg_n) {
                    if(preserve) {
                        string_obj* out = STRING_NEW("");

                        int result = statment_tree_internal_commands_read_nextin_oneline_preserve_num(nextin, out, n, lf);

                        if(result == -1) {
                            err_msg("interrupt", sname, sline);

                            string_delete(out);
                            return FALSE;
                        }
                        else if(result == 1) {
                            string_delete(out);
                            break;
                        }

                        if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(out)))
                        {
                            err_msg("signal interrupt", sname, sline);
                            string_delete(out);

                            return FALSE;
                        }
                        *rcode = 0;

                        string_delete(out);
                    }
                    else {
                        string_obj* str = STRING_NEW("");
                        int result = statment_tree_internal_commands_read_nextin_oneline_num(nextin, str, n, lf);

                        if(result == -1) {
                            err_msg("interrupt", sname, sline);
                            string_delete(str);
                            return FALSE;
                        }
                        else if(result == 1) {
                            string_delete(str);
                            break;
                        }

                        if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(str)))
                        {
                            err_msg("signal interrupt", sname, sline);

                            string_delete(str);
                            return FALSE;
                        }
                        *rcode = 0;

                        string_delete(str);
                    }
                }
                else {
                    string_obj* str = STRING_NEW("");
                    int result;
                    if(preserve) {
                        result = statment_tree_internal_commands_read_nextin_oneline_preserve(nextin, str, lf);
                    }
                    else {
                        result = statment_tree_internal_commands_read_nextin_oneline(nextin, str, lf);
                    }

                    if(result == 0) { 
                        if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(str)))
                        {
                            err_msg("signal interrupt", sname, sline);

                            string_delete(str);

                            return FALSE;
                        }
                        *rcode = 0;
                    }
                    else if(result == -1) {
                        err_msg("interrupt", sname, sline);
                        string_delete(str);

                        return FALSE;
                    }

                    string_delete(str);
                }
            }
            else if(vector_size(argv) == 2) {
                char* fname = string_c_str(vector_item(argv, 1));

                sRFd* rfd = hash_item(gReadBuffers, fname);
                if(rfd == 0) {
                    int fd = open(fname, O_RDONLY);

                    if(fd < 0) {
                        char buf[64];
                        snprintf(buf, 64, "read: can't open file %s", fname);
                        err_msg(buf, sname, sline);
                        return FALSE;
                    }
                    
                    rfd = RFD_NEW(fd);
                    hash_put(gReadBuffers, fname, rfd);
                }

                if(all) {
                    string_obj* str = STRING_NEW("");
                    int ret = statment_tree_internal_commands_read_nextin(rfd, str);
                    if(ret == 1) {
                        *rcode = 1;
                        sRFd_close(rfd);
                        string_delete(str);
                        sRFd_delete(rfd);
                        hash_erase(gReadBuffers, fname);
                        break;
                    }
                    else if(ret < 0)
                    {
                        err_msg("interrupt", sname, sline);
                        string_delete(str);
                        return FALSE;
                    }
                    else {
                        if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(str)))
                        {
                            err_msg("signal interrupt", sname, sline);
                            string_delete(str);
                            return FALSE;
                        }

                        sRFd_close(rfd);
                        sRFd_delete(rfd);
                        hash_erase(gReadBuffers, fname);

                        *rcode = 0;
                    }

                    string_delete(str);
                }
                else if(flg_n) {
                    int i;
                    for(i=0; i<n; i++) {
                        string_obj* str = STRING_NEW("");
                        int result = statment_tree_internal_commands_read_nextin_oneline(rfd, str, lf);

                        if(result == 0) { 
                            if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(str)))
                            {
                                err_msg("signal interrupt", sname, sline);
                                string_delete(str);

                                return FALSE;
                            }
                            *rcode = 0;
                        }
                        else if(result == -1) {
                            err_msg("interrupt", sname, sline);
                            string_delete(str);
                            return FALSE;
                        }
                        else {
                            sRFd_close(rfd);
                            sRFd_delete(rfd);
                            hash_erase(gReadBuffers, fname);
                            string_delete(str);
                            break;
                        }

                        string_delete(str);
                    }
                }
                else {
                    string_obj* str = STRING_NEW("");
                    int result = statment_tree_internal_commands_read_nextin_oneline(rfd, str, lf);

                    if(result == 0) { 
                        if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(str)))
                        {
                            err_msg("signal interrupt", sname, sline);
                            string_delete(str);

                            return FALSE;
                        }
                        *rcode = 0;
                    }
                    else if(result == -1) {
                        err_msg("interrupt", sname, sline);
                        string_delete(str);
                        return FALSE;
                    }
                    else {
                        sRFd_close(rfd);
                        sRFd_delete(rfd);
                        hash_erase(gReadBuffers, fname);
                    }

                    string_delete(str);
                }
            }

            }
            break;

        case kClose: {
            BOOL all = FALSE;

            int l;
            for(l=0; l<vector_size(argv); l++) {
                char* arg = string_c_str(vector_item(argv, l));

                // close all opened files
                // ٤ƤγեĤ
                if(strcmp(arg, "-a") == 0) {
                    all = TRUE;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
            }

            if(vector_size(argv) == 1 && all) {
                hash_it* it = hash_loop_begin(gReadBuffers);
                while(it) {
                    sRFd* rfd = hash_loop_item(it);
                    (void)close(rfd->mFd);
                    it = hash_loop_next(it);
                }
                hash_clear(gReadBuffers);
                *rcode = 0;
            }
            else if(vector_size(argv) == 2) {
                char* fname = string_c_str(vector_item(argv, 1));

                sRFd* rfd = hash_item(gReadBuffers, fname);
                if(rfd) {
                    (void)close(rfd->mFd);
                    sRFd_close(rfd);

                    sRFd_delete(rfd);
                    hash_erase(gReadBuffers, fname);
                    *rcode = 0;
                }
            }

            }
            break;

        case kCd:
            if(vector_size(argv) == 1) {
                char* path = getenv("HOME");
                if(path) {
                    char cwd[PATH_MAX];
                    char path2[PATH_MAX];

                    mygetcwd(cwd, PATH_MAX);

                    if(correct_path(cwd, path, path2, PATH_MAX)) {
                        struct stat stat_;
                        if(stat(path2, &stat_) == 0) {
                            if(S_ISDIR(stat_.st_mode)) {
                                setenv("PWD", path2, 1);
                                if(chdir(path2) >= 0) {
                                    *rcode = 0;
                                }
                            }
                        }
                    }
                }
            }
            else if(vector_size(argv) == 2) {
                char* path = string_c_str(vector_item(argv, 1));
                char cwd[PATH_MAX];
                char path2[PATH_MAX];

                mygetcwd(cwd, PATH_MAX);
                if(correct_path(cwd, path, path2, PATH_MAX)) {
                    struct stat stat_;
                    if(stat(path2, &stat_) == 0) {
                        if(S_ISDIR(stat_.st_mode)) {
                            setenv("PWD", path2, 1);
                            if(chdir(path2) >= 0) {
                                *rcode = 0;
                            }
                        }
                    }
                }
            }
            break;

        case kSelector: {
            static int scrolltop = 0;
            static int cursor = 0;
            BOOL multiple = FALSE;
            BOOL init_cursor = TRUE;
            BOOL init_scrolltop = TRUE;
            enum eLineField lf = gLineField;

            int i;
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv,i));
                // restore before cursor position
                // ݥλƱˤ
                if(strcmp(arg, "-r") == 0) {
                    init_cursor = FALSE;
                    init_scrolltop = FALSE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // set on curor pojition
                // ݥꤹ
                else if(strcmp(arg, "-c") == 0 
                    && i+1 < vector_size(argv)) 
                {
                    init_cursor = FALSE;
                    cursor = atoi(string_c_str(vector_item(argv, i+1)));
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // set on scroll top pojition
                // ȥåװ֤ꤹ
                else if(strcmp(arg, "-t") == 0 
                    && i+1 < vector_size(argv)) 
                {
                    init_scrolltop = FALSE;
                    scrolltop = atoi(string_c_str(vector_item(argv, i+1)));
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // select multiline lines
                // ʣ
                else if(strcmp(arg, "-m") == 0) {
                    multiple = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as CR
                // ԥɤCRȤư
                else if(strcmp(arg, "-Lm") == 0) {
                    lf = kCR;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as LF
                // ԥɤLFȤư
                else if(strcmp(arg, "-Lu") == 0) {
                    lf = kLF;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as Bel
                // ԥɤBelȤư
                else if(strcmp(arg, "-La") == 0) {
                    lf = kBel;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as CRLF
                // ԥɤCRLFȤư
                else if(strcmp(arg, "-Lw") == 0) {
                    lf = kCRLF;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            if(init_scrolltop) {
                scrolltop = 0;
            }
            if(init_cursor) {
                cursor = 0;
            }

            string_obj* str = STRING_NEW("");
            int ret = statment_tree_internal_commands_read_nextin(nextin,str) ;
            if(ret == 1) {
                string_delete(str);
                *rcode = 1;
                break;
            }
            else if(ret < 0)
            {
                err_msg("interrupt", sname, sline);
                string_delete(str);
                return FALSE;
            }
            string_obj* result = STRING_NEW("");
            if(!statment_tree_internal_commands_selector(str,result
                    , &scrolltop, &cursor, kUtf8, multiple, lf
                    , sname, sline))
            {
                string_delete(result);
                string_delete(str);

                return FALSE;
            }
            string_delete(str);

            if(strcmp(string_c_str(result), "") != 0) {
                if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(result)))
                {
                    err_msg("sinal interrupt", sname, sline);
                    string_delete(result);
                    return FALSE;
                }
                if(!statment_tree_internal_commands_write_lf(nextout,  lf))
                {
                    err_msg("singal interrupt", sname, sline);
                    string_delete(result);
                    return FALSE;
                }
                *rcode = 0;
            }

            string_delete(result);
            }
            break;

        case kMax: {
            BOOL new_line = TRUE;

            int l;
            for(l=0; l<vector_size(argv); l++) {
                char* arg = string_c_str(vector_item(argv, l));

                // when output the variant content, don't add LF at tail
                // ϤȤԤäʤ
                if(strcmp(arg, "-nl") == 0) {
                    new_line = FALSE;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
            }

            if(vector_size(argv) == 3) {
                int left = atoi(string_c_str(vector_item(argv, 1)));
                int right = atoi(string_c_str(vector_item(argv, 2)));

                if(left > right) {
                    *rcode = 0;
                    if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(vector_item(argv, 1))))
                    {
                        err_msg("signal interrupt", sname, sline);
                        return FALSE;
                    }
                    if(new_line) {
                        if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                        {
                            err_msg("singal interrupt", sname, sline);
                            return FALSE;
                        }
                    }
                }
                else {
                    *rcode = 0;
                    if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(vector_item(argv, 2))))
                    {
                        err_msg("signal interrupt", sname, sline);
                        return FALSE;
                    }
                    if(new_line) {
                        if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                        {
                            err_msg("singal interrupt", sname, sline);
                            return FALSE;
                        }
                    }
                }
            }
            }
            break;

        case kMin: {
            BOOL new_line = TRUE;

            int l;
            for(l=0; l<vector_size(argv); l++) {
                char* arg = string_c_str(vector_item(argv, l));

                // when output the variant content, don't add LF at tail
                // ϤȤԤäʤ
                if(strcmp(arg, "-nl") == 0) {
                    new_line = FALSE;
                    string_delete(vector_item(argv, l));
                    vector_erase(argv, l);
                    l--;
                    continue;
                }
            }

            if(vector_size(argv) == 3) {
                int left = atoi(string_c_str(vector_item(argv, 1)));
                int right = atoi(string_c_str(vector_item(argv, 2)));

                if(left < right) {
                    *rcode = 0;
                    if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(vector_item(argv, 1))))
                    {
                        err_msg("signal interrupt", sname, sline);
                        return FALSE;
                    }
                    if(new_line) {
                        if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                        {
                            err_msg("singal interrupt", sname, sline);
                            return FALSE;
                        }
                    }
                }
                else {
                    *rcode = 0;
                    if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(vector_item(argv, 2))))
                    {
                        err_msg("signal interrupt", sname, sline);
                        return FALSE;
                    }
                    if(new_line) {
                        if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                        {
                            err_msg("singal interrupt", sname, sline);
                            return FALSE;
                        }
                    }
                }
            }
            }
            break;
        

        case kExtName: {
            BOOL new_line = TRUE;

            int i;
            for(i=0; i<vector_size(argv); i++) {
                string_obj* item = vector_item(argv, i);
                // take a STDIN pipe
                // ɸϤ
                if(strcmp(string_c_str(item), "-I") == 0) {
                    input = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // when output the variant content, don't add LF at tail
                // ϤȤԤäʤ
                else if(strcmp(string_c_str(item), "-nl") == 0) {
                    new_line = FALSE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            if(input && vector_size(argv) == 1 && input) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str);
                if(ret == 1) {
                    string_delete(str);
                    *rcode = 1;
                    break;
                }
                else if(ret < 0)
                {
                    err_msg("interrupt", sname, sline);
                    string_delete(str);
                    return FALSE;
                }

                char* target = string_c_str(str);
                char path[PATH_MAX];
                extname(path, PATH_MAX, target);

                if(strcmp(path, "") != 0) {
                    if(!statment_tree_internal_commands_write_nextout(nextout, path))
                    {
                        err_msg("signal interrupt", sname, sline);
                        string_delete(str);
                        return FALSE;
                    }
                    if(new_line) {
                        if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                        {
                            err_msg("singal interrupt", sname, sline);
                            string_delete(str);
                            return FALSE;
                        }
                    }

                    *rcode = 0;
                }

                string_delete(str);
            }
            else if(vector_size(argv) == 2) {
                char path[PATH_MAX];
                extname(path, PATH_MAX, string_c_str(vector_item(argv, 1)));
                if(strcmp(path, "") != 0) {
                    if(!statment_tree_internal_commands_write_nextout(nextout, path))
                    {
                        err_msg("signal interrupt", sname, sline);
                        return FALSE;
                    }
                    if(new_line) {
                        if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                        {
                            err_msg("singal interrupt", sname, sline);
                            return FALSE;
                        }
                    }

                    *rcode = 0;
                }
            }
            }
            break;

        case kParentName: {
            BOOL new_line = TRUE;

            int i;
            for(i=0; i<vector_size(argv); i++) {
                string_obj* item = vector_item(argv, i);
                // take a STDIN pipe
                // ɸϤ
                if(strcmp(string_c_str(item), "-I") == 0) {
                    input = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // when output the variant content, don't add LF at tail
                // ϤȤԤäʤ
                else if(strcmp(string_c_str(item), "-nl") == 0) {
                    new_line = FALSE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            if(vector_size(argv) == 1 && input) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str);
                if(ret == 1) {
                    string_delete(str);
                    *rcode = 1;
                    break;
                }
                else if(ret < 0)
                {
                    err_msg("interrupt", sname, sline);
                    string_delete(str);
                    return FALSE;
                }

                char* target = string_c_str(str);
                char path[PATH_MAX];
                parentname(path, PATH_MAX, target);
                if(strcmp(path, "") != 0) {
                    if(!statment_tree_internal_commands_write_nextout(nextout, path))
                    {
                        err_msg("signal interrupt", sname, sline);
                        string_delete(str);
                        return FALSE;
                    }
                    if(new_line) {
                        if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                        {
                            err_msg("singal interrupt", sname, sline);
                            string_delete(str);
                            return FALSE;
                        }
                    }

                    *rcode = 0;
                }

                string_delete(str);
            }
            else if(vector_size(argv) == 2) {
                char path[PATH_MAX];
                parentname(path, PATH_MAX, string_c_str(vector_item(argv, 1)));
                if(strcmp(path, "") != 0) {
                    if(!statment_tree_internal_commands_write_nextout(nextout, path))
                    {
                        err_msg("signal interrupt", sname, sline);
                        return FALSE;
                    }
                    if(new_line) {
                        if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                        {
                            err_msg("singal interrupt", sname, sline);
                            return FALSE;
                        }
                    }
                    *rcode = 0;
                }
            }
            }
            break;

        case kNoExtName: {
            BOOL new_line = TRUE;

            int i;
            for(i=0; i<vector_size(argv); i++) {
                string_obj* item = vector_item(argv, i);
                // take a STDIN pipe
                // ɸϤ
                if(strcmp(string_c_str(item), "-I") == 0) {
                    input = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // when output the variant content, don't add LF at tail
                // ϤȤԤäʤ
                else if(strcmp(string_c_str(item), "-nl") == 0) {
                    new_line = FALSE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            if(vector_size(argv) == 1 && input) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(
                        nextin, str);
                if(ret == 1) {
                    string_delete(str);
                    *rcode = 1;
                    break;
                }
                else if(ret < 0)
                {
                    err_msg("interrupt", sname, sline);
                    string_delete(str);
                    return FALSE;
                }

                char* target = string_c_str(str);
                char path[PATH_MAX];
                noextname(path, PATH_MAX, target);
                if(strcmp(path, "") != 0) {
                    if(!statment_tree_internal_commands_write_nextout(nextout, path))
                    {
                        err_msg("signal interrupt", sname, sline);
                        string_delete(str);
                        return FALSE;
                    }
                    if(new_line) {
                        if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                        {
                            err_msg("singal interrupt", sname, sline);
                            string_delete(str);
                            return FALSE;
                        }
                    }

                    *rcode = 0;
                }

                string_delete(str);
            }
            else if(vector_size(argv) == 2) {
                char path[PATH_MAX];
                noextname(path, PATH_MAX, string_c_str(vector_item(argv, 1)));
                if(strcmp(path, "") != 0) {
                    if(!statment_tree_internal_commands_write_nextout(nextout, path))
                    {
                        err_msg("signal interrupt", sname, sline);
                        return FALSE;
                    }
                    if(new_line) {
                        if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                        {
                            err_msg("singal interrupt", sname, sline);
                            return FALSE;
                        }
                    }

                    *rcode = 0;
                }
            }
            }
            break;

        case kPopd: {
            string_obj* pwd = vector_pop_back(gDirStack);

            if(pwd) {
                char* path = string_c_str(pwd);
                char cwd[PATH_MAX];
                char path2[PATH_MAX];

                mygetcwd(cwd, PATH_MAX);
                if(correct_path(cwd, path, path2, PATH_MAX)) {
                    struct stat stat_;

                    if(stat(path2, &stat_) == 0) {
                        if(S_ISDIR(stat_.st_mode)) {
                            setenv("PWD", path2, 1);
                            if(chdir(path2) >= 0) {
                                *rcode = 0;
                            }
                        }
                    }
                }

                string_delete(pwd);
            }
            }
            break;

        case kPushd:
            vector_add(gDirStack, STRING_NEW(getenv("PWD")));
            *rcode = 0;
            break;

        case kSort: {
            int k;
            enum eLineField lf = gLineField;
            for(k=0; k<vector_size(argv); k++) {
                char* arg = string_c_str(vector_item(argv,k));
                // treat line field as CR
                // ԥɤCRȤư
                if(strcmp(arg, "-Lm") == 0) {
                    lf = kCR;
                    string_delete(vector_item(argv, k));
                    vector_erase(argv, k);
                    k--;
                    continue;
                }
                // treat line field as LF
                // ԥɤLFȤư
                else if(strcmp(arg, "-Lu") == 0) {
                    lf = kLF;
                    string_delete(vector_item(argv, k));
                    vector_erase(argv, k);
                    k--;
                    continue;
                }
                // treat line field as Bel
                // ԥɤBelȤư
                else if(strcmp(arg, "-La") == 0) {
                    lf = kBel;
                    string_delete(vector_item(argv, k));
                    vector_erase(argv, k);
                    k--;
                    continue;
                }
                // treat line field as CRLF
                // ԥɤCRLFȤư
                else if(strcmp(arg, "-Lw") == 0) {
                    lf = kCRLF;
                    string_delete(vector_item(argv, k));
                    vector_erase(argv, k);
                    k--;
                    continue;
                }
            }

            sBlock* sort_block;
            sBlock* maked_block = NULL;
            int line = 1;
            if(vector_size(blocks) >= 1) {
                sort_block = vector_item(blocks, 0);
            }
            else if(vector_size(argv) == 1) {
                sStatments* statments = STATMENTS_NEW();
                if(lf == kLF) {
                    if(! parse("| var -Lu _a _b; [ $(var _a) -slt $(var _b) ]", "sort block", &line, statments))
                    {
                        err_msg("invalid sort block", sname, sline);
                        sStatments_delete(statments);
                        return FALSE;
                    }
                }
                else if(lf == kCR) {
                    if(! parse("| var -Lm _a _b; [ $(var _a) -slt $(var _b) ]", "sort block", &line, statments))
                    {
                        err_msg("invalid sort block", sname, sline);
                        sStatments_delete(statments);
                        return FALSE;
                    }
                }
                else if(lf == kCRLF) {
                    if(! parse("| var -Lw _a _b; [ $(var _a) -slt $(var _b) ]", "sort block", &line, statments))
                    {
                        err_msg("invalid sort block", sname, sline);
                        sStatments_delete(statments);
                        return FALSE;
                    }
                }
                else {
                    if(! parse("| var -La _a _b; [ $(var _a) -slt $(var _b) ]", "sort block", &line, statments))
                    {
                        err_msg("invalid sort block", sname, sline);
                        sStatments_delete(statments);
                        return FALSE;
                    }
                }

                vector_obj* args = VECTOR_NEW(10);
                maked_block = sort_block = sBlock_new(MANAGED statments, MANAGED args, 0);
            }
            else {
                break;
            }

            vector_obj* v = VECTOR_NEW(100);
            while(1) {
                if(gKitutukiSigInt)  {
                    err_msg("intterrupt", sname, sline);
                    int i;
                    for(i=0; i<vector_size(v); i++) {
                        string_delete(vector_item(v, i));
                    }
                    vector_delete(v);
                    return FALSE;
                }
                string_obj* str = STRING_NEW("");
                int result = statment_tree_internal_commands_read_nextin_oneline(nextin, str, lf);

                if(result == -1) {  // CTRL_C
                    err_msg("interrupt", sname, sline);
                    string_delete(str);
                    int i;
                    for(i=0; i<vector_size(v); i++) {
                        string_delete(vector_item(v, i));
                    }
                    vector_delete(v);
                    return FALSE;
                }
                else if(result == 1) { // EOF
                    string_delete(str);
                    break;
                }

                vector_add(v, str);
            }

            gSortRunInfo = runinfo;
            gSortBlock = sort_block;
            gSortNextOut = nextout;
            gSortNextErr = nexterr;

            if(!vector_sort_cancelable(v, sort_fun)) {
                err_msg("interrupt", sname, sline);
                int i;
                for(i=0; i<vector_size(v); i++) {
                    string_delete(vector_item(v, i));
                }
                vector_delete(v);
                return FALSE;
            }
            if(*runinfo->return_) {
                int i;
                for(i=0; i<vector_size(v); i++) {
                    string_delete(vector_item(v, i));
                }
                vector_delete(v);
                return TRUE;
            }

            ///  ///
            int i;
            for(i=0; i<vector_size(v); i++) {
                if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(vector_item(v, i))))
                {
                    err_msg("signal interrupt", sname, sline);
                    int i;
                    for(i=0; i<vector_size(v); i++) {
                        string_delete(vector_item(v, i));
                    }
                    vector_delete(v);
                    return FALSE;
                }
            }

            for(i=0; i<vector_size(v); i++) {
                string_delete(vector_item(v, i));
            }
            vector_delete(v);

            if(maked_block) {
                sBlock_delete(maked_block);
            }

            *rcode = 0;
            }
            break;

        case kMinusMinus: {
            int i;
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv,i));
                // take a STDIN pipe
                // ɸϤ
                if(strcmp(arg, "-I") == 0) {
                    input = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            if(input) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str);
                if(ret == 1) {
                    string_delete(str);
                    *rcode = 1;
                    break;
                }
                else if(ret < 0)
                {
                    err_msg("interrupt", sname, sline);
                    string_delete(str);
                    return FALSE;
                }

                int n = atoi(string_c_str(str)) - 1;
                char buf[128];
                snprintf(buf, 128, "%d", n);

                if(!statment_tree_internal_commands_write_nextout(nextout, buf))
                {
                    err_msg("signal interrupt", sname, sline);
                    string_delete(str);
                    return FALSE;
                }
                *rcode = 0;

                string_delete(str);
            }
            else {
                if(vector_size(argv) == 2) {
                    char* arg = string_c_str(vector_item(argv, 1));

                    string_obj* var = saphire_get_local_var(arg, runinfo->object);
                    if(var) {
                        int n = atoi(string_c_str(var)) - 1;
                        char buf[128];
                        snprintf(buf, 128, "%d", n);
                        if(!saphire_set_local_var(arg, buf, runinfo->object)) {
                            err_msg("invalid refference", sname, sline);
                            return FALSE;
                        }
                    }
                    else {
                        int n = - 1;
                        char buf[128];
                        snprintf(buf, 128, "%d", n);
                        if(!saphire_set_local_var(arg, buf, runinfo->object)) {
                            err_msg("invalid refference", sname, sline);
                            return FALSE;
                        }
                    }
                    *rcode = 0;
                }
            }
            }
            break;

        case kPlusPlus: {
            int i;
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv,i));
                // take a STDIN pipe
                // ɸϤ
                if(strcmp(arg, "-I") == 0) {
                    input = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            if(input) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str);
                if(ret == 1) {
                    string_delete(str);
                    *rcode = 1;
                    break;
                }
                else if(ret < 0)
                {
                    err_msg("interrupt", sname, sline);
                    string_delete(str);
                    return FALSE;
                }

                int n = atoi(string_c_str(str)) + 1;
                char buf[128];
                snprintf(buf, 128, "%d", n);
                *rcode = 0;

                if(!statment_tree_internal_commands_write_nextout(nextout, buf))
                {
                    err_msg("signal interrupt", sname, sline);
                    string_delete(str);
                    return FALSE;
                }

                string_delete(str);
            }
            else {
                if(vector_size(argv) == 2) {
                    char* arg = string_c_str(vector_item(argv, 1));

                    string_obj* var = saphire_get_local_var(arg, runinfo->object);
                    if(var) {
                        int n = atoi(string_c_str(var)) + 1;
                        char buf[128];
                        snprintf(buf, 128, "%d", n);
                        if(!saphire_set_local_var(arg, buf, runinfo->object)) {
                            err_msg("invalid refference", sname, sline);
                            return FALSE;
                        }
                    }
                    else {
                        int n = 1;
                        char buf[128];
                        snprintf(buf, 128, "%d", n);
                        if(!saphire_set_local_var(arg, buf, runinfo->object)) {
                            err_msg("invalid refference", sname, sline);
                            return FALSE;
                        }
                    }
                    *rcode = 0;
                }
            }
            }
            break;

        case kPlus: {
            int i;
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv,i));
                // take a STDIN pipe
                // ɸϤ
                if(strcmp(arg, "-I") == 0) {
                    input = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            if(input && vector_size(argv) == 2) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str);
                if(ret == 1) {
                    string_delete(str);
                    *rcode = 1;
                    break;
                }
                else if(ret < 0)
                {
                    err_msg("interrupt", sname, sline);
                    string_delete(str);
                    return FALSE;
                }

                int n = atoi(string_c_str(str)) + atoi(string_c_str(vector_item(argv, 1)));
                char buf[128];
                snprintf(buf, 128, "%d", n);
                *rcode = 0;


                if(!statment_tree_internal_commands_write_nextout(nextout, buf))
                {
                    err_msg("signal interrupt", sname, sline);
                    string_delete(str);
                    return FALSE;
                }

                string_delete(str);
            }
            }
            break;

        case kMinus: {
            int i;
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv,i));
                // take a STDIN pipe
                // ɸϤ
                if(strcmp(arg, "-I") == 0) {
                    input = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            if(input && vector_size(argv) == 2) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str);
                if(ret == 1) {
                    string_delete(str);
                    *rcode = 1;
                    break;
                }
                else if(ret < 0)
                {
                    err_msg("interrupt", sname, sline);
                    string_delete(str);
                    return FALSE;
                }

                int n = atoi(string_c_str(str)) - atoi(string_c_str(vector_item(argv, 1)));
                char buf[128];
                snprintf(buf, 128, "%d", n);
                *rcode = 0;


                if(!statment_tree_internal_commands_write_nextout(nextout, buf))
                {
                    err_msg("signal interrupt", sname, sline);
                    string_delete(str);
                    return FALSE;
                }

                string_delete(str);
            }
            }
            break;

        case kMult: {
            int i;
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv,i));
                // take a STDIN pipe
                // ɸϤ
                if(strcmp(arg, "-I") == 0) {
                    input = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            if(input && vector_size(argv) == 2) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str);
                if(ret == 1) {
                    string_delete(str);
                    *rcode = 1;
                    break;
                }
                else if(ret < 0)
                {
                    err_msg("interrupt", sname, sline);
                    string_delete(str);
                    return FALSE;
                }

                int n = atoi(string_c_str(str)) * atoi(string_c_str(vector_item(argv, 1)));
                char buf[128];
                snprintf(buf, 128, "%d", n);
                *rcode = 0;


                if(!statment_tree_internal_commands_write_nextout(nextout, buf))
                {
                    err_msg("signal interrupt", sname, sline);
                    string_delete(str);
                    return FALSE;
                }

                string_delete(str);
            }
            }
            break;

        case kDiv: {
            int i;
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv,i));
                // take a STDIN pipe
                // ɸϤ
                if(strcmp(arg, "-I") == 0) {
                    input = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            if(input && vector_size(argv) == 2) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str);
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    break;
                }
                else if(ret < 0) 
                {
                    err_msg("interrupt", sname, sline);
                    string_delete(str);
                    return FALSE;
                }

                int n = atoi(string_c_str(str)) / atoi(string_c_str(vector_item(argv, 1)));
                char buf[128];
                snprintf(buf, 128, "%d", n);
                *rcode = 0;


                if(!statment_tree_internal_commands_write_nextout(nextout, buf))
                {
                    err_msg("signal interrupt", sname, sline);
                    string_delete(str);
                    return FALSE;
                }

                string_delete(str);
            }
            }
            break;

        case kMod: {
            int i;
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv,i));
                // take a STDIN pipe
                // ɸϤ
                if(strcmp(arg, "-I") == 0) {
                    input = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            if(input && vector_size(argv) == 2) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str);
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    break;
                }
                else if(ret < 0)
                {
                    err_msg("interrupt", sname, sline);
                    string_delete(str);
                    return FALSE;
                }

                int n = atoi(string_c_str(str)) % atoi(string_c_str(vector_item(argv, 1)));
                char buf[128];
                snprintf(buf, 128, "%d", n);
                *rcode = 0;


                if(!statment_tree_internal_commands_write_nextout(nextout, buf))
                {
                    err_msg("signal interrupt", sname, sline);
                    string_delete(str);
                    return FALSE;
                }

                string_delete(str);
            }
            }
            break;

        case kPow: {
            int i;
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv,i));
                // take a STDIN pipe
                // ɸϤ
                if(strcmp(arg, "-I") == 0) {
                    input = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            if(input && vector_size(argv) == 2) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str);
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    break;
                }
                else if(ret < 0)
                {
                    err_msg("interrupt", sname, sline);
                    string_delete(str);
                    return FALSE;
                }

                int n = pow(atoi(string_c_str(str)), atoi(string_c_str(vector_item(argv, 1))));
                char buf[128];
                snprintf(buf, 128, "%d", n);
                *rcode = 0;


                if(!statment_tree_internal_commands_write_nextout(nextout, buf))
                {
                    err_msg("signal interrupt", sname, sline);
                    string_delete(str);
                    return FALSE;
                }

                string_delete(str);
            }
            }
            break;

        case kRange: {
            if(vector_size(argv) == 3) {
                int first = atoi(string_c_str(vector_item(argv, 1)));
                int last = atoi(string_c_str(vector_item(argv, 2)));

                int i;
                for(i=first; i<=last; i++) {
                    char buf[BUFSIZ];
                    snprintf(buf, BUFSIZ, "%d", i);
                    if(!statment_tree_internal_commands_write_nextout(nextout, buf))
                    {
                        err_msg("signal interrupt", sname, sline);
                        return FALSE;
                    }
                    if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                    {
                        err_msg("singal interrupt", sname, sline);
                        return FALSE;
                    }
                    *rcode = 0;
                }
            }
            }
            break;

        case kPrintf: {
            int i;
            BOOL line_field = FALSE;
            enum eLineField lf = gLineField;
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv,i));
                // when output the variant content, add LF at tail
                // ϤȤԤä
                if(strcmp(arg, "-L") == 0) {
                    line_field = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // take a STDIN pipe
                // ɸϤ
                else if(strcmp(arg, "-I") == 0) {
                    input = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as CR
                // ԥɤCRȤư
                else if(strcmp(arg, "-Lm") == 0) {
                    lf = kCR;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as LF
                // ԥɤLFȤư
                else if(strcmp(arg, "-Lu") == 0) {
                    lf = kLF;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as Bel
                // ԥɤBelȤư
                else if(strcmp(arg, "-La") == 0) {
                    lf = kBel;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as CRLF
                // ԥɤCRLFȤư
                else if(strcmp(arg, "-Lw") == 0) {
                    lf = kCRLF;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            if(input && vector_size(argv) == 2) {
                ///  ///
                vector_obj* v = VECTOR_NEW(30);
                while(1) {
                    if(gKitutukiSigInt) {
                        err_msg("interrupt", sname, sline);
                        int i;
                        for(i=0; i<vector_size(v); i++) {
                            string_delete(vector_item(v, i));
                        }
                        vector_delete(v);
                        return FALSE;
                    }

                    string_obj* str = STRING_NEW("");
                    int result = statment_tree_internal_commands_read_nextin_oneline(nextin, str, lf);
                    if(result == 0) {
                        string_chomp2(str, lf);
                        vector_add(v, str);
                    }
                    else if(result == -1) {
                        err_msg("interrupt", sname, sline);
                        string_delete(str);
                        int i;
                        for(i=0; i<vector_size(v); i++) {
                            string_delete(vector_item(v, i));
                        }
                        vector_delete(v);
                        return FALSE;
                    }
                    else {
                        string_delete(str);
                        break;
                    }
                }

                ///  ///
                char* format = string_c_str(vector_item(argv, 1));

                if(!statment_tree_internal_commands_printf(format, v, nextout, line_field, sname, sline, lf)) {

                    int i;
                    for(i=0; i<vector_size(v); i++) {
                        string_delete(vector_item(v, i));
                    }
                    vector_delete(v);
                    return FALSE;
                }
                *rcode = 0;
                int i;
                for(i=0; i<vector_size(v); i++) {
                    string_delete(vector_item(v, i));
                }
                vector_delete(v);
            }
            else if(vector_size(argv) > 2) {
                ///  ///
                vector_obj* v = VECTOR_NEW(30);
                int i;
                for(i=2; i<vector_size(argv); i++) {
                    vector_add(v, STRING_NEW(string_c_str(vector_item(argv, i))));
                }

                ///  ///
                char* format = string_c_str(vector_item(argv, 1));

                if(!statment_tree_internal_commands_printf(format, v, nextout, line_field, sname, sline, lf)) 
                {
                    int i;
                    for(i=0; i<vector_size(v); i++) {
                        string_delete(vector_item(v, i));
                    }
                    vector_delete(v);
                    return FALSE;
                }

                for(i=0; i<vector_size(v); i++) {
                    string_delete(vector_item(v, i));
                }
                vector_delete(v);
                *rcode = 0;

            }
            
            }
            break;

        case kPomch: {
            int i;
            enum eLineField lf = gLineField;
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv,i));
                // take a STDIN pipe
                // ɸϤ
                if(strcmp(arg, "-I") == 0) {
                    input = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as CRLF
                // ԥɤCRLFȤư
                else if(strcmp(arg, "-Lw") == 0) {
                    lf = kCRLF;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as CR
                // ԥɤCRȤư
                else if(strcmp(arg, "-Lm") == 0) {
                    lf = kCR;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as LF
                // ԥɤLFȤư
                else if(strcmp(arg, "-Lu") == 0) {
                    lf = kLF;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as Bel
                // ԥɤBelȤư
                else if(strcmp(arg, "-La") == 0) {
                    lf = kBel;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            string_obj* str;
            if(input) {
                str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str) ;
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    break;
                }
                else if(ret < 0) {
                    err_msg("interrupt", sname, sline);
                    string_delete(str);
                    return FALSE;
                }
            }
            else {
                if(vector_size(argv) >= 2) {
                    str = STRING_NEW(string_c_str(vector_item(argv, 1)));
                }
                else {
                    str = STRING_NEW("");
                }
            }

            string_pomch(str, lf);
            if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(str))) {
                err_msg("interrupt", sname, sline);
                string_delete(str);
                return FALSE;
            }
            *rcode = 0;
            string_delete(str);
            }
            break;

        case kPTee: {
            string_obj* str = STRING_NEW("");
            int ret = statment_tree_internal_commands_read_nextin(nextin, str) ;
            if(ret == 1) {
                *rcode = 1;
                string_delete(str);
                break;
            }
            else if(ret < 0) {
                err_msg("interrupt", sname, sline);
                string_delete(str);
                return FALSE;
            }

            int i;
            for(i=0; i<vector_size(blocks); i++) {
                sBlock* block = vector_item(blocks, i);
                sStatments* statments = block->mStatments;
                sRFd* nextin2 = RFD_NEW2(-1, string_c_str(str));

                char* fname = MALLOC(strlen(sname) + 32);
                snprintf(fname, strlen(sname) + 32, "%s %d: ptee", sname, sline);
                *rcode = run(runinfo, statments, fname, nextout , nextin2, nexterr , FALSE);

                FREE(fname);
                sRFd_delete(nextin2);

                if(runinfo->enable_break && *runinfo->break_) {
                    string_delete(str);
                    return TRUE;
                }
                else if(runinfo->enable_return && *runinfo->return_) {
                    string_delete(str);
                    return TRUE;
                }
                else if(*rcode < 0) {
                    string_delete(str);
                    return FALSE;
                }
            }

            string_delete(str);

            }
            break;

        case kPCat: {
            int i;
            for(i=0; i<vector_size(blocks); i++) {
                sBlock* block = vector_item(blocks, i);
                sStatments* statments = block->mStatments;

                char* fname = MALLOC(strlen(sname) + 32);
                snprintf(fname, strlen(sname) + 32, "%s %d: pcat", sname, sline);
                *rcode = run(runinfo, statments, fname, nextout , nextin, nexterr , FALSE);
                FREE(fname);

                if(runinfo->enable_break && *runinfo->break_) {
                    return TRUE;
                }
                else if(runinfo->enable_return && *runinfo->return_) {
                    return TRUE;
                }
                else if(*rcode < 0) {
                    return FALSE;
                }
            }
            }
            break;

        case kReturn: {
            if(vector_size(argv) == 1) {
                *runinfo->return_ = TRUE;
                *rcode = 0;
                return TRUE;
            }
            else if(vector_size(argv) > 1) {
                *runinfo->return_ = TRUE;
                *rcode = atoi(string_c_str(vector_item(argv, 1)));
                return TRUE;
            }
            }
            break;

        case kMInitScr:
            minitscr();
            *rcode = 0;
            break;

        case kMEndWin:
            mendwin();
            *rcode = 0;
            break;

        case kMClear:
            mclear();
            *rcode = 0;
            break;

        case kMClearImmediately:
            mclear_immediately();
            *rcode = 0;
            break;

        case kMRefresh:
            mrefresh();
            *rcode = 0;
            break;

        case kMMove:
            if(vector_size(argv) == 3) {
                mmove(atoi(string_c_str(vector_item(argv, 1)))
                    , atoi(string_c_str(vector_item(argv, 2))));
                *rcode = 0;
            }
            break;

        case kMMoveImmediately:
            if(vector_size(argv) == 3) {
                mmove_immediately(atoi(string_c_str(vector_item(argv, 1)))
                    , atoi(string_c_str(vector_item(argv, 2))));
                *rcode = 0;
            }
            break;

        case kMPrintw: {
            int i;
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv,i));
                // take a STDIN pipe
                // ɸϤ
                if(strcmp(arg, "-I") == 0) {
                    input = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            string_obj* str;
            if(input) {
                str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str) ;
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    break;
                }
                else if(ret < 0) {
                    err_msg("interrupt", sname, sline);
                    string_delete(str);
                    return FALSE;
                }
            }
            else {
                if(vector_size(argv) >= 2) {
                    str = STRING_NEW(string_c_str(vector_item(argv, 1)));
                }
                else {
                    str = STRING_NEW("");
                }
            }

            *rcode = 0;
            mprintw("%s", string_c_str(str));

            string_delete(str);
            }
            break;

        case kYeild: {
            int block_num;
            if(vector_size(argv) > 1) {
                block_num = atoi(string_c_str(vector_item(argv, 1)));
            }
            else {
                block_num = 0;
            }

            if(runinfo->parent_blocks && block_num < vector_size(runinfo->parent_blocks)) {
                sBlock* block = vector_item(runinfo->parent_blocks, block_num);
                sStatments* statments = block->mStatments;

                int i;
                for(i=0; i<vector_size(block->mArgs); i++) {
                    string_obj* arg = vector_item(block->mArgs, i);

                    if(i+2 < vector_size(argv)) {
                        (void)saphire_set_local_var(string_c_str(arg), string_c_str(vector_item(argv, i+2)), NULL);
                    }
                }

                char* fname = MALLOC(strlen(sname) + 32);
                snprintf(fname, strlen(sname) + 32, "%s %d: yeild", sname, sline);

                *rcode = run(runinfo, statments, fname, nextout , nextin, nexterr , FALSE);

                FREE(fname);

                if(runinfo->enable_break && *runinfo->break_) {
                    return TRUE;
                }
                else if(runinfo->enable_return && *runinfo->return_) {
                    return TRUE;
                }
                if(*rcode < 0) {
                    return FALSE;
                }
            }
            }
            break;

        case kBlock: {
            int i;
            BOOL number = FALSE;
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv,i));
                // block number
                // block number
                if(strcmp(arg, "-n") == 0) 
                {
                    number = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            if(number) {
                if(runinfo->parent_blocks) {
                    char buf[1024];
                    snprintf(buf, 1024, "%d", vector_size(runinfo->parent_blocks));

                    if(!statment_tree_internal_commands_write_nextout(nextout, buf))
                    {
                        err_msg("singal interrupt", sname, sline);
                        return FALSE;
                    }
                    if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                    {
                        err_msg("singal interrupt", sname, sline);
                        return FALSE;
                    }

                    *rcode = 0;
                }
            }
            else {
                int block_num;
                if(vector_size(argv) > 1) {
                    block_num = atoi(string_c_str(vector_item(argv, 1)));
                }
                else {
                    block_num = 0;
                }

                if(runinfo->parent_blocks && block_num < vector_size(runinfo->parent_blocks)) {
                    sBlock* block = vector_item(runinfo->parent_blocks, block_num);
                    sStatments* statments = block->mStatments;

                    if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(statments->mSource)))
                    {
                        err_msg("singal interrupt", sname, sline);
                        return FALSE;
                    }

                    *rcode = 0;
                }
            }
            }
            break;


        case kEach: {
            int i;
            enum eLineField lf = gLineField;
            int number = 1;
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv,i));
                // treat line field as CR
                // ԥɤCRȤư
                if(strcmp(arg, "-Lm") == 0) {
                    lf = kCR;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as LF
                // ԥɤLFȤư
                else if(strcmp(arg, "-Lu") == 0) {
                    lf = kLF;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as Bel
                // ԥɤBelȤư
                else if(strcmp(arg, "-La") == 0) {
                    lf = kBel;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as CRLF
                // ԥɤCRLFȤư
                else if(strcmp(arg, "-Lw") == 0) {
                    lf = kCRLF;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // get n lines
                // n 
                else if(strcmp(arg, "-n") == 0 
                    && i+1 < vector_size(argv)) 
                {
                    number = atoi(string_c_str(vector_item(argv, i+1)));
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            if(vector_size(blocks) >= 1) {
                if(number == 1) {
                    char* fname = MALLOC(strlen(sname) + 32);
                    snprintf(fname, strlen(sname) + 32, "%s %d: each", sname, sline);
                    sBlock* block = vector_item(blocks, 0);
                    sStatments* statments = block->mStatments;

                    string_obj* arg;
                    if(vector_size(block->mArgs) >= 1) {
                        arg = vector_item(block->mArgs, 0);
                    }
                    else {
                        arg = NULL;
                    }

                    int i = 0;
                    while(1) {
                        if(gKitutukiSigInt)  {
                            err_msg("intterrupt", sname, sline);
                            FREE(fname);
                            return FALSE;
                        }
                        string_obj* str = STRING_NEW("");
                        int result = statment_tree_internal_commands_read_nextin_oneline(nextin, str, lf);

                        if(result == -1) {  // CTRL_C
                            err_msg("interrupt KKKK", sname, sline);
                            string_delete(str);
                            FREE(fname);
                            return FALSE;
                        }
                        else if(result == 1) { // EOF
                            string_delete(str);
                            break;
                        }

                        if(arg) {
                            char buf[1024];
                            snprintf(buf, 1024, "%d", i);
                            (void)saphire_set_local_var(string_c_str(arg), buf, NULL);
                        }

                        sRFd* nextin2 = RFD_NEW2(-1, string_c_str(str));
                        BOOL enable_break = runinfo->enable_break;
                        runinfo->enable_break = TRUE;
                        *rcode = run(runinfo, statments , fname, nextout , nextin2, nexterr, FALSE);
                        runinfo->enable_break = enable_break;

                        sRFd_delete(nextin2);

                        if(*runinfo->break_) {
                            *runinfo->break_ = FALSE;
                            string_delete(str);
                            break;
                        }
                        else if(runinfo->enable_return && *runinfo->return_) {
                            string_delete(str);
                            FREE(fname);
                            return TRUE;
                        }
                        else if(*rcode < 0) {
                            string_delete(str);
                            FREE(fname);
                            return FALSE;
                        }
                        i++;

                        string_delete(str);
                    }

                    FREE(fname);
                }
                else if(number >= 2) {
                    char* fname = MALLOC(strlen(sname) + 32);
                    snprintf(fname, strlen(sname) + 32, "%s %d: each", sname, sline);
                    sBlock* block = vector_item(blocks, 0);
                    sStatments* statments = block->mStatments;

                    string_obj* arg;
                    if(vector_size(block->mArgs) >= 1) {
                        arg = vector_item(block->mArgs, 0);
                    }
                    else {
                        arg = NULL;
                    }

                    int i = 0;
                    while(1) {
                        if(gKitutukiSigInt)  {
                            err_msg("intterrupt", sname, sline);
                            FREE(fname);
                            return FALSE;
                        }
                        string_obj* str = STRING_NEW("");
                        int result = statment_tree_internal_commands_read_nextin_oneline_num(nextin, str, number, lf);

                        if(result == -1) {  // CTRL_C
                            err_msg("interrupt KKKK", sname, sline);
                            string_delete(str);
                            FREE(fname);
                            return FALSE;
                        }
                        else if(result == 1) { // EOF
                            string_delete(str);
                            break;
                        }

                        if(arg) {
                            char buf[1024];
                            snprintf(buf, 1024, "%d", i);
                            (void)saphire_set_local_var(string_c_str(arg), buf, NULL);
                        }

                        sRFd* nextin2 = RFD_NEW2(-1, string_c_str(str));
                        BOOL enable_break = runinfo->enable_break;
                        runinfo->enable_break = TRUE;
                        *rcode = run(runinfo, statments , fname, nextout , nextin2, nexterr, FALSE);
                        runinfo->enable_break  = enable_break;

                        sRFd_delete(nextin2);

                        if(*runinfo->break_) {
                            *runinfo->break_ = FALSE;
                            string_delete(str);
                            break;
                        }
                        else if(runinfo->enable_return && *runinfo->return_) {
                            string_delete(str);
                            FREE(fname);
                            return TRUE;
                        }
                        else if(*rcode < 0) {
                            string_delete(str);
                            FREE(fname);
                            return FALSE;
                        }
                        i++;

                        string_delete(str);
                    }

                    FREE(fname);
                }
            }
            }
            break;

        case kForeach: {
            if(vector_size(blocks) >= 1) {
                char* fname = MALLOC(strlen(sname) + 32);
                snprintf(fname, strlen(sname) + 32, "%s %d: each", sname, sline);
                sBlock* block = vector_item(blocks, 0);
                sStatments* statments = block->mStatments;

                int i;
                for(i=1; i<vector_size(argv); i++) {
                    if(gKitutukiSigInt)  {
                        err_msg("intterrupt", sname, sline);
                        FREE(fname);
                        return FALSE;
                    }
                    string_obj* str = vector_item(argv, i);

                    sRFd* nextin2 = RFD_NEW2(-1, string_c_str(str));
                    BOOL enable_break = runinfo->enable_break;
                    runinfo->enable_break = TRUE;
                    *rcode = run(runinfo, statments , fname, nextout , nextin2, nexterr , FALSE);
                    runinfo->enable_break = enable_break;
                    sRFd_delete(nextin2);

                    if(runinfo->enable_break && *runinfo->break_) {
                        *runinfo->break_ = FALSE;
                        break;
                    }
                    else if(runinfo->enable_return && *runinfo->return_) {
                        FREE(fname);
                        return TRUE;
                    }
                    else if(*rcode < 0) {
                        FREE(fname);
                        return FALSE;
                    }
                }

                FREE(fname);
            }
            }
            break;

        case kAbs: {
            int i;
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv,i));
                // take a STDIN pipe
                // ɸϤ
                if(strcmp(arg, "-I") == 0) {
                    input = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            string_obj* str = STRING_NEW("");
            if(input) {
                int ret = statment_tree_internal_commands_read_nextin(nextin, str) ;
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    break;
                }
                else if(ret < 0) {
                    *rcode = 2;
                    err_msg("interrupt", sname, sline);
                    string_delete(str);
                    return FALSE;
                }
            }
            else if(vector_size(argv) >= 2){
                string_put(str, string_c_str(vector_item(argv, 1)));
            }
            else {
                err_msg("abs: invalid argument", sname, sline);
                string_delete(str);
                return FALSE;
            }

            int n = abs(atoi(string_c_str(str)));
            string_delete(str);
            *rcode = 0;

            char buf[1024];
            snprintf(buf, 1024, "%d", n);
            if(!statment_tree_internal_commands_write_nextout(nextout, buf) )
            {
                err_msg("interrupt Kasdf", sname, sline);
                return FALSE;
            }
            if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
            {
                err_msg("singal interrupt", sname, sline);
                return FALSE;
            }


            
            }
            break;

        case kFAbs: {
            int i;
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv,i));
                // take a STDIN pipe
                // ɸϤ
                if(strcmp(arg, "-I") == 0) {
                    input = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            string_obj* str = STRING_NEW("");
            if(input) {
                int ret = statment_tree_internal_commands_read_nextin(nextin, str) ;
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    break;
                }
                else if(ret < 0) {
                    *rcode = 2;
                    err_msg("interrupt asdfasdfas", sname, sline);
                    string_delete(str);
                    return FALSE;
                }
            }
            else if(vector_size(argv) >= 2){
                string_put(str, string_c_str(vector_item(argv, 1)));
            }
            else {
                err_msg("abs: invalid argument", sname, sline);
                string_delete(str);
                return FALSE;
            }

            double n = fabs(atof(string_c_str(str)));
            string_delete(str);
            *rcode = 0;

            char buf[1024];
            snprintf(buf, 1024, "%lf", n);
            if(!statment_tree_internal_commands_write_nextout(nextout, buf) )
            {
                err_msg("interrupt GGG", sname, sline);
                return FALSE;
            }
            if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
            {
                err_msg("singal interrupt", sname, sline);
                return FALSE;
            }


            
            }
            break;

        case kP: {
            int scrolltop = -1;
            int cursor = -1;
            enum eLineField lf = gLineField;
            BOOL viewonly = FALSE;

            int i;
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv,i));
                // set on curor pojition
                // ݥꤹ
                if(strcmp(arg, "-c") == 0 
                    && i+1 < vector_size(argv)) 
                {
                    cursor = atoi(string_c_str(vector_item(argv, i+1)));
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // set on scroll top pojition
                // ȥåװ֤ꤹ
                else if(strcmp(arg, "-t") == 0 
                    && i+1 < vector_size(argv)) 
                {
                    scrolltop = atoi(string_c_str(vector_item(argv, i+1)));
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // no raise when cancel
                // 󥻥뤷˥顼򵯤ʤ
                else if(strcmp(arg, "-v") == 0) {
                    viewonly = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as CRLF
                // ԥɤCRLFȤư
                else if(strcmp(arg, "-Lw") == 0) {
                    lf = kCRLF;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as CR
                // ԥɤCRȤư
                else if(strcmp(arg, "-Lm") == 0) {
                    lf = kCR;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as LF
                // ԥɤLFȤư
                else if(strcmp(arg, "-Lu") == 0) {
                    lf = kLF;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // treat line field as Bel
                // ԥɤBelȤư
                else if(strcmp(arg, "-La") == 0) {
                    lf = kBel;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            if(scrolltop == -1) {
                scrolltop = 0;
            }
            if(cursor == -1) {
                cursor = 0;
            }

            string_obj* str = STRING_NEW("");
            int ret = statment_tree_internal_commands_read_nextin(nextin,str) ;
            if(ret == 1) {
                *rcode = 1;
                string_delete(str);
                break;
            }
            else if(ret < 0)
            {
                err_msg("interrupt", sname, sline);
                string_delete(str);
                return FALSE;
            }
            int result = -1;
            if(!statment_tree_internal_commands_p(str, &result, &scrolltop, &cursor, kUtf8, lf,sname, sline, viewonly))
            {
                string_delete(str);
                return FALSE;
            }

            if(!viewonly && (result == -1 || !statment_tree_internal_commands_write_nextout(nextout, string_c_str(str))))
            {
                err_msg("interrupt", sname, sline);

                string_delete(str);

                return FALSE;
            }
            *rcode = 0;

            string_delete(str);

            }
            break;

        case kQuote: {
            int i;
            BOOL bashquote = FALSE;
            BOOL all = FALSE;
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv,i));
                // quote with bash using characters
                // bashüʸ򥯥Ȥ
                if(strcmp(arg, "-b") == 0) {
                    bashquote = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // quote all non alphabet character
                // ե٥åȰʳȤ
                else if(strcmp(arg, "-all") == 0) {
                    all = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }
            if(input) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(
                                    nextin, str);
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    break;
                }
                else if(ret < 0)
                {
                    err_msg("interrupt a", sname, sline);
                    string_delete(str);
                    return FALSE;
                }

                string_obj* quoted = STRING_NEW("");
                if(bashquote) {
                    bash_get_quoted_fname(string_c_str(str), quoted);
                }
                else if(all) {
                    all_get_quoted_fname(string_c_str(str), quoted);
                }
                else {
                    saphire_get_quoted_fname(string_c_str(str), quoted);
                }
                string_delete(str);
                if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(quoted)) )
                {
                    err_msg("signal interrupt", sname, sline);
                    string_delete(quoted);
                    return FALSE;
                }

                *rcode = 0;
                string_delete(quoted);
            }
            else if(vector_size(argv) >= 1) {
                int i;
                for(i=1; i<vector_size(argv); i++) {
                    string_obj* str = vector_item(argv, i);

                    string_obj* quoted = STRING_NEW("");
                    if(bashquote) {
                        bash_get_quoted_fname(string_c_str(str), quoted);
                    }
                    else if(all) {
                        all_get_quoted_fname(string_c_str(str), quoted);
                    }
                    else {
                        saphire_get_quoted_fname(string_c_str(str), quoted);
                    }
                    if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(quoted)) )
                    {
                        string_delete(quoted);
                        err_msg("signal interrupt", sname, sline);
                        return FALSE;
                    }
                    string_delete(quoted);
                }

                *rcode = 0;
            }
            }
            break;

        case kTime: {
            if(vector_size(blocks) >= 1) {
                sBlock* block = vector_item(blocks, 0);
                sStatments* statments = block->mStatments;


                time_t timer;
                time(&timer);

                BOOL enable_break = runinfo->enable_break;
                runinfo->enable_break = TRUE;
                *rcode = run(runinfo, statments , "time", nextout , nextin, nexterr , FALSE);
                runinfo->enable_break = enable_break;

                if(runinfo->enable_break && *runinfo->break_) {
                    return TRUE;
                }
                else if(runinfo->enable_return && *runinfo->return_) {
                    return TRUE;
                }
                if(*rcode < 0) {
                    return FALSE;
                }

                time_t timer2;
                time(&timer2);
               

                int sec = timer2 - timer;
                int minuts = sec / 60;
                int sec2 = sec - minuts * 60;

                char buf[1024];
                snprintf(buf, 1024, "%d sec(%d minuts %d sec)\n", sec, minuts, sec2);

                if(!statment_tree_internal_commands_write_nextout(nextout, buf) )
                {
                    err_msg("signal interrupt", sname, sline);
                    return FALSE;
                }
            }
            }
            break;

        case kFSelector: {
            int i;
            BOOL multiple = FALSE;
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv,i));
                // multiline
                // ʣԤˤޤɽ
                if(strcmp(arg, "-m") == 0) {
                    multiple = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            if(!statment_tree_internal_commands_fselector(nextout, sname, sline, multiple))
            {
                return FALSE;
            }
            *rcode = 0;
            }
            break;

        case kUnset: {
            if(vector_size(argv) == 2) {
                char* name = string_c_str(vector_item(argv, 1));
                if(unsetenv(name) == 0) {
                    *rcode = 0;
                }
                else {
                    err_msg("invalid env name", sname, sline);
                    return FALSE;
                }
            }
            }
            break;

        case kUMask: {
            if(vector_size(argv) == 2) {
                int number = strtol(string_c_str(vector_item(argv, 1)), NULL, 8);
                umask(number);
                *rcode =0;
            }
            }
            break;

        case kErrMsg: {
            if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(gErrMsg)) )
            {
                err_msg("signal interrupt", sname, sline);
                return FALSE;
            }
            if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
            {
                err_msg("singal interrupt", sname, sline);
                return FALSE;
            }
            *rcode = 0;
            }
            break;

        case kRunInfo: {
            if(!statment_tree_internal_commands_write_nextout(nextout, "+++ Source Info +++")) 
            {
                err_msg("signal interrupt", sname, sline);
                return FALSE;
            }
            if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
            {
                err_msg("singal interrupt", sname, sline);
                return FALSE;
            }
            if(!statment_tree_internal_commands_write_nextout(nextout, sname))
            {
                err_msg("signal interrupt", sname, sline);
                return FALSE;
            }
            if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
            {
                err_msg("singal interrupt", sname, sline);
                return FALSE;
            }
            char buf[128];
            snprintf(buf, 128, "%d", sline);
            if(!statment_tree_internal_commands_write_nextout(nextout, buf))
            {
                err_msg("signal interrupt", sname, sline);
                return FALSE;
            }
            if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
            {
                err_msg("singal interrupt", sname, sline);
                return FALSE;
            }

            if(runinfo->object) {
                if(!statment_tree_internal_commands_write_nextout(nextout, "+++ Classes +++")) 
                {
                    err_msg("signal interrupt", sname, sline);
                    return FALSE;
                }
                if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                {
                    err_msg("singal interrupt", sname, sline);
                    return FALSE;
                }

                sObject* parent = runinfo->object;
                while(parent) {
                    if(parent->mClassName) {
                        if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(parent->mClassName))) 
                        {
                            err_msg("signal interrupt", sname, sline);
                            return FALSE;
                        }
                        if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                        {
                            err_msg("singal interrupt", sname, sline);
                            return FALSE;
                        }
                    }
                    else {
                        if(!statment_tree_internal_commands_write_nextout(nextout, "nothing")) 
                        {
                            err_msg("signal interrupt", sname, sline);
                            return FALSE;
                        }
                        if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                        {
                            err_msg("singal interrupt", sname, sline);
                            return FALSE;
                        }
                    }

                    parent = parent->mParent;
                }

                if(!statment_tree_internal_commands_write_nextout(nextout, "+++ Objects +++")) 
                {
                    err_msg("signal interrupt", sname, sline);
                    return FALSE;
                }
                if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                {
                    err_msg("singal interrupt", sname, sline);
                    return FALSE;
                }

                parent = runinfo->object;
                while(parent) {
                    if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(parent->mName))) 
                    {
                        err_msg("signal interrupt", sname, sline);
                        return FALSE;
                    }
                    if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                    {
                        err_msg("singal interrupt", sname, sline);
                        return FALSE;
                    }

                    parent = parent->mParent;
                }
            }

            if(!statment_tree_internal_commands_write_nextout(nextout, "+++ Running Class +++")) 
            {
                err_msg("signal interrupt", sname, sline);
                return FALSE;
            }
            if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
            {
                err_msg("singal interrupt", sname, sline);
                return FALSE;
            }
            if(runinfo->running_class) {
                if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(runinfo->running_class->name))) 
                {
                    err_msg("signal interrupt", sname, sline);
                    return FALSE;
                }
                if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                {
                    err_msg("singal interrupt", sname, sline);
                    return FALSE;
                }
                if(!statment_tree_internal_commands_write_nextout(nextout, "+++ Running Class Info +++")) 
                {
                    err_msg("signal interrupt", sname, sline);
                    return FALSE;
                }
                if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                {
                    err_msg("singal interrupt", sname, sline);
                    return FALSE;
                }
                if(runinfo->running_class->input) {
                    if(!statment_tree_internal_commands_write_nextout(nextout, "input"))
                    {
                        err_msg("signal interrupt", sname, sline);
                        return FALSE;
                    }
                    if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                    {
                        err_msg("singal interrupt", sname, sline);
                        return FALSE;
                    }
                }
                if(runinfo->running_class->output) {
                    if(!statment_tree_internal_commands_write_nextout(nextout, "output"))
                    {
                        err_msg("signal interrupt", sname, sline);
                        return FALSE;
                    }
                    if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                    {
                        err_msg("singal interrupt", sname, sline);
                        return FALSE;
                    }
                }
            }

            if(!statment_tree_internal_commands_write_nextout(nextout, "+++ Running Function +++")) 
            {
                err_msg("signal interrupt", sname, sline);
                return FALSE;
            }
            if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
            {
                err_msg("singal interrupt", sname, sline);
                return FALSE;
            }
            if(runinfo->running_fun) {
                if(!statment_tree_internal_commands_write_nextout(nextout, string_c_str(runinfo->running_fun->name))) 
                {
                    err_msg("signal interrupt", sname, sline);
                    return FALSE;
                }
                if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                {
                    err_msg("singal interrupt", sname, sline);
                    return FALSE;
                }
                if(!statment_tree_internal_commands_write_nextout(nextout, "+++ Running Function Info +++")) 
                {
                    err_msg("signal interrupt", sname, sline);
                    return FALSE;
                }
                if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                {
                    err_msg("singal interrupt", sname, sline);
                    return FALSE;
                }
                if(runinfo->running_fun->input) {
                    if(!statment_tree_internal_commands_write_nextout(nextout, "input"))
                    {
                        err_msg("signal interrupt", sname, sline);
                        return FALSE;
                    }
                    if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                    {
                        err_msg("singal interrupt", sname, sline);
                        return FALSE;
                    }
                }
                if(runinfo->running_fun->output) {
                    if(!statment_tree_internal_commands_write_nextout(nextout, "output"))
                    {
                        err_msg("signal interrupt", sname, sline);
                        return FALSE;
                    }
                    if(!statment_tree_internal_commands_write_lf(nextout,  kLF))
                    {
                        err_msg("singal interrupt", sname, sline);
                        return FALSE;
                    }
                }
            }

            *rcode = 0;
            }
            break;

        case kConditionN: {
            if(input) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str); 
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    return TRUE;
                }
                else if(ret < 0)
                {
                    string_delete(str);
                    return FALSE;
                }

                if(strcmp(string_c_str(str), "") != 0) {
                    *rcode = 0;
                }

                string_delete(str);
            }
            else {
                if(vector_size(argv) > 1) {
                    int i;
                    for(i=1; i<vector_size(argv); i++) {
                        char* item = string_c_str(vector_item(argv, i));

                        if(strcmp(item, "") != 0) {
                            *rcode = 0;
                        }
                        else {
                            break;
                        }
                    }
                }
            }
            }
            break;

        case kConditionZ: {
            if(input) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str); 
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    return TRUE;
                }
                else if(ret < 0)
                {
                    string_delete(str);
                    return FALSE;
                }

                if(strcmp(string_c_str(str), "") == 0) {
                    *rcode = 0;
                }

                string_delete(str);
            }
            else {
                if(vector_size(argv) > 1) {
                    int i;
                    for(i=1; i<vector_size(argv); i++) {
                        char* item = string_c_str(vector_item(argv, i));

                        if(strcmp(item, "") == 0) {
                            *rcode = 0;
                        }
                        else {
                            break;
                        }
                    }
                }
            }
            }
            break;

        case kConditionB: {
            if(input) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str); 
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    return TRUE;
                }
                else if(ret < 0)
                {
                    string_delete(str);
                    return FALSE;
                }

                struct stat stat_;
                if(stat(string_c_str(str), &stat_) == 0) {
                    if(S_ISBLK(stat_.st_mode)) {
                        *rcode = 0;
                    }
                }

                string_delete(str);
            }
            else {
                if(vector_size(argv) > 1) {
                    int i;
                    for(i=1; i<vector_size(argv); i++) {
                        char* item = string_c_str(vector_item(argv, i));

                        struct stat stat_;
                        if(stat(item, &stat_) == 0) {
                            if(S_ISBLK(stat_.st_mode)) {
                                *rcode = 0;
                            }
                            else {
                                break;
                            }
                        }
                        else {
                            break;
                        }
                    }
                }
            }
            }
            break;

        case kConditionC: {
            if(input) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str); 
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    return TRUE;
                }
                else if(ret < 0)
                {
                    string_delete(str);
                    return FALSE;
                }

                struct stat stat_;
                if(stat(string_c_str(str), &stat_) == 0) {
                    if(S_ISCHR(stat_.st_mode)) {
                        *rcode = 0;
                    }
                }

                string_delete(str);
            }
            else {
                if(vector_size(argv) > 1) {
                    int i;
                    for(i=1; i<vector_size(argv); i++) {
                        char* item = string_c_str(vector_item(argv, i));

                        struct stat stat_;
                        if(stat(item, &stat_) == 0) {
                            if(S_ISCHR(stat_.st_mode)) {
                                *rcode = 0;
                            }
                            else {
                                break;
                            }
                        }
                        else {
                            break;
                        }
                    }
                }
            }
            }
            break;

        case kConditionD: {
            if(input) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str); 
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    return TRUE;
                }
                else if(ret < 0)
                {
                    string_delete(str);
                    return FALSE;
                }

                struct stat stat_;
                if(stat(string_c_str(str), &stat_) == 0) {
                    if(S_ISDIR(stat_.st_mode)) {
                        *rcode = 0;
                    }
                }

                string_delete(str);
            }
            else {
                if(vector_size(argv) > 1) {
                    int i;
                    for(i=1; i<vector_size(argv); i++) {
                        char* item = string_c_str(vector_item(argv, i));

                        struct stat stat_;
                        if(stat(item, &stat_) == 0) {
                            if(S_ISDIR(stat_.st_mode)) {
                                *rcode = 0;
                            }
                            else {
                                break;
                            }
                        }
                        else {
                            break;
                        }
                    }
                }
            }
            }
            break;

        case kConditionF: {
            if(input) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str); 
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    return TRUE;
                }
                else if(ret < 0)
                {
                    string_delete(str);
                    return FALSE;
                }

                struct stat stat_;
                if(stat(string_c_str(str), &stat_) == 0) {
                    if(S_ISREG(stat_.st_mode)) {
                        *rcode = 0;
                    }
                }

                string_delete(str);
            }
            else {
                if(vector_size(argv) > 1) {
                    int i;
                    for(i=1; i<vector_size(argv); i++) {
                        char* item = string_c_str(vector_item(argv, i));

                        struct stat stat_;
                        if(stat(item, &stat_) == 0) {
                            if(S_ISREG(stat_.st_mode)) {
                                *rcode = 0;
                            }
                            else {
                                break;
                            }
                        }
                        else {
                            break;
                        }
                    }
                }
            }
            }
            break;

        case kConditionH: {
            if(input) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str); 
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    return TRUE;
                }
                else if(ret < 0)
                {
                    string_delete(str);
                    return FALSE;
                }

                struct stat stat_;
                if(stat(string_c_str(str), &stat_) == 0) {
                    if(S_ISLNK(stat_.st_mode)) {
                        *rcode = 0;
                    }
                }

                string_delete(str);
            }
            else {
                if(vector_size(argv) > 1) {
                    int i;
                    for(i=1; i<vector_size(argv); i++) {
                        char* item = string_c_str(vector_item(argv, i));

                        struct stat stat_;
                        if(stat(item, &stat_) == 0) {
                            if(S_ISLNK(stat_.st_mode)) {
                                *rcode = 0;
                            }
                            else {
                                break;
                            }
                        }
                        else {
                            break;
                        }
                    }
                }
            }
            }
            break;

        case kConditionL: {
            if(input) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str); 
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    return TRUE;
                }
                else if(ret < 0)
                {
                    string_delete(str);
                    return FALSE;
                }

                struct stat stat_;
                if(stat(string_c_str(str), &stat_) == 0) {
                    if(S_ISLNK(stat_.st_mode)) {
                        *rcode = 0;
                    }
                }

                string_delete(str);
            }
            else {
                if(vector_size(argv) > 1) {
                    int i;
                    for(i=1; i<vector_size(argv); i++) {
                        char* item = string_c_str(vector_item(argv, i));

                        struct stat stat_;
                        if(stat(item, &stat_) == 0) {
                            if(S_ISLNK(stat_.st_mode)) {
                                *rcode = 0;
                            }
                            else {
                                break;
                            }
                        }
                        else {
                            break;
                        }
                    }
                }
            }
            }
            break;

        case kConditionP: {
            if(input) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str); 
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    return TRUE;
                }
                else if(ret < 0)
                {
                    string_delete(str);
                    return FALSE;
                }

                struct stat stat_;
                if(stat(string_c_str(str), &stat_) == 0) {
                    if(S_ISFIFO(stat_.st_mode)) {
                        *rcode = 0;
                    }
                }

                string_delete(str);
            }
            else {
                if(vector_size(argv) > 1) {
                    int i;
                    for(i=1; i<vector_size(argv); i++) {
                        char* item = string_c_str(vector_item(argv, i));

                        struct stat stat_;
                        if(stat(item, &stat_) == 0) {
                            if(S_ISFIFO(stat_.st_mode)) {
                                *rcode = 0;
                            }
                            else {
                                break;
                            }
                        }
                        else {
                            break;
                        }
                    }
                }
            }
            }
            break;

        case kConditionS2: {
            if(input) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str); 
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    return TRUE;
                }
                else if(ret < 0)
                {
                    string_delete(str);
                    return FALSE;
                }

                struct stat stat_;
                if(stat(string_c_str(str), &stat_) == 0) {
                    if(S_ISSOCK(stat_.st_mode)) {
                        *rcode = 0;
                    }
                }

                string_delete(str);
            }
            else {
                if(vector_size(argv) > 1) {
                    int i;
                    for(i=1; i<vector_size(argv); i++) {
                        char* item = string_c_str(vector_item(argv, i));

                        struct stat stat_;
                        if(stat(item, &stat_) == 0) {
                            if(S_ISSOCK(stat_.st_mode)) {
                                *rcode = 0;
                            }
                            else {
                                break;
                            }
                        }
                        else {
                            break;
                        }
                    }
                }
            }
            }
            break;

        case kConditionT:
            break;

        case kConditionG: {
            if(input) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str); 
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    return TRUE;
                }
                else if(ret < 0)
                {
                    string_delete(str);
                    return FALSE;
                }

                struct stat stat_;
                if(stat(string_c_str(str), &stat_) == 0) {
                    if(stat_.st_mode & S_ISGID) {
                        *rcode = 0;
                    }
                }

                string_delete(str);
            }
            else {
                if(vector_size(argv) > 1) {
                    int i;
                    for(i=1; i<vector_size(argv); i++) {
                        char* item = string_c_str(vector_item(argv, i));

                        struct stat stat_;
                        if(stat(item, &stat_) == 0) {
                            if(stat_.st_mode & S_ISGID) {
                                *rcode = 0;
                            }
                            else {
                                break;
                            }
                        }
                        else {
                            break;
                        }
                    }
                }
            }
            }
            break;

        case kConditionK: {
            if(input) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str); 
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    return TRUE;
                }
                else if(ret < 0)
                {
                    string_delete(str);
                    return FALSE;
                }

                struct stat stat_;
                if(stat(string_c_str(str), &stat_) == 0) {
#if defined(S_ISTXT)
                    if(stat_.st_mode & S_ISTXT) {
                        *rcode = 0;
                    }
#endif
#if defined(S_ISVTX)
                    if(stat_.st_mode & S_ISVTX) {
                        *rcode = 0;
                    }
#endif
                }

                string_delete(str);
            }
            else {
                if(vector_size(argv) > 1) {
                    int i;
                    for(i=1; i<vector_size(argv); i++) {
                        char* item = string_c_str(vector_item(argv, i));

                        struct stat stat_;
                        if(stat(item, &stat_) == 0) {
#if defined(S_ISTXT)
                            if(stat_.st_mode & S_ISTXT) {
                                *rcode = 0;
                            }
#endif
#if defined(S_ISVTX)
                            if(stat_.st_mode & S_ISVTX) {
                                *rcode = 0;
                            }
#endif
                            else {
                                break;
                            }
                        }
                        else {
                            break;
                        }
                    }
                }
            }
            }
            break;

        case kConditionU: {
            if(input) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str); 
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    return TRUE;
                }
                else if(ret < 0)
                {
                    string_delete(str);
                    return FALSE;
                }

                struct stat stat_;
                if(stat(string_c_str(str), &stat_) == 0) {
                    if(stat_.st_mode & S_ISUID) {
                        *rcode = 0;
                    }
                }

                string_delete(str);
            }
            else {
                if(vector_size(argv) > 1) {
                    int i;
                    for(i=1; i<vector_size(argv); i++) {
                        char* item = string_c_str(vector_item(argv, i));

                        struct stat stat_;
                        if(stat(item, &stat_) == 0) {
                            if(stat_.st_mode & S_ISUID) {
                                *rcode = 0;
                            }
                            else {
                                break;
                            }
                        }
                        else {
                            break;
                        }
                    }
                }
            }
            }
            break;

        case kConditionR: {
            if(input) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str); 
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    return TRUE;
                }
                else if(ret < 0)
                {
                    string_delete(str);
                    return FALSE;
                }

                if(access(string_c_str(str), R_OK) == 0) {
                    *rcode = 0;
                }

                string_delete(str);
            }
            else {
                if(vector_size(argv) > 1) {
                    int i;
                    for(i=1; i<vector_size(argv); i++) {
                        char* item = string_c_str(vector_item(argv, i));

                        if(access(item, R_OK) == 0) {
                            *rcode = 0;
                        }
                        else {
                            break;
                        }
                    }
                }
            }
            }
            break;

        case kConditionW: {
            if(input) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str); 
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    return TRUE;
                }
                else if(ret < 0)
                {
                    string_delete(str);
                    return FALSE;
                }

                if(access(string_c_str(str), W_OK) == 0) {
                    *rcode = 0;
                }

                string_delete(str);
            }
            else {
                if(vector_size(argv) > 1) {
                    int i;
                    for(i=1; i<vector_size(argv); i++) {
                        char* item = string_c_str(vector_item(argv, i));

                        if(access(item, W_OK) == 0) {
                            *rcode = 0;
                        }
                        else {
                            break;
                        }
                    }
                }
            }
            }
            break;

        case kConditionX: {
            if(input) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str); 
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    return TRUE;
                }
                else if(ret < 0)
                {
                    string_delete(str);
                    return FALSE;
                }

                if(access(string_c_str(str), X_OK) == 0) {
                    *rcode = 0;
                }

                string_delete(str);
            }
            else {
                if(vector_size(argv) > 1) {
                    int i;
                    for(i=1; i<vector_size(argv); i++) {
                        char* item = string_c_str(vector_item(argv, i));

                        if(access(item, X_OK) == 0) {
                            *rcode = 0;
                        }
                        else {
                            break;
                        }
                    }
                }
            }
            }
            break;

        case kConditionO: {
            if(input) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str); 
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    return TRUE;
                }
                else if(ret < 0)
                {
                    string_delete(str);
                    return FALSE;
                }

                struct stat stat_;
                if(stat(string_c_str(str), &stat_) == 0) {
                    if(stat_.st_uid == getuid()) {
                        *rcode = 0;
                    }
                }

                string_delete(str);
            }
            else {
                if(vector_size(argv) > 1) {
                    int i;
                    for(i=1; i<vector_size(argv); i++) {
                        char* item = string_c_str(vector_item(argv, i));

                        struct stat stat_;
                        if(stat(item, &stat_) == 0) {
                            if(stat_.st_uid == getuid()) {
                                *rcode = 0;
                            }
                            else {
                                break;
                            }
                        }
                        else {
                            break;
                        }
                    }
                }
            }
            }
            break;

        case kConditionG2: {
            if(input) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str); 
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    return TRUE;
                }
                else if(ret < 0)
                {
                    string_delete(str);
                    return FALSE;
                }

                struct stat stat_;
                if(stat(string_c_str(str), &stat_) == 0) {
                    if(stat_.st_gid == getgid()) {
                        *rcode = 0;
                    }
                }

                string_delete(str);
            }
            else {
                if(vector_size(argv) > 1) {
                    int i;
                    for(i=1; i<vector_size(argv); i++) {
                        char* item = string_c_str(vector_item(argv, i));

                        struct stat stat_;
                        if(stat(item, &stat_) == 0) {
                            if(stat_.st_gid == getgid()) {
                                *rcode = 0;
                            }
                            else {
                                break;
                            }
                        }
                        else {
                            break;
                        }
                    }
                }
            }
            }
            break;

        case kConditionE: {
            if(input) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str); 
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    return TRUE;
                }
                else if(ret < 0)
                {
                    string_delete(str);
                    return FALSE;
                }

                struct stat stat_;
                if(stat(string_c_str(str), &stat_) == 0) {
                    *rcode = 0;
                }

                string_delete(str);
            }
            else {
                if(vector_size(argv) > 1) {
                    int i;
                    for(i=1; i<vector_size(argv); i++) {
                        char* item = string_c_str(vector_item(argv, i));

                        struct stat stat_;
                        if(stat(item, &stat_) == 0) {
                            *rcode = 0;
                        }
                        else {
                            break;
                        }
                    }
                }
            }
            }
            break;

        case kConditionS: {
            if(input) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str); 
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    return TRUE;
                }
                else if(ret < 0)
                {
                    string_delete(str);
                    return FALSE;
                }

                struct stat stat_;
                if(stat(string_c_str(str), &stat_) == 0) {
                    if(stat_.st_size > 0) {
                        *rcode = 0;
                    }
                }

                string_delete(str);
            }
            else {
                if(vector_size(argv) > 1) {
                    int i;
                    for(i=1; i<vector_size(argv); i++) {
                        char* item = string_c_str(vector_item(argv, i));

                        struct stat stat_;
                        if(stat(item, &stat_) == 0) {
                            if(stat_.st_size > 0) {
                                *rcode = 0;
                            }
                            else {
                                break;
                            }
                        }
                        else {
                            break;
                        }
                    }
                }
            }
            }
            break;

        case kConditionEq: {
            if(input && vector_size(argv) == 2) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str); 
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    return TRUE;
                }
                else if(ret < 0)
                {
                    string_delete(str);
                    return FALSE;
                }

                if(strcmp(string_c_str(str), string_c_str(vector_item(argv, 1))) == 0) {
                    *rcode = 0;
                }

                string_delete(str);
            }
            else if(vector_size(argv) == 3) {
                if(strcmp(string_c_str(vector_item(argv, 1)), string_c_str(vector_item(argv,2))) == 0) {
                    *rcode = 0;
                }
            }
            }
            break;

        case kConditionNEq: {
            if(input && vector_size(argv) == 2) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str); 
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    return TRUE;
                }
                else if(ret < 0)
                {
                    string_delete(str);
                    return FALSE;
                }

                if(strcmp(string_c_str(str), string_c_str(vector_item(argv, 1))) != 0) {
                    *rcode = 0;
                }

                string_delete(str);
            }
            else if(vector_size(argv) == 3) {
                if(strcmp(string_c_str(vector_item(argv, 1)), string_c_str(vector_item(argv,2))) != 0) {
                    *rcode = 0;
                }
            }
            }
            break;

        case kConditionSLT: {
            if(input && vector_size(argv) == 2) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str); 
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    return TRUE;
                }
                else if(ret < 0)
                {
                    string_delete(str);
                    return FALSE;
                }

                if(strcmp(string_c_str(str), string_c_str(vector_item(argv, 1))) < 0) {
                    *rcode = 0;
                }

                string_delete(str);
            }
            else if(vector_size(argv) == 3) {
                if(strcmp(string_c_str(vector_item(argv, 1)), string_c_str(vector_item(argv,2))) < 0) {
                    *rcode = 0;
                }
            }
            }
            break;

        case kConditionSGT: {
            if(input && vector_size(argv) == 2) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str); 
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    return TRUE;
                }
                else if(ret < 0)
                {
                    string_delete(str);
                    return FALSE;
                }

                if(strcmp(string_c_str(str), string_c_str(vector_item(argv, 1))) > 0) {
                    *rcode = 0;
                }

                string_delete(str);
            }
            else if(vector_size(argv) == 3) {
                if(strcmp(string_c_str(vector_item(argv, 1)), string_c_str(vector_item(argv,2))) > 0) {
                    *rcode = 0;
                }
            }
            }
            break;

        case kConditionSLE: {
            if(input && vector_size(argv) == 2) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str); 
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    return TRUE;
                }
                else if(ret < 0)
                {
                    string_delete(str);
                    return FALSE;
                }

                if(strcmp(string_c_str(str), string_c_str(vector_item(argv, 1))) <= 0) {
                    *rcode = 0;
                }

                string_delete(str);
            }
            else if(vector_size(argv) == 3) {
                if(strcmp(string_c_str(vector_item(argv, 1)), string_c_str(vector_item(argv,2))) <= 0) {
                    *rcode = 0;
                }
            }
            }
            break;

        case kConditionSGE: {
            if(input && vector_size(argv) == 2) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str); 
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    return TRUE;
                }
                else if(ret < 0)
                {
                    string_delete(str);
                    return FALSE;
                }

                if(strcmp(string_c_str(str), string_c_str(vector_item(argv, 1))) >= 0) {
                    *rcode = 0;
                }

                string_delete(str);
            }
            else if(vector_size(argv) == 3) {
                if(strcmp(string_c_str(vector_item(argv, 1)), string_c_str(vector_item(argv,2))) >= 0) {
                    *rcode = 0;
                }
            }
            }
            break;

        case kConditionSILT: {
            if(input && vector_size(argv) == 2) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str); 
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    return TRUE;
                }
                else if(ret < 0)
                {
                    string_delete(str);
                    return FALSE;
                }

                if(strcasecmp(string_c_str(str), string_c_str(vector_item(argv, 1))) < 0) {
                    *rcode = 0;
                }

                string_delete(str);
            }
            else if(vector_size(argv) == 3) {
                if(strcasecmp(string_c_str(vector_item(argv, 1)), string_c_str(vector_item(argv,2))) < 0) {
                    *rcode = 0;
                }
            }
            }
            break;

        case kConditionSIGT: {
            if(input && vector_size(argv) == 2) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str); 
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    return TRUE;
                }
                else if(ret < 0)
                {
                    string_delete(str);
                    return FALSE;
                }

                if(strcasecmp(string_c_str(str), string_c_str(vector_item(argv, 1))) < 0) {
                    *rcode = 0;
                }

                string_delete(str);
            }
            else if(vector_size(argv) == 3) {
                if(strcasecmp(string_c_str(vector_item(argv, 1)), string_c_str(vector_item(argv,2))) < 0) {
                    *rcode = 0;
                }
            }
            }
            break;

        case kConditionSILE: {
            if(input && vector_size(argv) == 2) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str); 
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    return TRUE;
                }
                else if(ret < 0)
                {
                    string_delete(str);
                    return FALSE;
                }

                if(strcasecmp(string_c_str(str), string_c_str(vector_item(argv, 1))) <= 0) {
                    *rcode = 0;
                }

                string_delete(str);
            }
            else if(vector_size(argv) == 3) {
                if(strcasecmp(string_c_str(vector_item(argv, 1)), string_c_str(vector_item(argv,2))) <= 0) {
                    *rcode = 0;
                }
            }
            }
            break;

        case kConditionSIGE: {
            if(input && vector_size(argv) == 2) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str); 
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    return TRUE;
                }
                else if(ret < 0)
                {
                    string_delete(str);
                    return FALSE;
                }

                if(strcasecmp(string_c_str(str), string_c_str(vector_item(argv, 1))) >= 0) {
                    *rcode = 0;
                }

                string_delete(str);
            }
            else if(vector_size(argv) == 3) {
                if(strcasecmp(string_c_str(vector_item(argv, 1)), string_c_str(vector_item(argv,2))) >= 0) {
                    *rcode = 0;
                }
            }
            }
            break;

        case kConditionEqI: {
            if(input && vector_size(argv) == 2) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str); 
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    return TRUE;
                }
                else if(ret < 0)
                {
                    string_delete(str);
                    return FALSE;
                }

                if(strcasecmp(string_c_str(str), string_c_str(vector_item(argv, 1))) == 0) {
                    *rcode = 0;
                }

                string_delete(str);
            }
            else if(vector_size(argv) == 3) {
                if(strcasecmp(string_c_str(vector_item(argv, 1)), string_c_str(vector_item(argv,2))) == 0) {
                    *rcode = 0;
                }
            }
            }
            break;

        case kConditionRE:
        case kConditionREIM:
        case kConditionREMI:
        case kConditionREI:
        case kConditionREM: {
            int i;
            enum eKanjiCode code = gKanjiCode;
            for(i=0; i<vector_size(argv); i++) {
                char* arg = string_c_str(vector_item(argv, i));

                // take a STDIN pipe
                // ɸϤ
                if(strcmp(arg, "-I") == 0) {
                    input = TRUE;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // assume data as Shift JIS
                // ǡSjis󥳡ɤȤư
                else if(strcmp(arg, "-s") == 0) {
                    code = kSjis;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // assume data as Eucjp
                // ǡEucjp󥳡ɤȤư
                else if(strcmp(arg, "-e") == 0) {
                    code = kEucjp;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // assume data as Utf-8
                // ǡUtf-8󥳡ɤȤư
                else if(strcmp(arg, "-w") == 0) {
                    code = kUtf8;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
                // assume data as ASCII code
                // ǡASCIIǡȤư
                else if(strcmp(arg, "-b") == 0) {
                    code = kByte;
                    string_delete(vector_item(argv, i));
                    vector_erase(argv, i);
                    i--;
                    continue;
                }
            }

            char* target;
            char* regex;
            string_obj* str;
            if(input && vector_size(argv) == 2) {
                str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str); 
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    return TRUE;
                }
                else if(ret < 0)
                {
                    string_delete(str);
                    return FALSE;
                }

                target = string_c_str(str);
                regex = string_c_str(vector_item(argv, 1));
            }
            else if(vector_size(argv) == 3) {
                target = string_c_str(vector_item(argv, 1));
                regex = string_c_str(vector_item(argv, 2));
                str = NULL;
            }
            else {
                break;
            }

            char* regex2 = regex;

            int r;
            regex_t* reg;

            if(command->mKind == kConditionREIM || command->mKind == kConditionREMI)
            {
                reg = get_reg(&r, regex2, TRUE, TRUE, code);
            }
            else if(command->mKind == kConditionREI) {
                reg = get_reg(&r, regex2, TRUE, FALSE, code);
            }
            else if(command->mKind == kConditionREM) {
                reg = get_reg(&r, regex2, FALSE, TRUE, code);
            }
            else {
                reg = get_reg(&r, regex2, FALSE, FALSE, code);
            }

            if(r == ONIG_NORMAL) {
                OnigRegion* region = onig_region_new();
                int r2 = onig_search(reg, target
                   , target + strlen(target)
                   , target, target + strlen(target)
                   , region, ONIG_OPTION_NONE);

                if(region->num_regs > 0) {
                    if(region->beg[0] > 0) {
                        /// ޥåʸ ///
                        char* tmp = MALLOC(region->beg[0] + 1);

                        memcpy(tmp, target, region->beg[0]);
                        tmp[region->beg[0]] = 0;

                        (void)saphire_set_local_var("PREMATCH", tmp, NULL);

                        FREE(tmp);
                    }
                    else {
                        (void)saphire_set_local_var("PREMATCH", "", NULL);
                    }

                    /// ޥåʸ ///
                    char* tmp = MALLOC(
                            region->end[0]-region->beg[0] + 1);

                    memcpy(tmp, target + region->beg[0]
                     , region->end[0]-region->beg[0]);

                    tmp[region->end[0]
                        - region->beg[0]] = 0;

                    (void)saphire_set_local_var("MATCH", tmp, NULL);

                    FREE(tmp);

                    /// ޥåʸθ ///
                    const int n = strlen(target)-region->end[0];
                    if(n > 0) {
                        char* tmp = MALLOC(n + 1);

                        memcpy(tmp, target + region->end[0], n);

                        tmp[n] = 0;

                        (void)saphire_set_local_var("POSTMATCH", tmp, NULL);

                        FREE(tmp);
                    }
                    else {
                        (void)saphire_set_local_var("POSTMATCH", "", NULL);
                    }
                }
                if(r2 >= 0) {
                    int i;
                    for (i=1; i<region->num_regs; i++) {
                        char* tmp =
                            MALLOC(region->end[i]-region->beg[i]+1);

                        memcpy(tmp, target + region->beg[i]
                         , region->end[i]-region->beg[i]);

                        tmp[region->end[i]
                            - region->beg[i]] = 0;

                        char name[16];
                        snprintf(name, 16, "%d", i);

                        (void)saphire_set_local_var(name, tmp, NULL);

                        FREE(tmp);
                    }
                }

                if(r2 >= 0) {
                    *rcode = 0;
                }

                onig_region_free(region, 1);
            }
            else {
                err_msg("-re: invalid regex", sname, sline);

                if(str) string_delete(str);
                return FALSE;
            }

            if(str) string_delete(str);
            }
            break;

        case kConditionEQ: {
            if(input && vector_size(argv) == 2) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str); 
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    return TRUE;
                }
                else if(ret < 0)
                {
                    string_delete(str);
                    return FALSE;
                }

                if(atoi(string_c_str(str)) == atoi(string_c_str(vector_item(argv, 1)))) {
                    *rcode = 0;
                }

                string_delete(str);
            }
            else if(vector_size(argv) == 3) {
                if(atoi(string_c_str(vector_item(argv, 1))) == atoi(string_c_str(vector_item(argv,2)))) 
                {
                    *rcode = 0;
                }
            }
            }
            break;

        case kConditionNE: {
            if(input && vector_size(argv) == 2) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str); 
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    return TRUE;
                }
                else if(ret < 0)
                {
                    string_delete(str);
                    return FALSE;
                }

                if(atoi(string_c_str(str)) != atoi(string_c_str(vector_item(argv, 1)))) {
                    *rcode = 0;
                }

                string_delete(str);
            }
            else if(vector_size(argv) == 3) {
                if(atoi(string_c_str(vector_item(argv, 1))) != atoi(string_c_str(vector_item(argv,2)))) 
                {
                    *rcode = 0;
                }
            }
            }
            break;

        case kConditionLT: {
            if(input && vector_size(argv) == 2) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str); 
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    return TRUE;
                }
                else if(ret < 0)
                {
                    string_delete(str);
                    return FALSE;
                }

                if(atoi(string_c_str(str)) < atoi(string_c_str(vector_item(argv, 1)))) {
                    *rcode = 0;
                }

                string_delete(str);
            }
            else if(vector_size(argv) == 3) {
                if(atoi(string_c_str(vector_item(argv, 1))) < atoi(string_c_str(vector_item(argv,2)))) 
                {
                    *rcode = 0;
                }
            }
            }
            break;

        case kConditionLE: {
            if(input && vector_size(argv) == 2) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str); 
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    return TRUE;
                }
                else if(ret < 0)
                {
                    string_delete(str);
                    return FALSE;
                }

                if(atoi(string_c_str(str)) <= atoi(string_c_str(vector_item(argv, 1)))) {
                    *rcode = 0;
                }

                string_delete(str);
            }
            else if(vector_size(argv) == 3) {
                if(atoi(string_c_str(vector_item(argv, 1))) <= atoi(string_c_str(vector_item(argv,2)))) 
                {
                    *rcode = 0;
                }
            }
            }
            break;

        case kConditionGT: {
            if(input && vector_size(argv) == 2) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str); 
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    return TRUE;
                }
                else if(ret < 0)
                {
                    string_delete(str);
                    return FALSE;
                }

                if(atoi(string_c_str(str)) > atoi(string_c_str(vector_item(argv, 1)))) {
                    *rcode = 0;
                }

                string_delete(str);
            }
            else if(vector_size(argv) == 3) {
                if(atoi(string_c_str(vector_item(argv, 1))) > atoi(string_c_str(vector_item(argv,2)))) 
                {
                    *rcode = 0;
                }
            }
            }
            break;

        case kConditionGE: {
            if(input && vector_size(argv) == 2) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str); 
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    return TRUE;
                }
                else if(ret < 0)
                {
                    string_delete(str);
                    return FALSE;
                }

                if(atoi(string_c_str(str)) >= atoi(string_c_str(vector_item(argv, 1)))) {
                    *rcode = 0;
                }

                string_delete(str);
            }
            else if(vector_size(argv) == 3) {
                if(atoi(string_c_str(vector_item(argv, 1))) >= atoi(string_c_str(vector_item(argv,2)))) 
                {
                    *rcode = 0;
                }
            }
            }
            break;

        case kConditionNT: {
            if(input && vector_size(argv) == 2) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str); 
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    return TRUE;
                }
                else if(ret < 0)
                {
                    string_delete(str);
                    return FALSE;
                }

                struct stat lstat_;
                struct stat rstat_;
                if(lstat(string_c_str(str), &lstat_) == 0) {
                    if(lstat(string_c_str(vector_item(argv, 1)), &rstat_) == 0) {
                        if(lstat_.st_mtime > rstat_.st_mtime) 
                        {
                            *rcode = 0;
                        }
                    }
                }

                string_delete(str);
            }
            else if(vector_size(argv) == 3) {
                struct stat lstat_;
                struct stat rstat_;
                if(lstat(string_c_str(vector_item(argv, 1)), &lstat_) == 0) {
                    if(lstat(string_c_str(vector_item(argv, 2)), &rstat_) == 0) {
                        if(lstat_.st_mtime > rstat_.st_mtime) 
                        {
                            *rcode = 0;
                        }
                    }
                }
            }
            }
            break;

        case kConditionOT: {
            if(input && vector_size(argv) == 2) {
                string_obj* str = STRING_NEW("");
                int ret = statment_tree_internal_commands_read_nextin(nextin, str); 
                if(ret == 1) {
                    *rcode = 1;
                    string_delete(str);
                    return TRUE;
                }
                else if(ret < 0)
                {
                    string_delete(str);
                    return FALSE;
                }

                struct stat lstat_;
                struct stat rstat_;
                if(lstat(string_c_str(str), &lstat_) == 0) {
                    if(lstat(string_c_str(vector_item(argv, 1)), &rstat_) == 0) {
                        if(lstat_.st_mtime < rstat_.st_mtime) 
                        {
                            *rcode = 0;
                        }
                    }
                }

                string_delete(str);
            }
            else if(vector_size(argv) == 3) {
                struct stat lstat_;
                struct stat rstat_;
                if(lstat(string_c_str(vector_item(argv, 1)), &lstat_) == 0) {
                    if(lstat(string_c_str(vector_item(argv, 2)), &rstat_) == 0) {
                        if(lstat_.st_mtime < rstat_.st_mtime) 
                        {
                            *rcode = 0;
                        }
                    }
                }
            }
            }
            break;

        case kConditionEF: {
            }
            break;

        default: {
            fprintf(stderr, "unexpected err. illegal command(%s)\n", string_c_str(vector_item(argv, 0)));
            exit(1);
        }
