#ifndef SRC_NODE2EXE_H_

#define SRC_NODE2EXE_H_

#include <iostream> //cout

#include <string>

#include <vector>

#include <map>

#include <io.h> //fopen

#include <windows.h> // FindFirstFile

#include <sys/stat.h> // _S_IFREG

#include <sstream> //ss

#include <algorithm> // find_if

#include <functional> //not1

#include <cctype> //isspace

#define BUFFER_SIZE ((size_t)8 * 1024 * 1024)

#ifndef min

#define min(a,b) (((a) < (b)) ? (a) : (b))

#endif

#ifndef max

#define max(a,b) (((a) > (b)) ? (a) : (b))

#endif

#ifndef THROW_LAST

#define THROW_LAST(msg)\

int lastError = GetLastError(); \

std::wprintf(L"%s: %d", msg, lastError); \

throw(lastError, __FILE__, __LINE__);

#endif

#pragma warning(disable: 4996)

namespace node {

// renamed Start in node.cc

int Start_orig(int argc, char *argv[]);

}

namespace node2exe {

// a list of paths that were created, files and folders

// in the order they were created

std::vector<std::wstring> createdPaths;

// config for the program, keys will be lowercase always

std::map<std::wstring, std::wstring> config;

// return lower case version of the string

std::string toLower(std::string data) {

}

// return lower case version of the string

std::wstring toLower(std::wstring data) {

}

// return wstring version of the string

std::wstring toWstring(std::string data) {

return std::wstring(data.begin(), data.end());

}

// toBool

bool toBool(std::wstring value) {

}

// returns true if the config value matches the key

bool configIs(std::wstring key, std::wstring value) {

}

// returns the config value or the default value if not specified

bool configGetBool(std::wstring key, bool defaultValue) {

}

// returns the config value or the default value if not specified

std::wstring configGet(std::wstring key, std::wstring defaultValue) {

}

// expands environment variables in the input string

std::wstring expandEnv(const std::wstring& source)

}

// sets environment variable

void env(const std::wstring& name, const std::wstring& value){

}

// gets environment variable, throws error if it does not exist

std::wstring env(const wchar_t* name) {

}

// get time with millisecond precision as iso format string

std::string timeIso() {

}

// split the string on delim, stops after finding max parts, remiander of the string will be put in the last part

// if max is 0 continue to the end

std::vector<std::wstring> &split(const std::wstring &s, wchar_t delim, size_t max, std::vector<std::wstring> &elems) {

std::wstringstream ss(s);

std::wstring item;

size_t count = 0;

while (std::getline(ss, item, delim)) {

elems.push_back(item);

if (max != 0 && ++count == max) {

if (!ss.eof()) {

std::istreambuf_iterator<wchar_t> eos;

std::wstring final(std::istreambuf_iterator<wchar_t>(ss), eos);

elems.push_back(final);

}

return elems;

}

}

return elems;

}

// split the string on delim

std::vector<std::wstring> split(const std::wstring &s, wchar_t delim, size_t max) {

}

// split the string on delim

std::vector<std::wstring> split(const std::wstring &s, wchar_t delim) {

}

// trim whitespace from start

static inline std::wstring &ltrim(std::wstring &s) {

s.erase(s.begin(), std::find_if(s.begin(), s.end(), std::not1(std::ptr_fun<int, int>(std::isspace))));

return s;

}

// trim whitespace from end

static inline std::wstring &rtrim(std::wstring &s) {

s.erase(std::find_if(s.rbegin(), s.rend(), std::not1(std::ptr_fun<int, int>(std::isspace))).base(), s.end());

return s;

}

// trim whitespace from both ends

static inline std::wstring &trim(std::wstring &s) {

return ltrim(rtrim(s));

}

// trim chars in supplied string from start

static inline std::wstring &ltrim(std::wstring &s, const wchar_t* chars) {

size_t startpos = s.find_first_not_of(chars);

if (std::wstring::npos != startpos)

{

s = s.substr(startpos);

}

return s;

}

// trim chars in supplied string from end

static inline std::wstring &rtrim(std::wstring &s, const wchar_t* chars) {

size_t endpos = s.find_last_not_of(chars);

if (std::wstring::npos != endpos)

{

s = s.substr(0, endpos + 1);

}

return s;

}

