KLNX.cpp_

/****************************************************************
		COMPILADOR DE LENGUAJE KAREL PARA LINUX

		Autor: Ing. CUAUHTEMOC RIVERA LOAIZA

		Rutinas de generacion del lenguaje ensamblador
		Karel elaboradas por el Ing. Rafael R. Ochoa
		rochoa@scfie.eie.umich.mx

		Universidad Michoacana de San Nicolas de Hidalgo

		Seccion de Graduados de la Facultad de Ingenieria
		Electrica

		Maestria en Sistemas Computacionales

		crivera@scfie.eie.umich.mx
******************************************************************

Proposito: 	Este programa permite la compilacion de programas
		hechos en el lenguaje Karel, dentro del ambiente
		de Linux. En caso de una compilacion sin errores,
		se produce a la salida un archivo con extension
		*.ok, el cual puede ser visualizado en la interfaz
		hecha en Tcl/Tk (se requiere contar con el inter-
		prete de este lenguaje).

******************************************************************

Uso del
Programa:	Se requiere de un compliador de C++. Para la com-
		pilacion del programa fuente se necesita hacer lo
		siguiente:
			g++ -o <karel> <karel.cpp>
		Por ejemplo, para correr el archivo 6.kar:
			/<path>/karel 6
		Al correr el programa se pide al usuario que de
		el nombre del archivo karel, pero sin la extension
		exito se obtiene un archivo en lenguaje ensamblador
		de Karel (nombre_archivo.ok), el cual se visualiza
		en el interprete.
		En caso de errores en el programa *.kar se produce
		un mensaje de error.

*****************************************************************/


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

char *token(int, char *);
char *instr_primitivas (char *);
char *pruebas_karel (char *);
char *genera_etiqueta(void);
char gen_etiq(void);

class tabla_de_simbolos{
		char *instr;
		tabla_de_simbolos *sig;
	public:
		void nueva_instruccion(char *);
		int existe_instruccion(char *);
};

class ensamblador {
		int linea;
		char *comando;
		ensamblador *sig;
	public:
		void archivo_virtual(char *,int);
		friend void archivo_ensamblador (char *);
		friend void genera_nva_instr();
};

class entrada{
	public:
		char *linea;
		int num;
		entrada *sig;
		void inserta_nodo (int , char *);
		void textLoadFile (char *);
};

class instrucciones:public entrada{
		void instruccion ();
		void genera_nva_instr();
		void repite ();
		void fin_bloque();
		void mientras ();
		void si ();
		friend void genera_nva_instr();
		friend void programa();
};

class ambiente:public entrada{
		void karel_inicio();
		void forma_entorno();
		void inicio_de_ambiente();
		void instrucciones_de_ambiente ();
		void fin_de_ambiente();
		friend void archivo_ensamblador (char *);
};

class ejecucion:public entrada{
		void inicia_programa();
		void inicia_ejecucion();
		void fin_ejecucion();
		void fin_programa();
		friend void archivo_ensamblador (char *);
		friend void programa();
};

entrada *start, *nodo;
ensamblador *karel;
tabla_de_simbolos *proxima_nva_instr;
int etiqueta;

/***********************************************************
	Nombre de la funcion: textLoadFile

	Proposito: Apertura del archivo *.kar para
	Entrega: Nada
	Funciones externas: inserta_nodo
************************************************************/
void entrada::textLoadFile(char *fileName){
	char ch, car[1], linea[80];
	int numero_linea = 1;

	ifstream inicio(fileName);
	if(!inicio){
		cout<<"Error de lectura!";
		exit (0);
	}
	inicio.get(ch);
	while (ch != EOF){
		linea[0] = '\0';
		while (ch == ' ' || ch == '\t' )
			inicio.get(ch);
		while (ch != '\n' && ch != EOF){
			car[0] = ch;
			car[1] = '\0';
			strcat(linea, car);
			inicio.get(ch);
		}
		if (strlen(linea) > 0)
			inserta_nodo(numero_linea, linea);
		numero_linea++;
		inicio.get(ch);
	}
	inicio.close();
}

