comun.cpp

Ir a la documentación de este archivo.

// vim: set expandtab tabstop=8 shiftwidth=8 foldmethod=marker:
#include <set>
#include <iostream>
#include <iomanip>
#include <list>
#include <vector>
#include <fstream>
#include <istream>
#include <sstream>

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <err.h>

// using namespace std;
// La anterior comentada por poco portable

#include "comun.hpp"


vector<string> estalla(const string &delimitador, const string &cad)
{
        vector<string> arr;

        int cadlong = cad.length();
        int dellong = delimitador.length();
        if (dellong == 0)
                return arr;

        int i = 0;
        int k = 0;
        while( i < cadlong ) {
                int j=0;
                while (i + j < cadlong && j < dellong && cad[i + j] == delimitador[j]) {
                        j++;
                }
                if (j == dellong) {
                        arr.push_back( cad.substr(k, i-k) );
                        i += dellong;
                        k = i;
                } else {
                        i++;
                }
        }
        arr.push_back(cad.substr(k, i-k) );

        return arr;
}

void verificaNombre(const char *na, char *nrel)
{
        ASSERT(na != NULL);
        ASSERT(nrel != NULL);
        /*      nrel[MAXLURL - 1] = '\0';
                ASSERT(nrel[MAXLURL - 1] == '\0'); */

        if (strcmp(na + (strlen(na) - 7), ".indice") != 0) {
                stringstream ss;
                ss << "Se esperaba extensión .indice de '" << na << "'" ;
                throw ss.str();
        }
        if (strlen(na) > MAXLURL - 3) {
                stringstream ss;
                ss << "Nombre de archivo excede "
                << MAXLURL - 3 << " caracteres" ;
                throw ss.str();
        }
        strlcpy(nrel, na, strlen(na) - 6);
        strlcat(nrel, ".relacion", MAXLURL);
}

string
prefijo_comun_mas_largo(string a, string b)
{
        int c;
        int m = min(min(a.size(), b.size()), (unsigned long)MAXCAD);
        for (c = 0 ; c < m && a[c] == b[c] ; c++) {}
        return a.substr(0, c);
}

std::string errorFormato(std::istream &is, string m)
{
        stringstream r;
        r << max(0L, (long)is.tellg() - 1) << ": " << m;
        return r.str();
}

string leeCad(std::istream &is) throw(string)
{
        int c = is.get();
        string cad = "";
        if (c == '\n' || c == EOF) {
                return "";
        }
        while (c != FINCADENA && c != EOF && cad.size() < MAXCAD) {
                cad += c;
                c = is.get();
        }
        if (cad.size() >= MAXCAD) {
                cerr << "No se indexó completa palabra larga: " << cad << endl;
                while (c != FINCADENA && c != EOF) {
                        c =  is.get();
                }
        }
        if (c != FINCADENA) {

                throw errorFormato(is, string("Se esperaba ") + FINCADENA);
        }
        return cad;
}

long
leeHex(std::istream &is) throw(std::string)
{
        unsigned int i;
        long valor = 0;
        int c = 0;

        //clog << "OJO leeHex..." << endl;
        for (i = 0; i < (int)MAXLHEX; i++) {
                c = is.get();
                //clog << "OJO leeHex i=" << i << ", c=" << (char)c << endl;
                if (c == EOF) {
                        std::stringstream ss;
                        ss << "Se esperaban " << MAXLHEX << " digitos no " << i;
                        throw errorFormato(is, ss.str());
                }
                if ((c < '0' || c > '9') && (c < 'a' || c > 'f')) {
                        throw errorFormato(is, "Se esperaba digito hexadecimal");
                }
                valor = valor * 16 + ((c >= '0' && c <= '9') ?
                                      c - '0' : c - 'a' + 10);
                //clog << "OJO leeHex valor=" << valor << endl;
        }

        return valor;
}


/*
 * Escribe en os un entero como hexadecimal de 8 digitos.
 * @param n Entero, debe ser menor o igual a 0xffffffff
 */
void escribeHex(std::ostream &os, unsigned long n)
{
        ASSERT(n <= 0xffffffff);
        os << setfill('0') << setw(8) << setbase(16) << n ;
}


void escribe128b(std::ostream &os, unsigned long n)
{
        // clog << "OJO escribe128b n=" << n << endl;
        ASSERT(n <= 0xffffffff);
        string res = "";
        unsigned long c = n;

        for (int i = 0; i<MAXL128B; i++) {
                char r = (c % 128) + '0';
                res = r + res;
                c = c / 128;
        }

        os << res;
}


long
lee128b(std::istream &is) throw (std::string)
{
        int i;
        long valor = 0;
        int c = 0;

        for (i = 0; i < (int)MAXL128B; i++) {
                c = is.get();
                //clog << "OJO lee128bx c=" << c << endl;
                if (c == EOF) {
                        std::stringstream ss;
                        ss << "Se esperaban  " << MAXL128B << " digitos, no " << i;
                        throw errorFormato(is, ss.str());
                }

                if (c < '0' || c > ('0' + 127)) {
                        throw errorFormato(is, "Se esperaba digito 128b");
                }
                valor = valor * 128 + (c - '0');
        }


        return valor;
}


