Merge pull request #10 from fakefloordiv/megacalc

Megacalc

Author: flrdv

README.md

@@ -1,6 +1,6 @@
 [![wakatime](https://wakatime.com/badge/user/b4a2ea9a-a721-41c8-b704-79b9b8cec646/project/3e68a432-deec-4dab-ba8a-a5f424e91eed.svg)](https://wakatime.com/badge/user/b4a2ea9a-a721-41c8-b704-79b9b8cec646/project/3e68a432-deec-4dab-ba8a-a5f424e91eed)
 # pycalc
-Simple calculator on python, written in academic purposes. Uses Sorting Station Algorithm for building reverse polish notation stack. Supports all kinds of operations python supports (except bool operations like or, not, etc. but they will be implemented as a functions of std-library), functions defining, variables declarations, etc.
+Simple calculator on python, written in academic purposes. TURING-COMPLETE. Uses Sorting Station Algorithm for building reverse polish notation stack. Supports all kinds of operations python supports (except bool operations like or, not, etc. but they will be implemented as a functions of std-library), functions defining, variables declarations, etc.
 
 # How to install?
 ```bash

docs/stdlib.md

@@ -72,6 +72,34 @@ float(".5") == .5
 
 ---
 
+## `str`
+Semantic:
+```
+str(15.5)
+```
+Returns: string
+
+Examples:
+```
+str(.5) == "0.5"
+```
+
+---
+
+## `strjoin`
+Semantic:
+```
+strjoin(separator, mem)
+```
+Returns: single string
+
+Examples:
+```
+strjoin(".", "123") == "1.2.3"
+```
+
+---
+
 ## `range`
 Semantic:
 ```

examples/arrays.calc

@@ -8,7 +8,7 @@ arrMake(size, bytesize) = malloc(size*bytesize)
 arrGet(arr, index, bytesize) =
     reduce(
         (x, y) = x + (y<<8),
-        slice(arr, index*bytesize, bytesize)
+        slice(arr, index*bytesize, index*bytesize+bytesize)
     )
 
 arrSet(arr, index, bytesize, value) =

examples/breakinggates.calc

@@ -1,12 +1,10 @@
-print("1: ")
-src = input()
-print("2: ")
-modified = input()
+src = input("1: ")
+modified = input("2: ")
 
-count(mem, char) =
+count(string, char) =
     len(filter(
         (x) = x==char,
-        mem
+        string
     ))
 
 extra = 0
@@ -15,4 +13,4 @@ map(
         if(count(src, x) != count(modified, x), () = extra=x),
     modified
 )
-println(chr(extra))
+println(extra)

examples/turingmachine.calc

@@ -0,0 +1,46 @@
+rulesMap(func, rules) =
+    map(
+        (x) = func(slice(rules, x, x+5)),
+        range(0, len(rules), 5)
+    )
+
+step(tape, rules, state, position) =
+    char = get(tape, position);
+    selectedRule = 0;
+    rulesMap(
+        (rule) = if(
+            (get(rule, 0) == state) + (get(rule, 1) == char) == 2,
+            () = selectedRule = rule
+        ),
+        rules
+    );
+    set(tape, position, get(selectedRule, 3));
+    moveHead = get(selectedRule, 4);
+    branch(
+        moveHead == 2,
+        () = position = position + 1,
+        moveHead == 1,
+        () = position = position - 1,
+    );
+    mallocfor(get(selectedRule, 2), position)
+
+
+rules = mallocfor(
+    1, ord("0"), 1, ord("1"), 2,
+    1, ord("1"), 1, ord("0"), 2,
+    1, ord("*"), 2, ord("*"), 1
+)
+tape = map(ord, "010011001*")
+println("tape was: ", strjoin("", map(chr, tape)))
+
+state = 1
+position = 0
+while(
+    () = state != 2,
+    () =
+        result = step(tape, rules, state, position);
+        state = get(result, 0);
+        position = get(result, 1)
+)
+
+println("tape became: ", strjoin("", map(chr, tape)))

pycalc/interpreter/interpret.py

@@ -8,7 +8,8 @@
 from pycalc.tokentypes.tokens import Token, Tokens, Function
 from pycalc.tokentypes.types import (TokenKind, TokenType, Stack, Namespace, Number,
                                      NamespaceValue, ArgumentsError, NameNotFoundError,
-                                     InvalidSyntaxError, NoCodeError)
+                                     InvalidSyntaxError, ExternalFunctionError,
+                                     PyCalcError, NoCodeError)
 
 
 Value = Union[Number, Function]
@@ -107,7 +108,10 @@ def interpret(self, code: str, namespace: Namespace) -> Value:
         tokens = self.tokenizer.tokenize(code)
         stacks = self.stackbuilder.build(tokens)
         namespaces = NamespaceStack()
-        namespaces.add_namespace(namespace)
+        # empty namespace especially for global namespace
+        # because default one must not be overridden by
+        # global namespace of code
+        namespaces.add_namespaces(namespace, {})
 
         return self._interpreter(stacks, namespaces)
 
@@ -164,14 +168,15 @@ def _interpret_line(self, expression: Stack[Token], namespaces: NamespaceStack)
                     call_result = func(*(arg.value for arg in args))
                 except ArgumentsError as exc:
                     raise ArgumentsError(str(exc), token.pos) from None
+                except PyCalcError as exc:
+                    raise exc from None
+                except Exception as exc:
+                    raise ExternalFunctionError(str(exc), token.pos)
 
                 stack.append(self._token(call_result, token.pos))
             elif token.type == TokenType.FUNCDEF:
-                func_namespace = namespaces.copy()
-                func_namespace.add_namespace({})
-
                 func = self._spawn_function(
-                    namespace=func_namespace,
+                    namespace=namespaces.copy(),
                     name=token.value.name,
                     fargs=[tok.value for tok in token.value.args],
                     body=token.value.body
@@ -201,9 +206,6 @@ def _interpret_line(self, expression: Stack[Token], namespaces: NamespaceStack)
 
         return result.value
 
-    def _import(self, path: str):
-        ...
-
     def _spawn_function(self,
                         namespace: NamespaceStack,
                         name: str,
@@ -212,7 +214,7 @@ def _spawn_function(self,
         def real_function(*args) -> Number:
             if not fargs and args:
                 raise ArgumentsError("function takes no arguments", (-1, -1))
-            if len(fargs) != len(args):
+            elif len(fargs) != len(args):
                 text = (
                     "not enough arguments",
                     "too much arguments"
@@ -229,7 +231,7 @@ def real_function(*args) -> Number:
                 return self._interpret_line(body, namespace)
 
         return Function(
-            name=f"{name}({','.join(fargs)})",
+            name=f"{name or '<lambda>'}({','.join(fargs)})",
             target=real_function
         )
 

pycalc/lex/tokenizer.py

@@ -231,10 +231,13 @@ def _parse_unary(self, tokens: Tokens) -> Tokens:
                 output.append(token)
 
         if buffer:
-            raise InvalidSyntaxError(
-                "unexpected operator in the end of the expression",
-                buffer[-1].pos
-            )
+            if len(buffer) == 1 and buffer[0].type == TokenType.OP_SEMICOLON:
+                output.append(buffer.pop())
+            else:
+                raise InvalidSyntaxError(
+                    "unexpected operator in the end of the expression",
+                    buffer[-1].pos
+                )
 
         return output
 

pycalc/stack/builder.py

@@ -128,50 +128,53 @@ def _build_line(self, tokens: Tokens) -> Stack:
 
     def _count_args(self, tokens: Tokens) -> List[int]:
         result = []
-        skip_rparens = 0
 
-        for i, token in enumerate(tokens[1:]):
-            if skip_rparens:
-                if token.type == TokenType.RPAREN:
-                    skip_rparens -= 1
+        for funccall in self.__find_funccalls(tokens):
+            result.append(0)
+            waitforcomma = False
+            parens = 0
 
-                continue
+            for token in funccall:
+                if parens:
+                    if token.type == TokenType.LPAREN:
+                        parens += 1
+                    elif token.type == TokenType.RPAREN:
+                        parens -= 1
 
-            if token.type == TokenType.LPAREN and tokens[i].type == TokenType.VAR:
-                counters = self.__argscounter(tokens[i+2:])
-                result.extend(counters)
-                skip_rparens = len(counters)
+                    continue
+                elif token.type == TokenType.LPAREN:
+                    parens += 1
+                    result[-1] += not waitforcomma
+                    waitforcomma = True
+                elif waitforcomma:
+                    waitforcomma = token.type != TokenType.OP_COMMA
+                else:
+                    result[-1] += 1
+                    waitforcomma = True
 
         return result
 
-    def __argscounter(self, tokens: Tokens) -> List[int]:
-        result = [0]
-        skip_rparens = 0
-
-        waitforcomma = False
+    def __find_funccalls(self, tokens: Tokens) -> List[Tokens]:
+        funcs: List[Tokens] = []
+        parens = 0
 
-        for i, token in enumerate(tokens):
-            if skip_rparens:
-                if token.type == TokenType.RPAREN:
-                    skip_rparens -= 1
-
-                continue
-            elif token.type == TokenType.RPAREN:
-                return result
+        for i, token in enumerate(tokens[1:], start=1):
+            if parens:
+                if token.type == TokenType.LPAREN:
+                    parens += 1
+                elif token.type == TokenType.RPAREN:
+                    parens -= 1
 
-            if waitforcomma:
-                if token.type == TokenType.OP_COMMA:
-                    waitforcomma = False
-            elif token.kind != TokenKind.PAREN:
-                result[0] += 1
-                waitforcomma = True
+                    if not parens:
+                        funcs.extend(self.__find_funccalls(funcs[-1]))
+                        continue
 
-            if token.type == TokenType.LPAREN:
-                counters = self.__argscounter(tokens[i+1:])
-                result.extend(counters)
-                skip_rparens = len(counters)
+                funcs[-1].append(token)
+            elif token.type == TokenType.LPAREN and tokens[i - 1].type == TokenType.VAR:
+                parens = 1
+                funcs.append([])
 
-        return result
+        return funcs
 
     @staticmethod
     def _expr_divider(expr: Tokens) -> Iterator[Tuple[Tokens, Tuple[int, int]]]:

pycalc/tokentypes/types.py

@@ -181,5 +181,9 @@ class UnknownTokenError(PyCalcError):
     pass
 
 
+class ExternalFunctionError(PyCalcError):
+    pass
+
+
 class NoCodeError(Exception):
     pass

repl.py

@@ -93,7 +93,8 @@ def script_exec_mode(filename: str):
     except NoCodeError:
         pass
     except Exception as exc:
-        print(f"{fd.name}:?:?: internal interpreter error: {exc.__class__.__name__}({repr(exc)})")
+        print(f"{fd.name}:?:?: internal interpreter error:")
+        raise exc
 
 
 if __name__ == '__main__':

std/stdlibrary.py

@@ -18,6 +18,8 @@ def decorator(a: Callable, b: Iterable) -> list:
     "cbrt": lambda a: a ** (1/3),
     "int": int,
     "float": float,
+    "str": str,
+    "strjoin": str.join,
     "range": range,
     "inv": lambda a: ~a,
     "pi": pi,
@@ -35,12 +37,14 @@ def decorator(a: Callable, b: Iterable) -> list:
     "set": stdmem.mem_set,
     "slice": stdmem.slice_,
     "len": len,
-    "call": lambda func: func(),
 
     "map": _as_list(map),
     "filter": _as_list(filter),
     "reduce": reduce,
     "while": stdstatements.while_,
     "if": stdstatements.if_else,
     "branch": stdstatements.branch,
+
+    "nop": lambda: 0,
+    "call": lambda func: func(),
 }

std/stdmem.py

@@ -24,5 +24,5 @@ def mem_set(mem: List[int], offset: int, value: int) -> int:
     return 0
 
 
-def slice_(mem: List[int], begin: int, offset: int) -> List[int]:
-    return mem[begin:begin+offset]
+def slice_(mem: List[int], begin: int, end: int) -> List[int]:
+    return mem[begin:end]

tests/testcases.py

@@ -150,7 +150,7 @@ def test_declare_var(self):
         self.assertEqual(evaluate("a=5+5"), 10)
 
     def test_get_declared_var(self):
-        self.assertEqual(evaluate("a"), 10)
+        self.assertEqual(evaluate("a=10 \n a"), 10)
 
 
 class TestFunctions(TestCase):
@@ -177,12 +177,10 @@ def test_funcdef(self):
         self.assertEqual(func_c.name, "c(x,y)")
 
     def test_def_func_call(self):
-        evaluate("f(x,y)=x*y")
-        self.assertEqual(evaluate("f(2,5)"), 10)
+        self.assertEqual(evaluate("f(x,y)=x*y \n f(2,5)"), 10)
 
     def test_def_func_argexpr(self):
-        evaluate("f(x,y)=x*y")
-        self.assertEqual(evaluate("f(2+5, 3*2)"), 42)
+        self.assertEqual(evaluate("f(x,y)=x*y \n f(2+5, 3*2)"), 42)
 
     def test_funcdef_argexpr(self):
         with self.assertRaises(InvalidSyntaxError):
@@ -205,16 +203,14 @@ def test_funcdef_no_body(self):
 
 class TestLambdas(TestCase):
     def test_assign_to_var(self):
-        func = evaluate("a=(x)=x+1")
-        self.assertIsInstance(func, Function)
-        self.assertEqual(evaluate("a(1)"), 2)
+        self.assertEqual(evaluate("a=(x)=x+1 \n a(1)"), 2)
 
     def test_lambda_as_argument(self):
-        sum_func = evaluate("sum(mem)=reduce((x,y)=x+y, mem)")
-        range_func = evaluate("range(begin, end) = i=begin-1; map((x)=i=i+1;x+i, malloc(end-begin))")
-        self.assertIsInstance(sum_func, Function)
-        self.assertIsInstance(range_func, Function)
-        self.assertEqual(evaluate("sum(range(0,5))"), 10)
+        self.assertEqual(evaluate("""
+        sum(mem)=reduce((x,y)=x+y, mem)
+        range(begin, end) = i=begin-1; map((x)=i=i+1;x+i, malloc(end-begin))
+        sum(range(0,5))
+        """), 10)
 
     def test_missing_brace_in_arglambda(self):
         with self.assertRaises(InvalidSyntaxError):