/***********************************************************
	Nombre de la funcion: INSERTA_NODO

	Proposito: Formar la lista lineal con un nodo
		   para cada renglon del programa inicial
	Entrega: Nada
	Funciones externas: Ninguna.
************************************************************/
void entrada::inserta_nodo (int num_linea, char linea[80]){
	entrada *act = NULL, *ant = NULL, *nodo_nuevo = NULL;

	if (!(nodo_nuevo = new entrada)){
		cout<<"\nError de asignacion";
		exit(1);
	}
	nodo_nuevo->linea = strdup(linea);
	nodo_nuevo->num   = num_linea;
	nodo_nuevo->sig   = NULL;
	if(!start)
		start = nodo_nuevo;
	else {
		act = start;
		while (act) {
			ant = act;
			act = act->sig;
		}
	nodo_nuevo->linea   = strdup(linea);
	nodo_nuevo->num     = num_linea;
	nodo_nuevo->sig = NULL;
	ant->sig = nodo_nuevo;
	}
}


////////////////////////////////////////////////////////////////
//		RUTINAS DE CREACION DE AMBIENTE		      //
////////////////////////////////////////////////////////////////
/***********************************************************
	Nombre de la funcion: FORMA_ENTORNO

		   etiqueta "jc kini", que le indica al
	Entrega: Nada
************************************************************/
void ambiente::forma_entorno() {
	ensamblador haz;

	inicio_de_ambiente();
	karel_inicio();
	instrucciones_de_ambiente();
	fin_de_ambiente();
	haz.archivo_virtual("jc kini", nodo->num);
}

/***********************************************************
	Nombre de la funcion: KAREL_INICIO

	Entrega: Nada
	Funciones externas: archivo_virtual, token
************************************************************/
void ambiente::karel_inicio(){
	ensamblador haz;

	if (strncmp(nodo->linea, "KAREL_ESTA_EN_CALLE", 19) != 0 ){
		exit(1);
	}
	haz.archivo_virtual("k", nodo->num);
	haz.archivo_virtual(token(2,nodo->linea), nodo->num); // calle
	haz.archivo_virtual(token(4,nodo->linea), nodo->num); // avenida
	haz.archivo_virtual(token(6,nodo->linea), nodo->num); // direccion
	haz.archivo_virtual(token(8,nodo->linea), nodo->num); // monedas
	nodo = nodo->sig;
}

/***********************************************************
	Nombre de la funcion: INSTRUCCIONES DE AMBIENTE

	Entrega: Nada
	Funciones externas: archivo_virtual, token
************************************************************/
void ambiente::instrucciones_de_ambiente() {
	ensamblador haz;

	while (strncmp(nodo->linea, "FIN_DE_AMBIENTE", 15) != 0 ) {
	  if (strncmp(nodo->linea, "PARED_JUNTO_A_CALLE", 19) == 0 ) {
		haz.archivo_virtual("pc", nodo->num);
		haz.archivo_virtual(token(2,nodo->linea), nodo->num);
		haz.archivo_virtual(token(4,nodo->linea), nodo->num);
		haz.archivo_virtual(token(6,nodo->linea), nodo->num);
	  }
	  if (strncmp(nodo->linea, "PARED_JUNTO_A_AVENIDA", 21) == 0 ){
		haz.archivo_virtual("pa", nodo->num);
		haz.archivo_virtual(token(2,nodo->linea), nodo->num);
		haz.archivo_virtual(token(4,nodo->linea), nodo->num);
		haz.archivo_virtual(token(6,nodo->linea), nodo->num);
	  }
	  if (strncmp(nodo->linea, "HAY", 3) == 0 ){
		haz.archivo_virtual("m", nodo->num);
		haz.archivo_virtual(token(2,nodo->linea), nodo->num);
		haz.archivo_virtual(token(4,nodo->linea), nodo->num);
		haz.archivo_virtual(token(6,nodo->linea), nodo->num);
	  }
	nodo = nodo->sig;
	}
	if (strncmp(nodo->linea, "FIN_DE_AMBIENTE", 15) != 0 ){
		cout<<"\nNo se encuentra el FIN_DE_AMBIENTE";
		exit(1);
	}
}

