/*
|
* Copyright (C) 2018 The Android Open Source Project
|
*
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
*/
|
|
#include "utils/lua-utils.h"
|
|
// lua_dump takes an extra argument "strip" in 5.3, but not in 5.2.
|
#ifndef TC3_AOSP
|
#define lua_dump(L, w, d, s) lua_dump((L), (w), (d))
|
#endif
|
|
namespace libtextclassifier3 {
|
namespace {
|
// Upvalue indices for the flatbuffer callback.
|
static constexpr int kSchemaArgId = 1;
|
static constexpr int kTypeArgId = 2;
|
static constexpr int kTableArgId = 3;
|
|
static constexpr luaL_Reg defaultlibs[] = {{"_G", luaopen_base},
|
{LUA_TABLIBNAME, luaopen_table},
|
{LUA_STRLIBNAME, luaopen_string},
|
{LUA_BITLIBNAME, luaopen_bit32},
|
{LUA_MATHLIBNAME, luaopen_math},
|
{nullptr, nullptr}};
|
|
// Implementation of a lua_Writer that appends the data to a string.
|
int LuaStringWriter(lua_State *state, const void *data, size_t size,
|
void *result) {
|
std::string *const result_string = static_cast<std::string *>(result);
|
result_string->insert(result_string->size(), static_cast<const char *>(data),
|
size);
|
return LUA_OK;
|
}
|
|
} // namespace
|
|
LuaEnvironment::LuaEnvironment() { state_ = luaL_newstate(); }
|
|
LuaEnvironment::~LuaEnvironment() {
|
if (state_ != nullptr) {
|
lua_close(state_);
|
}
|
}
|
|
int LuaEnvironment::Iterator::NextCallback(lua_State *state) {
|
return FromUpValue<Iterator *>(kIteratorArgId, state)->Next(state);
|
}
|
|
int LuaEnvironment::Iterator::LengthCallback(lua_State *state) {
|
return FromUpValue<Iterator *>(kIteratorArgId, state)->Length(state);
|
}
|
|
int LuaEnvironment::Iterator::ItemCallback(lua_State *state) {
|
return FromUpValue<Iterator *>(kIteratorArgId, state)->Item(state);
|
}
|
|
int LuaEnvironment::Iterator::IteritemsCallback(lua_State *state) {
|
return FromUpValue<Iterator *>(kIteratorArgId, state)->Iteritems(state);
|
}
|
|
void LuaEnvironment::PushFlatbuffer(const char *name,
|
const reflection::Schema *schema,
|
const reflection::Object *type,
|
const flatbuffers::Table *table,
|
lua_State *state) {
|
lua_newtable(state);
|
luaL_newmetatable(state, name);
|
lua_pushlightuserdata(state, AsUserData(schema));
|
lua_pushlightuserdata(state, AsUserData(type));
|
lua_pushlightuserdata(state, AsUserData(table));
|
lua_pushcclosure(state, &GetFieldCallback, 3);
|
lua_setfield(state, -2, kIndexKey);
|
lua_setmetatable(state, -2);
|
}
|
|
int LuaEnvironment::GetFieldCallback(lua_State *state) {
|
// Fetch the arguments.
|
const reflection::Schema *schema =
|
FromUpValue<reflection::Schema *>(kSchemaArgId, state);
|
const reflection::Object *type =
|
FromUpValue<reflection::Object *>(kTypeArgId, state);
|
const flatbuffers::Table *table =
|
FromUpValue<flatbuffers::Table *>(kTableArgId, state);
|
return GetField(schema, type, table, state);
|
}
|
|
int LuaEnvironment::GetField(const reflection::Schema *schema,
|
const reflection::Object *type,
|
const flatbuffers::Table *table,
|
lua_State *state) {
|
const char *field_name = lua_tostring(state, -1);
|
const reflection::Field *field = type->fields()->LookupByKey(field_name);
|
if (field == nullptr) {
|
lua_error(state);
|
return 0;
|
}
|
// Provide primitive fields directly.
|
const reflection::BaseType field_type = field->type()->base_type();
|
switch (field_type) {
|
case reflection::Bool:
|
lua_pushboolean(state, table->GetField<uint8_t>(
|
field->offset(), field->default_integer()));
|
break;
|
case reflection::Int:
|
lua_pushinteger(state, table->GetField<int32>(field->offset(),
|
field->default_integer()));
|
break;
|
case reflection::Long:
|
lua_pushinteger(state, table->GetField<int64>(field->offset(),
|
field->default_integer()));
|
break;
|
case reflection::Float:
|
lua_pushnumber(state, table->GetField<float>(field->offset(),
|
field->default_real()));
|
break;
|
case reflection::Double:
|
lua_pushnumber(state, table->GetField<double>(field->offset(),
|
field->default_real()));
|
break;
|
case reflection::String: {
|
const flatbuffers::String *string_value =
|
table->GetPointer<const flatbuffers::String *>(field->offset());
|
if (string_value != nullptr) {
|
lua_pushlstring(state, string_value->data(), string_value->Length());
|
} else {
|
lua_pushlstring(state, "", 0);
|
}
|
break;
|
}
|
case reflection::Obj: {
|
const flatbuffers::Table *field_table =
|
table->GetPointer<const flatbuffers::Table *>(field->offset());
|
if (field_table == nullptr) {
|
TC3_LOG(ERROR) << "Field was not set in entity data.";
|
lua_error(state);
|
return 0;
|
}
|
const reflection::Object *field_type =
|
schema->objects()->Get(field->type()->index());
|
PushFlatbuffer(field->name()->c_str(), schema, field_type, field_table,
|
state);
|
break;
|
}
|
default:
|
TC3_LOG(ERROR) << "Unsupported type: " << field_type;
|
lua_error(state);
|
return 0;
|
}
|
return 1;
|
}
|
|
int LuaEnvironment::ReadFlatbuffer(ReflectiveFlatbuffer *buffer) {
|
if (lua_type(state_, /*idx=*/-1) != LUA_TTABLE) {
|
TC3_LOG(ERROR) << "Expected actions table, got: "
|
<< lua_type(state_, /*idx=*/-1);
|
lua_error(state_);
|
return LUA_ERRRUN;
|
}
|
|
lua_pushnil(state_);
|
while (lua_next(state_, /*idx=*/-2)) {
|
const StringPiece key = ReadString(/*index=*/-2);
|
const reflection::Field *field = buffer->GetFieldOrNull(key);
|
if (field == nullptr) {
|
TC3_LOG(ERROR) << "Unknown field: " << key.ToString();
|
lua_error(state_);
|
return LUA_ERRRUN;
|
}
|
switch (field->type()->base_type()) {
|
case reflection::Obj:
|
return ReadFlatbuffer(buffer->Mutable(field));
|
case reflection::Bool:
|
buffer->Set(field,
|
static_cast<bool>(lua_toboolean(state_, /*idx=*/-1)));
|
break;
|
case reflection::Int:
|
buffer->Set(field, static_cast<int>(lua_tonumber(state_, /*idx=*/-1)));
|
break;
|
case reflection::Long:
|
buffer->Set(field,
|
static_cast<int64>(lua_tonumber(state_, /*idx=*/-1)));
|
break;
|
case reflection::Float:
|
buffer->Set(field,
|
static_cast<float>(lua_tonumber(state_, /*idx=*/-1)));
|
break;
|
case reflection::Double:
|
buffer->Set(field,
|
static_cast<double>(lua_tonumber(state_, /*idx=*/-1)));
|
break;
|
case reflection::String: {
|
buffer->Set(field, ReadString(/*index=*/-1));
|
break;
|
}
|
default:
|
TC3_LOG(ERROR) << "Unsupported type: " << field->type()->base_type();
|
lua_error(state_);
|
return LUA_ERRRUN;
|
}
|
lua_pop(state_, 1);
|
}
|
// lua_pop(state_, /*n=*/1);
|
return LUA_OK;
|
}
|
|
void LuaEnvironment::LoadDefaultLibraries() {
|
for (const luaL_Reg *lib = defaultlibs; lib->func; lib++) {
|
luaL_requiref(state_, lib->name, lib->func, 1);
|
lua_pop(state_, 1); /* remove lib */
|
}
|
}
|
|
void LuaEnvironment::PushValue(const Variant &value) {
|
if (value.HasInt()) {
|
lua_pushnumber(state_, value.IntValue());
|
} else if (value.HasInt64()) {
|
lua_pushnumber(state_, value.Int64Value());
|
} else if (value.HasBool()) {
|
lua_pushboolean(state_, value.BoolValue());
|
} else if (value.HasFloat()) {
|
lua_pushnumber(state_, value.FloatValue());
|
} else if (value.HasDouble()) {
|
lua_pushnumber(state_, value.DoubleValue());
|
} else if (value.HasString()) {
|
lua_pushlstring(state_, value.StringValue().data(),
|
value.StringValue().size());
|
} else {
|
TC3_LOG(FATAL) << "Unknown value type.";
|
}
|
}
|
|
StringPiece LuaEnvironment::ReadString(const int index) const {
|
size_t length = 0;
|
const char *data = lua_tolstring(state_, index, &length);
|
return StringPiece(data, length);
|
}
|
|
void LuaEnvironment::PushString(const StringPiece str) {
|
lua_pushlstring(state_, str.data(), str.size());
|
}
|
|
void LuaEnvironment::PushFlatbuffer(const reflection::Schema *schema,
|
const flatbuffers::Table *table) {
|
PushFlatbuffer(schema->root_table()->name()->c_str(), schema,
|
schema->root_table(), table, state_);
|
}
|
|
int LuaEnvironment::RunProtected(const std::function<int()> &func,
|
const int num_args, const int num_results) {
|
struct ProtectedCall {
|
std::function<int()> func;
|
|
static int run(lua_State *state) {
|
// Read the pointer to the ProtectedCall struct.
|
ProtectedCall *p = static_cast<ProtectedCall *>(
|
lua_touserdata(state, lua_upvalueindex(1)));
|
return p->func();
|
}
|
};
|
ProtectedCall protected_call = {func};
|
lua_pushlightuserdata(state_, &protected_call);
|
lua_pushcclosure(state_, &ProtectedCall::run, /*n=*/1);
|
// Put the closure before the arguments on the stack.
|
if (num_args > 0) {
|
lua_insert(state_, -(1 + num_args));
|
}
|
return lua_pcall(state_, num_args, num_results, /*errorfunc=*/0);
|
}
|
|
bool LuaEnvironment::Compile(StringPiece snippet, std::string *bytecode) {
|
if (luaL_loadbuffer(state_, snippet.data(), snippet.size(),
|
/*name=*/nullptr) != LUA_OK) {
|
TC3_LOG(ERROR) << "Could not compile lua snippet: "
|
<< ReadString(/*index=*/-1).ToString();
|
lua_pop(state_, 1);
|
return false;
|
}
|
if (lua_dump(state_, LuaStringWriter, bytecode, /*strip*/ 1) != LUA_OK) {
|
TC3_LOG(ERROR) << "Could not dump compiled lua snippet.";
|
lua_pop(state_, 1);
|
return false;
|
}
|
lua_pop(state_, 1);
|
return true;
|
}
|
|
bool Compile(StringPiece snippet, std::string *bytecode) {
|
return LuaEnvironment().Compile(snippet, bytecode);
|
}
|
|
} // namespace libtextclassifier3
|
