[J-u-boot.git] / boot / expo_build.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Building an expo from an FDT description
 *
 * Copyright 2022 Google LLC
 * Written by Simon Glass <[email protected]>
 */

#define LOG_CATEGORY	LOGC_EXPO

#include <common.h>
#include <expo.h>
#include <fdtdec.h>
#include <log.h>
#include <malloc.h>
#include <dm/ofnode.h>
#include <linux/libfdt.h>

/**
 * struct build_info - Information to use when building
 *
 * @str_for_id: String for each ID in use, NULL if empty. The string is NULL
 *	if there is nothing for this ID. Since ID 0 is never used, the first
 *	element of this array is always NULL
 * @str_count: Number of entries in @str_for_id
 * @err_node: Node being processed (for error reporting)
 * @err_prop: Property being processed (for error reporting)
 */
struct build_info {
	const char **str_for_id;
	int str_count;
	ofnode err_node;
	const char *err_prop;
};

/**
 * add_txt_str - Add a string or lookup its ID, then add to expo
 *
 * @info: Build information
 * @node: Node describing scene
 * @scn: Scene to add to
 * @find_name: Name to look for (e.g. "title"). This will find a property called
 * "title" if it exists, else will look up the string for "title-id"
 * Return: ID of added string, or -ve on error
 */
int add_txt_str(struct build_info *info, ofnode node, struct scene *scn,
		const char *find_name, uint obj_id)
{
	const char *text;
	uint str_id;
	int ret;

	info->err_prop = find_name;
	text = ofnode_read_string(node, find_name);
	if (!text) {
		char name[40];
		u32 id;

		snprintf(name, sizeof(name), "%s-id", find_name);
		ret = ofnode_read_u32(node, name, &id);
		if (ret)
			return log_msg_ret("id", -ENOENT);

		if (id >= info->str_count)
			return log_msg_ret("id", -E2BIG);
		text = info->str_for_id[id];
		if (!text)
			return log_msg_ret("id", -EINVAL);
	}

	ret = expo_str(scn->expo, find_name, 0, text);
	if (ret < 0)
		return log_msg_ret("add", ret);
	str_id = ret;

	ret = scene_txt_str(scn, find_name, obj_id, str_id, text, NULL);
	if (ret < 0)
		return log_msg_ret("add", ret);

	return ret;
}

/**
 * add_txt_str_list - Add a list string or lookup its ID, then add to expo
 *
 * @info: Build information
 * @node: Node describing scene
 * @scn: Scene to add to
 * @find_name: Name to look for (e.g. "title"). This will find a string-list
 * property called "title" if it exists, else will look up the string in the
 * "title-id" string list.
 * Return: ID of added string, or -ve on error
 */
int add_txt_str_list(struct build_info *info, ofnode node, struct scene *scn,
		     const char *find_name, int index, uint obj_id)
{
	const char *text;
	uint str_id;
	int ret;

	ret = ofnode_read_string_index(node, find_name, index, &text);
	if (ret) {
		char name[40];
		u32 id;

		snprintf(name, sizeof(name), "%s-id", find_name);
		ret = ofnode_read_u32_index(node, name, index, &id);
		if (ret)
			return log_msg_ret("id", -ENOENT);

		if (id >= info->str_count)
			return log_msg_ret("id", -E2BIG);
		text = info->str_for_id[id];
		if (!text)
			return log_msg_ret("id", -EINVAL);
	}

	ret = expo_str(scn->expo, find_name, 0, text);
	if (ret < 0)
		return log_msg_ret("add", ret);
	str_id = ret;

	ret = scene_txt_str(scn, find_name, obj_id, str_id, text, NULL);
	if (ret < 0)
		return log_msg_ret("add", ret);

	return ret;
}

/*
 * build_element() - Handle creating a text object from a label
 *
 * Look up a property called @label or @label-id and create a string for it
 */
int build_element(void *ldtb, int node, const char *label)
{
	return 0;
}

