{"id":16287165,"url":"https://github.com/bandysc/binterpreter","last_synced_at":"2025-10-13T15:32:02.935Z","repository":{"id":74061360,"uuid":"133440724","full_name":"BAndysc/BInterpreter","owner":"BAndysc","description":"Small interpreter for my small language written in Haskell for MIMUW JPP course.","archived":false,"fork":false,"pushed_at":"2018-05-15T01:37:36.000Z","size":40,"stargazers_count":3,"open_issues_count":0,"forks_count":2,"subscribers_count":3,"default_branch":"master","last_synced_at":"2025-04-12T06:14:37.917Z","etag":null,"topics":[],"latest_commit_sha":null,"homepage":null,"language":"Haskell","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"unlicense","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/BAndysc.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2018-05-15T01:16:02.000Z","updated_at":"2024-11-12T06:42:47.000Z","dependencies_parsed_at":null,"dependency_job_id":"e2893e70-61a2-471b-984c-5f46547ffa9c","html_url":"https://github.com/BAndysc/BInterpreter","commit_stats":null,"previous_names":[],"tags_count":0,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/BAndysc%2FBInterpreter","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/BAndysc%2FBInterpreter/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/BAndysc%2FBInterpreter/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/BAndysc%2FBInterpreter/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/BAndysc","download_url":"https://codeload.github.com/BAndysc/BInterpreter/tar.gz/refs/heads/master","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":248525138,"owners_count":21118619,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":[],"created_at":"2024-10-10T19:44:30.860Z","updated_at":"2025-10-13T15:31:57.915Z","avatar_url":"https://github.com/BAndysc.png","language":"Haskell","funding_links":[],"categories":[],"sub_categories":[],"readme":"# Język BK\n\n## Opis rozwiązania\n\nInterpreter opiera się głównie na dwóch monadach: `State` i `Reader`. `Reader` trzyma \"środowisko\" - mapę nazw zmiennych w ich lokację. `State` trzyma mapę lokacji w wartości \"w pamięci\" oraz następną wolną \"lokację\". Nieużywane lokacje nie sa zwalniane.\n\n## Opis plików\n\n * `Types.hs` - wszystkie wykorzystane typy (poza type checkerem), opis w pliku\n * `Memory.hs` - pomocnicze funkcje do zarządzania stanem pamięci\n * `TypeChecker.hs` - moduł odpowiedzialny za statyczne typowanie\n * `Interpreter.hs` - właściwy interpreter\n * `main.hs` - plik początkowy interpretera\n\n## Wymagania i kompilacja\n\nInterpreter wymaga biblioteki `mtl`, został przetestowany na wersjach ghc 7.6.3 oraz 8.0.2.\n\n```\n\tcabal update\n\tcabal install mtl\n    make\n    ./interpreter\n```\n\n## Opis jęzka\n\n### Program:\n\nProgram jest po prostu listą instrukcji oddzielonych średnikiem.\n\n### Typy:\n\nDostępne są trzy typy proste: `int` (liczba całkowita), `bool` oraz `string`. Stałe liczbowe to po prostu `\\-?[0-9]+`, stałe typu `bool` to `true` i `false`. Literały napisowe zapisujemy w cudzysłowach. Dodatkowo funkcje mogą zwracać typ `void`, czyli tak naprawdę nic nie zwracać.\nListy są typu `List\u003cT\u003e`, gdzie T jest dowolnym innym typem.\nFunkcje anonimowe są typu: `Fun\u003c[Typ zwracany]([lista typów przyjmowanych argumentów])\u003e`.\n\n(W kolejnej wersji dostępne będą struktury, ich typ to `struct [IDENTYFIKATOR]`)\n\nTypowanie jest statyczne.\n\n##### Domyślne wartości typów przy inicjalizacji zmiennych:\n\n * `int` -\u003e `0`\n * `bool` -\u003e `false`\n * `string` -\u003e `\"\"`\n * `List` -\u003e `[]`\n * `Fun` -\u003e brak (niedopuszczalna deklaracja zmiennej na funkcję bez funkcji)\n\n### Arytmetyka\n\nOperatory arytmetyczne: +, -, *, /, %, minus unarny\nOperatory porównania: \u003c, \u003c=, \u003e, \u003e=, ==, !=\nOperatory logiczne: and, or, not\n\n\n### if:\n\n```\nif [WARUNEK] then\n{\n\t[Stmt]\n}\t\nelse\n{\n\t[Stmt]\n}\n```\n\nelse jest opcjonalny. Warunek jest wyrażeniem, musi być typu `bool`. Nawiasy klamrowe są wymagane (w celu uniknięcia niejednoznaczności przy if _ then if _ then _ else _)\n\n### while\n\n```\nwhile [WARUNEK] do\n\tStmt\n```\n\nWarunek jest sprawdzany *przed* każdym obrotem pętli. Warunek jest wyrażeniem, musi być typu `bool`.\n\n### for\n\n```\nfor [ZMIENNA] from [WYRAŻENIE [OD]] to [WYRAŻENIE [DO]] do\n\tStmt\n```\n\nPrzed uruchomieniem pętli wyliczana jest wartość wyrażeń [od] i [do], muszą być typu int, instrukcja jest wykonywana ([DO] - [OD] + 1) razy, przed wykonaniem instrukcji na [zmienną] przypisana jest wartość wyrażenia. Gdy [DO] \u003c [OD], to pętla nie jest wykonywana ani razu.\n\n### for in\n```\nfor [ZMIENNA] in [WYRAŻENIE]\n\tStmt\n```\n\n[WYRAŻENIE] musi być typu `List\u003cT\u003e`, a [ZMIENNA] typu `T`. Instrukcja jest uruchamiane dla każdego elementu listy, przypisawszy wcześniej wartość tego elementu na [ZMIENNĄ].\n\n### Funkcje\n```\nfunction NAZWA([ARGUMENT]) -\u003e TYP_ZWRACANY\n{\n\t[Stmt]\n}\n// ARGUMENT ::= (ref)? T nazwa\n``` \nFunkcje mają nazwę, listę argumentów oddzielonych przecinkami i typ zwracany. Funkcje mogą przyjmować typy `int`, `bool`, `string`, `List\u003cT\u003e`, `struct [Ident]` oraz `Fun\u003cT([S])\u003e`. Takie też typy mogą zwrócić, dodatkowo mogą zwrócić typ `void`, co oznacza, że funkcja nic nie zwraca (jest \"procedurą\"). Dodatkowo argumenty fukcji mogą być poprzedzone modyfikatorem `ref` oznaczjącym, że argument przekazywany jest przez referencję. Domyślnie argumenty są przykazywane przez *wartość*.\n\n##### Wołanie funkcji\n```\n\tnazwa_funkcji([lista argumentów])\n```\n\nWywołujemy funkcję podając jej identyfikator i w nawiasie listę argumentów. Jeśli argument w definicji funkcji poprzedzony jest modyfikatorem `ref`, to także podczas wołania funkcji należy przekazać *zmienną* z modyfikatorem `ref` (i naturalnie nie może to być wtedy wyrażenie, tylko identyfikator!). \n\n##### Funkcje anonimowe\n```\n\tFun\u003cT([S])\u003e = [C] ([S]) -\u003e T { Stmt; }\n```\n\n`[S]` to lista argumentów przyjmowanych przez funkcję anonimową, analogicznie jak w funkcjach.\n`T` to typ zwracany analogicznie jak w funkcjach.\n`C` to lista identyfikatorów, tzw. \"Capture Group\", których *wartość* będzie widoczna w ciele lambdy. UWAGA: wartość tych zmiennych jest wyliczana w momencie deklaracji lambdy. Zatem kod:\n```\n\tint x = 10;\n\tFun\u003cvoid()\u003e f = [x] () -\u003e void { print x };\n\tx = 20;\n\tf();\n```\nSpowoduje wypisanie wartości `10`. W ciele lambdy nie można się odwoływać do innych zmiennych niż te z `capture groupy` oraz argumentów.\n\n##### Funkcje zagnieżdżone\nFunkcja można zagnieżdżać, tzn. można deklarować funkcje w funkcji. Funkcja zagnieżdżona ma dostęp do `wszystkich` identyfikatorów widocznych w zewnętrzenej funkcji. Funkcje zagnieżdżone naturalnie nie są widoczne poza funkcją zewnętrzną.\n\n### Print, format\nDwie instrukcje wbudowane slużące do wypisywania na ekran. \n\n##### print\n```\n\tprint [WYRAŻENIE]\n```\nWylicza wartość wyrażenia i drukuje na standardowe wyjście.\n\n##### format\n```\n\tformat [FORMAT_STRING] [WYRAŻENIA...]\n```\nPierwszym argumentem jest `string` oznaczjący format. Specjalny znak `_` oznacza wzięcie kolejnego wyrażenia z listy wyrażeń i wypisania właśnie niego. Gdy podane jest więcej wyrażeń niż `_`, nic się nie dzieje, gdy jest mniej - na ekran wypisuje się znak `_`.\n\n```\n\tformat \"_ + _ = _\\n\" 1, 2, 1 + 2\n\t// 1 + 2 = 3\n\n\tformat \"_ + _ = _\\n\" 1, 2\n\t// 1 + 2 = _\n```\n\n### Obsługa błędów\nWystępują dwa typy wyjątków:\n \n  * typecheck exception - taki wyjątek jest zgłaszany podczas statycznego typowania\n\n  * runtime exception - taki wyjątek jest zgłaszany podczas interpretowania programu (np. dzielenie przez 0)\n\n### Listy\n```\n\tList\u003cT\u003e lista;\n\tT t;\n\tlista.push t (-\u003e void);\n\tlista::at [Integer] (-\u003e T);\n\tlista::length (-\u003e int);\n```\nListy mogą przechowywać dowolny typ (także inne listy). Dostępne są trzy funkcje wbudowane: `push`, `at`, `length`. `Push` wkłada element na koniec listy, `at` zwraca element pod danym indeksem (gdy indeks jest poza zakresem to zgłaszany jest błąd wykonania), `length` zwraca długość listy.\n\n### Struktury\n[NIEDOSTĘPNE W TEJ ITERACJI]\n```\n\tstruct NAZWA\n\t{\n\t\tTYP_POLA [NAZWA_POLA];\n\t\tTYP_POLA_2 [NAZWA_POLA_2];\n\t\t.\n\t\t.\n\t}\n```\nDefinicja struktury składa się z listy nazwy pól wraz z ich typem. \n\n\n### Cechy języka\n\n```\n                                           15 maja       12 czerwca\n1 (dwa typy) int, bool                        +       \n2 (arytmetyka, porównania)                    +           \n3 (while, if)                                 +\n4 (procedury lub funkcje, rekurencja)         +                     \n5 (print)                                     +\n6 a) (przez zmienną i wartość)                +\n  b) (pętla for)                              +\n7 (statyczne typowanie)                       +       \n8 (przesłanianie i statyczne wiązanie)        +                     \n9 (obsługa błędów wykonania)                  +           \n10 (funkcje zwracające wartość)               +                \n   b) (listy)                                 +                \n   c) (rekordy)                                               +\n   f) (funkcje jako parametry)                +                \n   h) (funkcje anonimowe)                     +                \n12 (funkcje zagnieżdżone                      +                \n\tze statycznym wiązaniem)                         \n```\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fbandysc%2Fbinterpreter","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fbandysc%2Fbinterpreter","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fbandysc%2Fbinterpreter/lists"}