File: intel_parser_t.c

package info (click to toggle)
fcml 1.3.0-2
links: PTS, VCS
area: main
in suites: forky, sid
size: 9,536 kB
sloc: ansic: 57,510; cpp: 21,835; sh: 4,410; lex: 834; makefile: 508; yacc: 317
file content (1101 lines) | stat: -rw-r--r-- 49,443 bytes
parent folder | download | duplicates (2)
/*
 * FCML - Free Code Manipulation Library.
 * Copyright (C) 2010-2020 Slawomir Wojtasiak
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

#include "intel_parser_t.h"

#include <string.h>

#include <fcml_ceh.h>
#include <fcml_common.h>
#include <fcml_types.h>
#include <fcml_errors.h>
#include <fcml_parser.h>
#include <fcml_parser_int.h>
#include <fcml_intel_dialect.h>

fcml_st_dialect *internal_dialect_intel = NULL;
fcml_st_parser_context internal_intel_context = {0};

fcml_bool fcml_tf_parser_suite_init(void) {
	fcml_fn_dialect_init_intel( FCML_INTEL_DIALECT_CF_DEFAULT, &internal_dialect_intel );
	internal_intel_context.dialect = internal_dialect_intel;
	return internal_dialect_intel != NULL;
}

fcml_bool fcml_tf_parser_suite_cleanup(void) {
	if( internal_dialect_intel ) {
		fcml_fn_dialect_free( internal_dialect_intel );
	}
	fcml_fn_symbol_table_free( internal_intel_context.symbol_table );
	return FCML_TRUE;
}

void fcml_tf_parser_int_parse_test1(void) {
	fcml_st_parser_result result;
	fcml_fn_parser_result_prepare( &result );
	STF_ASSERT_EQUAL( fcml_fn_parse( &internal_intel_context, "mov 80-90", &result ), FCML_CEH_GEC_NO_ERROR );
	if( result.instruction != NULL ) {
		STF_ASSERT_EQUAL( result.instruction->operands[0].type, FCML_OT_IMMEDIATE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.size, FCML_DS_8 );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.is_signed, FCML_TRUE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.int8, (fcml_int8_t)-10 );
	} else {
        STF_FAIL();
    }
	fcml_fn_parser_result_free( &result );
}

void fcml_tf_parser_int_parse_test2(void) {
	fcml_st_parser_result result;
	fcml_fn_parser_result_prepare( &result );
	STF_ASSERT_EQUAL( fcml_fn_parse( &internal_intel_context, "mov 0xFF", &result ), FCML_CEH_GEC_NO_ERROR );
	if( result.instruction != NULL ) {
		STF_ASSERT_EQUAL( result.instruction->operands[0].type, FCML_OT_IMMEDIATE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.size, FCML_DS_8 );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.is_signed, FCML_FALSE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.int8, (fcml_int8_t)0xFF );
	} else {
        STF_FAIL();
    }
	fcml_fn_parser_result_free( &result );
}

void fcml_tf_parser_int_parse_test3(void) {
	fcml_st_parser_result result;
	fcml_fn_parser_result_prepare( &result );
	STF_ASSERT_EQUAL( fcml_fn_parse( &internal_intel_context, "mov 0xFFF", &result ), FCML_CEH_GEC_NO_ERROR );
	if( result.instruction != NULL ) {
		STF_ASSERT_EQUAL( result.instruction->operands[0].type, FCML_OT_IMMEDIATE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.size, FCML_DS_16 );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.is_signed, FCML_FALSE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.int16, (fcml_uint16_t)0x0FFF );
	} else {
        STF_FAIL();
    }
	fcml_fn_parser_result_free( &result );
}

void fcml_tf_parser_int_parse_test4(void) {
	fcml_st_parser_result result;
	fcml_fn_parser_result_prepare( &result );
	STF_ASSERT_EQUAL( fcml_fn_parse( &internal_intel_context, "mov 0xFFFF", &result ), FCML_CEH_GEC_NO_ERROR );
	if( result.instruction != NULL ) {
		STF_ASSERT_EQUAL( result.instruction->operands[0].type, FCML_OT_IMMEDIATE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.size, FCML_DS_16 );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.is_signed, FCML_FALSE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.int16, (fcml_int16_t)0xFFFF );
	} else {
        STF_FAIL();
    }
	fcml_fn_parser_result_free( &result );
}

void fcml_tf_parser_int_parse_test5(void) {
	fcml_st_parser_result result;
	fcml_fn_parser_result_prepare( &result );
	STF_ASSERT_EQUAL( fcml_fn_parse( &internal_intel_context, "mov 0xFFFFF", &result ), FCML_CEH_GEC_NO_ERROR );
	if( result.instruction != NULL ) {
		STF_ASSERT_EQUAL( result.instruction->operands[0].type, FCML_OT_IMMEDIATE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.size, FCML_DS_32 );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.is_signed, FCML_FALSE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.int32, (fcml_uint32_t)0x000FFFFF );
	} else {
        STF_FAIL();
    }
	fcml_fn_parser_result_free( &result );
}

void fcml_tf_parser_int_parse_test6(void) {
	fcml_st_parser_result result;
	fcml_fn_parser_result_prepare( &result );
	STF_ASSERT_EQUAL( fcml_fn_parse( &internal_intel_context, "mov 0xFFFFFFFF", &result ), FCML_CEH_GEC_NO_ERROR );
	if( result.instruction != NULL ) {
		STF_ASSERT_EQUAL( result.instruction->operands[0].type, FCML_OT_IMMEDIATE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.size, FCML_DS_32 );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.is_signed, FCML_FALSE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.int32, (fcml_uint32_t)0xFFFFFFFF );
	} else {
	    STF_FAIL();
    }
	fcml_fn_parser_result_free( &result );
}

void fcml_tf_parser_int_parse_test7(void) {
	fcml_st_parser_result result;
	fcml_fn_parser_result_prepare( &result );
	STF_ASSERT_EQUAL( fcml_fn_parse( &internal_intel_context, "mov 0xFFFFFFFFFFFFFFFF", &result ), FCML_CEH_GEC_NO_ERROR );
	if( result.instruction != NULL ) {
		STF_ASSERT_EQUAL( result.instruction->operands[0].type, FCML_OT_IMMEDIATE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.size, FCML_DS_64 );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.is_signed, FCML_FALSE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.int64, 0xFFFFFFFFFFFFFFFFUL );
	} else {
        STF_FAIL();
    }
	fcml_fn_parser_result_free( &result );
}

void fcml_tf_parser_int_parse_test8(void) {
	fcml_st_parser_result result;
	fcml_fn_parser_result_prepare( &result );
	STF_ASSERT_EQUAL( fcml_fn_parse( &internal_intel_context, "mov -0xFFFFFFFFFFFFFFFF", &result ), FCML_CEH_GEC_NO_ERROR );
	if( result.instruction != NULL ) {
		STF_ASSERT_EQUAL( result.instruction->operands[0].type, FCML_OT_IMMEDIATE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.size, FCML_DS_8 );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.is_signed, FCML_FALSE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.int8, (fcml_uint8_t)(fcml_int8_t)1 );
	} else {
        STF_FAIL();
    }
	fcml_fn_parser_result_free( &result );
}

void fcml_tf_parser_int_parse_test9(void) {
	fcml_st_parser_result result;
	fcml_fn_parser_result_prepare( &result );
	STF_ASSERT_EQUAL( fcml_fn_parse( &internal_intel_context, "mov -0xFF", &result ), FCML_CEH_GEC_NO_ERROR );
	if( result.instruction != NULL ) {
		STF_ASSERT_EQUAL( result.instruction->operands[0].type, FCML_OT_IMMEDIATE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.size, FCML_DS_16 );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.is_signed, FCML_TRUE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.int16, (fcml_int16_t)-255 );
	} else {
        STF_FAIL();
    }
	fcml_fn_parser_result_free( &result );
}

void fcml_tf_parser_int_parse_test10(void) {
	fcml_st_parser_result result;
	fcml_fn_parser_result_prepare( &result );
	STF_ASSERT_EQUAL( fcml_fn_parse( &internal_intel_context, "mov 1+2", &result ), FCML_CEH_GEC_NO_ERROR );
	if( result.instruction != NULL ) {
		STF_ASSERT_EQUAL( result.instruction->operands[0].type, FCML_OT_IMMEDIATE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.size, FCML_DS_8 );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.is_signed, FCML_FALSE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.int8, (fcml_uint8_t)(fcml_int8_t)3 );
	} else {
        STF_FAIL();
    }
	fcml_fn_parser_result_free( &result );
}

void fcml_tf_parser_int_parse_test11(void) {
	fcml_st_parser_result result;
	fcml_fn_parser_result_prepare( &result );
	STF_ASSERT_EQUAL( fcml_fn_parse( &internal_intel_context, "mov 1+2*8/(15-13)-1", &result ), FCML_CEH_GEC_NO_ERROR );
	if( result.instruction != NULL ) {
		STF_ASSERT_EQUAL( result.instruction->operands[0].type, FCML_OT_IMMEDIATE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.size, FCML_DS_8 );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.is_signed, FCML_FALSE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.int8, (fcml_uint8_t)8 );
	} else {
        STF_FAIL();
    }
	fcml_fn_parser_result_free( &result );
}

void fcml_tf_parser_int_parse_test12(void) {
	fcml_st_parser_result result;
	fcml_fn_parser_result_prepare( &result );
	STF_ASSERT_EQUAL( fcml_fn_parse( &internal_intel_context, "mov 65535", &result ), FCML_CEH_GEC_NO_ERROR );
	if( result.instruction != NULL ) {
		STF_ASSERT_EQUAL( result.instruction->operands[0].type, FCML_OT_IMMEDIATE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.size, FCML_DS_16 );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.is_signed, FCML_FALSE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.int16, (fcml_int16_t)0xFFFF );
	} else {
        STF_FAIL();
    }
	fcml_fn_parser_result_free( &result );
}

void fcml_tf_parser_int_parse_test13(void) {
	fcml_st_parser_result result;
	fcml_fn_parser_result_prepare( &result );
	STF_ASSERT_EQUAL( fcml_fn_parse( &internal_intel_context, "mov -32768", &result ), FCML_CEH_GEC_NO_ERROR );
	if( result.instruction != NULL ) {
		STF_ASSERT_EQUAL( result.instruction->operands[0].type, FCML_OT_IMMEDIATE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.size, FCML_DS_16 );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.is_signed, FCML_TRUE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.int16, (fcml_int16_t)-32768 );
	} else {
        STF_FAIL();
    }
	fcml_fn_parser_result_free( &result );
}

void fcml_tf_parser_int_parse_test14(void) {
	fcml_st_parser_result result;
	fcml_fn_parser_result_prepare( &result );
	STF_ASSERT_EQUAL( fcml_fn_parse( &internal_intel_context, "mov (-2147483647 - 1)", &result ), FCML_CEH_GEC_NO_ERROR );
	STF_ASSERT_EQUAL( result.instruction->operands[0].type, FCML_OT_IMMEDIATE );
	STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.size, FCML_DS_32 );
	STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.is_signed, FCML_TRUE );
	STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.int32, (fcml_uint32_t)(-2147483647 - 1) );
	fcml_fn_parser_result_free( &result );
}

void fcml_tf_parser_int_parse_test15(void) {
	fcml_st_parser_result result;
	fcml_fn_parser_result_prepare( &result );
	STF_ASSERT_EQUAL( fcml_fn_parse( &internal_intel_context, "mov (-9223372036854775807 - 1)", &result ), FCML_CEH_GEC_NO_ERROR );
	if( result.instruction != NULL ) {
		STF_ASSERT_EQUAL( result.instruction->operands[0].type, FCML_OT_IMMEDIATE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.size, FCML_DS_64 );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.is_signed, FCML_TRUE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.int64, (fcml_uint64_t)(-9223372036854775807LL - 1) );
	} else {
        STF_FAIL();
    }
	fcml_fn_parser_result_free( &result );
}

void fcml_tf_parser_int_parse_test16(void) {
	fcml_st_parser_result result;
	fcml_fn_parser_result_prepare( &result );
	STF_ASSERT_EQUAL( fcml_fn_parse( &internal_intel_context, "mov 18446744073709551615", &result ), FCML_CEH_GEC_NO_ERROR );
	if( result.instruction != NULL ) {
		STF_ASSERT_EQUAL( result.instruction->operands[0].type, FCML_OT_IMMEDIATE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.size, FCML_DS_64 );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.is_signed, FCML_FALSE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.int64, (fcml_uint64_t)18446744073709551615ULL );
	} else {
        STF_FAIL();
    }
	fcml_fn_parser_result_free( &result );
}

void fcml_tf_parser_int_parse_test17(void) {
	fcml_st_parser_result result;
	fcml_fn_parser_result_prepare( &result );
	STF_ASSERT_EQUAL( fcml_fn_parse( &internal_intel_context, "mov 5675", &result ), FCML_CEH_GEC_NO_ERROR );
	if( result.instruction != NULL ) {
		STF_ASSERT_EQUAL( result.instruction->operands[0].type, FCML_OT_IMMEDIATE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.size, FCML_DS_16 );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.is_signed, FCML_FALSE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.int16, (fcml_uint16_t)5675 );
	} else {
        STF_FAIL();
    }
	fcml_fn_parser_result_free( &result );
}

void fcml_tf_parser_int_parse_test18(void) {
	fcml_st_parser_result result;
	fcml_fn_parser_result_prepare( &result );
	STF_ASSERT_EQUAL( fcml_fn_parse( &internal_intel_context, "mov 2147483647", &result ), FCML_CEH_GEC_NO_ERROR );
	if( result.instruction != NULL ) {
		STF_ASSERT_EQUAL( result.instruction->operands[0].type, FCML_OT_IMMEDIATE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.size, FCML_DS_32 );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.is_signed, FCML_FALSE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.int32, (fcml_uint32_t)2147483647 );
	} else {
        STF_FAIL();
    }
	fcml_fn_parser_result_free( &result );
}

void fcml_tf_parser_int_parse_test19(void) {
	fcml_st_parser_result result;
	fcml_fn_parser_result_prepare( &result );
	STF_ASSERT_EQUAL( fcml_fn_parse( &internal_intel_context, "mov 4294967295", &result ), FCML_CEH_GEC_NO_ERROR );
	if( result.instruction != NULL ) {
		STF_ASSERT_EQUAL( result.instruction->operands[0].type, FCML_OT_IMMEDIATE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.size, FCML_DS_32 );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.is_signed, FCML_FALSE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.int32, (fcml_uint32_t)4294967295U );
	} else {
        STF_FAIL();
    }
	fcml_fn_parser_result_free( &result );
}

void fcml_tf_parser_int_parse_test20(void) {
	fcml_st_parser_result result;
	fcml_fn_parser_result_prepare( &result );
	STF_ASSERT_EQUAL( fcml_fn_parse( &internal_intel_context, "mov 4294967296", &result ), FCML_CEH_GEC_NO_ERROR );
	if( result.instruction != NULL ) {
		STF_ASSERT_EQUAL( result.instruction->operands[0].type, FCML_OT_IMMEDIATE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.size, FCML_DS_64 );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.is_signed, FCML_FALSE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.int64, (fcml_uint64_t)4294967296ULL );
	} else {
        STF_FAIL();
    }
	fcml_fn_parser_result_free( &result );
}

void fcml_tf_parser_int_parse_test21(void) {
	fcml_st_parser_result result;
	fcml_fn_parser_result_prepare( &result );
	STF_ASSERT_EQUAL( fcml_fn_parse( &internal_intel_context, "mov -0xFFFFFFFF", &result ), FCML_CEH_GEC_NO_ERROR );
	if( result.instruction != NULL ) {
		STF_ASSERT_EQUAL( result.instruction->operands[0].type, FCML_OT_IMMEDIATE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.size, FCML_DS_64 );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.is_signed, FCML_TRUE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.int64, (fcml_uint64_t)-4294967295LL );
	} else {
        STF_FAIL();
    }
	fcml_fn_parser_result_free( &result );
}

void fcml_tf_parser_int_parse_test22(void) {
	fcml_st_parser_result result;
	fcml_fn_parser_result_prepare( &result );
	STF_ASSERT_EQUAL( fcml_fn_parse( &internal_intel_context, "mov 255", &result ), FCML_CEH_GEC_NO_ERROR );
	if( result.instruction != NULL ) {
		STF_ASSERT_EQUAL( result.instruction->operands[0].type, FCML_OT_IMMEDIATE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.size, FCML_DS_8 );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.is_signed, FCML_FALSE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.int8, (fcml_int8_t)0xFF );
	} else {
        STF_FAIL();
    }
	fcml_fn_parser_result_free( &result );
}

void fcml_tf_parser_int_parse_test23(void) {
	fcml_st_parser_result result;
	fcml_fn_parser_result_prepare( &result );
	STF_ASSERT_EQUAL( fcml_fn_parse( &internal_intel_context, "mov 1", &result ), FCML_CEH_GEC_NO_ERROR );
	if( result.instruction != NULL ) {
		STF_ASSERT_EQUAL( result.instruction->operands[0].type, FCML_OT_IMMEDIATE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.size, FCML_DS_8 );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.is_signed, FCML_FALSE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.int8, 1 );
	} else {
        STF_FAIL();
    }
	fcml_fn_parser_result_free( &result );
}

void fcml_tf_parser_int_parse_test24(void) {
	fcml_st_parser_result result;
	fcml_fn_parser_result_prepare( &result );
    STF_ASSERT_EQUAL( fcml_fn_parse( &internal_intel_context, "mov dword ptr [0x0000FFFF]", &result ), FCML_CEH_GEC_NO_ERROR );
    if( result.instruction != NULL ) {
        STF_ASSERT_EQUAL( result.instruction->operands[0].type, FCML_OT_ADDRESS );
        STF_ASSERT_EQUAL( result.instruction->operands[0].address.address_form, FCML_AF_OFFSET );
        STF_ASSERT_EQUAL( result.instruction->operands[0].address.offset.size, FCML_DS_16 );
        STF_ASSERT_EQUAL( result.instruction->operands[0].address.offset.off16, (fcml_int16_t)0xFFFF );
    } else {
        STF_FAIL();
    }
    fcml_fn_parser_result_free( &result );
}

void fcml_tf_parser_int_parse_test25(void) {
	fcml_st_parser_result result;
	fcml_fn_parser_result_prepare( &result );
    STF_ASSERT_EQUAL( fcml_fn_parse( &internal_intel_context, "mov dword ptr [0xFF-1]", &result ), FCML_CEH_GEC_NO_ERROR );
    if( result.instruction != NULL ) {
        STF_ASSERT_EQUAL( result.instruction->operands[0].type, FCML_OT_ADDRESS );
        STF_ASSERT_EQUAL( result.instruction->operands[0].address.address_form, FCML_AF_OFFSET );
        STF_ASSERT_EQUAL( result.instruction->operands[0].address.offset.size, FCML_DS_16 );
        STF_ASSERT_EQUAL( result.instruction->operands[0].address.offset.off16, 254 );
    } else {
        STF_FAIL();
    }
    fcml_fn_parser_result_free( &result );
}

void fcml_tf_parser_int_parse_test26(void) {
	fcml_st_parser_result result;
	fcml_fn_parser_result_prepare( &result );
    STF_ASSERT_EQUAL( fcml_fn_parse( &internal_intel_context, "mov dword ptr [-1]", &result ), FCML_CEH_GEC_NO_ERROR );
    if( result.instruction != NULL ) {
        STF_ASSERT_EQUAL( result.instruction->operands[0].type, FCML_OT_ADDRESS );
        STF_ASSERT_EQUAL( result.instruction->operands[0].address.address_form, FCML_AF_OFFSET );
        STF_ASSERT_EQUAL( result.instruction->operands[0].address.offset.size, FCML_DS_16 );
        STF_ASSERT_EQUAL( result.instruction->operands[0].address.offset.off16, (fcml_int16_t)0xFFFF );
    } else {
        STF_FAIL();
    }
    fcml_fn_parser_result_free( &result );
}

void fcml_tf_parser_int_parse_test27(void) {
	fcml_st_parser_result result;
	fcml_fn_parser_result_prepare( &result );
    STF_ASSERT_EQUAL( fcml_fn_parse( &internal_intel_context, "mov dword ptr [0xFFFFFFFFFFFFFFFF]", &result ), FCML_CEH_GEC_NO_ERROR );
    if( result.instruction != NULL ) {
        STF_ASSERT_EQUAL( result.instruction->operands[0].type, FCML_OT_ADDRESS );
        STF_ASSERT_EQUAL( result.instruction->operands[0].address.address_form, FCML_AF_OFFSET );
        STF_ASSERT_EQUAL( result.instruction->operands[0].address.offset.size, FCML_DS_64 );
        STF_ASSERT_EQUAL( result.instruction->operands[0].address.offset.off64, 0xFFFFFFFFFFFFFFFFULL );
    } else {
        STF_FAIL();
    }
    fcml_fn_parser_result_free( &result );
}

void fcml_tf_parser_int_parse_test28(void) {
	fcml_st_parser_result result;
	fcml_fn_parser_result_prepare( &result );
    STF_ASSERT_EQUAL( fcml_fn_parse( &internal_intel_context, "mov dword ptr [eax+0xFFFFFFFFFFFFFFFF]", &result ), FCML_CEH_GEC_NO_ERROR );
    if( result.instruction != NULL ) {
        STF_ASSERT_EQUAL( result.instruction->operands[0].type, FCML_OT_ADDRESS );
        STF_ASSERT_EQUAL( result.instruction->operands[0].address.address_form, FCML_AF_COMBINED );
        STF_ASSERT_EQUAL( result.instruction->operands[0].address.effective_address.base.type, FCML_REG_GPR );
        STF_ASSERT_EQUAL( result.instruction->operands[0].address.effective_address.base.reg, FCML_REG_EAX );
        STF_ASSERT_EQUAL( result.instruction->operands[0].address.effective_address.displacement.size, FCML_DS_64 );
        STF_ASSERT_EQUAL( result.instruction->operands[0].address.effective_address.displacement.int64, 0xFFFFFFFFFFFFFFFFULL );
    } else {
        STF_FAIL();
    }
    fcml_fn_parser_result_free( &result );
}

void fcml_tf_parser_int_parse_test29(void) {
	fcml_st_parser_result result;
	fcml_fn_parser_result_prepare( &result );
    STF_ASSERT_EQUAL( fcml_fn_parse( &internal_intel_context, "mov xmmword ptr [eax+0xFFFFFFFFFFFFFFFF]", &result ), FCML_CEH_GEC_NO_ERROR );
    if( result.instruction != NULL ) {
        STF_ASSERT_EQUAL( result.instruction->operands[0].type, FCML_OT_ADDRESS );
        STF_ASSERT_EQUAL( result.instruction->operands[0].hints, FCML_OP_HINT_MULTIMEDIA_INSTRUCTION );
        STF_ASSERT_EQUAL( result.instruction->operands[0].address.address_form, FCML_AF_COMBINED );
        STF_ASSERT_EQUAL( result.instruction->operands[0].address.effective_address.base.type, FCML_REG_GPR );
        STF_ASSERT_EQUAL( result.instruction->operands[0].address.effective_address.base.reg, FCML_REG_EAX );
        STF_ASSERT_EQUAL( result.instruction->operands[0].address.effective_address.displacement.size, FCML_DS_64 );
        STF_ASSERT_EQUAL( result.instruction->operands[0].address.effective_address.displacement.int64, 0xFFFFFFFFFFFFFFFFULL );
    } else {
        STF_FAIL();
    }
    fcml_fn_parser_result_free( &result );
}

void fcml_tf_parser_int_parse_test30(void) {
	fcml_st_parser_result result;
	fcml_fn_parser_result_prepare( &result );
	STF_ASSERT_EQUAL( fcml_fn_parse( &internal_intel_context, "lock mov 1", &result ), FCML_CEH_GEC_NO_ERROR );
	if( result.instruction != NULL ) {
		STF_ASSERT_EQUAL( result.instruction->operands[0].type, FCML_OT_IMMEDIATE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.size, FCML_DS_8 );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.is_signed, FCML_FALSE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.int8, (fcml_uint8_t)1 );
		STF_ASSERT_EQUAL( result.instruction->prefixes, FCML_PREFIX_LOCK );
	} else {
        STF_FAIL();
    }
	fcml_fn_parser_result_free( &result );
}

void fcml_tf_parser_int_parse_test31(void) {
	/* Check if multiple prefixes are allowed.*/
	fcml_st_parser_result result;
	fcml_fn_parser_result_prepare( &result );
	STF_ASSERT_EQUAL( fcml_fn_parse( &internal_intel_context, "lock repne repe mov 1", &result ), FCML_CEH_GEC_NO_ERROR );
	if( result.instruction != NULL ) {
		STF_ASSERT_EQUAL( result.instruction->operands[0].type, FCML_OT_IMMEDIATE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.size, FCML_DS_8 );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.is_signed, FCML_FALSE );
		STF_ASSERT_EQUAL( result.instruction->operands[0].immediate.int8, (fcml_uint8_t)1 );
		STF_ASSERT_EQUAL( result.instruction->prefixes, FCML_PREFIX_LOCK | FCML_PREFIX_REPE | FCML_PREFIX_REPNE );
	} else {
        STF_FAIL();
    }
	fcml_fn_parser_result_free( &result );
}