/**
 * read_strings() - Read in the list of strings
 *
 * Read the strings into an ID-indexed list, so they can be used for building
 * an expo. The strings are in a /strings node and each has its own subnode
 * containing the ID and the string itself:
 *
 * example {
 *    id = <123>;
 *    value = "This is a test";
 * };
 *
 * Future work may add support for unicode and multiple languages
 *
 * @info: Build information
 * @root: Root node to read from
 * Returns: 0 if OK, -ENOMEM if out of memory, -EINVAL if there is a format
 * error
 */
static int read_strings(struct build_info *info, ofnode root)
{
	ofnode strings, node;

	strings = ofnode_find_subnode(root, "strings");
	if (!ofnode_valid(strings))
		return log_msg_ret("str", -EINVAL);

	ofnode_for_each_subnode(node, strings) {
		const char *val;
		int ret;
		u32 id;

		info->err_node = node;
		ret = ofnode_read_u32(node, "id", &id);
		if (ret)
			return log_msg_ret("id", -ENOENT);
		val = ofnode_read_string(node, "value");
		if (!val)
			return log_msg_ret("val", -EINVAL);

		if (id >= info->str_count) {
			int new_count = info->str_count + 20;
			void *new_arr;

			new_arr = realloc(info->str_for_id,
					  new_count * sizeof(char *));
			if (!new_arr)
				return log_msg_ret("id", -ENOMEM);
			memset(new_arr + info->str_count, '\0',
			       (new_count - info->str_count) * sizeof(char *));
			info->str_for_id = new_arr;
			info->str_count = new_count;
		}

		info->str_for_id[id] = val;
	}

	return 0;
}

/**
 * list_strings() - List the available strings with their IDs
 *
 * @info: Build information
 */
static void list_strings(struct build_info *info)
{
	int i;

	for (i = 0; i < info->str_count; i++) {
		if (info->str_for_id[i])
			printf("%3d %s\n", i, info->str_for_id[i]);
	}
}

/**
 * menu_build() - Build a menu and add it to a scene
 *
 * See doc/develop/expo.rst for a description of the format
 *
 * @info: Build information
 * @node: Node containing the menu description
 * @scn: Scene to add the menu to
 * @id: ID for the menu
 * @objp: Returns the object pointer
 * Returns: 0 if OK, -ENOMEM if out of memory, -EINVAL if there is a format
 * error, -ENOENT if there is a references to a non-existent string
 */
static int menu_build(struct build_info *info, ofnode node, struct scene *scn,
		      uint id, struct scene_obj **objp)
{
	struct scene_obj_menu *menu;
	uint title_id, menu_id;
	const u32 *item_ids;
	int ret, size, i;
	const char *name;

	name = ofnode_get_name(node);

	ret = scene_menu(scn, name, id, &menu);
	if (ret < 0)
		return log_msg_ret("men", ret);
	menu_id = ret;

	/* Set the title */
	ret = add_txt_str(info, node, scn, "title", 0);
	if (ret < 0)
		return log_msg_ret("tit", ret);
	title_id = ret;
	ret = scene_menu_set_title(scn, menu_id, title_id);
	if (ret)
		return log_msg_ret("set", ret);

	item_ids = ofnode_read_prop(node, "item-id", &size);
	if (!item_ids)
		return log_msg_ret("itm", -EINVAL);
	if (!size || size % sizeof(u32))
		return log_msg_ret("isz", -EINVAL);
	size /= sizeof(u32);

	for (i = 0; i < size; i++) {
		struct scene_menitem *item;
		uint label, key, desc;

		ret = add_txt_str_list(info, node, scn, "item-label", i, 0);
		if (ret < 0 && ret != -ENOENT)
			return log_msg_ret("lab", ret);
		label = max(0, ret);

		ret = add_txt_str_list(info, node, scn, "key-label", i, 0);
		if (ret < 0 && ret != -ENOENT)
			return log_msg_ret("key", ret);
		key = max(0, ret);

		ret = add_txt_str_list(info, node, scn, "desc-label", i, 0);
		if (ret < 0  && ret != -ENOENT)
			return log_msg_ret("lab", ret);
		desc = max(0, ret);

		ret = scene_menuitem(scn, menu_id, simple_xtoa(i),
				     fdt32_to_cpu(item_ids[i]), key, label,
				     desc, 0, 0, &item);
		if (ret < 0)
			return log_msg_ret("mi", ret);
	}
	*objp = &menu->obj;

	return 0;
}

