lstrlib.c File Reference

#include "lprefix.h"
#include <ctype.h>
#include <float.h>
#include <limits.h>
#include <locale.h>
#include <math.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "lua.h"
#include "lauxlib.h"
#include "lualib.h"

Go to the source code of this file.

Data Structures
struct	str_Writer
struct	MatchState
struct	GMatchState
struct	cD
struct	Header

Macros
#define	lstrlib_c
#define	LUA_LIB
#define	LUA_MAXCAPTURES   32
#define	uchar(c)   ((unsigned char)(c))
#define	MAX_SIZET   ((size_t)(~(size_t)0))
#define	MAXSIZE    (sizeof(size_t) < sizeof(int) ? MAX_SIZET : (size_t)(INT_MAX))
#define	CAP_UNFINISHED   (-1)
#define	CAP_POSITION   (-2)
#define	MAXCCALLS   200
#define	L_ESC   '%'
#define	SPECIALS   "^$*+?.([%-"
#define	MAX_ITEMF   (110 + l_floatatt(MAX_10_EXP))
#define	MAX_ITEM   120
#define	L_FMTFLAGS   "-+ #0"
#define	MAX_FORMAT   32
#define	LUAL_PACKPADBYTE   0x00
#define	MAXINTSIZE   16
#define	NB   CHAR_BIT
#define	MC   ((1 << NB) - 1)
#define	SZINT   ((int)sizeof(lua_Integer))
#define	MAXALIGN   (offsetof(struct cD, u))

Typedefs
typedef struct MatchState	MatchState
typedef struct GMatchState	GMatchState
typedef struct Header	Header
typedef enum KOption	KOption

Enumerations
enum	KOption {   Kint , Kuint , Kfloat , Knumber ,   Kdouble , Kchar , Kstring , Kzstr ,   Kpadding , Kpaddalign , Knop }

Functions
static int	str_len (lua_State *L)
static size_t	posrelatI (lua_Integer pos, size_t len)
static size_t	getendpos (lua_State *L, int arg, lua_Integer def, size_t len)
static int	str_sub (lua_State *L)
static int	str_reverse (lua_State *L)
static int	str_lower (lua_State *L)
static int	str_upper (lua_State *L)
static int	str_rep (lua_State *L)
static int	str_byte (lua_State *L)
static int	str_char (lua_State *L)
static int	writer (lua_State *L, const void *b, size_t size, void *ud)
static int	str_dump (lua_State *L)
static int	tonum (lua_State *L, int arg)
static void	trymt (lua_State *L, const char *mtname)
static int	arith (lua_State *L, int op, const char *mtname)
static int	arith_add (lua_State *L)
static int	arith_sub (lua_State *L)
static int	arith_mul (lua_State *L)
static int	arith_mod (lua_State *L)
static int	arith_pow (lua_State *L)
static int	arith_div (lua_State *L)
static int	arith_idiv (lua_State *L)
static int	arith_unm (lua_State *L)
static const char *	match (MatchState *ms, const char *s, const char *p)
static int	check_capture (MatchState *ms, int l)
static int	capture_to_close (MatchState *ms)
static const char *	classend (MatchState *ms, const char *p)
static int	match_class (int c, int cl)
static int	matchbracketclass (int c, const char *p, const char *ec)
static int	singlematch (MatchState *ms, const char *s, const char *p, const char *ep)
static const char *	matchbalance (MatchState *ms, const char *s, const char *p)
static const char *	max_expand (MatchState *ms, const char *s, const char *p, const char *ep)
static const char *	min_expand (MatchState *ms, const char *s, const char *p, const char *ep)
static const char *	start_capture (MatchState *ms, const char *s, const char *p, int what)
static const char *	end_capture (MatchState *ms, const char *s, const char *p)
static const char *	match_capture (MatchState *ms, const char *s, int l)
static const char *	lmemfind (const char *s1, size_t l1, const char *s2, size_t l2)
static size_t	get_onecapture (MatchState *ms, int i, const char *s, const char *e, const char **cap)
static void	push_onecapture (MatchState *ms, int i, const char *s, const char *e)
static int	push_captures (MatchState *ms, const char *s, const char *e)
static int	nospecials (const char *p, size_t l)
static void	prepstate (MatchState *ms, lua_State *L, const char *s, size_t ls, const char *p, size_t lp)
static void	reprepstate (MatchState *ms)
static int	str_find_aux (lua_State *L, int find)
static int	str_find (lua_State *L)
static int	str_match (lua_State *L)
static int	gmatch_aux (lua_State *L)
static int	gmatch (lua_State *L)
static void	add_s (MatchState *ms, luaL_Buffer *b, const char *s, const char *e)
static int	add_value (MatchState *ms, luaL_Buffer *b, const char *s, const char *e, int tr)
static int	str_gsub (lua_State *L)
static void	addquoted (luaL_Buffer *b, const char *s, size_t len)
static int	quotefloat (lua_State *L, char *buff, lua_Number n)
static void	addliteral (lua_State *L, luaL_Buffer *b, int arg)
static const char *	scanformat (lua_State *L, const char *strfrmt, char *form)
static void	addlenmod (char *form, const char *lenmod)
static int	str_format (lua_State *L)
static int	digit (int c)
static int	getnum (const char **fmt, int df)
static int	getnumlimit (Header *h, const char **fmt, int df)
static void	initheader (lua_State *L, Header *h)
static KOption	getoption (Header *h, const char **fmt, int *size)
static KOption	getdetails (Header *h, size_t totalsize, const char **fmt, int *psize, int *ntoalign)
static void	packint (luaL_Buffer *b, lua_Unsigned n, int islittle, int size, int neg)
static void	copywithendian (char *dest, const char *src, int size, int islittle)
static int	str_pack (lua_State *L)
static int	str_packsize (lua_State *L)
static lua_Integer	unpackint (lua_State *L, const char *str, int islittle, int size, int issigned)
static int	str_unpack (lua_State *L)
static void	createmetatable (lua_State *L)
LUAMOD_API int	luaopen_string (lua_State *L)

Variables
static const luaL_Reg	stringmetamethods []
union {
int   dummy
char   little
}	nativeendian = {1}
static const luaL_Reg	strlib []

Macro Definition Documentation

CAP_POSITION

#define CAP_POSITION   (-2)

Definition at line 355 of file lua-5.4.3/src/lstrlib.c.

Referenced by add_s(), get_onecapture(), match(), and push_onecapture().

CAP_UNFINISHED

#define CAP_UNFINISHED   (-1)

Definition at line 354 of file lua-5.4.3/src/lstrlib.c.

Referenced by capture_to_close(), check_capture(), end_capture(), get_onecapture(), and match().

L_ESC

#define L_ESC   '%'

Definition at line 382 of file lua-5.4.3/src/lstrlib.c.

Referenced by add_s(), classend(), match(), matchbracketclass(), singlematch(), and str_format().

L_FMTFLAGS

#define L_FMTFLAGS   "-+ #0"

Definition at line 1094 of file lua-5.4.3/src/lstrlib.c.

Referenced by scanformat().

lstrlib_c

#define lstrlib_c

Definition at line 7 of file lua-5.4.3/src/lstrlib.c.

LUA_LIB

#define LUA_LIB

Definition at line 8 of file lua-5.4.3/src/lstrlib.c.

LUA_MAXCAPTURES

#define LUA_MAXCAPTURES   32

Definition at line 35 of file lua-5.4.3/src/lstrlib.c.

Referenced by start_capture().

LUAL_PACKPADBYTE

#define LUAL_PACKPADBYTE   0x00

Definition at line 1332 of file lua-5.4.3/src/lstrlib.c.

Referenced by str_pack().

MAX_FORMAT

#define MAX_FORMAT   32

Definition at line 1101 of file lua-5.4.3/src/lstrlib.c.

Referenced by str_format().

MAX_ITEM

#define MAX_ITEM   120

Definition at line 1089 of file lua-5.4.3/src/lstrlib.c.

Referenced by addliteral(), quotefloat(), and str_format().

MAX_ITEMF

#define MAX_ITEMF   (110 + l_floatatt(MAX_10_EXP))

Definition at line 1078 of file lua-5.4.3/src/lstrlib.c.

Referenced by str_format().

MAX_SIZET

#define MAX_SIZET   ((size_t)(~(size_t)0))

Definition at line 47 of file lua-5.4.3/src/lstrlib.c.

MAXALIGN

#define MAXALIGN   (offsetof(struct cD, u))

Definition at line 1361 of file lua-5.4.3/src/lstrlib.c.

Referenced by getoption().

MAXCCALLS

#define MAXCCALLS   200

Definition at line 378 of file lua-5.4.3/src/lstrlib.c.

Referenced by prepstate(), and reprepstate().

MAXINTSIZE

#define MAXINTSIZE   16

Definition at line 1336 of file lua-5.4.3/src/lstrlib.c.

Referenced by getnumlimit().

MAXSIZE

#define MAXSIZE    (sizeof(size_t) < sizeof(int) ? MAX_SIZET : (size_t)(INT_MAX))

Definition at line 49 of file lua-5.4.3/src/lstrlib.c.

#define MAXSIZE  \
    (sizeof(size_t) < sizeof(int) ? MAX_SIZET : (size_t)(INT_MAX))

Referenced by getnum(), str_packsize(), and str_rep().

MC

#define MC   ((1 << NB) - 1)

Definition at line 1342 of file lua-5.4.3/src/lstrlib.c.

Referenced by packint(), and unpackint().

NB

#define NB   CHAR_BIT

Definition at line 1339 of file lua-5.4.3/src/lstrlib.c.

Referenced by packint(), str_pack(), and unpackint().

SPECIALS

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

Definition at line 383 of file lua-5.4.3/src/lstrlib.c.

