tTh/libtthimage
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
e3347cb775
libtthimage/Tools/fonctions.c
tTh 56941f1215 breakin a srand usage
2023-11-14 13:09:27 +01:00

469 lines
9.5 KiB
C
Raw Blame History

/*
T G A _ O U T I L S
-------------------
fonctions communes a tous les outils - new 11 juin 2002
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/* non portable but useful function */
char *strdup(const char *s);
#define IN_FONCTION
#include "tga_outils.h"
/*::------------------------------------------------------------------::*/
int cherche_mot_clef(char *mot, mot_clef *liste, int *pmode, int *pnbarg)
{
int idx = 0;
idx = 0;
while (liste[idx].nom != NULL)
{
#if DEBUG_LEVEL > 1
fprintf(stderr, "check %12s %8s\n", liste[idx].nom,
liste[idx].ptypes);
#endif
if ( ! strcmp(liste[idx].nom, mot) )
{
*pmode = liste[idx].code;
*pnbarg = strlen(liste[idx].ptypes);
#if DEBUG_LEVEL > 1
fprintf(stderr, "found! mode %d nbpar %d\n", *pmode, *pnbarg);
sleep(1);
#endif
return idx;
}
idx++;
}
#if DEBUG_LEVEL > 1
fprintf(stderr, "%s : %s not found\n", __func__, mot);
#endif
return -1;
}
/*::------------------------------------------------------------------::*/
int liste_mots_clefs(mot_clef *liste, int flag)
{
mot_clef *pmc;
#if DEBUG_LEVEL > 1
fprintf(stderr, "%s ( %p %d )\n", __func__, liste, flag);
#endif
if (42 != flag) {
fprintf(stderr, "UH ? flag is not the universal answer ?\n");
}
pmc = liste;
printf(" commande | type arg | explication\n");
printf("------------+----------+------------------------------------\n");
while (pmc->nom != NULL)
{
if (pmc->aide != NULL)
printf(" %-10s | %-8s | %s\n",
pmc->nom, pmc->ptypes, pmc->aide);
pmc++;
}
printf("------------+----------+------------------------------------\n");
return 0;
}
/*::------------------------------------------------------------------::*/
/*
* INPUT str string to scan for an integer
* pval pointer to the return value
* k * not used *
*
* OUTPUT 1 successfuly make a conversion
* 0 strange error occured :(
*/
int parse_int_param(char *str, int *pval, int k)
{
long lfoo;
int val;
if (k) fprintf(stderr, "%s: k %d\n", __func__, k);
val = (int)(lfoo = strtol(str, NULL, 0));
#if DEBUG_LEVEL
fprintf(stderr, "%s: %s: '%s' -> %ld -> %d\n",
__FILE__, __func__, str, lfoo, val);
#endif
*pval = val;
return 1;
}
/*::------------------------------------------------------------------::*/
/* Thu 17 Nov 2022
* input str a string like '640x480'
* pw, ph pointers to result
*
* output 0 on ok, INVALID_PARAM on error
*/
int parse_size_param(char *str, int *pw, int *ph)
{
int tw, th, foo;
#if DEBUG_LEVEL
fprintf(stderr, ">>> %s ( '%s' %p %p )\n", __func__,
str, pw, ph);
#endif
foo = sscanf(str, "%dx%d", &tw, &th);
if (2 != foo) {
fprintf(stderr, "%s: fail %d on '%s'\n", __func__, foo, str);
return INVALID_PARAM;
}
/* fprintf(stderr, " %d %d\n", tw, th); */
*pw = tw; *ph = th;
return 0;
}
/*::------------------------------------------------------------------::*/
/* input: str string to scan for four csv int
prect rectangle struct who need datas
k * not used *
output 1 all correct
2 invalid string
27 janvier 2014
*/
int parse_rect_param(char *str, Image_Rect *prect, int k)
{
char *cptr;
int idx, foo, val;
#if DEBUG_LEVEL
fprintf(stderr, "%s '%s' to %p\n", __func__, str, prect);
#endif
if (k) fprintf(stderr, "%s : k is %d, but must be 0\n", __func__, k);
memset(prect, 0, sizeof(Image_Rect));
cptr = strdup(str);
#if DEBUG_LEVEL
fprintf(stderr, "copie dans cptr %p\n", cptr);
#endif
idx = 0;
cptr = strtok(cptr, ",");
while (NULL != cptr) {
fprintf(stderr, "%3d %p = '%s'\n", idx, cptr, cptr);
foo = sscanf(cptr, "%d", &val);
if (1 != foo) {
fprintf(stderr, "%s: err sscanf on '%s'\n", __func__, cptr);
exit(1);
}
/*
* no error check ?
*/
fprintf(stderr, "val = %d\n", val);
switch (idx) {
case 0: prect->x = val; break;
case 1: prect->y = val; break;
case 2: prect->w = val; break;
case 3: prect->h = val; break;
}
cptr = strtok(NULL, ",");
idx++;
}
free(cptr);
return 0;
}
/*::------------------------------------------------------------------::*/
static Param params[NB_PARAMS];
int parse_parametres(int argc, char *argv[], char *types, int prem)
{
int foo, idxt;
int entier;
double flottant;
char *cptr;
#if DEBUG_LEVEL
fprintf(stderr, "Parse params: types '%s' debut %d\n", types, prem);
#endif
/*
* init de la table des param<61>tres.
*/
for (foo=0; foo<NB_PARAMS; foo++) {
params[foo].type = '?';
}
for (foo=prem, idxt=0; foo<argc; foo++, idxt++)
{
#if DEBUG_LEVEL
fprintf(stderr, "\t%d/%d\t%c\t%s\n", foo, idxt, types[idxt], argv[foo]);
#endif
switch (types[idxt])
{
case 'c':
if (strlen(argv[foo])!=1)
{
fprintf(stderr, "bad length of char param\n");
}
else
{
#if DEBUG_LEVEL
fprintf(stderr, "char param = %d\n", *argv[foo]);
#endif
params[idxt].type = 'c';
params[idxt].p.i = *argv[foo];
}
break;
case 'i':
/*
* En fait, ici, il serait bon de parser aussi les
* parametres donnes en hexadecimal.
*/
if (parse_int_param(argv[foo], &entier, 0)==1)
{
params[idxt].type = 'i';
params[idxt].p.i = entier;
}
else
{
fprintf(stderr, "ERR parse int param %s\n", argv[foo]);
exit(5);
}
break;
case 's':
#if DEBUG_LEVEL
fprintf(stderr, "%s: case 's' : %p\n", __func__, argv[foo]);
#endif
if ((cptr=strdup(argv[foo]))!=NULL)
{
params[idxt].type = 's';
params[idxt].p.s = cptr;
}
else
{
fprintf(stderr, "ERR parse param %s\n", argv[foo]);
exit(5);
}
break;
case 'd':
/* the 'd' is for 'double precision', not for 'decimal' */
if (1 == sscanf(argv[foo], "%lf", &flottant))
{
params[idxt].type = 'd';
params[idxt].p.d = flottant;
#if DEBUG_LEVEL
fprintf(stderr, "at foo=%d, val is %f %g\n",
foo, flottant, flottant);
#endif
}
else
{
fprintf(stderr,"ERR parse float param %s\n",argv[foo]);
exit(5);
}
break;
case 'f':
/* the 'f' is for 'flag', not for 'float' */
switch(argv[foo][0])
{
case '0': case 'f': case 'F': case 'n': case 'N':
params[idxt].type = 'f';
params[idxt].p.i = 0;
break;
case '1': case 't': case 'T': case 'y': case 'Y':
params[idxt].type = 'f';
params[idxt].p.i = 1;
break;
default:
fprintf(stderr, "bad flag %s\n", argv[foo]);
exit(5);
}
break;
case 'R':
fprintf(stderr, "'Rect' parser not implemented\n");
exit(6);
default:
fprintf(stderr, "partype #%d '%c' invalid\n",
idxt, types[idxt]);
exit(5);
}
}
return 0;
}
/*::------------------------------------------------------------------::*/
/* affichage de la liste des parametres trouves */
void print_parametres(void)
{
int foo;
printf(" +------+-----+\n");
printf(" | parameters |\n");
printf(" +------+-----+\n");
for (foo=0; foo<NB_PARAMS; foo++)
{
printf(" | %2d | %c |\n", foo, params[foo].type);
}
printf(" +------+-----+\n");
fflush(stdout);
}
/*::------------------------------------------------------------------::*/
/*
* fonctions de r<>cuperation d'un param<61>tre.
*/
int GIP(int rang)
{
if (rang<0 || params[rang].type!='i') {
fprintf(stderr, "erreur GIP %d\n", rang);
exit(5);
}
return params[rang].p.i;
}
int GCP(int rang)
{
if (rang<0 || params[rang].type!='c') {
fprintf(stderr, "erreur GCP %d\n", rang);
exit(5);
}
return params[rang].p.i;
}
/* get an 'int' parameter with a default value */
int GIPdef(int rang, int def)
{
#if DEBUG_LEVEL
fprintf(stderr, "Warning ! %s is not tested\n", __func__);
#endif
if (rang<0 || params[rang].type!='i') {
return def;
}
return params[rang].p.i;
}
char * GSP(int rang)
{
#if DEBUG_LEVEL > 1
fprintf(stderr, "GetStringParameter(%d)\n", rang);
#endif
if (rang<0 || params[rang].type!='s') {
fprintf(stderr, "erreur GSP %d\n", rang);
exit(5);
}
#if DEBUG_LEVEL > 1
fprintf(stderr, "GetStringParameter -> %s\n", params[rang].p.s);
#endif
return params[rang].p.s;
}
double GDP(int rang)
{
if (rang<0 || params[rang].type!='d') {
fprintf(stderr, "erreur GDP %d\n", rang);
exit(5);
}
return params[rang].p.d;
}
int GFP(int rang)
{
if (rang<0 || params[rang].type!='f') {
fprintf(stderr, "erreur GFP %d\n", rang);
exit(5);
}
return params[rang].p.i;
}
/*::------------------------------------------------------------------::*/
static int verboselevel;
int must_be_verbose(void)
{
char *envvar;
envvar = getenv(NOM_VAR_ENV_VERBOSE);
if ((envvar!=NULL) && !strcmp(envvar, "yes"))
{
#if DEBUG_LEVEL > 1
fprintf(stderr, "HA HA HA ! pid:%d MUST BE VERBOSE !\n", getpid());
#endif
return 1;
}
return 0;
}
/* new Fri 18 Nov 2022 11:48:06 PM CET */
int set_verbosity(int level)
{
int tmplevel;
tmplevel = verboselevel;
verboselevel = level;
return tmplevel;
}
int get_verbosity(void)
{
return verboselevel;
}
/*::------------------------------------------------------------------::*/
int dump_command_line(int argc, char *argv[], int force)
{
char *envvar;
int flag=0, foo;
#if DEBUG_LEVEL
fprintf(stderr, "%s : %s, argc=%d\n", __func__, argv[0], argc);
#endif
envvar = getenv(NOM_VAR_ENV_VERBOSE);
if ( (envvar!=NULL) && !strcmp(envvar, "yes") ) flag = 1;
if (flag || force) {
fprintf(stderr, "TGA(%d) %d arg:", getpid(), argc);
for (foo=0; foo<argc; foo++)
fprintf(stderr, " %s", argv[foo]);
fprintf(stderr, "\n");
}
return flag;
}
/*::------------------------------------------------------------------::*/
int set_new_seed(int k)
{
char *ptr;
long seed;
if (NULL==(ptr=getenv("FIXED_SEED"))) {
/* no fixed seed in context, doing semi-random */
srand(getpid() + k);
#if DEBUG_LEVEL
fprintf(stderr, "no FIXED_SEED, first rand is number : %d\n", rand());
#endif
}
else {
/* try to parse the env var */
seed = strtol(ptr, NULL, 0);
srand(seed);
}
return rand();
}
/*::------------------------------------------------------------------::*/
Reference in New Issue View Git Blame Copy Permalink