static int textline_build(struct build_info *info, ofnode node,
			  struct scene *scn, uint id, struct scene_obj **objp)
{
	struct scene_obj_textline *ted;
	uint ted_id, edit_id;
	const char *name;
	u32 max_chars;
	int ret;

	name = ofnode_get_name(node);

	info->err_prop = "max-chars";
	ret = ofnode_read_u32(node, "max-chars", &max_chars);
	if (ret)
		return log_msg_ret("max", -ENOENT);

	ret = scene_textline(scn, name, id, max_chars, &ted);
	if (ret < 0)
		return log_msg_ret("ted", ret);
	ted_id = ret;

	/* Set the title */
	ret = add_txt_str(info, node, scn, "title", 0);
	if (ret < 0)
		return log_msg_ret("tit", ret);
	ted->label_id = ret;

	/* Setup the editor */
	info->err_prop = "edit-id";
	ret = ofnode_read_u32(node, "edit-id", &id);
	if (ret)
		return log_msg_ret("id", -ENOENT);
	edit_id = ret;

	ret = scene_txt_str(scn, "edit", edit_id, 0, abuf_data(&ted->buf),
			    NULL);
	if (ret < 0)
		return log_msg_ret("add", ret);
	ted->edit_id = ret;

	return 0;
}

/**
 * obj_build() - Build an expo object and add it to a scene
 *
 * See doc/develop/expo.rst for a description of the format
 *
 * @info: Build information
 * @node: Node containing the object description
 * @scn: Scene to add the object to
 * Returns: 0 if OK, -ENOMEM if out of memory, -EINVAL if there is a format
 * error, -ENOENT if there is a references to a non-existent string
 */
static int obj_build(struct build_info *info, ofnode node, struct scene *scn)
{
	struct scene_obj *obj;
	const char *type;
	u32 id, val;
	int ret;

	log_debug("- object %s\n", ofnode_get_name(node));
	ret = ofnode_read_u32(node, "id", &id);
	if (ret)
		return log_msg_ret("id", -ENOENT);

	type = ofnode_read_string(node, "type");
	if (!type)
		return log_msg_ret("typ", -EINVAL);

	if (!strcmp("menu", type))
		ret = menu_build(info, node, scn, id, &obj);
	else if (!strcmp("textline", type))
		ret = textline_build(info, node, scn, id, &obj);
	else
		ret = -EOPNOTSUPP;
	if (ret)
		return log_msg_ret("bld", ret);

	if (!ofnode_read_u32(node, "start-bit", &val))
		obj->start_bit = val;
	if (!ofnode_read_u32(node, "bit-length", &val))
		obj->bit_length = val;

	return 0;
}

/**
 * scene_build() - Build a scene and all its objects
 *
 * See doc/develop/expo.rst for a description of the format
 *
 * @info: Build information
 * @node: Node containing the scene description
 * @scn: Scene to add the object to
 * Returns: 0 if OK, -ENOMEM if out of memory, -EINVAL if there is a format
 * error, -ENOENT if there is a references to a non-existent string
 */
static int scene_build(struct build_info *info, ofnode scn_node,
		       struct expo *exp)
{
	const char *name;
	struct scene *scn;
	uint id, title_id;
	ofnode node;
	int ret;

	info->err_node = scn_node;
	name = ofnode_get_name(scn_node);
	log_debug("Building scene %s\n", name);
	ret = ofnode_read_u32(scn_node, "id", &id);
	if (ret)
		return log_msg_ret("id", -ENOENT);

	ret = scene_new(exp, name, id, &scn);
	if (ret < 0)
		return log_msg_ret("scn", ret);

	ret = add_txt_str(info, scn_node, scn, "title", 0);
	if (ret < 0)
		return log_msg_ret("tit", ret);
	title_id = ret;
	scene_title_set(scn, title_id);

