l0n0lc 0.3.2__py3-none-any.whl → 0.5.0__py3-none-any.whl

l0n0lc//351/200/232/347/224/250.py

@@ -0,0 +1,134 @@
+import re
+import os
+import inspect
+from typing import List, Optional, Any, Dict
+
+
+def 变量名(var):
+    frame = inspect.currentframe()
+    if frame is None:
+        return
+    frame = frame.f_back
+    if frame is None:
+        return
+    for name, value in frame.f_locals.items():
+        if value is var:
+            return name
+    for name, value in frame.f_globals.items():
+        if value is var:
+            return name
+    return None
+
+
+def 上层变量名(var):
+    frame = inspect.currentframe()
+    if frame is None:
+        return
+    frame = frame.f_back
+    if frame is None:
+        return
+    counter = 0
+    for name, value in frame.f_locals.items():
+        if value is var:
+            counter += 1
+            if counter > 1:
+                return name
+    for name, value in frame.f_globals.items():
+        if value is var:
+            counter += 1
+            if counter > 1:
+                return name
+    return None
+
+
+def 十进制转换为其他进制(数值: int, 进制: int, digits="0123456789ABCDEF"):
+    if 数值 == 0:
+        return "0"
+    result = ""
+    is_negative = 数值 < 0
+    数值 = abs(数值)
+    while 数值 > 0:
+        数值, remainder = divmod(数值, 进制)  # 除基取余
+        result = digits[remainder] + result  # 余数映射字符
+    return ("-" if is_negative else "") + result
+
+
+class c函数映射:
+    def __init__(
+            self, 目标函数,
+            include目录: Optional[List[str]],
+            库列表: Optional[List[str]],
+            库目录: Optional[List[str]]) -> None:
+        self.目标函数 = 目标函数
+        self.include目录 = include目录 or []
+        self.库列表 = 库列表 or []
+        self.库目录 = 库目录 or []
+
+
+class 通用信息:
+    直接调用函数 = set()
+    函数映射表: Dict[Any, c函数映射] = {}
+    include表 = set()
+    连接库表 = set()
+    变量最大ID = 0
+    python内置映射 = {}
+    使用unicode编程 = True
+    工作文件夹地址 = './l0n0lcoutput'
+
+    @staticmethod
+    def 缓存接调用函数():
+        通用信息.直接调用函数.add(range)
+
+    @staticmethod
+    def 添加内置映射(v):
+        通用信息.python内置映射[v.__name__] = v
+
+    @staticmethod
+    def 内置映射():
+        for v in [int, float, str, bool, range, complex, set, tuple, list, dict,
+                  print, input, abs, round, pow, divmod, sum, min, max,
+                  isinstance, len, open, ]:
+            通用信息.添加内置映射(v)
+
+
+通用信息.内置映射()
+
+
+def 直接调用函数(fn):
+    通用信息.直接调用函数.add(fn)
+    return fn
+
+
+def 映射函数(
+        被映射函数,
+        include目录: Optional[List[str]] = None,
+        链接库列表: Optional[List[str]] = None,
+        库目录列表: Optional[List[str]] = None):
+    def 装饰器(映射目标):
+        通用信息.函数映射表[被映射函数] = c函数映射(映射目标, include目录, 链接库列表, 库目录列表)
+        return 映射目标
+    return 装饰器
+
+
+def 有非英文变量字符(s):
+    return bool(re.search(r'[^A-Za-z0-9_]', s))
+
+
+def 生成变量Id(原始名字: str | None = None):
+    if 原始名字 is not None and (通用信息.使用unicode编程 or not 有非英文变量字符(原始名字)):
+        return 原始名字
+    ret = f'_{通用信息.变量最大ID}'
+    通用信息.变量最大ID += 1
+    return ret
+
+
+def 尝试创建文件夹(文件夹名: str):
+    if os.path.exists(文件夹名):
+        return
+    os.mkdir(文件夹名)
+
+
+def toCString(v):
+    if isinstance(v, str):
+        return f'u8"{v}"'
+    return str(v)

