def __init__(self, boolean): # create function prototype namespace = boolean._namespace name = boolean.type().name() super().__init__( namespace, namespace.get('bool').type(), 'bool_from_json(', ) # add arguments self.add( calligra.declaration( namespace, namespace.get(name), 'value', pointer = True, ) ) self.add( calligra.declaration( namespace, namespace.get('json_t'), 'json', pointer = True, ) )
def __init__(self, integer): # create function prototype namespace = integer._namespace name = integer.type().name() super().__init__( namespace, namespace.get('bool').type(), calligra.method_name(namespace.get(name).name(), '_from_json'), ) self._integer = integer # add arguments self.add( calligra.declaration( namespace, namespace.get(name), 'value', pointer = True, ) ) self.add( calligra.declaration( namespace, namespace.get('json_t'), 'json', pointer = True, ) )
def __init__(self, namespace): super().__init__(namespace, self.__class__.__name__) self.add( calligra.declaration( namespace, namespace.get('char'), 'scheme', pointer = True ) ) self.add( calligra.declaration( namespace, namespace.get('char'), 'authority', pointer = True ) ) self.add( calligra.declaration( namespace, namespace.get('char'), 'path', pointer = True ) ) self.add( calligra.declaration( namespace, namespace.get('char'), 'query', pointer = True ) ) self.add( calligra.declaration( namespace, namespace.get('char'), 'fragment', pointer = True ) )
def test_anonymous(self): namespace = calligra.namespace(calligra.stdlib.namespace) anonymous = calligra.struct(namespace, '') anonymous.add( calligra.declaration(namespace, namespace.get('size_t'), 'member1')) anonymous.add( calligra.declaration(namespace, namespace.get('char'), 'member2')) code_re = re.compile( r'^struct\s*{\s*size_t\s+member1;\s*char\s+member2;\s*}\s*$') self.assertTrue(code_re.match(anonymous.code())) with self.assertRaises(KeyError) as cm: calligra.stdlib.listnames(namespace, anonymous.type().name())
def call(self, str_arg): if isinstance(str_arg[-1].array, str): size = '{} - 1'.format(str_arg[-1].array) elif str_arg[-1].array: size = str(str_arg[-1].array - 1) else: size = self._char.strlen.call(str_arg) c_arg = calligra.declaration(namespace, self._namespace.get('uint8_t'), '0') n_arg = calligra.declaration(namespace, self._namespace.get('size_t'), size) return super().call(str_arg, (c_arg, ), (n_arg, ))
def __init__(self, char): super().__init__(namespace, namespace.get('void'), 'memset', imported=True) self._char = char self.add(calligra.declaration(namespace, self._char, 's', pointer=True)) self.add(calligra.declaration(namespace, namespace.get('uint8_t'), 'c')) self.add(calligra.declaration(namespace, namespace.get('size_t'), 'n'))
def test_simple(self): namespace = calligra.namespace(calligra.stdlib.namespace) simple = calligra.struct(namespace, 'simple') simple.add( calligra.declaration(namespace, namespace.get('size_t'), 'member1')) simple.add( calligra.declaration(namespace, namespace.get('char'), 'member2')) code_re = re.compile( r'^struct\s+simple\s*{\s*size_t\s+member1;\s*char\s+member2;\s*}\s*$' ) self.assertTrue(code_re.match(simple.code())) names = calligra.stdlib.listnames(namespace, simple.type().name()) self.assertEqual(names, ['size_t', 'char', 'struct simple'])
def test_listnames(self): union = calligra.union(calligra.stdlib.namespace, '') union.add( calligra.declaration(calligra.stdlib.namespace, calligra.stdlib.namespace.get('size_t'), 'variant1')) union.add( calligra.declaration(calligra.stdlib.namespace, calligra.stdlib.namespace.get('char'), 'variant2')) simple = calligra.struct(calligra.stdlib.namespace, 'simple') simple.add(union) names = calligra.stdlib.listnames(calligra.stdlib.namespace, simple.type().name()) self.assertEqual(names, ['size_t', 'char', 'struct simple'])
def __init__(self, namespace): super().__init__(namespace, namespace.get('size_t'), self.__class__.__name__, imported=True) self.add( calligra.declaration(namespace, namespace.get('void'), 'type', const=True))
def __init__(self, char): name = char.type().name() super().__init__(namespace, namespace.get('size_t'), self.__class__.__name__, imported=True) self.add( calligra.declaration( namespace, namespace.get(name), 's', const=True, pointer=True, ))
def body(self, prefix = ''): code = '' properties = self._struct.properties() code += prefix + 'json_t *child;\n' code += prefix + 'size_t count = 0;\n\n' code += prefix + 'if(!{} || !json_is_object(json)) {{\n'.format( self.properties()[0].name() ) code += prefix + '\treturn false;\n' code += prefix + '}\n\n' for property in properties: property_type = self._namespace.get(property.type()) code += prefix + '/*' + property.name() + '*/\n' access = property.access(self._namespace, (self.properties()[0], )) #nil = property.nil(self._namespace, (self.properties()[0], )) if hasattr(property_type, 'from_json'): code += prefix + 'if({}) {{\n'.format(access) code += prefix + '\tchild = json_object_get(json, "{}");\n'.format( property.name() ) code += prefix + '\tif(!child) {\n' code += prefix + '\t\treturn false;\n' code += prefix + '\t}\n' child = calligra.declaration( self._namespace, self._namespace.get('json_t'), 'child', pointer = True ) code += prefix + '\tif(!{}) {{\n'.format( property_type.from_json.call( (self.properties()[0], property), (child, ) ), ) code += prefix + '\t\treturn false;\n' code += prefix + '\t}\n' code += prefix + '\tcount += 1;\n' code += prefix + '}\n' code += prefix + 'if(json_object_size(json) != count) {\n' code += prefix + '\treturn false;\n' code += prefix + '}\n' code += prefix + 'return true;\n' return code
def body(self, prefix = ''): code = '' code += prefix + 'if(!json_is_real(json)) {\n' code += prefix + '\treturn false;\n' code += prefix + '}\n' real = calligra.declaration( self._namespace, self._namespace.get('double'), 'real' ) code += prefix + 'double real = json_real_value(json);\n' code += prefix + 'if({}) {{\n'.format( self._real.valid(self._namespace, (real, )) ) code += prefix + '\treturn false;\n' code += prefix + '}\n' code += prefix + '*value = ({})real;\n'.format(self._real.name()) code += prefix + 'return true;\n' return code
def body(self, prefix = ''): code = '' code += prefix + 'if(!json_is_integer(json)) {\n' code += prefix + '\treturn false;\n' code += prefix + '}\n' integer = calligra.declaration( self._namespace, self._namespace.get('json_int_t'), 'integer' ) code += prefix + 'json_int_t integer = json_integer_value(json);\n' valid = self._integer.valid(self._namespace, (integer, )) if valid: code += prefix + 'if({}) {{\n'.format(valid) code += prefix + '\treturn false;\n' code += prefix + '}\n' code += prefix + '*value = ({})integer;\n'.format(self._integer.name()) code += prefix + 'return true;\n' return code
def __init__(self, integer): # create function prototype namespace = integer._namespace name = integer.type().name() super().__init__( namespace, namespace.get('json_t').type(), 'json_integer', pointer = True, imported = True, ) # add arguments self.add( calligra.declaration( namespace, namespace.get(name), 'value', ) )
def __init__(self, struct): # create function prototype namespace = struct._namespace name = struct.type().name() super().__init__( namespace, namespace.get('json_t').type(), calligra.method_name(namespace.get(name).name(), '_to_json'), pointer = True ) self._struct = struct # add arguments self.add( calligra.declaration( namespace, self._struct, namespace.get(name).name(), pointer = True, const = True, ) )