	ret = add_txt_str(info, scn_node, scn, "prompt", 0);
	if (ret < 0)
		return log_msg_ret("pr", ret);

	ofnode_for_each_subnode(node, scn_node) {
		info->err_node = node;
		ret = obj_build(info, node, scn);
		if (ret < 0)
			return log_msg_ret("mit", ret);
	}

	return 0;
}

int build_it(struct build_info *info, ofnode root, struct expo **expp)
{
	ofnode scenes, node;
	struct expo *exp;
	u32 dyn_start;
	int ret;

	ret = read_strings(info, root);
	if (ret)
		return log_msg_ret("str", ret);
	if (_DEBUG)
		list_strings(info);
	info->err_node = root;

	ret = expo_new("name", NULL, &exp);
	if (ret)
		return log_msg_ret("exp", ret);

	if (!ofnode_read_u32(root, "dynamic-start", &dyn_start))
		expo_set_dynamic_start(exp, dyn_start);

	scenes = ofnode_find_subnode(root, "scenes");
	if (!ofnode_valid(scenes))
		return log_msg_ret("sno", -EINVAL);

	ofnode_for_each_subnode(node, scenes) {
		ret = scene_build(info, node, exp);
		if (ret < 0)
			return log_msg_ret("scn", ret);
	}
	*expp = exp;

	return 0;
}

