CM: Rename public interfaces to start with 'cm_'

coderarjob · coderarjob · commit 6a1d169113a7 · 2024-11-28T22:16:21.000+05:30
diff --git a/include/cm/cm.h b/include/cm/cm.h
@@ -11,17 +11,15 @@
 #include <types.h>
 #include <stdarg.h>
 
-
-#define HALT()                      for (;;)
-
+#define INVALID_HANDLE (-1)
+#define HALT()         for (;;)
 
 INT snprintf (CHAR* dest, size_t size, const CHAR* fmt, ...);
 INT vsnprintf (CHAR* dest, size_t size, const CHAR* fmt, va_list l);
 
-
 /***************************************************************************************************
  * Halts thread for 'ms' miliseconds
  *
  * @return      Nothing
  **************************************************************************************************/
-void delay (UINT ms);
+void cm_delay (UINT ms);
diff --git a/include/cm/syscall.h b/include/cm/syscall.h
@@ -17,68 +17,68 @@
 #endif
 
 S32 syscall (OSIF_SYSCALLS fn, U32 arg1, U32 arg2, U32 arg3, U32 arg4, U32 arg5);
-INT os_thread_create (void (*startLocation)(), bool isKernelMode);
-INT os_process_create (void* startLocation, SIZE binaryLengthBytes, bool isKernelMode);
-UINT os_get_tick_period_us();
-bool os_process_is_yield_requested();
-bool os_process_is_child_exited (UINT* exitCode);
+INT cm_thread_create (void (*startLocation)(), bool isKernelMode);
+INT cm_process_create (void* startLocation, SIZE binaryLengthBytes, bool isKernelMode);
+UINT cm_get_tick_period_us();
+bool cm_process_is_yield_requested();
+bool cm_process_is_child_exited (UINT* exitCode);
 
-static inline UINT os_tickcount_to_microsec(UINT tick)
+static inline UINT cm_tickcount_to_microsec(UINT tick)
 {
-    return ((tick)*os_get_tick_period_us());
+    return ((tick)*cm_get_tick_period_us());
 }
 
-static inline void os_yield()
+static inline void cm_process_yield()
 {
     syscall (OSIF_SYSCALL_YIELD_PROCESS, 0, 0, 0, 0, 0);
 }
 
-static inline void os_process_kill(UINT code)
+static inline void cm_process_kill(UINT code)
 {
     syscall (OSIF_SYSCALL_KILL_PROCESS, code, 0, 0, 0, 0);
 }
 
-static inline void os_putstr (char* text)
+static inline void cm_putstr (char* text)
 {
     syscall (OSIF_SYSCALL_CONSOLE_WRITELN, (PTR)text, 0, 0, 0, 0);
 }
 
-static inline U32 os_process_get_pid()
+static inline U32 cm_process_get_pid()
 {
     return (U32)syscall (OSIF_SYSCALL_PROCESS_GETPID, 0, 0, 0, 0, 0);
 }
 
-static inline U32 os_get_tickcount()
+static inline U32 cm_get_tickcount()
 {
     return (U32)syscall (OSIF_SYSCALL_TIMER_GET_TICKCOUNT, 0, 0, 0, 0, 0);
 }
 
-static inline Handle os_window_create (const char* title)
+static inline Handle cm_window_create (const char* title)
 {
     return (Handle)syscall (OSIF_SYSCALL_WINDOW_CREATE, (PTR)title, 0, 0, 0, 0);
 }
 
-static inline U32 os_window_destory (Handle h)
+static inline U32 cm_window_destory (Handle h)
 {
     return (U32)syscall (OSIF_SYSCALL_WINDOW_DESTORY, (U32)h, 0, 0, 0, 0);
 }
 
-static inline void* os_process_get_datamem_start()
+static inline void* cm_process_get_datamem_start()
 {
     return (void*)syscall (OSIF_SYSCALL_PROCESS_GET_DATAMEM_START, 0, 0, 0, 0, 0);
 }
 
-static inline void* os_window_flush_graphics()
+static inline void* cm_window_flush_graphics()
 {
     return (void*)syscall (OSIF_SYSCALL_WINDOW_FLUSH_GRAPHICS, 0, 0, 0, 0, 0);
 }
 
