test.pzl

// zlc testing script

unsigned long ext_var;
extern unsigned long action;
extern char *ext_names[5];
//extern char *header, *referer, *method, *protocol, *uri, *host, *port, *query;
unsigned long g_var1 = 345467;

import __cdecl print2(char *, char *);
import __cdecl int strcmp2(char *, char *);
import __cdecl print(char *);
import __cdecl printn(int);
import __cdecl printh(unsigned long);
import __cdecl int settextcolor(unsigned long);
import __cdecl strcmp(char *, char *);
import __cdecl isset(char *);
import __cdecl merge(char **, char *);
import __cdecl char *encode(char *);
import __cdecl char *decode(char *);
import __cdecl free(char *);
import __stdcall int MessageBoxA(unsigned long, char *, char *, unsigned long) from "user32.dll";

function test_params(char *one, char *two, char *three);
function cb_func();

function print_ascii(char *text)
{
	unsigned long i;
	i = 0;
	while(text[i])
	{
		if((text[i] == '\x1b') && (text[i+1] == '['))
		{
			unsigned long color;
			color = 0;
		while(text[i+2] && text[i+3] && (text[i+4] == ';'))
		{
			unsigned long color1;
			color1 = ((text[i+2] - '0') *10) + (text[i+3] - '0');
//#define FOREGROUND_BLUE      0x0001 // text color contains blue.
//#define FOREGROUND_GREEN     0x0002 // text color contains green.
//#define FOREGROUND_RED       0x0004 // text color contains red.
//#define FOREGROUND_INTENSITY 0x0008 // text color is intensified.

//#define BACKGROUND_BLUE      0x0010 // background color contains blue.
//#define BACKGROUND_GREEN     0x0020 // background color contains green.
//#define BACKGROUND_RED       0x0040 // background color contains red.
//#define BACKGROUND_INTENSITY 0x0080 // background color is intensified.
			if(color1 == 30)
			{
				color |= 0;
			}
			else if(color1 == 31)
			{	
				color |= 0x0008 | 0x0004;
			}
			else if(color1 == 32)
			{	
				color |= 0x0008 | 0x0002;
			}
			else if(color1 == 33)
			{	
				color |= 0x0008 | 0x0002 | 0x0004;
			}
			else if(color1 == 34)
			{	
				color |= 0x0008 | 0x0001;
			}
			else if(color1 == 35)
			{	
				color |= 0x0008 | 0x0001 | 0x0004;
			}
			else if(color1 == 36)
			{	
				color |= 0x0008 | 0x0001 | 0x0002;
			}
			else if(color1 == 37)
			{	
				color |= 0x0008 | 0x0001 | 0x0002 | 0x0004;
			}
			else if(color1 == 40)
			{	
				color |= 0x0080 | 0x0040;
			}
			else if(color1 == 41)
			{	
				color |= 0x0080 | 0x0040;
			}
			else if(color1 == 42)
			{	
				color |= 0x0080 | 0x0020;
			}
			else if(color1 == 43)
			{	
				color |= 0x0080 | 0x0020 | 0x0040;
			}
			else if(color1 == 44)
			{	
				color |= 0x0080 | 0x0010;
			}
			else if(color1 == 45)
			{	
				color |= 0x0080 | 0x0010 | 0x0040;
			}
			else if(color1 == 46)
			{	
				color |= 0x0080 | 0x0010 | 0x0020;
			}
			else if(color1 == 47)
			{	
				color |= 0x0080 | 0x0010 | 0x0020 | 0x0040;
			}
			i += 3;
		}
			settextcolor(color);
			i += 1;
		}
		else
		{	
			char out[2];
			out[0] = text[i];
			out[1] = 0;
			print(out);
		}
		i++;
	}
	settextcolor(0x0001 | 0x0002 | 0x0004);
}

function test_return()
{
	return "Function result return test:                           \x1B[32;PASSED\n";
}

unsigned long g_var2 = 235476;

