RT-Thread finsh源码分析: finsh_ops.c

/*
 *  operations for finsh shell.
 *
 * COPYRIGHT (C) 2006 - 2013, RT-Thread Development Team
 *
 *  This file is part of RT-Thread (http://www.rt-thread.org)
 *  Maintainer: bernard.xiong <bernard.xiong at gmail.com>
 *
 *  All rights reserved.
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Change Logs:
 * Date           Author       Notes
 * 2010-03-22     Bernard      first version
 */

//该文件用于栈操作，类似栈计算器实现

#include "finsh_ops.h"
#include "finsh_vm.h"

//字节操作，结果保存在栈中，栈指针减一
#define OP_BIN_BYTE(x)  do {\
        (finsh_sp - 2)->char_value = (finsh_sp - 2)->char_value x (finsh_sp - 1)->char_value; \
        finsh_sp--; \
    }while (0)

//字操作，结果保存在栈中，栈指针减一
#define OP_BIN_WORD(x)  do {\
        (finsh_sp - 2)->short_value = (finsh_sp - 2)->short_value x (finsh_sp - 1)->short_value; \
        finsh_sp--; \
    }while (0)

//双字操作，结果保存在栈中，栈指针减一
#define OP_BIN_DWORD(x)  do {\
        (finsh_sp - 2)->long_value = (finsh_sp - 2)->long_value x (finsh_sp - 1)->long_value; \
        finsh_sp--; \
    }while (0)

//空操作
/* --- noop --- */
void OP_no_op()
{
    /* none */
    return ;
}

//加
/* --- add --- */
void OP_add_byte()
{
    OP_BIN_BYTE(+);

    return ;
}

void OP_add_word()
{
    OP_BIN_WORD(+);

    return ;
}

void OP_add_dword()
{
    OP_BIN_DWORD(+);

    return ;
}

//减
/* --- sub --- */
void OP_sub_byte()
{
    OP_BIN_BYTE(-);

    return ;
}

void OP_sub_word()
{
    OP_BIN_WORD(-);

    return ;
}

void OP_sub_dword()
{
    OP_BIN_DWORD(-);

    return ;
}

//除
/* --- div --- */
void OP_div_byte()
{
    OP_BIN_BYTE(/);

    return ;
}

void OP_div_word()
{
    OP_BIN_WORD(/);

    return ;
}

void OP_div_dword()
{
    OP_BIN_DWORD(/);

    return ;
}

//求余
/* --- mod --- */
void OP_mod_byte()
{
    OP_BIN_BYTE(%);

    return ;
}

void OP_mod_word()
{
    OP_BIN_WORD(%);

    return ;
}

void OP_mod_dword()
{
    OP_BIN_DWORD(%);

    return ;
}

//乘
/* --- mul --- */
void OP_mul_byte()
{
    OP_BIN_BYTE(*);

    return ;
}

void OP_mul_word()
{
    OP_BIN_WORD(*);

    return ;
}

void OP_mul_dword()
{
    OP_BIN_DWORD(*);

    return ;
}

//与
/* --- and --- */
void OP_and_byte()
{
    OP_BIN_BYTE(&);

    return ;
}

void OP_and_word()
{
    OP_BIN_WORD(&);

    return ;
}

void OP_and_dword()
{
    OP_BIN_DWORD(&);

    return ;
}

//或
/* --- or --- */
void OP_or_byte()
{
    OP_BIN_BYTE(|);

    return ;
}

void OP_or_word()
{
    OP_BIN_WORD(|);

    return ;
}

void OP_or_dword()
{
    OP_BIN_DWORD(|);

    return ;
}

//抑或
/* --- xor --- */
void OP_xor_byte()
{
    OP_BIN_BYTE(^);

    return ;
}

void OP_xor_word()
{
    OP_BIN_WORD(^);

    return ;
}

void OP_xor_dword()
{
    OP_BIN_DWORD(^);

    return ;
}

//取反
/* --- bw --- */
void OP_bw_byte()
{
    (finsh_sp - 1)->char_value = ~ ((finsh_sp - 1)->char_value);

    return ;
}

void OP_bw_word()
{
    (finsh_sp - 1)->short_value = ~ ((finsh_sp - 1)->short_value);

    return ;
}

void OP_bw_dword()
{
    (finsh_sp - 1)->long_value = ~ ((finsh_sp - 1)->long_value);

    return ;
}

//左移
/* --- shl --- */
void OP_shl_byte()
{
    OP_BIN_BYTE(<<);

    return ;
}

void OP_shl_word()
{
    OP_BIN_WORD(<<);

    return ;
}

