/*
** $Id: lstrlib.c,v 1.132.1.5 2010/05/14 15:34:19 roberto Exp $
** Standard library for string operations and pattern-matching
** See Copyright Notice in lua.h
*/


#include <ctype.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define lstrlib_c
#define LUA_LIB

#include "lua.h"

#include "lauxlib.h"
#include "lualib.h"


/* macro to `unsign' a character */
#define uchar(c)        ((unsigned char)(c))



static int str_len (lua_State *L) {
  size_t l;
  luaL_checklstring(L, 1, &l);
  lua_pushinteger(L, l);
  return 1;
}


static ptrdiff_t posrelat (ptrdiff_t pos, size_t len) {
  /* relative string position: negative means back from end */
  if (pos < 0) pos += (ptrdiff_t)len + 1;
  return (pos >= 0) ? pos : 0;
}


static int str_sub (lua_State *L) {
  size_t l;
  const char *s = luaL_checklstring(L, 1, &l);
  ptrdiff_t start = posrelat(luaL_checkinteger(L, 2), l);
  ptrdiff_t end = posrelat(luaL_optinteger(L, 3, -1), l);
  if (start < 1) start = 1;
  if (end > (ptrdiff_t)l) end = (ptrdiff_t)l;
  if (start <= end)
    lua_pushlstring(L, s+start-1, end-start+1);
  else lua_pushliteral(L, "");
  return 1;
}


static int str_reverse (lua_State *L) {
  size_t l;
  luaL_Buffer b;
  const char *s = luaL_checklstring(L, 1, &l);
  luaL_buffinit(L, &b);
  while (l--) luaL_addchar(&b, s[l]);
  luaL_pushresult(&b);
  return 1;
}


static int str_lower (lua_State *L) {
  size_t l;
  size_t i;
  luaL_Buffer b;
  const char *s = luaL_checklstring(L, 1, &l);
  luaL_buffinit(L, &b);
  for (i=0; i<l; i++)
    luaL_addchar(&b, tolower(uchar(s[i])));
  luaL_pushresult(&b);
  return 1;
}


static int str_upper (lua_State *L) {
  size_t l;
  size_t i;
  luaL_Buffer b;
  const char *s = luaL_checklstring(L, 1, &l);
  luaL_buffinit(L, &b);
  for (i=0; i<l; i++)
    luaL_addchar(&b, toupper(uchar(s[i])));
  luaL_pushresult(&b);
  return 1;
}

static int str_rep (lua_State *L) {
  size_t l;
  luaL_Buffer b;
  const char *s = luaL_checklstring(L, 1, &l);
  int n = luaL_checkint(L, 2);
  luaL_buffinit(L, &b);
  while (n-- > 0)
    luaL_addlstring(&b, s, l);
  luaL_pushresult(&b);
  return 1;
}


static int str_byte (lua_State *L) {
  size_t l;
  const char *s = luaL_checklstring(L, 1, &l);
  ptrdiff_t posi = posrelat(luaL_optinteger(L, 2, 1), l);
  ptrdiff_t pose = posrelat(luaL_optinteger(L, 3, posi), l);
  int n, i;
  if (posi <= 0) posi = 1;
  if ((size_t)pose > l) pose = l;
  if (posi > pose) return 0;  /* empty interval; return no values */
  n = (int)(pose -  posi + 1);
  if (posi + n <= pose)  /* overflow? */
    luaL_error(L, "string slice too long");
  luaL_checkstack(L, n, "string slice too long");
  for (i=0; i<n; i++)
    lua_pushinteger(L, uchar(s[posi+i-1]));
  return n;
}


static int str_char (lua_State *L) {
  int n = lua_gettop(L);  /* number of arguments */
  int i;
  luaL_Buffer b;
  luaL_buffinit(L, &b);
  for (i=1; i<=n; i++) {
    int c = luaL_checkint(L, i);
    luaL_argcheck(L, uchar(c) == c, i, "invalid value");
    luaL_addchar(&b, uchar(c));
  }
  luaL_pushresult(&b);
  return 1;
}


static int writer (lua_State *L, const void* b, size_t size, void* B) {
  (void)L;
  luaL_addlstring((luaL_Buffer*) B, (const char *)b, size);
  return 0;
}