Referenced by nospecials().

SZINT

#define SZINT   ((int)sizeof(lua_Integer))

Definition at line 1345 of file lua-5.4.3/src/lstrlib.c.

Referenced by packint(), str_pack(), and unpackint().

uchar

#define uchar

(

c

)

((unsigned char)(c))

Definition at line 40 of file lua-5.4.3/src/lstrlib.c.

Referenced by add_s(), addquoted(), match(), matchbracketclass(), scanformat(), singlematch(), str_byte(), str_char(), str_lower(), and str_upper().

Typedef Documentation

GMatchState

typedef struct GMatchState GMatchState

Header

typedef struct Header Header

KOption

typedef enum KOption KOption

MatchState

typedef struct MatchState MatchState

Enumeration Type Documentation

KOption

enum KOption

Enumerator
Kint
Kuint
Kfloat
Knumber
Kdouble
Kchar
Kstring
Kzstr
Kpadding
Kpaddalign
Knop

Definition at line 1377 of file lua-5.4.3/src/lstrlib.c.

                     {
  Kint,     /* signed integers */
  Kuint,    /* unsigned integers */
  Kfloat,   /* single-precision floating-point numbers */
  Knumber,  /* Lua "native" floating-point numbers */
  Kdouble,  /* double-precision floating-point numbers */
  Kchar,    /* fixed-length strings */
  Kstring,  /* strings with prefixed length */
  Kzstr,    /* zero-terminated strings */
  Kpadding, /* padding */
  Kpaddalign,   /* padding for alignment */
  Knop      /* no-op (configuration or spaces) */
} KOption;

Function Documentation

add_s()

static void add_s ( MatchState * ms, luaL_Buffer * b, const char * s, const char * e )

static

Definition at line 871 of file lua-5.4.3/src/lstrlib.c.

                                                                  {
  size_t l;
  lua_State *L = ms->L;
  const char *news = lua_tolstring(L, 3, &l);
  const char *p;
  while ((p = (char *)memchr(news, L_ESC, l)) != NULL) {
    luaL_addlstring(b, news, p - news);
    p++;  /* skip ESC */
    if (*p == L_ESC)  /* '%%' */
      luaL_addchar(b, *p);
    else if (*p == '0')  /* '%0' */
        luaL_addlstring(b, s, e - s);
    else if (isdigit(uchar(*p))) {  /* '%n' */
      const char *cap;
      ptrdiff_t resl = get_onecapture(ms, *p - '1', s, e, &cap);
      if (resl == CAP_POSITION)
        luaL_addvalue(b);  /* add position to accumulated result */
      else
        luaL_addlstring(b, cap, resl);
    }
    else
      luaL_error(L, "invalid use of '%c' in replacement string", L_ESC);
    l -= p + 1 - news;
    news = p + 1;
  }
  luaL_addlstring(b, news, l);
}

References CAP_POSITION, get_onecapture(), MatchState::L, L_ESC, lua_tolstring(), luaL_addchar, luaL_addlstring(), luaL_addvalue(), luaL_error(), NULL, s, and uchar.

Referenced by add_value().

add_value()

static int add_value ( MatchState * ms, luaL_Buffer * b, const char * s, const char * e, int tr )

static

Definition at line 906 of file lua-5.4.3/src/lstrlib.c.

                                                             {
  lua_State *L = ms->L;
  switch (tr) {
    case LUA_TFUNCTION: {  /* call the function */
      int n;
      lua_pushvalue(L, 3);  /* push the function */
      n = push_captures(ms, s, e);  /* all captures as arguments */
      lua_call(L, n, 1);  /* call it */
      break;
    }
    case LUA_TTABLE: {  /* index the table */
      push_onecapture(ms, 0, s, e);  /* first capture is the index */
      lua_gettable(L, 3);
      break;
    }
    default: {  /* LUA_TNUMBER or LUA_TSTRING */
      add_s(ms, b, s, e);  /* add value to the buffer */
      return 1;  /* something changed */
    }
  }
  if (!lua_toboolean(L, -1)) {  /* nil or false? */
    lua_pop(L, 1);  /* remove value */
    luaL_addlstring(b, s, e - s);  /* keep original text */
    return 0;  /* no changes */
  }
  else if (l_unlikely(!lua_isstring(L, -1)))
    return luaL_error(L, "invalid replacement value (a %s)",
                         luaL_typename(L, -1));
  else {
    luaL_addvalue(b);  /* add result to accumulator */
    return 1;  /* something changed */
  }
}

References add_s(), MatchState::L, lua_call, lua_gettable(), lua_isstring(), lua_pop, lua_pushvalue(), LUA_TFUNCTION, lua_toboolean(), LUA_TTABLE, luaL_addlstring(), luaL_addvalue(), luaL_error(), luaL_typename, push_captures(), push_onecapture(), and s.

Referenced by str_gsub().

addlenmod()

static void addlenmod ( char * form, const char * lenmod )

static

Definition at line 1217 of file lua-5.4.3/src/lstrlib.c.

                                                       {
  size_t l = strlen(form);
  size_t lm = strlen(lenmod);
  char spec = form[l - 1];
  strcpy(form + l - 1, lenmod);
  form[l + lm - 1] = spec;
  form[l + lm] = '\0';
}

Referenced by str_format().

addliteral()

static void addliteral ( lua_State * L, luaL_Buffer * b, int arg )

static

Definition at line 1157 of file lua-5.4.3/src/lstrlib.c.

                                                               {
  switch (lua_type(L, arg)) {
    case LUA_TSTRING: {
      size_t len;
      const char *s = lua_tolstring(L, arg, &len);
      addquoted(b, s, len);
      break;
    }
    case LUA_TNUMBER: {
      char *buff = luaL_prepbuffsize(b, MAX_ITEM);
      int nb;
      if (!lua_isinteger(L, arg))  /* float? */
        nb = quotefloat(L, buff, lua_tonumber(L, arg));
      else {  /* integers */
        lua_Integer n = lua_tointeger(L, arg);
        const char *format = (n == LUA_MININTEGER)  /* corner case? */
                           ? "0x%" LUA_INTEGER_FRMLEN "x"  /* use hex */
                           : LUA_INTEGER_FMT;  /* else use default format */
        nb = l_sprintf(buff, MAX_ITEM, format, (LUAI_UACINT)n);
      }
      luaL_addsize(b, nb);
      break;
    }
    case LUA_TNIL: case LUA_TBOOLEAN: {
      luaL_tolstring(L, arg, NULL);
      luaL_addvalue(b);
      break;
    }
    default: {
      luaL_argerror(L, arg, "value has no literal form");
    }
  }
}

References addquoted(), arg, format(), l_sprintf, LUA_INTEGER_FMT, lua_isinteger(), LUA_TBOOLEAN, LUA_TNIL, LUA_TNUMBER, lua_tointeger, lua_tolstring(), lua_tonumber, LUA_TSTRING, lua_type(), LUAI_UACINT, luaL_addsize, luaL_addvalue(), luaL_argerror(), luaL_prepbuffsize(), luaL_tolstring(), MAX_ITEM, NULL, quotefloat(), and s.

Referenced by str_format().

addquoted()

static void addquoted ( luaL_Buffer * b, const char * s, size_t len )

static

Definition at line 1104 of file lua-5.4.3/src/lstrlib.c.

                                                                  {
  luaL_addchar(b, '"');
  while (len--) {
    if (*s == '"' || *s == '\\' || *s == '\n') {
      luaL_addchar(b, '\\');
      luaL_addchar(b, *s);
    }
    else if (iscntrl(uchar(*s))) {
      char buff[10];
      if (!isdigit(uchar(*(s+1))))
        l_sprintf(buff, sizeof(buff), "\\%d", (int)uchar(*s));
      else
        l_sprintf(buff, sizeof(buff), "\\%03d", (int)uchar(*s));
      luaL_addstring(b, buff);
    }
    else
      luaL_addchar(b, *s);
    s++;
  }
  luaL_addchar(b, '"');
}

References l_sprintf, luaL_addchar, luaL_addstring(), s, and uchar.

Referenced by addliteral().

arith()

static int arith ( lua_State * L, int op, const char * mtname )

static

Definition at line 288 of file lua-5.4.3/src/lstrlib.c.

                                                            {
  if (tonum(L, 1) && tonum(L, 2))
    lua_arith(L, op);  /* result will be on the top */
  else
    trymt(L, mtname);
  return 1;
}

References lua_arith(), tonum(), and trymt().

Referenced by arith_add(), arith_div(), arith_idiv(), arith_mod(), arith_mul(), arith_pow(), arith_sub(), arith_unm(), and windowCodeRangeTest().

arith_add()

static int arith_add ( lua_State * L )

static

Definition at line 297 of file lua-5.4.3/src/lstrlib.c.

                                    {
  return arith(L, LUA_OPADD, "__add");
}

References arith(), and LUA_OPADD.

arith_div()

static int arith_div ( lua_State * L )

static

Definition at line 317 of file lua-5.4.3/src/lstrlib.c.

                                    {
  return arith(L, LUA_OPDIV, "__div");
}

References arith(), and LUA_OPDIV.

arith_idiv()

static int arith_idiv ( lua_State * L )

static

Definition at line 321 of file lua-5.4.3/src/lstrlib.c.

                                     {
  return arith(L, LUA_OPIDIV, "__idiv");
}

References arith(), and LUA_OPIDIV.

arith_mod()

static int arith_mod ( lua_State * L )

static

Definition at line 309 of file lua-5.4.3/src/lstrlib.c.

                                    {
  return arith(L, LUA_OPMOD, "__mod");
}

References arith(), and LUA_OPMOD.

arith_mul()

static int arith_mul ( lua_State * L )

static

