l0n0lc 0.1.0__py3-none-any.whl

l0n0lc/__init__.py

@@ -0,0 +1,6 @@
+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/c/345/237/237.py

@@ -0,0 +1,152 @@
+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

@@ -0,0 +1,191 @@
+
+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**'    

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

@@ -0,0 +1,296 @@
+from .utils import 十进制转换为其他进制
+from typing import Union, Any, Callable, Type, List
+from .c域 import 输出, c_函数域, c_结构体域
+import inspect
+
+
+class c_类型基础:
+    _进制字符 = "0123456789abcdefghigklmnopqrstuvwxyzABCDEFGHIGKLMNOPQRSTUVWXYZ"
+    变量自增ID = 0
+    类型名 = ''
+    是结构体类 = False
+
+    @staticmethod
+    def 生成ID():
+        ID = '_' + 十进制转换为其他进制(c_类型基础.变量自增ID, len(c_类型基础._进制字符), c_类型基础._进制字符)
+        c_类型基础.变量自增ID += 1
+        return ID
+
+    def __init__(
+            self,
+            初始值: Union[Any, None] = '',
+            变量名: Union[str, None] = None,
+            是静态变量: Union[bool, None] = False,
+            使用等号赋值: bool = False):
+        self.类型 = self.__class__.类型名
+        self.变量名 = 变量名 or c_类型基础.生成ID()
+        self.是静态变量 = 是静态变量  # TODO
+        self.使用等号赋值 = 使用等号赋值
+        self.初始值 = 初始值
+        self.生成初始值字符串()
+        self.输出定义()
+
+    def 类型名称(self):
+        return f'{self.类型}'
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'({self.初始值})'
+        if self.使用等号赋值:
+            self.初始化字符串 = f'= {self.初始化字符串}'
+        if isinstance(self.初始值, str) and len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+
+    def 赋值为(self, new_value):
+        输出(f'{self.变量名} = ({new_value});\n')
+
+    def 获取成员值(self, 字段名: str):
+        if self.__class__.类型名.strip().endswith('*'):
+            return f'{self.变量名}->{字段名}'
+        else:
+            return f'{self.变量名}.{字段名}'
+
+    def 成员赋值(self, 字段名: str, 数值):
+        if self.__class__.类型名.strip().endswith('*'):
+            输出(f'{self.变量名}->{字段名} = {数值};\n')
+        else:
+            输出(f'{self.变量名}.{字段名} = {数值};\n')
+
+    def __str__(self) -> str:
+        return self.变量名
+
+    def 取址(self):
+        return f'(&{self.变量名})'
+
+    def 析址(self):
+        return f'(*{self.变量名})'
+
+    def __add__(self, other):
+        return f'{self} + {other}'
+
+    def __sub__(self, other):
+        return f'{self} - {other}'
+
+    def __mul__(self, other):
+        return f'{self} * {other}'
+
+    def __truediv__(self, other):
+        return f'{self} / {other}'
+
+    def __mod__(self, other):
+        return f'{self} % {other}'
+
+    def __lshift__(self, other):
+        return f'{self} << {other}'
+
+    def __rshift__(self, other):
+        return f'{self} >> {other}'
+
+    def __and__(self, other):
+        return f'{self} & {other}'
+
+    def __or__(self, other):
+        return f'{self} | {other}'
+
+    def __xor__(self, other):
+        return f'{self} ^ {other}'
+
+    def __iadd__(self, other):
+        输出(f'{self} += {other};\n')
+        return self
+
+    def __isub__(self, other):
+        输出(f'{self} -= {other}\n')
+        return self
+
+    def __imul__(self, other):
+        输出(f'{self} *= {other}\n')
+        return self
+
+    def __itruediv__(self, other):
+        输出(f'{self} /= {other}\n')
+        return self
+
+    def __imod__(self, other):
+        输出(f'{self} %= {other}\n')
+        return self
+
+    def __ilshift__(self, other):
+        输出(f'{self} <<= {other}\n')
+        return self
+
+    def __irshift__(self, other):
+        输出(f'{self} >>= {other}\n')
+        return self
+
+    def __iand__(self, other):
+        输出(f'{self} &= {other}\n')
+        return self
+
+    def __ior__(self, other):
+        输出(f'{self} |= {other}\n')
+        return self
+
+    def __ixor__(self, other):
+        输出(f'{self} ^= {other}\n')
+        return self
+
+    def __invert__(self):
+        return f'~{self}'
+
+    def __getitem__(self, key):
+        return f'{self}[{key}]'
+
+    def __setitem__(self, key, value):
+        输出(f'{self}[{key}] = {value};\n')
+
+    def __call__(self, *args: Any) -> Any:
+        if self.__class__.是结构体类:
+            if len(args) == 0:
+                return self.赋值为
+            if len(args) == 1:
+                return self.获取成员值(args[0])
+            if len(args) == 2:
+                self.成员赋值(args[0], args[1])
+            return self
+
+        self.赋值为(args[0])
+
+    def 等于(self, other):
+        return f'{self} == {other}'
+
+    def 不等于(self, other):
+        return f'{self} != {other}'
+
+    def 大于(self, other):
+        return f'{self} > {other}'
+
+    def 小于(self, other):
+        return f'{self} < {other}'
+
+    def 大于等于(self, other):
+        return f'{self} >= {other}'
+
+    def 小于等于(self, other):
+        return f'{self} <= {other}'
+
+    def 强转(self, 类型):
+        return f'(({类型.类型名}){self})'
+
+
+def 创建普通类(类型: str) -> Type:
+    class 类(c_类型基础):
+        类型名 = 类型
+    return 类
+
+
+class c_void(c_类型基础):
+    类型名 = 'void'
+
+    def __init__(self):
+        self.类型 = self.__class__.类型名
+        self.变量名 = ''
+
+    def 输出定义(self):
+        pass
+
+    def 赋值为(self, new_value):
+        pass
+
+
+class c_void_p(c_类型基础):
+    类型名 = 'void*'
+
+
+class 已存在变量(c_类型基础):
+    def __init__(self, 变量名: str) -> None:
+        self.变量名 = 变量名
+
+
+def c_结构体():
+    def 装饰函数(fn: Callable):
+        定义 = fn()
+        with c_结构体域(fn.__name__):
+            for 字段名, (类型, 默认值) in 定义.items():
+                类型(默认值, 变量名=字段名, 使用等号赋值=True)
+
+        class 结构体类(c_类型基础):
+            类型名 = fn.__name__
+            是结构体类 = True
+        return 结构体类
+    return 装饰函数
+
+
+def 根据signature构建并调用函数(
+        fn: Callable,
+        self_=None,
+        前缀: Union[None, str, List[str]] = None):
+    sig = inspect.signature(fn)
+    with c_函数域(fn.__name__, sig.parameters,
+               sig.return_annotation, 前缀) as f:
+        参数列表 = []
+
+        for 参数名, 参数 in sig.parameters.items():
+            class Temp(c_类型基础):
+                类型名 = 参数.annotation.类型名
+                是结构体类 = 参数.annotation.是结构体类
+
+                def __init__(self):
+                    self.类型 = Temp.类型名
+                    self.变量名 = 参数名
+
+            参数列表.append(Temp())
+        ret = fn(*参数列表)
+        if ret is not None:
+            f.返回(ret)
+    return f
+
+
+def 调用函数域(fn: c_函数域, *args):
+    参数字符串 = ', '.join([str(arg) for arg in args])
+    ID = c_类型基础.生成ID()
+    if fn.返回类型 == 'void':
+        输出(f'{fn.函数名} ({参数字符串});\n')
+        return 已存在变量('')
+    else:
+        输出(f'auto {ID} = {fn.函数名} ({参数字符串});\n')
+        return 已存在变量(ID)
+
+
+def c_函数(前缀: Union[None, str, List[str]] = None):
+    class 装饰类:
+        def __init__(self, fn: Callable) -> None:
+            self.函数 = 根据signature构建并调用函数(
+                fn, None, 前缀)
+            self.函数名 = fn.__name__
+
+        def __call__(self, *args: Any) -> Any:
+            return 调用函数域(self.函数, *args)
+
+    return 装饰类
+
+
+def c_数组(类型, 长度: int):
+    class c_数组类型(c_类型基础):
+        类型名 = f'{类型.类型名}*'
+        数组长度 = 长度
+
+        def 输出定义(self):
+            if self.使用等号赋值:
+                输出(f'{类型.类型名} {self}[{长度}] = {self.初始化字符串};\n')
+            else:
+                输出(f'{类型.类型名} {self}[{长度}];\n')
+
+        def __getitem__(self, key):
+            if key < 0 or key >= 长度:
+                raise Exception(f'key = {key}。 但是key应该在[0, {长度})之间。')
+            return super().__getitem__(key)
+
+        def __setitem__(self, key, value):
+            if key < 0 or key >= 长度:
+                raise Exception(f'key = {key}。 但是key应该在[0, {长度})之间。')
+            return super().__setitem__(key, value)
+
+    return c_数组类型()

