asmpp.cpp File Reference

#include "tokenizer.hpp"
#include <cstdlib>
#include <cstdio>
#include <sstream>
#include <ctime>
#include <cstring>

Include dependency graph for asmpp.cpp:

Go to the source code of this file.

Classes
struct	IDENTIFIER

Macros
#define	_stricmp   strcasecmp
#define	PROFILING_ENABLED   0
#define	FOLLOWED_BY(x)   x
#define	ANY_CHAR   R"((?:.|\n))"
#define	WHITESPACE   R"((?:[ \t]++))"
#define	NEWLINE   R"([\n])"
#define	WS_OR_NL   R"((?:)" WHITESPACE "|" NEWLINE R"()+)"
#define	SEPARATOR   R"([\s,\=\+\-\*\/\:\~\[\]])"
#define	INST_PREFIX    "REX|REXW|REXR|REXX|REXB|LOCK|REP|REPE|REPZ|REPNE|REPNZ"
#define	INSTRUCTION

Enumerations
enum	TOKEN_TYPE {   Invalid = -1 , Eof , WhiteSpace , NewLine ,   Comment , DecNumber , HexNumber , String ,   BraceOpen , BraceClose , MemRefStart , MemRefEnd ,   Colon , Operator , StringDef , KW_include ,   KW_option , KW_model , KW_const , KW_code ,   KW_endprolog , KW_ALIGN , KW_EXTERN , KW_PUBLIC ,   KW_ENDM , KW_END , KW_if , KW_ifdef ,   KW_ifndef , KW_else , KW_endif , KW_allocstack ,   KW_savereg , KW_savexmm128 , KW_DB , KW_DW ,   KW_DD , KW_DQ , KW_EQU , KW_TEXTEQU ,   KW_MACRO , KW_PROC , KW_FRAME , KW_ENDP ,   KW_RECORD , KW_MASK , KW_ERRDEF , Filename ,   InstPrefix , Instruction , Reg8 , Reg16 ,   Reg32 , Reg64 , RegXmm , BYTE_PTR ,   WORD_PTR , DWORD_PTR , QWORD_PTR , XMMWORD_PTR ,   LabelName , Identifier }
enum class	IDTYPE {   Memory , Register , Label , Constant ,   Macro , Instruction , String , Unknown }

Functions
int	fake_printf (const char *format,...)
static void	add_identifier (Token &tok, IDTYPE type)
void	add_mem_id (Token &tok)
bool	is_mem_id (Token &tok)
bool	iequals (const string &a, const string &b)
const char *	get_expression_operator (const string &op)
Token	get_expected_token (Token &&tok, TOKEN_TYPE type)
Token	get_ws (Token &&tok)
Token	get_ws_or_nl (Token &&tok)
bool	is_string_in_list (vector< string > list, string str)
size_t	translate_token (TokenList &tokens, size_t index, const vector< string > &macro_params)
size_t	complete_line (TokenList &tokens, size_t index, const vector< string > &macro_params)
size_t	translate_expression (TokenList &tokens, size_t index, const vector< string > &macro_params)
size_t	translate_mem_ref (TokenList &tokens, size_t index, const vector< string > &macro_params)
static bool	is_number_token (const Token &tok)
static size_t	skip_whitespace (TokenList &tokens, size_t index)
static size_t	translate_rip_relative_offset (TokenList &tokens, size_t index, const vector< string > &macro_params)
size_t	translate_instruction_param (TokenList &tokens, size_t index, const vector< string > &macro_params)
static bool	is_jmp_or_call (const Token &tok)
size_t	translate_instruction (TokenList &tokens, size_t index, const vector< string > &macro_params)
size_t	translate_item (TokenList &tokens, size_t index, const vector< string > &macro_params)
size_t	translate_list (TokenList &tokens, size_t index, const vector< string > &macro_params)
size_t	translate_data_def (TokenList &tokens, size_t index, const vector< string > &macro_params)
size_t	translate_construct_one_param (string translated, TokenList &tokens, size_t index, const vector< string > &macro_params)
size_t	translate_record (TokenList &tokens, size_t index, const vector< string > &macro_params)
static bool	find_proc_frame (TokenList &tokens, size_t index, size_t &frameEndIndex)
size_t	translate_identifier_construct (TokenList &tokens, size_t index, const vector< string > &macro_params)
size_t	translate_construct (TokenList &tokens, size_t index, const vector< string > &macro_params)
size_t	translate_macro (TokenList &tokens, size_t index)
void	translate (TokenList &tokens)
int	main (int argc, char *argv[])

Variables
time_t	search_time
vector< TOKEN_DEF >	g_TokenList
unsigned int	g_label_number = 0
bool	g_processing_jmp = false
vector< bool >	g_proc_frame_stack
vector< IDENTIFIER >	g_identifiers
static bool	g_intel_syntax_emitted = false

Macro Definition Documentation

_stricmp

#define _stricmp   strcasecmp

Definition at line 24 of file asmpp.cpp.

ANY_CHAR

#define ANY_CHAR   R"((?:.|\n))"

Definition at line 117 of file asmpp.cpp.

FOLLOWED_BY

#define FOLLOWED_BY

(

x

)

x

Definition at line 115 of file asmpp.cpp.

INST_PREFIX

#define INST_PREFIX    "REX|REXW|REXR|REXX|REXB|LOCK|REP|REPE|REPZ|REPNE|REPNZ"

Definition at line 123 of file asmpp.cpp.

INSTRUCTION

#define INSTRUCTION

Definition at line 126 of file asmpp.cpp.

NEWLINE

#define NEWLINE   R"([\n])"

Definition at line 119 of file asmpp.cpp.

