1 files changed, 40 insertions, 40 deletions

diff --git a/src/mesa/shader/slang/slang_storage.h b/src/mesa/shader/slang/slang_storage.h
index a99f38f65c..84206d0156 100644
--- a/src/mesa/shader/slang/slang_storage.h
+++ b/src/mesa/shader/slang/slang_storage.h
@@ -32,14 +32,14 @@ extern "C" {
 #endif
 
 /*
-	Program variable data storage is kept completely transparent to the front-end compiler. It is
-	up to the back-end how the data is actually allocated. The slang_storage_type enum
-	provides the basic information about how the memory is interpreted. This abstract piece
-	of memory is called a data slot. A data slot of a particular type has a fixed size.
-
-	For now, only the three basic types are supported, that is bool, int and float. Other built-in
-	types like vector or matrix can easily be decomposed into a series of basic types.
-*/
+ * Program variable data storage is kept completely transparent to the front-end compiler. It is
+ * up to the back-end how the data is actually allocated. The slang_storage_type enum
+ * provides the basic information about how the memory is interpreted. This abstract piece
+ * of memory is called a data slot. A data slot of a particular type has a fixed size.
+ *
+ * For now, only the three basic types are supported, that is bool, int and float. Other built-in
+ * types like vector or matrix can easily be decomposed into a series of basic types.
+ */
 typedef enum slang_storage_type_
 {
 	slang_stor_aggregate,
@@ -49,59 +49,59 @@ typedef enum slang_storage_type_
 } slang_storage_type;
 
 /*
-	The slang_storage_array structure groups data slots of the same type into an array. This
-	array has a fixed length. Arrays are required to have a size equal to the sum of sizes of its
-	elements. They are also required to support indirect addressing. That is, if B references
-	first data slot in the array, S is the size of the data slot and I is the integral index that
-	is not known at compile time, B+I*S references I-th data slot.
-
-	This structure is also used to break down built-in data types that are not supported directly.
-	Vectors, like vec3, are constructed from arrays of their basic types. Matrices are formed of
-	an array of column vectors, which are in turn processed as other vectors.
-*/
+ * The slang_storage_array structure groups data slots of the same type into an array. This
+ * array has a fixed length. Arrays are required to have a size equal to the sum of sizes of its
+ * elements. They are also required to support indirect addressing. That is, if B references
+ * first data slot in the array, S is the size of the data slot and I is the integral index that
+ * is not known at compile time, B+I*S references I-th data slot.
+ *

+ * This structure is also used to break down built-in data types that are not supported directly.
+ * Vectors, like vec3, are constructed from arrays of their basic types. Matrices are formed of
+ * an array of column vectors, which are in turn processed as other vectors.
+ */
 typedef struct slang_storage_array_
 {
 	slang_storage_type type;
 	struct slang_storage_aggregate_ *aggregate;	/* slang_stor_aggregate */
-	unsigned int length;
+	GLuint length;
 } slang_storage_array;
 
-int slang_storage_array_construct (slang_storage_array *);
-void slang_storage_array_destruct (slang_storage_array *);
+GLboolean slang_storage_array_construct (slang_storage_array *);
+GLvoid slang_storage_array_destruct (slang_storage_array *);
 
 /*
-	The slang_storage_aggregate structure relaxes the indirect addressing requirement for
-	slang_storage_array structure. Aggregates are always accessed statically - its member
-	addresses are well-known at compile time. For example, user-defined types are implemented as
-	aggregates. Aggregates can collect data of a different type.
-*/
+ * The slang_storage_aggregate structure relaxes the indirect addressing requirement for
+ * slang_storage_array structure. Aggregates are always accessed statically - its member
+ * addresses are well-known at compile time. For example, user-defined types are implemented as
+ * aggregates. Aggregates can collect data of a different type.
+ */
 typedef struct slang_storage_aggregate_
 {
 	slang_storage_array *arrays;
-	unsigned int count;
+	GLuint count;
 } slang_storage_aggregate;
 
-int slang_storage_aggregate_construct (slang_storage_aggregate *);
-void slang_storage_aggregate_destruct (slang_storage_aggregate *);
+GLboolean slang_storage_aggregate_construct (slang_storage_aggregate *);
+GLvoid slang_storage_aggregate_destruct (slang_storage_aggregate *);
 
-int _slang_aggregate_variable (slang_storage_aggregate *, struct slang_type_specifier_ *,
+GLboolean _slang_aggregate_variable (slang_storage_aggregate *, struct slang_type_specifier_ *,
 	struct slang_operation_ *, struct slang_function_scope_ *, slang_struct_scope *,
 	slang_variable_scope *, struct slang_machine_ *, struct slang_assembly_file_ *,

 	slang_atom_pool *);
 
 /*
-	returns total size (in machine units) of the given aggregate
-	returns 0 on error
-*/
-unsigned int _slang_sizeof_aggregate (const slang_storage_aggregate *);
+ * Returns total size (in machine units) of the given aggregate.
+ * Returns 0 on error.
+ */
+GLuint _slang_sizeof_aggregate (const slang_storage_aggregate *);
 
 /*
-	converts structured aggregate to a flat one, with arrays of generic type being
-	one-element long
-	returns 1 on success
-	returns 0 otherwise
-*/
-int _slang_flatten_aggregate (slang_storage_aggregate *, const slang_storage_aggregate *);
+ * Converts structured aggregate to a flat one, with arrays of generic type being
+ * one-element long.
+ * Returns GL_TRUE on success.
+ * Returns GL_FALSE otherwise.
+ */
+GLboolean _slang_flatten_aggregate (slang_storage_aggregate *, const slang_storage_aggregate *);
 
 #ifdef __cplusplus
 }