#include<conio.h>
#include<iostream.h>
#include<math.h>
#include<string.h>
#include<stdlib.h>
#include<stdio.h>
#include<fstream.h>


class Pila; //Clase prototipo
class nodo
{
double dato;
nodo *sig;  // ESTADOS

//-------------CREAR CONSTRUCTOR---------

nodo();
friend Pila ;
};
//--------------------------------------
class Pila
{
nodo *tope;
int nnodos;

public:
//---------CONSTRUCTOR PILA-----------
Pila();
void Push(double);
double Top();
void Drop ();
double Pop ();
void Show();
void Clear();
~Pila();
void swap();  //Cambiar los dos nodos en el topo de la pila los dos primeros.
void Dup(); //Duplica el nodo  que esta en el tope de la pila.
void Depth();
void Pick(); //Trabaja con PUSH
void DupN(); //Trabaja con PUSH
void DropN();
void Roll();
void RollD();
void Add();
void Sub();
void Mult();
void Divi();
void Pot();
};

//------------CONSTRUCTOR DE PILA---------------
 Pila::Pila()
{
tope=NULL;
nnodos=0;
}
//------------CONSTRUCTOR DEL NODO---------

nodo::nodo ()
{
dato=0;
sig=NULL;
}

void main()
{
   FILE *Archivo=NULL;
   char letra;
	char arc[50];
	int num=0;
	char cadena[50];

   cout<<"Ingrese la ruta y nombre del archivo: "<<endl;
   cin >> "%s" >> arc;

   Archivo = fopen(arc,"r");
   if(Archivo == NULL)
	{
   	cout<<"No se ha encontrado el archivo";
   }
   else
   {
   	while(feof(Archivo)==0)
      {
      	fscanf(Archivo,"%s",&cadena);
         num = atof(cadena);
			if(num != 0)
			{
         Push(num);
         }
         if(strcmp(cadena,"top") == 0 ){
				Top();
            }


			if( strcmp(cadena,"drop") == 0 )
				Drop();


			if( strcmp(cadena,"pop") == 0 )
				Pop();


			if( strcmp(cadena,"show") == 0 )
				Show();


			if( strcmp(cadena,"clear") == 0 )
				Clear();

			if( strcmp(cadena,"swap") == 0 )
				Swap();


			if( strcmp(cadena,"depth") == 0 )
				Depth();


			if( strcmp(cadena,"dup") == 0 )
				Dup();

			if( strcmp(cadena,"pick") == 0 )
				Pick();


			if( strcmp(cadena,"dupn") == 0 )
				DupN();


			if( strcmp(cadena,"dropn") == 0 )
				DropN();

			if( strcmp(cadena,"roll") == 0 )
				Roll();


			if( strcmp(cadena,"rolld") == 0 )
				RollD();


			if( strcmp(cadena,"+") == 0 )
				Add(Lista);


			if( strcmp(cadena,"-") == 0 )
				Sub();


			if( strcmp(cadena,"*") == 0 )
				Mult();

			//Division
			if( strcmp(cadena,"/") == 0 )
				Div();

			//Exponente
			if( strcmp(cadena,"^x") == 0 )
				Pot();
		}
	}
	fclose(Archivo);
	cout<<"\nPila:\n"<<endl;
	//show();
	clear2();
	system("PAUSE");
}



//--------------CONSTRUCTOR DE PUSH --------------- (lifo)
void Pila::Push(double d)
{
	nodo *nuevo=new nodo;
	nuevo->dato=d;
	nuevo->sig=tope;
	tope=nuevo;
	nnodos ++;
}

//---------------CONSTRUCTOR DE TOP-------------
double Pila::Top()
{
return ((tope)?tope->dato:NULL);
//operador condicional (cond)?rv:rf
}

//--------------CONSTRUCTOR DE DROP-----------
void Pila::Drop()
{
	if (tope)
   {
  		nodo *tmp=tope;
  		tope=tope->sig;
  		delete tmp;
  		nnodos --;
  	}
}
//----------CONSTRUCTOR DE POP----------------
double Pila::Pop ()
{
	double dtmp=Top();
	Drop();
	return dtmp;
}
//------------------------------------------------


void Pila::Show()
{
	nodo *tmp=tope;
	while(tmp)
	{
   	cout<<tmp->dato<<",";
		tmp=tmp->sig;
	}
   cout<<endl;
}

void Pila::Clear()
{
	while(nnodos>0)
	Drop();
}

Pila::~Pila()
{
	Clear() ;
}

void Pila::swap()
{
	if(nnodos>=2)
	{
   	nodo *tmp=tope;
		tope=tope->sig;
		tmp->sig=tope->sig;
		tope->sig=tmp;
	}
}

void Pila::Dup()
{
	if(tope)
	Push(Top());
}

void Pila::Depth()
{
	Push(nnodos);
}

void Pila::Pick()
{
	if(tope)
	{
   	double n=Pop(); //Borra el dato y lo retorna n guarda el numero del nodo que quiero copiar
		if((n<=nnodos) &&(n>=1))
			{
         	nodo *tmp=tope;
				for(int x=1;x<n;x++)
				tmp=tmp->sig;
				Push(tmp->dato);
      	}
   }
}

void Pila::DupN()
{
if(tope)
	{	double N=Pop();
   	if(N>=1)
      {
        	N=(N<nnodos)?N:nnodos;
         for(int x=1; x<=N; x++)
         {	Push(N);
         	Pick();
         }
      }
   }
}

void Pila::DropN()
{
	if(tope)
	{	double N=Pop();
   	if(N>=1)
      {
        	N=(N<nnodos)?N:nnodos;
         for(int x=1; x<=N; x++)
         Drop();
      }
   }
}

void Pila::Add()
{
	if(nnodos>=2)
   	{
      	Push(Pop()+Pop());
      }
}

void Pila::Sub()
{
	if(nnodos>=2)
   	{
      	swap();
         Push(Pop()-Pop());
      }
}

void Pila::Mult()
{
	if(nnodos>=2)
   	{
      	Push(Pop()*Pop());
      }
}

void Pila::Divi()
{
	if(nnodos>=2)
   	{
      	swap();
         Push(Pop()/Pop());
      }
}

void Pila::Pot()
{
	if(nnodos>=2)
   	{
      	Push(pow(Pop(),Pop()));
      }
}

void Pila::Roll()
{
    if (tope)
   {
      double N=Pop();

       nodo *tmp = tope;

             for(double x=1 ; x<N ; x++)
         {
             tmp = tmp->sig;
         }

         Push(tmp->dato);
   }
}

void Pila::RollD()
{
	if(tope)
		{
		double n = Pop();
		Depth();
			if(n <= Pop())
				{
				nodo *tmp = tope;
				for(double x=1; (x<n-1) && (tmp->sig) ;x++)
			tmp = tmp -> sig;
			Push(Pop());
				}
		}
}