C语言之为表达式计算器实现定义变量和使用变量功能

• 上一篇实现了基本表达式的加减乘除和括号运算功能
• 这一次的目标是实现定义变量和使用变量功能
• 增加分号做为分隔符和结束符！！！
• 变量名为大小字母组合，长度不能超过7个字母！！！
• 定义变量格式： a = 9;
• 使用变量格式： a + 100;

重新定义数据类型

• 将原来的enum定义去掉！！！

/* define express datatype */
typedef enum _ExpressDataType ExprDT;
enum _ExpressDataType {
  DT_OPERATOR,
  DT_INTEGER,
};

• 直按改为宏定义！！！

/* define express node data type */
#define DT_OPERATOR 0X01
#define DT_INTEGER  0X02
#define DT_VARIABLE 0X03

将表达式结构体定义修改一下

• 增加成员字符数组name，做为保存变量名的空间！！！
• 将dt改为字符型，只占1个字节，name占7个字节，做到8字节对齐！！！

/* define express struct */
typedef struct _Express Expr;
struct _Express {
  char name[7]; //variable name
  char dt; //datatype
  union {
    char oval; //operator
    long ival; //integer
  } V;
};

修改输出信息函数

• 加入输出变量名信息，代码如下：

/* output express value */
void
out_value (Expr expr)
{
  switch (expr.dt)
    {
    case DT_OPERATOR: printf (" %c",  expr.V.oval); break;
    case DT_INTEGER : printf (" %ld", expr.V.ival); break;
    case DT_VARIABLE: printf (" %s",  expr.name);   break;
    }
}

/* output express info */
void
out_info (Expr expr)
{
  switch (expr.dt)
    {
    case DT_OPERATOR: printf (" op : %c\n",  expr.V.oval); break;
    case DT_INTEGER : printf ("int : %ld\n", expr.V.ival); break;
    case DT_VARIABLE: printf ("var : %s\n",  expr.name);   break;
    }
}

提前准备

• 将转换函数mid_torpn和计算函数compute_rpn_express的定义提前，以便parse_string函数来调用！！！

/* declare here !!! */
/* middle expr to rpn expr */
int
mid_torpn (Expr *expr, Expr *rpn, int elen);

/* compute rpn express */
Expr
compute_rpn_express (Expr *expr, int rlen);

• 定义get_value函数，根据变量名获取变量值
• 第一个参数vtab为变量表的指针
• 第二个参数vlen为变量表的长度
• 第三个参数name为变量名

/* get value by variable name */
Expr
get_value (Expr *vtab, int vlen, char *name)
{
  Expr rs = {0, 0, 0};
  for (int k = 0; k < vlen; k++)
    {
      if (0 == strcmp (name, vtab[k].name))
	{
	  rs = vtab[k]; break;
	}
    }
  return rs;
}

重新定义parse_string函数

• parse_string函数定义如下：
• 第一个参数estr为表达式字符串指针
• 第二个参数expr为表达式结构数组
• 第三个参数elen为表达式结构数组的长度
• 第四个参数vtab为变量表结构数组
• 第五个参数vlen为保存变量数量的整型指针

/* parse express string to Expr struct array */
int
parse_string (char *estr,  //express string
	      Expr *expr,  //express struct array
	      int elen,    //express struct array length
	      Expr *vtab,  //variable struct array
	      int *vlen)   //how many variable struct in array

• parse_string函数内部变量定义如下：

• idx 表达式字符串索引，每读一个字符自增一

• ep 表达式结构数组索引，每保存一个Expr自增一

• nbuf 保存数字，长度为32

• ndx nbuf的索引，每保存一个数字自增一

• vbuf 保存变量名，长度为8

• vdx vbuf的索引，每保存一个字母自增一，长度超过7则显示出错信息并退出运行！！！

• aflag 赋值标志，发现等号后设置

• vflag 变量标志，发现字母后设置

处理字母和等号

