hawk/samples/hawk51.cpp

/*
 * $Id$
 *
    Copyright (c) 2006-2019 Chung, Hyung-Hwan. All rights reserved.

    Redistribution and use in source and binary forms, with or without
    modification, are permitted provided that the following conditions
    are met:
    1. Redistributions of source code must retain the above copyright
       notice, this list of conditions and the following disclaimer.
    2. Redistributions in binary form must reproduce the above copyright
       notice, this list of conditions and the following disclaimer in the
       documentation and/or other materials provided with the distribution.

    THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR
    IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
    OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
    IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
    NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
    THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <Hawk.hpp>
#include <hawk-utl.h>
#include <hawk-fmt.h>
#include <hawk-cli.h>

#include <stdio.h>
#include <string.h>
#include <signal.h>
#include <stdarg.h>
#include <stdlib.h>
#include <locale.h>

#include <cstring>

#if defined(_WIN32)
#	include <windows.h>
#	include <signal.h>
#elif defined(__OS2__)
#	define INCL_DOSPROCESS
#	include <os2.h>
#	include <signal.h>
#else
#	include <unistd.h>
#	include <signal.h>
#	include <errno.h>
#endif

/* these three definitions for doxygen cross-reference */
typedef HAWK::HawkStd HawkStd;
typedef HAWK::HawkStd::Run Run;
typedef HAWK::HawkStd::Value Value;

/*#ifdef _WIN32
static BOOL WINAPI stop_run (DWORD ctrl_type);
#else */
static void stop_run (int sig);
static void do_nothing (int sig);
/*#endif*/
static void relay_signal (int sig);
static int setsignal (int sig, void(*handler)(int), int restart);
static void print_debug_return (hawk_rtx_t* rtx, hawk_val_t* ret);

class MyHawk: public HawkStd
{
public:
	MyHawk (HAWK::Mmgr* mmgr = HAWK_NULL): HawkStd(mmgr) { }
	~MyHawk () { this->close(); }

	int open ()
	{
		if (HawkStd::open() <= -1) return -1;

		idLastSleep = this->addGlobal(HAWK_T("LAST_SLEEP"));
		if (idLastSleep <= -1) goto oops;

		/* this is for demonstration only.
		 * you can use sys::sleep() instead */
		if (this->addFunction(HAWK_T("sleep"), 1, 1, HAWK_NULL, (FunctionHandler)&MyHawk::sleep) <= -1 ||
		    this->addFunction(HAWK_T("sumintarray"), 1, 1, HAWK_NULL, (FunctionHandler)&MyHawk::sumintarray) <= -1 ||
		    this->addFunction(HAWK_T("arrayindices"), 1, 1, HAWK_NULL, (FunctionHandler)&MyHawk::arrayindices) <= -1) goto oops;

		return 0;

	oops:
		HawkStd::close();
		return -1;
	}

	void uponSigset (Run& run, int sig, bool reset)
	{
		if (reset)
		{
			/* this part must be in sync with set_singal() */
			if (sig == SIGINT)
				setsignal(sig, stop_run, 0);
		#if defined(SIGPIPE)
			else if (sig == SIGPIPE)
				setsignal(sig, do_nothing, 0);
		#endif
			else
				setsignal(sig, SIG_DFL, 0);
		}
		else
		{
			setsignal(sig, relay_signal, 0);
		}
	}

	int sleep (Run& run, Value& ret, Value* args, hawk_oow_t nargs, const hawk_ooch_t* name, hawk_oow_t len)
	{
		if (args[0].isIndexed())
		{
			run.setError (HAWK_EINVAL);
			return -1;
		}

		hawk_int_t x = args[0].toInt();

		/*Value arg;
		if (run.getGlobal(idLastSleep, arg) == 0)
			hawk_printf(HAWK_T("GOOD: [%d]\n"), (int)arg.toInt());
		else { hawk_printf(HAWK_T("BAD:\n")); }
		*/

		if (run.setGlobal (idLastSleep, x) <= -1) return -1;

	#if defined(_WIN32)
		::Sleep ((DWORD)(x * 1000));
		return ret.setInt (0);
	#elif defined(__OS2__)
		::DosSleep ((ULONG)(x * 1000));
		return ret.setInt (0);
	#else
		return ret.setInt (::sleep (x));
	#endif
	}