static int str_dump (lua_State *L) {
  luaL_Buffer b;
  luaL_checktype(L, 1, LUA_TFUNCTION);
  lua_settop(L, 1);
  luaL_buffinit(L,&b);
  if (lua_dump(L, writer, &b) != 0)
    luaL_error(L, "unable to dump given function");
  luaL_pushresult(&b);
  return 1;
}



/*
** {======================================================
** PATTERN MATCHING
** =======================================================
*/


#define CAP_UNFINISHED	(-1)
#define CAP_POSITION	(-2)

typedef struct MatchState {
  const char *src_init;  /* init of source string */
  const char *src_end;  /* end (`\0') of source string */
  lua_State *L;
  int level;  /* total number of captures (finished or unfinished) */
  struct {
    const char *init;
    ptrdiff_t len;
  } capture[LUA_MAXCAPTURES];
} MatchState;


#define L_ESC		'%'
#define SPECIALS	"^$*+?.([%-"


static int check_capture (MatchState *ms, int l) {
  l -= '1';
  if (l < 0 || l >= ms->level || ms->capture[l].len == CAP_UNFINISHED)
    return luaL_error(ms->L, "invalid capture index");
  return l;
}


static int capture_to_close (MatchState *ms) {
  int level = ms->level;
  for (level--; level>=0; level--)
    if (ms->capture[level].len == CAP_UNFINISHED) return level;
  return luaL_error(ms->L, "invalid pattern capture");
}


static const char *classend (MatchState *ms, const char *p) {
  switch (*p++) {
    case L_ESC: {
      if (*p == '\0')
        luaL_error(ms->L, "malformed pattern (ends with " LUA_QL("%%") ")");
      return p+1;
    }
    case '[': {
      if (*p == '^') p++;
      do {  /* look for a `]' */
        if (*p == '\0')
          luaL_error(ms->L, "malformed pattern (missing " LUA_QL("]") ")");
        if (*(p++) == L_ESC && *p != '\0')
          p++;  /* skip escapes (e.g. `%]') */
      } while (*p != ']');
      return p+1;
    }
    default: {
      return p;
    }
  }
}


static int match_class (int c, int cl) {
  int res;
  switch (tolower(cl)) {
    case 'a' : res = isalpha(c); break;
    case 'c' : res = iscntrl(c); break;
    case 'd' : res = isdigit(c); break;
    case 'l' : res = islower(c); break;
    case 'p' : res = ispunct(c); break;
    case 's' : res = isspace(c); break;
    case 'u' : res = isupper(c); break;
    case 'w' : res = isalnum(c); break;
    case 'x' : res = isxdigit(c); break;
    case 'z' : res = (c == 0); break;
    default: return (cl == c);
  }
  return (islower(cl) ? res : !res);
}


static int matchbracketclass (int c, const char *p, const char *ec) {
  int sig = 1;
  if (*(p+1) == '^') {
    sig = 0;
    p++;  /* skip the `^' */
  }
  while (++p < ec) {
    if (*p == L_ESC) {
      p++;
      if (match_class(c, uchar(*p)))
        return sig;
    }
    else if ((*(p+1) == '-') && (p+2 < ec)) {
      p+=2;
      if (uchar(*(p-2)) <= c && c <= uchar(*p))
        return sig;
    }
    else if (uchar(*p) == c) return sig;
  }
  return !sig;
}


static int singlematch (int c, const char *p, const char *ep) {
  switch (*p) {
    case '.': return 1;  /* matches any char */
    case L_ESC: return match_class(c, uchar(*(p+1)));
    case '[': return matchbracketclass(c, p, ep-1);
    default:  return (uchar(*p) == c);
  }
}


static const char *match (MatchState *ms, const char *s, const char *p);


static const char *matchbalance (MatchState *ms, const char *s,
                                   const char *p) {
  if (*p == 0 || *(p+1) == 0)
    luaL_error(ms->L, "unbalanced pattern");
  if (*s != *p) return NULL;
  else {
    int b = *p;
    int e = *(p+1);
    int cont = 1;
    while (++s < ms->src_end) {
      if (*s == e) {
        if (--cont == 0) return s+1;
      }
      else if (*s == b) cont++;
    }
  }
  return NULL;  /* string ends out of balance */
}