• 大小写字母 A-Za-z 长度小于等于7，超出则出错退出！！！
• 遇到等号’='，将字符串保存到变量表中去，同时清空vbuf，vdx置0，aflag置0！

代码如下：

	case 'A'...'Z':
	case 'a'...'z': //letter
	  {
	    vbuf[vdx] = c; vdx++; vflag = 1;
	    if (vdx == 8)
	      {
		printf ("Error: Variable name length bigger than 7!\n");
		exit (0);
	      }
	  }
	  break;

	case '=': //assignment
	  vtab[*vlen].dt = DT_VARIABLE;
	  for (int i = 0; i < 7; i++)
	    vtab[*vlen].name[i] = vbuf[i];
	  memset (vbuf, 0, 7); vdx = 0; aflag = 1; vflag = 0;
	  break;

处理数字

• 保存数字至表达式结构数组

代码如下：

	case '0'...'9': //number
	  {
	    char n = estr[idx+1];
	    nbuf[ndx] = c; ndx++;
	    if (n == ' ' || n == ')' || n == ';' || n == '\0'|| //number end
		n == '+' || n == '-' || n == '*' || n == '/') //operator
	      {
		long lt = strtol (nbuf, NULL, 10);
		memset (nbuf, 0, 32); nbuf[0] = '+'; ndx = 1;
		expr[ep].dt = DT_INTEGER;
		expr[ep].V.ival = lt; ep++;
	      }
	  }
	  break;

处理分隔符（分号）

• 当vflag置1时，根据变量名取变量值，保存到表达式结构数组！
• 当aflag置1时，运算表达式，将结果赋值给变量！

代码如下：

	case ';': //semicolon, Separator
	  {
	    if (vflag == 1)
	      {
		Expr vs = get_value (vtab, *vlen, vbuf);
		//printf ("GOT Variable [%s] : [%ld]\n", vbuf, vs.V.ival);
		expr[ep].V.ival = vs.V.ival;
		expr[ep].dt = DT_INTEGER; ep++;
		memset (vbuf, 0, 7); vdx = 0; vflag = 0;
	      }

	    if (aflag == 1) //compute express
	      {
		int len = ep, rlen;
		Expr rs;
		Expr rpn[128];

		//if (ep == 0) return 0; //do nothing
		rlen = mid_torpn (expr, rpn, ep); //len);
		printf ("--------------------\n");
		rs = compute_rpn_express (rpn, rlen);
		printf ("--------------------\n");
		printf ("Result : [%ld]\n", rs.V.ival);

		vtab[*vlen].V.ival = rs.V.ival;
		printf ("Variable name : [%s], value : [%ld]\n",
			vtab[*vlen].name, vtab[*vlen].V.ival);

		*vlen = *vlen + 1;
		return 0;
	      }
	  }
	  break;

处理运算符加减乘除括号

• 处理数字的符号，也就是负号问题！
• 如果vflag置1，查找变量表，将变量的值存入表达式！
• 保存运算符至表达式结构数组！

代码如下：

	case '+': case '-': case '*': case '/':	case '(': case ')': //operator
	  {
	    if (c == '-') //negative number
	      {
		char n = estr[idx+1];
		if (n >= '0' && n <= '9')
		  {
		    printf ("Info : negative number!\n");
		    nbuf[0] = c; break;
		  }
	      }

	    if (vflag == 1)
	      {
		Expr vs = get_value (vtab, *vlen, vbuf);
		//printf ("GOT Variable [%s] : [%ld]\n", vbuf, vs.V.ival);
		expr[ep].V.ival = vs.V.ival;
		expr[ep].dt = DT_INTEGER; ep++;
		memset (vbuf, 0, 7); vdx = 0; vflag = 0;
	      }

	    //printf ("save a operator : %c\n", c); //save op
	    expr[ep].dt = DT_OPERATOR;
	    expr[ep].V.oval = c; ep++;
	  }
	  break;