int expo_build(ofnode root, struct expo **expp)
{
	struct build_info info;
	struct expo *exp;
	int ret;

	memset(&info, '\0', sizeof(info));
	ret = build_it(&info, root, &exp);
	if (ret) {
		char buf[120];
		int node_ret;

		node_ret = ofnode_get_path(info.err_node, buf, sizeof(buf));
		log_warning("Build failed at node %s, property %s\n",
			    node_ret ? ofnode_get_name(info.err_node) : buf,
			    info.err_prop);

		return log_msg_ret("bui", ret);
	}
	*expp = exp;

	return 0;
}
Commit	Line	Data
82cafee1 SG	1	// SPDX-License-Identifier: GPL-2.0+
	2	/*
	3	* Building an expo from an FDT description
	4	*
	5	* Copyright 2022 Google LLC
	6	* Written by Simon Glass <[email protected]>
	7	*/
	8
	9	#define LOG_CATEGORY LOGC_EXPO
	10
	11	#include <common.h>
	12	#include <expo.h>
	13	#include <fdtdec.h>
	14	#include <log.h>
	15	#include <malloc.h>
	16	#include <dm/ofnode.h>
	17	#include <linux/libfdt.h>
	18
	19	/**
	20	* struct build_info - Information to use when building
	21	*
	22	* @str_for_id: String for each ID in use, NULL if empty. The string is NULL
	23	* if there is nothing for this ID. Since ID 0 is never used, the first
	24	* element of this array is always NULL
	25	* @str_count: Number of entries in @str_for_id
5fb9e2aa SG	26	* @err_node: Node being processed (for error reporting)
5fb9e2aa SG	27	* @err_prop: Property being processed (for error reporting)
82cafee1 SG	28	*/
	29	struct build_info {
	30	const char **str_for_id;
	31	int str_count;
5fb9e2aa SG	32	ofnode err_node;
5fb9e2aa SG	33	const char *err_prop;
82cafee1 SG	34	};
	35
	36	/**
	37	* add_txt_str - Add a string or lookup its ID, then add to expo
	38	*
	39	* @info: Build information
	40	* @node: Node describing scene
	41	* @scn: Scene to add to
	42	* @find_name: Name to look for (e.g. "title"). This will find a property called
	43	* "title" if it exists, else will look up the string for "title-id"
	44	* Return: ID of added string, or -ve on error
	45	*/
	46	int add_txt_str(struct build_info info, ofnode node, struct scene scn,
	47	const char *find_name, uint obj_id)
	48	{
	49	const char *text;
	50	uint str_id;
	51	int ret;
	52
5fb9e2aa	53	info->err_prop = find_name;
82cafee1 SG	54	text = ofnode_read_string(node, find_name);
	55	if (!text) {
	56	char name[40];
	57	u32 id;
	58
	59	snprintf(name, sizeof(name), "%s-id", find_name);
	60	ret = ofnode_read_u32(node, name, &id);
	61	if (ret)
5fb9e2aa	62	return log_msg_ret("id", -ENOENT);
82cafee1 SG	63
	64	if (id >= info->str_count)
	65	return log_msg_ret("id", -E2BIG);
	66	text = info->str_for_id[id];
	67	if (!text)
	68	return log_msg_ret("id", -EINVAL);
	69	}
	70
	71	ret = expo_str(scn->expo, find_name, 0, text);
	72	if (ret < 0)
	73	return log_msg_ret("add", ret);
	74	str_id = ret;
	75
	76	ret = scene_txt_str(scn, find_name, obj_id, str_id, text, NULL);
	77	if (ret < 0)
	78	return log_msg_ret("add", ret);
	79
	80	return ret;
	81	}
	82
	83	/**
	84	* add_txt_str_list - Add a list string or lookup its ID, then add to expo
	85	*
	86	* @info: Build information
	87	* @node: Node describing scene
	88	* @scn: Scene to add to
	89	* @find_name: Name to look for (e.g. "title"). This will find a string-list
	90	* property called "title" if it exists, else will look up the string in the
	91	* "title-id" string list.
	92	* Return: ID of added string, or -ve on error
	93	*/
	94	int add_txt_str_list(struct build_info info, ofnode node, struct scene scn,
	95	const char *find_name, int index, uint obj_id)
	96	{
	97	const char *text;
	98	uint str_id;
	99	int ret;
	100
	101	ret = ofnode_read_string_index(node, find_name, index, &text);
	102	if (ret) {
	103	char name[40];
	104	u32 id;
	105
	106	snprintf(name, sizeof(name), "%s-id", find_name);
	107	ret = ofnode_read_u32_index(node, name, index, &id);
	108	if (ret)
	109	return log_msg_ret("id", -ENOENT);
	110
	111	if (id >= info->str_count)
	112	return log_msg_ret("id", -E2BIG);
	113	text = info->str_for_id[id];
	114	if (!text)
	115	return log_msg_ret("id", -EINVAL);
	116	}
	117
	118	ret = expo_str(scn->expo, find_name, 0, text);
	119	if (ret < 0)
	120	return log_msg_ret("add", ret);
	121	str_id = ret;
	122
	123	ret = scene_txt_str(scn, find_name, obj_id, str_id, text, NULL);
	124	if (ret < 0)
	125	return log_msg_ret("add", ret);
	126
127	return ret;
128	}
129
130	/*
131	* build_element() - Handle creating a text object from a label
132	*
133	* Look up a property called @label or @label-id and create a string for it
134	*/
135	int build_element(void ldtb, int node, const char label)
136	{
137	return 0;
138	}
139
140	/**
141	* read_strings() - Read in the list of strings
142	*
143	* Read the strings into an ID-indexed list, so they can be used for building
144	* an expo. The strings are in a /strings node and each has its own subnode
145	* containing the ID and the string itself:
146	*
147	* example {
148	* id = <123>;
149	* value = "This is a test";
150	* };
151	*
152	* Future work may add support for unicode and multiple languages
153	*
154	* @info: Build information
155	* @root: Root node to read from
156	* Returns: 0 if OK, -ENOMEM if out of memory, -EINVAL if there is a format
157	* error
158	*/
159	static int read_strings(struct build_info *info, ofnode root)
160	{
161	ofnode strings, node;
162
163	strings = ofnode_find_subnode(root, "strings");
164	if (!ofnode_valid(strings))
165	return log_msg_ret("str", -EINVAL);
166
167	ofnode_for_each_subnode(node, strings) {
168	const char *val;
169	int ret;
170	u32 id;
171
5fb9e2aa	172	info->err_node = node;
82cafee1 SG	173	ret = ofnode_read_u32(node, "id", &id);
82cafee1 SG	174	if (ret)
5fb9e2aa	175	return log_msg_ret("id", -ENOENT);
82cafee1 SG	176	val = ofnode_read_string(node, "value");
	177	if (!val)
	178	return log_msg_ret("val", -EINVAL);
	179
	180	if (id >= info->str_count) {
	181	int new_count = info->str_count + 20;
	182	void *new_arr;
	183
	184	new_arr = realloc(info->str_for_id,
	185	new_count * sizeof(char *));
	186	if (!new_arr)
	187	return log_msg_ret("id", -ENOMEM);
	188	memset(new_arr + info->str_count, '\0',
	189	(new_count - info->str_count) * sizeof(char *));
	190	info->str_for_id = new_arr;
	191	info->str_count = new_count;
	192	}
	193
	194	info->str_for_id[id] = val;
	195	}
	196
	197	return 0;
	198	}
	199
	200	/**
	201	* list_strings() - List the available strings with their IDs
	202	*
	203	* @info: Build information
	204	*/
	205	static void list_strings(struct build_info *info)
	206	{
	207	int i;
	208
	209	for (i = 0; i < info->str_count; i++) {
	210	if (info->str_for_id[i])
	211	printf("%3d %s\n", i, info->str_for_id[i]);
	212	}
	213	}
	214
	215	/**
	216	* menu_build() - Build a menu and add it to a scene
	217	*
a3a057f8	218	* See doc/develop/expo.rst for a description of the format
82cafee1 SG	219	*
	220	* @info: Build information
	221	* @node: Node containing the menu description
	222	* @scn: Scene to add the menu to
431b21fd SG	223	* @id: ID for the menu
431b21fd SG	224	* @objp: Returns the object pointer
82cafee1 SG	225	* Returns: 0 if OK, -ENOMEM if out of memory, -EINVAL if there is a format
	226	* error, -ENOENT if there is a references to a non-existent string
	227	*/