	int sumintarray (Run& run, Value& ret, Value* args, hawk_oow_t nargs, const hawk_ooch_t* name, hawk_oow_t len)
	{
		// BEGIN {
		//   for(i=0;i<=10;i++) x[i]=i;
		//   print sumintarray(x);
		// }
		hawk_int_t x = 0;

		if (args[0].isIndexed())
		{
			Value val(run);
			Value::Index idx;
			Value::IndexIterator ii;

			ii = args[0].getFirstIndex(&idx);
			while (ii != ii.END)
			{
				if (args[0].getIndexed(idx, &val) <= -1) return -1;
				x += val.toInt ();

				ii = args[0].getNextIndex(&idx, ii);
			}
		}
		else x += args[0].toInt();

		return ret.setInt(x);
	}

	int arrayindices (Run& run, Value& ret, Value* args, hawk_oow_t nargs, const hawk_ooch_t* name, hawk_oow_t len)
	{
		// create another array composed of array indices
		// BEGIN {
		//   for(i=0;i<=10;i++) x[i]=i;
		//   y=arrayindices(x);
		//   for (i in y) print y[i];
		// }
		if (!args[0].isIndexed()) return 0;

		Value::Index idx;
		Value::IndexIterator ii;
		hawk_int_t i;

		ii = args[0].getFirstIndex (&idx);
		for (i = 0; ii != ii.END ; i++)
		{
			Value::IntIndex iidx (i);
			if (ret.setIndexedStr (
				iidx, idx.pointer(), idx.length()) <= -1) return -1;
			ii = args[0].getNextIndex (&idx, ii);
		}

		return 0;
	}

private:
	int idLastSleep;
};

static MyHawk* app_hawk = HAWK_NULL;

static void relay_signal (int sig)
{
	if (app_hawk) app_hawk->raiseSignal(sig);
}

static void print_error (const hawk_bch_t* fmt, ...)
{
	va_list va;

	fprintf(stderr, "ERROR: ");

	va_start (va, fmt);
	vfprintf(stderr, fmt, va);
	va_end (va);
}

static void print_warning (const hawk_bch_t* fmt, ...)
{
	va_list va;
	fprintf (stderr, "WARNING: ");
	va_start (va, fmt);
	vfprintf (stderr, fmt, va);
	va_end (va);
}

static void print_error(MyHawk& hawk)
{
	hawk_errnum_t code = hawk.getErrorNumber();
	hawk_loc_t loc = hawk.getErrorLocation();

	if (loc.file)
	{
		print_error("Line %lu Column %lu Code %d File %s - %s\n",
			(unsigned long int)loc.line,
			(unsigned long int)loc.colm,
			(int)code,
			hawk.getErrorLocationFileB(),
			hawk.getErrorMessageB());
	}
	else
	{
		print_error("Line %lu Column %lu Code %d - %s\n",
			(unsigned long int)loc.line,
			(unsigned long int)loc.colm,
			(int)code,
			hawk.getErrorMessageB());
	}
}

/*
#if defined(_WIN32)
static BOOL WINAPI stop_run (DWORD ctrl_type)
{
	if (ctrl_type == CTRL_C_EVENT ||
	    ctrl_type == CTRL_CLOSE_EVENT)
	{
		if (app_hawk) app_hawk->halt();
		return TRUE;
	}

	return FALSE;
}
#else */

static int setsignal (int sig, void(*handler)(int), int restart)
{
#if defined(HAVE_SIGACTION)
	struct sigaction sa_int;

	sa_int.sa_handler = handler;
	sigemptyset(&sa_int.sa_mask);

	sa_int.sa_flags = 0;

	if (restart)
	{
	#if defined(SA_RESTART)
		sa_int.sa_flags |= SA_RESTART;
	#endif
	}
	else
	{
	#if defined(SA_INTERRUPT)
		sa_int.sa_flags |= SA_INTERRUPT;
	#endif
	}
	return sigaction(sig, &sa_int, NULL);
#else
	return (signal(sig, handler) == SIG_ERR)? -1: 0;
#endif
}

static void stop_run (int sig)
{
	int e = errno;
	if (app_hawk) app_hawk->halt();
	errno = e;
}

static void do_nothing (int sig)
{
}

/*#endif*/

