.github/workflows/main.yml

@@ -70,7 +70,6 @@ jobs:
       if: github.ref == 'refs/heads/main'
     - name: Compile and Test
       run: |
-        python scripts/check_pragma_once.py include
         mkdir -p output/x86_64
         python cmake_build.py
         python scripts/run_tests.py

CMakeLists.txt

@@ -5,11 +5,15 @@ project(pocketpy)
 set(CMAKE_C_STANDARD 11)
 set(CMAKE_C_STANDARD_REQUIRED ON)
 
-# use UNITY_BUILD if CMake version >= 3.16
+# use IPO
-if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.16")
+option(PK_BUILD_WITH_IPO "" TRUE)
-    option(PK_BUILD_WITH_UNITY "" TRUE)
+include(CheckIPOSupported)
+check_ipo_supported(RESULT result)
+
+if(result AND PK_BUILD_WITH_IPO)
+    set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
 else()
-    option(PK_BUILD_WITH_UNITY "" FALSE)
+    message(WARNING ">> IPO disabled. You will not get the best performance.")
 endif()
 
 if(WIN32)
@@ -90,20 +94,13 @@ else()
     target_link_libraries(main ${PROJECT_NAME})
 endif()
 
-if(UNIX AND NOT APPLE)
+if(UNIX)
     target_link_libraries(${PROJECT_NAME} m)
     if(PK_ENABLE_OS)
         target_link_libraries(${PROJECT_NAME} dl)
     endif()
 endif()
 
-if(PK_BUILD_WITH_UNITY)
-    set_source_files_properties(${POCKETPY_SRC} PROPERTIES UNITY_GROUP "pocketpy")
-    set_target_properties(${PROJECT_NAME} PROPERTIES UNITY_BUILD_MODE GROUP)
-    set_target_properties(${PROJECT_NAME} PROPERTIES UNITY_BUILD ON)
-endif()
-
-############################################
 if(PK_BUILD_MODULE_LZ4)
     target_link_libraries(${PROJECT_NAME} lz4)
 endif()

build_ios.sh

@@ -8,7 +8,10 @@ cd build
 
 FLAGS="-DCMAKE_TOOLCHAIN_FILE=3rd/ios.toolchain.cmake \
     -DDEPLOYMENT_TARGET=13.0 \
-    -DPK_BUILD_STATIC_LIB=ON"
+    -DPK_BUILD_STATIC_LIB=ON \
+    -DPK_BUILD_WITH_IPO=OFF \
+    -DPK_BUILD_MODULE_LZ4=ON \
+    -DPK_BUILD_MODULE_LIBHV=ON"
 
 cmake -B os64 -G Xcode $FLAGS -DPLATFORM=OS64 ..
 cmake --build os64 --config Release

docs/coding-style-guide.md

