#include "config.h"
#include <errno.h>
#include <stdlib.h>
#include <fcntl.h>
#include <glob.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <pwd.h>
#include <limits.h>

#include "saphire/saphire.h"
#include "saphire/saphire_inner.h"


// ????????
static void skip_spaces(char** p, string_obj* not_evaled)
{
    while(**p == ' ' || **p == '\t') {
        string_push_back2(not_evaled, **p);
        (*p)++;
    }
}

// {}, <>, (), []????????????????????OK
// ???????parse???
// ???????
static BOOL read_until_next_close_character(char first_char, char last_char, char** p, string_obj* not_evaled, int* read_end_of_statment, BOOL line_inc, char* sname, int* sline)
{
    if(**p == first_char) {
        string_push_back2(not_evaled, **p);
        (*p)++;

        int nest = 0;
        BOOL squote = FALSE;
        BOOL dquote = FALSE;
        while(1) {
            if(gKitutukiSigInt) {
                err_msg("signal interrupt", sname, *sline);
                gKitutukiSigInt = FALSE;
                return FALSE;
            }
            /// ???? ///
            if(!squote && !dquote && **p == '\\') {
                string_push_back2(not_evaled, **p);
                (*p)++;

                if(line_inc && **p == '\n') {
                    (*sline)++;
                }
                else if(**p == 0) {
                    err_msg("unexpected end(0) after quote", sname, *sline);
                    return FALSE;
                }

                string_push_back2(not_evaled, **p);
                (*p)++;
            }
            /// ???????? ///
            else if(!dquote && **p == '\'') {
                squote = !squote;
                string_push_back2(not_evaled, **p);
                (*p)++;
            }
            /// ??????? ///
            else if(!squote && **p == '"') {
                dquote = !dquote;
                string_push_back2(not_evaled, **p);
                (*p)++;
            }
            /// ?????????
            else if(!squote && **p == '$') {
                // ?????? $()
                if(*(*p+1) == '$' && *(*p+2) == '(' || *(*p+1) == '(')
                {
                    if(*(*p+1) == '$') {
                        string_push_back2(not_evaled, **p); // $
                        (*p)++;
                        string_push_back2(not_evaled, **p); // $
                        (*p)++;
                    }
                    else {
                        string_push_back2(not_evaled, **p); // $
                        (*p)++;
                    }

                    if(!read_until_next_close_character('(', ')', p, not_evaled, read_end_of_statment, line_inc, sname, sline)) {
                        return FALSE;
                    }

                    *read_end_of_statment = 1;
                }
                /// ???? ///
                else {
                    BOOL quote;
                    if(*(*p+1) == '$') {
                        string_push_back2(not_evaled, **p); // $
                        (*p)++;
                        string_push_back2(not_evaled, **p); // $
                        (*p)++;

                        quote = FALSE;
                    }
                    else {
                        string_push_back2(not_evaled, **p); // $
                        (*p)++;

                        quote = TRUE;
                    }

                    if(**p >= '0' && **p <= '9' || **p == '{' || **p >= 'a' && **p <= 'z' || **p >= 'A' && **p <= 'Z' || **p == '_') {
                        if(**p == '{') {
                            if(!read_until_next_close_character('{', '}', p, not_evaled, read_end_of_statment, TRUE, sname, sline)) {
                                return FALSE;
                            }
                        }
                        else {
                            while(**p) {
                                if(**p >= '0' && **p <= '9' || **p >= 'a' && **p <= 'z' || **p >= 'A' && **p <= 'Z' || **p == '_') {
                                    string_push_back2(not_evaled, **p); // ??
                                    (*p)++;
                                }
                                else {
                                    break;
                                }
                            }
                        }

                        *read_end_of_statment = 1;
                    }
                    else {
                        if(quote) {
                            string_push_back2(not_evaled, '$');
                        }
                        else {
                            string_push_back2(not_evaled, '$');
                            string_push_back2(not_evaled, '$');
                        }
                    }
                }
            }
            else if(squote || dquote) {
                if(**p == 0) {
                    err_msg("close ' or \" before the end of source", sname, *sline);
                    return FALSE;
                }
                else {
                    if(line_inc && **p == '\n') {
                        (*sline)++;
                    }

                    string_push_back2(not_evaled, **p);
                    (*p)++;
                }
            }
            else if(**p == first_char) {
                nest++;
                string_push_back2(not_evaled, **p);
                (*p)++;
            }
            else if(**p == last_char) {
                string_push_back2(not_evaled, **p);
                (*p)++;

                if(nest == 0) {
                    break;
                }
                nest--;
            }
            else if(**p == 0) {
                char buf[256];
                snprintf(buf, 256, "read_util_next_close_character: unexpected end(0). close with (%c)", last_char);
                err_msg(buf, sname, *sline);
                return FALSE;
            }
            else if(line_inc && **p == '\n') {
                (*sline)++;
                string_push_back2(not_evaled, **p);
                (*p)++;
            }
            else {
                string_push_back2(not_evaled, **p);
                (*p)++;
            }
        }
    }
    
    return TRUE;
}

// ??????????? contents????
// ?????????????
// ????????????
static BOOL read_block(char** p, string_obj* contents, vector_obj* args, string_obj* not_evaled, BOOL line_inc, char* sname, int* sline)
{
    int line_of_head = *sline;
    string_push_back2(not_evaled, **p); //  {
    (*p)++;
    
    while(1) {
        if(**p == ' ') {
            string_push_back2(not_evaled, **p);
            string_push_back2(contents, *((*p)++));
        }
        else if(**p == '\t') {
            string_push_back2(not_evaled, **p);
            string_push_back2(contents, *((*p)++));
        }
        else if(**p == '\n') {
            line_inc && (*sline)++;
            string_push_back2(not_evaled, **p);
            string_push_back2(contents, *((*p)++));
        }
        else {
            break;
        }
    }

    /// ??
    if(args) {
        if(**p == ':') {
            string_push_back2(not_evaled, **p);
            (*p)++;

            while(**p) {
                string_obj* str = STRING_NEW("");
                skip_spaces(p, not_evaled);
                while(**p >= 'a' && **p <= 'z'
                    || **p >= 'A' && **p <= 'Z'
                    || **p == '_')
                {
                    string_push_back2(str, **p);
                    string_push_back2(not_evaled, **p);
                    (*p)++;
                }
                skip_spaces(p, not_evaled);

                vector_add(args, str);

                if(**p >= 'a' && **p <= 'z'
                    || **p >= 'A' && **p <= 'Z'
                    || **p == '_')
                {
                }
                else {
                    if(**p == ':') {
                        string_push_back2(not_evaled, **p);
                        (*p)++;
                        break;
                    }
                    else {
                        char buf[1024];
                        snprintf(buf, 1024, "unexpected char(%c)", **p);
                        err_msg(buf, sname, line_of_head);
                        return FALSE;
                    }
                }
            }
        }

        while(1) {
            if(**p == ' ') {
                string_push_back2(not_evaled, **p);
                string_push_back2(contents, *((*p)++));
            }
            else if(**p == '\t') {
                string_push_back2(not_evaled, **p);
                string_push_back2(contents, *((*p)++));
            }
            else if(**p == '\n') {
                line_inc && (*sline)++;
                string_push_back2(not_evaled, **p);
                string_push_back2(contents, *((*p)++));
            }
            else {
                break;
            }
        }
    }

    BOOL squote = FALSE;
    BOOL dquote = FALSE;
    int nest = 0;
    while(1) {
        /// ????
        if(!squote && !dquote && **p == '\\') {
            string_push_back2(not_evaled, **p);
            string_push_back2(contents, *((*p)++));

            if(line_inc && **p == '\n') {
                (*sline)++;
            }
            else if(*p == 0) {
                err_msg("unsigned end after quote",sname, *sline);
                return FALSE;
            }

            string_push_back2(not_evaled, **p);
            string_push_back2(contents, *((*p)++));
        }
        /// ????????
        else if(!dquote && **p == '\'') {
            string_push_back2(not_evaled, **p);
            string_push_back2(contents, *((*p)++));
            squote = !squote;
        }
        /// ???????
        else if(!squote && **p == '"') {
            string_push_back2(not_evaled, **p);
            string_push_back2(contents, *((*p)++));
            dquote = !dquote;
        }
        /// ????????????????? ///
        else if(squote || dquote) {
            if(**p == 0) {
                err_msg("get block: close \" or \' before the end of block", sname, line_of_head);
                return FALSE;
            }
            else if(line_inc && **p == '\n') {
                (*sline)++;
            }

            string_push_back2(not_evaled, **p);
            string_push_back2(contents, *((*p)++));
        }
        else if(**p == '(') {
            string_push_back2(not_evaled, **p);
            string_push_back2(contents, *((*p)++));
            nest++;
        }
        else if(**p == ')') {
            string_push_back2(not_evaled, **p);
            (*p)++;
            nest--;

            if(nest == -1) {
                break;
            }
            else {
                string_push_back2(contents, ')');
            }
        }
        else if(**p == 0) {
            err_msg("get block: found 0. close )", sname, line_of_head);
            return FALSE;
        }
        else if(**p == '\n') {
            line_inc && (*sline)++;
            string_push_back2(not_evaled, **p);
            string_push_back2(contents, **p);
            (*p)++;
        }
        else {
            string_push_back2(not_evaled, **p);
            string_push_back2(contents, **p);
            (*p)++;
        }
    }

    return TRUE;
}

/// ?????
static void expand_tilda(string_obj* buf, string_obj* path)
{
    char* p = string_c_str(buf);
    p++; // ~

    string_obj* user = STRING_NEW("");
    while(*p && *p != '/') {
        string_push_back2(user, *p);
        p++;
    }

    /// ???????????????????
    if(string_length(user) == 0) {
        char* home = getenv("HOME");
        if(home) {
            string_push_back(path, home);
        }
        else {
            struct passwd* pw = getpwuid(getuid());
            if(pw) {
                string_push_back(path, pw->pw_dir);
            }
            else {
                string_push_back(path, "~");
            }
        }
    }
    else {
        struct passwd* pw = getpwnam(string_c_str(user));
        if(pw) {
            string_push_back(path, pw->pw_dir);
        }
        else {
            string_push_back2(path, '~');
            string_push_back(path, string_c_str(user));
        }
    }

    /// ?????
    string_push_back(path, p);

    string_delete(user);
}