static void set_signal (void)
{
/*#ifdef _WIN32
	SetConsoleCtrlHandler(stop_run, TRUE);
#else*/
	/*setsignal(SIGINT, stop_run, 1); TO BE MORE COMPATIBLE WITH WIN32*/
	setsignal(SIGINT, stop_run, 0);
#if defined(SIGPIPE)
	setsignal(SIGPIPE, do_nothing, 0);
#endif
/*#endif*/
}

static void unset_signal(void)
{
/*
#ifdef _WIN32
	SetConsoleCtrlHandler(stop_run, FALSE);
#else*/
	setsignal(SIGINT, SIG_DFL, 1);
#if defined(SIGPIPE)
	setsignal(SIGPIPE, SIG_DFL, 1);
#endif
/*#endif*/
}

static void print_usage (FILE* out, const hawk_bch_t* argv0)
{
	fprintf(out, "USAGE: %s [options] -f sourcefile [ -- ] [datafile]*\n", argv0);
	fprintf(out, "       %s [options] [ -- ] sourcestring [datafile]*\n", argv0);
	fprintf(out, "Where options are:\n");
	fprintf(out, " -h                print this message\n");
	fprintf(out, " -D                show extra information\n");
	fprintf(out, " -f sourcefile     set the source script file\n");
	fprintf(out, " -d deparsedfile   set the deparsing output file\n");
	fprintf(out, " -o outputfile     set the console output file\n");
	fprintf(out, " -F string         set a field separator(FS)\n");
	fprintf(out, " -v name=value     add a global variable assignment\n");
	fprintf(out, " -I string         set include directories\n");
	fprintf(out, " --modlibdirs str  set module library directories\n");
}

struct cmdline_t
{
	struct gv_t
	{
		int id;
		hawk_bch_t* name;
		hawk_bch_t* value;
	};

	hawk_bch_t* ins;
	hawk_bch_t* inf;
	hawk_bch_t* outf;
	hawk_bch_t* outc;
	hawk_bch_t* fs;
	hawk_bch_t* incdirs;
	hawk_bch_t* modlibdirs;

	gv_t* gvm;
	int gvcapa;
	int gvsize;

	HAWK::Hawk::Value* argv;
	int argc;
	int debug;
};

static void print_awk_value (hawk_rtx_t* rtx, const hawk_oocs_t* name, hawk_val_t* val)
{
	hawk_t* hawk = hawk_rtx_gethawk(rtx);
	hawk_bch_t* str;
	hawk_oow_t len;
	hawk_errinf_t oerrinf;
#if defined(HAWK_OOCH_IS_UCH)
	hawk_bch_t* bcname = HAWK_NULL;
#endif

	hawk_rtx_geterrinf(rtx, &oerrinf);

	str = hawk_rtx_valtobcstrdup(rtx, val, &len);
	if (!str)
	{
		if (hawk_rtx_geterrnum(rtx) == HAWK_EVALTOSTR)
		{
		#if defined(HAWK_OOCH_IS_UCH)
			bcname = hawk_rtx_duputobchars(rtx, name->ptr, name->len, HAWK_NULL);
			if (bcname)
			{
				fprintf(stderr, "%s = [not printable]\n", bcname);
				hawk_rtx_freemem(rtx, bcname);
			}
			else
			{
				fprintf(stderr, "***OUT OF MEMORY***\n");
			}
		#else
			fprintf(stderr, "%.*s = [not printable]\n", (int)name->len, name->ptr);
		#endif
			hawk_rtx_seterrinf(rtx, &oerrinf);
		}
		else
		{
			fprintf(stderr, "***OUT OF MEMORY***\n");
		}
	}
	else
	{
	#if defined(HAWK_OOCH_IS_UCH)
		bcname = hawk_rtx_duputobchars(rtx, name->ptr, name->len, HAWK_NULL);
		if (!bcname)
		{
			fprintf(stderr, "***OUT OF MEMORY***\n");
			hawk_freemem(hawk, str);
			return;
		}
		fprintf(stderr, "%s = %.*s\n", bcname, (int)len, str);
		hawk_rtx_freemem(rtx, bcname);
	#else
		fprintf(stderr, "%.*s = %.*s\n", (int)name->len, name->ptr, (int)len, str);
	#endif
		hawk_freemem(hawk, str);
	}
}

