%include <typemaps.i>

// FIXME: We need to port more typemaps from Python

//===----------------------------------------------------------------------===//

// In Lua 5.3 and beyond the VM supports integers, so we need to remap
// SWIG's internal handling of integers.


%define LLDB_NUMBER_TYPEMAP(TYPE)

// Primitive integer mapping
%typemap(in,checkfn="lua_isinteger") TYPE
%{ $1 = ($type)lua_tointeger(L, $input); %}
%typemap(in,checkfn="lua_isinteger") const TYPE&($basetype temp)
%{ temp=($basetype)lua_tointeger(L,$input); $1=&temp;%}
%typemap(out) TYPE
%{ lua_pushinteger(L, (lua_Integer) $1); SWIG_arg++;%}
%typemap(out) const TYPE&
%{ lua_pushinteger(L, (lua_Integer) $1); SWIG_arg++;%}

// Pointer and reference mapping
%typemap(in,checkfn="lua_isinteger") TYPE *INPUT($*ltype temp), TYPE &INPUT($*ltype temp)
%{ temp = ($*ltype)lua_tointeger(L,$input);
   $1 = &temp; %}
%typemap(in, numinputs=0) TYPE *OUTPUT ($*ltype temp)
%{ $1 = &temp; %}
%typemap(argout) TYPE *OUTPUT
%{  lua_pushinteger(L, (lua_Integer) *$1); SWIG_arg++;%}
%typemap(in) TYPE *INOUT = TYPE *INPUT;
%typemap(argout) TYPE *INOUT = TYPE *OUTPUT;
%typemap(in) TYPE &OUTPUT = TYPE *OUTPUT;
%typemap(argout) TYPE &OUTPUT = TYPE *OUTPUT;
%typemap(in) TYPE &INOUT = TYPE *INPUT;
%typemap(argout) TYPE &INOUT = TYPE *OUTPUT;
%typemap(in,checkfn="lua_isinteger") const TYPE *INPUT($*ltype temp)
%{ temp = ($*ltype)lua_tointeger(L,$input);
   $1 = &temp; %}

%enddef // LLDB_NUMBER_TYPEMAP

LLDB_NUMBER_TYPEMAP(unsigned char);
LLDB_NUMBER_TYPEMAP(signed char);
LLDB_NUMBER_TYPEMAP(short);
LLDB_NUMBER_TYPEMAP(unsigned short);
LLDB_NUMBER_TYPEMAP(signed short);
LLDB_NUMBER_TYPEMAP(int);
LLDB_NUMBER_TYPEMAP(unsigned int);
LLDB_NUMBER_TYPEMAP(signed int);
LLDB_NUMBER_TYPEMAP(long);
LLDB_NUMBER_TYPEMAP(unsigned long);
LLDB_NUMBER_TYPEMAP(signed long);
LLDB_NUMBER_TYPEMAP(long long);
LLDB_NUMBER_TYPEMAP(unsigned long long);
LLDB_NUMBER_TYPEMAP(signed long long);
LLDB_NUMBER_TYPEMAP(enum SWIGTYPE);

%apply unsigned long { size_t };
%apply const unsigned long & { const size_t & };
%apply long { ssize_t };
%apply const long & { const ssize_t & };

//===----------------------------------------------------------------------===//

// FIXME:
//  Ideally all the typemaps should be revisited in a future SB API revision.
//  Typemaps, usually, modifies the function signatures and might spawn
//  different LLDB APIs across languages (C++, Python, Lua...).
//  Historically, typemaps have been used to replace SWIG's deficiencies,
//  but SWIG itself evolved and some API design choices are now redundant.

//===----------------------------------------------------------------------===//

// Typemap definitions to allow SWIG to properly handle char buffer.

// typemap for a char buffer
%typemap(in) (char *dst, size_t dst_len) {
   $2 = luaL_checkinteger(L, $input);
   if ($2 <= 0) {
      return luaL_error(L, "Positive integer expected");
   }
   $1 = (char *) malloc($2);
}