static BOOL add_arg_to_command(sCommand* command, MANAGED sArg* new_arg, char* sname, int* sline)
{
    vector_add(command->mArgs, new_arg);

    if(vector_size(command->mArgs) == 1) {
        if(new_arg->mKind == 0) {
            /// ???????????????? ///
            command->mKind = get_command_kind(string_c_str(new_arg->mBody));
        }
        else {
            err_msg("command name must be determined staticaly", sname, *sline);
            return FALSE;
        }
    }

    return TRUE;
}

/// ???????
static BOOL read_one_argument(char** p, string_obj* buf, string_obj* not_evaled, int* read_end_of_statment, sCommand* command, char* sname, int* sline, BOOL expand_quote)
{
    /// ????????????????? 127????
    static unsigned char table[] = { 
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
        1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 
    };

    BOOL squote = FALSE;
    BOOL dquote = FALSE;
    while(**p) {
        if(gKitutukiSigInt) {
            gKitutukiSigInt = FALSE;
            err_msg("signal interrupt", sname, *sline);

            return FALSE;
        }

        /// ???
        if(!squote && !dquote && **p == '"' && *(*p+1) == '"') {
            break;
        }
        else if(!dquote && !squote && **p =='\'' && *(*p+1) == '\'') {
            break;
        }
        else if(**p == '\\' && *(*p+1) == 't') {
            string_push_back2(not_evaled, **p);
            string_push_back2(not_evaled, *(*p+1));

            string_push_back2(buf, '\t');

            (*p)+=2;
        }
        else if(**p == '\\' && *(*p+1) == 'n') {
            string_push_back2(not_evaled, **p);
            string_push_back2(not_evaled, *(*p+1));

            string_push_back2(buf, '\n');

            (*p)+=2;
        }
        else if(**p == '\\' && *(*p+1) == 'r') {
            string_push_back2(not_evaled, **p);
            string_push_back2(not_evaled, *(*p+1));

            string_push_back2(buf, '\r');

            (*p)+=2;
        }
        else if(**p == '\\' && *(*p+1) == 'a') {
            string_push_back2(not_evaled, **p);
            string_push_back2(not_evaled, *(*p+1));

            string_push_back2(buf, '\a');

            (*p)+=2;
        }
        else if(!squote && !dquote && **p == '\\') {
            if(expand_quote) {
                string_push_back2(not_evaled, **p);
                (*p)++;

                if(**p == 0) {
                    err_msg("unexpected end. can't quote null.", sname, *sline);
                    return FALSE;
                }
                else if(**p == '\n') {
                    (*sline)++;
                }

                string_push_back2(not_evaled, **p);
                string_push_back2(buf, **p);

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

                (*p)++;
            }
        }
        else if(!dquote && **p == '\'') {
            if(expand_quote) {
                string_push_back2(not_evaled, **p);
                (*p)++;
                squote = !squote;
            }
            else {
                string_push_back2(not_evaled, **p);
                string_push_back2(buf, **p);

                (*p)++;
            }
        }
        else if(!squote && **p == '"') {
            if(expand_quote) {
                dquote = !dquote;
                string_push_back2(not_evaled, **p);
                (*p)++;
            }
            else {
                string_push_back2(not_evaled, **p);
                string_push_back2(buf, **p);

                (*p)++;
            }
        }
        /// ?????????
        else if(!squote && **p == '$') {
            // ?????? $()
            if(*(*p+1) == '(' || *(*p+1) == '$' && *(*p+2) == '(')
            {
                if(*(*p+1) == '$') {
                    string_push_back2(not_evaled, **p); // $
                    (*p)++;
                    string_push_back2(not_evaled, **p); // $
                    (*p)++;
                }
                else {
                    string_push_back2(not_evaled, **p); // $
                    (*p)++;
                }

                if(!read_until_next_close_character('(', ')', p, not_evaled, read_end_of_statment, TRUE, sname, sline)) {
                    return FALSE;
                }

                *read_end_of_statment = 1;
            }
            /// ????
            else {
                BOOL quote;
                if(*(*p+1) == '$') {
                    string_push_back2(not_evaled, **p); // $
                    (*p)++;
                    string_push_back2(not_evaled, **p); // $
                    (*p)++;

                    quote = FALSE;
                }
                else {
                    string_push_back2(not_evaled, **p); // $
                    (*p)++;

                    quote = TRUE;
                }

                if(**p >= '0' && **p <= '9' || **p == '{' || **p >= 'a' && **p <= 'z' || **p >= 'A' && **p <= 'Z' || **p == '_') {
                    if(**p == '{') {
                        if(!read_until_next_close_character('{', '}', p, not_evaled, read_end_of_statment, TRUE, sname, sline)) {
                            return FALSE;
                        }
                    }
                    else {
                        while(**p) {
                            if(**p >= '0' && **p <= '9' || **p >= 'a' && **p <= 'z' || **p >= 'A' && **p <= 'Z' || **p == '_') {
                                string_push_back2(not_evaled, **p); // ??
                                (*p)++;
                            }
                            else {
                                break;
                            }
                        }
                    }

                    *read_end_of_statment = 1;
                }
                else {
                    if(quote) {
                        string_push_back2(buf, '$');
                    }
                    else {
                        string_push_back2(buf, '$');
                        string_push_back2(buf, '$');
                    }
                }
            }
        }
        /// ?????????????????
        else if(squote || dquote) {
            if(**p == 0) {
                err_msg("close single quote or double quote", sname, *sline);
                return FALSE;
            }
            else if(**p == '\n') {
                (*sline)++;
            }

            string_push_back2(not_evaled, **p);
            string_push_back2(buf, **p);
            (*p)++;
        }
/*
        /// ?????
        else if(command && vector_size(command->mArgs) > 0 && command->mKind != kCommand && string_c_str(buf)[0] == 0 && **p == '-')
        {
            string_push_back2(not_evaled, **p);
            string_push_back2(buf, **p);
            (*p)++;

            if(!read_one_argument(p, buf, not_evaled, read_end_of_statment, NULL, sname, sline, FALSE))
            {
                return FALSE;
            }

            int i = 0;
            int options = 0;
            while(kCommandOptions[i]) {
                if(strcmp(string_c_str(buf), kCommandOptions[command->mKind][i]) == 0)
                {
                    options |= 0x1 << i;
                }
                i++;
            }

            if(options) { 
                command->mOptions |= options; 
                string_put(buf, "");
            }
            else {
                if(!add_arg_to_command(command, ARG_NEW(0, MANAGED buf), sname, sline))
                {
                    return FALSE;
                }
            }
        }
*/
        /// ????? ///
        else if(**p == '~') {
            string_push_back2(not_evaled, **p);
            string_push_back2(buf, **p);
            (*p)++;

            if(strlen(string_c_str(buf)) == 1 && command) {
                if(!read_one_argument(p, buf, not_evaled, read_end_of_statment, NULL, sname, sline, FALSE))
                {
                    return FALSE;
                }

                string_obj* path = STRING_NEW("");
                expand_tilda(buf, path);

                string_obj* path2 = STRING_NEW("");
                BOOL glob_ = FALSE;
                char* p = string_c_str(path);
                BOOL squote = FALSE;
                BOOL dquote = FALSE;
                while(*p) {
                    if(!dquote && *p == '\'') {
                        p++;
                        squote = !squote;
                    }
                    else if(!squote && *p == '"') {
                        p++;
                        dquote = !dquote;
                    }
                    else if(squote || dquote) {
                        string_push_back2(path2, *p);
                        p++;
                    }
                    else if(*p == '\\') {
                        p++;
                        string_push_back2(path2, *p);
                        p++;
                    }
                    else if(*p == '[') {
                        string_push_back2(path2, *p);
                        p++;

                        while(*p) {
                            if(*p == ']') {
                                glob_ = TRUE;
                                string_push_back2(path2, *p);
                                p++;
                                break;
                            }
                            else {
                                string_push_back2(path2, *p);
                                p++;
                            }
                        }
                    }
                    else if(*p == '?' || *p == '*') {
                        glob_ = TRUE;
                        string_push_back2(path2, *p);
                        p++;
                    }
                    else {
                        string_push_back2(path2, *p);
                        p++;
                    }
                }

                string_delete(path);

                if(glob_) {
                    glob_t result;
                    int rc = glob(string_c_str(path2), 0, NULL, &result);
                    if(rc == GLOB_NOSPACE) {
                        err_msg("read_one_argument: out of space during glob operation", sname, *sline);
                        string_delete(path2);
                        return FALSE;
                    }
                    else if(rc == GLOB_NOMATCH) {
                    }
                    else {
                        int i;
                        for(i=0; i<result.gl_pathc; i++) {
                            char* file = result.gl_pathv[i];
                            if(strcmp(file, ".") != 0 && strcmp(file, "..") != 0)
                            {
                                string_obj* str = STRING_NEW(file);
                                if(!add_arg_to_command(command, ARG_NEW(0, MANAGED str), sname, sline))
                                {
                                    string_delete(path2);
                                    return FALSE;
                                }
                            }
                        }

                        string_put(buf, ""); // ?????????mArgs??????
                    }
                    string_delete(path2);
                }
                else {
                    if(!add_arg_to_command(command, ARG_NEW(0, MANAGED path2), sname, sline))
                    {
                        return FALSE;
                    }
                    string_put(buf, ""); // ???????????mArgs??????
                }
                break;
            }
        }
        /// ??? ///
        else if(command && vector_size(command->mArgs) > 0 && (**p == '[' || **p == '?' || **p == '*')) 
        {
            string_push_back2(not_evaled, **p);
            string_push_back2(buf, **p);
            (*p)++;

            if(!read_one_argument(p, buf, not_evaled, read_end_of_statment, NULL, sname, sline, TRUE))
            {
                return FALSE;
            }

            glob_t result;
            int rc = glob(string_c_str(buf), 0, NULL, &result);
            if(rc == GLOB_NOSPACE) {
                err_msg("read_one_argument: out of space during glob operation", sname, *sline);
                return FALSE;
            }
            else if(rc == GLOB_NOMATCH) {
            }
            else {
                int i;
                for(i=0; i<result.gl_pathc; i++) {
                    char* file = result.gl_pathv[i];
                    if(strcmp(file, ".") != 0 && strcmp(file, "..") != 0)
                    {
                        string_obj* str = STRING_NEW(file);
                        if(!add_arg_to_command(command, ARG_NEW(0, MANAGED str), sname, sline))
                        {
                            return FALSE;
                        }
                    }
                }

                string_put(buf, ""); // ?????????mArgs??????
            }
            break;
        }
        // ->?????
        else if(command && vector_size(command->mArgs) == 0 && **p == '-' && *(*p+1) == '>') 
        {
            string_push_back2(not_evaled, **p);
            string_push_back2(buf, **p);

            (*p)++;

            string_push_back2(not_evaled, **p);
            string_push_back2(buf, **p);

            (*p)++;
        }
        /// utf-8??????
        else if(((unsigned char)**p) > 127) {
            string_push_back2(not_evaled, **p);
            string_push_back2(buf, **p);

            (*p)++;
        }
        // ???????????????
        else if(**p == '@' && (*(*p+1) == '(') || (*(*p+1) == '@' && *(*p+2) == '(') || (*(*p+1) == '@' && *(*p+2) >= 'a' && *(*p+2) <= 'z' && *(*p+3) == '(')) 
        {
            break;
        }
        // % ????????????
        else if(**p == '%' && (*(*p+1) == '>' || *(*p+1) == '2')) {
            break;
        }
        else if(table[**p]) {
            break;
        }
        else {
            string_push_back2(not_evaled, **p);
            string_push_back2(buf, **p);

            (*p)++;
        }
    }

    if(squote) {
        err_msg("require to close '", sname, *sline);
        return FALSE;
    }

    if(dquote) {
        err_msg("require to close \"", sname, *sline);
        return FALSE;
    }

    return TRUE;
}

