pynie
Chris Burdess
parrot-dev at bluezoo.org
Sun Oct 13 08:48:11 UTC 2013
The following patch fixes the first and second problems with the pynie build:
diff -r pynie.orig/setup.py pynie/setup.py
78c78
< spawn([PARROT, GRAMMAR_GEN, '--output=include/gen_grammar.pir', 'Grammar/Grammar.pg'])
---
> spawn([PARROT, GRAMMAR_GEN, '--encoding=utf8', '--output=include/gen_grammar.pir', 'Grammar/Grammar.pg'])
81c81
< spawn([PARROT, NQP, '--output=include/gen_actions.pir', '--encoding=fixed_8', '--target=pir', 'Grammar/Actions.nqp'])
---
> spawn(['parrot-nqp', '--output=include/gen_actions.pir', '--encoding=fixed_8', '--target=pir', 'Grammar/Actions.nqp'])
Unfortunately Parrot has problems reading the gen_builtins.pir that parrot-nqp
generated:
/usr/local/bin/parrot -o pynie.pbc pynie.pir
error:imcc:syntax error, unexpected VAR, expecting '(' ('x')
in file 'include/gen_builtins.pir' line 1163
included from 'pynie.pir' line 1
error:imcc:syntax error, unexpected VAR, expecting '(' ('a')
in file 'include/gen_builtins.pir' line 1983
included from 'pynie.pir' line 1
current instr.: '__default_get_packfile' pc 408 (frontend/parrot2/prt0.pir:151)
error: command '/usr/local/bin/parrot' failed with exit status 1
If someone with more indepth PIR experience could have a look at why this
error might occur (source file attached for convenience) it would be much
appreciated.
--
Chris Burdess
-------------- next part --------------
=head1 NAME
src/builtins/funcs.pir - built-in functions
=head1 DESCRIPTION
Implements Python's built-in functions. Descriptions are taken from:
http://docs.python.org/lib/built-in-funcs.html
NOTE: most functions are not implemented yet, only stubs are supplied.
=head1 Functions
=over 4
=cut
.namespace []
=item abs(x)
Return the absolute value of a number. The argument may be a plain or
long integer or a floating point number. If the argument is a complex
number, its magnitude is returned.
=cut
.sub 'abs'
.param pmc x
$P0 = abs x
.return ($P0)
.end
=item all(iterable)
Return True if all elements of the iterable are true.
=cut
.sub 'all'
.param pmc iterable
.local pmc iterator, result, obj
iterator = iter iterable
result = new 'Integer' # should be boolean or whatever
.local int bool
loop_check:
unless iterator goto loop_end
obj = shift iterator
bool = istrue obj
unless bool goto fail
goto loop_check
loop_end:
result = 1
.return (result)
fail:
result = 0
.return (result)
.end
=item any(iterable)
Return True if any element of the iterable is true.
=cut
.sub 'any'
.param pmc iterable
.local pmc iterator, result, obj
iterator = iter iterable
result = new 'Integer' # should be bool
.local int bool
loop_check:
unless iterator goto fail
obj = shift iterator
bool = istrue obj
unless bool goto loop_check
result = 1
.return (result)
fail:
result = 0
.return (result)
.end
=item bool([x])
Convert a value to a Boolean, using the standard truth testing procedure.
If x is false or omitted, this returns False; otherwise it returns True.
bool is also a class, which is a subclass of int. Class bool cannot be
subclassed further. Its only instances are False and True.
=cut
.sub 'bool'
.param pmc x :optional
.param int has_x :opt_flag
.local pmc result
result = new 'Integer' # should be bool or whatever
if has_x == 0 goto fail
$I0 = x
unless $I0 goto fail
result = 1
.return (result)
fail:
result = 0
.return (result)
.end
=item chr(i)
Return a string of one character whose ASCII code is the integer i.
For example, chr(97) returns the string 'a'. This is the inverse of ord().
The argument must be in the range [0..255], inclusive; ValueError will
be raised if i is outside that range.
=cut
.sub 'chr'
.param int i
if i < 0 goto valueerror
if i > 255 goto valueerror
.local pmc result
result = new [ 'str' ]
$S0 = chr i
result = $S0
.return (result)
valueerror:
$P0 = new 'Exception'
$P0 = "ValueError"
throw $P0
.end
=item classmethod(function)
Return a class method for function.
A class method receives the class as implicit first argument,
just like an instance method receives the instance.
To declare a class method, use this idiom:
class C:
@classmethod
def f(cls, arg1, arg2, ...): ...
The @classmethod form is a function decorator - see the description
of function definitions in chapter 7 of the Python Reference Manual for details.
It can be called either on the class (such as C.f()) or on an
instance (such as C().f()). The instance is ignored except for its class.
If a class method is called for a derived class, the derived class object
is passed as the implied first argument.
Class methods are different than C++ or Java static methods. If you want
those, see staticmethod() in this section.
For more information on class methods, consult the documentation on the
standard type hierarchy in chapter 3 of the Python Reference Manual
(at the bottom). New in version 2.2. Changed in version 2.4: Function
decorator syntax added.
=cut
.sub 'classmethod'
.param pmc function
$P0 = new 'Exception'
$P0 = 'NotImplementedError' # XXX
throw $P0
.end
=item compile(string, filename, kind[, flags[, dont_inherit]])
Compile the string into a code object. Code objects can be executed by an exec
statement or evaluated by a call to eval(). The filename argument should give
the file from which the code was read; pass some recognizable value if it
wasn't read from a file ('<string>' is commonly used). The kind argument
specifies what kind of code must be compiled; it can be 'exec' if string
consists of a sequence of statements, 'eval' if it consists of a single
expression, or 'single' if it consists of a single interactive statement
(in the latter case, expression statements that evaluate to something else
than None will be printed).
When compiling multi-line statements, two caveats apply: line endings must be
represented by a single newline character ('\n'), and the input must be
terminated by at least one newline character. If line endings are represented
by '\r\n', use the string replace() method to change them into '\n'.
The optional arguments flags and dont_inherit (which are new in Python 2.2)
control which future statements (see PEP 236) affect the compilation of string.
If neither is present (or both are zero) the code is compiled with those future
statements that are in effect in the code that is calling compile. If the flags
argument is given and dont_inherit is not (or is zero) then the future
statements specified by the flags argument are used in addition to those that
would be used anyway. If dont_inherit is a non-zero integer then the flags
argument is it - the future statements in effect around the call to compile
are ignored.
Future statements are specified by bits which can be bitwise or-ed together to
specify multiple statements. The bitfield required to specify a given feature
can be found as the compiler_flag attribute on the _Feature instance in the
__future__ module.
=cut
.sub 'compile'
.param pmc str
.param pmc filename
.param pmc kind
.param pmc flags :optional
.param pmc dont_inherit :optional
$P0 = new 'Exception'
$P0 = 'NotImplementedError' # XXX
throw $P0
.end
=item complex([real[, imag]])
Create a complex number with the value real + imag*j or convert a string or
number to a complex number. If the first parameter is a string, it will be
interpreted as a complex number and the function must be called without a
second parameter. The second parameter can never be a string. Each argument
may be any numeric type (including complex). If imag is omitted, it defaults
to zero and the function serves as a numeric conversion function like int(),
long() and float(). If both arguments are omitted, returns 0j.
=cut
.sub 'complex'
.param pmc real :optional
.param pmc imag :optional
$P0 = new 'Exception'
$P0 = 'NotImplementedError' # XXX
throw $P0
.end
=item delattr(object, name)
This is a relative of setattr(). The arguments are an object and a string.
The string must be the name of one of the object's attributes. The function
deletes the named attribute, provided the object allows it. For example,
delattr(x, 'foobar') is equivalent to del x.foobar.
=cut
.sub 'delattr'
.param pmc obj
.param pmc name
$P0 = new 'Exception'
$P0 = 'NotImplementedError' # XXX
throw $P0
.end
=item dict([mapping-or-sequence])
Return a new dictionary initialized from an optional positional argument or
from a set of keyword arguments. If no arguments are given, return a new empty
dictionary. If the positional argument is a mapping object, return a dictionary
mapping the same keys to the same values as does the mapping object. Otherwise
the positional argument must be a sequence, a container that supports iteration,
or an iterator object. The elements of the argument must each also be of one of
those kinds, and each must in turn contain exactly two objects. The first is
used as a key in the new dictionary, and the second as the key's value. If a
given key is seen more than once, the last value associated with it is retained
in the new dictionary.
If keyword arguments are given, the keywords themselves with their associated
values are added as items to the dictionary. If a key is specified both in the
positional argument and as a keyword argument, the value associated with the
keyword is retained in the dictionary. For example, these all return a dictionary
equal to {"one": 2, "two": 3}:
* dict({'one': 2, 'two': 3})
* dict({'one': 2, 'two': 3}.items())
* dict({'one': 2, 'two': 3}.iteritems())
* dict(zip(('one', 'two'), (2, 3)))
* dict([['two', 3], ['one', 2]])
* dict(one=2, two=3)
* dict([(['one', 'two'][i-2], i) for i in (2, 3)])
New in version 2.2. Changed in version 2.3: Support for building a dictionary
from keyword arguments added.
=cut
.sub 'dict'
.param pmc sequence :optional
.param pmc mapping :slurpy :named :optional
$P0 = new 'Exception'
$P0 = 'NotImplementedError' # XXX
throw $P0
.end
=item dir([object])
Without arguments, return the list of names in the current local symbol table.
With an argument, attempts to return a list of valid attributes for that object.
This information is gleaned from the object's __dict__ attribute, if defined,
and from the class or type object. The list is not necessarily complete. If the
object is a module object, the list contains the names of the module's attributes.
If the object is a type or class object, the list contains the names of its
attributes, and recursively of the attributes of its bases. Otherwise, the list
contains the object's attributes' names, the names of its class's attributes,
and recursively of the attributes of its class's base classes. The resulting
list is sorted alphabetically. For example:
>>> import struct
>>> dir()
['__builtins__', '__doc__', '__name__', 'struct']
>>> dir(struct)
['__doc__', '__name__', 'calcsize', 'error', 'pack', 'unpack']
Note: Because dir() is supplied primarily as a convenience for use at an
interactive prompt, it tries to supply an interesting set of names more than it
tries to supply a rigorously or consistently defined set of names, and its
detailed behavior may change across releases.
=cut
.sub 'dir'
.param pmc obj :optional
$P0 = new 'Exception'
$P0 = 'NotImplementedError' # XXX
throw $P0
.end
=item divmod(a, b)
Take two (non complex) numbers as arguments and return a pair of numbers
consisting of their quotient and remainder when using long division.
With mixed operand types, the rules for binary arithmetic operators apply.
For plain and long integers, the result is the same as (a // b, a % b).
For floating point numbers the result is (q, a % b), where q is usually
math.floor(a / b) but may be 1 less than that. In any case q * b + a % b
is very close to a, if a % b is non-zero it has the same sign as b, and
0 <= abs(a % b) < abs(b).
Changed in version 2.3: Using divmod() with complex numbers is deprecated.
=cut
.sub 'divmod'
.param pmc a
.param pmc b
$P0 = new 'Exception'
$P0 = 'NotImplementedError' # XXX
throw $P0
.end
=item enumerate(iterable)
Return an enumerate object. iterable must be a sequence, an iterator, or
some other object which supports iteration. The next() method of the
iterator returned by enumerate() returns a tuple containing a count
(from zero) and the corresponding value obtained from iterating over
iterable. enumerate() is useful for obtaining an indexed series:
(0, seq[0]), (1, seq[1]), (2, seq[2]), .... New in version 2.3.
=cut
.sub 'enumerate'
.param pmc iterable
$P0 = new 'Exception'
$P0 = 'NotImplementedError' # XXX
throw $P0
.end
=item eval(expression[, globals[, locals]])
The arguments are a string and optional globals and locals. If provided,
globals must be a dictionary. If provided, locals can be any mapping object.
Changed in version 2.4: formerly locals was required to be a dictionary.
The expression argument is parsed and evaluated as a Python expression
(technically speaking, a condition list) using the globals and locals
dictionaries as global and local name space. If the globals dictionary
is present and lacks '__builtins__', the current globals are copied into
globals before expression is parsed. This means that expression normally
has full access to the standard __builtin__ module and restricted
environments are propagated. If the locals dictionary is omitted it
defaults to the globals dictionary. If both dictionaries are omitted,
the expression is executed in the environment where eval is called.
The return value is the result of the evaluated expression.
Syntax errors are reported as exceptions. Example:
>>> x = 1
>>> print eval('x+1')
2
This function can also be used to execute arbitrary code objects
(such as those created by compile()). In this case pass a code object
instead of a string. The code object must have been compiled passing
'eval' as the kind argument.
Hints: dynamic execution of statements is supported by the exec statement.
Execution of statements from a file is supported by the execfile() function.
The globals() and locals() functions returns the current global and local
dictionary, respectively, which may be useful to pass around for use by
eval() or execfile().
=cut
.sub 'eval'
.param pmc expr
.param pmc globals :optional
.param pmc locals :optional
$P0 = new 'Exception'
$P0 = 'NotImplementedError' # XXX
throw $P0
.end
=item file(filename[, mode[, bufsize]])
Constructor function for the file type, described further in section 3.9,
``File Objects''. The constructor's arguments are the same as those of
the open() built-in function described below.
When opening a file, it's preferable to use open() instead of invoking this
constructor directly. file is more suited to type testing (for example,
writing "isinstance(f, file)").
New in version 2.2.
=cut
.sub 'file'
.param pmc filename
.param pmc mode :optional
.param pmc bufsize :optional
$P0 = new 'Exception'
$P0 = 'NotImplementedError' # XXX
throw $P0
.end
=item filter(function, list)
Construct a list from those elements of list for which function returns true.
list may be either a sequence, a container which supports iteration, or an
iterator, If list is a string or a tuple, the result also has that type;
otherwise it is always a list. If function is None, the identity function
is assumed, that is, all elements of list that are false are removed.
Note that filter(function, list) is equivalent to [item for item in list if
function(item)] if function is not None and [item for item in list if item]
if function is None.
=cut
.sub 'filter'
.param pmc function
.param pmc list
$P0 = new 'Exception'
$P0 = 'NotImplementedError' # XXX
throw $P0
.end
=item float([x])
Convert a string or a number to floating point. If the argument is a string,
it must contain a possibly signed decimal or floating point number, possibly
embedded in whitespace. Otherwise, the argument may be a plain or long integer
or a floating point number, and a floating point number with the same value
(within Python's floating point precision) is returned. If no argument is
given, returns 0.0.
Note: When passing in a string, values for NaN and Infinity may be returned,
depending on the underlying C library. The specific set of strings accepted
which cause these values to be returned depends entirely on the C library
and is known to vary.
=cut
.sub 'float'
.param pmc x :optional
$P0 = new 'Exception'
$P0 = 'NotImplementedError' # XXX
throw $P0
.end
=item frozenset([iterable])
Return a frozenset object whose elements are taken from iterable. Frozensets
are sets that have no update methods but can be hashed and used as members of
other sets or as dictionary keys. The elements of a frozenset must be immutable
themselves. To represent sets of sets, the inner sets should also be frozenset
objects. If iterable is not specified, returns a new empty set, frozenset([]).
New in version 2.4.
=cut
.sub 'frozenset'
.param pmc iterable :optional
$P0 = new 'Exception'
$P0 = 'NotImplementedError' # XXX
throw $P0
.end
=item getattr(object, name[, default])
Return the value of the named attributed of object. name must be a string.
If the string is the name of one of the object's attributes, the result is
the value of that attribute. For example, getattr(x, 'foobar') is equivalent
to x.foobar. If the named attribute does not exist, default is returned if
provided, otherwise AttributeError is raised.
=cut
.sub 'getattr'
.param pmc obj
.param pmc name
.param pmc default :optional
$P0 = new 'Exception'
$P0 = 'NotImplementedError' # XXX
throw $P0
.end
=item globals()
Return a dictionary representing the current global symbol table. This is
always the dictionary of the current module (inside a function or method,
this is the module where it is defined, not the module from which it is called).
=cut
.sub 'globals'
$P0 = new 'Exception'
$P0 = 'NotImplementedError' # XXX
throw $P0
.end
=item hasattr(object, name)
The arguments are an object and a string. The result is True if the string
is the name of one of the object's attributes, False if not.
(This is implemented by calling getattr(object, name) and seeing whether
it raises an exception or not.)
=cut
.sub 'hasattr'
.param pmc obj
.param pmc name
$P0 = new 'Exception'
$P0 = 'NotImplementedError' # XXX
throw $P0
.end
=item hash(object)
Return the hash value of the object (if it has one). Hash values are integers.
They are used to quickly compare dictionary keys during a dictionary lookup.
Numeric values that compare equal have the same hash value (even if they are
of different types, as is the case for 1 and 1.0).
=cut
.sub 'hash'
.param pmc obj
$P0 = new 'Exception'
$P0 = 'NotImplementedError' # XXX
throw $P0
.end
=item help([object])
Invoke the built-in help system. (This function is intended for interactive use.)
If no argument is given, the interactive help system starts on the interpreter
console. If the argument is a string, then the string is looked up as the name
of a module, function, class, method, keyword, or documentation topic, and a
help page is printed on the console. If the argument is any other kind of object,
a help page on the object is generated. New in version 2.2.
=cut
.sub 'help'
.param pmc obj :optional
$P0 = new 'Exception'
$P0 = 'NotImplementedError' # XXX
throw $P0
.end
=item hex(x)
Convert an integer number (of any size) to a hexadecimal string. The result
is a valid Python expression. Changed in version 2.4: Formerly only returned an
unsigned literal.
=cut
.sub 'hex'
.param pmc x
.local int digit
.local string digit_str, result, prefix
$I0 = x
unless $I0 == 0 goto is_nonzero
.return ('0x0')
is_nonzero:
result = ''
unless $I0 < 0 goto is_positive
# is negative
prefix = '-0x'
$I0 = -$I0
goto loop
is_positive:
prefix = '0x'
loop:
digit = $I0 & 0xf
$I0 >>= 4
digit_str = substr '0123456789abcdef', digit, 1
result = digit_str . result
if $I0 > 0 goto loop
result = prefix . result
.return (result)
.end
=item id(object)
Return the ``identity'' of an object. This is an integer (or long integer)
which is guaranteed to be unique and constant for this object during its
lifetime. Two objects with non-overlapping lifetimes may have the same id()
value. (Implementation note: this is the address of the object.)
=cut
.sub 'id'
.param pmc obj
$P0 = new 'Exception'
$P0 = 'NotImplementedError' # XXX
throw $P0
.end
=item input([prompt])
Equivalent to eval(raw_input(prompt)). Warning: This function is not safe
from user errors! It expects a valid Python expression as input; if the
input is not syntactically valid, a SyntaxError will be raised. Other
exceptions may be raised if there is an error during evaluation.
(On the other hand, sometimes this is exactly what you need when writing
a quick script for expert use.)
If the readline module was loaded, then input() will use it to provide
elaborate line editing and history features.
Consider using the raw_input() function for general input from users.
=cut
.sub 'input'
.param pmc prompt :optional
$P0 = new 'Exception'
$P0 = 'NotImplementedError' # XXX
throw $P0
.end
=item int([x[, radix]])
Convert a string or number to a plain integer. If the argument is a
string, it must contain a possibly signed decimal number representable
as a Python integer, possibly embedded in whitespace. The radix parameter
gives the base for the conversion and may be any integer in the range
[2, 36], or zero. If radix is zero, the proper radix is guessed based
on the contents of string; the interpretation is the same as for integer
literals. If radix is specified and x is not a string, TypeError is raised.
Otherwise, the argument may be a plain or long integer or a floating point
number. Conversion of floating point numbers to integers truncates
(towards zero). If the argument is outside the integer range a long object
will be returned instead. If no arguments are given, returns 0.
=cut
.sub 'int'
.param pmc x :optional
.param pmc radix :optional
$P0 = new 'Exception'
$P0 = 'NotImplementedError' # XXX
throw $P0
.end
=item isinstance(object, classinfo)
Return true if the object argument is an instance of the classinfo argument,
or of a (direct or indirect) subclass thereof. Also return true if classinfo
is a type object and object is an object of that type. If object is not a class
instance or an object of the given type, the function always returns false.
If classinfo is neither a class object nor a type object, it may be a tuple of
class or type objects, or may recursively contain other such tuples
(other sequence types are not accepted). If classinfo is not a class, type,
or tuple of classes, types, and such tuples, a TypeError exception is raised.
Changed in version 2.2: Support for a tuple of type information was added.
=cut
.sub 'isinstance'
.param pmc obj
.param pmc classinfo
$I0 = isa obj, classinfo
.return ($I0)
.end
=item issubclass(class, classinfo)
Return true if class is a subclass (direct or indirect) of classinfo. A class
is considered a subclass of itself. classinfo may be a tuple of class objects,
in which case every entry in classinfo will be checked. In any other case, a
TypeError exception is raised. Changed in version 2.3: Support for a tuple of
type information was added.
=cut
.sub 'issubclass'
.param pmc class
.param pmc classinfo
$P0 = new 'Exception'
$P0 = 'NotImplementedError' # XXX
throw $P0
.end
=item iter(o[, sentinel])
Return an iterator object. The first argument is interpreted very differently
depending on the presence of the second argument. Without a second argument,
o must be a collection object which supports the iteration protocol
(the __iter__() method), or it must support the sequence protocol
(the __getitem__() method with integer arguments starting at 0).
If it does not support either of those protocols, TypeError is raised.
If the second argument, sentinel, is given, then o must be a callable object.
The iterator created in this case will call o with no arguments for each call
to its next() method; if the value returned is equal to sentinel, StopIteration
will be raised, otherwise the value will be returned. New in version 2.2.
=cut
.sub 'iter'
.param pmc o
.param pmc sentinel :optional
$P0 = new 'Exception'
$P0 = 'NotImplementedError' # XXX
throw $P0
.end
=item len(s)
Return the length (the number of items) of an object. The argument may be a
sequence (string, tuple or list) or a mapping (dictionary).
=cut
.sub 'len'
.param pmc s
$I0 = elements s
$P0 = new 'Integer'
$P0 = $I0
.return ($P0)
.end
=item locals()
Update and return a dictionary representing the current local symbol table.
Warning: The contents of this dictionary should not be modified; changes may not
affect the values of local variables used by the interpreter.
=cut
.sub 'locals'
$P0 = new 'Exception'
$P0 = 'NotImplementedError' # XXX
throw $P0
.end
=item long([x[, radix]])
Convert a string or number to a long integer. If the argument is a string,
it must contain a possibly signed number of arbitrary size, possibly embedded
in whitespace. The radix argument is interpreted in the same way as for int(),
and may only be given when x is a string. Otherwise, the argument may be a
plain or long integer or a floating point number, and a long integer with the
same value is returned. Conversion of floating point numbers to integers
truncates (towards zero). If no arguments are given, returns 0L.
=cut
.sub 'long'
.param pmc x :optional
.param pmc radix :optional
$P0 = new 'Exception'
$P0 = 'NotImplementedError' # XXX
throw $P0
.end
=item map(function, list, ...)
Apply function to every item of list and return a list of the results. If
additional list arguments are passed, function must take that many arguments
and is applied to the items of all lists in parallel; if a list is shorter
than another it is assumed to be extended with None items. If function is
None, the identity function is assumed; if there are multiple list arguments,
map() returns a list consisting of tuples containing the corresponding items
from all lists (a kind of transpose operation). The list arguments may be any
kind of sequence; the result is always a list.
=cut
.sub 'map'
.param pmc function
.param pmc list
.param pmc args :slurpy
# XXX allow function to be None
# XXX return an iterator rather than a list (as per Python 3.0)
.local int num_lists
.local pmc result, list_array, iter_array, func_params
list_array = args
unshift list_array, list
num_lists = elements list_array
# Build list of iterators, one for each list
iter_array = new 'FixedPMCArray'
iter_array = num_lists
$I0 = 0
make_iter_array_loop:
$P0 = list_array[$I0]
$P1 = iter $P0
iter_array[$I0] = $P1
inc $I0
unless $I0 >= num_lists goto make_iter_array_loop
# Now iterate over all the lists together
result = new [ 'list' ]
loop:
func_params = new 'FixedPMCArray'
func_params = num_lists
# get one element from each iterator
$I0 = 0
make_func_params_loop:
$P0 = iter_array[$I0]
# XXX extra None's should be added if any list is shorter than the others
unless $P0 goto done # stop when done iterating over any of the lists
$P1 = shift $P0
func_params[$I0] = $P1
inc $I0
unless $I0 >= num_lists goto make_func_params_loop
# call function and add function result to result list
$P0 = function(func_params :flat)
push result, $P0
goto loop
done:
.return (result)
.end
=item max(s[, args...][key])
With a single argument s, return the largest item of a non-empty sequence
(such as a string, tuple or list). With more than one argument, return the
largest of the arguments.
The optional key argument specifies a one-argument ordering function like
that used for list.sort(). The key argument, if supplied, must be in keyword
form (for example, "max(a,b,c,key=func)"). Changed in version 2.5: Added
support for the optional key argument.
=cut
.sub 'max'
.param pmc s
.param pmc args :slurpy
#.param pmc key :named :optional XXX
.local pmc iterator, result
$I0 = elements args
if $I0 > 0 goto multiple_args
iterator = iter s
result = shift iterator
goto loop_check
multiple_args:
iterator = iter args
result = s
loop_check:
.local pmc i
unless iterator goto loop_end
i = shift iterator
unless i > result goto loop_check
set result, i
goto loop_check
loop_end:
.return (result)
.end
=item min(s[, args...][key])
With a single argument s, return the smallest item of a non-empty sequence
(such as a string, tuple or list). With more than one argument, return the
smallest of the arguments.
The optional key argument specifies a one-argument ordering function like
that used for list.sort(). The key argument, if supplied, must be in keyword
form (for example, "min(a,b,c,key=func)"). Changed in version 2.5: Added
support for the optional key argument.
=cut
.sub 'min'
.param pmc s
.param pmc args :slurpy
#.param pmc key :named :optional XXX
.local pmc iterator, result
$I0 = elements args
if $I0 > 0 goto multiple_args
iterator = iter s
result = shift iterator
goto loop_check
multiple_args:
iterator = iter args
result = s
loop_check:
.local pmc i
unless iterator goto loop_end
i = shift iterator
unless i < result goto loop_check
set result, i
goto loop_check
loop_end:
.return (result)
.end
=item object()
Return a new featureless object. object is a base for all new style classes.
It has the methods that are common to all instances of new style classes.
New in version 2.2.
Changed in version 2.3: This function does not accept any arguments.
Formerly, it accepted arguments but ignored them.
=cut
.sub 'object'
$P0 = new 'Exception'
$P0 = 'NotImplementedError' # XXX
throw $P0
.end
=item oct(x)
Convert an integer number (of any size) to an octal string. The result is a
valid Python expression. Changed in version 2.4: Formerly only returned an
unsigned literal.
=cut
.sub 'oct'
.param pmc x
$P0 = new 'Exception'
$P0 = 'NotImplementedError' # XXX
throw $P0
.end
=item open(filename[, mode[, bufsize]])
Open a file, returning an object of the file type described in section 3.9,
``File Objects''. If the file cannot be opened, IOError is raised. When
opening a file, it's preferable to use open() instead of invoking the file
constructor directly.
The first two arguments are the same as for stdio's fopen(): filename is the
file name to be opened, and mode is a string indicating how the file is to be opened.
The most commonly-used values of mode are 'r' for reading, 'w' for writing
(truncating the file if it already exists), and 'a' for appending
(which on some Unix systems means that all writes append to the end of the
file regardless of the current seek position). If mode is omitted, it
defaults to 'r'. When opening a binary file, you should append 'b' to the
mode value to open the file in binary mode, which will improve portability.
(Appending 'b' is useful even on systems that don't treat binary and text
files differently, where it serves as documentation.) See below for more
possible values of mode.
The optional bufsize argument specifies the file's desired buffer size: 0
means unbuffered, 1 means line buffered, any other positive value means use
a buffer of (approximately) that size. A negative bufsize means to use the
system default, which is usually line buffered for tty devices and fully
buffered for other files. If omitted, the system default is used.2.3
Modes 'r+', 'w+' and 'a+' open the file for updating (note that 'w+'
truncates the file). Append 'b' to the mode to open the file in binary mode,
on systems that differentiate between binary and text files; on systems that
don't have this distinction, adding the 'b' has no effect.
In addition to the standard fopen() values mode may be 'U' or 'rU'. Python is
usually built with universal newline support; supplying 'U' opens the file as
a text file, but lines may be terminated by any of the following: the
Unix end-of-line convention '\n', the Macintosh convention '\r', or the Windows
convention '\r\n'. All of these external representations are seen as '\n' by
the Python program. If Python is built without universal newline support a mode
with 'U' is the same as normal text mode. Note that file objects so opened also
have an attribute called newlines which has a value of None (if no newlines
have yet been seen), '\n', '\r', '\r\n', or a tuple containing all the newline
types seen.
Python enforces that the mode, after stripping 'U', begins with 'r', 'w' or 'a'.
Changed in version 2.5: Restriction on first letter of mode string introduced.
=cut
.sub 'open'
.param pmc filename
.param pmc mode :optional
.param pmc bufsize :optional
$P0 = new 'Exception'
$P0 = 'NotImplementedError' # XXX
throw $P0
.end
=item ord(c)
Given a string of length one, return an integer representing the Unicode code
point of the character when the argument is a unicode object, or the value of
the byte when the argument is an 8-bit string. For example, ord('a') returns
the integer 97, ord(u'\u2020') returns 8224. This is the inverse of chr() for
8-bit strings and of unichr() for unicode objects. If a unicode argument is
given and Python was built with UCS2 Unicode, then the character's code point
must be in the range [0..65535] inclusive; otherwise the string length is two,
and a TypeError will be raised.
=cut
.sub 'ord'
.param pmc c
$S0 = c
$I0 = length $S0
if $I0 != 1 goto typeerror
$I1 = ord $S0
.return ($I1)
typeerror:
$P0 = new 'Exception'
$P0 = "TypeError"
throw $P0
.end
=item pow(x, y[, z])
Return x to the power y; if z is present, return x to the power y, modulo z
(computed more efficiently than pow(x, y) % z). The two-argument form
pow(x, y) is equivalent to using the power operator: x**y.
The arguments must have numeric types. With mixed operand types, the coercion
rules for binary arithmetic operators apply. For int and long int operands,
the result has the same type as the operands (after coercion) unless the
second argument is negative; in that case, all arguments are converted to
float and a float result is delivered. For example, 10**2 returns 100, but
10**-2 returns 0.01. (This last feature was added in Python 2.2.
In Python 2.1 and before, if both arguments were of integer types and the
second argument was negative, an exception was raised.) If the second
argument is negative, the third argument must be omitted. If z is present,
x and y must be of integer types, and y must be non-negative.
(This restriction was added in Python 2.2. In Python 2.1 and before,
floating 3-argument pow() returned platform-dependent results depending on
floating-point rounding accidents.)
=cut
.sub 'pow'
.param pmc x
.param pmc y
.param pmc z :optional
.param int has_z :opt_flag
if has_z goto when_has_z
$P0 = pow x, y
.return ($P0)
when_has_z:
# use a fast exponentiation method
.local int X, Y, Z
X = x
Y = y
Z = z
$I0 = 1
loop:
unless Y > 0 goto endloop
$I1 = band Y, 1
bitcheck:
unless $I1 == 1 goto endbitcheck
$I1 = $I0 * X
$I0 = mod $I1, Z
endbitcheck:
Y = shr Y, 1
$I1 = X * X
X = mod $I1, Z
goto loop
endloop:
.return ($I0)
.end
=item property([fget[, fset[, fdel[, doc]]]])
Return a property attribute for new-style classes (classes that derive
from object).
fget is a function for getting an attribute value, likewise fset is a function
for setting, and fdel a function for del'ing, an attribute. Typical use is to
define a managed attribute x:
class C(object):
def __init__(self): self.__x = None
def getx(self): return self._x
def setx(self, value): self._x = value
def delx(self): del self._x
x = property(getx, setx, delx, "I'm the 'x' property.")
If given, doc will be the docstring of the property attribute. Otherwise, the
property will copy fget's docstring (if it exists). This makes it possible to
create read-only properties easily using property() as a decorator:
class Parrot(object):
def __init__(self):
self._voltage = 100000
@property
def voltage(self):
"""Get the current voltage."""
return self._voltage
turns the voltage() method into a ``getter'' for a read-only attribute with
the same name.
New in version 2.2. Changed in version 2.5: Use fget's docstring if no doc given.
=cut
.sub 'property'
.param pmc fget :optional
.param pmc fset :optional
.param pmc fdel :optional
.param pmc doc :optional
$P0 = new 'Exception'
$P0 = 'NotImplementedError' # XXX
throw $P0
.end
=item range([start,] stop[, step])
This is a versatile function to create lists containing arithmetic
progressions. It is most often used in for loops. The arguments must be plain
integers. If the step argument is omitted, it defaults to 1. If the start
argument is omitted, it defaults to 0. The full form returns a list of plain
integers [start, start + step, start + 2 * step, ...]. If step is positive,
the last element is the largest start + i * step less than stop; if step is
negative, the last element is the smallest start + i * step greater than stop.
step must not be zero (or else ValueError is raised). Example:
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(1, 11)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> range(0, 30, 5)
[0, 5, 10, 15, 20, 25]
>>> range(0, 10, 3)
[0, 3, 6, 9]
>>> range(0, -10, -1)
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> range(0)
[]
>>> range(1, 0)
[]
=cut
.sub 'range'
.param pmc stop
# XXX start, step
.local int stopn
.local pmc lst
.local pmc tmp
$I0 = 0
lst = new [ 'list' ]
stopn = stop
loop:
unless $I0 < stopn goto done
tmp = new 'Integer'
tmp = $I0
push lst, tmp
inc $I0
goto loop
done:
.return (lst)
.end
=item repr(object)
Return a string containing a printable representation of an object. This is
the same value yielded by conversions (reverse quotes). It is sometimes useful
to be able to access this operation as an ordinary function. For many types,
this function makes an attempt to return a string that would yield an object
with the same value when passed to eval().
=cut
.sub 'repr'
.param pmc obj
.local string result
$I0 = can obj, '__repr__'
unless $I0 goto no_repr
.tailcall obj.'__repr__'()
no_repr:
result = obj
.return (result)
.end
=item reversed(seq)
Return a reverse iterator. seq must be an object which supports the sequence
protocol (the __len__() method and the __getitem__() method with integer
arguments starting at 0). New in version 2.4.
=cut
.sub 'reversed'
.param pmc seq
$P0 = new 'Exception'
$P0 = 'NotImplementedError' # XXX
throw $P0
.end
=item round(x[, n])
Return the floating point value x rounded to n digits after the decimal point.
If n is omitted, it defaults to zero. The result is a floating point number.
Values are rounded to the closest multiple of 10 to the power minus n; if two
multiples are equally close, rounding is done away from 0 (so. for example,
round(0.5) is 1.0 and round(-0.5) is -1.0).
=cut
.sub 'round'
.param pmc x
.param pmc n :optional
$P0 = new 'Exception'
$P0 = 'NotImplementedError' # XXX
throw $P0
.end
=item set([iterable])
Return a set whose elements are taken from iterable. The elements must be
immutable. To represent sets of sets, the inner sets should be frozenset
objects. If iterable is not specified, returns a new empty set, set([]).
New in version 2.4.
=cut
.sub 'set'
.param pmc iterable :optional
$P0 = new 'Exception'
$P0 = 'NotImplementedError' # XXX
throw $P0
.end
=item setattr(object, name, value)
This is the counterpart of getattr(). The arguments are an object, a
string and an arbitrary value. The string may name an existing attribute
or a new attribute. The function assigns the value to the attribute, provided
the object allows it. For example, setattr(x, 'foobar', 123) is
equivalent to x.foobar = 123.
=cut
.sub 'setattr'
.param pmc obj
.param pmc name
.param pmc value
$P0 = new 'Exception'
$P0 = 'NotImplementedError' # XXX
throw $P0
.end
=item slice([start,] stop[, step])
Return a slice object representing the set of indices specified by
range(start, stop, step). The start and step arguments default to None.
Slice objects have read-only data attributes start, stop and step which
merely return the argument values (or their default). They have no other
explicit functionality; however they are used by Numerical Python and
other third party extensions. Slice objects are also generated when
extended indexing syntax is used. For example: "a[start:stop:step]"
or "a[start:stop, i]".
=cut
.sub 'slice'
.param pmc start #:optional?
.param pmc stop
.param pmc step :optional
$P0 = new 'Exception'
$P0 = 'NotImplementedError' # XXX
throw $P0
.end
=item sorted(iterable[, cmp[, key[, reverse]]])
Return a new sorted list from the items in iterable.
The optional arguments cmp, key, and reverse have the same meaning as those
for the list.sort() method (described in section 3.6.4).
cmp specifies a custom comparison function of two arguments (iterable elements)
which should return a negative, zero or positive number depending on whether
the first argument is considered smaller than, equal to, or larger than the
second argument: "cmp=lambda x,y: cmp(x.lower(), y.lower())"
key specifies a function of one argument that is used to extract a comparison
key from each list element: "key=str.lower"
reverse is a boolean value. If set to True, then the list elements are sorted
as if each comparison were reversed.
In general, the key and reverse conversion processes are much faster than
specifying an equivalent cmp function. This is because cmp is called multiple
times for each list element while key and reverse touch each element only once.
New in version 2.4.
=cut
.sub 'sorted'
.param pmc iterable
.param pmc cmp :optional
.param pmc key :optional
.param pmc reverse :optional
$P0 = new 'Exception'
$P0 = 'NotImplementedError' # XXX
throw $P0
.end
=item staticmethod(function)
Return a static method for function.
A static method does not receive an implicit first argument. To declare a
static method, use this idiom:
class C:
@staticmethod
def f(arg1, arg2, ...): ...
The @staticmethod form is a function decorator - see the description of
function definitions in chapter 7 of the Python Reference Manual for details.
It can be called either on the class (such as C.f()) or on an instance
(such as C().f()). The instance is ignored except for its class.
Static methods in Python are similar to those found in Java or C++.
For a more advanced concept, see classmethod() in this section.
For more information on static methods, consult the documentation on the
standard type hierarchy in chapter 3 of the Python Reference Manual
(at the bottom). New in version 2.2. Changed in version 2.4:
Function decorator syntax added.
=cut
.sub 'staticmethod'
.param pmc function
$P0 = new 'Exception'
$P0 = 'NotImplementedError' # XXX
throw $P0
.end
=item sum(sequence[, start])
Sums start and the items of a sequence, from left to right, and returns the
total. start defaults to 0. The sequence's items are normally numbers, and are
not allowed to be strings. The fast, correct way to concatenate sequence of
strings is by calling ''.join(sequence). Note that sum(range(n), m) is
equivalent to reduce(operator.add, range(n), m) New in version 2.3.
=cut
.sub 'sum'
.param pmc sequence
.param pmc start :optional
.param int has_start :opt_flag
.local num result
unless has_start goto no_start
result = start
goto setup_loop
no_start:
result = 0
setup_loop:
.local pmc iterator
iterator = iter sequence
.local int i
loop_check:
unless iterator goto loop_end
i = shift iterator
result += i
goto loop_check
loop_end:
.return (result)
.end
=item super(type[, object-or-type])
Return the superclass of type. If the second argument is omitted the super
object returned is unbound. If the second argument is an object,
isinstance(obj, type) must be true. If the second argument is a type,
issubclass(type2, type) must be true. super() only works for new-style classes.
A typical use for calling a cooperative superclass method is:
class C(B):
def meth(self, arg):
super(C, self).meth(arg)
Note that super is implemented as part of the binding process for explicit
dotted attribute lookups such as "super(C, self).__getitem__(name)".
Accordingly, super is undefined for implicit lookups using statements or
operators such as "super(C, self)[name]". New in version 2.2.
=cut
.sub 'super'
.param pmc type
.param pmc obj_or_type :optional
$P0 = new 'Exception'
$P0 = 'NotImplementedError' # XXX
throw $P0
.end
=item tuple([sequence])
Return a tuple whose items are the same and in the same order as sequence's
items. sequence may be a sequence, a container that supports iteration, or
an iterator object. If sequence is already a tuple, it is returned unchanged.
For instance, tuple('abc') returns ('a', 'b', 'c') and tuple([1, 2, 3])
returns (1, 2, 3). If no argument is given, returns a new empty tuple, ().
=cut
.sub 'tuple'
.param pmc sequence :optional
$P0 = new 'Exception'
$P0 = 'NotImplementedError' # XXX
throw $P0
.end
=item type(object)
Return the type of an object. The return value is a type object.
The isinstance() built-in function is recommended for testing the
type of an object.
With three arguments, type functions as a constructor as detailed below.
=cut
.sub 'type' :multi(pmc)
.param pmc obj
$P0 = typeof obj
.return ($P0)
.end
=item type(name, bases, dict)
Return a new type object. This is essentially a dynamic form of the class
statement. The name string is the class name and becomes the __name__
attribute; the bases tuple itemizes the base classes and becomes the
__bases__ attribute; and the dict dictionary is the namespace containing
definitions for class body and becomes the __dict__ attribute.
For example, the following two statements create identical type objects:
>>> class X(object):
... a = 1
...
>>> X = type('X', (object,), dict(a=1))
New in version 2.2.
=cut
.sub 'type' :multi(pmc, pmc, pmc)
.param pmc name
.param pmc bases
.param pmc dict
$P0 = new 'Exception'
$P0 = 'NotImplementedError' # XXX
throw $P0
.end
=item vars([object])
Without arguments, return a dictionary corresponding to the current
local symbol table. With a module, class or class instance object as
argument (or anything else that has a __dict__ attribute), returns a
dictionary corresponding to the object's symbol table. The returned
dictionary should not be modified: the effects on the corresponding
symbol table are undefined.2.4
=cut
.sub 'vars'
.param pmc obj :optional
$P0 = new 'Exception'
$P0 = 'NotImplementedError' # XXX
throw $P0
.end
=item zip([iterable, ...])
This function returns a list of tuples, where the i-th tuple contains the
i-th element from each of the argument sequences or iterables. The returned
list is truncated in length to the length of the shortest argument sequence.
When there are multiple arguments which are all of the same length, zip()
is similar to map() with an initial argument of None. With a single sequence
argument, it returns a list of 1-tuples. With no arguments, it returns an
empty list. New in version 2.0.
Changed in version 2.4: Formerly, zip() required at least one argument
and zip() raised a TypeError instead of returning an empty list.
=cut
.sub 'zip'
.param pmc iterable :optional
.param pmc args :slurpy
$P0 = new 'Exception'
$P0 = 'NotImplementedError' # XXX
throw $P0
.end
=back
=head1 AUTHOR
Pynie is authored and maintained by Patrick R. Michaud.
=cut
# Local Variables:
# mode: pir
# fill-column: 100
# End:
# vim: expandtab shiftwidth=4 ft=pir:
# Copyright (C) 2009, Bradley M. Kuhn
# License: Artistic-2.0-or-later
=head1 NAME
src/builtins/helper.pir - helper functions
=head1 Functions
=over 4
=cut
=item is_type_sub(val)
Returns true iff. the typeof the argument, val, is "Sub".
=cut
.sub 'is_type_sub'
.param pmc val
.local pmc valtype
typeof valtype, val
eq valtype, "Sub", return_true
.return(0)
return_true:
.return(1)
.end
=head1 NAME
src/builtins/inplace.pir - Inplace assignments
=head1 Functions
=over 4
=cut
.namespace []
.include 'cclass.pasm'
.sub 'print'
.param pmc args :slurpy
.param string end :named('end') :optional
.param int got_end :opt_flag
.local pmc iterator
.local string full_string, space
full_string = ''
space = ''
iterator = iter args
iter_loop:
unless iterator goto iter_end
$S0 = shift iterator
full_string .= space
full_string .= $S0
space = ' '
goto iter_loop
iter_end:
unless got_end goto add_newline
full_string .= end
goto no_newline
add_newline:
full_string .= "\n"
no_newline:
print full_string
.return ()
.end
=back
=cut
# Local Variables:
# mode: pir
# fill-column: 100
# End:
# vim: expandtab shiftwidth=4 ft=pir:
=head1 NAME
src/builtins/lists.pir - List operations
=head1 Functions
=over 4
=cut
.namespace []
.sub 'listmaker'
.param pmc args :slurpy
unless null args goto have_args
args = new [ 'list' ]
have_args:
.return (args)
.end
.sub 'tuplemaker'
.param pmc args :slurpy
.local pmc ret
ret = new 'FixedPMCArray'
if null args goto no_args
set ret, args
no_args:
.return (ret)
.end
.sub 'dictmaker'
.param pmc args :slurpy
.local pmc result
.local pmc iterator
.local pmc key, value
result = new [ 'dict' ]
if null args goto done
iterator = iter args
loop:
unless iterator goto done
key = shift iterator
value = shift iterator
result[key] = value
goto loop
done:
.return (result)
.end
=back
=head1 AUTHOR
Patrick Michaud <pmichaud at pobox.com> is the current author and
maintainer. Patches and suggestions can be sent to
<parrot-dev at lists.parrot.org> or <perl-compiler at perl.org> .
=cut
# Local Variables:
# mode: pir
# fill-column: 100
# End:
# vim: expandtab shiftwidth=4 ft=pir:
=head1 NAME
src/builtins/oper.pir - operators
=head1 Functions
=over 4
=cut
.namespace []
.sub 'infix:=='
.param pmc a
.param pmc b
$I0 = iseq a, b
.return ($I0)
.end
.sub 'infix:!='
.param pmc a
.param pmc b
$I0 = isne a, b
.return ($I0)
.end
.sub 'infix:<='
.param pmc a
.param pmc b
$I0 = isle a, b
.return ($I0)
.end
.sub 'infix:>='
.param pmc a
.param pmc b
$I0 = isge a, b
.return ($I0)
.end
.sub 'infix:<'
.param pmc a
.param pmc b
$I0 = islt a, b
.return ($I0)
.end
.sub 'infix:>'
.param pmc a
.param pmc b
$I0 = isgt a, b
.return ($I0)
.end
.sub 'prefix:+'
.param pmc n
.return (n)
.end
.sub 'prefix:++'
.param pmc n
inc n
.return (n)
.end
.sub 'prefix:--'
.param pmc n
dec n
.return (n)
.end
.sub 'postfix:++'
.param pmc n
$P0 = clone n
inc n
.return ($P0)
.end
.sub 'postfix:--'
.param pmc n
$P0 = clone n
dec n
.return ($P0)
.end
.sub 'infix:^'
.param int a
.param int b
$I0 = bxor a, b
.return ($I0)
.end
.sub 'infix:&'
.param int a
.param int b
$I0 = band a, b
.return ($I0)
.end
.sub 'infix:|'
.param int a
.param int b
$I0 = bor a, b
.return ($I0)
.end
.sub 'sqrt'
.param num n
n = sqrt n
.return (n)
.end
.sub 'scale'
.param pmc n
$S0 = n
$I0 = index $S0, '.'
if $I0 >= 0 goto nonzero
.return (0)
nonzero:
$I1 = length $S0
$I0 = $I1 - $I0
dec $I0
.return ($I0)
.end
.sub 'length'
.param pmc n
$S0 = n
$I0 = length $S0
$I1 = index $S0, '.'
if $I1 < 0 goto integer
dec $I0
integer:
.return ($I0)
.end
.sub 'saynum'
.param pmc n
print n
print "\n"
.end
.sub 'infix:**'
.param num a
.param num b
$N0 = pow a, b
.return($N0)
.end
=back
=head1 AUTHOR
Patrick Michaud <pmichaud at pobox.com> is the current author and
maintainer. Patches and suggestions can be sent to
<parrot-dev at lists.parrot.org> or <perl-compiler at perl.org> .
=cut
# Local Variables:
# mode: pir
# fill-column: 100
# End:
# vim: expandtab shiftwidth=4 ft=pir:
.sub '' :anon :init
# setup type Class
$P0 = newclass [ 'type' ]
addattribute $P0, '_class'
# XXX there should be a type object wrapping the type class
.end
.namespace [ 'type' ]
.sub 'make_type_object'
.param pmc _class
.local pmc init_args
init_args = new 'Hash'
init_args['_class'] = _class
$P1 = new [ 'type' ], init_args
.return ($P1)
.end
.sub 'wrap_class'
.param string name
.param pmc _class
.local pmc make_type_object
make_type_object = get_global 'make_type_object'
$P0 = make_type_object(_class)
set_hll_global name, $P0
.end
.sub 'invoke' :vtable
.param pmc args :slurpy
.param pmc kwargs :named :slurpy
$P0 = getattribute self, '_class'
# XXX $P1 should be an instance of self
$P1 = new $P0
$I0 = can $P1, '__init__'
unless $I0 goto done
$P1.'__init__'(args :flat, kwargs :flat)
done:
.return ($P1)
.end
.sub 'get_string' :vtable
$P0 = getattribute self, '_class'
$S0 = $P0.'name'()
$S1 = "<class '"
$S1 .= $S0
$S1 .= "'>"
.return ($S1)
.end
.namespace []
.sub '' :anon :init :load
$P0 = subclass 'ResizablePMCArray', [ 'list' ]
$P1 = get_global [ 'type' ], 'wrap_class'
$P1('list', $P0)
$P2 = get_class 'ResizablePMCArray'
$P1 = getinterp
$P1.'hll_map'($P2, $P0)
.end
.namespace [ 'list' ]
=item list([sequence])
Return a list whose items are the same and in the same order as sequence's items.
sequence may be either a sequence, a container that supports iteration, or an
iterator object. If sequence is already a list, a copy is made and returned,
similar to sequence[:]. For instance, list('abc') returns ['a', 'b', 'c'] and
list( (1, 2, 3) ) returns [1, 2, 3]. If no argument is given, returns a new
empty list, [].
=cut
.sub '__init__' :method
.param pmc sequence :optional
.param int has_seq :opt_flag
unless has_seq goto no_seq
self.'extend'(sequence)
no_seq:
# do nothing, just an empty list
.end
.sub 'get_string' :vtable
.local pmc iterator
.local string result
iterator = iter self
result = '['
unless iterator goto done
# first element separately, to handle commas properly
$P0 = shift iterator
$S0 = 'repr'($P0)
result .= $S0
loop:
unless iterator goto done
result .= ', '
$P0 = shift iterator
$S0 = 'repr'($P0)
result .= $S0
goto loop
done:
result .= ']'
.return (result)
.end
.sub 'is_equal' :vtable
.param pmc other
$I0 = isa other, [ 'list' ]
unless $I0 goto no
$I0 = elements self
$I1 = elements other
if $I0 != $I1 goto no
.local pmc i, j, item1, item2
i = iter self
j = iter other
loop:
# if no more elements and everything matched, then yes
unless i goto yes
item1 = shift i
item2 = shift j
if item1 != item2 goto no
goto loop
yes:
.return (1)
no:
.return (0)
.end
.sub 'append' :method
.param pmc x
push self, x
.end
.sub 'count' :method
.param pmc value
.local pmc ret, iterator
ret = new 'Integer'
ret = 0
iterator = iter self
loop:
unless iterator goto done
$P0 = shift iterator
if $P0 != value goto loop
inc ret
goto loop
done:
.return (ret)
.end
.sub 'extend' :method
.param pmc iterable
$I0 = elements self
splice self, iterable, $I0, 0
.end
.sub 'index' :method
.param pmc value
.param pmc start :optional
.param int has_start :opt_flag
.param pmc stop :optional
.param int has_stop :opt_flag
if has_start goto not_yet
if has_stop goto not_yet
.local pmc iterator
.local int idx
idx = -1
iterator = iter self
loop:
unless iterator goto not_found
inc idx
$P0 = shift iterator
unless $P0 == value goto loop
# found!
.return (idx)
not_found:
$P0 = new 'Exception'
$P0 = 'ValueError'
throw $P0
not_yet:
$P0 = new 'Exception'
$P0 = 'NotImplementedError' # XXX
throw $P0
.end
.sub 'insert' :method
.param pmc index
.param pmc object
$I0 = index
$P0 = new 'ResizablePMCArray'
push $P0, object
splice self, $P0, $I0, 0
.end
.sub 'pop' :method
.param int idx :optional
.param int has_idx :opt_flag
unless has_idx goto no_idx
$P1 = self[idx]
delete self[idx]
.return($P1)
no_idx:
$P1 = pop self
.return($P1)
.end
.sub 'remove' :method
.param pmc value
$I0 = self.'index'(value)
delete self[$I0]
.end
.sub 'reverse' :method
.local int i, j
.local pmc a, b
i = 0
j = elements self
dec j
loop:
if i >= j goto done
a = self[i]
b = self[j]
self[i] = b
self[j] = a
inc i
dec j
goto loop
done:
.end
.sub 'sort' :method
.param pmc key :named :optional
.param pmc reverse :named :optional
$P0 = new 'Exception'
$P0 = 'NotImplementedError' # XXX
throw $P0
.end
.namespace []
.sub '' :anon :init :load
$P0 = subclass 'String', [ 'str' ]
$P1 = get_global [ 'type' ], 'wrap_class'
$P1('str', $P0)
$P2 = get_class 'String'
$P1 = getinterp
$P1.'hll_map'($P2, $P0)
.end
.namespace [ 'str' ]
=item str([object])
Return a string containing a nicely printable representation of an object.
For strings, this returns the string itself. The difference with
repr(object) is that str(object) does not always attempt to return
a string that is acceptable to eval(); its goal is to return a
printable string. If no argument is given, returns the empty string, ''.
=cut
.sub '__init__' :method
.param pmc obj :optional
.param int has_obj :opt_flag
unless has_obj goto done
$S0 = obj
self = $S0
done:
.end
.sub '__repr__' :method
.local string result
result = "'"
# XXX escaping
$S0 = self
result .= $S0
result .= "'"
.return (result)
.end
.sub 'split' :method
.param pmc sep :optional :named('sep')
.param int has_sep :opt_flag
.param int maxsplit :optional :named('maxsplit')
.param int has_maxsplit :opt_flag
unless has_sep goto not_yet
if has_maxsplit goto not_yet
$S0 = sep
$S1 = self
$P0 = split $S0, $S1
# convert from ResizableStringArray to Pynie list
.tailcall 'listmaker'($P0 :flat)
not_yet:
$P0 = new 'Exception'
$P0 = 'NotImplementedError' # XXX
raise ($P0)
.end
.sub 'join' :method
.param pmc seq
$S0 = self
$S1 = join $S0, seq
.return ($S1)
.end
.namespace []
.sub '' :anon :init :load
$P0 = subclass 'Hash', [ 'dict' ]
# $P1 = get_global [ 'type' ], 'wrap_class'
# $P1('dict', $P0)
# $P2 = get_class 'Hash'
# $P1 = getinterp
# $P1.'hll_map'($P2, $P0)
.end
.namespace [ 'dict' ]
.sub 'get_string' :vtable
.local pmc iterator
.local string result
iterator = iter self
result = '{'
unless iterator goto done
# first element separately, to handle commas properly
$S0 = shift iterator
$P0 = self[$S0]
$S1 = 'repr'($S0)
result .= $S1
result .= ': '
$S1 = 'repr'($P0)
result .= $S1
loop:
unless iterator goto done
result .= ', '
$S0 = shift iterator
$P0 = self[$S0]
$S1 = 'repr'($S0)
result .= $S1
result .= ':'
$S1 = 'repr'($P0)
result .= $S1
goto loop
done:
result .= '}'
.return (result)
.end
.sub 'keys' :method
.local pmc ret, iterator
ret = new 'list'
iterator = iter self
loop:
unless iterator goto done
$S0 = shift iterator
push ret, $S0
goto loop
done:
.return (ret)
.end
# Local Variables:
# mode: pir
# fill-column: 100
# End:
# vim: expandtab shiftwidth=4 ft=pir:
More information about the parrot-dev
mailing list