hyung (hyung-hwan/hawk)

hyung (hyung-hwan/hawk) | MoltPulse

$ ./configure ## This step offers various build options
$ make
$ make install

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

static const hawk_bch_t* src =
	"BEGIN { print ARGV[0];"
	"   for (i=2;i<=9;i++)"
	"   {"
	"       for (j=1;j<=9;j++)"
	"           print i \"*\" j \"=\" i * j;"
	"       print \"---------------------\";"
	"   }"
	"}";

int main ()
{
	hawk_t* hawk = HAWK_NULL;
	hawk_rtx_t* rtx = HAWK_NULL;
	hawk_val_t* retv;
	hawk_parsestd_t psin[2];
	int ret;

	hawk = hawk_openstd(0, HAWK_NULL); /* create a hawk instance */
	if (!hawk)
	{
		fprintf(stderr, "ERROR: cannot open hawk\n");
		ret = -1; goto oops;
	}

	/* set up source script file to read in */
	memset(&psin, 0, HAWK_SIZEOF(psin));
	psin[0].type = HAWK_PARSESTD_BCS;  /* specify the first script path */
	psin[0].u.bcs.ptr = (hawk_bch_t*)src;
	psin[0].u.bcs.len = hawk_count_bcstr(src);
	psin[1].type = HAWK_PARSESTD_NULL; /* indicate the no more script to read */

	ret = hawk_parsestd(hawk, psin, HAWK_NULL); /* parse the script */
	if (ret <= -1)
	{
		hawk_logbfmt(hawk, HAWK_LOG_STDERR, "ERROR(parse): %js\n", hawk_geterrmsg(hawk));
		ret = -1; goto oops;
	}

	/* create a runtime context needed for execution */
	rtx = hawk_rtx_openstd(
		hawk,
		0,
		HAWK_T("hawk02"), /* ARGV[0] */
		HAWK_NULL,  /* stdin */
		HAWK_NULL,  /* stdout */
		HAWK_NULL   /* default cmgr */
	);
	if (!rtx)
	{
		hawk_logbfmt(hawk, HAWK_LOG_STDERR, "ERROR(rtx_open): %js\n", hawk_geterrmsg(hawk));
		ret = -1; goto oops;
	}

	/* execute the BEGIN/pattern-action/END blocks */
	retv = hawk_rtx_loop(rtx); /* alternatively, hawk_rtx_exec(rtx, HAWK_NULL, 0) */
	if (!retv)
	{
		hawk_logbfmt(hawk, HAWK_LOG_STDERR, "ERROR(rtx_loop): %js\n", hawk_geterrmsg(hawk));
		ret = -1; goto oops;
	}

	/* lowered the reference count of the returned value */
	hawk_rtx_refdownval(rtx, retv);
	ret = 0;

oops:
	if (rtx) hawk_rtx_close(rtx); /* destroy the runtime context */
	if (hawk) hawk_close(hawk); /* destroy the hawk instance */
	return -1;
}

$ gcc -Wall -O2 -o hawk02 hawk02.c -lhawk

static hawk_rtx_t* g_rtx = HAWK_NULL;

static void on_os_signal (int sig)
{
	if (g_rtx) hawk_rtx_raisesig(g_rtx, sig);
}

static void on_sigset (hawk_rtx_t* rtx, int sig, hawk_fun_t* fun)
{
	if (fun)
	{
		g_rtx = rtx;
		signal(sig, on_os_signal);
	}
	else
	{
		if (g_rtx == rtx) g_rtx = HAWK_NULL;
		signal(sig, SIG_DFL);
	}
}

hawk_rtx_ecb_t ecb;
memset(&ecb, 0, HAWK_SIZEOF(ecb));
ecb.sigset = on_sigset;
hawk_rtx_pushecb(rtx, &ecb);

#include <Hawk.hpp>
#include <stdio.h>

