diff --git a/src/mesa/shader/slang/slang_compile_function.c b/src/mesa/shader/slang/slang_compile_function.c
index eb8fd1bd40f..b0e2b62d423 100644
--- a/src/mesa/shader/slang/slang_compile_function.c
+++ b/src/mesa/shader/slang/slang_compile_function.c
@@ -33,50 +33,55 @@
 
 /* slang_fixup_table */
 
-void slang_fixup_table_init (slang_fixup_table *fix)
+void
+slang_fixup_table_init(slang_fixup_table * fix)
 {
-	fix->table = NULL;
-	fix->count = 0;
+   fix->table = NULL;
+   fix->count = 0;
 }
 
-void slang_fixup_table_free (slang_fixup_table *fix)
+void
+slang_fixup_table_free(slang_fixup_table * fix)
 {
-	slang_alloc_free (fix->table);
-	slang_fixup_table_init (fix);
+   slang_alloc_free(fix->table);
+   slang_fixup_table_init(fix);
 }
 
 /* slang_function */
 
-int slang_function_construct (slang_function *func)
+int
+slang_function_construct(slang_function * func)
 {
-	func->kind = slang_func_ordinary;
-	if (!slang_variable_construct (&func->header))
-		return 0;
-	func->parameters = (slang_variable_scope *) slang_alloc_malloc (sizeof (slang_variable_scope));
-	if (func->parameters == NULL)
-	{
-		slang_variable_destruct (&func->header);
-		return 0;
-	}
-   _slang_variable_scope_ctr (func->parameters);
-	func->param_count = 0;
-	func->body = NULL;
-	func->address = ~0;
-	slang_fixup_table_init (&func->fixups);
-	return 1;
+   func->kind = slang_func_ordinary;
+   if (!slang_variable_construct(&func->header))
+      return 0;
+
+   func->parameters = (slang_variable_scope *)
+      slang_alloc_malloc(sizeof(slang_variable_scope));
+   if (func->parameters == NULL) {
+      slang_variable_destruct(&func->header);
+      return 0;
+   }
+
+   _slang_variable_scope_ctr(func->parameters);
+   func->param_count = 0;
+   func->body = NULL;
+   func->address = ~0;
+   slang_fixup_table_init(&func->fixups);
+   return 1;
 }
 
-void slang_function_destruct (slang_function *func)
+void
+slang_function_destruct(slang_function * func)
 {
-	slang_variable_destruct (&func->header);
-	slang_variable_scope_destruct (func->parameters);
-	slang_alloc_free (func->parameters);
-	if (func->body != NULL)
-	{
-		slang_operation_destruct (func->body);
-		slang_alloc_free (func->body);
-	}
-	slang_fixup_table_free (&func->fixups);
+   slang_variable_destruct(&func->header);
+   slang_variable_scope_destruct(func->parameters);
+   slang_alloc_free(func->parameters);
+   if (func->body != NULL) {
+      slang_operation_destruct(func->body);
+      slang_alloc_free(func->body);
+   }
+   slang_fixup_table_free(&func->fixups);
 }
 
 /*
@@ -84,60 +89,82 @@ void slang_function_destruct (slang_function *func)
  */
 
 GLvoid
-_slang_function_scope_ctr (slang_function_scope *self)
+_slang_function_scope_ctr(slang_function_scope * self)
 {
    self->functions = NULL;
    self->num_functions = 0;
    self->outer_scope = NULL;
 }
 
-void slang_function_scope_destruct (slang_function_scope *scope)
+void
+slang_function_scope_destruct(slang_function_scope * scope)
 {
-	unsigned int i;
+   unsigned int i;
 
-	for (i = 0; i < scope->num_functions; i++)
-		slang_function_destruct (scope->functions + i);
-	slang_alloc_free (scope->functions);
+   for (i = 0; i < scope->num_functions; i++)
+      slang_function_destruct(scope->functions + i);
+   slang_alloc_free(scope->functions);
 }
 
