From e3e3423185a6e2285e504ce1588a12d544b8c7c7 Mon Sep 17 00:00:00 2001 From: Billy Date: Sat, 11 Jun 2022 09:12:13 +0000 Subject: [PATCH 01/12] Fixed usage of NumberExpression --- bagel/codeanalysis/literal_expression_syntax.py | 2 +- bagel/codeanalysis/syntaxkind.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/bagel/codeanalysis/literal_expression_syntax.py b/bagel/codeanalysis/literal_expression_syntax.py index 685374c..6965bc5 100644 --- a/bagel/codeanalysis/literal_expression_syntax.py +++ b/bagel/codeanalysis/literal_expression_syntax.py @@ -9,7 +9,7 @@ def __init__(self, literal_token: SyntaxToken): @property def kind(self) -> SyntaxKind: - return SyntaxKind.NumberExpression + return SyntaxKind.LiteralExpression def get_children(self) -> list: return [self.literal_token] diff --git a/bagel/codeanalysis/syntaxkind.py b/bagel/codeanalysis/syntaxkind.py index bea2e3c..5990ac7 100644 --- a/bagel/codeanalysis/syntaxkind.py +++ b/bagel/codeanalysis/syntaxkind.py @@ -15,6 +15,6 @@ class SyntaxKind(enum.Enum): CloseParenthesisToken = 9 # Expressions - NumberExpression = 10 + LiteralExpression = 10 BinaryExpression = 11 ParenthesizedExpression = 12 From e12ad497f7e3fdc599afc6de964879ef7304ca30 Mon Sep 17 00:00:00 2001 From: Billy Date: Sat, 11 Jun 2022 11:53:06 +0000 Subject: [PATCH 02/12] Some lexer cleanup --- .../__pycache__/evaluator.cpython-310.pyc | Bin 1549 -> 1552 bytes .../__pycache__/lexer.cpython-310.pyc | Bin 2198 -> 2190 bytes .../literal_expression_syntax.cpython-310.pyc | Bin 0 -> 1157 bytes .../__pycache__/parser.cpython-310.pyc | Bin 3339 -> 3354 bytes .../__pycache__/syntaxkind.cpython-310.pyc | Bin 677 -> 678 bytes bagel/codeanalysis/evaluator.py | 2 +- bagel/codeanalysis/lexer.py | 48 +++++++++--------- bagel/codeanalysis/parser.py | 8 +-- 8 files changed, 30 insertions(+), 28 deletions(-) create mode 100644 bagel/codeanalysis/__pycache__/literal_expression_syntax.cpython-310.pyc diff --git a/bagel/codeanalysis/__pycache__/evaluator.cpython-310.pyc b/bagel/codeanalysis/__pycache__/evaluator.cpython-310.pyc index 359b515179a6a52bff620b30eb6cec97dd107880..8cada84183a6cdf563923777d00503f4173a3ba8 100644 GIT binary patch delta 64 zcmeC>nZU!F&&$ij00ezCOOj4csWX} zLhL}Hqfnt65Frkr&@G6NxNr?a7DEb03PUqXFauCICs6J^RJjf-?`B)p*Nj}uIjI#A zK&y-6CR?%_GO;jCE?}2XSd&&$ij00f%0OOk9h^2V{SrLbf(70sMn%A&wk!;r<6!Up87n>-)JWe0K( zPd>?_U;>uq0CI2CFt9LWF{H4XGcYm4Gn6owuw)4XWf@X9QW%<9f*HUnIe{wQPL^d= zU;%MA+p@l96y(ZFttg2v$_%V+?`lq%f&j+^v^*(iff#(Dy~K^==_)pdX^& z5Fy5!Hct6X5!rYoT8J>No?T?6)Tz3UuxhJ1z)On>Svm;Wv_9Z6MC1lGj3YN=wu8|Q zk`BL9+;=L^NOh$H%-u0fC4b)ye-wIV7U@Kq;rnzd)$r2lNg-sKr)p&~Gu)pe4+L^! z85}HDRmgdkXC>zi0z!x)Sid;&pus-53bZVjI-gK;_Chu-`y_%{vTGPKO(*vq?c%5E zJvey>x``3{pjx#k(VJmY>5+d3Q{b$hKd7wRJ)p$XI6|!6uxmCwAOTCEeu9Dfm&Q|B z^2xVM2`%#uCRjp3Sid}V`EkK%5JU!n_)mr=P>%ty$a)kcwSIN#R&_j9qkfCJn5T2e zc@=R!FT_%j9drJDnW{RX=?~B`sw!OQVj*?8vOUpV+VfOqO8t~_2<;Iw)C5gE(LO2) z8lom-9dO((bX>U71bk0&8jD%Rd3ioqsB(ZKXz{wzOJA2hNjC9 Lc`=J2hBNmc+Wrf` literal 0 HcmV?d00001 diff --git a/bagel/codeanalysis/__pycache__/parser.cpython-310.pyc b/bagel/codeanalysis/__pycache__/parser.cpython-310.pyc index f117d0433c69bcab2fb21cb53252accd15987a4a..c25486053ccd9bdf999b0710698a8dfe9389adae 100644 GIT binary patch delta 833 zcmZXS&u-H|5XNzACmTCPNl@CvqUUhY3R((r1PVVt> zk-~4z^=?!vT{nTSBXWz6GvIlyE`?e}z@OucX|Ij!K? z>gKtLP21RH5RW3*ExyLI8edfB!y`+eh8-L0$Lg~{Tls%#NWHnTPUz!v@9L_a!(~c4 zPqMB=21D}?njswX`{9YTkQkOhnsE@j(iz6NfEFFvaU%4n%}=IFT*85Lp6m4db$#|}uP_y9yDYen z;qJN-K}2!YjlV=UZ&mlMT#Nedi&Ik#q3WO@CcY{G&y2QKL%nixs3f&9 z0X|hz1eOG0rAZd?D2e5CHBl)qP87zV$NRh2r9Pu3PqVazQcZjAJ?=rq;Hskgnxw{8 zSr)pyA536qu6EV;RfLn0euFa@z=~wSB&ZYE1mrC&!!#b7ZMWb7KbiM$E|KC-P$AX- z1|`o#HGcyeroggHeimM_a87ku!pq6+UY{qBXIaB9R_h)m1|ttF8b5 diff --git a/bagel/codeanalysis/__pycache__/syntaxkind.cpython-310.pyc b/bagel/codeanalysis/__pycache__/syntaxkind.cpython-310.pyc index dcf560e872ffb4e48d96571571832b2d2831b2b6..3146493188b15d560ee8dd83ee35eb7fffe829d9 100644 GIT binary patch delta 127 zcmZ3=x{Q@KpO=@50SL@vmL%0pP3~cm0ss$7DB1u3 diff --git a/bagel/codeanalysis/evaluator.py b/bagel/codeanalysis/evaluator.py index 8ec1f9c..c777f25 100644 --- a/bagel/codeanalysis/evaluator.py +++ b/bagel/codeanalysis/evaluator.py @@ -14,7 +14,7 @@ def evaluate(self) -> int: def evaluate_expression(self, node: ExpressionSyntax) -> int: if type(node) is LiteralExpressionSyntax: - return int(node.number_token.value) + return int(node.literal_token.value) if type(node) is BinaryExpressionSyntax: left = self.evaluate_expression(node.left) diff --git a/bagel/codeanalysis/lexer.py b/bagel/codeanalysis/lexer.py index 813f40d..49ff815 100644 --- a/bagel/codeanalysis/lexer.py +++ b/bagel/codeanalysis/lexer.py @@ -7,7 +7,7 @@ def __init__(self, text: str): self._text = text self._position = 0 self._diagnostics = [] - + @property def diagnostics(self) -> list: return self._diagnostics @@ -21,7 +21,7 @@ def current(self) -> str: def next(self) -> None: self._position += 1 - def next_token(self) -> SyntaxToken: + def lex(self) -> SyntaxToken: if self._position >= len(self._text): return SyntaxToken(SyntaxKind.EndOfFileToken, self._position, '\0', None) @@ -30,7 +30,7 @@ def next_token(self) -> SyntaxToken: while self.current.isdigit(): self.next() - + length = self._position - start text = self._text[start:length + start] try: @@ -44,30 +44,32 @@ def next_token(self) -> SyntaxToken: while self.current.isspace(): self.next() - + length = self._position - start text = self._text[start:length + start] return SyntaxToken(SyntaxKind.WhiteSpaceToken, start, text, None) - if self.current == '+': - self._position += 1 - return SyntaxToken(SyntaxKind.PlusToken, self._position, '+', None) - elif self.current == '-': - self._position += 1 - return SyntaxToken(SyntaxKind.MinusToken, self._position, '-', None) - elif self.current == '*': - self._position += 1 - return SyntaxToken(SyntaxKind.StarToken, self._position, '*', None) - elif self.current == '/': - self._position += 1 - return SyntaxToken(SyntaxKind.SlashToken, self._position, '/', None) - elif self.current == '(': - self._position += 1 - return SyntaxToken(SyntaxKind.OpenParenthesisToken, self._position, '(', None) - elif self.current == ')': - self._position += 1 - return SyntaxToken(SyntaxKind.CloseParenthesisToken, self._position, ')', None) + match self.current: + case '+': + self._position += 1 + return SyntaxToken(SyntaxKind.PlusToken, self._position, '+', None) + case '-': + self._position += 1 + return SyntaxToken(SyntaxKind.MinusToken, self._position, '-', None) + case '*': + self._position += 1 + return SyntaxToken(SyntaxKind.StarToken, self._position, '*', None) + case '/': + self._position += 1 + return SyntaxToken(SyntaxKind.SlashToken, self._position, '/', None) + case '(': + self._position += 1 + return SyntaxToken(SyntaxKind.OpenParenthesisToken, self._position, '(', None) + case ')': + self._position += 1 + return SyntaxToken(SyntaxKind.CloseParenthesisToken, self._position, ')', None) self._diagnostics.append(f"ERROR: bad character input: '{self.current}'") self._position += 1 - return SyntaxToken(SyntaxKind.BadToken, self._position, self._text[self._position - 1:1], None) \ No newline at end of file + return SyntaxToken( + SyntaxKind.BadToken, self._position, self._text[self._position - 1:1], None) diff --git a/bagel/codeanalysis/parser.py b/bagel/codeanalysis/parser.py index 8dbb22d..87fe28b 100644 --- a/bagel/codeanalysis/parser.py +++ b/bagel/codeanalysis/parser.py @@ -15,12 +15,12 @@ def __init__(self, text: str): self._tokens = [] lexer = Lexer(text) - token = lexer.next_token() + token = lexer.lex() self._tokens.append(token) while token.kind != SyntaxKind.EndOfFileToken: - token = lexer.next_token() + token = lexer.lex() if token.kind not in [SyntaxKind.WhiteSpaceToken, SyntaxKind.BadToken]: self._tokens.append(token) @@ -89,6 +89,6 @@ def parse_primary_expression(self) -> ExpressionSyntax: right = self.match_token(SyntaxKind.CloseParenthesisToken) return ParenthesizedExpressionSyntax(left, expression, right) - number_token = self.match_token(SyntaxKind.NumberToken) - return LiteralExpressionSyntax(number_token) + literal_token = self.match_token(SyntaxKind.NumberToken) + return LiteralExpressionSyntax(literal_token) From 39d7e779f352fe7e7d5d00ac3ee16945d973daab Mon Sep 17 00:00:00 2001 From: Billy Date: Sat, 11 Jun 2022 12:08:28 +0000 Subject: [PATCH 03/12] Data-driven operator precedence --- .../__pycache__/parser.cpython-310.pyc | Bin 3354 -> 3434 bytes bagel/codeanalysis/parser.py | 35 +++++++++--------- 2 files changed, 18 insertions(+), 17 deletions(-) diff --git a/bagel/codeanalysis/__pycache__/parser.cpython-310.pyc b/bagel/codeanalysis/__pycache__/parser.cpython-310.pyc index c25486053ccd9bdf999b0710698a8dfe9389adae..79e2c26bb15d56ea883e86ac28ea7e29f439c140 100644 GIT binary patch delta 773 zcmaJ;&ubGw6rMLbyV+lfCfzh?OaznExM=H-o1k7i2qHxcDC82-%v77&Bu*AY*^ooy zQ7_}klLb*cmi`C&7kCZo-CjHkLVdHL+LH_Ko9}(^+u8Ttz9}7)(t~u`CHUNW@oxRY zUU~vhRxhD>z03n)b0)GIjOY2{)NJL%0zVhpcNz@%9nU)%367Ts!77i zeuXjvMyhJQ%GL04nL!AtT-3a#KAB&=M9%8Gu0C3yp`o@@!^tc=>`2j%+CwS2f{T7v zbSavS9t#P>xQQ{kjS!Q!WS5MoqZ!1cM|;LDjE&fkx!8zd3uGQ^w5jV1oeWPi)*dsm zVj8p9+%d-Vi7Cs3m?TWiit3VAd@wuxP(;$m*ch-BD#F#P? zksfSO=>Y-4p*dG5D#4KgbIm}lf*zbbd5dAbJkNnRgd6y$*xC=>v((>`K0;{96dp6D zsrH;eeX|QJ1esM|oQ1VjEZo5ul@KUB2@Eoa4CtXx8TbjK$eu6X?Z}aktN&l1vfLrm z)KjLRb6{Po7)_Z*|S$bmEUCM?AN5gpyh6cUdnLmm; h(PnpBM2`ks>c-`Y`tBFhPp@hRCd~wpbM}{ffInm@qfr0= delta 721 zcmZuuzi-n}5cWOW$%`FZN}4ulXc$6TlBx}Ys#FYs5FvtgG|gLBr7{XbGHR-cVo6A9hkMa6YR}GGC#ocCv%D4WP=|VJ;{hQs6a)8G;tX)}VvK zU_A_Q2WwofoWnG;7QsD=A-|TOD!I7>gD3|N8?6#V+B@yNwhxikgPsWWo96(w^$*<$ys(;ey0=Kx2NWZAOhQRWkdTMcZ^PUxtn%8}zS#bfU4L(gZF-*CCDppDzBm_> z>WFh**uf|Ltzb8{yzS2LWx_9%;VmBUkFPhV_K54Z3HBx~$w~KBkF5bT)Mu+FTakv`#nk0Dk}wZjE{X diff --git a/bagel/codeanalysis/parser.py b/bagel/codeanalysis/parser.py index 87fe28b..b7b911e 100644 --- a/bagel/codeanalysis/parser.py +++ b/bagel/codeanalysis/parser.py @@ -51,7 +51,8 @@ def match_token(self, kind: SyntaxKind) -> SyntaxToken: if self.current.kind == kind: return self.next_token() - self._diagnostics.append(f"ERROR: Unexpected token <'{self.current.kind}'>, expected <{kind}>") + self._diagnostics.append( + f"ERROR: Unexpected token <'{self.current.kind}'>, expected <{kind}>") return SyntaxToken(kind, self.current.position, None, None) def parse(self) -> SyntaxTree: @@ -59,28 +60,29 @@ def parse(self) -> SyntaxTree: end_of_file_token = self.match_token(SyntaxKind.EndOfFileToken) return SyntaxTree(self._diagnostics, expression, end_of_file_token) - def parse_expression(self) -> ExpressionSyntax: - return self.parse_term() + def parse_expression(self, parent_precedence: int=0) -> ExpressionSyntax: + left = self.parse_primary_expression() - def parse_term(self) -> ExpressionSyntax: - left = self.parse_factor() + while True: + precedence = self.get_binary_operator_precedence(self.current.kind) + if not precedence or precedence <= parent_precedence: + break - while self.current.kind in [SyntaxKind.PlusToken, SyntaxKind.MinusToken]: operator_token = self.next_token() - right = self.parse_factor() + right = self.parse_expression(precedence) left = BinaryExpressionSyntax(left, operator_token, right) return left - def parse_factor(self) -> ExpressionSyntax: - left = self.parse_primary_expression() - - while self.current.kind in [SyntaxKind.StarToken, SyntaxKind.SlashToken]: - operator_token = self.next_token() - right = self.parse_primary_expression() - left = BinaryExpressionSyntax(left, operator_token, right) - - return left + @staticmethod + def get_binary_operator_precedence(kind: SyntaxKind) -> int: + match kind: + case SyntaxKind.StarToken | SyntaxKind.SlashToken: + return 2 + case SyntaxKind.PlusToken | SyntaxKind.MinusToken: + return 1 + case _: + return 0 def parse_primary_expression(self) -> ExpressionSyntax: if self.current.kind == SyntaxKind.OpenParenthesisToken: @@ -91,4 +93,3 @@ def parse_primary_expression(self) -> ExpressionSyntax: literal_token = self.match_token(SyntaxKind.NumberToken) return LiteralExpressionSyntax(literal_token) - From 5ee3464e23c5fb8900e3449dedd39a7862e16080 Mon Sep 17 00:00:00 2001 From: Billy Date: Sat, 11 Jun 2022 12:11:11 +0000 Subject: [PATCH 04/12] Move precedences to SyntaxFacts --- bagel/codeanalysis/parser.py | 13 ++----------- bagel/codeanalysis/syntaxfacts.py | 13 +++++++++++++ 2 files changed, 15 insertions(+), 11 deletions(-) create mode 100644 bagel/codeanalysis/syntaxfacts.py diff --git a/bagel/codeanalysis/parser.py b/bagel/codeanalysis/parser.py index b7b911e..a7d5431 100644 --- a/bagel/codeanalysis/parser.py +++ b/bagel/codeanalysis/parser.py @@ -6,6 +6,7 @@ from .syntaxkind import SyntaxKind from .syntaxtoken import SyntaxToken from .syntaxtree import SyntaxTree +from .syntaxfacts import SyntaxFacts class Parser: @@ -64,7 +65,7 @@ def parse_expression(self, parent_precedence: int=0) -> ExpressionSyntax: left = self.parse_primary_expression() while True: - precedence = self.get_binary_operator_precedence(self.current.kind) + precedence = SyntaxFacts.get_binary_operator_precedence(self.current.kind) if not precedence or precedence <= parent_precedence: break @@ -74,16 +75,6 @@ def parse_expression(self, parent_precedence: int=0) -> ExpressionSyntax: return left - @staticmethod - def get_binary_operator_precedence(kind: SyntaxKind) -> int: - match kind: - case SyntaxKind.StarToken | SyntaxKind.SlashToken: - return 2 - case SyntaxKind.PlusToken | SyntaxKind.MinusToken: - return 1 - case _: - return 0 - def parse_primary_expression(self) -> ExpressionSyntax: if self.current.kind == SyntaxKind.OpenParenthesisToken: left = self.next_token() diff --git a/bagel/codeanalysis/syntaxfacts.py b/bagel/codeanalysis/syntaxfacts.py new file mode 100644 index 0000000..0c36748 --- /dev/null +++ b/bagel/codeanalysis/syntaxfacts.py @@ -0,0 +1,13 @@ +from .syntaxkind import SyntaxKind + + +class SyntaxFacts: + @staticmethod + def get_binary_operator_precedence(kind: SyntaxKind) -> int: + match kind: + case SyntaxKind.StarToken | SyntaxKind.SlashToken: + return 2 + case SyntaxKind.PlusToken | SyntaxKind.MinusToken: + return 1 + case _: + return 0 From 4324d418928e32005991f8bee45c7744e485c9fc Mon Sep 17 00:00:00 2001 From: Billy Date: Sat, 11 Jun 2022 21:08:03 +0000 Subject: [PATCH 05/12] Unary operators --- .../__pycache__/evaluator.cpython-310.pyc | Bin 1552 -> 1784 bytes .../__pycache__/parser.cpython-310.pyc | Bin 3434 -> 3402 bytes .../__pycache__/syntaxfacts.cpython-310.pyc | Bin 0 -> 984 bytes .../__pycache__/syntaxkind.cpython-310.pyc | Bin 678 -> 706 bytes .../unary_expression_syntax.cpython-310.pyc | Bin 0 -> 1332 bytes bagel/codeanalysis/evaluator.py | 17 +++++++++--- bagel/codeanalysis/parser.py | 10 ++++++- bagel/codeanalysis/syntaxfacts.py | 8 ++++++ bagel/codeanalysis/syntaxkind.py | 5 ++-- bagel/codeanalysis/unary_expression_syntax.py | 25 ++++++++++++++++++ 10 files changed, 59 insertions(+), 6 deletions(-) create mode 100644 bagel/codeanalysis/__pycache__/syntaxfacts.cpython-310.pyc create mode 100644 bagel/codeanalysis/__pycache__/unary_expression_syntax.cpython-310.pyc create mode 100644 bagel/codeanalysis/unary_expression_syntax.py diff --git a/bagel/codeanalysis/__pycache__/evaluator.cpython-310.pyc b/bagel/codeanalysis/__pycache__/evaluator.cpython-310.pyc index 8cada84183a6cdf563923777d00503f4173a3ba8..be38d7adcb66ec27da748bcd285e0882c046f9b5 100644 GIT binary patch literal 1784 zcmZuxPjA~c6elIhmgGNmoixps70p#UB<+sFFcckv9kv+-ydK7jpqNY}N0vO2-V(#R z%)Rv^6a!XZmwu9c2VHmSR~UBKdz9rUn`Q9%@%PBbAKxDqyO`$@K?XSr4A4yUeg}@ZT+f zJ^VH`QYG0A)1w!OlDWB*I$cV!V?kIQ{7ssR2~ul*3?|QD=+8k&!l@wK5mdSt4u<75 z<4iE=!ORman6*S(x)x#f;*7VeOP9gfPf4~&Orc7qio#4B@K}GSCBdU7vXQ@}>9!yKWUXMo0sC$P|Z7x|3x4IKM4|Z(%8~{55(KB@I zsE%<~bm~so8kkws1N1ZC+XB4(j{bsne;Sx@+PQMnRZ=yp$3q+49 zE*sW&xarG1CdK5fyVgEO4_FuxrY zK5&+g&bAF#*KVT~Mv;$Am?twC$7LADvqCH~)Vp!~<08o_i^AGgNJ1T;*h7I~Y;d)# zv4>Ou0*A&R`lL_$?tyF3QPks~+DGA}`6!&&8fegpwS9tZy7*yL1v|_beSZHosP#5v x%Rj0M;Qw~468?DJe2#Z`uToYq+17-;#;#kJ{ufp3zQlJ)V>G%1GgJMB?!N$t%2@ya delta 814 zcmZva&x_MQ6vt;Klb=nqZFgyv3WB(Y+*a@+h(8b!7Pq*xryMMG6E*FmEt9EqAtKm4 z`-2=saKXcR^zRV7dC9@Q!=vw|KXwHZ=9`z#ym|S~oBXMMaJ@;j>JYfzWnZ8D&_8-t zdL4KRNk|1rXh12(Ot3@?v@+HNPxL@9V=j!u49qgtg_YQWP01q?8libYLUX|aC$zf6 zx4)n5Qp5p6GV}WE~uh2SgBY>huV-YXm`zZ;N6UTF<{0#rLWm4wjkDk z*+WNFhVF<-KVzBJB3-DrqE(L|G2LXol@9-}lt@TW*oEaFj5YicF!_?3LmXy0Nm z5!BBe_S56B8q6hrCb%qO70H3P@YAg4d46K-9xV5_Tr!Hsp~U8t_5Ww5ux=-la3-QV Q6w*?(=`QyNdu(Wb0fhpw7ytkO diff --git a/bagel/codeanalysis/__pycache__/parser.cpython-310.pyc b/bagel/codeanalysis/__pycache__/parser.cpython-310.pyc index 79e2c26bb15d56ea883e86ac28ea7e29f439c140..2a380126cd137f0646306c5ff0af209ead887027 100644 GIT binary patch delta 1627 zcmZux&2Jk;6yKTs^sc>eY$uJKrU`{m>{dxzwW5bmKopQT1W;OmR!CvvnIvv@*Y4~_ zN~Db$X*`|^)(H}cv8|Loxxuwoh`krtDH5RFl$M>N(0U11|KVlyxmHX|#x16yG$a^gx* zQP_^$*b6*`ov0euf||mW$d4z235DIL9#0073VTr_ZU#-Fy{ob1Dyto9tae0$7W3D% z?!+(neO*#a-AO{R|MuQU@H8C^lePUM3-=y8{-y_qUb%WF>}P2oFZ}ms!r~1W>0|jR zxkNhhK3TiaVJ+@3gHLW6Y>G`En?XaZC_BSuj*Xzn+F*TF&e8A96S^vhd_rGoTR;=& z5#KAUa5UlxD~z2%!bC+*=(nbQI4w*#i!WePB^OF3{xYeD< z8$>L^BoNH3aqih84c4x2ATVZS!s?jdvTccw@d14a4W5Xs1k=*v_*`+8dUyi z-MOwjvx@pC6e(Zlr!^sZXsv=`3WbLPKLaA!mY>@%PLG*06~l`B(Ox-pK+k~j7L2rP zg9Dmr4@s`wrFZp56(T-%cn#Z5ZPHJr$A*N=?C=QqL@G@T!GOD=C*jYzAHa- z+B0JjzX->If{^P@hX&{5vU{#0(5bFdW^);EVMKg03))CA^HJdsM_h#2P?S+GY_(2U z;6khQIpay67p53&ZD(T@B+%ZQFwzAO2JuN9GUXD;7nN4!h78@1WfMMA$pq)BJA!8_oA`37@={;*e_j>NN<3t{5xq-u&75w^Qp^ zs}6$St*?IG`qh0m)S3Q&L}6k{J_%}GRJ>QlpM#A5Dq!&y{{E#ESnN9EY|ZNp2E z6Ic9-;a23vRljO@IjY5VzmCx@6xe}tiUQ|^_>G{_MV@KD9> zXVhcdy)hHCMLA%id6xy_!Ne)|TVgDziz>*UHqMZGLM~4+@Z!@*9OR|mU?7qpXM151NK38Ln-dk-%{lA}>GQ0=Cz3}%cr(oSoBB4vxja zh@G4bgxFhD9e&fB(I>E6gpZun@UqL?+TNE^B$=na<{z)kYi%MgYDMi8xQWvUMov13 zILJ0lhAXO3TEtCtt@QmDMzyI8yrw~CD;pZh0C{=PPs1$iC(kS!%@NC$xR-736sF&V zQ>i}c;xe8iEv#0p&)zawmGZ`*CsVO04hB-BDOi=4v?ohLOM|UJhoFn5{;)1ijJV>) z!aM3e>-ts+^z_}n2mkZ~fFb$`Jw!*u)(j8PF4?6I@ev(T*&5Oz-otVn_DEOnGtgx4 z=npcWuHePgJRhdxlSFRlEG@$ime;{Ob2-g~>nHlz+hDl~7 zqnJ?B6=rTs51Vc_J^Z?MMm6Xlb2rU;S-2gGY^NWXa>*6F`63X*%%kFC6huFv#CA4D(bv^J?;nlkuYyy+ET04G18*{ E1DS4AGynhq diff --git a/bagel/codeanalysis/__pycache__/syntaxfacts.cpython-310.pyc b/bagel/codeanalysis/__pycache__/syntaxfacts.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..34de31c13c7bb6a88730871c819dc410829f1259 GIT binary patch literal 984 zcmaKqzi(495XXJC^ZNz0r~^W3H->a*1{MZ{Dv)46M2IkDv7BeOedOi6U^}8gZ0!br z221~?w=(5lU@3QgDN2iqC4X~wzIXP0a%I2YWw^fo_&Gi2jQt{KdkJ)oar*-l!wlqX z4ifj|HfXE?lLk$B=t!TqEW3**jcvZXV)pxwsY4DYt;Z;@B*|2m)O0T$CWK$2XaQj1) zZ%nelKEaH;4q!jy+UMx+);_Qf_J)^;(V9M8<3`6J9#(bU=S%;woY|u4zRQY@eFaY9 z=@oN5{Q3QK_@#6+ztE}m!3$c4xGK4 z2-H~uf$d`sf{I^B^q@mro0Xb4P|6m zOM-57K+R3F`v~?jc~@=N)>u;m8!Z*%}cY)$xf8| zywv&TB=JFqES=kMR+_pykrlzwbKEWojl`BvFOKGl=zD6k%{c4KoXo`JC?^MGaxkzku`pslW){ZD@l3J; P5Y=EUAVO+#50exC5M~>L delta 110 zcmX@ax{Q@KpO=@50SL@vmL%0piwmH`oxK;jmMO>TZlX-=vgBam0j0wg#X#Fznu9Tva< diff --git a/bagel/codeanalysis/__pycache__/unary_expression_syntax.cpython-310.pyc b/bagel/codeanalysis/__pycache__/unary_expression_syntax.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f066f57d5e8795f6a1e6cb2c24b7ba1a479baabb GIT binary patch literal 1332 zcmaJ=y>AmS6t{iO<$Ae%v;-j`!GKt@G%EuF1VRi*T>{H3)-`t8YcF@HeGyHRt&#Xg zSn}7fdu3wo#>9I*B~8|m|GD3c#vAsAL?_ir(AS97A zBV!s19<@P(8WElL)mcghVyXnM6&5Tk!%6(wtf6HPxNdTwQUs>rIWJIqC}v! z?(AF+y)C?`1E=HzY|{a;pbH|%f`J6&1G1tgJ!actCs|NAfDX@cqq33q;j*rSSP>n; z=g-^zw?bcVl<^L2c_^9Jr7nKbtJ}i|BkmB`u$p(AmTC+e hmBanB6;dp*Ro0 int: return self.evaluate_expression(self._root) def evaluate_expression(self, node: ExpressionSyntax) -> int: - if type(node) is LiteralExpressionSyntax: + if isinstance(node, LiteralExpressionSyntax): return int(node.literal_token.value) - if type(node) is BinaryExpressionSyntax: + if isinstance(node, UnaryExpressionSyntax): + operand = self.evaluate_expression(node.operand) + + if node.operator_token.kind == SyntaxKind.PlusToken: + return operand + if node.operator_token.kind == SyntaxKind.MinusToken: + return -operand + + raise Exception(f"Unexpected unary operator {node.operator_token.kind}") + + if isinstance(node, BinaryExpressionSyntax): left = self.evaluate_expression(node.left) right = self.evaluate_expression(node.right) @@ -31,7 +42,7 @@ def evaluate_expression(self, node: ExpressionSyntax) -> int: else: raise Exception(f"Unexpected binary operator {node.operator_token.kind}") - if type(node) is ParenthesizedExpressionSyntax: + if isinstance(node, ParenthesizedExpressionSyntax): return self.evaluate_expression(node.expression) raise Exception(f"Unexpected node {node.kind}") diff --git a/bagel/codeanalysis/parser.py b/bagel/codeanalysis/parser.py index a7d5431..5aacee8 100644 --- a/bagel/codeanalysis/parser.py +++ b/bagel/codeanalysis/parser.py @@ -1,3 +1,4 @@ +from bagel.codeanalysis.unary_expression_syntax import UnaryExpressionSyntax from .binary_expression_syntax import BinaryExpressionSyntax from .expression_syntax import ExpressionSyntax from .lexer import Lexer @@ -62,7 +63,14 @@ def parse(self) -> SyntaxTree: return SyntaxTree(self._diagnostics, expression, end_of_file_token) def parse_expression(self, parent_precedence: int=0) -> ExpressionSyntax: - left = self.parse_primary_expression() + left = None + unary_operator_precedence = SyntaxFacts.get_unary_operator_precedence(self.current.kind) + if unary_operator_precedence != 0 and unary_operator_precedence >= parent_precedence: + operator_token = self.next_token() + operand = self.parse_expression(unary_operator_precedence) + left = UnaryExpressionSyntax(operator_token, operand) + else: + left = self.parse_primary_expression() while True: precedence = SyntaxFacts.get_binary_operator_precedence(self.current.kind) diff --git a/bagel/codeanalysis/syntaxfacts.py b/bagel/codeanalysis/syntaxfacts.py index 0c36748..e6ed719 100644 --- a/bagel/codeanalysis/syntaxfacts.py +++ b/bagel/codeanalysis/syntaxfacts.py @@ -2,6 +2,14 @@ class SyntaxFacts: + @staticmethod + def get_unary_operator_precedence(kind: SyntaxKind) -> int: + match kind: + case SyntaxKind.PlusToken | SyntaxKind.MinusToken: + return 3 + case _: + return 0 + @staticmethod def get_binary_operator_precedence(kind: SyntaxKind) -> int: match kind: diff --git a/bagel/codeanalysis/syntaxkind.py b/bagel/codeanalysis/syntaxkind.py index 5990ac7..4cda465 100644 --- a/bagel/codeanalysis/syntaxkind.py +++ b/bagel/codeanalysis/syntaxkind.py @@ -16,5 +16,6 @@ class SyntaxKind(enum.Enum): # Expressions LiteralExpression = 10 - BinaryExpression = 11 - ParenthesizedExpression = 12 + UnaryExpression = 11 + BinaryExpression = 12 + ParenthesizedExpression = 13 diff --git a/bagel/codeanalysis/unary_expression_syntax.py b/bagel/codeanalysis/unary_expression_syntax.py new file mode 100644 index 0000000..cb54508 --- /dev/null +++ b/bagel/codeanalysis/unary_expression_syntax.py @@ -0,0 +1,25 @@ +from .expression_syntax import ExpressionSyntax +from .syntaxkind import SyntaxKind +from .syntaxtoken import SyntaxToken + + +class UnaryExpressionSyntax(ExpressionSyntax): + def __init__(self, operator_token: SyntaxToken, operand: ExpressionSyntax): + self._operator_token = operator_token + self._operand = operand + + @property + def kind(self) -> SyntaxKind: + return SyntaxKind.UnaryExpression + + def get_children(self) -> list: + # can be an array too + return [self.operator_token, self.operand] + + @property + def operator_token(self) -> SyntaxToken: + return self._operator_token + + @property + def operand(self) -> ExpressionSyntax: + return self._operand From 0a63b5519196872236270bd5bf23dd707ab476e9 Mon Sep 17 00:00:00 2001 From: Billy Date: Sat, 11 Jun 2022 21:25:07 +0000 Subject: [PATCH 06/12] Moved syntax APIs separate folder --- bagel/__init__.py | 2 +- bagel/__main__.py | 6 +++--- bagel/codeanalysis/evaluator.py | 13 +++++++------ .../{ => syntax}/binary_expression_syntax.py | 0 .../codeanalysis/{ => syntax}/expression_syntax.py | 0 bagel/codeanalysis/{ => syntax}/lexer.py | 0 .../{ => syntax}/literal_expression_syntax.py | 0 .../{ => syntax}/parenthesized_expression_syntax.py | 0 bagel/codeanalysis/{ => syntax}/parser.py | 2 +- bagel/codeanalysis/{ => syntax}/syntaxfacts.py | 0 bagel/codeanalysis/{ => syntax}/syntaxkind.py | 0 bagel/codeanalysis/{ => syntax}/syntaxnode.py | 0 bagel/codeanalysis/{ => syntax}/syntaxtoken.py | 0 bagel/codeanalysis/{ => syntax}/syntaxtree.py | 0 .../{ => syntax}/unary_expression_syntax.py | 0 15 files changed, 12 insertions(+), 11 deletions(-) rename bagel/codeanalysis/{ => syntax}/binary_expression_syntax.py (100%) rename bagel/codeanalysis/{ => syntax}/expression_syntax.py (100%) rename bagel/codeanalysis/{ => syntax}/lexer.py (100%) rename bagel/codeanalysis/{ => syntax}/literal_expression_syntax.py (100%) rename bagel/codeanalysis/{ => syntax}/parenthesized_expression_syntax.py (100%) rename bagel/codeanalysis/{ => syntax}/parser.py (97%) rename bagel/codeanalysis/{ => syntax}/syntaxfacts.py (100%) rename bagel/codeanalysis/{ => syntax}/syntaxkind.py (100%) rename bagel/codeanalysis/{ => syntax}/syntaxnode.py (100%) rename bagel/codeanalysis/{ => syntax}/syntaxtoken.py (100%) rename bagel/codeanalysis/{ => syntax}/syntaxtree.py (100%) rename bagel/codeanalysis/{ => syntax}/unary_expression_syntax.py (100%) diff --git a/bagel/__init__.py b/bagel/__init__.py index b794fd4..66a87bb 100644 --- a/bagel/__init__.py +++ b/bagel/__init__.py @@ -1 +1 @@ -__version__ = '0.1.0' +__version__ = '0.1.5' diff --git a/bagel/__main__.py b/bagel/__main__.py index 2dd41d0..d78960b 100644 --- a/bagel/__main__.py +++ b/bagel/__main__.py @@ -4,9 +4,9 @@ from colorama import Fore from .codeanalysis.evaluator import Evaluator -from .codeanalysis.syntaxnode import SyntaxNode -from .codeanalysis.syntaxtoken import SyntaxToken -from .codeanalysis.syntaxtree import SyntaxTree +from .codeanalysis.syntax.syntaxnode import SyntaxNode +from .codeanalysis.syntax.syntaxtoken import SyntaxToken +from .codeanalysis.syntax.syntaxtree import SyntaxTree colorama.init(autoreset=True) show_tree = False diff --git a/bagel/codeanalysis/evaluator.py b/bagel/codeanalysis/evaluator.py index b6ef357..bd5e954 100644 --- a/bagel/codeanalysis/evaluator.py +++ b/bagel/codeanalysis/evaluator.py @@ -1,9 +1,10 @@ -from bagel.codeanalysis.unary_expression_syntax import UnaryExpressionSyntax -from .binary_expression_syntax import BinaryExpressionSyntax -from .expression_syntax import ExpressionSyntax -from .literal_expression_syntax import LiteralExpressionSyntax -from .parenthesized_expression_syntax import ParenthesizedExpressionSyntax -from .syntaxkind import SyntaxKind +from .syntax.binary_expression_syntax import BinaryExpressionSyntax +from .syntax.expression_syntax import ExpressionSyntax +from .syntax.literal_expression_syntax import LiteralExpressionSyntax +from .syntax.parenthesized_expression_syntax import \ + ParenthesizedExpressionSyntax +from .syntax.syntaxkind import SyntaxKind +from .syntax.unary_expression_syntax import UnaryExpressionSyntax class Evaluator: diff --git a/bagel/codeanalysis/binary_expression_syntax.py b/bagel/codeanalysis/syntax/binary_expression_syntax.py similarity index 100% rename from bagel/codeanalysis/binary_expression_syntax.py rename to bagel/codeanalysis/syntax/binary_expression_syntax.py diff --git a/bagel/codeanalysis/expression_syntax.py b/bagel/codeanalysis/syntax/expression_syntax.py similarity index 100% rename from bagel/codeanalysis/expression_syntax.py rename to bagel/codeanalysis/syntax/expression_syntax.py diff --git a/bagel/codeanalysis/lexer.py b/bagel/codeanalysis/syntax/lexer.py similarity index 100% rename from bagel/codeanalysis/lexer.py rename to bagel/codeanalysis/syntax/lexer.py diff --git a/bagel/codeanalysis/literal_expression_syntax.py b/bagel/codeanalysis/syntax/literal_expression_syntax.py similarity index 100% rename from bagel/codeanalysis/literal_expression_syntax.py rename to bagel/codeanalysis/syntax/literal_expression_syntax.py diff --git a/bagel/codeanalysis/parenthesized_expression_syntax.py b/bagel/codeanalysis/syntax/parenthesized_expression_syntax.py similarity index 100% rename from bagel/codeanalysis/parenthesized_expression_syntax.py rename to bagel/codeanalysis/syntax/parenthesized_expression_syntax.py diff --git a/bagel/codeanalysis/parser.py b/bagel/codeanalysis/syntax/parser.py similarity index 97% rename from bagel/codeanalysis/parser.py rename to bagel/codeanalysis/syntax/parser.py index 5aacee8..b19af23 100644 --- a/bagel/codeanalysis/parser.py +++ b/bagel/codeanalysis/syntax/parser.py @@ -1,4 +1,4 @@ -from bagel.codeanalysis.unary_expression_syntax import UnaryExpressionSyntax +from .unary_expression_syntax import UnaryExpressionSyntax from .binary_expression_syntax import BinaryExpressionSyntax from .expression_syntax import ExpressionSyntax from .lexer import Lexer diff --git a/bagel/codeanalysis/syntaxfacts.py b/bagel/codeanalysis/syntax/syntaxfacts.py similarity index 100% rename from bagel/codeanalysis/syntaxfacts.py rename to bagel/codeanalysis/syntax/syntaxfacts.py diff --git a/bagel/codeanalysis/syntaxkind.py b/bagel/codeanalysis/syntax/syntaxkind.py similarity index 100% rename from bagel/codeanalysis/syntaxkind.py rename to bagel/codeanalysis/syntax/syntaxkind.py diff --git a/bagel/codeanalysis/syntaxnode.py b/bagel/codeanalysis/syntax/syntaxnode.py similarity index 100% rename from bagel/codeanalysis/syntaxnode.py rename to bagel/codeanalysis/syntax/syntaxnode.py diff --git a/bagel/codeanalysis/syntaxtoken.py b/bagel/codeanalysis/syntax/syntaxtoken.py similarity index 100% rename from bagel/codeanalysis/syntaxtoken.py rename to bagel/codeanalysis/syntax/syntaxtoken.py diff --git a/bagel/codeanalysis/syntaxtree.py b/bagel/codeanalysis/syntax/syntaxtree.py similarity index 100% rename from bagel/codeanalysis/syntaxtree.py rename to bagel/codeanalysis/syntax/syntaxtree.py diff --git a/bagel/codeanalysis/unary_expression_syntax.py b/bagel/codeanalysis/syntax/unary_expression_syntax.py similarity index 100% rename from bagel/codeanalysis/unary_expression_syntax.py rename to bagel/codeanalysis/syntax/unary_expression_syntax.py From 28307b34ec8b3d6e48fb4cd334d9e06b10942f07 Mon Sep 17 00:00:00 2001 From: Billy Date: Thu, 16 Jun 2022 18:28:07 +0000 Subject: [PATCH 07/12] Fix enum names --- bagel/__pycache__/__init__.cpython-310.pyc | Bin 149 -> 149 bytes bagel/__pycache__/__main__.cpython-310.pyc | Bin 1452 -> 1473 bytes .../__pycache__/evaluator.cpython-310.pyc | Bin 1784 -> 1802 bytes bagel/codeanalysis/evaluator.py | 12 ++++---- .../binary_expression_syntax.cpython-310.pyc | Bin 0 -> 1512 bytes .../expression_syntax.cpython-310.pyc | Bin 0 -> 369 bytes .../syntax/__pycache__/lexer.cpython-310.pyc | Bin 0 -> 2179 bytes .../literal_expression_syntax.cpython-310.pyc | Bin 0 -> 1164 bytes ...thesized_expression_syntax.cpython-310.pyc | Bin 0 -> 1667 bytes .../syntax/__pycache__/parser.cpython-310.pyc | Bin 0 -> 3367 bytes .../__pycache__/syntaxfacts.cpython-310.pyc | Bin 0 -> 991 bytes .../__pycache__/syntaxkind.cpython-310.pyc | Bin 0 -> 687 bytes .../__pycache__/syntaxnode.cpython-310.pyc | Bin 0 -> 625 bytes .../__pycache__/syntaxtoken.cpython-310.pyc | Bin 0 -> 1333 bytes .../__pycache__/syntaxtree.cpython-310.pyc | Bin 0 -> 1317 bytes .../unary_expression_syntax.cpython-310.pyc | Bin 0 -> 1339 bytes .../syntax/binary_expression_syntax.py | 2 +- bagel/codeanalysis/syntax/lexer.py | 20 ++++++------- .../syntax/literal_expression_syntax.py | 2 +- .../syntax/parenthesized_expression_syntax.py | 2 +- bagel/codeanalysis/syntax/parser.py | 12 ++++---- bagel/codeanalysis/syntax/syntaxfacts.py | 6 ++-- bagel/codeanalysis/syntax/syntaxkind.py | 28 +++++++++--------- bagel/codeanalysis/syntax/syntaxnode.py | 2 +- .../syntax/unary_expression_syntax.py | 2 +- 25 files changed, 44 insertions(+), 44 deletions(-) create mode 100644 bagel/codeanalysis/syntax/__pycache__/binary_expression_syntax.cpython-310.pyc create mode 100644 bagel/codeanalysis/syntax/__pycache__/expression_syntax.cpython-310.pyc create mode 100644 bagel/codeanalysis/syntax/__pycache__/lexer.cpython-310.pyc create mode 100644 bagel/codeanalysis/syntax/__pycache__/literal_expression_syntax.cpython-310.pyc create mode 100644 bagel/codeanalysis/syntax/__pycache__/parenthesized_expression_syntax.cpython-310.pyc create mode 100644 bagel/codeanalysis/syntax/__pycache__/parser.cpython-310.pyc create mode 100644 bagel/codeanalysis/syntax/__pycache__/syntaxfacts.cpython-310.pyc create mode 100644 bagel/codeanalysis/syntax/__pycache__/syntaxkind.cpython-310.pyc create mode 100644 bagel/codeanalysis/syntax/__pycache__/syntaxnode.cpython-310.pyc create mode 100644 bagel/codeanalysis/syntax/__pycache__/syntaxtoken.cpython-310.pyc create mode 100644 bagel/codeanalysis/syntax/__pycache__/syntaxtree.cpython-310.pyc create mode 100644 bagel/codeanalysis/syntax/__pycache__/unary_expression_syntax.cpython-310.pyc diff --git a/bagel/__pycache__/__init__.cpython-310.pyc b/bagel/__pycache__/__init__.cpython-310.pyc index cef0f46217a04a96385e364fdd2dcd0bf620bffc..36768bb3f680ac1a6af72f537c775dba4f31a09a 100644 GIT binary patch delta 24 ecmbQrIF*q*pO=@50SIoCte(hi%xF5%J`4au#0BjD delta 24 ecmbQrIF*q*pO=@50SKn=TsV>2n9*ROeHZ{kJq6+b diff --git a/bagel/__pycache__/__main__.cpython-310.pyc b/bagel/__pycache__/__main__.cpython-310.pyc index 686f4d5a135e15512652c3bb3049334c199b5681..200cf741c5da5af78b822e0951dbf8520bd8efa1 100644 GIT binary patch delta 123 zcmZ3(eUO_spO=@50SIoCtWHwc$m_)tFPEI3lA4&8m{VDtS*%xFnOBln0j2VQGDWOF a)lu@e6_w;?r{)#0fmC5LYV$%CZbks-IVx8G delta 102 zcmX@ey@s1NpO=@50SH?6E==Oy$m_-8C7zt0lA4&8m{VDtS*%xFnOBlnkp~niVg)LT YlE5NclAoQLSHuRAM$x=^8w)oh0DNU3ng9R* diff --git a/bagel/codeanalysis/__pycache__/evaluator.cpython-310.pyc b/bagel/codeanalysis/__pycache__/evaluator.cpython-310.pyc index be38d7adcb66ec27da748bcd285e0882c046f9b5..17faf7e759038ced698169054b93ab42a5f960fc 100644 GIT binary patch delta 689 zcmZ`$O;6iE5Z(1xY{zzGqC#6FKtdqpl4DN@B?kmmA$%AvdjJ{MfWI~!9tfGxd!yKi>p&FqtVh^GSIlTRx zFW`}Bi86PHyZLY2#MOLK*=|AUx>D4lA0g|7S#%Kf&v}%laks;(pkeNag}eX36Ra?w zn@p1FFIM+Zyd&*kYBtS+re0nt&vY< z)Yy0v#`>&-7cy7sEY2bxvNzIb5Vlx`<=4jCPdN&|JQ*)%affm_@|p6y_l_(1M9{-q bEf?le(xp8XEn^Xp!W10jVEHQ!o>2b*!HA|R delta 648 zcmZuuJ#W)M820(&Vmq-(QW}ClN>QhP6p4S(R;rkQR)K+As!Q%@t(@)X?4V?z8QQ6x zs$1FG0cON+=-Syopi=(<0|S09p+o{pe*D>3n(Hsjm_K2r>Mfh=*RFUz@U@r4c4d$Jgq{jTd(XHNr zc^4Jy?-MF#yVJ4cSr(;9f0pEQdWRNjYbRRD7hgtd1ATQN)Hg$h>IQ8gUp37A?JCro z#Tx%a#f0YkfZw~xn)Z=F`H(F!6p)fcS}mVJu%7N zr6ZmY|8$>M zzib0M0eA{fW^F7JLs;1?p{`y!^SJ}Bb$}MY8UUy(Gk)~!v50amsrXL| ghL(;>@y3hA=nJb+lrRZ-bdG;wt6SW0Pz^P$-+MWoh5!Hn diff --git a/bagel/codeanalysis/evaluator.py b/bagel/codeanalysis/evaluator.py index bd5e954..51b985b 100644 --- a/bagel/codeanalysis/evaluator.py +++ b/bagel/codeanalysis/evaluator.py @@ -21,9 +21,9 @@ def evaluate_expression(self, node: ExpressionSyntax) -> int: if isinstance(node, UnaryExpressionSyntax): operand = self.evaluate_expression(node.operand) - if node.operator_token.kind == SyntaxKind.PlusToken: + if node.operator_token.kind == SyntaxKind.PLUSTOKEN: return operand - if node.operator_token.kind == SyntaxKind.MinusToken: + if node.operator_token.kind == SyntaxKind.MINUSTOKEN: return -operand raise Exception(f"Unexpected unary operator {node.operator_token.kind}") @@ -32,13 +32,13 @@ def evaluate_expression(self, node: ExpressionSyntax) -> int: left = self.evaluate_expression(node.left) right = self.evaluate_expression(node.right) - if node.operator_token.kind == SyntaxKind.PlusToken: + if node.operator_token.kind == SyntaxKind.PLUSTOKEN: return left + right - elif node.operator_token.kind == SyntaxKind.MinusToken: + elif node.operator_token.kind == SyntaxKind.MINUSTOKEN: return left - right - elif node.operator_token.kind == SyntaxKind.StarToken: + elif node.operator_token.kind == SyntaxKind.STARTOKEN: return left * right - elif node.operator_token.kind == SyntaxKind.SlashToken: + elif node.operator_token.kind == SyntaxKind.SLASHTOKEN: return left / right else: raise Exception(f"Unexpected binary operator {node.operator_token.kind}") diff --git a/bagel/codeanalysis/syntax/__pycache__/binary_expression_syntax.cpython-310.pyc b/bagel/codeanalysis/syntax/__pycache__/binary_expression_syntax.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bc81c5aaab26a3e15ae50e7d7003b420ffe40175 GIT binary patch literal 1512 zcma)6OHbQC5Z;IFn8XQzQdFr(Jybp9LarRDic%qjDy0?fq4i~DvYTLV>~z;r3Ca!r z4C+7fwWprB_0rC)6$BxXy3&kib|yRDyplJYbpq$_WtjTrR0c6N4hsex{6-&$dg`3Ih~*c%6KnzChYf_tBJ*|s-LxdGX1mfHtO7VGI^ zGNqHMK~c8yvC?soYf)eprK^+SS<%N*&JW5A=mU`11~#KJBFKyZr!x+mNfMG<+UxMr z753S6vGA@Z?86LwU$Vij8lwRA3Eb^?&@ zu%;fndbt7-`aMB`p)86v2s3hy1l>4iLq5mD7iz0F!F3TuFjR%;pCzf(D#N!7qG_|M z*DKIG^nZeCUYk3t4WgQ3p&B=K83GG(3ysKD76FH8WjKw)ST%v_#;QO#0WZ*K1HD<1 z-{W!pzmV9)rMclq@7#ynSrO7MM6c7rVa?)^5~8dNG0Np6ML7`S`y@^)i^le7+(eDt zD*drW#KqJOpMHjSPMVlPKS!U(+x4LNxMdpWP`kj;&2F?$wkdPlw8fdzri>$PQR~y| v)S`_iJ7)1j^=jd8QmZ9sR2TNIq(X~fmc=jqw^gR^aCi(>EFb|5=obG684pZ8 literal 0 HcmV?d00001 diff --git a/bagel/codeanalysis/syntax/__pycache__/expression_syntax.cpython-310.pyc b/bagel/codeanalysis/syntax/__pycache__/expression_syntax.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..035a5b246af31814dc167e52da34a39edd689a05 GIT binary patch literal 369 zcmY*Uy-vh140f6#s;Vb3@Bpk`$P1iK6%t~*f!n%7xh6s<(xfDJ;yT02AYKS%W#Sc> za1z9iC4aG<&!26(Sk!>_wtwB;;`<(xzgA+>q5BI236f|SNlysefGi|^21ylpqJ1ID z4YVg81Zgb^^=3AEaa>!e2CV$ENa@ghgP@=%60n_MdlAmAkCRj0@2vS&XlbZ8H)2$r zhnn-z%7cz^!}-HO==}2n?iAG$e0J>7x_du~L3ws1?v!TRgafW4jL@^+dFIoGO#KYx wxpFzpj-pn)+()ROB&o7)Xq(fI#AOq4se0(xv8+5oiXJ-%et3G7>98!R!OV%DAeV_Vd{8Z7=?-F*=Qps zVuKAXjEd?s%a_}!ErVnzqYh>Na?qNlIvDAW*&ZDP8dZ>4+uJF=aYKDT64XJ(Y(NHz5zBf{y88xAEbC%BVPICb|~z71kRItV59c!m1#qx;7&$ z_AT;Dc__ok)jmml!ylEKj-nErTL{X zJ9W;me3z2=GeV4EksVP2IbKqnx7n}!4m&bNc9I<%$8cmmXVJXL68EqPsIByKr+J}t zUg3NF-8jQn{3DCtB~$Sf(2_AWuc9epG$-WiA{yeO8_}R74*oA1Wp{?`zCERhU82k7 zD~d=}!O~Sw*b-S2rbZ*uM&zGUk+TYEUm-Jy{A((*tdN;2q=U$GDsoOCohxJ(k^fFb z&MRbABZb@LzkxKSoadIpxf+LSsz46EHdY|7D=G1wo)xLwm%pIkw|lmr%zVvn@XD$RS!&OoemF$>dLojtBRe6 zg0$kqmr2{kHnWrLs@|Mhn6+W>Zm+>kbg+mj@lQxfPzIM{&*cud=dMu(j(sN&9|1ov z@tZp(Fu4mw()a*%lzf2~(aI-ao{zG+m!QWgmqql~sOG8bNB(}`d8zAp`+YI&(K_#W zKM(!h#f}jtQWof7&Or7DflLllvlpVYghEv%RUD~mc#mXnTdG=7ub1@irM?xDmcuYE zs|4IAfoqiwwcDs#sjL4>UHqBr>yXoeg#PE+0~wm;A$7jiC-{c?tZLnPmWQ(OAHj&y AIRF3v literal 0 HcmV?d00001 diff --git a/bagel/codeanalysis/syntax/__pycache__/literal_expression_syntax.cpython-310.pyc b/bagel/codeanalysis/syntax/__pycache__/literal_expression_syntax.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..765cdff3fcc03035918c14933cc534c1d4fc51d7 GIT binary patch literal 1164 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 literal 0 HcmV?d00001 diff --git a/bagel/codeanalysis/syntax/__pycache__/syntaxkind.cpython-310.pyc b/bagel/codeanalysis/syntax/__pycache__/syntaxkind.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5ce63cd0b1e504b41071baf2d46711694f7e1996 GIT binary patch literal 687 zcmZXS&2G~`5XaXaN!E@Xrxzr8=sg#5MnVXuU1(I-w!Ddexma$-LZyyVVglsA30?;A zM!s^&D{$(Lohm_$<)8mEo}Jkpd*!+|Q|5g6ee+#o><>A|W-8~Ex~nq?!54*sz2NrU$ z(SknO;9wtIbYOrkcsPI|daBc~w&k|`oPE2xEpbitcMWt>27&gy>kztx9)S}q0-br+ zCpZLGAsn65JWb1NnWt%Or|EKqn}W2Hrk^%hv46uS{>3c15+QIAy>6BF_HsHCGWO3! z8|a7g>xoDjr?%o?E?a3|Ps2xT$(g^;uw~%O%XaA?ibWXvi3nTYI}ai$jshov>XrC` zco!!^%4rmWHxK>f{UJ~fC)0l;;58KvDZkkIsXBFozt6{CSL?g#K3n9~c#?g{i}6jv z#R~JR%!+MwTaBw`;`_&)8vL{S?V2V|vu^$m&P?6Z{<{o{aIMK58MT?0n`LbZ#U^yv XNUKg&xthOd=l_zvYegM6dty8QZzrD* literal 0 HcmV?d00001 diff --git a/bagel/codeanalysis/syntax/__pycache__/syntaxnode.cpython-310.pyc b/bagel/codeanalysis/syntax/__pycache__/syntaxnode.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7ba599d64098a9409d3526733f3e40ad79ea73e7 GIT binary patch literal 625 zcmZ`$y-ve05I#F;2~jE}7BMS_#=d_VSg-}#D8#|4!2Y&}@x`ANaPSQuQPno~3qB+FpJV#eSeB$w6_q_yBN zmv#hx>xaek*>DpGTS0DnGT0Z%DHHW NT+)^dA$o9Z{Qz}4gC+m~ literal 0 HcmV?d00001 diff --git a/bagel/codeanalysis/syntax/__pycache__/syntaxtoken.cpython-310.pyc b/bagel/codeanalysis/syntax/__pycache__/syntaxtoken.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1fbdbd48a62c31933d701b554ea2027a6f843710 GIT binary patch literal 1333 zcma)5J#X7E5G6%Qk!9I&8utTj|A2ua-ix9L+Mz=MFX^O(P(&tGB1~o5Rf9o9VEn9q9Der*`Grn*aB%ivnpa>Xk+dLl znox>sukhw9VU&Czl1Y9^BvDkA;l>fY0B~=Fd8zTg7 zAEs%*D3VY~5>Haaq^G!K$_IkrD3rboE_t%0Lb;{bktajhyW|%%>46`CAIU!K_uW1R zKb8ZxAG?STk)hmnk%5Z@5E;oG7a7V&Q2eg#w^e_tPE~37DHLzRMP>3jufVU>S#ABV zX|Yt955=wruAzFEZl=cF!_BM4 zgY7L=HWVT+^I8amHi#Nfd?I>2?(|@9on`~A>ZL9-yx#S|HBLPDH3Bu{1Wu@Xu$)kh z8oQ!;2rpM~YewkesbZMd*tWnsA9XpgGxzcs)aLP;rG*?r=syMd58ry7HUe=bGTHByHJW*M# zcQ70-bhS{rUO53+UgVJS1W7j)-nmRvx^|kui$~oU{2(OHsTYjska=uG+c~Bhb7t`G mM8>HemDCn=6DZ-&&c2nFscG%sDCQ4834}oLF zA3}SC6X)JIF|$sJ`#@r)ncbOqXTJG%CRMlFBCx*OZ%02EAwSV*E)K>4hJ1-h!N+f=0# z)mV)4LJ8~f2LN-m@C+=HHy~yQ)PgREAPWYXE;wi=$sxI>!-TtzXvPnPPp~B(WJm%R z7*&jQ2mv+Hqt`%P6WxXF_shZON}rl(Hd1ErIy+Xy;K=JyB~?~t#mwYpU_AHB%|dm1 z)0vBf$jjUcfk6$bh(@$U=i7f-*js($BCYJ1E=TyVtA%G2EcgZkEXWBIsAD)LRIkH! zO?3x054KhtXksyKkQ?MHV)LCw$_6k0%%(Rn$}$i3u--z2lr*v+q#nAqLCt%O9LVB7Fbq!(<#zOb)AXu^kj zIZ)C2OdF-4fugBD>8Ehnh2BWGeu9Y5rLh6;6Y>mvDE_rOET%D?_Z!H4lws1t-YBz) z62i5Fm{jr%8eTxpice=*vHT?{a$_|Xp|Ki`OuKlhtEtj7*>QC=sZw zJ3E&HZwW8zz$tkJ+iZfE(HRkB#y|q{KDng54zq2sa#>J0fDX@cqp~CI!(m+qaY=Lp zpFgj=-wJ(dM#(^#?#tv@W!*z32ZdBgo@5h~nyzsacgOeyp%%=G%KvyYv4Ie2o|Z!3 z-XQj?_E;e0Ka=vC7PJVPhl1?aE0{wYBIFHmeX%xne%alH4)1k1=Sl^dkp~B>pK`kF@3bY>dlGy zXI;IE7r72ljX(O@irD+R7<3iy|EFRudz~f@O`Z&u5H=KISjcgPdL+cxagtRLjiaQI zIo$$bgONta<;2Z_-bNqKQd8<3%(-p}Hf^OPx&}VXFnBB=+m!K5+VW5`Z-=^guT!^M uw?^C{uwgatI4#u}HY$hvbt|M;VyUb{;YKldT0QU?w$dPz5s7F-cf7xXye{Pc literal 0 HcmV?d00001 diff --git a/bagel/codeanalysis/syntax/binary_expression_syntax.py b/bagel/codeanalysis/syntax/binary_expression_syntax.py index ebe8098..eb5599a 100644 --- a/bagel/codeanalysis/syntax/binary_expression_syntax.py +++ b/bagel/codeanalysis/syntax/binary_expression_syntax.py @@ -11,7 +11,7 @@ def __init__(self, left: ExpressionSyntax, operator_token: SyntaxToken, right: E @property def kind(self) -> SyntaxKind: - return SyntaxKind.BinaryExpression + return SyntaxKind.BINARYEXPRESSION def get_children(self) -> list: # can be an array too diff --git a/bagel/codeanalysis/syntax/lexer.py b/bagel/codeanalysis/syntax/lexer.py index 49ff815..535eb3e 100644 --- a/bagel/codeanalysis/syntax/lexer.py +++ b/bagel/codeanalysis/syntax/lexer.py @@ -23,7 +23,7 @@ def next(self) -> None: def lex(self) -> SyntaxToken: if self._position >= len(self._text): - return SyntaxToken(SyntaxKind.EndOfFileToken, self._position, '\0', None) + return SyntaxToken(SyntaxKind.EOFTOKEN, self._position, '\0', None) if self.current.isdigit(): start = self._position @@ -37,7 +37,7 @@ def lex(self) -> SyntaxToken: value = int(text) except ValueError: self._diagnostics.append(f"The number {self._text} isn't a valid int.") - return SyntaxToken(SyntaxKind.NumberToken, start, text, value) + return SyntaxToken(SyntaxKind.NUMBERTOKEN, start, text, value) if self.current.isspace(): start = self._position @@ -47,29 +47,29 @@ def lex(self) -> SyntaxToken: length = self._position - start text = self._text[start:length + start] - return SyntaxToken(SyntaxKind.WhiteSpaceToken, start, text, None) + return SyntaxToken(SyntaxKind.WHITESPACETOKEN, start, text, None) match self.current: case '+': self._position += 1 - return SyntaxToken(SyntaxKind.PlusToken, self._position, '+', None) + return SyntaxToken(SyntaxKind.PLUSTOKEN, self._position, '+', None) case '-': self._position += 1 - return SyntaxToken(SyntaxKind.MinusToken, self._position, '-', None) + return SyntaxToken(SyntaxKind.MINUSTOKEN, self._position, '-', None) case '*': self._position += 1 - return SyntaxToken(SyntaxKind.StarToken, self._position, '*', None) + return SyntaxToken(SyntaxKind.STARTOKEN, self._position, '*', None) case '/': self._position += 1 - return SyntaxToken(SyntaxKind.SlashToken, self._position, '/', None) + return SyntaxToken(SyntaxKind.SLASHTOKEN, self._position, '/', None) case '(': self._position += 1 - return SyntaxToken(SyntaxKind.OpenParenthesisToken, self._position, '(', None) + return SyntaxToken(SyntaxKind.OPENPARENTOKEN, self._position, '(', None) case ')': self._position += 1 - return SyntaxToken(SyntaxKind.CloseParenthesisToken, self._position, ')', None) + return SyntaxToken(SyntaxKind.CLOSEPARENTOKEN, self._position, ')', None) self._diagnostics.append(f"ERROR: bad character input: '{self.current}'") self._position += 1 return SyntaxToken( - SyntaxKind.BadToken, self._position, self._text[self._position - 1:1], None) + SyntaxKind.BADTOKEN, self._position, self._text[self._position - 1:1], None) diff --git a/bagel/codeanalysis/syntax/literal_expression_syntax.py b/bagel/codeanalysis/syntax/literal_expression_syntax.py index 6965bc5..f56ac82 100644 --- a/bagel/codeanalysis/syntax/literal_expression_syntax.py +++ b/bagel/codeanalysis/syntax/literal_expression_syntax.py @@ -9,7 +9,7 @@ def __init__(self, literal_token: SyntaxToken): @property def kind(self) -> SyntaxKind: - return SyntaxKind.LiteralExpression + return SyntaxKind.LITERALEXPRESSION def get_children(self) -> list: return [self.literal_token] diff --git a/bagel/codeanalysis/syntax/parenthesized_expression_syntax.py b/bagel/codeanalysis/syntax/parenthesized_expression_syntax.py index d9f1b11..159ee5a 100644 --- a/bagel/codeanalysis/syntax/parenthesized_expression_syntax.py +++ b/bagel/codeanalysis/syntax/parenthesized_expression_syntax.py @@ -12,7 +12,7 @@ def __init__(self, open_parenthesis_token: SyntaxToken, expression: ExpressionSy @property def kind(self) -> SyntaxKind: - return SyntaxKind.ParenthesizedExpression + return SyntaxKind.PARENEXPRESSION def get_children(self) -> list: return [self.open_parenthesis_token, self.expression, self.close_parenthesis_token] diff --git a/bagel/codeanalysis/syntax/parser.py b/bagel/codeanalysis/syntax/parser.py index b19af23..b775579 100644 --- a/bagel/codeanalysis/syntax/parser.py +++ b/bagel/codeanalysis/syntax/parser.py @@ -21,10 +21,10 @@ def __init__(self, text: str): self._tokens.append(token) - while token.kind != SyntaxKind.EndOfFileToken: + while token.kind != SyntaxKind.EOFTOKEN: token = lexer.lex() - if token.kind not in [SyntaxKind.WhiteSpaceToken, SyntaxKind.BadToken]: + if token.kind not in [SyntaxKind.WHITESPACETOKEN, SyntaxKind.BADTOKEN]: self._tokens.append(token) self._diagnostics += lexer.diagnostics @@ -59,7 +59,7 @@ def match_token(self, kind: SyntaxKind) -> SyntaxToken: def parse(self) -> SyntaxTree: expression = self.parse_expression() - end_of_file_token = self.match_token(SyntaxKind.EndOfFileToken) + end_of_file_token = self.match_token(SyntaxKind.EOFTOKEN) return SyntaxTree(self._diagnostics, expression, end_of_file_token) def parse_expression(self, parent_precedence: int=0) -> ExpressionSyntax: @@ -84,11 +84,11 @@ def parse_expression(self, parent_precedence: int=0) -> ExpressionSyntax: return left def parse_primary_expression(self) -> ExpressionSyntax: - if self.current.kind == SyntaxKind.OpenParenthesisToken: + if self.current.kind == SyntaxKind.OPENPARENTOKEN: left = self.next_token() expression = self.parse_expression() - right = self.match_token(SyntaxKind.CloseParenthesisToken) + right = self.match_token(SyntaxKind.CLOSEPARENTOKEN) return ParenthesizedExpressionSyntax(left, expression, right) - literal_token = self.match_token(SyntaxKind.NumberToken) + literal_token = self.match_token(SyntaxKind.NUMBERTOKEN) return LiteralExpressionSyntax(literal_token) diff --git a/bagel/codeanalysis/syntax/syntaxfacts.py b/bagel/codeanalysis/syntax/syntaxfacts.py index e6ed719..fee7025 100644 --- a/bagel/codeanalysis/syntax/syntaxfacts.py +++ b/bagel/codeanalysis/syntax/syntaxfacts.py @@ -5,7 +5,7 @@ class SyntaxFacts: @staticmethod def get_unary_operator_precedence(kind: SyntaxKind) -> int: match kind: - case SyntaxKind.PlusToken | SyntaxKind.MinusToken: + case SyntaxKind.PLUSTOKEN | SyntaxKind.MINUSTOKEN: return 3 case _: return 0 @@ -13,9 +13,9 @@ def get_unary_operator_precedence(kind: SyntaxKind) -> int: @staticmethod def get_binary_operator_precedence(kind: SyntaxKind) -> int: match kind: - case SyntaxKind.StarToken | SyntaxKind.SlashToken: + case SyntaxKind.STARTOKEN | SyntaxKind.SLASHTOKEN: return 2 - case SyntaxKind.PlusToken | SyntaxKind.MinusToken: + case SyntaxKind.PLUSTOKEN | SyntaxKind.MINUSTOKEN: return 1 case _: return 0 diff --git a/bagel/codeanalysis/syntax/syntaxkind.py b/bagel/codeanalysis/syntax/syntaxkind.py index 4cda465..5d6038b 100644 --- a/bagel/codeanalysis/syntax/syntaxkind.py +++ b/bagel/codeanalysis/syntax/syntaxkind.py @@ -3,19 +3,19 @@ class SyntaxKind(enum.Enum): # Tokens - BadToken = 0 - EndOfFileToken = 1 - WhiteSpaceToken = 2 - NumberToken = 3 - PlusToken = 4 - MinusToken = 5 - StarToken = 6 - SlashToken = 7 - OpenParenthesisToken = 8 - CloseParenthesisToken = 9 + BADTOKEN = 0 + EOFTOKEN = 1 + WHITESPACETOKEN = 2 + NUMBERTOKEN = 3 + PLUSTOKEN = 4 + MINUSTOKEN = 5 + STARTOKEN = 6 + SLASHTOKEN = 7 + OPENPARENTOKEN = 8 + CLOSEPARENTOKEN = 9 # Expressions - LiteralExpression = 10 - UnaryExpression = 11 - BinaryExpression = 12 - ParenthesizedExpression = 13 + LITERALEXPRESSION = 10 + UNARYEXPRESSION = 11 + BINARYEXPRESSION = 12 + PARENEXPRESSION = 13 diff --git a/bagel/codeanalysis/syntax/syntaxnode.py b/bagel/codeanalysis/syntax/syntaxnode.py index 74e0583..25a7f46 100644 --- a/bagel/codeanalysis/syntax/syntaxnode.py +++ b/bagel/codeanalysis/syntax/syntaxnode.py @@ -4,7 +4,7 @@ class SyntaxNode: @property def kind(self): - return SyntaxKind.BadToken + return SyntaxKind.BADTOKEN def get_children(self): return [] diff --git a/bagel/codeanalysis/syntax/unary_expression_syntax.py b/bagel/codeanalysis/syntax/unary_expression_syntax.py index cb54508..651b816 100644 --- a/bagel/codeanalysis/syntax/unary_expression_syntax.py +++ b/bagel/codeanalysis/syntax/unary_expression_syntax.py @@ -10,7 +10,7 @@ def __init__(self, operator_token: SyntaxToken, operand: ExpressionSyntax): @property def kind(self) -> SyntaxKind: - return SyntaxKind.UnaryExpression + return SyntaxKind.UNARYEXPRESSION def get_children(self) -> list: # can be an array too From a45396429b935d8642ca2d3f5cd1d1f9fbcda8c9 Mon Sep 17 00:00:00 2001 From: Billy Date: Thu, 16 Jun 2022 18:37:31 +0000 Subject: [PATCH 08/12] Add declarations of properties --- bagel/codeanalysis/syntax/binary_expression_syntax.py | 4 ++++ bagel/codeanalysis/syntax/lexer.py | 3 +++ bagel/codeanalysis/syntax/literal_expression_syntax.py | 2 ++ bagel/codeanalysis/syntax/parenthesized_expression_syntax.py | 4 ++++ bagel/codeanalysis/syntax/parser.py | 2 ++ bagel/codeanalysis/syntax/syntaxtoken.py | 5 +++++ bagel/codeanalysis/syntax/syntaxtree.py | 4 ++++ bagel/codeanalysis/syntax/unary_expression_syntax.py | 3 +++ 8 files changed, 27 insertions(+) diff --git a/bagel/codeanalysis/syntax/binary_expression_syntax.py b/bagel/codeanalysis/syntax/binary_expression_syntax.py index eb5599a..5673829 100644 --- a/bagel/codeanalysis/syntax/binary_expression_syntax.py +++ b/bagel/codeanalysis/syntax/binary_expression_syntax.py @@ -4,6 +4,10 @@ class BinaryExpressionSyntax(ExpressionSyntax): + _left: ExpressionSyntax + _operator_token: SyntaxToken + _right: ExpressionSyntax + def __init__(self, left: ExpressionSyntax, operator_token: SyntaxToken, right: ExpressionSyntax): self._left = left self._operator_token = operator_token diff --git a/bagel/codeanalysis/syntax/lexer.py b/bagel/codeanalysis/syntax/lexer.py index 535eb3e..c049cb3 100644 --- a/bagel/codeanalysis/syntax/lexer.py +++ b/bagel/codeanalysis/syntax/lexer.py @@ -3,6 +3,9 @@ class Lexer: + _text: str + _diagnostics: list + def __init__(self, text: str): self._text = text self._position = 0 diff --git a/bagel/codeanalysis/syntax/literal_expression_syntax.py b/bagel/codeanalysis/syntax/literal_expression_syntax.py index f56ac82..37bc158 100644 --- a/bagel/codeanalysis/syntax/literal_expression_syntax.py +++ b/bagel/codeanalysis/syntax/literal_expression_syntax.py @@ -4,6 +4,8 @@ class LiteralExpressionSyntax(ExpressionSyntax): + _literal_token: SyntaxToken + def __init__(self, literal_token: SyntaxToken): self._literal_token = literal_token diff --git a/bagel/codeanalysis/syntax/parenthesized_expression_syntax.py b/bagel/codeanalysis/syntax/parenthesized_expression_syntax.py index 159ee5a..91792d6 100644 --- a/bagel/codeanalysis/syntax/parenthesized_expression_syntax.py +++ b/bagel/codeanalysis/syntax/parenthesized_expression_syntax.py @@ -4,6 +4,10 @@ class ParenthesizedExpressionSyntax(ExpressionSyntax): + _open_parenthesis_token: SyntaxToken + _expression: ExpressionSyntax + _close_parenthesis_token: SyntaxToken + def __init__(self, open_parenthesis_token: SyntaxToken, expression: ExpressionSyntax, close_parenthesis_token: SyntaxToken): self._open_parenthesis_token = open_parenthesis_token diff --git a/bagel/codeanalysis/syntax/parser.py b/bagel/codeanalysis/syntax/parser.py index b775579..50c15ee 100644 --- a/bagel/codeanalysis/syntax/parser.py +++ b/bagel/codeanalysis/syntax/parser.py @@ -11,6 +11,8 @@ class Parser: + _diagnostics: list + def __init__(self, text: str): self._diagnostics = [] self._position = 0 diff --git a/bagel/codeanalysis/syntax/syntaxtoken.py b/bagel/codeanalysis/syntax/syntaxtoken.py index 1dcb10a..99ff48a 100644 --- a/bagel/codeanalysis/syntax/syntaxtoken.py +++ b/bagel/codeanalysis/syntax/syntaxtoken.py @@ -3,6 +3,11 @@ class SyntaxToken(SyntaxNode): + _kind: SyntaxKind + _position: int + _text: str + _value: object + def __init__(self, kind: SyntaxKind, position: int, text: str, value: object): self._kind = kind self._position = position diff --git a/bagel/codeanalysis/syntax/syntaxtree.py b/bagel/codeanalysis/syntax/syntaxtree.py index fc91769..9a35d83 100644 --- a/bagel/codeanalysis/syntax/syntaxtree.py +++ b/bagel/codeanalysis/syntax/syntaxtree.py @@ -3,6 +3,10 @@ class SyntaxTree: + _diagnostics: list + _root: ExpressionSyntax + _end_of_file_token: SyntaxToken + def __init__(self, diagnostics: list, root: ExpressionSyntax, end_of_file_token: SyntaxToken): self._diagnostics = diagnostics self._root = root diff --git a/bagel/codeanalysis/syntax/unary_expression_syntax.py b/bagel/codeanalysis/syntax/unary_expression_syntax.py index 651b816..7f27740 100644 --- a/bagel/codeanalysis/syntax/unary_expression_syntax.py +++ b/bagel/codeanalysis/syntax/unary_expression_syntax.py @@ -4,6 +4,9 @@ class UnaryExpressionSyntax(ExpressionSyntax): + _operator_token: SyntaxToken + _operand: ExpressionSyntax + def __init__(self, operator_token: SyntaxToken, operand: ExpressionSyntax): self._operator_token = operator_token self._operand = operand From 31d0a9a0ab912e2108f9f685b5bc7a1151254241 Mon Sep 17 00:00:00 2001 From: Billy Date: Fri, 17 Jun 2022 10:43:07 +0000 Subject: [PATCH 09/12] Add binder --- bagel/__main__.py | 51 ++--- bagel/__pycache__/__main__.cpython-310.pyc | Bin 1473 -> 1626 bytes .../__pycache__/evaluator.cpython-310.pyc | Bin 1802 -> 1573 bytes .../__pycache__/binder.cpython-310.pyc | Bin 0 -> 7357 bytes bagel/codeanalysis/binding/binder.py | 183 ++++++++++++++++++ bagel/codeanalysis/evaluator.py | 63 +++--- .../binary_expression_syntax.cpython-310.pyc | Bin 1512 -> 1576 bytes .../syntax/__pycache__/lexer.cpython-310.pyc | Bin 2179 -> 2228 bytes .../literal_expression_syntax.cpython-310.pyc | Bin 1164 -> 1198 bytes ...thesized_expression_syntax.cpython-310.pyc | Bin 1667 -> 1731 bytes .../syntax/__pycache__/parser.cpython-310.pyc | Bin 3367 -> 3401 bytes .../__pycache__/syntaxtoken.cpython-310.pyc | Bin 1333 -> 1412 bytes .../__pycache__/syntaxtree.cpython-310.pyc | Bin 1317 -> 1482 bytes .../unary_expression_syntax.cpython-310.pyc | Bin 1339 -> 1388 bytes bagel/codeanalysis/syntax/syntaxtree.py | 4 +- 15 files changed, 233 insertions(+), 68 deletions(-) create mode 100644 bagel/codeanalysis/binding/__pycache__/binder.cpython-310.pyc create mode 100644 bagel/codeanalysis/binding/binder.py diff --git a/bagel/__main__.py b/bagel/__main__.py index d78960b..99bbcc3 100644 --- a/bagel/__main__.py +++ b/bagel/__main__.py @@ -3,13 +3,15 @@ import colorama from colorama import Fore -from .codeanalysis.evaluator import Evaluator -from .codeanalysis.syntax.syntaxnode import SyntaxNode -from .codeanalysis.syntax.syntaxtoken import SyntaxToken -from .codeanalysis.syntax.syntaxtree import SyntaxTree +from codeanalysis.binding.binder import Binder + +from codeanalysis.evaluator import Evaluator +from codeanalysis.syntax.syntaxnode import SyntaxNode +from codeanalysis.syntax.syntaxtoken import SyntaxToken +from codeanalysis.syntax.syntaxtree import SyntaxTree colorama.init(autoreset=True) -show_tree = False +SHOW_TREE = False def pretty_print(node: SyntaxNode, indent: str = "", is_last: bool = True): @@ -40,49 +42,30 @@ def pretty_print(node: SyntaxNode, indent: str = "", is_last: bool = True): while True: line = input("» ") - # ideas - # a = input("» ") - # a = input("› ") - # a = input("¶ ") - # a = input("~ ") - # a = input("⇝ ") - # a = input("⇢ ") - # a = input("⇻ ") - # a = input("⇾ ") - # a = input("∢ ") - # a = input("∝ ") - # a = input("⊱ ") - - # a = input("⊶ ") - # a = input("⊷ ") - # a = input("⊸ ") - - # a = input("⋉ ") - # a = input("⋯ ") - # a = input("⨊ ") - # a = input("⨭ ") - # a = input("⫻ ") - if line is None or line == "": break if line == "#showtree": - show_tree = not show_tree - print("Showing parser trees" if show_tree else "Not showing parser trees") + SHOW_TREE = not SHOW_TREE + print("Showing parser trees" if SHOW_TREE else "Not showing parser trees") continue elif line == "#cls": os.system('cls') continue syntax_tree = SyntaxTree.parse(line) + binder = Binder() + bound_expression = binder.bind_expression(syntax_tree.root) + + diagnostics = syntax_tree.diagnostics + binder.diagnostics - if show_tree: + if SHOW_TREE: pretty_print(syntax_tree.root) - if not len(syntax_tree.diagnostics) > 0: - evaluator = Evaluator(syntax_tree.root) + if not any(syntax_tree.diagnostics): + evaluator = Evaluator(bound_expression) result = evaluator.evaluate() - print(str(result)) + print(result) else: for _diagnostic in syntax_tree.diagnostics: print(Fore.RED + _diagnostic) diff --git a/bagel/__pycache__/__main__.cpython-310.pyc b/bagel/__pycache__/__main__.cpython-310.pyc index 200cf741c5da5af78b822e0951dbf8520bd8efa1..9775d227840162c67cdd16d245d777352fa80aa6 100644 GIT binary patch delta 614 zcmY*V&ubG=5PtJ^vw7KUHk+pHrlzq!?4=Y15j={Dl_Io-Rwz7a!zOPmyWJo5Z436) zLp*p9DYnd4@ShRx`FKl(b@t=_oH zaB{P?dd-v(8;L1RV2UX-t|XSUN?eJniIAeiR$NPLX_vSf*AquNz!0K_5~}tAh_|Jy zeC41}4QwhGz1Nm%D(_uIwrULLRBHsXjco;&EZ?PAKjV5|!Sx}dWR8+Px(<^r&ZDbe zsdfr#enf-MA5(pS>LIepf?AyZ<($bPwx=L{G)GK!urpagKe|OsmnIO3mWyt}-G9iB zdf172K9fD#@DW>uYIIzPZWHW{AfKXzU3%vVu1r>^Os-M;S}`VV6pCl;xF*+$l z_gVS8FXvA-JHLyM-P?qj`8?A|(Rv!D3iY=$xX+=F}p) z!%Sh22JuxM=Jy8F6sD(TM6HeSL-SMZaA*Ih|MFmad;HUUv?HxTgjzO>*vGeTH0F7j zr884!*@g55+2wz{_KH1q6$YnimS2R!d}ajc)%b4ZVDAN$1QXl=hm%2R+=Pz7mjrl( b1h>Eg4gzfQHf4p@rfZV7xhN|(C(W-vMct8! delta 449 zcmXAlu}{`* zK|z6xM4L1;lyr2w0VT>C@D_~2u4eb2e?I*y?by7Oq9hCh!RxL6_-9_v))8|@l;n^J<(IK-wkX4f}m4Ejs6X=A6SD8G~{7OAx0Ga^{|YU z3)hx?K^3eHz*eb>a4NDbzDvh4-A4E+SWmOwBXe$qH8f2o{e?3^ zID@mJPcInOs5$~$XF8!W)jP8VO$}Df0iZZm*(Iq@-?peV{4x@Dj?+V$8$iMK!h+op z`@U_nFFW7AQoA80k6xdwE;QeZFWOmvvD!>hdI#>F9$-mAIe&Am;9Gv6YWcmo^RxfS z+3$WzlrOt$&9O?8q(63I>e&(=9sKJhS^wxT%b(rd^)(LBLQ4atsA5Y6O-HsgR9XtO X^q>L~Gz5GGQpo@!E)5ZPJbC>9GtFUQ diff --git a/bagel/codeanalysis/__pycache__/evaluator.cpython-310.pyc b/bagel/codeanalysis/__pycache__/evaluator.cpython-310.pyc index 17faf7e759038ced698169054b93ab42a5f960fc..15a22645bf3488a7a63e8240d90911bc7ec44fa5 100644 GIT binary patch literal 1573 zcmZuxOK;mo5Z)!16h*xpKjNZkP@M|!VxdKkK@r;$0->%_R8ora!qD2aLzyC#CDp`+ za*6XVf&$GkK!4F*d+N1^9(wA`QdH@pE9_|Jo86gjXLgvjS}uX{*N?xQvl=14qf#9v zD34)gUxDC+)0ix%PZx%7EKJ{AFrO_f-&)wdP016&4Q{?8+`KjX8fRnTS$|MC=-KMv zBwZ!^BuYYgJ$Sv8BFmyQQHK@y=~BorPvy5!!c|8bDm(9M;4I2vQ(VFKH9q~1-(t5$ zt8QmN=FVWCJ%*X}K?vegPJClZgee%OkKjJSyns7#_Kx`$w}cIv&1<05xFbxBFka^_ zAP#T9jhm`I_&JPMcoSs>GEH;EP|gepQ4U<=JcXHI3D$H?0?6=~e550f$~s`4p;#v3 z3yB*(64`>kzrXCgO666y3}+(iorISn?wxBnOSuS>Fuu;BtS3qeN6TyF1VNNUc@Ut} z48ywgW_Qc-s5C2EihL!L8P=>ExW-qYnKoguCcna*(+_k^WCH-8xwnZY0QhMw8*>C*_O=PmU+Urz7Zu*E6xq zq0uG2I>lmf0e)q4`68ECMCBa!`$N6AF`k}GemFkWO8dL%*<|?r+3>V*9rUNdB@S&HZS%gV@sa2FZ74I3lFK9f7gA?iCs@bTH7)9h YrP8PVFN|^?73{ykrq7Uam+V^q0Gcv<2LJ#7 literal 1802 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 literal 0 HcmV?d00001 diff --git a/bagel/codeanalysis/binding/binder.py b/bagel/codeanalysis/binding/binder.py new file mode 100644 index 0000000..b82a268 --- /dev/null +++ b/bagel/codeanalysis/binding/binder.py @@ -0,0 +1,183 @@ +from enum import Enum +from typing import List + +from ..syntax.binary_expression_syntax import BinaryExpressionSyntax +from ..syntax.expression_syntax import ExpressionSyntax +from ..syntax.literal_expression_syntax import LiteralExpressionSyntax +from ..syntax.syntaxkind import SyntaxKind +from ..syntax.unary_expression_syntax import UnaryExpressionSyntax + + +class BoundNodeKind(Enum): + LITERALEXPRESSION = 0 + UNARYEXPRESSION = 1 + BINARYEXPRESSION = 2 + +class BoundNode: + _kind: BoundNodeKind + + @property + def kind(self) -> BoundNodeKind: + return self._kind + +class BoundExpression(BoundNode): + _type: object + + @property + def type(self): + return self._type + +class BoundUnaryOperatorKind(Enum): + IDENTITY = 0 + NEGATION = 1 + +class BoundLiteralExpression(BoundExpression): + _value: object + + def __init__(self, value: object): + self._value = value + + @property + def kind(self) -> BoundNodeKind: + return BoundNodeKind.LITERALEXPRESSION + + @property + def type(self): + return type(self._value) + + @property + def value(self): + return self._value + +class BoundUnaryExpression(BoundExpression): + _operator_kind: BoundUnaryOperatorKind + _operand: BoundExpression + + def __init__(self, operator_kind: BoundUnaryOperatorKind, operand: BoundExpression): + self._operator_kind = operator_kind + self._operand = operand + + @property + def kind(self) -> BoundNodeKind: + return BoundNodeKind.UNARYEXPRESSION + + @property + def type(self): + return self._operand.type + + @property + def operator_kind(self) -> BoundUnaryOperatorKind: + return self._operator_kind + + @property + def operand(self) -> BoundExpression: + return self._operand + +class BoundBinaryOperatorKind(Enum): + ADDITION = 0 + SUBTRACTION = 1 + MULTIPLICATION = 2 + DIVISION = 3 + +class BoundBinaryExpression(BoundExpression): + _left: BoundExpression + _operator_kind: BoundUnaryOperatorKind + _right: BoundExpression + + def __init__(self, left: BoundExpression, operator_kind: BoundBinaryOperatorKind, right: BoundExpression): + self._left = left + self._operator_kind = operator_kind + self._right = right + + @property + def kind(self) -> BoundNodeKind: + return BoundNodeKind.BINARYEXPRESSION + + @property + def type(self): + return self._left.type + + @property + def left(self) -> BoundExpression: + return self._left + + @property + def operator_kind(self) -> BoundUnaryOperatorKind: + return self._operator_kind + + @property + def right(self) -> BoundExpression: + return self._right + +class Binder: + _diagnostics: List[str] + + def __init__(self): + self._diagnostics = [] + + @property + def diagnostics(self) -> List[str]: + return self._diagnostics + + def bind_expression(self, syntax: ExpressionSyntax) -> BoundExpression: + match syntax.kind: + case SyntaxKind.LITERALEXPRESSION: + return self.bind_literal_expression(syntax) + case SyntaxKind.UNARYEXPRESSION: + return self.bind_unary_expression(syntax) + case SyntaxKind.BINARYEXPRESSION: + return self.bind_binary_expression(syntax) + case _: + raise Exception(f"Unexpected syntax {syntax.kind}") + + def bind_literal_expression(self, syntax: LiteralExpressionSyntax) -> BoundLiteralExpression: + value = syntax.literal_token.value or 0 + return BoundLiteralExpression(value) + + def bind_unary_expression(self, syntax: UnaryExpressionSyntax) -> BoundUnaryExpression: + bound_operand = self.bind_expression(syntax.operand) + bound_operator_kind = self.bind_unary_operator_kind(syntax.operator_token.kind, bound_operand.type) + + if bound_operator_kind is None: + self._diagnostics.append(f"Unary operator {syntax.operator_token.text} is not defined for type {bound_operand.type}.") + return bound_operand + + return BoundUnaryExpression(bound_operator_kind, bound_operand) + + def bind_binary_expression(self, syntax: BinaryExpressionSyntax) -> BoundBinaryExpression: + bound_left = self.bind_expression(syntax.left) + bound_right = self.bind_expression(syntax.right) + bound_operator_kind = self.bind_binary_operator_kind(syntax.operator_token.kind, bound_left.type, bound_right.type) + if bound_operator_kind is None: + self._diagnostics.append(f"Binary operator {syntax.operator_token.text} is not defined for types {bound_left.type} and {bound_right.type}.") + return bound_left + + return BoundBinaryExpression(bound_left, bound_operator_kind, bound_right) + + def bind_unary_operator_kind(self, kind: SyntaxKind, operand_type: int) -> BoundUnaryOperatorKind | None: + if operand_type != int: + return + + match kind: + case SyntaxKind.PLUSTOKEN: + return BoundUnaryOperatorKind.IDENTITY + case SyntaxKind.MINUSTOKEN: + return BoundUnaryOperatorKind.NEGATION + case _: + raise Exception(f"Unexpected unary operator kind {kind}") + + def bind_binary_operator_kind(self, kind: SyntaxKind, left_type: int, right_type: int) -> BoundBinaryOperatorKind | None: + if left_type != int or right_type != int: + return + + match kind: + case SyntaxKind.PLUSTOKEN: + return BoundBinaryOperatorKind.ADDITION + case SyntaxKind.MINUSTOKEN: + return BoundBinaryOperatorKind.SUBTRACTION + case SyntaxKind.STARTOKEN: + return BoundBinaryOperatorKind.MULTIPLICATION + case SyntaxKind.SLASHTOKEN: + return BoundBinaryOperatorKind.DIVISION + case _: + raise Exception(f"Unexpected binary operator kind {kind}") diff --git a/bagel/codeanalysis/evaluator.py b/bagel/codeanalysis/evaluator.py index 51b985b..55df433 100644 --- a/bagel/codeanalysis/evaluator.py +++ b/bagel/codeanalysis/evaluator.py @@ -1,49 +1,46 @@ -from .syntax.binary_expression_syntax import BinaryExpressionSyntax -from .syntax.expression_syntax import ExpressionSyntax -from .syntax.literal_expression_syntax import LiteralExpressionSyntax -from .syntax.parenthesized_expression_syntax import \ - ParenthesizedExpressionSyntax -from .syntax.syntaxkind import SyntaxKind -from .syntax.unary_expression_syntax import UnaryExpressionSyntax +from .binding.binder import (BoundBinaryExpression, BoundBinaryOperatorKind, + BoundExpression, BoundLiteralExpression, + BoundUnaryExpression, BoundUnaryOperatorKind) class Evaluator: - def __init__(self, root: ExpressionSyntax): + _root: BoundExpression + + def __init__(self, root: BoundExpression): self._root = root def evaluate(self) -> int: return self.evaluate_expression(self._root) - def evaluate_expression(self, node: ExpressionSyntax) -> int: - if isinstance(node, LiteralExpressionSyntax): - return int(node.literal_token.value) + def evaluate_expression(self, node: BoundExpression) -> int: + if isinstance(node, BoundLiteralExpression): + return int(node.value) - if isinstance(node, UnaryExpressionSyntax): + if isinstance(node, BoundUnaryExpression): operand = self.evaluate_expression(node.operand) - if node.operator_token.kind == SyntaxKind.PLUSTOKEN: - return operand - if node.operator_token.kind == SyntaxKind.MINUSTOKEN: - return -operand - - raise Exception(f"Unexpected unary operator {node.operator_token.kind}") - - if isinstance(node, BinaryExpressionSyntax): + match node.operator_kind: + case BoundUnaryOperatorKind.IDENTITY: + return operand + case BoundUnaryOperatorKind.NEGATION: + return -operand + case _: + raise Exception(f"Unexpected unary operator {node.operator_kind}") + + if isinstance(node, BoundBinaryExpression): left = self.evaluate_expression(node.left) right = self.evaluate_expression(node.right) - if node.operator_token.kind == SyntaxKind.PLUSTOKEN: - return left + right - elif node.operator_token.kind == SyntaxKind.MINUSTOKEN: - return left - right - elif node.operator_token.kind == SyntaxKind.STARTOKEN: - return left * right - elif node.operator_token.kind == SyntaxKind.SLASHTOKEN: - return left / right - else: - raise Exception(f"Unexpected binary operator {node.operator_token.kind}") - - if isinstance(node, ParenthesizedExpressionSyntax): - return self.evaluate_expression(node.expression) + match node.operator_kind: + case BoundBinaryOperatorKind.ADDITION: + return left + right + case BoundBinaryOperatorKind.SUBTRACTION: + return left - right + case BoundBinaryOperatorKind.MULTIPLICATION: + return left * right + case BoundBinaryOperatorKind.DIVISION: + return left / right + case _: + raise Exception(f"Unexpected binary operator {node.operator_kind}") raise Exception(f"Unexpected node {node.kind}") diff --git a/bagel/codeanalysis/syntax/__pycache__/binary_expression_syntax.cpython-310.pyc b/bagel/codeanalysis/syntax/__pycache__/binary_expression_syntax.cpython-310.pyc index bc81c5aaab26a3e15ae50e7d7003b420ffe40175..3e79ba673069013647ca51b8e8fc57ee213225a1 100644 GIT binary patch delta 549 zcmZutyGjE=6y163Bm2lE<|UdUViiF|kbsg#(Za?inqpCwm6<>wY-D!9#KyujmO8za zg^Fwu>H+_5+fNB9CS^%#! ziYO+atx;WMD6+(;tr1KS(Wy=hih2eyi8aB2K~0jQRu2-JI1~H?f}Fs%z%KEG?kF7z zoF~50UB&2vDUhOK_Ps^Z8Yw9%Ps$ywS;?v={WxOdv(X)+Nzxz2opGE-BmNE=`~q~h znITqZrVN${O`PF`4tgvn8Tm-&@EN!P4sXG0*Oe`hA(1lv26sV$f5C1|(P-HtjU|4F z8lcPrbh)ECz`M?QtE@;E|h zD31sab^e2D{2QCV=QG?aW_}n(aXd_;RQyyDh8*Y{n`P0O;Xyx1Syft>zow;c<>d~x MW&wGtkcay7A5?p3XaE2J delta 507 zcmZ`#Jxc>Y5WU&m`$+CCi802Y7K#X-AR<_4>mQJy#i0arHYN~ME)gV+g+WLu^8@Te z$Pe*99N7B@taWygkiu;7cHVpYW_I^I`U>OQI4(N8e(ooi&6jxc_`pOvDWH=I1T9f$ zg;LA5hYH=1N?q-tr~S4-AA^y4f;3=WU|zr?`$g+Z<{?Jb53QnDiLqprXnLlM6|2O! z&~%b&PAAZyF`QBd)@zB%RbThona7vPd;#n7mwFkaFk*|DLF&j;x^y} zajJikAh5VKB47iZ+o{7{a5&Z41#fQ8aO$lbL--J^93R#of>_gmW<%X+L0hW`!c#Qt zD0BN@Pg8)XO*C_pEQSii)o3Q@P_L zdhCVs(svC;Z?oct{}1am(=EB}KHykByTgHMGnSQQ)nw-0nlWV;dEJQEjPNF+nsCwF U%P)67TGv*9JnZ2Xk(*xr3$c`9HV7)gHA*o7*!PkZ)& zzJ!D>{fHZo%$v}Ezp#JBO4IA?vUcPh@Whk%3N8)(Ef~ V+&D#EHzei0T;oDo9iTIr{{tzKPBj1k diff --git a/bagel/codeanalysis/syntax/__pycache__/literal_expression_syntax.cpython-310.pyc b/bagel/codeanalysis/syntax/__pycache__/literal_expression_syntax.cpython-310.pyc index 765cdff3fcc03035918c14933cc534c1d4fc51d7..c472c234ce0ddc100f68920b55e89fdc46710229 100644 GIT binary patch delta 461 zcmZvY%Sr<=6o!*b+Rn8X1s5*dxUnGaT-l9_Srm$uj`cDKp*5)v9cIdz0dXhTr5nk@ zXD9`qN9GND3zG=dg;^y0`M-1WpS(IBPLKzIi`065Tu+bRg7xjC5(34TqnM15umt6} zhd2?|jBtz7C5>yM&TFEfbe%Vr^aaPZ(vH$Lca-lMU-K^ajPG$jLft^Rc(>JLX;KQ9 zq^!*6B9r^Lw*z(cYL`^B5a|pWN~{og@)=)YM}Fd)6WjP;siW!)`WNBobP!&jkHRSG z56@N@^bp`}HeZ8uo@CsYDH$G_dTcsFdqWxCp#Hrm+1*2uau8Wtev$EkE&)ex{}h-` z+uGccGwTrhQd-?<)naUtWqCO%lRPUJgFqpby?}fnpnNj arVRZtg%02%8#jscXw?24^M{og-TMYv5M9au delta 421 zcmZvXKTE?v7{+s#Yx6&*E`o#TWs1DxnaL@aD-s8Cs=gA4GAaD&lU$fOs^ct-4AsS(%gc~X4M3_^`DL0oa zWunKK=%erP{*pbC)Ix8gx44bm(Ol&n?rQFGFEL`j+Zkr9fJt#NuR%0TR+Y)3Y$tPh zMotgXa9phMxUF(g#mUGCdMzH_I+kZ8cjW^e zoml8&qSs+-lhSz|_3uPGzP-;14x$X@H@!SmD_|@6XFriE?g)ffIW-E@E+0tK58#Wq4Bk69A^{%M_*FKq7z5p!5A diff --git a/bagel/codeanalysis/syntax/__pycache__/parenthesized_expression_syntax.cpython-310.pyc b/bagel/codeanalysis/syntax/__pycache__/parenthesized_expression_syntax.cpython-310.pyc index d06f43759a425126425dc95fcedccd315c12735a..609c7828e31200781e755d71687d89f9871fddef 100644 GIT binary patch delta 443 zcmY+9&q~8U5XSd!k|x=vt=1N_TJTiCo8qMheS{)jA|+IJ3xXt&76cJIv{w&07oWgO z&*E9UDfj?+0-wOMvw@24!VKSUzMY+!sW+uErF??t{c3S`bFUV+4=4QF1J2W6e3uIi|) zhb56nYPw#Mb@gj%=#>&x_3AO{HH!|s@(z5^LsqQ8Cv8DWhugV>^X9G%9)_MM#Kc^V z^NJ;Qvpj$;rfC3kc1}b1Vh6MiT|R7t*3SPKYqAATyh@w!%ul`2KywFbvK`reZQHJi z;d&28*@U6kUz%KNlJ>t1coBmo_DUQe?!vA-q7h`WS1+O@8Kr499ZfH?bdn_SD0hOt Z6AzqLJD2#(Za3*-@QFw5^%;E2yB`)vS#kgX delta 349 zcmY+8y-LJT5QQ_jKe@Tdjb>TcMMUfP0NR>P%SEt=tcA`^B`ib~JB!`cVwuKwSOnj} z2UxJ&LVOe_7gltNf%Bci%=vJ0=Vs2?h(|xJZsMg|JwLJVQ3Dt?F@hHudx^q}R-;6< zkd5*hwNKg@6Eq7shsLl@S*K{(x4{>zGt7gZ1tOU^ECR`YGds8&h{N(Css(^b diff --git a/bagel/codeanalysis/syntax/__pycache__/parser.cpython-310.pyc b/bagel/codeanalysis/syntax/__pycache__/parser.cpython-310.pyc index f1fc184d900308212ebd98eb0663996f7a5d6659..4bef039790ae646f81aa81dce2c85b24a9aac7ff 100644 GIT binary patch delta 408 zcmXYsJ4?e*6vuOto21R7FKyNO0zsjIgG)gaJ2*Khh@e?Q^<1S;5=kOH7Ke6l_JE6v zn}ZJ&7r#Qm$w@Q#5yY{hhvJ>?|9^kycer=eUeyg<*HZZOPww}E7xxM-9ym$G15`Y9 zTalU+2rCMzQa?~pL(vtUAx+e!#@Rr#D>~q1a2&HT%dK@F&_cVbd-i~`m~zk^P|o08 z#T@3@;$lJO{wIo9;wH~&y}$!QILxug((*uBVrd0OSUSW=iHT7hV`3PqTS{#rH8z`3 zETh!%vDG{b!Z>N|$F!k7>5XAOuv3V3mZBiIO^7+05C{spv9YmmLF*jQLJP4G z5e4x9EJg4E!gh9o;4A3KD&oNWbN(~`d^7V>zAoE)ww)1peC*%uY&_TlIJ{yP2tJ_T ziwJ?#7EwegmVG%;P!3e~3aYVu1ipr4)B~NnMq5S$GqK`l(v-m|6Rk95ru!n==rF}X zH?V(Cc$npm!_MV=4)g35JcbrhXqKU4IL^=QTSlSe7l|)@{hEWhwN4$3u ztAX8SXLm2^cUuvar5@OHENz2BZ&GW;<4@f{SmGtD{K@2~DzZ%Rj6@byJjne}=l|)kN-fqduLP4SnnTnY*m7ruZ{-2@>-&s0N8B59Pma$!MmC$q0> zaqX^qA3?}t_ynFAFW?OP|D5lfxtw{kCytkSo~_{68NZ%=Jb90IQw*3A5>P_*L}41E zK)MRk(N%N zGC>M9E=nW1iHFyWZ;;dNT*t<8Lx?HFLh0xw9kF3QuLvUkA$Nqhd`6Cl!#%aP>4`cb zcfXLlD$@R+1Y#vN*Z6~aV2Ik>=g(TxFWn1PMCX^u5OS8*`KNkl{TyXrK}#36wRouQ z|6)^OasLvZX?wrelGsJO%G-3A1bmln1%4F8X_^(WXm=DvJf`c5;vpp+CZi&6;PPKX TQ@R$cAhZ>We9yMZ-)Z^<_G;uIz(#Q~uW! oIvC-U?UD#fHpXX`jLhp=HlHo)YGCGmf9QiH!a!jS2@ZJq1*0EOu>b%7 diff --git a/bagel/codeanalysis/syntax/__pycache__/syntaxtree.cpython-310.pyc b/bagel/codeanalysis/syntax/__pycache__/syntaxtree.cpython-310.pyc index e022a6d7cb0b8c27382e42d36f9987f6e4a2d785..9653dfc8055e93d605eaa0705ba10648eaa3058b 100644 GIT binary patch literal 1482 zcma(RJx?1k)b@SkxFjTm@(t>I3)w1FLKSLNb&D#|F1J`m>_E!pF10TzL}7ydk9I`; zM_xNIvvulwzJy+ZO10$o<>%-3>Acwt39RQ|e;f}SLVhAsT_7Wegi!qg2tfo*$%w|3 z62XL%vXK)zmUdHjTqQ!`sdXi;%krcx`)3>ygwcnnP zmDCz!M;BRaWEML1

