str.c

/*******************************************************************************
*  
*  Implementace prekladace imperativniho jazyka IFJ 09
*  
*  xkubis03 - Radim Kubis
*  xbrene02 - Brenek Roman
*  xblaho01 - Blaho Vojtech
*  xlukas07 - Lukas Radek
*
*******************************************************************************/

// Knihovna pro práci s nekonečně dlouhými řetězci
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#include <stdio.h>
#include "str.h"

#define STR_LEN_INC 8
// Konstanta STR_LEN_INC udává, na kolik bytů provedeme počateční alokaci paměti
// Pokud načítáme řetězec znak po znaku, paměť se postupně bude alokovat na
// násobky tohoto čísla

int strInit(string *s)
// Funkce vytvoří nový řetězec
{
   if((s->str = (char*)malloc(STR_LEN_INC)) == NULL)  // Alokace a její kontrola
      return STR_ERROR;  // Při neúspěšné alokaci vracím chybu

   s->str[0] = '\0';  // Nastavím první znak na nulový -> prázdný řetězec
   s->length = 0;  // Nastavím délku řetězce na 0
   s->allocSize = STR_LEN_INC;  // Nastavím alokovanou velikost na STR_LEN_INC
   
   return STR_SUCCESS;  // Úspěšné vytvoření nového řetězce
}

void strFree(string *s)
// Funkce uvolní řetězec z paměti
{
   free(s->str);  // Uvolnění řetězce z paměti
}

void strClear(string *s)
// Funkce vymaže obsah řetězce
{
   s->str[0] = '\0';  // Nastavím první znak na nulový
   s->length = 0;  // Nastavím délku řetězce na 0
}

int strAddChar(string *s1, char c)
// Přidá na konec řetězce jeden znak
{
   if(s1->length + 1 >= s1->allocSize)  // Pokud alokovaná paměť nebude stačit
   {
      // Realokuji paměť řetězce
      if((s1->str = (char*)realloc(s1->str, s1->length + STR_LEN_INC)) == NULL)
         return STR_ERROR;  // Při neúspěšné realokaci vracím chybu

      s1->allocSize = s1->length + STR_LEN_INC;  // Přenastavím alokovanou paměť
   }
   
   s1->str[s1->length] = c;  // Přidám znak c na konec řetězce
   s1->length++;  // Zvětším délku řetězce
   s1->str[s1->length] = '\0';  // Posunu nulový znak o 1 pozici
   
   return STR_SUCCESS;  // Úspěšné přidání znaku do řetězce
}

int strCopyString(string *s1, string *s2)
// Funkce překopíruje řetězec s2 do s1
{
   int newLength = s2->length;  // Zjistím délku kopírovaného řetězce
   
   if(newLength >= s1->allocSize)  // Pokud alokovaná paměť nebude stačit
   {
      // Realokuji paměť řetězce
      if((s1->str = (char*)realloc(s1->str, newLength + 1)) == NULL)
         return STR_ERROR;  // Při neúspěšné realokaci vracím chybu

      s1->allocSize = newLength;  // Přenastavím alokovanou paměť
   }

   strcpy(s1->str, s2->str);  // Zkopíruji řetězec s2 do řetězce s1
   s1->length = newLength;  // Nastavím délku řetězce

   return STR_SUCCESS;  // Úspěšné zkopírování řetězce s2 do s1
}

int strCmpString(string *s1, string *s2)
// Funkce porovná oba řetězce a vrátí výsledek
{
   return strcmp(s1->str, s2->str);  // Vrací výsledek porovnání
}

int strCmpConstStr(string *s1, char* s2)
// Funkce porovná náš řetězec s konstantním řetězcem
{
   return strcmp(s1->str, s2);  // Vrací výsledek porovnání
}

char *strGetStr(string *s)
// Funkce vrátí textovou část řetězce
{
   return s->str;  // Vrací obsah řetězce
}

int strGetLength(string *s)
// Funkce vrátí délku daného řetězce
{
   return s->length;  // Vrací délku řetězce
}

int strConcate(string *s1, string *s2)
// Funkce přidá řetězec s2 do řetězce s1
{
    int delka1, delka2, newLength, index;  // Proměnné pro přidání
    
    delka1 = s1->length;  // Zjistím délku prvního
    
    delka2 = s2->length;  // Zjistím délku druhého
    
    newLength = delka1 + delka2;  // Nová délka

    if(newLength >= s1->allocSize)  // Pokud alokovaná paměť nebude stačit
    {
      // Realokuji paměť řetězce
      if((s1->str = (char*)realloc(s1->str, newLength + 1)) == NULL)
         return STR_ERROR;  // Při neúspěšné realokaci vracím chybu

      s1->allocSize = newLength;  // Přenastavím alokovanou paměť
    }
    
    // Zkopíruji po znacích druhý řetězec do prvního řetězce
    for(index = 0; index < delka2; index++)
    {
      if(strAddChar(s1, s2->str[index]) == STR_ERROR)
      // Přidám znak na konec řetězce s1 a kontrola
        return STR_ERROR;  // Vracím chybu přidání znaku
    }
    
    s1->length = newLength;  // Změním délku v prvním řetězci

    return STR_SUCCESS;  // Úspěšné přidání řetězce s2 do s1
}

