简易功能计算器0.1版本(基于双栈)

　　　　　　　　　　　　　　　　　　　　Lisa

          这个傲娇的计算器叫Lisa。

/*********************************************************
Code writer : EOF
Code file   : stack.h
Code date   : 2014.11.26
Email	    : jasonleaster@gmail.com

Code description:
	
	Here is a implementation of a naive computer
It based on two stack scheme which was found by Dijkstra.

*********************************************************/
#ifndef _STACK_H  
#define _STACK_H 1  
  
	#define EMPTY     0  
	#define NON_EMPTY 1  
	  
	#define ARRAYSIZE 1024

	#include <stdio.h>
	#include <stdlib.h>
	#include <unistd.h>

	struct node  
	{     
	    int data;  
	    struct node* next;  
	};  
	  
	int computer(void);

	struct node* creat_stack(void);
	int push_stack(struct node** pp_top,int number);
	int is_empty(struct node* p_node);
	void release_stack(struct node* p_top);
  
#endif

/*************************************************************
code writer : EOF
Code file   : computer_test.c
code date   : 2014.03.03
e-mail      : jasonleaster@gmail.com

code purpose :
		This is just a test code for "Lisa" that 
I created. If there is something wrong with my code, please
touche me by e-mail.

#ATTENTION#	
	You must input with '(' and ')' for each operator,
otherwise you will be puzzle about the result of output.

Usage:
	(1+2) would output 3
	(1+((2*3)+1))  == 8

If there is something wrong with my code, please touch me by e-mail.

******************************************************************/
#include "stack.h"

int main()
{
	int number = 0;
	printf("Hello ! This is a naive computer."
	       "Her name is 'Lisa' :)\n");

	number = computer();

	printf("The result of your inputed :%d\n",number);

	return 0;
}

/*********************************************************
Code writer : EOF
Code file   : computer.c
Code date   : 2014.11.26
Email	    : jasonleaster@gmail.com
Version	    : 0.0

Code description:

code purpose : 
	This code is my implementation for function creat_stack.
functin creat_stack would creat a the first node of the stack and 
just only the first node. You must know what is stack...

#ATTENTION#	
	You must input with '(' and ')' for each operator,
otherwise you will be puzzle about the result of output.

Usage:
	(1+2) would output 3
	(1+((2*3)+1))  == 8

If there is something wrong with my code, please touch me by e-mail.

*********************************************************/
#include "stack.h"

int computer(void)
{
	char string[ARRAYSIZE] = {0};

	/*
	**	According to Dijsktra's Two Stack scheme,
	** we creat two stack. 
	**	@p_stack_operand is pointer which point to
	** a stack only for operand in the inputed string. 
	** So do @p_stack_operator.
	*/
	struct node* p_stack_operand  = NULL;	
	struct node* p_stack_operator = NULL;	

	p_stack_operand  = creat_stack();
	p_stack_operator = creat_stack();

	int  temp      = 0;
	int  result    = 0;
	int  opr_one   = 0;
	int  opr_two   = 0;
	char operator  = 0;

	/*
	** 	Evil --> --> scanf("%s",&string);
	**
	** scanf family is not safe for string which is inputed.
	** I decide to give it up and use system call read().
	*/

	if(read(STDIN_FILENO,string,ARRAYSIZE) < 0)
	{
		printf("system call read() error"
		       " in function %s()\n",__FUNCTION__);
	}
	
	for(temp = 0;string[temp] != '\n';temp++)
	{
		if(string[temp] == '(')
		{
			continue;
		}

		if(string[temp] == ')')
		{
			opr_one  = pop_stack(p_stack_operand);
			opr_two  = pop_stack(p_stack_operand);

			operator = pop_stack(p_stack_operator);

			switch(operator)
			{
				case '+':
				{
					push_stack(&p_stack_operand,
						   opr_one + opr_two);
					break;
				};
				
				case '-':
				{
					push_stack(&p_stack_operand,
						   opr_one - opr_two);
					break;
				};

				case '*':
				{
					push_stack(&p_stack_operand,
						   opr_one * opr_two);
					break;
				};

				case '/':
				{
					push_stack(&p_stack_operand,
						   opr_one / opr_two);
					break;
				};

				default:
					goto out;
					result = -1;
					printf("ERROR!undefined "
					       "operator %c\n",operator);
	
			}
		}

		if(string[temp] >= '0' && string[temp] <= '9')
		{
			push_stack(&p_stack_operand,string[temp] - '0');
			continue;
		}

		if(string[temp] == '+' || string[temp] == '-'||
		   string[temp] == '*' || string[temp] == '/')
		{
			push_stack(&p_stack_operator,string[temp]);
			continue;
		}
	}
	
	/*
	** Finally, We got the result which is stored in stack--operand
	*/
	result = pop_stack(p_stack_operand);

out:
	release_stack(p_stack_operand);
	release_stack(p_stack_operator);

	return result;
}

/*********************************************************************
code writer : EOF
code date   : 2014.03.03
e-mail 	    : jasonleaster@gmail.com

**********************************************************************/
#include "stack.h"

struct node* creat_stack(void)
{
	struct node* p_top = NULL;

	p_top = (struct node*)malloc(sizeof(struct node));
	
	if(p_top == NULL)
	{
		printf("malloc failed\n");
	}
	
	p_top->next = NULL;

	while(is_empty(p_top) == NON_EMPTY)
	{
		pop_stack(p_top);	
	}
	
	return p_top;
}

/**********************************************************************
code writer: EOF
code date : 2014.03.03
e-mail: jasonleaster@gmail.com
code purpose :
	This code is a implementation for function is_empty
If there is something wrong with my code, please touch me by e-mail.

**********************************************************************/
#include "stack.h"

int is_empty(struct node* p_node)
{
	if(p_node->next == NULL)
	{
		return EMPTY;
	}
	else
	{
		return NON_EMPTY;
	}
}

/*****************************************************************
code writer: EOF
code date: 2014.03.03
e-mail: jasonleaster@gmail.com
code purpose :
	This code is a implementation for function pop_stack
If there is something wrong with my code, please touch me by e-mail

*****************************************************************/
#include "stack.h"

int pop_stack(struct node* p_top)
{
	struct node* temp = NULL;
	
	int number = 0;

	if(is_empty(p_top) == EMPTY)
	{
		printf("empty stack!\nprocess end");
		return EMPTY;
	}
	else
	{
		temp = p_top->next;
		p_top->next = p_top->next->next;
		number = temp->data;
		free(temp);
	}

	return number;
}

/*******************************************************************
code writer : EOF
code date:2014.03.03
e-mail:jasonleaster@gmail.com
code purpose :
	This is my implementaion for function push_stack
If there is somrthing wrong with my code, please touche me by e-mail.

*******************************************************************/
#include "stack.h"

int push_stack(struct node** pp_top,int number)
{
	struct node* temp = NULL;
	struct node* new_node = NULL;
	
	new_node = (struct node*)malloc(sizeof(struct node));
	
	if(new_node == NULL)
	{
		printf("malloc failed\nprocess end\n");
		return 0;
	}
	
	new_node->data = number;
	new_node->next = (*pp_top)->next;
	(*pp_top)->next = new_node;
}

#include "stack.h"

void release_stack(struct node* p_top)
{
	while(is_empty(p_top) == NON_EMPTY)
	{
		pop_stack(p_top);
	}
}

测试时，要严格按照输入要求进行测试！

欢迎提出发现的bug，或者指正编码风格不好的地方。