void fcml_tf_parser_int_parse_test32(void) {
	/* Duplicated prefixes aren't allowed.*/
	fcml_st_parser_result result;
	fcml_fn_parser_result_prepare( &result );
	STF_ASSERT_EQUAL( fcml_fn_parse( &internal_intel_context, "lock lock mov 1", &result ), FCML_CEH_GEC_INVALID_INPUT );
	if( result.instruction != NULL ) {
        STF_FAIL("Instruction should be NULL.");
	} else if( result.errors.errors ){
		fcml_st_ceh_error_container *cont = &(result.errors);
		STF_ASSERT_EQUAL( cont->errors->level, FCML_EN_CEH_EL_ERROR );
		STF_ASSERT_EQUAL( cont->errors->code, ( FCML_CEH_MEC_ERROR_INVALID_SYNTAX ) );
		STF_ASSERT_STRING_EQUAL( "Doubled prefixes.", cont->errors->message );
    } else {
    	STF_FAIL("Errors can not be null here.");
    }
	fcml_fn_parser_result_free( &result );
}

void fcml_tf_parser_int_parse_test_symbols_1(void) {
	fcml_st_parser_result result;
	fcml_fn_parser_result_prepare( &result );
	fcml_st_parser_context context = {0};
	context.dialect = internal_dialect_intel;
	context.ip = 0x401000;
	context.symbol_table = NULL;
	context.configuration.alloc_symbol_table_if_needed = FCML_TRUE;

	STF_ASSERT_EQUAL( fcml_fn_parse( &context, FCML_TEXT( "label:" ), &result ), FCML_CEH_GEC_NO_ERROR );
	STF_ASSERT_PTR_NULL( result.instruction );
	STF_ASSERT_PTR_NOT_NULL( result.symbol );
	STF_ASSERT_PTR_NOT_NULL( context.symbol_table );
	STF_ASSERT_EQUAL( result.symbol->value, 0x401000 );
	STF_ASSERT_STRING_EQUAL( result.symbol->symbol, FCML_TEXT( "label" ) );

	STF_ASSERT_EQUAL( fcml_fn_parse( &context, FCML_TEXT( "_label:" ), &result ), FCML_CEH_GEC_NO_ERROR );
	STF_ASSERT_PTR_NULL( result.instruction );
	STF_ASSERT_PTR_NOT_NULL( result.symbol );
	STF_ASSERT_EQUAL( result.symbol->value, 0x401000 );
	STF_ASSERT_STRING_EQUAL( result.symbol->symbol, FCML_TEXT( "_label" ) );

	fcml_fn_parser_result_free( &result );
	fcml_fn_symbol_table_free( context.symbol_table );
}

