ffstring.c

Go to the documentation of this file.

/*
 * finflect - Algorithms and tools for inflecting Finnish nouns
 * Copyright (C) 2004, 2005  The FinFlect Team
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 *
 * For the complete legal text of the GNU Lesser General Public License,
 * see the file LICENSE. For a complete list of authors and copyright
 * holders, see the file AUTHORS.
 */

/**
 * @file ffstring.c Implements the operations (declared in ffstring.h) related to the
 * ffstring string data type.
 */

#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <ctype.h>

#include "ffstring.h"
#include "ffutil.h"
#include "ffconfig.h"
#include "fferror.h"

static ffint32 _ffstring_instance_counter = 0;

ffint32 ffstring_create(const ffchar* source, ffstring* target) {
  ffint32 sourcelen = strlen(source);
  target->str = (char*) malloc(sourcelen+1);
  if (!target->str) {
    FF_PRINTERROR("Holy Shit! Malloc failed! omglol...");
    return FFERR_MEM;
  }

  /* Add default values */
  strcpy(target->str, source);
  target->len = sourcelen;

  _ffstring_instance_counter++;

  return 0;
}

ffint32 ffstring_delete(ffstring* target) {
  free(target->str);
  target->str = NULL;

  _ffstring_instance_counter--;

  return 0;
}

ffint32 ffstring_copy(const ffstring* source, ffstring* target) {
  return ffstring_create(source->str,target);
}

/* Other functions */

ffint32 ffstring_dfe(ffstring* target, ffuint32 count) {
  ffuint32 nlen;
  char* n;

  /* Check the lenght */
  nlen = target->len-count+1;
  if (nlen < 1) {
    FF_PRINTERROR("in function 'ffstring_dfe': New length smaller than 1");
    return FFERR_ARGUMENT;
  }

  /* Allocate memory */
  n = (char*) realloc(target->str, nlen);
  if (!n) {
    FF_PRINTERROR("in function 'ffstring_dfe': realloc failed! buy more memory X(");
    return FFERR_MEM;
  }

  /* Apply changes */
  target->str = n;
  target->str[target->len-count] = '\0';
  target->len -= count;

  return 0;
}

ffint32 ffstring_rfe(ffstring* target, ffuint32 count, char* append) {
  char* n;
  ffuint32 nlen;
  ffuint32 alen;


  alen = strlen(append);
  nlen = target->len-count+alen+1;

  if (nlen < 1) {
    FF_PRINTERROR("in function 'ffstring_rfe': New length smaller than 1");
    return FFERR_ARGUMENT;
  }


  /* Allocate new space */
  n = (char*) realloc(target->str, nlen);
  if (!n) {
    FF_PRINTERROR("in function 'ffstring_rfe': realloc failed!");
    return FFERR_MEM;
  }

  /* Apply changes
     - Break the old string where deleted part starts
       and overwrite it with new
  */
  target->str = n;
  target->str[target->len-count] = '\0';
  strcat(target->str,append);
  target->len += alen-count;
  return 0;
}

ffint32 ffstring_rfe_ff(ffstring* target, ffuint32 count, const ffstring* append) {
  return ffstring_rfe(target, count, append->str);
}

ffint32 ffstring_append(ffstring* target, char* append) {
  char* n;
  ffuint32 alen = strlen(append);

  /* Allocate new space */
  n = (char*) realloc(target->str, target->len+alen+1);
  if (!n) {
    FF_PRINTERROR("in function 'ffstring_append': realloc failed!");
    return FFERR_MEM;
  }

  /* Apply changes */
  target->str = n;
  strcat(target->str,append);
  target->len += alen;

  return 0;
}

ffint32 ffstring_append_ff(ffstring* target, const ffstring* source) {
  /**
   * @todo 
   * We already know the length of the source ffstring, so why not create an
   * optimized version?
   */
  return ffstring_append(target, source->str);
}

ffint32 ffstring_instcount(void) {
  return _ffstring_instance_counter;
}

ffint32 ffstring_tail(const ffstring* source, ffint32 count, ffstring* target) {
  ffint32 offset = source->len - count;
  if (offset < 0) {
    FF_PRINTERROR("in function 'ffstring_tail': offset is smaller than 0 and obviously someone has fucked up!");
    return FFERR_ARGUMENT;
  }
  return ffstring_create(source->str + offset, target);
}

ffint32 ffstring_tolower(ffstring* target) {
  ffchar* i;
  for (i = target->str; i < target->str + target->len; ++i) {
    *i = tolower(*i);
  }
  return 0;
}

ffint32 ffstring_lower(const ffstring* source, ffstring* target) {
  ffint32 error = 0;
  if ((error = ffstring_create(source->str, target))) {
    return error;
  }
  return ffstring_tolower(target);
}

ffint32 ffstring_compare(const ffstring* left, const ffchar* right) {
  return strcmp(left->str, right);
}

ffint32 ffstring_compare_ci(const ffstring* left, const ffchar* right) {
  ffint32 result;
  ffstring rightff;
  ffstring leftlower;
  ffstring rightlower;

  ffstring_create(right, &rightff);
  ffutil_tolower(left,&leftlower);
  ffutil_tolower(&rightff,&rightlower);

  result = strcmp(leftlower.str, rightlower.str);

  ffstring_delete(&rightff);
  ffstring_delete(&leftlower);
  ffstring_delete(&rightlower);

  return result;
}

