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

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

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