src/bookmarks/sql/src/engine_bookmark.c

00001 /******************************************************************************
00002 This file is part of mdictionary.
00003 
00004 mdictionary is free software; you can redistribute it and/or modify
00005 it under the terms of the GNU General Public License as published by
00006 the Free Software Foundation; either version 2 of the License, or
00007 (at your option) any later version.
00008 
00009 mdictionary is distributed in the hope that it will be useful, 
00010 but WITHOUT ANY WARRANTY; without even the implied warranty of
00011 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
00012 GNU General Public License for more details.
00013 
00014 You should have received a copy of the GNU General Public License 
00015 along with mdictionary; if not, write to the Free Software
00016 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
00017 
00018 Copyright 2006 ComArch S.A.
00019 ******************************************************************************/
00020 
00021 // header with data structure and function definition for XDXF engine.
00022 // Also Engine API. 
00023 #include <engine_bookmark.h>
00024 //------------------------------------------------------------------------------
00025 
00026 #ifndef NOLOGS
00027 #include <glib/gstdio.h>
00028 #include <string.h>
00029 #include <stdlib.h>
00030 #endif
00031 
00032 #define LOGS g_debug
00033 
00034 /*inline void LOGS(gchar* frm, ...) {
00035 #ifndef NOLOGS
00036         //g_printf(frm);
00037 #endif
00038 }*/
00039 
00040 //==============================================================================
00041 //==============================================================================
00042 //==============================================================================
00043 //-------------------------------------- FUNCTION FROM API 0.2 !!!
00044 //==============================================================================
00045 int get_id(void* data,int n,char** argv,char** names) {
00046         int len = strlen(&(argv[0][0]));
00047         memcpy(data,&(argv[0][0]), len);
00048         gchar* tmp = (gchar*)data;
00049         tmp[len] = 0;
00050         return 0;
00051 }
00052 
00053 gboolean bm_engine_add_word(Engine* engine,
00054                          gchar*  word,
00055                          gchar*  translation) {
00056         gint sql_res = 0;
00057         gchar* err = NULL;
00058         gboolean result = TRUE;
00059         gchar* sql = NULL;
00060 
00061         LOGS("Bookmark/%s->%s() called. Param\nEngine at address: %p\n"
00062              "word: %s\ntranslation address: %p\n",
00063              (gchar*)__FILE__,
00064              (gchar*)__FUNCTION__,
00065              engine,
00066              word,
00067              translation
00068             );
00069         g_assert(engine != NULL);
00070         g_assert(word != NULL);
00071         g_assert(translation != NULL);
00072 
00073         // start timer for this function
00074         timer(TIMER_START, (gchar*)(gchar*)__FUNCTION__);
00075 
00076         BookData* data = (BookData*)(engine->engine_data);
00077 /*
00078 
00079         gchar* tmp = g_utf8_strdown(word,-1);
00080         sql = g_strconcat("INSERT INTO words VALUES(NULL,\'",tmp,"\');",NULL);
00081         sql_res = sqlite_exec(data->db, sql, NULL, NULL, &err);
00082         if(err || sql_res!=0) {
00083                 LOGS("This word exists already\nError description: %s\n",err);
00084         }            
00085         g_free(sql); sql = NULL;
00086         const gchar* end;
00087         sqlite_vm* query = NULL;
00088 
00089         sql = g_strconcat("SELECT id FROM words WHERE word=\'",tmp,"\'",NULL);
00090         gchar word_id[20];
00091         sqlite_exec(
00092                 (data->db),
00093                 sql,
00094                 get_id,
00095                 word_id,
00096                 &err
00097         );
00098         LOGS("Founded id is equal: %s\n",word_id);
00099 */
00100         //sql = g_strconcat("INSERT INTO translations VALUES(NULL,\'",word,"\',\'",translation,"\');",NULL);
00101         sql = sqlite_mprintf("INSERT INTO translations VALUES(NULL,\'%q\',\'%q\');", word, translation);
00102 
00103         sql_res = sqlite_exec(data->db, sql, NULL, NULL, &err);
00104         if(err || sql_res!=0) {
00105                 LOGS("Error while adding translation for word %s\n"
00106                      "Reason: %s",
00107                      word,
00108                      err
00109                     );
00110                 result = FALSE;
00111         } 
00112         g_free(sql); sql = NULL;
00113 
00114         timer(TIMER_STOP, (gchar*)(gchar*)__FUNCTION__);
00115         return result;
00116 }
00117 //------------------------------------------------------------------------------
00118 gboolean bm_engine_remove_word(Engine* engine, gchar*  word) {
00119         gint sql_res = 0;
00120         gchar* err = NULL;
00121         gboolean result = TRUE;
00122 
00123         LOGS("Bookmark/%s->%s() called. Param\nEngine at address: %p\n"
00124              "word: %s\n",(gchar*)__FILE__,(gchar*)__FUNCTION__,engine,word);
00125         g_assert(engine != NULL);
00126         g_assert(word != NULL);
00127         timer(TIMER_START, (gchar*)(gchar*)__FUNCTION__);
00128 
00129         BookData* data = (BookData*)(engine->engine_data);
00130 /*
00131         gchar* tmp = g_utf8_strdown(word,-1);
00132         gchar* sql = g_strconcat("DELETE FROM translations WHERE word_id = "
00133                                  "(SELECT id FROM words WHERE word=\'",
00134                                  tmp,
00135                                  "\');",
00136                                  NULL
00137                                 );
00138         g_free(tmp); tmp = NULL;
00139         sql_res = sqlite_exec(data->db, sql, NULL, NULL, &err);
00140         if(err || sql_res!=0) {
00141                 LOGS("Error while deleting \'%s\' word translation(s):\n%s\n",word,err);
00142                 g_free(sql); sql = NULL;
00143                 return FALSE;
00144         }        
00145         g_free(sql); sql = NULL;
00146 
00147         gchar* sql = g_strconcat("DELETE FROM translations WHERE word LIKE \'",
00148                                  word,
00149                                  "\';",
00150                                  NULL
00151                                 );
00152 */
00153         gchar* sql = sqlite_mprintf("DELETE FROM translations WHERE word LIKE "
00154                                         "\'%q\';", word);
00155         sql_res = sqlite_exec(data->db, sql, NULL, NULL, &err);
00156         if(err || sql_res!=0) {
00157                 LOGS("Error while deleting \'%s\' <-> reason:\n%s\n",word,err);
00158                 g_free(sql); sql = NULL;
00159                 return FALSE;
00160         }
00161         g_free(sql); sql = NULL;
00162 
00163         timer(TIMER_STOP, (gchar*)(gchar*)__FUNCTION__);
00164         return result;
00165 }
00166 //------------------------------------------------------------------------------      
00167 gchar* bm_engine_get_lang_from(Engine* engine) {
00168         LOGS("Bookmark/%s->%s() called.\n",(gchar*)__FILE__,(gchar*)__FUNCTION__);
00169         gchar* result = g_strdup("any");
00170         LOGS("Bookmark/%s->%s() return string=%s\n",
00171                 (gchar*)__FILE__,
00172                 (gchar*)__FUNCTION__,
00173                 result
00174                );
00175         return result;
00176 }
00177 //------------------------------------------------------------------------------
00178 gchar* bm_engine_get_lang_to(Engine* engine) {
00179         LOGS("Bookmark/%s->%s() called.\n",(gchar*)__FILE__,(gchar*)__FUNCTION__);
00180         gchar* result = g_strdup("any");
00181         LOGS("Bookmark/%s->%s() return string=%s\n",
00182                 (gchar*)__FILE__,
00183                 (gchar*)__FUNCTION__,
00184                 result
00185                );
00186         return result;
00187 }
00188 //------------------------------------------------------------------------------
00189 gchar* bm_engine_get_title(Engine* engine) {
00190         LOGS("Bookmark/%s->%s() called.\n",(gchar*)__FILE__,(gchar*)__FUNCTION__);
00191         gchar* result = g_strconcat(g_get_user_name(),"s' bookmarks",NULL);
00192         LOGS("Bookmark/%s->%s() return string=%s\n",
00193                 (gchar*)__FILE__,
00194                 (gchar*)__FUNCTION__,
00195                 result
00196                );
00197         return result;
00198 }
00199 //------------------------------------------------------------------------------
00200 gchar* bm_engine_get_icon_path(Engine* engine) {
00201         LOGS("Bookmark/%s->%s() called.\n",(gchar*)__FILE__,(gchar*)__FUNCTION__);
00202         gchar* result = g_strdup("/usr/share/pixmaps/ws_eng_bookmark_icon.png");
00203         LOGS("Bookmark/%s->%s() return string=%s\n",
00204                 (gchar*)__FILE__,
00205                 (gchar*)__FUNCTION__,
00206                 result
00207                );
00208         return result;
00209 }
00210 
00211 //==============================================================================
00212 //==============================================================================
00213 //==============================================================================
00214 //-------------------------------------- FUNCTION TO WRITE (NOT IMPLEMENTED YET)
00215 //==============================================================================
00216 
00217 //------------------------------------------------------------------------------
00218 // searching word by concrete engine
00219 void bm_engine_search_word_translation(Engine* engine, gchar* word)
00220 {
00221         LOGS("Bookmark/%s->%s() called.\n-->PARAM:engine at adress=%p\n"
00222              "-->PARAM:word=\'%s\'\n",
00223              (gchar*)__FILE__,
00224              (gchar*)__FUNCTION__,
00225              engine,
00226              word
00227             );
00228         g_assert(engine != NULL);
00229         g_assert(word != NULL);
00230         // start timer for this function
00231         timer(TIMER_START, (gchar*)(gchar*)__FUNCTION__);
00232         BookData* data = (BookData*)(engine->engine_data);
00233         //gchar* tmp = g_utf8_strdown(word,-1);
00234         sqlite_vm* query;
00235         gchar* sql = NULL;
00236         gchar* tran = NULL;
00237 
00238 /*
00239         sql = g_strconcat("SELECT * FROM translations WHERE "
00240                           "word_id=(SELECT id FROM words WHERE word=\'",
00241                           tmp,
00242                           "\');",
00243                           NULL);
00244 */
00245 
00246         /*sql = g_strconcat("SELECT * FROM translations WHERE word LIKE \'",
00247                           tmp,
00248                           "\';",
00249                           NULL);*/
00250         sql = sqlite_mprintf("SELECT translation FROM translations WHERE word LIKE '%q';",
00251                                 word);
00252 
00253         gint sql_res = 0;
00254         const gchar* end;
00255         gchar* err = NULL;
00256         sql_res = sqlite_compile(data->db,  /* The open database */
00257                                  (const gchar*)sql, /* SQL statement to be compiled */
00258                                  &end,      /* OUT: uncompiled tail of zSql */
00259                                  &query,    /* OUT: the virtual machine */
00260                                  &err       /* OUT: Error message. */
00261                                 );
00262         if(err || sql_res!=0) {
00263                 LOGS("Error while compiling query:\n%s\nreason:%s\n",sql,err);
00264                 sqlite_freemem(sql);/*g_free(sql);*/ sql = NULL;
00265                 return;
00266         }
00267 
00268         gint nCol = 0;
00269         const gchar** values = NULL;
00270         const gchar** head = NULL;
00271         gint status = 0;
00272         gboolean first = TRUE;
00273         do { 
00274                 first = TRUE;
00275                 do {
00276                         if(!first) sleep(1);
00277                         first = FALSE;
00278                         status = sqlite_step(query,
00279                                         &nCol,
00280                                         &values,
00281                                         &head 
00282                                         );
00283                         if(status == SQLITE_ROW) {
00284                                 if (tran != NULL){
00285                                         tran = g_strconcat(tran,"<BR><BR>", 
00286                                                 (gchar*)(&(values[0][0])), NULL);       
00287                                 }else{
00288                                         tran = g_strdup_printf("%s <BR><BR>",
00289                                                 (gchar*)(&(values[0][0])));
00290                                 }
00291                                 LOGS("Translation found :\n\"%s\"\n",tran);
00292                         }
00293                 } while((status == SQLITE_BUSY) && (status != SQLITE_ERROR));
00294         } while((status == SQLITE_ROW) && (status != SQLITE_ERROR));
00295         sqlite_finalize(query,&err);
00296         sqlite_freemem(sql); sql = NULL;
00297         timer(TIMER_STOP,(gchar*)(gchar*)__FUNCTION__);
00298         timer(TIMER_START,"callback for returning word's translation START");
00299         // calling callback for word translation
00300 
00301         data->cb_search_word_trans(tran, word, data->cb_search_word_trans_data,
00302                                          ENGINE_NO_ERROR);
00303                 
00304         timer(TIMER_STOP,"callback for returning word's translation END");
00305         if(data->auto_free) {
00306                 LOGS("Bookmark/%s->%s() deleting all dynamic data because "
00307                      "AUTO_FREE=TRUE\n",
00308                      (gchar*)__FILE__,
00309                      (gchar*)__FUNCTION__
00310                     );
00311                 g_free(tran);
00312         }
00313         tran = NULL;
00314 }
00315 
00316 //------------------------------------------------------------------------------
00317 void bm_engine_close(Engine* engine)
00318 {
00319         LOGS("Bookmark/%s->%s() called.\n-->PARAM: engine adress=%p\n",
00320                 (gchar*)__FILE__,
00321                 (gchar*)__FUNCTION__,
00322                 engine);
00323         g_assert(engine != NULL);
00324         
00325         BookData* data = (BookData*)(engine->engine_data);
00326         sqlite_close(data->db);
00327         
00328         LOGS("Bookmark/%s->%s() engine at adress=%p is deleted.\n",
00329                 (gchar*)__FILE__,
00330                 (gchar*)__FUNCTION__,
00331                 engine);
00332         g_free(engine);
00333         engine = NULL;
00334 }
00335 //------------------------------------------------------------------------------
00336 
00337 Engine* bm_engine_create(gchar* location,
00338                       EngineOptimizationFlag auto_cache,
00339                       cb_progress progress_handler,
00340                       gpointer progress_data,
00341                       gdouble seed)
00342 {
00343         LOGS("Bookmark/%s->%s() called.\n"
00344              "-->PARAM:location=\'%s\'\n"
00345              "-->PARAM:auto_cache=%d\n",
00346              (gchar*)__FILE__,
00347              (gchar*)__FUNCTION__,
00348              location,
00349              (guint)auto_cache
00350             );
00351         timer(TIMER_START,(gchar*)(gchar*)__FUNCTION__);        
00352         gchar* tmp = g_strdup(location);
00353         string_to_path(&tmp);
00354 
00355         Engine* result = (Engine*)g_try_malloc(sizeof(Engine));
00356         result->engine_location = bm_engine_location;
00357         result->engine_is_optimized = bm_engine_is_optimized;
00358         result->engine_optimize = bm_engine_optimize;
00359         result->engine_search_word_list = bm_engine_search_word_list;
00360         result->engine_search_word_translation = 
00361                         bm_engine_search_word_translation;        
00362         result->engine_close = bm_engine_close;
00363         result->engine_status = bm_engine_status;
00364         result->engine_error_message = bm_engine_status_message;
00365         result->engine_set_callback = bm_engine_set_callback;
00366         result->engine_set_progress_seed = bm_engine_set_progress_seed;
00367         result->engine_set_auto_free = bm_engine_set_auto_free;
00368         // 0.2 API:
00369         result->engine_add_word = bm_engine_add_word;
00370         result->engine_remove_word = bm_engine_remove_word;
00371         result->engine_get_lang_from = bm_engine_get_lang_from;
00372         result->engine_get_lang_to = bm_engine_get_lang_to;
00373         result->engine_get_title = bm_engine_get_title;
00374         result->engine_get_icon_path = bm_engine_get_icon_path;
00375 
00376 
00377         BookData* data = (BookData*)g_try_malloc(sizeof(BookData));
00378         result->engine_data = (gpointer)data;
00379 
00380         LOGS("Bookmark/%s->%s() opening file...\'%s\'.\n",
00381              (gchar*)__FILE__,
00382              (gchar*)__FUNCTION__,
00383              location
00384             );
00385         gchar* tmp2 = g_strconcat(tmp,"/ws_bookmarks",NULL);
00386         gchar* err;
00387         data->db = sqlite_open(tmp2,0600,&err);
00388         g_free(tmp2); tmp2 = NULL;
00389         if(!(data->db)) {
00390                 LOGS("Bookmark/%s->%s() opening bookmark file failed.%s\n",
00391                      (gchar*)__FILE__,
00392                      (gchar*)__FUNCTION__,
00393                      err
00394                     );
00395                 g_free(err);
00396                 g_free(data);
00397                 g_free(result);
00398                 result = NULL;
00399         }
00400         else {
00401                 LOGS("Bookmark/%s->%s()opening dictionary file successed.\n",
00402                         (gchar*)__FILE__,
00403                         (gchar*)__FUNCTION__
00404                        );
00405                 data->dict_path = g_strdup(tmp);
00406                 data->cb_progress_caching = progress_handler;
00407                 data->cb_progress_caching_data = progress_data;        
00408                 data->cb_progress_caching_seed = seed;        
00409                 data->cb_progress_word_list = NULL;
00410                 data->cb_progress_word_list_data = NULL;
00411                 data->cb_progress_word_list_seed = 0.01;
00412                 data->cb_progress_word_trans = NULL;
00413                 data->cb_progress_word_trans_data = NULL;
00414                 data->cb_progress_word_trans_seed = 0.01;
00415 
00416                 data->cb_search_word_list = NULL;
00417                 data->cb_search_word_list_data = NULL;
00418 
00419                 data->cb_search_word_trans = NULL;
00420                 data->cb_search_word_trans_data = NULL;
00421 
00422                 data->auto_free = FALSE;
00423                 // there is no cache mechanizm in bookmarks
00424         }
00425         g_free(tmp); tmp = NULL;
00426         
00427         timer(TIMER_STOP,(gchar*)(gchar*)__FUNCTION__);
00428         LOGS("Bookmark/%s->%s() returned Engine at adress=%p\n",
00429              (gchar*)__FILE__,
00430              (gchar*)__FUNCTION__,
00431              result
00432             );
00433         return result;
00434 }
00435 //------------------------------------------------------------------------------
00436 
00437 
00438 
00439 static gboolean is_Bookmark_file(gchar* file) {
00440         LOGS("Bookmark/%s->%s() called.\n\
00441                  -->PARAM:file=\'%s\'\n",
00442                  (gchar*)__FILE__,
00443                  (gchar*)__FUNCTION__,
00444                  file
00445                );
00446         gchar* err;
00447         sqlite* tmp = sqlite_open(file,0600,&err);
00448         if(err || tmp==NULL) {
00449                 LOGS("Wrong file! Not a sqlite database.\n");
00450                 g_free(err); 
00451                 return FALSE;
00452         }
00453 
00454         gint result = 0;
00455         gchar sql[] = "SELECT COUNT(word) FROM translations WHERE word=\'.\';";  
00456 
00457         result = sqlite_exec(tmp, sql, NULL, NULL, &err);
00458         if(err || result!=0) {
00459                 LOGS("Wrong database! Not a bookmark.\n");
00460                 g_free(err);
00461                 sqlite_close(tmp);
00462                 return FALSE;
00463         }
00464         sqlite_close(tmp);
00465         return TRUE;
00466 }
00467 //------------------------------------------------------------------------------
00468 
00469 
00470 void bm_engine_optimize(Engine* engine)
00471 {
00472         LOGS("Bookmark/%s->%s() called for engine at adress=%p\n",
00473              (gchar*)__FILE__,
00474              (gchar*)__FUNCTION__,
00475              engine
00476             );
00477         LOGS("Unsupported optimization mechanizm for this engine!\n");
00478         LOGS("Bookmark/%s->%s()'s work finished.\n",(gchar*)__FILE__,(gchar*)__FUNCTION__);
00479 }
00480 //------------------------------------------------------------------------------
00481 gboolean bm_engine_check(gchar* location) 
00482 {        
00483         LOGS("Bookmark/%s->%s() called.\n-->PARAM:location=\'%s\'\n",
00484              (gchar*)__FILE__,
00485              (gchar*)__FUNCTION__,
00486              location
00487             );
00488         timer(TIMER_START,(gchar*)(gchar*)__FUNCTION__);
00489         gboolean result = TRUE;        
00490         gchar* filepath = g_strdup(location);
00491         gchar* tmp = NULL;
00492         string_to_path(&filepath);
00493         if (filepath == NULL) {
00494                 result = FALSE;
00495                 LOGS("Bookmark/%s->%s() location \'%s\' is not a proper "
00496                      "path!\n",
00497                      (gchar*)__FILE__,
00498                      (gchar*)__FUNCTION__,
00499                      location
00500                     );
00501         }
00502         else {
00503                 tmp = g_strconcat(filepath,"/ws_bookmarks",NULL);
00504                 g_free(filepath);
00505                 filepath = tmp;
00506                 tmp = NULL;
00507 
00508                 LOGS("Bookmark/%s->%s() finnal file to check is: %s\n",
00509                      (gchar*)__FILE__,
00510                      (gchar*)__FUNCTION__,
00511                      filepath
00512                     );
00513                 if (!g_file_test(filepath, G_FILE_TEST_IS_REGULAR)) {
00514                         LOGS("Bookmark/%s->%s() file \'%s\' does not exists!\n",
00515                              (gchar*)__FILE__,
00516                              (gchar*)__FUNCTION__,
00517                              filepath
00518                             );
00519                         result = FALSE;
00520                 };
00521         };
00522         if (result != FALSE) {
00523                 result = is_Bookmark_file(filepath);
00524         };
00525 
00526         g_free(filepath);
00527         timer(TIMER_STOP,(gchar*)(gchar*)__FUNCTION__);
00528         LOGS("Bookmark/%s->%s() returned bool statement=%s.\n",
00529              (gchar*)__FILE__,
00530              (gchar*)__FUNCTION__,
00531              PRINT_STATE(result)
00532             );
00533         return result;
00534 }
00535 
00536 //------------------------------------------------------------------------------
00537 gboolean bm_engine_is_optimized(Engine* engine) 
00538 {
00539         LOGS("Bookmark/%s->%s() called.\n-->PARAM: engine adress=%p\n",
00540              (gchar*)__FILE__,
00541              (gchar*)__FUNCTION__,
00542              engine
00543             );
00544         g_assert(engine != NULL);                
00545         gboolean result = FALSE;
00546         LOGS("Bookmark/%s->%s() returned bool statement=%s.\n",
00547              (gchar*)__FILE__,
00548              (gchar*)__FUNCTION__,
00549              PRINT_STATE(result)
00550             );
00551         return result;
00552 }
00553 //------------------------------------------------------------------------------
00554 
00555 void bm_engine_search_word_list(Engine* engine, gchar* pattern)
00556 {
00557         LOGS("Bookmark/%s->%s() called. Searching words list\n"
00558              "-->PARAM:engine at adress=%p\n"
00559              "-->PARAM:pattern=\"%s\"\n",
00560              (gchar*)__FILE__,
00561              (gchar*)__FUNCTION__,
00562              engine,
00563              pattern
00564             );
00565         g_assert(engine != NULL);
00566         g_assert(pattern != NULL);
00567 
00568         timer(TIMER_START,(gchar*)(gchar*)__FUNCTION__);
00569         BookData* data = (BookData*)(engine->engine_data);
00570         if(data->cb_search_word_list == NULL) {
00571                 LOGS("Bookmark/%s->%s() callback for Word List not set. "
00572                      "Searching aborted.\n",
00573                      (gchar*)__FILE__,
00574                      (gchar*)__FUNCTION__
00575                     );
00576                 timer(TIMER_STOP,(gchar*)(gchar*)__FUNCTION__);
00577                 return;
00578         };
00579  
00580 
00581         gchar* tmp = g_utf8_strdown(pattern,-1);
00582         sqlite_vm* query = NULL;
00583         gchar* sql = NULL;
00584         gchar* tran = NULL;
00585 
00586         //LOGS("::::BOOKMARKS!!!!:::: tmp = %s, int(tmp) = %i", tmp, tmp[0]);
00587 
00588 
00589         g_strstrip(tmp);
00590         if ((int)(tmp[0]) == 42 && tmp[1] == '\0') //asterix?
00591         {
00592                 sql = g_strconcat("SELECT DISTINCT word FROM translations;", NULL);
00593         }
00594         else
00595         {
00596                 sql = g_strconcat("SELECT word FROM translations WHERE "
00597                           "word LIKE \'",tmp,"\%\';",NULL);
00598         }
00599         LOGS("QUERY: %s\n",sql);
00600         gint sql_res = 0;
00601         const gchar* end;
00602         gchar* err = NULL;
00603         sql_res = sqlite_compile(data->db,  /* The open database */
00604                                  (const gchar*)sql,       /* SQL statement to be compiled */
00605                                  &end,      /* OUT: uncompiled tail of zSql */
00606                                  &query,    /* OUT: the virtual machine */
00607                                  &err       /* OUT: Error message. */
00608                                 );
00609         if(err || sql_res!=0) {
00610                 LOGS("Error while compiling query:\n%s\nreason:%s\n",sql,err);
00611                 g_free(sql); sql = NULL;
00612                 return;
00613         };    
00614         gint nCol = 0;
00615         const gchar** values = NULL;
00616         const gchar** head = NULL;
00617         gint status = 0;
00618         gboolean first = TRUE;
00619         GArray* result = g_array_new(TRUE, TRUE, sizeof(gchar*) );
00620         do { 
00621                 first = TRUE;
00622                 do {
00623                         if(!first) sleep(1);
00624                         first = FALSE;;
00625                         status = sqlite_step(
00626                                         query, 
00627                                         &nCol,            
00628                                         &values,  
00629                                         &head 
00630                                         );
00631                         if(status == SQLITE_ERROR) {
00632                                 LOGS("Error while making next step\n");
00633                                 g_free(sql); sql = NULL;
00634                                         return;
00635                         };
00636                         if(status == SQLITE_ROW) {
00637                                 LOGS("Fount new word: \"%s\"\n",&(values[0][0]));
00638                                 gchar* tmp = g_strdup((gchar*)&(values[0][0]));
00639                                 g_array_append_val(result, tmp );        
00640                         }
00641                 } while((status == SQLITE_BUSY) && (status != SQLITE_ERROR));
00642         } while((status == SQLITE_ROW) && (status != SQLITE_ERROR));
00643         sqlite_finalize(query,&err);
00644         timer(TIMER_STOP,(gchar*)(gchar*)__FUNCTION__);
00645 
00646 
00647         timer(TIMER_START,"callback for returning words LIST START");
00648         // calling callback for word translation
00649 
00650         data->cb_search_word_list(result , pattern, data->cb_search_word_list_data, ENGINE_NO_ERROR);
00651                 
00652         timer(TIMER_STOP,"callback for returning word LIST END");
00653         if(data->auto_free) {
00654                 LOGS("Bookmark/%s->%s() deleting all dynamic data because "
00655                      "AUTO_FREE=TRUE\n",
00656                      (gchar*)__FILE__,
00657                      (gchar*)__FUNCTION__
00658                     );
00659                 g_free(tran);
00660         }
00661 }
00662 
00663 //==============================================================================
00664 //==============================================================================
00665 //==============================================================================
00666 //---------------------------------------------------------- COMPLETED FUNCTIONS
00667 //==============================================================================
00668 // global functions
00669 EngineModule engine_global_functions()
00670 {
00671         LOGS("Bookmark/%s->%s() called.\n",(gchar*)__FILE__,(gchar*)__FUNCTION__);
00672         EngineModule result;        
00673         result.engine_check             = bm_engine_check;
00674         result.engine_description       = bm_engine_description;
00675         result.engine_format            = bm_engine_format;
00676         result.engine_version           = bm_engine_version;
00677         result.engine_create            = bm_engine_create;
00678         LOGS("Bookmark/%s->%s()returned EngineModule at adress=%p.\n",
00679              (gchar*)__FILE__,
00680              (gchar*)__FUNCTION__,
00681              &result
00682             );
00683         return result;
00684 }
00685 //------------------------------------------------------------------------------
00686 // for macro: dict_eng_status_message(error)
00687 gchar* bm_engine_status_message(EngineStatus error) 
00688 {
00689         LOGS("Bookmark/%s->%s() called.\n",(gchar*)__FILE__,(gchar*)__FUNCTION__);
00690         switch (error) {
00691                 case ENGINE_NO_ERROR:
00692                         return "No error.";
00693                 case ENGINE_WRONG_FILE:
00694                         return "File which You are trying to use is wrong type.";
00695                 case ENGINE_COULDNT_READ:
00696                         return "Could not read from file.";
00697                 case ENGINE_NO_FILE:
00698                         return "There is no such a file.";
00699                 case ENGINE_OUT_OF_MEMORY:
00700                         return "There were no enough memory for this action.";
00701                 default:
00702                         return "Wrong engine's status identifier!";
00703         }
00704 }
00705 //------------------------------------------------------------------------------
00706 // for macro: dict_eng_module_get_version(module)
00707 gchar* bm_engine_version() 
00708 {
00709         LOGS("Bookmark/%s->%s() called.\n",(gchar*)__FILE__,(gchar*)__FUNCTION__);
00710         gchar* result = g_strdup(DIC_ENG_VERSION);
00711         LOGS("Bookmark/%s->%s() return string=%s\n",
00712                 (gchar*)__FILE__,
00713                 (gchar*)__FUNCTION__,
00714                 result
00715                );
00716         return result;
00717 }
00718 //------------------------------------------------------------------------------
00719 // for macro: dict_eng_module_get_format(module)
00720 gchar* bm_engine_format() 
00721 {
00722         LOGS("Bookmark/%s->%s() called.\n",(gchar*)__FILE__,(gchar*)__FUNCTION__);
00723         gchar* result = g_strdup(DIC_ENG_FORMAT);
00724         LOGS("Bookmark/%s->%s() return string=%s\n",
00725              (gchar*)__FILE__,
00726              (gchar*)__FUNCTION__,
00727              result
00728             );
00729         return result;
00730 }
00731 //------------------------------------------------------------------------------
00732 // for macro: dict_eng_module_get_description(module)
00733 gchar* bm_engine_description() 
00734 {
00735         LOGS("Bookmark/%s->%s() called.\n",(gchar*)__FILE__,(gchar*)__FUNCTION__);
00736         gchar* result = g_strdup(DIC_ENG_DESCRIPTION);
00737         LOGS("Bookmark/%s->%s() return string=%s\n",
00738              (gchar*)__FILE__,
00739              (gchar*)__FUNCTION__,
00740              result
00741             );
00742         return result;
00743 }
00744 //------------------------------------------------------------------------------
00745 // for macro: dict_eng_get_location(engine)
00746 gchar* bm_engine_location(Engine* engine)
00747 {
00748         LOGS("Bookmark/%s->%s() called.\n-->PARAM: engine adress=%p\n",
00749              (gchar*)__FILE__,
00750              (gchar*)__FUNCTION__,
00751              engine
00752             );
00753         g_assert(engine != NULL);
00754         BookData* data = (BookData*)(engine->engine_data);
00755         
00756         gchar* result;
00757         if(data->auto_free) {
00758                 result = data->dict_path;
00759         }
00760         else {
00761                 result = g_strdup(data->dict_path);
00762         }
00763 
00764         LOGS("Bookmark/%s->%s() returned string=%s\n",
00765              (gchar*)__FILE__,
00766              (gchar*)__FUNCTION__,
00767              result
00768             );
00769         return result;
00770 }
00771 //------------------------------------------------------------------------------
00772 // for macro: dict_eng_set_auto_free(engine, state)
00773 void bm_engine_set_auto_free(Engine* engine, gboolean state) 
00774 {
00775         LOGS("Bookmark/%s->%s() called.\n"
00776              "-->PARAM:engine at adress=%p\n"
00777              "-->PARAM:state=%s\n",
00778              (gchar*)__FILE__,
00779              (gchar*)__FUNCTION__,
00780              engine,
00781              PRINT_STATE(state)
00782             );
00783         g_assert(engine != NULL);
00784         BookData* data = (BookData*)(engine->engine_data);
00785         
00786         data->auto_free = state;
00787         LOGS("Bookmark/%s->%s() Current auto_free is %s\n",
00788              (gchar*)__FILE__,
00789              (gchar*)__FUNCTION__,
00790              PRINT_STATE(data->auto_free)
00791             );
00792 }
00793 //------------------------------------------------------------------------------
00794 // for macro: dict_eng_get_last_status(engine)
00795 EngineStatus bm_engine_status(Engine* engine) 
00796 {
00797         LOGS("Bookmark/%s->%s() called.\n"
00798                 "-->PARAM:engine at adress=%p\n",
00799                 (gchar*)__FILE__,
00800                 (gchar*)__FUNCTION__,
00801                engine
00802                );
00803         BookData* data = (BookData*)(engine->engine_data);
00804         LOGS("Bookmark/%s->%s() returned error code: %d\n",
00805              (gchar*)__FILE__,
00806              (gchar*)__FUNCTION__,
00807              (gint)(data->last_error)
00808             );        
00809         return data->last_error;
00810 }
00811 //------------------------------------------------------------------------------
00812 // for macro: dict_eng_set_progress_seed(engine, signal, val)
00813 void bm_engine_set_progress_seed(Engine* engine, gchar* signal, gdouble seed) {
00814         LOGS("Bookmark/%s->%s() called.\n",(gchar*)__FILE__,(gchar*)__FUNCTION__);
00815         BookData* data = (BookData*)(engine->engine_data);
00816         if(g_ascii_strcasecmp(signal,ENGINE_PROGRESS_OPTIMIZING_SIGNAL) == 0)  {
00817                 data->cb_progress_caching_seed = seed;
00818                 LOGS("Bookmark/%s->%s() sets new seed=%0.2f for for signal "
00819                      "\"%s\".\n",
00820                      (gchar*)__FILE__,
00821                      (gchar*)__FUNCTION__,
00822                      seed,
00823                      signal
00824                     );        
00825         } 
00826         else {
00827                 LOGS("Bookmark/%s->%s() unsupported signalfor progress: %s.\n",
00828                      (gchar*)__FILE__,
00829                      (gchar*)__FUNCTION__,
00830                      signal
00831                     );
00832         };
00833 }
00834 //------------------------------------------------------------------------------
00835 // for macro: dict_eng_set_callback(engine,signal,c_handler,data)
00836 gpointer bm_engine_set_callback(Engine* engine,
00837                              gchar* signal,
00838                              gpointer c_handler,
00839                              gpointer user_data)
00840 {
00841         LOGS("Bookmark/%s->%s() called.\n",(gchar*)__FILE__,(gchar*)__FUNCTION__);
00842         g_assert(engine != NULL);
00843         g_assert(signal != NULL);
00844         g_assert(c_handler != NULL);
00845         BookData* data = (BookData*)(engine->engine_data);
00846         if(g_ascii_strcasecmp(signal,ENGINE_PROGRESS_OPTIMIZING_SIGNAL) == 0)  {
00847                 gpointer result = data->cb_progress_caching;
00848                 data->cb_progress_caching = c_handler;
00849                 data->cb_progress_caching_data = user_data;
00850                 LOGS("Bookmark/%s->%s() sets handler for signal \"%s\".\n",
00851                         (gchar*)__FILE__,
00852                         (gchar*)__FUNCTION__,
00853                         signal
00854                        );
00855                 LOGS("Bookmark/%s->%s() Function at adress =  %d.\n",
00856                         (gchar*)__FILE__,
00857                         (gchar*)__FUNCTION__,
00858                         (guint)c_handler
00859                        );
00860                 LOGS("Bookmark/%s->%s()     Data at adress =  %d.\n",
00861                         (gchar*)__FILE__,
00862                         (gchar*)__FUNCTION__,
00863                         (guint)user_data
00864                        );
00865                 return result;                
00866         }
00867         else if(g_ascii_strcasecmp(signal, ENGINE_WORD_LIST_SIGNAL) == 0) {
00868                 gpointer result = data->cb_search_word_list;
00869                 data->cb_search_word_list = c_handler;
00870                 data->cb_search_word_list_data = user_data;
00871                 LOGS("Bookmark/%s->%s() sets handler for signal \"%s\".\n",
00872                         (gchar*)__FILE__,
00873                         (gchar*)__FUNCTION__,
00874                         signal
00875                        );
00876                 LOGS("Bookmark/%s->%s() Function at adress =  %d.\n",
00877                         (gchar*)__FILE__,
00878                         (gchar*)__FUNCTION__,
00879                         (guint)c_handler
00880                        );
00881                 LOGS("Bookmark/%s->%s()     Data at adress =  %d.\n",
00882                         (gchar*)__FILE__,
00883                         (gchar*)__FUNCTION__,
00884                         (guint)user_data
00885                        );
00886                 return result;                        
00887         }
00888         else if(g_ascii_strcasecmp(signal,
00889                 ENGINE_WORD_TRANSLATION_SIGNAL) == 0)  {
00890                         gpointer result = data->cb_search_word_trans;
00891                         data->cb_search_word_trans = c_handler;
00892                         data->cb_search_word_trans_data = user_data;
00893                         LOGS("Bookmark/%s->%s() sets handler for signal \"%s\".\n",
00894                                 (gchar*)__FILE__,
00895                                 (gchar*)__FUNCTION__,
00896                                 signal
00897                                );
00898                         LOGS("Bookmark/%s->%s() Function at adress =  %d.\n",
00899                                 (gchar*)__FILE__,
00900                                 (gchar*)__FUNCTION__,
00901                                 (guint)c_handler
00902                                );
00903                         LOGS("Bookmark/%s->%s()     Data at adress =  %d.\n",
00904                                 (gchar*)__FILE__,
00905                                 (gchar*)__FUNCTION__,
00906                                 (guint)user_data
00907                                );
00908                         return result;                        
00909                 }
00910                 else {
00911                         g_warning("Bookmark/%s->%s() unsupported signal: %s.\n",
00912                                   (gchar*)__FILE__,
00913                                   (gchar*)__FUNCTION__,
00914                                   signal
00915                                  );
00916                         return NULL;
00917                 }
00918 }
00919 
00920 
00921 
00922 
00923 
00924 
00925 //==============================================================================
00926 //==============================================================================
00927 //==============================================================================
00928 //---------------------------------------------------------- HELPFULLY FUNCTIONS
00929 //==============================================================================
00930 
00931 //------------------------------------------------------------------------------
00932 static gchar* string_to_path(gchar** string) {
00933         LOGS("Bookmark/%s->%s() called.\n\
00934                  -->PARAM:string=\'%s\'\n",
00935                  (gchar*)__FILE__,
00936                  (gchar*)__FUNCTION__,
00937                  string[0]
00938                );
00939         gchar* arg = string[0];
00940         gchar* new = NULL;
00941         // cleaning from leading and trailing whitespaces
00942         g_strstrip(arg);        
00943          // add current directory if this is not absolute directory
00944         if (!g_path_is_absolute(arg)) {
00945                 gchar* tmp = g_get_current_dir();
00946                 new = g_strconcat(tmp,"/",arg,NULL);
00947                 g_free(arg); arg = new; new = NULL;
00948         };
00949         // this is not a directory
00950         if (!g_file_test(arg, G_FILE_TEST_IS_DIR)) {        
00951                 // if this is wrong filepath, string was wrong
00952                 if (!g_file_test(arg, G_FILE_TEST_IS_REGULAR)) {        
00953                         g_free(arg);
00954                         new = NULL;
00955                 }
00956                 //if this is a file, remove filename
00957                 else
00958                 {   
00959                         new = g_path_get_dirname (arg);
00960                         g_free(arg);
00961                 }
00962         }
00963         // this is a directory
00964         else {   
00965                 // remove suffix "/" if neded...     
00966                 if (g_str_has_suffix(arg,"/") ) {        
00967                         new = g_path_get_dirname (arg);
00968                         g_free(arg);
00969                 }
00970                 else {
00971                         new = arg;
00972                 }
00973         };
00974         // now in new should be proper filepath, if not, string was wrong
00975         if (!g_file_test(new, G_FILE_TEST_IS_DIR))  {        
00976                 // if that directory does not exist, passed string wasn't proper       
00977                 g_free(new);
00978                 new = NULL;
00979         };
00980         // replace string under passed address
00981         string[0] = new;
00982         LOGS("Bookmark/%s->%s() returned string=\'%s\'\n",
00983                 (gchar*)__FILE__,
00984                 (gchar*)__FUNCTION__,
00985                 string[0]
00986                );
00987         return new;
00988 }
00989 //------------------------------------------------------------------------------
00990 static double timer(gboolean start, gchar* message)
00991 {
00992         static GArray* stack = NULL;
00993         static gboolean first_run = TRUE;
00994         static struct timeval actual_time;
00995         static struct timeval last_time;
00996         static struct timeval result;
00997         static double seconds = 0.0;
00998         if(first_run) {
00999                 first_run = FALSE;
01000                 stack = g_array_new(TRUE, TRUE, sizeof(struct timeval));
01001         };        
01002 
01003         if (start) {
01004                 LOGS("Bookmark->%s() start timer for function '%s()'.\n",
01005                         (gchar*)__FUNCTION__,
01006                         message
01007                        );
01008                 g_array_prepend_val(stack, actual_time);
01009                 gettimeofday(&g_array_index(stack, struct timeval, 0),NULL);
01010                 return -1.0;
01011         }
01012         // we just want to end some timer - print some information about 
01013         // working time;
01014         else {          
01015                 gettimeofday(&actual_time,NULL);
01016                 last_time = g_array_index(stack, struct timeval, 0);
01017                 g_array_remove_index(stack, 0);
01018 
01019                 if (actual_time.tv_usec < last_time.tv_usec) {
01020                         int nsec = (last_time.tv_usec - actual_time.tv_usec) / 
01021                                         (1000000 + 1);
01022                         last_time.tv_usec -= 1000000 * nsec;
01023                         last_time.tv_sec += nsec;
01024                 }
01025                 if (actual_time.tv_usec - last_time.tv_usec > 1000000) {
01026                         int nsec = (last_time.tv_usec - actual_time.tv_usec) / 
01027                                         1000000;
01028                         last_time.tv_usec += 1000000 * nsec;
01029                         last_time.tv_sec -= nsec;
01030                 }
01031                 result.tv_sec = actual_time.tv_sec - last_time.tv_sec;
01032                 result.tv_usec = actual_time.tv_usec - last_time.tv_usec;
01033                 seconds = (((double)(result.tv_usec)) / 1e6) +
01034                                 ((double)(result.tv_sec));
01035 
01036                 LOGS("Bookmark->%s() function \'%s()\' was working for: %g "
01037                                 "[s] or %ld [us].\n",
01038                 (gchar*)__FUNCTION__,
01039                 message,
01040                 seconds,
01041                 ((long)(result.tv_sec*1e6)+(result.tv_usec))
01042                        );
01043                 // stack is empty so we delete everything
01044                 if(stack->len == 0)   
01045                 {
01046                         g_array_free(stack, TRUE);
01047                         first_run = TRUE;
01048                 }
01049         }
01050         return seconds;
01051 }
01052 //------------------------------------------------------------------------------
01053 
01054 
01055 

Generated on Wed Jan 2 09:19:42 2008 for WhiteStork Project by  doxygen 1.5.1