PROFILING_ENABLED

#define PROFILING_ENABLED   0

Definition at line 27 of file asmpp.cpp.

SEPARATOR

#define SEPARATOR   R"([\s,\=\+\-\*\/\:\~\[\]])"

Definition at line 121 of file asmpp.cpp.

WHITESPACE

#define WHITESPACE   R"((?:[ \t]++))"

Definition at line 118 of file asmpp.cpp.

WS_OR_NL

#define WS_OR_NL   R"((?:)" WHITESPACE "|" NEWLINE R"()+)"

Definition at line 120 of file asmpp.cpp.

Enumeration Type Documentation

IDTYPE

enum class IDTYPE

strong

Enumerator
Memory
Register
Label
Constant
Macro
Instruction
String
Unknown

Definition at line 317 of file asmpp.cpp.

{
    Memory,
    Register,
    Label,
    Constant,
    Macro,
    Instruction,
    String,
    Unknown
};

TOKEN_TYPE

enum TOKEN_TYPE

Enumerator
Invalid
Eof
WhiteSpace
NewLine
Comment
DecNumber
HexNumber
String
BraceOpen
BraceClose
MemRefStart
MemRefEnd
Colon
Operator
StringDef
KW_include
KW_option
KW_model
KW_const
KW_code
KW_endprolog
KW_ALIGN
KW_EXTERN
KW_PUBLIC
KW_ENDM
KW_END
KW_if
KW_ifdef
KW_ifndef
KW_else
KW_endif
KW_allocstack
KW_savereg
KW_savexmm128
KW_DB
KW_DW
KW_DD
KW_DQ
KW_EQU
KW_TEXTEQU
KW_MACRO
KW_PROC
KW_FRAME
KW_ENDP
KW_RECORD
KW_MASK
KW_ERRDEF
Filename
InstPrefix
Instruction
Reg8
Reg16
Reg32
Reg64
RegXmm
BYTE_PTR
WORD_PTR
DWORD_PTR
QWORD_PTR
XMMWORD_PTR
LabelName
Identifier

Definition at line 33 of file asmpp.cpp.

{
    Invalid = -1,
    Eof,
    WhiteSpace,
    NewLine,
    Comment,
    DecNumber,
    HexNumber,
    String,
 
    BraceOpen,
    BraceClose,
    MemRefStart,
    MemRefEnd,
    Colon,
    Operator,
    StringDef,
 
    KW_include,
    KW_option,
    KW_model,
    KW_const,
    KW_code,
    KW_endprolog,
    KW_ALIGN,
    KW_EXTERN,
    KW_PUBLIC,
    KW_ENDM,
    KW_END,
    KW_if,
    KW_ifdef,
    KW_ifndef,
    KW_else,
    KW_endif,
 
    KW_allocstack,
    KW_savereg,
    KW_savexmm128,
 
    KW_DB,
    KW_DW,
    KW_DD,
    KW_DQ,
    KW_EQU,
    KW_TEXTEQU,
    KW_MACRO,
    KW_PROC,
    KW_FRAME,
    KW_ENDP,
    KW_RECORD,
 
    KW_MASK,
    KW_ERRDEF,
 
    Filename,
    InstPrefix,
    Instruction,
    Reg8,
    Reg16,
    Reg32,
    Reg64,
    RegXmm,
    BYTE_PTR,
    WORD_PTR,
    DWORD_PTR,
    QWORD_PTR,
    XMMWORD_PTR,
 
    LabelName,
    Identifier
};

Function Documentation

add_identifier()

static void add_identifier ( Token &  tok, IDTYPE  type  )

static

Definition at line 339 of file asmpp.cpp.

{
    g_identifiers.push_back(IDENTIFIER{ tok.str(), type });
    //fprintf(stderr, "Added id: '%s'\n", tok.str().c_str());
}

Referenced by add_mem_id(), and translate_identifier_construct().

add_mem_id()

void add_mem_id

(

Token &

tok

)

Definition at line 346 of file asmpp.cpp.

{
    add_identifier(tok, IDTYPE::Memory);
}

Referenced by translate_construct(), and translate_identifier_construct().

complete_line()

size_t complete_line	(	TokenList &	tokens,
		size_t	index,
		const vector< string > &	macro_params
	)

Definition at line 506 of file asmpp.cpp.

{
    while (index < tokens.size())
    {
        Token tok = tokens[index];
        index = translate_token(tokens, index, macro_params);
        if ((tok.type() == TOKEN_TYPE::NewLine) ||
            (tok.type() == TOKEN_TYPE::Comment))
        {
            break;
        }
    }
 
    return index;
}

Referenced by translate_construct().

fake_printf()

int fake_printf	(	const char *	format,
			...
	)

Definition at line 106 of file asmpp.cpp.

{
    return 0;
}

find_proc_frame()

static bool find_proc_frame ( TokenList &  tokens, size_t  index, size_t &  frameEndIndex  )

static

Definition at line 1049 of file asmpp.cpp.

{
    while (index < tokens.size())
    {
        Token tok = tokens[index];
        if ((tok.type() == TOKEN_TYPE::NewLine) ||
            (tok.type() == TOKEN_TYPE::Comment))
        {
            return false;
        }
 
        if (tok.type() == TOKEN_TYPE::KW_FRAME)
        {
            frameEndIndex = index + 1;
            return true;
        }
 
        index++;
    }
 
    return false;
}

Referenced by translate_identifier_construct().

get_expected_token()

Token get_expected_token	(	Token &&	tok,
		TOKEN_TYPE	type
	)

Definition at line 399 of file asmpp.cpp.

