Важная информация

User Tag List

Страница 1 из 3 123 ПоследняяПоследняя
Показано с 1 по 10 из 25

Тема: Выравнивание, утрамбовывание и впихивание кода + быстрые таблицы переходов и SJASM

  1. #1
    Guru Аватар для NEO SPECTRUMAN
    Регистрация
    22.05.2011
    Адрес
    Дзержинск
    Сообщений
    4,043
    Спасибо Благодарностей отдано 
    157
    Спасибо Благодарностей получено 
    224
    Поблагодарили
    183 сообщений
    Mentioned
    3 Post(s)
    Tagged
    0 Thread(s)

    Cool Выравнивание, утрамбовывание и впихивание кода + быстрые таблицы переходов и SJASM

    ТО о чем так долго говорили большевики наконец свершилось!

    при поддержке Ped7g™
    мну наконец запилил размещатель\утрамбовщик быстрых таблиц переходов и не таблиц переходов

    и теперь возможно? можно будет забыть про бхмерское слоупочное
    Код:
    ld l,a
    ld h,tab_haddr
    ld a,(hl)
    inc h
    ld h,(hl)
    ld l,a
    jp (hl)
    и про всякие дырки в коде\данных после выравнивания


    собственно сабж patent pending и находиться в аттаче
    написан на редкостном говнокоде
    но на вид даже работает

    и засовывает код в первое попавшееся место
    (каждый свободный байт предварительно помечается в массиве)
    а не как было бы рациональнее

    напиханы всякие детекции вылазения за пределы выделенного участка памяти
    в случае заканчивания выделенной памяти
    но 100% детекцию всех возможных вариантов вылазения не гарантирую

    тк же не поддерживается много страничность !!!!!!!!1
    хотя ее наверно? можно как то прилепить
    как то прилеплена


    результат работы



    jp-ы ведут куда надо
    условная компиляция тоже работает

    как поведут себя инклуды и макросы науке неизвестно

    под таблицы генерируемые при помощи lua
    нужно предварительно забивать место

    таким образом

    Код:
    		tampright_align256_allocate_macro_pg01
    tab_1
    tab_1_haddr = high $
    			dup 512
    			nop
    			edup
    tab_2
    tab_2_haddr = high $
    			dup 512
    			nop
    			edup
    		end_tampright_align256_allocate_macro_pg01
    
    
    		org tab_1
    		lua allpass
    			for temp_cnt = 0x00,0x1FFF,0x10 do
    			sj.add_byte(math.floor(temp_cnt % 256))
    			end
    		endlua
    
    		org tab_2
    		lua allpass
    			for temp_cnt = 0x00,0x1FFF,0x10 do
    			sj.add_byte(math.floor(temp_cnt / 256))
    			end
    		endlua
    [свернуть]



    все метки и переменные названы достаточно длинно и своеобразно
    чтоб не конфликтовать с уже имеющимися в коде в который будут вставлены


    - - - Добавлено - - -

    собственно howto юзать быстрые таблицы
    Код:
    	ld l,a		;4
    	ld h,$7F	;7
    	ld h,(hl)	;7
    	jp (hl)		;4
    
    	fasttab_allocate_macro $7F,0
    	ld b,0
    	jp ix
    	end_fasttab_allocate_macro
    
    	fasttab_allocate_macro $7F,1
    	ld b,1
    	jp ix
    	end_fasttab_allocate_macro
    
    	;итд




    - - - Добавлено - - -


    АХТУНХ то что названо "page"
    есть нечто длинной 256 байт
    и с начальным адресом кратным 256
    которых у z80 целых 256 штук



    и собственно непонятно
    почему такого всегда нужного функционала
    нет не в одном? компиляторе




    в атаче сорец
    и z80 подсветка для npp
    Вложения Вложения
    Последний раз редактировалось NEO SPECTRUMAN; 30.03.2020 в 05:28.

  2. Этот пользователь поблагодарил NEO SPECTRUMAN за это полезное сообщение:

    Barmaley_m (30.03.2020)

  3. #1
    С любовью к вам, Yandex.Direct
    Размещение рекламы на форуме способствует его дальнейшему развитию

  4. #2
    Member
    Регистрация
    10.05.2019
    Адрес
    Prague, Czech Republic
    Сообщений
    103
    Спасибо Благодарностей отдано 
    14
    Спасибо Благодарностей получено 
    37
    Поблагодарили
    26 сообщений
    Mentioned
    1 Post(s)
    Tagged
    0 Thread(s)

    По умолчанию

    That's kinda long... ... I will maybe try one day to better understand what you did, but for the moment I'm just glad it works for you.

  5. #3
    Guru Аватар для NEO SPECTRUMAN
    Регистрация
    22.05.2011
    Адрес
    Дзержинск
    Сообщений
    4,043
    Спасибо Благодарностей отдано 
    157
    Спасибо Благодарностей получено 
    224
    Поблагодарили
    183 сообщений
    Mentioned
    3 Post(s)
    Tagged
    0 Thread(s)

    По умолчанию

    в процессе обильного использования
    понял что жестко протупил
    и что все xxxxx_end_macro
    нужно заменить на
    end_xxxxx_macro

  6. #4
    Guru Аватар для NEO SPECTRUMAN
    Регистрация
    22.05.2011
    Адрес
    Дзержинск
    Сообщений
    4,043
    Спасибо Благодарностей отдано 
    157
    Спасибо Благодарностей получено 
    224
    Поблагодарили
    183 сообщений
    Mentioned
    3 Post(s)
    Tagged
    0 Thread(s)

    По умолчанию

    А вот результат утрамбовки нескольких "быстрых" таблиц и отдельных участков кода в одну кучу


    конечно отлаживать код который каждый раз в новом месте
    это "одно удовольствие"

    видимо без экспорта меток теперь никак

    ...
    и да как выяснилось
    lua-льные генераторы таблиц
    внутри lua-льного утрамбовщика
    правильно неработают...
    Последний раз редактировалось NEO SPECTRUMAN; 20.07.2019 в 05:01.

  7. #5
    Guru Аватар для Shiny
    Регистрация
    19.01.2017
    Адрес
    г. Арзамас
    Сообщений
    2,119
    Записей в дневнике
    36
    Спасибо Благодарностей отдано 
    0
    Спасибо Благодарностей получено 
    14
    Поблагодарили
    7 сообщений
    Mentioned
    3 Post(s)
    Tagged
    0 Thread(s)

    По умолчанию

    неясен смысл телодвижений

  8. #6
    Guru Аватар для NEO SPECTRUMAN
    Регистрация
    22.05.2011
    Адрес
    Дзержинск
    Сообщений
    4,043
    Спасибо Благодарностей отдано 
    157
    Спасибо Благодарностей получено 
    224
    Поблагодарили
    183 сообщений
    Mentioned
    3 Post(s)
    Tagged
    0 Thread(s)

    По умолчанию

    Цитата Сообщение от Shiny Посмотреть сообщение
    неясен смысл телодвижений
    выигрыш 15 тактов на каждом табличном переходе

    в если за фрейм у меня их штух 700
    то выходит +10500t на фрейм
    Последний раз редактировалось NEO SPECTRUMAN; 20.07.2019 в 14:45.

  9. #7
    Guru Аватар для NEO SPECTRUMAN
    Регистрация
    22.05.2011
    Адрес
    Дзержинск
    Сообщений
    4,043
    Спасибо Благодарностей отдано 
    157
    Спасибо Благодарностей получено 
    224
    Поблагодарили
    183 сообщений
    Mentioned
    3 Post(s)
    Tagged
    0 Thread(s)

    По умолчанию

    Цитата Сообщение от Shiny Посмотреть сообщение
    неясен смысл телодвижений
    кроме того
    вот например
    код автоматически разложен вокруг и под экранным буфером
    без использования ручек (за раннее помечен буфер с запасом как занимающий место)


    - - - Добавлено - - -

    правда время компиляции с 0.140 сек увеличилось до 17.453...
    Последний раз редактировалось NEO SPECTRUMAN; 20.07.2019 в 19:08.

  10. #8
    Guru Аватар для NEO SPECTRUMAN
    Регистрация
    22.05.2011
    Адрес
    Дзержинск
    Сообщений
    4,043
    Спасибо Благодарностей отдано 
    157
    Спасибо Благодарностей получено 
    224
    Поблагодарили
    183 сообщений
    Mentioned
    3 Post(s)
    Tagged
    0 Thread(s)

    По умолчанию

    небольшой update
    Выпилены отладочные print-ы чтоб ускорить компиляцию
    пофикшены найденные в процессе эксплуатации баги


    старая версия!

    Код:
    		device zxspectrum128
    
    ;==============================================================================
    ; ALLOCATE DATA PROCEDURES r0005
    ; by NS									  2019
    ;==============================================================================
    ;							...some greets to Ped7g
    ;==============================================================================
    
    ;------------------------------------------------------------------------------
    						lua allpass
    --PAGES FOR ALLOCATE
    	lua_code_allocator_start_page = 0x80	--0x90
    	lua_code_allocator_end_page = 0x8F
    
    --ERRORS
    	lua_org_overwrite_error_stop = 1
    						endlua
    ;------------------------------------------------------------------------------
    ;MEMORY INIT
    						lua pass1
    						lua_code_allocator_array = {}
    						endlua
    ; принЯтое представление памЯти
    ;
    ;		 up
    ;	0000,0100...FE00,FF00
    ;	0001,0101...FE01,FF01
    ; left	.....................  right
    ;	00FE,01FE...FEFE,FFFE
    ;	00FF,01FF...FEFF,FFFF
    ;		down
    ;
    ;------------------------------------------------------------------------------
    						lua allpass
    	--all memory free
    	for temp_byte_cnt = 0x0000, 0xFFFF, 1 do
    	lua_code_allocator_array[temp_byte_cnt] = 1
    	end
    		--ROM 
    		for temp_byte_cnt = 0x0000, 0x3FFF, 1 do
    		lua_code_allocator_array[temp_byte_cnt] = 0
    		end
    		----some code protect
    		--for temp_byte_cnt = 0x9000, 0x91FF, 1 do
    		--lua_code_allocator_array[temp_byte_cnt] = 0
    		--end
    	
    						endlua
    						
    ;==============================================================================
    ; FAST TAB - генерациЯ быстрых таблиц переходов и утрамбовывание процедур
    ;						с выравниванием по левому краю
    ;
    ;	fasttab_allocate_macro tab_haddr,procedure_number
    ;	code\data...
    ;	end_fasttab_allocate_macro
    ;------------------------------------------------------------------------------
    ; FAST TAB RIGHT - генерациЯ быстрых таблиц переходов и утрамбовывание процедур
    ;						с выравниванием по правому краю
    ;
    ;	fasttabright_allocate_macro tab_haddr,procedure_number
    ;	code\data...
    ;	end_fasttabright_allocate_macro
    ;------------------------------------------------------------------------------
    ; FAST TAB USING
    ;	ld a,l		;4	;ld a,l
    ;	ld h,tab_haddr	;7	;ld h,tab_haddr
    ;	ld h,(hl)	;7	;ld h,(hl)
    ;	jp (hl)		;4	;dup 32 : ldi : edup
    ;			;22t	:
    ;------------------------------------------------------------------------------
    ; TAMP LEFT - утрамбовывание кода в найденное свободное место
    ;						с выравниванием по левому верхнему краю
    ;	tampleft_allocate_macro
    ;	code\data...
    ;	end_tampleft_allocate_macro
    ;------------------------------------------------------------------------------
    ; TAMP RIGHT - утрамбовывание кода в найденное свободное место
    ;						с выравниванием по правому нижнему краю
    ;	tampright_allocate_macro
    ;	code\data...
    ;	end_tampright_allocate_macro
    ;------------------------------------------------------------------------------
    ; TAMP LEFT ALIGN 256 - утрамбовывание кода в найденное свободное место
    ;						с выравниванием по кратному 256 адресу
    ;						с выравниванием по левому верхнему краю
    ;	tampleft_align256_allocate_macro
    ;	code\data...
    ;	end_tampleft_align256_allocate_macro
    ;------------------------------------------------------------------------------
    ; TAMP RIGHT ALIGN 256 - утрамбовывание кода в найденное свободное место
    ;						с выравниванием по кратному 256 адресу
    ;						с выравниванием по правому верхнему краю
    ;	tampright_align256_allocate_macro
    ;	code\data...
    ;	end_tampright_align256_allocate_macro
    ;------------------------------------------------------------------------------
    ; ORG - запихивание кода по указанному адресу с маркировкой занЯтого места
    ;						с предупреждением при перезаписи данных
    ;						и опциональной остановкой компилЯции
    ;	org_allocate_macro addr
    ;	code\data...
    ;	end_org_allocate_macro
    ;==============================================================================
    
    
    
    
    	
    
    
    
    ;------------------------------------------------------------------------------
    ;INIT SOME ARRAYS
    
    ;FAST TAB INIT
    	lua pass1
    			lua_fasttab_allocate_procedure_start_addr = {}
    				for temp_cnt = 0,255,1 do
    				lua_fasttab_allocate_procedure_start_addr[temp_cnt] = {}
    				end
    			lua_fasttab_allocate_end_addr = {}
    				for temp_cnt = 0,255,1 do
    				lua_fasttab_allocate_end_addr[temp_cnt] = {}
    				end
    	endlua
    ;FAST TAB RIGHT INIT
    	lua pass1
    			lua_fasttabright_allocate_procedure_start_addr = {}
    				for temp_cnt = 0,255,1 do
    				lua_fasttabright_allocate_procedure_start_addr[temp_cnt] = {}
    				end
    			lua_fasttabright_allocate_end_addr = {}
    				for temp_cnt = 0,255,1 do
    				lua_fasttabright_allocate_end_addr[temp_cnt] = {}
    				end
    	endlua
    ;ORG DATA INIT
    	lua pass1
    			lua_org_allocate_procedure_start_addr = {}
    			lua_org_allocate_end_addr = {}
    	endlua
    	lua allpass
    			lua_org_procedure_count = 0
    	endlua
    ;TAMP_LEFT DATA INIT
    	lua pass1
    			lua_tampleft_allocate_procedure_start_addr = {}
    			lua_tampleft_allocate_end_addr = {}
    	endlua
    	lua allpass
    			lua_tampleft_procedure_count = 0
    	endlua
    ;TAMP_LEFT ALIGN 256 DATA INIT
    	lua pass1
    			lua_tampleft_align256_allocate_procedure_start_addr = {}
    			lua_tampleft_align256_allocate_end_addr = {}
    	endlua
    	lua allpass
    			lua_tampleft_align256_procedure_count = 0
    	endlua
    ;TAMP_RIGHT DATA INIT
    	lua pass1
    			lua_tampright_allocate_procedure_start_addr = {}
    			lua_tampright_allocate_end_addr = {}
    	endlua
    	lua allpass
    			lua_tampright_procedure_count = 0
    	endlua
    ;TAMP_RIGHT ALIGN 256 DATA INIT
    	lua pass1
    			lua_tampright_align256_allocate_procedure_start_addr = {}
    			lua_tampright_align256_allocate_end_addr = {}
    	endlua
    	lua allpass
    			lua_tampright_align256_procedure_count = 0
    	endlua
    ;------------------------------------------------------------------------------
    ;FAST TAB 8P INIT
    	lua pass1
    			lua_fasttab_8p_allocate_procedure_start_addr = {}
    				for temp_cnt = 0,255,1 do
    				lua_fasttab_8p_allocate_procedure_start_addr[temp_cnt] = {}
    				end
    			lua_fasttab_8p_allocate_end_addr = {}
    				for temp_cnt = 0,255,1 do
    				lua_fasttab_8p_allocate_end_addr[temp_cnt] = {}
    				end
    	endlua
    ;------------------------------------------------------------------------------	
    ;------------------------------------------------------------------------------
    	
    	display "============================================================================="
    	display "LAST PASS!!!!"
    	display "============================================================================="
    
    ;==============================================================================
    ;==============================================================================
    
    
    
    
    ;==============================================================================
    ; FAST TAB
    ;==============================================================================
    ;FAST TAB macro
    						;по окончанию PASS2 уже установлен новый org!
    	macro fasttab_allocate_macro _fasttab_alloc_table_haddr?, _fasttab_alloc_procedure_number?
    								
    @__fasttab_allocate_table_haddr = _fasttab_alloc_table_haddr?
    @__fasttab_allocate_procedure_number = _fasttab_alloc_procedure_number?
    								
    		lua pass1
    								
    		lua_fasttab_allocate_procedure_start_addr[(_c("__fasttab_allocate_table_haddr"))][(_c("__fasttab_allocate_procedure_number"))] = _c("$")	
    									
    		endlua
    		lua allpass
    		lua_function_fasttab_allocate((_c("__fasttab_allocate_table_haddr")),(_c("__fasttab_allocate_procedure_number")))
    		endlua
    		
    		lua pass2	;copy
    		if lua_fasttab_allocator_page_finded == 1 then
    								
    			_pc(string.format("org $%04x", _c("__fasttab_allocate_table_haddr * 256") + (_c("__fasttab_allocate_procedure_number"))))
    								
    			_pc(string.format("defb $%02x", lua_fasttab_allocator_new_h_org))
    								
    			_pc(string.format("org $%04x", lua_fasttab_allocator_new_h_org*256 + (_c("__fasttab_allocate_procedure_number"))))
    		end 
    		endlua
    		lua pass3	;
    		if lua_fasttab_allocator_page_finded == 1 then
    								
    			_pc(string.format("org $%04x", _c("__fasttab_allocate_table_haddr * 256") + (_c("__fasttab_allocate_procedure_number"))))
    								
    			_pc(string.format("defb $%02x", lua_fasttab_allocator_new_h_org))
    								
    			_pc(string.format("org $%04x", lua_fasttab_allocator_new_h_org*256 + (_c("__fasttab_allocate_procedure_number"))))
    		end 
    		endlua
    	endm
    	
    ;------------------------------------------------------------------------------
    	
    		macro end_fasttab_allocate_macro
    		lua pass1
    								
    		lua_fasttab_allocate_end_addr[(_c("__fasttab_allocate_table_haddr"))][(_c("__fasttab_allocate_procedure_number"))] = _c("$")
    		--lua_fasttab_allocate_end_addr[lua_fasttab_table_haddr][lua_fasttab_procedure_number] = _c("$")
    								
    		endlua
    		lua allpass
    		lua_function_fasttab_allocate_end(_c("__fasttab_allocate_procedure_number"))
    		endlua
    	endm
    
    ;------------------------------------------------------------------------------
    ;FAST TAB lua
    
            lua allpass
    	
    	function lua_function_fasttab_allocate(lua_fasttab_table_haddr,lua_fasttab_procedure_number)
    								
    		fasttab_allocate_size = (lua_fasttab_allocate_end_addr[(_c("__fasttab_allocate_table_haddr"))][(_c("__fasttab_allocate_procedure_number"))]-lua_fasttab_allocate_procedure_start_addr[(_c("__fasttab_allocate_table_haddr"))][(_c("__fasttab_allocate_procedure_number"))])
    								
    			--free page search
    			lua_fasttab_allocator_page_finded = 0
    			fasttab_allocator_page_free_bytes = 1
    
    			for fasttab_allocator_page_search = lua_code_allocator_start_page, lua_code_allocator_end_page, 1 do
    				if lua_fasttab_allocator_page_finded == 0 then
    								
    				fasttab_allocator_page_free_bytes = 1
    								
    					for fasttab_allocator_byte_scan = ((fasttab_allocator_page_search*256) + lua_fasttab_procedure_number), ((fasttab_allocator_page_search*256) + lua_fasttab_procedure_number + fasttab_allocate_size - 1), 1 do
    								
    						if lua_code_allocator_array[fasttab_allocator_byte_scan] == 0 then
    							-- страница занЯта
    							fasttab_allocator_page_free_bytes = 0
    							--break
    						end
    					end
    				end
    				if lua_fasttab_allocator_page_finded == 0 then
    					if fasttab_allocator_page_free_bytes == 1 then
    								
    						for fasttab_allocator_byte_fill = ((fasttab_allocator_page_search*256) + lua_fasttab_procedure_number), ((fasttab_allocator_page_search*256) + fasttab_allocate_size + lua_fasttab_procedure_number - 1), 1 do
    						-- очистка свободных страниц
    						lua_code_allocator_array[fasttab_allocator_byte_fill] = 0
    								
    						end
    			
    					lua_fasttab_allocator_page_finded = 1
    					lua_fasttab_allocator_new_h_org = fasttab_allocator_page_search
    								
    						if (lua_code_allocator_start_page*256) > ((fasttab_allocator_page_search*256) + lua_fasttab_procedure_number) then
    							sj.error("OUT OF MEMORY !!!!!!!!!!!!!!!!!!!!!11111")
    							print ("FAST TAB")
    							print ("new_org < (lua_code_allocator_start_page*256)")
    							print (string.format("in procedure = $%02x",lua_fasttab_procedure_number))
    							print (string.format("table = $%02x",lua_fasttab_table_haddr))
    							sj.exit()
    						end
    						if ((lua_code_allocator_end_page*256)+255) < ((fasttab_allocator_page_search*256) + fasttab_allocate_size + lua_fasttab_procedure_number - 1) then
    							sj.error("OUT OF MEMORY !!!!!!!!!!!!!!!!!!!!!11111")
    							print ("FAST TAB")
    							print("new_org > ((lua_code_allocator_end_page*256)+255)")
    							print (string.format("in procedure = $%02x",lua_fasttab_procedure_number))
    							print (string.format("table = $%02x",lua_fasttab_table_haddr))
    							sj.exit()
    						end
    					end
    				end
    			end
    			if lua_fasttab_allocator_page_finded == 0 then
    				if fasttab_allocator_page_free_bytes == 0 then
    					sj.error("FREE PAGE NOT FOUND !!!!!!!!!!!!!!!!!!!!!11111")
    							print ("FAST TAB")
    							print (string.format("procedure = $%02x",lua_fasttab_procedure_number))
    							print (string.format("table = $%02x",lua_fasttab_table_haddr))
    							sj.exit()
    				end
    			end
    			if lua_fasttab_allocator_page_finded == 0 then
    				if fasttab_allocator_page_free_bytes == 1 then
    					sj.error("FREE PAGE NOT FOUND !!!!!!!!!!!!!!!!!!!!!11111")
    							print ("free_bytes = 1")
    							print ("FAST TAB")
    							print (string.format("procedure = $%02x",lua_fasttab_procedure_number))
    							print (string.format("table = $%02x",lua_fasttab_table_haddr))
    							sj.exit()
    				end
    			end
    	end
    
    -- ----------------------------------------------------------------------------
    	
    	function lua_function_fasttab_allocate_end(lua_fasttab_procedure_number)
    								
    	end
    	
    	endlua
    
    ;==============================================================================
    ; FAST TAB RIGHT
    ;==============================================================================
    ;FAST TAB RIGHT macro
    					;по окончанию PASS2 уже установлен новый org!
    	macro fasttabright_allocate_macro _fasttabright_alloc_table_haddr?, _fasttabright_alloc_procedure_number?
    								
    @__fasttabright_allocate_table_haddr = _fasttabright_alloc_table_haddr?
    @__fasttabright_allocate_procedure_number = _fasttabright_alloc_procedure_number?
    								
    				lua pass1		
    								
    		lua_fasttabright_allocate_procedure_start_addr[(_c("__fasttabright_allocate_table_haddr"))][(_c("__fasttabright_allocate_procedure_number"))] = _c("$")	
    								
    		endlua
    		lua allpass
    		lua_function_fasttabright_allocate((_c("__fasttabright_allocate_table_haddr")),(_c("__fasttabright_allocate_procedure_number")))
    		endlua
    		
    		lua pass2	;copy
    		if lua_fasttabright_allocator_page_finded == 1 then
    								
    			_pc(string.format("org $%04x", _c("__fasttabright_allocate_table_haddr * 256") + (_c("__fasttabright_allocate_procedure_number"))))
    								
    			_pc(string.format("defb $%02x", lua_fasttabright_allocator_new_h_org))
    								
    			_pc(string.format("org $%04x", lua_fasttabright_allocator_new_h_org*256 + (_c("__fasttabright_allocate_procedure_number"))))
    		end 
    		endlua
    		lua pass3	;
    		if lua_fasttabright_allocator_page_finded == 1 then
    								
    			_pc(string.format("org $%04x", _c("__fasttabright_allocate_table_haddr * 256") + (_c("__fasttabright_allocate_procedure_number"))))
    								
    			_pc(string.format("defb $%02x", lua_fasttabright_allocator_new_h_org))
    								
    			_pc(string.format("org $%04x", lua_fasttabright_allocator_new_h_org*256 + (_c("__fasttabright_allocate_procedure_number"))))
    		end 
    		endlua
    	endm
    	
    ;------------------------------------------------------------------------------
    	
    		macro end_fasttabright_allocate_macro
    		lua pass1
    								
    		lua_fasttabright_allocate_end_addr[(_c("__fasttabright_allocate_table_haddr"))][(_c("__fasttabright_allocate_procedure_number"))] = _c("$")
    		--lua_fasttabright_allocate_end_addr[lua_fasttabright_table_haddr][lua_fasttabright_procedure_number] = _c("$")
    								
    		endlua
    		lua allpass
    		lua_function_fasttabright_allocate_end(_c("__fasttabright_allocate_procedure_number"))
    		endlua
    	endm
    
    ;------------------------------------------------------------------------------
    ;FAST TAB RIGHT lua
    
            lua allpass
    	
    	function lua_function_fasttabright_allocate(lua_fasttabright_table_haddr,lua_fasttabright_procedure_number)
    								
    		fasttabright_allocate_size = (lua_fasttabright_allocate_end_addr[(_c("__fasttabright_allocate_table_haddr"))][(_c("__fasttabright_allocate_procedure_number"))]-lua_fasttabright_allocate_procedure_start_addr[(_c("__fasttabright_allocate_table_haddr"))][(_c("__fasttabright_allocate_procedure_number"))])
    								
    			--free page search
    			lua_fasttabright_allocator_page_finded = 0
    			fasttabright_allocator_page_free_bytes = 1
    
    			for fasttabright_allocator_page_search = lua_code_allocator_end_page, lua_code_allocator_start_page, -1 do
    				if lua_fasttabright_allocator_page_finded == 0 then
    								
    				fasttabright_allocator_page_free_bytes = 1
    								
    					for fasttabright_allocator_byte_scan = ((fasttabright_allocator_page_search*256) + lua_fasttabright_procedure_number), ((fasttabright_allocator_page_search*256) + lua_fasttabright_procedure_number + fasttabright_allocate_size - 1), 1 do
    								
    						if lua_code_allocator_array[fasttabright_allocator_byte_scan] == 0 then
    							-- страница занЯта
    							
    							fasttabright_allocator_page_free_bytes = 0
    							--break
    						end
    					end
    				end
    				if lua_fasttabright_allocator_page_finded == 0 then
    					if fasttabright_allocator_page_free_bytes == 1 then
    								
    						for fasttabright_allocator_byte_fill = ((fasttabright_allocator_page_search*256) + lua_fasttabright_procedure_number), ((fasttabright_allocator_page_search*256) + fasttabright_allocate_size + lua_fasttabright_procedure_number - 1), 1 do
    						-- очистка свободных страниц
    						lua_code_allocator_array[fasttabright_allocator_byte_fill] = 0
    								
    						end
    			
    					lua_fasttabright_allocator_page_finded = 1
    					lua_fasttabright_allocator_new_h_org = fasttabright_allocator_page_search
    								
    						if (lua_code_allocator_start_page*256) > ((fasttabright_allocator_page_search*256) + lua_fasttabright_procedure_number) then
    							sj.error("OUT OF MEMORY !!!!!!!!!!!!!!!!!!!!!11111")
    							print ("FAST TAB RIGHT")
    							print ("new_org < (lua_code_allocator_start_page*256)")
    							print (string.format("in procedure = $%02x",lua_fasttabright_procedure_number))
    							print (string.format("table = $%02x",lua_fasttabright_table_haddr))
    							sj.exit()
    						end
    						if ((lua_code_allocator_end_page*256)+255) < ((fasttabright_allocator_page_search*256) + fasttabright_allocate_size + lua_fasttabright_procedure_number - 1) then
    							sj.error("OUT OF MEMORY !!!!!!!!!!!!!!!!!!!!!11111")
    							print ("FAST TAB RIGHT")
    							print("new_org > ((lua_code_allocator_end_page*256)+255)")
    							print (string.format("in procedure = $%02x",lua_fasttabright_procedure_number))
    							print (string.format("table = $%02x",lua_fasttabright_table_haddr))
    							sj.exit()
    						end
    					end
    				end
    			end
    			if lua_fasttabright_allocator_page_finded == 0 then
    				if fasttabright_allocator_page_free_bytes == 0 then
    					sj.error("FREE PAGE NOT FOUND !!!!!!!!!!!!!!!!!!!!!11111")
    							print ("FAST TAB RIGHT")
    							print (string.format("procedure = $%02x",lua_fasttabright_procedure_number))
    							print (string.format("table = $%02x",lua_fasttabright_table_haddr))
    							sj.exit()
    				end
    			end
    			if lua_fasttabright_allocator_page_finded == 0 then
    				if fasttabright_allocator_page_free_bytes == 1 then
    					sj.error("FREE PAGE NOT FOUND !!!!!!!!!!!!!!!!!!!!!11111")
    							print ("free_bytes = 1")
    							print ("FAST TAB RIGHT")
    							print (string.format("procedure = $%02x",lua_fasttabright_procedure_number))
    							print (string.format("table = $%02x",lua_fasttabright_table_haddr))
    							sj.exit()
    				end
    			end
    	end
    
    -- ----------------------------------------------------------------------------
    	
    	function lua_function_fasttabright_allocate_end(lua_fasttabright_procedure_number)
    								
    	end
    	endlua
    
    ;==============================================================================
    ; ORG
    ;==============================================================================
    ;ORG macro
    					
    	macro org_allocate_macro _org_alloc_addr?
    		
    @__org_allocate_addr = _org_alloc_addr?
    
    		lua pass1				
    		lua_org_allocate_procedure_start_addr[lua_org_procedure_count] = _c("$")
    								
    		endlua
    		
    		lua allpass
    								
    		lua_function_org_allocate (_c("__org_allocate_addr"))
    								
    		endlua
    		
    		lua pass2	;
    		if lua_org_allocator_addr_finded == 1 then
    								
    			_pc(string.format("org $%04x", lua_org_allocator_new_org))
    		end 
    		endlua
    		lua pass3	;
    		if lua_org_allocator_addr_finded == 1 then
    								
    			_pc(string.format("org $%04x", lua_org_allocator_new_org))
    		end 
    		endlua
    	endm
    
    ;------------------------------------------------------------------------------
    
    		macro end_org_allocate_macro
    		lua pass1
    								
    		lua_org_allocate_end_addr[lua_org_procedure_count] = (_c("$"))
    								
    		endlua
    		
    		lua allpass
    		lua_function_org_allocate_end(1)
    		
    		lua_org_procedure_count = lua_org_procedure_count + 1
    		endlua
    	endm
    
    ;------------------------------------------------------------------------------
    ;ORG lua
    
            lua allpass
    	
    	function lua_function_org_allocate(lua_org_allocate_addr)
    								
    		org_allocate_size = (lua_org_allocate_end_addr[lua_org_procedure_count] - lua_org_allocate_procedure_start_addr[lua_org_procedure_count])
    								
    			--free page search
    			lua_org_allocator_addr_finded = 0
    			org_allocator_free_bytes = 1
    			
    					lua_org_allocator_addr_finded = 0
    					org_allocator_free_bytes = 1
    					
    					if lua_org_allocator_addr_finded == 0 then
    					for org_allocator_byte_scan = lua_org_allocate_addr, (lua_org_allocate_addr + org_allocate_size - 1), 1 do
    								
    						if lua_code_allocator_array[org_allocator_byte_scan] == 0 then
    						org_allocator_free_bytes = 0
    						end
    					end
    							if org_allocator_free_bytes == 0 then
    								sj.error("ORG DATA OVERWRITE!!!!!!!!!!!!!!!!!!!!!!!!!!")
    								sj.warning("ORG DATA OVERWRITE!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
    								print("new_org > ((lua_code_allocator_end_page*256)+255)")
    								print("procedure = ",lua_org_procedure_count)
    									if lua_org_overwrite_error_stop == 1 then
    										sj.exit()
    									end
    							end
    								
    							for org_allocator_byte_fill = lua_org_allocate_addr,(lua_org_allocate_addr + org_allocate_size - 1), 1 do
    								
    							-- очистка свободной памЯти
    							lua_code_allocator_array[org_allocator_byte_fill] = 0
    							end
    				
    						lua_org_allocator_addr_finded = 1
    						lua_org_allocator_new_org = lua_org_allocate_addr
    					end
    	end
    	
    -- ----------------------------------------------------------------------------
    	
    	function lua_function_org_allocate_end(temp)
    								
    	end
    		
    	endlua
    
    ;==============================================================================
    ; TAMP LEFT
    ;==============================================================================
    ;TAMP LEFT macro
    				
    	macro tampleft_allocate_macro
    		
    		lua pass1				
    		lua_tampleft_allocate_procedure_start_addr[lua_tampleft_procedure_count] = _c("$")
    								
    		endlua
    		
    		lua allpass
    								
    		lua_function_tampleft_allocate (0)
    								
    		endlua
    		
    		lua pass2	;
    		if lua_tampleft_allocator_addr_finded == 1 then
    								
    			_pc(string.format("org $%04x", lua_tampleft_allocator_new_org))
    		end 
    		endlua
    		lua pass3	;
    		if lua_tampleft_allocator_addr_finded == 1 then
    								
    			_pc(string.format("org $%04x", lua_tampleft_allocator_new_org))
    		end 
    		endlua
    	endm
    
    ;------------------------------------------------------------------------------
    
    		macro end_tampleft_allocate_macro
    		lua pass1
    								
    		lua_tampleft_allocate_end_addr[lua_tampleft_procedure_count] = (_c("$"))
    								
    		endlua
    		
    		lua allpass
    		lua_function_tampleft_allocate_end(1)
    		
    		lua_tampleft_procedure_count = lua_tampleft_procedure_count + 1
    		endlua
    	endm
    
    ;------------------------------------------------------------------------------
    ;TAMP left lua
    
            lua allpass
    	
    	function lua_function_tampleft_allocate(temp)
    								
    		tampleft_allocate_size = (lua_tampleft_allocate_end_addr[lua_tampleft_procedure_count] - lua_tampleft_allocate_procedure_start_addr[lua_tampleft_procedure_count])
    								
    			--free page search
    			lua_tampleft_allocator_addr_finded = 0
    			tampleft_allocator_free_bytes = 1
    								
    				for tampleft_allocator_addr_search = (lua_code_allocator_start_page*256),((lua_code_allocator_end_page*256)+255), 1 do
    
    					if lua_tampleft_allocator_addr_finded == 0 then
    						tampleft_allocator_free_bytes = 1
    								
    						for tampleft_allocator_byte_scan = (tampleft_allocator_addr_search), (tampleft_allocator_addr_search + tampleft_allocate_size - 1), 1 do
    								
    						if lua_code_allocator_array[tampleft_allocator_byte_scan] == 0 then
    						tampleft_allocator_free_bytes = 0
    						end
    						end
    					end
    					
    					if lua_tampleft_allocator_addr_finded == 0 then
    						if tampleft_allocator_free_bytes == 1 then
    								
    							for tampleft_allocator_byte_fill = (tampleft_allocator_addr_search),(tampleft_allocator_addr_search + tampleft_allocate_size -1), 1 do
    								
    							-- очистка свободной памЯти
    							lua_code_allocator_array[tampleft_allocator_byte_fill] = 0
    							end
    				
    						lua_tampleft_allocator_addr_finded = 1
    			
    						lua_tampleft_allocator_new_org = (tampleft_allocator_addr_search)
    								
    							if lua_tampleft_allocator_new_org > ((lua_code_allocator_end_page*256)+255) then
    								sj.error("OUT OF MEMORY !!!!!!!!!!!!!!!!!!!!!11111")
    								print ("TAMP LEFT")
    								print("new_org > ((lua_code_allocator_end_page*256)+255)")
    								print("in procedure = ",lua_tampleft_procedure_count)
    								sj.exit()
    							end
    							if (tampleft_allocator_addr_search + tampleft_allocate_size -1) > ((lua_code_allocator_end_page*256)+255) then
    								sj.error("OUT OF MEMORY !!!!!!!!!!!!!!!!!!!!!11111")
    								print ("TAMP LEFT")
    								print("new_org+size > ((lua_code_allocator_end_page*256)+255)")
    								print("in procedure = ",lua_tampleft_procedure_count)
    								sj.exit()
    							end
    							if lua_tampleft_allocator_new_org < (lua_code_allocator_start_page*256) then
    								sj.error("BUG?")
    								print ("TAMP LEFT")
    								print("new_org < (lua_code_allocator_start_page*256)")
    								print("in procedure = ",lua_tampleft_procedure_count)
    								sj.exit()
    							end
    						end
    					end
    				end
    				
    				if lua_tampleft_allocator_addr_finded == 0 then
    					if tampleft_allocator_free_bytes == 0 then
    						sj.error("FREE BYTES NOT FOUND o_O !!!!!!!!!!!!!!!!!!!!!11111")
    							print ("TAMP LEFT")
    							print("procedure = ",lua_tampleft_procedure_count)
    							sj.exit()
    					end
    				end
    				if lua_tampleft_allocator_addr_finded == 0 then
    					if tampleft_allocator_free_bytes == 1 then
    						sj.error("FREE BYTES NOT FOUND o_O !!!!!!!!!!!!!!!!!!!!!11111")
    							print ("free_bytes = 1")
    							print ("TAMP LEFT")
    							print("procedure = ",lua_tampleft_procedure_count)
    							sj.exit()
    					end
    				end
    	end
    
    -- ----------------------------------------------------------------------------
    	
    	function lua_function_tampleft_allocate_end(temp)
    								
    	end
    	endlua
    
    ;==============================================================================
    ; TAMP LEFT ALIGN 256
    ;==============================================================================
    ;TAMP LEFT ALIGN 256 macro
    					
    	macro tampleft_align256_allocate_macro
    		
    		lua pass1				
    		lua_tampleft_align256_allocate_procedure_start_addr[lua_tampleft_align256_procedure_count] = _c("$")
    								
    		endlua
    		
    		lua allpass
    								
    		lua_function_tampleft_align256_allocate (0)
    								
    		endlua
    		
    		lua pass2	;
    		if lua_tampleft_align256_allocator_addr_finded == 1 then
    								
    			_pc(string.format("org $%04x", lua_tampleft_align256_allocator_new_org))
    		end 
    		endlua
    		lua pass3	;
    		if lua_tampleft_align256_allocator_addr_finded == 1 then
    								
    			_pc(string.format("org $%04x", lua_tampleft_align256_allocator_new_org))
    		end 
    		endlua
    	endm
    
    ;------------------------------------------------------------------------------
    
    		macro end_tampleft_align256_allocate_macro
    		lua pass1	
    								
    		lua_tampleft_align256_allocate_end_addr[lua_tampleft_align256_procedure_count] = (_c("$"))
    								
    		endlua
    		
    		lua allpass
    		lua_function_tampleft_align256_allocate_end(1)
    		
    		lua_tampleft_align256_procedure_count = lua_tampleft_align256_procedure_count + 1
    		endlua
    	endm
    
    ;------------------------------------------------------------------------------
    ;TAMP LEFT ALIGN 256 lua
    
            lua allpass
    	
    	function lua_function_tampleft_align256_allocate(temp)
    								
    		tampleft_align256_allocate_size = (lua_tampleft_align256_allocate_end_addr[lua_tampleft_align256_procedure_count] - lua_tampleft_align256_allocate_procedure_start_addr[lua_tampleft_align256_procedure_count])
    								
    			--free page search
    			lua_tampleft_align256_allocator_addr_finded = 0
    			tampleft_align256_allocator_free_bytes = 1
    								
    				for tampleft_align256_allocator_addr_search = (lua_code_allocator_start_page*256), (lua_code_allocator_end_page*256), 256 do
    
    					if lua_tampleft_align256_allocator_addr_finded == 0 then
    						tampleft_align256_allocator_free_bytes = 1
    								
    						for tampleft_align256_allocator_byte_scan = tampleft_align256_allocator_addr_search,((tampleft_align256_allocator_addr_search + tampleft_align256_allocate_size)-1), 1 do
    								
    						if lua_code_allocator_array[tampleft_align256_allocator_byte_scan] == 0 then
    						tampleft_align256_allocator_free_bytes = 0
    						end
    						end
    					end
    					
    					if lua_tampleft_align256_allocator_addr_finded == 0 then
    						if tampleft_align256_allocator_free_bytes == 1 then
    								if (tampleft_align256_allocator_addr_search + tampleft_align256_allocate_size-1) < ((lua_code_allocator_end_page*256)+256) then
    									
    							for tampleft_align256_allocator_byte_fill = tampleft_align256_allocator_addr_search,((tampleft_align256_allocator_addr_search + tampleft_align256_allocate_size)-1), 1 do
    									
    							-- очистка свободной памЯти
    							lua_code_allocator_array[tampleft_align256_allocator_byte_fill] = 0
    							end
    				
    						lua_tampleft_align256_allocator_addr_finded = 1
    			
    						lua_tampleft_align256_allocator_new_org = tampleft_align256_allocator_addr_search
    									
    							if lua_tampleft_align256_allocator_new_org < (lua_code_allocator_start_page*256) then
    								sj.error("OUT OF MEMORY !!!!!!!!!!!!!!!!!!!!!11111")
    								print ("TAMP LEFT ALIGN 256")
    								print("new_org < (lua_code_allocator_start_page*256)")
    								print("in procedure = ",lua_tampleft_align256_procedure_count)
    								sj.exit()
    							end
    							if lua_tampleft_align256_allocator_new_org > ((lua_code_allocator_end_page*256)+255) then
    								sj.error("BUG?")
    								print ("TAMP LEFT ALIGN 256")
    								print("new_org > ((lua_code_allocator_end_page*256)+255)")
    								print("in procedure = ",lua_tampleft_align256_procedure_count)
    								sj.exit()
    							end
    							if ((lua_tampleft_align256_allocator_new_org+tampleft_align256_allocate_size)-1) > ((lua_code_allocator_end_page*256)+255) then
    								sj.error("OUT OF MEMORY !!!!!!!!!!!!!!!!!!!!!11111")
    								print ("TAMP LEFT ALIGN 256")
    								print("new_org+size > ((lua_code_allocator_end_page*256)+255)")
    								print("in procedure = ",lua_tampleft_align256_procedure_count)
    								sj.exit()
    							end
    								end
    						end
    					end
    				end
    				
    				if lua_tampleft_align256_allocator_addr_finded == 0 then
    					if tampleft_align256_allocator_free_bytes == 0 then
    						sj.error("FREE BYTES NOT FOUND o_O !!!!!!!!!!!!!!!!!!!!!11111")
    							print ("TAMP LEFT ALIGN 256")
    							
    							print("procedure = ",lua_tampleft_align256_procedure_count)
    							sj.exit()
    					end
    				end
    				if lua_tampleft_align256_allocator_addr_finded == 0 then
    					if tampleft_align256_allocator_free_bytes == 1 then
    					
    						sj.error("FREE BYTES NOT FOUND o_O !!!!!!!!!!!!!!!!!!!!!11111")
    							print ("free_bytes = 1")
    							print ("TAMP LEFT ALIGN 256")
    							
    							print("procedure = ",lua_tampleft_align256_procedure_count)
    							sj.exit()
    					end
    				end			
    	end
    
    -- ----------------------------------------------------------------------------
    	
    	function lua_function_tampleft_align256_allocate_end(temp)
    								
    	end	
    	
    	endlua
    
    ;==============================================================================
    ; TAMP RIGHT
    ;==============================================================================
    ;TAMP RIGHT macro
    				
    	macro tampright_allocate_macro
    		
    		lua pass1				
    		lua_tampright_allocate_procedure_start_addr[lua_tampright_procedure_count] = _c("$")
    								
    		endlua
    		
    		lua allpass
    								
    		lua_function_tampright_allocate (0)
    								
    		endlua
    		
    		lua pass2	;
    		if lua_tampright_allocator_addr_finded == 1 then
    								
    			_pc(string.format("org $%04x", lua_tampright_allocator_new_org))
    		end 
    		endlua
    		lua pass3	;
    		if lua_tampright_allocator_addr_finded == 1 then
    								
    			_pc(string.format("org $%04x", lua_tampright_allocator_new_org))
    		end 
    		endlua
    	endm
    
    ;------------------------------------------------------------------------------
    
    		macro end_tampright_allocate_macro
    		lua pass1	
    								
    		lua_tampright_allocate_end_addr[lua_tampright_procedure_count] = (_c("$"))
    								
    		endlua
    		
    		lua allpass
    		lua_function_tampright_allocate_end(1)
    		
    		lua_tampright_procedure_count = lua_tampright_procedure_count + 1
    		endlua
    	endm
    
    ;------------------------------------------------------------------------------
    ;TAMP RIGHT lua
    
            lua allpass
    	
    	function lua_function_tampright_allocate(temp)
    								
    		tampright_allocate_size = (lua_tampright_allocate_end_addr[lua_tampright_procedure_count] - lua_tampright_allocate_procedure_start_addr[lua_tampright_procedure_count])
    								
    			--free page search
    			lua_tampright_allocator_addr_finded = 0
    			tampright_allocator_free_bytes = 1
    								
    				for tampright_allocator_addr_search = ((lua_code_allocator_end_page*256)+255),(lua_code_allocator_start_page*256), -1 do
    
    					if lua_tampright_allocator_addr_finded == 0 then
    						tampright_allocator_free_bytes = 1
    								
    						for tampright_allocator_byte_scan = tampright_allocator_addr_search,((tampright_allocator_addr_search - tampright_allocate_size)+1), -1 do
    								
    						if lua_code_allocator_array[tampright_allocator_byte_scan] == 0 then
    						tampright_allocator_free_bytes = 0
    						end
    						end
    					end
    					
    					if lua_tampright_allocator_addr_finded == 0 then
    						if tampright_allocator_free_bytes == 1 then
    								
    							for tampright_allocator_byte_fill = tampright_allocator_addr_search,((tampright_allocator_addr_search - tampright_allocate_size)+1), -1 do
    								
    							-- очистка свободной памЯти
    							lua_code_allocator_array[tampright_allocator_byte_fill] = 0
    							end
    				
    						lua_tampright_allocator_addr_finded = 1
    			
    						lua_tampright_allocator_new_org = ((tampright_allocator_addr_search - tampright_allocate_size)+1)
    										
    							if lua_tampright_allocator_new_org < (lua_code_allocator_start_page*256) then
    								sj.error("OUT OF MEMORY !!!!!!!!!!!!!!!!!!!!!11111")
    								print ("TAMP RIGHT")
    								print("new_org < (lua_code_allocator_start_page*256)")
    								print("in procedure = ",lua_tampright_procedure_count)
    								sj.exit()
    							end
    							if lua_tampright_allocator_new_org > ((lua_code_allocator_end_page*256)+255) then
    								sj.error("BUG?")
    								print ("TAMP RIGHT")
    								print("new_org > ((lua_code_allocator_end_page*256)+255)")
    								print("in procedure = ",lua_tampright_procedure_count)
    								sj.exit()
    							end
    						end
    					end
    				end
    				
    				if lua_tampright_allocator_addr_finded == 0 then
    					if tampright_allocator_free_bytes == 0 then
    						sj.error("FREE BYTES NOT FOUND o_O !!!!!!!!!!!!!!!!!!!!!11111")
    							print ("TAMP RIGHT")
    							
    							print("procedure = ",lua_tampright_procedure_count)
    							sj.exit()
    					end
    				end
    				if lua_tampright_allocator_addr_finded == 0 then
    					if tampright_allocator_free_bytes == 1 then
    						sj.error("FREE BYTES NOT FOUND o_O !!!!!!!!!!!!!!!!!!!!!11111")
    							print ("free_bytes = 1")
    							print ("TAMP RIGHT")
    							
    							print("procedure = ",lua_tampright_procedure_count)
    							sj.exit()
    					end
    				end			
    	end
    
    -- ----------------------------------------------------------------------------
    
    	function lua_function_tampright_allocate_end(temp)
    								
    	end
    		
    	endlua
    
    ;==============================================================================
    ; TAMP RIGHT ALIGN 256
    ;==============================================================================
    ;TAMP RIGHT ALIGN 256 macro	
    				
    	macro tampright_align256_allocate_macro
    		
    		lua pass1				
    		lua_tampright_align256_allocate_procedure_start_addr[lua_tampright_align256_procedure_count] = _c("$")
    								
    		endlua
    		
    		lua allpass
    								
    		lua_function_tampright_align256_allocate (0)
    								
    		endlua
    		
    		lua pass2	;
    		if lua_tampright_align256_allocator_addr_finded == 1 then
    								
    			_pc(string.format("org $%04x", lua_tampright_align256_allocator_new_org))
    		end 
    		endlua
    		lua pass3	;
    		if lua_tampright_align256_allocator_addr_finded == 1 then
    								
    			_pc(string.format("org $%04x", lua_tampright_align256_allocator_new_org))
    		end 
    		endlua
    	endm
    
    ;------------------------------------------------------------------------------
    
    		macro end_tampright_align256_allocate_macro
    		lua pass1	
    								
    		lua_tampright_align256_allocate_end_addr[lua_tampright_align256_procedure_count] = (_c("$"))
    								
    		endlua
    		
    		lua allpass
    		lua_function_tampright_align256_allocate_end(1)
    		
    		lua_tampright_align256_procedure_count = lua_tampright_align256_procedure_count + 1
    		endlua
    	endm
    
    ;------------------------------------------------------------------------------
    ;TAMP RIGHT ALIGN 256 lua
    
            lua allpass
    	
    	function lua_function_tampright_align256_allocate(temp)
    								
    		tampright_align256_allocate_size = (lua_tampright_align256_allocate_end_addr[lua_tampright_align256_procedure_count] - lua_tampright_align256_allocate_procedure_start_addr[lua_tampright_align256_procedure_count])
    								
    			--free page search
    			lua_tampright_align256_allocator_addr_finded = 0
    			tampright_align256_allocator_free_bytes = 1
    								
    				for tampright_align256_allocator_addr_search = (lua_code_allocator_end_page*256),(lua_code_allocator_start_page*256), -256 do
    
    					if lua_tampright_align256_allocator_addr_finded == 0 then
    						tampright_align256_allocator_free_bytes = 1
    								
    						for tampright_align256_allocator_byte_scan = tampright_align256_allocator_addr_search,((tampright_align256_allocator_addr_search + tampright_align256_allocate_size)-1), 1 do
    							
    						if lua_code_allocator_array[tampright_align256_allocator_byte_scan] == 0 then
    						tampright_align256_allocator_free_bytes = 0
    						end
    						end
    					end
    					
    					if lua_tampright_align256_allocator_addr_finded == 0 then
    								
    						if tampright_align256_allocator_free_bytes == 1 then
    								if (tampright_align256_allocator_addr_search + tampright_align256_allocate_size-1) < ((lua_code_allocator_end_page*256)+256) then
    									
    							for tampright_align256_allocator_byte_fill = tampright_align256_allocator_addr_search,((tampright_align256_allocator_addr_search + tampright_align256_allocate_size)-1), 1 do
    								
    							-- очистка свободной памЯти
    							lua_code_allocator_array[tampright_align256_allocator_byte_fill] = 0
    							end
    				
    						lua_tampright_align256_allocator_addr_finded = 1
    			
    						lua_tampright_align256_allocator_new_org = tampright_align256_allocator_addr_search
    									 	
    							if lua_tampright_align256_allocator_new_org < (lua_code_allocator_start_page*256) then
    								sj.error("OUT OF MEMORY !!!!!!!!!!!!!!!!!!!!!11111")
    								print ("TAMP RIGHT")
    								print("new_org < (lua_code_allocator_start_page*256)")
    								print("in procedure = ",lua_tampright_align256_procedure_count)
    								sj.exit()
    							end
    							if lua_tampright_align256_allocator_new_org > ((lua_code_allocator_end_page*256)+255) then
    								sj.error("BUG?")
    								print ("TAMP RIGHT")
    								print("new_org > ((lua_code_allocator_end_page*256)+255)")
    								print("in procedure = ",lua_tampright_align256_procedure_count)
    								sj.exit()
    							end
    							if ((lua_tampright_align256_allocator_new_org+tampright_align256_allocate_size)-1) > ((lua_code_allocator_end_page*256)+255) then
    								sj.error("OUT OF MEMORY !!!!!!!!!!!!!!!!!!!!!11111")
    								print ("TAMP RIGHT")
    								print("new_org+size > ((lua_code_allocator_end_page*256)+255)")
    								print("in procedure = ",lua_tampright_align256_procedure_count)
    								sj.exit()
    							end
    								end
    						end
    					end
    				end
    				
    				if lua_tampright_align256_allocator_addr_finded == 0 then
    					if tampright_align256_allocator_free_bytes == 0 then
    						sj.error("FREE BYTES NOT FOUND o_O !!!!!!!!!!!!!!!!!!!!!11111")
    							print ("TAMP RIGHT")
    							
    							print("procedure = ",lua_tampright_align256_procedure_count)
    							sj.exit()
    					end
    				end
    				if lua_tampright_align256_allocator_addr_finded == 0 then
    					if tampright_align256_allocator_free_bytes == 1 then
    						sj.error("FREE BYTES NOT FOUND o_O !!!!!!!!!!!!!!!!!!!!!11111")
    							print ("free_bytes = 1")
    							print ("TAMP RIGHT")
    							
    							print("procedure = ",lua_tampright_align256_procedure_count)
    							sj.exit()
    					end
    				end
    	end
    
    -- ----------------------------------------------------------------------------
    	
    	function lua_function_tampright_align256_allocate_end(temp)
    								
    	end
    		
    	endlua
    
    ;==============================================================================
    
    ;==============================================================================
    ; FAST TAB 8P
    ;==============================================================================
    ;FAST TAB 8P macro
    						;по окончанию PASS2 уже установлен новый org!
    	macro fasttab_8p_allocate_macro _fasttab_8p_alloc_table_haddr?, _fasttab_8p_alloc_procedure_number?
    								
    @__fasttab_8p_allocate_table_haddr = _fasttab_8p_alloc_table_haddr?
    @__fasttab_8p_allocate_procedure_number = _fasttab_8p_alloc_procedure_number?
    
    								
    		lua pass1
    								
    		lua_fasttab_8p_allocate_procedure_start_addr[(_c("__fasttab_8p_allocate_table_haddr"))][(_c("__fasttab_8p_allocate_procedure_number"))] = _c("$")	
    											
    		endlua
    		lua allpass
    		lua_function_fasttab_8p_allocate((_c("__fasttab_8p_allocate_table_haddr")),(_c("__fasttab_8p_allocate_procedure_number")))
    		endlua
    		
    		lua pass2	;copy
    		if lua_fasttab_8p_allocator_page_finded == 1 then
    					for lua_fasttab_8p_32dup = 0,255,8 do
    								
    			_pc(string.format("org $%04x", _c("__fasttab_8p_allocate_table_haddr * 256") + (_c("__fasttab_8p_allocate_procedure_number"))+(lua_fasttab_8p_32dup)))
    								
    			_pc(string.format("defb $%02x", lua_fasttab_8p_allocator_new_h_org))
    					end
    								
    			_pc(string.format("org $%04x", lua_fasttab_8p_allocator_new_h_org*256 + (_c("__fasttab_8p_allocate_procedure_number"))))
    		end 
    		endlua
    		lua pass3	;
    		if lua_fasttab_8p_allocator_page_finded == 1 then
    					for lua_fasttab_8p_32dup = 0,255,8 do
    								
    			_pc(string.format("org $%04x", _c("__fasttab_8p_allocate_table_haddr * 256") + (_c("__fasttab_8p_allocate_procedure_number"))+(lua_fasttab_8p_32dup)))
    								
    			_pc(string.format("defb $%02x", lua_fasttab_8p_allocator_new_h_org))
    					end
    								
    			_pc(string.format("org $%04x", lua_fasttab_8p_allocator_new_h_org*256 + (_c("__fasttab_8p_allocate_procedure_number"))))		
    		end 
    		endlua
    	endm
    	
    ;------------------------------------------------------------------------------
    	
    		macro end_fasttab_8p_allocate_macro
    		lua pass1	
    								
    		lua_fasttab_8p_allocate_end_addr[(_c("__fasttab_8p_allocate_table_haddr"))][(_c("__fasttab_8p_allocate_procedure_number"))] = _c("$")
    		--lua_fasttab_8p_allocate_end_addr[lua_fasttab_8p_table_haddr][lua_fasttab_8p_procedure_number] = _c("$")
    								
    		endlua
    		lua allpass
    		lua_function_fasttab_8p_allocate_end(_c("__fasttab_8p_allocate_procedure_number"))
    		endlua
    	endm
    
    ;------------------------------------------------------------------------------
    ;FAST TAB 8P lua
    
            lua allpass
    	
    	function lua_function_fasttab_8p_allocate(lua_fasttab_8p_table_haddr,lua_fasttab_8p_procedure_number)
    								
    		
    		fasttab_8p_allocate_size = (lua_fasttab_8p_allocate_end_addr[(_c("__fasttab_8p_allocate_table_haddr"))][(_c("__fasttab_8p_allocate_procedure_number"))]-lua_fasttab_8p_allocate_procedure_start_addr[(_c("__fasttab_8p_allocate_table_haddr"))][(_c("__fasttab_8p_allocate_procedure_number"))])
    								
    			--free page search
    			lua_fasttab_8p_allocator_page_finded = 0
    			fasttab_8p_allocator_page_free_bytes = 1
    
    			for fasttab_8p_allocator_page_search = lua_code_allocator_start_page, lua_code_allocator_end_page, 1 do
    				if lua_fasttab_8p_allocator_page_finded == 0 then
    								
    				fasttab_8p_allocator_page_free_bytes = 1
    								
    					for fasttab_8p_allocator_byte_scan = ((fasttab_8p_allocator_page_search*256) + lua_fasttab_8p_procedure_number), ((fasttab_8p_allocator_page_search*256) + lua_fasttab_8p_procedure_number + fasttab_8p_allocate_size - 1), 1 do
    								
    						if lua_code_allocator_array[fasttab_8p_allocator_byte_scan] == 0 then
    							-- страница занята
    							
    							fasttab_8p_allocator_page_free_bytes = 0
    							--break
    						end
    					end
    				end
    				if lua_fasttab_8p_allocator_page_finded == 0 then
    					if fasttab_8p_allocator_page_free_bytes == 1 then
    								
    						for fasttab_8p_allocator_byte_fill = ((fasttab_8p_allocator_page_search*256) + lua_fasttab_8p_procedure_number), ((fasttab_8p_allocator_page_search*256) + fasttab_8p_allocate_size + lua_fasttab_8p_procedure_number - 1), 1 do
    						-- очистка свободных страниц
    						lua_code_allocator_array[fasttab_8p_allocator_byte_fill] = 0
    								
    						end
    			
    					lua_fasttab_8p_allocator_page_finded = 1
    					lua_fasttab_8p_allocator_new_h_org = fasttab_8p_allocator_page_search
    									
    						if (lua_code_allocator_start_page*256) > ((fasttab_8p_allocator_page_search*256) + lua_fasttab_8p_procedure_number) then
    							sj.error("OUT OF MEMORY !!!!!!!!!!!!!!!!!!!!!11111")
    							print ("FAST TAB 8P")
    							print ("new_org < (lua_code_allocator_start_page*256)")
    							print (string.format("in procedure = $%02x",lua_fasttab_8p_procedure_number))
    							print (string.format("table = $%02x",lua_fasttab_8p_table_haddr))
    							sj.exit()
    						end
    						if ((lua_code_allocator_end_page*256)+255) < ((fasttab_8p_allocator_page_search*256) + fasttab_8p_allocate_size + lua_fasttab_8p_procedure_number - 1) then
    							sj.error("OUT OF MEMORY !!!!!!!!!!!!!!!!!!!!!11111")
    							print ("FAST TAB 8P")
    							print("new_org > ((lua_code_allocator_end_page*256)+255)")
    							print (string.format("in procedure = $%02x",lua_fasttab_8p_procedure_number))
    							print (string.format("table = $%02x",lua_fasttab_8p_table_haddr))
    							sj.exit()
    						end
    					end
    				end
    			end
    			if lua_fasttab_8p_allocator_page_finded == 0 then
    				if fasttab_8p_allocator_page_free_bytes == 0 then
    					sj.error("FREE PAGE NOT FOUND !!!!!!!!!!!!!!!!!!!!!11111")
    							print ("FAST TAB 8P")
    							print (string.format("procedure = $%02x",lua_fasttab_8p_procedure_number))
    							print (string.format("table = $%02x",lua_fasttab_8p_table_haddr))
    							sj.exit()
    				end
    			end
    			if lua_fasttab_8p_allocator_page_finded == 0 then
    				if fasttab_8p_allocator_page_free_bytes == 1 then
    					sj.error("FREE PAGE NOT FOUND !!!!!!!!!!!!!!!!!!!!!11111")
    							print ("free_bytes = 1")
    							print ("FAST TAB 8P")
    							print (string.format("procedure = $%02x",lua_fasttab_8p_procedure_number))
    							print (string.format("table = $%02x",lua_fasttab_8p_table_haddr))
    							sj.exit()
    				end
    			end
    	end
    
    -- ----------------------------------------------------------------------------
    	
    	function lua_function_fasttab_8p_allocate_end(lua_fasttab_8p_procedure_number)
    								
    	end
    	
    	endlua
    
    ;==============================================================================
    
    
    ;==============================================================================
    ;==============================================================================
    ;==============================================================================
    ;==============================================================================
    ;==============================================================================
    
    
    
    
    
    
    ;==============================================================================
    ; TEST
    ;==============================================================================
    
    	org $4000
    
    		fasttab_allocate_macro $7E,$00
    		defg ########
    		defg #......#
    		defg #....#.#
    		defg #....#.#
    		defg #....#.#
    		defg #....#.#
    		defg #....#.#	
    		defg #......#
    		defg ########	
    		end_fasttab_allocate_macro
    
    		fasttab_allocate_macro $7E,$01
    		defg ########
    		defg #......#
    		defg #.####.#
    		defg #....#.#
    		defg #.####.#
    		defg #.#....#
    		defg #.####.#	
    		defg #......#
    		defg ########	
    		end_fasttab_allocate_macro
    
    		fasttabright_allocate_macro $7F,$02
    		defg ########
    		defg #......#
    		defg #.####.#
    		defg #....#.#
    		defg #.####.#
    		defg #....#.#
    		defg #.####.#	
    		defg #......#
    		defg ########		
    		end_fasttabright_allocate_macro
    		
    		fasttabright_allocate_macro $7F,$04
    		defg ########
    		defg #......#
    		defg #.#..#.#
    		defg #.#..#.#
    		defg #.####.#
    		defg #....#.#
    		defg #....#.#	
    		defg #......#
    		defg ########		
    		end_fasttabright_allocate_macro
    
    		org_allocate_macro $8334
    		defg ########
    		defg #......#
    		defg #.####.#
    		defg #.#....#
    		defg #.####.#
    		defg #....#.#
    		defg #.####.#	
    		defg #......#
    		defg ########	
    		end_org_allocate_macro
    		
    		org_allocate_macro $800B
    		defg ########
    		defg #......#
    		defg #.####.#
    		defg #.#....#
    		defg #.####.#
    		defg #.#..#.#
    		defg #.####.#	
    		defg #......#
    		defg ########	
    		end_org_allocate_macro
    
    		tampleft_allocate_macro
    		defg ########
    		defg #......#
    		defg #.####.#
    		defg #....#.#
    		defg #....#.#
    		defg #....#.#
    		defg #....#.#	
    		defg #......#
    		defg ########	
    		end_tampleft_allocate_macro
    		
    		tampleft_allocate_macro
    		defg ########
    		defg #......#
    		defg #.####.#
    		defg #.#..#.#
    		defg #.####.#
    		defg #.#..#.#
    		defg #.####.#	
    		defg #......#
    		defg ########	
    		end_tampleft_allocate_macro
    		
    		tampleft_align256_allocate_macro
    		defg ########
    		defg #......#
    		defg #.####.#
    		defg #.#..#.#
    		defg #.####.#
    		defg #....#.#
    		defg #.####.#	
    		defg #......#
    		defg ########	
    		end_tampleft_align256_allocate_macro
    		
    		tampleft_align256_allocate_macro
    		defg ########
    		defg #......#
    		defg #.####.#
    		defg #.#..#.#
    		defg #.####.#
    		defg #.#..#.#
    		defg #.#..#.#	
    		defg #......#
    		defg ########	
    		end_tampleft_align256_allocate_macro
    		
    		tampright_allocate_macro
    		defg ########
    		defg #......#
    		defg #.#....#
    		defg #.#....#
    		defg #.####.#
    		defg #.#..#.#
    		defg #.####.#	
    		defg #......#
    		defg ########	
    		end_tampright_allocate_macro
    		
    		tampright_allocate_macro
    		defg ########
    		defg #......#
    		defg #.####.#
    		defg #.#....#
    		defg #.#....#
    		defg #.#....#
    		defg #.####.#	
    		defg #......#
    		defg ########	
    		end_tampright_allocate_macro
    			
    		tampright_align256_allocate_macro
    		defg ########
    		defg #......#
    		defg #....#.#
    		defg #....#.#
    		defg #.####.#
    		defg #.#..#.#
    		defg #.####.#	
    		defg #......#
    		defg ########
    		end_tampright_align256_allocate_macro
    		
    		tampright_align256_allocate_macro
    		defg ########
    		defg #......#
    		defg #.####.#
    		defg #.#....#
    		defg #.####.#
    		defg #.#....#
    		defg #.####.#	
    		defg #......#
    		defg ########
    		end_tampright_align256_allocate_macro
    		
    		tampleft_allocate_macro
    		defg ########
    		defg #......#
    		defg #.####.#
    		defg #.#....#
    		defg #.#....#
    		defg #.#....#
    		defg #.####.#
    		defg #.#....#
    		defg #.#....#
    		defg #.#....#
    		defg #.#....#	
    		defg #......#
    		defg ########	
    		end_tampleft_allocate_macro	
    		
    
    		
    		fasttab_allocate_macro $7E,$20
    l0		ld a,a
    		jp l0
    		end_fasttab_allocate_macro
    
    		fasttab_allocate_macro $7E,$21
    l1		jp l1_2
    		ld a,b
    		ld a,b
    l1_2		jp l1_2
    		end_fasttab_allocate_macro
    
    		fasttabright_allocate_macro $7F,$40
    l2		ld b,b
    		jr l2
    		jp l2
    		end_fasttabright_allocate_macro
    
    ;l3
    		
    		fasttabright_allocate_macro $7F,$04
    		ld b,c
    		ld b,c
    		ld b,c
    		jr $
    		end_fasttabright_allocate_macro
    
    		org_allocate_macro $8464
    l4		ld hl,$
    		ld hl,$
    		ld hl,$
    		ld hl,$
    		jp l4
    		end_org_allocate_macro
    		
    		org_allocate_macro $861B
    		ld hl,$
    		jp $
    		end_org_allocate_macro
    
    		tampleft_allocate_macro
    l5		ld c,c
    		ld c,c
    		ld c,c
    		jp l5
    		jp l1
    		end_tampleft_allocate_macro
    		
    		tampleft_allocate_macro
    l6		ld c,d
    		jp l1
    		jp l2
    		jp l3
    		jp l4
    		jp l5
    		jp l6
    		jp l7
    		jp l8
    		jp l9
    		end_tampleft_allocate_macro
    		
    		tampleft_align256_allocate_macro
    l7		jp l7
    		end_tampleft_align256_allocate_macro
    		
    		tampleft_align256_allocate_macro
    l8		jp l8
    		end_tampleft_align256_allocate_macro
    		
    		tampright_allocate_macro
    l9		jr l9
    		end_tampright_allocate_macro
    		
    		tampright_allocate_macro
    l10		jp l10	
    		end_tampright_allocate_macro
    			
    		tampright_align256_allocate_macro
    l11		jp l11
    		end_tampright_align256_allocate_macro
    		
    		tampright_align256_allocate_macro
    l12		jp l12
    		end_tampright_align256_allocate_macro
    		
    		tampleft_allocate_macro
    l13		jp l13
    		end_tampleft_allocate_macro	
    
    	
    ;		org_allocate_macro $8000
    ;overwrite	nop
    ;check		nop
    ;		nop
    ;		nop
    ;		jp l4
    ;		end_org_allocate_macro
    
    ;		fasttab_8p_allocate_macro $48,1
    ;		defb $FF
    ;		end_fasttab_8p_allocate_macro
    	
    	org 60000
    
    Test_Start
    
    	jp Test_Start
    		
    
    ;===================================================================================
    
    
    	savesna "Test.sna",Test_Start



    - - - Добавлено - - -

    А тем временем оказалось что некий Simon Owen
    использовал быстрые таблицы еще 2008 году...

    ...правда после каждого изменения кода он видимо чем то пересчитывал адреса новых org-ов...
    да и дикое выравнивание у него...
    ...и вообще как можно кодить не на sjasm-е вообще? о_О

    - - - Добавлено - - -

    интересно что в процессе
    какого хрена позадирался регистр всех букв Я о_О
    notepad++ то еще гафно
    какието левые траблы с кодировками
    нормально не может открыть файл сделанный в блокноте...
    Последний раз редактировалось NEO SPECTRUMAN; 30.03.2020 в 05:33.

  11. #9
    Guru Аватар для NEO SPECTRUMAN
    Регистрация
    22.05.2011
    Адрес
    Дзержинск
    Сообщений
    4,043
    Спасибо Благодарностей отдано 
    157
    Спасибо Благодарностей получено 
    224
    Поблагодарили
    183 сообщений
    Mentioned
    3 Post(s)
    Tagged
    0 Thread(s)

    По умолчанию

    Все таки Simon Owen зря отказался от использования быстрых таблиц переходов в sid плеере (хотя во всех других эмуляторах у него быстрые таблицы)
    Весь код прекрасно поместился в 16 страниц адресов портов С64



    а производительностЕ прибавилась
    и теперь тактов пентагона без турбы хватает чтобы играть Cybernoid_II.sid
    тактов скорпиона таки не хватает...
    но скоростЕ еще можно выжать (правда тогда не влезет в 16 "страниц"...)

    хотя честных 69888 тактов и буфер в 250 фреймов
    позволяют отыграть достаточно долго
    пока чтение буфера не догонит запись
    Последний раз редактировалось NEO SPECTRUMAN; 02.08.2019 в 03:32.

  12. #10
    Banned
    Регистрация
    24.07.2008
    Адрес
    Курган
    Сообщений
    2,115
    Спасибо Благодарностей отдано 
    10
    Спасибо Благодарностей получено 
    13
    Поблагодарили
    13 сообщений
    Mentioned
    1 Post(s)
    Tagged
    0 Thread(s)

    По умолчанию

    Цитата Сообщение от NEO SPECTRUMAN Посмотреть сообщение
    и теперь возможно? можно будет забыть про бхмерское слоупочное
    Там в первой строке должно было быть ld l,a наверное?
    И ещё. Для некоторых объясни, зачем применяется "выравнивание кода и данных" где и как? Как делаются переходы откуда и как?

    Цитата Сообщение от NEO SPECTRUMAN Посмотреть сообщение
    а производительностЕ прибавилась
    и теперь тактов пентагона без турбы хватает чтобы играть Cybernoid_II.sid
    тактов скорпиона таки не хватает...
    но скоростЕ еще можно выжать (правда тогда не влезет в 16 "страниц"...)
    Поподробнее можно? Почему тактов пентагона не хватает? Там что, оцифровка идёт что ли? Какие 16 страниц? У пентагона 8 страниц, 16 у скорпа.

  13. Этот пользователь поблагодарил Vadim за это полезное сообщение:

    Reobne (02.08.2019)

Страница 1 из 3 123 ПоследняяПоследняя

Информация о теме

Пользователи, просматривающие эту тему

Эту тему просматривают: 1 (пользователей: 0 , гостей: 1)

Похожие темы

  1. Таблица переходов (computed goto)
    от Barmaley_m в разделе Программирование
    Ответов: 17
    Последнее: 03.07.2019, 22:31
  2. Быстрые 41256/4164
    от LeoN65816 в разделе Память
    Ответов: 5
    Последнее: 15.03.2019, 11:52
  3. Программы переходов экрана
    от AAA в разделе Софт
    Ответов: 2
    Последнее: 19.03.2013, 18:02
  4. Таблицы огибающих.
    от Robus в разделе Музыка
    Ответов: 9
    Последнее: 17.01.2013, 11:35
  5. Interference:построение таблицы
    от goblinish в разделе Программирование
    Ответов: 6
    Последнее: 17.11.2012, 13:43

Ваши права

  • Вы не можете создавать новые темы
  • Вы не можете отвечать в темах
  • Вы не можете прикреплять вложения
  • Вы не можете редактировать свои сообщения
  •