utils.c

Go to the documentation of this file.

//utils.c - various utilitys
#include "utils.h"
#include "types.h"
 
int abs(int x) { //absolute check
    if (x < 0) return -x; //if under 0
    return x; //if not
}
int strlen(const char* s) {
    int len = 0; //int lenth
    while (s[len]) len++; //calc length 
    return len;
}
 
int strcmp(const char* a, const char* b) { //string comparison
    while (*a && *b && *a == *b) { a++; b++; } //complex
    //while *a and *b and *a == *b aka while a and b are the same and exist increment them and return a - b
    return *a - *b; //return
}
 
void strcpy(char* dest, const char* src) { //dest and char
    while (*src) *dest++ = *src++; //while src exists dest++ is the same as src++
    *dest = 0;
}
 
void strcat(char* dest, const char* src) { //string concatonate
    while (*dest) dest++; //while *dest exists increment dest, not the ptr itself
    while (*src) *dest++ = *src++; //while src exist dest++ is src++
    *dest = 0; //set dest 0
}
 
/**
 * @brief itoa converts an integer to a decimal string
 *
 * itoa is a function that converts a signed integer into a
 * null-terminated decimal string representation
 * @param num, the integer to convert
 * @param str, the output buffer for the resulting string
 *
 * using itoa is done with
 * @code{.c}
 * #include "../lib/utils.h" //or just utils.h
 * char buff[12];
 * itoa(-42, buff);
 * @endcode
 *
 * @see atoi(), prtd()
 */
void itoa(int num, char* str) {
    char digits[12];
    int i = 0;
    int is_neg = 0;
    
    //handle 0
    if (num == 0) {
        str[0] = '0';
        str[1] = '\0';
        return;
    }
    
    //handle negative
    if (num < 0) {
        is_neg = 1;
        //special case for -2,147,483,648
        if (num == -2147483648) {
            str[0] = '-';
            str[1] = '2';
            str[2] = '1';
            str[3] = '4';
            str[4] = '7';
            str[5] = '4';
            str[6] = '8';
            str[7] = '3';
            str[8] = '6';
            str[9] = '4';
            str[10] = '8';
            str[11] = '\0';
            return;
        }
        num = -num;
    }
    
    //build digits in reverse
    while (num > 0) {
        digits[i++] = (char)('0' + (num % 10));
        num /= 10;
    }
    
    //add negative sign
    int idx = 0;
    if (is_neg) {
        str[idx++] = '-';
    }
    
    //reverse digits
    while (i > 0) {
        str[idx++] = digits[--i];
    }
    
    str[idx] = '\0';
}
 
/**
 * @brief atoi converts a decimal string to an integer
 *
 * atoi is a function that parses a string of digit characters
 * and returns the corresponding integer value
 * @param str, the null-terminated decimal string to parse
 *
 * using atoi is done with
 * @code{.c}
 * #include "../lib/utils.h" //or just utils.h
 * int value = atoi("42");
 * @endcode
 *
 * @see itoa()
 */
int atoi(const char *str) {
    int num = 0;
    while (*str >= '0' && *str <= '9') { //while string over zero and under 9 (1-8)
        num = num * 10 + (*str - '0'); //then do num is num * 10 + string - 0 and increment string
        str++;
    }
    return num; //return num
}
 
static uint32_t rng_state = 123456789;
 
/**
 * @brief srand seeds the random number generator
 *
 * srand is a function that initializes the xor-shift rng state
 * with a given seed value
 * @param seed, the initial seed value for the rng
 *
 * using srand is done with
 * @code{.c}
 * #include "../lib/utils.h" //or just utils.h
 * srand(12345);
 * @endcode
 *
 * @see rand()
 */
void srand(uint32_t seed) {
    rng_state = seed;
}
 
/**
 * @brief rand returns a pseudo-random 32 bit integer
 *
 * rand is a function that generates a random number using a
 * xor-shift algorithm on the internal rng state
 *
 * using rand is done with
 * @code{.c}
 * #include "../lib/utils.h" //or just utils.h
 * uint32_t rnd = rand();
 * @endcode
 *
 * @see srand()
 */
uint32_t rand(void) {
    rng_state ^= rng_state << 13; //shift state 3 times for randomness
    rng_state ^= rng_state >> 17;
    rng_state ^= rng_state << 5;
    return rng_state;
}
 
/**
 * @brief pargs parses a command line into an argument array
 *
 * pargs is a function that splits a string into an argv-style
 * array of null-terminated arguments, supporting quoted strings
 * and skipping leading '/' characters
 * @param line, the input line to parse (modified in-place)
 * @param args, the output array of string pointers
 *
 * using pargs is done with
 * @code{.c}
 * #include "../lib/utils.h" //or just utils.h
 * char input[100];
 * char *args[MAX_ARGS];
 * rdln(input, 100);
 * int argc = pargs(input, args);
 * @endcode
 *
 * @see shell(), MAX_ARGS
 */
int pargs(char *line, char *args[]) {
    int argc = 0;
    int i = 0;
    int in_quote = 0;
    
    //skip leading '/'
    if (line[0] == '/') i = 1;
    
    while (line[i] != '\0' && argc < MAX_ARGS) {
        //skip spaces (but not inside quotes)
        while (line[i] == ' ' && !in_quote) i++;
        if (line[i] == '\0') break;
        
        //start of argument
        args[argc] = &line[i];
        argc++;
        
        //check if arg starts with quote
        if (line[i] == '"') {
            in_quote = 1;
            args[argc-1] = &line[i+1]; //skip the quote
            i++; //move past the quote
        }
        
        //find end of argument
        while (line[i] != '\0') {
            if (in_quote) {
                if (line[i] == '"') {
                    line[i] = '\0'; //terminate at closing quote
                    i++; //move past the quote
                    in_quote = 0;
                    break;
                }
            } else {
                if (line[i] == ' ') { //if its a space
                    line[i] = '\0'; //term
                    i++; //inc and break
                    break;
                }
            }
            i++; //inc outside so it continues
        }
    }
    
    return argc; //return
}