236 lines
5.9 KiB
C
236 lines
5.9 KiB
C
#include <stdbool.h>
|
|
#include <stdio.h>
|
|
#include <malloc.h>
|
|
#include <string.h>
|
|
|
|
#include "hydroforth/hydroforth.h"
|
|
|
|
unsigned int hydroforth__hash_string(const char *const key, unsigned char len)
|
|
{
|
|
unsigned char i = 0;
|
|
unsigned int hash = 0;
|
|
while (i < len)
|
|
{
|
|
hash += key[i++];
|
|
hash += hash << 10;
|
|
hash ^= hash >> 6;
|
|
}
|
|
hash += hash << 3;
|
|
hash ^= hash >> 11;
|
|
hash += hash << 15;
|
|
|
|
return hash;
|
|
}
|
|
|
|
inline bool hydroforth__is_space(char c)
|
|
{
|
|
return c == ' ' || c == '\t';
|
|
}
|
|
|
|
bool hydroforth__parse(HYDROFORTH__INTERPRETER *interpreter)
|
|
{
|
|
const unsigned long start = interpreter->pos;
|
|
unsigned char len = 0;
|
|
while (!hydroforth__is_space(interpreter->src[interpreter->pos]) && interpreter->src[interpreter->pos] != '\n' && interpreter->src[interpreter->pos])
|
|
{
|
|
len++;
|
|
interpreter->pos++;
|
|
}
|
|
if (len == 1)
|
|
{
|
|
if (hydroforth__number__is_digit(interpreter->src[start]))
|
|
{
|
|
interpreter->call_stack[interpreter->call_stack_len++] = (HYDROFORTH__WORD){
|
|
.type = PUSH,
|
|
.data = {.number = interpreter->src[start] - '0'},
|
|
};
|
|
}
|
|
else
|
|
{
|
|
switch (interpreter->src[start])
|
|
{
|
|
case '\\':
|
|
do
|
|
{
|
|
interpreter->pos++;
|
|
} while (interpreter->src[interpreter->pos] != '\n' && interpreter->src[interpreter->pos]);
|
|
break;
|
|
|
|
case '(':
|
|
while (true)
|
|
{
|
|
interpreter->pos++;
|
|
if (interpreter->src[interpreter->pos] == ')' &&
|
|
(hydroforth__is_space(interpreter->src[interpreter->pos + 1]) ||
|
|
interpreter->src[interpreter->pos + 1] == '\n' ||
|
|
interpreter->src[interpreter->pos + 1] == '\0') ||
|
|
interpreter->src[interpreter->pos] == '\n' ||
|
|
interpreter->src[interpreter->pos] == '\0')
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
default:
|
|
interpreter->call_stack[interpreter->call_stack_len++] = (HYDROFORTH__WORD){
|
|
.type = CHAR_WORD,
|
|
.data = {.char_word = interpreter->src[start]},
|
|
};
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
const bool next_is_digit = hydroforth__number__is_digit(interpreter->src[start + 1]);
|
|
if (next_is_digit && interpreter->src[start] == '-')
|
|
{
|
|
int n;
|
|
if (!hydroforth__number__parse_number(interpreter->src + start + 1, len - 1, &n))
|
|
{
|
|
fputs("Error parsing number!", stderr);
|
|
return false;
|
|
}
|
|
interpreter->call_stack[interpreter->call_stack_len++] = (HYDROFORTH__WORD){
|
|
.type = PUSH,
|
|
.data = {.number = -n},
|
|
};
|
|
}
|
|
else if (next_is_digit && interpreter->src[start] == '+')
|
|
{
|
|
int n;
|
|
if (!hydroforth__number__parse_number(interpreter->src + start + 1, len - 1, &n))
|
|
{
|
|
fputs("Error parsing number!", stderr);
|
|
return false;
|
|
}
|
|
interpreter->call_stack[interpreter->call_stack_len++] = (HYDROFORTH__WORD){
|
|
.type = PUSH,
|
|
.data = {.number = n},
|
|
};
|
|
}
|
|
else if (hydroforth__number__is_digit(interpreter->src[start]))
|
|
{
|
|
int n;
|
|
if (!hydroforth__number__parse_number(interpreter->src + start, len, &n))
|
|
{
|
|
fputs("Error parsing number!", stderr);
|
|
return false;
|
|
}
|
|
interpreter->call_stack[interpreter->call_stack_len++] = (HYDROFORTH__WORD){
|
|
.type = PUSH,
|
|
.data = {.number = n},
|
|
};
|
|
}
|
|
else
|
|
{
|
|
const unsigned int hash = hydroforth__hash_string(interpreter->src + start, len);
|
|
switch (hash)
|
|
{
|
|
case 0x4078cde9: // --
|
|
do
|
|
{
|
|
interpreter->pos++;
|
|
} while (interpreter->src[interpreter->pos] != '\n' && interpreter->src[interpreter->pos]);
|
|
break;
|
|
|
|
default:
|
|
interpreter->call_stack[interpreter->call_stack_len++] = (HYDROFORTH__WORD){
|
|
.type = WORD,
|
|
.data = {.hash = hash},
|
|
};
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool hydroforth__run_call_stack(HYDROFORTH__INTERPRETER *interpreter)
|
|
{
|
|
for (unsigned char i = interpreter->call_stack_len; i > 0; interpreter->call_stack_len--, i--)
|
|
{
|
|
const HYDROFORTH__WORD *word = interpreter->call_stack + i - 1;
|
|
switch (word->type)
|
|
{
|
|
case PUSH:
|
|
interpreter->stack[interpreter->stack_len++] = word->data.number;
|
|
break;
|
|
|
|
case CHAR_WORD:
|
|
switch (word->data.char_word)
|
|
{
|
|
case ':':
|
|
printf("WORD DEFINITION\n");
|
|
break;
|
|
|
|
case '-':
|
|
interpreter->stack[interpreter->stack_len - 2] -= interpreter->stack[interpreter->stack_len - 1];
|
|
interpreter->stack_len--;
|
|
break;
|
|
|
|
case '+':
|
|
interpreter->stack[interpreter->stack_len - 2] += interpreter->stack[interpreter->stack_len - 1];
|
|
interpreter->stack_len--;
|
|
break;
|
|
|
|
case '*':
|
|
interpreter->stack[interpreter->stack_len - 2] *= interpreter->stack[interpreter->stack_len - 1];
|
|
interpreter->stack_len--;
|
|
break;
|
|
|
|
case '/':
|
|
interpreter->stack[interpreter->stack_len - 2] /= interpreter->stack[interpreter->stack_len - 1];
|
|
interpreter->stack_len--;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case WORD:
|
|
printf("HASH: 0x%x\n", word->data.hash);
|
|
switch (word->data.hash)
|
|
{
|
|
case 0xaddd94c: // debug
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool hydroforth__run(HYDROFORTH__INTERPRETER *interpreter)
|
|
{
|
|
while (true)
|
|
{
|
|
while (hydroforth__is_space(interpreter->src[interpreter->pos]) || interpreter->src[interpreter->pos] == '\n')
|
|
{
|
|
interpreter->pos++;
|
|
}
|
|
if (interpreter->src[interpreter->pos] == '\0')
|
|
{
|
|
return true;
|
|
}
|
|
if (!interpreter->src[interpreter->pos])
|
|
{
|
|
return true;
|
|
}
|
|
if (!hydroforth__parse(interpreter))
|
|
{
|
|
return false;
|
|
}
|
|
if (!hydroforth__run_call_stack(interpreter))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|