{
    if (tok.type() != type)
    {
        throw "Not white space after identifier!\n";
    }
 
    return tok;
}

Referenced by translate_construct(), translate_identifier_construct(), and translate_record().

get_expression_operator()

const char * get_expression_operator

(

const string &

op

)

Definition at line 378 of file asmpp.cpp.

{
    const struct
    {
        const char* masm;
        const char* gas;
    } operators[] = {
        {"and", "&"}, {"or", "|"}, {"shl", "<<"}, {"shr", ">>"}, {"not", "~"},
        {"eq", "=="}, {"ne", "!="}, {"lt", "<"}, {"le", "<="}, {"gt", ">"}, {"ge", ">="},
    };
 
    for (const auto& entry : operators)
    {
        if (iequals(op, entry.masm))
            return entry.gas;
    }
 
    return nullptr;
}

Referenced by translate_expression().

get_ws()

Token get_ws

(

Token &&

tok

)

Definition at line 409 of file asmpp.cpp.

{
    int type = tok.type();
    if (type != TOKEN_TYPE::WhiteSpace)
    {
        throw "Not white space after identifier!\n";
    }
 
    return tok;
}

Referenced by translate_construct(), translate_construct_one_param(), translate_data_def(), and translate_identifier_construct().

get_ws_or_nl()

Token get_ws_or_nl

(

Token &&

tok

)

Definition at line 420 of file asmpp.cpp.

{
    int type = tok.type();
    if ((type != TOKEN_TYPE::WhiteSpace) &&
        (type != TOKEN_TYPE::NewLine))
    {
        throw "Not white space after identifier!\n";
    }
 
    return tok;
}

Referenced by translate_construct().

iequals()

bool iequals	(	const string &	a,
		const string &	b
	)

Definition at line 366 of file asmpp.cpp.

{
    size_t sz = a.size();
    if (b.size() != sz)
        return false;
    for (unsigned int i = 0; i < sz; ++i)
        if (tolower(a[i]) != tolower(b[i]))
            return false;
    return true;
}

Referenced by get_expression_operator(), and is_jmp_or_call().

is_jmp_or_call()

static bool is_jmp_or_call ( const Token &  tok )

static

Definition at line 728 of file asmpp.cpp.

{
    const char* inst_list[] = {
        "jmp", "call", "ja", "jae", "jb", "jbe", "jc", "jcxz", "je", "jecxz", "jg", "jge",
        "jl", "jle", "jna", "jnae", "jnb", "jnbe", "jnc", "jne", "jng", "jnge", "jnl", "jnle",
        "jno", "jnp", "jns", "jnz", "jo", "jp", "jpe", "jpo", "jrcxz", "js", "jz", "loop", "loope",
        "loopne", "loopnz", "loopz"
    };
 
    for (const char* inst : inst_list)
    {
        if (iequals(tok.str(), inst))
        {
            return true;
        }
    }
 
    return false;
}

Referenced by translate_instruction().

is_mem_id()

bool is_mem_id

(

Token &

tok

)

Definition at line 352 of file asmpp.cpp.

{
    for (IDENTIFIER& identifier : g_identifiers)
    {
        if (identifier.Name == tok.str())
        {
            return identifier.Type == IDTYPE::Memory;
        }
    }
 
    return true;
}

Referenced by translate_instruction_param().

is_number_token()

static bool is_number_token ( const Token &  tok )

static

Definition at line 625 of file asmpp.cpp.

{
    return ((tok.type() == TOKEN_TYPE::DecNumber) ||
            (tok.type() == TOKEN_TYPE::HexNumber));
}

Referenced by translate_rip_relative_offset().

is_string_in_list()

bool is_string_in_list	(	vector< string >	list,
		string	str
	)

Definition at line 432 of file asmpp.cpp.

{
    for (string &s : list)
    {
        if (s == str)
        {
            return true;
        }
    }
 
    return false;
}

Referenced by translate_instruction_param(), and translate_token().

main()

int main	(	int	argc,
		char *	argv[]
	)

hosttype.c Copyright (C) 2002 by Brian Palmer brian.nosp@m.p@sg.nosp@m.inet..nosp@m.com

Definition at line 1441 of file asmpp.cpp.

{
    if (argc < 2)
    {
        fprintf(stderr, "Invalid parameter!\n");
        return -1;
    }
 
#if PROFILING_ENABLED
    time_t start_time = time(NULL);
#endif
 
    try
    {
        // Open and read the input file
        string filename(argv[1]);
        ifstream file(filename);
        stringstream buffer;
        buffer << file.rdbuf();
        string text = buffer.str();
 
        // Create the tokenizer
        Tokenizer tokenizer(g_TokenList);
 
        // Get a token list
        TokenList toklist(tokenizer, text);
 
        // Now translate the tokens
        translate(toklist);
    }
    catch (const char* message)
    {
        fprintf(stderr, "Exception caught: '%s'\n", message);
        return -2;
    }
 
#if PROFILING_ENABLED
    time_t total_time = time(NULL) + 1 - start_time;
    fprintf(stderr, "total_time = %llu\n", total_time);
    fprintf(stderr, "search_time = %llu\n", search_time);
    fprintf(stderr, "search: %llu %%\n", search_time * 100 / total_time);
#endif
 
    return 0;
}

skip_whitespace()

static size_t skip_whitespace ( TokenList &  tokens, size_t  index  )

static

Definition at line 633 of file asmpp.cpp.

{
    if ((index < tokens.size()) &&
        (tokens[index].type() == TOKEN_TYPE::WhiteSpace))
    {
        index++;
    }
 
    return index;
}

translate()

void translate

(

TokenList &

tokens

)

