l0n0lc 0.1.2__tar.gz → 0.2.0__tar.gz

{l0n0lc-0.1.2 → l0n0lc-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: l0n0lc
-Version: 0.1.2
+Version: 0.2.0
 Summary: 用python写c
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.10

l0n0lc-0.2.0/l0n0lc/__init__.py

@@ -0,0 +1,6 @@
+from .输出 import 配置输出函数
+from .c类型基础 import c类型基础, c_void, c_void_p, c函数, c结构体, c数组
+from .c域 import 花括号, 如果, 否则, 否则如果, 循环, 输出
+from .c基础类型 import *
+from .c语句 import *
+from .编译 import 编译

{l0n0lc-0.1.2 → l0n0lc-0.2.0}/l0n0lc/c/345/237/237.py

@@ -29,7 +29,7 @@ class 花括号:
         输出("}\n")
 
 
-class c_函数域:
+class c函数域:
     def __init__(
             self,
             函数名: str,

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

@@ -0,0 +1,191 @@
+
+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 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 bool(c类型基础):
+    类型名 = 'bool'
+
+class bool_p(c类型基础):
+    类型名 = f'bool*'
+
+class bool_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**'    

{l0n0lc-0.1.2 → l0n0lc-0.2.0}/l0n0lc/c/347/261/273/345/236/213/345/237/272/347/241/200.py

@@ -1,10 +1,10 @@
 from .utils import 十进制转换为其他进制
 from typing import Union, Any, Callable, Type, List
-from .c域 import 输出, c_函数域, c_结构体域
+from .c域 import 输出, c函数域, c_结构体域
 import inspect
 
 
-class c_类型基础:
+class c类型基础:
     _进制字符 = "0123456789abcdefghigklmnopqrstuvwxyzABCDEFGHIGKLMNOPQRSTUVWXYZ"
     变量自增ID = 0
     类型名 = ''
@@ -12,8 +12,8 @@ class c_类型基础:
 
     @staticmethod
     def 生成ID():
-        ID = '_' + 十进制转换为其他进制(c_类型基础.变量自增ID, len(c_类型基础._进制字符), c_类型基础._进制字符)
-        c_类型基础.变量自增ID += 1
+        ID = '_' + 十进制转换为其他进制(c类型基础.变量自增ID, len(c类型基础._进制字符), c类型基础._进制字符)
+        c类型基础.变量自增ID += 1
         return ID
 
     def __init__(
@@ -23,7 +23,7 @@ class c_类型基础:
             是静态变量: Union[bool, None] = False,
             使用等号赋值: bool = False):
         self.类型 = self.__class__.类型名
-        self.变量名 = 变量名 or c_类型基础.生成ID()
+        self.变量名 = 变量名 or c类型基础.生成ID()
         self.是静态变量 = 是静态变量  # TODO
         self.使用等号赋值 = 使用等号赋值
         self.初始值 = 初始值
@@ -181,12 +181,12 @@ class c_类型基础:
 
 
 def 创建普通类(类型: str) -> Type:
-    class 类(c_类型基础):
+    class 类(c类型基础):
         类型名 = 类型
     return 类
 
 
-class c_void(c_类型基础):
+class c_void(c类型基础):
     类型名 = 'void'
 
     def __init__(self):
@@ -200,23 +200,23 @@ class c_void(c_类型基础):
         pass
 
 
-class c_void_p(c_类型基础):
+class c_void_p(c类型基础):
     类型名 = 'void*'
 
 
-class 已存在变量(c_类型基础):
+class 已存在变量(c类型基础):
     def __init__(self, 变量名: str) -> None:
         self.变量名 = 变量名
 
 
-def c_结构体():
+def c结构体():
     def 装饰函数(fn: Callable):
         定义 = fn()
         with c_结构体域(fn.__name__):
             for 字段名, (类型, 默认值) in 定义.items():
                 类型(默认值, 变量名=字段名, 使用等号赋值=True)
 
-        class 结构体类(c_类型基础):
+        class 结构体类(c类型基础):
             类型名 = fn.__name__
             是结构体类 = True
         return 结构体类
@@ -228,12 +228,12 @@ def 根据signature构建并调用函数(
         self_=None,
         前缀: Union[None, str, List[str]] = None):
     sig = inspect.signature(fn)
-    with c_函数域(fn.__name__, sig.parameters,
+    with c函数域(fn.__name__, sig.parameters,
                sig.return_annotation, 前缀) as f:
         参数列表 = []
 
         for 参数名, 参数 in sig.parameters.items():
-            class Temp(c_类型基础):
+            class Temp(c类型基础):
                 类型名 = 参数.annotation.类型名
                 是结构体类 = 参数.annotation.是结构体类
 
@@ -248,9 +248,9 @@ def 根据signature构建并调用函数(
     return f
 
 
-def 调用函数域(fn: c_函数域, *args):
+def 调用函数域(fn: c函数域, *args):
     参数字符串 = ', '.join([str(arg) for arg in args])
-    ID = c_类型基础.生成ID()
+    ID = c类型基础.生成ID()
     if fn.返回类型 == 'void':
         输出(f'{fn.函数名} ({参数字符串});\n')
         return 已存在变量('')
@@ -259,7 +259,7 @@ def 调用函数域(fn: c_函数域, *args):
         return 已存在变量(ID)
 
 
-def c_函数(前缀: Union[None, str, List[str]] = None):
+def c函数(前缀: Union[None, str, List[str]] = None):
     class 装饰类:
         def __init__(self, fn: Callable) -> None:
             self.函数 = 根据signature构建并调用函数(
@@ -272,8 +272,8 @@ def c_函数(前缀: Union[None, str, List[str]] = None):
     return 装饰类
 
 
-def c_数组(类型, 长度: int):
-    class c_数组类型(c_类型基础):
+def c数组(类型, 长度: int):
+    class c_数组类型(c类型基础):
         类型名 = f'{类型.类型名}*'
         数组长度 = 长度
 

{l0n0lc-0.1.2 → l0n0lc-0.2.0}/l0n0lc.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: l0n0lc
-Version: 0.1.2
+Version: 0.2.0
 Summary: 用python写c
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.10

{l0n0lc-0.1.2 → l0n0lc-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "l0n0lc"
-version = "0.1.2"
+version = "0.2.0"
 description = "用python写c"
 readme = "README.md"
 requires-python = ">=3.10"

l0n0lc-0.1.2/l0n0lc/__init__.py

@@ -1,6 +0,0 @@
-from .输出 import 配置输出函数
-from .c类型基础 import c_类型基础, c_void, c_void_p, c_函数, c_结构体, c_数组
-from .c域 import 花括号, c_函数域, 如果, 否则, 否则如果, 循环, 输出
-from .c基础类型 import *
-from .c语句 import *
-from .编译 import 编译

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

@@ -1,191 +0,0 @@
-
-from .c类型基础 import c_类型基础
-
-class c_i8(c_类型基础):
-    类型名 = 'int8_t'
-
-class c_i8_p(c_类型基础):
-    类型名 = f'int8_t*'
-
-class c_i8_p_p(c_类型基础):
-    类型名 = f'int8_t**'    
-
-class c_i16(c_类型基础):
-    类型名 = 'int16_t'
-
-class c_i16_p(c_类型基础):
-    类型名 = f'int16_t*'
-
-class c_i16_p_p(c_类型基础):
-    类型名 = f'int16_t**'    
-
-class c_i32(c_类型基础):
-    类型名 = 'int32_t'
-
-class c_i32_p(c_类型基础):
-    类型名 = f'int32_t*'
-
-class c_i32_p_p(c_类型基础):
-    类型名 = f'int32_t**'    
-
-class c_i64(c_类型基础):
-    类型名 = 'int64_t'
-
-class c_i64_p(c_类型基础):
-    类型名 = f'int64_t*'
-
-class c_i64_p_p(c_类型基础):
-    类型名 = f'int64_t**'    
-
-class c_u8(c_类型基础):
-    类型名 = 'uint8_t'
-
-class c_u8_p(c_类型基础):
-    类型名 = f'uint8_t*'
-
-class c_u8_p_p(c_类型基础):
-    类型名 = f'uint8_t**'    
-
-class c_u16(c_类型基础):
-    类型名 = 'uint16_t'
-
-class c_u16_p(c_类型基础):
-    类型名 = f'uint16_t*'
-
-class c_u16_p_p(c_类型基础):
-    类型名 = f'uint16_t**'    
-
-class c_u32(c_类型基础):
-    类型名 = 'uint32_t'
-
-class c_u32_p(c_类型基础):
-    类型名 = f'uint32_t*'
-
-class c_u32_p_p(c_类型基础):
-    类型名 = f'uint32_t**'    
-
-class c_u64(c_类型基础):
-    类型名 = 'uint64_t'
-
-class c_u64_p(c_类型基础):
-    类型名 = f'uint64_t*'
-
-class c_u64_p_p(c_类型基础):
-    类型名 = f'uint64_t**'    
-
-class c_f32(c_类型基础):
-    类型名 = 'float'
-
-class c_f32_p(c_类型基础):
-    类型名 = f'float*'
-
-class c_f32_p_p(c_类型基础):
-    类型名 = f'float**'    
-
-class c_f64(c_类型基础):
-    类型名 = 'double'
-
-class c_f64_p(c_类型基础):
-    类型名 = f'double*'
-
-class c_f64_p_p(c_类型基础):
-    类型名 = f'double**'    
-
-class c_bool(c_类型基础):
-    类型名 = 'bool'
-
-class c_bool_p(c_类型基础):
-    类型名 = f'bool*'
-
-class c_bool_p_p(c_类型基础):
-    类型名 = f'bool**'    
-
-class c_char(c_类型基础):
-    类型名 = 'char'
-
-class c_char_p(c_类型基础):
-    类型名 = f'char*'
-
-class c_char_p_p(c_类型基础):
-    类型名 = f'char**'    
-
-class c_uchar(c_类型基础):
-    类型名 = 'unsigned char'
-
-class c_uchar_p(c_类型基础):
-    类型名 = f'unsigned char*'
-
-class c_uchar_p_p(c_类型基础):
-    类型名 = f'unsigned char**'    
-
-class c_int(c_类型基础):
-    类型名 = 'int'
-
-class c_int_p(c_类型基础):
-    类型名 = f'int*'
-
-class c_int_p_p(c_类型基础):
-    类型名 = f'int**'    
-
-class c_uint(c_类型基础):
-    类型名 = 'unsigned int'
-
-class c_uint_p(c_类型基础):
-    类型名 = f'unsigned int*'
-
-class c_uint_p_p(c_类型基础):
-    类型名 = f'unsigned int**'    
-
-class c_short(c_类型基础):
-    类型名 = 'short'
-
-class c_short_p(c_类型基础):
-    类型名 = f'short*'
-
-class c_short_p_p(c_类型基础):
-    类型名 = f'short**'    
-
-class c_ushort(c_类型基础):
-    类型名 = 'unsigned short'
-
-class c_ushort_p(c_类型基础):
-    类型名 = f'unsigned short*'
-
-class c_ushort_p_p(c_类型基础):
-    类型名 = f'unsigned short**'    
-
-class c_long(c_类型基础):
-    类型名 = 'long'
-
-class c_long_p(c_类型基础):
-    类型名 = f'long*'
-
-class c_long_p_p(c_类型基础):
-    类型名 = f'long**'    
-
-class c_ulong(c_类型基础):
-    类型名 = 'unsigned long'
-
-class c_ulong_p(c_类型基础):
-    类型名 = f'unsigned long*'
-
-class c_ulong_p_p(c_类型基础):
-    类型名 = f'unsigned long**'    
-
-class c_longlong(c_类型基础):
-    类型名 = 'long long'
-
-class c_longlong_p(c_类型基础):
-    类型名 = f'long long*'
-
-class c_longlong_p_p(c_类型基础):
-    类型名 = f'long long**'    
-
-class c_ulonglong(c_类型基础):
-    类型名 = 'unsigned long long'
-
-class c_ulonglong_p(c_类型基础):
-    类型名 = f'unsigned long long*'
-
-class c_ulonglong_p_p(c_类型基础):
-    类型名 = f'unsigned long long**'