xref: /dports/devel/sdlskk/sdlskk-0.5/dictionary.c

#include "sdlskk.h"
#include "sdlskk_internal.h"
#include <string.h>
#include <stdio.h>


#define BUF_SIZE 1024
static void parse_skk_jisyo_line( SDLSKK_Map* map, char* line, char users )
{
  int pos;
  SDLSKK_Char* yomi;
  SDLSKK_Char* kanji;
  SDLSKK_StrList* list;

  if( line[0] == ';' || line[0] == ' ' || line[0] == '\n' || line[0] == '\0' )
    return;

  pos = 0;
  yomi = SDLSKK_cstr_tokenize( line, '/', &pos );
  SDLSKK_Str_chop( yomi );

  list = SDLSKK_Map_get( map, yomi );
  if( list == NULL ){
    list = SDLSKK_StrList_new();
    SDLSKK_Map_set( map, yomi, list );
  }

  for(;;){
    kanji = SDLSKK_cstr_tokenize( line, '/', &pos );
    if( kanji[0]==0 ){
      free( kanji );
      return;
    }
    if( ! SDLSKK_StrList_find( list, kanji ) ){
      SDLSKK_StrList_push( list, kanji, users );
    }
  }

}

SDLSKK_Dictionary* SDLSKK_Dict_new( void )
{
  SDLSKK_Dictionary* dict;

  dict = SDLSKK_malloc( sizeof(SDLSKK_Dictionary) );
  dict->map = SDLSKK_Map_new( DICT_TABLE_SIZE );

  return dict;
}

int SDLSKK_Dict_load( SDLSKK_Dictionary* dict, char* filename, int users )
{
  FILE* fp;
  char buf[2048];

  fp = fopen( filename, "rt" );
  if( fp==NULL )
    return 0;

  while( fgets( buf, sizeof(buf), fp ) != NULL ){
    parse_skk_jisyo_line( dict->map, buf, users );
  }
  fclose( fp );
  return 1;
}

void SDLSKK_Dict_delete( SDLSKK_Dictionary* dict )
{
  SDLSKK_Dict_delete_all( dict );
}

void SDLSKK_Dict_delete_all( SDLSKK_Dictionary* dict )
{
  SDLSKK_Map_delete_all( dict->map );
  free( dict );
}

SDLSKK_DictionaryItem* SDLSKK_Dict_get( SDLSKK_Dictionary* dict,
					SDLSKK_Char *hiragana )
{
  SDLSKK_StrList *vals = SDLSKK_Map_get( dict->map, hiragana );
  SDLSKK_DictionaryItem* item;
  if( vals == NULL )
    return NULL;

  item = SDLSKK_malloc( sizeof(SDLSKK_DictionaryItem) );
  item->dict = dict;
  item->hiragana = hiragana;
  item->kanji = vals;
  item->cur = item->kanji->begin->next;

  return item;
}

void SDLSKK_Dict_add_empty_yomi( SDLSKK_Dictionary* dict,
				 SDLSKK_Char* yomi )
{
  if( SDLSKK_Map_get( dict->map, yomi ) != NULL )
    return;
  SDLSKK_Map_set( dict->map, yomi, SDLSKK_StrList_new() );
}

SDLSKK_Char* SDLSKK_DictItem_get_current( SDLSKK_DictionaryItem* item )
{
  return item->cur->val;
}

void SDLSKK_DictItem_next( SDLSKK_DictionaryItem* item )
{
  if( SDLSKK_DictItem_is_end( item ) )
    return;
  item->cur = item->cur->next;
}

void SDLSKK_DictItem_prev( SDLSKK_DictionaryItem* item )
{
  if( SDLSKK_DictItem_is_begin( item ) )
    return;
  item->cur = item->cur->prev;
}
void SDLSKK_DictItem_reset( SDLSKK_DictionaryItem* item )
{
  item->cur = item->kanji->begin->next;
}

void SDLSKK_DictItem_delete( SDLSKK_DictionaryItem* item )
{
  free( item );
}

int SDLSKK_DictItem_is_end( SDLSKK_DictionaryItem* item )
{
  return item->cur->next == item->kanji->end;
}

int SDLSKK_DictItem_is_begin( SDLSKK_DictionaryItem* item )
{
  return item->cur->prev == item->kanji->begin;
}

void SDLSKK_DictItem_commit( SDLSKK_DictionaryItem* item )
{
  item->cur->save = 1;
  item->cur->prev->next = item->cur->next;
  item->cur->next->prev = item->cur->prev;

  item->cur->prev = item->kanji->begin;
  item->cur->next = item->kanji->begin->next;
  item->kanji->begin->next->prev = item->cur;
  item->kanji->begin->next = item->cur;
}

void SDLSKK_DictItem_register_word( SDLSKK_DictionaryItem* item,
				    SDLSKK_Char* new_word )
{
  SDLSKK_Char* word = SDLSKK_Str_new( new_word );

  SDLSKK_StrList_shift( item->kanji, word, 1 );
}

void SDLSKK_DictItem_set_current( SDLSKK_DictionaryItem* item,
				  SDLSKK_Char* word )
{
  item->cur = SDLSKK_StrList_find( item->kanji, word );
}

int SDLSKK_DictItem_get_count( SDLSKK_DictionaryItem* item )
{
  int result;
  SDLSKK_DictionaryItem tmp_item;

  tmp_item = *item;
  for( result=0; !SDLSKK_DictItem_is_begin( &tmp_item ); ++result ){
    SDLSKK_DictItem_prev( &tmp_item );
  }

  return result;
}

int SDLSKK_Dict_save_user_dict( SDLSKK_Dictionary* dict, char* filename )
{
  FILE* fp;
  char line[5000];
  char buf[1000];
  int i;
  int save;
  SDLSKK_HashElement* hash_el;
  SDLSKK_ListElement* list_el;

  fp = fopen( filename, "wt" );
  if( fp == NULL )
    return 0;

  for( i = 0; i < dict->map->table_size; ++i ){
    for( hash_el = dict->map->table[i]; hash_el != NULL;
	 hash_el = hash_el->next ){
      save = 0;
      SDLSKK_Str_to_cstr( hash_el->key, buf, sizeof(buf) );
#ifdef HAVE_SNPRINTF
      snprintf( line, sizeof(line), "%s /", buf );
#else
      sprintf( line, "%s /", buf );
#endif
      for( list_el = hash_el->vals->begin->next;
	   list_el != hash_el->vals->end;
	   list_el = list_el->next ){
	if( list_el->save ){
	  save = 1;
	  SDLSKK_Str_to_cstr( list_el->val, buf, sizeof(buf) - 1 );
	  if( strlen( line ) + strlen( buf ) + 2 < sizeof(line) ){
	    strcat( buf, "/" );
	    strcat( line, buf );
	  }
	}
      }

      if( save ){
	fputs( line, fp );
	fputc( '\n', fp );
      }

    }
  }

  fclose(fp);

  return 1;
}