void fcml_tf_parser_int_parse_test_symbols_2(void) {
	fcml_st_parser_result result;
	fcml_fn_parser_result_prepare( &result );
	fcml_st_parser_context context = {0};
	context.dialect = internal_dialect_intel;
	context.configuration.override_labels = FCML_FALSE;
	context.configuration.alloc_symbol_table_if_needed = FCML_TRUE;
	context.ip = 0x401000;

	STF_ASSERT_EQUAL( fcml_fn_parse( &context, FCML_TEXT( "label: mov eax,1" ), &result ), FCML_CEH_GEC_NO_ERROR );
	STF_ASSERT_PTR_NOT_NULL( result.instruction );
	STF_ASSERT_STRING_EQUAL( result.instruction->mnemonic, "mov" );
	STF_ASSERT_PTR_NOT_NULL( result.symbol );
	STF_ASSERT_EQUAL( result.symbol->value, 0x401000 );
	STF_ASSERT_STRING_EQUAL( result.symbol->symbol, FCML_TEXT( "label" ) );

	fcml_fn_parser_result_free( &result );
	fcml_fn_symbol_table_free( context.symbol_table );
}

void fcml_tf_parser_int_parse_test_symbols_3(void) {

	fcml_st_parser_result result;

	fcml_fn_parser_result_prepare( &result );

	fcml_st_parser_context context = {0};
	context.dialect = internal_dialect_intel;
	context.configuration.override_labels = FCML_FALSE;
	context.ip = 0x401000;
	context.configuration.alloc_symbol_table_if_needed = FCML_TRUE;

	STF_ASSERT_EQUAL( fcml_fn_parse( &context, FCML_TEXT( "label: mov eax,1" ), &result ), FCML_CEH_GEC_NO_ERROR );
	STF_ASSERT_PTR_NOT_NULL( result.instruction );
	STF_ASSERT_STRING_EQUAL( result.instruction->mnemonic, "mov" );
	STF_ASSERT_PTR_NOT_NULL( result.symbol );
	STF_ASSERT_EQUAL( result.symbol->value, 0x401000 );
	STF_ASSERT_STRING_EQUAL( result.symbol->symbol, FCML_TEXT( "label" ) );

	/* Can not override symbol. */
	STF_ASSERT_EQUAL( fcml_fn_parse( &context, FCML_TEXT( "label: mov eax,1" ), &result ), FCML_CEH_GEC_INVALID_INPUT );

	fcml_st_ceh_error_info *error = result.errors.errors;
	STF_ASSERT_PTR_NOT_NULL( error );
	if( error ) {
		STF_ASSERT_EQUAL( error->code, FCML_CEH_MEC_ERROR_SYMBOL_ALREADY_DEFINED );
		STF_ASSERT_STRING_EQUAL( error->message, FCML_TEXT( "Symbol already defined: label." ) );
	}

	context.configuration.override_labels = FCML_TRUE;

	STF_ASSERT_EQUAL( fcml_fn_parse( &context, FCML_TEXT( "label: add eax,1" ), &result ), FCML_CEH_GEC_NO_ERROR );
	STF_ASSERT_PTR_NOT_NULL( result.instruction );
	STF_ASSERT_STRING_EQUAL( result.instruction->mnemonic, "add" );
	STF_ASSERT_PTR_NOT_NULL( result.symbol );
	STF_ASSERT_EQUAL( result.symbol->value, 0x401000 );
	STF_ASSERT_STRING_EQUAL( result.symbol->symbol, FCML_TEXT( "label" ) );

	fcml_fn_parser_result_free( &result );
	fcml_fn_symbol_table_free( context.symbol_table );
}