l0n0lc/c/350/257/255/345/217/245.py

@@ -0,0 +1,73 @@
+from .c域 import 输出
+
+
+def c_include(path: str):
+    输出(f'#include "{path}"\n')
+
+
+def c_pragma(v: str):
+    输出(f'#pragma {v}\n')
+
+
+def c_define(名字: str, 值: str):
+    输出(f'#define {名字} {值}\n')
+
+
+def c_undef(名字: str):
+    输出(f'#undef {名字}\n')
+
+
+def c_error(错误信息: str):
+    输出(f'#error "{错误信息}"\n')
+
+
+def c_line(行号: int, 文件名: str):
+    输出(f'#line {行号} {文件名}\n')
+
+
+class 如果定义了:
+    def __init__(self, 宏定义名: str):
+        self.宏定义名 = 宏定义名
+
+    def __enter__(self, *args, **kwargs):
+        输出(f"#ifdef {self.宏定义名}\n")
+        return self
+
+    def __exit__(self, *args, **kwargs):
+        输出("#endif\n")
+
+    def 否则(self):
+        输出("#else\n")
+
+
+class 如果没有定义:
+    def __init__(self, 宏定义名: str):
+        self.宏定义名 = 宏定义名
+
+    def __enter__(self, *args, **kwargs):
+        输出(f"#ifndef {self.宏定义名}\n")
+        return self
+
+    def __exit__(self, *args, **kwargs):
+        输出("#endif\n")
+
+    def 否则(self):
+        输出("#else\n")
+
+
+class 宏如果:
+    def __init__(self, 条件: str):
+        self.条件 = 条件
+
+    def __enter__(self, *args, **kwargs):
+        输出(f"#if {self.条件}\n")
+        return self
+
+    def __exit__(self, *args, **kwargs):
+        输出("#endif\n")
+
+    def 否则(self):
+        输出("#else\n")
+
+    def 否则如果(self, 条件: str):
+        输出(f"#elif {条件}\n")