431b21fd SG	228	static int menu_build(struct build_info info, ofnode node, struct scene scn,
431b21fd SG	229	uint id, struct scene_obj **objp)
82cafee1 SG	230	{
	231	struct scene_obj_menu *menu;
	232	uint title_id, menu_id;
	233	const u32 *item_ids;
	234	int ret, size, i;
	235	const char *name;
82cafee1 SG	236
82cafee1 SG	237	name = ofnode_get_name(node);
82cafee1 SG	238
	239	ret = scene_menu(scn, name, id, &menu);
	240	if (ret < 0)
	241	return log_msg_ret("men", ret);
	242	menu_id = ret;
	243
	244	/* Set the title */
	245	ret = add_txt_str(info, node, scn, "title", 0);
	246	if (ret < 0)
	247	return log_msg_ret("tit", ret);
	248	title_id = ret;
	249	ret = scene_menu_set_title(scn, menu_id, title_id);
5fb9e2aa SG	250	if (ret)
5fb9e2aa SG	251	return log_msg_ret("set", ret);
82cafee1 SG	252
	253	item_ids = ofnode_read_prop(node, "item-id", &size);
	254	if (!item_ids)
	255	return log_msg_ret("itm", -EINVAL);
	256	if (!size \|\| size % sizeof(u32))
	257	return log_msg_ret("isz", -EINVAL);
	258	size /= sizeof(u32);
	259
	260	for (i = 0; i < size; i++) {
	261	struct scene_menitem *item;
	262	uint label, key, desc;
	263
	264	ret = add_txt_str_list(info, node, scn, "item-label", i, 0);
	265	if (ret < 0 && ret != -ENOENT)
	266	return log_msg_ret("lab", ret);
	267	label = max(0, ret);
	268
	269	ret = add_txt_str_list(info, node, scn, "key-label", i, 0);
	270	if (ret < 0 && ret != -ENOENT)
	271	return log_msg_ret("key", ret);
	272	key = max(0, ret);
	273
	274	ret = add_txt_str_list(info, node, scn, "desc-label", i, 0);
	275	if (ret < 0 && ret != -ENOENT)
	276	return log_msg_ret("lab", ret);
	277	desc = max(0, ret);
	278
	279	ret = scene_menuitem(scn, menu_id, simple_xtoa(i),
	280	fdt32_to_cpu(item_ids[i]), key, label,
	281	desc, 0, 0, &item);
	282	if (ret < 0)
	283	return log_msg_ret("mi", ret);
	284	}
431b21fd	285	*objp = &menu->obj;
82cafee1 SG	286
	287	return 0;
	288	}
	289
