Refactoring

src/libs/math.cc

@@ -0,0 +1,32 @@
+#include "math.hpp"
+
+int pow(int x, int n) {
+  if (n < 0)
+    return -1;
+  else if (n == 0)
+    return 1;
+  else if (n == 1)
+    return x;
+  int ret = x;
+  for (int i = 0; i < (n - 1); i++)
+    ret *= x;
+  return ret;
+}
+
+int max(int x, int y) {
+  if (x > y)
+    return x;
+  return y;
+}
+
+int min(int x, int y) {
+  if (x < y)
+    return x;
+  return y;
+}
+
+int abs(int x) {
+  if (x < 0)
+    return -x;
+  return x;
+}

src/libs/math.hpp

@@ -0,0 +1,6 @@
+#pragma once
+
+int pow(int x, int n);
+int max(int x, int y);
+int min(int x, int y);
+int abs(int x);

src/libs/stdio.cc

@@ -0,0 +1,123 @@
+#include "stdio.hpp"
+#include "drivers/framebuffer.hpp"
+#include "math.hpp"
+#include "string.hpp"
+
+extern VIDEO_STATE VS;
+void (*__putchar)(char)=putchar;
+
+void printk(char *str,...) {
+  u64 rsi,rdx,rcx,r8,r9;
+  u64* rbp;
+  asm( "mov %%rsi, %0": "=a"(rsi));
+  asm( "mov %%rdx, %0": "=a"(rdx));
+  asm( "mov %%rcx, %0": "=a"(rcx));
+  asm( "mov %%r8, %0": "=a"(r8));
+  asm( "mov %%r9, %0": "=a"(r9));
+  asm( "mov %%rbp, %0": "=a"(rbp));
+
+  // Init informations
+  int len=strlen(str);
+  int i=0; // Pointer to the current character
+  int p=1; // Pointer to the current parameter
+
+  while (i!=len) {
+    char c=str[i];
+    // Check if special char is comming
+    if(str[i]=='%'){
+      char c2=str[i+1];
+      char c3=str[i+2];
+      // First just consider the data as a void pointer
+      u64 data;
+      switch (p) {
+      case 1:
+        data=rsi;
+        break;
+      case 2:
+        data=rdx;
+        break;
+      case 3:
+        data=rcx;
+        break;
+      case 4:
+        data=r8;
+        break;
+      case 5:
+        data=r9;
+        break;
+      default:
+        data=*(rbp+2+p-6);
+      }
+      
+      if(c2=='%'){
+        __putchar('%');
+        i++;
+      }
+      else if (c2=='d') {
+        int data_int=(int)data;
+        printi(data_int);
+        i++;
+        p++;
+      }
+      else if (c2=='s') {
+        print((char*)data);
+        i++;
+        p++;
+      }
+      else if (c2=='x') {
+        print("0x");
+        printh(data);
+        i++;
+        p++;
+      }
+      else if (c2=='l' && c3=='l') {
+        printi(data); // TODO: Print 64bit number
+        i+=2;
+        p++;
+      }
+    }
+    else{
+      __putchar(c);
+    }
+    i++;
+  }
+}
+
+void print(char *s){
+  int i=0;
+  while(s[i]!='\0'){
+    __putchar(s[i]);
+    i++;
+  }
+}
+
+void printc(char *str, VIDEO_COLORS c) {
+  VIDEO_COLORS backup = (VIDEO_COLORS)VS.fg;
+  VS.fg = c;
+  print(str);
+  VS.fg = backup;
+}
+
+void printi(int i) {
+  char str[12];
+  itoa(i, str);
+  print(str);
+}
+
+void printh(int h) {
+  char str[17];
+  itoh(h, str);
+  print(str);
+}
+void printh(int h, int size) {
+  char str[17];
+  char str2[17];
+  itoh(h, str);
+  int a = 0;
+  for (int i = min(max(16 - size, 0), 15); i < 16; i++) {
+    str2[a] = str[i];
+    a++;
+  }
+  str2[a] = '\0';
+  print(str2);
+}

src/libs/stdio.hpp

@@ -0,0 +1,36 @@
+#pragma once
+
+#include "drivers/framebuffer.hpp"
+
+/// @brief Current active framebuffer driver
+extern void (*__putchar)(char);
+
+/**
+ * Print a char* in the framebuffer
+ */
+void printk(char *,...);
+
+/**
+ * Print a char*
+ */
+void print(char *s);
+
+/**
+ * Print a char in the framebuffer
+ */
+void printc(char *, VIDEO_COLORS c);
+
+/**
+ * Print an integer using itoa()
+ */
+void printi(int i);
+
+/**
+ * Print an integer as hex using itoh()
+ */
+void printh(int h);
+
+/**
+ * Print an integer as hex using itoh() truncated to size
+ */
+void printh(int h, int size);

src/libs/string.cc

@@ -0,0 +1,71 @@
+#include "string.hpp"
+#include "math.hpp"
+
+void memcpy(void* src, void* dst, int size){
+    char *c_src=(char*)src;
+    char *c_dst=(char*)dst;
+    for(int i=0;i<size;i++)
+        *c_dst=*c_src;
+}
+
+void itoa(u64 i, char *a){
+    // Check if lower than 0
+    char neg=0;
+    if(i<0){
+        neg=1;
+        i=-i;
+        a[0]='-';
+    }
+
+    // Count number of digits
+    int len=1;
+    while(i/pow(10,len)>=1)
+    {
+        len++;
+    }
+
+    // Build string
+    int max_pow=len-1;
+    for(int j=0;j<=max_pow;j++){
+        int cur_pow=pow(10,max_pow-j);
+        char digit=i/cur_pow;
+        a[j+neg]='0'+digit;
+        i=i-digit*cur_pow; // Remove first digits (most significant)
+    }
+    a[len+neg]='\0';
+}
+
+void itoh(u64 i, char *a){
+    char hex[]={'0','1','2','3','4','5','6','7','8','9',
+        'A','B','C','D','E','F'
+    };
+
+    // i should be split int two
+    // indeed shifting with more than 32 bits seems undefined 
+    u32 i_a=i&0xFFFFFFFF;
+    u32 i_b=i>>32;
+
+   for(char j=0;j<8;j++){
+        u64 t=(j*4);
+        u64 mask=0xF;
+        mask=mask <<  t;
+        u64 index=(i_a&mask) >> t;
+        a[15-j]=hex[index];
+    } 
+
+   for(char j=0;j<8;j++){
+        u64 t=(j*4);
+        u64 mask=0xF;
+        mask=mask <<  t;
+        u64 index=(i_b&mask) >> t;
+        a[15-(j+8)]=hex[index];
+    }
+    a[16]='\0';
+}
+
+int strlen(char *s){
+    int i=0;
+    while(s[i]!='\0')
+        i++;
+    return i;
+}

src/libs/string.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "core/types.hpp"
+
+/**
+ * Copy data byte per byte from src to dst
+ */
+void memcpy(void *src, void *dst, int size);
+
+/**
+ * Convert int to char array
+ */
+void itoa(u64 i, char *a);
+
+/**
+ * Convert int to char array
+ */
+void itoh(u64 i, char *a);
+
+/**
+ * Length of a char*
+ */
+int strlen(char *s);