-static inline bool os_window_getFB (Handle h, OSIF_WindowFrameBufferInfo* wfb)
+static inline bool cm_window_getFB (Handle h, OSIF_WindowFrameBufferInfo* wfb)
 {
     return syscall (OSIF_SYSCALL_WINDOW_GET_WINDOW_FB, (U32)h, (PTR)wfb, 0, 0, 0);
 }
 
-static inline bool os_process_pop_event (OSIF_ProcessEvent* e)
+static inline bool cm_process_pop_event (OSIF_ProcessEvent* e)
 {
     return syscall (OSIF_SYSCALL_POP_PROCESS_EVENT, (PTR)e, 0, 0, 0, 0);
 }
diff --git a/src/apps/gui0.c b/src/apps/gui0.c
@@ -2,21 +2,22 @@
 #include <types.h>
 #include <cm.h>
 #include <graphics.h>
+#include <debug.h>
 
 void thread0();
 void thread1();
 void thread2();
 
 static OSIF_WindowFrameBufferInfo createWindow (const char* const title)
 {
-    Handle h = os_window_create (title);
+    Handle h = cm_window_create (title);
     if (h == INVALID_HANDLE) {
         ERROR ("Window creation failed");
         HALT();
     }
 
     OSIF_WindowFrameBufferInfo fbi;
-    if (!os_window_getFB (h, &fbi)) {
+    if (!cm_window_getFB (h, &fbi)) {
         ERROR ("Window creation failed");
         HALT();
     }
@@ -26,14 +27,14 @@ static OSIF_WindowFrameBufferInfo createWindow (const char* const title)
 
 void proc_main()
 {
-    os_window_flush_graphics();
-    os_thread_create (&thread1, false);
-    os_thread_create (&thread2, false);
-    os_thread_create (&thread0, false);
+    cm_window_flush_graphics();
+    cm_thread_create (&thread1, false);
+    cm_thread_create (&thread2, false);
+    cm_thread_create (&thread0, false);
 
     while (1) {
-        if (os_process_is_yield_requested()) {
-            os_yield();
+        if (cm_process_is_yield_requested()) {
+            cm_process_yield();
         }
     }
 }
@@ -53,8 +54,8 @@ void thread0()
         graphics_rect (&fbi, (UINT)x, 0, (UINT)width, fbi.height_px, color);
         x += width + 3;
 
-        os_window_flush_graphics();
-        delay (500);
+        cm_window_flush_graphics();
+        cm_delay (500);
     }
 }
 
@@ -77,8 +78,8 @@ void thread1()
                 graphics_putpixel (&fbi, x, y, color);
             }
         }
-        os_window_flush_graphics();
-        delay (100);
+        cm_window_flush_graphics();
+        cm_delay (100);
     }
 }
 
@@ -101,7 +102,7 @@ void thread2()
                 graphics_putpixel (&fbi, x, y, color);
             }
         }
-        os_window_flush_graphics();
-        delay (80);
+        cm_window_flush_graphics();
+        cm_delay (80);
     }
 }
diff --git a/src/cm/cm.c b/src/cm/cm.c
@@ -7,16 +7,17 @@
 #include <types.h>
 #include <cm/cm.h>
 #include <cm/syscall.h>
+#include <cm/debug.h>
 
-#define OS_MICRODEC_TO_TICK_COUNT(us) ((us) / os_get_tick_period_us())
+#define cm_MICRODEC_TO_TICK_COUNT(us) ((us) / cm_get_tick_period_us())
 
 void event_handler_NDU_()
 {
     volatile OSIF_ProcessEvent e = { 0 };
-    os_process_pop_event ((OSIF_ProcessEvent*)&e);
+    cm_process_pop_event ((OSIF_ProcessEvent*)&e);
     switch (e.event) {
     case OSIF_PROCESS_EVENT_PROCCESS_YIELD_REQ:
-        os_yield();
+        cm_process_yield();
         break;
     case OSIF_PROCESS_EVENT_PROCCESS_CHILD_KILLED:
         INFO ("Child exitted with code: %x", e.data);
@@ -26,14 +27,14 @@ void event_handler_NDU_()
     }
 }
 