Definition at line 305 of file lua-5.4.3/src/lstrlib.c.

                                    {
  return arith(L, LUA_OPMUL, "__mul");
}

References arith(), and LUA_OPMUL.

arith_pow()

static int arith_pow ( lua_State * L )

static

Definition at line 313 of file lua-5.4.3/src/lstrlib.c.

                                    {
  return arith(L, LUA_OPPOW, "__pow");
}

References arith(), and LUA_OPPOW.

arith_sub()

static int arith_sub ( lua_State * L )

static

Definition at line 301 of file lua-5.4.3/src/lstrlib.c.

                                    {
  return arith(L, LUA_OPSUB, "__sub");
}

References arith(), and LUA_OPSUB.

arith_unm()

static int arith_unm ( lua_State * L )

static

Definition at line 325 of file lua-5.4.3/src/lstrlib.c.

                                    {
  return arith(L, LUA_OPUNM, "__unm");
}

References arith(), and LUA_OPUNM.

capture_to_close()

static int capture_to_close ( MatchState * ms )

static

Definition at line 395 of file lua-5.4.3/src/lstrlib.c.

                                             {
  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");
}

References CAP_UNFINISHED, MatchState::capture, MatchState::L, MatchState::len, MatchState::level, and luaL_error().

Referenced by end_capture().

check_capture()

static int check_capture ( MatchState * ms, int l )

static

Definition at line 386 of file lua-5.4.3/src/lstrlib.c.

                                                 {
  l -= '1';
  if (l_unlikely(l < 0 || l >= ms->level ||
                 ms->capture[l].len == CAP_UNFINISHED))
    return luaL_error(ms->L, "invalid capture index %%%d", l + 1);
  return l;
}

References CAP_UNFINISHED, MatchState::capture, MatchState::L, MatchState::len, MatchState::level, and luaL_error().

Referenced by match_capture().

classend()

static const char * classend ( MatchState * ms, const char * p )

static

Definition at line 403 of file lua-5.4.3/src/lstrlib.c.

                                                            {
  switch (*p++) {
    case L_ESC: {
      if (l_unlikely(p == ms->p_end))
        luaL_error(ms->L, "malformed pattern (ends with '%%')");
      return p+1;
    }
    case '[': {
      if (*p == '^') p++;
      do {  /* look for a ']' */
        if (l_unlikely(p == ms->p_end))
          luaL_error(ms->L, "malformed pattern (missing ']')");
        if (*(p++) == L_ESC && p < ms->p_end)
          p++;  /* skip escapes (e.g. '%]') */
      } while (*p != ']');
      return p+1;
    }
    default: {
      return p;
    }
  }
}

References MatchState::L, L_ESC, luaL_error(), and MatchState::p_end.

Referenced by match().

copywithendian()

static void copywithendian ( char * dest, const char * src, int size, int islittle )

static

Definition at line 1532 of file lua-5.4.3/src/lstrlib.c.

                                                    {
  if (islittle == nativeendian.little)
    memcpy(dest, src, size);
  else {
    dest += size - 1;
    while (size-- != 0)
      *(dest--) = *(src++);
  }
}

References nativeendian.

Referenced by str_pack(), and str_unpack().

createmetatable()

static void createmetatable ( lua_State * L )

static

Definition at line 1795 of file lua-5.4.3/src/lstrlib.c.

                                           {
  /* table to be metatable for strings */
  luaL_newlibtable(L, stringmetamethods);
  luaL_setfuncs(L, stringmetamethods, 0);
  lua_pushliteral(L, "");  /* dummy string */
  lua_pushvalue(L, -2);  /* copy table */
  lua_setmetatable(L, -2);  /* set table as metatable for strings */
  lua_pop(L, 1);  /* pop dummy string */
  lua_pushvalue(L, -2);  /* get string library */
  lua_setfield(L, -2, "__index");  /* metatable.__index = string */
  lua_pop(L, 1);  /* pop metatable */
}

References lua_pop, lua_pushliteral, lua_pushvalue(), lua_setfield(), lua_setmetatable(), luaL_newlibtable, luaL_setfuncs(), and stringmetamethods.

Referenced by luaopen_string().

digit()

static int digit ( int c )

static

Definition at line 1396 of file lua-5.4.3/src/lstrlib.c.

{ return '0' <= c && c <= '9'; }

Referenced by getnum().

end_capture()

static const char * end_capture ( MatchState * ms, const char * s, const char * p )

static

Definition at line 548 of file lua-5.4.3/src/lstrlib.c.

                                                 {
  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;
}

References CAP_UNFINISHED, MatchState::capture, capture_to_close(), MatchState::init, MatchState::len, match(), NULL, and s.

Referenced by match().

get_onecapture()

static size_t get_onecapture ( MatchState * ms, int i, const char * s, const char * e, const char ** cap )

static

Definition at line 702 of file lua-5.4.3/src/lstrlib.c.

                                                               {
  if (i >= ms->level) {
    if (l_unlikely(i != 0))
      luaL_error(ms->L, "invalid capture index %%%d", i + 1);
    *cap = s;
    return e - s;
  }
  else {
    ptrdiff_t capl = ms->capture[i].len;
    *cap = ms->capture[i].init;
    if (l_unlikely(capl == CAP_UNFINISHED))
      luaL_error(ms->L, "unfinished capture");
    else if (capl == CAP_POSITION)
      lua_pushinteger(ms->L, (ms->capture[i].init - ms->src_init) + 1);
    return capl;
  }
}

References CAP_POSITION, CAP_UNFINISHED, MatchState::capture, MatchState::init, MatchState::L, MatchState::len, MatchState::level, lua_pushinteger(), luaL_error(), s, and MatchState::src_init.

Referenced by add_s(), and push_onecapture().

getdetails()

static KOption getdetails ( Header * h, size_t totalsize, const char ** fmt, int * psize, int * ntoalign )

static

Definition at line 1484 of file lua-5.4.3/src/lstrlib.c.

                                                                        {
  KOption opt = getoption(h, fmt, psize);
  int align = *psize;  /* usually, alignment follows size */
  if (opt == Kpaddalign) {  /* 'X' gets alignment from following option */
    if (**fmt == '\0' || getoption(h, fmt, &align) == Kchar || align == 0)
      luaL_argerror(h->L, 1, "invalid next option for option 'X'");
  }
  if (align <= 1 || opt == Kchar)  /* need no alignment? */
    *ntoalign = 0;
  else {
    if (align > h->maxalign)  /* enforce maximum alignment */
      align = h->maxalign;
    if (l_unlikely((align & (align - 1)) != 0))  /* not a power of 2? */
      luaL_argerror(h->L, 1, "format asks for alignment not power of 2");
    *ntoalign = (align - (int)(totalsize & (align - 1))) & (align - 1);
  }
  return opt;
}

References getoption(), Kchar, Kpaddalign, Header::L, luaL_argerror(), and Header::maxalign.

Referenced by str_pack(), str_packsize(), and str_unpack().

getendpos()

static size_t getendpos ( lua_State * L, int arg, lua_Integer def, size_t len )

static

Definition at line 87 of file lua-5.4.3/src/lstrlib.c.

                                     {
  lua_Integer pos = luaL_optinteger(L, arg, def);
  if (pos > (lua_Integer)len)
    return len;
  else if (pos >= 0)
    return (size_t)pos;
  else if (pos < -(lua_Integer)len)
    return 0;
  else return len + (size_t)pos + 1;
}

References arg, and luaL_optinteger().

Referenced by str_byte(), and str_sub().

getnum()

static int getnum ( const char ** fmt, int df )

static

Definition at line 1398 of file lua-5.4.3/src/lstrlib.c.

                                             {
  if (!digit(**fmt))  /* no number? */
    return df;  /* return default value */
  else {
    int a = 0;
    do {
      a = a*10 + (*((*fmt)++) - '0');
    } while (digit(**fmt) && a <= ((int)MAXSIZE - 9)/10);
    return a;
  }
}

References digit(), and MAXSIZE.

Referenced by getnumlimit(), and getoption().

getnumlimit()

static int getnumlimit ( Header * h, const char ** fmt, int df )

static

Definition at line 1415 of file lua-5.4.3/src/lstrlib.c.

                                                             {
  int sz = getnum(fmt, df);
  if (l_unlikely(sz > MAXINTSIZE || sz <= 0))
    return luaL_error(h->L, "integral size (%d) out of limits [1,%d]",
                            sz, MAXINTSIZE);
  return sz;
}

References getnum(), Header::L, luaL_error(), and MAXINTSIZE.

Referenced by getoption().

getoption()

static KOption getoption ( Header * h, const char ** fmt, int * size )

static

Definition at line 1437 of file lua-5.4.3/src/lstrlib.c.

                                                                  {
  int opt = *((*fmt)++);
  *size = 0;  /* default */
  switch (opt) {
    case 'b': *size = sizeof(char); return Kint;
    case 'B': *size = sizeof(char); return Kuint;
    case 'h': *size = sizeof(short); return Kint;
    case 'H': *size = sizeof(short); return Kuint;
    case 'l': *size = sizeof(long); return Kint;
    case 'L': *size = sizeof(long); return Kuint;
    case 'j': *size = sizeof(lua_Integer); return Kint;
    case 'J': *size = sizeof(lua_Integer); return Kuint;
    case 'T': *size = sizeof(size_t); return Kuint;
    case 'f': *size = sizeof(float); return Kfloat;
    case 'n': *size = sizeof(lua_Number); return Knumber;
    case 'd': *size = sizeof(double); return Kdouble;
    case 'i': *size = getnumlimit(h, fmt, sizeof(int)); return Kint;
    case 'I': *size = getnumlimit(h, fmt, sizeof(int)); return Kuint;
    case 's': *size = getnumlimit(h, fmt, sizeof(size_t)); return Kstring;
    case 'c':
      *size = getnum(fmt, -1);
      if (l_unlikely(*size == -1))
        luaL_error(h->L, "missing size for format option 'c'");
      return Kchar;
    case 'z': return Kzstr;
    case 'x': *size = 1; return Kpadding;
    case 'X': return Kpaddalign;
    case ' ': break;
    case '<': h->islittle = 1; break;
    case '>': h->islittle = 0; break;
    case '=': h->islittle = nativeendian.little; break;
    case '!': h->maxalign = getnumlimit(h, fmt, MAXALIGN); break;
    default: luaL_error(h->L, "invalid format option '%c'", opt);
  }
  return Knop;
}

