aboutsummaryrefslogtreecommitdiff
path: root/src/compiler/tree_parser/tree_parser.h
blob: 8a9f7b50cfc7b14d7766e2a7e15cdba0b82e73c7 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
#pragma once

#include <compiler/parser/parser.h>
#include <stdint.h>

typedef enum TreeToken {
  TREE_TOKEN_NONE = 0,
  TREE_TOKEN_ROOT,
  TREE_TOKEN_GLOBAL_SCOPE,
  TREE_TOKEN_LOCAL_SCOPE,
  TREE_TOKEN_FUNCTION_CALL,
  TREE_TOKEN_DEFINE_VARIABLE,
  TREE_TOKEN_DEFINE_CONSTANT,
  TREE_TOKEN_IDENTIFIER,
  TREE_TOKEN_VALUE_STRING,
  TREE_TOKEN_STRUCT,
  TREE_TOKEN_FUNCTION,
} TreeToken;

extern const char *TREE_TOKEN_STRINGS[];

typedef struct ParsedTree {
  char const *strBegin;
  char const *strEnd;
  TreeToken token;
  void *metadata;
} ParsedTree;

typedef struct TreeStructMetadata {
} TreeStructMetadata;

typedef ParsedTree *TypeId;

typedef struct TreeDefineVariableMetadata {
  char const *nameBegin;
  char const *nameEnd;
  TypeId type;
  ParsedTree *value;
  ParsedTree *tree;
} TreeDefineVariableMetadata;

typedef struct TreeFunctionCallMetadata {
  TreeDefineVariableMetadata *function;
  ParsedTree **values;
  size_t values_size;
} TreeFunctionCallMetadata;

typedef struct TreeScopeMetadata {
  ParsedTree **lines;
  size_t lines_size;
  TreeDefineVariableMetadata **variables;
  size_t variables_size;
} TreeScopeMetadata;

typedef struct TreeIdentifierMetadata {
  TreeDefineVariableMetadata *variable;
} TreeIdentifierMetadata;

typedef struct TreeFunctionMetadata {
  TreeDefineVariableMetadata **params;
  size_t params_size;
  TreeScopeMetadata *scope;
  TypeId returnType;
} TreeFunctionMetadata;

typedef SizedString TreeStringValueMetadata;

extern void _printParsedTreeNode(const ParsedTree *parsedTree, int indent);
extern void printParsedTreeNode(const ParsedTree *parsedTree);

extern void deleteParsedTree(ParsedTree *parsedTree);

extern ParsedTree *treeParser(SourceCode *code);
extern ParsedTree *_treeParser(const ParsedNode *node, SourceCode *code);

extern ParsedTree *treeParseNode(const ParsedNode *node, SourceCode *code,
                                 TreeScopeMetadata *scopes[],
                                 size_t scopes_size);

extern ParsedTree *treeParseRoot(const ParsedNode *root, SourceCode *code);
extern ParsedTree *treeParseLocalScope(const ParsedNode *node, SourceCode *code,
                                       TreeScopeMetadata *scopes[],
                                       size_t scopes_size);

extern TreeDefineVariableMetadata *treeParseDefineVariable(
    ParsedTree *tree, const ParsedNode *node, SourceCode *code,
    TreeScopeMetadata *scopes[], size_t scopes_size);
extern TreeDefineVariableMetadata *getVariable(
    const char *strBegin, const char *strEnd, SourceCode *code,
    TreeScopeMetadata *scopes[], size_t scopes_size);
extern ParsedTree *treeParseIdentifier(const ParsedNode *node, SourceCode *code,
                                       TreeScopeMetadata *scopes[],
                                       size_t scopes_size);
extern ParsedTree *treeParseFunctionCall(const ParsedNode *node,
                                         SourceCode *code,
                                         TreeScopeMetadata *scopes[],
                                         size_t scopes_size);
extern ParsedTree *treeParseValueString(const ParsedNode *node,
                                        SourceCode *code);
extern ParsedTree *treeParseVariableDefinition(
    const ParsedNode *node, SourceCode *code, TreeScopeMetadata *scopes[],
    size_t scopes_size, TreeToken token);
extern ParsedTree *treeParseStruct(const ParsedNode *node, SourceCode *code,
                                   TreeScopeMetadata *scopes[],
                                   size_t scopes_size);
extern ParsedTree *treeParseFunction(const ParsedNode *node, SourceCode *code,
                                     TreeScopeMetadata *scopes[],
                                     size_t scopes_size);
extern ParsedTree *treeParseImport(const ParsedNode *node, SourceCode *code,
                                   TreeScopeMetadata *scopes[],
                                   size_t scopes_size);

extern TypeId getTreeExpressionType(ParsedTree *const tree);
extern TypeId getType(const TreeDefineVariableMetadata *define);
extern bool isType(ParsedTree *const tree);
extern SizedString *nodeToString(ParsedNode const *node, SourceCode *code);
extern uint64_t hexToInt(char const*begin,char const*end,bool *isRight);

extern void pushVariableToScope(TreeScopeMetadata *scope,TreeDefineVariableMetadata *variable);
extern void pushLineToScope(TreeScopeMetadata *scope,ParsedTree *line);