CS107 Computer Organization and Systems Cheat Sheet (DRAFT) by yueqiao

#define CONSTANT 0x8
int main(int argc, char *argv[]) {
    char *prefix = "CS";
    int number = 107;
    // %s (string), %d (integer), %f (double)
    printf("You are in %s%d\n", prefix, number);
    return 0;
}

/* Unix
ls samples/server_files/home/ >> home_dir.txt
diff samples/server_files/users.list home_dir.txt
grep "sudo" samples/server_files/home/mattv/.bash_history  */
int main(int argc, char *argv[]) {
    int nlevels = DEFAULT_LEVELS;
    if (argc > 1) {
        nlevels = atoi(argv[1]);
        if (nlevels < 0 || nlevels > 8) {
// void error(int status, int errnum, const char *format, ...);
            error(1, 0, "out of range");   
        }
    }
    print_triangle(nlevels);
    return 0;
}

long signed_max(int bitwidth) {
    return ~signed_min(bitwidth);
}
long signed_min(int bitwidth) {
    return -1L << (bitwidth - 1);
}
long sat_add(long operand1, long operand2, int bitwidth) {
    if (!((operand1 >> (bitwidth - 1)) & 1L) && 
    !((operand2 >> (bitwidth - 1)) & 1L) && 
    (((operand1 + operand2) >> (bitwidth - 1)) & 1L)) {
        return signed_max(bitwidth);
    }
    if (((operand1 >> (bitwidth - 1)) & 1L) && 
    ((operand2 >> (bitwidth - 1)) & 1L) && 
    !(((operand1 + operand2) >> (bitwidth - 1)) & 1L)) {
        return signed_min(bitwidth);
    }
    return operand1 + operand2;
}
int to_utf8(unsigned short code_point, unsigned char utf8_bytes[]) {
    if (code_point <= 0x7f) {
        utf8_bytes[0] = code_point;
        return 1;
    } else if (code_point <= 0x7ff) {
        utf8_bytes[0] = 0xc0;  // represents 11000000.
        utf8_bytes[1] = 0x80;  // represents 10000000.
        utf8_bytes[0] |= (code_point & 0x7c0) >> 6;  // 0x7c0 provides the bit mask 11100000.
        utf8_bytes[1] |= code_point & 0x3f;  // 0x3f provides the bit mask 00111111.

        return 2;
    } else {
        utf8_bytes[0] = 0xe0;  // represents 11100000.
        utf8_bytes[1] = 0x80;  // represents 10000000.
        utf8_bytes[2] = 0x80;  // represents 10000000.
        utf8_bytes[0] |= (code_point & 0xf000) >> 12;  // 0xf000 provides the bit mask 1111000000000000.
        utf8_bytes[1] |= (code_point & 0xfc0) >> 6;  // 0xfc0 provides the bit mask 0000111111000000.
        utf8_bytes[2] |= code_point & 0x3f;  // 0x3f provides the bit mask 0000000000111111.
        return 3;
    }
}
#define BIT_MASK_3 7L
unsigned long advance(unsigned long cur_gen, unsigned char ruleset) {
    unsigned long next_gen = 0;
    unsigned long neighborhood = 0;
    neighborhood = (cur_gen << 1) & BIT_MASK_3;
    next_gen |= (ruleset >> neighborhood) & 1L; 

    for (int i = 0; i <= sizeof(long) * CHAR_BIT - 2; ++i) {
        neighborhood = (cur_gen >> i) & BIT_MASK_3;
        next_gen |= ((ruleset >> neighborhood) & 1L) << (i + 1); 
    }
    return next_gen;
}

void draw_generation(unsigned long gen) {
    for (int i = sizeof(long) * CHAR_BIT - 1; i >= 0; --i) {
        if ((gen >> i) & 1L) {
            printf(LIVE_STR);
        } else {
            printf(EMPTY_STR);
        }
    }
    printf("\n");
}

const char *get_env_value(const char envp[], const char key) {
    int lenKey = strlen(key);
    for (int i = 0; envp[i] != NULL; ++i) {
        char* match = strstr(envp[i], key);
        if (match == envp[i] && *(match + lenKey) == '=') {
            return match + lenKey + 1;
        }
    }
    return NULL;
}

