//: Arithmetic primitives :(before "End Primitive Recipe Declarations") ADD, :(before "End Primitive Recipe Numbers") put(Recipe_ordinal, "add", ADD); :(before "End Primitive Recipe Checks") case ADD: { // primary goal of these checks is to forbid address arithmetic for (int i = 0; i < SIZE(inst.ingredients); ++i) { if (!is_mu_number(inst.ingredients.at(i))) { raise << maybe(get(Recipe, r).name) << "'add' requires number ingredients, but got '" << inst.ingredients.at(i).original_string << "'\n" << end(); goto finish_checking_instruction; } } if (SIZE(inst.products) > 1) { raise << maybe(get(Recipe, r).name) << "'add' yields exactly one product in '" << to_original_string(inst) << "'\n" << end(); break; } if (!inst.products.empty() && !is_dummy(inst.products.at(0)) && !is_mu_number(inst.products.at(0))) { raise << maybe(get(Recipe, r).name) << "'add' should yield a number, but got '" << inst.products.at(0).original_string << "'\n" << end(); break; } break; } :(before "End Primitive Recipe Implementations") case ADD: { double result = 0; for (int i = 0; i < SIZE(ingredients); ++i) { result += ingredients.at(i).at(0); } products.resize(1); products.at(0).push_back(result); break; } :(scenario add_literal) def main [ 1:num <- add 23, 34 ] +mem: storing 57 in location 1 :(scenario add) def main [ 1:num <- copy 23 2:num <- copy 34 3:num <- add 1:num, 2:num ] +mem: storing 57 in location 3 :(scenario add_multiple) def main [ 1:num <- add 3, 4, 5 ] +mem: storing 12 in location 1 :(scenario add_checks_type) % Hide_errors = true; def main [ 1:num <- add 2:bool, 1 ] +error: main: 'add' requires number ingredients, but got '2:bool' :(scenario add_checks_return_type) % Hide_errors = true; def main [ 1:&:num <- add 2, 2 ] +error: main: 'add' should yield a number, but got '1:&:num' :(before "End Primitive Recipe Declarations") SUBTRACT, :(before "End Primitive Recipe Numbers") put(Recipe_ordinal, "subtract", SUBTRACT); :(before "End Primitive Recipe Checks") case SUBTRACT: { if (inst.ingredients.empty()) { raise << maybe(get(Recipe, r).name) << "'subtract' has no ingredients\n" << end(); break; } for (int i = 0; i < SIZE(inst.ingredients); ++i) { if (!is_mu_number(inst.ingredients.at(i))) { raise << maybe(get(Recipe, r).name) << "'subtract' requires number ingredients, but got '" << inst.ingredients.at(i).original_string << "'\n" << end(); goto finish_checking_instruction; } } if (SIZE(inst.products) > 1) { raise << maybe(get(Recipe, r).name) << "'subtract' yields exactly one product in '" << to_original_string(inst) << "'\n" << end(); break; } if (!inst.products.empty() && !is_dummy(inst.products.at(0)) && !is_mu_number(inst.products.at(0))) { raise << maybe(get(Recipe, r).name) << "'subtract' should yield a number, but got '" << inst.products.at(0).original_string << "'\n" << end(); break; } break; } :(before "End Primitive Recipe Implementations") case SUBTRACT: { double result = ingredients.at(0).at(0); for (int i = 1; i < SIZE(ingredients); ++i) result -= ingredients.at(i).at(0); products.resize(1); products.at(0).push_back(result); break; } :(scenario subtract_literal) def main [ 1:num <- subtract 5, 2 ] +mem: storing 3 in location 1 :(scenario subtract) def main [ 1:num <- copy 23 2:num <- copy 34 3:num <- subtract 1:num, 2:num ] +mem: storing -11 in location 3 :(scenario subtract_multiple) def main [ 1:num <- subtract 6, 3, 2 ] +mem: storing 1 in location 1 :(before "End Primitive Recipe Declarations") MULTIPLY, :(before "End Primitive Recipe Numbers") put(Recipe_ordinal, "multiply", MULTIPLY); :(before "End Primitive Recipe Checks") case MULTIPLY: { for (int i = 0; i < SIZE(inst.ingredients); ++i) { if (!is_mu_number(inst.ingredients.at(i))) { raise << maybe(get(Recipe, r).name) << "'multiply' requires number ingredients, but got '" << inst.ingredients.at(i).original_string << "'\n" << end(); goto finish_checking_instruction; } } if (SIZE(inst.products) > 1) { raise << maybe(get(Recipe, r).name) << "'multiply' yields exactly one product in '" << to_original_string(inst) << "'\n" << end(); break; } if (!inst.products.empty() && !is_dummy(inst.products.at(0)) && !is_mu_number(inst.products.at(0))) { raise << maybe(get(Recipe, r).name) << "'multiply' should yield a number, but got '" << inst.products.at(0).original_string << "'\n" << end(); break; } break; } :(before "End Primitive Recipe Implementations") case MULTIPLY: { double result = 1; for (int i = 0; i < SIZE(ingredients); ++i) { result *= ingredients.at(i).at(0); } products.resize(1); products.at(0).push_back(result); break; } :(scenario multiply_literal) def main [ 1:num <- multiply 2, 3 ] +mem: storing 6 in location 1 :(scenario multiply) def main [ 1:num <- copy 4 2:num <- copy 6 3:num <- multiply 1:num, 2:num ] +mem: storing 24 in location 3 :(scenario multiply_multiple) def main [ 1:num <- multiply 2, 3, 4 ] +mem: storing 24 in location 1 :(before "End Primitive Recipe Declarations") DIVIDE, :(before "End Primitive Recipe Numbers") put(Recipe_ordinal, "divide", DIVIDE); :(before "End Primitive Recipe Checks") case DIVIDE: { if (inst.ingredients.empty()) { raise << maybe(get(Recipe, r).name) << "'divide' has no ingredients\n" << end(); break; } for (int i = 0; i < SIZE(inst.ingredients); ++i) { if (!is_mu_number(inst.ingredients.at(i))) { raise << maybe(get(Recipe, r).name) << "'divide' requires number ingredients, but got '" << inst.ingredients.at(i).original_string << "'\n" << end(); goto finish_checking_instruction; } } if (SIZE(inst.products) > 1) { raise << maybe(get(Recipe, r).name) << "'divide' yields exactly one product in '" << to_original_string(inst) << "'\n" << end(); break; } if (!inst.products.empty() && !is_dummy(inst.products.at(0)) && !is_mu_number(inst.products.at(0))) { raise << maybe(get(Recipe, r).name) << "'divide' should yield a number, but got '" << inst.products.at(0).original_string << "'\n" << end(); break; } break; } :(before "End Primitive Recipe Implementations") case DIVIDE: { double result = ingredients.at(0).at(0); for (int i = 1; i < SIZE(ingredients); ++i) result /= ingredients.at(i).at(0); products.resize(1); products.at(0).push_back(result); break; } :(scenario divide_literal) def main [ 1:num <- divide 8, 2 ] +mem: storing 4 in location 1 :(scenario divide) def main [ 1:num <- copy 27 2:num <- copy 3 3:num <- divide 1:num, 2:num ] +mem: storing 9 in location 3 :(scenario divide_multiple) def main [ 1:num <- divide 12, 3, 2 ] +mem: storing 2 in location 1 //: Integer division :(before "End Primitive Recipe Declarations") DIVIDE_WITH_REMAINDER, :(before "End Primitive Recipe Numbers") put(Recipe_ordinal, "divide-with-remainder", DIVIDE_WITH_REMAINDER); :(before "End Primitive Recipe Checks") case DIVIDE_WITH_REMAINDER: { if (SIZE(inst.ingredients) != 2) { raise << maybe(get(Recipe, r).name) << "'divide-with-remainder' requires exactly two ingredients, but got '" << to_original_string(inst) << "'\n" << end(); break; } if (!is_mu_number(inst.ingredients.at(0)) || !is_mu_number(inst.ingredients.at(1))) { raise << maybe(get(Recipe, r).name) << "'divide-with-remainder' requires number ingredients, but got '" << to_original_string(inst) << "'\n" << end(); break; } if (SIZE(inst.products) > 2) { raise << maybe(get(Recipe, r).name) << "'divide-with-remainder' yields two products in '" << to_original_string(inst) << "'\n" << end(); break; } for (int i = 0; i < SIZE(inst.products); ++i) { if (!is_dummy(inst.products.at(i)) && !is_mu_number(inst.products.at(i))) { raise << maybe(get(Recipe, r).name) << "'divide-with-remainder' should yield a number, but got '" << inst.products.at(i).original_string << "'\n" << end(); goto finish_checking_instruction; } } break; } :(before "End Primitive Recipe Implementations") case DIVIDE_WITH_REMAINDER: { products.resize(2); // fractions will be dropped; very large numbers will overflow long long int a = static_cast(ingredients.at(0).at(0)); long long int b = static_cast(ingredients.at(1).at(0)); if (b == 0) { raise << maybe(current_recipe_name()) << "divide by zero in '" << to_original_string(current_instruction()) << "'\n" << end(); products.resize(2); products.at(0).push_back(0); products.at(1).push_back(0); break; } long long int quotient = a / b; long long int remainder = a % b; products.at(0).push_back(static_cast(quotient)); products.at(1).push_back(static_cast(remainder)); break; } :(scenario divide_with_remainder_literal) def main [ 1:num, 2:num <- divide-with-remainder 9, 2 ] +mem: storing 4 in location 1 +mem: storing 1 in location 2 :(scenario divide_with_remainder) def main [ 1:num <- copy 27 2:num <- copy 11 3:num, 4:num <- divide-with-remainder 1:num, 2:num ] +mem: storing 2 in location 3 +mem: storing 5 in location 4 :(scenario divide_with_decimal_point) def main [ 1:num <- divide 5, 2 ] +mem: storing 2.5 in location 1 :(scenario divide_by_zero) def main [ 1:num <- divide 4, 0 ] +mem: storing inf in location 1 :(scenario divide_by_zero_2) % Hide_errors = true; def main [ 1:num <- divide-with-remainder 4, 0 ] # integer division can't return floating-point infinity +error: main: divide by zero in '1:num <- divide-with-remainder 4, 0' //: Bitwise shifts :(before "End Primitive Recipe Declarations") SHIFT_LEFT, :(before "End Primitive Recipe Numbers") put(Recipe_ordinal, "shift-left", SHIFT_LEFT); :(before "End Primitive Recipe Checks") case SHIFT_LEFT: { if (SIZE(inst.ingredients) != 2) { raise << maybe(get(Recipe, r).name) << "'shift-left' requires exactly two ingredients, but got '" << to_original_string(inst) << "'\n" << end(); break; } if (!is_mu_number(inst.ingredients.at(0)) || !is_mu_number(inst.ingredients.at(1))) { raise << maybe(get(Recipe, r).name) << "'shift-left' requires number ingredients, but got '" << to_original_string(inst) << "'\n" << end(); break; } if (SIZE(inst.products) > 1) { raise << maybe(get(Recipe, r).name) << "'shift-left' yields one product in '" << to_original_string(inst) << "'\n" << end(); break; } if (!inst.products.empty() && !is_dummy(inst.products.at(0)) && !is_mu_number(inst.products.at(0))) { raise << maybe(get(Recipe, r).name) << "'shift-left' should yield a number, but got '" << inst.products.at(0).original_string << "'\n" << end(); goto finish_checking_instruction; } break; } :(before "End Primitive Recipe Implementations") case SHIFT_LEFT: { // ingredients must be integers int a = static_cast(ingredients.at(0).at(0)); int b = static_cast(ingredients.at(1).at(0)); products.resize(1); if (b < 0) { raise << maybe(current_recipe_name()) << "second ingredient can't be negative in '" << to_original_string(current_instruction()) << "'\n" << end(); products.at(0).push_back(0); break; } products.at(0).push_back(a<
#include "keyboard.h"
#include "isr.h"
#include "common.h"
#include "screen.h"
#include "ttydriver.h"
#include "fs.h"
#include "device.h"
#include "alloc.h"
#include "devfs.h"
#include "list.h"

