Add pre-installed python packages within rootfs overlay

TODO: This is just a quick fix and need to be changed to
buildroot packages in the upcoming days/weeks/months.

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/ArithmeticError.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_ARITHMETICERROR_HPP
+#define PYTHONIC_BUILTIN_ARITHMETICERROR_HPP
+
+#include "pythonic/include/builtins/ArithmeticError.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(ArithmeticError)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/AssertionError.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_ASSERTIONERROR_HPP
+#define PYTHONIC_BUILTIN_ASSERTIONERROR_HPP
+
+#include "pythonic/include/builtins/AssertionError.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(AssertionError)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/AttributeError.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_ATTRIBUTEERROR_HPP
+#define PYTHONIC_BUILTIN_ATTRIBUTEERROR_HPP
+
+#include "pythonic/include/builtins/AttributeError.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(AttributeError)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/BaseException.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_BASEEXCEPTION_HPP
+#define PYTHONIC_BUILTIN_BASEEXCEPTION_HPP
+
+#include "pythonic/include/builtins/BaseException.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(BaseException)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/BufferError.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_BUFFERERROR_HPP
+#define PYTHONIC_BUILTIN_BUFFERERROR_HPP
+
+#include "pythonic/include/builtins/BufferError.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(BufferError)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/BytesWarning.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_BYTESWARNING_HPP
+#define PYTHONIC_BUILTIN_BYTESWARNING_HPP
+
+#include "pythonic/include/builtins/BytesWarning.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(BytesWarning)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/DeprecationWarning.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_DEPRECATIONWARNING_HPP
+#define PYTHONIC_BUILTIN_DEPRECATIONWARNING_HPP
+
+#include "pythonic/include/builtins/DeprecationWarning.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(DeprecationWarning)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/EOFError.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_EOFERROR_HPP
+#define PYTHONIC_BUILTIN_EOFERROR_HPP
+
+#include "pythonic/include/builtins/EOFError.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(EOFError)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/EnvironmentError.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_ENVIRONMENTERROR_HPP
+#define PYTHONIC_BUILTIN_ENVIRONMENTERROR_HPP
+
+#include "pythonic/include/builtins/EnvironmentError.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(EnvironmentError)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/Exception.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_EXCEPTION_HPP
+#define PYTHONIC_BUILTIN_EXCEPTION_HPP
+
+#include "pythonic/include/builtins/Exception.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(Exception)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/False.hpp

@@ -0,0 +1,6 @@
+#ifndef PYTHONIC_BUILTIN_FALSE_HPP
+#define PYTHONIC_BUILTIN_FALSE_HPP
+
+#include "pythonic/include/builtins/False.hpp"
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/FileNotFoundError.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_FILENOTFOUNDERROR_HPP
+#define PYTHONIC_BUILTIN_FILENOTFOUNDERROR_HPP
+
+#include "pythonic/include/builtins/FileNotFoundError.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(FileNotFoundError)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/FloatingPointError.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_FLOATINGPOINTERROR_HPP
+#define PYTHONIC_BUILTIN_FLOATINGPOINTERROR_HPP
+
+#include "pythonic/include/builtins/FloatingPointError.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(FloatingPointError)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/FutureWarning.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_FUTUREWARNING_HPP
+#define PYTHONIC_BUILTIN_FUTUREWARNING_HPP
+
+#include "pythonic/include/builtins/FutureWarning.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(FutureWarning)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/GeneratorExit.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_GENERATOREXIT_HPP
+#define PYTHONIC_BUILTIN_GENERATOREXIT_HPP
+
+#include "pythonic/include/builtins/GeneratorExit.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(GeneratorExit)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/IOError.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_IOERROR_HPP
+#define PYTHONIC_BUILTIN_IOERROR_HPP
+
+#include "pythonic/include/builtins/IOError.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(IOError)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/ImportError.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_IMPORTERROR_HPP
+#define PYTHONIC_BUILTIN_IMPORTERROR_HPP
+
+#include "pythonic/include/builtins/ImportError.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(ImportError)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/ImportWarning.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_IMPORTWARNING_HPP
+#define PYTHONIC_BUILTIN_IMPORTWARNING_HPP
+
+#include "pythonic/include/builtins/ImportWarning.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(ImportWarning)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/IndentationError.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_INDENTATIONERROR_HPP
+#define PYTHONIC_BUILTIN_INDENTATIONERROR_HPP
+
+#include "pythonic/include/builtins/IndentationError.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(IndentationError)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/IndexError.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_INDEXERROR_HPP
+#define PYTHONIC_BUILTIN_INDEXERROR_HPP
+
+#include "pythonic/include/builtins/IndexError.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(IndexError)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/KeyError.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_KEYERROR_HPP
+#define PYTHONIC_BUILTIN_KEYERROR_HPP
+
+#include "pythonic/include/builtins/KeyError.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(KeyError)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/KeyboardInterrupt.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_KEYBOARDINTERRUPT_HPP
+#define PYTHONIC_BUILTIN_KEYBOARDINTERRUPT_HPP
+
+#include "pythonic/include/builtins/KeyboardInterrupt.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(KeyboardInterrupt)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/LookupError.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_LOOKUPERROR_HPP
+#define PYTHONIC_BUILTIN_LOOKUPERROR_HPP
+
+#include "pythonic/include/builtins/LookupError.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(LookupError)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/MemoryError.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_MEMORYERROR_HPP
+#define PYTHONIC_BUILTIN_MEMORYERROR_HPP
+
+#include "pythonic/include/builtins/MemoryError.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(MemoryError)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/NameError.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_NAMEERROR_HPP
+#define PYTHONIC_BUILTIN_NAMEERROR_HPP
+
+#include "pythonic/include/builtins/NameError.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(NameError)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/None.hpp

