kc3-lang/SDL/visualtest/src/parsehelper.c

• Show log

  Commit

• Hash : 70438be2
  Author :
  Date : 2014-12-03T10:55:23
  

  WinRT: fixed bug whereby SDL would override an app's default orientation WinRT apps can set a default, preferred orientation via a .appxmanifest file. SDL was overriding this on app startup, and making the app use all possible orientations (landscape and portrait). Thanks to Eric Wing for the heads up on this!

Download

• visualtest/src/parsehelper.c

• /* See COPYING.txt for the full license governing this code. */
  /**
   * \file parsehelper.c
   *
   * Source file with some helper functions for parsing strings.
   */
  
  #include <SDL_test.h>
  #include "SDL_visualtest_harness_argparser.h"
  
  /* this function uses a DFA to count the number of tokens in an agruments string.
     state 0 is taken to be the start and end state. State 1 handles a double quoted
     argument and state 2 handles unquoted arguments. */
  static int
  CountTokens(char* args)
  {
      int index, num_tokens;
      int state; /* current state of the DFA */
  
      if(!args)
      	return -1;
  
      index = 0;
      state = 0;
      num_tokens = 0;
      while(args[index])
      {
          char ch = args[index];
          switch(state)
          {
              case 0:
              if(ch == '\"')
              {
                  state = 1;
                  num_tokens++;
              }
              else if(!SDL_isspace(ch))
              {
                  state = 2;
                  num_tokens++;
              }
              break;
  
              case 1:
              if(ch == '\"')
              {
                  state = 0;
              }
              break;
  
              case 2:
              if(SDL_isspace(ch))
              {
                  state = 0;
              }
              break;
          }
          index++;
      }
      return num_tokens;
  }
  
  /* - size of tokens is num_tokens + 1
  - uses the same DFA used in CountTokens() to split args into an array of strings */
  static int
  TokenizeHelper(char* str, char** tokens, int num_tokens, int max_token_len)
  {
      int index, state, done, st_index, token_index;
  
      if(!str)
      {
          SDLTest_LogError("str argument cannot be NULL");
          return 0;
      }
      if(!tokens)
      {
          SDLTest_LogError("tokens argument cannot be NULL");
          return 0;
      }
      if(num_tokens <= 0)
      {
          SDLTest_LogError("num_tokens argument must be positive");
          return 0;
      }
      if(max_token_len <= 0)
      {
          SDLTest_LogError("max_token_len argument must be positive");
          return 0;
      }
  
      /* allocate memory for the tokens */
      tokens[num_tokens] = NULL;
      for(index = 0; index < num_tokens; index++)
      {
          tokens[index] = (char*)SDL_malloc(max_token_len);
          if(!tokens[index])
          {
              int i;
              SDLTest_LogError("malloc() failed.");
              for(i = 0; i < index; i++)
                  SDL_free(tokens[i]);
              return 0;
          }
          tokens[index][0] = '\0';
      }
  
      /* copy the tokens into the array */
      st_index = 0;
      index = 0;
      token_index = 0;
      state = 0;
      done = 0;
      while(!done)
      {
          char ch = str[index];
          switch(state)
          {
              case 0:
              if(ch == '\"')
              {
                  state = 1;
                  st_index = index + 1;
              }
              else if(!ch)
                  done = 1;
              else if(ch && !SDL_isspace(ch))
              {
                  state = 2;
                  st_index = index;
              }
              break;
  
              case 1:
              if(ch == '\"')
              {
                  int i;
                  state = 0;
                  for(i = st_index; i < index; i++)
                  {
                      tokens[token_index][i - st_index] = str[i];
                  }
                  tokens[token_index][i - st_index] = '\0';
                  token_index++;
              }
              else if(!ch)
              {
                  SDLTest_LogError("Parsing Error!");
                  done = 1;
              }
              break;
  
              case 2:
              if(!ch)
                  done = 1;
              if(SDL_isspace(ch) || !ch)
              {
                  int i;
                  state = 0;
                  for(i = st_index; i < index; i++)
                  {
                      tokens[token_index][i - st_index] = str[i];
                  }
                  tokens[token_index][i - st_index] = '\0';
                  token_index++;
              }
              break;
          }
          index++;
      }
      return 1;
  }
  
  char**
  SDLVisualTest_Tokenize(char* str, int max_token_len)
  {
      int num_tokens;
      char** tokens;
  
      if(!str)
      {
          SDLTest_LogError("str argument cannot be NULL");
          return NULL;
      }
      if(max_token_len <= 0)
      {
          SDLTest_LogError("max_token_len argument must be positive");
          return NULL;
      }
  
      num_tokens = CountTokens(str);
      if(num_tokens == 0)
          return NULL;
  
      tokens = (char**)SDL_malloc(sizeof(char*) * (num_tokens + 1));
      if(!TokenizeHelper(str, tokens, num_tokens, max_token_len))
      {
          SDLTest_LogError("TokenizeHelper() failed");
          SDL_free(tokens);
          return NULL;
      }
      return tokens;
  }
  
  char**
  SDLVisualTest_ParseArgsToArgv(char* args)
  {
      char** argv;
      int num_tokens;
  
      num_tokens = CountTokens(args);
      if(num_tokens == 0)
          return NULL;
  
      /* allocate space for arguments */
      argv = (char**)SDL_malloc((num_tokens + 2) * sizeof(char*));
      if(!argv)
      {
          SDLTest_LogError("malloc() failed.");
          return NULL;
      }
  
      /* tokenize */
      if(!TokenizeHelper(args, argv + 1, num_tokens, MAX_SUT_ARGS_LEN))
      {
          SDLTest_LogError("TokenizeHelper() failed");
          SDL_free(argv);
          return NULL;
      }
      argv[0] = NULL;
      return argv;
  }
  

Download