logo.cpp

#include "logo.h"
#include "ui_logo.h"
#include <QFile>
#include <iostream>
#include <QTextStream>
#include <QTextDocument>
#include <stdlib.h>
#include <stdio.h>
#include <fstream>
#include <string>
#include <input.h>
#include <QGraphicsItem>
#include <QGraphicsPolygonItem>
#include <QGraphicsScene>
#include <QTransform>
#include "virtualmemory.h"


using namespace std;


Logo::Logo(QWidget *parent) :
    QDialog(parent),
    ui(new Ui::Logo)
{
    ui->setupUi(this);
    memoria=new Memoria();
    scene = new QGraphicsScene(this);
    scene->setSceneRect(0, 0, 100, 100);
    ui->graphic->setScene(scene);


    polytri << QPointF(0,0) << QPointF(100,0) << QPointF(50,-86.6);
    polystar << QPointF(0,0) << QPointF(-11,37) << QPointF(-50,37) << QPointF(-19,59) << QPointF(-31,95) << QPointF(0,73.1) << QPointF(31,95) << QPointF(19,59) << QPointF(50,37) << QPointF(10,37);
    polypenta << QPointF(0,0) << QPointF(18.16,55.9) << QPointF(76.94,55.9) << QPointF(95.1,0) << QPointF(47.55,-34.55);
    polyhex << QPointF(0,0) << QPointF(-25,43.3) << QPointF(0,86.6) << QPointF(50,86.6) << QPointF(75,43.3) << QPointF(50,0);
    polyrhom << QPointF(0,0) << QPointF(-25,50) << QPointF(75,50) << QPointF(100,0);
    setExamples();


}

Logo::~Logo()
{
    delete ui;
}

//Esta funcion es para abrir un ventana emergente, es tulizado como un read en la maquina virtual
void Logo::saveRead(int dir, double value){
   memoria->save(dir, value);
}

//limpia la ventana cuando se le hace click a boton clear 
void Logo::on_clearButton_clicked()
{

    clearMessage();

}

//compila el codigo cuando se le hace click a boton compile
void Logo::on_compileButton_clicked()
{
    compeling();
    createMessage();
    setMessage();



}


//todos lo escrito en el text lo convierte en un archivo
void Logo::compeling(){
    QString document=ui->textProgram->toPlainText();
    QFile file("/home/ubuntu/Logo/in.pr");
    if (!file.open(QIODevice::WriteOnly))
        cout<<"no encontro el archivo";
    QTextStream out(&file);
    out<<document;
}

//esta funcion es para colocar ejemplos en el tab de examples, los ejemplos estan en un archivo
void Logo::setExamples(){
    QFile in("/home/ubuntu/Logo/muchoejemplos.txt");
    if (!in.open(QFile::ReadOnly | QFile::Text))
        cout<<"no encontro el archivo";
    QTextStream ReadFile(&in);
    ui->examplesText->setText(ReadFile.readAll());
}

//ejecuta desde comando nuestro compilador y lo manda a un archivo que contiene errores o si la funcion fue exitosa
void Logo::createMessage(){
    system("/home/ubuntu/Logo/compile/run /home/ubuntu/Logo/in.pr > /home/ubuntu/Logo/message.txt");


}


//abre el archivo message.txt y coloca los mensajes de error, print o compilacion exitosa en el tab de messages
void Logo::setMessage(){
    QFile in("/home/ubuntu/Logo/message.txt");
    if (!in.open(QFile::ReadOnly | QFile::Text))
        cout<<"no encontro el archivo";
    QTextStream ReadFile(&in);
    ui->textMessage->setText(ReadFile.readAll());

}

//Limpia el contenido del tab messages
void Logo::clearMessage(){
    ui->textMessage->setText("");
    QFile file("/home/ubuntu/Logo/message.txt");
    if (!file.open(QIODevice::WriteOnly | QIODevice::Text))
        cout<<"no encontro el archivo";
    QTextStream out(&file);
    out <<"";
}

//esta funcion de ejecuta cuando se le hace click a boton run
void Logo::on_runButton_clicked()
{
   MachineVirtual();
}



