IZP Projekt 4

/*
 * Soubor:  proj4.c
 * Datum:   16.12.2008
 * Autor:   David Sabata, xsabat01@stud.fit.vutbr.cz
 * Projekt: Razeni CSV dat
 * Popis:   Program radi data o osobach ze vstupniho souboru ve formatu CSV
 *          (carkami oddelene hodnoty), a to podle zvoleneho slozeneho klice.
 *          Je schopny radit podle vsech sloupcu vzestupne i sestupne a pri 
 *          razeni retezcovych dat dodrzuje normu pro razeni dat v ceskem jazyce
 *
 * Extra:   Je mozne spustit s parametrem -codepage a zvolit v jake znakove sade
 *          bude program pracovat (CP852, CP1250, ISO8859-2). Vice v napovede.    
 */
 
 
// prace se vstupem/vystupem
#include <stdio.h>
 
// obecne funkce jazyka C
#include <stdlib.h>
 
// kvuli funkci strcmp
#include <string.h>
 
// typ bool, konstanty true, false
#include <stdbool.h>
 
 
// Kody chyb a stavu programu
enum tcodes
{
   EOK = 0,    // Zadna chyba
   EEXIT,      // Pouze ukonceni, hlaska uz se vypsala
   EDEV,       // Pomocna chyba; u funkci, kde by mohla nastat chyba pri
               // nespravnych parametrech, ale pri beznem pouziti v tomto 
               // programu nenastava (kvuli znovupouzitelnosti)
   ECLWRONG,   // Nespravne parametry
   EBADKEY,    // Nespravne zadany slozeny klic
   EFINOPEN,   // Nelze otevrit vstupni soubor
   EFOUTOPEN,  // Nelze vytrvorit vystupni soubor
   EFCLOSE,    // Nepodarilo se uzavrit soubor
   EFOUTCLOSE, // Nepodarilo se uzavrit vystupni soubor
   EFBADINPUT, // Data v souboru nejsou ve spravnem formatu
   EMALLOC,    // Chyba alokace
};
 
// Pole textovych retezcu vypisovanych funkci printError
const char *EMSG[] =
{
   // EOK
   "Vse v poradku",
   // EEXIT
   "",
   // EDEV
   "Vnitrni chyba",
   // ECLWRONG
   "Nespravne parametry prikazoveho radku, pro napovedu pouzijte parametr -h",
   // EBADKEY
   "Nespravne zadany slozeny klic", 
   // EFINOPEN
   "Nepodarilo se otevrit soubor se vstupnimi daty",
   // EFOUTOPEN
   "Nepodarilo se vytvorit vystupni soubor",
   // EFCLOSE
   "Nepodarilo se uzavrit soubor",
   // EFOUTCLOSE
   "Nepodarilo se uzavrit vystupni soubor",
   // EFBADINPUT
   "Data ve vstupnim souboru nejsou ve spravnem formatu",   
   // EMALLOC
   "Chyba pri alokaci pameti",
};
 
// Maximalni pocet klicu podle kterych se radi
#define COLS 5
 
// Kolik znaku z kazdeho sloupce se pocita
#define MAXSTRLEN 21
 
// Akce - navratova hodnota funkce co kontroluje parametry
enum actions
{
   AHELP,
   AASC = -1,  // Hodnoty jsou dulezite pro radici funkci
   ADESC = 1
};
 
// Kodovani - pro oznaceni prevodnich tabulek
enum codepage
{
   CP852 = 0,
   ISO88592,
   CP1250
};
 
// Defaultni kodovani - pokud neni dane parametrem
#define DEFAULT_CODEPAGE ISO88592
 
// Primarni a sekundarni prekladova tabulka
enum table
{
   PRIM = 0,
   SEC = 1
};
 
// Struktura pro data polozky
typedef struct
{
   char prijmeni[MAXSTRLEN];
   char jmeno[MAXSTRLEN];
   char mesto[MAXSTRLEN];
   char pohlavi[2];
   unsigned long long int rodnecislo;  // Do unsg lng int se 10mistne RC nevejde      
} TData;
 
// Struktura pro polozku (obousmerny seznam)
typedef struct item
{
   TData data;
   struct item *next;
   struct item *prev;
} TItem;
 
// Struktura pro seznam
typedef struct 
{
   TItem *head;
   TItem *tail;
} TList;
 
////////////////////////////////////////////////////////////////////////////////
void printHelp();
void printError(int error);
void die(int error);
int loadParams(int argc, char *argv[]);
bool checkKey(char *argv);
void getKey(char *key, char *argv);
int getEncoding(int argc, char *argv[]);
 
