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.

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 }

Functions
int	fake_printf (const char *format,...)
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)
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
vector< string >	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

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_mem_id()

void add_mem_id

(

Token &

tok

)

Definition at line 302 of file asmpp.cpp.

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

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 442 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 335 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 345 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 356 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 323 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 translate_expression().

is_mem_id()

bool is_mem_id

(

Token &

tok

)

Definition at line 309 of file asmpp.cpp.

{
    for (auto id : g_identifiers)
    {
        if (id == tok.str())
        {
            return true;
        }
    }
 
    return false;
}

Referenced by translate_instruction_param().

is_string_in_list()

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

Definition at line 368 of file asmpp.cpp.

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

Referenced by translate_token().

main()

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

Definition at line 1164 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 1142 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 967 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 788 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 697 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 459 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 878 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());
        }
        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());
            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());
            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;
            }
            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 607 of file asmpp.cpp.

{
    // 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:
                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;
        }
    }
 
    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 557 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;
 
            case TOKEN_TYPE::Identifier:
                index = translate_token(tokens, index, macro_params);
                if (is_mem_id(tok))
                {
                    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 643 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 658 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 1089 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 524 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 798 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 382 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<string> g_identifiers

Definition at line 299 of file asmpp.cpp.

Referenced by add_mem_id(), 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_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().