//dibuja las figuras dependiendo de los parametros que se le den, es usada en la maquina virtual
void Logo::dibujaFigura(int figura, int x, int y, int rotate, int scale, QBrush &colorFig,   QPen &colorThi, int sizex, int sizey){
    switch(figura){
    case 31:
        dot = scene->addLine(0, 0, 0.1, 0, colorThi);
        dot->resetTransform();
        dot->setPos(x,y);
        dot->setScale(scale);
        dot->setRotation(rotate);
        break;
    case 32:
        line = scene->addLine(x, y, sizex,sizey, colorThi);
        line->resetTransform();
        line->setScale(scale);
        line->setRotation(rotate);
        break;
    case 33:
        triangle = scene->addPolygon(polytri,colorThi,colorFig);
        triangle->resetTransform();
        triangle->setPos(x,y);
        triangle->setScale(scale);
        triangle->setRotation(rotate);
        break;
    case 34:
       rectangle = scene->addRect(0, 0, 50, 50, colorThi, colorFig);
       rectangle->resetTransform();
       rectangle->setPos(x,y);
       rectangle->setScale(scale);
       rectangle->setRotation(rotate);
        break;
    case 35:
        ellipse = scene->addEllipse(0,0,100,100, colorThi, colorFig);
        ellipse->resetTransform();
        ellipse->setPos(x,y);
        ellipse->setScale(scale);
        ellipse->setRotation(rotate);
        break;
    case 36:
        star = scene->addPolygon(polystar,colorThi,colorFig);
        star->resetTransform();
        star->setPos(x,y);
        star->setScale(scale);
        star->setRotation(rotate);
        break;
    case 37:
        pentagon = scene->addPolygon(polypenta,colorThi,colorFig);
        pentagon->resetTransform();
        pentagon->setPos(x,y);
        pentagon->setScale(scale);
        pentagon->setRotation(rotate);
        break;
    case 38:
        hexagon = scene->addPolygon(polyhex,colorThi,colorFig);
        hexagon->resetTransform();
        hexagon->setPos(x,y);
        hexagon->setScale(scale);
        hexagon->setRotation(rotate);
        break;
    case 39:
        rhomboid = scene->addPolygon(polyrhom,colorThi,colorFig);
        rhomboid->resetTransform();
        rhomboid->setPos(x,y);
        rhomboid->setScale(scale);
        rhomboid->setRotation(rotate);
        break;
    }


}


//hace una conversion de double a boolean para hacer comparaciones
bool Logo::atob(double a){
    if(a >= 1.0){
        return true;
    } else {
        return false;
    }
}



