lib.c

/* lib.c - Some basic library functions (printf, strlen, etc.)
 * vim:ts=4 noexpandtab
 */

#include "lib.h"
#define VIDEO 0xB8000
#define NUM_COLS 80
#define NUM_ROWS 25
#define ATTRIB 0x7
#define GREEN_BK 0x4C
#define GREEN_FG 0x4C
#define CANA_BK	62
#define CANA_FG 62
#define RED_BK	116//12, 116
#define RED_FG	116
#define DEFA_BK 7
#define DEFA_FG 7
#define LOW_CURS 0x0F
#define HIGH_CURS 0x0E
#define VGA_INDX1 0x3D4
#define VGA_INDX2 0x3D5

static int screen_x_arr[3];
static int screen_y_arr[3];
//static int screen_x_arr[id] = 0;
//static int screen_y_arr[id] = 0;
static char* video_mem = (char *)VIDEO;
static int screen_loc = 0;

static uint32_t color_bkgrd = DEFA_BK;
static uint32_t color_cursor = DEFA_FG;

/*
* void set_term_color(int setting);
*   Inputs: color setting
*   Return Value: none
*	Function: change terminal colors
*/
void set_term_color(int setting)
{
	if(setting < 0 || setting > 3)
		return;
	if(setting == 0)
	{
		color_bkgrd = DEFA_BK;
		color_cursor = DEFA_FG;
	}
	if(setting == 1)
	{
		color_bkgrd = GREEN_BK;
		color_cursor = GREEN_FG;
	}
	if(setting == 2)
	{
		color_bkgrd = CANA_BK;
		color_cursor = CANA_FG;
	}
	if(setting == 3)
	{
		color_bkgrd = RED_BK;
		color_cursor = RED_FG;
	}
}

/*
* int get_Hen_row(void);
*   Inputs: row to set to 
*   Return Value: none
*	Function: set the row
*/
void set_screen_row(int y)
{
	screen_y_arr[id] = y;
}

/*
* int get_screen_row(void);
*   Inputs: col to set to
*   Return Value: none
*	Function: set the col
*/
void set_screen_col(int x)
{
	screen_x_arr[id] = x;
}

/*
* int get_screen_row(void);
*   Inputs: void
*   Return Value: current screen row
*	Function: return the current row the screen is on
*/
int get_screen_row(void)
{
	return screen_y_arr[id];
}

/*
* int get_screen_col(void);
*   Inputs: void
*   Return Value: current screen col
*	Function: return the current col the screen is on
*/
int get_screen_col(void)
{
	return screen_x_arr[id];
}

/*
* void overlap(void);
*   Inputs: void
*   Return Value: none
*	Function: Clears current line and line above then updates cursor position
*/
void overlap(void)
{
	reset_cursor(1);
	screen_y_arr[id] -= 1;
	reset_cursor(1);
	update_cursor(screen_y_arr[id], screen_x_arr[id]);
}

/*
* void inc_screen_row(void);
*   Inputs: void
*   Return Value: none
*	Function: Increment the screen row index and reset the column index.
*/
void inc_screen_row(void)
{
	screen_y_arr[id] += 1;
	//screen_x_arr[id] = 0;
}

/*
* void inc_screen_row(void);
*   Inputs: void
*   Return Value: none
*	Function: Decrement the screen row index and reset the column index.
*/
void dec_screen_row(void)
{
	screen_y_arr[id] -= 1;
	//screen_x_arr[id] = 0;
}

/*
* void update_cursor(int row, int col);
*   Inputs: row and column indexes to place the cursor at
*   Return Value: none
*	Function: Moves the cursor to the given screen location
*/
void update_cursor(int row, int col)
 {

    unsigned short position=(row*NUM_COLS) + col;
    // cursor LOW port to vga INDEX register
    outb(LOW_CURS, VGA_INDX1);
    outb((unsigned char)(position&0xFF), VGA_INDX2);
    // cursor HIGH port to vga INDEX register
    outb(HIGH_CURS, VGA_INDX1);
    outb((unsigned char )((position>>8)&0xFF), VGA_INDX2);
    /*
    int i;
	screen_loc = screen_y_arr[id];
	int save_x = screen_x_arr[id];
	for(i = (NUM_COLS*row) + col; i < ((row*NUM_COLS)+col)+1; i++){
		*(uint8_t *)(video_mem + (i << 1)) = '\0';
		// *(uint8_t *)(video_mem + (i << 1) + 1) = GREEN;
	}
	// *(uint8_t *)(video_mem + (i << 1) + 1) = color_cursor;
	screen_y_arr[id] = screen_loc;
	screen_x_arr[id] = save_x;
	*/
 }
 