int main ()
{
	HAWK::HawkStd hawk;

	if (hawk.open() <= -1)
	{
		fprintf(stderr, "unable to open hawk - %s\n", hawk.getErrorMessageB());
		return -1;
	}

	HAWK::HawkStd::SourceString s("BEGIN { print \"hello, world\"; }");
	if (hawk.parse(s, HAWK::HawkStd::Source::NONE) == HAWK_NULL)
	{
		fprintf(stderr, "unable to parse - %s\n", hawk.getErrorMessageB());
		hawk.close();
		return -1;
	}

	HAWK::Hawk::Value vr;
	hawk.loop(&vr);  // alternatively, hawk.exec(&vr, HAWK_NULL, 0);

	hawk.close();
	return 0;
}

$ hawk -f script.hawk input.txt

$ echo "a,b,c" | hawk 'BEGIN{FS=","} {print $2}'

$ printf 'alpha,beta,gamma\n' | hawk --cut 'd, f1 f3'
alpha,gamma
$ printf 'abcdef\n' | hawk --cut 'c2-4'
bcd

$ hawk --sed 's/foo/bar/g' input.txt
$ hawk --sed -n -e '/ERROR/p' application.log

$ hawk --sed --output-line-ending=native '' input.txt
$ hawk --sed --input-line-ending=lf --output-line-ending=lf 's/\r//g' input.txt

$ printf 'PROJECT\n' | hawk --m4 -DPROJECT=hawk
$ hawk --m4 -I ./macros document.m4

hawk --sh -c 'echo hello | tr a-z A-Z > result.txt; cat < result.txt'
hawk --sh -c 'addcmd copy /bin/cat; mode registered; echo hello | copy'

BEGIN {
	data["name"] = "Hawk"
	data["items"] = @["one", "two", "three"]
	rc = mus::process("Hello {{name}}:{{#items}} {{.}}{{/items}}",
	                  data, output, mus::STR_TO_STR)
	if (rc == 0) print output
	else print mus::errmsg()
}

hawkgo --httpd --listen 127.0.0.1:8080 --listen '[::1]:8080' \
  --root ./public --script-root ./scripts --route /api/=handler.hawk

function handle(request)
{
	print "Hello", request["path"];
}

function handle(request)
{
	http::setstatus(200);
	http::setheader("Content-Type", "text/plain; charset=utf-8");
	printf "%s %s\n", http::getmethod(), http::getpath();
	http::flush();
	while (getline > 0) print $0;
}

#include <hawk-aux.h>

hawk_uint16_t id;
hawk_aux_cbs_t callbacks = { application_call, application_close };

/* Check the return value of each operation for errors. */
hawk_rtx_getauxid(rtx, HAWK_T("application"), &id);
hawk_rtx_setauxctx(rtx, id, &callbacks, context);
hawk_rtx_auxcall(rtx, id, command, data);
hawk_rtx_setauxctx(rtx, id, HAWK_NULL, HAWK_NULL);

BEGIN { FS=","; print "start" }
$3 ~ /ERR/ { print NR, $1, $3 }
END { print "done", NR }

@pragma entry main
function main(a, b) {
	print "entry:", a, b
}

$ hawk -f script.hawk one two
entry: one two

BEGIN {
	a = 10
	b = 3.14
	s = "hello"
	c = 'X'
	c2 = @C"X"
	bc = @b'x'
	bc2 = @bc"x"
	bs = @b"\x00\x01"
	m = @{"k": 1, "j": "hello"}
	arr = @["x", "y"]
	print hawk::typename(a), hawk::typename(b), hawk::typename(s), hawk::typename(c), hawk::typename(c2), hawk::typename(bc), hawk::typename(bc2), hawk::typename(bs), hawk::typename(m), hawk::typename(arr)
}

BEGIN {
	x = 10 + 5 * 2
	x += 3
	s = "ha"
	s %%= "wk"
	if (x >= 20) print x
	print s
	if ("10" === 10) print "no"
}

BEGIN {
	print "hi" %% "!"
	if ("A" ~ /^[A-Z]$/) print "regex ok"
}

