#include <string.h>

// Exemple de functii cu prelucrare de siruri
// functiile cu _ sunt exemplele noastre, celelalte sunt standard

// returneaza indicele (intreg) al primei aparitii a caracterului c
// in sirul s, sau -1 daca c nu apare in s
// similara cu functia de biblioteca strchr care returneaza pointer
int str_index(char s[], char c)
{
  int i;
  for (i = 0; s[i] != '\0'; ++i)
    if (s[i] == c) return i;
  return -1;	// daca am ajuns la sfarsit (\0) fara sa-l gasim pe c
}
// varianta cu pointeri
int str_index(char s[], char c)
{
  char *p;	// pointer la caracterul curent din sir
  for (p = s; *p; ++p)
    if (*p == c) return p - s;
  return -1;
}

// functia standard de comparare a doua siruri
// returneaza ceva < 0 daca s1 e inaintea lui s2 in ordine alfabetica
// > 0 daca s1 e dupa s2, si 0 pentru siruri egale
int strcmp (const char *s1, const char *s2) { /* comparã */
  while (*s1 == *s2 && *s1) { s1++; s2++; } /* egale dar nu '\0' */
  return *s1 - *s2; /* < 0 pt. s1<s2, > 0 pt. s1>s2, 0 pt. egal */ 
}
// varianta cu indici
int strcmp(char s1[], char s2[])
{
  int i;
  for (i = 0; s1[i] == s2[i] && s1[i]; ++i);
  return s1[i] - s2[i];
}

// functie care adauga un caracter la capatul unui sir
// presupune ca exista loc in memorie
// atentie ! nu se poate folosi strcat, care adauga un SIR (char *)
char *str_add1(char *dest, char end)
{
  char *p = dest + strlen(dest);	// pointer la coada (\0)
  *p = end;	// suprascrie \0 cu noul caracter
  *++p = 0;	// adauga un nou \0 in coada
  return dest;	// returneaza sirul rezultat
}

// functie standard care copiaza n octeti de la src la dest
// atentie: zonele de memorie nu trebuie sa se suprapuna !
void *memcpy(void *dest, const void *src, size_t n)
{
  int i;
  for (i = 0; i < n; ++i)
    ((char *)dest)[i] = ((char *)src)[i]; // typecast pentru a folosi indice
  return dest;
}

// pune laolalta sirurile s1 si s2 intr-o zona de memorie proaspat alocata
char *str_join(const char *s1, const char *s2)
{
  int l1 = strlen(s1);	// folosim de mai multe ori => punem intr-o variabila
  char *s = malloc(l1 + strlen(s2) + 1);	// loc pt sirul nou + \0
  if (s == NULL) return NULL;	// n-a reusit malloc
  strcpy(s, s1);	// functie standard -- copiem primul sir
  strcpy(s + l1, s2);	// copiem al doilea in coada primului, cu tot cu \0
  return s;
}