asmpp.cpp File Reference

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

Include dependency graph for asmpp.cpp:

Go to the source code of this file.

Classes
struct	IDENTIFIER

Macros
#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	INSTRUCTION

Enumerations
enum	TOKEN_TYPE {   Invalid = -1 , Eof , WhiteSpace , NewLine ,   Comment , DecNumber , HexNumber , String ,   BraceOpen , BraceClose , MemRefStart , MemRefEnd ,   Colon , Operator , StringDef , KW_include ,   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 , 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)
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)
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)
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< IDENTIFIER >	g_identifiers

Macro Definition Documentation

ANY_CHAR

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

Definition at line 109 of file asmpp.cpp.

FOLLOWED_BY

#define FOLLOWED_BY

(

x

)

x

Definition at line 107 of file asmpp.cpp.

INSTRUCTION

#define INSTRUCTION

Definition at line 115 of file asmpp.cpp.

NEWLINE

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

Definition at line 111 of file asmpp.cpp.

PROFILING_ENABLED

#define PROFILING_ENABLED   0

Definition at line 22 of file asmpp.cpp.

SEPARATOR

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

Definition at line 113 of file asmpp.cpp.

WHITESPACE

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

Definition at line 110 of file asmpp.cpp.

WS_OR_NL

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

Definition at line 112 of file asmpp.cpp.

Enumeration Type Documentation

IDTYPE

enum class IDTYPE

strong

Enumerator
Memory
Register
Label
Constant
Macro
Instruction
String
Unknown

Definition at line 301 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_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
Instruction
Reg8
Reg16
Reg32
Reg64
RegXmm
BYTE_PTR
WORD_PTR
DWORD_PTR
QWORD_PTR
XMMWORD_PTR
LabelName
Identifier

Definition at line 28 of file asmpp.cpp.

{
    Invalid = -1,
    Eof,
    WhiteSpace,
    NewLine,
    Comment,
    DecNumber,
    HexNumber,
    String,
 
    BraceOpen,
    BraceClose,
    MemRefStart,
    MemRefEnd,
    Colon,
    Operator,
    StringDef,
 
    KW_include,
    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,
    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 323 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 330 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 469 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 98 of file asmpp.cpp.

{
    return 0;
}

get_expected_token()

Token get_expected_token	(	Token &&	tok,
		TOKEN_TYPE	type
	)

Definition at line 362 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_ws()

Token get_ws

(

Token &&

tok

)

Definition at line 372 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_one_param(), translate_data_def(), and translate_identifier_construct().

get_ws_or_nl()

Token get_ws_or_nl

(

Token &&

tok

)

Definition at line 383 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 350 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 is_jmp_or_call(), and translate_expression().

is_jmp_or_call()

static bool is_jmp_or_call ( const Token &  tok )

static

Definition at line 639 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 336 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_string_in_list()

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

Definition at line 395 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[]
	)

Definition at line 1228 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;
}

translate()

void translate

(

TokenList &

tokens

)

Definition at line 1206 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 1031 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:
#ifdef TARGET_amd64
            printf(".code64");
#else
            printf(".code");
#endif
            printf(" .intel_syntax noprefix");
            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:
        case TOKEN_TYPE::KW_ifdef:
        case TOKEN_TYPE::KW_ifndef:
        case TOKEN_TYPE::KW_else:
        case TOKEN_TYPE::KW_endif:
            // TODO: handle parameter differences between "if" and ".if" etc.
            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_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::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 848 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 757 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;
 
        // 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++;
        }
    }
 
    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 486 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:
                if (iequals(tok.str(), "and"))
                {
                    printf("&");
                    index += 1;
                }
                else if (iequals(tok.str(), "or"))
                {
                    printf("|");
                    index += 1;
                }
                else if (iequals(tok.str(), "shl"))
                {
                    printf("<<");
                    index += 1;
                }
                else if (iequals(tok.str(), "not"))
                {
                    printf("!");
                    index += 1;
                }
                else
                {
                    throw "Invalid expression";
                }
                break;
 
            case TOKEN_TYPE::Operator:
                if (tok.str() == ",")
                {
                    return index;
                }
            case TOKEN_TYPE::WhiteSpace:
            case TOKEN_TYPE::BraceOpen:
            case TOKEN_TYPE::BraceClose:
            case TOKEN_TYPE::DecNumber:
            case TOKEN_TYPE::HexNumber:
            case TOKEN_TYPE::Identifier:
                index = translate_token(tokens, index, macro_params);
                break;
 
            default:
                index = translate_token(tokens, index, macro_params);
        }
    }
 
    return index;
}

Referenced by 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 938 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(".func %s\n", tok.str().c_str());
            printf("%s:", tok.str().c_str());
            index += 3;
 
            if ((tokens[index].type() == TOKEN_TYPE::WhiteSpace) &&
                (tokens[index + 1].type() == TOKEN_TYPE::KW_FRAME))
            {
#ifdef TARGET_amd64
                printf("\n.seh_proc %s\n", tok.str().c_str());
#else
                printf("\n.cfi_startproc\n");
#endif
                index += 2;
            }
            add_identifier(tok, IDTYPE::Label);
            break;
        }
 
        case TOKEN_TYPE::KW_ENDP:
        {
            printf(".seh_endproc\n.endfunc");
            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 659 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 584 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)
                {
                    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 703 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 718 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 1153 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 551 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 858 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_token()

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

Definition at line 409 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(), and translate_mem_ref().

Variable Documentation

g_identifiers

vector<IDENTIFIER> g_identifiers

Definition at line 319 of file asmpp.cpp.

Referenced by add_identifier(), and is_mem_id().

g_label_number

unsigned int g_label_number = 0

Definition at line 297 of file asmpp.cpp.

Referenced by translate_identifier_construct().

g_processing_jmp

bool g_processing_jmp = false

Definition at line 299 of file asmpp.cpp.

Referenced by translate_instruction(), and translate_instruction_param().

g_TokenList

vector<TOKEN_DEF> g_TokenList

Definition at line 225 of file asmpp.cpp.

Referenced by main().

search_time

time_t search_time

Definition at line 26 of file asmpp.cpp.

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