int w_newFileData(lua_State *L)
{
// Single argument: treat as filepath or File.
if (lua_gettop(L) == 1)
{
// We don't use luax_getfiledata because we want to use an ioError.
if (lua_isstring(L, 1))
luax_convobj(L, 1, "filesystem", "newFile");
// Get FileData from the File.
if (luax_istype(L, 1, FILESYSTEM_FILE_ID))
{
File *file = luax_checkfile(L, 1);
FileData *data = 0;
try
{
data = file->read();
}
catch (love::Exception &e)
{
return luax_ioError(L, "%s", e.what());
}
luax_pushtype(L, FILESYSTEM_FILE_DATA_ID, data);
data->release();
return 1;
}
else
return luaL_argerror(L, 1, "filename or File expected");
}
size_t length = 0;
const char *str = luaL_checklstring(L, 1, &length);
const char *filename = luaL_checkstring(L, 2);
const char *decstr = lua_isstring(L, 3) ? lua_tostring(L, 3) : 0;
FileData::Decoder decoder = FileData::FILE;
if (decstr && !FileData::getConstant(decstr, decoder))
return luaL_error(L, "Invalid FileData decoder: %s", decstr);
FileData *t = 0;
switch (decoder)
{
case FileData::FILE:
t = instance()->newFileData((void *)str, (int)length, filename);
break;
case FileData::BASE64:
t = instance()->newFileData(str, filename);
break;
default:
return luaL_error(L, "Invalid FileData decoder: %s", decstr);
}
luax_pushtype(L, FILESYSTEM_FILE_DATA_ID, t);
t->release();
return 1;
}
int w_File_getMode(lua_State *L)
{
File *file = luax_checkfile(L, 1);
File::Mode mode = file->getMode();
const char *str = 0;
if (!File::getConstant(mode, str))
return luax_ioError(L, "Unknown file mode.");
lua_pushstring(L, str);
return 1;
}
int w_File_seek(lua_State *L)
{
File *file = luax_checkfile(L, 1);
lua_Number pos = luaL_checknumber(L, 2);
// Push false on negative and precision-problematic numbers.
// Better fail than seek to an unknown position.
if (pos < 0.0 || pos >= 9007199254740992.0)
luax_pushboolean(L, false);
else
luax_pushboolean(L, file->seek((uint64)pos));
return 1;
}
File *luax_getfile(lua_State *L, int idx)
{
File *file = nullptr;
if (lua_isstring(L, idx))
{
const char *filename = luaL_checkstring(L, idx);
file = instance()->newFile(filename);
}
else
file = luax_checkfile(L, idx);
return file;
}
int w_File_tell(lua_State *L)
{
File *file = luax_checkfile(L, 1);
int64 pos = file->tell();
// Push nil on failure or if pos does not fit into a double precision floating-point number.
if (pos == -1)
return luax_ioError(L, "Invalid position.");
else if (pos >= 0x20000000000000LL)
return luax_ioError(L, "Number is too large.");
else
lua_pushnumber(L, (lua_Number)pos);
return 1;
}
int w_File_getBuffer(lua_State *L)
{
File *file = luax_checkfile(L, 1);
int64 size = 0;
File::BufferMode bufmode = file->getBuffer(size);
const char *str = 0;
if (!File::getConstant(bufmode, str))
return luax_ioError(L, "Unknown file buffer mode.");
lua_pushstring(L, str);
lua_pushnumber(L, (lua_Number) size);
return 2;
}
int w_File_flush(lua_State *L)
{
File *file = luax_checkfile(L, 1);
bool success = false;
try
{
success = file->flush();
}
catch (love::Exception &e)
{
return luax_ioError(L, "%s", e.what());
}
luax_pushboolean(L, success);
return 1;
}
int w_File_write(lua_State *L)
{
File *file = luax_checkfile(L, 1);
bool result = false;
if (lua_isstring(L, 2))
{
try
{
size_t datasize = 0;
const char *data = lua_tolstring(L, 2, &datasize);
if (!lua_isnoneornil(L, 3))
datasize = luaL_checkinteger(L, 3);
result = file->write(data, datasize);
}
catch (love::Exception &e)
{
return luax_ioError(L, "%s", e.what());
}
}
else if (luax_istype(L, 2, DATA_ID))
{
try
{
love::Data *data = luax_totype<love::Data>(L, 2, DATA_ID);
result = file->write(data, luaL_optinteger(L, 3, data->getSize()));
}
catch (love::Exception &e)
{
return luax_ioError(L, "%s", e.what());
}
}
else
{
return luaL_argerror(L, 2, "string or data expected");
}
luax_pushboolean(L, result);
return 1;
}
int w_File_open(lua_State *L)
{
File *file = luax_checkfile(L, 1);
const char *str = luaL_checkstring(L, 2);
File::Mode mode;
if (!File::getConstant(str, mode))
return luaL_error(L, "Incorrect file open mode: %s", str);
try
{
luax_pushboolean(L, file->open(mode));
}
catch (love::Exception &e)
{
return luax_ioError(L, "%s", e.what());
}
return 1;
}
int w_File_read(lua_State *L)
{
File *file = luax_checkfile(L, 1);
StrongRef<Data> d = nullptr;
int64 size = (int64) luaL_optnumber(L, 2, (lua_Number) File::ALL);
try
{
d.set(file->read(size), Acquire::NORETAIN);
}
catch (love::Exception &e)
{
return luax_ioError(L, "%s", e.what());
}
lua_pushlstring(L, (const char *) d->getData(), d->getSize());
lua_pushnumber(L, d->getSize());
return 2;
}
int w_File_lines(lua_State *L)
{
File *file = luax_checkfile(L, 1);
lua_pushnumber(L, 0); // File position.
luax_pushboolean(L, file->getMode() != File::MODE_CLOSED); // Save current file mode.
if (file->getMode() != File::MODE_READ)
{
if (file->getMode() != File::MODE_CLOSED)
file->close();
bool success = false;
luax_catchexcept(L, [&](){ success = file->open(File::MODE_READ); });
if (!success)
return luaL_error(L, "Could not open file.");
}
lua_pushcclosure(L, w_File_lines_i, 3);
return 1;
}
int w_File_getSize(lua_State *L)
{
File *t = luax_checkfile(L, 1);
int64 size = -1;
try
{
size = t->getSize();
}
catch (love::Exception &e)
{
return luax_ioError(L, "%s", e.what());
}
// Push nil on failure or if size does not fit into a double precision floating-point number.
if (size == -1)
return luax_ioError(L, "Could not determine file size.");
else if (size >= 0x20000000000000LL)
return luax_ioError(L, "Size is too large.");
lua_pushnumber(L, (lua_Number) size);
return 1;
}
int w_File_setBuffer(lua_State *L)
{
File *file = luax_checkfile(L, 1);
const char *str = luaL_checkstring(L, 2);
int64 size = (int64) luaL_optnumber(L, 3, 0.0);
File::BufferMode bufmode;
if (!File::getConstant(str, bufmode))
return luaL_error(L, "Incorrect file buffer mode: %s", str);
bool success = false;
try
{
success = file->setBuffer(bufmode, size);
}
catch (love::Exception &e)
{
return luax_ioError(L, "%s", e.what());
}
luax_pushboolean(L, success);
return 1;
}
int w_File_close(lua_State *L)
{
File *file = luax_checkfile(L, 1);
luax_pushboolean(L, file->close());
return 1;
}
int w_File_isEOF(lua_State *L)
{
File *file = luax_checkfile(L, 1);
luax_pushboolean(L, file->isEOF());
return 1;
}
int w_File_getExtension(lua_State *L)
{
File *file = luax_checkfile(L, 1);
luax_pushstring(L, file->getExtension());
return 1;
}
int w_File_getFilename(lua_State *L)
{
File *file = luax_checkfile(L, 1);
luax_pushstring(L, file->getFilename());
return 1;
}