Definition at line 1419 of file asmpp.cpp.

{
    size_t index = 0;
    size_t size = tokens.size();
    vector<string> empty_macro_params;
 
    while (index < size)
    {
        // Macros are special
        if ((tokens[index].type() == TOKEN_TYPE::Identifier) &&
            (tokens[index + 1].type() == TOKEN_TYPE::WhiteSpace) &&
            (tokens[index + 2].type() == TOKEN_TYPE::KW_MACRO))
        {
            index = translate_macro(tokens, index);
        }
        else
        {
            index = translate_construct(tokens, index, empty_macro_params);
        }
    }
}

Referenced by main().

translate_construct()

size_t translate_construct	(	TokenList &	tokens,
		size_t	index,
		const vector< string > &	macro_params
	)

Definition at line 1184 of file asmpp.cpp.

{
    Token tok = tokens[index];
 
    switch (tok.type())
    {
        case TOKEN_TYPE::WhiteSpace:
        case TOKEN_TYPE::NewLine:
        case TOKEN_TYPE::Comment:
            return translate_token(tokens, index, macro_params);
 
        case TOKEN_TYPE::Identifier:
            return translate_identifier_construct(tokens, index, macro_params);
 
        case TOKEN_TYPE::KW_ALIGN:
            index = translate_construct_one_param(".align", tokens, index, macro_params);
            break;
 
        case TOKEN_TYPE::KW_allocstack:
            index = translate_construct_one_param(".seh_stackalloc", tokens, index, macro_params);
            break;
 
        case TOKEN_TYPE::KW_code:
        {
            printf(".text\n");
#ifdef TARGET_amd64
            printf(".code64\n");
#else
            printf(".code32\n");
#endif
            if (!g_intel_syntax_emitted)
            {
                printf(".intel_syntax noprefix\n");
                g_intel_syntax_emitted = true;
            }
            index++;
            break;
        }
 
        case TOKEN_TYPE::KW_const:
            printf(".section .rdata");
            index++;
            break;
 
        case TOKEN_TYPE::KW_DB:
        case TOKEN_TYPE::KW_DW:
        case TOKEN_TYPE::KW_DD:
        case TOKEN_TYPE::KW_DQ:
            return translate_data_def(tokens, index, macro_params);
 
        case TOKEN_TYPE::KW_END:
            printf("// END\n");
            return tokens.size();
 
        case TOKEN_TYPE::KW_endprolog:
            printf(".seh_endprologue");
            index++;
            break;
 
        case TOKEN_TYPE::KW_EXTERN:
        {
            Token tok1 = get_ws_or_nl(tokens[index + 1]);
            Token tok2 = get_expected_token(tokens[index + 2], TOKEN_TYPE::Identifier);
            add_mem_id(tok2);
            printf("//");
            return complete_line(tokens, index, macro_params);
        }
 
        case TOKEN_TYPE::KW_if:
            printf(".");
            return translate_expression(tokens, index, macro_params);
 
        case TOKEN_TYPE::KW_ifdef:
        case TOKEN_TYPE::KW_ifndef:
        case TOKEN_TYPE::KW_else:
        case TOKEN_TYPE::KW_endif:
            printf(".");
            return complete_line(tokens, index, macro_params);
 
        case TOKEN_TYPE::KW_include:
        {
            // The next token should be white space
            Token tok1 = get_ws_or_nl(tokens[index + 1]);
            Token tok2 = get_expected_token(tokens[index + 2], TOKEN_TYPE::Filename);
            printf("#include \"%s.h\"", tok2.str().c_str());
            index += 3;
            break;
        }
 
        case TOKEN_TYPE::KW_option:
        {
            // The next token should be white space, followed by an identifier
            Token tok1 = get_ws(tokens[index + 1]);
            Token tok2 = get_expected_token(tokens[index + 2], TOKEN_TYPE::Identifier);
 
            // We just ignore this for now and just print it as a comment
            printf("//");
            return complete_line(tokens, index, macro_params);
        }
 
        case TOKEN_TYPE::KW_model:
        {
            // The next token should be white space, followed by an identifier
            Token tok1 = get_ws(tokens[index + 1]);
            Token tok2 = get_expected_token(tokens[index + 2], TOKEN_TYPE::Identifier);
 
            // Check if the model is valid (we only support flat)
            if (_stricmp(tok2.str().c_str(), "FLAT") != 0)
            {
                throw "Invalid model";
            }
 
            index += 3;
 
            // Skip optional white space
            if (tokens[index].type() == TOKEN_TYPE::WhiteSpace)
            {
                index++;
            }
 
            // Check if it is followed by a comma and another identifier
            if (tokens[index].type() == TOKEN_TYPE::Operator &&
                tokens[index].str() == ",")
            {
                // This could be "C" or "STDCALL", but we don't handle those yet
                throw "Invalid model";
            }
 
            return complete_line(tokens, index, macro_params);
        }
 
        case TOKEN_TYPE::KW_PUBLIC:
            index = translate_construct_one_param(".global", tokens, index, macro_params);
            break;
 
        case TOKEN_TYPE::KW_savereg:
            printf(".seh_savereg");
            return complete_line(tokens, index + 1, macro_params);
 
        case TOKEN_TYPE::KW_savexmm128:
            printf(".seh_savexmm");
            return complete_line(tokens, index + 1, macro_params);
 
        case TOKEN_TYPE::InstPrefix:
        {
            // The next token should be white space, followed by an instruction
            Token tok1 = get_ws(tokens[index + 1]);
            Token tok2 = get_expected_token(tokens[index + 2], TOKEN_TYPE::Instruction);
            printf("%s%s", tok.str().c_str(), tok1.str().c_str());
            index += 2;
            /* Fall through */
        }
        case TOKEN_TYPE::Instruction:
            index = translate_instruction(tokens, index, macro_params);
            break;
 
        case TOKEN_TYPE::KW_ERRDEF:
            printf("//");
            return complete_line(tokens, index, macro_params);
 
        default:
            throw "failed to translate construct";
    }
 
    // Skip optional white-space
    if (tokens[index].type() == TOKEN_TYPE::WhiteSpace)
    {
        index++;
    }
 
    // Line should end here!
    Token end = tokens[index];
    if ((end.type() != TOKEN_TYPE::Comment) &&
        (end.type() != TOKEN_TYPE::NewLine))
    {
        throw "unexpected tokens";
    }
 
    return index;
}