/// if?????
static BOOL read_command_parse_if_statment(char** p, sCommand* command, sStatment* statment, string_obj* not_evaled, int* read_end_of_statment, char* sname, int* sline)
{
    skip_spaces(p, not_evaled);

    if(**p != '(') {
        err_msg("expected (", sname, *sline);
        return FALSE;
    }

    /// ??????? ///
    string_obj* str = STRING_NEW("");
    int read_end_of_statment2 = -1;
    if(!read_until_next_close_character('(', ')', p, str, &read_end_of_statment2, FALSE, sname, sline)) {
        string_delete(str);
        return FALSE;
    }
    string_push_back(not_evaled, string_c_str(str));

    string_erase(str, 0, 1);
    string_trunc(str, string_length(str)-1);

    sStatments* condition = STATMENTS_NEW();

    if(!parse(string_c_str(str), sname, sline, condition))
    {
        string_delete(str);
        sStatments_delete(condition);
        return FALSE;
    }
    string_delete(str);

    skip_spaces(p, not_evaled);

    /// ??? ///
    sStatments* loop = STATMENTS_NEW();

    if(**p == '(') {
        string_obj* str = STRING_NEW("");
        if(!read_block(p, str, NULL, not_evaled, FALSE, sname, sline)) {
            string_delete(str);
            sStatments_delete(condition);
            sStatments_delete(loop);
            return FALSE;
        }

        if(!parse(string_c_str(str), sname, sline, loop))
        {
            sStatments_delete(condition);
            sStatments_delete(loop);
            string_delete(str);
            return FALSE;
        }
        string_delete(str);
    }
    else {
        err_msg("expected block.", sname, *sline);
        sStatments_delete(condition);
        sStatments_delete(loop);
        return FALSE;
    }

    skip_spaces(p, not_evaled);

    vector_obj* conditions = VECTOR_NEW(30);
    vector_obj* loops = VECTOR_NEW(30);
    
    vector_add(conditions, condition);
    vector_add(loops, loop);

    /// elif ?? ///
    if(**p == 'e' && *(*p+1) == 'l' 
        && *(*p+2) == 'i' && *(*p+3) == 'f' 
        && (*(*p+4) == ' ' || *(*p+4) == '\t' || *(*p+4) == '('))
    {
        while(**p == 'e' && *(*p+1) == 'l' && *(*p+2) == 'i' 
            && *(*p+3) == 'f' 
            && (*(*p+4) == ' ' || *(*p+4) == '\t' || *(*p+4) == '('))
        {
            string_push_back2(not_evaled, **p);
            (*p)++;
            string_push_back2(not_evaled, **p);
            (*p)++;
            string_push_back2(not_evaled, **p);
            (*p)++;
            string_push_back2(not_evaled, **p);
            (*p)++;

            skip_spaces(p, not_evaled);

            if(**p != '(') {
                err_msg("expected (", sname, *sline);
                int i;
                for(i=0; i<vector_size(conditions); i++) {
                    sStatments_delete(vector_item(conditions, i));
                }
                vector_delete(conditions);
                for(i=0; i<vector_size(loops); i++) {
                    sStatments_delete(vector_item(loops, i));
                }
                vector_delete(loops);
    
                return FALSE;
            }

            /// ??? ///
            string_obj* str = STRING_NEW("");
            int read_end_of_statment = -1;
            if(!read_until_next_close_character('(', ')', p, str, &read_end_of_statment, FALSE, sname, sline)) {
                string_delete(str);
                int i;
                for(i=0; i<vector_size(conditions); i++) {
                    sStatments_delete(vector_item(conditions, i));
                }
                vector_delete(conditions);
                for(i=0; i<vector_size(loops); i++) {
                    sStatments_delete(vector_item(loops, i));
                }
                vector_delete(loops);
                return FALSE;
            }
            string_push_back(not_evaled, string_c_str(str));

            sStatments* condition = STATMENTS_NEW();
            if(!parse(string_c_str(str), sname, sline, condition))
            {
                sStatments_delete(condition);
                int i;
                for(i=0; i<vector_size(conditions); i++) {
                    sStatments_delete(vector_item(conditions, i));
                }
                vector_delete(conditions);
                for(i=0; i<vector_size(loops); i++) {
                    sStatments_delete(vector_item(loops, i));
                }
                vector_delete(loops);
                string_delete(str);
                return FALSE;
            }
            string_delete(str);

            vector_add(conditions, condition);

            skip_spaces(p, not_evaled);

            /// ??? ///
            sStatments* loop = STATMENTS_NEW();

            if(**p == '(') {
                string_obj* str = STRING_NEW("");
                if(!read_block(p, str, NULL, not_evaled, FALSE, sname, sline)) {
                    string_delete(str);
                    sStatments_delete(loop);
                    int i;
                    for(i=0; i<vector_size(conditions); i++) {
                        sStatments_delete(vector_item(conditions, i));
                    }
                    vector_delete(conditions);
                    for(i=0; i<vector_size(loops); i++) {
                        sStatments_delete(vector_item(loops, i));
                    }
                    vector_delete(loops);
                    return FALSE;
                }

                if(!parse(string_c_str(str), sname, sline, loop))
                {
                    sStatments_delete(loop);
                    string_delete(str);
                    int i;
                    for(i=0; i<vector_size(conditions); i++) {
                        sStatments_delete(vector_item(conditions, i));
                    }
                    vector_delete(conditions);
                    for(i=0; i<vector_size(loops); i++) {
                        sStatments_delete(vector_item(loops, i));
                    }
                    vector_delete(loops);
                    return FALSE;
                }
                string_delete(str);
            }
            else {
                err_msg("expected block.", sname, *sline);
                sStatments_delete(loop);
                int i;
                for(i=0; i<vector_size(conditions); i++) {
                    sStatments_delete(vector_item(conditions, i));
                }
                vector_delete(conditions);
                for(i=0; i<vector_size(loops); i++) {
                    sStatments_delete(vector_item(loops, i));
                }
                vector_delete(loops);
                return FALSE;
            }

            skip_spaces(p, not_evaled);

            vector_add(loops, loop);
        }
    }

    /// else ?? ///
    if(**p == 'e' && *(*p+1) == 'l' && *(*p+2) == 's' && *(*p+3) == 'e' && (*(*p+4) == ' ' || *(*p+4) == '\t' || *(*p+4) == '('))
    {
        string_push_back2(not_evaled, **p);
        (*p)++;
        string_push_back2(not_evaled, **p);
        (*p)++;
        string_push_back2(not_evaled, **p);
        (*p)++;
        string_push_back2(not_evaled, **p);
        (*p)++;

        skip_spaces(p, not_evaled);
        
        /// ??? ///
        sStatments* loop = STATMENTS_NEW();

        if(**p == '(') {
            string_obj* str = STRING_NEW("");
            if(!read_block(p, str, NULL, not_evaled, FALSE, sname, sline)) {
                string_delete(str);
                sStatments_delete(loop);
                int i;
                for(i=0; i<vector_size(conditions); i++) {
                    sStatments_delete(vector_item(conditions, i));
                }
                vector_delete(conditions);
                for(i=0; i<vector_size(loops); i++) {
                    sStatments_delete(vector_item(loops, i));
                }
                vector_delete(loops);
                return FALSE;
            }

            if(!parse(string_c_str(str), sname, sline, loop))
            {
                string_delete(str);
                sStatments_delete(loop);
                int i;
                for(i=0; i<vector_size(conditions); i++) {
                    sStatments_delete(vector_item(conditions, i));
                }
                vector_delete(conditions);
                for(i=0; i<vector_size(loops); i++) {
                    sStatments_delete(vector_item(loops, i));
                }
                return FALSE;
            }
            string_delete(str);
        }
        else {
            err_msg("expected block.", sname, *sline);
            int i;
            for(i=0; i<vector_size(conditions); i++) {
                sStatments_delete(vector_item(conditions, i));
            }
            vector_delete(conditions);
            for(i=0; i<vector_size(loops); i++) {
                sStatments_delete(vector_item(loops, i));
            }
            sStatments_delete(loop);
            return FALSE;
        }

        skip_spaces(p, not_evaled);

        vector_add(loops, loop);
    }
    
    command->mKind = kIf;
    command->mExtra = sIf_new(MANAGED conditions, MANAGED loops);

    return TRUE;
}