l0n0lc-0.5.0.dist-info/METADATA

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: l0n0lc
+Version: 0.5.0
+Summary: 用python写c
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.26.0
+Dynamic: license-file
+
+# 将python函数翻译为c++函数并运行
+
+## hello_world.py
+```python
+import l0n0lc as lc
+import math
+
+
+@lc.映射函数(math.ceil, ['<cmath>'])
+def cpp_ceil(v):
+    return f'std::ceil({lc.toCString(v)});'
+
+
+@lc.映射函数(print, ['<iostream>'])
+def cpp_cout(*args):
+    code = f'std::cout'
+    for arg in args:
+        code += f'<< {lc.toCString(arg)} << " "'
+    code += '<< std::endl;'
+    return code
+
+
+@lc.jit(每次运行都重新编译=True)
+def test_add(a: int, b: int) -> int:
+    if a > 1:
+        return a + b
+    for i in range(1, 10, 2):
+        a += i
+    for i in [1, 2, 3]:
+        a += i
+    a = math.ceil(12.5)
+    cc = {'a': 1, 'b': 2}
+    cc['123'] = 111
+    aa = [1, 3, 2]
+    aa[0] = 134
+    for i in range(3):
+        print(i, aa[i])
+    print('Hello World', a, b)
+    return a + b + 1
+
+
+print(test_add(1, 3))
+```
+## 执行hello_world.py
+```bash
+$ python hello_world.py
+0 134 
+1 3 
+2 2 
+Hello World 13 3 
+17
+```
+## 查看生成的c++代码文件
+```bash
+$ ls -al l0n0lcoutput
+total 44
+drwxr-xr-x  2 root root  4096 Sep 11 01:38 .
+drwxrwxrwx 12 1000 1000  4096 Sep 10 02:36 ..
+-rw-r--r--  1 root root   599 Sep 11 01:38 test_add_@402bbf73254216d8.cpp
+-rw-r--r--  1 root root   150 Sep 11 01:38 test_add_@402bbf73254216d8.h
+-rwxr-xr-x  1 root root 25264 Sep 11 01:38 test_add_@402bbf73254216d8.so
+```
+
+## test_add_@402bbf73254216d8.h
+
+```c++
+#include <cmath>
+#include <cstdint>
+#include <iostream>
+#include <string>
+#include <unordered_map>
+extern "C" int64_t test_add (int64_t a, int64_t b);
+```
+
+## test_add_@402bbf73254216d8.cpp
+```c++
+#include "test_add_@402bbf73254216d8.h"
+extern "C" int64_t test_add (int64_t a, int64_t b)
+{
+  if ((a > 1))
+  {
+    return a + b;
+  }
+
+  for (int64_t i = 1; i < 10; i += 2)
+  {
+    a = a + i;
+  }
+
+  for (auto i : {1,2,3})
+  {
+    a = a + i;
+  }
+
+  a = std::ceil(12.5);;
+  std::unordered_map<std::string, int64_t> cc = {{ u8"a", 1 },{ u8"b", 2 }};
+  cc[u8"123"] = 111;
+  int64_t aa[] = {1,3,2};
+  aa[0] = 134;
+  for (int64_t i = 0; i < 3; ++i)
+  {
+    std::cout<< i << " "<< aa[i] << " "<< std::endl;
+  }
+
+  std::cout<< u8"Hello World" << " "<< a << " "<< b << " "<< std::endl;
+  return a + b + 1;
+}
+
+```

l0n0lc-0.5.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+l0n0lc/StdList.py,sha256=fA6sWAfW2JgDUhQDK2Hlx_PPuSdLwTcCTk5aha4zA-Q,863
+l0n0lc/StdMap.py,sha256=TIVKqhT078cjLIM0Zlq-TwGFSy-KwOyJe00BLFPVxr8,735
+l0n0lc/__init__.py,sha256=fUC6TMeN_fEL7HDazrBEdoWOQkXi5uSGZb7LZj6juog,137
+l0n0lc/c基础处理.py,sha256=ZJEMxK1MyRAgbUnpfUUZC0ZHj61RCD6UMlhVssCyiCE,8201
+l0n0lc/jit.py,sha256=zI6erRTE90chukkpovOCwAHXxFUI-SSaDvsmFKHwLYs,22718
+l0n0lc/编译.py,sha256=f1ugdTpnKcDOprcGu2Q5zMm_sYdxWMphBeo4ZL-cW3o,2016
+l0n0lc/通用.py,sha256=O_Y4bbW1WzHCJkibxAy9WGACv-aEZJLG-fEeVBcAbBQ,3649
+l0n0lc-0.5.0.dist-info/licenses/LICENSE,sha256=1L-MAjulZ3kpbYwsJtlXpDVITRxykna2Ecg_521YfkA,1093
+l0n0lc-0.5.0.dist-info/METADATA,sha256=bpEXrXY0TGG96jvvcscid62YkzZWcQcLMNH6KfruUDc,2429
+l0n0lc-0.5.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+l0n0lc-0.5.0.dist-info/top_level.txt,sha256=Q21D_eEY_-xgRUPwATGp9YDKSBO4w_7MI2MYxQI1aT4,7
+l0n0lc-0.5.0.dist-info/RECORD,,

l0n0lc/c/345/237/237.py

