Tool Native Library Generator (C/C++ to B4A)

#include <string>

char* test(char* param)
{  
    if (strcmp(param, "12345") == 0) {
        return "ok";
    }
    else {
        return param;
    }
}

- C:\My Native Libs\MazeSolver  <-- native_library_compiler_2_x.jar, \workspace, \project
- C:\My Native Libs\NinjaCore   <-- native_library_compiler_2_x.jar, \workspace, \project
- C:\My Native Libs\Foo         <-- native_library_compiler_2_x.jar, \workspace, \project
- C:\My Native Libs\Foo2        <-- native_library_compiler_2_x.jar, \workspace, \project

Name:    FastMath
Author:  Ninja Dynamics
Version: 1.50
Package: com.ninjadynamics.fastmath
[LIB] C:\Android\B4A External Libs
[NDK] C:\ProgramData\Microsoft\AndroidNDK\android-ndk-r10e
[SLC] C:\Program Files (x86)\Anywhere Software\SLC

OUTPUT:
[16:30:41] Ready.
[16:32:23] Working...
[16:32:24] Java file generated.
[16:32:24] JNI header file generated.
[16:32:24] JNI source file generated.
[16:32:24] Preparing to compile.
[16:32:38] Native library compiled.
[16:32:38] Deleting old JAR file.
[16:32:38] Deleting old XML file.
[16:32:42] B4A library compiled.

Sub RunNDK
    Dim fileList As List
    fileList = File.ListFiles(File.DirApp)
    For Each item As String In fileList
        If item.EndsWith(".h") Or item.EndsWith(".c") Or item.EndsWith(".cpp") Then
            File.Copy(File.DirApp, item, File.DirApp & "\workspace", item)
            File.Delete(File.DirApp, item)
        End If
    Next
    Dim compileCommand, copyCommand As String   
    compileCommand = "path %PATH%;" & pathNDK & CRLF & _
                     "cd workspace" & CRLF & _
                     "ndk-build -B"                   
    copyCommand    = "xcopy workspace\libs project\additional\lib /e /h /y"   
    File.WriteString(File.DirApp, "compile.bat", compileCommand)
    File.WriteString(File.DirApp, "copylib.bat", copyCommand)   
    Dim ndk, xcopy As Shell       
    ndk.Initialize("ndk", "compile.bat", Null)
    xcopy.Initialize("xcopy", "copylib.bat", Null)   
    ndk.RunSynchronous(-1)   
    xcopy.RunSynchronous(-1)   
    File.Delete(File.DirApp, "copylib.bat")
    If File.ListFiles(File.DirApp & "\project\additional\lib").Size > 0 Then
        File.Delete(File.DirApp, "compile.bat")
        txtStatsBox.Text = txtStatsBox.Text & "[" & DateTime.Time(DateTime.Now) & "] Native library compiled." & CRLF       
    Else
        File.Copy(File.DirApp, "compile.bat", File.DirApp & "\workspace", "compile.bat")
        File.Delete(File.DirApp, "compile.bat")
        txtStatsBox.Text = txtStatsBox.Text & "[" & DateTime.Time(DateTime.Now) & "] NDK compilation FAILED." & CRLF
        txtStatsBox.Text = txtStatsBox.Text & "[" & DateTime.Time(DateTime.Now) & "] Run 'workspace\compile.bat' to see what went wrong." & CRLF
        ok = False       
    End If
End Sub