static const char *max_expand (MatchState *ms, const char *s,
                                 const char *p, const char *ep) {
  ptrdiff_t i = 0;  /* counts maximum expand for item */
  while ((s+i)<ms->src_end && singlematch(uchar(*(s+i)), p, ep))
    i++;
  /* keeps trying to match with the maximum repetitions */
  while (i>=0) {
    const char *res = match(ms, (s+i), ep+1);
    if (res) return res;
    i--;  /* else didn't match; reduce 1 repetition to try again */
  }
  return NULL;
}


static const char *min_expand (MatchState *ms, const char *s,
                                 const char *p, const char *ep) {
  for (;;) {
    const char *res = match(ms, s, ep+1);
    if (res != NULL)
      return res;
    else if (s<ms->src_end && singlematch(uchar(*s), p, ep))
      s++;  /* try with one more repetition */
    else return NULL;
  }
}


static const char *start_capture (MatchState *ms, const char *s,
                                    const char *p, int what) {
  const char *res;
  int level = ms->level;
  if (level >= LUA_MAXCAPTURES) luaL_error(ms->L, "too many captures");
  ms->capture[level].init = s;
  ms->capture[level].len = what;
  ms->level = level+1;
  if ((res=match(ms, s, p)) == NULL)  /* match failed? */
    ms->level--;  /* undo capture */
  return res;
}


static const char *end_capture (MatchState *ms, const char *s,
                                  const char *p) {
  int l = capture_to_close(ms);
  const char *res;
  ms->capture[l].len = s - ms->capture[l].init;  /* close capture */
  if ((res = match(ms, s, p)) == NULL)  /* match failed? */
    ms->capture[l].len = CAP_UNFINISHED;  /* undo capture */
  return res;
}


static const char *match_capture (MatchState *ms, const char *s, int l) {
  size_t len;
  l = check_capture(ms, l);
  len = ms->capture[l].len;
  if ((size_t)(ms->src_end-s) >= len &&
      memcmp(ms->capture[l].init, s, len) == 0)
    return s+len;
  else return NULL;
}


static const char *match (MatchState *ms, const char *s, const char *p) {
  init: /* using goto's to optimize tail recursion */
  switch (*p) {
    case '(': {  /* start capture */
      if (*(p+1) == ')')  /* position capture? */
        return start_capture(ms, s, p+2, CAP_POSITION);
      else
        return start_capture(ms, s, p+1, CAP_UNFINISHED);
    }
    case ')': {  /* end capture */
      return end_capture(ms, s, p+1);
    }
    case L_ESC: {
      switch (*(p+1)) {
        case 'b': {  /* balanced string? */
          s = matchbalance(ms, s, p+2);
          if (s == NULL) return NULL;
          p+=4; goto init;  /* else return match(ms, s, p+4); */
        }
        case 'f': {  /* frontier? */
          const char *ep; char previous;
          p += 2;
          if (*p != '[')
            luaL_error(ms->L, "missing " LUA_QL("[") " after "
                               LUA_QL("%%f") " in pattern");
          ep = classend(ms, p);  /* points to what is next */
          previous = (s == ms->src_init) ? '\0' : *(s-1);
          if (matchbracketclass(uchar(previous), p, ep-1) ||
             !matchbracketclass(uchar(*s), p, ep-1)) return NULL;
          p=ep; goto init;  /* else return match(ms, s, ep); */
        }
        default: {
          if (isdigit(uchar(*(p+1)))) {  /* capture results (%0-%9)? */
            s = match_capture(ms, s, uchar(*(p+1)));
            if (s == NULL) return NULL;
            p+=2; goto init;  /* else return match(ms, s, p+2) */
          }
          goto dflt;  /* case default */
        }
      }
    }
    case '\0': {  /* end of pattern */
      return s;  /* match succeeded */
    }
    case '$': {
      if (*(p+1) == '\0')  /* is the `$' the last char in pattern? */
        return (s == ms->src_end) ? s : NULL;  /* check end of string */
      else goto dflt;
    }
    default: dflt: {  /* it is a pattern item */
      const char *ep = classend(ms, p);  /* points to what is next */
      int m = s<ms->src_end && singlematch(uchar(*s), p, ep);
      switch (*ep) {
        case '?': {  /* optional */
          const char *res;
          if (m && ((res=match(ms, s+1, ep+1)) != NULL))
            return res;
          p=ep+1; goto init;  /* else return match(ms, s, ep+1); */
        }
        case '*': {  /* 0 or more repetitions */
          return max_expand(ms, s, p, ep);
        }
        case '+': {  /* 1 or more repetitions */
          return (m ? max_expand(ms, s+1, p, ep) : NULL);
        }
        case '-': {  /* 0 or more repetitions (minimum) */
          return min_expand(ms, s, p, ep);
        }
        default: {
          if (!m) return NULL;
          s++; p=ep; goto init;  /* else return match(ms, s+1, ep); */
        }
      }
    }
  }
}



