C++ Parser Operaciones Algebraicas Lineales archivo.txt

Un analizador sintáctico (en inglés parser) es una de las partes de un compilador que transforma su entrada en un árbol de derivación. El análisis sintáctico convierte el texto de entrada en otras estructuras (comúnmente árboles), que son más útiles para el posterior análisis y capturan la jerarquía implícita de la entrada. Un analizador léxico crea tokens de una secuencia de caracteres de entrada y son estos tokens los que son procesados por el analizador sintáctico para construir la estructura de datos, por ejemplo un árbol de análisis o árboles de sintaxis abstracta.

Source https://github.com/torukMnk/Q-parser

Archivo .txt

lado1=5;
lado2=86;
base=105;
color2=200;
calculo=lado1+lado2-base+300-100/color2-4;

Salida :: Q-Compiler ::

lado1=5;
lado2=86;
base=105;
color2=200;
calculo=-3.07;

q-compiler.cpp

/**
 * 
 * Desarrollador: Guillermo Quezada de Pedro
 * Sem: 6 Grupo "F"
 * Profesor: M.C. Benjamin Iglesias Cortes
 * 
 * */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <sstream>
#include <iostream>
#define MEM_LINES 128
#define MEM_VARIABLES 128
#define MEM_OPERATIONS 128

using namespace std;

class Compilation
{
  FILE *_file;
  long lSize;
  char *buffer;
  int char_count;
  size_t result;
  char *q_buffer;
  int q_count;
  int _line;
  int n_digit;

  struct lines
  {
    char line_data[MEM_VARIABLES];
    int len;
  }line[MEM_LINES];

  struct asignations
  {
    char variable[MEM_VARIABLES];
    float value;
    int len;
    int n_operators;
  }asignation[MEM_LINES];

  struct operations
  {
    char variable[MEM_VARIABLES];
    char _operator;
    float value;
    int line;
  }operation[MEM_OPERATIONS];

  public:

  void file_read(char file_name[])
  {
    _file = fopen(file_name,"rb");
    if (_file==NULL) {fputs ("File error",stderr); exit (1);}
    fseek(_file,0,SEEK_END);
    lSize = ftell(_file);
    rewind(_file);
    buffer = (char*)malloc(sizeof(char)*lSize);
    result = fread(buffer,1,lSize,_file);
    fclose (_file);
  }

  void file_compress()
  {
    q_count = 0;
    q_buffer = (char*)malloc(sizeof(char)*lSize);
    for(char_count = 0;char_count < lSize;char_count++)
    {
      if(buffer[char_count] != ' ' )
      {
        q_buffer[q_count] = buffer[char_count];
        q_count +=1;
      }
    }
    free(buffer);
  }

  void compile_lines()
  {
    memset( &line, 0, sizeof(line) );
    int _char;
    int _data;
    _line = 0;
    _data = 0;

    for(_char = 0; _char < q_count; _char++)
    {
      line[_line].line_data[_data] = q_buffer[_char];
      _data +=1;
      if( q_buffer[_char] == ';' )
      {
        line[_line].len = strlen(line[_line].line_data);
        _line +=1;
        _data = 0;
      }
    }
    free(q_buffer);
  }

  void compile_variables_assignation()
  {
    memset( &asignation, 0, sizeof(asignation) );
    int _char;
    int i;
    _char = 0;
    for(i=0;i < _line;i++)
    {
      while(line[i].line_data[_char] != '=')
      {
        asignation[i].variable[_char] = line[i].line_data[_char];
        _char +=1;
      };
      asignation[i].len = strlen(asignation[i].variable);
      _char = 0;
    }
  }

