Zinc
/
sync
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: Zinc:9bc67d4268d0e94327523670cd133803d0a145a3
Branches Tags
Zinc:master
..
compare: Zinc:68c114ce1d022bbec450dcdd85ed60e24cd04aba
Branches Tags
Zinc:master

No commits in common. "9bc67d4268d0e94327523670cd133803d0a145a3" and "68c114ce1d022bbec450dcdd85ed60e24cd04aba" have entirely different histories.
9bc67d4268 ... 68c114ce1d

5 changed files with 70 additions and 141 deletions
Show Stats Expand all files Collapse all files

14
include/sync/lexer.h
View File

@ -35,25 +35,15 @@ typedef struct {
size_t line;
} Lexer;
typedef struct TokenResult {
typedef struct {
SyncResultType type;
union {
Token result;
SyncError error;
};
struct TokenResult* next;
} TokenResult;
typedef struct {
SyncResultType type;
union {
struct TokenResult* result;
GeneralError error;
};
} LexerResult;
void lexer_init(Lexer* lexer, const char* filename, const char* source);
LexerResult lexical_analysis(Lexer* lexer);
void clean_token_result(TokenResult* head);
TokenResult lexer_next(Lexer* lexer);
#endif // SYNC_LEXER_H

21
include/sync/types.h
View File

@ -3,11 +3,6 @@
#include <stddef.h>
typedef struct {
const char *message;
int code;
} GeneralError;
typedef struct {
const char *filename;
size_t line;
@ -17,9 +12,9 @@ typedef struct {
} FileInfo;
typedef enum {
SYNC_LEXICAL_ERROR,
SYNC_SYNTACTICAL_ERROR,
SYNC_SEMANTICAL_ERROR
SYNC_LEXER_ERROR,
SYNC_PARSER_ERROR,
SYNC_RUNTIME_ERROR
} SyncErrorType;
typedef struct {
@ -29,8 +24,16 @@ typedef struct {
} SyncError;
typedef enum {
SYNC_ERROR,
SYNC_RESULT,
SYNC_ERROR,
} SyncResultType;
// typedef struct {
// SyncResultType type;
// union {
// void *result;
// SyncError error;
// };
// } SyncResult;
#endif // SYNC_TYPES_H

74
src/lexer.c
View File

@ -1,6 +1,5 @@
#include <ctype.h>
#include <string.h>
#include <stdlib.h>
#include "sync/types.h"
#include "sync/lexer.h"
@ -79,32 +78,20 @@ static char is_identifier_char(char c) {
return isalnum(c) || c == '_';
}
static LexerResult lexer_result(Lexer* lexer, TokenType type, size_t start, size_t start_line) {
TokenResult* result = (TokenResult*)malloc(sizeof(TokenResult));
if (result == NULL)
return (LexerResult){SYNC_ERROR, .error = (GeneralError){"Failed to allocate memory.", 1}};
result->type = SYNC_RESULT;
result->result.type = type;
result->result.start = &lexer->source[start];
result->result.length = lexer->pos - start;
result->result.file_info = get_file_info(lexer, start, start_line);
result->next = NULL;
return (LexerResult){SYNC_RESULT, .result = result};
static TokenResult lexer_result(Lexer* lexer, TokenType type, size_t start, size_t start_line) {
return (TokenResult){SYNC_RESULT, .result = (Token){
type,
&lexer->source[start],
lexer->pos - start,
get_file_info(lexer, start, start_line)
}};
}
static LexerResult lexer_error(Lexer* lexer, const char* message, size_t start, size_t start_line) {
TokenResult* result = (TokenResult*)malloc(sizeof(TokenResult));
if (result == NULL)
return (LexerResult){SYNC_ERROR, .error = (GeneralError){"Failed to allocate memory.", 1}};
result->type = SYNC_ERROR;
result->error.type = SYNC_LEXICAL_ERROR;
result->error.message = message;
result->error.file_info = get_file_info(lexer, start, start_line);
result->next = NULL;
return (LexerResult){SYNC_RESULT, .result = result};
static TokenResult lexer_error(Lexer* lexer, const char* message, size_t start, size_t start_line) {
return (TokenResult){SYNC_ERROR, .error = (SyncError){SYNC_LEXER_ERROR, message, get_file_info(lexer, start, start_line)}};
}
static LexerResult lexer_next(Lexer* lexer) {
TokenResult lexer_next(Lexer* lexer) {
// Gets the next token from the source
while (isspace(peek(lexer)) || peek(lexer) == '/') {
@ -203,7 +190,7 @@ static LexerResult lexer_next(Lexer* lexer) {
if (peek(lexer) == '=') advance(lexer);
return lexer_result(lexer, TOKEN_OPERATOR, start, start_line);
case '-':
if (peek(lexer) == '=' || peek(lexer) == '>') advance(lexer);
if (peek(lexer) == '=') advance(lexer);
return lexer_result(lexer, TOKEN_OPERATOR, start, start_line);
case '*':
if (peek(lexer) == '=') advance(lexer);
@ -223,42 +210,3 @@ static LexerResult lexer_next(Lexer* lexer) {
default: return lexer_error(lexer, "Unknown token", start, start_line);
}
}
LexerResult lexical_analysis(Lexer *lexer) {
LexerResult result;
TokenResult* head = NULL;
TokenResult* current = NULL;
do {
if (head == NULL) {
result = lexer_next(lexer);
if (result.type == SYNC_ERROR) {
clean_token_result(head);
return result;
}
head = result.result;
current = head;
} else {
result = lexer_next(lexer);
if (result.type == SYNC_ERROR) {
clean_token_result(head);
return result;
}
current->next = result.result;
current = current->next;
}
if (current == NULL) {
clean_token_result(head);
return (LexerResult){SYNC_ERROR, .error = (GeneralError){"Unknown Error.", 1}};
}
} while (current->type != SYNC_ERROR && current->result.type != TOKEN_EOF);
return (LexerResult){SYNC_RESULT, .result = head};
}
void clean_token_result(TokenResult* head) {
while (head != NULL) {
TokenResult* temp = head;
head = head->next;
free(temp);
}
}

32
src/main.c
View File

@ -40,31 +40,21 @@ int main(void) {
Lexer lexer;
lexer_init(&lexer, filename, source);
LexerResult lexer_result = lexical_analysis(&lexer);
if (lexer_result.type == SYNC_ERROR) {
fprintf(stderr, "Error: %s\n", lexer_result.error.message);
free(source);
return lexer_result.error.code;
}
TokenResult* token_result = lexer_result.result;
int error_count = 0;
while (token_result != NULL) {
if (token_result->type == SYNC_ERROR) {
fprintf(stderr, "Error: %s\n", token_result->error.message);
fprintf(stderr, "\tFilename: %s\n", token_result->error.file_info.filename);
fprintf(stderr, "\tLn: %zi, Col: %zi\n", token_result->error.file_info.line, token_result->error.file_info.column);
clean_token_result(lexer_result.result);
TokenResult result;
do {
result = lexer_next(&lexer);
if (result.type == SYNC_RESULT) {
print_token(result.result);
} else {
fprintf(stderr, "Error: %s\n", result.error.message);
fprintf(stderr, "\tFilename: %s\n", result.error.file_info.filename);
fprintf(stderr, "\tLine: %zi\n", result.error.file_info.line);
fprintf(stderr, "\tColumn: %zi\n", result.error.file_info.column);
free(source);
return 1;
} else {
print_token(token_result->result);
}
token_result = token_result->next;
}
} while (result.type != SYNC_ERROR && result.result.type != TOKEN_EOF);
clean_token_result(lexer_result.result);
free(source);
return 0;
}

70
test/test_lexer.c
View File

@ -4,56 +4,54 @@
#include "../include/sync/types.h"
#include "../include/sync/lexer.h"
// TODO: Update Tests
void test_tokenize_simple_assignment(void) {
const char* src = "x = 42;";
Lexer lexer;
lexer_init(&lexer, "<stdin>", src);
// void test_tokenize_simple_assignment(void) {
// const char* src = "x = 42;";
// Lexer lexer;
// lexer_init(&lexer, "<stdin>", src);
TokenResult t = lexer_next(&lexer);
assert(t.type == SYNC_RESULT && t.result.type == TOKEN_IDENTIFIER && strncmp(t.result.start, "x", t.result.length) == 0);
// TokenResult t = lexer_next(&lexer);
// assert(t.type == SYNC_RESULT && t.result.type == TOKEN_IDENTIFIER && strncmp(t.result.start, "x", t.result.length) == 0);
t = lexer_next(&lexer);
assert(t.type == SYNC_RESULT && t.result.type == TOKEN_OPERATOR && strncmp(t.result.start, "=", t.result.length) == 0);
// t = lexer_next(&lexer);
// assert(t.type == SYNC_RESULT && t.result.type == TOKEN_OPERATOR && strncmp(t.result.start, "=", t.result.length) == 0);
t = lexer_next(&lexer);
assert(t.type == SYNC_RESULT && t.result.type == TOKEN_NUMBER && strncmp(t.result.start, "42", t.result.length) == 0);
// t = lexer_next(&lexer);
// assert(t.type == SYNC_RESULT && t.result.type == TOKEN_NUMBER && strncmp(t.result.start, "42", t.result.length) == 0);
t = lexer_next(&lexer);
assert(t.type == SYNC_RESULT && t.result.type == TOKEN_SEMICOLON);
// t = lexer_next(&lexer);
// assert(t.type == SYNC_RESULT && t.result.type == TOKEN_SEMICOLON);
t = lexer_next(&lexer);
assert(t.type == SYNC_RESULT && t.result.type == TOKEN_EOF);
}
// t = lexer_next(&lexer);
// assert(t.type == SYNC_RESULT && t.result.type == TOKEN_EOF);
// }
void test_tokenize_function_call(void) {
const char* src = "print(x);";
Lexer lexer;
lexer_init(&lexer, "<stdin>", src);
// void test_tokenize_function_call(void) {
// const char* src = "print(x);";
// Lexer lexer;
// lexer_init(&lexer, "<stdin>", src);
TokenResult t = lexer_next(&lexer);
assert(t.type == SYNC_RESULT && t.result.type == TOKEN_IDENTIFIER && strncmp(t.result.start, "print", t.result.length) == 0);
// TokenResult t = lexer_next(&lexer);
// assert(t.type == SYNC_RESULT && t.result.type == TOKEN_IDENTIFIER && strncmp(t.result.start, "print", t.result.length) == 0);
t = lexer_next(&lexer);
assert(t.type == SYNC_RESULT && t.result.type == TOKEN_LPAREN);
// t = lexer_next(&lexer);
// assert(t.type == SYNC_RESULT && t.result.type == TOKEN_LPAREN);
t = lexer_next(&lexer);
assert(t.type == SYNC_RESULT && t.result.type == TOKEN_IDENTIFIER && strncmp(t.result.start, "x", t.result.length) == 0);
// t = lexer_next(&lexer);
// assert(t.type == SYNC_RESULT && t.result.type == TOKEN_IDENTIFIER && strncmp(t.result.start, "x", t.result.length) == 0);
t = lexer_next(&lexer);
assert(t.type == SYNC_RESULT && t.result.type == TOKEN_RPAREN);
// t = lexer_next(&lexer);
// assert(t.type == SYNC_RESULT && t.result.type == TOKEN_RPAREN);
t = lexer_next(&lexer);
assert(t.type == SYNC_RESULT && t.result.type == TOKEN_SEMICOLON);
// t = lexer_next(&lexer);
// assert(t.type == SYNC_RESULT && t.result.type == TOKEN_SEMICOLON);
// t = lexer_next(&lexer);
// assert(t.type == SYNC_RESULT && t.result.type == TOKEN_EOF);
// }
t = lexer_next(&lexer);
assert(t.type == SYNC_RESULT && t.result.type == TOKEN_EOF);
}
int main(void) {
// test_tokenize_simple_assignment();
// test_tokenize_function_call();
test_tokenize_simple_assignment();
test_tokenize_function_call();
printf("All lexer tests passed.\n");
return 0;