recog_basic_fuzzer.cc:_ZL21leptSetStdNullHandlerv: 12| 2|{ 13| 2| leptSetStderrHandler(send_to_devnull); 14| 2|} recog_basic_fuzzer.cc:_ZL15send_to_devnullPKc: 8| 4|static void send_to_devnull(const char *) {} LLVMFuzzerTestOneInput: 7| 2|{ 8| 2| leptSetStdNullHandler(); 9| | 10| 2| L_RECOG *recog; 11| 2| char filename[256]; 12| 2| sprintf(filename, "/tmp/libfuzzer.%d", getppid()); 13| | 14| 2| FILE *fp = fopen(filename, "wb"); 15| 2| if (!fp) ------------------ | Branch (15:9): [True: 0, False: 2] ------------------ 16| 0| return 0; 17| 2| fwrite(data, size, 1, fp); 18| 2| fclose(fp); 19| | 20| 2| recog = recogRead(filename); 21| | 22| 2| recogDestroy(&recog); 23| 2| unlink(filename); 24| 2| return 0; 25| 2|} recogDestroy: 473| 2|{ 474| 2|L_RECOG *recog; 475| | 476| 2| if (!precog) { ------------------ | Branch (476:9): [True: 0, False: 2] ------------------ 477| 0| L_WARNING("ptr address is null\n", __func__); ------------------ | | 610| 0| IF_SEV(L_SEVERITY_WARNING, \ | | ------------------ | | | | 586| 0| ((l) >= MINIMUM_SEVERITY && (l) >= LeptMsgSeverity ? (t) : (f)) | | | | ------------------ | | | | | | 485| 0| #define MINIMUM_SEVERITY L_SEVERITY_INFO /*!< Compile-time default */ | | | | ------------------ | | | | | Branch (586:8): [Folded - Ignored] | | | | | Branch (586:35): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 611| 0| (void)lept_stderr("Warning in %s: " a, __VA_ARGS__), \ | | 612| 0| (void)0) ------------------ 478| 0| return; 479| 0| } 480| | 481| 2| if ((recog = *precog) == NULL) return; ------------------ | Branch (481:9): [True: 2, False: 0] ------------------ 482| | 483| 0| LEPT_FREE(recog->centtab); ------------------ | | 385| 0| #define LEPT_FREE(ptr) free(ptr) ------------------ 484| 0| LEPT_FREE(recog->sumtab); ------------------ | | 385| 0| #define LEPT_FREE(ptr) free(ptr) ------------------ 485| 0| sarrayDestroy(&recog->sa_text); 486| 0| l_dnaDestroy(&recog->dna_tochar); 487| 0| pixaaDestroy(&recog->pixaa_u); 488| 0| pixaDestroy(&recog->pixa_u); 489| 0| ptaaDestroy(&recog->ptaa_u); 490| 0| ptaDestroy(&recog->pta_u); 491| 0| numaDestroy(&recog->nasum_u); 492| 0| numaaDestroy(&recog->naasum_u); 493| 0| pixaaDestroy(&recog->pixaa); 494| 0| pixaDestroy(&recog->pixa); 495| 0| ptaaDestroy(&recog->ptaa); 496| 0| ptaDestroy(&recog->pta); 497| 0| numaDestroy(&recog->nasum); 498| 0| numaaDestroy(&recog->naasum); 499| 0| pixaDestroy(&recog->pixa_tr); 500| 0| pixaDestroy(&recog->pixadb_ave); 501| 0| pixaDestroy(&recog->pixa_id); 502| 0| pixDestroy(&recog->pixdb_ave); 503| 0| pixDestroy(&recog->pixdb_range); 504| 0| pixaDestroy(&recog->pixadb_boot); 505| 0| pixaDestroy(&recog->pixadb_split); 506| 0| bmfDestroy(&recog->bmf); 507| 0| rchDestroy(&recog->rch); 508| 0| rchaDestroy(&recog->rcha); 509| 0| recogDestroyDid(recog); 510| 0| LEPT_FREE(recog); ------------------ | | 385| 0| #define LEPT_FREE(ptr) free(ptr) ------------------ 511| 0| *precog = NULL; 512| 0|} recogRead: 819| 2|{ 820| 2|FILE *fp; 821| 2|L_RECOG *recog; 822| | 823| 2| if (!filename) ------------------ | Branch (823:9): [True: 0, False: 2] ------------------ 824| 0| return (L_RECOG *)ERROR_PTR("filename not defined", __func__, NULL); ------------------ | | 593| 0| IF_SEV(L_SEVERITY_ERROR, returnErrorPtr((a), (b), (c)), (void *)(c)) | | ------------------ | | | | 586| 0| ((l) >= MINIMUM_SEVERITY && (l) >= LeptMsgSeverity ? (t) : (f)) | | | | ------------------ | | | | | | 485| 0| #define MINIMUM_SEVERITY L_SEVERITY_INFO /*!< Compile-time default */ | | | | ------------------ | | | | | Branch (586:8): [Folded - Ignored] | | | | | Branch (586:35): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 825| 2| if ((fp = fopenReadStream(filename)) == NULL) ------------------ | Branch (825:9): [True: 0, False: 2] ------------------ 826| 0| return (L_RECOG *)ERROR_PTR_1("stream not opened", ------------------ | | 602| 0| IF_SEV(L_SEVERITY_ERROR, returnErrorPtr1((a), (f), (b), (c)), \ | | ------------------ | | | | 586| 0| ((l) >= MINIMUM_SEVERITY && (l) >= LeptMsgSeverity ? (t) : (f)) | | | | ------------------ | | | | | | 485| 0| #define MINIMUM_SEVERITY L_SEVERITY_INFO /*!< Compile-time default */ | | | | ------------------ | | | | | Branch (586:8): [Folded - Ignored] | | | | | Branch (586:35): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 603| 0| (void *)(c)) ------------------ 827| 2| filename, __func__, NULL); 828| | 829| 2| if ((recog = recogReadStream(fp)) == NULL) { ------------------ | Branch (829:9): [True: 2, False: 0] ------------------ 830| 2| fclose(fp); 831| 2| return (L_RECOG *)ERROR_PTR_1("recog not read", ------------------ | | 602| 2| IF_SEV(L_SEVERITY_ERROR, returnErrorPtr1((a), (f), (b), (c)), \ | | ------------------ | | | | 586| 2| ((l) >= MINIMUM_SEVERITY && (l) >= LeptMsgSeverity ? (t) : (f)) | | | | ------------------ | | | | | | 485| 4| #define MINIMUM_SEVERITY L_SEVERITY_INFO /*!< Compile-time default */ | | | | ------------------ | | | | | Branch (586:8): [Folded - Ignored] | | | | | Branch (586:35): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 603| 2| (void *)(c)) ------------------ 832| 2| filename, __func__, NULL); 833| 2| } 834| | 835| 0| fclose(fp); 836| 0| return recog; 837| 2|} recogReadStream: 848| 2|{ 849| 2|l_int32 version, setsize, threshold, scalew, scaleh, linew; 850| 2|l_int32 maxyshift, nc; 851| 2|L_DNA *dna_tochar; 852| 2|PIXAA *paa; 853| 2|L_RECOG *recog; 854| 2|SARRAY *sa_text; 855| | 856| 2| if (!fp) ------------------ | Branch (856:9): [True: 0, False: 2] ------------------ 857| 0| return (L_RECOG *)ERROR_PTR("stream not defined", __func__, NULL); ------------------ | | 593| 0| IF_SEV(L_SEVERITY_ERROR, returnErrorPtr((a), (b), (c)), (void *)(c)) | | ------------------ | | | | 586| 0| ((l) >= MINIMUM_SEVERITY && (l) >= LeptMsgSeverity ? (t) : (f)) | | | | ------------------ | | | | | | 485| 0| #define MINIMUM_SEVERITY L_SEVERITY_INFO /*!< Compile-time default */ | | | | ------------------ | | | | | Branch (586:8): [Folded - Ignored] | | | | | Branch (586:35): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 858| | 859| 2| if (fscanf(fp, "\nRecog Version %d\n", &version) != 1) ------------------ | Branch (859:9): [True: 2, False: 0] ------------------ 860| 2| return (L_RECOG *)ERROR_PTR("not a recog file", __func__, NULL); ------------------ | | 593| 2| IF_SEV(L_SEVERITY_ERROR, returnErrorPtr((a), (b), (c)), (void *)(c)) | | ------------------ | | | | 586| 2| ((l) >= MINIMUM_SEVERITY && (l) >= LeptMsgSeverity ? (t) : (f)) | | | | ------------------ | | | | | | 485| 4| #define MINIMUM_SEVERITY L_SEVERITY_INFO /*!< Compile-time default */ | | | | ------------------ | | | | | Branch (586:8): [Folded - Ignored] | | | | | Branch (586:35): [True: 2, False: 0] | | | | ------------------ | | ------------------ ------------------ 861| 0| if (version != RECOG_VERSION_NUMBER) ------------------ | | 114| 0|#define RECOG_VERSION_NUMBER 2 ------------------ | Branch (861:9): [True: 0, False: 0] ------------------ 862| 0| return (L_RECOG *)ERROR_PTR("invalid recog version", __func__, NULL); ------------------ | | 593| 0| IF_SEV(L_SEVERITY_ERROR, returnErrorPtr((a), (b), (c)), (void *)(c)) | | ------------------ | | | | 586| 0| ((l) >= MINIMUM_SEVERITY && (l) >= LeptMsgSeverity ? (t) : (f)) | | | | ------------------ | | | | | | 485| 0| #define MINIMUM_SEVERITY L_SEVERITY_INFO /*!< Compile-time default */ | | | | ------------------ | | | | | Branch (586:8): [Folded - Ignored] | | | | | Branch (586:35): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 863| 0| if (fscanf(fp, "Size of character set = %d\n", &setsize) != 1) ------------------ | Branch (863:9): [True: 0, False: 0] ------------------ 864| 0| return (L_RECOG *)ERROR_PTR("setsize not read", __func__, NULL); ------------------ | | 593| 0| IF_SEV(L_SEVERITY_ERROR, returnErrorPtr((a), (b), (c)), (void *)(c)) | | ------------------ | | | | 586| 0| ((l) >= MINIMUM_SEVERITY && (l) >= LeptMsgSeverity ? (t) : (f)) | | | | ------------------ | | | | | | 485| 0| #define MINIMUM_SEVERITY L_SEVERITY_INFO /*!< Compile-time default */ | | | | ------------------ | | | | | Branch (586:8): [Folded - Ignored] | | | | | Branch (586:35): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 865| 0| if (fscanf(fp, "Binarization threshold = %d\n", &threshold) != 1) ------------------ | Branch (865:9): [True: 0, False: 0] ------------------ 866| 0| return (L_RECOG *)ERROR_PTR("binary thresh not read", __func__, NULL); ------------------ | | 593| 0| IF_SEV(L_SEVERITY_ERROR, returnErrorPtr((a), (b), (c)), (void *)(c)) | | ------------------ | | | | 586| 0| ((l) >= MINIMUM_SEVERITY && (l) >= LeptMsgSeverity ? (t) : (f)) | | | | ------------------ | | | | | | 485| 0| #define MINIMUM_SEVERITY L_SEVERITY_INFO /*!< Compile-time default */ | | | | ------------------ | | | | | Branch (586:8): [Folded - Ignored] | | | | | Branch (586:35): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 867| 0| if (fscanf(fp, "Maxyshift = %d\n", &maxyshift) != 1) ------------------ | Branch (867:9): [True: 0, False: 0] ------------------ 868| 0| return (L_RECOG *)ERROR_PTR("maxyshift not read", __func__, NULL); ------------------ | | 593| 0| IF_SEV(L_SEVERITY_ERROR, returnErrorPtr((a), (b), (c)), (void *)(c)) | | ------------------ | | | | 586| 0| ((l) >= MINIMUM_SEVERITY && (l) >= LeptMsgSeverity ? (t) : (f)) | | | | ------------------ | | | | | | 485| 0| #define MINIMUM_SEVERITY L_SEVERITY_INFO /*!< Compile-time default */ | | | | ------------------ | | | | | Branch (586:8): [Folded - Ignored] | | | | | Branch (586:35): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 869| 0| if (fscanf(fp, "Scale to width = %d\n", &scalew) != 1) ------------------ | Branch (869:9): [True: 0, False: 0] ------------------ 870| 0| return (L_RECOG *)ERROR_PTR("width not read", __func__, NULL); ------------------ | | 593| 0| IF_SEV(L_SEVERITY_ERROR, returnErrorPtr((a), (b), (c)), (void *)(c)) | | ------------------ | | | | 586| 0| ((l) >= MINIMUM_SEVERITY && (l) >= LeptMsgSeverity ? (t) : (f)) | | | | ------------------ | | | | | | 485| 0| #define MINIMUM_SEVERITY L_SEVERITY_INFO /*!< Compile-time default */ | | | | ------------------ | | | | | Branch (586:8): [Folded - Ignored] | | | | | Branch (586:35): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 871| 0| if (fscanf(fp, "Scale to height = %d\n", &scaleh) != 1) ------------------ | Branch (871:9): [True: 0, False: 0] ------------------ 872| 0| return (L_RECOG *)ERROR_PTR("height not read", __func__, NULL); ------------------ | | 593| 0| IF_SEV(L_SEVERITY_ERROR, returnErrorPtr((a), (b), (c)), (void *)(c)) | | ------------------ | | | | 586| 0| ((l) >= MINIMUM_SEVERITY && (l) >= LeptMsgSeverity ? (t) : (f)) | | | | ------------------ | | | | | | 485| 0| #define MINIMUM_SEVERITY L_SEVERITY_INFO /*!< Compile-time default */ | | | | ------------------ | | | | | Branch (586:8): [Folded - Ignored] | | | | | Branch (586:35): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 873| 0| if (fscanf(fp, "Normalized line width = %d\n", &linew) != 1) ------------------ | Branch (873:9): [True: 0, False: 0] ------------------ 874| 0| return (L_RECOG *)ERROR_PTR("line width not read", __func__, NULL); ------------------ | | 593| 0| IF_SEV(L_SEVERITY_ERROR, returnErrorPtr((a), (b), (c)), (void *)(c)) | | ------------------ | | | | 586| 0| ((l) >= MINIMUM_SEVERITY && (l) >= LeptMsgSeverity ? (t) : (f)) | | | | ------------------ | | | | | | 485| 0| #define MINIMUM_SEVERITY L_SEVERITY_INFO /*!< Compile-time default */ | | | | ------------------ | | | | | Branch (586:8): [Folded - Ignored] | | | | | Branch (586:35): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 875| 0| if ((recog = recogCreate(scalew, scaleh, linew, threshold, ------------------ | Branch (875:9): [True: 0, False: 0] ------------------ 876| 0| maxyshift)) == NULL) 877| 0| return (L_RECOG *)ERROR_PTR("recog not made", __func__, NULL); ------------------ | | 593| 0| IF_SEV(L_SEVERITY_ERROR, returnErrorPtr((a), (b), (c)), (void *)(c)) | | ------------------ | | | | 586| 0| ((l) >= MINIMUM_SEVERITY && (l) >= LeptMsgSeverity ? (t) : (f)) | | | | ------------------ | | | | | | 485| 0| #define MINIMUM_SEVERITY L_SEVERITY_INFO /*!< Compile-time default */ | | | | ------------------ | | | | | Branch (586:8): [Folded - Ignored] | | | | | Branch (586:35): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 878| | 879| 0| if (fscanf(fp, "\nLabels for character set:\n") == -1) { ------------------ | Branch (879:9): [True: 0, False: 0] ------------------ 880| 0| recogDestroy(&recog); 881| 0| return (L_RECOG *)ERROR_PTR("label intro not read", __func__, NULL); ------------------ | | 593| 0| IF_SEV(L_SEVERITY_ERROR, returnErrorPtr((a), (b), (c)), (void *)(c)) | | ------------------ | | | | 586| 0| ((l) >= MINIMUM_SEVERITY && (l) >= LeptMsgSeverity ? (t) : (f)) | | | | ------------------ | | | | | | 485| 0| #define MINIMUM_SEVERITY L_SEVERITY_INFO /*!< Compile-time default */ | | | | ------------------ | | | | | Branch (586:8): [Folded - Ignored] | | | | | Branch (586:35): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 882| 0| } 883| 0| l_dnaDestroy(&recog->dna_tochar); 884| 0| if ((dna_tochar = l_dnaReadStream(fp)) == NULL) { ------------------ | Branch (884:9): [True: 0, False: 0] ------------------ 885| 0| recogDestroy(&recog); 886| 0| return (L_RECOG *)ERROR_PTR("dna_tochar not read", __func__, NULL); ------------------ | | 593| 0| IF_SEV(L_SEVERITY_ERROR, returnErrorPtr((a), (b), (c)), (void *)(c)) | | ------------------ | | | | 586| 0| ((l) >= MINIMUM_SEVERITY && (l) >= LeptMsgSeverity ? (t) : (f)) | | | | ------------------ | | | | | | 485| 0| #define MINIMUM_SEVERITY L_SEVERITY_INFO /*!< Compile-time default */ | | | | ------------------ | | | | | Branch (586:8): [Folded - Ignored] | | | | | Branch (586:35): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 887| 0| } 888| 0| recog->dna_tochar = dna_tochar; 889| 0| sarrayDestroy(&recog->sa_text); 890| 0| if ((sa_text = sarrayReadStream(fp)) == NULL) { ------------------ | Branch (890:9): [True: 0, False: 0] ------------------ 891| 0| recogDestroy(&recog); 892| 0| return (L_RECOG *)ERROR_PTR("sa_text not read", __func__, NULL); ------------------ | | 593| 0| IF_SEV(L_SEVERITY_ERROR, returnErrorPtr((a), (b), (c)), (void *)(c)) | | ------------------ | | | | 586| 0| ((l) >= MINIMUM_SEVERITY && (l) >= LeptMsgSeverity ? (t) : (f)) | | | | ------------------ | | | | | | 485| 0| #define MINIMUM_SEVERITY L_SEVERITY_INFO /*!< Compile-time default */ | | | | ------------------ | | | | | Branch (586:8): [Folded - Ignored] | | | | | Branch (586:35): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 893| 0| } 894| 0| recog->sa_text = sa_text; 895| | 896| 0| if (fscanf(fp, "\nPixaa of all samples in the training set:\n") == -1) { ------------------ | Branch (896:9): [True: 0, False: 0] ------------------ 897| 0| recogDestroy(&recog); 898| 0| return (L_RECOG *)ERROR_PTR("pixaa intro not read", __func__, NULL); ------------------ | | 593| 0| IF_SEV(L_SEVERITY_ERROR, returnErrorPtr((a), (b), (c)), (void *)(c)) | | ------------------ | | | | 586| 0| ((l) >= MINIMUM_SEVERITY && (l) >= LeptMsgSeverity ? (t) : (f)) | | | | ------------------ | | | | | | 485| 0| #define MINIMUM_SEVERITY L_SEVERITY_INFO /*!< Compile-time default */ | | | | ------------------ | | | | | Branch (586:8): [Folded - Ignored] | | | | | Branch (586:35): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 899| 0| } 900| 0| if ((paa = pixaaReadStream(fp)) == NULL) { ------------------ | Branch (900:9): [True: 0, False: 0] ------------------ 901| 0| recogDestroy(&recog); 902| 0| return (L_RECOG *)ERROR_PTR("pixaa not read", __func__, NULL); ------------------ | | 593| 0| IF_SEV(L_SEVERITY_ERROR, returnErrorPtr((a), (b), (c)), (void *)(c)) | | ------------------ | | | | 586| 0| ((l) >= MINIMUM_SEVERITY && (l) >= LeptMsgSeverity ? (t) : (f)) | | | | ------------------ | | | | | | 485| 0| #define MINIMUM_SEVERITY L_SEVERITY_INFO /*!< Compile-time default */ | | | | ------------------ | | | | | Branch (586:8): [Folded - Ignored] | | | | | Branch (586:35): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 903| 0| } 904| 0| recog->setsize = setsize; 905| 0| nc = pixaaGetCount(paa, NULL); 906| 0| if (nc != setsize) { ------------------ | Branch (906:9): [True: 0, False: 0] ------------------ 907| 0| recogDestroy(&recog); 908| 0| pixaaDestroy(&paa); 909| 0| L_ERROR("(setsize = %d) != (paa count = %d)\n", __func__, ------------------ | | 606| 0| IF_SEV(L_SEVERITY_ERROR, \ | | ------------------ | | | | 586| 0| ((l) >= MINIMUM_SEVERITY && (l) >= LeptMsgSeverity ? (t) : (f)) | | | | ------------------ | | | | | | 485| 0| #define MINIMUM_SEVERITY L_SEVERITY_INFO /*!< Compile-time default */ | | | | ------------------ | | | | | Branch (586:8): [Folded - Ignored] | | | | | Branch (586:35): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 607| 0| (void)lept_stderr("Error in %s: " a, __VA_ARGS__), \ | | 608| 0| (void)0) ------------------ 910| 0| setsize, nc); 911| 0| return NULL; 912| 0| } 913| | 914| 0| recogAddAllSamples(&recog, paa, 0); /* this finishes */ 915| 0| pixaaDestroy(&paa); 916| 0| if (!recog) ------------------ | Branch (916:9): [True: 0, False: 0] ------------------ 917| 0| return (L_RECOG *)ERROR_PTR("bad templates", __func__, NULL); ------------------ | | 593| 0| IF_SEV(L_SEVERITY_ERROR, returnErrorPtr((a), (b), (c)), (void *)(c)) | | ------------------ | | | | 586| 0| ((l) >= MINIMUM_SEVERITY && (l) >= LeptMsgSeverity ? (t) : (f)) | | | | ------------------ | | | | | | 485| 0| #define MINIMUM_SEVERITY L_SEVERITY_INFO /*!< Compile-time default */ | | | | ------------------ | | | | | Branch (586:8): [Folded - Ignored] | | | | | Branch (586:35): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 918| 0| return recog; 919| 0|} returnErrorPtr: 240| 2|{ 241| 2| lept_stderr("Error in %s: %s\n", procname, msg); 242| 2| return pval; 243| 2|} returnErrorPtr1: 303| 2|{ 304| 2| lept_stderr("Leptonica Error in %s: %s: %s\n", procname, msg, arg); 305| 2| return pval; 306| 2|} leptSetStderrHandler: 352| 2|{ 353| 2| if (handler) ------------------ | Branch (353:9): [True: 2, False: 0] ------------------ 354| 2| stderr_handler = handler; 355| 0| else 356| 0| stderr_handler = lept_default_stderr_handler; 357| 2|} lept_stderr: 378| 4|{ 379| 4|va_list args; 380| 4|char msg[MAX_DEBUG_MESSAGE]; 381| 4|l_int32 n; 382| | 383| 4| va_start(args, fmt); 384| 4| n = vsnprintf(msg, sizeof(msg), fmt, args); 385| 4| va_end(args); 386| 4| if (n < 0) ------------------ | Branch (386:9): [True: 0, False: 4] ------------------ 387| 0| return; 388| 4| (*stderr_handler)(msg); 389| 4|} stringNew: 228| 2|{ 229| 2|l_int32 len; 230| 2|char *dest; 231| | 232| 2| if (!src) { ------------------ | Branch (232:9): [True: 0, False: 2] ------------------ 233| 0| L_WARNING("src not defined\n", __func__); ------------------ | | 610| 0| IF_SEV(L_SEVERITY_WARNING, \ | | ------------------ | | | | 586| 0| ((l) >= MINIMUM_SEVERITY && (l) >= LeptMsgSeverity ? (t) : (f)) | | | | ------------------ | | | | | | 485| 0| #define MINIMUM_SEVERITY L_SEVERITY_INFO /*!< Compile-time default */ | | | | ------------------ | | | | | Branch (586:8): [Folded - Ignored] | | | | | Branch (586:35): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 611| 0| (void)lept_stderr("Warning in %s: " a, __VA_ARGS__), \ | | 612| 0| (void)0) ------------------ 234| 0| return NULL; 235| 0| } 236| | 237| 2| len = strlen(src); 238| 2| if ((dest = (char *)LEPT_CALLOC(len + 1, sizeof(char))) == NULL) ------------------ | | 383| 2| #define LEPT_CALLOC(numelem, elemsize) calloc(numelem, elemsize) ------------------ | Branch (238:9): [True: 0, False: 2] ------------------ 239| 0| return (char *)ERROR_PTR("dest not made", __func__, NULL); ------------------ | | 593| 0| IF_SEV(L_SEVERITY_ERROR, returnErrorPtr((a), (b), (c)), (void *)(c)) | | ------------------ | | | | 586| 0| ((l) >= MINIMUM_SEVERITY && (l) >= LeptMsgSeverity ? (t) : (f)) | | | | ------------------ | | | | | | 485| 0| #define MINIMUM_SEVERITY L_SEVERITY_INFO /*!< Compile-time default */ | | | | ------------------ | | | | | Branch (586:8): [Folded - Ignored] | | | | | Branch (586:35): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 240| | 241| 2| stringCopy(dest, src, len); 242| 2| return dest; 243| 2|} stringCopy: 268| 4|{ 269| 4|l_int32 i; 270| | 271| 4| if (!dest) ------------------ | Branch (271:9): [True: 0, False: 4] ------------------ 272| 0| return ERROR_INT("dest not defined", __func__, 1); ------------------ | | 589| 0| IF_SEV(L_SEVERITY_ERROR, returnErrorInt((a), (b), (c)), (l_int32)(c)) | | ------------------ | | | | 586| 0| ((l) >= MINIMUM_SEVERITY && (l) >= LeptMsgSeverity ? (t) : (f)) | | | | ------------------ | | | | | | 485| 0| #define MINIMUM_SEVERITY L_SEVERITY_INFO /*!< Compile-time default */ | | | | ------------------ | | | | | Branch (586:8): [Folded - Ignored] | | | | | Branch (586:35): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 273| 4| if (!src || n < 1) ------------------ | Branch (273:9): [True: 0, False: 4] | Branch (273:17): [True: 0, False: 4] ------------------ 274| 0| return 0; 275| | 276| | /* Implementation of strncpy that valgrind doesn't complain about */ 277| 80| for (i = 0; i < n && src[i] != '\0'; i++) ------------------ | Branch (277:17): [True: 76, False: 4] | Branch (277:26): [True: 76, False: 0] ------------------ 278| 76| dest[i] = src[i]; 279| 4| for (; i < n; i++) ------------------ | Branch (279:12): [True: 0, False: 4] ------------------ 280| 0| dest[i] = '\0'; 281| 4| return 0; 282| 4|} fopenReadStream: 1877| 2|{ 1878| 2|char *fname, *tail; 1879| 2|FILE *fp; 1880| | 1881| 2| if (!filename) ------------------ | Branch (1881:9): [True: 0, False: 2] ------------------ 1882| 0| return (FILE *)ERROR_PTR("filename not defined", __func__, NULL); ------------------ | | 593| 0| IF_SEV(L_SEVERITY_ERROR, returnErrorPtr((a), (b), (c)), (void *)(c)) | | ------------------ | | | | 586| 0| ((l) >= MINIMUM_SEVERITY && (l) >= LeptMsgSeverity ? (t) : (f)) | | | | ------------------ | | | | | | 485| 0| #define MINIMUM_SEVERITY L_SEVERITY_INFO /*!< Compile-time default */ | | | | ------------------ | | | | | Branch (586:8): [Folded - Ignored] | | | | | Branch (586:35): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1883| | 1884| | /* Try input filename */ 1885| 2| fname = genPathname(filename, NULL); 1886| 2| fp = fopen(fname, "rb"); 1887| 2| LEPT_FREE(fname); ------------------ | | 385| 2| #define LEPT_FREE(ptr) free(ptr) ------------------ 1888| 2| if (fp) return fp; ------------------ | Branch (1888:9): [True: 2, False: 0] ------------------ 1889| | 1890| | /* Else, strip directory and try locally */ 1891| 0| splitPathAtDirectory(filename, NULL, &tail); 1892| 0| if (!tail) ------------------ | Branch (1892:9): [True: 0, False: 0] ------------------ 1893| 0| return (FILE*)ERROR_PTR_1("tail not found", filename, __func__, NULL); ------------------ | | 602| 0| IF_SEV(L_SEVERITY_ERROR, returnErrorPtr1((a), (f), (b), (c)), \ | | ------------------ | | | | 586| 0| ((l) >= MINIMUM_SEVERITY && (l) >= LeptMsgSeverity ? (t) : (f)) | | | | ------------------ | | | | | | 485| 0| #define MINIMUM_SEVERITY L_SEVERITY_INFO /*!< Compile-time default */ | | | | ------------------ | | | | | Branch (586:8): [Folded - Ignored] | | | | | Branch (586:35): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 603| 0| (void *)(c)) ------------------ 1894| 0| fp = fopen(tail, "rb"); 1895| 0| if (!fp) ------------------ | Branch (1895:9): [True: 0, False: 0] ------------------ 1896| 0| L_ERROR("failed to open locally with tail %s for filename %s\n", ------------------ | | 606| 0| IF_SEV(L_SEVERITY_ERROR, \ | | ------------------ | | | | 586| 0| ((l) >= MINIMUM_SEVERITY && (l) >= LeptMsgSeverity ? (t) : (f)) | | | | ------------------ | | | | | | 485| 0| #define MINIMUM_SEVERITY L_SEVERITY_INFO /*!< Compile-time default */ | | | | ------------------ | | | | | Branch (586:8): [Folded - Ignored] | | | | | Branch (586:35): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 607| 0| (void)lept_stderr("Error in %s: " a, __VA_ARGS__), \ | | 608| 0| (void)0) ------------------ 1897| 0| __func__, tail, filename); 1898| 0| LEPT_FREE(tail); ------------------ | | 385| 0| #define LEPT_FREE(ptr) free(ptr) ------------------ 1899| 0| return fp; 1900| 0|} convertSepCharsInPath: 3024| 2|{ 3025| 2|l_int32 i; 3026| 2|size_t len; 3027| | 3028| 2| if (!path) ------------------ | Branch (3028:9): [True: 0, False: 2] ------------------ 3029| 0| return ERROR_INT("path not defined", __func__, 1); ------------------ | | 589| 0| IF_SEV(L_SEVERITY_ERROR, returnErrorInt((a), (b), (c)), (l_int32)(c)) | | ------------------ | | | | 586| 0| ((l) >= MINIMUM_SEVERITY && (l) >= LeptMsgSeverity ? (t) : (f)) | | | | ------------------ | | | | | | 485| 0| #define MINIMUM_SEVERITY L_SEVERITY_INFO /*!< Compile-time default */ | | | | ------------------ | | | | | Branch (586:8): [Folded - Ignored] | | | | | Branch (586:35): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 3030| 2| if (type != UNIX_PATH_SEPCHAR && type != WIN_PATH_SEPCHAR) ------------------ | Branch (3030:9): [True: 0, False: 2] | Branch (3030:38): [True: 0, False: 0] ------------------ 3031| 0| return ERROR_INT("invalid type", __func__, 1); ------------------ | | 589| 0| IF_SEV(L_SEVERITY_ERROR, returnErrorInt((a), (b), (c)), (l_int32)(c)) | | ------------------ | | | | 586| 0| ((l) >= MINIMUM_SEVERITY && (l) >= LeptMsgSeverity ? (t) : (f)) | | | | ------------------ | | | | | | 485| 0| #define MINIMUM_SEVERITY L_SEVERITY_INFO /*!< Compile-time default */ | | | | ------------------ | | | | | Branch (586:8): [Folded - Ignored] | | | | | Branch (586:35): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 3032| | 3033| 2| len = strlen(path); 3034| 2| if (type == UNIX_PATH_SEPCHAR) { ------------------ | Branch (3034:9): [True: 2, False: 0] ------------------ 3035| |#ifdef _WIN32 /* only convert on Windows */ 3036| | for (i = 0; i < len; i++) { 3037| | if (path[i] == '\\') 3038| | path[i] = '/'; 3039| | } 3040| |#endif /* _WIN32 */ 3041| 2| } else { /* WIN_PATH_SEPCHAR */ 3042| 0| for (i = 0; i < len; i++) { ------------------ | Branch (3042:21): [True: 0, False: 0] ------------------ 3043| 0| if (path[i] == '/') ------------------ | Branch (3043:17): [True: 0, False: 0] ------------------ 3044| 0| path[i] = '\\'; 3045| 0| } 3046| 0| } 3047| 2| return 0; 3048| 2|} genPathname: 3090| 2|{ 3091| |#if defined(REWRITE_TMP) 3092| |l_int32 rewrite_tmp = TRUE; 3093| |#else 3094| 2|l_int32 rewrite_tmp = FALSE; ------------------ | | 301| 2|#define FALSE 0 ------------------ 3095| 2|#endif /* REWRITE_TMP */ 3096| 2|char *cdir, *pathout; 3097| 2|l_int32 dirlen, namelen; 3098| 2|size_t size; 3099| | 3100| 2| if (!dir && !fname) ------------------ | Branch (3100:9): [True: 0, False: 2] | Branch (3100:17): [True: 0, False: 0] ------------------ 3101| 0| return (char *)ERROR_PTR("no input", __func__, NULL); ------------------ | | 593| 0| IF_SEV(L_SEVERITY_ERROR, returnErrorPtr((a), (b), (c)), (void *)(c)) | | ------------------ | | | | 586| 0| ((l) >= MINIMUM_SEVERITY && (l) >= LeptMsgSeverity ? (t) : (f)) | | | | ------------------ | | | | | | 485| 0| #define MINIMUM_SEVERITY L_SEVERITY_INFO /*!< Compile-time default */ | | | | ------------------ | | | | | Branch (586:8): [Folded - Ignored] | | | | | Branch (586:35): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 3102| | 3103| | /* Handle the case where we start from the current directory */ 3104| 2| if (!dir || dir[0] == '\0') { ------------------ | Branch (3104:9): [True: 0, False: 2] | Branch (3104:17): [True: 0, False: 2] ------------------ 3105| 0| if ((cdir = getcwd(NULL, 0)) == NULL) ------------------ | Branch (3105:13): [True: 0, False: 0] ------------------ 3106| 0| return (char *)ERROR_PTR("no current dir found", __func__, NULL); ------------------ | | 593| 0| IF_SEV(L_SEVERITY_ERROR, returnErrorPtr((a), (b), (c)), (void *)(c)) | | ------------------ | | | | 586| 0| ((l) >= MINIMUM_SEVERITY && (l) >= LeptMsgSeverity ? (t) : (f)) | | | | ------------------ | | | | | | 485| 0| #define MINIMUM_SEVERITY L_SEVERITY_INFO /*!< Compile-time default */ | | | | ------------------ | | | | | Branch (586:8): [Folded - Ignored] | | | | | Branch (586:35): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 3107| 2| } else { 3108| 2| if ((cdir = stringNew(dir)) == NULL) ------------------ | Branch (3108:13): [True: 0, False: 2] ------------------ 3109| 0| return (char *)ERROR_PTR("stringNew failed", __func__, NULL); ------------------ | | 593| 0| IF_SEV(L_SEVERITY_ERROR, returnErrorPtr((a), (b), (c)), (void *)(c)) | | ------------------ | | | | 586| 0| ((l) >= MINIMUM_SEVERITY && (l) >= LeptMsgSeverity ? (t) : (f)) | | | | ------------------ | | | | | | 485| 0| #define MINIMUM_SEVERITY L_SEVERITY_INFO /*!< Compile-time default */ | | | | ------------------ | | | | | Branch (586:8): [Folded - Ignored] | | | | | Branch (586:35): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 3110| 2| } 3111| | 3112| | /* Convert to unix path separators, and remove the trailing 3113| | * slash in the directory, except when dir == "/" */ 3114| 2| convertSepCharsInPath(cdir, UNIX_PATH_SEPCHAR); 3115| 2| dirlen = strlen(cdir); 3116| 2| if (cdir[dirlen - 1] == '/' && dirlen != 1) { ------------------ | Branch (3116:9): [True: 0, False: 2] | Branch (3116:36): [True: 0, False: 0] ------------------ 3117| 0| cdir[dirlen - 1] = '\0'; 3118| 0| dirlen--; 3119| 0| } 3120| | 3121| 2| namelen = (fname) ? strlen(fname) : 0; ------------------ | Branch (3121:15): [True: 0, False: 2] ------------------ 3122| 2| size = dirlen + namelen + 256; 3123| 2| if ((pathout = (char *)LEPT_CALLOC(size, sizeof(char))) == NULL) { ------------------ | | 383| 2| #define LEPT_CALLOC(numelem, elemsize) calloc(numelem, elemsize) ------------------ | Branch (3123:9): [True: 0, False: 2] ------------------ 3124| 0| LEPT_FREE(cdir); ------------------ | | 385| 0| #define LEPT_FREE(ptr) free(ptr) ------------------ 3125| 0| return (char *)ERROR_PTR("pathout not made", __func__, NULL); ------------------ | | 593| 0| IF_SEV(L_SEVERITY_ERROR, returnErrorPtr((a), (b), (c)), (void *)(c)) | | ------------------ | | | | 586| 0| ((l) >= MINIMUM_SEVERITY && (l) >= LeptMsgSeverity ? (t) : (f)) | | | | ------------------ | | | | | | 485| 0| #define MINIMUM_SEVERITY L_SEVERITY_INFO /*!< Compile-time default */ | | | | ------------------ | | | | | Branch (586:8): [Folded - Ignored] | | | | | Branch (586:35): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 3126| 0| } 3127| | 3128| | /* First handle %dir (which may be a full pathname). 3129| | * There is no path rewriting on unix, and on win32, we do not 3130| | * rewrite unless the specified directory is /tmp or 3131| | * a subdirectory of /tmp */ 3132| 2| if (!rewrite_tmp || dirlen < 4 || ------------------ | Branch (3132:9): [True: 2, False: 0] | Branch (3132:25): [True: 0, False: 0] ------------------ 3133| 2| (dirlen == 4 && strncmp(cdir, "/tmp", 4) != 0) || /* not in "/tmp" */ ------------------ | Branch (3133:10): [True: 0, False: 0] | Branch (3133:25): [True: 0, False: 0] ------------------ 3134| 2| (dirlen > 4 && strncmp(cdir, "/tmp/", 5) != 0)) { /* not in "/tmp/" */ ------------------ | Branch (3134:10): [True: 0, False: 0] | Branch (3134:24): [True: 0, False: 0] ------------------ 3135| 2| stringCopy(pathout, cdir, dirlen); 3136| 2| } else { /* Rewrite with "/tmp" specified for the directory. */ 3137| |#if defined(__APPLE__) 3138| | size_t n = confstr(_CS_DARWIN_USER_TEMP_DIR, pathout, size); 3139| | if (n == 0 || n > size) { 3140| | /* Fall back to using /tmp */ 3141| | stringCopy(pathout, cdir, dirlen); 3142| | } else { 3143| | /* Add the rest of cdir */ 3144| | if (dirlen > 4) 3145| | stringCat(pathout, size, cdir + 4); 3146| | } 3147| |#elif defined(_WIN32) 3148| | l_int32 tmpdirlen; 3149| | char tmpdir[MAX_PATH]; 3150| | GetTempPathA(sizeof(tmpdir), tmpdir); /* get the Windows temp dir */ 3151| | tmpdirlen = strlen(tmpdir); 3152| | if (tmpdirlen > 0 && tmpdir[tmpdirlen - 1] == '\\') { 3153| | tmpdir[tmpdirlen - 1] = '\0'; /* trim the trailing '\' */ 3154| | } 3155| | tmpdirlen = strlen(tmpdir); 3156| | stringCopy(pathout, tmpdir, tmpdirlen); 3157| | 3158| | /* Add the rest of cdir */ 3159| | if (dirlen > 4) 3160| | stringCat(pathout, size, cdir + 4); 3161| |#endif /* _WIN32 */ 3162| 0| } 3163| | 3164| | /* Now handle %fname */ 3165| 2| if (fname && strlen(fname) > 0) { ------------------ | Branch (3165:9): [True: 0, False: 2] | Branch (3165:18): [True: 0, False: 0] ------------------ 3166| 0| dirlen = strlen(pathout); 3167| 0| pathout[dirlen] = '/'; 3168| 0| stringCat(pathout, size, fname); 3169| 0| } 3170| | 3171| 2| LEPT_FREE(cdir); ------------------ | | 385| 2| #define LEPT_FREE(ptr) free(ptr) ------------------ 3172| 2| return pathout; 3173| 2|}