void Logo::MachineVirtual(){

    ui->textMessage->setText("Running...\n");

    memoria->salvarConstantes();

    double re;QString doc, s1;//allocation
    double value1, value2, temp, resul; int mod1, mod2, direccion;//expresiones
    bool logica;
    Input *read;//lectura
    int seguir; //entero donde seguira la funcion
    MemoriaLocales *memoria_locales;
    int Li, Ls;//Limites de los arreglos
    int valor1, valor2; //arreglos

    int program[1000][4];
    int instr=0;
    string line;
    ifstream myfile ("/home/ubuntu/Logo/Objecto.txt");

    if (myfile.is_open())
    {
      while ( getline (myfile,line) )
      {
          int lon = line.find("$");
          string operator_s = line.substr(0,lon);

          line=line.substr(line.find("$")+1);
          lon=line.find("$");
          string operando_1s = line.substr(0,lon);

          line=line.substr(line.find("$")+1);
          lon=line.find("$");
          string operando_2s = line.substr(0,lon);

          line=line.substr(line.find("$")+1);
          lon=line.find("$");
          string resul_s = line.substr(0,lon);

          int operator_i= atoi(operator_s.c_str());
          int operando_1i= atoi(operando_1s.c_str());
          int operando_2i= atoi(operando_2s.c_str());
          int resul_i= atoi(resul_s.c_str());

          program[instr][0]=operator_i;
          program[instr][1]=operando_1i;
          program[instr][2]=operando_2i;
          program[instr][3]=resul_i;

          instr++;


      }
      myfile.close();
    }

    else cout << "Unable to open file";

    //initializa atributos
    int x_position=0;
    int y_position=0;
    int sizex=0;
    int sizey=0;
    int rotate=0;
    int scale=1;

    QBrush colorFigure(Qt::yellow);
    QPen colorThick(Qt::black);

    //en cuanto ejecuta MemoriaVirtual() se limpia la ventana principal
        scene->clear();

        int cont=0;
        while(cont != 10000){
            int instruccion = program[cont][0];

            switch(instruccion){
        //GOtoMain
            case 0:
                cont=program[cont][3];
                break;
            //plus
            case 1:
                value1=memoria->get(program[cont][1]);
                value2=memoria->get(program[cont][2]);
                temp=program[cont][3];
                resul=value1+value2;
                memoria->save(temp,resul);
                cont++;
                break;
            //minus "-"
            case 2:;
                value1=memoria->get(program[cont][1]);
                value2=memoria->get(program[cont][2]);
                temp=program[cont][3];
                resul=value1-value2;
                memoria->save(temp,resul);
                cont++;
                break;
            //multiply "*"
            case 3:
                value1=memoria->get(program[cont][1]);
                value2=memoria->get(program[cont][2]);
                temp=program[cont][3];
                resul=value1*value2;
                memoria->save(temp,resul);
                cont++;
                break;
            //divide "/"
            case 4:
                value1=memoria->get(program[cont][1]);
                value2=memoria->get(program[cont][2]);
                temp=program[cont][3];
                resul=value1/value2;
                memoria->save(temp,resul);
                cont++;
                break;
            //module "%"
            case 5:;
                value1=memoria->get(program[cont][1]);
                value2=memoria->get(program[cont][2]);
                temp=program[cont][3];
                mod1=(int)value1;
                mod2=(int)value2;
                resul=mod1%mod2;
                memoria->save(temp,resul);
                cont++;
                break;
            //equal "=="
            case 6:
                value1=memoria->get(program[cont][1]);
                value2=memoria->get(program[cont][2]);
                temp=program[cont][3];
                logica=(value1==value2);
                memoria->save(temp,logica);
                cont++;
                break;
            //no equal "!="
            case 7:
                value1=memoria->get(program[cont][1]);
                value2=memoria->get(program[cont][2]);
                temp=program[cont][3];
                logica=(value1!=value2);
                memoria->save(temp,logica);
                cont++;
                break;
            //greater than ">"
            case 8:
                value1=memoria->get(program[cont][1]);
                value2=memoria->get(program[cont][2]);
                temp=program[cont][3];
                logica=(value1>value2);
                memoria->save(temp,logica);
                cont++;
                break;
            //less than "<"
            case 9:
                value1=memoria->get(program[cont][1]);
                value2=memoria->get(program[cont][2]);
                temp=program[cont][3];
                logica=(value1<value2);
                memoria->save(temp,logica);
                cont++;
                break;
            //greater or equal than ">="
            case 10:
                value1=memoria->get(program[cont][1]);
                value2=memoria->get(program[cont][2]);
                temp=program[cont][3];
                logica=(value1>=value2);
                memoria->save(temp,logica);
                cont++;
                break;
            //less or equal than "<="
            case 11:
                value1=memoria->get(program[cont][1]);
                value2=memoria->get(program[cont][2]);
                temp=program[cont][3];
                logica=(value1<=value2);
                memoria->save(temp,logica);
                cont++;
                break;
            //and
            case 12:
                value1=memoria->get(program[cont][1]);
                value2=memoria->get(program[cont][2]);
                temp=program[cont][3];
                logica=(atob(value1) && atob(value2));
                memoria->save(temp,logica);
                cont++;
                break;
            //or
            case 13:
                value1=memoria->get(program[cont][1]);
                value2=memoria->get(program[cont][2]);
                temp=program[cont][3];
                logica=(atob(value1) || atob(value2));
                memoria->save(temp,logica);
                cont++;
                break;
            //allocation "="
            case 14:
                value1= memoria->get(program[cont][1]);
                direccion=program[cont][3];
                memoria->save(direccion, value1);
                cont++;
                break;
            //read
            case 15:
                value1=program[cont][3];
                read=new Input(*this , value1, &Logo::saveRead);
                read->exec();
                delete read;
                cont++;
                break;
            //print
            case 16:
               re=memoria->get(program[cont][1]);
               doc=ui->textMessage->toPlainText();
               s1= QString::number(re);
               ui->textMessage->setText(doc+ s1 +"\n");
                cont++;
                break;
           //gotoFalse
            case 17:
                value1=memoria->get(program[cont][1]);
                value2=0;
                if(value1 == value2 )
                    cont=program[cont][3];
                else
                    cont++;
                break;
           //gotoFin en caso de IF ELSE y no entre al ELSE
            case 18:
                 cont=program[cont][3];
                break;
           //gotoRetorno en caso de regresare al principio del WHILE
            case 19:
                cont=program[cont][3];
                break;
            //GotoTrue tambien en case de DO WHILE
            case 20:
                value1=memoria->get(program[cont][1]);
                value2=1;
                if(value1 == value2 )
                    cont=program[cont][3];
                else
                    cont++;
                break;
            //retorno
            case 21:
                value1=memoria->get(program[cont][1]);
                direccion=program[cont][3];
                memoria->save(direccion, value1);
                cont++;
                break;
            //assig, asigna el valor del retorno del subproceso correspondiente a una temporal
            case 22:
                value1=memoria->get(program[cont][1]);
                direccion=program[cont][3];
                memoria->save(direccion, value1);
                cont++;
                break;
            //RET, sale del subproceso
            case 23:
                memoria->despertarMemoria();
                cont=memoria->memoriaActual->instruccion;
                break;
            //ERA, crea memoria
            case 24:
                memoria_locales=new MemoriaLocales();
                //memoria_locales->direccionFuncion=program[cont][1];
                cont++;
                break;
            //PARA, parametros para funciones que loss requieran
            case 25:
                value1=memoria->get(program[cont][1]);
                memoria_locales->save(program[cont][3]-18000,value1);
                cont++;
                break;
            //GOTOSUB, va al subproceso
            case 26:
                seguir = cont+1;
                memoria->memoriaActual->instruccion=seguir;
                memoria->dormirMemoria();
                memoria->colocarMemoria(memoria_locales);
                cont=program[cont][1];
                break;
            //ESTA CASE VA SER PARA INICIALIZAR LA FIGURA Y COLCARLA EN EL SCENE
            //DRAW
            case 30:
                x_position=0;
                y_position=0;
                sizex=0;
                sizey=0;
                rotate=0;
                scale=1;
                colorFigure.setColor(Qt::white);
                colorThick.setColor(Qt::black);
                cont++;
                break;
            //A PARTIR DE AQUI SE CAMBIAN LOS ATRIBUTOS DEPENDIENTE DE LOS QUE SE HAYA SALECCIONADO
            //x_position
            case 31:
                x_position=(int)memoria->get(program[cont][1]);
                cont++;
                break;
            //y_position
            case 32:
                y_position=(int)memoria->get(program[cont][1]);
                cont++;
                break;
            //rotate, antes rotateRight
            case 33:
                rotate=(int)memoria->get(program[cont][1]);
                 cont++;
                break;
            //rotateLeft -- ATENCION NO SIRVE
            case 34:
                //rotateLeft=(int)memoria->get(program[cont][1]);
                cont++;
                break;
            //size
            case 35:
                switch(program[cont][1]){
                case 1:
                    scale=1;//pequeño
                    break;
                case 2:
                    scale=2;//normal
                    break;
                case 3:
                    scale=3;//grande
                    break;
                }
                cont++;
                break;
            //thick
            case 36:
                 switch(program[cont][1]){
                 case 1:
                     colorThick.setStyle(Qt::SolidLine);
                     break;
                 case 2:
                     colorThick.setStyle(Qt::DashLine);
                     break;
                 case 3:
                     colorThick.setStyle(Qt::DotLine);
                     break;

            }
                cont++;
                break;
               //colorThick
            case 37:
                switch(program[cont][1]){
                case 1:
                    colorThick.setColor(Qt::blue);
                    break;
                case 2:
                    colorThick.setColor(Qt::yellow);
                    break;
                case 3:
                    colorThick.setColor(Qt::red);
                    break;
                case 4:
                    colorThick.setColor(QColor("#ff69b4")); //pink
                    break;
                case 5:
                    colorThick.setColor(QColor("#8b4513")); //brown
                    break;
                case 6:
                    colorThick.setColor(Qt::black);
                    break;
                case 7:
                    colorThick.setColor(Qt::white);
                    break;
                case 8:
                    colorThick.setColor(Qt::green);
                    break;
                case 9:
                    colorThick.setColor(Qt::gray);
                    break;
                case 10:
                    colorThick.setColor(QColor("#ffa500")); //orange
                    break;
                case 11:
                    colorThick.setColor(QColor("#a020f0")); //purple
                    break;
                }
                cont++;
                break;
            //colorFigure
            case 38:
                switch(program[cont][1]){
                case 1:
                    colorFigure.setColor(Qt::blue);
                    break;
                case 2:
                    colorFigure.setColor(Qt::yellow);
                    break;
                case 3:
                    colorFigure.setColor(Qt::red);
                    break;
                case 4:
                    colorFigure.setColor(QColor("#ff69b4")); //pink
                    break;
                case 5:
                    colorFigure.setColor(QColor("#8b4513")); //brown
                    break;
                case 6:
                    colorFigure.setColor(Qt::black);
                    break;
                case 7:
                    colorFigure.setColor(Qt::white);
                    break;
                case 8:
                    colorFigure.setColor(Qt::green);
                    break;
                case 9:
                    colorFigure.setColor(Qt::gray);
                    break;
                case 10:
                    colorFigure.setColor(QColor("#ffa500")); //orange
                    break;
                case 11:
                    colorFigure.setColor(QColor("#a020f0")); //purple
                    break;
                }
                cont++;
                break;
            //sizeX
            case 61:
                sizex=(int)memoria->get(program[cont][1]);
                cont++;
                break;
            //sizeY
            case 62:
                sizey=(int)memoria->get(program[cont][1]);
                cont++;
                break;
            //END
            //finalmente se dibujan las figuras en la ventana
            case 50:
                switch(program[cont][1]){
                case 41:
                    dibujaFigura(31, x_position, y_position, rotate, scale, colorFigure, colorThick, sizex, sizey);
                    break;
                case 42:
                     dibujaFigura(32, x_position, y_position, rotate, scale, colorFigure, colorThick, sizex, sizey);
                    break;
                case 43:
                    dibujaFigura(33, x_position, y_position, rotate, scale, colorFigure, colorThick, sizex, sizey);
                    break;
                case 44:
                    dibujaFigura(34, x_position, y_position, rotate, scale, colorFigure, colorThick, sizex, sizey);
                    break;
                case 45:
                    dibujaFigura(35, x_position, y_position, rotate, scale, colorFigure, colorThick, sizex, sizey);
                    break;
                case 46:
                    dibujaFigura(36, x_position, y_position, rotate, scale, colorFigure, colorThick, sizex, sizey);
                    break;
                case 47:
                    dibujaFigura(37, x_position, y_position, rotate, scale, colorFigure, colorThick, sizex, sizey);
                    break;
                case 48:
                    dibujaFigura(38, x_position, y_position, rotate, scale, colorFigure, colorThick, sizex, sizey);
                    break;
                case 49:
                    dibujaFigura(39, x_position, y_position, rotate, scale, colorFigure, colorThick, sizex, sizey);
                    break;
                }
                cont++;
                break;
            //Verifica
            case 51:
                value1=memoria->get(program[cont][1]);
                Li=program[cont][2];
                Ls=program[cont][3];
                if(!(value1 >= Li && value1 <= Ls)){
                    doc=ui->textMessage->toPlainText();
                    ui->textMessage->setText(doc +"Error de limite de memoria\n");
                    cont=99;
                }
                else cont++;
                break;
            //multiplica Array
            case 52:
                valor1=(int)(memoria->get(program[cont][1]));
                valor2=program[cont][2];
                resul=valor1*valor2;
                memoria->save(program[cont][3], resul);
                cont++;
                break;
            //suma Array
            case 53:
                valor1=(int)(memoria->get(program[cont][1]));
                valor2=(int)(memoria->get(program[cont][2]));
                resul=valor1+valor2;
                memoria->save(program[cont][3], resul);
                cont++;
                break;
            //Suma K
            case 54:
                valor1=(int)(memoria->get(program[cont][1]));
                valor2=program[cont][2];
                resul=valor1+valor2;
                memoria->save(program[cont][3], resul);
                cont++;
                break;
            case 55:
                valor1=(int)(memoria->get(program[cont][1]));
                valor2=program[cont][2];
                resul=valor1+valor2;
                memoria->saveApuntador(program[cont][3], resul);
                cont++;
                break;
            //end program
            case 99:
                doc=ui->textMessage->toPlainText();
                ui->textMessage->setText(doc + "end running");
                cont=10000;
                break;
            default:
                cont++;
                break;

            }
            //contador++;
        }
}