bool loadList(TList *list, char *filename);
bool insertTail(TList *list, TData data);
void printList(TList *list);
bool saveList(TList *list, char *fname);
void freeList(TList *list);
 
void insertBubbleSort(TList *list, int dir, char *key, int enc);
 
int cmp(TData *data1, TData *data2, char *key, int enc);
int myNumCmp(unsigned long long int num1, unsigned long long int num2);
int myStrCmp(char *str1, char *str2, int enc);
////////////////////////////////////////////////////////////////////////////////
/**
 * Hlavni program.
 */
int main(int argc, char *argv[])
{
   // Napoveda nebo razeni ASC/DESC
   int action = loadParams(argc, argv);
 
   // Zjistime kodovani
   int enc = getEncoding(argc, argv);
 
   // Retezec pro uchovani slozeneho klice
   char key[COLS+1];
 
   switch (action)
   {
      case AHELP:
         printHelp();
         break;
      //------------------------------------------------------------------------   
      case AASC:
      case ADESC:
         if (checkKey(argv[1]) == false)
            die(EBADKEY);
         else
            getKey(key, argv[1]);
 
 
         TList list = {.head = NULL };
 
         // Nacist seznam ze vstupniho souboru argv[2]
         if (loadList(&list, argv[2])==false)
            die(EEXIT);         
 
         // Seradit
         insertBubbleSort(&list, action, key, enc);
 
         //printList(&list);
 
         // Ulozit
         if (saveList(&list, argv[3]) == false)
         {
            // Uvolnit pamet a ukoncit s chybou
            freeList(&list);
            die(EEXIT);
         }
 
         // Uvolnit pamet
         freeList(&list);
 
         break;            
   }
 
   return EXIT_SUCCESS;
}
////////////////////////////////////////////////////////////////////////////////
 
/**
 * Vytiskne napovedu
 * @return void  
 */
void printHelp()
{   
   printf(
      "Program pro razeni CSV seznamu\n"
      "Autor: David Sabata (c)2008\n"
      "Program radi data ze vstupniho souboru ve formatu CSV podle zvoleneho\n"
      "slozeneho klice a serazena data uklada do vystupniho souboru.\n\n"
      "proj4 [-h] [[+-]key=12345] [vst.soubor] [vyst.soubor] [-codepage CP]\n"
      "\t-h\tVypsani teto napovedy\n\n"
      "\tkey\tZadani slozeneho klice, + znaci vzestupne razeni, - sestupne.\n"
      "\t\tCisla znaci sloupce, podle kterych se bude radit. Sloupec\n"
      "\t\tvpravo ma nejvyssi prioritu.\n\n"
      "\tvst.soubor\tSoubor ze ktereho se budou cist data\n\n"
      "\tvyst.soubor\tSoubor do ktereho se budou zapisovat data\n\n"
      "\t-codepage CP\tDefinuje znakovou sadu ve ktere bude program pracovat.\n"
      "\t\t\tMozne hodnoty CP: cp852, iso88592, cp1250\n"
      "\t\t\tVychozi znakova sada je ISO8859-2"
   );
}
 
 
/**
 * Vytiskne chybovou hlasku, ale neukonci; pouziva se pokud ma chyba
 * vybublat do vyssi funkce ktera potrebuje neco uvolni/uzavrit 
 * @param code kod chyby nebo stavu programu
 * @return void 
 */
void printError(int error)
{  
   if (error != EEXIT)
      fprintf(stderr, "Chyba: %s\n", EMSG[error]);
}
 
/**
 * Vytiskne chybu a ukonci program
 * @param code kod chyby nebo stavu programu
 * @return void 
 */
void die(int error)
{   
   printError(error);
   exit(EXIT_FAILURE);
}
 
 
/**
 * Nacte parametry a vyhodnoti akci, pripadne chybu
 * @param argc int pocet parametru
 * @param argv char pole parametru
 * @return int akce ktera se ma provest   
 */ 