BEGIN {
	if (1 && 0) print "no"; else print "ok"
}

BEGIN {
	print (1 | 2)  # bitwise OR => 3
	print 1 | 2    # pipe to external command "2"
}

@const C = 5
@global g = 10 + C, h
BEGIN {
	@local x = g + 1, y
	print x, g
	x = 1
	g = 2
	print x, g
}

BEGIN {
	arr = @["a", "b", "c"]
	m = @{"k": "v", 10: "ten"}
	arr[4] = "d"
	m["x"] = 99
	print arr[1], m["k"], m[10]
}

function inc(&x) { x += 1 }
function greet(name) { if (name == "") name = "world"; print "hi", name }
BEGIN { n = 1; inc(n); greet(); greet("hawk"); print n }

function dump(...) {
	@local i
	for (i = 0; i < @argc; i++) print @argv[i]
}
BEGIN { dump("a", 10, "b") }

function desc(a, b) { return b - a }
BEGIN {
	@local a, b, i
	a = @[3, 1, 2]
	asort(a, b, desc)
	for (i in b) print i, b[i]
}

@pragma xcall on

@global gf = func(a, b) { return a + b }

BEGIN {
	@local lf = func(x) { return x * 2 }
	pf = func(z) { return z - 1 }      # plain/implicit variable
	m = @{}
	m["call"] = func(v) { return v * v }  # indexed assignment
	m.call2 = func(v) { return v + 100 }  # dot-notation indexed assignment

	print gf(10, 20), lf(7), pf(9), m["call"](5), m.call2(5)
}

{ if ($1 > 0) print $1; else print "skip" }

BEGIN {
	i = 1
	while (i <= 3) { print i; i++ }
}

BEGIN {
	i = 0
	do { print i; i++ } while (i < 3)
}

BEGIN {
	for (i = 1; i <= 3; i++) print i
}

BEGIN {
	arr = @["x", "y"]
	for (i in arr) print i, arr[i]
}

BEGIN {
	b = @{"k": 1}
	if ("k" in b) print "yes"
}

BEGIN {
	x = 2
	switch (x) {
	case 1: print "one"; break;
	case 2: print "two"; break;
	default: print "other";
	}
}

BEGIN {
	for (i = 1; i <= 5; i++) {
		if (i == 3) continue
		if (i == 5) break
		print i
	}
	exit 0
}

BEGIN {
	print "BEGIN"
	exit 99
}
END {
	print "END" ## this is executed
}

BEGIN {
	print "BEGIN"
	@exit 99
}
END {
	print "END" ## this is not executed
}

$ hawk -t /tmp/1 -t /tmp/2 'BEGIN { print 10; nextofile; print 20 }'

BEGIN {
	while (("ls -laF" | getline x) > 0) print "\t", x;
	close ("ls -laF");
}

BEGIN {
	cmd = "sort";
	data = hawk::array("hello", "world", "two-way pipe", "testing");

	for (i = 1; i <= length(data); i++) print data[i] |& cmd;
	close(cmd, "to");

	while ((cmd |& getline line) > 0) print line;
	close(cmd);
}

BEGIN {
	while ((getline line < "input.txt") > 0) print line > "out.txt"
	print "more" >> "out.txt"
}

BEGIN { getbline b < "bin.dat"; print str::tohex(b) }

BEGIN { FS="?,\"\"\""; }
{ for (i = 0; i <= NF; i++) print i, "[" $i "]"; }

{ print NR, NF, $0 }

BEGIN {
	print ARGC, ARGV[0]
	print ENVIRON["HOME"]
	PIPECLOEXEC = 1
}

BEGIN { print length("hawk"), substr("hawk", 2, 2) }

@pragma entry main;
function main () { print "hello, world"; }

@pragma entry main
function main(arg1, arg2) {
	print "Arguments:", arg1, arg2
}

$ hawk -f main.hawk arg1_value arg2_value

@pragma entry main
function main(...) {
	@local i
	for (i = 0; i < @argc; i++) printf("%s:", @argv[i])
	print ""
}

