Mailman 3 July 2003 - pypy-dev

builtin refactoring branch
by holger krekel July 12, 2003

July 12, 2003

Hello PyPy, in the last days i experimentally tried some approaches to "fixing" problems regarding the crossing of app-level/interpreter-level boundary. While Armin already posted how we'd probably like to have the situation (easily intermingling app-level and interpreter-level without _app files) there are some concepts to clarify. I think it makes sense to try to clarify the issues by focusing on "builtins" first because they imply interesting cases: - interpreter-level functions are … [View More]

2 1

type problems
by Michael Hudson July 11, 2003

July 11, 2003

I wrote this on the train yesterday. Some of it is a bit out of date from talking on IRC today, but not all of it. A tip for making the multimethod implementation more comprehensible: separate finding the method to call from calling it. Also, consistently using common lisp terminology would help *me*, if no-one else. And, finally, presuming that the implementation isn't going to change drastically another four or five times, documentation would be good! As Samuele and Armin are … [View More]

4 8

specfic questions for getting into the code for first time
by Hunter Peress July 11, 2003

July 11, 2003

I ran pypy -S the first time two days ago. before, i had been lurking on the mailing lists and irc channel. I was met with extreme apathy and active negativity and downright avoidance yesterday in the irc. It should be evident that I am a kind and extroverted person that wants to help the project. over 4 hours of repeating questions on irc, i was able to glean just a little bit of information. Here are my questions: Specific example: could someone kindly explain how you can tell that … [View More]

2 1

Re: Greetings
by Jonathan David Riehl July 10, 2003

July 10, 2003

