def printOn(self, out):
out.call(u"print", [StrObject(self.repr().decode("utf-8"))])
def testHashInequal(self):
a = StrObject(u"acerbic")
b = StrObject(u"bitter")
self.assertNotEqual(a.hash(), b.hash())
def testLastIndexOfFail(self):
s = StrObject(u"needle")
result = s.call(u"lastIndexOf", [StrObject(u"x")])
self.assertEqual(result.getInt(), -1)
def testToLowerCaseUnicode(self):
s = StrObject(u"Α And Ω")
result = s.call(u"toLowerCase", [])
self.assertEqual(result._s, u"α and ω")
def testToUpperCaseUnicode(self):
s = StrObject(u"¡Holá!")
result = s.call(u"toUpperCase", [])
self.assertEqual(result._s, u"¡HOLÁ!")
def testJoin(self):
s = StrObject(u"|")
result = s.call(
u"join",
[ConstList([StrObject(u"5"), StrObject(u"42")])])
self.assertEqual(result._s, u"5|42")
def testSliceStartStop(self):
s = StrObject(u"the lime in the coconut")
result = s.call(u"slice", [IntObject(4), IntObject(8)])
self.assertEqual(result._s, u"lime")
def printOn(self, out):
out.call(u"print", [StrObject(u"Same")])
def printOn(self, out):
from typhon.objects.data import StrObject
out.call(u"print", [StrObject(u"SubrangeGuard")])
def printOn(self, out):
out.call(u"print", [StrObject(u"FinalSlot[")])
out.call(u"print", [self.valueGuard]),
out.call(u"print", [StrObject(u"]")])
def printOn(self, out):
out.call(u"print", [StrObject(u"Same[")])
out.call(u"print", [self.value])
out.call(u"print", [StrObject(u"]")])
def uncall(self):
return wrapList([StrObject(self._s)])
def printOn(self, out):
out.call(u"print", [StrObject(u"<makeLiteral>")])
def uncall(self):
return wrapList([
StrObject(self._d if self._d else u""), self._n,
self._as if self._as is not None else NullObject,
wrapList(self._implements), self._script
])
def recv(self, atom, args):
from typhon.objects.collections.lists import ConstList
# _makeIterator/0: Create an iterator for this collection's contents.
if atom is _MAKEITERATOR_0:
return self._makeIterator()
if atom is _PRINTON_1:
printer = args[0]
self.printOn(printer)
return NullObject
if atom is _UNCALL_0:
from typhon.objects.collections.maps import EMPTY_MAP
# [1,2,3].asSet() -> [[1,2,3], "asSet"]
rv = ConstList(self.objectSet.keys())
return ConstList(
[rv, StrObject(u"asSet"),
ConstList([]), EMPTY_MAP])
# contains/1: Determine whether an element is in this collection.
if atom is CONTAINS_1:
return wrapBool(self.contains(args[0]))
# size/0: Get the number of elements in the collection.
if atom is SIZE_0:
return IntObject(self.size())
# slice/1 and slice/2: Select a subrange of this collection.
if atom is SLICE_1:
start = unwrapInt(args[0])
try:
return self.slice(start)
except IndexError:
raise userError(u"slice/1: Index out of bounds")
# slice/1 and slice/2: Select a subrange of this collection.
if atom is SLICE_2:
start = unwrapInt(args[0])
stop = unwrapInt(args[1])
try:
return self.slice(start, stop)
except IndexError:
raise userError(u"slice/1: Index out of bounds")
# snapshot/0: Create a new constant collection with a copy of the
# current collection's contents.
if atom is SNAPSHOT_0:
return self.snapshot()
if atom is ASSET_0:
return self
if atom is DIVERGE_0:
_flexSet = getGlobal(u"_flexSet").getValue()
return _flexSet.call(u"run", [self])
if atom is AND_1:
return self._and(args[0])
# or/1: Unify the elements of this collection with another.
if atom is OR_1:
return self._or(args[0])
# XXX Decide if we follow python-style '-' or E-style '&!' here.
if atom is SUBTRACT_1:
return self.subtract(args[0])
if atom is ASLIST_0:
return ConstList(self.objectSet.keys())
if atom is BUTNOT_1:
return self.subtract(args[0])
if atom is WITH_1:
key = args[0]
d = self.objectSet.copy()
d[key] = None
return ConstSet(d)
if atom is WITHOUT_1:
key = args[0]
d = self.objectSet.copy()
# Ignore the case where the key wasn't in the map.
if key in d:
del d[key]
return ConstSet(d)
if atom is INCLUDE_1:
key = args[0]
self.include(key)
return NullObject
if atom is REMOVE_1:
key = args[0]
self.remove(key)
return NullObject
if atom is POP_0:
return self.pop()
raise Refused(self, atom, args)
def printOn(self, out):
from typhon.objects.data import StrObject
out.call(u"print", [subrangeGuardMaker])
out.call(u"print", [StrObject(u"[")])
out.call(u"print", [self.superGuard])
out.call(u"print", [StrObject(u"]")])
def testGetOutOfBounds(self):
s = StrObject(u"index")
self.assertRaises(UserException, s.call, u"get", [IntObject(6)])
def recv(self, atom, args):
from typhon.nodes import Noun, Method, Obj
from typhon.objects.equality import optSame, EQUAL
from typhon.objects.user import Audition
if atom is _UNCALL_0:
from typhon.objects.collections.maps import EMPTY_MAP
return ConstList([
subrangeGuardMaker,
StrObject(u"get"),
ConstList([self.superGuard]), EMPTY_MAP
])
if atom is AUDIT_1:
audition = args[0]
if not isinstance(audition, Audition):
raise userError(u"not invoked with an Audition")
ast = audition.ast
if not isinstance(ast, Obj):
raise userError(u"audition not created with an object expr")
methods = ast._script._methods
for m in methods:
if isinstance(m, Method) and m._verb == u"coerce":
mguard = m._g
if isinstance(mguard, Noun):
rGSG = audition.getGuard(mguard.name)
if isinstance(rGSG, FinalSlotGuard):
rGSG0 = rGSG.valueGuard
if isinstance(rGSG0, SameGuard):
resultGuard = rGSG0.value
if (optSame(resultGuard,
self.superGuard) is EQUAL or
(SUPERSETOF_1
in self.superGuard.respondingAtoms()
and self.superGuard.call(
u"supersetOf",
[resultGuard]) is wrapBool(True))):
return wrapBool(True)
raise userError(
u"%s does not have a result guard implying "
u"%s, but %s" %
(audition.fqn, self.superGuard.toQuote(),
resultGuard.toQuote()))
raise userError(
u"%s does not have a determinable "
u"result guard, but <& %s> :%s" %
(audition.fqn, mguard.name, rGSG.toQuote()))
break
return self
if atom is PASSES_1:
return wrapBool(args[0].auditedBy(self))
if atom is COERCE_2:
specimen, ej = args[0], args[1]
if specimen.auditedBy(self):
return specimen
c = specimen.call(u"_conformTo", [self])
if c.auditedBy(self):
return c
throw(
ej,
StrObject(u"%s does not conform to %s" %
(specimen.toQuote(), self.toQuote())))
raise Refused(self, atom, args)
def testSliceStart(self):
s = StrObject(u"slice of lemon")
result = s.call(u"slice", [IntObject(9)])
self.assertEqual(result._s, u"lemon")
def _uncall(self):
from typhon.objects.collections.lists import wrapList
from typhon.objects.collections.maps import EMPTY_MAP
# [1,2,3].asSet() -> [[1,2,3], "asSet"]
rv = wrapList(self.objectSet.keys())
return [rv, StrObject(u"asSet"), wrapList([]), EMPTY_MAP]
def testSliceStartNegative(self):
s = StrObject(u"nope")
self.assertRaises(UserException, s.call, u"slice", [IntObject(-2)])
def unboxUnconnectedRef(value):
assert isinstance(value, UnconnectedRef), "Implementation detail"
return value._problem
unboxedStrategies = [
makeUnboxedListStrategy(cls, box, unbox, exemplar)
for (cls, box, unbox, exemplar) in [
# Bools.
(BoolObject, wrapBool, unwrapBool, FalseObject),
# Chars.
(CharObject, CharObject, unwrapChar, CharObject(u'▲')),
# Small ints.
(IntObject, IntObject, unwrapInt, IntObject(42)),
# Unicode strings.
(StrObject, StrObject, unwrapStr, StrObject(u"▲")),
# Bytestrings.
(BytesObject, BytesObject, unwrapBytes, BytesObject("M")),
# _booleanFlow-generated lists of unconnected refs.
(UnconnectedRef, UnconnectedRef, unboxUnconnectedRef,
UnconnectedRef(StrObject(u"Implementation detail leaked"))),
]
]
@rstrategies.strategy(generalize=[NullListStrategy] + unboxedStrategies +
[GenericListStrategy])
class EmptyListStrategy(Strategy):
"""
A list with no elements.
"""
def testToUpperCase(self):
s = StrObject(u"lower")
result = s.call(u"toUpperCase", [])
self.assertEqual(result._s, u"LOWER")
def fireString(self, message):
return self.fire(StrObject(message))
def testHashEqual(self):
a = StrObject(u"acidic")
b = StrObject(u"acidic")
self.assertEqual(a.hash(), b.hash())
def visitStrExpr(self, s, span):
return self.dest.LiveExpr(StrObject(s), span)
def testIndexOf(self):
s = StrObject(u"needle")
result = s.call(u"indexOf", [StrObject(u"e")])
self.assertEqual(result.getInt(), 1)
def runTyphon(argv):
recorder = Recorder()
recorder.start()
# Initialize libsodium.
if rsodium.init() < 0:
print "Couldn't initialize libsodium!"
return 1
config = Configuration(argv)
if config.verbose:
enableDebugPrint()
config.enableLogging()
if len(config.argv) < 2:
print "No file provided?"
return 1
# Pass user configuration to the JIT.
set_user_param(None, config.jit)
# Intialize our loop.
uv_loop = ruv.alloc_loop()
# Usurp SIGPIPE, as libuv does not handle it.
rsignal.pypysig_ignore(rsignal.SIGPIPE)
# Initialize our first vat. It shall be immortal.
vatManager = VatManager()
vat = Vat(vatManager, uv_loop, checkpoints=-1)
vatManager.vats.append(vat)
# Update loop timing information. Until the loop really gets going, we
# have to do this ourselves in order to get the timing correct for early
# timers.
ruv.update_time(uv_loop)
try:
with scopedVat(vat) as vat:
prelude = loadPrelude(config, recorder, vat)
except LoadFailed as lf:
print lf
return 1
registerGlobals(prelude)
scope = safeScope()
scope.update(prelude)
ss = scope.copy()
reflectedSS = monteMap()
for k, b in ss.iteritems():
reflectedSS[StrObject(u"&&" + k)] = b
ss[u"safeScope"] = finalBinding(ConstMap(reflectedSS), deepFrozenGuard)
reflectedSS[StrObject(u"&&safeScope")] = ss[u"safeScope"]
scope[u"safeScope"] = ss[u"safeScope"]
scope.update(unsafeScope(config))
reflectedUnsafeScope = monteMap()
unsafeScopeDict = {}
for k, b in scope.iteritems():
reflectedUnsafeScope[StrObject(u"&&" + k)] = b
unsafeScopeDict[k] = b
rus = finalBinding(ConstMap(reflectedUnsafeScope), anyGuard)
reflectedUnsafeScope[StrObject(u"&&unsafeScope")] = rus
unsafeScopeDict[u"unsafeScope"] = rus
try:
code = obtainModule([""], config.argv[1], recorder)
except LoadFailed as lf:
print lf
return 1
if config.loadOnly:
# We are finished.
return 0
if not config.benchmark:
benchmarkSettings.disable()
with profiling("vmprof.log", config.profile):
# Update loop timing information.
ruv.update_time(uv_loop)
debug_print("Taking initial turn in script...")
result = NullObject
with recorder.context("Time spent in vats"):
with scopedVat(vat):
result = evaluateTerms([code], unsafeScopeDict)
if result is None:
return 1
# Exit status code.
exitStatus = 0
# Update loop timing information.
ruv.update_time(uv_loop)
try:
runUntilDone(vatManager, uv_loop, recorder)
rv = resolution(result) if result is not None else NullObject
if isinstance(rv, IntObject):
exitStatus = rv.getInt()
except SystemExit:
pass
# Huh, apparently this doesn't work. Wonder why/why not.
# exitStatus = se.code
finally:
recorder.stop()
recorder.printResults()
# Clean up and exit.
cleanUpEverything()
return exitStatus
def testTrimEmpty(self):
s = StrObject(u"")
result = s.call(u"trim", [])
self.assertEqual(result._s, u"")
def printOn(self, printer):
# Note that the printer is a Monte-level object. Also note that, at
# this point, we have had a bad day; we did not respond to _printOn/1.
from typhon.objects.data import StrObject
printer.call(u"print",
[StrObject(u"<%s>" % self.codeScript.displayName)])
