include <lexer>

include <ast_nodes>

struct Parser [

toks: List<Token>,

pos: Int

]

impl Parser [

fun cur(self) -> Token [

end self.toks[self.pos]

]

fun at_end(self) -> Bool [

end self.cur().kind == Eof

]

fun advance(self) -> Token [

let t = self.toks[self.pos]

if self.pos < self.toks.len() - 1 [

self.pos = self.pos + 1

]

end t

]

!!! `value: Option<Str>` odpowiada Pythonowemu `value: str | None =

!!! None` - `none()` = "dopasuj tylko po `kind`", `some(x)` = "i

!!! po wartosci". `kind.clone()` PONIZEJ jest KONIECZNE, nie

!!! kosmetyczne: `kind: TokKind` to ZNANY enum, wiec ten codegen

!!! ZAWSZE przekazuje go jako `&TokKind` (patrz `_is_refable` w

!!! codegen.py - kazdy enum/struct/Str/List jest "refable"), a

!!! porownanie `t.kind != kind` bylo by wtedy `TokKind != &TokKind`

!!! - PRAWDZIWA niezgodnosc typow w Rust (derive'owany `PartialEq`

!!! daje TYLKO `PartialEq<Self>`, nie `PartialEq<&Self>`), znaleziona

!!! i naprawiona w TEJ sesji. `.clone()` na referencji auto-derefuje

!!! sie (w przeciwienstwie do operatorow `==`/`!=`, wywolania metod

!!! W RUST auto-derefuja odbiornik) i zwraca WLASCIWY, owned

!!! `TokKind`.

fun check(self, kind: TokKind, value: Option<Str>) -> Bool [

let t = self.cur()

if t.kind != kind.clone() [

end false

]

match value [

Some(v) -> [

end t.value == v

]

None -> [

end true

]

]

]

fun match_tok(self, kind: TokKind, value: Option<Str>) -> Option<Token> [

if self.check(kind, value) [

end some(self.advance())

]

end none()

]

!!! Bez prawdziwego `ParseError`/wyjatkow w tej wersji bootstrapu

!!! (patrz "Ograniczenia") - gdy oczekiwany token nie wystepuje,

!!! `log`-uje ostrzezenie i i tak KONSUMUJE biezacy token (best-effort,

!!! nie zatrzymuje parsowania) zamiast rzucac `ParseError` jak w

!!! parser.py.

fun expect(self, kind: TokKind, value: Option<Str>) -> Token [

if not self.check(kind, value) [

let bad = self.cur()

log("[hackerc-self] parser: nieoczekiwany token '" + bad.value + "' w linii " + (bad.line as Str) + ", kolumna " + (bad.col as Str))

]

end self.advance()

]

fun skip_newlines(self) [

while self.check(Newline, none()) or self.check(LineComment, none()) [

self.advance()

]

]

!!! Jak `skip_newlines`, ale ZWRACA tekst napotkanych komentarzy `!`

!!! (w kolejnosci wystapienia) zamiast je odrzucac - wywolujacy

!!! doczepia je do nastepnej instrukcji (patrz "Ograniczenia":

!!! `_leading_comments`/`hackerc fmt` nie sa jeszcze uzyte tutaj,

!!! sam mechanizm zbierania jest juz gotowy).

fun skip_newlines_collect_comments(self) -> List<Str> [

let comments: List<Str> = []

while true [

if self.check(Newline, none()) [

self.advance()

] elif self.check(LineComment, none()) [

comments.push(self.advance().value)

] else [

break

]

]

end comments

]

!!! -- program --------------------------------------------------------

fun parse_program(self) -> Program [

let body: List<Stmt> = []

self.skip_newlines_collect_comments()

while not self.at_end() [

let stmt = self.parse_statement()

body.push(stmt)

self.skip_newlines_collect_comments()

]

end Program(body)

]

!!! -- instrukcje -------------------------------------------------------

fun parse_block(self) -> List<Stmt> [

self.expect(Open, none())

self.skip_newlines_collect_comments()

let stmts: List<Stmt> = []

while not self.check(Close, none()) [

let stmt = self.parse_statement()

stmts.push(stmt)

self.skip_newlines_collect_comments()

]

self.expect(Close, none())

end stmts

]

fun parse_statement(self) -> Stmt [

let t = self.cur()

if t.kind == DocComment [

self.advance()

end ExprStmt(StringLit(t.value, true))

]

if t.kind == Keyword [

let kw = t.value

if kw == "using" [

end self.parse_using()

]

if kw == "get" [

end self.parse_get_import()

]

if kw == "include" [

end self.parse_include()

]

if kw == "let" [

end self.parse_let(false)

]

if kw == "const" [

end self.parse_let(true)

]

if kw == "pub" [

self.advance()

let inner = self.parse_statement()

match inner [

FunDecl(name, params, ret_type, body, is_pub, type_params) -> [

end FunDecl(name, params, ret_type, body, true, type_params)

]

_ -> [

end inner

]

]

]

if kw == "region" [

end self.parse_region()

]

if kw == "fun" [

end self.parse_fun()

]

if kw == "if" [

end self.parse_if()

]

if kw == "while" [

end self.parse_while()

]

if kw == "for" [

end self.parse_for()

]

if kw == "end" [

self.advance()

let value: Option<Expr> = none()

if not self.check(Newline, none()) and not self.check(Close, none()) [

value = some(self.parse_expr())

]

end ReturnStmt(value)

]

if kw == "break" [

self.advance()

end BreakStmt

]

if kw == "continue" [

self.advance()

end ContinueStmt

]

if kw == "direct" [

end self.parse_direct()

]

if kw == "manual" [

end self.parse_manual()

]

if kw == "gc" [

end self.parse_gc_pragma()

]

if kw == "struct" [

end self.parse_struct()

]

if kw == "enum" [

end self.parse_enum()

]

if kw == "impl" [

end self.parse_impl()

]

if kw == "match" [

end self.parse_match()

]

]

!! wyrazenie / przypisanie

let expr = self.parse_expr()

if self.cur().kind == Op and (self.cur().value == "=" or self.cur().value == "+=" or self.cur().value == "-=" or self.cur().value == "*=" or self.cur().value == "/=") [

let op = self.advance().value

let value = self.parse_expr()

end AssignStmt(expr, op, value)

]

end ExprStmt(expr)

]

fun parse_using(self) -> Stmt [

self.expect(Keyword, some("using"))

self.expect(LAngle, none())

let version_parts = ""

while not self.check(RAngle, none()) [

version_parts = version_parts + self.advance().value

]

self.expect(RAngle, none())

end UsingStmt(version_parts)

]

!!! Czyta tekst az do napotkania '::', '>' lub ':' (na poziomie top) -

!!! parytet z `_read_angle_segment` w parser.py.

fun read_angle_segment(self) -> Str [

let parts = ""

while not (self.check(DColon, none()) or self.check(RAngle, none()) or self.check(Colon, none())) [

parts = parts + self.advance().value

]

end parts

]

fun parse_get_import(self) -> Stmt [

self.expect(Keyword, some("get"))

self.expect(LAngle, none())

let source = self.read_angle_segment()

if source == "selfhost" [

!!! `get <selfhost:...>` jest zablokowane (na wyrazne

!!! zyczenie uzytkownika) - uzyj `include <plik>` zamiast

!!! tego. `parser.hcs` (w odroznieniu od `parser.py`) NIE MA

!!! wyjatkow/`Result` dla bledow parsera (patrz "Ograniczenia"

!!! - best-effort, `log()` i kontynuacja) - to jedyny sposob

!!! zasygnalizowania tego bledu W TYM PLIKU. `parser.py` (uzywany

!!! dzis jako stage0) DAJE prawdziwy blad skladni (ParseError).

log("[hackerc-self] parser: 'get <selfhost:...>' jest zablokowane - uzyj 'include <plik>' zamiast tego")

]

self.expect(Colon, none())

let name = self.read_angle_segment()

let version: Option<Str> = none()

if self.check(DColon, none()) [

self.advance()

version = some(self.read_angle_segment())

]

self.expect(RAngle, none())

!!! ZMIANA 0.3 - `get <extern:sciezka> use <static|dynamic>`:

!!! `use <...>` istnieje TYLKO za `get <extern:...>` (inne

!!! zrodla - std/core/crates/pypi/npm/jsr/vira/c/cpp - nie maja

!!! trybu linkowania w tym miejscu skladni), i zapisuje tryb w

!!! tym samym slocie co `::wersja` (patrz komentarz przy

!!! `GetImportStmt` w ast_nodes.hcs) - `extern` nigdy nie ma

!!! obu naraz, wiec kolizji nie ma.

if source == "extern" and self.check(Keyword, some("use")) [

self.advance()

self.expect(LAngle, none())

version = some(self.read_angle_segment())

self.expect(RAngle, none())

]

let details: List<Str> = []

if self.check(Keyword, some("import")) [

self.advance()

self.expect(LAngle, none())

details.push(self.read_angle_segment())

while self.check(DColon, none()) [

self.advance()

details.push(self.read_angle_segment())

]

self.expect(RAngle, none())

]

end GetImportStmt(source, name, version, details)

]

!!! `include <sciezka>` - parytet z `parse_include()` (parser.py) -

!!! prostsze niz `get`: jeden segment, bez `source:`/`::wersja`/

!!! `import <details>`.

fun parse_include(self) -> Stmt [

self.expect(Keyword, some("include"))

self.expect(LAngle, none())

let path = self.read_angle_segment()

self.expect(RAngle, none())

end IncludeStmt(path)

]

fun parse_type(self) -> TypeRef [

let name_tok = self.advance()

let generic: Option<TypeRef> = none()

let generic2: Option<TypeRef> = none()

if self.check(LAngle, none()) [

self.advance()

generic = some(self.parse_type())

if self.check(Comma, none()) [

self.advance()

generic2 = some(self.parse_type())

]

self.expect(RAngle, none())

]

end TypeRef(name_tok.value, generic, generic2)

]

fun parse_let(self, is_const: Bool) -> Stmt [

self.advance()

let name = self.expect(Ident, none()).value

let type_ref: Option<TypeRef> = none()

if self.check(Colon, none()) [

self.advance()

type_ref = some(self.parse_type())

]

let value: Option<Expr> = none()

if self.check(Op, some("=")) [

self.advance()

value = some(self.parse_expr())

]

end LetStmt(name, type_ref, value, is_const)

]

fun parse_params(self) -> List<Param> [

let params: List<Param> = []

self.expect(LParen, none())

while not self.check(RParen, none()) [

if self.check(Keyword, some("self")) [

self.advance()

params.push(Param("self", none(), none()))

if not self.check(Comma, none()) [

break

]

self.advance()

] else [

let pname = self.expect(Ident, none()).value

let ptype: Option<TypeRef> = none()

if self.check(Colon, none()) [

self.advance()

ptype = some(self.parse_type())

]

let pdefault: Option<Expr> = none()

if self.check(Op, some("=")) [

self.advance()

pdefault = some(self.parse_expr())

]

params.push(Param(pname, ptype, pdefault))

if not self.check(Comma, none()) [

break

]

self.advance()

]

]

self.expect(RParen, none())

end params

]

!!! Opcjonalna lista parametrow generycznych `<T, U>` po nazwie

!!! struct/fun/enum/impl.

fun parse_type_params(self) -> List<Str> [

let params: List<Str> = []

if not self.check(LAngle, none()) [

end params

]

self.advance()

while not self.check(RAngle, none()) [

params.push(self.expect(Ident, none()).value)

if not self.check(Comma, none()) [

break

]

self.advance()

]

self.expect(RAngle, none())

end params

]

fun parse_fun(self) -> Stmt [

self.expect(Keyword, some("fun"))

let name = self.expect(Ident, none()).value

let type_params = self.parse_type_params()

let params = self.parse_params()

let ret_type: Option<TypeRef> = none()

if self.check(Op, some("->")) [

self.advance()

ret_type = some(self.parse_type())

]

let body = self.parse_block()

end FunDecl(name, params, ret_type, body, false, type_params)

]

fun parse_if(self) -> Stmt [

self.expect(Keyword, some("if"))

let cond = self.parse_expr()

let body = self.parse_block()

let elifs: List<ElifArm> = []

let else_body: Option<List<Stmt>> = none()

self.skip_newlines_soft()

while self.check(Keyword, some("elif")) [

self.advance()

let econd = self.parse_expr()

let ebody = self.parse_block()

elifs.push(ElifArm(econd, ebody))

self.skip_newlines_soft()

]

if self.check(Keyword, some("else")) [

self.advance()

else_body = some(self.parse_block())

]

end IfStmt(cond, body, elifs, else_body)

]

!!! Podglada czy po newline'ach jest `elif`/`else` (zeby obsluzyc

!!! `else` na nowej linii po `]`) - cofa sie jesli nie.

