Merge pull request #35 from Leandros/master

Explicitly namespace every extern identifier

include/internal/filesystem.h

@@ -24,14 +24,14 @@
 CPU_FEATURES_START_CPP_NAMESPACE
 
 // Same as linux "open(filename, O_RDONLY)", retries automatically on EINTR.
-int OpenFile(const char* filename);
+int CpuFeatures_OpenFile(const char* filename);
 
 // Same as linux "read(file_descriptor, buffer, buffer_size)", retries
 // automatically on EINTR.
-int ReadFile(int file_descriptor, void* buffer, size_t buffer_size);
+int CpuFeatures_ReadFile(int file_descriptor, void* buffer, size_t buffer_size);
 
 // Same as linux "close(file_descriptor)".
-void CloseFile(int file_descriptor);
+void CpuFeatures_CloseFile(int file_descriptor);
 
 CPU_FEATURES_END_CPP_NAMESPACE
 

include/internal/hwcaps.h

@@ -66,7 +66,7 @@ typedef struct {
   uint32_t hwcaps2;
 } HardwareCapabilities;
 
-HardwareCapabilities GetHardwareCapabilities(void);
+HardwareCapabilities CpuFeatures_GetHardwareCapabilities(void);
 
 CPU_FEATURES_END_CPP_NAMESPACE
 

include/internal/linux_features_aggregator.h

