l0n0lc 0.3.1__tar.gz → 0.4.0__tar.gz

{l0n0lc-0.3.1 → l0n0lc-0.4.0}/PKG-INFO

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

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

@@ -0,0 +1,670 @@
+
+from .c类型基础 import c类型基础
+from .c域 import 输出
+
+class i8(c类型基础):
+    类型名 = 'int8_t'
+
+class i8引用(c类型基础):
+    类型名 = 'int8_t&'    
+    
+class i8指针(c类型基础):
+    类型名 = f'int8_t*'
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class i8指针的指针(c类型基础):
+    类型名 = f'int8_t**'    
+
+class i16(c类型基础):
+    类型名 = 'int16_t'
+
+class i16引用(c类型基础):
+    类型名 = 'int16_t&'    
+    
+class i16指针(c类型基础):
+    类型名 = f'int16_t*'
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class i16指针的指针(c类型基础):
+    类型名 = f'int16_t**'    
+
+class i32(c类型基础):
+    类型名 = 'int32_t'
+
+class i32引用(c类型基础):
+    类型名 = 'int32_t&'    
+    
+class i32指针(c类型基础):
+    类型名 = f'int32_t*'
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class i32指针的指针(c类型基础):
+    类型名 = f'int32_t**'    
+
+class i64(c类型基础):
+    类型名 = 'int64_t'
+
+class i64引用(c类型基础):
+    类型名 = 'int64_t&'    
+    
+class i64指针(c类型基础):
+    类型名 = f'int64_t*'
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class i64指针的指针(c类型基础):
+    类型名 = f'int64_t**'    
+
+class u8(c类型基础):
+    类型名 = 'uint8_t'
+
+class u8引用(c类型基础):
+    类型名 = 'uint8_t&'    
+    
+class u8指针(c类型基础):
+    类型名 = f'uint8_t*'
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class u8指针的指针(c类型基础):
+    类型名 = f'uint8_t**'    
+
+class u16(c类型基础):
+    类型名 = 'uint16_t'
+
+class u16引用(c类型基础):
+    类型名 = 'uint16_t&'    
+    
+class u16指针(c类型基础):
+    类型名 = f'uint16_t*'
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class u16指针的指针(c类型基础):
+    类型名 = f'uint16_t**'    
+
+class u32(c类型基础):
+    类型名 = 'uint32_t'
+
+class u32引用(c类型基础):
+    类型名 = 'uint32_t&'    
+    
+class u32指针(c类型基础):
+    类型名 = f'uint32_t*'
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class u32指针的指针(c类型基础):
+    类型名 = f'uint32_t**'    
+
+class u64(c类型基础):
+    类型名 = 'uint64_t'
+
+class u64引用(c类型基础):
+    类型名 = 'uint64_t&'    
+    
+class u64指针(c类型基础):
+    类型名 = f'uint64_t*'
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class u64指针的指针(c类型基础):
+    类型名 = f'uint64_t**'    
+
+class bf16(c类型基础):
+    类型名 = 'bfloat16_t'
+
+class bf16引用(c类型基础):
+    类型名 = 'bfloat16_t&'    
+    
+class bf16指针(c类型基础):
+    类型名 = f'bfloat16_t*'
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class bf16指针的指针(c类型基础):
+    类型名 = f'bfloat16_t**'    
+
+class f16(c类型基础):
+    类型名 = 'half'
+
+class f16引用(c类型基础):
+    类型名 = 'half&'    
+    
+class f16指针(c类型基础):
+    类型名 = f'half*'
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class f16指针的指针(c类型基础):
+    类型名 = f'half**'    
+
+class f32(c类型基础):
+    类型名 = 'float'
+
+class f32引用(c类型基础):
+    类型名 = 'float&'    
+    
+class f32指针(c类型基础):
+    类型名 = f'float*'
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class f32指针的指针(c类型基础):
+    类型名 = f'float**'    
+
+class f64(c类型基础):
+    类型名 = 'double'
+
+class f64引用(c类型基础):
+    类型名 = 'double&'    
+    
+class f64指针(c类型基础):
+    类型名 = f'double*'
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class f64指针的指针(c类型基础):
+    类型名 = f'double**'    
+
+class boolean(c类型基础):
+    类型名 = 'bool'
+
+class boolean引用(c类型基础):
+    类型名 = 'bool&'    
+    
+class boolean指针(c类型基础):
+    类型名 = f'bool*'
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class boolean指针的指针(c类型基础):
+    类型名 = f'bool**'    
+
+class char(c类型基础):
+    类型名 = 'char'
+
+class char引用(c类型基础):
+    类型名 = 'char&'    
+    
+class char指针(c类型基础):
+    类型名 = f'char*'
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class char指针的指针(c类型基础):
+    类型名 = f'char**'    
+
+class uchar(c类型基础):
+    类型名 = 'unsigned char'
+
+class uchar引用(c类型基础):
+    类型名 = 'unsigned char&'    
+    
+class uchar指针(c类型基础):
+    类型名 = f'unsigned char*'
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class uchar指针的指针(c类型基础):
+    类型名 = f'unsigned char**'    
+
+class int(c类型基础):
+    类型名 = 'int'
+
+class int引用(c类型基础):
+    类型名 = 'int&'    
+    
+class int指针(c类型基础):
+    类型名 = f'int*'
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class int指针的指针(c类型基础):
+    类型名 = f'int**'    
+
+class uint(c类型基础):
+    类型名 = 'unsigned int'
+
+class uint引用(c类型基础):
+    类型名 = 'unsigned int&'    
+    
+class uint指针(c类型基础):
+    类型名 = f'unsigned int*'
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class uint指针的指针(c类型基础):
+    类型名 = f'unsigned int**'    
+
+class short(c类型基础):
+    类型名 = 'short'
+
+class short引用(c类型基础):
+    类型名 = 'short&'    
+    
+class short指针(c类型基础):
+    类型名 = f'short*'
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class short指针的指针(c类型基础):
+    类型名 = f'short**'    
+
+class ushort(c类型基础):
+    类型名 = 'unsigned short'
+
+class ushort引用(c类型基础):
+    类型名 = 'unsigned short&'    
+    
+class ushort指针(c类型基础):
+    类型名 = f'unsigned short*'
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class ushort指针的指针(c类型基础):
+    类型名 = f'unsigned short**'    
+
+class long(c类型基础):
+    类型名 = 'long'
+
+class long引用(c类型基础):
+    类型名 = 'long&'    
+    
+class long指针(c类型基础):
+    类型名 = f'long*'
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class long指针的指针(c类型基础):
+    类型名 = f'long**'    
+
+class ulong(c类型基础):
+    类型名 = 'unsigned long'
+
+class ulong引用(c类型基础):
+    类型名 = 'unsigned long&'    
+    
+class ulong指针(c类型基础):
+    类型名 = f'unsigned long*'
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class ulong指针的指针(c类型基础):
+    类型名 = f'unsigned long**'    
+
+class longlong(c类型基础):
+    类型名 = 'long long'
+
+class longlong引用(c类型基础):
+    类型名 = 'long long&'    
+    
+class longlong指针(c类型基础):
+    类型名 = f'long long*'
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class longlong指针的指针(c类型基础):
+    类型名 = f'long long**'    
+
+class ulonglong(c类型基础):
+    类型名 = 'unsigned long long'
+
+class ulonglong引用(c类型基础):
+    类型名 = 'unsigned long long&'    
+    
+class ulonglong指针(c类型基础):
+    类型名 = f'unsigned long long*'
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class ulonglong指针的指针(c类型基础):
+    类型名 = f'unsigned long long**'    

{l0n0lc-0.3.1 → l0n0lc-0.4.0}/l0n0lc.egg-info/PKG-INFO

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

{l0n0lc-0.3.1 → l0n0lc-0.4.0}/pyproject.toml

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

l0n0lc-0.3.1/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 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**'