mirror of
https://dev.iopsys.eu/bbf/bbfdm.git
synced 2025-12-10 07:44:39 +01:00
879 lines
33 KiB
Python
Executable file
879 lines
33 KiB
Python
Executable file
#!/usr/bin/python3
|
|
|
|
# Copyright (C) 2024 iopsys Software Solutions AB
|
|
# Author: Amin Ben Romdhane <amin.benromdhane@iopsys.eu>
|
|
|
|
from __future__ import print_function
|
|
|
|
import os
|
|
import sys
|
|
import json
|
|
from collections import OrderedDict
|
|
import bbf_common as bbf
|
|
|
|
DMC_DIR = "datamodel"
|
|
|
|
def getlastname(name):
|
|
return name.replace(".{i}", "").split('.')[-2]
|
|
|
|
|
|
def getname(objname):
|
|
OBJSname = objname
|
|
if (objname.count('.') > 1 and (objname.count('.') != 2 or objname.count('{i}') != 1)):
|
|
OBJSname = objname.replace("Device", "", 1)
|
|
OBJSname = OBJSname.replace("{i}", "").replace(".", "")
|
|
if objname.count('.') == 1:
|
|
return OBJSname
|
|
if (objname.count('.') == 2 and objname.count('{i}') == 1):
|
|
OBJSname = "Services" + OBJSname
|
|
return OBJSname
|
|
return OBJSname
|
|
|
|
|
|
def getarrayoptionparam(value, option):
|
|
if isinstance(value, dict):
|
|
for obj, val in value.items():
|
|
if obj == option and isinstance(val, list):
|
|
return val
|
|
return None
|
|
|
|
|
|
def getprotocolsparam(value, option):
|
|
if isinstance(value, dict):
|
|
for obj, val in value.items():
|
|
if obj == option and isinstance(val, list):
|
|
if len(val) == 2:
|
|
return "BBFDM_BOTH"
|
|
elif val[0] == "usp":
|
|
return "BBFDM_USP"
|
|
else:
|
|
return "BBFDM_CWMP"
|
|
return "BBFDM_BOTH"
|
|
|
|
|
|
def getargsparam(value):
|
|
if isinstance(value, dict):
|
|
for obj, val in value.items():
|
|
return obj, val
|
|
return None, None
|
|
|
|
|
|
def get_mapping_param(mappingobj):
|
|
dm_type = bbf.get_option_value(mappingobj, "type")
|
|
if dm_type == "uci":
|
|
uciobj = bbf.get_option_value(mappingobj, "uci")
|
|
file = bbf.get_option_value(uciobj, "file")
|
|
sectionobj = bbf.get_option_value(uciobj, "section")
|
|
sectiontype = bbf.get_option_value(sectionobj, "type")
|
|
sectionname = bbf.get_option_value(sectionobj, "name")
|
|
sectionindex = bbf.get_option_value(sectionobj, "index")
|
|
optionobj = bbf.get_option_value(uciobj, "option")
|
|
optionname = bbf.get_option_value(optionobj, "name")
|
|
path = bbf.get_option_value(uciobj, "path")
|
|
ref = bbf.get_option_value(uciobj, "ref")
|
|
return dm_type, file, sectiontype, sectionname, sectionindex, optionname, path, ref
|
|
elif dm_type == "ubus":
|
|
ubusobj = bbf.get_option_value(mappingobj, "ubus")
|
|
dm_object = bbf.get_option_value(ubusobj, "object")
|
|
method = bbf.get_option_value(ubusobj, "method")
|
|
argsobj = bbf.get_option_value(ubusobj, "args")
|
|
arg1, arg2 = getargsparam(argsobj)
|
|
key = bbf.get_option_value(ubusobj, "key")
|
|
return dm_type, dm_object, method, arg1, arg2, key, None, None
|
|
elif dm_type == "procfs" or dm_type == "sysfs":
|
|
file = bbf.get_option_value(mappingobj, "file")
|
|
return dm_type, file, None, None, None, None, None, None
|
|
else:
|
|
cliobj = bbf.get_option_value(mappingobj, "cli")
|
|
command = bbf.get_option_value(cliobj, "command")
|
|
argsobj = bbf.get_option_value(cliobj, "args")
|
|
i = 0
|
|
value = ""
|
|
list_length = len(argsobj)
|
|
while i < list_length:
|
|
if value == "":
|
|
value = "\"" + argsobj[i] + "\", "
|
|
elif i == list_length-1:
|
|
value = value + "\"" + argsobj[i] + "\""
|
|
else:
|
|
value = value + "\"" + argsobj[i] + "\", "
|
|
i += 1
|
|
return dm_type, command, list_length, value, None, None, None, None
|
|
|
|
|
|
def printGlobalstrCommon(str_exp):
|
|
fp = open(DMC_DIR + "/common.c", 'a', encoding='utf-8')
|
|
print("%s" % str_exp, file=fp)
|
|
fp.close()
|
|
|
|
|
|
def get_mapping_obj(mappingobj):
|
|
dm_type = bbf.get_option_value(mappingobj, "type")
|
|
if dm_type == "uci":
|
|
uciobj = bbf.get_option_value(mappingobj, "uci")
|
|
file = bbf.get_option_value(uciobj, "file")
|
|
sectionobj = bbf.get_option_value(uciobj, "section")
|
|
sectiontype = bbf.get_option_value(sectionobj, "type")
|
|
dmmapfile = bbf.get_option_value(uciobj, "dmmapfile")
|
|
return dm_type, file, sectiontype, dmmapfile, None, None
|
|
elif dm_type == "ubus":
|
|
ubusobj = bbf.get_option_value(mappingobj, "ubus")
|
|
dm_object = bbf.get_option_value(ubusobj, "object")
|
|
method = bbf.get_option_value(ubusobj, "method")
|
|
argsobj = bbf.get_option_value(ubusobj, "args")
|
|
arg1, arg2 = getargsparam(argsobj)
|
|
key = bbf.get_option_value(ubusobj, "key")
|
|
return dm_type, dm_object, method, arg1, arg2, key
|
|
else:
|
|
return dm_type, None, None, None, None, None
|
|
|
|
|
|
def generate_validate_value(dmparam, value):
|
|
validate_value = ""
|
|
maxsizeparam = "-1"
|
|
itemminparam = "-1"
|
|
itemmaxparam = "-1"
|
|
rangeminparam = "NULL"
|
|
rangemaxparam = "NULL"
|
|
|
|
listparam = bbf.get_option_value(value, "list")
|
|
if listparam is not None:
|
|
datatypeparam = bbf.get_option_value(listparam, "datatype")
|
|
maxsizeparam = bbf.get_option_value(listparam, "maxsize")
|
|
if maxsizeparam is None:
|
|
maxsizeparam = "-1"
|
|
itemparam = bbf.get_option_value(listparam, "item")
|
|
if itemparam is not None:
|
|
itemminparam = bbf.get_option_value(itemparam, "min")
|
|
if itemminparam is None:
|
|
itemminparam = "-1"
|
|
itemmaxparam = bbf.get_option_value(itemparam, "max")
|
|
if itemmaxparam is None:
|
|
itemmaxparam = "-1"
|
|
|
|
rangeparam = getarrayoptionparam(listparam, "range")
|
|
if rangeparam is not None:
|
|
range_length = len(rangeparam)
|
|
rangeargs = "RANGE_ARGS{"
|
|
for i in range(range_length - 1):
|
|
rangeminparam = bbf.get_option_value(rangeparam[i], "min")
|
|
if rangeminparam is None:
|
|
rangeminparam = "NULL"
|
|
rangemaxparam = bbf.get_option_value(rangeparam[i], "max")
|
|
if rangemaxparam is None:
|
|
rangemaxparam = "NULL"
|
|
rangeargs += "{\"%s\",\"%s\"}," % (
|
|
rangeminparam, rangemaxparam)
|
|
rangeminparam = bbf.get_option_value(
|
|
rangeparam[range_length - 1], "min")
|
|
if rangeminparam is None:
|
|
rangeminparam = "NULL"
|
|
rangemaxparam = bbf.get_option_value(
|
|
rangeparam[range_length - 1], "max")
|
|
if rangemaxparam is None:
|
|
rangemaxparam = "NULL"
|
|
rangeargs += "{\"%s\",\"%s\"}}, %s" % (
|
|
rangeminparam, rangemaxparam, range_length)
|
|
else:
|
|
rangeargs = "RANGE_ARGS{{NULL,NULL}}, 1"
|
|
|
|
enumarationsparam = getarrayoptionparam(listparam, "enumerations")
|
|
if enumarationsparam is not None:
|
|
list_enumarationsparam = enumarationsparam
|
|
enum_length = len(list_enumarationsparam)
|
|
enumarationsparam = dmparam if datatypeparam == "string" else datatypeparam
|
|
str_enum = "char *%s[] = {" % enumarationsparam
|
|
for i in range(enum_length):
|
|
str_enum += "\"%s\", " % list_enumarationsparam[i]
|
|
str_enum += "NULL};"
|
|
printGlobalstrCommon(str_enum)
|
|
else:
|
|
enumarationsparam = "NULL"
|
|
|
|
patternparam = getarrayoptionparam(listparam, "pattern")
|
|
if patternparam is not None:
|
|
list_patternparam = patternparam
|
|
pattern_length = len(list_patternparam)
|
|
patternparam = dmparam if datatypeparam == "string" else datatypeparam
|
|
str_pattern = "char *%s[] = {" % patternparam
|
|
for i in range(pattern_length):
|
|
str_pattern += "\"^%s$\", " % list_patternparam[i]
|
|
str_pattern += "NULL};"
|
|
printGlobalstrCommon(str_pattern)
|
|
elif datatypeparam == "IPAddress":
|
|
patternparam = "IPAddress"
|
|
elif datatypeparam == "IPv6Address":
|
|
patternparam = "IPv6Address"
|
|
elif datatypeparam == "IPPrefix":
|
|
patternparam = "IPPrefix"
|
|
elif datatypeparam == "IPv6Prefix":
|
|
patternparam = "IPv6Prefix"
|
|
else:
|
|
patternparam = "NULL"
|
|
|
|
if datatypeparam == "unsignedInt":
|
|
validate_value += " if (bbfdm_validate_unsignedInt_list(ctx, value, %s, %s, %s, %s))\n" % (
|
|
itemminparam, itemmaxparam, maxsizeparam, rangeargs)
|
|
else:
|
|
if rangeminparam == "NULL":
|
|
rangeminparam = "-1"
|
|
if rangemaxparam == "NULL":
|
|
rangemaxparam = "-1"
|
|
validate_value += " if (bbfdm_validate_string_list(ctx, value, %s, %s, %s, %s, %s, %s, %s))\n" % (
|
|
itemminparam, itemmaxparam, maxsizeparam, rangeminparam, rangemaxparam, enumarationsparam, patternparam)
|
|
else:
|
|
datatypeparam = bbf.get_option_value(value, "datatype")
|
|
rangeparam = getarrayoptionparam(value, "range")
|
|
if rangeparam is not None:
|
|
range_length = len(rangeparam)
|
|
rangeargs = "RANGE_ARGS{"
|
|
for i in range(range_length - 1):
|
|
rangeminparam = bbf.get_option_value(rangeparam[i], "min")
|
|
if rangeminparam is None:
|
|
rangeminparam = "NULL"
|
|
rangemaxparam = bbf.get_option_value(rangeparam[i], "max")
|
|
if rangemaxparam is None:
|
|
rangemaxparam = "NULL"
|
|
rangeargs += "{\"%s\",\"%s\"}," % (
|
|
rangeminparam, rangemaxparam)
|
|
rangeminparam = bbf.get_option_value(
|
|
rangeparam[range_length - 1], "min")
|
|
if rangeminparam is None:
|
|
rangeminparam = "NULL"
|
|
rangemaxparam = bbf.get_option_value(
|
|
rangeparam[range_length - 1], "max")
|
|
if rangemaxparam is None:
|
|
rangemaxparam = "NULL"
|
|
rangeargs += "{\"%s\",\"%s\"}}, %s" % (
|
|
rangeminparam, rangemaxparam, range_length)
|
|
else:
|
|
rangeargs = "RANGE_ARGS{{NULL,NULL}}, 1"
|
|
|
|
enumarationsparam = getarrayoptionparam(value, "enumerations")
|
|
if enumarationsparam is not None:
|
|
list_enumarationsparam = enumarationsparam
|
|
enum_length = len(list_enumarationsparam)
|
|
enumarationsparam = dmparam if datatypeparam == "string" else datatypeparam
|
|
str_enum = "char *%s[] = {" % enumarationsparam
|
|
for i in range(enum_length):
|
|
str_enum += "\"%s\", " % list_enumarationsparam[i]
|
|
str_enum += "NULL};"
|
|
printGlobalstrCommon(str_enum)
|
|
else:
|
|
enumarationsparam = "NULL"
|
|
|
|
patternparam = getarrayoptionparam(value, "pattern")
|
|
if patternparam is not None:
|
|
list_patternparam = patternparam
|
|
pattern_length = len(list_patternparam)
|
|
patternparam = dmparam if datatypeparam == "string" else datatypeparam
|
|
str_pattern = "char *%s[] = {" % patternparam
|
|
for i in range(pattern_length):
|
|
str_pattern += "\"^%s$\", " % list_patternparam[i]
|
|
str_pattern += "NULL};"
|
|
printGlobalstrCommon(str_pattern)
|
|
elif datatypeparam == "IPAddress":
|
|
patternparam = "IPAddress"
|
|
elif datatypeparam == "IPv6Address":
|
|
patternparam = "IPv6Address"
|
|
elif datatypeparam == "IPPrefix":
|
|
patternparam = "IPPrefix"
|
|
elif datatypeparam == "IPv6Prefix":
|
|
patternparam = "IPv6Prefix"
|
|
else:
|
|
patternparam = "NULL"
|
|
|
|
if datatypeparam == "boolean":
|
|
validate_value += " if (bbfdm_validate_boolean(ctx, value))\n"
|
|
elif datatypeparam == "unsignedInt":
|
|
validate_value += " if (bbfdm_validate_unsignedInt(ctx, value, %s))\n" % rangeargs
|
|
elif datatypeparam == "int":
|
|
validate_value += " if (bbfdm_validate_int(ctx, value, %s))\n" % rangeargs
|
|
elif datatypeparam == "unsignedLong":
|
|
validate_value += " if (bbfdm_validate_unsignedLong(ctx, value, %s))\n" % rangeargs
|
|
elif datatypeparam == "long":
|
|
validate_value += " if (bbfdm_validate_long(ctx, value, %s))\n" % rangeargs
|
|
elif datatypeparam == "dateTime":
|
|
validate_value += " if (bbfdm_validate_dateTime(ctx, value))\n"
|
|
elif datatypeparam == "hexBinary":
|
|
if rangeminparam == "NULL":
|
|
rangeminparam = "-1"
|
|
if rangemaxparam == "NULL":
|
|
rangemaxparam = "-1"
|
|
validate_value += " if (bbfdm_validate_hexBinary(ctx, value, %s))\n" % rangeargs
|
|
else:
|
|
if rangeminparam == "NULL":
|
|
rangeminparam = "-1"
|
|
if rangemaxparam == "NULL":
|
|
rangemaxparam = "-1"
|
|
validate_value += " if (bbfdm_validate_string(ctx, value, %s, %s, %s, %s))\n" % (
|
|
rangeminparam, rangemaxparam, enumarationsparam, patternparam)
|
|
validate_value += " return FAULT_9007;"
|
|
validate_value = validate_value.replace("\"NULL\"", "NULL")
|
|
return validate_value
|
|
|
|
|
|
def printheaderObjCommon(objname):
|
|
fp = open('./.objparamarray.c', 'a', encoding='utf-8')
|
|
print("/* *** %s *** */" % objname, file=fp)
|
|
fp.close()
|
|
|
|
|
|
def cprintheaderOBJS(objname):
|
|
fp = open('./.objparamarray.c', 'a', encoding='utf-8')
|
|
print("DMOBJ %s[] = {" % ("t" + getname(objname) + "Obj"), file=fp)
|
|
print("/* OBJ, permission, addobj, delobj, checkdep, browseinstobj, nextdynamicobj, dynamicleaf, nextobj, leaf, linker, bbfdm_type, uniqueKeys */", file=fp)
|
|
fp.close()
|
|
|
|
|
|
def hprintheaderOBJS(objname):
|
|
fp = open('./.objparamarray.h', 'a', encoding='utf-8')
|
|
print("extern DMOBJ %s[];" % ("t" + getname(objname) + "Obj"), file=fp)
|
|
fp.close()
|
|
|
|
|
|
def cprinttopfile(fp, filename):
|
|
print("/*", file=fp)
|
|
print(" * Copyright (C) 2023 iopsys Software Solutions AB", file=fp)
|
|
print(" *", file=fp)
|
|
print(" * This program is free software; you can redistribute it and/or modify", file=fp)
|
|
print(" * it under the terms of the GNU Lesser General Public License version 2.1", file=fp)
|
|
print(" * as published by the Free Software Foundation", file=fp)
|
|
print(" *", file=fp)
|
|
print(" * Author: <Name> <Surname> <name.surname@iopsys.eu>", file=fp)
|
|
print(" */", file=fp)
|
|
print("", file=fp)
|
|
print("#include \"%s.h\"" % filename.lower(), file=fp)
|
|
print("", file=fp)
|
|
|
|
|
|
def hprinttopfile(fp, filename):
|
|
print("/*", file=fp)
|
|
print(" * Copyright (C) 2023 iopsys Software Solutions AB", file=fp)
|
|
print(" *", file=fp)
|
|
print(" * This program is free software; you can redistribute it and/or modify", file=fp)
|
|
print(" * it under the terms of the GNU Lesser General Public License version 2.1", file=fp)
|
|
print(" * as published by the Free Software Foundation", file=fp)
|
|
print(" *", file=fp)
|
|
print(" * Author: <Name> <Surname> <name.surname@iopsys.eu>", file=fp)
|
|
print(" */", file=fp)
|
|
print("", file=fp)
|
|
print("#ifndef __%s_H" % filename.upper(), file=fp)
|
|
print("#define __%s_H" % filename.upper(), file=fp)
|
|
print("", file=fp)
|
|
print("#include <libbbfdm-api/dmcommon.h>", file=fp)
|
|
print("", file=fp)
|
|
|
|
|
|
def hprintfootfile(fp, filename):
|
|
print("", file=fp)
|
|
print("#endif //__%s_H" % filename.upper(), file=fp)
|
|
print("", file=fp)
|
|
|
|
|
|
def cprintAddDelObj(faddobj, fdelobj):
|
|
fp = open('./.objadddel.c', 'a', encoding='utf-8')
|
|
print("static int %s(char *refparam, struct dmctx *ctx, void *data, char **instance)" %
|
|
faddobj, file=fp)
|
|
print("{", file=fp)
|
|
print(" //TODO", file=fp)
|
|
print(" return 0;", file=fp)
|
|
print("}", file=fp)
|
|
print("", file=fp)
|
|
print("static int %s(char *refparam, struct dmctx *ctx, void *data, char *instance, unsigned char del_action)" % fdelobj, file=fp)
|
|
print("{", file=fp)
|
|
print(" switch (del_action) {", file=fp)
|
|
print(" case DEL_INST:", file=fp)
|
|
print(" //TODO", file=fp)
|
|
print(" break;", file=fp)
|
|
print(" case DEL_ALL:", file=fp)
|
|
print(" //TODO", file=fp)
|
|
print(" break;", file=fp)
|
|
print(" }", file=fp)
|
|
print(" return 0;", file=fp)
|
|
print("}", file=fp)
|
|
print("", file=fp)
|
|
fp.close()
|
|
|
|
|
|
def cprintBrowseObj(fbrowse, mappingobj, dmobject):
|
|
# Open file
|
|
fp = open('./.objbrowse.c', 'a', encoding='utf-8')
|
|
|
|
# Mapping Parameter
|
|
if mappingobj is not None:
|
|
dm_type, res1, res2, res3, res4, res5 = get_mapping_obj(mappingobj)
|
|
if dm_type == "uci":
|
|
print("/*#%s!%s:%s/%s/%s*/" %
|
|
(dmobject, dm_type.upper(), res1, res2, res3), file=fp)
|
|
elif dm_type == "ubus":
|
|
print("/*#%s!%s:%s/%s/%s,%s/%s*/" %
|
|
(dmobject, dm_type.upper(), res1, res2, res3, res4, res5), file=fp)
|
|
|
|
print("static int %s(struct dmctx *dmctx, DMNODE *parent_node, void *prev_data, char *prev_instance)" % fbrowse, file=fp)
|
|
print("{", file=fp)
|
|
print(" //TODO", file=fp)
|
|
print(" return 0;", file=fp)
|
|
print("}", file=fp)
|
|
print("", file=fp)
|
|
|
|
# Close file
|
|
fp.close()
|
|
|
|
|
|
def cprintGetSetValue(getvalue, setvalue, dmparam, value):
|
|
# Open file
|
|
fp = open('./.getstevalue.c', 'a', encoding='utf-8')
|
|
|
|
# Generate Validate value
|
|
validate_value = ""
|
|
if setvalue != "NULL":
|
|
validate_value = generate_validate_value(dmparam, value)
|
|
|
|
print("static int %s(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)" % getvalue, file=fp)
|
|
print("{", file=fp)
|
|
print(" //TODO", file=fp)
|
|
print(" return 0;", file=fp)
|
|
print("}", file=fp)
|
|
print("", file=fp)
|
|
if setvalue != "NULL":
|
|
print("static int %s(char *refparam, struct dmctx *ctx, void *data, char *instance, char *value, int action)" % setvalue, file=fp)
|
|
print("{", file=fp)
|
|
print(" switch (action) {", file=fp)
|
|
print(" case VALUECHECK:", file=fp)
|
|
print("%s" % validate_value, file=fp)
|
|
print(" break;", file=fp)
|
|
print(" case VALUESET:", file=fp)
|
|
print(" //TODO", file=fp)
|
|
print(" break;", file=fp)
|
|
print(" }", file=fp)
|
|
print(" return 0;", file=fp)
|
|
print("}", file=fp)
|
|
print("", file=fp)
|
|
|
|
# Close file
|
|
fp.close()
|
|
|
|
|
|
def cprintOperateCommands(getoperateargs, operate, in_args, out_args, struct_name):
|
|
# Open file
|
|
fp = open('./.operatecommands.c', 'a', encoding='utf-8')
|
|
|
|
if in_args != None or out_args != None:
|
|
############################## OPERATE ARGUMENTS ########################################
|
|
print("static operation_args %s = {" % struct_name, file=fp)
|
|
|
|
if in_args != None:
|
|
if isinstance(in_args, dict):
|
|
print(" .in = (const char *[]) {", file=fp)
|
|
for obj, _val in in_args.items():
|
|
print(" \"%s\"," % obj, file=fp)
|
|
print(" NULL", file=fp)
|
|
print(" %s" % ("}," if out_args != None else "}"), file=fp)
|
|
|
|
if out_args != None:
|
|
if isinstance(out_args, dict):
|
|
print(" .out = (const char *[]) {", file=fp)
|
|
for obj, _val in out_args.items():
|
|
print(" \"%s\"," % obj, file=fp)
|
|
print(" NULL", file=fp)
|
|
print(" }", file=fp)
|
|
|
|
print("};", file=fp)
|
|
print("", file=fp)
|
|
|
|
print("static int %s(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)" % getoperateargs, file=fp)
|
|
print("{", file=fp)
|
|
print(" *value = (char *)&%s;" % struct_name, file=fp)
|
|
print(" return 0;", file=fp)
|
|
print("}", file=fp)
|
|
print("", file=fp)
|
|
|
|
############################## OPERATE ########################################
|
|
print("static int %s(char *refparam, struct dmctx *ctx, void *data, char *instance, char *value, int action)" % operate, file=fp)
|
|
print("{", file=fp)
|
|
print(" //TODO", file=fp)
|
|
print(" return 0;", file=fp)
|
|
print("}", file=fp)
|
|
print("", file=fp)
|
|
|
|
# Close file
|
|
fp.close()
|
|
|
|
|
|
def cprintEvent(geteventargs, param_args, struct_name):
|
|
# Open file
|
|
fp = open('./.events.c', 'a', encoding='utf-8')
|
|
|
|
if param_args != None:
|
|
############################## OPERATE ARGUMENTS ########################################
|
|
print("static event_args %s = {" % struct_name, file=fp)
|
|
if isinstance(param_args, dict):
|
|
print(" .name = \"\"", file=fp)
|
|
print(" .param = (const char *[]) {", file=fp)
|
|
for obj, _val in param_args.items():
|
|
print(" \"%s\"," % obj, file=fp)
|
|
print(" NULL", file=fp)
|
|
print(" }", file=fp)
|
|
|
|
print("};", file=fp)
|
|
print("", file=fp)
|
|
|
|
print("static int %s(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)" % geteventargs, file=fp)
|
|
print("{", file=fp)
|
|
print(" *value = (char *)&%s;" % struct_name, file=fp)
|
|
print(" return 0;", file=fp)
|
|
print("}", file=fp)
|
|
print("", file=fp)
|
|
|
|
# Close file
|
|
fp.close()
|
|
|
|
|
|
def cprintheaderPARAMS(objname):
|
|
fp = open('./.objparamarray.c', 'a', encoding='utf-8')
|
|
print("DMLEAF %s[] = {" % ("t" + getname(objname) + "Params"), file=fp)
|
|
print("/* PARAM, permission, type, getvalue, setvalue, bbfdm_type */", file=fp)
|
|
fp.close()
|
|
|
|
|
|
def hprintheaderPARAMS(objname):
|
|
fp = open('./.objparamarray.h', 'a', encoding='utf-8')
|
|
print("extern DMLEAF %s[];" % ("t" + getname(objname) + "Params"), file=fp)
|
|
fp.close()
|
|
|
|
|
|
def printPARAMline(parentname, dmparam, value):
|
|
commonname = getname(parentname) + "_" + dmparam
|
|
ptype = bbf.get_param_type(value)
|
|
getvalue = "get_" + commonname
|
|
bbfdm = getprotocolsparam(value, "protocols")
|
|
accessparam = bbf.get_option_value(value, "write")
|
|
|
|
if accessparam:
|
|
access = "&DMWRITE"
|
|
setvalue = "set_" + commonname
|
|
else:
|
|
access = "&DMREAD"
|
|
setvalue = "NULL"
|
|
|
|
cprintGetSetValue(getvalue, setvalue, dmparam, value)
|
|
|
|
fp = open('./.objparamarray.c', 'a', encoding='utf-8')
|
|
print("{\"%s\", %s, %s, %s, %s, %s}," %
|
|
(dmparam, access, ptype, getvalue, setvalue, bbfdm), file=fp)
|
|
fp.close()
|
|
|
|
|
|
def printCOMMANDline( parentname, dmparam, value ):
|
|
commonname = getname(parentname) + "_" + dmparam
|
|
ptype = bbf.get_param_type(value)
|
|
operate = "operate_" + commonname.replace("()", "")
|
|
bbfdm = getprotocolsparam(value, "protocols")
|
|
asyncparam = bbf.get_option_value(value, "async")
|
|
in_args = bbf.get_option_value(value, "input")
|
|
out_args = bbf.get_option_value(value, "output")
|
|
|
|
if asyncparam:
|
|
c_type = "&DMASYNC"
|
|
else:
|
|
c_type = "&DMSYNC"
|
|
|
|
if in_args != None or out_args != None:
|
|
getoperateargs = "get_operate_args_" + commonname.replace("()", "")
|
|
else:
|
|
getoperateargs = "NULL"
|
|
|
|
cprintOperateCommands(getoperateargs, operate, in_args, out_args, commonname.replace("()", "").lower()+"_args")
|
|
|
|
fp = open('./.objparamarray.c', 'a', encoding='utf-8')
|
|
print("{\"%s\", %s, %s, %s, %s, %s}," % (dmparam, c_type, ptype, getoperateargs, operate, bbfdm), file=fp)
|
|
fp.close()
|
|
|
|
|
|
def printEVENTline( parentname, dmparam, value ):
|
|
commonname = getname(parentname) + "_" + dmparam
|
|
ptype = bbf.get_param_type(value)
|
|
bbfdm = getprotocolsparam(value, "protocols")
|
|
hasparam = bbf.obj_has_param(value)
|
|
|
|
if hasparam:
|
|
geteventargs = "get_event_args_" + commonname.replace("!", "")
|
|
cprintEvent(geteventargs, value, commonname.replace("!", "").lower()+"_args")
|
|
else:
|
|
geteventargs = "NULL"
|
|
|
|
fp = open('./.objparamarray.c', 'a', encoding='utf-8')
|
|
print("{\"%s\", &DMREAD, %s, %s, NULL, %s}," % (dmparam, ptype, geteventargs, bbfdm), file=fp)
|
|
fp.close()
|
|
|
|
|
|
def printtailArray():
|
|
fp = open('./.objparamarray.c', 'a', encoding='utf-8')
|
|
print("{0}", file=fp)
|
|
print("};", file=fp)
|
|
print("", file=fp)
|
|
fp.close()
|
|
|
|
|
|
def printOBJline(dmobject, value):
|
|
commonname = getname(dmobject)
|
|
hasobj = bbf.obj_has_child(value)
|
|
hasparam = bbf.obj_has_param(value)
|
|
accessobj = bbf.get_option_value(value, "access")
|
|
mappingobj = bbf.get_option_value(value, "mapping")
|
|
bbfdm = getprotocolsparam(value, "protocols")
|
|
|
|
if accessobj:
|
|
access = "&DMWRITE"
|
|
faddobj = "addObj" + commonname
|
|
fdelobj = "delObj" + commonname
|
|
cprintAddDelObj(faddobj, fdelobj)
|
|
else:
|
|
access = "&DMREAD"
|
|
faddobj = "NULL"
|
|
fdelobj = "NULL"
|
|
|
|
if dmobject.endswith(".{i}."):
|
|
fbrowse = "browse" + commonname + "Inst"
|
|
cprintBrowseObj(fbrowse, mappingobj, dmobject)
|
|
else:
|
|
fbrowse = "NULL"
|
|
|
|
if hasobj:
|
|
objchildarray = "t" + commonname + "Obj"
|
|
else:
|
|
objchildarray = "NULL"
|
|
|
|
if hasparam:
|
|
paramarray = "t" + commonname + "Params"
|
|
else:
|
|
paramarray = "NULL"
|
|
|
|
fp = open('./.objparamarray.c', 'a', encoding='utf-8')
|
|
print("{\"%s\", %s, %s, %s, NULL, %s, NULL, NULL, %s, %s, NULL, %s, NULL}," % (getlastname(
|
|
dmobject), access, faddobj, fdelobj, fbrowse, objchildarray, paramarray, bbfdm), file=fp)
|
|
fp.close()
|
|
|
|
|
|
def print_dmc_usage():
|
|
print("Usage: " + sys.argv[0] + " [Object path]")
|
|
print("Examples:")
|
|
print(" - " + sys.argv[0])
|
|
print(" ==> Generate the C code of full data model in datamodel/ folder")
|
|
print(" - " + sys.argv[0] + " Device.DeviceInfo.")
|
|
print(" ==> Generate the C code of Device.DeviceInfo object in datamodel/ folder")
|
|
print(" - " + sys.argv[0] + " Device.Services.VoiceService.{i}.DECT.Base.{i}.")
|
|
print(" ==> Generate the C code for a specific multi-instance object in datamodel/ folder")
|
|
|
|
def object_parse_childs(dmobject, value, nextlevel):
|
|
hasobj = bbf.obj_has_child(value)
|
|
hasparam = bbf.obj_has_param(value)
|
|
|
|
if hasobj or hasparam:
|
|
printheaderObjCommon(dmobject)
|
|
|
|
if hasobj:
|
|
cprintheaderOBJS(dmobject)
|
|
hprintheaderOBJS(dmobject)
|
|
|
|
if isinstance(value, dict):
|
|
for k, v in value.items():
|
|
if isinstance(v, dict):
|
|
for k1, v1 in v.items():
|
|
if k1 == "type" and v1 == "object":
|
|
printOBJline(k, v)
|
|
break
|
|
printtailArray()
|
|
|
|
if hasparam:
|
|
cprintheaderPARAMS(dmobject)
|
|
hprintheaderPARAMS(dmobject)
|
|
if isinstance(value, dict):
|
|
for k, v in value.items():
|
|
if k == "mapping":
|
|
continue
|
|
if isinstance(v, dict):
|
|
for k1, v1 in v.items():
|
|
|
|
if k1 == "type" and v1 == "command":
|
|
printCOMMANDline(dmobject, k, v)
|
|
break
|
|
|
|
if k1 == "type" and v1 == "event":
|
|
printEVENTline(dmobject, k, v)
|
|
break
|
|
|
|
if k1 == "type" and v1 != "object":
|
|
printPARAMline(dmobject, k, v)
|
|
break
|
|
|
|
printtailArray()
|
|
|
|
if hasobj and nextlevel == 0:
|
|
if isinstance(value, dict):
|
|
for k, v in value.items():
|
|
if isinstance(v, dict):
|
|
for k1, v1 in v.items():
|
|
if k1 == "type" and v1 == "object":
|
|
object_parse_childs(k, v, 0)
|
|
|
|
|
|
def generatecfromobj(pobj, pvalue, pdir, nextlevel):
|
|
bbf.create_folder(pdir)
|
|
removetmpfiles()
|
|
object_parse_childs(pobj, pvalue, nextlevel)
|
|
|
|
dmfpc = open(pdir + "/" + getname(pobj).lower() + ".c", "w", encoding='utf-8')
|
|
dmfph = open(pdir + "/" + getname(pobj).lower() + ".h", "w", encoding='utf-8')
|
|
cprinttopfile(dmfpc, getname(pobj).lower())
|
|
hprinttopfile(dmfph, getname(pobj).lower())
|
|
|
|
try:
|
|
exists = os.path.isfile("./.objbrowse.c")
|
|
if exists:
|
|
print(
|
|
"/*************************************************************", file=dmfpc)
|
|
print("* ENTRY METHOD", file=dmfpc)
|
|
print(
|
|
"**************************************************************/", file=dmfpc)
|
|
tmpf = open("./.objbrowse.c", "r", encoding='utf-8')
|
|
tmpd = tmpf.read()
|
|
tmpf.close()
|
|
dmfpc.write(tmpd)
|
|
except IOError:
|
|
pass
|
|
|
|
try:
|
|
exists = os.path.isfile("./.objadddel.c")
|
|
if exists:
|
|
print(
|
|
"/*************************************************************", file=dmfpc)
|
|
print("* ADD & DEL OBJ", file=dmfpc)
|
|
print(
|
|
"**************************************************************/", file=dmfpc)
|
|
tmpf = open("./.objadddel.c", "r", encoding='utf-8')
|
|
tmpd = tmpf.read()
|
|
tmpf.close()
|
|
dmfpc.write(tmpd)
|
|
except IOError:
|
|
pass
|
|
|
|
try:
|
|
exists = os.path.isfile("./.getstevalue.c")
|
|
if exists:
|
|
print(
|
|
"/*************************************************************", file=dmfpc)
|
|
print("* GET & SET PARAM", file=dmfpc)
|
|
print(
|
|
"**************************************************************/", file=dmfpc)
|
|
tmpf = open("./.getstevalue.c", "r", encoding='utf-8')
|
|
tmpd = tmpf.read()
|
|
tmpf.close()
|
|
dmfpc.write(tmpd)
|
|
except IOError:
|
|
pass
|
|
|
|
try:
|
|
exists = os.path.isfile("./.operatecommands.c")
|
|
if exists:
|
|
print("/*************************************************************", file=dmfpc)
|
|
print("* OPERATE COMMANDS", file=dmfpc)
|
|
print("**************************************************************/", file=dmfpc)
|
|
tmpf = open("./.operatecommands.c", "r", encoding='utf-8')
|
|
tmpd = tmpf.read()
|
|
tmpf.close()
|
|
dmfpc.write(tmpd)
|
|
except IOError:
|
|
pass
|
|
|
|
try:
|
|
exists = os.path.isfile("./.events.c")
|
|
if exists:
|
|
print("/*************************************************************", file=dmfpc)
|
|
print("* EVENTS", file=dmfpc)
|
|
print("**************************************************************/", file=dmfpc)
|
|
tmpf = open("./.events.c", "r", encoding='utf-8')
|
|
tmpd = tmpf.read()
|
|
tmpf.close()
|
|
dmfpc.write(tmpd)
|
|
except IOError:
|
|
pass
|
|
|
|
try:
|
|
print("/**********************************************************************************************************************************", file=dmfpc)
|
|
print("* OBJ & PARAM DEFINITION", file=dmfpc)
|
|
print("***********************************************************************************************************************************/", file=dmfpc)
|
|
tmpf = open("./.objparamarray.c", "r", encoding='utf-8')
|
|
tmpd = tmpf.read()
|
|
tmpf.close()
|
|
dmfpc.write(tmpd)
|
|
except IOError:
|
|
pass
|
|
|
|
try:
|
|
tmpf = open("./.objparamarray.h", "r", encoding='utf-8')
|
|
tmpd = tmpf.read()
|
|
tmpf.close()
|
|
dmfph.write(tmpd)
|
|
print("", file=dmfph)
|
|
except IOError:
|
|
pass
|
|
|
|
hprintfootfile(dmfph, getname(pobj).lower())
|
|
removetmpfiles()
|
|
|
|
|
|
def removetmpfiles():
|
|
bbf.remove_file("./.objparamarray.c")
|
|
bbf.remove_file("./.objparamarray.h")
|
|
bbf.remove_file("./.objadddel.c")
|
|
bbf.remove_file("./.objbrowse.c")
|
|
bbf.remove_file("./.getstevalue.c")
|
|
bbf.remove_file("./.operatecommands.c")
|
|
bbf.remove_file("./.events.c")
|
|
|
|
|
|
def generatecfromspecificobj(passed_data, obj_to_find):
|
|
for _obj, _value in passed_data.items():
|
|
if isinstance(_value, dict) and 'type' in _value and _value['type'] == "object":
|
|
if _obj != obj_to_find:
|
|
generatecfromspecificobj(_value, obj_to_find)
|
|
else:
|
|
return generatecfromobj(_obj, _value, DMC_DIR, 0)
|
|
|
|
|
|
### main ###
|
|
if len(sys.argv) > 1 and (sys.argv[1]).lower() in ["-h", "--help"]:
|
|
print_dmc_usage()
|
|
exit(1)
|
|
|
|
bbf.remove_folder(DMC_DIR)
|
|
|
|
json_file = open(bbf.DM_JSON_FILE, "r", encoding='utf-8')
|
|
data = json.loads(json_file.read(), object_pairs_hook=OrderedDict)
|
|
|
|
for dm_obj, dm_value in data.items():
|
|
|
|
if dm_obj is None or not isinstance(dm_value, dict):
|
|
print("Wrong JSON Data model format!")
|
|
exit(0)
|
|
|
|
# Generate the object file if it is defined by "sys.argv[1]" argument
|
|
if len(sys.argv) > 1 and sys.argv[1] != dm_obj:
|
|
generatecfromspecificobj(dm_value, sys.argv[1])
|
|
break
|
|
|
|
# Generate the root object tree file
|
|
generatecfromobj(dm_obj, dm_value, DMC_DIR, 1)
|
|
|
|
# Generate the sub object tree file
|
|
for obj1, value1 in dm_value.items():
|
|
if isinstance(value1, dict) and 'type' in value1 and value1['type'] == "object":
|
|
generatecfromobj(obj1, value1, DMC_DIR, 0)
|
|
|
|
|
|
if os.path.isdir(DMC_DIR):
|
|
print("Source code generated under \"%s\" folder" % DMC_DIR)
|
|
else:
|
|
print("No source code generated!")
|