@@ -0,0 +1,6 @@
+#ifndef PYTHONIC_BUILTIN_NONE_HPP
+#define PYTHONIC_BUILTIN_NONE_HPP
+
+#include "pythonic/include/builtins/None.hpp"
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/NotImplementedError.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_NOTIMPLEMENTEDERROR_HPP
+#define PYTHONIC_BUILTIN_NOTIMPLEMENTEDERROR_HPP
+
+#include "pythonic/include/builtins/NotImplementedError.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(NotImplementedError)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/OSError.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_OSERROR_HPP
+#define PYTHONIC_BUILTIN_OSERROR_HPP
+
+#include "pythonic/include/builtins/OSError.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(OSError)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/OverflowError.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_OVERFLOWERROR_HPP
+#define PYTHONIC_BUILTIN_OVERFLOWERROR_HPP
+
+#include "pythonic/include/builtins/OverflowError.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(OverflowError)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/PendingDeprecationWarning.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_PENDINGDEPRECATIONWARNING_HPP
+#define PYTHONIC_BUILTIN_PENDINGDEPRECATIONWARNING_HPP
+
+#include "pythonic/include/builtins/PendingDeprecationWarning.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(PendingDeprecationWarning)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/ReferenceError.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_REFERENCEERROR_HPP
+#define PYTHONIC_BUILTIN_REFERENCEERROR_HPP
+
+#include "pythonic/include/builtins/ReferenceError.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(ReferenceError)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/RuntimeError.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_RUNTIMEERROR_HPP
+#define PYTHONIC_BUILTIN_RUNTIMEERROR_HPP
+
+#include "pythonic/include/builtins/RuntimeError.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(RuntimeError)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/RuntimeWarning.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_RUNTIMEWARNING_HPP
+#define PYTHONIC_BUILTIN_RUNTIMEWARNING_HPP
+
+#include "pythonic/include/builtins/RuntimeWarning.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(RuntimeWarning)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/StopIteration.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_STOPITERATION_HPP
+#define PYTHONIC_BUILTIN_STOPITERATION_HPP
+
+#include "pythonic/include/builtins/StopIteration.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(StopIteration)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/SyntaxError.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_SYNTAXERROR_HPP
+#define PYTHONIC_BUILTIN_SYNTAXERROR_HPP
+
+#include "pythonic/include/builtins/SyntaxError.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(SyntaxError)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/SyntaxWarning.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_SYNTAXWARNING_HPP
+#define PYTHONIC_BUILTIN_SYNTAXWARNING_HPP
+
+#include "pythonic/include/builtins/SyntaxWarning.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(SyntaxWarning)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/SystemError.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_SYSTEMERROR_HPP
+#define PYTHONIC_BUILTIN_SYSTEMERROR_HPP
+
+#include "pythonic/include/builtins/SystemError.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(SystemError)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/SystemExit.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_SYSTEMEXIT_HPP
+#define PYTHONIC_BUILTIN_SYSTEMEXIT_HPP
+
+#include "pythonic/include/builtins/SystemExit.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(SystemExit)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/TabError.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_TABERROR_HPP
+#define PYTHONIC_BUILTIN_TABERROR_HPP
+
+#include "pythonic/include/builtins/TabError.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(TabError)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/True.hpp

@@ -0,0 +1,6 @@
+#ifndef PYTHONIC_BUILTIN_TRUE_HPP
+#define PYTHONIC_BUILTIN_TRUE_HPP
+
+#include "pythonic/include/builtins/True.hpp"
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/TypeError.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_TYPEERROR_HPP
+#define PYTHONIC_BUILTIN_TYPEERROR_HPP
+
+#include "pythonic/include/builtins/TypeError.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(TypeError)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/UnboundLocalError.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_UNBOUNDLOCALERROR_HPP
+#define PYTHONIC_BUILTIN_UNBOUNDLOCALERROR_HPP
+
+#include "pythonic/include/builtins/UnboundLocalError.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(UnboundLocalError)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/UnicodeError.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_UNICODEERROR_HPP
+#define PYTHONIC_BUILTIN_UNICODEERROR_HPP
+
+#include "pythonic/include/builtins/UnicodeError.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(UnicodeError)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/UnicodeWarning.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_UNICODEWARNING_HPP
+#define PYTHONIC_BUILTIN_UNICODEWARNING_HPP
+
+#include "pythonic/include/builtins/UnicodeWarning.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(UnicodeWarning)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/UserWarning.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_USERWARNING_HPP
+#define PYTHONIC_BUILTIN_USERWARNING_HPP
+
+#include "pythonic/include/builtins/UserWarning.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(UserWarning)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/ValueError.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_VALUEERROR_HPP
+#define PYTHONIC_BUILTIN_VALUEERROR_HPP
+
+#include "pythonic/include/builtins/ValueError.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(ValueError)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/Warning.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_WARNING_HPP
+#define PYTHONIC_BUILTIN_WARNING_HPP
+
+#include "pythonic/include/builtins/Warning.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(Warning)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/ZeroDivisionError.hpp

@@ -0,0 +1,17 @@
+#ifndef PYTHONIC_BUILTIN_ZERODIVISIONERROR_HPP
+#define PYTHONIC_BUILTIN_ZERODIVISIONERROR_HPP
+
+#include "pythonic/include/builtins/ZeroDivisionError.hpp"
+
+#include "pythonic/types/exceptions.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  PYTHONIC_EXCEPTION_IMPL(ZeroDivisionError)
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/abs.hpp

@@ -0,0 +1,7 @@
+#ifndef PYTHONIC_BUILTIN_ABS_HPP
+#define PYTHONIC_BUILTIN_ABS_HPP
+
+#include "pythonic/include/builtins/abs.hpp"
+#include "pythonic/numpy/abs.hpp"
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/all.hpp

@@ -0,0 +1,24 @@
+#ifndef PYTHONIC_BUILTIN_ALL_HPP
+#define PYTHONIC_BUILTIN_ALL_HPP
+
+#include "pythonic/utils/functor.hpp"
+#include "pythonic/include/builtins/all.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  template <class Iterable>
+  bool all(Iterable &&s)
+  {
+    auto iend = s.end();
+    for (auto iter = s.begin(); iter != iend; ++iter)
+      if (!*iter)
+        return false;
+    return true;
+  }
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/any.hpp

@@ -0,0 +1,24 @@
+#ifndef PYTHONIC_BUILTIN_ANY_HPP
+#define PYTHONIC_BUILTIN_ANY_HPP
+
+#include "pythonic/include/builtins/any.hpp"
+
+#include "pythonic/utils/functor.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+  template <class Iterable>
+  bool any(Iterable &&s)
+  {
+    auto iend = s.end();
+    for (auto iter = s.begin(); iter != iend; ++iter)
+      if (*iter)
+        return true;
+    return false;
+  }
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/assert.hpp

