c99test.c

一款拥有一定历史的C语言编译器

				z = x; z >>= y;
				uz.ll = ux.ll; uz.ll >>= uy.ll;
				result_ll_val(">>=",x_val, y_val, z,__LINE__ -1);
				break;
		/* Casting */
		case op_cast:
			{
#ifndef NOFLOAT
				float f;
				double	d;
#endif
				char	c;
				unsigned char uc;
				short s;
				unsigned short us;
				int 	i;
				unsigned int ui;
				long	l;
				unsigned long ul;

#ifndef NOFLOAT
				f = (float)x;
				uz.ll = (LONGLONG)f;
				result_ll_val("cast from float",x_val, 0L, (long)f,__LINE__ -1);
				d = x;
				uz.ll = (LONGLONG)d;
				result_ll_val("cast from double",x_val, 0L, (long)d,__LINE__ -1);
#endif
				c = (char)x;
				uz.ll = c;
				result_ll_val("cast from char",x_val, 0L, c,__LINE__ -1);
				uc = (unsigned char)x;
				uz.ll = uc;
				result_ll_val("cast from unsigned char",x_val, 0L, (long)uc,__LINE__ -1);
				s = (short)x;
				uz.ll = s;
				result_ll_val("cast from short",x_val, 0L, (long)s,__LINE__ -1);
				us = (unsigned short)x;
				uz.ll = us;
				result_ll_val("cast from unsigned short",x_val, 0L, (long)us,__LINE__ -1);
				i = x;
				uz.ll = i;
				result_ll_val("cast from int",x_val, 0L, (long)i,__LINE__ -1);
				ui = x;
				uz.ll = ui;
				result_ll_val("cast from unsigned int",x_val, 0L, (long)ui,__LINE__ -1);
				l = x;
				uz.ll = l;
				result_ll_val("cast from long",x_val, 0L, (long)l,__LINE__ -1);
				ul = x;
				uz.ll = ul;
				result_ll_val("cast from unsigned long",x_val, 0L, (long)ul,__LINE__ -1);
				break;
			}

	}
}

/*
 *	Do the specified operations using unsigned operands
 */

