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,
)
)