static void print_debug_return (hawk_rtx_t* rtx, hawk_val_t* ret)
{
	hawk_oow_t len;
	hawk_bch_t* str;
	hawk_rtx_nv_itr_t itr;
	hawk_val_t* nv;

	if (hawk_rtx_isnilval(rtx, ret))
	{
		fprintf(stderr, "[RETURN] - ***nil***\n");
	}
	else
	{
		str = hawk_rtx_valtobcstrdup(rtx, ret, &len);
		if (!str)
		{
			fprintf(stderr, "[RETURN] - ***OUT OF MEMORY***\n");
		}
		else
		{
			fprintf(stderr, "[RETURN] - [%.*s]\n", (int)len, str);
			hawk_freemem(hawk_rtx_gethawk(rtx), str);
		}
	}

	fprintf(stderr, "[NAMED VARIABLES]\n");
	for (nv = hawk_rtx_getfirstnv(rtx, &itr); nv; nv = hawk_rtx_getnextnv(rtx, &itr))
	{
		print_awk_value(rtx, &itr.name, nv);
	}
	fprintf(stderr, "[END OF NAMED VARIABLES]\n");
}

static void free_cmdline (cmdline_t* cmdline)
{
	if (cmdline->gvm)
	{
		free(cmdline->gvm);
		cmdline->gvm = HAWK_NULL;
	}

	cmdline->gvcapa = 0;
	cmdline->gvsize = 0;
}

static int add_var_assign (cmdline_t* cmdline, hawk_bch_t* name, hawk_bch_t* value, int argc)
{
	if (cmdline->gvsize >= cmdline->gvcapa)
	{
		int newcapa = cmdline->gvcapa + argc + 1;
		cmdline_t::gv_t* tmp = (cmdline_t::gv_t*)realloc(cmdline->gvm, HAWK_SIZEOF(*tmp) * newcapa);
		if (!tmp) return -1;
		cmdline->gvm = tmp;
		cmdline->gvcapa = newcapa;
	}

	cmdline->gvm[cmdline->gvsize].id = -1;
	cmdline->gvm[cmdline->gvsize].name = name;
	cmdline->gvm[cmdline->gvsize].value = value;
	cmdline->gvsize++;
	return 0;
}

static int set_modlibdirs (MyHawk& hawk, const hawk_bch_t* dirs)
{
#if defined(HAWK_OOCH_IS_UCH)
	hawk_uch_t* tmp;
	int n;

	tmp = hawk_dupbtoucstr((hawk_t*)hawk, dirs, HAWK_NULL, 1);
	if (!tmp) return -1;

	n = hawk_setopt((hawk_t*)hawk, HAWK_OPT_MODLIBDIRS, tmp);
	hawk_freemem((hawk_t*)hawk, tmp);
	return n;
#else
	return hawk_setopt((hawk_t*)hawk, HAWK_OPT_MODLIBDIRS, dirs);
#endif
}

