/* * decode.c * Copyright (C) 2000-2003 Michel Lespinasse * Copyright (C) 1999-2000 Aaron Holtzman * * This file is part of mpeg2dec, a free MPEG-2 video stream decoder. * See http://libmpeg2.sourceforge.net/ for updates. * * mpeg2dec is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * mpeg2dec is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * * $Id$ * libmpeg2 sync history: * 2008-07-01 - CVS revision 1.114 */ #include "plugin.h" #include "mpeg2dec_config.h" #include "mpeg2.h" #include "attributes.h" #include "mpeg2_internal.h" #define BUFFER_SIZE (1194 * 1024) #if defined(CPU_COLDFIRE) || (defined(CPU_ARM) && ARM_ARCH >= 6) /* twice as large as on other targets because coldfire uses * a secondary, transposed buffer for optimisation */ static int16_t static_dct_block[128] IBSS_ATTR ATTR_ALIGN(16); #define DCT_BLOCKSIZE (128 * sizeof (int16_t)) #else static int16_t static_dct_block[64] IBSS_ATTR ATTR_ALIGN(16); #define DCT_BLOCKSIZE (64 * sizeof (int16_t)) #endif const mpeg2_info_t * mpeg2_info (mpeg2dec_t * mpeg2dec) { return &mpeg2dec->info; } static inline int skip_chunk (mpeg2dec_t * mpeg2dec, int bytes) { uint8_t * current; uint32_t shift; uint8_t * limit; uint8_t byte; if (!bytes) return 0; current = mpeg2dec->buf_start; shift = mpeg2dec->shift; limit = current + bytes; do { byte = *current++; if (shift == 0x00000100) { int skipped; mpeg2dec->shift = 0xffffff00; skipped = current - mpeg2dec->buf_start; mpeg2dec->buf_start = current; return skipped; } shift = (shift | byte) << 8; } while (current < limit); mpeg2dec->shift = shift; mpeg2dec->buf_start = current; return 0; } static inline int copy_chunk (mpeg2dec_t * mpeg2dec, int bytes) { uint8_t * current; uint32_t shift; uint8_t * chunk_ptr; uint8_t * limit; uint8_t byte; if (!bytes) return 0; current = mpeg2dec->buf_start; shift = mpeg2dec->shift; chunk_ptr = mpeg2dec->chunk_ptr; limit = current + bytes; do { byte = *current++; if (shift == 0x00000100) { int copied; mpeg2dec->shift = 0xffffff00; mpeg2dec->chunk_ptr = chunk_ptr + 1; copied = current - mpeg2dec->buf_start; mpeg2dec->buf_start = current; return copied; } shift = (shift | byte) << 8; *chunk_ptr++ = byte; } while (current < limit); mpeg2dec->shift = shift; mpeg2dec->buf_start = current; return 0; } void mpeg2_buffer (mpeg2dec_t * mpeg2dec, uint8_t * start, uint8_t * end) { mpeg2dec->buf_start = start; mpeg2dec->buf_end = end; } int mpeg2_getpos (mpeg2dec_t * mpeg2dec) { return mpeg2dec->buf_end - mpeg2dec->buf_start; } static inline mpeg2_state_t seek_chunk (mpeg2dec_t * mpeg2dec) { int size, skipped; size = mpeg2dec->buf_end - mpeg2dec->buf_start; skipped = skip_chunk (mpeg2dec, size); if (!skipped) { mpeg2dec->bytes_since_tag += size; return STATE_BUFFER; } mpeg2dec->bytes_since_tag += skipped; mpeg2dec->code = mpeg2dec->buf_start[-1]; return STATE_INTERNAL_NORETURN; } mpeg2_state_t mpeg2_seek_header (mpeg2dec_t * mpeg2dec) { while (!(mpeg2dec->code == 0xb3 || ((mpeg2dec->code == 0xb7 || mpeg2dec->code == 0xb8 || !mpeg2dec->code) && mpeg2dec->sequence.width != (unsigned)-1))) { if (seek_chunk (mpeg2dec) == STATE_BUFFER) return STATE_BUFFER; } mpeg2dec->chunk_start = mpeg2dec->chunk_ptr = mpeg2dec->chunk_buffer; mpeg2dec->user_data_len = 0; return ((mpeg2dec->code == 0xb7) ? mpeg2_header_end(mpeg2dec) : mpeg2_parse_header(mpeg2dec)); } #define RECEIVED(code,state) (((state) << 8) + (code)) mpeg2_state_t mpeg2_parse (mpeg2dec_t * mpeg2dec) { int size_buffer, size_chunk, copied; if (mpeg2dec->action) { mpeg2_state_t state; state = mpeg2dec->action (mpeg2dec); if ((int)state > (int)STATE_INTERNAL_NORETURN) return state; } while (1) { while ((unsigned) (mpeg2dec->code - mpeg2dec->first_decode_slice) < mpeg2dec->nb_decode_slices) { size_buffer = mpeg2dec->buf_end - mpeg2dec->buf_start; size_chunk = mpeg2dec->chunk_buffer + BUFFER_SIZE - mpeg2dec->chunk_ptr; if (size_buffer <= size_chunk) { copied = copy_chunk (mpeg2dec, size_buffer); if (!copied) { mpeg2dec->bytes_since_tag += size_buffer; mpeg2dec->chunk_ptr += size_buffer; return STATE_BUFFER; } } else { copied = copy_chunk (mpeg2dec, size_chunk); if (!copied) { /* filled the chunk buffer without finding a start code */ mpeg2dec->bytes_since_tag += size_chunk; mpeg2dec->action = seek_chunk; return STATE_INVALID; } } mpeg2dec->bytes_since_tag += copied; mpeg2_slice (&mpeg2dec->decoder, mpeg2dec->code, mpeg2dec->chunk_start); mpeg2dec->code = mpeg2dec->buf_start[-1]; mpeg2dec->chunk_ptr = mpeg2dec->chunk_start; } if ((unsigned) (mpeg2dec->code - 1) >= 0xb0 - 1) break; if (seek_chunk (mpeg2dec) == STATE_BUFFER) return STATE_BUFFER; } mpeg2dec->action = mpeg2_seek_header; switch (mpeg2dec->code) { case 0x00: return mpeg2dec->state; case 0xb3: case 0xb7: case 0xb8: return (mpeg2dec->state == STATE_SLICE) ? STATE_SLICE : STATE_INVALID; default: mpeg2dec->action = seek_chunk; return STATE_INVALID; } } mpeg2_state_t mpeg2_parse_header (mpeg2dec_t * mpeg2dec) { static int (* const process_header[9]) (mpeg2dec_t *) = { mpeg2_header_picture, mpeg2_header_extension, mpeg2_header_user_data, mpeg2_header_sequence, NULL, NULL, NULL, NULL, mpeg2_header_gop }; int size_buffer, size_chunk, copied; mpeg2dec->action = mpeg2_parse_header; mpeg2dec->info.user_data = NULL; mpeg2dec->info.user_data_len = 0; while (1) { size_buffer = mpeg2dec->buf_end - mpeg2dec->buf_start; size_chunk = mpeg2dec->chunk_buffer + BUFFER_SIZE - mpeg2dec->chunk_ptr; if (size_buffer <= size_chunk) { copied = copy_chunk (mpeg2dec, size_buffer); if (!copied) { mpeg2dec->bytes_since_tag += size_buffer; mpeg2dec->chunk_ptr += size_buffer; return STATE_BUFFER; } } else { copied = copy_chunk (mpeg2dec, size_chunk); if (!copied) { /* filled the chunk buffer without finding a start code */ mpeg2dec->bytes_since_tag += size_chunk; mpeg2dec->code = 0xb4; mpeg2dec->action = mpeg2_seek_header; return STATE_INVALID; } } mpeg2dec->bytes_since_tag += copied; if (process_header[mpeg2dec->code & 0x0b] (mpeg2dec)) { mpeg2dec->code = mpeg2dec->buf_start[-1]; mpeg2dec->action = mpeg2_seek_header; return STATE_INVALID; } mpeg2dec->code = mpeg2dec->buf_start[-1]; switch (RECEIVED (mpeg2dec->code, mpeg2dec->state)) { /* state transition after a sequence header */ case RECEIVED (0x00, STATE_SEQUENCE): case RECEIVED (0xb8, STATE_SEQUENCE): mpeg2_header_sequence_finalize (mpeg2dec); break; /* other legal state transitions */ case RECEIVED (0x00, STATE_GOP): mpeg2_header_gop_finalize (mpeg2dec); break; case RECEIVED (0x01, STATE_PICTURE): case RECEIVED (0x01, STATE_PICTURE_2ND): mpeg2_header_picture_finalize (mpeg2dec); mpeg2dec->action = mpeg2_header_slice_start; break; /* legal headers within a given state */ case RECEIVED (0xb2, STATE_SEQUENCE): case RECEIVED (0xb2, STATE_GOP): case RECEIVED (0xb2, STATE_PICTURE): case RECEIVED (0xb2, STATE_PICTURE_2ND): case RECEIVED (0xb5, STATE_SEQUENCE): case RECEIVED (0xb5, STATE_PICTURE): case RECEIVED (0xb5, STATE_PICTURE_2ND): mpeg2dec->chunk_ptr = mpeg2dec->chunk_start; continue; default: mpeg2dec->action = mpeg2_seek_header; return STATE_INVALID; } mpeg2dec->chunk_start = mpeg2dec->chunk_ptr = mpeg2dec->chunk_buffer; mpeg2dec->user_data_len = 0; return mpeg2dec->state; } } int mpeg2_convert (mpeg2dec_t * mpeg2dec, mpeg2_convert_t convert, void * arg) { mpeg2_convert_init_t convert_init; int error; error = convert (MPEG2_CONVERT_SET, NULL, &mpeg2dec->sequence, 0, arg, &convert_init); if (!error) { mpeg2dec->convert = convert; mpeg2dec->convert_arg = arg; mpeg2dec->convert_id_size = convert_init.id_size; mpeg2dec->convert_stride = 0; } return error; } int mpeg2_stride (mpeg2dec_t * mpeg2dec, int stride) { if (!mpeg2dec->convert) { if (stride < (int) mpeg2dec->sequence.width) stride = mpeg2dec->sequence.width; mpeg2dec->decoder.stride_frame = stride; } else { mpeg2_convert_init_t convert_init; stride = mpeg2dec->convert(MPEG2_CONVERT_STRIDE, NULL, &mpeg2dec->sequence, stride, mpeg2dec->convert_arg, &convert_init); mpeg2dec->convert_id_size = convert_init.id_size; mpeg2dec->convert_stride = stride; } return stride; } void mpeg2_set_buf (mpeg2dec_t * mpeg2dec, uint8_t * buf[MPEG2_COMPONENTS], void * id) { mpeg2_fbuf_t * fbuf; if (mpeg2dec->custom_fbuf) { if (mpeg2dec->state == STATE_SEQUENCE) { mpeg2dec->fbuf[2] = mpeg2dec->fbuf[1]; mpeg2dec->fbuf[1] = mpeg2dec->fbuf[0]; } mpeg2_set_fbuf (mpeg2dec, (mpeg2dec->decoder.coding_type == PIC_FLAG_CODING_TYPE_B)); fbuf = mpeg2dec->fbuf[0]; } else { fbuf = &mpeg2dec->fbuf_alloc[mpeg2dec->alloc_index].fbuf; mpeg2dec->alloc_index_user = ++mpeg2dec->alloc_index; } fbuf->buf[0] = buf[0]; #if MPEG2_COLOR fbuf->buf[1] = buf[1]; fbuf->buf[2] = buf[2]; #endif fbuf->id = id; } void mpeg2_custom_fbuf (mpeg2dec_t * mpeg2dec, int custom_fbuf) { mpeg2dec->custom_fbuf = custom_fbuf; } void mpeg2_skip (mpeg2dec_t * mpeg2dec, int skip) { mpeg2dec->first_decode_slice = 1; mpeg2dec->nb_decode_slices = skip ? 0 : (0xb0 - 1); } void mpeg2_slice_region (mpeg2dec_t * mpeg2dec, int start, int end) { start = (start < 1) ? 1 : (start > 0xb0) ? 0xb0 : start; end = (end < start) ? start : (end > 0xb0) ? 0xb0 : end; mpeg2dec->first_decode_slice = start; mpeg2dec->nb_decode_slices = end - start; } void mpeg2_tag_picture (mpeg2dec_t * mpeg2dec, uint32_t tag, uint32_t tag2) { mpeg2dec->tag_previous = mpeg2dec->tag_current; mpeg2dec->tag2_previous = mpeg2dec->tag2_current; mpeg2dec->tag_current = tag; mpeg2dec->tag2_current = tag2; mpeg2dec->num_tags++; mpeg2dec->bytes_since_tag = 0; } void mpeg2_reset (mpeg2dec_t * mpeg2dec, int full_reset) { mpeg2dec->buf_start = mpeg2dec->buf_end = NULL; mpeg2dec->num_tags = 0; mpeg2dec->shift = 0xffffff00; mpeg2dec->code = 0xb4; mpeg2dec->action = mpeg2_seek_header; mpeg2dec->state = STATE_INVALID; mpeg2dec->first = 1; mpeg2_reset_info(&mpeg2dec->info); mpeg2dec->info.gop = NULL; mpeg2dec->info.user_data = NULL; mpeg2dec->info.user_data_len = 0; if (full_reset) { mpeg2dec->info.sequence = NULL; mpeg2_header_state_init (mpeg2dec); } } mpeg2dec_t * mpeg2_init (void) { mpeg2dec_t * mpeg2dec; mpeg2_idct_init (); mpeg2dec = (mpeg2dec_t *)mpeg2_bufalloc(sizeof (mpeg2dec_t), MPEG2_ALLOC_MPEG2DEC); if (mpeg2dec == NULL) return NULL; mpeg2dec->decoder.DCTblock = static_dct_block; rb->memset (mpeg2dec->decoder.DCTblock, 0, DCT_BLOCKSIZE); DEBUGF("DCTblock: %p\n", mpeg2dec->decoder.DCTblock); mpeg2dec->chunk_buffer = (uint8_t *)mpeg2_bufalloc(BUFFER_SIZE + 4, MPEG2_ALLOC_CHUNK); mpeg2dec->sequence.width = (unsigned)-1; mpeg2_reset (mpeg2dec, 1); return mpeg2dec; } void mpeg2_close (mpeg2dec_t * mpeg2dec) { mpeg2_header_state_init (mpeg2dec); #if 0 /* These are dedicated buffers in rockbox */ mpeg2_free (mpeg2dec->chunk_buffer); mpeg2_free (mpeg2dec); #endif } n307' href='#n307'>307 308 309 310 311 312 313 314 315 
/*
** $Id: loadlib.c,v 1.52.1.3 2008/08/06 13:29:28 roberto Exp $
** Dynamic library loader for Lua
** See Copyright Notice in lua.h
**
** This module contains an implementation of loadlib for Unix systems
** that have dlfcn, an implementation for Darwin (Mac OS X), an
** implementation for Windows, and a stub for other systems.
*/