@@ -0,0 +1,28 @@
+#ifndef PYTHONIC_BUILTIN_ASSERT_HPP
+#define PYTHONIC_BUILTIN_ASSERT_HPP
+
+#include "pythonic/include/builtins/assert.hpp"
+
+#include "pythonic/builtins/AssertionError.hpp"
+#include "pythonic/types/str.hpp"
+
+PYTHONIC_NS_BEGIN
+
+void pythran_assert(bool cond)
+{
+#ifndef NDEBUG
+  if (!cond)
+    throw types::AssertionError();
+#endif
+}
+
+void pythran_assert(bool cond, types::str const &what)
+{
+#ifndef NDEBUG
+  if (!cond)
+    throw types::AssertionError(what);
+#endif
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/bin.hpp

@@ -0,0 +1,64 @@
+#ifndef PYTHONIC_BUILTIN_BIN_HPP
+#define PYTHONIC_BUILTIN_BIN_HPP
+
+#include "pythonic/include/builtins/bin.hpp"
+
+#include "pythonic/types/str.hpp"
+#include "pythonic/utils/functor.hpp"
+
+#include <algorithm>
+#include <cmath>
+#include <limits>
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+  template <class T>
+  typename std::enable_if<std::is_scalar<T>::value, types::str>::type
+  bin(T const &v)
+  {
+    using UT = typename std::make_unsigned<T>::type;
+    if (v < T{0})
+      if (v == std::numeric_limits<T>::min()) {
+        // In this special case, calling -v would overflow so
+        // a special case is needed.
+        types::str res;
+        auto &backend = res.chars();
+        backend.resize(8 * sizeof(T) + 3);
+        auto it = backend.begin();
+        *it++ = '-';
+        *it++ = '0';
+        *it++ = 'b';
+        *it++ = '1';
+        std::fill(it, backend.end(), '0');
+        return res;
+      } else
+        return "-" + bin(-v);
+    else if (v == T{0})
+      return "0b0";
+    else {
+      // Due to rounding errors, we cannot use std::log2(v)
+      // to accuratly find length.
+      size_t len = (8 * sizeof(UT)) - 1;
+      UT i{UT{1} << len};
+      while (!(i & v)) {
+        i >>= 1;
+        len--;
+      }
+      types::str res;
+      res.reserve(2 + len);
+      auto &backend = res.chars();
+      backend.append("0b");
+      for (; i; i >>= 1)
+        if (v & i)
+          backend.append("1");
+        else
+          backend.append("0");
+      return res;
+    }
+  }
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/bool_.hpp

@@ -0,0 +1,42 @@
+#ifndef PYTHONIC_BUILTIN_BOOL_HPP
+#define PYTHONIC_BUILTIN_BOOL_HPP
+
+#include "pythonic/include/builtins/bool_.hpp"
+
+#include "pythonic/utils/functor.hpp"
+#include "pythonic/types/tuple.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+  namespace functor
+  {
+
+    template <class T>
+    bool bool_::operator()(T const &val) const
+    {
+      return static_cast<bool>(val);
+    }
+
+    template <class... Ts>
+    bool bool_::operator()(std::tuple<Ts...> const &val) const
+    {
+      return sizeof...(Ts);
+    }
+
+    template <class T, size_t N>
+    bool bool_::operator()(types::array<T, N> const &val) const
+    {
+      return N;
+    }
+
+    bool bool_::operator()() const
+    {
+      return false;
+    }
+  }
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/chr.hpp

@@ -0,0 +1,21 @@
+#ifndef PYTHONIC_BUILTIN_CHR_HPP
+#define PYTHONIC_BUILTIN_CHR_HPP
+
+#include "pythonic/include/builtins/chr.hpp"
+
+#include "pythonic/types/str.hpp"
+#include "pythonic/utils/functor.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+  template <class T>
+  types::str chr(T const &v)
+  {
+    return types::str((char)v);
+  }
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/complex.hpp

@@ -0,0 +1,24 @@
+#ifndef PYTHONIC_BUILTIN_COMPLEX_HPP
+#define PYTHONIC_BUILTIN_COMPLEX_HPP
+
+#include "pythonic/include/builtins/complex.hpp"
+
+#include "pythonic/types/complex.hpp"
+#include "pythonic/utils/functor.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  namespace functor
+  {
+    complex::type complex::operator()(double v0, double v1) const
+    {
+      return {v0, v1};
+    }
+  }
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/complex/conjugate.hpp

@@ -0,0 +1,7 @@
+#ifndef PYTHONIC_BUILTIN_COMPLEX_CONJUGATE_HPP
+#define PYTHONIC_BUILTIN_COMPLEX_CONJUGATE_HPP
+
+#include "pythonic/include/builtins/complex/conjugate.hpp"
+#include "pythonic/numpy/conjugate.hpp"
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/dict.hpp

@@ -0,0 +1,47 @@
+#ifndef PYTHONIC_BUILTIN_DICT_HPP
+#define PYTHONIC_BUILTIN_DICT_HPP
+
+#include "pythonic/include/builtins/dict.hpp"
+
+#include "pythonic/types/dict.hpp"
+#include "pythonic/utils/functor.hpp"
+
+#include <tuple>
+#include <utility>
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  namespace anonymous
+  {
+    types::empty_dict dict()
+    {
+      return types::empty_dict();
+    }
+
+    template <class K, class V>
+    types::dict<K, V> dict(types::dict<K, V> const &other)
+    {
+      return other.copy();
+    }
+
+    template <class Iterable>
+    auto dict(Iterable &&iterable) -> types::dict<
+        typename std::decay<decltype(std::get<0>(*iterable.begin()))>::type,
+        typename std::decay<decltype(std::get<1>(*iterable.begin()))>::type>
+    {
+      types::dict<
+          typename std::decay<decltype(std::get<0>(*iterable.begin()))>::type,
+          typename std::decay<decltype(std::get<1>(*iterable.begin()))>::type>
+          out = types::empty_dict();
+      for (auto const &i : iterable)
+        out[std::get<0>(i)] = std::get<1>(i);
+      return out;
+    }
+  }
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/dict/clear.hpp

@@ -0,0 +1,7 @@
+#ifndef PYTHONIC_BUILTIN_DICT_CLEAR_HPP
+#define PYTHONIC_BUILTIN_DICT_CLEAR_HPP
+
+#include "pythonic/include/builtins/dict/clear.hpp"
+#include "pythonic/__dispatch__/clear.hpp"
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/dict/copy.hpp

@@ -0,0 +1,7 @@
+#ifndef PYTHONIC_BUILTIN_DICT_COPY_HPP
+#define PYTHONIC_BUILTIN_DICT_COPY_HPP
+
+#include "pythonic/include/builtins/dict/copy.hpp"
+#include "pythonic/__dispatch__/copy.hpp"
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/dict/fromkeys.hpp

@@ -0,0 +1,34 @@
+#ifndef PYTHONIC_BUILTIN_DICT_FROMKEYS_HPP
+#define PYTHONIC_BUILTIN_DICT_FROMKEYS_HPP
+
+#include "pythonic/include/builtins/dict/fromkeys.hpp"
+
+#include "pythonic/types/dict.hpp"
+#include "pythonic/utils/functor.hpp"
+
+#include <type_traits>
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  namespace dict
+  {
+
+    template <class Iterable, class V>
+    types::dict<typename std::remove_reference<Iterable>::type::value_type, V>
+    fromkeys(Iterable &&iter, V const &v)
+    {
+      types::dict<typename std::remove_reference<Iterable>::type::value_type,
+                  V> D =
+          types::empty_dict(); // Allocate default capacity to dict
+      for (auto const &i : iter)
+        D[i] = v;
+      return D;
+    }
+  }
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/dict/get.hpp

@@ -0,0 +1,39 @@
+#ifndef PYTHONIC_BUILTIN_DICT_GET_HPP
+#define PYTHONIC_BUILTIN_DICT_GET_HPP
+
+#include "pythonic/include/builtins/dict/get.hpp"
+
+#include "pythonic/types/dict.hpp"
+#include "pythonic/types/NoneType.hpp"
+#include "pythonic/utils/functor.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  namespace dict
+  {
+    template <class K, class V, class W, class X>
+    typename __combined<V, X>::type get(types::dict<K, V> const &d, W const &k,
+                                        X const &default_)
+    {
+      return d.get(k, default_);
+    }
+
+    template <class K, class V, class W>
+    types::none<V> get(types::dict<K, V> const &d, W const &k)
+    {
+      return d.get(k);
+    }
+
+    template <class W, class X>
+    X get(types::empty_dict const &, W const &, X const &default_)
+    {
+      return default_;
+    }
+  }
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/dict/items.hpp

@@ -0,0 +1,29 @@
+#ifndef PYTHONIC_BUILTIN_DICT_ITEMS_HPP
+#define PYTHONIC_BUILTIN_DICT_ITEMS_HPP
+
+#include "pythonic/include/builtins/dict/items.hpp"
+
+#include "pythonic/include/utils/functor.hpp"
+#include "pythonic/include/types/dict.hpp"
+#include "pythonic/include/types/list.hpp"
+
+#include <tuple>
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  namespace dict
+  {
+
+    template <class D>
+    auto items(D &&d) -> decltype(std::forward<D>(d).items())
+    {
+      return std::forward<D>(d).items();
+    }
+  }
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/dict/keys.hpp

@@ -0,0 +1,30 @@
+#ifndef PYTHONIC_BUILTIN_DICT_KEYS_HPP
+#define PYTHONIC_BUILTIN_DICT_KEYS_HPP
+
+#include "pythonic/include/builtins/dict/keys.hpp"
+
+#include "pythonic/types/dict.hpp"
+#include "pythonic/types/list.hpp"
+#include "pythonic/utils/functor.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  namespace dict
+  {
+
+    // We need a copy here for lvalue like :
+    // for i in {"a": "b", "c": "d"}.keys():
+    //     pass
+    template <class D>
+    auto keys(D &&d) -> decltype(std::forward<D>(d).keys())
+    {
+      return std::forward<D>(d).keys();
+    }
+  }
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/dict/pop.hpp

@@ -0,0 +1,7 @@
+#ifndef PYTHONIC_BUILTIN_DICT_POP_HPP
+#define PYTHONIC_BUILTIN_DICT_POP_HPP
+
+#include "pythonic/include/builtins/dict/pop.hpp"
+#include "pythonic/__dispatch__/pop.hpp"
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/dict/popitem.hpp

@@ -0,0 +1,28 @@
+#ifndef PYTHONIC_BUILTIN_DICT_POPITEM_HPP
+#define PYTHONIC_BUILTIN_DICT_POPITEM_HPP
+
+#include "pythonic/include/builtins/dict/popitem.hpp"
+
+#include "pythonic/types/dict.hpp"
+#include "pythonic/utils/functor.hpp"
+
+#include <tuple>
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  namespace dict
+  {
+
+    template <class D>
+    auto popitem(D &&d) -> decltype(std::forward<D>(d).popitem())
+    {
+      return std::forward<D>(d).popitem();
+    }
+  }
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/dict/setdefault.hpp

@@ -0,0 +1,44 @@
+#ifndef PYTHONIC_BUILTIN_DICT_SETDEFAULT_HPP
+#define PYTHONIC_BUILTIN_DICT_SETDEFAULT_HPP
+
+#include "pythonic/include/builtins/dict/setdefault.hpp"
+
+#include "pythonic/types/dict.hpp"
+#include "pythonic/utils/functor.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  namespace dict
+  {
+
+    template <class K, class V, class W, class X>
+    V &setdefault(types::dict<K, V> &d, W const &k, X const &default_)
+    {
+      return d.setdefault(k, default_);
+    }
+
+    template <class K, class V, class W>
+    types::none<V> setdefault(types::dict<K, V> &d, W const &k)
+    {
+      return d.get(k);
+    }
+
+    template <class K, class V, class W, class X>
+    V setdefault(types::dict<K, V> &&d, W const &k, X const &default_)
+    {
+      return d.setdefault(k, default_);
+    }
+
+    template <class K, class V, class W>
+    types::none<V> setdefault(types::dict<K, V> &&d, W const &k)
+    {
+      return d.get(k);
+    }
+  }
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/dict/update.hpp

@@ -0,0 +1,7 @@
+#ifndef PYTHONIC_BUILTIN_DICT_UPDATE_HPP
+#define PYTHONIC_BUILTIN_DICT_UPDATE_HPP
+
+#include "pythonic/include/builtins/dict/update.hpp"
+#include "pythonic/__dispatch__/update.hpp"
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/dict/values.hpp

@@ -0,0 +1,26 @@
+#ifndef PYTHONIC_BUILTIN_DICT_VALUES_HPP
+#define PYTHONIC_BUILTIN_DICT_VALUES_HPP
+
+#include "pythonic/include/builtins/dict/values.hpp"
+
+#include "pythonic/types/dict.hpp"
+#include "pythonic/utils/functor.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  namespace dict
+  {
+
+    template <class D>
+    auto values(D &&d) -> decltype(std::forward<D>(d).values())
+    {
+      return std::forward<D>(d).values();
+    }
+  }
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/divmod.hpp

@@ -0,0 +1,23 @@
+#ifndef PYTHONIC_BUILTIN_DIVMOD_HPP
+#define PYTHONIC_BUILTIN_DIVMOD_HPP
+
+#include "pythonic/include/builtins/divmod.hpp"
+
+#include "pythonic/types/tuple.hpp"
+#include "pythonic/utils/functor.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  template <class T0, class T1>
+  auto divmod(T0 const &t0, T1 const &t1) // other types are left over
+      -> decltype(types::make_tuple(t0 / t1, t0 % t1))
+  {
+    return types::make_tuple(t0 / t1, t0 % t1);
+  }
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/enumerate.hpp

@@ -0,0 +1,117 @@
+#ifndef PYTHONIC_BUILTIN_ENUMERATE_HPP
+#define PYTHONIC_BUILTIN_ENUMERATE_HPP
+
+#include "pythonic/include/builtins/enumerate.hpp"
+
+#include "pythonic/utils/functor.hpp"
+
+#include <tuple>
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  namespace details
+  {
+    /// enumerate_iterator implementation
+
+    template <class Iterator>
+    enumerate_iterator<Iterator>::enumerate_iterator()
+    {
+    }
+
+    template <class Iterator>
+    enumerate_iterator<Iterator>::enumerate_iterator(Iterator const &iter,
+                                                     long first)
+        : value(first), iter(iter)
+    {
+    }
+
+    template <class Iterator>
+    enumerate_iterator<Iterator> &enumerate_iterator<Iterator>::
+    operator+=(long n)
+    {
+      value += n, iter += n;
+      return *this;
+    }
+
+    // Comparison operators can't use value as end() doesn't have a valid
+    // value content
+    // du to the lake of size information for generator
+    // TODO : We could handle case with && without size if there is a
+    // performances benefits
+    template <class Iterator>
+    bool enumerate_iterator<Iterator>::
+    operator!=(enumerate_iterator<Iterator> const &other) const
+    {
+      return !(*this == other);
+    }
+
+    template <class Iterator>
+    bool enumerate_iterator<Iterator>::
+    operator<(enumerate_iterator const &other) const
+    {
+      return iter < other.iter;
+    }
+
+    template <class Iterator>
+    bool enumerate_iterator<Iterator>::
+    operator==(enumerate_iterator<Iterator> const &other) const
+    {
+      return iter == other.iter;
+    }
+
+    template <class Iterator>
+    long enumerate_iterator<Iterator>::
+    operator-(enumerate_iterator<Iterator> const &other) const
+    {
+      return iter - other.iter;
+    }
+
+    /// details::enumerate implementation
+    template <class Iterable>
+    enumerate<Iterable>::enumerate()
+    {
+    }
+
+    template <class Iterable>
+    enumerate<Iterable>::enumerate(Iterable seq, long first)
+        : Iterable(seq), iterator(Iterable::begin(), first),
+          end_iter(Iterable::end(), -1)
+    {
+    }
+
+    template <class Iterable>
+    typename enumerate<Iterable>::iterator &enumerate<Iterable>::begin()
+    {
+      return *this;
+    }
+
+    template <class Iterable>
+    typename enumerate<Iterable>::iterator const &
+    enumerate<Iterable>::begin() const
+    {
+      return *this;
+    }
+
+    template <class Iterable>
+    typename enumerate<Iterable>::iterator enumerate<Iterable>::end() const
+    {
+      return end_iter;
+    }
+  }
+
+  /// enumerate implementation
+
+  template <class Iterable>
+  details::enumerate<typename std::remove_cv<
+      typename std::remove_reference<Iterable>::type>::type>
+  enumerate(Iterable &&seq, long first)
+  {
+    return {std::forward<Iterable>(seq), first};
+  }
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/file.hpp

@@ -0,0 +1,25 @@
+#ifndef PYTHONIC_BUILTIN_FILE_HPP
+#define PYTHONIC_BUILTIN_FILE_HPP
+
+#include "pythonic/include/builtins/file.hpp"
+
+#include "pythonic/types/file.hpp"
+#include "pythonic/types/str.hpp"
+#include "pythonic/utils/functor.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  namespace anonymous
+  {
+    types::file file(types::str const &filename, types::str const &strmode)
+    {
+      return {filename, strmode};
+    }
+  }
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/file/close.hpp

@@ -0,0 +1,29 @@
+#ifndef PYTHONIC_BUILTIN_FILE_CLOSE_HPP
+#define PYTHONIC_BUILTIN_FILE_CLOSE_HPP
+
+#include "pythonic/include/builtins/file/close.hpp"
+
+#include "pythonic/types/file.hpp"
+#include "pythonic/utils/functor.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  namespace file
+  {
+
+    void close(types::file &f)
+    {
+      f.close();
+    }
+
+    void close(types::file &&f)
+    {
+      f.close();
+    }
+  }
+}
+PYTHONIC_NS_END
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/file/fileno.hpp