string normalizaCaracter(char c)
{
        string o = "";
        if ((c >= 'A' && c <= 'Z') ||
                        (c >= '0' && c <= '9') ) { //Mayúsculas
                o += c;
        }
        if (c >= 'a' && c <= 'z') { //Minúsculas pasan a mayúsculas
                o += (c - ('a' - 'A'));
        } else if (c == 'á' || c == 'Á') { // Tildes
                o += 'A';
        } else if (c == 'é' || c == 'É') { // Tildes
                o += 'E';
        } else if (c == 'í' || c == 'Í') { // Tildes
                o += 'I';
        } else if (c == 'ó' || c == 'Ó') { // Tildes
                o += 'O';
        } else if (c == 'ú' || c == 'Ú') { // Tildes
                o += 'U';
        } else if (c == 'ü' || c == 'Ü') { // Dieresis
                o += 'U';
        } else if (c == 'ñ') {
                o += 'Ñ';
        }
        // Lo demás se ignora
        return o;
}

const int tamnoagregan = 40;
string noagregan[tamnoagregan] = {

                                         "Y",  // Conjunciones
                                         "O",
                                         "EL", // Artículos
                                         "LA",
                                         "LOS",
                                         "LAS",
                                         "UN",
                                         "UNA",
                                         "UNOS",
                                         "UNAS",
                                         "A", // Preposiciones http://www.apoyolingua.com/LASPREPOSICIONES.htm
                                         "ANTE",
                                         "BAJO",
                                         "CON",
                                         "CONTRA",
                                         "DE",
                                         "DESDE",
                                         "DURANTE",
                                         "EN",
                                         "ENTRE",
                                         "HACIA",
                                         "HASTA",
                                         "MEDIANTE",
                                         "PARA",
                                         "POR",
                                         "SEGUN",
                                         "SIN",
                                         "SOBRE",
                                         "TRAS",
                                         "QUE", //Otros
                                         "LE",
                                         "LES",
                                         "DEL",
                                         "AL",
                                         "CUANDO",
                                         "SU",
                                         "SUS",
                                         "COMO",
                                         "O",
                                         "MAS"
                                 };



string normaliza(string s)
{

        string::iterator i;
        string o = "";
        int c;
        for (c = 0, i = s.begin(); i != s.end() && c <= (int)MAXCAD;
                        c++ , i++) {
                if (*i == '.' && (i+1 != s.end()) &&
                                (normalizaCaracter(*(i+1)) != "")) {
                        o += ".";
                } else {
                        o += normalizaCaracter(*i);
                }
        }

        for (int i = 0; i < tamnoagregan; i++) {
                if (o == noagregan[i]) {
                        return string("");
                }
        }

        return o;
}


int car_utf8_a_latin1(const char *u8, char *latin1)
{
        ASSERT(u8 != NULL);
        ASSERT(latin1 != NULL);
        ASSERT(u8[0] != '\0');
        int num;

        /*      clog << "car_utf8_a_latin1(\"" << u8 << "\")" << endl;
                clog << "ascii *u8=" << (unsigned int)(*u8) << endl;
                clog << "*u8 & 0xc0=" << ((unsigned int)*u8 & 0xc0) << endl; */

        /*if (*u8 & 0x80) {
        } else*/
        if ((((unsigned int)*u8 & 0xc0) == 0xc0) && u8[1] != '\0') {
                *latin1 = u8[0] << 6 | (u8[1] & 0x3f);
                num = 2;
        } else {
                *latin1 = *u8;
                num = 1;
        }

        //clog << "car_utf8_a_latin1 por salir con num=" << num << " y *latin1 ='" << *latin1 << "'" << endl;
        return num;
}

string utf8_a_latin1(const char *u8, int len)
{
        ASSERT(u8 != NULL);
        ASSERT(len >= 0);
        string r = "";

        /*clog << "utf8_a_latin1(\"" << u8 << "\", "<< len << ")" << endl;*/
        char *i = (char *)u8;
        while (*i != '\0' && i - u8 < len) {
                char latin1;
                int nb = car_utf8_a_latin1(i, &latin1);
                i += nb;
                r += latin1;
                //clog << "OJO tras iteracion i = '" << i << "', r='" << r << "'" << endl;
        }
        r += "";
        return r;
}


string
directorio_temp()
{
        //clog << "OJO directorio_tempo()" << endl;
        char sfn[100];

        strlcpy(sfn, "/tmp/leeXXXXXX", sizeof(sfn));
        if (mkdtemp(sfn) == NULL) {
                stringstream ss;
                ss << strerror(errno);
                throw ss.str();
        }
        return string(sfn);
}

---