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