@@ -0,0 +1,24 @@
+#ifndef PYTHONIC_BUILTIN_FILE_FILENO_HPP
+#define PYTHONIC_BUILTIN_FILE_FILENO_HPP
+
+#include "pythonic/include/builtins/file/fileno.hpp"
+
+#include "pythonic/types/file.hpp"
+#include "pythonic/utils/functor.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  namespace file
+  {
+
+    long fileno(types::file const &f)
+    {
+      return f.fileno();
+    }
+  }
+}
+PYTHONIC_NS_END
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/file/flush.hpp

@@ -0,0 +1,29 @@
+#ifndef PYTHONIC_BUILTIN_FILE_FLUSH_HPP
+#define PYTHONIC_BUILTIN_FILE_FLUSH_HPP
+
+#include "pythonic/include/builtins/file/flush.hpp"
+
+#include "pythonic/types/file.hpp"
+#include "pythonic/utils/functor.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  namespace file
+  {
+
+    void flush(types::file &f)
+    {
+      f.flush();
+    }
+
+    void flush(types::file &&f)
+    {
+      f.flush();
+    }
+  }
+}
+PYTHONIC_NS_END
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/file/isatty.hpp

@@ -0,0 +1,24 @@
+#ifndef PYTHONIC_BUILTIN_FILE_ISATTY_HPP
+#define PYTHONIC_BUILTIN_FILE_ISATTY_HPP
+
+#include "pythonic/include/builtins/file/isatty.hpp"
+
+#include "pythonic/types/file.hpp"
+#include "pythonic/utils/functor.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  namespace file
+  {
+
+    bool isatty(types::file const &f)
+    {
+      return f.isatty();
+    }
+  }
+}
+PYTHONIC_NS_END
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/file/next.hpp

