From: Alan T. DeKok <aland@freeradius.org>
Date: Mon, 30 Jun 2025 16:09:25 +0000 (-0400)
Subject: move unlang_ext_t fields to unlang_op_t
X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=42498b00576ac07b798ebe8888e91791485a3b30;p=thirdparty%2Ffreeradius-server.git

move unlang_ext_t fields to unlang_op_t

in preparation for adding function-style arguments to keywords
---

diff --git a/src/lib/unlang/call.c b/src/lib/unlang/call.c
index 3169b358a6..53f35896c3 100644
--- a/src/lib/unlang/call.c
+++ b/src/lib/unlang/call.c
@@ -250,8 +250,14 @@ void unlang_call_init(void)
 {
 	unlang_register(UNLANG_TYPE_CALL,
 			   &(unlang_op_t){
-				.name			= "call",
-				.interpret		= unlang_call_frame_init,
-				.flag			= UNLANG_OP_FLAG_RCODE_SET | UNLANG_OP_FLAG_DEBUG_BRACES
+				.name		= "call",
+				.flag		= UNLANG_OP_FLAG_RCODE_SET | UNLANG_OP_FLAG_DEBUG_BRACES,
+				.type		= UNLANG_TYPE_CALL,
+
+				.interpret	= unlang_call_frame_init,
+
+
+				.unlang_size	= sizeof(unlang_call_t),
+				.unlang_name	= "unlang_call_t",
 			   });
 }
diff --git a/src/lib/unlang/caller.c b/src/lib/unlang/caller.c
index 578e082d67..def5c58345 100644
--- a/src/lib/unlang/caller.c
+++ b/src/lib/unlang/caller.c
@@ -57,7 +57,12 @@ void unlang_caller_init(void)
 	unlang_register(UNLANG_TYPE_CALLER,
 			   &(unlang_op_t){
 				.name = "caller",
+				.type = UNLANG_TYPE_CALLER,
+				.flag = UNLANG_OP_FLAG_DEBUG_BRACES,
+
 				.interpret = unlang_caller,
-				.flag = UNLANG_OP_FLAG_DEBUG_BRACES
+
+				.unlang_size = sizeof(unlang_caller_t),
+				.unlang_name = "unlang_caller_t",
 			   });
 }
diff --git a/src/lib/unlang/catch.c b/src/lib/unlang/catch.c
index 5aa85e5175..c607be9f27 100644
--- a/src/lib/unlang/catch.c
+++ b/src/lib/unlang/catch.c
@@ -104,7 +104,12 @@ void unlang_catch_init(void)
 	unlang_register(UNLANG_TYPE_CATCH,
 			   &(unlang_op_t){
 				.name = "catch",
+				.type = UNLANG_TYPE_CATCH,
+				.flag = UNLANG_OP_FLAG_DEBUG_BRACES,
+
 				.interpret = unlang_catch,
-				.flag = UNLANG_OP_FLAG_DEBUG_BRACES
+
+				.unlang_size = sizeof(unlang_catch_t),
+				.unlang_name = "unlang_catch_t",
 			   });
 }
diff --git a/src/lib/unlang/compile.c b/src/lib/unlang/compile.c
index 5b5a25f1d7..537880159a 100644
--- a/src/lib/unlang/compile.c
+++ b/src/lib/unlang/compile.c
@@ -131,7 +131,7 @@ void compile_copy_context(unlang_compile_t *dst, unlang_compile_t const *src)
 #define UPDATE_CTX2 compile_copy_context(&unlang_ctx2, unlang_ctx)
 
 
-static unlang_t *compile_empty(unlang_t *parent, unlang_compile_t *unlang_ctx, CONF_SECTION *cs, unlang_ext_t const *ext);
+static unlang_t *compile_empty(unlang_t *parent, unlang_compile_t *unlang_ctx, CONF_SECTION *cs, unlang_type_t type);
 
 static char const unlang_spaces[] = "                                                                                                                                                                                                                                                                ";
 
@@ -553,20 +553,23 @@ int unlang_fixup_update(map_t *map, void *ctx)
 }
 
 
