From efc87e30f4e51979ff1e70e04d8be16e4aa00125 Mon Sep 17 00:00:00 2001 From: timotheyca Date: Sat, 24 Jul 2021 14:54:25 +0300 Subject: [PATCH] xx2b, bitwise, b_halve --- bu4/{utils.py => common_interface.py} | 8 +- bu4/evaluation/{ => av}/aftervalue.py | 37 ++----- bu4/evaluation/av/envtype.py | 12 +++ bu4/evaluation/{ => av}/lambdaenv.py | 8 +- bu4/evaluation/avcall.py | 14 --- bu4/evaluation/{ => constructs}/elambda.py | 10 +- bu4/evaluation/{ => constructs}/elinked.py | 7 +- bu4/evaluation/{ => constructs}/enull.py | 3 +- bu4/evaluation/{ => constructs}/evaluable.py | 3 + bu4/evaluation/constructs/evalue.py | 13 +++ bu4/evaluation/{ => constructs}/proxy.py | 9 +- bu4/{toolchain => evaluation}/sync.py | 5 +- bu4/evaluation/synced.py | 14 +++ bu4/evaluation/targets/avcall.py | 17 +++ bu4/evaluation/{ => targets}/avcontainer.py | 7 +- bu4/evaluation/targets/avtarget.py | 9 ++ bu4/linking/altarget.py | 6 -- bu4/linking/evaluable_from_parsed.py | 12 +++ bu4/linking/linkingfinished.py | 6 -- bu4/{toolchain => linking}/prepare.py | 15 +-- bu4/linking/{ => states}/afterlinking.py | 7 +- bu4/linking/states/linkingfinished.py | 9 ++ bu4/linking/{ => states}/linkingparsed.py | 5 +- bu4/linking/states/linkingstate.py | 5 + bu4/linking/{alal.py => targets/alchain.py} | 11 +- bu4/linking/{ => targets}/allambda.py | 7 +- bu4/linking/targets/altarget.py | 9 ++ bu4/parsing/abstractparser.py | 6 ++ bu4/{ => parsing}/codes.py | 0 bu4/parsing/{ => constructs}/lcall.py | 23 ++-- bu4/parsing/{ => constructs}/linked.py | 7 +- bu4/parsing/{ => constructs}/llambda.py | 20 ++-- bu4/parsing/{ => constructs}/lname.py | 12 ++- bu4/parsing/constructs/lnull.py | 35 +++++++ bu4/parsing/lnull.py | 33 ------ bu4/parsing/parser.py | 105 ++++--------------- bu4/parsing/states/parsestate.py | 5 + bu4/parsing/states/psafter.py | 10 ++ bu4/parsing/states/pscall.py | 24 +++++ bu4/parsing/states/psfinal.py | 9 ++ bu4/parsing/states/psread.py | 7 ++ bu4/parsing/targets/pschain.py | 15 +++ bu4/parsing/targets/psendswith.py | 18 ++++ bu4/parsing/targets/pslambda.py | 15 +++ bu4/parsing/targets/pstarget.py | 9 ++ bu4/{ => parsing}/toolchain/parse.py | 5 +- bu4/{ => parsing}/toolchain/readfile.py | 4 +- bu4/{ => parsing}/toolchain/transply.py | 4 +- bu4/toolchain/elinked.py | 10 -- bu4/toolchain/synced.py | 12 --- main.py | 15 ++- src/@.bu4 | 1 + src/binary/@.bu4 | 1 + src/binary/add.bu4 | 3 +- src/binary/bitwise.bu4 | 99 +++++++++++++++++ src/serialization/@.bu4 | 1 + src/serialization/hex.bu4 | 15 +++ src/sys1.bu4 | 15 +++ timesample.py | 2 + 59 files changed, 548 insertions(+), 260 deletions(-) rename bu4/{utils.py => common_interface.py} (71%) rename bu4/evaluation/{ => av}/aftervalue.py (53%) create mode 100644 bu4/evaluation/av/envtype.py rename bu4/evaluation/{ => av}/lambdaenv.py (70%) delete mode 100644 bu4/evaluation/avcall.py rename bu4/evaluation/{ => constructs}/elambda.py (58%) rename bu4/evaluation/{ => constructs}/elinked.py (60%) rename bu4/evaluation/{ => constructs}/enull.py (59%) rename bu4/evaluation/{ => constructs}/evaluable.py (76%) create mode 100644 bu4/evaluation/constructs/evalue.py rename bu4/evaluation/{ => constructs}/proxy.py (80%) rename bu4/{toolchain => evaluation}/sync.py (56%) create mode 100644 bu4/evaluation/synced.py create mode 100644 bu4/evaluation/targets/avcall.py rename bu4/evaluation/{ => targets}/avcontainer.py (50%) create mode 100644 bu4/evaluation/targets/avtarget.py delete mode 100644 bu4/linking/altarget.py create mode 100644 bu4/linking/evaluable_from_parsed.py delete mode 100644 bu4/linking/linkingfinished.py rename bu4/{toolchain => linking}/prepare.py (60%) rename bu4/linking/{ => states}/afterlinking.py (53%) create mode 100644 bu4/linking/states/linkingfinished.py rename bu4/linking/{ => states}/linkingparsed.py (53%) create mode 100644 bu4/linking/states/linkingstate.py rename bu4/linking/{alal.py => targets/alchain.py} (50%) rename bu4/linking/{ => targets}/allambda.py (57%) create mode 100644 bu4/linking/targets/altarget.py create mode 100644 bu4/parsing/abstractparser.py rename bu4/{ => parsing}/codes.py (100%) rename bu4/parsing/{ => constructs}/lcall.py (69%) rename bu4/parsing/{ => constructs}/linked.py (71%) rename bu4/parsing/{ => constructs}/llambda.py (69%) rename bu4/parsing/{ => constructs}/lname.py (67%) create mode 100644 bu4/parsing/constructs/lnull.py delete mode 100644 bu4/parsing/lnull.py create mode 100644 bu4/parsing/states/parsestate.py create mode 100644 bu4/parsing/states/psafter.py create mode 100644 bu4/parsing/states/pscall.py create mode 100644 bu4/parsing/states/psfinal.py create mode 100644 bu4/parsing/states/psread.py create mode 100644 bu4/parsing/targets/pschain.py create mode 100644 bu4/parsing/targets/psendswith.py create mode 100644 bu4/parsing/targets/pslambda.py create mode 100644 bu4/parsing/targets/pstarget.py rename bu4/{ => parsing}/toolchain/parse.py (60%) rename bu4/{ => parsing}/toolchain/readfile.py (67%) rename bu4/{ => parsing}/toolchain/transply.py (91%) delete mode 100644 bu4/toolchain/elinked.py delete mode 100644 bu4/toolchain/synced.py create mode 100644 src/binary/bitwise.bu4 create mode 100644 src/serialization/@.bu4 create mode 100644 src/serialization/hex.bu4 create mode 100644 src/sys1.bu4 diff --git a/bu4/utils.py b/bu4/common_interface.py similarity index 71% rename from bu4/utils.py rename to bu4/common_interface.py index 729eeac..ff441c8 100644 --- a/bu4/utils.py +++ b/bu4/common_interface.py @@ -1,6 +1,8 @@ -from bu4.evaluation.proxy import eproxy -from bu4.evaluation.aftervalue import EValue -from bu4.toolchain.sync import sync +from bu4.evaluation.constructs.evalue import EValue +from bu4.evaluation.constructs.proxy import eproxy +from bu4.evaluation.sync import sync + +__all__ = ('to_bool', 'with_common_interface',) def to_bool(_01): diff --git a/bu4/evaluation/aftervalue.py b/bu4/evaluation/av/aftervalue.py similarity index 53% rename from bu4/evaluation/aftervalue.py rename to bu4/evaluation/av/aftervalue.py index b9e729e..0f6ab45 100644 --- a/bu4/evaluation/aftervalue.py +++ b/bu4/evaluation/av/aftervalue.py @@ -1,19 +1,8 @@ -import abc -from typing import Mapping +from bu4.evaluation.targets.avtarget import AVTarget +from bu4.evaluation.constructs.evaluable import Evaluable +from bu4.evaluation.constructs.evalue import EValue -from bu4.evaluation.evaluable import Evaluable - -try: - from typing import TypeAlias -except ImportError: - TypeAlias = type - -envtype: TypeAlias = Mapping[bytes, 'AfterValue'] - - -class AVTarget: - def given(self, value: 'EValue') -> Evaluable: - raise NotImplementedError +__all__ = ('AfterValue',) class AfterValue(Evaluable): @@ -21,30 +10,22 @@ class AfterValue(Evaluable): self.evaluable = evaluable self.target = target - def next(self) -> 'Evaluable': + def next(self) -> Evaluable: if isinstance(self.evaluable, EValue): - if isinstance(self.target, AVAV): + if isinstance(self.target, AVChain): self.evaluable, self.target = self.target.target.given(self.evaluable), self.target.aftertarget return self return self.target.given(self.evaluable) if isinstance(self.evaluable, AfterValue): - self.evaluable, self.target = self.evaluable.evaluable, AVAV(self.evaluable.target, self.target) + self.evaluable, self.target = self.evaluable.evaluable, AVChain(self.evaluable.target, self.target) self.evaluable = self.evaluable.next() return self -class AVAV(AVTarget): +class AVChain(AVTarget): def __init__(self, target: AVTarget, aftertarget: AVTarget): self.target = target self.aftertarget = aftertarget - def given(self, value: 'EValue') -> Evaluable: + def given(self, value: EValue) -> Evaluable: return AfterValue(self.target.given(value), self.aftertarget) - - -class EValue(Evaluable, abc.ABC): - def next(self) -> 'EValue': - return self - - def call(self, argument: Evaluable) -> Evaluable: - raise NotImplementedError diff --git a/bu4/evaluation/av/envtype.py b/bu4/evaluation/av/envtype.py new file mode 100644 index 0000000..e100b65 --- /dev/null +++ b/bu4/evaluation/av/envtype.py @@ -0,0 +1,12 @@ +from typing import Mapping + +from bu4.evaluation.av.aftervalue import AfterValue + +__all__ = ('envtype',) + +try: + from typing import TypeAlias +except ImportError: + TypeAlias = type + +envtype: TypeAlias = Mapping[bytes, AfterValue] diff --git a/bu4/evaluation/lambdaenv.py b/bu4/evaluation/av/lambdaenv.py similarity index 70% rename from bu4/evaluation/lambdaenv.py rename to bu4/evaluation/av/lambdaenv.py index 58612ad..f78542c 100644 --- a/bu4/evaluation/lambdaenv.py +++ b/bu4/evaluation/av/lambdaenv.py @@ -1,7 +1,11 @@ from typing import Mapping, Iterator -from bu4.evaluation.avcontainer import AVContainer -from bu4.evaluation.aftervalue import AfterValue, envtype, Evaluable +from bu4.evaluation.av.aftervalue import AfterValue +from bu4.evaluation.targets.avcontainer import AVContainer +from bu4.evaluation.av.envtype import envtype +from bu4.evaluation.constructs.evaluable import Evaluable + +__all__ = ('LambdaEnv',) class LambdaEnv(Mapping): diff --git a/bu4/evaluation/avcall.py b/bu4/evaluation/avcall.py deleted file mode 100644 index e493a30..0000000 --- a/bu4/evaluation/avcall.py +++ /dev/null @@ -1,14 +0,0 @@ -from bu4.evaluation.elinked import ELinked -from bu4.parsing.linked import Linked -from bu4.evaluation.aftervalue import Evaluable, EValue, AVTarget, envtype - -__all__ = ('AVCall',) - - -class AVCall(AVTarget): - def __init__(self, env: envtype, argument: Linked): - self.env = env - self.argument = argument - - def given(self, value: EValue) -> Evaluable: - return value.call(ELinked(self.env, self.argument)) diff --git a/bu4/evaluation/elambda.py b/bu4/evaluation/constructs/elambda.py similarity index 58% rename from bu4/evaluation/elambda.py rename to bu4/evaluation/constructs/elambda.py index a09f669..ac347bd 100644 --- a/bu4/evaluation/elambda.py +++ b/bu4/evaluation/constructs/elambda.py @@ -1,7 +1,9 @@ -from bu4.evaluation.elinked import ELinked -from bu4.evaluation.lambdaenv import LambdaEnv -from bu4.parsing.linked import Linked -from bu4.evaluation.aftervalue import EValue, envtype, Evaluable +from bu4.evaluation.constructs.elinked import ELinked +from bu4.evaluation.av.envtype import envtype +from bu4.evaluation.constructs.evaluable import Evaluable +from bu4.evaluation.constructs.evalue import EValue +from bu4.evaluation.av.lambdaenv import LambdaEnv +from bu4.parsing.constructs.linked import Linked __all__ = ('ELambda',) diff --git a/bu4/evaluation/elinked.py b/bu4/evaluation/constructs/elinked.py similarity index 60% rename from bu4/evaluation/elinked.py rename to bu4/evaluation/constructs/elinked.py index 50cb55d..0624e89 100644 --- a/bu4/evaluation/elinked.py +++ b/bu4/evaluation/constructs/elinked.py @@ -1,5 +1,8 @@ -from bu4.parsing.linked import Linked -from bu4.evaluation.aftervalue import Evaluable, envtype +from bu4.evaluation.av.envtype import envtype +from bu4.evaluation.constructs.evaluable import Evaluable +from bu4.parsing.constructs.linked import Linked + +__all__ = ('ELinked',) class ELinked(Evaluable): diff --git a/bu4/evaluation/enull.py b/bu4/evaluation/constructs/enull.py similarity index 59% rename from bu4/evaluation/enull.py rename to bu4/evaluation/constructs/enull.py index 1545e6d..577332c 100644 --- a/bu4/evaluation/enull.py +++ b/bu4/evaluation/constructs/enull.py @@ -1,4 +1,5 @@ -from bu4.evaluation.aftervalue import EValue, Evaluable +from bu4.evaluation.constructs.evaluable import Evaluable +from bu4.evaluation.constructs.evalue import EValue __all__ = ('ENull',) diff --git a/bu4/evaluation/evaluable.py b/bu4/evaluation/constructs/evaluable.py similarity index 76% rename from bu4/evaluation/evaluable.py rename to bu4/evaluation/constructs/evaluable.py index 960616a..06c1942 100644 --- a/bu4/evaluation/evaluable.py +++ b/bu4/evaluation/constructs/evaluable.py @@ -1,3 +1,6 @@ +__all__ = ('Evaluable',) + + class Evaluable: def next(self) -> 'Evaluable': raise NotImplementedError diff --git a/bu4/evaluation/constructs/evalue.py b/bu4/evaluation/constructs/evalue.py new file mode 100644 index 0000000..1686cb3 --- /dev/null +++ b/bu4/evaluation/constructs/evalue.py @@ -0,0 +1,13 @@ +import abc + +from bu4.evaluation.constructs.evaluable import Evaluable + +__all__ = ('EValue',) + + +class EValue(Evaluable, abc.ABC): + def next(self) -> 'EValue': + return self + + def call(self, argument: Evaluable) -> Evaluable: + raise NotImplementedError diff --git a/bu4/evaluation/proxy.py b/bu4/evaluation/constructs/proxy.py similarity index 80% rename from bu4/evaluation/proxy.py rename to bu4/evaluation/constructs/proxy.py index 6b82643..e65c269 100644 --- a/bu4/evaluation/proxy.py +++ b/bu4/evaluation/constructs/proxy.py @@ -1,7 +1,12 @@ from typing import Any -from bu4.evaluation.aftervalue import AVTarget, EValue, Evaluable, AfterValue -from bu4.toolchain.sync import sync +from bu4.evaluation.av.aftervalue import AfterValue +from bu4.evaluation.targets.avtarget import AVTarget +from bu4.evaluation.constructs.evaluable import Evaluable +from bu4.evaluation.constructs.evalue import EValue +from bu4.evaluation.sync import sync + +__all__ = ('eproxy', 'antiproxy') class AVProxyCall(AVTarget): diff --git a/bu4/toolchain/sync.py b/bu4/evaluation/sync.py similarity index 56% rename from bu4/toolchain/sync.py rename to bu4/evaluation/sync.py index c58141b..a23b716 100644 --- a/bu4/toolchain/sync.py +++ b/bu4/evaluation/sync.py @@ -1,4 +1,7 @@ -from bu4.evaluation.aftervalue import Evaluable, EValue +from bu4.evaluation.constructs.evaluable import Evaluable +from bu4.evaluation.constructs.evalue import EValue + +__all__ = ('sync',) def sync(evaluable: Evaluable) -> EValue: diff --git a/bu4/evaluation/synced.py b/bu4/evaluation/synced.py new file mode 100644 index 0000000..fb1ca73 --- /dev/null +++ b/bu4/evaluation/synced.py @@ -0,0 +1,14 @@ +from bu4.evaluation.constructs.evalue import EValue +from bu4.evaluation.sync import sync +from bu4.linking.evaluable_from_parsed import evaluable_from_parsed +from bu4.parsing.toolchain.parse import parse +from bu4.parsing.toolchain.transply import transply + +__all__ = ('synced',) + + +def synced(source: str) -> EValue: + bsource = transply(source) + parsed = parse(bsource) + evaluable = evaluable_from_parsed({}, parsed) + return sync(evaluable) diff --git a/bu4/evaluation/targets/avcall.py b/bu4/evaluation/targets/avcall.py new file mode 100644 index 0000000..61e887d --- /dev/null +++ b/bu4/evaluation/targets/avcall.py @@ -0,0 +1,17 @@ +from bu4.evaluation.targets.avtarget import AVTarget +from bu4.evaluation.constructs.elinked import ELinked +from bu4.evaluation.av.envtype import envtype +from bu4.evaluation.constructs.evaluable import Evaluable +from bu4.evaluation.constructs.evalue import EValue +from bu4.parsing.constructs.linked import Linked + +__all__ = ('AVCall',) + + +class AVCall(AVTarget): + def __init__(self, env: envtype, argument: Linked): + self.env = env + self.argument = argument + + def given(self, value: EValue) -> Evaluable: + return value.call(ELinked(self.env, self.argument)) diff --git a/bu4/evaluation/avcontainer.py b/bu4/evaluation/targets/avcontainer.py similarity index 50% rename from bu4/evaluation/avcontainer.py rename to bu4/evaluation/targets/avcontainer.py index 0a5f25d..f844a9a 100644 --- a/bu4/evaluation/avcontainer.py +++ b/bu4/evaluation/targets/avcontainer.py @@ -1,4 +1,9 @@ -from bu4.evaluation.aftervalue import EValue, AfterValue, Evaluable, AVTarget +from bu4.evaluation.av.aftervalue import AfterValue +from bu4.evaluation.targets.avtarget import AVTarget +from bu4.evaluation.constructs.evaluable import Evaluable +from bu4.evaluation.constructs.evalue import EValue + +__all__ = ('AVContainer',) class AVContainer(AVTarget): diff --git a/bu4/evaluation/targets/avtarget.py b/bu4/evaluation/targets/avtarget.py new file mode 100644 index 0000000..2ce38d8 --- /dev/null +++ b/bu4/evaluation/targets/avtarget.py @@ -0,0 +1,9 @@ +from bu4.evaluation.constructs.evaluable import Evaluable +from bu4.evaluation.constructs.evalue import EValue + +__all__ = ('AVTarget',) + + +class AVTarget: + def given(self, value: EValue) -> Evaluable: + raise NotImplementedError diff --git a/bu4/linking/altarget.py b/bu4/linking/altarget.py deleted file mode 100644 index e63e8be..0000000 --- a/bu4/linking/altarget.py +++ /dev/null @@ -1,6 +0,0 @@ -from bu4.parsing.linked import Linked, LinkingState - - -class ALTarget: - def given(self, linked: Linked) -> LinkingState: - raise NotImplementedError diff --git a/bu4/linking/evaluable_from_parsed.py b/bu4/linking/evaluable_from_parsed.py new file mode 100644 index 0000000..ed2a4b8 --- /dev/null +++ b/bu4/linking/evaluable_from_parsed.py @@ -0,0 +1,12 @@ +from bu4.evaluation.constructs.elinked import ELinked +from bu4.evaluation.av.envtype import envtype +from bu4.linking.prepare import prepare +from bu4.parsing.constructs.linked import Parsed + +__all__ = ('evaluable_from_parsed',) + + +def evaluable_from_parsed(env: envtype, parsed: Parsed): + linked = parsed.link(set(env)) + prepare(linked) + return ELinked(env, linked) diff --git a/bu4/linking/linkingfinished.py b/bu4/linking/linkingfinished.py deleted file mode 100644 index 3168f6e..0000000 --- a/bu4/linking/linkingfinished.py +++ /dev/null @@ -1,6 +0,0 @@ -from bu4.parsing.linked import LinkingState, Linked - - -class LinkingFinished(LinkingState): - def __init__(self, linked: Linked): - self.linked = linked diff --git a/bu4/toolchain/prepare.py b/bu4/linking/prepare.py similarity index 60% rename from bu4/toolchain/prepare.py rename to bu4/linking/prepare.py index f1cab13..6159084 100644 --- a/bu4/toolchain/prepare.py +++ b/bu4/linking/prepare.py @@ -1,15 +1,18 @@ -from bu4.linking.afterlinking import AfterLinking -from bu4.linking.alal import ALAL -from bu4.parsing.linked import LinkingState, Linked -from bu4.linking.linkingfinished import LinkingFinished -from bu4.linking.linkingparsed import LinkingParsed +from bu4.linking.states.afterlinking import AfterLinking +from bu4.linking.targets.alchain import ALChain +from bu4.linking.states.linkingfinished import LinkingFinished +from bu4.linking.states.linkingparsed import LinkingParsed +from bu4.linking.states.linkingstate import LinkingState +from bu4.parsing.constructs.linked import Linked + +__all__ = ('prepare',) def _afterlinking_iteration(state: AfterLinking) -> LinkingState: if isinstance(state.state, LinkingFinished): state = state.target.given(state.state.linked) elif isinstance(state.state, AfterLinking): - state.state, state.target = state.state.state, ALAL(state.state.target, state.target) + state.state, state.target = state.state.state, ALChain(state.state.target, state.target) elif isinstance(state.state, LinkingParsed): state.state = state.state.parsed.link(state.state.promise).link() else: diff --git a/bu4/linking/afterlinking.py b/bu4/linking/states/afterlinking.py similarity index 53% rename from bu4/linking/afterlinking.py rename to bu4/linking/states/afterlinking.py index 796228d..1b4c261 100644 --- a/bu4/linking/afterlinking.py +++ b/bu4/linking/states/afterlinking.py @@ -1,5 +1,8 @@ -from bu4.linking.altarget import ALTarget -from bu4.parsing.linked import LinkingState +from bu4.linking.targets.altarget import ALTarget + +__all__ = ('AfterLinking',) + +from bu4.linking.states.linkingstate import LinkingState class AfterLinking(LinkingState): diff --git a/bu4/linking/states/linkingfinished.py b/bu4/linking/states/linkingfinished.py new file mode 100644 index 0000000..47634a6 --- /dev/null +++ b/bu4/linking/states/linkingfinished.py @@ -0,0 +1,9 @@ +from bu4.linking.states.linkingstate import LinkingState +from bu4.parsing.constructs.linked import Linked + +__all__ = ('LinkingFinished',) + + +class LinkingFinished(LinkingState): + def __init__(self, linked: Linked): + self.linked = linked diff --git a/bu4/linking/linkingparsed.py b/bu4/linking/states/linkingparsed.py similarity index 53% rename from bu4/linking/linkingparsed.py rename to bu4/linking/states/linkingparsed.py index a3b2948..61968c0 100644 --- a/bu4/linking/linkingparsed.py +++ b/bu4/linking/states/linkingparsed.py @@ -1,4 +1,7 @@ -from bu4.parsing.linked import LinkingState, Parsed +from bu4.linking.states.linkingstate import LinkingState +from bu4.parsing.constructs.linked import Parsed + +__all__ = ('LinkingParsed',) class LinkingParsed(LinkingState): diff --git a/bu4/linking/states/linkingstate.py b/bu4/linking/states/linkingstate.py new file mode 100644 index 0000000..b1e8b4b --- /dev/null +++ b/bu4/linking/states/linkingstate.py @@ -0,0 +1,5 @@ +__all__ = ('LinkingState',) + + +class LinkingState: + pass diff --git a/bu4/linking/alal.py b/bu4/linking/targets/alchain.py similarity index 50% rename from bu4/linking/alal.py rename to bu4/linking/targets/alchain.py index 5aa845d..bd973f3 100644 --- a/bu4/linking/alal.py +++ b/bu4/linking/targets/alchain.py @@ -1,9 +1,12 @@ -from bu4.linking.afterlinking import AfterLinking -from bu4.linking.altarget import ALTarget -from bu4.parsing.linked import Linked, LinkingState +from bu4.linking.states.afterlinking import AfterLinking +from bu4.linking.targets.altarget import ALTarget +from bu4.linking.states.linkingstate import LinkingState +from bu4.parsing.constructs.linked import Linked + +__all__ = ('ALChain',) -class ALAL(ALTarget): +class ALChain(ALTarget): def __init__(self, target: ALTarget, aftertarget: ALTarget): self.target = target self.aftertarget = aftertarget diff --git a/bu4/linking/allambda.py b/bu4/linking/targets/allambda.py similarity index 57% rename from bu4/linking/allambda.py rename to bu4/linking/targets/allambda.py index a88f2fd..c88f52d 100644 --- a/bu4/linking/allambda.py +++ b/bu4/linking/targets/allambda.py @@ -1,7 +1,10 @@ from typing import Callable -from bu4.linking.altarget import ALTarget -from bu4.parsing.linked import Linked, LinkingState +from bu4.linking.targets.altarget import ALTarget +from bu4.linking.states.linkingstate import LinkingState +from bu4.parsing.constructs.linked import Linked + +__all__ = ('ALLambda',) class ALLambda(ALTarget): diff --git a/bu4/linking/targets/altarget.py b/bu4/linking/targets/altarget.py new file mode 100644 index 0000000..d4c27d9 --- /dev/null +++ b/bu4/linking/targets/altarget.py @@ -0,0 +1,9 @@ +from bu4.linking.states.linkingstate import LinkingState +from bu4.parsing.constructs.linked import Linked + +__all__ = ('ALTarget',) + + +class ALTarget: + def given(self, linked: Linked) -> LinkingState: + raise NotImplementedError diff --git a/bu4/parsing/abstractparser.py b/bu4/parsing/abstractparser.py new file mode 100644 index 0000000..bb49a93 --- /dev/null +++ b/bu4/parsing/abstractparser.py @@ -0,0 +1,6 @@ +__all__ = ('AbstractParser',) + + +class AbstractParser: + def read(self) -> int: + raise NotImplementedError diff --git a/bu4/codes.py b/bu4/parsing/codes.py similarity index 100% rename from bu4/codes.py rename to bu4/parsing/codes.py diff --git a/bu4/parsing/lcall.py b/bu4/parsing/constructs/lcall.py similarity index 69% rename from bu4/parsing/lcall.py rename to bu4/parsing/constructs/lcall.py index 9a8ce4a..a604e6e 100644 --- a/bu4/parsing/lcall.py +++ b/bu4/parsing/constructs/lcall.py @@ -1,14 +1,17 @@ -from bu4.codes import CODE_CALL -from bu4.evaluation.avcall import AVCall -from bu4.evaluation.elinked import ELinked -from bu4.linking.afterlinking import AfterLinking -from bu4.linking.allambda import ALLambda -from bu4.parsing.linked import Linked, Parsed, LinkingState -from bu4.linking.linkingfinished import LinkingFinished -from bu4.linking.linkingparsed import LinkingParsed -from bu4.evaluation.aftervalue import envtype, Evaluable, AfterValue +from bu4.evaluation.av.aftervalue import AfterValue +from bu4.evaluation.av.envtype import envtype +from bu4.linking.states.linkingstate import LinkingState +from bu4.parsing.codes import CODE_CALL +from bu4.evaluation.targets.avcall import AVCall +from bu4.evaluation.constructs.elinked import ELinked +from bu4.linking.states.afterlinking import AfterLinking +from bu4.linking.targets.allambda import ALLambda +from bu4.parsing.constructs.linked import Linked, Parsed +from bu4.linking.states.linkingfinished import LinkingFinished +from bu4.linking.states.linkingparsed import LinkingParsed +from bu4.evaluation.constructs.evaluable import Evaluable -__all__ = ('LCall', 'PCall',) +__all__ = ('PCall',) class LCall(Linked): diff --git a/bu4/parsing/linked.py b/bu4/parsing/constructs/linked.py similarity index 71% rename from bu4/parsing/linked.py rename to bu4/parsing/constructs/linked.py index 6c669cb..e03ac50 100644 --- a/bu4/parsing/linked.py +++ b/bu4/parsing/constructs/linked.py @@ -1,8 +1,9 @@ -from bu4.evaluation.aftervalue import envtype, Evaluable +from bu4.evaluation.av.envtype import envtype +from bu4.evaluation.constructs.evaluable import Evaluable +__all__ = ('Linked', 'Parsed',) -class LinkingState: - pass +from bu4.linking.states.linkingstate import LinkingState class Linked: diff --git a/bu4/parsing/llambda.py b/bu4/parsing/constructs/llambda.py similarity index 69% rename from bu4/parsing/llambda.py rename to bu4/parsing/constructs/llambda.py index 187741e..3c16a2d 100644 --- a/bu4/parsing/llambda.py +++ b/bu4/parsing/constructs/llambda.py @@ -1,13 +1,15 @@ -from bu4.codes import CODE_MAKE, CODE_NULL -from bu4.evaluation.elambda import ELambda -from bu4.linking.afterlinking import AfterLinking -from bu4.linking.allambda import ALLambda -from bu4.parsing.linked import Linked, Parsed, LinkingState -from bu4.linking.linkingfinished import LinkingFinished -from bu4.linking.linkingparsed import LinkingParsed -from bu4.evaluation.aftervalue import envtype, Evaluable +from bu4.evaluation.av.envtype import envtype +from bu4.linking.states.linkingstate import LinkingState +from bu4.parsing.codes import CODE_MAKE, CODE_NULL +from bu4.evaluation.constructs.elambda import ELambda +from bu4.linking.states.afterlinking import AfterLinking +from bu4.linking.targets.allambda import ALLambda +from bu4.parsing.constructs.linked import Linked, Parsed +from bu4.linking.states.linkingfinished import LinkingFinished +from bu4.linking.states.linkingparsed import LinkingParsed +from bu4.evaluation.constructs.evaluable import Evaluable -__all__ = ('LLambda', 'PLambda',) +__all__ = ('PLambda',) class LLambda(Linked): diff --git a/bu4/parsing/lname.py b/bu4/parsing/constructs/lname.py similarity index 67% rename from bu4/parsing/lname.py rename to bu4/parsing/constructs/lname.py index 8a34f82..6140c53 100644 --- a/bu4/parsing/lname.py +++ b/bu4/parsing/constructs/lname.py @@ -1,10 +1,12 @@ -from bu4.codes import CODE_NAME, CODE_NULL -from bu4.parsing.linked import Linked, LinkingState, Parsed -from bu4.linking.linkingfinished import LinkingFinished -from bu4.evaluation.aftervalue import envtype, Evaluable +from bu4.evaluation.av.envtype import envtype +from bu4.linking.states.linkingstate import LinkingState +from bu4.parsing.codes import CODE_NAME, CODE_NULL +from bu4.parsing.constructs.linked import Linked, Parsed +from bu4.linking.states.linkingfinished import LinkingFinished +from bu4.evaluation.constructs.evaluable import Evaluable -__all__ = ('LName', 'PName',) +__all__ = ('PName',) class LName(Linked): diff --git a/bu4/parsing/constructs/lnull.py b/bu4/parsing/constructs/lnull.py new file mode 100644 index 0000000..4305ed5 --- /dev/null +++ b/bu4/parsing/constructs/lnull.py @@ -0,0 +1,35 @@ +from bu4.evaluation.constructs.enull import ENull +from bu4.evaluation.av.envtype import envtype +from bu4.linking.states.linkingstate import LinkingState +from bu4.parsing.codes import CODE_NULL +from bu4.parsing.constructs.linked import Linked, Parsed +from bu4.linking.states.linkingfinished import LinkingFinished +from bu4.evaluation.constructs.evaluable import Evaluable + + +__all__ = ('PNull',) + + +class LNull(Linked): + def __init__(self): + self.future = set() + + def link(self) -> LinkingState: + return LinkingFinished(self) + + def evaluable(self, env: envtype) -> Evaluable: + return ENull() + + def __str__(self): + return '?' + + def unlink(self) -> Parsed: + return PNull() + + +class PNull(Parsed): + def link(self, promise: set[bytes]) -> Linked: + return LNull() + + def __bytes__(self): + return bytes([CODE_NULL]) diff --git a/bu4/parsing/lnull.py b/bu4/parsing/lnull.py deleted file mode 100644 index d4a8592..0000000 --- a/bu4/parsing/lnull.py +++ /dev/null @@ -1,33 +0,0 @@ -from bu4.evaluation.enull import ENull -from bu4.codes import CODE_NULL -from bu4.parsing.linked import Linked, LinkingState, Parsed -from bu4.linking.linkingfinished import LinkingFinished -from bu4.evaluation.aftervalue import envtype, Evaluable - - -__all__ = ('LNull', 'PNull',) - - -class LNull(Linked): - def __init__(self): - self.future = set() - - def link(self) -> LinkingState: - return LinkingFinished(self) - - def evaluable(self, env: envtype) -> Evaluable: - return ENull() - - def __str__(self): - return '?' - - def unlink(self) -> Parsed: - return PNull() - - -class PNull(Parsed): - def link(self, promise: set[bytes]) -> 'Linked': - return LNull() - - def __bytes__(self): - return bytes([CODE_NULL]) diff --git a/bu4/parsing/parser.py b/bu4/parsing/parser.py index 7eb9e17..ee36c60 100644 --- a/bu4/parsing/parser.py +++ b/bu4/parsing/parser.py @@ -1,86 +1,23 @@ from io import BytesIO -from typing import Callable -from bu4.parsing.linked import Parsed -from bu4.parsing.lname import PName -from bu4.codes import CODE_NULL, CODE_CALL, CODE_MAKE, CODE_NAME, CODE_SKIP, CODE_QUOT, CODE_QOPN, CODE_QCLS -from bu4.parsing.lcall import PCall -from bu4.parsing.lnull import PNull +from bu4.parsing.abstractparser import AbstractParser +from bu4.parsing.codes import * +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.psafter import PSAfter +from bu4.parsing.states.pscall import pscall +from bu4.parsing.states.psfinal import PSFinal +from bu4.parsing.states.psread import PSRead +from bu4.parsing.targets.pschain import PSChain +from bu4.parsing.targets.psendswith import PSEndsWith +from bu4.parsing.targets.pslambda import PSLambda -from bu4.parsing.llambda import PLambda +__all__ = ('Parser',) -class ParseState: - pass - - -class PSRead(ParseState): - pass - - -class PSFinal(ParseState): - def __init__(self, parsed: Parsed): - self.parsed = parsed - - -class PSATarget: - def given(self, parsed: Parsed) -> ParseState: - raise NotImplementedError - - -class PSAfter(ParseState): - def __init__(self, state, target: PSATarget): - self.state = state - self.target = target - - -class PSAA(PSATarget): - def __init__(self, target: PSATarget, aftertarget: PSATarget): - self.target = target - self.aftertarget = aftertarget - - def given(self, parsed: Parsed) -> ParseState: - return PSAfter(self.target.given(parsed), self.aftertarget) - - -class PSALambda(PSATarget): - def __init__(self, lambda_: Callable[[Parsed], ParseState]): - self.lambda_ = lambda_ - - def given(self, parsed: Parsed) -> ParseState: - return self.lambda_(parsed) - - -class PSAEndsWith(PSATarget): - def __init__(self, parser: 'Parser', c: int, msg: str): - self.parser = parser - self.c = c - self.msg = msg - - def given(self, parsed: Parsed) -> ParseState: - assert self.parser.read() == self.c, self.msg - return PSFinal(parsed) - - -_apacall = PSAfter( - PSRead(), - PSALambda( - lambda argument: PSAfter( - PSRead(), - PSALambda( - lambda lambda_: PSFinal( - PCall( - argument, - lambda_ - ) - ) - ) - ) - ) -) - - -class Parser: +class Parser(AbstractParser): def __init__(self, s: bytes): self.__s = BytesIO(s) @@ -101,11 +38,11 @@ class Parser: if c == CODE_NULL: state.state = PSFinal(PNull()) elif c == CODE_CALL: - state.state = _apacall + state.state = pscall elif c == CODE_MAKE: state.state = (lambda name: PSAfter( PSRead(), - PSALambda( + PSLambda( lambda value: PSFinal(PLambda(name, value)) ) ))(self.parse_name()) @@ -114,16 +51,16 @@ class Parser: elif c == CODE_SKIP: pass elif c == CODE_QUOT: - state.target = PSAA(PSAEndsWith(self, CODE_QUOT, "quot expected"), state.target) + state.target = PSChain(PSEndsWith(self, CODE_QUOT, "quot expected"), state.target) elif c == CODE_QOPN: - state.target = PSAA(PSAEndsWith(self, CODE_QCLS, "qcls expected"), state.target) + state.target = PSChain(PSEndsWith(self, CODE_QCLS, "qcls expected"), state.target) else: raise ValueError(f"unknown control: {hex(c)}") return state def _state_next(self, state: PSAfter): if isinstance(state.state, PSAfter): - state.state, state.target = state.state.state, PSAA(state.state.target, state.target) + 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): @@ -131,7 +68,7 @@ class Parser: return state def parse(self) -> Parsed: - state = PSAfter(PSRead(), PSALambda(lambda parsed: PSFinal(parsed))) + state = PSAfter(PSRead(), PSLambda(lambda parsed: PSFinal(parsed))) while True: if isinstance(state, PSFinal): return state.parsed diff --git a/bu4/parsing/states/parsestate.py b/bu4/parsing/states/parsestate.py new file mode 100644 index 0000000..f6dca66 --- /dev/null +++ b/bu4/parsing/states/parsestate.py @@ -0,0 +1,5 @@ +__all__ = ('ParseState',) + + +class ParseState: + pass diff --git a/bu4/parsing/states/psafter.py b/bu4/parsing/states/psafter.py new file mode 100644 index 0000000..e937388 --- /dev/null +++ b/bu4/parsing/states/psafter.py @@ -0,0 +1,10 @@ +from bu4.parsing.states.parsestate import ParseState +from bu4.parsing.targets.pstarget import PSTarget + +__all__ = ('PSAfter',) + + +class PSAfter(ParseState): + def __init__(self, state: ParseState, target: PSTarget): + self.state = state + self.target = target diff --git a/bu4/parsing/states/pscall.py b/bu4/parsing/states/pscall.py new file mode 100644 index 0000000..940d70c --- /dev/null +++ b/bu4/parsing/states/pscall.py @@ -0,0 +1,24 @@ +from bu4.parsing.constructs.lcall import PCall +from bu4.parsing.states.psafter import PSAfter +from bu4.parsing.states.psfinal import PSFinal +from bu4.parsing.targets.pslambda import PSLambda +from bu4.parsing.states.psread import PSRead + +__all__ = ('pscall',) + +pscall = PSAfter( + PSRead(), + PSLambda( + lambda argument: PSAfter( + PSRead(), + PSLambda( + lambda lambda_: PSFinal( + PCall( + argument, + lambda_ + ) + ) + ) + ) + ) +) diff --git a/bu4/parsing/states/psfinal.py b/bu4/parsing/states/psfinal.py new file mode 100644 index 0000000..21f5592 --- /dev/null +++ b/bu4/parsing/states/psfinal.py @@ -0,0 +1,9 @@ +from bu4.parsing.constructs.linked import Parsed +from bu4.parsing.states.parsestate import ParseState + +__all__ = ('PSFinal',) + + +class PSFinal(ParseState): + def __init__(self, parsed: Parsed): + self.parsed = parsed diff --git a/bu4/parsing/states/psread.py b/bu4/parsing/states/psread.py new file mode 100644 index 0000000..02df39a --- /dev/null +++ b/bu4/parsing/states/psread.py @@ -0,0 +1,7 @@ +from bu4.parsing.states.parsestate import ParseState + +__all__ = ('PSRead',) + + +class PSRead(ParseState): + pass diff --git a/bu4/parsing/targets/pschain.py b/bu4/parsing/targets/pschain.py new file mode 100644 index 0000000..79b52aa --- /dev/null +++ b/bu4/parsing/targets/pschain.py @@ -0,0 +1,15 @@ +from bu4.parsing.constructs.linked import Parsed +from bu4.parsing.states.parsestate import ParseState +from bu4.parsing.states.psafter import PSAfter +from bu4.parsing.targets.pstarget import PSTarget + +__all__ = ('PSChain',) + + +class PSChain(PSTarget): + def __init__(self, target: PSTarget, aftertarget: PSTarget): + self.target = target + self.aftertarget = aftertarget + + def given(self, parsed: Parsed) -> ParseState: + return PSAfter(self.target.given(parsed), self.aftertarget) diff --git a/bu4/parsing/targets/psendswith.py b/bu4/parsing/targets/psendswith.py new file mode 100644 index 0000000..490d3a8 --- /dev/null +++ b/bu4/parsing/targets/psendswith.py @@ -0,0 +1,18 @@ +from bu4.parsing.abstractparser import AbstractParser +from bu4.parsing.constructs.linked import Parsed +from bu4.parsing.states.parsestate import ParseState +from bu4.parsing.states.psfinal import PSFinal +from bu4.parsing.targets.pstarget import PSTarget + +__all__ = ('PSEndsWith',) + + +class PSEndsWith(PSTarget): + def __init__(self, parser: AbstractParser, c: int, msg: str): + self.parser = parser + self.c = c + self.msg = msg + + def given(self, parsed: Parsed) -> ParseState: + assert self.parser.read() == self.c, self.msg + return PSFinal(parsed) diff --git a/bu4/parsing/targets/pslambda.py b/bu4/parsing/targets/pslambda.py new file mode 100644 index 0000000..b65c820 --- /dev/null +++ b/bu4/parsing/targets/pslambda.py @@ -0,0 +1,15 @@ +from typing import Callable + +from bu4.parsing.constructs.linked import Parsed +from bu4.parsing.states.parsestate import ParseState +from bu4.parsing.targets.pstarget import PSTarget + +__all__ = ('PSLambda',) + + +class PSLambda(PSTarget): + def __init__(self, lambda_: Callable[[Parsed], ParseState]): + self.lambda_ = lambda_ + + def given(self, parsed: Parsed) -> ParseState: + return self.lambda_(parsed) diff --git a/bu4/parsing/targets/pstarget.py b/bu4/parsing/targets/pstarget.py new file mode 100644 index 0000000..0358d75 --- /dev/null +++ b/bu4/parsing/targets/pstarget.py @@ -0,0 +1,9 @@ +from bu4.parsing.constructs.linked import Parsed +from bu4.parsing.states.parsestate import ParseState + +__all__ = ('PSTarget',) + + +class PSTarget: + def given(self, parsed: Parsed) -> ParseState: + raise NotImplementedError diff --git a/bu4/toolchain/parse.py b/bu4/parsing/toolchain/parse.py similarity index 60% rename from bu4/toolchain/parse.py rename to bu4/parsing/toolchain/parse.py index dfc0a29..de3361e 100644 --- a/bu4/toolchain/parse.py +++ b/bu4/parsing/toolchain/parse.py @@ -1,6 +1,9 @@ -from bu4.parsing.linked import Parsed +from bu4.parsing.constructs.linked import Parsed from bu4.parsing.parser import Parser +__all__ = ('parse',) + + def parse(source: bytes) -> Parsed: return Parser(source).parse() diff --git a/bu4/toolchain/readfile.py b/bu4/parsing/toolchain/readfile.py similarity index 67% rename from bu4/toolchain/readfile.py rename to bu4/parsing/toolchain/readfile.py index 716bc1f..a83ea77 100644 --- a/bu4/toolchain/readfile.py +++ b/bu4/parsing/toolchain/readfile.py @@ -1,13 +1,15 @@ import os from io import StringIO +__all__ = ('readfile',) + def readfile(path: str) -> str: srcio = StringIO() with open(path + '.bu4') as file: for line in file: if line.startswith('@'): - srcio.write(readfile(os.path.join(path, '..', line.removeprefix('@').strip()))) + srcio.write(readfile(os.path.join(path, os.path.pardir, line.removeprefix('@').strip()))) else: srcio.write(line) return srcio.getvalue() diff --git a/bu4/toolchain/transply.py b/bu4/parsing/toolchain/transply.py similarity index 91% rename from bu4/toolchain/transply.py rename to bu4/parsing/toolchain/transply.py index 025a1c5..b005845 100644 --- a/bu4/toolchain/transply.py +++ b/bu4/parsing/toolchain/transply.py @@ -1,6 +1,8 @@ from io import BytesIO -from bu4.codes import CODE_CALL, CODE_QOPN, CODE_MAKE, CODE_QCLS, CODE_NULL, CODE_SKIP, CODE_NAME, CODE_QUOT +from bu4.parsing.codes import * + +__all__ = ('transply',) def transply(source: str) -> bytes: diff --git a/bu4/toolchain/elinked.py b/bu4/toolchain/elinked.py deleted file mode 100644 index dcb070d..0000000 --- a/bu4/toolchain/elinked.py +++ /dev/null @@ -1,10 +0,0 @@ -from bu4.evaluation.elinked import ELinked -from bu4.parsing.linked import Parsed -from bu4.evaluation.aftervalue import envtype -from bu4.toolchain.prepare import prepare - - -def elinked(env: envtype, parsed: Parsed): - linked = parsed.link(set(env)) - prepare(linked) - return ELinked(env, linked) diff --git a/bu4/toolchain/synced.py b/bu4/toolchain/synced.py deleted file mode 100644 index c7b36d0..0000000 --- a/bu4/toolchain/synced.py +++ /dev/null @@ -1,12 +0,0 @@ -from bu4.evaluation.aftervalue import EValue -from bu4.toolchain.elinked import elinked -from bu4.toolchain.parse import parse -from bu4.toolchain.sync import sync -from bu4.toolchain.transply import transply - - -def synced(source: str) -> EValue: - bsource = transply(source) - parsed = parse(bsource) - evaluable = elinked({}, parsed) - return sync(evaluable) diff --git a/main.py b/main.py index f9ddc7f..111c90c 100644 --- a/main.py +++ b/main.py @@ -1,8 +1,8 @@ -from bu4.evaluation.proxy import antiproxy, eproxy -from bu4.toolchain.readfile import readfile -from bu4.toolchain.sync import sync -from bu4.toolchain.synced import synced -from bu4.utils import with_common_interface +from bu4.common_interface import with_common_interface +from bu4.evaluation.constructs.proxy import antiproxy, eproxy +from bu4.evaluation.sync import sync +from bu4.evaluation.synced import synced +from bu4.parsing.toolchain.readfile import readfile from timesample import TimeSample with TimeSample(' compilation'): @@ -49,3 +49,8 @@ with TimeSample(' full'): sys3 = with_common_interface(synced(readfile('src/sys3'))) sys3 = sync(sys3.call(eproxy(5))) print(sys3) +with TimeSample(' full'): + sys1 = with_common_interface(synced(readfile('src/sys1'))) + sys1 = sync(sys1.call(eproxy(77))) + sys1 = sync(sys1.call(eproxy(194))) + print(sys1) diff --git a/src/@.bu4 b/src/@.bu4 index 2f6cf0d..95c0d8b 100644 --- a/src/@.bu4 +++ b/src/@.bu4 @@ -3,4 +3,5 @@ @binary/@ @convert/@ @io/@ +@serialization/@ @numbers diff --git a/src/binary/@.bu4 b/src/binary/@.bu4 index 403f23c..4ad2d08 100644 --- a/src/binary/@.bu4 +++ b/src/binary/@.bu4 @@ -3,3 +3,4 @@ @add @mul @sub +@bitwise diff --git a/src/binary/add.bu4 b/src/binary/add.bu4 index c33bf8b..506cd8b 100644 --- a/src/binary/add.bu4 +++ b/src/binary/add.bu4 @@ -1,4 +1,5 @@ -{ (b) | b_double } +{ (b) | b_double } +{ (b) [b]> | b_halve } { /(b_add) diff --git a/src/binary/bitwise.bu4 b/src/binary/bitwise.bu4 new file mode 100644 index 0000000..dd2b99c --- /dev/null +++ b/src/binary/bitwise.bu4 @@ -0,0 +1,99 @@ +{ + /(b_and) + (bA)(bB) + /(zqA)(lbA)(hb!A) + / + /(zqB)(lbB)(hb!B) + / + / + /[hb!B]/[hb!A][b_and] + / + /[lbB]/[lbA][and] + [b!] + / + [b0] + [zqB] + [bB] + / + [b0] + [zqA] + [bA] + [YC] +| + b_and +} + +{ + /(b_or) + (bA)(bB) + /(zqA)(lbA)(hb!A) + / + /(zqB)(lbB)(hb!B) + / + / + /[hb!B]/[hb!A][b_or] + / + /[lbB]/[lbA][or] + [b!] + / + [bA] + [zqB] + [bB] + / + [bB] + [zqA] + [bA] + [YC] +| + b_or +} + +{ + /(b_xor) + (bA)(bB) + /(zqA)(lbA)(hb!A) + / + /(zqB)(lbB)(hb!B) + / + / + /[hb!B]/[hb!A][b_xor] + / + /[lbB]/[lbA][xor] + [b!] + / + [bA] + [zqB] + [bB] + / + [bB] + [zqA] + [bA] + [YC] +| + b_xor +} + +{ + /(b_exclude) + (bA)(bB) + /(zqA)(lbA)(hb!A) + / + /(zqB)(lbB)(hb!B) + / + / + /[hb!B]/[hb!A][b_exclude] + / + //[lbA][and] + [b!] + / + [bA] + [zqB] + [bB] + / + [b0] + [zqA] + [bA] + [YC] +| + b_exclude +} diff --git a/src/serialization/@.bu4 b/src/serialization/@.bu4 new file mode 100644 index 0000000..b0865b2 --- /dev/null +++ b/src/serialization/@.bu4 @@ -0,0 +1 @@ +@hex diff --git a/src/serialization/hex.bu4 b/src/serialization/hex.bu4 new file mode 100644 index 0000000..00c876b --- /dev/null +++ b/src/serialization/hex.bu4 @@ -0,0 +1,15 @@ +{ + (b) ////[b][b_double][b_double][b_double][b_double] +| + x16 +} + +{ + { (higher) (zq)(lb)(hb) / [higher] /[lb][b!] | 2x2b } + { (higher) (zq)(lb)(hb) ///[higher][2x2b][hb ]/[lb][b!] | 4x2b } + { (higher) (zq)(lb)(hb) ///[higher][4x2b][hb ]/[lb][b!] | 8x2b } + { (higher) (zq)(lb)(hb) ///[higher][8x2b][hb ]/[lb][b!] | xx2b } + (lower) (higher) ////[b0][xx2b][higher][xx2b][lower] +| + xx2b +} diff --git a/src/sys1.bu4 b/src/sys1.bu4 new file mode 100644 index 0000000..11db521 --- /dev/null +++ b/src/sys1.bu4 @@ -0,0 +1,15 @@ +@@ + +"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" +@ci + +(a)(b) + + / + / + /[b][n_to_bx] + / + /[a][n_to_bx] + [xx2b] + [b_to_nx] +"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" diff --git a/timesample.py b/timesample.py index e85d4ac..2a3cbce 100644 --- a/timesample.py +++ b/timesample.py @@ -1,5 +1,7 @@ import time +__all__ = ('TimeSample',) + class TimeSample: level = 0