@@ -0,0 +1,7 @@
+#ifndef PYTHONIC_BUILTIN_FILE_NEXT_HPP
+#define PYTHONIC_BUILTIN_FILE_NEXT_HPP
+
+#include "pythonic/include/builtins/file/next.hpp"
+#include "pythonic/__dispatch__/next.hpp"
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/file/read.hpp

@@ -0,0 +1,29 @@
+#ifndef PYTHONIC_BUILTIN_FILE_READ_HPP
+#define PYTHONIC_BUILTIN_FILE_READ_HPP
+
+#include "pythonic/include/builtins/file/read.hpp"
+
+#include "pythonic/types/file.hpp"
+#include "pythonic/types/str.hpp"
+#include "pythonic/utils/functor.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  namespace file
+  {
+
+    types::str read(types::file &f, long size)
+    {
+      return f.read(size);
+    }
+    types::str read(types::file &&f, long size)
+    {
+      return f.read(size);
+    }
+  }
+}
+PYTHONIC_NS_END
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/file/readline.hpp

@@ -0,0 +1,30 @@
+#ifndef PYTHONIC_BUILTIN_FILE_READLINE_HPP
+#define PYTHONIC_BUILTIN_FILE_READLINE_HPP
+
+#include "pythonic/include/builtins/file/readline.hpp"
+
+#include "pythonic/types/file.hpp"
+#include "pythonic/types/str.hpp"
+#include "pythonic/utils/functor.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  namespace file
+  {
+
+    types::str readline(types::file &f, long size)
+    {
+      return size < 0 ? f.readline() : f.readline(size);
+    }
+
+    types::str readline(types::file &&f, long size)
+    {
+      return size < 0 ? f.readline() : f.readline(size);
+    }
+  }
+}
+PYTHONIC_NS_END
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/file/readlines.hpp

