loader: rerun clang-format on some files

3 files changed, 67 insertions, 56 deletions

diff --git a/loader/loader.c b/loader/loader.c
index 060a05a1..affdadf1 100644
--- a/loader/loader.c
+++ b/loader/loader.c
@@ -1896,7 +1896,8 @@ loader_add_layer_properties(const struct loader_instance *inst,
                 GET_JSON_OBJECT(ext_item, entrypoints)
                 int entry_count;
                 if (entrypoints == NULL) {
-                    loader_add_to_dev_ext_list(inst, &props->device_extension_list,
+                    loader_add_to_dev_ext_list(inst,
+                                               &props->device_extension_list,
                                                &ext_prop, 0, NULL);
                     continue;
                 }
@@ -2962,8 +2963,8 @@ VkResult loader_create_instance_chain(const VkInstanceCreateInfo *pCreateInfo,
         instance_create_info.pNext = loader_create_info.pNext;
         loader_create_info.pNext = &instance_create_info;
 
-        res = fpCreateInstance(&loader_create_info, pAllocator,
-                               created_instance);
+        res =
+            fpCreateInstance(&loader_create_info, pAllocator, created_instance);
     } else {
         // Couldn't find CreateInstance function!
         res = VK_ERROR_INITIALIZATION_FAILED;
@@ -3066,7 +3067,8 @@ loader_create_device_terminator(VkPhysicalDevice physicalDevice,
      * independent of the actual ICD, just in the same library.
      */
     char **filtered_extension_names = NULL;
-    filtered_extension_names = loader_stack_alloc(pCreateInfo->enabledExtensionCount * sizeof(char *));
+    filtered_extension_names =
+        loader_stack_alloc(pCreateInfo->enabledExtensionCount * sizeof(char *));
     if (!filtered_extension_names) {
         return VK_ERROR_OUT_OF_HOST_MEMORY;
     }
@@ -3075,14 +3077,16 @@ loader_create_device_terminator(VkPhysicalDevice physicalDevice,
     localCreateInfo.ppEnabledLayerNames = NULL;
 
     localCreateInfo.enabledExtensionCount = 0;
-    localCreateInfo.ppEnabledExtensionNames = (const char * const *) filtered_extension_names;
+    localCreateInfo.ppEnabledExtensionNames =
+        (const char *const *)filtered_extension_names;
 
     for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
         const char *extension_name = pCreateInfo->ppEnabledExtensionNames[i];
-        VkExtensionProperties *prop = get_extension_property(extension_name,
-                                      &phys_dev->device_extension_cache);
+        VkExtensionProperties *prop = get_extension_property(
+            extension_name, &phys_dev->device_extension_cache);
         if (prop) {
-            filtered_extension_names[localCreateInfo.enabledExtensionCount] = (char *) extension_name;
+            filtered_extension_names[localCreateInfo.enabledExtensionCount] =
+                (char *)extension_name;
             localCreateInfo.enabledExtensionCount++;
         }
     }
@@ -3245,10 +3249,12 @@ VkResult loader_validate_layers(const struct loader_instance *inst,
     struct loader_layer_properties *prop;
 
     for (uint32_t i = 0; i < layer_count; i++) {
-        VkStringErrorFlags result = vk_string_validate(MaxLoaderStringLength, ppEnabledLayerNames[i]);
+        VkStringErrorFlags result =
+            vk_string_validate(MaxLoaderStringLength, ppEnabledLayerNames[i]);
         if (result != VK_STRING_ERROR_NONE) {
             loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                "Loader: Device ppEnabledLayerNames contains string that is too long or is badly formed");
+                       "Loader: Device ppEnabledLayerNames contains string "
+                       "that is too long or is badly formed");
             return VK_ERROR_LAYER_NOT_PRESENT;
         }
 
@@ -3270,10 +3276,12 @@ VkResult loader_validate_instance_extensions(
     struct loader_layer_properties *layer_prop;
 
     for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
-        VkStringErrorFlags result = vk_string_validate(MaxLoaderStringLength, pCreateInfo->ppEnabledExtensionNames[i]);
+        VkStringErrorFlags result = vk_string_validate(
+            MaxLoaderStringLength, pCreateInfo->ppEnabledExtensionNames[i]);
         if (result != VK_STRING_ERROR_NONE) {
             loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                "Loader: Instance ppEnabledExtensionNames contains string that is too long or is badly formed");
+                       "Loader: Instance ppEnabledExtensionNames contains "
+                       "string that is too long or is badly formed");
             return VK_ERROR_EXTENSION_NOT_PRESENT;
         }
 
@@ -3325,10 +3333,12 @@ VkResult loader_validate_device_extensions(
 
     for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
 
-        VkStringErrorFlags result = vk_string_validate(MaxLoaderStringLength, pCreateInfo->ppEnabledExtensionNames[i]);
+        VkStringErrorFlags result = vk_string_validate(
+            MaxLoaderStringLength, pCreateInfo->ppEnabledExtensionNames[i]);
         if (result != VK_STRING_ERROR_NONE) {
-            loader_log(phys_dev->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                "Loader: Device ppEnabledExtensionNames contains string that is too long or is badly formed");
+            loader_log(phys_dev->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                       0, "Loader: Device ppEnabledExtensionNames contains "
+                          "string that is too long or is badly formed");
             return VK_ERROR_EXTENSION_NOT_PRESENT;
         }
 
@@ -3748,8 +3758,7 @@ loader_CreateDevice(VkPhysicalDevice physicalDevice,
 
     /* validate any app enabled layers are available */
     if (pCreateInfo->enabledLayerCount > 0) {
-        res = loader_validate_layers(inst,
-                                     pCreateInfo->enabledLayerCount,
+        res = loader_validate_layers(inst, pCreateInfo->enabledLayerCount,
                                      pCreateInfo->ppEnabledLayerNames,
                                      &inst->device_layer_list);
         if (res != VK_SUCCESS) {
@@ -3931,16 +3940,19 @@ vkEnumerateInstanceExtensionProperties(const char *pLayerName,
 
     /* get layer libraries if needed */
     if (pLayerName && strlen(pLayerName) != 0) {
-        if (vk_string_validate(MaxLoaderStringLength, pLayerName) == VK_STRING_ERROR_NONE) {
+        if (vk_string_validate(MaxLoaderStringLength, pLayerName) ==
+            VK_STRING_ERROR_NONE) {
             loader_layer_scan(NULL, &instance_layers, NULL);
             for (uint32_t i = 0; i < instance_layers.count; i++) {
-                struct loader_layer_properties *props = &instance_layers.list[i];
+                struct loader_layer_properties *props =
+                    &instance_layers.list[i];
                 if (strcmp(props->info.layerName, pLayerName) == 0) {
-                   global_ext_list = &props->instance_extension_list;
+                    global_ext_list = &props->instance_extension_list;
                 }
             }
         } else {
-            assert(VK_FALSE && "vkEnumerateInstanceExtensionProperties:  pLayerName is too long or is badly formed");
+            assert(VK_FALSE && "vkEnumerateInstanceExtensionProperties:  "
+                               "pLayerName is too long or is badly formed");
             return VK_ERROR_EXTENSION_NOT_PRESENT;
         }
     } else {
@@ -4043,16 +4055,17 @@ loader_EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,
 
     /* get layer libraries if needed */
     if (pLayerName && strlen(pLayerName) != 0) {
-        if (vk_string_validate(MaxLoaderStringLength, pLayerName) == VK_STRING_ERROR_NONE) {
+        if (vk_string_validate(MaxLoaderStringLength, pLayerName) ==
+            VK_STRING_ERROR_NONE) {
             for (uint32_t i = 0;
-                i < phys_dev->this_instance->device_layer_list.count; i++) {
+                 i < phys_dev->this_instance->device_layer_list.count; i++) {
                 struct loader_layer_properties *props =
                     &phys_dev->this_instance->device_layer_list.list[i];
                 if (strcmp(props->info.layerName, pLayerName) == 0) {
-                   dev_ext_list = &props->device_extension_list;
+                    dev_ext_list = &props->device_extension_list;
                 }
             }
-            count = (dev_ext_list == NULL) ? 0: dev_ext_list->count;
+            count = (dev_ext_list == NULL) ? 0 : dev_ext_list->count;
             if (pProperties == NULL) {
                 *pPropertyCount = count;
                 return VK_SUCCESS;
@@ -4069,8 +4082,9 @@ loader_EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,
                 return VK_INCOMPLETE;
             }
         } else {
-            loader_log(phys_dev->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                "vkEnumerateDeviceExtensionProperties:  pLayerName is too long or is badly formed");
+            loader_log(phys_dev->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                       0, "vkEnumerateDeviceExtensionProperties:  pLayerName "
+                          "is too long or is badly formed");
             return VK_ERROR_EXTENSION_NOT_PRESENT;
         }
         return VK_SUCCESS;
@@ -4201,21 +4215,19 @@ loader_EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,
     return VK_SUCCESS;
 }
 
-VkStringErrorFlags vk_string_validate(const int max_length, const char *utf8)
-{
+VkStringErrorFlags vk_string_validate(const int max_length, const char *utf8) {
     VkStringErrorFlags result = VK_STRING_ERROR_NONE;
-    int                num_char_bytes;
-    int                i,j;
+    int num_char_bytes;
+    int i, j;
 
-    for (i = 0; i < max_length; i++)
-    {
+    for (i = 0; i < max_length; i++) {
         if (utf8[i] == 0) {
             break;
         } else if ((utf8[i] >= 0x20) && (utf8[i] < 0x7f)) {
             num_char_bytes = 0;
-        } else if ((utf8[i] & UTF8_ONE_BYTE_MASK)   == UTF8_ONE_BYTE_CODE) {
+        } else if ((utf8[i] & UTF8_ONE_BYTE_MASK) == UTF8_ONE_BYTE_CODE) {
             num_char_bytes = 1;
-        } else if ((utf8[i] & UTF8_TWO_BYTE_MASK)   == UTF8_TWO_BYTE_CODE)   {
+        } else if ((utf8[i] & UTF8_TWO_BYTE_MASK) == UTF8_TWO_BYTE_CODE) {
             num_char_bytes = 2;
         } else if ((utf8[i] & UTF8_THREE_BYTE_MASK) == UTF8_THREE_BYTE_CODE) {
             num_char_bytes = 3;
@@ -4236,4 +4248,3 @@ VkStringErrorFlags vk_string_validate(const int max_length, const char *utf8)
     }
     return result;
 }
-
diff --git a/loader/loader.h b/loader/loader.h
index b333f524..72639eb0 100644
--- a/loader/loader.h
+++ b/loader/loader.h
@@ -67,23 +67,22 @@ enum layer_type {
         0xc, // both instance and device layer, bitwise
 };
 
-
 typedef enum VkStringErrorFlagBits {
-    VK_STRING_ERROR_NONE      = 0x00000000,
-    VK_STRING_ERROR_LENGTH    = 0x00000001,
-    VK_STRING_ERROR_BAD_DATA  = 0x00000002,
+    VK_STRING_ERROR_NONE = 0x00000000,
+    VK_STRING_ERROR_LENGTH = 0x00000001,
+    VK_STRING_ERROR_BAD_DATA = 0x00000002,
 } VkStringErrorFlagBits;
 typedef VkFlags VkStringErrorFlags;
 
-static const int  MaxLoaderStringLength = 256;
-static const char UTF8_ONE_BYTE_CODE    = 0xC0;
-static const char UTF8_ONE_BYTE_MASK    = 0xE0;
-static const char UTF8_TWO_BYTE_CODE    = 0xE0;
-static const char UTF8_TWO_BYTE_MASK    = 0xF0;
-static const char UTF8_THREE_BYTE_CODE  = 0xF0;
-static const char UTF8_THREE_BYTE_MASK  = 0xF8;
-static const char UTF8_DATA_BYTE_CODE   = 0x80;
-static const char UTF8_DATA_BYTE_MASK   = 0xC0;
+static const int MaxLoaderStringLength = 256;
+static const char UTF8_ONE_BYTE_CODE = 0xC0;
+static const char UTF8_ONE_BYTE_MASK = 0xE0;
+static const char UTF8_TWO_BYTE_CODE = 0xE0;
+static const char UTF8_TWO_BYTE_MASK = 0xF0;
+static const char UTF8_THREE_BYTE_CODE = 0xF0;
+static const char UTF8_THREE_BYTE_MASK = 0xF8;
+static const char UTF8_DATA_BYTE_CODE = 0x80;
+static const char UTF8_DATA_BYTE_MASK = 0xC0;
 
 // form of all dynamic lists/arrays
 // only the list element should be changed
@@ -523,6 +522,7 @@ void *loader_tls_heap_alloc(size_t size);
 
 void loader_tls_heap_free(void *pMemory);
 
-VkStringErrorFlags vk_string_validate(const int max_length, const char *char_array);
+VkStringErrorFlags vk_string_validate(const int max_length,
+                                      const char *char_array);
 
 #endif /* LOADER_H */
diff --git a/loader/trampoline.c b/loader/trampoline.c
index b35f1d82..ff3cd965 100644
--- a/loader/trampoline.c
+++ b/loader/trampoline.c
@@ -106,10 +106,10 @@ vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo,
 
     /* validate the app requested layers to be enabled */
     if (pCreateInfo->enabledLayerCount > 0) {
-        res = loader_validate_layers(ptr_instance,
-                                     pCreateInfo->enabledLayerCount,
-                                     pCreateInfo->ppEnabledLayerNames,
-                                     &ptr_instance->instance_layer_list);
+        res =
+            loader_validate_layers(ptr_instance, pCreateInfo->enabledLayerCount,
+                                   pCreateInfo->ppEnabledLayerNames,
+                                   &ptr_instance->instance_layer_list);
         if (res != VK_SUCCESS) {
             util_DestroyDebugReportCallback(ptr_instance, instance_callback,
                                             NULL);
@@ -127,8 +127,8 @@ vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo,
     loader_get_icd_loader_instance_extensions(
         ptr_instance, &ptr_instance->icd_libs, &ptr_instance->ext_list);
     res = loader_validate_instance_extensions(
-        ptr_instance, &ptr_instance->ext_list, &ptr_instance->instance_layer_list,
-        pCreateInfo);
+        ptr_instance, &ptr_instance->ext_list,
+        &ptr_instance->instance_layer_list, pCreateInfo);
     if (res != VK_SUCCESS) {
         loader_delete_layer_properties(ptr_instance,
                                        &ptr_instance->device_layer_list);