/*
* void update_screen();
*   Inputs: void
*   Return Value: none
*	Function: Shift the screen contents up by one
*/
void update_screen()
{
	int i;
	for(i = 0; i < (NUM_ROWS-1)*NUM_COLS; i++)
	{
		*(uint8_t *)(video_mem + (i << 1)) = *(uint8_t *)(video_mem + ((i+NUM_COLS) << 1));
		*(uint8_t *)(video_mem + (i << 1) + 1) = color_bkgrd;
	}
	for(i = (NUM_ROWS-1)*NUM_COLS; i < NUM_ROWS*NUM_COLS; i++)
	{
		*(uint8_t *)(video_mem + (i << 1)) = ' ';
		*(uint8_t *)(video_mem + (i << 1) + 1) = color_bkgrd;
	}
	//*(uint8_t *)(video_mem + (i << 1) + 1) = color_cursor;
	screen_y_arr[id] = NUM_ROWS-1;
	screen_x_arr[id] = 0;
}

/*
* void clear_line(void);
*   Inputs: void
*   Return Value: none
*	Function: Clears current line in video memory
*/
void clear_line(void)
{
	int i;
	screen_loc = screen_y_arr[id];
	for(i = NUM_COLS*screen_y_arr[id]; i < (screen_y_arr[id]+1)*NUM_COLS; i++){
		*(uint8_t *)(video_mem + (i << 1)) = ' ';
		*(uint8_t *)(video_mem + (i << 1) + 1) = color_bkgrd;
	}
	//*(uint8_t *)(video_mem + (i << 1) + 1) = color_cursor;
	screen_y_arr[id] = screen_loc;
	screen_x_arr[id] = 0;
}


/*
* void clear_spot(void);
*   Inputs: void
*   Return Value: x, y
*	Function: Clears current line in video memory
*/
void clear_spot(int col, int row, int num)
{
	int i;
	screen_loc = screen_y_arr[id];
	int save_x = screen_x_arr[id];
	for(i = (NUM_COLS*row) + col; i < ((row*NUM_COLS)+col)+num; i++){
		*(uint8_t *)(video_mem + (i << 1)) = ' ';
		*(uint8_t *)(video_mem + (i << 1) + 1) = color_bkgrd;
	}
	//*(uint8_t *)(video_mem + (i << 1) + 1) = color_cursor;
	screen_y_arr[id] = screen_loc;
	screen_x_arr[id] = save_x;
}

/*
* void reset_cursor(int setting);
*   Inputs: setting to use
*   Return Value: none
*	Function: Clears appropriate screen locations and resets rows/columns
*/
void reset_cursor(int setting)
{
	if(setting == 0)
	{
		clear();
		screen_x_arr[id] = 0;
		screen_y_arr[id] = 0;
	}
	else if(setting == 1)
	{
		screen_x_arr[id] = 0;
		clear_line();
	}
	else if(setting == 2)
		screen_y_arr[id] = 0;
}

/*
* void clear(void);
*   Inputs: void
*   Return Value: none
*	Function: Clears video memory
*/
void
clear(void)
{
    int32_t i;
    for(i=0; i<NUM_ROWS*NUM_COLS; i++) {
        *(uint8_t *)(video_mem + (i << 1)) = ' ';
        *(uint8_t *)(video_mem + (i << 1) + 1) = color_cursor;
    }
    //*(uint8_t *)(video_mem + (i << 1) + 1) = color_cursor;
}