/***********************************************************
	Nombre de la funcion: INICIO_AMBIENTE

		   AMBIENTE
	Entrega: Nada
************************************************************/
void ambiente::inicio_de_ambiente(){
	if (strncmp(nodo->linea, "INICIO_DE_AMBIENTE", 18) != 0 ){
		cout<<"No se encuentra INICIO_DE_AMBIENTE";
		exit(1);
	}
	nodo = nodo->sig;
}

/***********************************************************
	Nombre de la funcion: FIN_AMBIENTE

		   AMBIENTE
	Entrega: Nada
	Funciones externas: Ninguna
************************************************************/
void ambiente::fin_de_ambiente(){
	if (strncmp(nodo->linea, "FIN_DE_AMBIENTE", 15) != 0 ){
		cout<<"No se encuentra FIN_DE_AMBIENTE";
		exit(1);
	}
	nodo = nodo->sig;
}

/***********************************************************
	Nombre de la funcion: TOKEN

	Funciones externas:Ninguna
************************************************************/
char *token(int localizacion, char *renglon){
	char simbolo[1], palabra[80],*cadena = NULL, c=' ',*cad;
	int posicion=0;

	cadena = strdup(renglon);
	while(localizacion>1){
		cadena= strchr(cadena,c);
		cadena = cadena++;
		localizacion--;
	}
	palabra[0] = '\0';
	cad=strchr(cadena,c);
	posicion=cad-cadena;
	for (int i=0;i<posicion;i++){
		if (cadena[i]!=';' && cadena[i]!=' '){
			simbolo[0]=cadena[i];
			simbolo[1]='\0';
			strcat(palabra,simbolo);}
	}
	return palabra;
}


/***********************************************************
	Nombre de la funcion: INSTR_PRIMITIVAS

		    instruccion primitiva de karel
	Funciones externas: token
************************************************************/
char *instr_primitivas(char *cadena){
   tabla_de_simbolos checa;

   if ((strlen(token(1,cadena)) == 19) &&
       (strncmp(token(1,cadena), "gira_a_la_izquierda", 19) == 0 )
      ) return "gi";
   if ((strlen(token(1,cadena)) == 7) &&
       (strncmp(token(1,cadena), "apagate",7) == 0 )
      ) return "ap";
   if ((strlen(token(1,cadena)) == 13) &&
       (strncmp(token(1,cadena), "coloca_moneda",13) == 0 )
      ) return "cm";
   if ((strlen(token(1,cadena)) == 6) &&
       (strncmp(token(1,cadena), "avanza", 6) == 0 )
      ) return "av";
   if ((strlen(token(1,cadena)) == 13) &&
       (strncmp(token(1,cadena), "recoge_moneda", 13) == 0 )
      ) return "rm";
   if (checa.existe_instruccion(token(1, cadena))) return token(1, cadena);
   return "\0";
}