/* Undefined symbol. */
void fcml_tf_parser_int_parse_test_symbols_4(void) {
	fcml_st_parser_result result;
	fcml_fn_parser_result_prepare( &result );
	fcml_st_parser_context context = {0};
	context.dialect = internal_dialect_intel;
	context.ip = 0x401000;
	context.configuration.alloc_symbol_table_if_needed = FCML_TRUE;

	STF_ASSERT_EQUAL( fcml_fn_parse( &context, FCML_TEXT( "label: mov eax, symbol" ), &result ), FCML_CEH_GEC_UNDEFINED_SYMBOL );
	STF_ASSERT_PTR_NULL( result.instruction );
	STF_ASSERT_PTR_NULL( result.symbol );

	fcml_st_ceh_error_info *error = result.errors.errors;
	STF_ASSERT_PTR_NOT_NULL( error );
	if( error ) {
		STF_ASSERT_EQUAL( error->code, FCML_CEH_MEC_ERROR_UNDEFINED_SYMBOL );
		STF_ASSERT_STRING_EQUAL( error->message, FCML_TEXT( "Undefined symbol: symbol." ) );
	}

	fcml_fn_parser_result_free( &result );
	fcml_fn_symbol_table_free( context.symbol_table );
}

/* Ignore symbols. */
void fcml_tf_parser_int_parse_test_symbols_5(void) {

	fcml_st_parser_result result;
	fcml_fn_parser_result_prepare( &result );
	fcml_st_parser_context context = {0};
	context.dialect = internal_dialect_intel;
	context.ip = 0x401000;
	context.configuration.ignore_undefined_symbols = FCML_TRUE;
	context.configuration.override_labels = FCML_TRUE;
	context.configuration.alloc_symbol_table_if_needed = FCML_TRUE;

	STF_ASSERT_EQUAL( fcml_fn_parse( &context, FCML_TEXT( "label: mov eax, symbol" ), &result ), FCML_CEH_GEC_NO_ERROR );
	STF_ASSERT_PTR_NOT_NULL( result.instruction );
	STF_ASSERT_PTR_NOT_NULL( result.symbol );

	if( result.instruction ) {
		fcml_st_instruction *instruction = result.instruction;
		STF_ASSERT_EQUAL( instruction->operands[1].type, FCML_OT_IMMEDIATE );
		STF_ASSERT_EQUAL( instruction->operands[1].immediate.size, FCML_DS_8 );
		STF_ASSERT_EQUAL( instruction->operands[1].immediate.int8, 0 );
		STF_ASSERT_EQUAL( instruction->operands[1].immediate.is_signed, FCML_TRUE );
	}

	fcml_fn_parser_result_free( &result );
	fcml_fn_symbol_table_free( context.symbol_table );
}