void OP_shl_dword()
{
    OP_BIN_DWORD(<<);

    return ;
}

//右移
/* --- shr --- */
void OP_shr_byte()
{
    OP_BIN_BYTE(>>);

    return ;
}

void OP_shr_word()
{
    OP_BIN_WORD(>>);

    return ;
}

void OP_shr_dword()
{
    OP_BIN_DWORD(>>);

    return ;
}

//入栈
/* --- ld --- */
void OP_ld_byte()
{
    finsh_sp->char_value = *finsh_pc;

    finsh_sp++;
    finsh_pc++;

    return ;
}

void OP_ld_word()
{
    finsh_sp->short_value = FINSH_GET16(finsh_pc);

    finsh_sp ++;
    finsh_pc += 2;

    return ;
}

void OP_ld_dword()
{
    finsh_sp->long_value = FINSH_GET32(finsh_pc);

    finsh_sp ++;
    finsh_pc += 4;

    return ;
}

void OP_ld_value_byte()
{
    char* c;

    c = (char*) (FINSH_GET32(finsh_pc));

    finsh_sp->char_value = *c;

    finsh_sp ++;
    finsh_pc += 4;

    return;
}

void OP_ld_value_byte_stack()
{
    char* c;

    c = (char *)(finsh_sp - 1)->long_value;
    (finsh_sp - 1)->char_value = *c;

    return;
}

void OP_ld_value_word()
{
    short* s;

    s = (short*) (FINSH_GET32(finsh_pc));

    finsh_sp->short_value = *s;

    finsh_sp ++;
    finsh_pc += 4;

    return;
}

void OP_ld_value_word_stack()
{
    short* s;

    s = (short *)(finsh_sp - 1)->long_value;
    (finsh_sp - 1)->short_value = *s;

    return;
}

void OP_ld_value_dword()
{
    long* l;

    l = (long*) (FINSH_GET32(finsh_pc));

    finsh_sp->long_value = *l;

    finsh_sp ++;
    finsh_pc += 4;

    return;
}

void OP_ld_value_dword_stack()
{
    long* l;

    l = (long *)(finsh_sp - 1)->long_value;
    (finsh_sp - 1)->long_value = *l;

    return;
}

//出栈
/* --- st --- */
/*
 * 2006-4-16 bernard
 * fixed the sp move bug
 */
void OP_st_byte()
{
    *(char*)((finsh_sp - 2)->long_value) = (finsh_sp - 1)->char_value;
    finsh_sp --;

    return ;
}

/*
 * 2006-4-16 bernard
 * fixed the sp move bug
 */
void OP_st_word()
{
    *(short*)((finsh_sp - 2)->long_value) = (finsh_sp - 1)->short_value;
    finsh_sp --;

    return ;
}

/*
 * 2006-4-16 bernard
 * fixed the sp move bug
 */
void OP_st_dword()
{
    *(long*)((finsh_sp - 2)->long_value) = (finsh_sp - 1)->long_value;
    finsh_sp --;

    return ;
}

/* --- pop --- */
void OP_pop()
{
    finsh_sp --;
    return ;
}

