fixed comment

[rocksndiamonds.git] / src / libgame / misc.c

diff --git a/src/libgame/misc.c b/src/libgame/misc.c
index 536d90b53816d3b4ab11e26f28ed0f54edd9842e..264b7f8d9af49b2f9e410f0f4a0e42b62cd9fe71 100644 (file)
--- a/src/libgame/misc.c
+++ b/src/libgame/misc.c
@@ -620,12 +620,12 @@ static unsigned int mainCounter(int mode)
   return current_ms - base_ms;
 }
 
-void InitCounter()             // set counter back to zero
+void InitCounter(void)         // set counter back to zero
 {
   mainCounter(INIT_COUNTER);
 }
 
-unsigned int Counter() // get milliseconds since last call of InitCounter()
+unsigned int Counter(void)     // get milliseconds since last call of InitCounter()
 {
   return mainCounter(READ_COUNTER);
 }
@@ -1084,6 +1084,24 @@ char *getBasePath(char *filename)
 }
 
 
+// ----------------------------------------------------------------------------
+// various memory functions
+// ----------------------------------------------------------------------------
+
+void *getMemCopy(const void *m, size_t size)
+{
+  void *m_copy;
+
+  if (m == NULL)
+    return NULL;
+
+  m_copy = checked_malloc(size);
+  memcpy(m_copy, m, size);
+
+  return m_copy;
+}
+
+
 // ----------------------------------------------------------------------------
 // various string functions
 // ----------------------------------------------------------------------------
@@ -1220,6 +1238,18 @@ char *getStringCopyNStatic(const char *s, int n)
   return s_copy;
 }
 
+char *getStringToUpper(const char *s)
+{
+  char *s_copy = checked_malloc(strlen(s) + 1);
+  char *s_ptr = s_copy;
+
+  while (*s)
+    *s_ptr++ = toupper(*s++);
+  *s_ptr = '\0';
+
+  return s_copy;
+}
+
 char *getStringToLower(const char *s)
 {
   char *s_copy = checked_malloc(strlen(s) + 1);
@@ -1239,6 +1269,178 @@ void setString(char **old_value, const char *new_value)
   *old_value = getStringCopy(new_value);
 }
 
+char **getSplitStringArray(const char *s, const char *separators, int max_tokens)
+{
+  const char *s_ptr, *s_last = s;
+  byte separator_table[256] = { FALSE };
+  int num_tokens;
+  char **tokens = NULL;
+
+  if (s == NULL)
+    return NULL;
+
+  if (separators == NULL)
+    return NULL;
+
+  if (max_tokens < 1)
+    max_tokens = INT_MAX;
+
+  // if string is empty, return empty array
+  if (*s == '\0')
+  {
+    tokens = checked_malloc(sizeof(char *));
+    tokens[0] = NULL;
+
+    return tokens;
+  }
+
+  // initialize separator table for all characters in separators string
+  for (s_ptr = separators; *s_ptr != '\0'; s_ptr++)
+    separator_table[*(byte *)s_ptr] = TRUE;
+
+  // count number of tokens in string
+  for (num_tokens = 1, s_ptr = s; *s_ptr != '\0'; s_ptr++)
+    if (separator_table[*(byte *)s_ptr] && num_tokens < max_tokens)
+      num_tokens++;
+
+  // allocate array for determined number of tokens
+  tokens = checked_malloc((num_tokens + 1) * sizeof(char *));
+
+  // copy all but last separated sub-strings to array
+  for (num_tokens = 0, s_ptr = s; *s_ptr != '\0'; s_ptr++)
+  {
+    if (separator_table[*(byte *)s_ptr] && num_tokens + 1 < max_tokens)
+    {
+      tokens[num_tokens++] = getStringCopyN(s_last, s_ptr - s_last);
+      s_last = s_ptr + 1;
+    }
+  }
+
+  // copy last separated sub-string to array
+  tokens[num_tokens++] = getStringCopyN(s_last, s_ptr - s_last);
+
+  // terminate array
+  tokens[num_tokens] = NULL;
+
+  return tokens;
+}
+
+int getStringArrayLength(char **s_array)
+{
+  int num_strings = 0;
+
+  if (s_array == NULL)
+    return 0;
+
+  while (s_array[num_strings] != NULL)
+    num_strings++;
+
+  return num_strings;
+}
+
+void freeStringArray(char **s_array)
+{
+  int i;
+
+  if (s_array == NULL)
+    return;
+
+  for (i = 0; s_array[i] != NULL; i++)
+    checked_free(s_array[i]);
+
+  checked_free(s_array);
+}
+
+char *getUnescapedString(const char *s)
+{
+  const char *s_ptr = s;
+  const char *octal_ptr;
+  char *s_unescaped;
+  char *s_unescaped_ptr;
+
+  if (s == NULL)
+    return NULL;
+
+  s_unescaped = checked_malloc(strlen(s) + 1);
+  s_unescaped_ptr = s_unescaped;
+
+  while (*s_ptr != '\0')
+  {
+    if (*s_ptr == '\\')
+    {
+      s_ptr++;
+
+      switch (*s_ptr)
+      {
+       case '\0':
+         Warn("getUnescapedString: trailing \\");
+         goto out;
+
+       case '0':
+       case '1':
+       case '2':
+       case '3':
+       case '4':
+       case '5':
+       case '6':
+       case '7':
+         *s_unescaped_ptr = 0;
+         octal_ptr = s_ptr;
+
+         while (s_ptr < octal_ptr + 3 && *s_ptr >= '0' && *s_ptr <= '7')
+         {
+           *s_unescaped_ptr = (*s_unescaped_ptr * 8) + (*s_ptr - '0');
+           s_ptr++;
+         }
+
+         s_unescaped_ptr++;
+         s_ptr--;
+         break;
+
+       case 'b':
+         *s_unescaped_ptr++ = '\b';
+         break;
+
+       case 'f':
+         *s_unescaped_ptr++ = '\f';
+         break;
+
+       case 'n':
+         *s_unescaped_ptr++ = '\n';
+         break;
+
+       case 'r':
+         *s_unescaped_ptr++ = '\r';
+         break;
+
+       case 't':
+         *s_unescaped_ptr++ = '\t';
+         break;
+
+       case 'v':
+         *s_unescaped_ptr++ = '\v';
+         break;
+
+       default:
+         /* also handles \" and \\ */
+         *s_unescaped_ptr++ = *s_ptr;
+         break;
+      }
+    }
+    else
+    {
+      *s_unescaped_ptr++ = *s_ptr;
+    }
+
+    s_ptr++;
+  }
+
+ out:
+  *s_unescaped_ptr = '\0';
+
+  return s_unescaped;
+}
+
 boolean strEqual(const char *s1, const char *s2)
 {
   return (s1 == NULL && s2 == NULL ? TRUE  :