@@ -0,0 +1,33 @@
+#ifndef PYTHONIC_BUILTIN_FILE_READLINES_HPP
+#define PYTHONIC_BUILTIN_FILE_READLINES_HPP
+
+#include "pythonic/include/builtins/file/readlines.hpp"
+
+#include "pythonic/types/file.hpp"
+#include "pythonic/types/list.hpp"
+#include "pythonic/types/str.hpp"
+#include "pythonic/utils/functor.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  namespace file
+  {
+
+    template <class F>
+    types::list<types::str> readlines(F &&f)
+    {
+      return f.readlines();
+    }
+
+    template <class F>
+    types::list<types::str> readlines(F &&f, long sizehint)
+    {
+      return f.readlines(sizehint);
+    }
+  }
+}
+PYTHONIC_NS_END
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/file/seek.hpp

@@ -0,0 +1,39 @@
+#ifndef PYTHONIC_BUILTIN_FILE_SEEK_HPP
+#define PYTHONIC_BUILTIN_FILE_SEEK_HPP
+
+#include "pythonic/include/builtins/file/seek.hpp"
+
+#include "pythonic/types/file.hpp"
+#include "pythonic/utils/functor.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  namespace file
+  {
+
+    void seek(types::file &f, long offset)
+    {
+      f.seek(offset);
+    }
+
+    void seek(types::file &&f, long offset)
+    {
+      // Nothing have to be done as it is a lvalue
+    }
+
+    void seek(types::file &f, long offset, long whence)
+    {
+      f.seek(offset, whence);
+    }
+
+    void seek(types::file &&f, long offset, long whence)
+    {
+      // Nothing have to be done as it is a lvalue
+    }
+  }
+}
+PYTHONIC_NS_END
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/file/tell.hpp

@@ -0,0 +1,24 @@
+#ifndef PYTHONIC_BUILTIN_FILE_TELL_HPP
+#define PYTHONIC_BUILTIN_FILE_TELL_HPP
+
+#include "pythonic/include/builtins/file/tell.hpp"
+
+#include "pythonic/types/file.hpp"
+#include "pythonic/utils/functor.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  namespace file
+  {
+
+    long tell(types::file const &f)
+    {
+      return f.tell();
+    }
+  }
+}
+PYTHONIC_NS_END
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/file/truncate.hpp

@@ -0,0 +1,39 @@
+#ifndef PYTHONIC_BUILTIN_FILE_TRUNCATE_HPP
+#define PYTHONIC_BUILTIN_FILE_TRUNCATE_HPP
+
+#include "pythonic/include/builtins/file/truncate.hpp"
+
+#include "pythonic/types/file.hpp"
+#include "pythonic/utils/functor.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  namespace file
+  {
+
+    void truncate(types::file &f)
+    {
+      f.truncate();
+    }
+
+    void truncate(types::file &&f)
+    {
+      f.truncate();
+    }
+
+    void truncate(types::file &f, long size)
+    {
+      f.truncate(size);
+    }
+
+    void truncate(types::file &&f, long size)
+    {
+      f.truncate(size);
+    }
+  }
+}
+PYTHONIC_NS_END
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/file/write.hpp

@@ -0,0 +1,30 @@
+#ifndef PYTHONIC_BUILTIN_FILE_WRITE_HPP
+#define PYTHONIC_BUILTIN_FILE_WRITE_HPP
+
+#include "pythonic/include/builtins/file/write.hpp"
+
+#include "pythonic/types/file.hpp"
+#include "pythonic/types/str.hpp"
+#include "pythonic/utils/functor.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  namespace file
+  {
+
+    long write(types::file &f, types::str const &str)
+    {
+      return f.write(str);
+    }
+
+    long write(types::file &&f, types::str const &str)
+    {
+      return f.write(str);
+    }
+  }
+}
+PYTHONIC_NS_END
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/file/writelines.hpp

@@ -0,0 +1,25 @@
+#ifndef PYTHONIC_BUILTIN_FILE_WRITELINES_HPP
+#define PYTHONIC_BUILTIN_FILE_WRITELINES_HPP
+
+#include "pythonic/include/builtins/file/writelines.hpp"
+
+#include "pythonic/types/file.hpp"
+#include "pythonic/utils/functor.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  namespace file
+  {
+
+    template <class F, class T>
+    void writelines(F &&f, T const &sequence)
+    {
+      f.writelines(sequence);
+    }
+  }
+}
+PYTHONIC_NS_END
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/filter.hpp