/* --- call --- */
void OP_call()
{
    /* the max number of arg*/
    unsigned long parameterv[16];
    unsigned int  parameters, i;

    typedef unsigned long var_t;
    typedef var_t (*op_func)();
    op_func f;
    var_t   r;

    parameters = *finsh_pc ++;

    i = 0; finsh_sp --;
    while (i < parameters)
    {
        parameterv[parameters - 1 - i] = finsh_sp->long_value;
        finsh_sp --;
        i++;
    }

    f = (op_func)(finsh_sp->long_value);
    switch (parameters)
    {
    case 0:
        r = f(0);
        break;

    case 1:
        r = f(parameterv[0]);
        break;

    case 2:
        r = f(parameterv[0], parameterv[1]);
        break;

    case 3:
        r = f(parameterv[0], parameterv[1], parameterv[2]);
        break;

    case 4:
        r = f(parameterv[0], parameterv[1], parameterv[2], parameterv[3]);
        break;

    case 5:
        r = f(parameterv[0], parameterv[1], parameterv[2], parameterv[3],
                parameterv[4]);
        break;

    case 6:
        r = f(parameterv[0], parameterv[1], parameterv[2], parameterv[3],
                parameterv[4], parameterv[5]);
        break;

    case 7:
        r = f(parameterv[0], parameterv[1], parameterv[2], parameterv[3],
                parameterv[4], parameterv[5], parameterv[6]);
        break;

    case 8:
        r = f(parameterv[0], parameterv[1], parameterv[2], parameterv[3],
                parameterv[4], parameterv[5], parameterv[6], parameterv[7]);
        break;

    case 9:
        r = f(parameterv[0], parameterv[1], parameterv[2], parameterv[3],
                parameterv[4], parameterv[5], parameterv[6], parameterv[7],
                parameterv[8]);
        break;

    case 10:
        r = f(parameterv[0], parameterv[1], parameterv[2], parameterv[3],
                parameterv[4], parameterv[5], parameterv[6], parameterv[7],
                parameterv[8], parameterv[9]);
        break;

    case 11:
        r = f(parameterv[0], parameterv[1], parameterv[2], parameterv[3],
                parameterv[4], parameterv[5], parameterv[6], parameterv[7],
                parameterv[8], parameterv[9], parameterv[10]);
        break;

    case 12:
        r = f(parameterv[0], parameterv[1], parameterv[2], parameterv[3],
                parameterv[4], parameterv[5], parameterv[6], parameterv[7],
                parameterv[8], parameterv[9], parameterv[10], parameterv[11]);
        break;

    case 13:
        r = f(parameterv[0], parameterv[1], parameterv[2], parameterv[3],
                parameterv[4], parameterv[5], parameterv[6], parameterv[7],
                parameterv[8], parameterv[9], parameterv[10], parameterv[11],
                parameterv[12]);
        break;

    case 14:
        r = f(parameterv[0], parameterv[1], parameterv[2], parameterv[3],
                parameterv[4], parameterv[5], parameterv[6], parameterv[7],
                parameterv[8], parameterv[9], parameterv[10], parameterv[11],
                parameterv[12], parameterv[13]);
        break;

    case 15:
        r = f(parameterv[0], parameterv[1], parameterv[2], parameterv[3],
                parameterv[4], parameterv[5], parameterv[6], parameterv[7],
                parameterv[8], parameterv[9], parameterv[10], parameterv[11],
                parameterv[12], parameterv[13], parameterv[14]);
        break;

    case 16:
        r = f(parameterv[0], parameterv[1], parameterv[2], parameterv[3],
                parameterv[4], parameterv[5], parameterv[6], parameterv[7],
                parameterv[8], parameterv[9], parameterv[10], parameterv[11],
                parameterv[12], parameterv[13], parameterv[14], parameterv[15]);
        break;

    default:
        r = 0;
        break;
    }

    finsh_sp->long_value = r;
    finsh_sp ++;

    return ;
}

//操作表，注意const修饰符
const op_func op_table[] =
{
    /* 00 */ OP_no_op,
    /* 01 */ OP_add_byte,
    /* 02 */ OP_add_word,
    /* 03 */ OP_add_dword,
    /* 04 */ OP_sub_byte,
    /* 05 */ OP_sub_word,
    /* 06 */ OP_sub_dword,
    /* 07 */ OP_div_byte,
    /* 08 */ OP_div_word,
    /* 09 */ OP_div_dword,
    /* 10 */ OP_mod_byte,
    /* 11 */ OP_mod_word,
    /* 12 */ OP_mod_dword,
    /* 13 */ OP_mul_byte,
    /* 14 */ OP_mul_word,
    /* 15 */ OP_mul_dword,
    /* 16 */ OP_and_byte,
    /* 17 */ OP_and_word,
    /* 18 */ OP_and_dword,
    /* 19 */ OP_or_byte,
    /* 20 */ OP_or_word,
    /* 21 */ OP_or_dword,
    /* 22 */ OP_xor_byte,
    /* 23 */ OP_xor_word,
    /* 24 */ OP_xor_dword,
    /* 25 */ OP_bw_byte,
    /* 26 */ OP_bw_word,
    /* 27 */ OP_bw_dword,
    /* 28 */ OP_shl_byte,
    /* 29 */ OP_shl_word,
    /* 30 */ OP_shl_dword,
    /* 31 */ OP_shr_byte,
    /* 32 */ OP_shr_word,
    /* 33 */ OP_shr_dword,
    /* 34 */ OP_ld_byte,
    /* 35 */ OP_ld_word,
    /* 36 */ OP_ld_dword,
    /* 37 */ OP_ld_value_byte,
    /* 38 */ OP_ld_value_word,
    /* 39 */ OP_ld_value_dword,
    /* 40 */ OP_st_byte,
    /* 41 */ OP_st_word,
    /* 42 */ OP_st_dword,
    /* 43 */ OP_pop,
    /* 44 */ OP_call,
    /* 45 */ OP_ld_value_byte_stack,
    /* 46 */ OP_ld_value_word_stack,
    /* 47 */ OP_ld_value_dword_stack,
    NULL
};