¿Necesita un programa en lenguaje C en Linux con aproximadamente 300 líneas de código fuente? Gracias
¿Crees que esto funcionará?
#incluye & ltstdio.h & gt
#incluye & ltstdlib.h & gt
#incluye & ltctype.h & gt
# include & ltstring.h & gt
#Definir EMAX 101
Char·operator[]="()+-*/^";
char expr[EMAX];
struct stack_head {
struct stack _ head * pre
};
Opción de estructura_ stack_node {
struct stack_head stack;
char c;
} * opt_topp = NULL/*parte superior de la pila del operador*/
Estructura val_stack_node {
struct stack_head stack;
long long val
} * val _ topp = NULL/*parte superior de la pila de valores* /
void stack_push(void *toppp, void *newp);
void *stack_pop(void *toppp);
void opt_stack_ push(char c);
char opt_stack_pop();
void val_stack_push(long long val);
long long val_stack_pop();
int isopt(char c);/* Compruebe si el carácter es un operador*/
/*En cada estado con el carácter dado Conjunto de acciones*/
void action _ 0(int I
<); p>acción nula _ 1(int I);acción nula _ 2(int I);
acción nula _ 3(int I
); acción nula _ 4(int I);
acción nula _ 5(int I);
acción nula _ 6(int I); _ 7(int I);
acción nula _ 8();
entrada nula _ expr();/*Expresión de entrada*/
void stack_push (void *toppp, void *newp)
{
struct stack _ head * temp = (struct stack _ head *)
temp-> ; pre = *(struct stack _ head * *)toppp
*( struct stack _ head * *)toppp = (struct stack _ head *) newp; /p>
void * stack_pop(void *toppp)
{
struct stack _ head * temp
if(*(struct stack _ head * *)toppp == NULL){
printf("¡La pila de enlaces está vacía! \n ");<
/p>
Salir(1);
}
temp = *(struct stack _ head * *)toppp;
*(struct stack _ head * *)toppp = temp-& gt; pre
Temperatura de retorno (void *);
}
void stack_clear(void *toppp)
{
estructura pila _ cabeza * temp
mientras(*(estructura pila _ cabeza * *)toppp!=NULL) {
temp =(*(struct stack _ head * *)toppp)-& gt; pre
gratis(*(struct stack _ head * *)toppp);
*( struct stack _ head * *)toppp = temp;
}
}
void opt_stack_push(char c)
{
Nodo de pila de optimización de estructura * nodo de optimización
=(struct opt _ stack _ node *)malloc(sizeof(struct opt _ stack _ node)
opt _ nodep->c = c
stack_push(& opt_topp, opt_nodep);
}
char opt_stack_pop()
{
struct option_stack_node*temporary
=(struct opt_stack_node *)stack_pop(&opt_topp);
char c = temp->c;
Gratis (temporal);
Devolver c;
}
Val_stack_push vacío(long long val)
{
Estructura val_stack_node *val_nodep
=(estructura val_stack_node *)malloc(sizeof(estructura val_stack_node));
val_nodep-> val = val
stack _ push(& val_topp, val _ nodep);
}
long long val_stack_pop()
{
struct value_stack_node*temporary
=(struct val _ stack _ node *)stack _ pop(& val _ topp);
long long val = temp ->val
libre (temporal);
retorno val
}
int isopt(char c)
{
if (strchr(operador, c) == NULL || c == '\0') {
Devuelve 0; De lo contrario {
Devuelve 1;
}
}
int compute(long long i, char opt, long long j, long largo *resultado)
{
largo largo p
rod = 1;
Interruptor (opcional){
Caso "+":
*Resultado = I+j;
Regresar 0;
Caso '-':
*Resultado = I-j;
Devuelve 0;
Caso '* ':
* resultado = I * j;
Devuelve 0;
Caso "/":
if (j == 0) {
printf(": Error semántico: el divisor no puede ser 0 \n ");
Devuelve 101
} En caso contrario {
* Resultado = I/j;
Devuelve 0;
}
Keith·'^':
if (j & gt; = 0) {
mientras(j & gt; 0) {
prod = prod * I;
j-;
p>
}
*resultado=producto;
Devuelve 0;
} else if (i == 0) {
printf(":Error semántico: "
"Las potencias de 0 no pueden ser negativas\n");
Devuelve 102;
} En caso contrario {
mientras(j & gt; 0) {
prod = prod/I;
j-;
}
*result=producto;
Devuelve 0;
}
Valor predeterminado:
devuelve 201;
}
}
void action_0(int i)
{
char c = expr[I]; p>
if (isspace(c)) {
acción _ 0(++i);
} else if (isdigit(c)) {
acción _ 1(I);
} else if (isopt(c) || c == '\0') {
cambiar(c ) {
p>Caso '(':
opt _ stack _ push(c);
acción _ 0(++i);
Romper ;
Caso '-':
opt _ stack _ push(' _ ');
acción _ 1(++ I);
p>
Romper;
Valor predeterminado:
printf(":Error de sintaxis: 201 \n ");
}
} De lo contrario {
printf(": Error léxico: carácter inesperado \n " en 101 entrada
}
}
void action_1(int i)
{
char c = expr[I];
if ( isdigit(c)) {
val_stack_push((龙龙)c-48);
Action_2(++i);
} else if(isopt (c)| | c = = '\ 0 ' | es espacio(c)){
cambiar(c) {
caso '(':
opt _ stack _ push (c);
acción _ 0(++i);
Romper;
Caso '-':
opt _ stack _ push(' _ ');
acción _ 1(++I
Romper
>Valor predeterminado:
printf(":Error de sintaxis: 211 \n ");
}
} En caso contrario {
printf (":error léxico: carácter inesperado en 111 entrada\n ");
}
}
void action_2(int i)
{
char c = expr[I];
if (isdigit(c)) {
val _ stack _ push((long long ) c-48+val _ stack _ pop()* 10);
Acción_2(++i);
} else if(isopt(c)| | c = = ' \ 0 ' | es espacio(c)){
Action_3㈠;
}else{
printf(": Error léxico: 121 Carácter inesperado\n ") en la entrada;
}
}
void action_3(int i)
{
char c = expr[I];
if (isspace(c)) {
Acción_3(++i);
} else if(isopt(c )| | c = = ' \ 0 ' | es dígito(c)){
cambiar(c) {
Keith·' ^':
Acción_4(1);
Pausa;
Caso ' * ':
Caso "/" :
Acción_5㈠;
Pausa;
Caso '+':
Caso '-':
Acción_6(1);
Salto;
Caso ")":
Acción_7(1);
Salto;
Caso '\0':
acción _ 8();
Interrupción;
Predeterminado:
printf(": Error de sintaxis: 231 \ n "); /p>
}
} De lo contrario {
printf(": Error léxico: 131 Carácter inesperado\n ") en la entrada;
}
}
Operación no válida_4(int i)
{
char c = expr[I];
char top_opt = opt_topp-& gt; c;
cambiar (top_opt) {
Caso "+":
Caso '-':
Caso '(':
Caso ' $ ':
Caso ' * ':
Caso "/":
Keith · '^':
opt _ stack _ push( c);
acción _ 0(++i);
Romper;
Caso '_':
val _ topp ->val =-val_topp->val
opt_stack_pop();
Acción_4(1);
Interrupción;
Valor predeterminado:
printf(":Error inesperado: 341 \n ");
}
}
Operación no válida_5(int i)
{
char c = expr[I];
char top _ opt = opt _ topp-& gt;c;
long lo
ng rs
Longlong se ha ido;
Longlong tiene razón;
Cambiar (top_opt) {
Caso "+":
Caso '-':
Caso '(':
Caso ' $ ':
opt _ stack _ push (c);
action_0(++i);
Romper;
Caso ' * ':
Caso "/":
Keith·'^':
derecha = val _ stack _ pop()
izquierda = val _ stack _ pop();
if(calcular(izquierda, opt_stack_pop(), derecha, & amprs)==0) {
val _ stack _ push(RS
Acción_5㈠;
;}
Pausa;
Caso '_':
val_topp->val =-val_topp-& gt;val
opt_stack_pop();
action_5㈠;
break;
Valor predeterminado:
printf(":Error inesperado: 351 \ n ");
}
}
Operación no válida _6(int i)
{
char c = expr[I];
char top _ opt = opt _ topp-& gt;
long long rs
Longlong se ha ido;
Longlong tiene razón;
Cambiar (top_opt) {
Caso '(':
Caso ' $ ':
opt _ stack _ push(c);
acción _ 0(++i );
Romper;
Caso '+':
Caso '-':
Caso ' * ':
Caso "/":
Keith'^':
derecha = val_stack_pop();
izquierda = val_stack_pop();
if(compute(izquierda, opt_stack_pop(), derecha, & amprs)==0) {
val_stack_push( RS);
Acción_6㈠;
}
Romper;
Caso '_':
val _ topp-& gt; val =-val _ topp-& gt;
opt_stack_pop();
Acción_6㈠;
Interrupción;
Predeterminado:
printf(":Error inesperado: 361 \n ");
}
}
Operación no válida_7(int i)
{
char c = expr[I];
char top _ opt = opt _ topp -& gt;c;
long long rs
Longlong se ha ido;
Longlong a la derecha;
Cambiar ( top_opt) {
Caso '(':
opt _ stack _ pop();
Acción_ 3(++i);
Romper;
Caso '$':
>printf(":Error de sintaxis: 271 corchete sin cerrar,"
"Se esperaba otro ")'\n");
Roto;
Caso "+ ":
Caso '-':
Caso ' * ':
Caso "/":
Keith·'^' :
derecha = val _ stack _ pop();
izquierda = val _ stack _ pop();
if (calcular(izquierda, opt_stack_pop( ), derecha, &rs)==0) {
val_stack_push(RS);
action_7(one);
}
Romper;
Caso ' _ ':
val _ topp-& gt; val =-val _ topp-& gt;
Acción_7(1);
Interrupción;
Valor predeterminado:
printf(":Error inesperado: 371 \ n ")
}
}
Operación no válida_8()
{
char top _ opt = opt _; topp-& gt; c;
long long rs
Longlong se ha ido;
龙龙right;
Cambiar (top_opt) {
Case '(':
printf(": Error de sintaxis: 281 Corchete sin cerrar, "
" esperando otro "("\n");
Roto;
Caso '$':
p>
printf("%lld\n ",val_stack_pop());
Rotura;
Caso "+":
Caso '-':
Caso ' * ':
Caso "/":
Keith·'^':
derecha = val_stack_pop();
izquierda = val_stack_pop();
if(calcular(izquierda,opt_stack_pop(),derecha, & amprs) == 0) {
val _ stack _ push(RS
acción _ 8(); /p>
}
Rotura;
Caso '_':
val _ topp-& gt; gt; val
opt _ stack_pop();
action_8();
break;
Valor predeterminado:
printf(": Error inesperado: 381 \n ");
}
}
void input_expr()
{
scanf("%100[^\n]",expr);
mientras (getchar()! = '\n') {}
}
int main()
{
printf(" \nCalculadora versión 1 . 0 2(2012-10-15)\n "
"La longitud máxima de la expresión es 100 caracteres\n "
"Salir con ' q()' \n\. n "
" >);
entrada _ expr();
mientras (cadena
cmp(expr, "q()")! = 0) {
pila _ clear(amp; opt _ topp);
pila _ clear(amp; val _ topp);
opt _ stack); _ push(' $ ');
acción _ 0(0);
printf(" >);
entrada _ expr();
p>
}
Devuelve 0;
}