static int handle_cmdline (MyHawk& hawk, int argc, hawk_bch_t* argv[], cmdline_t* cmdline)
{
	static hawk_bcli_lng_t lng[] =
	{
		{ ":modlibdirs", '\0' },
		{ HAWK_NULL, '\0' }
	};

	static hawk_bcli_t opt =
	{
		"hDF:f:d:o:I:v:",
		lng
	};
	hawk_bci_t c;

	std::memset(cmdline, 0, HAWK_SIZEOF(*cmdline));
	while ((c = hawk_get_bcli(argc, argv, &opt)) != HAWK_BCI_EOF)
	{
		switch (c)
		{
			case 'h':
				print_usage(stdout, argv[0]);
				return 0;

			case 'D':
				cmdline->debug = 1;
				break;

			case 'F':
				cmdline->fs = opt.arg;
				break;

			case 'f':
				cmdline->inf = opt.arg;
				break;

			case 'd':
				cmdline->outf = opt.arg;
				break;

			case 'o':
				cmdline->outc = opt.arg;
				break;

			case 'I':
				cmdline->incdirs = opt.arg;
				break;

			case 'v':
			{
				hawk_bch_t* eq = hawk_find_bchar_in_bcstr(opt.arg, HAWK_T('='));
				if (!eq)
				{
					print_error("no value for '%s' in 'v'\n", opt.arg);
					return -1;
				}

				*eq = '\0';
				if (add_var_assign(cmdline, opt.arg, eq + 1, argc) <= -1)
				{
					print_error("out of memory\n");
					return -1;
				}
				break;
			}

			case '\0':
				if (hawk_comp_bcstr(opt.lngopt, "modlibdirs", 0) == 0)
					cmdline->modlibdirs = opt.arg;
				else
				{
					print_error("illegal option - '%s'\n", opt.lngopt);
					return -1;
				}
				break;

			case '?':
				if (opt.lngopt) print_error("illegal option - '%s'\n", opt.lngopt);
				else print_error("illegal option - '%c'\n", opt.opt);
				return -1;

			case ':':
				if (opt.lngopt) print_error("bad argument for '%s'\n", opt.lngopt);
				else print_error("bad argument for '%c'\n", opt.opt);
				return -1;

			default:
				print_usage(stderr, argv[0]);
				return -1;
		}
	}

	if (opt.ind < argc && !cmdline->inf) cmdline->ins = argv[opt.ind++];

	cmdline->argc = 0;
	while (opt.ind < argc)
	{
		if (hawk.addArgument(argv[opt.ind++]) <= -1)
		{
			print_error(hawk);
			return -1;
		}
	}

	if (!cmdline->ins && !cmdline->inf)
	{
		print_usage(stderr, argv[0]);
		return -1;
	}

	return 1;
}

static void free_args_for_exec (cmdline_t* cmdline)
{
	if (cmdline->argv)
	{
		delete[] cmdline->argv;
		cmdline->argv = HAWK_NULL;
	}
	cmdline->argc = 0;
}

static int make_args_for_exec (cmdline_t* cmdline, MyHawk& hawk, MyHawk::Run* run)
{
	try
	{
		cmdline->argc = 0;
		cmdline->argv = HAWK_NULL;
		hawk_oow_t count = hawk.getArgumentCount();

		cmdline->argv = new HAWK::Hawk::Value[count - 1];
		for (hawk_oow_t i = 1; i < count; i++)
		{
			if (cmdline->argv[i - 1].setStr(run, hawk.getArgument(i)) <= -1)
			{
				free_args_for_exec(cmdline);
				return -1;
			}
			cmdline->argc++;
		}
	}
	catch (...)
	{
		free_args_for_exec(cmdline);
		hawk.setError(HAWK_ENOMEM);
		return -1;
	}

	return 0;
}


