dmlib: tools/fanalyze.c comparison

comparison tools/fanalyze.c @ 2586:9807ae37ad69

Require stdbool.h, we require C11 now.

author	Matti Hamalainen <ccr@tnsp.org>
date	Thu, 08 Dec 2022 15:59:22 +0200
parents	9f26a93d7e70
children	81f45b2fa118

comparison

equal deleted inserted replaced

-:ef6c826c5b7a
+:9807ae37ad69
 {
 char *filename;
 Uint8 *data;
 size_t size;
 DMStats stats;
-BOOL analyzed;
+bool analyzed;
 size_t index;
 } DMSourceFile;
 typedef struct
 {
 int type;
 int disp;
 int nvalues;
 Uint32 values[SET_MAX_GREP_LIST];
-BOOL vwildcards[SET_MAX_GREP_LIST];
+bool vwildcards[SET_MAX_GREP_LIST];
 } DMGrepValue;
 typedef struct
 {
 DMSourceFile   srcFiles[SET_MAX_FILES];    // Source file names
 DMStats        totalStats;
 int            nsetGrepValues = 0;
 DMGrepValue    setGrepValues[SET_MAX_GREP_VALUES];
 size_t         optMinMatchLen = 8;
-BOOL           optOffsetMode = FALSE;
+bool           optOffsetMode = false;
 DMMatchSeq dmSequences[SET_MAX_SEQUENCES];
 int ndmSequences = 0;
 "under development.\n"
 );
 }
-BOOL dmGetData(const int type, const DMSourceFile *file, const size_t offs, Uint32 *mval)
+bool dmGetData(const int type, const DMSourceFile *file, const size_t offs, Uint32 *mval)
 {
 Uint8 *data = file->data + offs;
 if (offs + dmGrepTypes[type].bsize >= file->size)
 {
 *mval = 0;
-return FALSE;
+return false;
 }
 switch (type)
 {
 case DMGV_UINT8:
 *mval = DM_BE32_TO_NATIVE(*((Uint32 *) data));
 break;
 default:
 *mval = 0;
-return FALSE;
+return false;
 }
-return TRUE;
+return true;
 }