Referenced by translate(), and translate_macro().

translate_construct_one_param()

size_t translate_construct_one_param	(	string	translated,
		TokenList &	tokens,
		size_t	index,
		const vector< string > &	macro_params
	)

Definition at line 958 of file asmpp.cpp.

{
    // The next token should be white space
    Token tok1 = get_ws(tokens[index + 1]);
 
    printf("%s%s", translated.c_str(), tok1.str().c_str());
    return translate_expression(tokens, index + 2, macro_params);
}

Referenced by translate_construct().

translate_data_def()

size_t translate_data_def	(	TokenList &	tokens,
		size_t	index,
		const vector< string > &	macro_params
	)

Definition at line 846 of file asmpp.cpp.

{
    Token tok = tokens[index];
    Token tok1 = get_ws(tokens[index + 1]);
    string directive, need, have ="";
 
    switch (tok.type())
    {
        case TOKEN_TYPE::KW_DB:
            directive = ".byte";
            break;
 
        case TOKEN_TYPE::KW_DW:
            directive = ".short";
            break;
 
        case TOKEN_TYPE::KW_DD:
            directive = ".long";
            break;
 
        case TOKEN_TYPE::KW_DQ:
            directive = ".quad";
            break;
    }
 
    index += 2;
 
    while (index < tokens.size())
    {
        // Check if we need '.ascii' for ASCII strings
        if (tokens[index].str()[0] == '\"')
        {
            need = ".ascii";
        }
        else
        {
            need = directive;
        }
 
        // Output the directive we need (or a comma)
        if (have == "")
        {
            printf("%s ", need.c_str());
        }
        else if (have != need)
        {
            printf("\n%s ", need.c_str());
        }
        else
        {
            printf(", ");
        }
 
        have = need;
 
        // Check if this is an identifier
        if (tokens[index].type() == TOKEN_TYPE::Identifier)
        {
            // Assume this is a memory reference or a constant
            index = translate_token(tokens, index, macro_params);
        }
        else
        {
            // The item itself
            index = translate_item(tokens, index, macro_params);
        }
 
        // Optional white space
        if (tokens[index].type() == TOKEN_TYPE::WhiteSpace)
        {
            index = translate_token(tokens, index, macro_params);
        }
 
        // End of list?
        if ((tokens[index].type() == TOKEN_TYPE::Comment) ||
            (tokens[index].type() == TOKEN_TYPE::NewLine))
        {
            return index;
        }
 
        // We expect a comma here
        if ((tokens[index].type() != TOKEN_TYPE::Operator) ||
            (tokens[index].str() != ","))
        {
            throw "Unexpected end of list";
        }
 
        // Skip comma and optional white-space
        index++;
        if (tokens[index].type() == TOKEN_TYPE::WhiteSpace)
        {
            index++;
        }
 
        // Check if the list continues after a line break
        if ((tokens[index].type() == TOKEN_TYPE::NewLine) ||
            (tokens[index].type() == TOKEN_TYPE::Comment))
        {
            index++;
            if (tokens[index].type() == TOKEN_TYPE::WhiteSpace)
            {
                index++;
            }
        }
 
    }
 
    throw "Failed to translate list";
    return -1;
}

Referenced by translate_construct(), and translate_identifier_construct().

translate_expression()

size_t translate_expression	(	TokenList &	tokens,
		size_t	index,
		const vector< string > &	macro_params
	)

Definition at line 523 of file asmpp.cpp.

{
    while (index < tokens.size())
    {
        Token tok = tokens[index];
        switch (tok.type())
        {
            case TOKEN_TYPE::NewLine:
            case TOKEN_TYPE::Comment:
                return index;
 
            case TOKEN_TYPE::KW_MASK:
                printf("MASK_");
                index += 2;
                break;
 
            case TOKEN_TYPE::Instruction:
            {
                const char* op = get_expression_operator(tok.str());
                if (!op)
                {
                    throw "Invalid expression";
                }
                printf("%s", op);
                index += 1;
                break;
            }
 
            case TOKEN_TYPE::Operator:
                if (tok.str() == ",")
                {
                    return index;
                }
                index = translate_token(tokens, index, macro_params);
                break;
 
            case TOKEN_TYPE::Identifier:
            {
                const char* op = get_expression_operator(tok.str());
                if (op)
                {
                    printf("%s", op);
                    index += 1;
                }
                else
                {
                    index = translate_token(tokens, index, macro_params);
                }
                break;
            }
 
            case TOKEN_TYPE::WhiteSpace:
            case TOKEN_TYPE::BraceOpen:
            case TOKEN_TYPE::BraceClose:
            case TOKEN_TYPE::DecNumber:
            case TOKEN_TYPE::HexNumber:
                index = translate_token(tokens, index, macro_params);
                break;
 
            default:
                index = translate_token(tokens, index, macro_params);
        }
    }
 
    return index;
}