static const char *lmemfin<span class="hl com">/*</span>
<span class="hl com">Minetest</span>
<span class="hl com">Copyright (C) 2013 celeron55, Perttu Ahola &lt;celeron55&#64;gmail.com&gt;</span>
<span class="hl com"></span>
<span class="hl com">This program is free software; you can redistribute it and/or modify</span>
<span class="hl com">it under the terms of the GNU Lesser General Public License as published by</span>
<span class="hl com">the Free Software Foundation; either version 2.1 of the License, or</span>
<span class="hl com">(at your option) any later version.</span>
<span class="hl com"></span>
<span class="hl com">This program is distributed in the hope that it will be useful,</span>
<span class="hl com">but WITHOUT ANY WARRANTY; without even the implied warranty of</span>
<span class="hl com">MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the</span>
<span class="hl com">GNU Lesser General Public License for more details.</span>
<span class="hl com"></span>
<span class="hl com">You should have received a copy of the GNU Lesser General Public License along</span>
<span class="hl com">with this program; if not, write to the Free Software Foundation, Inc.,</span>
<span class="hl com">51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.</span>
<span class="hl com">*/</span>

<span class="hl ppc">#include</span> <span class="hl pps">&quot;test.h&quot;</span><span class="hl ppc"></span>

<span class="hl ppc">#include &lt;sstream&gt;</span>

<span class="hl ppc">#include</span> <span class="hl pps">&quot;log.h&quot;</span><span class="hl ppc"></span>
<span class="hl ppc">#include</span> <span class="hl pps">&quot;serialization.h&quot;</span><span class="hl ppc"></span>
<span class="hl ppc">#include</span> <span class="hl pps">&quot;nodedef.h&quot;</span><span class="hl ppc"></span>
<span class="hl ppc">#include</span> <span class="hl pps">&quot;noise.h&quot;</span><span class="hl ppc"></span>

<span class="hl kwc">class</span> TestFilePath <span class="hl opt">:</span> <span class="hl kwc">public</span> TestBase <span class="hl opt">{</span>
<span class="hl kwc">public</span><span class="hl opt">:</span>
	<span class="hl kwd">TestFilePath</span><span class="hl opt">() {</span> <span class="hl kwc">TestManager</span><span class="hl opt">::</span><span class="hl kwd">registerTestModule</span><span class="hl opt">(</span><span class="hl kwa">this</span><span class="hl opt">); }</span>
	<span class="hl kwb">const char</span> <span class="hl opt">*</span><span class="hl kwd">getName</span><span class="hl opt">() {</span> <span class="hl kwa">return</span> <span class="hl str">&quot;TestFilePath&quot;</span><span class="hl opt">; }</span>

	<span class="hl kwb">void</span> <span class="hl kwd">runTests</span><span class="hl opt">(</span>IGameDef <span class="hl opt">*</span>gamedef<span class="hl opt">);</span>

	<span class="hl kwb">void</span> <span class="hl kwd">testIsDirDelimiter</span><span class="hl opt">();</span>
	<span class="hl kwb">void</span> <span class="hl kwd">testPathStartsWith</span><span class="hl opt">();</span>
	<span class="hl kwb">void</span> <span class="hl kwd">testRemoveLastPathComponent</span><span class="hl opt">();</span>
	<span class="hl kwb">void</span> <span class="hl kwd">testRemoveLastPathComponentWithTrailingDelimiter</span><span class="hl opt">();</span>
	<span class="hl kwb">void</span> <span class="hl kwd">testRemoveRelativePathComponent</span><span class="hl opt">();</span>
<span class="hl opt">};</span>

<span class="hl kwb">static</span> TestFilePath g_test_instance<span class="hl opt">;</span>