int loadParams(int argc, char *argv[])
{
   // Napoveda
   if (argc == 2 && strcmp("-h", argv[1]) == 0) 
      return AHELP;
 
   // Razeni vzestupne
   if ( (argc == 4 || (argc == 6 && strcmp("-codepage", argv[4]) == 0)) &&
        strncmp("+key=", argv[1], 5) == 0 && strlen(argv[1]) < = 5+COLS)
      return AASC;
 
   // Razeni sestupne
   if ( (argc == 4 || (argc == 6 && strcmp("-codepage", argv[4]) == 0)) &&
        strncmp("-key=", argv[1], 5) == 0 && strlen(argv[1]) <= 5+COLS)
      return ADESC;
 
   // Cokoliv jineho je chyba, vytiskneme hlasku o nespravnych parametrech,
   // coz zaroven ukonci program. Hodnota v returnu je pouze formalita. 
   die(ECLWRONG);
 
   return -1;
}
 
 
/**
 * Kontroluje jestli je slozeny klic spravne zadany, tj. nejvyse MAXKEY cislic
 * @param char *argv prvni parametr vcetne +-key=
 * @return bool
 */     
bool checkKey(char *argv) 
{
   // Inicializace pro 5, protoze prvnich 5 znaku klice je [+-]key=
   int len = strlen(argv);
   for (int i = 5; i < len; i++)
   {
      // Klice se cisluji od jednicky
      if (argv[i] < '1' || argv[i] >= '1'+COLS)
         return false;
   }
 
   return true;
}
 
 
/**
 * Nacte z parametru ciselnou hodnotu slozeneho klice a ulozi ji do 
 * retezce predaneho odkazem
 * @param char *key retezec do ktereho se ulozi klic
 * @param char *argv parametr, ze ktereho se klic nacita
 * @return void
 */     
void getKey(char *key, char *argv)
{   
   int len = strlen(argv);
   int j = 0;
 
   // Argv je ve tvaru '-key=12345', proto zaciname na 5, cimz se dostaneme
   // primo na ciselnou cast
   for(int i = 5; i<len ; i++)
   {
      key[j] = argv[i];
      j++;
   }  
 
   // Pridat ukoncovaci znak
   key[j] = '\0';
}
 
 
/**
 * Zkusi nacist z parametru kodovani, jinak vraci defaultni
 * @param int argc pocet parametru
 * @param char *argv[] pole parametru
 * @return int kodovani
 */    
int getEncoding(int argc, char *argv[])
{
   if (argc < 6 || strcmp("-codepage", argv[4]) != 0)
      return DEFAULT_CODEPAGE;
 
   if (strcmp("cp1250", argv[5]) == 0)
      return CP1250;
 
   if (strcmp("iso88592", argv[5]) == 0)
      return ISO88592;
 
   if (strcmp("cp852", argv[5]) == 0)
      return CP852;
 
   return DEFAULT_CODEPAGE;
}
 
////////////////////////////////////////////////////////////////////////////////
 
/**
 * Nacte ze zadaneho CSV souboru data do seznamu
 * @param TList *list linearni seznam
 * @param char *filename nazev souboru s daty
 * @return bool nastala chyba?
 */     
bool loadList(TList *list, char *filename)
{
   FILE *fp;
   // Otevreni souboru a kontrola
   fp = fopen(filename, "r");
   if (fp == NULL)
   {
      printf("%s\n", filename);
      printError(EFINOPEN);
      return false;
   }
 
   // Kontrolni pocet nactenych hodnot
   int check;    
 
   TData data;
 
   // Cyklus se prerusuje vnitrne, aby nemusel byt cely dlouhy
   // nacitaci vyraz v podmince
   while (true)   
   {
      // Nacist radek souboru 
      check = fscanf(fp, "%20[^,]%*c%20[^,]%*c%1s%*c%20[^,]%*c%10llu\n", 
         data.prijmeni, data.jmeno, data.pohlavi, data.mesto, &data.rodnecislo);
 
      // Jsme na konci souboru?
      if (check == EOF)
         break;
 
      // Nacetly se vsechny sloupce?
      if (check != COLS)
      {
         // Vypsat chybu, uzavrit soubor a vratit false
         printError(EFBADINPUT);
         printf("%i %s", check, data.prijmeni);
         if (fclose(fp) == EOF)
            printError(EFCLOSE);
 
         return false;
      }
 
      // Vlozit na konec seznamu
      if (insertTail(list, data) == false)
      {
         // Chyba uz se vypsala, uzavrit a vratit false
         if (fclose(fp) == EOF)
            printError(EFCLOSE);
 
         return false;
      }    
 
   }//while
 
   // Uzavrit soubor
   if (fclose(fp) == EOF)
   {
      printError(EFCLOSE); 
      return false;
   }
 
   return true;
}
 
 
/**
 * Vlozi TData na konec seznamu TList
 * @param TList *list odkaz na seznam
 * @param TData data data k vlozeni
 * @return bool
 */    