$ hawk -f main.hawk 10 20 30 40 50

function x(a, b, ...) {
	print "a=", a, "b=", b, "rest=", (@argc - 2)
}
BEGIN { x(1, 2, 3, 4) }

@pragma implicit off;
BEGIN {
    a = 10; ## syntax error - undefined identifier 'a'
}

@pragma implicit off;
BEGIN {
    @local a;
    a = 10; ## syntax ok - 'a' is declared before use
}

@pragma defermodsym on
BEGIN {
	if (0) optionalmod::setup();
	print "startup complete";
}

$ hawk --defermodsym on -f script.hawk

$ echo '  a  b  c  d  ' | hawk '@pragma striprecspc on;
BEGIN { FS="[[:space:]]+"; }
{
    print "NF=" NF;
    for (i = 0; i < NF; i++) print i " [" $(i+1) "]";
}'
NF=4
0 [a]
1 [b]
2 [c]
3 [d]

$ echo '  a  b  c  d  ' | hawk '@pragma striprecspc off;
BEGIN { FS="[[:space:]]+"; }
{
    print "NF=" NF;
    for (i = 0; i < NF; i++) print i " [" $(i+1) "]";
}'
NF=6
0 []
1 [a]
2 [b]
3 [c]
4 [d]
5 []

function print_hello() { print "hello\n"; }

@include "hello.inc";
BEGIN { print_hello(); }

@include_once "hello.inc";
@include_once "hello.inc";
BEGIN { print_hello(); }

BEGIN {
	@include "init.inc";
	...
}

x = y; # assign y to x.
/*
this line is ignored.
this line is ignored too.
*/

BEGIN {
	i = 0
	n = 1
	while (i < 10) {
		if (n % 2 == 0) {
			print n
			i++
		}
		n++
	}
}

BEGIN {
	do {
		printf "Enter a positive number: "
		getline num
	} while (num <= 0)
	print "You entered:", num
}

BEGIN {
	for (i = 1; i <= 10; i++) {
		for (j = 1; j <= 10; j++) {
			printf "%4d", i * j
		}
		printf "\n"
	}
}

BEGIN {
	for (i = 1; i <= 20; i++) {
		if (i % 2 != 0) {
			continue
		}
		print i
		if (i >= 16) {
			break
		}
	}
}

{
	n = split($0, words, /[^[:alnum:]_]+/)
	for (i = 1; i <= n; i++) {
		freq[words[i]]++
	}
}

END {
	for (w in freq) {
		printf "%s: %d\n", w, freq[w]
	}
}

BEGIN {
	print str::tohex(digest::sha256(@b"hello"))
}

ctx = digest::init("sha256")
ctx = digest::update(ctx, first_chunk)
ctx = digest::update(ctx, second_chunk)
hash = str::tohex(digest::final(ctx))

BEGIN {
	data = json::parse("{\"name\":\"hawk\",\"items\":[1,2,3]}")
	data.items[4] = 4
	print data.name
	print json::stringify(data)
}

BEGIN {
	source = "define(`NAME', `hawk')dnl\nNAME"
	rc = m4::process(source, output, m4::STR_TO_STR)
	if (rc == 0) print output
}

BEGIN {
	rc = m4::process("document.m4", "document.txt",
	                 m4::FILE_TO_FILE, "./macros")
}

BEGIN {
	rc = sed::process("s/foo/bar/g", "foo foo", output, sed::STR_TO_STR)
	if (rc == 0) print output
}

BEGIN {
	master = sys::openpt(sys::O_RDWR | sys::O_NOCTTY);
	if (master < 0) { print sys::errmsg(); exit 1; }
	if (sys::grantpt(master) < 0 || sys::unlockpt(master) < 0 ||
	    sys::ptsname(master, pathname) < 0) {
		print sys::errmsg(); sys::close(master); exit 1;
	}
	slave = sys::open(pathname, sys::O_RDWR | sys::O_NOCTTY);
	if (slave < 0) { print sys::errmsg(); sys::close(master); exit 1; }
	sys::tcsetraw(slave);
	sys::write(slave, @b"hello");
	sys::read(master, text, 5);
	print text;
	sys::close(slave);
	sys::close(master);
}