bool scan_token(const char **p_input, 
const char *delimiters, char buf[], size_t buflen) {
    const char begin = p_input;
    begin += strspn(begin, delimiters);
    const char* end = begin + strcspn(begin, delimiters);
    
    int maxlen = 0;
    if (end - begin <= buflen - 1) {
        maxlen = end - begin;
    } else {
        maxlen = buflen - 1;
    }
    if (maxlen <= 0) {
        *p_input = begin;
        return false;
    }
    strncpy(buf, begin, maxlen);
    buf[maxlen] = '\0';
    *p_input = begin + maxlen;
    return true;
}
int main(int argc, char argv[], const char envp[]) {
    const char *searchpath = get_env_value(envp, "MYPATH");
    if (searchpath == NULL) {
        searchpath = get_env_value(envp, "PATH");
    }
    if (argc == 1) {
        char dir[PATH_MAX];
        const char *remaining = searchpath;

        printf("Directories in search path:\n");
        while (scan_token(&remaining, ":", dir, sizeof(dir))) {
            printf("%s\n", dir);
        }
    } else {
        for (size_t i = 1; i < argc; ++i) {
            const char *executable = argv[i];
            char dir[PATH_MAX];
            const char *remaining = searchpath;
            while (scan_token(&remaining, ":", dir, sizeof(dir))) {
                strcat(dir, "/");
                strcat(dir, executable);
                if (access(dir, R_OK | X_OK) == 0) {  
                    printf("%s\n", dir);
                    break;
                }
            }        
        }
    }   
    return 0;
}

char *read_line(FILE *file_pointer) {
    char* buffer = malloc(MINIMUM_SIZE);
    assert(buffer != NULL);
    size_t curSize = MINIMUM_SIZE;
    char* curPtr = fgets(buffer, curSize, file_pointer);
    if (curPtr == NULL) {
        free(buffer);
        return NULL;
    }
    size_t strLen = strlen(buffer);
    while (*(buffer + strLen - 1) != '\n') {
        curSize *= 2;
        buffer = realloc(buffer, curSize);
        assert(buffer != NULL);
        curPtr = buffer + strLen;
        char* newPtr = fgets(curPtr, curSize - strLen, file_pointer); 
        if (newPtr == NULL) {
            *curPtr = '\0'; 
            break;
        } else {
            curPtr = newPtr;
        }
        strLen += strlen(curPtr);
    }
    if (*(buffer + strLen - 1) == '\n') {
        *(buffer + strLen - 1) = '\0'; 
    }
    return buffer;
}
void print_last_n(FILE *file_pointer, int n) {
    char* lines[n];
    char* line = NULL;
    int idx = 0;
    size_t cnt_read = 0;
    while ((line = read_line(file_pointer)) != NULL) {
        lines[idx] = line;
        idx = (idx + 1) % n;
        ++cnt_read;
    }
    if (cnt_read < n) {
        idx = 0;
    } else {
        cnt_read = n;
    }
    line = lines[idx];
    size_t cnt_print = 0;
    while (cnt_print < cnt_read) {
        printf("%s\n", line);
        free(line);
        idx = (idx + 1) % n;
        line = lines[idx];
        ++cnt_print;
    }
}
struct Element {
    char* str;
    int cnt;
};

void print_uniq_lines(FILE *file_pointer) {
    size_t curSize = ESTIMATE;
    struct Element arr = malloc(sizeof(struct Element)  curSize);
    assert(arr != NULL);
    size_t cntElement = 0;
    char* line = NULL;
    while ((line = read_line(file_pointer)) != NULL) {
        bool found = false;
        for (size_t i = 0; i < cntElement; ++i) {
            if (strcmp(line, arr[i].str) == 0) {
                ++arr[i].cnt;
                found = true;
                free(line); 
                break;
            }
        }
        if (!found) {
            arr[cntElement].str = line;
            arr[cntElement].cnt = 1;
            ++cntElement;
            if (cntElement == curSize) {
                curSize += ESTIMATE;
                arr = realloc(arr, sizeof(struct Element) * curSize);
                assert(arr != NULL);
            }
        }
    }
    for (size_t i = 0; i < cntElement; ++i) {
        printf("%7d %s\n", arr[i].cnt, arr[i].str);
        free(arr[i].str);
    }
    free(arr);
}