hp7A?`XTn)G#u_8K_3*?g66>DPMa-rCO81_s!cS=cV+;pf5 z)8Jy5oMgE!hJCHjFXM5Q=Y{f+?r@n2o)7q7m`Yw?Fs5F)VO-QTE047LXlk*LX0YF2 z$m>AN=!|eOV*u&Q0muY7A~&=bIVym2wS)kx8o9>RG99QoN*V~70B(qC1N!x{`z2Rr zdYts7?!Hb=WZFHpu%8Q=WJ!9Vhq|k6QRb+C;P=NDCg6OS4GYfEsP+N))TbexuKr2V z{zAw2N){89^|9iMg*0vq>kbXf$R`LxEdv=*8^{e+E#R!PC0IcggF)gBv*NSqdgaMV zcK`XBdWKf!@7P?ep#W1-c?AQra!mQORe1x8_J78)2I?u}ScNS-w8nQU#vk>9aSM4~ z7)KZCuSan%@7rP*7(oTY*}R0=#1^@tmu$wqvG0)8$muD(0HfuN?rVA~Fx*!G^CjEJdK6yW)S zMvVoH(-XO+E1RfjwXsQ}I<{Vxj3nnKKZT`&Nx%Qc2nFscG%sDCQ4834}oLF zA3}SC6X)JIF|$sJ`#@r)ncbOqXTJG%CRMlFBCx*OZ%02EAwSV*E)K>4hJ1-h!N+f=0# z)mV)4LJ8~f2LN-m@C+=HHy~yQ)PgREAPWYXE;wi=$sxI>!-TtzXvPnPPp~B(WJm%R z7*&jQ2mv+Hqt`%P6WxXF_shZON}rl(Hd1ErIy+Xy;K=JyB~?~t#mwYpU_AHB%|dm1 z)0vBf$jjUcfk6$bh(@$U=i7f-*js($BCYJ1E=TyVtA%G2EcgZkEXWBIsAD)LRIkH! zO?3x054KhtXksyKkQ?MHV)LCw$_6k0%%(Rn$}$i3u--z2lr*v+q#nAqLCt%O9LVB7Fbq!(<#zOb)AXu^kj zIZ)C2OdF-4fugBD>8Ehnh2BWGeu9Y5rLh6;6Y>mvDE_rOET%D?_Z!H4lws1t-YBz) z62i5Fm{jr%8eTxpice=*vHT?{a$_|Xp|Ki`OuKlhtEtjlOsTZq6lGuR)*O?M6^bZi*yu(k^*f*!3jXL zG~C2zAa`J5$QHBuzkg@+&wk4v85dC`37)gr$JHi(iQgY8RGMTINXCXlb1i`OiFWX2 zeF9u_5ZW0DaKN35%+(%v+8;6SA()FtngysOY6&g$TaC|AhY&S>*boOv3`s*GSR0UZ zz1|v{+#b-4Zla2NUFKC$s;aotruP4U0o$X;yQPa6OAkxRYcbW6QRy#9U_a>vl~%HI ztiXCSwr}jT*)V0RHw(U<)ZvY;)b;In0;M)>yT=Fq@*h%Kx^}^LoaMZZedQ-B>@_$* t+_h4qIQd9m SyntaxToken: return self._end_of_file_token @staticmethod - def parse(text: str) -> object: + def parse(text: str) -> SyntaxTree: from .parser import Parser parser = Parser(text) return parser.parse() From cd1b1855108781254974d5ec1455f8d8d9741477 Mon Sep 17 00:00:00 2001 From: Billy Date: Fri, 17 Jun 2022 10:50:47 +0000 Subject: [PATCH 10/12] gitignore --- .gitignore | 3 +++ bagel/__pycache__/__init__.cpython-310.pyc | Bin 149 -> 0 bytes bagel/__pycache__/__main__.cpython-310.pyc | Bin 1626 -> 0 bytes .../binary_expression_syntax.cpython-310.pyc | Bin 1505 -> 0 bytes .../__pycache__/evaluator.cpython-310.pyc | Bin 1573 -> 0 bytes .../expression_syntax.cpython-310.pyc | Bin 362 -> 0 bytes .../__pycache__/lexer.cpython-310.pyc | Bin 2190 -> 0 bytes .../literal_expression_syntax.cpython-310.pyc | Bin 1157 -> 0 bytes .../number_expression_syntax.cpython-310.pyc | Bin 1147 -> 0 bytes ...renthesized_expression_syntax.cpython-310.pyc | Bin 1668 -> 0 bytes .../__pycache__/parser.cpython-310.pyc | Bin 3402 -> 0 bytes .../__pycache__/syntaxfacts.cpython-310.pyc | Bin 984 -> 0 bytes .../__pycache__/syntaxkind.cpython-310.pyc | Bin 706 -> 0 bytes .../__pycache__/syntaxnode.cpython-310.pyc | Bin 618 -> 0 bytes .../__pycache__/syntaxtoken.cpython-310.pyc | Bin 1326 -> 0 bytes .../__pycache__/syntaxtree.cpython-310.pyc | Bin 1310 -> 0 bytes .../unary_expression_syntax.cpython-310.pyc | Bin 1332 -> 0 bytes .../binding/__pycache__/binder.cpython-310.pyc | Bin 7357 -> 0 bytes .../binary_expression_syntax.cpython-310.pyc | Bin 1576 -> 0 bytes .../expression_syntax.cpython-310.pyc | Bin 369 -> 0 bytes .../syntax/__pycache__/lexer.cpython-310.pyc | Bin 2228 -> 0 bytes .../literal_expression_syntax.cpython-310.pyc | Bin 1198 -> 0 bytes ...renthesized_expression_syntax.cpython-310.pyc | Bin 1731 -> 0 bytes .../syntax/__pycache__/parser.cpython-310.pyc | Bin 3401 -> 0 bytes .../__pycache__/syntaxfacts.cpython-310.pyc | Bin 991 -> 0 bytes .../__pycache__/syntaxkind.cpython-310.pyc | Bin 687 -> 0 bytes .../__pycache__/syntaxnode.cpython-310.pyc | Bin 625 -> 0 bytes .../__pycache__/syntaxtoken.cpython-310.pyc | Bin 1412 -> 0 bytes .../__pycache__/syntaxtree.cpython-310.pyc | Bin 1482 -> 0 bytes .../unary_expression_syntax.cpython-310.pyc | Bin 1388 -> 0 bytes 30 files changed, 3 insertions(+) delete mode 100644 bagel/__pycache__/__init__.cpython-310.pyc delete mode 100644 bagel/__pycache__/__main__.cpython-310.pyc delete mode 100644 bagel/codeanalysis/__pycache__/binary_expression_syntax.cpython-310.pyc delete mode 100644 bagel/codeanalysis/__pycache__/evaluator.cpython-310.pyc delete mode 100644 bagel/codeanalysis/__pycache__/expression_syntax.cpython-310.pyc delete mode 100644 bagel/codeanalysis/__pycache__/lexer.cpython-310.pyc delete mode 100644 bagel/codeanalysis/__pycache__/literal_expression_syntax.cpython-310.pyc delete mode 100644 bagel/codeanalysis/__pycache__/number_expression_syntax.cpython-310.pyc delete mode 100644 bagel/codeanalysis/__pycache__/parenthesized_expression_syntax.cpython-310.pyc delete mode 100644 bagel/codeanalysis/__pycache__/parser.cpython-310.pyc delete mode 100644 bagel/codeanalysis/__pycache__/syntaxfacts.cpython-310.pyc delete mode 100644 bagel/codeanalysis/__pycache__/syntaxkind.cpython-310.pyc delete mode 100644 bagel/codeanalysis/__pycache__/syntaxnode.cpython-310.pyc delete mode 100644 bagel/codeanalysis/__pycache__/syntaxtoken.cpython-310.pyc delete mode 100644 bagel/codeanalysis/__pycache__/syntaxtree.cpython-310.pyc delete mode 100644 bagel/codeanalysis/__pycache__/unary_expression_syntax.cpython-310.pyc delete mode 100644 bagel/codeanalysis/binding/__pycache__/binder.cpython-310.pyc delete mode 100644 bagel/codeanalysis/syntax/__pycache__/binary_expression_syntax.cpython-310.pyc delete mode 100644 bagel/codeanalysis/syntax/__pycache__/expression_syntax.cpython-310.pyc delete mode 100644 bagel/codeanalysis/syntax/__pycache__/lexer.cpython-310.pyc delete mode 100644 bagel/codeanalysis/syntax/__pycache__/literal_expression_syntax.cpython-310.pyc delete mode 100644 bagel/codeanalysis/syntax/__pycache__/parenthesized_expression_syntax.cpython-310.pyc delete mode 100644 bagel/codeanalysis/syntax/__pycache__/parser.cpython-310.pyc delete mode 100644 bagel/codeanalysis/syntax/__pycache__/syntaxfacts.cpython-310.pyc delete mode 100644 bagel/codeanalysis/syntax/__pycache__/syntaxkind.cpython-310.pyc delete mode 100644 bagel/codeanalysis/syntax/__pycache__/syntaxnode.cpython-310.pyc delete mode 100644 bagel/codeanalysis/syntax/__pycache__/syntaxtoken.cpython-310.pyc delete mode 100644 bagel/codeanalysis/syntax/__pycache__/syntaxtree.cpython-310.pyc delete mode 100644 bagel/codeanalysis/syntax/__pycache__/unary_expression_syntax.cpython-310.pyc diff --git a/.gitignore b/.gitignore index e69de29..63ef37c 100644 --- a/.gitignore +++ b/.gitignore @@ -0,0 +1,3 @@ +__pycache__/** +*.pyc +.pytest_cache/** diff --git a/bagel/__pycache__/__init__.cpython-310.pyc b/bagel/__pycache__/__init__.cpython-310.pyc deleted file mode 100644 index 36768bb3f680ac1a6af72f537c775dba4f31a09a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 149 zcmd1j<>g`kf*U2Plf;1ZV-N=!FakLaKwQiLBvKfn7*ZI688n%ySPk?H^-TRV8Kb!4 z6OiCw001GkAvyp6 diff --git a/bagel/__pycache__/__main__.cpython-310.pyc b/bagel/__pycache__/__main__.cpython-310.pyc deleted file mode 100644 index 9775d227840162c67cdd16d245d777352fa80aa6..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1626 zcmaJ>PjA~c6elT4mSn|o{@PiV#%+4>B>{RFFbqT2HN`fd>Cj{d#-SAylS^gGl1oxc z95}!*?^^7V;|>Y1%Yc1@9R>{h6gmyrsb8U&>`~6r1j9y~kH7cckB{Wzqq3mW%Jl{|bRW8UjuGOB;{>tEh#3Z*B)Cr)!Nz7KR-ZCjVw%`}hdCv-lS-)?vaV4qt0~TN;aCeHk+{c7r-A2bh^M7&nC9u zbWzNmVb&0Ij961NPnSfa`wm!^Ap)T8yJj}vA$A*P-!_bN$}k?HXCAu)Hqu=acN(bN-A^w+YByh-%x|@EK_6vO z!00@PQ!XSRZ}Xcd$s?T^#or#LIy&6SxFJ<1+D_IJ>09TH6k?~1nHS|SNhqNo6{w&o z%qbibHPuBWR$&q;-LcHVm(79Eh5j*g^#_O%k(6V|BRRG-8ewj6`U-9wuyqZiF7A>m z-5SBUG|iE`H$q*Tqa4e78gcuIflB*TtTDn68`gTCJFr&eJ#>tZ+z~o;&JcH(&@tUb zX_X>f8Gep|YbxlNeu+|i0Fev}^6DSk+8x;thmPzX8C!7gUvRXI+TK>~!CB5vPR>uh zh5x1Y<3y9@z>qsjr2GwT9a*hbD>sQaKlu*e>kDXYudoL)hP2Th4~B99m^0ATT@V2dNPz1g zeH`E#c1WEN0y=gvxd^OTOfSkAxha9)e{CIkYwAUIprLw>=C=XG>3(YvNhM^<7}Zg8 zE7L8*`Im>TbrMxrAljtN=uZ1?K{CbMPL^acg7Xnrg)MiW2%|JghALL;dyq^BRgOYR zvk$g-gCYJYeMyb;)(xjBpThcNFx4$>Lt6cBk~R;eyt4lbWezLN*N@RSjWzSOKY6kn z?mXSxEG(sELHDvODN|S2aXQGMERr}CavG)-jv6X0`phmf$EuUvg(fC*%z@#Wr_C6O zLnsQR;w&ww%redDds%+NF6(9!RUSwCX{L1CffPsSka<^WVeTb_mkq)4M6+u6md~uG zn-9wZx+a=to9+kwjOU5?5Wek5eFnlsF4POujFIL?C~jJ0$;EX*E^(li2-J=b(g)2j Spt1-B=@Yl~_)uTu&%XfxbF diff --git a/bagel/codeanalysis/__pycache__/binary_expression_syntax.cpython-310.pyc b/bagel/codeanalysis/__pycache__/binary_expression_syntax.cpython-310.pyc deleted file mode 100644 index d05ef08f045d4c71fbbfa6c3b275c5c755a4d064..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1505 zcma)6J8#=C5avUY67(mU!*Z7D0-lLxC*rq=isS+EF4)E~%h#;4S$n zUGkT>cIuq1Q|~A^NE{m|fji%kr@QZ7u6wvYHo`Hjls zX+|l^tYlN3aVPWAoBEkg$yXvh>E9CRD|*ATKn6pScK%TKJf$}Iay8S+n4+$R^Qy_O z;4W&VZ$%|R>$ckW`a)GB_~^+AKsy35SHKj>s3aMaRB_3aC%NL|z(w~mUqNKm88g|D z;jMQ=vk>$x(6?lC>t&I9=b(3G?B2WX#)F%l?7N%z!Dd?~?xrVqAe&vge_T|#p06fj zy;6-E+plLz=S{6egIQQ#7n8GQgr!^_lo`-xAhQo_K^H`j1p`hO95|C?NbcxK%B?S) z+ikJpHxSNo>RHdIa;&jBx`QkPc1Ls{e*PW}e%AWJ%<_>kgX4Un%E77QqgtxG%FDSa z%;3}|B-BHDgmL{joXu@0L{Sxu5a`=rlz;{_qStTMm*H?}Zv(BGOI?ky`^$qel1m+( zHRPNQiQWP+WtziJmaICyqq+wVE~A!hgKE7C7@8QQdn{(au3xWy*iO?S+C4*op&W_? zgatWAf;OD9318yjD@E12V7iJTo~TBQ&WciMRiQ6~XcBh)b_1Hn_Rml)YjcmaK~zgD zRO70yL*PK};Ult*MZhWA7*699woRbAyD1P(z$<)of!=M%@9CWWUr6lY+T3uK4<14u zYzXN#;Uw+juvYn031K54rnS5*QI3W9ahaFxi^le7TtSW9vf)f4;%4rKPrtxBuPjWX zU!u*^wR+TiTrZ7tsC{5)=2kf*`;_?!?Q`ZOlyRgz>TFKZj@@~-V-Amv+J(bOZI__i eUbz2|7A=NZ7vF{-+Dt#;@EELEOkx_-J^l~TkV^Fc diff --git a/bagel/codeanalysis/__pycache__/evaluator.cpython-310.pyc b/bagel/codeanalysis/__pycache__/evaluator.cpython-310.pyc deleted file mode 100644 index 15a22645bf3488a7a63e8240d90911bc7ec44fa5..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1573 zcmZuxOK;mo5Z)!16h*xpKjNZkP@M|!VxdKkK@r;$0->%_R8ora!qD2aLzyC#CDp`+ za*6XVf&$GkK!4F*d+N1^9(wA`QdH@pE9_|Jo86gjXLgvjS}uX{*N?xQvl=14qf#9v zD34)gUxDC+)0ix%PZx%7EKJ{AFrO_f-&)wdP016&4Q{?8+`KjX8fRnTS$|MC=-KMv zBwZ!^BuYYgJ$Sv8BFmyQQHK@y=~BorPvy5!!c|8bDm(9M;4I2vQ(VFKH9q~1-(t5$ zt8QmN=FVWCJ%*X}K?vegPJClZgee%OkKjJSyns7#_Kx`$w}cIv&1<05xFbxBFka^_ zAP#T9jhm`I_&JPMcoSs>GEH;EP|gepQ4U<=JcXHI3D$H?0?6=~e550f$~s`4p;#v3 z3yB*(64`>kzrXCgO666y3}+(iorISn?wxBnOSuS>Fuu;BtS3qeN6TyF1VNNUc@Ut} z48ywgW_Qc-s5C2EihL!L8P=>ExW-qYnKoguCcna*(+_k^WCH-8xwnZY0QhMw8*>C*_O=PmU+Urz7Zu*E6xq zq0uG2I>lmf0e)q4`68ECMCBa!`$N6AF`k}GemFkWO8dL%*<|?r+3>V*9rUNdB@S&HZS%gV@sa2FZ74I3lFK9f7gA?iCs@bTH7)9h YrP8PVFN|^?73{ykrq7Uam+V^q0Gcv<2LJ#7 diff --git a/bagel/codeanalysis/__pycache__/expression_syntax.cpython-310.pyc b/bagel/codeanalysis/__pycache__/expression_syntax.cpython-310.pyc deleted file mode 100644 index 371e69e12908ad513ed3790f23f54944c1740f60..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 362 zcmY*Uy-vh140f6#s;Vb3@Bm0mUFeJi=!AsWZs4{qQLc$jr%RI(bK*L~qpBoa@?2nFOURTedG%ZX%3!e?<*r2Y<_qJnCnxSDpniH9bk3QqYq)JajB diff --git a/bagel/codeanalysis/__pycache__/lexer.cpython-310.pyc b/bagel/codeanalysis/__pycache__/lexer.cpython-310.pyc deleted file mode 100644 index cc2435e23b2c3ddda3e20be34c38223f3735708f..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2190 zcmaJ?OK%%D5aw_nTCE{P!vIew1=j05C=)CLl%xxU{22O$r$k{&h0f^=~-}m|+uf6V*72sT+ad=043g)-heEKGXv zeO3tMYL0s}+>^xs0hc}>x!XAOW1J-GgJ69wKziF;aN(W!eP0H`mm%_j2v7WD=vS#l9`BpE09b(hK+U?Nq7;L^)wp(;qJ1)9k5g_tUX zu~M=yv}W_r;y%=2(r_`IuJ%40P#YDe%tzM(zQRIdWnBo$om3mdT-SbqRbC;#l!rD< zV&{{@m;6zkX)87X_YwR~0v3&D{HFm)1s?8W-=-scQF+PKk0d>!WI29y%3ee-v3zF| z{W&3~aE%>N0y&;e99P-z{5m`GCZVZLy<<4?pRi)tXC^+}0MxenwHI|^b)Mrz{nLAi z*Y_t@z%yp!X`m%<>Yqo`#Ar^)*J(7w7nhN!PZs}Q&< zSZs@|3E!a+86xuUxyVI}49}4jME)}u*|x~aIWj_IITyKPkX0Jd z<9~qi=Im$1;$nwGnkrDke~1;Ry9&(Fx;)0QH6{Y8uCvl@^wc6Au1W3DuIv=! z{Vl0Flci3ki&fJ}JHMuRCOTPRZqDFKd!}cwR>F-Ltk2+!8FVL~-Fx_ObUUip%u8O;fbe$EQ`m%Yi5F6XyX1TP@TP=~Wl4+6cWJWC$ z=b`g5ew^lGc~7aKvMr_z)6qy4qOA37$X1&aZ3`?Hp6q5uZc;mRE7b@2SUWQQAuG=4 z>ZVE6sdzI_^{%6rH_-Njlp4dX#K!5QD|hpumhXw9JE^dMF7_e{IM8U+^h0bsJ7(9m z=`z4Pj^(@E2Yb`OHB`|*%du`y@iR$nP@HZ`fd8GwDkD*B#ADAO6 zzrvenYt|!Sa<1{~A@w8E@K^u!k zYB-Y09F~5bp|piUTQOTGWvjYIvbRmvQq=twJ;T(=G-*W);|f~9y%xkl+q0{^ZcxVB mzUzDVuDb(La{@z8yYoPX=6NWiuiXy5q0VcYd7agv?fnmzMBwZI diff --git a/bagel/codeanalysis/__pycache__/literal_expression_syntax.cpython-310.pyc b/bagel/codeanalysis/__pycache__/literal_expression_syntax.cpython-310.pyc deleted file mode 100644 index 9dccda15ab9bc4ed7d68b4ad6f5a635376739edf..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1157 zcmZ`&JCE8x5Z>_%V+?`lq%f&j+^v^*(iff#(Dy~K^==_)pdX^& z5Fy5!Hct6X5!rYoT8J>No?T?6)Tz3UuxhJ1z)On>Svm;Wv_9Z6MC1lGj3YN=wu8|Q zk`BL9+;=L^NOh$H%-u0fC4b)ye-wIV7U@Kq;rnzd)$r2lNg-sKr)p&~Gu)pe4+L^! z85}HDRmgdkXC>zi0z!x)Sid;&pus-53bZVjI-gK;_Chu-`y_%{vTGPKO(*vq?c%5E zJvey>x``3{pjx#k(VJmY>5+d3Q{b$hKd7wRJ)p$XI6|!6uxmCwAOTCEeu9Dfm&Q|B z^2xVM2`%#uCRjp3Sid}V`EkK%5JU!n_)mr=P>%ty$a)kcwSIN#R&_j9qkfCJn5T2e zc@=R!FT_%j9drJDnW{RX=?~B`sw!OQVj*?8vOUpV+VfOqO8t~_2<;Iw)C5gE(LO2) z8lom-9dO((bX>U71bk0&8jD%Rd3ioqsB(ZKXz{wzOJA2hNjC9 Lc`=J2hBNmc+Wrf` diff --git a/bagel/codeanalysis/__pycache__/number_expression_syntax.cpython-310.pyc b/bagel/codeanalysis/__pycache__/number_expression_syntax.cpython-310.pyc deleted file mode 100644 index 2f28dfa157bc594d9a820dc0abffe9ec969c36b5..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1147 zcmZ`&J&)5s5Z&>294F+^iH3rL$^}VF0jCoPQGn8f%FW8j?gd{QJM22*5~aKR6q@`c zw^Y=0RLrdJq7agic098)v-|eVxa@R7hVts|kFjqt_LH1LanQNOrC*~GOhC@&kN}Wv z<<{IzY-8KGGj|gg*heND;cl65CEVMIC%h4h{a=9PG1R>ecMB!8&dOr6DysAj_rk{d zlobNKcH@01XR?@J(Lb_B^BK1#OF*#15+LmxOIX6*I*B7);YbgCS9n|J9ugn@0DWHs z7;l+4<+ns=;-P3G!l-^WT+YW*9RsYR!tC?PAVQAzLN=}UxHQqYfequx%!ut^xPzp_ z4{KwqcC^fIl!vK1rl{i2_27G{W_poMq#nFWr!pUmjh>W3rbU{sbfyOn$H+Z-TpRZK zi&Y(Po)uZexlb?%PYCN5rytXQ%&k2otEDO?)R#vgo0fSGfvngqjF_T>V@uiise8u< z??AOMU|!RxHsv`pY$v_&HzD$@_4DJxrq6xKJC7p3;tjiH(>)F_^r?_BhJ4q)4Yi&ntK(Ys)L0p7gAL#(+<_6Jtxm}rJhm_VLhOQ8lb2j%0)#%O}qrG z3zpr3u5Hxn+@|vG}!3)Q}@=vo90PZG+3Ibi&z8^ HT-tvD#DWK# diff --git a/bagel/codeanalysis/__pycache__/parenthesized_expression_syntax.cpython-310.pyc b/bagel/codeanalysis/__pycache__/parenthesized_expression_syntax.cpython-310.pyc deleted file mode 100644 index f32af5d646e90598d1a812ec5a0f0a88f241d2df..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1668 zcma)6L2uJA6t?3u?b5XCV5}2@3kO6vtQSBW08JpY1JZ<4PPtfF?QPl8q}Z8QtKPPs z!exKSS5BOF;{xwFv@6|GVaYGg?>*=H{QREtR?8I_-Ltj=EIL+9eS+NiSIB39nDW`cDemLuxu7&qqpXo#a`6 zoE7mo*!)ualw<-{&2sf6Kb6@4HvKa^Sna~p=O84Bs34IesAR&Cu3(ZKdKTS{Y7&rT z{m>D0(YSOkXw-o98m!lZf9XcP^)pyEMPU6+YjMHS5^ZY<<}vG{V=XPQ0jIfV9)FIN z%!*^FlZh0|XEIy)NM?LAkI}rq;}~DgPj9+|G}rQW&;T<&8>l-lKfu&mAf|LmIGH*i z>6C$V1nHA2x*syrkKHh-$;<*Iw^iu1@tR9!TAL zA0NrIcVOip7c$P`bgUEIyE!xDWdW9Jd)qssv1xFgWJ$p}LTCi@9FO{R@^ocVcV^p+ zr(|)avH_OVY@m+QCJO&qkQ3S`Y7NxTQ4Bt&Tk-!Zs#@T;$1KGhPl#a4JUM}4^(wW7oJ!!}lb77r!o#^-#Pi?bBQ2)2%b!eM8tV7GW zNp0MIST`FtY5Uu_mX7huF2+hPTdG+a?CVz2MyLgN%f_}-<4t+mcUW~A(;1L}26U7C E0eKjZK>z>% diff --git a/bagel/codeanalysis/__pycache__/parser.cpython-310.pyc b/bagel/codeanalysis/__pycache__/parser.cpython-310.pyc deleted file mode 100644 index 2a380126cd137f0646306c5ff0af209ead887027..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3402 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 diff --git a/bagel/codeanalysis/__pycache__/syntaxnode.cpython-310.pyc b/bagel/codeanalysis/__pycache__/syntaxnode.cpython-310.pyc deleted file mode 100644 index cf2ffde8c1d23ed54c3299b80898b563d4c84c17..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 618 zcmZ`$y-veG4E9};5~5Z}ENqCiODi!0s>;BCl%-5rPHB9U(ljY|sUThHqp(!GQC22i zfeAaMRgl1v9sgWDf41{ZCjgSc<=gn3z8@Sk#i3w8YEQ`^ph#gZA|c=gP@=O2bY5j7 z(H%k8`xNx3E2>~rW<~sRJIyem%rDsko>5vuBoHF09TX_n@G2q~9dy?adFT;jYlju) zs1t_Y3Hz+qq_#z-fJZTcjR?EaNQxtW7~@?&)7eH;uGQ)N2Fw8!zRvs4xtZBToM_u0 z#uJ_P$F)tUNu0%LX{WYt>lrdi^%iC2&S)5qdogxPu8y`dGOr%j{wL?s4-*)HVW(zb z7-;J;A>)&&+7n%<Q1g$oisW%--NUsU#TpfYo)3{sdN3+Ps=#{ zsrU<%FSIF2!>ESu-RQk1VE8gj(J~z$qzFXYsk33%seT0Z%D>nWx#II! JMr^~e^9{1WfL{Or diff --git a/bagel/codeanalysis/__pycache__/syntaxtoken.cpython-310.pyc b/bagel/codeanalysis/__pycache__/syntaxtoken.cpython-310.pyc deleted file mode 100644 index a0ca05a2efd95ae1091984f056b2c89748be95b0..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1326 zcma)5y>8nu5GF-Rk!9I&8utfnU%)_74_(_LXoe02yrh#BLJ^r%i7dIK+{S^n1n7%& z$t!W~)Hz$H-cfNX7YPswJn@dF`|jscH5fz$*8aPnhd(?*excG`9F#rS<`oD@BrV9C zCY0jYE4(>N7$qNxWRhPJ$rZa`377r>nFPNnd@`XnI#`u;diE(VE$#FJDp=_xLm@&OF8KvbdZ0(3N3sw1eRt16 zkLAGK$Ijw|Whl3uW#B9USVnTkS%&fvB)@C>ZPuTwQ&n1i3d!4WQJK8XE6{6oR$KpD zS}axOL$d3IXJ{kYhizVhXlO$OX*`g$VIaMRgJhB%kSjWyaO(>fyeDp>`@)3}go{7% zEjOw-(imF@D7H{wv#yBVhS#4r)9;l&HH$P;X8IvLR>kzt$qd?@mT9pvxtSU_hZ-w- zy;#{$h`h{eAuy)FZ~?_9qUYmI@vqlzHqfeG>N3N*t{0whW5L%Ls39j%n(o1ILN$`> zis~V}T&ArUp^D|iu&=RSfpN?#Esdq8{O;LS3-vQ``;~XD@$7U1P!+jV6_T^3locvR~bO;+QL(V)b`ry9k z$blEP(RaFCa#Wm6wvjbuI#)v2NQikQmj#|#6AP1h@u4< z)09%&vx1Fz$|-qA6j$PsC~?73p@IXFguf_UNT}<*J)0P9ZC;fJ)3VOaz}H^vK2|5X z9Kx|%D+FsF#Fn5mNvR?!Q&e-sv`}0JqfkMPOOb|pO@*3|m|9cOrMRGJ#F5F z>)sQ9r>$b|Y3a7==ooHxMnY|-J9-!WIttB+0wQH+9J1Q$%=R@m+sjAv->Qc#S zBu9CnW$p0`fVo<@2Nua25W53vPUl3DIRj1S95hqpfLzf*!d)zz@dN1-Y{`2W65)i^ z#mEE@&>%f#4b&Ae9r*ly-v3gW6FbR<+V)>(N4n@AdOfU^&dRKq+T8Z7=e~xr_9jyo zNtu^?s6raj7M*SXEq`xy#)U@Lr=}d@i>?;#QLxf$3@|6hP??Efn^3b3pDSu& z_;{2HwSgv9(FVCjqCz&?X{2lr^3QB$6QeBiVDp+SRLDgm3qtCmYa7(8+sJ`5|6g!K z`CxFQALA~9?>2(pdpsve140u%Fw02_ zKV-&g1Dz92{LVav%P#On!p$Q@gf4@fcbAYS;6w4R9kYl=bk=Ji_fZB(7ki`3##&0( zl5$+BQ|NRF%_={iX2tRsQRKEZScJi93^MJaiK!;q)YChS>S9}GFhgTqf2x$@aMOj= z;jtdp1`#!o`bYF#f|G=uVzH`->`)f;DB~-6N)4VEBms=%%^!@kzRNu@*IpQYNEaya V#zV5Q*s){{#IP8dm@S diff --git a/bagel/codeanalysis/__pycache__/unary_expression_syntax.cpython-310.pyc b/bagel/codeanalysis/__pycache__/unary_expression_syntax.cpython-310.pyc deleted file mode 100644 index f066f57d5e8795f6a1e6cb2c24b7ba1a479baabb..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1332 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 diff --git a/bagel/codeanalysis/syntax/__pycache__/binary_expression_syntax.cpython-310.pyc b/bagel/codeanalysis/syntax/__pycache__/binary_expression_syntax.cpython-310.pyc deleted file mode 100644 index 3e79ba673069013647ca51b8e8fc57ee213225a1..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1576 zcma)6OHbQC5Z;IF1m{T!v{I2;sp=sYa_s?ClnNnKDXmB=wZ5!Ob^`{-PIrwUC^z^8 z{THaW{v2O>>X}z)hr;V^nm6|@M_L&ZrAcp` zWZ@;~{DS)sB@(1cA$?BIRMLl+9vly(9k}KP5JdtiNx;4k#g!xJHc>7-89Y(u+kixI zz~M?y@qs5xvV7wNo+`-|RURLIjyGpmf54GD&*mmUi1*W4&|1pt+&$>NJN&ly z_0!>AuXpgVdrNf<3^uWXG|U;aQZ2}Z<|1i5nB`phir2e==GBP9!~xLg~WkgR9!pLFJ~b)mxQ#7)onL$ zSd(z5gvfm%hN(P{k*^Bz{XC2di^lfA>WVN)(k#s2&&vp*aT7I;LS7zeOd%WFY1G(K zSm?-P8W(haByid0Mnb!w!~Pj8mQTtQe;bUsO&woAe4qt&x81Hafq n9AJwks1yqOcT-@-VD|u6Ja#?G+eHE1;!GK=aFtYPmA3dlD&Jag diff --git a/bagel/codeanalysis/syntax/__pycache__/expression_syntax.cpython-310.pyc b/bagel/codeanalysis/syntax/__pycache__/expression_syntax.cpython-310.pyc deleted file mode 100644 index 035a5b246af31814dc167e52da34a39edd689a05..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 369 zcmY*Uy-vh140f6#s;Vb3@Bpk`$P1iK6%t~*f!n%7xh6s<(xfDJ;yT02AYKS%W#Sc> za1z9iC4aG<&!26(Sk!>_wtwB;;`<(xzgA+>q5BI236f|SNlysefGi|^21ylpqJ1ID z4YVg81Zgb^^=3AEaa>!e2CV$ENa@ghgP@=%60n_MdlAmAkCRj0@2vS&XlbZ8H)2$r zhnn-z%7cz^!}-HO==}2n?iAG$e0J>7x_du~L3ws1?v!TRgafW4jL@^+dFIoGO#KYx wxpFzpj-pn)+()ROB&o7)XF>d?hnWbBRQmCB_W zTaZt7554ss6iALiFZ~n!6MO9`r`~l*XGq(zQ>6=#;taoeaAr8vpi&7Le!o8ZV`~{# ze-m;3bC9@;BfEi>Q*z z-hY^+0;!UvHU_&g?IGa8=OT3%N4A5LWL*%f%Qu;Hq$}VKlOF!^J7`NfPq;uk$8Oh` z1>s8%>4FH3-6QA*hC_&=2o0wwYN9MEhz=23!kwy^L#ixF=;?g!t;l_;axc60WjD~|O z(a9iHKCyZ3X0rc86_9wvR0)5kUo1WwsNHNB_hh!X9B<41;+C0v10mxy?jK}HwwRfK zF80akTf>7qh@vD-bQBd)M@Gth@F9e8)tu|r>2~fbsYfd9QD#m*TGKG6A=wFgO5Q`e z3C7V^pr}HOgLWz-nU~H5sfvt@LgMrBytR35_dn*Sq>Q-+F36n5&^_fxuI&%~j|T`0r2VtqQO$+!E zlZ;ulE+|{f#)+Ax-4x5@8rh{d)L|T2o5a3gk7^;nVFIv%;CBKruO00^^@uC5{*PP} z4*x~rB~#xM_mF~R>4gb<5xm6oopQ2I2{D0d?2rP;u`+R7Wxw$2?9dtex;Sx;;Lv@{ z(#tN>;lV1Pw2?2pC<`O=9Piif&P%-EKd=;@G2>4KH8~Ua%$q8Db4<2QydgTh;0q1Z?I~UCAiG>WCyz`PJeviBt&ujo^(H2W^bz^zOys;l`e(=jBLA9+tQ%zE z3>hFYpNYI=kii+Uh{%6tA}pNK}1>RVIz+|=|G zZsu@f3X4(Vh%6+TNVXHLE)(UT**yF%?vG?ksev-hCHLduP^Ka;wKpFvx7Lj` z37Q_5&pp2XV58MpTe{b>JH@q?&5m7$j~=v7*Tv4p(ur)?Sy}4bw~*@UTC2UbwBBl4 zdhXuJYNvIM5iBo#ZMK@&dB{mG)3MTBAKT2f-Z8y7_b_TB`EIYlPPG3Kiex|HRD(K% z9D6PgAbb-#b>P@{%J3oZH#L57rv@$$p-K|(nFGVW!mFs|V{qS$i?)}b#U@wOY}?HW zb^SEnlTnn1QM5M@qdu+6QS{R&?w{;9nO6B+6vb&e&@sI|8DiXig8T}dHyEnHP%3?( zYDk*2nQSSO)SJYkhw0oz&0o<&O^qz0%!VugbeVIn2HdGZ=+zyAXg9q)w2##;zW%mG iN|vGN4}i5o%FY=u_RJF#+_A^{ikh$K=Vexgy7Mnpk=>#I diff --git a/bagel/codeanalysis/syntax/__pycache__/literal_expression_syntax.cpython-310.pyc b/bagel/codeanalysis/syntax/__pycache__/literal_expression_syntax.cpython-310.pyc deleted file mode 100644 index c472c234ce0ddc100f68920b55e89fdc46710229..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1198 zcmZ`&OK;Oa5Z?7GuH%FTDskb!0S>-2CnOFP;-LsCs(_k;kS{AYyDe@vcGz{*Cd#e- z5B!FRf3#OloVjsgW=*5C)GO_H9=o1zzL_mMoru8te*WX|nM24=G}e~~#!J}xIS5WT zm1IIwN>O*DGjUVb>aO%Ae(F>5mT-^zSA_e5Ub<<(gAqwuzbIT!sM#D`OqI|&FN@Kv zsIm+2MYZ-mFF083+BzstMKOj;H`WTxXK)LWQchCm6A`ZPINbq6!aZ`h%e^Zv^+f;} zT3`pfb>&^sGz5DC?2vCjJhE{-AMv)0w|NX$JLchDUI~@S+gMGP$vVO+gl9T8%rWq{ zTBzfG16w1-3%Vc-SR0Wg9WJQ~z?V42(?TAp78pyS+VJ`Fu76&tQ$5YbLib;1$3pfG ztsIwJWJM-tI@f(|+3Q~e5Gz_)9oe4FOvqSX^opF&5m6ziiKATjnBLy*!C?Q@-r&o}{lRFo`vJ?u(rsO}i1DCz3av)% zH)0B$`J*OGc(54k~FiV(em(O$1{mVr)|KGl_c4*tfGx))9s8!rWsl zD~htpDtKL*G1WnDI926TsA^`Lq^n^4xGj&$0VjP-E#i| DK+hMA diff --git a/bagel/codeanalysis/syntax/__pycache__/parenthesized_expression_syntax.cpython-310.pyc b/bagel/codeanalysis/syntax/__pycache__/parenthesized_expression_syntax.cpython-310.pyc deleted file mode 100644 index 609c7828e31200781e755d71687d89f9871fddef..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1731 zcma)6&2AGh5VqHwO}hClO@9s`RU8oE&|E;`P@w{f5JC!70}|ScwZv|_?PfRFTeXRD zYoCC(sCW||VXvGx_r?Wgyd({265(jZGvk@{=lMxoF1rNQ_w#R`M>ZipP?=s}BYQyl zIWR#44M~rBl%i~fR*!ki$SkybIWI@a8zO9xyCNbd=_T_V;dDqN|C2&^gQm6CMPEs+ zgE;C8qQt)do101Rf=GZ?%(M^jsf@Z1^v`lY+XK>Hfl1;~K|Jdtkxbfx?h=`U-GUu; zwhKrk0~|TwNOtImyeM4Ro+I;OMHUV%;fmsweM!9)&|T0=q73InbIw4oh^jd+8A}c< zHL+?e<%!Qdv1Tk4QHOV~rw{ghC8Ok6>R>3v>}%6a9`|L$`x7V46MSh}M>4*Wh1nH1#+HNp~X;*n<1z-(3 zwY3Zn)e2g$eN++HHBlAVezlwDu{za#zbkd~m476|=4ZpZv5JH=U>kJFgsB=!)cXsKZ@eSPvAdQ zbFQ%93fm|x^c7@QB?HsXs*W~040NJ!;Ah(jhj*r(R1R!dbiEDCB?XE<*RrVl+j45O z!Yo#!8P%!rZa4Dj>TNdv&anZNy4g_U0Av$Z%narq(7eWcVhV)8WTvdJn}0Xr285p5~od diff --git a/bagel/codeanalysis/syntax/__pycache__/parser.cpython-310.pyc b/bagel/codeanalysis/syntax/__pycache__/parser.cpython-310.pyc deleted file mode 100644 index 4bef039790ae646f81aa81dce2c85b24a9aac7ff..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3401 zcmZ`*TW{RP73K^t%jI6RT3MDI$7+Gp*fh1$B1wV5Fk(BKw6P-@l8pv@A=W#y@=9Fp zW=JK{f&vQ2PyGu;0r}BLei2{$lz-3$0h;d&xfjU_2@cQ9oH=tY-#IhmTFo=?{P(-> zUqm&-_z!iK9}}HV@x}i{BMiYpW5j&Mh~^<5nZBuMGqgswZ)@5Lol(gzY1$6mQQ0qR z+6lc;#jj|(6jnzyzouz7tdAOgL(}E3Ia={oH0_10(W<}7j4upP5!F|QsGf1ZEoys4 zr~V^@LLHW^J&$_oqlEAC_ErZ1g_G7yp1p z8a@+-&z~F8l$K!k;CN{dxG;tF%JLmq61FtacSPxxb;f*G+!SS5#;7;2geNMmY`>zp zJaAP-O>yu8R$D zw8agC<(~xKKLxBDobAJSeX^eaG>h6+=f`Gd|Pkz z#!xpg_|wN*-;LE_Jn8jiy!EiRFT<@Dy6umJ>_xrsBp$|FvBvz?M0@`3FUP zAZS8Jd>xI$=ykcvs=SJ}#jC9PbK99V@_5~yt;ifDlOq-NDZge9(e&wHIUwLzav9t1 zFzu~3Ol@FTE1fs*P?vW8Exwo{@9=4>*lfuOid4*;@n8_kiwGff%n|YlI<#rZ)(t{L z0-PN1Gj?dJYedcZf?YQ@pc;*(oG8Rq=~`i`71|2ni&P6#$INy94UO6eqddN(e`Zaj zJp3KzV~ViH>a5K?KCKjH(Ck}&B2%@WXh~|E8?T{+x{VHe^&Wm|lNt)|!c$qPf263m z`~kz-TP~m0i*1Uj3p>#+bLWto$vLNR3V_W7)39bK!_MUY4p(G_b^vG{Dm`#X3ok;N z=3xIL_+tvS1FJ1IT`81VaHuwBFXS{SRl=vu{|p2vbpSOEx$@u&POiY1d5$`k&;1M4 zEM;iTf7_JTiJj&%4h|UO%tB4Ewx>6`ySqEPf7yJF-6yi2NU^EYWb@vgY5mUq4>sq+ z_kLpcJEh!O(ofx?h7ww>Qd35gxwFik`9gDE@}i`w*gIjH-YrPpd_Y^<=h!9}pQpg}xLr z>dOnkCV0=S%Wns;2A08|+%_{c1w(<}Oi{>@sGG2x3OOv!%lN6CIH{G|XZ(~$G+M$e zFB_2J&ZRi1qyCgSkigW(WfX0K(2^VnUMwZ$ltWVK%sl1ayr&w_t>dW*e*Ud}nFL34 z6$r)?ob1V1Etzx~DZj@OML5o`YcGIxIHI)+_xkUW#25N@aivI#d&kYQY>Px$p&TUs z#;+=o)#sXNSZ5{OkA&|noS)fhxc@S_6iG!2Yk+Nnun@&2AnGBWF6X?CKWCQX{!AnM zf7A8l2rt=m0k?F@%_I9II(e!RVv)!<3-1$(ZHgEE4(3XTgPFL5!d%h&i~I)v-+9pwUEoRQPp7rga066o}!kd{x?03wGUG(4TM&b~q$u#oi9R?p za~LJMVCBb#F4(%9kQcZo7_>!8DA8q2pT<YTTltZnjA zlhw_ZU3c4dYfTZ~Hf&nY0lPqckY6;4{3tTu?PWax$~I z>EF)lPjTH|0_#kkMuC^>w77;<@&TPldAToG65PCX-Si8V0bRazk|2z2&v`fU`$42;#gpn8W9QtcFc57xW?AA>kuWFR->W)`BEqp0QcvZRPY%z0LO0T#cWK#_P(O4e&~BXKw2&*RLAagUT&S*Ld`Pm z<|?0Br;FUFsk5myHcKth^Xn*_M<5}(lEAMxm+-B-!ejTpIsV~8PY-;K&>%j43AKUU zVzha^167njZd(|Gyuw!!{YRA_I11z_;{~yE^eDK*K> zY)p2f)R&naFHa(0=wg^oZ1E{KRdr&R6^@?cHb|&5R)lJC)Lum2Q=tvUVH0@$0fhay hE6P^YBh=j?XE<0%5^@GAji=Sao)KhEIU{yo`~fNe-d6ws diff --git a/bagel/codeanalysis/syntax/__pycache__/syntaxkind.cpython-310.pyc b/bagel/codeanalysis/syntax/__pycache__/syntaxkind.cpython-310.pyc deleted file mode 100644 index 5ce63cd0b1e504b41071baf2d46711694f7e1996..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 687 zcmZXS&2G~`5XaXaN!E@Xrxzr8=sg#5MnVXuU1(I-w!Ddexma$-LZyyVVglsA30?;A zM!s^&D{$(Lohm_$<)8mEo}Jkpd*!+|Q|5g6ee+#o><>A|W-8~Ex~nq?!54*sz2NrU$ z(SknO;9wtIbYOrkcsPI|daBc~w&k|`oPE2xEpbitcMWt>27&gy>kztx9)S}q0-br+ zCpZLGAsn65JWb1NnWt%Or|EKqn}W2Hrk^%hv46uS{>3c15+QIAy>6BF_HsHCGWO3! z8|a7g>xoDjr?%o?E?a3|Ps2xT$(g^;uw~%O%XaA?ibWXvi3nTYI}ai$jshov>XrC` zco!!^%4rmWHxK>f{UJ~fC)0l;;58KvDZkkIsXBFozt6{CSL?g#K3n9~c#?g{i}6jv z#R~JR%!+MwTaBw`;`_&)8vL{S?V2V|vu^$m&P?6Z{<{o{aIMK58MT?0n`LbZ#U^yv XNUKg&xthOd=l_zvYegM6dty8QZzrD* diff --git a/bagel/codeanalysis/syntax/__pycache__/syntaxnode.cpython-310.pyc b/bagel/codeanalysis/syntax/__pycache__/syntaxnode.cpython-310.pyc deleted file mode 100644 index 7ba599d64098a9409d3526733f3e40ad79ea73e7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 625 zcmZ`$y-ve05I#F;2~jE}7BMS_#=d_VSg-}#D8#|4!2Y&}@x`ANaPSQuQPno~3qB+FpJV#eSeB$w6_q_yBN zmv#hx>xaek*>DpGTS0DnGT0Z%DHHW NT+)^dA$o9Z{Qz}4gC+m~ diff --git a/bagel/codeanalysis/syntax/__pycache__/syntaxtoken.cpython-310.pyc b/bagel/codeanalysis/syntax/__pycache__/syntaxtoken.cpython-310.pyc deleted file mode 100644 index 6e1f7fb4e0cc1ff6dd56c9aa497263c1451746d0..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1412 zcma)5&2Q5%6t`n1P1Db@ZcGRvu9eVw;({hL!GQx(FM~@iR#tl>EKQ1?!aDV~{TbtbtRAcZtPIu$to(pTUojadUp7=AL)AD5Wm861JPuV; zwiG+@WLtKw_$7@a&|9E)We@yq=l4PH%Pr^cI7S$L@4KX4?}Y$@8L2@F^LHVQF4kW=d^?;`pM>y)o`7pbouiI55Sbj&jl5eaGaJ@LGtPrJ-xeOk={)fhX5M->_O j9FStwO>Yf3JQ>X($VF~~v*AIN@oS{KK_0Y8n-17tn~fjS diff --git a/bagel/codeanalysis/syntax/__pycache__/syntaxtree.cpython-310.pyc b/bagel/codeanalysis/syntax/__pycache__/syntaxtree.cpython-310.pyc deleted file mode 100644 index 9653dfc8055e93d605eaa0705ba10648eaa3058b..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1482 zcma(RJx?1k)b@SkxFjTm@(t>I3)w1FLKSLNb&D#|F1J`m>_E!pF10TzL}7ydk9I`; zM_xNIvvulwzJy+ZO10$o<>%-3>Acwt39RQ|e;f}SLVhAsT_7Wegi!qg2tfo*$%w|3 z62XL%vXK)zmUdHjTqQ!`sdXi;%krcx`)3>ygwcnnP zmDCz!M;BRaWEML1

hp7A?`XTn)G#u_8K_3*?g66>DPMa-rCO81_s!cS=cV+;pf5 z)8Jy5oMgE!hJCHjFXM5Q=Y{f+?r@n2o)7q7m`Yw?Fs5F)VO-QTE047LXlk*LX0YF2 z$m>AN=!|eOV*u&Q0muY7A~&=bIVym2wS)kx8o9>RG99QoN*V~70B(qC1N!x{`z2Rr zdYts7?!Hb=WZFHpu%8Q=WJ!9Vhq|k6QRb+C;P=NDCg6OS4GYfEsP+N))TbexuKr2V z{zAw2N){89^|9iMg*0vq>kbXf$R`LxEdv=*8^{e+E#R!PC0IcggF)gBv*NSqdgaMV zcK`XBdWKf!@7P?ep#W1-c?AQra!mQORe1x8_J78)2I?u}ScNS-w8nQU#vk>9aSM4~ z7)KZCuSan%@7rP*7(oTY*}R0=#1^@tmu$wqvG0)8$muD(0HfuN?rVA~Fx*!G^CjEJdK6yW)S zMvVoH(-XO+E1RfjwXsQ}I<{Vxj3nnKKZT`&Nx%QOK;Oa5Z+xs;yTWwCFM{F4v0%G&6Puic&H$R6i`D2__A`d+v3()hh0ZBQEu&@ zsrW~}a^l<@CuY`4+NOb(c04cde&5X4d7}{$Sf9^-9(5c-exY%DxnR72ZJvP;M9_?k zXiO>UEMp@lcC7AX?#PQhO5PIT3h$B#Ptpq~_Juzn-P&&ouXkzL-aj8}X-t}{!BiE= zIrzd#d!H%+R=u)5+!(T6fNs%h&C|UEVmC;qNl4o z$`;SZQYS^Od4br=pmHctHdi7wYb!B?f-e{94EAf-rVV0F=Y*3v0|_(-Agx$WY#;fa+nL5s3e=3)bxxke{X_h zxLkIHSN`4c6bSHCr3L3WAqGqD(~!;{ujRkHNG^RXi-}f4?D%4#j@yz$3I#c(1ETR{ zAcfq^)?xqU!PosS9}o5igLfbLS5()*Z#h+>fobj;%t;fpYpj;fW;^TgVA?$l%K~Ge z=HwJNJz+OUmc`VYkgw#DnC}`E> zH2`d{A0n^^AZAb3-+Fi2{&}z7#)E7JsGX>FlcEN^`DpBt6vcbhmgDj7-6%aHR? zE+!f35$E40NmfNPjuLz?JW(nyk^=q(hI5Uj)Y#ZE7;EHEOzmK3EOhB+sVQ^^b8dQs zU0msr_P~b~HCU&R1T>&qjJa*vbWk#i$O+rqa; a+`8H#vGW=1Rji+5e+^=dNJJyrasC2if;mY5 From 86d950f8a6d44e81e419e8f914c88d3272470fc7 Mon Sep 17 00:00:00 2001 From: Billy Date: Sat, 30 Jul 2022 08:05:38 +0000 Subject: [PATCH 11/12] Add binder --- .env | 1 + .vscode/launch.json | 16 +++ .vscode/settings.json | 3 + bagel/__main__.py | 11 +- bagel/codeanalysis/binding/__init__.py | 9 ++ bagel/codeanalysis/binding/binder.py | 107 +----------------- .../binding/boundbinaryexpression.py | 34 ++++++ .../binding/boundbinaryoperatorkind.py | 8 ++ bagel/codeanalysis/binding/boundexpression.py | 9 ++ .../binding/boundliteralexpression.py | 21 ++++ bagel/codeanalysis/binding/boundnode.py | 9 ++ bagel/codeanalysis/binding/boundnodekind.py | 7 ++ .../binding/boundunaryexpression.py | 27 +++++ .../binding/boundunaryoperatorkind.py | 6 + bagel/codeanalysis/evaluator.py | 2 +- 15 files changed, 162 insertions(+), 108 deletions(-) create mode 100644 .env create mode 100644 .vscode/launch.json create mode 100644 .vscode/settings.json create mode 100644 bagel/codeanalysis/binding/__init__.py create mode 100644 bagel/codeanalysis/binding/boundbinaryexpression.py create mode 100644 bagel/codeanalysis/binding/boundbinaryoperatorkind.py create mode 100644 bagel/codeanalysis/binding/boundexpression.py create mode 100644 bagel/codeanalysis/binding/boundliteralexpression.py create mode 100644 bagel/codeanalysis/binding/boundnode.py create mode 100644 bagel/codeanalysis/binding/boundnodekind.py create mode 100644 bagel/codeanalysis/binding/boundunaryexpression.py create mode 100644 bagel/codeanalysis/binding/boundunaryoperatorkind.py diff --git a/.env b/.env new file mode 100644 index 0000000..fa1d905 --- /dev/null +++ b/.env @@ -0,0 +1 @@ +PYTHONPATH=bagel \ No newline at end of file diff --git a/.vscode/launch.json b/.vscode/launch.json new file mode 100644 index 0000000..b538b66 --- /dev/null +++ b/.vscode/launch.json @@ -0,0 +1,16 @@ +{ + // Use IntelliSense to learn about possible attributes. + // Hover to view descriptions of existing attributes. + // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387 + "version": "0.2.0", + "configurations": [ + { + "name": "Python: Current File", + "type": "python", + "request": "launch", + "program": "-m ${workspaceRoot}/bagel", + "console": "integratedTerminal", + "justMyCode": true + } + ] +} \ No newline at end of file diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..26df38b --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,3 @@ +{ + "python.linting.enabled": false +} \ No newline at end of file diff --git a/bagel/__main__.py b/bagel/__main__.py index 99bbcc3..569b3cc 100644 --- a/bagel/__main__.py +++ b/bagel/__main__.py @@ -3,12 +3,11 @@ import colorama from colorama import Fore -from codeanalysis.binding.binder import Binder - -from codeanalysis.evaluator import Evaluator -from codeanalysis.syntax.syntaxnode import SyntaxNode -from codeanalysis.syntax.syntaxtoken import SyntaxToken -from codeanalysis.syntax.syntaxtree import SyntaxTree +from .codeanalysis.binding.binder import Binder +from .codeanalysis.evaluator import Evaluator +from .codeanalysis.syntax.syntaxnode import SyntaxNode +from .codeanalysis.syntax.syntaxtoken import SyntaxToken +from .codeanalysis.syntax.syntaxtree import SyntaxTree colorama.init(autoreset=True) SHOW_TREE = False diff --git a/bagel/codeanalysis/binding/__init__.py b/bagel/codeanalysis/binding/__init__.py new file mode 100644 index 0000000..6839e2a --- /dev/null +++ b/bagel/codeanalysis/binding/__init__.py @@ -0,0 +1,9 @@ +from .boundnode import BoundNode +from .boundnodekind import BoundNodeKind +from .boundexpression import BoundExpression +from .boundliteralexpression import BoundLiteralExpression +from .boundunaryoperatorkind import BoundUnaryOperatorKind +from .boundunaryexpression import BoundUnaryExpression +from .boundbinaryoperatorkind import BoundBinaryOperatorKind +from .boundbinaryexpression import BoundBinaryExpression +from .binder import Binder diff --git a/bagel/codeanalysis/binding/binder.py b/bagel/codeanalysis/binding/binder.py index b82a268..cbdf97f 100644 --- a/bagel/codeanalysis/binding/binder.py +++ b/bagel/codeanalysis/binding/binder.py @@ -1,4 +1,3 @@ -from enum import Enum from typing import List from ..syntax.binary_expression_syntax import BinaryExpressionSyntax @@ -7,107 +6,13 @@ from ..syntax.syntaxkind import SyntaxKind from ..syntax.unary_expression_syntax import UnaryExpressionSyntax +from .boundexpression import BoundExpression +from .boundbinaryexpression import BoundBinaryExpression +from .boundunaryexpression import BoundUnaryExpression +from .boundliteralexpression import BoundLiteralExpression +from .boundunaryoperatorkind import BoundUnaryOperatorKind +from .boundbinaryoperatorkind import BoundBinaryOperatorKind -class BoundNodeKind(Enum): - LITERALEXPRESSION = 0 - UNARYEXPRESSION = 1 - BINARYEXPRESSION = 2 - -class BoundNode: - _kind: BoundNodeKind - - @property - def kind(self) -> BoundNodeKind: - return self._kind - -class BoundExpression(BoundNode): - _type: object - - @property - def type(self): - return self._type - -class BoundUnaryOperatorKind(Enum): - IDENTITY = 0 - NEGATION = 1 - -class BoundLiteralExpression(BoundExpression): - _value: object - - def __init__(self, value: object): - self._value = value - - @property - def kind(self) -> BoundNodeKind: - return BoundNodeKind.LITERALEXPRESSION - - @property - def type(self): - return type(self._value) - - @property - def value(self): - return self._value - -class BoundUnaryExpression(BoundExpression): - _operator_kind: BoundUnaryOperatorKind - _operand: BoundExpression - - def __init__(self, operator_kind: BoundUnaryOperatorKind, operand: BoundExpression): - self._operator_kind = operator_kind - self._operand = operand - - @property - def kind(self) -> BoundNodeKind: - return BoundNodeKind.UNARYEXPRESSION - - @property - def type(self): - return self._operand.type - - @property - def operator_kind(self) -> BoundUnaryOperatorKind: - return self._operator_kind - - @property - def operand(self) -> BoundExpression: - return self._operand - -class BoundBinaryOperatorKind(Enum): - ADDITION = 0 - SUBTRACTION = 1 - MULTIPLICATION = 2 - DIVISION = 3 - -class BoundBinaryExpression(BoundExpression): - _left: BoundExpression - _operator_kind: BoundUnaryOperatorKind - _right: BoundExpression - - def __init__(self, left: BoundExpression, operator_kind: BoundBinaryOperatorKind, right: BoundExpression): - self._left = left - self._operator_kind = operator_kind - self._right = right - - @property - def kind(self) -> BoundNodeKind: - return BoundNodeKind.BINARYEXPRESSION - - @property - def type(self): - return self._left.type - - @property - def left(self) -> BoundExpression: - return self._left - - @property - def operator_kind(self) -> BoundUnaryOperatorKind: - return self._operator_kind - - @property - def right(self) -> BoundExpression: - return self._right class Binder: _diagnostics: List[str] diff --git a/bagel/codeanalysis/binding/boundbinaryexpression.py b/bagel/codeanalysis/binding/boundbinaryexpression.py new file mode 100644 index 0000000..fde3beb --- /dev/null +++ b/bagel/codeanalysis/binding/boundbinaryexpression.py @@ -0,0 +1,34 @@ +from .boundexpression import BoundExpression +from .boundnodekind import BoundNodeKind +from .boundunaryoperatorkind import BoundUnaryOperatorKind +from .boundbinaryoperatorkind import BoundBinaryOperatorKind + +class BoundBinaryExpression(BoundExpression): + _left: BoundExpression + _operator_kind: BoundUnaryOperatorKind + _right: BoundExpression + + def __init__(self, left: BoundExpression, operator_kind: BoundBinaryOperatorKind, right: BoundExpression): + self._left = left + self._operator_kind = operator_kind + self._right = right + + @property + def kind(self) -> BoundNodeKind: + return BoundNodeKind.BINARYEXPRESSION + + @property + def type(self): + return self._left.type + + @property + def left(self) -> BoundExpression: + return self._left + + @property + def operator_kind(self) -> BoundUnaryOperatorKind: + return self._operator_kind + + @property + def right(self) -> BoundExpression: + return self._right diff --git a/bagel/codeanalysis/binding/boundbinaryoperatorkind.py b/bagel/codeanalysis/binding/boundbinaryoperatorkind.py new file mode 100644 index 0000000..2cad387 --- /dev/null +++ b/bagel/codeanalysis/binding/boundbinaryoperatorkind.py @@ -0,0 +1,8 @@ +from enum import Enum + + +class BoundBinaryOperatorKind(Enum): + ADDITION = 0 + SUBTRACTION = 1 + MULTIPLICATION = 2 + DIVISION = 3 diff --git a/bagel/codeanalysis/binding/boundexpression.py b/bagel/codeanalysis/binding/boundexpression.py new file mode 100644 index 0000000..eadc111 --- /dev/null +++ b/bagel/codeanalysis/binding/boundexpression.py @@ -0,0 +1,9 @@ +from .boundnode import BoundNode + + +class BoundExpression(BoundNode): + _type: object + + @property + def type(self): + return self._type diff --git a/bagel/codeanalysis/binding/boundliteralexpression.py b/bagel/codeanalysis/binding/boundliteralexpression.py new file mode 100644 index 0000000..91de9dc --- /dev/null +++ b/bagel/codeanalysis/binding/boundliteralexpression.py @@ -0,0 +1,21 @@ +from .boundexpression import BoundExpression +from .boundnodekind import BoundNodeKind + + +class BoundLiteralExpression(BoundExpression): + _value: object + + def __init__(self, value: object): + self._value = value + + @property + def kind(self) -> BoundNodeKind: + return BoundNodeKind.LITERALEXPRESSION + + @property + def type(self): + return type(self._value) + + @property + def value(self): + return self._value diff --git a/bagel/codeanalysis/binding/boundnode.py b/bagel/codeanalysis/binding/boundnode.py new file mode 100644 index 0000000..fa01742 --- /dev/null +++ b/bagel/codeanalysis/binding/boundnode.py @@ -0,0 +1,9 @@ +from .boundnodekind import BoundNodeKind + + +class BoundNode: + _kind: BoundNodeKind + + @property + def kind(self) -> BoundNodeKind: + return self._kind diff --git a/bagel/codeanalysis/binding/boundnodekind.py b/bagel/codeanalysis/binding/boundnodekind.py new file mode 100644 index 0000000..b31895e --- /dev/null +++ b/bagel/codeanalysis/binding/boundnodekind.py @@ -0,0 +1,7 @@ +from enum import Enum + + +class BoundNodeKind(Enum): + LITERALEXPRESSION = 0 + UNARYEXPRESSION = 1 + BINARYEXPRESSION = 2 diff --git a/bagel/codeanalysis/binding/boundunaryexpression.py b/bagel/codeanalysis/binding/boundunaryexpression.py new file mode 100644 index 0000000..0d3311d --- /dev/null +++ b/bagel/codeanalysis/binding/boundunaryexpression.py @@ -0,0 +1,27 @@ +from .boundnodekind import BoundNodeKind +from .boundunaryoperatorkind import BoundUnaryOperatorKind +from .boundexpression import BoundExpression + +class BoundUnaryExpression(BoundExpression): + _operator_kind: BoundUnaryOperatorKind + _operand: BoundExpression + + def __init__(self, operator_kind: BoundUnaryOperatorKind, operand: BoundExpression): + self._operator_kind = operator_kind + self._operand = operand + + @property + def kind(self) -> BoundNodeKind: + return BoundNodeKind.UNARYEXPRESSION + + @property + def type(self): + return self._operand.type + + @property + def operator_kind(self) -> BoundUnaryOperatorKind: + return self._operator_kind + + @property + def operand(self) -> BoundExpression: + return self._operand \ No newline at end of file diff --git a/bagel/codeanalysis/binding/boundunaryoperatorkind.py b/bagel/codeanalysis/binding/boundunaryoperatorkind.py new file mode 100644 index 0000000..189c275 --- /dev/null +++ b/bagel/codeanalysis/binding/boundunaryoperatorkind.py @@ -0,0 +1,6 @@ +from enum import Enum + + +class BoundUnaryOperatorKind(Enum): + IDENTITY = 0 + NEGATION = 1 diff --git a/bagel/codeanalysis/evaluator.py b/bagel/codeanalysis/evaluator.py index 55df433..c0ae6db 100644 --- a/bagel/codeanalysis/evaluator.py +++ b/bagel/codeanalysis/evaluator.py @@ -1,4 +1,4 @@ -from .binding.binder import (BoundBinaryExpression, BoundBinaryOperatorKind, +from .binding import (BoundBinaryExpression, BoundBinaryOperatorKind, BoundExpression, BoundLiteralExpression, BoundUnaryExpression, BoundUnaryOperatorKind) From 759e45cbb628290f22e43f27af839050d0184022 Mon Sep 17 00:00:00 2001 From: Billy Date: Sat, 30 Jul 2022 13:59:48 +0000 Subject: [PATCH 12/12] Add support for boolean literals --- .vscode/launch.json | 5 ++--- .vscode/tasks.json | 15 +++++++++++++ bagel/codeanalysis/binding/binder.py | 2 +- bagel/codeanalysis/evaluator.py | 14 ++++++------ bagel/codeanalysis/syntax/lexer.py | 19 ++++++++++++++++ .../syntax/literal_expression_syntax.py | 8 ++++++- bagel/codeanalysis/syntax/parser.py | 22 ++++++++++++------- bagel/codeanalysis/syntax/syntaxfacts.py | 10 +++++++++ bagel/codeanalysis/syntax/syntaxkind.py | 15 ++++++++----- 9 files changed, 85 insertions(+), 25 deletions(-) create mode 100644 .vscode/tasks.json diff --git a/.vscode/launch.json b/.vscode/launch.json index b538b66..30c05a5 100644 --- a/.vscode/launch.json +++ b/.vscode/launch.json @@ -5,11 +5,10 @@ "version": "0.2.0", "configurations": [ { - "name": "Python: Current File", + "name": "Python: Module", "type": "python", "request": "launch", - "program": "-m ${workspaceRoot}/bagel", - "console": "integratedTerminal", + "module": "bagel", "justMyCode": true } ] diff --git a/.vscode/tasks.json b/.vscode/tasks.json new file mode 100644 index 0000000..5532b8b --- /dev/null +++ b/.vscode/tasks.json @@ -0,0 +1,15 @@ +{ + "version": "2.0.0", + "tasks": [ + { + "label": "bagel: REPL", + "type": "shell", + "command": "python -m bagel", + "problemMatcher": [], + "group": { + "kind": "build", + "isDefault": true + } + } + ] +} \ No newline at end of file diff --git a/bagel/codeanalysis/binding/binder.py b/bagel/codeanalysis/binding/binder.py index cbdf97f..9cf4383 100644 --- a/bagel/codeanalysis/binding/binder.py +++ b/bagel/codeanalysis/binding/binder.py @@ -36,7 +36,7 @@ def bind_expression(self, syntax: ExpressionSyntax) -> BoundExpression: raise Exception(f"Unexpected syntax {syntax.kind}") def bind_literal_expression(self, syntax: LiteralExpressionSyntax) -> BoundLiteralExpression: - value = syntax.literal_token.value or 0 + value = syntax.value if syntax.value != None else 0 return BoundLiteralExpression(value) def bind_unary_expression(self, syntax: UnaryExpressionSyntax) -> BoundUnaryExpression: diff --git a/bagel/codeanalysis/evaluator.py b/bagel/codeanalysis/evaluator.py index c0ae6db..cc7c767 100644 --- a/bagel/codeanalysis/evaluator.py +++ b/bagel/codeanalysis/evaluator.py @@ -9,16 +9,16 @@ class Evaluator: def __init__(self, root: BoundExpression): self._root = root - def evaluate(self) -> int: + def evaluate(self) -> object: return self.evaluate_expression(self._root) - def evaluate_expression(self, node: BoundExpression) -> int: + def evaluate_expression(self, node: BoundExpression) -> object: if isinstance(node, BoundLiteralExpression): - return int(node.value) + return node.value if isinstance(node, BoundUnaryExpression): - operand = self.evaluate_expression(node.operand) - + operand = int(self.evaluate_expression(node.operand)) + match node.operator_kind: case BoundUnaryOperatorKind.IDENTITY: return operand @@ -28,8 +28,8 @@ def evaluate_expression(self, node: BoundExpression) -> int: raise Exception(f"Unexpected unary operator {node.operator_kind}") if isinstance(node, BoundBinaryExpression): - left = self.evaluate_expression(node.left) - right = self.evaluate_expression(node.right) + left = int(self.evaluate_expression(node.left)) + right = int(self.evaluate_expression(node.right)) match node.operator_kind: case BoundBinaryOperatorKind.ADDITION: diff --git a/bagel/codeanalysis/syntax/lexer.py b/bagel/codeanalysis/syntax/lexer.py index c049cb3..300a7c9 100644 --- a/bagel/codeanalysis/syntax/lexer.py +++ b/bagel/codeanalysis/syntax/lexer.py @@ -1,3 +1,6 @@ +from curses.ascii import isalpha + +from .syntaxfacts import SyntaxFacts from .syntaxkind import SyntaxKind from .syntaxtoken import SyntaxToken @@ -21,6 +24,10 @@ def current(self) -> str: return '\0' return self._text[self._position] + @staticmethod + def isletter(c: str) -> bool: + return c.isalpha() or c == '_' + def next(self) -> None: self._position += 1 @@ -52,6 +59,18 @@ def lex(self) -> SyntaxToken: text = self._text[start:length + start] return SyntaxToken(SyntaxKind.WHITESPACETOKEN, start, text, None) + if self.isletter(self.current): + start = self._position + + while self.isletter(self.current): + self.next() + + length = self._position - start + text = self._text[start:length + start] + kind = SyntaxFacts.get_keyword_kind(text) + return SyntaxToken(kind, start, text, None) + + match self.current: case '+': self._position += 1 diff --git a/bagel/codeanalysis/syntax/literal_expression_syntax.py b/bagel/codeanalysis/syntax/literal_expression_syntax.py index 37bc158..3eb6f14 100644 --- a/bagel/codeanalysis/syntax/literal_expression_syntax.py +++ b/bagel/codeanalysis/syntax/literal_expression_syntax.py @@ -6,8 +6,10 @@ class LiteralExpressionSyntax(ExpressionSyntax): _literal_token: SyntaxToken - def __init__(self, literal_token: SyntaxToken): + def __init__(self, literal_token: SyntaxToken, value: object=None): self._literal_token = literal_token + + self._value = value if value != None else literal_token.value @property def kind(self) -> SyntaxKind: @@ -20,3 +22,7 @@ def get_children(self) -> list: def literal_token(self) -> SyntaxToken: return self._literal_token + @property + def value(self) -> SyntaxToken: + return self._value + diff --git a/bagel/codeanalysis/syntax/parser.py b/bagel/codeanalysis/syntax/parser.py index 50c15ee..18a50e2 100644 --- a/bagel/codeanalysis/syntax/parser.py +++ b/bagel/codeanalysis/syntax/parser.py @@ -86,11 +86,17 @@ def parse_expression(self, parent_precedence: int=0) -> ExpressionSyntax: return left def parse_primary_expression(self) -> ExpressionSyntax: - if self.current.kind == SyntaxKind.OPENPARENTOKEN: - left = self.next_token() - expression = self.parse_expression() - right = self.match_token(SyntaxKind.CLOSEPARENTOKEN) - return ParenthesizedExpressionSyntax(left, expression, right) - - literal_token = self.match_token(SyntaxKind.NUMBERTOKEN) - return LiteralExpressionSyntax(literal_token) + match self.current.kind: + case SyntaxKind.OPENPARENTOKEN: + left = self.next_token() + expression = self.parse_expression() + right = self.match_token(SyntaxKind.CLOSEPARENTOKEN) + return ParenthesizedExpressionSyntax(left, expression, right) + case SyntaxKind.TRUEKEYWORD | SyntaxKind.FALSEKEYWORD: + keyword_token = self.next_token() + value = self.current.kind == SyntaxKind.TRUEKEYWORD + a = LiteralExpressionSyntax(keyword_token, value) + return a + case _: + literal_token = self.match_token(SyntaxKind.NUMBERTOKEN) + return LiteralExpressionSyntax(literal_token) diff --git a/bagel/codeanalysis/syntax/syntaxfacts.py b/bagel/codeanalysis/syntax/syntaxfacts.py index fee7025..1050eea 100644 --- a/bagel/codeanalysis/syntax/syntaxfacts.py +++ b/bagel/codeanalysis/syntax/syntaxfacts.py @@ -19,3 +19,13 @@ def get_binary_operator_precedence(kind: SyntaxKind) -> int: return 1 case _: return 0 + + @staticmethod + def get_keyword_kind(text: str) -> SyntaxKind: + match text: + case 'true': + return SyntaxKind.TRUEKEYWORD + case 'false': + return SyntaxKind.FALSEKEYWORD + case _: + return SyntaxKind.IDENTIFIERTOKEN diff --git a/bagel/codeanalysis/syntax/syntaxkind.py b/bagel/codeanalysis/syntax/syntaxkind.py index 5d6038b..c8168a5 100644 --- a/bagel/codeanalysis/syntax/syntaxkind.py +++ b/bagel/codeanalysis/syntax/syntaxkind.py @@ -13,9 +13,14 @@ class SyntaxKind(enum.Enum): SLASHTOKEN = 7 OPENPARENTOKEN = 8 CLOSEPARENTOKEN = 9 - + IDENTIFIERTOKEN = 10 + + # Keywords + FALSEKEYWORD = 11 + TRUEKEYWORD = 12 + # Expressions - LITERALEXPRESSION = 10 - UNARYEXPRESSION = 11 - BINARYEXPRESSION = 12 - PARENEXPRESSION = 13 + LITERALEXPRESSION = 13 + UNARYEXPRESSION = 14 + BINARYEXPRESSION = 15 + PARENEXPRESSION = 16