// SBProcess::ReadCStringFromMemory() uses a void*, but needs to be treated
// as char data instead of byte data.
%typemap(in) (void *char_buf, size_t size) = (char *dst, size_t dst_len);

// Also SBProcess::ReadMemory.
%typemap(in) (void *buf, size_t size) = (char *dst, size_t dst_len);

// Return the char buffer.  Discarding any previous return result
%typemap(argout) (char *dst, size_t dst_len) {
   lua_pop(L, 1); // Blow away the previous result
   if ($result == 0) {
      lua_pushliteral(L, "");
   } else {
      lua_pushlstring(L, (const char *)$1, $result);
   }
   free($1);
   // SWIG_arg was already incremented
}

// SBProcess::ReadCStringFromMemory() uses a void*, but needs to be treated
// as char data instead of byte data.
%typemap(argout) (void *char_buf, size_t size) = (char *dst, size_t dst_len);

// Also SBProcess::ReadMemory.
%typemap(argout) (void *buf, size_t size) = (char *dst, size_t dst_len);

//===----------------------------------------------------------------------===//

// Typemap for handling a snprintf-like API like SBThread::GetStopDescription.

%typemap(in) (char *dst_or_null, size_t dst_len) {
   $2 = luaL_checkinteger(L, $input);
   if ($2 <= 0) {
      return luaL_error(L, "Positive integer expected");
   }
   $1 = (char *)malloc($2);
}

%typemap(argout) (char *dst_or_null, size_t dst_len) {
   lua_pop(L, 1); // Blow away the previous result
   lua_pushlstring(L, (const char *)$1, $result);
   free($1);
   // SWIG_arg was already incremented
}

//===----------------------------------------------------------------------===//

// Typemap for handling SBModule::GetVersion

%typemap(in) (uint32_t *versions, uint32_t num_versions) {
   $2 = 99;
   $1 = (uint32_t *)malloc(sizeof(uint32_t) * $2);
}

%typemap(argout) (uint32_t *versions, uint32_t num_versions) {
   uint32_t count = result;
   if (count >= $2)
      count = $2;
   lua_newtable(L);
   int i = 0;
   while (i++ < count) {
      lua_pushinteger(L, $1[i - 1]);
      lua_seti(L, -2, i);
   }
   SWIG_arg++;
   free($1);
}

//===----------------------------------------------------------------------===//

// Typemap for handling SBDebugger::SetLoggingCallback

%typemap(in) (lldb::LogOutputCallback log_callback, void *baton) {
   $1 = LLDBSwigLuaCallLuaLogOutputCallback;
   $2 = (void *)L;

   luaL_checktype(L, 2, LUA_TFUNCTION);
   lua_settop(L, 2);

   lua_pushlightuserdata(L, (void *)&LLDBSwigLuaCallLuaLogOutputCallback);
   lua_insert(L, 2);
   lua_settable(L, LUA_REGISTRYINDEX);
}

//===----------------------------------------------------------------------===//

// Typemap for handling SBEvent::SBEvent(uint32_t event, const char *cstr, uint32_t cstr_len)

%typemap(in) (const char *cstr, uint32_t cstr_len) {
   $1 = (char *)luaL_checklstring(L, $input, (size_t *)&$2);
}

// Typemap for handling SBProcess::PutSTDIN

%typemap(in) (const char *src, size_t src_len) {
   $1 = (char *)luaL_checklstring(L, $input, &$2);
}

// Typemap for handling SBProcess::WriteMemory, SBTarget::GetInstructions...

%typemap(in) (const void *buf, size_t size),
             (const void *data, size_t data_len) {
   $1 = (void *)luaL_checklstring(L, $input, &$2);
}

//===----------------------------------------------------------------------===//

// Typemap for handling char ** in SBTarget::LaunchSimple, SBTarget::Launch...

// It should accept a Lua table of strings, for stuff like "argv" and "envp".