#include <stdlib.h>
#include <string.h>


#define loadlib_c
#define LUA_LIB

#include "lua.h"

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


#define setprogdir(L)       ((void)0)


/*
** {======================================================
** 'require' function
** =======================================================
*/


static int readable (const char *filename) {
  int f = rb->open(filename, O_RDONLY);  /* try to open file */
  if (f < 0) return 0;  /* open failed */
  rb->close(f);
  return 1;
}


static const char *pushnexttemplate (lua_State *L, const char *path) {
  const char *l;
  while (*path == *LUA_PATHSEP) path++;  /* skip separators */
  if (*path == '\0') return NULL;  /* no more templates */
  l = strchr(path, *LUA_PATHSEP);  /* find next separator */
  if (l == NULL) l = path + strlen(path);
  lua_pushlstring(L, path, l - path);  /* template */
  return l;
}


static const char *findfile (lua_State *L, const char *name,
                                           const char *pname) {
  const char *path, *current_path = get_current_path(L, 2);
  name = luaL_gsub(L, name, ".", LUA_DIRSEP);
  lua_getfield(L, LUA_ENVIRONINDEX, pname);
  path = lua_tostring(L, -1);
  if (path == NULL)
    luaL_error(L, LUA_QL("package.%s") " must be a string", pname);
  lua_pushliteral(L, "");  /* error accumulator */
  while ((path = pushnexttemplate(L, path)) != NULL) {
    const char *filename;
    filename = luaL_gsub(L, lua_tostring(L, -1), LUA_PATH_MARK, name);
    if(current_path != NULL) filename = luaL_gsub(L, filename, "$", current_path);
    lua_remove(L, -2);  /* remove path template */
    if (readable(filename))  /* does file exist and is readable? */
      return filename;  /* return that file name */
    lua_pushfstring(L, "\n\tno file " LUA_QS, filename);
    lua_remove(L, -2);  /* remove file name */
    lua_concat(L, 2);  /* add entry to possible error message */
  }
  return NULL;  /* not found */
}