static uint8* gKeyBuffer = NULL;
static uint32 gKeyBufferWriteIndex = 0;
static uint32 gKeyBufferReadIndex = 0;

#define KEYBUFFER_SIZE 128

static BOOL keyboard_open(File *file, uint32 flags);
static void keyboard_close(File *file);
static int32 keyboard_read(File *file, uint32 size, uint8 *buffer);
static int32 keyboard_ioctl(File *file, int32 request, void * argp);

typedef enum ReadMode {
    Blocking = 0,
    NonBlocking = 1
} ReadMode;

typedef struct Reader {
    uint32 readIndex;
    ReadMode readMode;
} Reader;

static List* gReaders = NULL;

static void handleKeyboardInterrupt(Registers *regs);

void initializeKeyboard() {
    Device device;
    memset((uint8*)&device, 0, sizeof(Device));
    strcpy(device.name, "keyboard");
    device.deviceType = FT_CharacterDevice;
    device.open = keyboard_open;
    device.close = keyboard_close;
    device.read = keyboard_read;
    device.ioctl = keyboard_ioctl;

    gKeyBuffer = kmalloc(KEYBUFFER_SIZE);
    memset((uint8*)gKeyBuffer, 0, KEYBUFFER_SIZE);

    gReaders = List_Create();

    registerDevice(&device);

    registerInterruptHandler(IRQ1, handleKeyboardInterrupt);
}

static BOOL keyboard_open(File *file, uint32 flags) {
    Reader* reader = (Reader*)kmalloc(sizeof(Reader));
    reader->readIndex = 0;
    reader->readMode = Blocking;

    if (gKeyBufferWriteIndex > 0) {
        reader->readIndex = gKeyBufferWriteIndex;