Correct spelling of 'seperate' in the skin parsing code - FS#11724 by Alexander Levin

git-svn-id: svn://svn.rockbox.org/rockbox/trunk@28485 a1c6a512-1295-4272-9138-f99709370657

lib/skin_parser/skin_debug.c

···
     case DECIMAL_EXPECTED:
         error_message =  "Expected decimal";
         break;
-    case SEPERATOR_EXPECTED:
-        error_message = "Expected argument seperator";
+    case SEPARATOR_EXPECTED:
+        error_message = "Expected argument separator";
         break;
     case CLOSE_EXPECTED:
         error_message = "Expected list close";
         break;
     case MULTILINE_EXPECTED:
-        error_message = "Expected subline seperator";
+        error_message = "Expected subline separator";
         break;
     };
 

lib/skin_parser/skin_parser.c

···
 
 /*
  * If conditional is set to true, then this will break upon encountering
- * SEPERATESYM.  This should only be used when parsing a line inside a
+ * SEPARATESYM.  This should only be used when parsing a line inside a
  * conditional, otherwise just use the wrapper function skin_parse_line()
  */
 static struct skin_element* skin_parse_line_optional(const char** document,
···
     retval->type = LINE;
     retval->line = skin_line;
     if(*cursor != '\0' && *cursor != '\n' && *cursor != MULTILINESYM
-       && !(conditional && (*cursor == ARGLISTSEPERATESYM
+       && !(conditional && (*cursor == ARGLISTSEPARATESYM
                             || *cursor == ARGLISTCLOSESYM
-                            || *cursor == ENUMLISTSEPERATESYM
+                            || *cursor == ENUMLISTSEPARATESYM
                             || *cursor == ENUMLISTCLOSESYM)))
     {
         retval->children_count = 1;
···
 #endif
 
     while(*cursor != '\n' && *cursor != '\0' && *cursor != MULTILINESYM
-          && !((*cursor == ARGLISTSEPERATESYM
+          && !((*cursor == ARGLISTSEPARATESYM
                 || *cursor == ARGLISTCLOSESYM
-                || *cursor == ENUMLISTSEPERATESYM
+                || *cursor == ENUMLISTSEPARATESYM
                 || *cursor == ENUMLISTCLOSESYM)
                && conditional)
           && !(check_viewport(cursor) && cursor != *document))
···
 
     /* First we count the sublines */
     while(*cursor != '\0' && *cursor != '\n'
-          && !((*cursor == ARGLISTSEPERATESYM
+          && !((*cursor == ARGLISTSEPARATESYM
                 || *cursor == ARGLISTCLOSESYM
-                || *cursor == ENUMLISTSEPERATESYM
+                || *cursor == ENUMLISTSEPARATESYM
                 || *cursor == ENUMLISTCLOSESYM)
                && conditional)
           && !(check_viewport(cursor) && cursor != *document))
···
         {
             skip_arglist(&cursor);
         }
-        else if(*cursor == ARGLISTSEPERATESYM)
+        else if(*cursor == ARGLISTSEPARATESYM)
         {
             num_args++;
             cursor++;
···
 
         skip_whitespace(&cursor);
 
-        if(*cursor != ARGLISTSEPERATESYM && i < num_args - 1)
+        if(*cursor != ARGLISTSEPARATESYM && i < num_args - 1)
         {
-            skin_error(SEPERATOR_EXPECTED, cursor);
+            skin_error(SEPARATOR_EXPECTED, cursor);
             return 0;
         }
         else if(*cursor != ARGLISTCLOSESYM && i == num_args - 1)
···
 
 /*
  * If the conditional flag is set true, then parsing text will stop at an
- * ARGLISTSEPERATESYM.  Only set that flag when parsing within a conditional
+ * ARGLISTSEPARATESYM.  Only set that flag when parsing within a conditional
  */
 static int skin_parse_text(struct skin_element* element, const char** document,
                            int conditional)
···
     /* First figure out how much text we're copying */
     while(*cursor != '\0' && *cursor != '\n' && *cursor != MULTILINESYM
           && *cursor != COMMENTSYM
-          && !((*cursor == ARGLISTSEPERATESYM
+          && !((*cursor == ARGLISTSEPARATESYM
                 || *cursor == ARGLISTCLOSESYM
-                || *cursor == ENUMLISTSEPERATESYM
+                || *cursor == ENUMLISTSEPARATESYM
                 || *cursor == ENUMLISTCLOSESYM)
                && conditional))
     {
···
                 break;
             cursor++;
         }
-        else if(*cursor == ENUMLISTSEPERATESYM)
+        else if(*cursor == ENUMLISTSEPARATESYM)
         {
             children++;
             cursor++;
···
             cursor = conditional_end;
 #endif
 
-        if(i < children - 1 && *cursor != ENUMLISTSEPERATESYM)
+        if(i < children - 1 && *cursor != ENUMLISTSEPARATESYM)
         {
-            skin_error(SEPERATOR_EXPECTED, cursor);
+            skin_error(SEPARATOR_EXPECTED, cursor);
             return 0;
         }
         else if(i == children - 1 && *cursor != ENUMLISTCLOSESYM)
···
 
     /* Checking for sublines */
     while(*cursor != '\n' && *cursor != '\0'
-          && *cursor != ENUMLISTSEPERATESYM && *cursor != ARGLISTSEPERATESYM
+          && *cursor != ENUMLISTSEPARATESYM && *cursor != ARGLISTSEPARATESYM
           && *cursor != ENUMLISTCLOSESYM && *cursor != ARGLISTCLOSESYM)
     {
         if(*cursor == MULTILINESYM)

lib/skin_parser/skin_parser.h

···
     INSUFFICIENT_ARGS,
     INT_EXPECTED,
     DECIMAL_EXPECTED,
-    SEPERATOR_EXPECTED,
+    SEPARATOR_EXPECTED,
     CLOSE_EXPECTED,
     MULTILINE_EXPECTED
 };

lib/skin_parser/skin_scan.c

···
     char* buffer = NULL;
     int i;
 
-    while(*cursor != ARGLISTSEPERATESYM && *cursor != ARGLISTCLOSESYM &&
+    while(*cursor != ARGLISTSEPARATESYM && *cursor != ARGLISTCLOSESYM &&
           *cursor != '\0')
     {
         if(*cursor == COMMENTSYM)

lib/skin_parser/symbols.h

···
 #define MULTILINESYM ';'
 #define ARGLISTOPENSYM '('
 #define ARGLISTCLOSESYM ')'
-#define ARGLISTSEPERATESYM ','
-#define ENUMLISTSEPERATESYM '|'
+#define ARGLISTSEPARATESYM ','
+#define ENUMLISTSEPARATESYM '|'
 #define ENUMLISTOPENSYM '<'
 #define ENUMLISTCLOSESYM '>'
 #define DEFAULTSYM '-'