bool insertTail(TList *list, TData data)
{
   // Alokovat misto pro polozku
   TItem *newItem;
 
   newItem = malloc(sizeof(TItem));
 
   if (newItem == NULL)
   {
      printError(EMALLOC);
      return false;
   }
 
   // Vlozit data
   newItem->data = data;
   newItem->next = NULL;
 
   // Vlozit na konec seznamu
   if (list->tail != NULL)
   {
      newItem->prev = list->tail;
      list->tail->next = newItem;
      list->tail = newItem;
   }
   else // Pro prvni prvek
   {
      list->head = newItem;
      list->tail = newItem;
      newItem->prev = NULL;
   }
 
   return true;
}
 
/**
 * Vypise obsah seznamu
 * @param TList *list seznam k vypsani 
 * @return void 
 */ 
void printList(TList *list)
{
   for (TItem *tmp = list->head; tmp != NULL; tmp = tmp->next)
   {
      printf("%20s %20s %1s %20s %12llu\n", 
      tmp->data.prijmeni, tmp->data.jmeno, tmp->data.pohlavi, tmp->data.mesto, tmp->data.rodnecislo);  
   }   
}
 
 
/**
 * Ulozi seznam do souboru
 * @param TList *list seznam
 * @param char *fname nazev souboru
 * @return bool
 */    
bool saveList(TList *list, char *fname)
{   
   // Vytvorit soubor
   FILE *fp;      
   if ((fp = fopen(fname, "w")) == NULL)
   {
      printError(EFOUTOPEN);
      return false;
   } 
 
   // Vypsat zaznamy
   for (TItem *tmp = list->head; tmp != NULL; tmp = tmp->next)
   {
      fprintf(fp, "%s,%s,%s,%s,%llu\n", 
      tmp->data.prijmeni, tmp->data.jmeno, tmp->data.pohlavi, tmp->data.mesto, 
      tmp->data.rodnecislo);  
   }   
 
   // Uzavrit soubor
   if (fclose(fp) == EOF)
   {
      printError(EFOUTCLOSE);
      return false;
   }
 
   return true;
}
 
/**
 * Uvolni seznam z pameti
 * @param TList *list seznam k uvolneni
 * @return void 
 */   
void freeList(TList *list)
{
   TItem *item;
 
   while (list->head != NULL)
   {
      // Nacist prvek
      item = list->head;
      // Nastavit zacatek seznamu na dalsi polozku
      list->head = item->next;
      // Uvolnit pamet
      free(item);
   }   
}
 
////////////////////////////////////////////////////////////////////////////////
 
/**
 * Seradi seznam ve smeru dir (AASC|ADESC) podle slozeneho klice
 * @param TList *list seznam ktery se bude radit
 * @param int dir smer razeni AASC|ADESC
 * @param char *key slozeny klic - cisla sloupcu podle kterych se bude radit
 * @param int enc kodovani ktere se pouzije pri porovnavani 
 * @return void
 */     
void insertBubbleSort(TList *list, int dir, char *key, int enc)
{
   // Razeni ma smysl pouze pro seznam delky 2+
   if (list->head == list->tail)
      return;
 
   // Zarazka, pomocna polozka
   TData tmp;
 
   // Ukazovatka
   TItem *i = list->head->next;  // presouvany prvek
 
   while (i != NULL)
   {
      // Hodnota kterou budeme presouvat
      tmp = i->data;
 
      // Pomocna polozka pri hledani mista pro vkladany prvek
      TItem *j = i;            
 
      // Hledat misto a posouvat prvky
      // dir ma hodnotu AASC(-1) nebo ADESC(1) a porovnavaci funkce vraci
      // taky 1 a -1, cimz se radi vzestupne nebo sestupne
      while (j->prev != NULL && cmp(&tmp, &j->prev->data, key, enc) == dir)
      {
         // Odsunout prvek doprava (aby se udelalo misto pro vkladany)
         j->data = j->prev->data;         
 
         // hledani postupuje smerem doleva
         j = j->prev;                        
      }      
 
      // Vlozit na spravne misto
      j->data = tmp;
 
      // Posunout ukazovatko pro insert
      i = i->next;      
   }
 
}
 
 
/**
 * Porovnava datove struktury podle zadaneho slozeneho klice
 * @param TData *data1 prvni datova struktura 
 * @param TData *data2 druha datova struktura
 * @param char *key slozeny klic
 * @param int enc kodovani ktere se pouzije pri porovnavani 
 * @return int 0 pro shodne, -1 pokud je prvni mensi, 1 pokud je druhy mensi
 */  