/* Use defined symbol in the instruction. */
void fcml_tf_parser_int_parse_test_symbols_6(void) {

	fcml_st_parser_result result;
	fcml_fn_parser_result_prepare( &result );
	fcml_st_parser_context context = {0};
	context.dialect = internal_dialect_intel;
	context.ip = 0x401000;
	context.configuration.ignore_undefined_symbols = FCML_TRUE;
	context.configuration.override_labels = FCML_TRUE;
	context.configuration.alloc_symbol_table_if_needed = FCML_TRUE;

	STF_ASSERT_EQUAL( fcml_fn_parse( &context, FCML_TEXT( "label: mov eax, label" ), &result ), FCML_CEH_GEC_NO_ERROR );
	STF_ASSERT_PTR_NOT_NULL( result.instruction );
	STF_ASSERT_PTR_NOT_NULL( result.symbol );

	if( result.instruction ) {
		fcml_st_instruction *instruction = result.instruction;
		STF_ASSERT_EQUAL( instruction->operands[1].type, FCML_OT_IMMEDIATE );
		STF_ASSERT_EQUAL( instruction->operands[1].immediate.size, FCML_DS_32 );
		STF_ASSERT_EQUAL( instruction->operands[1].immediate.int32, 0x401000 );
		// Symbols are always defined as signed values.
		STF_ASSERT_EQUAL( instruction->operands[1].immediate.is_signed, FCML_TRUE );
	}

	fcml_fn_parser_result_free( &result );
	fcml_fn_symbol_table_free( context.symbol_table );
}