function test_array(char p1[], char p2[5], char *p3[], char *p4[5])
{
	unsigned long i;
	
	printh(p1); print_ascii("\n");
	printh(p2); print_ascii("\n");
	printh(p3); print_ascii("\n");
	printh(p4); print_ascii("\n");

	printn(sizeof(p1)); print_ascii("\n");
	printn(sizeof(p2)); print_ascii("\n");
	printn(sizeof(p3)); print_ascii("\n");
	printn(sizeof(p4)); print_ascii("\n");
//*
	print_ascii("Test array p1:\n");
	for(i = 0; i < 5; i++)
	{
		printn(i); print_ascii(". ");
		printn(p1[i]); print_ascii("\n");
	}

	print_ascii("Test array p2:\n");
	for(i = 0; i < 5; i++)
	{
		printn(i); print_ascii(". ");
		printn(p2[i]); print_ascii("\n");
	}

	print_ascii("Test array p3:\n");
	for(i = 0; i < 5; i++)
	{
		print_ascii(p3[i]); print_ascii("\n");
	}

	print_ascii("Test array p4:\n");
	for(i = 0; i < 5; i++)
	{
		print_ascii(p4[i]); print_ascii("\n");
	}
//*/
}

unsigned long g_var3 = 789645;

function test_script()
{
	unsigned long pass;

	//___dbg_print_regs;

	print_ascii("\n");
	print_ascii(__COMPILER__);
	print_ascii("\nScript compiled at: ");
	print_ascii(__DATE__);
	print_ascii(" ");
	print_ascii(__TIME__);
	print_ascii("\nThis is a test script! :)\n");

	print_ascii("Test if-else-if-else conditions:                       ");
	pass = 0;

	if(action == 1)
		// here place code for action 1
		pass = 0;
	else if(action == 2)
		pass = 0;
	else if(action == 3)
		pass = 1;
	else if(action == 4)
		pass = 0;
	else
		pass = 0;

	action = 1982;

	print_ascii(pass?"\x1B[32;PASSED\n":"\x1B[31;FAILED\n");

	print_ascii("if(1) if(0) else . else:                               ");

	if(1)
		if(0)
			print_ascii("\x1B[31;FAILED");
		else
			print_ascii("\x1B[32;PASSED\n");
	else
		print_ascii("\x1B[31;FAILED\n");

	print_ascii("Test switch without break:                             ");
	pass = 4;
	switch(2)
	{
		case 2:
			pass--;
		case 1:
			pass--;
		default:
			pass--;
	}

	print_ascii((pass==1)?"\x1B[32;PASSED\n":"\x1B[31;FAILED\n");

	print_ascii("Test switch default case:                              ");
	pass = 3;
	switch(1)
	{
		case 2:
			pass--;
		case 1:
			pass--;
		default:
			pass--;
	}

	print_ascii((pass==1)?"\x1B[32;PASSED\n":"\x1B[31;FAILED\n");

	print_ascii("Test switch in switch with break:                      ");
	pass = 0;
	switch(1)
	{
		case 2:
			pass = 0;
			break;
		case 1:
			switch(7)
			{
				case 1:
					pass = 0;
					break;
				case 7:
					pass = 1;
					break;
				default:
					pass = 0;
					break;
			}
			break;
		default:
			pass = 0;
	}

	print_ascii((pass==1)?"\x1B[32;PASSED\n":"\x1B[31;FAILED\n");

	print_ascii(test_return());

	print_ascii("Test infinity loop to print 4 messages from array with break:\n");

	char *arr_msg[5];
	unsigned long msg_code;

	arr_msg[0] = "0.                                                     \x1B[32;PASSED\n";
	arr_msg[1] = "1.                                                     \x1B[32;PASSED\n";
	arr_msg[2] = "2.                                                     \x1B[32;PASSED\n";
	arr_msg[3] = "3.                                                     \x1B[32;PASSED\n";
	arr_msg[4] = "4.                                                     \x1B[31;FAILED\n";

	for(msg_code = 0; TRUE; msg_code++)
	{
		if(msg_code <= 3)
		{
			print_ascii(arr_msg[msg_code]);
		}
		else
		{
			break;
		}
	}

	print_ascii("Test sizeof for variables, types and arrays:\n");

	char msg[] = "Message";
	print_ascii("  sizeof(msg):                                         "); print_ascii((sizeof(msg) == 8)?"\x1B[32;PASSED\n":"\x1B[31;FAILED\n");

	char *text[2+3];
	short int ***ptr_size = &ptr_size;
	char ch[10];
	char hello[] = {'\x1B', '[', '3', '2', ';', 'P', 'A', 'S', 'S', 'E', 'D', '\n', '\0'};
	char uk[][3] = {1,2,3,4,5};
	short int uk2[][4][2] = {1,2,3,4,5,6,7,8,9,10};

	print_ascii("  sizeof(text):                                        "); print_ascii((sizeof(text) == 20)?"\x1B[32;PASSED\n":"\x1B[31;FAILED\n");
	print_ascii("  sizeof(text[0]):                                     "); print_ascii((sizeof(text[0]) == 4)?"\x1B[32;PASSED\n":"\x1B[31;FAILED\n");
	print_ascii("  sizeof(text[0][0]):                                  "); print_ascii((sizeof(text[0][0]) == 1)?"\x1B[32;PASSED\n":"\x1B[31;FAILED\n");
	print_ascii("  sizeof(ptr_size):                                    "); print_ascii((sizeof(ptr_size) == 4)?"\x1B[32;PASSED\n":"\x1B[31;FAILED\n");
	print_ascii("  sizeof(ptr_size[0]):                                 "); print_ascii((sizeof(ptr_size[0]) == 4)?"\x1B[32;PASSED\n":"\x1B[31;FAILED\n");
	print_ascii("  sizeof(ptr_size[0][0]):                              "); print_ascii((sizeof(ptr_size[0][0]) == 4)?"\x1B[32;PASSED\n":"\x1B[31;FAILED\n");
	print_ascii("  sizeof(ptr_size[0][0][0]):                           "); print_ascii((sizeof(ptr_size[0][0][0]) == 2)?"\x1B[32;PASSED\n":"\x1B[31;FAILED\n");
	print_ascii("  sizeof(ch):                                          "); print_ascii((sizeof(ch) == 10)?"\x1B[32;PASSED\n":"\x1B[31;FAILED\n");
	print_ascii("  sizeof(hello):                                       "); print_ascii((sizeof(hello) == 13)?hello:"\x1B[31;FAILED\n");
	print_ascii("  sizeof(uk):                                          "); print_ascii((sizeof(uk) == 6)?"\x1B[32;PASSED\n":"\x1B[31;FAILED\n");
	print_ascii("  sizeof(uk2):                                         "); print_ascii((sizeof(uk2) == 32)?"\x1B[32;PASSED\n":"\x1B[31;FAILED\n");
	print_ascii("  sizeof(short int):                                   "); print_ascii((sizeof(short int) == 2)?"\x1B[32;PASSED\n":"\x1B[31;FAILED\n");
	print_ascii("  sizeof(int):                                         "); print_ascii((sizeof(int) == 4)?"\x1B[32;PASSED\n":"\x1B[31;FAILED\n");
	print_ascii("  sizeof(unsigned long):                               "); print_ascii((sizeof(unsigned long) == 4)?"\x1B[32;PASSED\n":"\x1B[31;FAILED\n");
	print_ascii("  sizeof(double):                                      "); print_ascii((sizeof(double) == 8)?"\x1B[32;PASSED\n":"\x1B[31;FAILED\n");
	print_ascii("  sizeof(char):                                        "); print_ascii((sizeof(char) == 1)?"\x1B[32;PASSED\n":"\x1B[31;FAILED\n");
	print_ascii("  sizeof(uk2[0]):                                      "); print_ascii((sizeof(uk2[0]) == 16)?"\x1B[32;PASSED\n":"\x1B[31;FAILED\n");
	print_ascii("  sizeof(uk2[0][0]):                                   "); print_ascii((sizeof(uk2[0][0]) == 4)?"\x1B[32;PASSED\n":"\x1B[31;FAILED\n");
	print_ascii("  sizeof(uk2[0][0][0]):                                "); print_ascii((sizeof(uk2[0][0][0]) == 2)?"\x1B[32;PASSED\n":"\x1B[31;FAILED\n");

	/*
	print_ascii("  sizeof(p1):      "); print_ascii((sizeof(p1) == 1)?"\x1B[32;PASSED\n":"\x1B[31;FAILED\n");
	print_ascii("  sizeof(p2):      "); print_ascii((sizeof(p2) == 4)?"\x1B[32;PASSED\n":"\x1B[31;FAILED\n");
	print_ascii("  sizeof(p3):      "); print_ascii((sizeof(p3) == 5)?"\x1B[32;PASSED\n":"\x1B[31;FAILED\n");
	print_ascii("  sizeof(p4):      "); print_ascii((sizeof(p4) == 4)?"\x1B[32;PASSED\n":"\x1B[31;FAILED\n");
	*/

	print_ascii("Test for loop with extract array value as condition:   ");

	unsigned long int i, x;

	text[0] = "Hello, World!";
	text[1] = "Static array defenition example";
	text[2] = "One level supported only";
	text[3] = "Next step - multiple level!";
	text[4] = 0;

	for(i = 0; text[i]; i++) nop;

	print_ascii((i == 4)?"\x1B[32;PASSED\n":"\x1B[31;FAILED\n");

	print_ascii("Test size override prefix:                             ");

	char message[8];

	message[4] = 'E';
	message[0] = 'P';
	message[2] = 'S';
	message[3] = 'S';
	message[5] = 'D';
	message[1] = 'A';
	message[6] = '\n';
	message[7] = 0;

	print_ascii(message);

	print_ascii("Test for fixed size multi-level array matrix[5][7]:    ");
	pass = 1;

	short int matrix[5][7];
	short int *pmatrix = matrix;

	if(sizeof(matrix) != 70) pass = 0;

	for(i = 0; i < 5; i++)
	{
	  for(x = 0; x < 7; x++)
	  {
		 matrix[i][x] = (i+1)*(x+1);
	  }
	}

	for(i = 0; i < 5; i++)
	{
		for(x = 0; x < 7; x++)
		{
			if(matrix[i][x] != (i+1)*(x+1))
			{
				pass = 0;
				break 2;
			}

			if(&matrix[i][x] != pmatrix)
			{
				pass = 0;
				break 2;
			}

			pmatrix++;
		}
	}

	print_ascii(pass?"\x1B[32;PASSED\n":"\x1B[31;FAILED\n");

	print_ascii("Test goto-loop with external variable:                 ");
	pass = 0;

	ext_var = 1;

	lb_loop:
	   if(ext_var++ < 2)
	   {
		  goto lb_loop;
	   }
	   else
	   {
		   pass = 1;
	   }

	print_ascii(pass?"\x1B[32;PASSED\n":"\x1B[31;FAILED\n");

	print_ascii("Test logical conditions (or, and):                     ");
	pass = 1;

	pass || print_ascii("\x1B[31;FAILED ");
	0 && print_ascii("\x1B[31;FAILED ");
	1 || print_ascii("\x1B[31;FAILED ");

	print_ascii(pass?"\x1B[32;PASSED\n":"\x1B[31;FAILED\n");

	while(0) if(1)
	{
		print_ascii("Test while loop:                                       \x1B[31;FAILED\n"); 
		break;
	}

	print_ascii("Test operand size override:                            ");
	pass = 0;

	char test = 0xFFFF;
	if(test == 0xFF) pass = 1;

	print_ascii(pass?"\x1B[32;PASSED\n":"\x1B[31;FAILED\n");

	print_ascii("Test array with auto size and values pointed to words: ");
	pass = 0;

	unsigned long offset;
	char *arr_of_words[] =
	{
		"bird",
		"snake",
		"tiger",
		"wolf",
		NULL
	};

	char *key = "tiger";

	if(sizeof(arr_of_words) != 20) pass = 0;

	for(offset = 0; arr_of_words[offset]; offset++)
	{
		if(!strcmp(arr_of_words[offset], key)) pass = 1;
	}

	if(!pass) goto lb_end_test_01;

	pass = 0;

	char **word = arr_of_words;

	while(*word)
	{
		if(!strcmp(*word, key)) pass = 1;
		word++;
	}

	lb_end_test_01:

	print_ascii(pass?"\x1B[32;PASSED\n":"\x1B[31;FAILED\n");

	print_ascii("Test arithmetic operations:                            ");
	pass = 1;

	unsigned long z = 0;

	z += 10;
	if(z != 10) pass = 0;
	z -= 5;
	if(z != 5) pass = 0;
	z *= 2;
	if(z != 10) pass = 0;
	z /= 2;
	if(z != 5) pass = 0;
	z %= 2;
	if(z != 1) pass = 0;
	z <<= 1;
	if(z != 2) pass = 0;
	z >>= 1;
	if(z != 1) pass = 0;
	z &= 0x0100;
	if(z) pass = 0;
	z |= 0x0100;
	if(z != 256) pass = 0;
	z ^= 0x0100;
	if(z) pass = 0;

	print_ascii(pass?"\x1B[32;PASSED\n":"\x1B[31;FAILED\n");

	print_ascii("Test global variable initialisation:                   ");
	pass = 1;
	if(g_var1 != 345467) pass = 0;
	if(g_var2 != 235476) pass = 0;
	if(g_var3 != 789645) pass = 0;
	print_ascii(pass?"\x1B[32;PASSED\n":"\x1B[31;FAILED\n");

	char p1[5];
	char p2[5];
	char *p3[5];
	char *p4[5];

	p1[0] = 20;
	p1[1] = 21;
	p1[2] = 22;
	p1[3] = 23;
	p1[4] = 24;

	p2[0] = 30;
	p2[1] = 31;
	p2[2] = 32;
	p2[3] = 33;
	p2[4] = 34;

	p3[0] = "p3[0] =                                                \x1B[32;PASSED";
	p3[1] = "p3[1] =                                                \x1B[32;PASSED";
	p3[2] = "p3[2] =                                                \x1B[32;PASSED";
	p3[3] = "p3[3] =                                                \x1B[32;PASSED";
	p3[4] = "p3[4] =                                                \x1B[32;PASSED";

	p4[0] = "p4[0] =                                                \x1B[32;PASSED";
	p4[1] = "p4[1] =                                                \x1B[32;PASSED";
	p4[2] = "p4[2] =                                                \x1B[32;PASSED";
	p4[3] = "p4[3] =                                                \x1B[32;PASSED";
	p4[4] = "p4[4] =                                                \x1B[32;PASSED";

	print_ascii("Test array pointer:                                    ");

	pass = 0;

	if(p1 == &p1)
	{
		pass = 1;
	}

	print_ascii(pass?"\x1B[32;PASSED\n":"\x1B[31;FAILED\n");

	printh(p1); print_ascii("\n");
	printh(p2); print_ascii("\n");
	printh(p3); print_ascii("\n");
	printh(p4); print_ascii("\n\n");

	test_array(p1, p2, p3, p4);

	print_ascii("Test internal function call and params order:          ");

	print_ascii(test_params("one", "two", "three")?"\x1B[32;PASSED\n":"\x1B[31;FAILED\n");

	print_ascii("Test callback function call:                           ");
	void *cb_fn;
	cb_fn = cb_func;
	cb_fn();

	print_ascii("Test external array:\n");

	for(i = 0; i < 5; i++)
	{
		print_ascii(ext_names[i]);
	}

	print_ascii("Test typeof:                                           \n");
	char var[12][27];
	unsigned long var_type;
	var_type = typeof(var);
	print_ascii("  Variable i has type (hex):                           "); printh(var_type); print_ascii("\n");
	print_ascii("  Variable i has type (string):   signed char i[12] ==");

	if(var_type & 0x00001000)
	{
		print_ascii(" internal");
	}
	if(var_type & 0x00002000)
	{
		print_ascii(" external");
	}
	if(var_type & 0x00000200)
	{
		print_ascii(" signed");
	}
	if(var_type & 0x00000400)
	{
		print_ascii(" unsigned");
	}
	if(var_type & 0x00000080)
	{
		print_ascii(" short");
	}
	if(var_type & 0x00000100)
	{
		print_ascii(" long");
	}
	if(var_type & 0x00000004)
	{
		print_ascii(" void");
	}
	if(var_type & 0x00000008)
	{
		print_ascii(" char");
	}
	if(var_type & 0x00000010)
	{
		print_ascii(" double");
	}
	if(var_type & 0x00000020)
	{
		print_ascii(" float");
	}
	if(var_type & 0x00000040)
	{
		print_ascii(" int");
	}
	unsigned long ii;
	ii = (var_type & 0xFF000000) >> 24;
	print_ascii(" ");
	while(ii--)
	{
		print_ascii("*");
	}
	print_ascii("i");
	if(var_type & 0x00004000)
	{
		print_ascii("[");printn(sizeof(var)/sizeof(var[0]));print_ascii("]");
	}
	print_ascii(";\n");

	print_ascii("Test swap parameters when push to call stack:          ");
	char *temp;
	char *temp2;
	char *header = NULL;
	char *query = "\x1B[32;PASSED\n";
	merge(&header, temp = encode(query));
	free(temp);
	print_ascii(temp2 = decode(header));
	free(temp2);

	print_ascii("Call external MessageBox function: ");

	if(MessageBoxA(0, "MessageBox function loaded from user32.dll", "Test caption", 0x00000004 | 0x00000010) == 6)
	{
		print_ascii("You choice:         \x1B[32;YES\n");
	}
	else
	{
		print_ascii("You choice:         \x1B[31;NO\n");
	}


	//___dbg_print_regs;
}