交互运算表达式循环

• 定义表达式字符串es，用来保存从标准输入的字符，定义变量idx为索引
• 定义表达式结构数组expr，用来保存表达式
• 定义RPN表达式结构数组rpn，用来保存RPN表达式
• 定义变量表达式结构数组vart，用来保存变量
• 定义相关的长度整型变量：
• len，从字符串解析得到的表达式的长度
• rlen，转换为RPN表达式后，RPN表达式的长度
• vlen，变量表的长度
• 定义返回结果变量rs
• 如果是变量定义，如：a=9;，则parse_string函数返回值为0，说明无表达式，只有变量定义！！！

代码如下：

/* evalute express */
void
eval_express (void)
{
  char es[1024] = {0}; //save string from stdin
  Expr expr[128]; //save express parse from string
  Expr rpn[128];  //save rpn express from express
  Expr vart[128]; //save variable express parse from string
  Expr rs;        //the result
  int idx = 0;    //index of es
  int len = 0;    //length of express parse from string
  int rlen = 0;   //rpn express length from express
  int vlen = 0;   //variable express length parse from string
  char c;

  printf ("EXPR:> ");
  c = fgetc (stdin);
  while (c != EOF)
    {
      if (c == '\n')
	{
	  len  = parse_string (es, expr, 128, vart, &vlen);
	  if (len == 0)
	    {
	      //get a variable declare express
	      memset (es, 0, 1024); len = 0; rlen = 0; idx = 0;
	      printf ("EXPR:> ");
	      c = fgetc (stdin);
	    }
	  else
	    {
	      rlen = mid_torpn (expr, rpn, len);
	      printf ("------------------------------\n");
	      for (int i = 0; i < rlen; i++)
		out_value (rpn[i]);
	      printf ("\n------------------------------\n");
	      rs = compute_rpn_express (rpn, rlen);
	      printf ("------------------------------\n");
	      printf (" Result : %ld\n", rs.V.ival);
	      memset (es, 0, 1024);
	      len = 0; rlen = 0; idx = 0;
	      printf ("EXPR:> ");
	      c = fgetc (stdin);
	    }
	}
      else
	{
	  es[idx] = c;
	  idx++; c = fgetc (stdin);
	}
    }
}

测试表达式

常规表达式

• 100+200-300; 100*200/400;
• 10+2030-50; (10+20)(50-30);
• (10+(30-20))50; 10+2030/40;

编译运行，达到预期，效果如下：

songvm@ubuntu:~/works/tmpc/boo$ gcc -g pt.c -o pt
songvm@ubuntu:~/works/tmpc/boo$ ./pt
EXPR:> 100+200-300;
------------------------------
 100 200 + 300 -
------------------------------
push 100
push 200
operate : 100 + 200 = 300
push 300
operate : 300 - 300 = 0
------------------------------
 Result : 0
EXPR:> 100*200/400;
------------------------------
 100 200 * 400 /
------------------------------
push 100
push 200
operate : 100 * 200 = 20000
push 400
operate : 20000 / 400 = 50
------------------------------
 Result : 50
EXPR:> 10+20*30-50;
------------------------------
 10 20 30 * + 50 -
------------------------------
push 10
push 20
push 30
operate : 20 * 30 = 600
operate : 10 + 600 = 610
push 50
operate : 610 - 50 = 560
------------------------------
 Result : 560
EXPR:> (10+20)*(50-30);
------------------------------
 10 20 + 50 30 - *
------------------------------
push 10
push 20
operate : 10 + 20 = 30
push 50
push 30
operate : 50 - 30 = 20
operate : 30 * 20 = 600
------------------------------
 Result : 600
EXPR:> (10+(30-20))*50;
------------------------------
 10 30 20 - + 50 *
------------------------------
push 10
push 30
push 20
operate : 30 - 20 = 10
operate : 10 + 10 = 20
push 50
operate : 20 * 50 = 1000
------------------------------
 Result : 1000