7318e0ef SG	290	static int textline_build(struct build_info *info, ofnode node,
	291	struct scene scn, uint id, struct scene_obj *objp)
	292	{
	293	struct scene_obj_textline *ted;
	294	uint ted_id, edit_id;
	295	const char *name;
	296	u32 max_chars;
	297	int ret;
	298
	299	name = ofnode_get_name(node);
	300
	301	info->err_prop = "max-chars";
	302	ret = ofnode_read_u32(node, "max-chars", &max_chars);
	303	if (ret)
	304	return log_msg_ret("max", -ENOENT);
	305
	306	ret = scene_textline(scn, name, id, max_chars, &ted);
	307	if (ret < 0)
	308	return log_msg_ret("ted", ret);
	309	ted_id = ret;
	310
	311	/* Set the title */
	312	ret = add_txt_str(info, node, scn, "title", 0);
	313	if (ret < 0)
	314	return log_msg_ret("tit", ret);
	315	ted->label_id = ret;
	316
	317	/* Setup the editor */
	318	info->err_prop = "edit-id";
	319	ret = ofnode_read_u32(node, "edit-id", &id);
	320	if (ret)
	321	return log_msg_ret("id", -ENOENT);
	322	edit_id = ret;
	323
	324	ret = scene_txt_str(scn, "edit", edit_id, 0, abuf_data(&ted->buf),
	325	NULL);
	326	if (ret < 0)
	327	return log_msg_ret("add", ret);
	328	ted->edit_id = ret;
	329
	330	return 0;
	331	}
	332
82cafee1	333	/**
431b21fd	334	* obj_build() - Build an expo object and add it to a scene
82cafee1	335	*
a3a057f8	336	* See doc/develop/expo.rst for a description of the format
82cafee1 SG	337	*
	338	* @info: Build information
	339	* @node: Node containing the object description
	340	* @scn: Scene to add the object to
	341	* Returns: 0 if OK, -ENOMEM if out of memory, -EINVAL if there is a format
	342	* error, -ENOENT if there is a references to a non-existent string
	343	*/
	344	static int obj_build(struct build_info info, ofnode node, struct scene scn)
	345	{
431b21fd	346	struct scene_obj *obj;
82cafee1	347	const char *type;
eb6c71b5	348	u32 id, val;
82cafee1 SG	349	int ret;
	350
	351	log_debug("- object %s\n", ofnode_get_name(node));
	352	ret = ofnode_read_u32(node, "id", &id);
	353	if (ret)
5fb9e2aa	354	return log_msg_ret("id", -ENOENT);
82cafee1 SG	355
	356	type = ofnode_read_string(node, "type");
	357	if (!type)
	358	return log_msg_ret("typ", -EINVAL);
	359
	360	if (!strcmp("menu", type))
431b21fd	361	ret = menu_build(info, node, scn, id, &obj);
7318e0ef SG	362	else if (!strcmp("textline", type))
7318e0ef SG	363	ret = textline_build(info, node, scn, id, &obj);
5fb9e2aa SG	364	else
5fb9e2aa SG	365	ret = -EOPNOTSUPP;
82cafee1 SG	366	if (ret)
	367	return log_msg_ret("bld", ret);
	368
eb6c71b5 SG	369	if (!ofnode_read_u32(node, "start-bit", &val))
	370	obj->start_bit = val;
	371	if (!ofnode_read_u32(node, "bit-length", &val))
	372	obj->bit_length = val;
	373
82cafee1 SG	374	return 0;
	375	}
	376
	377	/**
	378	* scene_build() - Build a scene and all its objects
	379	*
a3a057f8	380	* See doc/develop/expo.rst for a description of the format
82cafee1 SG	381	*
	382	* @info: Build information
	383	* @node: Node containing the scene description
	384	* @scn: Scene to add the object to
	385	* Returns: 0 if OK, -ENOMEM if out of memory, -EINVAL if there is a format
	386	* error, -ENOENT if there is a references to a non-existent string
	387	*/
	388	static int scene_build(struct build_info *info, ofnode scn_node,
	389	struct expo *exp)
	390	{
	391	const char *name;
	392	struct scene *scn;
	393	uint id, title_id;
	394	ofnode node;
	395	int ret;
	396
5fb9e2aa	397	info->err_node = scn_node;
82cafee1 SG	398	name = ofnode_get_name(scn_node);
	399	log_debug("Building scene %s\n", name);
	400	ret = ofnode_read_u32(scn_node, "id", &id);
	401	if (ret)
5fb9e2aa	402	return log_msg_ret("id", -ENOENT);
82cafee1 SG	403
	404	ret = scene_new(exp, name, id, &scn);
	405	if (ret < 0)
	406	return log_msg_ret("scn", ret);
	407
	408	ret = add_txt_str(info, scn_node, scn, "title", 0);
	409	if (ret < 0)
	410	return log_msg_ret("tit", ret);
	411	title_id = ret;
	412	scene_title_set(scn, title_id);
	413
	414	ret = add_txt_str(info, scn_node, scn, "prompt", 0);
	415	if (ret < 0)
	416	return log_msg_ret("pr", ret);
	417
	418	ofnode_for_each_subnode(node, scn_node) {
5fb9e2aa	419	info->err_node = node;
82cafee1 SG	420	ret = obj_build(info, node, scn);
	421	if (ret < 0)
	422	return log_msg_ret("mit", ret);
	423	}
	424
	425	return 0;
	426	}
	427
