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"

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)
  {
    perror("malloc");
    return -1;
  }

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

  _ffstring_instance_counter++;

  return 0;
}

ffint32 ffstring_delete(ffstring* target)
{

  free(target->str);

  _ffstring_instance_counter--;

  return 0;
}

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

ffint32 ffstring_move_and_delete(ffstring* source, ffstring* target)
{
  ffstring_delete(target);
  ffstring_copy(source, target);
  ffstring_delete(source);
  return 0;
}



/* Other functions */

ffint32 ffstring_dfe(ffstring* target, ffuint32 count)
{

  ffuint32 nlen;
  char* n;

  /* Check the lengt */
  nlen = target->len-count+1;
  if (nlen < 1)
  {
    printf("ffstring_dfe: New length smaller than 1\n");
    return -2;
  }

  /* Allocate memory */
  n = (char*) realloc(target->str, nlen);
  if (!n)
  {
    perror("realloc");
    return -1;
  }

  /* 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 )
  {
    printf("ffstring_rfe: New length smaller than 1");
    return -2;
  }


  /* Allocate new space */
  n = (char*) realloc(target->str, nlen);
  if (!n)
  {
    perror("realloc");
    return -1;
  }

  /* 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)
  {
    perror("realloc");
    return -1;
  }

  /* 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()
{
  return _ffstring_instance_counter;
}

ffint32 ffstring_tail(const ffstring* source, ffint32 count, ffstring* target)
{
  ffint32 offset = source->len - count;
  if (offset < 0)
    return -2;

  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)
{
  return strcasecmp(left->str, right);
}

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)
{
  return strcasecmp(left->str, right->str);
}

ffint32 ffstring_decinst()
{
  if (_ffstring_instance_counter <= 0)
    return -1;
  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;
  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)
{
  return !ffstring_compare_ci(left, right);
}

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)
{
  return !ffstring_compare_ff_ci(left, right);
}

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);
}

---