int cmp(TData *data1, TData *data2, char *key, int enc)
{
   int len = strlen(key);
 
   // Vysledek porovnani
   int comp;
 
   for (int i = 0; i < len; i++)
   {      
      // Porovnavani podle cisla sloupcu
      switch(key[i])
      {
         // Prijmeni
         case '1':
            comp = myStrCmp(data1->prijmeni, data2->prijmeni, enc);
            break;
         // Jmeno
         case '2':
            comp = myStrCmp(data1->jmeno, data2->jmeno, enc);
            break;
         // Pohlavi
         case '3':
            comp = myStrCmp(data1->pohlavi, data2->pohlavi, enc);
            break;
         // Mesto
         case '4':
            comp = myStrCmp(data1->mesto, data2->mesto, enc);
            break;
         // Rodne cislo
         case '5':            
            comp = myNumCmp(data1->rodnecislo, data2->rodnecislo);
            break;      
      }
 
      // Povedlo seradit ? vratit vysledek : jinak radit podle dalsiho sloupce
      if (comp != 0)
         return comp;            
   }
 
   // Nepodarilo se seradit podle zadneho sloupce, zaznamy jsou naprosto stejne
   return 0;
}
 
 
/**
 * Porovnava dve cisla
 * @param unsigned long int num1 prvni cislo
 * @param unsigned long int num2 druhe cislo
 * @return int 0 pro stejne, -1 pokud je prvni mensi, 1 pokud je prvni vetsi
 */    
int myNumCmp(unsigned long long int num1, unsigned long long int num2)
{
   if (num1 < num2)
      return -1;
   if (num1 > num2)
      return 1;
 
   return 0;
}
 
 
// Prekladove tabulky obsahuji "ohodnoceni" znaku, podle nehoz se znaky radi.
// Stejnou hodnotu maji velka i mala provedeni daneho znaku. Pro CH je vzdy
// rezervovano jedno misto. Vynechany jsou cisla a jine specialni znaky, ktere
// se nemohou vyskytovat ani v jednom z testovanych retezcu.
#define CHR_CH 10
 
 
// Primarni prekladova tabulka pro CP852
const int primCP852[256] = {
   [0x00] = 0,    [0x20] = 0,    [0xFF] = 0,                   //Mezera, \0
   [0x41] = 1,    [0x61] = 1,    [0xA0] = 1,    [0xB5] = 1,    //A   
   [0x42] = 2,    [0x62] = 2,                                  //B
   [0x43] = 3,    [0x63] = 3,                                  //C
   [0xAC] = 4,    [0x9F] = 4,                                  //C s hackem
   [0x44] = 5,    [0x64] = 5,    [0xD2] = 5,    [0xD4] = 5,    //D
   [0x45] = 6,    [0x65] = 6,    [0xB7] = 6,    [0xD8] = 6,    //E
                                 [0x90] = 6,    [0x82] = 6,
   [0x46] = 7,    [0x66] = 7,                                  //F
   [0x47] = 8,    [0x67] = 8,                                  //G
   [0x48] = 9,    [0x68] = 9,                                  //H
   [0x01] = CHR_CH,   //CH - s hodnotou 0x01 se neporovnava, jen drzi misto
   [0x49] = 11,   [0x69] = 11,   [0xD6] = 11,   [0xA1] = 11,   //I
   [0x4A] = 12,   [0x6A] = 12,                                 //J
   [0x4B] = 13,   [0x6B] = 13,                                 //K
   [0x4C] = 14,   [0x6C] = 14,                                 //L
   [0x4D] = 15,   [0x6D] = 15,                                 //M
   [0x4E] = 16,   [0x6E] = 16,   [0xD5] = 16,   [0xE5] = 16,   //N
   [0x4F] = 17,   [0x6F] = 17,   [0xE0] = 17,   [0xA2] = 17,   //O
   [0x50] = 18,   [0x70] = 18,                                 //P
   [0x51] = 19,   [0x71] = 19,                                 //Q
   [0x52] = 20,   [0x72] = 20,                                 //R
   [0xFC] = 21,   [0xFD] = 21,                                 //R s hackem
   [0x53] = 22,   [0x73] = 22,                                 //S
   [0xE6] = 23,   [0xE7] = 23,                                 //S s hackem
   [0x54] = 24,   [0x74] = 24,   [0x9B] = 24,   [0x9C] = 24,   //T
   [0x55] = 25,   [0x75] = 25,   [0xDE] = 25,   [0x85] = 25,   //U
                                 [0xE9] = 25,   [0xA3] = 25,
   [0x56] = 26,   [0x76] = 26,                                 //V
   [0x57] = 27,   [0x77] = 27,                                 //W
   [0x58] = 28,   [0x78] = 28,                                 //X
   [0x59] = 29,   [0x79] = 29,   [0xED] = 29,   [0xEC] = 29,   //Y
   [0x5A] = 30,   [0x7A] = 30,                                 //Z
   [0xA6] = 31,   [0xA7] = 31,                                 //Z s hackem
   [0x2E] = 32,                                                //tecka
   [0x2D] = 33,                                                //pomlcka
};
 