static int hawk_main (MyHawk& hawk, int argc, hawk_bch_t* argv[])
{
	MyHawk::Run* run;
	cmdline_t cmdline;
	int n;

	hawk.setTrait(hawk.getTrait() | HAWK_FLEXMAP | HAWK_RWPIPE | HAWK_NEXTOFILE);

	// ARGV[0]
	if (hawk.addArgument(argv[0]) <= -1)
	{
		print_error(hawk);
		return -1;
	}

	if ((n = handle_cmdline(hawk, argc, argv, &cmdline)) <= 0)
	{
		free_cmdline(&cmdline);
		return n;
	}

	if (cmdline.incdirs) hawk.setIncludeDirs(cmdline.incdirs);
	if (cmdline.modlibdirs && set_modlibdirs(hawk, cmdline.modlibdirs) <= -1)
	{
		print_error(hawk);
		free_cmdline(&cmdline);
		return -1;
	}
	for (int i = 0; i < cmdline.gvsize; i++)
	{
		cmdline.gvm[i].id = hawk.addGlobal(cmdline.gvm[i].name);
		if (cmdline.gvm[i].id <= -1)
		{
			print_error(hawk);
			free_cmdline(&cmdline);
			return -1;
		}
	}

	MyHawk::Source* in, * out;
	MyHawk::SourceString in_str(cmdline.ins);
	MyHawk::SourceFile in_file(cmdline.inf);
	MyHawk::SourceFile out_file(cmdline.outf);

	in = (cmdline.ins)? (MyHawk::Source*)&in_str: (MyHawk::Source*)&in_file;
	out = (cmdline.outf)? (MyHawk::Source*)&out_file: &MyHawk::Source::NONE;
	run = hawk.parse(*in, *out);
	if (!run)
	{
		print_error(hawk);
		free_cmdline(&cmdline);
		return -1;
	}

	if (cmdline.inf && run->setGlobal(HAWK_GBL_SCRIPTNAME, cmdline.inf, hawk_count_bcstr(cmdline.inf)) <= -1)
	{
		print_error(hawk);
		free_cmdline(&cmdline);
		return -1;
	}

	for (int i = 0; i < cmdline.gvsize; i++)
	{
		if (run->setGlobal(cmdline.gvm[i].id, cmdline.gvm[i].value) <= -1)
		{
			print_error(hawk);
			free_cmdline(&cmdline);
			return -1;
		}
	}

	if (cmdline.fs)
	{
		MyHawk::Value fs(run);
		if (fs.setStr(cmdline.fs) <= -1)
		{
			print_error(hawk);
			free_cmdline(&cmdline);
			return -1;
		}
		if (hawk.setGlobal(HAWK_GBL_FS, fs) <= -1)
		{
			print_error(hawk);
			free_cmdline(&cmdline);
			return -1;
		}
	}

	if (cmdline.outc)
	{
		if (hawk.addConsoleOutput(cmdline.outc) <= -1)
		{
			print_error(hawk);
			free_cmdline(&cmdline);
			return -1;
		}
	}

	MyHawk::Value ret;

	if (make_args_for_exec(&cmdline, hawk, run) <= -1) // data made here is not uself if hawk.loop() invoked in hawk.exec().
	{
		print_error(hawk);
		free_cmdline(&cmdline);
		return -1;
	}

	//if (hawk.loop(&ret) <= -1)
	if (hawk.exec(&ret, cmdline.argv, cmdline.argc) <= -1)
	{
		print_error(hawk);
		free_args_for_exec(&cmdline);
		free_cmdline(&cmdline);
		return -1;
	}

	if (cmdline.debug) print_debug_return(*run, ret);

	free_args_for_exec(&cmdline);
	free_cmdline(&cmdline);
	return 0;
}

static HAWK_INLINE int execute_hawk (int argc, hawk_bch_t* argv[])
{
	//HAWK::HeapMmgr hm (1000000);
	//MyHawk awk(&hm);
	MyHawk hawk;

	if (hawk.open() <= -1)
	{
		print_error(hawk);
		return -1;
	}
	app_hawk = &hawk;

	set_signal();
	int n = hawk_main(hawk, argc, argv);
	unset_signal();

	app_hawk = HAWK_NULL;
	hawk.close();
	return n;
}

/* ---------------------------------------------------------------------- */

int main (int argc, hawk_bch_t* argv[])
{
	int ret;

#if defined(_WIN32)
	char locale[100];
	UINT codepage;
	WSADATA wsadata;
	int sock_inited = 0;
#elif defined(__DOS__)
	extern BOOL _watt_do_exit;
	int sock_inited = 0;
#else
	/* nothing special */
#endif

#if defined(_WIN32)
	codepage = GetConsoleOutputCP();
	if (codepage == CP_UTF8)
	{
		/*SetConsoleOUtputCP(CP_UTF8);*/
		/*hawk_setdflcmgrbyid(HAWK_CMGR_UTF8);*/
	}
	else
	{
		/* .codepage */
		hawk_fmt_uintmax_to_bcstr(locale, HAWK_COUNTOF(locale), codepage, 10, -1, '\0', ".");
		setlocale(LC_ALL, locale);
		/* hawk_setdflcmgrbyid(HAWK_CMGR_SLMB); */
	}

#else
	setlocale(LC_ALL, "");
	/* hawk_setdflcmgrbyid(HAWK_CMGR_SLMB); */
#endif

#if defined(_WIN32)
	if (WSAStartup(MAKEWORD(2,0), &wsadata) != 0)
		print_warning("Failed to start up winsock\n");
	else sock_inited = 1;
#elif defined(__DOS__)
	/* TODO: add an option to skip watt-32 */
	_watt_do_exit = 0; /* prevent sock_init from exiting upon failure */
	if (sock_init() != 0) print_warning("Failed to initialize watt-32\n");
	else sock_inited = 1;
#endif

	ret = execute_hawk(argc, argv);

#if defined(_WIN32)
	if (sock_inited) WSACleanup();
#elif defined(__DOS__)
	if (sock_inited) sock_exit();
#endif

	return ret;
}