/* Multpile symbols in expression. */
void fcml_tf_parser_int_parse_test_symbols_7(void) {

	fcml_st_parser_result result;
	fcml_fn_parser_result_prepare( &result );
	fcml_st_parser_context context = {0};
	context.dialect = internal_dialect_intel;
	context.ip = 0x401000;
	context.configuration.ignore_undefined_symbols = FCML_TRUE;
	context.configuration.override_labels = FCML_TRUE;
	context.symbol_table = fcml_fn_symbol_table_alloc();
	if( !context.symbol_table ) {
		STF_FAIL("Out of memory.");
		return;
	}

	STF_ASSERT_EQUAL( fcml_fn_symbol_add_raw( context.symbol_table, FCML_TEXT("symbol_1"), 10 ), FCML_CEH_GEC_NO_ERROR );
	STF_ASSERT_EQUAL( fcml_fn_symbol_add_raw( context.symbol_table, FCML_TEXT("symbol_2"), 5 ), FCML_CEH_GEC_NO_ERROR );
	STF_ASSERT_EQUAL( fcml_fn_symbol_add_raw( context.symbol_table, FCML_TEXT("symbol_3"), 2 ), FCML_CEH_GEC_NO_ERROR );

	STF_ASSERT_EQUAL( fcml_fn_parse( &context, FCML_TEXT( "label: mov eax, label + ( ( symbol_1 * symbol_2 ) / symbol_3 )" ), &result ), FCML_CEH_GEC_NO_ERROR );
	STF_ASSERT_PTR_NOT_NULL( result.instruction );
	STF_ASSERT_PTR_NOT_NULL( result.symbol );

	if( result.instruction ) {
		fcml_st_instruction *instruction = result.instruction;
		STF_ASSERT_EQUAL( instruction->operands[1].type, FCML_OT_IMMEDIATE );
		STF_ASSERT_EQUAL( instruction->operands[1].immediate.size, FCML_DS_32 );
		STF_ASSERT_EQUAL( instruction->operands[1].immediate.int32, 0x401000 + 25 );
		STF_ASSERT_EQUAL( instruction->operands[1].immediate.is_signed, FCML_FALSE );
	}

	fcml_fn_parser_result_free( &result );
	fcml_fn_symbol_table_free( context.symbol_table );
}

/* Extracting symbols. */
void fcml_tf_parser_int_parse_test_symbols_8(void) {

	fcml_st_parser_result result;

	fcml_fn_parser_result_prepare( &result );

	fcml_st_parser_context context = {0};
	context.dialect = internal_dialect_intel;
	context.ip = 0x401000;
	context.configuration.ignore_undefined_symbols = FCML_TRUE;
	context.configuration.override_labels = FCML_TRUE;
	context.symbol_table = fcml_fn_symbol_table_alloc();
	if( !context.symbol_table ) {
		STF_FAIL("Out of memory.");
		return;
	}

	STF_ASSERT_EQUAL( fcml_fn_symbol_add_raw( context.symbol_table, FCML_TEXT("symbol_1"), 10 ), FCML_CEH_GEC_NO_ERROR );
	STF_ASSERT_EQUAL( fcml_fn_symbol_add_raw( context.symbol_table, FCML_TEXT("symbol_2"), 5 ), FCML_CEH_GEC_NO_ERROR );
	STF_ASSERT_EQUAL( fcml_fn_symbol_add_raw( context.symbol_table, FCML_TEXT("symbol_3"), 2 ), FCML_CEH_GEC_NO_ERROR );

	fcml_st_parser_ast ast = {0};
	fcml_ceh_error error = fcml_fn_parse_to_ast( &context, FCML_TEXT( "label: mov eax, label + ( ( symbol_1 * symbol_2 ) / symbol_3 )" ), &ast );

	if( !error ) {

		STF_ASSERT_PTR_NOT_NULL( ast.symbol );
		STF_ASSERT_PTR_NOT_NULL( ast.tree );

		if( ast.tree ) {
			fcml_st_coll_list *list = NULL;
			error = fcml_fn_ast_extract_used_symbols( ast.tree, &list );
			if( !error ) {
				STF_ASSERT_EQUAL( list->size, 4 );
				fcml_fn_coll_list_free( list, NULL, NULL );
			}

		}

	}

	fcml_fn_parser_free_ast( &ast );
	fcml_fn_symbol_table_free( context.symbol_table );
}

void fcml_tf_parser_int_parse_test_symbols_9(void) {
	fcml_st_parser_result result;
	fcml_fn_parser_result_prepare( &result );
	fcml_st_parser_context context = {0};
	context.dialect = internal_dialect_intel;
	context.ip = 0x401000;
	context.symbol_table = NULL;
	context.configuration.disable_symbols_declaration = FCML_TRUE;

	STF_ASSERT_EQUAL( fcml_fn_parse( &context, FCML_TEXT( "label:" ), &result ), FCML_CEH_GEC_UNSUPPORTED_LABEL_DECLARATION );
	STF_ASSERT_PTR_NULL( result.instruction );
	STF_ASSERT_PTR_NULL( result.symbol );
	STF_ASSERT_PTR_NULL( result.errors.errors );
	STF_ASSERT_PTR_NULL( result.errors.last_error );

	fcml_fn_parser_result_free( &result );
}

void fcml_tf_parser_int_parse_test_symbols_10(void) {

	fcml_st_parser_result result;
	fcml_fn_parser_result_prepare( &result );
	fcml_st_parser_context context = {0};
	context.dialect = internal_dialect_intel;
	context.ip = 0x401000;
	context.symbol_table = NULL;
	context.configuration.disable_symbols_declaration = FCML_FALSE;
	context.configuration.alloc_symbol_table_if_needed = FCML_FALSE;

	STF_ASSERT_EQUAL( fcml_fn_parse( &context, FCML_TEXT( "label: mov eax, 1" ), &result ), FCML_CEH_GEC_NO_ERROR );
	STF_ASSERT_PTR_NOT_NULL( result.instruction );
	STF_ASSERT_PTR_NULL( result.symbol );
	STF_ASSERT_PTR_NULL( result.errors.errors );
	STF_ASSERT_PTR_NULL( result.errors.last_error );
	STF_ASSERT_PTR_NULL( context.symbol_table );

	fcml_fn_parser_result_free( &result );
}

void fcml_tf_parser_int_parse_test_symbols_11(void) {

	/* Symbol table not found and not allocated. */
	fcml_st_parser_result result;
	fcml_fn_parser_result_prepare( &result );
	fcml_st_parser_context context = {0};
	context.dialect = internal_dialect_intel;
	context.configuration.override_labels = FCML_FALSE;
	context.configuration.alloc_symbol_table_if_needed = FCML_FALSE;
	context.ip = 0x401000;

	STF_ASSERT_EQUAL( fcml_fn_parse( &context, FCML_TEXT( "label: mov eax,1" ), &result ), FCML_CEH_GEC_NO_ERROR );
	STF_ASSERT_PTR_NOT_NULL( result.instruction );
	STF_ASSERT_STRING_EQUAL( result.instruction->mnemonic, "mov" );
	STF_ASSERT_PTR_NULL( result.symbol );
	STF_ASSERT_PTR_NULL( context.symbol_table );

	fcml_fn_parser_result_free( &result );
}


/* Pseudo operations operands parsing. */
void fcml_tf_parser_intel_parse_test_pseudo_operation_1(void) {

	fcml_st_parser_result result;
	fcml_fn_parser_result_prepare( &result );
	fcml_st_parser_context context = {0};
	context.dialect = internal_dialect_intel;
	context.ip = 0x401000;
	context.configuration.ignore_undefined_symbols = FCML_TRUE;
	context.configuration.override_labels = FCML_TRUE;
	context.configuration.alloc_symbol_table_if_needed = FCML_TRUE;

	STF_ASSERT_EQUAL( fcml_fn_parse( &context, FCML_TEXT( "label: db 0x12" ), &result ), FCML_CEH_GEC_NO_ERROR );
	STF_ASSERT_PTR_NOT_NULL( result.instruction );
	STF_ASSERT_PTR_NOT_NULL( result.symbol );

	if( result.instruction ) {
		fcml_st_instruction *instruction = result.instruction;
		STF_ASSERT_STRING_EQUAL( "db", result.instruction->mnemonic );
		STF_ASSERT_EQUAL( 1, instruction->operands_count );
		STF_ASSERT_EQUAL( instruction->operands[0].type, FCML_OT_IMMEDIATE );
		STF_ASSERT_EQUAL( instruction->operands[0].immediate.size, FCML_DS_8 );
		STF_ASSERT_EQUAL( instruction->operands[0].immediate.int8, 0x12 );
		STF_ASSERT_EQUAL( instruction->operands[0].immediate.is_signed, FCML_FALSE );
	}

	fcml_fn_parser_result_free( &result );
	fcml_fn_symbol_table_free( context.symbol_table );
}