static void loaderror (lua_State *L, const char *filename) {
  luaL_error(L, "error loading module " LUA_QS " from file " LUA_QS ":\n\t%s",
                lua_tostring(L, 1), filename, lua_tostring(L, -1));
}


static int loader_Lua (lua_State *L) {
  const char *filename;
  const char *name = luaL_checkstring(L, 1);
  filename = findfile(L, name, "path");
  if (filename == NULL) return 1;  /* library not found in this path */
  if (luaL_loadfile(L, filename) != 0)
    loaderror(L, filename);
  return 1;  /* library loaded successfully */
}


static int loader_preload (lua_State *L) {
  const char *name = luaL_checkstring(L, 1);
  lua_getfield(L, LUA_ENVIRONINDEX, "preload");
  if (!lua_istable(L, -1))
    luaL_error(L, LUA_QL("package.preload") " must be a table");
  lua_getfield(L, -1, name);
  if (lua_isnil(L, -1))  /* not found? */
    lua_pushfstring(L, "\n\tno field package.preload['%s']", name);
  return 1;
}


static const int sentinel_ = 0;
#define sentinel    ((void *)&sentinel_)


static int ll_require (lua_State *L) {
  const char *name = luaL_checkstring(L, 1);
  int i;
  lua_settop(L, 1);  /* _LOADED table will be at index 2 */
  lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED");
  lua_getfield(L, 2, name);
  if (lua_toboolean(L, -1)) {  /* is it there? */
    if (lua_touserdata(L, -1) == sentinel)  /* check loops */
      luaL_error(L, "loop or previous error loading module " LUA_QS, name);
    return 1;  /* package is already loaded */
  }
  /* else must load it; iterate over available loaders */
  lua_getfield(L, LUA_ENVIRONINDEX, "loaders");
  if (!lua_istable(L, -1))
    luaL_error(L, LUA_QL("package.loaders") " must be a table");
  lua_pushliteral(L, "");  /* error message accumulator */
  for (i=1; ; i++) {
    lua_rawgeti(L, -2, i);  /* get a loader */
    if (lua_isnil(L, -1))
      luaL_error(L, "module " LUA_QS " not found:%s",
                    name, lua_tostring(L, -2));
    lua_pushstring(L, name);
    lua_call(L, 1, 1);  /* call it */
    if (lua_isfunction(L, -1))  /* did it find module? */
      break;  /* module loaded successfully */
    else if (lua_isstring(L, -1))  /* loader returned error message? */
      lua_concat(L, 2);  /* accumulate it */
    else
      lua_pop(L, 1);
  }
  lua_pushlightuserdata(L, sentinel);
  lua_setfield(L, 2, name);  /* _LOADED[name] = sentinel */
  lua_pushstring(L, name);  /* pass name as argument to module */
  lua_call(L, 1, 1);  /* run loaded module */
  if (!lua_isnil(L, -1))  /* non-nil return? */
    lua_setfield(L, 2, name);  /* _LOADED[name] = returned value */
  lua_getfield(L, 2, name);
  if (lua_touserdata(L, -1) == sentinel) {   /* module did not set a value? */
    lua_pushboolean(L, 1);  /* use true as result */
    lua_pushvalue(L, -1);  /* extra copy to be returned */
    lua_setfield(L, 2, name);  /* _LOADED[name] = true */
  }
  return 1;
}