@@ -1,152 +0,0 @@
-from typing import List, Union
-from .输出 import 输出函数
-import types
-当前域 = []
-
-
-def 进入域(域):
-    当前域.append(域)
-
-
-def 退出域():
-    当前域.pop(-1)
-
-
-def 输出(内容: str, 输出前缀: bool = True):
-    if 输出前缀:
-        for i in range(len(当前域)):
-            输出函数('    ')
-    输出函数(内容)
-
-
-class 花括号:
-    def __enter__(self, *args, **kwargs):
-        输出("{\n")
-        进入域(self)
-
-    def __exit__(self, *args, **kwargs):
-        退出域()
-        输出("}\n")
-
-
-class c函数域:
-    def __init__(
-            self,
-            函数名: str,
-            参数名及类型,
-            返回类型,
-            前缀: Union[None, str, List[str]] = None) -> None:
-        self.函数名 = 函数名
-        self.参数名及类型 = 参数名及类型
-        try:
-            self.返回类型 = getattr(返回类型, '类型名')
-        except:
-            self.返回类型 = None
-        if isinstance(前缀, str):
-            self.前缀 = 前缀
-        elif isinstance(前缀, list):
-            self.前缀 = ' '.join(前缀)
-        else:
-            self.前缀 = ''
-
-    def __enter__(self, *args, **kwargs):
-        输出(self.前缀)
-        输出(' ')
-        if self.返回类型 is None:
-            输出('void ')
-        else:
-            输出(self.返回类型)
-        输出(' ', False)
-        输出(self.函数名, False)
-        输出('(', False)
-        参数数量 = len(self.参数名及类型.keys())
-        i = 0
-        for k, v in self.参数名及类型.items():
-            if k == 'self':
-                i += 1
-                continue
-            输出(f'{v.annotation.类型名} {k}', False)
-            if i < 参数数量 - 1:
-                输出(', ', False)
-            i += 1
-        输出(')', False)
-        输出("{\n", False)
-        进入域(self)
-        return self
-
-    def __exit__(self, *args, **kwargs):
-        退出域()
-        输出("}\n")
-
-    def 返回(self, 返回值):
-        输出(f'return {str(返回值)};\n')
-
-
-class c结构体域:
-    def __init__(self, 类型名: str) -> None:
-        self.类型名 = 类型名
-
-    def __enter__(self, *args, **kwargs):
-        输出(f"struct {self.类型名}")
-        输出("{\n")
-        进入域(self)
-
-    def __exit__(self, *args, **kwargs):
-        退出域()
-        输出("};\n")
-
-
-class 如果:
-    def __init__(self, 条件) -> types.NoneType:
-        self.条件 = 条件
-
-    def __enter__(self, *args, **kwargs):
-        输出(f"if ({self.条件}){{\n")
-        进入域(self)
-
-    def __exit__(self, *args, **kwargs):
-        退出域()
-        输出("}\n")
-
-
-class 否则:
-    def __enter__(self, *args, **kwargs):
-        输出("else {\n")
-        进入域(self)
-
-    def __exit__(self, *args, **kwargs):
-        退出域()
-        输出("}\n")
-
-
-class 否则如果:
-    def __init__(self, 条件) -> types.NoneType:
-        self.条件 = 条件
-
-    def __enter__(self, *args, **kwargs):
-        输出(f"else if ({self.条件}){{\n")
-        进入域(self)
-
-    def __exit__(self, *args, **kwargs):
-        退出域()
-        输出("}\n")
-
-
-class 循环:
-    def __init__(self, 条件) -> types.NoneType:
-        self.条件 = 条件
-
-    def __enter__(self, *args, **kwargs):
-        输出(f"while ({self.条件}){{\n")
-        进入域(self)
-        return self
-
-    def __exit__(self, *args, **kwargs):
-        退出域()
-        输出("}\n")
-
-    def 继续(self):
-        输出("continue;\n")
-
-    def 跳出(self):
-        输出("break;\n")

l0n0lc/c/345/237/272/347/241/200/347/261/273/345/236/213.py

