finally found the right solution to variable initialization, added array initializers

src/snc/gen_code.c

@@ -158,7 +158,13 @@ static void gen_user_var(Program *p)
 			gen_line_marker(vp->decl);
 			if (!opt_reent) printf("static");
 			indent(1);
-			gen_var_decl(vp); printf(";\n");
+			gen_var_decl(vp);
+			if (!opt_reent)
+			{
+				printf(" = ");
+				gen_var_init(vp, 0);
+			}
+			printf(";\n");
 		}
 	}
 	foreach (ssp, p->prog->prog_statesets)
@@ -200,10 +206,17 @@ static void gen_user_var(Program *p)
 					printf("} %s_%s;\n", VAR_PREFIX, sp->value);
 				}
 			}
-			indent(level); printf("} %s_%s;\n", VAR_PREFIX, ssp->value);
+			indent(level); printf("} %s_%s", VAR_PREFIX, ssp->value);
+			if (!opt_reent)
+			{
+				printf(" = ");
+				gen_ss_user_var_init(ssp, level);
+			}
+			printf(";\n");
 		}
 	}
 	if (opt_reent) printf("};\n");
+	printf("\n");
 }
 
 /* Generate C code in definition section */

src/snc/gen_ss_code.c

@@ -136,7 +136,7 @@ static void gen_prog_func(
 	const char *name,
 	Expr *xp,
 	void (*gen_body)(Expr *xp));
-static void gen_prog_init_func(Expr *prog);
+static void gen_prog_init_func(Expr *prog, int opt_reent);
 
 /*
  * Expression context. Certain nodes of the syntax tree are
@@ -216,7 +216,7 @@ void gen_ss_code(Program *program)
 	Expr	*sp;
 
 	/* Generate program init func */
-	gen_prog_init_func(prog);
+	gen_prog_init_func(prog, program->options.reent);
 
 	/* Generate program entry func */
 	if (prog->prog_entry)
@@ -291,6 +291,40 @@ static void gen_local_var_decls(Expr *scope, int level)
 	}
 }
 