/// while?????
static BOOL read_command_parse_while_statment(char** p, sCommand* command, sStatment* statment, string_obj* not_evaled, int* read_end_of_statment, char* sname, int* sline)
{
    skip_spaces(p, not_evaled);

    if(**p != '(') {
        err_msg("expected (", sname, *sline);
        return FALSE;
    }

    /// ??????? ///
    string_obj* str = STRING_NEW("");
    int read_end_of_statment2 = -1;
    if(!read_until_next_close_character('(', ')', p, str, &read_end_of_statment2, FALSE, sname, sline)) {
        string_delete(str);
        return FALSE;
    }
    string_push_back(not_evaled, string_c_str(str));

    string_erase(str, 0, 1);
    string_trunc(str, string_length(str)-1);

    sStatments* conditions = STATMENTS_NEW();
    if(!parse(string_c_str(str), sname, sline, conditions))
    {
        sStatments_delete(conditions);
        string_delete(str);
        return FALSE;
    }
    string_delete(str);

    while(**p) {
        if(**p == '\n') {
            (*sline)++;
            string_push_back2(not_evaled, **p);
            (*p)++;
        }
        else if(**p == ' ' || **p == '\t') {
            string_push_back2(not_evaled, **p);
            (*p)++;
        }
        else {
            break;
        }
    }

    /// ???????? ///
    sStatments* loops = STATMENTS_NEW();

    if(**p == '(') {
        string_obj* str = STRING_NEW("");
        if(!read_block(p, str, NULL, not_evaled, FALSE, sname, sline)) {
            sStatments_delete(conditions);
            sStatments_delete(loops);
            string_delete(str);
            return FALSE;
        }

        if(!parse(string_c_str(str), sname, sline, loops))
        {
            string_delete(str);
            sStatments_delete(conditions);
            sStatments_delete(loops);
            return FALSE;
        }

        string_delete(str);
    }
    else {
        err_msg("expected block.", sname, *sline);
        sStatments_delete(conditions);
        sStatments_delete(loops);
        return FALSE;
    }

    command->mKind = kWhile;
        // ??????mNotEvaled????????????
        // ???command??????
    command->mExtra = sWhile_new(MANAGED conditions, MANAGED loops);

    return TRUE;
}