/***********************************************************
	Nombre de la funcion: PRUEBAS_KAREL

		    prueba de karel
		   prueba en ensamblador Karel
	Funciones externas:Ninguna
************************************************************/
char *pruebas_karel(char *cadena){
   if (strncmp(cadena, "frente_despejado",        16) == 0 ) return "fd";
   if (strncmp(cadena, "frente_bloqueado",        16) == 0 ) return "fn";
   if (strncmp(cadena, "izquierda_despejada",     19) == 0 ) return "id";
   if (strncmp(cadena, "izquierda_bloqueada",     19) == 0 ) return "ib";
   if (strncmp(cadena, "derecha_despejada",       17) == 0 ) return "dd";
   if (strncmp(cadena, "derecha_bloqueada",       17) == 0 ) return "db";
   if (strncmp(cadena, "junto_a_moneda",          14) == 0 ) return "jm";
   if (strncmp(cadena, "no_junto_a_moneda",       17) == 0 ) return "njm";
   if (strncmp(cadena, "hacia_el_norte",          14) == 0 ) return "hn";
   if (strncmp(cadena, "no_hacia_el_norte",       17) == 0 ) return "nhn";
   if (strncmp(cadena, "hacia_el_sur",            12) == 0 ) return "hs";
   if (strncmp(cadena, "no_hacia_el_sur",         15) == 0 ) return "nhs";
   if (strncmp(cadena, "hacia_el_este",           13) == 0 ) return "he";
   if (strncmp(cadena, "no_hacia_el_este",        16) == 0 ) return "nhe";
   if (strncmp(cadena, "hacia_el_oeste",          14) == 0 ) return "ho";
   if (strncmp(cadena, "no_hacia_el_oeste",       17) == 0 ) return "nho";
   if (strncmp(cadena, "con_monedas_en_su_bolsa", 23) == 0 ) return "din";
   if (strncmp(cadena, "sin_monedas_en_su_bolsa", 23) == 0 ) return "smb";
   else { cout<<"\nInstruccion desconocida!";
	exit(1); }
   return "\0";
}

/***********************************************************
	Nombre de la funcion: ARCHIVO_VIRTUAL

	Entrega: Nada.
		   coloca todo el programa en ensamblador Karel
	Funciones externas:Ninguna
************************************************************/
void ensamblador::archivo_virtual(char *mnemonico,int num_linea){
	ensamblador *ant = NULL, *act = karel;

	while(act) {
		ant = act;
		act = act->sig;
	}
	if (!(act = new ensamblador)) {
		cout<<"\nError de asignacion";
		exit(1);
	}
	act->comando = strdup(mnemonico);
	act->linea = num_linea;
	act->sig = NULL;
	if(!karel)
		karel = act;
	else
		ant->sig = act;
}


////////////////////////////////////////////////////////////////
//		RUTINAS PARA LA EJECUCION DE KAREL	      //
////////////////////////////////////////////////////////////////
void programa(){

	ensamblador haz;
	instrucciones ejecuta;
	ejecucion corre;

	corre.inicia_programa();
	ejecuta.genera_nva_instr();
	corre.inicia_ejecucion();
	while (strncmp(nodo->linea, "FIN_DE_EJECUCION", 16) != 0)
		ejecuta.instruccion();
	corre.fin_ejecucion();
	corre.fin_programa();
	haz.archivo_virtual("ok", 1);
}

/***********************************************************
	Nombre de la funcion: INICIA_PROGRAMA

	Proposito: Verifica la existencia del token
		   "INICIO_DE_PROGRAMA"
	Entrega: Nada
	Funciones externas: Ninguna
************************************************************/

void ejecucion::inicia_programa(){
	if (strncmp(nodo->linea, "INICIO_DE_PROGRAMA", 18) != 0 ){
		cout<<"\nNo se encuentra INICIO_DE_PROGRAMA";
		exit(1);
	}
	nodo = nodo->sig;
}

/***********************************************************
	Nombre de la funcion: INICIA_EJECUCION

	Proposito: Verifica la existencia del token
		   "INICIO_DE_EJECUCION" y agrega
		   al programa en ensamblador la
		   etiqueta "kini", la cual indica
		   karel.
	Entrega: Nada
	Funciones externas: archivo_virtual
************************************************************/
void ejecucion::inicia_ejecucion(){
	ensamblador haz;

	if (strncmp(nodo->linea, "INICIO_DE_EJECUCION", 19) != 0 ){
		cout<<"\nNo se encuentra INICIO_DE_EJECUCION";
		exit(1);
	}
	haz.archivo_virtual("kini", nodo->num);
	nodo = nodo->sig;
}