//*/
/*

lb_exit_script:

print_ascii("\nexit regs check:");
_asm {
   dbg_print_regs
}

unsigned long int *int_array;
int_array = alloc(2 * sizeof(unsigned long int));
int_array[0] = 0xAAAAAAAA;
int_array[1] = 0xBBBBBBBB;
free(int_array);

for(0;1;0) { if(1) break; continue; }

while(1)
{
    nop;
    nop;
    while(2)
    {
       nop;
       nop;
       if(3) break 2;
       nop;
       nop;
       continue 2;
       nop;
       nop;
    }


    nop;
    nop;
}
    nop;
    nop;

_asm {nop}
_asm {lb_test1:}
_asm {lb_test2: nop}

print_ascii("Test inline assembler: ");
pass = 0;

_asm
{
	//dbg_print_regs
	push eax
	push ecx

	mov ecx, [ext_var]
lb_again:
	push ecx
	push "some text"
	call fn_loop
	add ecx, 1
	mov [ext_var], ecx
	test eax, eax
	jz lb_again
lb_exit:
	pop ecx
	pop eax
	//dbg_print_regs
}

print_ascii(pass?"\x1B[32;PASSED\n":"\x1B[31;FAILED\n");


//*/

//function proxy_rd()
function proxy_rd(char **header, char *referer, char *method, char *protocol, char *uri, char *host, char *port, char *query)
{
	char *temp;

	merge(header, method);
	merge(header, " ");
	merge(header, uri);
	if(isset(query))
	{
		merge(header, "?");
		merge(header, temp = encode(query)); free(temp);
	}
	merge(header, " ");
	merge(header, protocol);
	merge(header, "\r\n");
	if(isset(host))
	{
		merge(header, "Host: ");
		merge(header, host);
		if(isset(port))
		{
			merge(header, ":");
			merge(header, port);
		}
		merge(header, "\r\n");
	}
	if(isset(referer))
	{
		merge(header, "Referer: ");
		merge(header, referer);
		merge(header, "\r\n");
	}
	merge(header, "\r\n");

	print_ascii("\n---- header ----\n");
	print_ascii(*header);
	print_ascii("---- header ----\n");
}

function small_test()
{
	unsigned long offset;
	char *key = "tiger";

	for(offset = 0; offset < 10; offset++)
	{
		___dbg_print_regs;
		strcmp(key, key);
		___dbg_print_regs;
	}
}

function cb_func()
{
	print_ascii("\x1B[32;PASSED\n");
}

function test_params(char *one, char *two, char *three)
{
	unsigned long pass;

	pass = 1;

	if(strcmp(one, "one") != 0) pass = 0;
	if(strcmp(two, "two") != 0) pass = 0;
	if(strcmp(three, "three") != 0) pass = 0;

	return pass;
}

function print_params(char **one, char *two, char *three)
{
	print_ascii(*one);
	print_ascii(two);
	print_ascii(three);

	return 1982;
}

function int main()
{
	//_asm
	//{
	//	test_script()
	//}
	//small_test();
	//proxy_rd();
	return test_script();
	"\r\n---------------------------------------------\r\n                   TEST SCRIPT                \r\n----------------------------------------------\r\n";
}