separate_arguments(SECOND_BUILD_ENV UNIX_COMMAND$ENV{SECOND_BUILD})

set(LVGL_HEADER"${BINDING_DIR}/build/lvgl_header.h")

set(LVGL_DIR"${BINDING_DIR}/lib/lvgl")

file(GLOB_RECURSE LVGL_HEADERS${BINDING_DIR}/lib/lvgl/src/*.h${BINDING_DIR}/lib/lv_conf.h)

if(${SECOND_BUILD_ENV}EQUAL"0")

execute_process(

${Python3_EXECUTABLE}${BINDING_DIR}/gen/$ENV{GEN_SCRIPT}_api_gen_mpy.py${LV_CFLAGS} --output=${CMAKE_BINARY_DIR}/lv_mp.c --include=${BINDING_DIR}/lib --include=${BINDING_DIR}/lib/lvgl --board=$ENV{LV_PORT} --module_name=lvgl --module_prefix=lv --metadata=${CMAKE_BINARY_DIR}/lv_mp.c.json --header_file=${LVGL_HEADER}

${Python3_EXECUTABLE}${BINDING_DIR}/gen/$ENV{GEN_SCRIPT}_api_gen_mpy.py${LV_CFLAGS} --output=${CMAKE_BINARY_DIR}/lv_mp.c --include=${BINDING_DIR}/lib --include=${BINDING_DIR}/lib/lvgl --board=$ENV{LV_PORT} --module_name=lvgl --module_prefix=lv --metadata=${CMAKE_BINARY_DIR}/lv_mp.c.json --header_file=${LVGL_DIR}/lvgl.h

LIB_DIR =$(LVGL_BINDING_DIR)/lib

LVGL_DIR =$(LVGL_BINDING_DIR)/lib/lvgl

LVGL_HEADER =$(LVGL_BINDING_DIR)/build/lvgl_header.h

CURRENT_DIR =$(LVGL_BINDING_DIR)/ext_mod/lvgl

CFLAGS_USERMOD += -I$(LVGL_DIR)

$(LVGL_MPY):$(ALL_LVGL_SRC)$(LVGL_BINDING_DIR)/gen/$(GEN_SCRIPT)_api_gen_mpy.py

$(Q)mkdir -p$(dir$@)

$(Q)$(PYTHON)$(LVGL_BINDING_DIR)/gen/$(GEN_SCRIPT)_api_gen_mpy.py$(LV_CFLAGS) --board=$(LV_PORT) --output=$(LVGL_MPY) --include=$(LIB_DIR) --include=$(LVGL_DIR) --module_name=lvgl --module_prefix=lv --metadata=$(LVGL_MPY_METADATA) --header_file=$(LVGL_HEADER)

$(Q)$(PYTHON) $(LVGL_BINDING_DIR)/gen/$(GEN_SCRIPT)_api_gen_mpy.py $(LV_CFLAGS) --board=$(LV_PORT) --output=$(LVGL_MPY) --include=$(LIB_DIR) --include=$(LVGL_DIR) --module_name=lvgl --module_prefix=lv --metadata=$(LVGL_MPY_METADATA) --header_file=$(LVGL_DIR)/lvgl.h

.PHONY: LVGL_MPY

LVGL_MPY:$(LVGL_MPY)

fromos.pathimportcommonprefix

script_path=dirname(abspath(__file__))

pycparser_path=os.path.join(script_path,'..','lib','pycparser')

project_path=os.path.abspath(os.path.join(script_path,'..'))

pycparser_path=os.path.join(project_path,'lib','pycparser')

sys.path.insert(0,os.path.abspath(pycparser_path))

c_ast._repr=_repr

setattr(c_ast.Node,'__repr__',Node__repr__)

argParser.add_argument('--board',dest='board',help='Board or OS',metavar='<Board or OS>',action='store',default='')

argParser.add_argument('--output',dest='output',help='Output file path',metavar='<Output path>',action='store')

argParser.add_argument('--debug',dest='debug',help='enable debugging output',action='store_true')

argParser.add_argument('--header_file',dest='input',action='append',default=[])

argParser.add_argument('--header_file',dest='header',action='store',default=None)

args,unknownargs=argParser.parse_known_args()

module_name=args.module_name

module_prefix=args.module_prefixifargs.module_prefixelseargs.module_name

input_headers=args.input[:]

input_header=args.header

DEBUG=args.debug

lvgl_path=os.path.dirname(input_header)

private_header=os.path.join(lvgl_path,'lv_private.h')

lv_config_path=os.path.abspath(os.path.join(lvgl_path,'..','lv_conf.h'))

gen_json_path=os.path.join(lvgl_path,'scripts/gen_json')

sys.path.insert(0,gen_json_path)

original_nodes= {}

forkey,valueinc_ast.__dict__.items():

ifinspect.isclass(value):

original_nodes[key]=value

json_ast=gen_json.run(None,lv_config_path,False,os.path.join(project_path,'build','lvgl_header.h'),False)

lvgl_json=json_ast.to_dict()

forkey,valueinoriginal_nodes.items():

setattr(c_ast,key,value)

c_ast._repr=_repr

setattr(c_ast.Node,'__repr__',Node__repr__)

pp_file=args.output.rsplit('.',1)[0]+'.pp'

ifDEBUG:

cpp_cmd.extend([f'-D{define}'fordefineinargs.define])

cpp_cmd.extend(['-DPYCPARSER','-E',f'-I{fake_libc_path}'])

cpp_cmd.extend([f'-I{include}'forincludeinargs.include])

cpp_cmd.append(f'"{input_headers[0]}"')

cpp_cmd.append(f'"{input_header}"')

ifsys.platform.startswith('win'):

create_obj_pattern=re.compile('^{prefix}_(.+)_create$'.format(prefix=module_prefix))

lv_method_pattern=re.compile('^{prefix}_[^_]+_(.+)'.format(prefix=module_prefix),re.IGNORECASE)

lv_base_obj_pattern=re.compile('^(struct _){{0,1}}{prefix}_{base_name}_t( [*]){{0,1}}'.format(prefix=module_prefix,base_name=base_obj_name))

lv_str_enum_pattern=re.compile('^_{prefix}_STR_(.+)'.format(prefix=module_prefix.upper()))

lv_str_enum_pattern=re.compile('^_?{prefix}_STR_(.+)'.format(prefix=module_prefix.upper()))

lv_callback_type_pattern=re.compile('({prefix}_){{0,1}}(.+)_cb(_t){{0,1}}'.format(prefix=module_prefix))

lv_global_callback_pattern=re.compile('.*g_cb_t')

lv_func_returns_array=re.compile('.*_array$')

pp_data=f.read()

cparser=pycparser.CParser()

ast=cparser.parse(pp_data,input_headers[0])

ast=cparser.parse(pp_data,input_header)

forward_struct_decls= {}

synonym[t.declname]=t.type.name

struct_typedefs= [typedeffortypedefintypedefsifis_struct(typedef.type)]

structs=collections.OrderedDict((typedef.declname,typedef.type)fortypedefinstruct_typedefsiftypedef.declnameandtypedef.type.decls)# and not lv_base_obj_pattern.match(typedef.declname))

structs_without_typedef=collections.OrderedDict((decl.type.name,decl.type)fordeclinast.extifhasattr(decl,'type')andis_struct(decl.type))

fortypedefinstruct_typedefs:

iftypedef.type.declsisNone:# None means it's a forward declaration

struct_name=typedef.type.name

iftypedef.type.nameinstructs_without_typedef:

typedef.type=structs_without_typedef[struct_name]

structs=collections.OrderedDict((typedef.declname,typedef.type)fortypedefinstruct_typedefsiftypedef.declnameandtypedef.type.decls)# and not lv_base_obj_pattern.match(typedef.declname))

structs.update(structs_without_typedef)# This is for struct without typedef

explicit_structs=collections.OrderedDict((typedef.type.name,typedef.declname)fortypedefinstruct_typedefsiftypedef.type.name)# and not lv_base_obj_pattern.match(typedef.type.name))

opaque_structs=collections.OrderedDict((typedef.declname,c_ast.Struct(name=typedef.declname,decls=[]))fortypedefintypedefsifisinstance(typedef.type,c_ast.Struct)andtypedef.type.decls==None)

input_headers= [input_header,private_header]

print ("""

""".format(

module_name=module_name,

cmd_line=' '.join(argv),

cmd_line=' '.join(sys.argv),

pp_cmd=pp_cmd,

objs=", ".join(['%s(%s)'% (objname,parent_obj_names[objname])forobjnameinobj_names]),

lv_headers='\n'.join('#include "%s"'%headerforheaderininput_headers)))

enums[enum_name]=enum

forenumin [enumforenuminenumsiflen(enums[enum])==1andenum.startswith('ENUM')]:

int_constants.append('%s_%s'% (enum,list(enums[enum].keys())[0]))

int_constants.append('%s_%s'% (enum,next(iter(enums[enum]))))

enum_name='%s_%s'% (enum,list(enums[enum].keys())[0])

constant_metadata[enum_name.replace('ENUM_','').replace('LV_','')]= {'py_type':'int','c_type':enum_name.replace('ENUM_','')}

delenums[enum]

user_data_found=user_datain [decl.namefordeclinflatten_struct_decls]

ud_accessors=get_user_data_accessors(containing_struct,containing_struct_name)

ifuser_data_found:

res= (user_data, )

else:

res= (None, )

ifnotuser_data_foundandlvgl_jsonisnotNone:

containing_struct_j=next((structforstructinlvgl_json["structures"]ifstruct["name"]==struct_arg_type_name),None)

if (containing_struct_jisNone

andstruct_arg_type_name.startswith("lv_")

andNoneisnotnext((fwd_declforfwd_declinlvgl_json["forward_decls"]iffwd_decl["name"]==struct_arg_type_name),None)

):

containing_struct_j=next((structforstructinlvgl_json["structures"]ifstruct["name"]==struct_arg_type_name_with_underscore),None)

ifcontaining_struct_jisnotNone:

user_data_found=any(user_data==field["name"]forfieldincontaining_struct_j["fields"])

return (user_dataifuser_data_foundelseNone),*get_user_data_accessors(containing_struct,containing_struct_name)

gen_func_error(decl,"Missing 'user_data' as a field of the first parameter of the callback function '%s_%s_callback'"% (struct_name,func_name))

else:

gen_func_error(decl,"Missing 'user_data' member in struct '%s'"%struct_name)

write_cases.append('case MP_QSTR_{field}: data->{field} = {cast}mp_lv_callback(dest[1], {lv_callback} ,MP_QSTR_{struct_name}_{field}, {user_data}, NULL, NULL, NULL); break; // converting to callback {type_name}'.

format(struct_name=struct_name,field=sanitize(decl.name),lv_callback=lv_callback,user_data=full_user_data_ptr,type_name=type_name,cast=cast))

read_cases.append('case MP_QSTR_{field}: dest[0] = mp_lv_funcptr(&mp_{funcptr}_mpobj, {cast}data->{field}, {lv_callback} ,MP_QSTR_{struct_name}_{field}, {user_data}); break; // converting from callback {type_name}'.

format(struct_name=struct_name,field=sanitize(decl.name),lv_callback=lv_callback,funcptr=lv_to_mp_funcptr[type_name],user_data=full_user_data,type_name=type_name,cast=cast))

attribute_meta[sanitize(decl.name)]= {'py_type':'Callable','c_type':type_name,'is_writeable':True,'is_readable':True}

write_cases.append('case MP_QSTR_{field}: data->{decl_name} = {cast}mp_lv_callback(dest[1], {lv_callback} ,MP_QSTR_{struct_name}_{field}, {user_data}, NULL, NULL, NULL); break; // converting to callback {type_name}'.

format(struct_name=struct_name,field=sanitize(decl.name),decl_name=decl.name,lv_callback=lv_callback,user_data=full_user_data_ptr,type_name=type_name,cast=cast))

read_cases.append('case MP_QSTR_{field}: dest[0] = mp_lv_funcptr(&mp_{funcptr}_mpobj, {cast}data->{decl_name}, {lv_callback} ,MP_QSTR_{struct_name}_{field}, {user_data}); break; // converting from callback {type_name}'.

format(struct_name=struct_name,field=sanitize(decl.name),decl_name=decl.name,lv_callback=lv_callback,funcptr=lv_to_mp_funcptr[type_name],user_data=full_user_data,type_name=type_name,cast=cast))

else:

ifisinstance(decl.type,c_ast.ArrayDecl):

memcpy_size='sizeof(%s)*%s'% (gen.visit(decl.type.type),gen.visit(decl.type.dim))

ifis_writeable:

write_cases.append('case MP_QSTR_{field}: memcpy((void*)&data->{field}, {cast}{convertor}(dest[1]), {size}); break; // converting to {type_name}'.

format(field=sanitize(decl.name),convertor=mp_to_lv_convertor,type_name=type_name,cast=cast,size=memcpy_size))

read_cases.append('case MP_QSTR_{field}: dest[0] = {convertor}({cast}data->{field}); break; // converting from {type_name}'.

format(field=sanitize(decl.name),convertor=lv_to_mp_convertor,type_name=type_name,cast=cast))

write_cases.append('case MP_QSTR_{field}: memcpy((void*)&data->{decl_name}, {cast}{convertor}(dest[1]), {size}); break; // converting to {type_name}'.

format(field=sanitize(decl.name),decl_name=decl.name,convertor=mp_to_lv_convertor,type_name=type_name,cast=cast,size=memcpy_size))

read_cases.append('case MP_QSTR_{field}: dest[0] = {convertor}({cast}data->{decl_name}); break; // converting from {type_name}'.

format(field=sanitize(decl.name),decl_name=decl.name,convertor=lv_to_mp_convertor,type_name=type_name,cast=cast))

else:

ifis_writeable:

write_cases.append('case MP_QSTR_{field}: data->{field} = {cast}{convertor}(dest[1]); break; // converting to {type_name}'.

format(field=sanitize(decl.name),convertor=mp_to_lv_convertor,type_name=type_name,cast=cast))

read_cases.append(

'case MP_QSTR_{field}: dest[0] = {convertor}({cast}data->{field}); break; // converting from {type_name}'.

format(field=sanitize(decl.name),convertor=lv_to_mp_convertor,type_name=type_name,cast=cast))

write_cases.append('case MP_QSTR_{field}: data->{decl_name} = {cast}{convertor}(dest[1]); break; // converting to {type_name}'.

format(field=sanitize(decl.name),decl_name=decl.name,convertor=mp_to_lv_convertor,type_name=type_name,cast=cast))

read_cases.append('case MP_QSTR_{field}: dest[0] = {convertor}({cast}data->{decl_name}); break; // converting from {type_name}'.

format(field=sanitize(decl.name),decl_name=decl.name,convertor=lv_to_mp_convertor,type_name=type_name,cast=cast))

print('''

prototype_str=gen.visit(function_prototype(func))

ifprototype_strinfunc_prototypes:

original_func=func_prototypes[prototype_str]

ifnotoriginal_func.name.endswith('cb_t')andgenerated_funcs[original_func.name]==True:

ifgenerated_funcs[original_func.name]==True:

print("/* Reusing %s for %s */"% (original_func.name,func.name))

emit_func_obj(func.name,original_func.name,param_count,func.name,is_static_member(func,base_obj_type))

func=func.name,

func_ptr=prototype_str,

print_func=gen.visit(func),

build_args="\n ".join(build_args),

build_args="\n ".join([build_mp_func_arg(arg,i,func,obj_name)fori,arginenumerated_args

ifisinstance(arg,c_ast.EllipsisParam)or

(notisinstance(arg.type,c_ast.TypeDecl))or

(notisinstance(arg.type.type,c_ast.IdentifierType))or

'void'notinarg.type.type.names]),# Handle the case of 'void' param which should be ignored

send_args=", ".join([(arg.nameif (hasattr(arg,'name')andarg.name)else ("arg%d"%i))fori,arginenumerate(args)]),

build_result=build_result,

build_return_value=build_return_value))