BEGIN {
	if (sys::openpty(master, slave) < 0) exit 1;

	fflush();
	pid = sys::fork();
	if (pid < 0)
	{
		sys::close(master);
		sys::close(slave);
		exit 1;
	}

	if (pid == 0)
	{
		sys::close(master);

		if (sys::login_tty(slave) < 0) exit 1;

		rc = sys::system("exec /bin/sh -i");
		exit (rc == 0? 0: 1);
	}

	sys::close(slave);
	sys::write(master, @b"echo hello; exit\n");

	while (1)
	{
		n = sys::read(master, data);
		if (n == sys::RC_EINTR) continue;
		if (n <= 0) break;

		printf "%s", data;
	}

	sys::wait(pid, status);
	sys::close(master);
}

BEGIN {
	if (sys::openlog("remote://127.0.0.1:514/myapp",
		sys::LOG_OPT_ISO8601 | sys::LOG_OPT_PID | sys::LOG_OPT_NDELAY,
		sys::LOG_FAC_USER) < 0) {
		print sys::errmsg(); exit 1;
	}
	if (sys::writelog(sys::LOG_PRI_INFO, "started") < 0) print sys::errmsg();
	sys::closelog();
}

function on_int(sig) { print "got", sig }

BEGIN {
	sys::signal(sys::SIGINT, on_int);
	sys::raise(sys::SIGINT);
	## sys::kill(sys::getpid(), sys::SIGINT);
	sys::signal(sys::SIGINT, @nil);
}

BEGIN {
	f = sys::open("/etc/sysctl.conf", sys::O_RDONLY);
	if (f >= 0) {
		while(sys::read(f, x, 10) > 0) printf(@b"%s", x);
		sys::close(f);
	}
}

BEGIN {
	f = sys::open("data.bin", sys::O_RDWR);
	if (f < 0) { print sys::errmsg(); exit 1; }
	if (sys::read(f, line, 8192, "\n") > 0) {
		if (sys::fseek(f, 0, sys::SEEK_CUR) >= 0)
			sys::write(f, @b"replacement");
		else print sys::errmsg();
	}
	sys::close(f);
}

BEGIN {
	a = sys::openfd(1);
	sys::write(a, @b"let me write something here\n");
	sys::close(a, sys::C_KEEPFD); ## set C_KEEPFD to release 1 without closing it.
	##sys::close(a);
	print "done\n";
}

sys::addtomux(m, fd, sys::MUX_EVT_IN, sys::MUX_FLAG_NOAUTODEL);

BEGIN {
	if (sys::pipe(p0, p1, sys::O_CLOEXEC | sys::O_NONBLOCK) <= -1)
	##if (sys::pipe(p0, p1, sys::O_CLOEXEC) <= -1)
	##if (sys::pipe(p0, p1) <= -1)
	{
		print "pipe error";
		return -1;
	}
	a = sys::fork();
	if (a <= -1) 
	{
		print "fork error";
		sys::close(p0);
		sys::close(p1);
	}
	else if (a == 0)
	{
		## child
		printf("child.... %d %d %d\n", sys::getpid(), p0, p1);
		sys::close(p1);
		while (1)
		{
			n = sys::read(p0, k, 3);
			if (n <= 0) 
			{
				if (n == sys::RC_EAGAIN) continue; ## nonblock but data not available
				if (n != 0) print "ERROR: " sys::errmsg();
				break;
			}
			print k;
		}
		sys::close(p0);
		return 123;
	}
	else
	{
		## parent
		printf("parent.... %d %d %d\n", sys::getpid(), p0, p1);
		sys::close(p0);
		sys::write(p1, @b"hello");
		sys::write(p1, @b"world");
		sys::close(p1);

		##sys::wait(a, status, sys::WNOHANG);
		while (sys::wait(a, status) != a);
		if (sys::WIFEXITED(status)) print "Exit code: " sys::WEXITSTATUS(status);
		else print "Child terminated abnormally"
	}
}

