name stringlengths 1 4.98k | code stringlengths 61 2.07M | asm stringlengths 57 12.9M | file stringlengths 18 192 |
|---|---|---|---|
cedit::Cedit::event_delete() | void Cedit::event_delete()
{
// Last character and last row
if(this->currentIndex == this->contentIt->length() && this->content.end() == std::next(this->contentIt))
{
return;
}
// Line end: copy next line to this line, delete next line
else if(this->currentIndex == this->contentIt->length()-1 && this->contentIt... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
movq 0x50(%rdi), %rax
movq %rax, -0xd0(%rbp)
addq $0x18, %rdi
callq 0x92f0
movq %rax, %rdi
callq 0x4640
movq -0xd0(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al... | JD297[P]cedit/src/cedit.cpp |
cedit::Cedit::event_left() | void Cedit::event_left()
{
this->refreshDisplay = false;
if(this->currentIndex > 0)
{
this->currentIndex--;
this->savedIndex = this->currentIndex;
}
else if(this->currentIndex == 0 && this->contentIt != this->content.begin())
{
this->scrollup();
this->contentIt = std::prev(this->contentIt);
this->curr... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movb $0x0, 0x6c(%rax)
cmpq $0x0, 0x50(%rax)
jbe 0x650c
movq -0x28(%rbp), %rax
movq 0x50(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x50(%rax)
movq 0x50(%rax), %rcx
movq %rcx, 0x58(%rax)
jmp 0x65aa
movq -0x28(%rbp... | JD297[P]cedit/src/cedit.cpp |
cedit::Cedit::event_right() | void Cedit::event_right()
{
this->refreshDisplay = false;
const auto itEnd = std::prev(this->content.end());
if(this->currentIndex < this->contentIt->length()-1 ||
(this->currentIndex < this->contentIt->length() && contentIt == itEnd)
)
{
if(currentIndex == this->contentIt->length() && this->contentIt->back... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movb $0x0, 0x6c(%rdi)
callq 0x92c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x9280
movq -0x38(%rbp), %rdi
movq %rax, -0x10(%rbp)
movq 0x50(%rdi), %rax
movq %rax, -0x30(%rbp)
addq $0x... | JD297[P]cedit/src/cedit.cpp |
cedit::Cedit::event_up() | void Cedit::event_up()
{
this->refreshDisplay = false;
if(this->contentIt != this->content.begin())
{
this->scrollup();
this->contentIt = std::prev(this->contentIt);
if(this->contentIt->length()-1 < this->savedIndex)
{
this->currentIndex = this->contentIt->length()-1;
}
else
{
this->currentInde... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movb $0x0, 0x6c(%rdi)
movq %rdi, %rax
addq $0x18, %rax
movq %rax, -0x28(%rbp)
callq 0x91c0
movq -0x28(%rbp), %rdi
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x9310
testb $0x1, %al
jne 0x6762
jmp 0x67e... | JD297[P]cedit/src/cedit.cpp |
cedit::Cedit::event_down() | void Cedit::event_down()
{
this->refreshDisplay = false;
if(this->contentIt == std::prev(this->content.end()))
{
return;
}
this->contentIt = std::next(this->contentIt);
this->scrolldown();
if(this->contentIt->length() <= this->savedIndex && this->contentIt == std::prev(this->content.end()))
{
this->curre... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movb $0x0, 0x6c(%rdi)
movq %rdi, %rax
addq $0x18, %rax
movq %rax, -0x40(%rbp)
callq 0x92c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x9280
movq -0x40(%rbp), %rdi
movq %rax, -0x10(%rb... | JD297[P]cedit/src/cedit.cpp |
cedit::Cedit::event_pagedown() | void Cedit::event_pagedown()
{
if(this->entryLine > this->content.size()-this->height)
{
this->contentIt = std::prev(this->content.end());
}
else
{
this->entryLine += this->height;
// Compares long int with size_t aka unsigned long int, type cast is required
if(std::distance(this->contentIt, this->content... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movq 0x60(%rdi), %rax
movq %rax, -0x50(%rbp)
callq 0x9590
movq -0x58(%rbp), %rdx
movq %rax, %rcx
movq -0x50(%rbp), %rax
subq 0x100(%rdx), %rcx
cmpq %rcx, %rax
jbe 0x69cb
movq -0x58(%rbp), %rdi
callq 0x92c0
mov... | JD297[P]cedit/src/cedit.cpp |
cedit::Cedit::event_pageup() | void Cedit::event_pageup()
{
if(this->entryLine < this->height)
{
this->entryLine = 0;
this->contentIt = this->content.begin();
}
else
{
this->entryLine -= this->height;
this->contentIt = std::prev(this->contentIt, this->height);
}
this->currentIndex = 0;
this->savedIndex = 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq 0x60(%rcx), %rax
cmpq 0x100(%rcx), %rax
jae 0x6ad7
movq -0x28(%rbp), %rdi
movq $0x0, 0x60(%rdi)
callq 0x91c0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx,... | JD297[P]cedit/src/cedit.cpp |
cedit::Cedit::event_end() | void Cedit::event_end()
{
if(contentIt != std::prev(this->content.end()))
{
this->currentIndex = this->contentIt->length()-1;
this->savedIndex = this->contentIt->length()-1;
}
else
{
this->currentIndex = this->contentIt->length();
this->savedIndex = this->contentIt->length();
}
this->refreshDisplay = fa... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
callq 0x92c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x9280
movq -0x20(%rbp), %rdi
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %... | JD297[P]cedit/src/cedit.cpp |
cedit::Cedit::event_goto() | void Cedit::event_goto()
{
if(!this->menu.type("Springe zu [Zeile Spalte]: ")) {
this->refreshDisplay = false;
return;
}
std::size_t row;
std::size_t column = 1;
std::stringstream converter(this->menu.content);
converter >> row >> column;
row--;
column--;
if(this->content.size() > row)
{
this->content... | pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp # imm = 0x1F0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x1c8(%rbp)
addq $0xb0, %rdi
leaq 0x748c(%rip), %rsi # 0xe124
leaq 0x75da(%rip), %rdx # 0xe279
callq 0xd910
testb $0x1, %al
jne 0x6cb8
movq -0x1c8(%rbp), %rax
movb $0x0, 0x6c(%rax)
jmp... | JD297[P]cedit/src/cedit.cpp |
cedit::Cedit::event_change_tab() | void Cedit::event_change_tab()
{
if(this->session.size() == 0)
{
return;
}
short int key = wgetch(this->menu.window);
auto mapIt = this->session.find(this->filename);
if(key == KEY_LEFT)
{
if(mapIt == this->session.begin())
{
mapIt = std::prev(this->session.end());
}
else
{
mapIt = std::prev... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
addq $0x20, %rdi
callq 0x9e80
cmpq $0x0, %rax
jne 0x6e6b
jmp 0x6fef
movq -0x78(%rbp), %rax
movq 0xb0(%rax), %rdi
callq 0x41d0
movq -0x78(%rbp), %rsi
movw %ax, -0xa(%rbp)
movq %rsi, %rdi
addq $0x20, %rdi
addq $... | JD297[P]cedit/src/cedit.cpp |
cedit::Cedit::event_write() | void Cedit::event_write()
{
if( (this->key >= 32 && this->key <= 126) || this->key == 10 || this->key == 9)
{
this->contentIt->insert(this->currentIndex, 1, (char)key);
}
// Return key
if(this->key == 10)
{
if(this->currentIndex < this->contentIt->length()-1)
{
// Insert new line with content after curs... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xd8(%rbp)
cmpl $0x20, 0x68(%rax)
jl 0x702d
movq -0xd8(%rbp), %rax
cmpl $0x7e, 0x68(%rax)
jle 0x7047
movq -0xd8(%rbp), %rax
cmpl $0xa, 0x68(%rax)
je 0x7047
movq -0xd8(%rbp), %rax
cmpl $0x9, 0x68... | JD297[P]cedit/src/cedit.cpp |
cedit::Cedit::event_load(char const*) | void Cedit::event_load(const char* filename)
{
if(!this->filename.empty())
{
this->session[this->filename] = {
this->content,
std::distance(this->content.begin(), this->contentIt),
this->currentIndex,
this->savedIndex,
this->entryLine,
this->showLineNumbers
};
}
this->reset();
std::string m... | pushq %rbp
movq %rsp, %rbp
subq $0x850, %rsp # imm = 0x850
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x6e0(%rbp)
addq $0x70, %rdi
callq 0x46c0
testb $0x1, %al
jne 0x74af
movq -0x6e0(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x6f8(%rbp)
callq 0x95c0
movq -0x6e0(%rbp),... | JD297[P]cedit/src/cedit.cpp |
cedit::Cedit::display_header() | void Cedit::display_header()
{
const std::string filename = this->filename.empty() ? NEW_FILE : this->filename;
if(this->refreshHeader)
{
wclear(this->wheader);
wbkgd(this->wheader, A_REVERSE);
mvwprintw(this->wheader, 0, 2, VERSION);
mvwprintw(this->wheader, 0, this->width / 2 - filename.size() / 2, filena... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x70, %rdi
callq 0x46c0
movb $0x0, -0x2a(%rbp)
testb $0x1, %al
jne 0x8757
jmp 0x8780
leaq -0x29(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x4710
movq -0x50(%rbp), %rdx
movb $0x1, -0x2a(%rbp)
leaq 0x58da(%... | JD297[P]cedit/src/cedit.cpp |
cedit::Cedit::display_content() | void Cedit::display_content()
{
wclear(this->wcontent);
const auto itBegin = this->displayFirstIt();
const auto itEnd = this->displayLastIt();
for(auto it = itBegin; it != itEnd; it++)
{
this->display_linenumbers(it);
if(this->contentIt == it)
{
getyx(this->wcontent, this->cursorY, this->cursorXReset);... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq 0xa8(%rax), %rdi
callq 0x4410
movq -0xa0(%rbp), %rdi
callq 0x8600
movq -0xa0(%rbp), %rdi
movq %rax, -0x10(%rbp)
callq 0x8640
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %r... | JD297[P]cedit/src/cedit.cpp |
cedit::Cedit::display_linenumbers(std::_List_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>) | void Cedit::display_linenumbers(std::list<std::string>::iterator it)
{
if(this->showLineNumbers)
{
const auto itBegin = this->displayFirstIt();
std::stringstream ss;
ss << " " << std::setw(3) << std::distance(itBegin, it) + this->entryLine + 1;
wattron(this->wcontent, A_REVERSE);
wprintw(this->wcontent, ... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1e8(%rbp)
testb $0x1, 0x90(%rax)
je 0x8fc0
movq -0x1e8(%rbp), %rdi
callq 0x8600
movq %rax, -0x18(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x4330
leaq -0x190(%rbp), %rdi
leaq... | JD297[P]cedit/src/cedit.cpp |
NCURSES_INIT() | void NCURSES_INIT()
{
initscr();
noecho();
cbreak();
raw();
keypad(stdscr, true);
set_escdelay(100);
set_tabsize(4);
short bg = 0;
short fg = 0;
use_default_colors();
start_color();
// get default colors
pair_content(0, &bg, &fg);
// set colors with default background
for(int i = 0; i < 8; i++)
{
... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x4630
callq 0x4500
callq 0x4180
callq 0x4190
movq 0x5d8d(%rip), %rax # 0x12fd0
movq (%rax), %rdi
movl $0x1, %esi
callq 0x41e0
movl $0x64, %edi
callq 0x4490
movl $0x4, %edi
callq 0x44e0
movw $0x0, -0x2(%rbp)
movw $0x0, -0x4(%rbp)
callq 0x42f0
callq 0x40f0
xorl %edi... | JD297[P]cedit/src/main.cpp |
cedit::arguments(int, char const**, cedit::Cedit*) | void arguments(const int argc, const char** argv, cedit::Cedit* cedit)
{
if(argc >= 3)
{
endwin();
std::cerr << "cedit: invalid argument -- \'" << argv[2] << "\'\n";
std::cerr << "usage: cedit [path/to/file]\n";
exit(1);
}
else if(argc == 2) {
cedit->event_load(argv[1]);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x3, -0x4(%rbp)
jl 0xd32d
callq 0x4540
movq 0x5d0b(%rip), %rdi # 0x12ff0
leaq 0xf6e(%rip), %rsi # 0xe25a
callq 0x43f0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x43f0... | JD297[P]cedit/src/main.cpp |
main | int main(const int argc, const char** argv)
{
NCURSES_INIT();
cedit::Cedit editor;
cedit::arguments(argc, argv, &editor);
editor.run();
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0xd220
leaq -0x128(%rbp), %rdi
movq %rdi, -0x140(%rbp)
callq 0x4930
movq -0x140(%rbp), %rdx
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0xd2c0
jmp 0xd396
leaq -0x128(%rbp... | JD297[P]cedit/src/main.cpp |
cedit::Menu::display(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, short) | void Menu::display(std::string message, short color) {
wclear(this->window);
message = "[ " + message + " ]";
wattron(this->window, COLOR_PAIR(color));
wattron(this->window, A_REVERSE);
mvwprintw(this->window, 0, (size_t)(getmaxx(stdscr) / 2 - message.length() / 2), message.c_str());
wattroff(this->window, A_... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x78(%rbp)
movw %dx, %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq (%rax), %rdi
callq 0x4410
movq -0x78(%rbp), %rdx
leaq 0xd6e(%rip), %rsi # 0xe297
leaq -0x58(%rbp), %rdi
movq %rdi, -... | JD297[P]cedit/src/menu.cpp |
cedit::Menu::display_type(char const*) | void Menu::display_type(const char* text) {
wbkgd(this->window, A_REVERSE);
wclear(this->window);
wprintw(this->window, text);
mvwprintw(this->window, 0, std::strlen(text), "%s", this->content.c_str());
wmove(this->window, 0, std::strlen(text) + this->currentIndex);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq (%rax), %rdi
movl $0x40000, %esi # imm = 0x40000
callq 0x46d0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x4410
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp... | JD297[P]cedit/src/menu.cpp |
cedit::Menu::event_backspace() | void Menu::event_backspace() {
if(this->currentIndex <= 0) {
return;
}
this->content.erase(this->currentIndex - 1, 1);
this->currentIndex--;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x38(%rax)
ja 0xd83d
jmp 0xd86a
movq -0x10(%rbp), %rax
movq %rax, %rdi
addq $0x18, %rdi
movq 0x38(%rax), %rsi
subq $0x1, %rsi
movl $0x1, %edx
callq 0x4100
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rc... | JD297[P]cedit/src/menu.cpp |
cedit::Menu::type(char const*, char const*) | [[nodiscard]] bool Menu::type(const char* text, const char* content) {
this->content = content;
this->currentIndex = 0;
while(true) {
this->display_type(text);
this->key = wgetch(this->window);
switch(this->key) {
case 10:
wbkgd(this->window, A_NORMAL)... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x20(%rbp), %rsi
addq $0x18, %rdi
callq 0x45c0
movq -0x28(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xd6a0
movq... | JD297[P]cedit/src/menu.cpp |
cedit::Window::Window(unsigned long, unsigned long, unsigned long, unsigned long) | Window::Window(size_t sizeX, std::size_t sizeY, std::size_t posX, std::size_t posY) {
this->width = sizeX;
this->height = sizeY;
this->window = newwin(this->height, this->width, posY, posX);
keypad(this->window, true);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rcx
movl %e... | JD297[P]cedit/src/window.cpp |
yyensure_buffer_stack() | static void yyensure_buffer_stack (void)
{
yy_size_t num_to_alloc;
if (!(yy_buffer_stack)) {
/* First allocation is just for 2 elements, since we don't know if this
* scanner will even need a stack. We use 2 instead of 1 to avoid an
* immediate realloc on the next call.
*/
num_to_alloc = ... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x36260(%rip) # 0x41380
jne 0xb185
movq $0x1, -0x8(%rbp)
movq -0x8(%rbp), %rdi
shlq $0x3, %rdi
callq 0xbda0
movq %rax, 0x36242(%rip) # 0x41380
cmpq $0x0, 0x3623a(%rip) # 0x41380
jne 0xb154
leaq 0x26f68(%rip), %rdi # 0x320b7
callq 0xbae0
movq 0x36225... | Bartor[P]kompilator/front/compiler.l.c |
yy_create_buffer(_IO_FILE*, int) | YY_BUFFER_STATE yy_create_buffer (FILE * file, int size )
{
YY_BUFFER_STATE b;
b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
if ( ! b )
YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
b->yy_buf_size = size;
/* yy_ch_buf has to be 2 characters longer than the size g... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x40, %edi
callq 0xbda0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xb250
leaq 0x26d20(%rip), %rdi # 0x31f6b
callq 0xbae0
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x18(%rbp), %rax
mov... | Bartor[P]kompilator/front/compiler.l.c |
yy_load_buffer_state() | static void yy_load_buffer_state (void)
{
(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
(yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
(yy_hold_char) = *(yy_c_buf_p);
} | pushq %rbp
movq %rsp, %rbp
movq 0x360c5(%rip), %rax # 0x41380
movq 0x360c6(%rip), %rcx # 0x41388
movq (%rax,%rcx,8), %rax
movl 0x1c(%rax), %eax
movl %eax, 0x360d9(%rip) # 0x413a8
movq 0x360aa(%rip), %rax # 0x41380
movq 0x360ab(%rip), %rcx # 0x41388
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rax
movq... | Bartor[P]kompilator/front/compiler.l.c |
yy_get_previous_state() | static yy_state_type yy_get_previous_state (void)
{
yy_state_type yy_current_state;
char *yy_cp;
yy_current_state = (yy_start);
for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
{
YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
if ( yy_accept[yy_current_state] )
{
... | pushq %rbp
movq %rsp, %rbp
movl 0x36052(%rip), %eax # 0x4137c
movl %eax, -0x4(%rbp)
movq 0x3603c(%rip), %rax # 0x41370
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq 0x3604d(%rip), %rax # 0x41390
jae 0xb42f
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0xb36b
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
mov... | Bartor[P]kompilator/front/compiler.l.c |
yy_try_NUL_trans(int) | static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
{
int yy_is_jam;
char *yy_cp = (yy_c_buf_p);
YY_CHAR yy_c = 1;
if ( yy_accept[yy_current_state] )
{
(yy_last_accepting_state) = yy_current_state;
(yy_last_accepting_cpos) = yy_cp;
}
while ( yy_chk[yy_base[yy_current_state] + yy_c... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq 0x35f42(%rip), %rax # 0x41390
movq %rax, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x2642f(%rip), %rax # 0x31890
cmpw $0x0, (%rax,%rcx,2)
je 0xb47c
movl -0x4(%rbp), %eax
movl %eax, 0x35f2b(%rip) # 0x4139c
movq -0x10(%rbp), %rax
movq... | Bartor[P]kompilator/front/compiler.l.c |
yy_get_next_buffer() | static int yy_get_next_buffer (void)
{
char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
char *source = (yytext_ptr);
int number_to_move, i;
int ret_val;
if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
YY_FATAL_ERROR(
"fatal flex scanner internal error--end of buffer missed" )... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x35e51(%rip), %rax # 0x41380
movq 0x35e52(%rip), %rcx # 0x41388
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq 0x35e27(%rip), %rax # 0x41370
movq %rax, -0x18(%rbp)
movq 0x35e3c(%rip), %rax # 0x41390
movq 0x35e25(%rip), %rcx ... | Bartor[P]kompilator/front/compiler.l.c |
yyrestart(_IO_FILE*) | void yyrestart (FILE * input_file )
{
if ( ! YY_CURRENT_BUFFER ){
yyensure_buffer_stack ();
YY_CURRENT_BUFFER_LVALUE =
yy_create_buffer( yyin, YY_BUF_SIZE );
}
yy_init_buffer( YY_CURRENT_BUFFER, input_file );
yy_load_buffer_state( );
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x3584c(%rip) # 0x41380
je 0xbb4e
movq 0x35843(%rip), %rax # 0x41380
movq 0x35844(%rip), %rcx # 0x41388
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
jmp 0xbb56
xorl %eax, %eax
movq %rax, -0x10(%rbp)
jmp 0xbb56
movq -0x10(%rbp), ... | Bartor[P]kompilator/front/compiler.l.c |
yy_init_buffer(yy_buffer_state*, _IO_FILE*) | static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file )
{
int oerrno = errno;
yy_flush_buffer( b );
b->yy_input_file = file;
b->yy_fill_buffer = 1;
/* If b is the current buffer, then yy_init_buffer was _probably_
* called from yyrestart() or through yy_get_next_buffer.
* In that case, ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x6040
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0xbe70
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x34(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0... | Bartor[P]kompilator/front/compiler.l.c |
yy_switch_to_buffer(yy_buffer_state*) | void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer )
{
/* TODO. We should be able to replace this entire function body
* with
* yypop_buffer_state();
* yypush_buffer_state(new_buffer);
*/
yyensure_buffer_stack ();
if ( YY_CURRENT_BUFFER == new_buffer )
return;
if ( YY_CURRENT_BUFFER )
{
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0xb110
cmpq $0x0, 0x356b7(%rip) # 0x41380
je 0xbce3
movq 0x356ae(%rip), %rax # 0x41380
movq 0x356af(%rip), %rcx # 0x41388
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
jmp 0xbceb
xorl %eax, %eax
movq %rax, -0x10(%rbp)
jmp 0xbceb
movq ... | Bartor[P]kompilator/front/compiler.l.c |
yy_delete_buffer(yy_buffer_state*) | void yy_delete_buffer (YY_BUFFER_STATE b )
{
if ( ! b )
return;
if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
if ( b->yy_is_our_buffer )
yyfree( (void *) b->yy_ch_buf );
yyfree( (void *) b );
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xbdd5
jmp 0xbe4a
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x3559b(%rip) # 0x41380
je 0xbdff
movq 0x35592(%rip), %rax # 0x41380
movq 0x35593(%rip), %rcx # 0x41388
movq (%rax,%rcx,8), %rax
movq %rax, -0... | Bartor[P]kompilator/front/compiler.l.c |
yy_flush_buffer(yy_buffer_state*) | void yy_flush_buffer (YY_BUFFER_STATE b )
{
if ( ! b )
return;
b->yy_n_chars = 0;
/* We always need two end-of-buffer characters. The first causes
* a transition to the end-of-buffer state. The second causes
* a jam in that state.
*/
b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
b->yy_ch_buf[1] = YY_EN... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xbe88
jmp 0xbf14
movq -0x8(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movb $0x0, 0x1(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rc... | Bartor[P]kompilator/front/compiler.l.c |
yypush_buffer_state(yy_buffer_state*) | void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
{
if (new_buffer == NULL)
return;
yyensure_buffer_stack();
/* This block is copied from yy_switch_to_buffer. */
if ( YY_CURRENT_BUFFER )
{
/* Flush out information for old buffer. */
*(yy_c_buf_p) = (yy_hold_char);
YY_CURRENT_BUFFER_LVALUE->yy_b... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xbf38
jmp 0xc023
callq 0xb110
cmpq $0x0, 0x3543b(%rip) # 0x41380
je 0xbf5f
movq 0x35432(%rip), %rax # 0x41380
movq 0x35433(%rip), %rcx # 0x41388
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
jmp 0xbf67
xorl %eax, ... | Bartor[P]kompilator/front/compiler.l.c |
yypop_buffer_state() | void yypop_buffer_state (void)
{
if (!YY_CURRENT_BUFFER)
return;
yy_delete_buffer(YY_CURRENT_BUFFER );
YY_CURRENT_BUFFER_LVALUE = NULL;
if ((yy_buffer_stack_top) > 0)
--(yy_buffer_stack_top);
if (YY_CURRENT_BUFFER) {
yy_load_buffer_state( );
(yy_did_buffer_switch_on_eof) = 1;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
cmpq $0x0, 0x35340(%rip) # 0x41380
je 0xc05a
movq 0x35337(%rip), %rax # 0x41380
movq 0x35338(%rip), %rcx # 0x41388
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0xc062
xorl %eax, %eax
movq %rax, -0x8(%rbp)
jmp 0xc062
movq -0x8(%rbp), %rax
cmpq $0x0, %rax
jne ... | Bartor[P]kompilator/front/compiler.l.c |
yy_scan_buffer(char*, unsigned long) | YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size )
{
YY_BUFFER_STATE b;
if ( size < 2 ||
base[size-2] != YY_END_OF_BUFFER_CHAR ||
base[size-1] != YY_END_OF_BUFFER_CHAR )
/* They forgot to leave room for the EOB's. */
return NULL;
b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buf... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x2, -0x18(%rbp)
jb 0xc161
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x2, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0xc161
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %... | Bartor[P]kompilator/front/compiler.l.c |
yy_scan_bytes(char const*, int) | YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len )
{
YY_BUFFER_STATE b;
char *buf;
yy_size_t n;
int i;
/* Get memory for full buffer, including space for trailing EOB's. */
n = (yy_size_t) (_yybytes_len + 2);
buf = (char *) yyalloc( n );
if ( ! buf )
YY_FATAL_ERROR( "out of dynami... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x2, %eax
cltq
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xbda0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xc28b
leaq 0x25d3b(%rip), %rdi # 0x31fc1
callq 0xbae0
movl $0x0, -0x2c(%rbp... | Bartor[P]kompilator/front/compiler.l.c |
yylex_destroy() | int yylex_destroy (void)
{
/* Pop the buffer stack, destroying each element. */
while(YY_CURRENT_BUFFER){
yy_delete_buffer( YY_CURRENT_BUFFER );
YY_CURRENT_BUFFER_LVALUE = NULL;
yypop_buffer_state();
}
/* Destroy the stack itself. */
yyfree((yy_buffer_stack) );
(yy_buffer_stack) = NULL;
/* R... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
jmp 0xc40a
cmpq $0x0, 0x34f6e(%rip) # 0x41380
je 0xc42c
movq 0x34f65(%rip), %rax # 0x41380
movq 0x34f66(%rip), %rcx # 0x41388
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0xc434
xorl %eax, %eax
movq %rax, -0x8(%rbp)
jmp 0xc434
movq -0x8(%rbp), %rax
cmpq $0x0... | Bartor[P]kompilator/front/compiler.l.c |
CommandList::toString[abi:cxx11](int) | std::string CommandList::toString(int indentation) {
std::string s = indent(indentation) + ("CommandList<\n");
for (int i = 0; i < commands.size(); i++) {
s += commands[i]->toString(indentation + 1);
}
s += indent(indentation) + ">\n";
return s;
} | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xb8(%rbp)
movq %rdi, %rax
movq %rax, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0xc0(%rbp)
movb $0x0, -0x15(%rbp)
movl -0x14(%rbp), %edx
leaq -0x38(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x... | Bartor[P]kompilator/front/ast/node.cpp |
DeclarationList::toString[abi:cxx11](int) | std::string DeclarationList::toString(int indentation) {
std::string s = indent(indentation) + ("DeclarationList<\n");
for (const auto &declaration : declarations) s += declaration->toString(indentation + 1);
s += indent(indentation) + ">\n";
return s;
} | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xd8(%rbp)
movq %rdi, %rax
movq %rax, -0xe8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0xe0(%rbp)
movb $0x0, -0x15(%rbp)
movl -0x14(%rbp), %edx
leaq -0x38(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x... | Bartor[P]kompilator/front/ast/node.cpp |
CommandList::copy(std::function<Node* (Node*)>) | virtual Node *copy(Callback replacer) {
CommandList *cmdList = new CommandList();
for (const auto &cmd : commands) {
cmdList->commands.push_back(cmd->copy(replacer));
}
return cmdList;
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl $0x20, %edi
callq 0x6260
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x78(%rbp)
callq 0x8420
jmp 0x100bd
movq -0x80(%rbp), %rax
movq -0x78(%rbp), %rcx
movq %r... | Bartor[P]kompilator/front/ast/node.h |
DeclarationList::copy(std::function<Node* (Node*)>) | virtual Node *copy(Callback replacer) {
DeclarationList *dclList = new DeclarationList();
for (auto const &dcl : declarations) {
dclList->declarations.push_back(static_cast<AbstractDeclaration *>(dcl->copy(replacer)));
}
return dclList;
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl $0x20, %edi
callq 0x6260
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x78(%rbp)
callq 0x83b0
jmp 0x1107d
movq -0x80(%rbp), %rax
movq -0x78(%rbp), %rcx
movq %r... | Bartor[P]kompilator/front/ast/node.h |
AbstractAssembler::prepareConstants(bool) | void AbstractAssembler::prepareConstants(bool verbose) {
constants = new Constants(accumulatorNumber);
for (const auto num : program.constants.constants) {
Constant *constantPointer = constants->addConstant(num);
if (constantPointer && verbose) {
std::cout << constantPointer->toStr... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movl $0x30, %edi
callq 0x6260
movq %rax, %rdi
movq -0x78(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x70(%rbp)
movq (%rax), %rsi
callq 0x231a0
jmp 0x11a61
movq -... | Bartor[P]kompilator/middle/abstract_assembler/AbstractAssembler.cpp |
AbstractAssembler::assembleConstants() | InstructionList &AbstractAssembler::assembleConstants() {
InstructionList &list = constants->oneAndMinusOne(primaryAccumulator);
for (const auto &constant : constants->getConstants()) {
InstructionList &generatedCode = constant->generateConstant(constants, primaryAccumulator, secondaryAccumulator);
... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq 0x30(%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x236c0
movq %rax, %rcx
movq -0x68(%rbp), %rax
movq %rcx, -0x10(%rbp)
movq 0x30(%rax), %rsi
leaq -0x30(%rbp), %rdi
callq 0x1f8a0
leaq -0x30(%rbp), %rax
movq %ra... | Bartor[P]kompilator/middle/abstract_assembler/AbstractAssembler.cpp |
AbstractAssembler::getVariablesFromDeclarations(bool) | void AbstractAssembler::getVariablesFromDeclarations(bool verbose) {
scopedVariables = new ScopedVariables(
1 // next address...
+ accumulatorNumber // ...offset by accumulators...
+ program.constants.constants.size() * 2 // ...constants times two for additional special constants... | pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc0(%rbp)
movl $0x20, %edi
callq 0x6260
movq %rax, %rcx
movq -0xc0(%rbp), %rax
movq %rcx, -0xb8(%rbp)
movq %rcx, -0xd0(%rbp)
movq (%rax), %rcx... | Bartor[P]kompilator/middle/abstract_assembler/AbstractAssembler.cpp |
AbstractAssembler::removeUselessConstants(InstructionList&) | void AbstractAssembler::removeUselessConstants(InstructionList &instructions) {
std::vector < Constant * > toRemove;
for (auto const &constant : constants->getConstants()) {
bool found = false;
for (auto const &ins : instructions.getInstructions()) {
if (auto addrIns = dynamic_cast<... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1fd80
movq -0xc8(%rbp), %rax
movq 0x30(%rax), %rsi
leaq -0x48(%rbp), %rdi
callq 0x1f8a0
jmp 0x1219d
leaq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x3... | Bartor[P]kompilator/middle/abstract_assembler/AbstractAssembler.cpp |
AbstractAssembler::assembleCommands(CommandList&) | SimpleResolution *AbstractAssembler::assembleCommands(CommandList &commandList) {
InstructionList &instructions = *new InstructionList();
for (const auto &command : commandList.commands) {
long long tempVars = 0;
if (auto commandList = dynamic_cast<CommandList *>(command)) { // NESTED COMMANDL... | pushq %rbp
movq %rsp, %rbp
subq $0x4e0, %rsp # imm = 0x4E0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x200(%rbp)
movl $0x20, %edi
callq 0x6260
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x1f8(%rbp)
callq 0x2b0c0
jmp 0x1245c
movq -0x1f8(%rbp), %rax
movq %rax, -0x18(%rbp)
... | Bartor[P]kompilator/middle/abstract_assembler/AbstractAssembler.cpp |
AbstractAssembler::resolve(AbstractIdentifier&, bool) | Resolution *AbstractAssembler::resolve(AbstractIdentifier &identifier, bool checkInit = true) {
Variable *var = scopedVariables->resolveVariable(identifier.name);
if (checkInit && !var->initialized) {
std::cout << " [w] Variable " << var->name << " may not have been initialized" << std::endl;
... | pushq %rbp
movq %rsp, %rbp
subq $0x2c0, %rsp # imm = 0x2C0
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x168(%rbp)
movq 0x28(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x246a0
movq %rax, -0x28(%rbp)
tes... | Bartor[P]kompilator/middle/abstract_assembler/AbstractAssembler.cpp |
AbstractAssembler::resolve(AbstractValue&) | Resolution *AbstractAssembler::resolve(AbstractValue &value) {
try { // NUMBER VALUE - 0
NumberValue &numberValue = dynamic_cast<NumberValue &>(value);
ResolvableAddress &address = constants->getConstant(numberValue.value)->getAddress();
return new Resolution(
*new Instructio... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x2b5b2(%rip), %rsi # 0x40078
leaq 0x2b713(%rip), %rdx # 0x401e0
xorl %eax, %eax
movl %eax, %ecx
callq 0x62f0
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax... | Bartor[P]kompilator/middle/abstract_assembler/AbstractAssembler.cpp |
AbstractAssembler::assembleCondition(Condition&, InstructionList&) | SimpleResolution *AbstractAssembler::assembleCondition(Condition &condition, InstructionList &codeBlock) {
InstructionList &instructions = *new InstructionList();
Resolution *lhsResolution = resolve(condition.lhs);
Resolution *rhsResolution = resolve(condition.rhs);
bool incResolved = false;
if (r... | pushq %rbp
movq %rsp, %rbp
subq $0x360, %rsp # imm = 0x360
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1b0(%rbp)
movl $0x20, %edi
callq 0x6260
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x1a8(%rbp)
callq 0x2b0c0
jmp 0x1e7c0
movq -0x1b0(%rbp), %rdi
... | Bartor[P]kompilator/middle/abstract_assembler/AbstractAssembler.cpp |
AbstractAssembler::assemble(bool) | InstructionList &AbstractAssembler::assemble(bool verbose) {
getVariablesFromDeclarations(verbose);
prepareConstants(verbose);
SimpleResolution *programCodeResolution = assembleCommands(program.commands);
removeUselessConstants(programCodeResolution->instructions);
InstructionList &instructions = as... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x11c90
movq -0x28(%rbp), %rdi
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x11a20
m... | Bartor[P]kompilator/middle/abstract_assembler/AbstractAssembler.cpp |
lltoa[abi:cxx11](unsigned long long, int) | std::string lltoa(unsigned long long val, int base) {
static char buf[64] = {0};
int i = 62;
if (val == 0) return std::string("0");
for (; val && i; --i, val /= base) {
buf[i] = "0123456789abcdef"[val % base];
}
return std::string(&buf[i + 1]);
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x3e, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x21bc7
leaq -0x19(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x64e0
movq -0x40(%rbp), %rdi
movq ... | Bartor[P]kompilator/middle/abstract_assembler/Constant.cpp |
calculatePrefix(Constant*, Constant*) | long long calculatePrefix(Constant *a, Constant *b) {
long long prefixLength = 0;
while (a->binaryString[prefixLength] && b->binaryString[prefixLength] && a->binaryString[prefixLength] == b->binaryString[prefixLength]) {
prefixLength++;
}
return prefixLength;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
callq 0x6580
movq %rax, %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0x19(%rbp)
je 0x21d2d
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
movq -0x18... | Bartor[P]kompilator/middle/abstract_assembler/Constant.cpp |
Constant::Constant(long long, ResolvableAddress&) | Constant::Constant(long long value, ResolvableAddress &address) : value(value), address(address) {
long long valCopy = llabs(value);
binaryString = std::string(lltoa(valCopy, 2));
generationCost = 0;
for (long long i = 0; i < binaryString.size(); i++) {
if (binaryString[i] == '1') generationCos... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movq -0x18(%rbp), %rax
movq %rax, (%rdi)
movq -0x10(%rbp), %rax
movq %rax, 0x8(%rdi)
addq $0x18, %rdi
movq %rdi, -0x60(%rbp)
callq 0x63b0
movq -0x10(%rbp), %rax
mo... | Bartor[P]kompilator/middle/abstract_assembler/Constant.cpp |
Constant::generateConstant(Constants*, ResolvableAddress&, ResolvableAddress&) | InstructionList &Constant::generateConstant(Constants *constantsData, ResolvableAddress &primaryAccumulator, ResolvableAddress &secondaryAccumulator) {
InstructionList &instructions = *new InstructionList();
if (value == 0) {
instructions.append(new Sub(primaryAccumulator))
.append(new ... | pushq %rbp
movq %rsp, %rbp
subq $0x330, %rsp # imm = 0x330
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xf0(%rbp)
movl $0x20, %edi
callq 0x6260
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xe8(%rbp)
callq 0x2b0c0
jmp 0x21f04
m... | Bartor[P]kompilator/middle/abstract_assembler/Constant.cpp |
Constants::addConstant(long long) | Constant *Constants::addConstant(long long value) {
if (value == 1 || value == -1) return nullptr;
for (const auto &constant : constants) {
if (constant->value == value) {
return nullptr;
}
}
ResolvableAddress &address = *new ResolvableAddress(currentAddress++); // assign a... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
cmpq $0x1, -0x18(%rbp)
je 0x2334c
cmpq $-0x1, -0x18(%rbp)
jne 0x23359
movq $0x0, -0x8(%rbp)
jmp 0x235d8
movq -0x88(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp),... | Bartor[P]kompilator/middle/abstract_assembler/Constants.cpp |
Constants::removeConstant(Constant*) | void Constants::removeConstant(Constant *constant) {
for (long long i = 0; i < constants.size(); i++) {
if (constants[i] == constant) {
constants.erase(constants.begin() + i);
break;
}
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
addq $0x10, %rdi
callq 0x20600
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x23... | Bartor[P]kompilator/middle/abstract_assembler/Constants.cpp |
Constants::oneAndMinusOne(ResolvableAddress&) | InstructionList &Constants::oneAndMinusOne(ResolvableAddress &primaryAccumulator) {
InstructionList &list = *new InstructionList();
list.append(new Sub(primaryAccumulator))
.append(new Inc())
.append(new Store(one->getAddress()))
.append(new Dec())
.append(new Dec... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x20, %edi
callq 0x6260
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x2b0c0
jmp 0x236f6
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %... | Bartor[P]kompilator/middle/abstract_assembler/Constants.cpp |
Constants::getConstant(long long) | Constant *Constants::getConstant(long long value) {
if (value == 1) return one;
else if (value == -1) return minusOne;
else {
for (const auto &constant : constants) {
if (constant->value == value) return constant;
}
return nullptr;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x1, -0x18(%rbp)
jne 0x2393f
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x239cd
cmpq $-0x1, -0x18(%rbp)
jne 0x23954
movq -0x40(%rbp), %rax
movq 0x8(%rax),... | Bartor[P]kompilator/middle/abstract_assembler/Constants.cpp |
ScopedVariables::pushVariableScope(Variable*) | void ScopedVariables::pushVariableScope(Variable *variable) {
if (!dynamic_cast<TemporaryVariable *>(variable)) {
for (const auto &var : variables) {
if (var->name == variable->name) throw "Redeclaration of variable " + var->name;
}
}
variable->getAddress().setAddress(currentAdd... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x244f7
movq -0x48(%rbp), %rdi
leaq 0x1c177(%rip), %rsi # 0x40658
leaq 0x1c288(%rip), %rdx # 0x40770
xorl %eax, %... | Bartor[P]kompilator/middle/abstract_assembler/ScopedVariables.cpp |
ScopedVariables::popVariableScope(long long) | void ScopedVariables::popVariableScope(long long times) {
while (times-- > 0) {
Variable *v = variables.back();
currentAddress -= variables.back()->size;
variables.pop_back();
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x10(%rbp)
cmpq $0x0, %rax
jle 0x24693
movq -0x20(%rbp), %rdi
callq 0x249b0
movq -0x20(%rbp), %rdi
movq (%rax), %rax
m... | Bartor[P]kompilator/middle/abstract_assembler/ScopedVariables.cpp |
ScopedVariables::resolveVariable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | Variable *ScopedVariables::resolveVariable(std::string &name) {
for (const auto &variable : variables) {
if (dynamic_cast<TemporaryVariable *>(variable) == nullptr) {
if (variable->name == name) return variable;
}
}
throw "No variable in current scope: " + name;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x247d0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x24800
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x24830
testb ... | Bartor[P]kompilator/middle/abstract_assembler/ScopedVariables.cpp |
checkTautology(Condition&) | ConditionState checkTautology(Condition &condition) {
try {
NumberValue &lVal = dynamic_cast<NumberValue &>(condition.lhs);
NumberValue &rVal = dynamic_cast<NumberValue &>(condition.rhs);
switch (condition.type) {
case EQUAL:
return lVal.value == rVal.value ? ALW... | pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x1a94a(%rip), %rsi # 0x40078
leaq 0x1aaab(%rip), %rdx # 0x401e0
xorl %eax, %eax
movl %eax, %ecx
callq 0x62f0
movq %rax, -0xa8(%rbp)
cmpq $0x0, %rax
jne 0x25752
callq 0x6... | Bartor[P]kompilator/middle/ast_optimizer/ASTOptimizer.cpp |
ASTOptimizer::traverse(CommandList&, std::function<Node* (Node*)>) | bool ASTOptimizer::traverse(CommandList &commandList, Callback callback) {
bool changed = false;
for (int i = 0; i < commandList.commands.size(); i++) {
Node *newNode = callback(commandList.commands[i]);
if (newNode != commandList.commands[i]) {
commandList.commands[i] = newNode;
... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdx, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movb $0x0, -0x19(%rbp)
movl $0x0, -0x20(%rbp)
movslq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0... | Bartor[P]kompilator/middle/ast_optimizer/ASTOptimizer.cpp |
ASTOptimizer::traverse(Node*, std::function<Node* (Node*)>) | bool ASTOptimizer::traverse(Node *node, Callback callback) {
if (auto cmdList = dynamic_cast<CommandList *>(node)) {
return traverse(*cmdList, callback);
} else if (auto whileNode = dynamic_cast<While *>(node)) {
return traverse(whileNode->commands, callback);
} else if (auto forNode = dynam... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rdx, -0x138(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x130(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x128(%rbp)
cmpq $0x0, %rax
je 0x260f1
movq -0x128(%rbp), %rdi
leaq 0x19e88... | Bartor[P]kompilator/middle/ast_optimizer/ASTOptimizer.cpp |
ASTOptimizer::constantExpressionOptimizer(Node*) | Node *ASTOptimizer::constantExpressionOptimizer(Node *node) {
if (auto assignNode = dynamic_cast<Assignment *>(node)) {
try {
auto binaryExpression = dynamic_cast<BinaryExpression &>(assignNode->expression);
try {
auto lhsConstant = dynamic_cast<NumberValue &>(binaryE... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
cmpq $0x0, %rax
je 0x26636
movq -0xa0(%rbp), %rdi
leaq 0x19943(%rip), %rsi # 0x3ff60
leaq 0x19d6c(%rip), %rd... | Bartor[P]kompilator/middle/ast_optimizer/ASTOptimizer.cpp |
ASTOptimizer::constantLoopUnroller(Node*) | Node *ASTOptimizer::constantLoopUnroller(Node *node) {
if (auto forNode = dynamic_cast<For *>(node)) {
try {
auto startConstant = dynamic_cast<NumberValue &>(forNode->startValue);
try {
auto endConstant = dynamic_cast<NumberValue &>(forNode->endValue);
... | pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x110(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x108(%rbp)
cmpq $0x0, %rax
je 0x26b26
movq -0x108(%rbp), %rdi
leaq 0x19453(%rip), %rsi # 0x3ff60
leaq 0x1999c(%rip), ... | Bartor[P]kompilator/middle/ast_optimizer/ASTOptimizer.cpp |
ASTOptimizer::constantConditionRemover(Node*) | Node *ASTOptimizer::constantConditionRemover(Node *node) {
if (auto whileNode = dynamic_cast<While *>(node)) {
if (checkTautology(whileNode->condition) == ALWAYS) {
std::cout << " |[w] Infinite loop detected" << std::endl;
return node;
} else if (checkTautology(whileNode->co... | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xa8(%rbp)
cmpq $0x0, %rax
je 0x2707b
movq -0xa8(%rbp), %rdi
leaq 0x18efe(%rip), %rsi # 0x3ff60
leaq 0x193ff(%rip), %rdx # 0x40468
xorl %eax, %eax
movl %eax, %ec... | Bartor[P]kompilator/middle/ast_optimizer/ASTOptimizer.cpp |
ASTOptimizer::optimize(bool) | void ASTOptimizer::optimize(bool verbose) {
while (traverse(originalProgram->commands, [this](Node *node) -> Node * { return constantConditionRemover(node); })) {
std::cout << " [i] flattening always true expressions" << std::endl;
}
while (traverse(originalProgram->commands, [this](Node *node) -... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rax
movq (%rax), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, -0xb8(%rbp)
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
leaq... | Bartor[P]kompilator/middle/ast_optimizer/ASTOptimizer.cpp |
ASTOptimizer::iteratorReplacer(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, long long)::$_0::operator()(Node*) const | Callback ASTOptimizer::iteratorReplacer(std::string &variableToReplace, long long value) {
return [this, variableToReplace, value](Node *node) -> Node * {
if (auto idVal = dynamic_cast<IdentifierValue *>(node)) {
try {
VariableIdentifier &varId = dynamic_cast<VariableIdentifier &... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
je 0x27e7a
movq -0x68(%rbp), %rdi
leaq 0x180fc(%rip), %rsi # 0x3ff60
leaq 0x183bd(%rip), %rdx # 0x40228
xorl %eax,... | Bartor[P]kompilator/middle/ast_optimizer/ASTOptimizer.cpp |
PeepholeOptimizer::optimize(bool) | void PeepholeOptimizer::optimize(bool verbose) {
std::cout << " [i] Removing useless STORE LOADs..." << std::endl;
while (removeUselessStoreLoads()) {
if (verbose) std::cout << std::endl << "Removed useless STORE LOAD";
}
std::cout << " [i] Removing useless STORE LOADIs..." << std::endl;
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x16d25(%rip), %rdi # 0x40fc8
leaq 0x86ff(%rip), %rsi # 0x329a9
callq 0x6250
movq %rax, %rdi
movq 0x16cd7(%rip), %rsi # 0x40f90
callq 0x6280... | Bartor[P]kompilator/middle/peephole/PeepholeOptimizer.cpp |
PeepholeOptimizer::removeUselessStoreLoads() | bool PeepholeOptimizer::removeUselessStoreLoads() {
for (int i = 0; i < instructions.getInstructions().size(); i++) {
if (auto storeInstruction = dynamic_cast<Store *>(instructions.getInstructions()[i])) {
int offsetToNonStub = 0;
while (dynamic_cast<Stub *>(instructions.getInstruct... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x70(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq %rcx, -0x78(%rbp)
movq (%rax), %rdi
callq 0x2b160
movq %rax, %rdi
callq 0x2aba0
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %... | Bartor[P]kompilator/middle/peephole/PeepholeOptimizer.cpp |
PeepholeOptimizer::removeUselessStoreLoadis() | bool PeepholeOptimizer::removeUselessStoreLoadis() {
for (int i = 0; i < instructions.getInstructions().size(); i++) {
if (auto storeInstruction = dynamic_cast<Store *>(instructions.getInstructions()[i])) {
int offsetToNonStub = 0;
while (dynamic_cast<Stub *>(instructions.getInstruc... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x78(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq %rcx, -0x80(%rbp)
movq (%rax), %rdi
callq 0x2b160
movq %rax, %rdi
callq 0x2aba0
movq %rax, %rcx
movq -0x8... | Bartor[P]kompilator/middle/peephole/PeepholeOptimizer.cpp |
InstructionList::seal(bool) | void InstructionList::seal(bool addHalt) {
if (addHalt) instructions.push_back(new Halt());
long long counter = 0;
for (const auto &ins : instructions) { // instruction address resolution
ins->setAddress(counter);
if (!ins->stub) {
counter++; // stubs use next instruction's addr... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
testb $0x1, -0x9(%rbp)
je 0x2b309
movq -0x48(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x50(%rbp)
movl $0x18, %edi
callq 0x6260
movq %rax, %rdi
movq %rdi, -0x58... | Bartor[P]kompilator/back/asm/InstructionList.cpp |
main | int main(int argc, char **argv) {
std::chrono::steady_clock::time_point begin = std::chrono::steady_clock::now();
if (argc < 2) {
std::cerr << "[i] Usage: compiler <source> [destination] [optimize=(0|1)]" << std::endl;
return 1;
}
FILE *source = fopen(argv[1], "r");
if (!source) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x580, %rsp # imm = 0x580
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x6390
movq %rax, -0x18(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x2edf6
movq 0x12221(%rip), %rdi # 0x40ff0
leaq 0x3d90(%rip), %rsi # 0x32b66
callq 0x6250
movq %rax, %rdi
movq 0... | Bartor[P]kompilator/main.cpp |
main | int main()
{
bool lAgain = true;
string lInput;
while ( lAgain )
{
// start game
Game * lJeopardy = new Game(5);
cout << "Welcome to a new game of Jeopardy.\n\n";
// while game not done continue playing
while(lJeopardy->playing())
{
//Start by showing the board
lJeopardy->showBoard();
// upda... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
movb $0x1, -0x5(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3390
testb $0x1, -0x5(%rbp)
je 0x388e
movl $0x18, %edi
callq 0x3290
movq %rax, -0x48(%rbp)
jmp 0x3756
movq -0x48(%rbp), %rdi
movl $0x5, %esi
callq 0x3920
jmp 0x3766
movq -0x48(%rbp), %rax
movq %rax, -0... | Matlock42[P]Jeopardy/jgame.cpp |
Game::Game(int) | Game::Game(int aSize)
{
this->mScore = 0;
this->mPlaying = true;
this->mSize = aSize;
this->mQuestionSet = new Question**[mSize];
for(int lRow = 0; lRow < aSize; lRow++)
{
this->mQuestionSet[lRow] = new Question*[mSize];
}
loadQuestions();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, 0x4(%rax)
movb $0x1, (%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x8(%rax)
movslq 0x8(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %c... | Matlock42[P]Jeopardy/jgameClass.cpp |
Game::loadQuestions() | int Game::loadQuestions(void)
{
/* initialize random seed: */
srand (time(NULL));
std::vector <std::string> files;
// get list of xml files
files = findXML(".");
if( files.size() < mSize)
{
cout << "Unable load game: inadequate categories. ("<< files.size() <<")\n";
return -1;
}
// shuffle up the li... | pushq %rbp
movq %rsp, %rbp
subq $0x10340, %rsp # imm = 0x10340
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x10218(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x3250
movl %eax, %edi
callq 0x3270
leaq -0x28(%rbp), %rdi
callq 0x5630
movq -0x10218(%rbp), %rsi
leaq 0x8868(%rip), %rdx # 0xc289
le... | Matlock42[P]Jeopardy/jgameClass.cpp |
Game::showBoard() | int Game::showBoard(void)
{
clearScreen();
int i,j,k;
int lPrompt;
int * t; // Number of additional tabs to add to make things line up
t = new int [mSize];
for(j = 0; j < mSize; j++) // print category names
{
cout << mQuestionSet[j][0]->category() << "\t";
t[j] = ((mQuestionSet[j][0]->category().length()) /... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x43e0
movq -0xa0(%rbp), %rax
movslq 0x8(%rax), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, -0x20(%rbp)
movl $0x0, ... | Matlock42[P]Jeopardy/jgameClass.cpp |
Game::showQuestion(int) | bool Game::showQuestion(int aPrompt)
{
int lCatagory, lPrice;
int lPrompt;
bool lCorrect;
// split 2 digit prompt into category and price (and make base zero)
lCatagory = (aPrompt / 10 % 10) - 1; // tens digit
lPrice = (aPrompt % 10) - 1; // ones digit
// make sure selection is a valid choice
if( lCatagory ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl $0xa, %ecx
cltd
idivl %ecx
subl $0x1, %edx
movl %edx, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
sub... | Matlock42[P]Jeopardy/jgameClass.cpp |
Game::updateStatus() | int Game::updateStatus(void)
{
bool lDone = true; // assume done
// loop through the questionSet and see if they have all been played
// for efficency, start with the high dollar/harder questions
// loop through rows (bottom to top)
for(int i = mSize-1; i >= 0; i--)
{
// loop through columns
for(int j=0; j ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movb $0x1, -0x9(%rbp)
movl 0x8(%rax), %eax
subl $0x1, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jl 0x4c4f
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge ... | Matlock42[P]Jeopardy/jgameClass.cpp |
Game::findXML[abi:cxx11](char const*) | std::vector <std::string> Game::findXML ( const char *path)
{
tinydir_dir dir;
std::string s;
std::vector <std::string> output;
// open the current directory
if (tinydir_open(&dir, path) == -1)
{
std::cout << "Error opening directory";
}
while (dir.has_next)
{
tinydir_file file;
// get the file
if ... | pushq %rbp
movq %rsp, %rbp
subq $0x2310, %rsp # imm = 0x2310
movq %rdi, -0x22c0(%rbp)
movq %rdi, %rax
movq %rax, -0x22d0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x22c8(%rbp)
leaq -0x1058(%rbp), %rdi
callq 0x3390
movq -0x22c0(%rbp), %rdi
movb... | Matlock42[P]Jeopardy/jgameClass.cpp |
tinydir_open(tinydir_dir*, char const*) | _TINYDIR_FUNC
int tinydir_open(tinydir_dir *dir, const char *path)
{
if (dir == NULL || path == NULL || strlen(path) == 0)
{
errno = EINVAL;
return -1;
}
if (strlen(path) + _TINYDIR_PATH_EXTRA >= _TINYDIR_PATH_MAX)
{
errno = ENAMETOOLONG;
return -1;
}
/* initialise dir */
dir->_files = NULL;
#ifdef _MS... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x514d
cmpq $0x0, -0x18(%rbp)
je 0x514d
movq -0x18(%rbp), %rdi
callq 0x3100
cmpq $0x0, %rax
jne 0x5164
callq 0x3050
movl $0x16, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5257
movq -0x18... | Matlock42[P]Jeopardy/./tinydir/tinydir.h |
tinydir_next(tinydir_dir*) | _TINYDIR_FUNC
int tinydir_next(tinydir_dir *dir)
{
if (dir == NULL)
{
errno = EINVAL;
return -1;
}
if (!dir->has_next)
{
errno = ENOENT;
return -1;
}
#ifdef _MSC_VER
if (FindNextFile(dir->_h, &dir->_f) == 0)
#else
dir->_e = readdir(dir->_d);
if (dir->_e == NULL)
#endif
{
dir->has_next = 0;
#ifdef _... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5437
callq 0x3050
movl $0x16, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5499
movq -0x10(%rbp), %rax
cmpl $0x0, 0x1000(%rax)
jne 0x5458
callq 0x3050
movl $0x2, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0x... | Matlock42[P]Jeopardy/./tinydir/tinydir.h |
tinydir_close(tinydir_dir*) | _TINYDIR_FUNC
void tinydir_close(tinydir_dir *dir)
{
if (dir == NULL)
{
return;
}
memset(dir->path, 0, sizeof(dir->path));
dir->has_next = 0;
dir->n_files = -1;
if (dir->_files != NULL)
{
free(dir->_files);
}
dir->_files = NULL;
#ifdef _MSC_VER
if (dir->_h != INVALID_HANDLE_VALUE)
{
FindClose(dir->_h... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x54c8
jmp 0x555d
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x1000, %edx # imm = 0x1000
callq 0x3140
movq -0x8(%rbp), %rax
movl $0x0, 0x1000(%rax)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x1004(%rax) # imm = 0xFFFFFF... | Matlock42[P]Jeopardy/./tinydir/tinydir.h |
rapidxml::file<char>::file(char const*) | file(const char *filename)
{
using namespace std;
// Open stream
basic_ifstream<Ch> stream(filename, ios::binary);
if (!stream)
throw runtime_error(string("cannot open file ") + filename);
stream.unsetf(ios::skipws);
... | pushq %rbp
movq %rsp, %rbp
subq $0x2e0, %rsp # imm = 0x2E0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x2a8(%rbp)
movq %rdi, %rax
movq %rax, -0x2a0(%rbp)
callq 0x6ee0
movq -0x10(%rbp), %rsi
leaq -0x218(%rbp), %rdi
movl $0x4, %edx
callq 0x34e0
jmp 0x58b4
movq -0x218(%rbp), ... | Matlock42[P]Jeopardy/./RapidXml/rapidxml_utils.hpp |
void rapidxml::xml_document<char>::parse<0>(char*) | void parse(Ch *text)
{
assert(text);
// Remove current contents
this->remove_all_nodes();
this->remove_all_attributes();
// Parse BOM, if any
parse_bom<Flags>(text);
// Parse children
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5bc1
jmp 0x5be0
leaq 0x6774(%rip), %rdi # 0xc33c
leaq 0x6772(%rip), %rsi # 0xc341
movl $0x567, %edx # imm = 0x567
leaq 0x677e(%rip), %rcx... | Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp |
rapidxml::xml_node<char>::first_node(char const*, unsigned long, bool) const | xml_node<Ch> *first_node(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const
{
if (name)
{
if (name_size == 0)
name_size = internal::measure(name);
for (xml_node<Ch> *child = m_first_node; child; child = chi... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5d9f
cmpq $0x0, -0x20(%rbp)
jne 0x5d22
movq -0x18(%rbp), %rdi
callq 0x9370
movq %r... | Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp |
unsigned long rapidxml::count_children<char>(rapidxml::xml_node<char>*) | inline std::size_t count_children(xml_node<Ch> *node)
{
xml_node<Ch> *child = node->first_node();
std::size_t count = 0;
while (child)
{
++count;
child = child->next_sibling();
}
return count;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %ecx
movq %rdx, %rsi
callq 0x5ce0
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5e1b
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rb... | Matlock42[P]Jeopardy/./RapidXml/rapidxml_utils.hpp |
rapidxml::xml_node<char>::first_attribute(char const*, unsigned long, bool) const | xml_attribute<Ch> *first_attribute(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const
{
if (name)
{
if (name_size == 0)
name_size = internal::measure(name);
for (xml_attribute<Ch> *attribute = m_first_attri... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5ee2
cmpq $0x0, -0x20(%rbp)
jne 0x5e72
movq -0x18(%rbp), %rdi
callq 0x9370
movq %r... | Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp |
rapidxml::xml_node<char>::next_sibling(char const*, unsigned long, bool) const | xml_node<Ch> *next_sibling(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const
{
assert(this->m_parent); // Cannot query for siblings if node has no parent
if (name)
{
if (name_size == 0)
name_size = interna... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, 0x20(%rax)
je 0x5f6c
jmp 0x5f8b
leaq 0x6604(%rip), %rdi # 0xc577
leaq 0x63c7(%rip), %rsi ... | Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp |
rapidxml::memory_pool<char>::clear() | void clear()
{
while (m_begin != m_static_memory)
{
char *previous_begin = reinterpret_cast<header *>(align(m_begin))->previous_begin;
if (m_free_func)
m_free_func(m_begin);
else
delete[] m_begin;
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq (%rcx), %rax
addq $0x18, %rcx
cmpq %rcx, %rax
je 0x6313
movq -0x18(%rbp), %rdi
movq (%rdi), %rsi
callq 0x6340
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, -0x... | Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp |
void rapidxml::xml_document<char>::parse_bom<0>(char*&) | void parse_bom(Ch *&text)
{
// UTF-8?
if (static_cast<unsigned char>(text[0]) == 0xEF &&
static_cast<unsigned char>(text[1]) == 0xBB &&
static_cast<unsigned char>(text[2]) == 0xBF)
{
text += 3; // Skup utf-8 bom
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
cmpl $0xef, %eax
jne 0x7cff
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0xbb, %eax
jne 0x7cff
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl 0x2(%rax), %eax
cmp... | Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp |
void rapidxml::xml_document<char>::skip<rapidxml::xml_document<char>::whitespace_pred, 0>(char*&) | static void skip(Ch *&text)
{
Ch *tmp = text;
while (StopPred::test(*tmp))
++tmp;
text = tmp;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x8220
cmpb $0x0, %al
je 0x7d45
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x7d27
movq -0x10(%rbp), %rcx
movq -0x8(%rbp... | Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp |
rapidxml::xml_node<char>* rapidxml::xml_document<char>::parse_node<0>(char*&) | xml_node<Ch> *parse_node(Ch *&text)
{
// Parse proper node type
switch (text[0])
{
// <...
default:
// Parse and append element node
return parse_element<Flags>(text);
// <?...
case Ch('?'):
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
movl %eax, -0x28(%rbp)
subl $0x21, %eax
je 0x7e6a
jmp 0x7d90
movl -0x28(%rbp), %eax
subl $0x3f, %eax
je 0x7db0
jmp 0x7d9a
m... | Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp |
rapidxml::xml_node<char>::append_node(rapidxml::xml_node<char>*) | void append_node(xml_node<Ch> *child)
{
assert(child && !child->parent() && child->type() != node_document);
if (first_node())
{
child->m_prev_sibling = m_last_node;
m_last_node->m_next_sibling = child;
}
else
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x11(%rbp)
je 0x810d
movq -0x10(%rbp), %rdi
callq 0x9db0
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x11(%rbp)
jne 0x810... | Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp |
rapidxml::xml_node<char>* rapidxml::xml_document<char>::parse_element<0>(char*&) | xml_node<Ch> *parse_element(Ch *&text)
{
// Create element node
xml_node<Ch> *element = this->allocate_node(node_element);
// Extract element name
Ch *name = text;
skip<node_name_pred, Flags>(text);
if (text == name)
RAPIDX... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x60, %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %r9d
movq %r9, %rdx
movq %r9, %rcx
movq %r9, %r8
callq 0x8a40
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
... | Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp |
rapidxml::xml_node<char>* rapidxml::xml_document<char>::parse_xml_declaration<0>(char*&) | xml_node<Ch> *parse_xml_declaration(Ch *&text)
{
// If parsing of declaration is disabled
if (!(Flags & parse_declaration_node))
{
// Skip until end of declaration
while (text[0] != Ch('?') || text[1] != Ch('>'))
{
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x3f, %ecx
movb %al, -0x29(%rbp)
jne 0x84c8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x3e, %eax
setne %al
movb %al, -0x2... | Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp |
rapidxml::xml_node<char>* rapidxml::xml_document<char>::parse_pi<0>(char*&) | xml_node<Ch> *parse_pi(Ch *&text)
{
// If creation of PI nodes is enabled
if (Flags & parse_pi_nodes)
{
// Create pi node
xml_node<Ch> *pi = this->allocate_node(node_pi);
// Extract PI target name
Ch *name = tex... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x3f, %ecx
movb %al, -0x1d(%rbp)
jne 0x85a8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x3e, %eax
setne %al
movb %al, -0x1... | Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.