void fcml_tf_parser_int_parse_test_decorator_bcast(void) {
    fcml_st_parser_result result;
    fcml_fn_parser_result_prepare(&result);
    STF_ASSERT_EQUAL(
            fcml_fn_parse(&internal_intel_context, "vaddpd [eax]{1to8}",
                    &result), FCML_CEH_GEC_NO_ERROR);
    if (result.instruction != NULL) {
        fcml_st_operand *operand = &(result.instruction->operands[0]);
        STF_ASSERT_EQUAL(operand->type, FCML_OT_ADDRESS);
        STF_ASSERT_EQUAL(operand->address.address_form, FCML_AF_COMBINED);
        STF_ASSERT_EQUAL(operand->address.effective_address.base.type,
                FCML_REG_GPR);
        STF_ASSERT_EQUAL(operand->address.effective_address.base.reg,
                FCML_REG_EAX);
        STF_ASSERT_EQUAL(operand->decorators.bcast.is_not_null, FCML_TRUE);
        STF_ASSERT_EQUAL(operand->decorators.bcast.value, 8);
    } else {
        STF_FAIL();
    }
    fcml_fn_parser_result_free(&result);
}

void fcml_tf_parser_int_parse_test_decorator_opmask(void) {
    fcml_st_parser_result result;
    fcml_fn_parser_result_prepare(&result);
    STF_ASSERT_EQUAL(
            fcml_fn_parse(&internal_intel_context, "vaddpd zmm1{k1}",
                    &result), FCML_CEH_GEC_NO_ERROR);
    if (result.instruction != NULL) {
        fcml_st_operand *operand = &(result.instruction->operands[0]);
        STF_ASSERT_EQUAL(operand->type, FCML_OT_REGISTER);
        STF_ASSERT_EQUAL(operand->reg.type, FCML_REG_SIMD);
        STF_ASSERT_EQUAL(operand->reg.reg, FCML_REG_ZMM1);
        STF_ASSERT_EQUAL(operand->reg.size, FCML_DS_512);
        STF_ASSERT_EQUAL(operand->decorators.operand_mask_reg.type,
                FCML_REG_OPMASK);
        STF_ASSERT_EQUAL(operand->decorators.operand_mask_reg.size,
                FCML_DS_64);
        STF_ASSERT_EQUAL(operand->decorators.operand_mask_reg.reg,
                FCML_REG_K1);
        STF_ASSERT_EQUAL(operand->decorators.z, FCML_FALSE);

    } else {
        STF_FAIL();
    }
    fcml_fn_parser_result_free(&result);
}

void fcml_tf_parser_int_parse_test_decorator_opmask_k_z_for_addressing(void) {
    fcml_st_parser_result result;
    fcml_fn_parser_result_prepare(&result);
    STF_ASSERT_EQUAL(
            fcml_fn_parse(&internal_intel_context, "vaddpd cs:[rax+rbx]{k4}{z}",
                    &result), FCML_CEH_GEC_NO_ERROR);
    if (result.instruction != NULL) {
        fcml_st_operand *operand = &(result.instruction->operands[0]);

        STF_ASSERT_EQUAL(result.instruction->operands[0].
                type, FCML_OT_ADDRESS);
        STF_ASSERT_EQUAL(result.instruction->operands[0].
                address.address_form, FCML_AF_COMBINED);
        STF_ASSERT_EQUAL(result.instruction->operands[0].
                address.effective_address.base.size, FCML_DS_64);
        STF_ASSERT_EQUAL(result.instruction->operands[0].
                address.effective_address.base.reg, FCML_REG_RAX);
        STF_ASSERT_EQUAL(result.instruction->operands[0].
                address.effective_address.index.size, FCML_DS_64);
        STF_ASSERT_EQUAL(result.instruction->operands[0].
                address.effective_address.index.reg, FCML_REG_RBX);
        STF_ASSERT_EQUAL(result.instruction->operands[0].
                address.segment_selector.segment_selector.reg, FCML_REG_CS);

        STF_ASSERT_EQUAL(operand->decorators.operand_mask_reg.type,
                FCML_REG_OPMASK);
        STF_ASSERT_EQUAL(operand->decorators.operand_mask_reg.size,
                FCML_DS_64);
        STF_ASSERT_EQUAL(operand->decorators.operand_mask_reg.reg,
                FCML_REG_K4);
        STF_ASSERT_EQUAL(operand->decorators.z, FCML_TRUE);
    } else {
        STF_FAIL();
    }
    fcml_fn_parser_result_free(&result);
}

void fcml_tf_parser_int_parse_test_decorator_opmask_k(void) {
    fcml_st_parser_result result;
    fcml_fn_parser_result_prepare(&result);
    STF_ASSERT_EQUAL(
            fcml_fn_parse(&internal_intel_context, "vaddpd zmm31{k4}{z}",
                    &result), FCML_CEH_GEC_NO_ERROR);
    if (result.instruction != NULL) {
        fcml_st_operand *operand = &(result.instruction->operands[0]);
        STF_ASSERT_EQUAL(operand->type, FCML_OT_REGISTER);
        STF_ASSERT_EQUAL(operand->reg.type, FCML_REG_SIMD);
        STF_ASSERT_EQUAL(operand->reg.reg, FCML_REG_ZMM31);
        STF_ASSERT_EQUAL(operand->reg.size, FCML_DS_512);
        STF_ASSERT_EQUAL(operand->decorators.operand_mask_reg.type,
                FCML_REG_OPMASK);
        STF_ASSERT_EQUAL(operand->decorators.operand_mask_reg.size,
                FCML_DS_64);
        STF_ASSERT_EQUAL(operand->decorators.operand_mask_reg.reg,
                FCML_REG_K4);
        STF_ASSERT_EQUAL(operand->decorators.z, FCML_TRUE);
    } else {
        STF_FAIL();
    }
    fcml_fn_parser_result_free(&result);
}

void fcml_tf_parser_int_parse_test_decorator_z(void) {
    fcml_st_parser_result result;
    fcml_fn_parser_result_prepare(&result);
    STF_ASSERT_EQUAL(
            fcml_fn_parse(&internal_intel_context, "vaddpd zmm31{z}",
                    &result), FCML_CEH_GEC_NO_ERROR);
    if (result.instruction != NULL) {
        fcml_st_operand *operand = &(result.instruction->operands[0]);
        STF_ASSERT_EQUAL(operand->decorators.z, FCML_TRUE);
    } else {
        STF_FAIL();
    }
    fcml_fn_parser_result_free(&result);
}