char* cMapReadVector(uintptr_t cMapAddress, int x, int y)
{
    ContentMap *cMap = (ContentMap*)(cMapAddress);
    if (x >= cMap->sizeX || y >= cMap->sizeY || x < 0 || y < 0) {
        return "";
    }  
    int vectorIndex = ((y * cMap->sizeX) + x);
    std::string output;
    std::stringstream ss;
    for (unsigned int i = 0; i < cMap->contentClass[vectorIndex].size(); i++)
    {
        if (i != 0) {
            ss << " ";
        }
        //long long a = 1231239812;
        ss << std::to_string(cMap->contentClass[vectorIndex][i]) << ":";
        ss << std::to_string(cMap->contentType[vectorIndex][i]) << ":";
        ss << std::to_string(cMap->contentID[vectorIndex][i]);
        //ss << a;
    }
    output = ss.str();
    char* result = (char*)output.c_str();
    size_t allocSize = sizeof(result) * output.length();
    if (allocSize > 0) {
        cMap->outputString = (char*)realloc(cMap->outputString, allocSize);  
        strcpy(cMap->outputString, result);
        return cMap->outputString;
    }
    else {
        return "";
    }
}

#include <stdio.h>
#include <string>
#include <iostream>

using namespace std;
static const std::string base64_chars =
             "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
             "abcdefghijklmnopqrstuvwxyz"
             "0123456789+/";

//Test line. Already ciphered and in base 64. This line will return the key after processed by
//decodex.

char Base[]="FTRVExxMZwRSUFUQbC19TxIpEBEPI3E8VVcGbHYMHBdBAytBFTkSNjteQ39FJhoKNFQpEHIZakMnBFVtT0Nl";
/*
*
*/
//::ignore
std::string cryptDecrypt(std::string toEncrypt) {
    char key[8] = {'l', 'c', 'g','!','%','}','$','z'}; // just some xors as per web example
    std::string output = toEncrypt;
   
    for (unsigned int i = 0; i < toEncrypt.size(); i++)
        output[i] = toEncrypt[i] ^ key[i % (sizeof(key) / sizeof(char))];
    return output;
}




static inline bool is_base64(unsigned char c) {
  return (isalnum(c) || (c == '+') || (c == '/'));
}
//::ignore
std::string base64_encode(unsigned char const* bytes_to_encode, unsigned int in_len) {
  std::string ret;
  int i = 0;
  int j = 0;
  unsigned char char_array_3[3];
  unsigned char char_array_4[4];

  while (in_len--) {
    char_array_3[i++] = *(bytes_to_encode++);
    if (i == 3) {
      char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
      char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
      char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
      char_array_4[3] = char_array_3[2] & 0x3f;

      for(i = 0; (i <4) ; i++)
        ret += base64_chars[char_array_4[i]];
      i = 0;
    }
  }

  if (i)
  {
    for(j = i; j < 3; j++)
      char_array_3[j] = '\0';

    char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
    char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
    char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
    char_array_4[3] = char_array_3[2] & 0x3f;

    for (j = 0; (j < i + 1); j++)
      ret += base64_chars[char_array_4[j]];

    while((i++ < 3))
      ret += '=';

  }

  return ret;

}
//::ignore
std::string base64_decode(std::string const& encoded_string) {
  int in_len = encoded_string.size();
  int i = 0;
  int j = 0;
  int in_ = 0;
  unsigned char char_array_4[4], char_array_3[3];
  std::string ret;

  while (in_len-- && ( encoded_string[in_] != '=') && is_base64(encoded_string[in_])) {
    char_array_4[i++] = encoded_string[in_]; in_++;
    if (i ==4) {
      for (i = 0; i <4; i++)
        char_array_4[i] = base64_chars.find(char_array_4[i]);

      char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
      char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
      char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];

      for (i = 0; (i < 3); i++)
        ret += char_array_3[i];
      i = 0;
    }
  }

  if (i) {
    for (j = i; j <4; j++)
      char_array_4[j] = 0;

    for (j = 0; j <4; j++)
      char_array_4[j] = base64_chars.find(char_array_4[j]);

    char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
    char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
    char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];

    for (j = 0; (j < i - 1); j++) ret += char_array_3[j];
  }

  return ret;
}

char * decodex() {
    std::string encoded=::Base;
    std::string decoded = base64_decode(encoded);
    string decriptado = cryptDecrypt(decoded);
    char* devolve=&decriptado[0u];
    cout << devolve<<"\n\n";
        return devolve;
}