@@ -1,209 +0,0 @@
-
-from .c类型基础 import c类型基础
-
-class i8(c类型基础):
-    类型名 = 'int8_t'
-
-class i8_p(c类型基础):
-    类型名 = f'int8_t*'
-
-class i8_p_p(c类型基础):
-    类型名 = f'int8_t**'    
-
-class i16(c类型基础):
-    类型名 = 'int16_t'
-
-class i16_p(c类型基础):
-    类型名 = f'int16_t*'
-
-class i16_p_p(c类型基础):
-    类型名 = f'int16_t**'    
-
-class i32(c类型基础):
-    类型名 = 'int32_t'
-
-class i32_p(c类型基础):
-    类型名 = f'int32_t*'
-
-class i32_p_p(c类型基础):
-    类型名 = f'int32_t**'    
-
-class i64(c类型基础):
-    类型名 = 'int64_t'
-
-class i64_p(c类型基础):
-    类型名 = f'int64_t*'
-
-class i64_p_p(c类型基础):
-    类型名 = f'int64_t**'    
-
-class u8(c类型基础):
-    类型名 = 'uint8_t'
-
-class u8_p(c类型基础):
-    类型名 = f'uint8_t*'
-
-class u8_p_p(c类型基础):
-    类型名 = f'uint8_t**'    
-
-class u16(c类型基础):
-    类型名 = 'uint16_t'
-
-class u16_p(c类型基础):
-    类型名 = f'uint16_t*'
-
-class u16_p_p(c类型基础):
-    类型名 = f'uint16_t**'    
-
-class u32(c类型基础):
-    类型名 = 'uint32_t'
-
-class u32_p(c类型基础):
-    类型名 = f'uint32_t*'
-
-class u32_p_p(c类型基础):
-    类型名 = f'uint32_t**'    
-
-class u64(c类型基础):
-    类型名 = 'uint64_t'
-
-class u64_p(c类型基础):
-    类型名 = f'uint64_t*'
-
-class u64_p_p(c类型基础):
-    类型名 = f'uint64_t**'    
-
-class bf16(c类型基础):
-    类型名 = 'bfloat16_t'
-
-class bf16_p(c类型基础):
-    类型名 = f'bfloat16_t*'
-
-class bf16_p_p(c类型基础):
-    类型名 = f'bfloat16_t**'    
-
-class f16(c类型基础):
-    类型名 = 'half'
-
-class f16_p(c类型基础):
-    类型名 = f'half*'
-
-class f16_p_p(c类型基础):
-    类型名 = f'half**'    
-
-class f32(c类型基础):
-    类型名 = 'float'
-
-class f32_p(c类型基础):
-    类型名 = f'float*'
-
-class f32_p_p(c类型基础):
-    类型名 = f'float**'    
-
-class f64(c类型基础):
-    类型名 = 'double'
-
-class f64_p(c类型基础):
-    类型名 = f'double*'
-
-class f64_p_p(c类型基础):
-    类型名 = f'double**'    
-
-class boolean(c类型基础):
-    类型名 = 'bool'
-
-class boolean_p(c类型基础):
-    类型名 = f'bool*'
-
-class boolean_p_p(c类型基础):
-    类型名 = f'bool**'    
-
-class char(c类型基础):
-    类型名 = 'char'
-
-class char_p(c类型基础):
-    类型名 = f'char*'
-
-class char_p_p(c类型基础):
-    类型名 = f'char**'    
-
-class uchar(c类型基础):
-    类型名 = 'unsigned char'
-
-class uchar_p(c类型基础):
-    类型名 = f'unsigned char*'
-
-class uchar_p_p(c类型基础):
-    类型名 = f'unsigned char**'    
-
-class int(c类型基础):
-    类型名 = 'int'
-
-class int_p(c类型基础):
-    类型名 = f'int*'
-
-class int_p_p(c类型基础):
-    类型名 = f'int**'    
-
-class uint(c类型基础):
-    类型名 = 'unsigned int'
-
-class uint_p(c类型基础):
-    类型名 = f'unsigned int*'
-
-class uint_p_p(c类型基础):
-    类型名 = f'unsigned int**'    
-
-class short(c类型基础):
-    类型名 = 'short'
-
-class short_p(c类型基础):
-    类型名 = f'short*'
-
-class short_p_p(c类型基础):
-    类型名 = f'short**'    
-
-class ushort(c类型基础):
-    类型名 = 'unsigned short'
-
-class ushort_p(c类型基础):
-    类型名 = f'unsigned short*'
-
-class ushort_p_p(c类型基础):
-    类型名 = f'unsigned short**'    
-
-class long(c类型基础):
-    类型名 = 'long'
-
-class long_p(c类型基础):
-    类型名 = f'long*'
-
-class long_p_p(c类型基础):
-    类型名 = f'long**'    
-
-class ulong(c类型基础):
-    类型名 = 'unsigned long'
-
-class ulong_p(c类型基础):
-    类型名 = f'unsigned long*'
-
-class ulong_p_p(c类型基础):
-    类型名 = f'unsigned long**'    
-
-class longlong(c类型基础):
-    类型名 = 'long long'
-
-class longlong_p(c类型基础):
-    类型名 = f'long long*'
-
-class longlong_p_p(c类型基础):
-    类型名 = f'long long**'    
-
-class ulonglong(c类型基础):
-    类型名 = 'unsigned long long'
-
-class ulonglong_p(c类型基础):
-    类型名 = f'unsigned long long*'
-
-class ulonglong_p_p(c类型基础):
-    类型名 = f'unsigned long long**'