// trim chars in supplied string from both ends

static inline std::wstring &trim(std::wstring &s, const wchar_t* chars) {

return ltrim(rtrim(s, chars), chars);

}

// get high precision time as long long

unsigned long long nanoTime() {

}

// Returns the path to a the windows temp dir with trailing slash

std::wstring getTemp() {

}

// gets the current working directory with trailing slash

std::wstring getCwd() {

}

// join the string with delim

std::wstring join(std::vector<std::wstring> elems, std::wstring delim) {

}

// extract bytes from file to file at dest

void extractFile(FILE *dest, FILE *file, const size_t pos, const size_t size) {

}

// extract bytes from file to string at dest

std::wstring extractString(FILE *file, const size_t pos, const size_t size) {

}

// read the config data, into config map, keys will be lowercase always

void readConfig(std::wstring data) {

}

// returns a list of the files and directories in the path

// (not including .. and not . (although i never saw .))

std::vector<std::wstring> listDir(std::wstring path)

}

// trim \ from end of a path

static std::wstring trimSlash(std::wstring s) {

}

// deletes the path, whether it is a file or directory

// please be very careful what you pass this!

// returns true if the item is no longer present when this has exited

bool rmpath(std::wstring path, bool recusive) {

}

// ensures all the directories in the specified path exist

// adds to createdPaths any directories created

void mkpath(std::wstring path) {

}

// search for pattern in file, start at position, max positions in elems (if max is 0 all will be returned)

void findInFile(const std::string &pattern, FILE *file, const size_t start, const size_t max, std::vector<size_t> &elems, const size_t buffer_size) {

}

// overloaded findInFile that returns a vector rather than needing one

// to be passed by reference

std::vector<size_t> findInFile(const std::string &pattern, FILE *file, const size_t pos, const size_t max, const size_t buffer_size) {

}

// overloaded findInFile with default buffer size of 8MB

// and returns a vector rather than needing one to be passed by reference

std::vector<size_t> findInFile(const std::string &pattern, FILE *file, const size_t pos, const size_t max) {

return findInFile(pattern, file, pos, max, BUFFER_SIZE);

}

// overloaded findInFile with default buffer size of 8MB

// and just returns the position of the match or -1 if none found

size_t findInFile(const std::string &pattern, FILE *file, const size_t pos) {

}

// takes a relative path and turns it into an absolute path

std::wstring resolvePath(std::wstring path) {

}

// unless the path starts with .\ ./ ..\ ../ \\ or have second char : the will be treated as relative

// to the NODE2EXE_DEST folder

std::wstring resolvePathSpecial(std::wstring path) {

}

// returns true if the path exists already

bool pathExists(std::wstring path) {

struct _stat fi;

return 0 == _wstat(path.c_str(), &fi);

}

// returns the dirname of a path, no trailing slash

std::wstring dirname(std::wstring path) {

}

// extract part of the exe, deciding on the name and path first

void extractExePart(const size_t count, FILE *file, const size_t start, const size_t end) {

}

// seek through the bytes of the currently executing file for boundary

// when found save the parts to files named node2exe.js, 1, 2, 3, 4 ...

// until no more boundaries are found

bool unpackExe(FILE *file) {

}

// clean up the temp folder

void cleanUp() {

}

// handle CTRL+C, close etc.

// whatever happened clean up

BOOL WINAPI consoleHandler(DWORD signal) {

cleanUp();

return FALSE;

}

// node2exe's start decides on a temp folder,

// unpacks the file parts, if any then injects node2exe.js as the first argv

// tries to trap any exit of the program CTRL+C, close etc.

int start(int argc, char *argv[]) {

}

}

namespace node {

int Start(int argc, char *argv[]) {

return node2exe::start(argc, argv);

}

// an exit method that does clean up first

void exit(int exitCode) {

node2exe::cleanUp();

std::exit(exitCode);

}

// an exit method that does clean up first

void _exit(int exitCode) {

node2exe::cleanUp();

_exit(exitCode);

}

}

#endif // SRC_NODE2EXE_H_