/***************************************************************
	Nombre de la funcion: GENERA_NVA_INSTR

		   ensamblador Karel
	Entrega: Nada
	Funciones externas: nueva_instruccion,instruccion
			    archivo_virtual.
****************************************************************/
void instrucciones::genera_nva_instr(){
   instrucciones ejecuta;
   ensamblador haz;
   tabla_de_simbolos checa;

   while ( (nodo) && (strncmp(nodo->linea, "INICIO_DE_EJECUCION", 19) != 0) )
   {
      if (strncmp(nodo->linea, "DEFINE_NUEVA_INSTRUCCION", 24) == 0 )
      {
	 haz.archivo_virtual(token(2, nodo->linea), nodo->num);
	 checa.nueva_instruccion(token(2, nodo->linea));
	 nodo = nodo->sig;
	 ejecuta.instruccion();
      }
      haz.archivo_virtual("rs", nodo->num);
   }
   if ( !nodo ){
	cout<<"\nError en la linea"<<nodo->num<<" => "<<nodo->linea;
	exit(1);
   }
}

/***************************************************************
	Nombre de la funcion: INSTRUCCION

		   o condicionales.
	Entrega: Nada
	Funciones externas: si, mientras, repite,
			    archivo_virtual, existe_instruccion
****************************************************************/
void instrucciones::instruccion(){
   char *id = NULL, *brinco = NULL;
   ensamblador haz;
   tabla_de_simbolos checa;

   if ( (strncmp(nodo->linea, "INICIO_DE_EJECUCION",     19) == 0 ) ||
	(strncmp(nodo->linea, "FIN_DE_EJECUCION",        16) == 0 ) ||
	(strncmp(nodo->linea, "DEFINE_INSTRUCCION_NUEVA",24) == 0 ) ||
	(strncmp(nodo->linea, "FIN",                      3) == 0 )
      ) return;
   if (strncmp(nodo->linea, "INICIO", 6) == 0 ){
	fin_bloque();
	return;
   }
   if (strncmp(nodo->linea, "SI", 2) == 0 ){
	si();
	return;
   }
   if (strncmp(nodo->linea, "REPITE", 6) == 0 ){
	repite();
	return;
   }
   if (strncmp(nodo->linea, "MIENTRAS", 8) == 0 ){
	mientras();
	return;
   }
   if (strlen(id = strdup(instr_primitivas(nodo->linea))) == 0){
	cout<<"\nError en la linea"<<nodo->num<<" => "<<nodo->linea;
	exit(1);
   }

   if (checa.existe_instruccion(token(1, nodo->linea))){
	sprintf(brinco, "js %s", id);
	haz.archivo_virtual(brinco, nodo->num);
   }
   else
	haz.archivo_virtual(id, nodo->num);
   nodo = nodo->sig;

}

/***********************************************************
	Nombre de la funcion: MIENTRAS

		   MIENTRAS con ensamblador Karel.
	Entrega: Nada
	Funciones externas: pruebas_karel, instruccion,
			    archivo_virtual, genera_etiqueta
************************************************************/
void instrucciones::mientras(){
   char *id = NULL, *etiq_ciclo, *etiq_no_ok, brinco[30],etic;
   ensamblador haz;
   instrucciones ejecuta;

   etiq_ciclo[0] = '\0'; etiq_no_ok[0] = '\0';
   if ( strlen(id = strdup(pruebas_karel(token(2,nodo->linea)))) == 0 ){
	cout<<"\nError en la linea"<<nodo->num<<" => "<<nodo->linea;
	exit(1);
   }
   etiq_ciclo = genera_etiqueta();
//   etic=gen_etiq();
   haz.archivo_virtual(etiq_ciclo, nodo->num);
   haz.archivo_virtual(id, nodo->num);
   etiq_no_ok = genera_etiqueta();
   sprintf(brinco,"jc %s", etiq_no_ok);
   haz.archivo_virtual(brinco, nodo->num);
   nodo = nodo->sig;
   ejecuta.instruccion();
   sprintf(brinco, "jc %s", etiq_ciclo);
   haz.archivo_virtual(brinco, nodo->num);
   haz.archivo_virtual(etiq_no_ok, nodo->num);
}