EXPR:> 10+20*30/40;
------------------------------
 10 20 30 * 40 / +
------------------------------
push 10
push 20
push 30
operate : 20 * 30 = 600
push 40
operate : 600 / 40 = 15
operate : 10 + 15 = 25
------------------------------
 Result : 25
EXPR:> 

变量表达式

• 变量简单赋值：a = 100;
• 变量表达式赋值：b = 9 + 10;
• 变量赋值变量：c = a + b;
• 变量赋值变量表达式：d = c - a + b;

编译运行，基本达到预期，效果如下：

songvm@ubuntu:~/works/tmpc/boo$ gcc -g pt.c -o pt
songvm@ubuntu:~/works/tmpc/boo$ ./pt
EXPR:> a = 100;
--------------------
push 100
--------------------
Result : [100]
Variable name : [a], value : [100]
EXPR:> b = 9 + 10;
--------------------
push 9
push 10
operate : 9 + 10 = 19
--------------------
Result : [19]
Variable name : [b], value : [19]
EXPR:> c = a + b;
--------------------
push 100
push 19
operate : 100 + 19 = 119
--------------------
Result : [119]
Variable name : [c], value : [119]
EXPR:> d = c - a + b;
--------------------
push 119
push 100
operate : 119 - 100 = 19
push 19
operate : 19 + 19 = 38
--------------------
Result : [38]
Variable name : [d], value : [38]
EXPR:> a * a - c + d;
------------------------------
 100 100 * 119 - 38 +
------------------------------
push 100
push 100
operate : 100 * 100 = 10000
push 119
operate : 10000 - 119 = 9881
push 38
operate : 9881 + 38 = 9919
------------------------------
 Result : 9919
EXPR:> 

完整源码如下：

/* filename: pt.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* compile : gcc pt.c -o pt */
/*     run : ./pt           */

/* define express node data type */
#define DT_OPERATOR 0X01
#define DT_INTEGER  0X02
#define DT_VARIABLE 0X03

/* define express struct */
typedef struct _Express Expr;
struct _Express {
  char name[7]; //variable name
  char dt; //express datatype
  union {
    char oval; //operator
    long ival; //integer
  } V;
};

/* output express value */
void
out_value (Expr expr)
{
  switch (expr.dt)
    {
    case DT_OPERATOR: printf (" %c",  expr.V.oval); break;
    case DT_INTEGER : printf (" %ld", expr.V.ival); break;
    case DT_VARIABLE: printf (" %s",  expr.name);   break;
    }
}

/* output express info */
void
out_info (Expr expr)
{
  switch (expr.dt)
    {
    case DT_OPERATOR: printf (" op : %c\n",  expr.V.oval); break;
    case DT_INTEGER : printf ("int : %ld\n", expr.V.ival); break;
    case DT_VARIABLE: printf ("var : %s\n",  expr.name);   break;
    }
}

/* declare here !!! */
/* middle expr to rpn expr */
int
mid_torpn (Expr *expr, Expr *rpn, int elen);

/* compute rpn express */
Expr
compute_rpn_express (Expr *expr, int rlen);

/* get value by variable name */
Expr
get_value (Expr *vtab, int vlen, char *name)
{
  Expr rs = {0, 0, 0};
  for (int k = 0; k < vlen; k++)
    {
      if (0 == strcmp (name, vtab[k].name))
	{
	  rs = vtab[k]; break;
	}
    }
  return rs;
}