/// ?????????
static BOOL read_command(char** p, sCommand* command, sStatment* statment, string_obj* not_evaled, int* read_end_of_statment, char* sname, int* sline)
{
    while(**p) {
        string_obj* buf = STRING_NEW("");

        if(!read_one_argument(p, buf, not_evaled, read_end_of_statment, command, sname, sline, TRUE)) 
        {
            string_delete(buf);
            return FALSE;
        }

        /// ??????? ///
        if(strcmp(string_c_str(buf), "") != 0) {
            if(vector_size(command->mArgs) == 0) {
                if(strcmp(string_c_str(buf), "if") == 0) {
                    if(!add_arg_to_command(command, ARG_NEW(0, MANAGED buf), sname, sline))
                    {
                        return FALSE;
                    }
                    string_push_back(statment->mTitle, string_c_str(buf));
                    string_push_back(statment->mTitle, " ");

                    if(!read_command_parse_if_statment(p, command, statment, not_evaled, read_end_of_statment, sname, sline))
                    {
                        return FALSE;
                    }
                }
                else if(strcmp(string_c_str(buf), "while") == 0) {
                    if(!add_arg_to_command(command, ARG_NEW(0, MANAGED buf), sname, sline))
                    {
                        return FALSE;
                    }

                    string_push_back(statment->mTitle, string_c_str(buf));
                    string_push_back(statment->mTitle, " ");

                    if(!read_command_parse_while_statment(p, command, statment, not_evaled, read_end_of_statment, sname, sline))
                    {
                        return FALSE;
                    }
                }
                else {
                    if(vector_size(statment->mCommands) == 0 && strcmp(string_c_str(buf), "!") == 0)
                    {
                        statment->mRCodeReverse = TRUE;
                    }

                    if(!add_arg_to_command(command, ARG_NEW(0, MANAGED buf), sname, sline))
                    {
                        return FALSE;
                    }

                    string_push_back(statment->mTitle, string_c_str(buf));
                    string_push_back(statment->mTitle, " ");
                }
            }
            else {
                if(!add_arg_to_command(command, ARG_NEW(0, MANAGED buf), sname, sline))
                {
                    return FALSE;
                }
                string_push_back(statment->mTitle, string_c_str(buf));
                string_push_back(statment->mTitle, " ");
            }
        }
        else {
            /// ?????
            if(**p == '\'') {
                string_push_back(not_evaled, "''");
                (*p)+=2;

                if(!add_arg_to_command(command, ARG_NEW(0, MANAGED buf), sname, sline))
                {
                    return FALSE;
                }
                string_push_back(statment->mTitle, "'");
                string_push_back(statment->mTitle, " ");

                continue;
            }
            else if(**p == '"') {
                string_push_back(not_evaled, "\"\"");
                (*p)+=2;

                /// ???????????????? ///
                if(!add_arg_to_command(command, ARG_NEW(0, MANAGED buf), sname, sline))
                {
                    return FALSE;
                }
                string_push_back(statment->mTitle, "\"\"");
                string_push_back(statment->mTitle, " ");

                continue;
            }
            else {
                string_delete(buf);
            }
        }

        /// ?????????? ///
        if((**p == '@' && *(*p+1) == '(') || (**p == '@' && *(*p+1) == '@' && *(*p+2) == '(') || (**p == '@' && *(*p+1) == '@' && *(*p+2) >= 'a' && *(*p+2) <= 'z' && *(*p+3) == '(')) 
            {
            string_push_back2(not_evaled, **p);
            (*p)++;

            BOOL double_;
            enum eLineField lf;
            if(**p == '@') {
                string_push_back2(not_evaled, **p);
                (*p)++;

                double_ = TRUE;
                if(**p == '(') {
                    lf = kLF;
                }
                else if(*(*p+1) == 'a') {
                    lf = kBel;
                    string_push_back2(not_evaled, **p);
                    (*p)++;
                }
                else if(*(*p+1) == 'm') {
                    lf = kCR;
                    string_push_back2(not_evaled, **p);
                    (*p)++;
                }
                else if(*(*p+1) == 'w') {
                    lf = kCRLF;
                    string_push_back2(not_evaled, **p);
                    (*p)++;
                }
                else {
                    lf = kLF;
                    string_push_back2(not_evaled, **p);
                    (*p)++;
                }
            }
            else if(**p == '(') {
                double_ = FALSE;
                lf = kLF;
            }

            string_obj* str = STRING_NEW("");
            int read_end_of_statment = -1;
            if(!read_until_next_close_character('(', ')', p, str, &read_end_of_statment, FALSE, sname, sline)) {
                string_delete(str);
                return FALSE;
            }
            string_push_back(not_evaled, string_c_str(str));
            string_push_back(statment->mTitle, string_c_str(str));

            string_erase(str, 0, 1);
            string_trunc(str, string_length(str)-1);

            sStatments* statments = STATMENTS_NEW();
            if(!parse(string_c_str(str), sname, sline, statments))
            {
                string_delete(str);
                sStatments_delete(statments);
                return FALSE;
            }

            string_delete(str);

            if(double_) {
                if(!add_arg_to_command(command, ARG_NEW(4, MANAGED sAtCommand_new(MANAGED statments, lf)), sname, sline))
                {
                    return FALSE;
                }
            }
            else {
                if(!add_arg_to_command(command, ARG_NEW(2, MANAGED statments), sname, sline)) 
                {
                    return FALSE;
                }
            }
        }
        else if(**p == '>') {
            /// ?????? ///
            if(*(*p+1) == '(') {
                string_push_back2(not_evaled, **p);
                (*p)++;

                string_obj* cmd = STRING_NEW("");
                if(!read_until_next_close_character('(', ')', p, cmd, read_end_of_statment, FALSE, sname, sline)) {
                    string_delete(cmd);
                    return FALSE;
                }
                string_push_back(not_evaled, string_c_str(cmd));

                string_erase(cmd, 0, 1); // (???
                string_trunc(cmd, string_length(cmd)-1); // )???

                sStatments* statments = STATMENTS_NEW();
                if(!parse(string_c_str(cmd), sname, sline, statments)) {
                    sStatments_delete(statments);
                    string_delete(cmd);
                    return FALSE;
                }

                string_delete(cmd);

                if(vector_size(command->mArgs) == 0) {
                    err_msg("command name must be determined staticaly", sname, *sline);
                    sStatments_delete(statments);
                    return FALSE;
                }

                if(!add_arg_to_command(command, ARG_NEW(8, MANAGED statments), sname, sline))
                {
                    return FALSE;
                }
            }
            /// ??????
            else if(*(*p+1) == '>') {
                string_push_back(not_evaled, ">>");
                (*p)+=2;
                int fd = 1;
                enum eRedirect type = kRedirectAppend;

                skip_spaces(p, not_evaled);

                if(!add_arg_to_command(command, ARG_NEW(9, MANAGED sRedirect_new(type, fd)), sname, sline))
                {
                    return FALSE;
                }
            }
            /// ??????
            else {
                string_push_back(not_evaled, ">");
                (*p)++;
                int fd = 1;
                enum eRedirect type = kRedirectOverwrite;

                skip_spaces(p, not_evaled);

                if(!add_arg_to_command(command, ARG_NEW(9, MANAGED sRedirect_new(type, fd)), sname, sline))
                {
                    return FALSE;
                }
            }
        }
        else if(**p == '<') {
            /// ????????
            if(*(*p+1) == '<') {
                string_push_back2(not_evaled, **p);
                (*p)++;
                string_push_back2(not_evaled, **p);
                (*p)++;

                skip_spaces(p, not_evaled);

                BOOL expand_env = TRUE;

                BOOL squote = FALSE;
                BOOL dquote = FALSE;
                if(**p == '\'') {
                    squote = TRUE;
                    string_push_back2(not_evaled, **p);
                    (*p)++;
                }
                else if(**p == '"') {
                    dquote = TRUE;
                    string_push_back2(not_evaled, **p);
                    (*p)++;
                }

                string_obj* name = STRING_NEW("");
                while(**p) {
                    if(**p == '\n') {
                        string_push_back2(not_evaled, **p);
                        (*p)++;
                        break;
                    }
                    else if(**p == ' ' || **p == '\t') {
                        skip_spaces(p, not_evaled);
                        if(**p != '\n') {
                            err_msg("invalid here document name1", sname, *sline);
                            string_delete(name);
                            return FALSE;
                        }
                        string_push_back2(not_evaled, **p);
                        (*p)++;
                        break;
                    }
                    else if(**p >='A' && ** p <= 'Z' || **p >='a' && **p <='z')
                    {
                        string_push_back2(name, **p);
                        string_push_back2(not_evaled, **p);
                        (*p)++;
                    }
                    else if(dquote && **p == '"') {
                        expand_env = TRUE;
                        dquote = FALSE;
                        string_push_back2(not_evaled, **p);
                        (*p)++;
                        skip_spaces(p, not_evaled);
                        if(**p != '\n') {
                            err_msg("invalid here document name2", sname, *sline);
                            string_delete(name);
                            return FALSE;
                        }
                        string_push_back2(not_evaled, **p);
                        (*p)++;
                        break;
                    }
                    else if(squote && **p == '\'') {
                        expand_env = FALSE;
                        squote = FALSE;
                        string_push_back2(not_evaled, **p);
                        (*p)++;
                        skip_spaces(p, not_evaled);
                        if(**p != '\n') {
                            err_msg("invalid here document name3", sname, *sline);
                            string_delete(name);
                            return FALSE;
                        }
                        string_push_back2(not_evaled, **p);
                        (*p)++;
                        break;
                    }
                    else {
                        err_msg("invalid here document name4", sname, *sline);
                        string_delete(name);
                        return FALSE;
                    }
                }

                if(dquote || squote|| string_c_str(name)[0] == 0) {
                    err_msg("invalid here document name5", sname, *sline);
                    string_delete(name);
                    return FALSE;
                }

                string_obj* text = STRING_NEW("");
                string_obj* line = STRING_NEW("");
                while(**p) {
                    if(**p == '\n') {
                        string_push_back2(not_evaled, **p);
                        (*p)++;
                        string_push_back(text, string_c_str(line));
                        string_push_back2(text, '\n');
                        string_put(line, "");
                    }
                    else {
                        string_push_back2(line, **p);
                        string_push_back2(not_evaled, **p);
                        (*p)++;

                        if(strstr(string_c_str(line), string_c_str(name)) == string_c_str(line))
                        {
                            break;
                        }
                    }
                }

                if(vector_size(command->mArgs) == 0) {
                    err_msg("command name must be determined staticaly", sname, *sline);
                    string_delete(line);
                    string_delete(name);
                    return FALSE;
                }

                if(!add_arg_to_command(command, ARG_NEW(7, sHereDoc_new(MANAGED text, expand_env)), sname, sline))
                {
                    string_delete(line);
                    string_delete(name);
                    return FALSE;
                }

                string_delete(line);
                string_delete(name);
            }
            /// ?????? ///
            else if(*(*p+1) == '(') {
                string_push_back2(not_evaled, **p);
                (*p)++;

                string_obj* cmd = STRING_NEW("");
                if(!read_until_next_close_character('(', ')', p, cmd, read_end_of_statment, FALSE, sname, sline)) {
                    string_delete(cmd);
                    return FALSE;
                }
                string_push_back(not_evaled, string_c_str(cmd));

                string_erase(cmd, 0, 1); // (???
                string_trunc(cmd, string_length(cmd)-1); // )???

                sStatments* statments = STATMENTS_NEW();
                if(!parse(string_c_str(cmd), sname, sline, statments)) {
                    string_delete(cmd);
                    sStatments_delete(statments);
                    return FALSE;
                }

                string_delete(cmd);

                if(!add_arg_to_command(command, ARG_NEW(6, MANAGED statments), sname, sline))
                {
                    return FALSE;
                }
            }
            /// ??????
            else {
                (*p)++;
                string_push_back(not_evaled, "<");
                int fd = 0;
                enum eRedirect type = kRedirectInput;

                skip_spaces(p, not_evaled);

                if(!add_arg_to_command(command, ARG_NEW(9, MANAGED sRedirect_new(type, fd)), sname, sline))
                {
                    return FALSE;
                }
            }
        }
        /// ?????? ///
        else if(**p == '%') {
            if(*(*p+1) == '>' && *(*p+2) == '>') {
                string_push_back(not_evaled, "%>>");
                break;
            }
            else if(*(*p+1) == '2' && *(*p+2) == '>' && *(*p+3) == '>') 
            {
                string_push_back(not_evaled, "%2>>");
                (*p)+=4;
                int fd = 2;
                enum eRedirect type = kRedirectAppend;

                skip_spaces(p, not_evaled);

                if(!add_arg_to_command(command, ARG_NEW(9, MANAGED sRedirect_new(type, fd)), sname, sline))
                {
                    return FALSE;
                }

            }
            else if(*(*p+1) == '2' && *(*p+2) == '>') {
                string_push_back(not_evaled, "%2>");
                (*p)+=3;
                int fd = 2;
                enum eRedirect type = kRedirectOverwrite;

                skip_spaces(p, not_evaled);

                if(vector_size(command->mArgs) == 0) {
                    err_msg("command name must be determined staticaly", sname, *sline);
                    return FALSE;
                }

                if(!add_arg_to_command(command, ARG_NEW(9, MANAGED sRedirect_new(type, fd)), sname, sline))
                {
                    return FALSE;
                }

            }
            else if(*(*p+1) == '>') {
                string_push_back(not_evaled, "%>");
                (*p)+=2;

                int fd = 0;
                enum eRedirect type = kRedirectErrAndOutput;

                skip_spaces(p, not_evaled);

                if(!add_arg_to_command(command, ARG_NEW(9, MANAGED sRedirect_new(type, fd)), sname, sline))
                {
                    return FALSE;
                }
            }
            else {
                char buf[128];
                snprintf(buf, 128, "unexpected token1 -->%c\n", **p);
                err_msg(buf, sname, *sline);
                return FALSE;
            }
        }
        /// ?? ///
        else if(**p == ' ' || **p == '\t') {
            skip_spaces(p, not_evaled);
        }
        /// ?????????? ///
        else if(**p == '(') {
            /// ???????????????? ///
            if(vector_size(command->mArgs) == 0) {
                string_obj* str = STRING_NEW("");
                int read_end_of_statment = -1;
                if(!read_until_next_close_character('(', ')', p, str, &read_end_of_statment, FALSE, sname, sline)) {
                    string_delete(str);
                    return FALSE;
                }
                string_push_back(not_evaled, string_c_str(str));
                string_push_back(statment->mTitle, string_c_str(str));

                string_erase(str, 0, 1);
                string_trunc(str, string_length(str)-1);

                sStatments* statments = STATMENTS_NEW();
                if(!parse(string_c_str(str), sname, sline, statments))
                {
                    string_delete(str);
                    sStatments_delete(statments);
                    return FALSE;
                }

                string_delete(str);

                command->mKind= kSubshell;
                if(!add_arg_to_command(command, ARG_NEW(0, MANAGED STRING_NEW("subshell")), sname, sline))
                {
                    return FALSE;
                }
                command->mExtra = sSubshell_new(MANAGED statments);
            }
            /// ???? ///
            else {
                string_obj* str = STRING_NEW("");
                vector_obj* args = VECTOR_NEW(10);
                if(!read_block(p, str, args, not_evaled, FALSE, sname, sline)) {
                    int i;
                    for(i=0; i<vector_size(args); i++) {
                        string_delete(vector_item(args, i));
                    }
                    vector_delete(args);
                    string_delete(str);
                    return FALSE;
                }

                sStatments* block = STATMENTS_NEW();
                if(!parse(string_c_str(str), sname, sline, block))
                {
                    sStatments_delete(block);
                    int i;
                    for(i=0; i<vector_size(args); i++) {
                        string_delete(vector_item(args, i));
                    }
                    vector_delete(args);
                    string_delete(str);
                    return FALSE;
                }

                int count = 0;
                int i;
                for(i=0; i<vector_size(command->mArgs); i++) {
                    sArg* arg = vector_item(command->mArgs, i);
                    if(arg->mKind != 5) {
                        count++;
                    }
                }

                if(vector_size(command->mArgs) == 0) {
                    err_msg("command name must be determined staticaly", sname, *sline);
                    sStatments_delete(block);
                    int i;
                    for(i=0; i<vector_size(args); i++) {
                        string_delete(vector_item(args, i));
                    }
                    vector_delete(args);
                    string_delete(str);
                    return FALSE;
                }

                if(!add_arg_to_command(command, ARG_NEW(5, MANAGED sBlock_new(MANAGED block, MANAGED args, count-1)), sname, sline))
                {
                    string_delete(str);
                    return FALSE;
                }

                string_push_back(statment->mTitle, string_c_str(str));
                string_push_back(statment->mTitle, " ");

                skip_spaces(p, not_evaled);

                string_delete(str);
            }
        }
        else {
            break;
        }
    }

    return TRUE;
}