fun skip_newlines_soft(self) [

let save = self.pos

while self.check(Newline, none()) or self.check(LineComment, none()) [

self.advance()

]

if not (self.check(Keyword, some("elif")) or self.check(Keyword, some("else"))) [

self.pos = save

]

]

fun parse_while(self) -> Stmt [

self.expect(Keyword, some("while"))

let cond = self.parse_expr()

let body = self.parse_block()

end WhileStmt(cond, body)

]

fun parse_for(self) -> Stmt [

self.expect(Keyword, some("for"))

let var = self.expect(Ident, none()).value

self.expect(Keyword, some("in"))

let iterable = self.parse_expr()

let body = self.parse_block()

end ForStmt(var, iterable, body)

]

!!! ZMIANA 0.3 - `region [ ... ]` zastepuje stare `extern "lib" fun

!!! nazwa(...)`. Jedna deklaracja `region` moze niesc DOWOLNIE

!!! WIELE sygnatur (zamiast jednej naraz jak wczesniej) i jest

!!! zwiazana z ostatnim poprzedzajacym `get <extern:...> use

!!! <tryb>` w tym samym pliku (wiazanie robione dopiero w

!!! `codegen.hcs::gen_region`, patrz `pending_extern_lib`/

!!! `pending_extern_mode` - parser NIE sprawdza tego powiazania,

!!! best-effort jak reszta bootstrapu, patrz "Ograniczenia").

