diff options
author | Campbell Barton <ideasman42@gmail.com> | 2019-04-17 07:17:24 +0300 |
---|---|---|
committer | Campbell Barton <ideasman42@gmail.com> | 2019-04-17 07:21:24 +0300 |
commit | e12c08e8d170b7ca40f204a5b0423c23a9fbc2c1 (patch) | |
tree | 8cf3453d12edb177a218ef8009357518ec6cab6a /source/blender/python/intern/bpy_utils_units.c | |
parent | b3dabc200a4b0399ec6b81f2ff2730d07b44fcaa (diff) |
ClangFormat: apply to source, most of intern
Apply clang format as proposed in T53211.
For details on usage and instructions for migrating branches
without conflicts, see:
https://wiki.blender.org/wiki/Tools/ClangFormat
Diffstat (limited to 'source/blender/python/intern/bpy_utils_units.c')
-rw-r--r-- | source/blender/python/intern/bpy_utils_units.c | 481 |
1 files changed, 251 insertions, 230 deletions
diff --git a/source/blender/python/intern/bpy_utils_units.c b/source/blender/python/intern/bpy_utils_units.c index abae53088a8..b80ea50dd09 100644 --- a/source/blender/python/intern/bpy_utils_units.c +++ b/source/blender/python/intern/bpy_utils_units.c @@ -43,25 +43,25 @@ static PyTypeObject BPyUnitsCategoriesType; /* XXX Maybe better as externs of BKE_unit.h ? */ static const char *bpyunits_usystem_items[] = { - "NONE", - "METRIC", - "IMPERIAL", - NULL, + "NONE", + "METRIC", + "IMPERIAL", + NULL, }; static const char *bpyunits_ucategorie_items[] = { - "NONE", - "LENGTH", - "AREA", - "VOLUME", - "MASS", - "ROTATION", - "TIME", - "VELOCITY", - "ACCELERATION", - "CAMERA", - "POWER", - NULL, + "NONE", + "LENGTH", + "AREA", + "VOLUME", + "MASS", + "ROTATION", + "TIME", + "VELOCITY", + "ACCELERATION", + "CAMERA", + "POWER", + NULL, }; /** @@ -73,261 +73,282 @@ static PyStructSequence_Field bpyunits_systems_fields[ARRAY_SIZE(bpyunits_usyste static PyStructSequence_Field bpyunits_categories_fields[ARRAY_SIZE(bpyunits_ucategorie_items)]; static PyStructSequence_Desc bpyunits_systems_desc = { - (char *)"bpy.utils.units.systems", /* name */ - (char *)"This named tuple contains all pre-defined unit systems", /* doc */ - bpyunits_systems_fields, /* fields */ - ARRAY_SIZE(bpyunits_systems_fields) - 1, + (char *)"bpy.utils.units.systems", /* name */ + (char *)"This named tuple contains all pre-defined unit systems", /* doc */ + bpyunits_systems_fields, /* fields */ + ARRAY_SIZE(bpyunits_systems_fields) - 1, }; static PyStructSequence_Desc bpyunits_categories_desc = { - (char *)"bpy.utils.units.categories", /* name */ - (char *)"This named tuple contains all pre-defined unit names", /* doc */ - bpyunits_categories_fields, /* fields */ - ARRAY_SIZE(bpyunits_categories_fields) - 1, + (char *)"bpy.utils.units.categories", /* name */ + (char *)"This named tuple contains all pre-defined unit names", /* doc */ + bpyunits_categories_fields, /* fields */ + ARRAY_SIZE(bpyunits_categories_fields) - 1, }; /** * Simple utility function to initialize #PyStructSequence_Desc */ -static PyObject *py_structseq_from_strings( - PyTypeObject *py_type, - PyStructSequence_Desc *py_sseq_desc, - const char **str_items) +static PyObject *py_structseq_from_strings(PyTypeObject *py_type, + PyStructSequence_Desc *py_sseq_desc, + const char **str_items) { - PyObject *py_struct_seq; - int pos = 0; + PyObject *py_struct_seq; + int pos = 0; - const char **str_iter; - PyStructSequence_Field *desc; + const char **str_iter; + PyStructSequence_Field *desc; - /* initialize array */ - /* We really populate the contexts' fields here! */ - for (str_iter = str_items, desc = py_sseq_desc->fields; *str_iter; str_iter++, desc++) { - desc->name = (char *)*str_iter; - desc->doc = NULL; - } - /* end sentinel */ - desc->name = desc->doc = NULL; + /* initialize array */ + /* We really populate the contexts' fields here! */ + for (str_iter = str_items, desc = py_sseq_desc->fields; *str_iter; str_iter++, desc++) { + desc->name = (char *)*str_iter; + desc->doc = NULL; + } + /* end sentinel */ + desc->name = desc->doc = NULL; - PyStructSequence_InitType(py_type, py_sseq_desc); + PyStructSequence_InitType(py_type, py_sseq_desc); - /* initialize pytype */ - py_struct_seq = PyStructSequence_New(py_type); - BLI_assert(py_struct_seq != NULL); + /* initialize pytype */ + py_struct_seq = PyStructSequence_New(py_type); + BLI_assert(py_struct_seq != NULL); - for (str_iter = str_items; *str_iter; str_iter++) { - PyStructSequence_SET_ITEM(py_struct_seq, pos++, PyUnicode_FromString((*str_iter))); - } + for (str_iter = str_items; *str_iter; str_iter++) { + PyStructSequence_SET_ITEM(py_struct_seq, pos++, PyUnicode_FromString((*str_iter))); + } - return py_struct_seq; + return py_struct_seq; } static bool bpyunits_validate(const char *usys_str, const char *ucat_str, int *r_usys, int *r_ucat) { - *r_usys = BLI_str_index_in_array(usys_str, bpyunits_usystem_items); - if (*r_usys < 0) { - PyErr_Format(PyExc_ValueError, - "Unknown unit system specified: %.200s.", - usys_str); - return false; - } - - *r_ucat = BLI_str_index_in_array(ucat_str, bpyunits_ucategorie_items); - if (*r_ucat < 0) { - PyErr_Format(PyExc_ValueError, - "Unknown unit category specified: %.200s.", - ucat_str); - return false; - } - - if (!bUnit_IsValid(*r_usys, *r_ucat)) { - PyErr_Format(PyExc_ValueError, - "%.200s / %.200s unit system/category combination is not valid.", - usys_str, ucat_str); - return false; - } - - return true; + *r_usys = BLI_str_index_in_array(usys_str, bpyunits_usystem_items); + if (*r_usys < 0) { + PyErr_Format(PyExc_ValueError, "Unknown unit system specified: %.200s.", usys_str); + return false; + } + + *r_ucat = BLI_str_index_in_array(ucat_str, bpyunits_ucategorie_items); + if (*r_ucat < 0) { + PyErr_Format(PyExc_ValueError, "Unknown unit category specified: %.200s.", ucat_str); + return false; + } + + if (!bUnit_IsValid(*r_usys, *r_ucat)) { + PyErr_Format(PyExc_ValueError, + "%.200s / %.200s unit system/category combination is not valid.", + usys_str, + ucat_str); + return false; + } + + return true; } -PyDoc_STRVAR(bpyunits_to_value_doc, -".. method:: to_value(unit_system, unit_category, str_input, str_ref_unit=None)\n" -"\n" -" Convert a given input string into a float value.\n" -"\n" -" :arg unit_system: The unit system, from :attr:`bpy.utils.units.systems`.\n" -" :type unit_system: string\n" -" :arg unit_category: The category of data we are converting (length, area, rotation, etc.),\n" -" from :attr:`bpy.utils.units.categories`.\n" -" :type unit_category: string\n" -" :arg str_input: The string to convert to a float value.\n" -" :type str_input: string\n" -" :arg str_ref_unit: A reference string from which to extract a default unit, if none is found in ``str_input``.\n" -" :type str_ref_unit: string or None\n" -" :return: The converted/interpreted value.\n" -" :rtype: float\n" -" :raises ValueError: if conversion fails to generate a valid python float value.\n" -); +PyDoc_STRVAR( + bpyunits_to_value_doc, + ".. method:: to_value(unit_system, unit_category, str_input, str_ref_unit=None)\n" + "\n" + " Convert a given input string into a float value.\n" + "\n" + " :arg unit_system: The unit system, from :attr:`bpy.utils.units.systems`.\n" + " :type unit_system: string\n" + " :arg unit_category: The category of data we are converting (length, area, rotation, " + "etc.),\n" + " from :attr:`bpy.utils.units.categories`.\n" + " :type unit_category: string\n" + " :arg str_input: The string to convert to a float value.\n" + " :type str_input: string\n" + " :arg str_ref_unit: A reference string from which to extract a default unit, if none is " + "found in ``str_input``.\n" + " :type str_ref_unit: string or None\n" + " :return: The converted/interpreted value.\n" + " :rtype: float\n" + " :raises ValueError: if conversion fails to generate a valid python float value.\n"); static PyObject *bpyunits_to_value(PyObject *UNUSED(self), PyObject *args, PyObject *kw) { - char *usys_str = NULL, *ucat_str = NULL, *inpt = NULL, *uref = NULL; - const float scale = 1.0f; - - char *str; - Py_ssize_t str_len; - double result; - int usys, ucat; - PyObject *ret; - - static const char *_keywords[] = { - "unit_system", "unit_category", "str_input", "str_ref_unit", NULL, - }; - static _PyArg_Parser _parser = {"sss#|z:to_value", _keywords, 0}; - if (!_PyArg_ParseTupleAndKeywordsFast( - args, kw, &_parser, - &usys_str, &ucat_str, &inpt, &str_len, &uref)) - { - return NULL; - } - - if (!bpyunits_validate(usys_str, ucat_str, &usys, &ucat)) { - return NULL; - } - - str_len = str_len * 2 + 64; - str = PyMem_MALLOC(sizeof(*str) * (size_t)str_len); - BLI_strncpy(str, inpt, (size_t)str_len); - - bUnit_ReplaceString(str, (int)str_len, uref, scale, usys, ucat); - - if (!PyC_RunString_AsNumber(NULL, str, "<bpy_units_api>", &result)) { - if (PyErr_Occurred()) { - PyErr_Print(); - PyErr_Clear(); - } - - PyErr_Format(PyExc_ValueError, - "'%.200s' (converted as '%s') could not be evaluated.", - inpt, str); - ret = NULL; - } - else { - ret = PyFloat_FromDouble(result); - } - - PyMem_FREE(str); - return ret; + char *usys_str = NULL, *ucat_str = NULL, *inpt = NULL, *uref = NULL; + const float scale = 1.0f; + + char *str; + Py_ssize_t str_len; + double result; + int usys, ucat; + PyObject *ret; + + static const char *_keywords[] = { + "unit_system", + "unit_category", + "str_input", + "str_ref_unit", + NULL, + }; + static _PyArg_Parser _parser = {"sss#|z:to_value", _keywords, 0}; + if (!_PyArg_ParseTupleAndKeywordsFast( + args, kw, &_parser, &usys_str, &ucat_str, &inpt, &str_len, &uref)) { + return NULL; + } + + if (!bpyunits_validate(usys_str, ucat_str, &usys, &ucat)) { + return NULL; + } + + str_len = str_len * 2 + 64; + str = PyMem_MALLOC(sizeof(*str) * (size_t)str_len); + BLI_strncpy(str, inpt, (size_t)str_len); + + bUnit_ReplaceString(str, (int)str_len, uref, scale, usys, ucat); + + if (!PyC_RunString_AsNumber(NULL, str, "<bpy_units_api>", &result)) { + if (PyErr_Occurred()) { + PyErr_Print(); + PyErr_Clear(); + } + + PyErr_Format( + PyExc_ValueError, "'%.200s' (converted as '%s') could not be evaluated.", inpt, str); + ret = NULL; + } + else { + ret = PyFloat_FromDouble(result); + } + + PyMem_FREE(str); + return ret; } PyDoc_STRVAR(bpyunits_to_string_doc, -".. method:: to_string(unit_system, unit_category, value, precision=3, split_unit=False, compatible_unit=False)\n" -"\n" -" Convert a given input float value into a string with units.\n" -"\n" -" :arg unit_system: The unit system, from :attr:`bpy.utils.units.systems`.\n" -" :type unit_system: string\n" -" :arg unit_category: The category of data we are converting (length, area, rotation, etc.),\n" -" from :attr:`bpy.utils.units.categories`.\n" -" :type unit_category: string\n" -" :arg value: The value to convert to a string.\n" -" :type value: float\n" -" :arg precision: Number of digits after the comma.\n" -" :type precision: int\n" -" :arg split_unit: Whether to use several units if needed (1m1cm), or always only one (1.01m).\n" -" :type split_unit: bool\n" -" :arg compatible_unit: Whether to use keyboard-friendly units (1m2) or nicer utf-8 ones (1m²).\n" -" :type compatible_unit: bool\n" -" :return: The converted string.\n" -" :rtype: str\n" -" :raises ValueError: if conversion fails to generate a valid python string.\n" -); + ".. method:: to_string(unit_system, unit_category, value, precision=3, " + "split_unit=False, compatible_unit=False)\n" + "\n" + " Convert a given input float value into a string with units.\n" + "\n" + " :arg unit_system: The unit system, from :attr:`bpy.utils.units.systems`.\n" + " :type unit_system: string\n" + " :arg unit_category: The category of data we are converting (length, area, " + "rotation, etc.),\n" + " from :attr:`bpy.utils.units.categories`.\n" + " :type unit_category: string\n" + " :arg value: The value to convert to a string.\n" + " :type value: float\n" + " :arg precision: Number of digits after the comma.\n" + " :type precision: int\n" + " :arg split_unit: Whether to use several units if needed (1m1cm), or always only " + "one (1.01m).\n" + " :type split_unit: bool\n" + " :arg compatible_unit: Whether to use keyboard-friendly units (1m2) or nicer " + "utf-8 ones (1m²).\n" + " :type compatible_unit: bool\n" + " :return: The converted string.\n" + " :rtype: str\n" + " :raises ValueError: if conversion fails to generate a valid python string.\n"); static PyObject *bpyunits_to_string(PyObject *UNUSED(self), PyObject *args, PyObject *kw) { - char *usys_str = NULL, *ucat_str = NULL; - double value = 0.0; - int precision = 3; - bool split_unit = false, compatible_unit = false; - - int usys, ucat; - - static const char *_keywords[] = { - "unit_system", "unit_category", "value", - "precision", "split_unit", "compatible_unit", NULL, - }; - static _PyArg_Parser _parser = {"ssd|iO&O&:to_string", _keywords, 0}; - if (!_PyArg_ParseTupleAndKeywordsFast( - args, kw, &_parser, - &usys_str, &ucat_str, &value, &precision, - PyC_ParseBool, &split_unit, - PyC_ParseBool, &compatible_unit)) - { - return NULL; - } - - if (!bpyunits_validate(usys_str, ucat_str, &usys, &ucat)) { - return NULL; - } - - { - /* Maximum expected length of string result: - * - number itself: precision + decimal dot + up to four 'above dot' digits. - * - unit: up to ten chars (six currently, let's be conservative, also because we use some utf8 chars). - * This can be repeated twice (e.g. 1m20cm), and we add ten more spare chars (spaces, trailing '\0'...). - * So in practice, 64 should be more than enough. - */ - char buf1[64], buf2[64], *str; - PyObject *result; - - bUnit_AsString(buf1, sizeof(buf1), value, precision, usys, ucat, (bool)split_unit, false); - - if (compatible_unit) { - bUnit_ToUnitAltName(buf2, sizeof(buf2), buf1, usys, ucat); - str = buf2; - } - else { - str = buf1; - } - - result = PyUnicode_FromString(str); - - return result; - } + char *usys_str = NULL, *ucat_str = NULL; + double value = 0.0; + int precision = 3; + bool split_unit = false, compatible_unit = false; + + int usys, ucat; + + static const char *_keywords[] = { + "unit_system", + "unit_category", + "value", + "precision", + "split_unit", + "compatible_unit", + NULL, + }; + static _PyArg_Parser _parser = {"ssd|iO&O&:to_string", _keywords, 0}; + if (!_PyArg_ParseTupleAndKeywordsFast(args, + kw, + &_parser, + &usys_str, + &ucat_str, + &value, + &precision, + PyC_ParseBool, + &split_unit, + PyC_ParseBool, + &compatible_unit)) { + return NULL; + } + + if (!bpyunits_validate(usys_str, ucat_str, &usys, &ucat)) { + return NULL; + } + + { + /* Maximum expected length of string result: + * - number itself: precision + decimal dot + up to four 'above dot' digits. + * - unit: up to ten chars (six currently, let's be conservative, also because we use some utf8 chars). + * This can be repeated twice (e.g. 1m20cm), and we add ten more spare chars (spaces, trailing '\0'...). + * So in practice, 64 should be more than enough. + */ + char buf1[64], buf2[64], *str; + PyObject *result; + + bUnit_AsString(buf1, sizeof(buf1), value, precision, usys, ucat, (bool)split_unit, false); + + if (compatible_unit) { + bUnit_ToUnitAltName(buf2, sizeof(buf2), buf1, usys, ucat); + str = buf2; + } + else { + str = buf1; + } + + result = PyUnicode_FromString(str); + + return result; + } } static PyMethodDef bpyunits_methods[] = { - {"to_value", (PyCFunction)bpyunits_to_value, METH_VARARGS | METH_KEYWORDS, bpyunits_to_value_doc}, - {"to_string", (PyCFunction)bpyunits_to_string, METH_VARARGS | METH_KEYWORDS, bpyunits_to_string_doc}, - {NULL, NULL, 0, NULL}, + {"to_value", + (PyCFunction)bpyunits_to_value, + METH_VARARGS | METH_KEYWORDS, + bpyunits_to_value_doc}, + {"to_string", + (PyCFunction)bpyunits_to_string, + METH_VARARGS | METH_KEYWORDS, + bpyunits_to_string_doc}, + {NULL, NULL, 0, NULL}, }; -PyDoc_STRVAR(bpyunits_doc, -"This module contains some data/methods regarding units handling." -); +PyDoc_STRVAR(bpyunits_doc, "This module contains some data/methods regarding units handling."); static struct PyModuleDef bpyunits_module = { - PyModuleDef_HEAD_INIT, - "bpy.utils.units", - bpyunits_doc, - -1, /* multiple "initialization" just copies the module dict. */ - bpyunits_methods, - NULL, NULL, NULL, NULL, + PyModuleDef_HEAD_INIT, + "bpy.utils.units", + bpyunits_doc, + -1, /* multiple "initialization" just copies the module dict. */ + bpyunits_methods, + NULL, + NULL, + NULL, + NULL, }; PyObject *BPY_utils_units(void) { - PyObject *submodule, *item; + PyObject *submodule, *item; - submodule = PyModule_Create(&bpyunits_module); - PyDict_SetItemString(PyImport_GetModuleDict(), bpyunits_module.m_name, submodule); + submodule = PyModule_Create(&bpyunits_module); + PyDict_SetItemString(PyImport_GetModuleDict(), bpyunits_module.m_name, submodule); - /* Finalize our unit systems and types structseq definitions! */ + /* Finalize our unit systems and types structseq definitions! */ - /* bpy.utils.units.system */ - item = py_structseq_from_strings(&BPyUnitsSystemsType, &bpyunits_systems_desc, bpyunits_usystem_items); - PyModule_AddObject(submodule, "systems", item); /* steals ref */ + /* bpy.utils.units.system */ + item = py_structseq_from_strings( + &BPyUnitsSystemsType, &bpyunits_systems_desc, bpyunits_usystem_items); + PyModule_AddObject(submodule, "systems", item); /* steals ref */ - /* bpy.utils.units.categories */ - item = py_structseq_from_strings(&BPyUnitsCategoriesType, &bpyunits_categories_desc, bpyunits_ucategorie_items); - PyModule_AddObject(submodule, "categories", item); /* steals ref */ + /* bpy.utils.units.categories */ + item = py_structseq_from_strings( + &BPyUnitsCategoriesType, &bpyunits_categories_desc, bpyunits_ucategorie_items); + PyModule_AddObject(submodule, "categories", item); /* steals ref */ - return submodule; + return submodule; } |