Custom "sprintf" type function
I'm taking a break from programming this function, figured I would post it here in the mean time for anyone curious enough to look for problems in it:
Code:
dint specidy_modifier( dint c )
{
switch ( c )
{
case 't': /* ptrdiff_t */
case 'z': /* size_t */
case 'j': /* intmax_t/uintmax_t/dmax/umax */
case 'p': /* intptr_t/uintptr_t/dptr/uptr */
case 'I': /* int8_t etc */
case 'L': /* ldnum */
case 'l': /* long/ulong/wchs/wch */
case 'h': /* char/short */
return c;
}
return 0;
}
dint specify_integer( dint c )
{
switch ( c )
{
case 'd': case 'i': /* signed decimal */
return 'd';
case 'n': /* pointer to integer */
case 'b': /* unsigned binary */
case 'o': /* unsigned octal */
case 'u': /* unsigned decimal */
case 'x': /* unsigned lower case hexedecimal */
case 'X': /* unsigned upper case hexadecimal */
return c;
}
return 0;
}
dint specify_double( dint c )
{
switch ( c )
{
case 'f': case 'F':
case 'g': case 'G':
case 'e': case 'E':
case 'a': case 'A':
return c;
}
return 0;
}
dint specify_text( dint c )
{
switch ( c )
{
case 'c': /* single character */
case 's': /* string */
}
return 0;
}
typedef struct _ARG
{
uint i;
bool addr;
uint opts;
/* Prefix length */
uint pfxl;
/* Precision */
uint prec;
/* Min Count */
uint minc;
/* Specified type: signed, unsigned, floating point, string, etc */
dint spec;
/* Variant of type: char, short, long, long long, etc*/
dint type;
dint const *text;
} ARG;
typedef enum _FORMAT_FLAG
{
FORMAT_FLAG_ALIGN_LEFT = 0,
FORMAT_FLAG_BOTH_SIGNS,
FORMAT_FLAG_PLUS2SPACE,
FORMAT_FLAG_PREFIX_LIT,
FORMAT_FLAG_SUFFIX_LIT,
FORMAT_FLAG_PAD_WITH_0,
FORMAT_FLAG_COUNT,
FORMAT_FLAG_DECIMALDIG = FORMAT_FLAG_COUNT
} FORMAT_FLAG;
BASIC_EXP void optsofArg( ARG *arg )
{
static dint const opts[FORMAT_FLAG_COUNT] = { '-', '+', ' ', '#', '~', '0' };
uint i;
bool opt;
arg->opts = 0;
for ( i = 0; FORMAT_FLAG_COUNT; ++i )
{
opt = (arg->text[0] == opts[i]);
arg->opts |= opt << i;
arg->text += opt;
arg->i += opt;
}
}
BASIC_EXP bool mincofArg( ARG *arg )
{
arg->minc = 0;
if ( arg->text[0] == '*' )
{
arg->text++;
arg->i++;
return true;
}
if ( isdigit( arg->text[0] ) )
{
uint i;
for ( i = 0; i < bitsof(uint); ++i )
{
if ( !isdigit( arg->text[0] ) )
break;
arg->minc *= 10;
arg->minc += (arg->text[0] - '0');
arg->text++;
arg->i++;
}
}
return false;
}
BASIC_EXP bool precofArg( ARG *arg )
{
arg->prec = 0;
if ( arg->text[0] == '.' )
{
uint i;
arg->i++;
arg->text++;
if ( arg->text[0] == '*' )
{
arg->i++;
arg->text++;
arg->opts |= (1u << FORMAT_FLAG_DECIMALDIG);
return true;
}
for ( i = 0; i < bitsof(uint); ++i )
{
if ( !isdigit( arg->text[0] ) )
break;
arg->prec *= 10;
arg->prec += (arg->text[0] - '0');
arg->text++;
arg->i++;
}
arg->opts |= (!!i << FORMAT_FLAG_DECIMALDIG);
}
return false;
}
BASIC_EXP void typeofArg( ARG *arg )
{
dint type;
arg->type = specidy_modifier( arg->text[0] );
switch ( arg->type )
{
case 'p':
arg->spec = specify_integer( arg->text[1] );
if ( !(arg->spec) )
{
arg->opts |= (1u << FORMAT_FLAG_PREFIX_LIT);
arg->spec = 'X';
arg->type = 0;
return;
}
break;
case 'L':
arg->spec = specify_double( arg->text[1] );
if ( !(arg->spec) )
arg->spec = 'g';
else
{
arg->text++;
arg->i++;
}
return;
default: if ( !(arg->type) ) return;
}
type = specidy_modifier( arg->text[1] );
if ( type )
{
if ( type != arg->type )
{
arg->spec = 'd';
return;
}
switch ( type )
{
case 'l':
arg->spec = 'L';
arg->text++;
arg->i++;
break;
case 'h':
arg->spec = 'H';
arg->text++;
arg->i++;
break;
default:
arg->spec = 'd';
return;
}
}
arg->spec = specify_integer( arg->text[1] );
if ( arg->spec )
{
arg->i++;
arg->text++;
return;
}
arg->spec = specify_text( arg->text[1] );
if ( arg->spec )
{
arg->i++;
arg->text++;
return;
}
arg->spec = 'd';
}
/* Extend length */
BASIC_EXP void extlenArg( ARG *arg )
{
arg->pfxl = 0;
arg->sfxl = 0;
if ( specify_text( arg->spec ) )
{
arg->pfxl = 1 + (arg->type == 'l');
arg->sfxl = 1;
return;
}
switch ( arg->spec )
{
case 'b': case 'x': case 'X': case 'a' case 'A':
arg->pfxl = 2;
break;
case 'o':
arg->pfxl = 1;
break;
case 'u':
arg->sfxl = 1;
break;
}
switch ( arg->type )
{
case 'h': case 'l': arg->sfxl += 1; break;
case 'H': case 'L': arg->sfxl += 2; break;
}
}
BASIC_EXP uint addpfx( DINTS *Text, ARG *arg, uint j )
{
dint *text = Text->array;
if ( arg->pfxl )
{
switch ( arg->spec )
{
case 'o': text[j++] = '0'; break;
case 'b': text[j++] = '0'; text[j++] = 'b'; break;
case 'x': case 'a': text[j++] = '0'; text[j++] = 'x'; break;
case 'X': case 'A': text[j++] = '0'; text[j++] = 'X'; break;
case 'c':
text[j] = 'L';
j += (arg->type == 'l');
text[j++] = '\'';
break;
case 's':
text[j] = 'L';
j += (arg->type == 'l');
text[j++] = '"';
}
}
return j;
}
BASIC_EXP uint addsfx( DINTS *Text, ARG *arg, uint j )
{
dint *text = Text->array;
if ( arg->sfxl )
{
switch ( arg->spec )
{
case 'u': text[j++] = 'U'; break;
case 'c': text[j++] = '\''; return j;
case 's': text[j++] = '"'; return j;
}
if ( specify_double( arg->spec ) )
return j;
switch ( arg->type )
{
case 'L': text[j++] = 'L';
case 'l': text[j++] = 'L'; break;
case 'H': text[j++] = 'H';
case 'h': text[j++] = 'H'; break;
case 'j': text[j++] = 'J'; break;
case 'p': text[j++] = 'P'; break;
case 'z': text[j++] = 'Z'; break;
case 't': text[j++] = 'T';
}
}
return j;
}
Code:
BASIC_EXP dint markTextv( void *ud, DINTS *Text, dint const *args, va_list va )
{
dint err = 0;
dint *text = NULL;
uint i, j, k, init = 0, term = 0, prec, not0;
ACHN num = {0};
ACHF fpn = {0};
dmax d; umax u;
achs str;
wchs wcs;
ARG arg = {0};
/* Get a rough total number of potential characters */
for ( i = 0, j = 0; args[i]; ++i, ++j )
j += bitsof(umax) * (args[i] == '%');
/* Reduce the number of allocations needed to print text */
err = markTextt( ud, Text, j );
if ( err )
{
ECHO_ERRNO( stdout, err );
return err;
}
/* Actually process the arguments this time */
for ( arg.text = args; args[arg.i]; arg.i++, ++term )
{
if ( arg.text[arg.i] != '%' )
continue;
if ( term )
{
err = growTextn( ud, Text, args + init, term - init );
if ( err )
{
ECHO_ERRNO( stdout, err );
return err;
}
init = i;
term = i;
}
arg.i++;
arg.text++;
optsofArg( &arg );
if ( mincofArg( &arg ) )
arg.minc = va_arg( va, uint );
if ( precofArg(&arg) )
arg.prec = va_arg( va, uint );
typeofArg(&arg);
extlenArg(&arg);
if ( !(arg->opts & (1u << FORMAT_FLAG_PREFIX_LIT)) )
{
arg->pfxl = 0;
if ( specify_text( arg->spec ) )
arg->sfxl = 0;
}
d = 0;
u = 0;
str = NULL;
wcs = NULL;
memset( &num, 0, sizeof(ACHN) );
memset( &fpn, 0, sizeof(ACHN) );
switch ( arg.spec )
{
case 'X': case 'A': case 'p': str = ACHS_0TO9 "ABCDEF"; break;
case 'x': case 'a': str = ACHS_0TO9 "abcdef"; break;
case 'o': str = "01234567"; break;
case 'b': str = "01"; break;
default: str = ACHS_0TO9; break;
}
if ( specify_double( arg.spec ) )
{
j = Text->count;
ldnum2achs
(
&fpn, (arg.type == 'L')
? va_arg( va, ldnum ) : va_arg( va, dnum ),
str
);
prec = (arg->opts & (1u << FORMAT_FLAG_DECIMALDIG))
? arg->prec : fpn.dec.not0;
k = fpn.exp.not0;
not0 = fpn.num.not0 + prec + k + !!prec + !!k;
not0 += arg->pfxl;
not0 = (not0 < arg->minc) ? arg->minc : not0;
err = growTextc( ud, Text, not0 );
if ( err )
{
ECHO_ERRNO( stdout, err );
return err;
}
text = Text->array;
j = addpfx( Text, &arg, j );
for ( k = 0; k < fpn.num.not0; ++k )
text[j] = fpn.num.text[k];
if ( prec < fpn.dec.not0 )
{
for ( k = 0; k < prec; ++k )
text[j] = fpn.dec.text[k];
}
else if ( prec )
{
/* TODO take note of 0s prior to readable
* number */
for ( k = 0; k < fpn.dec.not0; ++k, --prec )
text[j] = fpn.dec.text[k];
for ( ; prec; text[j] = '0', --prec );
}
for ( k = 0; k < fpn.num.not0; ++k )
text[j] = fpn.num.text[k];
continue;
}
switch ( arg.spec )
{
case 'c':
d = va_arg( va, dint );
j = Text->count;
err = growTextc( ud, Text, 1 );
if ( err )
{
ECHO_ERRNO( stdout, err );
return err;
}
text = Text->array;
text[j] = d;
continue;
case 's':
not0 = arg->prec;
if ( arg.type == 'l' )
{
wcs = va_arg( va, wchs );
if ( wcs )
not0 = not0 ? wchsnot0(wcs) : 0;
else
{
wcs = L"(null)";
not0 = wchsnot0(wcs);
}
j = Text->count;
err = growTextc( ud, Text, not0 + (6 * !not0) );
if ( err )
{
ECHO_ERRNO( stdout, err );
return err;
}
text = Text->array;
for ( k = 0; k < not0; ++k, ++j )
text[j] = wcs[k];
}
else
{
str = va_arg( va, achs );
if ( str )
not0 = not0 ? achsnot0(str) : 0;
else
{
str = "(null)";
not0 = achsnot0(str);
}
j = Text->count;
err = growTextc( ud, Text, not0 );
if ( err )
{
ECHO_ERRNO( stdout, err );
return err;
}
text = Text->array;
for ( k = 0; k < not0; ++k, ++j )
text[j] = str[k];
}
continue;
case 'p':
{
ptr pointer = va_arg( va, void* );
j = Text->count;
umax2achs( &num, (uptr)pointer, str );
err = growTextc( ud, Text, num.not0 + 1 );
if ( err )
{
ECHO_ERRNO( stdout, err );
return err;
}
text = Text->array;
if ( arg.opts && (1u << FORMAT_FLAG_BOTH_SIGNS) )
text[j++] = '+';
else if ( arg.opts && (1u << FORMAT_FLAG_PLUS2SPACE) )
text[j++] = ' ';
for ( k = 0; k < num.not0; ++k, ++j )
text[j] = num.text[k];
continue;
}
case 'd':
switch ( arg.type )
{
case 't': d = va_arg( va, ptrdiff_t ); break;
case 'z': d = va_arg( va, size_t ); break;
case 'p': d = va_arg( va, dptr ); break;
case 'j': d = va_arg( va, dmax ); break;
case 'l': d = va_arg( va, dlong ); break;
default: d = va_arg( va, dint ); break;
}
j = Text->count;
dmax2achs( &num, d, str );
err = growTextc( ud, Text, num.not0 + 1 );
if ( err )
{
ECHO_ERRNO( stdout, err );
return err;
}
text = Text->array;
if ( num.sign[0] == '-' )
text[j++] = '-';
else if ( arg.opts && (1u << FORMAT_FLAG_BOTH_SIGNS) )
text[j++] = '+';
else if ( arg.opts && (1u << FORMAT_FLAG_PLUS2SPACE) )
text[j++] = ' ';
for ( k = 0; k < num.not0; ++k, ++j )
text[j] = num.text[k];
continue;
default:
switch ( arg.type )
{
case 't': u = va_arg( va, ptrdiff_t ); break;
case 'z': u = va_arg( va, size_t ); break;
case 'p': u = va_arg( va, uptr ); break;
case 'j': u = va_arg( va, umax ); break;
case 'l': u = va_arg( va, ulong ); break;
default: u = va_arg( va, uint ); break;
}
j = Text->count;
umax2achs( &num, u, str );
err = growTextc( ud, Text, num.not0 + 1 );
if ( err )
{
ECHO_ERRNO( stdout, err );
return err;
}
text = Text->array;
if ( arg.opts && (1u << FORMAT_FLAG_BOTH_SIGNS) )
text[j++] = '+';
else if ( arg.opts && (1u << FORMAT_FLAG_PLUS2SPACE) )
text[j++] = ' ';
for ( k = 0; k < num.not0; ++k, ++j )
text[j] = num.text[k];
break;
}
}
return 0;
}
dint is just a typedef for signed int, DINTS is just a typedef to my abstract buffer handling object BUFFER, as for ACHN/ACHF:
Code:
typedef struct _ACHN
{
uint not0;
ach sign[2];
ach text[bitsof(umax)];
} ACHN;
typedef struct _ACHF { ACHN num, dec, exp; } ACHF;
typedef union _ACHV { ACHF n; ACHN i[3]; } ACHV;
...
BASIC void umax2achs( ACHN *dst, umax val, achs base )
{
ach tmp[bitsof(umax)] = {0};
uint i = 0, j = 0, max = achsnot0( base );
memset( dst, 0, sizeof(ACHN) );
if ( !max )
return;
while ( val )
{
tmp[j++] = base[val % max];
val /= max;
}
dst->not0 = j;
while ( j )
dst->text[i++] = tmp[--j];
}
BASIC void dmax2achs( ACHN *dst, dmax val, achs base )
{
if ( val < 0 )
{
umax2achs( dst, -val, base );
dst->sign[0] = '-';
return;
}
umax2achs( dst, val, base );
}
BASIC void ldnum2achs( ACHF *dst, ldnum val, achs base )
{
dint exp = 0;
ldnum full = 0, part = 0;
uint max = achsnot0( base );
if ( !max )
{
memset( dst, 0, sizeof(ACHF) );
return;
}
frexpl( val, &exp );
if ( exp > LDBL_MAX_10_EXP )
{
if ( val < 0 )
{
while ( -val > max )
val /= max;
}
else
{
while ( val > max )
val /= max;
}
}
if ( val > 0u )
{
full = floorl( val );
part = val - full;
}
else
{
full = ceill(val);
part = -(val + full);
}
while ( floorl(part) != part )
part *= max;
dmax2achs( &(dst->num), (dmax)full, base );
umax2achs( &(dst->dec), (umax)part, base );
dmax2achs( &(dst->exp), exp, ACHS_0TO9 );
}
Can't remember what ACHV was for so if you think of anything lemme know, oh and achs is just a typedef to char const *, likewise ach is just a typedef to char, they exist to complete the set (I also have wchs, tchs, uchs, c16s & c32s, tch/s being for TCHAR on windows and char anywhere else, uchs is for char or uint_least8_t)