/* }====================================================== */



/*
** {======================================================
** 'module' function
** =======================================================
*/
  

static void setfenv (lua_State *L) {
  lua_Debug ar;
  if (lua_getstack(L, 1, &ar) == 0 ||
      lua_getinfo(L, "f", &ar) == 0 ||  /* get calling function */
      lua_iscfunction(L, -1))
    luaL_error(L, LUA_QL("module") " not called from a Lua function");
  lua_pushvalue(L, -2);
  lua_setfenv(L, -2);
  lua_pop(L, 1);
}


static void dooptions (lua_State *L, int n) {
  int i;
  for (i = 2; i <= n; i++) {
    lua_pushvalue(L, i);  /* get option (a function) */
    lua_pushvalue(L, -2);  /* module */
    lua_call(L, 1, 0);
  }
}


static void modinit (lua_State *L, const char *modname) {
  const char *dot;
  lua_pushvalue(L, -1);
  lua_setfield(L, -2, "_M");  /* module._M = module */
  lua_pushstring(L, modname);
  lua_setfield(L, -2, "_NAME");
  dot = rb->strrchr(modname, '.');  /* look for last dot in module name */
  if (dot == NULL) dot = modname;
  else dot++;
  /* set _PACKAGE as package name (full module name minus last part) */
  lua_pushlstring(L, modname, dot - modname);
  lua_setfield(L, -2, "_PACKAGE");
}