/// ??????
static BOOL read_statment(char**p, sStatment* statment, string_obj* not_evaled, int* read_end_of_statment, char* sname, int* sline)
{
    /// ?? ///
    if(**p == '!') {
        string_push_back2(not_evaled, '!');
        (*p)++;
        statment->mRCodeReverse = TRUE;

        skip_spaces(p, not_evaled);
    }

    /// ????????, STDIN??? ///
    if(**p == '|' && *(*p+1) == '>') {
        string_push_back2(not_evaled, **p);
        (*p)++;
        string_push_back2(not_evaled, **p);
        (*p)++;

        statment->mGlobalPipeIn = 1;

        skip_spaces(p, not_evaled);
    }
    else if(**p == '|' && *(*p+1) >= '0' && *(*p+1) <= '9' && *(*p+2) == '>') {
        string_push_back2(not_evaled, **p);
        (*p)++;
        int num = **p - '0';
        string_push_back2(not_evaled, **p);
        (*p)++;
        string_push_back2(not_evaled, **p);
        (*p)++;

        statment->mGlobalPipeIn = 4;
        statment->mGlobalPipeInNum = num;

        skip_spaces(p, not_evaled);
    }
    else if(**p == '|' && *(*p+1) != '|') {
        string_push_back2(not_evaled, **p);
        (*p)++;

        skip_spaces(p, not_evaled);

        statment->mSTDINPipe = TRUE;
    }

    while(**p) {
        sCommand* command = COMMAND_NEW();
        if(!read_command(p, command, statment, not_evaled, read_end_of_statment, sname, sline)) 
        {
            sCommand_delete(command);
            return FALSE;
        }

        /// ???? ///
        if(*read_end_of_statment == -1 
            && vector_size((command)->mArgs) > 0) 
        {
            vector_add(statment->mCommands, MANAGED command);
        }
        else {
            sCommand_delete(command);
        }

        if(**p == '|' && *(*p+1) != '>' && (*(*p+1) < '0' || *(*p+1) > '9') && *(*p+1) != '|')
        {
            string_push_back(not_evaled, "|");
            (*p)++;
        }
        else {
            break;
        }
    }

    return TRUE;
}

/// ?????gErrMsg??????????????????????
BOOL parse(char* cmdline, char* sname, int* sline, sStatments* statments)
{
    char* p = cmdline;

    string_put(statments->mSource, cmdline);

    while(*p) {
        /// ?????????? ///
        while(*p == ' ' || *p == '\t' || *p == '\n' && (*sline)++) { p++; }

        /// ?? ///
        sStatment* statment = STATMENT_NEW();
        string_obj* not_evaled = STRING_NEW("");
        int read_end_of_statment = -1;
            // ????????????????
            // ???????????????????????
        int line_of_head = *sline;

        if(!read_statment(&p, statment, not_evaled, &read_end_of_statment, sname, sline))
        {
            sStatment_delete(statment);
            string_delete(not_evaled);
            return FALSE;
        }
        /// ????????
        if(*p == '|' && *(p+1) >= '0' && *(p+1) <= '9' && *(p+2) == '>') {
            string_push_back(not_evaled, "|");
            p++;
            int num = *p - '0';
            string_push_back2(not_evaled, *p);
            p++;
            string_push_back2(not_evaled, *p);
            p++;

            if(*p == '>') {
                string_push_back(not_evaled, ">");
                p++;
                statment->mGlobalPipeOut = 0x14;
                statment->mGlobalPipeOutNum = num;
            }
            else {
                statment->mGlobalPipeOut = 4;
                statment->mGlobalPipeOutNum = num;
            }

            skip_spaces(&p, not_evaled);
        }

        else if(*p == '|' && *(p+1) == '>') {
            string_push_back(not_evaled, "|");
            p++;
            string_push_back(not_evaled, ">");
            p++;

            if(*p == '>') {
                string_push_back(not_evaled, ">");
                p++;
                statment->mGlobalPipeOut = 0x11;
            }
            else {
                statment->mGlobalPipeOut = 0x01;
            }

            skip_spaces(&p, not_evaled);
        }

        /// ?????
        if(*p == '&' && *(p+1) == '&') {
            string_push_back(not_evaled, "&&");
            p+=2;
            statment->mTerminated = kTAndAnd;
            statment->mLine = line_of_head;
            string_put(statment->mFName, sname);

            skip_spaces(&p, not_evaled);
        }
        else if(*p == '|' && *(p+1) == '|') {
            string_push_back(not_evaled, "||");
            p+=2;

            statment->mTerminated = kTOrOr;
            statment->mLine = line_of_head;
            string_put(statment->mFName, sname);

            skip_spaces(&p, not_evaled);
        }
        else if(*p == '&') {
            string_push_back2(not_evaled, '&');
            p++;

            statment->mBackground = TRUE;
            statment->mTerminated = kTNormal;
            statment->mLine = line_of_head;
            string_put(statment->mFName, sname);

            skip_spaces(&p, not_evaled);
        }
        else if(*p == '\n') {
            statment->mTerminated = kTNormal;
            statment->mLine = line_of_head;
            string_put(statment->mFName, sname);

            (*sline)++;
            string_push_back2(not_evaled, '\n');
            p++; 
            skip_spaces(&p, not_evaled);
        }
        else if(*p == ';') {
            statment->mTerminated = kTNormal;
            statment->mLine = line_of_head;
            string_put(statment->mFName, sname);

            string_push_back2(not_evaled, ';');
            p++;
            skip_spaces(&p, not_evaled);
        }
        else if(*p == 0) {
            statment->mTerminated = kTNormal;
            statment->mLine = line_of_head;
            string_put(statment->mFName, sname);
        }
        else {
            char buf[128];
            snprintf(buf, 128, "unexpected token3 -->%c\n", *p);
            err_msg(buf, sname, *sline);
            sStatment_delete(statment);
            string_delete(not_evaled);
            return FALSE;
        }

        /// ????????????
        if(read_end_of_statment != -1) {
            statment->mNotEvaled = MANAGED not_evaled;
        }
        else {
            string_delete(not_evaled);
        }

        // ???????????????????????????
        if(vector_size(statment->mCommands) > 0 || statment->mNotEvaled != NULL) {
            vector_add(statments->mStatments, MANAGED statment);
        }
        else {
            sStatment_delete(statment);
        }
    }

    return TRUE;
}

// ????????????
static BOOL expand_env_get_quoted_str(char* fname, string_obj* quoted_fname, char* sname, int* sline)
{
    char* p = fname;
    while(*p) {
        if(gKitutukiSigInt) {
            gKitutukiSigInt = FALSE;
            err_msg("signal interrupt", sname, *sline);
            return FALSE;
        }
        if(*p == '\n') {
            string_push_back(quoted_fname, "\\n");
            p++;
        }
        else if(*p == '\r') {
            string_push_back(quoted_fname, "\\r");
            p++;
        }
        else if(*p == '\t') {
            string_push_back(quoted_fname, "\\t");
            p++;
        }
        else if(*p == '\a') {
            string_push_back(quoted_fname, "\\a");
            p++;
        }
        else if(*p==' ' || *p=='*' || *p=='&' || *p=='~'
                || *p=='#' || *p =='$' || *p=='(' || *p==')'
                || *p=='\\' || *p=='|' || *p=='[' || *p==']' || *p=='{' 
                || *p=='}' || *p==';'
                || *p=='\'' || *p=='"' || *p=='<' || *p=='>' || *p=='?' 
                || *p=='%' || *p=='@')
        {
            string_push_back2(quoted_fname, '\\');
            string_push_back2(quoted_fname, *p++);
        }
        else {
            string_push_back2(quoted_fname, *p++);
        }
    }

    return TRUE;
}

