Пример #1
0
int main(int argc, char *argv[])
{
    int pid, todc[2], fromdc[2];

    /* make tow pipes */

    if (pipe(todc) == -1 || pipe(fromdc) == -1)
        opps("pipe failed", 1);

    /* get a process for user interface */

    if ((pid = fork()) == -1)
        opps("Cannot fork", 2);
    if (pid == 0)               /* child dc */
        be_dc(todc, fromdc);
    else{
        be_bc(todc, fromdc);
        wait(NULL);
    }

    return 0;
}
Пример #2
0
int be_dc(int in[2], int out[2])
/* set up stdin and stdout, then execl dc */
{
    /* setup stdin from pipein */
    if (dup2(in[0], 0) == -1) { /* copy read end to 0 */
        opps("dc: cannot redirect stdin", 3);
    }

    close(in[0]);               /* moved to fd0 */
    close(in[1]);               /* won't write here */

    /* set up stdout to pipeout */
    if (dup2(out[1], 1) == -1) {
        opps("dc: cannot readirect stdout", 4);
    }

    close(out[1]);              /* moved to fd1 */
    close(out[0]);              /* won't read from here */

    /* now execl dc with the - option */
    execlp("dc", "dc", "-", NULL);
    opps("Cannot run dc", 5);
}
Пример #3
0
int check_syntax(const char *message)
{
    int l_check = 0;
    int m_check = 0;
    int b_check = 0;

    int i = 0;

    for (i = 0; i < strlen(message); i++) {
        switch (message[i]) {
        case '(':
            l_check++;
            break;
        case ')':
            l_check--;
            break;
        case '[':
            m_check++;
            break;
        case ']':
            m_check--;
            break;
        case '{':
            b_check++;
            break;
        case '}':
            b_check--;
            break;
        default:
            continue;
        }

        if (l_check < 0 || m_check < 0 ||
            b_check < 0) {
            opps("syntax errors\n", 98);
        }
    }
    return 1;
}
Пример #4
0
std::string Value::asString(void) const
{
    std::string id = get_cur_union_member_type_id(m_index);

    if(typeid(bool).name()==id)
    {//bool                    m_bool;          //0
        if(m_data.m_bool)
            return "true";
        else
            return "false";
    }
    else if(typeid(char).name()==id)
    {//char                    m_char;          //1
        char tmp[2];
        tmp[0] = m_data.m_char;
        tmp[1] = 0;
        return std::string(tmp);
    }
    else if(typeid(const char*).name()==id)
    {//const char*             m_char_ptr;      //2
        if(m_data.m_char_ptr != nullptr)
        {
            const char *ptr = m_data.m_char_ptr;
            char tmp[size];
            unsigned int cnt = 0;
            while(*ptr != '\0' && cnt < size)
            {
                tmp[cnt] = ptr[cnt];
                cnt++;
            }
            tmp[cnt] = 0;

            return std::string(tmp);
        }
        else
            opps();
    }
    else if(typeid(unsigned char).name()==id)
    {//unsigned char           m_uchar;         //3
        char tmp[2];
        tmp[0] = LinuxUtility::convertIntegerToDigitCharacter(m_data.m_uchar);
        tmp[1] = 0;
        return std::string(tmp);
    }
    else if(typeid(const unsigned char*).name()==id)
    {//const unsigned char*    m_uchar_ptr;     //4
        if(m_data.m_uchar_ptr != nullptr)
        {
            const unsigned char *ptr = m_data.m_uchar_ptr;
            char tmp[size];
            unsigned int cnt = 0;
            while(*ptr != '\0' && cnt < size)
            {
                tmp[cnt] = (char)ptr[cnt];
                cnt++;
            }
            tmp[cnt] = 0;

            return std::string(tmp);
        }
        else
            opps();
    }
    else if(typeid(short).name()==id)
    {//short                   m_short;         //5
        char tmp[256];
        memset(tmp,0,sizeof(tmp));
        sprintf(tmp,"%hd",m_data.m_short);
        return std::string(tmp);
    }
    else if(typeid(const short*).name()==id)
    {//const short*            m_short_ptr;     //6
        char tmp[256];
        memset(tmp,0,sizeof(tmp));
        if(m_data.m_short_ptr != nullptr)
            sprintf(tmp,"%hd",*m_data.m_short_ptr);
        else
            opps();
        return std::string(tmp);
    }
    else if(typeid(unsigned short).name()==id)
    {//unsigned short          m_ushort;		//7
        char tmp[256];
        memset(tmp,0,sizeof(tmp));
        sprintf(tmp,"%hu",m_data.m_ushort);
        return std::string(tmp);
    }
    else if(typeid(const unsigned short*).name()==id)
    {//const unsigned short*   m_ushort_ptr;	//8
        char tmp[256];
        memset(tmp,0,sizeof(tmp));
        if(m_data.m_ushort_ptr != nullptr)
            sprintf(tmp,"%hu",*m_data.m_ushort_ptr);
        else
            opps();
        return std::string(tmp);
    }
    else if(typeid(int).name()==id)
    {//int                     m_int;           //9
        char tmp[256];
        memset(tmp,0,sizeof(tmp));
        sprintf(tmp,"%d",m_data.m_int);
        return std::string(tmp);
    }
    else if(typeid(const int*).name()==id)
    {//const int*              m_int_ptr;       //10
        char tmp[256];
        memset(tmp,0,sizeof(tmp));
        if(m_data.m_int_ptr != nullptr)
            sprintf(tmp,"%d",*m_data.m_int_ptr);
        else
            opps();
        return std::string(tmp);
    }
    else if(typeid(unsigned int).name()==id)
    {//unsigned int            m_uint;          //11
        char tmp[256];
        memset(tmp,0,sizeof(tmp));
        sprintf(tmp,"%u",m_data.m_uint);
        return std::string(tmp);
    }
    else if(typeid(const unsigned int*).name()==id)
    {//const unsigned int*     m_uint_ptr;      //12
        char tmp[256];
        memset(tmp,0,sizeof(tmp));
        if(m_data.m_uint_ptr != nullptr)
            sprintf(tmp,"%u",*m_data.m_uint_ptr);
        else
            opps();
        return std::string(tmp);
    }
    else if(typeid(long).name()==id)
    {//long                    m_long;          //13
        char tmp[256];
        memset(tmp,0,sizeof(tmp));
        sprintf(tmp,"%ld",m_data.m_long);
        return std::string(tmp);
    }
    else if(typeid(const long*).name()==id)
    {//const long*             m_long_ptr;      //14
        char tmp[256];
        memset(tmp,0,sizeof(tmp));
        if(m_data.m_long_ptr != nullptr)
            sprintf(tmp,"%ld",*m_data.m_long_ptr);
        else
            opps();
        return std::string(tmp);
    }
    else if(typeid(unsigned long).name()==id)
    {//unsigned long           m_ulong;         //15
        char tmp[256];
        memset(tmp,0,sizeof(tmp));
        sprintf(tmp,"%lu",m_data.m_ulong);
        return std::string(tmp);
    }
    else if(typeid(const unsigned long*).name()==id)
    {//const unsigned long*    m_ulong_ptr;     //16
        char tmp[256];
        memset(tmp,0,sizeof(tmp));
        if(m_data.m_ulong_ptr != nullptr)
            sprintf(tmp,"%lu",*m_data.m_ulong_ptr);
        else
            opps();
        return std::string(tmp);
    }
    else if(typeid(float).name()==id)
    {//float                   m_float;         //17
        char tmp[256];
        memset(tmp,0,sizeof(tmp));
        sprintf(tmp,"%f",m_data.m_float);
        return std::string(tmp);
    }
    else if(typeid(const float*).name()==id)
    {//const float*            m_float_ptr;     //18
        char tmp[256];
        memset(tmp,0,sizeof(tmp));
        if(m_data.m_float_ptr != nullptr)
            sprintf(tmp,"%f",*m_data.m_float_ptr);
        else
            opps();
        return std::string(tmp);
    }
    else if(typeid(double).name()==id)
    {//double                  m_double;		//19
        char tmp[256];
        memset(tmp,0,sizeof(tmp));
        sprintf(tmp,"%lf",m_data.m_double);
        return std::string(tmp);
    }
    else if(typeid(const double*).name()==id)
    {//const double*           m_double_ptr;	//20
        char tmp[256];
        memset(tmp,0,sizeof(tmp));
        if(m_data.m_double_ptr != nullptr)
            sprintf(tmp,"%lf",*m_data.m_double_ptr);
        else
            opps();
        return std::string(tmp);
    }
    else if(typeid(const std::string*).name()==id)
    {//const std::string*      m_string_ptr;	//21
        if(m_data.m_string_ptr != nullptr)
            return *m_data.m_string_ptr;
        else
            opps();
    }
    else if(typeid(const Value*).name()==id)
    {//const Value*            m_value_ptr;     //22
        //return convert_value_to_string(m_data.m_value_ptr);
        if(m_data.m_value_ptr != nullptr)
            return m_data.m_value_ptr->asString();
        else
            opps();
    }
    else if(typeid(const ColorCode).name()==id)
    {//const ColorCode         m_color_code;	//23
    	std::string tmp;
    	tmp = "\e[" + Value((int)m_data.m_color_code).asString() + "m";
    	return tmp;
    }