def inner(f):
name = f.__name__.decode("utf-8")
doc = f.__doc__.decode("utf-8") if f.__doc__ else None
if singleAtom is None:
arity = len(inspect.getargspec(f).args)
theAtom = getAtom(name, arity)
else:
arity = singleAtom.arity
theAtom = singleAtom
unrolledArity = unrolling_iterable(range(arity))
class runnableObject(Object):
def toString(self):
return u"<%s>" % name
def auditorStamps(self):
return _stamps
def docString(self):
return doc
def respondingAtoms(self):
return {theAtom: doc}
def recv(self, atom, listArgs):
if atom is theAtom:
args = ()
for i in unrolledArity:
args += (listArgs[i], )
return f(*args)
else:
raise Refused(self, atom, listArgs)
return runnableObject
def call(self, verb, arguments, namedArgs=None):
"""
Pass a message immediately to this object.
"""
from typhon.objects.collections.maps import EMPTY_MAP
if namedArgs is None:
namedArgs = EMPTY_MAP
arity = len(arguments)
atom = getAtom(verb, arity)
return self.callAtom(atom, arguments, namedArgs)
def visitMethodExpr(self, doc, verb, patts, namedPatts, guard, body,
localSize, span):
atom = getAtom(verb, len(patts))
patts = [self.visitPatt(patt) for patt in patts]
namedPatts = [self.visitNamedPatt(namedPatt) for namedPatt in
namedPatts]
guard = self.visitExpr(guard)
body = self.visitExpr(body)
return self.dest.MethodExpr(doc, atom, patts, namedPatts, guard, body,
localSize, span)
def call(self, verb, arguments, namedArgs=None):
"""
Pass a message immediately to this object.
"""
from typhon.objects.collections.maps import EMPTY_MAP
if namedArgs is None:
namedArgs = EMPTY_MAP
arity = len(arguments)
atom = getAtom(verb, arity)
return self.callAtom(atom, arguments, namedArgs)
def call(self, verb, arguments, namedArgs=None, span=None):
"""
Pass a message immediately to this object.
This is the correct method to call if you have a verb.
"""
arity = len(arguments)
atom = getAtom(verb, arity)
return self.callAtom(atom, arguments, namedArgs, span)
def call(self, verb, arguments, namedArgs=None, span=None):
"""
Pass a message immediately to this object.
This is the correct method to call if you have a verb.
"""
arity = len(arguments)
atom = getAtom(verb, arity)
return self.callAtom(atom, arguments, namedArgs, span)
def mirandaMethods(self, atom, arguments, namedArgsMap):
from typhon.objects.collections.maps import EMPTY_MAP
if atom is _CONFORMTO_1:
# Welcome to _conformTo/1.
# to _conformTo(_): return self
return self
if atom is _GETALLEGEDINTERFACE_0:
# Welcome to _getAllegedInterface/0.
interface = self.optInterface()
if interface is None:
from typhon.objects.interfaces import ComputedInterface
interface = ComputedInterface(self)
return interface
if atom is _PRINTON_1:
# Welcome to _printOn/1.
from typhon.objects.constants import NullObject
self.printOn(arguments[0])
return NullObject
if atom is _RESPONDSTO_2:
from typhon.objects.constants import wrapBool
from typhon.objects.data import unwrapInt, unwrapStr
verb = unwrapStr(arguments[0])
arity = unwrapInt(arguments[1])
atom = getAtom(verb, arity)
result = (atom in self.respondingAtoms() or
atom in mirandaAtoms)
return wrapBool(result)
if atom is _SEALEDDISPATCH_1:
# to _sealedDispatch(_): return null
from typhon.objects.constants import NullObject
return NullObject
if atom is _UNCALL_0:
from typhon.objects.constants import NullObject
return NullObject
if atom is _WHENMORERESOLVED_1:
# Welcome to _whenMoreResolved.
# This method's implementation, in Monte, should be:
# to _whenMoreResolved(callback): callback<-(self)
from typhon.vats import currentVat
vat = currentVat.get()
vat.sendOnly(arguments[0], RUN_1, [self], EMPTY_MAP)
from typhon.objects.constants import NullObject
return NullObject
return None
def sendOnly(self, target, verb, args, namedArgs):
"""
Send a message to an object.
The message will be delivered on some subsequent turn.
"""
namedArgs = resolution(namedArgs)
if not isinstance(namedArgs, ConstMap):
raise WrongType(u"namedArgs must be a ConstMap")
# Signed, sealed, delivered, I'm yours.
sendAtom = getAtom(verb, len(args))
vat = currentVat.get()
vat.sendOnly(target, sendAtom, args, namedArgs)
def sendOnly(self, target, verb, args, namedArgs):
"""
Send a message to an object.
The message will be delivered on some subsequent turn.
"""
namedArgs = resolution(namedArgs)
if not isinstance(namedArgs, ConstMap):
raise WrongType(u"namedArgs must be a ConstMap")
# Signed, sealed, delivered, I'm yours.
sendAtom = getAtom(verb, len(args))
vat = currentVat.get()
vat.sendOnly(target, sendAtom, args, namedArgs)
def mirandaMethods(self, atom, arguments, namedArgsMap):
from typhon.objects.collections.maps import EMPTY_MAP
if atom is _CONFORMTO_1:
# Welcome to _conformTo/1.
# to _conformTo(_): return self
return self
if atom is _GETALLEGEDINTERFACE_0:
# Welcome to _getAllegedInterface/0.
interface = self.optInterface()
if interface is None:
from typhon.objects.interfaces import ComputedInterface
interface = ComputedInterface(self)
return interface
if atom is _PRINTON_1:
# Welcome to _printOn/1.
from typhon.objects.constants import NullObject
self.printOn(arguments[0])
return NullObject
if atom is _RESPONDSTO_2:
from typhon.objects.constants import wrapBool
from typhon.objects.data import unwrapInt, unwrapStr
verb = unwrapStr(arguments[0])
arity = unwrapInt(arguments[1])
atom = getAtom(verb, arity)
result = (atom in self.respondingAtoms() or atom in mirandaAtoms)
return wrapBool(result)
if atom is _SEALEDDISPATCH_1:
# to _sealedDispatch(_): return null
from typhon.objects.constants import NullObject
return NullObject
if atom is _UNCALL_0:
from typhon.objects.constants import NullObject
return NullObject
if atom is _WHENMORERESOLVED_1:
# Welcome to _whenMoreResolved.
# This method's implementation, in Monte, should be:
# to _whenMoreResolved(callback): callback<-(self)
from typhon.vats import currentVat
vat = currentVat.get()
vat.sendOnly(arguments[0], RUN_1, [self], EMPTY_MAP)
from typhon.objects.constants import NullObject
return NullObject
return None
def send(self, target, verb, args, namedArgs):
"""
Send a message to an object, returning a promise for the message
delivery.
The promise will be fulfilled after successful delivery, or smashed
upon error.
The message will be delivered on some subsequent turn.
"""
namedArgs = resolution(namedArgs)
if not isinstance(namedArgs, ConstMap):
raise WrongType(u"namedArgs must be a ConstMap")
# Signed, sealed, delivered, I'm yours.
sendAtom = getAtom(verb, len(args))
vat = currentVat.get()
return vat.send(target, sendAtom, args, namedArgs)
def send(self, target, verb, args, namedArgs):
"""
Send a message to an object, returning a promise for the message
delivery.
The promise will be fulfilled after successful delivery, or smashed
upon error.
The message will be delivered on some subsequent turn.
"""
namedArgs = resolution(namedArgs)
if not isinstance(namedArgs, ConstMap):
raise WrongType(u"namedArgs must be a ConstMap")
# Signed, sealed, delivered, I'm yours.
sendAtom = getAtom(verb, len(args))
vat = currentVat.get()
return vat.send(target, sendAtom, args, namedArgs)
def inner(f):
name = f.__name__.decode("utf-8")
doc = f.__doc__.decode("utf-8") if f.__doc__ else None
if singleAtom is None:
arity = len(inspect.getargspec(f).args)
theAtom = getAtom(name, arity)
else:
arity = singleAtom.arity
theAtom = singleAtom
unrolledArity = unrolling_iterable(range(arity))
class runnableObject(Object):
def toString(self):
return u"<%s>" % name
def auditorStamps(self):
from typhon.objects.collections.helpers import asSet
return asSet(_stamps)
def isSettled(self, sofar=None):
return True
def docString(self):
return doc
def respondingAtoms(self):
return {theAtom: doc}
def recv(self, atom, listArgs):
if atom is theAtom:
args = ()
for i in unrolledArity:
args += (listArgs[i],)
return f(*args)
else:
raise Refused(self, atom, listArgs)
return runnableObject
def testIdempotency(self):
first = getAtom(u"test", 5)
second = getAtom(u"test", 5)
self.assertTrue(first is second)
from typhon.atoms import getAtom
from typhon.autohelp import autohelp
from typhon.errors import Refused
from typhon.objects.constants import NullObject
from typhon.objects.collections.sets import ConstSet, monteSet
from typhon.objects.data import IntObject, StrObject
from typhon.objects.root import Object
GETARITY_0 = getAtom(u"getArity", 0)
GETDOCSTRING_0 = getAtom(u"getDocstring", 0)
GETMETHODS_0 = getAtom(u"getMethods", 0)
GETVERB_0 = getAtom(u"getVerb", 0)
@autohelp
class ComputedMethod(Object):
"""
A method description.
"""
_immutable_ = True
def __init__(self, arity, docstring, verb):
self.arity = arity
self.docstring = docstring
self.verb = verb
def toString(self):
return u"<computed message %s/%d>" % (self.verb, self.arity)
from typhon.env import finalize
from typhon.errors import LoadFailed, Refused, userError
from typhon.importing import (codeFromAst, evaluateRaise, obtainModule,
obtainModuleFromSource)
from typhon.load.mast import loadMASTBytes
from typhon.nodes import kernelAstStamp
from typhon.objects.auditors import deepFrozenStamp, transparentStamp
from typhon.objects.collections.lists import ConstList
from typhon.objects.collections.maps import ConstMap, monteMap, unwrapMap
from typhon.objects.collections.sets import ConstSet
from typhon.objects.data import StrObject, unwrapBytes, wrapBool, unwrapStr
from typhon.objects.guards import (BoolGuard, BytesGuard, CharGuard,
DoubleGuard, IntGuard, StrGuard, VoidGuard)
from typhon.objects.root import Object, audited, runnable
EVALTOPAIR_2 = getAtom(u"evalToPair", 2)
FROMAST_3 = getAtom(u"fromAST", 3)
RUN_1 = getAtom(u"run", 1)
RUN_2 = getAtom(u"run", 2)
@runnable(RUN_1, [deepFrozenStamp])
def isList(specimen):
return wrapBool(isinstance(specimen, ConstList))
@runnable(RUN_1, [deepFrozenStamp])
def isMap(specimen):
return wrapBool(isinstance(specimen, ConstMap))
from rpython.rlib.rstring import ParseStringError
from rpython.rlib.rstruct.ieee import unpack_float
from typhon.atoms import getAtom
from typhon.autohelp import autohelp, method
from typhon.objects.auditors import deepFrozenStamp
from typhon.objects.collections.lists import listFromIterable
from typhon.objects.collections.maps import ConstMap
from typhon.objects.data import (bytesToString, unwrapInt,
unwrapChar)
from typhon.objects.ejectors import throwStr
from typhon.objects.root import Object, audited, runnable
from typhon.profile import profileTyphon
FROMPAIRS_1 = getAtom(u"fromPairs", 1)
@autohelp
@audited.DF
class MakeBytes(Object):
"""
The maker of `Bytes`.
"""
def toString(self):
return u"<makeBytes>"
@method("Bytes", "Str")
def fromStr(self, s):
return "".join([chr(ord(c)) for c in s])
from typhon.objects.data import StrObject, unwrapStr
from typhon.errors import Refused
from typhon.objects.exceptions import unsealException
from typhon.objects.files import makeFileResource
from typhon.objects.networking.dns import getAddrInfo
from typhon.objects.networking.endpoints import (makeTCP4ClientEndpoint,
makeTCP4ServerEndpoint)
from typhon.objects.networking.stdio import makeStdErr, makeStdIn, makeStdOut
from typhon.objects.processes import CurrentProcess, makeProcess
from typhon.objects.root import Object, audited
from typhon.objects.runtime import CurrentRuntime
from typhon.objects.timeit import bench
from typhon.objects.timers import Timer
from typhon.vats import CurrentVatProxy
RUN_1 = getAtom("run", 1)
@audited.DF
class FindTyphonFile(Object):
def __init__(self, paths):
self.paths = paths
def recv(self, atom, args):
if atom is RUN_1:
pname = unwrapStr(args[0])
for extension in [".ty", ".mast"]:
path = pname.encode("utf-8") + extension
for base in self.paths:
fullpath = os.path.join(base, path)
if os.path.exists(fullpath):
from typhon.errors import Ejecting, Refused, UserException, userError
from typhon.log import log
from typhon.objects.auditors import deepFrozenStamp
from typhon.objects.constants import NullObject, unwrapBool, wrapBool
from typhon.objects.collections.lists import ConstList
from typhon.objects.data import StrObject, unwrapStr
from typhon.objects.ejectors import Ejector
from typhon.objects.guards import anyGuard
from typhon.objects.printers import Printer
from typhon.objects.root import Object
from typhon.objects.slots import finalBinding
from typhon.smallcaps.machine import SmallCaps
# XXX AuditionStamp, Audition guard
ASK_1 = getAtom(u"ask", 1)
GETGUARD_1 = getAtom(u"getGuard", 1)
GETOBJECTEXPR_0 = getAtom(u"getObjectExpr", 0)
GETFQN_0 = getAtom(u"getFQN", 0)
pemci = u".".join([
u"lo lebna cu rivbi",
u"lo nu fi ri facki",
u"fa le vi larmuzga",
u"fe le zi ca du'u",
u"le lebna pu jbera",
u"lo catlu pe ro da",
])
def boolStr(b):
# Copyright (C) 2015 Google Inc. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may not
# use this file except in compliance with the License. You may obtain a copy
# of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from typhon.atoms import getAtom
from typhon.objects.data import StrObject
from typhon.objects.root import runnable
GETFQNPREFIX_0 = getAtom(u"getFQNPrefix", 0)
@runnable(GETFQNPREFIX_0)
def MetaContext():
"""
Obtain the fully qualified name prefix.
"""
return StrObject(u"unknown$monte$source$")
from rpython.rlib.objectmodel import compute_identity_hash
from typhon.atoms import getAtom
from typhon.autohelp import autohelp
from typhon.errors import Refused, userError
from typhon.objects.auditors import selfless, transparentStamp
from typhon.objects.collections.lists import ConstList, unwrapList
from typhon.objects.collections.maps import ConstMap
from typhon.objects.constants import BoolObject, NullObject, wrapBool
from typhon.objects.data import BigInt, BytesObject, CharObject, DoubleObject, IntObject, StrObject
from typhon.objects.refs import resolution, isResolved
from typhon.objects.root import Object, audited
ISSETTLED_1 = getAtom(u"isSettled", 1)
MAKETRAVERSALKEY_1 = getAtom(u"makeTraversalKey", 1)
OPTSAME_2 = getAtom(u"optSame", 2)
SAMEEVER_2 = getAtom(u"sameEver", 2)
SAMEYET_2 = getAtom(u"sameYet", 2)
class Equality(object):
def __init__(self, label):
self._label = label
def __repr__(self):
return self._label
EQUAL = Equality("EQUAL")
from rpython.rlib.rarithmetic import intmask
from typhon.atoms import getAtom
from typhon.autohelp import autohelp, method
from typhon.objects.root import Object
from typhon.objects.collections.maps import EMPTY_MAP
from typhon.objects.data import IntObject
from typhon.ruv import (alloc_signal, free, SignalStart, SignalStop,
stashSignal, unstashSignal, unstashingSignal)
RUN_1 = getAtom(u"run", 1)
def _signalCB(signal, signum):
with unstashingSignal(signal) as (vat, handle):
vat.sendOnly(handle._target, RUN_1, [IntObject(intmask(signum))],
EMPTY_MAP)
@autohelp
class SignalHandle(Object):
def __init__(self, signum, target, vat):
self._signum = signum
self._target = target
self._vat = vat
self._signal = alloc_signal(vat.uv_loop)
SignalStart(self._signal, _signalCB, self._signum)
stashSignal(self._signal, (vat, self))
@method("Void")
def alterMethods(cls):
"""
Alter Monte methods on behalf of AutoHelp.
Return the signatures of the altered methods.
NOT_RPYTHON
"""
atoms = []
imports = set()
execNames = {"Refused": Refused}
def nextName(nameIndex=[0]):
name = "_%d" % nameIndex[0]
nameIndex[0] += 1
return name
def namedLiteral(lit):
name = nextName()
execNames[name] = lit
return name
dispatchClauses = []
methods = harvestMethods(cls)
for attr, (f, verb, args, kwargs, rv) in methods.iteritems():
assignments = []
if isStarArgs(args):
atomTest = "atom.verb == %r" % verb
call = "self.%s(args)" % attr
else:
atom = getAtom(verb, len(args))
atomName = namedLiteral(atom)
atoms.append(atom)
atomTest = "atom is %s" % atomName
argNames = []
for i, arg in enumerate(args):
argName = nextName()
argNames.append(argName)
assignments.append("%s = args[%d]" % (argName, i))
if arg != "Any":
unwrapperModule = wrappers[arg]
pred = "is" + arg
imports.add("from %s import %s" % (unwrapperModule, pred))
atomTest += " and %s(args[%d])" % (pred, i)
unwrapper = "unwrap" + arg
imports.add("from %s import %s" % (unwrapperModule,
unwrapper))
assignments.append("%s = %s(%s)" % (argName, unwrapper,
argName))
else:
imports.add("from typhon.objects.refs import resolution")
assignments.append("%s = resolution(%s)" % (argName,
argName))
for k, v in kwargs.iteritems():
# Look up the default value. We're going to pop this in and
# use None as a sentinel value in .extractStringKey(). ~ C.
default = getKwargDefault(f, k)
defaultName = namedLiteral(default)
kwargName = nextName()
argNames.append("%s=%s" % (k, kwargName))
assignments.append("%s = namedArgs.extractStringKey(%r, None)"
% (kwargName, k.decode("utf-8")))
# If the kwarg is None, then it wasn't passed in; use the
# default. Otherwise, invoke the unwrapper if one exists.
assignments.append("if %s is None: %s = %s"
% (kwargName, kwargName, defaultName))
if v != "Any":
unwrapperModule = wrappers[v]
unwrapper = "unwrap" + v
imports.add("from %s import %s"
% (unwrapperModule, unwrapper))
assignments.append("else: %s = %s(%s)"
% (kwargName, unwrapper, kwargName))
call = "self.%s(%s)" % (attr, ",".join(argNames))
retvals = []
if rv == "Any":
# No wrapping.
retvals.append("return rv")
elif rv == "Void":
# Enforced correctness. Disobedience will not be tolerated.
retvals.append("assert rv is None, 'habanero'")
retvals.append("from typhon.objects.constants import NullObject")
retvals.append("return NullObject")
else:
wrapperModule = wrappers[rv]
wrapper = "wrap" + rv
imports.add("from %s import %s" % (wrapperModule, wrapper))
retvals.append("return %s(rv)" % wrapper)
# We need to use newlines for the assignments since kwarg assignments
# are conditional.
dispatchClauses.append("""
if %s:
%s
rv = %s
%s
""" % (atomTest, "\n ".join(assignments), call, ";".join(retvals)))
setattr(cls, attr, f)
# Temporary. Soon, all classes shall receive AutoHelp, and no class will
# have a handwritten recv().
if dispatchClauses:
exec py.code.Source("""
def recvNamed(self, atom, args, namedArgs):
%s
%s
rv = self.mirandaMethods(atom, args, namedArgs)
if rv is None:
raise Refused(self, atom, args)
else:
return rv
""" % (";".join(imports), "\n".join(dispatchClauses))).compile() in execNames
recvNamed = execNames["recvNamed"]
# This is the place for fixing the "too many constants" JIT
# translation error. If there's too many dispatch clauses in
# .recvNamed(), then the JIT transformation fails because too many
# constant values are being mixed in. This number is determined
# empirically; uncomment the next line to take measurements:
# print "Made %d dispatch clauses for %r" % (len(dispatchClauses), cls)
# Here's a worksheet. Please keep it up-to-date when altering this
# section of code. ~ C.
# * At last run, the longest working list of clauses had length 40
# * And the shortest list which broke translation had length 46
# * Assuming that each clause has a constant integral number of
# constants, the number of constants per clause is 6
# * The maximum number of allowed constants is 255
# * Therefore, the longest working list can have maximum length 42
if len(dispatchClauses) >= 42:
# Too many constants; forbid the JIT from recursing into us.
recvNamed = dont_look_inside(recvNamed)
cls.recvNamed = recvNamed
return atoms
from typhon.atoms import getAtom
from typhon.autohelp import autohelp, method
from typhon.enum import makeEnum
from typhon.errors import Ejecting, UserException, userError
from typhon.log import log
from typhon.objects.auditors import deepFrozenStamp, selfless
from typhon.objects.constants import NullObject
from typhon.objects.ejectors import Ejector
from typhon.objects.root import Object, audited
from typhon.vats import currentVat
BROKEN, EVENTUAL, NEAR = makeEnum(u"RefState",
u"broken eventual near".split())
RESOLVE_1 = getAtom(u"resolve", 1)
RESOLVE_2 = getAtom(u"resolve", 2)
RUN_1 = getAtom(u"run", 1)
_WHENBROKEN_1 = getAtom(u"_whenBroken", 1)
_WHENMORERESOLVED_1 = getAtom(u"_whenMoreResolved", 1)
def makePromise(guard=None):
vat = currentVat.get()
buf = MessageBuffer(vat)
sref = SwitchableRef(BufferingRef(buf))
return sref, LocalResolver(sref, buf, vat, guard)
def _toRef(o, vat):
if isinstance(o, Promise):
from rpython.rlib.rarithmetic import intmask
from rpython.rlib.objectmodel import we_are_translated
from rpython.rtyper.lltypesystem.rffi import charpsize2str
from typhon import ruv
from typhon.atoms import getAtom
from typhon.autohelp import autohelp
from typhon.errors import Refused, userError
from typhon.objects.constants import NullObject
from typhon.objects.data import BytesObject, StrObject, unwrapBytes
from typhon.objects.root import Object
from typhon.vats import scopedVat
ABORTFLOW_0 = getAtom(u"abortFlow", 0)
FLOWABORTED_1 = getAtom(u"flowAborted", 1)
FLOWINGFROM_1 = getAtom(u"flowingFrom", 1)
FLOWSTOPPED_1 = getAtom(u"flowStopped", 1)
FLOWTO_1 = getAtom(u"flowTo", 1)
FLUSH_0 = getAtom(u"flush", 0)
PAUSEFLOW_0 = getAtom(u"pauseFlow", 0)
RECEIVE_1 = getAtom(u"receive", 1)
RUN_2 = getAtom(u"run", 2)
STOPFLOW_0 = getAtom(u"stopFlow", 0)
UNPAUSE_0 = getAtom(u"unpause", 0)
@autohelp
class StreamUnpauser(Object):
"""
def visitCallExpr(self, obj, verb, args, namedArgs, span):
obj = self.visitExpr(obj)
atom = getAtom(verb, len(args))
args = [self.visitExpr(arg) for arg in args]
namedArgs = [self.visitNamedArg(namedArg) for namedArg in namedArgs]
return self.dest.CallExpr(obj, atom, args, namedArgs, span)
from rpython.rlib.objectmodel import we_are_translated
from rpython.rlib.rarithmetic import intmask
from typhon import ruv
from typhon.atoms import getAtom
from typhon.autohelp import autohelp
from typhon.errors import Refused, userError
from typhon.objects.collections.lists import ConstList, unwrapList
from typhon.objects.constants import NullObject
from typhon.objects.data import StrObject, unwrapBytes, unwrapInt
from typhon.objects.networking.streams import StreamDrain, StreamFount
from typhon.objects.refs import LocalResolver, makePromise
from typhon.objects.root import Object, runnable
from typhon.vats import currentVat, scopedVat
CONNECT_0 = getAtom(u"connect", 0)
LISTEN_1 = getAtom(u"listen", 1)
RUN_1 = getAtom(u"run", 1)
RUN_2 = getAtom(u"run", 2)
SHUTDOWN_0 = getAtom(u"shutdown", 0)
def connectCB(connect, status):
status = intmask(status)
stream = connect.c_handle
try:
vat, resolvers = ruv.unstashStream(stream)
fountResolver, drainResolver = unwrapList(resolvers)
assert isinstance(fountResolver, LocalResolver)
assert isinstance(drainResolver, LocalResolver)
from rpython.rlib.jit import JitDriver, promote
from typhon.atoms import getAtom
from typhon.errors import Ejecting
from typhon.objects.auditors import deepFrozenStamp
from typhon.objects.collections.lists import unwrapList
from typhon.objects.collections.maps import EMPTY_MAP
from typhon.objects.constants import NullObject
from typhon.objects.ejectors import Ejector
from typhon.objects.root import runnable
from typhon.objects.user import BusyObject, ScriptObject
from typhon.smallcaps.machine import SmallCaps
RUN_2 = getAtom(u"run", 2)
RUN_3 = getAtom(u"run", 3)
def getLocation(code):
return code.profileName
loopDriver = JitDriver(greens=["code"],
reds=["consumer", "ejector", "iterator"],
get_printable_location=getLocation)
def slowLoop(iterable, consumer):
iterator = iterable.call(u"_makeIterator", [])
from typhon.atoms import getAtom
from typhon.errors import userError
from typhon.vats import currentVat
from typhon.objects.collections.lists import ConstList
from typhon.objects.collections.maps import EMPTY_MAP
from typhon.objects.data import NullObject, StrObject, unwrapBool
from typhon.objects.equality import (EQUAL, TraversalKey, optSame, isSameEver,
isSettled)
from typhon.objects.guards import anyGuard
from typhon.objects.refs import (EVENTUAL, NEAR, Promise, UnconnectedRef,
isResolved, resolution)
from typhon.objects.root import audited
from typhon.objects.slots import FinalSlot
HANDLESEND_3 = getAtom(u"handleSend", 3)
HANDLESENDONLY_3 = getAtom(u"handleSendOnly", 3)
RUN_3 = getAtom(u"run", 3)
def send(ref, atom, args, namedArgs):
if isinstance(ref, Promise):
return ref.sendAll(atom, args, namedArgs)
else:
vat = currentVat.get()
return vat.send(ref, atom, args, namedArgs)
def sendOnly(ref, atom, args, namedArgs):
if isinstance(ref, Promise):
ref.sendAllOnly(atom, args, namedArgs)
else:
# under the License.
from rpython.rlib.jit import JitDriver
from typhon.atoms import getAtom
from typhon.errors import Ejecting
from typhon.nano.interp import InterpObject
from typhon.objects.auditors import deepFrozenStamp
from typhon.objects.collections.lists import unwrapList
from typhon.objects.collections.maps import EMPTY_MAP
from typhon.objects.constants import NullObject
from typhon.objects.ejectors import Ejector
from typhon.objects.root import runnable
RUN_2 = getAtom(u"run", 2)
def getLocation(method, displayName):
return displayName
loopDriver = JitDriver(greens=["method", "displayName"],
reds=["consumer", "ejector", "iterator"],
get_printable_location=getLocation)
def slowLoop(iterable, consumer):
iterator = iterable.call(u"_makeIterator", [])
with Ejector() as ej:
def alterMethods(cls):
"""
Alter Monte methods on behalf of AutoHelp.
Return the signatures of the altered methods.
NOT_RPYTHON
"""
atoms = {}
imports = set()
execNames = {"Refused": Refused}
def nextName(nameIndex=[0]):
name = "_%d" % nameIndex[0]
nameIndex[0] += 1
return name
def namedLiteral(lit):
name = nextName()
execNames[name] = lit
return name
dispatchClauses = []
methods = harvestMethods(cls)
for attr, (f, verb, args, kwargs, rv) in methods.iteritems():
assignments = []
if isStarArgs(args):
atomTest = "atom.verb == %r" % verb
call = "self.%s(args)" % attr
else:
atom = getAtom(verb, len(args))
atomName = namedLiteral(atom)
ds = f.__doc__
if ds is not None:
ds = ds.decode("utf-8")
atoms[atom] = ds
atomTest = "atom is %s" % atomName
argNames = []
for i, arg in enumerate(args):
argName = nextName()
argNames.append(argName)
assignments.append("%s = args[%d]" % (argName, i))
if arg != "Any":
unwrapperModule = wrappers[arg]
pred = "is" + arg
imports.add("from %s import %s" % (unwrapperModule, pred))
atomTest += " and %s(args[%d])" % (pred, i)
unwrapper = "unwrap" + arg
imports.add("from %s import %s" % (unwrapperModule,
unwrapper))
assignments.append("%s = %s(%s)" % (argName, unwrapper,
argName))
else:
imports.add("from typhon.objects.refs import resolution")
assignments.append("%s = resolution(%s)" % (argName,
argName))
for k, v in kwargs.iteritems():
# Look up the default value. We're going to pop this in and
# use None as a sentinel value in .extractStringKey(). ~ C.
default = getKwargDefault(f, k)
defaultName = namedLiteral(default)
kwargName = nextName()
argNames.append("%s=%s" % (k, kwargName))
assignments.append("%s = namedArgs.extractStringKey(%r, None)"
% (kwargName, k.decode("utf-8")))
# If the kwarg is None, then it wasn't passed in; use the
# default. Otherwise, invoke the unwrapper if one exists.
assignments.append("if %s is None: %s = %s"
% (kwargName, kwargName, defaultName))
if v != "Any":
unwrapperModule = wrappers[v]
unwrapper = "unwrap" + v
imports.add("from %s import %s"
% (unwrapperModule, unwrapper))
assignments.append("else: %s = %s(%s)"
% (kwargName, unwrapper, kwargName))
call = "self.%s(%s)" % (attr, ",".join(argNames))
retvals = []
if rv == "Any":
# No wrapping.
retvals.append("return rv")
elif rv == "Void":
# Enforced correctness. Disobedience will not be tolerated.
retvals.append("assert rv is None, 'habanero'")
retvals.append("from typhon.objects.constants import NullObject")
retvals.append("return NullObject")
else:
wrapperModule = wrappers[rv]
wrapper = "wrap" + rv
imports.add("from %s import %s" % (wrapperModule, wrapper))
retvals.append("return %s(rv)" % wrapper)
# We need to use newlines for the assignments since kwarg assignments
# are conditional.
dispatchClauses.append("""
if %s:
%s
rv = %s
%s
""" % (atomTest, "\n ".join(assignments), call, ";".join(retvals)))
setattr(cls, attr, f)
# Temporary. Soon, all classes shall receive AutoHelp, and no class will
# have a handwritten recv().
if dispatchClauses:
exec py.code.Source("""
def recvNamed(self, atom, args, namedArgs):
%s
%s
rv = self.mirandaMethods(atom, args, namedArgs)
if rv is None:
raise Refused(self, atom, args)
else:
return rv
""" % (";".join(imports), "\n".join(dispatchClauses))).compile() in execNames
recvNamed = execNames["recvNamed"]
# This is the place for fixing the "too many constants" JIT
# translation error. If there's too many dispatch clauses in
# .recvNamed(), then the JIT transformation fails because too many
# constant values are being mixed in. This number is determined
# empirically; uncomment the next line to take measurements:
# print "Made %d dispatch clauses for %r" % (len(dispatchClauses), cls)
# Here's a worksheet. Please keep it up-to-date when altering this
# section of code. ~ C.
# * At last run, the longest working list of clauses had length 40
# * And the shortest list which broke translation had length 46
# * Assuming that each clause has a constant integral number of
# constants, the number of constants per clause is 6
# * The maximum number of allowed constants is 255
# * Therefore, the longest working list can have maximum length 42
if len(dispatchClauses) >= 42:
# Too many constants; forbid the JIT from recursing into us.
recvNamed = dont_look_inside(recvNamed)
cls.recvNamed = recvNamed
return atoms
from rpython.rtyper.lltypesystem.lltype import nullptr
from rpython.rtyper.lltypesystem.rffi import getintfield
from typhon import ruv
from typhon.atoms import getAtom
from typhon.autohelp import autohelp
from typhon.errors import Refused
from typhon.objects.collections.lists import ConstList
from typhon.objects.data import (bytesToString, unwrapBytes, BytesObject,
StrObject)
from typhon.objects.refs import LocalResolver, makePromise
from typhon.objects.root import Object, runnable
from typhon.vats import currentVat, scopedVat
GETADDRESS_0 = getAtom(u"getAddress", 0)
GETFAMILY_0 = getAtom(u"getFamily", 0)
GETSOCKETTYPE_0 = getAtom(u"getSocketType", 0)
RUN_2 = getAtom(u"run", 2)
socktypes = {
s.SOCK_DGRAM: u"datagram",
s.SOCK_RAW: u"raw",
s.SOCK_RDM: u"reliable datagram",
s.SOCK_SEQPACKET: u"packet",
s.SOCK_STREAM: u"stream",
}
class AddrInfo(Object):
from typhon import ruv
from typhon.atoms import getAtom
from typhon.autohelp import autohelp, method
from typhon.objects.files import FileFount, FileDrain
from typhon.objects.networking.streams import StreamDrain, StreamFount
from typhon.objects.networking.streamcaps import (FileSink, FileSource,
StreamSink, StreamSource)
from typhon.objects.root import Object, runnable
from typhon.vats import currentVat
RUN_0 = getAtom(u"run", 0)
@runnable(RUN_0)
def makeStdIn():
vat = currentVat.get()
uv_loop = vat.uv_loop
stdinKind = ruv.guess_handle(0)
if stdinKind == ruv.HANDLE_TTY:
stdin = ruv.alloc_tty(uv_loop, 0, True)
return StreamFount(ruv.rffi.cast(ruv.stream_tp, stdin), vat)
else:
return FileFount(ruv.alloc_fs(), 0, vat)
@runnable(RUN_0)
def makeStdOut():
vat = currentVat.get()
uv_loop = vat.uv_loop
stdoutKind = ruv.guess_handle(1)
from rpython.rlib.rarithmetic import intmask
from rpython.rtyper.lltypesystem.lltype import scoped_alloc
from rpython.rtyper.lltypesystem.rffi import charpsize2str, INTP
from typhon import ruv
from typhon.atoms import getAtom
from typhon.autohelp import autohelp, method
from typhon.errors import userError
from typhon.objects.constants import NullObject
from typhon.objects.data import BytesObject, StrObject
from typhon.objects.refs import makePromise
from typhon.objects.signals import SignalHandle
from typhon.objects.root import Object
from typhon.vats import scopedVat
ABORT_1 = getAtom(u"abort", 1)
COMPLETE_0 = getAtom(u"complete", 0)
RUN_1 = getAtom(u"run", 1)
@autohelp
class _NullSink(Object):
"""
A sink which does nothing.
"""
@method("Void", "Any")
def run(self, _):
pass
@method("Void")
def complete(self):
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from typhon.atoms import getAtom
from typhon.autohelp import autohelp
from typhon.errors import Refused, userError
from typhon.objects.collections.lists import ConstList
from typhon.objects.constants import NullObject
from typhon.objects.data import StrObject
from typhon.objects.root import Object, audited
_UNCALL_0 = getAtom(u"_uncall", 0)
GET_0 = getAtom(u"get", 0)
GETGUARD_0 = getAtom(u"getGuard", 0)
PUT_1 = getAtom(u"put", 1)
@autohelp
@audited.Transparent
class Binding(Object):
"""
A slot and a guard describing the nature of the slot.
"""
_immutable_ = True
def __init__(self, slot, guard):
from rpython.rlib.objectmodel import specialize
from typhon.atoms import getAtom
from typhon.env import Environment
from typhon.errors import Ejecting, UserException, userError
from typhon.objects.collections.lists import unwrapList
from typhon.objects.collections.maps import ConstMap, monteMap, unwrapMap
from typhon.objects.constants import NullObject, unwrapBool
from typhon.objects.data import StrObject
from typhon.objects.ejectors import Ejector, theThrower, throw
from typhon.objects.exceptions import sealException
from typhon.objects.guards import anyGuard
from typhon.objects.slots import finalBinding, varBinding
from typhon.smallcaps import ops
GET_0 = getAtom(u"get", 0)
PUT_1 = getAtom(u"put", 1)
def mkMirandaArgs():
# XXX monteMap()
_d = monteMap()
_d[StrObject(u"FAIL")] = theThrower
return ConstMap(_d)
MIRANDA_ARGS = mkMirandaArgs()
class SmallCaps(object):
"""
from typhon.atoms import getAtom
from typhon.errors import userError
from typhon.vats import currentVat
from typhon.objects.collections.lists import wrapList
from typhon.objects.collections.maps import EMPTY_MAP
from typhon.objects.data import NullObject, StrObject
from typhon.objects.equality import EQUAL, TraversalKey, optSame, isSameEver
from typhon.objects.guards import anyGuard
from typhon.objects.refs import (EVENTUAL, NEAR, Promise, UnconnectedRef,
isResolved, resolution)
from typhon.objects.root import audited
from typhon.objects.slots import FinalSlot
HANDLESEND_3 = getAtom(u"handleSend", 3)
HANDLESENDONLY_3 = getAtom(u"handleSendOnly", 3)
RUN_3 = getAtom(u"run", 3)
def send(ref, atom, args, namedArgs):
if isinstance(ref, Promise):
return ref.sendAll(atom, args, namedArgs)
else:
vat = currentVat.get()
return vat.send(ref, atom, args, namedArgs)
def sendOnly(ref, atom, args, namedArgs):
if isinstance(ref, Promise):
ref.sendAllOnly(atom, args, namedArgs)
else:
vat = currentVat.get()
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from rpython.rlib.jit import promote, unroll_safe
from rpython.rlib.objectmodel import always_inline
from typhon.atoms import getAtom
from typhon.objects.auditors import deepFrozenGuard, deepFrozenStamp
from typhon.objects.data import StrObject
from typhon.objects.guards import anyGuard
from typhon.objects.slots import Binding, finalBinding, VarSlot
GET_0 = getAtom(u"get", 0)
PUT_1 = getAtom(u"put", 1)
@always_inline
def bindingToSlot(binding):
if isinstance(binding, Binding):
return binding.get()
from typhon.objects.collections.maps import EMPTY_MAP
return binding.callAtom(GET_0, [], EMPTY_MAP)
@always_inline
def bindingToValue(binding):
from typhon.objects.collections.maps import EMPTY_MAP
if isinstance(binding, Binding):
def testRepr(self):
atom = getAtom(u"test", 5)
self.assertEqual(repr(atom), u"Atom(test/5)")
from rpython.rtyper.lltypesystem.lltype import scoped_alloc
from rpython.rtyper.lltypesystem.rffi import charpsize2str
from typhon import log, rsodium, ruv
from typhon.atoms import getAtom
from typhon.autohelp import autohelp, method
from typhon.enum import makeEnum
from typhon.errors import userError
from typhon.objects.constants import NullObject
from typhon.objects.data import BytesObject, StrObject, unwrapStr
from typhon.objects.refs import LocalResolver, makePromise
from typhon.objects.root import Object, runnable
from typhon.vats import currentVat, scopedVat
ABORTFLOW_0 = getAtom(u"abortFlow", 0)
FLOWABORTED_1 = getAtom(u"flowAborted", 1)
FLOWSTOPPED_1 = getAtom(u"flowStopped", 1)
RECEIVE_1 = getAtom(u"receive", 1)
RUN_1 = getAtom(u"run", 1)
@autohelp
class FileUnpauser(Object):
"""
A pause on a file fount.
"""
def __init__(self, fount):
self.fount = fount
# License for the specific language governing permissions and limitations
# under the License.
import inspect
from rpython.rlib import rgc
from rpython.rlib.unroll import unrolling_iterable
from rpython.rlib.jit import jit_debug, promote, unroll_safe
from rpython.rlib.objectmodel import compute_identity_hash, specialize
from rpython.rlib.rstackovf import StackOverflow, check_stack_overflow
from typhon.atoms import getAtom
from typhon.errors import Refused, UserException, userError
from typhon.profile import profileTyphon
RUN_1 = getAtom(u"run", 1)
_CONFORMTO_1 = getAtom(u"_conformTo", 1)
_GETALLEGEDINTERFACE_0 = getAtom(u"_getAllegedInterface", 0)
_PRINTON_1 = getAtom(u"_printOn", 1)
_RESPONDSTO_2 = getAtom(u"_respondsTo", 2)
_SEALEDDISPATCH_1 = getAtom(u"_sealedDispatch", 1)
_UNCALL_0 = getAtom(u"_uncall", 0)
_WHENMORERESOLVED_1 = getAtom(u"_whenMoreResolved", 1)
mirandaAtoms = [
_CONFORMTO_1,
_GETALLEGEDINTERFACE_0,
_PRINTON_1,
_RESPONDSTO_2,
_SEALEDDISPATCH_1,
_UNCALL_0,
# under the License.
import inspect
from rpython.rlib import rgc
from rpython.rlib.unroll import unrolling_iterable
from rpython.rlib.jit import jit_debug, promote, unroll_safe
from rpython.rlib.objectmodel import compute_identity_hash, specialize
from rpython.rlib.rstackovf import StackOverflow, check_stack_overflow
from typhon.atoms import getAtom
from typhon.errors import Refused, UserException, userError
from typhon.profile import profileTyphon
RUN_1 = getAtom(u"run", 1)
_CONFORMTO_1 = getAtom(u"_conformTo", 1)
_GETALLEGEDINTERFACE_0 = getAtom(u"_getAllegedInterface", 0)
_PRINTON_1 = getAtom(u"_printOn", 1)
_RESPONDSTO_2 = getAtom(u"_respondsTo", 2)
_SEALEDDISPATCH_1 = getAtom(u"_sealedDispatch", 1)
_UNCALL_0 = getAtom(u"_uncall", 0)
_WHENMORERESOLVED_1 = getAtom(u"_whenMoreResolved", 1)
def makeMirandaArgs():
from typhon.objects.collections.maps import monteMap
from typhon.objects.data import StrObject
from typhon.objects.ejectors import theThrower
# XXX monteMap()
"""
Some cryptographic services.
"""
from rpython.rlib.rarithmetic import intmask
from typhon import log, rsodium
from typhon.atoms import getAtom
from typhon.autohelp import autohelp
from typhon.errors import Refused, WrongType, userError
from typhon.objects.collections.lists import ConstList
from typhon.objects.data import (BytesObject, IntObject, StrObject,
unwrapBytes)
from typhon.objects.root import Object
ASBYTES_0 = getAtom(u"asBytes", 0)
FROMBYTES_1 = getAtom(u"fromBytes", 1)
FROMPUBLICBYTES_1 = getAtom(u"fromPublicBytes", 1)
FROMSECRETBYTES_1 = getAtom(u"fromSecretBytes", 1)
GETALGORITHM_0 = getAtom(u"getAlgorithm", 0)
GETENTROPY_0 = getAtom(u"getEntropy", 0)
KEYMAKER_0 = getAtom(u"keyMaker", 0)
MAKESECUREENTROPY_0 = getAtom(u"makeSecureEntropy", 0)
PAIRWITH_1 = getAtom(u"pairWith", 1)
PUBLICKEY_0 = getAtom(u"publicKey", 0)
RUN_0 = getAtom(u"run", 0)
SEAL_1 = getAtom(u"seal", 1)
UNSEAL_2 = getAtom(u"unseal", 2)
@autohelp
def callAtom(self, atom, arguments, namedArgsMap):
"""
This method is used to reuse atoms without having to rebuild them.
"""
from typhon.objects.collections.maps import EMPTY_MAP
# Promote the atom, on the basis that atoms are generally reused.
atom = promote(atom)
# Log the atom to the JIT log. Don't do this if the atom's not
# promoted; it'll be slow.
jit_debug(atom.repr)
try:
return self.recvNamed(atom, arguments, namedArgsMap)
except Refused as r:
# This block of method implementations is Typhon's Miranda
# protocol. ~ C.
if atom is _CONFORMTO_1:
# Welcome to _conformTo/1.
# to _conformTo(_): return self
return self
if atom is _GETALLEGEDINTERFACE_0:
# Welcome to _getAllegedInterface/0.
interface = self.optInterface()
if interface is None:
from typhon.objects.interfaces import ComputedInterface
interface = ComputedInterface(self)
return interface
if atom is _PRINTON_1:
# Welcome to _printOn/1.
from typhon.objects.constants import NullObject
self.printOn(arguments[0])
return NullObject
if atom is _RESPONDSTO_2:
from typhon.objects.constants import wrapBool
from typhon.objects.data import unwrapInt, unwrapStr
verb = unwrapStr(arguments[0])
arity = unwrapInt(arguments[1])
atom = getAtom(verb, arity)
result = (atom in self.respondingAtoms()
or atom in mirandaAtoms)
return wrapBool(result)
if atom is _SEALEDDISPATCH_1:
# to _sealedDispatch(_): return null
from typhon.objects.constants import NullObject
return NullObject
if atom is _UNCALL_0:
from typhon.objects.constants import NullObject
return NullObject
if atom is _WHENMORERESOLVED_1:
# Welcome to _whenMoreResolved.
# This method's implementation, in Monte, should be:
# to _whenMoreResolved(callback): callback<-(self)
from typhon.vats import currentVat
vat = currentVat.get()
vat.sendOnly(arguments[0], RUN_1, [self], EMPTY_MAP)
from typhon.objects.constants import NullObject
return NullObject
addTrail(r, self, atom, arguments)
raise
except UserException as ue:
addTrail(ue, self, atom, arguments)
raise
except MemoryError:
ue = userError(u"Memory corruption or exhausted heap")
addTrail(ue, self, atom, arguments)
raise ue
except StackOverflow:
check_stack_overflow()
ue = userError(u"Stack overflow")
addTrail(ue, self, atom, arguments)
raise ue
from rpython.rlib.rstring import StringBuilder, UnicodeBuilder, replace, split from rpython.rlib.rstruct.ieee import pack_float from rpython.rlib.unicodedata import unicodedb_6_2_0 as unicodedb from typhon.atoms import getAtom from typhon.autohelp import autohelp from typhon.errors import Refused, WrongType, userError from typhon.objects.auditors import deepFrozenStamp from typhon.objects.comparison import Incomparable from typhon.objects.constants import NullObject, unwrapBool, wrapBool from typhon.objects.root import Object, audited, runnable from typhon.prelude import getGlobalValue from typhon.quoting import quoteChar, quoteStr ABOVEZERO_0 = getAtom(u"aboveZero", 0) ABS_0 = getAtom(u"abs", 0) ADD_1 = getAtom(u"add", 1) AND_1 = getAtom(u"and", 1) APPROXDIVIDE_1 = getAtom(u"approxDivide", 1) ASINTEGER_0 = getAtom(u"asInteger", 0) ASLIST_0 = getAtom(u"asList", 0) ASSET_0 = getAtom(u"asSet", 0) ASSTRING_0 = getAtom(u"asString", 0) ATLEASTZERO_0 = getAtom(u"atLeastZero", 0) ATMOSTZERO_0 = getAtom(u"atMostZero", 0) BELOWZERO_0 = getAtom(u"belowZero", 0) BITLENGTH_0 = getAtom(u"bitLength", 0) COMBINE_1 = getAtom(u"combine", 1) COMPLEMENT_0 = getAtom(u"complement", 0) CONTAINS_1 = getAtom(u"contains", 1)
import py
from rpython.rlib.rbigint import BASE10, rbigint
from typhon import nodes
from typhon.atoms import getAtom
from typhon.autohelp import autoguard, autohelp, method
from typhon.errors import userError
from typhon.nanopass import makeIR
from typhon.objects.constants import NullObject
from typhon.objects.data import SourceSpan
from typhon.objects.root import Object, audited
from typhon.quoting import quoteChar, quoteStr
from typhon.objects.collections.lists import ConstList
GETSTARTLINE_0 = getAtom(u"getStartLine", 0)
def saveScripts(ast):
ast = SanityCheck().visitExpr(ast)
ast = SaveScripts().visitExpr(ast)
return ast
MastIR = makeIR("Mast",
["Noun"],
{
"Expr": {
"NullExpr": [],
"CharExpr": [("c", None)],
"DoubleExpr": [("d", None)],
"IntExpr": [("i", None)],
"StrExpr": [("s", None)],
from typhon.errors import Ejecting, Refused, UserException, userError
from typhon.log import log
from typhon.objects.auditors import deepFrozenStamp
from typhon.objects.constants import NullObject, unwrapBool, wrapBool
from typhon.objects.collections.lists import ConstList
from typhon.objects.data import StrObject, unwrapStr
from typhon.objects.ejectors import Ejector
from typhon.objects.guards import anyGuard
from typhon.objects.printers import Printer
from typhon.objects.root import Object
from typhon.objects.slots import finalBinding
from typhon.smallcaps.machine import SmallCaps
# XXX AuditionStamp, Audition guard
ASK_1 = getAtom(u"ask", 1)
GETGUARD_1 = getAtom(u"getGuard", 1)
GETOBJECTEXPR_0 = getAtom(u"getObjectExpr", 0)
GETFQN_0 = getAtom(u"getFQN", 0)
pemci = u".".join([
u"lo lebna cu rivbi",
u"lo nu fi ri facki",
u"fa le vi larmuzga",
u"fe le zi ca du'u",
u"le lebna pu jbera",
u"lo catlu pe ro da",
])
def boolStr(b):
from typhon.atoms import getAtom
from typhon.autohelp import autohelp
from typhon.objects.auditors import deepFrozenStamp
from typhon.objects.collections.lists import wrapList
from typhon.objects.data import StrObject
from typhon.objects.ejectors import throwStr
from typhon.objects.root import Object, runnable
RUN_2 = getAtom(u"run", 2)
def sealException(ue):
val = ue.getPayload()
trail = ue.trail
if isinstance(val, SealedException):
return val
return SealedException(val, trail)
@autohelp
class SealedException(Object):
"""
An exception.
Sealed within this object are the details of an exceptional occurrence.
"""
def __init__(self, value, trail):
self.value = value
self.trail = trail
from rpython.rlib.rstring import StringBuilder, UnicodeBuilder, replace, split
from rpython.rlib.rstruct.ieee import float_pack
from rpython.rlib.unicodedata import unicodedb_6_2_0 as unicodedb
from typhon.atoms import getAtom
from typhon.autohelp import autohelp, method
from typhon.errors import WrongType, userError
from typhon.objects.auditors import deepFrozenStamp
from typhon.objects.comparison import Incomparable
from typhon.objects.constants import NullObject, unwrapBool, wrapBool
from typhon.objects.root import Object, audited, runnable
from typhon.spans import Span
from typhon.prelude import getGlobalValue
from typhon.quoting import quoteChar, quoteStr
RUN_6 = getAtom(u"run", 6)
@specialize.argtype(0, 1)
def cmp(l, r):
if l < r:
return -1
elif l > r:
return 1
else:
return 0
@specialize.argtype(0, 1)
def polyCmp(l, r):
if l < r:
from rpython.rlib.objectmodel import import_from_mixin from rpython.rlib.rarithmetic import intmask from typhon.atoms import getAtom from typhon.autohelp import autohelp from typhon.errors import Ejecting, Refused, UserException, userError from typhon.objects.collections.helpers import MonteSorter from typhon.objects.constants import NullObject, wrapBool from typhon.objects.data import IntObject, StrObject, unwrapInt from typhon.objects.ejectors import Ejector, throw from typhon.objects.printers import toString from typhon.objects.root import Object, audited from typhon.rstrategies import rstrategies from typhon.strategies import strategyFactory ADD_1 = getAtom(u"add", 1) ASMAP_0 = getAtom(u"asMap", 0) ASSET_0 = getAtom(u"asSet", 0) CONTAINS_1 = getAtom(u"contains", 1) DIVERGE_0 = getAtom(u"diverge", 0) EXTEND_1 = getAtom(u"extend", 1) GET_1 = getAtom(u"get", 1) INDEXOF_1 = getAtom(u"indexOf", 1) INDEXOF_2 = getAtom(u"indexOf", 2) INSERT_2 = getAtom(u"insert", 2) JOIN_1 = getAtom(u"join", 1) LAST_0 = getAtom(u"last", 0) MULTIPLY_1 = getAtom(u"multiply", 1) NEXT_1 = getAtom(u"next", 1) OP__CMP_1 = getAtom(u"op__cmp", 1) POP_0 = getAtom(u"pop", 0)
from rpython.rlib import rgc
from rpython.rlib.rerased import new_erasing_pair
# from typhon import ruv
from typhon.atoms import getAtom
from typhon.autohelp import autohelp
from typhon.errors import Refused
from typhon.objects.collections.lists import ConstList
from typhon.objects.collections.maps import ConstMap, monteMap
from typhon.objects.data import IntObject, StrObject
from typhon.objects.root import Object, runnable
from typhon.objects.user import ScriptObject
GETBUCKETS_0 = getAtom(u"getBuckets", 0)
GETCRYPT_0 = getAtom(u"getCrypt", 0)
GETDISASSEMBLER_0 = getAtom(u"getDisassembler", 0)
GETHANDLES_0 = getAtom(u"getHandles", 0)
GETHEAPSTATISTICS_0 = getAtom(u"getHeapStatistics", 0)
GETMEMORYUSAGE_0 = getAtom(u"getMemoryUsage", 0)
GETOBJECTCOUNT_0 = getAtom(u"getObjectCount", 0)
GETREACTORSTATISTICS_0 = getAtom(u"getReactorStatistics", 0)
# The fun of GC management. This is all very subject to change and only works
# with rpython 0.1.4 from PyPI. Sorry. ~ C.
def clear_gcflag_extra(fromlist):
pending = fromlist[:]
while pending:
gcref = pending.pop()
if rgc.get_gcflag_extra(gcref):
import weakref from typhon.atoms import getAtom from typhon.autohelp import autohelp from typhon.enum import makeEnum from typhon.errors import Refused, UserException, userError from typhon.log import log from typhon.objects.auditors import deepFrozenStamp, selfless from typhon.objects.constants import NullObject, unwrapBool, wrapBool from typhon.objects.data import StrObject from typhon.objects.root import Object, audited from typhon.vats import currentVat BROKEN, EVENTUAL, NEAR = makeEnum(u"RefState", u"broken eventual near".split()) BROKEN_1 = getAtom(u"broken", 1) FULFILLMENT_1 = getAtom(u"fulfillment", 1) ISBROKEN_1 = getAtom(u"isBroken", 1) ISDEEPFROZEN_1 = getAtom(u"isDeepFrozen", 1) ISEVENTUAL_1 = getAtom(u"isEventual", 1) ISFAR_1 = getAtom(u"isFar", 1) ISNEAR_1 = getAtom(u"isNear", 1) ISRESOLVED_1 = getAtom(u"isResolved", 1) ISSELFISH_1 = getAtom(u"isSelfish", 1) ISSELFLESS_1 = getAtom(u"isSelfless", 1) ISSETTLED_1 = getAtom(u"isSettled", 1) MAKEPROXY_3 = getAtom(u"makeProxy", 3) OPTPROBLEM_1 = getAtom(u"optProblem", 1) PROMISE_0 = getAtom(u"promise", 0) RESOLVE_1 = getAtom(u"resolve", 1) RESOLVE_2 = getAtom(u"resolve", 2)
def getAtom(self):
return getAtom(self._verb, len(self._ps))
from rpython.rlib.rarithmetic import intmask
from rpython.rtyper.lltypesystem.lltype import nullptr
from typhon import ruv
from typhon.atoms import getAtom
from typhon.autohelp import autohelp, method
from typhon.errors import userError
from typhon.objects.collections.maps import monteMap
from typhon.objects.data import BytesObject, StrObject, unwrapBytes
from typhon.objects.networking.streamcaps import (StreamSink, StreamSource,
emptySource, nullSink)
from typhon.objects.root import Object, audited
from typhon.objects.refs import makePromise
from typhon.vats import currentVat, scopedVat
FLOWTO_1 = getAtom(u"flowTo", 1)
RUN_3 = getAtom(u"run", 3)
@autohelp
class CurrentProcess(Object):
"""
The current process on the local node.
"""
def __init__(self, config):
self.config = config
def toString(self):
return u"<current process (PID %d)>" % os.getpid()
@method("List")
from typhon.atoms import getAtom
from typhon.autohelp import autohelp, method
from typhon.errors import UserException
from typhon.objects.auditors import (SealedPortrayal, deepFrozenStamp,
selfless, semitransparentStamp)
from typhon.objects.collections.helpers import asSet
from typhon.objects.collections.lists import wrapList
from typhon.objects.collections.maps import EMPTY_MAP
from typhon.objects.data import StrObject
from typhon.objects.ejectors import throwStr
from typhon.objects.root import Object, runnable
RUN_1 = getAtom(u"run", 1)
RUN_2 = getAtom(u"run", 2)
def sealException(ue):
val = ue.getPayload()
if isinstance(val, SealedException):
return val
else:
return SealedException(ue)
@autohelp
class SealedException(Object):
"""
An exception.
Sealed within this object are the details of an exceptional occurrence.
"""
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from typhon.atoms import getAtom
from typhon.autohelp import autohelp
from typhon.errors import Refused, userError
from typhon.objects.root import Object, audited
from typhon.prelude import getGlobalValue
AND_1 = getAtom(u"and", 1)
BUTNOT_1 = getAtom(u"butNot", 1)
NOT_0 = getAtom(u"not", 0)
OP__CMP_1 = getAtom(u"op__cmp", 1)
OR_1 = getAtom(u"or", 1)
PICK_2 = getAtom(u"pick", 2)
XOR_1 = getAtom(u"xor", 1)
@autohelp
@audited.DF
class _NullObject(Object):
"""
The null object.
"""