<span class="hl kwb">void</span> <span class="hl kwc">TestFilePath</span><span class="hl opt">::</span><span class="hl kwd">runTests</span><span class="hl opt">(</span>IGameDef <span class="hl opt">*</span>gamedef<span class="hl opt">)</span>
<span class="hl opt">{</span>
	<span class="hl kwd">TEST</span><span class="hl opt">(</span>testIsDirDelimiter<span class="hl opt">);</span>
	<span class="hl kwd">TEST</span><span class="hl opt">(</span>testPathStartsWith<span class="hl opt">);</span>
	<span class="hl kwd">TEST</span><span class="hl opt">(</span>testRemoveLastPathComponent<span class="hl opt">);</span>
	<span class="hl kwd">TEST</span><span class="hl opt">(</span>testRemoveLastPathComponentWithTrailingDelimiter<span class="hl opt">);</span>
	<span class="hl kwd">TEST</span><span class="hl opt">(</span>testRemoveRelativePathComponent<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl slc">////////////////////////////////////////////////////////////////////////////////</span>

<span class="hl slc">// adjusts a POSIX path to system-specific conventions</span>
<span class="hl slc">// -&gt; changes &apos;/&apos; to DIR_DELIM</span>
<span class="hl slc">// -&gt; absolute paths start with &quot;C:\\&quot; on windows</span>
<span class="hl kwc">std</span><span class="hl opt">::</span>string <span class="hl kwd">p</span><span class="hl opt">(</span><span class="hl kwc">std</span><span class="hl opt">::</span>string path<span class="hl opt">)</span>
<span class="hl opt">{</span>
	<span class="hl kwa">for</span> <span class="hl opt">(</span><span class="hl kwb">size_t</span> i <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span> i <span class="hl opt">&lt;</span> path<span class="hl opt">.</span><span class="hl kwd">size</span><span class="hl opt">(); ++</span>i<span class="hl opt">) {</span>
		<span class="hl kwa">if</span> <span class="hl opt">(</span>path<span class="hl opt">[</span>i<span class="hl opt">] ==</span> <span class="hl str">&apos;/&apos;</span><span class="hl opt">) {</span>
			path<span class="hl opt">.</span><span class="hl kwd">replace</span><span class="hl opt">(</span>i<span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">,</span> DIR_DELIM<span class="hl opt">);</span>
			i <span class="hl opt">+=</span> <span class="hl kwc">std</span><span class="hl opt">::</span><span class="hl kwd">string</span><span class="hl opt">(</span>DIR_DELIM<span class="hl opt">).</span><span class="hl kwd">size</span><span class="hl opt">() -</span> <span class="hl num">1</span><span class="hl opt">;</span> <span class="hl slc">// generally a no-op</span>
		<span class="hl opt">}</span>
	<span class="hl opt">}</span>

	<span class="hl ppc">#ifdef _WIN32</span>
	<span class="hl kwa">if</span> <span class="hl opt">(</span>path<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">] ==</span> <span class="hl str">&apos;</span><span class="hl esc">\\</span><span class="hl str">&apos;</span><span class="hl opt">)</span>
		path <span class="hl opt">=</span> <span class="hl str">&quot;C:&quot;</span> <span class="hl opt">+</span> path<span class="hl opt">;</span>
	<span class="hl ppc">#endif</span>

	<span class="hl kwa">return</span> path<span class="hl opt">;</span>
<span class="hl opt">}</span>


<span class="hl kwb">void</span> <span class="hl kwc">TestFilePath</span><span class="hl opt">::</span><span class="hl kwd">testIsDirDelimiter</span><span class="hl opt">()</span>
<span class="hl opt">{</span>
	<span class="hl kwd">UASSERT</span><span class="hl opt">(</span><span class="hl kwc">fs</span><span class="hl opt">::</span><span class="hl kwd">IsDirDelimiter</span><span class="hl opt">(</span><span class="hl str">&apos;/&apos;</span><span class="hl opt">) ==</span> <span class="hl kwa">true</span><span class="hl opt">);</span>
	<span class="hl kwd">UASSERT</span><span class="hl opt">(</span><span class="hl kwc">fs</span><span class="hl opt">::</span><span class="hl kwd">IsDirDelimiter</span><span class="hl opt">(</span><span class="hl str">&apos;A&apos;</span><span class="hl opt">) ==</span> <span class="hl kwa">false</span><span class="hl opt">);</span>
	<span class="hl kwd">UASSERT</span><span class="hl opt">(</span><span class="hl kwc">fs</span><span class="hl opt">::</span><span class="hl kwd">IsDirDelimiter</span><span class="hl opt">(</span><span class="hl num">0</span><span class="hl opt">) ==</span> <span class="hl kwa">false</span><span class="hl opt">);</span>
<span class="hl ppc">#ifdef _WIN32</span>
	<span class="hl kwd">UASSERT</span><span class="hl opt">(</span><span class="hl kwc">fs</span><span class="hl opt">::</span><span class="hl kwd">IsDirDelimiter</span><span class="hl opt">(</span><span class="hl str">&apos;</span><span class="hl esc">\\</span><span class="hl str">&apos;</span><span class="hl opt">) ==</span> <span class="hl kwa">true</span><span class="hl opt">);</span>
<span class="hl ppc">#else</span>
	<span class="hl kwd">UASSERT</span><span class="hl opt">(</span><span class="hl kwc">fs</span><span class="hl opt">::</span><span class="hl kwd">IsDirDelimiter</span><span class="hl opt">(</span><span class="hl str">&apos;</span><span class="hl esc">\\</span><span class="hl str">&apos;</span><span class="hl opt">) ==</span> <span class="hl kwa">false</span><span class="hl opt">);</span>
<span class="hl ppc">#endif</span>
<span class="hl opt">}</span>


<span class="hl kwb">void</span> <span class="hl kwc">TestFilePath</span><span class="hl opt">::</span><span class="hl kwd">testPathStartsWith</span><span class="hl opt">()</span>
<span class="hl opt">{</span>
	<span class="hl kwb">const int</span> numpaths <span class="hl opt">=</span> <span class="hl num">12</span><span class="hl opt">;</span>
	<span class="hl kwc">std</span><span class="hl opt">::</span>string paths<span class="hl opt">[</span>numpaths<span class="hl opt">] = {</span>
		<span class="hl str">&quot;&quot;</span><span class="hl opt">,</span>
		<span class="hl kwd">p</span><span class="hl opt">(</span><span class="hl str">&quot;/&quot;</span><span class="hl opt">),</span>
		<span class="hl kwd">p</span><span class="hl opt">(</span><span class="hl str">&quot;/home/user/minetest&quot;</span><span class="hl opt">),</span>
		<span class="hl kwd">p</span><span class="hl opt">(</span><span class="hl str">&quot;/home/user/minetest/bin&quot;</span><span class="hl opt">),</span>
		<span class="hl kwd">p</span><span class="hl opt">(</span><span class="hl str">&quot;/home/user/.minetest&quot;</span><span class="hl opt">),</span>
		<span class="hl kwd">p</span><span class="hl opt">(</span><span class="hl str">&quot;/tmp/dir/file&quot;</span><span class="hl opt">),</span>
		<span class="hl kwd">p</span><span class="hl opt">(</span><span class="hl str">&quot;/tmp/file/&quot;</span><span class="hl opt">),</span>
		<span class="hl kwd">p</span><span class="hl opt">(</span><span class="hl str">&quot;/tmP/file&quot;</span><span class="hl opt">),</span>
		<span class="hl kwd">p</span><span class="hl opt">(</span><span class="hl str">&quot;/tmp&quot;</span><span class="hl opt">),</span>
		<span class="hl kwd">p</span><span class="hl opt">(</span><span class="hl str">&quot;/tmp/dir&quot;</span><span class="hl opt">),</span>
		<span class="hl kwd">p</span><span class="hl opt">(</span><span class="hl str">&quot;/home/user2/minetest/worlds&quot;</span><span class="hl opt">),</span>
		<span class="hl kwd">p</span><span class="hl opt">(</span><span class="hl str">&quot;/home/user2/minetest/world&quot;</span><span class="hl opt">),</span>
	<span class="hl opt">};</span>
	<span class="hl com">/*</span>
<span class="hl com">		expected fs::PathStartsWith results</span>
<span class="hl com">		0 = returns false</span>
<span class="hl com">		1 = returns true</span>
<span class="hl com">		2 = returns false on windows, true elsewhere</span>
<span class="hl com">		3 = returns true on windows, false elsewhere</span>
<span class="hl com">		4 = returns true if and only if</span>
<span class="hl com">			FILESYS_CASE_INSENSITIVE is true</span>
<span class="hl com">	*/</span>
	<span class="hl kwb">int</span> expected_results<span class="hl opt">[</span>numpaths<span class="hl opt">][</sp