/programs/develop/SPForth/Tupfile.lua |
---|
0,0 → 1,3 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"}) |
tup.rule({"meforth.ASM", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "meforth") |
/programs/develop/asciivju/trunk/Tupfile.lua |
---|
0,0 → 1,2 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("asciivju.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "asciivju") |
/programs/develop/cObj/trunk/Tupfile.lua |
---|
0,0 → 1,3 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"}) |
tup.rule({"cObj.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "cObj") |
/programs/develop/examples/checkbox/trunk/Tupfile.lua |
---|
0,0 → 1,2 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("checkbox.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "checkbox") |
/programs/develop/examples/circle/trunk/Tupfile.lua |
---|
0,0 → 1,2 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("circle.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "circle") |
/programs/develop/examples/clipboard/Tupfile.lua |
---|
0,0 → 1,6 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.foreach_rule( |
{"clip_get.asm", "clip_put.asm"}, |
"fasm %f %o " .. tup.getconfig("KPACK_CMD"), |
"%B" |
) |
/programs/develop/examples/cpuspeed/trunk/Tupfile.lua |
---|
0,0 → 1,3 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"}) |
tup.rule({"cpuspeed.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "cpuspeed") |
/programs/develop/examples/editbox/trunk/EDITBOX.INC |
---|
File deleted |
\ No newline at end of file |
/programs/develop/examples/editbox/trunk/Tupfile.lua |
---|
0,0 → 1,2 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("editbox.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "editbox") |
/programs/develop/examples/editbox/trunk/editbox.inc |
---|
0,0 → 1,271 |
; SEE YOU File FAQ.txt and HISTORY. Good Like! |
;;;;;;;;;;;;;;;;;; |
include 'editbox.mac' ;¬ ªà®á ª®â®àë© ¤®«¦¥ ®¡«¥£ç¨âì ¦¨§ì :) á¯¥æ¨ «ì® ¤«ï editbox |
;;;;;;;;;;;;;;;;;; |
macro use_edit_box |
{ |
edit_box: |
ed_width equ [edi] ;è¨à¨ ª®¬¯®¥â |
ed_left equ [edi+4] ;¯®«®¦¥¨¥ ¯® ®á¨ å |
ed_top equ [edi+8] ;¯®«®¦¥¨¥ ¯® ®á¨ ã |
ed_color equ [edi+12] ;梥â ä® ª®¬¯®¥â |
shift_color equ [edi+16] ;=0x6a9480 |
ed_focus_border_color equ [edi+20] ;梥â à ¬ª¨ ª®¬¯®¥â |
ed_blur_border_color equ [edi+24] ;梥⠥ ªâ¨¢®£® ª®¬¯®¥â |
ed_text_color equ [edi+28] ;梥â ⥪áâ |
ed_max equ [edi+32] ;ª®«-¢® ᨬ¢®«®¢ ª®â®àë¥ ¬®¦® ¬ ªá¨¬ «ì® ¢¢¥á⨠|
ed_text equ [edi+36] ;㪠§ â¥«ì ¡ãä¥à |
ed_flags equ [edi+40] ;ä« £¨ |
ed_size equ [edi+44] ;ª®«-¢® ᨬ¢®«®¢ |
ed_pos equ [edi+48] ;¯®§¨æ¨ï ªãàá®à |
ed_offset equ [edi+52] ;ᬥ饨¥ |
cl_curs_x equ [edi+56] ;¯à¥¤ë¤ã饥 ª®®à¤¨ â ªãàá®à ¯® å |
cl_curs_y equ [edi+60] ;¯à¥¤ë¤ã饥 ª®®à¤¨ â ªãàá®à ¯® ã |
ed_shift_pos equ [edi+64] ;¯®«®¦¥¨¥ ªãàá®à |
ed_shift_pos_old equ [edi+68] ;áâ ஥ ¯®«®¦¥¨¥ ªãàá®à |
;========================================================== |
;=== ¯à®æ¥¤ãà ¯à®à¨á®¢ª¨ ================================= |
;========================================================== |
.draw: |
pushad |
;--- à¨á㥬 à ¬ªã --- |
call .draw_border ; ãªæ¨ï áâ ¡¨«ì |
.draw_bg_cursor_text: |
;--- ¨§¬¥ï¥¬ ᬥ饨¥, ¥á«¨ ¤® --- |
call .check_offset ;¢ëç¨á«¥¨¥ ¯®§¨æ¨¨ ªãàá®à áâ ¡¨«ì |
;--- à¨á㥬 ¢ãâà¥îî ®¡« áâì --- |
call .draw_bg ; à¨á®¢ âì ¯àאַ㣮«ì¨ª à ¡®ç¥© ®¡« á⨠|
;---- à¨á㥬 ¢ë¤¥«¥¨¥, ¯® shift ¥á«¨ ¥áâì |
call .draw_shift |
.draw_cursor_text: |
;--- à¨á㥬 ªãàá®à --- |
;--- ¬®¦¥â ¥£® ¥ ¤® à¨á®¢ âì ---- |
test word ed_flags,ed_focus |
je @f |
call .draw_cursor |
@@: |
call .draw_text |
;;;;;;;;;;;;;;;;;;;;;;;;;; |
;¡é¨© ¢ë室 ¨§ editbox ¤«ï ¢á¥å äãªæ¨© ¨ ¯®áâ ®¡à ¡®â稪®¢ |
;;;;;;;;;;;;;;;;;;;;;;;;;; |
.editbox_exit: |
edit_ex |
;========================================================== |
;=== ®¡à ¡®âª ª« ¢¨ âãàë ================================= |
;========================================================== |
.key: |
pushad |
test word ed_flags,ed_focus ; ¥á«¨ ¥ ¢ 䮪ãá¥, ¢ë室¨¬ |
je .editbox_exit |
test word ed_flags,ed_mouse_on |
jne .editbox_exit |
;஢¥àª ¦ â shift ? |
call .check_shift |
;---------------------------------------------------------- |
;--- ¯à®¢¥à塞, çâ® ¦ â® -------------------------------- |
;---------------------------------------------------------- |
use_key_process backspase,delete,left,right,home,end,insert |
;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
; £«ãèª ®¡à ¡®âªã ª« ¢¨è ¢¢¥àå ¨ ¢¨§ â.¥. ¯à¨ ®¡ à㦥¨¨ íâ¨å ª®¤®¢ ¯à®¨á室¨â ¢ë室 ¨§ ®¡à ¡®â稪 |
;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
use_key_no_process up,down,esc,enter,tab,numl,capsl,scrolll |
;--- ¦ â ¤àã£ ï ª« ¢¨è --- |
;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
;஢¥àª ãáâ ®¢«¥ «¨ ä« £ ¯à¨ ª®â®à®¬ 㦮 ¢ë¢®¤¨âì ⮫쪮 æ¨äàë ¢ 㦮¬ ¡®ªá¥ ¥á«¨ â ª®©¥®¡å®¤¨¬®á⨠¥â 㦮 § ª®¬¥â¨à®¢ âì ¬ ªà®á |
;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
use_key_figures_only |
;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
;¯à®¢¥àª shift ¡ë« «¨ ¦ â |
;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
are_key_shift_press |
;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
; ¯à®¢¥à塞, 室¨âáï «¨ ªãàá®à ¢ ª®æ¥ + ¤ «ì¥©è ï ®¡à ¡®âª |
;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
are_key_cur_end |
;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
;¡à ¡®âª ª« ¢¨è insert,delete.backspase,home,end,left,right |
;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
use_work_key |
;========================================================== |
;=== ®¡à ¡®âª ¬ëè¨ ======================================= |
;========================================================== |
.mouse: |
pushad |
;debug |
;---------------------------------------------------------- |
;--- ¯®«ãç ¥¬ á®áâ®ï¨¥ ª®¯®ª ¬ëè¨ ----------------------- |
;---------------------------------------------------------- |
mcall 37,2 |
;---------------------------------------------------------- |
;--- ¯à®¢¥à塞 á®áâ®ï¨¥ ---------------------------------- |
;---------------------------------------------------------- |
test eax,1 |
jnz .mouse_left_button |
and word ed_flags,ed_mouse_on_off |
xor ebx,ebx |
mov dword [mouse_flag],ebx |
jmp .editbox_exit |
.mouse_left_button: |
;---------------------------------------------------------- |
;--- ¡«®ª¨à®¢ª ®â 䮪ãá¨à®¢ª¨ ¢ ¤àã£¨å ¡®ªá å ¯à¨ ¯®¯ ¤ ¨¨ ¨å ªãàá®à |
;---------------------------------------------------------- |
mov eax,dword [mouse_flag] |
test eax,eax |
jz @f |
cmp eax,edi |
je @f |
jmp ._blur |
;---------------------------------------------------------- |
;--- ¯®«ãç ¥¬ ª®®à¤¨ âë ¬ëè¨ ®â®á¨â¥«ì® ®ª |
;---------------------------------------------------------- |
@@: mcall 37,1 |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
;ãªæ¨ï ®¡à ¡®âª¨ ¬ë誨 ¯®«ã票¥ ª®®à¤¨ â ¨ ¯à®¢¥àª ¨å + ¢ë¤¥«¥¨ï |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
use_work_mouse |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
;¡é¨¥ äãªæ¨¨ ®¡à ¡®âª¨ |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
use_general_func |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
;ãªæ¨¨ ¤«ï à ¡®âë á key |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
use_key_func |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
;ãªæ¨¨ ¤«ï à ¡®âë á mouse |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
use_mouse_func |
} |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
;Bit mask from editbox |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
ed_figure_only= 1000000000000000b ;®¤¨ ᨬ¢®«ë |
ed_always_focus= 100000000000000b |
ed_focus= 10b ;䮪ãá ¯à¨«®¦¥¨ï |
ed_shift_on= 1000b ;¥á«¨ ¥ ãáâ ®¢«¥ -§ ç¨â ¢¯¥à¢ë¥ ¦ â shift,¥á«¨ ¡ë« ãáâ ®¢«¥, § ç¨â ¬ë 㦥 çâ® - â® ¤¥« «¨ 㤥ন¢ ï shift |
ed_shift_on_off=1111111111110111b |
ed_shift= 100b ;¢ª«îç ¥âáï ¯à¨ ¦ ⨨ shift â.¥. ¥á«¨ ¦¨¬ î |
ed_shift_off= 1111111111111011b |
ed_shift_bac= 10000b ;¡¨â ¤«ï ®ç¨á⪨ ¢ë¤¥«¥®£® shift â.¥. ¯à¨ ãáâ ®¢ª¥ £®¢®à¨â çâ® ¥áâì ¢ë¤¥«¥¨¥ |
ed_shift_bac_cl=1111111111101111b ;®ç¨á⪠¯à¨ 㤠«¥¨¨ ¢ë¤¥«¥¨ï |
ed_shift_cl= 1111111111100011b |
ed_shift_mcl= 1111111111111011b |
ed_left_fl= 100000b |
ed_right_fl= 1111111111011111b |
ed_offset_fl= 1000000b |
ed_offset_cl= 1111111110111111b |
ed_insert= 10000000b |
ed_insert_cl= 1111111101111111b |
ed_mouse_on = 100000000b |
ed_mous_adn_b= 100011000b |
ed_mouse_on_off=1111111011111111b |
ed_height=14 ; ¢ëá®â |
macro draw_edit_boxes start,_end |
{ |
mov edi,start |
mov ecx,((_end-start)/ed_struc_size) |
@@: |
call edit_box.draw |
add edi,ed_struc_size |
loop @b |
} |
macro mouse_edit_boxes start,_end |
{ |
mov edi,start |
mov ecx,((_end-start)/ed_struc_size) |
@@: |
call edit_box.mouse |
add edi,ed_struc_size |
loop @b |
} |
macro key_edit_boxes start,end |
{ |
mov edi,start |
mov ecx,((end-start)/ed_struc_size) |
@@: |
call edit_box.key |
add edi,ed_struc_size |
loop @b |
} |
ed_struc_size=72 |
struc edit_box width,left,top,color,shift_color,focus_border_color,\ |
blur_border_color,text_color,max,text,flags,size,pos |
{ |
.width dd width |
.left dd left |
.top dd top |
.color dd color |
.shift_color dd shift_color |
.focus_border_color dd focus_border_color |
.blur_border_color dd blur_border_color |
.text_color dd text_color |
.max dd max |
.text dd text |
.flags dd flags+0 |
.size dd size+0 |
.pos dd pos+0 |
.offset dd 0 |
.cl_curs_x dd 0 |
.cl_curs_y dd 0 |
.shift dd 0 |
.shift_old dd 0 |
} |
macro edit_boxes_set_sys_color start,end,color_table |
{ |
mov edi,start |
mov ecx,((end-start)/ed_struc_size) |
mov esi,color_table |
@@: |
mov eax,[esi+36] |
mov ebx,[esi+20] |
mov ed_focus_border_color,eax |
shr bh,1 |
shr bl,1 |
shr ah,1 |
shr al,1 |
add ah,bh |
add al,bl |
ror eax,16 |
ror ebx,16 |
shr bl,1 |
shr al,1 |
add al,bl |
ror eax,16 |
mov ed_blur_border_color,eax |
add edi,ed_struc_size |
loop @b |
} |
macro draw_edit_box ed_ptr |
{ |
mov edi,ed_ptr |
call edit_box.draw |
} |
macro mouse_edit_box ed_ptr |
{ |
mov edi,ed_ptr |
call edit_box.mouse |
} |
macro key_edit_box ed_ptr |
{ |
mov edi,ed_ptr |
call edit_box.key |
} |
macro default_box ed_ptr |
{ |
pusha |
; xor eax,eax |
; mov ed_shift_pos,eax |
; mov ed_shift_pos_old,eax |
and word ed_flags,ed_shift_cl |
; mov ed_offset,eax |
popa |
} |
/programs/develop/examples/example2/trunk/Tupfile.lua |
---|
0,0 → 1,3 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"}) |
tup.rule({"example2.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "example2") |
/programs/develop/examples/example3/trunk/Tupfile.lua |
---|
0,0 → 1,3 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"}) |
tup.rule({"example3.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "example3") |
/programs/develop/examples/hello/trunk/Tupfile.lua |
---|
0,0 → 1,3 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"}) |
tup.rule({"hello.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "hello") |
/programs/develop/examples/ipc/trunk/Tupfile.lua |
---|
0,0 → 1,3 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"}) |
tup.rule({"ipc.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "ipc") |
/programs/develop/examples/ir/trunk/Tupfile.lua |
---|
0,0 → 1,3 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"}) |
tup.rule({"ir.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "ir") |
/programs/develop/examples/numcalc/trunk/Tupfile.lua |
---|
0,0 → 1,2 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("@numcalc.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "@numcalc") |
/programs/develop/examples/radiobutton/trunk/Tupfile.lua |
---|
0,0 → 1,2 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("optionbox.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "optionbox") |
/programs/develop/examples/rtdata/trunk/Tupfile.lua |
---|
0,0 → 1,3 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"}) |
tup.rule({"rtdata.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "rtdata") |
/programs/develop/examples/template/trunk/Tupfile.lua |
---|
0,0 → 1,3 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"}) |
tup.rule({"template.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "template") |
/programs/develop/examples/thread/trunk/Tupfile.lua |
---|
0,0 → 1,3 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"}) |
tup.rule({"thread.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "thread") |
/programs/develop/fasm/trunk/Tupfile.lua |
---|
0,0 → 1,3 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"}) |
tup.rule({"fasm.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "fasm") |
/programs/develop/fast_call_test/Tupfile.lua |
---|
0,0 → 1,2 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("test.ASM", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "test") |
/programs/develop/h2d2b/trunk/Tupfile.lua |
---|
0,0 → 1,3 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"}) |
tup.rule({"h2d2b.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "h2d2b") |
/programs/develop/heed/trunk/Tupfile.lua |
---|
0,0 → 1,3 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"}) |
tup.rule({"heed.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "heed") |
/programs/develop/hexview/trunk/Tupfile.lua |
---|
0,0 → 1,3 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"}) |
tup.rule({"hexview.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "hexview") |
/programs/develop/info3ds/Tupfile.lua |
---|
0,0 → 1,3 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"}) |
tup.rule({"info3ds.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "info3ds") |
/programs/develop/keyascii/trunk/Tupfile.lua |
---|
0,0 → 1,3 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"}) |
tup.rule({"keyascii.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "keyascii") |
/programs/develop/kol_f_edit/Tupfile.lua |
---|
0,0 → 1,4 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"}) |
tup.rule({"kol_f_edit.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "bin/kol_f_edit") |
tup.rule({"ob_o.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o", "bin/ob_o.opt") |
/programs/develop/libraries/TinyGL/BeOS/GLView.cpp |
---|
0,0 → 1,205 |
#include "GLView.h" |
#include <stdio.h> |
#include <interface/Bitmap.h> |
BLocker BGLView::locker; |
BGLView::BGLView(BRect rect, char *name, |
ulong resizingMode, ulong mode, |
ulong options) |
: BView(rect, name, resizingMode, mode|B_FRAME_EVENTS|B_WILL_DRAW) |
{ |
#ifdef __INTEL__ |
color_space cs = B_RGB16_LITTLE; |
#else |
color_space cs = B_RGB16_BIG; |
#endif |
this->bitmaps[0] = new BBitmap(rect, cs, false, true); |
this->bitmaps[1] = new BBitmap(rect, cs, false, true); |
this->currBitmap = 0; |
int w = this->bitmaps[0]->BytesPerRow() / 2; |
int h = rect.Height() + 1; |
void *buffers[2]; |
buffers[0] = this->bitmaps[0]->Bits(); |
buffers[1] = this->bitmaps[1]->Bits(); |
this->context = ostgl_create_context(w, h, 16, buffers, 2); |
ostgl_make_current(this->context, 0); |
} |
BGLView::~BGLView() |
{ |
ostgl_delete_context(this->context); |
delete this->bitmaps[0]; |
delete this->bitmaps[1]; |
} |
void |
BGLView::LockGL() |
{ |
BGLView::locker.Lock(); |
ostgl_make_current(this->context, this->currBitmap); |
} |
void |
BGLView::UnlockGL() |
{ |
BGLView::locker.Unlock(); |
} |
void |
BGLView::SwapBuffers() |
{ |
if (Window()->Lock()) { |
DrawBitmap(this->bitmaps[this->currBitmap]); |
Window()->Unlock(); |
this->currBitmap ^= 1; |
} |
} |
/* |
BView * |
BGLView::EmbeddedView() |
{ |
return NULL; |
} |
status_t |
BGLView::CopyPixelsOut(BPoint source, BBitmap *dest) |
{ |
assert(0); |
return 0; |
} |
status_t |
BGLView::CopyPixelsIn(BBitmap *source, BPoint dest) |
{ |
assert(0); |
return 0; |
} |
*/ |
void |
BGLView::ErrorCallback(GLenum /*errorCode*/) |
{ |
} |
void |
BGLView::Draw(BRect rect) |
{ |
//fprintf(stderr, "GLView::Draw()"); |
DrawBitmap(this->bitmaps[this->currBitmap^1], rect, rect); |
} |
void |
BGLView::AttachedToWindow() |
{ |
} |
void |
BGLView::AllAttached() |
{ |
} |
void |
BGLView::DetachedFromWindow() |
{ |
} |
void |
BGLView::AllDetached() |
{ |
} |
void |
BGLView::FrameResized(float w, float h) |
{ |
delete this->bitmaps[0]; |
delete this->bitmaps[1]; |
#ifdef __INTEL__ |
color_space cs = B_RGB16_LITTLE; |
#else |
color_space cs = B_RGB16_BIG; |
#endif |
this->bitmaps[0] = new BBitmap(BRect(0,0, w-1, h-1), |
cs, false, true); |
this->bitmaps[1] = new BBitmap(BRect(0,0, w-1, h-1), |
cs, false, true); |
int w2 = this->bitmaps[0]->BytesPerRow() / 2; |
void *buffers[2]; |
buffers[0] = this->bitmaps[0]->Bits(); |
buffers[1] = this->bitmaps[1]->Bits(); |
ostgl_resize(this->context, w2, h, buffers); |
} |
/* |
status_t |
BGLView::Perform(perform_code d, void *arg) |
{ |
} |
*/ |
// |
// the rest are pass-through functions |
// |
status_t |
BGLView::Archive(BMessage *data, bool deep) const |
{ |
return BView::Archive(data, deep); |
} |
void |
BGLView::MessageReceived(BMessage *msg) |
{ |
BView::MessageReceived(msg); |
} |
void |
BGLView::SetResizingMode(uint32 mode) |
{ |
BView::SetResizingMode(mode); |
} |
void |
BGLView::Show() |
{ |
BView::Show(); |
} |
void |
BGLView::Hide() |
{ |
BView::Hide(); |
} |
BHandler * |
BGLView::ResolveSpecifier(BMessage *msg, int32 index, |
BMessage *specifier, int32 form, |
const char *property) |
{ |
return BView::ResolveSpecifier(msg, index, specifier, form, property); |
} |
status_t |
BGLView::GetSupportedSuites(BMessage *data) |
{ |
return BView::GetSupportedSuites(data); |
} |
/* |
void |
BGLView::DirectConnected( direct_buffer_info *info ) |
{ |
BView::DirectConnected(info); |
} |
*/ |
/* |
void |
BGLView::EnableDirectMode( bool enabled ) |
{ |
BView::EnableDirectMode(enabled); |
} |
*/ |
/programs/develop/libraries/TinyGL/BeOS/GLView.h |
---|
0,0 → 1,72 |
#ifndef _glview_h_ |
#define _glview_h_ |
#define BGL_RGB 0 |
#define BGL_INDEX 1 |
#define BGL_SINGLE 0 |
#define BGL_DOUBLE 2 |
#define BGL_DIRECT 0 |
#define BGL_INDIRECT 4 |
#define BGL_ACCUM 8 |
#define BGL_ALPHA 16 |
#define BGL_DEPTH 32 |
#define BGL_OVERLAY 64 |
#define BGL_UNDERLAY 128 |
#define BGL_STENCIL 512 |
#include <interface/View.h> |
#include <support/Locker.h> |
#include <GL/gl.h> |
#include <GL/oscontext.h> |
#include <game/WindowScreen.h> |
#include <game/DirectWindow.h> |
class BGLView : public BView { |
public: |
BGLView(BRect rect, char *name, |
ulong resizingMode, ulong mode, |
ulong options); |
virtual ~BGLView(); |
void LockGL(); |
void UnlockGL(); |
void SwapBuffers(); |
// BView *EmbeddedView(); |
// status_t CopyPixelsOut(BPoint source, BBitmap *dest); |
// status_t CopyPixelsIn(BBitmap *source, BPoint dest); |
virtual void ErrorCallback(GLenum errorCode); |
virtual void Draw(BRect updateRect); |
virtual void AttachedToWindow(); |
virtual void AllAttached(); |
virtual void DetachedFromWindow(); |
virtual void AllDetached(); |
virtual void FrameResized(float width, float height); |
// virtual status_t Perform(perform_code d, void *arg); |
// |
// Methods below are pass-throughs to BView for the moment. |
// |
virtual status_t Archive(BMessage *data, bool deep = true) const; |
virtual void MessageReceived(BMessage *msg); |
virtual void SetResizingMode(uint32 mode); |
virtual void Show(); |
virtual void Hide(); |
virtual BHandler *ResolveSpecifier(BMessage *msg, int32 index, |
BMessage *specifier, int32 form, |
const char *property); |
virtual status_t GetSupportedSuites(BMessage *data); |
//void DirectConnected( direct_buffer_info *info ); |
//void EnableDirectMode( bool enabled ); |
private: |
ostgl_context *context; |
BBitmap *bitmaps[2]; |
int currBitmap; |
static BLocker locker; |
}; |
#endif // _glview_h_ |
/programs/develop/libraries/TinyGL/BeOS/Makefile |
---|
0,0 → 1,16 |
OBJS=GLView.o |
INCLUDES = -I../include |
LIB = libGLView.a |
all: $(LIB) |
$(LIB): $(OBJS) |
rm -f $(LIB) |
ar rcs $(LIB) $(OBJS) |
cp $(LIB) ../lib |
clean: |
rm -f *~ *.o *.a |
GLView.o: GLView.cpp GLView.h |
$(CC) $(CFLAGS) $(INCLUDES) -c GLView.cpp |
/programs/develop/libraries/TinyGL/Changelog |
---|
0,0 → 1,48 |
version 0.41: iadn |
- support for KolibriOS (added kosgl.h, kosgl.c, |
modifications zfeatures.h, glColor4f, glColor4fv, glMaterialfv, glClearColor, ZB_resize) |
- added module glu in library |
- added gluLookAt, RGBFtoRGBI |
- modifications ZB_open, gl_malloc, gl_free, gl_zalloc, gl_get_context |
- fixed bug in gl_draw_line, updateTmp, gl_draw_triangle_clip, zline.h (for INTERP_RGB definition r,g,b ) |
- TINYGL library tells where is library extracted |
- build on mingw |
version 0.4: |
- added 24/32 bit rendering support (Olivier Landemarre - F. Bellard) |
- fixed GL_TRIANGLE_STRIP (Olivier Landemarre) |
- added gl_malloc, gl_free, gl_zalloc wrappers (Olivier Landemarre) |
version 0.3: |
- added NanoX API (nglx) (F. Bellard) |
- added gears example and unified GUI in examples (F. Bellard) |
- added TGL_FEATURE_RENDER_BITS so that it will be possible to render |
natively in 15/16/24 or 32 bits. (F. Bellard) |
- interpolated lines (Olivier Landemarre) |
- fast no shading case (Olivier Landemarre) |
- fast no projection case (Olivier Landemarre) |
version 0.2: Fabrice Bellard |
- added 24/32 bpp support. Added some features.h ifdefs. |
- fixed some error reporting cases in the examples |
- endianness is deduced from the glibc (BYTE_ORDER macro) |
version 0.19: Peder Blekken |
- new files BeOS/* src/msghandling.*, src/arrays.*, src/oscontext.c |
include/GL/oscontext.h src/features.h |
- added support for BeOS, see README.BEOS |
- added support for drawing convex polygons with unlimited # of vertices |
- added support for GL_LIGHT_MODEL_TWO_SIDE |
- added generic rotation code for glopRotate |
- added support for opengl 1.1 arrays |
- added support for glPolygonOffset, not implemented. |
- added glGetFloatv, limited support. |
- added some pnames for glGetIntegerv |
- added some empty functions in include/GL/gl.h to compile VRMLView |
- added GL_VERSION_1_1 define in include/GL/gl.h |
- fixed "bug" when context->gl_resize_viewport is not set. |
- fixed bug in glBindTexture (didn't accept texture object 0) |
version 0.1: |
- Initial revision, Fabrice Bellard |
/programs/develop/libraries/TinyGL/INSTALL |
---|
0,0 → 1,10 |
Installation: |
- Edit config.mk and change what is needed. You can also look at |
src/zfeatures.h to change very specific details (only useful to tune |
TinyGL to your needs). You can link the examples with either OpenGL, |
Mesa or TinyGL. |
- Type 'make'. The library 'libTinyGL.a' is copied into './lib'. The |
examples are build in './examples'. Only the directories './lib' and |
'./include' are needed to use TinyGL from another program. |
/programs/develop/libraries/TinyGL/Install.ru |
---|
0,0 → 1,7 |
Ó âàñ äîëæíà áûòü óñòàíîâëåíà áèáëèîòåêà menuetlibc äëÿ Êîëèáðè. |
Ñîçäàéòå ïåðåìåííóþ TINYGL â êà÷åñòâå çíà÷åíèÿ êîòîðîé çàäàéòå ïóòü |
ê äàííîìó êàòàëîãó. |
Èç ýòîãî êàòàëîãà âûïîëíèòå êîìàíäó make. |
 ïîäêàòàëîãàõ ðàçìåùåíû |
'./include' - çàãîëîâî÷íûå ôàéëû áèáëèîòåêè |
'./lib ' - ñêîìïèëèðîâàííàÿ áèáëèîòåêà |
/programs/develop/libraries/TinyGL/LICENCE |
---|
0,0 → 1,22 |
Copyright notice: |
(C) 1997-1998 Fabrice Bellard |
This software is provided 'as-is', without any express or implied |
warranty. In no event will the authors be held liable for any damages |
arising from the use of this software. |
Permission is granted to anyone to use this software for any purpose, |
including commercial applications, and to alter it and redistribute it |
freely, subject to the following restrictions: |
1. The origin of this software must not be misrepresented; you must not |
claim that you wrote the original software. If you use this software |
in a product, an acknowledgment in the product and its documentation |
*is* required. |
2. Altered source versions must be plainly marked as such, and must not be |
misrepresented as being the original software. |
3. This notice may not be removed or altered from any source distribution. |
If you redistribute modified sources, I would appreciate that you |
include in the files history information documenting your changes. |
/programs/develop/libraries/TinyGL/LIMITATIONS |
---|
0,0 → 1,206 |
Here are listed the functions that TinyGL understands with the known |
limitations. The non mentionned functions are *not* implemented and |
must not be used. |
************ glEnable / glDisable |
- The following flags are handled: |
GL_CULL_FACE, GL_LIGHTING, GL_COLOR_MATERIAL, GL_TEXTURE_2D, GL_NORMALIZE, |
GL_LIGHTx, GL_POLYGON_OFFSET_FILL, GL_POLYGON_OFFSET_POINT, |
GL_POLYGON_OFFSET_LINE |
- GL_DEPTH_TEST is accepted, but it is only used for lines. For all |
other primitives, Z buffer use is assumed. The DepthMode is |
hardcoded as GL_LESS (OpenGL default). |
************ glShadeModel |
OK. |
************ glCullFace |
OK. |
************ glPolygonMode |
OK. |
************ glBegin |
No tests are performed to prevent some functions of being executed |
between glBegin/glEnd. |
************ glEnd |
OK. |
************ glVertex |
Some prototypes are not implemented. |
************ glColor |
Some prototypes are not implemented. |
************ glNormal |
Some prototypes are not implemented. |
************ glTexCoord |
- Some prototypes are not implemented. |
- The Matrix transformation is not applied yet. |
************ glEdgeFlag |
OK. The edge handling has to be tested, although it is not much useful |
in TinyGL. |
************ glMatrixMode / glLoadMatrixf / glLoadIdentity / glMultMatrixf / |
glPushMatrix / glPopMatrix / glRotatef / glTranslatef / glScalef / |
glFrustum |
- The prototypes with doubles are not implemented. |
************ glViewport |
GlViewport calls a function pointers to tell glx (or another display |
system) to resize the Z buffer and the ximage. Made optional in |
version 0.2. |
************ glGenLists / glIsList / glNewList / glEndList / glCallList |
OK. |
************ glClear / glClearColor / glClearDepth |
The whole zbuffer and the colors are cleared in any case. The clear color |
can be redefined, by *not* the initial z value. |
************ glRenderMode |
Only the modes GL_RENDER and GL_SELECT are implemented. |
************ glSelectBuffer / glInitNames / glPushName / glPopName / glLoadName |
OK. |
************ glGenTextures / glDeleteTextures / glBindTexture |
OK. These functions should be used to get the maximum performance with |
TinyGL. |
************ glTexImage2D |
The function accepts only RGB UNSIGNED_BYTES bitmaps. They are |
internally resized to 256x256 so you'd better use that size. No |
mipmapping is implemented although it will come if asked. No borders |
are implemented. |
************ glTexEnvi |
The only supported mode is GL_DECAL, although others are planned if |
asked. |
************ glTexParameteri |
The other prototypes are not implemented. Only the follwing mode are |
implemented: |
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); |
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); |
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); |
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); |
************ glPixelStorei |
The pixels are alware byte aligned. |
************ glMaterialfv / glMaterialf / glColorMaterial |
OK. |
************ glLightfv / glLightf / glLightModeli / glLightModelfv |
OK. The OpenGL lightening is implemented but not optimized. |
************ glFlush |
Ignored. |
************ glHint |
Ignored. |
************ glGetIntegerv |
- only GL_VIEWPORT, GL_MAX_MODELVIEW_STACK_DEPTH, |
GL_MAX_PROJECTION_STACK_DEPTH, GL_MAX_LIGHTS, GL_MAX_TEXTURE_SIZE, |
GL_MAX_TEXTURE_STACK_DEPTH |
************ glGetIntegerv |
- only GL_TEXTURE_MATRIX, GL_PROJECTION_MATRIX, GL_MODELVIEW_MATRIX, |
GL_LINE_WIDTH, GL_LINE_WIDTH_RANGE, GL_POINT_SIZE, GL_POINT_SIZE_RANGE |
************ glPolygonOffset |
- only API implemented. |
************ glEnableClientState, glDisableClientState, |
- No support for GL_INDEX_ARRAY_POINTER or GL_EDGE_FLAG_ARRAY_POINTER |
************ glVertexPointer, glNormalPointer, |
glColorPointer, glTexureCoordPointer |
- OK |
------------------------------------------------------------------------------ |
TinyGL GLX emulation: |
************ glXQueryExtension |
Returns always True |
************ glXChooseVisual |
Only 8 bit Pseudocolor or 16 bit Truecolor Visual are accepted. The |
attribute list is ignored. |
************ glXCreateContext |
The sharing is not implemented although the code could handle it. |
************ glXDestroyContext |
OK. |
************ glXMakeCurrent |
Not all the syntax is supported yet, in particular with the 'NULL' or |
'None' parameters. |
************ glXSwapBuffers |
OK. |
************ glXWaitGL / glXWaitX |
Ignored. |
See README.BEOS for BeOS limitations. |
/programs/develop/libraries/TinyGL/Makefile |
---|
0,0 → 1,7 |
all: |
make -C src |
clean: |
make -C src clean |
/programs/develop/libraries/TinyGL/README |
---|
0,0 → 1,150 |
TinyGL 0.4 (c) 1997-2002 Fabrice Bellard. |
General Description: |
-------------------- |
TinyGL is intended to be a very small implementation of a subset of |
OpenGL* for embedded systems or games. It is a software only |
implementation. Only the main OpenGL calls are implemented. All the |
calls I considered not important are simply *not implemented*. |
The main strength of TinyGL is that it is fast and simple because it |
has not to be exactly compatible with OpenGL. In particular, the |
texture mapping and the geometrical transformations are very fast. |
The main features of TinyGL are: |
- Header compatible with OpenGL (the headers are adapted from the very good |
Mesa by Brian Paul et al.) |
- Zlib-like licence for easy integration in commercial designs (read |
the LICENCE file). |
- Subset of GLX for easy testing with X Window. |
- GLX like API (NGLX) to use it with NanoX in MicroWindows/NanoX. |
- Subset of BGLView under BeOS. |
- OpenGL like lightening. |
- Complete OpenGL selection mode handling for object picking. |
- 16 bit Z buffer. 16/24/32 bit RGB rendering. High speed dithering to |
paletted 8 bits if needed. High speed conversion to 24 bit packed |
pixel or 32 bit RGBA if needed. |
- Fast Gouraud shadding optimized for 16 bit RGB. |
- Fast texture mapping capabilities, with perspective correction and |
texture objects. |
- 32 bit float only arithmetic. |
- Very small: compiled code size of about 40 kB on x86. The file |
src/zfeatures.h can be used to remove some unused features from |
TinyGL. |
- C sources for GCC on 32/64 bit architectures. It has been tested |
succesfully on x86-Linux and sparc-Solaris. |
Examples: |
--------- |
I took three simple examples from the Mesa package to test the main |
functions of TinyGL. You can link them to either TinyGL, Mesa or any |
other OpenGL/GLX implementation. You can also compile them with |
Microwindows. |
- texobj illustrates the use of texture objects. Its shows the speed |
of TinyGL in this case. |
- glutmech comes from the GLUT packages. It is much bigger and slower |
because it uses the lightening. I have just included some GLU |
functions and suppressed the GLUT related code to make it work. It |
shows the display list handling of TinyGL in particular. You can look |
at the source code to learn the keys to move the robot. The key 't' |
toggles between shaded rendering and wire frame. |
- You can download and compile the VReng project to see that TinyGL |
has been successfully used in a big project |
(http://www-inf.enst.fr/vreng). |
Architecture: |
------------- |
TinyGL is made up four main modules: |
- Mathematical routines (zmath). |
- OpenGL-like emulation (zgl). |
- Z buffer and rasterisation (zbuffer). |
- GLX interface (zglx). |
To use TinyGL in an embedded system, you should look at the GLX layer |
and modify it to suit your need. Adding a more user friendly |
developper layer (as in Mesa) may be useful. |
Notes - limitations: |
-------------------- |
- See the file 'LIMITATIONS' to see the current functions supported by the API. |
- The multithreading could be easily implemented since no global state |
is maintainted. The library gets the current context with a function |
which can be modified. |
- The lightening is not very fast. I supposed that in most games the |
lightening is computed by the 3D engine. |
- Some changes are needed for 64 bit pointers for the handling of |
arrays of float with the GLParam union. |
- List sharing is partialy supported in the source, but not by the |
current TinyGLX implementation (is it really useful ?). |
- No user clipping planes are supported. |
- No color index mode (no longer useful !) |
- The mipmapping is not implemented. |
- The perspecture correction in the mapping code does not use W but |
1/Z. In any 'normal scene' it should work. |
- The resizing of the viewport in TinyGLX ensures that the width and |
the height are multiples of 4. This is not optimal because some pixels |
of the window may not be refreshed. |
Why ? |
----- |
TinyGL was developped as a student project for a Virtual Reality |
network system called VReng (see the VReng home page at |
http://www-inf.enst.fr/vreng). |
At that time (January 1997), my initial project was to write my own 3D |
rasterizer based on some old sources I wrote. But I realized that it |
would be better to use OpenGL to work on any platform. My problem was |
that I wanted to use texture mapping which was (and is still) quite |
slower on many software OpenGL implementation. I could have modified |
Mesa to suit my needs, but I really wanted to use my old sources for |
that project. |
I finally decided to use the same syntax as OpenGL but with my own |
libraries, thinking that later it could ease the porting of VReng to |
OpenGL. |
Now VReng is at last compatible with OpenGL, and I managed to patch |
TinyGL so that VReng can still work with it without any modifications. |
Since TinyGL may be useful for some people, especially in the world of |
embedded designs, I decided to release it 'as is', otherwise, it would |
have been lost on my hard disk ! |
------------------------------------------------------------------------------ |
* OpenGL(R) is a registered trademark of Silicon Graphics, Inc. |
------------------------------------------------------------------------------ |
Fabrice Bellard. |
/programs/develop/libraries/TinyGL/config.mk |
---|
0,0 → 1,7 |
##################################################################### |
# C compiler |
CC= gcc |
CFLAGS= -c -nodefaultlibs -mmmx -mtune=pentiumpro -O2 -w |
/programs/develop/libraries/TinyGL/examples/Makefile |
---|
0,0 → 1,29 |
include ../config.mk |
PROGS = mech texobj gears spin |
all: $(PROGS) |
clean: |
rm -f core *.o *~ $(PROGS) |
mech: mech.o glu.o $(UI_OBJS) $(GL_DEPS) |
$(CC) $(LFLAGS) $^ -o $@ $(GL_LIBS) $(UI_LIBS) -lm |
texobj: texobj.o $(UI_OBJS) $(GL_DEPS) |
$(CC) $(LFLAGS) $^ -o $@ $(GL_LIBS) $(UI_LIBS) -lm |
gears: gears.o $(UI_OBJS) $(GL_DEPS) |
$(CC) $(LFLAGS) $^ -o $@ $(GL_LIBS) $(UI_LIBS) -lm |
spin: spin.o $(UI_OBJS) $(GL_DEPS) |
$(CC) $(LFLAGS) $^ -o $@ $(GL_LIBS) $(UI_LIBS) -lm |
.c.o: |
$(CC) $(CFLAGS) $(GL_INCLUDES) $(UI_INCLUDES) -c $*.c |
mech.o: glu.h |
glu.o: glu.h |
ui.o: ui.h |
/programs/develop/libraries/TinyGL/examples/gears.c |
---|
0,0 → 1,300 |
/* gears.c */ |
/* |
* 3-D gear wheels. This program is in the public domain. |
* |
* Brian Paul |
*/ |
#include <math.h> |
#include <stdlib.h> |
#include <stdio.h> |
#include <string.h> |
#include <GL/glx.h> |
#include <GL/gl.h> |
#include "ui.h" |
#ifndef M_PI |
# define M_PI 3.14159265 |
#endif |
/* |
* Draw a gear wheel. You'll probably want to call this function when |
* building a display list since we do a lot of trig here. |
* |
* Input: inner_radius - radius of hole at center |
* outer_radius - radius at center of teeth |
* width - width of gear |
* teeth - number of teeth |
* tooth_depth - depth of tooth |
*/ |
static void gear( GLfloat inner_radius, GLfloat outer_radius, GLfloat width, |
GLint teeth, GLfloat tooth_depth ) |
{ |
GLint i; |
GLfloat r0, r1, r2; |
GLfloat angle, da; |
GLfloat u, v, len; |
r0 = inner_radius; |
r1 = outer_radius - tooth_depth/2.0; |
r2 = outer_radius + tooth_depth/2.0; |
da = 2.0*M_PI / teeth / 4.0; |
glShadeModel( GL_FLAT ); |
glNormal3f( 0.0, 0.0, 1.0 ); |
/* draw front face */ |
glBegin( GL_QUAD_STRIP ); |
for (i=0;i<=teeth;i++) { |
angle = i * 2.0*M_PI / teeth; |
glVertex3f( r0*cos(angle), r0*sin(angle), width*0.5 ); |
glVertex3f( r1*cos(angle), r1*sin(angle), width*0.5 ); |
glVertex3f( r0*cos(angle), r0*sin(angle), width*0.5 ); |
glVertex3f( r1*cos(angle+3*da), r1*sin(angle+3*da), width*0.5 ); |
} |
glEnd(); |
/* draw front sides of teeth */ |
glBegin( GL_QUADS ); |
da = 2.0*M_PI / teeth / 4.0; |
for (i=0;i<teeth;i++) { |
angle = i * 2.0*M_PI / teeth; |
glVertex3f( r1*cos(angle), r1*sin(angle), width*0.5 ); |
glVertex3f( r2*cos(angle+da), r2*sin(angle+da), width*0.5 ); |
glVertex3f( r2*cos(angle+2*da), r2*sin(angle+2*da), width*0.5 ); |
glVertex3f( r1*cos(angle+3*da), r1*sin(angle+3*da), width*0.5 ); |
} |
glEnd(); |
glNormal3f( 0.0, 0.0, -1.0 ); |
/* draw back face */ |
glBegin( GL_QUAD_STRIP ); |
for (i=0;i<=teeth;i++) { |
angle = i * 2.0*M_PI / teeth; |
glVertex3f( r1*cos(angle), r1*sin(angle), -width*0.5 ); |
glVertex3f( r0*cos(angle), r0*sin(angle), -width*0.5 ); |
glVertex3f( r1*cos(angle+3*da), r1*sin(angle+3*da), -width*0.5 ); |
glVertex3f( r0*cos(angle), r0*sin(angle), -width*0.5 ); |
} |
glEnd(); |
/* draw back sides of teeth */ |
glBegin( GL_QUADS ); |
da = 2.0*M_PI / teeth / 4.0; |
for (i=0;i<teeth;i++) { |
angle = i * 2.0*M_PI / teeth; |
glVertex3f( r1*cos(angle+3*da), r1*sin(angle+3*da), -width*0.5 ); |
glVertex3f( r2*cos(angle+2*da), r2*sin(angle+2*da), -width*0.5 ); |
glVertex3f( r2*cos(angle+da), r2*sin(angle+da), -width*0.5 ); |
glVertex3f( r1*cos(angle), r1*sin(angle), -width*0.5 ); |
} |
glEnd(); |
/* draw outward faces of teeth */ |
glBegin( GL_QUAD_STRIP ); |
for (i=0;i<teeth;i++) { |
angle = i * 2.0*M_PI / teeth; |
glVertex3f( r1*cos(angle), r1*sin(angle), width*0.5 ); |
glVertex3f( r1*cos(angle), r1*sin(angle), -width*0.5 ); |
u = r2*cos(angle+da) - r1*cos(angle); |
v = r2*sin(angle+da) - r1*sin(angle); |
len = sqrt( u*u + v*v ); |
u /= len; |
v /= len; |
glNormal3f( v, -u, 0.0 ); |
glVertex3f( r2*cos(angle+da), r2*sin(angle+da), width*0.5 ); |
glVertex3f( r2*cos(angle+da), r2*sin(angle+da), -width*0.5 ); |
glNormal3f( cos(angle), sin(angle), 0.0 ); |
glVertex3f( r2*cos(angle+2*da), r2*sin(angle+2*da), width*0.5 ); |
glVertex3f( r2*cos(angle+2*da), r2*sin(angle+2*da), -width*0.5 ); |
u = r1*cos(angle+3*da) - r2*cos(angle+2*da); |
v = r1*sin(angle+3*da) - r2*sin(angle+2*da); |
glNormal3f( v, -u, 0.0 ); |
glVertex3f( r1*cos(angle+3*da), r1*sin(angle+3*da), width*0.5 ); |
glVertex3f( r1*cos(angle+3*da), r1*sin(angle+3*da), -width*0.5 ); |
glNormal3f( cos(angle), sin(angle), 0.0 ); |
} |
glVertex3f( r1*cos(0), r1*sin(0), width*0.5 ); |
glVertex3f( r1*cos(0), r1*sin(0), -width*0.5 ); |
glEnd(); |
glShadeModel( GL_SMOOTH ); |
/* draw inside radius cylinder */ |
glBegin( GL_QUAD_STRIP ); |
for (i=0;i<=teeth;i++) { |
angle = i * 2.0*M_PI / teeth; |
glNormal3f( -cos(angle), -sin(angle), 0.0 ); |
glVertex3f( r0*cos(angle), r0*sin(angle), -width*0.5 ); |
glVertex3f( r0*cos(angle), r0*sin(angle), width*0.5 ); |
} |
glEnd(); |
} |
static GLfloat view_rotx=20.0, view_roty=30.0, view_rotz=0.0; |
static GLint gear1, gear2, gear3; |
static GLfloat angle = 0.0; |
static GLuint limit; |
static GLuint count = 1; |
void draw( void ) |
{ |
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); |
glPushMatrix(); |
glRotatef( view_rotx, 1.0, 0.0, 0.0 ); |
glRotatef( view_roty, 0.0, 1.0, 0.0 ); |
glRotatef( view_rotz, 0.0, 0.0, 1.0 ); |
glPushMatrix(); |
glTranslatef( -3.0, -2.0, 0.0 ); |
glRotatef( angle, 0.0, 0.0, 1.0 ); |
glCallList(gear1); |
glPopMatrix(); |
glPushMatrix(); |
glTranslatef( 3.1, -2.0, 0.0 ); |
glRotatef( -2.0*angle-9.0, 0.0, 0.0, 1.0 ); |
glCallList(gear2); |
glPopMatrix(); |
glPushMatrix(); |
glTranslatef( -3.1, 4.2, 0.0 ); |
glRotatef( -2.0*angle-25.0, 0.0, 0.0, 1.0 ); |
glCallList(gear3); |
glPopMatrix(); |
glPopMatrix(); |
tkSwapBuffers(); |
count++; |
if (count==limit) { |
exit(0); |
} |
} |
void idle( void ) |
{ |
angle += 2.0; |
draw(); |
} |
/* change view angle, exit upon ESC */ |
GLenum key(int k, GLenum mask) |
{ |
switch (k) { |
case KEY_UP: |
view_rotx += 5.0; |
return GL_TRUE; |
case KEY_DOWN: |
view_rotx -= 5.0; |
return GL_TRUE; |
case KEY_LEFT: |
view_roty += 5.0; |
return GL_TRUE; |
case KEY_RIGHT: |
view_roty -= 5.0; |
return GL_TRUE; |
case 'z': |
view_rotz += 5.0; |
return GL_TRUE; |
case 'Z': |
view_rotz -= 5.0; |
return GL_TRUE; |
case KEY_ESCAPE: |
exit(0); |
} |
return GL_FALSE; |
} |
/* new window size or exposure */ |
void reshape( int width, int height ) |
{ |
GLfloat h = (GLfloat) height / (GLfloat) width; |
glViewport(0, 0, (GLint)width, (GLint)height); |
glMatrixMode(GL_PROJECTION); |
glLoadIdentity(); |
glFrustum( -1.0, 1.0, -h, h, 5.0, 60.0 ); |
glMatrixMode(GL_MODELVIEW); |
glLoadIdentity(); |
glTranslatef( 0.0, 0.0, -40.0 ); |
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); |
} |
void init( void ) |
{ |
static GLfloat pos[4] = {5.0, 5.0, 10.0, 0.0 }; |
static GLfloat red[4] = {0.8, 0.1, 0.0, 1.0 }; |
static GLfloat green[4] = {0.0, 0.8, 0.2, 1.0 }; |
static GLfloat blue[4] = {0.2, 0.2, 1.0, 1.0 }; |
glLightfv( GL_LIGHT0, GL_POSITION, pos ); |
glEnable( GL_CULL_FACE ); |
glEnable( GL_LIGHTING ); |
glEnable( GL_LIGHT0 ); |
glEnable( GL_DEPTH_TEST ); |
/* make the gears */ |
gear1 = glGenLists(1); |
glNewList(gear1, GL_COMPILE); |
glMaterialfv( GL_FRONT, GL_AMBIENT_AND_DIFFUSE, red ); |
gear( 1.0, 4.0, 1.0, 20, 0.7 ); |
glEndList(); |
gear2 = glGenLists(1); |
glNewList(gear2, GL_COMPILE); |
glMaterialfv( GL_FRONT, GL_AMBIENT_AND_DIFFUSE, green ); |
gear( 0.5, 2.0, 2.0, 10, 0.7 ); |
glEndList(); |
gear3 = glGenLists(1); |
glNewList(gear3, GL_COMPILE); |
glMaterialfv( GL_FRONT, GL_AMBIENT_AND_DIFFUSE, blue ); |
gear( 1.3, 2.0, 0.5, 10, 0.7 ); |
glEndList(); |
glEnable( GL_NORMALIZE ); |
} |
int main(int argc, char **argv) |
{ |
if (argc>1) { |
/* do 'n' frames then exit */ |
limit = atoi( argv[1] ) + 1; |
} |
else { |
limit = 0; |
} |
return ui_loop(argc, argv, "gears"); |
} |
/programs/develop/libraries/TinyGL/examples/glu.c |
---|
0,0 → 1,261 |
#include <stdlib.h> |
#include <math.h> |
#include <GL/gl.h> |
#include "glu.h" |
void drawTorus(float rc, int numc, float rt, int numt) |
{ |
int i, j, k; |
double s, t; |
double x, y, z; |
double pi, twopi; |
pi = 3.14159265358979323846; |
twopi = 2 * pi; |
for (i = 0; i < numc; i++) { |
glBegin(GL_QUAD_STRIP); |
for (j = 0; j <= numt; j++) { |
for (k = 1; k >= 0; k--) { |
s = (i + k) % numc + 0.5; |
t = j % numt; |
x = cos(t*twopi/numt) * cos(s*twopi/numc); |
y = sin(t*twopi/numt) * cos(s*twopi/numc); |
z = sin(s*twopi/numc); |
glNormal3f(x, y, z); |
x = (rt + rc * cos(s*twopi/numc)) * cos(t*twopi/numt); |
y = (rt + rc * cos(s*twopi/numc)) * sin(t*twopi/numt); |
z = rc * sin(s*twopi/numc); |
glVertex3f(x, y, z); |
} |
} |
glEnd(); |
} |
} |
static void normal3f( GLfloat x, GLfloat y, GLfloat z ) |
{ |
GLdouble mag; |
mag = sqrt( x*x + y*y + z*z ); |
if (mag>0.00001F) { |
x /= mag; |
y /= mag; |
z /= mag; |
} |
glNormal3f( x, y, z ); |
} |
void gluPerspective( GLdouble fovy, GLdouble aspect, |
GLdouble zNear, GLdouble zFar ) |
{ |
GLdouble xmin, xmax, ymin, ymax; |
ymax = zNear * tan( fovy * M_PI / 360.0 ); |
ymin = -ymax; |
xmin = ymin * aspect; |
xmax = ymax * aspect; |
glFrustum( xmin, xmax, ymin, ymax, zNear, zFar ); |
} |
GLUquadricObj *gluNewQuadric(void) |
{ |
return NULL; |
} |
void gluQuadricDrawStyle(GLUquadricObj *obj, int style) |
{ |
} |
void gluCylinder( GLUquadricObj *qobj, |
GLdouble baseRadius, GLdouble topRadius, GLdouble height, |
GLint slices, GLint stacks ) |
{ |
GLdouble da, r, dr, dz; |
GLfloat z, nz, nsign; |
GLint i, j; |
GLfloat du = 1.0 / slices; |
GLfloat dv = 1.0 / stacks; |
GLfloat tcx = 0.0, tcy = 0.0; |
nsign = 1.0; |
da = 2.0*M_PI / slices; |
dr = (topRadius-baseRadius) / stacks; |
dz = height / stacks; |
nz = (baseRadius-topRadius) / height; /* Z component of normal vectors */ |
for (i=0;i<slices;i++) { |
GLfloat x1 = -sin(i*da); |
GLfloat y1 = cos(i*da); |
GLfloat x2 = -sin((i+1)*da); |
GLfloat y2 = cos((i+1)*da); |
z = 0.0; |
r = baseRadius; |
tcy = 0.0; |
glBegin( GL_QUAD_STRIP ); |
for (j=0;j<=stacks;j++) { |
if (nsign==1.0) { |
normal3f( x1*nsign, y1*nsign, nz*nsign ); |
glTexCoord2f(tcx, tcy); |
glVertex3f( x1*r, y1*r, z ); |
normal3f( x2*nsign, y2*nsign, nz*nsign ); |
glTexCoord2f(tcx+du, tcy); |
glVertex3f( x2*r, y2*r, z ); |
} |
else { |
normal3f( x2*nsign, y2*nsign, nz*nsign ); |
glTexCoord2f(tcx, tcy); |
glVertex3f( x2*r, y2*r, z ); |
normal3f( x1*nsign, y1*nsign, nz*nsign ); |
glTexCoord2f(tcx+du, tcy); |
glVertex3f( x1*r, y1*r, z ); |
} |
z += dz; |
r += dr; |
tcy += dv; |
} |
glEnd(); |
tcx += du; |
} |
} |
/* Disk (adapted from Mesa) */ |
void gluDisk( GLUquadricObj *qobj, |
GLdouble innerRadius, GLdouble outerRadius, |
GLint slices, GLint loops ) |
{ |
GLdouble a, da; |
GLfloat dr; |
GLfloat r1, r2, dtc; |
GLint s, l; |
GLfloat sa,ca; |
/* Normal vectors */ |
glNormal3f( 0.0, 0.0, +1.0 ); |
da = 2.0*M_PI / slices; |
dr = (outerRadius-innerRadius) / (GLfloat) loops; |
/* texture of a gluDisk is a cut out of the texture unit square */ |
/* x, y in [-outerRadius, +outerRadius]; s, t in [0, 1] (linear mapping) */ |
dtc = 2.0f * outerRadius; |
r1 = innerRadius; |
for (l=0;l<loops;l++) { |
r2 = r1 + dr; |
glBegin( GL_QUAD_STRIP ); |
for (s=0;s<=slices;s++) { |
if (s==slices) a = 0.0; |
else a = s * da; |
sa = sin(a); ca = cos(a); |
glTexCoord2f(0.5+sa*r2/dtc,0.5+ca*r2/dtc); |
glVertex2f( r2*sa, r2*ca ); |
glTexCoord2f(0.5+sa*r1/dtc,0.5+ca*r1/dtc); |
glVertex2f( r1*sa, r1*ca ); |
} |
glEnd(); |
r1 = r2; |
} |
} |
/* |
* Sphère (adapted from Mesa) |
*/ |
void gluSphere(GLUquadricObj *qobj, |
float radius,int slices,int stacks) |
{ |
float rho, drho, theta, dtheta; |
float x, y, z; |
float s, t, ds, dt; |
int i, j, imin, imax; |
int normals; |
float nsign; |
normals=1; |
nsign=1; |
drho = M_PI / (float) stacks; |
dtheta = 2.0 * M_PI / (float) slices; |
/* draw +Z end as a triangle fan */ |
glBegin( GL_TRIANGLE_FAN ); |
glNormal3f( 0.0, 0.0, 1.0 ); |
glTexCoord2f(0.5,0.0); |
glVertex3f( 0.0, 0.0, nsign * radius ); |
for (j=0;j<=slices;j++) { |
theta = (j==slices) ? 0.0 : j * dtheta; |
x = -sin(theta) * sin(drho); |
y = cos(theta) * sin(drho); |
z = nsign * cos(drho); |
if (normals) glNormal3f( x*nsign, y*nsign, z*nsign ); |
glVertex3f( x*radius, y*radius, z*radius ); |
} |
glEnd(); |
ds = 1.0 / slices; |
dt = 1.0 / stacks; |
t = 1.0; /* because loop now runs from 0 */ |
if (1) { |
imin = 0; |
imax = stacks; |
} |
else { |
imin = 1; |
imax = stacks-1; |
} |
/* draw intermediate stacks as quad strips */ |
for (i=imin;i<imax;i++) { |
rho = i * drho; |
glBegin( GL_QUAD_STRIP ); |
s = 0.0; |
for (j=0;j<=slices;j++) { |
theta = (j==slices) ? 0.0 : j * dtheta; |
x = -sin(theta) * sin(rho); |
y = cos(theta) * sin(rho); |
z = nsign * cos(rho); |
if (normals) glNormal3f( x*nsign, y*nsign, z*nsign ); |
glTexCoord2f(s,1-t); |
glVertex3f( x*radius, y*radius, z*radius ); |
x = -sin(theta) * sin(rho+drho); |
y = cos(theta) * sin(rho+drho); |
z = nsign * cos(rho+drho); |
if (normals) glNormal3f( x*nsign, y*nsign, z*nsign ); |
glTexCoord2f(s,1-(t-dt)); |
s += ds; |
glVertex3f( x*radius, y*radius, z*radius ); |
} |
glEnd(); |
t -= dt; |
} |
/* draw -Z end as a triangle fan */ |
glBegin( GL_TRIANGLE_FAN ); |
glNormal3f( 0.0, 0.0, -1.0 ); |
glTexCoord2f(0.5,1.0); |
glVertex3f( 0.0, 0.0, -radius*nsign ); |
rho = M_PI - drho; |
s = 1.0; |
t = dt; |
for (j=slices;j>=0;j--) { |
theta = (j==slices) ? 0.0 : j * dtheta; |
x = -sin(theta) * sin(rho); |
y = cos(theta) * sin(rho); |
z = nsign * cos(rho); |
if (normals) glNormal3f( x*nsign, y*nsign, z*nsign ); |
glTexCoord2f(s,1-t); |
s -= ds; |
glVertex3f( x*radius, y*radius, z*radius ); |
} |
glEnd(); |
} |
/programs/develop/libraries/TinyGL/examples/glu.h |
---|
0,0 → 1,23 |
void gluPerspective( GLdouble fovy, GLdouble aspect, |
GLdouble zNear, GLdouble zFar ); |
typedef struct { |
int draw_style; |
} GLUquadricObj; |
#define GLU_LINE 0 |
GLUquadricObj *gluNewQuadric(void); |
void gluQuadricDrawStyle(GLUquadricObj *obj, int style); |
void gluSphere(GLUquadricObj *qobj, |
float radius,int slices,int stacks); |
void gluCylinder( GLUquadricObj *qobj, |
GLdouble baseRadius, GLdouble topRadius, GLdouble height, |
GLint slices, GLint stacks ); |
void gluDisk( GLUquadricObj *qobj, |
GLdouble innerRadius, GLdouble outerRadius, |
GLint slices, GLint loops ); |
void drawTorus(float rc, int numc, float rt, int numt); |
/programs/develop/libraries/TinyGL/examples/mech.c |
---|
0,0 → 1,1753 |
/** |
* program : glutmech V1.1 |
* author : Simon Parkinson-Bates. |
* E-mail : sapb@yallara.cs.rmit.edu.au |
* Copyright Simon Parkinson-Bates. |
* "source if freely avaliable to anyone to copy as long as they |
* acknowledge me in their work." |
* |
* Funtional features |
* ------------------ |
* * online menu system avaliable by pressing left mouse button |
* * online cascading help system avaliable, providing information on |
* the several key strokes and what they do. |
* * animation sequence coded which makes the mech walk through an |
* environment. Shadows will soon be added to make it look |
* more realistic. |
* * menu control to view mech in wireframe or sold mode. |
* * various key strokes avaliable to control idependently the mechs |
* many joints. |
* * various key strokes avaliable to view mech and environment from |
* different angles |
* * various key strokes avaliable to alter positioning of the single |
* light source. |
* |
* |
* Program features |
* ---------------- |
* * uses double buffering |
* * uses display lists |
* * uses glut to manage windows, callbacks, and online menu. |
* * uses glpolygonfill() to maintain colors in wireframe and solid |
* mode. |
* |
**/ |
/* start of compilation conditions */ |
#define SPHERE |
#define COLOR |
#define LIGHT |
#define TORSO |
#define HIP |
#define SHOULDER |
#define UPPER_ARM |
#define LOWER_ARM |
#define ROCKET_POD |
#define UPPER_LEG |
#define LOWER_LEG |
#define NO_NORM |
#define ANIMATION |
#define DRAW_MECH |
#define DRAW_ENVIRO |
#define MOVE_LIGHT |
/* end of compilation conditions */ |
/* start various header files needed */ |
#include <stdlib.h> |
#include <stdio.h> |
#include <math.h> |
#define GLUT |
#define GLUT_KEY |
#define GLUT_SPEC |
#include <GL/gl.h> |
#include <GL/glx.h> |
#include "glu.h" |
#include "ui.h" |
/* end of header files */ |
/* start of display list definitions */ |
#define SOLID_MECH_TORSO 1 |
#define SOLID_MECH_HIP 2 |
#define SOLID_MECH_SHOULDER 3 |
#define SOLID_MECH_UPPER_ARM 4 |
#define SOLID_MECH_FOREARM 5 |
#define SOLID_MECH_UPPER_LEG 6 |
#define SOLID_MECH_FOOT 7 |
#define SOLID_MECH_ROCKET 8 |
#define SOLID_MECH_VULCAN 9 |
#define SOLID_ENVIRO 10 |
/* end of display list definitions */ |
/* start of motion rate variables */ |
#define ANKLE_RATE 3 |
#define HEEL_RATE 3 |
#define ROTATE_RATE 10 |
#define TILT_RATE 10 |
#define ELBOW_RATE 2 |
#define SHOULDER_RATE 5 |
#define LAT_RATE 5 |
#define CANNON_RATE 40 |
#define UPPER_LEG_RATE 3 |
#define UPPER_LEG_RATE_GROIN 10 |
#define LIGHT_TURN_RATE 10 |
#define VIEW_TURN_RATE 10 |
/* end of motion rate variables */ |
/* start of motion variables */ |
#ifndef PI |
#define PI 3.141592654 |
#endif |
char leg = 0; |
int shoulder1 = 0, shoulder2 = 0, shoulder3 = 0, shoulder4 = 0, lat1 = 20, lat2 = 20, |
elbow1 = 0, elbow2 = 0, pivot = 0, tilt = 10, ankle1 = 0, ankle2 = 0, heel1 = 0, |
heel2 = 0, hip11 = 0, hip12 = 10, hip21 = 0, hip22 = 10, fire = 0, solid_part = 0, |
anim = 0, turn = 0, turn1 = 0, lightturn = 0, lightturn1 = 0; |
float elevation = 0.0, distance = 0.0, frame = 3.0 |
/* foot1v[] = {} foot2v[] = {} */ ; |
/* end of motion variables */ |
/* start of material definitions */ |
#ifdef LIGHT |
GLfloat mat_specular[] = |
{0.628281, 0.555802, 0.366065, 1.0}; |
GLfloat mat_ambient[] = |
{0.24725, 0.1995, 0.0745, 1.0}; |
GLfloat mat_diffuse[] = |
{0.75164, 0.60648, 0.22648, 1.0}; |
GLfloat mat_shininess[] = |
{128.0 * 0.4}; |
GLfloat mat_specular2[] = |
{0.508273, 0.508273, 0.508373, 1.0}; |
GLfloat mat_ambient2[] = |
{0.19225, 0.19225, 0.19225, 1.0}; |
GLfloat mat_diffuse2[] = |
{0.50754, 0.50754, 0.50754, 1.0}; |
GLfloat mat_shininess2[] = |
{128.0 * 0.6}; |
GLfloat mat_specular3[] = |
{0.296648, 0.296648, 0.296648, 1.0}; |
GLfloat mat_ambient3[] = |
{0.25, 0.20725, 0.20725, 1.0}; |
GLfloat mat_diffuse3[] = |
{1, 0.829, 0.829, 1.0}; |
GLfloat mat_shininess3[] = |
{128.0 * 0.088}; |
GLfloat mat_specular4[] = |
{0.633, 0.727811, 0.633, 1.0}; |
GLfloat mat_ambient4[] = |
{0.0215, 0.1745, 0.0215, 1.0}; |
GLfloat mat_diffuse4[] = |
{0.07568, 0.61424, 0.07568, 1.0}; |
GLfloat mat_shininess4[] = |
{128 * 0.6}; |
GLfloat mat_specular5[] = |
{0.60, 0.60, 0.50, 1.0}; |
GLfloat mat_ambient5[] = |
{0.0, 0.0, 0.0, 1.0}; |
GLfloat mat_diffuse5[] = |
{0.5, 0.5, 0.0, 1.0}; |
GLfloat mat_shininess5[] = |
{128.0 * 0.25}; |
#endif |
/* end of material definitions */ |
/* start of the body motion functions */ |
void |
Heel1Add(void) |
{ |
heel1 = (heel1 + HEEL_RATE) % 360; |
} |
void |
Heel1Subtract(void) |
{ |
heel1 = (heel1 - HEEL_RATE) % 360; |
} |
void |
Heel2Add(void) |
{ |
heel2 = (heel2 + HEEL_RATE) % 360; |
} |
void |
Heel2Subtract(void) |
{ |
heel2 = (heel2 - HEEL_RATE) % 360; |
} |
void |
Ankle1Add(void) |
{ |
ankle1 = (ankle1 + ANKLE_RATE) % 360; |
} |
void |
Ankle1Subtract(void) |
{ |
ankle1 = (ankle1 - ANKLE_RATE) % 360; |
} |
void |
Ankle2Add(void) |
{ |
ankle2 = (ankle2 + ANKLE_RATE) % 360; |
} |
void |
Ankle2Subtract(void) |
{ |
ankle2 = (ankle2 - ANKLE_RATE) % 360; |
} |
void |
RotateAdd(void) |
{ |
pivot = (pivot + ROTATE_RATE) % 360; |
} |
void |
RotateSubtract(void) |
{ |
pivot = (pivot - ROTATE_RATE) % 360; |
} |
void |
MechTiltSubtract(void) |
{ |
tilt = (tilt - TILT_RATE) % 360; |
} |
void |
MechTiltAdd(void) |
{ |
tilt = (tilt + TILT_RATE) % 360; |
} |
void |
elbow1Add(void) |
{ |
elbow1 = (elbow1 + ELBOW_RATE) % 360; |
} |
void |
elbow1Subtract(void) |
{ |
elbow1 = (elbow1 - ELBOW_RATE) % 360; |
} |
void |
elbow2Add(void) |
{ |
elbow2 = (elbow2 + ELBOW_RATE) % 360; |
} |
void |
elbow2Subtract(void) |
{ |
elbow2 = (elbow2 - ELBOW_RATE) % 360; |
} |
void |
shoulder1Add(void) |
{ |
shoulder1 = (shoulder1 + SHOULDER_RATE) % 360; |
} |
void |
shoulder1Subtract(void) |
{ |
shoulder1 = (shoulder1 - SHOULDER_RATE) % 360; |
} |
void |
shoulder2Add(void) |
{ |
shoulder2 = (shoulder2 + SHOULDER_RATE) % 360; |
} |
void |
shoulder2Subtract(void) |
{ |
shoulder2 = (shoulder2 - SHOULDER_RATE) % 360; |
} |
void |
shoulder3Add(void) |
{ |
shoulder3 = (shoulder3 + SHOULDER_RATE) % 360; |
} |
void |
shoulder3Subtract(void) |
{ |
shoulder3 = (shoulder3 - SHOULDER_RATE) % 360; |
} |
void |
shoulder4Add(void) |
{ |
shoulder4 = (shoulder4 + SHOULDER_RATE) % 360; |
} |
void |
shoulder4Subtract(void) |
{ |
shoulder4 = (shoulder4 - SHOULDER_RATE) % 360; |
} |
void |
lat1Raise(void) |
{ |
lat1 = (lat1 + LAT_RATE) % 360; |
} |
void |
lat1Lower(void) |
{ |
lat1 = (lat1 - LAT_RATE) % 360; |
} |
void |
lat2Raise(void) |
{ |
lat2 = (lat2 + LAT_RATE) % 360; |
} |
void |
lat2Lower(void) |
{ |
lat2 = (lat2 - LAT_RATE) % 360; |
} |
void |
FireCannon(void) |
{ |
fire = (fire + CANNON_RATE) % 360; |
} |
void |
RaiseLeg1Forward(void) |
{ |
hip11 = (hip11 + UPPER_LEG_RATE) % 360; |
} |
void |
LowerLeg1Backwards(void) |
{ |
hip11 = (hip11 - UPPER_LEG_RATE) % 360; |
} |
void |
RaiseLeg1Outwards(void) |
{ |
hip12 = (hip12 + UPPER_LEG_RATE_GROIN) % 360; |
} |
void |
LowerLeg1Inwards(void) |
{ |
hip12 = (hip12 - UPPER_LEG_RATE_GROIN) % 360; |
} |
void |
RaiseLeg2Forward(void) |
{ |
hip21 = (hip21 + UPPER_LEG_RATE) % 360; |
} |
void |
LowerLeg2Backwards(void) |
{ |
hip21 = (hip21 - UPPER_LEG_RATE) % 360; |
} |
void |
RaiseLeg2Outwards(void) |
{ |
hip22 = (hip22 + UPPER_LEG_RATE_GROIN) % 360; |
} |
void |
LowerLeg2Inwards(void) |
{ |
hip22 = (hip22 - UPPER_LEG_RATE_GROIN) % 360; |
} |
/* end of body motion functions */ |
/* start of light source position functions */ |
void |
TurnRight(void) |
{ |
turn = (turn - VIEW_TURN_RATE) % 360; |
} |
void |
TurnLeft(void) |
{ |
turn = (turn + VIEW_TURN_RATE) % 360; |
} |
void |
TurnForwards(void) |
{ |
turn1 = (turn1 - VIEW_TURN_RATE) % 360; |
} |
void |
TurnBackwards(void) |
{ |
turn1 = (turn1 + VIEW_TURN_RATE) % 360; |
} |
void |
LightTurnRight(void) |
{ |
lightturn = (lightturn + LIGHT_TURN_RATE) % 360; |
} |
void |
LightTurnLeft(void) |
{ |
lightturn = (lightturn - LIGHT_TURN_RATE) % 360; |
} |
void |
LightForwards(void) |
{ |
lightturn1 = (lightturn1 + LIGHT_TURN_RATE) % 360; |
} |
void |
LightBackwards(void) |
{ |
lightturn1 = (lightturn1 - LIGHT_TURN_RATE) % 360; |
} |
/* end of light source position functions */ |
/* start of geometric shape functions */ |
void |
Box(float width, float height, float depth, char solid) |
{ |
char i, j = 0; |
float x = width / 2.0, y = height / 2.0, z = depth / 2.0; |
for (i = 0; i < 4; i++) { |
glRotatef(90.0, 0.0, 0.0, 1.0); |
if (j) { |
if (!solid) |
glBegin(GL_LINE_LOOP); |
else |
glBegin(GL_QUADS); |
glNormal3f(-1.0, 0.0, 0.0); |
glVertex3f(-x, y, z); |
glVertex3f(-x, -y, z); |
glVertex3f(-x, -y, -z); |
glVertex3f(-x, y, -z); |
glEnd(); |
if (solid) { |
glBegin(GL_TRIANGLES); |
glNormal3f(0.0, 0.0, 1.0); |
glVertex3f(0.0, 0.0, z); |
glVertex3f(-x, y, z); |
glVertex3f(-x, -y, z); |
glNormal3f(0.0, 0.0, -1.0); |
glVertex3f(0.0, 0.0, -z); |
glVertex3f(-x, -y, -z); |
glVertex3f(-x, y, -z); |
glEnd(); |
} |
j = 0; |
} else { |
if (!solid) |
glBegin(GL_LINE_LOOP); |
else |
glBegin(GL_QUADS); |
glNormal3f(-1.0, 0.0, 0.0); |
glVertex3f(-y, x, z); |
glVertex3f(-y, -x, z); |
glVertex3f(-y, -x, -z); |
glVertex3f(-y, x, -z); |
glEnd(); |
if (solid) { |
glBegin(GL_TRIANGLES); |
glNormal3f(0.0, 0.0, 1.0); |
glVertex3f(0.0, 0.0, z); |
glVertex3f(-y, x, z); |
glVertex3f(-y, -x, z); |
glNormal3f(0.0, 0.0, -1.0); |
glVertex3f(0.0, 0.0, -z); |
glVertex3f(-y, -x, -z); |
glVertex3f(-y, x, -z); |
glEnd(); |
} |
j = 1; |
} |
} |
} |
void |
Octagon(float side, float height, char solid) |
{ |
char j; |
float x = sin(0.785398163) * side, y = side / 2.0, z = height / 2.0, c; |
c = x + y; |
for (j = 0; j < 8; j++) { |
glTranslatef(-c, 0.0, 0.0); |
if (!solid) |
glBegin(GL_LINE_LOOP); |
else |
glBegin(GL_QUADS); |
glNormal3f(-1.0, 0.0, 0.0); |
glVertex3f(0.0, -y, z); |
glVertex3f(0.0, y, z); |
glVertex3f(0.0, y, -z); |
glVertex3f(0.0, -y, -z); |
glEnd(); |
glTranslatef(c, 0.0, 0.0); |
if (solid) { |
glBegin(GL_TRIANGLES); |
glNormal3f(0.0, 0.0, 1.0); |
glVertex3f(0.0, 0.0, z); |
glVertex3f(-c, -y, z); |
glVertex3f(-c, y, z); |
glNormal3f(0.0, 0.0, -1.0); |
glVertex3f(0.0, 0.0, -z); |
glVertex3f(-c, y, -z); |
glVertex3f(-c, -y, -z); |
glEnd(); |
} |
glRotatef(45.0, 0.0, 0.0, 1.0); |
} |
} |
/* end of geometric shape functions */ |
#ifdef NORM |
void |
Normalize(float v[3]) |
{ |
GLfloat d = sqrt(v[1] * v[1] + v[2] * v[2] + v[3] * v[3]); |
if (d == 0.0) { |
printf("zero length vector"); |
return; |
} |
v[1] /= d; |
v[2] /= d; |
v[3] /= d; |
} |
void |
NormXprod(float v1[3], float v2[3], float v[3], float out[3]) |
{ |
GLint i, j; |
GLfloat length; |
out[0] = v1[1] * v2[2] - v1[2] * v2[1]; |
out[1] = v1[2] * v2[0] - v1[0] * v2[2]; |
out[2] = v1[0] * v2[1] - v1[1] * v2[0]; |
Normalize(out); |
} |
#endif |
void |
SetMaterial(GLfloat spec[], GLfloat amb[], GLfloat diff[], GLfloat shin[]) |
{ |
glMaterialfv(GL_FRONT, GL_SPECULAR, spec); |
glMaterialfv(GL_FRONT, GL_SHININESS, shin); |
glMaterialfv(GL_FRONT, GL_AMBIENT, amb); |
glMaterialfv(GL_FRONT, GL_DIFFUSE, diff); |
} |
void |
MechTorso(char solid) |
{ |
glNewList(SOLID_MECH_TORSO, GL_COMPILE); |
#ifdef LIGHT |
SetMaterial(mat_specular, mat_ambient, mat_diffuse, mat_shininess); |
#endif |
glColor3f(1.0, 1.0, 0.0); |
Box(1.0, 1.0, 3.0, solid); |
glTranslatef(0.75, 0.0, 0.0); |
#ifdef LIGHT |
SetMaterial(mat_specular2, mat_ambient2, mat_diffuse2, mat_shininess2); |
#endif |
glColor3f(0.5, 0.5, 0.5); |
Box(0.5, 0.6, 2.0, solid); |
glTranslatef(-1.5, 0.0, 0.0); |
Box(0.5, 0.6, 2.0, solid); |
glTranslatef(0.75, 0.0, 0.0); |
glEndList(); |
} |
void |
MechHip(char solid) |
{ |
int i; |
GLUquadricObj *hip[2]; |
glNewList(SOLID_MECH_HIP, GL_COMPILE); |
#ifdef LIGHT |
SetMaterial(mat_specular, mat_ambient, mat_diffuse, mat_shininess); |
#endif |
glColor3f(1.0, 1.0, 0.0); |
Octagon(0.7, 0.5, solid); |
#ifdef SPHERE |
for (i = 0; i < 2; i++) { |
if (i) |
glScalef(-1.0, 1.0, 1.0); |
glTranslatef(1.0, 0.0, 0.0); |
hip[i] = gluNewQuadric(); |
#ifdef LIGHT |
SetMaterial(mat_specular2, mat_ambient2, mat_diffuse2, mat_shininess2); |
#endif |
glColor3f(0.5, 0.5, 0.5); |
if (!solid) |
gluQuadricDrawStyle(hip[i], GLU_LINE); |
gluSphere(hip[0], 0.2, 16, 16); |
glTranslatef(-1.0, 0.0, 0.0); |
} |
glScalef(-1.0, 1.0, 1.0); |
#endif |
glEndList(); |
} |
void |
Shoulder(char solid) |
{ |
GLUquadricObj *deltoid = gluNewQuadric(); |
glNewList(SOLID_MECH_SHOULDER, GL_COMPILE); |
#ifdef LIGHT |
SetMaterial(mat_specular, mat_ambient, mat_diffuse, mat_shininess); |
#endif |
glColor3f(1.0, 1.0, 0.0); |
Box(1.0, 0.5, 0.5, solid); |
glTranslatef(0.9, 0.0, 0.0); |
#ifdef LIGHT |
SetMaterial(mat_specular2, mat_ambient2, mat_diffuse2, mat_shininess2); |
#endif |
glColor3f(0.5, 0.5, 0.5); |
#ifdef SPHERE |
if (!solid) |
gluQuadricDrawStyle(deltoid, GLU_LINE); |
gluSphere(deltoid, 0.6, 16, 16); |
#endif |
glTranslatef(-0.9, 0.0, 0.0); |
glEndList(); |
} |
void |
UpperArm(char solid) |
{ |
GLUquadricObj *upper = gluNewQuadric(); |
GLUquadricObj *joint[2]; |
GLUquadricObj *joint1[2]; |
int i; |
glNewList(SOLID_MECH_UPPER_ARM, GL_COMPILE); |
#ifdef LIGHT |
SetMaterial(mat_specular, mat_ambient, mat_diffuse, mat_shininess); |
#endif |
glColor3f(1.0, 1.0, 0.0); |
Box(1.0, 2.0, 1.0, solid); |
glTranslatef(0.0, -0.95, 0.0); |
glRotatef(90.0, 1.0, 0.0, 0.0); |
#ifdef LIGHT |
SetMaterial(mat_specular2, mat_ambient2, mat_diffuse2, mat_shininess2); |
#endif |
glColor3f(0.5, 0.5, 0.5); |
if (!solid) |
gluQuadricDrawStyle(upper, GLU_LINE); |
gluCylinder(upper, 0.4, 0.4, 1.5, 16, 10); |
#ifdef LIGHT |
SetMaterial(mat_specular, mat_ambient, mat_diffuse, mat_shininess); |
#endif |
glColor3f(1.0, 1.0, 0.0); |
glRotatef(-90.0, 1.0, 0.0, 0.0); |
glTranslatef(-0.4, -1.85, 0.0); |
glRotatef(90.0, 0.0, 1.0, 0.0); |
for (i = 0; i < 2; i++) { |
joint[i] = gluNewQuadric(); |
if (!solid) |
gluQuadricDrawStyle(joint[i], GLU_LINE); |
if (i) |
gluCylinder(joint[i], 0.5, 0.5, 0.8, 16, 10); |
else |
gluCylinder(joint[i], 0.2, 0.2, 0.8, 16, 10); |
} |
for (i = 0; i < 2; i++) { |
if (i) |
glScalef(-1.0, 1.0, 1.0); |
joint1[i] = gluNewQuadric(); |
if (!solid) |
gluQuadricDrawStyle(joint1[i], GLU_LINE); |
if (i) |
glTranslatef(0.0, 0.0, 0.8); |
gluDisk(joint1[i], 0.2, 0.5, 16, 10); |
if (i) |
glTranslatef(0.0, 0.0, -0.8); |
} |
glScalef(-1.0, 1.0, 1.0); |
glRotatef(-90.0, 0.0, 1.0, 0.0); |
glTranslatef(0.4, 2.9, 0.0); |
glEndList(); |
} |
void |
VulcanGun(char solid) |
{ |
int i; |
GLUquadricObj *Barrel[5]; |
GLUquadricObj *BarrelFace[5]; |
GLUquadricObj *Barrel2[5]; |
GLUquadricObj *Barrel3[5]; |
GLUquadricObj *BarrelFace2[5]; |
GLUquadricObj *Mount = gluNewQuadric(); |
GLUquadricObj *Mount_face = gluNewQuadric(); |
glNewList(SOLID_MECH_VULCAN, GL_COMPILE); |
#ifdef LIGHT |
SetMaterial(mat_specular2, mat_ambient2, mat_diffuse2, mat_shininess2); |
#endif |
glColor3f(0.5, 0.5, 0.5); |
if (!solid) { |
gluQuadricDrawStyle(Mount, GLU_LINE); |
gluQuadricDrawStyle(Mount_face, GLU_LINE); |
} |
gluCylinder(Mount, 0.5, 0.5, 0.5, 16, 10); |
glTranslatef(0.0, 0.0, 0.5); |
gluDisk(Mount_face, 0.0, 0.5, 16, 10); |
for (i = 0; i < 5; i++) { |
Barrel[i] = gluNewQuadric(); |
BarrelFace[i] = gluNewQuadric(); |
BarrelFace2[i] = gluNewQuadric(); |
Barrel2[i] = gluNewQuadric(); |
Barrel3[i] = gluNewQuadric(); |
glRotatef(72.0, 0.0, 0.0, 1.0); |
glTranslatef(0.0, 0.3, 0.0); |
if (!solid) { |
gluQuadricDrawStyle(Barrel[i], GLU_LINE); |
gluQuadricDrawStyle(BarrelFace[i], GLU_LINE); |
gluQuadricDrawStyle(BarrelFace2[i], GLU_LINE); |
gluQuadricDrawStyle(Barrel2[i], GLU_LINE); |
gluQuadricDrawStyle(Barrel3[i], GLU_LINE); |
} |
gluCylinder(Barrel[i], 0.15, 0.15, 2.0, 16, 10); |
gluCylinder(Barrel3[i], 0.06, 0.06, 2.0, 16, 10); |
glTranslatef(0.0, 0.0, 2.0); |
gluDisk(BarrelFace[i], 0.1, 0.15, 16, 10); |
gluCylinder(Barrel2[i], 0.1, 0.1, 0.1, 16, 5); |
glTranslatef(0.0, 0.0, 0.1); |
gluDisk(BarrelFace2[i], 0.06, 0.1, 16, 5); |
glTranslatef(0.0, -0.3, -2.1); |
} |
glEndList(); |
} |
void |
ForeArm(char solid) |
{ |
char i; |
glNewList(SOLID_MECH_FOREARM, GL_COMPILE); |
#ifdef LIGHT |
SetMaterial(mat_specular, mat_ambient, mat_diffuse, mat_shininess); |
#endif |
glColor3f(1.0, 1.0, 0.0); |
for (i = 0; i < 5; i++) { |
glTranslatef(0.0, -0.1, -0.15); |
Box(0.6, 0.8, 0.2, solid); |
glTranslatef(0.0, 0.1, -0.15); |
Box(0.4, 0.6, 0.1, solid); |
} |
glTranslatef(0.0, 0.0, 2.45); |
Box(1.0, 1.0, 2.0, solid); |
glTranslatef(0.0, 0.0, -1.0); |
glEndList(); |
} |
void |
UpperLeg(char solid) |
{ |
int i; |
GLUquadricObj *Hamstring = gluNewQuadric(); |
GLUquadricObj *Knee = gluNewQuadric(); |
GLUquadricObj *joint[2]; |
glNewList(SOLID_MECH_UPPER_LEG, GL_COMPILE); |
#ifdef LIGHT |
SetMaterial(mat_specular, mat_ambient, mat_diffuse, mat_shininess); |
#endif |
glColor3f(1.0, 1.0, 0.0); |
if (!solid) { |
gluQuadricDrawStyle(Hamstring, GLU_LINE); |
gluQuadricDrawStyle(Knee, GLU_LINE); |
} |
glTranslatef(0.0, -1.0, 0.0); |
Box(0.4, 1.0, 0.7, solid); |
glTranslatef(0.0, -0.65, 0.0); |
for (i = 0; i < 5; i++) { |
Box(1.2, 0.3, 1.2, solid); |
glTranslatef(0.0, -0.2, 0.0); |
Box(1.0, 0.1, 1.0, solid); |
glTranslatef(0.0, -0.2, 0.0); |
} |
glTranslatef(0.0, -0.15, -0.4); |
Box(2.0, 0.5, 2.0, solid); |
glTranslatef(0.0, -0.3, -0.2); |
glRotatef(90.0, 1.0, 0.0, 0.0); |
#ifdef LIGHT |
SetMaterial(mat_specular2, mat_ambient2, mat_diffuse2, mat_shininess2); |
#endif |
glColor3f(0.5, 0.5, 0.5); |
gluCylinder(Hamstring, 0.6, 0.6, 3.0, 16, 10); |
#ifdef LIGHT |
SetMaterial(mat_specular, mat_ambient, mat_diffuse, mat_shininess); |
#endif |
glColor3f(1.0, 1.0, 0.0); |
glRotatef(-90.0, 1.0, 0.0, 0.0); |
glTranslatef(0.0, -1.5, 1.0); |
Box(1.5, 3.0, 0.5, solid); |
glTranslatef(0.0, -1.75, -0.8); |
Box(2.0, 0.5, 2.0, solid); |
glTranslatef(0.0, -0.9, -0.85); |
#ifdef LIGHT |
SetMaterial(mat_specular2, mat_ambient2, mat_diffuse2, mat_shininess2); |
#endif |
glColor3f(0.5, 0.5, 0.5); |
gluCylinder(Knee, 0.8, 0.8, 1.8, 16, 10); |
for (i = 0; i < 2; i++) { |
if (i) |
glScalef(-1.0, 1.0, 1.0); |
joint[i] = gluNewQuadric(); |
if (!solid) |
gluQuadricDrawStyle(joint[i], GLU_LINE); |
if (i) |
glTranslatef(0.0, 0.0, 1.8); |
gluDisk(joint[i], 0.0, 0.8, 16, 10); |
if (i) |
glTranslatef(0.0, 0.0, -1.8); |
} |
glScalef(-1.0, 1.0, 1.0); |
glEndList(); |
} |
void |
Foot(char solid) |
{ |
glNewList(SOLID_MECH_FOOT, GL_COMPILE); |
#ifdef LIGHT |
SetMaterial(mat_specular2, mat_ambient2, mat_diffuse2, mat_shininess2); |
#endif |
glColor3f(0.5, 0.5, 0.5); |
glRotatef(90.0, 1.0, 0.0, 0.0); |
Octagon(1.5, 0.6, solid); |
glRotatef(-90.0, 1.0, 0.0, 0.0); |
glEndList(); |
} |
void |
LowerLeg(char solid) |
{ |
float k, l; |
GLUquadricObj *ankle = gluNewQuadric(); |
GLUquadricObj *ankle_face[2],*joints; |
#ifdef LIGHT |
SetMaterial(mat_specular, mat_ambient, mat_diffuse, mat_shininess); |
#endif |
glColor3f(1.0, 1.0, 0.0); |
for (k = 0.0; k < 2.0; k++) { |
for (l = 0.0; l < 2.0; l++) { |
glPushMatrix(); |
glTranslatef(k, 0.0, l); |
#ifdef LIGHT |
SetMaterial(mat_specular, mat_ambient, mat_diffuse, mat_shininess); |
#endif |
glColor3f(1.0, 1.0, 0.0); |
Box(1.0, 0.5, 1.0, solid); |
glTranslatef(0.0, -0.45, 0.0); |
#ifdef LIGHT |
SetMaterial(mat_specular2, mat_ambient2, mat_diffuse2, mat_shininess2); |
#endif |
glColor3f(0.5, 0.5, 0.5); |
#ifdef SPHERE |
joints = gluNewQuadric(); |
if(!solid)gluQuadricDrawStyle(joints, GLU_LINE); |
gluSphere(joints,0.2, 16, 16); |
free(joints); |
#endif |
if (leg) |
glRotatef((GLfloat) heel1, 1.0, 0.0, 0.0); |
else |
glRotatef((GLfloat) heel2, 1.0, 0.0, 0.0); |
/* glTranslatef(0.0, -0.2, 0.0); */ |
glTranslatef(0.0, -1.7, 0.0); |
#ifdef LIGHT |
SetMaterial(mat_specular, mat_ambient, mat_diffuse, mat_shininess); |
#endif |
glColor3f(1.0, 1.0, 0.0); |
Box(0.25, 3.0, 0.25, solid); |
glTranslatef(0.0, -1.7, 0.0); |
#ifdef LIGHT |
SetMaterial(mat_specular2, mat_ambient2, mat_diffuse2, mat_shininess2); |
#endif |
glColor3f(0.5, 0.5, 0.5); |
#ifdef SPHERE |
joints = gluNewQuadric(); |
if(!solid)gluQuadricDrawStyle(joints, GLU_LINE); |
gluSphere(joints, 0.2, 16, 16); |
#endif |
if (leg) |
glRotatef((GLfloat) - heel1, 1.0, 0.0, 0.0); |
else |
glRotatef((GLfloat) - heel2, 1.0, 0.0, 0.0); |
glTranslatef(0.0, -0.45, 0.0); |
#ifdef LIGHT |
SetMaterial(mat_specular, mat_ambient, mat_diffuse, mat_shininess); |
#endif |
glColor3f(1.0, 1.0, 0.0); |
Box(1.0, 0.5, 1.0, solid); |
if (!k && !l) { |
int j; |
glTranslatef(-0.4, -0.8, 0.5); |
if (leg) |
glRotatef((GLfloat) ankle1, 1.0, 0.0, 0.0); |
else |
glRotatef((GLfloat) ankle2, 1.0, 0.0, 0.0); |
glRotatef(90.0, 0.0, 1.0, 0.0); |
if (!solid) |
gluQuadricDrawStyle(ankle, GLU_LINE); |
gluCylinder(ankle, 0.8, 0.8, 1.8, 16, 10); |
for (j = 0; j < 2; j++) { |
ankle_face[j] = gluNewQuadric(); |
if (!solid) |
gluQuadricDrawStyle(ankle_face[j], GLU_LINE); |
if (j) { |
glScalef(-1.0, 1.0, 1.0); |
glTranslatef(0.0, 0.0, 1.8); |
} |
gluDisk(ankle_face[j], 0.0, 0.8, 16, 10); |
if (j) |
glTranslatef(0.0, 0.0, -1.8); |
} |
glScalef(-1.0, 1.0, 1.0); |
glRotatef(-90.0, 0.0, 1.0, 0.0); |
glTranslatef(0.95, -0.8, 0.0); |
glCallList(SOLID_MECH_FOOT); |
} |
glPopMatrix(); |
} |
} |
} |
void |
RocketPod(char solid) |
{ |
int i, j, k = 0; |
GLUquadricObj *rocket[6]; |
GLUquadricObj *rocket1[6]; |
glNewList(SOLID_MECH_ROCKET, GL_COMPILE); |
#ifdef LIGHT |
SetMaterial(mat_specular2, mat_ambient2, mat_diffuse2, mat_shininess2); |
#endif |
glColor3f(0.5, 0.5, 0.5); |
glScalef(0.4, 0.4, 0.4); |
glRotatef(45.0, 0.0, 0.0, 1.0); |
glTranslatef(1.0, 0.0, 0.0); |
Box(2.0, 0.5, 3.0, solid); |
glTranslatef(1.0, 0.0, 0.0); |
glRotatef(45.0, 0.0, 0.0, 1.0); |
glTranslatef(0.5, 0.0, 0.0); |
Box(1.2, 0.5, 3.0, solid); |
glTranslatef(2.1, 0.0, 0.0); |
glRotatef(-90.0, 0.0, 0.0, 1.0); |
#ifdef LIGHT |
SetMaterial(mat_specular, mat_ambient, mat_diffuse, mat_shininess); |
#endif |
glColor3f(1.0, 1.0, 0.0); |
Box(2.0, 3.0, 4.0, solid); |
glTranslatef(-0.5, -1.0, 1.3); |
for (i = 0; i < 2; i++) { |
for (j = 0; j < 3; j++) { |
rocket[k] = gluNewQuadric(); |
rocket1[k] = gluNewQuadric(); |
if (!solid) { |
gluQuadricDrawStyle(rocket[k], GLU_LINE); |
gluQuadricDrawStyle(rocket1[k], GLU_LINE); |
} |
glTranslatef(i, j, 0.6); |
#ifdef LIGHT |
SetMaterial(mat_specular3, mat_ambient3, mat_diffuse3, mat_shininess3); |
#endif |
glColor3f(1.0, 1.0, 1.0); |
gluCylinder(rocket[k], 0.4, 0.4, 0.3, 16, 10); |
glTranslatef(0.0, 0.0, 0.3); |
#ifdef LIGHT |
SetMaterial(mat_specular4, mat_ambient4, mat_diffuse4, mat_shininess4); |
#endif |
glColor3f(0.0, 1.0, 0.0); |
gluCylinder(rocket1[k], 0.4, 0.0, 0.5, 16, 10); |
k++; |
glTranslatef(-i, -j, -0.9); |
} |
} |
glEndList(); |
} |
void |
Enviro(char solid) |
{ |
int i, j; |
glNewList(SOLID_ENVIRO, GL_COMPILE); |
SetMaterial(mat_specular4, mat_ambient4, mat_diffuse4, mat_shininess4); |
glColor3f(0.0, 1.0, 0.0); |
Box(20.0, 0.5, 30.0, solid); |
SetMaterial(mat_specular4, mat_ambient3, mat_diffuse2, mat_shininess); |
glColor3f(0.6, 0.6, 0.6); |
glTranslatef(0.0, 0.0, -10.0); |
for (j = 0; j < 6; j++) { |
for (i = 0; i < 2; i++) { |
if (i) |
glScalef(-1.0, 1.0, 1.0); |
glTranslatef(10.0, 4.0, 0.0); |
Box(4.0, 8.0, 2.0, solid); |
glTranslatef(0.0, -1.0, -3.0); |
Box(4.0, 6.0, 2.0, solid); |
glTranslatef(-10.0, -3.0, 3.0); |
} |
glScalef(-1.0, 1.0, 1.0); |
glTranslatef(0.0, 0.0, 5.0); |
} |
glEndList(); |
} |
void |
Toggle(void) |
{ |
if (solid_part) |
solid_part = 0; |
else |
solid_part = 1; |
} |
void |
disable(void) |
{ |
glDisable(GL_LIGHTING); |
glDisable(GL_DEPTH_TEST); |
glDisable(GL_NORMALIZE); |
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); |
} |
void |
lighting(void) |
{ |
GLfloat position[] = |
{0.0, 0.0, 2.0, 1.0}; |
#ifdef MOVE_LIGHT |
glRotatef((GLfloat) lightturn1, 1.0, 0.0, 0.0); |
glRotatef((GLfloat) lightturn, 0.0, 1.0, 0.0); |
glRotatef(0.0, 1.0, 0.0, 0.0); |
#endif |
glEnable(GL_LIGHTING); |
glEnable(GL_LIGHT0); |
glEnable(GL_NORMALIZE); |
/* glEnable(GL_FLAT); */ |
/* glDepthFunc(GL_LESS); */ |
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); |
glLightfv(GL_LIGHT0, GL_POSITION, position); |
glLightf(GL_LIGHT0, GL_SPOT_CUTOFF, 80.0); |
glTranslatef(0.0, 0.0, 2.0); |
glDisable(GL_LIGHTING); |
Box(0.1, 0.1, 0.1, 0); |
glEnable(GL_LIGHTING); |
/* glEnable(GL_CULL_FACE); */ |
} |
void |
DrawMech(void) |
{ |
int i, j; |
glScalef(0.5, 0.5, 0.5); |
glPushMatrix(); |
glTranslatef(0.0, -0.75, 0.0); |
glRotatef((GLfloat) tilt, 1.0, 0.0, 0.0); |
glRotatef(90.0, 1.0, 0.0, 0.0); |
#ifdef HIP |
glCallList(SOLID_MECH_HIP); |
#endif |
glRotatef(-90.0, 1.0, 0.0, 0.0); |
glTranslatef(0.0, 0.75, 0.0); |
glPushMatrix(); |
glRotatef((GLfloat) pivot, 0.0, 1.0, 0.0); |
glPushMatrix(); |
#ifdef TORSO |
glCallList(SOLID_MECH_TORSO); |
#endif |
glPopMatrix(); |
glPushMatrix(); |
glTranslatef(0.5, 0.5, 0.0); |
#ifdef ROCKET_POD |
glCallList(SOLID_MECH_ROCKET); |
#endif |
glPopMatrix(); |
for (i = 0; i < 2; i++) { |
glPushMatrix(); |
if (i) |
glScalef(-1.0, 1.0, 1.0); |
glTranslatef(1.5, 0.0, 0.0); |
#ifdef SHOULDER |
glCallList(SOLID_MECH_SHOULDER); |
#endif |
glTranslatef(0.9, 0.0, 0.0); |
if (i) { |
glRotatef((GLfloat) lat1, 0.0, 0.0, 1.0); |
glRotatef((GLfloat) shoulder1, 1.0, 0.0, 0.0); |
glRotatef((GLfloat) shoulder3, 0.0, 1.0, 0.0); |
} else { |
glRotatef((GLfloat) lat2, 0.0, 0.0, 1.0); |
glRotatef((GLfloat) shoulder2, 1.0, 0.0, 0.0); |
glRotatef((GLfloat) shoulder4, 0.0, 1.0, 0.0); |
} |
glTranslatef(0.0, -1.4, 0.0); |
#ifdef UPPER_ARM |
glCallList(SOLID_MECH_UPPER_ARM); |
#endif |
glTranslatef(0.0, -2.9, 0.0); |
if (i) |
glRotatef((GLfloat) elbow1, 1.0, 0.0, 0.0); |
else |
glRotatef((GLfloat) elbow2, 1.0, 0.0, 0.0); |
glTranslatef(0.0, -0.9, -0.2); |
#ifdef LOWER_ARM |
glCallList(SOLID_MECH_FOREARM); |
glPushMatrix(); |
glTranslatef(0.0, 0.0, 2.0); |
glRotatef((GLfloat) fire, 0.0, 0.0, 1.0); |
glCallList(SOLID_MECH_VULCAN); |
glPopMatrix(); |
#endif |
glPopMatrix(); |
} |
glPopMatrix(); |
glPopMatrix(); |
for (j = 0; j < 2; j++) { |
glPushMatrix(); |
if (j) { |
glScalef(-0.5, 0.5, 0.5); |
leg = 1; |
} else { |
glScalef(0.5, 0.5, 0.5); |
leg = 0; |
} |
glTranslatef(2.0, -1.5, 0.0); |
if (j) { |
glRotatef((GLfloat) hip11, 1.0, 0.0, 0.0); |
glRotatef((GLfloat) hip12, 0.0, 0.0, 1.0); |
} else { |
glRotatef((GLfloat) hip21, 1.0, 0.0, 0.0); |
glRotatef((GLfloat) hip22, 0.0, 0.0, 1.0); |
} |
glTranslatef(0.0, 0.3, 0.0); |
#ifdef UPPER_LEG |
glPushMatrix(); |
glCallList(SOLID_MECH_UPPER_LEG); |
glPopMatrix(); |
#endif |
glTranslatef(0.0, -8.3, -0.4); |
if (j) |
glRotatef((GLfloat) - hip12, 0.0, 0.0, 1.0); |
else |
glRotatef((GLfloat) - hip22, 0.0, 0.0, 1.0); |
glTranslatef(-0.5, -0.85, -0.5); |
#ifdef LOWER_LEG |
LowerLeg(1); |
#endif |
glPopMatrix(); |
} |
} |
void |
display(void) |
{ |
glClearColor(0.0, 0.0, 0.0, 0.0); |
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); |
glEnable(GL_DEPTH_TEST); |
glPushMatrix(); |
glRotatef((GLfloat) turn, 0.0, 1.0, 0.0); |
glRotatef((GLfloat) turn1, 1.0, 0.0, 0.0); |
#ifdef LIGHT |
if (solid_part) { |
glPushMatrix(); |
lighting(); |
glPopMatrix(); |
} else |
disable(); |
#endif |
#ifdef DRAW_MECH |
glPushMatrix(); |
glTranslatef(0.0, elevation, 0.0); |
DrawMech(); |
glPopMatrix(); |
#endif |
#ifdef DRAW_ENVIRO |
glPushMatrix(); |
if (distance >= 20.136) |
distance = 0.0; |
glTranslatef(0.0, -5.0, -distance); |
glCallList(SOLID_ENVIRO); |
glTranslatef(0.0, 0.0, 10.0); |
glCallList(SOLID_ENVIRO); |
glPopMatrix(); |
#endif |
glPopMatrix(); |
glFlush(); |
tkSwapBuffers(); |
} |
void |
init(void) |
{ |
char i = 1; |
#ifdef LIGHT |
SetMaterial(mat_specular2, mat_ambient2, mat_diffuse2, mat_shininess2); |
#endif |
glEnable(GL_DEPTH_TEST); |
MechTorso(i); |
MechHip(i); |
Shoulder(i); |
RocketPod(i); |
UpperArm(i); |
ForeArm(i); |
UpperLeg(i); |
Foot(i); |
VulcanGun(i); |
Enviro(i); |
} |
void |
reshape(int w, int h) |
{ |
glViewport(0, 0, w, h); |
glMatrixMode(GL_PROJECTION); |
glLoadIdentity(); |
gluPerspective(65.0, (GLfloat) w / (GLfloat) h, 1.0, 20.0); |
glMatrixMode(GL_MODELVIEW); |
glLoadIdentity(); |
glTranslatef(0.0, 1.2, -5.5); /* viewing transform */ |
} |
#ifdef ANIMATION |
void |
animation_walk(void) |
{ |
float angle; |
static int step; |
if (step == 0 || step == 2) { |
/* for(frame=3.0; frame<=21.0; frame=frame+3.0){ */ |
if (frame >= 0.0 && frame <= 21.0) { |
if (frame == 0.0) |
frame = 3.0; |
angle = (180 / PI) * (acos(((cos((PI / 180) * frame) * 2.043) + 1.1625) / 3.2059)); |
if (frame > 0) { |
elevation = -(3.2055 - (cos((PI / 180) * angle) * 3.2055)); |
} else |
elevation = 0.0; |
if (step == 0) { |
hip11 = -(frame * 1.7); |
if (1.7 * frame > 15) |
heel1 = frame * 1.7; |
heel2 = 0; |
ankle1 = frame * 1.7; |
if (frame > 0) |
hip21 = angle; |
else |
hip21 = 0; |
ankle2 = -hip21; |
shoulder1 = frame * 1.5; |
shoulder2 = -frame * 1.5; |
elbow1 = frame; |
elbow2 = -frame; |
} else { |
hip21 = -(frame * 1.7); |
if (1.7 * frame > 15) |
heel2 = frame * 1.7; |
heel1 = 0; |
ankle2 = frame * 1.7; |
if (frame > 0) |
hip11 = angle; |
else |
hip11 = 0; |
ankle1 = -hip11; |
shoulder1 = -frame * 1.5; |
shoulder2 = frame * 1.5; |
elbow1 = -frame; |
elbow2 = frame; |
} |
if (frame == 21) |
step++; |
if (frame < 21) |
frame = frame + 3.0; |
} |
} |
if (step == 1 || step == 3) { |
/* for(x=21.0; x>=0.0; x=x-3.0){ */ |
if (frame <= 21.0 && frame >= 0.0) { |
angle = (180 / PI) * (acos(((cos((PI / 180) * frame) * 2.043) + 1.1625) / 3.2029)); |
if (frame > 0) |
elevation = -(3.2055 - (cos((PI / 180) * angle) * 3.2055)); |
else |
elevation = 0.0; |
if (step == 1) { |
elbow2 = hip11 = -frame; |
elbow1 = heel1 = frame; |
heel2 = 15; |
ankle1 = frame; |
if (frame > 0) |
hip21 = angle; |
else |
hip21 = 0; |
ankle2 = -hip21; |
shoulder1 = 1.5 * frame; |
shoulder2 = -frame * 1.5; |
} else { |
elbow1 = hip21 = -frame; |
elbow2 = heel2 = frame; |
heel1 = 15; |
ankle2 = frame; |
if (frame > 0) |
hip11 = angle; |
else |
hip11 = 0; |
ankle1 = -hip11; |
shoulder1 = -frame * 1.5; |
shoulder2 = frame * 1.5; |
} |
if (frame == 0.0) |
step++; |
if (frame > 0) |
frame = frame - 3.0; |
} |
} |
if (step == 4) |
step = 0; |
distance += 0.1678; |
} |
void |
animation(void) |
{ |
animation_walk(); |
} |
#endif |
GLenum key(int key, GLenum mask) |
{ |
int i = 0; |
switch (key) { |
/* start arm control functions */ |
case 'q':{ |
shoulder2Subtract(); |
i++; |
} |
break; |
case 'a':{ |
shoulder2Add(); |
i++; |
} |
break; |
case 'w':{ |
shoulder1Subtract(); |
i++; |
} |
break; |
case 's':{ |
shoulder1Add(); |
i++; |
} |
break; |
case '2':{ |
shoulder3Add(); |
i++; |
} |
break; |
case '1':{ |
shoulder4Add(); |
i++; |
} |
break; |
case '4':{ |
shoulder3Subtract(); |
i++; |
} |
break; |
case '3':{ |
shoulder4Subtract(); |
i++; |
} |
break; |
case 'z':{ |
lat2Raise(); |
i++; |
} |
break; |
case 'Z':{ |
lat2Lower(); |
i++; |
} |
break; |
case 'x':{ |
lat1Raise(); |
i++; |
} |
break; |
case 'X':{ |
lat1Lower(); |
i++; |
} |
break; |
case 'A':{ |
elbow2Add(); |
i++; |
} |
break; |
case 'Q':{ |
elbow2Subtract(); |
i++; |
} |
break; |
case 'S':{ |
elbow1Add(); |
i++; |
} |
break; |
case 'W':{ |
elbow1Subtract(); |
i++; |
} |
break; |
/* end of arm control functions */ |
/* start of torso control functions */ |
case 'd':{ |
RotateAdd(); |
i++; |
} |
break; |
case 'g':{ |
RotateSubtract(); |
i++; |
} |
break; |
case 'r':{ |
MechTiltAdd(); |
i++; |
} |
break; |
case 'f':{ |
MechTiltSubtract(); |
i++; |
} |
break; |
/* end of torso control functions */ |
/* start of leg control functions */ |
case 'h':{ |
RaiseLeg2Forward(); |
i++; |
} |
break; |
case 'y':{ |
LowerLeg2Backwards(); |
i++; |
} |
break; |
case 'Y':{ |
RaiseLeg2Outwards(); |
i++; |
} |
break; |
case 'H':{ |
LowerLeg2Inwards(); |
i++; |
} |
break; |
case 'j':{ |
RaiseLeg1Forward(); |
i++; |
} |
break; |
case 'u':{ |
LowerLeg1Backwards(); |
i++; |
} |
break; |
case 'U':{ |
RaiseLeg1Outwards(); |
i++; |
} |
break; |
case 'J':{ |
LowerLeg1Inwards(); |
i++; |
} |
break; |
case 'N':{ |
Heel2Add(); |
i++; |
} |
break; |
case 'n':{ |
Heel2Subtract(); |
i++; |
} |
break; |
case 'M':{ |
Heel1Add(); |
i++; |
} |
break; |
case 'm':{ |
Heel1Subtract(); |
i++; |
} |
break; |
case 'k':{ |
Ankle2Add(); |
i++; |
} |
break; |
case 'K':{ |
Ankle2Subtract(); |
i++; |
} |
break; |
case 'l':{ |
Ankle1Add(); |
i++; |
} |
break; |
case 'L':{ |
Ankle1Subtract(); |
i++; |
} |
break; |
/* end of leg control functions */ |
/* start of light source position functions */ |
case 'p':{ |
LightTurnRight(); |
i++; |
} |
break; |
case 'i':{ |
LightTurnLeft(); |
i++; |
} |
break; |
case 'o':{ |
LightForwards(); |
i++; |
} |
break; |
case '9':{ |
LightBackwards(); |
i++; |
} |
break; |
/* end of light source position functions */ |
/* start of misc functions */ |
case 't': |
Toggle(); |
break; |
case KEY_LEFT: |
TurnLeft(); |
break; |
case KEY_RIGHT: |
TurnRight(); |
break; |
case KEY_UP: |
TurnBackwards(); |
break; |
case KEY_DOWN: |
TurnForwards(); |
break; |
case ' ': |
FireCannon(); |
} |
return 0; |
} |
void printHelp(void) |
{ |
printf("at the shoulders:"); |
printf("forward : q,w"); |
printf("backwards : a,s"); |
printf("outwards : z,x"); |
printf("inwards : Z,X"); |
#if 0 |
glut_menu[6] = glutCreateMenu(null_select); |
printf("upwards : Q,W\n"); |
printf("downwards : A,S\n"); |
printf("outwards : 1,2\n"); |
printf("inwards : 3,4\n"); |
glut_menu[1] = glutCreateMenu(null_select); |
printf(" : Page_up\n"); |
glut_menu[8] = glutCreateMenu(null_select); |
printf("forward : y,u\n"); |
printf("backwards : h.j\n"); |
printf("outwards : Y,U\n"); |
printf("inwards : H,J\n"); |
glut_menu[9] = glutCreateMenu(null_select); |
printf("forward : n,m\n"); |
printf("backwards : N,M\n"); |
glut_menu[9] = glutCreateMenu(null_select); |
printf("forward : n,m\n"); |
printf("backwards : N,M\n"); |
glut_menu[10] = glutCreateMenu(null_select); |
printf("toes up : K,L\n"); |
printf("toes down : k,l\n"); |
glut_menu[11] = glutCreateMenu(null_select); |
printf("right : right arrow\n"); |
printf("left : left arrow\n"); |
printf("down : up arrow\n"); |
printf("up : down arrow\n"); |
glut_menu[12] = glutCreateMenu(null_select); |
printf("right : p\n"); |
printf("left : i\n"); |
printf("up : 9\n"); |
printf("down : o\n"); |
glut_menu[4] = glutCreateMenu(NULL); |
glutAddSubMenu("at the elbows?", glut_menu[6]); |
glut_menu[7] = glutCreateMenu(NULL); |
glutAddSubMenu("at the hip? ", glut_menu[8]); |
glutAddSubMenu("at the knees?", glut_menu[9]); |
glutAddSubMenu("at the ankles? ", glut_menu[10]); |
printf("turn left : d\n"); |
printf("turn right : g\n"); |
glut_menu[3] = glutCreateMenu(null_select); |
printf("tilt backwards : f\n"); |
printf("tilt forwards : r\n"); |
glut_menu[0] = glutCreateMenu(NULL); |
glutAddSubMenu("move the arms.. ", glut_menu[4]); |
glutAddSubMenu("fire the vulcan guns?", glut_menu[1]); |
glutAddSubMenu("move the legs.. ", glut_menu[7]); |
glutAddSubMenu("move the torso?", glut_menu[2]); |
glutAddSubMenu("move the hip?", glut_menu[3]); |
glutAddSubMenu("rotate the scene..", glut_menu[11]); |
#ifdef MOVE_LIGHT |
glutAddSubMenu("rotate the light source..", glut_menu[12]); |
#endif |
glutCreateMenu(menu_select); |
#ifdef ANIMATION |
printf("Start Walk", 1); |
printf("Stop Walk", 2); |
#endif |
printf("Toggle Wireframe", 3); |
glutAddSubMenu("How do I ..", glut_menu[0]); |
printfy("Quit", 4); |
glutAttachMenu(GLUT_LEFT_BUTTON); |
glutAttachMenu(GLUT_RIGHT_BUTTON); |
#endif |
} |
void idle( void ) |
{ |
/* animate the mech */ |
animation(); |
/* draw the Mech */ |
display(); |
} |
/* #define PROFILE */ |
#ifdef PROFILE |
extern int count_triangles; |
#endif |
// #define LINUX_TEST_FLOAT |
#ifdef LINUX_TEST_FLOAT |
#include <fpu_control.h> |
#endif |
int |
main(int argc, char **argv) |
{ |
#ifdef LINUX_TEST_FLOAT |
/* for debuging floating point errors under Linux */ |
__setfpucw ( 0x1372 ); |
#endif |
Toggle(); |
return ui_loop(argc, argv, "mech"); |
} |
/programs/develop/libraries/TinyGL/examples/nanox.c |
---|
0,0 → 1,113 |
/* |
* Demonstration program for Nano-X graphics. |
*/ |
#include <stdio.h> |
#include <stdlib.h> |
#include <string.h> |
#define MWINCLUDECOLORS |
#include <microwin/nano-X.h> |
#include <GL/gl.h> |
#include <GL/nglx.h> |
#include "ui.h" |
static GR_WINDOW_ID w1; /* id for large window */ |
static GR_GC_ID gc1; /* graphics context for text */ |
void errorcatcher(); /* routine to handle errors */ |
void tkSwapBuffers(void) |
{ |
nglXSwapBuffers(w1); |
} |
int |
ui_loop(int argc,char **argv, const char *name) |
{ |
GR_EVENT event; /* current event */ |
GR_IMAGE_ID id = 0; |
NGLXContext cx; |
int width, height, k; |
if (GrOpen() < 0) { |
fprintf(stderr, "cannot open graphics\n"); |
exit(1); |
} |
width = 400; |
height = 300; |
GrSetErrorHandler(errorcatcher); |
w1 = GrNewWindow(GR_ROOT_WINDOW_ID, 10, 10, width, height, 4, BLACK, WHITE); |
GrSelectEvents(w1, GR_EVENT_MASK_CLOSE_REQ|GR_EVENT_MASK_EXPOSURE|GR_EVENT_MASK_KEY_DOWN); |
GrMapWindow(w1); |
gc1 = GrNewGC(); |
GrSetGCForeground(gc1, WHITE); |
cx = nglXCreateContext(NULL, 0); |
nglXMakeCurrent(w1, cx); |
init(); |
reshape(width, height); |
while (1) { |
GrCheckNextEvent(&event); |
switch(event.type) { |
case GR_EVENT_TYPE_CLOSE_REQ: |
GrFreeImage(id); |
GrClose(); |
exit(0); |
case GR_EVENT_TYPE_EXPOSURE: |
break; |
case GR_EVENT_TYPE_KEY_DOWN: |
{ |
GR_EVENT_KEYSTROKE *kp = &event.keystroke; |
/* XXX: nanoX special keys are totally bugged ! */ |
switch(kp->ch) { |
case 81: |
k = KEY_LEFT; |
break; |
case 83: |
k = KEY_RIGHT; |
break; |
case 82: |
k = KEY_UP; |
break; |
case 84: |
k = KEY_DOWN; |
break; |
default: |
k = kp->ch; |
break; |
} |
key(k, 0); |
} |
break; |
default: |
idle(); |
break; |
} |
} |
return 0; |
} |
/* |
* Here on an unrecoverable error. |
*/ |
void |
errorcatcher(code, name, id) |
GR_ERROR code; /* error code */ |
GR_FUNC_NAME name; /* function name which failed */ |
GR_ID id; /* resource id */ |
{ |
GrClose(); |
fprintf(stderr, "DEMO ERROR: code %d, function %s, resource id %d\n", |
code, name, id); |
exit(1); |
} |
/programs/develop/libraries/TinyGL/examples/spin.c |
---|
0,0 → 1,160 |
/* spin.c */ |
/* |
* Spinning box. This program is in the public domain. |
* |
* Brian Paul |
*/ |
#include <math.h> |
#include <stdio.h> |
#include <GL/glx.h> |
#include <GL/gl.h> |
#include "ui.h" |
static GLfloat Xrot, Xstep; |
static GLfloat Yrot, Ystep; |
static GLfloat Zrot, Zstep; |
static GLfloat Step = 5.0; |
static GLfloat Scale = 1.0; |
static GLuint Object; |
static GLuint make_object( void ) |
{ |
GLuint list; |
list = glGenLists( 1 ); |
glNewList( list, GL_COMPILE ); |
glBegin( GL_LINE_LOOP ); |
glColor3f( 1.0, 1.0, 1.0 ); |
glVertex3f( 1.0, 0.5, -0.4 ); |
glColor3f( 1.0, 0.0, 0.0 ); |
glVertex3f( 1.0, -0.5, -0.4 ); |
glColor3f( 0.0, 1.0, 0.0 ); |
glVertex3f( -1.0, -0.5, -0.4 ); |
glColor3f( 0.0, 0.0, 1.0 ); |
glVertex3f( -1.0, 0.5, -0.4 ); |
glEnd(); |
glColor3f( 1.0, 1.0, 1.0 ); |
glBegin( GL_LINE_LOOP ); |
glVertex3f( 1.0, 0.5, 0.4 ); |
glVertex3f( 1.0, -0.5, 0.4 ); |
glVertex3f( -1.0, -0.5, 0.4 ); |
glVertex3f( -1.0, 0.5, 0.4 ); |
glEnd(); |
glBegin( GL_LINES ); |
glVertex3f( 1.0, 0.5, -0.4 ); glVertex3f( 1.0, 0.5, 0.4 ); |
glVertex3f( 1.0, -0.5, -0.4 ); glVertex3f( 1.0, -0.5, 0.4 ); |
glVertex3f( -1.0, -0.5, -0.4 ); glVertex3f( -1.0, -0.5, 0.4 ); |
glVertex3f( -1.0, 0.5, -0.4 ); glVertex3f( -1.0, 0.5, 0.4 ); |
glEnd(); |
glEndList(); |
return list; |
} |
void reshape( int width, int height ) |
{ |
glViewport(0, 0, (GLint)width, (GLint)height); |
glMatrixMode(GL_PROJECTION); |
glLoadIdentity(); |
glFrustum( -1.0, 1.0, -1.0, 1.0, 5.0, 15.0 ); |
glMatrixMode(GL_MODELVIEW); |
} |
GLenum key(int k, GLenum mask) |
{ |
switch (k) { |
case KEY_ESCAPE: |
exit(0); |
} |
return GL_FALSE; |
} |
void draw( void ) |
{ |
glClear( GL_COLOR_BUFFER_BIT ); |
glPushMatrix(); |
glTranslatef( 0.0, 0.0, -10.0 ); |
glScalef( Scale, Scale, Scale ); |
if (Xstep) { |
glRotatef( Xrot, 1.0, 0.0, 0.0 ); |
} |
else if (Ystep) { |
glRotatef( Yrot, 0.0, 1.0, 0.0 ); |
} |
else { |
glRotatef( Zrot, 0.0, 0.0, 1.0 ); |
} |
glCallList( Object ); |
glPopMatrix(); |
glFlush(); |
tkSwapBuffers(); |
} |
void idle( void ) |
{ |
Xrot += Xstep; |
Yrot += Ystep; |
Zrot += Zstep; |
if (Xrot>=360.0) { |
Xrot = Xstep = 0.0; |
Ystep = Step; |
} |
else if (Yrot>=360.0) { |
Yrot = Ystep = 0.0; |
Zstep = Step; |
} |
else if (Zrot>=360.0) { |
Zrot = Zstep = 0.0; |
Xstep = Step; |
} |
draw(); |
} |
void init(void) |
{ |
Object = make_object(); |
glCullFace( GL_BACK ); |
/* glEnable( GL_CULL_FACE );*/ |
glDisable( GL_DITHER ); |
glShadeModel( GL_FLAT ); |
/* glEnable( GL_DEPTH_TEST ); */ |
Xrot = Yrot = Zrot = 0.0; |
Xstep = Step; |
Ystep = Zstep = 0.0; |
} |
int main( int argc, char *argv[] ) |
{ |
return ui_loop(argc, argv, "spin"); |
} |
/programs/develop/libraries/TinyGL/examples/texobj.c |
---|
0,0 → 1,193 |
/* |
* Example of using the 1.1 texture object functions. |
* Also, this demo utilizes Mesa's fast texture map path. |
* |
* Brian Paul June 1996 |
*/ |
#include <math.h> |
#include <stdlib.h> |
#include <stdio.h> |
#include <string.h> |
#include <GL/glx.h> |
#include <GL/gl.h> |
#include "ui.h" |
static GLuint TexObj[2]; |
static GLfloat Angle = 0.0f; |
static int cnt=0,v=0; |
void |
draw(void) |
{ |
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); |
glColor3f(1.0, 1.0, 1.0); |
/* draw first polygon */ |
glPushMatrix(); |
glTranslatef(-1.0, 0.0, 0.0); |
glRotatef(Angle, 0.0, 0.0, 1.0); |
glBindTexture(GL_TEXTURE_2D, TexObj[v]); |
glEnable(GL_TEXTURE_2D); |
glBegin(GL_QUADS); |
glTexCoord2f(0.0, 0.0); |
glVertex2f(-1.0, -1.0); |
glTexCoord2f(1.0, 0.0); |
glVertex2f(1.0, -1.0); |
glTexCoord2f(1.0, 1.0); |
glVertex2f(1.0, 1.0); |
glTexCoord2f(0.0, 1.0); |
glVertex2f(-1.0, 1.0); |
glEnd(); |
glDisable(GL_TEXTURE_2D); |
glPopMatrix(); |
/* draw second polygon */ |
glPushMatrix(); |
glTranslatef(1.0, 0.0, 0.0); |
glRotatef(Angle - 90.0, 0.0, 1.0, 0.0); |
glBindTexture(GL_TEXTURE_2D, TexObj[1-v]); |
glEnable(GL_TEXTURE_2D); |
glBegin(GL_QUADS); |
glTexCoord2f(0.0, 0.0); |
glVertex2f(-1.0, -1.0); |
glTexCoord2f(1.0, 0.0); |
glVertex2f(1.0, -1.0); |
glTexCoord2f(1.0, 1.0); |
glVertex2f(1.0, 1.0); |
glTexCoord2f(0.0, 1.0); |
glVertex2f(-1.0, 1.0); |
glEnd(); |
glDisable(GL_TEXTURE_2D); |
glPopMatrix(); |
tkSwapBuffers(); |
} |
/* new window size or exposure */ |
void |
reshape(int width, int height) |
{ |
glViewport(0, 0, (GLint) width, (GLint) height); |
glMatrixMode(GL_PROJECTION); |
glLoadIdentity(); |
/* glOrtho( -3.0, 3.0, -3.0, 3.0, -10.0, 10.0 ); */ |
glFrustum(-2.0, 2.0, -2.0, 2.0, 6.0, 20.0); |
glMatrixMode(GL_MODELVIEW); |
glLoadIdentity(); |
glTranslatef(0.0, 0.0, -8.0); |
} |
void bind_texture(int texobj,int image) |
{ |
static int width = 8, height = 8; |
static int color[2][3]={ |
{255,0,0}, |
{0,255,0}, |
}; |
GLubyte tex[64][3]; |
static GLubyte texchar[2][8*8] = { |
{ |
0, 0, 0, 0, 0, 0, 0, 0, |
0, 0, 0, 0, 1, 0, 0, 0, |
0, 0, 0, 1, 1, 0, 0, 0, |
0, 0, 0, 0, 1, 0, 0, 0, |
0, 0, 0, 0, 1, 0, 0, 0, |
0, 0, 0, 0, 1, 0, 0, 0, |
0, 0, 0, 1, 1, 1, 0, 0, |
0, 0, 0, 0, 0, 0, 0, 0}, |
{ |
0, 0, 0, 0, 0, 0, 0, 0, |
0, 0, 0, 2, 2, 0, 0, 0, |
0, 0, 2, 0, 0, 2, 0, 0, |
0, 0, 0, 0, 0, 2, 0, 0, |
0, 0, 0, 0, 2, 0, 0, 0, |
0, 0, 0, 2, 0, 0, 0, 0, |
0, 0, 2, 2, 2, 2, 0, 0, |
0, 0, 0, 0, 0, 0, 0, 0}}; |
int i,j; |
glBindTexture(GL_TEXTURE_2D, texobj); |
/* red on white */ |
for (i = 0; i < height; i++) { |
for (j = 0; j < width; j++) { |
int p = i * width + j; |
if (texchar[image][(height - i - 1) * width + j]) { |
tex[p][0] = color[image][0]; |
tex[p][1] = color[image][1]; |
tex[p][2] = color[image][2]; |
} else { |
tex[p][0] = 255; |
tex[p][1] = 255; |
tex[p][2] = 255; |
} |
} |
} |
glTexImage2D(GL_TEXTURE_2D, 0, 3, width, height, 0, |
GL_RGB, GL_UNSIGNED_BYTE, tex); |
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); |
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); |
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); |
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); |
/* end of texture object */ |
} |
void |
init(void) |
{ |
glEnable(GL_DEPTH_TEST); |
/* Setup texturing */ |
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL); |
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST); |
/* generate texture object IDs */ |
glGenTextures(2, TexObj); |
bind_texture(TexObj[0],0); |
bind_texture(TexObj[1],1); |
} |
void |
idle(void) |
{ |
Angle += 2.0; |
if (++cnt==5) { |
cnt=0; |
v=!v; |
} |
draw(); |
} |
/* change view angle, exit upon ESC */ |
GLenum key(int k, GLenum mask) |
{ |
switch (k) { |
case 'q': |
case KEY_ESCAPE: |
exit(0); |
} |
return GL_FALSE; |
} |
int main(int argc, char **argv) |
{ |
return ui_loop(argc, argv, "texobj"); |
} |
/programs/develop/libraries/TinyGL/examples/ui.h |
---|
0,0 → 1,17 |
/* |
* tk like ui |
*/ |
void draw( void ); |
void idle( void ); |
GLenum key(int k, GLenum mask); |
void reshape( int width, int height ); |
void init( void ); |
int ui_loop(int argc, char **argv, const char *name); |
void tkSwapBuffers(void); |
#define KEY_UP 0xe000 |
#define KEY_DOWN 0xe001 |
#define KEY_LEFT 0xe002 |
#define KEY_RIGHT 0xe003 |
#define KEY_ESCAPE 0xe004 |
/programs/develop/libraries/TinyGL/include/GL/gl.h |
---|
0,0 → 1,838 |
/* |
* The following constants come from Mesa |
*/ |
#ifndef GL_H |
#define GL_H |
#define GL_VERSION_1_1 1 |
#ifdef __cplusplus |
extern "C" { |
#endif |
enum { |
/* Boolean values */ |
GL_FALSE = 0, |
GL_TRUE = 1, |
/* Data types */ |
GL_BYTE = 0x1400, |
GL_UNSIGNED_BYTE = 0x1401, |
GL_SHORT = 0x1402, |
GL_UNSIGNED_SHORT = 0x1403, |
GL_INT = 0x1404, |
GL_UNSIGNED_INT = 0x1405, |
GL_FLOAT = 0x1406, |
GL_DOUBLE = 0x140A, |
GL_2_BYTES = 0x1407, |
GL_3_BYTES = 0x1408, |
GL_4_BYTES = 0x1409, |
/* Primitives */ |
GL_LINES = 0x0001, |
GL_POINTS = 0x0000, |
GL_LINE_STRIP = 0x0003, |
GL_LINE_LOOP = 0x0002, |
GL_TRIANGLES = 0x0004, |
GL_TRIANGLE_STRIP = 0x0005, |
GL_TRIANGLE_FAN = 0x0006, |
GL_QUADS = 0x0007, |
GL_QUAD_STRIP = 0x0008, |
GL_POLYGON = 0x0009, |
GL_EDGE_FLAG = 0x0B43, |
/* Vertex Arrays */ |
GL_VERTEX_ARRAY = 0x8074, |
GL_NORMAL_ARRAY = 0x8075, |
GL_COLOR_ARRAY = 0x8076, |
GL_INDEX_ARRAY = 0x8077, |
GL_TEXTURE_COORD_ARRAY = 0x8078, |
GL_EDGE_FLAG_ARRAY = 0x8079, |
GL_VERTEX_ARRAY_SIZE = 0x807A, |
GL_VERTEX_ARRAY_TYPE = 0x807B, |
GL_VERTEX_ARRAY_STRIDE = 0x807C, |
GL_VERTEX_ARRAY_COUNT = 0x807D, |
GL_NORMAL_ARRAY_TYPE = 0x807E, |
GL_NORMAL_ARRAY_STRIDE = 0x807F, |
GL_NORMAL_ARRAY_COUNT = 0x8080, |
GL_COLOR_ARRAY_SIZE = 0x8081, |
GL_COLOR_ARRAY_TYPE = 0x8082, |
GL_COLOR_ARRAY_STRIDE = 0x8083, |
GL_COLOR_ARRAY_COUNT = 0x8084, |
GL_INDEX_ARRAY_TYPE = 0x8085, |
GL_INDEX_ARRAY_STRIDE = 0x8086, |
GL_INDEX_ARRAY_COUNT = 0x8087, |
GL_TEXTURE_COORD_ARRAY_SIZE = 0x8088, |
GL_TEXTURE_COORD_ARRAY_TYPE = 0x8089, |
GL_TEXTURE_COORD_ARRAY_STRIDE = 0x808A, |
GL_TEXTURE_COORD_ARRAY_COUNT = 0x808B, |
GL_EDGE_FLAG_ARRAY_STRIDE = 0x808C, |
GL_EDGE_FLAG_ARRAY_COUNT = 0x808D, |
GL_VERTEX_ARRAY_POINTER = 0x808E, |
GL_NORMAL_ARRAY_POINTER = 0x808F, |
GL_COLOR_ARRAY_POINTER = 0x8090, |
GL_INDEX_ARRAY_POINTER = 0x8091, |
GL_TEXTURE_COORD_ARRAY_POINTER = 0x8092, |
GL_EDGE_FLAG_ARRAY_POINTER = 0x8093, |
GL_V2F = 0x2A20, |
GL_V3F = 0x2A21, |
GL_C4UB_V2F = 0x2A22, |
GL_C4UB_V3F = 0x2A23, |
GL_C3F_V3F = 0x2A24, |
GL_N3F_V3F = 0x2A25, |
GL_C4F_N3F_V3F = 0x2A26, |
GL_T2F_V3F = 0x2A27, |
GL_T4F_V4F = 0x2A28, |
GL_T2F_C4UB_V3F = 0x2A29, |
GL_T2F_C3F_V3F = 0x2A2A, |
GL_T2F_N3F_V3F = 0x2A2B, |
GL_T2F_C4F_N3F_V3F = 0x2A2C, |
GL_T4F_C4F_N3F_V4F = 0x2A2D, |
/* Matrix Mode */ |
GL_MATRIX_MODE = 0x0BA0, |
GL_MODELVIEW = 0x1700, |
GL_PROJECTION = 0x1701, |
GL_TEXTURE = 0x1702, |
/* Points */ |
GL_POINT_SMOOTH = 0x0B10, |
GL_POINT_SIZE = 0x0B11, |
GL_POINT_SIZE_GRANULARITY = 0x0B13, |
GL_POINT_SIZE_RANGE = 0x0B12, |
/* Lines */ |
GL_LINE_SMOOTH = 0x0B20, |
GL_LINE_STIPPLE = 0x0B24, |
GL_LINE_STIPPLE_PATTERN = 0x0B25, |
GL_LINE_STIPPLE_REPEAT = 0x0B26, |
GL_LINE_WIDTH = 0x0B21, |
GL_LINE_WIDTH_GRANULARITY = 0x0B23, |
GL_LINE_WIDTH_RANGE = 0x0B22, |
/* Polygons */ |
GL_POINT = 0x1B00, |
GL_LINE = 0x1B01, |
GL_FILL = 0x1B02, |
GL_CCW = 0x0901, |
GL_CW = 0x0900, |
GL_FRONT = 0x0404, |
GL_BACK = 0x0405, |
GL_CULL_FACE = 0x0B44, |
GL_CULL_FACE_MODE = 0x0B45, |
GL_POLYGON_SMOOTH = 0x0B41, |
GL_POLYGON_STIPPLE = 0x0B42, |
GL_FRONT_FACE = 0x0B46, |
GL_POLYGON_MODE = 0x0B40, |
GL_POLYGON_OFFSET_FACTOR = 0x3038, |
GL_POLYGON_OFFSET_UNITS = 0x2A00, |
GL_POLYGON_OFFSET_POINT = 0x2A01, |
GL_POLYGON_OFFSET_LINE = 0x2A02, |
GL_POLYGON_OFFSET_FILL = 0x8037, |
/* Display Lists */ |
GL_COMPILE = 0x1300, |
GL_COMPILE_AND_EXECUTE = 0x1301, |
GL_LIST_BASE = 0x0B32, |
GL_LIST_INDEX = 0x0B33, |
GL_LIST_MODE = 0x0B30, |
/* Depth buffer */ |
GL_NEVER = 0x0200, |
GL_LESS = 0x0201, |
GL_GEQUAL = 0x0206, |
GL_LEQUAL = 0x0203, |
GL_GREATER = 0x0204, |
GL_NOTEQUAL = 0x0205, |
GL_EQUAL = 0x0202, |
GL_ALWAYS = 0x0207, |
GL_DEPTH_TEST = 0x0B71, |
GL_DEPTH_BITS = 0x0D56, |
GL_DEPTH_CLEAR_VALUE = 0x0B73, |
GL_DEPTH_FUNC = 0x0B74, |
GL_DEPTH_RANGE = 0x0B70, |
GL_DEPTH_WRITEMASK = 0x0B72, |
GL_DEPTH_COMPONENT = 0x1902, |
/* Lighting */ |
GL_LIGHTING = 0x0B50, |
GL_LIGHT0 = 0x4000, |
GL_LIGHT1 = 0x4001, |
GL_LIGHT2 = 0x4002, |
GL_LIGHT3 = 0x4003, |
GL_LIGHT4 = 0x4004, |
GL_LIGHT5 = 0x4005, |
GL_LIGHT6 = 0x4006, |
GL_LIGHT7 = 0x4007, |
GL_SPOT_EXPONENT = 0x1205, |
GL_SPOT_CUTOFF = 0x1206, |
GL_CONSTANT_ATTENUATION = 0x1207, |
GL_LINEAR_ATTENUATION = 0x1208, |
GL_QUADRATIC_ATTENUATION = 0x1209, |
GL_AMBIENT = 0x1200, |
GL_DIFFUSE = 0x1201, |
GL_SPECULAR = 0x1202, |
GL_SHININESS = 0x1601, |
GL_EMISSION = 0x1600, |
GL_POSITION = 0x1203, |
GL_SPOT_DIRECTION = 0x1204, |
GL_AMBIENT_AND_DIFFUSE = 0x1602, |
GL_COLOR_INDEXES = 0x1603, |
GL_LIGHT_MODEL_TWO_SIDE = 0x0B52, |
GL_LIGHT_MODEL_LOCAL_VIEWER = 0x0B51, |
GL_LIGHT_MODEL_AMBIENT = 0x0B53, |
GL_FRONT_AND_BACK = 0x0408, |
GL_SHADE_MODEL = 0x0B54, |
GL_FLAT = 0x1D00, |
GL_SMOOTH = 0x1D01, |
GL_COLOR_MATERIAL = 0x0B57, |
GL_COLOR_MATERIAL_FACE = 0x0B55, |
GL_COLOR_MATERIAL_PARAMETER = 0x0B56, |
GL_NORMALIZE = 0x0BA1, |
/* User clipping planes */ |
GL_CLIP_PLANE0 = 0x3000, |
GL_CLIP_PLANE1 = 0x3001, |
GL_CLIP_PLANE2 = 0x3002, |
GL_CLIP_PLANE3 = 0x3003, |
GL_CLIP_PLANE4 = 0x3004, |
GL_CLIP_PLANE5 = 0x3005, |
/* Accumulation buffer */ |
GL_ACCUM_RED_BITS = 0x0D58, |
GL_ACCUM_GREEN_BITS = 0x0D59, |
GL_ACCUM_BLUE_BITS = 0x0D5A, |
GL_ACCUM_ALPHA_BITS = 0x0D5B, |
GL_ACCUM_CLEAR_VALUE = 0x0B80, |
GL_ACCUM = 0x0100, |
GL_ADD = 0x0104, |
GL_LOAD = 0x0101, |
GL_MULT = 0x0103, |
GL_RETURN = 0x0102, |
/* Alpha testing */ |
GL_ALPHA_TEST = 0x0BC0, |
GL_ALPHA_TEST_REF = 0x0BC2, |
GL_ALPHA_TEST_FUNC = 0x0BC1, |
/* Blending */ |
GL_BLEND = 0x0BE2, |
GL_BLEND_SRC = 0x0BE1, |
GL_BLEND_DST = 0x0BE0, |
GL_ZERO = 0, |
GL_ONE = 1, |
GL_SRC_COLOR = 0x0300, |
GL_ONE_MINUS_SRC_COLOR = 0x0301, |
GL_DST_COLOR = 0x0306, |
GL_ONE_MINUS_DST_COLOR = 0x0307, |
GL_SRC_ALPHA = 0x0302, |
GL_ONE_MINUS_SRC_ALPHA = 0x0303, |
GL_DST_ALPHA = 0x0304, |
GL_ONE_MINUS_DST_ALPHA = 0x0305, |
GL_SRC_ALPHA_SATURATE = 0x0308, |
GL_CONSTANT_COLOR = 0x8001, |
GL_ONE_MINUS_CONSTANT_COLOR = 0x8002, |
GL_CONSTANT_ALPHA = 0x8003, |
GL_ONE_MINUS_CONSTANT_ALPHA = 0x8004, |
/* Render Mode */ |
GL_FEEDBACK = 0x1C01, |
GL_RENDER = 0x1C00, |
GL_SELECT = 0x1C02, |
/* Feedback */ |
GL_2D = 0x0600, |
GL_3D = 0x0601, |
GL_3D_COLOR = 0x0602, |
GL_3D_COLOR_TEXTURE = 0x0603, |
GL_4D_COLOR_TEXTURE = 0x0604, |
GL_POINT_TOKEN = 0x0701, |
GL_LINE_TOKEN = 0x0702, |
GL_LINE_RESET_TOKEN = 0x0707, |
GL_POLYGON_TOKEN = 0x0703, |
GL_BITMAP_TOKEN = 0x0704, |
GL_DRAW_PIXEL_TOKEN = 0x0705, |
GL_COPY_PIXEL_TOKEN = 0x0706, |
GL_PASS_THROUGH_TOKEN = 0x0700, |
/* Fog */ |
GL_FOG = 0x0B60, |
GL_FOG_MODE = 0x0B65, |
GL_FOG_DENSITY = 0x0B62, |
GL_FOG_COLOR = 0x0B66, |
GL_FOG_INDEX = 0x0B61, |
GL_FOG_START = 0x0B63, |
GL_FOG_END = 0x0B64, |
GL_LINEAR = 0x2601, |
GL_EXP = 0x0800, |
GL_EXP2 = 0x0801, |
/* Logic Ops */ |
GL_LOGIC_OP = 0x0BF1, |
GL_LOGIC_OP_MODE = 0x0BF0, |
GL_CLEAR = 0x1500, |
GL_SET = 0x150F, |
GL_COPY = 0x1503, |
GL_COPY_INVERTED = 0x150C, |
GL_NOOP = 0x1505, |
GL_INVERT = 0x150A, |
GL_AND = 0x1501, |
GL_NAND = 0x150E, |
GL_OR = 0x1507, |
GL_NOR = 0x1508, |
GL_XOR = 0x1506, |
GL_EQUIV = 0x1509, |
GL_AND_REVERSE = 0x1502, |
GL_AND_INVERTED = 0x1504, |
GL_OR_REVERSE = 0x150B, |
GL_OR_INVERTED = 0x150D, |
/* Stencil */ |
GL_STENCIL_TEST = 0x0B90, |
GL_STENCIL_WRITEMASK = 0x0B98, |
GL_STENCIL_BITS = 0x0D57, |
GL_STENCIL_FUNC = 0x0B92, |
GL_STENCIL_VALUE_MASK = 0x0B93, |
GL_STENCIL_REF = 0x0B97, |
GL_STENCIL_FAIL = 0x0B94, |
GL_STENCIL_PASS_DEPTH_PASS = 0x0B96, |
GL_STENCIL_PASS_DEPTH_FAIL = 0x0B95, |
GL_STENCIL_CLEAR_VALUE = 0x0B91, |
GL_STENCIL_INDEX = 0x1901, |
GL_KEEP = 0x1E00, |
GL_REPLACE = 0x1E01, |
GL_INCR = 0x1E02, |
GL_DECR = 0x1E03, |
/* Buffers, Pixel Drawing/Reading */ |
GL_NONE = 0, |
GL_LEFT = 0x0406, |
GL_RIGHT = 0x0407, |
/*GL_FRONT = 0x0404, */ |
/*GL_BACK = 0x0405, */ |
/*GL_FRONT_AND_BACK = 0x0408, */ |
GL_FRONT_LEFT = 0x0400, |
GL_FRONT_RIGHT = 0x0401, |
GL_BACK_LEFT = 0x0402, |
GL_BACK_RIGHT = 0x0403, |
GL_AUX0 = 0x0409, |
GL_AUX1 = 0x040A, |
GL_AUX2 = 0x040B, |
GL_AUX3 = 0x040C, |
GL_COLOR_INDEX = 0x1900, |
GL_RED = 0x1903, |
GL_GREEN = 0x1904, |
GL_BLUE = 0x1905, |
GL_ALPHA = 0x1906, |
GL_LUMINANCE = 0x1909, |
GL_LUMINANCE_ALPHA = 0x190A, |
GL_ALPHA_BITS = 0x0D55, |
GL_RED_BITS = 0x0D52, |
GL_GREEN_BITS = 0x0D53, |
GL_BLUE_BITS = 0x0D54, |
GL_INDEX_BITS = 0x0D51, |
GL_SUBPIXEL_BITS = 0x0D50, |
GL_AUX_BUFFERS = 0x0C00, |
GL_READ_BUFFER = 0x0C02, |
GL_DRAW_BUFFER = 0x0C01, |
GL_DOUBLEBUFFER = 0x0C32, |
GL_STEREO = 0x0C33, |
GL_BITMAP = 0x1A00, |
GL_COLOR = 0x1800, |
GL_DEPTH = 0x1801, |
GL_STENCIL = 0x1802, |
GL_DITHER = 0x0BD0, |
GL_RGB = 0x1907, |
GL_RGBA = 0x1908, |
/* Implementation limits */ |
GL_MAX_LIST_NESTING = 0x0B31, |
GL_MAX_ATTRIB_STACK_DEPTH = 0x0D35, |
GL_MAX_MODELVIEW_STACK_DEPTH = 0x0D36, |
GL_MAX_NAME_STACK_DEPTH = 0x0D37, |
GL_MAX_PROJECTION_STACK_DEPTH = 0x0D38, |
GL_MAX_TEXTURE_STACK_DEPTH = 0x0D39, |
GL_MAX_EVAL_ORDER = 0x0D30, |
GL_MAX_LIGHTS = 0x0D31, |
GL_MAX_CLIP_PLANES = 0x0D32, |
GL_MAX_TEXTURE_SIZE = 0x0D33, |
GL_MAX_PIXEL_MAP_TABLE = 0x0D34, |
GL_MAX_VIEWPORT_DIMS = 0x0D3A, |
GL_MAX_CLIENT_ATTRIB_STACK_DEPTH= 0x0D3B, |
/* Gets */ |
GL_ATTRIB_STACK_DEPTH = 0x0BB0, |
GL_COLOR_CLEAR_VALUE = 0x0C22, |
GL_COLOR_WRITEMASK = 0x0C23, |
GL_CURRENT_INDEX = 0x0B01, |
GL_CURRENT_COLOR = 0x0B00, |
GL_CURRENT_NORMAL = 0x0B02, |
GL_CURRENT_RASTER_COLOR = 0x0B04, |
GL_CURRENT_RASTER_DISTANCE = 0x0B09, |
GL_CURRENT_RASTER_INDEX = 0x0B05, |
GL_CURRENT_RASTER_POSITION = 0x0B07, |
GL_CURRENT_RASTER_TEXTURE_COORDS = 0x0B06, |
GL_CURRENT_RASTER_POSITION_VALID = 0x0B08, |
GL_CURRENT_TEXTURE_COORDS = 0x0B03, |
GL_INDEX_CLEAR_VALUE = 0x0C20, |
GL_INDEX_MODE = 0x0C30, |
GL_INDEX_WRITEMASK = 0x0C21, |
GL_MODELVIEW_MATRIX = 0x0BA6, |
GL_MODELVIEW_STACK_DEPTH = 0x0BA3, |
GL_NAME_STACK_DEPTH = 0x0D70, |
GL_PROJECTION_MATRIX = 0x0BA7, |
GL_PROJECTION_STACK_DEPTH = 0x0BA4, |
GL_RENDER_MODE = 0x0C40, |
GL_RGBA_MODE = 0x0C31, |
GL_TEXTURE_MATRIX = 0x0BA8, |
GL_TEXTURE_STACK_DEPTH = 0x0BA5, |
GL_VIEWPORT = 0x0BA2, |
/* Evaluators */ |
GL_AUTO_NORMAL = 0x0D80, |
GL_MAP1_COLOR_4 = 0x0D90, |
GL_MAP1_GRID_DOMAIN = 0x0DD0, |
GL_MAP1_GRID_SEGMENTS = 0x0DD1, |
GL_MAP1_INDEX = 0x0D91, |
GL_MAP1_NORMAL = 0x0D92, |
GL_MAP1_TEXTURE_COORD_1 = 0x0D93, |
GL_MAP1_TEXTURE_COORD_2 = 0x0D94, |
GL_MAP1_TEXTURE_COORD_3 = 0x0D95, |
GL_MAP1_TEXTURE_COORD_4 = 0x0D96, |
GL_MAP1_VERTEX_3 = 0x0D97, |
GL_MAP1_VERTEX_4 = 0x0D98, |
GL_MAP2_COLOR_4 = 0x0DB0, |
GL_MAP2_GRID_DOMAIN = 0x0DD2, |
GL_MAP2_GRID_SEGMENTS = 0x0DD3, |
GL_MAP2_INDEX = 0x0DB1, |
GL_MAP2_NORMAL = 0x0DB2, |
GL_MAP2_TEXTURE_COORD_1 = 0x0DB3, |
GL_MAP2_TEXTURE_COORD_2 = 0x0DB4, |
GL_MAP2_TEXTURE_COORD_3 = 0x0DB5, |
GL_MAP2_TEXTURE_COORD_4 = 0x0DB6, |
GL_MAP2_VERTEX_3 = 0x0DB7, |
GL_MAP2_VERTEX_4 = 0x0DB8, |
GL_COEFF = 0x0A00, |
GL_DOMAIN = 0x0A02, |
GL_ORDER = 0x0A01, |
/* Hints */ |
GL_FOG_HINT = 0x0C54, |
GL_LINE_SMOOTH_HINT = 0x0C52, |
GL_PERSPECTIVE_CORRECTION_HINT = 0x0C50, |
GL_POINT_SMOOTH_HINT = 0x0C51, |
GL_POLYGON_SMOOTH_HINT = 0x0C53, |
GL_DONT_CARE = 0x1100, |
GL_FASTEST = 0x1101, |
GL_NICEST = 0x1102, |
/* Scissor box */ |
GL_SCISSOR_TEST = 0x0C11, |
GL_SCISSOR_BOX = 0x0C10, |
/* Pixel Mode / Transfer */ |
GL_MAP_COLOR = 0x0D10, |
GL_MAP_STENCIL = 0x0D11, |
GL_INDEX_SHIFT = 0x0D12, |
GL_INDEX_OFFSET = 0x0D13, |
GL_RED_SCALE = 0x0D14, |
GL_RED_BIAS = 0x0D15, |
GL_GREEN_SCALE = 0x0D18, |
GL_GREEN_BIAS = 0x0D19, |
GL_BLUE_SCALE = 0x0D1A, |
GL_BLUE_BIAS = 0x0D1B, |
GL_ALPHA_SCALE = 0x0D1C, |
GL_ALPHA_BIAS = 0x0D1D, |
GL_DEPTH_SCALE = 0x0D1E, |
GL_DEPTH_BIAS = 0x0D1F, |
GL_PIXEL_MAP_S_TO_S_SIZE = 0x0CB1, |
GL_PIXEL_MAP_I_TO_I_SIZE = 0x0CB0, |
GL_PIXEL_MAP_I_TO_R_SIZE = 0x0CB2, |
GL_PIXEL_MAP_I_TO_G_SIZE = 0x0CB3, |
GL_PIXEL_MAP_I_TO_B_SIZE = 0x0CB4, |
GL_PIXEL_MAP_I_TO_A_SIZE = 0x0CB5, |
GL_PIXEL_MAP_R_TO_R_SIZE = 0x0CB6, |
GL_PIXEL_MAP_G_TO_G_SIZE = 0x0CB7, |
GL_PIXEL_MAP_B_TO_B_SIZE = 0x0CB8, |
GL_PIXEL_MAP_A_TO_A_SIZE = 0x0CB9, |
GL_PIXEL_MAP_S_TO_S = 0x0C71, |
GL_PIXEL_MAP_I_TO_I = 0x0C70, |
GL_PIXEL_MAP_I_TO_R = 0x0C72, |
GL_PIXEL_MAP_I_TO_G = 0x0C73, |
GL_PIXEL_MAP_I_TO_B = 0x0C74, |
GL_PIXEL_MAP_I_TO_A = 0x0C75, |
GL_PIXEL_MAP_R_TO_R = 0x0C76, |
GL_PIXEL_MAP_G_TO_G = 0x0C77, |
GL_PIXEL_MAP_B_TO_B = 0x0C78, |
GL_PIXEL_MAP_A_TO_A = 0x0C79, |
GL_PACK_ALIGNMENT = 0x0D05, |
GL_PACK_LSB_FIRST = 0x0D01, |
GL_PACK_ROW_LENGTH = 0x0D02, |
GL_PACK_SKIP_PIXELS = 0x0D04, |
GL_PACK_SKIP_ROWS = 0x0D03, |
GL_PACK_SWAP_BYTES = 0x0D00, |
GL_UNPACK_ALIGNMENT = 0x0CF5, |
GL_UNPACK_LSB_FIRST = 0x0CF1, |
GL_UNPACK_ROW_LENGTH = 0x0CF2, |
GL_UNPACK_SKIP_PIXELS = 0x0CF4, |
GL_UNPACK_SKIP_ROWS = 0x0CF3, |
GL_UNPACK_SWAP_BYTES = 0x0CF0, |
GL_ZOOM_X = 0x0D16, |
GL_ZOOM_Y = 0x0D17, |
/* Texture mapping */ |
GL_TEXTURE_ENV = 0x2300, |
GL_TEXTURE_ENV_MODE = 0x2200, |
GL_TEXTURE_1D = 0x0DE0, |
GL_TEXTURE_2D = 0x0DE1, |
GL_TEXTURE_WRAP_S = 0x2802, |
GL_TEXTURE_WRAP_T = 0x2803, |
GL_TEXTURE_MAG_FILTER = 0x2800, |
GL_TEXTURE_MIN_FILTER = 0x2801, |
GL_TEXTURE_ENV_COLOR = 0x2201, |
GL_TEXTURE_GEN_S = 0x0C60, |
GL_TEXTURE_GEN_T = 0x0C61, |
GL_TEXTURE_GEN_MODE = 0x2500, |
GL_TEXTURE_BORDER_COLOR = 0x1004, |
GL_TEXTURE_WIDTH = 0x1000, |
GL_TEXTURE_HEIGHT = 0x1001, |
GL_TEXTURE_BORDER = 0x1005, |
GL_TEXTURE_COMPONENTS = 0x1003, |
GL_NEAREST_MIPMAP_NEAREST = 0x2700, |
GL_NEAREST_MIPMAP_LINEAR = 0x2702, |
GL_LINEAR_MIPMAP_NEAREST = 0x2701, |
GL_LINEAR_MIPMAP_LINEAR = 0x2703, |
GL_OBJECT_LINEAR = 0x2401, |
GL_OBJECT_PLANE = 0x2501, |
GL_EYE_LINEAR = 0x2400, |
GL_EYE_PLANE = 0x2502, |
GL_SPHERE_MAP = 0x2402, |
GL_DECAL = 0x2101, |
GL_MODULATE = 0x2100, |
GL_NEAREST = 0x2600, |
GL_REPEAT = 0x2901, |
GL_CLAMP = 0x2900, |
GL_S = 0x2000, |
GL_T = 0x2001, |
GL_R = 0x2002, |
GL_Q = 0x2003, |
GL_TEXTURE_GEN_R = 0x0C62, |
GL_TEXTURE_GEN_Q = 0x0C63, |
GL_PROXY_TEXTURE_1D = 0x8063, |
GL_PROXY_TEXTURE_2D = 0x8064, |
GL_TEXTURE_PRIORITY = 0x8066, |
GL_TEXTURE_RESIDENT = 0x8067, |
GL_TEXTURE_1D_BINDING = 0x8068, |
GL_TEXTURE_2D_BINDING = 0x8069, |
/* Internal texture formats */ |
GL_ALPHA4 = 0x803B, |
GL_ALPHA8 = 0x803C, |
GL_ALPHA12 = 0x803D, |
GL_ALPHA16 = 0x803E, |
GL_LUMINANCE4 = 0x803F, |
GL_LUMINANCE8 = 0x8040, |
GL_LUMINANCE12 = 0x8041, |
GL_LUMINANCE16 = 0x8042, |
GL_LUMINANCE4_ALPHA4 = 0x8043, |
GL_LUMINANCE6_ALPHA2 = 0x8044, |
GL_LUMINANCE8_ALPHA8 = 0x8045, |
GL_LUMINANCE12_ALPHA4 = 0x8046, |
GL_LUMINANCE12_ALPHA12 = 0x8047, |
GL_LUMINANCE16_ALPHA16 = 0x8048, |
GL_INTENSITY = 0x8049, |
GL_INTENSITY4 = 0x804A, |
GL_INTENSITY8 = 0x804B, |
GL_INTENSITY12 = 0x804C, |
GL_INTENSITY16 = 0x804D, |
GL_R3_G3_B2 = 0x2A10, |
GL_RGB4 = 0x804F, |
GL_RGB5 = 0x8050, |
GL_RGB8 = 0x8051, |
GL_RGB10 = 0x8052, |
GL_RGB12 = 0x8053, |
GL_RGB16 = 0x8054, |
GL_RGBA2 = 0x8055, |
GL_RGBA4 = 0x8056, |
GL_RGB5_A1 = 0x8057, |
GL_RGBA8 = 0x8058, |
GL_RGB10_A2 = 0x8059, |
GL_RGBA12 = 0x805A, |
GL_RGBA16 = 0x805B, |
/* Utility */ |
GL_VENDOR = 0x1F00, |
GL_RENDERER = 0x1F01, |
GL_VERSION = 0x1F02, |
GL_EXTENSIONS = 0x1F03, |
/* Errors */ |
GL_INVALID_VALUE = 0x0501, |
GL_INVALID_ENUM = 0x0500, |
GL_INVALID_OPERATION = 0x0502, |
GL_STACK_OVERFLOW = 0x0503, |
GL_STACK_UNDERFLOW = 0x0504, |
GL_OUT_OF_MEMORY = 0x0505, |
/* |
* 1.0 Extensions |
*/ |
/* GL_EXT_blend_minmax and GL_EXT_blend_color */ |
GL_CONSTANT_COLOR_EXT = 0x8001, |
GL_ONE_MINUS_CONSTANT_COLOR_EXT = 0x8002, |
GL_CONSTANT_ALPHA_EXT = 0x8003, |
GL_ONE_MINUS_CONSTANT_ALPHA_EXT = 0x8004, |
GL_BLEND_EQUATION_EXT = 0x8009, |
GL_MIN_EXT = 0x8007, |
GL_MAX_EXT = 0x8008, |
GL_FUNC_ADD_EXT = 0x8006, |
GL_FUNC_SUBTRACT_EXT = 0x800A, |
GL_FUNC_REVERSE_SUBTRACT_EXT = 0x800B, |
GL_BLEND_COLOR_EXT = 0x8005, |
/* GL_EXT_polygon_offset */ |
GL_POLYGON_OFFSET_EXT = 0x8037, |
GL_POLYGON_OFFSET_FACTOR_EXT = 0x8038, |
GL_POLYGON_OFFSET_BIAS_EXT = 0x8039, |
/* GL_EXT_vertex_array */ |
GL_VERTEX_ARRAY_EXT = 0x8074, |
GL_NORMAL_ARRAY_EXT = 0x8075, |
GL_COLOR_ARRAY_EXT = 0x8076, |
GL_INDEX_ARRAY_EXT = 0x8077, |
GL_TEXTURE_COORD_ARRAY_EXT = 0x8078, |
GL_EDGE_FLAG_ARRAY_EXT = 0x8079, |
GL_VERTEX_ARRAY_SIZE_EXT = 0x807A, |
GL_VERTEX_ARRAY_TYPE_EXT = 0x807B, |
GL_VERTEX_ARRAY_STRIDE_EXT = 0x807C, |
GL_VERTEX_ARRAY_COUNT_EXT = 0x807D, |
GL_NORMAL_ARRAY_TYPE_EXT = 0x807E, |
GL_NORMAL_ARRAY_STRIDE_EXT = 0x807F, |
GL_NORMAL_ARRAY_COUNT_EXT = 0x8080, |
GL_COLOR_ARRAY_SIZE_EXT = 0x8081, |
GL_COLOR_ARRAY_TYPE_EXT = 0x8082, |
GL_COLOR_ARRAY_STRIDE_EXT = 0x8083, |
GL_COLOR_ARRAY_COUNT_EXT = 0x8084, |
GL_INDEX_ARRAY_TYPE_EXT = 0x8085, |
GL_INDEX_ARRAY_STRIDE_EXT = 0x8086, |
GL_INDEX_ARRAY_COUNT_EXT = 0x8087, |
GL_TEXTURE_COORD_ARRAY_SIZE_EXT = 0x8088, |
GL_TEXTURE_COORD_ARRAY_TYPE_EXT = 0x8089, |
GL_TEXTURE_COORD_ARRAY_STRIDE_EXT= 0x808A, |
GL_TEXTURE_COORD_ARRAY_COUNT_EXT= 0x808B, |
GL_EDGE_FLAG_ARRAY_STRIDE_EXT = 0x808C, |
GL_EDGE_FLAG_ARRAY_COUNT_EXT = 0x808D, |
GL_VERTEX_ARRAY_POINTER_EXT = 0x808E, |
GL_NORMAL_ARRAY_POINTER_EXT = 0x808F, |
GL_COLOR_ARRAY_POINTER_EXT = 0x8090, |
GL_INDEX_ARRAY_POINTER_EXT = 0x8091, |
GL_TEXTURE_COORD_ARRAY_POINTER_EXT= 0x8092, |
GL_EDGE_FLAG_ARRAY_POINTER_EXT = 0x8093 |
}; |
enum { |
GL_CURRENT_BIT = 0x00000001, |
GL_POINT_BIT = 0x00000002, |
GL_LINE_BIT = 0x00000004, |
GL_POLYGON_BIT = 0x00000008, |
GL_POLYGON_STIPPLE_BIT = 0x00000010, |
GL_PIXEL_MODE_BIT = 0x00000020, |
GL_LIGHTING_BIT = 0x00000040, |
GL_FOG_BIT = 0x00000080, |
GL_DEPTH_BUFFER_BIT = 0x00000100, |
GL_ACCUM_BUFFER_BIT = 0x00000200, |
GL_STENCIL_BUFFER_BIT = 0x00000400, |
GL_VIEWPORT_BIT = 0x00000800, |
GL_TRANSFORM_BIT = 0x00001000, |
GL_ENABLE_BIT = 0x00002000, |
GL_COLOR_BUFFER_BIT = 0x00004000, |
GL_HINT_BIT = 0x00008000, |
GL_EVAL_BIT = 0x00010000, |
GL_LIST_BIT = 0x00020000, |
GL_TEXTURE_BIT = 0x00040000, |
GL_SCISSOR_BIT = 0x00080000, |
GL_ALL_ATTRIB_BITS = 0x000fffff |
}; |
/* some types */ |
typedef int GLenum; |
typedef void GLvoid; |
typedef unsigned char GLboolean; |
typedef signed char GLbyte; /* 1-byte signed */ |
typedef short GLshort; /* 2-byte signed */ |
typedef int GLint; /* 4-byte signed */ |
typedef unsigned char GLubyte; /* 1-byte unsigned */ |
typedef unsigned short GLushort; /* 2-byte unsigned */ |
typedef unsigned int GLuint; /* 4-byte unsigned */ |
typedef float GLfloat; /* single precision float */ |
typedef double GLdouble; /* double precision float */ |
typedef int GLsizei; |
/* functions */ |
void glEnable(int code); |
void glDisable(int code); |
void glShadeModel(int mode); |
void glCullFace(int mode); |
void glPolygonMode(int face,int mode); |
void glBegin(int type); |
void glEnd(void); |
#define PROTO_GL1(name) \ |
void gl ## name ## 1f(float); \ |
void gl ## name ## 1d(double); \ |
void gl ## name ## 1fv(float *); \ |
void gl ## name ## 1dv(double *); |
#define PROTO_GL2(name) \ |
void gl ## name ## 2f(float ,float); \ |
void gl ## name ## 2d(double ,double); \ |
void gl ## name ## 2fv(float *); \ |
void gl ## name ## 2dv(double *); |
#define PROTO_GL3(name) \ |
void gl ## name ## 3f(float ,float ,float); \ |
void gl ## name ## 3d(double ,double ,double); \ |
void gl ## name ## 3fv(float *); \ |
void gl ## name ## 3dv(double *); |
#define PROTO_GL4(name) \ |
void gl ## name ## 4f(float ,float ,float, float ); \ |
void gl ## name ## 4d(double ,double ,double, double ); \ |
void gl ## name ## 4fv(float *); \ |
void gl ## name ## 4dv(double *); |
PROTO_GL2(Vertex) |
PROTO_GL3(Vertex) |
PROTO_GL4(Vertex) |
PROTO_GL3(Color) |
PROTO_GL4(Color) |
PROTO_GL3(Normal) |
PROTO_GL1(TexCoord) |
PROTO_GL2(TexCoord) |
PROTO_GL3(TexCoord) |
PROTO_GL4(TexCoord) |
void glEdgeFlag(int flag); |
/* matrix */ |
void glMatrixMode(int mode); |
void glLoadMatrixf(const float *m); |
void glLoadIdentity(void); |
void glMultMatrixf(const float *m); |
void glPushMatrix(void); |
void glPopMatrix(void); |
void glRotatef(float angle,float x,float y,float z); |
void glTranslatef(float x,float y,float z); |
void glScalef(float x,float y,float z); |
void glViewport(int x,int y,int width,int height); |
void glFrustum(double left,double right,double bottom,double top, |
double near_,double far_); |
/* lists */ |
unsigned int glGenLists(int range); |
int glIsList(unsigned int list); |
void glNewList(unsigned int list,int mode); |
void glEndList(void); |
void glCallList(unsigned int list); |
/* clear */ |
void glClear(int mask); |
void glClearColor(float r,float g,float b,float a); |
void glClearDepth(double depth); |
/* selection */ |
int glRenderMode(int mode); |
void glSelectBuffer(int size,unsigned int *buf); |
void glInitNames(void); |
void glPushName(unsigned int name); |
void glPopName(void); |
void glLoadName(unsigned int name); |
/* textures */ |
void glGenTextures(int n, unsigned int *textures); |
void glDeleteTextures(int n, const unsigned int *textures); |
void glBindTexture(int target,int texture); |
void glTexImage2D( int target, int level, int components, |
int width, int height, int border, |
int format, int type, void *pixels); |
void glTexEnvi(int target,int pname,int param); |
void glTexParameteri(int target,int pname,int param); |
void glPixelStorei(int pname,int param); |
/* lighting */ |
void glMaterialfv(int mode,int type,float *v); |
void glMaterialf(int mode,int type,float v); |
void glColorMaterial(int mode,int type); |
void glLightfv(int light,int type,float *v); |
void glLightf(int light,int type,float v); |
void glLightModeli(int pname,int param); |
void glLightModelfv(int pname,float *param); |
/* misc */ |
void glFlush(void); |
void glHint(int target,int mode); |
void glGetIntegerv(int pname,int *params); |
void glGetFloatv(int pname, float *v); |
void glFrontFace(int mode); |
/* opengl 1.2 arrays */ |
void glEnableClientState(GLenum array); |
void glDisableClientState(GLenum array); |
void glArrayElement(GLint i); |
void glVertexPointer(GLint size, GLenum type, GLsizei stride, |
const GLvoid *pointer); |
void glColorPointer(GLint size, GLenum type, GLsizei stride, |
const GLvoid *pointer); |
void glNormalPointer(GLenum type, GLsizei stride, |
const GLvoid *pointer); |
void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, |
const GLvoid *pointer); |
/* opengl 1.2 polygon offset */ |
void glPolygonOffset(GLfloat factor, GLfloat units); |
/* not implemented, just added to compile */ |
/* |
inline void glPointSize(float) {} |
inline void glLineWidth(float) {} |
inline void glDeleteLists(int, int) {} |
inline void glDepthFunc(int) {} |
inline void glBlendFunc(int, int) {} |
inline void glTexEnvf(int, int, int) {} |
inline void glOrtho(float,float,float,float,float,float){} |
inline void glVertex2i(int,int) {} |
inline void glDepthMask(int) {} |
inline void glFogi(int, int) {} |
inline void glFogfv(int, const float*) {} |
inline void glFogf(int, float) {} |
inline void glRasterPos2f(float, float) {} |
inline void glPolygonStipple(void*) {} |
inline void glTexParameterf(int, int, int) {}; |
*/ |
/* non compatible functions */ |
void glDebug(int mode); |
void glInit(void *zbuffer); |
void glClose(void); |
#ifdef __cplusplus |
} |
#endif |
#endif |
/programs/develop/libraries/TinyGL/include/GL/glu.h |
---|
0,0 → 1,44 |
#ifndef GLU_H |
#define GLU_H |
#ifdef __cplusplus |
extern "C" { |
#endif |
void gluPerspective( GLdouble fovy, GLdouble aspect, |
GLdouble zNear, GLdouble zFar ); |
void |
gluLookAt(GLdouble eyex, GLdouble eyey, GLdouble eyez, |
GLdouble centerx, GLdouble centery, GLdouble centerz, |
GLdouble upx, GLdouble upy, GLdouble upz); |
void drawTorus(float rc, int numc, float rt, int numt); |
typedef struct { |
int draw_style; |
} GLUquadricObj; |
#define GLU_LINE 0 |
GLUquadricObj* gluNewQuadric(void); |
void gluQuadricDrawStyle(GLUquadricObj *obj, int style); |
void gluSphere(GLUquadricObj *qobj, |
float radius,int slices,int stacks); |
void gluCylinder( GLUquadricObj *qobj, |
GLdouble baseRadius, GLdouble topRadius, GLdouble height, |
GLint slices, GLint stacks ); |
void gluDisk( GLUquadricObj *qobj, |
GLdouble innerRadius, GLdouble outerRadius, |
GLint slices, GLint loops ); |
#ifdef __cplusplus |
} |
#endif |
#endif |
/programs/develop/libraries/TinyGL/include/kosgl.h |
---|
0,0 → 1,28 |
#ifndef KOSGL_H |
#define KOSGL_H |
#include <GL/gl.h> |
#include <GL/glu.h> |
#ifdef __cplusplus |
extern "C" { |
#endif |
typedef void *KOSGLContext; |
extern KOSGLContext kosglCreateContext( KOSGLContext shareList, int flags ); |
extern void kosglDestroyContext( KOSGLContext ctx1 ); |
extern int kosglMakeCurrent( int win_x0, int win_y0, |
int win_x, int win_y, |
KOSGLContext ctx); |
extern void kosglSwapBuffers(); |
#ifdef __cplusplus |
} |
#endif |
#endif |
/programs/develop/libraries/TinyGL/src/Makefile |
---|
0,0 → 1,38 |
include ../config.mk |
OBJS= clip.o vertex.o api.o list.o init.o matrix.o texture.o \ |
misc.o clear.o light.o select.o get.o error.o \ |
zbuffer.o zline.o zdither.o ztriangle.o \ |
zmath.o image_util.o msghandling.o \ |
arrays.o specbuf.o glu.o kosgl.o |
INCLUDES = -I$(TINYGL)/include -I$(MENUETDEV)/include |
LIB = libTinyGL.a |
all: $(LIB) |
$(LIB): $(OBJS) |
rm -f $(LIB) |
ar rcs $(LIB) $(OBJS) |
copy /y $@ $(TINYGL)\lib |
del $(LIB) |
clean: |
rm -f *~ *.o *.a $(TINYGL)/$(LIB) |
.c.o: |
$(CC) $(CFLAGS) $(INCLUDES) -c $*.c |
clip.o: zgl.h zfeatures.h |
vertex.o: zgl.h zfeatures.h |
light.o: zgl.h zfeatures.h |
matrix.o: zgl.h zfeatures.h |
list.o: zgl.h opinfo.h zfeatures.h |
arrays.c: zgl.h zfeatures.h |
specbuf.o: zgl.h zfeatures.h |
glx.o: zgl.h zfeatures.h |
nglx.o: zgl.h zfeatures.h |
zline.o: zgl.h zfeatures.h zline.h |
ztriangle.o: ztriangle.c ztriangle.h zgl.h zfeatures.h |
$(CC) $(CFLAGS) $(INCLUDES) -c $*.c |
/programs/develop/libraries/TinyGL/src/Tupfile.lua |
---|
0,0 → 1,7 |
if tup.getconfig("NO_GCC") ~= "" then return end |
HELPERDIR = (tup.getconfig("HELPERDIR") == "") and "../../../.." or tup.getconfig("HELPERDIR") |
tup.include(HELPERDIR .. "/use_gcc.lua") |
tup.include(HELPERDIR .. "/use_menuetlibc.lua") |
INCLUDES = INCLUDES .. " -I../include" |
compile_gcc("*.c") |
tup.rule(OBJS, "kos32-ar rcs %o %f", {"../lib/libTinyGL.a", "../<>"}) |
/programs/develop/libraries/TinyGL/src/api.c |
---|
0,0 → 1,666 |
#include "zgl.h" |
#include <stdio.h> |
/* glVertex */ |
void glVertex4f(float x,float y,float z,float w) |
{ |
GLParam p[5]; |
p[0].op=OP_Vertex; |
p[1].f=x; |
p[2].f=y; |
p[3].f=z; |
p[4].f=w; |
gl_add_op(p); |
} |
void glVertex2f(float x,float y) |
{ |
glVertex4f(x,y,0,1); |
} |
void glVertex3f(float x,float y,float z) |
{ |
glVertex4f(x,y,z,1); |
} |
void glVertex3fv(float *v) |
{ |
glVertex4f(v[0],v[1],v[2],1); |
} |
/* glNormal */ |
void glNormal3f(float x,float y,float z) |
{ |
GLParam p[4]; |
p[0].op=OP_Normal; |
p[1].f=x; |
p[2].f=y; |
p[3].f=z; |
gl_add_op(p); |
} |
void glNormal3fv(float *v) |
{ |
glNormal3f(v[0],v[1],v[2]); |
} |
/* glColor */ |
void glColor4f(float r,float g,float b,float a) |
{ |
GLParam p[8]; |
p[0].op=OP_Color; |
p[1].f=b; |
p[2].f=g; |
p[3].f=r; |
p[4].f=a; |
/* direct convertion to integer to go faster if no shading */ |
RGBFtoRGBI(r,g,b,p[7].ui,p[6].ui,p[5].ui); |
gl_add_op(p); |
} |
void glColor4fv(float *v) |
{ |
GLParam p[8]; |
p[0].op=OP_Color; |
p[1].f=v[2]; |
p[2].f=v[1]; |
p[3].f=v[0]; |
p[4].f=v[3]; |
/* direct convertion to integer to go faster if no shading */ |
p[5].ui = (unsigned int) (v[2] * (ZB_POINT_RED_MAX - ZB_POINT_RED_MIN) + |
ZB_POINT_RED_MIN); |
p[6].ui = (unsigned int) (v[1] * (ZB_POINT_GREEN_MAX - ZB_POINT_GREEN_MIN) + |
ZB_POINT_GREEN_MIN); |
p[7].ui = (unsigned int) (v[0] * (ZB_POINT_BLUE_MAX - ZB_POINT_BLUE_MIN) + |
ZB_POINT_BLUE_MIN); |
gl_add_op(p); |
} |
void glColor3f(float x,float y,float z) |
{ |
glColor4f(x,y,z,1); |
} |
void glColor3fv(float *v) |
{ |
glColor4f(v[0],v[1],v[2],1); |
} |
/* TexCoord */ |
void glTexCoord4f(float s,float t,float r,float q) |
{ |
GLParam p[5]; |
p[0].op=OP_TexCoord; |
p[1].f=s; |
p[2].f=t; |
p[3].f=r; |
p[4].f=q; |
gl_add_op(p); |
} |
void glTexCoord2f(float s,float t) |
{ |
glTexCoord4f(s,t,0,1); |
} |
void glTexCoord2fv(float *v) |
{ |
glTexCoord4f(v[0],v[1],0,1); |
} |
void glEdgeFlag(int flag) |
{ |
GLParam p[2]; |
p[0].op=OP_EdgeFlag; |
p[1].i=flag; |
gl_add_op(p); |
} |
/* misc */ |
void glShadeModel(int mode) |
{ |
GLParam p[2]; |
assert(mode == GL_FLAT || mode == GL_SMOOTH); |
p[0].op=OP_ShadeModel; |
p[1].i=mode; |
gl_add_op(p); |
} |
void glCullFace(int mode) |
{ |
GLParam p[2]; |
assert(mode == GL_BACK || |
mode == GL_FRONT || |
mode == GL_FRONT_AND_BACK); |
p[0].op=OP_CullFace; |
p[1].i=mode; |
gl_add_op(p); |
} |
void glFrontFace(int mode) |
{ |
GLParam p[2]; |
assert(mode == GL_CCW || mode == GL_CW); |
mode = (mode != GL_CCW); |
p[0].op=OP_FrontFace; |
p[1].i=mode; |
gl_add_op(p); |
} |
void glPolygonMode(int face,int mode) |
{ |
GLParam p[3]; |
assert(face == GL_BACK || |
face == GL_FRONT || |
face == GL_FRONT_AND_BACK); |
assert(mode == GL_POINT || mode == GL_LINE || mode==GL_FILL); |
p[0].op=OP_PolygonMode; |
p[1].i=face; |
p[2].i=mode; |
gl_add_op(p); |
} |
/* glEnable / glDisable */ |
void glEnable(int cap) |
{ |
GLParam p[3]; |
p[0].op=OP_EnableDisable; |
p[1].i=cap; |
p[2].i=1; |
gl_add_op(p); |
} |
void glDisable(int cap) |
{ |
GLParam p[3]; |
p[0].op=OP_EnableDisable; |
p[1].i=cap; |
p[2].i=0; |
gl_add_op(p); |
} |
/* glBegin / glEnd */ |
void glBegin(int mode) |
{ |
GLParam p[2]; |
p[0].op=OP_Begin; |
p[1].i=mode; |
gl_add_op(p); |
} |
void glEnd(void) |
{ |
GLParam p[1]; |
p[0].op=OP_End; |
gl_add_op(p); |
} |
/* matrix */ |
void glMatrixMode(int mode) |
{ |
GLParam p[2]; |
p[0].op=OP_MatrixMode; |
p[1].i=mode; |
gl_add_op(p); |
} |
void glLoadMatrixf(const float *m) |
{ |
GLParam p[17]; |
int i; |
p[0].op=OP_LoadMatrix; |
for(i=0;i<16;i++) p[i+1].f=m[i]; |
gl_add_op(p); |
} |
void glLoadIdentity(void) |
{ |
GLParam p[1]; |
p[0].op=OP_LoadIdentity; |
gl_add_op(p); |
} |
void glMultMatrixf(const float *m) |
{ |
GLParam p[17]; |
int i; |
p[0].op=OP_MultMatrix; |
for(i=0;i<16;i++) p[i+1].f=m[i]; |
gl_add_op(p); |
} |
void glPushMatrix(void) |
{ |
GLParam p[1]; |
p[0].op=OP_PushMatrix; |
gl_add_op(p); |
} |
void glPopMatrix(void) |
{ |
GLParam p[1]; |
p[0].op=OP_PopMatrix; |
gl_add_op(p); |
} |
void glRotatef(float angle,float x,float y,float z) |
{ |
GLParam p[5]; |
p[0].op=OP_Rotate; |
p[1].f=angle; |
p[2].f=x; |
p[3].f=y; |
p[4].f=z; |
gl_add_op(p); |
} |
void glTranslatef(float x,float y,float z) |
{ |
GLParam p[4]; |
p[0].op=OP_Translate; |
p[1].f=x; |
p[2].f=y; |
p[3].f=z; |
gl_add_op(p); |
} |
void glScalef(float x,float y,float z) |
{ |
GLParam p[4]; |
p[0].op=OP_Scale; |
p[1].f=x; |
p[2].f=y; |
p[3].f=z; |
gl_add_op(p); |
} |
void glViewport(int x,int y,int width,int height) |
{ |
GLParam p[5]; |
p[0].op=OP_Viewport; |
p[1].i=x; |
p[2].i=y; |
p[3].i=width; |
p[4].i=height; |
gl_add_op(p); |
} |
void glFrustum(double left,double right,double bottom,double top, |
double near,double farv) |
{ |
GLParam p[7]; |
p[0].op=OP_Frustum; |
p[1].f=left; |
p[2].f=right; |
p[3].f=bottom; |
p[4].f=top; |
p[5].f=near; |
p[6].f=farv; |
gl_add_op(p); |
} |
/* lightening */ |
void glMaterialfv(int mode,int type,float *v) |
{ |
GLParam p[7]; |
int i,n; |
assert(mode == GL_FRONT || mode == GL_BACK || mode==GL_FRONT_AND_BACK); |
p[0].op=OP_Material; |
p[1].i=mode; |
p[2].i=type; |
n=4; |
if (type == GL_SHININESS) n=1; |
p[3].f=v[2]; |
p[4].f=v[1]; |
p[5].f=v[0]; |
p[6].f=v[3]; |
for(i=n;i<4;i++) p[3+i].f=0; |
gl_add_op(p); |
} |
void glMaterialf(int mode,int type,float v) |
{ |
GLParam p[7]; |
int i; |
p[0].op=OP_Material; |
p[1].i=mode; |
p[2].i=type; |
p[3].f=v; |
for(i=0;i<3;i++) p[4+i].f=0; |
gl_add_op(p); |
} |
void glColorMaterial(int mode,int type) |
{ |
GLParam p[3]; |
p[0].op=OP_ColorMaterial; |
p[1].i=mode; |
p[2].i=type; |
gl_add_op(p); |
} |
void glLightfv(int light,int type,float *v) |
{ |
GLParam p[7]; |
int i; |
p[0].op=OP_Light; |
p[1].i=light; |
p[2].i=type; |
/* TODO: 3 composants ? */ |
for(i=0;i<4;i++) p[3+i].f=v[i]; |
gl_add_op(p); |
} |
void glLightf(int light,int type,float v) |
{ |
GLParam p[7]; |
int i; |
p[0].op=OP_Light; |
p[1].i=light; |
p[2].i=type; |
p[3].f=v; |
for(i=0;i<3;i++) p[4+i].f=0; |
gl_add_op(p); |
} |
void glLightModeli(int pname,int param) |
{ |
GLParam p[6]; |
int i; |
p[0].op=OP_LightModel; |
p[1].i=pname; |
p[2].f=(float)param; |
for(i=0;i<4;i++) p[3+i].f=0; |
gl_add_op(p); |
} |
void glLightModelfv(int pname,float *param) |
{ |
GLParam p[6]; |
int i; |
p[0].op=OP_LightModel; |
p[1].i=pname; |
for(i=0;i<4;i++) p[2+i].f=param[i]; |
gl_add_op(p); |
} |
/* clear */ |
void glClear(int mask) |
{ |
GLParam p[2]; |
p[0].op=OP_Clear; |
p[1].i=mask; |
gl_add_op(p); |
} |
void glClearColor(float r,float g,float b,float a) |
{ |
GLParam p[5]; |
p[0].op=OP_ClearColor; |
p[1].f=b; |
p[2].f=g; |
p[3].f=r; |
p[4].f=a; |
gl_add_op(p); |
} |
void glClearDepth(double depth) |
{ |
GLParam p[2]; |
p[0].op=OP_ClearDepth; |
p[1].f=depth; |
gl_add_op(p); |
} |
/* textures */ |
void glTexImage2D( int target, int level, int components, |
int width, int height, int border, |
int format, int type, void *pixels) |
{ |
GLParam p[10]; |
p[0].op=OP_TexImage2D; |
p[1].i=target; |
p[2].i=level; |
p[3].i=components; |
p[4].i=width; |
p[5].i=height; |
p[6].i=border; |
p[7].i=format; |
p[8].i=type; |
p[9].p=pixels; |
gl_add_op(p); |
} |
void glBindTexture(int target,int texture) |
{ |
GLParam p[3]; |
p[0].op=OP_BindTexture; |
p[1].i=target; |
p[2].i=texture; |
gl_add_op(p); |
} |
void glTexEnvi(int target,int pname,int param) |
{ |
GLParam p[8]; |
p[0].op=OP_TexEnv; |
p[1].i=target; |
p[2].i=pname; |
p[3].i=param; |
p[4].f=0; |
p[5].f=0; |
p[6].f=0; |
p[7].f=0; |
gl_add_op(p); |
} |
void glTexParameteri(int target,int pname,int param) |
{ |
GLParam p[8]; |
p[0].op=OP_TexParameter; |
p[1].i=target; |
p[2].i=pname; |
p[3].i=param; |
p[4].f=0; |
p[5].f=0; |
p[6].f=0; |
p[7].f=0; |
gl_add_op(p); |
} |
void glPixelStorei(int pname,int param) |
{ |
GLParam p[3]; |
p[0].op=OP_PixelStore; |
p[1].i=pname; |
p[2].i=param; |
gl_add_op(p); |
} |
/* selection */ |
void glInitNames(void) |
{ |
GLParam p[1]; |
p[0].op=OP_InitNames; |
gl_add_op(p); |
} |
void glPushName(unsigned int name) |
{ |
GLParam p[2]; |
p[0].op=OP_PushName; |
p[1].i=name; |
gl_add_op(p); |
} |
void glPopName(void) |
{ |
GLParam p[1]; |
p[0].op=OP_PopName; |
gl_add_op(p); |
} |
void glLoadName(unsigned int name) |
{ |
GLParam p[2]; |
p[0].op=OP_LoadName; |
p[1].i=name; |
gl_add_op(p); |
} |
void |
glPolygonOffset(GLfloat factor, GLfloat units) |
{ |
GLParam p[3]; |
p[0].op = OP_PolygonOffset; |
p[1].f = factor; |
p[2].f = units; |
} |
/* Special Functions */ |
void glCallList(unsigned int list) |
{ |
GLParam p[2]; |
p[0].op=OP_CallList; |
p[1].i=list; |
gl_add_op(p); |
} |
void glFlush(void) |
{ |
/* nothing to do */ |
} |
void glHint(int target,int mode) |
{ |
GLParam p[3]; |
p[0].op=OP_Hint; |
p[1].i=target; |
p[2].i=mode; |
gl_add_op(p); |
} |
/* Non standard functions */ |
void glDebug(int mode) |
{ |
GLContext *c=gl_get_context(); |
c->print_flag=mode; |
} |
/programs/develop/libraries/TinyGL/src/arrays.c |
---|
0,0 → 1,206 |
#include "zgl.h" |
/*#include <assert.h>*/ |
#include <stdio.h> |
#define VERTEX_ARRAY 0x0001 |
#define COLOR_ARRAY 0x0002 |
#define NORMAL_ARRAY 0x0004 |
#define TEXCOORD_ARRAY 0x0008 |
void |
glopArrayElement(GLContext *c, GLParam *param) |
{ |
int i; |
int states = c->client_states; |
int idx = param[1].i; |
if (states & COLOR_ARRAY) { |
GLParam p[5]; |
int size = c->color_array_size; |
i = idx * (size + c->color_array_stride); |
p[1].f = c->color_array[i]; |
p[2].f = c->color_array[i+1]; |
p[3].f = c->color_array[i+2]; |
p[4].f = size > 3 ? c->color_array[i+3] : 1.0f; |
glopColor(c, p); |
} |
if (states & NORMAL_ARRAY) { |
i = idx * (3 + c->normal_array_stride); |
c->current_normal.X = c->normal_array[i]; |
c->current_normal.Y = c->normal_array[i+1]; |
c->current_normal.Z = c->normal_array[i+2]; |
c->current_normal.Z = 0.0f; |
} |
if (states & TEXCOORD_ARRAY) { |
int size = c->texcoord_array_size; |
i = idx * (size + c->texcoord_array_stride); |
c->current_tex_coord.X = c->texcoord_array[i]; |
c->current_tex_coord.Y = c->texcoord_array[i+1]; |
c->current_tex_coord.Z = size > 2 ? c->texcoord_array[i+2] : 0.0f; |
c->current_tex_coord.W = size > 3 ? c->texcoord_array[i+3] : 1.0f; |
} |
if (states & VERTEX_ARRAY) { |
GLParam p[5]; |
int size = c->vertex_array_size; |
i = idx * (size + c->vertex_array_stride); |
p[1].f = c->vertex_array[i]; |
p[2].f = c->vertex_array[i+1]; |
p[3].f = size > 2 ? c->vertex_array[i+2] : 0.0f; |
p[4].f = size > 3 ? c->vertex_array[i+3] : 1.0f; |
glopVertex(c, p); |
} |
} |
void |
glArrayElement(GLint i) |
{ |
GLParam p[2]; |
p[0].op = OP_ArrayElement; |
p[1].i = i; |
gl_add_op(p); |
} |
void |
glopEnableClientState(GLContext *c, GLParam *p) |
{ |
c->client_states |= p[1].i; |
} |
void |
glEnableClientState(GLenum array) |
{ |
GLParam p[2]; |
p[0].op = OP_EnableClientState; |
switch(array) { |
case GL_VERTEX_ARRAY: |
p[1].i = VERTEX_ARRAY; |
break; |
case GL_NORMAL_ARRAY: |
p[1].i = NORMAL_ARRAY; |
break; |
case GL_COLOR_ARRAY: |
p[1].i = COLOR_ARRAY; |
break; |
case GL_TEXTURE_COORD_ARRAY: |
p[1].i = TEXCOORD_ARRAY; |
break; |
default: |
assert(0); |
break; |
} |
gl_add_op(p); |
} |
void |
glopDisableClientState(GLContext *c, GLParam *p) |
{ |
c->client_states &= p[1].i; |
} |
void |
glDisableClientState(GLenum array) |
{ |
GLParam p[2]; |
p[0].op = OP_DisableClientState; |
switch(array) { |
case GL_VERTEX_ARRAY: |
p[1].i = ~VERTEX_ARRAY; |
break; |
case GL_NORMAL_ARRAY: |
p[1].i = ~NORMAL_ARRAY; |
break; |
case GL_COLOR_ARRAY: |
p[1].i = ~COLOR_ARRAY; |
break; |
case GL_TEXTURE_COORD_ARRAY: |
p[1].i = ~TEXCOORD_ARRAY; |
break; |
default: |
assert(0); |
break; |
} |
gl_add_op(p); |
} |
void |
glopVertexPointer(GLContext *c, GLParam *p) |
{ |
c->vertex_array_size = p[1].i; |
c->vertex_array_stride = p[2].i; |
c->vertex_array = p[3].p; |
} |
void |
glVertexPointer(GLint size, GLenum type, GLsizei stride, |
const GLvoid *pointer) |
{ |
GLParam p[4]; |
assert(type == GL_FLOAT); |
p[0].op = OP_VertexPointer; |
p[1].i = size; |
p[2].i = stride; |
p[3].p = (void*)pointer; |
gl_add_op(p); |
} |
void |
glopColorPointer(GLContext *c, GLParam *p) |
{ |
c->color_array_size = p[1].i; |
c->color_array_stride = p[2].i; |
c->color_array = p[3].p; |
} |
void |
glColorPointer(GLint size, GLenum type, GLsizei stride, |
const GLvoid *pointer) |
{ |
GLParam p[4]; |
assert(type == GL_FLOAT); |
p[0].op = OP_ColorPointer; |
p[1].i = size; |
p[2].i = stride; |
p[3].p = (void*)pointer; |
gl_add_op(p); |
} |
void |
glopNormalPointer(GLContext *c, GLParam *p) |
{ |
c->normal_array_stride = p[1].i; |
c->normal_array = p[2].p; |
} |
void |
glNormalPointer(GLenum type, GLsizei stride, |
const GLvoid *pointer) |
{ |
GLParam p[3]; |
assert(type == GL_FLOAT); |
p[0].op = OP_NormalPointer; |
p[1].i = stride; |
p[2].p = (void*)pointer; |
} |
void |
glopTexCoordPointer(GLContext *c, GLParam *p) |
{ |
c->texcoord_array_size = p[1].i; |
c->texcoord_array_stride = p[2].i; |
c->texcoord_array = p[3].p; |
} |
void |
glTexCoordPointer(GLint size, GLenum type, GLsizei stride, |
const GLvoid *pointer) |
{ |
GLParam p[4]; |
assert(type == GL_FLOAT); |
p[0].op = OP_TexCoordPointer; |
p[1].i = size; |
p[2].i = stride; |
p[3].p = (void*)pointer; |
} |
/programs/develop/libraries/TinyGL/src/clear.c |
---|
0,0 → 1,30 |
#include "zgl.h" |
void glopClearColor(GLContext *c,GLParam *p) |
{ |
c->clear_color.v[0]=p[1].f; |
c->clear_color.v[1]=p[2].f; |
c->clear_color.v[2]=p[3].f; |
c->clear_color.v[3]=p[4].f; |
} |
void glopClearDepth(GLContext *c,GLParam *p) |
{ |
c->clear_depth=p[1].f; |
} |
void glopClear(GLContext *c,GLParam *p) |
{ |
int mask=p[1].i; |
int z=0; |
int r=(int)(c->clear_color.v[0]*65535); |
int g=(int)(c->clear_color.v[1]*65535); |
int b=(int)(c->clear_color.v[2]*65535); |
/* TODO : correct value of Z */ |
ZB_clear(c->zb,mask & GL_DEPTH_BUFFER_BIT,z, |
mask & GL_COLOR_BUFFER_BIT,r,g,b); |
} |
/programs/develop/libraries/TinyGL/src/clip.c |
---|
0,0 → 1,450 |
#include "zgl.h" |
/* fill triangle profile */ |
/* #define PROFILE */ |
#define CLIP_XMIN (1<<0) |
#define CLIP_XMAX (1<<1) |
#define CLIP_YMIN (1<<2) |
#define CLIP_YMAX (1<<3) |
#define CLIP_ZMIN (1<<4) |
#define CLIP_ZMAX (1<<5) |
void gl_transform_to_viewport(GLContext *c,GLVertex *v) |
{ |
float winv; |
/* coordinates */ |
winv=1.0/v->pc.W; |
v->zp.x= (int) ( v->pc.X * winv * c->viewport.scale.X |
+ c->viewport.trans.X ); |
v->zp.y= (int) ( v->pc.Y * winv * c->viewport.scale.Y |
+ c->viewport.trans.Y ); |
v->zp.z= (int) ( v->pc.Z * winv * c->viewport.scale.Z |
+ c->viewport.trans.Z ); |
/* color */ |
if (c->lighting_enabled) { |
v->zp.r=(int)(v->color.v[0] * (ZB_POINT_RED_MAX - ZB_POINT_RED_MIN) |
+ ZB_POINT_RED_MIN); |
v->zp.g=(int)(v->color.v[1] * (ZB_POINT_GREEN_MAX - ZB_POINT_GREEN_MIN) |
+ ZB_POINT_GREEN_MIN); |
v->zp.b=(int)(v->color.v[2] * (ZB_POINT_BLUE_MAX - ZB_POINT_BLUE_MIN) |
+ ZB_POINT_BLUE_MIN); |
} else { |
/* no need to convert to integer if no lighting : take current color */ |
v->zp.r = c->longcurrent_color[0]; |
v->zp.g = c->longcurrent_color[1]; |
v->zp.b = c->longcurrent_color[2]; |
} |
/* texture */ |
if (c->texture_2d_enabled) { |
v->zp.s=(int)(v->tex_coord.X * (ZB_POINT_S_MAX - ZB_POINT_S_MIN) |
+ ZB_POINT_S_MIN); |
v->zp.t=(int)(v->tex_coord.Y * (ZB_POINT_T_MAX - ZB_POINT_T_MIN) |
+ ZB_POINT_T_MIN); |
} |
} |
static void gl_add_select1(GLContext *c,int z1,int z2,int z3) |
{ |
unsigned int min,max; |
min=max=z1; |
if (z2<min) min=z2; |
if (z3<min) min=z3; |
if (z2>max) max=z2; |
if (z3>max) max=z3; |
gl_add_select(c,0xffffffff-min,0xffffffff-max); |
} |
/* point */ |
void gl_draw_point(GLContext *c,GLVertex *p0) |
{ |
if (p0->clip_code == 0) { |
if (c->render_mode == GL_SELECT) { |
gl_add_select(c,p0->zp.z,p0->zp.z); |
} else { |
ZB_plot(c->zb,&p0->zp); |
} |
} |
} |
/* line */ |
static inline void interpolate(GLVertex *q,GLVertex *p0,GLVertex *p1,float t) |
{ |
q->pc.X=p0->pc.X+(p1->pc.X-p0->pc.X)*t; |
q->pc.Y=p0->pc.Y+(p1->pc.Y-p0->pc.Y)*t; |
q->pc.Z=p0->pc.Z+(p1->pc.Z-p0->pc.Z)*t; |
q->pc.W=p0->pc.W+(p1->pc.W-p0->pc.W)*t; |
q->color.v[0]=p0->color.v[0] + (p1->color.v[0]-p0->color.v[0])*t; |
q->color.v[1]=p0->color.v[1] + (p1->color.v[1]-p0->color.v[1])*t; |
q->color.v[2]=p0->color.v[2] + (p1->color.v[2]-p0->color.v[2])*t; |
} |
/* |
* Line Clipping |
*/ |
/* Line Clipping algorithm from 'Computer Graphics', Principles and |
Practice */ |
static inline int ClipLine1(float denom,float num,float *tmin,float *tmax) |
{ |
float t; |
if (denom>0) { |
t=num/denom; |
if (t>*tmax) return 0; |
if (t>*tmin) *tmin=t; |
} else if (denom<0) { |
t=num/denom; |
if (t<*tmin) return 0; |
if (t<*tmax) *tmax=t; |
} else if (num>0) return 0; |
return 1; |
} |
void gl_draw_line(GLContext *c,GLVertex *p1,GLVertex *p2) |
{ |
float dx,dy,dz,dw,x1,y1,z1,w1; |
float tmin,tmax; |
GLVertex q1,q2; |
int cc1,cc2; |
cc1=p1->clip_code; |
cc2=p2->clip_code; |
if ( (cc1 | cc2) == 0) { |
if (c->render_mode == GL_SELECT) { |
gl_add_select1(c,p1->zp.z,p2->zp.z,p2->zp.z); |
} else { |
if (c->depth_test) |
ZB_line_z(c->zb,&p1->zp,&p2->zp); |
else |
ZB_line(c->zb,&p1->zp,&p2->zp); |
} |
} else if ( (cc1&cc2) != 0 ) { |
return; |
} else { |
dx=p2->pc.X-p1->pc.X; |
dy=p2->pc.Y-p1->pc.Y; |
dz=p2->pc.Z-p1->pc.Z; |
dw=p2->pc.W-p1->pc.W; |
x1=p1->pc.X; |
y1=p1->pc.Y; |
z1=p1->pc.Z; |
w1=p1->pc.W; |
tmin=0; |
tmax=1; |
if (ClipLine1(dx+dw,-x1-w1,&tmin,&tmax) && |
ClipLine1(-dx+dw,x1-w1,&tmin,&tmax) && |
ClipLine1(dy+dw,-y1-w1,&tmin,&tmax) && |
ClipLine1(-dy+dw,y1-w1,&tmin,&tmax) && |
ClipLine1(dz+dw,-z1-w1,&tmin,&tmax) && |
ClipLine1(-dz+dw,z1-w1,&tmin,&tmax)) { |
interpolate(&q1,p1,p2,tmin); |
interpolate(&q2,p1,p2,tmax); |
gl_transform_to_viewport(c,&q1); |
gl_transform_to_viewport(c,&q2); |
RGBFtoRGBI(q1.color.v[0],q1.color.v[1],q1.color.v[2],q1.zp.r,q1.zp.g,q1.zp.b); |
RGBFtoRGBI(q2.color.v[0],q2.color.v[1],q2.color.v[2],q2.zp.r,q2.zp.g,q2.zp.b); |
if (c->depth_test) |
ZB_line_z(c->zb,&q1.zp,&q2.zp); |
else |
ZB_line(c->zb,&q1.zp,&q2.zp); |
} |
} |
} |
/* triangle */ |
/* |
* Clipping |
*/ |
/* We clip the segment [a,b] against the 6 planes of the normal volume. |
* We compute the point 'c' of intersection and the value of the parameter 't' |
* of the intersection if x=a+t(b-a). |
*/ |
#define clip_func(name,sign,dir,dir1,dir2) \ |
static float name(V4 *c,V4 *a,V4 *b) \ |
{\ |
float t,dX,dY,dZ,dW,den;\ |
dX = (b->X - a->X);\ |
dY = (b->Y - a->Y);\ |
dZ = (b->Z - a->Z);\ |
dW = (b->W - a->W);\ |
den = -(sign d ## dir) + dW;\ |
if (den == 0) t=0;\ |
else t = ( sign a->dir - a->W) / den;\ |
c->dir1 = a->dir1 + t * d ## dir1;\ |
c->dir2 = a->dir2 + t * d ## dir2;\ |
c->W = a->W + t * dW;\ |
c->dir = sign c->W;\ |
return t;\ |
} |
clip_func(clip_xmin,-,X,Y,Z) |
clip_func(clip_xmax,+,X,Y,Z) |
clip_func(clip_ymin,-,Y,X,Z) |
clip_func(clip_ymax,+,Y,X,Z) |
clip_func(clip_zmin,-,Z,X,Y) |
clip_func(clip_zmax,+,Z,X,Y) |
float (*clip_proc[6])(V4 *,V4 *,V4 *)= { |
clip_xmin,clip_xmax, |
clip_ymin,clip_ymax, |
clip_zmin,clip_zmax |
}; |
static inline void updateTmp(GLContext *c, |
GLVertex *q,GLVertex *p0,GLVertex *p1,float t) |
{ |
if (c->current_shade_model == GL_SMOOTH) { |
q->color.v[0]=p0->color.v[0] + (p1->color.v[0]-p0->color.v[0])*t; |
q->color.v[1]=p0->color.v[1] + (p1->color.v[1]-p0->color.v[1])*t; |
q->color.v[2]=p0->color.v[2] + (p1->color.v[2]-p0->color.v[2])*t; |
} else { |
q->color.v[0]=p0->color.v[0]; |
q->color.v[1]=p0->color.v[1]; |
q->color.v[2]=p0->color.v[2]; |
} |
if (c->texture_2d_enabled) { |
q->tex_coord.X=p0->tex_coord.X + (p1->tex_coord.X-p0->tex_coord.X)*t; |
q->tex_coord.Y=p0->tex_coord.Y + (p1->tex_coord.Y-p0->tex_coord.Y)*t; |
} |
q->clip_code=gl_clipcode(q->pc.X,q->pc.Y,q->pc.Z,q->pc.W); |
if (q->clip_code==0){ |
gl_transform_to_viewport(c,q); |
RGBFtoRGBI(q->color.v[0],q->color.v[1],q->color.v[2],q->zp.r,q->zp.g,q->zp.b); |
} |
} |
static void gl_draw_triangle_clip(GLContext *c, |
GLVertex *p0,GLVertex *p1,GLVertex *p2,int clip_bit); |
void gl_draw_triangle(GLContext *c, |
GLVertex *p0,GLVertex *p1,GLVertex *p2) |
{ |
int co,c_and,cc[3],front; |
float norm; |
cc[0]=p0->clip_code; |
cc[1]=p1->clip_code; |
cc[2]=p2->clip_code; |
co=cc[0] | cc[1] | cc[2]; |
/* we handle the non clipped case here to go faster */ |
if (co==0) { |
norm=(float)(p1->zp.x-p0->zp.x)*(float)(p2->zp.y-p0->zp.y)- |
(float)(p2->zp.x-p0->zp.x)*(float)(p1->zp.y-p0->zp.y); |
if (norm == 0) return; |
front = norm < 0.0; |
front = front ^ c->current_front_face; |
/* back face culling */ |
if (c->cull_face_enabled) { |
/* most used case first */ |
if (c->current_cull_face == GL_BACK) { |
if (front == 0) return; |
c->draw_triangle_front(c,p0,p1,p2); |
} else if (c->current_cull_face == GL_FRONT) { |
if (front != 0) return; |
c->draw_triangle_back(c,p0,p1,p2); |
} else { |
return; |
} |
} else { |
/* no culling */ |
if (front) { |
c->draw_triangle_front(c,p0,p1,p2); |
} else { |
c->draw_triangle_back(c,p0,p1,p2); |
} |
} |
} else { |
c_and=cc[0] & cc[1] & cc[2]; |
if (c_and==0) { |
gl_draw_triangle_clip(c,p0,p1,p2,0); |
} |
} |
} |
static void gl_draw_triangle_clip(GLContext *c, |
GLVertex *p0,GLVertex *p1,GLVertex *p2,int clip_bit) |
{ |
int co,c_and,co1,cc[3],edge_flag_tmp,clip_mask; |
GLVertex tmp1,tmp2,*q[3]; |
float tt; |
cc[0]=p0->clip_code; |
cc[1]=p1->clip_code; |
cc[2]=p2->clip_code; |
co=cc[0] | cc[1] | cc[2]; |
if (co == 0) { |
gl_draw_triangle(c,p0,p1,p2); |
} else { |
c_and=cc[0] & cc[1] & cc[2]; |
/* the triangle is completely outside */ |
if (c_and!=0) return; |
/* find the next direction to clip */ |
while (clip_bit < 6 && (co & (1 << clip_bit)) == 0) { |
clip_bit++; |
} |
/* this test can be true only in case of rounding errors */ |
if (clip_bit == 6) { |
#if 0 |
printf("Error:\n"); |
printf("%f %f %f %f\n",p0->pc.X,p0->pc.Y,p0->pc.Z,p0->pc.W); |
printf("%f %f %f %f\n",p1->pc.X,p1->pc.Y,p1->pc.Z,p1->pc.W); |
printf("%f %f %f %f\n",p2->pc.X,p2->pc.Y,p2->pc.Z,p2->pc.W); |
#endif |
return; |
} |
clip_mask = 1 << clip_bit; |
co1=(cc[0] ^ cc[1] ^ cc[2]) & clip_mask; |
if (co1) { |
/* one point outside */ |
if (cc[0] & clip_mask) { q[0]=p0; q[1]=p1; q[2]=p2; } |
else if (cc[1] & clip_mask) { q[0]=p1; q[1]=p2; q[2]=p0; } |
else { q[0]=p2; q[1]=p0; q[2]=p1; } |
tt=clip_proc[clip_bit](&tmp1.pc,&q[0]->pc,&q[1]->pc); |
updateTmp(c,&tmp1,q[0],q[1],tt); |
tt=clip_proc[clip_bit](&tmp2.pc,&q[0]->pc,&q[2]->pc); |
updateTmp(c,&tmp2,q[0],q[2],tt); |
tmp1.edge_flag=q[0]->edge_flag; |
edge_flag_tmp=q[2]->edge_flag; |
q[2]->edge_flag=0; |
gl_draw_triangle_clip(c,&tmp1,q[1],q[2],clip_bit+1); |
tmp2.edge_flag=0; |
tmp1.edge_flag=0; |
q[2]->edge_flag=edge_flag_tmp; |
gl_draw_triangle_clip(c,&tmp2,&tmp1,q[2],clip_bit+1); |
} else { |
/* two points outside */ |
if ((cc[0] & clip_mask)==0) { q[0]=p0; q[1]=p1; q[2]=p2; } |
else if ((cc[1] & clip_mask)==0) { q[0]=p1; q[1]=p2; q[2]=p0; } |
else { q[0]=p2; q[1]=p0; q[2]=p1; } |
tt=clip_proc[clip_bit](&tmp1.pc,&q[0]->pc,&q[1]->pc); |
updateTmp(c,&tmp1,q[0],q[1],tt); |
tt=clip_proc[clip_bit](&tmp2.pc,&q[0]->pc,&q[2]->pc); |
updateTmp(c,&tmp2,q[0],q[2],tt); |
tmp1.edge_flag=1; |
tmp2.edge_flag=q[2]->edge_flag; |
gl_draw_triangle_clip(c,q[0],&tmp1,&tmp2,clip_bit+1); |
} |
} |
} |
void gl_draw_triangle_select(GLContext *c, |
GLVertex *p0,GLVertex *p1,GLVertex *p2) |
{ |
gl_add_select1(c,p0->zp.z,p1->zp.z,p2->zp.z); |
} |
#ifdef PROFILE |
int count_triangles,count_triangles_textured,count_pixels; |
#endif |
void gl_draw_triangle_fill(GLContext *c, |
GLVertex *p0,GLVertex *p1,GLVertex *p2) |
{ |
#ifdef PROFILE |
{ |
int norm; |
assert(p0->zp.x >= 0 && p0->zp.x < c->zb->xsize); |
assert(p0->zp.y >= 0 && p0->zp.y < c->zb->ysize); |
assert(p1->zp.x >= 0 && p1->zp.x < c->zb->xsize); |
assert(p1->zp.y >= 0 && p1->zp.y < c->zb->ysize); |
assert(p2->zp.x >= 0 && p2->zp.x < c->zb->xsize); |
assert(p2->zp.y >= 0 && p2->zp.y < c->zb->ysize); |
norm=(p1->zp.x-p0->zp.x)*(p2->zp.y-p0->zp.y)- |
(p2->zp.x-p0->zp.x)*(p1->zp.y-p0->zp.y); |
count_pixels+=abs(norm)/2; |
count_triangles++; |
} |
#endif |
if (c->texture_2d_enabled) { |
#ifdef PROFILE |
count_triangles_textured++; |
#endif |
ZB_setTexture(c->zb,c->current_texture->images[0].pixmap); |
ZB_fillTriangleMappingPerspective(c->zb,&p0->zp,&p1->zp,&p2->zp); |
} else if (c->current_shade_model == GL_SMOOTH) { |
ZB_fillTriangleSmooth(c->zb,&p0->zp,&p1->zp,&p2->zp); |
} else { |
ZB_fillTriangleFlat(c->zb,&p0->zp,&p1->zp,&p2->zp); |
} |
} |
/* Render a clipped triangle in line mode */ |
void gl_draw_triangle_line(GLContext *c, |
GLVertex *p0,GLVertex *p1,GLVertex *p2) |
{ |
if (c->depth_test) { |
if (p0->edge_flag) ZB_line_z(c->zb,&p0->zp,&p1->zp); |
if (p1->edge_flag) ZB_line_z(c->zb,&p1->zp,&p2->zp); |
if (p2->edge_flag) ZB_line_z(c->zb,&p2->zp,&p0->zp); |
} else { |
if (p0->edge_flag) ZB_line(c->zb,&p0->zp,&p1->zp); |
if (p1->edge_flag) ZB_line(c->zb,&p1->zp,&p2->zp); |
if (p2->edge_flag) ZB_line(c->zb,&p2->zp,&p0->zp); |
} |
} |
/* Render a clipped triangle in point mode */ |
void gl_draw_triangle_point(GLContext *c, |
GLVertex *p0,GLVertex *p1,GLVertex *p2) |
{ |
if (p0->edge_flag) ZB_plot(c->zb,&p0->zp); |
if (p1->edge_flag) ZB_plot(c->zb,&p1->zp); |
if (p2->edge_flag) ZB_plot(c->zb,&p2->zp); |
} |
/programs/develop/libraries/TinyGL/src/error.c |
---|
0,0 → 1,16 |
#include <stdarg.h> |
#include "zgl.h" |
void gl_fatal_error(char *format, ...) |
{ |
va_list ap; |
va_start(ap,format); |
fprintf(stderr,"TinyGL: fatal error: "); |
vfprintf(stderr,format,ap); |
fprintf(stderr,"\n"); |
exit(1); |
va_end(ap); |
} |
/programs/develop/libraries/TinyGL/src/get.c |
---|
0,0 → 1,72 |
#include "zgl.h" |
void glGetIntegerv(int pname,int *params) |
{ |
GLContext *c=gl_get_context(); |
switch(pname) { |
case GL_VIEWPORT: |
params[0]=c->viewport.xmin; |
params[1]=c->viewport.ymin; |
params[2]=c->viewport.xsize; |
params[3]=c->viewport.ysize; |
break; |
case GL_MAX_MODELVIEW_STACK_DEPTH: |
*params = MAX_MODELVIEW_STACK_DEPTH; |
break; |
case GL_MAX_PROJECTION_STACK_DEPTH: |
*params = MAX_PROJECTION_STACK_DEPTH; |
break; |
case GL_MAX_LIGHTS: |
*params = MAX_LIGHTS; |
break; |
case GL_MAX_TEXTURE_SIZE: |
*params = 256; /* not completely true, but... */ |
break; |
case GL_MAX_TEXTURE_STACK_DEPTH: |
*params = MAX_TEXTURE_STACK_DEPTH; |
break; |
default: |
gl_fatal_error("glGet: option not implemented"); |
break; |
} |
} |
void glGetFloatv(int pname, float *v) |
{ |
int i; |
int mnr = 0; /* just a trick to return the correct matrix */ |
GLContext *c = gl_get_context(); |
switch (pname) { |
case GL_TEXTURE_MATRIX: |
mnr++; |
case GL_PROJECTION_MATRIX: |
mnr++; |
case GL_MODELVIEW_MATRIX: |
{ |
float *p = &c->matrix_stack_ptr[mnr]->m[0][0];; |
for (i = 0; i < 4; i++) { |
*v++ = p[0]; |
*v++ = p[4]; |
*v++ = p[8]; |
*v++ = p[12]; |
p++; |
} |
} |
break; |
case GL_LINE_WIDTH: |
*v = 1.0f; |
break; |
case GL_LINE_WIDTH_RANGE: |
v[0] = v[1] = 1.0f; |
break; |
case GL_POINT_SIZE: |
*v = 1.0f; |
break; |
case GL_POINT_SIZE_RANGE: |
v[0] = v[1] = 1.0f; |
default: |
fprintf(stderr,"warning: unknown pname in glGetFloatv()\n"); |
break; |
} |
} |
/programs/develop/libraries/TinyGL/src/glu.c |
---|
0,0 → 1,343 |
#include <stdlib.h> |
#include <math.h> |
#include <GL/gl.h> |
#include <GL/glu.h> |
void drawTorus(float rc, int numc, float rt, int numt) |
{ |
int i, j, k; |
double s, t; |
double x, y, z; |
double pi, twopi; |
pi = 3.14159265358979323846; |
twopi = 2 * pi; |
for (i = 0; i < numc; i++) { |
glBegin(GL_QUAD_STRIP); |
for (j = 0; j <= numt; j++) { |
for (k = 1; k >= 0; k--) { |
s = (i + k) % numc + 0.5; |
t = j % numt; |
x = cos(t*twopi/numt) * cos(s*twopi/numc); |
y = sin(t*twopi/numt) * cos(s*twopi/numc); |
z = sin(s*twopi/numc); |
glNormal3f(x, y, z); |
x = (rt + rc * cos(s*twopi/numc)) * cos(t*twopi/numt); |
y = (rt + rc * cos(s*twopi/numc)) * sin(t*twopi/numt); |
z = rc * sin(s*twopi/numc); |
glVertex3f(x, y, z); |
} |
} |
glEnd(); |
} |
} |
static void normal3f( GLfloat x, GLfloat y, GLfloat z ) |
{ |
GLdouble mag; |
mag = sqrt( x*x + y*y + z*z ); |
if (mag>0.00001F) { |
x /= mag; |
y /= mag; |
z /= mag; |
} |
glNormal3f( x, y, z ); |
} |
void gluPerspective( GLdouble fovy, GLdouble aspect, |
GLdouble zNear, GLdouble zFar ) |
{ |
GLdouble xmin, xmax, ymin, ymax; |
ymax = zNear * tan( fovy * M_PI / 360.0 ); |
ymin = -ymax; |
xmin = ymin * aspect; |
xmax = ymax * aspect; |
glFrustum( xmin, xmax, ymin, ymax, zNear, zFar ); |
} |
void |
gluLookAt(GLdouble eyex, GLdouble eyey, GLdouble eyez, |
GLdouble centerx, GLdouble centery, GLdouble centerz, |
GLdouble upx, GLdouble upy, GLdouble upz) |
{ |
GLfloat m[16]; |
GLdouble x[3], y[3], z[3]; |
GLdouble mag; |
/* Make rotation matrix */ |
/* Z vector */ |
z[0] = eyex - centerx; |
z[1] = eyey - centery; |
z[2] = eyez - centerz; |
mag = sqrt(z[0] * z[0] + z[1] * z[1] + z[2] * z[2]); |
if (mag) { /* mpichler, 19950515 */ |
z[0] /= mag; |
z[1] /= mag; |
z[2] /= mag; |
} |
/* Y vector */ |
y[0] = upx; |
y[1] = upy; |
y[2] = upz; |
/* X vector = Y cross Z */ |
x[0] = y[1] * z[2] - y[2] * z[1]; |
x[1] = -y[0] * z[2] + y[2] * z[0]; |
x[2] = y[0] * z[1] - y[1] * z[0]; |
/* Recompute Y = Z cross X */ |
y[0] = z[1] * x[2] - z[2] * x[1]; |
y[1] = -z[0] * x[2] + z[2] * x[0]; |
y[2] = z[0] * x[1] - z[1] * x[0]; |
/* mpichler, 19950515 */ |
/* cross product gives area of parallelogram, which is < 1.0 for |
* non-perpendicular unit-length vectors; so normalize x, y here |
*/ |
mag = sqrt(x[0] * x[0] + x[1] * x[1] + x[2] * x[2]); |
if (mag) { |
x[0] /= mag; |
x[1] /= mag; |
x[2] /= mag; |
} |
mag = sqrt(y[0] * y[0] + y[1] * y[1] + y[2] * y[2]); |
if (mag) { |
y[0] /= mag; |
y[1] /= mag; |
y[2] /= mag; |
} |
#define M(row,col) m[col*4+row] |
M(0, 0) = x[0]; |
M(0, 1) = x[1]; |
M(0, 2) = x[2]; |
M(0, 3) = 0.0; |
M(1, 0) = y[0]; |
M(1, 1) = y[1]; |
M(1, 2) = y[2]; |
M(1, 3) = 0.0; |
M(2, 0) = z[0]; |
M(2, 1) = z[1]; |
M(2, 2) = z[2]; |
M(2, 3) = 0.0; |
M(3, 0) = 0.0; |
M(3, 1) = 0.0; |
M(3, 2) = 0.0; |
M(3, 3) = 1.0; |
#undef M |
glMultMatrixf(m); |
/* Translate Eye to Origin */ |
glTranslatef(-eyex, -eyey, -eyez); |
} |
GLUquadricObj *gluNewQuadric(void) |
{ |
return NULL; |
} |
void gluQuadricDrawStyle(GLUquadricObj *obj, int style) |
{ |
} |
void gluCylinder( GLUquadricObj *qobj, |
GLdouble baseRadius, GLdouble topRadius, GLdouble height, |
GLint slices, GLint stacks ) |
{ |
GLdouble da, r, dr, dz; |
GLfloat z, nz, nsign; |
GLint i, j; |
GLfloat du = 1.0 / slices; |
GLfloat dv = 1.0 / stacks; |
GLfloat tcx = 0.0, tcy = 0.0; |
nsign = 1.0; |
da = 2.0*M_PI / slices; |
dr = (topRadius-baseRadius) / stacks; |
dz = height / stacks; |
nz = (baseRadius-topRadius) / height; /* Z component of normal vectors */ |
for (i=0;i<slices;i++) { |
GLfloat x1 = -sin(i*da); |
GLfloat y1 = cos(i*da); |
GLfloat x2 = -sin((i+1)*da); |
GLfloat y2 = cos((i+1)*da); |
z = 0.0; |
r = baseRadius; |
tcy = 0.0; |
glBegin( GL_QUAD_STRIP ); |
for (j=0;j<=stacks;j++) { |
if (nsign==1.0) { |
normal3f( x1*nsign, y1*nsign, nz*nsign ); |
glTexCoord2f(tcx, tcy); |
glVertex3f( x1*r, y1*r, z ); |
normal3f( x2*nsign, y2*nsign, nz*nsign ); |
glTexCoord2f(tcx+du, tcy); |
glVertex3f( x2*r, y2*r, z ); |
} |
else { |
normal3f( x2*nsign, y2*nsign, nz*nsign ); |
glTexCoord2f(tcx, tcy); |
glVertex3f( x2*r, y2*r, z ); |
normal3f( x1*nsign, y1*nsign, nz*nsign ); |
glTexCoord2f(tcx+du, tcy); |
glVertex3f( x1*r, y1*r, z ); |
} |
z += dz; |
r += dr; |
tcy += dv; |
} |
glEnd(); |
tcx += du; |
} |
} |
/* Disk (adapted from Mesa) */ |
void gluDisk( GLUquadricObj *qobj, |
GLdouble innerRadius, GLdouble outerRadius, |
GLint slices, GLint loops ) |
{ |
GLdouble a, da; |
GLfloat dr; |
GLfloat r1, r2, dtc; |
GLint s, l; |
GLfloat sa,ca; |
/* Normal vectors */ |
glNormal3f( 0.0, 0.0, +1.0 ); |
da = 2.0*M_PI / slices; |
dr = (outerRadius-innerRadius) / (GLfloat) loops; |
/* texture of a gluDisk is a cut out of the texture unit square */ |
/* x, y in [-outerRadius, +outerRadius]; s, t in [0, 1] (linear mapping) */ |
dtc = 2.0f * outerRadius; |
r1 = innerRadius; |
for (l=0;l<loops;l++) { |
r2 = r1 + dr; |
glBegin( GL_QUAD_STRIP ); |
for (s=0;s<=slices;s++) { |
if (s==slices) a = 0.0; |
else a = s * da; |
sa = sin(a); ca = cos(a); |
glTexCoord2f(0.5+sa*r2/dtc,0.5+ca*r2/dtc); |
glVertex2f( r2*sa, r2*ca ); |
glTexCoord2f(0.5+sa*r1/dtc,0.5+ca*r1/dtc); |
glVertex2f( r1*sa, r1*ca ); |
} |
glEnd(); |
r1 = r2; |
} |
} |
/* |
* Sphere (adapted from Mesa) |
*/ |
void gluSphere(GLUquadricObj *qobj, |
float radius,int slices,int stacks) |
{ |
float rho, drho, theta, dtheta; |
float x, y, z; |
float s, t, ds, dt; |
int i, j, imin, imax; |
int normals; |
float nsign; |
normals=1; |
nsign=1; |
drho = M_PI / (float) stacks; |
dtheta = 2.0 * M_PI / (float) slices; |
/* draw +Z end as a triangle fan */ |
glBegin( GL_TRIANGLE_FAN ); |
glNormal3f( 0.0, 0.0, 1.0 ); |
glTexCoord2f(0.5,0.0); |
glVertex3f( 0.0, 0.0, nsign * radius ); |
for (j=0;j<=slices;j++) { |
theta = (j==slices) ? 0.0 : j * dtheta; |
x = -sin(theta) * sin(drho); |
y = cos(theta) * sin(drho); |
z = nsign * cos(drho); |
if (normals) glNormal3f( x*nsign, y*nsign, z*nsign ); |
glVertex3f( x*radius, y*radius, z*radius ); |
} |
glEnd(); |
ds = 1.0 / slices; |
dt = 1.0 / stacks; |
t = 1.0; /* because loop now runs from 0 */ |
if (1) { |
imin = 0; |
imax = stacks; |
} |
else { |
imin = 1; |
imax = stacks-1; |
} |
/* draw intermediate stacks as quad strips */ |
for (i=imin;i<imax;i++) { |
rho = i * drho; |
glBegin( GL_QUAD_STRIP ); |
s = 0.0; |
for (j=0;j<=slices;j++) { |
theta = (j==slices) ? 0.0 : j * dtheta; |
x = -sin(theta) * sin(rho); |
y = cos(theta) * sin(rho); |
z = nsign * cos(rho); |
if (normals) glNormal3f( x*nsign, y*nsign, z*nsign ); |
glTexCoord2f(s,1-t); |
glVertex3f( x*radius, y*radius, z*radius ); |
x = -sin(theta) * sin(rho+drho); |
y = cos(theta) * sin(rho+drho); |
z = nsign * cos(rho+drho); |
if (normals) glNormal3f( x*nsign, y*nsign, z*nsign ); |
glTexCoord2f(s,1-(t-dt)); |
s += ds; |
glVertex3f( x*radius, y*radius, z*radius ); |
} |
glEnd(); |
t -= dt; |
} |
/* draw -Z end as a triangle fan */ |
glBegin( GL_TRIANGLE_FAN ); |
glNormal3f( 0.0, 0.0, -1.0 ); |
glTexCoord2f(0.5,1.0); |
glVertex3f( 0.0, 0.0, -radius*nsign ); |
rho = M_PI - drho; |
s = 1.0; |
t = dt; |
for (j=slices;j>=0;j--) { |
theta = (j==slices) ? 0.0 : j * dtheta; |
x = -sin(theta) * sin(rho); |
y = cos(theta) * sin(rho); |
z = nsign * cos(rho); |
if (normals) glNormal3f( x*nsign, y*nsign, z*nsign ); |
glTexCoord2f(s,1-t); |
s -= ds; |
glVertex3f( x*radius, y*radius, z*radius ); |
} |
glEnd(); |
} |
/programs/develop/libraries/TinyGL/src/image_util.c |
---|
0,0 → 1,136 |
#include "zgl.h" |
/* |
* image conversion |
*/ |
void gl_convertRGB_to_5R6G5B(unsigned short *pixmap,unsigned char *rgb, |
int xsize,int ysize) |
{ |
int i,n; |
unsigned char *p; |
p=rgb; |
n=xsize*ysize; |
for(i=0;i<n;i++) { |
pixmap[i]=((p[0]&0xF8)<<8) | ((p[1]&0xFC)<<3) | ((p[2]&0xF8)>>3); |
p+=3; |
} |
} |
void gl_convertRGB_to_8A8R8G8B(unsigned int *pixmap, unsigned char *rgb, |
int xsize, int ysize) |
{ |
int i,n; |
unsigned char *p; |
p=rgb; |
n=xsize*ysize; |
for(i=0;i<n;i++) { |
pixmap[i]=(((unsigned int)p[0])<<16) | |
(((unsigned int)p[1])<<8) | |
(((unsigned int)p[2])); |
p+=3; |
} |
} |
/* |
* linear interpolation with xf,yf normalized to 2^16 |
*/ |
#define INTERP_NORM_BITS 16 |
#define INTERP_NORM (1 << INTERP_NORM_BITS) |
static inline int interpolate(int v00,int v01,int v10,int xf,int yf) |
{ |
return v00+(((v01-v00)*xf + (v10-v00)*yf) >> INTERP_NORM_BITS); |
} |
/* |
* TODO: more accurate resampling |
*/ |
void gl_resizeImage(unsigned char *dest,int xsize_dest,int ysize_dest, |
unsigned char *src,int xsize_src,int ysize_src) |
{ |
unsigned char *pix,*pix_src; |
float x1,y1,x1inc,y1inc; |
int xi,yi,j,xf,yf,x,y; |
pix=dest; |
pix_src=src; |
x1inc=(float) (xsize_src - 1) / (float) (xsize_dest - 1); |
y1inc=(float) (ysize_src - 1) / (float) (ysize_dest - 1); |
y1=0; |
for(y=0;y<ysize_dest;y++) { |
x1=0; |
for(x=0;x<xsize_dest;x++) { |
xi=(int) x1; |
yi=(int) y1; |
xf=(int) ((x1 - floor(x1)) * INTERP_NORM); |
yf=(int) ((y1 - floor(y1)) * INTERP_NORM); |
if ((xf+yf) <= INTERP_NORM) { |
for(j=0;j<3;j++) { |
pix[j]=interpolate(pix_src[(yi*xsize_src+xi)*3+j], |
pix_src[(yi*xsize_src+xi+1)*3+j], |
pix_src[((yi+1)*xsize_src+xi)*3+j], |
xf,yf); |
} |
} else { |
xf=INTERP_NORM - xf; |
yf=INTERP_NORM - yf; |
for(j=0;j<3;j++) { |
pix[j]=interpolate(pix_src[((yi+1)*xsize_src+xi+1)*3+j], |
pix_src[((yi+1)*xsize_src+xi)*3+j], |
pix_src[(yi*xsize_src+xi+1)*3+j], |
xf,yf); |
} |
} |
pix+=3; |
x1+=x1inc; |
} |
y1+=y1inc; |
} |
} |
#define FRAC_BITS 16 |
/* resizing with no interlating nor nearest pixel */ |
void gl_resizeImageNoInterpolate(unsigned char *dest,int xsize_dest,int ysize_dest, |
unsigned char *src,int xsize_src,int ysize_src) |
{ |
unsigned char *pix,*pix_src,*pix1; |
int x1,y1,x1inc,y1inc; |
int xi,yi,x,y; |
pix=dest; |
pix_src=src; |
x1inc=(int)((float) ((xsize_src)<<FRAC_BITS) / (float) (xsize_dest)); |
y1inc=(int)((float) ((ysize_src)<<FRAC_BITS) / (float) (ysize_dest)); |
y1=0; |
for(y=0;y<ysize_dest;y++) { |
x1=0; |
for(x=0;x<xsize_dest;x++) { |
xi=x1 >> FRAC_BITS; |
yi=y1 >> FRAC_BITS; |
pix1=pix_src+(yi*xsize_src+xi)*3; |
pix[0]=pix1[0]; |
pix[1]=pix1[1]; |
pix[2]=pix1[2]; |
pix+=3; |
x1+=x1inc; |
} |
y1+=y1inc; |
} |
} |
/programs/develop/libraries/TinyGL/src/init.c |
---|
0,0 → 1,189 |
#include "zgl.h" |
GLContext *gl_ctx; |
void initSharedState(GLContext *c) |
{ |
GLSharedState *s=&c->shared_state; |
s->lists=gl_zalloc(sizeof(GLList *) * MAX_DISPLAY_LISTS); |
s->texture_hash_table= |
gl_zalloc(sizeof(GLTexture *) * TEXTURE_HASH_TABLE_SIZE); |
alloc_texture(c,0); |
} |
void endSharedState(GLContext *c) |
{ |
GLSharedState *s=&c->shared_state; |
int i; |
for(i=0;i<MAX_DISPLAY_LISTS;i++) { |
/* TODO */ |
} |
gl_free(s->lists); |
gl_free(s->texture_hash_table); |
} |
void glInit(void *zbuffer1) |
{ |
ZBuffer *zbuffer=(ZBuffer *)zbuffer1; |
GLContext *c; |
GLViewport *v; |
int i; |
c=gl_zalloc(sizeof(GLContext)); |
gl_ctx=c; |
c->zb=zbuffer; |
/* allocate GLVertex array */ |
c->vertex_max = POLYGON_MAX_VERTEX; |
c->vertex = gl_malloc(POLYGON_MAX_VERTEX*sizeof(GLVertex)); |
/* viewport */ |
v=&c->viewport; |
v->xmin=0; |
v->ymin=0; |
v->xsize=zbuffer->xsize; |
v->ysize=zbuffer->ysize; |
v->updated=1; |
/* shared state */ |
initSharedState(c); |
/* lists */ |
c->exec_flag=1; |
c->compile_flag=0; |
c->print_flag=0; |
c->in_begin=0; |
/* lights */ |
for(i=0;i<MAX_LIGHTS;i++) { |
GLLight *l=&c->lights[i]; |
l->ambient=gl_V4_New(0,0,0,1); |
l->diffuse=gl_V4_New(1,1,1,1); |
l->specular=gl_V4_New(1,1,1,1); |
l->position=gl_V4_New(0,0,1,0); |
l->norm_position=gl_V3_New(0,0,1); |
l->spot_direction=gl_V3_New(0,0,-1); |
l->norm_spot_direction=gl_V3_New(0,0,-1); |
l->spot_exponent=0; |
l->spot_cutoff=180; |
l->attenuation[0]=1; |
l->attenuation[1]=0; |
l->attenuation[2]=0; |
l->enabled=0; |
} |
c->first_light=NULL; |
c->ambient_light_model=gl_V4_New(0.2,0.2,0.2,1); |
c->local_light_model=0; |
c->lighting_enabled=0; |
c->light_model_two_side = 0; |
/* default materials */ |
for(i=0;i<2;i++) { |
GLMaterial *m=&c->materials[i]; |
m->emission=gl_V4_New(0,0,0,1); |
m->ambient=gl_V4_New(0.2,0.2,0.2,1); |
m->diffuse=gl_V4_New(0.8,0.8,0.8,1); |
m->specular=gl_V4_New(0,0,0,1); |
m->shininess=0; |
} |
c->current_color_material_mode=GL_FRONT_AND_BACK; |
c->current_color_material_type=GL_AMBIENT_AND_DIFFUSE; |
c->color_material_enabled=0; |
/* textures */ |
glInitTextures(c); |
/* default state */ |
c->current_color.X=1.0; |
c->current_color.Y=1.0; |
c->current_color.Z=1.0; |
c->current_color.W=1.0; |
c->longcurrent_color[0] = 65535; |
c->longcurrent_color[1] = 65535; |
c->longcurrent_color[2] = 65535; |
c->current_normal.X=1.0; |
c->current_normal.Y=0.0; |
c->current_normal.Z=0.0; |
c->current_normal.W=0.0; |
c->current_edge_flag=1; |
c->current_tex_coord.X=0; |
c->current_tex_coord.Y=0; |
c->current_tex_coord.Z=0; |
c->current_tex_coord.W=1; |
c->polygon_mode_front=GL_FILL; |
c->polygon_mode_back=GL_FILL; |
c->current_front_face=0; /* 0 = GL_CCW 1 = GL_CW */ |
c->current_cull_face=GL_BACK; |
c->current_shade_model=GL_SMOOTH; |
c->cull_face_enabled=0; |
/* clear */ |
c->clear_color.v[0]=0; |
c->clear_color.v[1]=0; |
c->clear_color.v[2]=0; |
c->clear_color.v[3]=0; |
c->clear_depth=0; |
/* selection */ |
c->render_mode=GL_RENDER; |
c->select_buffer=NULL; |
c->name_stack_size=0; |
/* matrix */ |
c->matrix_mode=0; |
c->matrix_stack_depth_max[0]=MAX_MODELVIEW_STACK_DEPTH; |
c->matrix_stack_depth_max[1]=MAX_PROJECTION_STACK_DEPTH; |
c->matrix_stack_depth_max[2]=MAX_TEXTURE_STACK_DEPTH; |
for(i=0;i<3;i++) { |
c->matrix_stack[i]=gl_zalloc(c->matrix_stack_depth_max[i] * sizeof(M4)); |
c->matrix_stack_ptr[i]=c->matrix_stack[i]; |
} |
glMatrixMode(GL_PROJECTION); |
glLoadIdentity(); |
glMatrixMode(GL_TEXTURE); |
glLoadIdentity(); |
glMatrixMode(GL_MODELVIEW); |
glLoadIdentity(); |
c->matrix_model_projection_updated=1; |
/* opengl 1.1 arrays */ |
c->client_states = 0; |
/* opengl 1.1 polygon offset */ |
c->offset_states = 0; |
/* clear the resize callback function pointer */ |
c->gl_resize_viewport = NULL; |
/* specular buffer */ |
c->specbuf_first = NULL; |
c->specbuf_used_counter = 0; |
c->specbuf_num_buffers = 0; |
/* depth test */ |
c->depth_test = 0; |
} |
void glClose(void) |
{ |
GLContext *c=gl_get_context(); |
endSharedState(c); |
gl_free(c); |
} |
/programs/develop/libraries/TinyGL/src/kosgl.c |
---|
0,0 → 1,127 |
/* simple gl like driver for TinyGL and KolibriOS - porting iadn */ |
#include <GL/gl.h> |
#include "kosgl.h" |
#include "zgl.h" |
typedef struct { |
GLContext *gl_context; |
int xsize,ysize; |
int dx,dy; |
int x,y; |
} TinyGLContext; |
KOSGLContext kosglCreateContext(KOSGLContext shareList, int flags) |
{ |
TinyGLContext *ctx; |
if (shareList != NULL) { |
gl_fatal_error("No sharing available in TinyGL"); |
} |
ctx=gl_malloc(sizeof(TinyGLContext)); |
if (!ctx) |
return NULL; |
ctx->gl_context=NULL; |
return (KOSGLContext) ctx; |
} |
void kosglDestroyContext( KOSGLContext ctx1 ) |
{ |
TinyGLContext *ctx = (TinyGLContext *) ctx1; |
if (ctx->gl_context != NULL) { |
glClose(); |
} |
gl_free(ctx); |
} |
/* resize the glx viewport : we try to use the xsize and ysize |
given. We return the effective size which is guaranted to be smaller */ |
static int gl_resize_viewport(GLContext *c,int *xsize_ptr,int *ysize_ptr) |
{ |
TinyGLContext *ctx; |
int xsize,ysize; |
ctx=(TinyGLContext *)c->opaque; |
xsize=*xsize_ptr; |
ysize=*ysize_ptr; |
/* we ensure that xsize and ysize are multiples of 2 for the zbuffer. |
TODO: find a better solution */ |
xsize&=~3; |
ysize&=~3; |
if (xsize == 0 || ysize == 0) return -1; |
*xsize_ptr=xsize-1; |
*ysize_ptr=ysize-1; |
ctx->dx = xsize; |
ctx->dy = ysize; |
ctx->xsize=xsize; |
ctx->ysize=ysize; |
/* resize the Z buffer */ |
ZB_resize(c->zb,NULL,xsize,ysize); |
return 0; |
} |
/* we assume here that drawable is a window */ |
int kosglMakeCurrent( int win_x0, int win_y0,int win_x, int win_y, KOSGLContext ctx1) |
{ |
TinyGLContext *ctx = (TinyGLContext *) ctx1; |
int mode; |
ZBuffer *zb; |
if (ctx->gl_context == NULL) { |
/* create the TinyGL context */ |
ctx->x = win_x0; |
ctx->y = win_y0; |
ctx->dx = win_x; |
ctx->dy = win_y; |
/* currently, we only support 16 bit rendering */ |
mode = ZB_MODE_RGB24; |
zb=ZB_open(win_x,win_y,mode,0,NULL,NULL,NULL); |
if (zb == NULL) { |
fprintf(stderr, "Error while initializing Z buffer\n"); |
exit(1); |
} |
/* initialisation of the TinyGL interpreter */ |
glInit(zb); |
ctx->gl_context=gl_get_context(); |
ctx->gl_context->opaque=(void *) ctx; |
ctx->gl_context->gl_resize_viewport=gl_resize_viewport; |
/* set the viewport : we force a call to gl_resize_viewport */ |
ctx->gl_context->viewport.xsize=-1; |
ctx->gl_context->viewport.ysize=-1; |
glViewport(0, 0, win_x, win_y); |
} |
return 1; |
} |
void kosglSwapBuffers( ) |
{ |
GLContext *gl_context; |
TinyGLContext *ctx; |
/* retrieve the current TinyGLContext */ |
gl_context=gl_get_context(); |
ctx=(TinyGLContext *)gl_context->opaque; |
__asm__ __volatile__("int $0x40"::"a"(7), |
"b"((char *)gl_context->zb->pbuf), |
"c"((ctx->dx<<16)|ctx->dy), |
"d"((ctx->x<<16)|ctx->y)); |
} |
/programs/develop/libraries/TinyGL/src/light.c |
---|
0,0 → 1,306 |
#include "zgl.h" |
#include "msghandling.h" |
void glopMaterial(GLContext *c,GLParam *p) |
{ |
int mode=p[1].i; |
int type=p[2].i; |
float *v=&p[3].f; |
int i; |
GLMaterial *m; |
if (mode == GL_FRONT_AND_BACK) { |
p[1].i=GL_FRONT; |
glopMaterial(c,p); |
mode=GL_BACK; |
} |
if (mode == GL_FRONT) m=&c->materials[0]; |
else m=&c->materials[1]; |
switch(type) { |
case GL_EMISSION: |
for(i=0;i<4;i++) |
m->emission.v[i]=v[i]; |
break; |
case GL_AMBIENT: |
for(i=0;i<4;i++) |
m->ambient.v[i]=v[i]; |
break; |
case GL_DIFFUSE: |
for(i=0;i<4;i++) |
m->diffuse.v[i]=v[i]; |
break; |
case GL_SPECULAR: |
for(i=0;i<4;i++) |
m->specular.v[i]=v[i]; |
break; |
case GL_SHININESS: |
m->shininess=v[0]; |
m->shininess_i = (v[0]/128.0f)*SPECULAR_BUFFER_RESOLUTION; |
break; |
case GL_AMBIENT_AND_DIFFUSE: |
for(i=0;i<4;i++) |
m->diffuse.v[i]=v[i]; |
for(i=0;i<4;i++) |
m->ambient.v[i]=v[i]; |
break; |
default: |
assert(0); |
} |
} |
void glopColorMaterial(GLContext *c,GLParam *p) |
{ |
int mode=p[1].i; |
int type=p[2].i; |
c->current_color_material_mode=mode; |
c->current_color_material_type=type; |
} |
void glopLight(GLContext *c,GLParam *p) |
{ |
int light=p[1].i; |
int type=p[2].i; |
V4 v; |
GLLight *l; |
int i; |
assert(light >= GL_LIGHT0 && light < GL_LIGHT0+MAX_LIGHTS ); |
l=&c->lights[light-GL_LIGHT0]; |
for(i=0;i<4;i++) v.v[i]=p[3+i].f; |
switch(type) { |
case GL_AMBIENT: |
l->ambient=v; |
break; |
case GL_DIFFUSE: |
l->diffuse=v; |
break; |
case GL_SPECULAR: |
l->specular=v; |
break; |
case GL_POSITION: |
{ |
V4 pos; |
gl_M4_MulV4(&pos,c->matrix_stack_ptr[0],&v); |
l->position=pos; |
if (l->position.v[3] == 0) { |
l->norm_position.X=pos.X; |
l->norm_position.Y=pos.Y; |
l->norm_position.Z=pos.Z; |
gl_V3_Norm(&l->norm_position); |
} |
} |
break; |
case GL_SPOT_DIRECTION: |
for(i=0;i<3;i++) { |
l->spot_direction.v[i]=v.v[i]; |
l->norm_spot_direction.v[i]=v.v[i]; |
} |
gl_V3_Norm(&l->norm_spot_direction); |
break; |
case GL_SPOT_EXPONENT: |
l->spot_exponent=v.v[0]; |
break; |
case GL_SPOT_CUTOFF: |
{ |
float a=v.v[0]; |
assert(a == 180 || (a>=0 && a<=90)); |
l->spot_cutoff=a; |
if (a != 180) l->cos_spot_cutoff=cos(a * M_PI / 180.0); |
} |
break; |
case GL_CONSTANT_ATTENUATION: |
l->attenuation[0]=v.v[0]; |
break; |
case GL_LINEAR_ATTENUATION: |
l->attenuation[1]=v.v[0]; |
break; |
case GL_QUADRATIC_ATTENUATION: |
l->attenuation[2]=v.v[0]; |
break; |
default: |
assert(0); |
} |
} |
void glopLightModel(GLContext *c,GLParam *p) |
{ |
int pname=p[1].i; |
float *v=&p[2].f; |
int i; |
switch(pname) { |
case GL_LIGHT_MODEL_AMBIENT: |
for(i=0;i<4;i++) |
c->ambient_light_model.v[i]=v[i]; |
break; |
case GL_LIGHT_MODEL_LOCAL_VIEWER: |
c->local_light_model=(int)v[0]; |
break; |
case GL_LIGHT_MODEL_TWO_SIDE: |
c->light_model_two_side = (int)v[0]; |
break; |
default: |
tgl_warning("glopLightModel: illegal pname: 0x%x\n", pname); |
//assert(0); |
break; |
} |
} |
static inline float clampf(float a,float min,float max) |
{ |
if (a<min) return min; |
else if (a>max) return max; |
else return a; |
} |
void gl_enable_disable_light(GLContext *c,int light,int v) |
{ |
GLLight *l=&c->lights[light]; |
if (v && !l->enabled) { |
l->enabled=1; |
l->next=c->first_light; |
c->first_light=l; |
l->prev=NULL; |
} else if (!v && l->enabled) { |
l->enabled=0; |
if (l->prev == NULL) c->first_light=l->next; |
else l->prev->next=l->next; |
if (l->next != NULL) l->next->prev=l->prev; |
} |
} |
/* non optimized lightening model */ |
void gl_shade_vertex(GLContext *c,GLVertex *v) |
{ |
float R,G,B,A; |
GLMaterial *m; |
GLLight *l; |
V3 n,s,d; |
float dist,tmp,att,dot,dot_spot,dot_spec; |
int twoside = c->light_model_two_side; |
m=&c->materials[0]; |
n.X=v->normal.X; |
n.Y=v->normal.Y; |
n.Z=v->normal.Z; |
R=m->emission.v[0]+m->ambient.v[0]*c->ambient_light_model.v[0]; |
G=m->emission.v[1]+m->ambient.v[1]*c->ambient_light_model.v[1]; |
B=m->emission.v[2]+m->ambient.v[2]*c->ambient_light_model.v[2]; |
A=clampf(m->diffuse.v[3],0,1); |
for(l=c->first_light;l!=NULL;l=l->next) { |
float lR,lB,lG; |
/* ambient */ |
lR=l->ambient.v[0] * m->ambient.v[0]; |
lG=l->ambient.v[1] * m->ambient.v[1]; |
lB=l->ambient.v[2] * m->ambient.v[2]; |
if (l->position.v[3] == 0) { |
/* light at infinity */ |
d.X=l->position.v[0]; |
d.Y=l->position.v[1]; |
d.Z=l->position.v[2]; |
att=1; |
} else { |
/* distance attenuation */ |
d.X=l->position.v[0]-v->ec.v[0]; |
d.Y=l->position.v[1]-v->ec.v[1]; |
d.Z=l->position.v[2]-v->ec.v[2]; |
dist=sqrt(d.X*d.X+d.Y*d.Y+d.Z*d.Z); |
if (dist>1E-3) { |
tmp=1/dist; |
d.X*=tmp; |
d.Y*=tmp; |
d.Z*=tmp; |
} |
att=1.0f/(l->attenuation[0]+dist*(l->attenuation[1]+ |
dist*l->attenuation[2])); |
} |
dot=d.X*n.X+d.Y*n.Y+d.Z*n.Z; |
if (twoside && dot < 0) dot = -dot; |
if (dot>0) { |
/* diffuse light */ |
lR+=dot * l->diffuse.v[0] * m->diffuse.v[0]; |
lG+=dot * l->diffuse.v[1] * m->diffuse.v[1]; |
lB+=dot * l->diffuse.v[2] * m->diffuse.v[2]; |
/* spot light */ |
if (l->spot_cutoff != 180) { |
dot_spot=-(d.X*l->norm_spot_direction.v[0]+ |
d.Y*l->norm_spot_direction.v[1]+ |
d.Z*l->norm_spot_direction.v[2]); |
if (twoside && dot_spot < 0) dot_spot = -dot_spot; |
if (dot_spot < l->cos_spot_cutoff) { |
/* no contribution */ |
continue; |
} else { |
/* TODO: optimize */ |
if (l->spot_exponent > 0) { |
att=att*pow(dot_spot,l->spot_exponent); |
} |
} |
} |
/* specular light */ |
if (c->local_light_model) { |
V3 vcoord; |
vcoord.X=v->ec.X; |
vcoord.Y=v->ec.Y; |
vcoord.Z=v->ec.Z; |
gl_V3_Norm(&vcoord); |
s.X=d.X-vcoord.X; |
s.Y=d.Y-vcoord.X; |
s.Z=d.Z-vcoord.X; |
} else { |
s.X=d.X; |
s.Y=d.Y; |
s.Z=d.Z+1.0; |
} |
dot_spec=n.X*s.X+n.Y*s.Y+n.Z*s.Z; |
if (twoside && dot_spec < 0) dot_spec = -dot_spec; |
if (dot_spec>0) { |
GLSpecBuf *specbuf; |
int idx; |
tmp=sqrt(s.X*s.X+s.Y*s.Y+s.Z*s.Z); |
if (tmp > 1E-3) { |
dot_spec=dot_spec / tmp; |
} |
/* TODO: optimize */ |
/* testing specular buffer code */ |
/* dot_spec= pow(dot_spec,m->shininess);*/ |
specbuf = specbuf_get_buffer(c, m->shininess_i, m->shininess); |
idx = (int)(dot_spec*SPECULAR_BUFFER_SIZE); |
if (idx > SPECULAR_BUFFER_SIZE) idx = SPECULAR_BUFFER_SIZE; |
dot_spec = specbuf->buf[idx]; |
lR+=dot_spec * l->specular.v[0] * m->specular.v[0]; |
lG+=dot_spec * l->specular.v[1] * m->specular.v[1]; |
lB+=dot_spec * l->specular.v[2] * m->specular.v[2]; |
} |
} |
R+=att * lR; |
G+=att * lG; |
B+=att * lB; |
} |
v->color.v[0]=clampf(R,0,1); |
v->color.v[1]=clampf(G,0,1); |
v->color.v[2]=clampf(B,0,1); |
v->color.v[3]=A; |
} |
/programs/develop/libraries/TinyGL/src/list.c |
---|
0,0 → 1,251 |
#include "zgl.h" |
static char *op_table_str[]= |
{ |
#define ADD_OP(a,b,c) "gl" #a " " #c, |
#include "opinfo.h" |
}; |
static void (*op_table_func[])(GLContext *,GLParam *)= |
{ |
#define ADD_OP(a,b,c) glop ## a , |
#include "opinfo.h" |
}; |
static int op_table_size[]= |
{ |
#define ADD_OP(a,b,c) b + 1 , |
#include "opinfo.h" |
}; |
static GLList *find_list(GLContext *c,unsigned int list) |
{ |
return c->shared_state.lists[list]; |
} |
static void delete_list(GLContext *c,int list) |
{ |
GLParamBuffer *pb,*pb1; |
GLList *l; |
l=find_list(c,list); |
assert(l != NULL); |
/* free param buffer */ |
pb=l->first_op_buffer; |
while (pb!=NULL) { |
pb1=pb->next; |
gl_free(pb); |
pb=pb1; |
} |
gl_free(l); |
c->shared_state.lists[list]=NULL; |
} |
static GLList *alloc_list(GLContext *c,int list) |
{ |
GLList *l; |
GLParamBuffer *ob; |
l=gl_zalloc(sizeof(GLList)); |
ob=gl_zalloc(sizeof(GLParamBuffer)); |
ob->next=NULL; |
l->first_op_buffer=ob; |
ob->ops[0].op=OP_EndList; |
c->shared_state.lists[list]=l; |
return l; |
} |
void gl_print_op(FILE *f,GLParam *p) |
{ |
int op; |
char *s; |
op=p[0].op; |
p++; |
s=op_table_str[op]; |
while (*s != 0) { |
if (*s == '%') { |
s++; |
switch (*s++) { |
case 'f': |
fprintf(f,"%g",p[0].f); |
break; |
default: |
fprintf(f,"%d",p[0].i); |
break; |
} |
p++; |
} else { |
fputc(*s,f); |
s++; |
} |
} |
fprintf(f,"\n"); |
} |
void gl_compile_op(GLContext *c,GLParam *p) |
{ |
int op,op_size; |
GLParamBuffer *ob,*ob1; |
int index,i; |
op=p[0].op; |
op_size=op_table_size[op]; |
index=c->current_op_buffer_index; |
ob=c->current_op_buffer; |
/* we should be able to add a NextBuffer opcode */ |
if ((index + op_size) > (OP_BUFFER_MAX_SIZE-2)) { |
ob1=gl_zalloc(sizeof(GLParamBuffer)); |
ob1->next=NULL; |
ob->next=ob1; |
ob->ops[index].op=OP_NextBuffer; |
ob->ops[index+1].p=(void *)ob1; |
c->current_op_buffer=ob1; |
ob=ob1; |
index=0; |
} |
for(i=0;i<op_size;i++) { |
ob->ops[index]=p[i]; |
index++; |
} |
c->current_op_buffer_index=index; |
} |
void gl_add_op(GLParam *p) |
{ |
GLContext *c=gl_get_context(); |
int op; |
op=p[0].op; |
if (c->exec_flag) { |
op_table_func[op](c,p); |
} |
if (c->compile_flag) { |
gl_compile_op(c,p); |
} |
if (c->print_flag) { |
gl_print_op(stderr,p); |
} |
} |
/* this opcode is never called directly */ |
void glopEndList(GLContext *c,GLParam *p) |
{ |
assert(0); |
} |
/* this opcode is never called directly */ |
void glopNextBuffer(GLContext *c,GLParam *p) |
{ |
assert(0); |
} |
void glopCallList(GLContext *c,GLParam *p) |
{ |
GLList *l; |
int list,op; |
list=p[1].ui; |
l=find_list(c,list); |
if (l == NULL) gl_fatal_error("list %d not defined",list); |
p=l->first_op_buffer->ops; |
while (1) { |
op=p[0].op; |
if (op == OP_EndList) break; |
if (op == OP_NextBuffer) { |
p=(GLParam *)p[1].p; |
} else { |
op_table_func[op](c,p); |
p+=op_table_size[op]; |
} |
} |
} |
void glNewList(unsigned int list,int mode) |
{ |
GLList *l; |
GLContext *c=gl_get_context(); |
assert(mode == GL_COMPILE || mode == GL_COMPILE_AND_EXECUTE); |
assert(c->compile_flag == 0); |
l=find_list(c,list); |
if (l!=NULL) delete_list(c,list); |
l=alloc_list(c,list); |
c->current_op_buffer=l->first_op_buffer; |
c->current_op_buffer_index=0; |
c->compile_flag=1; |
c->exec_flag=(mode == GL_COMPILE_AND_EXECUTE); |
} |
void glEndList(void) |
{ |
GLContext *c=gl_get_context(); |
GLParam p[1]; |
assert(c->compile_flag == 1); |
/* end of list */ |
p[0].op=OP_EndList; |
gl_compile_op(c,p); |
c->compile_flag=0; |
c->exec_flag=1; |
} |
int glIsList(unsigned int list) |
{ |
GLContext *c=gl_get_context(); |
GLList *l; |
l=find_list(c,list); |
return (l != NULL); |
} |
unsigned int glGenLists(int range) |
{ |
GLContext *c=gl_get_context(); |
int count,i,list; |
GLList **lists; |
lists=c->shared_state.lists; |
count=0; |
for(i=0;i<MAX_DISPLAY_LISTS;i++) { |
if (lists[i]==NULL) { |
count++; |
if (count == range) { |
list=i-range+1; |
for(i=0;i<range;i++) { |
alloc_list(c,list+i); |
} |
return list; |
} |
} else { |
count=0; |
} |
} |
return 0; |
} |
/programs/develop/libraries/TinyGL/src/matrix.c |
---|
0,0 → 1,241 |
#include "zgl.h" |
void gl_print_matrix( const float *m) |
{ |
int i; |
for (i=0;i<4;i++) { |
fprintf(stderr,"%f %f %f %f\n", m[i], m[4+i], m[8+i], m[12+i] ); |
} |
} |
static inline void gl_matrix_update(GLContext *c) |
{ |
c->matrix_model_projection_updated=(c->matrix_mode<=1); |
} |
void glopMatrixMode(GLContext *c,GLParam *p) |
{ |
int mode=p[1].i; |
switch(mode) { |
case GL_MODELVIEW: |
c->matrix_mode=0; |
break; |
case GL_PROJECTION: |
c->matrix_mode=1; |
break; |
case GL_TEXTURE: |
c->matrix_mode=2; |
break; |
default: |
assert(0); |
} |
} |
void glopLoadMatrix(GLContext *c,GLParam *p) |
{ |
M4 *m; |
int i; |
GLParam *q; |
m=c->matrix_stack_ptr[c->matrix_mode]; |
q=p+1; |
for(i=0;i<4;i++) { |
m->m[0][i]=q[0].f; |
m->m[1][i]=q[1].f; |
m->m[2][i]=q[2].f; |
m->m[3][i]=q[3].f; |
q+=4; |
} |
gl_matrix_update(c); |
} |
void glopLoadIdentity(GLContext *c,GLParam *p) |
{ |
gl_M4_Id(c->matrix_stack_ptr[c->matrix_mode]); |
gl_matrix_update(c); |
} |
void glopMultMatrix(GLContext *c,GLParam *p) |
{ |
M4 m; |
int i; |
GLParam *q; |
q=p+1; |
for(i=0;i<4;i++) { |
m.m[0][i]=q[0].f; |
m.m[1][i]=q[1].f; |
m.m[2][i]=q[2].f; |
m.m[3][i]=q[3].f; |
q+=4; |
} |
gl_M4_MulLeft(c->matrix_stack_ptr[c->matrix_mode],&m); |
gl_matrix_update(c); |
} |
void glopPushMatrix(GLContext *c,GLParam *p) |
{ |
int n=c->matrix_mode; |
M4 *m; |
assert( (c->matrix_stack_ptr[n] - c->matrix_stack[n] + 1 ) |
< c->matrix_stack_depth_max[n] ); |
m=++c->matrix_stack_ptr[n]; |
gl_M4_Move(&m[0],&m[-1]); |
gl_matrix_update(c); |
} |
void glopPopMatrix(GLContext *c,GLParam *p) |
{ |
int n=c->matrix_mode; |
assert( c->matrix_stack_ptr[n] > c->matrix_stack[n] ); |
c->matrix_stack_ptr[n]--; |
gl_matrix_update(c); |
} |
void glopRotate(GLContext *c,GLParam *p) |
{ |
M4 m; |
float u[3]; |
float angle; |
int dir_code; |
angle = p[1].f * M_PI / 180.0; |
u[0]=p[2].f; |
u[1]=p[3].f; |
u[2]=p[4].f; |
/* simple case detection */ |
dir_code = ((u[0] != 0)<<2) | ((u[1] != 0)<<1) | (u[2] != 0); |
switch(dir_code) { |
case 0: |
gl_M4_Id(&m); |
break; |
case 4: |
if (u[0] < 0) angle=-angle; |
gl_M4_Rotate(&m,angle,0); |
break; |
case 2: |
if (u[1] < 0) angle=-angle; |
gl_M4_Rotate(&m,angle,1); |
break; |
case 1: |
if (u[2] < 0) angle=-angle; |
gl_M4_Rotate(&m,angle,2); |
break; |
default: |
{ |
float cost, sint; |
/* normalize vector */ |
float len = u[0]*u[0]+u[1]*u[1]+u[2]*u[2]; |
if (len == 0.0f) return; |
len = 1.0f / sqrt(len); |
u[0] *= len; |
u[1] *= len; |
u[2] *= len; |
/* store cos and sin values */ |
cost=cos(angle); |
sint=sin(angle); |
/* fill in the values */ |
m.m[3][0]=m.m[3][1]=m.m[3][2]= |
m.m[0][3]=m.m[1][3]=m.m[2][3]=0.0f; |
m.m[3][3]=1.0f; |
/* do the math */ |
m.m[0][0]=u[0]*u[0]+cost*(1-u[0]*u[0]); |
m.m[1][0]=u[0]*u[1]*(1-cost)-u[2]*sint; |
m.m[2][0]=u[2]*u[0]*(1-cost)+u[1]*sint; |
m.m[0][1]=u[0]*u[1]*(1-cost)+u[2]*sint; |
m.m[1][1]=u[1]*u[1]+cost*(1-u[1]*u[1]); |
m.m[2][1]=u[1]*u[2]*(1-cost)-u[0]*sint; |
m.m[0][2]=u[2]*u[0]*(1-cost)-u[1]*sint; |
m.m[1][2]=u[1]*u[2]*(1-cost)+u[0]*sint; |
m.m[2][2]=u[2]*u[2]+cost*(1-u[2]*u[2]); |
} |
} |
gl_M4_MulLeft(c->matrix_stack_ptr[c->matrix_mode],&m); |
gl_matrix_update(c); |
} |
void glopScale(GLContext *c,GLParam *p) |
{ |
float *m; |
float x=p[1].f,y=p[2].f,z=p[3].f; |
m=&c->matrix_stack_ptr[c->matrix_mode]->m[0][0]; |
m[0] *= x; m[1] *= y; m[2] *= z; |
m[4] *= x; m[5] *= y; m[6] *= z; |
m[8] *= x; m[9] *= y; m[10] *= z; |
m[12] *= x; m[13] *= y; m[14] *= z; |
gl_matrix_update(c); |
} |
void glopTranslate(GLContext *c,GLParam *p) |
{ |
float *m; |
float x=p[1].f,y=p[2].f,z=p[3].f; |
m=&c->matrix_stack_ptr[c->matrix_mode]->m[0][0]; |
m[3] = m[0] * x + m[1] * y + m[2] * z + m[3]; |
m[7] = m[4] * x + m[5] * y + m[6] * z + m[7]; |
m[11] = m[8] * x + m[9] * y + m[10] * z + m[11]; |
m[15] = m[12] * x + m[13] * y + m[14] * z + m[15]; |
gl_matrix_update(c); |
} |
void glopFrustum(GLContext *c,GLParam *p) |
{ |
float *r; |
M4 m; |
float left=p[1].f; |
float right=p[2].f; |
float bottom=p[3].f; |
float top=p[4].f; |
float near=p[5].f; |
float farp=p[6].f; |
float x,y,A,B,C,D; |
x = (2.0*near) / (right-left); |
y = (2.0*near) / (top-bottom); |
A = (right+left) / (right-left); |
B = (top+bottom) / (top-bottom); |
C = -(farp+near) / ( farp-near); |
D = -(2.0*farp*near) / (farp-near); |
r=&m.m[0][0]; |
r[0]= x; r[1]=0; r[2]=A; r[3]=0; |
r[4]= 0; r[5]=y; r[6]=B; r[7]=0; |
r[8]= 0; r[9]=0; r[10]=C; r[11]=D; |
r[12]= 0; r[13]=0; r[14]=-1; r[15]=0; |
gl_M4_MulLeft(c->matrix_stack_ptr[c->matrix_mode],&m); |
gl_matrix_update(c); |
} |
/programs/develop/libraries/TinyGL/src/misc.c |
---|
0,0 → 1,147 |
#include "zgl.h" |
#include "msghandling.h" |
void glopViewport(GLContext *c,GLParam *p) |
{ |
int xsize,ysize,xmin,ymin,xsize_req,ysize_req; |
xmin=p[1].i; |
ymin=p[2].i; |
xsize=p[3].i; |
ysize=p[4].i; |
/* we may need to resize the zbuffer */ |
if (c->viewport.xmin != xmin || |
c->viewport.ymin != ymin || |
c->viewport.xsize != xsize || |
c->viewport.ysize != ysize) { |
xsize_req=xmin+xsize; |
ysize_req=ymin+ysize; |
if (c->gl_resize_viewport && |
c->gl_resize_viewport(c,&xsize_req,&ysize_req) != 0) { |
gl_fatal_error("glViewport: error while resizing display"); |
} |
xsize=xsize_req-xmin; |
ysize=ysize_req-ymin; |
if (xsize <= 0 || ysize <= 0) { |
gl_fatal_error("glViewport: size too small"); |
} |
tgl_trace("glViewport: %d %d %d %d\n", |
xmin, ymin, xsize, ysize); |
c->viewport.xmin=xmin; |
c->viewport.ymin=ymin; |
c->viewport.xsize=xsize; |
c->viewport.ysize=ysize; |
c->viewport.updated=1; |
} |
} |
void glopEnableDisable(GLContext *c,GLParam *p) |
{ |
int code=p[1].i; |
int v=p[2].i; |
switch(code) { |
case GL_CULL_FACE: |
c->cull_face_enabled=v; |
break; |
case GL_LIGHTING: |
c->lighting_enabled=v; |
break; |
case GL_COLOR_MATERIAL: |
c->color_material_enabled=v; |
break; |
case GL_TEXTURE_2D: |
c->texture_2d_enabled=v; |
break; |
case GL_NORMALIZE: |
c->normalize_enabled=v; |
break; |
case GL_DEPTH_TEST: |
c->depth_test = v; |
break; |
case GL_POLYGON_OFFSET_FILL: |
if (v) c->offset_states |= TGL_OFFSET_FILL; |
else c->offset_states &= ~TGL_OFFSET_FILL; |
break; |
case GL_POLYGON_OFFSET_POINT: |
if (v) c->offset_states |= TGL_OFFSET_POINT; |
else c->offset_states &= ~TGL_OFFSET_POINT; |
break; |
case GL_POLYGON_OFFSET_LINE: |
if (v) c->offset_states |= TGL_OFFSET_LINE; |
else c->offset_states &= ~TGL_OFFSET_LINE; |
break; |
default: |
if (code>=GL_LIGHT0 && code<GL_LIGHT0+MAX_LIGHTS) { |
gl_enable_disable_light(c,code - GL_LIGHT0, v); |
} else { |
/* |
fprintf(stderr,"glEnableDisable: 0x%X not supported.\n",code); |
*/ |
} |
break; |
} |
} |
void glopShadeModel(GLContext *c,GLParam *p) |
{ |
int code=p[1].i; |
c->current_shade_model=code; |
} |
void glopCullFace(GLContext *c,GLParam *p) |
{ |
int code=p[1].i; |
c->current_cull_face=code; |
} |
void glopFrontFace(GLContext *c,GLParam *p) |
{ |
int code=p[1].i; |
c->current_front_face=code; |
} |
void glopPolygonMode(GLContext *c,GLParam *p) |
{ |
int face=p[1].i; |
int mode=p[2].i; |
switch(face) { |
case GL_BACK: |
c->polygon_mode_back=mode; |
break; |
case GL_FRONT: |
c->polygon_mode_front=mode; |
break; |
case GL_FRONT_AND_BACK: |
c->polygon_mode_front=mode; |
c->polygon_mode_back=mode; |
break; |
default: |
assert(0); |
} |
} |
void glopHint(GLContext *c,GLParam *p) |
{ |
#if 0 |
int target=p[1].i; |
int mode=p[2].i; |
/* do nothing */ |
#endif |
} |
void |
glopPolygonOffset(GLContext *c, GLParam *p) |
{ |
c->offset_factor = p[1].f; |
c->offset_units = p[2].f; |
} |
/programs/develop/libraries/TinyGL/src/msghandling.c |
---|
0,0 → 1,52 |
#include <stdarg.h> |
#include <stdio.h> |
#define NDEBUG |
#ifdef NDEBUG |
#define NO_DEBUG_OUTPUT |
#endif |
/* Use this function to output messages when something unexpected |
happens (which might be an indication of an error). *Don't* use it |
when there's internal errors in the code - these should be handled |
by asserts. */ |
void |
tgl_warning(const char *format, ...) |
{ |
#ifndef NO_DEBUG_OUTPUT |
va_list args; |
va_start(args, format); |
fprintf(stderr, "*WARNING* "); |
vfprintf(stderr, format, args); |
va_end(args); |
#endif /* !NO_DEBUG_OUTPUT */ |
} |
/* This function should be used for debug output only. */ |
void |
tgl_trace(const char *format, ...) |
{ |
#ifndef NO_DEBUG_OUTPUT |
va_list args; |
va_start(args, format); |
fprintf(stderr, "*DEBUG* "); |
vfprintf(stderr, format, args); |
va_end(args); |
#endif /* !NO_DEBUG_OUTPUT */ |
} |
/* Use this function to output info about things in the code which |
should be fixed (missing handling of special cases, important |
features not implemented, known bugs/buglets, ...). */ |
void |
tgl_fixme(const char *format, ...) |
{ |
#ifndef NO_DEBUG_OUTPUT |
va_list args; |
va_start(args, format); |
fprintf(stderr, "*FIXME* "); |
vfprintf(stderr, format, args); |
va_end(args); |
#endif /* !NO_DEBUG_OUTPUT */ |
} |
/programs/develop/libraries/TinyGL/src/msghandling.h |
---|
0,0 → 1,8 |
#ifndef _msghandling_h_ |
#define _msghandling_h_ |
extern void tgl_warning(const char *text, ...); |
extern void tgl_trace(const char *text, ...); |
extern void tgl_fixme(const char *text, ...); |
#endif /* _msghandling_h_ */ |
/programs/develop/libraries/TinyGL/src/opinfo.h |
---|
0,0 → 1,71 |
ADD_OP(Color,7,"%f %f %f %f %d %d %d") |
ADD_OP(TexCoord,4,"%f %f %f %f") |
ADD_OP(EdgeFlag,1,"%d") |
ADD_OP(Normal,3,"%f %f %f") |
ADD_OP(Begin,1,"%C") |
ADD_OP(Vertex,4,"%f %f %f %f") |
ADD_OP(End,0,"") |
ADD_OP(EnableDisable,2,"%C %d") |
ADD_OP(MatrixMode,1,"%C") |
ADD_OP(LoadMatrix,16,"") |
ADD_OP(LoadIdentity,0,"") |
ADD_OP(MultMatrix,16,"") |
ADD_OP(PushMatrix,0,"") |
ADD_OP(PopMatrix,0,"") |
ADD_OP(Rotate,4,"%f %f %f %f") |
ADD_OP(Translate,3,"%f %f %f") |
ADD_OP(Scale,3,"%f %f %f") |
ADD_OP(Viewport,4,"%d %d %d %d") |
ADD_OP(Frustum,6,"%f %f %f %f %f %f") |
ADD_OP(Material,6,"%C %C %f %f %f %f") |
ADD_OP(ColorMaterial,2,"%C %C") |
ADD_OP(Light,6,"%C %C %f %f %f %f") |
ADD_OP(LightModel,5,"%C %f %f %f %f") |
ADD_OP(Clear,1,"%d") |
ADD_OP(ClearColor,4,"%f %f %f %f") |
ADD_OP(ClearDepth,1,"%f") |
ADD_OP(InitNames,0,"") |
ADD_OP(PushName,1,"%d") |
ADD_OP(PopName,0,"") |
ADD_OP(LoadName,1,"%d") |
ADD_OP(TexImage2D,9,"%d %d %d %d %d %d %d %d %d") |
ADD_OP(BindTexture,2,"%C %d") |
ADD_OP(TexEnv,7,"%C %C %C %f %f %f %f") |
ADD_OP(TexParameter,7,"%C %C %C %f %f %f %f") |
ADD_OP(PixelStore,2,"%C %C") |
ADD_OP(ShadeModel,1,"%C") |
ADD_OP(CullFace,1,"%C") |
ADD_OP(FrontFace,1,"%C") |
ADD_OP(PolygonMode,2,"%C %C") |
ADD_OP(CallList,1,"%d") |
ADD_OP(Hint,2,"%C %C") |
/* special opcodes */ |
ADD_OP(EndList,0,"") |
ADD_OP(NextBuffer,1,"%p") |
/* opengl 1.1 arrays */ |
ADD_OP(ArrayElement, 1, "%d") |
ADD_OP(EnableClientState, 1, "%C") |
ADD_OP(DisableClientState, 1, "%C") |
ADD_OP(VertexPointer, 4, "%d %C %d %p") |
ADD_OP(ColorPointer, 4, "%d %C %d %p") |
ADD_OP(NormalPointer, 3, "%C %d %p") |
ADD_OP(TexCoordPointer, 4, "%d %C %d %p") |
/* opengl 1.1 polygon offset */ |
ADD_OP(PolygonOffset, 2, "%f %f") |
#undef ADD_OP |
/programs/develop/libraries/TinyGL/src/select.c |
---|
0,0 → 1,114 |
#include "zgl.h" |
int glRenderMode(int mode) |
{ |
GLContext *c=gl_get_context(); |
int result=0; |
switch(c->render_mode) { |
case GL_RENDER: |
break; |
case GL_SELECT: |
if (c->select_overflow) { |
result=-c->select_hits; |
} else { |
result=c->select_hits; |
} |
c->select_overflow=0; |
c->select_ptr=c->select_buffer; |
c->name_stack_size=0; |
break; |
default: |
assert(0); |
} |
switch(mode) { |
case GL_RENDER: |
c->render_mode=GL_RENDER; |
break; |
case GL_SELECT: |
c->render_mode=GL_SELECT; |
assert( c->select_buffer != NULL); |
c->select_ptr=c->select_buffer; |
c->select_hits=0; |
c->select_overflow=0; |
c->select_hit=NULL; |
break; |
default: |
assert(0); |
} |
return result; |
} |
void glSelectBuffer(int size,unsigned int *buf) |
{ |
GLContext *c=gl_get_context(); |
assert(c->render_mode != GL_SELECT); |
c->select_buffer=buf; |
c->select_size=size; |
} |
void glopInitNames(GLContext *c,GLParam *p) |
{ |
if (c->render_mode == GL_SELECT) { |
c->name_stack_size=0; |
c->select_hit=NULL; |
} |
} |
void glopPushName(GLContext *c,GLParam *p) |
{ |
if (c->render_mode == GL_SELECT) { |
assert(c->name_stack_size<MAX_NAME_STACK_DEPTH); |
c->name_stack[c->name_stack_size++]=p[1].i; |
c->select_hit=NULL; |
} |
} |
void glopPopName(GLContext *c,GLParam *p) |
{ |
if (c->render_mode == GL_SELECT) { |
assert(c->name_stack_size>0); |
c->name_stack_size--; |
c->select_hit=NULL; |
} |
} |
void glopLoadName(GLContext *c,GLParam *p) |
{ |
if (c->render_mode == GL_SELECT) { |
assert(c->name_stack_size>0); |
c->name_stack[c->name_stack_size-1]=p[1].i; |
c->select_hit=NULL; |
} |
} |
void gl_add_select(GLContext *c,unsigned int zmin,unsigned int zmax) |
{ |
unsigned int *ptr; |
int n,i; |
if (!c->select_overflow) { |
if (c->select_hit==NULL) { |
n=c->name_stack_size; |
if ((c->select_ptr-c->select_buffer+3+n) > |
c->select_size) { |
c->select_overflow=1; |
} else { |
ptr=c->select_ptr; |
c->select_hit=ptr; |
*ptr++=c->name_stack_size; |
*ptr++=zmin; |
*ptr++=zmax; |
for(i=0;i<n;i++) *ptr++=c->name_stack[i]; |
c->select_ptr=ptr; |
c->select_hits++; |
} |
} else { |
if (zmin<c->select_hit[1]) c->select_hit[1]=zmin; |
if (zmax>c->select_hit[2]) c->select_hit[2]=zmax; |
} |
} |
} |
/programs/develop/libraries/TinyGL/src/specbuf.c |
---|
0,0 → 1,52 |
#include "zgl.h" |
#include "msghandling.h" |
#include <math.h> |
#include <stdlib.h> |
static void calc_buf(GLSpecBuf *buf, const float shininess) |
{ |
int i; |
float val, inc; |
val = 0.0f; |
inc = 1.0f/SPECULAR_BUFFER_SIZE; |
for (i = 0; i <= SPECULAR_BUFFER_SIZE; i++) { |
buf->buf[i] = pow(val, shininess); |
val += inc; |
} |
} |
GLSpecBuf * |
specbuf_get_buffer(GLContext *c, const int shininess_i, |
const float shininess) |
{ |
GLSpecBuf *found, *oldest; |
found = oldest = c->specbuf_first; |
while (found && found->shininess_i != shininess_i) { |
if (found->last_used < oldest->last_used) { |
oldest = found; |
} |
found = found->next; |
} |
if (found) { /* hey, found one! */ |
found->last_used = c->specbuf_used_counter++; |
return found; |
} |
if (oldest == NULL || c->specbuf_num_buffers < MAX_SPECULAR_BUFFERS) { |
/* create new buffer */ |
GLSpecBuf *buf = gl_malloc(sizeof(GLSpecBuf)); |
if (!buf) gl_fatal_error("could not allocate specular buffer"); |
c->specbuf_num_buffers++; |
buf->next = c->specbuf_first; |
c->specbuf_first = buf; |
buf->last_used = c->specbuf_used_counter++; |
buf->shininess_i = shininess_i; |
calc_buf(buf, shininess); |
return buf; |
} |
/* overwrite the lru buffer */ |
/*tgl_trace("overwriting spec buffer :(\n");*/ |
oldest->shininess_i = shininess_i; |
oldest->last_used = c->specbuf_used_counter++; |
calc_buf(oldest, shininess); |
return oldest; |
} |
/programs/develop/libraries/TinyGL/src/specbuf.h |
---|
0,0 → 1,22 |
#ifndef _tgl_specbuf_h_ |
#define _tgl_specbuf_h_ |
/* Max # of specular light pow buffers */ |
#define MAX_SPECULAR_BUFFERS 8 |
/* # of entries in specular buffer */ |
#define SPECULAR_BUFFER_SIZE 1024 |
/* specular buffer granularity */ |
#define SPECULAR_BUFFER_RESOLUTION 1024 |
typedef struct GLSpecBuf { |
int shininess_i; |
int last_used; |
float buf[SPECULAR_BUFFER_SIZE+1]; |
struct GLSpecBuf *next; |
} GLSpecBuf; |
GLSpecBuf *specbuf_get_buffer(GLContext *c, const int shininess_i, |
const float shininess); |
void specbuf_cleanup(GLContext *c); /* free all memory used */ |
#endif /* _tgl_specbuf_h_ */ |
/programs/develop/libraries/TinyGL/src/texture.c |
---|
0,0 → 1,229 |
/* |
* Texture Manager |
*/ |
#include "zgl.h" |
static GLTexture *find_texture(GLContext *c,int h) |
{ |
GLTexture *t; |
t=c->shared_state.texture_hash_table[h % TEXTURE_HASH_TABLE_SIZE]; |
while (t!=NULL) { |
if (t->handle == h) return t; |
t=t->next; |
} |
return NULL; |
} |
static void free_texture(GLContext *c,int h) |
{ |
GLTexture *t,**ht; |
GLImage *im; |
int i; |
t=find_texture(c,h); |
if (t->prev==NULL) { |
ht=&c->shared_state.texture_hash_table |
[t->handle % TEXTURE_HASH_TABLE_SIZE]; |
*ht=t->next; |
} else { |
t->prev->next=t->next; |
} |
if (t->next!=NULL) t->next->prev=t->prev; |
for(i=0;i<MAX_TEXTURE_LEVELS;i++) { |
im=&t->images[i]; |
if (im->pixmap != NULL) gl_free(im->pixmap); |
} |
gl_free(t); |
} |
GLTexture *alloc_texture(GLContext *c,int h) |
{ |
GLTexture *t,**ht; |
t=gl_zalloc(sizeof(GLTexture)); |
ht=&c->shared_state.texture_hash_table[h % TEXTURE_HASH_TABLE_SIZE]; |
t->next=*ht; |
t->prev=NULL; |
if (t->next != NULL) t->next->prev=t; |
*ht=t; |
t->handle=h; |
return t; |
} |
void glInitTextures(GLContext *c) |
{ |
/* textures */ |
c->texture_2d_enabled=0; |
c->current_texture=find_texture(c,0); |
} |
void glGenTextures(int n, unsigned int *textures) |
{ |
GLContext *c=gl_get_context(); |
int max,i; |
GLTexture *t; |
max=0; |
for(i=0;i<TEXTURE_HASH_TABLE_SIZE;i++) { |
t=c->shared_state.texture_hash_table[i]; |
while (t!=NULL) { |
if (t->handle>max) max=t->handle; |
t=t->next; |
} |
} |
for(i=0;i<n;i++) { |
textures[i]=max+i+1; |
} |
} |
void glDeleteTextures(int n, const unsigned int *textures) |
{ |
GLContext *c=gl_get_context(); |
int i; |
GLTexture *t; |
for(i=0;i<n;i++) { |
t=find_texture(c,textures[i]); |
if (t!=NULL && t!=0) { |
if (t==c->current_texture) { |
glBindTexture(GL_TEXTURE_2D,0); |
} |
free_texture(c,textures[i]); |
} |
} |
} |
void glopBindTexture(GLContext *c,GLParam *p) |
{ |
int target=p[1].i; |
int texture=p[2].i; |
GLTexture *t; |
assert(target == GL_TEXTURE_2D && texture >= 0); |
t=find_texture(c,texture); |
if (t==NULL) { |
t=alloc_texture(c,texture); |
} |
c->current_texture=t; |
} |
void glopTexImage2D(GLContext *c,GLParam *p) |
{ |
int target=p[1].i; |
int level=p[2].i; |
int components=p[3].i; |
int width=p[4].i; |
int height=p[5].i; |
int border=p[6].i; |
int format=p[7].i; |
int type=p[8].i; |
void *pixels=p[9].p; |
GLImage *im; |
unsigned char *pixels1; |
int do_free; |
if (!(target == GL_TEXTURE_2D && level == 0 && components == 3 && |
border == 0 && format == GL_RGB && |
type == GL_UNSIGNED_BYTE)) { |
gl_fatal_error("glTexImage2D: combinaison of parameters not handled"); |
} |
do_free=0; |
if (width != 256 || height != 256) { |
pixels1 = gl_malloc(256 * 256 * 3); |
/* no interpolation is done here to respect the original image aliasing ! */ |
gl_resizeImageNoInterpolate(pixels1,256,256,pixels,width,height); |
do_free=1; |
width=256; |
height=256; |
} else { |
pixels1=pixels; |
} |
im=&c->current_texture->images[level]; |
im->xsize=width; |
im->ysize=height; |
if (im->pixmap!=NULL) gl_free(im->pixmap); |
#if TGL_FEATURE_RENDER_BITS == 24 |
im->pixmap=gl_malloc(width*height*3); |
if(im->pixmap) { |
memcpy(im->pixmap,pixels1,width*height*3); |
} |
#elif TGL_FEATURE_RENDER_BITS == 32 |
im->pixmap=gl_malloc(width*height*4); |
if(im->pixmap) { |
gl_convertRGB_to_8A8R8G8B(im->pixmap,pixels1,width,height); |
} |
#elif TGL_FEATURE_RENDER_BITS == 16 |
im->pixmap=gl_malloc(width*height*2); |
if(im->pixmap) { |
gl_convertRGB_to_5R6G5B(im->pixmap,pixels1,width,height); |
} |
#else |
#error TODO |
#endif |
if (do_free) gl_free(pixels1); |
} |
/* TODO: not all tests are done */ |
void glopTexEnv(GLContext *c,GLParam *p) |
{ |
int target=p[1].i; |
int pname=p[2].i; |
int param=p[3].i; |
if (target != GL_TEXTURE_ENV) { |
error: |
gl_fatal_error("glTexParameter: unsupported option"); |
} |
if (pname != GL_TEXTURE_ENV_MODE) goto error; |
if (param != GL_DECAL) goto error; |
} |
/* TODO: not all tests are done */ |
void glopTexParameter(GLContext *c,GLParam *p) |
{ |
int target=p[1].i; |
int pname=p[2].i; |
int param=p[3].i; |
if (target != GL_TEXTURE_2D) { |
error: |
gl_fatal_error("glTexParameter: unsupported option"); |
} |
switch(pname) { |
case GL_TEXTURE_WRAP_S: |
case GL_TEXTURE_WRAP_T: |
if (param != GL_REPEAT) goto error; |
break; |
} |
} |
void glopPixelStore(GLContext *c,GLParam *p) |
{ |
int pname=p[1].i; |
int param=p[2].i; |
if (pname != GL_UNPACK_ALIGNMENT || |
param != 1) { |
gl_fatal_error("glPixelStore: unsupported option"); |
} |
} |
/programs/develop/libraries/TinyGL/src/vertex.c |
---|
0,0 → 1,364 |
#include "zgl.h" |
void glopNormal(GLContext * c, GLParam * p) |
{ |
V3 v; |
v.X = p[1].f; |
v.Y = p[2].f; |
v.Z = p[3].f; |
c->current_normal.X = v.X; |
c->current_normal.Y = v.Y; |
c->current_normal.Z = v.Z; |
c->current_normal.W = 0; |
} |
void glopTexCoord(GLContext * c, GLParam * p) |
{ |
c->current_tex_coord.X = p[1].f; |
c->current_tex_coord.Y = p[2].f; |
c->current_tex_coord.Z = p[3].f; |
c->current_tex_coord.W = p[4].f; |
} |
void glopEdgeFlag(GLContext * c, GLParam * p) |
{ |
c->current_edge_flag = p[1].i; |
} |
void glopColor(GLContext * c, GLParam * p) |
{ |
c->current_color.X = p[1].f; |
c->current_color.Y = p[2].f; |
c->current_color.Z = p[3].f; |
c->current_color.W = p[4].f; |
c->longcurrent_color[0] = p[5].ui; |
c->longcurrent_color[1] = p[6].ui; |
c->longcurrent_color[2] = p[7].ui; |
if (c->color_material_enabled) { |
GLParam q[7]; |
q[0].op = OP_Material; |
q[1].i = c->current_color_material_mode; |
q[2].i = c->current_color_material_type; |
q[3].f = p[1].f; |
q[4].f = p[2].f; |
q[5].f = p[3].f; |
q[6].f = p[4].f; |
glopMaterial(c, q); |
} |
} |
void gl_eval_viewport(GLContext * c) |
{ |
GLViewport *v; |
float zsize = (1 << (ZB_Z_BITS + ZB_POINT_Z_FRAC_BITS)); |
v = &c->viewport; |
v->trans.X = ((v->xsize - 0.5) / 2.0) + v->xmin; |
v->trans.Y = ((v->ysize - 0.5) / 2.0) + v->ymin; |
v->trans.Z = ((zsize - 0.5) / 2.0) + ((1 << ZB_POINT_Z_FRAC_BITS)) / 2; |
v->scale.X = (v->xsize - 0.5) / 2.0; |
v->scale.Y = -(v->ysize - 0.5) / 2.0; |
v->scale.Z = -((zsize - 0.5) / 2.0); |
} |
void glopBegin(GLContext * c, GLParam * p) |
{ |
int type; |
M4 tmp; |
assert(c->in_begin == 0); |
type = p[1].i; |
c->begin_type = type; |
c->in_begin = 1; |
c->vertex_n = 0; |
c->vertex_cnt = 0; |
if (c->matrix_model_projection_updated) { |
if (c->lighting_enabled) { |
/* precompute inverse modelview */ |
gl_M4_Inv(&tmp, c->matrix_stack_ptr[0]); |
gl_M4_Transpose(&c->matrix_model_view_inv, &tmp); |
} else { |
float *m = &c->matrix_model_projection.m[0][0]; |
/* precompute projection matrix */ |
gl_M4_Mul(&c->matrix_model_projection, |
c->matrix_stack_ptr[1], |
c->matrix_stack_ptr[0]); |
/* test to accelerate computation */ |
c->matrix_model_projection_no_w_transform = 0; |
if (m[12] == 0.0 && m[13] == 0.0 && m[14] == 0.0) |
c->matrix_model_projection_no_w_transform = 1; |
} |
/* test if the texture matrix is not Identity */ |
c->apply_texture_matrix = !gl_M4_IsId(c->matrix_stack_ptr[2]); |
c->matrix_model_projection_updated = 0; |
} |
/* viewport */ |
if (c->viewport.updated) { |
gl_eval_viewport(c); |
c->viewport.updated = 0; |
} |
/* triangle drawing functions */ |
if (c->render_mode == GL_SELECT) { |
c->draw_triangle_front = gl_draw_triangle_select; |
c->draw_triangle_back = gl_draw_triangle_select; |
} else { |
switch (c->polygon_mode_front) { |
case GL_POINT: |
c->draw_triangle_front = gl_draw_triangle_point; |
break; |
case GL_LINE: |
c->draw_triangle_front = gl_draw_triangle_line; |
break; |
default: |
c->draw_triangle_front = gl_draw_triangle_fill; |
break; |
} |
switch (c->polygon_mode_back) { |
case GL_POINT: |
c->draw_triangle_back = gl_draw_triangle_point; |
break; |
case GL_LINE: |
c->draw_triangle_back = gl_draw_triangle_line; |
break; |
default: |
c->draw_triangle_back = gl_draw_triangle_fill; |
break; |
} |
} |
} |
/* coords, tranformation , clip code and projection */ |
/* TODO : handle all cases */ |
static inline void gl_vertex_transform(GLContext * c, GLVertex * v) |
{ |
float *m; |
V4 *n; |
if (c->lighting_enabled) { |
/* eye coordinates needed for lighting */ |
m = &c->matrix_stack_ptr[0]->m[0][0]; |
v->ec.X = (v->coord.X * m[0] + v->coord.Y * m[1] + |
v->coord.Z * m[2] + m[3]); |
v->ec.Y = (v->coord.X * m[4] + v->coord.Y * m[5] + |
v->coord.Z * m[6] + m[7]); |
v->ec.Z = (v->coord.X * m[8] + v->coord.Y * m[9] + |
v->coord.Z * m[10] + m[11]); |
v->ec.W = (v->coord.X * m[12] + v->coord.Y * m[13] + |
v->coord.Z * m[14] + m[15]); |
/* projection coordinates */ |
m = &c->matrix_stack_ptr[1]->m[0][0]; |
v->pc.X = (v->ec.X * m[0] + v->ec.Y * m[1] + |
v->ec.Z * m[2] + v->ec.W * m[3]); |
v->pc.Y = (v->ec.X * m[4] + v->ec.Y * m[5] + |
v->ec.Z * m[6] + v->ec.W * m[7]); |
v->pc.Z = (v->ec.X * m[8] + v->ec.Y * m[9] + |
v->ec.Z * m[10] + v->ec.W * m[11]); |
v->pc.W = (v->ec.X * m[12] + v->ec.Y * m[13] + |
v->ec.Z * m[14] + v->ec.W * m[15]); |
m = &c->matrix_model_view_inv.m[0][0]; |
n = &c->current_normal; |
v->normal.X = (n->X * m[0] + n->Y * m[1] + n->Z * m[2]); |
v->normal.Y = (n->X * m[4] + n->Y * m[5] + n->Z * m[6]); |
v->normal.Z = (n->X * m[8] + n->Y * m[9] + n->Z * m[10]); |
if (c->normalize_enabled) { |
gl_V3_Norm(&v->normal); |
} |
} else { |
/* no eye coordinates needed, no normal */ |
/* NOTE: W = 1 is assumed */ |
m = &c->matrix_model_projection.m[0][0]; |
v->pc.X = (v->coord.X * m[0] + v->coord.Y * m[1] + |
v->coord.Z * m[2] + m[3]); |
v->pc.Y = (v->coord.X * m[4] + v->coord.Y * m[5] + |
v->coord.Z * m[6] + m[7]); |
v->pc.Z = (v->coord.X * m[8] + v->coord.Y * m[9] + |
v->coord.Z * m[10] + m[11]); |
if (c->matrix_model_projection_no_w_transform) { |
v->pc.W = m[15]; |
} else { |
v->pc.W = (v->coord.X * m[12] + v->coord.Y * m[13] + |
v->coord.Z * m[14] + m[15]); |
} |
} |
v->clip_code = gl_clipcode(v->pc.X, v->pc.Y, v->pc.Z, v->pc.W); |
} |
void glopVertex(GLContext * c, GLParam * p) |
{ |
GLVertex *v; |
int n, i, cnt; |
assert(c->in_begin != 0); |
n = c->vertex_n; |
cnt = c->vertex_cnt; |
cnt++; |
c->vertex_cnt = cnt; |
/* quick fix to avoid crashes on large polygons */ |
if (n >= c->vertex_max) { |
GLVertex *newarray; |
c->vertex_max <<= 1; /* just double size */ |
newarray = gl_malloc(sizeof(GLVertex) * c->vertex_max); |
if (!newarray) { |
gl_fatal_error("unable to allocate GLVertex array.\n"); |
} |
memcpy(newarray, c->vertex, n * sizeof(GLVertex)); |
gl_free(c->vertex); |
c->vertex = newarray; |
} |
/* new vertex entry */ |
v = &c->vertex[n]; |
n++; |
v->coord.X = p[1].f; |
v->coord.Y = p[2].f; |
v->coord.Z = p[3].f; |
v->coord.W = p[4].f; |
gl_vertex_transform(c, v); |
/* color */ |
if (c->lighting_enabled) { |
gl_shade_vertex(c, v); |
} else { |
v->color = c->current_color; |
} |
/* tex coords */ |
if (c->texture_2d_enabled) { |
if (c->apply_texture_matrix) { |
gl_M4_MulV4(&v->tex_coord, c->matrix_stack_ptr[2], &c->current_tex_coord); |
} else { |
v->tex_coord = c->current_tex_coord; |
} |
} |
/* precompute the mapping to the viewport */ |
if (v->clip_code == 0) |
gl_transform_to_viewport(c, v); |
/* edge flag */ |
v->edge_flag = c->current_edge_flag; |
switch (c->begin_type) { |
case GL_POINTS: |
gl_draw_point(c, &c->vertex[0]); |
n = 0; |
break; |
case GL_LINES: |
if (n == 2) { |
gl_draw_line(c, &c->vertex[0], &c->vertex[1]); |
n = 0; |
} |
break; |
case GL_LINE_STRIP: |
case GL_LINE_LOOP: |
if (n == 1) { |
c->vertex[2] = c->vertex[0]; |
} else if (n == 2) { |
gl_draw_line(c, &c->vertex[0], &c->vertex[1]); |
c->vertex[0] = c->vertex[1]; |
n = 1; |
} |
break; |
case GL_TRIANGLES: |
if (n == 3) { |
gl_draw_triangle(c, &c->vertex[0], &c->vertex[1], &c->vertex[2]); |
n = 0; |
} |
break; |
case GL_TRIANGLE_STRIP: |
if (cnt >= 3) { |
if (n == 3) |
n = 0; |
/* needed to respect triangle orientation */ |
switch(cnt & 1) { |
case 0: |
gl_draw_triangle(c,&c->vertex[2],&c->vertex[1],&c->vertex[0]); |
break; |
default: |
case 1: |
gl_draw_triangle(c,&c->vertex[0],&c->vertex[1],&c->vertex[2]); |
break; |
} |
} |
break; |
case GL_TRIANGLE_FAN: |
if (n == 3) { |
gl_draw_triangle(c, &c->vertex[0], &c->vertex[1], &c->vertex[2]); |
c->vertex[1] = c->vertex[2]; |
n = 2; |
} |
break; |
case GL_QUADS: |
if (n == 4) { |
c->vertex[2].edge_flag = 0; |
gl_draw_triangle(c, &c->vertex[0], &c->vertex[1], &c->vertex[2]); |
c->vertex[2].edge_flag = 1; |
c->vertex[0].edge_flag = 0; |
gl_draw_triangle(c, &c->vertex[0], &c->vertex[2], &c->vertex[3]); |
n = 0; |
} |
break; |
case GL_QUAD_STRIP: |
if (n == 4) { |
gl_draw_triangle(c, &c->vertex[0], &c->vertex[1], &c->vertex[2]); |
gl_draw_triangle(c, &c->vertex[1], &c->vertex[3], &c->vertex[2]); |
for (i = 0; i < 2; i++) |
c->vertex[i] = c->vertex[i + 2]; |
n = 2; |
} |
break; |
case GL_POLYGON: |
break; |
default: |
gl_fatal_error("glBegin: type %x not handled\n", c->begin_type); |
} |
c->vertex_n = n; |
} |
void glopEnd(GLContext * c, GLParam * param) |
{ |
assert(c->in_begin == 1); |
if (c->begin_type == GL_LINE_LOOP) { |
if (c->vertex_cnt >= 3) { |
gl_draw_line(c, &c->vertex[0], &c->vertex[2]); |
} |
} else if (c->begin_type == GL_POLYGON) { |
int i = c->vertex_cnt; |
while (i >= 3) { |
i--; |
gl_draw_triangle(c, &c->vertex[i], &c->vertex[0], &c->vertex[i - 1]); |
} |
} |
c->in_begin = 0; |
} |
/programs/develop/libraries/TinyGL/src/zbuffer.c |
---|
0,0 → 1,509 |
/* |
* Z buffer: 16 bits Z / 16 bits color |
* |
*/ |
#include <stdlib.h> |
#include <stdio.h> |
/*#include <assert.h>*/ |
#include <string.h> |
#include "zbuffer.h" |
ZBuffer *ZB_open(int xsize, int ysize, int mode, |
int nb_colors, |
unsigned char *color_indexes, |
int *color_table, |
void *frame_buffer) |
{ |
ZBuffer *zb; |
int size; |
zb = gl_malloc(sizeof(ZBuffer)); |
if (zb == NULL) |
return NULL; |
zb->xsize = xsize; |
zb->ysize = ysize; |
zb->mode = mode; |
zb->linesize = (xsize * PSZB + 3) & ~3; |
switch (mode) { |
#ifdef TGL_FEATURE_8_BITS |
case ZB_MODE_INDEX: |
ZB_initDither(zb, nb_colors, color_indexes, color_table); |
break; |
#endif |
#ifdef TGL_FEATURE_32_BITS |
case ZB_MODE_RGBA: |
#endif |
#ifdef TGL_FEATURE_24_BITS |
case ZB_MODE_RGB24: |
#endif |
case ZB_MODE_5R6G5B: |
zb->nb_colors = 0; |
break; |
default: |
goto error; |
} |
size = zb->xsize * zb->ysize * sizeof(unsigned short); |
zb->zbuf = gl_malloc(size); |
if (zb->zbuf == NULL) |
goto error; |
zb->frame_buffer_allocated = 0; |
zb->pbuf = NULL; |
zb->current_texture = NULL; |
return zb; |
error: |
gl_free(zb); |
return NULL; |
} |
void ZB_close(ZBuffer * zb) |
{ |
#ifdef TGL_FEATURE_8_BITS |
if (zb->mode == ZB_MODE_INDEX) |
ZB_closeDither(zb); |
#endif |
if (zb->frame_buffer_allocated) |
gl_free(zb->pbuf); |
gl_free(zb->zbuf); |
gl_free(zb); |
} |
void ZB_resize(ZBuffer * zb, void *frame_buffer, int xsize, int ysize) |
{ |
int size; |
/* xsize must be a multiple of 4 */ |
xsize = xsize & ~3; |
zb->xsize = xsize; |
zb->ysize = ysize; |
zb->linesize = (xsize * PSZB + 3) & ~3; |
size = zb->xsize * zb->ysize * sizeof(unsigned short); |
gl_free(zb->zbuf); |
zb->zbuf = gl_malloc(size); |
if (zb->frame_buffer_allocated) |
gl_free(zb->pbuf); |
if (frame_buffer == NULL) { |
zb->pbuf = gl_malloc((zb->ysize+1) * (zb->linesize)); |
zb->frame_buffer_allocated = 1; |
} else { |
zb->pbuf = frame_buffer; |
zb->frame_buffer_allocated = 0; |
} |
} |
static void ZB_copyBuffer(ZBuffer * zb, |
void *buf, |
int linesize) |
{ |
unsigned char *p1; |
PIXEL *q; |
int y, n; |
q = zb->pbuf; |
p1 = buf; |
n = zb->xsize * PSZB; |
for (y = 0; y < zb->ysize; y++) { |
memcpy(p1, q, n); |
p1 += linesize; |
q = (PIXEL *) ((char *) q + zb->linesize); |
} |
} |
#if TGL_FEATURE_RENDER_BITS == 16 |
/* 32 bpp copy */ |
#ifdef TGL_FEATURE_32_BITS |
#define RGB16_TO_RGB32(p0,p1,v)\ |
{\ |
unsigned int g,b,gb;\ |
g = (v & 0x07E007E0) << 5;\ |
b = (v & 0x001F001F) << 3;\ |
gb = g | b;\ |
p0 = (gb & 0x0000FFFF) | ((v & 0x0000F800) << 8);\ |
p1 = (gb >> 16) | ((v & 0xF8000000) >> 8);\ |
} |
static void ZB_copyFrameBufferRGB32(ZBuffer * zb, |
void *buf, |
int linesize) |
{ |
unsigned short *q; |
unsigned int *p, *p1, v, w0, w1; |
int y, n; |
q = zb->pbuf; |
p1 = (unsigned int *) buf; |
for (y = 0; y < zb->ysize; y++) { |
p = p1; |
n = zb->xsize >> 2; |
do { |
v = *(unsigned int *) q; |
#if BYTE_ORDER == BIG_ENDIAN |
RGB16_TO_RGB32(w1, w0, v); |
#else |
RGB16_TO_RGB32(w0, w1, v); |
#endif |
p[0] = w0; |
p[1] = w1; |
v = *(unsigned int *) (q + 2); |
#if BYTE_ORDER == BIG_ENDIAN |
RGB16_TO_RGB32(w1, w0, v); |
#else |
RGB16_TO_RGB32(w0, w1, v); |
#endif |
p[2] = w0; |
p[3] = w1; |
q += 4; |
p += 4; |
} while (--n > 0); |
p1 += linesize; |
} |
} |
#endif |
/* 24 bit packed pixel handling */ |
#ifdef TGL_FEATURE_24_BITS |
/* order: RGBR GBRG BRGB */ |
/* XXX: packed pixel 24 bit support not tested */ |
/* XXX: big endian case not optimised */ |
#if BYTE_ORDER == BIG_ENDIAN |
#define RGB16_TO_RGB24(p0,p1,p2,v1,v2)\ |
{\ |
unsigned int r1,g1,b1,gb1,g2,b2,gb2;\ |
v1 = (v1 << 16) | (v1 >> 16);\ |
v2 = (v2 << 16) | (v2 >> 16);\ |
r1 = (v1 & 0xF800F800);\ |
g1 = (v1 & 0x07E007E0) << 5;\ |
b1 = (v1 & 0x001F001F) << 3;\ |
gb1 = g1 | b1;\ |
p0 = ((gb1 & 0x0000FFFF) << 8) | (r1 << 16) | (r1 >> 24);\ |
g2 = (v2 & 0x07E007E0) << 5;\ |
b2 = (v2 & 0x001F001F) << 3;\ |
gb2 = g2 | b2;\ |
p1 = (gb1 & 0xFFFF0000) | (v2 & 0xF800) | ((gb2 >> 8) & 0xff);\ |
p2 = (gb2 << 24) | ((v2 & 0xF8000000) >> 8) | (gb2 >> 16);\ |
} |
#else |
#define RGB16_TO_RGB24(p0,p1,p2,v1,v2)\ |
{\ |
unsigned int r1,g1,b1,gb1,g2,b2,gb2;\ |
r1 = (v1 & 0xF800F800);\ |
g1 = (v1 & 0x07E007E0) << 5;\ |
b1 = (v1 & 0x001F001F) << 3;\ |
gb1 = g1 | b1;\ |
p0 = ((gb1 & 0x0000FFFF) << 8) | (r1 << 16) | (r1 >> 24);\ |
g2 = (v2 & 0x07E007E0) << 5;\ |
b2 = (v2 & 0x001F001F) << 3;\ |
gb2 = g2 | b2;\ |
p1 = (gb1 & 0xFFFF0000) | (v2 & 0xF800) | ((gb2 >> 8) & 0xff);\ |
p2 = (gb2 << 24) | ((v2 & 0xF8000000) >> 8) | (gb2 >> 16);\ |
} |
#endif |
static void ZB_copyFrameBufferRGB24(ZBuffer * zb, |
void *buf, |
int linesize) |
{ |
unsigned short *q; |
unsigned int *p, *p1, w0, w1, w2, v0, v1; |
int y, n; |
q = zb->pbuf; |
p1 = (unsigned int *) buf; |
linesize = linesize * 3; |
for (y = 0; y < zb->ysize; y++) { |
p = p1; |
n = zb->xsize >> 2; |
do { |
v0 = *(unsigned int *) q; |
v1 = *(unsigned int *) (q + 2); |
RGB16_TO_RGB24(w0, w1, w2, v0, v1); |
p[0] = w0; |
p[1] = w1; |
p[2] = w2; |
q += 4; |
p += 3; |
} while (--n > 0); |
(char *) p1 += linesize; |
} |
} |
#endif |
void ZB_copyFrameBuffer(ZBuffer * zb, void *buf, |
int linesize) |
{ |
switch (zb->mode) { |
#ifdef TGL_FEATURE_8_BITS |
case ZB_MODE_INDEX: |
ZB_ditherFrameBuffer(zb, buf, linesize >> 1); |
break; |
#endif |
#ifdef TGL_FEATURE_16_BITS |
case ZB_MODE_5R6G5B: |
ZB_copyBuffer(zb, buf, linesize); |
break; |
#endif |
#ifdef TGL_FEATURE_32_BITS |
case ZB_MODE_RGBA: |
ZB_copyFrameBufferRGB32(zb, buf, linesize >> 1); |
break; |
#endif |
#ifdef TGL_FEATURE_24_BITS |
case ZB_MODE_RGB24: |
ZB_copyFrameBufferRGB24(zb, buf, linesize >> 1); |
break; |
#endif |
default: |
assert(0); |
} |
} |
#endif /* TGL_FEATURE_RENDER_BITS == 16 */ |
#if TGL_FEATURE_RENDER_BITS == 24 |
#define RGB24_TO_RGB16(r, g, b) \ |
((((r) >> 3) << 11) | (((g) >> 2) << 5) | ((b) >> 3)) |
/* XXX: not optimized */ |
static void ZB_copyFrameBuffer5R6G5B(ZBuffer * zb, |
void *buf, int linesize) |
{ |
PIXEL *q; |
unsigned short *p, *p1; |
int y, n; |
q = zb->pbuf; |
p1 = (unsigned short *) buf; |
for (y = 0; y < zb->ysize; y++) { |
p = p1; |
n = zb->xsize >> 2; |
do { |
p[0] = RGB24_TO_RGB16(q[0], q[1], q[2]); |
p[1] = RGB24_TO_RGB16(q[3], q[4], q[5]); |
p[2] = RGB24_TO_RGB16(q[6], q[7], q[8]); |
p[3] = RGB24_TO_RGB16(q[9], q[10], q[11]); |
q = (PIXEL *)((char *)q + 4 * PSZB); |
p += 4; |
} while (--n > 0); |
p1 = (unsigned short *)((char *)p1 + linesize); |
} |
} |
void ZB_copyFrameBuffer(ZBuffer * zb, void *buf, |
int linesize) |
{ |
switch (zb->mode) { |
#ifdef TGL_FEATURE_16_BITS |
case ZB_MODE_5R6G5B: |
ZB_copyFrameBuffer5R6G5B(zb, buf, linesize); |
break; |
#endif |
#ifdef TGL_FEATURE_24_BITS |
case ZB_MODE_RGB24: |
ZB_copyBuffer(zb, buf, linesize); |
break; |
#endif |
default: |
assert(0); |
} |
} |
#endif /* TGL_FEATURE_RENDER_BITS == 24 */ |
#if TGL_FEATURE_RENDER_BITS == 32 |
#define RGB32_TO_RGB16(v) \ |
(((v >> 8) & 0xf800) | (((v) >> 5) & 0x07e0) | (((v) & 0xff) >> 3)) |
/* XXX: not optimized */ |
static void ZB_copyFrameBuffer5R6G5B(ZBuffer * zb, |
void *buf, int linesize) |
{ |
PIXEL *q; |
unsigned short *p, *p1; |
int y, n; |
q = zb->pbuf; |
p1 = (unsigned short *) buf; |
for (y = 0; y < zb->ysize; y++) { |
p = p1; |
n = zb->xsize >> 2; |
do { |
p[0] = RGB32_TO_RGB16(q[0]); |
p[1] = RGB32_TO_RGB16(q[1]); |
p[2] = RGB32_TO_RGB16(q[2]); |
p[3] = RGB32_TO_RGB16(q[3]); |
q += 4; |
p += 4; |
} while (--n > 0); |
p1 = (unsigned short *)((char *)p1 + linesize); |
} |
} |
void ZB_copyFrameBuffer(ZBuffer * zb, void *buf, |
int linesize) |
{ |
switch (zb->mode) { |
#ifdef TGL_FEATURE_16_BITS |
case ZB_MODE_5R6G5B: |
ZB_copyFrameBuffer5R6G5B(zb, buf, linesize); |
break; |
#endif |
#ifdef TGL_FEATURE_32_BITS |
case ZB_MODE_RGBA: |
ZB_copyBuffer(zb, buf, linesize); |
break; |
#endif |
default: |
assert(0); |
} |
} |
#endif /* TGL_FEATURE_RENDER_BITS == 32 */ |
/* |
* adr must be aligned on an 'int' |
*/ |
void memset_s(void *adr, int val, int count) |
{ |
int i, n, v; |
unsigned int *p; |
unsigned short *q; |
p = adr; |
v = val | (val << 16); |
n = count >> 3; |
for (i = 0; i < n; i++) { |
p[0] = v; |
p[1] = v; |
p[2] = v; |
p[3] = v; |
p += 4; |
} |
q = (unsigned short *) p; |
n = count & 7; |
for (i = 0; i < n; i++) |
*q++ = val; |
} |
void memset_l(void *adr, int val, int count) |
{ |
int i, n, v; |
unsigned int *p; |
p = adr; |
v = val; |
n = count >> 2; |
for (i = 0; i < n; i++) { |
p[0] = v; |
p[1] = v; |
p[2] = v; |
p[3] = v; |
p += 4; |
} |
n = count & 3; |
for (i = 0; i < n; i++) |
*p++ = val; |
} |
/* count must be a multiple of 4 and >= 4 */ |
void memset_RGB24(void *adr,int r, int v, int b,long count) |
{ |
long i, n; |
register long v1,v2,v3,*pt=(long *)(adr); |
unsigned char *p,R=(unsigned char)r,V=(unsigned char)v,B=(unsigned char)b; |
p=(unsigned char *)adr; |
*p++=R; |
*p++=V; |
*p++=B; |
*p++=R; |
*p++=V; |
*p++=B; |
*p++=R; |
*p++=V; |
*p++=B; |
*p++=R; |
*p++=V; |
*p++=B; |
v1=*pt++; |
v2=*pt++; |
v3=*pt++; |
n = count >> 2; |
for(i=1;i<n;i++) { |
*pt++=v1; |
*pt++=v2; |
*pt++=v3; |
} |
} |
void ZB_clear(ZBuffer * zb, int clear_z, int z, |
int clear_color, int r, int g, int b) |
{ |
#if TGL_FEATURE_RENDER_BITS != 24 |
int color; |
#endif |
int y; |
PIXEL *pp; |
if (clear_z) { |
memset_s(zb->zbuf, z, zb->xsize * zb->ysize); |
} |
if (clear_color) { |
pp = zb->pbuf; |
for (y = 0; y < zb->ysize; y++) { |
#if TGL_FEATURE_RENDER_BITS == 15 || TGL_FEATURE_RENDER_BITS == 16 |
color = RGB_TO_PIXEL(r, g, b); |
memset_s(pp, color, zb->xsize); |
#elif TGL_FEATURE_RENDER_BITS == 32 |
color = RGB_TO_PIXEL(r, g, b); |
memset_l(pp, color, zb->xsize); |
#elif TGL_FEATURE_RENDER_BITS == 24 |
memset_RGB24(pp,r>>8,g>>8,b>>8,zb->xsize); |
#else |
#error TODO |
#endif |
pp = (PIXEL *) ((char *) pp + zb->linesize); |
} |
} |
} |
/programs/develop/libraries/TinyGL/src/zbuffer.h |
---|
0,0 → 1,169 |
#ifndef _tgl_zbuffer_h_ |
#define _tgl_zbuffer_h_ |
/* |
* Z buffer |
*/ |
#include "zfeatures.h" |
#define ZB_Z_BITS 16 |
#define ZB_POINT_Z_FRAC_BITS 14 |
#define ZB_POINT_S_MIN ( (1<<13) ) |
#define ZB_POINT_S_MAX ( (1<<22)-(1<<13) ) |
#define ZB_POINT_T_MIN ( (1<<21) ) |
#define ZB_POINT_T_MAX ( (1<<30)-(1<<21) ) |
#define ZB_POINT_RED_MIN ( (1<<10) ) |
#define ZB_POINT_RED_MAX ( (1<<16)-(1<<10) ) |
#define ZB_POINT_GREEN_MIN ( (1<<9) ) |
#define ZB_POINT_GREEN_MAX ( (1<<16)-(1<<9) ) |
#define ZB_POINT_BLUE_MIN ( (1<<10) ) |
#define ZB_POINT_BLUE_MAX ( (1<<16)-(1<<10) ) |
/* display modes */ |
#define ZB_MODE_5R6G5B 1 /* true color 16 bits */ |
#define ZB_MODE_INDEX 2 /* color index 8 bits */ |
#define ZB_MODE_RGBA 3 /* 32 bit rgba mode */ |
#define ZB_MODE_RGB24 4 /* 24 bit rgb mode */ |
#define ZB_NB_COLORS 225 /* number of colors for 8 bit display */ |
#if TGL_FEATURE_RENDER_BITS == 15 |
#define RGB_TO_PIXEL(r,g,b) \ |
((((r) >> 1) & 0x7c00) | (((g) >> 6) & 0x03e0) | ((b) >> 11)) |
typedef unsigned short PIXEL; |
/* bytes per pixel */ |
#define PSZB 2 |
/* bits per pixel = (1 << PSZH) */ |
#define PSZSH 4 |
#elif TGL_FEATURE_RENDER_BITS == 16 |
/* 16 bit mode */ |
#define RGB_TO_PIXEL(r,g,b) \ |
(((r) & 0xF800) | (((g) >> 5) & 0x07E0) | ((b) >> 11)) |
typedef unsigned short PIXEL; |
#define PSZB 2 |
#define PSZSH 4 |
#elif TGL_FEATURE_RENDER_BITS == 24 |
#define RGB_TO_PIXEL(r,g,b) \ |
((((r) << 8) & 0xff0000) | ((g) & 0xff00) | ((b) >> 8)) |
typedef unsigned char PIXEL; |
#define PSZB 3 |
#define PSZSH 5 |
#elif TGL_FEATURE_RENDER_BITS == 32 |
#define RGB_TO_PIXEL(r,g,b) \ |
((((r) << 8) & 0xff0000) | ((g) & 0xff00) | ((b) >> 8)) |
typedef unsigned int PIXEL; |
#define PSZB 4 |
#define PSZSH 5 |
#else |
#error Incorrect number of bits per pixel |
#endif |
typedef struct { |
int xsize,ysize; |
int linesize; /* line size, in bytes */ |
int mode; |
unsigned short *zbuf; |
PIXEL *pbuf; |
int frame_buffer_allocated; |
int nb_colors; |
unsigned char *dctable; |
int *ctable; |
PIXEL *current_texture; |
} ZBuffer; |
typedef struct { |
int x,y,z; /* integer coordinates in the zbuffer */ |
int s,t; /* coordinates for the mapping */ |
int r,g,b; /* color indexes */ |
float sz,tz; /* temporary coordinates for mapping */ |
} ZBufferPoint; |
/* zbuffer.c */ |
ZBuffer *ZB_open(int xsize,int ysize,int mode, |
int nb_colors, |
unsigned char *color_indexes, |
int *color_table, |
void *frame_buffer); |
void ZB_close(ZBuffer *zb); |
void ZB_resize(ZBuffer *zb,void *frame_buffer,int xsize,int ysize); |
void ZB_clear(ZBuffer *zb,int clear_z,int z, |
int clear_color,int r,int g,int b); |
/* linesize is in BYTES */ |
void ZB_copyFrameBuffer(ZBuffer *zb,void *buf,int linesize); |
/* zdither.c */ |
void ZB_initDither(ZBuffer *zb,int nb_colors, |
unsigned char *color_indexes,int *color_table); |
void ZB_closeDither(ZBuffer *zb); |
void ZB_ditherFrameBuffer(ZBuffer *zb,unsigned char *dest, |
int linesize); |
/* zline.c */ |
void ZB_plot(ZBuffer *zb,ZBufferPoint *p); |
void ZB_line(ZBuffer *zb,ZBufferPoint *p1,ZBufferPoint *p2); |
void ZB_line_z(ZBuffer * zb, ZBufferPoint * p1, ZBufferPoint * p2); |
/* ztriangle.c */ |
void ZB_setTexture(ZBuffer *zb, PIXEL *texture); |
void ZB_fillTriangleFlat(ZBuffer *zb, |
ZBufferPoint *p1,ZBufferPoint *p2,ZBufferPoint *p3); |
void ZB_fillTriangleSmooth(ZBuffer *zb, |
ZBufferPoint *p1,ZBufferPoint *p2,ZBufferPoint *p3); |
void ZB_fillTriangleMapping(ZBuffer *zb, |
ZBufferPoint *p1,ZBufferPoint *p2,ZBufferPoint *p3); |
void ZB_fillTriangleMappingPerspective(ZBuffer *zb, |
ZBufferPoint *p0,ZBufferPoint *p1,ZBufferPoint *p2); |
typedef void (*ZB_fillTriangleFunc)(ZBuffer *, |
ZBufferPoint *,ZBufferPoint *,ZBufferPoint *); |
/* |
* Memory allocator for TinyGL |
*/ |
/* modify these functions so that they suit your needs */ |
static inline void gl_free(void *p) |
{ |
free(p); |
} |
static inline void *gl_malloc(int size) |
{ |
return malloc(size); |
} |
static inline void *gl_zalloc(int size) |
{ |
return calloc(1, size); |
} |
#endif /* _tgl_zbuffer_h_ */ |
/programs/develop/libraries/TinyGL/src/zdither.c |
---|
0,0 → 1,159 |
/* |
* Highly optimised dithering 16 bits -> 8 bits. |
* The formulas were taken in Mesa (Bob Mercier mercier@hollywood.cinenet.net). |
*/ |
#include <stdlib.h> |
#include <stdio.h> |
#include "zbuffer.h" |
/*#include <assert.h>*/ |
#if defined(TGL_FEATURE_8_BITS) |
#define _R 5 |
#define _G 9 |
#define _B 5 |
#define _DX 4 |
#define _DY 4 |
#define _D (_DX*_DY) |
#define _MIX(r,g,b) ( ((g)<<6) | ((b)<<3) | (r) ) |
#define DITHER_TABLE_SIZE (1 << 15) |
#define DITHER_INDEX(r,g,b) ((b) + (g) * _B + (r) * (_B * _G)) |
#define MAXC 256 |
static int kernel8[_DY*_DX] = { |
0 * MAXC, 8 * MAXC, 2 * MAXC, 10 * MAXC, |
12 * MAXC, 4 * MAXC, 14 * MAXC, 6 * MAXC, |
3 * MAXC, 11 * MAXC, 1 * MAXC, 9 * MAXC, |
15 * MAXC, 7 * MAXC, 13 * MAXC, 5 * MAXC, |
}; |
/* we build the color table and the lookup table */ |
void ZB_initDither(ZBuffer *zb,int nb_colors, |
unsigned char *color_indexes,int *color_table) |
{ |
int c,r,g,b,i,index,r1,g1,b1; |
if (nb_colors < (_R * _G * _B)) { |
fprintf(stderr,"zdither: not enough colors\n"); |
exit(1); |
} |
for(i=0;i<nb_colors;i++) color_table[i]=0; |
zb->nb_colors=nb_colors; |
zb->ctable=gl_malloc(nb_colors * sizeof(int)); |
for (r = 0; r < _R; r++) { |
for (g = 0; g < _G; g++) { |
for (b = 0; b < _B; b++) { |
r1=(r*255) / (_R - 1); |
g1=(g*255) / (_G - 1); |
b1=(b*255) / (_B - 1); |
index=DITHER_INDEX(r,g,b); |
c=(r1 << 16) | (g1 << 8) | b1; |
zb->ctable[index]=c; |
color_table[index]=c; |
} |
} |
} |
zb->dctable=gl_malloc( DITHER_TABLE_SIZE ); |
for(i=0;i<DITHER_TABLE_SIZE;i++) { |
r=(i >> 12) & 0x7; |
g=(i >> 8) & 0xF; |
b=(i >> 3) & 0x7; |
index=DITHER_INDEX(r,g,b); |
zb->dctable[i]=color_indexes[index]; |
} |
} |
void ZB_closeDither(ZBuffer *zb) |
{ |
gl_free(zb->ctable); |
gl_free(zb->dctable); |
} |
#if 0 |
int ZDither_lookupColor(int r,int g,int b) |
{ |
unsigned char *ctable=zdither_color_table; |
return ctable[_MIX(_DITH0(_R, r), _DITH0(_G, g),_DITH0(_B, b))]; |
} |
#endif |
#define DITHER_PIXEL2(a) \ |
{ \ |
register int v,t,r,g,c; \ |
v=*(unsigned int *)(pp+(a)); \ |
g=(v & 0x07DF07DF) + g_d; \ |
r=(((v & 0xF800F800) >> 2) + r_d) & 0x70007000; \ |
t=r | g; \ |
c=ctable[t & 0xFFFF] | (ctable[t >> 16] << 8); \ |
*(unsigned short *)(dest+(a))=c; \ |
} |
/* NOTE: all the memory access are 16 bit aligned, so if buf or |
linesize are not multiple of 2, it cannot work efficiently (or |
hang!) */ |
void ZB_ditherFrameBuffer(ZBuffer *zb,unsigned char *buf, |
int linesize) |
{ |
int xk,yk,x,y,c1,c2; |
unsigned char *dest1; |
unsigned short *pp1; |
int r_d,g_d,b_d; |
unsigned char *ctable=zb->dctable; |
register unsigned char *dest; |
register unsigned short *pp; |
assert( ((long)buf & 1) == 0 && (linesize & 1) == 0); |
for(yk=0;yk<4;yk++) { |
for(xk=0;xk<4;xk+=2) { |
#if BYTE_ORDER == BIG_ENDIAN |
c1=kernel8[yk*4+xk+1]; |
c2=kernel8[yk*4+xk]; |
#else |
c1=kernel8[yk*4+xk]; |
c2=kernel8[yk*4+xk+1]; |
#endif |
r_d=((c1 << 2) & 0xF800) >> 2; |
g_d=(c1 >> 4) & 0x07C0; |
b_d=(c1 >> 9) & 0x001F; |
r_d|=(((c2 << 2) & 0xF800) >> 2) << 16; |
g_d|=((c2 >> 4) & 0x07C0) << 16; |
b_d|=((c2 >> 9) & 0x001F) << 16; |
g_d=b_d | g_d; |
dest1=buf + (yk * linesize) + xk; |
pp1=zb->pbuf + (yk * zb->xsize) + xk; |
for(y=yk;y<zb->ysize;y+=4) { |
dest=dest1; |
pp=pp1; |
for(x=xk;x<zb->xsize;x+=16) { |
DITHER_PIXEL2(0); |
DITHER_PIXEL2(1*4); |
DITHER_PIXEL2(2*4); |
DITHER_PIXEL2(3*4); |
pp+=16; |
dest+=16; |
} |
dest1+=linesize*4; |
pp1+=zb->xsize*4; |
} |
} |
} |
} |
#endif |
/programs/develop/libraries/TinyGL/src/zfeatures.h |
---|
0,0 → 1,54 |
#ifndef _tgl_features_h_ |
#define _tgl_features_h_ |
#define NDEBUG |
/*for menuetlibc*/ |
#ifdef NDEBUG |
/* |
* If not debugging, assert does nothing. |
*/ |
#define assert(x) ((void)0) |
#else /* debugging enabled */ |
#include <assert.h> |
#endif |
/* It is possible to enable/disable (compile time) features in this |
header file. */ |
/*#define TGL_FEATURE_ARRAYS 1*/ |
/*#define TGL_FEATURE_DISPLAYLISTS 1*/ |
/*#define TGL_FEATURE_POLYGON_OFFSET 1*/ |
/* |
* Matrix of internal and external pixel formats supported. 'Y' means |
* supported. |
* |
* External 8 16 24 32 |
* Internal |
* 15 . . . . |
* 16 Y Y Y Y |
* 24 . Y Y . |
* 32 . Y . Y |
* |
* |
* 15 bpp does not work yet (although it is easy to add it - ask me if |
* you need it). |
* |
* Internal pixel format: see TGL_FEATURE_RENDER_BITS |
* External pixel format: see TGL_FEATURE_xxx_BITS |
*/ |
/* enable various convertion code from internal pixel format (usually |
16 bits per pixel) to any external format */ |
/*#define TGL_FEATURE_16_BITS 1*/ |
/*#define TGL_FEATURE_8_BITS 1*/ |
#define TGL_FEATURE_24_BITS 1 |
/*#define TGL_FEATURE_32_BITS 1*/ |
/*#define TGL_FEATURE_RENDER_BITS 15*/ |
/*#define TGL_FEATURE_RENDER_BITS 16*/ |
#define TGL_FEATURE_RENDER_BITS 24 |
/*#define TGL_FEATURE_RENDER_BITS 32*/ |
#endif /* _tgl_features_h_ */ |
/programs/develop/libraries/TinyGL/src/zgl.h |
---|
0,0 → 1,392 |
#ifndef _tgl_zgl_h_ |
#define _tgl_zgl_h_ |
#include <stdlib.h> |
#include <stdio.h> |
#include <math.h> |
/*#include <assert.h>*/ |
#include <GL/gl.h> |
#include "zbuffer.h" |
#include "zmath.h" |
#include "zfeatures.h" |
#define fputc(...) /*nothing*/ |
#define fprintf(...) /*nothing*/ |
#define vfprintf(...) /*nothing*/ |
#undef stderr |
#define stderr ((FILE*)-1) |
/*#define DEBUG */ |
/*#define NDEBUG */ |
enum { |
#define ADD_OP(a,b,c) OP_ ## a , |
#include "opinfo.h" |
}; |
/* initially # of allocated GLVertexes (will grow when necessary) */ |
#define POLYGON_MAX_VERTEX 16 |
/* Max # of specular light pow buffers */ |
#define MAX_SPECULAR_BUFFERS 8 |
/* # of entries in specular buffer */ |
#define SPECULAR_BUFFER_SIZE 1024 |
/* specular buffer granularity */ |
#define SPECULAR_BUFFER_RESOLUTION 1024 |
#define MAX_MODELVIEW_STACK_DEPTH 32 |
#define MAX_PROJECTION_STACK_DEPTH 8 |
#define MAX_TEXTURE_STACK_DEPTH 8 |
#define MAX_NAME_STACK_DEPTH 64 |
#define MAX_TEXTURE_LEVELS 11 |
#define MAX_LIGHTS 16 |
#define VERTEX_HASH_SIZE 1031 |
#define MAX_DISPLAY_LISTS 1024 |
#define OP_BUFFER_MAX_SIZE 512 |
#define TGL_OFFSET_FILL 0x1 |
#define TGL_OFFSET_LINE 0x2 |
#define TGL_OFFSET_POINT 0x4 |
typedef struct GLSpecBuf { |
int shininess_i; |
int last_used; |
float buf[SPECULAR_BUFFER_SIZE+1]; |
struct GLSpecBuf *next; |
} GLSpecBuf; |
typedef struct GLLight { |
V4 ambient; |
V4 diffuse; |
V4 specular; |
V4 position; |
V3 spot_direction; |
float spot_exponent; |
float spot_cutoff; |
float attenuation[3]; |
/* precomputed values */ |
float cos_spot_cutoff; |
V3 norm_spot_direction; |
V3 norm_position; |
/* we use a linked list to know which are the enabled lights */ |
int enabled; |
struct GLLight *next,*prev; |
} GLLight; |
typedef struct GLMaterial { |
V4 emission; |
V4 ambient; |
V4 diffuse; |
V4 specular; |
float shininess; |
/* computed values */ |
int shininess_i; |
int do_specular; |
} GLMaterial; |
typedef struct GLViewport { |
int xmin,ymin,xsize,ysize; |
V3 scale; |
V3 trans; |
int updated; |
} GLViewport; |
typedef union { |
int op; |
float f; |
int i; |
unsigned int ui; |
void *p; |
} GLParam; |
typedef struct GLParamBuffer { |
GLParam ops[OP_BUFFER_MAX_SIZE]; |
struct GLParamBuffer *next; |
} GLParamBuffer; |
typedef struct GLList { |
GLParamBuffer *first_op_buffer; |
/* TODO: extensions for an hash table or a better allocating scheme */ |
} GLList; |
typedef struct GLVertex { |
int edge_flag; |
V3 normal; |
V4 coord; |
V4 tex_coord; |
V4 color; |
/* computed values */ |
V4 ec; /* eye coordinates */ |
V4 pc; /* coordinates in the normalized volume */ |
int clip_code; /* clip code */ |
ZBufferPoint zp; /* integer coordinates for the rasterization */ |
} GLVertex; |
typedef struct GLImage { |
void *pixmap; |
int xsize,ysize; |
} GLImage; |
/* textures */ |
#define TEXTURE_HASH_TABLE_SIZE 256 |
typedef struct GLTexture { |
GLImage images[MAX_TEXTURE_LEVELS]; |
int handle; |
struct GLTexture *next,*prev; |
} GLTexture; |
/* shared state */ |
typedef struct GLSharedState { |
GLList **lists; |
GLTexture **texture_hash_table; |
} GLSharedState; |
struct GLContext; |
typedef void (*gl_draw_triangle_func)(struct GLContext *c, |
GLVertex *p0,GLVertex *p1,GLVertex *p2); |
/* display context */ |
typedef struct GLContext { |
/* Z buffer */ |
ZBuffer *zb; |
/* lights */ |
GLLight lights[MAX_LIGHTS]; |
GLLight *first_light; |
V4 ambient_light_model; |
int local_light_model; |
int lighting_enabled; |
int light_model_two_side; |
/* materials */ |
GLMaterial materials[2]; |
int color_material_enabled; |
int current_color_material_mode; |
int current_color_material_type; |
/* textures */ |
GLTexture *current_texture; |
int texture_2d_enabled; |
/* shared state */ |
GLSharedState shared_state; |
/* current list */ |
GLParamBuffer *current_op_buffer; |
int current_op_buffer_index; |
int exec_flag,compile_flag,print_flag; |
/* matrix */ |
int matrix_mode; |
M4 *matrix_stack[3]; |
M4 *matrix_stack_ptr[3]; |
int matrix_stack_depth_max[3]; |
M4 matrix_model_view_inv; |
M4 matrix_model_projection; |
int matrix_model_projection_updated; |
int matrix_model_projection_no_w_transform; |
int apply_texture_matrix; |
/* viewport */ |
GLViewport viewport; |
/* current state */ |
int polygon_mode_back; |
int polygon_mode_front; |
int current_front_face; |
int current_shade_model; |
int current_cull_face; |
int cull_face_enabled; |
int normalize_enabled; |
gl_draw_triangle_func draw_triangle_front,draw_triangle_back; |
/* selection */ |
int render_mode; |
unsigned int *select_buffer; |
int select_size; |
unsigned int *select_ptr,*select_hit; |
int select_overflow; |
int select_hits; |
/* names */ |
unsigned int name_stack[MAX_NAME_STACK_DEPTH]; |
int name_stack_size; |
/* clear */ |
float clear_depth; |
V4 clear_color; |
/* current vertex state */ |
V4 current_color; |
unsigned int longcurrent_color[3]; /* precomputed integer color */ |
V4 current_normal; |
V4 current_tex_coord; |
int current_edge_flag; |
/* glBegin / glEnd */ |
int in_begin; |
int begin_type; |
int vertex_n,vertex_cnt; |
int vertex_max; |
GLVertex *vertex; |
/* opengl 1.1 arrays */ |
float *vertex_array; |
int vertex_array_size; |
int vertex_array_stride; |
float *normal_array; |
int normal_array_stride; |
float *color_array; |
int color_array_size; |
int color_array_stride; |
float *texcoord_array; |
int texcoord_array_size; |
int texcoord_array_stride; |
int client_states; |
/* opengl 1.1 polygon offset */ |
float offset_factor; |
float offset_units; |
int offset_states; |
/* specular buffer. could probably be shared between contexts, |
but that wouldn't be 100% thread safe */ |
GLSpecBuf *specbuf_first; |
int specbuf_used_counter; |
int specbuf_num_buffers; |
/* opaque structure for user's use */ |
void *opaque; |
/* resize viewport function */ |
int (*gl_resize_viewport)(struct GLContext *c,int *xsize,int *ysize); |
/* depth test */ |
int depth_test; |
} GLContext; |
extern GLContext *gl_ctx; |
void gl_add_op(GLParam *p); |
/* clip.c */ |
void gl_transform_to_viewport(GLContext *c,GLVertex *v); |
void gl_draw_triangle(GLContext *c,GLVertex *p0,GLVertex *p1,GLVertex *p2); |
void gl_draw_line(GLContext *c,GLVertex *p0,GLVertex *p1); |
void gl_draw_point(GLContext *c,GLVertex *p0); |
void gl_draw_triangle_point(GLContext *c, |
GLVertex *p0,GLVertex *p1,GLVertex *p2); |
void gl_draw_triangle_line(GLContext *c, |
GLVertex *p0,GLVertex *p1,GLVertex *p2); |
void gl_draw_triangle_fill(GLContext *c, |
GLVertex *p0,GLVertex *p1,GLVertex *p2); |
void gl_draw_triangle_select(GLContext *c, |
GLVertex *p0,GLVertex *p1,GLVertex *p2); |
/* matrix.c */ |
void gl_print_matrix(const float *m); |
/* |
void glopLoadIdentity(GLContext *c,GLParam *p); |
void glopTranslate(GLContext *c,GLParam *p);*/ |
/* light.c */ |
void gl_add_select(GLContext *c,unsigned int zmin,unsigned int zmax); |
void gl_enable_disable_light(GLContext *c,int light,int v); |
void gl_shade_vertex(GLContext *c,GLVertex *v); |
void glInitTextures(GLContext *c); |
void glEndTextures(GLContext *c); |
GLTexture *alloc_texture(GLContext *c,int h); |
/* image_util.c */ |
void gl_convertRGB_to_5R6G5B(unsigned short *pixmap,unsigned char *rgb, |
int xsize,int ysize); |
void gl_convertRGB_to_8A8R8G8B(unsigned int *pixmap, unsigned char *rgb, |
int xsize, int ysize); |
void gl_resizeImage(unsigned char *dest,int xsize_dest,int ysize_dest, |
unsigned char *src,int xsize_src,int ysize_src); |
void gl_resizeImageNoInterpolate(unsigned char *dest,int xsize_dest,int ysize_dest, |
unsigned char *src,int xsize_src,int ysize_src); |
static inline GLContext *gl_get_context(void) |
{ |
return gl_ctx; |
}; |
void gl_fatal_error(char *format, ...); |
/* specular buffer "api" */ |
GLSpecBuf *specbuf_get_buffer(GLContext *c, const int shininess_i, |
const float shininess); |
#ifdef __BEOS__ |
void dprintf(const char *, ...); |
#else /* !BEOS */ |
#ifdef DEBUG |
#define dprintf(format, args...) \ |
fprintf(stderr,"In '%s': " format "\n",__FUNCTION__, ##args); |
#else |
#define dprintf(format, args...) |
#endif |
#endif /* !BEOS */ |
/* glopXXX functions */ |
#define ADD_OP(a,b,c) void glop ## a (GLContext *,GLParam *); |
#include "opinfo.h" |
/* this clip epsilon is needed to avoid some rounding errors after |
several clipping stages */ |
#define CLIP_EPSILON (1E-5) |
static inline int gl_clipcode(float x,float y,float z,float w1) |
{ |
float w; |
w=w1 * (1.0 + CLIP_EPSILON); |
return (x<-w) | |
((x>w)<<1) | |
((y<-w)<<2) | |
((y>w)<<3) | |
((z<-w)<<4) | |
((z>w)<<5) ; |
} |
#define RGBFtoRGBI(rf,gf,bf,ri,gi,bi) \ |
{\ |
ri = (unsigned int) (rf * (ZB_POINT_RED_MAX - ZB_POINT_RED_MIN) + \ |
ZB_POINT_RED_MIN); \ |
gi = (unsigned int) (gf * (ZB_POINT_GREEN_MAX - ZB_POINT_GREEN_MIN) + \ |
ZB_POINT_GREEN_MIN); \ |
bi = (unsigned int) (bf * (ZB_POINT_BLUE_MAX - ZB_POINT_BLUE_MIN) + \ |
ZB_POINT_BLUE_MIN);\ |
} |
#endif /* _tgl_zgl_h_ */ |
/programs/develop/libraries/TinyGL/src/zline.c |
---|
0,0 → 1,84 |
#include <stdlib.h> |
#include "zbuffer.h" |
#define ZCMP(z,zpix) ((z) >= (zpix)) |
void ZB_plot(ZBuffer * zb, ZBufferPoint * p) |
{ |
unsigned short *pz; |
PIXEL *pp; |
int zz; |
pz = zb->zbuf + (p->y * zb->xsize + p->x); |
pp = (PIXEL *) ((char *) zb->pbuf + zb->linesize * p->y + p->x * PSZB); |
zz = p->z >> ZB_POINT_Z_FRAC_BITS; |
if (ZCMP(zz, *pz)) { |
#if TGL_FEATURE_RENDER_BITS == 24 |
pp[0]=p->r>>8; |
pp[1]=p->g>>8; |
pp[2]=p->b>>8; |
#else |
*pp = RGB_TO_PIXEL(p->r, p->g, p->b); |
#endif |
*pz = zz; |
} |
} |
#define INTERP_Z |
static void ZB_line_flat_z(ZBuffer * zb, ZBufferPoint * p1, ZBufferPoint * p2, |
int color) |
{ |
#include "zline.h" |
} |
/* line with color interpolation */ |
#define INTERP_Z |
#define INTERP_RGB |
static void ZB_line_interp_z(ZBuffer * zb, ZBufferPoint * p1, ZBufferPoint * p2) |
{ |
#include "zline.h" |
} |
/* no Z interpolation */ |
static void ZB_line_flat(ZBuffer * zb, ZBufferPoint * p1, ZBufferPoint * p2, |
int color) |
{ |
#include "zline.h" |
} |
#define INTERP_RGB |
static void ZB_line_interp(ZBuffer * zb, ZBufferPoint * p1, ZBufferPoint * p2) |
{ |
#include "zline.h" |
} |
void ZB_line_z(ZBuffer * zb, ZBufferPoint * p1, ZBufferPoint * p2) |
{ |
int color1, color2; |
color1 = RGB_TO_PIXEL(p1->r, p1->g, p1->b); |
color2 = RGB_TO_PIXEL(p2->r, p2->g, p2->b); |
/* choose if the line should have its color interpolated or not */ |
if (color1 == color2) { |
ZB_line_flat_z(zb, p1, p2, color1); |
} else { |
ZB_line_interp_z(zb, p1, p2); |
} |
} |
void ZB_line(ZBuffer * zb, ZBufferPoint * p1, ZBufferPoint * p2) |
{ |
int color1, color2; |
color1 = RGB_TO_PIXEL(p1->r, p1->g, p1->b); |
color2 = RGB_TO_PIXEL(p2->r, p2->g, p2->b); |
/* choose if the line should have its color interpolated or not */ |
if (color1 == color2) { |
ZB_line_flat(zb, p1, p2, color1); |
} else { |
ZB_line_interp(zb, p1, p2); |
} |
} |
/programs/develop/libraries/TinyGL/src/zline.h |
---|
0,0 → 1,121 |
{ |
int n, dx, dy, sx, pp_inc_1, pp_inc_2; |
register int a; |
register PIXEL *pp; |
#if defined(INTERP_RGB) || TGL_FEATURE_RENDER_BITS == 24 |
register unsigned int r, g, b; |
#endif |
#ifdef INTERP_RGB |
register unsigned int rinc, ginc, binc; |
#endif |
#ifdef INTERP_Z |
register unsigned short *pz; |
int zinc; |
register int z, zz; |
#endif |
if (p1->y > p2->y || (p1->y == p2->y && p1->x > p2->x)) { |
ZBufferPoint *tmp; |
tmp = p1; |
p1 = p2; |
p2 = tmp; |
} |
sx = zb->xsize; |
pp = (PIXEL *) ((char *) zb->pbuf + zb->linesize * p1->y + p1->x * PSZB); |
#ifdef INTERP_Z |
pz = zb->zbuf + (p1->y * sx + p1->x); |
z = p1->z; |
#endif |
dx = p2->x - p1->x; |
dy = p2->y - p1->y; |
#ifdef INTERP_RGB |
r = p1->r << 8; |
g = p1->g << 8; |
b = p1->b << 8; |
#elif TGL_FEATURE_RENDER_BITS == 24 |
/* for 24 bits, we store the colors in different variables */ |
r = p2->r >> 8; |
g = p2->g >> 8; |
b = p2->b >> 8; |
#endif |
#ifdef INTERP_RGB |
#define RGB(x) x |
#if TGL_FEATURE_RENDER_BITS == 24 |
#define RGBPIXEL pp[0] = r >> 16, pp[1] = g >> 16, pp[2] = b >> 16 |
#else |
#define RGBPIXEL *pp = RGB_TO_PIXEL(r >> 8,g >> 8,b >> 8) |
#endif |
#else /* INTERP_RGB */ |
#define RGB(x) |
#if TGL_FEATURE_RENDER_BITS == 24 |
#define RGBPIXEL pp[0] = r, pp[1] = g, pp[2] = b |
#else |
#define RGBPIXEL *pp = color |
#endif |
#endif /* INTERP_RGB */ |
#ifdef INTERP_Z |
#define ZZ(x) x |
#define PUTPIXEL() \ |
{ \ |
zz=z >> ZB_POINT_Z_FRAC_BITS; \ |
if (ZCMP(zz,*pz)) { \ |
RGBPIXEL; \ |
*pz=zz; \ |
} \ |
} |
#else /* INTERP_Z */ |
#define ZZ(x) |
#define PUTPIXEL() RGBPIXEL |
#endif /* INTERP_Z */ |
#define DRAWLINE(dx,dy,inc_1,inc_2) \ |
n=dx;\ |
ZZ(zinc=(p2->z-p1->z)/n);\ |
RGB(rinc=((p2->r-p1->r) << 8)/n;\ |
ginc=((p2->g-p1->g) << 8)/n;\ |
binc=((p2->b-p1->b) << 8)/n);\ |
a=2*dy-dx;\ |
dy=2*dy;\ |
dx=2*dx-dy;\ |
pp_inc_1 = (inc_1) * PSZB;\ |
pp_inc_2 = (inc_2) * PSZB;\ |
do {\ |
PUTPIXEL();\ |
ZZ(z+=zinc);\ |
RGB(r+=rinc;g+=ginc;b+=binc);\ |
if (a>0) { pp=(PIXEL *)((char *)pp + pp_inc_1); ZZ(pz+=(inc_1)); a-=dx; }\ |
else { pp=(PIXEL *)((char *)pp + pp_inc_2); ZZ(pz+=(inc_2)); a+=dy; }\ |
} while (--n >= 0); |
/* fin macro */ |
if (dx == 0 && dy == 0) { |
PUTPIXEL(); |
} else if (dx > 0) { |
if (dx >= dy) { |
DRAWLINE(dx, dy, sx + 1, 1); |
} else { |
DRAWLINE(dy, dx, sx + 1, sx); |
} |
} else { |
dx = -dx; |
if (dx >= dy) { |
DRAWLINE(dx, dy, sx - 1, -1); |
} else { |
DRAWLINE(dy, dx, sx - 1, sx); |
} |
} |
} |
#undef INTERP_Z |
#undef INTERP_RGB |
/* internal defines */ |
#undef DRAWLINE |
#undef PUTPIXEL |
#undef ZZ |
#undef RGB |
#undef RGBPIXEL |
/programs/develop/libraries/TinyGL/src/zmath.c |
---|
0,0 → 1,274 |
/* Some simple mathematical functions. Don't look for some logic in |
the function names :-) */ |
#include <stdlib.h> |
#include <string.h> |
#include <math.h> |
#include "zmath.h" |
/* ******* Gestion des matrices 4x4 ****** */ |
void gl_M4_Id(M4 *a) |
{ |
int i,j; |
for(i=0;i<4;i++) |
for(j=0;j<4;j++) |
if (i==j) a->m[i][j]=1.0; else a->m[i][j]=0.0; |
} |
int gl_M4_IsId(M4 *a) |
{ |
int i,j; |
for(i=0;i<4;i++) |
for(j=0;j<4;j++) { |
if (i==j) { |
if (a->m[i][j] != 1.0) return 0; |
} else if (a->m[i][j] != 0.0) return 0; |
} |
return 1; |
} |
void gl_M4_Mul(M4 *c,M4 *a,M4 *b) |
{ |
int i,j,k; |
float s; |
for(i=0;i<4;i++) |
for(j=0;j<4;j++) { |
s=0.0; |
for(k=0;k<4;k++) s+=a->m[i][k]*b->m[k][j]; |
c->m[i][j]=s; |
} |
} |
/* c=c*a */ |
void gl_M4_MulLeft(M4 *c,M4 *b) |
{ |
int i,j,k; |
float s; |
M4 a; |
/*memcpy(&a, c, 16*sizeof(float)); |
*/ |
a=*c; |
for(i=0;i<4;i++) |
for(j=0;j<4;j++) { |
s=0.0; |
for(k=0;k<4;k++) s+=a.m[i][k]*b->m[k][j]; |
c->m[i][j]=s; |
} |
} |
void gl_M4_Move(M4 *a,M4 *b) |
{ |
memcpy(a,b,sizeof(M4)); |
} |
void gl_MoveV3(V3 *a,V3 *b) |
{ |
memcpy(a,b,sizeof(V3)); |
} |
void gl_MulM4V3(V3 *a,M4 *b,V3 *c) |
{ |
a->X=b->m[0][0]*c->X+b->m[0][1]*c->Y+b->m[0][2]*c->Z+b->m[0][3]; |
a->Y=b->m[1][0]*c->X+b->m[1][1]*c->Y+b->m[1][2]*c->Z+b->m[1][3]; |
a->Z=b->m[2][0]*c->X+b->m[2][1]*c->Y+b->m[2][2]*c->Z+b->m[2][3]; |
} |
void gl_MulM3V3(V3 *a,M4 *b,V3 *c) |
{ |
a->X=b->m[0][0]*c->X+b->m[0][1]*c->Y+b->m[0][2]*c->Z; |
a->Y=b->m[1][0]*c->X+b->m[1][1]*c->Y+b->m[1][2]*c->Z; |
a->Z=b->m[2][0]*c->X+b->m[2][1]*c->Y+b->m[2][2]*c->Z; |
} |
void gl_M4_MulV4(V4 *a,M4 *b,V4 *c) |
{ |
a->X=b->m[0][0]*c->X+b->m[0][1]*c->Y+b->m[0][2]*c->Z+b->m[0][3]*c->W; |
a->Y=b->m[1][0]*c->X+b->m[1][1]*c->Y+b->m[1][2]*c->Z+b->m[1][3]*c->W; |
a->Z=b->m[2][0]*c->X+b->m[2][1]*c->Y+b->m[2][2]*c->Z+b->m[2][3]*c->W; |
a->W=b->m[3][0]*c->X+b->m[3][1]*c->Y+b->m[3][2]*c->Z+b->m[3][3]*c->W; |
} |
/* transposition of a 4x4 matrix */ |
void gl_M4_Transpose(M4 *a,M4 *b) |
{ |
a->m[0][0]=b->m[0][0]; |
a->m[0][1]=b->m[1][0]; |
a->m[0][2]=b->m[2][0]; |
a->m[0][3]=b->m[3][0]; |
a->m[1][0]=b->m[0][1]; |
a->m[1][1]=b->m[1][1]; |
a->m[1][2]=b->m[2][1]; |
a->m[1][3]=b->m[3][1]; |
a->m[2][0]=b->m[0][2]; |
a->m[2][1]=b->m[1][2]; |
a->m[2][2]=b->m[2][2]; |
a->m[2][3]=b->m[3][2]; |
a->m[3][0]=b->m[0][3]; |
a->m[3][1]=b->m[1][3]; |
a->m[3][2]=b->m[2][3]; |
a->m[3][3]=b->m[3][3]; |
} |
/* inversion of an orthogonal matrix of type Y=M.X+P */ |
void gl_M4_InvOrtho(M4 *a,M4 b) |
{ |
int i,j; |
float s; |
for(i=0;i<3;i++) |
for(j=0;j<3;j++) a->m[i][j]=b.m[j][i]; |
a->m[3][0]=0.0; a->m[3][1]=0.0; a->m[3][2]=0.0; a->m[3][3]=1.0; |
for(i=0;i<3;i++) { |
s=0; |
for(j=0;j<3;j++) s-=b.m[j][i]*b.m[j][3]; |
a->m[i][3]=s; |
} |
} |
/* Inversion of a general nxn matrix. |
Note : m is destroyed */ |
int Matrix_Inv(float *r,float *m,int n) |
{ |
int i,j,k,l; |
float max,tmp,t; |
/* identitée dans r */ |
for(i=0;i<n*n;i++) r[i]=0; |
for(i=0;i<n;i++) r[i*n+i]=1; |
for(j=0;j<n;j++) { |
/* recherche du nombre de plus grand module sur la colonne j */ |
max=m[j*n+j]; |
k=j; |
for(i=j+1;i<n;i++) |
if (fabs(m[i*n+j])>fabs(max)) { |
k=i; |
max=m[i*n+j]; |
} |
/* non intersible matrix */ |
if (max==0) return 1; |
/* permutation des lignes j et k */ |
if (k!=j) { |
for(i=0;i<n;i++) { |
tmp=m[j*n+i]; |
m[j*n+i]=m[k*n+i]; |
m[k*n+i]=tmp; |
tmp=r[j*n+i]; |
r[j*n+i]=r[k*n+i]; |
r[k*n+i]=tmp; |
} |
} |
/* multiplication de la ligne j par 1/max */ |
max=1/max; |
for(i=0;i<n;i++) { |
m[j*n+i]*=max; |
r[j*n+i]*=max; |
} |
for(l=0;l<n;l++) if (l!=j) { |
t=m[l*n+j]; |
for(i=0;i<n;i++) { |
m[l*n+i]-=m[j*n+i]*t; |
r[l*n+i]-=r[j*n+i]*t; |
} |
} |
} |
return 0; |
} |
/* inversion of a 4x4 matrix */ |
void gl_M4_Inv(M4 *a,M4 *b) |
{ |
M4 tmp; |
memcpy(&tmp, b, 16*sizeof(float)); |
Matrix_Inv(&a->m[0][0],&tmp.m[0][0],4); |
} |
void gl_M4_Rotate(M4 *a,float t,int u) |
{ |
float s,c; |
int v,w; |
if ((v=u+1)>2) v=0; |
if ((w=v+1)>2) w=0; |
s=sin(t); |
c=cos(t); |
gl_M4_Id(a); |
a->m[v][v]=c; a->m[v][w]=-s; |
a->m[w][v]=s; a->m[w][w]=c; |
} |
/* inverse of a 3x3 matrix */ |
void gl_M3_Inv(M3 *a,M3 *m) |
{ |
float det; |
det = m->m[0][0]*m->m[1][1]*m->m[2][2]-m->m[0][0]*m->m[1][2]*m->m[2][1]- |
m->m[1][0]*m->m[0][1]*m->m[2][2]+m->m[1][0]*m->m[0][2]*m->m[2][1]+ |
m->m[2][0]*m->m[0][1]*m->m[1][2]-m->m[2][0]*m->m[0][2]*m->m[1][1]; |
a->m[0][0] = (m->m[1][1]*m->m[2][2]-m->m[1][2]*m->m[2][1])/det; |
a->m[0][1] = -(m->m[0][1]*m->m[2][2]-m->m[0][2]*m->m[2][1])/det; |
a->m[0][2] = -(-m->m[0][1]*m->m[1][2]+m->m[0][2]*m->m[1][1])/det; |
a->m[1][0] = -(m->m[1][0]*m->m[2][2]-m->m[1][2]*m->m[2][0])/det; |
a->m[1][1] = (m->m[0][0]*m->m[2][2]-m->m[0][2]*m->m[2][0])/det; |
a->m[1][2] = -(m->m[0][0]*m->m[1][2]-m->m[0][2]*m->m[1][0])/det; |
a->m[2][0] = (m->m[1][0]*m->m[2][1]-m->m[1][1]*m->m[2][0])/det; |
a->m[2][1] = -(m->m[0][0]*m->m[2][1]-m->m[0][1]*m->m[2][0])/det; |
a->m[2][2] = (m->m[0][0]*m->m[1][1]-m->m[0][1]*m->m[1][0])/det; |
} |
/* vector arithmetic */ |
int gl_V3_Norm(V3 *a) |
{ |
float n; |
n=sqrt(a->X*a->X+a->Y*a->Y+a->Z*a->Z); |
if (n==0) return 1; |
a->X/=n; |
a->Y/=n; |
a->Z/=n; |
return 0; |
} |
V3 gl_V3_New(float x,float y,float z) |
{ |
V3 a; |
a.X=x; |
a.Y=y; |
a.Z=z; |
return a; |
} |
V4 gl_V4_New(float x,float y,float z,float w) |
{ |
V4 a; |
a.X=x; |
a.Y=y; |
a.Z=z; |
a.W=w; |
return a; |
} |
/programs/develop/libraries/TinyGL/src/zmath.h |
---|
0,0 → 1,56 |
#ifndef __ZMATH__ |
#define __ZMATH__ |
/*for menuetlibc*/ |
#define pow powf |
/* Matrix & Vertex */ |
typedef struct { |
float m[4][4]; |
} M4; |
typedef struct { |
float m[3][3]; |
} M3; |
typedef struct { |
float m[3][4]; |
} M34; |
#define X v[0] |
#define Y v[1] |
#define Z v[2] |
#define W v[3] |
typedef struct { |
float v[3]; |
} V3; |
typedef struct { |
float v[4]; |
} V4; |
void gl_M4_Id(M4 *a); |
int gl_M4_IsId(M4 *a); |
void gl_M4_Move(M4 *a,M4 *b); |
void gl_MoveV3(V3 *a,V3 *b); |
void gl_MulM4V3(V3 *a,M4 *b,V3 *c); |
void gl_MulM3V3(V3 *a,M4 *b,V3 *c); |
void gl_M4_MulV4(V4 * a,M4 *b,V4 * c); |
void gl_M4_InvOrtho(M4 *a,M4 b); |
void gl_M4_Inv(M4 *a,M4 *b); |
void gl_M4_Mul(M4 *c,M4 *a,M4 *b); |
void gl_M4_MulLeft(M4 *c,M4 *a); |
void gl_M4_Transpose(M4 *a,M4 *b); |
void gl_M4_Rotate(M4 *c,float t,int u); |
int gl_V3_Norm(V3 *a); |
V3 gl_V3_New(float x,float y,float z); |
V4 gl_V4_New(float x,float y,float z,float w); |
int gl_Matrix_Inv(float *r,float *m,int n); |
#endif /*__ZMATH__*/ |
/programs/develop/libraries/TinyGL/src/ztriangle.c |
---|
0,0 → 1,394 |
#include <stdlib.h> |
#include "zbuffer.h" |
#define ZCMP(z,zpix) ((z) >= (zpix)) |
void ZB_fillTriangleFlat(ZBuffer *zb, |
ZBufferPoint *p0,ZBufferPoint *p1,ZBufferPoint *p2) |
{ |
#if TGL_FEATURE_RENDER_BITS == 24 |
unsigned char colorR, colorG, colorB; |
#else |
int color; |
#endif |
#define INTERP_Z |
#if TGL_FEATURE_RENDER_BITS == 24 |
#define DRAW_INIT() \ |
{ \ |
colorR=p2->r>>8; \ |
colorG=p2->g>>8; \ |
colorB=p2->b>>8; \ |
} |
#define PUT_PIXEL(_a) \ |
{ \ |
zz=z >> ZB_POINT_Z_FRAC_BITS; \ |
if (ZCMP(zz,pz[_a])) { \ |
pp[3 * _a]=colorR;\ |
pp[3 * _a + 1]=colorG;\ |
pp[3 * _a + 2]=colorB;\ |
pz[_a]=zz; \ |
}\ |
z+=dzdx; \ |
} |
#else |
#define DRAW_INIT() \ |
{ \ |
color=RGB_TO_PIXEL(p2->r,p2->g,p2->b); \ |
} |
#define PUT_PIXEL(_a) \ |
{ \ |
zz=z >> ZB_POINT_Z_FRAC_BITS; \ |
if (ZCMP(zz,pz[_a])) { \ |
pp[_a]=color; \ |
pz[_a]=zz; \ |
} \ |
z+=dzdx; \ |
} |
#endif /* TGL_FEATURE_RENDER_BITS == 24 */ |
#include "ztriangle.h" |
} |
/* |
* Smooth filled triangle. |
* The code below is very tricky :) |
*/ |
void ZB_fillTriangleSmooth(ZBuffer *zb, |
ZBufferPoint *p0,ZBufferPoint *p1,ZBufferPoint *p2) |
{ |
#if TGL_FEATURE_RENDER_BITS == 16 |
int _drgbdx; |
#endif |
#define INTERP_Z |
#define INTERP_RGB |
#define SAR_RND_TO_ZERO(v,n) (v / (1<<n)) |
#if TGL_FEATURE_RENDER_BITS == 24 |
#define DRAW_INIT() \ |
{ \ |
} |
#define PUT_PIXEL(_a) \ |
{ \ |
zz=z >> ZB_POINT_Z_FRAC_BITS; \ |
if (ZCMP(zz,pz[_a])) { \ |
pp[3 * _a]=or1 >> 8;\ |
pp[3 * _a + 1]=og1 >> 8;\ |
pp[3 * _a + 2]=ob1 >> 8;\ |
pz[_a]=zz; \ |
}\ |
z+=dzdx; \ |
og1+=dgdx; \ |
or1+=drdx; \ |
ob1+=dbdx; \ |
} |
#elif TGL_FEATURE_RENDER_BITS == 16 |
#define DRAW_INIT() \ |
{ \ |
_drgbdx=(SAR_RND_TO_ZERO(drdx,6) << 22) & 0xFFC00000; \ |
_drgbdx|=SAR_RND_TO_ZERO(dgdx,5) & 0x000007FF; \ |
_drgbdx|=(SAR_RND_TO_ZERO(dbdx,7) << 12) & 0x001FF000; \ |
} |
#define PUT_PIXEL(_a) \ |
{ \ |
zz=z >> ZB_POINT_Z_FRAC_BITS; \ |
if (ZCMP(zz,pz[_a])) { \ |
tmp=rgb & 0xF81F07E0; \ |
pp[_a]=tmp | (tmp >> 16); \ |
pz[_a]=zz; \ |
} \ |
z+=dzdx; \ |
rgb=(rgb+drgbdx) & ( ~ 0x00200800); \ |
} |
#define DRAW_LINE() \ |
{ \ |
register unsigned short *pz; \ |
register PIXEL *pp; \ |
register unsigned int tmp,z,zz,rgb,drgbdx; \ |
register int n; \ |
n=(x2 >> 16) - x1; \ |
pp=pp1+x1; \ |
pz=pz1+x1; \ |
z=z1; \ |
rgb=(r1 << 16) & 0xFFC00000; \ |
rgb|=(g1 >> 5) & 0x000007FF; \ |
rgb|=(b1 << 5) & 0x001FF000; \ |
drgbdx=_drgbdx; \ |
while (n>=3) { \ |
PUT_PIXEL(0); \ |
PUT_PIXEL(1); \ |
PUT_PIXEL(2); \ |
PUT_PIXEL(3); \ |
pz+=4; \ |
pp+=4; \ |
n-=4; \ |
} \ |
while (n>=0) { \ |
PUT_PIXEL(0); \ |
pz+=1; \ |
pp+=1; \ |
n-=1; \ |
} \ |
} |
#else |
#define DRAW_INIT() \ |
{ \ |
} |
#define PUT_PIXEL(_a) \ |
{ \ |
zz=z >> ZB_POINT_Z_FRAC_BITS; \ |
if (ZCMP(zz,pz[_a])) { \ |
pp[_a] = RGB_TO_PIXEL(or1, og1, ob1);\ |
pz[_a]=zz; \ |
}\ |
z+=dzdx; \ |
og1+=dgdx; \ |
or1+=drdx; \ |
ob1+=dbdx; \ |
} |
#endif /* TGL_FEATURE_RENDER_BITS */ |
#include "ztriangle.h" |
} |
void ZB_setTexture(ZBuffer *zb,PIXEL *texture) |
{ |
zb->current_texture=texture; |
} |
void ZB_fillTriangleMapping(ZBuffer *zb, |
ZBufferPoint *p0,ZBufferPoint *p1,ZBufferPoint *p2) |
{ |
PIXEL *texture; |
#define INTERP_Z |
#define INTERP_ST |
#define DRAW_INIT() \ |
{ \ |
texture=zb->current_texture; \ |
} |
#if TGL_FEATURE_RENDER_BITS == 24 |
#define PUT_PIXEL(_a) \ |
{ \ |
unsigned char *ptr;\ |
zz=z >> ZB_POINT_Z_FRAC_BITS; \ |
if (ZCMP(zz,pz[_a])) { \ |
ptr = texture + (((t & 0x3FC00000) | s) >> 14) * 3; \ |
pp[3 * _a]= ptr[0];\ |
pp[3 * _a + 1]= ptr[1];\ |
pp[3 * _a + 2]= ptr[2];\ |
pz[_a]=zz; \ |
} \ |
z+=dzdx; \ |
s+=dsdx; \ |
t+=dtdx; \ |
} |
#else |
#define PUT_PIXEL(_a) \ |
{ \ |
zz=z >> ZB_POINT_Z_FRAC_BITS; \ |
if (ZCMP(zz,pz[_a])) { \ |
pp[_a]=texture[((t & 0x3FC00000) | s) >> 14]; \ |
pz[_a]=zz; \ |
} \ |
z+=dzdx; \ |
s+=dsdx; \ |
t+=dtdx; \ |
} |
#endif |
#include "ztriangle.h" |
} |
/* |
* Texture mapping with perspective correction. |
* We use the gradient method to make less divisions. |
* TODO: pipeline the division |
*/ |
#if 1 |
void ZB_fillTriangleMappingPerspective(ZBuffer *zb, |
ZBufferPoint *p0,ZBufferPoint *p1,ZBufferPoint *p2) |
{ |
PIXEL *texture; |
float fdzdx,fndzdx,ndszdx,ndtzdx; |
#define INTERP_Z |
#define INTERP_STZ |
#define NB_INTERP 8 |
#define DRAW_INIT() \ |
{ \ |
texture=zb->current_texture;\ |
fdzdx=(float)dzdx;\ |
fndzdx=NB_INTERP * fdzdx;\ |
ndszdx=NB_INTERP * dszdx;\ |
ndtzdx=NB_INTERP * dtzdx;\ |
} |
#if TGL_FEATURE_RENDER_BITS == 24 |
#define PUT_PIXEL(_a) \ |
{ \ |
unsigned char *ptr;\ |
zz=z >> ZB_POINT_Z_FRAC_BITS; \ |
if (ZCMP(zz,pz[_a])) { \ |
ptr = texture + (((t & 0x3FC00000) | (s & 0x003FC000)) >> 14) * 3;\ |
pp[3 * _a]= ptr[0];\ |
pp[3 * _a + 1]= ptr[1];\ |
pp[3 * _a + 2]= ptr[2];\ |
pz[_a]=zz; \ |
} \ |
z+=dzdx; \ |
s+=dsdx; \ |
t+=dtdx; \ |
} |
#else |
#define PUT_PIXEL(_a) \ |
{ \ |
zz=z >> ZB_POINT_Z_FRAC_BITS; \ |
if (ZCMP(zz,pz[_a])) { \ |
pp[_a]=*(PIXEL *)((char *)texture+ \ |
(((t & 0x3FC00000) | (s & 0x003FC000)) >> (17 - PSZSH)));\ |
pz[_a]=zz; \ |
} \ |
z+=dzdx; \ |
s+=dsdx; \ |
t+=dtdx; \ |
} |
#endif |
#define DRAW_LINE() \ |
{ \ |
register unsigned short *pz; \ |
register PIXEL *pp; \ |
register unsigned int s,t,z,zz; \ |
register int n,dsdx,dtdx; \ |
float sz,tz,fz,zinv; \ |
n=(x2>>16)-x1; \ |
fz=(float)z1;\ |
zinv=1.0 / fz;\ |
pp=(PIXEL *)((char *)pp1 + x1 * PSZB); \ |
pz=pz1+x1; \ |
z=z1; \ |
sz=sz1;\ |
tz=tz1;\ |
while (n>=(NB_INTERP-1)) { \ |
{\ |
float ss,tt;\ |
ss=(sz * zinv);\ |
tt=(tz * zinv);\ |
s=(int) ss;\ |
t=(int) tt;\ |
dsdx= (int)( (dszdx - ss*fdzdx)*zinv );\ |
dtdx= (int)( (dtzdx - tt*fdzdx)*zinv );\ |
fz+=fndzdx;\ |
zinv=1.0 / fz;\ |
}\ |
PUT_PIXEL(0); \ |
PUT_PIXEL(1); \ |
PUT_PIXEL(2); \ |
PUT_PIXEL(3); \ |
PUT_PIXEL(4); \ |
PUT_PIXEL(5); \ |
PUT_PIXEL(6); \ |
PUT_PIXEL(7); \ |
pz+=NB_INTERP; \ |
pp=(PIXEL *)((char *)pp + NB_INTERP * PSZB);\ |
n-=NB_INTERP; \ |
sz+=ndszdx;\ |
tz+=ndtzdx;\ |
} \ |
{\ |
float ss,tt;\ |
ss=(sz * zinv);\ |
tt=(tz * zinv);\ |
s=(int) ss;\ |
t=(int) tt;\ |
dsdx= (int)( (dszdx - ss*fdzdx)*zinv );\ |
dtdx= (int)( (dtzdx - tt*fdzdx)*zinv );\ |
}\ |
while (n>=0) { \ |
PUT_PIXEL(0); \ |
pz+=1; \ |
pp=(PIXEL *)((char *)pp + PSZB);\ |
n-=1; \ |
} \ |
} |
#include "ztriangle.h" |
} |
#endif |
#if 0 |
/* slow but exact version (only there for reference, incorrect for 24 |
bits) */ |
void ZB_fillTriangleMappingPerspective(ZBuffer *zb, |
ZBufferPoint *p0,ZBufferPoint *p1,ZBufferPoint *p2) |
{ |
PIXEL *texture; |
#define INTERP_Z |
#define INTERP_STZ |
#define DRAW_INIT() \ |
{ \ |
texture=zb->current_texture; \ |
} |
#define PUT_PIXEL(_a) \ |
{ \ |
float zinv; \ |
int s,t; \ |
zz=z >> ZB_POINT_Z_FRAC_BITS; \ |
if (ZCMP(zz,pz[_a])) { \ |
zinv= 1.0 / (float) z; \ |
s= (int) (sz * zinv); \ |
t= (int) (tz * zinv); \ |
pp[_a]=texture[((t & 0x3FC00000) | s) >> 14]; \ |
pz[_a]=zz; \ |
} \ |
z+=dzdx; \ |
sz+=dszdx; \ |
tz+=dtzdx; \ |
} |
#include "ztriangle.h" |
} |
#endif |
/programs/develop/libraries/TinyGL/src/ztriangle.h |
---|
0,0 → 1,363 |
/* |
* We draw a triangle with various interpolations |
*/ |
{ |
ZBufferPoint *t,*pr1,*pr2,*l1,*l2; |
float fdx1, fdx2, fdy1, fdy2, fz, d1, d2; |
unsigned short *pz1; |
PIXEL *pp1; |
int part,update_left,update_right; |
int nb_lines,dx1,dy1,tmp,dx2,dy2; |
int error,derror; |
int x1,dxdy_min,dxdy_max; |
/* warning: x2 is multiplied by 2^16 */ |
int x2,dx2dy2; |
#ifdef INTERP_Z |
int z1,dzdx,dzdy,dzdl_min,dzdl_max; |
#endif |
#ifdef INTERP_RGB |
int r1,drdx,drdy,drdl_min,drdl_max; |
int g1,dgdx,dgdy,dgdl_min,dgdl_max; |
int b1,dbdx,dbdy,dbdl_min,dbdl_max; |
#endif |
#ifdef INTERP_ST |
int s1,dsdx,dsdy,dsdl_min,dsdl_max; |
int t1,dtdx,dtdy,dtdl_min,dtdl_max; |
#endif |
#ifdef INTERP_STZ |
float sz1,dszdx,dszdy,dszdl_min,dszdl_max; |
float tz1,dtzdx,dtzdy,dtzdl_min,dtzdl_max; |
#endif |
/* we sort the vertex with increasing y */ |
if (p1->y < p0->y) { |
t = p0; |
p0 = p1; |
p1 = t; |
} |
if (p2->y < p0->y) { |
t = p2; |
p2 = p1; |
p1 = p0; |
p0 = t; |
} else if (p2->y < p1->y) { |
t = p1; |
p1 = p2; |
p2 = t; |
} |
/* we compute dXdx and dXdy for all interpolated values */ |
fdx1 = p1->x - p0->x; |
fdy1 = p1->y - p0->y; |
fdx2 = p2->x - p0->x; |
fdy2 = p2->y - p0->y; |
fz = fdx1 * fdy2 - fdx2 * fdy1; |
if (fz == 0) |
return; |
fz = 1.0 / fz; |
fdx1 *= fz; |
fdy1 *= fz; |
fdx2 *= fz; |
fdy2 *= fz; |
#ifdef INTERP_Z |
d1 = p1->z - p0->z; |
d2 = p2->z - p0->z; |
dzdx = (int) (fdy2 * d1 - fdy1 * d2); |
dzdy = (int) (fdx1 * d2 - fdx2 * d1); |
#endif |
#ifdef INTERP_RGB |
d1 = p1->r - p0->r; |
d2 = p2->r - p0->r; |
drdx = (int) (fdy2 * d1 - fdy1 * d2); |
drdy = (int) (fdx1 * d2 - fdx2 * d1); |
d1 = p1->g - p0->g; |
d2 = p2->g - p0->g; |
dgdx = (int) (fdy2 * d1 - fdy1 * d2); |
dgdy = (int) (fdx1 * d2 - fdx2 * d1); |
d1 = p1->b - p0->b; |
d2 = p2->b - p0->b; |
dbdx = (int) (fdy2 * d1 - fdy1 * d2); |
dbdy = (int) (fdx1 * d2 - fdx2 * d1); |
#endif |
#ifdef INTERP_ST |
d1 = p1->s - p0->s; |
d2 = p2->s - p0->s; |
dsdx = (int) (fdy2 * d1 - fdy1 * d2); |
dsdy = (int) (fdx1 * d2 - fdx2 * d1); |
d1 = p1->t - p0->t; |
d2 = p2->t - p0->t; |
dtdx = (int) (fdy2 * d1 - fdy1 * d2); |
dtdy = (int) (fdx1 * d2 - fdx2 * d1); |
#endif |
#ifdef INTERP_STZ |
{ |
float zz; |
zz=(float) p0->z; |
p0->sz= (float) p0->s * zz; |
p0->tz= (float) p0->t * zz; |
zz=(float) p1->z; |
p1->sz= (float) p1->s * zz; |
p1->tz= (float) p1->t * zz; |
zz=(float) p2->z; |
p2->sz= (float) p2->s * zz; |
p2->tz= (float) p2->t * zz; |
d1 = p1->sz - p0->sz; |
d2 = p2->sz - p0->sz; |
dszdx = (fdy2 * d1 - fdy1 * d2); |
dszdy = (fdx1 * d2 - fdx2 * d1); |
d1 = p1->tz - p0->tz; |
d2 = p2->tz - p0->tz; |
dtzdx = (fdy2 * d1 - fdy1 * d2); |
dtzdy = (fdx1 * d2 - fdx2 * d1); |
} |
#endif |
/* screen coordinates */ |
pp1 = (PIXEL *) ((char *) zb->pbuf + zb->linesize * p0->y); |
pz1 = zb->zbuf + p0->y * zb->xsize; |
DRAW_INIT(); |
for(part=0;part<2;part++) { |
if (part == 0) { |
if (fz > 0) { |
update_left=1; |
update_right=1; |
l1=p0; |
l2=p2; |
pr1=p0; |
pr2=p1; |
} else { |
update_left=1; |
update_right=1; |
l1=p0; |
l2=p1; |
pr1=p0; |
pr2=p2; |
} |
nb_lines = p1->y - p0->y; |
} else { |
/* second part */ |
if (fz > 0) { |
update_left=0; |
update_right=1; |
pr1=p1; |
pr2=p2; |
} else { |
update_left=1; |
update_right=0; |
l1=p1; |
l2=p2; |
} |
nb_lines = p2->y - p1->y + 1; |
} |
/* compute the values for the left edge */ |
if (update_left) { |
dy1 = l2->y - l1->y; |
dx1 = l2->x - l1->x; |
if (dy1 > 0) |
tmp = (dx1 << 16) / dy1; |
else |
tmp = 0; |
x1 = l1->x; |
error = 0; |
derror = tmp & 0x0000ffff; |
dxdy_min = tmp >> 16; |
dxdy_max = dxdy_min + 1; |
#ifdef INTERP_Z |
z1=l1->z; |
dzdl_min=(dzdy + dzdx * dxdy_min); |
dzdl_max=dzdl_min + dzdx; |
#endif |
#ifdef INTERP_RGB |
r1=l1->r; |
drdl_min=(drdy + drdx * dxdy_min); |
drdl_max=drdl_min + drdx; |
g1=l1->g; |
dgdl_min=(dgdy + dgdx * dxdy_min); |
dgdl_max=dgdl_min + dgdx; |
b1=l1->b; |
dbdl_min=(dbdy + dbdx * dxdy_min); |
dbdl_max=dbdl_min + dbdx; |
#endif |
#ifdef INTERP_ST |
s1=l1->s; |
dsdl_min=(dsdy + dsdx * dxdy_min); |
dsdl_max=dsdl_min + dsdx; |
t1=l1->t; |
dtdl_min=(dtdy + dtdx * dxdy_min); |
dtdl_max=dtdl_min + dtdx; |
#endif |
#ifdef INTERP_STZ |
sz1=l1->sz; |
dszdl_min=(dszdy + dszdx * dxdy_min); |
dszdl_max=dszdl_min + dszdx; |
tz1=l1->tz; |
dtzdl_min=(dtzdy + dtzdx * dxdy_min); |
dtzdl_max=dtzdl_min + dtzdx; |
#endif |
} |
/* compute values for the right edge */ |
if (update_right) { |
dx2 = (pr2->x - pr1->x); |
dy2 = (pr2->y - pr1->y); |
if (dy2>0) |
dx2dy2 = ( dx2 << 16) / dy2; |
else |
dx2dy2 = 0; |
x2 = pr1->x << 16; |
} |
/* we draw all the scan line of the part */ |
while (nb_lines>0) { |
nb_lines--; |
#ifndef DRAW_LINE |
/* generic draw line */ |
{ |
register PIXEL *pp; |
register int n; |
#ifdef INTERP_Z |
register unsigned short *pz; |
register unsigned int z,zz; |
#endif |
#ifdef INTERP_RGB |
register unsigned int or1,og1,ob1; |
#endif |
#ifdef INTERP_ST |
register unsigned int s,t; |
#endif |
#ifdef INTERP_STZ |
float sz,tz; |
#endif |
n=(x2 >> 16) - x1; |
pp=(PIXEL *)((char *)pp1 + x1 * PSZB); |
#ifdef INTERP_Z |
pz=pz1+x1; |
z=z1; |
#endif |
#ifdef INTERP_RGB |
or1 = r1; |
og1 = g1; |
ob1 = b1; |
#endif |
#ifdef INTERP_ST |
s=s1; |
t=t1; |
#endif |
#ifdef INTERP_STZ |
sz=sz1; |
tz=tz1; |
#endif |
while (n>=3) { |
PUT_PIXEL(0); |
PUT_PIXEL(1); |
PUT_PIXEL(2); |
PUT_PIXEL(3); |
#ifdef INTERP_Z |
pz+=4; |
#endif |
pp=(PIXEL *)((char *)pp + 4 * PSZB); |
n-=4; |
} |
while (n>=0) { |
PUT_PIXEL(0); |
#ifdef INTERP_Z |
pz+=1; |
#endif |
pp=(PIXEL *)((char *)pp + PSZB); |
n-=1; |
} |
} |
#else |
DRAW_LINE(); |
#endif |
/* left edge */ |
error+=derror; |
if (error > 0) { |
error-=0x10000; |
x1+=dxdy_max; |
#ifdef INTERP_Z |
z1+=dzdl_max; |
#endif |
#ifdef INTERP_RGB |
r1+=drdl_max; |
g1+=dgdl_max; |
b1+=dbdl_max; |
#endif |
#ifdef INTERP_ST |
s1+=dsdl_max; |
t1+=dtdl_max; |
#endif |
#ifdef INTERP_STZ |
sz1+=dszdl_max; |
tz1+=dtzdl_max; |
#endif |
} else { |
x1+=dxdy_min; |
#ifdef INTERP_Z |
z1+=dzdl_min; |
#endif |
#ifdef INTERP_RGB |
r1+=drdl_min; |
g1+=dgdl_min; |
b1+=dbdl_min; |
#endif |
#ifdef INTERP_ST |
s1+=dsdl_min; |
t1+=dtdl_min; |
#endif |
#ifdef INTERP_STZ |
sz1+=dszdl_min; |
tz1+=dtzdl_min; |
#endif |
} |
/* right edge */ |
x2+=dx2dy2; |
/* screen coordinates */ |
pp1=(PIXEL *)((char *)pp1 + zb->linesize); |
pz1+=zb->xsize; |
} |
} |
} |
#undef INTERP_Z |
#undef INTERP_RGB |
#undef INTERP_ST |
#undef INTERP_STZ |
#undef DRAW_INIT |
#undef DRAW_LINE |
#undef PUT_PIXEL |
/programs/develop/libraries/base64/Tupfile.lua |
---|
0,0 → 1,2 |
if tup.getconfig("NO_GCC") ~= "" then return end |
tup.rule("base64.c", "kos32-gcc -fno-ident -Os -c -o %o %f " .. tup.getconfig("KPACK_CMD"), "base64.obj") |
/programs/develop/libraries/box_lib/asm/trunk/Tupfile.lua |
---|
0,0 → 1,2 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.foreach_rule({"ctrldemo.asm", "editbox_ex.asm"}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "%B") |
/programs/develop/libraries/box_lib/trunk/Tupfile.lua |
---|
0,0 → 1,2 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("box_lib.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "box_lib.obj") |
/programs/develop/libraries/buf2d/trunk/Tupfile.lua |
---|
0,0 → 1,2 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("buf2d.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "buf2d.obj") |
/programs/develop/libraries/buf2d/trunk/examples/Tupfile.lua |
---|
0,0 → 1,2 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.foreach_rule("*.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "%B") |
/programs/develop/libraries/charset/Tupfile.lua |
---|
0,0 → 1,2 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("charset.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "charset.obj") |
/programs/develop/libraries/console/Tupfile.lua |
---|
0,0 → 1,2 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("console.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "console.obj") |
/programs/develop/libraries/console/examples/Tupfile.lua |
---|
0,0 → 1,2 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.foreach_rule("*.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "%B") |
/programs/develop/libraries/crypt_des/example/Tupfile.lua |
---|
0,0 → 1,2 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("crypt_files.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "crypt_files") |
/programs/develop/libraries/crypt_des/trunk/Tupfile.lua |
---|
0,0 → 1,2 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("crypt_des.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "crypt_des.obj") |
/programs/develop/libraries/exif/examples/Tupfile.lua |
---|
0,0 → 1,2 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("viev_exif.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "viev_exif") |
/programs/develop/libraries/exif/trunk/Tupfile.lua |
---|
0,0 → 1,2 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("exif.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "exif.obj") |
/programs/develop/libraries/fontslib/trunk/Tupfile.lua |
---|
0,0 → 1,3 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("font_.asm", "fasm %f %o", "font01.ksf") |
tup.rule("fonts_lib.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "fonts_lib.obj") |
/programs/develop/libraries/gblib/Tupfile.lua |
---|
0,0 → 1,2 |
if tup.getconfig("NO_GCC") ~= "" then return end |
tup.rule("gblib.c", "kos32-gcc -fno-ident -Os -c -o %o %f " .. tup.getconfig("KPACK_CMD"), "gblib.obj") |
/programs/develop/libraries/gblib/example/Tupfile.lua |
---|
0,0 → 1,7 |
if tup.getconfig("NO_FASM") ~= "" or tup.getconfig("NO_GCC") ~= "" then return end |
HELPERDIR = (tup.getconfig("HELPERDIR") == "") and "../../../.." or tup.getconfig("HELPERDIR") |
tup.include(HELPERDIR .. "/use_gcc.lua") |
LDFLAGS = LDFLAGS .. " -T kolibri.ld" |
tup.append_table(OBJS, tup.rule("asm_code.asm", "fasm %f %o", "asm_code.o")) |
compile_gcc{"example.c", "system/kolibri.c", "system/stdlib.c", "system/string.c"} |
link_gcc("example") |
/programs/develop/libraries/gblib/example/gblib.h |
---|
1,11 → 1,13 |
#pragma pack(push, 1) |
typedef struct |
{ |
int w __attribute__((packed)); |
int h __attribute__((packed)); |
char *bmp __attribute__((packed)); |
char *alpha __attribute__((packed)); |
} GB_BMP __attribute__((packed)); |
int w; |
int h; |
char *bmp; |
char *alpha; |
} GB_BMP; |
#pragma pack(pop) |
void (* __stdcall gb_pixel_set)(GB_BMP *b, int x, int y, unsigned c); |
/programs/develop/libraries/gblib/example/kolibri.ld |
---|
17,4 → 17,8 |
*(.bss) |
} |
Memory = . ; |
/DISCARD/ : { |
*(.comment) |
*(.drectve) |
} |
} |
/programs/develop/libraries/gblib/example/system/kolibri.h |
---|
1,38 → 1,40 |
#define NULL ((void*)0) |
#pragma pack(push, 1) |
typedef struct |
{ |
unsigned p00 __attribute__((packed)); |
unsigned p04 __attribute__((packed)); |
unsigned p08 __attribute__((packed)); |
unsigned p12 __attribute__((packed)); |
unsigned p16 __attribute__((packed)); |
char p20 __attribute__((packed)); |
char *p21 __attribute__((packed)); |
} kol_struct70 __attribute__((packed)); |
unsigned p00; |
unsigned p04; |
unsigned p08; |
unsigned p12; |
unsigned p16; |
char p20; |
char *p21; |
} kol_struct70; |
typedef struct |
{ |
unsigned p00 __attribute__((packed)); |
char p04 __attribute__((packed)); |
char p05[3] __attribute__((packed)); |
unsigned p08 __attribute__((packed)); |
unsigned p12 __attribute__((packed)); |
unsigned p16 __attribute__((packed)); |
unsigned p20 __attribute__((packed)); |
unsigned p24 __attribute__((packed)); |
unsigned p28 __attribute__((packed)); |
unsigned p32[2] __attribute__((packed)); |
unsigned p40 __attribute__((packed)); |
} kol_struct_BDVK __attribute__((packed)); |
unsigned p00; |
char p04; |
char p05[3]; |
unsigned p08; |
unsigned p12; |
unsigned p16; |
unsigned p20; |
unsigned p24; |
unsigned p28; |
unsigned p32[2]; |
unsigned p40; |
} kol_struct_BDVK; |
typedef struct |
{ |
char *name __attribute__((packed)); |
void *data __attribute__((packed)); |
} kol_struct_import __attribute__((packed)); |
char *name; |
void *data; |
} kol_struct_import; |
#pragma pack(pop) |
void kol_exit(); |
/programs/develop/libraries/http/Tupfile.lua |
---|
0,0 → 1,2 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("http.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "http.obj") |
/programs/develop/libraries/http/examples/Tupfile.lua |
---|
0,0 → 1,2 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.foreach_rule("*.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "%B") |
/programs/develop/libraries/iconv/Tupfile.lua |
---|
0,0 → 1,2 |
if tup.getconfig("NO_GCC") ~= "" then return end |
tup.rule("iconv.c", "kos32-gcc -fno-ident -Os -c -o %o %f " .. tup.getconfig("KPACK_CMD"), "iconv.obj") |
/programs/develop/libraries/iconv/iconv.c |
---|
1,5 → 1,7 |
#include <string.h> |
#include <stdio.h> |
//#include <string.h> |
//#include <stdio.h> |
typedef unsigned int size_t; |
#define NULL ((void*)0) |
typedef int conv_t; |
typedef unsigned int ucs4_t; |
/programs/develop/libraries/libcrash/trunk/Tupfile.lua |
---|
0,0 → 1,3 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("libcrash.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "libcrash.obj") |
tup.rule("crashtest.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "crashtest") |
/programs/develop/libraries/libs-dev/libgfx/Tupfile.lua |
---|
0,0 → 1,2 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("libgfx.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "libgfx.obj") |
/programs/develop/libraries/libs-dev/libimg/Tupfile.lua |
---|
0,0 → 1,2 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("libimg.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "libimg.obj") |
/programs/develop/libraries/libs-dev/libini/Tupfile.lua |
---|
0,0 → 1,2 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("libini.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "libini.obj") |
/programs/develop/libraries/libs-dev/libio/Tupfile.lua |
---|
0,0 → 1,2 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("libio.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "libio.obj") |
/programs/develop/libraries/menuetlibc/programs/Makefile |
---|
File deleted |
/programs/develop/libraries/menuetlibc/programs/htmlview/html.h |
---|
File deleted |
/programs/develop/libraries/menuetlibc/programs/htmlview/parser.cpp |
---|
File deleted |
/programs/develop/libraries/menuetlibc/programs/htmlview/Makefile |
---|
File deleted |
/programs/develop/libraries/menuetlibc/programs/htmlview/textstreamparser.cpp |
---|
File deleted |
/programs/develop/libraries/menuetlibc/programs/htmlview/parser.h |
---|
File deleted |
/programs/develop/libraries/menuetlibc/programs/htmlview/html.cpp |
---|
File deleted |
/programs/develop/libraries/menuetlibc/programs/htmlview/pagebuffer.cpp |
---|
File deleted |
/programs/develop/libraries/menuetlibc/programs/htmlview/copying |
---|
File deleted |
/programs/develop/libraries/menuetlibc/programs/htmlview/filestreamparser.cpp |
---|
File deleted |
/programs/develop/libraries/menuetlibc/programs/binclock/main.c |
---|
File deleted |
\ No newline at end of file |
/programs/develop/libraries/menuetlibc/programs/binclock/Makefile |
---|
File deleted |
/programs/develop/libraries/menuetlibc/programs/ld-dll.old/loader.h |
---|
File deleted |
/programs/develop/libraries/menuetlibc/programs/ld-dll.old/Makefile |
---|
File deleted |
/programs/develop/libraries/menuetlibc/programs/ld-dll.old/kernel.c |
---|
File deleted |
/programs/develop/libraries/menuetlibc/programs/ld-dll.old/ld-dll.map |
---|
File deleted |
/programs/develop/libraries/menuetlibc/programs/ld-dll.old/main.c |
---|
File deleted |
/programs/develop/libraries/menuetlibc/programs/ld-dll.old/dll_list.c |
---|
File deleted |
/programs/develop/libraries/menuetlibc/programs/ld-dll.old/load.map |
---|
File deleted |
/programs/develop/libraries/menuetlibc/programs/multiview/Makefile |
---|
File deleted |
/programs/develop/libraries/menuetlibc/programs/multiview/test.jpg |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Deleted: svn:mime-type |
-application/octet-stream |
\ No newline at end of property |
/programs/develop/libraries/menuetlibc/programs/multiview/main.c |
---|
File deleted |
/programs/develop/libraries/menuetlibc/programs/contemp/Makefile |
---|
File deleted |
/programs/develop/libraries/menuetlibc/programs/contemp/main.c |
---|
File deleted |
/programs/develop/libraries/menuetlibc/programs/rwtest/Makefile |
---|
File deleted |
/programs/develop/libraries/menuetlibc/programs/rwtest/test.c |
---|
File deleted |
/programs/develop/libraries/menuetlibc/programs/ld-dll/Makefile |
---|
File deleted |
/programs/develop/libraries/menuetlibc/programs/ld-dll/ld-dll.h |
---|
File deleted |
/programs/develop/libraries/menuetlibc/programs/ld-dll/dll_desc.h |
---|
File deleted |
/programs/develop/libraries/menuetlibc/programs/ld-dll/kernel.c |
---|
File deleted |
/programs/develop/libraries/menuetlibc/programs/ld-dll/main.c |
---|
File deleted |
/programs/develop/libraries/menuetlibc/programs/ld-dll/dll_list.c |
---|
File deleted |
/programs/develop/libraries/menuetlibc/programs/plaympg/Makefile |
---|
File deleted |
/programs/develop/libraries/menuetlibc/programs/plaympg/main.c |
---|
File deleted |
/programs/develop/libraries/menuetlibc/Makefile |
---|
11,7 → 11,6 |
make -C src depend |
make -C src |
make -C stub |
make -C programs |
genconfig: |
ifdef ON_MINGW |
24,5 → 23,4 |
make -C src clean |
make -C linuxtools clean |
make -C stub clean |
make -C programs clean |
$(RM) mkversion$(EXESUFFIX) |
/programs/develop/libraries/menuetlibc/Tupfile.lua |
---|
0,0 → 1,6 |
if tup.getconfig("TUP_PLATFORM") == "win32" |
-- on win32 '#' is not a special character, but backslash and quotes would be printed as is |
then tup.rule('echo #define NEEDS_UNDERSCORES > %o', {"config.h"}) |
-- on unix '#' should be escaped |
else tup.rule('echo "#define NEEDS_UNDERSCORES" > %o', {"config.h"}) |
end |
/programs/develop/libraries/menuetlibc/include/libm/math.h |
---|
167,7 → 167,7 |
extern double j1 __P((double)); |
extern double jn __P((int, double)); |
extern double lgamma __P((double)); |
extern double nan __P((void)); |
extern double nan __P((const char*)); |
extern double y0 __P((double)); |
extern double y1 __P((double)); |
extern double yn __P((int, double)); |
187,7 → 187,7 |
extern double pow10 __P((double)); |
extern double pow2 __P((double)); |
extern double powi __P((double, int)); |
extern void sincos __P((double *, double *, double)); |
extern void sincos __P((double, double *, double *)); |
extern double remainder __P((double, double)); |
extern double scalb __P((double, double)); |
263,7 → 263,7 |
extern float j1f __P((float)); |
extern float jnf __P((int, float)); |
extern float lgammaf __P((float)); |
extern float nanf __P((void)); |
extern float nanf __P((const char*)); |
extern float y0f __P((float)); |
extern float y1f __P((float)); |
extern float ynf __P((int, float)); |
/programs/develop/libraries/menuetlibc/include/math.h |
---|
74,7 → 74,7 |
double pow10(double _x); |
double pow2(double _x); |
double powi(double, int); |
void sincos(double *, double *, double); |
void sincos(double, double *, double *); |
/* These are in libm.a (Cygnus). You must link -lm to get these */ |
/* See libm/math.h for comments */ |
100,7 → 100,7 |
extern double j1(double); |
extern double jn(int, double); |
extern double lgamma(double); |
extern double nan(void); |
extern double nan(const char*); |
extern double y0(double); |
extern double y1(double); |
extern double yn(int, double); |
152,7 → 152,7 |
extern float j1f(float); |
extern float jnf(int, float); |
extern float lgammaf(float); |
extern float nanf(void); |
extern float nanf(const char*); |
extern float y0f(float); |
extern float y1f(float); |
extern float ynf(int, float); |
/programs/develop/libraries/menuetlibc/include/scripts/menuetos_app_v01.ld |
---|
5,6 → 5,7 |
.text 0x000000 : |
{ |
code = . ; _code = . ; |
*(.A) |
*(.text) |
*(.fixup) |
*(.gnu.warning) |
43,6 → 44,24 |
{ |
*(.bss) |
} |
end = . ; _end = . ; |
end = . ; _end = . ; ___memsize = . ; |
/DISCARD/ : |
{ |
*(.debug$S) |
*(.debug$T) |
*(.debug$F) |
*(.drectve) |
*(.note.GNU-stack) |
*(.eh_frame) |
*(.comment) |
*(.debug_abbrev) |
*(.debug_info) |
*(.debug_line) |
*(.debug_frame) |
*(.debug_loc) |
*(.debug_pubnames) |
*(.debug_aranges) |
*(.debug_ranges) |
} |
} |
/programs/develop/libraries/menuetlibc/include/string.h |
---|
49,8 → 49,8 |
#include <sys/movedata.h> |
int bcmp(const void *_ptr1, const void *_ptr2, int _length); |
void * bcopy(const void *_a, void *_b, size_t _len); |
void * bzero(void *ptr, size_t _len); |
void bcopy(const void *_a, void *_b, size_t _len); |
void bzero(void *ptr, size_t _len); |
int ffs(int _mask); |
char * index(const char *_string, int _c); |
void * memccpy(void *_to, const void *_from, int c, size_t n); |
/programs/develop/libraries/menuetlibc/src/libc/Tupfile.lua |
---|
0,0 → 1,85 |
if tup.getconfig("NO_GCC") ~= "" then return end |
FOLDERS = { |
"ansi/assert", |
"ansi/ctype", |
"ansi/errno", |
"ansi/locale", |
"ansi/math", |
"ansi/setjmp", |
"ansi/stdio", |
"ansi/stdlib", |
"ansi/string", |
"ansi/time", |
"ansif", |
"compat/bsd", |
"compat/io", |
"compat/math", |
"compat/mman", |
"compat/mntent", |
"compat/search", |
"compat/signal", |
"compat/stdio", |
"compat/stdlib", |
"compat/string", |
"compat/sys/resource", |
"compat/sys/stat", |
"compat/sys/vfs", |
"compat/termios", |
"compat/time", |
"compat/unistd", |
"compat/v1", |
"crt0", |
"dos/compat", |
"dos/dir", |
"dos/dos", |
"dos/dos_emu", |
"dos/errno", |
"dos/io", |
"dos/process", |
"dos/sys/timeb", |
"fsext", |
"menuetos", |
"net", |
"pc_hw/cpu", |
"pc_hw/endian", |
"pc_hw/farptr", |
"pc_hw/fpu", |
"pc_hw/hwint", |
"pc_hw/kb", |
"pc_hw/mem", |
"pc_hw/sound", |
"pc_hw/timer", |
"posix/dirent", |
"posix/fcntl", |
"posix/fnmatch", |
"posix/glob", |
"posix/grp", |
-- "posix/regex", -- not compilable |
"posix/pwd", |
"posix/setjmp", |
"posix/signal", |
"posix/stdio", |
"posix/sys/stat", |
"posix/sys/times", |
"posix/sys/wait", |
"posix/unistd", |
"posix/utime", |
"posix/utsname", |
"termios", |
} |
CFLAGS="-Os -fno-stack-check -fno-stack-protector -mno-stack-arg-probe -fno-ident -fomit-frame-pointer -fno-asynchronous-unwind-tables -mpreferred-stack-boundary=2" |
OBJS={} |
for i,v in ipairs(FOLDERS) do |
tup.append_table(OBJS, |
tup.foreach_rule({v .. "/*.c", extra_inputs = {"../../config.h"}}, |
'kos32-gcc -c -I../../include -D__DEV_CONFIG_H=\\"../../config.h\\" ' .. CFLAGS .. " -o %o %f", |
v .. "/%B.o") |
) |
tup.append_table(OBJS, |
tup.foreach_rule({v .. "/*.s", extra_inputs = {"../../config.h"}}, |
'kos32-cpp -I../../include -D__DEV_CONFIG_H=\\"../../config.h\\" %f | kos32-as -o %o', |
v .. "/%B.o") |
) |
end |
tup.rule(OBJS, "kos32-ar rcs %o %f", {"../../lib/libc.a", "../../<libc>"}) |
/programs/develop/libraries/menuetlibc/src/libc/ansi/stdio/fprintf.c |
---|
1,5 → 1,6 |
/* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */ |
#include <stdio.h> |
#include <stdarg.h> |
#include <libc/file.h> |
int |
/programs/develop/libraries/menuetlibc/src/libc/compat/bsd/bcopy.c |
---|
3,8 → 3,8 |
#undef bcopy |
void * |
void |
bcopy(const void *a, void *b, size_t len) |
{ |
return memmove(b, a, len); |
memmove(b, a, len); |
} |
/programs/develop/libraries/menuetlibc/src/libc/compat/bsd/bzero.c |
---|
3,8 → 3,8 |
#undef bzero |
void * |
void |
bzero(void *a, size_t b) |
{ |
return memset(a,0,b); |
memset(a,0,b); |
} |
/programs/develop/libraries/menuetlibc/src/libc/compat/math/sincos.s |
---|
6,18 → 6,18 |
MK_C_SYM(sincos) |
/* void sincos(double *cosine, double *sine, double x); */ |
/* void sincos(double x, double *sine, double *cosine); */ |
movl 16(%esp), %ecx |
movl 8(%esp), %ecx |
movl 4(%esp), %eax /* Point to cosine. */ |
movl 8(%esp), %edx /* Point to sine. */ |
movl 16(%esp), %eax /* Point to cosine. */ |
movl 12(%esp), %edx /* Point to sine. */ |
andl $0x7FF00000, %ecx /* Examine exponent of x. */ |
cmpl $0x43E00000, %ecx /* |x| >= 2^63 */ |
jae bigarg |
fldl 12(%esp) |
fldl 4(%esp) |
fsincos |
fstpl (%eax) /* cos */ |
fstpl (%edx) /* sin */ |
/programs/develop/libraries/menuetlibc/src/libc/dos/dos_emu/fslayer.c |
---|
File deleted |
/programs/develop/libraries/menuetlibc/src/libcpp/Tupfile.lua |
---|
0,0 → 1,6 |
if tup.getconfig('NO_GCC') ~= "" then return end |
CFLAGS = "-Os -fno-stack-check -fno-stack-protector -mno-stack-arg-probe -fno-ident -fomit-frame-pointer -fno-asynchronous-unwind-tables -mpreferred-stack-boundary=2" |
OBJS = tup.foreach_rule({"*.cpp", extra_inputs = {"../../config.h"}}, |
'kos32-gcc -c -I../../include -D__DEV_CONFIG_H=\\"../../config.h\\" ' .. CFLAGS .. " -o %o %f", |
"%B.o") |
tup.rule(OBJS, "kos32-ar rcs %o %f", {"../../lib/libcpp.a", "../../<libcpp>"}) |
/programs/develop/libraries/menuetlibc/src/libm/ef_sinh.s |
---|
File deleted |
/programs/develop/libraries/menuetlibc/src/libm/Tupfile.lua |
---|
0,0 → 1,9 |
if tup.getconfig('NO_GCC') ~= "" then return end |
CFLAGS="-D_USE_LIBM_MATH_H -Os -fno-stack-check -fno-stack-protector -mno-stack-arg-probe -fno-ident -fomit-frame-pointer -fno-asynchronous-unwind-tables -mpreferred-stack-boundary=2" |
OBJS = tup.foreach_rule({"*.c", extra_inputs = {"../../config.h"}}, |
'kos32-gcc -c -I../../include -D__DEV_CONFIG_H=\\"../../config.h\\" ' .. CFLAGS .. ' -o %o %f', |
"%B.o") |
OBJS += tup.foreach_rule({"*.s", extra_inputs = {"../../config.h"}}, |
'kos32-cpp -I../../include -D__DEV_CONFIG_H=\\"../../config.h\\" %f | kos32-as -o %o', |
"%B.o") |
tup.rule(OBJS, "kos32-ar rcs %o %f", {"../../lib/libm.a", "../../<libm>"}) |
/programs/develop/libraries/menuetlibc/src/libm/k_standa.c |
---|
28,6 → 28,8 |
#undef fflush |
#endif /* !defined(_USE_WRITE) */ |
inline int fputs(const char* str, FILE* f) { return -1; } |
#ifdef __STDC__ |
static const double zero = 0.0; /* used as const */ |
#else |
/programs/develop/libraries/menuetlibc/stub/Tupfile.lua |
---|
0,0 → 1,2 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("crt0_coff.asm", "fasm %f %o", "crt0.o") |
/programs/develop/libraries/menuetlibc/stub/crt0_coff.asm |
---|
7,6 → 7,7 |
EXTRN ___menuet__app_param_area |
EXTRN ___menuet__app_path_area |
EXTRN ___crt1_startup |
EXTRN ___memsize |
start: |
public ___menuet__app_header |
public ___menuet__memsize |
22,7 → 23,7 |
; dd _edata |
dd 0 |
___menuet__memsize: |
dd 0x400000 |
dd ___memsize |
dd app_stack |
dd ___menuet__app_param_area |
dd ___menuet__app_path_area |
54,5 → 55,6 |
end if |
section '.bss' readable writeable |
rd 0x20000 |
;rd 0x20000 |
rb 0x10000 |
app_stack: |
/programs/develop/libraries/menuetlibc_example/Tupfile.lua |
---|
0,0 → 1,6 |
if tup.getconfig('NO_GCC') ~= "" then return end |
HELPERDIR = (tup.getconfig("HELPERDIR") == "") and "../../.." or tup.getconfig("HELPERDIR") |
tup.include(HELPERDIR .. "/use_gcc.lua") |
tup.include(HELPERDIR .. "/use_menuetlibc.lua") |
compile_gcc{"main.c"} |
link_gcc("binclock") |
/programs/develop/libraries/menuetlibc_example/main.c |
---|
0,0 → 1,89 |
#include<menuet/os.h> |
#define B_SZ 10 |
static char * Title="BinClock"; |
static void draw_small_box(int x,int y,int is_on) |
{ |
__menuet__bar(x,y,B_SZ,B_SZ,is_on ? 0xFF0000 : 0x103000); |
} |
static void draw_box_group(int x,int y,int num) |
{ |
int i,j; |
char buf[2]; |
buf[0]=(num&(1+2+4+8))+'0'; |
buf[1]='\0'; |
for(i=0;i<4;i++) |
{ |
j=(B_SZ+2)*i; |
draw_small_box(x,y+((B_SZ+2)*i),num & (1<<(3-i)) ? 1 : 0); |
} |
__menuet__bar(x,y+((B_SZ+2)*4),B_SZ,B_SZ,0x800000); |
__menuet__write_text(x+2,y+((B_SZ+2)*4)+3,0xFFFFFF,buf,1); |
} |
static void draw_bcd_num(int x,int y,int num) |
{ |
int v1,v2; |
v1=(num>>4)&(1+2+4+8); |
v2=num & (1+2+4+8); |
draw_box_group(x,y,v1); |
draw_box_group(x+B_SZ+2,y,v2); |
} |
static void draw_hms(int x,int y) |
{ |
__u32 t; |
int h,m,s; |
t=__menuet__getsystemclock(); |
s=(t & 0x00FF0000)>>16; |
m=(t & 0x0000FF00)>>8; |
h=(t & 0x000000FF); |
draw_bcd_num(x,y,h); |
x+=((B_SZ+2)<<1)+2; |
draw_bcd_num(x,y,m); |
x+=((B_SZ+2)<<1)+2; |
draw_bcd_num(x,y,s); |
} |
static void draw_h(void) |
{ |
draw_hms(22,28); |
} |
static void paint(void) |
{ |
__menuet__window_redraw(1); |
__menuet__define_window(100,100,40+((B_SZ+2)*6)+4,30+((B_SZ+2)*4)+16,0x03000080,0x800000FF,0x000080); |
__menuet__write_text(3,3,0xFFFFFF,Title,strlen(Title)); |
__menuet__bar(20,26,((B_SZ+2)*6)+4+2,4+((B_SZ+1)*4)+2,0); |
draw_h(); |
__menuet__window_redraw(2); |
} |
void main(void) |
{ |
int i; |
paint(); |
for(;;) |
{ |
__menuet__delay100(20); |
i=__menuet__check_for_event(); |
draw_h(); |
switch(i) |
{ |
case 1: |
paint(); |
continue; |
case 2: |
__menuet__getkey(); |
continue; |
case 3: |
if(__menuet__get_button_id()==1) __menuet__sys_exit(); |
continue; |
} |
} |
} |
/programs/develop/libraries/menuetlibc_example/Makefile |
---|
0,0 → 1,3 |
OUTFILE = mbinclk |
OBJS = main.o |
include $(MENUETDEV)/makefiles/Makefile_for_program |
/programs/develop/libraries/msgbox/Tupfile.lua |
---|
0,0 → 1,2 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("msgbox.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "msgbox.obj") |
/programs/develop/libraries/network/Tupfile.lua |
---|
0,0 → 1,2 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("network.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "network.obj") |
/programs/develop/libraries/network/examples/Tupfile.lua |
---|
0,0 → 1,2 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("nslookup.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "nslookup") |
/programs/develop/libraries/pixlib/Tupfile.lua |
---|
0,0 → 1,2 |
if tup.getconfig("NO_GCC") ~= "" then return end |
tup.rule("pixlib.c", "kos32-gcc -march=pentium-mmx -fno-ident -Os -c -o %o %f " .. tup.getconfig("KPACK_CMD"), "pixlib.obj") |
/programs/develop/libraries/proc_lib/trunk/Tupfile.lua |
---|
0,0 → 1,2 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("proc_lib.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "proc_lib.obj") |
/programs/develop/libraries/qs/Tupfile.lua |
---|
0,0 → 1,2 |
if tup.getconfig("NO_GCC") ~= "" then return end |
tup.rule("qs.c", "kos32-gcc -fno-ident -Os -c -o %o %f " .. tup.getconfig("KPACK_CMD"), "qs.obj") |
/programs/develop/libraries/sorter/Tupfile.lua |
---|
0,0 → 1,2 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("sort.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "sort.obj") |
/programs/develop/libraries/ufmod/Fasm/Tupfile.lua |
---|
0,0 → 1,3 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"}) |
tup.rule({"mini.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "mini") |
/programs/develop/libraries/ufmod/Tupfile.lua |
---|
0,0 → 1,32 |
if tup.getconfig("NO_FASM") ~= "" then return end |
-- Select mixing rate: 22050, 44100 or 48000 (22.05 KHz, 44.1 KHz or 48 KHz) |
UF_FREQ="48000" |
-- Set volume ramping mode (interpolation): NONE, WEAK or STRONG |
UF_RAMP="STRONG" |
-- Set build mode: NORMAL, UNSAFE or AC97SND |
UF_MODE="NORMAL" |
if tup.getconfig("TUP_PLATFORM") == "win32" |
then tup.rule( |
"echo UF_FREQ equ $(UF_FREQ) > %o && " .. |
"echo UF_RAMP equ $(UF_RAMP) >> %o && " .. |
"echo UF_MODE equ $(UF_MODE) >> %o && " .. |
"echo DEBUG equ 0 >> %o && " .. |
"echo NOLINKER equ 0 >> %o && " .. |
"echo include 'eff.inc' >> %o && " .. |
"echo include 'fasm.asm' >> %o", |
{"tmp.asm"}) |
else tup.rule( |
"echo UF_FREQ equ $(UF_FREQ) > %o && " .. |
"echo UF_RAMP equ $(UF_RAMP) >> %o && " .. |
"echo UF_MODE equ $(UF_MODE) >> %o && " .. |
"echo DEBUG equ 0 >> %o && " .. |
"echo NOLINKER equ 0 >> %o && " .. |
"echo include \"'eff.inc'\" >> %o && " .. |
"echo include \"'fasm.asm'\" >> %o", |
{"tmp.asm"}) |
end |
tup.rule("tmp.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "ufmod.obj") |
/programs/develop/libraries/utils/trunk/Tupfile.lua |
---|
0,0 → 1,2 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("utils.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "utils.obj") |
/programs/develop/libraries/wword/Tupfile.lua |
---|
0,0 → 1,2 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("wword.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "wword.obj") |
/programs/develop/mstate/Tupfile.lua |
---|
0,0 → 1,2 |
if tup.getconfig("NO_NASM") ~= "" then return end |
tup.rule("mstate.asm", "nasm -t -f bin -o %o %f " .. tup.getconfig("KPACK_CMD"), "mstate") |
/programs/develop/mstate/mstate.asm |
---|
77,11 → 77,11 |
MENUET01 db 'MENUET01' |
version dd 1 |
program.start dd START |
program.end dd END |
program.memory dd END + PATH_SIZE + PARAMS_SIZE + STACK_SIZE |
program.stack dd END + PATH_SIZE + PARAMS_SIZE + STACK_SIZE |
program.params dd END + PATH_SIZE |
program.path dd END |
program.end dd _END |
program.memory dd _END + PATH_SIZE + PARAMS_SIZE + STACK_SIZE |
program.stack dd _END + PATH_SIZE + PARAMS_SIZE + STACK_SIZE |
program.params dd _END + PATH_SIZE |
program.path dd _END |
; ---------------------------------------------------------------------------- ; |
mouse_body_color dd MOUSE_BODY_COLOR |
mouse_left_button_color dd MOUSE_LEFT_BUTTON_COLOR |
243,4 → 243,4 |
int 64 |
; ---------------------------------------------------------------------------- ; |
align 4 |
END: |
_END: |
/programs/develop/mtdbg/Tupfile.lua |
---|
0,0 → 1,2 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("mtdbg.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "mtdbg") |
/programs/develop/param/trunk/Tupfile.lua |
---|
0,0 → 1,3 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"}) |
tup.rule({"param.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "param") |
/programs/develop/scancode/trunk/Tupfile.lua |
---|
0,0 → 1,3 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"}) |
tup.rule({"scancode.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "scancode") |
/programs/develop/scc/Cc1.asm |
---|
File deleted |
/programs/develop/scc/Cc3.asm |
---|
File deleted |
/programs/develop/scc/Cc2.asm |
---|
File deleted |
/programs/develop/scc/CC1.ASM |
---|
0,0 → 1,5066 |
_nogo: TIMES 1 DD 0 |
_noloc: TIMES 1 DD 0 |
_opindex: TIMES 1 DD 0 |
_opsize: TIMES 1 DD 0 |
_swactive: TIMES 1 DD 0 |
_swdefaul: TIMES 1 DD 0 |
_swnext DD 0 |
_swend DD 0 |
_stage DD 0 |
_wq DD 0 |
_argcs: TIMES 1 DD 0 |
_argvs DD 0 |
_wqptr DD 0 |
_litptr: TIMES 1 DD 0 |
_macptr: TIMES 1 DD 0 |
_pptr: TIMES 1 DD 0 |
_ch: TIMES 1 DD 0 |
_nch: TIMES 1 DD 0 |
_declared: TIMES 1 DD 0 |
_iflevel: TIMES 1 DD 0 |
_skipleve: TIMES 1 DD 0 |
_nxtlab: TIMES 1 DD 0 |
_litlab: TIMES 1 DD 0 |
_csp: TIMES 1 DD 0 |
_argstk: TIMES 1 DD 0 |
_argtop: TIMES 1 DD 0 |
_ncmp: TIMES 1 DD 0 |
_errflag: TIMES 1 DD 0 |
_eof: TIMES 1 DD 0 |
_output: TIMES 1 DD 0 |
_files: TIMES 1 DD 0 |
_filearg DD 0 |
_input DD -1 |
_input2 DD -1 |
_usexpr DD 1 |
_ccode DD 1 |
_snext DD 0 |
_stail DD 0 |
_slast DD 0 |
_listfp: TIMES 1 DD 0 |
_lastst: TIMES 1 DD 0 |
_oldseg: TIMES 1 DD 0 |
_optimize: TIMES 1 DB 0 |
_alarm: TIMES 1 DB 0 |
_monitor: TIMES 1 DB 0 |
_pause: TIMES 1 DB 0 |
_symtab DD 0 |
_litq DD 0 |
_macn DD 0 |
_macq DD 0 |
_pline DD 0 |
_mline DD 0 |
_line DD 0 |
_lptr DD 0 |
_glbptr DD 0 |
_locptr DD 0 |
_quote DB 34 |
TIMES 1 DB 0 |
_cptr DD 0 |
_cptr2 DD 0 |
_cptr3 DD 0 |
_msname: TIMES 9 DB 0 |
_ssname: TIMES 9 DB 0 |
_op DD 57,73,3,20,55,43,22,47,35,7 |
DD 6,1,69,52,16,49 |
_op2 DD 57,73,3,20,55,44,23,48,36,7 |
DD 6,1,69,53,17,50 |
_main: |
PUSH EBP |
MOV EBP,ESP |
MOV EAX,_1_1+0 |
PUSH EAX |
MOV EAX,__iob |
MOV EBX,32 |
ADD EAX,EBX |
PUSH EAX |
MOV CL,2 |
CALL _fputs |
ADD ESP,8 |
MOV EAX,_1_1+47 |
PUSH EAX |
MOV EAX,__iob |
MOV EBX,32 |
ADD EAX,EBX |
PUSH EAX |
MOV CL,2 |
CALL _fputs |
ADD ESP,8 |
MOV EAX,_1_1+95 |
PUSH EAX |
MOV EAX,__iob |
MOV EBX,32 |
ADD EAX,EBX |
PUSH EAX |
MOV CL,2 |
CALL _fputs |
ADD ESP,8 |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV DWORD [_argcs],EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV DWORD [_argvs],EAX |
MOV EAX,360 |
PUSH EAX |
MOV EAX,1 |
PUSH EAX |
MOV CL,2 |
CALL _OS_callo |
ADD ESP,8 |
MOV DWORD [_swnext],EAX |
MOV EAX,[_swnext] |
MOV EBX,1424 |
ADD EAX,EBX |
MOV DWORD [_swend],EAX |
MOV EAX,200 |
PUSH EAX |
MOV EAX,8 |
PUSH EAX |
MOV CL,2 |
CALL _OS_callo |
ADD ESP,8 |
MOV DWORD [_stage],EAX |
MOV EAX,30 |
PUSH EAX |
MOV EAX,4 |
PUSH EAX |
MOV CL,2 |
CALL _OS_callo |
ADD ESP,8 |
MOV DWORD [_wq],EAX |
MOV DWORD [_wqptr],EAX |
MOV EAX,3000 |
PUSH EAX |
MOV EAX,1 |
PUSH EAX |
MOV CL,2 |
CALL _OS_callo |
ADD ESP,8 |
MOV DWORD [_litq],EAX |
MOV EAX,3300 |
PUSH EAX |
MOV EAX,1 |
PUSH EAX |
MOV CL,2 |
CALL _OS_callo |
ADD ESP,8 |
MOV DWORD [_macn],EAX |
MOV EAX,2100 |
PUSH EAX |
MOV EAX,1 |
PUSH EAX |
MOV CL,2 |
CALL _OS_callo |
ADD ESP,8 |
MOV DWORD [_macq],EAX |
MOV EAX,128 |
PUSH EAX |
MOV EAX,1 |
PUSH EAX |
MOV CL,2 |
CALL _OS_callo |
ADD ESP,8 |
MOV DWORD [_pline],EAX |
MOV EAX,128 |
PUSH EAX |
MOV EAX,1 |
PUSH EAX |
MOV CL,2 |
CALL _OS_callo |
ADD ESP,8 |
MOV DWORD [_mline],EAX |
MOV EAX,[_stage] |
MOV EBX,6400 |
ADD EAX,EBX |
MOV DWORD [_slast],EAX |
MOV EAX,4400 |
PUSH EAX |
MOV EAX,1 |
PUSH EAX |
MOV CL,2 |
CALL _OS_callo |
ADD ESP,8 |
MOV DWORD [_symtab],EAX |
MOV EAX,[_symtab] |
MOV DWORD [_locptr],EAX |
MOV EAX,[_symtab] |
MOV EBX,400 |
ADD EAX,EBX |
MOV DWORD [_glbptr],EAX |
XOR CL,CL |
CALL _ask |
XOR CL,CL |
CALL _openfile |
XOR CL,CL |
CALL _preproce |
XOR CL,CL |
CALL _header |
XOR CL,CL |
CALL _setcodes |
XOR CL,CL |
CALL _parse |
XOR CL,CL |
CALL _trailer |
MOV EAX,[_output] |
PUSH EAX |
MOV CL,1 |
CALL _OS_fclos |
ADD ESP,4 |
POP EBP |
RET |
_1_1 DB 83,109,97,108,108,32,67,32,51,56 |
DB 54,47,78,84,44,32,86,101,114,115 |
DB 105,111,110,32,51,46,49,44,32,82 |
DB 101,118,105,115,105,111,110,32,76,101 |
DB 118,101,108,32,49,10,0,67,111,112 |
DB 121,114,105,103,104,116,32,49,57,56 |
DB 50,44,32,49,57,56,51,44,32,49 |
DB 57,56,53,44,32,49,57,56,56,32 |
DB 74,46,32,69,46,32,72,101,110,100 |
DB 114,105,120,10,0,67,111,112,121,114 |
DB 105,103,104,116,32,49,57,57,56,32 |
DB 32,72,32,84,32,87,97,108,104,101 |
DB 105,109,10,10,0 |
_parse: |
PUSH EBP |
MOV EBP,ESP |
_1_3: |
MOV EAX,[_eof] |
OR EAX,EAX |
JE _1_5 |
JMP _1_4 |
_1_5: |
MOV EAX,_1_2+0 |
PUSH EAX |
MOV EAX,6 |
PUSH EAX |
MOV CL,2 |
CALL _amatch |
ADD ESP,8 |
OR EAX,EAX |
JNE _1_7 |
JMP _1_6 |
_1_7: |
MOV EAX,3 |
PUSH EAX |
MOV CL,1 |
CALL _dodeclar |
ADD ESP,4 |
JMP _1_8 |
_1_6: |
MOV EAX,2 |
PUSH EAX |
MOV CL,1 |
CALL _dodeclar |
ADD ESP,4 |
OR EAX,EAX |
JNE _1_10 |
JMP _1_9 |
_1_10: |
JMP _1_11 |
_1_9: |
MOV EAX,_1_2+7 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _1_13 |
JMP _1_12 |
_1_13: |
XOR CL,CL |
CALL _doasm |
JMP _1_14 |
_1_12: |
MOV EAX,_1_2+12 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _1_16 |
JMP _1_15 |
_1_16: |
XOR CL,CL |
CALL _doinclud |
JMP _1_17 |
_1_15: |
MOV EAX,_1_2+21 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _1_19 |
JMP _1_18 |
_1_19: |
XOR CL,CL |
CALL _dodefine |
JMP _1_20 |
_1_18: |
XOR CL,CL |
CALL _dofuncti |
_1_20: |
_1_17: |
_1_14: |
_1_11: |
_1_8: |
XOR CL,CL |
CALL _blanks |
JMP _1_3 |
_1_4: |
POP EBP |
RET |
_1_2 DB 101,120,116,101,114,110,0,35,97,115 |
DB 109,0,35,105,110,99,108,117,100,101 |
DB 0,35,100,101,102,105,110,101,0 |
_dodeclar: |
PUSH EBP |
MOV EBP,ESP |
MOV EAX,_1_21+0 |
PUSH EAX |
MOV EAX,4 |
PUSH EAX |
MOV CL,2 |
CALL _amatch |
ADD ESP,8 |
OR EAX,EAX |
JNE _1_23 |
JMP _1_22 |
_1_23: |
MOV EAX,4 |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _declglb |
ADD ESP,8 |
JMP _1_24 |
_1_22: |
MOV EAX,_1_21+5 |
PUSH EAX |
MOV EAX,8 |
PUSH EAX |
MOV CL,2 |
CALL _amatch |
ADD ESP,8 |
OR EAX,EAX |
JNE _1_26 |
JMP _1_25 |
_1_26: |
MOV EAX,_1_21+14 |
PUSH EAX |
MOV EAX,4 |
PUSH EAX |
MOV CL,2 |
CALL _amatch |
ADD ESP,8 |
OR EAX,EAX |
JNE _1_28 |
JMP _1_27 |
_1_28: |
MOV EAX,5 |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _declglb |
ADD ESP,8 |
JMP _1_29 |
_1_27: |
MOV EAX,_1_21+19 |
PUSH EAX |
MOV EAX,3 |
PUSH EAX |
MOV CL,2 |
CALL _amatch |
ADD ESP,8 |
MOV EAX,17 |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _declglb |
ADD ESP,8 |
_1_29: |
JMP _1_30 |
_1_25: |
MOV EAX,_1_21+23 |
PUSH EAX |
MOV EAX,3 |
PUSH EAX |
MOV CL,2 |
CALL _amatch |
ADD ESP,8 |
OR EAX,EAX |
JE _1_34 |
JMP _1_32 |
_1_34: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,3 |
CALL __eq |
OR EAX,EAX |
JE _1_35 |
JMP _1_32 |
_1_35: |
XOR EAX,EAX |
JMP _1_33 |
_1_32: |
MOV EAX,1 |
_1_33: |
OR EAX,EAX |
JNE _1_36 |
JMP _1_31 |
_1_36: |
MOV EAX,16 |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _declglb |
ADD ESP,8 |
JMP _1_37 |
_1_31: |
XOR EAX,EAX |
POP EBP |
RET |
_1_37: |
_1_30: |
_1_24: |
XOR CL,CL |
CALL _ns |
MOV EAX,1 |
POP EBP |
RET |
_1_21 DB 99,104,97,114,0,117,110,115,105,103 |
DB 110,101,100,0,99,104,97,114,0,105 |
DB 110,116,0,105,110,116,0 |
_declglb: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-8 |
_1_39: |
XOR CL,CL |
CALL _endst |
OR EAX,EAX |
JNE _1_42 |
JMP _1_41 |
_1_42: |
MOV ESP,EBP |
POP EBP |
RET |
_1_41: |
MOV EAX,_1_38+0 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _1_44 |
JMP _1_43 |
_1_44: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX,3 |
MOV [EBX],EAX |
LEA EAX,[EBP-8] |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],EAX |
JMP _1_45 |
_1_43: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX,1 |
MOV [EBX],EAX |
LEA EAX,[EBP-8] |
MOV EBX,EAX |
MOV EAX,1 |
MOV [EBX],EAX |
_1_45: |
MOV EAX,_ssname |
PUSH EAX |
MOV CL,1 |
CALL _symname |
ADD ESP,4 |
OR EAX,EAX |
JE _1_47 |
JMP _1_46 |
_1_47: |
XOR CL,CL |
CALL _illname |
_1_46: |
MOV EAX,_ssname |
PUSH EAX |
MOV CL,1 |
CALL _findglb |
ADD ESP,4 |
OR EAX,EAX |
JNE _1_49 |
JMP _1_48 |
_1_49: |
MOV EAX,_ssname |
PUSH EAX |
MOV CL,1 |
CALL _multidef |
ADD ESP,4 |
_1_48: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,1 |
CALL __eq |
OR EAX,EAX |
JNE _1_51 |
JMP _1_50 |
_1_51: |
MOV EAX,_1_38+2 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _1_53 |
JMP _1_52 |
_1_53: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX,4 |
MOV [EBX],EAX |
MOV EAX,_1_38+4 |
PUSH EAX |
MOV CL,1 |
CALL _need |
ADD ESP,4 |
JMP _1_54 |
_1_52: |
MOV EAX,_1_38+6 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _1_56 |
JMP _1_55 |
_1_56: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX,2 |
MOV [EBX],EAX |
LEA EAX,[EBP-8] |
PUSH EAX |
XOR CL,CL |
CALL _needsub |
POP EBX |
MOV [EBX],EAX |
_1_55: |
_1_54: |
_1_50: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,3 |
CALL __eq |
OR EAX,EAX |
JNE _1_58 |
JMP _1_57 |
_1_58: |
MOV EAX,_ssname |
PUSH EAX |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,2 |
MOV ECX,EAX |
MOV EAX,EBX |
SAR EAX,CL |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,3 |
CALL _external |
ADD ESP,12 |
JMP _1_59 |
_1_57: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,4 |
CALL __ne |
OR EAX,EAX |
JNE _1_61 |
JMP _1_60 |
_1_61: |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,2 |
MOV ECX,EAX |
MOV EAX,EBX |
SAR EAX,CL |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,3 |
CALL _initials |
ADD ESP,12 |
_1_60: |
_1_59: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,3 |
CALL __eq |
OR EAX,EAX |
JNE _1_63 |
JMP _1_62 |
_1_63: |
MOV EAX,_ssname |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV EAX,4 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV EAX,_glbptr |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,7 |
CALL _addsym |
ADD ESP,28 |
JMP _1_64 |
_1_62: |
MOV EAX,_ssname |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,2 |
MOV ECX,EAX |
MOV EAX,EBX |
SAR EAX,CL |
POP EBX |
IMUL EBX |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV EAX,_glbptr |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,7 |
CALL _addsym |
ADD ESP,28 |
_1_64: |
MOV EAX,_1_38+8 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JE _1_66 |
JMP _1_65 |
_1_66: |
MOV ESP,EBP |
POP EBP |
RET |
_1_65: |
JMP _1_39 |
_1_40: |
MOV ESP,EBP |
POP EBP |
RET |
_1_38 DB 42,0,40,0,41,0,91,0,44,0 |
_initials: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-4 |
XOR EAX,EAX |
MOV DWORD [_litptr],EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JE _1_69 |
JMP _1_68 |
_1_69: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX,-1 |
MOV [EBX],EAX |
_1_68: |
LEA EAX,[EBP-4] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
MOV [EBX],EAX |
MOV EAX,_1_67+0 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _1_71 |
JMP _1_70 |
_1_71: |
MOV EAX,_1_67+2 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _1_73 |
JMP _1_72 |
_1_73: |
_1_74: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _1_76 |
JMP _1_75 |
_1_76: |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
PUSH EAX |
MOV CL,3 |
CALL _init |
ADD ESP,12 |
MOV EAX,_1_67+4 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JE _1_78 |
JMP _1_77 |
_1_78: |
JMP _1_75 |
_1_77: |
JMP _1_74 |
_1_75: |
MOV EAX,_1_67+6 |
PUSH EAX |
MOV CL,1 |
CALL _need |
ADD ESP,4 |
JMP _1_79 |
_1_72: |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
PUSH EAX |
MOV CL,3 |
CALL _init |
ADD ESP,12 |
_1_79: |
_1_70: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,-1 |
CALL __eq |
OR EAX,EAX |
JNE _1_83 |
JMP _1_81 |
_1_83: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,-1 |
CALL __eq |
OR EAX,EAX |
JNE _1_84 |
JMP _1_81 |
_1_84: |
MOV EAX,1 |
JMP _1_82 |
_1_81: |
XOR EAX,EAX |
_1_82: |
OR EAX,EAX |
JNE _1_85 |
JMP _1_80 |
_1_85: |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,2 |
CALL __eq |
OR EAX,EAX |
JNE _1_87 |
JMP _1_86 |
_1_87: |
MOV EAX,_1_67+8 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
_1_86: |
XOR EAX,EAX |
PUSH EAX |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX,4 |
MOV [EBX],EAX |
PUSH EAX |
MOV CL,2 |
CALL _stowlit |
ADD ESP,8 |
_1_80: |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _public |
ADD ESP,4 |
MOV EAX,[_litptr] |
OR EAX,EAX |
JG _1_89 |
JMP _1_88 |
_1_89: |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _dumplits |
ADD ESP,4 |
JMP _1_90 |
_1_88: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JG _1_92 |
JMP _1_91 |
_1_92: |
MOV EAX,58 |
PUSH EAX |
MOV EAX,[_output] |
PUSH EAX |
MOV CL,2 |
CALL _OS_fputc |
ADD ESP,8 |
_1_91: |
_1_90: |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _dumpzero |
ADD ESP,8 |
MOV ESP,EBP |
POP EBP |
RET |
_1_67 DB 61,0,123,0,44,0,125,0,110,101 |
DB 101,100,32,97,114,114,97,121,32,115 |
DB 105,122,101,0 |
_init: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-4 |
LEA EAX,[EBP-4] |
PUSH EAX |
MOV CL,1 |
CALL _string |
ADD ESP,4 |
OR EAX,EAX |
JNE _1_95 |
JMP _1_94 |
_1_95: |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,1 |
CALL __eq |
OR EAX,EAX |
JE _1_99 |
JMP _1_97 |
_1_99: |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,1 |
CALL __ne |
OR EAX,EAX |
JE _1_100 |
JMP _1_97 |
_1_100: |
XOR EAX,EAX |
JMP _1_98 |
_1_97: |
MOV EAX,1 |
_1_98: |
OR EAX,EAX |
JNE _1_101 |
JMP _1_96 |
_1_101: |
MOV EAX,_1_93+0 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
_1_96: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV EAX,[_litptr] |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
XCHG EAX,EBX |
SUB EAX,EBX |
POP EBX |
XCHG EAX,EBX |
SUB EAX,EBX |
POP EBX |
MOV [EBX],EAX |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,3 |
CALL __eq |
OR EAX,EAX |
JNE _1_103 |
JMP _1_102 |
_1_103: |
XOR CL,CL |
CALL _point |
_1_102: |
JMP _1_104 |
_1_94: |
LEA EAX,[EBP-4] |
PUSH EAX |
MOV CL,1 |
CALL _constexp |
ADD ESP,4 |
OR EAX,EAX |
JNE _1_106 |
JMP _1_105 |
_1_106: |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,3 |
CALL __eq |
OR EAX,EAX |
JNE _1_108 |
JMP _1_107 |
_1_108: |
MOV EAX,_1_93+42 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
_1_107: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _stowlit |
ADD ESP,8 |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,1 |
XCHG EAX,EBX |
SUB EAX,EBX |
POP EBX |
MOV [EBX],EAX |
_1_105: |
_1_104: |
MOV ESP,EBP |
POP EBP |
RET |
_1_93 DB 109,117,115,116,32,97,115,115,105,103 |
DB 110,32,116,111,32,99,104,97,114,32 |
DB 112,111,105,110,116,101,114,32,111,114 |
DB 32,99,104,97,114,32,97,114,114,97 |
DB 121,0,99,97,110,110,111,116,32,97 |
DB 115,115,105,103,110,32,116,111,32,112 |
DB 111,105,110,116,101,114,0 |
_needsub: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-4 |
MOV EAX,_1_109+0 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _1_111 |
JMP _1_110 |
_1_111: |
XOR EAX,EAX |
MOV ESP,EBP |
POP EBP |
RET |
_1_110: |
LEA EAX,[EBP-4] |
PUSH EAX |
MOV CL,1 |
CALL _constexp |
ADD ESP,4 |
OR EAX,EAX |
JE _1_113 |
JMP _1_112 |
_1_113: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX,1 |
MOV [EBX],EAX |
_1_112: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JL _1_115 |
JMP _1_114 |
_1_115: |
MOV EAX,_1_109+2 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
LEA EAX,[EBP-4] |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
NEG EAX |
POP EBX |
MOV [EBX],EAX |
_1_114: |
MOV EAX,_1_109+24 |
PUSH EAX |
MOV CL,1 |
CALL _need |
ADD ESP,4 |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV ESP,EBP |
POP EBP |
RET |
_1_109 DB 93,0,110,101,103,97,116,105,118,101 |
DB 32,115,105,122,101,32,105,108,108,101 |
DB 103,97,108,0,93,0 |
_doinclud: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-36 |
XOR CL,CL |
CALL _blanks |
MOV EAX,[_lptr] |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,34 |
CALL __eq |
OR EAX,EAX |
JE _1_120 |
JMP _1_118 |
_1_120: |
MOV EAX,[_lptr] |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,60 |
CALL __eq |
OR EAX,EAX |
JE _1_121 |
JMP _1_118 |
_1_121: |
XOR EAX,EAX |
JMP _1_119 |
_1_118: |
MOV EAX,1 |
_1_119: |
OR EAX,EAX |
JNE _1_122 |
JMP _1_117 |
_1_122: |
MOV EAX,[_lptr] |
INC EAX |
MOV DWORD [_lptr],EAX |
_1_117: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],EAX |
_1_123: |
MOV EAX,[_lptr] |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
OR EAX,EAX |
JNE _1_127 |
JMP _1_125 |
_1_127: |
MOV EAX,[_lptr] |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,34 |
CALL __ne |
OR EAX,EAX |
JNE _1_128 |
JMP _1_125 |
_1_128: |
MOV EAX,[_lptr] |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,62 |
CALL __ne |
OR EAX,EAX |
JNE _1_129 |
JMP _1_125 |
_1_129: |
MOV EAX,[_lptr] |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,10 |
CALL __ne |
OR EAX,EAX |
JNE _1_130 |
JMP _1_125 |
_1_130: |
MOV EAX,1 |
JMP _1_126 |
_1_125: |
XOR EAX,EAX |
_1_126: |
OR EAX,EAX |
JNE _1_131 |
JMP _1_124 |
_1_131: |
LEA EAX,[EBP-36] |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
ADD EAX,EBX |
PUSH EAX |
MOV EAX,[_lptr] |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
POP EBX |
MOV [EBX],AL |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
INC EAX |
MOV [EBX],EAX |
JMP _1_123 |
_1_124: |
LEA EAX,[EBP-36] |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
ADD EAX,EBX |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],AL |
LEA EAX,[EBP-36] |
PUSH EAX |
MOV EAX,_1_116+0 |
PUSH EAX |
MOV CL,2 |
CALL _OS_fopen |
ADD ESP,8 |
MOV DWORD [_input2],EAX |
OR EAX,EAX |
JE _1_133 |
JMP _1_132 |
_1_133: |
MOV EAX,-1 |
MOV DWORD [_input2],EAX |
MOV EAX,_1_116+2 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
_1_132: |
XOR CL,CL |
CALL _kill |
MOV ESP,EBP |
POP EBP |
RET |
_1_116 DB 114,0,111,112,101,110,32,102,97,105 |
DB 108,117,114,101,32,111,110,32,105,110 |
DB 99,108,117,100,101,32,102,105,108,101 |
DB 0 |
_dodefine: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-4 |
MOV EAX,_msname |
PUSH EAX |
MOV CL,1 |
CALL _symname |
ADD ESP,4 |
OR EAX,EAX |
JE _1_136 |
JMP _1_135 |
_1_136: |
XOR CL,CL |
CALL _illname |
XOR CL,CL |
CALL _kill |
MOV ESP,EBP |
POP EBP |
RET |
_1_135: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],EAX |
MOV EAX,_msname |
PUSH EAX |
MOV EAX,[_macn] |
PUSH EAX |
MOV EAX,11 |
PUSH EAX |
MOV EAX,[_macn] |
MOV EBX,3300 |
ADD EAX,EBX |
PUSH EAX |
MOV EAX,300 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,6 |
CALL _search |
ADD ESP,24 |
OR EAX,EAX |
JE _1_138 |
JMP _1_137 |
_1_138: |
MOV EAX,[_cptr] |
MOV DWORD [_cptr2],EAX |
OR EAX,EAX |
JNE _1_140 |
JMP _1_139 |
_1_140: |
_1_141: |
MOV EAX,[_cptr2] |
INC EAX |
MOV DWORD [_cptr2],EAX |
DEC EAX |
PUSH EAX |
MOV EAX,_msname |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
INC EAX |
MOV [EBX],EAX |
DEC EAX |
POP EBX |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
POP EBX |
MOV [EBX],AL |
OR EAX,EAX |
JNE _1_143 |
JMP _1_142 |
_1_143: |
JMP _1_141 |
_1_142: |
JMP _1_144 |
_1_139: |
MOV EAX,_1_134+0 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
MOV ESP,EBP |
POP EBP |
RET |
_1_144: |
_1_137: |
MOV EAX,[_macptr] |
PUSH EAX |
MOV EAX,[_cptr] |
MOV EBX,9 |
ADD EAX,EBX |
PUSH EAX |
MOV EAX,2 |
PUSH EAX |
MOV CL,3 |
CALL _putint |
ADD ESP,12 |
_1_145: |
XOR CL,CL |
CALL _white |
OR EAX,EAX |
JNE _1_147 |
JMP _1_146 |
_1_147: |
XOR CL,CL |
CALL _gch |
JMP _1_145 |
_1_146: |
_1_148: |
XOR CL,CL |
CALL _gch |
PUSH EAX |
MOV CL,1 |
CALL _putmac |
ADD ESP,4 |
OR EAX,EAX |
JNE _1_150 |
JMP _1_149 |
_1_150: |
JMP _1_148 |
_1_149: |
MOV EAX,[_macptr] |
MOV EBX,EAX |
MOV EAX,2099 |
CALL __ge |
OR EAX,EAX |
JNE _1_152 |
JMP _1_151 |
_1_152: |
MOV EAX,_1_134+22 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
MOV EAX,7 |
PUSH EAX |
MOV CL,1 |
CALL _OS_exit |
ADD ESP,4 |
_1_151: |
MOV ESP,EBP |
POP EBP |
RET |
_1_134 DB 109,97,99,114,111,32,110,97,109,101 |
DB 32,116,97,98,108,101,32,102,117,108 |
DB 108,0,109,97,99,114,111,32,115,116 |
DB 114,105,110,103,32,113,117,101,117,101 |
DB 32,102,117,108,108,0 |
_putmac: |
PUSH EBP |
MOV EBP,ESP |
MOV EAX,[_macq] |
PUSH EAX |
MOV EAX,[_macptr] |
POP EBX |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
POP EBX |
MOV [EBX],AL |
MOV EAX,[_macptr] |
MOV EBX,EAX |
MOV EAX,2099 |
CALL __lt |
OR EAX,EAX |
JNE _1_155 |
JMP _1_154 |
_1_155: |
MOV EAX,[_macptr] |
INC EAX |
MOV DWORD [_macptr],EAX |
_1_154: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
POP EBP |
RET |
_dofuncti: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-4 |
XOR EAX,EAX |
MOV DWORD [_litptr],EAX |
MOV DWORD [_lastst],EAX |
MOV DWORD [_noloc],EAX |
MOV DWORD [_nogo],EAX |
XOR CL,CL |
CALL _getlabel |
MOV DWORD [_litlab],EAX |
MOV EAX,[_symtab] |
MOV DWORD [_locptr],EAX |
MOV EAX,_1_156+0 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _1_158 |
JMP _1_157 |
_1_158: |
XOR CL,CL |
CALL _blanks |
_1_157: |
MOVSX EAX,BYTE [_monitor] |
OR EAX,EAX |
JNE _1_160 |
JMP _1_159 |
_1_160: |
MOV EAX,[_line] |
PUSH EAX |
MOV EAX,__iob |
MOV EBX,64 |
ADD EAX,EBX |
PUSH EAX |
MOV CL,2 |
CALL _lout |
ADD ESP,8 |
_1_159: |
MOV EAX,_ssname |
PUSH EAX |
MOV CL,1 |
CALL _symname |
ADD ESP,4 |
OR EAX,EAX |
JE _1_162 |
JMP _1_161 |
_1_162: |
MOV EAX,_1_156+5 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
XOR EAX,EAX |
MOV DWORD [_errflag],EAX |
XOR CL,CL |
CALL _kill |
MOV ESP,EBP |
POP EBP |
RET |
_1_161: |
LEA EAX,[EBP-4] |
PUSH EAX |
MOV EAX,_ssname |
PUSH EAX |
MOV CL,1 |
CALL _findglb |
ADD ESP,4 |
POP EBX |
MOV [EBX],EAX |
OR EAX,EAX |
JNE _1_164 |
JMP _1_163 |
_1_164: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,2 |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,4 |
CALL __eq |
OR EAX,EAX |
JNE _1_166 |
JMP _1_165 |
_1_166: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,2 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX,2 |
MOV [EBX],AL |
JMP _1_167 |
_1_165: |
MOV EAX,_ssname |
PUSH EAX |
MOV CL,1 |
CALL _multidef |
ADD ESP,4 |
_1_167: |
JMP _1_168 |
_1_163: |
MOV EAX,_ssname |
PUSH EAX |
MOV EAX,4 |
PUSH EAX |
MOV EAX,16 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV EAX,_glbptr |
PUSH EAX |
MOV EAX,2 |
PUSH EAX |
MOV CL,7 |
CALL _addsym |
ADD ESP,28 |
_1_168: |
MOV EAX,4 |
PUSH EAX |
MOV CL,1 |
CALL _public |
ADD ESP,4 |
XOR EAX,EAX |
MOV DWORD [_argstk],EAX |
MOV EAX,_1_156+37 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JE _1_170 |
JMP _1_169 |
_1_170: |
MOV EAX,_1_156+39 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
_1_169: |
_1_171: |
MOV EAX,_1_156+53 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JE _1_173 |
JMP _1_172 |
_1_173: |
MOV EAX,_ssname |
PUSH EAX |
MOV CL,1 |
CALL _symname |
ADD ESP,4 |
OR EAX,EAX |
JNE _1_175 |
JMP _1_174 |
_1_175: |
MOV EAX,_ssname |
PUSH EAX |
MOV CL,1 |
CALL _findloc |
ADD ESP,4 |
OR EAX,EAX |
JNE _1_177 |
JMP _1_176 |
_1_177: |
MOV EAX,_ssname |
PUSH EAX |
MOV CL,1 |
CALL _multidef |
ADD ESP,4 |
JMP _1_178 |
_1_176: |
MOV EAX,_ssname |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV EAX,[_argstk] |
PUSH EAX |
MOV EAX,_locptr |
PUSH EAX |
MOV EAX,1 |
PUSH EAX |
MOV CL,7 |
CALL _addsym |
ADD ESP,28 |
MOV EAX,[_argstk] |
MOV EBX,4 |
ADD EAX,EBX |
MOV DWORD [_argstk],EAX |
_1_178: |
JMP _1_179 |
_1_174: |
MOV EAX,_1_156+55 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
XOR CL,CL |
CALL _skip |
_1_179: |
XOR CL,CL |
CALL _blanks |
MOV EAX,[_lptr] |
PUSH EAX |
MOV EAX,_1_156+77 |
PUSH EAX |
MOV CL,2 |
CALL _streq |
ADD ESP,8 |
MOV EBX,EAX |
XOR EAX,EAX |
CALL __eq |
OR EAX,EAX |
JNE _1_183 |
JMP _1_181 |
_1_183: |
MOV EAX,_1_156+79 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
MOV EBX,EAX |
XOR EAX,EAX |
CALL __eq |
OR EAX,EAX |
JNE _1_184 |
JMP _1_181 |
_1_184: |
MOV EAX,1 |
JMP _1_182 |
_1_181: |
XOR EAX,EAX |
_1_182: |
OR EAX,EAX |
JNE _1_185 |
JMP _1_180 |
_1_185: |
MOV EAX,_1_156+81 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
_1_180: |
XOR CL,CL |
CALL _endst |
OR EAX,EAX |
JNE _1_187 |
JMP _1_186 |
_1_187: |
JMP _1_172 |
_1_186: |
JMP _1_171 |
_1_172: |
XOR EAX,EAX |
MOV DWORD [_csp],EAX |
MOV EAX,[_argstk] |
MOV EBX,4 |
ADD EAX,EBX |
MOV DWORD [_argtop],EAX |
_1_188: |
MOV EAX,[_argstk] |
OR EAX,EAX |
JNE _1_190 |
JMP _1_189 |
_1_190: |
MOV EAX,_1_156+90 |
PUSH EAX |
MOV EAX,4 |
PUSH EAX |
MOV CL,2 |
CALL _amatch |
ADD ESP,8 |
OR EAX,EAX |
JNE _1_192 |
JMP _1_191 |
_1_192: |
MOV EAX,4 |
PUSH EAX |
MOV CL,1 |
CALL _doargs |
ADD ESP,4 |
XOR CL,CL |
CALL _ns |
JMP _1_193 |
_1_191: |
MOV EAX,_1_156+95 |
PUSH EAX |
MOV EAX,3 |
PUSH EAX |
MOV CL,2 |
CALL _amatch |
ADD ESP,8 |
OR EAX,EAX |
JNE _1_195 |
JMP _1_194 |
_1_195: |
MOV EAX,16 |
PUSH EAX |
MOV CL,1 |
CALL _doargs |
ADD ESP,4 |
XOR CL,CL |
CALL _ns |
JMP _1_196 |
_1_194: |
MOV EAX,_1_156+99 |
PUSH EAX |
MOV EAX,8 |
PUSH EAX |
MOV CL,2 |
CALL _amatch |
ADD ESP,8 |
OR EAX,EAX |
JNE _1_198 |
JMP _1_197 |
_1_198: |
MOV EAX,_1_156+108 |
PUSH EAX |
MOV EAX,4 |
PUSH EAX |
MOV CL,2 |
CALL _amatch |
ADD ESP,8 |
OR EAX,EAX |
JNE _1_200 |
JMP _1_199 |
_1_200: |
MOV EAX,5 |
PUSH EAX |
MOV CL,1 |
CALL _doargs |
ADD ESP,4 |
XOR CL,CL |
CALL _ns |
JMP _1_201 |
_1_199: |
MOV EAX,_1_156+113 |
PUSH EAX |
MOV EAX,3 |
PUSH EAX |
MOV CL,2 |
CALL _amatch |
ADD ESP,8 |
MOV EAX,17 |
PUSH EAX |
MOV CL,1 |
CALL _doargs |
ADD ESP,4 |
XOR CL,CL |
CALL _ns |
_1_201: |
JMP _1_202 |
_1_197: |
MOV EAX,_1_156+117 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
JMP _1_189 |
_1_202: |
_1_196: |
_1_193: |
JMP _1_188 |
_1_189: |
MOV EAX,18 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
XOR CL,CL |
CALL _statemen |
MOV EAX,[_lastst] |
MOV EBX,EAX |
MOV EAX,3 |
CALL __ne |
OR EAX,EAX |
JNE _1_206 |
JMP _1_204 |
_1_206: |
MOV EAX,[_lastst] |
MOV EBX,EAX |
MOV EAX,13 |
CALL __ne |
OR EAX,EAX |
JNE _1_207 |
JMP _1_204 |
_1_207: |
MOV EAX,1 |
JMP _1_205 |
_1_204: |
XOR EAX,EAX |
_1_205: |
OR EAX,EAX |
JNE _1_208 |
JMP _1_203 |
_1_208: |
MOV EAX,67 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
_1_203: |
MOV EAX,[_litptr] |
OR EAX,EAX |
JNE _1_210 |
JMP _1_209 |
_1_210: |
MOV EAX,1 |
PUSH EAX |
MOV CL,1 |
CALL _toseg |
ADD ESP,4 |
MOV EAX,66 |
PUSH EAX |
MOV EAX,[_litlab] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
MOV EAX,1 |
PUSH EAX |
MOV CL,1 |
CALL _dumplits |
ADD ESP,4 |
_1_209: |
MOV ESP,EBP |
POP EBP |
RET |
_1_156 DB 118,111,105,100,0,105,108,108,101,103 |
DB 97,108,32,102,117,110,99,116,105,111 |
DB 110,32,111,114,32,100,101,99,108,97 |
DB 114,97,116,105,111,110,0,40,0,110 |
DB 111,32,111,112,101,110,32,112,97,114 |
DB 101,110,0,41,0,105,108,108,101,103 |
DB 97,108,32,97,114,103,117,109,101,110 |
DB 116,32,110,97,109,101,0,41,0,44 |
DB 0,110,111,32,99,111,109,109,97,0 |
DB 99,104,97,114,0,105,110,116,0,117 |
DB 110,115,105,103,110,101,100,0,99,104 |
DB 97,114,0,105,110,116,0,119,114,111 |
DB 110,103,32,110,117,109,98,101,114,32 |
DB 111,102,32,97,114,103,117,109,101,110 |
DB 116,115,0 |
_doargs: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-16 |
_1_212: |
MOV EAX,[_argstk] |
OR EAX,EAX |
JE _1_215 |
JMP _1_214 |
_1_215: |
MOV ESP,EBP |
POP EBP |
RET |
_1_214: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV EAX,3 |
PUSH EAX |
LEA EAX,[EBP-4] |
PUSH EAX |
LEA EAX,[EBP-8] |
PUSH EAX |
MOV CL,4 |
CALL _decl |
ADD ESP,16 |
OR EAX,EAX |
JNE _1_217 |
JMP _1_216 |
_1_217: |
LEA EAX,[EBP-16] |
PUSH EAX |
MOV EAX,_ssname |
PUSH EAX |
MOV CL,1 |
CALL _findloc |
ADD ESP,4 |
POP EBX |
MOV [EBX],EAX |
OR EAX,EAX |
JNE _1_219 |
JMP _1_218 |
_1_219: |
LEA EAX,[EBP-16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
MOV [EBX],AL |
LEA EAX,[EBP-16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,1 |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
MOV [EBX],AL |
LEA EAX,[EBP-8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,3 |
ADD EAX,EBX |
PUSH EAX |
MOV EAX,4 |
PUSH EAX |
MOV CL,3 |
CALL _putint |
ADD ESP,12 |
MOV EAX,[_argtop] |
PUSH EAX |
LEA EAX,[EBP-16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,5 |
ADD EAX,EBX |
MOV EBX,2 |
ADD EAX,EBX |
PUSH EAX |
MOV EAX,4 |
PUSH EAX |
MOV CL,2 |
CALL _getint |
ADD ESP,8 |
POP EBX |
XCHG EAX,EBX |
SUB EAX,EBX |
PUSH EAX |
LEA EAX,[EBP-16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,5 |
ADD EAX,EBX |
MOV EBX,2 |
ADD EAX,EBX |
PUSH EAX |
MOV EAX,4 |
PUSH EAX |
MOV CL,3 |
CALL _putint |
ADD ESP,12 |
JMP _1_220 |
_1_218: |
MOV EAX,_1_211+0 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
_1_220: |
_1_216: |
MOV EAX,[_argstk] |
MOV EBX,EAX |
MOV EAX,4 |
XCHG EAX,EBX |
SUB EAX,EBX |
MOV DWORD [_argstk],EAX |
XOR CL,CL |
CALL _endst |
OR EAX,EAX |
JNE _1_222 |
JMP _1_221 |
_1_222: |
MOV ESP,EBP |
POP EBP |
RET |
_1_221: |
MOV EAX,_1_211+16 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JE _1_224 |
JMP _1_223 |
_1_224: |
MOV EAX,_1_211+18 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
_1_223: |
JMP _1_212 |
_1_213: |
MOV ESP,EBP |
POP EBP |
RET |
_1_211 DB 110,111,116,32,97,110,32,97,114,103 |
DB 117,109,101,110,116,0,44,0,110,111 |
DB 32,99,111,109,109,97,0 |
_decl: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-12 |
MOV EAX,_1_225+0 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _1_227 |
JMP _1_226 |
_1_227: |
LEA EAX,[EBP-8] |
MOV EBX,EAX |
MOV EAX,1 |
MOV [EBX],EAX |
JMP _1_228 |
_1_226: |
LEA EAX,[EBP-8] |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],EAX |
_1_228: |
MOV EAX,_1_225+2 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _1_230 |
JMP _1_229 |
_1_230: |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,3 |
MOV [EBX],EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,4 |
MOV [EBX],EAX |
JMP _1_231 |
_1_229: |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,1 |
MOV [EBX],EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+20] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,2 |
MOV ECX,EAX |
MOV EAX,EBX |
SAR EAX,CL |
POP EBX |
MOV [EBX],EAX |
_1_231: |
LEA EAX,[EBP-4] |
PUSH EAX |
MOV EAX,_ssname |
PUSH EAX |
MOV CL,1 |
CALL _symname |
ADD ESP,4 |
POP EBX |
MOV [EBX],EAX |
OR EAX,EAX |
JE _1_233 |
JMP _1_232 |
_1_233: |
XOR CL,CL |
CALL _illname |
_1_232: |
LEA EAX,[EBP-8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _1_237 |
JMP _1_235 |
_1_237: |
MOV EAX,_1_225+4 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _1_238 |
JMP _1_235 |
_1_238: |
MOV EAX,1 |
JMP _1_236 |
_1_235: |
XOR EAX,EAX |
_1_236: |
OR EAX,EAX |
JNE _1_239 |
JMP _1_234 |
_1_239: |
_1_234: |
MOV EAX,_1_225+6 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _1_241 |
JMP _1_240 |
_1_241: |
LEA EAX,[EBP-8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
CALL __lneg |
OR EAX,EAX |
JE _1_245 |
JMP _1_243 |
_1_245: |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,3 |
CALL __ne |
OR EAX,EAX |
JE _1_246 |
JMP _1_243 |
_1_246: |
XOR EAX,EAX |
JMP _1_244 |
_1_243: |
MOV EAX,1 |
_1_244: |
OR EAX,EAX |
JNE _1_247 |
JMP _1_242 |
_1_247: |
MOV EAX,_1_225+8 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
_1_242: |
MOV EAX,_1_225+21 |
PUSH EAX |
MOV CL,1 |
CALL _need |
ADD ESP,4 |
JMP _1_248 |
_1_240: |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,1 |
CALL __eq |
OR EAX,EAX |
JNE _1_252 |
JMP _1_250 |
_1_252: |
MOV EAX,_1_225+23 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _1_253 |
JMP _1_250 |
_1_253: |
MOV EAX,1 |
JMP _1_251 |
_1_250: |
XOR EAX,EAX |
_1_251: |
OR EAX,EAX |
JNE _1_254 |
JMP _1_249 |
_1_254: |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
MOV [EBX],EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
XOR CL,CL |
CALL _needsub |
POP EBX |
IMUL EBX |
POP EBX |
MOV [EBX],EAX |
OR EAX,EAX |
JE _1_256 |
JMP _1_255 |
_1_256: |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,2 |
CALL __eq |
OR EAX,EAX |
JNE _1_258 |
JMP _1_257 |
_1_258: |
MOV EAX,_1_225+25 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
_1_257: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,4 |
MOV [EBX],EAX |
_1_255: |
_1_249: |
_1_248: |
LEA EAX,[EBP-12] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,4 |
XCHG EAX,EBX |
CDQ |
IDIV EBX |
MOV EAX,EDX |
POP EBX |
MOV [EBX],EAX |
LEA EAX,[EBP-12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _1_260 |
JMP _1_259 |
_1_260: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,4 |
XCHG EAX,EBX |
SUB EAX,EBX |
POP EBX |
ADD EAX,EBX |
POP EBX |
MOV [EBX],EAX |
_1_259: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV ESP,EBP |
POP EBP |
RET |
_1_225 DB 40,0,42,0,41,0,40,0,116,114 |
DB 121,32,40,42,46,46,46,41,40,41 |
DB 0,41,0,91,0,110,101,101,100,32 |
DB 97,114,114,97,121,32,115,105,122,101 |
DB 0 |
_statemen: |
PUSH EBP |
MOV EBP,ESP |
MOV EAX,[_ch] |
MOV EBX,EAX |
XOR EAX,EAX |
CALL __eq |
OR EAX,EAX |
JNE _1_265 |
JMP _1_263 |
_1_265: |
MOV EAX,[_eof] |
OR EAX,EAX |
JNE _1_266 |
JMP _1_263 |
_1_266: |
MOV EAX,1 |
JMP _1_264 |
_1_263: |
XOR EAX,EAX |
_1_264: |
OR EAX,EAX |
JNE _1_267 |
JMP _1_262 |
_1_267: |
POP EBP |
RET |
_1_262: |
MOV EAX,_1_261+0 |
PUSH EAX |
MOV EAX,4 |
PUSH EAX |
MOV CL,2 |
CALL _amatch |
ADD ESP,8 |
OR EAX,EAX |
JNE _1_270 |
JMP _1_269 |
_1_270: |
MOV EAX,4 |
PUSH EAX |
MOV CL,1 |
CALL _declloc |
ADD ESP,4 |
XOR CL,CL |
CALL _ns |
JMP _1_271 |
_1_269: |
MOV EAX,_1_261+5 |
PUSH EAX |
MOV EAX,3 |
PUSH EAX |
MOV CL,2 |
CALL _amatch |
ADD ESP,8 |
OR EAX,EAX |
JNE _1_273 |
JMP _1_272 |
_1_273: |
MOV EAX,16 |
PUSH EAX |
MOV CL,1 |
CALL _declloc |
ADD ESP,4 |
XOR CL,CL |
CALL _ns |
JMP _1_274 |
_1_272: |
MOV EAX,_1_261+9 |
PUSH EAX |
MOV EAX,8 |
PUSH EAX |
MOV CL,2 |
CALL _amatch |
ADD ESP,8 |
OR EAX,EAX |
JNE _1_276 |
JMP _1_275 |
_1_276: |
MOV EAX,_1_261+18 |
PUSH EAX |
MOV EAX,4 |
PUSH EAX |
MOV CL,2 |
CALL _amatch |
ADD ESP,8 |
OR EAX,EAX |
JNE _1_278 |
JMP _1_277 |
_1_278: |
MOV EAX,5 |
PUSH EAX |
MOV CL,1 |
CALL _declloc |
ADD ESP,4 |
XOR CL,CL |
CALL _ns |
JMP _1_279 |
_1_277: |
MOV EAX,_1_261+23 |
PUSH EAX |
MOV EAX,3 |
PUSH EAX |
MOV CL,2 |
CALL _amatch |
ADD ESP,8 |
MOV EAX,17 |
PUSH EAX |
MOV CL,1 |
CALL _declloc |
ADD ESP,4 |
XOR CL,CL |
CALL _ns |
_1_279: |
JMP _1_280 |
_1_275: |
MOV EAX,[_declared] |
OR EAX,EAX |
JGE _1_282 |
JMP _1_281 |
_1_282: |
MOV EAX,[_ncmp] |
MOV EBX,EAX |
MOV EAX,1 |
CALL __gt |
OR EAX,EAX |
JNE _1_284 |
JMP _1_283 |
_1_284: |
MOV EAX,[_declared] |
MOV DWORD [_nogo],EAX |
_1_283: |
MOV EAX,2 |
PUSH EAX |
MOV EAX,[_csp] |
PUSH EAX |
MOV EAX,[_declared] |
POP EBX |
XCHG EAX,EBX |
SUB EAX,EBX |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
MOV EAX,-1 |
MOV DWORD [_declared],EAX |
_1_281: |
MOV EAX,_1_261+27 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _1_286 |
JMP _1_285 |
_1_286: |
XOR CL,CL |
CALL _compound |
JMP _1_287 |
_1_285: |
MOV EAX,_1_261+29 |
PUSH EAX |
MOV EAX,2 |
PUSH EAX |
MOV CL,2 |
CALL _amatch |
ADD ESP,8 |
OR EAX,EAX |
JNE _1_289 |
JMP _1_288 |
_1_289: |
XOR CL,CL |
CALL _doif |
MOV EAX,1 |
MOV DWORD [_lastst],EAX |
JMP _1_290 |
_1_288: |
MOV EAX,_1_261+32 |
PUSH EAX |
MOV EAX,5 |
PUSH EAX |
MOV CL,2 |
CALL _amatch |
ADD ESP,8 |
OR EAX,EAX |
JNE _1_292 |
JMP _1_291 |
_1_292: |
XOR CL,CL |
CALL _dowhile |
MOV EAX,2 |
MOV DWORD [_lastst],EAX |
JMP _1_293 |
_1_291: |
MOV EAX,_1_261+38 |
PUSH EAX |
MOV EAX,2 |
PUSH EAX |
MOV CL,2 |
CALL _amatch |
ADD ESP,8 |
OR EAX,EAX |
JNE _1_295 |
JMP _1_294 |
_1_295: |
XOR CL,CL |
CALL _dodo |
MOV EAX,8 |
MOV DWORD [_lastst],EAX |
JMP _1_296 |
_1_294: |
MOV EAX,_1_261+41 |
PUSH EAX |
MOV EAX,3 |
PUSH EAX |
MOV CL,2 |
CALL _amatch |
ADD ESP,8 |
OR EAX,EAX |
JNE _1_298 |
JMP _1_297 |
_1_298: |
XOR CL,CL |
CALL _dofor |
MOV EAX,9 |
MOV DWORD [_lastst],EAX |
JMP _1_299 |
_1_297: |
MOV EAX,_1_261+45 |
PUSH EAX |
MOV EAX,6 |
PUSH EAX |
MOV CL,2 |
CALL _amatch |
ADD ESP,8 |
OR EAX,EAX |
JNE _1_301 |
JMP _1_300 |
_1_301: |
XOR CL,CL |
CALL _doswitch |
MOV EAX,10 |
MOV DWORD [_lastst],EAX |
JMP _1_302 |
_1_300: |
MOV EAX,_1_261+52 |
PUSH EAX |
MOV EAX,4 |
PUSH EAX |
MOV CL,2 |
CALL _amatch |
ADD ESP,8 |
OR EAX,EAX |
JNE _1_304 |
JMP _1_303 |
_1_304: |
XOR CL,CL |
CALL _docase |
MOV EAX,11 |
MOV DWORD [_lastst],EAX |
JMP _1_305 |
_1_303: |
MOV EAX,_1_261+57 |
PUSH EAX |
MOV EAX,7 |
PUSH EAX |
MOV CL,2 |
CALL _amatch |
ADD ESP,8 |
OR EAX,EAX |
JNE _1_307 |
JMP _1_306 |
_1_307: |
XOR CL,CL |
CALL _dodefaul |
MOV EAX,12 |
MOV DWORD [_lastst],EAX |
JMP _1_308 |
_1_306: |
MOV EAX,_1_261+65 |
PUSH EAX |
MOV EAX,4 |
PUSH EAX |
MOV CL,2 |
CALL _amatch |
ADD ESP,8 |
OR EAX,EAX |
JNE _1_310 |
JMP _1_309 |
_1_310: |
XOR CL,CL |
CALL _dogoto |
MOV EAX,13 |
MOV DWORD [_lastst],EAX |
JMP _1_311 |
_1_309: |
XOR CL,CL |
CALL _dolabel |
OR EAX,EAX |
JNE _1_313 |
JMP _1_312 |
_1_313: |
MOV EAX,14 |
MOV DWORD [_lastst],EAX |
JMP _1_314 |
_1_312: |
MOV EAX,_1_261+70 |
PUSH EAX |
MOV EAX,6 |
PUSH EAX |
MOV CL,2 |
CALL _amatch |
ADD ESP,8 |
OR EAX,EAX |
JNE _1_316 |
JMP _1_315 |
_1_316: |
XOR CL,CL |
CALL _doreturn |
XOR CL,CL |
CALL _ns |
MOV EAX,3 |
MOV DWORD [_lastst],EAX |
JMP _1_317 |
_1_315: |
MOV EAX,_1_261+77 |
PUSH EAX |
MOV EAX,5 |
PUSH EAX |
MOV CL,2 |
CALL _amatch |
ADD ESP,8 |
OR EAX,EAX |
JNE _1_319 |
JMP _1_318 |
_1_319: |
XOR CL,CL |
CALL _dobreak |
XOR CL,CL |
CALL _ns |
MOV EAX,4 |
MOV DWORD [_lastst],EAX |
JMP _1_320 |
_1_318: |
MOV EAX,_1_261+83 |
PUSH EAX |
MOV EAX,8 |
PUSH EAX |
MOV CL,2 |
CALL _amatch |
ADD ESP,8 |
OR EAX,EAX |
JNE _1_322 |
JMP _1_321 |
_1_322: |
XOR CL,CL |
CALL _docont |
XOR CL,CL |
CALL _ns |
MOV EAX,5 |
MOV DWORD [_lastst],EAX |
JMP _1_323 |
_1_321: |
MOV EAX,_1_261+92 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _1_325 |
JMP _1_324 |
_1_325: |
XOR EAX,EAX |
MOV DWORD [_errflag],EAX |
JMP _1_326 |
_1_324: |
MOV EAX,_1_261+94 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _1_328 |
JMP _1_327 |
_1_328: |
XOR CL,CL |
CALL _doasm |
MOV EAX,6 |
MOV DWORD [_lastst],EAX |
JMP _1_329 |
_1_327: |
XOR EAX,EAX |
PUSH EAX |
MOV CL,1 |
CALL _doexpr |
ADD ESP,4 |
XOR CL,CL |
CALL _ns |
MOV EAX,7 |
MOV DWORD [_lastst],EAX |
_1_329: |
_1_326: |
_1_323: |
_1_320: |
_1_317: |
_1_314: |
_1_311: |
_1_308: |
_1_305: |
_1_302: |
_1_299: |
_1_296: |
_1_293: |
_1_290: |
_1_287: |
_1_280: |
_1_274: |
_1_271: |
_1_268: |
MOV EAX,[_lastst] |
POP EBP |
RET |
_1_261 DB 99,104,97,114,0,105,110,116,0,117 |
DB 110,115,105,103,110,101,100,0,99,104 |
DB 97,114,0,105,110,116,0,123,0,105 |
DB 102,0,119,104,105,108,101,0,100,111 |
DB 0,102,111,114,0,115,119,105,116,99 |
DB 104,0,99,97,115,101,0,100,101,102 |
DB 97,117,108,116,0,103,111,116,111,0 |
DB 114,101,116,117,114,110,0,98,114,101 |
DB 97,107,0,99,111,110,116,105,110,117 |
DB 101,0,59,0,35,97,115,109,0 |
_declloc: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-8 |
MOV EAX,[_swactive] |
OR EAX,EAX |
JNE _1_332 |
JMP _1_331 |
_1_332: |
MOV EAX,_1_330+0 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
_1_331: |
MOV EAX,[_noloc] |
OR EAX,EAX |
JNE _1_334 |
JMP _1_333 |
_1_334: |
MOV EAX,_1_330+22 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
_1_333: |
MOV EAX,[_declared] |
OR EAX,EAX |
JL _1_336 |
JMP _1_335 |
_1_336: |
MOV EAX,_1_330+44 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
_1_335: |
_1_337: |
XOR CL,CL |
CALL _endst |
OR EAX,EAX |
JNE _1_340 |
JMP _1_339 |
_1_340: |
MOV ESP,EBP |
POP EBP |
RET |
_1_339: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV EAX,2 |
PUSH EAX |
LEA EAX,[EBP-4] |
PUSH EAX |
LEA EAX,[EBP-8] |
PUSH EAX |
MOV CL,4 |
CALL _decl |
ADD ESP,16 |
MOV EAX,[_declared] |
PUSH EAX |
LEA EAX,[EBP-8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
ADD EAX,EBX |
MOV DWORD [_declared],EAX |
MOV EAX,_ssname |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV EAX,[_csp] |
PUSH EAX |
MOV EAX,[_declared] |
POP EBX |
XCHG EAX,EBX |
SUB EAX,EBX |
PUSH EAX |
MOV EAX,_locptr |
PUSH EAX |
MOV EAX,1 |
PUSH EAX |
MOV CL,7 |
CALL _addsym |
ADD ESP,28 |
MOV EAX,_1_330+72 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JE _1_342 |
JMP _1_341 |
_1_342: |
MOV ESP,EBP |
POP EBP |
RET |
_1_341: |
JMP _1_337 |
_1_338: |
MOV ESP,EBP |
POP EBP |
RET |
_1_330 DB 110,111,116,32,97,108,108,111,119,101 |
DB 100,32,105,110,32,115,119,105,116,99 |
DB 104,0,110,111,116,32,97,108,108,111 |
DB 119,101,100,32,119,105,116,104,32,103 |
DB 111,116,111,0,109,117,115,116,32,100 |
DB 101,99,108,97,114,101,32,102,105,114 |
DB 115,116,32,105,110,32,98,108,111,99 |
DB 107,0,44,0 |
_compound: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-8 |
LEA EAX,[EBP-4] |
PUSH EAX |
MOV EAX,[_csp] |
POP EBX |
MOV [EBX],EAX |
LEA EAX,[EBP-8] |
PUSH EAX |
MOV EAX,[_locptr] |
POP EBX |
MOV [EBX],EAX |
XOR EAX,EAX |
MOV DWORD [_declared],EAX |
MOV EAX,[_ncmp] |
INC EAX |
MOV DWORD [_ncmp],EAX |
_1_344: |
MOV EAX,_1_343+0 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JE _1_346 |
JMP _1_345 |
_1_346: |
MOV EAX,[_eof] |
OR EAX,EAX |
JNE _1_348 |
JMP _1_347 |
_1_348: |
MOV EAX,_1_343+2 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
JMP _1_345 |
JMP _1_349 |
_1_347: |
XOR CL,CL |
CALL _statemen |
_1_349: |
JMP _1_344 |
_1_345: |
MOV EAX,[_ncmp] |
DEC EAX |
MOV DWORD [_ncmp],EAX |
OR EAX,EAX |
JNE _1_353 |
JMP _1_351 |
_1_353: |
MOV EAX,[_lastst] |
MOV EBX,EAX |
MOV EAX,3 |
CALL __ne |
OR EAX,EAX |
JNE _1_354 |
JMP _1_351 |
_1_354: |
MOV EAX,[_lastst] |
MOV EBX,EAX |
MOV EAX,13 |
CALL __ne |
OR EAX,EAX |
JNE _1_355 |
JMP _1_351 |
_1_355: |
MOV EAX,1 |
JMP _1_352 |
_1_351: |
XOR EAX,EAX |
_1_352: |
OR EAX,EAX |
JNE _1_356 |
JMP _1_350 |
_1_356: |
MOV EAX,2 |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
_1_350: |
LEA EAX,[EBP-8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV DWORD [_cptr],EAX |
_1_357: |
MOV EAX,[_cptr] |
PUSH EAX |
MOV EAX,[_locptr] |
POP EBX |
CALL __ult |
OR EAX,EAX |
JNE _1_359 |
JMP _1_358 |
_1_359: |
MOV EAX,[_cptr] |
PUSH EAX |
MOV CL,1 |
CALL _nextsym |
ADD ESP,4 |
MOV DWORD [_cptr2],EAX |
MOV EAX,[_cptr] |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
OR EAX,EAX |
JE _1_361 |
JMP _1_360 |
_1_361: |
_1_362: |
MOV EAX,[_cptr] |
PUSH EAX |
MOV EAX,[_cptr2] |
POP EBX |
CALL __ult |
OR EAX,EAX |
JNE _1_364 |
JMP _1_363 |
_1_364: |
LEA EAX,[EBP-8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
INC EAX |
MOV [EBX],EAX |
DEC EAX |
PUSH EAX |
MOV EAX,[_cptr] |
INC EAX |
MOV DWORD [_cptr],EAX |
DEC EAX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
POP EBX |
MOV [EBX],AL |
JMP _1_362 |
_1_363: |
JMP _1_365 |
_1_360: |
MOV EAX,[_cptr2] |
MOV DWORD [_cptr],EAX |
_1_365: |
JMP _1_357 |
_1_358: |
LEA EAX,[EBP-8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV DWORD [_locptr],EAX |
MOV EAX,-1 |
MOV DWORD [_declared],EAX |
MOV ESP,EBP |
POP EBP |
RET |
_1_343 DB 125,0,110,111,32,102,105,110,97,108 |
DB 32,125,0 |
_doif: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-8 |
LEA EAX,[EBP-4] |
PUSH EAX |
XOR CL,CL |
CALL _getlabel |
POP EBX |
MOV [EBX],EAX |
PUSH EAX |
MOV EAX,1 |
PUSH EAX |
MOV CL,2 |
CALL _test |
ADD ESP,8 |
XOR CL,CL |
CALL _statemen |
MOV EAX,_1_366+0 |
PUSH EAX |
MOV EAX,4 |
PUSH EAX |
MOV CL,2 |
CALL _amatch |
ADD ESP,8 |
OR EAX,EAX |
JE _1_368 |
JMP _1_367 |
_1_368: |
MOV EAX,41 |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
MOV ESP,EBP |
POP EBP |
RET |
_1_367: |
LEA EAX,[EBP-8] |
PUSH EAX |
XOR CL,CL |
CALL _getlabel |
POP EBX |
MOV [EBX],EAX |
MOV EAX,[_lastst] |
MOV EBX,EAX |
MOV EAX,3 |
CALL __ne |
OR EAX,EAX |
JNE _1_372 |
JMP _1_370 |
_1_372: |
MOV EAX,[_lastst] |
MOV EBX,EAX |
MOV EAX,13 |
CALL __ne |
OR EAX,EAX |
JNE _1_373 |
JMP _1_370 |
_1_373: |
MOV EAX,1 |
JMP _1_371 |
_1_370: |
XOR EAX,EAX |
_1_371: |
OR EAX,EAX |
JNE _1_374 |
JMP _1_369 |
_1_374: |
MOV EAX,40 |
PUSH EAX |
LEA EAX,[EBP-8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
_1_369: |
MOV EAX,41 |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
XOR CL,CL |
CALL _statemen |
MOV EAX,41 |
PUSH EAX |
LEA EAX,[EBP-8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
MOV ESP,EBP |
POP EBP |
RET |
_1_366 DB 101,108,115,101,0 |
_dowhile: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-16 |
LEA EAX,[EBP-16] |
PUSH EAX |
MOV CL,1 |
CALL _addwhile |
ADD ESP,4 |
MOV EAX,41 |
PUSH EAX |
LEA EAX,[EBP-16] |
MOV EBX,4 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
LEA EAX,[EBP-16] |
MOV EBX,8 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV EAX,1 |
PUSH EAX |
MOV CL,2 |
CALL _test |
ADD ESP,8 |
XOR CL,CL |
CALL _statemen |
MOV EAX,40 |
PUSH EAX |
LEA EAX,[EBP-16] |
MOV EBX,4 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
MOV EAX,41 |
PUSH EAX |
LEA EAX,[EBP-16] |
MOV EBX,8 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
XOR CL,CL |
CALL _delwhile |
MOV ESP,EBP |
POP EBP |
RET |
_dodo: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-16 |
LEA EAX,[EBP-16] |
PUSH EAX |
MOV CL,1 |
CALL _addwhile |
ADD ESP,4 |
MOV EAX,41 |
PUSH EAX |
LEA EAX,[EBP-16] |
MOV EBX,4 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
XOR CL,CL |
CALL _statemen |
MOV EAX,_1_376+0 |
PUSH EAX |
MOV CL,1 |
CALL _need |
ADD ESP,4 |
LEA EAX,[EBP-16] |
MOV EBX,8 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV EAX,1 |
PUSH EAX |
MOV CL,2 |
CALL _test |
ADD ESP,8 |
MOV EAX,40 |
PUSH EAX |
LEA EAX,[EBP-16] |
MOV EBX,4 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
MOV EAX,41 |
PUSH EAX |
LEA EAX,[EBP-16] |
MOV EBX,8 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
XOR CL,CL |
CALL _delwhile |
XOR CL,CL |
CALL _ns |
MOV ESP,EBP |
POP EBP |
RET |
_1_376 DB 119,104,105,108,101,0 |
_dofor: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-24 |
LEA EAX,[EBP-16] |
PUSH EAX |
MOV CL,1 |
CALL _addwhile |
ADD ESP,4 |
LEA EAX,[EBP-20] |
PUSH EAX |
XOR CL,CL |
CALL _getlabel |
POP EBX |
MOV [EBX],EAX |
LEA EAX,[EBP-24] |
PUSH EAX |
XOR CL,CL |
CALL _getlabel |
POP EBX |
MOV [EBX],EAX |
MOV EAX,_1_377+0 |
PUSH EAX |
MOV CL,1 |
CALL _need |
ADD ESP,4 |
MOV EAX,_1_377+2 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JE _1_379 |
JMP _1_378 |
_1_379: |
XOR EAX,EAX |
PUSH EAX |
MOV CL,1 |
CALL _doexpr |
ADD ESP,4 |
XOR CL,CL |
CALL _ns |
_1_378: |
MOV EAX,41 |
PUSH EAX |
LEA EAX,[EBP-20] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
MOV EAX,_1_377+4 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JE _1_381 |
JMP _1_380 |
_1_381: |
LEA EAX,[EBP-16] |
MOV EBX,8 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _test |
ADD ESP,8 |
XOR CL,CL |
CALL _ns |
_1_380: |
MOV EAX,40 |
PUSH EAX |
LEA EAX,[EBP-24] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
MOV EAX,41 |
PUSH EAX |
LEA EAX,[EBP-16] |
MOV EBX,4 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
MOV EAX,_1_377+6 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JE _1_383 |
JMP _1_382 |
_1_383: |
XOR EAX,EAX |
PUSH EAX |
MOV CL,1 |
CALL _doexpr |
ADD ESP,4 |
MOV EAX,_1_377+8 |
PUSH EAX |
MOV CL,1 |
CALL _need |
ADD ESP,4 |
_1_382: |
MOV EAX,40 |
PUSH EAX |
LEA EAX,[EBP-20] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
MOV EAX,41 |
PUSH EAX |
LEA EAX,[EBP-24] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
XOR CL,CL |
CALL _statemen |
MOV EAX,40 |
PUSH EAX |
LEA EAX,[EBP-16] |
MOV EBX,4 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
MOV EAX,41 |
PUSH EAX |
LEA EAX,[EBP-16] |
MOV EBX,8 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
XOR CL,CL |
CALL _delwhile |
MOV ESP,EBP |
POP EBP |
RET |
_1_377 DB 40,0,59,0,59,0,41,0,41,0 |
_doswitch: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-36 |
LEA EAX,[EBP-24] |
PUSH EAX |
MOV EAX,[_swactive] |
POP EBX |
MOV [EBX],EAX |
LEA EAX,[EBP-28] |
PUSH EAX |
MOV EAX,[_swdefaul] |
POP EBX |
MOV [EBX],EAX |
LEA EAX,[EBP-32] |
PUSH EAX |
LEA EAX,[EBP-36] |
PUSH EAX |
MOV EAX,[_swnext] |
POP EBX |
MOV [EBX],EAX |
POP EBX |
MOV [EBX],EAX |
LEA EAX,[EBP-16] |
PUSH EAX |
MOV CL,1 |
CALL _addwhile |
ADD ESP,4 |
MOV EAX,[_wqptr] |
MOV EBX,4 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX,12 |
XCHG EAX,EBX |
SUB EAX,EBX |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],EAX |
MOV EAX,_1_384+0 |
PUSH EAX |
MOV CL,1 |
CALL _need |
ADD ESP,4 |
MOV EAX,1 |
PUSH EAX |
MOV CL,1 |
CALL _doexpr |
ADD ESP,4 |
MOV EAX,_1_384+2 |
PUSH EAX |
MOV CL,1 |
CALL _need |
ADD ESP,4 |
XOR EAX,EAX |
MOV DWORD [_swdefaul],EAX |
MOV EAX,1 |
MOV DWORD [_swactive],EAX |
MOV EAX,40 |
PUSH EAX |
LEA EAX,[EBP-20] |
PUSH EAX |
XOR CL,CL |
CALL _getlabel |
POP EBX |
MOV [EBX],EAX |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
XOR CL,CL |
CALL _statemen |
MOV EAX,40 |
PUSH EAX |
LEA EAX,[EBP-16] |
MOV EBX,8 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
MOV EAX,41 |
PUSH EAX |
LEA EAX,[EBP-20] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
MOV EAX,72 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
_1_385: |
LEA EAX,[EBP-36] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV EAX,[_swnext] |
POP EBX |
CALL __ult |
OR EAX,EAX |
JNE _1_387 |
JMP _1_386 |
_1_387: |
MOV EAX,56 |
PUSH EAX |
LEA EAX,[EBP-36] |
MOV EBX,EAX |
MOV EAX, [EBX] |
INC EAX |
INC EAX |
INC EAX |
INC EAX |
MOV [EBX],EAX |
DEC EAX |
DEC EAX |
DEC EAX |
DEC EAX |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
MOV EAX,112 |
PUSH EAX |
LEA EAX,[EBP-36] |
MOV EBX,EAX |
MOV EAX, [EBX] |
INC EAX |
INC EAX |
INC EAX |
INC EAX |
MOV [EBX],EAX |
DEC EAX |
DEC EAX |
DEC EAX |
DEC EAX |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
JMP _1_385 |
_1_386: |
MOV EAX,112 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
MOV EAX,[_swdefaul] |
OR EAX,EAX |
JNE _1_389 |
JMP _1_388 |
_1_389: |
MOV EAX,40 |
PUSH EAX |
MOV EAX,[_swdefaul] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
_1_388: |
MOV EAX,41 |
PUSH EAX |
LEA EAX,[EBP-16] |
MOV EBX,8 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
XOR CL,CL |
CALL _delwhile |
LEA EAX,[EBP-32] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV DWORD [_swnext],EAX |
LEA EAX,[EBP-28] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV DWORD [_swdefaul],EAX |
LEA EAX,[EBP-24] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV DWORD [_swactive],EAX |
MOV ESP,EBP |
POP EBP |
RET |
_1_384 DB 40,0,41,0 |
_docase: |
PUSH EBP |
MOV EBP,ESP |
MOV EAX,[_swactive] |
OR EAX,EAX |
JE _1_392 |
JMP _1_391 |
_1_392: |
MOV EAX,_1_390+0 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
_1_391: |
MOV EAX,[_swnext] |
PUSH EAX |
MOV EAX,[_swend] |
POP EBX |
CALL __ugt |
OR EAX,EAX |
JNE _1_394 |
JMP _1_393 |
_1_394: |
MOV EAX,_1_390+14 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
POP EBP |
RET |
_1_393: |
MOV EAX,41 |
PUSH EAX |
MOV EAX,[_swnext] |
INC EAX |
INC EAX |
INC EAX |
INC EAX |
MOV DWORD [_swnext],EAX |
DEC EAX |
DEC EAX |
DEC EAX |
DEC EAX |
PUSH EAX |
XOR CL,CL |
CALL _getlabel |
POP EBX |
MOV [EBX],EAX |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
MOV EAX,[_swnext] |
INC EAX |
INC EAX |
INC EAX |
INC EAX |
MOV DWORD [_swnext],EAX |
DEC EAX |
DEC EAX |
DEC EAX |
DEC EAX |
PUSH EAX |
MOV CL,1 |
CALL _constexp |
ADD ESP,4 |
MOV EAX,_1_390+29 |
PUSH EAX |
MOV CL,1 |
CALL _need |
ADD ESP,4 |
POP EBP |
RET |
_1_390 DB 110,111,116,32,105,110,32,115,119,105 |
DB 116,99,104,0,116,111,111,32,109,97 |
DB 110,121,32,99,97,115,101,115,0,58 |
DB 0 |
_dodefaul: |
PUSH EBP |
MOV EBP,ESP |
MOV EAX,[_swactive] |
OR EAX,EAX |
JNE _1_397 |
JMP _1_396 |
_1_397: |
MOV EAX,[_swdefaul] |
OR EAX,EAX |
JNE _1_399 |
JMP _1_398 |
_1_399: |
MOV EAX,_1_395+0 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
_1_398: |
JMP _1_400 |
_1_396: |
MOV EAX,_1_395+18 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
_1_400: |
MOV EAX,_1_395+32 |
PUSH EAX |
MOV CL,1 |
CALL _need |
ADD ESP,4 |
MOV EAX,41 |
PUSH EAX |
XOR CL,CL |
CALL _getlabel |
MOV DWORD [_swdefaul],EAX |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
POP EBP |
RET |
_1_395 DB 109,117,108,116,105,112,108,101,32,100 |
DB 101,102,97,117,108,116,115,0,110,111 |
DB 116,32,105,110,32,115,119,105,116,99 |
DB 104,0,58,0 |
_dogoto: |
PUSH EBP |
MOV EBP,ESP |
MOV EAX,[_nogo] |
OR EAX,EAX |
JG _1_403 |
JMP _1_402 |
_1_403: |
MOV EAX,_1_401+0 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
JMP _1_404 |
_1_402: |
MOV EAX,1 |
MOV DWORD [_noloc],EAX |
_1_404: |
MOV EAX,_ssname |
PUSH EAX |
MOV CL,1 |
CALL _symname |
ADD ESP,4 |
OR EAX,EAX |
JNE _1_406 |
JMP _1_405 |
_1_406: |
MOV EAX,40 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,1 |
CALL _addlabel |
ADD ESP,4 |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
JMP _1_407 |
_1_405: |
MOV EAX,_1_401+30 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
_1_407: |
XOR CL,CL |
CALL _ns |
POP EBP |
RET |
_1_401 DB 110,111,116,32,97,108,108,111,119,101 |
DB 100,32,119,105,116,104,32,98,108,111 |
DB 99,107,45,108,111,99,97,108,115,0 |
DB 98,97,100,32,108,97,98,101,108,0 |
_dolabel: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-4 |
XOR CL,CL |
CALL _blanks |
LEA EAX,[EBP-4] |
PUSH EAX |
MOV EAX,[_lptr] |
POP EBX |
MOV [EBX],EAX |
MOV EAX,_ssname |
PUSH EAX |
MOV CL,1 |
CALL _symname |
ADD ESP,4 |
OR EAX,EAX |
JNE _1_410 |
JMP _1_409 |
_1_410: |
XOR CL,CL |
CALL _gch |
MOV EBX,EAX |
MOV EAX,58 |
CALL __eq |
OR EAX,EAX |
JNE _1_412 |
JMP _1_411 |
_1_412: |
MOV EAX,41 |
PUSH EAX |
MOV EAX,1 |
PUSH EAX |
MOV CL,1 |
CALL _addlabel |
ADD ESP,4 |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
MOV EAX,1 |
MOV ESP,EBP |
POP EBP |
RET |
_1_411: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV EAX,[_lptr] |
POP EBX |
XCHG EAX,EBX |
SUB EAX,EBX |
PUSH EAX |
MOV CL,1 |
CALL _bump |
ADD ESP,4 |
_1_413: |
_1_409: |
XOR EAX,EAX |
MOV ESP,EBP |
POP EBP |
RET |
_addlabel: |
PUSH EBP |
MOV EBP,ESP |
MOV EAX,_ssname |
PUSH EAX |
MOV CL,1 |
CALL _findloc |
ADD ESP,4 |
MOV DWORD [_cptr],EAX |
OR EAX,EAX |
JNE _1_416 |
JMP _1_415 |
_1_416: |
MOV EAX,[_cptr] |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
OR EAX,EAX |
JNE _1_418 |
JMP _1_417 |
_1_418: |
MOV EAX,_1_414+0 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
JMP _1_419 |
_1_417: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _1_421 |
JMP _1_420 |
_1_421: |
MOV EAX,[_cptr] |
MOV EBX,1 |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
OR EAX,EAX |
JNE _1_423 |
JMP _1_422 |
_1_423: |
MOV EAX,_1_414+12 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
JMP _1_424 |
_1_422: |
MOV EAX,[_cptr] |
MOV EBX,1 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX,1 |
MOV [EBX],AL |
_1_424: |
_1_420: |
_1_419: |
JMP _1_425 |
_1_415: |
MOV EAX,_ssname |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
XOR CL,CL |
CALL _getlabel |
PUSH EAX |
MOV EAX,_locptr |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,7 |
CALL _addsym |
ADD ESP,28 |
MOV DWORD [_cptr],EAX |
_1_425: |
MOV EAX,[_cptr] |
MOV EBX,5 |
ADD EAX,EBX |
MOV EBX,2 |
ADD EAX,EBX |
PUSH EAX |
MOV EAX,4 |
PUSH EAX |
MOV CL,2 |
CALL _getint |
ADD ESP,8 |
POP EBP |
RET |
_1_414 DB 110,111,116,32,97,32,108,97,98,101 |
DB 108,0,100,117,112,108,105,99,97,116 |
DB 101,32,108,97,98,101,108,0 |
_doreturn: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-4 |
XOR CL,CL |
CALL _endst |
OR EAX,EAX |
JE _1_428 |
JMP _1_427 |
_1_428: |
MOV EAX,1 |
PUSH EAX |
MOV CL,1 |
CALL _doexpr |
ADD ESP,4 |
_1_427: |
LEA EAX,[EBP-4] |
PUSH EAX |
MOV EAX,[_csp] |
POP EBX |
MOV [EBX],EAX |
MOV EAX,67 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV DWORD [_csp],EAX |
MOV ESP,EBP |
POP EBP |
RET |
_dobreak: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-4 |
LEA EAX,[EBP-4] |
PUSH EAX |
MOV EAX,[_wqptr] |
PUSH EAX |
MOV CL,1 |
CALL _readwhil |
ADD ESP,4 |
POP EBX |
MOV [EBX],EAX |
OR EAX,EAX |
JE _1_431 |
JMP _1_430 |
_1_431: |
MOV ESP,EBP |
POP EBP |
RET |
_1_430: |
MOV EAX,2 |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
MOV EAX,40 |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,8 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
MOV ESP,EBP |
POP EBP |
RET |
_docont: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-4 |
LEA EAX,[EBP-4] |
PUSH EAX |
MOV EAX,[_wqptr] |
POP EBX |
MOV [EBX],EAX |
_1_433: |
LEA EAX,[EBP-4] |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _readwhil |
ADD ESP,4 |
POP EBX |
MOV [EBX],EAX |
OR EAX,EAX |
JE _1_436 |
JMP _1_435 |
_1_436: |
MOV ESP,EBP |
POP EBP |
RET |
_1_435: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,4 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _1_438 |
JMP _1_437 |
_1_438: |
JMP _1_434 |
_1_437: |
JMP _1_433 |
_1_434: |
MOV EAX,2 |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
MOV EAX,40 |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,4 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
MOV ESP,EBP |
POP EBP |
RET |
_doasm: |
PUSH EBP |
MOV EBP,ESP |
XOR EAX,EAX |
MOV DWORD [_ccode],EAX |
_1_440: |
XOR CL,CL |
CALL _inline |
MOV EAX,_1_439+0 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _1_443 |
JMP _1_442 |
_1_443: |
JMP _1_441 |
_1_442: |
MOV EAX,[_eof] |
OR EAX,EAX |
JNE _1_445 |
JMP _1_444 |
_1_445: |
JMP _1_441 |
_1_444: |
MOV EAX,[_line] |
PUSH EAX |
MOV EAX,[_output] |
PUSH EAX |
MOV CL,2 |
CALL _fputs |
ADD ESP,8 |
JMP _1_440 |
_1_441: |
XOR CL,CL |
CALL _kill |
MOV EAX,1 |
MOV DWORD [_ccode],EAX |
POP EBP |
RET |
_1_439 DB 35,101,110,100,97,115,109,0 |
_doexpr: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-16 |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV DWORD [_usexpr],EAX |
_1_447: |
LEA EAX,[EBP-12] |
PUSH EAX |
LEA EAX,[EBP-16] |
PUSH EAX |
MOV CL,2 |
CALL _setstage |
ADD ESP,8 |
LEA EAX,[EBP-4] |
PUSH EAX |
LEA EAX,[EBP-8] |
PUSH EAX |
MOV CL,2 |
CALL _expressi |
ADD ESP,8 |
LEA EAX,[EBP-12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _clearsta |
ADD ESP,8 |
MOV EAX,[_ch] |
MOV EBX,EAX |
MOV EAX,44 |
CALL __ne |
OR EAX,EAX |
JNE _1_450 |
JMP _1_449 |
_1_450: |
JMP _1_448 |
_1_449: |
MOV EAX,1 |
PUSH EAX |
MOV CL,1 |
CALL _bump |
ADD ESP,4 |
JMP _1_447 |
_1_448: |
MOV EAX,1 |
MOV DWORD [_usexpr],EAX |
MOV ESP,EBP |
POP EBP |
RET |
_ask: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-8 |
LEA EAX,[EBP-4] |
PUSH EAX |
XOR EAX,EAX |
MOV DWORD [_nxtlab],EAX |
MOV DWORD [_listfp],EAX |
POP EBX |
MOV [EBX],EAX |
MOV EAX,__iob |
MOV EBX,32 |
ADD EAX,EBX |
MOV DWORD [_output],EAX |
XOR EAX,EAX |
MOV BYTE [_optimize],AL |
XOR EAX,EAX |
MOV BYTE [_pause],AL |
MOV BYTE [_monitor],AL |
MOV BYTE [_alarm],AL |
MOV EAX,[_mline] |
MOV DWORD [_line],EAX |
_1_452: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
INC EAX |
MOV [EBX],EAX |
PUSH EAX |
MOV EAX,[_line] |
PUSH EAX |
MOV EAX,128 |
PUSH EAX |
MOV EAX,[_argcs] |
PUSH EAX |
MOV EAX,[_argvs] |
PUSH EAX |
MOV CL,5 |
CALL _getarg |
ADD ESP,20 |
MOV EBX,EAX |
MOV EAX,-1 |
CALL __ne |
OR EAX,EAX |
JNE _1_454 |
JMP _1_453 |
_1_454: |
MOV EAX,[_line] |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,45 |
CALL __ne |
OR EAX,EAX |
JNE _1_458 |
JMP _1_456 |
_1_458: |
MOV EAX,[_line] |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,47 |
CALL __ne |
OR EAX,EAX |
JNE _1_459 |
JMP _1_456 |
_1_459: |
MOV EAX,1 |
JMP _1_457 |
_1_456: |
XOR EAX,EAX |
_1_457: |
OR EAX,EAX |
JNE _1_460 |
JMP _1_455 |
_1_460: |
JMP _1_452 |
_1_455: |
MOV EAX,[_line] |
MOV EBX,1 |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _toupper |
ADD ESP,4 |
MOV EBX,EAX |
MOV EAX,76 |
CALL __eq |
OR EAX,EAX |
JNE _1_464 |
JMP _1_462 |
_1_464: |
MOV EAX,[_line] |
MOV EBX,2 |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _isdigit |
ADD ESP,4 |
OR EAX,EAX |
JNE _1_465 |
JMP _1_462 |
_1_465: |
MOV EAX,[_line] |
MOV EBX,3 |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,32 |
CALL __le |
OR EAX,EAX |
JNE _1_466 |
JMP _1_462 |
_1_466: |
MOV EAX,1 |
JMP _1_463 |
_1_462: |
XOR EAX,EAX |
_1_463: |
OR EAX,EAX |
JNE _1_467 |
JMP _1_461 |
_1_467: |
MOV EAX,[_line] |
MOV EBX,2 |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,48 |
XCHG EAX,EBX |
SUB EAX,EBX |
MOV DWORD [_listfp],EAX |
JMP _1_452 |
_1_461: |
MOV EAX,[_line] |
MOV EBX,1 |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _toupper |
ADD ESP,4 |
MOV EBX,EAX |
MOV EAX,78 |
CALL __eq |
OR EAX,EAX |
JNE _1_471 |
JMP _1_469 |
_1_471: |
MOV EAX,[_line] |
MOV EBX,2 |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _toupper |
ADD ESP,4 |
MOV EBX,EAX |
MOV EAX,79 |
CALL __eq |
OR EAX,EAX |
JNE _1_472 |
JMP _1_469 |
_1_472: |
MOV EAX,[_line] |
MOV EBX,3 |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,32 |
CALL __le |
OR EAX,EAX |
JNE _1_473 |
JMP _1_469 |
_1_473: |
MOV EAX,1 |
JMP _1_470 |
_1_469: |
XOR EAX,EAX |
_1_470: |
OR EAX,EAX |
JNE _1_474 |
JMP _1_468 |
_1_474: |
XOR EAX,EAX |
MOV BYTE [_optimize],AL |
JMP _1_452 |
_1_468: |
MOV EAX,[_line] |
MOV EBX,1 |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _toupper |
ADD ESP,4 |
MOV EBX,EAX |
MOV EAX,68 |
CALL __eq |
OR EAX,EAX |
JNE _1_476 |
JMP _1_475 |
_1_476: |
LEA EAX,[EBP-8] |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],EAX |
MOV EAX,[_line] |
PUSH EAX |
LEA EAX,[EBP-8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,2 |
ADD EAX,EBX |
POP EBX |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV DWORD [_ch],EAX |
MOV EAX,[_line] |
PUSH EAX |
LEA EAX,[EBP-8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
ADD EAX,EBX |
MOV EBX,2 |
ADD EAX,EBX |
MOV DWORD [_lptr],EAX |
XOR CL,CL |
CALL _dodefine |
JMP _1_452 |
_1_475: |
MOV EAX,[_line] |
MOV EBX,2 |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,32 |
CALL __le |
OR EAX,EAX |
JNE _1_478 |
JMP _1_477 |
_1_478: |
MOV EAX,[_line] |
MOV EBX,1 |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _toupper |
ADD ESP,4 |
MOV EBX,EAX |
MOV EAX,65 |
CALL __eq |
OR EAX,EAX |
JNE _1_480 |
JMP _1_479 |
_1_480: |
MOV EAX,1 |
MOV BYTE [_alarm],AL |
JMP _1_452 |
_1_479: |
MOV EAX,[_line] |
MOV EBX,1 |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _toupper |
ADD ESP,4 |
MOV EBX,EAX |
MOV EAX,77 |
CALL __eq |
OR EAX,EAX |
JNE _1_482 |
JMP _1_481 |
_1_482: |
MOV EAX,1 |
MOV BYTE [_monitor],AL |
JMP _1_452 |
_1_481: |
MOV EAX,[_line] |
MOV EBX,1 |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _toupper |
ADD ESP,4 |
MOV EBX,EAX |
MOV EAX,80 |
CALL __eq |
OR EAX,EAX |
JNE _1_484 |
JMP _1_483 |
_1_484: |
MOV EAX,1 |
MOV BYTE [_pause],AL |
JMP _1_452 |
_1_483: |
_1_477: |
MOV EAX,_1_451+0 |
PUSH EAX |
MOV EAX,__iob |
MOV EBX,64 |
ADD EAX,EBX |
PUSH EAX |
MOV CL,2 |
CALL _fputs |
ADD ESP,8 |
MOV EAX,_1_451+57 |
PUSH EAX |
MOV EAX,__iob |
MOV EBX,64 |
ADD EAX,EBX |
PUSH EAX |
MOV CL,2 |
CALL _fputs |
ADD ESP,8 |
MOV EAX,_1_451+74 |
PUSH EAX |
MOV EAX,__iob |
MOV EBX,64 |
ADD EAX,EBX |
PUSH EAX |
MOV CL,2 |
CALL _fputs |
ADD ESP,8 |
MOV EAX,_1_451+89 |
PUSH EAX |
MOV EAX,__iob |
MOV EBX,64 |
ADD EAX,EBX |
PUSH EAX |
MOV CL,2 |
CALL _fputs |
ADD ESP,8 |
MOV EAX,_1_451+104 |
PUSH EAX |
MOV EAX,__iob |
MOV EBX,64 |
ADD EAX,EBX |
PUSH EAX |
MOV CL,2 |
CALL _fputs |
ADD ESP,8 |
MOV EAX,_1_451+118 |
PUSH EAX |
MOV EAX,__iob |
MOV EBX,64 |
ADD EAX,EBX |
PUSH EAX |
MOV CL,2 |
CALL _fputs |
ADD ESP,8 |
MOV EAX,_1_451+139 |
PUSH EAX |
MOV EAX,__iob |
MOV EBX,64 |
ADD EAX,EBX |
PUSH EAX |
MOV CL,2 |
CALL _fputs |
ADD ESP,8 |
MOV EAX,7 |
PUSH EAX |
MOV CL,1 |
CALL _OS_exit |
ADD ESP,4 |
JMP _1_452 |
_1_453: |
MOV ESP,EBP |
POP EBP |
RET |
_1_451 DB 117,115,97,103,101,58,32,99,99,32 |
DB 91,102,105,108,101,93,46,46,46,32 |
DB 91,45,109,93,32,91,45,97,93,32 |
DB 91,45,112,93,32,91,45,108,35,93 |
DB 32,91,45,110,111,93,32,91,45,100 |
DB 60,105,100,62,93,10,0,32,45,109 |
DB 32,32,32,32,32,109,111,110,105,116 |
DB 111,114,10,0,32,45,97,32,32,32 |
DB 32,32,97,108,97,114,109,10,0,32 |
DB 45,112,32,32,32,32,32,112,97,117 |
DB 115,101,10,0,32,45,108,35,32,32 |
DB 32,32,108,105,115,116,10,0,32,45 |
DB 110,111,32,32,32,32,110,111,32,111 |
DB 112,116,105,109,105,122,101,10,0,32 |
DB 45,100,60,105,100,62,32,112,114,101 |
DB 45,35,100,101,102,105,110,101,32,105 |
DB 100,10,0 |
_openfile: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-28 |
MOV EAX,-1 |
MOV DWORD [_input],EAX |
_1_486: |
MOV EAX,[_filearg] |
INC EAX |
MOV DWORD [_filearg],EAX |
PUSH EAX |
MOV EAX,[_pline] |
PUSH EAX |
MOV EAX,128 |
PUSH EAX |
MOV EAX,[_argcs] |
PUSH EAX |
MOV EAX,[_argvs] |
PUSH EAX |
MOV CL,5 |
CALL _getarg |
ADD ESP,20 |
MOV EBX,EAX |
MOV EAX,-1 |
CALL __ne |
OR EAX,EAX |
JNE _1_488 |
JMP _1_487 |
_1_488: |
MOV EAX,[_pline] |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,45 |
CALL __eq |
OR EAX,EAX |
JE _1_492 |
JMP _1_490 |
_1_492: |
MOV EAX,[_pline] |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,47 |
CALL __eq |
OR EAX,EAX |
JE _1_493 |
JMP _1_490 |
_1_493: |
XOR EAX,EAX |
JMP _1_491 |
_1_490: |
MOV EAX,1 |
_1_491: |
OR EAX,EAX |
JNE _1_494 |
JMP _1_489 |
_1_494: |
JMP _1_486 |
_1_489: |
LEA EAX,[EBP-28] |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],EAX |
LEA EAX,[EBP-20] |
MOV EBX,EAX |
MOV EAX,-1 |
MOV [EBX],EAX |
LEA EAX,[EBP-24] |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],EAX |
_1_495: |
MOV EAX,[_pline] |
PUSH EAX |
LEA EAX,[EBP-20] |
MOV EBX,EAX |
MOV EAX, [EBX] |
INC EAX |
MOV [EBX],EAX |
POP EBX |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
OR EAX,EAX |
JNE _1_497 |
JMP _1_496 |
_1_497: |
MOV EAX,[_pline] |
PUSH EAX |
LEA EAX,[EBP-20] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,46 |
CALL __eq |
OR EAX,EAX |
JNE _1_499 |
JMP _1_498 |
_1_499: |
LEA EAX,[EBP-28] |
MOV EBX,EAX |
MOV EAX,1 |
MOV [EBX],EAX |
JMP _1_496 |
_1_498: |
LEA EAX,[EBP-24] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,10 |
CALL __lt |
OR EAX,EAX |
JNE _1_501 |
JMP _1_500 |
_1_501: |
LEA EAX,[EBP-16] |
PUSH EAX |
LEA EAX,[EBP-24] |
MOV EBX,EAX |
MOV EAX, [EBX] |
INC EAX |
MOV [EBX],EAX |
DEC EAX |
POP EBX |
ADD EAX,EBX |
PUSH EAX |
MOV EAX,[_pline] |
PUSH EAX |
LEA EAX,[EBP-20] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
POP EBX |
MOV [EBX],AL |
_1_500: |
JMP _1_495 |
_1_496: |
LEA EAX,[EBP-28] |
MOV EBX,EAX |
MOV EAX, [EBX] |
CALL __lneg |
OR EAX,EAX |
JNE _1_503 |
JMP _1_502 |
_1_503: |
MOV EAX,[_pline] |
PUSH EAX |
LEA EAX,[EBP-20] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
ADD EAX,EBX |
PUSH EAX |
MOV EAX,_1_485+0 |
PUSH EAX |
MOV CL,2 |
CALL _strcpy |
ADD ESP,8 |
_1_502: |
MOV EAX,[_pline] |
PUSH EAX |
MOV EAX,_1_485+3 |
PUSH EAX |
MOV CL,2 |
CALL _mustopen |
ADD ESP,8 |
MOV DWORD [_input],EAX |
MOV EAX,[_files] |
CALL __lneg |
OR EAX,EAX |
JNE _1_505 |
JMP _1_504 |
_1_505: |
LEA EAX,[EBP-16] |
PUSH EAX |
LEA EAX,[EBP-24] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
ADD EAX,EBX |
PUSH EAX |
MOV EAX,_1_485+5 |
PUSH EAX |
MOV CL,2 |
CALL _strcpy |
ADD ESP,8 |
LEA EAX,[EBP-16] |
PUSH EAX |
MOV EAX,_1_485+10 |
PUSH EAX |
MOV CL,2 |
CALL _mustopen |
ADD ESP,8 |
MOV DWORD [_output],EAX |
_1_504: |
MOV EAX,1 |
MOV DWORD [_files],EAX |
XOR CL,CL |
CALL _kill |
MOV ESP,EBP |
POP EBP |
RET |
JMP _1_486 |
_1_487: |
MOV EAX,[_files] |
INC EAX |
MOV DWORD [_files],EAX |
DEC EAX |
OR EAX,EAX |
JNE _1_507 |
JMP _1_506 |
_1_507: |
MOV EAX,1 |
MOV DWORD [_eof],EAX |
JMP _1_508 |
_1_506: |
MOV EAX,__iob |
MOV DWORD [_input],EAX |
_1_508: |
XOR CL,CL |
CALL _kill |
MOV ESP,EBP |
POP EBP |
RET |
_1_485 DB 46,67,0,114,0,46,65,83,77,0 |
DB 119,0 |
_mustopen: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-4 |
LEA EAX,[EBP-4] |
PUSH EAX |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _OS_fopen |
ADD ESP,8 |
POP EBX |
MOV [EBX],EAX |
OR EAX,EAX |
JNE _1_511 |
JMP _1_510 |
_1_511: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV ESP,EBP |
POP EBP |
RET |
_1_510: |
MOV EAX,_1_509+0 |
PUSH EAX |
MOV EAX,__iob |
MOV EBX,64 |
ADD EAX,EBX |
PUSH EAX |
MOV CL,2 |
CALL _fputs |
ADD ESP,8 |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV EAX,__iob |
MOV EBX,64 |
ADD EAX,EBX |
PUSH EAX |
MOV CL,2 |
CALL _lout |
ADD ESP,8 |
MOV EAX,7 |
PUSH EAX |
MOV CL,1 |
CALL _OS_exit |
ADD ESP,4 |
MOV ESP,EBP |
POP EBP |
RET |
_1_509 DB 111,112,101,110,32,101,114,114,111,114 |
DB 32,111,110,32,0 |
/programs/develop/scc/CC2.ASM |
---|
0,0 → 1,3034 |
_preproce: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-8 |
MOV EAX,[_ccode] |
OR EAX,EAX |
JNE _2_3 |
JMP _2_2 |
_2_3: |
MOV EAX,[_mline] |
MOV DWORD [_line],EAX |
XOR CL,CL |
CALL _ifline |
MOV EAX,[_eof] |
OR EAX,EAX |
JNE _2_5 |
JMP _2_4 |
_2_5: |
MOV ESP,EBP |
POP EBP |
RET |
_2_4: |
JMP _2_6 |
_2_2: |
XOR CL,CL |
CALL _inline |
MOV ESP,EBP |
POP EBP |
RET |
_2_6: |
MOV EAX,-1 |
MOV DWORD [_pptr],EAX |
_2_7: |
MOV EAX,[_ch] |
MOV EBX,EAX |
MOV EAX,10 |
CALL __ne |
OR EAX,EAX |
JNE _2_11 |
JMP _2_9 |
_2_11: |
MOV EAX,[_ch] |
OR EAX,EAX |
JNE _2_12 |
JMP _2_9 |
_2_12: |
MOV EAX,1 |
JMP _2_10 |
_2_9: |
XOR EAX,EAX |
_2_10: |
OR EAX,EAX |
JNE _2_13 |
JMP _2_8 |
_2_13: |
XOR CL,CL |
CALL _white |
OR EAX,EAX |
JNE _2_15 |
JMP _2_14 |
_2_15: |
MOV EAX,32 |
PUSH EAX |
MOV CL,1 |
CALL _keepch |
ADD ESP,4 |
_2_16: |
XOR CL,CL |
CALL _white |
OR EAX,EAX |
JNE _2_18 |
JMP _2_17 |
_2_18: |
XOR CL,CL |
CALL _gch |
JMP _2_16 |
_2_17: |
JMP _2_19 |
_2_14: |
MOV EAX,[_ch] |
MOV EBX,EAX |
MOV EAX,34 |
CALL __eq |
OR EAX,EAX |
JNE _2_21 |
JMP _2_20 |
_2_21: |
MOV EAX,[_ch] |
PUSH EAX |
MOV CL,1 |
CALL _keepch |
ADD ESP,4 |
XOR CL,CL |
CALL _gch |
_2_22: |
MOV EAX,[_ch] |
MOV EBX,EAX |
MOV EAX,34 |
CALL __ne |
OR EAX,EAX |
JE _2_28 |
JMP _2_24 |
_2_28: |
MOV EAX,[_lptr] |
MOV EBX,EAX |
MOV EAX,1 |
XCHG EAX,EBX |
SUB EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,92 |
CALL __eq |
OR EAX,EAX |
JNE _2_29 |
JMP _2_25 |
_2_29: |
MOV EAX,[_lptr] |
MOV EBX,EAX |
MOV EAX,2 |
XCHG EAX,EBX |
SUB EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,92 |
CALL __ne |
OR EAX,EAX |
JNE _2_30 |
JMP _2_25 |
_2_30: |
MOV EAX,1 |
JMP _2_26 |
_2_25: |
XOR EAX,EAX |
_2_26: |
OR EAX,EAX |
JE _2_31 |
JMP _2_24 |
_2_31: |
XOR EAX,EAX |
JMP _2_27 |
_2_24: |
MOV EAX,1 |
_2_27: |
OR EAX,EAX |
JNE _2_32 |
JMP _2_23 |
_2_32: |
MOV EAX,[_ch] |
OR EAX,EAX |
JE _2_34 |
JMP _2_33 |
_2_34: |
MOV EAX,_2_1+0 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
JMP _2_23 |
_2_33: |
XOR CL,CL |
CALL _gch |
PUSH EAX |
MOV CL,1 |
CALL _keepch |
ADD ESP,4 |
JMP _2_22 |
_2_23: |
XOR CL,CL |
CALL _gch |
MOV EAX,34 |
PUSH EAX |
MOV CL,1 |
CALL _keepch |
ADD ESP,4 |
JMP _2_35 |
_2_20: |
MOV EAX,[_ch] |
MOV EBX,EAX |
MOV EAX,39 |
CALL __eq |
OR EAX,EAX |
JNE _2_37 |
JMP _2_36 |
_2_37: |
MOV EAX,39 |
PUSH EAX |
MOV CL,1 |
CALL _keepch |
ADD ESP,4 |
XOR CL,CL |
CALL _gch |
_2_38: |
MOV EAX,[_ch] |
MOV EBX,EAX |
MOV EAX,39 |
CALL __ne |
OR EAX,EAX |
JE _2_44 |
JMP _2_40 |
_2_44: |
MOV EAX,[_lptr] |
MOV EBX,EAX |
MOV EAX,1 |
XCHG EAX,EBX |
SUB EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,92 |
CALL __eq |
OR EAX,EAX |
JNE _2_45 |
JMP _2_41 |
_2_45: |
MOV EAX,[_lptr] |
MOV EBX,EAX |
MOV EAX,2 |
XCHG EAX,EBX |
SUB EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,92 |
CALL __ne |
OR EAX,EAX |
JNE _2_46 |
JMP _2_41 |
_2_46: |
MOV EAX,1 |
JMP _2_42 |
_2_41: |
XOR EAX,EAX |
_2_42: |
OR EAX,EAX |
JE _2_47 |
JMP _2_40 |
_2_47: |
XOR EAX,EAX |
JMP _2_43 |
_2_40: |
MOV EAX,1 |
_2_43: |
OR EAX,EAX |
JNE _2_48 |
JMP _2_39 |
_2_48: |
MOV EAX,[_ch] |
OR EAX,EAX |
JE _2_50 |
JMP _2_49 |
_2_50: |
MOV EAX,_2_1+9 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
JMP _2_39 |
_2_49: |
XOR CL,CL |
CALL _gch |
PUSH EAX |
MOV CL,1 |
CALL _keepch |
ADD ESP,4 |
JMP _2_38 |
_2_39: |
XOR CL,CL |
CALL _gch |
MOV EAX,39 |
PUSH EAX |
MOV CL,1 |
CALL _keepch |
ADD ESP,4 |
JMP _2_51 |
_2_36: |
MOV EAX,[_ch] |
MOV EBX,EAX |
MOV EAX,47 |
CALL __eq |
OR EAX,EAX |
JNE _2_55 |
JMP _2_53 |
_2_55: |
MOV EAX,[_nch] |
MOV EBX,EAX |
MOV EAX,42 |
CALL __eq |
OR EAX,EAX |
JNE _2_56 |
JMP _2_53 |
_2_56: |
MOV EAX,1 |
JMP _2_54 |
_2_53: |
XOR EAX,EAX |
_2_54: |
OR EAX,EAX |
JNE _2_57 |
JMP _2_52 |
_2_57: |
MOV EAX,2 |
PUSH EAX |
MOV CL,1 |
CALL _bump |
ADD ESP,4 |
_2_58: |
MOV EAX,[_ch] |
MOV EBX,EAX |
MOV EAX,42 |
CALL __eq |
OR EAX,EAX |
JNE _2_62 |
JMP _2_60 |
_2_62: |
MOV EAX,[_nch] |
MOV EBX,EAX |
MOV EAX,47 |
CALL __eq |
OR EAX,EAX |
JNE _2_63 |
JMP _2_60 |
_2_63: |
MOV EAX,1 |
JMP _2_61 |
_2_60: |
XOR EAX,EAX |
_2_61: |
OR EAX,EAX |
JE _2_64 |
JMP _2_59 |
_2_64: |
MOV EAX,[_ch] |
OR EAX,EAX |
JNE _2_66 |
JMP _2_65 |
_2_66: |
MOV EAX,1 |
PUSH EAX |
MOV CL,1 |
CALL _bump |
ADD ESP,4 |
JMP _2_67 |
_2_65: |
XOR CL,CL |
CALL _ifline |
MOV EAX,[_eof] |
OR EAX,EAX |
JNE _2_69 |
JMP _2_68 |
_2_69: |
JMP _2_59 |
_2_68: |
_2_67: |
JMP _2_58 |
_2_59: |
MOV EAX,2 |
PUSH EAX |
MOV CL,1 |
CALL _bump |
ADD ESP,4 |
JMP _2_70 |
_2_52: |
MOV EAX,[_ch] |
MOV EBX,EAX |
MOV EAX,47 |
CALL __eq |
OR EAX,EAX |
JNE _2_74 |
JMP _2_72 |
_2_74: |
MOV EAX,[_nch] |
MOV EBX,EAX |
MOV EAX,47 |
CALL __eq |
OR EAX,EAX |
JNE _2_75 |
JMP _2_72 |
_2_75: |
MOV EAX,1 |
JMP _2_73 |
_2_72: |
XOR EAX,EAX |
_2_73: |
OR EAX,EAX |
JNE _2_76 |
JMP _2_71 |
_2_76: |
MOV EAX,2 |
PUSH EAX |
MOV CL,1 |
CALL _bump |
ADD ESP,4 |
_2_77: |
MOV EAX,[_ch] |
MOV EBX,EAX |
MOV EAX,10 |
CALL __ne |
OR EAX,EAX |
JNE _2_79 |
JMP _2_78 |
_2_79: |
MOV EAX,[_ch] |
OR EAX,EAX |
JNE _2_81 |
JMP _2_80 |
_2_81: |
MOV EAX,1 |
PUSH EAX |
MOV CL,1 |
CALL _bump |
ADD ESP,4 |
JMP _2_82 |
_2_80: |
MOV EAX,[_eof] |
OR EAX,EAX |
JNE _2_84 |
JMP _2_83 |
_2_84: |
JMP _2_78 |
_2_83: |
_2_82: |
JMP _2_77 |
_2_78: |
MOV EAX,1 |
PUSH EAX |
MOV CL,1 |
CALL _bump |
ADD ESP,4 |
JMP _2_85 |
_2_71: |
MOV EAX,[_ch] |
PUSH EAX |
MOV CL,1 |
CALL _an |
ADD ESP,4 |
OR EAX,EAX |
JNE _2_87 |
JMP _2_86 |
_2_87: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],EAX |
_2_88: |
MOV EAX,[_ch] |
PUSH EAX |
MOV CL,1 |
CALL _an |
ADD ESP,4 |
OR EAX,EAX |
JNE _2_92 |
JMP _2_90 |
_2_92: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,8 |
CALL __lt |
OR EAX,EAX |
JNE _2_93 |
JMP _2_90 |
_2_93: |
MOV EAX,1 |
JMP _2_91 |
_2_90: |
XOR EAX,EAX |
_2_91: |
OR EAX,EAX |
JNE _2_94 |
JMP _2_89 |
_2_94: |
MOV EAX,_msname |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
INC EAX |
MOV [EBX],EAX |
DEC EAX |
POP EBX |
ADD EAX,EBX |
PUSH EAX |
MOV EAX,[_ch] |
POP EBX |
MOV [EBX],AL |
XOR CL,CL |
CALL _gch |
JMP _2_88 |
_2_89: |
MOV EAX,_msname |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
ADD EAX,EBX |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],AL |
MOV EAX,_msname |
PUSH EAX |
MOV EAX,[_macn] |
PUSH EAX |
MOV EAX,11 |
PUSH EAX |
MOV EAX,[_macn] |
MOV EBX,3300 |
ADD EAX,EBX |
PUSH EAX |
MOV EAX,300 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,6 |
CALL _search |
ADD ESP,24 |
OR EAX,EAX |
JNE _2_96 |
JMP _2_95 |
_2_96: |
LEA EAX,[EBP-4] |
PUSH EAX |
MOV EAX,[_cptr] |
MOV EBX,9 |
ADD EAX,EBX |
PUSH EAX |
MOV EAX,2 |
PUSH EAX |
MOV CL,2 |
CALL _getint |
ADD ESP,8 |
POP EBX |
MOV [EBX],EAX |
_2_97: |
LEA EAX,[EBP-8] |
PUSH EAX |
MOV EAX,[_macq] |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
INC EAX |
MOV [EBX],EAX |
DEC EAX |
POP EBX |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
POP EBX |
MOV [EBX],AL |
OR EAX,EAX |
JNE _2_99 |
JMP _2_98 |
_2_99: |
LEA EAX,[EBP-8] |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _keepch |
ADD ESP,4 |
JMP _2_97 |
_2_98: |
_2_100: |
MOV EAX,[_ch] |
PUSH EAX |
MOV CL,1 |
CALL _an |
ADD ESP,4 |
OR EAX,EAX |
JNE _2_102 |
JMP _2_101 |
_2_102: |
XOR CL,CL |
CALL _gch |
JMP _2_100 |
_2_101: |
JMP _2_103 |
_2_95: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],EAX |
_2_104: |
LEA EAX,[EBP-8] |
PUSH EAX |
MOV EAX,_msname |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
INC EAX |
MOV [EBX],EAX |
DEC EAX |
POP EBX |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
POP EBX |
MOV [EBX],AL |
OR EAX,EAX |
JNE _2_106 |
JMP _2_105 |
_2_106: |
LEA EAX,[EBP-8] |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _keepch |
ADD ESP,4 |
JMP _2_104 |
_2_105: |
_2_103: |
JMP _2_107 |
_2_86: |
XOR CL,CL |
CALL _gch |
PUSH EAX |
MOV CL,1 |
CALL _keepch |
ADD ESP,4 |
_2_107: |
_2_85: |
_2_70: |
_2_51: |
_2_35: |
_2_19: |
JMP _2_7 |
_2_8: |
MOV EAX,[_pptr] |
MOV EBX,EAX |
MOV EAX,127 |
CALL __ge |
OR EAX,EAX |
JNE _2_109 |
JMP _2_108 |
_2_109: |
MOV EAX,_2_1+23 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
_2_108: |
XOR EAX,EAX |
PUSH EAX |
MOV CL,1 |
CALL _keepch |
ADD ESP,4 |
MOV EAX,[_pline] |
MOV DWORD [_line],EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,1 |
CALL _bump |
ADD ESP,4 |
MOV ESP,EBP |
POP EBP |
RET |
_2_1 DB 110,111,32,113,117,111,116,101,0,110 |
DB 111,32,97,112,111,115,116,114,111,112 |
DB 104,101,0,108,105,110,101,32,116,111 |
DB 111,32,108,111,110,103,0 |
_keepch: |
PUSH EBP |
MOV EBP,ESP |
MOV EAX,[_pptr] |
MOV EBX,EAX |
MOV EAX,127 |
CALL __lt |
OR EAX,EAX |
JNE _2_112 |
JMP _2_111 |
_2_112: |
MOV EAX,[_pline] |
PUSH EAX |
MOV EAX,[_pptr] |
INC EAX |
MOV DWORD [_pptr],EAX |
POP EBX |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
POP EBX |
MOV [EBX],AL |
_2_111: |
POP EBP |
RET |
_ifline: |
PUSH EBP |
MOV EBP,ESP |
_2_114: |
XOR CL,CL |
CALL _inline |
MOV EAX,[_eof] |
OR EAX,EAX |
JNE _2_117 |
JMP _2_116 |
_2_117: |
POP EBP |
RET |
_2_116: |
MOV EAX,_2_113+0 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _2_119 |
JMP _2_118 |
_2_119: |
MOV EAX,[_iflevel] |
INC EAX |
MOV DWORD [_iflevel],EAX |
MOV EAX,[_skipleve] |
OR EAX,EAX |
JNE _2_121 |
JMP _2_120 |
_2_121: |
JMP _2_114 |
_2_120: |
MOV EAX,_msname |
PUSH EAX |
MOV CL,1 |
CALL _symname |
ADD ESP,4 |
MOV EAX,_msname |
PUSH EAX |
MOV EAX,[_macn] |
PUSH EAX |
MOV EAX,11 |
PUSH EAX |
MOV EAX,[_macn] |
MOV EBX,3300 |
ADD EAX,EBX |
PUSH EAX |
MOV EAX,300 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,6 |
CALL _search |
ADD ESP,24 |
OR EAX,EAX |
JE _2_123 |
JMP _2_122 |
_2_123: |
MOV EAX,[_iflevel] |
MOV DWORD [_skipleve],EAX |
_2_122: |
JMP _2_114 |
_2_118: |
MOV EAX,_2_113+7 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _2_125 |
JMP _2_124 |
_2_125: |
MOV EAX,[_iflevel] |
INC EAX |
MOV DWORD [_iflevel],EAX |
MOV EAX,[_skipleve] |
OR EAX,EAX |
JNE _2_127 |
JMP _2_126 |
_2_127: |
JMP _2_114 |
_2_126: |
MOV EAX,_msname |
PUSH EAX |
MOV CL,1 |
CALL _symname |
ADD ESP,4 |
MOV EAX,_msname |
PUSH EAX |
MOV EAX,[_macn] |
PUSH EAX |
MOV EAX,11 |
PUSH EAX |
MOV EAX,[_macn] |
MOV EBX,3300 |
ADD EAX,EBX |
PUSH EAX |
MOV EAX,300 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,6 |
CALL _search |
ADD ESP,24 |
OR EAX,EAX |
JNE _2_129 |
JMP _2_128 |
_2_129: |
MOV EAX,[_iflevel] |
MOV DWORD [_skipleve],EAX |
_2_128: |
JMP _2_114 |
_2_124: |
MOV EAX,_2_113+15 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _2_131 |
JMP _2_130 |
_2_131: |
MOV EAX,[_iflevel] |
OR EAX,EAX |
JNE _2_133 |
JMP _2_132 |
_2_133: |
MOV EAX,[_skipleve] |
PUSH EAX |
MOV EAX,[_iflevel] |
POP EBX |
CALL __eq |
OR EAX,EAX |
JNE _2_135 |
JMP _2_134 |
_2_135: |
XOR EAX,EAX |
MOV DWORD [_skipleve],EAX |
JMP _2_136 |
_2_134: |
MOV EAX,[_skipleve] |
OR EAX,EAX |
JE _2_138 |
JMP _2_137 |
_2_138: |
MOV EAX,[_iflevel] |
MOV DWORD [_skipleve],EAX |
_2_137: |
_2_136: |
JMP _2_139 |
_2_132: |
XOR CL,CL |
CALL _noiferr |
_2_139: |
JMP _2_114 |
_2_130: |
MOV EAX,_2_113+21 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _2_141 |
JMP _2_140 |
_2_141: |
MOV EAX,[_iflevel] |
OR EAX,EAX |
JNE _2_143 |
JMP _2_142 |
_2_143: |
MOV EAX,[_skipleve] |
PUSH EAX |
MOV EAX,[_iflevel] |
POP EBX |
CALL __eq |
OR EAX,EAX |
JNE _2_145 |
JMP _2_144 |
_2_145: |
XOR EAX,EAX |
MOV DWORD [_skipleve],EAX |
_2_144: |
MOV EAX,[_iflevel] |
DEC EAX |
MOV DWORD [_iflevel],EAX |
JMP _2_146 |
_2_142: |
XOR CL,CL |
CALL _noiferr |
_2_146: |
JMP _2_114 |
_2_140: |
MOV EAX,[_skipleve] |
OR EAX,EAX |
JNE _2_148 |
JMP _2_147 |
_2_148: |
JMP _2_114 |
_2_147: |
MOV EAX,[_ch] |
OR EAX,EAX |
JE _2_150 |
JMP _2_149 |
_2_150: |
JMP _2_114 |
_2_149: |
JMP _2_115 |
JMP _2_114 |
_2_115: |
POP EBP |
RET |
_2_113 DB 35,105,102,100,101,102,0,35,105,102 |
DB 110,100,101,102,0,35,101,108,115,101 |
DB 0,35,101,110,100,105,102,0 |
_inline: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-8 |
MOV EAX,[_input] |
MOV EBX,EAX |
MOV EAX,-1 |
CALL __eq |
OR EAX,EAX |
JNE _2_153 |
JMP _2_152 |
_2_153: |
XOR CL,CL |
CALL _openfile |
_2_152: |
MOV EAX,[_eof] |
OR EAX,EAX |
JNE _2_155 |
JMP _2_154 |
_2_155: |
MOV ESP,EBP |
POP EBP |
RET |
_2_154: |
LEA EAX,[EBP-8] |
PUSH EAX |
MOV EAX,[_input2] |
POP EBX |
MOV [EBX],EAX |
MOV EBX,EAX |
MOV EAX,-1 |
CALL __eq |
OR EAX,EAX |
JNE _2_157 |
JMP _2_156 |
_2_157: |
LEA EAX,[EBP-8] |
PUSH EAX |
MOV EAX,[_input] |
POP EBX |
MOV [EBX],EAX |
_2_156: |
MOV EAX,[_line] |
PUSH EAX |
MOV EAX,127 |
PUSH EAX |
LEA EAX,[EBP-8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,3 |
CALL _fgets |
ADD ESP,12 |
OR EAX,EAX |
JE _2_159 |
JMP _2_158 |
_2_159: |
LEA EAX,[EBP-8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _OS_fclos |
ADD ESP,4 |
MOV EAX,[_input2] |
MOV EBX,EAX |
MOV EAX,-1 |
CALL __ne |
OR EAX,EAX |
JNE _2_161 |
JMP _2_160 |
_2_161: |
MOV EAX,-1 |
MOV DWORD [_input2],EAX |
JMP _2_162 |
_2_160: |
MOV EAX,-1 |
MOV DWORD [_input],EAX |
_2_162: |
MOV EAX,[_line] |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],AL |
JMP _2_163 |
_2_158: |
MOV EAX,[_listfp] |
OR EAX,EAX |
JNE _2_165 |
JMP _2_164 |
_2_165: |
MOV EAX,[_listfp] |
PUSH EAX |
MOV EAX,[_output] |
POP EBX |
CALL __eq |
OR EAX,EAX |
JNE _2_167 |
JMP _2_166 |
_2_167: |
MOV EAX,59 |
PUSH EAX |
MOV EAX,[_output] |
PUSH EAX |
MOV CL,2 |
CALL _OS_fputc |
ADD ESP,8 |
_2_166: |
MOV EAX,[_line] |
PUSH EAX |
MOV EAX,[_listfp] |
PUSH EAX |
MOV CL,2 |
CALL _fputs |
ADD ESP,8 |
_2_164: |
_2_163: |
XOR EAX,EAX |
PUSH EAX |
MOV CL,1 |
CALL _bump |
ADD ESP,4 |
MOV ESP,EBP |
POP EBP |
RET |
_inbyte: |
PUSH EBP |
MOV EBP,ESP |
_2_169: |
MOV EAX,[_ch] |
OR EAX,EAX |
JE _2_171 |
JMP _2_170 |
_2_171: |
MOV EAX,[_eof] |
OR EAX,EAX |
JNE _2_173 |
JMP _2_172 |
_2_173: |
XOR EAX,EAX |
POP EBP |
RET |
_2_172: |
XOR CL,CL |
CALL _preproce |
JMP _2_169 |
_2_170: |
XOR CL,CL |
CALL _gch |
POP EBP |
RET |
_symname: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-8 |
XOR CL,CL |
CALL _blanks |
MOV EAX,[_ch] |
PUSH EAX |
MOV CL,1 |
CALL _alpha |
ADD ESP,4 |
OR EAX,EAX |
JE _2_176 |
JMP _2_175 |
_2_176: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],AL |
MOV ESP,EBP |
POP EBP |
RET |
_2_175: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],EAX |
_2_177: |
MOV EAX,[_ch] |
PUSH EAX |
MOV CL,1 |
CALL _an |
ADD ESP,4 |
OR EAX,EAX |
JNE _2_179 |
JMP _2_178 |
_2_179: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
ADD EAX,EBX |
PUSH EAX |
XOR CL,CL |
CALL _gch |
POP EBX |
MOV [EBX],AL |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,8 |
CALL __lt |
OR EAX,EAX |
JNE _2_181 |
JMP _2_180 |
_2_181: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
INC EAX |
MOV [EBX],EAX |
_2_180: |
JMP _2_177 |
_2_178: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
ADD EAX,EBX |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],AL |
MOV EAX,1 |
MOV ESP,EBP |
POP EBP |
RET |
_need: |
PUSH EBP |
MOV EBP,ESP |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JE _2_184 |
JMP _2_183 |
_2_184: |
MOV EAX,_2_182+0 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
_2_183: |
POP EBP |
RET |
_2_182 DB 109,105,115,115,105,110,103,32,116,111 |
DB 107,101,110,0 |
_ns: |
PUSH EBP |
MOV EBP,ESP |
MOV EAX,_2_185+0 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JE _2_187 |
JMP _2_186 |
_2_187: |
MOV EAX,_2_185+2 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
JMP _2_188 |
_2_186: |
XOR EAX,EAX |
MOV DWORD [_errflag],EAX |
_2_188: |
POP EBP |
RET |
_2_185 DB 59,0,110,111,32,115,101,109,105,99 |
DB 111,108,111,110,0 |
_match: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-4 |
XOR CL,CL |
CALL _blanks |
LEA EAX,[EBP-4] |
PUSH EAX |
MOV EAX,[_lptr] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _streq |
ADD ESP,8 |
POP EBX |
MOV [EBX],EAX |
OR EAX,EAX |
JNE _2_191 |
JMP _2_190 |
_2_191: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _bump |
ADD ESP,4 |
MOV EAX,1 |
MOV ESP,EBP |
POP EBP |
RET |
_2_190: |
XOR EAX,EAX |
MOV ESP,EBP |
POP EBP |
RET |
_streq: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-4 |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],EAX |
_2_193: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
OR EAX,EAX |
JNE _2_195 |
JMP _2_194 |
_2_195: |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
POP EBX |
CALL __ne |
OR EAX,EAX |
JNE _2_197 |
JMP _2_196 |
_2_197: |
XOR EAX,EAX |
MOV ESP,EBP |
POP EBP |
RET |
_2_196: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
INC EAX |
MOV [EBX],EAX |
JMP _2_193 |
_2_194: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV ESP,EBP |
POP EBP |
RET |
_amatch: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-4 |
XOR CL,CL |
CALL _blanks |
LEA EAX,[EBP-4] |
PUSH EAX |
MOV EAX,[_lptr] |
PUSH EAX |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,3 |
CALL _astreq |
ADD ESP,12 |
POP EBX |
MOV [EBX],EAX |
OR EAX,EAX |
JNE _2_200 |
JMP _2_199 |
_2_200: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _bump |
ADD ESP,4 |
MOV EAX,1 |
MOV ESP,EBP |
POP EBP |
RET |
_2_199: |
XOR EAX,EAX |
MOV ESP,EBP |
POP EBP |
RET |
_astreq: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-4 |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],EAX |
_2_202: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
CALL __lt |
OR EAX,EAX |
JNE _2_204 |
JMP _2_203 |
_2_204: |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
PUSH EAX |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
POP EBX |
CALL __ne |
OR EAX,EAX |
JNE _2_206 |
JMP _2_205 |
_2_206: |
JMP _2_203 |
_2_205: |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,32 |
CALL __lt |
OR EAX,EAX |
JNE _2_208 |
JMP _2_207 |
_2_208: |
JMP _2_203 |
_2_207: |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,32 |
CALL __lt |
OR EAX,EAX |
JNE _2_210 |
JMP _2_209 |
_2_210: |
JMP _2_203 |
_2_209: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
INC EAX |
MOV [EBX],EAX |
JMP _2_202 |
_2_203: |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _an |
ADD ESP,4 |
OR EAX,EAX |
JE _2_214 |
JMP _2_212 |
_2_214: |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _an |
ADD ESP,4 |
OR EAX,EAX |
JE _2_215 |
JMP _2_212 |
_2_215: |
XOR EAX,EAX |
JMP _2_213 |
_2_212: |
MOV EAX,1 |
_2_213: |
OR EAX,EAX |
JNE _2_216 |
JMP _2_211 |
_2_216: |
XOR EAX,EAX |
MOV ESP,EBP |
POP EBP |
RET |
_2_211: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV ESP,EBP |
POP EBP |
RET |
_nextop: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-4 |
XOR EAX,EAX |
MOV DWORD [_opindex],EAX |
XOR CL,CL |
CALL _blanks |
_2_218: |
XOR EAX,EAX |
MOV DWORD [_opsize],EAX |
_2_220: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,32 |
CALL __gt |
OR EAX,EAX |
JNE _2_222 |
JMP _2_221 |
_2_222: |
LEA EAX,[EBP-4] |
PUSH EAX |
MOV EAX,[_opsize] |
INC EAX |
MOV DWORD [_opsize],EAX |
DEC EAX |
POP EBX |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
INC EAX |
MOV [EBX],EAX |
DEC EAX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
POP EBX |
MOV [EBX],AL |
JMP _2_220 |
_2_221: |
LEA EAX,[EBP-4] |
PUSH EAX |
MOV EAX,[_opsize] |
POP EBX |
ADD EAX,EBX |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],AL |
MOV EAX,[_lptr] |
PUSH EAX |
LEA EAX,[EBP-4] |
PUSH EAX |
MOV CL,2 |
CALL _streq |
ADD ESP,8 |
MOV DWORD [_opsize],EAX |
OR EAX,EAX |
JNE _2_224 |
JMP _2_223 |
_2_224: |
MOV EAX,[_lptr] |
PUSH EAX |
MOV EAX,[_opsize] |
POP EBX |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,61 |
CALL __ne |
OR EAX,EAX |
JNE _2_228 |
JMP _2_226 |
_2_228: |
MOV EAX,[_lptr] |
PUSH EAX |
MOV EAX,[_opsize] |
POP EBX |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
PUSH EAX |
MOV EAX,[_lptr] |
PUSH EAX |
MOV EAX,[_opsize] |
POP EBX |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX,1 |
XCHG EAX,EBX |
SUB EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
POP EBX |
CALL __ne |
OR EAX,EAX |
JNE _2_229 |
JMP _2_226 |
_2_229: |
MOV EAX,1 |
JMP _2_227 |
_2_226: |
XOR EAX,EAX |
_2_227: |
OR EAX,EAX |
JNE _2_230 |
JMP _2_225 |
_2_230: |
MOV EAX,1 |
MOV ESP,EBP |
POP EBP |
RET |
_2_225: |
_2_223: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
OR EAX,EAX |
JNE _2_232 |
JMP _2_231 |
_2_232: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
INC EAX |
MOV [EBX],EAX |
MOV EAX,[_opindex] |
INC EAX |
MOV DWORD [_opindex],EAX |
JMP _2_233 |
_2_231: |
XOR EAX,EAX |
MOV ESP,EBP |
POP EBP |
RET |
_2_233: |
JMP _2_218 |
_2_219: |
MOV ESP,EBP |
POP EBP |
RET |
_blanks: |
PUSH EBP |
MOV EBP,ESP |
_2_235: |
_2_237: |
MOV EAX,[_ch] |
OR EAX,EAX |
JNE _2_239 |
JMP _2_238 |
_2_239: |
XOR CL,CL |
CALL _white |
OR EAX,EAX |
JNE _2_241 |
JMP _2_240 |
_2_241: |
XOR CL,CL |
CALL _gch |
JMP _2_242 |
_2_240: |
POP EBP |
RET |
_2_242: |
JMP _2_237 |
_2_238: |
MOV EAX,[_line] |
PUSH EAX |
MOV EAX,[_mline] |
POP EBX |
CALL __eq |
OR EAX,EAX |
JNE _2_244 |
JMP _2_243 |
_2_244: |
POP EBP |
RET |
_2_243: |
XOR CL,CL |
CALL _preproce |
MOV EAX,[_eof] |
OR EAX,EAX |
JNE _2_246 |
JMP _2_245 |
_2_246: |
JMP _2_236 |
_2_245: |
JMP _2_235 |
_2_236: |
POP EBP |
RET |
_white: |
PUSH EBP |
MOV EBP,ESP |
MOV EAX,[_lptr] |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,32 |
CALL __le |
OR EAX,EAX |
JNE _2_250 |
JMP _2_248 |
_2_250: |
MOV EAX,[_lptr] |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
OR EAX,EAX |
JNE _2_251 |
JMP _2_248 |
_2_251: |
MOV EAX,1 |
JMP _2_249 |
_2_248: |
XOR EAX,EAX |
_2_249: |
POP EBP |
RET |
_gch: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-4 |
LEA EAX,[EBP-4] |
PUSH EAX |
MOV EAX,[_ch] |
POP EBX |
MOV [EBX],EAX |
OR EAX,EAX |
JNE _2_254 |
JMP _2_253 |
_2_254: |
MOV EAX,1 |
PUSH EAX |
MOV CL,1 |
CALL _bump |
ADD ESP,4 |
_2_253: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV ESP,EBP |
POP EBP |
RET |
_bump: |
PUSH EBP |
MOV EBP,ESP |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _2_257 |
JMP _2_256 |
_2_257: |
MOV EAX,[_lptr] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
ADD EAX,EBX |
MOV DWORD [_lptr],EAX |
JMP _2_258 |
_2_256: |
MOV EAX,[_line] |
MOV DWORD [_lptr],EAX |
_2_258: |
MOV EAX,[_lptr] |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV DWORD [_nch],EAX |
MOV DWORD [_ch],EAX |
OR EAX,EAX |
JNE _2_260 |
JMP _2_259 |
_2_260: |
MOV EAX,[_lptr] |
MOV EBX,1 |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV DWORD [_nch],EAX |
_2_259: |
POP EBP |
RET |
_kill: |
PUSH EBP |
MOV EBP,ESP |
MOV EAX,[_line] |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],AL |
XOR EAX,EAX |
PUSH EAX |
MOV CL,1 |
CALL _bump |
ADD ESP,4 |
POP EBP |
RET |
_skip: |
PUSH EBP |
MOV EBP,ESP |
XOR CL,CL |
CALL _inbyte |
PUSH EAX |
MOV CL,1 |
CALL _an |
ADD ESP,4 |
OR EAX,EAX |
JNE _2_264 |
JMP _2_263 |
_2_264: |
_2_265: |
MOV EAX,[_ch] |
PUSH EAX |
MOV CL,1 |
CALL _an |
ADD ESP,4 |
OR EAX,EAX |
JNE _2_267 |
JMP _2_266 |
_2_267: |
XOR CL,CL |
CALL _gch |
JMP _2_265 |
_2_266: |
JMP _2_268 |
_2_263: |
_2_269: |
MOV EAX,[_ch] |
PUSH EAX |
MOV CL,1 |
CALL _an |
ADD ESP,4 |
OR EAX,EAX |
JE _2_271 |
JMP _2_270 |
_2_271: |
MOV EAX,[_ch] |
OR EAX,EAX |
JE _2_273 |
JMP _2_272 |
_2_273: |
JMP _2_270 |
_2_272: |
XOR CL,CL |
CALL _gch |
JMP _2_269 |
_2_270: |
_2_268: |
XOR CL,CL |
CALL _blanks |
POP EBP |
RET |
_endst: |
PUSH EBP |
MOV EBP,ESP |
XOR CL,CL |
CALL _blanks |
MOV EAX,[_lptr] |
PUSH EAX |
MOV EAX,_2_274+0 |
PUSH EAX |
MOV CL,2 |
CALL _streq |
ADD ESP,8 |
OR EAX,EAX |
JE _2_277 |
JMP _2_275 |
_2_277: |
MOV EAX,[_ch] |
MOV EBX,EAX |
XOR EAX,EAX |
CALL __eq |
OR EAX,EAX |
JE _2_278 |
JMP _2_275 |
_2_278: |
XOR EAX,EAX |
JMP _2_276 |
_2_275: |
MOV EAX,1 |
_2_276: |
POP EBP |
RET |
_2_274 DB 59,0 |
_addsym: |
PUSH EBP |
MOV EBP,ESP |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV EAX,_glbptr |
POP EBX |
CALL __eq |
OR EAX,EAX |
JNE _2_281 |
JMP _2_280 |
_2_281: |
LEA EAX,[EBP+32] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _findglb |
ADD ESP,4 |
MOV DWORD [_cptr2],EAX |
OR EAX,EAX |
JNE _2_283 |
JMP _2_282 |
_2_283: |
MOV EAX,[_cptr2] |
POP EBP |
RET |
_2_282: |
MOV EAX,[_cptr] |
OR EAX,EAX |
JE _2_285 |
JMP _2_284 |
_2_285: |
MOV EAX,_2_279+0 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
XOR EAX,EAX |
POP EBP |
RET |
_2_284: |
JMP _2_286 |
_2_280: |
MOV EAX,[_locptr] |
PUSH EAX |
MOV EAX,[_symtab] |
MOV EBX,400 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX,20 |
XCHG EAX,EBX |
SUB EAX,EBX |
POP EBX |
CALL __ugt |
OR EAX,EAX |
JNE _2_288 |
JMP _2_287 |
_2_288: |
MOV EAX,_2_279+29 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
MOV EAX,7 |
PUSH EAX |
MOV CL,1 |
CALL _OS_exit |
ADD ESP,4 |
_2_287: |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV DWORD [_cptr],EAX |
_2_286: |
MOV EAX,[_cptr] |
PUSH EAX |
LEA EAX,[EBP+28] |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
POP EBX |
MOV [EBX],AL |
MOV EAX,[_cptr] |
MOV EBX,1 |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP+24] |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
POP EBX |
MOV [EBX],AL |
MOV EAX,[_cptr] |
MOV EBX,2 |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
MOV [EBX],AL |
LEA EAX,[EBP+20] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV EAX,[_cptr] |
MOV EBX,3 |
ADD EAX,EBX |
PUSH EAX |
MOV EAX,4 |
PUSH EAX |
MOV CL,3 |
CALL _putint |
ADD ESP,12 |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV EAX,[_cptr] |
MOV EBX,5 |
ADD EAX,EBX |
MOV EBX,2 |
ADD EAX,EBX |
PUSH EAX |
MOV EAX,4 |
PUSH EAX |
MOV CL,3 |
CALL _putint |
ADD ESP,12 |
MOV EAX,[_cptr] |
MOV EBX,11 |
ADD EAX,EBX |
MOV DWORD [_cptr2],EAX |
MOV DWORD [_cptr3],EAX |
_2_289: |
LEA EAX,[EBP+32] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _an |
ADD ESP,4 |
OR EAX,EAX |
JNE _2_291 |
JMP _2_290 |
_2_291: |
MOV EAX,[_cptr2] |
INC EAX |
MOV DWORD [_cptr2],EAX |
DEC EAX |
PUSH EAX |
LEA EAX,[EBP+32] |
MOV EBX,EAX |
MOV EAX, [EBX] |
INC EAX |
MOV [EBX],EAX |
DEC EAX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
POP EBX |
MOV [EBX],AL |
JMP _2_289 |
_2_290: |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV EAX,_locptr |
POP EBX |
CALL __eq |
OR EAX,EAX |
JNE _2_293 |
JMP _2_292 |
_2_293: |
MOV EAX,[_cptr2] |
PUSH EAX |
MOV EAX,[_cptr2] |
PUSH EAX |
MOV EAX,[_cptr3] |
POP EBX |
XCHG EAX,EBX |
SUB EAX,EBX |
POP EBX |
MOV [EBX],AL |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV EAX,[_cptr2] |
INC EAX |
MOV DWORD [_cptr2],EAX |
POP EBX |
MOV [EBX],EAX |
_2_292: |
MOV EAX,[_cptr] |
POP EBP |
RET |
_2_279 DB 103,108,111,98,97,108,32,115,121,109 |
DB 98,111,108,32,116,97,98,108,101,32 |
DB 111,118,101,114,102,108,111,119,0,108 |
DB 111,99,97,108,32,115,121,109,98,111 |
DB 108,32,116,97,98,108,101,32,111,118 |
DB 101,114,102,108,111,119,0 |
_search: |
PUSH EBP |
MOV EBP,ESP |
LEA EAX,[EBP+24] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+28] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _hash |
ADD ESP,4 |
PUSH EAX |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,1 |
XCHG EAX,EBX |
SUB EAX,EBX |
POP EBX |
XCHG EAX,EBX |
CDQ |
IDIV EBX |
MOV EAX,EDX |
PUSH EAX |
LEA EAX,[EBP+20] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
IMUL EBX |
POP EBX |
ADD EAX,EBX |
MOV DWORD [_cptr2],EAX |
MOV DWORD [_cptr],EAX |
_2_295: |
MOV EAX,[_cptr] |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
OR EAX,EAX |
JNE _2_297 |
JMP _2_296 |
_2_297: |
LEA EAX,[EBP+28] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV EAX,[_cptr] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
ADD EAX,EBX |
PUSH EAX |
MOV EAX,8 |
PUSH EAX |
MOV CL,3 |
CALL _astreq |
ADD ESP,12 |
OR EAX,EAX |
JNE _2_299 |
JMP _2_298 |
_2_299: |
MOV EAX,1 |
POP EBP |
RET |
_2_298: |
MOV EAX,[_cptr] |
PUSH EAX |
LEA EAX,[EBP+20] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
ADD EAX,EBX |
MOV DWORD [_cptr],EAX |
PUSH EAX |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
CALL __uge |
OR EAX,EAX |
JNE _2_301 |
JMP _2_300 |
_2_301: |
LEA EAX,[EBP+24] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV DWORD [_cptr],EAX |
_2_300: |
MOV EAX,[_cptr] |
PUSH EAX |
MOV EAX,[_cptr2] |
POP EBX |
CALL __eq |
OR EAX,EAX |
JNE _2_303 |
JMP _2_302 |
_2_303: |
XOR EAX,EAX |
MOV DWORD [_cptr],EAX |
POP EBP |
RET |
_2_302: |
JMP _2_295 |
_2_296: |
XOR EAX,EAX |
POP EBP |
RET |
_hash: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-8 |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],EAX |
_2_305: |
LEA EAX,[EBP-8] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
INC EAX |
MOV [EBX],EAX |
DEC EAX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
POP EBX |
MOV [EBX],EAX |
OR EAX,EAX |
JNE _2_307 |
JMP _2_306 |
_2_307: |
LEA EAX,[EBP-4] |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,1 |
MOV ECX,EAX |
MOV EAX,EBX |
SAL EAX,CL |
PUSH EAX |
LEA EAX,[EBP-8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
ADD EAX,EBX |
POP EBX |
MOV [EBX],EAX |
JMP _2_305 |
_2_306: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV ESP,EBP |
POP EBP |
RET |
_findglb: |
PUSH EBP |
MOV EBP,ESP |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV EAX,[_symtab] |
MOV EBX,400 |
ADD EAX,EBX |
PUSH EAX |
MOV EAX,20 |
PUSH EAX |
MOV EAX,[_symtab] |
MOV EBX,400 |
ADD EAX,EBX |
MOV EBX,3980 |
ADD EAX,EBX |
PUSH EAX |
MOV EAX,200 |
PUSH EAX |
MOV EAX,11 |
PUSH EAX |
MOV CL,6 |
CALL _search |
ADD ESP,24 |
OR EAX,EAX |
JNE _2_310 |
JMP _2_309 |
_2_310: |
MOV EAX,[_cptr] |
POP EBP |
RET |
_2_309: |
XOR EAX,EAX |
POP EBP |
RET |
_findloc: |
PUSH EBP |
MOV EBP,ESP |
MOV EAX,[_locptr] |
MOV EBX,EAX |
MOV EAX,1 |
XCHG EAX,EBX |
SUB EAX,EBX |
MOV DWORD [_cptr],EAX |
_2_312: |
MOV EAX,[_cptr] |
PUSH EAX |
MOV EAX,[_symtab] |
POP EBX |
CALL __ugt |
OR EAX,EAX |
JNE _2_314 |
JMP _2_313 |
_2_314: |
MOV EAX,[_cptr] |
PUSH EAX |
MOV EAX,[_cptr] |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
POP EBX |
XCHG EAX,EBX |
SUB EAX,EBX |
MOV DWORD [_cptr],EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV EAX,[_cptr] |
PUSH EAX |
MOV EAX,8 |
PUSH EAX |
MOV CL,3 |
CALL _astreq |
ADD ESP,12 |
OR EAX,EAX |
JNE _2_316 |
JMP _2_315 |
_2_316: |
MOV EAX,[_cptr] |
MOV EBX,EAX |
MOV EAX,11 |
XCHG EAX,EBX |
SUB EAX,EBX |
POP EBP |
RET |
_2_315: |
MOV EAX,[_cptr] |
MOV EBX,EAX |
MOV EAX,11 |
XCHG EAX,EBX |
SUB EAX,EBX |
MOV EBX,EAX |
MOV EAX,1 |
XCHG EAX,EBX |
SUB EAX,EBX |
MOV DWORD [_cptr],EAX |
JMP _2_312 |
_2_313: |
XOR EAX,EAX |
POP EBP |
RET |
_nextsym: |
PUSH EBP |
MOV EBP,ESP |
LEA EAX,[EBP+8] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,11 |
ADD EAX,EBX |
POP EBX |
MOV [EBX],EAX |
_2_318: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
INC EAX |
MOV [EBX],EAX |
DEC EAX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,32 |
CALL __ge |
OR EAX,EAX |
JNE _2_320 |
JMP _2_319 |
_2_320: |
JMP _2_318 |
_2_319: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBP |
RET |
_addwhile: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-4 |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV EAX,[_csp] |
POP EBX |
MOV [EBX],EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,4 |
ADD EAX,EBX |
PUSH EAX |
XOR CL,CL |
CALL _getlabel |
POP EBX |
MOV [EBX],EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,8 |
ADD EAX,EBX |
PUSH EAX |
XOR CL,CL |
CALL _getlabel |
POP EBX |
MOV [EBX],EAX |
MOV EAX,[_wqptr] |
PUSH EAX |
MOV EAX,[_wq] |
MOV EBX,120 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX,12 |
XCHG EAX,EBX |
SUB EAX,EBX |
POP EBX |
CALL __eq |
OR EAX,EAX |
JNE _2_323 |
JMP _2_322 |
_2_323: |
MOV EAX,_2_321+0 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
MOV EAX,7 |
PUSH EAX |
MOV CL,1 |
CALL _OS_exit |
ADD ESP,4 |
_2_322: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],EAX |
_2_324: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,3 |
CALL __lt |
OR EAX,EAX |
JNE _2_326 |
JMP _2_325 |
_2_326: |
MOV EAX,[_wqptr] |
INC EAX |
INC EAX |
INC EAX |
INC EAX |
MOV DWORD [_wqptr],EAX |
DEC EAX |
DEC EAX |
DEC EAX |
DEC EAX |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
INC EAX |
MOV [EBX],EAX |
DEC EAX |
POP EBX |
SHL EAX,1 |
SHL EAX,1 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
MOV [EBX],EAX |
JMP _2_324 |
_2_325: |
MOV ESP,EBP |
POP EBP |
RET |
_2_321 DB 99,111,110,116,114,111,108,32,115,116 |
DB 97,116,101,109,101,110,116,32,110,101 |
DB 115,116,105,110,103,32,108,105,109,105 |
DB 116,0 |
_readwhil: |
PUSH EBP |
MOV EBP,ESP |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV EAX,[_wq] |
POP EBX |
CALL __ule |
OR EAX,EAX |
JNE _2_329 |
JMP _2_328 |
_2_329: |
MOV EAX,_2_327+0 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
XOR EAX,EAX |
POP EBP |
RET |
_2_328: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,12 |
XCHG EAX,EBX |
SUB EAX,EBX |
POP EBP |
RET |
_2_330: |
POP EBP |
RET |
_2_327 DB 111,117,116,32,111,102,32,99,111,110 |
DB 116,101,120,116,0 |
_delwhile: |
PUSH EBP |
MOV EBP,ESP |
MOV EAX,[_wqptr] |
PUSH EAX |
MOV EAX,[_wq] |
POP EBX |
CALL __ugt |
OR EAX,EAX |
JNE _2_333 |
JMP _2_332 |
_2_333: |
MOV EAX,[_wqptr] |
MOV EBX,EAX |
MOV EAX,12 |
XCHG EAX,EBX |
SUB EAX,EBX |
MOV DWORD [_wqptr],EAX |
_2_332: |
POP EBP |
RET |
_alpha: |
PUSH EBP |
MOV EBP,ESP |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _isalpha |
ADD ESP,4 |
OR EAX,EAX |
JE _2_337 |
JMP _2_335 |
_2_337: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,95 |
CALL __eq |
OR EAX,EAX |
JE _2_338 |
JMP _2_335 |
_2_338: |
XOR EAX,EAX |
JMP _2_336 |
_2_335: |
MOV EAX,1 |
_2_336: |
POP EBP |
RET |
_an: |
PUSH EBP |
MOV EBP,ESP |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _alpha |
ADD ESP,4 |
OR EAX,EAX |
JE _2_342 |
JMP _2_340 |
_2_342: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _isdigit |
ADD ESP,4 |
OR EAX,EAX |
JE _2_343 |
JMP _2_340 |
_2_343: |
XOR EAX,EAX |
JMP _2_341 |
_2_340: |
MOV EAX,1 |
_2_341: |
POP EBP |
RET |
_getlabel: |
PUSH EBP |
MOV EBP,ESP |
MOV EAX,[_nxtlab] |
INC EAX |
MOV DWORD [_nxtlab],EAX |
POP EBP |
RET |
_getint: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-4 |
LEA EAX,[EBP-4] |
PUSH EAX |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
DEC EAX |
MOV [EBX],EAX |
POP EBX |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
POP EBX |
MOV [EBX],EAX |
_2_346: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
DEC EAX |
MOV [EBX],EAX |
INC EAX |
OR EAX,EAX |
JNE _2_348 |
JMP _2_347 |
_2_348: |
LEA EAX,[EBP-4] |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,8 |
MOV ECX,EAX |
MOV EAX,EBX |
SAL EAX,CL |
PUSH EAX |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,255 |
AND EAX,EBX |
POP EBX |
OR EAX,EBX |
POP EBX |
MOV [EBX],EAX |
JMP _2_346 |
_2_347: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV ESP,EBP |
POP EBP |
RET |
_putint: |
PUSH EBP |
MOV EBP,ESP |
_2_350: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
DEC EAX |
MOV [EBX],EAX |
INC EAX |
OR EAX,EAX |
JNE _2_352 |
JMP _2_351 |
_2_352: |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
INC EAX |
MOV [EBX],EAX |
DEC EAX |
PUSH EAX |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
MOV [EBX],AL |
LEA EAX,[EBP+16] |
PUSH EAX |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,8 |
MOV ECX,EAX |
MOV EAX,EBX |
SAR EAX,CL |
POP EBX |
MOV [EBX],EAX |
JMP _2_350 |
_2_351: |
POP EBP |
RET |
_lout: |
PUSH EBP |
MOV EBP,ESP |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _fputs |
ADD ESP,8 |
MOV EAX,10 |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _OS_fputc |
ADD ESP,8 |
POP EBP |
RET |
_illname: |
PUSH EBP |
MOV EBP,ESP |
MOV EAX,_2_354+0 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
XOR CL,CL |
CALL _skip |
POP EBP |
RET |
_2_354 DB 105,108,108,101,103,97,108,32,115,121 |
DB 109,98,111,108,0 |
_multidef: |
PUSH EBP |
MOV EBP,ESP |
MOV EAX,_2_355+0 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
POP EBP |
RET |
_2_355 DB 97,108,114,101,97,100,121,32,100,101 |
DB 102,105,110,101,100,0 |
_needlval: |
PUSH EBP |
MOV EBP,ESP |
MOV EAX,_2_356+0 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
POP EBP |
RET |
_2_356 DB 109,117,115,116,32,98,101,32,108,118 |
DB 97,108,117,101,0 |
_noiferr: |
PUSH EBP |
MOV EBP,ESP |
MOV EAX,_2_357+0 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
XOR EAX,EAX |
MOV DWORD [_errflag],EAX |
POP EBP |
RET |
_2_357 DB 110,111,32,109,97,116,99,104,105,110 |
DB 103,32,35,105,102,46,46,46,0 |
_error: |
PUSH EBP |
MOV EBP,ESP |
MOV EAX,[_errflag] |
OR EAX,EAX |
JNE _2_360 |
JMP _2_359 |
_2_360: |
POP EBP |
RET |
_2_359: |
MOV EAX,1 |
MOV DWORD [_errflag],EAX |
_2_361: |
MOV EAX,[_line] |
PUSH EAX |
MOV EAX,__iob |
MOV EBX,64 |
ADD EAX,EBX |
PUSH EAX |
MOV CL,2 |
CALL _lout |
ADD ESP,8 |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV EAX,__iob |
MOV EBX,64 |
ADD EAX,EBX |
PUSH EAX |
MOV CL,2 |
CALL _errout |
ADD ESP,8 |
MOVSX EAX,BYTE [_alarm] |
OR EAX,EAX |
JNE _2_363 |
JMP _2_362 |
_2_363: |
MOV EAX,7 |
PUSH EAX |
MOV EAX,__iob |
MOV EBX,64 |
ADD EAX,EBX |
PUSH EAX |
MOV CL,2 |
CALL _OS_fputc |
ADD ESP,8 |
_2_362: |
MOVSX EAX,BYTE [_pause] |
OR EAX,EAX |
JNE _2_365 |
JMP _2_364 |
_2_365: |
_2_366: |
MOV EAX,__iob |
MOV EBX,64 |
ADD EAX,EBX |
PUSH EAX |
MOV CL,1 |
CALL _OS_fgetc |
ADD ESP,4 |
MOV EBX,EAX |
MOV EAX,10 |
CALL __ne |
OR EAX,EAX |
JNE _2_368 |
JMP _2_367 |
_2_368: |
JMP _2_366 |
_2_367: |
_2_364: |
MOV EAX,[_listfp] |
OR EAX,EAX |
JG _2_370 |
JMP _2_369 |
_2_370: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV EAX,[_listfp] |
PUSH EAX |
MOV CL,2 |
CALL _errout |
ADD ESP,8 |
_2_369: |
POP EBP |
RET |
_errout: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-4 |
LEA EAX,[EBP-4] |
PUSH EAX |
MOV EAX,[_line] |
MOV EBX,2 |
ADD EAX,EBX |
POP EBX |
MOV [EBX],EAX |
_2_372: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
INC EAX |
MOV [EBX],EAX |
DEC EAX |
PUSH EAX |
MOV EAX,[_lptr] |
POP EBX |
CALL __ule |
OR EAX,EAX |
JNE _2_374 |
JMP _2_373 |
_2_374: |
MOV EAX,32 |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _OS_fputc |
ADD ESP,8 |
JMP _2_372 |
_2_373: |
MOV EAX,_2_371+0 |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _lout |
ADD ESP,8 |
MOV EAX,_2_371+3 |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _fputs |
ADD ESP,8 |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _lout |
ADD ESP,8 |
MOV ESP,EBP |
POP EBP |
RET |
_2_371 DB 47,92,0,42,42,42,42,32,0 |
/programs/develop/scc/CC3.ASM |
---|
0,0 → 1,6740 |
_constexp: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-12 |
LEA EAX,[EBP-8] |
PUSH EAX |
LEA EAX,[EBP-12] |
PUSH EAX |
MOV CL,2 |
CALL _setstage |
ADD ESP,8 |
LEA EAX,[EBP-4] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _expressi |
ADD ESP,8 |
LEA EAX,[EBP-8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _clearsta |
ADD ESP,8 |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JE _3_3 |
JMP _3_2 |
_3_3: |
MOV EAX,_3_1+0 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
_3_2: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV ESP,EBP |
POP EBP |
RET |
_3_1 DB 109,117,115,116,32,98,101,32,99,111 |
DB 110,115,116,97,110,116,32,101,120,112 |
DB 114,101,115,115,105,111,110,0 |
_null_is: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-4 |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],EAX |
_3_7: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,7 |
CALL __lt |
OR EAX,EAX |
JNE _3_9 |
JMP _3_6 |
_3_9: |
JMP _3_8 |
_3_5: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
INC EAX |
MOV [EBX],EAX |
JMP _3_7 |
_3_8: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
SHL EAX,1 |
SHL EAX,1 |
ADD EAX,EBX |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],EAX |
JMP _3_5 |
_3_6: |
MOV ESP,EBP |
POP EBP |
RET |
_expressi: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-32 |
LEA EAX,[EBP-32] |
PUSH EAX |
MOV CL,1 |
CALL _null_is |
ADD ESP,4 |
LEA EAX,[EBP-32] |
PUSH EAX |
MOV CL,1 |
CALL _level1 |
ADD ESP,4 |
OR EAX,EAX |
JNE _3_12 |
JMP _3_11 |
_3_12: |
LEA EAX,[EBP-32] |
PUSH EAX |
MOV CL,1 |
CALL _fetch |
ADD ESP,4 |
_3_11: |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-32] |
MOV EBX,12 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
MOV [EBX],EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-32] |
MOV EBX,16 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
MOV [EBX],EAX |
MOV ESP,EBP |
POP EBP |
RET |
_test: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-36 |
LEA EAX,[EBP-28] |
PUSH EAX |
MOV CL,1 |
CALL _null_is |
ADD ESP,4 |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _3_15 |
JMP _3_14 |
_3_15: |
MOV EAX,_3_13+0 |
PUSH EAX |
MOV CL,1 |
CALL _need |
ADD ESP,4 |
_3_14: |
_3_16: |
LEA EAX,[EBP-32] |
PUSH EAX |
LEA EAX,[EBP-36] |
PUSH EAX |
MOV CL,2 |
CALL _setstage |
ADD ESP,8 |
LEA EAX,[EBP-28] |
PUSH EAX |
MOV CL,1 |
CALL _level1 |
ADD ESP,4 |
OR EAX,EAX |
JNE _3_19 |
JMP _3_18 |
_3_19: |
LEA EAX,[EBP-28] |
PUSH EAX |
MOV CL,1 |
CALL _fetch |
ADD ESP,4 |
_3_18: |
MOV EAX,_3_13+2 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _3_21 |
JMP _3_20 |
_3_21: |
LEA EAX,[EBP-32] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-36] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _clearsta |
ADD ESP,8 |
JMP _3_22 |
_3_20: |
JMP _3_17 |
_3_22: |
JMP _3_16 |
_3_17: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _3_24 |
JMP _3_23 |
_3_24: |
MOV EAX,_3_13+4 |
PUSH EAX |
MOV CL,1 |
CALL _need |
ADD ESP,4 |
_3_23: |
LEA EAX,[EBP-28] |
MOV EBX,12 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _3_26 |
JMP _3_25 |
_3_26: |
LEA EAX,[EBP-32] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _clearsta |
ADD ESP,8 |
LEA EAX,[EBP-28] |
MOV EBX,16 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _3_28 |
JMP _3_27 |
_3_28: |
MOV ESP,EBP |
POP EBP |
RET |
_3_27: |
MOV EAX,40 |
PUSH EAX |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
MOV ESP,EBP |
POP EBP |
RET |
_3_25: |
LEA EAX,[EBP-28] |
MOV EBX,24 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _3_30 |
JMP _3_29 |
_3_30: |
LEA EAX,[EBP-28] |
MOV EBX,20 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
JMP _3_33 |
_3_34: |
_3_35: |
MOV EAX,19 |
PUSH EAX |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-28] |
PUSH EAX |
MOV CL,3 |
CALL _zerojump |
ADD ESP,12 |
JMP _3_32 |
_3_36: |
_3_37: |
MOV EAX,54 |
PUSH EAX |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-28] |
PUSH EAX |
MOV CL,3 |
CALL _zerojump |
ADD ESP,12 |
JMP _3_32 |
_3_38: |
MOV EAX,34 |
PUSH EAX |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-28] |
PUSH EAX |
MOV CL,3 |
CALL _zerojump |
ADD ESP,12 |
JMP _3_32 |
_3_39: |
MOV EAX,21 |
PUSH EAX |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-28] |
PUSH EAX |
MOV CL,3 |
CALL _zerojump |
ADD ESP,12 |
JMP _3_32 |
_3_40: |
LEA EAX,[EBP-28] |
MOV EBX,24 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _clearsta |
ADD ESP,8 |
JMP _3_32 |
_3_41: |
MOV EAX,46 |
PUSH EAX |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-28] |
PUSH EAX |
MOV CL,3 |
CALL _zerojump |
ADD ESP,12 |
JMP _3_32 |
_3_42: |
MOV EAX,40 |
PUSH EAX |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-28] |
PUSH EAX |
MOV CL,3 |
CALL _zerojump |
ADD ESP,12 |
JMP _3_32 |
_3_43: |
MOV EAX,42 |
PUSH EAX |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-28] |
PUSH EAX |
MOV CL,3 |
CALL _zerojump |
ADD ESP,12 |
JMP _3_32 |
_3_44: |
MOV EAX,54 |
PUSH EAX |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
JMP _3_32 |
JMP _3_32 |
_3_33: |
CALL __switch |
DD _3_34 |
DD 20 |
DD _3_35 |
DD 44 |
DD _3_36 |
DD 55 |
DD _3_37 |
DD 36 |
DD _3_38 |
DD 35 |
DD _3_39 |
DD 22 |
DD _3_40 |
DD 23 |
DD _3_41 |
DD 47 |
DD _3_42 |
DD 48 |
DD _3_43 |
DD 43 |
DD 0 |
JMP _3_44 |
_3_32: |
JMP _3_45 |
_3_29: |
MOV EAX,54 |
PUSH EAX |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
_3_45: |
LEA EAX,[EBP-32] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-36] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _clearsta |
ADD ESP,8 |
MOV ESP,EBP |
POP EBP |
RET |
_3_13 DB 40,0,44,0,41,0 |
_zerojump: |
PUSH EBP |
MOV EBP,ESP |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,24 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _clearsta |
ADD ESP,8 |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
POP EBP |
RET |
_level1: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-48 |
LEA EAX,[EBP-32] |
PUSH EAX |
MOV CL,1 |
CALL _null_is |
ADD ESP,4 |
LEA EAX,[EBP-40] |
PUSH EAX |
MOV CL,1 |
CALL _null_is |
ADD ESP,4 |
LEA EAX,[EBP-4] |
PUSH EAX |
MOV EAX,_level2 |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _down1 |
ADD ESP,8 |
POP EBX |
MOV [EBX],EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,12 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _3_49 |
JMP _3_48 |
_3_49: |
MOV EAX,108 |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,16 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
_3_48: |
MOV EAX,_3_47+0 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _3_51 |
JMP _3_50 |
_3_51: |
LEA EAX,[EBP-44] |
PUSH EAX |
LEA EAX,[EBP-48] |
MOV EBX,EAX |
MOV EAX,57 |
MOV [EBX],EAX |
POP EBX |
MOV [EBX],EAX |
JMP _3_52 |
_3_50: |
MOV EAX,_3_47+3 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _3_54 |
JMP _3_53 |
_3_54: |
LEA EAX,[EBP-44] |
PUSH EAX |
LEA EAX,[EBP-48] |
MOV EBX,EAX |
MOV EAX,73 |
MOV [EBX],EAX |
POP EBX |
MOV [EBX],EAX |
JMP _3_55 |
_3_53: |
MOV EAX,_3_47+6 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _3_57 |
JMP _3_56 |
_3_57: |
LEA EAX,[EBP-44] |
PUSH EAX |
LEA EAX,[EBP-48] |
MOV EBX,EAX |
MOV EAX,3 |
MOV [EBX],EAX |
POP EBX |
MOV [EBX],EAX |
JMP _3_58 |
_3_56: |
MOV EAX,_3_47+9 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _3_60 |
JMP _3_59 |
_3_60: |
LEA EAX,[EBP-44] |
PUSH EAX |
LEA EAX,[EBP-48] |
MOV EBX,EAX |
MOV EAX,1 |
MOV [EBX],EAX |
POP EBX |
MOV [EBX],EAX |
JMP _3_61 |
_3_59: |
MOV EAX,_3_47+12 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _3_63 |
JMP _3_62 |
_3_63: |
LEA EAX,[EBP-44] |
PUSH EAX |
LEA EAX,[EBP-48] |
MOV EBX,EAX |
MOV EAX,69 |
MOV [EBX],EAX |
POP EBX |
MOV [EBX],EAX |
JMP _3_64 |
_3_62: |
MOV EAX,_3_47+15 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _3_66 |
JMP _3_65 |
_3_66: |
LEA EAX,[EBP-44] |
MOV EBX,EAX |
MOV EAX,52 |
MOV [EBX],EAX |
LEA EAX,[EBP-48] |
MOV EBX,EAX |
MOV EAX,53 |
MOV [EBX],EAX |
JMP _3_67 |
_3_65: |
MOV EAX,_3_47+18 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _3_69 |
JMP _3_68 |
_3_69: |
LEA EAX,[EBP-44] |
MOV EBX,EAX |
MOV EAX,16 |
MOV [EBX],EAX |
LEA EAX,[EBP-48] |
MOV EBX,EAX |
MOV EAX,17 |
MOV [EBX],EAX |
JMP _3_70 |
_3_68: |
MOV EAX,_3_47+21 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _3_72 |
JMP _3_71 |
_3_72: |
LEA EAX,[EBP-44] |
MOV EBX,EAX |
MOV EAX,49 |
MOV [EBX],EAX |
LEA EAX,[EBP-48] |
MOV EBX,EAX |
MOV EAX,50 |
MOV [EBX],EAX |
JMP _3_73 |
_3_71: |
MOV EAX,_3_47+24 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _3_75 |
JMP _3_74 |
_3_75: |
LEA EAX,[EBP-44] |
PUSH EAX |
LEA EAX,[EBP-48] |
MOV EBX,EAX |
MOV EAX,7 |
MOV [EBX],EAX |
POP EBX |
MOV [EBX],EAX |
JMP _3_76 |
_3_74: |
MOV EAX,_3_47+28 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _3_78 |
JMP _3_77 |
_3_78: |
LEA EAX,[EBP-44] |
PUSH EAX |
LEA EAX,[EBP-48] |
MOV EBX,EAX |
MOV EAX,6 |
MOV [EBX],EAX |
POP EBX |
MOV [EBX],EAX |
JMP _3_79 |
_3_77: |
MOV EAX,_3_47+32 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _3_81 |
JMP _3_80 |
_3_81: |
LEA EAX,[EBP-44] |
PUSH EAX |
LEA EAX,[EBP-48] |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],EAX |
POP EBX |
MOV [EBX],EAX |
JMP _3_82 |
_3_80: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV ESP,EBP |
POP EBP |
RET |
_3_82: |
_3_79: |
_3_76: |
_3_73: |
_3_70: |
_3_67: |
_3_64: |
_3_61: |
_3_58: |
_3_55: |
_3_52: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JE _3_84 |
JMP _3_83 |
_3_84: |
XOR CL,CL |
CALL _needlval |
XOR EAX,EAX |
MOV ESP,EBP |
POP EBP |
RET |
_3_83: |
LEA EAX,[EBP-40] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
MOV [EBX],EAX |
LEA EAX,[EBP-40] |
MOV EBX,4 |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,4 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
MOV [EBX],EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,4 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _3_86 |
JMP _3_85 |
_3_86: |
LEA EAX,[EBP-44] |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _3_88 |
JMP _3_87 |
_3_88: |
MOV EAX,60 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _fetch |
ADD ESP,4 |
_3_87: |
LEA EAX,[EBP-44] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-48] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV EAX,_level1 |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-32] |
PUSH EAX |
MOV CL,5 |
CALL _down2 |
ADD ESP,20 |
LEA EAX,[EBP-44] |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _3_90 |
JMP _3_89 |
_3_90: |
MOV EAX,59 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
_3_89: |
JMP _3_91 |
_3_85: |
LEA EAX,[EBP-44] |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _3_93 |
JMP _3_92 |
_3_93: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _fetch |
ADD ESP,4 |
LEA EAX,[EBP-44] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-48] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV EAX,_level1 |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-32] |
PUSH EAX |
MOV CL,5 |
CALL _down2 |
ADD ESP,20 |
JMP _3_94 |
_3_92: |
LEA EAX,[EBP-32] |
PUSH EAX |
MOV CL,1 |
CALL _level1 |
ADD ESP,4 |
OR EAX,EAX |
JNE _3_96 |
JMP _3_95 |
_3_96: |
LEA EAX,[EBP-32] |
PUSH EAX |
MOV CL,1 |
CALL _fetch |
ADD ESP,4 |
_3_95: |
_3_94: |
_3_91: |
LEA EAX,[EBP-40] |
PUSH EAX |
MOV CL,1 |
CALL _store |
ADD ESP,4 |
XOR EAX,EAX |
MOV ESP,EBP |
POP EBP |
RET |
_3_47 DB 124,61,0,94,61,0,38,61,0,43 |
DB 61,0,45,61,0,42,61,0,47,61 |
DB 0,37,61,0,62,62,61,0,60,60 |
DB 61,0,61,0 |
_level2: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-76 |
LEA EAX,[EBP-28] |
PUSH EAX |
MOV CL,1 |
CALL _null_is |
ADD ESP,4 |
LEA EAX,[EBP-56] |
PUSH EAX |
MOV CL,1 |
CALL _null_is |
ADD ESP,4 |
LEA EAX,[EBP-60] |
PUSH EAX |
MOV EAX,_level3 |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _down1 |
ADD ESP,8 |
POP EBX |
MOV [EBX],EAX |
MOV EAX,_3_97+0 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JE _3_99 |
JMP _3_98 |
_3_99: |
LEA EAX,[EBP-60] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV ESP,EBP |
POP EBP |
RET |
_3_98: |
LEA EAX,[EBP-60] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV EAX,54 |
PUSH EAX |
LEA EAX,[EBP-64] |
PUSH EAX |
XOR CL,CL |
CALL _getlabel |
POP EBX |
MOV [EBX],EAX |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,4 |
CALL _dropout |
ADD ESP,16 |
MOV EAX,_level2 |
PUSH EAX |
LEA EAX,[EBP-28] |
PUSH EAX |
MOV CL,2 |
CALL _down1 |
ADD ESP,8 |
OR EAX,EAX |
JNE _3_101 |
JMP _3_100 |
_3_101: |
LEA EAX,[EBP-28] |
PUSH EAX |
MOV CL,1 |
CALL _fetch |
ADD ESP,4 |
JMP _3_102 |
_3_100: |
LEA EAX,[EBP-28] |
MOV EBX,12 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _3_104 |
JMP _3_103 |
_3_104: |
MOV EAX,108 |
PUSH EAX |
LEA EAX,[EBP-28] |
MOV EBX,16 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
_3_103: |
_3_102: |
MOV EAX,_3_97+2 |
PUSH EAX |
MOV CL,1 |
CALL _need |
ADD ESP,4 |
MOV EAX,40 |
PUSH EAX |
LEA EAX,[EBP-68] |
PUSH EAX |
XOR CL,CL |
CALL _getlabel |
POP EBX |
MOV [EBX],EAX |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
MOV EAX,41 |
PUSH EAX |
LEA EAX,[EBP-64] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
MOV EAX,_level2 |
PUSH EAX |
LEA EAX,[EBP-56] |
PUSH EAX |
MOV CL,2 |
CALL _down1 |
ADD ESP,8 |
OR EAX,EAX |
JNE _3_106 |
JMP _3_105 |
_3_106: |
LEA EAX,[EBP-56] |
PUSH EAX |
MOV CL,1 |
CALL _fetch |
ADD ESP,4 |
JMP _3_107 |
_3_105: |
LEA EAX,[EBP-56] |
MOV EBX,12 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _3_109 |
JMP _3_108 |
_3_109: |
MOV EAX,108 |
PUSH EAX |
LEA EAX,[EBP-56] |
MOV EBX,16 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
_3_108: |
_3_107: |
MOV EAX,41 |
PUSH EAX |
LEA EAX,[EBP-68] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,12 |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,16 |
ADD EAX,EBX |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],EAX |
POP EBX |
MOV [EBX],EAX |
LEA EAX,[EBP-28] |
MOV EBX,12 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _3_113 |
JMP _3_111 |
_3_113: |
LEA EAX,[EBP-56] |
MOV EBX,12 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _3_114 |
JMP _3_111 |
_3_114: |
MOV EAX,1 |
JMP _3_112 |
_3_111: |
XOR EAX,EAX |
_3_112: |
OR EAX,EAX |
JNE _3_115 |
JMP _3_110 |
_3_115: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,8 |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,4 |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,24 |
ADD EAX,EBX |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],EAX |
POP EBX |
MOV [EBX],EAX |
POP EBX |
MOV [EBX],EAX |
JMP _3_116 |
_3_110: |
LEA EAX,[EBP-56] |
MOV EBX,12 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _3_118 |
JMP _3_117 |
_3_118: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,8 |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP-28] |
MOV EBX,8 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
MOV [EBX],EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,4 |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP-28] |
MOV EBX,4 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
MOV [EBX],EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,24 |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP-28] |
MOV EBX,24 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
MOV [EBX],EAX |
JMP _3_119 |
_3_117: |
LEA EAX,[EBP-28] |
MOV EBX,12 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JE _3_123 |
JMP _3_121 |
_3_123: |
LEA EAX,[EBP-28] |
MOV EBX,8 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-56] |
MOV EBX,8 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
CALL __eq |
OR EAX,EAX |
JE _3_124 |
JMP _3_121 |
_3_124: |
XOR EAX,EAX |
JMP _3_122 |
_3_121: |
MOV EAX,1 |
_3_122: |
OR EAX,EAX |
JNE _3_125 |
JMP _3_120 |
_3_125: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,8 |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP-56] |
MOV EBX,8 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
MOV [EBX],EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,4 |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP-56] |
MOV EBX,4 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
MOV [EBX],EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,24 |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP-56] |
MOV EBX,24 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
MOV [EBX],EAX |
JMP _3_126 |
_3_120: |
MOV EAX,_3_97+4 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
_3_126: |
_3_119: |
_3_116: |
XOR EAX,EAX |
MOV ESP,EBP |
POP EBP |
RET |
_3_97 DB 63,0,58,0,109,105,115,109,97,116 |
DB 99,104,101,100,32,101,120,112,114,101 |
DB 115,115,105,111,110,115,0 |
_level3: |
PUSH EBP |
MOV EBP,ESP |
MOV EAX,_3_127+0 |
PUSH EAX |
MOV EAX,19 |
PUSH EAX |
MOV EAX,1 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV EAX,_level4 |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,6 |
CALL _skim |
ADD ESP,24 |
POP EBP |
RET |
_3_127 DB 124,124,0 |
_level4: |
PUSH EBP |
MOV EBP,ESP |
MOV EAX,_3_128+0 |
PUSH EAX |
MOV EAX,54 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV EAX,1 |
PUSH EAX |
MOV EAX,_level5 |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,6 |
CALL _skim |
ADD ESP,24 |
POP EBP |
RET |
_3_128 DB 38,38,0 |
_level5: |
PUSH EBP |
MOV EBP,ESP |
MOV EAX,_3_129+0 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV EAX,_level6 |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,4 |
CALL _down |
ADD ESP,16 |
POP EBP |
RET |
_3_129 DB 124,0 |
_level6: |
PUSH EBP |
MOV EBP,ESP |
MOV EAX,_3_130+0 |
PUSH EAX |
MOV EAX,1 |
PUSH EAX |
MOV EAX,_level7 |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,4 |
CALL _down |
ADD ESP,16 |
POP EBP |
RET |
_3_130 DB 94,0 |
_level7: |
PUSH EBP |
MOV EBP,ESP |
MOV EAX,_3_131+0 |
PUSH EAX |
MOV EAX,2 |
PUSH EAX |
MOV EAX,_level8 |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,4 |
CALL _down |
ADD ESP,16 |
POP EBP |
RET |
_3_131 DB 38,0 |
_level8: |
PUSH EBP |
MOV EBP,ESP |
MOV EAX,_3_132+0 |
PUSH EAX |
MOV EAX,3 |
PUSH EAX |
MOV EAX,_level9 |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,4 |
CALL _down |
ADD ESP,16 |
POP EBP |
RET |
_3_132 DB 61,61,32,33,61,0 |
_level9: |
PUSH EBP |
MOV EBP,ESP |
MOV EAX,_3_133+0 |
PUSH EAX |
MOV EAX,5 |
PUSH EAX |
MOV EAX,_level10 |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,4 |
CALL _down |
ADD ESP,16 |
POP EBP |
RET |
_3_133 DB 60,61,32,62,61,32,60,32,62,0 |
_level10: |
PUSH EBP |
MOV EBP,ESP |
MOV EAX,_3_134+0 |
PUSH EAX |
MOV EAX,9 |
PUSH EAX |
MOV EAX,_level11 |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,4 |
CALL _down |
ADD ESP,16 |
POP EBP |
RET |
_3_134 DB 62,62,32,60,60,0 |
_level11: |
PUSH EBP |
MOV EBP,ESP |
MOV EAX,_3_135+0 |
PUSH EAX |
MOV EAX,11 |
PUSH EAX |
MOV EAX,_level12 |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,4 |
CALL _down |
ADD ESP,16 |
POP EBP |
RET |
_3_135 DB 43,32,45,0 |
_level12: |
PUSH EBP |
MOV EBP,ESP |
MOV EAX,_3_136+0 |
PUSH EAX |
MOV EAX,13 |
PUSH EAX |
MOV EAX,_level13 |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,4 |
CALL _down |
ADD ESP,16 |
POP EBP |
RET |
_3_136 DB 42,32,47,32,37,0 |
_level13: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-8 |
MOV EAX,_3_137+0 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _3_139 |
JMP _3_138 |
_3_139: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _level13 |
ADD ESP,4 |
OR EAX,EAX |
JE _3_141 |
JMP _3_140 |
_3_141: |
XOR CL,CL |
CALL _needlval |
XOR EAX,EAX |
MOV ESP,EBP |
POP EBP |
RET |
_3_140: |
MOV EAX,68 |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,3 |
CALL _step |
ADD ESP,12 |
XOR EAX,EAX |
MOV ESP,EBP |
POP EBP |
RET |
_3_138: |
MOV EAX,_3_137+3 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _3_144 |
JMP _3_143 |
_3_144: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _level13 |
ADD ESP,4 |
OR EAX,EAX |
JE _3_146 |
JMP _3_145 |
_3_146: |
XOR CL,CL |
CALL _needlval |
XOR EAX,EAX |
MOV ESP,EBP |
POP EBP |
RET |
_3_145: |
MOV EAX,65 |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,3 |
CALL _step |
ADD ESP,12 |
XOR EAX,EAX |
MOV ESP,EBP |
POP EBP |
RET |
_3_143: |
MOV EAX,_3_137+6 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _3_149 |
JMP _3_148 |
_3_149: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _level13 |
ADD ESP,4 |
OR EAX,EAX |
JNE _3_151 |
JMP _3_150 |
_3_151: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _fetch |
ADD ESP,4 |
_3_150: |
MOV EAX,13 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,16 |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,16 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
NOT EAX |
POP EBX |
MOV [EBX],EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,24 |
ADD EAX,EBX |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],EAX |
MOV ESP,EBP |
POP EBP |
RET |
_3_148: |
MOV EAX,_3_137+8 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _3_154 |
JMP _3_153 |
_3_154: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _level13 |
ADD ESP,4 |
OR EAX,EAX |
JNE _3_156 |
JMP _3_155 |
_3_156: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _fetch |
ADD ESP,4 |
_3_155: |
MOV EAX,45 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,16 |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,16 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
CALL __lneg |
POP EBX |
MOV [EBX],EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,24 |
ADD EAX,EBX |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],EAX |
MOV ESP,EBP |
POP EBP |
RET |
_3_153: |
MOV EAX,_3_137+10 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _3_159 |
JMP _3_158 |
_3_159: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _level13 |
ADD ESP,4 |
OR EAX,EAX |
JNE _3_161 |
JMP _3_160 |
_3_161: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _fetch |
ADD ESP,4 |
_3_160: |
MOV EAX,4 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,16 |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,16 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
NEG EAX |
POP EBX |
MOV [EBX],EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,24 |
ADD EAX,EBX |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],EAX |
MOV ESP,EBP |
POP EBP |
RET |
_3_158: |
MOV EAX,_3_137+12 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _3_164 |
JMP _3_163 |
_3_164: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _level13 |
ADD ESP,4 |
OR EAX,EAX |
JNE _3_166 |
JMP _3_165 |
_3_166: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _fetch |
ADD ESP,4 |
_3_165: |
LEA EAX,[EBP-8] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
MOV [EBX],EAX |
OR EAX,EAX |
JNE _3_168 |
JMP _3_167 |
_3_168: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,4 |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP-8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,1 |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
POP EBX |
MOV [EBX],EAX |
JMP _3_169 |
_3_167: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,4 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX,16 |
MOV [EBX],EAX |
_3_169: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,24 |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,8 |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,12 |
ADD EAX,EBX |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],EAX |
POP EBX |
MOV [EBX],EAX |
POP EBX |
MOV [EBX],EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,16 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX,1 |
MOV [EBX],EAX |
MOV EAX,1 |
MOV ESP,EBP |
POP EBP |
RET |
_3_163: |
MOV EAX,_3_137+14 |
PUSH EAX |
MOV EAX,6 |
PUSH EAX |
MOV CL,2 |
CALL _amatch |
ADD ESP,8 |
OR EAX,EAX |
JNE _3_172 |
JMP _3_171 |
_3_172: |
ADD ESP,-24 |
MOV EAX,_3_137+21 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _3_174 |
JMP _3_173 |
_3_174: |
LEA EAX,[EBP-16] |
MOV EBX,EAX |
MOV EAX,1 |
MOV [EBX],EAX |
JMP _3_175 |
_3_173: |
LEA EAX,[EBP-16] |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],EAX |
_3_175: |
LEA EAX,[EBP-12] |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],EAX |
MOV EAX,_3_137+23 |
PUSH EAX |
MOV EAX,8 |
PUSH EAX |
MOV CL,2 |
CALL _amatch |
ADD ESP,8 |
OR EAX,EAX |
JNE _3_177 |
JMP _3_176 |
_3_177: |
LEA EAX,[EBP-12] |
MOV EBX,EAX |
MOV EAX,4 |
MOV [EBX],EAX |
_3_176: |
MOV EAX,_3_137+32 |
PUSH EAX |
MOV EAX,3 |
PUSH EAX |
MOV CL,2 |
CALL _amatch |
ADD ESP,8 |
OR EAX,EAX |
JNE _3_179 |
JMP _3_178 |
_3_179: |
LEA EAX,[EBP-12] |
MOV EBX,EAX |
MOV EAX,4 |
MOV [EBX],EAX |
JMP _3_180 |
_3_178: |
MOV EAX,_3_137+36 |
PUSH EAX |
MOV EAX,4 |
PUSH EAX |
MOV CL,2 |
CALL _amatch |
ADD ESP,8 |
OR EAX,EAX |
JNE _3_182 |
JMP _3_181 |
_3_182: |
LEA EAX,[EBP-12] |
MOV EBX,EAX |
MOV EAX,1 |
MOV [EBX],EAX |
_3_181: |
_3_180: |
LEA EAX,[EBP-12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _3_184 |
JMP _3_183 |
_3_184: |
MOV EAX,_3_137+41 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _3_186 |
JMP _3_185 |
_3_186: |
LEA EAX,[EBP-12] |
MOV EBX,EAX |
MOV EAX,4 |
MOV [EBX],EAX |
_3_185: |
JMP _3_187 |
_3_183: |
LEA EAX,[EBP-32] |
PUSH EAX |
MOV CL,1 |
CALL _symname |
ADD ESP,4 |
OR EAX,EAX |
JNE _3_193 |
JMP _3_189 |
_3_193: |
LEA EAX,[EBP-20] |
PUSH EAX |
LEA EAX,[EBP-32] |
PUSH EAX |
MOV CL,1 |
CALL _findloc |
ADD ESP,4 |
POP EBX |
MOV [EBX],EAX |
OR EAX,EAX |
JE _3_194 |
JMP _3_190 |
_3_194: |
LEA EAX,[EBP-20] |
PUSH EAX |
LEA EAX,[EBP-32] |
PUSH EAX |
MOV CL,1 |
CALL _findglb |
ADD ESP,4 |
POP EBX |
MOV [EBX],EAX |
OR EAX,EAX |
JE _3_195 |
JMP _3_190 |
_3_195: |
XOR EAX,EAX |
JMP _3_191 |
_3_190: |
MOV EAX,1 |
_3_191: |
OR EAX,EAX |
JNE _3_196 |
JMP _3_189 |
_3_196: |
LEA EAX,[EBP-20] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,4 |
CALL __ne |
OR EAX,EAX |
JNE _3_197 |
JMP _3_189 |
_3_197: |
LEA EAX,[EBP-20] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
XOR EAX,EAX |
CALL __ne |
OR EAX,EAX |
JNE _3_198 |
JMP _3_189 |
_3_198: |
MOV EAX,1 |
JMP _3_192 |
_3_189: |
XOR EAX,EAX |
_3_192: |
OR EAX,EAX |
JNE _3_199 |
JMP _3_188 |
_3_199: |
LEA EAX,[EBP-12] |
PUSH EAX |
LEA EAX,[EBP-20] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,3 |
ADD EAX,EBX |
PUSH EAX |
MOV EAX,4 |
PUSH EAX |
MOV CL,2 |
CALL _getint |
ADD ESP,8 |
POP EBX |
MOV [EBX],EAX |
JMP _3_200 |
_3_188: |
LEA EAX,[EBP-12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JE _3_202 |
JMP _3_201 |
_3_202: |
MOV EAX,_3_137+43 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
_3_201: |
_3_200: |
_3_187: |
LEA EAX,[EBP-16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _3_204 |
JMP _3_203 |
_3_204: |
MOV EAX,_3_137+66 |
PUSH EAX |
MOV CL,1 |
CALL _need |
ADD ESP,4 |
_3_203: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,12 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX,16 |
MOV [EBX],EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,16 |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP-12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
MOV [EBX],EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,8 |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,4 |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],EAX |
POP EBX |
MOV [EBX],EAX |
POP EBX |
MOV [EBX],EAX |
XOR EAX,EAX |
MOV ESP,EBP |
POP EBP |
RET |
_3_171: |
MOV EAX,_3_137+68 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _3_207 |
JMP _3_206 |
_3_207: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _level13 |
ADD ESP,4 |
OR EAX,EAX |
JE _3_209 |
JMP _3_208 |
_3_209: |
MOV EAX,_3_137+70 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
XOR EAX,EAX |
MOV ESP,EBP |
POP EBP |
RET |
_3_208: |
LEA EAX,[EBP-8] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
MOV [EBX],EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,8 |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP-8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,1 |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
POP EBX |
MOV [EBX],EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,4 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _3_211 |
JMP _3_210 |
_3_211: |
XOR EAX,EAX |
MOV ESP,EBP |
POP EBP |
RET |
_3_210: |
MOV EAX,25 |
PUSH EAX |
LEA EAX,[EBP-8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,4 |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP-8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,1 |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
POP EBX |
MOV [EBX],EAX |
XOR EAX,EAX |
MOV ESP,EBP |
POP EBP |
RET |
_3_206: |
LEA EAX,[EBP-4] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _level14 |
ADD ESP,4 |
POP EBX |
MOV [EBX],EAX |
MOV EAX,_3_137+86 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _3_214 |
JMP _3_213 |
_3_214: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JE _3_216 |
JMP _3_215 |
_3_216: |
XOR CL,CL |
CALL _needlval |
XOR EAX,EAX |
MOV ESP,EBP |
POP EBP |
RET |
_3_215: |
MOV EAX,68 |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV EAX,65 |
PUSH EAX |
MOV CL,3 |
CALL _step |
ADD ESP,12 |
XOR EAX,EAX |
MOV ESP,EBP |
POP EBP |
RET |
_3_213: |
MOV EAX,_3_137+89 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _3_219 |
JMP _3_218 |
_3_219: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JE _3_221 |
JMP _3_220 |
_3_221: |
XOR CL,CL |
CALL _needlval |
XOR EAX,EAX |
MOV ESP,EBP |
POP EBP |
RET |
_3_220: |
MOV EAX,65 |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV EAX,68 |
PUSH EAX |
MOV CL,3 |
CALL _step |
ADD ESP,12 |
XOR EAX,EAX |
MOV ESP,EBP |
POP EBP |
RET |
_3_218: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV ESP,EBP |
POP EBP |
RET |
_3_222: |
_3_217: |
_3_212: |
_3_205: |
_3_170: |
_3_162: |
_3_157: |
_3_152: |
_3_147: |
_3_142: |
MOV ESP,EBP |
POP EBP |
RET |
_3_137 DB 43,43,0,45,45,0,126,0,33,0 |
DB 45,0,42,0,115,105,122,101,111,102 |
DB 0,40,0,117,110,115,105,103,110,101 |
DB 100,0,105,110,116,0,99,104,97,114 |
DB 0,42,0,109,117,115,116,32,98,101 |
DB 32,111,98,106,101,99,116,32,111,114 |
DB 32,116,121,112,101,0,41,0,38,0 |
DB 105,108,108,101,103,97,108,32,97,100 |
DB 100,114,101,115,115,0,43,43,0,45 |
DB 45,0 |
_level14: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-24 |
LEA EAX,[EBP-4] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _primary |
ADD ESP,4 |
POP EBX |
MOV [EBX],EAX |
LEA EAX,[EBP-16] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
MOV [EBX],EAX |
XOR CL,CL |
CALL _blanks |
MOV EAX,[_ch] |
MOV EBX,EAX |
MOV EAX,91 |
CALL __eq |
OR EAX,EAX |
JE _3_227 |
JMP _3_225 |
_3_227: |
MOV EAX,[_ch] |
MOV EBX,EAX |
MOV EAX,40 |
CALL __eq |
OR EAX,EAX |
JE _3_228 |
JMP _3_225 |
_3_228: |
XOR EAX,EAX |
JMP _3_226 |
_3_225: |
MOV EAX,1 |
_3_226: |
OR EAX,EAX |
JNE _3_229 |
JMP _3_224 |
_3_229: |
ADD ESP,-28 |
LEA EAX,[EBP-52] |
PUSH EAX |
MOV CL,1 |
CALL _null_is |
ADD ESP,4 |
_3_230: |
MOV EAX,_3_223+0 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _3_233 |
JMP _3_232 |
_3_233: |
LEA EAX,[EBP-16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JE _3_235 |
JMP _3_234 |
_3_235: |
MOV EAX,_3_223+2 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
XOR CL,CL |
CALL _skip |
MOV EAX,_3_223+18 |
PUSH EAX |
MOV CL,1 |
CALL _need |
ADD ESP,4 |
XOR EAX,EAX |
MOV ESP,EBP |
POP EBP |
RET |
_3_234: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,8 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _3_237 |
JMP _3_236 |
_3_237: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _3_239 |
JMP _3_238 |
_3_239: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _fetch |
ADD ESP,4 |
_3_238: |
JMP _3_240 |
_3_236: |
MOV EAX,_3_223+20 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],EAX |
_3_240: |
LEA EAX,[EBP-20] |
PUSH EAX |
LEA EAX,[EBP-24] |
PUSH EAX |
MOV CL,2 |
CALL _setstage |
ADD ESP,8 |
LEA EAX,[EBP-52] |
MOV EBX,12 |
ADD EAX,EBX |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],EAX |
XOR EAX,EAX |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV EAX,_level1 |
PUSH EAX |
LEA EAX,[EBP-52] |
PUSH EAX |
LEA EAX,[EBP-52] |
PUSH EAX |
MOV CL,5 |
CALL _down2 |
ADD ESP,20 |
MOV EAX,_3_223+36 |
PUSH EAX |
MOV CL,1 |
CALL _need |
ADD ESP,4 |
LEA EAX,[EBP-52] |
MOV EBX,12 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _3_242 |
JMP _3_241 |
_3_242: |
LEA EAX,[EBP-20] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _clearsta |
ADD ESP,8 |
LEA EAX,[EBP-52] |
MOV EBX,16 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _3_244 |
JMP _3_243 |
_3_244: |
LEA EAX,[EBP-16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,1 |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,2 |
MOV ECX,EAX |
MOV EAX,EBX |
SAR EAX,CL |
MOV EBX,EAX |
MOV EAX,4 |
CALL __eq |
OR EAX,EAX |
JNE _3_246 |
JMP _3_245 |
_3_246: |
MOV EAX,110 |
PUSH EAX |
LEA EAX,[EBP-52] |
MOV EBX,16 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,2 |
MOV ECX,EAX |
MOV EAX,EBX |
SAL EAX,CL |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
JMP _3_247 |
_3_245: |
LEA EAX,[EBP-16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,1 |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,2 |
MOV ECX,EAX |
MOV EAX,EBX |
SAR EAX,CL |
MOV EBX,EAX |
MOV EAX,2 |
CALL __eq |
OR EAX,EAX |
JNE _3_249 |
JMP _3_248 |
_3_249: |
MOV EAX,110 |
PUSH EAX |
LEA EAX,[EBP-52] |
MOV EBX,16 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,1 |
MOV ECX,EAX |
MOV EAX,EBX |
SAL EAX,CL |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
JMP _3_250 |
_3_248: |
MOV EAX,110 |
PUSH EAX |
LEA EAX,[EBP-52] |
MOV EBX,16 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
_3_250: |
_3_247: |
MOV EAX,1 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
_3_243: |
JMP _3_251 |
_3_241: |
LEA EAX,[EBP-16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,1 |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,2 |
MOV ECX,EAX |
MOV EAX,EBX |
SAR EAX,CL |
MOV EBX,EAX |
MOV EAX,4 |
CALL __eq |
OR EAX,EAX |
JNE _3_253 |
JMP _3_252 |
_3_253: |
MOV EAX,14 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
MOV EAX,14 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
JMP _3_254 |
_3_252: |
LEA EAX,[EBP-16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,1 |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,2 |
MOV ECX,EAX |
MOV EAX,EBX |
SAR EAX,CL |
MOV EBX,EAX |
MOV EAX,2 |
CALL __eq |
OR EAX,EAX |
JNE _3_256 |
JMP _3_255 |
_3_256: |
MOV EAX,14 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
_3_255: |
_3_254: |
MOV EAX,1 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
_3_251: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,8 |
ADD EAX,EBX |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,4 |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP-16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,1 |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
POP EBX |
MOV [EBX],EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX,1 |
MOV [EBX],EAX |
JMP _3_257 |
_3_232: |
MOV EAX,_3_223+38 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _3_259 |
JMP _3_258 |
_3_259: |
LEA EAX,[EBP-16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JE _3_261 |
JMP _3_260 |
_3_261: |
XOR EAX,EAX |
PUSH EAX |
MOV CL,1 |
CALL _callfunc |
ADD ESP,4 |
JMP _3_262 |
_3_260: |
LEA EAX,[EBP-16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,4 |
CALL __ne |
OR EAX,EAX |
JNE _3_264 |
JMP _3_263 |
_3_264: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _3_268 |
JMP _3_266 |
_3_268: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,16 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
CALL __lneg |
OR EAX,EAX |
JNE _3_269 |
JMP _3_266 |
_3_269: |
MOV EAX,1 |
JMP _3_267 |
_3_266: |
XOR EAX,EAX |
_3_267: |
OR EAX,EAX |
JNE _3_270 |
JMP _3_265 |
_3_270: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _fetch |
ADD ESP,4 |
_3_265: |
XOR EAX,EAX |
PUSH EAX |
MOV CL,1 |
CALL _callfunc |
ADD ESP,4 |
JMP _3_271 |
_3_263: |
LEA EAX,[EBP-16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _callfunc |
ADD ESP,4 |
_3_271: |
_3_262: |
LEA EAX,[EBP-4] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,12 |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,16 |
ADD EAX,EBX |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],EAX |
POP EBX |
MOV [EBX],EAX |
POP EBX |
MOV [EBX],EAX |
POP EBX |
MOV [EBX],EAX |
JMP _3_272 |
_3_258: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV ESP,EBP |
POP EBP |
RET |
_3_272: |
_3_257: |
JMP _3_230 |
_3_231: |
ADD ESP,28 |
_3_224: |
LEA EAX,[EBP-16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _3_276 |
JMP _3_274 |
_3_276: |
LEA EAX,[EBP-16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,4 |
CALL __eq |
OR EAX,EAX |
JNE _3_277 |
JMP _3_274 |
_3_277: |
MOV EAX,1 |
JMP _3_275 |
_3_274: |
XOR EAX,EAX |
_3_275: |
OR EAX,EAX |
JNE _3_278 |
JMP _3_273 |
_3_278: |
MOV EAX,25 |
PUSH EAX |
LEA EAX,[EBP-16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],EAX |
XOR EAX,EAX |
MOV ESP,EBP |
POP EBP |
RET |
_3_273: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV ESP,EBP |
POP EBP |
RET |
_3_223 DB 91,0,99,97,110,39,116,32,115,117 |
DB 98,115,99,114,105,112,116,0,93,0 |
DB 99,97,110,39,116,32,115,117,98,115 |
DB 99,114,105,112,116,0,93,0,40,0 |
_primary: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-20 |
MOV EAX,_3_279+0 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _3_281 |
JMP _3_280 |
_3_281: |
_3_282: |
LEA EAX,[EBP-20] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _level1 |
ADD ESP,4 |
POP EBX |
MOV [EBX],EAX |
MOV EAX,_3_279+2 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _3_284 |
JMP _3_283 |
_3_284: |
JMP _3_282 |
_3_283: |
MOV EAX,_3_279+4 |
PUSH EAX |
MOV CL,1 |
CALL _need |
ADD ESP,4 |
LEA EAX,[EBP-20] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV ESP,EBP |
POP EBP |
RET |
_3_280: |
XOR EAX,EAX |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV EAX,14 |
PUSH EAX |
MOV CL,3 |
CALL _putint |
ADD ESP,12 |
LEA EAX,[EBP-16] |
PUSH EAX |
MOV CL,1 |
CALL _symname |
ADD ESP,4 |
OR EAX,EAX |
JNE _3_286 |
JMP _3_285 |
_3_286: |
LEA EAX,[EBP-4] |
PUSH EAX |
LEA EAX,[EBP-16] |
PUSH EAX |
MOV CL,1 |
CALL _findloc |
ADD ESP,4 |
POP EBX |
MOV [EBX],EAX |
OR EAX,EAX |
JNE _3_288 |
JMP _3_287 |
_3_288: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
OR EAX,EAX |
JE _3_290 |
JMP _3_289 |
_3_290: |
XOR CL,CL |
CALL _experr |
XOR EAX,EAX |
MOV ESP,EBP |
POP EBP |
RET |
_3_289: |
MOV EAX,58 |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,5 |
ADD EAX,EBX |
MOV EBX,2 |
ADD EAX,EBX |
PUSH EAX |
MOV EAX,4 |
PUSH EAX |
MOV CL,2 |
CALL _getint |
ADD ESP,8 |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
MOV [EBX],EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,4 |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,1 |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
POP EBX |
MOV [EBX],EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,2 |
CALL __eq |
OR EAX,EAX |
JNE _3_292 |
JMP _3_291 |
_3_292: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,8 |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,1 |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
POP EBX |
MOV [EBX],EAX |
XOR EAX,EAX |
MOV ESP,EBP |
POP EBP |
RET |
_3_291: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,3 |
CALL __eq |
OR EAX,EAX |
JNE _3_294 |
JMP _3_293 |
_3_294: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,4 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX,17 |
MOV [EBX],EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,8 |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,1 |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
POP EBX |
MOV [EBX],EAX |
_3_293: |
MOV EAX,1 |
MOV ESP,EBP |
POP EBP |
RET |
_3_287: |
LEA EAX,[EBP-4] |
PUSH EAX |
LEA EAX,[EBP-16] |
PUSH EAX |
MOV CL,1 |
CALL _findglb |
ADD ESP,4 |
POP EBX |
MOV [EBX],EAX |
OR EAX,EAX |
JNE _3_296 |
JMP _3_295 |
_3_296: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
MOV [EBX],EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,4 |
CALL __ne |
OR EAX,EAX |
JNE _3_298 |
JMP _3_297 |
_3_298: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,2 |
CALL __eq |
OR EAX,EAX |
JNE _3_300 |
JMP _3_299 |
_3_300: |
MOV EAX,25 |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,4 |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,8 |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,1 |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
POP EBX |
MOV [EBX],EAX |
POP EBX |
MOV [EBX],EAX |
XOR EAX,EAX |
MOV ESP,EBP |
POP EBP |
RET |
_3_299: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,3 |
CALL __eq |
OR EAX,EAX |
JNE _3_302 |
JMP _3_301 |
_3_302: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,8 |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,1 |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
POP EBX |
MOV [EBX],EAX |
_3_301: |
MOV EAX,1 |
MOV ESP,EBP |
POP EBP |
RET |
_3_297: |
JMP _3_303 |
_3_295: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-16] |
PUSH EAX |
MOV EAX,4 |
PUSH EAX |
MOV EAX,16 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV EAX,_glbptr |
PUSH EAX |
MOV EAX,4 |
PUSH EAX |
MOV CL,7 |
CALL _addsym |
ADD ESP,28 |
POP EBX |
MOV [EBX],EAX |
_3_303: |
XOR EAX,EAX |
MOV ESP,EBP |
POP EBP |
RET |
_3_285: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _constant |
ADD ESP,4 |
OR EAX,EAX |
JE _3_305 |
JMP _3_304 |
_3_305: |
XOR CL,CL |
CALL _experr |
_3_304: |
XOR EAX,EAX |
MOV ESP,EBP |
POP EBP |
RET |
_3_279 DB 40,0,44,0,41,0 |
_experr: |
PUSH EBP |
MOV EBP,ESP |
MOV EAX,_3_306+0 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
MOV EAX,108 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
XOR CL,CL |
CALL _skip |
POP EBP |
RET |
_3_306 DB 105,110,118,97,108,105,100,32,101,120 |
DB 112,114,101,115,115,105,111,110,0 |
_callfunc: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-12 |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],EAX |
XOR CL,CL |
CALL _blanks |
_3_308: |
MOV EAX,[_lptr] |
PUSH EAX |
MOV EAX,_3_307+0 |
PUSH EAX |
MOV CL,2 |
CALL _streq |
ADD ESP,8 |
OR EAX,EAX |
JE _3_310 |
JMP _3_309 |
_3_310: |
XOR CL,CL |
CALL _endst |
OR EAX,EAX |
JNE _3_312 |
JMP _3_311 |
_3_312: |
JMP _3_309 |
_3_311: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _3_314 |
JMP _3_313 |
_3_314: |
LEA EAX,[EBP-8] |
PUSH EAX |
LEA EAX,[EBP-12] |
PUSH EAX |
MOV CL,2 |
CALL _expressi |
ADD ESP,8 |
MOV EAX,60 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
JMP _3_315 |
_3_313: |
MOV EAX,60 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
LEA EAX,[EBP-8] |
PUSH EAX |
LEA EAX,[EBP-12] |
PUSH EAX |
MOV CL,2 |
CALL _expressi |
ADD ESP,8 |
MOV EAX,71 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
_3_315: |
LEA EAX,[EBP-4] |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,4 |
ADD EAX,EBX |
POP EBX |
MOV [EBX],EAX |
MOV EAX,_3_307+2 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JE _3_317 |
JMP _3_316 |
_3_317: |
JMP _3_309 |
_3_316: |
JMP _3_308 |
_3_309: |
MOV EAX,_3_307+4 |
PUSH EAX |
MOV CL,1 |
CALL _need |
ADD ESP,4 |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _3_321 |
JMP _3_319 |
_3_321: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,11 |
ADD EAX,EBX |
PUSH EAX |
MOV EAX,_3_307+6 |
PUSH EAX |
MOV CL,2 |
CALL _streq |
ADD ESP,8 |
MOV EBX,EAX |
XOR EAX,EAX |
CALL __eq |
OR EAX,EAX |
JNE _3_322 |
JMP _3_319 |
_3_322: |
MOV EAX,1 |
JMP _3_320 |
_3_319: |
XOR EAX,EAX |
_3_320: |
OR EAX,EAX |
JNE _3_323 |
JMP _3_318 |
_3_323: |
MOV EAX,5 |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,2 |
MOV ECX,EAX |
MOV EAX,EBX |
SAR EAX,CL |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
_3_318: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _3_325 |
JMP _3_324 |
_3_325: |
MOV EAX,9 |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
JMP _3_326 |
_3_324: |
MOV EAX,8 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
_3_326: |
MOV EAX,2 |
PUSH EAX |
MOV EAX,[_csp] |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
ADD EAX,EBX |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
MOV ESP,EBP |
POP EBP |
RET |
_3_307 DB 41,0,44,0,41,0,67,67,65,82 |
DB 71,67,0 |
_fdouble: |
PUSH EBP |
MOV EBP,ESP |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,1 |
CALL __eq |
OR EAX,EAX |
JE _3_333 |
JMP _3_329 |
_3_333: |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,69 |
CALL __eq |
OR EAX,EAX |
JE _3_334 |
JMP _3_329 |
_3_334: |
XOR EAX,EAX |
JMP _3_330 |
_3_329: |
MOV EAX,1 |
_3_330: |
OR EAX,EAX |
JNE _3_335 |
JMP _3_331 |
_3_335: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,8 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
XOR EAX,EAX |
CALL __eq |
OR EAX,EAX |
JNE _3_336 |
JMP _3_331 |
_3_336: |
MOV EAX,1 |
JMP _3_332 |
_3_331: |
XOR EAX,EAX |
_3_332: |
OR EAX,EAX |
JNE _3_337 |
JMP _3_328 |
_3_337: |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,8 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,2 |
MOV ECX,EAX |
MOV EAX,EBX |
SAR EAX,CL |
JMP _3_340 |
_3_341: |
_3_342: |
XOR EAX,EAX |
POP EBP |
RET |
_3_343: |
MOV EAX,1 |
POP EBP |
RET |
_3_344: |
MOV EAX,2 |
POP EBP |
RET |
JMP _3_339 |
_3_340: |
CALL __switch |
DD _3_342 |
DD 1 |
DD _3_343 |
DD 2 |
DD _3_344 |
DD 4 |
DD 0 |
JMP _3_341 |
_3_339: |
_3_328: |
XOR EAX,EAX |
POP EBP |
RET |
_step: |
PUSH EBP |
MOV EBP,ESP |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _fetch |
ADD ESP,4 |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,8 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _3_348 |
JMP _3_346 |
_3_348: |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,8 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,2 |
MOV ECX,EAX |
MOV EAX,EBX |
SAR EAX,CL |
JMP _3_347 |
_3_346: |
MOV EAX,1 |
_3_347: |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _store |
ADD ESP,4 |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _3_350 |
JMP _3_349 |
_3_350: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,8 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _3_353 |
JMP _3_351 |
_3_353: |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,8 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,2 |
MOV ECX,EAX |
MOV EAX,EBX |
SAR EAX,CL |
JMP _3_352 |
_3_351: |
MOV EAX,1 |
_3_352: |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
_3_349: |
POP EBP |
RET |
_store: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-4 |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,4 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _3_356 |
JMP _3_355 |
_3_356: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,4 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,2 |
MOV ECX,EAX |
MOV EAX,EBX |
SAR EAX,CL |
MOV EBX,EAX |
MOV EAX,1 |
CALL __eq |
OR EAX,EAX |
JNE _3_358 |
JMP _3_357 |
_3_358: |
MOV EAX,62 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
JMP _3_359 |
_3_357: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,4 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,2 |
MOV ECX,EAX |
MOV EAX,EBX |
SAR EAX,CL |
MOV EBX,EAX |
MOV EAX,2 |
CALL __eq |
OR EAX,EAX |
JNE _3_361 |
JMP _3_360 |
_3_361: |
MOV EAX,64 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
JMP _3_362 |
_3_360: |
MOV EAX,115 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
_3_362: |
_3_359: |
JMP _3_363 |
_3_355: |
LEA EAX,[EBP-4] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
MOV [EBX],EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,3 |
CALL __eq |
OR EAX,EAX |
JNE _3_365 |
JMP _3_364 |
_3_365: |
MOV EAX,114 |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
JMP _3_366 |
_3_364: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,1 |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,2 |
MOV ECX,EAX |
MOV EAX,EBX |
SAR EAX,CL |
MOV EBX,EAX |
MOV EAX,1 |
CALL __eq |
OR EAX,EAX |
JNE _3_368 |
JMP _3_367 |
_3_368: |
MOV EAX,61 |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
JMP _3_369 |
_3_367: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,1 |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,2 |
MOV ECX,EAX |
MOV EAX,EBX |
SAR EAX,CL |
MOV EBX,EAX |
MOV EAX,2 |
CALL __eq |
OR EAX,EAX |
JNE _3_371 |
JMP _3_370 |
_3_371: |
MOV EAX,63 |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
JMP _3_372 |
_3_370: |
MOV EAX,114 |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
_3_372: |
_3_369: |
_3_366: |
_3_363: |
MOV ESP,EBP |
POP EBP |
RET |
_fetch: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-4 |
LEA EAX,[EBP-4] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
MOV [EBX],EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,4 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _3_375 |
JMP _3_374 |
_3_375: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,4 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,2 |
MOV ECX,EAX |
MOV EAX,EBX |
SAR EAX,CL |
MOV EBX,EAX |
MOV EAX,4 |
CALL __eq |
OR EAX,EAX |
JNE _3_377 |
JMP _3_376 |
_3_377: |
MOV EAX,109 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
JMP _3_378 |
_3_376: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,4 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,2 |
MOV ECX,EAX |
MOV EAX,EBX |
SAR EAX,CL |
MOV EBX,EAX |
MOV EAX,2 |
CALL __eq |
OR EAX,EAX |
JNE _3_380 |
JMP _3_379 |
_3_380: |
MOV EAX,32 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
JMP _3_381 |
_3_379: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,1 |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,1 |
AND EAX,EBX |
OR EAX,EAX |
JNE _3_383 |
JMP _3_382 |
_3_383: |
MOV EAX,29 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
JMP _3_384 |
_3_382: |
MOV EAX,28 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
_3_384: |
_3_381: |
_3_378: |
JMP _3_385 |
_3_374: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,3 |
CALL __eq |
OR EAX,EAX |
JNE _3_387 |
JMP _3_386 |
_3_387: |
MOV EAX,107 |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
JMP _3_388 |
_3_386: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,1 |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,2 |
MOV ECX,EAX |
MOV EAX,EBX |
SAR EAX,CL |
MOV EBX,EAX |
MOV EAX,4 |
CALL __eq |
OR EAX,EAX |
JNE _3_390 |
JMP _3_389 |
_3_390: |
MOV EAX,107 |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
JMP _3_391 |
_3_389: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,1 |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,2 |
MOV ECX,EAX |
MOV EAX,EBX |
SAR EAX,CL |
MOV EBX,EAX |
MOV EAX,2 |
CALL __eq |
OR EAX,EAX |
JNE _3_393 |
JMP _3_392 |
_3_393: |
MOV EAX,30 |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
JMP _3_394 |
_3_392: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,1 |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,1 |
AND EAX,EBX |
OR EAX,EAX |
JNE _3_396 |
JMP _3_395 |
_3_396: |
MOV EAX,27 |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
JMP _3_397 |
_3_395: |
MOV EAX,26 |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
_3_397: |
_3_394: |
_3_391: |
_3_388: |
_3_385: |
MOV ESP,EBP |
POP EBP |
RET |
_constant: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-4 |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,12 |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,16 |
ADD EAX,EBX |
PUSH EAX |
MOV CL,1 |
CALL _number |
ADD ESP,4 |
POP EBX |
MOV [EBX],EAX |
OR EAX,EAX |
JNE _3_400 |
JMP _3_399 |
_3_400: |
MOV EAX,108 |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,16 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
JMP _3_401 |
_3_399: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,12 |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,16 |
ADD EAX,EBX |
PUSH EAX |
MOV CL,1 |
CALL _chrcon |
ADD ESP,4 |
POP EBX |
MOV [EBX],EAX |
OR EAX,EAX |
JNE _3_403 |
JMP _3_402 |
_3_403: |
MOV EAX,108 |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,16 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
JMP _3_404 |
_3_402: |
LEA EAX,[EBP-4] |
PUSH EAX |
MOV CL,1 |
CALL _string |
ADD ESP,4 |
OR EAX,EAX |
JNE _3_406 |
JMP _3_405 |
_3_406: |
MOV EAX,24 |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
JMP _3_407 |
_3_405: |
XOR EAX,EAX |
MOV ESP,EBP |
POP EBP |
RET |
_3_407: |
_3_404: |
_3_401: |
MOV EAX,1 |
MOV ESP,EBP |
POP EBP |
RET |
_number: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-8 |
LEA EAX,[EBP-4] |
PUSH EAX |
LEA EAX,[EBP-8] |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],EAX |
POP EBX |
MOV [EBX],EAX |
_3_409: |
MOV EAX,_3_408+0 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _3_412 |
JMP _3_411 |
_3_412: |
JMP _3_413 |
_3_411: |
MOV EAX,_3_408+2 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JNE _3_415 |
JMP _3_414 |
_3_415: |
LEA EAX,[EBP-8] |
MOV EBX,EAX |
MOV EAX,1 |
MOV [EBX],EAX |
JMP _3_416 |
_3_414: |
JMP _3_410 |
_3_416: |
_3_413: |
JMP _3_409 |
_3_410: |
MOV EAX,[_ch] |
PUSH EAX |
MOV CL,1 |
CALL _isdigit |
ADD ESP,4 |
OR EAX,EAX |
JE _3_418 |
JMP _3_417 |
_3_418: |
XOR EAX,EAX |
MOV ESP,EBP |
POP EBP |
RET |
_3_417: |
MOV EAX,[_ch] |
MOV EBX,EAX |
MOV EAX,48 |
CALL __eq |
OR EAX,EAX |
JNE _3_420 |
JMP _3_419 |
_3_420: |
_3_421: |
MOV EAX,[_ch] |
MOV EBX,EAX |
MOV EAX,48 |
CALL __eq |
OR EAX,EAX |
JNE _3_423 |
JMP _3_422 |
_3_423: |
XOR CL,CL |
CALL _inbyte |
JMP _3_421 |
_3_422: |
MOV EAX,[_ch] |
PUSH EAX |
MOV CL,1 |
CALL _toupper |
ADD ESP,4 |
MOV EBX,EAX |
MOV EAX,88 |
CALL __eq |
OR EAX,EAX |
JNE _3_425 |
JMP _3_424 |
_3_425: |
XOR CL,CL |
CALL _inbyte |
_3_426: |
MOV EAX,[_ch] |
PUSH EAX |
MOV CL,1 |
CALL _isxdigit |
ADD ESP,4 |
OR EAX,EAX |
JNE _3_428 |
JMP _3_427 |
_3_428: |
MOV EAX,[_ch] |
PUSH EAX |
MOV CL,1 |
CALL _isdigit |
ADD ESP,4 |
OR EAX,EAX |
JNE _3_430 |
JMP _3_429 |
_3_430: |
LEA EAX,[EBP-4] |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,16 |
IMUL EBX |
PUSH EAX |
XOR CL,CL |
CALL _inbyte |
MOV EBX,EAX |
MOV EAX,48 |
XCHG EAX,EBX |
SUB EAX,EBX |
POP EBX |
ADD EAX,EBX |
POP EBX |
MOV [EBX],EAX |
JMP _3_431 |
_3_429: |
LEA EAX,[EBP-4] |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,16 |
IMUL EBX |
MOV EBX,10 |
ADD EAX,EBX |
PUSH EAX |
XOR CL,CL |
CALL _inbyte |
PUSH EAX |
MOV CL,1 |
CALL _toupper |
ADD ESP,4 |
MOV EBX,EAX |
MOV EAX,65 |
XCHG EAX,EBX |
SUB EAX,EBX |
POP EBX |
ADD EAX,EBX |
POP EBX |
MOV [EBX],EAX |
_3_431: |
JMP _3_426 |
_3_427: |
JMP _3_432 |
_3_424: |
_3_433: |
MOV EAX,[_ch] |
MOV EBX,EAX |
MOV EAX,48 |
CALL __ge |
OR EAX,EAX |
JNE _3_437 |
JMP _3_435 |
_3_437: |
MOV EAX,[_ch] |
MOV EBX,EAX |
MOV EAX,55 |
CALL __le |
OR EAX,EAX |
JNE _3_438 |
JMP _3_435 |
_3_438: |
MOV EAX,1 |
JMP _3_436 |
_3_435: |
XOR EAX,EAX |
_3_436: |
OR EAX,EAX |
JNE _3_439 |
JMP _3_434 |
_3_439: |
LEA EAX,[EBP-4] |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,8 |
IMUL EBX |
PUSH EAX |
XOR CL,CL |
CALL _inbyte |
MOV EBX,EAX |
MOV EAX,48 |
XCHG EAX,EBX |
SUB EAX,EBX |
POP EBX |
ADD EAX,EBX |
POP EBX |
MOV [EBX],EAX |
JMP _3_433 |
_3_434: |
_3_432: |
JMP _3_440 |
_3_419: |
_3_441: |
MOV EAX,[_ch] |
PUSH EAX |
MOV CL,1 |
CALL _isdigit |
ADD ESP,4 |
OR EAX,EAX |
JNE _3_443 |
JMP _3_442 |
_3_443: |
LEA EAX,[EBP-4] |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,10 |
IMUL EBX |
PUSH EAX |
XOR CL,CL |
CALL _inbyte |
MOV EBX,EAX |
MOV EAX,48 |
XCHG EAX,EBX |
SUB EAX,EBX |
POP EBX |
ADD EAX,EBX |
POP EBX |
MOV [EBX],EAX |
JMP _3_441 |
_3_442: |
_3_440: |
LEA EAX,[EBP-8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _3_445 |
JMP _3_444 |
_3_445: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
NEG EAX |
POP EBX |
MOV [EBX],EAX |
MOV EAX,16 |
MOV ESP,EBP |
POP EBP |
RET |
_3_444: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
MOV [EBX],EAX |
OR EAX,EAX |
JL _3_447 |
JMP _3_446 |
_3_447: |
MOV EAX,17 |
MOV ESP,EBP |
POP EBP |
RET |
_3_446: |
MOV EAX,16 |
MOV ESP,EBP |
POP EBP |
RET |
_3_448: |
MOV ESP,EBP |
POP EBP |
RET |
_3_408 DB 43,0,45,0 |
_chrcon: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-4 |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],EAX |
MOV EAX,_3_449+0 |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JE _3_451 |
JMP _3_450 |
_3_451: |
XOR EAX,EAX |
MOV ESP,EBP |
POP EBP |
RET |
_3_450: |
_3_452: |
MOV EAX,[_ch] |
MOV EBX,EAX |
MOV EAX,39 |
CALL __ne |
OR EAX,EAX |
JNE _3_454 |
JMP _3_453 |
_3_454: |
LEA EAX,[EBP-4] |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,8 |
MOV ECX,EAX |
MOV EAX,EBX |
SAL EAX,CL |
PUSH EAX |
XOR CL,CL |
CALL _litchar |
MOV EBX,EAX |
MOV EAX,255 |
AND EAX,EBX |
POP EBX |
ADD EAX,EBX |
POP EBX |
MOV [EBX],EAX |
JMP _3_452 |
_3_453: |
XOR CL,CL |
CALL _gch |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
MOV [EBX],EAX |
MOV EAX,16 |
MOV ESP,EBP |
POP EBP |
RET |
_3_449 DB 39,0 |
_string: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-4 |
MOV EAX,_quote |
PUSH EAX |
MOV CL,1 |
CALL _match |
ADD ESP,4 |
OR EAX,EAX |
JE _3_457 |
JMP _3_456 |
_3_457: |
XOR EAX,EAX |
MOV ESP,EBP |
POP EBP |
RET |
_3_456: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV EAX,[_litptr] |
POP EBX |
MOV [EBX],EAX |
_3_458: |
MOV EAX,[_ch] |
MOV EBX,EAX |
MOV EAX,34 |
CALL __ne |
OR EAX,EAX |
JNE _3_460 |
JMP _3_459 |
_3_460: |
MOV EAX,[_ch] |
OR EAX,EAX |
JE _3_462 |
JMP _3_461 |
_3_462: |
JMP _3_459 |
_3_461: |
XOR CL,CL |
CALL _litchar |
PUSH EAX |
MOV EAX,1 |
PUSH EAX |
MOV CL,2 |
CALL _stowlit |
ADD ESP,8 |
JMP _3_458 |
_3_459: |
XOR CL,CL |
CALL _gch |
MOV EAX,[_litq] |
PUSH EAX |
MOV EAX,[_litptr] |
INC EAX |
MOV DWORD [_litptr],EAX |
DEC EAX |
POP EBX |
ADD EAX,EBX |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],AL |
MOV EAX,1 |
MOV ESP,EBP |
POP EBP |
RET |
_stowlit: |
PUSH EBP |
MOV EBP,ESP |
MOV EAX,[_litptr] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX,2999 |
CALL __ge |
OR EAX,EAX |
JNE _3_465 |
JMP _3_464 |
_3_465: |
MOV EAX,_3_463+0 |
PUSH EAX |
MOV CL,1 |
CALL _error |
ADD ESP,4 |
MOV EAX,7 |
PUSH EAX |
MOV CL,1 |
CALL _OS_exit |
ADD ESP,4 |
_3_464: |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV EAX,[_litq] |
PUSH EAX |
MOV EAX,[_litptr] |
POP EBX |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,3 |
CALL _putint |
ADD ESP,12 |
MOV EAX,[_litptr] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
ADD EAX,EBX |
MOV DWORD [_litptr],EAX |
POP EBP |
RET |
_3_463 DB 108,105,116,101,114,97,108,32,113,117 |
DB 101,117,101,32,111,118,101,114,102,108 |
DB 111,119,0 |
_litchar: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-8 |
MOV EAX,[_ch] |
MOV EBX,EAX |
MOV EAX,92 |
CALL __ne |
OR EAX,EAX |
JE _3_470 |
JMP _3_468 |
_3_470: |
MOV EAX,[_nch] |
MOV EBX,EAX |
XOR EAX,EAX |
CALL __eq |
OR EAX,EAX |
JE _3_471 |
JMP _3_468 |
_3_471: |
XOR EAX,EAX |
JMP _3_469 |
_3_468: |
MOV EAX,1 |
_3_469: |
OR EAX,EAX |
JNE _3_472 |
JMP _3_467 |
_3_472: |
XOR CL,CL |
CALL _gch |
MOV ESP,EBP |
POP EBP |
RET |
_3_467: |
XOR CL,CL |
CALL _gch |
MOV EAX,[_ch] |
JMP _3_475 |
_3_476: |
XOR CL,CL |
CALL _gch |
MOV EAX,10 |
MOV ESP,EBP |
POP EBP |
RET |
_3_477: |
XOR CL,CL |
CALL _gch |
MOV EAX,13 |
MOV ESP,EBP |
POP EBP |
RET |
_3_478: |
XOR CL,CL |
CALL _gch |
MOV EAX,9 |
MOV ESP,EBP |
POP EBP |
RET |
_3_479: |
XOR CL,CL |
CALL _gch |
MOV EAX,8 |
MOV ESP,EBP |
POP EBP |
RET |
_3_480: |
XOR CL,CL |
CALL _gch |
MOV EAX,12 |
MOV ESP,EBP |
POP EBP |
RET |
JMP _3_474 |
_3_475: |
CALL __switch |
DD _3_476 |
DD 110 |
DD _3_477 |
DD 114 |
DD _3_478 |
DD 116 |
DD _3_479 |
DD 98 |
DD _3_480 |
DD 102 |
DD 0 |
_3_474: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX,3 |
MOV [EBX],EAX |
LEA EAX,[EBP-8] |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],EAX |
_3_481: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
DEC EAX |
MOV [EBX],EAX |
INC EAX |
MOV EBX,EAX |
XOR EAX,EAX |
CALL __gt |
OR EAX,EAX |
JNE _3_485 |
JMP _3_483 |
_3_485: |
MOV EAX,[_ch] |
MOV EBX,EAX |
MOV EAX,48 |
CALL __ge |
OR EAX,EAX |
JNE _3_486 |
JMP _3_483 |
_3_486: |
MOV EAX,[_ch] |
MOV EBX,EAX |
MOV EAX,55 |
CALL __le |
OR EAX,EAX |
JNE _3_487 |
JMP _3_483 |
_3_487: |
MOV EAX,1 |
JMP _3_484 |
_3_483: |
XOR EAX,EAX |
_3_484: |
OR EAX,EAX |
JNE _3_488 |
JMP _3_482 |
_3_488: |
LEA EAX,[EBP-8] |
PUSH EAX |
LEA EAX,[EBP-8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,3 |
MOV ECX,EAX |
MOV EAX,EBX |
SAL EAX,CL |
PUSH EAX |
XOR CL,CL |
CALL _gch |
POP EBX |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX,48 |
XCHG EAX,EBX |
SUB EAX,EBX |
POP EBX |
MOV [EBX],EAX |
JMP _3_481 |
_3_482: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,2 |
CALL __eq |
OR EAX,EAX |
JNE _3_490 |
JMP _3_489 |
_3_490: |
XOR CL,CL |
CALL _gch |
MOV ESP,EBP |
POP EBP |
RET |
_3_489: |
LEA EAX,[EBP-8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV ESP,EBP |
POP EBP |
RET |
_3_491: |
MOV ESP,EBP |
POP EBP |
RET |
_skim: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-12 |
LEA EAX,[EBP-8] |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],EAX |
_3_493: |
LEA EAX,[EBP-4] |
PUSH EAX |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _down1 |
ADD ESP,8 |
POP EBX |
MOV [EBX],EAX |
LEA EAX,[EBP+28] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _nextop |
ADD ESP,4 |
OR EAX,EAX |
JNE _3_496 |
JMP _3_495 |
_3_496: |
MOV EAX,[_opsize] |
PUSH EAX |
MOV CL,1 |
CALL _bump |
ADD ESP,4 |
LEA EAX,[EBP-8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JE _3_498 |
JMP _3_497 |
_3_498: |
LEA EAX,[EBP-8] |
PUSH EAX |
XOR CL,CL |
CALL _getlabel |
POP EBX |
MOV [EBX],EAX |
_3_497: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+24] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,4 |
CALL _dropout |
ADD ESP,16 |
JMP _3_499 |
_3_495: |
LEA EAX,[EBP-8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _3_501 |
JMP _3_500 |
_3_501: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+24] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,4 |
CALL _dropout |
ADD ESP,16 |
MOV EAX,108 |
PUSH EAX |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
MOV EAX,40 |
PUSH EAX |
LEA EAX,[EBP-12] |
PUSH EAX |
XOR CL,CL |
CALL _getlabel |
POP EBX |
MOV [EBX],EAX |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
MOV EAX,41 |
PUSH EAX |
LEA EAX,[EBP-8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
MOV EAX,108 |
PUSH EAX |
LEA EAX,[EBP+20] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
MOV EAX,41 |
PUSH EAX |
LEA EAX,[EBP-12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,4 |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,8 |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,12 |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,16 |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,24 |
ADD EAX,EBX |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],EAX |
POP EBX |
MOV [EBX],EAX |
POP EBX |
MOV [EBX],EAX |
POP EBX |
MOV [EBX],EAX |
POP EBX |
MOV [EBX],EAX |
XOR EAX,EAX |
MOV ESP,EBP |
POP EBP |
RET |
_3_500: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV ESP,EBP |
POP EBP |
RET |
_3_502: |
_3_499: |
JMP _3_493 |
_3_494: |
MOV ESP,EBP |
POP EBP |
RET |
_dropout: |
PUSH EBP |
MOV EBP,ESP |
LEA EAX,[EBP+20] |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _3_505 |
JMP _3_504 |
_3_505: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _fetch |
ADD ESP,4 |
JMP _3_506 |
_3_504: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,12 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _3_508 |
JMP _3_507 |
_3_508: |
MOV EAX,108 |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,16 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
_3_507: |
_3_506: |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
POP EBP |
RET |
_down: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-4 |
LEA EAX,[EBP-4] |
PUSH EAX |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _down1 |
ADD ESP,8 |
POP EBX |
MOV [EBX],EAX |
LEA EAX,[EBP+20] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _nextop |
ADD ESP,4 |
OR EAX,EAX |
JE _3_511 |
JMP _3_510 |
_3_511: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV ESP,EBP |
POP EBP |
RET |
_3_510: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _3_513 |
JMP _3_512 |
_3_513: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _fetch |
ADD ESP,4 |
_3_512: |
_3_514: |
LEA EAX,[EBP+20] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _nextop |
ADD ESP,4 |
OR EAX,EAX |
JNE _3_517 |
JMP _3_516 |
_3_517: |
ADD ESP,-28 |
LEA EAX,[EBP-32] |
PUSH EAX |
MOV CL,1 |
CALL _null_is |
ADD ESP,4 |
MOV EAX,[_opsize] |
PUSH EAX |
MOV CL,1 |
CALL _bump |
ADD ESP,4 |
MOV EAX,[_opindex] |
PUSH EAX |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
ADD EAX,EBX |
MOV DWORD [_opindex],EAX |
MOV EAX,_op |
PUSH EAX |
MOV EAX,[_opindex] |
POP EBX |
SHL EAX,1 |
SHL EAX,1 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV EAX,_op2 |
PUSH EAX |
MOV EAX,[_opindex] |
POP EBX |
SHL EAX,1 |
SHL EAX,1 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP-32] |
PUSH EAX |
MOV CL,5 |
CALL _down2 |
ADD ESP,20 |
ADD ESP,28 |
JMP _3_518 |
_3_516: |
XOR EAX,EAX |
MOV ESP,EBP |
POP EBP |
RET |
_3_518: |
JMP _3_514 |
_3_515: |
MOV ESP,EBP |
POP EBP |
RET |
_down1: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-12 |
LEA EAX,[EBP-8] |
PUSH EAX |
LEA EAX,[EBP-12] |
PUSH EAX |
MOV CL,2 |
CALL _setstage |
ADD ESP,8 |
LEA EAX,[EBP-4] |
PUSH EAX |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
XCHG EAX,EBX |
PUSH EBX |
CALL EAX |
ADD ESP,4 |
POP EBX |
MOV [EBX],EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,12 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _3_521 |
JMP _3_520 |
_3_521: |
LEA EAX,[EBP-8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _clearsta |
ADD ESP,8 |
_3_520: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV ESP,EBP |
POP EBP |
RET |
_down2: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-16 |
LEA EAX,[EBP-4] |
PUSH EAX |
LEA EAX,[EBP-8] |
PUSH EAX |
MOV CL,2 |
CALL _setstage |
ADD ESP,8 |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,24 |
ADD EAX,EBX |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],EAX |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,12 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _3_524 |
JMP _3_523 |
_3_524: |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _down1 |
ADD ESP,8 |
OR EAX,EAX |
JNE _3_526 |
JMP _3_525 |
_3_526: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _fetch |
ADD ESP,4 |
_3_525: |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,16 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JE _3_528 |
JMP _3_527 |
_3_528: |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,24 |
ADD EAX,EBX |
PUSH EAX |
MOV EAX,[_snext] |
POP EBX |
MOV [EBX],EAX |
_3_527: |
MOV EAX,33 |
PUSH EAX |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,16 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+24] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,3 |
CALL _fdouble |
ADD ESP,12 |
POP EBX |
MOV ECX,EAX |
MOV EAX,EBX |
SAL EAX,CL |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
JMP _3_529 |
_3_523: |
MOV EAX,60 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,2 |
CALL _down1 |
ADD ESP,8 |
OR EAX,EAX |
JNE _3_531 |
JMP _3_530 |
_3_531: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _fetch |
ADD ESP,4 |
_3_530: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,12 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _3_533 |
JMP _3_532 |
_3_533: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,16 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JE _3_535 |
JMP _3_534 |
_3_535: |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,24 |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP-8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
MOV [EBX],EAX |
_3_534: |
MOV EAX,[_csp] |
MOV EBX,4 |
ADD EAX,EBX |
MOV DWORD [_csp],EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _clearsta |
ADD ESP,8 |
LEA EAX,[EBP+24] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,1 |
CALL __eq |
OR EAX,EAX |
JNE _3_537 |
JMP _3_536 |
_3_537: |
MOV EAX,110 |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,16 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+24] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,3 |
CALL _fdouble |
ADD ESP,12 |
POP EBX |
MOV ECX,EAX |
MOV EAX,EBX |
SAL EAX,CL |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
JMP _3_538 |
_3_536: |
MOV EAX,51 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
MOV EAX,108 |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,16 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+24] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,3 |
CALL _fdouble |
ADD ESP,12 |
POP EBX |
MOV ECX,EAX |
MOV EAX,EBX |
SAL EAX,CL |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
_3_538: |
JMP _3_539 |
_3_532: |
MOV EAX,59 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
LEA EAX,[EBP-16] |
PUSH EAX |
LEA EAX,[EBP+24] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,3 |
CALL _fdouble |
ADD ESP,12 |
POP EBX |
MOV [EBX],EAX |
OR EAX,EAX |
JNE _3_541 |
JMP _3_540 |
_3_541: |
MOV EAX,14 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
LEA EAX,[EBP-16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,1 |
CALL __gt |
OR EAX,EAX |
JNE _3_543 |
JMP _3_542 |
_3_543: |
MOV EAX,14 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
_3_542: |
_3_540: |
LEA EAX,[EBP-16] |
PUSH EAX |
LEA EAX,[EBP+24] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,3 |
CALL _fdouble |
ADD ESP,12 |
POP EBX |
MOV [EBX],EAX |
OR EAX,EAX |
JNE _3_545 |
JMP _3_544 |
_3_545: |
MOV EAX,15 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
LEA EAX,[EBP-16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,1 |
CALL __gt |
OR EAX,EAX |
JNE _3_547 |
JMP _3_546 |
_3_547: |
MOV EAX,15 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
_3_546: |
_3_544: |
_3_539: |
_3_529: |
LEA EAX,[EBP+24] |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _3_549 |
JMP _3_548 |
_3_549: |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _nosign |
ADD ESP,4 |
OR EAX,EAX |
JE _3_553 |
JMP _3_551 |
_3_553: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,1 |
CALL _nosign |
ADD ESP,4 |
OR EAX,EAX |
JE _3_554 |
JMP _3_551 |
_3_554: |
XOR EAX,EAX |
JMP _3_552 |
_3_551: |
MOV EAX,1 |
_3_552: |
OR EAX,EAX |
JNE _3_555 |
JMP _3_550 |
_3_555: |
LEA EAX,[EBP+24] |
PUSH EAX |
LEA EAX,[EBP+20] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
MOV [EBX],EAX |
_3_550: |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,12 |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,12 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,12 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
AND EAX,EBX |
POP EBX |
MOV [EBX],EAX |
OR EAX,EAX |
JNE _3_557 |
JMP _3_556 |
_3_557: |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,16 |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,16 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+24] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,16 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,3 |
CALL _calc |
ADD ESP,12 |
POP EBX |
MOV [EBX],EAX |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _clearsta |
ADD ESP,8 |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,12 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,17 |
CALL __eq |
OR EAX,EAX |
JNE _3_559 |
JMP _3_558 |
_3_559: |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,12 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX,17 |
MOV [EBX],EAX |
_3_558: |
JMP _3_560 |
_3_556: |
LEA EAX,[EBP+24] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
LEA EAX,[EBP+24] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,69 |
CALL __eq |
OR EAX,EAX |
JNE _3_564 |
JMP _3_562 |
_3_564: |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,8 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,2 |
MOV ECX,EAX |
MOV EAX,EBX |
SAR EAX,CL |
MOV EBX,EAX |
MOV EAX,2 |
CALL __eq |
OR EAX,EAX |
JNE _3_565 |
JMP _3_562 |
_3_565: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,8 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,2 |
MOV ECX,EAX |
MOV EAX,EBX |
SAR EAX,CL |
MOV EBX,EAX |
MOV EAX,2 |
CALL __eq |
OR EAX,EAX |
JNE _3_566 |
JMP _3_562 |
_3_566: |
MOV EAX,1 |
JMP _3_563 |
_3_562: |
XOR EAX,EAX |
_3_563: |
OR EAX,EAX |
JNE _3_567 |
JMP _3_561 |
_3_567: |
MOV EAX,70 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
MOV EAX,31 |
PUSH EAX |
MOV EAX,1 |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
MOV EAX,7 |
PUSH EAX |
XOR EAX,EAX |
PUSH EAX |
MOV CL,2 |
CALL _gen |
ADD ESP,8 |
_3_561: |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,20 |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP+24] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
MOV [EBX],EAX |
_3_560: |
LEA EAX,[EBP+24] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,69 |
CALL __eq |
OR EAX,EAX |
JE _3_571 |
JMP _3_569 |
_3_571: |
LEA EAX,[EBP+24] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,1 |
CALL __eq |
OR EAX,EAX |
JE _3_572 |
JMP _3_569 |
_3_572: |
XOR EAX,EAX |
JMP _3_570 |
_3_569: |
MOV EAX,1 |
_3_570: |
OR EAX,EAX |
JNE _3_573 |
JMP _3_568 |
_3_573: |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,8 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _3_577 |
JMP _3_575 |
_3_577: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,8 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _3_578 |
JMP _3_575 |
_3_578: |
MOV EAX,1 |
JMP _3_576 |
_3_575: |
XOR EAX,EAX |
_3_576: |
OR EAX,EAX |
JNE _3_579 |
JMP _3_574 |
_3_579: |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,8 |
ADD EAX,EBX |
MOV EBX,EAX |
XOR EAX,EAX |
MOV [EBX],EAX |
JMP _3_580 |
_3_574: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,8 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JNE _3_582 |
JMP _3_581 |
_3_582: |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
MOV [EBX],EAX |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,4 |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,4 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
MOV [EBX],EAX |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,8 |
ADD EAX,EBX |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,8 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
MOV [EBX],EAX |
_3_581: |
_3_580: |
_3_568: |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
XOR EAX,EAX |
CALL __eq |
OR EAX,EAX |
JE _3_588 |
JMP _3_584 |
_3_588: |
LEA EAX,[EBP-12] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
MOV [EBX],EAX |
OR EAX,EAX |
JNE _3_589 |
JMP _3_585 |
_3_589: |
LEA EAX,[EBP-12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,1 |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,1 |
AND EAX,EBX |
OR EAX,EAX |
JNE _3_590 |
JMP _3_585 |
_3_590: |
MOV EAX,1 |
JMP _3_586 |
_3_585: |
XOR EAX,EAX |
_3_586: |
OR EAX,EAX |
JE _3_591 |
JMP _3_584 |
_3_591: |
XOR EAX,EAX |
JMP _3_587 |
_3_584: |
MOV EAX,1 |
_3_587: |
OR EAX,EAX |
JNE _3_592 |
JMP _3_583 |
_3_592: |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
MOV [EBX],EAX |
_3_583: |
_3_548: |
MOV ESP,EBP |
POP EBP |
RET |
_nosign: |
PUSH EBP |
MOV EBP,ESP |
ADD ESP,-4 |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,8 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
OR EAX,EAX |
JE _3_599 |
JMP _3_595 |
_3_599: |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,12 |
ADD EAX,EBX |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX,17 |
CALL __eq |
OR EAX,EAX |
JE _3_600 |
JMP _3_595 |
_3_600: |
LEA EAX,[EBP-4] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
MOV [EBX],EAX |
OR EAX,EAX |
JNE _3_601 |
JMP _3_596 |
_3_601: |
LEA EAX,[EBP-4] |
MOV EBX,EAX |
MOV EAX, [EBX] |
MOV EBX,1 |
ADD EAX,EBX |
MOV EBX,EAX |
MOVSX EAX,BYTE [EBX] |
MOV EBX,EAX |
MOV EAX,1 |
AND EAX,EBX |
OR EAX,EAX |
JNE _3_602 |
JMP _3_596 |
_3_602: |
MOV EAX,1 |
JMP _3_597 |
_3_596: |
XOR EAX,EAX |
_3_597: |
OR EAX,EAX |
JE _3_603 |
JMP _3_595 |
_3_603: |
XOR EAX,EAX |
JMP _3_598 |
_3_595: |
MOV EAX,1 |
_3_598: |
OR EAX,EAX |
JNE _3_604 |
JMP _3_594 |
_3_604: |
MOV EAX,1 |
MOV ESP,EBP |
POP EBP |
RET |
_3_594: |
XOR EAX,EAX |
MOV ESP,EBP |
POP EBP |
RET |
_calc: |
PUSH EBP |
MOV EBP,ESP |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
JMP _3_608 |
_3_609: |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
ADD EAX,EBX |
POP EBP |
RET |
_3_610: |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
XCHG EAX,EBX |
SUB EAX,EBX |
POP EBP |
RET |
_3_611: |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
IMUL EBX |
POP EBP |
RET |
_3_612: |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
XCHG EAX,EBX |
CDQ |
IDIV EBX |
POP EBP |
RET |
_3_613: |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
XCHG EAX,EBX |
CDQ |
IDIV EBX |
MOV EAX,EDX |
POP EBP |
RET |
_3_614: |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
CALL __eq |
POP EBP |
RET |
_3_615: |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
CALL __ne |
POP EBP |
RET |
_3_616: |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
CALL __le |
POP EBP |
RET |
_3_617: |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
CALL __ge |
POP EBP |
RET |
_3_618: |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
CALL __lt |
POP EBP |
RET |
_3_619: |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
CALL __gt |
POP EBP |
RET |
_3_620: |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
AND EAX,EBX |
POP EBP |
RET |
_3_621: |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
OR EAX,EBX |
POP EBP |
RET |
_3_622: |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
XOR EAX,EBX |
POP EBP |
RET |
_3_623: |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
MOV ECX,EAX |
MOV EAX,EBX |
SAR EAX,CL |
POP EBP |
RET |
_3_624: |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
MOV ECX,EAX |
MOV EAX,EBX |
SAL EAX,CL |
POP EBP |
RET |
JMP _3_607 |
_3_608: |
CALL __switch |
DD _3_609 |
DD 1 |
DD _3_610 |
DD 69 |
DD _3_611 |
DD 52 |
DD _3_612 |
DD 16 |
DD _3_613 |
DD 49 |
DD _3_614 |
DD 20 |
DD _3_615 |
DD 55 |
DD _3_616 |
DD 43 |
DD _3_617 |
DD 22 |
DD _3_618 |
DD 47 |
DD _3_619 |
DD 35 |
DD _3_620 |
DD 3 |
DD _3_621 |
DD 57 |
DD _3_622 |
DD 73 |
DD _3_623 |
DD 7 |
DD _3_624 |
DD 6 |
DD 0 |
_3_607: |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
MOV CL,3 |
CALL _calc2 |
ADD ESP,12 |
POP EBP |
RET |
_calc2: |
PUSH EBP |
MOV EBP,ESP |
LEA EAX,[EBP+12] |
MOV EBX,EAX |
MOV EAX, [EBX] |
JMP _3_628 |
_3_629: |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
MUL EBX |
POP EBP |
RET |
_3_630: |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
XCHG EAX,EBX |
XOR EDX,EDX |
DIV EBX |
POP EBP |
RET |
_3_631: |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
XCHG EAX,EBX |
XOR EDX,EDX |
DIV EBX |
MOV EAX,EDX |
POP EBP |
RET |
_3_632: |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
CALL __ule |
POP EBP |
RET |
_3_633: |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
CALL __uge |
POP EBP |
RET |
_3_634: |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
CALL __ult |
POP EBP |
RET |
_3_635: |
LEA EAX,[EBP+16] |
MOV EBX,EAX |
MOV EAX, [EBX] |
PUSH EAX |
LEA EAX,[EBP+8] |
MOV EBX,EAX |
MOV EAX, [EBX] |
POP EBX |
CALL __ugt |
POP EBP |
RET |
JMP _3_627 |
_3_628: |
CALL __switch |
DD _3_629 |
DD 53 |
DD _3_630 |
DD 17 |
DD _3_631 |
DD 50 |
DD _3_632 |
DD 44 |
DD _3_633 |
DD 23 |
DD _3_634 |
DD 48 |
DD _3_635 |
DD 36 |
DD 0 |
_3_627: |
XOR EAX,EAX |
POP EBP |
RET |
/programs/develop/scc/OSFUNC.ASM |
---|
1,4 → 1,4 |
include "macros.inc" |
include "MACROS.INC" |
; |
; OS function implementation |
; SmallC for KolibriOS |
/programs/develop/scc/Tupfile.lua |
---|
0,0 → 1,2 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("SCC.ASM", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "SCC") |
/programs/develop/sdk/trunk/pixlib/Tupfile.lua |
---|
0,0 → 1,2 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.foreach_rule("*.asm", "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "%B") |
/programs/develop/sdk/trunk/sound/src/Tupfile.lua |
---|
0,0 → 1,7 |
if tup.getconfig("NO_FASM") ~= "" or (tup.getconfig("NO_MSVC") ~= "" and tup.getconfig("NO_GCC") ~= "") then return end |
OBJS = tup.foreach_rule("*.asm", "fasm %f %o", "%B.obj") |
if tup.getconfig("NO_GCC") == "" |
then tup.rule(OBJS, "kos32-ar rcs %o %f", "sound.lib") |
else tup.rule(OBJS, "link.exe /lib /out:%o %f", "sound.lib") |
end |
/programs/develop/str_double/trunk/Tupfile.lua |
---|
0,0 → 1,3 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"}) |
tup.rule({"str_double.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "str_double") |
/programs/develop/tinypad/trunk/Tupfile.lua |
---|
0,0 → 1,3 |
if tup.getconfig("NO_FASM") ~= "" then return end |
tup.rule("echo lang fix " .. ((tup.getconfig("LANG") == "") and "en" or tup.getconfig("LANG")) .. " > lang.inc", {"lang.inc"}) |
tup.rule({"tinypad.asm", extra_inputs = {"lang.inc"}}, "fasm %f %o " .. tup.getconfig("KPACK_CMD"), "tinypad") |