@@ -43,16 +43,18 @@ typedef struct {
 // For every config, looks into flags_line for the presence of the
 // corresponding proc_cpuinfo_flag, calls `set_bit` accordingly.
 // Note: features is a pointer to the underlying Feature struct.
-void SetFromFlags(const size_t configs_size, const CapabilityConfig* configs,
+void CpuFeatures_SetFromFlags(const size_t configs_size,
-                  const StringView flags_line, void* const features);
+                              const CapabilityConfig* configs,
+                              const StringView flags_line,
+                              void* const features);
 
 // For every config, looks into hwcaps for the presence of the feature. Calls
 // `set_bit` with true if the hardware capability is found.
 // Note: features is a pointer to the underlying Feature struct.
-void OverrideFromHwCaps(const size_t configs_size,
+void CpuFeatures_OverrideFromHwCaps(const size_t configs_size,
-                        const CapabilityConfig* configs,
+                                    const CapabilityConfig* configs,
-                        const HardwareCapabilities hwcaps,
+                                    const HardwareCapabilities hwcaps,
-                        void* const features);
+                                    void* const features);
 
 CPU_FEATURES_END_CPP_NAMESPACE
 #endif  // CPU_FEATURES_INCLUDE_INTERNAL_LINUX_FEATURES_AGGREGATOR_H_

include/internal/string_view.h

@@ -46,55 +46,61 @@ static inline StringView view(const char* str, const size_t size) {
 static inline StringView str(const char* str) { return view(str, strlen(str)); }
 
 // Returns the index of the first occurrence of c in view or -1 if not found.
-int IndexOfChar(const StringView view, char c);
+int CpuFeatures_StringView_IndexOfChar(const StringView view, char c);
 
 // Returns the index of the first occurrence of sub_view in view or -1 if not
 // found.
-int IndexOf(const StringView view, const StringView sub_view);
+int CpuFeatures_StringView_IndexOf(const StringView view,
+                                   const StringView sub_view);
 
 // Returns whether a is equal to b (same content).
-bool IsEquals(const StringView a, const StringView b);
+bool CpuFeatures_StringView_IsEquals(const StringView a, const StringView b);
 
 // Returns whether a starts with b.
-bool StartsWith(const StringView a, const StringView b);
+bool CpuFeatures_StringView_StartsWith(const StringView a, const StringView b);
 
 // Removes count characters from the beginning of view or kEmptyStringView if
 // count if greater than view.size.
-StringView PopFront(const StringView view, size_t count);
+StringView CpuFeatures_StringView_PopFront(const StringView view, size_t count);
 
 // Removes count characters from the end of view or kEmptyStringView if count if
 // greater than view.size.
-StringView PopBack(const StringView str_view, size_t count);
+StringView CpuFeatures_StringView_PopBack(const StringView str_view,
+                                          size_t count);
 
 // Keeps the count first characters of view or view if count if greater than
 // view.size.
-StringView KeepFront(const StringView view, size_t count);
+StringView CpuFeatures_StringView_KeepFront(const StringView view,
+                                            size_t count);
 
 // Retrieves the first character of view. If view is empty the behavior is
 // undefined.
-char Front(const StringView view);
+char CpuFeatures_StringView_Front(const StringView view);
 
 // Retrieves the last character of view. If view is empty the behavior is
 // undefined.
-char Back(const StringView view);
+char CpuFeatures_StringView_Back(const StringView view);
 
 // Removes leading and tailing space characters.
-StringView TrimWhitespace(StringView view);
+StringView CpuFeatures_StringView_TrimWhitespace(StringView view);
 
 // Convert StringView to positive integer. e.g. "42", "0x2a".
 // Returns -1 on error.
-int ParsePositiveNumber(const StringView view);
+int CpuFeatures_StringView_ParsePositiveNumber(const StringView view);
 
 // Copies src StringView to dst buffer.
-void CopyString(const StringView src, char* dst, size_t dst_size);
+void CpuFeatures_StringView_CopyString(const StringView src, char* dst,
+                                       size_t dst_size);
 
 // Checks if line contains the specified whitespace separated word.
-bool HasWord(const StringView line, const char* const word);
+bool CpuFeatures_StringView_HasWord(const StringView line,
+                                    const char* const word);
 
 // Get key/value from line. key and value are separated by ": ".
 // key and value are cleaned up from leading and trailing whitespaces.
-bool GetAttributeKeyValue(const StringView line, StringView* key,
+bool CpuFeatures_StringView_GetAttributeKeyValue(const StringView line,
-                          StringView* value);
+                                                 StringView* key,
+                                                 StringView* value);
 
 CPU_FEATURES_END_CPP_NAMESPACE
 

src/cpuinfo_aarch64.c

@@ -46,24 +46,24 @@ static bool HandleAarch64Line(const LineResult result,
                               Aarch64Info* const info) {
   StringView line = result.line;
   StringView key, value;
-  if (GetAttributeKeyValue(line, &key, &value)) {
+  if (CpuFeatures_StringView_GetAttributeKeyValue(line, &key, &value)) {
-    if (IsEquals(key, str("Features"))) {
+    if (CpuFeatures_StringView_IsEquals(key, str("Features"))) {
-      SetFromFlags(kConfigsSize, kConfigs, value, &info->features);
+      CpuFeatures_SetFromFlags(kConfigsSize, kConfigs, value, &info->features);
-    } else if (IsEquals(key, str("CPU implementer"))) {
+    } else if (CpuFeatures_StringView_IsEquals(key, str("CPU implementer"))) {
-      info->implementer = ParsePositiveNumber(value);
+      info->implementer = CpuFeatures_StringView_ParsePositiveNumber(value);
-    } else if (IsEquals(key, str("CPU variant"))) {
+    } else if (CpuFeatures_StringView_IsEquals(key, str("CPU variant"))) {
-      info->variant = ParsePositiveNumber(value);
+      info->variant = CpuFeatures_StringView_ParsePositiveNumber(value);
-    } else if (IsEquals(key, str("CPU part"))) {
+    } else if (CpuFeatures_StringView_IsEquals(key, str("CPU part"))) {
-      info->part = ParsePositiveNumber(value);
+      info->part = CpuFeatures_StringView_ParsePositiveNumber(value);
-    } else if (IsEquals(key, str("CPU revision"))) {
+    } else if (CpuFeatures_StringView_IsEquals(key, str("CPU revision"))) {
-      info->revision = ParsePositiveNumber(value);
+      info->revision = CpuFeatures_StringView_ParsePositiveNumber(value);
     }
   }
   return !result.eof;
 }
 
 static void FillProcCpuInfoData(Aarch64Info* const info) {
-  const int fd = OpenFile("/proc/cpuinfo");
+  const int fd = CpuFeatures_OpenFile("/proc/cpuinfo");
   if (fd >= 0) {
     StackLineReader reader;
     StackLineReader_Initialize(&reader, fd);
@@ -72,7 +72,7 @@ static void FillProcCpuInfoData(Aarch64Info* const info) {
         break;
       }
     }
-    CloseFile(fd);
+    CpuFeatures_CloseFile(fd);
   }
 }
 
@@ -85,8 +85,9 @@ Aarch64Info GetAarch64Info(void) {
   Aarch64Info info = kEmptyAarch64Info;
 
   FillProcCpuInfoData(&info);
-  OverrideFromHwCaps(kConfigsSize, kConfigs, GetHardwareCapabilities(),
+  CpuFeatures_OverrideFromHwCaps(kConfigsSize, kConfigs,
-                     &info.features);
+                                 CpuFeatures_GetHardwareCapabilities(),
+                                 &info.features);
 
   return info;
 }

src/cpuinfo_arm.c

@@ -62,8 +62,8 @@ typedef struct {
 
 static int IndexOfNonDigit(StringView str) {
   size_t index = 0;
-  while (str.size && isdigit(Front(str))) {
+  while (str.size && isdigit(CpuFeatures_StringView_Front(str))) {
-    str = PopFront(str, 1);
+    str = CpuFeatures_StringView_PopFront(str, 1);
     ++index;
   }
   return index;
@@ -73,26 +73,29 @@ static bool HandleArmLine(const LineResult result, ArmInfo* const info,
                           ProcCpuInfoData* const proc_info) {
   StringView line = result.line;
   StringView key, value;
-  if (GetAttributeKeyValue(line, &key, &value)) {
+  if (CpuFeatures_StringView_GetAttributeKeyValue(line, &key, &value)) {
-    if (IsEquals(key, str("Features"))) {
+    if (CpuFeatures_StringView_IsEquals(key, str("Features"))) {
-      SetFromFlags(kConfigsSize, kConfigs, value, &info->features);
+      CpuFeatures_SetFromFlags(kConfigsSize, kConfigs, value, &info->features);
-    } else if (IsEquals(key, str("CPU implementer"))) {
+    } else if (CpuFeatures_StringView_IsEquals(key, str("CPU implementer"))) {
-      info->implementer = ParsePositiveNumber(value);
+      info->implementer = CpuFeatures_StringView_ParsePositiveNumber(value);
-    } else if (IsEquals(key, str("CPU variant"))) {
+    } else if (CpuFeatures_StringView_IsEquals(key, str("CPU variant"))) {
-      info->variant = ParsePositiveNumber(value);
+      info->variant = CpuFeatures_StringView_ParsePositiveNumber(value);
-    } else if (IsEquals(key, str("CPU part"))) {
+    } else if (CpuFeatures_StringView_IsEquals(key, str("CPU part"))) {
-      info->part = ParsePositiveNumber(value);
+      info->part = CpuFeatures_StringView_ParsePositiveNumber(value);
-    } else if (IsEquals(key, str("CPU revision"))) {
+    } else if (CpuFeatures_StringView_IsEquals(key, str("CPU revision"))) {
-      info->revision = ParsePositiveNumber(value);
+      info->revision = CpuFeatures_StringView_ParsePositiveNumber(value);
-    } else if (IsEquals(key, str("CPU architecture"))) {
+    } else if (CpuFeatures_StringView_IsEquals(key, str("CPU architecture"))) {
       // CPU architecture is a number that may be followed by letters. e.g.
       // "6TEJ", "7".
-      const StringView digits = KeepFront(value, IndexOfNonDigit(value));
+      const StringView digits =
-      info->architecture = ParsePositiveNumber(digits);
+          CpuFeatures_StringView_KeepFront(value, IndexOfNonDigit(value));
-    } else if (IsEquals(key, str("Processor"))) {
+      info->architecture = CpuFeatures_StringView_ParsePositiveNumber(digits);
-      proc_info->processor_reports_armv6 = IndexOf(value, str("(v6l)")) >= 0;
+    } else if (CpuFeatures_StringView_IsEquals(key, str("Processor"))) {
-    } else if (IsEquals(key, str("Hardware"))) {
+      proc_info->processor_reports_armv6 =
-      proc_info->hardware_reports_goldfish = IsEquals(value, str("Goldfish"));
+          CpuFeatures_StringView_IndexOf(value, str("(v6l)")) >= 0;
+    } else if (CpuFeatures_StringView_IsEquals(key, str("Hardware"))) {
+      proc_info->hardware_reports_goldfish =
+          CpuFeatures_StringView_IsEquals(value, str("Goldfish"));
     }
   }
   return !result.eof;
@@ -148,7 +151,7 @@ static void FixErrors(ArmInfo* const info,
 
 static void FillProcCpuInfoData(ArmInfo* const info,
                                 ProcCpuInfoData* proc_cpu_info_data) {
-  const int fd = OpenFile("/proc/cpuinfo");
+  const int fd = CpuFeatures_OpenFile("/proc/cpuinfo");
   if (fd >= 0) {
     StackLineReader reader;
     StackLineReader_Initialize(&reader, fd);
@@ -158,7 +161,7 @@ static void FillProcCpuInfoData(ArmInfo* const info,
         break;
       }
     }
-    CloseFile(fd);
+    CpuFeatures_CloseFile(fd);
   }
 }
 
@@ -174,8 +177,9 @@ ArmInfo GetArmInfo(void) {
   ProcCpuInfoData proc_cpu_info_data = kEmptyProcCpuInfoData;
 
   FillProcCpuInfoData(&info, &proc_cpu_info_data);
-  OverrideFromHwCaps(kConfigsSize, kConfigs, GetHardwareCapabilities(),
+  CpuFeatures_OverrideFromHwCaps(kConfigsSize, kConfigs,
-                     &info.features);
+                                 CpuFeatures_GetHardwareCapabilities(),
+                                 &info.features);
 
   FixErrors(&info, &proc_cpu_info_data);
 

src/cpuinfo_mips.c

@@ -32,16 +32,16 @@ static bool HandleMipsLine(const LineResult result,
                            MipsFeatures* const features) {
   StringView key, value;
   // See tests for an example.
-  if (GetAttributeKeyValue(result.line, &key, &value)) {
+  if (CpuFeatures_StringView_GetAttributeKeyValue(result.line, &key, &value)) {
-    if (IsEquals(key, str("ASEs implemented"))) {
+    if (CpuFeatures_StringView_IsEquals(key, str("ASEs implemented"))) {
-      SetFromFlags(kConfigsSize, kConfigs, value, features);
+      CpuFeatures_SetFromFlags(kConfigsSize, kConfigs, value, features);
     }
   }
   return !result.eof;
 }
 
 static void FillProcCpuInfoData(MipsFeatures* const features) {
-  const int fd = OpenFile("/proc/cpuinfo");
+  const int fd = CpuFeatures_OpenFile("/proc/cpuinfo");
   if (fd >= 0) {
     StackLineReader reader;
     StackLineReader_Initialize(&reader, fd);
@@ -50,7 +50,7 @@ static void FillProcCpuInfoData(MipsFeatures* const features) {
         break;
       }
     }
-    CloseFile(fd);
+    CpuFeatures_CloseFile(fd);
   }
 }
 
@@ -63,8 +63,9 @@ MipsInfo GetMipsInfo(void) {
   MipsInfo info = kEmptyMipsInfo;
 
   FillProcCpuInfoData(&info.features);
-  OverrideFromHwCaps(kConfigsSize, kConfigs, GetHardwareCapabilities(),
+  CpuFeatures_OverrideFromHwCaps(kConfigsSize, kConfigs,
-                     &info.features);
+                                 CpuFeatures_GetHardwareCapabilities(),
+                                 &info.features);
   return info;
 }
 

src/filesystem.c

@@ -21,18 +21,21 @@
 
 #if defined(_MSC_VER)
 #include <io.h>
-int OpenFile(const char* filename) { return _open(filename, _O_RDONLY); }
+int CpuFeatures_OpenFile(const char* filename) {
+  return _open(filename, _O_RDONLY);
+}
 
-void CloseFile(int file_descriptor) { _close(file_descriptor); }
+void CpuFeatures_CloseFile(int file_descriptor) { _close(file_descriptor); }
 
-int ReadFile(int file_descriptor, void* buffer, size_t buffer_size) {
+int CpuFeatures_ReadFile(int file_descriptor, void* buffer,
+                         size_t buffer_size) {
   return _read(file_descriptor, buffer, buffer_size);
 }
 
 #else
 #include <unistd.h>
 
-int OpenFile(const char* filename) {
+int CpuFeatures_OpenFile(const char* filename) {
   int result;
   do {
     result = open(filename, O_RDONLY);
@@ -40,9 +43,10 @@ int OpenFile(const char* filename) {
   return result;
 }
 
-void CloseFile(int file_descriptor) { close(file_descriptor); }
+void CpuFeatures_CloseFile(int file_descriptor) { close(file_descriptor); }
 
-int ReadFile(int file_descriptor, void* buffer, size_t buffer_size) {
+int CpuFeatures_ReadFile(int file_descriptor, void* buffer,
+                         size_t buffer_size) {
   int result;
   do {
     result = read(file_descriptor, buffer, buffer_size);

src/hwcaps.c

@@ -110,13 +110,13 @@ static uint32_t GetElfHwcapFromProcSelfAuxv(uint32_t hwcap_type) {
   } entry;
   uint32_t result = 0;
   const char filepath[] = "/proc/self/auxv";
-  const int fd = OpenFile(filepath);
+  const int fd = CpuFeatures_OpenFile(filepath);
   if (fd < 0) {
     D("Could not open %s\n", filepath);
     return 0;
   }
   for (;;) {
-    const int ret = ReadFile(fd, (char*)&entry, sizeof entry);
+    const int ret = CpuFeatures_ReadFile(fd, (char*)&entry, sizeof entry);
     if (ret < 0) {
       D("Error while reading %s\n", filepath);
       break;
@@ -130,7 +130,7 @@ static uint32_t GetElfHwcapFromProcSelfAuxv(uint32_t hwcap_type) {
       break;
     }
   }
-  CloseFile(fd);
+  CpuFeatures_CloseFile(fd);
   return result;
 }
 
@@ -145,7 +145,7 @@ static uint32_t GetHardwareCapabilitiesFor(uint32_t type) {
   return hwcaps;
 }
 
-HardwareCapabilities GetHardwareCapabilities(void) {
+HardwareCapabilities CpuFeatures_GetHardwareCapabilities(void) {
   HardwareCapabilities capabilities;
   capabilities.hwcaps = GetHardwareCapabilitiesFor(AT_HWCAP);
   capabilities.hwcaps2 = GetHardwareCapabilitiesFor(AT_HWCAP2);
@@ -159,7 +159,7 @@ HardwareCapabilities GetHardwareCapabilities(void) {
 ////////////////////////////////////////////////////////////////////////////////
 
 const HardwareCapabilities kEmptyHardwareCapabilities;
-HardwareCapabilities GetHardwareCapabilities(void) {
+HardwareCapabilities CpuFeatures_GetHardwareCapabilities(void) {
   return kEmptyHardwareCapabilities;
 }
 #endif

src/linux_features_aggregator.c

@@ -15,12 +15,15 @@
 #include "internal/linux_features_aggregator.h"
 #include "internal/string_view.h"
 
-void SetFromFlags(const size_t configs_size, const CapabilityConfig* configs,
+void CpuFeatures_SetFromFlags(const size_t configs_size,
-                  const StringView flags_line, void* const features) {
+                              const CapabilityConfig* configs,
+                              const StringView flags_line,
+                              void* const features) {
   size_t i = 0;
   for (; i < configs_size; ++i) {
     const CapabilityConfig config = configs[i];
-    config.set_bit(features, HasWord(flags_line, config.proc_cpuinfo_flag));
+    config.set_bit(features, CpuFeatures_StringView_HasWord(
+                                 flags_line, config.proc_cpuinfo_flag));
   }
 }
 
@@ -34,10 +37,10 @@ static bool IsHwCapsSet(const HardwareCapabilities hwcaps_mask,
          IsSet(hwcaps_mask.hwcaps2, hwcaps.hwcaps2);
 }
 
-void OverrideFromHwCaps(const size_t configs_size,
+void CpuFeatures_OverrideFromHwCaps(const size_t configs_size,
-                        const CapabilityConfig* configs,
+                                    const CapabilityConfig* configs,
-                        const HardwareCapabilities hwcaps,
+                                    const HardwareCapabilities hwcaps,
-                        void* const features) {
+                                    void* const features) {
   size_t i = 0;
   for (; i < configs_size; ++i) {
     const CapabilityConfig* config = &configs[i];

src/stack_line_reader.c

@@ -28,8 +28,8 @@ void StackLineReader_Initialize(StackLineReader* reader, int fd) {
 
 // Replaces the content of buffer with bytes from the file.
 static int LoadFullBuffer(StackLineReader* reader) {
-  const int read =
+  const int read = CpuFeatures_ReadFile(reader->fd, reader->buffer,
-      ReadFile(reader->fd, reader->buffer, STACK_LINE_READER_BUFFER_SIZE);
+                                        STACK_LINE_READER_BUFFER_SIZE);
   assert(read >= 0);
   reader->view.ptr = reader->buffer;
   reader->view.size = read;
@@ -40,7 +40,7 @@ static int LoadFullBuffer(StackLineReader* reader) {
 static int LoadMore(StackLineReader* reader) {
   char* const ptr = reader->buffer + reader->view.size;
   const size_t size_to_read = STACK_LINE_READER_BUFFER_SIZE - reader->view.size;
-  const int read = ReadFile(reader->fd, ptr, size_to_read);
+  const int read = CpuFeatures_ReadFile(reader->fd, ptr, size_to_read);
   assert(read >= 0);
   assert(read <= (int)size_to_read);
   reader->view.size += read;
@@ -48,7 +48,7 @@ static int LoadMore(StackLineReader* reader) {
 }
 
 static int IndexOfEol(StackLineReader* reader) {
-  return IndexOfChar(reader->view, '\n');
+  return CpuFeatures_StringView_IndexOfChar(reader->view, '\n');
 }
 
 // Relocate buffer's pending bytes at the beginning of the array and fills the
@@ -71,7 +71,8 @@ static void SkipToNextLine(StackLineReader* reader) {
     } else {
       const int eol_index = IndexOfEol(reader);
       if (eol_index >= 0) {
-        reader->view = PopFront(reader->view, eol_index + 1);
+        reader->view =
+            CpuFeatures_StringView_PopFront(reader->view, eol_index + 1);
         break;
       }
     }
@@ -120,8 +121,10 @@ LineResult StackLineReader_NextLine(StackLineReader* reader) {
       return CreateTruncatedLineResult(reader->view);
     }
     {
-      StringView line = KeepFront(reader->view, eol_index);
+      StringView line =
-      reader->view = PopFront(reader->view, eol_index + 1);
+          CpuFeatures_StringView_KeepFront(reader->view, eol_index);
+      reader->view =
+          CpuFeatures_StringView_PopFront(reader->view, eol_index + 1);
       return CreateValidLineResult(line);
     }
   }

src/string_view.c

@@ -18,7 +18,7 @@
 #include <ctype.h>
 #include <string.h>
 
-int IndexOfChar(const StringView view, char c) {
+int CpuFeatures_StringView_IndexOfChar(const StringView view, char c) {
   if (view.ptr && view.size) {
     const char* const found = (const char*)memchr(view.ptr, c, view.size);
     if (found) {
@@ -28,67 +28,74 @@ int IndexOfChar(const StringView view, char c) {
   return -1;
 }
 
-int IndexOf(const StringView view, const StringView sub_view) {
+int CpuFeatures_StringView_IndexOf(const StringView view,
+                                   const StringView sub_view) {
   if (sub_view.size) {
     StringView remainder = view;
     while (remainder.size >= sub_view.size) {
-      const int found_index = IndexOfChar(remainder, sub_view.ptr[0]);
+      const int found_index =
+          CpuFeatures_StringView_IndexOfChar(remainder, sub_view.ptr[0]);
       if (found_index < 0) break;
-      remainder = PopFront(remainder, found_index);
+      remainder = CpuFeatures_StringView_PopFront(remainder, found_index);
-      if (StartsWith(remainder, sub_view)) {
+      if (CpuFeatures_StringView_StartsWith(remainder, sub_view)) {
         return remainder.ptr - view.ptr;
       }
-      remainder = PopFront(remainder, 1);
+      remainder = CpuFeatures_StringView_PopFront(remainder, 1);
     }
   }
   return -1;
 }
 
-bool IsEquals(const StringView a, const StringView b) {
+bool CpuFeatures_StringView_IsEquals(const StringView a, const StringView b) {
   if (a.size == b.size) {
     return a.ptr == b.ptr || memcmp(a.ptr, b.ptr, b.size) == 0;
   }
   return false;
 }
 
-bool StartsWith(const StringView a, const StringView b) {
+bool CpuFeatures_StringView_StartsWith(const StringView a, const StringView b) {
   return a.ptr && b.ptr && b.size && a.size >= b.size
              ? memcmp(a.ptr, b.ptr, b.size) == 0
              : false;
 }
 
-StringView PopFront(const StringView str_view, size_t count) {
+StringView CpuFeatures_StringView_PopFront(const StringView str_view,
+                                           size_t count) {
   if (count > str_view.size) {
     return kEmptyStringView;
   }
   return view(str_view.ptr + count, str_view.size - count);
 }
 
-StringView PopBack(const StringView str_view, size_t count) {
+StringView CpuFeatures_StringView_PopBack(const StringView str_view,
+                                          size_t count) {
   if (count > str_view.size) {
     return kEmptyStringView;
   }
   return view(str_view.ptr, str_view.size - count);
 }
 
-StringView KeepFront(const StringView str_view, size_t count) {
+StringView CpuFeatures_StringView_KeepFront(const StringView str_view,
+                                            size_t count) {
   return count <= str_view.size ? view(str_view.ptr, count) : str_view;
 }
 
-char Front(const StringView view) {
+char CpuFeatures_StringView_Front(const StringView view) {
   assert(view.size);
   assert(view.ptr);
   return view.ptr[0];
 }
 
-char Back(const StringView view) {
+char CpuFeatures_StringView_Back(const StringView view) {
   assert(view.size);
   return view.ptr[view.size - 1];
 }
 
-StringView TrimWhitespace(StringView view) {
+StringView CpuFeatures_StringView_TrimWhitespace(StringView view) {
-  while (view.size && isspace(Front(view))) view = PopFront(view, 1);
+  while (view.size && isspace(CpuFeatures_StringView_Front(view)))
-  while (view.size && isspace(Back(view))) view = PopBack(view, 1);
+    view = CpuFeatures_StringView_PopFront(view, 1);
+  while (view.size && isspace(CpuFeatures_StringView_Back(view)))
+    view = CpuFeatures_StringView_PopBack(view, 1);
   return view;
 }
 
@@ -103,19 +110,21 @@ static int HexValue(const char c) {
 static int ParsePositiveNumberWithBase(const StringView view, int base) {
   int result = 0;
   StringView remainder = view;
-  for (; remainder.size; remainder = PopFront(remainder, 1)) {
+  for (; remainder.size;
-    const int value = HexValue(Front(remainder));
+       remainder = CpuFeatures_StringView_PopFront(remainder, 1)) {
+    const int value = HexValue(CpuFeatures_StringView_Front(remainder));
     if (value < 0 || value >= base) return -1;
     result = (result * base) + value;
   }
   return result;
 }
 
-int ParsePositiveNumber(const StringView view) {
+int CpuFeatures_StringView_ParsePositiveNumber(const StringView view) {
   if (view.size) {
     const StringView hex_prefix = str("0x");
-    if (StartsWith(view, hex_prefix)) {
+    if (CpuFeatures_StringView_StartsWith(view, hex_prefix)) {
-      const StringView span_no_prefix = PopFront(view, hex_prefix.size);
+      const StringView span_no_prefix =
+          CpuFeatures_StringView_PopFront(view, hex_prefix.size);
       return ParsePositiveNumberWithBase(span_no_prefix, 16);
     }
     return ParsePositiveNumberWithBase(view, 10);
@@ -123,7 +132,8 @@ int ParsePositiveNumber(const StringView view) {
   return -1;
 }
 
-void CopyString(const StringView src, char* dst, size_t dst_size) {
+void CpuFeatures_StringView_CopyString(const StringView src, char* dst,
+                                       size_t dst_size) {
   if (dst_size > 0) {
     const size_t max_copy_size = dst_size - 1;
     const size_t copy_size =
@@ -133,31 +143,40 @@ void CopyString(const StringView src, char* dst, size_t dst_size) {
   }
 }
 
-bool HasWord(const StringView line, const char* const word_str) {
+bool CpuFeatures_StringView_HasWord(const StringView line,
+                                    const char* const word_str) {
   const StringView word = str(word_str);
   StringView remainder = line;
   for (;;) {
-    const int index_of_word = IndexOf(remainder, word);
+    const int index_of_word = CpuFeatures_StringView_IndexOf(remainder, word);
     if (index_of_word < 0) {
       return false;
     } else {
-      const StringView before = KeepFront(line, index_of_word);
+      const StringView before =
-      const StringView after = PopFront(line, index_of_word + word.size);
+          CpuFeatures_StringView_KeepFront(line, index_of_word);
-      const bool valid_before = before.size == 0 || Back(before) == ' ';
+      const StringView after =
-      const bool valid_after = after.size == 0 || Front(after) == ' ';
+          CpuFeatures_StringView_PopFront(line, index_of_word + word.size);
+      const bool valid_before =
+          before.size == 0 || CpuFeatures_StringView_Back(before) == ' ';
+      const bool valid_after =
+          after.size == 0 || CpuFeatures_StringView_Front(after) == ' ';
       if (valid_before && valid_after) return true;
-      remainder = PopFront(remainder, index_of_word + word.size);
+      remainder =
+          CpuFeatures_StringView_PopFront(remainder, index_of_word + word.size);
     }
   }
   return false;
 }
 
-bool GetAttributeKeyValue(const StringView line, StringView* key,
+bool CpuFeatures_StringView_GetAttributeKeyValue(const StringView line,
-                          StringView* value) {
+                                                 StringView* key,
+                                                 StringView* value) {
   const StringView sep = str(": ");
-  const int index_of_separator = IndexOf(line, sep);
+  const int index_of_separator = CpuFeatures_StringView_IndexOf(line, sep);
   if (index_of_separator < 0) return false;
-  *value = TrimWhitespace(PopFront(line, index_of_separator + sep.size));
+  *value = CpuFeatures_StringView_TrimWhitespace(
-  *key = TrimWhitespace(KeepFront(line, index_of_separator));
+      CpuFeatures_StringView_PopFront(line, index_of_separator + sep.size));
+  *key = CpuFeatures_StringView_TrimWhitespace(
+      CpuFeatures_StringView_KeepFront(line, index_of_separator));
   return true;
 }

test/filesystem_for_testing.cc

@@ -81,7 +81,7 @@ FakeFilesystem& GetEmptyFilesystem() {
   return *kFilesystem;
 }
 
-extern "C" int OpenFile(const char* filename) {
+extern "C" int CpuFeatures_OpenFile(const char* filename) {
   auto* const file = kFilesystem->FindFileOrNull(filename);
   if (file) {
     file->Open();
@@ -90,11 +90,12 @@ extern "C" int OpenFile(const char* filename) {
   return -1;
 }
 
-extern "C" void CloseFile(int file_descriptor) {
+extern "C" void CpuFeatures_CloseFile(int file_descriptor) {
   kFilesystem->FindFileOrDie(file_descriptor)->Close();
 }
 
-extern "C" int ReadFile(int file_descriptor, void* buf, size_t count) {
+extern "C" int CpuFeatures_ReadFile(int file_descriptor, void* buf,
+                                    size_t count) {
   return kFilesystem->FindFileOrDie(file_descriptor)
       ->Read(file_descriptor, buf, count);
 }

test/hwcaps_for_testing.cc

@@ -25,7 +25,7 @@ void SetHardwareCapabilities(uint32_t hwcaps, uint32_t hwcaps2) {
   g_hardware_capabilities->hwcaps2 = hwcaps2;
 }
 
-HardwareCapabilities GetHardwareCapabilities(void) {
+HardwareCapabilities CpuFeatures_GetHardwareCapabilities(void) {
   return *g_hardware_capabilities;
 }
 

test/linux_features_aggregator_test.cc

@@ -42,7 +42,8 @@ class LinuxFeatureAggregatorTest : public testing::Test {
 
 TEST_F(LinuxFeatureAggregatorTest, FromFlagsEmpty) {
   Features features;
-  SetFromFlags(kConfigs.size(), kConfigs.data(), str(""), &features);
+  CpuFeatures_SetFromFlags(kConfigs.size(), kConfigs.data(), str(""),
+                           &features);
   EXPECT_FALSE(features.a);
   EXPECT_FALSE(features.b);
   EXPECT_FALSE(features.c);
@@ -50,7 +51,8 @@ TEST_F(LinuxFeatureAggregatorTest, FromFlagsEmpty) {
 
 TEST_F(LinuxFeatureAggregatorTest, FromFlagsAllSet) {
   Features features;
-  SetFromFlags(kConfigs.size(), kConfigs.data(), str("a c b"), &features);
+  CpuFeatures_SetFromFlags(kConfigs.size(), kConfigs.data(), str("a c b"),
+                           &features);
   EXPECT_TRUE(features.a);
   EXPECT_TRUE(features.b);
   EXPECT_TRUE(features.c);
@@ -58,7 +60,8 @@ TEST_F(LinuxFeatureAggregatorTest, FromFlagsAllSet) {
 
 TEST_F(LinuxFeatureAggregatorTest, FromFlagsOnlyA) {
   Features features;
-  SetFromFlags(kConfigs.size(), kConfigs.data(), str("a"), &features);
+  CpuFeatures_SetFromFlags(kConfigs.size(), kConfigs.data(), str("a"),
+                           &features);
   EXPECT_TRUE(features.a);
   EXPECT_FALSE(features.b);
   EXPECT_FALSE(features.c);
@@ -69,7 +72,8 @@ TEST_F(LinuxFeatureAggregatorTest, FromHwcapsNone) {
   capability.hwcaps = 0;   // matches none
   capability.hwcaps2 = 0;  // matches none
   Features features;
-  OverrideFromHwCaps(kConfigs.size(), kConfigs.data(), capability, &features);
+  CpuFeatures_OverrideFromHwCaps(kConfigs.size(), kConfigs.data(), capability,
+                                 &features);
   EXPECT_FALSE(features.a);
   EXPECT_FALSE(features.b);
   EXPECT_FALSE(features.c);
@@ -80,7 +84,8 @@ TEST_F(LinuxFeatureAggregatorTest, FromHwcapsSet) {
   capability.hwcaps = 0b0010;   // matches b but not a
   capability.hwcaps2 = 0b1111;  // matches c
   Features features;
-  OverrideFromHwCaps(kConfigs.size(), kConfigs.data(), capability, &features);
+  CpuFeatures_OverrideFromHwCaps(kConfigs.size(), kConfigs.data(), capability,
+                                 &features);
   EXPECT_FALSE(features.a);
   EXPECT_TRUE(features.b);
   EXPECT_TRUE(features.c);

test/stack_line_reader_test.cc

@@ -20,7 +20,7 @@
 namespace cpu_features {
 
 bool operator==(const StringView& a, const StringView& b) {
-  return IsEquals(a, b);
+  return CpuFeatures_StringView_IsEquals(a, b);
 }
 
 namespace {

test/string_view_test.cc

@@ -19,7 +19,7 @@
 namespace cpu_features {
 
 bool operator==(const StringView& a, const StringView& b) {
-  return IsEquals(a, b);
+  return CpuFeatures_StringView_IsEquals(a, b);
 }
 
 namespace {
@@ -35,95 +35,101 @@ TEST(StringViewTest, Build) {
   EXPECT_EQ(view.size, 4);
 }
 
-TEST(StringViewTest, IndexOfChar) {
+TEST(StringViewTest, CpuFeatures_StringView_IndexOfChar) {
   // Found.
-  EXPECT_EQ(IndexOfChar(str("test"), 'e'), 1);
+  EXPECT_EQ(CpuFeatures_StringView_IndexOfChar(str("test"), 'e'), 1);
   // Not found.
-  EXPECT_EQ(IndexOfChar(str("test"), 'z'), -1);
+  EXPECT_EQ(CpuFeatures_StringView_IndexOfChar(str("test"), 'z'), -1);
   // Empty.
-  EXPECT_EQ(IndexOfChar(kEmptyStringView, 'z'), -1);
+  EXPECT_EQ(CpuFeatures_StringView_IndexOfChar(kEmptyStringView, 'z'), -1);
 }
 
-TEST(StringViewTest, IndexOf) {
+TEST(StringViewTest, CpuFeatures_StringView_IndexOf) {
   // Found.
-  EXPECT_EQ(IndexOf(str("test"), str("es")), 1);
+  EXPECT_EQ(CpuFeatures_StringView_IndexOf(str("test"), str("es")), 1);
   // Not found.
-  EXPECT_EQ(IndexOf(str("test"), str("aa")), -1);
+  EXPECT_EQ(CpuFeatures_StringView_IndexOf(str("test"), str("aa")), -1);
   // Empty.
-  EXPECT_EQ(IndexOf(kEmptyStringView, str("aa")), -1);
+  EXPECT_EQ(CpuFeatures_StringView_IndexOf(kEmptyStringView, str("aa")), -1);
-  EXPECT_EQ(IndexOf(str("aa"), kEmptyStringView), -1);
+  EXPECT_EQ(CpuFeatures_StringView_IndexOf(str("aa"), kEmptyStringView), -1);
 }
 
-TEST(StringViewTest, StartsWith) {
+TEST(StringViewTest, CpuFeatures_StringView_StartsWith) {
-  EXPECT_TRUE(StartsWith(str("test"), str("te")));
+  EXPECT_TRUE(CpuFeatures_StringView_StartsWith(str("test"), str("te")));
-  EXPECT_FALSE(StartsWith(str("test"), str("")));
+  EXPECT_FALSE(CpuFeatures_StringView_StartsWith(str("test"), str("")));
-  EXPECT_FALSE(StartsWith(str("test"), kEmptyStringView));
+  EXPECT_FALSE(
-  EXPECT_FALSE(StartsWith(kEmptyStringView, str("test")));
+      CpuFeatures_StringView_StartsWith(str("test"), kEmptyStringView));
+  EXPECT_FALSE(
+      CpuFeatures_StringView_StartsWith(kEmptyStringView, str("test")));
 }
 
-TEST(StringViewTest, IsEquals) {
+TEST(StringViewTest, CpuFeatures_StringView_IsEquals) {
-  EXPECT_TRUE(IsEquals(kEmptyStringView, kEmptyStringView));
+  EXPECT_TRUE(
-  EXPECT_TRUE(IsEquals(kEmptyStringView, str("")));
+      CpuFeatures_StringView_IsEquals(kEmptyStringView, kEmptyStringView));
-  EXPECT_TRUE(IsEquals(str(""), kEmptyStringView));
+  EXPECT_TRUE(CpuFeatures_StringView_IsEquals(kEmptyStringView, str("")));
-  EXPECT_TRUE(IsEquals(str("a"), str("a")));
+  EXPECT_TRUE(CpuFeatures_StringView_IsEquals(str(""), kEmptyStringView));
-  EXPECT_FALSE(IsEquals(str("a"), str("b")));
+  EXPECT_TRUE(CpuFeatures_StringView_IsEquals(str("a"), str("a")));
-  EXPECT_FALSE(IsEquals(str("a"), kEmptyStringView));
+  EXPECT_FALSE(CpuFeatures_StringView_IsEquals(str("a"), str("b")));
-  EXPECT_FALSE(IsEquals(kEmptyStringView, str("a")));
+  EXPECT_FALSE(CpuFeatures_StringView_IsEquals(str("a"), kEmptyStringView));
+  EXPECT_FALSE(CpuFeatures_StringView_IsEquals(kEmptyStringView, str("a")));
 }
 
-TEST(StringViewTest, PopFront) {
+TEST(StringViewTest, CpuFeatures_StringView_PopFront) {
-  EXPECT_EQ(PopFront(str("test"), 2), str("st"));
+  EXPECT_EQ(CpuFeatures_StringView_PopFront(str("test"), 2), str("st"));
-  EXPECT_EQ(PopFront(str("test"), 0), str("test"));
+  EXPECT_EQ(CpuFeatures_StringView_PopFront(str("test"), 0), str("test"));
-  EXPECT_EQ(PopFront(str("test"), 4), str(""));
+  EXPECT_EQ(CpuFeatures_StringView_PopFront(str("test"), 4), str(""));
-  EXPECT_EQ(PopFront(str("test"), 100), str(""));
+  EXPECT_EQ(CpuFeatures_StringView_PopFront(str("test"), 100), str(""));
 }
 
-TEST(StringViewTest, ParsePositiveNumber) {
+TEST(StringViewTest, CpuFeatures_StringView_ParsePositiveNumber) {
-  EXPECT_EQ(ParsePositiveNumber(str("42")), 42);
+  EXPECT_EQ(CpuFeatures_StringView_ParsePositiveNumber(str("42")), 42);
-  EXPECT_EQ(ParsePositiveNumber(str("0x2a")), 42);
+  EXPECT_EQ(CpuFeatures_StringView_ParsePositiveNumber(str("0x2a")), 42);
-  EXPECT_EQ(ParsePositiveNumber(str("0x2A")), 42);
+  EXPECT_EQ(CpuFeatures_StringView_ParsePositiveNumber(str("0x2A")), 42);
 
-  EXPECT_EQ(ParsePositiveNumber(str("-0x2A")), -1);
+  EXPECT_EQ(CpuFeatures_StringView_ParsePositiveNumber(str("-0x2A")), -1);
-  EXPECT_EQ(ParsePositiveNumber(str("abc")), -1);
+  EXPECT_EQ(CpuFeatures_StringView_ParsePositiveNumber(str("abc")), -1);
-  EXPECT_EQ(ParsePositiveNumber(str("")), -1);
+  EXPECT_EQ(CpuFeatures_StringView_ParsePositiveNumber(str("")), -1);
 }
 
-TEST(StringViewTest, CopyString) {
+TEST(StringViewTest, CpuFeatures_StringView_CopyString) {
   char buf[4];
   buf[0] = 'X';
 
   // Empty
-  CopyString(str(""), buf, sizeof(buf));
+  CpuFeatures_StringView_CopyString(str(""), buf, sizeof(buf));
   EXPECT_STREQ(buf, "");
 
   // Less
-  CopyString(str("a"), buf, sizeof(buf));
+  CpuFeatures_StringView_CopyString(str("a"), buf, sizeof(buf));
   EXPECT_STREQ(buf, "a");
 
   // exact
-  CopyString(str("abc"), buf, sizeof(buf));
+  CpuFeatures_StringView_CopyString(str("abc"), buf, sizeof(buf));
   EXPECT_STREQ(buf, "abc");
 
   // More
-  CopyString(str("abcd"), buf, sizeof(buf));
+  CpuFeatures_StringView_CopyString(str("abcd"), buf, sizeof(buf));
   EXPECT_STREQ(buf, "abc");
 }
 
-TEST(StringViewTest, HasWord) {
+TEST(StringViewTest, CpuFeatures_StringView_HasWord) {
   // Find flags at beginning, middle and end.
-  EXPECT_TRUE(HasWord(str("first middle last"), "first"));
+  EXPECT_TRUE(
-  EXPECT_TRUE(HasWord(str("first middle last"), "middle"));
+      CpuFeatures_StringView_HasWord(str("first middle last"), "first"));
-  EXPECT_TRUE(HasWord(str("first middle last"), "last"));
+  EXPECT_TRUE(
+      CpuFeatures_StringView_HasWord(str("first middle last"), "middle"));
+  EXPECT_TRUE(CpuFeatures_StringView_HasWord(str("first middle last"), "last"));
   // Do not match partial flags
-  EXPECT_FALSE(HasWord(str("first middle last"), "irst"));
+  EXPECT_FALSE(
-  EXPECT_FALSE(HasWord(str("first middle last"), "mid"));
+      CpuFeatures_StringView_HasWord(str("first middle last"), "irst"));
-  EXPECT_FALSE(HasWord(str("first middle last"), "las"));
+  EXPECT_FALSE(CpuFeatures_StringView_HasWord(str("first middle last"), "mid"));
+  EXPECT_FALSE(CpuFeatures_StringView_HasWord(str("first middle last"), "las"));
 }
 
-TEST(StringViewTest, GetAttributeKeyValue) {
+TEST(StringViewTest, CpuFeatures_StringView_GetAttributeKeyValue) {
   const StringView line = str(" key :   first middle last   ");
   StringView key, value;
-  EXPECT_TRUE(GetAttributeKeyValue(line, &key, &value));
+  EXPECT_TRUE(CpuFeatures_StringView_GetAttributeKeyValue(line, &key, &value));
   EXPECT_EQ(key, str("key"));
   EXPECT_EQ(value, str("first middle last"));
 }
@@ -131,7 +137,7 @@ TEST(StringViewTest, GetAttributeKeyValue) {
 TEST(StringViewTest, FailingGetAttributeKeyValue) {
   const StringView line = str("key  first middle last");
   StringView key, value;
-  EXPECT_FALSE(GetAttributeKeyValue(line, &key, &value));
+  EXPECT_FALSE(CpuFeatures_StringView_GetAttributeKeyValue(line, &key, &value));
 }
 
 }  // namespace