utils/lua-utils.cc - platform/external/libtextclassifier - Git at Google

 /*
  * 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
	/*
	* 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