Use string.h functions where applicable + some cleanup (#26)

* Use string.h functions in cpio.c

* Use string.h functions in vfs.c

* Use isprint in classic.c

* Use string.h in console.c + some minor readability improvements

* Use kmemcpy in memmgt.c

* Deprecate walk_pagetable

Author: ryuukumar

kernel/src/kernel/console.c

@@ -1,3 +1,4 @@
+#include <kclib/ctype.h>
 #include <kclib/string.h>
 #include <kernel/console.h>
 #include <kernel/graphics.h>
@@ -78,8 +79,7 @@ void init_console (size_t x_screen, size_t y_screen, size_t x_pad, size_t y_pad,
 
 	fs = font_size;
 
-	for (size_t i = 0; i < xc * yc; i++)
-		buffer[i] = 32;
+	kmemset (buffer, 32, xc * yc);
 }
 
 /*!
@@ -93,11 +93,11 @@ void set_color (uint32_t c) { color = c; }
 Update the display.
 */
 void update () {
-	for (size_t i = 0; i < yc; i++) {
-		for (size_t j = 0; j < xc; j++) {
-			renderGlyph (glyph (buffer[i * xc + j]), 8, 5, xs + (fs * j * (5 + xsp)),
-						 ys + (fs * i * (8 + ysp)), fs, colorbuffer[i * xc + j]);
-		}
+	for (size_t pos = 0; pos < xc * yc; pos++) {
+		size_t i = pos / xc;
+		size_t j = pos % xc;
+		renderGlyph (glyph (buffer[pos]), 8, 5, xs + (fs * j * (5 + xsp)),
+					 ys + (fs * i * (8 + ysp)), fs, colorbuffer[pos]);
 	}
 }
 
@@ -120,9 +120,8 @@ Print a single character to the screen.
 void putchar (unsigned char rc) {
 	switch (rc) {
 	case '\n':
-		idx = xc * ((idx / xc) + 1);
-		while (idx >= CONSOLE_HEIGHT * CONSOLE_WIDTH)
-			idx -= CONSOLE_HEIGHT * CONSOLE_WIDTH;
+		idx = ((idx / xc) + 1) * xc;
+		if (idx >= xc * yc) idx -= xc * yc;
 		return;
 	}
 	registerChar (rc, idx);

kernel/src/kernel/fs/cpio.c

@@ -1,3 +1,4 @@
+#include <kclib/ctype.h>
 #include <kclib/stdio.h>
 #include <kclib/string.h>
 #include <kernel/error.h>
@@ -13,16 +14,13 @@
 static uint64_t hex_to_u64 (const char hex[8]) [[unsequenced]] {
 	uint64_t val = 0;
 	for (int i = 0; i < 8; i++) {
-		char	c = hex[i];
-		uint8_t digit;
-		if (c >= '0' && c <= '9')
+		unsigned char c = (unsigned char)hex[i];
+		uint8_t		  digit;
+		if (!isxdigit (c)) break;
+		if (isdigit (c))
 			digit = c - '0';
-		else if (c >= 'A' && c <= 'F')
-			digit = c - 'A' + 10;
-		else if (c >= 'a' && c <= 'f')
-			digit = c - 'a' + 10;
 		else
-			break;
+			digit = tolower (c) - 'a' + 10;
 		val = (val << 4) | digit;
 	}
 	return val;
@@ -75,13 +73,7 @@ static int mkdir_if_required (const char* dir, inode* root) {
 	if (error == -EPNOEXIST) {
 		child_name = nullptr;
 
-		char* last_slash = nullptr;
-		for (int i = len - 1; i >= 0; i--) {
-			if (path[i] == '/') {
-				last_slash = &path[i];
-				break;
-			}
-		}
+		char* last_slash = kstrrchr (path, '/');
 
 		if (last_slash && last_slash != path) {
 			*last_slash = '\0';
@@ -134,17 +126,14 @@ static int parse_entry_to_inode (cpio_newc_header_t* header, const char* out_pat
 		}
 	}
 	if (filetype == C_ISREG) {
-		char* trailing_slashes = &filename[namesize - 1];
-		while ((uintptr_t)trailing_slashes > (uintptr_t)filename && *trailing_slashes == '/')
-			trailing_slashes--;
-		trailing_slashes[1] = 0;
-
-		char* last_slash = trailing_slashes;
-		while ((uintptr_t)last_slash > (uintptr_t)filename && *last_slash != '/')
-			last_slash--;
+		size_t flen = kstrlen (filename);
+		while (flen > 1 && filename[flen - 1] == '/')
+			flen--;
+		filename[flen] = '\0';
 
-		if (last_slash != filename) { // i.e. there is a prefix
-			*last_slash = 0;
+		char* last_slash = kstrrchr (filename, '/');
+		if (last_slash && last_slash != filename) {
+			*last_slash = '\0';
 			mkdir_if_required (filename, root_dir);
 			*last_slash = '/';
 		}

kernel/src/kernel/fs/vfs.c

@@ -1,3 +1,4 @@
+#include <kclib/ctype.h>
 #include <kclib/string.h>
 #include <kernel/error.h>
 #include <kernel/fs/vfs.h>
@@ -9,7 +10,8 @@ inode* vfs_absolute_root = nullptr;
 
 static bool filename_has_invalid_chars (char* filename) {
 	while (*filename != 0) {
-		if (*filename == '/' || *filename < (char)32) return true;
+		unsigned char c = (unsigned char)*filename;
+		if (c == '/' || !isprint (c)) return true;
 		filename++;
 	}
 	return false;
@@ -28,12 +30,10 @@ int vfs_resolve_parent (const char* path_arg, inode* root, inode** r_parent, cha
 	char* path = kstrdup (path_arg);
 	if (!path) return -ENOMEM;
 
-	char* last_slash = nullptr;
-	for (int i = kstrlen (path) - 1; i >= 0; i--) {
-		if (path[i] == '/') {
-			last_slash = &path[i];
-			break;
-		}
+	char* last_slash = kstrrchr (path, '/');
+	if (!last_slash) {
+		kfree (path);
+		return -EINVARG;
 	}
 
 	*r_name = kstrdup (last_slash + 1);
@@ -184,9 +184,8 @@ int do_lookup (char* filename, inode** result, inode* root) {
 	}
 
 	// get the target_name
-	char* target_name = (char*)kmalloc ((size_t)(next_slash - filename));
-	kmemcpy ((void*)target_name, (void*)(filename + 1), (size_t)(next_slash - filename) - 1);
-	target_name[(size_t)(next_slash - filename) - 1] = 0;
+	size_t comp_len = (size_t)(next_slash - filename) - 1;
+	char*  target_name = kstrndup (filename + 1, comp_len);
 
 	if (kstrcmp (target_name, ".") == 0) {
 		kfree (target_name);

kernel/src/kernel/hardfonts/classic.c

@@ -1,3 +1,4 @@
+#include <kclib/ctype.h>
 #include <kernel/hardfonts/classic.h>
 #include <stddef.h>
 #include <stdint.h>
@@ -782,6 +783,6 @@ Return the glyph for a certain character from the classic font
 @return	pointer to 5x8 glyph
 */
 unsigned char* glyph (char index) {
-	if (index < 32) return &__classic_font__[0][0][0];
+	if (!isprint (index)) return &__classic_font__[0][0][0];
 	return &__classic_font__[index - 32][0][0];
 }

kernel/src/kernel/memmgt.c

@@ -644,46 +644,6 @@ void init_memmgt (uint64_t p_hhdm_offset, struct limine_memmap_response* memmap_
  */
 uintptr_t get_kernel_cr3 (void) { return kernel_cr3; }
 
-/*!
- * Walks the page table hierarchy and prints present entries and their address ranges.
- * @deprecated
- */
-void walk_pagetable () {
-	pml4t_entry_t* pml4t_entry = &pml4_base_ptr[1];
-	if (!pml4t_entry->present) return;
-
-	pdpt_entry_t* pdpt_base_ptr =
-		(pdpt_entry_t*)get_vaddr_from_frame (pml4t_entry->pdpt_base_address);
-	pdpt_entry_t* pdpt_entry = &pdpt_base_ptr[0];
-	if (!pdpt_entry->present) return;
-
-	pd_entry_t* pd_base_ptr = (pd_entry_t*)get_vaddr_from_frame (pdpt_entry->pd_base_address);
-	for (int k = 0; k < 512; k++) {
-		pd_entry_t* pd_entry = &pd_base_ptr[k];
-		if (!pd_entry->present) continue;
-		kprintf ("PD %d: PT Base Address:   0x%lx\n", k, pd_entry->pt_base_address << 12);
-		pt_entry_t* pt_base_ptr = (pt_entry_t*)get_vaddr_from_frame (pd_entry->pt_base_address);
-
-		bool is_present_pt[512] = {false};
-		for (int k = 0; k < 512; k++)
-			is_present_pt[k] = (&pt_base_ptr[k])->present;
-
-		// print ranges of present pd's
-		int range_start = -1;
-		for (int k = 0; k <= 512; k++) {
-			if (k < 512 && is_present_pt[k]) {
-				if (range_start == -1) range_start = k;
-			} else if (range_start != -1) {
-				if (range_start == k - 1)
-					kprintf ("  Present PT: %d\n", range_start);
-				else
-					kprintf ("  Present PTs: %d-%d\n", range_start, k - 1);
-				range_start = -1;
-			}
-		}
-	}
-}
-
 /*!
  * Finds the physical address mapped to a given virtual address.
  * @param vaddr The virtual address to look up.
@@ -753,8 +713,7 @@ int clone_user_memory (uint64_t cr3_src, uint64_t* cr3_dest) {
 
 	// map the higher half to be exactly the same as kernel's
 	pml4t_entry_t* krnl_pml4_table = (pml4t_entry_t*)((uint64_t)get_kernel_cr3 () + hhdm_offset);
-	for (int i = 256; i < 512; i++)
-		dest_pml4_table[i] = krnl_pml4_table[i];
+	kmemcpy (&dest_pml4_table[256], &krnl_pml4_table[256], 256 * sizeof (pml4t_entry_t));
 
 	// deep clone the lower half (user space)
 	for (uint16_t pml4_index = 0; pml4_index < 256; pml4_index++) {