/***********************************************************
	Nombre de la funcion: REPITE

		   REPITE con ensamblador Karel.
	Entrega: Nada
	Funciones externas: instruccion
************************************************************/
void instrucciones::repite(){
	instrucciones ejecuta;
	entrada *ciclo = NULL;
	int n;

	n = atoi( token(2, nodo->linea)  );
	nodo = nodo->sig;
	ciclo = nodo;
	while (n) { nodo = ciclo;
		ejecuta.instruccion();
		n--;
	}
}

/***********************************************************
	Nombre de la funcion: SI

		   y SINO con ensamblador Karel.
	Entrega: Nada
	Funciones externas: genera_etiqueta,instruccion,
			    archivo_virtual, pruebas_karel
************************************************************/
void instrucciones::si(){
   char *id = NULL, *etiq_0, *etiq_1, brinco_0[30], brinco_1[30];
   ensamblador haz;
   instrucciones ejecuta;

   if ( strlen(id = strdup(pruebas_karel(token(2,nodo->linea)))) == 0 ){
	cout<<"\nError en la linea"<<nodo->num<<" => "<<nodo->linea;
	exit(1);
   }
   etiq_0 = genera_etiqueta();
   etiq_1 = genera_etiqueta();
   sprintf(brinco_0,"jc %s", etiq_0);
   sprintf(brinco_1,"jc %s", etiq_1);
   haz.archivo_virtual(id, nodo->num);
   haz.archivo_virtual(brinco_0, nodo->num);
   nodo = nodo->sig;
   ejecuta.instruccion();
   haz.archivo_virtual(brinco_1, nodo->num);
   haz.archivo_virtual(etiq_0, nodo->num);
   if (strncmp(nodo->linea,"SINO",4) == 0){
	nodo = nodo->sig;
	ejecuta.instruccion();
   }
   haz.archivo_virtual(etiq_1, nodo->num);
}

/***********************************************************
	Nombre de la funcion: GENERA_ETIQUETA

		   en ensamblador Karel
	Funciones externas: Ninguna
************************************************************/
char *genera_etiqueta(void){
	char etiq[10];

	sprintf(etiq, "etiq_%d", etiqueta);
	etiqueta++;
	return strdup(etiq);
}
char gen_etiq(void){
	char etiq[10];

	sprintf(etiq, "etiq_%d", etiqueta);
	etiqueta++;
	return *etiq;
}

/***********************************************************
	Nombre de la funcion: FIN_BLOQUE

	Entrega: Nada
	Funciones externas: instruccion
************************************************************/
void instrucciones::fin_bloque(){
	nodo = nodo->sig;
	entrada ir;
	instrucciones ejecuta;

	while ((strncmp(nodo->linea,"FIN", 3) != 0) && (nodo))
		ejecuta.instruccion();
	if (strncmp(nodo->linea, "FIN", 3) != 0 ){
		cout<<"\nError en la linea"<<nodo->num<<" => "<<nodo->linea;
		exit(1);
	}
	nodo = nodo->sig;
}

/***********************************************************
	Nombre de la funcion: FIN_EJECUCION

	Proposito: Verifica la existencia del token
		   "FIN_DE_EJECUCION"
	Entrega: Nada
	Funciones externas: Ninguna
************************************************************/
void ejecucion::fin_ejecucion(){
	if (strncmp(nodo->linea, "FIN_DE_EJECUCION", 16) != 0 ){
		cout<<"\nNo se encuentra FIN_DE_EJECUCION";
		exit(1);
	}
	nodo = nodo->sig;
}