-static unlang_group_t *group_allocate(unlang_t *parent, CONF_SECTION *cs, unlang_ext_t const *ext)
+static unlang_group_t *group_allocate(unlang_t *parent, CONF_SECTION *cs, unlang_type_t type)
 {
 	unlang_group_t	*g;
 	unlang_t	*c;
 	TALLOC_CTX	*ctx;
+	unlang_op_t const *op = &unlang_ops[type];
 
 	ctx = parent;
 	if (!ctx) ctx = cs;
 
+	fr_assert(op->unlang_size > 0);
+
 	/*
 	 *	All the groups have a common header
 	 */
-	g = (unlang_group_t *)_talloc_zero_pooled_object(ctx, ext->len, ext->type_name,
-							 ext->pool_headers, ext->pool_len);
+	g = (unlang_group_t *)_talloc_zero_pooled_object(ctx, op->unlang_size, op->unlang_name,
+							 op->pool_headers, op->pool_len);
 	if (!g) return NULL;
 
 	g->children = NULL;
@@ -575,7 +578,7 @@ static unlang_group_t *group_allocate(unlang_t *parent, CONF_SECTION *cs, unlang
 
 	c = unlang_group_to_generic(g);
 	c->parent = parent;
-	c->type = ext->type;
+	c->type = type;
 	c->ci = CF_TO_ITEM(cs);
 
 	return g;
@@ -695,12 +698,6 @@ static unlang_t *compile_map(unlang_t *parent, unlang_compile_t *unlang_ctx, CON
 
 	tmpl_rules_t		t_rules;
 
-	static unlang_ext_t const map_ext = {
-		.type = UNLANG_TYPE_MAP,
-		.len = sizeof(unlang_map_t),
-		.type_name = "unlang_map_t"
-	};
-
 	/*
 	 *	The RHS is NOT resolved in the context of the LHS.
 	 */
@@ -721,7 +718,7 @@ static unlang_t *compile_map(unlang_t *parent, unlang_compile_t *unlang_ctx, CON
 	}
 	t_rules.literals_safe_for = map_proc_literals_safe_for(proc);
 
-	g = group_allocate(parent, cs, &map_ext);
+	g = group_allocate(parent, cs, UNLANG_TYPE_MAP);
 	if (!g) return NULL;
 
 	gext = unlang_group_to_map(g);
@@ -1145,12 +1142,6 @@ static unlang_t *compile_update(unlang_t *parent, unlang_compile_t *unlang_ctx,
 
 	tmpl_rules_t		t_rules;
 
-	static unlang_ext_t const update_ext = {
-		.type = UNLANG_TYPE_UPDATE,
-		.len = sizeof(unlang_map_t),
-		.type_name = "unlang_map_t"
-	};
-
 	if (main_config_migrate_option_get("forbid_update")) {
 		cf_log_err(cs, "The use of 'update' sections is forbidden by the server configuration");
 		return NULL;
@@ -1172,7 +1163,7 @@ static unlang_t *compile_update(unlang_t *parent, unlang_compile_t *unlang_ctx,
 	t_rules.attr.allow_wildcard = true;
 	RULES_VERIFY(&t_rules);
 
-	g = group_allocate(parent, cs, &update_ext);
+	g = group_allocate(parent, cs, UNLANG_TYPE_UPDATE);
 	if (!g) return NULL;
 
 	gext = unlang_group_to_map(g);
@@ -1908,7 +1899,7 @@ bool unlang_compile_actions(unlang_mod_actions_t *actions, CONF_SECTION *action_
 	return true;
 }
 
-static unlang_t *compile_empty(unlang_t *parent, unlang_compile_t *unlang_ctx, CONF_SECTION *cs, unlang_ext_t const *ext)
+static unlang_t *compile_empty(unlang_t *parent, unlang_compile_t *unlang_ctx, CONF_SECTION *cs, unlang_type_t type)
 {
 	unlang_group_t *g;
 	unlang_t *c;
@@ -1918,12 +1909,12 @@ static unlang_t *compile_empty(unlang_t *parent, unlang_compile_t *unlang_ctx, C
 	 *	*interpreter* type is GROUP, even if the *debug names*
 	 *	are something else.
 	 */
-	g = group_allocate(parent, cs, ext);
+	g = group_allocate(parent, cs, type);
 	if (!g) return NULL;
 
 	c = unlang_group_to_generic(g);
 	if (!cs) {
-		c->name = unlang_ops[ext->type].name;
+		c->name = unlang_ops[type].name;
 		c->debug_name = c->name;
 
 	} else {
@@ -2242,8 +2233,7 @@ static unlang_t *compile_children(unlang_group_t *g, unlang_compile_t *unlang_ct
 /*
  *	Generic "compile a section with more unlang inside of it".
  */
-static unlang_t *compile_section(unlang_t *parent, unlang_compile_t *unlang_ctx, CONF_SECTION *cs,
-				 unlang_ext_t const *ext)
+static unlang_t *compile_section(unlang_t *parent, unlang_compile_t *unlang_ctx, CONF_SECTION *cs, unlang_type_t type)
 {
 	unlang_group_t	*g;
 	unlang_t	*c;
@@ -2255,7 +2245,7 @@ static unlang_t *compile_section(unlang_t *parent, unlang_compile_t *unlang_ctx,
 	/*
 	 *	We always create a group, even if the section is empty.
 	 */
-	g = group_allocate(parent, cs, ext);
+	g = group_allocate(parent, cs, type);
 	if (!g) return NULL;
 
 	c = unlang_group_to_generic(g);
@@ -2271,7 +2261,7 @@ static unlang_t *compile_section(unlang_t *parent, unlang_compile_t *unlang_ctx,
 	 *	Make sure to tell the user that we're running a
 	 *	policy, and not anything else.
 	 */
-	if (ext->type == UNLANG_TYPE_POLICY) {
+	if (type == UNLANG_TYPE_POLICY) {
 		MEM(c->debug_name = talloc_typed_asprintf(c, "policy %s", name1));
 
 	} else if (!name2) {
@@ -2287,15 +2277,9 @@ static unlang_t *compile_section(unlang_t *parent, unlang_compile_t *unlang_ctx,
 
 static unlang_t *compile_group(unlang_t *parent, unlang_compile_t *unlang_ctx, CONF_ITEM const *ci)
 {
-	static unlang_ext_t const group = {
-		.type = UNLANG_TYPE_GROUP,
-		.len = sizeof(unlang_group_t),
-		.type_name = "unlang_group_t",
-	};
-
 	if (!cf_item_next(ci, NULL)) return UNLANG_IGNORE;
 
-	return compile_section(parent, unlang_ctx, cf_item_to_section(ci), &group);
+	return compile_section(parent, unlang_ctx, cf_item_to_section(ci), UNLANG_TYPE_GROUP);
 }
 
 static fr_table_num_sorted_t transaction_keywords[] = {
@@ -2386,12 +2370,6 @@ static unlang_t *compile_transaction(unlang_t *parent, unlang_compile_t *unlang_
 	unlang_t *c;
 	unlang_compile_t unlang_ctx2;
 
-	static unlang_ext_t const transaction = {
-		.type = UNLANG_TYPE_TRANSACTION,
-		.len = sizeof(unlang_transaction_t),
-		.type_name = "unlang_transaction_t",
-	};
-
 	if (cf_section_name2(cs) != NULL) {
 		cf_log_err(cs, "Unexpected argument to 'transaction' section");
 		cf_log_err(ci, DOC_KEYWORD_REF(transaction));
@@ -2415,7 +2393,7 @@ static unlang_t *compile_transaction(unlang_t *parent, unlang_compile_t *unlang_
 	unlang_ctx2.actions.actions[RLM_MODULE_INVALID] = MOD_ACTION_RETURN;
 	unlang_ctx2.actions.actions[RLM_MODULE_DISALLOW] = MOD_ACTION_RETURN;
 
-	g = group_allocate(parent, cs, &transaction);
+	g = group_allocate(parent, cs, UNLANG_TYPE_TRANSACTION);
 	if (!g) return NULL;
 
 	c = unlang_group_to_generic(g);
@@ -2443,12 +2421,6 @@ static unlang_t *compile_try(unlang_t *parent, unlang_compile_t *unlang_ctx, CON
 	unlang_t *c;
 	CONF_ITEM *next;
 
-	static unlang_ext_t const ext = {
-		.type = UNLANG_TYPE_TRY,
-		.len = sizeof(unlang_try_t),
-		.type_name = "unlang_try_t",
-	};
-
 	/*
 	 *	The transaction is empty, ignore it.
 	 */
@@ -2473,7 +2445,7 @@ static unlang_t *compile_try(unlang_t *parent, unlang_compile_t *unlang_ctx, CON
 		goto print_url;
 	}
 
-	g = group_allocate(parent, cs, &ext);
+	g = group_allocate(parent, cs, UNLANG_TYPE_TRY);
 	if (!g) return NULL;
 
 	c = unlang_group_to_generic(g);
@@ -2511,12 +2483,6 @@ static unlang_t *compile_catch(unlang_t *parent, unlang_compile_t *unlang_ctx, C
 	CONF_ITEM *prev;
 	char const *name;
 
-	static unlang_ext_t const ext = {
-		.type = UNLANG_TYPE_CATCH,
-		.len = sizeof(unlang_catch_t),
-		.type_name = "unlang_catch_t",
-	};
-
 	prev = cf_item_prev(cf_parent(ci), ci);
 	while (prev && cf_item_is_data(prev)) prev = cf_item_prev(cf_parent(ci), prev);
 
@@ -2538,7 +2504,7 @@ static unlang_t *compile_catch(unlang_t *parent, unlang_compile_t *unlang_ctx, C
 		goto fail;
 	}
 
-	g = group_allocate(parent, cs, &ext);
+	g = group_allocate(parent, cs, UNLANG_TYPE_CATCH);
 	if (!g) return NULL;
 
 	c = unlang_group_to_generic(g);
@@ -2627,14 +2593,6 @@ static unlang_t *compile_switch(unlang_t *parent, unlang_compile_t *unlang_ctx,
 	fr_type_t		type;
 	fr_htrie_type_t		htype;
 
-	static unlang_ext_t const switch_ext = {
-		.type = UNLANG_TYPE_SWITCH,
-		.len = sizeof(unlang_switch_t),
-		.type_name = "unlang_switch_t",
-		.pool_headers = TMPL_POOL_DEF_HEADERS,
-		.pool_len = TMPL_POOL_DEF_LEN
-	};
-
 	/*
 	 *	We allow unknown attributes here.
 	 */
@@ -2652,7 +2610,7 @@ static unlang_t *compile_switch(unlang_t *parent, unlang_compile_t *unlang_ctx,
 
 	if (!cf_item_next(cs, NULL)) return UNLANG_IGNORE;
 
-	g = group_allocate(parent, cs, &switch_ext);
+	g = group_allocate(parent, cs, UNLANG_TYPE_SWITCH);
 	if (!g) return NULL;
 
 	gext = unlang_group_to_switch(g);
@@ -2872,12 +2830,6 @@ static unlang_t *compile_case(unlang_t *parent, unlang_compile_t *unlang_ctx, CO
 	tmpl_t			*vpt = NULL;
 	tmpl_rules_t		t_rules;
 
-	static unlang_ext_t const case_ext = {
-		.type = UNLANG_TYPE_CASE,
-		.len = sizeof(unlang_case_t),
-		.type_name = "unlang_case_t",
-	};
-
 	/*
 	 *	We allow unknown attributes here.
 	 */
@@ -2969,7 +2921,7 @@ static unlang_t *compile_case(unlang_t *parent, unlang_compile_t *unlang_ctx, CO
 	 *	will silently skip the match, and then fall through to
 	 *	the "default" statement.
 	 */
-	c = compile_section(parent, unlang_ctx, cs, &case_ext);
+	c = compile_section(parent, unlang_ctx, cs, UNLANG_TYPE_CASE);
 	if (!c) {
 		talloc_free(vpt);
 		return NULL;
@@ -3000,12 +2952,6 @@ static unlang_t *compile_timeout(unlang_t *parent, unlang_compile_t *unlang_ctx,
 	tmpl_t			*vpt = NULL;
 	fr_token_t		token;
 
-	static unlang_ext_t const timeout_ext = {
-		.type = UNLANG_TYPE_TIMEOUT,
-		.len = sizeof(unlang_timeout_t),
-		.type_name = "unlang_timeout_t",
-	};
-
 	/*
 	 *	Timeout <time ref>
 	 */
@@ -3019,7 +2965,7 @@ static unlang_t *compile_timeout(unlang_t *parent, unlang_compile_t *unlang_ctx,
 
 	if (!cf_item_next(cs, NULL)) return UNLANG_IGNORE;
 
-	g = group_allocate(parent, cs, &timeout_ext);
+	g = group_allocate(parent, cs, UNLANG_TYPE_TIMEOUT);
 	if (!g) return NULL;
 
 	gext = unlang_group_to_timeout(g);
@@ -3086,7 +3032,7 @@ static unlang_t *compile_timeout(unlang_t *parent, unlang_compile_t *unlang_ctx,
 	/*
 	 *	Compile the contents of a "timeout".
 	 */
-	c = compile_section(parent, unlang_ctx, cs, &timeout_ext);
+	c = compile_section(parent, unlang_ctx, cs, UNLANG_TYPE_TIMEOUT);
 	if (!c) return NULL;
 
 	g = unlang_generic_to_group(c);
@@ -3110,12 +3056,6 @@ static unlang_t *compile_limit(unlang_t *parent, unlang_compile_t *unlang_ctx, C
 	ssize_t			slen;
 	tmpl_rules_t		t_rules;
 
-	static unlang_ext_t const limit_ext = {
-		.type = UNLANG_TYPE_LIMIT,
-		.len = sizeof(unlang_limit_t),
-		.type_name = "unlang_limit_t",
-	};
-
 	/*
 	 *	limit <number>
 	 */
@@ -3129,7 +3069,7 @@ static unlang_t *compile_limit(unlang_t *parent, unlang_compile_t *unlang_ctx, C
 
 	if (!cf_item_next(cs, NULL)) return UNLANG_IGNORE;
 
-	g = group_allocate(parent, cs, &limit_ext);
+	g = group_allocate(parent, cs, UNLANG_TYPE_LIMIT);
 	if (!g) return NULL;
 
 	gext = unlang_group_to_limit(g);
@@ -3195,7 +3135,7 @@ static unlang_t *compile_limit(unlang_t *parent, unlang_compile_t *unlang_ctx, C
 	/*
 	 *	Compile the contents of a "limit".
 	 */
-	c = compile_section(parent, unlang_ctx, cs, &limit_ext);
+	c = compile_section(parent, unlang_ctx, cs, UNLANG_TYPE_LIMIT);
 	if (!c) return NULL;
 
 	g = unlang_generic_to_group(c);
@@ -3228,14 +3168,6 @@ static unlang_t *compile_foreach(unlang_t *parent, unlang_compile_t *unlang_ctx,
 	tmpl_rules_t		t_rules;
 	unlang_compile_t	unlang_ctx2;
 
-	static unlang_ext_t const foreach_ext = {
-		.type = UNLANG_TYPE_FOREACH,
-		.len = sizeof(unlang_foreach_t),
-		.type_name = "unlang_foreach_t",
-		.pool_headers = TMPL_POOL_DEF_HEADERS,
-		.pool_len = TMPL_POOL_DEF_LEN
-	};
-
 	/*
 	 *	Ignore empty "foreach" blocks, and don't even sanity check their arguments.
 	 */
@@ -3257,7 +3189,7 @@ static unlang_t *compile_foreach(unlang_t *parent, unlang_compile_t *unlang_ctx,
 	/*
 	 *	Allocate a group for the "foreach" block.
 	 */
-	g = group_allocate(parent, cs, &foreach_ext);
+	g = group_allocate(parent, cs, UNLANG_TYPE_FOREACH);
 	if (!g) return NULL;
 
 	c = unlang_group_to_generic(g);
@@ -3458,12 +3390,6 @@ static unlang_t *compile_break(unlang_t *parent, unlang_compile_t *unlang_ctx, C
 {
 	unlang_t *unlang;
 
-	static unlang_ext_t const break_ext = {
-		.type = UNLANG_TYPE_BREAK,
-		.len = sizeof(unlang_group_t),
-		.type_name = "unlang_group_t",
-	};
-
 	for (unlang = parent; unlang != NULL; unlang = unlang->parent) {
 		/*
 		 *	"break" doesn't go past a return point.
@@ -3482,19 +3408,13 @@ static unlang_t *compile_break(unlang_t *parent, unlang_compile_t *unlang_ctx, C
 
 	parent->closed = true;
 
-	return compile_empty(parent, unlang_ctx, NULL, &break_ext);
+	return compile_empty(parent, unlang_ctx, NULL, UNLANG_TYPE_BREAK);
 }
 
 static unlang_t *compile_continue(unlang_t *parent, unlang_compile_t *unlang_ctx, CONF_ITEM const *ci)
 {
 	unlang_t *unlang;
 
-	static unlang_ext_t const break_ext = {
-		.type = UNLANG_TYPE_CONTINUE,
-		.len = sizeof(unlang_group_t),
-		.type_name = "unlang_group_t",
-	};
-
 	for (unlang = parent; unlang != NULL; unlang = unlang->parent) {
 		/*
 		 *	"continue" doesn't go past a return point.
@@ -3513,7 +3433,7 @@ static unlang_t *compile_continue(unlang_t *parent, unlang_compile_t *unlang_ctx
 
 	parent->closed = true;
 
-	return compile_empty(parent, unlang_ctx, NULL, &break_ext);
+	return compile_empty(parent, unlang_ctx, NULL, UNLANG_TYPE_CONTINUE);
 }
 
 
@@ -3521,12 +3441,6 @@ static unlang_t *compile_detach(unlang_t *parent, unlang_compile_t *unlang_ctx,
 {
 	unlang_t *subrequest;
 
-	static unlang_ext_t const detach_ext = {
-		.type = UNLANG_TYPE_DETACH,
-		.len = sizeof(unlang_group_t),
-		.type_name = "unlang_group_t",
-	};
-
 	for (subrequest = parent;
 	     subrequest != NULL;
 	     subrequest = subrequest->parent) {
@@ -3548,17 +3462,11 @@ static unlang_t *compile_detach(unlang_t *parent, unlang_compile_t *unlang_ctx,
 		return NULL;
 	}
 
-	return compile_empty(parent, unlang_ctx, NULL, &detach_ext);
+	return compile_empty(parent, unlang_ctx, NULL, UNLANG_TYPE_DETACH);
 }
 
 static unlang_t *compile_return(unlang_t *parent, unlang_compile_t *unlang_ctx, UNUSED CONF_ITEM const *ci)
 {
-	static unlang_ext_t const return_ext = {
-		.type = UNLANG_TYPE_RETURN,
-		.len = sizeof(unlang_group_t),
-		.type_name = "unlang_group_t",
-	};
-
 	/*
 	 *	These types are all parallel, and therefore can have a "return" in them.
 	 */
@@ -3573,7 +3481,7 @@ static unlang_t *compile_return(unlang_t *parent, unlang_compile_t *unlang_ctx,
 		break;
 	}
 
-	return compile_empty(parent, unlang_ctx, NULL, &return_ext);
+	return compile_empty(parent, unlang_ctx, NULL, UNLANG_TYPE_RETURN);
 }
 
 static unlang_t *compile_tmpl(unlang_t *parent, unlang_compile_t *unlang_ctx, CONF_ITEM *ci)
@@ -3616,8 +3524,7 @@ static const fr_sbuff_term_t if_terminals = FR_SBUFF_TERMS(
 	L("{"),
 );
 
-static unlang_t *compile_if_subsection(unlang_t *parent, unlang_compile_t *unlang_ctx, CONF_SECTION *cs,
-				       unlang_ext_t const *ext)
+static unlang_t *compile_if_subsection(unlang_t *parent, unlang_compile_t *unlang_ctx, CONF_SECTION *cs, unlang_type_t type)
 {
 	unlang_t		*c;
 
@@ -3634,7 +3541,7 @@ static unlang_t *compile_if_subsection(unlang_t *parent, unlang_compile_t *unlan
 	};
 
 	if (!cf_section_name2(cs)) {
-		cf_log_err(cs, "'%s' without condition", unlang_ops[ext->type].name);
+		cf_log_err(cs, "'%s' without condition", unlang_ops[type].name);
 		return NULL;
 	}
 
@@ -3691,7 +3598,7 @@ static unlang_t *compile_if_subsection(unlang_t *parent, unlang_compile_t *unlan
 		 */
 		if (is_truthy && !value) {
 			cf_log_debug_prefix(cs, "Skipping contents of '%s' as it is always 'false'",
-					    unlang_ops[ext->type].name);
+					    unlang_ops[type].name);
 
 			/*
 			 *	Free the children, which frees any xlats,
@@ -3700,10 +3607,10 @@ static unlang_t *compile_if_subsection(unlang_t *parent, unlang_compile_t *unlan
 			 *
 			 *	However, we still need to cache the conditions, as they will be accessed at run-time.
 			 */
-			c = compile_empty(parent, unlang_ctx, cs, ext);
+			c = compile_empty(parent, unlang_ctx, cs, type);
 			cf_section_free_children(cs);
 		} else {
-			c = compile_section(parent, unlang_ctx, cs, ext);
+			c = compile_section(parent, unlang_ctx, cs, type);
 		}
 	}
 
@@ -3741,46 +3648,24 @@ static unlang_t *compile_if_subsection(unlang_t *parent, unlang_compile_t *unlan
 
 static unlang_t *compile_if(unlang_t *parent, unlang_compile_t *unlang_ctx, CONF_ITEM const *ci)
 {
-	static unlang_ext_t const if_ext = {
-		.type = UNLANG_TYPE_IF,
-		.len = sizeof(unlang_cond_t),
-		.type_name = "unlang_cond_t",
-		.pool_headers = 1 + 1 + (TMPL_POOL_DEF_HEADERS * 2),
-		.pool_len = sizeof(map_t) + (TMPL_POOL_DEF_LEN * 2)
-	};
-
-	return compile_if_subsection(parent, unlang_ctx, cf_item_to_section(ci), &if_ext);
+	return compile_if_subsection(parent, unlang_ctx, cf_item_to_section(ci), UNLANG_TYPE_IF);
 }
 
 static unlang_t *compile_elsif(unlang_t *parent, unlang_compile_t *unlang_ctx, CONF_ITEM const *ci)
 {
-	static unlang_ext_t const elsif_ext = {
-		.type = UNLANG_TYPE_ELSIF,
-		.len = sizeof(unlang_cond_t),
-		.type_name = "unlang_cond_t",
-		.pool_headers = 1 + 1 + (TMPL_POOL_DEF_HEADERS * 2),
-		.pool_len = sizeof(map_t) + (TMPL_POOL_DEF_LEN * 2)
-	};
-
-	return compile_if_subsection(parent, unlang_ctx, cf_item_to_section(ci), &elsif_ext);
+	return compile_if_subsection(parent, unlang_ctx, cf_item_to_section(ci), UNLANG_TYPE_ELSIF);
 }
 
 static unlang_t *compile_else(unlang_t *parent, unlang_compile_t *unlang_ctx, CONF_ITEM const *ci)
 {
 	CONF_SECTION *cs = cf_item_to_section(ci);
 
-	static unlang_ext_t const else_ext = {
-		.type = UNLANG_TYPE_ELSE,
-		.len = sizeof(unlang_group_t),
-		.type_name = "unlang_group_t"
-	};
-
 	if (cf_section_name2(cs)) {
 		cf_log_err(cs, "'else' cannot have a condition");
 		return NULL;
 	}
 
-	return compile_section(parent, unlang_ctx, cs, &else_ext);
+	return compile_section(parent, unlang_ctx, cs, UNLANG_TYPE_ELSE);
 }
 
 /*
@@ -3842,19 +3727,13 @@ static unlang_t *compile_redundant(unlang_t *parent, unlang_compile_t *unlang_ct
 	CONF_SECTION			*cs = cf_item_to_section(ci);
 	unlang_t			*c;
 
-	static unlang_ext_t const	redundant_ext = {
-						.type = UNLANG_TYPE_REDUNDANT,
-						.len = sizeof(unlang_group_t),
-						.type_name = "unlang_group_t"
-					};
-
 	if (!cf_item_next(cs, NULL)) return UNLANG_IGNORE;
 
 	if (!validate_limited_subsection(cs, cf_section_name1(cs))) {
 		return NULL;
 	}
 
-	c = compile_section(parent, unlang_ctx, cs, &redundant_ext);
+	c = compile_section(parent, unlang_ctx, cs, UNLANG_TYPE_REDUNDANT);
 	if (!c) return NULL;
 
 	/*
@@ -3865,7 +3744,7 @@ static unlang_t *compile_redundant(unlang_t *parent, unlang_compile_t *unlang_ct
 }
 
 static unlang_t *compile_load_balance_subsection(unlang_t *parent, unlang_compile_t *unlang_ctx, CONF_SECTION *cs,
-						 unlang_ext_t const *ext)
+						 unlang_type_t type)
 {
 	char const			*name2;
 	unlang_t			*c;
@@ -3885,13 +3764,13 @@ static unlang_t *compile_load_balance_subsection(unlang_t *parent, unlang_compil
 	 *	No children?  Die!
 	 */
 	if (!cf_item_next(cs, NULL)) {
-		cf_log_err(cs, "%s sections cannot be empty", unlang_ops[ext->type].name);
+		cf_log_err(cs, "%s sections cannot be empty", unlang_ops[type].name);
 		return NULL;
 	}
 
 	if (!validate_limited_subsection(cs, cf_section_name1(cs))) return NULL;
 
-	c = compile_section(parent, unlang_ctx, cs, ext);
+	c = compile_section(parent, unlang_ctx, cs, type);
 	if (!c) return NULL;
 
 	g = unlang_generic_to_group(c);
@@ -3910,18 +3789,18 @@ static unlang_t *compile_load_balance_subsection(unlang_t *parent, unlang_compil
 	}
 
 	if (name2) {
-		fr_token_t type;
+		fr_token_t quote;
 		ssize_t slen;
 
 		/*
 		 *	Create the template.  All attributes and xlats are
 		 *	defined by now.
 		 */
-		type = cf_section_name2_quote(cs);
+		quote = cf_section_name2_quote(cs);
 		gext = unlang_group_to_load_balance(g);
 		slen = tmpl_afrom_substr(gext, &gext->vpt,
 					 &FR_SBUFF_IN(name2, strlen(name2)),
-					 type,
+					 quote,
 					 NULL,
 					 &t_rules);
 		if (!gext->vpt) {
@@ -3961,25 +3840,13 @@ static unlang_t *compile_load_balance_subsection(unlang_t *parent, unlang_compil
 
 static unlang_t *compile_load_balance(unlang_t *parent, unlang_compile_t *unlang_ctx, CONF_ITEM const *ci)
 {
-	static unlang_ext_t const load_balance_ext = {
-		.type = UNLANG_TYPE_LOAD_BALANCE,
-		.len = sizeof(unlang_load_balance_t),
-		.type_name = "unlang_load_balance_t"
-	};
-
-	return compile_load_balance_subsection(parent, unlang_ctx, cf_item_to_section(ci), &load_balance_ext);
+	return compile_load_balance_subsection(parent, unlang_ctx, cf_item_to_section(ci), UNLANG_TYPE_LOAD_BALANCE);
 }
 
 
 static unlang_t *compile_redundant_load_balance(unlang_t *parent, unlang_compile_t *unlang_ctx, CONF_ITEM const *ci)
 {
-	static unlang_ext_t const redundant_load_balance_ext = {
-		.type = UNLANG_TYPE_REDUNDANT_LOAD_BALANCE,
-		.len = sizeof(unlang_load_balance_t),
-		.type_name = "unlang_load_balance_t"
-	};
-
-	return compile_load_balance_subsection(parent, unlang_ctx, cf_item_to_section(ci), &redundant_load_balance_ext);
+	return compile_load_balance_subsection(parent, unlang_ctx, cf_item_to_section(ci), UNLANG_TYPE_REDUNDANT_LOAD_BALANCE);
 }
 
 static unlang_t *compile_parallel(unlang_t *parent, unlang_compile_t *unlang_ctx, CONF_ITEM const *ci)
@@ -3994,12 +3861,6 @@ static unlang_t *compile_parallel(unlang_t *parent, unlang_compile_t *unlang_ctx
 	bool				clone = true;
 	bool				detach = false;
 
-	static unlang_ext_t const 	parallel_ext = {
-						.type = UNLANG_TYPE_PARALLEL,
-						.len = sizeof(unlang_parallel_t),
-						.type_name = "unlang_parallel_t"
-					};
-
 	if (!cf_item_next(cs, NULL)) return UNLANG_IGNORE;
 
 	/*
@@ -4032,7 +3893,7 @@ static unlang_t *compile_parallel(unlang_t *parent, unlang_compile_t *unlang_ctx
 		return NULL;
 	}
 
-	c = compile_section(parent, unlang_ctx, cs, &parallel_ext);
+	c = compile_section(parent, unlang_ctx, cs, UNLANG_TYPE_PARALLEL);
 	if (!c) return NULL;
 
 	g = unlang_generic_to_group(c);
@@ -4068,14 +3929,6 @@ static unlang_t *compile_subrequest(unlang_t *parent, unlang_compile_t *unlang_c
 
 	tmpl_t				*vpt = NULL, *src_vpt = NULL, *dst_vpt = NULL;
 
-	static unlang_ext_t const 	subrequest_ext = {
-						.type = UNLANG_TYPE_SUBREQUEST,
-						.len = sizeof(unlang_subrequest_t),
-						.type_name = "unlang_subrequest_t",
-						.pool_headers = (TMPL_POOL_DEF_HEADERS * 3),
-						.pool_len = (TMPL_POOL_DEF_LEN * 3)
-					};
-
 	/*
 	 *	subrequest { ... }
 	 *
@@ -4314,7 +4167,7 @@ get_packet_type:
 	/*
 	 *	Compile the subsection with a *different* default dictionary.
 	 */
-	c = compile_section(parent, &unlang_ctx2, cs, &subrequest_ext);
+	c = compile_section(parent, &unlang_ctx2, cs, UNLANG_TYPE_SUBREQUEST);
 	if (!c) return NULL;
 
 	/*
@@ -4359,12 +4212,6 @@ static unlang_t *compile_call(unlang_t *parent, unlang_compile_t *unlang_ctx, CO
 	fr_dict_t const			*dict;
 	fr_dict_attr_t const		*attr_packet_type;
 
-	static unlang_ext_t const 	call_ext = {
-						.type = UNLANG_TYPE_CALL,
-						.len = sizeof(unlang_call_t),
-						.type_name = "unlang_call_t",
-					};
-
 	server = cf_section_name2(cs);
 	if (!server) {
 		cf_log_err(cs, "You MUST specify a server name for 'call <server> { ... }'");
@@ -4410,7 +4257,7 @@ static unlang_t *compile_call(unlang_t *parent, unlang_compile_t *unlang_ctx, CO
 		return NULL;
 	}
 
-	c = compile_section(parent, unlang_ctx, cs, &call_ext);
+	c = compile_section(parent, unlang_ctx, cs, UNLANG_TYPE_CALL);
 	if (!c) return NULL;
 
 	/*
@@ -4442,12 +4289,6 @@ static unlang_t *compile_caller(unlang_t *parent, unlang_compile_t *unlang_ctx,
 
 	fr_dict_autoload_talloc_t	*dict_ref = NULL;
 
-	static unlang_ext_t const 	caller_ext = {
-						.type = UNLANG_TYPE_CALLER,
-						.len = sizeof(unlang_caller_t),
-						.type_name = "unlang_caller_t",
-					};
-
 	name = cf_section_name2(cs);
 	if (!name) {
 		cf_log_err(cs, "You MUST specify a protocol name for 'caller <protocol> { ... }'");
@@ -4488,7 +4329,7 @@ static unlang_t *compile_caller(unlang_t *parent, unlang_compile_t *unlang_ctx,
 	unlang_ctx2.section_name1 = "caller";
 	unlang_ctx2.section_name2 = name;
 
-	c = compile_section(parent, &unlang_ctx2, cs, &caller_ext);
+	c = compile_section(parent, &unlang_ctx2, cs, UNLANG_TYPE_CALLER);
 	if (!c) {
 		talloc_free(dict_ref);
 		return NULL;
@@ -4526,18 +4367,6 @@ static unlang_t *compile_function(unlang_t *parent, unlang_compile_t *unlang_ctx
 	unlang_compile_t		unlang_ctx2;
 	unlang_t			*c;
 
-	static unlang_ext_t const 	policy_ext = {
-						.type = UNLANG_TYPE_POLICY,
-						.len = sizeof(unlang_group_t),
-						.type_name = "unlang_group_t",
-					};
-
-	static unlang_ext_t const 	group_ext = {
-						.type = UNLANG_TYPE_GROUP,
-						.len = sizeof(unlang_group_t),
-						.type_name = "unlang_group_t",
-					};
-
 	/*
 	 *	module.c takes care of ensuring that this is:
 	 *
@@ -4572,7 +4401,7 @@ static unlang_t *compile_function(unlang_t *parent, unlang_compile_t *unlang_ctx
 		 *	group foo { ...
 		 */
 		c = compile_section(parent, &unlang_ctx2, subcs,
-				    policy ? &policy_ext : &group_ext);
+				    policy ? UNLANG_TYPE_POLICY : UNLANG_TYPE_GROUP);
 	}
 	if (!c) return NULL;
 	fr_assert(c != UNLANG_IGNORE);
@@ -5134,11 +4963,6 @@ int unlang_compile(virtual_server_t const *vs,
 	tmpl_rules_t			my_rules;
 	char const			*name1, *name2;
 	CONF_DATA const			*cd;
-	static unlang_ext_t const 	group_ext = {
-						.type = UNLANG_TYPE_GROUP,
-						.len = sizeof(unlang_group_t),
-						.type_name = "unlang_group_t",
-	};
 
 	/*
 	 *	Don't compile it twice, and don't print out debug
@@ -5173,7 +4997,7 @@ int unlang_compile(virtual_server_t const *vs,
 				.actions = *actions,
 				.rules = rules
 			    },
-			    cs, &group_ext);
+			    cs, UNLANG_TYPE_GROUP);
 	if (!c) return -1;
 
 	if (DEBUG_ENABLED4) unlang_dump(c, 2);
diff --git a/src/lib/unlang/condition.c b/src/lib/unlang/condition.c
index e80621626e..135cdd8506 100644
--- a/src/lib/unlang/condition.c
+++ b/src/lib/unlang/condition.c
@@ -117,8 +117,16 @@ void unlang_condition_init(void)
 	unlang_register(UNLANG_TYPE_IF,
 			   &(unlang_op_t){
 				.name = "if",
-				.interpret = unlang_if,
+				.type = UNLANG_TYPE_IF,
 				.flag = UNLANG_OP_FLAG_DEBUG_BRACES,
+
+				.interpret = unlang_if,
+
+				.unlang_size = sizeof(unlang_cond_t),
+				.unlang_name = "unlang_cond_t",
+				.pool_headers = 1 + 1 + (TMPL_POOL_DEF_HEADERS * 2),
+				.pool_len = sizeof(map_t) + (TMPL_POOL_DEF_LEN * 2),
+
 				.frame_state_size = sizeof(unlang_frame_state_cond_t),
 				.frame_state_type = "unlang_frame_state_cond_t",
 			   });
@@ -126,15 +134,28 @@ void unlang_condition_init(void)
 	unlang_register(UNLANG_TYPE_ELSE,
 			   &(unlang_op_t){
 				.name = "else",
+				.type = UNLANG_TYPE_ELSE,
 				.flag = UNLANG_OP_FLAG_DEBUG_BRACES,
-				.interpret = unlang_group
-			   });
+
+				.interpret = unlang_group,
+
+				.unlang_size = sizeof(unlang_group_t),
+				.unlang_name = "unlang_group_t"	
+		   });
 
 	unlang_register(UNLANG_TYPE_ELSIF,
 			   &(unlang_op_t){
 				.name = "elseif",
-				.interpret = unlang_if,
+				.type = UNLANG_TYPE_ELSIF,
 				.flag = UNLANG_OP_FLAG_DEBUG_BRACES,
+
+				.interpret = unlang_if,
+
+				.unlang_size = sizeof(unlang_cond_t),
+				.unlang_name = "unlang_cond_t",
+				.pool_headers = 1 + 1 + (TMPL_POOL_DEF_HEADERS * 2),
+				.pool_len = sizeof(map_t) + (TMPL_POOL_DEF_LEN * 2),
+
 				.frame_state_size = sizeof(unlang_frame_state_cond_t),
 				.frame_state_type = "unlang_frame_state_cond_t",
 			   });
diff --git a/src/lib/unlang/detach.c b/src/lib/unlang/detach.c
index 52f2de2c51..6431e5677e 100644
--- a/src/lib/unlang/detach.c
+++ b/src/lib/unlang/detach.c
@@ -56,6 +56,11 @@ void unlang_detach_init(void)
 	unlang_register(UNLANG_TYPE_DETACH,
 			&(unlang_op_t){
 				.name = "detach",
+				.type = UNLANG_TYPE_DETACH,
+
 				.interpret = unlang_detach,
-			});
+
+				.unlang_size = sizeof(unlang_group_t),
+				.unlang_name = "unlang_group_t",	
+		});
 }
diff --git a/src/lib/unlang/foreach.c b/src/lib/unlang/foreach.c
index 5872b407ed..d8e086089e 100644
--- a/src/lib/unlang/foreach.c
+++ b/src/lib/unlang/foreach.c
@@ -552,19 +552,37 @@ void unlang_foreach_init(void)
 	unlang_register(UNLANG_TYPE_FOREACH,
 			   &(unlang_op_t){
 				.name = "foreach",
+				.type = UNLANG_TYPE_FOREACH,
+				.flag = UNLANG_OP_FLAG_DEBUG_BRACES | UNLANG_OP_FLAG_BREAK_POINT | UNLANG_OP_FLAG_CONTINUE_POINT,
+
 				.interpret = unlang_foreach,
-				.flag = UNLANG_OP_FLAG_DEBUG_BRACES | UNLANG_OP_FLAG_BREAK_POINT | UNLANG_OP_FLAG_CONTINUE_POINT
+
+				.unlang_size = sizeof(unlang_foreach_t),
+				.unlang_name = "unlang_foreach_t",
+
+				.pool_headers = TMPL_POOL_DEF_HEADERS,
+				.pool_len = TMPL_POOL_DEF_LEN
 			   });
 
 	unlang_register(UNLANG_TYPE_BREAK,
 			   &(unlang_op_t){
 				.name = "break",
+				.type = UNLANG_TYPE_BREAK,
+
 				.interpret = unlang_break,
+
+				.unlang_size = sizeof(unlang_group_t),
+				.unlang_name = "unlang_group_t",
 			   });
 
 	unlang_register(UNLANG_TYPE_CONTINUE,
 			   &(unlang_op_t){
 				.name = "continue",
+				.type = UNLANG_TYPE_CONTINUE,
+
 				.interpret = unlang_continue,
+
+				.unlang_size = sizeof(unlang_group_t),
+				.unlang_name = "unlang_group_t",
 			   });
 }
diff --git a/src/lib/unlang/group.c b/src/lib/unlang/group.c
index 916028f339..b44b9e90ba 100644
--- a/src/lib/unlang/group.c
+++ b/src/lib/unlang/group.c
@@ -44,21 +44,36 @@ void unlang_group_init(void)
 	unlang_register(UNLANG_TYPE_GROUP,
 			   &(unlang_op_t){
 				.name = "group",
+				.type = UNLANG_TYPE_GROUP,
+				.flag = UNLANG_OP_FLAG_DEBUG_BRACES,
+
 				.interpret = unlang_group,
-				.flag = UNLANG_OP_FLAG_DEBUG_BRACES
+
+				.unlang_size = sizeof(unlang_group_t),
+				.unlang_name = "unlang_group_t",
 			   });
 
 	unlang_register(UNLANG_TYPE_REDUNDANT,
 			   &(unlang_op_t){
 				.name = "redundant",
+				.type = UNLANG_TYPE_REDUNDANT,
+				.flag = UNLANG_OP_FLAG_DEBUG_BRACES,
+
 				.interpret = unlang_group,
-				.flag = UNLANG_OP_FLAG_DEBUG_BRACES
+
+				.unlang_size = sizeof(unlang_group_t),
+				.unlang_name = "unlang_group_t",
 			   });
 
 	unlang_register(UNLANG_TYPE_POLICY,
 			   &(unlang_op_t){
 				.name = "policy",
+				.type = UNLANG_TYPE_POLICY,
+				.flag = UNLANG_OP_FLAG_DEBUG_BRACES | UNLANG_OP_FLAG_RETURN_POINT,
+
 				.interpret = unlang_policy,
-				.flag = UNLANG_OP_FLAG_DEBUG_BRACES | UNLANG_OP_FLAG_RETURN_POINT
-			   });
+
+				.unlang_size = sizeof(unlang_group_t),
+				.unlang_name = "unlang_group_t",	
+		   });
 }
diff --git a/src/lib/unlang/limit.c b/src/lib/unlang/limit.c
index b0a45de71c..b59ad654c0 100644
--- a/src/lib/unlang/limit.c
+++ b/src/lib/unlang/limit.c
@@ -127,9 +127,15 @@ void unlang_limit_init(void)
 	unlang_register(UNLANG_TYPE_LIMIT,
 			   &(unlang_op_t){
 				.name = "limit",
+				.type = UNLANG_TYPE_LIMIT,
+				.flag = UNLANG_OP_FLAG_DEBUG_BRACES,
+
 				.interpret = unlang_limit,
 				.signal = unlang_limit_signal,
-				.flag = UNLANG_OP_FLAG_DEBUG_BRACES,
+
+				.unlang_size = sizeof(unlang_limit_t),
+				.unlang_name = "unlang_limit_t",
+
 				.frame_state_size = sizeof(unlang_frame_state_limit_t),
 				.frame_state_type = "unlang_frame_state_limit_t",
 
diff --git a/src/lib/unlang/load_balance.c b/src/lib/unlang/load_balance.c
index a5691c3def..90b841dc3a 100644
--- a/src/lib/unlang/load_balance.c
+++ b/src/lib/unlang/load_balance.c
@@ -247,8 +247,14 @@ void unlang_load_balance_init(void)
 	unlang_register(UNLANG_TYPE_LOAD_BALANCE,
 			   &(unlang_op_t){
 				.name = "load-balance group",
-				.interpret = unlang_load_balance,
+				.type = UNLANG_TYPE_LOAD_BALANCE,
 				.flag = UNLANG_OP_FLAG_DEBUG_BRACES | UNLANG_OP_FLAG_RCODE_SET,
+
+				.interpret = unlang_load_balance,
+
+				.unlang_size = sizeof(unlang_load_balance_t),
+				.unlang_name = "unlang_load_balance_t",
+
 			        .frame_state_size = sizeof(unlang_frame_state_redundant_t),
 				.frame_state_type = "unlang_frame_state_redundant_t",
 			   });
@@ -256,8 +262,14 @@ void unlang_load_balance_init(void)
 	unlang_register(UNLANG_TYPE_REDUNDANT_LOAD_BALANCE,
 			   &(unlang_op_t){
 				.name = "redundant-load-balance group",
-				.interpret = unlang_redundant_load_balance,
+				.type = UNLANG_TYPE_REDUNDANT_LOAD_BALANCE,	
 				.flag = UNLANG_OP_FLAG_DEBUG_BRACES | UNLANG_OP_FLAG_RCODE_SET,
+
+				.interpret = unlang_redundant_load_balance,
+
+				.unlang_size = sizeof(unlang_load_balance_t),
+				.unlang_name = "unlang_load_balance_t",
+
 			        .frame_state_size = sizeof(unlang_frame_state_redundant_t),
 				.frame_state_type = "unlang_frame_state_redundant_t",
 			   });
diff --git a/src/lib/unlang/map.c b/src/lib/unlang/map.c
index 8ccab42c2b..f5c91eabf6 100644
--- a/src/lib/unlang/map.c
+++ b/src/lib/unlang/map.c
@@ -449,15 +449,26 @@ void unlang_map_init(void)
 	unlang_register(UNLANG_TYPE_UPDATE,
 			   &(unlang_op_t){
 				.name = "update",
+				.type = UNLANG_TYPE_UPDATE,
+				.flag = UNLANG_OP_FLAG_DEBUG_BRACES,
+
 				.interpret = unlang_update_state_init,
-				.flag = UNLANG_OP_FLAG_DEBUG_BRACES
+
+				.unlang_size = sizeof(unlang_map_t),
+				.unlang_name = "unlang_map_t",
 			   });
 
 	unlang_register(UNLANG_TYPE_MAP,
 			   &(unlang_op_t){
 				.name = "map",
+				.type = UNLANG_TYPE_MAP,
 				.flag = UNLANG_OP_FLAG_RCODE_SET,
+
 				.interpret = unlang_map_state_init,
+
+				.unlang_size = sizeof(unlang_map_t),
+				.unlang_name = "unlang_map_t",
+
 				.frame_state_size = sizeof(unlang_frame_state_map_proc_t),
 				.frame_state_type = "unlang_frame_state_map_proc_t",
 			   });
diff --git a/src/lib/unlang/parallel.c b/src/lib/unlang/parallel.c
index cb0816cdfd..35f1032aa7 100644
--- a/src/lib/unlang/parallel.c
+++ b/src/lib/unlang/parallel.c
@@ -382,8 +382,13 @@ void unlang_parallel_init(void)
 	unlang_register(UNLANG_TYPE_PARALLEL,
 			   &(unlang_op_t){
 				.name = "parallel",
+				.type = UNLANG_TYPE_PARALLEL,	
+				.flag = UNLANG_OP_FLAG_DEBUG_BRACES | UNLANG_OP_FLAG_RCODE_SET | UNLANG_OP_FLAG_NO_FORCE_UNWIND,
+
 				.interpret = unlang_parallel,
 				.signal = unlang_parallel_signal,
-				.flag = UNLANG_OP_FLAG_DEBUG_BRACES | UNLANG_OP_FLAG_RCODE_SET | UNLANG_OP_FLAG_NO_FORCE_UNWIND
+
+				.unlang_size = sizeof(unlang_parallel_t),
+				.unlang_name = "unlang_parallel_t"
 			   });
 }
diff --git a/src/lib/unlang/return.c b/src/lib/unlang/return.c
index ae05160c08..b43a420e14 100644
--- a/src/lib/unlang/return.c
+++ b/src/lib/unlang/return.c
@@ -51,6 +51,11 @@ void unlang_return_init(void)
 	unlang_register(UNLANG_TYPE_RETURN,
 			   &(unlang_op_t){
 				.name = "return",
+				.type = UNLANG_TYPE_RETURN,
+
 				.interpret = unlang_return,
+
+				.unlang_size = sizeof(unlang_group_t),
+				.unlang_name = "unlang_group_t",
 			   });
 }
diff --git a/src/lib/unlang/subrequest.c b/src/lib/unlang/subrequest.c
index 7694019905..652a59fe9b 100644
--- a/src/lib/unlang/subrequest.c
+++ b/src/lib/unlang/subrequest.c
@@ -523,8 +523,8 @@ int unlang_subrequest_op_init(void)
 	unlang_register(UNLANG_TYPE_SUBREQUEST,
 			&(unlang_op_t){
 				.name = "subrequest",
-				.interpret = unlang_subrequest_init,
-				.signal = unlang_subrequest_signal,
+				.type = UNLANG_TYPE_SUBREQUEST,
+
 				/*
 				 *	Frame can't be cancelled, because children need to
 				 *	write out status to the parent.  If we don't do this,
@@ -537,6 +537,16 @@ int unlang_subrequest_op_init(void)
 				 *	guaranteed the parent still exists.
 				 */
 				.flag = UNLANG_OP_FLAG_DEBUG_BRACES | UNLANG_OP_FLAG_RCODE_SET | UNLANG_OP_FLAG_NO_FORCE_UNWIND,
+
+				.interpret = unlang_subrequest_init,
+				.signal = unlang_subrequest_signal,
+
+
+				.unlang_size = sizeof(unlang_subrequest_t),
+				.unlang_name = "unlang_subrequest_t",
+				.pool_headers = (TMPL_POOL_DEF_HEADERS * 3),
+				.pool_len = (TMPL_POOL_DEF_LEN * 3),
+
 				.frame_state_size = sizeof(unlang_child_request_t),
 				.frame_state_type = "unlang_child_request_t",
 			});
diff --git a/src/lib/unlang/switch.c b/src/lib/unlang/switch.c
index 68430d1154..5c68bfbbb3 100644
--- a/src/lib/unlang/switch.c
+++ b/src/lib/unlang/switch.c
@@ -133,14 +133,29 @@ void unlang_switch_init(void)
 	unlang_register(UNLANG_TYPE_SWITCH,
 			   &(unlang_op_t){
 				.name = "switch",
+				.type = UNLANG_TYPE_SWITCH,
+				.flag = UNLANG_OP_FLAG_DEBUG_BRACES,
+
 				.interpret = unlang_switch,
-				.flag = UNLANG_OP_FLAG_DEBUG_BRACES
+					
+
+				.unlang_size = sizeof(unlang_switch_t),
+				.unlang_name = "unlang_switch_t",
+
+				.pool_headers = TMPL_POOL_DEF_HEADERS,
+				.pool_len = TMPL_POOL_DEF_LEN
 			   });
 
+
 	unlang_register(UNLANG_TYPE_CASE,
 			   &(unlang_op_t){
 				.name = "case",
+				.type = UNLANG_TYPE_CASE,
+				.flag = UNLANG_OP_FLAG_DEBUG_BRACES | UNLANG_OP_FLAG_BREAK_POINT,
+
 				.interpret = unlang_case,
-				.flag = UNLANG_OP_FLAG_DEBUG_BRACES | UNLANG_OP_FLAG_BREAK_POINT
+
+				.unlang_size = sizeof(unlang_case_t),
+				.unlang_name = "unlang_case_t",
 			   });
 }
diff --git a/src/lib/unlang/timeout.c b/src/lib/unlang/timeout.c
index 6c17a96157..73c90d260f 100644
--- a/src/lib/unlang/timeout.c
+++ b/src/lib/unlang/timeout.c
@@ -270,9 +270,15 @@ void unlang_timeout_init(void)
 	unlang_register(UNLANG_TYPE_TIMEOUT,
 			&(unlang_op_t){
 				.name = "timeout",
-				.interpret = unlang_timeout,
+				.type = UNLANG_TYPE_TIMEOUT,
 				.flag = UNLANG_OP_FLAG_DEBUG_BRACES | UNLANG_OP_FLAG_RCODE_SET,
+
+				.interpret = unlang_timeout,
 				.signal = unlang_timeout_signal,
+
+				.unlang_size = sizeof(unlang_timeout_t),
+				.unlang_name = "unlang_timeout_t",
+
 				.frame_state_size = sizeof(unlang_frame_state_timeout_t),
 				.frame_state_type = "unlang_frame_state_timeout_t",
 			});
diff --git a/src/lib/unlang/transaction.c b/src/lib/unlang/transaction.c
index dc081b90d0..746d91503c 100644
--- a/src/lib/unlang/transaction.c
+++ b/src/lib/unlang/transaction.c
@@ -139,10 +139,16 @@ void unlang_transaction_init(void)
 	unlang_register(UNLANG_TYPE_TRANSACTION,
 			   &(unlang_op_t){
 				.name = "transaction",
+				.type = UNLANG_TYPE_TRANSACTION,
+				.flag = UNLANG_OP_FLAG_DEBUG_BRACES,
+
 				.interpret = unlang_transaction,
 				.signal = unlang_transaction_signal,
+
+				.unlang_size = sizeof(unlang_transaction_t),
+				.unlang_name = "unlang_transaction_t",
+
 				.frame_state_size = sizeof(unlang_frame_state_transaction_t),
 				.frame_state_type = "unlang_frame_state_transaction_t",
-				.flag = UNLANG_OP_FLAG_DEBUG_BRACES
 			   });
 }
diff --git a/src/lib/unlang/try.c b/src/lib/unlang/try.c
index 9317672fec..b76b97494b 100644
--- a/src/lib/unlang/try.c
+++ b/src/lib/unlang/try.c
@@ -25,6 +25,7 @@
 RCSID("$Id$")
 
 #include "unlang_priv.h"
+#include "try_priv.h"
 #include "catch_priv.h"
 
 static unlang_action_t unlang_try(UNUSED unlang_result_t *p_result, request_t *request, unlang_stack_frame_t *frame)
@@ -44,7 +45,12 @@ void unlang_try_init(void)
 	unlang_register(UNLANG_TYPE_TRY,
 			   &(unlang_op_t){
 				.name = "try",
+				.type = UNLANG_TYPE_TRY,
+				.flag = UNLANG_OP_FLAG_DEBUG_BRACES,
+
 				.interpret = unlang_try,
-				.flag = UNLANG_OP_FLAG_DEBUG_BRACES
+
+				.unlang_size = sizeof(unlang_try_t),
+				.unlang_name = "unlang_try_t",
 			   });
 }
diff --git a/src/lib/unlang/unlang_priv.h b/src/lib/unlang/unlang_priv.h
index 1eaf62b040..92aa232af9 100644
--- a/src/lib/unlang/unlang_priv.h
+++ b/src/lib/unlang/unlang_priv.h
@@ -139,17 +139,6 @@ struct unlang_s {
 	unlang_mod_actions_t	actions;	//!< Priorities, etc. for the various return codes.
 };
 
-/** Describes how to allocate an #unlang_group_t with additional memory keyword specific data
- *
- */
-typedef struct {
-	unlang_type_t		type;		//!< Keyword.
-	size_t			len;		//!< Total length of the unlang_group_t + specialisation struct.
-	unsigned		pool_headers;	//!< How much additional space to allocate for chunk headers.
-	size_t			pool_len;	//!< How much additional space to allocate for extensions.
-	char const		*type_name;	//!< Talloc type name.
-} unlang_ext_t;
-
 typedef struct {
 	fr_dict_t		*dict;		//!< our dictionary
 	fr_dict_attr_t const	*root;		//!< the root of our dictionary
@@ -237,7 +226,8 @@ DIAG_ON(attributes)
  * will return an #unlang_action_t, which determines what the interpreter does next.
  */
 typedef struct {
-	char const		*name;				//!< Name of the operation.
+	char const		*name;				//!< Name of the keyword
+	unlang_type_t		type;				//!< enum value for the keyword
 
 	unlang_process_t	interpret;     			//!< Function to interpret the keyword
 
@@ -245,6 +235,13 @@ typedef struct {
 
 	unlang_dump_t		dump;				//!< Dump additional information about the frame state.
 
+	size_t			unlang_size;			//!< Total length of the unlang_t + specialisation struct.
+	char const		*unlang_name;			//!< Talloc type name for the unlang_t
+
+	unsigned		pool_headers;			//!< How much additional space to allocate for chunk headers.
+	size_t			pool_len;			//!< How much additional space to allocate for chunks
+
+
 	unlang_thread_instantiate_t thread_instantiate;		//!< per-thread instantiation function
 	size_t			thread_inst_size;
 	char const		*thread_inst_type;