!!! Kazda linia wewnatrz to goła sygnatura `fun nazwa(params) ->

!!! Typ` (typ zwracany opcjonalny) BEZ ciala i bez `[ ... ]` -

!!! parytet skladniowy z `parse_params()`/`parse_type()`

!!! uzywanymi normalnie w `parse_fun()`.

fun parse_region(self) -> Stmt [

self.expect(Keyword, some("region"))

self.expect(Open, none())

self.skip_newlines()

let sigs: List<ExternSig> = []

while not self.check(Close, none()) and not self.at_end() [

self.expect(Keyword, some("fun"))

let name = self.expect(Ident, none()).value

let params = self.parse_params()

let ret_type: Option<TypeRef> = none()

if self.check(Op, some("->")) [

self.advance()

ret_type = some(self.parse_type())

]

sigs.push(ExternSig(name, params, ret_type))

self.skip_newlines()

]

self.expect(Close, none())

end RegionBlock(sigs)

]

!!! `direct[]` jest wyjatkowe: w prawdziwym hackerc surowy tekst

!!! pomiedzy `[`/`]` jest wyciagany PRZED tokenizacja (patrz

!!! transpiler.py::`_extract_direct_blocks`) - Parser normalnie

!!! NIGDY nie widzi tokenow `direct` (parytet: `parse_direct` w

!!! parser.py TEZ tylko rzuca `ParseError` mowiacy "to powinno byc

!!! obsluzone na etapie preprocessing"). Ta metoda jest wiec

!!! siecia bezpieczenstwa, nie realna implementacja - patrz

!!! "Ograniczenia".

fun parse_direct(self) -> Stmt [

self.advance()

log("[hackerc-self] parser: 'direct' powinno byc wyciagniete na etapie preprocessing, nie parsowane")

end DirectBlock([])

]

fun parse_manual(self) -> Stmt [

self.expect(Keyword, some("manual"))

let body = self.parse_block()

end ManualBlock(body)

]

!! Skladnia pragmy to `gc:use::tryb` (patrz `gen_toplevel`/

!! `fmt_stmt` -> `"gc:use::" + mode` w codegen.hcs/formatter.hcs) -

!! `Colon` (":"), DOWOLNY token (typowo identyfikator "use", ale

!! parser go nie sprawdza - patrz `self.advance()` bez `expect`),

!! potem `DColon` ("::") i dopiero `tryb`.

fun parse_gc_pragma(self) -> Stmt [

self.expect(Keyword, some("gc"))

self.expect(Colon, none())

self.advance()

self.expect(DColon, none())

let mode = self.advance().value

end GcPragma(mode)

]

fun parse_struct(self) -> Stmt [

self.expect(Keyword, some("struct"))

let name = self.expect(Ident, none()).value

let type_params = self.parse_type_params()

self.expect(Open, none())

self.skip_newlines()

let fields: List<Param> = []

while not self.check(Close, none()) [

let fname = self.expect(Ident, none()).value

self.expect(Colon, none())

let ftype = self.parse_type()

fields.push(Param(fname, some(ftype), none()))

if self.check(Comma, none()) [

self.advance()

]

self.skip_newlines()

]

self.expect(Close, none())

end StructDecl(name, fields, type_params)

]

fun parse_enum(self) -> Stmt [

self.expect(Keyword, some("enum"))

let name = self.expect(Ident, none()).value

let type_params = self.parse_type_params()

self.expect(Open, none())

self.skip_newlines()

let variants: List<EnumVariant> = []

while not self.check(Close, none()) [

let vname = self.expect(Ident, none()).value

let vfields: List<TypeRef> = []

if self.check(LParen, none()) [

self.advance()

while not self.check(RParen, none()) [

vfields.push(self.parse_type())

if not self.check(Comma, none()) [

break

]

self.advance()

]

self.expect(RParen, none())

]

variants.push(EnumVariant(vname, vfields))

if self.check(Comma, none()) [

self.advance()

]

self.skip_newlines()

]

self.expect(Close, none())

end EnumDecl(name, variants, type_params)

]

!!! `impl Nazwa [ fun metoda(self, ...) -> Typ [ ... ] ... ]`.

!!! Komentarze `!!` przed metoda sa dziś ZBIERANE (`pending_doc`,

!!! parytet z `pending_doc` w parser.py), ale NIE MA gdzie ich

!!! doczepic (`FunDecl` w tym AST nie ma pola

!!! `_leading_doc_comments`, patrz "Ograniczenia" w ast_nodes.hcs) -

!!! sa wiec dzis odrzucane po zebraniu, TYLKO zeby nie wywolac

!!! `expect(Keyword, "fun")` na tokenie `DocComment` i nie

!!! wyprodukowac spurious ostrzezenia.

fun parse_impl(self) -> Stmt [

self.expect(Keyword, some("impl"))

let struct_name = self.expect(Ident, none()).value

let type_params = self.parse_type_params()

self.expect(Open, none())

self.skip_newlines()

let methods: List<Stmt> = []

while not self.check(Close, none()) [

if self.check(DocComment, none()) [

self.advance()

self.skip_newlines()

] else [

!! NAPRAWIONE (wykryte przez `showcase.hcs` - `pub fun`

!! w `impl` konczylo sie kaskada "nieoczekiwany token")

!! - w przeciwienstwie do najwyzszego poziomu (patrz

!! obsluga "pub" w `parse_statement()`), ta petla

!! wolala `parse_fun()` BEZPOSREDNIO (z pominieciem

!! `parse_statement()`), wiec wiodace `pub` nie bylo w

!! ogole konsumowane.

let is_pub_method = false

if self.check(Keyword, some("pub")) [

self.advance()

is_pub_method = true

]

let m = self.parse_fun()

if is_pub_method [

match m [

FunDecl(name, params, ret_type, body, mip, type_params2) -> [

m = FunDecl(name, params, ret_type, body, true, type_params2)

]

_ -> [

]

]

]

methods.push(m)

self.skip_newlines()

]

]

self.expect(Close, none())

end ImplDecl(struct_name, methods, type_params)

]

!!! `match wyrazenie [ Wariant(bind, ...) -> [ ... ] ... _ -> [...] ]`.

fun parse_match(self) -> Stmt [

self.expect(Keyword, some("match"))

let subject = self.parse_expr()

self.expect(Open, none())

self.skip_newlines()

let arms: List<MatchArm> = []

while not self.check(Close, none()) [

let vname = self.expect(Ident, none()).value

let binds: List<Str> = []

if self.check(LParen, none()) [

self.advance()

while not self.check(RParen, none()) [

binds.push(self.expect(Ident, none()).value)

if not self.check(Comma, none()) [

break

]

self.advance()

]

self.expect(RParen, none())

]

self.expect(Op, some("->"))

let body = self.parse_block()

arms.push(MatchArm(vname, binds, body))

self.skip_newlines()

]

self.expect(Close, none())

end MatchStmt(subject, arms)

]

!!! -- wyrazenia (precedence climbing) --------------------------------

fun parse_expr(self) -> Expr [

end self.parse_or()

]

fun parse_or(self) -> Expr [

let left = self.parse_and()

while self.check(Keyword, some("or")) or self.check(Op, some("||")) [

self.advance()

let right = self.parse_and()

left = BinOp("or", left, right)

]

end left

]

fun parse_and(self) -> Expr [

let left = self.parse_not()

while self.check(Keyword, some("and")) or self.check(Op, some("&&")) [

self.advance()

let right = self.parse_not()

left = BinOp("and", left, right)

]

end left

]

fun parse_not(self) -> Expr [

if self.check(Keyword, some("not")) or self.check(Op, some("!")) [

self.advance()

let operand = self.parse_not()

end UnaryOp("not", operand)

]

end self.parse_comparison()

]

fun parse_comparison(self) -> Expr [

let left = self.parse_additive()

while (self.check(Op, none()) and (self.cur().value == "==" or self.cur().value == "!=" or self.cur().value == "<=" or self.cur().value == ">=")) or self.check(LAngle, none()) or self.check(RAngle, none()) [

let op = self.advance().value

let right = self.parse_additive()

left = BinOp(op, left, right)

]

end left

]

fun parse_additive(self) -> Expr [

let left = self.parse_mult()

while self.check(Op, none()) and (self.cur().value == "+" or self.cur().value == "-") [

let op = self.advance().value

let right = self.parse_mult()

left = BinOp(op, left, right)

]

end left

]

fun parse_mult(self) -> Expr [

let left = self.parse_unary()

while self.check(Op, none()) and (self.cur().value == "*" or self.cur().value == "/" or self.cur().value == "%") [

let op = self.advance().value

let right = self.parse_unary()

left = BinOp(op, left, right)

]

end left

]

fun parse_unary(self) -> Expr [

if self.check(Op, none()) and (self.cur().value == "-" or self.cur().value == "+") [

let op = self.advance().value

let operand = self.parse_unary()

end UnaryOp(op, operand)

]

end self.parse_postfix()

]

!!! Lancuch postfiksowy: wywolania `f(...)`, `.pole`, `as Typ`, `?`,

!!! `[indeks]` - w DOWOLNEJ kolejnosci i liczbie, np. `f().pole?[0]`.

!!! `x[i]` jest dozwolone TYLKO gdy `[` jest "tight" (bez bialej

!!! spacji przed nim, patrz `Token.tight` w lexer.hcs) - to

!!! odrozniamy od nowego bloku (`if x [ ... ]`) juz na poziomie

!!! lexera, wiec tutaj nie ma juz niejednoznacznosci.

fun parse_postfix(self) -> Expr [

let expr = self.parse_primary()

while true [

if self.check(LParen, none()) [

self.advance()

let args: List<Expr> = []

while not self.check(RParen, none()) [

args.push(self.parse_expr())

if not self.check(Comma, none()) [

break

]

self.advance()

]

self.expect(RParen, none())

expr = Call(expr, args)

] elif self.check(Op, some(".")) [

self.advance()

let name = self.expect(Ident, none()).value

expr = Attr(expr, name)

] elif self.check(Keyword, some("as")) [

self.advance()

let cast_type = self.parse_type()

expr = Cast(expr, cast_type)

] elif self.check(Question, none()) [

self.advance()

expr = TryOp(expr)

] elif self.check(Open, none()) and self.cur().tight [

self.advance()

let index = self.parse_expr()

self.expect(Close, none())

expr = Index(expr, index)

] else [

break

]

]

end expr

]

fun parse_primary(self) -> Expr [

let t = self.cur()

if t.kind == Number [

self.advance()

end NumberLit(t.value)

]

if t.kind == StrLit [

self.advance()

end StringLit(t.value, false)

]

if t.kind == Keyword and (t.value == "true" or t.value == "false") [

self.advance()

end BoolLit(t.value == "true")

]

if t.kind == Keyword and t.value == "null" [

self.advance()

end NullLit

]

if t.kind == Keyword and t.value == "self" [

self.advance()

end IdentExpr("self")

]

if t.kind == Ident [

self.advance()

end IdentExpr(t.value)

]

if t.kind == LParen [

self.advance()

let e = self.parse_expr()

self.expect(RParen, none())

end e

]

if t.kind == Open [

self.advance()

let items: List<Expr> = []

self.skip_newlines()

while not self.check(Close, none()) [

items.push(self.parse_expr())

self.skip_newlines()

if not self.check(Comma, none()) [

self.skip_newlines()

break

]

self.advance()

self.skip_newlines()

]

self.expect(Close, none())

end ListLit(items)

]

log("[hackerc-self] parser: nieoczekiwany token '" + t.value + "' w linii " + (t.line as Str) + ", kolumna " + (t.col as Str))

self.advance()

end NullLit

]

]

!!! `parse(source)` - odpowiednik wolnej funkcji `parse()` w parser.py

!!! (tokenizuje, potem `Parser(tokens, 0).parse_program()`).

fun parse(source: Str) -> Program [

let tokens = tokenize(source)

let p = Parser(tokens, 0)

end p.parse_program()

]

!!! Demonstracyjne uzycie: parsuje maly, ale reprezentatywny fragment

!!! HackerScript zawierajacy struct+impl+fun+if+match+wywolanie

!!! metody+`?` - sprawdza, ze cala gramatyka spina sie w jeden dzialajacy

!!! pipeline `Str -> tokenize -> Parser -> Program`.

fun main() [

let src = "struct Point [\n x: Int,\n y: Int\n]\n\nimpl Point [\n fun sum(self) -> Int [\n end self.x + self.y\n ]\n]\n\nfun classify(n: Int) -> Str [\n if n > 0 [\n end \"pozytywne\"\n ] elif n < 0 [\n end \"negatywne\"\n ] else [\n end \"zero\"\n ]\n]\n\nfun main() [\n let p = Point(1, 2)\n log(p.sum())\n log(classify(p.x)?)\n]\n"

let prog = parse(src)

log("instrukcje najwyzszego poziomu:", prog.body.len())

]