-void delay (UINT ms)
+void cm_delay (UINT ms)
 {
     UINT us = ms * 1000;
 
-    U32 start_tick = os_get_tickcount();
-    U32 end_tick   = start_tick + OS_MICRODEC_TO_TICK_COUNT (us);
+    U32 start_tick = cm_get_tickcount();
+    U32 end_tick   = start_tick + cm_MICRODEC_TO_TICK_COUNT (us);
 
-    while (os_get_tickcount() < end_tick) {
+    while (cm_get_tickcount() < end_tick) {
         event_handler_NDU_();
     }
 }
diff --git a/src/cm/syscalls.c b/src/cm/syscalls.c
@@ -30,7 +30,7 @@ S32 syscall (OSIF_SYSCALLS fn, U32 arg1, U32 arg2, U32 arg3, U32 arg4, U32 arg5)
     return retval;
 }
 
-INT os_process_create (void* startLocation, SIZE binaryLengthBytes, bool isKernelMode)
+INT cm_process_create (void* startLocation, SIZE binaryLengthBytes, bool isKernelMode)
 {
     KProcessFlags flags = PROCESS_FLAGS_NONE;
     if (isKernelMode) {
@@ -41,7 +41,7 @@ INT os_process_create (void* startLocation, SIZE binaryLengthBytes, bool isKerne
                     0, 0);
 }
 
-INT os_thread_create (void (*startLocation)(), bool isKernelMode)
+INT cm_thread_create (void (*startLocation)(), bool isKernelMode)
 {
     KProcessFlags flags = PROCESS_FLAGS_THREAD;
     if (isKernelMode) {
@@ -50,14 +50,14 @@ INT os_thread_create (void (*startLocation)(), bool isKernelMode)
     return syscall (OSIF_SYSCALL_CREATE_PROCESS, (U32)startLocation, 0, (U32)flags, 0, 0);
 }
 
-bool os_process_is_yield_requested()
+bool cm_process_is_yield_requested()
 {
     volatile OSIF_ProcessEvent e = { 0 };
-    os_process_pop_event ((OSIF_ProcessEvent*)&e);
+    cm_process_pop_event ((OSIF_ProcessEvent*)&e);
     return (e.event == OSIF_PROCESS_EVENT_PROCCESS_YIELD_REQ);
 }
 
-UINT os_get_tick_period_us()
+UINT cm_get_tick_period_us()
 {
     return CONFIG_TICK_PERIOD_MICROSEC;
 }

Original file line number	Diff line number	Diff line change
`@@ -17,68 +17,68 @@`
`17`	`17`	`#endif`
`18`	`18`
`19`	`19`	`S32 syscall (OSIF_SYSCALLS fn, U32 arg1, U32 arg2, U32 arg3, U32 arg4, U32 arg5);`
`20`		`-INT os_thread_create (void (*startLocation)(), bool isKernelMode);`
`21`		`-INT os_process_create (void* startLocation, SIZE binaryLengthBytes, bool isKernelMode);`
`22`		`-UINT os_get_tick_period_us();`
`23`		`-bool os_process_is_yield_requested();`
`24`		`-bool os_process_is_child_exited (UINT* exitCode);`
	`20`	`+INT cm_thread_create (void (*startLocation)(), bool isKernelMode);`
	`21`	`+INT cm_process_create (void* startLocation, SIZE binaryLengthBytes, bool isKernelMode);`
	`22`	`+UINT cm_get_tick_period_us();`
	`23`	`+bool cm_process_is_yield_requested();`
	`24`	`+bool cm_process_is_child_exited (UINT* exitCode);`
`25`	`25`
`26`		`-static inline UINT os_tickcount_to_microsec(UINT tick)`
	`26`	`+static inline UINT cm_tickcount_to_microsec(UINT tick)`
`27`	`27`	`{`
`28`		`- return ((tick)*os_get_tick_period_us());`
	`28`	`+ return ((tick)*cm_get_tick_period_us());`
`29`	`29`	`}`
`30`	`30`
`31`		`-static inline void os_yield()`
	`31`	`+static inline void cm_process_yield()`
`32`	`32`	`{`
`33`	`33`	`syscall (OSIF_SYSCALL_YIELD_PROCESS, 0, 0, 0, 0, 0);`
`34`	`34`	`}`
`35`	`35`
`36`		`-static inline void os_process_kill(UINT code)`
	`36`	`+static inline void cm_process_kill(UINT code)`
`37`	`37`	`{`
`38`	`38`	`syscall (OSIF_SYSCALL_KILL_PROCESS, code, 0, 0, 0, 0);`
`39`	`39`	`}`
`40`	`40`
`41`		`-static inline void os_putstr (char* text)`
	`41`	`+static inline void cm_putstr (char* text)`
`42`	`42`	`{`
`43`	`43`	`syscall (OSIF_SYSCALL_CONSOLE_WRITELN, (PTR)text, 0, 0, 0, 0);`
`44`	`44`	`}`
`45`	`45`
`46`		`-static inline U32 os_process_get_pid()`
	`46`	`+static inline U32 cm_process_get_pid()`
`47`	`47`	`{`
`48`	`48`	`return (U32)syscall (OSIF_SYSCALL_PROCESS_GETPID, 0, 0, 0, 0, 0);`
`49`	`49`	`}`
`50`	`50`
`51`		`-static inline U32 os_get_tickcount()`
	`51`	`+static inline U32 cm_get_tickcount()`
`52`	`52`	`{`
`53`	`53`	`return (U32)syscall (OSIF_SYSCALL_TIMER_GET_TICKCOUNT, 0, 0, 0, 0, 0);`
`54`	`54`	`}`
`55`	`55`
`56`		`-static inline Handle os_window_create (const char* title)`
	`56`	`+static inline Handle cm_window_create (const char* title)`
`57`	`57`	`{`
`58`	`58`	`return (Handle)syscall (OSIF_SYSCALL_WINDOW_CREATE, (PTR)title, 0, 0, 0, 0);`
`59`	`59`	`}`
`60`	`60`
`61`		`-static inline U32 os_window_destory (Handle h)`
	`61`	`+static inline U32 cm_window_destory (Handle h)`
`62`	`62`	`{`
`63`	`63`	`return (U32)syscall (OSIF_SYSCALL_WINDOW_DESTORY, (U32)h, 0, 0, 0, 0);`
`64`	`64`	`}`
`65`	`65`
`66`		`-static inline void* os_process_get_datamem_start()`
	`66`	`+static inline void* cm_process_get_datamem_start()`
`67`	`67`	`{`
`68`	`68`	`return (void*)syscall (OSIF_SYSCALL_PROCESS_GET_DATAMEM_START, 0, 0, 0, 0, 0);`
`69`	`69`	`}`
`70`	`70`
`71`		`-static inline void* os_window_flush_graphics()`
	`71`	`+static inline void* cm_window_flush_graphics()`
`72`	`72`	`{`
`73`	`73`	`return (void*)syscall (OSIF_SYSCALL_WINDOW_FLUSH_GRAPHICS, 0, 0, 0, 0, 0);`
`74`	`74`	`}`
`75`	`75`
`76`		`-static inline bool os_window_getFB (Handle h, OSIF_WindowFrameBufferInfo* wfb)`
	`76`	`+static inline bool cm_window_getFB (Handle h, OSIF_WindowFrameBufferInfo* wfb)`
`77`	`77`	`{`
`78`	`78`	`return syscall (OSIF_SYSCALL_WINDOW_GET_WINDOW_FB, (U32)h, (PTR)wfb, 0, 0, 0);`
`79`	`79`	`}`
`80`	`80`
`81`		`-static inline bool os_process_pop_event (OSIF_ProcessEvent* e)`
	`81`	`+static inline bool cm_process_pop_event (OSIF_ProcessEvent* e)`
`82`	`82`	`{`
`83`	`83`	`return syscall (OSIF_SYSCALL_POP_PROCESS_EVENT, (PTR)e, 0, 0, 0, 0);`
`84`	`84`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,21 +2,22 @@`
`2`	`2`	`#include <types.h>`
`3`	`3`	`#include <cm.h>`
`4`	`4`	`#include <graphics.h>`
	`5`	`+#include <debug.h>`
`5`	`6`
`6`	`7`	`void thread0();`
`7`	`8`	`void thread1();`
`8`	`9`	`void thread2();`
`9`	`10`
`10`	`11`	`static OSIF_WindowFrameBufferInfo createWindow (const char* const title)`
`11`	`12`	`{`
`12`		`- Handle h = os_window_create (title);`
	`13`	`+ Handle h = cm_window_create (title);`
`13`	`14`	`if (h == INVALID_HANDLE) {`
`14`	`15`	`ERROR ("Window creation failed");`
`15`	`16`	`HALT();`
`16`	`17`	`}`
`17`	`18`
`18`	`19`	`OSIF_WindowFrameBufferInfo fbi;`
`19`		`- if (!os_window_getFB (h, &fbi)) {`
	`20`	`+ if (!cm_window_getFB (h, &fbi)) {`
`20`	`21`	`ERROR ("Window creation failed");`
`21`	`22`	`HALT();`
`22`	`23`	`}`
`@@ -26,14 +27,14 @@ static OSIF_WindowFrameBufferInfo createWindow (const char* const title)`
`26`	`27`
`27`	`28`	`void proc_main()`
`28`	`29`	`{`
`29`		`- os_window_flush_graphics();`
`30`		`- os_thread_create (&thread1, false);`
`31`		`- os_thread_create (&thread2, false);`
`32`		`- os_thread_create (&thread0, false);`
	`30`	`+ cm_window_flush_graphics();`
	`31`	`+ cm_thread_create (&thread1, false);`
	`32`	`+ cm_thread_create (&thread2, false);`
	`33`	`+ cm_thread_create (&thread0, false);`
`33`	`34`
`34`	`35`	`while (1) {`
`35`		`- if (os_process_is_yield_requested()) {`
`36`		`- os_yield();`
	`36`	`+ if (cm_process_is_yield_requested()) {`
	`37`	`+ cm_process_yield();`
`37`	`38`	`}`
`38`	`39`	`}`
`39`	`40`	`}`
`@@ -53,8 +54,8 @@ void thread0()`
`53`	`54`	`graphics_rect (&fbi, (UINT)x, 0, (UINT)width, fbi.height_px, color);`
`54`	`55`	`x += width + 3;`
`55`	`56`
`56`		`- os_window_flush_graphics();`
`57`		`- delay (500);`
	`57`	`+ cm_window_flush_graphics();`
	`58`	`+ cm_delay (500);`
`58`	`59`	`}`
`59`	`60`	`}`
`60`	`61`
`@@ -77,8 +78,8 @@ void thread1()`
`77`	`78`	`graphics_putpixel (&fbi, x, y, color);`
`78`	`79`	`}`
`79`	`80`	`}`
`80`		`- os_window_flush_graphics();`
`81`		`- delay (100);`
	`81`	`+ cm_window_flush_graphics();`
	`82`	`+ cm_delay (100);`
`82`	`83`	`}`
`83`	`84`	`}`
`84`	`85`
`@@ -101,7 +102,7 @@ void thread2()`
`101`	`102`	`graphics_putpixel (&fbi, x, y, color);`
`102`	`103`	`}`
`103`	`104`	`}`
`104`		`- os_window_flush_graphics();`
`105`		`- delay (80);`
	`105`	`+ cm_window_flush_graphics();`
	`106`	`+ cm_delay (80);`
`106`	`107`	`}`
`107`	`108`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,16 +7,17 @@`
`7`	`7`	`#include <types.h>`
`8`	`8`	`#include <cm/cm.h>`
`9`	`9`	`#include <cm/syscall.h>`
	`10`	`+#include <cm/debug.h>`
`10`	`11`
`11`		`-#define OS_MICRODEC_TO_TICK_COUNT(us) ((us) / os_get_tick_period_us())`
	`12`	`+#define cm_MICRODEC_TO_TICK_COUNT(us) ((us) / cm_get_tick_period_us())`
`12`	`13`
`13`	`14`	`void event_handler_NDU_()`
`14`	`15`	`{`
`15`	`16`	`volatile OSIF_ProcessEvent e = { 0 };`
`16`		`- os_process_pop_event ((OSIF_ProcessEvent*)&e);`
	`17`	`+ cm_process_pop_event ((OSIF_ProcessEvent*)&e);`
`17`	`18`	`switch (e.event) {`
`18`	`19`	`case OSIF_PROCESS_EVENT_PROCCESS_YIELD_REQ:`
`19`		`- os_yield();`
	`20`	`+ cm_process_yield();`
`20`	`21`	`break;`
`21`	`22`	`case OSIF_PROCESS_EVENT_PROCCESS_CHILD_KILLED:`
`22`	`23`	`INFO ("Child exitted with code: %x", e.data);`
`@@ -26,14 +27,14 @@ void event_handler_NDU_()`
`26`	`27`	`}`
`27`	`28`	`}`
`28`	`29`
`29`		`-void delay (UINT ms)`
	`30`	`+void cm_delay (UINT ms)`
`30`	`31`	`{`
`31`	`32`	`UINT us = ms * 1000;`
`32`	`33`
`33`		`- U32 start_tick = os_get_tickcount();`
`34`		`- U32 end_tick = start_tick + OS_MICRODEC_TO_TICK_COUNT (us);`
	`34`	`+ U32 start_tick = cm_get_tickcount();`
	`35`	`+ U32 end_tick = start_tick + cm_MICRODEC_TO_TICK_COUNT (us);`
`35`	`36`
`36`		`- while (os_get_tickcount() < end_tick) {`
	`37`	`+ while (cm_get_tickcount() < end_tick) {`
`37`	`38`	`event_handler_NDU_();`
`38`	`39`	`}`
`39`	`40`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ S32 syscall (OSIF_SYSCALLS fn, U32 arg1, U32 arg2, U32 arg3, U32 arg4, U32 arg5)`
`30`	`30`	`return retval;`
`31`	`31`	`}`
`32`	`32`
`33`		`-INT os_process_create (void* startLocation, SIZE binaryLengthBytes, bool isKernelMode)`
	`33`	`+INT cm_process_create (void* startLocation, SIZE binaryLengthBytes, bool isKernelMode)`
`34`	`34`	`{`
`35`	`35`	`KProcessFlags flags = PROCESS_FLAGS_NONE;`
`36`	`36`	`if (isKernelMode) {`
`@@ -41,7 +41,7 @@ INT os_process_create (void* startLocation, SIZE binaryLengthBytes, bool isKerne`
`41`	`41`	`0, 0);`
`42`	`42`	`}`
`43`	`43`
`44`		`-INT os_thread_create (void (*startLocation)(), bool isKernelMode)`
	`44`	`+INT cm_thread_create (void (*startLocation)(), bool isKernelMode)`
`45`	`45`	`{`
`46`	`46`	`KProcessFlags flags = PROCESS_FLAGS_THREAD;`
`47`	`47`	`if (isKernelMode) {`
`@@ -50,14 +50,14 @@ INT os_thread_create (void (*startLocation)(), bool isKernelMode)`
`50`	`50`	`return syscall (OSIF_SYSCALL_CREATE_PROCESS, (U32)startLocation, 0, (U32)flags, 0, 0);`
`51`	`51`	`}`
`52`	`52`
`53`		`-bool os_process_is_yield_requested()`
	`53`	`+bool cm_process_is_yield_requested()`
`54`	`54`	`{`
`55`	`55`	`volatile OSIF_ProcessEvent e = { 0 };`
`56`		`- os_process_pop_event ((OSIF_ProcessEvent*)&e);`
	`56`	`+ cm_process_pop_event ((OSIF_ProcessEvent*)&e);`
`57`	`57`	`return (e.event == OSIF_PROCESS_EVENT_PROCCESS_YIELD_REQ);`
`58`	`58`	`}`
`59`	`59`
`60`		`-UINT os_get_tick_period_us()`
	`60`	`+UINT cm_get_tick_period_us()`
`61`	`61`	`{`
`62`	`62`	`return CONFIG_TICK_PERIOD_MICROSEC;`
`63`	`63`	`}`