// Sekundarni prekladova tabulka pro CP852 - jen znaky ktere se v primarni
// tabulce prekryvaly
const int secCP852[256] = {
   [0x41] = 1,    [0x61] = 1,    //A
   [0xA0] = 2,    [0xB5] = 2,    //A s carkou   
   [0x44] = 3,    [0x64] = 3,    //D
   [0xD2] = 4,    [0xD4] = 4,    //D s hackem
   [0x45] = 5,    [0x65] = 5,    //E
   [0x90] = 6,    [0x82] = 6,    //E s carkou
   [0xB7] = 7,    [0xD8] = 7,    //E s hackem
   [0x49] = 8,    [0x69] = 8,    //I
   [0xD6] = 9,    [0xA1] = 9,    //I s carkou
   [0x4E] = 10,   [0x6E] = 10,   //N
   [0xD5] = 11,   [0xE5] = 11,   //N s hackem
   [0x4F] = 12,   [0x6F] = 12,   //O
   [0xE0] = 13,   [0xA2] = 13,   //O s carkou   
   [0x54] = 14,   [0x74] = 14,   //T
   [0x9B] = 15,   [0x9C] = 15,   //T s hackem
   [0x55] = 16,   [0x75] = 16,   //U
   [0xE9] = 17,   [0xA3] = 17,   //U s carkou
   [0xDE] = 18,   [0x85] = 18,   //U s krouzkem
   [0x59] = 19,   [0x79] = 19,   //Y
   [0xED] = 20,   [0xEC] = 20,   //Y s carkou   
};
//------------------------------------------------------------------------------
 
// Primarni prekladova tabulka pro ISO88592
const int primISO88592[256] = {
   [0x00] = 0,    [0x20] = 0,    [0xA0] = 0,                   //Mezera, \0
   [0x41] = 1,    [0x61] = 1,    [0xC1] = 1,    [0xE1] = 1,    //A   
   [0x42] = 2,    [0x62] = 2,                                  //B
   [0x43] = 3,    [0x63] = 3,                                  //C
   [0xC8] = 4,    [0xE8] = 4,                                  //C s hackem
   [0x44] = 5,    [0x64] = 5,    [0xCF] = 5,    [0xEF] = 5,    //D
   [0x45] = 6,    [0x65] = 6,    [0xCC] = 6,    [0xEC] = 6,    //E
                                 [0xC9] = 6,    [0xE9] = 6,
   [0x46] = 7,    [0x66] = 7,                                  //F
   [0x47] = 8,    [0x67] = 8,                                  //G
   [0x48] = 9,    [0x68] = 9,                                  //H
   [0x01] = CHR_CH,   //CH - s hodnotou 0x01 se neporovnava, jen drzi misto
   [0x49] = 11,   [0x69] = 11,   [0xCD] = 11,   [0xED] = 11,   //I
   [0x4A] = 12,   [0x6A] = 12,                                 //J
   [0x4B] = 13,   [0x6B] = 13,                                 //K
   [0x4C] = 14,   [0x6C] = 14,                                 //L
   [0x4D] = 15,   [0x6D] = 15,                                 //M
   [0x4E] = 16,   [0x6E] = 16,   [0xD2] = 16,   [0xF2] = 16,   //N
   [0x4F] = 17,   [0x6F] = 17,   [0xD3] = 17,   [0xF3] = 17,   //O
   [0x50] = 18,   [0x70] = 18,                                 //P
   [0x51] = 19,   [0x71] = 19,                                 //Q
   [0x52] = 20,   [0x72] = 20,                                 //R
   [0xD8] = 21,   [0xF8] = 21,                                 //R s hackem
   [0x53] = 22,   [0x73] = 22,                                 //S
   [0xA9] = 23,   [0xB9] = 23,                                 //S s hackem
   [0x54] = 24,   [0x74] = 24,   [0xAB] = 24,   [0xBB] = 24,   //T
   [0x55] = 25,   [0x75] = 25,   [0xD9] = 25,   [0xF9] = 25,   //U
                                 [0xDA] = 25,   [0xFA] = 25,
   [0x56] = 26,   [0x76] = 26,                                 //V
   [0x57] = 27,   [0x77] = 27,                                 //W
   [0x58] = 28,   [0x78] = 28,                                 //X
   [0x59] = 29,   [0x79] = 29,   [0xDD] = 29,   [0xFD] = 29,   //Y
   [0x5A] = 30,   [0x7A] = 30,                                 //Z
   [0xAE] = 31,   [0xBE] = 31,                                 //Z s hackem
   [0x2E] = 32,                                                //tecka
   [0x2D] = 33,                                                //pomlcka
};
 
