Open-Argon/Chloride
1
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

add function assignment

Browse Source
This commit is contained in:
William Bell
2025-10-21 20:34:33 +01:00
parent 70ba81bebc
commit c8394228b3
14 changed files with 139 additions and 52 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/arobject.h
View File

@@ -33,7 +33,6 @@ typedef enum {
field__address,
__call__,
__number__,
field_log,
field_length,
__getattribute__,
__set_attr__,

7
src/lexer/lex.l
View File

@@ -32,13 +32,6 @@ int yywrap(void * unused_param) {
":" { return TOKEN_COLON; }
"=" { return TOKEN_ASSIGN; }
"+=" { return TOKEN_ASSIGN_PLUS; }
"-=" { return TOKEN_ASSIGN_MINUS; }
"//=" { return TOKEN_ASSIGN_FLOORDIV; }
"/=" { return TOKEN_ASSIGN_SLASH; }
"%=" { return TOKEN_ASSIGN_MODULO; }
"*=" { return TOKEN_ASSIGN_STAR; }
"^=" { return TOKEN_ASSIGN_CARET; }
"not"[ \t]+"in" { return TOKEN_NOT_IN; }
"in" { return TOKEN_IN; }

9
src/lexer/token.h
View File

@@ -17,13 +17,6 @@ typedef enum {
TOKEN_INDENT,
TOKEN_ASSIGN,
TOKEN_ASSIGN_PLUS,
TOKEN_ASSIGN_MINUS,
TOKEN_ASSIGN_FLOORDIV,
TOKEN_ASSIGN_SLASH,
TOKEN_ASSIGN_MODULO,
TOKEN_ASSIGN_STAR,
TOKEN_ASSIGN_CARET,
// Operators
TOKEN_CARET, // ^ (Exponentiation)
@@ -31,8 +24,8 @@ typedef enum {
TOKEN_SLASH, // / (Division)
TOKEN_FLOORDIV, // // (Floor Division)
TOKEN_MODULO, // % (Modulo)
TOKEN_PLUS, // + (Addition)
TOKEN_MINUS, // - (Subtraction)
TOKEN_PLUS, // + (Addition)
TOKEN_LT, // <
TOKEN_GT, // >
TOKEN_LE, // <=

79
src/parser/assignable/assign/assign.c
View File

@@ -7,25 +7,38 @@
#include "assign.h"
#include "../../../lexer/token.h"
#include "../../../memory.h"
#include "../../function/function.h"
#include "../../parser.h"
#include "../../string/string.h"
#include "../access/access.h"
#include "../call/call.h"
#include "../identifier/identifier.h"
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
ParsedValueReturn parse_assign(char *file, DArray *tokens,
ParsedValue *assign_to, size_t *index) {
Token *token = darray_get(tokens, *index);
bool is_function = false;
char *function_name;
bool to_free_function_name = false;
DArray function_args;
ParsedValue *function_assign_to;
switch (assign_to->type) {
case AST_IDENTIFIER:
case AST_ACCESS:
break;
case AST_CALL:;
ParsedCall *call = assign_to->data;
darray_init(&function_args, sizeof(char *));
for (size_t i = 0; i < call->args.size; i++) {
if (((ParsedValue *)darray_get(&call->args, i))->type != AST_IDENTIFIER) {
ParsedValue *arg = darray_get(&call->args, i);
if (arg->type != AST_IDENTIFIER) {
free_parsed(assign_to);
free(assign_to);
darray_free(&function_args, free_parameter);
return (ParsedValueReturn){
create_err(
token->line, token->column, token->length, file, "Syntax Error",
@@ -34,6 +47,32 @@ ParsedValueReturn parse_assign(char *file, DArray *tokens,
"only use letters, digits, or _, and can't be keywords."),
NULL};
}
char *param = strdup(((ParsedIdentifier *)arg->data)->name);
darray_push(&function_args, &param);
}
darray_free(&call->args, free_parsed);
is_function = true;
function_assign_to = call->to_call;
switch (function_assign_to->type) {
case AST_IDENTIFIER:
function_name = ((ParsedIdentifier *)function_assign_to->data)->name;
break;
case AST_ACCESS:
if (((ParsedAccess *)function_assign_to->data)->access->type ==
AST_STRING) {
ParsedString *name =
((ParsedAccess *)function_assign_to->data)->access->data;
function_name = checked_malloc(name->length + 1);
function_name[name->length] = 0;
memcpy(function_name, name->string, name->length);
to_free_function_name = true;
break;
}
// FALL THROUGH
default:
function_name = "anonymous";
break;
}
break;
default:;
@@ -44,36 +83,40 @@ ParsedValueReturn parse_assign(char *file, DArray *tokens,
free(assign_to);
return (ParsedValueReturn){err, NULL};
}
(*index)++;
token = darray_get(tokens, *index);
ParsedValueReturn from = parse_token(file, tokens, index, true);
if (from.err.exists) {
return from;
}
if (!from.value) {
return (ParsedValueReturn){create_err(token->line, token->column,
token->length, file, "Syntax Error",
"expected body"),
NULL};
}
if (is_function) {
from.value =
create_parsed_function(function_name, function_args, from.value);
if (to_free_function_name) free(function_name);
free(assign_to->data);
free(assign_to);
assign_to = function_assign_to;
}
ParsedAssign *assign = checked_malloc(sizeof(ParsedAssign));
assign->to = assign_to;
assign->type = token->type;
assign->type = 0;
assign->from = NULL;
ParsedValue *parsedValue = checked_malloc(sizeof(ParsedValue));
parsedValue->type = AST_ASSIGN;
parsedValue->data = assign;
(*index)++;
ArErr err = error_if_finished(file, tokens, index);
if (err.exists) {
free_parsed(parsedValue);
free(parsedValue);
return (ParsedValueReturn){err, NULL};
}
token = darray_get(tokens, *index);
ParsedValueReturn from = parse_token(file, tokens, index, true);
if (from.err.exists) {
free_parsed(parsedValue);
free(parsedValue);
return from;
}
assign->from = from.value;
if (!assign->from) {
free_parsed(parsedValue);
free(parsedValue);
return (ParsedValueReturn){create_err(token->line, token->column,
token->length, file, "Syntax Error",
"expected body"),
NULL};
}
return (ParsedValueReturn){no_err, parsedValue};
}

7
src/parser/parser.c
View File

@@ -158,13 +158,6 @@ ParsedValueReturn parse_token_full(char *file, DArray *tokens, size_t *index,
token = darray_get(tokens, *index);
switch (token->type) {
case TOKEN_ASSIGN:
case TOKEN_ASSIGN_CARET:
case TOKEN_ASSIGN_FLOORDIV:
case TOKEN_ASSIGN_MINUS:
case TOKEN_ASSIGN_MODULO:
case TOKEN_ASSIGN_PLUS:
case TOKEN_ASSIGN_SLASH:
case TOKEN_ASSIGN_STAR:
output = parse_assign(file, tokens, output.value, index);
break;
case TOKEN_LPAREN:

2
src/runtime/objects/dictionary/dictionary.c
View File

@@ -95,7 +95,7 @@ ArgonObject *create_ARGON_DICTIONARY_TYPE___string__(size_t argc,
string_object->value.as_str->length);
string_length += string_object->value.as_str->length;
} else {
char *string_obj = "<object>";
char *string_obj = "{...}";
size_t length = strlen(string_obj);
string = realloc(string, string_length + length);
memcpy(string + string_length, string_obj, length);

3
src/runtime/objects/object.c
View File

@@ -39,7 +39,7 @@ const char *built_in_field_names[BUILT_IN_FIELDS_COUNT] = {
"__string__",
"__subtract__",
"__multiply__",
"__divide__",
"__divide__",
"__new__",
"__init__",
"__boolean__",
@@ -49,7 +49,6 @@ const char *built_in_field_names[BUILT_IN_FIELDS_COUNT] = {
"address",
"__call__",
"__number__",
"log",
"length",
"__getattribute__",
"__set_attr__",

69
src/runtime/runtime.c
View File

@@ -31,6 +31,11 @@
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#if defined(_WIN32)
#include <windows.h>
#else
extern char **environ;
#endif
ArgonObject *ARGON_METHOD_TYPE;
Stack *Global_Scope = NULL;
@@ -692,11 +697,11 @@ void bootstrap_types() {
create_ARGON_DICTIONARY_TYPE();
}
void add_to_scope(Stack *stack, char *name, ArgonObject *value) {
void add_to_hashmap(struct hashmap_GC *hashmap, char *name, ArgonObject *value) {
size_t length = strlen(name);
uint64_t hash = siphash64_bytes(name, length, siphash_key);
ArgonObject *key = new_string_object(name, length, 0, hash);
hashmap_insert_GC(stack->scope, hash, key, value, 0);
hashmap_insert_GC(hashmap, hash, key, value, 0);
}
void bootstrap_globals() {
@@ -712,11 +717,56 @@ void bootstrap_globals() {
add_to_scope(Global_Scope, "divide", DIVIDE_FUNCTION);
add_to_scope(Global_Scope, "dictionary", ARGON_DICTIONARY_TYPE);
ArgonObject *argon_term = new_class();
add_builtin_field(argon_term, __init__, ARGON_NULL);
add_builtin_field(argon_term, field_log,
struct hashmap_GC *argon_term = createHashmap_GC();
add_to_hashmap(argon_term, "log",
create_argon_native_function("log", term_log));
add_to_scope(Global_Scope, "term", argon_term);
add_to_scope(Global_Scope, "term", create_dictionary(argon_term));
struct hashmap_GC *environment_variables = createHashmap_GC();
#if defined(_WIN32)
// Windows: use WinAPI
LPCH env = GetEnvironmentStringsA();
if (!env) return;
for (LPCH var = env; *var; var += strlen(var) + 1) {
// Each string is like "KEY=VALUE"
const char *equals = strchr(var, '=');
if (equals) {
size_t key_len = equals - var;
char key[256];
if (key_len >= sizeof(key))
key_len = sizeof(key) - 1;
strncpy(key, var, key_len);
key[key_len] = '\0';
const char *value = getenv(key);
add_to_hashmap(environment_variables, key,
value?new_string_object_null_terminated((char *)value):ARGON_NULL);
}
}
FreeEnvironmentStringsA(env);
#else
// POSIX systems: use environ
for (char **env = environ; *env != NULL; env++) {
const char *equals = strchr(*env, '=');
if (equals) {
size_t key_len = equals - *env;
char key[256];
if (key_len >= sizeof(key))
key_len = sizeof(key) - 1;
strncpy(key, *env, key_len);
key[key_len] = '\0';
const char *value = getenv(key);
add_to_hashmap(environment_variables, key,
value?new_string_object_null_terminated((char *)value):ARGON_NULL);
}
}
#endif
add_to_scope(Global_Scope, "env", create_dictionary(environment_variables));
}
int compare_by_order(const void *a, const void *b) {
@@ -800,6 +850,13 @@ Stack *create_scope(Stack *prev, bool force) {
return prev;
}
void add_to_scope(Stack *stack, char *name, ArgonObject *value) {
size_t length = strlen(name);
uint64_t hash = siphash64_bytes(name, length, siphash_key);
ArgonObject *key = new_string_object(name, length, 0, hash);
hashmap_insert_GC(stack->scope, hash, key, value, 0);
}
void runtime(Translated _translated, RuntimeState _state, Stack *stack,
ArErr *err) {
static void *const dispatch_table[] = {

2
src/runtime/runtime.h
View File

@@ -91,6 +91,8 @@ Stack *create_scope(Stack *prev, bool force);
void add_to_scope(Stack *stack, char *name, ArgonObject *value);
void add_to_hashmap(struct hashmap_GC *hashmap, char *name, ArgonObject *value);
void runtime(Translated translated, RuntimeState state, Stack *stack,
ArErr *err);

2
src/translator/assignment/assignment.c
View File

@@ -8,7 +8,6 @@
#include "../../hash_data/hash_data.h"
#include "../../parser/assignable/access/access.h"
#include "../../parser/assignable/identifier/identifier.h"
#include "../../parser/string/string.h"
#include "../translator.h"
#include <stddef.h>
#include <stdio.h>
@@ -71,6 +70,7 @@ size_t translate_parsed_assignment(Translated *translated,
push_instruction_byte(translated, OP_CALL);
translated->registerAssignment--;
break;
default:
fprintf(stderr, "panic: unsupported assignment\n");
exit(EXIT_FAILURE);