+static void gen_type_default(Type *type)
+{
+	uint n;
+
+	assert(type);
+	switch(type->tag)
+	{
+	case V_STRING:
+		printf("\"\"");
+		break;
+	case V_ARRAY:
+		printf("{");
+		for (n=0; n<type->val.array.num_elems; n++)
+		{
+			gen_type_default(type->val.array.elem_type);
+			if (n+1<type->val.array.num_elems) printf(",");
+		}
+		printf("}");
+		break;
+	default:
+		printf("0");
+	}
+}
+
+void gen_var_init(Var *vp, int level)
+{
+	assert(vp);
+
+	if (vp->init)
+		gen_expr(C_INIT, vp->init, level);
+	else
+		gen_type_default(vp->type);
+}
+
 static void gen_state_func(
 	const char *ss_name,
 	const char *state_name,
@@ -615,6 +649,16 @@ static void gen_expr(
 		}
 		printf(")");
 		break;
+	case E_INIT:
+		printf("{");
+		foreach (cep, ep->init_elems)
+		{
+			gen_expr(context, cep, 0);
+			if (cep->next)
+				printf(", ");
+		}
+		printf("}");
+		break;
 	case E_TERNOP:
 		gen_expr(context, ep->ternop_cond, 0);
 		printf(" ? ");
@@ -945,51 +989,92 @@ static void gen_pv_func(
 #endif
 }
 
-/* Generate initialisation code for one element of the UserVar struct. */
-static int iter_user_var_init(Expr *dp, Expr *scope, void *parg)
+/* Generate initializer for the UserVar structs. */
+void gen_ss_user_var_init(Expr *ssp, int level)
 {
-	assert(dp);
-	assert(dp->type == D_DECL);
-
-	Var *vp = dp->extra.e_decl;
+	Var *vp;
+	Expr *sp;
 
-	assert(vp);
-	if (vp->init && vp->decl)
+	assert(ssp->type == D_SS);
+	printf("{\n");
+	foreach(vp, ssp->extra.e_ss->var_list->first)
 	{
-		if (vp->type->tag < V_CHAR)
-		{
-			error_at_expr(vp->decl,
-			  "initialisation not allowed for variables of this type");
-		}
-		else
+		indent(level+1); gen_var_init(vp, level+1); printf(",\n");
+	}
+	foreach (sp, ssp->ss_states)
+	{
+		int s_empty;
+
+		assert(sp->type == D_STATE);
+		s_empty = !sp->extra.e_state->var_list->first;
+		if (!s_empty)
 		{
-			gen_line_marker(dp);
-			indent(1);
-			gen_var_access(vp);
-			printf(" = ");
-			gen_expr(C_INIT, vp->init, 0);
-			printf(";\n");
+			indent(level+1); printf("{\n");
+			foreach (vp, sp->extra.e_state->var_list->first)
+			{
+					indent(level+2); gen_var_init(vp, level+2);
+					printf("%s\n", vp->next ? "," : "");
+			}
+			indent(level+1);
+			printf("}%s\n", sp->next ? "," : "");
 		}
 	}
-	return FALSE;		/* do not descend into children */
+	indent(level); printf("}");
 }
 
-/* Generate initialisation for variables with global lifetime. */
-static void gen_user_var_init(Expr *ep, int stop_mask)
+/* Generate initializer for the UserVar structs. */
+static void gen_user_var_init(Expr *prog, int level)
 {
-	const int type_mask = (1<<D_DECL);
-	traverse_expr_tree(ep, type_mask, stop_mask, 0, iter_user_var_init, 0);
+	Var *vp;
+	Expr *ssp;
+
+	assert(prog->type == D_PROG);
+	printf("{\n");
+	/* global variables */
+	foreach(vp, prog->extra.e_prog->first)
+	{
+		if (vp->type->tag >= V_CHAR)
+		{
+			indent(level+1); gen_var_init(vp, level+1); printf(",\n");
+		}
+	}
+
+	foreach (ssp, prog->prog_statesets)
+	{
+		Expr *sp;
+		int ss_empty = !ssp->extra.e_ss->var_list->first;
+		if (ss_empty)
+		{
+			foreach (sp, ssp->ss_states)
+			{
+				if (sp->extra.e_state->var_list->first)
+				{
+					ss_empty = 0;
+					break;
+				}
+			}
+		}
+		if (!ss_empty)
+		{
+			indent(level+1);
+			gen_ss_user_var_init(ssp, level+1);
+			printf("%s\n", ssp->next ? "," : "");
+		}
+	}
+	indent(level); printf("}");
 }
 
-static void gen_prog_init_func(Expr *prog)
+static void gen_prog_init_func(Expr *prog, int opt_reent)
 {
-	const int global_stop_mask = ~((1<<D_DECL)|(1<<D_PROG));
-
 	assert(prog->type == D_PROG);
 	printf("\n/* Program init func */\n");
 	printf("static void global_prog_init(struct %s *pVar)\n{\n", VAR_PREFIX);
-	/* initialize global variables */
-	gen_user_var_init(prog, global_stop_mask);
+	if (opt_reent)
+	{
+		indent(1); printf("*pVar = (struct %s)", VAR_PREFIX);
+		gen_user_var_init(prog, 1);
+		printf(";\n");
+	}
 	printf("}\n");
 }
 

src/snc/gen_ss_code.h

@@ -16,5 +16,7 @@
 
 void init_gen_ss_code(Program *program);
 void gen_ss_code(Program *program);
+void gen_ss_user_var_init(Expr *ssp, int level);
+void gen_var_init(Var *vp, int level);
 
 #endif	/*INCLgensscodeh*/

src/snc/snl.lem

@@ -164,7 +164,7 @@ init_declarators(p) ::= init_declarators(xs) COMMA init_declarator(x).
 						{ p = link_expr(xs, x); }
 
 init_declarator(p) ::= declarator(x).		{ p = decl_add_init(x, 0); }
-init_declarator(p) ::= declarator(x) EQUAL expr(i).
+init_declarator(p) ::= declarator(x) EQUAL init_expr(i).
 						{ p = decl_add_init(x, i); }
 
 declarator(p) ::= ASTERISK declarator(x).	{ p = decl_prefix_pointer(x); }
@@ -176,6 +176,14 @@ direct_declarator(p) ::= LPAREN declarator(x) RPAREN.
 direct_declarator(p) ::= direct_declarator(x) subscript(s).
 						{ p = decl_postfix_array(x, s.str); }
 
+// Initializer
+init_expr(p) ::= LBRACE(t) init_exprs(x) RBRACE.{ p = expr(E_INIT, t, x); }
+init_expr(p) ::= expr(x).			{ p = x; }
+
+init_exprs(p) ::= init_exprs(xs) COMMA init_expr(x).	{ p = link_expr(xs, x); }
+init_exprs(p) ::= init_expr(x).				{ p = x; }
+init_exprs(p) ::= .					{ p = 0; }
+
 %type type {int}
 type(p) ::= CHAR.				{ p = V_CHAR;	}
 type(p) ::= SHORT.				{ p = V_SHORT;	}