void	op_test_ull (int op_type, unsigned int x_val, unsigned int y_val)
{
	x = x_val;	y = y_val;
	ux.ull = x_val; uy.ull = y_val;
	switch (op_type)
	{
		case op_add:
				z = x + y;
				uz.ull = ux.ull + uy.ull;
				result_ull_val("+",x_val,y_val,z,__LINE__ -1);
				z = x; z += y;
				uz.ull = ux.ull ;uz.ull += uy.ull;
				result_ull_val("+=",x_val,y_val,z,__LINE__ -1);
				break;
		case op_subtract:
				z = x - y;
				uz.ull = ux.ull - uy.ull;
				result_ull_val("-",x_val,y_val,z,__LINE__ -1);
				z = x; z -= y;
				uz.ull = ux.ull ;uz.ull -= uy.ull;
				result_ull_val("-=",x_val,y_val,z,__LINE__ -1);
				break;
		case op_multiply:
				z = x * y;
				uz.ull = ux.ull * uy.ull;
				result_ull_val("*",x_val,y_val,z,__LINE__ -1);
				z = x; z *= y;
				uz.ull = ux.ull ;uz.ull *= uy.ull;
				result_ull_val("*=",x_val,y_val,z,__LINE__ -1);
				break;
		case op_divide:
				z = x / y;
				uz.ll = ux.ll / uy.ll;
				result_ll_val("/",x_val,y_val,z,__LINE__ -1);
				z = x; z /= y;
				uz.ll = ux.ll ;uz.ll /= uy.ll;
				result_ll_val("/=",x_val,y_val,z,__LINE__ -1);
				break;
		case op_remainder:
				z = x % y;
				uz.ull = ux.ull % uy.ull;
				result_ull_val("%",x_val,y_val,z,__LINE__ -1);
				z = x; z %= y;
				uz.ull = ux.ull ;uz.ull %= uy.ull;
				result_ull_val("%=",x_val,y_val,z,__LINE__ -1);
				break;
	/* logical */
		case op_less:
				z = x < y;
				uz.ull = ux.ull < uy.ull;
				result_ull_val("<",x_val,y_val,z,__LINE__ -1);
				z = x <= y;
				uz.ull = ux.ull <= uy.ull;
				result_ull_val("<=",x_val,y_val,z,__LINE__ -1);
				break;
		case op_greater:
				z = x > y;
				uz.ull = ux.ull > uy.ull;
				result_ull_val(">",x_val,y_val,z,__LINE__ -1);
				z = x >= y;
				uz.ull = ux.ull >= uy.ull;
				result_ull_val(">=",x_val,y_val,z,__LINE__ -1);
				break;
		case op_equality:
				z = x == y;
				uz.ull = ux.ull == uy.ull;
				result_ull_val("==",x_val,y_val,z,__LINE__ -1);
				break;
		case op_inequality:
				z = x != y;
				uz.ull = ux.ull != uy.ull;
				result_ull_val("!=",x_val,y_val,z,__LINE__ -1);
				break;
		case op_logicaland:
				z = x && y;
				uz.ull = ux.ull && uy.ull;
				result_ull_val("&&",x_val,y_val,z,__LINE__ -1);
				break;
		case op_logicalor:
				z = x || y;
				uz.ull = ux.ull || uy.ull;
				result_ull_val("||",x_val,y_val,z,__LINE__ -1);
				break;
#if 0
		case op_hook:
				z = (x == y ? 0 : 1);
				uz.ull = (ux.ull == uy.ull ? 0 : 1);
				result_ull_val("?:",x_val,y_val,z,__LINE__ -1);
				break;
#endif
	/* unary */
#if 0
		case op_minus:
				z = -x;
				uz.ull = -ux.ull;
				result_ull_val("-",x_val, 0L, z,__LINE__ -1);
				break;
#endif
		case op_not:
				z = !x;
				uz.ull = !ux.ull;
				result_ull_val("!",x_val, 0L, z,__LINE__ -1);
				break;
		case op_postincrement:
				z = x++;
				uz.ull = ux.ull++;
				result_ull_val("++(post)",x_val, 0L, z,__LINE__ -1);
				z = x; z++;
				uz.ull = ux.ull;  uz.ull++;
				result_ull_val("++(post - unary)",x_val, 0L, z,__LINE__ -1);
				break;
		case op_preincrement:
				z = ++x;
				uz.ull = ++ux.ull;
				result_ull_val("++(pre)",x_val, 0L, z,__LINE__ -1);
				z = x; ++z;
				uz.ull = ux.ull;  ++uz.ull;
				result_ull_val("++(pre - unary)",x_val, 0L, z,__LINE__ -1);
				break;
		case op_postdecrement:
				z = x--;
				uz.ull = ux.ull--;
				result_ull_val("--(post)",x_val, 0L, z,__LINE__ -1);
				z = x; z--;
				uz.ull = ux.ull;  uz.ull--;
				result_ull_val("--(post - unary)",x_val, 0L, z,__LINE__ -1);
				break;
		case op_predecrement:
				z = --x;
				uz.ull = --ux.ull;
				result_ull_val("--(pre)",x_val, 0L, z,__LINE__ -1);
				z = x; --z;
				uz.ull = ux.ull;  --uz.ull;
				result_ull_val("--(pre - unary)",x_val, 0L, z,__LINE__ -1);
				break;
	/* bitwise */
		case op_and:
				z = x & y;
				uz.ull = ux.ull & uy.ull;
				result_ull_val("&",x_val, y_val, z,__LINE__ -1);
				z = x; z &= y;
				uz.ull = ux.ull;  uz.ull &= uy.ull;
				result_ull_val("&=",x_val, y_val, z,__LINE__ -1);
				break;
		case op_or:
				z = x | y;
				uz.ull = (ux.ull | uy.ull);
				result_ull_val("|",x_val, y_val, z,__LINE__ -1);
				z = x; z |= y;
				uz.ull = ux.ull;  uz.ull |= uy.ull;
				result_ull_val("|=",x_val, y_val, z,__LINE__ -1);
				break;
		case op_xor:
				z = x ^ y;
				uz.ull = (ux.ull ^ uy.ull);
				result_ull_val("^",x_val, y_val, z,__LINE__ -1);
				z = x; z ^= y;
				uz.ull = ux.ull;  uz.ull ^= uy.ull;
				result_ull_val("^=",x_val, y_val, z,__LINE__ -1);
				break;
		case op_negate:
				z = ~x;
				uz.ull = ~ux.ull;
				result_ull_val("~",x_val, 0L, z,__LINE__ -1);
				break;
		case op_lsh:
				z = x << y;
				uz.ull = (ux.ull << uy.ull);
				result_ull_val("<<",x_val, y_val, z,__LINE__ -1);
				z = x; z <<= y;
				uz.ull = ux.ull; uz.ull <<= uy.ull;
				result_ull_val("<<=",x_val, y_val, z,__LINE__ -1);
				break;
		case op_rsh:
				z = x >> y;
				uz.ull = (ux.ull >> uy.ull);
				result_ull_val(">>",x_val, y_val, z,__LINE__ -1);
				z = x; z >>= y;
				uz.ull = ux.ull; uz.ull >>= uy.ull;
				result_ull_val(">>=",x_val, y_val, z,__LINE__ -1);
				break;
		/* Casting */
		case op_cast:
			{
#ifndef NOFLOAT
				float f;
				double	d;
#endif
				char	c;
				unsigned char uc;
				short s;
				unsigned short us;
				int 	i;
				unsigned int ui;
				long	l;
				unsigned long ul;

#ifndef NOFLOAT
				f = (float)x;
				ux.ull = (LONGLONG)f;
				result_ull_val("cast from float",x_val, 0L, (unsigned long)f,__LINE__ -1);
				d = x;
				ux.ull = (LONGLONG)d;
				result_ull_val("cast from double",x_val, 0L, (unsigned long)d,__LINE__ -1);
#endif
				c = (char)x;
				uz.ull = c;
				result_ull_val("cast from char",x_val, 0L, (unsigned long)c,__LINE__ -1);
				uc = (unsigned char)x;
				uz.ull = uc;
				result_ull_val("cast from unsigned char",x_val, 0L, (unsigned long)uc,__LINE__ -1);
				s = (short)x;
				uz.ull = s;
				result_ull_val("cast from short",x_val, 0L, (unsigned long)s,__LINE__ -1);
				us = (unsigned short)x;
				uz.ull = us;
				result_ull_val("cast from unsigned short",x_val, 0L, (unsigned long)us,__LINE__ -1);
				i = x;
				uz.ull = i;
				result_ull_val("cast from int",x_val, 0L, (unsigned long)i,__LINE__ -1);
				ui = x;
				uz.ull = ui;
				result_ull_val("cast from unsigned int",x_val, 0L, (unsigned long)ui,__LINE__ -1);
				l = x;
				ux.ull = l;
				result_ull_val("cast from long",x_val, 0L, (unsigned long)l,__LINE__ -1);
				ul = x;
				uz.ull = ul;
				result_ull_val("cast from unsigned long",x_val, 0L, (unsigned long)ul,__LINE__ -1);
				break;
			}

	}
}

