add declaring and assignment with parser LHS support

src/parser/assignable/access/access.c

@@ -0,0 +1,28 @@
+#include "access.h"
+#include "../../../lexer/token.h"
+#include "../../parser.h"
+#include <string.h>
+#include <stdlib.h>
+#include "../../../memory.h"
+
+ParsedValue *parse_access(char*file,DArray *tokens, size_t * index, ParsedValue * to_access) {
+  (*index)++;
+  error_if_finished(file, tokens, index);
+  Token * token = darray_get(tokens, *index);
+  ParsedValue *parsedValue = checked_malloc(sizeof(ParsedValue));
+  ParsedAccess *parsedAccess = checked_malloc(sizeof(ParsedAccess));
+  parsedAccess->to_access = to_access;
+  parsedAccess->access = strcpy(checked_malloc(sizeof(token->value)), token->value);
+  parsedValue->type = AST_ACCESS;
+  parsedValue->data = parsedAccess;
+  return parsedValue;
+}
+
+void free_parse_access(void *ptr) {
+  ParsedValue *parsedValue = ptr;
+  ParsedAccess *parsedAccess = parsedValue->data;
+  free_parsed(parsedAccess->to_access);
+  free(parsedAccess->access);
+  free(parsedAccess->to_access);
+  free(parsedAccess);
+}

src/parser/assignable/access/access.h

@@ -0,0 +1,16 @@
+#ifndef ACCESS_H
+#define ACCESS_H
+#include "../../parser.h"
+#include "../../../lexer/token.h"  // for Token
+
+typedef struct {
+  ParsedValue * to_access;
+  char * access;
+} ParsedAccess;
+
+// Function declaration for parsing an identifier
+ParsedValue *parse_access(char*file,DArray *tokens, size_t * index, ParsedValue * to_access);
+
+void free_parse_access(void *ptr);
+
+#endif // ACCESS_H

src/parser/assignable/assign/assign.c

@@ -0,0 +1,40 @@
+#include "assign.h"
+#include "../../../lexer/token.h"
+#include "../../parser.h"
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "../../../memory.h"
+
+ParsedValue *parse_assign(char *file, DArray *tokens,
+                          ParsedValue *assign_to, size_t *index) {
+  Token *token = darray_get(tokens, *index);
+  switch (assign_to->type) {
+    case AST_IDENTIFIER:
+    case AST_ASSIGN:
+      break;
+    default:
+      fprintf(stderr, "%s:%u:%u error: can't assign to %s\n", file, token->line,
+              token->column, ValueTypeNames[assign_to->type]);
+      exit(EXIT_FAILURE);
+  }
+  ParsedAssign *assign = checked_malloc(sizeof(ParsedAssign));
+  assign->to = assign_to;
+  assign->type = token->type;
+  (*index)++;
+  error_if_finished(file,tokens,index);
+  token = darray_get(tokens, *index);
+  assign->from = parse_token(file, tokens, index, true);
+  ParsedValue *parsedValue = checked_malloc(sizeof(ParsedValue));
+  parsedValue->type = AST_ASSIGN;
+  parsedValue->data = assign;
+  return parsedValue;
+}
+
+void free_parse_assign(void *ptr) {
+  ParsedValue *parsedValue = ptr;
+  ParsedAssign *parsedAssign = parsedValue->data;
+  free_parsed(parsedAssign->to);
+  free_parsed(parsedAssign->from);
+  free(parsedAssign);
+}

src/parser/assignable/assign/assign.h

@@ -0,0 +1,17 @@
+#ifndef ASSIGN_H
+#define ASSIGN_H
+#include "../../parser.h"
+#include "../../../lexer/token.h"
+
+typedef struct {
+  ParsedValue * to;
+  TokenType type;
+  ParsedValue * from;
+} ParsedAssign;
+
+ParsedValue *parse_assign(char*file, DArray *tokens,
+                          ParsedValue *assign_to, size_t *index);
+
+void free_parse_assign(void*ptr);
+
+#endif // ASSIGN_H

src/parser/assignable/call/call.c

@@ -0,0 +1,59 @@
+#include "call.h"
+#include "../../../lexer/token.h"
+#include "../../../memory.h"
+#include "../../parser.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+ParsedValue *parse_call(char *file, DArray *tokens, size_t *index,
+                        ParsedValue *to_call) {
+  (*index)++;
+  error_if_finished(file, tokens, index);
+  ParsedValue *parsedValue = checked_malloc(sizeof(ParsedValue));
+  ParsedCall *parsedCall = checked_malloc(sizeof(ParsedCall));
+  DArray *args = checked_malloc(sizeof(DArray));
+  darray_init(args, sizeof(ParsedValue));
+  parsedCall->to_call = to_call;
+  parsedCall->args = args;
+  parsedValue->type = AST_ACCESS;
+  parsedValue->data = parsedCall;
+  Token *token = darray_get(tokens, *index);
+  DArray *arg = checked_malloc(sizeof(DArray));
+  darray_init(arg, sizeof(ParsedValue));
+  while (true) {
+    bool to_break = false;
+    switch (token->type) {
+    case TOKEN_RPAREN:
+      to_break = true;
+      break;
+    default:
+      break;
+    }
+    if (to_break)
+      break;
+    ParsedValue *parsedValue = parse_token(file, tokens, index, true);
+    darray_push(arg, parsedValue);
+    switch (token->type) {
+    case TOKEN_COMMA:
+      darray_push(args, arg);
+      arg = checked_malloc(sizeof(DArray));
+      darray_init(arg, sizeof(ParsedValue));
+      break;
+    default:
+      break;
+    }
+  }
+  return parsedValue;
+}
+
+void free_parse_call(void *ptr) {
+  ParsedValue *parsedValue = ptr;
+  ParsedCall *parsedCall = parsedValue->data;
+
+  free_parsed(parsedCall->to_call);
+
+  
+
+  free(parsedCall);
+}

src/parser/assignable/call/call.h

@@ -0,0 +1,16 @@
+#ifndef CALL_H
+#define CALL_H
+#include "../../parser.h"
+#include "../../../lexer/token.h"  // for Token
+
+typedef struct {
+  ParsedValue * to_call;
+  DArray * args;
+} ParsedCall;
+
+// Function declaration for parsing an identifier
+ParsedValue *parse_call(char *file, DArray *tokens, size_t *index,
+                        ParsedValue *to_call);
+void free_parse_call(void *ptr);
+
+#endif // CALL_H

src/parser/assignable/identifier/identifier.c

@@ -0,0 +1,12 @@
+#include "identifier.h"
+#include "../../../lexer/token.h"
+#include "../../parser.h"
+#include <string.h>
+#include "../../../memory.h"
+
+ParsedValue *parse_identifier(Token *token) {
+  ParsedValue *parsedValue = checked_malloc(sizeof(ParsedValue));
+  parsedValue->type = AST_IDENTIFIER;
+  parsedValue->data = strcpy(checked_malloc(sizeof(token->value)), token->value);
+  return parsedValue;
+}

src/parser/assignable/identifier/identifier.h

@@ -0,0 +1,11 @@
+// parser.h
+
+#ifndef IDENTIFIER_H
+#define IDENTIFIER_H
+#include "../../parser.h"
+#include "../../../lexer/token.h"  // for Token
+
+// Function declaration for parsing an identifier
+ParsedValue * parse_identifier(Token * token);
+
+#endif // IDENTIFIER_H