// Sekundarni prekladova tabulka pro ISO88592 - jen znaky ktere se v primarni
// tabulce prekryvaly
const int secISO88592[256] = {
   [0x41] = 1,    [0x61] = 1,    //A
   [0xC1] = 2,    [0xE1] = 2,    //A s carkou   
   [0x44] = 3,    [0x64] = 3,    //D
   [0xCF] = 4,    [0xEF] = 4,    //D s hackem
   [0x45] = 5,    [0x65] = 5,    //E
   [0xC9] = 6,    [0xE9] = 6,    //E s carkou
   [0xCC] = 7,    [0xEC] = 7,    //E s hackem
   [0x49] = 8,    [0x69] = 8,    //I
   [0xCD] = 9,    [0xED] = 9,    //I s carkou
   [0x4E] = 10,   [0x6E] = 10,   //N
   [0xD2] = 11,   [0xF2] = 11,   //N s hackem
   [0x4F] = 12,   [0x6F] = 12,   //O
   [0xD3] = 13,   [0xF3] = 13,   //O s carkou   
   [0x54] = 14,   [0x74] = 14,   //T
   [0xAB] = 15,   [0xBB] = 15,   //T s hackem
   [0x55] = 16,   [0x75] = 16,   //U
   [0xDA] = 17,   [0xFA] = 17,   //U s carkou
   [0xD9] = 18,   [0xF9] = 18,   //U s krouzkem
   [0x59] = 19,   [0x79] = 19,   //Y
   [0xDD] = 20,   [0xFD] = 20,   //Y s carkou   
};
 
//------------------------------------------------------------------------------
 
// Primarni prekladova tabulka pro CP1250
const int primCP1250[256] = {
   [0x00] = 0,    [0x20] = 0,    [0xA0] = 0,                   //Mezera, \0
   [0x41] = 1,    [0x61] = 1,    [0xC1] = 1,    [0xE1] = 1,    //A   
   [0x42] = 2,    [0x62] = 2,                                  //B
   [0x43] = 3,    [0x63] = 3,                                  //C
   [0xC8] = 4,    [0xE8] = 4,                                  //C s hackem
   [0x44] = 5,    [0x64] = 5,    [0xCF] = 5,    [0xEF] = 5,    //D
   [0x45] = 6,    [0x65] = 6,    [0xCC] = 6,    [0xEC] = 6,    //E
                                 [0xC9] = 6,    [0xE9] = 6,
   [0x46] = 7,    [0x66] = 7,                                  //F
   [0x47] = 8,    [0x67] = 8,                                  //G
   [0x48] = 9,    [0x68] = 9,                                  //H
   [0x01] = CHR_CH,   //CH - s hodnotou 0x01 se neporovnava, jen drzi misto
   [0x49] = 11,   [0x69] = 11,   [0xCD] = 11,   [0xED] = 11,   //I
   [0x4A] = 12,   [0x6A] = 12,                                 //J
   [0x4B] = 13,   [0x6B] = 13,                                 //K
   [0x4C] = 14,   [0x6C] = 14,                                 //L
   [0x4D] = 15,   [0x6D] = 15,                                 //M
   [0x4E] = 16,   [0x6E] = 16,   [0xD2] = 16,   [0xF2] = 16,   //N
   [0x4F] = 17,   [0x6F] = 17,   [0xD3] = 17,   [0xF3] = 17,   //O
   [0x50] = 18,   [0x70] = 18,                                 //P
   [0x51] = 19,   [0x71] = 19,                                 //Q
   [0x52] = 20,   [0x72] = 20,                                 //R
   [0xD8] = 21,   [0xF8] = 21,                                 //R s hackem
   [0x53] = 22,   [0x73] = 22,                                 //S
   [0xA9] = 23,   [0xB9] = 23,                                 //S s hackem
   [0x54] = 24,   [0x74] = 24,   [0x8D] = 24,   [0x9D] = 24,   //T
   [0x55] = 25,   [0x75] = 25,   [0xD9] = 25,   [0xF9] = 25,   //U
                                 [0xDA] = 25,   [0xFA] = 25,
   [0x56] = 26,   [0x76] = 26,                                 //V
   [0x57] = 27,   [0x77] = 27,                                 //W
   [0x58] = 28,   [0x78] = 28,                                 //X
   [0x59] = 29,   [0x79] = 29,   [0xDD] = 29,   [0xFD] = 29,   //Y
   [0x5A] = 30,   [0x7A] = 30,                                 //Z
   [0xAE] = 31,   [0xBE] = 31,                                 //Z s hackem
   [0x2E] = 32,                                                //tecka
   [0x2D] = 33,                                                //pomlcka
};
 