static int ll_module (lua_State *L) {
  const char *modname = luaL_checkstring(L, 1);
  int loaded = lua_gettop(L) + 1;  /* index of _LOADED table */
  lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED");
  lua_getfield(L, loaded, modname);  /* get _LOADED[modname] */
  if (!lua_istable(L, -1)) {  /* not found? */
    lua_pop(L, 1);  /* remove previous result */
    /* try global variable (and create one if it does not exist) */
    if (luaL_findtable(L, LUA_GLOBALSINDEX, modname, 1) != NULL)
      return luaL_error(L, "name conflict for module " LUA_QS, modname);
    lua_pushvalue(L, -1);
    lua_setfield(L, loaded, modname);  /* _LOADED[modname] = new table */
  }
  /* check whether table already has a _NAME field */
  lua_getfield(L, -1, "_NAME");
  if (!lua_isnil(L, -1))  /* is table an initialized module? */
    lua_pop(L, 1);
  else {  /* no; initialize it */
    lua_pop(L, 1);
    modinit(L, modname);
  }
  lua_pushvalue(L, -1);
  setfenv(L);
  dooptions(L, loaded - 1);
  return 0;
}


static int ll_seeall (lua_State *L) {
  luaL_checktype(L, 1, LUA_TTABLE);
  if (!lua_getmetatable(L, 1)) {
    lua_createtable(L, 0, 1); /* create new metatable */
    lua_pushvalue(L, -1);
    lua_setmetatable(L, 1);
  }
  lua_pushvalue(L, LUA_GLOBALSINDEX);
  lua_setfield(L, -2, "__index");  /* mt.__index = _G */
  return 0;
}


