mirror of
https://github.com/pocketpy/pocketpy
synced 2025-10-26 14:30:17 +00:00
170 lines
4.0 KiB
Markdown
170 lines
4.0 KiB
Markdown
---
|
|
title: Stack Manipulation
|
|
icon: dot
|
|
order: 8
|
|
---
|
|
|
|
### Basic manipulation
|
|
|
|
+ `bool pkpy_dup(pkpy_vm*, int)`
|
|
|
|
Duplicate the value at the given index.
|
|
|
|
+ `bool pkpy_pop(pkpy_vm*, int)`
|
|
|
|
Pop `n` values from the stack.
|
|
|
|
+ `bool pkpy_pop_top(pkpy_vm*)`
|
|
|
|
Pop the top value from the stack.
|
|
|
|
+ `bool pkpy_dup_top(pkpy_vm*)`
|
|
|
|
Duplicate the top value on the stack.
|
|
|
|
+ `bool pkpy_rot_two(pkpy_vm*)`
|
|
|
|
Swap the top two values on the stack.
|
|
|
|
+ `int pkpy_stack_size(pkpy_vm*)`
|
|
|
|
Get the element count of the stack.
|
|
|
|
|
|
### Basic push, check and convert
|
|
|
|
+ `pkpy_push_xxx` pushes a value onto the stack.
|
|
+ `pkpy_is_xxx` checks if the value at the given index is of the given type.
|
|
+ `pkpy_to_xxx` converts the value at the given index to the given type.
|
|
|
|
Stack index is 0-based instead of 1-based. And it can be negative, which means the index is counted from the top of the stack.
|
|
|
|
```c
|
|
// int
|
|
PK_EXPORT bool pkpy_push_int(pkpy_vm*, int);
|
|
PK_EXPORT bool pkpy_is_int(pkpy_vm*, int i);
|
|
PK_EXPORT bool pkpy_to_int(pkpy_vm*, int i, int* out);
|
|
|
|
// float
|
|
PK_EXPORT bool pkpy_push_float(pkpy_vm*, double);
|
|
PK_EXPORT bool pkpy_is_float(pkpy_vm*, int i);
|
|
PK_EXPORT bool pkpy_to_float(pkpy_vm*, int i, double* out);
|
|
|
|
// bool
|
|
PK_EXPORT bool pkpy_push_bool(pkpy_vm*, bool);
|
|
PK_EXPORT bool pkpy_is_bool(pkpy_vm*, int i);
|
|
PK_EXPORT bool pkpy_to_bool(pkpy_vm*, int i, bool* out);
|
|
|
|
// string
|
|
PK_EXPORT bool pkpy_push_string(pkpy_vm*, pkpy_CString);
|
|
PK_EXPORT bool pkpy_is_string(pkpy_vm*, int i);
|
|
PK_EXPORT bool pkpy_to_string(pkpy_vm*, int i, pkpy_CString* out);
|
|
|
|
// void_p
|
|
PK_EXPORT bool pkpy_push_voidp(pkpy_vm*, void*);
|
|
PK_EXPORT bool pkpy_is_voidp(pkpy_vm*, int i);
|
|
PK_EXPORT bool pkpy_to_voidp(pkpy_vm*, int i, void** out);
|
|
|
|
// none
|
|
PK_EXPORT bool pkpy_push_none(pkpy_vm*);
|
|
PK_EXPORT bool pkpy_is_none(pkpy_vm*, int i);
|
|
```
|
|
|
|
### Special push
|
|
|
|
+ `pkpy_push_null(pkpy_vm*)`
|
|
|
|
Push a `PY_NULL` onto the stack. It is used for `pkpy_vectorcall`.
|
|
|
|
+ `pkpy_push_function(pkpy_vm*, const char* sig, pkpy_CFunction f)`
|
|
|
|
Push a function onto the stack. `sig` is the function signature, e.g. `add(a: int, b: int) -> int`. `f` is the function pointer.
|
|
|
|
+ `pkpy_push_module(pkpy_vm*, const char* name)`
|
|
|
|
Push a new module onto the stack. `name` is the module name. This is not `import`. It creates a new module object.
|
|
|
|
### Variable access
|
|
|
|
+ `bool pkpy_getattr(pkpy_vm*, pkpy_CName name)`
|
|
|
|
Push `b.<name>` onto the stack. Return false if the attribute is not found.
|
|
|
|
```
|
|
[b] -> [b.<name>]
|
|
```
|
|
|
|
+ `bool pkpy_setattr(pkpy_vm*, pkpy_CName name)`
|
|
|
|
Set `b.<name>` to the value at the top of the stack.
|
|
First push the value, then push `b`.
|
|
|
|
```
|
|
[value, b] -> []
|
|
```
|
|
|
|
+ `bool pkpy_getglobal(pkpy_vm*, pkpy_CName name)`
|
|
|
|
Push a global/builtin variable onto the stack. Return false if the variable is not found.
|
|
|
|
```
|
|
[] -> [value]
|
|
```
|
|
|
|
+ `bool pkpy_setglobal(pkpy_vm*, pkpy_CName name)`
|
|
|
|
Set a global variable to the value at the top of the stack.
|
|
|
|
```
|
|
[value] -> []
|
|
```
|
|
|
|
+ `bool pkpy_eval(pkpy_vm*, const char* source)`
|
|
|
|
Evaluate a string and push the result onto the stack.
|
|
|
|
```
|
|
[] -> [result]
|
|
```
|
|
|
|
+ `bool pkpy_unpack_sequence(pkpy_vm*, int size)`
|
|
|
|
Unpack a sequence at the top of the stack. `size` is the element count of the sequence.
|
|
|
|
```
|
|
[a] -> [a[0], a[1], ..., a[size - 1]]
|
|
```
|
|
|
|
+ `bool pkpy_get_unbound_method(pkpy_vm*, pkpy_CName name)`
|
|
|
|
It is used for method call.
|
|
Get an unbound method from the object at the top of the stack. `name` is the method name.
|
|
Also push the object as self.
|
|
|
|
```
|
|
[obj] -> [obj.<name> self]
|
|
```
|
|
+ `bool pkpy_py_repr(pkpy_vm*)`
|
|
|
|
Get the repr of the value at the top of the stack.
|
|
|
|
```
|
|
[value] -> [repr(value)]
|
|
```
|
|
|
|
+ `bool pkpy_py_str(pkpy_vm*)`
|
|
|
|
Get the str of the value at the top of the stack.
|
|
|
|
```
|
|
[value] -> [str(value)]
|
|
```
|
|
|
|
+ `bool pkpy_py_import(pkpy_vm*, const char* name)`
|
|
|
|
Import a module and push it onto the stack.
|
|
|
|
```
|
|
[] -> [module]
|
|
```
|