/* parse express string to Expr struct array */
int
parse_string (char *estr,  //express string
	      Expr *expr,  //express struct array
	      int elen,    //express struct array length
	      Expr *vtab,  //variable struct array
	      int *vlen)   //how many variable struct in array
{
  char nbuf[32] = {0}; //save number
  int  ndx = 1;        //number index
  int  idx = 0;        //express string index
  int  ep = 0;         //expr pointer
  char vbuf[8] = {0};  //save variable name
  int  vdx = 0;        //variable name index
  int  aflag = 0, vflag = 0; //assignment flag, variable flag
  char c;

  nbuf[0] = '+';
  c = estr[idx];
  while (c != 0)
    {
      switch (c)
	{
	case 'A'...'Z':
	case 'a'...'z': //letter
	  {
	    vbuf[vdx] = c; vdx++; vflag = 1;
	    if (vdx == 8)
	      {
		printf ("Error: Variable name length bigger than 7!\n");
		exit (0);
	      }
	  }
	  break;

	case '=': //assignment
	  vtab[*vlen].dt = DT_VARIABLE;
	  for (int i = 0; i < 7; i++)
	    vtab[*vlen].name[i] = vbuf[i];
	  memset (vbuf, 0, 7); vdx = 0; aflag = 1; vflag = 0;
	  break;

	case ';': //semicolon, Separator
	  {
	    if (vflag == 1)
	      {
		Expr vs = get_value (vtab, *vlen, vbuf);
		//printf ("GOT Variable [%s] : [%ld]\n", vbuf, vs.V.ival);
		expr[ep].V.ival = vs.V.ival;
		expr[ep].dt = DT_INTEGER; ep++;
		memset (vbuf, 0, 7); vdx = 0; vflag = 0;
	      }

	    if (aflag == 1) //compute express
	      {
		int len = ep, rlen;
		Expr rs;
		Expr rpn[128];

		//if (ep == 0) return 0; //do nothing
		rlen = mid_torpn (expr, rpn, ep); //len);
		printf ("--------------------\n");
		rs = compute_rpn_express (rpn, rlen);
		printf ("--------------------\n");
		printf ("Result : [%ld]\n", rs.V.ival);

		vtab[*vlen].V.ival = rs.V.ival;
		printf ("Variable name : [%s], value : [%ld]\n",
			vtab[*vlen].name, vtab[*vlen].V.ival);

		*vlen = *vlen + 1;
		return 0;
	      }
	  }
	  break;

	case '0'...'9': //number
	  {
	    char n = estr[idx+1];
	    nbuf[ndx] = c; ndx++;
	    if (n == ' ' || n == ')' || n == ';' || n == '\0'|| //number end
		n == '+' || n == '-' || n == '*' || n == '/') //operator
	      {
		long lt = strtol (nbuf, NULL, 10);
		memset (nbuf, 0, 32); nbuf[0] = '+'; ndx = 1;
		expr[ep].dt = DT_INTEGER;
		expr[ep].V.ival = lt; ep++;
	      }
	  }
	  break;

	case '+': case '-': case '*': case '/':	case '(': case ')': //operator
	  {
	    if (c == '-') //negative number
	      {
		char n = estr[idx+1];
		if (n >= '0' && n <= '9')
		  {
		    printf ("Info : negative number!\n");
		    nbuf[0] = c; break;
		  }
	      }

	    if (vflag == 1)
	      {
		Expr vs = get_value (vtab, *vlen, vbuf);
		//printf ("GOT Variable [%s] : [%ld]\n", vbuf, vs.V.ival);
		expr[ep].V.ival = vs.V.ival;
		expr[ep].dt = DT_INTEGER; ep++;
		memset (vbuf, 0, 7); vdx = 0; vflag = 0;
	      }

	    //printf ("save a operator : %c\n", c); //save op
	    expr[ep].dt = DT_OPERATOR;
	    expr[ep].V.oval = c; ep++;
	  }
	  break;

	case ' ': //space do nothing
	  break;

	default:
	  printf ("Error: Syntax error!\n");
	  exit (0);
	}

      idx++; c = estr[idx]; //next char
    }

  return ep;
}

/* get priority level */
static char
get_plv (char x)
{
  if (x == '+') return 1;
  if (x == '-') return 1;
  if (x == '*') return 2;
  if (x == '/') return 2;
  return 0;
}