#if 0
LONGLONG	func_ll (LONGLONG param1, long param2, int line)
{
	printf ("%4.d: %-8s Function call with long long parameter\n", line, param1 == param2 ? "OK" : "FAILED");
	return param1;
}


unsigned LONGLONG	func_ull (unsigned LONGLONG param1, unsigned long param2, int line)
{
	printf ("%4.d: %-8s Function call with unsigned long long parameter\n", line, param1 == param2 ? "OK" : "FAILED");
	return param1;
}
#endif

void main (int argc, char * argv[])
{
	int i;
	LONGLONG	ll;
	unsigned LONGLONG	ull;
	char	filename[200];


	if (argc > 1)
	{
		if (NULL == freopen (argv[1], "w", stdout))
		{
			fprintf (stderr, "%s: Failed to open file '%s' for output\n",
					 _prog_name, argv[1]);
			exit (-1);
		}
		else
		{
			need_getchar = FALSE;
		}
	}
	else
	{
		printf ("C99TEST\n");
		printf ("~~~~~~~\n");

		printf ("Enter filename for results\n(or ENTER for stout)\n:  ");
		gets(filename);
		if (strlen(filename))
		{
			if (NULL == freopen (filename, "w", stdout))
			{
				fprintf (stderr, "%s: Failed to open file '%s' for output\n",
						 _prog_name, filename);
				exit (-1);
			}
			else
			{
				need_getchar = FALSE;
			}
		}
		else
		{
			need_getchar = TRUE;
		}

	}

	if (FALSE == need_getchar)
	{
		printf ("C99TEST\n");
		printf ("~~~~~~~\n");
	}

	printf ("Operator Tests:\n\n");

	printf ("Line  Status   Test Performed                  High     Low      = Result (expected)\n");

	for (i = op_add ; i < op_maximum ; i++ )
	{
			op_test_ll (i, 20,3);
			op_test_ll (i, 20,-3);
			op_test_ll (i, -20,3);
			op_test_ll (i, -20,-3);
			op_test_ull (i, 20,3);
	}

	printf ("\nFunction Call Tests:\n\n");


#if 0
	ll = func_ll((LONGLONG)27,27,__LINE__);
	printf ("%4.d: %-8s Function call returning long long\n", __LINE__ -1, ll == 27 ? "OK" : "FAILED");

	ull = func_ull((unsigned LONGLONG)27,27,__LINE__);
	printf ("%4.d: %-8s Function call returning unsigned long long\n", __LINE__ -1, ull == 27 ? "OK" : "FAILED");
#endif

	printf ("\nTESTS COMPLETED\n");
	if (need_getchar)
	{
		fgetc(stderr);
	}
	else
	{
		fprintf (stderr,"\nTESTS COMPLETED\n");
	}
	exit(0);
}