CInterface: reformatted according to .clang-format rules

glslang/CInterface/glslang_c_interface.cpp

@@ -28,24 +28,22 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "glslang_c_interface.h"
 
-#include "glslang/Include/ShHandle.h"
-#include "StandAlone/DirStackFileIncluder.h"
-#include "StandAlone/ResourceLimits.h"
+#include "SPIRV/GlslangToSpv.h"
 #include "SPIRV/Logger.h"
 #include "SPIRV/SpvTools.h"
-#include "SPIRV/GlslangToSpv.h"
+#include "StandAlone/DirStackFileIncluder.h"
+#include "StandAlone/ResourceLimits.h"
+#include "glslang/Include/ShHandle.h"
 
 #include "glslang/Include/ResourceLimits.h"
 #include "glslang/MachineIndependent/Versions.h"
 
-typedef struct glslang_shader_s
-{
+typedef struct glslang_shader_s {
     glslang::TShader* shader;
     std::string preprocessedGLSL;
 } glslang_shader_t;
 
-typedef struct glslang_program_s
-{
+typedef struct glslang_program_s {
     glslang::TProgram* program;
     std::vector<unsigned int> spirv;
     std::string loggerMessages;
@@ -64,87 +62,57 @@ typedef struct glslang_program_s
    to allow its lifetime management by another C callback
    (CallbackIncluder::callbacks::free_include_result)
 */
-class CallbackIncluder: public glslang::TShader::Includer
-{
+class CallbackIncluder : public glslang::TShader::Includer {
 public:
     /* Wrapper of IncludeResult which stores a glsl_include_result object internally */
-	class CallbackIncludeResult: public glslang::TShader::Includer::IncludeResult
-	{
+    class CallbackIncludeResult : public glslang::TShader::Includer::IncludeResult {
     public:
-		CallbackIncludeResult(const std::string& headerName,
-			const char* const headerData,
-			const size_t headerLength,
-			void* userData,
-			glsl_include_result_t* includeResult):
-            			glslang::TShader::Includer::IncludeResult(
-					headerName, headerData, headerLength, userData),
+        CallbackIncludeResult(const std::string& headerName, const char* const headerData, const size_t headerLength,
+                              void* userData, glsl_include_result_t* includeResult)
+            : glslang::TShader::Includer::IncludeResult(headerName, headerData, headerLength, userData),
               includeResult(includeResult)
-		{}
+        {
+        }
 
         virtual ~CallbackIncludeResult() {}
+
     protected:
         friend class CallbackIncluder;
 
         glsl_include_result_t* includeResult;
     };
+
 public:
-	CallbackIncluder(glsl_include_callbacks_t _callbacks, void *_context):
-		callbacks(_callbacks),
-		context(_context)
-	{}
+    CallbackIncluder(glsl_include_callbacks_t _callbacks, void* _context) : callbacks(_callbacks), context(_context) {}
 
     virtual ~CallbackIncluder() {}
 
-        virtual IncludeResult* includeSystem(const char* headerName,
-                                             const char* includerName,
+    virtual IncludeResult* includeSystem(const char* headerName, const char* includerName,
                                          size_t inclusionDepth) override
     {
-		if (this->callbacks.include_system)
-		{
+        if (this->callbacks.include_system) {
             glsl_include_result_t* result =
-				this->callbacks.include_system(
-					this->context,
-					headerName,
-					includerName,
-					inclusionDepth);
-
-			return new CallbackIncludeResult(
-				std::string(headerName),
-				result->header_data,
-				result->header_length,
-				nullptr,
-				result
-			);
+                this->callbacks.include_system(this->context, headerName, includerName, inclusionDepth);
+
+            return new CallbackIncludeResult(std::string(headerName), result->header_data, result->header_length,
+                                             nullptr, result);
         }
 
-		return glslang::TShader::Includer::includeSystem(
-			headerName, includerName, inclusionDepth);
+        return glslang::TShader::Includer::includeSystem(headerName, includerName, inclusionDepth);
     }
 
-        virtual IncludeResult* includeLocal(const char* headerName,
-                                            const char* includerName,
+    virtual IncludeResult* includeLocal(const char* headerName, const char* includerName,
                                         size_t inclusionDepth) override
     {
-		if (this->callbacks.include_local)
-		{
+        if (this->callbacks.include_local) {
             glsl_include_result_t* result =
-				this->callbacks.include_local(
-					this->context,
-					headerName,
-					includerName,
-					inclusionDepth);
-
-			return new CallbackIncludeResult(
-				std::string(headerName),
-				result->header_data,
-				result->header_length,
-				nullptr,
-				result
-			);
+                this->callbacks.include_local(this->context, headerName, includerName, inclusionDepth);
+
+            return new CallbackIncludeResult(std::string(headerName), result->header_data, result->header_length,
+                                             nullptr, result);
         }
 
-		return glslang::TShader::Includer::includeLocal(
-			headerName, includerName, inclusionDepth);
+        return glslang::TShader::Includer::includeLocal(headerName, includerName, inclusionDepth);
     }
 
     /* This function only calls free_include_result callback
@@ -154,9 +122,8 @@ public:
         if (result == nullptr)
             return;
 
-		if (this->callbacks.free_include_result && (result->userData == nullptr))
-		{
-			CallbackIncludeResult* innerResult = static_cast<CallbackIncludeResult *>(result);
+        if (this->callbacks.free_include_result && (result->userData == nullptr)) {
+            CallbackIncludeResult* innerResult = static_cast<CallbackIncludeResult*>(result);
             /* use internal free() function */
             this->callbacks.free_include_result(this->context, innerResult->includeResult);
             /* ignore internal fields of TShader::Includer::IncludeResult */
@@ -164,32 +131,26 @@ public:
             return;
         }
 
-		delete [] static_cast<char*>(result->userData);
+        delete[] static_cast<char*>(result->userData);
         delete result;
     }
+
 private:
     CallbackIncluder() {}
 
     /* C callback pointers */
     glsl_include_callbacks_t callbacks;
     /* User-defined context */
-	void *context;
+    void* context;
 };
 
-int  glslang_initialize_process()
-{
-	return static_cast<int>(glslang::InitializeProcess());
-}
+int glslang_initialize_process() { return static_cast<int>(glslang::InitializeProcess()); }
 
-void glslang_finalize_process()
-{
-	glslang::FinalizeProcess();
-}
+void glslang_finalize_process() { glslang::FinalizeProcess(); }
 
 static EShLanguage c_shader_stage(glslang_stage_t stage)
 {
-	switch(stage)
-	{
+    switch (stage) {
     case SH_STAGE_VERTEX:
         return EShLangVertex;
     case SH_STAGE_TESSCONTROL:
@@ -226,8 +187,7 @@ static EShLanguage c_shader_stage(glslang_stage_t stage)
 
 static EShMessages c_shader_messages(glslang_messages_t messages)
 {
-	switch(messages)
-	{
+    switch (messages) {
     case SH_MSG_RELAXED_ERRORS:
         return EShMsgRelaxedErrors;
     case SH_MSG_SUPPRESS_WARNINGS:
@@ -264,10 +224,10 @@ static EShMessages c_shader_messages(glslang_messages_t messages)
     return EShMsgDefault;
 }
 
-static glslang::EShTargetLanguageVersion c_shader_target_language_version(glslang_target_language_version_t target_language_version)
+static glslang::EShTargetLanguageVersion
+c_shader_target_language_version(glslang_target_language_version_t target_language_version)
 {
-	switch(target_language_version)
-	{
+    switch (target_language_version) {
     case SH_TARGET_SPV_1_0:
         return glslang::EShTargetSpv_1_0;
     case SH_TARGET_SPV_1_1:
@@ -288,8 +248,7 @@ static glslang::EShTargetLanguageVersion c_shader_target_language_version(glslan
 
 static glslang::EShClient c_shader_client(glslang_client_t client)
 {
-	switch(client)
-	{
+    switch (client) {
     case SH_CLIENT_VULKAN:
         return glslang::EShClientVulkan;
     case SH_CLIENT_OPENGL:
@@ -303,8 +262,7 @@ static glslang::EShClient c_shader_client(glslang_client_t client)
 
 static glslang::EShTargetClientVersion c_shader_client_version(glslang_target_client_version_t client_version)
 {
-	switch(client_version)
-	{
+    switch (client_version) {
     case SH_TARGET_VULKAN_1_1:
         return glslang::EShTargetVulkan_1_1;
     case SH_TARGET_OPENGL_450:
@@ -326,8 +284,7 @@ static glslang::EShTargetLanguage c_shader_target_language(glslang_target_langua
 
 static glslang::EShSource c_shader_source(glslang_source_t source)
 {
-	switch(source)
-	{
+    switch (source) {
     case SH_SOURCE_GLSL:
         return glslang::EShSourceGlsl;
     case SH_SOURCE_HLSL:
@@ -341,8 +298,7 @@ static glslang::EShSource c_shader_source(glslang_source_t source)
 
 static EProfile c_shader_profile(glslang_profile_t profile)
 {
-	switch(profile)
-	{
+    switch (profile) {
     case SH_BAD_PROFILE:
         return EBadProfile;
     case SH_NO_PROFILE:
@@ -358,10 +314,9 @@ static EProfile c_shader_profile(glslang_profile_t profile)
     return EProfile();
 }
 
-glslang_shader_t *glslang_shader_create(glslang_input_t *input)
+glslang_shader_t* glslang_shader_create(glslang_input_t* input)
 {
-	if ( !input || !input->code )
-	{
+    if (!input || !input->code) {
         printf("Error creating shader: null input(%p)/input->code\n", input);
 
         if (input)
@@ -370,21 +325,20 @@ glslang_shader_t *glslang_shader_create(glslang_input_t *input)
         return nullptr;
     }
 
-	glslang_shader_t *shader = new glslang_shader_t();
+    glslang_shader_t* shader = new glslang_shader_t();
 
-	shader->shader = new glslang::TShader( c_shader_stage(input->stage) );
-	shader->shader->setStrings( &input->code, 1 );
-	shader->shader->setEnvInput( c_shader_source(input->language), c_shader_stage(input->stage), c_shader_client(input->client), input->default_version );
-	shader->shader->setEnvClient( c_shader_client(input->client), c_shader_client_version(input->client_version) );
-	shader->shader->setEnvTarget( c_shader_target_language(input->target_language), c_shader_target_language_version(input->target_language_version) );
+    shader->shader = new glslang::TShader(c_shader_stage(input->stage));
+    shader->shader->setStrings(&input->code, 1);
+    shader->shader->setEnvInput(c_shader_source(input->language), c_shader_stage(input->stage),
+                                c_shader_client(input->client), input->default_version);
+    shader->shader->setEnvClient(c_shader_client(input->client), c_shader_client_version(input->client_version));
+    shader->shader->setEnvTarget(c_shader_target_language(input->target_language),
+                                 c_shader_target_language_version(input->target_language_version));
 
     return shader;
 }
 
-const char* glslang_shader_get_preprocessed_code(glslang_shader_t* shader)
-{
-	return shader->preprocessedGLSL.c_str();
-}
+const char* glslang_shader_get_preprocessed_code(glslang_shader_t* shader) { return shader->preprocessedGLSL.c_str(); }
 
 int glslang_shader_preprocess(glslang_shader_t* shader, glslang_input_t* i)
 {
@@ -392,111 +346,89 @@ int  glslang_shader_preprocess(glslang_shader_t* shader, glslang_input_t* i)
     /* TODO: use custom callbacks if they are available in 'i->callbacks' */
     return shader->shader->preprocess(
         /* No user-defined resources limit */
-		&glslang::DefaultTBuiltInResource,
-		i->default_version,
-		c_shader_profile(i->default_profile),
-		(bool)i->force_default_version_and_profile,
-		(bool)i->forward_compatible,
-		c_shader_messages(i->messages),
-		&shader->preprocessedGLSL,
-		Includer
-	);
+        &glslang::DefaultTBuiltInResource, i->default_version, c_shader_profile(i->default_profile),
+        (bool)i->force_default_version_and_profile, (bool)i->forward_compatible, c_shader_messages(i->messages),
+        &shader->preprocessedGLSL, Includer);
 }
 
-int glslang_shader_parse(glslang_shader_t *shader, glslang_input_t *input)
+int glslang_shader_parse(glslang_shader_t* shader, glslang_input_t* input)
 {
     const char* preprocessedCStr = shader->preprocessedGLSL.c_str();
-	shader->shader->setStrings( &preprocessedCStr, 1 );
+    shader->shader->setStrings(&preprocessedCStr, 1);
 
     return shader->shader->parse(
         /* No user-defined resource limits for now */
-		&glslang::DefaultTBuiltInResource,
-		input->default_version,
-		(bool)input->forward_compatible,
-		c_shader_messages(input->messages)
-	);
+        &glslang::DefaultTBuiltInResource, input->default_version, (bool)input->forward_compatible,
+        c_shader_messages(input->messages));
 }
 
-const char* glslang_shader_get_info_log(glslang_shader_t *shader)
-{
-	return shader->shader->getInfoLog();
-}
+const char* glslang_shader_get_info_log(glslang_shader_t* shader) { return shader->shader->getInfoLog(); }
 
-const char* glslang_shader_get_info_debug_log(glslang_shader_t *shader)
-{
-	return shader->shader->getInfoDebugLog();
-}
+const char* glslang_shader_get_info_debug_log(glslang_shader_t* shader) { return shader->shader->getInfoDebugLog(); }
 
-void glslang_shader_delete(glslang_shader_t *shader)
+void glslang_shader_delete(glslang_shader_t* shader)
 {
     if (!shader)
         return;
 
-	delete(shader->shader);
-	delete(shader);
+    delete (shader->shader);
+    delete (shader);
 }
 
-glslang_program_t *glslang_program_create()
+glslang_program_t* glslang_program_create()
 {
-	glslang_program_t *p = new glslang_program_t();
+    glslang_program_t* p = new glslang_program_t();
     p->program = new glslang::TProgram();
     return p;
 }
 
-void glslang_program_SPIRV_generate(glslang_program_t *program, glslang_stage_t stage )
+void glslang_program_SPIRV_generate(glslang_program_t* program, glslang_stage_t stage)
 {
     spv::SpvBuildLogger logger;
     glslang::SpvOptions spvOptions;
     spvOptions.validate = true;
 
-	const glslang::TIntermediate* intermediate = program->program->getIntermediate( c_shader_stage(stage) );
+    const glslang::TIntermediate* intermediate = program->program->getIntermediate(c_shader_stage(stage));
 
-	glslang::GlslangToSpv( *intermediate, program->spirv, &logger, &spvOptions );
+    glslang::GlslangToSpv(*intermediate, program->spirv, &logger, &spvOptions);
 
     program->loggerMessages = logger.getAllMessages();
 }
 
-size_t glslang_program_SPIRV_get_size(glslang_program_t *program)
-{
-	return program->spirv.size();
-}
+size_t glslang_program_SPIRV_get_size(glslang_program_t* program) { return program->spirv.size(); }
 
-void glslang_program_SPIRV_get(glslang_program_t *program, unsigned int* out)
+void glslang_program_SPIRV_get(glslang_program_t* program, unsigned int* out)
 {
-	memcpy( out, program->spirv.data(), program->spirv.size() * sizeof( unsigned int ) );
+    memcpy(out, program->spirv.data(), program->spirv.size() * sizeof(unsigned int));
 }
 
-const char* glslang_program_SPIRV_get_messages(glslang_program_t *program)
+const char* glslang_program_SPIRV_get_messages(glslang_program_t* program)
 {
     return program->loggerMessages.empty() ? nullptr : program->loggerMessages.c_str();
 }
 
-void glslang_program_delete(glslang_program_t *program)
+void glslang_program_delete(glslang_program_t* program)
 {
     if (!program)
         return;
 
-	delete(program->program);
-	delete(program);
+    delete (program->program);
+    delete (program);
 }
 
-void glslang_program_add_shader(glslang_program_t *program, glslang_shader_t *shader)
+void glslang_program_add_shader(glslang_program_t* program, glslang_shader_t* shader)
 {
     program->program->addShader(shader->shader);
 }
 
-int glslang_program_link(glslang_program_t *program, int messages)
+int glslang_program_link(glslang_program_t* program, int messages)
 {
     return (int)program->program->link((EShMessages)messages);
 }
 
-const char* glslang_program_get_info_log(glslang_program_t *program)
-{
-	return program->program->getInfoLog();
-}
+const char* glslang_program_get_info_log(glslang_program_t* program) { return program->program->getInfoLog(); }
 
-const char* glslang_program_get_info_debug_log(glslang_program_t *program)
+const char* glslang_program_get_info_debug_log(glslang_program_t* program)
 {
     return program->program->getInfoDebugLog();
 }
-

glslang/Include/c_shader_types.h

@@ -104,10 +104,7 @@ typedef enum {
 } glslang_target_language_version_t;
 
 /* EShExecutable counterpart */
-typedef enum {
-    SH_EX_VERTEX_FRAGMENT,
-    SH_EX_FRAGMENT
-} glslang_executable_t;
+typedef enum { SH_EX_VERTEX_FRAGMENT, SH_EX_FRAGMENT } glslang_executable_t;
 
 /* EShOptimizationLevel counterpart  */
 typedef enum {
@@ -144,8 +141,7 @@ typedef enum {
 } glslang_messages_t;
 
 /* EShReflectionOptions counterpart */
-typedef enum
-{
+typedef enum {
     SH_REFLECTION_DEFAULT = 0,
     SH_REFLECTION_STRICT_ARRAY_SUFFIX = (1 << 0),
     SH_REFLECTION_BASIC_ARRAY_SUFFIX = (1 << 1),
@@ -165,4 +161,3 @@ typedef enum {
 } glslang_profile_t;
 
 #endif
-

glslang/Include/glslang_c_interface.h

@@ -36,8 +36,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 typedef struct glslang_shader_s glslang_shader_t;
 typedef struct glslang_program_s glslang_program_t;
 
-typedef struct glslang_input_s
-{
+typedef struct glslang_input_s {
     glslang_source_t language;
     glslang_stage_t stage;
     glslang_client_t client;
@@ -54,74 +53,62 @@ typedef struct glslang_input_s
 } glslang_input_t;
 
 /* Inclusion result structure allocated by C include_local/include_system callbacks */
-typedef struct glsl_include_result_s
-{
+typedef struct glsl_include_result_s {
     /* Header file name or NULL if inclusion failed */
-	const char *header_name;
+    const char* header_name;
 
     /* Header contents or NULL */
-	const char *header_data;
+    const char* header_data;
     size_t header_length;
 
 } glsl_include_result_t;
 
 /* Callback for local file inclusion */
-typedef glsl_include_result_t* (*glsl_include_local_func)(
-	void *ctx,
-	const char *header_name,
-	const char *includer_name,
+typedef glsl_include_result_t* (*glsl_include_local_func)(void* ctx, const char* header_name, const char* includer_name,
                                                           size_t include_depth);
 
 /* Callback for system file inclusion */
-typedef glsl_include_result_t* (*glsl_include_system_func)(
-	void *ctx,
-	const char *header_name,
-	const char *includer_name,
-	size_t include_depth); 
+typedef glsl_include_result_t* (*glsl_include_system_func)(void* ctx, const char* header_name,
+                                                           const char* includer_name, size_t include_depth);
 
 /* Callback for include result destruction */
-typedef int (*glsl_free_include_result_func)(
-	void *ctx,
-	glsl_include_result_t *result);
+typedef int (*glsl_free_include_result_func)(void* ctx, glsl_include_result_t* result);
 
 /* Collection of callbacks for GLSL preprocessor */
-typedef struct glsl_include_callbacks_s
-{
+typedef struct glsl_include_callbacks_s {
     glsl_include_system_func include_system;
     glsl_include_local_func include_local;
     glsl_free_include_result_func free_include_result;
 } glsl_include_callbacks_t;
 
 #ifdef __cplusplus
-extern "C"
-{
+extern "C" {
 #endif
 
 int glslang_initialize_process();
 void glslang_finalize_process();
 
-glslang_shader_t *glslang_shader_create(glslang_input_t *input);
-void glslang_shader_delete(glslang_shader_t *shader);
-int glslang_shader_preprocess(glslang_shader_t *shader, glslang_input_t *input);
-int glslang_shader_parse(glslang_shader_t *shader, glslang_input_t *input);
-const char* glslang_shader_get_preprocessed_code(glslang_shader_t *shader);
-const char* glslang_shader_get_info_log(glslang_shader_t *shader);
-const char* glslang_shader_get_info_debug_log(glslang_shader_t *shader);
-
-glslang_program_t *glslang_program_create();
-void glslang_program_delete(glslang_program_t *program);
-void glslang_program_add_shader(glslang_program_t *program, glslang_shader_t *shader);
-int glslang_program_link(glslang_program_t *program, int messages);
-void glslang_program_SPIRV_generate(glslang_program_t *program, glslang_stage_t stage);
-size_t glslang_program_SPIRV_get_size(glslang_program_t *program);
-void glslang_program_SPIRV_get(glslang_program_t *program, unsigned int *);
-const char* glslang_program_SPIRV_get_messages(glslang_program_t *program);
-const char* glslang_program_get_info_log(glslang_program_t *program);
-const char* glslang_program_get_info_debug_log(glslang_program_t *program);
+glslang_shader_t* glslang_shader_create(glslang_input_t* input);
+void glslang_shader_delete(glslang_shader_t* shader);
+int glslang_shader_preprocess(glslang_shader_t* shader, glslang_input_t* input);
+int glslang_shader_parse(glslang_shader_t* shader, glslang_input_t* input);
+const char* glslang_shader_get_preprocessed_code(glslang_shader_t* shader);
+const char* glslang_shader_get_info_log(glslang_shader_t* shader);
+const char* glslang_shader_get_info_debug_log(glslang_shader_t* shader);
+
+glslang_program_t* glslang_program_create();
+void glslang_program_delete(glslang_program_t* program);
+void glslang_program_add_shader(glslang_program_t* program, glslang_shader_t* shader);
+int glslang_program_link(glslang_program_t* program, int messages);
+void glslang_program_SPIRV_generate(glslang_program_t* program, glslang_stage_t stage);
+size_t glslang_program_SPIRV_get_size(glslang_program_t* program);
+void glslang_program_SPIRV_get(glslang_program_t* program, unsigned int*);
+const char* glslang_program_SPIRV_get_messages(glslang_program_t* program);
+const char* glslang_program_get_info_log(glslang_program_t* program);
+const char* glslang_program_get_info_debug_log(glslang_program_t* program);
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif /* #ifdef GLSLANG_C_IFACE_INCLUDED */
-