-void dmPrintGrepValueList(FILE *fh, const DMGrepValue *node, const BOOL match, DMSourceFile *file, const size_t offs)
+void dmPrintGrepValueList(FILE *fh, const DMGrepValue *node, const bool match, DMSourceFile *file, const size_t offs)
 {
 char mfmt[16];
 unsigned int bsize = dmGrepTypes[node->type].bsize;
 snprintf(mfmt, sizeof(mfmt), "%%%s%d%s%%s",
 {
 const char *specsep = strchr(arg, ':');
 char *vspec, *vstr, *vsep;
 DMGrepValue val;
 int ret = DMERR_OK;
-BOOL more;
+bool more;
 memset(&val, 0, sizeof(val));
 if (setMode != FA_ANALYZE && setMode != mode)
 {
 }
 // Parse spec if any
 if (vspec != NULL)
 {
-BOOL vendianess = TRUE;
+bool vendianess = true;
 char *vtmp = vspec;
 // Get endianess specifier, if any
 if (strncasecmp(vtmp, "le", 2) == 0)
 {
-vendianess = TRUE;
+vendianess = true;
 vtmp += 2;
 }
 else
 if (strncasecmp(vtmp, "be", 2) == 0)
 {
-vendianess = FALSE;
+vendianess = false;
 vtmp += 2;
 }
 // Get value bit size
 if (strncmp(vtmp, "8", 1) == 0)
 }
 if ((vsep = strchr(vtmp, ',')) != NULL)
 {
 *vsep = 0;
-more = TRUE;
+more = true;
 }
 else
-more = FALSE;
+more = false;
 if (vtmp[0] == '#' || vtmp[0] == '?')
 {
-val.vwildcards[val.nvalues] = TRUE;
+val.vwildcards[val.nvalues] = true;
 if (mode == FA_OFFSET)
 {
 ret = dmError(DMERR_INVALID_ARGS,
 "Offset mode does not allow wildcard values.\n");
 goto out;
 if (mode == FA_GREP)
 {
 printf("Grep %s: ",
 dmGrepTypes[val.type].desc);
-dmPrintGrepValueList(stdout, node, FALSE, NULL, 0);
+dmPrintGrepValueList(stdout, node, false, NULL, 0);
 printf("\n");
 }
 }
 else
 {
 dmFree(vstr);
 return ret;
 }
-BOOL argHandleOpt(const int optN, char *optArg, char *currArg)
+bool argHandleOpt(const int optN, char *optArg, char *currArg)
 {
 switch (optN)
 {
 case 0:
 argShowHelp();
 optMinMatchLen = atoi(optArg);
 if (optMinMatchLen < 2 || optMinMatchLen > 16*1024)
 {
 dmErrorMsg("Invalid minimum match length '%s'.\n",
 optArg);
-return FALSE;
+return false;
 }
-return TRUE;
+return true;
 case 18:
-optOffsetMode = TRUE;
+optOffsetMode = true;
 break;
 default:
 dmErrorMsg("Unknown argument '%s'.\n", currArg);
-return FALSE;
+return false;
 }
-return TRUE;
+return true;
 }
-BOOL argHandleNonOpt(char *currArg)
+bool argHandleNonOpt(char *currArg)
 {
 if (nsrcFiles < SET_MAX_FILES)
 {
 DMSourceFile *file = &srcFiles[nsrcFiles];
 file->filename = currArg;
 file->index = nsrcFiles;
 nsrcFiles++;
-return TRUE;
+return true;
 }
 else
 {
 dmErrorMsg("Maximum number of input files exceeded (%d).\n",
 SET_MAX_FILES);
-return TRUE;
+return true;
 }
 }
 void dmInitStats(DMStats *stats)
 }
 printf("\n\n");
 }
-BOOL dmAddMatchSequence(Uint8 *data, const size_t len, DMSourceFile *file, size_t offs)
+bool dmAddMatchSequence(Uint8 *data, const size_t len, DMSourceFile *file, size_t offs)
 {
 DMMatchSeq *seq = NULL;
 // Check for existing match sequence
 for (int n = 0; n < ndmSequences; n++)
 {
 // No sequence found, add a new one
 if (ndmSequences + 1 >= SET_MAX_SEQUENCES)
 {
 dmErrorMsg("Too many matching sequences found.\n");
-return FALSE;
+return false;
 }
 seq = &dmSequences[ndmSequences++];
 }
 else
 for (int n = 0; n < seq->nplaces; n++)
 {
 DMMatchPlace *place = &seq->places[n];
 if (place->file == file &&
 place->offs + seq->len == offs + len)
-return TRUE;
+return true;
 }
 }
 seq->data = data;
 seq->len = len;
 {
 DMMatchPlace *place = &seq->places[seq->nplaces++];
 place->file = file;
 place->offs = offs;
-return TRUE;
+return true;
 }
 else
-return FALSE;
+return false;
 }
 int dmCompareMatchPlaces(const void *pa, const void *pb)
 {
 int main(int argc, char *argv[])
 {
 DMCompElem *compBuf = NULL;
 size_t compBufSize = 0, totalSize = 0, fileFlagsSize;
-BOOL *fileFlags = NULL;
+bool *fileFlags = NULL;
 int res;
 memset(&dmSequences, 0, sizeof(dmSequences));
 dmInitProg("fanalyze",
 "No input file(s) specified.\n");
 goto out;
 }
 // Allocate file flags
-fileFlagsSize = sizeof(BOOL) * nsrcFiles;
+fileFlagsSize = sizeof(bool) * nsrcFiles;
 if ((fileFlags = dmMalloc(fileFlagsSize)) == NULL)
 {
 dmErrorMsg("Could not allocate %" DM_PRIu_SIZE_T " bytes of memory for file flag array.\n",
 fileFlagsSize);
 goto out;
 for (int n = 0; n < nsetGrepValues; n++)
 {
 DMGrepValue *node = &setGrepValues[n];
 const DMGrepType *def = &dmGrepTypes[node->type];
-BOOL sep = FALSE;
+bool sep = false;
 if (optOffsetMode)
 {
 printf("%s %s -o ",
 argv[0], file->filename);
 }
 for (size_t offs = 0; offs + (def->bsize * node->nvalues) < file->size; offs++)
 {
-BOOL match = TRUE;
+bool match = true;
 for (int n = 0; n < node->nvalues; n++)
 if (!node->vwildcards[n])
 {
 Uint32 mval;
 dmGetData(node->type, file, offs + n * def->bsize, &mval);
 if (mval != node->values[n])
 {
-match = FALSE;
+match = false;
 break;
 }
 }
 if (match)
 {
 if (optOffsetMode)
 {
 printf("%s0x%" DM_PRIx_SIZE_T, sep ? "," : "", offs);
-sep = TRUE;
+sep = true;
 }
 else
 printf("%08" DM_PRIx_SIZE_T, offs);
 if (!optOffsetMode)
 {
 if (dmVerbosity >= 1)
 {
 printf(" : ");
-dmPrintGrepValueList(stdout, node, TRUE, file, offs);
+dmPrintGrepValueList(stdout, node, true, file, offs);
 }
 printf("\n");
 }
 }
 }
 // Display results
 //
 for (size_t offs = 0, n = 0; offs < compBufSize; offs++)
 {
 DMCompElem *el = &compBuf[offs];
-BOOL var = el->variants > 1;
+bool var = el->variants > 1;
 if (n == 0)
 printf("%08" DM_PRIx_SIZE_T " | ", offs);
 if (var)
 if (setMode == FA_DIFF)
 {
 //
 // Attempt to find matching sequences of N+
 //
-BOOL slow = FALSE;
+bool slow = false;
 int ss = 0;
 printf("Attempting to find matching sequences of %" DM_PRIu_SIZE_T " bytes or more.\n",
 optMinMatchLen);
 if (totalSize > 32*1024)
 {
 dmPrint(0,
 "WARNING! Total data size is large, and the matching \"algorithm\"\n"
 "used is horribly inefficient. This will be quite slow ...\n");
-slow = TRUE;
+slow = true;
 }
 for (int nfile1 = 0; nfile1 < nsrcFiles; nfile1++)
 {
 DMSourceFile *file1 = &srcFiles[nfile1];
 if (cnt < optMinMatchLen)
 moffs1++;
 }
 }
-file1->analyzed = TRUE;
+file1->analyzed = true;
 }
 done:
 if (slow)
 for (int nplace = 0; nplace < seq->nplaces; nplace++)
 {
 DMMatchPlace *place = &seq->places[nplace];
 if (!fileFlags[place->file->index])
 {
-fileFlags[place->file->index] = TRUE;
+fileFlags[place->file->index] = true;
 seq->nfiles++;
 }
 }
 }

Mercurial > hg > dmlib

comparison tools/fanalyze.c @ 2586:9807ae37ad69