int concateStrings(string *s1, string *s2, string *s3)
// Funkce zkopíruje řetězec s1 do s3 a přidá za něj řetězec s2
{   
    int delka, index;  // Proměnné pro přidávání
    
    if(strCopyString(s3,s1) == STR_ERROR)  // Zkopíruji s1 do s3 a kontrola
      return STR_ERROR;
    
    delka = strGetLength(s2); // Uložím si délku druhého

    for(index = 0; index < delka; index++)  // Kopíruji do s3 znaky z s2
    {
      if(strAddChar(s3, s2->str[index]) == STR_ERROR)
      // Přidám znak na konec řetězce a kontrola
        return STR_ERROR;
    }
    
    return STR_SUCCESS;  // Úspěšné sloučení řetězců s1 a s2 do řetězce s3
}

int strCopyChar(string *s1, char retezec[])
// Funkce zkopíruje řetězec do řetězce s1
{
  int delka, x;  // Proměnné pro kopírování

  strClear(s1);  // Vyprázdnění prvního řetězce
  
  delka = strlen(retezec);  // Zjistím délku řetězce
  
  for(x = 0; x < delka; x++)  // Procházím řetězec po znacích
  {
    if(strAddChar(s1, retezec[x]) == STR_ERROR)
    // Přidávám znak na konec řetězce s1
      return STR_ERROR;
  }
  
  return STR_SUCCESS;  // Úspěšné zkopírování řetězce do řetězce s1
}

/**************************************************************************************************/
/*                                       TODO                                                     */
/**************************************************************************************************/

int find(string *s1, string *s2) {

  int i = -1, j, citac=0;
  int delka_vzorku = s1->length; //delka vzorku
  char *vektor = (char*)malloc((delka_vzorku+1)*sizeof(char));  //vektor, ktery bude udrzovat cisla o kolik se ma text pri vyhledavani posunout

   vektor[0] = -1;

//VYTVOŘENÍ VEKTORU
  //vyvoreni vektoru, pomoci ktereho se nebudeme vracet pri vyhledavani v textu zpet
   for (j = 0; j < delka_vzorku; j++) {
      while ((i > -1) && (s1->str[j] != s1->str[i]))
         i = vektor[i];
      i++;
      if (s1->str[j+1] == s1->str[i])
         vektor[j+1] = vektor[i];
      else
         vektor[j+1] = i;
   }

  //zvetseni cisel ve vektoru o 1
  for(i =0; i < delka_vzorku; i++) {
    vektor[i] = vektor[i]+1;
  }

//VLASTNI HLEDANI PODRETEZCE
  i=0;
  j=0;
  //cyklus prochazejici hlavni retezec dokud nenarazi na konec
  while (s2->str[i] != '\0') {

  //pokud se hledany znak retezce shoduje s 1.znakem podretezce
    if(s2->str[i] == s1->str[0]) {
      //prochazej podretezec dokud nedojdes na konec
      while(s1->str[j] != '\0') {
        //pokud se dalsi znaky podretezce a retezce rovnaji
        if(s2->str[i+j] == s1->str[j]) {
          citac++;
        }
        else {
          //vzorek se nenasel - vymazou se pomocne promenne a skoci se o predem vypocitany vektor
          if(citac != delka_vzorku) {
            s2->str[i]=s2->str[i]+vektor[j];
            j=0;
            citac=0;
            break;
          }
        }

        j++;
        //v pripade ze se citac rovna velikosti pole - retezce se rovnaji a vraci se pozice hledaneho podretezce v retezci
        if(citac == delka_vzorku) {
		  free(vektor);
          return (i + 1);
        }
      }

    }
    i++;
  }

  free(vektor);
  return 0;

}

void mergessort(string *s1, int levy, int pravy){
    int pivot;

    if(levy<pravy){ //dokud nemame jedno cislo
        pivot=(levy+pravy)/2;
		mergessort(s1, levy, pivot); //rozdelime na levou
		mergessort(s1, pivot+1, pravy); //a pravou cast
		merge(s1, levy, pivot, pravy); //zatridime je do sebe
    }
}

void merge(string *s1, int lev, int piv, int prav){
    char *pomocne_pole; //pomuzeme si pomocnym polem
    int i, j, k; //pomocne promenna cyklu
    int levy=lev;
    int pravy=prav;
    int pivot=piv;

    pomocne_pole=(char *) malloc((pravy+1)*sizeof(char)); //naalokujeme ono pole

    for(i=levy; i<=pravy; i++){ //do pomocneho pole si prekopirujeme cele pole
		pomocne_pole[i]=s1->str[i];
    }

    i=levy;
    j=pivot+1;
    k=levy;

    while(i<=pivot && j<=pravy){ //nejvetsi prvek vzdycky nakopiruju do pole cisel
      if(pomocne_pole[i]<=pomocne_pole[j]){ //pokud je prvek z leve poloviny mensi, ulozim ho do vyslednyho pole
		  s1->str[k]=pomocne_pole[i];
          i++;
          k++;
      }
      else{ //jinak tam ulozim prvek z prave poloviny
		  s1->str[k]=pomocne_pole[j];
          j++;
          k++;
      }
     }

    while (i<=pivot){ //pokud existuje nejaky zbytek prvni pulky, dokopiruj ho do pole_cisel
		s1->str[k]=pomocne_pole[i];
        i++;
        k++;
    }

    free(pomocne_pole);
}