@@ -0,0 +1,129 @@
+#ifndef PYTHONIC_BUILTIN_FILTER_HPP
+#define PYTHONIC_BUILTIN_FILTER_HPP
+
+#include "pythonic/include/builtins/filter.hpp"
+
+#include "pythonic/utils/iterator.hpp"
+#include "pythonic/itertools/common.hpp"
+#include "pythonic/utils/functor.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+  namespace details
+  {
+    template <typename Operator, typename List0>
+    bool filter_iterator<Operator, List0>::test_filter(std::false_type)
+    {
+      return op(*iter);
+    }
+
+    template <typename Operator, typename List0>
+    bool filter_iterator<Operator, List0>::test_filter(std::true_type)
+    {
+      return *iter;
+    }
+
+    template <typename Operator, typename List0>
+    filter_iterator<Operator, List0>::filter_iterator(Operator _op, List0 &_seq)
+        : op(_op), iter(_seq.begin()), iter_end(_seq.end())
+    {
+      if (!test_filter(std::is_same<types::none_type, Operator>()))
+        next_value();
+    }
+
+    template <typename Operator, typename List0>
+    filter_iterator<Operator, List0>::filter_iterator(itertools::npos,
+                                                      Operator _op, List0 &_seq)
+        : op(_op), iter(_seq.end()), iter_end(_seq.end())
+    {
+    }
+
+    template <typename Operator, typename List0>
+    typename List0::value_type filter_iterator<Operator, List0>::
+    operator*() const
+    {
+      return *iter;
+    }
+
+    template <typename Operator, typename List0>
+    filter_iterator<Operator, List0> &filter_iterator<Operator, List0>::
+    operator++()
+    {
+      next_value();
+      return *this;
+    }
+
+    template <typename Operator, typename List0>
+    void filter_iterator<Operator, List0>::next_value()
+    {
+      while (++iter != iter_end) {
+        if (test_filter(std::is_same<types::none_type, Operator>()))
+          return;
+      }
+    }
+
+    template <typename Operator, typename List0>
+    bool filter_iterator<Operator, List0>::
+    operator==(filter_iterator const &other) const
+    {
+      return !(iter != other.iter);
+    }
+
+    template <typename Operator, typename List0>
+    bool filter_iterator<Operator, List0>::
+    operator!=(filter_iterator const &other) const
+    {
+      return iter != other.iter;
+    }
+
+    template <typename Operator, typename List0>
+    bool filter_iterator<Operator, List0>::
+    operator<(filter_iterator const &other) const
+    {
+      return iter != other.iter;
+    }
+
+    template <typename Operator, typename List0>
+    filter<Operator, List0>::filter(Operator _op, List0 const &_seq)
+        : utils::iterator_reminder<false, List0>(_seq),
+          iterator(_op, this->values),
+          end_iter(itertools::npos(), _op, this->values)
+    {
+    }
+
+    template <typename Operator, typename List0>
+    typename filter<Operator, List0>::iterator &filter<Operator, List0>::begin()
+    {
+      return *this;
+    }
+
+    template <typename Operator, typename List0>
+    typename filter<Operator, List0>::iterator const &
+    filter<Operator, List0>::begin() const
+    {
+      return *this;
+    }
+
+    template <typename Operator, typename List0>
+    typename filter<Operator, List0>::iterator const &
+    filter<Operator, List0>::end() const
+    {
+      return end_iter;
+    }
+  }
+
+  template <typename Operator, typename List0>
+  details::filter<typename std::remove_cv<
+                      typename std::remove_reference<Operator>::type>::type,
+                  typename std::remove_cv<
+                      typename std::remove_reference<List0>::type>::type>
+  filter(Operator &&_op, List0 &&_seq)
+  {
+    return {std::forward<Operator>(_op), std::forward<List0>(_seq)};
+  }
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/float_.hpp

@@ -0,0 +1,29 @@
+#ifndef PYTHONIC_BUILTIN_FLOAT_HPP
+#define PYTHONIC_BUILTIN_FLOAT_HPP
+
+#include "pythonic/include/builtins/float_.hpp"
+
+#include "pythonic/utils/functor.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  namespace functor
+  {
+    template <class T>
+    float_::type float_::operator()(T &&t) const
+    {
+      return static_cast<float_::type>(t);
+    }
+
+    float_::type float_::operator()() const
+    {
+      return 0.;
+    }
+  }
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/float_/is_integer.hpp

@@ -0,0 +1,26 @@
+#ifndef PYTHONIC_BUILTIN_FLOAT_ISINTEGER_HPP
+#define PYTHONIC_BUILTIN_FLOAT_ISINTEGER_HPP
+
+#include "pythonic/include/builtins/float_/is_integer.hpp"
+
+#include "pythonic/utils/functor.hpp"
+
+#include <cmath>
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  namespace float_
+  {
+
+    bool is_integer(double d)
+    {
+      return std::trunc(d) == d;
+    }
+  }
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/getattr.hpp

@@ -0,0 +1,6 @@
+#ifndef PYTHONIC_BUILTIN_GETATTR_HPP
+#define PYTHONIC_BUILTIN_GETATTR_HPP
+
+#include "pythonic/include/builtins/getattr.hpp"
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/hex.hpp

@@ -0,0 +1,26 @@
+#ifndef PYTHONIC_BUILTIN_HEX_HPP
+#define PYTHONIC_BUILTIN_HEX_HPP
+
+#include "pythonic/include/builtins/hex.hpp"
+
+#include "pythonic/utils/functor.hpp"
+#include "pythonic/types/str.hpp"
+
+#include <sstream>
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  template <class T>
+  types::str hex(T const &v)
+  {
+    std::ostringstream oss;
+    oss << "0x" << std::hex << v;
+    return oss.str();
+  }
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/id.hpp

@@ -0,0 +1,43 @@
+#ifndef PYTHONIC_BUILTIN_ID_HPP
+#define PYTHONIC_BUILTIN_ID_HPP
+
+#include "pythonic/include/builtins/id.hpp"
+
+#include "pythonic/utils/functor.hpp"
+
+/*
+ * We use uintptr_t conversion because on windows 64 bits, sizeof(void*) == 8
+ * && sizeof(long) == 4. Because of this, void* to long is forbidden but
+ * void* -> uintptr_t -> long is allowed
+ * Accuracy is lost this way...
+ */
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  template <class T>
+  long id(T const &t)
+  {
+    return t.id();
+  }
+
+  long id(long const &t)
+  {
+    return reinterpret_cast<uintptr_t>(&t);
+  }
+
+  long id(double const &t)
+  {
+    return reinterpret_cast<uintptr_t>(&t);
+  }
+
+  long id(bool const &t)
+  {
+    return reinterpret_cast<uintptr_t>(&t);
+  }
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/in.hpp

