PTV/builtup4
1
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

_mod_mul

Browse Source
This commit is contained in:
AF 2021-08-01 00:50:02 +03:00
parent 9e1a953898
commit e06606ed1e
9 changed files with 77 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
bu4/parsing/constructs/lcall.py
View File

@ -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_)

24
bu4/parsing/parser.py
View File

@ -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:

24
bu4/parsing/states/pscall.py
View File

@ -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_
)
)
)
)
)
)
)

8
bu4/parsing/targets/psendswith.py
View File

@ -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)

30
bu4/parsing/toolchain/transply.py
View File

@ -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()

12
main.py
View File

@ -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'))))

1
src/math/@.bu4
View File

@ -1,2 +1,3 @@
@gcd
@exp
@mod_mul

17
src/math/mod_mul.bu4 Normal file
View File

@ -0,0 +1,17 @@
{
(_div) (_mul) (_m)
(_a) (_b)
/
/
/
[_b]
/
[_a]
[_mul]
/
[_m]
[_div]
[second]
|
_mod_mul
}

6
src/sys1.bu4
View File

@ -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)
{ /</[m][n_to_b]>/[b_mul]/[b_div][_mod_mul] | mod_mul }
{ /[b1]/[b_halve]/[b_lb]/[b_zq]/[mod_mul][_exp] | exp }
/
/