-int slang_function_scope_find_by_name (slang_function_scope *funcs, slang_atom a_name, int all_scopes)
-{
-	unsigned int i;
 
-	for (i = 0; i < funcs->num_functions; i++)
-		if (a_name == funcs->functions[i].header.a_name)
-			return 1;
-	if (all_scopes && funcs->outer_scope != NULL)
-		return slang_function_scope_find_by_name (funcs->outer_scope, a_name, 1);
-	return 0;
+/**
+ * Search a list of functions for a particular function by name.
+ * \param funcs  the list of functions to search
+ * \param a_name  the name to search for
+ * \param all_scopes  if non-zero, search containing scopes too.
+ * \return pointer to found function, or NULL.
+ */
+int
+slang_function_scope_find_by_name(slang_function_scope * funcs,
+                                  slang_atom a_name, int all_scopes)
+{
+   unsigned int i;
+
+   for (i = 0; i < funcs->num_functions; i++)
+      if (a_name == funcs->functions[i].header.a_name)
+         return 1;
+   if (all_scopes && funcs->outer_scope != NULL)
+      return slang_function_scope_find_by_name(funcs->outer_scope, a_name, 1);
+   return 0;
 }
 
-slang_function *slang_function_scope_find (slang_function_scope *funcs, slang_function *fun,
-	int all_scopes)
+
+/**
+ * Search a list of functions for a particular function (for implementing
+ * function calls.  Matching is done by first comparing the function's name,
+ * then the function's parameter list.
+ *
+ * \param funcs  the list of functions to search
+ * \param fun  the function to search for
+ * \param all_scopes  if non-zero, search containing scopes too.
+ * \return pointer to found function, or NULL.
+ */
+slang_function *
+slang_function_scope_find(slang_function_scope * funcs, slang_function * fun,
+                          int all_scopes)
 {
-	unsigned int i;
+   unsigned int i;
 
-	for (i = 0; i < funcs->num_functions; i++)
-	{
-		slang_function *f = &funcs->functions[i];
-		unsigned int j;
+   for (i = 0; i < funcs->num_functions; i++) {
+      slang_function *f = &funcs->functions[i];
+      unsigned int j;
 
-		if (fun->header.a_name != f->header.a_name)
-			continue;
-		if (fun->param_count != f->param_count)
-			continue;
-		for (j = 0; j < fun->param_count; j++)
-		{
-			if (!slang_type_specifier_equal (&fun->parameters->variables[j].type.specifier,
-					&f->parameters->variables[j].type.specifier))
-				break;
-		}
-		if (j == fun->param_count)
-			return f;
-	}
-	if (all_scopes && funcs->outer_scope != NULL)
-		return slang_function_scope_find (funcs->outer_scope, fun, 1);
-	return NULL;
+      if (fun->header.a_name != f->header.a_name)
+         continue;
+      if (fun->param_count != f->param_count)
+         continue;
+      for (j = 0; j < fun->param_count; j++) {
+         if (!slang_type_specifier_equal
+             (&fun->parameters->variables[j].type.specifier,
+              &f->parameters->variables[j].type.specifier))
+            break;
+      }
+      if (j == fun->param_count)
+         return f;
+   }
+   if (all_scopes && funcs->outer_scope != NULL)
+      return slang_function_scope_find(funcs->outer_scope, fun, 1);
+   return NULL;
 }
 
 /*
@@ -145,31 +172,30 @@ slang_function *slang_function_scope_find (slang_function_scope *funcs, slang_fu
  */
 
 GLboolean
-_slang_build_export_code_table (slang_export_code_table *tbl, slang_function_scope *funs,
-                                slang_code_unit *unit)
+_slang_build_export_code_table(slang_export_code_table * tbl,
+                               slang_function_scope * funs,
+                               slang_code_unit * unit)
 {
-	slang_atom mainAtom;
-	GLuint i;
+   slang_atom mainAtom;
+   GLuint i;
 
-	mainAtom = slang_atom_pool_atom (tbl->atoms, "main");
-	if (mainAtom == SLANG_ATOM_NULL)
-		return GL_FALSE;
+   mainAtom = slang_atom_pool_atom(tbl->atoms, "main");
+   if (mainAtom == SLANG_ATOM_NULL)
+      return GL_FALSE;
 
-	for (i = 0; i < funs->num_functions; i++)
-	{
-		if (funs->functions[i].header.a_name == mainAtom)
-		{
-			slang_function *fun = &funs->functions[i];
-			slang_export_code_entry *e;
-			slang_assemble_ctx A;
+   for (i = 0; i < funs->num_functions; i++) {
+      if (funs->functions[i].header.a_name == mainAtom) {
+         slang_function *fun = &funs->functions[i];
+         slang_export_code_entry *e;
+         slang_assemble_ctx A;
 
-			e = slang_export_code_table_add (tbl);
-			if (e == NULL)
-				return GL_FALSE;
+         e = slang_export_code_table_add(tbl);
+         if (e == NULL)
+            return GL_FALSE;
          e->address = unit->object->assembly.count;
-			e->name = slang_atom_pool_atom (tbl->atoms, "@main");
-			if (e->name == SLANG_ATOM_NULL)
-				return GL_FALSE;
+         e->name = slang_atom_pool_atom(tbl->atoms, "@main");
+         if (e->name == SLANG_ATOM_NULL)
+            return GL_FALSE;
 
          A.file = &unit->object->assembly;
          A.mach = &unit->object->machine;
@@ -177,12 +203,13 @@ _slang_build_export_code_table (slang_export_code_table *tbl, slang_function_sco
          A.space.funcs = &unit->funs;
          A.space.structs = &unit->structs;
          A.space.vars = &unit->vars;
-         slang_assembly_file_push_label (&unit->object->assembly, slang_asm_local_alloc, 20);
-         slang_assembly_file_push_label (&unit->object->assembly, slang_asm_enter, 20);
-			_slang_assemble_function_call (&A, fun, NULL, 0, GL_FALSE);
-         slang_assembly_file_push (&unit->object->assembly, slang_asm_exit);
-		}
-	}
-	return GL_TRUE;
+         slang_assembly_file_push_label(&unit->object->assembly,
+                                        slang_asm_local_alloc, 20);
+         slang_assembly_file_push_label(&unit->object->assembly,
+                                        slang_asm_enter, 20);
+         _slang_assemble_function_call(&A, fun, NULL, 0, GL_FALSE);
+         slang_assembly_file_push(&unit->object->assembly, slang_asm_exit);
+      }
+   }
+   return GL_TRUE;
 }
-