BOOL expand_env(char* p, string_obj* out, sRFd* rfd, char* sname, int* sline, sObject* object)
{
    BOOL squote = FALSE;
    BOOL dquote = FALSE;

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

        /// ???? ///
        if(!squote && !dquote && *p == '\\') {
            string_push_back2(out, *p++);
            if(*p == 0) {
                err_msg("unexpected end after quote", sname, *sline);
                return FALSE;
            }

            string_push_back2(out, *p++);
        }
        /// ???????? ///
        else if(!dquote && *p == '\'') {
            squote = !squote;
            string_push_back2(out, *p++);
        }
        /// ??????? ///
        else if(!squote && *p == '"') {
            dquote = !dquote;
            string_push_back2(out, *p++);
        }
        /// ??????
        else if(!squote && *p == '$') {
            /// ?????? $( ///
            if(*(p+1) == '$' && *(p+2) == '(' || *(p+1) == '(')
            {
                BOOL quote;
                if(*(p+1) == '$') {
                    p+=2;
                    quote = FALSE;
                }
                else {
                    p++;
                    quote = TRUE;
                }

                string_obj* str = STRING_NEW("");
                int read_end_of_statment = -1;
                if(!read_until_next_close_character('(', ')', &p, str, &read_end_of_statment, FALSE, sname, sline)) 
                {
                    string_delete(str);
                    return FALSE;
                }

                string_erase(str, 0, 1); // (???
                string_trunc(str, string_length(str)-1); // )???

                sWFd* pipeout = WFD_NEW(-1);
                char* fname = MALLOC(strlen(sname) + 256);
                snprintf(fname, strlen(sname) + 256, "%s %d: expand command", sname, *sline);
                int rcode = saphire_shell5(pipeout, string_c_str(str), fname, rfd, object);
                FREE(fname);
                string_delete(str);
                if(rcode < 0) {
                    sWFd_delete(pipeout);
                    return FALSE;
                }

                if(quote) {
                    string_obj* quoted = STRING_NEW("");
                    if(!expand_env_get_quoted_str(pipeout->mBuffer, quoted, sname, sline))
                    {
                        sWFd_delete(pipeout);
                        string_delete(quoted);
                        return FALSE;
                    }
                    string_push_back(out, string_c_str(quoted));
                    string_delete(quoted);
                }
                else {
                    string_push_back(out, pipeout->mBuffer);
                }

                sWFd_delete(pipeout);
            }
            /// var, global, export ?? ///
            else {
                BOOL quote;
                if(*(p+1) == '$') {
                    p+=2;
                    quote = FALSE;
                }
                else {
                    p++;
                    quote = TRUE;
                }

                if((*p >= '0' && *p <= '9' || *p >= 'a' && *p <= 'z' || *p >= 'A' && *p <= 'Z' || *p == '_') || *p == '{') {
                    string_obj* name = STRING_NEW("");

                    BOOL bracket;
                    if(*p == '{') {
                        int read_end_of_statment = -1;
                        if(!read_until_next_close_character('{', '}',&p, name, &read_end_of_statment, TRUE, sname, sline)) {
                            string_delete(name);
                            return FALSE;
                        }

                        string_erase(name, 0, 1);
                        string_trunc(name, string_length(name)-1);
                        bracket = TRUE;
                    }
                    else {
                        bracket = FALSE;
                        while(*p) {
                            if(*p >= '0' && *p <= '9' || *p >= 'a' && *p <= 'z' || *p >= 'A' && *p <= 'Z' || *p == '_') {
                                string_push_back2(name, *p); // $
                                p++;
                            }
                            else {
                                break;
                            }
                        }
                    }

                    char* name2 = string_c_str(name);

                    /// Var ///
                    string_obj* var = saphire_get_local_var(name2, object);
                    char* env = NULL;

                    if(var == NULL) {
                        var = saphire_get_global_var(name2, object, FALSE);
                        if(var == NULL) {
                            /// export ///
                            env = getenv(name2);
                            if(env) {
                                var = STRING_NEW(env);
                            }
                            else {
                                var = NULL;
                            }
                        }
                    }

                    if(var) {
                        if(quote) {
                            string_obj* quoted = STRING_NEW("");
                            if(!expand_env_get_quoted_str(string_c_str(var), quoted, sname, sline))
                            {
                                string_delete(name);
                                if(env) string_delete(var);
                                return FALSE;
                            }
                            string_push_back(out, string_c_str(quoted));
                            string_delete(quoted);
                        }
                        else {
                            string_push_back(out, string_c_str(var));
                        }

                        if(env) string_delete(var);
                    }

                    string_delete(name);
                }
                else {
                    if(quote) {
                        string_push_back2(out, '$');
                    }
                    else {
                        string_push_back(out, "$$");
                    }
                }
            }
        }
        else if(squote || dquote) {
            if(*p == 0) {
                err_msg("close ' or \" before the end of statment", sname, *sline);
                return FALSE;
            }

            string_push_back2(out, *p++);
        }
        /// ????????????
        else if(*p == '<' && *(p+1) == '<') {
            string_push_back2(out, *p);
            p++;
            string_push_back2(out, *p);
            p++;

            skip_spaces(&p, out);

            BOOL squote = FALSE;
            BOOL dquote = FALSE;
            if(*p == '\'') {
                squote = TRUE;
                string_push_back2(out, *p);
                p++;
            }
            else if(*p == '"') {
                dquote = TRUE;
                string_push_back2(out, *p);
                p++;
            }

            string_obj* name = STRING_NEW("");
            while(*p) {
                if(*p == '\n') {
                    string_push_back2(out, *p);
                    p++;
                    break;
                }
                else if(*p == ' ' || *p == '\t') {
                    skip_spaces(&p, out);
                    if(*p != '\n') {
                        err_msg("invalid here document name7", sname, *sline);
                        string_delete(name);
                        return FALSE;
                    }
                    string_push_back2(out, *p);
                    p++;
                    break;
                }
                else if(*p >='A' && * p <= 'Z' || *p >='a' && *p <='z')
                {
                    string_push_back2(name, *p);
                    string_push_back2(out, *p);
                    p++;
                }
                else if(dquote && *p == '"') {
                    dquote = FALSE;
                    string_push_back2(out, *p);
                    p++;
                    skip_spaces(&p, out);
                    if(*p != '\n') {
                        err_msg("invalid here document name8", sname, *sline);
                        string_delete(name);
                        return FALSE;
                    }
                    string_push_back2(out, *p);
                    p++;
                    break;
                }
                else if(squote && *p == '\'') {
                    squote = FALSE;
                    string_push_back2(out, *p);
                    p++;
                    skip_spaces(&p, out);
                    if(*p != '\n') {
                        err_msg("invalid here document name9", sname, *sline);
                        string_delete(name);
                        return FALSE;
                    }
                    string_push_back2(out, *p);
                    p++;
                    break;
                }
                else {
                    err_msg("invalid here document name", sname, *sline);
                    string_delete(name);
                    return FALSE;
                }
            }

            if(dquote || squote|| string_c_str(name)[0] == 0) {
                err_msg("invalid here document name10", sname, *sline);
                string_delete(name);
                return FALSE;
            }

            string_obj* line = STRING_NEW("");
            while(*p) {
                if(*p == '\n') {
                    string_push_back2(out, *p);
                    p++;
                }
                else {
                    string_push_back2(line, *p);
                    string_push_back2(out, *p);
                    p++;

                    if(strstr(string_c_str(line), string_c_str(name)) == string_c_str(line))
                    {
                        break;
                    }
                }
            }

            string_delete(line);
            string_delete(name);
        }

        /// ??????????????????
        else if(*p == '(') {
            int read_end_of_statment = -1;
            if(!read_until_next_close_character('(', ')', &p, out, &read_end_of_statment, FALSE, sname, sline))
            {
                return FALSE;
            }
        }
        else {
            string_push_back2(out, *p++);
        }
    }

    return TRUE;
}

BOOL expand_brace_expression(string_obj* tail, vector_obj* v, string_obj* start, string_obj* end, char** p, char* sname, int* sline)
{
    string_obj* str = STRING_NEW("");

    while(1) {
        if(**p == '\\') {
            (*p)++;
            string_push_back2(str, '\\');
            string_push_back2(str, **p);
            (*p)++;
        }
        else if(**p == '{') {
            (*p)++;

            vector_obj* v2 = VECTOR_NEW(10);
            string_obj* tail2 = STRING_NEW("");
            string_obj* start2 = STRING_NEW("");
            string_obj* end2 = STRING_NEW("");
            if(!expand_brace_expression(tail2, v2, start2, end2, p, sname, sline)) {
                string_delete(str);
                string_delete(tail2);
                string_delete(start2);
                string_delete(end2);
                int i;
                for(i=0; i<vector_size(v2); i++) {
                    string_delete(vector_item(v2, i));
                }
                vector_delete(v2);
                return FALSE;
            }

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

            /// string
            if(string_c_str(start2)[0] == 0) {
                if(vector_size(v2) == 0) {
                    err_msg("invalid brace expression2", sname, *sline);
                    string_delete(str);
                    string_delete(tail2);
                    vector_delete(v2);
                    string_delete(start2);
                    string_delete(end2);
                    return FALSE;
                }

                int i;
                for(i=0; i<vector_size(v2); i++) {
                    string_obj* str2 = STRING_NEW("");
                    string_push_back(str2, string_c_str(str));
                    string_push_back(str2, string_c_str(vector_item(v2, i)));
                    string_push_back(str2, string_c_str(tail2));

                    vector_add(v, str2);
                }
            }
            /// number
            else {
                int start3 = atoi(string_c_str(start2));
                int end3 = atoi(string_c_str(end2));

                int num_len = strlen(string_c_str(start2));
                if(start3 < 0) num_len--;

                char buf2[1024];
                buf2[0] = '%';
                snprintf(buf2 + 1, 1023, "0%dd", num_len);

                if(start3 < end3) {
                    int i;
                    for(i=start3; i<=end3; i++) {
                        string_obj* str2 = STRING_NEW("");

                        string_push_back(str2, string_c_str(str));

                        char buf[1024];
                        if(i < 0) {
                            buf[0] = '-';
                            snprintf(buf + 1, 1023, buf2, abs(i));
                        }
                        else {
                            snprintf(buf, 1024, buf2, i);
                        }

                        string_push_back(str2, buf);

                        string_push_back(str2, string_c_str(tail2));

                        vector_add(v, str2);
                    }
                }
                else if(start3 == end3) {
                    vector_add(v, STRING_NEW(string_c_str(start2)));
                }
                else {
                    int i;
                    for(i=start3; i>=end3; i--) {
                        string_obj* str2 = STRING_NEW("");

                        string_push_back(str2, string_c_str(str));

                        char buf[1024];
                        if(i < 0) {
                            buf[0] = '-';
                            snprintf(buf + 1, 1023, buf2, abs(i));
                        }
                        else {
                            snprintf(buf, 1024, buf2, i);
                        }
                        string_push_back(str2, buf);

                        string_push_back(str2, string_c_str(tail2));

                        vector_add(v, str2);
                    }
                }
            }

            string_put(str, "");
            string_delete(tail2);
            int i;
            for(i=0; i<vector_size(v2); i++) {
                string_delete(vector_item(v2, i));
            }
            vector_delete(v2);

            string_delete(start2);
            string_delete(end2);
        }
        else if(**p == '}') {
            (*p)++;

            if(*(*p-2) == ',') {
                    vector_add(v, str);
            }
            else {
                if(string_c_str(str)[0] == 0) {
                    string_delete(str);
                }
                else {
                    vector_add(v, str);
                }
            }

            while(**p) {
                if(**p == '\\') {
                    (*p)++;
                    string_push_back2(tail, '\\');
                    string_push_back2(tail, **p);
                    (*p)++;
                }
                else if(**p == ' ' || **p == '\t' || **p == '\n' || **p == ',' || **p=='>' || **p=='}'  || **p=='&' || **p=='~' || **p=='#' || **p =='$' || **p=='(' || **p==')' || **p=='|' || **p==';' || **p=='\'' || **p=='"' || **p=='<' || **p=='%' || **p=='@')
                {
                    break;
                }
                else {
                    string_push_back2(tail, **p);
                    (*p)++;
                }
            }

            break;
        }
        else if(**p == ',') {
            (*p)++;

            vector_add(v, str);
            str = STRING_NEW("");
        }
        else if(**p == '.' && *(*p+1) == '.') {
            (*p)+=2;

            string_put(start, string_c_str(str));

            string_put(str, "");

            if(**p == '-') {
                string_push_back2(str, **p);
                (*p)++;
            }

            while(1) {
                if(**p == '}') {
                    (*p)++;
                    break;
                }
                else if(**p >= '0' && **p <= '9') {
                    string_push_back2(str, **p);
                    (*p)++;
                }
                else {
                    err_msg("invalid brace expression", sname, *sline);
                    string_delete(str);
                    return FALSE;
                }
            }

            string_put(end, string_c_str(str));

            while(**p) {
                if(**p == '\\') {
                    (*p)++;
                    string_push_back2(tail, '\\');
                    string_push_back2(tail, **p);
                    (*p)++;
                }
                else if(**p == ' ' || **p == '\t' || **p == '\n' || **p == ',' || **p=='}' || **p=='>' || **p=='&' || **p=='~' || **p=='#' || **p =='$' || **p=='(' || **p==')' || **p=='|' || **p==';' || **p=='\'' || **p=='"' || **p=='<' || **p=='%' || **p=='@')
                {
                    break;
                }
                else {
                    string_push_back2(tail, **p);
                    (*p)++;
                }
            }

            string_delete(str);
            break;
        }
        else if(**p == 0) {
            err_msg("invalid brace expression", sname, *sline);
            string_delete(str);
            return FALSE;
        }
        else {
            string_push_back2(str, **p);
            (*p)++;
        }
    }

    return TRUE;
}

