diff --git a/.ft_printf.c.swn b/.ft_printf.c.swn new file mode 100644 index 0000000..e57f2e2 Binary files /dev/null and b/.ft_printf.c.swn differ diff --git a/ft_printf.c b/ft_printf.c index 9d9ba40..0f53885 100644 --- a/ft_printf.c +++ b/ft_printf.c @@ -1,13 +1,13 @@ #include "ft_printf.h" +#include -int ft_error(int i) -{ - if (i == 0) - return (1); - return (0); -} - +//int ft_error(int i) +//{ +// if (i == 0) +// return (1); +// return (0); +//} /* %[arg_nbr$][flags 0,-,#,', ,+][width *][.precision *][length hh,h,ll,l,L,j,t,z][specifier d,i,u,x,X,c,s,p,%,e,f,g,n,E,F,G,a,A,C,S,o] @@ -43,43 +43,98 @@ while ((s = next_word(str)) != NULL) */ -char *ft_nextword(char *str) -{ - char *word; - word = strdup(str); - return (word); -} +//char *ft_nextword(char *str) +//{ +// char *word; +// +// word = strdup(str); +// return (word); +//} -t_prist *ft_store(char *str) -{ - t_prist *lst; - t_prist *lstmp; - char *tmp; +//t_prist *ft_store(char *str) +//{ +// t_prist *lst; +// t_prist *lstmp; +// char *tmp; +// +// lst = NULL; +// while (*str != '\0') +// { +// lstmp = lst; +// (*lst) = (t_prist *)malloc(sizeof(*lst)); +// tmp = ft_nextword(str); +// (*arglst)->str = ft_strdup(tmp); +// ...fill_flag...; +// if (tmp != NULL) +// tmp[0] = '%'; +// str = tmp; +// lst->next = lstmp; +// } +// return (lst); +//} - lst = NULL; - while (*str != '\0') - { - lstmp = lst; - (*lst) = (t_prist *)malloc(sizeof(*lst)); - tmp = ft_nextword(str); - (*arglst)->str = ft_strdup(tmp); - ...fill_flag...; - if (tmp != NULL) - tmp[0] = '%'; - str = tmp; - lst->next = lstmp; - } - return (lst); -} +/* +** char *print; | -contain the arg converted into a string +** char *type; | -contain the specifier type to use +** | by va_arg +** while s = next_word() | -return the next sequence to be print +** | (either a string, or a conversion) +** type = ft_specifier(&s) | -return the type if it's a conversion, +** | or NULL if it's a string. +** | if convers0, rmvs length & specifier from s +** if !type: ft_put_word() | -print the string if it wasn't a conversion +** while flag_*(s) | -for each * present, expand it into s +** ft_expand_star() | in order it appears +** print = ft_convert() | -convert the arg with its type, +** | then trsfm it into a str and rtrn the str +** ft_flag_transform() | -proceed all modification according to flags +** ft_put_word(print) | -print the string fully converted +** return (length) | -return the length of what was printed +*/ int ft_printf(char *string, ...) { + char *print; + char *type; + int length; + + length = 0; + while ((s = next_word(str)) != NULL) + { + if (!(type = ft_specifier(&s))) + lentgh += ft_put_word(s); + while (flag_*(s)) + ft_expand_star(va_arg(ap, int), &s); + print = ft_convert(va_arg(ap, type), type); + print = ft_flag_transform(s, print); + length += ft_put_word(print); + } + return (length) +} + +// ft_flag_transform() +// { +// if ((i = flag_p(&s))) // precision is calculated before width, if its on string it cuts it if smaller than it, +// print = ft_precision(i, print); // and on numbers it add '0' before it if bigger, then add minus sign if negatif (if precision is given with flags - or 0 they're ignored and cuted from s) +// if ((i = flag_w(s))) // +// { +// if (flag_-(s)) +// print = ft_right_padded(i, print); +// else if (flag_0(s)) +// print = ft_left_padded(i, print); +// } +// // if (flag_+(s)) +// // else if (flag_space(s)) +// // if (flag_'(s)) +// // if (flag_#(s)) +// // print = ft_alternate_form(print) +// } + t_prist *lst; va_list ap; va_start(ap, string); - lst = ft_store(string); while (*string != '\0') { if (*string == 's') @@ -107,11 +162,28 @@ int main(void) i = 6; printf("%s-%s-%c-%i\n\n", s, str, c, i); ft_printf(s, c, str, i); + printf("char %lu\n", sizeof(char)); + printf("short %lu\n", sizeof(short)); + printf("int %lu\n", sizeof(int)); + printf("long %lu\n", sizeof(long)); + printf("long long %lu\n", sizeof(long long)); + printf("unsigned char %lu\n", sizeof(unsigned char)); + printf("unsigned short %lu\n", sizeof(unsigned short)); + printf("unsigned int %lu\n", sizeof(unsigned int)); + printf("unsigned long %lu\n", sizeof(unsigned long)); + printf("unsigned long long %lu\n", sizeof(unsigned long long)); + printf("char * %lu\n", sizeof(char *)); + printf("short * %lu\n", sizeof(short *)); + printf("int * %lu\n", sizeof(int *)); + printf("long * %lu\n", sizeof(long *)); + printf("long long * %lu\n", sizeof(long long *)); + printf("double %lu\n", sizeof(double)); +// printf("wint_t %lu\n", sizeof(wint_t)); +// printf("wchar_T %lu\n", sizeof(wchar_t)); return (0); } /* - conversions : cspdiuxX% flags : - 0 . * conversions : nfge @@ -121,80 +193,79 @@ conversions : nfge % [flags 0,- ][width *][.precision *] [specifier d,i,u,x,X,c,s,p,% ] % [flags #,', ,+] [length hh,h,ll,l ][specifier e,f,g,n ] -int flag: pw+ '#-0 -00000000 00000000 00000000 00000001 == 1 '0' -00000000 00000000 00000000 00000010 == 2 '-' -00000000 00000000 00000000 00000100 == 4 '#' -00000000 00000000 00000000 00001000 == 8 ''' -00000000 00000000 00000000 00010000 == 16 ' ' -00000000 00000000 00000000 00100000 == 32 '+' -00000000 00000000 00000000 01000000 == 64 '*' width -00000000 00000000 00000000 10000000 == 128 '*' precision +p == long unsigned int -typedef struct s_prist -{ - char *str; - int flag; // default 0 ; [0-#' +**] binary - int width; // default 0 ; - int prec; // default 0 ; precision - char *length; // default "\0" ; - char spec; // default 0 ; specifier - char *arg; // default "\0" ; - int p_nb; // default 0 ; print_nb : order in which to print (order it was found in string) - int a_nb; // default 0 ; arg_nb : number of the corresponding argument (for flag $) - struct s_prist *next; -} t_prist; +char 1bytes 8bits +short 2bytes 16bits +int 4bytes 32bits +long 8bytes 64bits +long long 8bytes 64bits -("2 1 3 4 3", 1, 2, 3, 4) + 255 -127 - +127 00 [char] [hhd, hhi, c] [int] [d( , h, hh), i( , h, hh), c] + 65535 -32768 - +32767 01 [short] [hd, hi] [int] + 4294967295 -2147483648 - +2147483647 02 [int] [d, i] [int] +18446744073709551615 -9223372036854775808 - +9223372036854775807 04 [long] [ld, li] [long] [d(l ,ll), i(l, ll)] +18446744073709551615 -9223372036854775808 - +9223372036854775807 04 [long long] [lld, lli] [long] + 256 0 - +255 05 [unsigned char] [hhu, hhx, hhX] [unsigned long] [u( , h, hh, l, ll), x( , h, hh, l, ll), X( , h, hh, l, ll), p] + 65536 0 - +65536 06 [unsigned short] [hu, hx, hX] [unsigned long] + 4294967296 0 - +4294967296 07 [unsigned int] [u, x, X, p] [unsigned long] +18446744073709551616 0 - +18446744073709551616 09 [unsigned long] [lu, lx, lX] [unsigned long] +18446744073709551616 0 - +18446744073709551616 09 [unsigned long long] [llu, llx, llX] [unsigned long] +18446744073709551616 0 - +18446744073709551616 10 [char *] [s, hhn] [char *] [s] -ft_error(int err) -ft_store("%i truc %-10d machin\n") - ft_split_print(str) - prist->str = "%i"; - ft_fill_lst(prist) - prist->flag; // default = 0 - prist->width; // default = 0 - prist->prec; // default = 0 - prist->length; - prist->spec; - prist->p_nb; - prist->a_nb; // if not $ == p_nb - prist->str = " truc "; - ft_fill_lst(prist) - ... // if str start without % it means it can be printed as a string directly - prist->str = "%-10d"; - ft_fill_lst... - prist->str = " machin\n"; - ft_fill_lst... - return - {{str; flag; width; precision; length; specifier; p_nb 1; a_nb 2}, - {str; flag; width; precision; length; specifier; p_nb 2; a_nb 1}, - {str; flag; width; precision; length; specifier; p_nb 3; a_nb 3}, - {str; flag; width; precision; length; specifier; p_nb 4; a_nb 4}, - {str; flag; width; precision; length; specifier; p_nb 5; a_nb 3}} +18446744073709551616 0 - +18446744073709551616 16 [double] [e, le, f, lf, g, lg] [] +18446744073709551616 0 - +18446744073709551616 17 [wint_t] [lc] [] +18446744073709551616 0 - +18446744073709551616 18 [wchar_t] [ls] [] +18446744073709551616 0 - +18446744073709551616 11 [short *] [hn] [] +18446744073709551616 0 - +18446744073709551616 12 [int *] [n] [] +18446744073709551616 0 - +18446744073709551616 13 [long *] [ln] [] +18446744073709551616 0 - +18446744073709551616 14 [long long *] [lln] [] -ft_sort_by_arg -{{str; flag; width; precision; length; specifier; p_nb 2; a_nb 1}, - {str; flag; width; precision; length; specifier; p_nb 1; a_nb 2}, - {str; flag; width; precision; length; specifier; p_nb 3; a_nb 3}, - {str; flag; width; precision; length; specifier; p_nb 5; a_nb 3}, - {str; flag; width; precision; length; specifier; p_nb 4; a_nb 4}} +d int 0 int +dhh char 1 char +dh short 2 short +dl long 3 long +dll long long 4 long long -ft_add_arg -if lst->str[o] != '\%' rerun without looking for argument -if lst->flag == * rerun for next argument but same list element - [fl][w][p] or or - %i ,1 -> '1' [] [0][0] [ ][0][0] [] [0][0] - %*i ,3,1 -> ' 1' [*] [0][0] [* ][0][0] [w] [0][0] - %.*i ,2,1 -> '01' [*] [0][0] [ *][0][0] [p] [0][0] - %*.*i ,3,2,1 -> ' 01' [**][0][0] [**][0][0] [wp][0][0] - %3.*i ,2,1 -> ' 01' [*] [3][0] [ *][3][0] [p] [3][0] - %*.2i ,3,1 -> ' 01' [*] [0][2] [* ][0][2] [w] [0][2] - %3.2i ,1 -> ' 01' [] [3][2] [ ][3][2] [] [3][2] -if lst->next->a_nb == lst->a_nb rerun for next list element but same argument -{{str; flag; width; precision; length; specifier; arg; p_nb 2; a_nb 1}, - {str; flag; width; precision; length; specifier; arg; p_nb 1; a_nb 2}, - {str; flag; width; precision; length; specifier; arg; p_nb 3; a_nb 3}, - {str; flag; width; precision; length; specifier; arg; p_nb 5; a_nb 3}, - {str; flag; width; precision; length; specifier; arg; p_nb 4; a_nb 4}} +i int +ihh char +ih short +il long +ill long long + +u unsigned int 5 unsigned int +uhh unsigned char 6 unsigned char +uh unsigned short 7 unsigned short +ul unsigned long 8 unsigned long +ull unsigned long long 9 unsigned long long + +x unsigned int +xhh unsigned char +xh unsigned short +xl unsigned long +xll unsigned long long + +X unsigned int +Xhh unsigned char +Xh unsigned short +Xl unsigned long +Xll unsigned long long + +c char -> int +cl wint_t 10 wint_t +s char * 11 char * +sl wchar_t * 12 wchar_t * +p unsigned int +e double 13 double +el +f double +fl +g double +gl + +n int * 14 int * +nhh char * +nh short * 15 short * +nl long * 16 long * +nll long long * 17 long long * */ diff --git a/main.c b/main.c index 65214f1..b9f93d4 100644 --- a/main.c +++ b/main.c @@ -94,7 +94,7 @@ int main(void) printf("(\"%%i\",0x1E240) : "); printf("%i\n", 0x1E240); printf("\n"); printf("-----------------------------------------------\n"); - printf("- flags : -,0,.,* -\n"); + printf("- flags : -0.* -\n"); printf("- taille de champ minimale -\n"); printf("-----------------------------------------------\n\n"); @@ -118,6 +118,9 @@ int main(void) // printf("(\"%%0i\",0) ft : "); ft_printf("'%0i'\n", 0); printf("(\"%%0i\",0) : "); printf("'%0i'\n", 0); printf("\n"); + // printf("(\"%%6i\",-456) ft : "); ft_printf("'%6i'\n", -456); + printf("(\"%%6i\",-456) : "); printf("'%6i'\n", -456); printf("\n"); + printf("- flag - --------------------------------------\n\n"); // printf("(\"%%-3s\",\"a\") ft : "); ft_printf("'%-3s'\n", "a"); @@ -146,11 +149,37 @@ int main(void) // printf("(\"%%03i\",1) ft : "); ft_printf("'%03i'\n", 1); printf("(\"%%03i\",1) : "); printf("'%03i'\n", 1); printf("\n"); - printf("- flag . --------------------------------------\n\n"); + // printf("(\"%%09i\",\"123456\") ft : "); ft_printf("'%09s'\n", "123456"); +// printf("(\"%%09i\",\"123456\") : "); printf("'%09s'\n", "123456"); printf("\n"); + + // printf("(\"%%03i\",1) ft : "); ft_printf("'%03i'\n", 1); + printf("(\"%%03i\",1) : "); printf("'%03i'\n", 1); printf("\n"); + + // printf("(\"%%03i\",1) ft : "); ft_printf("'%03i'\n", 1); + printf("(\"%%03i\",1) : "); printf("'%03i'\n", 1); printf("\n"); + + printf("- flag . (diouxXs) ----------------------------------------------------------\n"); + printf("- if the . is not followed by a number, the value is 0\n"); + printf("- with arg value of 0, precision of 0 print nothing\n"); + printf("- with numbers (diouxX), gives the minimum number of digit to appear\n"); + printf("- if precision > nbr, it's preceded by '0'\n"); + printf("- if nbr < 0, '-' is not counted in precision\n"); + printf("- (length with '-' is (length(nbr or precision) + 1)'\n"); + printf("- if 0 flag is given (for width or precision) it's ignored\n"); + printf("- with strings (s), gives the maximum number of characters to be print\n"); + printf("- if precision > length(s), it's not preceded by '0'\n"); + printf("- precision is calculated before width\n"); + printf("\n"); // printf("(\"%%.5s\",\"12\") ft : "); ft_printf("'%.5s'\n", "12"); printf("(\"%%.5s\",\"12\") : "); printf("'%.5s'\n", "12"); printf("\n"); + // printf("(\"%%.5s\",\"12345678\") ft : "); ft_printf("'%.5s'\n", "12345678"); + printf("(\"%%.5s\",\"12345678\") : "); printf("'%.5s'\n", "12345678"); printf("\n"); + + // printf("(\"%%12.5s\",\"12345678\") ft : "); ft_printf("'%12.5s'\n", "12345678"); + printf("(\"%%12.5s\",\"12345678\") : "); printf("'%12.5s'\n", "12345678"); printf("\n"); + // printf("(\"%%.5i\",12) ft : "); ft_printf("'%.5i'\n", 12); printf("(\"%%.5i\",12) : "); printf("'%.5i'\n", 12); printf("\n"); @@ -178,6 +207,9 @@ int main(void) // printf("(\"%%.i\",0) ft : "); ft_printf("'%.i'\n", 0); printf("(\"%%.i\",0) : "); printf("'%.i'\n", 0); printf("\n"); + // printf("(\"%%i\",0) ft : "); ft_printf("'%i'\n", 0); + printf("(\"%%i\",0) : "); printf("'%i'\n", 0); printf("\n"); + // printf("(\"%%010.7X\",8645) ft : "); ft_printf("'%010.7X'\n", 8645); printf("(\"%%010.7X\",8645) : "); printf("'%010.7X'\n", 8645); printf("\n"); @@ -187,8 +219,14 @@ int main(void) // printf("(\"%%-10.7X\",8645) ft : "); ft_printf("'%-10.7X'\n", 8645); printf("(\"%%-10.7X\",8645) : "); printf("'%-10.7X'\n", 8645); printf("\n"); - // printf("(\"%%-.7X\",8645) ft : "); ft_printf("'%-.7X'\n", 8645); - printf("(\"%%-.7X\",8645) : "); printf("'%-.7X'\n", 8645); printf("\n"); + // printf("(\"%%-.7i\",8645) ft : "); ft_printf("'%-.7i'\n", 8645); + printf("(\"%%-.7i\",8645) : "); printf("'%-.7i'\n", 8645); printf("\n"); + + // printf("(\"%%.7i\",-8645) ft : "); ft_printf("'%.7i'\n", -8645); + printf("(\"%%.7i\",-8645) : "); printf("'%.7i'\n", -8645); printf("\n"); + + // printf("(\"%%.07i\",8645) ft : "); ft_printf("'%.07i'\n", 8645); + printf("(\"%%.07i\",8645) : "); printf("'%.07i'\n", 8645); printf("\n"); printf("- flag * --------------------------------------\n\n"); @@ -283,87 +321,165 @@ int main(void) return (0); } - // conversions : cspdiuxX% - // flags : -,0,.,* - // conversions : nfge - // flags : l,ll,h,hh,#,', ,+ - // - // usage : - // %[arg_nbr$][flags #,0,-, ,+,'][width *][.precision *][length hh,h,ll,l,L,j,t,z][specifier d,i,u,x,X,c,s,p,%,e,f,g,n,E,F,G,a,A,C,S,o] - // % [flags 0,- ][width *][.precision *] [specifier d,i,u,x,X,c,s,p,% ] - // % [flags #,', ,+] [length hh,h,ll,l ][specifier e,f,g,n ] - // - // [arg_nbr] - //( nbr$ specify the argument to access, they are numbered starting at 1 - // - // [flags] #,0,-, ,+,' - // - left-justify within the given field width - // 0 left-pads the number with zeroes (0) instead of spaces, where - // padding is specified (see width sub-specifier) - //( + forces to precede the result with a plus or minus sign even for - // positive numbers) - //( (space) if no sign is going to be written, a blank space is inserted - // before the value) - //( # (o, x, X, a, A, e, E, f, F, g, G) used with (o, x or X) the - // value is preceded with 0, 0x or 0X for values different than - // zero. used with (e, E or f), it forces the written output to - // contain a decimal point even if no digits would follow. by - // default, if no digits follow, no decimal point is written. used - // with (g or G) the result is the same as with e or E but trailing - // zeros are not removed - //( ' (d, u, i, f, F) used with d, u or i, or the integral portion of - // a float f or F, the decimal conversions are printed by groups of - // thousands separated by the non-monetary separator returned by - // localeconv(3) (ex 123456789 -> 123,456,789) - // - // - // [specifiers] d,i,u,x,X,c,s,p,%,e,f,g,n,E,F,G,a,A,C,S,o - // c char character - // s *char string of characters - // p * pointer adress - // d int (or i) signed decimal integer - // i int (or d) signed decimal integer - // u int unsigned decimal integer - // x int unsigned hexadecimal integer - // X int unsigned hexadecimal integer (capital letters) - //( n *int nothing printed - //( f float decimal floating point - //( e float scientific notation (mantissa/exponent) using e - //( g float uses the shorter of %e or %f - //((F float - //((E float scientific notation (mantissa/exponent) using E - //((G float uses the shorter of %E or %f - //((o int signed octal - //((C char treated as c with l modifier - //((a float - //((A float - //((S *char treated as s with l modifier - // - // [width] - // (nbr) minimum number of characters to be printed. if the value to be - // printed is shorter than this number, the result is padded with - // blank spaces. The value is not truncated even if the result is - // larger - // * the width is not specified in the format string, but as an - // additional integer value argument preceding the argument that - // has to be formatted - // - // [.precision] - // .nbr fot integer specifiers (d,i,o,x,X) - precision specifies the - // minimum number of digits to be written. If the value to be - // written is shorter than this number, the result is padded with - // leading zeros. The value is not truncated even if the result is - // longer. A precision of 0 means that no character is written for - // the value 0. For e, E and f specifiers − this is the number of - // digits to be printed after the decimal point. For g and G - // specifiers − This is the maximum number of significant digits - // to be printed. For s − this is the maximum number of characters - // to be printed. By default all characters are printed until the - // ending null character is encountered. For c type − it has no - // effect. When no precision is specified, the default is 1. If the - // period is specified without an explicit value for precision, 0 - // is assumed - // .* the precision is not specified in the format string, but as an - // additional integer value argument preceding the argument that - // has to be formated - // +/* + int flag: pw+ '#-0 + 00000000 00000000 00000000 00000001 == 1 '0' + 00000000 00000000 00000000 00000010 == 2 '-' + 00000000 00000000 00000000 00000100 == 4 '#' + 00000000 00000000 00000000 00001000 == 8 ''' + 00000000 00000000 00000000 00010000 == 16 ' ' + 00000000 00000000 00000000 00100000 == 32 '+' + 00000000 00000000 00000000 01000000 == 64 '*' width + 00000000 00000000 00000000 10000000 == 128 '*' precision + + typedef struct s_prist + { + char *str; + int flag; // default 0 ; [0-#' +**] binary + int width; // default 0 ; + int prec; // default 0 ; precision + char *length; // default "\0" ; + char spec; // default 0 ; specifier + char *arg; // default "\0" ; + int p_nb; // default 0 ; print_nb : order in which to print (order it was found in string) + int a_nb; // default 0 ; arg_nb : number of the corresponding argument (for flag $) + struct s_prist *next; + } t_prist; + + ("2 1 3 4 3", 1, 2, 3, 4) + + ft_error(int err) + ft_store("%i truc %-10d machin\n") + ft_split_print(str) + prist->str = "%i"; + ft_fill_lst(prist) + prist->flag; // default = 0 + prist->width; // default = 0 + prist->prec; // default = 0 + prist->length; + prist->spec; + prist->p_nb; + prist->a_nb; // if not $ == p_nb + prist->str = " truc "; + ft_fill_lst(prist) + ... // if str start without % it means it can be printed as a string directly + prist->str = "%-10d"; + ft_fill_lst... + prist->str = " machin\n"; + ft_fill_lst... + return + {{str; flag; width; precision; length; specifier; p_nb 1; a_nb 2}, + {str; flag; width; precision; length; specifier; p_nb 2; a_nb 1}, + {str; flag; width; precision; length; specifier; p_nb 3; a_nb 3}, + {str; flag; width; precision; length; specifier; p_nb 4; a_nb 4}, + {str; flag; width; precision; length; specifier; p_nb 5; a_nb 3}} + + ft_sort_by_arg + {{str; flag; width; precision; length; specifier; p_nb 2; a_nb 1}, + {str; flag; width; precision; length; specifier; p_nb 1; a_nb 2}, + {str; flag; width; precision; length; specifier; p_nb 3; a_nb 3}, + {str; flag; width; precision; length; specifier; p_nb 5; a_nb 3}, + {str; flag; width; precision; length; specifier; p_nb 4; a_nb 4}} + + ft_add_arg + if lst->str[o] != '\%' rerun without looking for argument + if lst->flag == * rerun for next argument but same list element + [fl][w][p] or or + %i ,1 -> '1' [] [0][0] [ ][0][0] [] [0][0] + %*i ,3,1 -> ' 1' [*] [0][0] [* ][0][0] [w] [0][0] + %.*i ,2,1 -> '01' [*] [0][0] [ *][0][0] [p] [0][0] + %*.*i ,3,2,1 -> ' 01' [**][0][0] [**][0][0] [wp][0][0] + %3.*i ,2,1 -> ' 01' [*] [3][0] [ *][3][0] [p] [3][0] + %*.2i ,3,1 -> ' 01' [*] [0][2] [* ][0][2] [w] [0][2] + %3.2i ,1 -> ' 01' [] [3][2] [ ][3][2] [] [3][2] + if lst->next->a_nb == lst->a_nb rerun for next list element but same argument + {{str; flag; width; precision; length; specifier; arg; p_nb 2; a_nb 1}, + {str; flag; width; precision; length; specifier; arg; p_nb 1; a_nb 2}, + {str; flag; width; precision; length; specifier; arg; p_nb 3; a_nb 3}, + {str; flag; width; precision; length; specifier; arg; p_nb 5; a_nb 3}, + {str; flag; width; precision; length; specifier; arg; p_nb 4; a_nb 4}} + + conversions : cspdiuxX% + flags : -,0,.,* + conversions : nfge + flags : l,ll,h,hh,#,', ,+ + + usage : + printf %[arg_nbr$][flags #,0,-, ,+,'][width *][.precision *][length hh,h,ll,l,L,j,t,z][specifier d,i,u,x,X,c,s,p,%,e,f,g,n,E,F,G,a,A,C,S,o] + ft_printf % [flags 0,- ][width *][.precision *] [specifier d,i,u,x,X,c,s,p,% ] + bonus % [flags #,', ,+] [length hh,h,ll,l ][specifier e,f,g,n ] + + [arg_nbr] + ( nbr$ specify the argument to access, they are numbered starting at 1 + + [flags] #,0,-, ,+,' + - left-justify within the given field width + 0 left-pads the number with zeroes (0) instead of spaces, where + padding is specified (see width sub-specifier) + ( + forces to precede the result with a plus or minus sign even for + positive numbers) + ( (space) if no sign is going to be written, a blank space is inserted + before the value) + ( # (o, x, X, a, A, e, E, f, F, g, G) used with (o, x or X) the + value is preceded with 0, 0x or 0X for values different than + zero. used with (e, E or f), it forces the written output to + contain a decimal point even if no digits would follow. by + default, if no digits follow, no decimal point is written. used + with (g or G) the result is the same as with e or E but trailing + zeros are not removed + ( ' (d, u, i, f, F) used with d, u or i, or the integral portion of + a float f or F, the decimal conversions are printed by groups of + thousands separated by the non-monetary separator returned by + localeconv(3) (ex 123456789 -> 123,456,789) + + + [specifiers] d,i,u,x,X,c,s,p,%,e,f,g,n,E,F,G,a,A,C,S,o + c char character + s *char string of characters + p * pointer adress + d int (or i) signed decimal integer + i int (or d) signed decimal integer + u int unsigned decimal integer + x int unsigned hexadecimal integer + X int unsigned hexadecimal integer (capital letters) + ( n *int nothing printed + ( f float decimal floating point + ( e float scientific notation (mantissa/exponent) using e + ( g float uses the shorter of %e or %f + ((F float + ((E float scientific notation (mantissa/exponent) using E + ((G float uses the shorter of %E or %f + ((o int signed octal + ((C char treated as c with l modifier + ((a float + ((A float + ((S *char treated as s with l modifier + + [width] + (nbr) minimum number of characters to be printed. if the value to be + printed is shorter than this number, the result is padded with + blank spaces. The value is not truncated even if the result is + larger + * the width is not specified in the format string, but as an + additional integer value argument preceding the argument that + has to be formatted + + [.precision] + .nbr fot integer specifiers (d,i,o,x,X) - precision specifies the + minimum number of digits to be written. If the value to be + written is shorter than this number, the result is padded with + leading zeros. The value is not truncated even if the result is + longer. A precision of 0 means that no character is written for + the value 0. For e, E and f specifiers − this is the number of + digits to be printed after the decimal point. For g and G + specifiers − This is the maximum number of significant digits + to be printed. For s − this is the maximum number of characters + to be printed. By default all characters are printed until the + ending null character is encountered. For c type − it has no + effect. When no precision is specified, the default is 1. If the + period is specified without an explicit value for precision, 0 + is assumed + .* the precision is not specified in the format string, but as an + additional integer value argument preceding the argument that + has to be formated +*/