// Sekundarni prekladova tabulka pro CP1250 - jen znaky ktere se v primarni
// tabulce prekryvaly
const int secCP1250[256] = {
   [0x41] = 1,    [0x61] = 1,    //A
   [0xC1] = 2,    [0xE1] = 2,    //A s carkou   
   [0x44] = 3,    [0x64] = 3,    //D
   [0xCF] = 4,    [0xEF] = 4,    //D s hackem
   [0x45] = 5,    [0x65] = 5,    //E
   [0xC9] = 6,    [0xE9] = 6,    //E s carkou
   [0xCC] = 7,    [0xEC] = 7,    //E s hackem
   [0x49] = 8,    [0x69] = 8,    //I
   [0xCD] = 9,    [0xED] = 9,    //I s carkou
   [0x4E] = 10,   [0x6E] = 10,   //N
   [0xD2] = 11,   [0xF2] = 11,   //N s hackem
   [0x4F] = 12,   [0x6F] = 12,   //O
   [0xD3] = 13,   [0xF3] = 13,   //O s carkou   
   [0x54] = 14,   [0x74] = 14,   //T
   [0x8D] = 15,   [0x9D] = 15,   //T s hackem
   [0x55] = 16,   [0x75] = 16,   //U
   [0xDA] = 17,   [0xFA] = 17,   //U s carkou
   [0xD9] = 18,   [0xF9] = 18,   //U s krouzkem
   [0x59] = 19,   [0x79] = 19,   //Y
   [0xDD] = 20,   [0xFD] = 20,   //Y s carkou   
};
 
 
// Pro zjednoduseni pristupu
const int *transCP852[] = { [PRIM] = primCP852, [SEC] = secCP852 };
const int *transISO88592[] = { [PRIM] = primISO88592, [SEC] = secISO88592 };
const int *transCP1250[] = { [PRIM] = primCP1250, [SEC] = secCP1250 };
 
const int **table[] = { [CP852] = transCP852, [ISO88592] = transISO88592,
                        [CP1250] = transCP1250 };
 
/**
 * Porovnava dva retezce
 * @param char *str1 prvni retezec
 * @param char *str2 druhy retezec
 * @param int enc kodovani retezcu 
 * @return int 0 pro stejne, -1 pokud je prvni mensi, 1 pokud je prvni vetsi
 */
int myStrCmp(char *str1, char *str2, int enc)
{
   // Protoze je v tabulce i \0 je mozne pouzit delku kterehokoliv z retezcu
   int len1 = strlen(str1);
 
   int val1, val2;
 
   // Radit postupne pro obe tabulky
   for (int tab = PRIM; tab < = SEC; tab++)
   {
      // Razeni - vcetne ukoncovaciho znaku!
      for (int i = 0; i<=len1; i++)
      {
         //Fix pro CH
         if ( (str1[i] == 'C' || str1[i] == 'c') && 
              (str1[i+1] == 'H' || str1[i+1] == 'h'))
            val1 = CHR_CH;
         else
            val1 = table[enc][tab][(unsigned char)str1[i]];
 
         // Fix pro CH
         if ( (str2[i] == 'C' || str2[i] == 'c') && 
              (str2[i+1] == 'H' || str2[i+1] == 'h'))
            val2 = CHR_CH;
         else
            val2 = table[enc][tab][(unsigned char)str2[i]];
 
         // Porovnat vahy
         if (val1 < val2)
            return -1;
         if (val1 > val2)
            return 1;
      }
   }
 
   return 0;
}