Referenced by translate_construct(), translate_construct_one_param(), translate_identifier_construct(), and translate_instruction_param().

translate_identifier_construct()

size_t translate_identifier_construct	(	TokenList &	tokens,
		size_t	index,
		const vector< string > &	macro_params
	)

Definition at line 1073 of file asmpp.cpp.

{
    Token tok = tokens[index];
    Token tok1 = tokens[index + 1];
 
    if (tok1.type() == TOKEN_TYPE::Colon)
    {
        if (tok.str() == "@@")
        {
            g_label_number++;
            printf("%u:", g_label_number);
        }
        else
        {
            printf("%s:", tok.str().c_str());
        }
        add_identifier(tok, IDTYPE::Label);
        return index + 2;
    }
 
    Token tok2 = tokens[index + 2];
 
    switch (tok2.type())
    {
        case TOKEN_TYPE::KW_MACRO:
            throw "Cannot have a nested macro!";
 
        case TOKEN_TYPE::KW_DB:
        case TOKEN_TYPE::KW_DW:
        case TOKEN_TYPE::KW_DD:
        case TOKEN_TYPE::KW_DQ:
            printf("%s:%s", tok.str().c_str(), tok1.str().c_str());
            add_mem_id(tok);
            return translate_data_def(tokens, index + 2, macro_params);
 
        case TOKEN_TYPE::KW_EQU:
            //printf("%s%s", tok.str().c_str(), tok1.str().c_str());
            printf("#define %s ", tok.str().c_str());
            add_identifier(tok, IDTYPE::Constant);
            return translate_expression(tokens, index + 3, macro_params);
 
        case TOKEN_TYPE::KW_TEXTEQU:
        {
            Token tok3 = get_ws(tokens[index + 3]);
            Token tok4 = get_expected_token(tokens[index + 4], TOKEN_TYPE::StringDef);
 
            string textdef = tok4.str();
            printf("#define %s %s", tok.str().c_str(), textdef.substr(1, textdef.size() - 2).c_str());
            add_identifier(tok, IDTYPE::Constant);
            return index + 5;
        }
 
        case TOKEN_TYPE::KW_PROC:
        {
            printf("%s:", tok.str().c_str());
            index += 3;
 
            size_t frameEndIndex;
            bool hasFrame = find_proc_frame(tokens, index, frameEndIndex);
            g_proc_frame_stack.push_back(hasFrame);
 
            if (hasFrame)
            {
#ifdef TARGET_amd64
                printf("\n.seh_proc %s\n", tok.str().c_str());
#else
                printf("\n.cfi_startproc\n");
#endif
                index = frameEndIndex;
            }
            add_identifier(tok, IDTYPE::Label);
            break;
        }
 
        case TOKEN_TYPE::KW_ENDP:
        {
            bool hasFrame = false;
            if (!g_proc_frame_stack.empty())
            {
                hasFrame = g_proc_frame_stack.back();
                g_proc_frame_stack.pop_back();
            }
 
            if (hasFrame)
            {
#ifdef TARGET_amd64
                printf(".seh_endproc");
#else
                printf(".cfi_endproc");
#endif
            }
            index += 3;
            break;
        }
 
        case TOKEN_TYPE::KW_RECORD:
            index = translate_record(tokens, index, macro_params);
            break;
 
        default:
            // We don't know what it is, assume it's a macro and treat it like an instruction
            index = translate_instruction(tokens, index, macro_params);
            break;
    }
 
    return index;
}

Referenced by translate_construct().

translate_instruction()

size_t translate_instruction	(	TokenList &	tokens,
		size_t	index,
		const vector< string > &	macro_params
	)

Definition at line 748 of file asmpp.cpp.

{
    // Check for jump/call instructions
    if (is_jmp_or_call(tokens[index]))
    {
        g_processing_jmp = true;
    }
 
    // Translate the instruction itself
    index = translate_token(tokens, index, macro_params);
 
    // Handle instruction parameters
    while (index < tokens.size())
    {
        // Optional whitespace
        if (tokens[index].type() == TOKEN_TYPE::WhiteSpace)
        {
            index = translate_token(tokens, index, macro_params);
        }
 
        // Check for parameters
        Token tok = tokens[index];
        switch (tok.type())
        {
            case TOKEN_TYPE::Comment:
            case TOKEN_TYPE::NewLine:
                g_processing_jmp = false;
                return index;
 
            case TOKEN_TYPE::WhiteSpace:
            case TOKEN_TYPE::Operator:
                index = translate_token(tokens, index, macro_params);
                break;
 
            default:
                index = translate_instruction_param(tokens, index, macro_params);
                break;
        }
    }
 
    g_processing_jmp = false;
    return index;
}

Referenced by translate_construct(), and translate_identifier_construct().

translate_instruction_param()

size_t translate_instruction_param	(	TokenList &	tokens,
		size_t	index,
		const vector< string > &	macro_params
	)

Definition at line 672 of file asmpp.cpp.