%typemap(in) char ** {
   if (lua_istable(L, $input)) {
      size_t size = lua_rawlen(L, $input);
      $1 = (char **)malloc((size + 1) * sizeof(char *));
      int i = 0, j = 0;
      while (i++ < size) {
         lua_rawgeti(L, $input, i);
         if (!lua_isstring(L, -1)) {
            // if current element cannot be converted to string, raise an error
            lua_pop(L, 1);
            return luaL_error(L, "List should only contain strings");
         }
         $1[j++] = (char *)lua_tostring(L, -1);
         lua_pop(L, 1);
      }
      $1[j] = 0;
   } else if (lua_isnil(L, $input)) {
      // "nil" is also acceptable, equivalent as an empty table
      $1 = NULL;
   } else {
      return luaL_error(L, "A list of strings expected");
   }
}

%typemap(freearg) char ** {
   free((char *) $1);
}

%typecheck(SWIG_TYPECHECK_STRING_ARRAY) char ** {
   $1 = (lua_istable(L, $input) || lua_isnil(L, $input));
}

//===----------------------------------------------------------------------===//

// Typemap for file handles (e.g. used in SBDebugger::SetOutputFile)

%typemap(in) lldb::FileSP {
   luaL_Stream *p = (luaL_Stream *)luaL_checkudata(L, $input, LUA_FILEHANDLE);
   lldb::FileSP file_sp;
   file_sp = std::make_shared<lldb_private::NativeFile>(p->f, false);
   if (!file_sp->IsValid())
      return luaL_error(L, "Invalid file");
   $1 = file_sp;
}

%typecheck(SWIG_TYPECHECK_POINTER) lldb::FileSP {
   $1 = (lua_isuserdata(L, $input)) &&
        (luaL_testudata(L, $input, LUA_FILEHANDLE) != nullptr);
}

// Typemap for file handles (e.g. used in SBDebugger::GetOutputFileHandle)

%typemap(out) lldb::FileSP {
   lldb::FileSP &sp = $1;
   if (sp && sp->IsValid()) {
      luaL_Stream *p = (luaL_Stream *)lua_newuserdata(L, sizeof(luaL_Stream));
      p->closef = &LLDBSwigLuaCloseFileHandle;
      p->f = sp->GetStream();
      luaL_setmetatable(L, LUA_FILEHANDLE);
      SWIG_arg++;
   }
}

//===----------------------------------------------------------------------===//

// Typemap for SBData::CreateDataFromUInt64Array, SBData::SetDataFromUInt64Array ...

%typemap(in) (uint64_t* array, size_t array_len),
             (uint32_t* array, size_t array_len),
             (int64_t* array, size_t array_len),
             (int32_t* array, size_t array_len),
             (double* array, size_t array_len) {
   if (lua_istable(L, $input)) {
      // It should accept a table of numbers.
      $2 = lua_rawlen(L, $input);
      $1 = ($1_ltype)malloc(($2) * sizeof($*1_type));
      int i = 0, j = 0;
      while (i++ < $2) {
         lua_rawgeti(L, $input, i);
         if (!lua_isnumber(L, -1)) {
            // if current element cannot be converted to number, raise an error
            lua_pop(L, 1);
            return luaL_error(L, "List should only contain numbers");
         }
         $1[j++] = ($*1_ltype)lua_tonumber(L, -1);
         lua_pop(L, 1);
      }
   } else if (lua_isnil(L, $input)) {
      // "nil" is also acceptable, equivalent as an empty table
      $1 = NULL;
      $2 = 0;
   } else {
      // else raise an error
      return luaL_error(L, "A list of numbers expected.");
   }
}

%typemap(freearg) (uint64_t* array, size_t array_len),
             (uint32_t* array, size_t array_len),
             (int64_t* array, size_t array_len),
             (int32_t* array, size_t array_len),
             (double* array, size_t array_len) {
   free($1);
}

//===----------------------------------------------------------------------===//

// Typemap for SBCommandReturnObject::PutCString

%typemap(in) (const char *string, int len) {
   if (lua_isnil(L, $input)) {
      $1 = NULL;
      $2 = 0;
   }
   else {
      $1 = (char *)luaL_checklstring(L, $input, (size_t *)&$2);
   }
}

//===----------------------------------------------------------------------===//