/* Standard printf().
 * Only supports the following format strings:
 * %%  - print a literal '%' character
 * %x  - print a number in hexadecimal
 * %u  - print a number as an unsigned integer
 * %d  - print a number as a signed integer
 * %c  - print a character
 * %s  - print a string
 * %#x - print a number in 32-bit aligned hexadecimal, i.e.
 *       print 8 hexadecimal digits, zero-padded on the left.
 *       For example, the hex number "E" would be printed as
 *       "0000000E".
 *       Note: This is slightly different than the libc specification
 *       for the "#" modifier (this implementation doesn't add a "0x" at
 *       the beginning), but I think it's more flexible this way.
 *       Also note: %x is the only conversion specifier that can use
 *       the "#" modifier to alter output.
 * */
int32_t
printf(int8_t *format, ...)
{
	/* Pointer to the format string */
	int8_t* buf = format;

	/* Stack pointer for the other parameters */
	int32_t* esp = (void *)&format;
	esp++;

	while(*buf != '\0') {
		switch(*buf) {
			case '%':
				{
					int32_t alternate = 0;
					buf++;

format_char_switch:
					/* Conversion specifiers */
					switch(*buf) {
						/* Print a literal '%' character */
						case '%':
							putc('%');
							break;

						/* Use alternate formatting */
						case '#':
							alternate = 1;
							buf++;
							/* Yes, I know gotos are bad.  This is the
							 * most elegant and general way to do this,
							 * IMHO. */
							goto format_char_switch;

						/* Print a number in hexadecimal form */
						case 'x':
							{
								int8_t conv_buf[64];
								if(alternate == 0) {
									itoa(*((uint32_t *)esp), conv_buf, 16);
									puts(conv_buf);
								} else {
									int32_t starting_index;
									int32_t i;
									itoa(*((uint32_t *)esp), &conv_buf[8], 16);
									i = starting_index = strlen(&conv_buf[8]);
									while(i < 8) {
										conv_buf[i] = '0';
										i++;
									}
									puts(&conv_buf[starting_index]);
								}
								esp++;
							}
							break;

						/* Print a number in unsigned int form */
						case 'u':
							{
								int8_t conv_buf[36];
								itoa(*((uint32_t *)esp), conv_buf, 10);
								puts(conv_buf);
								esp++;
							}
							break;

						/* Print a number in signed int form */
						case 'd':
							{
								int8_t conv_buf[36];
								int32_t value = *((int32_t *)esp);
								if(value < 0) {
									conv_buf[0] = '-';
									itoa(-value, &conv_buf[1], 10);
								} else {
									itoa(value, conv_buf, 10);
								}
								puts(conv_buf);
								esp++;
							}
							break;

						/* Print a single character */
						case 'c':
							putc( (uint8_t) *((int32_t *)esp) );
							esp++;
							break;

						/* Print a NULL-terminated string */
						case 's':
							puts( *((int8_t **)esp) );
							esp++;
							break;

						default:
							break;
					}

				}
				break;

			default:
				putc(*buf);
				break;
		}
		buf++;
	}

	return (buf - format);
}

/*
* int32_t puts(int8_t* s);
*   Inputs: int_8* s = pointer to a string of characters
*   Return Value: Number of bytes written
*	Function: Output a string to the console 
*/

int32_t
puts(int8_t* s)
{
	register int32_t index = 0;
	while(s[index] != '\0') {
		putc(s[index]);
		index++;
	}

	return index;
}

/*
* void putc(uint8_t c);
*   Inputs: uint_8* c = character to print
*   Return Value: void
*	Function: Output a character to the console 
*/

void
putc(uint8_t c)
{
	if(c == '\0')
		return;
    if(c == '\n' || c == '\r') {
        screen_y_arr[id]++;
        screen_x_arr[id]=0;
    } else {
    	*(uint8_t *)(video_mem + ((NUM_COLS*screen_y_arr[id] + screen_x_arr[id]) << 1)) = color_bkgrd;
        *(uint8_t *)(video_mem + ((NUM_COLS*screen_y_arr[id] + screen_x_arr[id]) << 1)) = c;
        *(uint8_t *)(video_mem + ((NUM_COLS*screen_y_arr[id] + screen_x_arr[id]) << 1) + 1) = color_bkgrd;
        screen_x_arr[id]++;
        screen_x_arr[id] %= NUM_COLS;
        screen_y_arr[id] = (screen_y_arr[id] + (screen_x_arr[id] / NUM_COLS)) % NUM_ROWS;
    }
}