References getnum(), getnumlimit(), Header::islittle, Kchar, Kdouble, Kfloat, Kint, Knop, Knumber, Kpaddalign, Kpadding, Kstring, Kuint, Kzstr, Header::L, luaL_error(), Header::maxalign, MAXALIGN, and nativeendian.

Referenced by getdetails().

gmatch()

static int gmatch ( lua_State * L )

static

Definition at line 854 of file lua-5.4.3/src/lstrlib.c.

                                 {
  size_t ls, lp;
  const char *s = luaL_checklstring(L, 1, &ls);
  const char *p = luaL_checklstring(L, 2, &lp);
  size_t init = posrelatI(luaL_optinteger(L, 3, 1), ls) - 1;
  GMatchState *gm;
  lua_settop(L, 2);  /* keep strings on closure to avoid being collected */
  gm = (GMatchState *)lua_newuserdatauv(L, sizeof(GMatchState), 0);
  if (init > ls)  /* start after string's end? */
    init = ls + 1;  /* avoid overflows in 's + init' */
  prepstate(&gm->ms, L, s, ls, p, lp);
  gm->src = s + init; gm->p = p; gm->lastmatch = NULL;
  lua_pushcclosure(L, gmatch_aux, 3);
  return 1;
}

References gmatch_aux(), GMatchState::lastmatch, lua_newuserdatauv(), lua_pushcclosure(), lua_settop(), luaL_checklstring(), luaL_optinteger(), GMatchState::ms, NULL, GMatchState::p, posrelatI(), prepstate(), s, and GMatchState::src.

gmatch_aux()

static int gmatch_aux ( lua_State * L )

static

Definition at line 838 of file lua-5.4.3/src/lstrlib.c.

                                     {
  GMatchState *gm = (GMatchState *)lua_touserdata(L, lua_upvalueindex(3));
  const char *src;
  gm->ms.L = L;
  for (src = gm->src; src <= gm->ms.src_end; src++) {
    const char *e;
    reprepstate(&gm->ms);
    if ((e = match(&gm->ms, src, gm->p)) != NULL && e != gm->lastmatch) {
      gm->src = gm->lastmatch = e;
      return push_captures(&gm->ms, src, e);
    }
  }
  return 0;  /* not found */
}

References MatchState::L, GMatchState::lastmatch, lua_touserdata(), lua_upvalueindex, match(), GMatchState::ms, NULL, GMatchState::p, push_captures(), reprepstate(), GMatchState::src, and MatchState::src_end.

Referenced by gmatch().

initheader()

static void initheader ( lua_State * L, Header * h )

static

Definition at line 1427 of file lua-5.4.3/src/lstrlib.c.

                                                 {
  h->L = L;
  h->islittle = nativeendian.little;
  h->maxalign = 1;
}

References Header::islittle, Header::L, Header::maxalign, and nativeendian.

Referenced by str_pack(), str_packsize(), and str_unpack().

lmemfind()

static const char * lmemfind ( const char * s1, size_t l1, const char * s2, size_t l2 )

static

Definition at line 673 of file lua-5.4.3/src/lstrlib.c.

                                                          {
  if (l2 == 0) return s1;  /* empty strings are everywhere */
  else if (l2 > l1) return NULL;  /* avoids a negative 'l1' */
  else {
    const char *init;  /* to search for a '*s2' inside 's1' */
    l2--;  /* 1st char will be checked by 'memchr' */
    l1 = l1-l2;  /* 's2' cannot be found after that */
    while (l1 > 0 && (init = (const char *)memchr(s1, *s2, l1)) != NULL) {
      init++;   /* 1st char is already checked */
      if (memcmp(init, s2+1, l2) == 0)
        return init-1;
      else {  /* correct 'l1' and 's1' to try again */
        l1 -= init-s1;
        s1 = init;
      }
    }
    return NULL;  /* not found */
  }
}

References NULL.

Referenced by str_find_aux().

luaopen_string()

LUAMOD_API int luaopen_string

(

lua_State *

L

)

Definition at line 1812 of file lua-5.4.3/src/lstrlib.c.

                                             {
  luaL_newlib(L, strlib);
  createmetatable(L);
  return 1;
}

References createmetatable(), luaL_newlib, and strlib.

match()

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

static

Definition at line 570 of file lua-5.4.3/src/lstrlib.c.

                                                                        {
  if (l_unlikely(ms->matchdepth-- == 0))
    luaL_error(ms->L, "pattern too complex");
  init: /* using goto's to optimize tail recursion */
  if (p != ms->p_end) {  /* end of pattern? */
    switch (*p) {
      case '(': {  /* start capture */
        if (*(p + 1) == ')')  /* position capture? */
          s = start_capture(ms, s, p + 2, CAP_POSITION);
        else
          s = start_capture(ms, s, p + 1, CAP_UNFINISHED);
        break;
      }
      case ')': {  /* end capture */
        s = end_capture(ms, s, p + 1);
        break;
      }
      case '$': {
        if ((p + 1) != ms->p_end)  /* is the '$' the last char in pattern? */
          goto dflt;  /* no; go to default */
        s = (s == ms->src_end) ? s : NULL;  /* check end of string */
        break;
      }
      case L_ESC: {  /* escaped sequences not in the format class[*+?-]? */
        switch (*(p + 1)) {
          case 'b': {  /* balanced string? */
            s = matchbalance(ms, s, p + 2);
            if (s != NULL) {
              p += 4; goto init;  /* return match(ms, s, p + 4); */
            }  /* else fail (s == NULL) */
            break;
          }
          case 'f': {  /* frontier? */
            const char *ep; char previous;
            p += 2;
            if (l_unlikely(*p != '['))
              luaL_error(ms->L, "missing '[' after '%%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)) {
              p = ep; goto init;  /* return match(ms, s, ep); */
            }
            s = NULL;  /* match failed */
            break;
          }
          case '0': case '1': case '2': case '3':
          case '4': case '5': case '6': case '7':
          case '8': case '9': {  /* capture results (%0-%9)? */
            s = match_capture(ms, s, uchar(*(p + 1)));
            if (s != NULL) {
              p += 2; goto init;  /* return match(ms, s, p + 2) */
            }
            break;
          }
          default: goto dflt;
        }
        break;
      }
      default: dflt: {  /* pattern class plus optional suffix */
        const char *ep = classend(ms, p);  /* points to optional suffix */
        /* does not match at least once? */
        if (!singlematch(ms, s, p, ep)) {
          if (*ep == '*' || *ep == '?' || *ep == '-') {  /* accept empty? */
            p = ep + 1; goto init;  /* return match(ms, s, ep + 1); */
          }
          else  /* '+' or no suffix */
            s = NULL;  /* fail */
        }
        else {  /* matched once */
          switch (*ep) {  /* handle optional suffix */
            case '?': {  /* optional */
              const char *res;
              if ((res = match(ms, s + 1, ep + 1)) != NULL)
                s = res;
              else {
                p = ep + 1; goto init;  /* else return match(ms, s, ep + 1); */
              }
              break;
            }
            case '+':  /* 1 or more repetitions */
              s++;  /* 1 match already done */
              /* FALLTHROUGH */
            case '*':  /* 0 or more repetitions */
              s = max_expand(ms, s, p, ep);
              break;
            case '-':  /* 0 or more repetitions (minimum) */
              s = min_expand(ms, s, p, ep);
              break;
            default:  /* no suffix */
              s++; p = ep; goto init;  /* return match(ms, s + 1, ep); */
          }
        }
        break;
      }
    }
  }
  ms->matchdepth++;
  return s;
}

References CAP_POSITION, CAP_UNFINISHED, classend(), end_capture(), MatchState::L, L_ESC, luaL_error(), match(), match_capture(), matchbalance(), matchbracketclass(), MatchState::matchdepth, max_expand(), min_expand(), NULL, MatchState::p_end, s, singlematch(), MatchState::src_end, MatchState::src_init, start_capture(), and uchar.

Referenced by end_capture(), gmatch_aux(), match(), max_expand(), min_expand(), start_capture(), str_find_aux(), and str_gsub().

match_capture()

static const char * match_capture ( MatchState * ms, const char * s, int l )

static

Definition at line 559 of file lua-5.4.3/src/lstrlib.c.

                                                                        {
  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;
}

References MatchState::capture, check_capture(), MatchState::init, MatchState::len, NULL, s, and MatchState::src_end.

Referenced by match().

match_class()

static int match_class ( int c, int cl )

static

