fork download 
  1. /*
  2. 	expr --> ( expr ) | expr op expr | number
  3. 	op --> + | - | * | /
  4. 	number --> integer
  5. 	integer --> integer digit | digit
  6. 	digit --> 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
  7. */
  8. #include <stdio.h>
  9. #include <stdlib.h>
  10. #include <string.h>
  11. #include <math.h>
  12.  
  13. #define SUCC 0
  14. #define FAIL 1
  15. #define YES 0
  16. #define NO 1
  17. #define EMPTY -1
  18. #define STACK_LIMIT 80
  19.  
  20. typedef union data { char op; double value; } DATA;
  21.  
  22. typedef struct stack {
  23. 	int type;								/* 0: operator, 1: data */
  24. 	DATA data;
  25. 	int priority; } STACK_DATA;
  26.  
  27. struct stack STACK[STACK_LIMIT];
  28. int STACK_TOP = EMPTY;
  29.  
  30. char expr[80];
  31. int i = 0;
  32.  
  33.  
  34. void push( STACK_DATA data )
  35.  
  36. {
  37.   if ( STACK_TOP < STACK_LIMIT - 1 )
  38.     STACK[++STACK_TOP] = data;
  39.   else
  40.   {
  41.     printf( "\nStack Overflow!!\n" );
  42.     exit( 1 );
  43.   }
  44. }
  45.  
  46. STACK_DATA pop( void )
  47.  
  48. {
  49.   if ( STACK_TOP != EMPTY )
  50.     return( STACK[STACK_TOP--] );
  51.   else
  52.   {
  53.     printf( "\nStack Underflow!!\n" );
  54.     exit( 1 );
  55.   }
  56. }
  57.  
  58. int number( void )
  59.  
  60. {
  61. 	STACK_DATA data;
  62. 	int k = 0, mantissa = NO;
  63. 	char value[80];
  64.  
  65. 	while ( expr[i] >= '0' && expr[i] <= '9' )		/* integer */
  66. 	{
  67. 		mantissa = YES;
  68. 		value[k++] = expr[i++];
  69. 	}
  70.  
  71. 	value[k] = '\0';
  72.  
  73. 	data.type = 1;
  74. 	data.data.value = atof( value );
  75. 	data.priority = 0;
  76. 	push( data );
  77.  
  78. 	return( SUCC );
  79. }
  80.  
  81. int evaluate( void )
  82.  
  83. {
  84. 	STACK_DATA data, data1, data2, opcode;
  85.  
  86. 	if ( STACK_TOP == EMPTY )
  87. 		return( FAIL );
  88. 	data1 = pop();
  89. 	if ( data1.type != 1 )
  90. 		return( FAIL );				/* not an operand */
  91.  
  92. 	if ( STACK_TOP == EMPTY )
  93. 		return( FAIL );
  94. 	opcode = pop();
  95. 	if ( opcode.type != 0 )
  96. 		return( FAIL );				/* not an operator */
  97.  
  98. 	if ( STACK_TOP == EMPTY )
  99. 		return( FAIL );
  100. 	data2 = pop();
  101. 	if ( data2.type != 1 )
  102. 		return( FAIL );				/* not an operand */
  103.  
  104. 	switch( opcode.data.op )
  105. 	{
  106. 		case '+' : data.data.value = data2.data.value + data1.data.value;
  107. 			break;
  108. 		case '-' : data.data.value = data2.data.value - data1.data.value;
  109. 			break;
  110. 		case '*' : data.data.value = data2.data.value * data1.data.value;
  111. 			break;
  112. 		case '/' : data.data.value = data2.data.value / data1.data.value;
  113. 			break;
  114. 		default: return( FAIL );
  115. 			break;
  116. 	}
  117.  
  118. 	data.type = 1;
  119. 	data.priority = 0;
  120. 	push( data );
  121.  
  122. 	return( SUCC );
  123. }
  124.  
  125. int right_parenthesis( void )
  126.  
  127. {
  128. 	STACK_DATA data;
  129.  
  130. 	while ( STACK_TOP != EMPTY )
  131. 	{
  132. 		if ( STACK_TOP-1 != EMPTY && STACK[STACK_TOP-1].data.op == '(' )
  133. 		{
  134. 			i++;
  135. 			data = pop();						
  136. 			pop();								/* remove left parenthesis */
  137. 			push( data );
  138. 			return( SUCC );
  139. 		}
  140. 		else if ( evaluate() == FAIL )
  141. 			return( FAIL );
  142. 	}
  143.  
  144. 	return( FAIL );
  145. }
  146.  
  147. int parenthesis( void )
  148. {
  149. 	STACK_DATA data;
  150.  
  151. 	data.type = 0;
  152. 	data.data.op = expr[i++];
  153. 	data.priority = 0;						/* left_parenthesis */
  154. 	push( data );	
  155.  
  156. 	return( SUCC );
  157. }
  158.  
  159. int op( void )
  160. {
  161. 	STACK_DATA data;
  162.  
  163. 	switch ( expr[i] )
  164. 	{
  165. 		case '+' :
  166. 		case '-' : data.priority = 1;
  167. 			break;
  168. 		case '*' :
  169. 		case '/' : data.priority = 2;
  170. 			break;
  171. 		default :
  172. 			return( FAIL );
  173. 	}
  174.  
  175. 	while ( STACK_TOP > 0 && data.priority <= STACK[STACK_TOP-1].priority )
  176. 	{
  177. 		if ( evaluate() == FAIL )
  178. 			return( FAIL );
  179. 	}
  180.  
  181. 	data.type = 0;
  182. 	data.data.op = expr[i++];
  183. 	push( data );
  184.  
  185. 	return( SUCC );
  186. }
  187.  
  188. int expression( void )
  189. {
  190. 	while ( expr[i] == ' ' )				/* skip the leading spaces */
  191. 		i++;
  192.  
  193.     if ( expr[i] == '(' )
  194.  		return( parenthesis() );			/* ( expr) */
  195.  
  196.     if ( expr[i] == '+' || expr[i] == '-' || expr[i] == '*' || expr[i] == '/' )
  197. 		return( op() );						/* expr op expr */
  198.  
  199. 	if ( expr[i] >= '0' && expr[i] <= '9'	)	
  200. 		return( number() );					/* number */
  201.  
  202. 	if ( expr[i] == ')')					/* end of parenthesis */
  203. 		return( right_parenthesis() );
  204.  
  205. 	if ( expr[i] == '\0')					/* end of expression */
  206. 		return( SUCC );
  207. 	else
  208. 		return( FAIL );
  209. }
  210.  
  211. int result( void )
  212.  
  213. {
  214. 	while ( STACK_TOP > 0 )
  215. 	{
  216. 		if ( evaluate() == FAIL )
  217. 			return( FAIL );
  218. 	}
  219.  
  220. 	return( SUCC );
  221. }
  222.  
  223. void calculate( void )
  224. {
  225. 	STACK_DATA data;
  226.  
  227. 	while ( expr[i] != '\0' )
  228. 	{
  229. 		if ( expression() == FAIL )		/* parse the exspression */
  230. 			break;
  231. 	}
  232.  
  233. 	if ( expr[i] == '\0' )	/* end of expression */
  234.     {
  235. 		if ( result() == SUCC && STACK_TOP == 0 )
  236. 		{
  237. 			data = pop();
  238. 			if ( data.type == 1 )
  239. 				printf( "The result is %g\n", data.data.value );
  240. 			else
  241. 				printf( "Error : Illegal expression\n" );
  242.  		}
  243. 		else
  244. 			printf( "Error : Illegal expression\n" );
  245.     }
  246. 	else
  247. 		printf( "Error : Illegal expression\n" );
  248. }
  249.  
  250. void init( void )
  251. {
  252. 	STACK_TOP = EMPTY;   /* clear stack */
  253. 	i = 0;
  254. }
  255.  
  256. int main( void )
  257. {
  258. 	char ch;
  259.  
  260. 	do
  261. 	{
  262. 		init();				/* initialize */
  263.  
  264. 		printf( "Please keyin expression to be evaluated \n" );
  265. 		fflush( stdin );
  266. 		gets( expr );
  267.  
  268. 		calculate();
  269.  
  270. 		printf( "Continue (y/n) ? " );
  271. 		ch = getchar();
  272. 	} while( !( ch == 'n' || ch == 'N' ) );
  273.  
  274. 	return( 0 );
  275. }
Compilation error #stdin compilation error #stdout 0s 0KB
comments (?)
stdin 
Standard input is empty
compilation info 
prog.cpp: In function ‘int main()’:
prog.cpp:266:14: error: ‘gets’ was not declared in this scope
   gets( expr );
              ^
stdout 
Standard output is empty
https://ideone.com/EiR1uC
language:
C++ (gcc 8.3)
created:
6 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!