/* }====================================================== */



/* auxiliary mark (for internal use) */
#define AUXMARK     "\1"

static void setpath (lua_State *L, const char *fieldname, const char *envname,
                                   const char *def) {
  (void)envname;
  lua_pushstring(L, def);  /* use default */
  setprogdir(L);
  lua_setfield(L, -2, fieldname);
}


static const luaL_Reg pk_funcs[] = {
  {"seeall", ll_seeall},
  {NULL, NULL}
};


static const luaL_Reg ll_funcs[] = {
  {"module", ll_module},
  {"require", ll_require},
  {NULL, NULL}
};


static const lua_CFunction loaders[] =
  {loader_preload, loader_Lua, NULL};


LUALIB_API int luaopen_package (lua_State *L) {
  int i;
  /* create new type _LOADLIB */
  luaL_newmetatable(L, "_LOADLIB");
  /* create `package' table */
  luaL_register(L, LUA_LOADLIBNAME, pk_funcs);
#if defined(LUA_COMPAT_LOADLIB) 
  lua_getfield(L, -1, "loadlib");
  lua_setfield(L, LUA_GLOBALSINDEX, "loadlib");
#endif
  lua_pushvalue(L, -1);
  lua_replace(L, LUA_ENVIRONINDEX);
  /* create `loaders' table */
  lua_createtable(L, 0, sizeof(loaders)/sizeof(loaders[0]) - 1);
  /* fill it with pre-defined loaders */
  for (i=0; loaders[i] != NULL; i++) {
    lua_pushcfunction(L, loaders[i]);
    lua_rawseti(L, -2, i+1);
  }
  lua_setfield(L, -2, "loaders");  /* put it in field `loaders' */
  setpath(L, "path", LUA_PATH, LUA_PATH_DEFAULT);  /* set field `path' */
  /* store config information */
  lua_pushliteral(L, LUA_DIRSEP "\n" LUA_PATHSEP "\n" LUA_PATH_MARK "\n"
                     LUA_EXECDIR "\n" LUA_IGMARK);
  lua_setfield(L, -2, "config");
  /* set field `loaded' */
  luaL_findtable(L, LUA_REGISTRYINDEX, "_LOADED", 2);
  lua_setfield(L, -2, "loaded");
  /* set field `preload' */
  lua_newtable(L);
  lua_setfield(L, -2, "preload");
  lua_pushvalue(L, LUA_GLOBALSINDEX);
  luaL_register(L, NULL, ll_funcs);  /* open lib into global table */
  lua_pop(L, 1);
  return 1;  /* return 'package' table */
}
generated by cgit v1.1 at 2026-05-06 10:45:14 +0000