// ?????????
// ???????????????
// ?????????
BOOL delete_comments(char* p, string_obj* cmdline2, char* separator, char* sname, int* sline)
{
    BOOL squote = FALSE;
    BOOL dquote = FALSE;

    string_obj* head = STRING_NEW("");
    while(*p) {
        if(!dquote && !squote && *p == '\\') {
            string_push_back2(cmdline2, *p++);

            string_push_back2(head, *p);
            string_push_back2(cmdline2, *p++);
        }
        else if(!dquote && *p == '\'') {
            string_push_back2(cmdline2, *p++);
            squote = !squote;
        }
        else if(!squote && *p == '"') {
            string_push_back2(cmdline2, *p++);
            dquote = !dquote;
        }
        else if(squote || dquote) {
            if(*p == 0) {
                err_msg("close \" or \' before the end of comments", sname, *sline);
                string_delete(head);
                return FALSE;
            }
            else {
                string_push_back2(head, *p);
                string_push_back2(cmdline2, *p++);
            }
        }
        /// ?????
        else if(*p == '$' && *(p+1) == '{') {
            string_push_back2(head, *p);
            string_push_back2(cmdline2, *p++);
            string_push_back2(head, *p);
            string_push_back2(cmdline2, *p++);
        }
        /// ???? ///
        else if(*p == '#') {
            p++;

            while(*p) {
                if(*p == '\n') {
                    string_push_back2(cmdline2, '\n');
                    p++;

                    break;
                }
                else {
                    p++; 
                }
            }
        }
        /// ??????
        else if(*p == '{') {
            p++;

            vector_obj* v = VECTOR_NEW(10);
            string_obj* tail = STRING_NEW("");
            string_obj* start = STRING_NEW("");
            string_obj* end = STRING_NEW("");
            if(!expand_brace_expression(tail, v, start, end, &p, sname, sline)) {
                string_delete(head);
                string_delete(tail);
                string_delete(start);
                string_delete(end);
                int i;
                for(i=0; i<vector_size(v); i++) {
                    string_delete(vector_item(v, i));
                }
                vector_delete(v);
                return FALSE;
            }

            /// string
            if(string_c_str(start)[0] == 0) {
                if(vector_size(v) == 0) {
                    err_msg("invalid brace expression", sname, *sline);
                    string_delete(head);
                    string_delete(tail);
                    string_delete(start);
                    string_delete(end);
                    vector_delete(v);
                    return FALSE;
                }

                string_push_back(cmdline2, string_c_str(vector_item(v, 0)));
                string_push_back(cmdline2, string_c_str(tail));
                string_push_back2(cmdline2, ' ');

                int i;
                for(i=1; i<vector_size(v); i++) {
                    string_push_back(cmdline2, string_c_str(head));
                    string_push_back(cmdline2, string_c_str(vector_item(v, i)));
                    string_push_back(cmdline2, string_c_str(tail));
                    if(i < vector_size(v)-1) string_push_back2(cmdline2, ' ');
                }
            }
            /// number
            else {
                int start2 = atoi(string_c_str(start));
                int end2 = atoi(string_c_str(end));

                int num_len = strlen(string_c_str(start));
                if(num_len < 0) num_len--;

                char buf2[1024];
                buf2[0] = '%';
                snprintf(buf2 + 1, 1023, "0%dd", num_len);

                if(start2 < end2) {
                    string_push_back(cmdline2, string_c_str(start));
                    string_push_back(cmdline2, string_c_str(tail));
                    string_push_back2(cmdline2, ' ');

                    int i;
                    for(i=start2+1; i<=end2; i++) {
                        string_push_back(cmdline2, string_c_str(head));

                        char buf[1024];
                        if(i < 0) {
                            buf[0] = '-';
                            snprintf(buf + 1, 1023, buf2, abs(i));
                        }
                        else {
                            snprintf(buf, 1024, buf2, i);
                        }

                        string_push_back(cmdline2, buf);
                        string_push_back(cmdline2, string_c_str(tail));
                        if(i <= end2-1) string_push_back2(cmdline2, ' ');
                    }
                }
                else if(start2 == end2) {
                    string_push_back(cmdline2, string_c_str(start));
                    string_push_back(cmdline2, string_c_str(tail));
                    string_push_back2(cmdline2, ' ');
                }
                else {
                    string_push_back(cmdline2, string_c_str(start));
                    string_push_back(cmdline2, string_c_str(tail));
                    string_push_back2(cmdline2, ' ');

                    int i;
                    for(i=start2-1; i>=end2; i--) {
                        string_push_back(cmdline2, string_c_str(head));

                        char buf[1024];
                        if(i < 0) {
                            buf[0] = '-';
                            snprintf(buf + 1, 1023, buf2, abs(i));
                        }
                        else {
                            snprintf(buf, 1024, buf2, i);
                        }
                        string_push_back(cmdline2, buf);

                        string_push_back(cmdline2, string_c_str(tail));

                        if(i>= end2 + 1) string_push_back2(cmdline2, ' ');
                    }
                }
            }

            string_put(head, "");
            string_delete(tail);
            int i;
            for(i=0; i<vector_size(v); i++) {
                string_delete(vector_item(v, i));
            }
            vector_delete(v);
            string_delete(start);
            string_delete(end);
        }
        else if(*p == ' ' || *p == '\t' || *p == '\n') {
            string_push_back2(cmdline2, *p++);

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

    string_delete(head);
    return TRUE;
}

// ??????????????????????
// ??????????????
// ?????gErrMsg???????????????
BOOL saphire_compile(char* fname, char* out_fname)
{
    /// ???? ///
    string_obj* str = STRING_NEW("");

    int f = open(fname, O_RDONLY);
    if(f < 0) {
        string_delete(str);
        return FALSE;
    }

    char buf[BUFSIZ];
    while(1) {
        int size = read(f, buf, BUFSIZ-1);
        if(size == 0) {
            break;
        }
        if(size < 0) {
            close(f);
            string_delete(str);
            return FALSE;
        }

        buf[size] = 0;

        string_push_back(str, buf);
    }
    close(f);
    
    /// ??? ///
    int sline = 1;

    string_obj* str2 = STRING_NEW("");
    if(!delete_comments(string_c_str(str), str2, " ", fname, &sline)) {
        string_delete(str);
        string_delete(str2);
        return FALSE;
    }
    string_delete(str);

    sline = 1;

    sStatments* statments = STATMENTS_NEW();
    if(!parse(string_c_str(str2), fname, &sline, statments)) {
        sStatments_delete(statments);
        string_delete(str2);
        return FALSE;
    }

    string_delete(str2);

    /// ?????????? ///
    int fd = open(out_fname, O_WRONLY|O_TRUNC|O_CREAT, 0644);
    if(write(fd, gMagicNumber, strlen(gMagicNumber)) < 0) {
        perror("write");
        exit(1);
    }

    sStatments_save(statments, fd);

    (void)close(fd);

    sStatments_delete(statments);

    return TRUE;
}

// ??????????(????????????)????????
// ??????
// ????-1???????????gErrMsg????????????????
int saphire_load_obj(char* fname, sWFd* pipeout, sRFd* pipein, int pipeerr, vector_obj* parent_blocks)
{
    gKitutukiSigInt = FALSE;
    int fd = open(fname, O_RDONLY);
    if(fd < 0) {
        return -1;
    }
    
    char magic_number[64];
    if(read(fd, magic_number, strlen(gMagicNumber)) < 0) {
        perror("read");
        exit(1);
    }
    magic_number[strlen(gMagicNumber)] = 0;
    
    if(strcmp(magic_number, gMagicNumber) != 0) {
        return -1;
    }
    
    /// ?????????????? ///
    sStatments* statments = sStatments_load(fd);

    /// ?? ///
    int return_ = FALSE;
    int break_ = FALSE;

    sRunInfo runinfo;
    runinfo.return_ = &return_;
    runinfo.break_ = &break_;
    runinfo.envs = VECTOR_NEW(10);
    runinfo.enable_return = TRUE;
    runinfo.enable_break = FALSE;
    runinfo.parent_blocks = parent_blocks;
    runinfo.object = NULL;
    runinfo.running_fun = NULL;
    runinfo.running_class = NULL;

    int rcode = run(&runinfo, statments, fname, pipeout, pipein, pipeerr , FALSE);

    /// ?? ///
    close(fd);

    int i;
    for(i=0; i<vector_size(runinfo.envs); i++) {
        string_delete(vector_item(runinfo.envs, i));
    }
    vector_delete(runinfo.envs);
    sStatments_delete(statments);

    return rcode;
}