ffint32 ffstring_compare_ff(const ffstring* left, const ffstring* right) {
  return strcmp(left->str, right->str);
}

ffint32 ffstring_compare_ff_ci(const ffstring* left, const ffstring* right) {
  ffint32 result;
  ffstring leftlower;
  ffstring rightlower;

  ffutil_tolower(left,&leftlower);
  ffutil_tolower(right,&rightlower);

  result = strcmp(leftlower.str, rightlower.str);

  ffstring_delete(&leftlower);
  ffstring_delete(&rightlower);

  return result;
}

ffint32 ffstring_decinst(void) {
  if (_ffstring_instance_counter <= 0) {
    FF_PRINTERROR("in function 'ffstring_decinst': memory management is b0rked!");
    return FFERR_MEM;
  } else {
    --_ffstring_instance_counter;
    return 0;
  }
}

ffint32 ffstring_compare_tail(const ffstring* left, ffuint32 count, const ffchar* right) {
  ffstring tail;
  ffint32 result;

  if (left->len < count) {
    return -1;
  }

  ffstring_tail(left, count, &tail);
  result = ffstring_compare(&tail, right);
  ffstring_delete(&tail);
  return result;
}

ffint32 ffstring_compare_tail_ci(const ffstring* left, ffuint32 count, const ffchar* right) {
  ffstring tail;
  ffint32 result;

  if (left->len < count) {
    return -1;
  }

  ffstring_tail(left, count, &tail);
  result = ffstring_compare_ci(&tail, right);
  ffstring_delete(&tail);
  return result;
}

ffint32 ffstring_compare_tail_ff(const ffstring* left, ffuint32 count, const ffstring* right) {
  ffstring tail;
  ffint32 result;

  if (left->len < count) {
    return -1;
  }

  ffstring_tail(left, count, &tail);
  result = ffstring_compare_ff(&tail, right);
  ffstring_delete(&tail);
  return result;
}

ffint32 ffstring_compare_tail_ff_ci(const ffstring* left, ffuint32 count, const ffstring* right) {
  ffstring tail;
  ffint32 result;

  if (left->len < count) {
    return -1;
  }

  ffstring_tail(left, count, &tail);
  result = ffstring_compare_ff_ci(&tail, right);
  ffstring_delete(&tail);
  return result;
}

ffchar ffstring_last(const ffstring* source) {
  if (source->len < 1) {
    return 0;
  } else {
    return *(source->str + source->len - 1);
  }
}

ffint32 ffstring_compare_last(const ffstring* left, const ffchar right) {
  /**
   * @todo Umlauts
   */
  ffchar left_last = ffstring_last(left);

  if (left_last < right) {
    return -1;
  } else if (left_last == right) {
    return 0;
  } else {
    return 1;
  }
}

ffint32 ffstring_compare_last_ci(const ffstring* left, const ffchar right) {
  /**
   * @todo Umlauts
   */
  ffchar left_lower, right_lower;

  left_lower = tolower(ffstring_last(left));
  right_lower = tolower(right);

  if (left_lower < right_lower) {
    return -1;
  } else if (left_lower == right_lower) {
    return 0;
  } else {
    return 1;
  }
}

ffbool ffstring_equals(const ffstring* left, const ffchar* right) {
  return !ffstring_compare(left, right);
}

ffbool ffstring_equals_ci(const ffstring* left, const ffchar* right) {
  ffuint32 i;

  if (left->len != strlen(right)) {
    return 0;
  }

  for (i = 0;i < left->len; i++) {
    if (ffutil_ffchar_tolower(left->str[i]) != ffutil_ffchar_tolower(right[i])) {
      return 0;
    }
  }
  return 1;
}

ffbool ffstring_equals_ff(const ffstring* left, const ffstring* right) {
  return !ffstring_compare_ff(left, right);
}

ffbool ffstring_equals_ff_ci(const ffstring* left, const ffstring* right) {
  ffuint32 i;

  if (left->len != right->len) {
    return 0;
  }

  for (i = 0;i < left->len; i++) {
    if (ffutil_ffchar_tolower(left->str[i]) != ffutil_ffchar_tolower(right->str[i])) {
      return 0;
    }
  }
  return 1;
}

ffbool ffstring_tail_equals(const ffstring* left, const ffint32 count, const ffchar* right) {
  return !ffstring_compare_tail(left, count, right);
}

ffbool ffstring_tail_equals_ci(const ffstring* left, const ffint32 count, const ffchar* right) {
  return !ffstring_compare_tail_ci(left, count, right);
}

ffbool ffstring_tail_equals_ff(const ffstring* left, const ffint32 count, const ffstring* right) {
  return !ffstring_compare_tail_ff(left, count, right);
}

ffbool ffstring_tail_equals_ff_ci(const ffstring* left, const ffint32 count, const ffstring* right) {
  return !ffstring_compare_tail_ff_ci(left, count, right);
}

ffbool ffstring_last_equals(const ffstring* left, ffchar right) {
  return !ffstring_compare_last(left, right);
}

ffbool ffstring_last_equals_ci(const ffstring* left, ffchar right) {
  return !ffstring_compare_last_ci(left, right);
}

---