@@ -1,221 +0,0 @@
----
-icon: book
-order: -5
-label: Coding Style Guide
----
-
-## Indentation
-
-Use four spaces for indentation. Do not use `TAB`.
-
-## Strings
-
-```python
-# Prefer single quotes for strings
-s = 'this is a string'
-
-# Use double quotes only if the string itself contains a single quote
-s = "this ' is single quote"
-```
-
-## Docstrings
-
-Always use triple quotes for docstrings.
-
-```python
-def f():
-    """This is a multi-line docstring.
-
-    Here is some content. Docstrings partially support Markdown.
-    """
-
-def g():
-    """This is a single-line docstring."""
-```
-
-Use natural language to describe the function's purpose. Do not enumerate each parameter and return value.
-
-```python
-# Correct
-def add(a: int, b: int):
-    """Add two integers `a` and `b`."""
-
-# Incorrect
-def add(a: int, b: int):
-    """
-    @param a, the first argument
-    @param b, the second argument
-    @return, the result of a + b
-    """
-```
-
-## Spaces
-
-```python
-# Add a space after `,` or `:`
-a, b = 1, 2
-c = [1, 2, 3]
-d = {'key': 'value'}
-
-# Spaces may be added around operators
-res = 1 + 2
-if res < 2: pass
-# Spaces can also be selectively added to indicate operator precedence
-x = x * 2 - 1
-hypot2 = x * x + y * y
-c = (a + b) * (a - b)
-
-# Add a space after `:` in type annotations
-def f(a: int, b: float): ...
-def g() -> int: ...
-
-# Add spaces around `=` when specifying default values in function parameters
-def f(a: int = 1, b: int | None = None): ...
-# However, omit spaces if the parameter has no type annotation
-def f(a=1, b=2): pass
-
-# Do not add spaces in keyword arguments when calling functions
-print(1, 2, 3, end='', sep=',')
-f(a=10, b=20)
-```
-
-## Naming Conventions
-
-+ Classes: `CapitalizedWords`
-+ Functions and variables: `lower_case_with_underscores`
-+ Constants and enums: `UPPER_CASE_WITH_UNDERSCORES` or `CapitalizedWords`
-+ Anonymous ordered variables: `_0`, `_1`, `_2`
-+ Discarded variables: `_`
-+ Some standard library functions: `lowercase`
-
-Here are some commonly used naming conventions:
-+ `self`: The first parameter of an instance method
-+ `cls`: The first parameter of class methods and `__new__`
-
-### Using Abbreviations
-
-Use abbreviations only for temporary variables and internal implementations.
-
-Abbreviations should be well-established, include key syllables of the original word, and be immediately recognizable.
-
-* `context` -> `ctx` (✔)
-* `temporary` -> `tmp` (✔)
-* `distribution` -> `dist` (✔)
-* `visited` -> `vis` (❌)
-
-```python
-# Incorrect: Using abbreviations in public function parameters
-def some_pub_fn(ctx, req_id, data):
-    pass
-
-# Correct
-def some_public_function(context, request_id, data):
-    pass
-```
-
-### Using Precise Terminology
-
-Naming should convey precise meanings, especially when multiple synonyms exist.
-
-For example, `count`, `size`, and `length` all relate to quantity, but they have different nuances:
-
-+ `count`: Represents a counted value
-+ `length`: Represents the number of elements in a container
-+ `size`: Represents the byte size of an object
-
-```python
-s = 'aaabc⭐'
-count = s.count('a')
-length = len(s)
-size = len(s.encode())
-
-print(f"{s!r} has a length of {length}, a size of {size} bytes, and contains {count} occurrences of 'a'")
-# 'aaabc⭐' has a length of 6, a size of 8 bytes, and contains 3 occurrences of 'a'
-```
-
-### Using Professional Terminology
-
-+ For item quantities in a game: `quantity` is better than `item_count`
-+ For grid counts: `area` (meaning surface area) is better than `grid_count`
-
-### Avoiding Built-in Names
-
-```python
-# Incorrect: Overwriting `builtins.map`
-map = [[1, 2, 3], [4, 5, 6]]
-# Incorrect: Overwriting `builtins.type`
-type = some_thing.type
-```
-
-### Internal Functions and Classes
-
-Use a single underscore `_` as a prefix for internal functions. Never use a double underscore `__` (except for magic methods).
-
-```python
-def _internal_func():
-    """This is an internal function."""
-
-class _InternalClass:
-    def _internal_f(self): pass
-```
-
-## Importing Modules
-
-1. Import standard library modules first.
-2. Then import third-party dependencies.
-3. Finally, import project-specific modules.
-
-```python
-from typing import Any
-from collections import deque
-
-from array2d import array2d
-
-from ..utils import logger
-```
-
-## Coding Practices
-
-Use `is not` when checking for `None`. Do not explicitly compare with `True` or `False`.
-
-```python
-# Correct
-if x is not None: pass
-
-# Incorrect
-if x != None: pass
-
-# Correct
-x = True
-if x: pass
-if not x: pass
-
-# Incorrect
-if x == True: pass
-if x is True: pass
-if x != False: pass
-```
-
-The `if` statement implicitly calls `bool()`, so it can be used to check if a container is empty.
-
-```python
-not_empty_list = [1]
-not_empty_string = '1'
-truth = True
-
-if not_empty_list:
-    print('true value')
-
-if not_empty_string:
-    print('true value')
-
-if truth:
-    print('true value')
-
-# Explicitly checking for emptiness is also valid
-if len(not_empty_list) > 0: pass
-```
-
-## References
-
-[PEP 8 – Style Guide for Python Code](https://peps.python.org/pep-0008/)

docs/gsoc2024/guide.md

@@ -49,7 +49,7 @@ Type "exit()" to exit.
 
 ### Coding style guide
 
-See [Coding Style Guide](../coding-style-guide.md).
+See [Coding Style Guide](../coding_style_guide.md).
 
 ### Contact us
 

docs/gsoc2025/guide.md

@@ -49,7 +49,7 @@ Type "exit()" to exit.
 
 ### Coding style guide
 
-See [Coding Style Guide](../coding-style-guide.md).
+See [Coding Style Guide](../coding_style_guide.md).
 
 ### Contact us
 

include/pocketpy/interpreter/heap.h

@@ -1,5 +1,3 @@
-#pragma once
-
 #include "pocketpy/objects/object.h"
 #include "pocketpy/interpreter/objectpool.h"
 

plugins/flutter/pocketpy/lib/pocketpy_bindings_generated.dart

@@ -269,6 +269,7 @@ class PocketpyBindings {
       _py_newglobalsPtr.asFunction<void Function(py_OutRef)>();
 
   /// Python equivalent to `locals()`.
+  /// @return a temporary object, which expires on the associated function return.
   void py_newlocals(
     py_OutRef arg0,
   ) {
@@ -420,23 +421,6 @@ class PocketpyBindings {
   late final _py_newstrv =
       _py_newstrvPtr.asFunction<void Function(py_OutRef, c11_sv)>();
 
-  /// Create a formatted `str` object.
-  void py_newfstr(
-    py_OutRef arg0,
-    ffi.Pointer<ffi.Char> arg1,
-  ) {
-    return _py_newfstr(
-      arg0,
-      arg1,
-    );
-  }
-
-  late final _py_newfstrPtr = _lookup<
-      ffi.NativeFunction<
-          ffi.Void Function(py_OutRef, ffi.Pointer<ffi.Char>)>>('py_newfstr');
-  late final _py_newfstr = _py_newfstrPtr
-      .asFunction<void Function(py_OutRef, ffi.Pointer<ffi.Char>)>();
-
   /// Create a `bytes` object with `n` UNINITIALIZED bytes.
   ffi.Pointer<ffi.UnsignedChar> py_newbytes(
     py_OutRef arg0,
@@ -515,7 +499,7 @@ class PocketpyBindings {
 
   /// Create a `tuple` with `n` UNINITIALIZED elements.
   /// You should initialize all elements before using it.
-  py_ObjectRef py_newtuple(
+  void py_newtuple(
     py_OutRef arg0,
     int n,
   ) {
@@ -526,10 +510,10 @@ class PocketpyBindings {
   }
 
   late final _py_newtuplePtr =
-      _lookup<ffi.NativeFunction<py_ObjectRef Function(py_OutRef, ffi.Int)>>(
+      _lookup<ffi.NativeFunction<ffi.Void Function(py_OutRef, ffi.Int)>>(
           'py_newtuple');
   late final _py_newtuple =
-      _py_newtuplePtr.asFunction<py_ObjectRef Function(py_OutRef, int)>();
+      _py_newtuplePtr.asFunction<void Function(py_OutRef, int)>();
 
   /// Create an empty `list`.
   void py_newlist(
@@ -683,21 +667,6 @@ class PocketpyBindings {
   late final _py_name2str =
       _py_name2strPtr.asFunction<ffi.Pointer<ffi.Char> Function(int)>();
 
-  /// Convert a name to a python `str` object with cache.
-  py_GlobalRef py_name2ref(
-    int arg0,
-  ) {
-    return _py_name2ref(
-      arg0,
-    );
-  }
-
-  late final _py_name2refPtr =
-      _lookup<ffi.NativeFunction<py_GlobalRef Function(py_Name)>>(
-          'py_name2ref');
-  late final _py_name2ref =
-      _py_name2refPtr.asFunction<py_GlobalRef Function(int)>();
-
   /// Convert a `c11_sv` to a name.
   int py_namev(
     c11_sv arg0,
@@ -1163,7 +1132,7 @@ class PocketpyBindings {
   late final _py_tpcall =
       _py_tpcallPtr.asFunction<bool Function(int, int, py_Ref)>();
 
-  /// Check if the object is an instance of the given type exactly.
+  /// Check if the object is an instance of the given type.
   /// Raise `TypeError` if the check fails.
   bool py_checktype(
     py_Ref self,
@@ -1181,24 +1150,6 @@ class PocketpyBindings {
   late final _py_checktype =
       _py_checktypePtr.asFunction<bool Function(py_Ref, int)>();
 
-  /// Check if the object is an instance of the given type or its subclass.
-  /// Raise `TypeError` if the check fails.
-  bool py_checkinstance(
-    py_Ref self,
-    int type,
-  ) {
-    return _py_checkinstance(
-      self,
-      type,
-    );
-  }
-
-  late final _py_checkinstancePtr =
-      _lookup<ffi.NativeFunction<ffi.Bool Function(py_Ref, py_Type)>>(
-          'py_checkinstance');
-  late final _py_checkinstance =
-      _py_checkinstancePtr.asFunction<bool Function(py_Ref, int)>();
-
   /// Get the i-th register.
   /// All registers are located in a contiguous memory.
   py_GlobalRef py_getreg(
@@ -2900,9 +2851,6 @@ final class c11_vec2i extends ffi.Union {
 
   @ffi.Array.multi([2])
   external ffi.Array<ffi.Int> data;
-
-  @ffi.Int64()
-  external int _i64;
 }
 
 final class UnnamedStruct1 extends ffi.Struct {
@@ -3024,9 +2972,6 @@ final class py_Callbacks extends ffi.Struct {
   external ffi
       .Pointer<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Char>)>>
       print;
-
-  /// Used by `input` to get a character.
-  external ffi.Pointer<ffi.NativeFunction<ffi.Int Function()>> getchar;
 }
 
 /// Python compiler modes.
@@ -3054,9 +2999,6 @@ typedef py_i64 = ffi.Int64;
 /// A 64-bit floating-point type. Corresponds to `float` in python.
 typedef py_f64 = ffi.Double;
 
-/// A reference which has the same lifespan as the python object.
-typedef py_ObjectRef = ffi.Pointer<py_TValue>;
-
 /// Native function signature.
 /// @param argc number of arguments.
 /// @param argv array of arguments. Use `py_arg(i)` macro to get the i-th argument.
@@ -3081,6 +3023,9 @@ typedef py_Dtor
 /// An item reference to a container object. It invalidates when the container is modified.
 typedef py_ItemRef = ffi.Pointer<py_TValue>;
 
+/// A reference which has the same lifespan as the python object.
+typedef py_ObjectRef = ffi.Pointer<py_TValue>;
+
 /// Python favored string formatting.
 /// %d: int
 /// %i: py_i64 (int64_t)
@@ -3257,20 +3202,17 @@ abstract class py_PredefinedTypes {
   static const int tp_mat3x3 = 57;
 
   /// array2d
-  static const int tp_array2d_like = 58;
+  static const int tp_array2d = 58;
-  static const int tp_array2d_like_iterator = 59;
+  static const int tp_array2d_iterator = 59;
-  static const int tp_array2d = 60;
-  static const int tp_array2d_view = 61;
-  static const int tp_chunked_array2d = 62;
 }
 
-const String PK_VERSION = '2.0.6';
+const String PK_VERSION = '2.0.5';
 
 const int PK_VERSION_MAJOR = 2;
 
 const int PK_VERSION_MINOR = 0;
 
-const int PK_VERSION_PATCH = 6;
+const int PK_VERSION_PATCH = 5;
 
 const int PK_LOW_MEMORY_MODE = 0;
 

scripts/check_pragma_once.py

@@ -1,20 +0,0 @@
-import os
-import sys
-
-def check_pragma_once_in_dir(path):
-    for root, dirs, files in os.walk(path):
-        if 'include/pocketpy/xmacros' in root or 'include/pybind11' in root:
-            continue
-        for file in files:
-            if file.endswith(".c") or file.endswith(".h"):
-                with open(os.path.join(root, file), "r", encoding='utf-8') as f:
-                    print(f"==> {os.path.join(root, file)}")
-                    text = f.read()
-                    assert text.count("#pragma once") == 1, "#pragma once should appear exactly once"
-
-if __name__ == "__main__":
-    if len(sys.argv) < 2:
-        print("Usage: python scripts/check_pragma_once.py <path>")
-        sys.exit(1)
-
-    check_pragma_once_in_dir(sys.argv[1])

src/compiler/compiler.c

@@ -2858,6 +2858,7 @@ const static PrattRule rules[TK__COUNT__] = {
 };
 // clang-format on
 
+#undef static_assert_expr_size
 #undef vtcall
 #undef vtemit_
 #undef vtemit_del