//
// this function reads words in the word file and try analyse them
//
void analyse_word_list(Dictionary* d,
U_FILE* words,
U_FILE* result,
U_FILE* debug,
U_FILE* new_unknown_words,
const Alphabet* alph,
const bool* prefix,const bool* suffix,
struct utags UTAG,
vector_ptr* rules,
vector_ptr* entries)
{
u_printf("Analysing russian unknown words...\n");
int n=0;
int words_done = 0;
Ustring* s=new_Ustring(MAX_WORD_LENGTH);
while (EOF!=readline(s,words)) {
if (!analyse_word(s->str,d,debug,result,prefix,suffix,alph,UTAG,rules,entries)) {
// if the analysis has failed, we store the word in the new unknown word file
u_fprintf(new_unknown_words,"%S\n",s->str);
} else {
n++;
}
if ( (++words_done % 10000) == 0)
u_printf("%d words done", words_done);
}
free_Ustring(s);
u_printf("%d words decomposed as compound words\n",n);
}
static int hfsys_event_callback( uint32_t event_id,void * param)
{
switch(event_id)
{
case HFE_WIFI_STA_CONNECTED:
u_printf("wifi sta connected!!\n");
break;
case HFE_WIFI_STA_DISCONNECTED:
u_printf("wifi sta disconnected!!\n");
break;
case HFE_DHCP_OK:
{
uint32_t *p_ip;
p_ip = (uint32_t*)param;
u_printf("dhcp ok %08X!\n",*p_ip);
}
break;
case HFE_SMTLK_OK:
u_printf("smtlk ok!\n");
return -1;
break;
case HFE_CONFIG_RELOAD:
u_printf("reload!\n");
break;
default:
break;
}
return 0;
}
int do_extract_from_opened_pack_archive_onefile(
unzFile uf,
const char* filename,
int opt_extract_without_path,
const char* prefix_extracting_name,
int transform_path_separator, int quiet)
{
int iCaseSensitivity = 1;
if (unzLocateFile(uf,filename,iCaseSensitivity)!=UNZ_OK)
{
u_printf("file %s not found in the zipfile\n",filename);
return 2;
}
if (is_last_char_path_separator(prefix_extracting_name))
{
if (quiet == 0)
u_printf("Creating extracting directory: %s\n",prefix_extracting_name);
mkDirPortable(prefix_extracting_name);
}
if (do_extract_from_opened_pack_archive_currentfile(uf,&opt_extract_without_path,prefix_extracting_name,transform_path_separator,quiet) == UNZ_OK)
return 0;
else
return 1;
}
/**
* This function takes a dictionary tree and minimizes it using
* Dominique Revuz's algorithm. 'used_inf_values' is used to mark
* INF codes that are actually used in the .bin.
*/
void minimize_tree(struct dictionary_node* root,struct bit_array* used_inf_values,Abstract_allocator prv_alloc) {
u_printf("Minimizing... \n");
struct transition_list** transitions_by_height;
struct dictionary_node_transition** transitions;
//init_minimize_arrays(&transitions_by_height,&transitions);
init_minimize_arrays_transition_list(&transitions_by_height);
unsigned int H=sort_by_height(root,transitions_by_height,used_inf_values,prv_alloc);
unsigned int nb=0;
for (unsigned int k1=0;k1<=H;k1++) {
unsigned int nbcur = convert_list_to_array_size(k1,transitions_by_height);
if (nbcur>nb) {
nb = nbcur;
}
}
init_minimize_arrays_dictionary_node_transition(&transitions,nb);
float z;
for (unsigned int k=0;k<=H;k++) {
int size=convert_list_to_array(k,transitions_by_height,transitions,nb,prv_alloc);
for (int l=0;l<size;l++) {
check_nodes(transitions[l]);
}
quicksort(0,size-1,transitions);
merge(size,transitions,prv_alloc);
z=(float)(100.0*(float)(k)/(float)H);
if (z>100.0) z=(float)100.0;
u_printf("%2.0f%% completed... \r",z);
}
u_printf("Minimization done. \n");
free_minimize_arrays(transitions_by_height,transitions);
}
static void usage_scores() {
display_copyright_notice();
u_printf(
"Usage: SpellCheck [OPTIONS] <dic1> [<dic2> <dic3> ...]\n"
"\n"
"The --scores=XXX option allows you to specify a score for each of the\n"
"%d supported kinds of error. XXX must be made of %d comma-separated integer\n"
"values which respectively mean the following:\n"
"- letter duplication: devil => devvil\n"
"- any other letter insertion: devil => degvil\n"
"- double letter simplification: battle => batle\n"
"- any other letter omission: battle => bttle\n"
"- letter inversion: happy => ahppy\n"
"- diacritic error: %Ctaient => etaient\n"
"- case error: London => london\n"
"- letter close on keyboard: battle => bzttle\n"
"- any other letter change: battle => blttle\n"
"\n"
"Each hypothesis is given the sum of its errors' scores. The lower\n"
"the score, the better the hypothesis. Default values are:\n"
"--scores=%d",N_SPSubOp,N_SPSubOp,0xE9,default_scores[0]);
for (int i=1;i<N_SPSubOp;i++) {
u_printf(",%d",default_scores[i]);
}
u_printf("\n\n");
}
/**
* Reads all the Thai lines and put them in a sorted tree, then saves them
* exploring the tree.
*/
void sort_thai(struct sort_infos* inf) {
u_printf("Loading text...\n");
while (read_line_thai(inf)) {
}
u_printf("%d lines read\n", inf->number_of_lines);
save(inf);
}
//
// this function reads words in the word file and try analyse them
//
void analyse_word_list(const unsigned char* tableau_bin,
const struct INF_codes* inf,
U_FILE* words,
U_FILE* result,
U_FILE* debug,
U_FILE* new_unknown_words,
const Alphabet* alph,
const bool* prefix,const bool* suffix,
struct utags UTAG,
vector_ptr* rules,
vector_ptr* entries)
{
unichar s[MAX_WORD_LENGTH];
u_printf("Analysing russian unknown words...\n");
int n=0;
int words_done = 0;
while (EOF!=u_fgets_limit2(s,MAX_WORD_LENGTH,words)) {
if (!analyse_word(s,tableau_bin,debug,result,inf,prefix,suffix,alph,UTAG,rules,entries)) {
// if the analysis has failed, we store the word in the new unknown word file
u_fprintf(new_unknown_words,"%S\n",s);
} else {
n++;
}
if ( (++words_done % 10000) == 0)
u_printf("%d words done", words_done);
}
u_printf("%d words decomposed as compound words\n",n);
}
int USER_FUNC app_main (void)
{
time_t now=time(NULL);
u_printf("[CALLBACK DEMO]sdk version(%s),the app_main start time is %d %s\n",hfsys_get_sdk_version(),now,ctime(&now));
if(hfsys_register_system_event((hfsys_event_callback_t)hfsys_event_callback)!=HF_SUCCESS)
{
u_printf("register system event fail\n");
}
if(hfgpio_fmap_check()!=0)
{
while(1)
{
HF_Debug(DEBUG_ERROR,"gpio map file error\n");
msleep(1000);
}
return 0;
}
show_reset_reason();
while(!hfnet_wifi_is_active())
{
msleep(50);
}
//if(hfnet_start_assis(ASSIS_PORT)!=HF_SUCCESS)
if(hfnet_start_assis_ex(ASSIS_PORT,(hfnet_callback_t)assis_ex_recv_callback)!=HF_SUCCESS)
{
HF_Debug(DEBUG_WARN,"start httpd fail\n");
}
if(hfnet_start_httpd(HFTHREAD_PRIORITIES_MID)!=HF_SUCCESS)
{
HF_Debug(DEBUG_WARN,"start httpd fail\n");
}
if(hfnet_start_uart(HFTHREAD_PRIORITIES_LOW,(hfnet_callback_t)uart_recv_callback)!=HF_SUCCESS)
{
HF_Debug(DEBUG_WARN,"start uart fail!\n");
}
if(hfnet_start_socketa(HFTHREAD_PRIORITIES_LOW,(hfnet_callback_t)socketa_recv_callback)!=HF_SUCCESS)
{
HF_Debug(DEBUG_WARN,"start socketa fail\n");
}
if(hfnet_start_socketb(HFTHREAD_PRIORITIES_LOW,(hfnet_callback_t)socketb_recv_callback)!=HF_SUCCESS)
{
HF_Debug(DEBUG_WARN,"start socketb fail\n");
}
//创建一个自动定时器，每1s钟触发一次。
if((hnlink_timer = hftimer_create("NLINK-FALSH-TIMER",1000,true,1,nlink_falsh_timer_callback,0))==NULL)
{
u_printf("create timer fail\n");
}
return 1;
}
///////////////////////////////////////////////////////////////////////////
// Print the contents of a table of unicode strings to the standard output.
void u_print_unitab(unitab_t tab) {
int i;
u_printf("\n");
for (i=0; i<tab.n; i++) {
u_printf("%S ", tab.t[i]);
}
u_printf("\n");
}
void display_list_ustring(const struct list_ustring *l){
u_printf("list_ustring = ");
while(l!=NULL){
u_printf("%S",l->string);
l=l->next;
}
u_printf("\n");
}
int main(int argc, char* argv[])
{
char *a = NULL;
u_printf("We will try to access NULL");
*a = 'D';
u_printf("%c", a);
return 0;
}
void wifi_scan(void *arg)
{
while(1)
{
u_printf("ssid,auth,encry,channel,rssi,mac\r\n\r\n");
hfwifi_scan(hfwifi_scan_test);
u_printf("\r\n\r\n********************\r\n\r\n");
msleep(30000);
}
}
static int USER_FUNC socketb_recv_callback(uint32_t event,char *data,uint32_t len,uint32_t buf_len)
{
if(event==HFNET_SOCKETB_DATA_READY)
HF_Debug(DEBUG_LEVEL_LOW,"socketb recv %d bytes data %d\n",len,buf_len);
else if(event==HFNET_SOCKETB_CONNECTED)
u_printf("socket b connected!\n");
else if(event==HFNET_SOCKETB_DISCONNECTED)
u_printf("socket b disconnected!\n");
return len;
}
////////////////////////////////////////////
// Prints the set of instantiations.
int unif_print_vars(MultiFlex_ctx* p_multiFlex_ctx) {
int v;
int i;
u_printf("INSTANTIATION VARIABLES:\n");
for (v=0;v<(p_multiFlex_ctx->UNIF_VARS).no_vars;v++) {
u_printf("%S:%S=",(p_multiFlex_ctx->UNIF_VARS).vars[v].id,(p_multiFlex_ctx->UNIF_VARS).vars[v].cat->name);
i=(p_multiFlex_ctx->UNIF_VARS).vars[v].val;
u_printf("%S\n",(p_multiFlex_ctx->UNIF_VARS).vars[v].cat->values[i]);
}
return 0;
}
////////////////////////////////////////////
// Prints the set of instantiations.
int unif_print_vars(unif_vars_T* UNIF_VARS) {
int v;
int i;
u_printf("INSTANTIATION VARIABLES:\n");
for (v=0;v<UNIF_VARS->no_vars;v++) {
u_printf("%S:%S=",UNIF_VARS->vars[v].id,UNIF_VARS->vars[v].cat->name);
i=UNIF_VARS->vars[v].val;
u_printf("%S\n",UNIF_VARS->vars[v].cat->values[i]);
}
return 0;
}
int do_extract_from_opened_pack_archive(
unzFile uf,
int opt_extract_without_path,
const char* prefix_extracting_name,
int transform_path_separator, int quiet)
{
uLong i;
unz_global_info gi;
int err;
int retValue = 0;
err = unzGetGlobalInfo(uf,&gi);
if (err!=UNZ_OK)
{
u_printf("error %d with zipfile in unzGetGlobalInfo \n",err);
return 1;
}
if (gi.number_entry != 0)
{
err = unzGoToFirstFile(uf);
if (err!=UNZ_OK)
{
u_printf("error %d with zipfile in unzGetGlobalInfo \n",err);
return 1;
}
}
if (is_last_char_path_separator(prefix_extracting_name))
{
if (quiet == 0)
u_printf("Creating extracting directory: %s\n",prefix_extracting_name);
mkDirPortable(prefix_extracting_name);
}
for (i=0;i<gi.number_entry;i++)
{
if (do_extract_from_opened_pack_archive_currentfile(uf,&opt_extract_without_path,prefix_extracting_name,transform_path_separator,quiet) != UNZ_OK)
break;
if ((i+1)<gi.number_entry)
{
err = unzGoToNextFile(uf);
if (err!=UNZ_OK)
{
u_printf("error %d with zipfile in unzGoToNextFile\n",err);
retValue = 1;
}
}
}
return retValue;
}
//
// this function reads words in the word file and try analyse them
//
void analyse_german_word_list(const unsigned char* bin,const struct INF_codes* inf,
U_FILE* words,U_FILE* result,U_FILE* debug,U_FILE* new_unknown_words,
const char* left,const char* right,const Alphabet* alphabet) {
unichar s[1000];
u_printf("Analysing german unknown words...\n");
int n=0;
while (EOF!=u_fgets_limit2(s,1000,words)) {
if (!analyse_german_word(s,debug,result,left,right,inf,alphabet,bin)) {
// if the analysis has failed, we store the word in the new unknown word file
u_fprintf(new_unknown_words,"%S\n",s);
} else {n++;}
}
u_printf("%d words decomposed as compound words\n",n);
}
USER_FUNC void test_uflash_start(void)
{
uint32_t i;
uint32_t value;
int pages;
hfuflash_erase_page(0,1);
for(i=0;i<HFFLASH_PAGE_SIZE;)
{
if(hfuflash_write(i,(char*)&i,sizeof(i))<sizeof(i))
{
u_printf("uflash eof\n");
break;
}
i+=sizeof(i);
}
for(i=0;i<HFFLASH_PAGE_SIZE;)
{
if(hfuflash_read(i,(char*)&value,4)<4)
{
u_printf("uflash eof\n");
break;
}
u_printf("%d\n",value);
i+=4;
}
pages = (HFUFLASH_SIZE+HFUFLASH1_SIZE)/HFFLASH_PAGE_SIZE;
for(i=0;i<pages;i++)
{
u_printf("erase test %d\n",i);
msleep(1000);
if(hfuflash_erase_page(i*HFFLASH_PAGE_SIZE,pages-i)!=HF_SUCCESS)
{
u_printf("test erase fail!\n");
return ;
}
}
for(i=0;i<HFUFLASH_SIZE+HFUFLASH1_SIZE;)
{
if(hfuflash_write(i,(char*)&i,sizeof(i))<sizeof(i))
{
u_printf("uflash eof\n");
break;
}
if(hfuflash_read(i,(char*)&value,4)<4)
{
u_printf("uflash eof\n");
break;
}
if(value!=i)
{
u_printf("test fail %d %d\n",i,value);
}
i+=sizeof(i);
}
}
void parse_text(struct fst2txt_parameters* p) {
fill_buffer(p->text_buffer,p->f_input);
int debut=p->fst2->initial_states[1];
p->variables=new_Variables(p->fst2->input_variables);
int n_blocks=0;
u_printf("Block %d",n_blocks);
int within_tag=0;
while (p->current_origin<p->text_buffer->size) {
if (!p->text_buffer->end_of_file
&& p->current_origin>(p->text_buffer->size-MINIMAL_SIZE_PRELOADED_TEXT)) {
/* If must change of block, we update the absolute offset, and we fill the
* buffer. */
p->absolute_offset=p->absolute_offset+p->current_origin;
fill_buffer(p->text_buffer,p->current_origin,p->f_input);
p->current_origin=0;
n_blocks++;
u_printf("\rBlock %d ",n_blocks);
}
p->output[0]='\0';
empty(p->stack);
p->input_length=0;
//memset(p->buffer,0,p->current_origin);
if (p->buffer[p->current_origin]=='{') {
within_tag=1;
} else if (p->buffer[p->current_origin]=='}') {
within_tag=0;
} else if (!within_tag && (p->buffer[p->current_origin]!=' ' || p->space_policy==START_WITH_SPACE)) {
// we don't start a match on a space
unichar mot_token_buffer[MOT_BUFFER_TOKEN_SIZE];
scan_graph(0,debut,0,0,NULL,mot_token_buffer,p);
}
u_fprintf(p->f_output,"%S",p->output);
if (p->input_length==0) {
// if no input was read, we go on
u_fputc(p->buffer[p->current_origin],p->f_output);
(p->current_origin)++;
}
else {
// we increase current_origin
p->current_origin=p->current_origin+p->input_length;
}
}
u_printf("\r \n");
free_Variables(p->variables);
p->variables=NULL;
}
static tcp_socket_connect_callback_t app_tcp_connect_callback(NETSOCKET socket)
{
u_printf("socket %d connected\n", socket);
g_tcp_connect_flag = 3;
hfnet_tcp_send(socket, "GET / HTTP/1.1\r\n\r\n", strlen("GET / HTTP/1.1\r\n\r\n"));
}
/**
* This function loads the given tagset file and returns the corresponding tagset_t
* structure.
*/
tagset_t* load_tagset(U_FILE* f) {
unichar buf[MAXBUF];
token_t* toks=NULL;
/* First, we read the language name */
while (toks==NULL) {
if ((u_fgets(buf,MAXBUF,f)) == EOF) {
error("Tagset definition file is empty\n");
return NULL;
}
line_cleanup(buf);
toks=tokenize(buf);
}
if (toks->type!=TOK_NAME || toks->next==NULL || toks->next->str==NULL) {
fatal_error("Tagset language needs a name\n");
}
tagset_t* tagset=new_tagset_t(toks->next->str);
int nb=0;
pos_section_t* pos;
while ((pos=parse_pos_section(f))!=NULL) {
pos->next=tagset->pos_sections;
tagset->pos_sections=pos;
nb++;
}
free_token_t(toks);
u_printf("%d POS definitions loaded.\n",nb);
return tagset;
}
void soft_reset(void)
{
u_printf(INFO,"system well reset \r\n");
NVIC_SystemReset();
__DSB();
while (1);
}
void check_valid_INF_lines(const unichar* t, bool* tableau, const struct INF_codes* inf)
{
u_printf("Check valid %S components...\n",t);
for (int i=0;i<inf->N;i++) {
tableau[i] = check_is_valid_for_an_INF_line(t, inf->codes[i]);
}
}
int USER_FUNC app_main(void)
{
u_printf("\n%s Start %s %s\n\n",g_hfm_name[__HF_MODULE_ID__],__DATE__,__TIME__);
if(hfnet_start_assis(ASSIS_PORT) != HF_SUCCESS)
{
HF_Debug(DEBUG_WARN,"start httpd fail\n");
}
#ifdef SUPPORT_UART_THROUGH
if(hfnet_start_socketa(0,NULL) != HF_SUCCESS)
{
HF_Debug(DEBUG_WARN,"start socketa fail\n");
}
if(hfnet_start_socketb(1,NULL) != HF_SUCCESS)
{
HF_Debug(DEBUG_WARN,"start socketb fail\n");
}
if(hfnet_start_uart_ex(0,NULL,4096) != HF_SUCCESS)
{
HF_Debug(DEBUG_WARN,"start uart fail!\n");
}
#else
if(hfnet_start_uart_ex(0,NULL,1024) != HF_SUCCESS)
{
HF_Debug(DEBUG_WARN,"start uart fail!\n");
}
#endif
return 1;
}
/**
* @brief This function handles NMI exception.
* @param None
* @retval None
*/
void NMI_Handler(void)
{
// u_printf(ERR_FUN,"");
while(1)
{
u_printf(ERR_FUN,"");
}
}
/**
* This function reads words from the unknown word file and tries to
* analyse them. The unknown word file is supposed to contain one word
* per line. If a word cannot be analyzed, we print it to the new
* unknown word list file.
*/
void analyse_norwegian_unknown_words(struct norwegian_infos* infos) {
unichar line[10000];
u_printf("Analysing norwegian unknown words...\n");
int n=0;
/* We read each line of the unknown word list and we try to analyze it */
while (EOF!=u_fgets_limit2(line,10000,infos->unknown_word_list)) {
if (!analyse_norwegian_word(line,infos)) {
/* If the analysis has failed, we store the word in the
* new unknown word file */
u_fprintf(infos->new_unknown_word_list,"%S\n",line);
} else {
/* Otherwise, we increase the number of analyzed words */
n++;
}
}
u_printf("%d words decomposed as compound words\n",n);
}
/**
* @brief This function handles Debug Monitor exception.
* @param None
* @retval None
*/
void DebugMon_Handler(void)
{
// u_printf(ERR_FUN,"");
while(1)
{
u_printf(ERR_FUN,"");
}
}
int main_fst2txt(struct fst2txt_parameters* p) {
p->f_input=u_fopen_existing_versatile_encoding(p->mask_encoding_compatibility_input,p->text_file,U_READ);
if (p->f_input==NULL) {
error("Cannot open file %s\n",p->text_file);
return 1;
}
p->text_buffer=new_buffer_for_file(UNICHAR_BUFFER,p->f_input,CAPACITY_LIMIT);
p->buffer=p->text_buffer->unichar_buffer;
p->f_output=u_fopen_creating_versatile_encoding(p->encoding_output,p->bom_output,p->temp_file,U_WRITE);
if (p->f_output==NULL) {
error("Cannot open temporary file %s\n",p->temp_file);
u_fclose(p->f_input);
return 1;
}
p->fst2=load_abstract_fst2(p->fst_file,1,NULL);
if (p->fst2==NULL) {
error("Cannot load grammar %s\n",p->fst_file);
u_fclose(p->f_input);
u_fclose(p->f_output);
return 1;
}
if (p->alphabet_file!=NULL && p->alphabet_file[0]!='\0') {
p->alphabet=load_alphabet(p->alphabet_file);
if (p->alphabet==NULL) {
error("Cannot load alphabet file %s\n",p->alphabet_file);
u_fclose(p->f_input);
u_fclose(p->f_output);
free_abstract_Fst2(p->fst2,NULL);
return 1;
}
}
u_printf("Applying %s in %s mode...\n",p->fst_file,(p->output_policy==MERGE_OUTPUTS)?"merge":"replace");
build_state_token_trees(p);
parse_text(p);
u_fclose(p->f_input);
u_fclose(p->f_output);
af_remove(p->text_file);
af_rename(p->temp_file,p->text_file);
u_printf("Done.\n");
return 0;
}
int main_Reg2Grf(int argc,char* const argv[]) {
if (argc==1) {
usage();
return 0;
}
Encoding encoding_output = DEFAULT_ENCODING_OUTPUT;
int bom_output = DEFAULT_BOM_OUTPUT;
int mask_encoding_compatibility_input = DEFAULT_MASK_ENCODING_COMPATIBILITY_INPUT;
int val,index=-1;
struct OptVars* vars=new_OptVars();
while (EOF!=(val=getopt_long_TS(argc,argv,optstring_Reg2Grf,lopts_Reg2Grf,&index,vars))) {
switch(val) {
case 'k': if (vars->optarg[0]=='\0') {
fatal_error("Empty input_encoding argument\n");
}
decode_reading_encoding_parameter(&mask_encoding_compatibility_input,vars->optarg);
break;
case 'q': if (vars->optarg[0]=='\0') {
fatal_error("Empty output_encoding argument\n");
}
decode_writing_encoding_parameter(&encoding_output,&bom_output,vars->optarg);
break;
case 'h': usage(); return 0;
case ':': if (index==-1) fatal_error("Missing argument for option -%c\n",vars->optopt);
else fatal_error("Missing argument for option --%s\n",lopts_Reg2Grf[index].name);
case '?': if (index==-1) fatal_error("Invalid option -%c\n",vars->optopt);
else fatal_error("Invalid option --%s\n",vars->optarg);
break;
}
index=-1;
}
if (vars->optind!=argc-1) {
fatal_error("Invalid arguments: rerun with --help\n");
}
U_FILE* f=u_fopen_existing_versatile_encoding(mask_encoding_compatibility_input,argv[vars->optind],U_READ);
if (f==NULL) {
fatal_error("Cannot open file %s\n",argv[vars->optind]);
}
/* We read the regular expression in the file */
unichar exp[REG_EXP_MAX_LENGTH];
if ((REG_EXP_MAX_LENGTH-1)==u_fgets(exp,REG_EXP_MAX_LENGTH,f)) {
fatal_error("Too long regular expression\n");
}
u_fclose(f);
char grf_name[FILENAME_MAX];
get_path(argv[vars->optind],grf_name);
strcat(grf_name,"regexp.grf");
if (!reg2grf(exp,grf_name,encoding_output,bom_output)) {
return 1;
}
free_OptVars(vars);
u_printf("Expression converted.\n");
return 0;
}
/////////////////////////////////////////////////////////////////////////////////
// Prints single unit into a DELAC file.
// If 'unit' void returns 1, if memory allocation problem returns -1, 0 otherwise.
int DLC_print_unit(struct l_morpho_t* pL_MORPHO,SU_id_T* unit) {
if (unit == NULL)
return 1;
u_printf("%S", unit->form);
if (unit->lemma) {
u_printf("(%S.%s", unit->lemma->unit, unit->lemma->paradigm);
if (unit->feat) {
unichar* tmp;
tmp = d_get_str_feat(pL_MORPHO,unit->feat);
if (tmp == NULL)
return -1;
u_printf(":%S", tmp);
free(tmp);
}
u_printf(")");
}
return 0;
}