BEGIN {
	if (sys::pipe(p0, p1, sys::O_NONBLOCK | sys::O_CLOEXEC) <= -1)
	{
			print "pipe error";
			return -1;
	}
	a = sys::fork();
	if (a <= -1)
	{
		print "fork error";
		sys::close (p0);
		sys::close (p1);
	}
	else if (a == 0)
	{
		## child
		sys::close (p0);

		stdout = sys::openfd(1);
		sys::dup(p1, stdout);

		print @b"hello world";
		print @b"testing sys::dup()";
		print @b"writing to standard output..";

		sys::close (p1);
		sys::close (stdout);
	}
	else
	{
		sys::close (p1);
		while (1)
		{
			n = sys::read(p0, k, 10);
			if (n <= 0)
			{
				if (n == sys::RC_EAGAIN) continue; ## nonblock but data not available
				if (n != 0) print "ERROR: " sys::errmsg();
				break;
			}
			print "[" k "]";
		}
		sys::close (p0);
		sys::wait(a);
	}
}

BEGIN {
	a = sys::open("/etc/inittab", sys::O_RDONLY);
	x = sys::open("/etc/fstab", sys::O_RDONLY);

	b = sys::dup(a);
	sys::close(a);

	while (sys::read(b, abc, 100) > 0) printf (@b"%s", abc);

	print "-------------------------------";

	c = sys::dup(x, b, sys::O_CLOEXEC);
	## assertion: b == c
	sys::close (x);

	while (sys::read(c, abc, 100) > 0) printf (@b"%s", abc);
	sys::close (c);
}

BEGIN {
	sys::pack(bin, "2x3");         ## Two zero bytes; the trailing 3 is ignored.
	sys::unpack(@b"AB", "B3", v);  ## v becomes 65; the trailing 3 is ignored.
}

BEGIN {
	d = sys::opendir("/etc", sys::DIR_SORT);
	if (d >= 0)
	{
		while (sys::readdir(d,a) > 0)
		{
			print a;
			sys::stat("/etc/" %% a, b);
			for (i in b) print "\t", i, b[i];
		}
		sys::closedir(d);
	} 
}

BEGIN { 
	if (sys::getnwifcfg("lo", sys::NWIFCFG_IN6, x) <= -1)
		print sys::errmsg();
	else
		for (i in x) print i, x[i]; 
}

BEGIN
{
	s = sys::socket();
	...
	sys::close (s);
}

BEGIN {
	ffi = ffi::open();
	if (ffi::call(ffi, r, @b"getenv", @b"s>s", "PATH") <= -1) print ffi::errmsg();
	else print r;
	ffi::close (ffi);
}

BEGIN {
	mysql = mysql::open();

	if (mysql::connect(mysql, "localhost", "username", "password", "mysql") <= -1)
	{
		print "connect error -", mysql::errmsg();
	}

	if (mysql::query(mysql, "select * from user") <= -1)
	{
		print "query error -", mysql::errmsg();
	}

	result = mysql::store_result(mysql);
	if (result <= -1)
	{
		print "store result error - ", mysql::errmsg();
	}

	while (mysql::fetch_row(result, row) > 0)
	{
		ncols = length(row);
		for (i = 0; i < ncols; i++) print row[i];
		print "----";
	}

	mysql::free_result(result);

	mysql::close(mysql);
}

sqlite> .schema
CREATE TABLE a(x int, y varchar(255));

@pragma entry main
@pragma implicit off