l0n0lc/utils.py

@@ -0,0 +1,50 @@
+import inspect
+
+
+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

l0n0lc//347/274/226/350/257/221.py

@@ -0,0 +1,54 @@
+from typing import Union, List
+import subprocess
+
+
+class 编译:
+    def __init__(self) -> None:
+        self.编译器 = '/bin/c++'
+        self.include目录列表 = []
+        self.库目录列表 = []
+        self.链接库 = []
+        self.编译选项 = []
+
+    def 设置编译器(self, 编译器地址: str):
+        self.编译器 = 编译器地址
+
+    def 添加include目录(self, 目录: Union[str, List[str]]):
+        if isinstance(目录, str):
+            self.include目录列表.append(目录)
+            return
+        self.include目录列表 += 目录
+
+    def 添加库目录(self, 目录: Union[str, List[str]]):
+        if isinstance(目录, str):
+            self.库目录列表.append(目录)
+            return
+        self.库目录列表 += 目录
+
+    def 添加链接库(self, 库名: Union[str, List[str]]):
+        if isinstance(库名, str):
+            self.链接库.append(库名)
+            return
+        self.链接库 += 库名
+
+    def 添加编译选项(self, 选项: Union[str, List[str]]):
+        if isinstance(选项, str):
+            self.编译选项.append(选项)
+            return
+        self.编译选项 += 选项
+
+    def 编译文件(self, 文件路径: str, 输出路径: str):
+        编译指令 = [self.编译器]
+        include指令 = [f'-I{目录}' for 目录 in self.include目录列表]
+        库目录指令 = [f'-L{目录}' for 目录 in self.库目录列表]
+        库链接指令 = [f'-l{库名}' for 库名 in self.链接库]
+        编译指令 += include指令 + 库目录指令 + 库链接指令 + self.编译选项
+        编译指令.append(文件路径)
+        编译指令.append('-o')
+        编译指令.append(输出路径)
+        subprocess.run(编译指令)
+
+    def 编译为动态库(self, 文件路径: str, 输出路径: str):
+        self.添加编译选项('-fPIC')
+        self.添加编译选项('--shared')
+        self.编译文件(文件路径, 输出路径)

l0n0lc//350/276/223/345/207/272.py

@@ -0,0 +1,17 @@
+import sys
+from typing import Any
+
+
+class 输出:
+    def __init__(self) -> None:
+        self.输出函数 = sys.stdout.write
+
+    def __call__(self, *args: Any, **kwds: Any) -> None:
+        self.输出函数(*args, **kwds)
+
+
+输出函数 = 输出()
+
+
+def 配置输出函数(fn):
+    输出函数.输出函数 = fn