/*
* int8_t* itoa(uint32_t value, int8_t* buf, int32_t radix);
*   Inputs: uint32_t value = number to convert
*			int8_t* buf = allocated buffer to place string in
*			int32_t radix = base system. hex, oct, dec, etc.
*   Return Value: number of bytes written
*	Function: Convert a number to its ASCII representation, with base "radix"
*/

int8_t*
itoa(uint32_t value, int8_t* buf, int32_t radix)
{
	static int8_t lookup[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";

	int8_t *newbuf = buf;
	int32_t i;
	uint32_t newval = value;

	/* Special case for zero */
	if(value == 0) {
		buf[0]='0';
		buf[1]='\0';
		return buf;
	}

	/* Go through the number one place value at a time, and add the
	 * correct digit to "newbuf".  We actually add characters to the
	 * ASCII string from lowest place value to highest, which is the
	 * opposite of how the number should be printed.  We'll reverse the
	 * characters later. */
	while(newval > 0) {
		i = newval % radix;
		*newbuf = lookup[i];
		newbuf++;
		newval /= radix;
	}

	/* Add a terminating NULL */
	*newbuf = '\0';

	/* Reverse the string and return */
	return strrev(buf);
}

/*
* int8_t* strrev(int8_t* s);
*   Inputs: int8_t* s = string to reverse
*   Return Value: reversed string
*	Function: reverses a string s
*/

int8_t*
strrev(int8_t* s)
{
	register int8_t tmp;
	register int32_t beg=0;
	register int32_t end=strlen(s) - 1;

	while(beg < end) {
		tmp = s[end];
		s[end] = s[beg];
		s[beg] = tmp;
		beg++;
		end--;
	}

	return s;
}

/*
* uint32_t strlen(const int8_t* s);
*   Inputs: const int8_t* s = string to take length of
*   Return Value: length of string s
*	Function: return length of string s
*/

uint32_t
strlen(const int8_t* s)
{
	register uint32_t len = 0;
	while(s[len] != '\0')
		len++;

	return len;
}

/*
* void* memset(void* s, int32_t c, uint32_t n);
*   Inputs: void* s = pointer to memory
*			int32_t c = value to set memory to
*			uint32_t n = number of bytes to set
*   Return Value: new string
*	Function: set n consecutive bytes of pointer s to value c
*/

void*
memset(void* s, int32_t c, uint32_t n)
{
	c &= 0xFF;
	asm volatile("                  \n\
			.memset_top:            \n\
			testl   %%ecx, %%ecx    \n\
			jz      .memset_done    \n\
			testl   $0x3, %%edi     \n\
			jz      .memset_aligned \n\
			movb    %%al, (%%edi)   \n\
			addl    $1, %%edi       \n\
			subl    $1, %%ecx       \n\
			jmp     .memset_top     \n\
			.memset_aligned:        \n\
			movw    %%ds, %%dx      \n\
			movw    %%dx, %%es      \n\
			movl    %%ecx, %%edx    \n\
			shrl    $2, %%ecx       \n\
			andl    $0x3, %%edx     \n\
			cld                     \n\
			rep     stosl           \n\
			.memset_bottom:         \n\
			testl   %%edx, %%edx    \n\
			jz      .memset_done    \n\
			movb    %%al, (%%edi)   \n\
			addl    $1, %%edi       \n\
			subl    $1, %%edx       \n\
			jmp     .memset_bottom  \n\
			.memset_done:           \n\
			"
			:
			: "a"(c << 24 | c << 16 | c << 8 | c), "D"(s), "c"(n)
			: "edx", "memory", "cc"
			);

	return s;
}

/*
* void* memset_word(void* s, int32_t c, uint32_t n);
*   Inputs: void* s = pointer to memory
*			int32_t c = value to set memory to
*			uint32_t n = number of bytes to set
*   Return Value: new string
*	Function: set lower 16 bits of n consecutive memory locations of pointer s to value c
*/

/* Optimized memset_word */
void*
memset_word(void* s, int32_t c, uint32_t n)
{
	asm volatile("                  \n\
			movw    %%ds, %%dx      \n\
			movw    %%dx, %%es      \n\
			cld                     \n\
			rep     stosw           \n\
			"
			:
			: "a"(c), "D"(s), "c"(n)
			: "edx", "memory", "cc"
			);

	return s;
}

/*
* void* memset_dword(void* s, int32_t c, uint32_t n);
*   Inputs: void* s = pointer to memory
*			int32_t c = value to set memory to
*			uint32_t n = number of bytes to set
*   Return Value: new string
*	Function: set n consecutive memory locations of pointer s to value c
*/

void*
memset_dword(void* s, int32_t c, uint32_t n)
{
	asm volatile("                  \n\
			movw    %%ds, %%dx      \n\
			movw    %%dx, %%es      \n\
			cld                     \n\
			rep     stosl           \n\
			"
			:
			: "a"(c), "D"(s), "c"(n)
			: "edx", "memory", "cc"
			);

	return s;
}

/*
* void* memcpy(void* dest, const void* src, uint32_t n);
*   Inputs: void* dest = destination of copy
*			const void* src = source of copy
*			uint32_t n = number of byets to copy
*   Return Value: pointer to dest
*	Function: copy n bytes of src to dest
*/

void*
memcpy(void* dest, const void* src, uint32_t n)
{
	asm volatile("                  \n\
			.memcpy_top:            \n\
			testl   %%ecx, %%ecx    \n\
			jz      .memcpy_done    \n\
			testl   $0x3, %%edi     \n\
			jz      .memcpy_aligned \n\
			movb    (%%esi), %%al   \n\
			movb    %%al, (%%edi)   \n\
			addl    $1, %%edi       \n\
			addl    $1, %%esi       \n\
			subl    $1, %%ecx       \n\
			jmp     .memcpy_top     \n\
			.memcpy_aligned:        \n\
			movw    %%ds, %%dx      \n\
			movw    %%dx, %%es      \n\
			movl    %%ecx, %%edx    \n\
			shrl    $2, %%ecx       \n\
			andl    $0x3, %%edx     \n\
			cld                     \n\
			rep     movsl           \n\
			.memcpy_bottom:         \n\
			testl   %%edx, %%edx    \n\
			jz      .memcpy_done    \n\
			movb    (%%esi), %%al   \n\
			movb    %%al, (%%edi)   \n\
			addl    $1, %%edi       \n\
			addl    $1, %%esi       \n\
			subl    $1, %%edx       \n\
			jmp     .memcpy_bottom  \n\
			.memcpy_done:           \n\
			"
			:
			: "S"(src), "D"(dest), "c"(n)
			: "eax", "edx", "memory", "cc"
			);

	return dest;
}

/*
* void* memmove(void* dest, const void* src, uint32_t n);
*   Inputs: void* dest = destination of move
*			const void* src = source of move
*			uint32_t n = number of byets to move
*   Return Value: pointer to dest
*	Function: move n bytes of src to dest
*/

/* Optimized memmove (used for overlapping memory areas) */
void*
memmove(void* dest, const void* src, uint32_t n)
{
	asm volatile("                  \n\
			movw    %%ds, %%dx      \n\
			movw    %%dx, %%es      \n\
			cld                     \n\
			cmp     %%edi, %%esi    \n\
			jae     .memmove_go     \n\
			leal    -1(%%esi, %%ecx), %%esi    \n\
			leal    -1(%%edi, %%ecx), %%edi    \n\
			std                     \n\
			.memmove_go:            \n\
			rep     movsb           \n\
			"
			:
			: "D"(dest), "S"(src), "c"(n)
			: "edx", "memory", "cc"
			);

	return dest;
}

/*
* int32_t strncmp(const int8_t* s1, const int8_t* s2, uint32_t n)
*   Inputs: const int8_t* s1 = first string to compare
*			const int8_t* s2 = second string to compare
*			uint32_t n = number of bytes to compare
*	Return Value: A zero value indicates that the characters compared 
*					in both strings form the same string.
*				A value greater than zero indicates that the first 
*					character that does not match has a greater value 
*					in str1 than in str2; And a value less than zero 
*					indicates the opposite.
*	Function: compares string 1 and string 2 for equality
*/

int32_t
strncmp(const int8_t* s1, const int8_t* s2, uint32_t n)
{
	int32_t i;
	for(i=0; i<n; i++) {
		if( (s1[i] != s2[i]) ||
				(s1[i] == '\0') /* || s2[i] == '\0' */ ) {

			/* The s2[i] == '\0' is unnecessary because of the short-circuit
			 * semantics of 'if' expressions in C.  If the first expression
			 * (s1[i] != s2[i]) evaluates to false, that is, if s1[i] ==
			 * s2[i], then we only need to test either s1[i] or s2[i] for
			 * '\0', since we know they are equal. */

			return s1[i] - s2[i];
		}
	}
	return 0;
}

/*
* int8_t* strcpy(int8_t* dest, const int8_t* src)
*   Inputs: int8_t* dest = destination string of copy
*			const int8_t* src = source string of copy
*   Return Value: pointer to dest
*	Function: copy the source string into the destination string
*/

int8_t*
strcpy(int8_t* dest, const int8_t* src)
{
	int32_t i=0;
	while(src[i] != '\0') {
		dest[i] = src[i];
		i++;
	}

	dest[i] = '\0';
	return dest;
}

/*
* int8_t* strcpy(int8_t* dest, const int8_t* src, uint32_t n)
*   Inputs: int8_t* dest = destination string of copy
*			const int8_t* src = source string of copy
*			uint32_t n = number of bytes to copy
*   Return Value: pointer to dest
*	Function: copy n bytes of the source string into the destination string
*/

int8_t*
strncpy(int8_t* dest, const int8_t* src, uint32_t n)
{
	int32_t i=0;
	while(src[i] != '\0' && i < n) {
		dest[i] = src[i];
		i++;
	}

	while(i < n) {
		dest[i] = '\0';
		i++;
	}

	return dest;
}

/*
* void test_interrupts(void)
*   Inputs: void
*   Return Value: void
*	Function: increments video memory. To be used to test rtc
*/

void
test_interrupts(void)
{
	int32_t i;
	for (i=0; i < NUM_ROWS*NUM_COLS; i++) {
		video_mem[i<<1]++;
	}
}

/*
*
*Inputs: string
*Return Value: length of string
*/

int32_t strlen_mine(char *str)
{
	int32_t count = 0;
	if (*str != '\0')
		count++;
	return count;
}
/*
 *----------------------------------------------------------------------
 *
 * strstr --
 *
 *	Locate the first instance of a substring in a string.
 *
 * Results:
 *	If string contains substring, the return value is the
 *	location of the first matching instance of substring
 *	in string.  If string doesn't contain substring, the
 *	return value is 0.  Matching is done on an exact
 *	character-for-character basis with no wildcards or special
 *	characters.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

char *
strstr(char *string, char* substring)
   
{
    register char *a, *b;

    /* First scan quickly through the two strings looking for a
     * single-character match.  When it's found, then compare the
     * rest of the substring.
     */

    b = substring;
    if (*b == 0) {
	return string;
    }
    for ( ; *string != 0; string += 1) {
	if (*string != *b) {
	    continue;
	}
	a = string;
	while (1) {
	    if (*b == 0) {
		return string;
	    }
	    if (*a++ != *b++) {
		break;
	    }
	}
	b = substring;
    }
    return (char *) 0;
}


/* 
*Input: String, substring
*Return: if a substring from initial pos - not -1
		 else- -1
*/
int32_t
str_find(char *string, char* substring)
{
	
    register char  *b;

    /* First scan quickly through the two strings looking for a
     * single-character match.  When it's found, then compare the
     * rest of the substring.
     */
     int i;
    int ret_value = -1;
    int count = 0;
    b = substring;
    if (*b == 0) {
	return ret_value;
    }
    for ( ; *string != 0; string += 1, b +=1) {
		i++;
		//if (i== BUFF_SIZE)
		//	break;
		if (*b != 0)
		{
			if (*string == *b) {
	   		 	count++;
	    		continue;
	    	}
			else
			{
				break;
			}
			
		}
		else
			break;
		
	}
	if (count == strlen(substring))
		ret_value = count;   
	return ret_value;
}

/* 
*Input: base, power
*Return: evaluated exponent
*/
int32_t pow(int32_t base, int32_t power)
{
	if(power == 0)
		return 1;
	int32_t e;
	int32_t ret_value = base;
	for(e = 1; e < power; e++)
	{
		ret_value *= base;
	}
	return ret_value;
}