aboutsummaryrefslogtreecommitdiff
path: root/src/compiler/tree_parser/tree_parser.h
blob: 0ee783fb0f6b5ef2cdf19d6f206b0f9d9d0eb92f (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
#pragma once

#include <compiler/parser/parser.h>

#include "utils/types.h"

typedef enum TreeToken {
  TREE_TOKEN_NONE = 0,
  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,
                                 const TreeScopeMetadata *scopes[],
                                 size_t scopes_size);

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

extern TreeDefineVariableMetadata *treeParseDefineVariable(
    ParsedTree *tree, const ParsedNode *node, SourceCode code,
    const TreeScopeMetadata *scopes[], size_t scopes_size);
extern TreeDefineVariableMetadata *getVariable(
    const char *strBegin, const char *strEnd, SourceCode code,
    const TreeScopeMetadata *scopes[], size_t scopes_size);
extern ParsedTree *treeParseIdentifier(const ParsedNode *node, SourceCode code,
                                       const TreeScopeMetadata *scopes[],
                                       size_t scopes_size);
extern ParsedTree *treeParseFunctionCall(const ParsedNode *node,
                                         SourceCode code,
                                         const TreeScopeMetadata *scopes[],
                                         size_t scopes_size);
extern ParsedTree *treeParseValueString(const ParsedNode *node,
                                        SourceCode code);
extern ParsedTree *treeParseVariableDefinition(
    const ParsedNode *node, SourceCode code, const TreeScopeMetadata *scopes[],
    size_t scopes_size, TreeToken token);
extern ParsedTree *treeParseStruct(const ParsedNode *node, SourceCode code,
                                   const TreeScopeMetadata *scopes[],
                                   size_t scopes_size);
extern ParsedTree *treeParseFunction(const ParsedNode *node, SourceCode code,
                                     const 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 *tree, SourceCode code);