@@ -0,0 +1,45 @@
+#ifndef PYTHONIC_BUILTIN_IN_HPP
+#define PYTHONIC_BUILTIN_IN_HPP
+
+#include "pythonic/include/builtins/in.hpp"
+
+#include "pythonic/types/traits.hpp"
+
+#include <algorithm>
+
+PYTHONIC_NS_BEGIN
+
+namespace details
+{
+  template <bool has_contains>
+  struct in {
+    template <class T, class V>
+    bool operator()(T &&t, V const &v) const;
+  };
+
+  template <>
+  template <class T, class V>
+  bool in<false>::operator()(T &&t, V const &v) const
+  {
+    return std::find(t.begin(), t.end(), v) != t.end();
+  }
+
+  template <>
+  template <class T, class V>
+  bool in<true>::operator()(T &&t, V const &v) const
+  {
+    return t.contains(v);
+  }
+}
+
+template <class T, class V>
+bool in(T &&t, V const &v)
+{
+  using RT =
+      typename std::remove_cv<typename std::remove_reference<T>::type>::type;
+  static bool constexpr has_contains = types::has_contains<RT, V>::value;
+  return details::in<has_contains>()(std::forward<T>(t), v);
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/int_.hpp

@@ -0,0 +1,45 @@
+#ifndef PYTHONIC_BUILTIN_INT_HPP
+#define PYTHONIC_BUILTIN_INT_HPP
+
+#include "pythonic/include/builtins/int_.hpp"
+
+#include "pythonic/types/str.hpp"
+
+#include <cassert>
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  namespace functor
+  {
+    int_::type int_::operator()(char const t[], long base) const
+    {
+      return std::strtol(t, nullptr, base);
+    }
+    int_::type int_::operator()(types::str const &t, long base) const
+    {
+      return (*this)(t.c_str(), base);
+    }
+    int_::type int_::operator()(types::chr const &t, long base) const
+    {
+      char tmp[2] = {t.c, 0};
+      return (*this)(&tmp[0], base);
+    }
+
+    template <class T>
+    int_::type int_::operator()(T &&t) const
+    {
+      return static_cast<int_::type>(t);
+    }
+
+    int_::type int_::operator()() const
+    {
+      return 0L;
+    }
+  }
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/isinstance.hpp

@@ -0,0 +1,7 @@
+#ifndef PYTHONIC_BUILTIN_ISINSTANCE_HPP
+#define PYTHONIC_BUILTIN_ISINSTANCE_HPP
+
+#include "pythonic/include/builtins/isinstance.hpp"
+#include "pythonic/include/builtins/pythran/is_none.hpp"
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/iter.hpp

@@ -0,0 +1,61 @@
+#ifndef PYTHONIC_BUILTIN_ITER_HPP
+#define PYTHONIC_BUILTIN_ITER_HPP
+
+#include "pythonic/include/builtins/iter.hpp"
+
+#include "pythonic/utils/functor.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  namespace details
+  {
+    /// details iter implementation
+
+    template <class T>
+    iter<T>::iter()
+    {
+    }
+
+    // FIXME : There is a dangling reference as data.begin() is ! the one
+    // from data "saved" in the "iter" struct
+    template <class T>
+    iter<T>::iter(T data)
+        : iterator(data.begin()), _end(data.end()), data(data)
+    {
+    }
+
+    template <class T>
+    typename iter<T>::iterator &iter<T>::begin()
+    {
+      return *this;
+    }
+
+    template <class T>
+    typename iter<T>::iterator const &iter<T>::begin() const
+    {
+      return *this;
+    }
+
+    template <class T>
+    typename iter<T>::iterator const &iter<T>::end() const
+    {
+      return _end;
+    }
+  }
+
+  /// iter implementation
+
+  template <class T>
+  details::iter<
+      typename std::remove_cv<typename std::remove_reference<T>::type>::type>
+  iter(T &&t)
+  {
+    return {std::forward<T>(t)};
+  }
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/len.hpp

@@ -0,0 +1,29 @@
+#ifndef PYTHONIC_BUILTIN_LEN_HPP
+#define PYTHONIC_BUILTIN_LEN_HPP
+
+#include "pythonic/include/builtins/len.hpp"
+
+#include "pythonic/types/traits.hpp"
+#include "pythonic/utils/functor.hpp"
+
+#include <tuple>
+#include <iterator>
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+  template <class... Types>
+  long len(std::tuple<Types...> const &)
+  {
+    return sizeof...(Types);
+  }
+
+  template <class T>
+  typename std::enable_if<types::has_size<T>::value, long>::type len(T const &t)
+  {
+    return t.size();
+  }
+}
+PYTHONIC_NS_END
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/list.hpp

@@ -0,0 +1,45 @@
+#ifndef PYTHONIC_BUILTIN_LIST_HPP
+#define PYTHONIC_BUILTIN_LIST_HPP
+
+#include "pythonic/include/builtins/list.hpp"
+
+#include "pythonic/types/list.hpp"
+#include "pythonic/utils/functor.hpp"
+
+#include <iterator>
+#include <type_traits>
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  namespace anonymous
+  {
+
+    inline types::empty_list list()
+    {
+      return types::empty_list();
+    }
+
+    inline types::empty_list list(types::empty_list)
+    {
+      return types::empty_list();
+    }
+
+    template <class Iterable>
+    types::list<typename std::decay<typename std::iterator_traits<
+        typename std::remove_reference<Iterable>::type::iterator>::value_type>::
+                    type>
+    list(Iterable &&t)
+    {
+      return types::list<typename std::decay<
+          typename std::iterator_traits<typename std::remove_reference<
+              Iterable>::type::iterator>::value_type>::type>(t.begin(),
+                                                             t.end());
+    }
+  }
+}
+PYTHONIC_NS_END
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/list/append.hpp

@@ -0,0 +1,34 @@
+#ifndef PYTHONIC_BUILTIN_LIST_APPEND_HPP
+#define PYTHONIC_BUILTIN_LIST_APPEND_HPP
+
+#include "pythonic/include/builtins/list/append.hpp"
+
+#include "pythonic/builtins/None.hpp"
+#include "pythonic/types/list.hpp"
+#include "pythonic/types/NoneType.hpp"
+#include "pythonic/utils/functor.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  namespace list
+  {
+
+    template <class T, class F>
+    types::none_type append(types::list<T> &seq, F &&value)
+    {
+      seq.push_back(std::forward<F>(value));
+      return builtins::None;
+    }
+    template <class T, class F>
+    types::none_type append(types::list<T> &&seq, F &&value)
+    {
+      seq.push_back(std::forward<F>(value));
+      return builtins::None;
+    }
+  }
+}
+PYTHONIC_NS_END
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/list/count.hpp

@@ -0,0 +1,7 @@
+#ifndef PYTHONIC_BUILTIN_LIST_COUNT_HPP
+#define PYTHONIC_BUILTIN_LIST_COUNT_HPP
+
+#include "pythonic/include/builtins/list/count.hpp"
+#include "pythonic/__dispatch__/count.hpp"
+
+#endif

buildroot-external/rootfs-overlay/usr/lib/python3.10/site-packages/pythran/pythonic/builtins/list/extend.hpp

@@ -0,0 +1,39 @@
+#ifndef PYTHONIC_BUILTIN_LIST_EXTEND_HPP
+#define PYTHONIC_BUILTIN_LIST_EXTEND_HPP
+
+#include "pythonic/include/builtins/list/extend.hpp"
+
+#include "pythonic/builtins/None.hpp"
+#include "pythonic/types/list.hpp"
+#include "pythonic/types/NoneType.hpp"
+#include "pythonic/utils/functor.hpp"
+
+PYTHONIC_NS_BEGIN
+
+namespace builtins
+{
+
+  namespace list
+  {
+    template <class T0, class T1>
+    typename std::enable_if<
+        !std::is_same<typename std::decay<T0>::type, types::empty_list>::value,
+        types::none_type>::type
+    extend(T0 &&seq, T1 const &add)
+    {
+      std::forward<T0>(seq) += add;
+      return {};
+    }
+
+    template <class T0, class T1>
+    typename std::enable_if<
+        std::is_same<typename std::decay<T0>::type, types::empty_list>::value,
+        types::none_type>::type
+    extend(T0 &&seq, T1 const &add)
+    {
+      return {};
+    }
+  }
+}
+PYTHONIC_NS_END
+#endif