add barebones uacpi support. just gets tables

1 files changed, 122 insertions, 52 deletions

diff --git a/lib/printf.c b/lib/printf.c
index b96c616..0a9cc15 100644
--- a/lib/printf.c
+++ b/lib/printf.c
@@ -17,6 +17,13 @@ int kprintf(const char *fmt, ...)
     if(str && i < size) str[i] = (c); \
     i++
 
+struct print_flags
+{
+    char flg_alt, flg_zeropad, flg_ladjust, flg_showsign, flg_signspace;
+    int fieldw, precision;
+    int lenmod, lenspec, radix, unsign;
+};
+
 static int
 convert_as_int(
         char *str,
@@ -51,26 +58,40 @@ convert_as_int(
 enum printf_state
 {
     FSTATE_DIRECT = 0,
+    FSTATE_FLAG,
+    FSTATE_FIELDWIDTH,
+    FSTATE_PRECISION,
+    FSTATE_LENMOD,
     FSTATE_CONVERT
 };
 
 static int
-s_convert_string(char *str, size_t size, va_list ap, size_t stri)
+s_convert_string(char *str, size_t size, va_list ap, size_t stri, struct print_flags flags)
 {
     const char *strarg = va_arg(ap, const char*);
-    for(const char *strargc = strarg; *strargc; strargc++) {
-        SPRINTF_PUTC(str, size, stri, *strargc);
+    if((uintptr_t)strarg < 0xFFFF800000000000ULL) return stri;
+
+    int arglen = flags.precision == 0 ? strlen(strarg) : flags.precision;
+    int minlen = flags.fieldw;
+    char padc = flags.flg_zeropad ? '0' : ' ';
+
+    for(int i = 0; i < minlen - arglen; i++) {
+        SPRINTF_PUTC(str, size, stri, padc);
+    }
+
+    for(int i = 0; i < arglen; i++) {
+        SPRINTF_PUTC(str, size, stri, strarg[i]);
     }
     return stri;
 }
 
 static int
 s_convert_int(char *str, size_t size, va_list ap, size_t stri,
-              int fw, char fp, int typelen, int radix, int usign, int caps)
+              struct print_flags flags)
 {
     char num_buf[64];
     uintmax_t value = 0;
-    switch(typelen) {
+    switch(flags.lenspec) {
         case 1: value = (uintmax_t)(int8_t)va_arg(ap, int); break;
         case 2: value = (uintmax_t)(int16_t)va_arg(ap, int); break;
         default:
@@ -79,17 +100,19 @@ s_convert_int(char *str, size_t size, va_list ap, size_t stri,
     }
     size_t pad_stri = stri;
 
-    int advance = convert_as_int(num_buf, 64, 0, value, radix, usign);
-    if(caps) {
+    int advance = convert_as_int(num_buf, 64, 0, value, flags.radix, flags.unsign);
+    if(flags.flg_alt) {
         for(int i = 0; i < advance; i++) {
             num_buf[i] = c_toupper(num_buf[i]);
         }
     }
 
-    int pad_diff = fw - advance;
+    int pad_diff = flags.fieldw - advance;
+    char padchar = flags.flg_zeropad ? '0' : ' ';
     for(int i = 0; i < pad_diff; i++) {
-        SPRINTF_PUTC(str, size, stri, fp);
+        SPRINTF_PUTC(str, size, stri, padchar);
     }
+    
     for(int i = 0; i < advance; i++) {
         SPRINTF_PUTC(str, size, stri, num_buf[i]);
     }
@@ -119,57 +142,104 @@ vsnprintf(
     int stri = 0;
     int state = FSTATE_DIRECT;
 
+    struct print_flags flags = { 0 };
+    flags.lenspec = 4;
+
     for(const char *fmtc = fmt; *fmtc; fmtc++) {
         if(state == FSTATE_DIRECT) {
             if(*fmtc == '%') {
-                state = FSTATE_CONVERT;
+                state++;
                 continue;
             }
             SPRINTF_PUTC(str, size, stri, *fmtc);
-        }else {
-            int field_width = 0;
-            char field_pad = ' ';
-
-            int lenspec = 4;
-        
-            int radix = 10;
-            int unsign = 0;
-            int caps = 0;
-
-            if(state == FSTATE_CONVERT) {
-                switch(*fmtc) {
-                    case 's':
-                        stri = s_convert_string(str, size, ap, stri);
-                        break;
-                    case 'b':
-                        stri = s_convert_int(str, size, ap, stri, field_width, field_pad, lenspec, 2, 1, 0);
-                        break;
-                    case 'o':
-                         stri = s_convert_int(str, size, ap, stri, field_width, field_pad, lenspec, 8, 0, 0);
-                        break;
-                    case 'p':
-                        lenspec = sizeof(uintptr_t);
-                        field_width = lenspec * 2;
-                        field_pad = '0';
-                    case 'X':
-                        caps = 1;
-                    case 'x':
-                        unsign = 1;
-                        stri = s_convert_int(str, size, ap, stri, field_width, field_pad, lenspec, 16, unsign, caps);
-                        break;
-                    case 'u':
-                        unsign = 1;
-                    case 'd':
-                    case 'i':
-                        stri = s_convert_int(str, size, ap, stri, field_width, field_pad, lenspec, 10, unsign, caps);
-                        break;
-                    /*custom formatters for jove.*/
-                    case 'P':
-                        stri = s_convert_path(str, size, ap, stri);
-                        break;
+        }else 
+        if(state == FSTATE_FLAG) {
+            switch(*fmtc) {
+                case '#': flags.flg_alt = 1; break;
+                case '0': flags.flg_zeropad = 1; break;
+                case '-': flags.flg_ladjust = 1; break;
+                case ' ': flags.flg_signspace = 1; break;
+                case '+': flags.flg_showsign = 1; break;
+                default:
+                    state++;
+                    fmtc--;
+                break;
+            }
+        }else
+        if(state == FSTATE_FIELDWIDTH) {
+            if(*fmtc > '0' && *fmtc <= '9') {
+                do {
+                    flags.fieldw *= 10;
+                    flags.fieldw += *fmtc - '0';
+                    fmtc++;
+                } while(*fmtc >= '0' && *fmtc <= '9');
+            }
+            fmtc--;
+            state++;
+        }else
+        if(state == FSTATE_PRECISION) {
+            if(*fmtc == '.') {
+                fmtc++;
+                while(*fmtc >= '0' && *fmtc <= '9') {
+                    flags.precision *= 10;
+                    flags.precision += *fmtc - '0';
+                    fmtc++;
                 }
             }
-            state = FSTATE_DIRECT;
+            fmtc--;
+            state++;
+        }else
+        if(state == FSTATE_LENMOD) {
+            switch(*fmtc) {
+                case 'l':
+                    flags.lenmod =
+                        flags.lenmod == 'l' ? 'L' : 'l';
+                break;
+                default:
+                    fmtc--;
+                    state++;
+                break;
+            }
+        }else
+        if(state == FSTATE_CONVERT) {
+            switch(*fmtc) {
+                case 's':
+                    stri = s_convert_string(str, size, ap, stri, flags);
+                    break;
+                case 'b':
+                    flags.radix = 2;
+                    stri = s_convert_int(str, size, ap, stri, flags);
+                    break;
+                case 'o':
+                    flags.radix = 8;
+                    stri = s_convert_int(str, size, ap, stri, flags);
+                    break;
+                case 'p':
+                    flags.lenspec = sizeof(uintptr_t);
+                    flags.fieldw = flags.lenspec * 2;
+                    flags.flg_zeropad = 1;
+                    flags.flg_alt = 1;
+                case 'X':
+                    flags.flg_alt = 1;
+                case 'x':
+                    flags.unsign = 1;
+                    flags.radix = 16;
+                    stri = s_convert_int(str, size, ap, stri, flags);
+                    break;
+                case 'u':
+                    flags.unsign = 1;
+                case 'd':
+                case 'i':
+                    flags.radix = 10;
+                    stri = s_convert_int(str, size, ap, stri, flags);
+                    break;
+                /*custom formatters for jove.*/
+                case 'P':
+                    stri = s_convert_path(str, size, ap, stri);
+                    break;
+            }
+        flags = (struct print_flags) { 0 };
+        state = FSTATE_DIRECT;
         }
     }
     if(str && stri < size) str[stri] = 0;