function main() {
	@local db, stmt, row, i, ncols;

	db = sqlite::open();
	if (db <= -1) {
		print "open error -", sqlite::errmsg();
		return;
	}

	if (sqlite::connect(db, "/tmp/test.db", sqlite::CONNECT_READWRITE) <= -1) {
		print "connect error -", sqlite::errmsg();
		sqlite::close(db);
		return;
	}

	sqlite::exec(db, "begin transaction");
	sqlite::exec(db, "delete from a");
	for (i = 0; i < 10; i++) {
		@local sql, fld;
		if (sqlite::escape_string(db, ((i % 2)? @b"'STXETX'": "'␂␃'") %% (math::rand() * 100), fld) <= -1) {
			print "escape_string error -", sqlite::errmsg();
			sqlite::exec(db, "rollback");
			sqlite::close(db);
			return;
		}
		sql=sprintf("insert into a(x,y) values(%d,'%s')", math::rand() * 100, fld);
		print sql;
		if (sqlite::exec(db, sql) <= -1) {
			print "exec error -", sqlite::errmsg();
			sqlite::exec(db, "rollback");
			sqlite::close(db);
			return;
		}
	}
	sqlite::exec(db, "commit");

	stmt = sqlite::prepare(db, "select x,y from a where x>?");
	if (stmt <= -1) {
		print "prepare error -", sqlite::errmsg();
		sqlite::close(db);
		return;
	}

	if (sqlite::bind(stmt, 1, 10) <= -1) {
		print "bind error -", sqlite::errmsg();
		sqlite::finalize(stmt);
		sqlite::close(db);
		return;
	}

	ncols = sqlite::column_count(stmt);
	printf ("TOTAL %d COLUMNS:\n", ncols);
	for (i = 1; i <= ncols; i++) {
		print "-", i, sqlite::column_name(stmt, i);
	}
	while (sqlite::fetch_row(stmt, row, sqlite::FETCH_ROW_ARRAY) > 0) {
		print "[id]", row[1], "[name]", row[2];
	}

	sqlite::finalize(stmt);
	sqlite::close(db);
}

function q(a) {
  a[1] = 20;
  a[2] = 30;
}

BEGIN {
  q(x);
  for (i in x)
    print i, x[i];
}

function q(&a) {
  a[1] = 20;
  a[2] = 30;
}

BEGIN {
  q(x);
  for (i in x)
    print i, x[i];
}

function q(a) {
  a[1] = 20;
  a[2] = 30;
}

BEGIN {
  x[3] = 99; delete (x[3]);  ## x = hawk::array() or x = hawk::map() also will do
  q(x);
  for (i in x)
    print i, x[i];
}

hyung

MoltPulse

Hawk - Embeddable AWK Interpreter in C/C++

Table of Contents

Features

Building Hawk From Source Code

Embedding Hawk in C Applications

Embedding Signal Handling

Embedding Hawk in C++ Applications

Language

What Hawk Is

Running Hawk

Cut, Sed, and M4 command modes

Embeddable shell and --sh

Embeddable Mustache engine

Go HTTP server mode

HTTP request and response helpers

Generic aux services

Go console I/O callbacks

Execution Model

@pragma entry

Values and Types

Expressions and Operators

Arithmetic and Comparison

Strings and Regex

Logical Operators

Bitwise Operators

Variables and Scope

Arrays and Maps

Functions

Function Literals

Control Flow

if / else

while

do ... while

for

for (i in array)

in operator (key existence)

switch

break / continue / return / exit / @exit

nextfile / nextofile

Input, Output, and Pipes

Built-in Variables

Built-in Functions

Pragmas

@pragma entry

@pragma implicit

@pragma defermodsym

@pragma striprecspc

@include and @include_once

Comments

Reserved Words

Some Examples

Garbage Collection

Modules

HTTP

Message Digest

Hawk

JSON

M4

Sed

String

System

Pseudo-terminals and terminal control

Remote logging timestamps

Time formatting

Sleep durations

Signals

Raw byte reads

Buffered reads and file positions

Wrap a file descriptor

I/O multiplexing

Multiplexer cleanup and fork

Pipe to a child process

Read child stdout

Duplicate file handles

Binary packing and unpacking

Directory traversal

Network interface info

Sockets

Embeddable shell and `--sh`