  void compile_variables_operation()
  {
    memset( &operation, 0, sizeof(operation) );
    int i;                  //Numero de Linea
    int len;                //Longitud de linea
    int k;                  //Lector de caracteres en la linea
    int _digit;             //Posicion de nuevo valor en la linea digit
    int _char;
    int count_as;           //Variables asignacion indirectas

    len = 0;
    n_digit = 0;
    _digit = 0;
    count_as = 0;

    for(i=0;i < _line; i++)
    {
      _char = asignation[i].len+1;
      len = line[i].len;

      for(k=0; k < len; k++)
      {
        if (isdigit(line[i].line_data[_char]))
        {
          operation[n_digit].variable[_digit] = line[i].line_data[_char];
          operation[n_digit].line = i;
          _digit +=1;
          _char+=1;
        }
        else if(isalpha(line[i].line_data[_char]))
        {
          operation[n_digit].variable[_digit] = line[i].line_data[_char];
          operation[n_digit].line = i;
          _digit +=1;
          _char+=1;
        }

        else
        {
          if(line[i].line_data[_char] != ';')
          {
            operation[n_digit+1]._operator = line[i].line_data[_char];
          }
          n_digit +=1;
          _digit = 0;
          _char +=1;
        }
        if(_char == len) k = len;
      }
    }

    //ASCII TO INTEGER
    for(i = 0; i < n_digit; i++)
    {
      operation[i].value = atoi(operation[i].variable);
    }

    //Operaciones Algebraicas Basicas(Lineal)
    float total;
    int n_operator;
    total = 0;
    n_operator = 0;
    for(i = 0; i < _line+1; i++)
    {
      for(k = 0; k < n_digit; k++)
      {
        if(operation[k].line == i)
        {
          if(isalpha(operation[k].variable[0]))
          {
            if(strcmp(operation[k].variable,asignation[k].variable))
            {
              operation[k].value = asignation[count_as].value;
              count_as += 1;
            }
          }

          n_operator +=1;
          asignation[i].n_operators = n_operator;
          if(operation[k]._operator == '\0')
          {
            total += operation[k].value;
            asignation[i].value = total;
          }
          if(operation[k]._operator == '+')
          {

            total += operation[k].value;
            asignation[i].value = total;
          }
          if(operation[k]._operator == '-')
          {
            total -= operation[k].value;
            asignation[i].value = total;
          }
          if(operation[k]._operator == '*')
          {
            total *= operation[k].value;
            asignation[i].value = total;
          }
          if(operation[k]._operator == '/')
          {
            total /= operation[k].value;
            asignation[i].value = total;
          }

        }
        else
        {
          total = 0;
          n_operator = 0;
        }
      }
    }
  }
  void q_file_make(char file_name[])
  {
    //Errores de visualizacion de SyntaxHighlighter
    //Funcion completa ->
    //https://github.com/torukMnk/Q-parser
  }

};

int main(void)
{
  Compilation com;
  char option;
  char name[16];

  do{
    //system("cls");   //Windows
    system("clear");   //Linux
    cout<<":: Q Compiler ::"<<"\n";
    cout<<"Nombre del archivo: ";
    cin>>name;
    cout<<'\n';
    com.file_read(name);
    com.file_compress();
    com.compile_lines();
    com.compile_variables_assignation();
    com.compile_variables_operation();
    com.q_file_make(name);

    cout<<"Desea compilar otro archivo: (Y/N): ";
    cin>>option;
    option = toupper(option);

  }while(option != 'N');
}

C++ Manejo de Cadenas

Manejo de Cadenas
Separacion Consonantes y Vocales
Separacion de Cadenas

#include 

using namespace std;

struct data{
    char cadenas[64];
}words[32];

void divition();
int main(void){

    char _string[64];
    cout<<"Escribe palabras maximo 32: ";
    cin.getline(_string,64);
    divition();

    /*
    *  Separar - Consonantes y Vocales
    */
    
    int cont;
    int len;

    char vocales[64];
    char consonantes[64];

    int count_v = 0;
    int count_c = 0;

    len = strlen(_string);
    _string[len] = ' ';

    for(cont= 0;cont < len; cont++)
    {
        if(_string[cont] == 'a' || _string[cont] == 'e' ||
           _string[cont] == 'i' || _string[cont] == 'o' || 
           _string[cont] == 'u')
        {
            vocales[count_v] = _string[cont];
            count_v +=1;
        }
        else
        {
            if(_string[cont] != ' ')
            {
                consonantes[count_c] = _string[cont];
                count_c += 1;
            }
        }
    }

    /*
    * Separar - Cadenas
    */

    int n_string = 0;
    int n_len = 0;
    for(cont = 0;cont <= len;cont++)
    {
        words[n_string].cadenas[n_len] = _string[cont];
        n_len +=1;
        if(_string[cont] == ' ')
        {
            n_string +=1;
            n_len = 0;
        }
    }
    
    /*
     * Separar -Mayusculas - Minusculas
     */

    char mixed[64];
    int val;
    
    for(cont = 0;cont < len; cont++)
    {
        val = cont%2;
        if(val == 0){ mixed[cont] = toupper(_string[cont]); }
        else{ mixed[cont] = tolower(_string[cont]); }
    }
    
 /*******************************************************/
    //Mostrar Cadenas
    for(cont = 0; cont < n_string; cont++){
        cout<<"Cadena["<<cont<<"]: "<<words[cont].cadenas<<endl;
    }
    divition();
    
    //Mostrar Vocales
    cout<<"Vocales: "<<endl;
    for(cont = 0; cont < count_v; cont++){ cout<<vocales[cont]; }
    cout<<endl;
    cout<<"Numero de Vocales: "<<count_v<<endl;
    divition();

    //Mostrar Consonantes
    cout<<"Consonantes"<<endl;
    for(cont = 0; cont < count_c; cont++){ cout<<consonantes[cont]; }
    cout<<endl;
    cout<<"Numero de consonantes: "<<count_c<<endl;
    divition();

    //Mostrar Mayusculas y Minusculas
    cout<<"Mayusculas - Minusculas"<<endl;
    for(cont = 0;cont < len; cont++){ cout<<mixed[cont]; }

    return 0;
}

void divition(){
    cout<<"============================================"<<endl;
}