{
    switch (tokens[index].type())
    {
        case TOKEN_TYPE::BYTE_PTR:
        case TOKEN_TYPE::WORD_PTR:
        case TOKEN_TYPE::DWORD_PTR:
        case TOKEN_TYPE::QWORD_PTR:
        case TOKEN_TYPE::XMMWORD_PTR:
            index = translate_token(tokens, index, macro_params);
 
            // Optional whitespace
            if (tokens[index].type() == TOKEN_TYPE::WhiteSpace)
            {
                index = translate_token(tokens, index, macro_params);
            }
    }
 
    while (index < tokens.size())
    {
        Token tok = tokens[index];
        switch (tok.type())
        {
            case TOKEN_TYPE::MemRefStart:
                return translate_mem_ref(tokens, index, macro_params);
 
            case TOKEN_TYPE::NewLine:
            case TOKEN_TYPE::Comment:
                return index;
 
            case TOKEN_TYPE::Operator:
                if (tok.str() == ",")
                    return index;
                return translate_token(tokens, index, macro_params);
 
            case TOKEN_TYPE::Identifier:
                index = translate_token(tokens, index, macro_params);
                if (is_mem_id(tok) &&
                    !is_string_in_list(macro_params, tok.str()) &&
                    !g_processing_jmp)
                {
                    index = translate_rip_relative_offset(tokens, index, macro_params);
                    printf("[rip]");
                }
                break;
 
            default:
                index = translate_expression(tokens, index, macro_params);
        }
    }
 
    return index;
}

Referenced by translate_instruction().

translate_item()

size_t translate_item	(	TokenList &	tokens,
		size_t	index,
		const vector< string > &	macro_params
	)

Definition at line 792 of file asmpp.cpp.

{
    switch (tokens[index].type())
    {
        case TOKEN_TYPE::DecNumber:
        case TOKEN_TYPE::HexNumber:
        case TOKEN_TYPE::String:
        case TOKEN_TYPE::WhiteSpace:
            return translate_token(tokens, index, macro_params);
    }
 
    throw "Failed to translate item";
    return -1;
}

Referenced by translate_data_def(), and translate_list().

translate_list()

size_t translate_list	(	TokenList &	tokens,
		size_t	index,
		const vector< string > &	macro_params
	)

Definition at line 807 of file asmpp.cpp.

{
    while (index < tokens.size())
    {
        // The item itself
        index = translate_item(tokens, index, macro_params);
 
        // Optional white space
        if (tokens[index].type() == TOKEN_TYPE::WhiteSpace)
        {
            index = translate_token(tokens, index, macro_params);
        }
 
        // End of list?
        if ((tokens[index].type() == TOKEN_TYPE::Comment) ||
            (tokens[index].type() == TOKEN_TYPE::NewLine))
        {
            return index;
        }
 
        // We expect a comma here
        if ((tokens[index].type() != TOKEN_TYPE::Operator) ||
            (tokens[index].str() != ","))
        {
            throw "Unexpected end of list";
        }
 
        index = translate_token(tokens, index, macro_params);
        if (tokens[index].type() == TOKEN_TYPE::WhiteSpace)
        {
            index = translate_token(tokens, index, macro_params);
        }
    }
 
    throw "Failed to translate list";
    return -1;
}

translate_macro()

size_t translate_macro	(	TokenList &	tokens,
		size_t	index
	)

Definition at line 1366 of file asmpp.cpp.

{
    vector<string> macro_params;
 
    printf(".macro %s", tokens[index].str().c_str());
 
    // Parse marameters
    index += 3;
    while (index < tokens.size())
    {
        Token tok = tokens[index];
        switch (tok.type())
        {
            case TOKEN_TYPE::NewLine:
            case TOKEN_TYPE::Comment:
                index = translate_token(tokens, index, macro_params);
                break;
 
            case TOKEN_TYPE::Identifier:
                macro_params.push_back(tok.str());
                printf("%s", tok.str().c_str());
                index++;
                continue;
 
            case TOKEN_TYPE::WhiteSpace:
            case TOKEN_TYPE::Operator:
                index = translate_token(tokens, index, macro_params);
                continue;
        }
 
        break;
    }
 
    // Parse content
    while (index < tokens.size())
    {
        Token tok = tokens[index];
        switch (tok.type())
        {
            case TOKEN_TYPE::KW_ENDM:
                printf(".endm");
                return index + 1;
 
            default:
                index = translate_construct(tokens, index, macro_params);
        }
    }
 
    throw "Failed to translate macro";
    return -1;
}

Referenced by translate().

translate_mem_ref()

size_t translate_mem_ref	(	TokenList &	tokens,
		size_t	index,
		const vector< string > &	macro_params
	)

Definition at line 590 of file asmpp.cpp.

{
    unsigned int offset = 0;
 
    Token tok = tokens[index];
 
    if ((tok.type() == TOKEN_TYPE::DecNumber) ||
        (tok.type() == TOKEN_TYPE::HexNumber))
    {
        offset = stoi(tok.str(), nullptr, 0);
        index += 2;
    }
 
    index = translate_token(tokens, index, macro_params);
 
    while (index < tokens.size())
    {
        Token tok = tokens[index];
        index = translate_token(tokens, index, macro_params);
        if (tok.type() == TOKEN_TYPE::MemRefEnd)
        {
            if (offset != 0)
            {
                printf(" + %u", offset);
            }
            return index;
        }
    }
 
    throw "Failed to translate memory ref";
    return index;
}

Referenced by translate_instruction_param().

translate_record()

size_t translate_record	(	TokenList &	tokens,
		size_t	index,
		const vector< string > &	macro_params
	)

Definition at line 968 of file asmpp.cpp.