On Wed, 2 Jul 2003, holger krekel wrote: > In this doc-directory (http://codespeak.net/pypy/doc) you'll also find some > unsorted documentation which might help in understanding what we have been > doing this year. Still trying to decode the docs, but the RPython stuff is starting to look familiar (I was going to something similar). I know Chris mentioned working on a pure-Python compiler (one that didn't use sre), but if anyone has a good starting point in mind, please let me know. … [View More]

3 2

Application-level helpers
by Armin Rigo July 9, 2003

July 9, 2003

Hello everybody, Holger came up with a nice idea about application-level helpers, which he experimented on an svn branch: http://codespeak.net/svn/pypy/branch/pypy-noappfile/pypy/ The idea is already a few days old and I promized to write about it earlier, but I'm a bit busy until tomorrow so I'll keep it short :-) Holger clarified the role and definition of what is currently found in the _app.py files. We are trying to do several things at once there, and it is true that we often … [View More]only need a convenient way to write code without constantly wrapping and unwrapping objects. The plan is to be able to just write plain Python functions in the code, and call them "at application-level". There should be no need for the functions to be in a separate _app file if it is clear that it is application-level. For example, dictobject.py currently contains the magic code: def dict_update__Dict_Dict(space, w_self, w_other): w_self.space.gethelper(applicationfile).call("dict_update", [w_self, w_other]) Instead it could directly contain: def app_dict_update(d,o): for k in o.keys(): d[k] = o[k] dict_update__Dict_Dict = appfunction(app_dict_update) This means that app_dict_update() is a helper function that you write at application-level (hence the app_ prefix), whereas dict_update__Dict_Dict is a wrapper around it that you can call from interpreter-level with an extra "space" first argument. The change seems to be minor, but consider that helpers would now be together with the place they really belong to. They could be used directly as methods in classes, too. In short they make the bridge between interpreter-level and application-level code much smaller. The application-level code can also be allowed to call not only other application-level code, but interpreter-level one, all transparently (because they essentially live in the same globals). This clarification also means that it is an independent issue to know what we should write by strictly sticking to RPython or not. Application-level code is essentially just a way to avoid wraps. All interpreter-level code should be in RPython, but then some application-level code could be easy enough for the analyzer to understand too. If they are, the code generator can make efficient code from them too (cool!), i.e. it would not matter if the code was defined at interpreter-level or application-level. For very complex helpers, there is always the option to fall back to emitting frozen bytecode and interpreting it. I believe that this also clarifies some of the issues about the AnnotationObjSpace. More about it later... A bientôt, Armin. [View Less]

5 4

XRange Object [Fixed Patch]
by Moshe Zadka July 8, 2003

July 8, 2003

OK, I fixed the problem of not registering in the builtins, and now moshez@green:~/devel/pypy/src/pypy$ python2.2 interpreter/py.py -S Python 2.2.2 (#1, Nov 21 2002, 08:18:14) [GCC 2.95.4 20011002 (Debian prerelease)] in pypy PyPyConsole / StdObjSpace >>> for i in xrange(0,1,1): ... print i ... 0 [Though, this being my first playing around with PyPy, I must say I was a bit taken aback by just how slow it is :)] Diff still vs. 1116 Thanks and sorry for the slight spamming, … [View More]Moshe diff -urN -x.svn -x'*.pyc' src.old/pypy/objspace/std/objspace.py src/pypy/objspace/std/objspace.py --- src.old/pypy/objspace/std/objspace.py 2003-07-08 08:36:48.000000000 +0000 +++ src/pypy/objspace/std/objspace.py 2003-07-08 08:53:16.000000000 +0000 @@ -67,6 +67,7 @@ from stringtype import W_StringType from typetype import W_TypeType from slicetype import W_SliceType + from xrangetype import W_XRangeType return [value for key, value in result.__dict__.items() if not key.startswith('_')] # don't look @@ -260,6 +261,11 @@ import moduleobject return moduleobject.W_ModuleObject(self, w_name) + def newxrange(self, w_start, w_end, w_step): + # w_step may be a real None + import xrangeobject + return xrangeobject.W_XRangeObject(self, w_start, w_end, w_step) + def newstring(self, chars_w): try: chars = [chr(self.unwrap(w_c)) for w_c in chars_w] diff -urN -x.svn -x'*.pyc' src.old/pypy/objspace/std/test/test_xrangeobject.py src/pypy/objspace/std/test/test_xrangeobject.py --- src.old/pypy/objspace/std/test/test_xrangeobject.py 1970-01-01 00:00:00.000000000 +0000 +++ src/pypy/objspace/std/test/test_xrangeobject.py 2003-07-08 08:35:28.000000000 +0000 @@ -0,0 +1,70 @@ +import autopath +from pypy.objspace.std.xrangeobject import W_XRangeObject +from pypy.objspace.std.intobject import W_IntObject +from pypy.objspace.std.objspace import NoValue +from pypy.tool import test + +class TestW_XRangeObject(test.TestCase): + + def setUp(self): + self.space = test.objspace('std') + + def tearDown(self): + pass + + def test_is_true(self): + w = self.space.wrap + w_range = W_XRangeObject(self.space, w(0), w(0), w(1)) + self.assertEqual(self.space.is_true(w_range), False) + w_range = W_XRangeObject(self.space, w(0), w(1), w(1)) + self.assertEqual(self.space.is_true(w_range), True) + w_range = W_XRangeObject(self.space, w(0), w(5), w(1)) + self.assertEqual(self.space.is_true(w_range), True) + + def test_len(self): + w = self.space.wrap + w_range = W_XRangeObject(self.space, w(0), w(0), w(1)) + self.assertEqual_w(self.space.len(w_range), w(0)) + w_range = W_XRangeObject(self.space, w(0), w(1), w(1)) + self.assertEqual_w(self.space.len(w_range), w(1)) + w_range = W_XRangeObject(self.space, w(0), w(5), w(1)) + self.assertEqual_w(self.space.len(w_range), w(5)) + + def test_getitem(self): + w = self.space.wrap + w_range = W_XRangeObject(self.space, w(0), w(2), w(1)) + self.assertEqual_w(self.space.getitem(w_range, w(0)), w(0)) + self.assertEqual_w(self.space.getitem(w_range, w(1)), w(1)) + self.assertEqual_w(self.space.getitem(w_range, w(-2)), w(0)) + self.assertEqual_w(self.space.getitem(w_range, w(-1)), w(1)) + self.assertRaises_w(self.space.w_IndexError, + self.space.getitem, w_range, w(2)) + self.assertRaises_w(self.space.w_IndexError, + self.space.getitem, w_range, w(42)) + self.assertRaises_w(self.space.w_IndexError, + self.space.getitem, w_range, w(-3)) + + def test_iter(self): + w = self.space.wrap + w_range = W_XRangeObject(self.space, w(0), w(3), w(1)) + w_iter = self.space.iter(w_range) + self.assertEqual_w(self.space.next(w_iter), w(0)) + self.assertEqual_w(self.space.next(w_iter), w(1)) + self.assertEqual_w(self.space.next(w_iter), w(2)) + self.assertRaises(NoValue, self.space.next, w_iter) + self.assertRaises(NoValue, self.space.next, w_iter) + + def test_contains(self): + w = self.space.wrap + w_range = W_XRangeObject(self.space, w(0), w(3), w(1)) + self.assertEqual_w(self.space.contains(w_range, w(0)), + self.space.w_True) + self.assertEqual_w(self.space.contains(w_range, w(1)), + self.space.w_True) + self.assertEqual_w(self.space.contains(w_range, w(11)), + self.space.w_False) + self.assertEqual_w(self.space.contains(w_range, w_range), + self.space.w_False) + +if __name__ == '__main__': + test.main() diff -urN -x.svn -x'*.pyc' src.old/pypy/objspace/std/xrangeobject.py src/pypy/objspace/std/xrangeobject.py --- src.old/pypy/objspace/std/xrangeobject.py 1970-01-01 00:00:00.000000000 +0000 +++ src/pypy/objspace/std/xrangeobject.py 2003-07-08 08:32:53.000000000 +0000 @@ -0,0 +1,88 @@ +""" +Reviewed 03-06-21 + +slice object construction tested, OK +indices method tested, OK +""" + +from pypy.objspace.std.objspace import * +from pypy.interpreter.appfile import AppFile +from pypy.interpreter.extmodule import make_builtin_func +from pypy.objspace.std.instmethobject import W_InstMethObject +from xrangetype import W_XRangeType +from intobject import W_IntObject + +#appfile = AppFile(__name__, ["objspace.std"]) + + +class W_XRangeObject(W_Object): + statictype = W_XRangeType + + def __init__(w_self, space, w_start, w_stop, w_step): + W_Object.__init__(w_self, space) + w_self.w_start = w_start or W_IntObject(space, 0) + w_self.w_stop = w_stop + w_self.w_step = w_step or W_IntObject(space, 1) + + def tolist(w_self): + stop = w_self.space.unwrap(w_self.w_stop) + start = w_self.space.unwrap(w_self.w_start) + step = w_self.space.unwrap(w_self.w_step) + num = (stop-start)//step + # does this count as "using range in a loop"? + # RPython is poorly speced + return w_self.space.newlist([w_self.space.wrap(i*w_step+w_start) + for i in range(num)]) + +registerimplementation(W_XRangeObject) + +def getattr__XRange_ANY(space, w_range, w_attr): + if space.is_true(space.eq(w_attr, space.wrap('start'))): + if w_range.w_start is None: + return space.w_None + else: + return w_range.w_start + if space.is_true(space.eq(w_attr, space.wrap('stop'))): + if w_range.w_stop is None: + return space.w_None + else: + return w_range.w_stop + if space.is_true(space.eq(w_attr, space.wrap('step'))): + if w_range.w_step is None: + return space.w_None + else: + return w_range.w_step + if space.is_true(space.eq(w_attr, space.wrap('tolist'))): + w_builtinfn = make_builtin_func(space, W_XRangeObject.tolist) + return W_InstMethObject(space, w_builtinfn, w_range, w_range.statictype) + + raise FailedToImplement(space.w_AttributeError) + +def len__XRange(space, w_range): + stop = space.unwrap(w_range.w_stop) + start = space.unwrap(w_range.w_start) + step = space.unwrap(w_range.w_step) + num = (stop-start)//step + return W_IntObject(space, num) + +def getitem__XRange_Int(space, w_range, w_index): + stop = space.unwrap(w_range.w_stop) + start = space.unwrap(w_range.w_start) + step = space.unwrap(w_range.w_step) + num = (stop-start)//step + idx = w_index.intval + if idx < 0: + idx += num + if idx < 0 or idx >= num: + raise OperationError(space.w_IndexError, + space.wrap("xrange index out of range")) + return W_IntObject(space, start+step*idx) + +def iter__XRange(space, w_range): + # Someday, I'll write a smarter iterator + # This is like the old 2.2 slow iterator, rather than the new + # 2.3 fast iterator + import iterobject + return iterobject.W_SeqIterObject(space, w_range) + +register_all(vars()) diff -urN -x.svn -x'*.pyc' src.old/pypy/objspace/std/xrangetype.py src/pypy/objspace/std/xrangetype.py --- src.old/pypy/objspace/std/xrangetype.py 1970-01-01 00:00:00.000000000 +0000 +++ src/pypy/objspace/std/xrangetype.py 2003-07-08 08:55:04.000000000 +0000 @@ -0,0 +1,33 @@ +from pypy.objspace.std.objspace import * +from typeobject import W_TypeObject + +class W_XRangeType(W_TypeObject): + + typename = 'xrange' + +registerimplementation(W_XRangeType) + + +def type_new__XRangeType_XRangeType_ANY_ANY(space, w_basetype, w_xrangetype, w_args, w_kwds): + if space.is_true(w_kwds): + raise OperationError(space.w_TypeError, + space.wrap("no keyword arguments expected")) + args = space.unpackiterable(w_args) + start = space.w_None + stop = space.w_None + step = space.w_None + if len(args) == 1: + stop, = args + elif len(args) == 2: + start, stop = args + elif len(args) == 3: + start, stop, step = args + elif len(args) > 3: + raise OperationError(space.w_TypeError, + space.wrap("xrange() takes at most 3 arguments")) + else: + raise OperationError(space.w_TypeError, + space.wrap("xrange() takes at least 1 argument")) + return space.newxrange(start, stop, step), True + +register_all(vars()) -- Moshe Zadka -- http://moshez.org/ Buffy: I don't like you hanging out with someone that... short. Riley: Yeah, a lot of young people nowadays are experimenting with shortness. Agile Programming Language -- http://www.python.org/ [View Less]

2 4

X Range Object
by Moshe Zadka July 8, 2003

July 8, 2003

Here is a diff vs. revision 1116. It contains patches to the objspace module, but I wasn't sure how to add new names. Thanks, Moshe Zadka diff -urN -x.svn -x'*.pyc' src.old/pypy/objspace/std/objspace.py src/pypy/objspace/std/objspace.py --- src.old/pypy/objspace/std/objspace.py 2003-07-08 08:36:48.000000000 +0000 +++ src/pypy/objspace/std/objspace.py 2003-07-08 07:58:21.000000000 +0000 @@ -260,6 +260,11 @@ import moduleobject return moduleobject.W_ModuleObject(self, w_name) … [View More] + def newxrange(self, w_start, w_end, w_step): + # w_step may be a real None + import xrangeobject + return xrangeobject.W_XRangeObject(self, w_start, w_end, w_step) + def newstring(self, chars_w): try: chars = [chr(self.unwrap(w_c)) for w_c in chars_w] diff -urN -x.svn -x'*.pyc' src.old/pypy/objspace/std/test/test_xrangeobject.py src/pypy/objspace/std/test/test_xrangeobject.py --- src.old/pypy/objspace/std/test/test_xrangeobject.py 1970-01-01 00:00:00.000000000 +0000 +++ src/pypy/objspace/std/test/test_xrangeobject.py 2003-07-08 08:35:28.000000000 +0000 @@ -0,0 +1,70 @@ +import autopath +from pypy.objspace.std.xrangeobject import W_XRangeObject +from pypy.objspace.std.intobject import W_IntObject +from pypy.objspace.std.objspace import NoValue +from pypy.tool import test + +class TestW_XRangeObject(test.TestCase): + + def setUp(self): + self.space = test.objspace('std') + + def tearDown(self): + pass + + def test_is_true(self): + w = self.space.wrap + w_range = W_XRangeObject(self.space, w(0), w(0), w(1)) + self.assertEqual(self.space.is_true(w_range), False) + w_range = W_XRangeObject(self.space, w(0), w(1), w(1)) + self.assertEqual(self.space.is_true(w_range), True) + w_range = W_XRangeObject(self.space, w(0), w(5), w(1)) + self.assertEqual(self.space.is_true(w_range), True) + + def test_len(self): + w = self.space.wrap + w_range = W_XRangeObject(self.space, w(0), w(0), w(1)) + self.assertEqual_w(self.space.len(w_range), w(0)) + w_range = W_XRangeObject(self.space, w(0), w(1), w(1)) + self.assertEqual_w(self.space.len(w_range), w(1)) + w_range = W_XRangeObject(self.space, w(0), w(5), w(1)) + self.assertEqual_w(self.space.len(w_range), w(5)) + + def test_getitem(self): + w = self.space.wrap + w_range = W_XRangeObject(self.space, w(0), w(2), w(1)) + self.assertEqual_w(self.space.getitem(w_range, w(0)), w(0)) + self.assertEqual_w(self.space.getitem(w_range, w(1)), w(1)) + self.assertEqual_w(self.space.getitem(w_range, w(-2)), w(0)) + self.assertEqual_w(self.space.getitem(w_range, w(-1)), w(1)) + self.assertRaises_w(self.space.w_IndexError, + self.space.getitem, w_range, w(2)) + self.assertRaises_w(self.space.w_IndexError, + self.space.getitem, w_range, w(42)) + self.assertRaises_w(self.space.w_IndexError, + self.space.getitem, w_range, w(-3)) + + def test_iter(self): + w = self.space.wrap + w_range = W_XRangeObject(self.space, w(0), w(3), w(1)) + w_iter = self.space.iter(w_range) + self.assertEqual_w(self.space.next(w_iter), w(0)) + self.assertEqual_w(self.space.next(w_iter), w(1)) + self.assertEqual_w(self.space.next(w_iter), w(2)) + self.assertRaises(NoValue, self.space.next, w_iter) + self.assertRaises(NoValue, self.space.next, w_iter) + + def test_contains(self): + w = self.space.wrap + w_range = W_XRangeObject(self.space, w(0), w(3), w(1)) + self.assertEqual_w(self.space.contains(w_range, w(0)), + self.space.w_True) + self.assertEqual_w(self.space.contains(w_range, w(1)), + self.space.w_True) + self.assertEqual_w(self.space.contains(w_range, w(11)), + self.space.w_False) + self.assertEqual_w(self.space.contains(w_range, w_range), + self.space.w_False) + +if __name__ == '__main__': + test.main() diff -urN -x.svn -x'*.pyc' src.old/pypy/objspace/std/xrangeobject.py src/pypy/objspace/std/xrangeobject.py --- src.old/pypy/objspace/std/xrangeobject.py 1970-01-01 00:00:00.000000000 +0000 +++ src/pypy/objspace/std/xrangeobject.py 2003-07-08 08:32:53.000000000 +0000 @@ -0,0 +1,88 @@ +""" +Reviewed 03-06-21 + +slice object construction tested, OK +indices method tested, OK +""" + +from pypy.objspace.std.objspace import * +from pypy.interpreter.appfile import AppFile +from pypy.interpreter.extmodule import make_builtin_func +from pypy.objspace.std.instmethobject import W_InstMethObject +from xrangetype import W_XRangeType +from intobject import W_IntObject + +#appfile = AppFile(__name__, ["objspace.std"]) + + +class W_XRangeObject(W_Object): + statictype = W_XRangeType + + def __init__(w_self, space, w_start, w_stop, w_step): + W_Object.__init__(w_self, space) + w_self.w_start = w_start or W_IntObject(space, 0) + w_self.w_stop = w_stop + w_self.w_step = w_step or W_IntObject(space, 1) + + def tolist(w_self): + stop = w_self.space.unwrap(w_self.w_stop) + start = w_self.space.unwrap(w_self.w_start) + step = w_self.space.unwrap(w_self.w_step) + num = (stop-start)//step + # does this count as "using range in a loop"? + # RPython is poorly speced + return w_self.space.newlist([w_self.space.wrap(i*w_step+w_start) + for i in range(num)]) + +registerimplementation(W_XRangeObject) + +def getattr__XRange_ANY(space, w_range, w_attr): + if space.is_true(space.eq(w_attr, space.wrap('start'))): + if w_range.w_start is None: + return space.w_None + else: + return w_range.w_start + if space.is_true(space.eq(w_attr, space.wrap('stop'))): + if w_range.w_stop is None: + return space.w_None + else: + return w_range.w_stop + if space.is_true(space.eq(w_attr, space.wrap('step'))): + if w_range.w_step is None: + return space.w_None + else: + return w_range.w_step + if space.is_true(space.eq(w_attr, space.wrap('tolist'))): + w_builtinfn = make_builtin_func(space, W_XRangeObject.tolist) + return W_InstMethObject(space, w_builtinfn, w_range, w_range.statictype) + + raise FailedToImplement(space.w_AttributeError) + +def len__XRange(space, w_range): + stop = space.unwrap(w_range.w_stop) + start = space.unwrap(w_range.w_start) + step = space.unwrap(w_range.w_step) + num = (stop-start)//step + return W_IntObject(space, num) + +def getitem__XRange_Int(space, w_range, w_index): + stop = space.unwrap(w_range.w_stop) + start = space.unwrap(w_range.w_start) + step = space.unwrap(w_range.w_step) + num = (stop-start)//step + idx = w_index.intval + if idx < 0: + idx += num + if idx < 0 or idx >= num: + raise OperationError(space.w_IndexError, + space.wrap("xrange index out of range")) + return W_IntObject(space, start+step*idx) + +def iter__XRange(space, w_range): + # Someday, I'll write a smarter iterator + # This is like the old 2.2 slow iterator, rather than the new + # 2.3 fast iterator + import iterobject + return iterobject.W_SeqIterObject(space, w_range) + +register_all(vars()) diff -urN -x.svn -x'*.pyc' src.old/pypy/objspace/std/xrangetype.py src/pypy/objspace/std/xrangetype.py --- src.old/pypy/objspace/std/xrangetype.py 1970-01-01 00:00:00.000000000 +0000 +++ src/pypy/objspace/std/xrangetype.py 2003-07-08 08:00:45.000000000 +0000 @@ -0,0 +1,33 @@ +from pypy.objspace.std.objspace import * +from typeobject import W_TypeObject + +class W_XRangeType(W_TypeObject): + + typename = 'range' + +registerimplementation(W_XRangeType) + + +def type_new__XRangeType_XRangeType_ANY_ANY(space, w_basetype, w_xrangetype, w_args, w_kwds): + if space.is_true(w_kwds): + raise OperationError(space.w_TypeError, + space.wrap("no keyword arguments expected")) + args = space.unpackiterable(w_args) + start = space.w_None + stop = space.w_None + step = space.w_None + if len(args) == 1: + stop, = args + elif len(args) == 2: + start, stop = args + elif len(args) == 3: + start, stop, step = args + elif len(args) > 3: + raise OperationError(space.w_TypeError, + space.wrap("xrange() takes at most 3 arguments")) + else: + raise OperationError(space.w_TypeError, + space.wrap("xrange() takes at least 1 argument")) + return space.newxrange(start, stop, step), True + +register_all(vars()) -- Moshe Zadka -- http://moshez.org/ Buffy: I don't like you hanging out with someone that... short. Riley: Yeah, a lot of young people nowadays are experimenting with shortness. Agile Programming Language -- http://www.python.org/ [View Less]

1 0

Re: [pypy-dev] website update / pypy developments
by Laura Creighton July 7, 2003

July 7, 2003

In a message of Fri, 04 Jul 2003 23:41:48 +0200, holger krekel writes: <snip> >Speaking of EU-Funding. Should we setup a mailing-list for information >exchange and discussion? If we are to really go for the October 15th >deadline then we should start to rush or don't go for it this year (IMHO) >. > >cheers, > > holger I don't mind a separate mailing list, or if discussions happen here. Laura

2 1

Re: [pypy-svn] rev 1073 - in pypy/trunk/src/pypy: interpreter/test objspace/std tool
by Michael Hudson July 7, 2003

July 7, 2003

hpk(a)codespeak.net writes: > Author: hpk > Date: Mon Jun 30 17:41:07 2003 > New Revision: 1073 > > Modified: > pypy/trunk/src/pypy/interpreter/test/test_interpreter.py > pypy/trunk/src/pypy/objspace/std/register_all.py (props changed) > pypy/trunk/src/pypy/objspace/std/stringobject.py > pypy/trunk/src/pypy/tool/test.py > Log: > - improved the hack to perform specific objspace tests only when > actually running the tests with the respective … [View More]

3 4

Re: [pypy-dev] Annotating space status
by Samuele Pedroni July 7, 2003

July 7, 2003

At 08:50 06.07.2003 -0400, Guido van Rossum wrote: >Armin ends a long, eloquent and well thought-out message with: > > > Drawback: We can only process RPython program. Well, that was the original > > goal anyway. I think it is cleaner but it also means that it will take more > > time before we can actually process the whole of PyPy. The other > (current) > > solution is more like we have a very general but hacky W_Anything() > fall-back, > > that … [View More]

2 2