/* middle expr to rpn expr */
int
mid_torpn (Expr *expr, Expr *rpn, int elen)
{
  Expr st[8];
  int idx = 0, ip = 0;

  for (int j = 0; j < 8; j++)
    { st[j].dt = 0; st[j].V.oval = 0; }

  for (int i = 0; i < elen; i++)
    {
      Expr et = expr[i];
      switch (et.dt)
	{
	case DT_INTEGER: //number
	  rpn[idx].dt = DT_INTEGER;
	  rpn[idx].V.ival = et.V.ival; idx++;
	  break;

	case DT_OPERATOR: //operator
	  {
	    switch (et.V.oval)
	      {
	      case '+': case '-': case '*': case '/': //operator
		{
		  char lv, lx;
		  if (ip == 0) //stack empty
		    {
		      st[ip].dt = DT_OPERATOR;
		      st[ip].V.oval = et.V.oval; ip++; //push
		      break;
		    }
		  if (st[ip-1].dt == DT_OPERATOR && st[ip-1].V.oval == '(')
		    {
		      st[ip].dt = DT_OPERATOR;
		      st[ip].V.oval = et.V.oval; ip++; //push
		      break;
		    }
		  lv = get_plv (et.V.oval);
		  lx = get_plv (st[ip-1].V.oval);
		  if (lv > lx)
		    {
		      st[ip].dt = DT_OPERATOR;
		      st[ip].V.oval = et.V.oval; ip++; //push
		      break;
		    }
		  else
		    {
		      rpn[idx].dt = DT_OPERATOR;
		      rpn[idx].V.oval = st[ip-1].V.oval; idx++; //out
		      st[ip-1].dt = 0; st[ip-1].V.oval = 0; ip--; //pop
		      while (ip > 0)
			{
			  char lt = get_plv (st[ip-1].V.oval);
			  if (lv > lt)
			    {
			      st[ip].dt = DT_OPERATOR;
			      st[ip].V.oval = et.V.oval; ip++; //push
			      break;
			    }
			  else
			    {
			      rpn[idx].dt = DT_OPERATOR;
			      rpn[idx].V.oval = st[ip-1].V.oval; idx++; //out
			      st[ip-1].dt = 0; st[ip-1].V.oval = 0; ip--; //pop
			    }
			}
		      if (ip == 0)
			{
			  st[ip].dt = DT_OPERATOR;
			  st[ip].V.oval = et.V.oval; ip++; //push
			}
		    }
		}
		break;

	      case '(':
		st[ip].dt = DT_OPERATOR;
		st[ip].V.oval = et.V.oval; ip++; //push
		break;

	      case ')':
		{
		  while (ip > 0)
		    {
		      char ot = st[ip-1].V.oval;
		      if (ot == '(')
			{
			  st[ip-1].dt = 0; st[ip-1].V.oval = 0; ip--; //pop
			  break;
			}
		      else
			{
			  rpn[idx].dt = DT_OPERATOR;
			  rpn[idx].V.oval = st[ip-1].V.oval; idx++; //out
			  st[ip-1].dt = 0; st[ip-1].V.oval = 0; ip--; //pop
			}
		    }
		}
		break;
	      }
	  }
	  break;
	}
    }

  //pop until stack empty
  while (ip > 0)
    {
      rpn[idx].dt = DT_OPERATOR;
      rpn[idx].V.oval = st[ip-1].V.oval; idx++; //out
      st[ip-1].dt = 0; st[ip-1].V.oval = 0; ip--; //pop
    }

  return idx;
}