Definition at line 427 of file lua-5.4.3/src/lstrlib.c.

                                       {
  int res;
  switch (tolower(cl)) {
    case 'a' : res = isalpha(c); break;
    case 'c' : res = iscntrl(c); break;
    case 'd' : res = isdigit(c); break;
    case 'g' : res = isgraph(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;  /* deprecated option */
    default: return (cl == c);
  }
  return (islower(cl) ? res : !res);
}

Referenced by matchbracketclass(), and singlematch().

matchbalance()

static const char * matchbalance ( MatchState * ms, const char * s, const char * p )

static

Definition at line 486 of file lua-5.4.3/src/lstrlib.c.

                                                  {
  if (l_unlikely(p >= ms->p_end - 1))
    luaL_error(ms->L, "malformed pattern (missing arguments to '%%b')");
  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 */
}

References MatchState::L, luaL_error(), NULL, MatchState::p_end, and s.

Referenced by match().

matchbracketclass()

static int matchbracketclass ( int c, const char * p, const char * ec )

static

Definition at line 447 of file lua-5.4.3/src/lstrlib.c.

                                                                    {
  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;
}

References L_ESC, match_class(), and uchar.

Referenced by match(), and singlematch().

max_expand()

static const char * max_expand ( MatchState * ms, const char * s, const char * p, const char * ep )

static

Definition at line 506 of file lua-5.4.3/src/lstrlib.c.

                                                                {
  ptrdiff_t i = 0;  /* counts maximum expand for item */
  while (singlematch(ms, 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;
}

References match(), NULL, s, and singlematch().

Referenced by match().

min_expand()

static const char * min_expand ( MatchState * ms, const char * s, const char * p, const char * ep )

static

Definition at line 521 of file lua-5.4.3/src/lstrlib.c.

                                                                {
  for (;;) {
    const char *res = match(ms, s, ep+1);
    if (res != NULL)
      return res;
    else if (singlematch(ms, s, p, ep))
      s++;  /* try with one more repetition */
    else return NULL;
  }
}

References match(), NULL, s, and singlematch().

Referenced by match().

nospecials()

static int nospecials ( const char * p, size_t l )

static

Definition at line 746 of file lua-5.4.3/src/lstrlib.c.

                                                {
  size_t upto = 0;
  do {
    if (strpbrk(p + upto, SPECIALS))
      return 0;  /* pattern has a special character */
    upto += strlen(p + upto) + 1;  /* may have more after \0 */
  } while (upto <= l);
  return 1;  /* no special chars found */
}

References SPECIALS.

Referenced by str_find_aux().

packint()

static void packint ( luaL_Buffer * b, lua_Unsigned n, int islittle, int size, int neg )

static

Definition at line 1511 of file lua-5.4.3/src/lstrlib.c.

                                                      {
  char *buff = luaL_prepbuffsize(b, size);
  int i;
  buff[islittle ? 0 : size - 1] = (char)(n & MC);  /* first byte */
  for (i = 1; i < size; i++) {
    n >>= NB;
    buff[islittle ? i : size - 1 - i] = (char)(n & MC);
  }
  if (neg && size > SZINT) {  /* negative number need sign extension? */
    for (i = SZINT; i < size; i++)  /* correct extra bytes */
      buff[islittle ? i : size - 1 - i] = (char)MC;
  }
  luaL_addsize(b, size);  /* add result to buffer */
}

References luaL_addsize, luaL_prepbuffsize(), MC, NB, and SZINT.

Referenced by str_pack().

posrelatI()

static size_t posrelatI ( lua_Integer pos, size_t len )

static

Definition at line 71 of file lua-5.4.3/src/lstrlib.c.

                                                      {
  if (pos > 0)
    return (size_t)pos;
  else if (pos == 0)
    return 1;
  else if (pos < -(lua_Integer)len)  /* inverted comparison */
    return 1;  /* clip to 1 */
  else return len + (size_t)pos + 1;
}

Referenced by gmatch(), str_byte(), str_find_aux(), str_sub(), and str_unpack().

prepstate()

static void prepstate ( MatchState * ms, lua_State * L, const char * s, size_t ls, const char * p, size_t lp )

static

Definition at line 757 of file lua-5.4.3/src/lstrlib.c.

                                                                           {
  ms->L = L;
  ms->matchdepth = MAXCCALLS;
  ms->src_init = s;
  ms->src_end = s + ls;
  ms->p_end = p + lp;
}

References MatchState::L, MatchState::matchdepth, MAXCCALLS, MatchState::p_end, s, MatchState::src_end, and MatchState::src_init.

Referenced by gmatch(), str_find_aux(), and str_gsub().

push_captures()

static int push_captures ( MatchState * ms, const char * s, const char * e )

static

Definition at line 735 of file lua-5.4.3/src/lstrlib.c.

                                                                        {
  int i;
  int nlevels = (ms->level == 0 && s) ? 1 : ms->level;
  luaL_checkstack(ms->L, nlevels, "too many captures");
  for (i = 0; i < nlevels; i++)
    push_onecapture(ms, i, s, e);
  return nlevels;  /* number of strings pushed */
}

References MatchState::L, MatchState::level, luaL_checkstack(), push_onecapture(), and s.

Referenced by add_value(), gmatch_aux(), and str_find_aux().

push_onecapture()

static void push_onecapture ( MatchState * ms, int i, const char * s, const char * e )

static

Definition at line 725 of file lua-5.4.3/src/lstrlib.c.

                                                                   {
  const char *cap;
  ptrdiff_t l = get_onecapture(ms, i, s, e, &cap);
  if (l != CAP_POSITION)
    lua_pushlstring(ms->L, cap, l);
  /* else position was already pushed */
}

References CAP_POSITION, get_onecapture(), MatchState::L, lua_pushlstring(), and s.

Referenced by add_value(), and push_captures().

quotefloat()

static int quotefloat ( lua_State * L, char * buff, lua_Number n )

static

Definition at line 1133 of file lua-5.4.3/src/lstrlib.c.

                                                               {
  const char *s;  /* for the fixed representations */
  if (n == (lua_Number)HUGE_VAL)  /* inf? */
    s = "1e9999";
  else if (n == -(lua_Number)HUGE_VAL)  /* -inf? */
    s = "-1e9999";
  else if (n != n)  /* NaN? */
    s = "(0/0)";
  else {  /* format number as hexadecimal */
    int  nb = lua_number2strx(L, buff, MAX_ITEM,
                                 "%" LUA_NUMBER_FRMLEN "a", n);
    /* ensures that 'buff' string uses a dot as the radix character */
    if (memchr(buff, '.', nb) == NULL) {  /* no dot? */
      char point = lua_getlocaledecpoint();  /* try locale point */
      char *ppoint = (char *)memchr(buff, point, nb);
      if (ppoint) *ppoint = '.';  /* change it to a dot */
    }
    return nb;
  }
  /* for the fixed representations */
  return l_sprintf(buff, MAX_ITEM, "%s", s);
}

References l_sprintf, lua_getlocaledecpoint, lua_number2strx, LUA_NUMBER_FRMLEN, MAX_ITEM, NULL, and s.

Referenced by addliteral().

reprepstate()

static void reprepstate ( MatchState * ms )

static

Definition at line 767 of file lua-5.4.3/src/lstrlib.c.

                                         {
  ms->level = 0;
  lua_assert(ms->matchdepth == MAXCCALLS);
}

References MatchState::level, lua_assert, MatchState::matchdepth, and MAXCCALLS.

Referenced by gmatch_aux(), str_find_aux(), and str_gsub().

scanformat()

static const char * scanformat ( lua_State * L, const char * strfrmt, char * form )

static

Definition at line 1192 of file lua-5.4.3/src/lstrlib.c.

                                                                              {
  const char *p = strfrmt;
  while (*p != '\0' && strchr(L_FMTFLAGS, *p) != NULL) p++;  /* skip flags */
  if ((size_t)(p - strfrmt) >= sizeof(L_FMTFLAGS)/sizeof(char))
    luaL_error(L, "invalid format (repeated flags)");
  if (isdigit(uchar(*p))) p++;  /* skip width */
  if (isdigit(uchar(*p))) p++;  /* (2 digits at most) */
  if (*p == '.') {
    p++;
    if (isdigit(uchar(*p))) p++;  /* skip precision */
    if (isdigit(uchar(*p))) p++;  /* (2 digits at most) */
  }
  if (isdigit(uchar(*p)))
    luaL_error(L, "invalid format (width or precision too long)");
  *(form++) = '%';
  memcpy(form, strfrmt, ((p - strfrmt) + 1) * sizeof(char));
  form += (p - strfrmt) + 1;
  *form = '\0';
  return p;
}

References L_FMTFLAGS, luaL_error(), NULL, and uchar.

Referenced by str_format().

singlematch()

static int singlematch ( MatchState * ms, const char * s, const char * p, const char * ep )

static

Definition at line 470 of file lua-5.4.3/src/lstrlib.c.

                                        {
  if (s >= ms->src_end)
    return 0;
  else {
    int c = uchar(*s);
    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);
    }
  }
}

References L_ESC, match_class(), matchbracketclass(), s, MatchState::src_end, and uchar.

Referenced by match(), max_expand(), and min_expand().

start_capture()

static const char * start_capture ( MatchState * ms, const char * s, const char * p, int what )

static

Definition at line 534 of file lua-5.4.3/src/lstrlib.c.

                                                             {
  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;
}

References MatchState::capture, MatchState::init, MatchState::L, MatchState::len, MatchState::level, LUA_MAXCAPTURES, luaL_error(), match(), NULL, and s.

Referenced by match().

str_byte()

static int str_byte ( lua_State * L )

static

Definition at line 177 of file lua-5.4.3/src/lstrlib.c.

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

References getendpos(), lua_pushinteger(), luaL_checklstring(), luaL_checkstack(), luaL_error(), luaL_optinteger(), posrelatI(), s, and uchar.

str_char()

static int str_char ( lua_State * L )

static

Definition at line 195 of file lua-5.4.3/src/lstrlib.c.

                                   {
  int n = lua_gettop(L);  /* number of arguments */
  int i;
  luaL_Buffer b;
  char *p = luaL_buffinitsize(L, &b, n);
  for (i=1; i<=n; i++) {
    lua_Unsigned c = (lua_Unsigned)luaL_checkinteger(L, i);
    luaL_argcheck(L, c <= (lua_Unsigned)UCHAR_MAX, i, "value out of range");
    p[i - 1] = uchar(c);
  }
  luaL_pushresultsize(&b, n);
  return 1;
}

References lua_gettop(), luaL_argcheck, luaL_buffinitsize(), luaL_checkinteger(), luaL_pushresultsize(), and uchar.

str_dump()

static int str_dump ( lua_State * L )

static

Definition at line 233 of file lua-5.4.3/src/lstrlib.c.

                                   {
  struct str_Writer state;
  int strip = lua_toboolean(L, 2);
  luaL_checktype(L, 1, LUA_TFUNCTION);
  lua_settop(L, 1);  /* ensure function is on the top of the stack */
  state.init = 0;
  if (l_unlikely(lua_dump(L, writer, &state, strip) != 0))
    return luaL_error(L, "unable to dump given function");
  luaL_pushresult(&state.B);
  return 1;
}

References str_Writer::B, str_Writer::init, lua_dump(), lua_settop(), LUA_TFUNCTION, lua_toboolean(), luaL_checktype(), luaL_error(), luaL_pushresult(), and writer().

str_find()

static int str_find ( lua_State * L )

static

Definition at line 819 of file lua-5.4.3/src/lstrlib.c.

                                   {
  return str_find_aux(L, 1);
}

References str_find_aux().

str_find_aux()

static int str_find_aux ( lua_State * L, int find )

static

Definition at line 773 of file lua-5.4.3/src/lstrlib.c.

                                                 {
  size_t ls, lp;
  const char *s = luaL_checklstring(L, 1, &ls);
  const char *p = luaL_checklstring(L, 2, &lp);
  size_t init = posrelatI(luaL_optinteger(L, 3, 1), ls) - 1;
  if (init > ls) {  /* start after string's end? */
    luaL_pushfail(L);  /* cannot find anything */
    return 1;
  }
  /* explicit request or no special characters? */
  if (find && (lua_toboolean(L, 4) || nospecials(p, lp))) {
    /* do a plain search */
    const char *s2 = lmemfind(s + init, ls - init, p, lp);
    if (s2) {
      lua_pushinteger(L, (s2 - s) + 1);
      lua_pushinteger(L, (s2 - s) + lp);
      return 2;
    }
  }
  else {
    MatchState ms;
    const char *s1 = s + init;
    int anchor = (*p == '^');
    if (anchor) {
      p++; lp--;  /* skip anchor character */
    }
    prepstate(&ms, L, s, ls, p, lp);
    do {
      const char *res;
      reprepstate(&ms);
      if ((res=match(&ms, s1, p)) != NULL) {
        if (find) {
          lua_pushinteger(L, (s1 - s) + 1);  /* start */
          lua_pushinteger(L, res - s);   /* end */
          return push_captures(&ms, NULL, 0) + 2;
        }
        else
          return push_captures(&ms, s1, res);
      }
    } while (s1++ < ms.src_end && !anchor);
  }
  luaL_pushfail(L);  /* not found */
  return 1;
}

References find(), lmemfind(), lua_pushinteger(), lua_toboolean(), luaL_checklstring(), luaL_optinteger(), luaL_pushfail, match(), nospecials(), NULL, posrelatI(), prepstate(), push_captures(), reprepstate(), s, and MatchState::src_end.

Referenced by str_find(), and str_match().

str_format()

static int str_format ( lua_State * L )

static

Definition at line 1227 of file lua-5.4.3/src/lstrlib.c.

                                     {
  int top = lua_gettop(L);
  int arg = 1;
  size_t sfl;
  const char *strfrmt = luaL_checklstring(L, arg, &sfl);
  const char *strfrmt_end = strfrmt+sfl;
  luaL_Buffer b;
  luaL_buffinit(L, &b);
  while (strfrmt < strfrmt_end) {
    if (*strfrmt != L_ESC)
      luaL_addchar(&b, *strfrmt++);
    else if (*++strfrmt == L_ESC)
      luaL_addchar(&b, *strfrmt++);  /* %% */
    else { /* format item */
      char form[MAX_FORMAT];  /* to store the format ('%...') */
      int maxitem = MAX_ITEM;
      char *buff = luaL_prepbuffsize(&b, maxitem);  /* to put formatted item */
      int nb = 0;  /* number of bytes in added item */
      if (++arg > top)
        return luaL_argerror(L, arg, "no value");
      strfrmt = scanformat(L, strfrmt, form);
      switch (*strfrmt++) {
        case 'c': {
          nb = l_sprintf(buff, maxitem, form, (int)luaL_checkinteger(L, arg));
          break;
        }
        case 'd': case 'i':
        case 'o': case 'u': case 'x': case 'X': {
          lua_Integer n = luaL_checkinteger(L, arg);
          addlenmod(form, LUA_INTEGER_FRMLEN);
          nb = l_sprintf(buff, maxitem, form, (LUAI_UACINT)n);
          break;
        }
        case 'a': case 'A':
          addlenmod(form, LUA_NUMBER_FRMLEN);
          nb = lua_number2strx(L, buff, maxitem, form,
                                  luaL_checknumber(L, arg));
          break;
        case 'f':
          maxitem = MAX_ITEMF;  /* extra space for '%f' */
          buff = luaL_prepbuffsize(&b, maxitem);
          /* FALLTHROUGH */
        case 'e': case 'E': case 'g': case 'G': {
          lua_Number n = luaL_checknumber(L, arg);
          addlenmod(form, LUA_NUMBER_FRMLEN);
          nb = l_sprintf(buff, maxitem, form, (LUAI_UACNUMBER)n);
          break;
        }
        case 'p': {
          const void *p = lua_topointer(L, arg);
          if (p == NULL) {  /* avoid calling 'printf' with argument NULL */
            p = "(null)";  /* result */
            form[strlen(form) - 1] = 's';  /* format it as a string */
          }
          nb = l_sprintf(buff, maxitem, form, p);
          break;
        }
        case 'q': {
          if (form[2] != '\0')  /* modifiers? */
            return luaL_error(L, "specifier '%%q' cannot have modifiers");
          addliteral(L, &b, arg);
          break;
        }
        case 's': {
          size_t l;
          const char *s = luaL_tolstring(L, arg, &l);
          if (form[2] == '\0')  /* no modifiers? */
            luaL_addvalue(&b);  /* keep entire string */
          else {
            luaL_argcheck(L, l == strlen(s), arg, "string contains zeros");
            if (!strchr(form, '.') && l >= 100) {
              /* no precision and string is too long to be formatted */
              luaL_addvalue(&b);  /* keep entire string */
            }
            else {  /* format the string into 'buff' */
              nb = l_sprintf(buff, maxitem, form, s);
              lua_pop(L, 1);  /* remove result from 'luaL_tolstring' */
            }
          }
          break;
        }
        default: {  /* also treat cases 'pnLlh' */
          return luaL_error(L, "invalid conversion '%s' to 'format'", form);
        }
      }
      lua_assert(nb < maxitem);
      luaL_addsize(&b, nb);
    }
  }
  luaL_pushresult(&b);
  return 1;
}

References addlenmod(), addliteral(), arg, L_ESC, l_sprintf, lua_assert, lua_gettop(), lua_number2strx, LUA_NUMBER_FRMLEN, lua_pop, lua_topointer(), LUAI_UACINT, LUAI_UACNUMBER, luaL_addchar, luaL_addsize, luaL_addvalue(), luaL_argcheck, luaL_argerror(), luaL_buffinit(), luaL_checkinteger(), luaL_checklstring(), luaL_checknumber(), luaL_error(), luaL_prepbuffsize(), luaL_pushresult(), luaL_tolstring(), MAX_FORMAT, MAX_ITEM, MAX_ITEMF, NULL, s, and scanformat().

str_gsub()

static int str_gsub ( lua_State * L )

static

Definition at line 942 of file lua-5.4.3/src/lstrlib.c.

                                   {
  size_t srcl, lp;
  const char *src = luaL_checklstring(L, 1, &srcl);  /* subject */
  const char *p = luaL_checklstring(L, 2, &lp);  /* pattern */
  const char *lastmatch = NULL;  /* end of last match */
  int tr = lua_type(L, 3);  /* replacement type */
  lua_Integer max_s = luaL_optinteger(L, 4, srcl + 1);  /* max replacements */
  int anchor = (*p == '^');
  lua_Integer n = 0;  /* replacement count */
  int changed = 0;  /* change flag */
  MatchState ms;
  luaL_Buffer b;
  luaL_argexpected(L, tr == LUA_TNUMBER || tr == LUA_TSTRING ||
                   tr == LUA_TFUNCTION || tr == LUA_TTABLE, 3,
                      "string/function/table");
  luaL_buffinit(L, &b);
  if (anchor) {
    p++; lp--;  /* skip anchor character */
  }
  prepstate(&ms, L, src, srcl, p, lp);
  while (n < max_s) {
    const char *e;
    reprepstate(&ms);  /* (re)prepare state for new match */
    if ((e = match(&ms, src, p)) != NULL && e != lastmatch) {  /* match? */
      n++;
      changed = add_value(&ms, &b, src, e, tr) | changed;
      src = lastmatch = e;
    }
    else if (src < ms.src_end)  /* otherwise, skip one character */
      luaL_addchar(&b, *src++);
    else break;  /* end of subject */
    if (anchor) break;
  }
  if (!changed)  /* no changes? */
    lua_pushvalue(L, 1);  /* return original string */
  else {  /* something changed */
    luaL_addlstring(&b, src, ms.src_end-src);
    luaL_pushresult(&b);  /* create and return new string */
  }
  lua_pushinteger(L, n);  /* number of substitutions */
  return 2;
}

References add_value(), lua_pushinteger(), lua_pushvalue(), LUA_TFUNCTION, LUA_TNUMBER, LUA_TSTRING, LUA_TTABLE, lua_type(), luaL_addchar, luaL_addlstring(), luaL_argexpected, luaL_buffinit(), luaL_checklstring(), luaL_optinteger(), luaL_pushresult(), match(), NULL, prepstate(), reprepstate(), and MatchState::src_end.

str_len()

static int str_len ( lua_State * L )

static

Definition at line 55 of file lua-5.4.3/src/lstrlib.c.

                                  {
  size_t l;
  luaL_checklstring(L, 1, &l);
  lua_pushinteger(L, (lua_Integer)l);
  return 1;
}

References lua_pushinteger(), and luaL_checklstring().

str_lower()

static int str_lower ( lua_State * L )

static

Definition at line 124 of file lua-5.4.3/src/lstrlib.c.

                                    {
  size_t l;
  size_t i;
  luaL_Buffer b;
  const char *s = luaL_checklstring(L, 1, &l);
  char *p = luaL_buffinitsize(L, &b, l);
  for (i=0; i<l; i++)
    p[i] = tolower(uchar(s[i]));
  luaL_pushresultsize(&b, l);
  return 1;
}

References luaL_buffinitsize(), luaL_checklstring(), luaL_pushresultsize(), s, and uchar.

str_match()

static int str_match ( lua_State * L )

static

Definition at line 824 of file lua-5.4.3/src/lstrlib.c.

                                    {
  return str_find_aux(L, 0);
}

References str_find_aux().

str_pack()

static int str_pack ( lua_State * L )

static

Definition at line 1544 of file lua-5.4.3/src/lstrlib.c.

                                   {
  luaL_Buffer b;
  Header h;
  const char *fmt = luaL_checkstring(L, 1);  /* format string */
  int arg = 1;  /* current argument to pack */
  size_t totalsize = 0;  /* accumulate total size of result */
  initheader(L, &h);
  lua_pushnil(L);  /* mark to separate arguments from string buffer */
  luaL_buffinit(L, &b);
  while (*fmt != '\0') {
    int size, ntoalign;
    KOption opt = getdetails(&h, totalsize, &fmt, &size, &ntoalign);
    totalsize += ntoalign + size;
    while (ntoalign-- > 0)
     luaL_addchar(&b, LUAL_PACKPADBYTE);  /* fill alignment */
    arg++;
    switch (opt) {
      case Kint: {  /* signed integers */
        lua_Integer n = luaL_checkinteger(L, arg);
        if (size < SZINT) {  /* need overflow check? */
          lua_Integer lim = (lua_Integer)1 << ((size * NB) - 1);
          luaL_argcheck(L, -lim <= n && n < lim, arg, "integer overflow");
        }
        packint(&b, (lua_Unsigned)n, h.islittle, size, (n < 0));
        break;
      }
      case Kuint: {  /* unsigned integers */
        lua_Integer n = luaL_checkinteger(L, arg);
        if (size < SZINT)  /* need overflow check? */
          luaL_argcheck(L, (lua_Unsigned)n < ((lua_Unsigned)1 << (size * NB)),
                           arg, "unsigned overflow");
        packint(&b, (lua_Unsigned)n, h.islittle, size, 0);
        break;
      }
      case Kfloat: {  /* C float */
        float f = (float)luaL_checknumber(L, arg);  /* get argument */
        char *buff = luaL_prepbuffsize(&b, sizeof(f));
        /* move 'f' to final result, correcting endianness if needed */
        copywithendian(buff, (char *)&f, sizeof(f), h.islittle);
        luaL_addsize(&b, size);
        break;
      }
      case Knumber: {  /* Lua float */
        lua_Number f = luaL_checknumber(L, arg);  /* get argument */
        char *buff = luaL_prepbuffsize(&b, sizeof(f));
        /* move 'f' to final result, correcting endianness if needed */
        copywithendian(buff, (char *)&f, sizeof(f), h.islittle);
        luaL_addsize(&b, size);
        break;
      }
      case Kdouble: {  /* C double */
        double f = (double)luaL_checknumber(L, arg);  /* get argument */
        char *buff = luaL_prepbuffsize(&b, sizeof(f));
        /* move 'f' to final result, correcting endianness if needed */
        copywithendian(buff, (char *)&f, sizeof(f), h.islittle);
        luaL_addsize(&b, size);
        break;
      }
      case Kchar: {  /* fixed-size string */
        size_t len;
        const char *s = luaL_checklstring(L, arg, &len);
        luaL_argcheck(L, len <= (size_t)size, arg,
                         "string longer than given size");
        luaL_addlstring(&b, s, len);  /* add string */
        while (len++ < (size_t)size)  /* pad extra space */
          luaL_addchar(&b, LUAL_PACKPADBYTE);
        break;
      }
      case Kstring: {  /* strings with length count */
        size_t len;
        const char *s = luaL_checklstring(L, arg, &len);
        luaL_argcheck(L, size >= (int)sizeof(size_t) ||
                         len < ((size_t)1 << (size * NB)),
                         arg, "string length does not fit in given size");
        packint(&b, (lua_Unsigned)len, h.islittle, size, 0);  /* pack length */
        luaL_addlstring(&b, s, len);
        totalsize += len;
        break;
      }
      case Kzstr: {  /* zero-terminated string */
        size_t len;
        const char *s = luaL_checklstring(L, arg, &len);
        luaL_argcheck(L, strlen(s) == len, arg, "string contains zeros");
        luaL_addlstring(&b, s, len);
        luaL_addchar(&b, '\0');  /* add zero at the end */
        totalsize += len + 1;
        break;
      }
      case Kpadding: luaL_addchar(&b, LUAL_PACKPADBYTE);  /* FALLTHROUGH */
      case Kpaddalign: case Knop:
        arg--;  /* undo increment */
        break;
    }
  }
  luaL_pushresult(&b);
  return 1;
}

References arg, copywithendian(), getdetails(), initheader(), Header::islittle, Kchar, Kdouble, Kfloat, Kint, Knop, Knumber, Kpaddalign, Kpadding, Kstring, Kuint, Kzstr, lua_pushnil(), luaL_addchar, luaL_addlstring(), luaL_addsize, luaL_argcheck, luaL_buffinit(), luaL_checkinteger(), luaL_checklstring(), luaL_checknumber(), luaL_checkstring, LUAL_PACKPADBYTE, luaL_prepbuffsize(), luaL_pushresult(), NB, packint(), s, and SZINT.

str_packsize()

static int str_packsize ( lua_State * L )

static

Definition at line 1643 of file lua-5.4.3/src/lstrlib.c.

                                       {
  Header h;
  const char *fmt = luaL_checkstring(L, 1);  /* format string */
  size_t totalsize = 0;  /* accumulate total size of result */
  initheader(L, &h);
  while (*fmt != '\0') {
    int size, ntoalign;
    KOption opt = getdetails(&h, totalsize, &fmt, &size, &ntoalign);
    luaL_argcheck(L, opt != Kstring && opt != Kzstr, 1,
                     "variable-length format");
    size += ntoalign;  /* total space used by option */
    luaL_argcheck(L, totalsize <= MAXSIZE - size, 1,
                     "format result too large");
    totalsize += size;
  }
  lua_pushinteger(L, (lua_Integer)totalsize);
  return 1;
}

References getdetails(), initheader(), Kstring, Kzstr, lua_pushinteger(), luaL_argcheck, luaL_checkstring, and MAXSIZE.

str_rep()

static int str_rep ( lua_State * L )

static

Definition at line 150 of file lua-5.4.3/src/lstrlib.c.

                                  {
  size_t l, lsep;
  const char *s = luaL_checklstring(L, 1, &l);
  lua_Integer n = luaL_checkinteger(L, 2);
  const char *sep = luaL_optlstring(L, 3, "", &lsep);
  if (n <= 0)
    lua_pushliteral(L, "");
  else if (l_unlikely(l + lsep < l || l + lsep > MAXSIZE / n))
    return luaL_error(L, "resulting string too large");
  else {
    size_t totallen = (size_t)n * l + (size_t)(n - 1) * lsep;
    luaL_Buffer b;
    char *p = luaL_buffinitsize(L, &b, totallen);
    while (n-- > 1) {  /* first n-1 copies (followed by separator) */
      memcpy(p, s, l * sizeof(char)); p += l;
      if (lsep > 0) {  /* empty 'memcpy' is not that cheap */
        memcpy(p, sep, lsep * sizeof(char));
        p += lsep;
      }
    }
    memcpy(p, s, l * sizeof(char));  /* last copy (not followed by separator) */
    luaL_pushresultsize(&b, totallen);
  }
  return 1;
}

References lua_pushliteral, luaL_buffinitsize(), luaL_checkinteger(), luaL_checklstring(), luaL_error(), luaL_optlstring(), luaL_pushresultsize(), MAXSIZE, and s.

str_reverse()

static int str_reverse ( lua_State * L )

static

Definition at line 112 of file lua-5.4.3/src/lstrlib.c.

                                      {
  size_t l, i;
  luaL_Buffer b;
  const char *s = luaL_checklstring(L, 1, &l);
  char *p = luaL_buffinitsize(L, &b, l);
  for (i = 0; i < l; i++)
    p[i] = s[l - i - 1];
  luaL_pushresultsize(&b, l);
  return 1;
}

References luaL_buffinitsize(), luaL_checklstring(), luaL_pushresultsize(), and s.

str_sub()

static int str_sub ( lua_State * L )

static

Definition at line 100 of file lua-5.4.3/src/lstrlib.c.

                                  {
  size_t l;
  const char *s = luaL_checklstring(L, 1, &l);
  size_t start = posrelatI(luaL_checkinteger(L, 2), l);
  size_t end = getendpos(L, 3, -1, l);
  if (start <= end)
    lua_pushlstring(L, s + start - 1, (end - start) + 1);
  else lua_pushliteral(L, "");
  return 1;
}

References getendpos(), lua_pushliteral, lua_pushlstring(), luaL_checkinteger(), luaL_checklstring(), posrelatI(), and s.

str_unpack()

static int str_unpack ( lua_State * L )

static

Definition at line 1697 of file lua-5.4.3/src/lstrlib.c.

                                     {
  Header h;
  const char *fmt = luaL_checkstring(L, 1);
  size_t ld;
  const char *data = luaL_checklstring(L, 2, &ld);
  size_t pos = posrelatI(luaL_optinteger(L, 3, 1), ld) - 1;
  int n = 0;  /* number of results */
  luaL_argcheck(L, pos <= ld, 3, "initial position out of string");
  initheader(L, &h);
  while (*fmt != '\0') {
    int size, ntoalign;
    KOption opt = getdetails(&h, pos, &fmt, &size, &ntoalign);
    luaL_argcheck(L, (size_t)ntoalign + size <= ld - pos, 2,
                    "data string too short");
    pos += ntoalign;  /* skip alignment */
    /* stack space for item + next position */
    luaL_checkstack(L, 2, "too many results");
    n++;
    switch (opt) {
      case Kint:
      case Kuint: {
        lua_Integer res = unpackint(L, data + pos, h.islittle, size,
                                       (opt == Kint));
        lua_pushinteger(L, res);
        break;
      }
      case Kfloat: {
        float f;
        copywithendian((char *)&f, data + pos, sizeof(f), h.islittle);
        lua_pushnumber(L, (lua_Number)f);
        break;
      }
      case Knumber: {
        lua_Number f;
        copywithendian((char *)&f, data + pos, sizeof(f), h.islittle);
        lua_pushnumber(L, f);
        break;
      }
      case Kdouble: {
        double f;
        copywithendian((char *)&f, data + pos, sizeof(f), h.islittle);
        lua_pushnumber(L, (lua_Number)f);
        break;
      }
      case Kchar: {
        lua_pushlstring(L, data + pos, size);
        break;
      }
      case Kstring: {
        size_t len = (size_t)unpackint(L, data + pos, h.islittle, size, 0);
        luaL_argcheck(L, len <= ld - pos - size, 2, "data string too short");
        lua_pushlstring(L, data + pos + size, len);
        pos += len;  /* skip string */
        break;
      }
      case Kzstr: {
        size_t len = strlen(data + pos);
        luaL_argcheck(L, pos + len < ld, 2,
                         "unfinished string for format 'z'");
        lua_pushlstring(L, data + pos, len);
        pos += len + 1;  /* skip string plus final '\0' */
        break;
      }
      case Kpaddalign: case Kpadding: case Knop:
        n--;  /* undo increment */
        break;
    }
    pos += size;
  }
  lua_pushinteger(L, pos + 1);  /* next position */
  return n + 1;
}

References copywithendian(), getdetails(), initheader(), Header::islittle, Kchar, Kdouble, Kfloat, Kint, Knop, Knumber, Kpaddalign, Kpadding, Kstring, Kuint, Kzstr, lua_pushinteger(), lua_pushlstring(), lua_pushnumber(), luaL_argcheck, luaL_checklstring(), luaL_checkstack(), luaL_checkstring, luaL_optinteger(), posrelatI(), and unpackint().

str_upper()

static int str_upper ( lua_State * L )

static

Definition at line 137 of file lua-5.4.3/src/lstrlib.c.

                                    {
  size_t l;
  size_t i;
  luaL_Buffer b;
  const char *s = luaL_checklstring(L, 1, &l);
  char *p = luaL_buffinitsize(L, &b, l);
  for (i=0; i<l; i++)
    p[i] = toupper(uchar(s[i]));
  luaL_pushresultsize(&b, l);
  return 1;
}

References luaL_buffinitsize(), luaL_checklstring(), luaL_pushresultsize(), s, and uchar.

tonum()

static int tonum ( lua_State * L, int arg )

static

Definition at line 264 of file lua-5.4.3/src/lstrlib.c.

                                         {
  if (lua_type(L, arg) == LUA_TNUMBER) {  /* already a number? */
    lua_pushvalue(L, arg);
    return 1;
  }
  else {  /* check whether it is a numerical string */
    size_t len;
    const char *s = lua_tolstring(L, arg, &len);
    return (s != NULL && lua_stringtonumber(L, s) == len + 1);
  }
}

References arg, lua_pushvalue(), lua_stringtonumber(), LUA_TNUMBER, lua_tolstring(), lua_type(), NULL, and s.

Referenced by arith().

trymt()

static void trymt ( lua_State * L, const char * mtname )

static

Definition at line 277 of file lua-5.4.3/src/lstrlib.c.

                                                     {
  lua_settop(L, 2);  /* back to the original arguments */
  if (l_unlikely(lua_type(L, 2) == LUA_TSTRING ||
                 !luaL_getmetafield(L, 2, mtname)))
    luaL_error(L, "attempt to %s a '%s' with a '%s'", mtname + 2,
                  luaL_typename(L, -2), luaL_typename(L, -1));
  lua_insert(L, -3);  /* put metamethod before arguments */
  lua_call(L, 2, 1);  /* call metamethod */
}

References lua_call, lua_insert, lua_settop(), LUA_TSTRING, lua_type(), luaL_error(), luaL_getmetafield(), and luaL_typename.

Referenced by arith().

unpackint()

static lua_Integer unpackint ( lua_State * L, const char * str, int islittle, int size, int issigned )

static

Definition at line 1671 of file lua-5.4.3/src/lstrlib.c.

                                                                    {
  lua_Unsigned res = 0;
  int i;
  int limit = (size  <= SZINT) ? size : SZINT;
  for (i = limit - 1; i >= 0; i--) {
    res <<= NB;
    res |= (lua_Unsigned)(unsigned char)str[islittle ? i : size - 1 - i];
  }
  if (size < SZINT) {  /* real size smaller than lua_Integer? */
    if (issigned) {  /* needs sign extension? */
      lua_Unsigned mask = (lua_Unsigned)1 << (size*NB - 1);
      res = ((res ^ mask) - mask);  /* do sign extension */
    }
  }
  else if (size > SZINT) {  /* must check unread bytes */
    int mask = (!issigned || (lua_Integer)res >= 0) ? 0 : MC;
    for (i = limit; i < size; i++) {
      if (l_unlikely((unsigned char)str[islittle ? i : size - 1 - i] != mask))
        luaL_error(L, "%d-byte integer does not fit into Lua Integer", size);
    }
  }
  return (lua_Integer)res;
}

References luaL_error(), mask, MC, NB, and SZINT.

Referenced by str_unpack().

writer()

static int writer ( lua_State * L, const void * b, size_t size, void * ud )

static

Definition at line 222 of file lua-5.4.3/src/lstrlib.c.

                                                                       {
  struct str_Writer *state = (struct str_Writer *)ud;
  if (!state->init) {
    state->init = 1;
    luaL_buffinit(L, &state->B);
  }
  luaL_addlstring(&state->B, (const char *)b, size);
  return 0;
}

References str_Writer::B, str_Writer::init, luaL_addlstring(), and luaL_buffinit().

Referenced by str_dump().

Variable Documentation

dummy

int dummy

Definition at line 1350 of file lua-5.4.3/src/lstrlib.c.

little

char little

Definition at line 1351 of file lua-5.4.3/src/lstrlib.c.

[union]

const union { ... } nativeendian

Referenced by copywithendian(), getoption(), and initheader().

stringmetamethods

const luaL_Reg stringmetamethods[]

static

Initial value:

= {
  {"__add", arith_add},
  {"__sub", arith_sub},
  {"__mul", arith_mul},
  {"__mod", arith_mod},
  {"__pow", arith_pow},
  {"__div", arith_div},
  {"__idiv", arith_idiv},
  {"__unm", arith_unm},
  {"__index", NULL},  
  {NULL, NULL}
}

Definition at line 330 of file lua-5.4.3/src/lstrlib.c.

                                            {
  {"__add", arith_add},
  {"__sub", arith_sub},
  {"__mul", arith_mul},
  {"__mod", arith_mod},
  {"__pow", arith_pow},
  {"__div", arith_div},
  {"__idiv", arith_idiv},
  {"__unm", arith_unm},
  {"__index", NULL},  /* placeholder */
  {NULL, NULL}
};

Referenced by createmetatable().

strlib

const luaL_Reg strlib[]

static

Initial value:

= {
  {"byte", str_byte},
  {"char", str_char},
  {"dump", str_dump},
  {"find", str_find},
  {"format", str_format},
  {"gmatch", gmatch},
  {"gsub", str_gsub},
  {"len", str_len},
  {"lower", str_lower},
  {"match", str_match},
  {"rep", str_rep},
  {"reverse", str_reverse},
  {"sub", str_sub},
  {"upper", str_upper},
  {"pack", str_pack},
  {"packsize", str_packsize},
  {"unpack", str_unpack},
  {NULL, NULL}
}

Definition at line 1773 of file lua-5.4.3/src/lstrlib.c.

                                 {
  {"byte", str_byte},
  {"char", str_char},
  {"dump", str_dump},
  {"find", str_find},
  {"format", str_format},
  {"gmatch", gmatch},
  {"gsub", str_gsub},
  {"len", str_len},
  {"lower", str_lower},
  {"match", str_match},
  {"rep", str_rep},
  {"reverse", str_reverse},
  {"sub", str_sub},
  {"upper", str_upper},
  {"pack", str_pack},
  {"packsize", str_packsize},
  {"unpack", str_unpack},
  {NULL, NULL}
};

Referenced by luaopen_string().