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

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

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

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

@@ -1,50 +0,0 @@
-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//350/276/223/345/207/272.py

@@ -1,17 +0,0 @@
-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.4.0.dist-info/METADATA

@@ -1,79 +0,0 @@
-Metadata-Version: 2.4
-Name: l0n0lc
-Version: 0.4.0
-Summary: 用python写c
-Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Dynamic: license-file
-
-# 用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.4.0.dist-info/RECORD

@@ -1,13 +0,0 @@
-l0n0lc/__init__.py,sha256=FdeyabIdYOFtX2TGIfMfOv43Q7qiEdSvY3oclyzEom8,280
-l0n0lc/c域.py,sha256=iJXbsmI7jpM4THHSxRGBmUbHeOhBSEk8Js25Ri0wN98,3602
-l0n0lc/c基础类型.py,sha256=eSKeDGg2r1i4g6AcMCXC2bAL_5-ooksRzv6fsYs2zyE,21967
-l0n0lc/c类型基础.py,sha256=FmHGKICEkRm4mnUmqqf-PDF2yUg91mzBdJjq07L6e8k,8471
-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.4.0.dist-info/licenses/LICENSE,sha256=1L-MAjulZ3kpbYwsJtlXpDVITRxykna2Ecg_521YfkA,1093
-l0n0lc-0.4.0.dist-info/METADATA,sha256=rQR7nEJUID-ez9wScIxdX4uns0Qt56uJ4QWP_GPk59U,2128
-l0n0lc-0.4.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-l0n0lc-0.4.0.dist-info/top_level.txt,sha256=Q21D_eEY_-xgRUPwATGp9YDKSBO4w_7MI2MYxQI1aT4,7
-l0n0lc-0.4.0.dist-info/RECORD,,