char * decodex() {
    std::string encoded=::Base;
    std::string decoded = base64_decode(encoded);
    string decriptado = cryptDecrypt(decoded);
    char* devolve=&decriptado[0u];
    cout << devolve<<"\n\n";
        return devolve;
}

#include <stdio.h>
#include <string>
#include <iostream>

using namespace std;
static const std::string base64_chars =
             "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
             "abcdefghijklmnopqrstuvwxyz"
             "0123456789+/";

//Global variable
char* devolve;

//Test line. Already ciphered and in base 64. This line will return the key after processed by decodex.
char Base[]="FTRVExxMZwRSUFUQbC19TxIpEBEPI3E8VVcGbHYMHBdBAytBFTkSNjteQ39FJhoKNFQpEHIZakMnBFVtT0Nl";

//::ignore
std::string cryptDecrypt(std::string toEncrypt) {
    char key[8] = {'l', 'c', 'g','!','%','}','$','z'}; // just some xors as per web example
    std::string output = toEncrypt;
  
    for (unsigned int i = 0; i < toEncrypt.size(); i++)
        output[i] = toEncrypt[i] ^ key[i % (sizeof(key) / sizeof(char))];
    return output;
}

static inline bool is_base64(unsigned char c) {
  return (isalnum(c) || (c == '+') || (c == '/'));
}

//::ignore
std::string base64_encode(unsigned char const* bytes_to_encode, unsigned int in_len) {
  std::string ret;
  int i = 0;
  int j = 0;
  unsigned char char_array_3[3];
  unsigned char char_array_4[4];

  while (in_len--) {
    char_array_3[i++] = *(bytes_to_encode++);
    if (i == 3) {
      char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
      char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
      char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
      char_array_4[3] = char_array_3[2] & 0x3f;

      for(i = 0; (i <4) ; i++)
        ret += base64_chars[char_array_4[i]];
      i = 0;
    }
  }

  if (i)
  {
    for(j = i; j < 3; j++)
      char_array_3[j] = '\0';

    char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
    char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
    char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
    char_array_4[3] = char_array_3[2] & 0x3f;

    for (j = 0; (j < i + 1); j++)
      ret += base64_chars[char_array_4[j]];

    while((i++ < 3))
      ret += '=';
  }
  return ret;
}

//::ignore
std::string base64_decode(std::string const& encoded_string) {
  int in_len = encoded_string.size();
  int i = 0;
  int j = 0;
  int in_ = 0;
  unsigned char char_array_4[4], char_array_3[3];
  std::string ret;

  while (in_len-- && ( encoded_string[in_] != '=') && is_base64(encoded_string[in_])) {
    char_array_4[i++] = encoded_string[in_]; in_++;
    if (i ==4) {
      for (i = 0; i <4; i++)
        char_array_4[i] = base64_chars.find(char_array_4[i]);

      char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
      char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
      char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];

      for (i = 0; (i < 3); i++)
        ret += char_array_3[i];
      i = 0;
    }
  }

  if (i) {
    for (j = i; j <4; j++)
      char_array_4[j] = 0;

    for (j = 0; j <4; j++)
      char_array_4[j] = base64_chars.find(char_array_4[j]);

    char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
    char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
    char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];

    for (j = 0; (j < i - 1); j++) ret += char_array_3[j];
  }

  return ret;
}

char * decodex() {
    std::string encoded=::Base;
    std::string decoded = base64_decode(encoded);
    string decriptado = cryptDecrypt(decoded);

    char* result = (char*)decriptado.c_str();
    size_t allocSize = sizeof(result) * decriptado.length();
    if (allocSize > 0) {
        devolve = (char*)realloc(devolve, allocSize); 
        strcpy(devolve, result);
        return devolve;
    }
    else {
        return "";
    }   
}