From e06606ed1ea082edce20ab9e542291af708cfc65 Mon Sep 17 00:00:00 2001 From: timotheyca Date: Sun, 1 Aug 2021 00:50:02 +0300 Subject: [PATCH] _mod_mul --- bu4/parsing/constructs/lcall.py | 6 +++--- bu4/parsing/parser.py | 24 ++++++++++++++---------- bu4/parsing/states/pscall.py | 24 +++++++++++++----------- bu4/parsing/targets/psendswith.py | 8 ++++---- bu4/parsing/toolchain/transply.py | 30 +++++++++++++++--------------- main.py | 12 ++++++------ src/math/@.bu4 | 1 + src/math/mod_mul.bu4 | 17 +++++++++++++++++ src/sys1.bu4 | 6 ++++-- 9 files changed, 77 insertions(+), 51 deletions(-) create mode 100644 src/math/mod_mul.bu4 diff --git a/bu4/parsing/constructs/lcall.py b/bu4/parsing/constructs/lcall.py index 2fddc6d..44e4d7a 100644 --- a/bu4/parsing/constructs/lcall.py +++ b/bu4/parsing/constructs/lcall.py @@ -53,9 +53,9 @@ class LCall(Linked): class PCall(Parsed): - def __init__(self, value: Parsed, lambda_: Parsed): - self.value = value + def __init__(self, argument: Parsed, lambda_: Parsed): + self.argument = argument self.lambda_ = lambda_ def link(self, promise: set[bytes]) -> Linked: - return LCall(promise, self.value, self.lambda_) + return LCall(promise, self.argument, self.lambda_) diff --git a/bu4/parsing/parser.py b/bu4/parsing/parser.py index cdc749d..6c2d3d7 100644 --- a/bu4/parsing/parser.py +++ b/bu4/parsing/parser.py @@ -8,6 +8,7 @@ from bu4.parsing.constructs.linked import Parsed from bu4.parsing.constructs.llambda import PLambda from bu4.parsing.constructs.lname import PName from bu4.parsing.constructs.lnull import PNull +from bu4.parsing.states.parsestate import ParseState from bu4.parsing.states.psafter import PSAfter from bu4.parsing.states.pscall import pscall from bu4.parsing.states.psfinal import PSFinal @@ -20,14 +21,14 @@ __all__ = ('Parser',) class Parser(AbstractParser): - def __init__(self, s: bytes): - self.__s = BytesIO(s) + def __init__(self, source: bytes): + self.__source = BytesIO(source) def read(self) -> int: - bytes_ = self.__s.read(1) + bytes_ = self.__source.read(1) return bytes_[0] if bytes_ else 0 - def parse_name(self) -> bytes: + def _parse_name(self) -> bytes: s = BytesIO() while True: c = self.read() @@ -35,21 +36,22 @@ class Parser(AbstractParser): return s.getvalue() s.write(bytes([c])) - def _state_read(self, state: PSAfter): + def _state_read(self, state: PSAfter) -> ParseState: c = self.read() if c == CODE_NULL: state.state = PSFinal(PNull()) elif c == CODE_CALL: - state.state = pscall + state.state = pscall() elif c == CODE_MAKE: - state.state = (lambda name: PSAfter( + name = self._parse_name() + state.state = PSAfter( PSRead(), PSLambda( lambda value: PSFinal(PLambda(name, value)) ) - ))(self.parse_name()) + ) elif c == CODE_NAME: - state.state = PSFinal(PName(self.parse_name())) + state.state = PSFinal(PName(self._parse_name())) elif c == CODE_SKIP: pass elif c == CODE_QUOT: @@ -60,13 +62,15 @@ class Parser(AbstractParser): raise ValueError(f"unknown control: {hex(c)}") return state - def _state_next(self, state: PSAfter): + def _state_next(self, state: PSAfter) -> ParseState: if isinstance(state.state, PSAfter): state.state, state.target = state.state.state, PSChain(state.state.target, state.target) elif isinstance(state.state, PSFinal): state = state.target.given(state.state.parsed) elif isinstance(state.state, PSRead): state = self._state_read(state) + else: + raise TypeError return state def parse(self) -> Parsed: diff --git a/bu4/parsing/states/pscall.py b/bu4/parsing/states/pscall.py index 9274b0d..be8d6e5 100644 --- a/bu4/parsing/states/pscall.py +++ b/bu4/parsing/states/pscall.py @@ -8,19 +8,21 @@ from bu4.parsing.targets.pslambda import PSLambda __all__ = ('pscall',) -pscall = PSAfter( - PSRead(), - PSLambda( - lambda argument: PSAfter( - PSRead(), - PSLambda( - lambda lambda_: PSFinal( - PCall( - argument, - lambda_ + +def pscall(): + return PSAfter( + PSRead(), + PSLambda( + lambda argument: PSAfter( + PSRead(), + PSLambda( + lambda lambda_: PSFinal( + PCall( + argument, + lambda_ + ) ) ) ) ) ) -) diff --git a/bu4/parsing/targets/psendswith.py b/bu4/parsing/targets/psendswith.py index 6488bee..cf041cb 100644 --- a/bu4/parsing/targets/psendswith.py +++ b/bu4/parsing/targets/psendswith.py @@ -10,11 +10,11 @@ __all__ = ('PSEndsWith',) class PSEndsWith(PSTarget): - def __init__(self, parser: AbstractParser, c: int, msg: str): + def __init__(self, parser: AbstractParser, expected: int, message: str): self.parser = parser - self.c = c - self.msg = msg + self.expected = expected + self.message = message def given(self, parsed: Parsed) -> ParseState: - assert self.parser.read() == self.c, self.msg + assert self.parser.read() == self.expected, self.message return PSFinal(parsed) diff --git a/bu4/parsing/toolchain/transply.py b/bu4/parsing/toolchain/transply.py index 37ed93e..15ffda5 100644 --- a/bu4/parsing/toolchain/transply.py +++ b/bu4/parsing/toolchain/transply.py @@ -8,35 +8,35 @@ __all__ = ('transply',) def transply(source: str) -> bytes: - b = BytesIO() + transplied = BytesIO() for c in source: if c.isspace(): pass elif c in '/': - b.write(bytes([CODE_CALL])) + transplied.write(bytes([CODE_CALL])) elif c in '{‹': - b.write(bytes([CODE_CALL, CODE_QOPN])) + transplied.write(bytes([CODE_CALL, CODE_QOPN])) elif c in '(': - b.write(bytes([CODE_MAKE])) + transplied.write(bytes([CODE_MAKE])) elif c in '|': - b.write(bytes([CODE_QCLS, CODE_MAKE])) + transplied.write(bytes([CODE_QCLS, CODE_MAKE])) elif c in '})': - b.write(bytes([CODE_NULL])) + transplied.write(bytes([CODE_NULL])) elif c in '#': - b.write(bytes([CODE_SKIP])) + transplied.write(bytes([CODE_SKIP])) elif c in '?': - b.write(bytes([CODE_QOPN, CODE_NULL, CODE_QCLS])) + transplied.write(bytes([CODE_QOPN, CODE_NULL, CODE_QCLS])) elif c in ']': - b.write(bytes([CODE_NULL, CODE_QCLS])) + transplied.write(bytes([CODE_NULL, CODE_QCLS])) elif c in '[': - b.write(bytes([CODE_QOPN, CODE_NAME])) + transplied.write(bytes([CODE_QOPN, CODE_NAME])) elif c in '"': - b.write(bytes([CODE_QUOT])) + transplied.write(bytes([CODE_QUOT])) elif c in '<': - b.write(bytes([CODE_QOPN])) + transplied.write(bytes([CODE_QOPN])) elif c in '>›': - b.write(bytes([CODE_QCLS])) + transplied.write(bytes([CODE_QCLS])) else: value = c.encode() - b.write(value if len(value) == 1 else f'[{value.hex()}]'.encode()) - return b.getvalue() + transplied.write(value if len(value) == 1 else f'[{value.hex()}]'.encode()) + return transplied.getvalue() diff --git a/main.py b/main.py index 45588a5..13405bf 100644 --- a/main.py +++ b/main.py @@ -1,15 +1,13 @@ # Copyright (c) PARRRATE T&V 2021. All rights reserved. -import sys +import random from bu4.common_interface import with_common_interface from bu4.evaluation.constructs.proxy import antiproxy, eproxy from bu4.evaluation.sync import sync -from bu4.synced import synced from bu4.parsing.toolchain.readfile import readfile +from bu4.synced import synced from timesample import TimeSample -sys.setrecursionlimit(13) - with TimeSample('all'): with TimeSample('sys0'): with TimeSample('compilation'): @@ -58,8 +56,10 @@ with TimeSample('all'): TimeSample.print(sys3) with TimeSample('sys1'): sys1 = with_common_interface(synced(readfile('src/sys1'))) - sys1 = sync(sys1.call(eproxy(5))) - sys1 = sync(sys1.call(eproxy(6))) + random.seed(42) + sys1 = sync(sys1.call(eproxy(random.randrange(2 ** 10)))) + sys1 = sync(sys1.call(eproxy(random.randrange(2 ** 10)))) + sys1 = sync(sys1.call(eproxy(random.randrange(2 ** 10)))) TimeSample.print(sys1) with TimeSample('sys4'): TimeSample.print(with_common_interface(synced(readfile('src/sys4')))) diff --git a/src/math/@.bu4 b/src/math/@.bu4 index 69c2f05..00948d7 100644 --- a/src/math/@.bu4 +++ b/src/math/@.bu4 @@ -1,2 +1,3 @@ @gcd @exp +@mod_mul diff --git a/src/math/mod_mul.bu4 b/src/math/mod_mul.bu4 new file mode 100644 index 0000000..6c844b2 --- /dev/null +++ b/src/math/mod_mul.bu4 @@ -0,0 +1,17 @@ +{ + (_div) (_mul) (_m) + (_a) (_b) + / + / + / + [_b] + / + [_a] + [_mul] + / + [_m] + [_div] + [second] +| + _mod_mul +} diff --git a/src/sys1.bu4 b/src/sys1.bu4 index 9002367..90c1253 100644 --- a/src/sys1.bu4 +++ b/src/sys1.bu4 @@ -4,9 +4,11 @@ @ci { /[b_zq]/[b_div][_gcd] | gcd } -{ /[b1]/[b_halve]/[b_lb]/[b_zq]/[b_mul][_exp] | exp } -(a)(b) +(a)(b)(m) + +{ //[b_mul]/[b_div][_mod_mul] | mod_mul } +{ /[b1]/[b_halve]/[b_lb]/[b_zq]/[mod_mul][_exp] | exp } / /