/***********************************************************
	Nombre de la funcion: FIN_PROGRAMA

	Proposito: Verifica la existencia del token
		   "FIN_DE_PROGRAMA"
	Entrega: Nada
	Funciones externas: Ninguna
************************************************************/
void ejecucion::fin_programa(){
	if (strncmp(nodo->linea, "FIN_DE_PROGRAMA", 15) != 0 ){
		cout<<"\nNo se encuentra FIN_DE_PROGRAMA";
		exit(1);
	}
	nodo = nodo->sig;
}


////////////////////////////////////////////////////////////////
//		RUTINAS PARA LA CREACION DE UNA TABLA DE      //
//		SIMBOLOS EN DONDE PONER LAS NUEVAS	      //
//		INSTRUCCIONES		      		      //
////////////////////////////////////////////////////////////////
/***********************************************************
	Nombre de la funcion: NUEVA_INSTRUCCION

	Proposito: Insertar una nueva instruccion en la
		   tabla de simbolos
	Entrega: Nada.
	Funciones externas: Ninguna
************************************************************/
void tabla_de_simbolos::nueva_instruccion(char *instruccion){
	tabla_de_simbolos *act = NULL;

	if (!(act = new tabla_de_simbolos)){
		cout<<"Error de asignacion!";
		exit(1);
	}
	act->instr = strdup(instruccion);
	act->sig = proxima_nva_instr;
	proxima_nva_instr = act;
}

/***********************************************************
	Nombre de la funcion: EXISTE_INSTRUCCION

		simbolos
	Proposito: Realizar la escritura del archivo
	Entrega: 1 si la palabra existe, 0 en caso contrario
	Funciones externas: Ninguna
************************************************************/
int tabla_de_simbolos::existe_instruccion(char *cadena){
	tabla_de_simbolos *act = proxima_nva_instr;

	while (act){
		if ((strncmp(act->instr,cadena,strlen(cadena))== 0) &&
			(strlen(act->instr) == strlen(cadena)))
		    return 1;
		act = act->sig;
	}
	return 0;
}

/***********************************************************
	Nombre de la funcion: ARCHIVO_ENSAMBLADOR

	Proposito: Realizar la escritura del archivo
		   *.ok, el cual esta en lenguaje ensamblador
		   tipo Karel
	Entrega: Nada.
************************************************************/
void archivo_ensamblador(char *archivo_terminado) {
	nodo = start;
	char *num_linea, *mnemonico;
	int i;
	ambiente crea;
	crea.forma_entorno();

	//programa();
	ofstream salida(archivo_terminado);
	if (!salida){
		cout<<"Error de escritura en "<<archivo_terminado<<"!\n";
		return;
	}
		while(karel){
		sprintf(num_linea,"%d",karel->linea);
		mnemonico = strdup(karel->comando);
		i = 0;
		while (num_linea[i]) {
			salida.put(num_linea[i]);
			i++;
		}
		salida<<" ";
		i = 0;
		while (mnemonico[i]) {
			salida.put(mnemonico[i]);
			i++;
		}
		salida<<"\n";
		karel = karel->sig;
	}
	salida.close();
	cout<<"\nExito";
	delete mnemonico;
	delete karel;
	delete nodo;
	delete start;
}


/***************************************************************
////////////////////////////////////////////////////////////////
//		P R O G R A M A   P R I N C I P A L 	      //
////////////////////////////////////////////////////////////////
***************************************************************/
void main(){
	char *temp, fileName[20], archivo_ok[20],*cadena,*p;
	entrada ir;
	start = NULL;
	karel = NULL;
	etiqueta = 0;
	proxima_nva_instr = NULL;

	cout<<"\nkar ";
	cin>>temp;
	//cout<<"\n aparte"; gets(cadena);
	//p=strtok(cadena," ");

	strcpy(fileName,temp);

	sprintf(archivo_ok, "%s.ok",strtok(temp,"."));
	ir.textLoadFile(fileName);
	archivo_ensamblador(archivo_ok);
	exit (1);
}