{
    unsigned int bits, bitpos = 0;
    unsigned long long oldmask = 0, mask = 0;
 
    Token tok_name = get_expected_token(tokens[index], TOKEN_TYPE::Identifier);
    index += 4;
    while (index < tokens.size())
    {
        Token tok_member = get_expected_token(tokens[index++], TOKEN_TYPE::Identifier);
 
        if (tokens[index].type() == TOKEN_TYPE::WhiteSpace)
        {
            index++;
        }
 
        if (tokens[index++].str() != ":")
        {
            throw "Unexpected token";
        }
 
        if (tokens[index].type() == TOKEN_TYPE::WhiteSpace)
        {
            index++;
        }
 
        Token tok_bits = tokens[index++];
        if ((tok_bits.type() != TOKEN_TYPE::DecNumber) &&
            (tok_bits.type() != TOKEN_TYPE::HexNumber))
        {
            throw "Unexpected token";
        }
 
        bits = stoi(tok_bits.str(), nullptr, 0);
 
        printf("%s = %u\n", tok_member.str().c_str(), bitpos);
 
        oldmask = (1ULL << bitpos) - 1;
        bitpos += bits;
        mask = (1ULL << bitpos) - 1 - oldmask;
        printf("MASK_%s = 0x%llx\n", tok_member.str().c_str(), mask);
 
        if (tokens[index].type() == TOKEN_TYPE::WhiteSpace)
        {
            index++;
        }
 
        if ((tokens[index].type() == TOKEN_TYPE::NewLine) ||
            (tokens[index].type() == TOKEN_TYPE::Comment))
        {
            break;
        }
 
        if (tokens[index].str() != ",")
        {
            throw "unexpected token";
        }
 
        index++;
        if (tokens[index].type() == TOKEN_TYPE::WhiteSpace)
        {
            index++;
        }
 
        if ((tokens[index].type() == TOKEN_TYPE::NewLine) ||
            (tokens[index].type() == TOKEN_TYPE::Comment))
        {
            index++;
        }
 
        if (tokens[index].type() == TOKEN_TYPE::WhiteSpace)
        {
            index++;
        }
    }
 
    return index;
}

Referenced by translate_identifier_construct().

translate_rip_relative_offset()

static size_t translate_rip_relative_offset ( TokenList &  tokens, size_t  index, const vector< string > &  macro_params  )

static

Definition at line 646 of file asmpp.cpp.

{
    size_t operatorIndex = skip_whitespace(tokens, index);
    if ((operatorIndex == tokens.size()) ||
        (tokens[operatorIndex].type() != TOKEN_TYPE::Operator) ||
        ((tokens[operatorIndex].str() != "+") &&
         (tokens[operatorIndex].str() != "-")))
    {
        return index;
    }
 
    size_t numberIndex = skip_whitespace(tokens, operatorIndex + 1);
    if ((numberIndex == tokens.size()) ||
        !is_number_token(tokens[numberIndex]))
    {
        return index;
    }
 
    while (index <= numberIndex)
    {
        index = translate_token(tokens, index, macro_params);
    }
 
    return index;
}

Referenced by translate_instruction_param().

translate_token()

size_t translate_token	(	TokenList &	tokens,
		size_t	index,
		const vector< string > &	macro_params
	)

Definition at line 446 of file asmpp.cpp.

{
    Token tok = tokens[index];
    switch (tok.type())
    {
        case TOKEN_TYPE::Comment:
            printf("//%s", tok.str().c_str() + 1);
            break;
 
        case TOKEN_TYPE::DecNumber:
        {
            unsigned long long num = stoull(tok.str(), nullptr, 10);
            printf("%llu", num);
            break;
        }
 
        case TOKEN_TYPE::HexNumber:
        {
            string number = tok.str();
            printf("0x%s", number.substr(0, number.size() - 1).c_str());
            break;
        }
 
        case TOKEN_TYPE::Identifier:
            if (is_string_in_list(macro_params, tok.str()))
            {
                printf("\\");
            }
            printf("%s", tok.str().c_str());
            break;
 
        // We migt want to improve these
        case TOKEN_TYPE::BYTE_PTR:
        case TOKEN_TYPE::WORD_PTR:
        case TOKEN_TYPE::DWORD_PTR:
        case TOKEN_TYPE::QWORD_PTR:
        case TOKEN_TYPE::XMMWORD_PTR:
 
        // Check these. valid only in instructions?
        case TOKEN_TYPE::Reg8:
        case TOKEN_TYPE::Reg16:
        case TOKEN_TYPE::Reg32:
        case TOKEN_TYPE::Reg64:
        case TOKEN_TYPE::RegXmm:
        case TOKEN_TYPE::Instruction:
 
        case TOKEN_TYPE::WhiteSpace:
        case TOKEN_TYPE::NewLine:
        case TOKEN_TYPE::Operator:
            printf("%s", tok.str().c_str());
            break;
 
        default:
            printf("%s", tok.str().c_str());
            break;
    }
 
    return index + 1;
}

Referenced by complete_line(), translate_construct(), translate_data_def(), translate_expression(), translate_instruction(), translate_instruction_param(), translate_item(), translate_list(), translate_macro(), translate_mem_ref(), and translate_rip_relative_offset().

Variable Documentation

g_identifiers

vector<IDENTIFIER> g_identifiers

Definition at line 335 of file asmpp.cpp.

Referenced by add_identifier(), and is_mem_id().

g_intel_syntax_emitted

bool g_intel_syntax_emitted = false

static

Definition at line 1181 of file asmpp.cpp.

Referenced by translate_construct().

g_label_number

unsigned int g_label_number = 0

Definition at line 311 of file asmpp.cpp.

Referenced by translate_identifier_construct().

g_proc_frame_stack

vector<bool> g_proc_frame_stack

Definition at line 315 of file asmpp.cpp.

Referenced by translate_identifier_construct().

g_processing_jmp

bool g_processing_jmp = false

Definition at line 313 of file asmpp.cpp.

Referenced by translate_instruction(), and translate_instruction_param().

g_TokenList

vector<TOKEN_DEF> g_TokenList

Definition at line 236 of file asmpp.cpp.

Referenced by main().

search_time

time_t search_time

Definition at line 31 of file asmpp.cpp.

Referenced by main(), and Tokenizer::match().