l0n0lc-0.1.0.dist-info/METADATA

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: l0n0lc
+Version: 0.1.0
+Summary: Add your description here
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# 用python写c语言
+```python
+import l0n0lc as lc
+import os
+import ctypes
+
+if not os.path.exists('./l0n0lcoutput'):
+    os.mkdir('l0n0lcoutput')
+
+
+fp = open('l0n0lcoutput/helloworld.cpp', 'w')
+lc.配置输出函数(fp.write)
+lc.c_include('stdio.h')
+lc.c_include('stdlib.h')
+
+with lc.如果没有定义('hahaha'):
+    lc.c_define('hahaha', '2')
+
+
+@lc.c_函数(前缀=['extern "C"'])
+def test_add(a: lc.c_i32, b: lc.c_i32) -> lc.c_i32:
+    with lc.如果(a.大于(100)) as f:
+        a(10)
+    with lc.否则如果(a.等于(10)):
+        a(100)
+    with lc.否则():
+        a(1000)
+    return a + b # type: ignore
+
+@lc.c_函数()
+def main(argc: lc.c_i32, argv: lc.c_char_p_p) -> lc.c_i32:
+    c =lc.c_i32(test_add(1, 2))
+    lc.输出(f'printf("Hello World! c = %d\\n", {c});\n')
+    lc.输出('printf("Hello World!\\n");\n')
+    with lc.如果定义了('hahaha'):
+        lc.输出('printf("哈哈哈!\\n");\n')
+    with lc.宏如果('hahaha == 1') as c:
+        lc.输出('printf("111!\\n");\n')
+        c.否则如果('hahaha == 2')
+        lc.输出('printf("否则2!\\n");\n')
+        c.否则()
+        lc.输出('printf("否则!\\n");\n')
+    i = lc.c_i32(0)
+    with lc.循环(i.小于(argc)):
+        lc.输出(f'printf("i = %d, v = %s\\n", {i}, {argv[i]});\n')
+        i += 1
+    return 0  # type: ignore
+
+
+fp.close()
+
+cm = lc.编译()
+cm.编译文件('l0n0lcoutput/helloworld.cpp', 'l0n0lcoutput/helloworld')
+os.system('./l0n0lcoutput/helloworld 1 2')
+
+cm.编译为动态库('l0n0lcoutput/helloworld.cpp', 'l0n0lcoutput/libhelloworld.so')
+path = f'{os.getcwd()}/l0n0lcoutput/libhelloworld.so'
+print(path)
+libhelloworld = ctypes.CDLL(path)
+libhelloworld.test_add.argtypes=[ctypes.c_int32, ctypes.c_int32]
+libhelloworld.test_add.restype = ctypes.c_int32
+a = libhelloworld.test_add(300, 6)
+print(a)
+a = libhelloworld.test_add(10, 6)
+print(a)
+a = libhelloworld.test_add(1, 6)
+print(a)
+
+```

l0n0lc-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+l0n0lc/__init__.py,sha256=L68TK_0liDW_z02MTr5NWF5v3huyM-dwZsUUfsFePWc,297
+l0n0lc/c域.py,sha256=uxxD5A-wekc2bfdVQGUlyzvaQ30MPVhB6qeVkHrkU14,3604
+l0n0lc/c基础类型.py,sha256=PGkixIWWSVox7j-NQbFH0cqUcgDQjrEKcV5XoWlsWN0,4015
+l0n0lc/c类型基础.py,sha256=xItXb9WFF5wzHE5YNlr94_FpPV0TsY8pchx-qeXy3Z0,8493
+l0n0lc/c语句.py,sha256=1KuFjBpONO_MWTwQUxa14GFOp1yddPKsY-3-41qGe5Q,1506
+l0n0lc/utils.py,sha256=6OTdWdfwKIAqicSRTFmw-DYLn1xZv-JHC7J9aQffFZQ,1287
+l0n0lc/编译.py,sha256=mN5UoKCuNrUtJYn7cFkU5iSzmMdr8vw8Cz80kiOyZ3w,1971
+l0n0lc/输出.py,sha256=vJ-9cQ9U41-m4oyrDmhSWpsJG8FNtChm4sJ75Fy3m00,317
+l0n0lc-0.1.0.dist-info/METADATA,sha256=oG0nATnb1aRviJR29tv4cu1P78KIsc1La1dxdf6wUgk,2096
+l0n0lc-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+l0n0lc-0.1.0.dist-info/top_level.txt,sha256=Q21D_eEY_-xgRUPwATGp9YDKSBO4w_7MI2MYxQI1aT4,7
+l0n0lc-0.1.0.dist-info/RECORD,,

l0n0lc-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

l0n0lc-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+l0n0lc