//Função para verificar na pilha o estado
int VerificacaoPilha(Stack* Pilha,char* x)
{
int i,resposta;
char ValorRemovido;
char Valor_top;
int n = strlen(x);
i = 0;
while(i < n)
{
if(x[i] == ')')
{
peek(Pilha,&Valor_top);
if (sizeStack(Pilha) != 0 && Valor_top == '(')
pop(Pilha,&ValorRemovido);
else
{
clearStack(Pilha);
return 0;
}
}
else if(x[i] == ']')
{
peek(Pilha,&Valor_top);
if (sizeStack(Pilha) != 0 && Valor_top == '[')
pop(Pilha,&ValorRemovido);
else
{
clearStack(Pilha);
return 0;
}
}
else if(x[i] == '}')
{
peek(Pilha,&Valor_top);
if (sizeStack(Pilha) != 0 && Valor_top == '{')
pop(Pilha,&ValorRemovido);
else
{
clearStack(Pilha);
return 0;
}
}
else if (x[i] == '(' || x[i] == '[' || x[i] == '{')
push(Pilha,x[i]);
i++;
}
if (sizeStack(Pilha) == 0)
resposta = 1;
else
resposta = 0;
clearStack(Pilha);
return resposta;
}
// ------------------------------------------------------------ Print operands stack
void printAnds( const Stack Ands )
{
Iter si = newIter( Ands );
printf( "\nStack has %d items: bottom<[ ", sizeStack( Ands ) );
while (hasNextIter( si )) {
printOperand( nextIter( si ) );
}
printf( " ]>top\n" );
freeIter( si );
}
int main() {
Stack *s;
int i, removed, returned, e=5;
s = createStack();
initializeStack(s);
for (i=0; i<10; i++)
{
if(push(s, 5+i+1) == true)
{
printf("O valor %d foi inserido!\n", 5+i+1);
}
else
{
printf("O valor %d não pôde ser inserido.\n", 5+i+1);
}
}
for (i=0; i<7; i++)
{
if (pop(s, &removed)==true)
{
printf("Topo removido com sucesso, o valor era: %d\n", removed);
}
else
{
printf("Não foi possível remover o topo\n");
}
}
if (top(s, &returned) == true)
{
printf("O valor do topo é: %d\n", returned);
}
else
{
printf("Não há nada no topo.\n");
}
printStack(s);
if (containsStack(s, &e) == false)
{
printf("O valor 5 não está presente na pilha.\n");
}
else
{
printf("O valor 5 está presente na pilha.\n");
}
e++;
if (containsStack(s, &e) == false)
{
printf("O valor 6 não está presente na pilha.\n");
}
else
{
printf("O valor 6 está presente na pilha.\n");
}
printf("Tamanho da pilha: %d\n",sizeStack(s));
if (isEmptyStack(s) == true)
{
printf("A pilha está vazia.\n");
}
else
{
printf("A pilha não está vazia.\n");
}
return(0);
}
// -------------------------------- Evaluate all higher precedence operators on stack.
void forceEval( Eval ev, int rprec ) {
while( sizeStack( ev->Ators ) > 0 &&
precedenceOperator( (const Operator) topStack( ev->Ators ) ) >= rprec ) {
dispatchEval( ev );
}
}
//------------------------------------------------ Read input and evaluate expression.
double evaluateEval(Eval ev) {
Intype next; // Classification of next input character.
char inSymbol; // Read input operators into this.
Operator inOp; // Operator object constructed from inSymbol.
double inNumVal; // Read input operands into this.
Operand And; // Operand value
int numread;
int n;
for (;;) {
next = classifyEval(ev);
switch (next) {
case number:
n = sscanf(ev->instream, "%lg%n", &inNumVal, &numread);
ev->instream += numread;
if (n!=1 || sizeStack(ev->Ands) != ev->numbin)
return expErrorEval(ev);
And = newOperand(inNumVal);
pushStack(ev->Ands, And);
break;
case op:
if (sizeStack(ev->Ands) != ev->numbin+1)
return expErrorEval(ev);
inSymbol = *(ev->instream++);
inOp = newOperator(inSymbol);
forceEval(ev, precedenceOperator(inOp) );
pushStack(ev->Ators, inOp);
ev->numbin++;
break;
case lpar:
if (sizeStack(ev->Ands) != ev->numbin) return expErrorEval(ev);
inSymbol = *(ev->instream++);
inOp = newOperator(inSymbol); // put left paren on Ators stack
pushStack(ev->Ators, inOp);
break;
case rpar:
n = sscanf(ev->instream, " %c%n", &inSymbol, &numread);
ev->instream += numread;
if (sizeStack(ev->Ands) != ev->numbin+1)
return expErrorEval(ev);
forceEval(ev, 0);
if (isemptyStack(ev->Ators)) expErrorEval(ev); // too many right parens
Operator op = topStack(ev->Ators); // remove left paren operator from Ators stack
freeOperator(op);
popStack(ev->Ators);
break;
case end:
if (sizeStack(ev->Ands) != ev->numbin+1)
return expErrorEval(ev);
forceEval(ev, 0);
if (!isemptyStack(ev->Ators)) return expErrorEval(ev);
And = topStack(ev->Ands);
popStack(ev->Ands);
double retval = value(And);
freeOperand(And);
return retval;
break;
case bad:
default:
return expErrorEval(ev);
}
}
}