5fb9e2aa	428	int build_it(struct build_info info, ofnode root, struct expo *expp)
82cafee1	429	{
82cafee1 SG	430	ofnode scenes, node;
	431	struct expo *exp;
	432	u32 dyn_start;
	433	int ret;
	434
5fb9e2aa	435	ret = read_strings(info, root);
82cafee1 SG	436	if (ret)
82cafee1 SG	437	return log_msg_ret("str", ret);
a0874dc4	438	if (_DEBUG)
5fb9e2aa SG	439	list_strings(info);
5fb9e2aa SG	440	info->err_node = root;
82cafee1 SG	441
	442	ret = expo_new("name", NULL, &exp);
	443	if (ret)
	444	return log_msg_ret("exp", ret);
	445
	446	if (!ofnode_read_u32(root, "dynamic-start", &dyn_start))
	447	expo_set_dynamic_start(exp, dyn_start);
	448
	449	scenes = ofnode_find_subnode(root, "scenes");
	450	if (!ofnode_valid(scenes))
	451	return log_msg_ret("sno", -EINVAL);
	452
	453	ofnode_for_each_subnode(node, scenes) {
5fb9e2aa	454	ret = scene_build(info, node, exp);
82cafee1 SG	455	if (ret < 0)
	456	return log_msg_ret("scn", ret);
	457	}
	458	*expp = exp;
	459
	460	return 0;
	461	}
5fb9e2aa SG	462
	463	int expo_build(ofnode root, struct expo **expp)
	464	{
	465	struct build_info info;
	466	struct expo *exp;
	467	int ret;
	468
	469	memset(&info, '\0', sizeof(info));
	470	ret = build_it(&info, root, &exp);
	471	if (ret) {
	472	char buf[120];
	473	int node_ret;
	474
	475	node_ret = ofnode_get_path(info.err_node, buf, sizeof(buf));
	476	log_warning("Build failed at node %s, property %s\n",
	477	node_ret ? ofnode_get_name(info.err_node) : buf,
	478	info.err_prop);
	479
	480	return log_msg_ret("bui", ret);
	481	}
	482	*expp = exp;
	483
	484	return 0;
	485	}