void fcml_tf_parser_int_parse_test_decorator_er(void) {
    fcml_st_parser_result result;
    fcml_fn_parser_result_prepare(&result);
    STF_ASSERT_EQUAL(
            fcml_fn_parse(&internal_intel_context, "vaddpd {ru-sae}",
                    &result), FCML_CEH_GEC_NO_ERROR);
    if (result.instruction != NULL) {
        fcml_st_operand *operand = &(result.instruction->operands[0]);
        STF_ASSERT_EQUAL(operand->type, FCML_OT_VIRTUAL);
        STF_ASSERT_EQUAL(operand->decorators.er.is_not_null, FCML_TRUE);
        STF_ASSERT_EQUAL(operand->decorators.er.value, FCML_ER_RU_SAE);
    } else {
        STF_FAIL();
    }
    fcml_fn_parser_result_free(&result);
}

void fcml_tf_parser_int_parse_test_decorator_sae(void) {
    fcml_st_parser_result result;
    fcml_fn_parser_result_prepare(&result);
    STF_ASSERT_EQUAL(
            fcml_fn_parse(&internal_intel_context, "vaddpd {sae}",
                    &result), FCML_CEH_GEC_NO_ERROR);
    if (result.instruction != NULL) {
        fcml_st_operand *operand = &(result.instruction->operands[0]);
        STF_ASSERT_EQUAL(operand->type, FCML_OT_VIRTUAL);
        STF_ASSERT_EQUAL(operand->decorators.sae, FCML_TRUE);
    } else {
        STF_FAIL();
    }
    fcml_fn_parser_result_free(&result);
}

fcml_stf_test_case fcml_ti_parser[] = {
	{ "fcml_tf_parser_int_parse_test1", fcml_tf_parser_int_parse_test1 },
	{ "fcml_tf_parser_int_parse_test2", fcml_tf_parser_int_parse_test2 },
	{ "fcml_tf_parser_int_parse_test3", fcml_tf_parser_int_parse_test3 },
	{ "fcml_tf_parser_int_parse_test4", fcml_tf_parser_int_parse_test4 },
	{ "fcml_tf_parser_int_parse_test5", fcml_tf_parser_int_parse_test5 },
	{ "fcml_tf_parser_int_parse_test6", fcml_tf_parser_int_parse_test6 },
	{ "fcml_tf_parser_int_parse_test7", fcml_tf_parser_int_parse_test7 },
	{ "fcml_tf_parser_int_parse_test8", fcml_tf_parser_int_parse_test8 },
	{ "fcml_tf_parser_int_parse_test9", fcml_tf_parser_int_parse_test9 },
	{ "fcml_tf_parser_int_parse_test10", fcml_tf_parser_int_parse_test10 },
	{ "fcml_tf_parser_int_parse_test11", fcml_tf_parser_int_parse_test11 },
	{ "fcml_tf_parser_int_parse_test12", fcml_tf_parser_int_parse_test12 },
	{ "fcml_tf_parser_int_parse_test13", fcml_tf_parser_int_parse_test13 },
	{ "fcml_tf_parser_int_parse_test14", fcml_tf_parser_int_parse_test14 },
	{ "fcml_tf_parser_int_parse_test15", fcml_tf_parser_int_parse_test15 },
	{ "fcml_tf_parser_int_parse_test16", fcml_tf_parser_int_parse_test16 },
	{ "fcml_tf_parser_int_parse_test17", fcml_tf_parser_int_parse_test17 },
	{ "fcml_tf_parser_int_parse_test18", fcml_tf_parser_int_parse_test18 },
	{ "fcml_tf_parser_int_parse_test19", fcml_tf_parser_int_parse_test19 },
	{ "fcml_tf_parser_int_parse_test20", fcml_tf_parser_int_parse_test20 },
	{ "fcml_tf_parser_int_parse_test21", fcml_tf_parser_int_parse_test21 },
	{ "fcml_tf_parser_int_parse_test22", fcml_tf_parser_int_parse_test22 },
	{ "fcml_tf_parser_int_parse_test23", fcml_tf_parser_int_parse_test23 },
	{ "fcml_tf_parser_int_parse_test24", fcml_tf_parser_int_parse_test24 },
	{ "fcml_tf_parser_int_parse_test25", fcml_tf_parser_int_parse_test25 },
	{ "fcml_tf_parser_int_parse_test26", fcml_tf_parser_int_parse_test26 },
	{ "fcml_tf_parser_int_parse_test27", fcml_tf_parser_int_parse_test27 },
	{ "fcml_tf_parser_int_parse_test28", fcml_tf_parser_int_parse_test28 },
	{ "fcml_tf_parser_int_parse_test29", fcml_tf_parser_int_parse_test29 },
	{ "fcml_tf_parser_int_parse_test30", fcml_tf_parser_int_parse_test30 },
	{ "fcml_tf_parser_int_parse_test31", fcml_tf_parser_int_parse_test31 },
	{ "fcml_tf_parser_int_parse_test32", fcml_tf_parser_int_parse_test32 },
	{ "fcml_tf_parser_int_parse_test_symbols_1", fcml_tf_parser_int_parse_test_symbols_1 },
	{ "fcml_tf_parser_int_parse_test_symbols_2", fcml_tf_parser_int_parse_test_symbols_2 },
	{ "fcml_tf_parser_int_parse_test_symbols_3", fcml_tf_parser_int_parse_test_symbols_3 },
	{ "fcml_tf_parser_int_parse_test_symbols_4", fcml_tf_parser_int_parse_test_symbols_4 },
	{ "fcml_tf_parser_int_parse_test_symbols_5", fcml_tf_parser_int_parse_test_symbols_5 },
	{ "fcml_tf_parser_int_parse_test_symbols_6", fcml_tf_parser_int_parse_test_symbols_6 },
	{ "fcml_tf_parser_int_parse_test_symbols_7", fcml_tf_parser_int_parse_test_symbols_7 },
	{ "fcml_tf_parser_int_parse_test_symbols_8", fcml_tf_parser_int_parse_test_symbols_8 },
	{ "fcml_tf_parser_int_parse_test_symbols_9", fcml_tf_parser_int_parse_test_symbols_9 },
	{ "fcml_tf_parser_int_parse_test_symbols_10", fcml_tf_parser_int_parse_test_symbols_10 },
	{ "fcml_tf_parser_int_parse_test_symbols_11", fcml_tf_parser_int_parse_test_symbols_11 },
	{ "fcml_tf_parser_intel_parse_test_pseudo_operation_1", fcml_tf_parser_intel_parse_test_pseudo_operation_1 },
	{ "fcml_tf_parser_int_parse_test_decorator_bcast",
	        fcml_tf_parser_int_parse_test_decorator_bcast },
    { "fcml_tf_parser_int_parse_test_decorator_opmask",
            fcml_tf_parser_int_parse_test_decorator_opmask },
    { "fcml_tf_parser_int_parse_test_decorator_opmask_k",
            fcml_tf_parser_int_parse_test_decorator_opmask_k },
    { "fcml_tf_parser_int_parse_test_decorator_z",
            fcml_tf_parser_int_parse_test_decorator_z },
    { "fcml_tf_parser_int_parse_test_decorator_opmask_k_z_for_addressing",
            fcml_tf_parser_int_parse_test_decorator_opmask_k_z_for_addressing },
    { "fcml_tf_parser_int_parse_test_decorator_er",
            fcml_tf_parser_int_parse_test_decorator_er },
    { "fcml_tf_parser_int_parse_test_decorator_sae",
            fcml_tf_parser_int_parse_test_decorator_sae },
	FCML_STF_NULL_TEST
};

fcml_stf_test_suite fcml_si_intel_parser = {
	"suite-fcml-parser", fcml_tf_parser_suite_init, fcml_tf_parser_suite_cleanup, fcml_ti_parser
};