/* compute rpn express */
Expr
compute_rpn_express (Expr *expr, int rlen)
{
  Expr st[16], rs;
  int ip = 0;

  for (int j = 0; j < 16; j++)
    { st[j].dt = 0; st[j].V.oval = 0;}

  for (int i = 0; i < rlen; i++)
    {
      Expr et = expr[i];
      if (et.dt == DT_INTEGER)
	{
	  st[ip].dt = DT_INTEGER; st[ip].V.ival = et.V.ival; ip++;
	  printf ("push %ld\n", et.V.ival);
	}
      else if (et.dt == DT_OPERATOR)
	{
	  switch (et.V.oval)
	    {
	    case '+':
	      {
		printf ("operate : %ld + %ld = ",
			st[ip-2].V.ival, st[ip-1].V.ival);
		st[ip-2].V.ival = st[ip-2].V.ival + st[ip-1].V.ival;
		printf ("%ld\n", st[ip-2].V.ival);
		st[ip-1].V.oval = 0; ip--;
	      }
	      break;

	    case '-':
	      {
		printf ("operate : %ld - %ld = ",
			st[ip-2].V.ival, st[ip-1].V.ival);
		st[ip-2].V.ival = st[ip-2].V.ival - st[ip-1].V.ival;
		printf ("%ld\n", st[ip-2].V.ival);
		st[ip-1].V.ival = 0; ip--;
	      }
	      break;

	    case '*':
	      {
		printf ("operate : %ld * %ld = ",
			st[ip-2].V.ival, st[ip-1].V.ival);
		st[ip-2].V.ival = st[ip-2].V.ival * st[ip-1].V.ival;
		printf ("%ld\n", st[ip-2].V.ival);
		st[ip-1].V.ival = 0; ip--;
	      }
	      break;

	    case '/':
	      {
		printf ("operate : %ld / %ld = ",
			st[ip-2].V.ival, st[ip-1].V.ival);
		st[ip-2].V.ival = st[ip-2].V.ival / st[ip-1].V.ival;
		printf ("%ld\n", st[ip-2].V.ival);
		st[ip-1].V.ival = 0; ip--;
	      }
	      break;
	    }
	}
    }

  rs.dt = DT_INTEGER;
  rs.V.ival = st[0].V.ival;
  return rs;
}

/* evalute express */
void
eval_express (void)
{
  char es[1024] = {0}; //save string from stdin
  Expr expr[128]; //save express parse from string
  Expr rpn[128];  //save rpn express from express
  Expr vart[128]; //save variable express parse from string
  Expr rs;        //the result
  int idx = 0;    //index of es
  int len = 0;    //length of express parse from string
  int rlen = 0;   //rpn express length from express
  int vlen = 0;   //variable express length parse from string
  char c;

  printf ("EXPR:> ");
  c = fgetc (stdin);
  while (c != EOF)
    {
      if (c == '\n')
	{
	  len  = parse_string (es, expr, 128, vart, &vlen);
	  if (len == 0)
	    {
	      //get a variable declare express
	      memset (es, 0, 1024); len = 0; rlen = 0; idx = 0;
	      printf ("EXPR:> ");
	      c = fgetc (stdin);
	    }
	  else
	    {
	      rlen = mid_torpn (expr, rpn, len);
	      printf ("------------------------------\n");
	      for (int i = 0; i < rlen; i++)
		out_value (rpn[i]);
	      printf ("\n------------------------------\n");
	      rs = compute_rpn_express (rpn, rlen);
	      printf ("------------------------------\n");
	      printf (" Result : %ld\n", rs.V.ival);
	      memset (es, 0, 1024);
	      len = 0; rlen = 0; idx = 0;
	      printf ("EXPR:> ");
	      c = fgetc (stdin);
	    }
	}
      else
	{
	  es[idx] = c;
	  idx++; c = fgetc (stdin);
	}
    }
}

/**/
int
main (int argc, char *argv[])
{
  eval_express ();
  //printf ("Sizeof Expr : %lu\n", sizeof(Expr));
  return 0;
}
//-----(+-*/)-----//

• 测试虽然通过，感觉还不够充分，盼网友测试回复！
• 下一步研究给表达式加个调用函数功能！！！